dotgnu-pnet-commits
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[dotgnu-pnet-commits] pnet ./ChangeLog engine/jitc.c engine/jitc_call...


From: Klaus Treichel
Subject: [dotgnu-pnet-commits] pnet ./ChangeLog engine/jitc.c engine/jitc_call...
Date: Sat, 04 Mar 2006 14:36:08 +0000

CVSROOT:        /cvsroot/dotgnu-pnet
Module name:    pnet
Branch:         
Changes by:     Klaus Treichel <address@hidden> 06/03/04 14:36:08

Modified files:
        .              : ChangeLog 
        engine         : jitc.c jitc_call.c jitc_obj.c layout.c 
                         lib_array.c verify.c 

Log message:
        2006-03-04  Klaus Treichel  <address@hidden>
        
        * engine/jitc.c, engine/jitc_obj.c: Fix the TypedRef so that the layout 
of
        the ILTypedRefstructure is used. Fix jit type resolution of
        IL_META_ELEMTYPE_TYPEDREF.
        
        * engine/jitc_call.c: Fix the constructor call for multidimensional 
arrays.
        
        * engine/layout.c: Use IL_META_ELEMTYPE_PTR instead of
        IL_META_ELEMTYPE_TYPEDREF for pointer/reference types (what was 
obviously a
        bug).
        
        * engine/lib_array.c: use varargs for multidimensional arrays when the 
jit
        is used.
        
        * engine/verify.c: Do the stackrefresh before the label is inserted 
when the
        jit is used.

CVSWeb URLs:
http://cvs.savannah.gnu.org/viewcvs/dotgnu-pnet/pnet/ChangeLog.diff?tr1=1.3299&tr2=1.3300&r1=text&r2=text
http://cvs.savannah.gnu.org/viewcvs/dotgnu-pnet/pnet/engine/jitc.c.diff?tr1=1.21&tr2=1.22&r1=text&r2=text
http://cvs.savannah.gnu.org/viewcvs/dotgnu-pnet/pnet/engine/jitc_call.c.diff?tr1=1.9&tr2=1.10&r1=text&r2=text
http://cvs.savannah.gnu.org/viewcvs/dotgnu-pnet/pnet/engine/jitc_obj.c.diff?tr1=1.11&tr2=1.12&r1=text&r2=text
http://cvs.savannah.gnu.org/viewcvs/dotgnu-pnet/pnet/engine/layout.c.diff?tr1=1.42&tr2=1.43&r1=text&r2=text
http://cvs.savannah.gnu.org/viewcvs/dotgnu-pnet/pnet/engine/lib_array.c.diff?tr1=1.29&tr2=1.30&r1=text&r2=text
http://cvs.savannah.gnu.org/viewcvs/dotgnu-pnet/pnet/engine/verify.c.diff?tr1=1.47&tr2=1.48&r1=text&r2=text

Patches:
Index: pnet/ChangeLog
diff -u pnet/ChangeLog:1.3299 pnet/ChangeLog:1.3300
--- pnet/ChangeLog:1.3299       Mon Feb 27 15:51:19 2006
+++ pnet/ChangeLog      Sat Mar  4 14:36:08 2006
@@ -1,3 +1,21 @@
+2006-03-04  Klaus Treichel  <address@hidden>
+
+       * engine/jitc.c, engine/jitc_obj.c: Fix the TypedRef so that the layout 
of
+       the ILTypedRefstructure is used. Fix jit type resolution of
+       IL_META_ELEMTYPE_TYPEDREF.
+
+       * engine/jitc_call.c: Fix the constructor call for multidimensional 
arrays.
+
+       * engine/layout.c: Use IL_META_ELEMTYPE_PTR instead of
+       IL_META_ELEMTYPE_TYPEDREF for pointer/reference types (what was 
obviously a
+       bug).
+
+       * engine/lib_array.c: use varargs for multidimensional arrays when the 
jit
+       is used.
+
+       * engine/verify.c: Do the stackrefresh before the label is inserted 
when the
+       jit is used.
+
 2006-02-27  Aleksey Demakov  <address@hidden>
 
        * engine/jitc_conv.c (JITCoder_Conv): fix a typo.
Index: pnet/engine/jitc.c
diff -u pnet/engine/jitc.c:1.21 pnet/engine/jitc.c:1.22
--- pnet/engine/jitc.c:1.21     Mon Feb 27 15:51:19 2006
+++ pnet/engine/jitc.c  Sat Mar  4 14:36:08 2006
@@ -90,6 +90,7 @@
 static struct _tagILJitTypes _ILJitType_U4;
 static struct _tagILJitTypes _ILJitType_U8;
 static struct _tagILJitTypes _ILJitType_VPTR;
+static struct _tagILJitTypes _ILJitType_TYPEDREF;
 
 /*
  * Jit type for typed references.
@@ -1065,7 +1066,6 @@
 {
        ILJitType       returnType;
        ILJitType       args[3];
-       ILJitType       fields[2];
 
        /* Initialize libjit */
        jit_init();
@@ -1103,12 +1103,14 @@
 
 
        // Initialize the TypedRef type in its jit representation.      
-       fields[0] = _IL_JIT_TYPE_VPTR;
-       fields[1] = _IL_JIT_TYPE_VPTR;
-       if(!(_ILJitTypedRef = jit_type_create_struct(fields, 2, 1)))
+       if(!(_ILJitTypedRef = jit_type_create_struct(0, 0, 0)))
        {
                return 0;
        }
