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.c


From: Klaus Treichel
Subject: [dotgnu-pnet-commits] pnet ChangeLog engine/jitc.c engine/jitc_call.c
Date: Sat, 10 Jun 2006 12:38:45 +0000

CVSROOT:        /sources/dotgnu-pnet
Module name:    pnet
Changes by:     Klaus Treichel <ktreichel>      06/06/10 12:38:45

Modified files:
        .              : ChangeLog 
        engine         : jitc.c jitc_call.c 

Log message:
        2006-06-10  Klaus Treichel  <address@hidden>
        
                * engine/jitc.c: Fix problem with not existent pinvokes.
        
                * engine/jitc_call.c: Add more inlined math functions. 
Implement the
                CheckCallNull which fixes the failure of the String.Equals 
runtime test.

CVSWeb URLs:
http://cvs.savannah.gnu.org/viewcvs/pnet/ChangeLog?cvsroot=dotgnu-pnet&r1=1.3323&r2=1.3324
http://cvs.savannah.gnu.org/viewcvs/pnet/engine/jitc.c?cvsroot=dotgnu-pnet&r1=1.36&r2=1.37
http://cvs.savannah.gnu.org/viewcvs/pnet/engine/jitc_call.c?cvsroot=dotgnu-pnet&r1=1.18&r2=1.19

Patches:
Index: ChangeLog
===================================================================
RCS file: /sources/dotgnu-pnet/pnet/ChangeLog,v
retrieving revision 1.3323
retrieving revision 1.3324
diff -u -b -r1.3323 -r1.3324
--- ChangeLog   5 Jun 2006 11:34:45 -0000       1.3323
+++ ChangeLog   10 Jun 2006 12:38:45 -0000      1.3324
@@ -1,3 +1,10 @@
+2006-06-10  Klaus Treichel  <address@hidden>
+
+       * engine/jitc.c: Fix problem with not existent pinvokes.
+
+       * engine/jitc_call.c: Add more inlined math functions. Implement the
+       CheckCallNull which fixes the failure of the String.Equals runtime test.
+
 2006-06-05  Klaus Treichel  <address@hidden>
 
        * engine/call.c: Fix problems with type casting.

Index: engine/jitc.c
===================================================================
RCS file: /sources/dotgnu-pnet/pnet/engine/jitc.c,v
retrieving revision 1.36
retrieving revision 1.37
diff -u -b -r1.36 -r1.37
--- engine/jitc.c       4 Jun 2006 19:33:10 -0000       1.36
+++ engine/jitc.c       10 Jun 2006 12:38:45 -0000      1.37
@@ -2625,35 +2625,18 @@
  */
 static int _ILJitMethodIsAbstract(ILMethod *method)
 {
-       ILMethodCode code;
-
        if(!method)
        {
                /* This is obviously a bug and should not happen. */
                return 0;
        }
 
-       /* Get the method code */
-       if(!ILMethodGetCode(method, &code))
-       {
-               code.code = 0;
-       }
-
-       if(code.code)
+       if(ILMethod_IsAbstract(method) ||
+          ILClass_IsInterface(ILMethod_Owner(method)))
        {
-               /* Code is present so zhe method is not abstract. */
-               return 0;
+               return 1;
        }
-
-       if(method->implementAttrs &
-                       (IL_META_METHODIMPL_CODE_TYPE_MASK |
-                        IL_META_METHODIMPL_INTERNAL_CALL |
-                        IL_META_METHODIMPL_JAVA))
-       {
-               /* An internalcall or pinvoke implementation should exist. */
                return 0;
-       }
-       return 1;
 }
 
 #include "jitc_alloc.c"
@@ -3135,10 +3118,7 @@
                return 1;
        }
 
-       if(!_ILJitSetMethodInfo(coder, method, 0))
-       {
-               return 0;
-       }
+       _ILJitSetMethodInfo(coder, method, 0);
 
        /* are we ready now ? */
 
@@ -3192,10 +3172,7 @@
 #endif
        jitSignature = jit_function_get_signature(ancestorInfo->jitFunction);
 
-       if(!_ILJitSetMethodInfo(jitCoder, method, jitSignature))
-       {
-               return 0;
-       }
+       _ILJitSetMethodInfo(jitCoder, method, jitSignature);
 
        /* are we ready now ? */
 

