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

[Klaus Treichel]

CVSROOT:        /cvsroot/dotgnu-pnet
Module name:    pnet
Branch:         
Changes by:     Klaus Treichel <address@hidden> 06/01/06 17:38:57

Modified files:
        .              : ChangeLog 
        engine         : jitc.c jitc_obj.c jitc_var.c 

Log message:
        Add more of the jit coder.

CVSWeb URLs:
http://cvs.savannah.gnu.org/viewcvs/dotgnu-pnet/pnet/ChangeLog.diff?tr1=1.3270&tr2=1.3271&r1=text&r2=text
http://cvs.savannah.gnu.org/viewcvs/dotgnu-pnet/pnet/engine/jitc.c.diff?tr1=1.10&tr2=1.11&r1=text&r2=text
http://cvs.savannah.gnu.org/viewcvs/dotgnu-pnet/pnet/engine/jitc_obj.c.diff?tr1=1.1&tr2=1.2&r1=text&r2=text
http://cvs.savannah.gnu.org/viewcvs/dotgnu-pnet/pnet/engine/jitc_var.c.diff?tr1=1.3&tr2=1.4&r1=text&r2=text

Patches:
Index: pnet/ChangeLog
diff -u pnet/ChangeLog:1.3270 pnet/ChangeLog:1.3271
--- pnet/ChangeLog:1.3270       Fri Jan  6 11:18:42 2006
+++ pnet/ChangeLog      Fri Jan  6 17:38:56 2006
@@ -1,5 +1,13 @@
 2006-01-06  Klaus Treichel  <address@hidden>
 
+       * engine/jitc.c: Add some helper functions for jitc_obj.c
+
+       * engine/jitc_var.c: Clean up the code a bit.
+
+       * engine/jitc_obj.c: Implement CastClass/IsInst.
+
+2006-01-06  Klaus Treichel  <address@hidden>
+
        * engine/jitc.c, engine/jitc_ptr.c: Clean up the code a bit and fix a 
bug
        in stelem where a conversion to the array type was missing.
 
Index: pnet/engine/jitc.c
diff -u pnet/engine/jitc.c:1.10 pnet/engine/jitc.c:1.11
--- pnet/engine/jitc.c:1.10     Fri Jan  6 11:01:30 2006
+++ pnet/engine/jitc.c  Fri Jan  6 17:38:56 2006
@@ -69,6 +69,23 @@
 static ILJitType _ILJitSignature_ILEngineAlloc = 0;
 
 /*
+ * ILInt32 ILRuntimeCanCastClass(ILExecThread *thread, ILObject *object, 
ILClass *toClass)
+ *
+ */
+static ILJitType _ILJitSignature_ILRuntimeCanCastClass = 0;
+
+/*
+ * ILInt32 ILRuntimeClassImplements(ILObject *object, ILClass *toClass)
+ */
+static ILJitType _ILJitSignature_ILRuntimeClassImplements = 0;
+
+/*
+ * void *ILRuntimeGetThreadStatic(ILExecThread *thread,
+ *                                                        ILUInt32 slot, 
ILUInt32 size)
+ */
+static ILJitType _ILJitSignature_ILRuntimeGetThreadStatic = 0;
+
+/*
  * Define offsetof macro if not present.
  */
 #ifndef offsetof