+       jit_type_set_size_and_alignment(_ILJitTypedRef,
+                                                                       
sizeof(ILTypedRef),
+                                                                       
_IL_ALIGN_FOR_TYPE(void_p));
+       _ILJitTypesInitBase(&_ILJitType_TYPEDREF, _ILJitTypedRef);
 
        /* Initialize the native method signatures. */
        args[0] = _IL_JIT_TYPE_VPTR;
@@ -1670,7 +1672,7 @@
                else
                {
                        ILType *ownerType = ILType_FromClass(info);
-                       ILType *synType = type = ILClassGetSynType(info);
+                       ILType *synType = ILClassGetSynType(info);
 
                        if(!(synType && ILType_IsArray(synType)) && 
!ILTypeIsStringClass(ownerType))
                        {
@@ -2091,6 +2093,16 @@
                }
                case IL_META_ELEMTYPE_TYPEDBYREF:
                {
+                       return &_ILJitType_TYPEDREF;
+               }
+               case IL_META_ELEMTYPE_PTR:
+               case IL_META_ELEMTYPE_STRING:
+               case IL_META_ELEMTYPE_BYREF:
+               case IL_META_ELEMTYPE_ARRAY:
+               case IL_META_ELEMTYPE_FNPTR:
+               case IL_META_ELEMTYPE_OBJECT:
+               case IL_META_ELEMTYPE_SZARRAY:
+               {
                        return &_ILJitType_VPTR;
                }
        }