Index: engine/jitc_call.c
===================================================================
RCS file: /sources/dotgnu-pnet/pnet/engine/jitc_call.c,v
retrieving revision 1.18
retrieving revision 1.19
diff -u -b -r1.18 -r1.19
--- engine/jitc_call.c  4 Jun 2006 19:33:10 -0000       1.18
+++ engine/jitc_call.c  10 Jun 2006 12:38:45 -0000      1.19
@@ -561,6 +561,15 @@
 
 static void JITCoder_CheckCallNull(ILCoder *coder, ILCoderMethodInfo *info)
 {
+       ILJITCoder *jitCoder = _ILCoderToILJITCoder(coder);
+       ILUInt32 numArgs = info->numBaseArgs + info->numVarArgs;
+
+       if(info->hasParamArray)
+       {
+               /* Account for the vararg parameter array on the stack */
+               ++numArgs;
+       }
+       _ILJitCheckNull(jitCoder, jitCoder->jitStack[jitCoder->stackTop - 
numArgs]);
 }
 
 static void JITCoder_CallMethod(ILCoder *coder, ILCoderMethodInfo *info,
@@ -1169,6 +1178,457 @@
                }
                /* Not reached */
 
+               /*
+                * Cases for Math class inlines.
+                */
+               case IL_INLINEMETHOD_ABS_I4:
+               {
+                       ILJitValue value = 
jitCoder->jitStack[jitCoder->stackTop - 1];
+
+                       value = 
_ILJitValueConvertImplicit(jitCoder->jitFunction,
+                                                                               
           value,
+                                                                               
           _IL_JIT_TYPE_INT32);
+                       value = jit_insn_abs(jitCoder->jitFunction, value);
+                       value = 
_ILJitValueConvertToStackType(jitCoder->jitFunction,
+                                                                               
                  value);
+                       
+                       jitCoder->jitStack[jitCoder->stackTop - 1] = value;
+                       return 1;
+               }
+               /* Not reached */
+
+               case IL_INLINEMETHOD_ABS_R4:
+               {
+                       ILJitValue value = 
jitCoder->jitStack[jitCoder->stackTop - 1];
+
+                       value = 
_ILJitValueConvertImplicit(jitCoder->jitFunction,
+                                                                               
           value,
+                                                                               
           _IL_JIT_TYPE_SINGLE);
+                       value = jit_insn_abs(jitCoder->jitFunction, value);
+                       value = 
_ILJitValueConvertToStackType(jitCoder->jitFunction,
+                                                                               
                  value);
+                       
+                       jitCoder->jitStack[jitCoder->stackTop - 1] = value;
+                       return 1;
+               }
+               /* Not reached */
+
+               case IL_INLINEMETHOD_ABS_R8:
+               {
+                       ILJitValue value = 
jitCoder->jitStack[jitCoder->stackTop - 1];
+
+                       value = 
_ILJitValueConvertImplicit(jitCoder->jitFunction,
+                                                                               
           value,
+                                                                               
           _IL_JIT_TYPE_DOUBLE);
+                       value = jit_insn_abs(jitCoder->jitFunction, value);
+                       value = 
_ILJitValueConvertToStackType(jitCoder->jitFunction,
+                                                                               
                  value);
+                       
+                       jitCoder->jitStack[jitCoder->stackTop - 1] = value;
+                       return 1;
+               }
+               /* Not reached */
+
+               case IL_INLINEMETHOD_ASIN:
+               {
+                       ILJitValue value = 
jitCoder->jitStack[jitCoder->stackTop - 1];
+
+                       value = 
_ILJitValueConvertImplicit(jitCoder->jitFunction,
+                                                                               
           value,
+                                                                               
           _IL_JIT_TYPE_DOUBLE);
+                       value = jit_insn_asin(jitCoder->jitFunction, value);
+                       value = 
_ILJitValueConvertToStackType(jitCoder->jitFunction,
+                                                                               
                  value);
+                       
+                       jitCoder->jitStack[jitCoder->stackTop - 1] = value;
+                       return 1;
+               }
+               /* Not reached */
+
+               case IL_INLINEMETHOD_ATAN:
+               {
+                       ILJitValue value = 
jitCoder->jitStack[jitCoder->stackTop - 1];
+
+                       value = 
_ILJitValueConvertImplicit(jitCoder->jitFunction,
+                                                                               
           value,
+                                                                               
           _IL_JIT_TYPE_DOUBLE);
+                       value = jit_insn_atan(jitCoder->jitFunction, value);
+                       value = 
_ILJitValueConvertToStackType(jitCoder->jitFunction,
+                                                                               
                  value);
+                       
+                       jitCoder->jitStack[jitCoder->stackTop - 1] = value;
+                       return 1;
+               }
+               /* Not reached */
+
+               case IL_INLINEMETHOD_ATAN2:
+               {
+                       return 0;
+               }
+               /* Not reached */
+
+               case IL_INLINEMETHOD_CEILING:
+               {
+                       ILJitValue value = 
jitCoder->jitStack[jitCoder->stackTop - 1];
+
+                       value = 
_ILJitValueConvertImplicit(jitCoder->jitFunction,
+                                                                               
           value,
+                                                                               
           _IL_JIT_TYPE_DOUBLE);
+                       value = jit_insn_ceil(jitCoder->jitFunction, value);
+                       value = 
_ILJitValueConvertToStackType(jitCoder->jitFunction,
+                                                                               
                  value);
+                       
+                       jitCoder->jitStack[jitCoder->stackTop - 1] = value;
+                       return 1;
+               }
+               /* Not reached */
+
+               case IL_INLINEMETHOD_COS:
+               {
+                       ILJitValue value = 
jitCoder->jitStack[jitCoder->stackTop - 1];
+
+                       value = 
_ILJitValueConvertImplicit(jitCoder->jitFunction,
+                                                                               
           value,
+                                                                               
           _IL_JIT_TYPE_DOUBLE);
+                       value = jit_insn_cos(jitCoder->jitFunction, value);
+                       value = 
_ILJitValueConvertToStackType(jitCoder->jitFunction,
+                                                                               
                  value);
+                       
+                       jitCoder->jitStack[jitCoder->stackTop - 1] = value;
+                       return 1;
+               }
+               /* Not reached */
+
+               case IL_INLINEMETHOD_COSH:
+               {
+                       ILJitValue value = 
jitCoder->jitStack[jitCoder->stackTop - 1];
+
+                       value = 
_ILJitValueConvertImplicit(jitCoder->jitFunction,
+                                                                               
           value,
+                                                                               
           _IL_JIT_TYPE_DOUBLE);
+                       value = jit_insn_cosh(jitCoder->jitFunction, value);
+                       value = 
_ILJitValueConvertToStackType(jitCoder->jitFunction,
+                                                                               
                  value);
+                       
+                       jitCoder->jitStack[jitCoder->stackTop - 1] = value;
+                       return 1;
+               }
+               /* Not reached */
+
+               case IL_INLINEMETHOD_EXP:
+               {
+                       ILJitValue value = 
jitCoder->jitStack[jitCoder->stackTop - 1];
+
+                       value = 
_ILJitValueConvertImplicit(jitCoder->jitFunction,
+                                                                               
           value,
+                                                                               
           _IL_JIT_TYPE_DOUBLE);
+                       value = jit_insn_exp(jitCoder->jitFunction, value);
+                       value = 
_ILJitValueConvertToStackType(jitCoder->jitFunction,
+                                                                               
                  value);
+                       
+                       jitCoder->jitStack[jitCoder->stackTop - 1] = value;
+                       return 1;
+               }
+               /* Not reached */
+
+               case IL_INLINEMETHOD_FLOOR:
+               {
+                       ILJitValue value = 
jitCoder->jitStack[jitCoder->stackTop - 1];
+
+                       value = 
_ILJitValueConvertImplicit(jitCoder->jitFunction,
+                                                                               
           value,
+                                                                               
           _IL_JIT_TYPE_DOUBLE);
+                       value = jit_insn_floor(jitCoder->jitFunction, value);
+                       value = 
_ILJitValueConvertToStackType(jitCoder->jitFunction,
+                                                                               
                  value);
+                       
+                       jitCoder->jitStack[jitCoder->stackTop - 1] = value;
+                       return 1;
+               }
+               /* Not reached */
+
+               case IL_INLINEMETHOD_IEEEREMAINDER:
+               {
+                       return 0;
+               }
+               /* Not reached */
+
+               case IL_INLINEMETHOD_LOG:
+               {
+                       ILJitValue value = 
jitCoder->jitStack[jitCoder->stackTop - 1];
+
+                       value = 
_ILJitValueConvertImplicit(jitCoder->jitFunction,
+                                                                               
           value,
+                                                                               
           _IL_JIT_TYPE_DOUBLE);
+                       value = jit_insn_log(jitCoder->jitFunction, value);
+                       value = 
_ILJitValueConvertToStackType(jitCoder->jitFunction,
+                                                                               
                  value);
+                       
+                       jitCoder->jitStack[jitCoder->stackTop - 1] = value;
+                       return 1;
+               }
+               /* Not reached */
+
+               case IL_INLINEMETHOD_LOG10:
+               {
+                       ILJitValue value = 
jitCoder->jitStack[jitCoder->stackTop - 1];
+
+                       value = 
_ILJitValueConvertImplicit(jitCoder->jitFunction,
+                                                                               
           value,
+                                                                               
           _IL_JIT_TYPE_DOUBLE);
+                       value = jit_insn_log10(jitCoder->jitFunction, value);
+                       value = 
_ILJitValueConvertToStackType(jitCoder->jitFunction,
+                                                                               
                  value);
+                       
+                       jitCoder->jitStack[jitCoder->stackTop - 1] = value;
+                       return 1;
+               }
+               /* Not reached */
+
+               case IL_INLINEMETHOD_MAX_I4:
+               {
+                       ILJitValue value1 = 
jitCoder->jitStack[jitCoder->stackTop - 2];
+                       ILJitValue value2 = 
jitCoder->jitStack[jitCoder->stackTop - 1];
+                       ILJitValue result;
+
+                       value1 = 
_ILJitValueConvertImplicit(jitCoder->jitFunction,
+                                                                               
           value1,
+                                                                               
           _IL_JIT_TYPE_INT32);
+                       value2 = 
_ILJitValueConvertImplicit(jitCoder->jitFunction,
+                                                                               
           value2,
+                                                                               
           _IL_JIT_TYPE_INT32);
+                       result = jit_insn_max(jitCoder->jitFunction, value1, 
value2);
+                       result = 
_ILJitValueConvertToStackType(jitCoder->jitFunction,
+                                                                               
                   result);
+                       
+                       /* Pop one value from the stack. */
+                       JITC_ADJUST(jitCoder, -1);
+
+                       /* and replace the second one with the result. */
+                       jitCoder->jitStack[jitCoder->stackTop - 1] = result;
+                       return 1;
+               }
+               /* Not reached */
+
+               case IL_INLINEMETHOD_MIN_I4:
+               {
+                       ILJitValue value1 = 
jitCoder->jitStack[jitCoder->stackTop - 2];
+                       ILJitValue value2 = 
jitCoder->jitStack[jitCoder->stackTop - 1];
+                       ILJitValue result;
+
+                       value1 = 
_ILJitValueConvertImplicit(jitCoder->jitFunction,
+                                                                               
           value1,
+                                                                               
           _IL_JIT_TYPE_INT32);
+                       value2 = 
_ILJitValueConvertImplicit(jitCoder->jitFunction,
+                                                                               
           value2,
+                                                                               
           _IL_JIT_TYPE_INT32);
+                       result = jit_insn_min(jitCoder->jitFunction, value1, 
value2);
+                       result = 
_ILJitValueConvertToStackType(jitCoder->jitFunction,
+                                                                               
                   result);
+                       
+                       /* Pop one value from the stack. */
+                       JITC_ADJUST(jitCoder, -1);
+
+                       /* and replace the second one with the result. */
+                       jitCoder->jitStack[jitCoder->stackTop - 1] = result;
+                       return 1;
+               }
+               /* Not reached */
+
+               case IL_INLINEMETHOD_MAX_R4:
+               {
+                       ILJitValue value1 = 
jitCoder->jitStack[jitCoder->stackTop - 2];
+                       ILJitValue value2 = 
jitCoder->jitStack[jitCoder->stackTop - 1];
+                       ILJitValue result;
+
+                       value1 = 
_ILJitValueConvertImplicit(jitCoder->jitFunction,
+                                                                               
           value1,
+                                                                               
           _IL_JIT_TYPE_SINGLE);
+                       value2 = 
_ILJitValueConvertImplicit(jitCoder->jitFunction,
+                                                                               
           value2,
+                                                                               
           _IL_JIT_TYPE_SINGLE);
+                       result = jit_insn_max(jitCoder->jitFunction, value1, 
value2);
+                       result = 
_ILJitValueConvertToStackType(jitCoder->jitFunction,
+                                                                               
                   result);
+                       
+                       /* Pop one value from the stack. */
+                       JITC_ADJUST(jitCoder, -1);
+
+                       /* and replace the second one with the result. */
+                       jitCoder->jitStack[jitCoder->stackTop - 1] = result;
+                       return 1;
+               }
+               /* Not reached */
+
+               case IL_INLINEMETHOD_MIN_R4:
+               {
+                       ILJitValue value1 = 
jitCoder->jitStack[jitCoder->stackTop - 2];
+                       ILJitValue value2 = 
jitCoder->jitStack[jitCoder->stackTop - 1];
+                       ILJitValue result;
+
+                       value1 = 
_ILJitValueConvertImplicit(jitCoder->jitFunction,
+                                                                               
           value1,
+                                                                               
           _IL_JIT_TYPE_SINGLE);
+                       value2 = 
_ILJitValueConvertImplicit(jitCoder->jitFunction,
+                                                                               
           value2,
+                                                                               
           _IL_JIT_TYPE_SINGLE);
+                       result = jit_insn_min(jitCoder->jitFunction, value1, 
value2);
+                       result = 
_ILJitValueConvertToStackType(jitCoder->jitFunction,
+                                                                               
                   result);
+                       
+                       /* Pop one value from the stack. */
+                       JITC_ADJUST(jitCoder, -1);
+
+                       /* and replace the second one with the result. */
+                       jitCoder->jitStack[jitCoder->stackTop - 1] = result;
+                       return 1;
+               }
+               /* Not reached */
+
+               case IL_INLINEMETHOD_MAX_R8:
+               {
+                       ILJitValue value1 = 
jitCoder->jitStack[jitCoder->stackTop - 2];
+                       ILJitValue value2 = 
jitCoder->jitStack[jitCoder->stackTop - 1];
+                       ILJitValue result;
+
+                       value1 = 
_ILJitValueConvertImplicit(jitCoder->jitFunction,
+                                                                               
           value1,
+                                                                               
           _IL_JIT_TYPE_DOUBLE);
+                       value2 = 
_ILJitValueConvertImplicit(jitCoder->jitFunction,
+                                                                               
           value2,
+                                                                               
           _IL_JIT_TYPE_DOUBLE);
+                       result = jit_insn_max(jitCoder->jitFunction, value1, 
value2);
+                       result = 
_ILJitValueConvertToStackType(jitCoder->jitFunction,
+                                                                               
                   result);
+                       
+                       /* Pop one value from the stack. */
+                       JITC_ADJUST(jitCoder, -1);
+
+                       /* and replace the second one with the result. */
+                       jitCoder->jitStack[jitCoder->stackTop - 1] = result;
+                       return 1;
+               }
+               /* Not reached */
+
+               case IL_INLINEMETHOD_MIN_R8:
+               {
+                       ILJitValue value1 = 
jitCoder->jitStack[jitCoder->stackTop - 2];
+                       ILJitValue value2 = 
jitCoder->jitStack[jitCoder->stackTop - 1];
+                       ILJitValue result;
+
+                       value1 = 
_ILJitValueConvertImplicit(jitCoder->jitFunction,
+                                                                               
           value1,
+                                                                               
           _IL_JIT_TYPE_DOUBLE);
+                       value2 = 
_ILJitValueConvertImplicit(jitCoder->jitFunction,
+                                                                               
           value2,
+                                                                               
           _IL_JIT_TYPE_DOUBLE);
+                       result = jit_insn_min(jitCoder->jitFunction, value1, 
value2);
+                       result = 
_ILJitValueConvertToStackType(jitCoder->jitFunction,
+                                                                               
                   result);
+                       
+                       /* Pop one value from the stack. */
+                       JITC_ADJUST(jitCoder, -1);
+
+                       /* and replace the second one with the result. */
+                       jitCoder->jitStack[jitCoder->stackTop - 1] = result;
+                       return 1;
+               }
+               /* Not reached */
+
+               case IL_INLINEMETHOD_POW:
+               case IL_INLINEMETHOD_ROUND:
+               {
+                       return 0;
+               }
+               /* Not reached */
+
+               case IL_INLINEMETHOD_SIN:
+               {
+                       ILJitValue value = 
jitCoder->jitStack[jitCoder->stackTop - 1];
+
+                       value = 
_ILJitValueConvertImplicit(jitCoder->jitFunction,
+                                                                               
           value,
+                                                                               
           _IL_JIT_TYPE_DOUBLE);
+                       value = jit_insn_sin(jitCoder->jitFunction, value);
+                       value = 
_ILJitValueConvertToStackType(jitCoder->jitFunction,
+                                                                               
                  value);
+                       
+                       jitCoder->jitStack[jitCoder->stackTop - 1] = value;
+                       return 1;
+               }
+               /* Not reached */
+
+               case IL_INLINEMETHOD_SIGN_I4:
+               case IL_INLINEMETHOD_SIGN_R4:
+               case IL_INLINEMETHOD_SIGN_R8:
+               {
+                       return 0;
+               }
+               /* Not reached */
+
+               case IL_INLINEMETHOD_SINH:
+               {
+                       ILJitValue value = 
jitCoder->jitStack[jitCoder->stackTop - 1];
+
+                       value = 
_ILJitValueConvertImplicit(jitCoder->jitFunction,
+                                                                               
           value,
+                                                                               
           _IL_JIT_TYPE_DOUBLE);
+                       value = jit_insn_sinh(jitCoder->jitFunction, value);
+                       value = 
_ILJitValueConvertToStackType(jitCoder->jitFunction,
+                                                                               
                  value);
+                       
+                       jitCoder->jitStack[jitCoder->stackTop - 1] = value;
+                       return 1;
+               }
+               /* Not reached */
+
+               case IL_INLINEMETHOD_SQRT:
+               {
+                       ILJitValue value = 
jitCoder->jitStack[jitCoder->stackTop - 1];
+
+                       value = 
_ILJitValueConvertImplicit(jitCoder->jitFunction,
+                                                                               
           value,
+                                                                               
           _IL_JIT_TYPE_DOUBLE);
+                       value = jit_insn_sqrt(jitCoder->jitFunction, value);
+                       value = 
_ILJitValueConvertToStackType(jitCoder->jitFunction,
+                                                                               
                  value);
+                       
+                       jitCoder->jitStack[jitCoder->stackTop - 1] = value;
+                       return 1;
+               }
+               /* Not reached */
+
+               case IL_INLINEMETHOD_TAN:
+               {
+                       ILJitValue value = 
jitCoder->jitStack[jitCoder->stackTop - 1];
+
+                       value = 
_ILJitValueConvertImplicit(jitCoder->jitFunction,
+                                                                               
           value,
+                                                                               
           _IL_JIT_TYPE_DOUBLE);
+                       value = jit_insn_tan(jitCoder->jitFunction, value);
+                       value = 
_ILJitValueConvertToStackType(jitCoder->jitFunction,
+                                                                               
                  value);
+                       
+                       jitCoder->jitStack[jitCoder->stackTop - 1] = value;
+                       return 1;
+               }
+               /* Not reached */
+
+               case IL_INLINEMETHOD_TANH:
+               {
+                       ILJitValue value = 
jitCoder->jitStack[jitCoder->stackTop - 1];
+
+                       value = 
_ILJitValueConvertImplicit(jitCoder->jitFunction,
+                                                                               
           value,
+                                                                               
           _IL_JIT_TYPE_DOUBLE);
+                       value = jit_insn_tanh(jitCoder->jitFunction, value);
+                       value = 
_ILJitValueConvertToStackType(jitCoder->jitFunction,
+                                                                               
                  value);
+                       
+                       jitCoder->jitStack[jitCoder->stackTop - 1] = value;
+                       return 1;
+               }
+               /* Not reached */
        }
        /* If we get here, then we don't know how to inline the method */
        return 0;




reply via email to

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