@@ -306,6 +323,104 @@
 }
 
 /*
+ * Perform a class cast, taking arrays into account.
+ */
+ILInt32 ILRuntimeCanCastClass(ILExecThread *thread, ILObject *object, ILClass 
*toClass)
+{
+       ILImage *image = ILProgramItem_Image(thread->method);
+       ILClass *fromClass = GetObjectClass(object);
+       ILType *fromType = ILClassGetSynType(fromClass);
+       ILType *toType = ILClassGetSynType(toClass);
+       if(fromType && toType)
+       {
+               if(ILType_IsArray(fromType) && ILType_IsArray(toType) &&
+                  ILTypeGetRank(fromType) == ILTypeGetRank(toType))
+               {
+                       return ILTypeAssignCompatibleNonBoxing
+                         (image, ILTypeGetElemType(fromType), 
ILTypeGetElemType(toType));
+               }
+               else
+               {
+                       return 0;
+               }
+       }
+       else
+       {
+               fromType=ILTypeGetEnumType(ILClassToType(fromClass));
+               toType=ILTypeGetEnumType(ILClassToType(toClass));
+               
+               if(ILTypeIdentical(fromType,toType))
+               {
+                       return 1;
+               }
+
+               return ILClassInheritsFrom(fromClass, toClass);
+       }
+}
+
+/*
+ * Perform a check if a class implements a given interface.
+ */
+ILInt32 ILRuntimeClassImplements(ILObject *object, ILClass *toClass)
+{
+       ILClass *info = GetObjectClass(object);
+
+       return ILClassImplements(info, toClass);
+}
+
+/*
+ * Get a thread-static value from the current thread.
+ */
+void *ILRuntimeGetThreadStatic(ILExecThread *thread,
+                                                          ILUInt32 slot, 
ILUInt32 size)
+{
+       void **array;
+       ILUInt32 used;
+       void *ptr;
+
+       /* Determine if we need to allocate space for a new slot */
+       if(slot >= thread->threadStaticSlotsUsed)
+       {
+               used = (slot + 8) & ~7;
+               array = (void **)ILGCAlloc(sizeof(void *) * used);
+               if(!array)
+               {
+                       ILExecThreadThrowOutOfMemory(thread);
+                       return 0;
+               }
+               if(thread->threadStaticSlotsUsed > 0)
+               {
+                       ILMemMove(array, thread->threadStaticSlots,
+                                         sizeof(void *) * 
thread->threadStaticSlotsUsed);
+               }
+               thread->threadStaticSlots = array;
+               thread->threadStaticSlotsUsed = used;
+       }
+
+       /* Fetch the current value in the slot */
+       ptr = thread->threadStaticSlots[slot];
+       if(ptr)
+       {
+               return ptr;
+       }
+
+       /* Allocate a new value and write it to the slot */
+       if(!size)
+       {
+               /* Sanity check, just in case */
+               size = sizeof(unsigned long);
+       }
+       ptr = ILGCAlloc((unsigned long)size);
+       if(!ptr)
+       {
+               ILExecThreadThrowOutOfMemory(thread);
+               return 0;
+       }
+       thread->threadStaticSlots[slot] = ptr;
+       return ptr;
+}
+
+/*
  * Get the pointer to base type from the JitTypes.
  * The pointer type is created on demand if not allready present.
  * Returns 0 when out of memory.
@@ -469,6 +584,35 @@
                return 0;
        }
 
+       args[0] = _IL_JIT_TYPE_VPTR;
+       args[1] = _IL_JIT_TYPE_VPTR;
+       args[2] = _IL_JIT_TYPE_VPTR;
+       returnType = _IL_JIT_TYPE_INT32;
+       if(!(_ILJitSignature_ILRuntimeCanCastClass = 
+               jit_type_create_signature(IL_JIT_CALLCONV_CDECL, returnType, 
args, 3, 1)))
+       {
+               return 0;
+       }
+
+       args[0] = _IL_JIT_TYPE_VPTR;
+       args[1] = _IL_JIT_TYPE_VPTR;
+       returnType = _IL_JIT_TYPE_INT32;
+       if(!(_ILJitSignature_ILRuntimeClassImplements = 
+               jit_type_create_signature(IL_JIT_CALLCONV_CDECL, returnType, 
args, 2, 1)))
+       {
+               return 0;
+       }
+
+       args[0] = _IL_JIT_TYPE_VPTR;
+       args[1] = _IL_JIT_TYPE_UINT32;
+       args[2] = _IL_JIT_TYPE_UINT32;
+       returnType = _IL_JIT_TYPE_VPTR;
+       if(!(_ILJitSignature_ILRuntimeGetThreadStatic = 
+               jit_type_create_signature(IL_JIT_CALLCONV_CDECL, returnType, 
args, 3, 1)))
+       {
+               return 0;
+       }
+
        return 1;
 }
 /*
Index: pnet/engine/jitc_obj.c
diff -u pnet/engine/jitc_obj.c:1.1 pnet/engine/jitc_obj.c:1.2
--- pnet/engine/jitc_obj.c:1.1  Mon Dec 19 18:00:35 2005
+++ pnet/engine/jitc_obj.c      Fri Jan  6 17:38:56 2006
@@ -20,9 +20,107 @@
 
 #ifdef IL_JITC_CODE
 
+/*
+ * Get a ILJitValue with a pointer to the class' static area.
+ */
+static ILJitValue _ILJitGetClassStaticArea(ILExecThread *thread,
+                                                                               
   ILJitFunction func,
+                                                                               
   ILField *field)