Index: pnet/engine/jitc_call.c
diff -u pnet/engine/jitc_call.c:1.9 pnet/engine/jitc_call.c:1.10
--- pnet/engine/jitc_call.c:1.9 Sun Feb 19 18:31:11 2006
+++ pnet/engine/jitc_call.c     Sat Mar  4 14:36:08 2006
@@ -293,6 +293,9 @@
                                                          ILMethod *methodInfo)
 {
        ILJITCoder *jitCoder = _ILCoderToILJITCoder(coder);
+       ILClass *classInfo;
+       ILType *type;
+       ILType *synType;
        ILJitFunction jitFunction = ILJitFunctionFromILMethod(methodInfo);
        int argCount = info->numBaseArgs + info->numVarArgs;
        ILJitValue jitParams[argCount + 2];
@@ -338,13 +341,17 @@
        methodName = _ILJitFunctionGetMethodName(jitFunction);
 #endif
 #endif
+       classInfo = ILMethod_Owner(methodInfo);
+       type = ILType_FromClass(classInfo);
+       synType = ILClassGetSynType(classInfo);
+
        /* Output a call to the static constructor */
        _ILJitCallStaticConstructor(jitCoder, ILMethod_Owner(methodInfo), 1);
 
        /* Output a call to the constructor */
        jitParams[0] = jit_value_get_param(jitCoder->jitFunction, 0); // we add 
the current function thread as the first param
                
-       if(_ILJitIsStringClass(ILMethod_Owner(methodInfo)))
+       if((synType && ILType_IsArray(synType)) || ILTypeIsStringClass(type))
        {
                _ILJitFillArguments(jitCoder, &(jitParams[1]), info);
                // call the constructor with jitParams as input
Index: pnet/engine/jitc_obj.c
diff -u pnet/engine/jitc_obj.c:1.11 pnet/engine/jitc_obj.c:1.12
--- pnet/engine/jitc_obj.c:1.11 Sun Feb 19 18:31:11 2006
+++ pnet/engine/jitc_obj.c      Sat Mar  4 14:36:08 2006
@@ -96,15 +96,13 @@
                                                                          
ILClass *classInfo)
 {
        jit_label_t label1 = jit_label_undefined;
-       jit_nuint typeOffset = jit_type_get_offset(_ILJitTypedRef, 0);
-       jit_nuint valueOffset = jit_type_get_offset(_ILJitTypedRef, 1);
        ILJitValue info = jit_value_create_nint_constant(jitCoder->jitFunction,
                                                                                
                 _IL_JIT_TYPE_VPTR,
                                                                                
                 (jit_nint)classInfo);
        ILJitValue ptr = jit_insn_address_of(jitCoder->jitFunction, refValue);;
        ILJitValue type = jit_insn_load_relative(jitCoder->jitFunction,
                                                                                
         ptr,
-                                                                               
         typeOffset,
+                                                                               
         offsetof(ILTypedRef, type),
                                                                                
         _IL_JIT_TYPE_VPTR);
        ILJitValue temp;
        ILJitValue valuePtr;
@@ -114,7 +112,8 @@
        /* TODO: Throw System.InvalidCastException */
 
        jit_insn_label(jitCoder->jitFunction, &label1);
-       valuePtr = jit_insn_load_relative(jitCoder->jitFunction, ptr, 
valueOffset,
+       valuePtr = jit_insn_load_relative(jitCoder->jitFunction, ptr,
+                                                                         
offsetof(ILTypedRef, value),
                                                                          
_IL_JIT_TYPE_VPTR);
        return valuePtr;
 }
@@ -675,8 +674,6 @@
 static void JITCoder_MakeTypedRef(ILCoder *coder, ILClass *classInfo)
 {
        ILJITCoder *jitCoder = _ILCoderToILJITCoder(coder);
-       jit_nuint typeOffset = jit_type_get_offset(_ILJitTypedRef, 0);
-       jit_nuint valueOffset = jit_type_get_offset(_ILJitTypedRef, 1);
        /* Create the structure */
        ILJitValue value = jit_value_create(jitCoder->jitFunction, 
_ILJitTypedRef);
        ILJitValue ptr = jit_insn_address_of(jitCoder->jitFunction, value);
@@ -685,9 +682,11 @@
                                                                                
                                  _IL_JIT_TYPE_VPTR,
                                                                                
                                  (jit_nint)classInfo);
        
-       jit_insn_store_relative(jitCoder->jitFunction, ptr, typeOffset, 
typeConst);
+       jit_insn_store_relative(jitCoder->jitFunction, ptr,
+                                                       offsetof(ILTypedRef, 
type), typeConst);
                                
-       jit_insn_store_relative(jitCoder->jitFunction, ptr, valueOffset,
+       jit_insn_store_relative(jitCoder->jitFunction, ptr,
+                                                       offsetof(ILTypedRef, 
value),
                                                        
jitCoder->jitStack[jitCoder->stackTop - 1]);
 
        jitCoder->jitStack[jitCoder->stackTop - 1] = value;
@@ -708,12 +707,11 @@
        ILJitValue ptr =
                                jit_insn_address_of(jitCoder->jitFunction,
                                                                        
jitCoder->jitStack[jitCoder->stackTop - 1]);
-       jit_nuint typeOffset = jit_type_get_offset(_ILJitTypedRef, 0);
        jitCoder->jitStack[jitCoder->stackTop - 1] =
-                                                               
jit_insn_load_relative(jitCoder->jitFunction,
-                                                                               
                           ptr,
-                                                                               
                           typeOffset,
-                                                                               
                           _IL_JIT_TYPE_VPTR);
+                                                       
jit_insn_load_relative(jitCoder->jitFunction,
+                                                                               
                   ptr,
+                                                                               
                   offsetof(ILTypedRef, type),
+                                                                               
                   _IL_JIT_TYPE_VPTR);
 }
 
 static void JITCoder_PushToken(ILCoder *coder, ILProgramItem *item)
Index: pnet/engine/layout.c
diff -u pnet/engine/layout.c:1.42 pnet/engine/layout.c:1.43
--- pnet/engine/layout.c:1.42   Mon Jan  9 20:49:47 2006
+++ pnet/engine/layout.c        Sat Mar  4 14:36:08 2006
@@ -214,7 +214,7 @@
        {
                /* Everything else is laid out as a pointer */
        #ifdef IL_USE_JIT
-               if(!(layout->jitTypes = 
ILJitPrimitiveClrTypeToJitTypes(IL_META_ELEMTYPE_TYPEDBYREF)))
+               if(!(layout->jitTypes = 
ILJitPrimitiveClrTypeToJitTypes(IL_META_ELEMTYPE_PTR)))
                {
                        return 0;
                }
Index: pnet/engine/lib_array.c
diff -u pnet/engine/lib_array.c:1.29 pnet/engine/lib_array.c:1.30
--- pnet/engine/lib_array.c:1.29        Sat Jul 19 21:05:44 2003
+++ pnet/engine/lib_array.c     Sat Mar  4 14:36:08 2006
@@ -48,6 +48,9 @@
 extern "C" {
 #endif
 
+#ifdef IL_USE_JIT
+#define ArgWalker void *
+#else
 /*
  * Support for walking the argument stack in methods that
  * require a variable number of arguments.  This is CVM
@@ -82,6 +85,7 @@
                        ((args)->posn)
 #define        ArgWalkerAdvance(args,nwords) \
                        ((args)->posn += (nwords))
+#endif
 
 /*
  * Allocation constructor for single-dimensional arrays.
@@ -252,21 +256,38 @@
  */
 static void *GetElemAddress(ILExecThread *thread,
                                                        System_MArray *_this,
+#ifdef IL_USE_JIT
+                                                       void *args)
+#else
                                                        ArgWalker *args)
+#endif
 {
        ILInt32 offset;
        ILInt32 dim;
        ILInt32 index;
+#ifdef IL_USE_JIT
+       VA_LIST va;
+       
+       /* Copy the incoming "va_list" value */
+       ILMemCpy(&va, args, sizeof(VA_LIST));
+#endif
 
        /* Find the offset of the element */
        offset = 0;
        for(dim = 0; dim < _this->rank; ++dim)
        {
+       #ifdef IL_USE_JIT
+               index = VA_ARG(va, ILVaInt) - _this->bounds[dim].lower;
+       #else
                index = ArgWalkerGetInt(args) - _this->bounds[dim].lower;
+       #endif
                if(((ILUInt32)index) >= ((ILUInt32)(_this->bounds[dim].size)))
                {
                        ILExecThreadThrowSystem(thread, 
"System.IndexOutOfRangeException",
                                                                        
"Arg_InvalidArrayIndex");
+               #ifdef IL_USE_JIT
+                       VA_END;
+               #endif
                        return 0;
                }
                offset += index * _this->bounds[dim].multiplier;
@@ -316,18 +337,32 @@
  * the type of value.
  */
 static void SetElement(ILExecThread *thread, System_MArray *_this,
+#ifdef IL_USE_JIT
+                                          int valueType, void *args)
+#else
                                           int valueType, ArgWalker *args)
+#endif
 {
        ILInt32 offset;
        ILInt32 dim;
        ILInt32 index;
        void *address;
+#ifdef IL_USE_JIT
+       VA_LIST va;
+       
+       /* Copy the incoming "va_list" value */
+       ILMemCpy(&va, args, sizeof(VA_LIST));
+#endif
 
        /* Find the offset of the element */
        offset = 0;
        for(dim = 0; dim < _this->rank; ++dim)
        {
+       #ifdef IL_USE_JIT
+               index = VA_ARG(va, ILVaInt) - _this->bounds[dim].lower;
+       #else
                index = ArgWalkerGetInt(args) - _this->bounds[dim].lower;
+       #endif
                if(((ILUInt32)index) >= ((ILUInt32)(_this->bounds[dim].size)))
                {
                        ILExecThreadThrowSystem(thread, 
"System.IndexOutOfRangeException",
@@ -348,59 +383,100 @@
        {
                case IL_META_ELEMTYPE_I1:
                {
+               #ifdef IL_USE_JIT
+                       *((ILInt8 *)address) = VA_ARG(va, ILVaInt);
+               #else
                        *((ILInt8 *)address) = ArgWalkerGetShortInt(args, 
ILInt8);
+               #endif
                }
                break;
 
                case IL_META_ELEMTYPE_I2:
                {
+               #ifdef IL_USE_JIT
+                       *((ILInt16 *)address) = VA_ARG(va, ILVaInt);
+               #else
                        *((ILInt16 *)address) = ArgWalkerGetShortInt(args, 
ILInt16);
+               #endif
                }
                break;
 
                case IL_META_ELEMTYPE_I4:
                {
+               #ifdef IL_USE_JIT
+                       *((ILInt32 *)address) = VA_ARG(va, ILVaInt);
+               #else
                        *((ILInt32 *)address) = ArgWalkerGetInt(args);
+               #endif
                }
                break;
 
                case IL_META_ELEMTYPE_I8:
                {
+               #ifdef IL_USE_JIT
+                       ILInt64 longValue = VA_ARG(va, ILInt64);
+                       ILMemCpy(address, &longValue, sizeof(ILInt64));
+               #else
                        ILMemCpy(address, ArgWalkerGetAddr(args), 
sizeof(ILInt64));
                        ArgWalkerAdvance(args, CVM_WORDS_PER_LONG);
+               #endif
                }
                break;
 
                case IL_META_ELEMTYPE_R4:
                {
+               #ifdef IL_USE_JIT
+                       ILFloat floatValue = VA_ARG(va, ILDouble);
+                       ILMemCpy(address, &floatValue, sizeof(ILFloat));
+               #else
                        ILMemCpy(address, ArgWalkerGetAddr(args), 
sizeof(ILFloat));
                        ArgWalkerAdvance(args, CVM_WORDS_PER_NATIVE_FLOAT);
+               #endif
                }
                break;
 
                case IL_META_ELEMTYPE_R8:
                {
+               #ifdef IL_USE_JIT
+                       ILDouble floatValue = VA_ARG(va, ILVaDouble);
+                       ILMemCpy(address, &floatValue, sizeof(ILDouble));
+               #else
                        ILMemCpy(address, ArgWalkerGetAddr(args), 
sizeof(ILDouble));
                        ArgWalkerAdvance(args, CVM_WORDS_PER_NATIVE_FLOAT);
+               #endif
                }
                break;
 
                case IL_META_ELEMTYPE_R:
                {
+               #ifdef IL_USE_JIT
+                       ILNativeFloat floatValue = VA_ARG(va, ILNativeFloat);
+                       ILMemCpy(address, &floatValue, sizeof(ILNativeFloat));
+               #else
                        ILMemCpy(address, ArgWalkerGetAddr(args), 
sizeof(ILNativeFloat));
                        ArgWalkerAdvance(args, CVM_WORDS_PER_NATIVE_FLOAT);
+               #endif
                }
                break;
 
                case IL_META_ELEMTYPE_OBJECT:
                {
+               #ifdef IL_USE_JIT
+                       *((ILObject **)address) = (ILObject *)VA_ARG(va, void 
*);
+               #else
                        *((ILObject **)address) = (ILObject 
*)ArgWalkerGetPtr(args);
+               #endif
                }
                break;
 
                case IL_META_ELEMTYPE_VALUETYPE:
                {
+               #ifdef IL_USE_JIT
+                       void *ptrValue = VA_ARG(va, void *);
+                       ILMemCpy(address, ptrValue, _this->elemSize);
+               #else
                        ILMemCpy(address, ArgWalkerGetAddr(args), 
_this->elemSize);
+               #endif
                }
                break;
        }
@@ -411,12 +487,20 @@
  *
  * public T[,,,](int size1, int size2, ..., int sizeN)
  */
+#ifdef IL_USE_JIT
+static System_MArray *System_MArray_ctor_1(ILExecThread *thread, ...)
+#else
 static System_MArray *System_MArray_ctor_1(ILExecThread *thread)
+#endif
 {
        System_MArray *_this;
        ILInt32 dim;
        ILInt32 multiplier;
+#ifdef IL_USE_JIT
+       VA_START(thread);
+#else
        ArgWalker args;
+#endif
        int elemIsPrimitive;
 
        /* Construct the header part of the array */
@@ -428,12 +512,21 @@
        }
 
        /* Fill in the array header with the size values */
+#ifndef IL_USE_JIT
        ArgWalkerInit(&args);
+#endif
        for(dim = 0; dim < _this->rank; ++dim)
        {
                _this->bounds[dim].lower = 0;
+#ifdef IL_USE_JIT
+               _this->bounds[dim].size  = VA_ARG(va, ILVaInt);
+#else
                _this->bounds[dim].size  = ArgWalkerGetInt(&args);
+#endif
        }
+#ifdef IL_USE_JIT
+       VA_END;
+#endif
 
        /* Fill in the array header with the multiplier values */
        multiplier = 1;
@@ -452,12 +545,20 @@
  *
  * public T[,,,](int low1, int size1, ..., int lowN, int sizeN)
  */
+#ifdef IL_USE_JIT
+static System_MArray *System_MArray_ctor_2(ILExecThread *thread, ...)
+#else
 static System_MArray *System_MArray_ctor_2(ILExecThread *thread)
+#endif
 {
        System_MArray *_this;
        ILInt32 dim;
        ILInt32 multiplier;
+#ifdef IL_USE_JIT
+       VA_START(thread);
+#else
        ArgWalker args;
+#endif
        int elemIsPrimitive;
 
        /* Construct the header part of the array */
@@ -465,16 +566,29 @@
                                                                  
&elemIsPrimitive);
        if(!_this)
        {
+       #ifdef IL_USE_JIT
+               VA_END;
+       #endif
                return 0;
        }
 
        /* Fill in the array header with the lower bound and size values */
+#ifndef IL_USE_JIT
        ArgWalkerInit(&args);
+#endif
        for(dim = 0; dim < _this->rank; ++dim)
        {
+       #ifdef IL_USE_JIT
+               _this->bounds[dim].lower = VA_ARG(va, ILVaInt);
+               _this->bounds[dim].size  = VA_ARG(va, ILVaInt);
+       #else
                _this->bounds[dim].lower = ArgWalkerGetInt(&args);
                _this->bounds[dim].size  = ArgWalkerGetInt(&args);
+       #endif
        }
+#ifdef IL_USE_JIT
+       VA_END;
+#endif
 
        /* Fill in the array header with the multiplier values */
        multiplier = 1;
@@ -494,18 +608,35 @@
  * public sbyte Get(int index1, ..., int indexN)
  */
 static ILInt8 System_MArray_Get_sbyte(ILExecThread *thread,
+#ifdef IL_USE_JIT
+                                                                 System_MArray 
*_this, ...)
+#else
                                                                  System_MArray 
*_this)
+#endif
 {
        void *address;
+#ifdef IL_USE_JIT
+       VA_START(_this);
+
+       address = GetElemAddress(thread, _this, &va);
+#else
        ArgWalker args;
        ArgWalkerInitThis(&args);
+
        address = GetElemAddress(thread, _this, &args);
+#endif
        if(address)
        {
+       #ifdef IL_USE_JIT
+               VA_END;
+       #endif
                return *((ILInt8 *)address);
        }
        else
        {
+       #ifdef IL_USE_JIT
+               VA_END;
+       #endif
                return 0;
        }
 }
@@ -537,18 +668,33 @@
  * public byte Get(int index1, ..., int indexN)
  */
 static ILUInt8 System_MArray_Get_byte(ILExecThread *thread,
+#ifdef IL_USE_JIT
+                                                                 System_MArray 
*_this, ...)
+#else
                                                                  System_MArray 
*_this)
+#endif
 {
        void *address;
+#ifdef IL_USE_JIT
+       VA_START(_this);
+       address = GetElemAddress(thread, _this, &va);
+#else
        ArgWalker args;
        ArgWalkerInitThis(&args);
        address = GetElemAddress(thread, _this, &args);
+#endif
        if(address)
        {
+       #ifdef IL_USE_JIT
+               VA_END;
+       #endif
                return *((ILUInt8 *)address);
        }
        else
        {
+       #ifdef IL_USE_JIT
+               VA_END;
+       #endif
                return 0;
        }
 }
@@ -580,18 +726,33 @@
  * public short Get(int index1, ..., int indexN)
  */
 static ILInt16 System_MArray_Get_short(ILExecThread *thread,
+#ifdef IL_USE_JIT
+                                                                  
System_MArray *_this, ...)
+#else
                                                                   
System_MArray *_this)
+#endif
 {
        void *address;
+#ifdef IL_USE_JIT
+       VA_START(_this);
+       address = GetElemAddress(thread, _this, &va);
+#else
        ArgWalker args;
        ArgWalkerInitThis(&args);
        address = GetElemAddress(thread, _this, &args);
+#endif
        if(address)
        {
+       #ifdef IL_USE_JIT
+               VA_END;
+       #endif
                return *((ILInt16 *)address);
        }
        else
        {
+       #ifdef IL_USE_JIT
+               VA_END;
+       #endif
                return 0;
        }
 }
@@ -623,18 +784,33 @@
  * public ushort Get(int index1, ..., int indexN)
  */
 static ILUInt16 System_MArray_Get_ushort(ILExecThread *thread,
+#ifdef IL_USE_JIT
+                                                                    
System_MArray *_this, ...)
+#else
                                                                     
System_MArray *_this)
+#endif
 {
        void *address;
+#ifdef IL_USE_JIT
+       VA_START(_this);
+       address = GetElemAddress(thread, _this, &va);
+#else
        ArgWalker args;
        ArgWalkerInitThis(&args);
        address = GetElemAddress(thread, _this, &args);
+#endif
        if(address)
        {
+       #ifdef IL_USE_JIT
+               VA_END;
+       #endif
                return *((ILUInt16 *)address);
        }
        else
        {
+       #ifdef IL_USE_JIT
+               VA_END;
+       #endif
                return 0;
        }
 }
@@ -666,19 +842,34 @@
  * public int Get(int index1, ..., int indexN)
  */
 static ILInt32 System_MArray_Get_int(ILExecThread *thread,
+#ifdef IL_USE_JIT
+                                                                System_MArray 
*_this, ...)
+#else
                                                                 System_MArray 
*_this)
+#endif
 {
        void *address;
+#ifdef IL_USE_JIT
+       VA_START(_this);
+       address = GetElemAddress(thread, _this, &va);
+#else
        ArgWalker args;
        ArgWalkerInitThis(&args);
        address = GetElemAddress(thread, _this, &args);
+#endif
        if(address)
        {
+       #ifdef IL_USE_JIT
+               VA_END;
+       #endif
                return *((ILInt32 *)address);
        }
        else
        {
                return 0;
+       #ifdef IL_USE_JIT
+               VA_END;
+       #endif
        }
 }
 
@@ -709,18 +900,33 @@
  * public uint Get(int index1, ..., int indexN)
  */
 static ILUInt32 System_MArray_Get_uint(ILExecThread *thread,
+#ifdef IL_USE_JIT
+                                                                  
System_MArray *_this, ...)
+#else
                                                                   
System_MArray *_this)
+#endif
 {
        void *address;
+#ifdef IL_USE_JIT
+       VA_START(_this);
+       address = GetElemAddress(thread, _this, &va);
+#else
        ArgWalker args;
        ArgWalkerInitThis(&args);
        address = GetElemAddress(thread, _this, &args);
+#endif
        if(address)
        {
+       #ifdef IL_USE_JIT
+               VA_END;
+       #endif
                return *((ILUInt32 *)address);
        }
        else
        {
+       #ifdef IL_USE_JIT
+               VA_END;
+       #endif
                return 0;
        }
 }
@@ -752,18 +958,33 @@
  * public long Get(int index1, ..., int indexN)
  */
 static ILInt64 System_MArray_Get_long(ILExecThread *thread,
+#ifdef IL_USE_JIT
+                                                                 System_MArray 
*_this, ...)
+#else
                                                                  System_MArray 
*_this)
+#endif
 {
        void *address;
+#ifdef IL_USE_JIT
+       VA_START(_this);
+       address = GetElemAddress(thread, _this, &va);
+#else
        ArgWalker args;
        ArgWalkerInitThis(&args);
        address = GetElemAddress(thread, _this, &args);
+#endif
        if(address)
        {
+       #ifdef IL_USE_JIT
+               VA_END;
+       #endif
                return *((ILInt64 *)address);
        }
        else
        {
+       #ifdef IL_USE_JIT
+               VA_END;
+       #endif
                return 0;
        }
 }
@@ -795,18 +1016,33 @@
  * public ulong Get(int index1, ..., int indexN)
  */
 static ILUInt64 System_MArray_Get_ulong(ILExecThread *thread,
+#ifdef IL_USE_JIT
+                                                                   
System_MArray *_this, ...)
+#else
                                                                    
System_MArray *_this)
+#endif
 {
        void *address;
+#ifdef IL_USE_JIT
+       VA_START(_this);
+       address = GetElemAddress(thread, _this, &va);
+#else
        ArgWalker args;
        ArgWalkerInitThis(&args);
        address = GetElemAddress(thread, _this, &args);
+#endif
        if(address)
        {
+       #ifdef IL_USE_JIT
+               VA_END;
+       #endif
                return *((ILUInt64 *)address);
        }
        else
        {
+       #ifdef IL_USE_JIT
+               VA_END;
+       #endif
                return 0;
        }
 }
