2002-01-17 Dietmar Maurer <dietmar@ximian.com>

	* metadata.c (mono_type_stack_size): impl.

	* class.c (mono_class_get_field): impl. memberref token

	* jit.c (mono_analyze_stack): use LDIND_REF/STIND_REF

	* jit.c (main): install the trampoline before we start to create
	objects.

svn path=/trunk/mono/; revision=2015

diff --git a/mono/jit/ChangeLog b/mono/jit/ChangeLog
index c82310cdd4570e5f6e0ff41372c427cf96409d5c..2b65c332c117062181982fe8fc5b94c5a35f8dbd 100644 (file)
--- a/mono/jit/ChangeLog
+++ b/mono/jit/ChangeLog
@@ -1,3 +1,7 @@
+2002-01-17  Dietmar Maurer  <dietmar@ximian.com>
+
+       * jit.c (mono_analyze_stack): use LDIND_REF/STIND_REF
+
 2002-01-16  Dietmar Maurer  <dietmar@ximian.com>
 
        * jit.c (main): install the trampoline before we start to create

diff --git a/mono/jit/TODO b/mono/jit/TODO
index deae2f38ff2ff9f7ecb31ad71675aa92b4c59099..ac820a41a4336495bfff1fffb98ce680a80e3047 100644 (file)
--- a/mono/jit/TODO
+++ b/mono/jit/TODO
@@ -1,12 +1,10 @@
+* correctly align value types on the stack and in arrays
 * impl. marshalling attributes for pinvoke
 * raise exceptions everywhere
-* implement all those CONV and CONV_OVF opcodes
-* exceptions: handle exceptions inside unmanaged code
 * exceptions: save/restore floating point state
 * implement all floating point instruction in x86.brg, we also need to check
   the floating branch instruction - some of them seems to be wrong, we need to
   write better tests for that.
-* correctly align value types on the stack and in arrays
 * document the functions and variables in the JIT 
 * implement a register set for FP registers (just count register usage on x86)
 