+{
+       /* Get the static data area for a particular class */
+       ILClass *classInfo = ILField_Owner(field);
+       void *classStaticData = ((ILClassPrivate 
*)(classInfo->userData))->staticData;
+       ILJitValue staticData;
+
+       if(!classStaticData)
+       {
+               if(((ILClassPrivate *)(classInfo->userData))->managedStatic)
+               {
+                       classStaticData = _ILEngineAlloc(thread, 0,
+                          ((ILClassPrivate 
*)(classInfo->userData))->staticSize);
+               }
+               else
+               {
+                       /* There are no managed fields in the static area,
+                       so use atomic allocation */
+                       classStaticData = _ILEngineAllocAtomic(thread, 0,
+                          ((ILClassPrivate 
*)(classInfo->userData))->staticSize);
+               }
+               if(!classStaticData)
+               {
+                       jit_exception_builtin(JIT_RESULT_OUT_OF_MEMORY);
+               }
+               else
+               {
+                       ((ILClassPrivate *)(classInfo->userData))->staticData = 
classStaticData;
+               }
+       }
+       staticData = jit_value_create_nint_constant(func, _IL_JIT_TYPE_VPTR,
+                                                                               
                (jit_nint)classStaticData);
+       return staticData;
+}
+
 static void JITCoder_CastClass(ILCoder *coder, ILClass *classInfo,
                                                           int throwException)
 {
+       ILJITCoder *jitCoder = _ILCoderToILJITCoder(coder);
+       ILJitValue classTo = 
jit_value_create_nint_constant(jitCoder->jitFunction,
+                                                                               
                                _IL_JIT_TYPE_VPTR,
+                                                                               
                                (jit_nint)classInfo);
+       ILJitValue object = jitCoder->jitStack[jitCoder->stackTop - 1];
+       jit_label_t label = jit_label_undefined;
+       ILJitValue args[3];
+       ILJitValue returnValue;
+
+       jit_insn_branch_if_not(jitCoder->jitFunction, object, &label);
+       if(ILClass_IsInterface(classInfo))
+       {
+               /* We are casting to an interface */
+               args[0] = object;
+               args[1] = classTo;
+               returnValue = jit_insn_call_native(jitCoder->jitFunction, 0,
+                                                                               
   ILRuntimeClassImplements,
+                                                                               
   _ILJitSignature_ILRuntimeClassImplements,
+                                                                               
   args, 2, 0);
+               jit_insn_branch_if(jitCoder->jitFunction, returnValue, &label);
+               if(throwException)
+               {
+                       /* TODO: Throw an InvalidCastException here. */
+               }
+               else
+               {
+                       ILJitValue nullPointer = 
+                                       
jit_value_create_nint_constant(jitCoder->jitFunction,
+                                                                               
                   _IL_JIT_TYPE_VPTR,
+                                                                               
                   (jit_nint)0);
+                       jitCoder->jitStack[jitCoder->stackTop - 1] = 
nullPointer;
+               }
+       }
+       else
+       {
+               args[0] = jit_value_get_param(jitCoder->jitFunction, 0);
+               args[1] = object;
+               args[2] = classTo;
+               returnValue = jit_insn_call_native(jitCoder->jitFunction, 0,
+                                                                               
   ILRuntimeCanCastClass,
+                                                                               
   _ILJitSignature_ILRuntimeCanCastClass,
+                                                                               
   args, 3, 0);
+               jit_insn_branch_if(jitCoder->jitFunction, returnValue, &label);
+               if(throwException)
+               {
+                       /* TODO: Throw an InvalidCastException here. */
+
+               }
+               else
+               {
+                       ILJitValue nullPointer = 
+                                       
jit_value_create_nint_constant(jitCoder->jitFunction,
+                                                                               
                   _IL_JIT_TYPE_VPTR,
+                                                                               
                   (jit_nint)0);
+                       jitCoder->jitStack[jitCoder->stackTop - 1] = 
nullPointer;
+               }
+       }
+       jit_insn_label(jitCoder->jitFunction, &label);
 }
 
 static void JITCoder_LoadField(ILCoder *coder, ILEngineType ptrType,
@@ -110,6 +208,12 @@
 
 static void JITCoder_PushToken(ILCoder *coder, ILProgramItem *item)
 {
+       ILJITCoder *jitCoder = _ILCoderToILJITCoder(coder);
+       ILJitValue token = jit_value_create_nint_constant(jitCoder->jitFunction,
+                                                                               
                          _IL_JIT_TYPE_VPTR, 
+                                                                               
                 (jit_nint)item);
+
+       JITC_ADJUST(jitCoder, 1);
 }
 
 static void JITCoder_SizeOf(ILCoder *coder, ILType *type)
Index: pnet/engine/jitc_var.c
diff -u pnet/engine/jitc_var.c:1.3 pnet/engine/jitc_var.c:1.4
--- pnet/engine/jitc_var.c:1.3  Sat Dec 31 14:09:19 2005
+++ pnet/engine/jitc_var.c      Fri Jan  6 17:38:56 2006
@@ -20,25 +20,6 @@
 
 #ifdef IL_JITC_CODE
 
-/*
- * Convert a local/arg to the type needed on the stack.
- * Returns the converted value when conversion is needed or value as it is.
- */
-static ILJitValue ConvertToStack(ILJITCoder *coder, ILJitValue value)
-{
-       ILJitType type = jit_value_get_type(value);
-       ILJitType newType = jit_type_promote_int(type);
-
-       if(type != newType)
-       {
-               return jit_insn_convert(coder->jitFunction, value, newType, 0);
-       }
-       if((type == _IL_JIT_TYPE_SINGLE) || (type == _IL_JIT_TYPE_DOUBLE))
-       {
-               return jit_insn_convert(coder->jitFunction, value, 
_IL_JIT_TYPE_NFLOAT, 0);
-       }
-       return value;
-}
 
 /*
  * Handle a load from an argument.
@@ -48,7 +29,8 @@
        ILJITCoder *jitCoder = _ILCoderToILJITCoder(coder);
        /* We need argNum + 1 because the ILExecThread is added as param 0 */
        ILJitValue param = jit_value_get_param(jitCoder->jitFunction, argNum + 
1);
-       ILJitValue newParam = ConvertToStack(jitCoder, param);
+       ILJitValue newParam = 
_ILJitValueConvertToStackType(jitCoder->jitFunction,
+                                                                               
                                param);
 
        jitCoder->jitStack[jitCoder->stackTop] = newParam;
        JITC_ADJUST(jitCoder, 1);
@@ -63,7 +45,8 @@
        ILJitValue localValue = jitCoder->jitLocals[localNum];
 
        jitCoder->jitStack[jitCoder->stackTop] = 
-                                       ConvertToStack(jitCoder, localValue);
+                                       
_ILJitValueConvertToStackType(jitCoder->jitFunction,
+                                                                               
                  localValue);
        JITC_ADJUST(jitCoder, 1);
 }