@@ -838,18 +1074,33 @@
  * public float Get(int index1, ..., int indexN)
  */
 static ILFloat System_MArray_Get_float(ILExecThread *thread,
+#ifdef IL_USE_JIT
+                                                                  
System_MArray *_this, ...)
+#else
                                                                   
System_MArray *_this)
+#endif
 {
        void *address;
+#ifdef IL_USE_JIT
+       VA_START(_this);
+       address = GetElemAddress(thread, _this, &va);
+#else
        ArgWalker args;
        ArgWalkerInitThis(&args);
        address = GetElemAddress(thread, _this, &args);
+#endif
        if(address)
        {
+       #ifdef IL_USE_JIT
+               VA_END;
+       #endif
                return *((ILFloat *)address);
        }
        else
        {
+       #ifdef IL_USE_JIT
+               VA_END;
+       #endif
                return 0;
        }
 }
@@ -881,18 +1132,33 @@
  * public double Get(int index1, ..., int indexN)
  */
 static ILDouble System_MArray_Get_double(ILExecThread *thread,
+#ifdef IL_USE_JIT
+                                                                    
System_MArray *_this, ...)
+#else
                                                                     
System_MArray *_this)
+#endif
 {
        void *address;
+#ifdef IL_USE_JIT
+       VA_START(_this);
+       address = GetElemAddress(thread, _this, &va);
+#else
        ArgWalker args;
        ArgWalkerInitThis(&args);
        address = GetElemAddress(thread, _this, &args);
+#endif
        if(address)
        {
+       #ifdef IL_USE_JIT
+               VA_END;
+       #endif
                return *((ILDouble *)address);
        }
        else
        {
+       #ifdef IL_USE_JIT
+               VA_END;
+       #endif
                return 0;
        }
 }