diff --git a/mono/jit/emit-x86.c b/mono/jit/emit-x86.c
index 0a49df82e19b3a81773a16684a929392355c4f3a..01922aeed65e18a591b72f666219dd0f1d14fc78 100644 (file)
--- a/mono/jit/emit-x86.c
+++ b/mono/jit/emit-x86.c
@@ -100,6 +100,7 @@ enter_method (MonoMethod *method, gpointer ebp)
                        o = *((MonoObject **)ebp);
                        if (o) {
                                class = o->klass;
+                   
                                if (class == mono_defaults.string_class) {
                                        printf ("[STRING:%p:%s], ", o, mono_string_to_utf8 ((MonoString *)o));
                                } else if (class == mono_defaults.int32_class) {

diff --git a/mono/jit/jit.c b/mono/jit/jit.c
index 6bbf67ef755290ff8e5b4cfe8317110aac7c98e9..bf192706c2c0c76ada31176f29e2f2d06df743d2 100644 (file)
--- a/mono/jit/jit.c
+++ b/mono/jit/jit.c
@@ -48,7 +48,7 @@ static char *opcode_names [] = {
 };
 #undef OPDEF
 
-#define SET_VARINFO(vi,t,k,o,s)  do { vi.type=t; vi.kind=k; vi.offset=o; vi.size=s; } while (0)
+#define SET_VARINFO(vi,t,k,o,s) do { vi.type=t; vi.kind=k; vi.offset=o; vi.size=s; } while (0)
 
 #define MAKE_CJUMP(name)                                                      \
 case CEE_##name:                                                              \
@@ -83,11 +83,11 @@ case CEE_##name: {                                                            \
        break;                                                                \
 }
 
-#define MAKE_CMP(name)                                                        \
-case CEE_##name: {                                                            \
+#define MAKE_CMP(cname)                                                       \
+case CEE_##cname: {                                                           \
        ++ip;                                                                 \
        sp -= 2;                                                              \
-       t1 = mono_ctree_new (mp, MB_TERM_##name, sp [0], sp [1]);             \
+       t1 = mono_ctree_new (mp, MB_TERM_##cname, sp [0], sp [1]);            \
         g_assert (sp [0]->svt == sp [1]->svt);                                \
        PUSH_TREE (t1, VAL_I32);                                              \
        break;                                                                \
@@ -102,7 +102,7 @@ case CEE_##name: {                                                            \
         t1->svt = sp [0]->svt;                                                \
         t1 = mono_store_tree (cfg, -1, t1, &t2);                              \
         g_assert (t1);                                                        \
-        ADD_TREE (t1, cli_addr);                                                        \
+        ADD_TREE (t1, cli_addr);                                              \
        PUSH_TREE (t2, t2->svt);                                              \
        break;                                                                \
 }
@@ -289,8 +289,9 @@ map_store_svt_type (int svt)
 {
        switch (svt) {
        case VAL_I32:
-       case VAL_POINTER:
                return MB_TERM_STIND_I4;
+       case VAL_POINTER:
+               return MB_TERM_STIND_REF;
        case VAL_I64:
                return MB_TERM_STIND_I8;
        case VAL_DOUBLE:
@@ -313,7 +314,7 @@ static int
 map_stind_type (MonoType *type)
 {
        if (type->byref) 
-               return MB_TERM_STIND_I4;
+               return MB_TERM_STIND_REF;
 
        switch (type->type) {
        case MONO_TYPE_I1:
@@ -327,13 +328,14 @@ map_stind_type (MonoType *type)
        case MONO_TYPE_I:
        case MONO_TYPE_I4:
        case MONO_TYPE_U4:
+               return MB_TERM_STIND_I4;        
        case MONO_TYPE_CLASS:
        case MONO_TYPE_OBJECT:
        case MONO_TYPE_STRING:
        case MONO_TYPE_PTR:
        case MONO_TYPE_SZARRAY:
        case MONO_TYPE_ARRAY:    
-               return MB_TERM_STIND_I4;
+               return MB_TERM_STIND_REF;
        case MONO_TYPE_I8:
        case MONO_TYPE_U8:
                return MB_TERM_STIND_I8;
@@ -359,7 +361,7 @@ static int
 map_starg_type (MonoType *type)
 {
        if (type->byref) 
-               return MB_TERM_STIND_I4;
+               return MB_TERM_STIND_REF;
 
        switch (type->type) {
        case MONO_TYPE_I1:
@@ -371,13 +373,14 @@ map_starg_type (MonoType *type)
        case MONO_TYPE_I:
        case MONO_TYPE_I4:
        case MONO_TYPE_U4:
+               return MB_TERM_STIND_I4;
        case MONO_TYPE_CLASS:
        case MONO_TYPE_OBJECT:
        case MONO_TYPE_STRING:
        case MONO_TYPE_PTR:
        case MONO_TYPE_SZARRAY:
        case MONO_TYPE_ARRAY:    
-               return MB_TERM_STIND_I4;
+               return MB_TERM_STIND_REF;
        case MONO_TYPE_I8:
        case MONO_TYPE_U8:
                return MB_TERM_STIND_I8;
@@ -458,7 +461,7 @@ map_ldind_type (MonoType *type, MonoValueType *svt)
 {
        if (type->byref) {
                *svt = VAL_POINTER;
-               return MB_TERM_LDIND_I4;
+               return MB_TERM_LDIND_REF;
        }
 
        switch (type->type) {
@@ -490,7 +493,7 @@ map_ldind_type (MonoType *type, MonoValueType *svt)
        case MONO_TYPE_SZARRAY:
        case MONO_TYPE_ARRAY:    
                *svt = VAL_POINTER;
-               return MB_TERM_LDIND_U4;
+               return MB_TERM_LDIND_REF;
        case MONO_TYPE_I8:
        case MONO_TYPE_U8:
                *svt = VAL_I64;
@@ -522,7 +525,7 @@ map_ldarg_type (MonoType *type, MonoValueType *svt)
 {
        if (type->byref) {
                *svt = VAL_POINTER;
-               return MB_TERM_LDIND_I4;
+               return MB_TERM_LDIND_REF;
        }
 
        switch (type->type) {
@@ -726,11 +729,18 @@ arch_allocate_var (MonoFlowGraph *cfg, int size, int align, MonoValueKind kind,
        case MONO_ARGVAR: {
                int arg_start = 8 + cfg->has_vtarg*4;
 
+               /* fixme: we need to align stack values somehow
+               int opos, cpos, padding;
+               opos = cpos = arg_start + cfg->args_size;
+               cpos += align - 1;
+               cpos &= ~(align - 1);
+               padding = cpos - opos;
+               cfg->args_size += padding;
+               */
+
                SET_VARINFO (vi, type, kind, cfg->args_size + arg_start, size);
                g_array_append_val (cfg->varinfo, vi);
-
-               cfg->args_size += align - 1;
-               cfg->args_size &= ~(align - 1);
+               
                cfg->args_size += size;
                break;
        }
@@ -903,6 +913,12 @@ ctree_create_dup (MonoMemPool *mp, MBTree *s)
                t = mono_ctree_new (mp, MB_TERM_LDIND_I2, t, NULL);
                t->svt = VAL_I32;
                break;
+       case MB_TERM_STIND_REF:
+       case MB_TERM_LDIND_REF:
+               t = ctree_dup_address (mp, s->left);
+               t = mono_ctree_new (mp, MB_TERM_LDIND_REF, t, NULL);
+               t->svt = VAL_POINTER;
+               break;
        case MB_TERM_STIND_I4:
        case MB_TERM_LDIND_I4:
                t = ctree_dup_address (mp, s->left);
@@ -954,6 +970,8 @@ mono_store_tree (MonoFlowGraph *cfg, int slot, MBTree *s, MBTree **dup)
        case MB_TERM_LDIND_I2:
        case MB_TERM_STIND_I4:
        case MB_TERM_LDIND_I4:
+       case MB_TERM_STIND_REF:
+       case MB_TERM_LDIND_REF:
        case MB_TERM_STIND_I8:
        case MB_TERM_LDIND_I8:
        case MB_TERM_STIND_R4:
@@ -1631,11 +1649,7 @@ mono_analyze_stack (MonoFlowGraph *cfg)
                int align, size;
 
                for (i = 0; i < signature->param_count; ++i) {
-                       size = mono_type_size (signature->params [i], &align);
-                       if (size < 4) {
-                               size = 4; 
-                               align = 4;
-                       }
+                       size = mono_type_stack_size (signature->params [i], &align);
                        arch_allocate_var (cfg, size, align, MONO_ARGVAR, VAL_UNKNOWN);
                }
        }
@@ -2122,17 +2136,19 @@ mono_analyze_stack (MonoFlowGraph *cfg)
                                g_assert (t1);
                                ADD_TREE (t1, cli_addr);
                        }
+                       
+                       args_size += sizeof (gpointer); /* this argument */             
 
                        for (i = csig->param_count - 1; i >= 0; i--) {
                                MonoType *type = cm->signature->params [i];
+
+                               size = mono_type_stack_size (type, &align);
                                t1 = mono_ctree_new (mp, map_arg_type (type, FALSE), arg_sp [i], NULL); 
-                               size = mono_type_size (type, &align);
                                t1->data.i = size;
                                ADD_TREE (t1, cli_addr);
-                               args_size += (size + 3) & ~3;
+                               args_size += size;
                        }
 
-                       args_size += sizeof (gpointer); /* this argument */             
                        ci->args_size = args_size;
 
                        if (newarr) {
@@ -2156,7 +2172,7 @@ mono_analyze_stack (MonoFlowGraph *cfg)
 
                                t2 = mono_ctree_new_leaf (mp, MB_TERM_ADDR_G);
                                t2->data.p = (char *)cm + G_STRUCT_OFFSET (MonoMethod, addr);
-                               t2 = mono_ctree_new (mp, MB_TERM_LDIND_I4, t2, NULL);
+                               t2 = mono_ctree_new (mp, MB_TERM_LDIND_REF, t2, NULL);
 
                                t1 = mono_ctree_new (mp, map_call_type (csig->ret, &svt), this, t2);
                                t1->data.p = ci;
@@ -2229,11 +2245,10 @@ mono_analyze_stack (MonoFlowGraph *cfg)
                        for (i = nargs - 1; i >= 0; i--) {
                                MonoType *type = cm->signature->params [i];
                                t1 = mono_ctree_new (mp, map_arg_type (type, pinvoke), arg_sp [i], NULL);
-                               size = mono_type_size (type, &align);
+                               size = mono_type_stack_size (type, &align);
                                t1->data.i = size;
                                ADD_TREE (t1, cli_addr);
-                               args_size += (size + 3) & ~3;
-
+                               args_size += size;
                                // fixme: align value type arguments  to 8 byte boundary on the stack
                        }
 
@@ -2306,7 +2321,7 @@ mono_analyze_stack (MonoFlowGraph *cfg)
                                
                                        t2 = mono_ctree_new_leaf (mp, MB_TERM_ADDR_G);
                                        t2->data.p = (char *)cm + G_STRUCT_OFFSET (MonoMethod, addr);
-                                       t2 = mono_ctree_new (mp, MB_TERM_LDIND_I4, t2, NULL);
+                                       t2 = mono_ctree_new (mp, MB_TERM_LDIND_REF, t2, NULL);
                                }
 
                                t1 = mono_ctree_new (mp, map_call_type (csig->ret, &svt), this, t2);
@@ -2350,7 +2365,7 @@ mono_analyze_stack (MonoFlowGraph *cfg)
                        t1 = mono_ctree_new (mp, MB_TERM_ISINST, *sp, NULL);
                        t1->data.klass = c;
                        
-                       PUSH_TREE (t1, VAL_I32);
+                       PUSH_TREE (t1, VAL_POINTER);
 
                        ip += 4;
                        break;
@@ -2367,7 +2382,7 @@ mono_analyze_stack (MonoFlowGraph *cfg)
                        t1 = mono_ctree_new (mp, MB_TERM_CASTCLASS, *sp, NULL);
                        t1->data.klass = c;
                        
-                       PUSH_TREE (t1, VAL_I32);
+                       PUSH_TREE (t1, VAL_POINTER);
 
                        ip += 4;
                        break;
@@ -2409,7 +2424,7 @@ mono_analyze_stack (MonoFlowGraph *cfg)
                        ++ip;
                        t1 = mono_ctree_new_leaf (mp, MB_TERM_CONST_I4);
                        t1->data.i = 0;
-                       PUSH_TREE (t1, VAL_I32);
+                       PUSH_TREE (t1, VAL_POINTER);
                        break;
                }
                case CEE_LDC_I8: {
@@ -2528,7 +2543,7 @@ mono_analyze_stack (MonoFlowGraph *cfg)
                MAKE_LDIND (LDIND_U2,  MB_TERM_LDIND_U2, VAL_I32)
                MAKE_LDIND (LDIND_I,   MB_TERM_LDIND_I4, VAL_I32)
                MAKE_LDIND (LDIND_I4,  MB_TERM_LDIND_I4, VAL_I32)
-               MAKE_LDIND (LDIND_REF, MB_TERM_LDIND_U4, VAL_I32)
+               MAKE_LDIND (LDIND_REF, MB_TERM_LDIND_REF, VAL_POINTER)
                MAKE_LDIND (LDIND_U4,  MB_TERM_LDIND_U4, VAL_I32)
                MAKE_LDIND (LDIND_I8,  MB_TERM_LDIND_I8, VAL_I64)
                MAKE_LDIND (LDIND_R4,  MB_TERM_LDIND_R4, VAL_DOUBLE)
@@ -2541,7 +2556,7 @@ mono_analyze_stack (MonoFlowGraph *cfg)
                MAKE_STIND (STIND_I8,  MB_TERM_STIND_I8)
                MAKE_STIND (STIND_R4,  MB_TERM_STIND_R4)
                MAKE_STIND (STIND_R8,  MB_TERM_STIND_R8)
-               MAKE_STIND (STIND_REF, MB_TERM_STIND_I4)
+               MAKE_STIND (STIND_REF, MB_TERM_STIND_REF)
 
                MAKE_LDELEM (LDELEM_I1,  MB_TERM_LDIND_I1, VAL_I32, 1)
                MAKE_LDELEM (LDELEM_U1,  MB_TERM_LDIND_U1, VAL_I32, 1)
@@ -2549,7 +2564,7 @@ mono_analyze_stack (MonoFlowGraph *cfg)
                MAKE_LDELEM (LDELEM_U2,  MB_TERM_LDIND_U2, VAL_I32, 2)
                MAKE_LDELEM (LDELEM_I,   MB_TERM_LDIND_I4, VAL_I32, 4)
                MAKE_LDELEM (LDELEM_I4,  MB_TERM_LDIND_I4, VAL_I32, 4)
-               MAKE_LDELEM (LDELEM_REF, MB_TERM_LDIND_U4, VAL_I32, 4)
+               MAKE_LDELEM (LDELEM_REF, MB_TERM_LDIND_REF, VAL_POINTER, sizeof (gpointer))
                MAKE_LDELEM (LDELEM_U4,  MB_TERM_LDIND_U4, VAL_I32, 4)
                MAKE_LDELEM (LDELEM_I8,  MB_TERM_LDIND_I8, VAL_I64, 8)
                MAKE_LDELEM (LDELEM_R4,  MB_TERM_LDIND_R4, VAL_DOUBLE, 4)
@@ -2559,7 +2574,7 @@ mono_analyze_stack (MonoFlowGraph *cfg)
                MAKE_STELEM (STELEM_I2,  MB_TERM_STIND_I2, 2)
                MAKE_STELEM (STELEM_I4,  MB_TERM_STIND_I4, 4)
                MAKE_STELEM (STELEM_I,   MB_TERM_STIND_I4, 4)
-               MAKE_STELEM (STELEM_REF, MB_TERM_STIND_I4, 4)
+               MAKE_STELEM (STELEM_REF, MB_TERM_STIND_REF, sizeof (gpointer))
                MAKE_STELEM (STELEM_I8,  MB_TERM_STIND_I8, 8)
                MAKE_STELEM (STELEM_R4,  MB_TERM_STIND_R4, 4)
                MAKE_STELEM (STELEM_R8,  MB_TERM_STIND_R8, 8)
@@ -3041,7 +3056,7 @@ mono_analyze_stack (MonoFlowGraph *cfg)
 
                                t1 = mono_ctree_new_leaf (mp, MB_TERM_ADDR_G);
                                t1->data.p = (char *)cm + G_STRUCT_OFFSET (MonoMethod, addr);
-                               t1 = mono_ctree_new (mp, MB_TERM_LDIND_I4, t1, NULL);
+                               t1 = mono_ctree_new (mp, MB_TERM_LDIND_REF, t1, NULL);
                                PUSH_TREE (t1, VAL_POINTER);
                                break;
                        }

diff --git a/mono/jit/x86.brg b/mono/jit/x86.brg
index 210ca3ca480c5a783f9b4fc598cb9b32bcc79352..1c265c8091099095886c639b44a7f20346f46b39 100644 (file)
--- a/mono/jit/x86.brg
+++ b/mono/jit/x86.brg
@@ -160,9 +160,9 @@ void *MEMCOPY (void *dest, const void *src, size_t n);
 
 # constatnts
 %term CONST_I4 CONST_I8 CONST_R4 CONST_R8
-%term LDIND_I1 LDIND_U1 LDIND_I2 LDIND_U2 LDIND_I4 LDIND_I8 LDIND_R4 LDIND_R8
+%term LDIND_I1 LDIND_U1 LDIND_I2 LDIND_U2 LDIND_I4 LDIND_REF LDIND_I8 LDIND_R4 LDIND_R8
 %term LDIND_U4 LDIND_OBJ
-%term STIND_I1 STIND_I2 STIND_I4 STIND_I8 STIND_R4 STIND_R8 STIND_OBJ
+%term STIND_I1 STIND_I2 STIND_I4 STIND_REF STIND_I8 STIND_R4 STIND_R8 STIND_OBJ
 %term ADDR_L ADDR_G ARG_I4 ARG_I8 ARG_R4 ARG_R8 ARG_OBJ ARG_STRING CALL_I4 CALL_I8 CALL_R8 CALL_VOID
 %term BREAK SWITCH BR RET_VOID RET RET_OBJ ENDFINALLY
 %term ADD ADD_OVF ADD_OVF_UN SUB SUB_OVF SUB_OVF_UN MUL MUL_OVF MUL_OVF_UN 
@@ -385,6 +385,32 @@ stmt: STIND_I4 (addr, reg) {
        }
 }
 
+stmt: STIND_REF (addr, reg) {
+       PRINT_REG ("STIND_REF", tree->right->reg1);
+
+       switch (tree->left->data.ainfo.amode) {
+
+       case AMImmediate:
+               x86_mov_mem_reg (s->code, tree->left->data.ainfo.offset, tree->right->reg1, 4);
+               break;
+               
+       case AMBase:
+               x86_mov_membase_reg (s->code, tree->left->data.ainfo.basereg, 
+                                    tree->left->data.ainfo.offset, tree->right->reg1, 4);
+               break;          
+       case AMIndex:
+               x86_mov_memindex_reg (s->code, X86_NOBASEREG, tree->left->data.ainfo.offset,
+                                     tree->left->data.ainfo.indexreg, tree->left->data.ainfo.shift,
+                                     tree->right->reg1, 4);
+               break;          
+       case AMBaseIndex:
+               x86_mov_memindex_reg (s->code, tree->left->data.ainfo.basereg, tree->left->data.ainfo.offset,
+                                     tree->left->data.ainfo.indexreg, tree->left->data.ainfo.shift,
+                                     tree->right->reg1, 4);
+               break;          
+       }
+}
+
 stmt: STIND_I1 (addr, reg) {
        PRINT_REG ("STIND_I1", tree->right->reg1);
 
@@ -464,6 +490,33 @@ reg: LDIND_I4 (addr) {
        PRINT_REG ("LDIND_I4", tree->reg1);
 }
 
+reg: LDIND_REF (addr) {
+
+       switch (tree->left->data.ainfo.amode) {
+
+       case AMImmediate:
+               x86_mov_reg_mem (s->code, tree->reg1, tree->left->data.ainfo.offset, 4);
+               break;
+
+       case AMBase:
+               x86_mov_reg_membase (s->code, tree->reg1, tree->left->data.ainfo.basereg, 
+                                    tree->left->data.ainfo.offset, 4);
+               break;          
+       case AMIndex:
+               x86_mov_reg_memindex (s->code, tree->reg1, X86_NOBASEREG, tree->left->data.ainfo.offset,
+                                     tree->left->data.ainfo.indexreg, tree->left->data.ainfo.shift, 4);
+               break;          
+       case AMBaseIndex:
+               x86_mov_reg_memindex (s->code, tree->reg1, tree->left->data.ainfo.basereg, 
+                                     tree->left->data.ainfo.offset, tree->left->data.ainfo.indexreg, 
+                                     tree->left->data.ainfo.shift, 4);
+               break;          
+       }
+
+
+       PRINT_REG ("LDIND_REF", tree->reg1);
+}
+
 reg: LDIND_I1 (addr) {
        switch (tree->left->data.ainfo.amode) {
 
@@ -1536,7 +1589,7 @@ reg: CALL_I4 (this, reg) {
        g_assert (tree->reg1 == X86_EAX);
 }
 
-reg: CALL_I4 (this, LDIND_I4 (ADDR_G)) {
+reg: CALL_I4 (this, LDIND_REF (ADDR_G)) {
        MethodCallInfo *ci = tree->data.ci;
        int lreg = tree->left->reg1;
        int treg = X86_EAX;
@@ -1632,7 +1685,7 @@ reg: CALL_I4 (this, VFUNC_ADDR) {
        g_assert (tree->reg1 == X86_EAX);
 }
 
-stmt: CALL_VOID (this, LDIND_I4 (ADDR_G)) {
+stmt: CALL_VOID (this, LDIND_REF (ADDR_G)) {
        MethodCallInfo *ci = tree->data.ci;
        int lreg = tree->left->reg1;
        int treg = X86_EAX;
@@ -2150,7 +2203,7 @@ lreg: REM_UN (lreg, lreg) {
                  tree->reg2 == X86_EDX);
 }
 
-lreg: CALL_I8 (this, LDIND_I4 (ADDR_G)) {
+lreg: CALL_I8 (this, LDIND_REF (ADDR_G)) {
        MethodCallInfo *ci = tree->data.ci;
        int lreg = tree->left->reg1;
        int treg = X86_EAX;
@@ -2657,7 +2710,7 @@ stmt: BLE_UN (freg, freg) {
        x86_branch32 (s->code, X86_CC_NE, tree->data.bb->addr - offset, FALSE);
 }
 
-freg: CALL_R8 (this, LDIND_I4 (ADDR_G)) {
+freg: CALL_R8 (this, LDIND_REF (ADDR_G)) {
        MethodCallInfo *ci = tree->data.ci;
        int lreg = tree->left->reg1;
        int treg = X86_EAX;

diff --git a/mono/metadata/ChangeLog b/mono/metadata/ChangeLog
index a5f9aebd39cb71a7a68c15bb174e593e56682056..5b83daae3dba19ca250b557f229084668a8b954a 100644 (file)
--- a/mono/metadata/ChangeLog
+++ b/mono/metadata/ChangeLog
@@ -1,3 +1,9 @@
+2002-01-17  Dietmar Maurer  <dietmar@ximian.com>
+
+       * metadata.c (mono_type_stack_size): impl.
+
+       * class.c (mono_class_get_field): impl. memberref token
+
 2002-01-16 Veronica De Santis <veron78@@interfree.it>
 
         * icall.h : Added the internal calls mapping for CreateMutex_internal

diff --git a/mono/metadata/class.c b/mono/metadata/class.c
index b96425ee74f2da22a32a1dbbb052ec8ee7d2018a..0bdc3df0781aee7b056b4ac4e651e7d7425f32b1 100644 (file)
--- a/mono/metadata/class.c
+++ b/mono/metadata/class.c
@@ -978,8 +978,15 @@ mono_class_get_field (MonoClass *class, guint32 field_token)
 {
        int idx = mono_metadata_token_index (field_token);
 
-       if (mono_metadata_token_code (field_token) == MONO_TOKEN_MEMBER_REF)
-               g_error ("Unsupported Field Token is a MemberRef, implement me");
+       if (mono_metadata_token_code (field_token) == MONO_TOKEN_MEMBER_REF) {
+               MonoClass *refclass;
+               MonoClassField *field;
+
+               field = mono_field_from_memberref (class->image, field_token, &refclass);
+               g_assert (field != NULL);
+
+               return field;
+       }
 
        g_assert (mono_metadata_token_code (field_token) == MONO_TOKEN_FIELD_DEF);
 

diff --git a/mono/metadata/icall.c b/mono/metadata/icall.c
index 98ab544d0420cca25e9e298cadcc7b5e663280ae..b1efddc869fa7fc20fecdc533aad870ea588b6ac 100644 (file)
--- a/mono/metadata/icall.c
+++ b/mono/metadata/icall.c
@@ -247,6 +247,11 @@ ves_icall_type_is_subtype_of (MonoReflectionType *type, MonoReflectionType *c)
        MonoClass *klass;
        MonoClass *klassc;
 
+       g_assert (type != NULL);
+       
+       if (!c) /* FIXME: dont know what do do here */
+               return 0;
+
        while (!type->type) { /* FIXME: hack for TypeBuilder */
                MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)type;
                type = tb->parent;

diff --git a/mono/metadata/metadata.c b/mono/metadata/metadata.c
index 2ec589c1b0fe6151f2582dae31e1929c3292ac47..42a3a834ba194b23e9e426cfcb072ea661acbe27 100644 (file)
--- a/mono/metadata/metadata.c
+++ b/mono/metadata/metadata.c
@@ -1843,6 +1843,72 @@ mono_type_size (MonoType *t, gint *align)
        return 0;
 }
 
+/*
+ * mono_type_stack_size:
+ * @t: the type to return the size it uses on the stack
+ *
+ * Returns: the number of bytes required to hold an instance of this
+ * type on the runtime stack
+ */
+int
+mono_type_stack_size (MonoType *t, gint *align)
+{
+       g_assert (t != NULL);
+
+       if (t->byref) {
+               *align = __alignof__(gpointer);
+               return sizeof (gpointer);
+       }
+
+       switch (t->type){
+       case MONO_TYPE_BOOLEAN:
+       case MONO_TYPE_CHAR:
+       case MONO_TYPE_I1:
+       case MONO_TYPE_U1:
+       case MONO_TYPE_I2:
+       case MONO_TYPE_U2:
+       case MONO_TYPE_I4:
+       case MONO_TYPE_U4:
+               *align = __alignof__(gint32);
+               return 4;
+       case MONO_TYPE_R4:
+               *align = __alignof__(float);
+               return 4;
+               
+       case MONO_TYPE_I8:
+       case MONO_TYPE_U8:
+               *align = __alignof__(gint64);
+       case MONO_TYPE_R8:
+               *align = __alignof__(double);
+               return 8;
+               
+       case MONO_TYPE_I:
+       case MONO_TYPE_U:
+               *align = __alignof__(gpointer);
+               return sizeof (gpointer);
+               
+       case MONO_TYPE_VALUETYPE: {
+               guint32 size;
+
+               size = mono_class_value_size (t->data.klass, align);
+               return size;
+       }
+       case MONO_TYPE_STRING:
+       case MONO_TYPE_OBJECT:
+       case MONO_TYPE_CLASS:
+       case MONO_TYPE_SZARRAY:
+       case MONO_TYPE_PTR:
+       case MONO_TYPE_FNPTR:
+       case MONO_TYPE_ARRAY:
+       case MONO_TYPE_TYPEDBYREF: /* we may want to use a struct {MonoType* type, void *data } instead ...*/
+               *align = __alignof__(gpointer);
+               return sizeof (gpointer);
+       default:
+               g_error ("type 0x%02x unknown", t->type);
+       }
+       return 0;
+}
+
 gboolean
 mono_metadata_type_equal (MonoType *t1, MonoType *t2)
 {

diff --git a/mono/metadata/metadata.h b/mono/metadata/metadata.h
index 921d06d739605067a1fe884e68206ac5c02d5b9c..2b6434dfc04d355f3349cd8bf8995ded39489f20 100644 (file)
--- a/mono/metadata/metadata.h
+++ b/mono/metadata/metadata.h
@@ -244,6 +244,9 @@ MonoType      *mono_metadata_parse_field_type  (MonoMetadata      *m,
 void           mono_metadata_free_type         (MonoType        *type);
 int            mono_type_size                  (MonoType        *type, 
                                                int             *alignment);
+int            mono_type_stack_size            (MonoType        *type, 
+                                               int             *alignment);
+
 gboolean       mono_metadata_type_equal        (MonoType *t1, MonoType *t2);
 
 MonoMethodSignature  *mono_metadata_parse_method_signature (MonoMetadata            *m,