@@ -924,18 +1190,33 @@
  * public native float Get(int index1, ..., int indexN)
  */
 static ILNativeFloat System_MArray_Get_nativeFloat(ILExecThread *thread,
+#ifdef IL_USE_JIT
+                                                                               
   System_MArray *_this, ...)
+#else
                                                                                
   System_MArray *_this)
+#endif
 {
        void *address;
+#ifdef IL_USE_JIT
+       VA_START(_this);
+       address = GetElemAddress(thread, _this, &va);
+#else
        ArgWalker args;
        ArgWalkerInitThis(&args);
        address = GetElemAddress(thread, _this, &args);
+#endif
        if(address)
        {
+       #ifdef IL_USE_JIT
+               VA_END;
+       #endif
                return *((ILNativeFloat *)address);
        }
        else
        {
+       #ifdef IL_USE_JIT
+               VA_END;
+       #endif
                return 0;
        }
 }
@@ -968,18 +1249,33 @@
  * public Object Get(int index1, ..., int indexN)
  */
 static ILObject *System_MArray_Get_ref(ILExecThread *thread,
+#ifdef IL_USE_JIT
+                                                                  
System_MArray *_this, ...)
+#else
                                                                   
System_MArray *_this)
+#endif
 {
        void *address;
+#ifdef IL_USE_JIT
+       VA_START(_this);
+       address = GetElemAddress(thread, _this, &va);
+#else
        ArgWalker args;
        ArgWalkerInitThis(&args);
        address = GetElemAddress(thread, _this, &args);
+#endif
        if(address)
        {
+       #ifdef IL_USE_JIT
+               VA_END;
+       #endif
                return *((ILObject **)address);
        }
        else
        {
+       #ifdef IL_USE_JIT
+               VA_END;
+       #endif
                return 0;
        }
 }
@@ -1012,16 +1308,28 @@
  */
 static void System_MArray_Get_managedValue(ILExecThread *thread,
                                                                                
   void *result,
+#ifdef IL_USE_JIT
+                                                                          
System_MArray *_this, ...)
+#else
                                                                       
System_MArray *_this)
+#endif
 {
        void *address;
+#ifdef IL_USE_JIT
+       VA_START(_this);
+       address = GetElemAddress(thread, _this, &va);
+#else
        ArgWalker args;
        ArgWalkerInitThis(&args);
        address = GetElemAddress(thread, _this, &args);
+#endif
        if(address)
        {
                ILMemCpy(result, address, _this->elemSize);
        }
+#ifdef IL_USE_JIT
+       VA_END;
+#endif
 }
 
 /*
@@ -1056,12 +1364,22 @@
  * public type & Address(int index1, ..., int indexN)
  */
 static void *System_MArray_Address(ILExecThread *thread,
+#ifdef IL_USE_JIT
+                                                              System_MArray 
*_this, ...)
+#else
                                                               System_MArray 
*_this)
+#endif
 {
        void *address;
+#ifdef IL_USE_JIT
+       VA_START(_this);
+       address = GetElemAddress(thread, _this, &va);
+       VA_END;
+#else
        ArgWalker args;
        ArgWalkerInitThis(&args);
        address = GetElemAddress(thread, _this, &args);
+#endif
        return address;
 }
 
@@ -1072,11 +1390,21 @@
  * public void Set(int index1, ..., int indexN, byte value)
  */
 static void System_MArray_Set_byte(ILExecThread *thread,
+#ifdef IL_USE_JIT
+                                                              System_MArray 
*_this, ...)
+#else
                                                               System_MArray 
*_this)
+#endif
 {
+#ifdef IL_USE_JIT
+       VA_START(_this);
+       SetElement(thread, _this, IL_META_ELEMTYPE_I1, &va);
+       VA_END;
+#else
        ArgWalker args;
        ArgWalkerInitThis(&args);
        SetElement(thread, _this, IL_META_ELEMTYPE_I1, &args);
+#endif
 }
 
 /*
@@ -1105,11 +1433,21 @@
  * public void Set(int index1, ..., int indexN, ushort value)
  */
 static void System_MArray_Set_short(ILExecThread *thread,
+#ifdef IL_USE_JIT
+                                                               System_MArray 
*_this, ...)
+#else
                                                                System_MArray 
*_this)
+#endif
 {
+#ifdef IL_USE_JIT
+       VA_START(_this);
+       SetElement(thread, _this, IL_META_ELEMTYPE_I2, &va);
+       VA_END;
+#else
        ArgWalker args;
        ArgWalkerInitThis(&args);
        SetElement(thread, _this, IL_META_ELEMTYPE_I2, &args);
+#endif
 }
 
 /*
@@ -1138,11 +1476,21 @@
  * public void Set(int index1, ..., int indexN, uint value)
  */
 static void System_MArray_Set_int(ILExecThread *thread,
+#ifdef IL_USE_JIT
+                                                             System_MArray 
*_this, ...)
+#else
                                                              System_MArray 
*_this)
+#endif
 {
+#ifdef IL_USE_JIT
+       VA_START(_this);
+       SetElement(thread, _this, IL_META_ELEMTYPE_I4, &va);
+       VA_END;
+#else
        ArgWalker args;
        ArgWalkerInitThis(&args);
        SetElement(thread, _this, IL_META_ELEMTYPE_I4, &args);
+#endif
 }
 
 /*
@@ -1171,11 +1519,21 @@
  * public void Set(int index1, ..., int indexN, ulong value)
  */
 static void System_MArray_Set_long(ILExecThread *thread,
+#ifdef IL_USE_JIT
+                                                              System_MArray 
*_this, ...)
+#else
                                                               System_MArray 
*_this)
+#endif
 {
+#ifdef IL_USE_JIT
+       VA_START(_this);
+       SetElement(thread, _this, IL_META_ELEMTYPE_I8, &va);
+       VA_END;
+#else
        ArgWalker args;
        ArgWalkerInitThis(&args);
        SetElement(thread, _this, IL_META_ELEMTYPE_I8, &args);
+#endif
 }
 
 /*
@@ -1203,11 +1561,21 @@
  * public void Set(int index1, ..., int indexN, float value)
  */
 static void System_MArray_Set_float(ILExecThread *thread,
+#ifdef IL_USE_JIT
+                                                               System_MArray 
*_this, ...)
+#else
                                                                System_MArray 
*_this)
+#endif
 {
+#ifdef IL_USE_JIT
+       VA_START(_this);
+       SetElement(thread, _this, IL_META_ELEMTYPE_R4, &va);
+       VA_END;
+#else
        ArgWalker args;
        ArgWalkerInitThis(&args);
        SetElement(thread, _this, IL_META_ELEMTYPE_R4, &args);
+#endif
 }
 
 /*
@@ -1234,11 +1602,21 @@
  * public void Set(int index1, ..., int indexN, double value)
  */
 static void System_MArray_Set_double(ILExecThread *thread,
+#ifdef IL_USE_JIT
+                                                                System_MArray 
*_this, ...)
+#else
                                                                 System_MArray 
*_this)
+#endif
 {
+#ifdef IL_USE_JIT
+       VA_START(_this);
+       SetElement(thread, _this, IL_META_ELEMTYPE_R8, &va);
+       VA_END;
+#else
        ArgWalker args;
        ArgWalkerInitThis(&args);
        SetElement(thread, _this, IL_META_ELEMTYPE_R8, &args);
+#endif
 }
 
 /*
@@ -1265,11 +1643,21 @@
  * public void Set(int index1, ..., int indexN, native float value)
  */
 static void System_MArray_Set_nativeFloat(ILExecThread *thread,
+#ifdef IL_USE_JIT
+                                                                     
System_MArray *_this, ...)
+#else
                                                                      
System_MArray *_this)
+#endif
 {
+#ifdef IL_USE_JIT
+       VA_START(_this);
+       SetElement(thread, _this, IL_META_ELEMTYPE_R, &va);
+       VA_END;
+#else
        ArgWalker args;
        ArgWalkerInitThis(&args);
        SetElement(thread, _this, IL_META_ELEMTYPE_R, &args);
+#endif
 }
 
 /*
@@ -1296,11 +1684,21 @@
  * public void Set(int index1, ..., int indexN, Object value)
  */
 static void System_MArray_Set_ref(ILExecThread *thread,
+#ifdef IL_USE_JIT
+                                                             System_MArray 
*_this, ...)
+#else
                                                              System_MArray 
*_this)
+#endif
 {
+#ifdef IL_USE_JIT
+       VA_START(_this);
+       SetElement(thread, _this, IL_META_ELEMTYPE_OBJECT, &va);
+       VA_END;
+#else
        ArgWalker args;
        ArgWalkerInitThis(&args);
        SetElement(thread, _this, IL_META_ELEMTYPE_OBJECT, &args);
+#endif
 }
 
 /*
@@ -1327,11 +1725,21 @@
  * public void Set(int index1, ..., int indexN, type value)
  */
 static void System_MArray_Set_managedValue(ILExecThread *thread,
+#ifdef IL_USE_JIT
+                                                                      
System_MArray *_this, ...)
+#else
                                                                       
System_MArray *_this)
+#endif
 {
+#ifdef IL_USE_JIT
+       VA_START(_this);
+       SetElement(thread, _this, IL_META_ELEMTYPE_VALUETYPE, &va);
+       VA_END;
+#else
        ArgWalker args;
        ArgWalkerInitThis(&args);
        SetElement(thread, _this, IL_META_ELEMTYPE_VALUETYPE, &args);
+#endif
 }
 
 /*
Index: pnet/engine/verify.c
diff -u pnet/engine/verify.c:1.47 pnet/engine/verify.c:1.48
--- pnet/engine/verify.c:1.47   Wed Jun  9 03:39:23 2004
+++ pnet/engine/verify.c        Sat Mar  4 14:36:08 2006
@@ -1065,8 +1065,13 @@
                        VALIDATE_TARGET_STACK(offset);
 
                        /* Notify the coder of a label at this position */
+               #ifdef IL_USE_JIT
+                       ILCoderStackRefresh(coder, stack, stackSize);
+                       ILCoderLabel(coder, offset);
+               #else
                        ILCoderLabel(coder, offset);
                        ILCoderStackRefresh(coder, stack, stackSize);
+               #endif
                }
                else if(lastWasJump)
                {




reply via email to

[Prev in Thread] Current Thread [Next in Thread]