[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[dotgnu-pnet-commits] pnet ./ChangeLog engine/jitc.c engine/jitc.h en...
|
From: |
Klaus Treichel |
|
Subject: |
[dotgnu-pnet-commits] pnet ./ChangeLog engine/jitc.c engine/jitc.h en... |
|
Date: |
Wed, 04 Jan 2006 18:54:39 +0000 |
CVSROOT: /cvsroot/dotgnu-pnet
Module name: pnet
Branch:
Changes by: Klaus Treichel <address@hidden> 06/01/04 18:54:39
Modified files:
. : ChangeLog
engine : jitc.c jitc.h jitc_branch.c jitc_conv.c
jitc_ptr.c
Log message:
Add more of the jit coder.
CVSWeb URLs:
http://cvs.savannah.gnu.org/viewcvs/dotgnu-pnet/pnet/ChangeLog.diff?tr1=1.3266&tr2=1.3267&r1=text&r2=text
http://cvs.savannah.gnu.org/viewcvs/dotgnu-pnet/pnet/engine/jitc.c.diff?tr1=1.7&tr2=1.8&r1=text&r2=text
http://cvs.savannah.gnu.org/viewcvs/dotgnu-pnet/pnet/engine/jitc.h.diff?tr1=1.5&tr2=1.6&r1=text&r2=text
http://cvs.savannah.gnu.org/viewcvs/dotgnu-pnet/pnet/engine/jitc_branch.c.diff?tr1=1.3&tr2=1.4&r1=text&r2=text
http://cvs.savannah.gnu.org/viewcvs/dotgnu-pnet/pnet/engine/jitc_conv.c.diff?tr1=1.1&tr2=1.2&r1=text&r2=text
http://cvs.savannah.gnu.org/viewcvs/dotgnu-pnet/pnet/engine/jitc_ptr.c.diff?tr1=1.1&tr2=1.2&r1=text&r2=text
Patches:
Index: pnet/ChangeLog
diff -u pnet/ChangeLog:1.3266 pnet/ChangeLog:1.3267
--- pnet/ChangeLog:1.3266 Mon Jan 2 11:39:23 2006
+++ pnet/ChangeLog Wed Jan 4 18:54:38 2006
@@ -1,3 +1,9 @@
+2006-01-04 Klaus Treichel <address@hidden>
+
+ * engine/jitc.c, engine/jitc.h, engine/jitc_branch.c,
engine/jitc_conv.c,
+ engine/jitc_ptr.c: Implement the type conversion opcodes, the array
stuff
+ and some other pointer related opcodes.
+.
2006-01-02 Klaus Treichel <address@hidden>
* engine/jitc_stack.c: Implement JITCoder_StackRefresh.
Index: pnet/engine/jitc.c
diff -u pnet/engine/jitc.c:1.7 pnet/engine/jitc.c:1.8
--- pnet/engine/jitc.c:1.7 Fri Dec 30 17:42:19 2005
+++ pnet/engine/jitc.c Wed Jan 4 18:54:39 2006
@@ -459,10 +459,10 @@
_ILJitTypesInitBase(&_ILJitType_VPTR, jit_type_void_ptr);
/* Initialize the native method signatures. */
- args[0] = jit_type_void_ptr;
- args[1] = jit_type_void_ptr;
+ args[0] = _IL_JIT_TYPE_VPTR;
+ args[1] = _IL_JIT_TYPE_VPTR;
args[2] = jit_type_int;
- returnType = jit_type_void_ptr;
+ returnType = _IL_JIT_TYPE_VPTR;
if(!(_ILJitSignature_ILEngineAlloc =
jit_type_create_signature(IL_JIT_CALLCONV_CDECL, returnType,
args, 3, 1)))
{
@@ -562,6 +562,8 @@
jit_context_destroy(coder->context);
coder->context = 0;
}
+ ILMemPoolDestroy(&(coder->labelPool));
+
ILFree(coder);
}
@@ -673,15 +675,23 @@
#endif /* IL_CONFIG_PINVOKE */
/*
+ * Set the method member in the ILExecThread instance.
+ */
+static void SetMethodInThread(jit_function_t func, ILJitValue thread, ILMethod
*method)
+{
+ ILJitValue methodPtr = jit_value_create_nint_constant(func,
_IL_JIT_TYPE_VPTR, (jit_nint)method);
+
+ jit_insn_store_relative(func, thread, offsetof(ILExecThread, method),
methodPtr);
+}
+
+/*
* Generate the stub for calling an internal function.
*/
static int _ILJitCompileInternal(jit_function_t func, ILMethod *method, void
*nativeFunction)
{
ILJitType signature = jit_function_get_signature(func);
- ILJitType returnType = jit_type_get_return(signature);
unsigned int numParams = jit_type_num_params(signature);
ILJitValue returnValue;
- ILJitValue methodPtr = jit_value_create_nint_constant(func,
jit_type_void_ptr, (jit_nint)method);
/* We need to set the method member in the ILExecThread == arg[0]. */
if(numParams > 0)
@@ -696,7 +706,7 @@
return JIT_RESULT_OUT_OF_MEMORY;
}
}
- jit_insn_store_relative(func, jitParams[0],
offsetof(ILExecThread, method), methodPtr);
+ SetMethodInThread(func, jitParams[0], method);
returnValue = jit_insn_call_native(func, 0, nativeFunction,
signature, jitParams, numParams, 0);
}
else
Index: pnet/engine/jitc.h
diff -u pnet/engine/jitc.h:1.5 pnet/engine/jitc.h:1.6
--- pnet/engine/jitc.h:1.5 Fri Dec 30 17:42:19 2005
+++ pnet/engine/jitc.h Wed Jan 4 18:54:39 2006
@@ -43,7 +43,7 @@
#define _IL_JIT_TYPE_UINT32 jit_type_uint
#define _IL_JIT_TYPE_UINT64 jit_type_ulong
#define _IL_JIT_TYPE_NUINT jit_type_nuint
-#define _IL_JIT_TYPE_VPTR jit_type_void_ptr;
+#define _IL_JIT_TYPE_VPTR jit_type_void_ptr
/*
* Definition of method metadata indexes.
Index: pnet/engine/jitc_branch.c
diff -u pnet/engine/jitc_branch.c:1.3 pnet/engine/jitc_branch.c:1.4
--- pnet/engine/jitc_branch.c:1.3 Sat Dec 31 09:16:04 2005
+++ pnet/engine/jitc_branch.c Wed Jan 4 18:54:39 2006
@@ -227,7 +227,7 @@
{
/* Test two values for equality */
AdjustMixedBinary(coder, 0, value1, value2);
- return jit_insn_eq(coder->jitFunction, *value2,
*value1);
+ return jit_insn_eq(coder->jitFunction, *value1,
*value2);
}
break;
@@ -235,7 +235,7 @@
{
/* Test two unsigned values for inequality */
AdjustMixedBinary(coder, 1, value1, value2);
- return jit_insn_ne(coder->jitFunction, *value2,
*value1);
+ return jit_insn_ne(coder->jitFunction, *value1,
*value2);
}
break;
@@ -244,7 +244,7 @@
{
/* Test two signed values for greater than */
AdjustMixedBinary(coder, 0, value1, value2);
- return jit_insn_gt(coder->jitFunction, *value2,
*value1);
+ return jit_insn_gt(coder->jitFunction, *value1,
*value2);
}
break;
@@ -253,7 +253,7 @@
{
/* Test two unsigned values for greater than */
AdjustMixedBinary(coder, 1, value1, value2);
- return jit_insn_gt(coder->jitFunction, *value2,
*value1);
+ return jit_insn_gt(coder->jitFunction, *value1,
*value2);
}
break;
@@ -261,7 +261,7 @@
{
/* Test two signed values for greater than or equal */
AdjustMixedBinary(coder, 0, value1, value2);
- return jit_insn_ge(coder->jitFunction, *value2,
*value1);
+ return jit_insn_ge(coder->jitFunction, *value1,
*value2);
}
break;
@@ -269,7 +269,7 @@
{
/* Test two unsigned values for greater than or equal
*/
AdjustMixedBinary(coder, 1, value1, value2);
- return jit_insn_ge(coder->jitFunction, *value2,
*value1);
+ return jit_insn_ge(coder->jitFunction, *value1,
*value2);
}
break;
@@ -278,7 +278,7 @@
{
/* Test two signed values for less than */
AdjustMixedBinary(coder, 0, value1, value2);
- return jit_insn_lt(coder->jitFunction, *value2,
*value1);
+ return jit_insn_lt(coder->jitFunction, *value1,
*value2);
}
break;
@@ -287,7 +287,7 @@
{
/* Test two unsigned values for less than */
AdjustMixedBinary(coder, 1, value1, value2);
- return jit_insn_lt(coder->jitFunction, *value2,
*value1);
+ return jit_insn_lt(coder->jitFunction, *value1,
*value2);
}
break;
@@ -295,7 +295,7 @@
{
/* Test two signed values for less than or equal */
AdjustMixedBinary(coder, 0, value1, value2);
- return jit_insn_le(coder->jitFunction, *value2,
*value1);
+ return jit_insn_le(coder->jitFunction, *value1,
*value2);
}
break;
@@ -303,7 +303,7 @@
{
/* Test two unsigned values for less than or equal */
AdjustMixedBinary(coder, 1, value1, value2);
- return jit_insn_lt(coder->jitFunction, *value2,
*value1);
+ return jit_insn_lt(coder->jitFunction, *value1,
*value2);
}
break;
}
@@ -360,8 +360,8 @@
{
/* Equality testing branch */
temp = OutputCompare(jitCoder, IL_OP_BEQ,
-
&(jitCoder->jitStack[jitCoder->stackTop - 1]),
-
&(jitCoder->jitStack[jitCoder->stackTop - 2]));
+
&(jitCoder->jitStack[jitCoder->stackTop - 2]),
+
&(jitCoder->jitStack[jitCoder->stackTop - 1]));
jit_insn_branch_if(jitCoder->jitFunction, temp,
&(label->label));
JITC_ADJUST(jitCoder, -2);
}
@@ -372,8 +372,8 @@
{
/* Unsigned inequality testing branch */
temp = OutputCompare(jitCoder, IL_OP_BNE_UN,
-
&(jitCoder->jitStack[jitCoder->stackTop - 1]),
-
&(jitCoder->jitStack[jitCoder->stackTop - 2]));
+
&(jitCoder->jitStack[jitCoder->stackTop - 2]),
+
&(jitCoder->jitStack[jitCoder->stackTop - 1]));
jit_insn_branch_if(jitCoder->jitFunction, temp,
&(label->label));
JITC_ADJUST(jitCoder, -2);
}
@@ -384,8 +384,8 @@
{
/* Signed greater than testing branch */
temp = OutputCompare(jitCoder, IL_OP_BGT,
-
&(jitCoder->jitStack[jitCoder->stackTop - 1]),
-
&(jitCoder->jitStack[jitCoder->stackTop - 2]));
+
&(jitCoder->jitStack[jitCoder->stackTop - 2]),
+
&(jitCoder->jitStack[jitCoder->stackTop - 1]));
jit_insn_branch_if(jitCoder->jitFunction, temp,
&(label->label));
JITC_ADJUST(jitCoder, -2);
}
@@ -396,8 +396,8 @@
{
/* Unsigned greater than testing branch */
temp = OutputCompare(jitCoder, IL_OP_BGT_UN,
-
&(jitCoder->jitStack[jitCoder->stackTop - 1]),
-
&(jitCoder->jitStack[jitCoder->stackTop - 2]));
+
&(jitCoder->jitStack[jitCoder->stackTop - 2]),
+
&(jitCoder->jitStack[jitCoder->stackTop - 1]));
jit_insn_branch_if(jitCoder->jitFunction, temp,
&(label->label));
JITC_ADJUST(jitCoder, -2);
}
@@ -408,8 +408,8 @@
{
/* Signed greater than or equal testing branch */
temp = OutputCompare(jitCoder, IL_OP_BGE,
-
&(jitCoder->jitStack[jitCoder->stackTop - 1]),
-
&(jitCoder->jitStack[jitCoder->stackTop - 2]));
+
&(jitCoder->jitStack[jitCoder->stackTop - 2]),
+
&(jitCoder->jitStack[jitCoder->stackTop - 1]));
jit_insn_branch_if(jitCoder->jitFunction, temp,
&(label->label));
JITC_ADJUST(jitCoder, -2);
}
@@ -420,8 +420,8 @@
{
/* Unsigned greater than or equal testing branch */
temp = OutputCompare(jitCoder, IL_OP_BGE_UN,
-
&(jitCoder->jitStack[jitCoder->stackTop - 1]),
-
&(jitCoder->jitStack[jitCoder->stackTop - 2]));
+
&(jitCoder->jitStack[jitCoder->stackTop - 2]),
+
&(jitCoder->jitStack[jitCoder->stackTop - 1]));
jit_insn_branch_if(jitCoder->jitFunction, temp,
&(label->label));
JITC_ADJUST(jitCoder, -2);
}
@@ -432,8 +432,8 @@
{
/* Signed less than testing branch */
temp = OutputCompare(jitCoder, IL_OP_BLT,
-
&(jitCoder->jitStack[jitCoder->stackTop - 1]),
-
&(jitCoder->jitStack[jitCoder->stackTop - 2]));
+
&(jitCoder->jitStack[jitCoder->stackTop - 2]),
+
&(jitCoder->jitStack[jitCoder->stackTop - 1]));
jit_insn_branch_if(jitCoder->jitFunction, temp,
&(label->label));
JITC_ADJUST(jitCoder, -2);
}
@@ -444,8 +444,8 @@
{
/* Unsigned less than testing branch */
temp = OutputCompare(jitCoder, IL_OP_BLT_UN,
-
&(jitCoder->jitStack[jitCoder->stackTop - 1]),
-
&(jitCoder->jitStack[jitCoder->stackTop - 2]));
+
&(jitCoder->jitStack[jitCoder->stackTop - 2]),
+
&(jitCoder->jitStack[jitCoder->stackTop - 1]));
jit_insn_branch_if(jitCoder->jitFunction, temp,
&(label->label));
JITC_ADJUST(jitCoder, -2);
}
@@ -456,8 +456,8 @@
{
/* Signed less than or equal testing branch */
temp = OutputCompare(jitCoder, IL_OP_BLE,
-
&(jitCoder->jitStack[jitCoder->stackTop - 1]),
-
&(jitCoder->jitStack[jitCoder->stackTop - 2]));
+
&(jitCoder->jitStack[jitCoder->stackTop - 2]),
+
&(jitCoder->jitStack[jitCoder->stackTop - 1]));
jit_insn_branch_if(jitCoder->jitFunction, temp,
&(label->label));
JITC_ADJUST(jitCoder, -2);
}
@@ -468,8 +468,8 @@
{
/* Unsigned less than or equal testing branch */
temp = OutputCompare(jitCoder, IL_OP_BLE_UN,
-
&(jitCoder->jitStack[jitCoder->stackTop - 1]),
-
&(jitCoder->jitStack[jitCoder->stackTop - 2]));
+
&(jitCoder->jitStack[jitCoder->stackTop - 2]),
+
&(jitCoder->jitStack[jitCoder->stackTop - 1]));
jit_insn_branch_if(jitCoder->jitFunction, temp,
&(label->label));
JITC_ADJUST(jitCoder, -2);
}
@@ -503,8 +503,8 @@
ILJitValue temp;
temp = OutputCompare(jitCoder, opcode,
-
&(jitCoder->jitStack[jitCoder->stackTop - 1]),
-
&(jitCoder->jitStack[jitCoder->stackTop - 2]));
+
&(jitCoder->jitStack[jitCoder->stackTop - 2]),
+
&(jitCoder->jitStack[jitCoder->stackTop - 1]));
if(invertTest)
{
temp = jit_insn_to_not_bool(jitCoder->jitFunction, temp);
Index: pnet/engine/jitc_conv.c
diff -u pnet/engine/jitc_conv.c:1.1 pnet/engine/jitc_conv.c:1.2
--- pnet/engine/jitc_conv.c:1.1 Mon Dec 19 18:00:35 2005
+++ pnet/engine/jitc_conv.c Wed Jan 4 18:54:39 2006
@@ -21,10 +21,515 @@
#ifdef IL_JITC_CODE
/*
+ * Make sure that the given value is signed or unsigned.
+ * Does a conversion if necessairy and returns the converted item
+ * or returns the item as it is.
+ */
+static ILJitValue ConvertSign(ILJITCoder *jitCoder, ILJitValue value,
+ int isUnsigned, int
checkOverflow)
+{
+ ILJitType type = jit_value_get_type(value);
+
+ type = jit_type_normalize(type);
+
+ if(isUnsigned)
+ {
+ if(type == _IL_JIT_TYPE_INT32)
+ {
+ return jit_insn_convert(jitCoder->jitFunction,
+ value,
+
_IL_JIT_TYPE_UINT32,
+
checkOverflow);
+ }
+ else if(type == _IL_JIT_TYPE_INT64)
+ {
+ return jit_insn_convert(jitCoder->jitFunction,
+ value,
+
_IL_JIT_TYPE_UINT64,
+
checkOverflow);
+ }
+ }
+ else
+ {
+ if(type == _IL_JIT_TYPE_UINT32)
+ {
+ return jit_insn_convert(jitCoder->jitFunction,
+ value,
+
_IL_JIT_TYPE_INT32,
+
checkOverflow);
+ }
+ else if(type == _IL_JIT_TYPE_UINT64)
+ {
+ return jit_insn_convert(jitCoder->jitFunction,
+ value,
+
_IL_JIT_TYPE_INT64,
+
checkOverflow);
+ }
+ }
+ return value;
+}
+
+/*
+ * Convert the topmost stackitem according to the given opcode.
+ * When unsigned is 0 then a sign extension will be done.
+ * When checkOberflow is not 0 then an overflow check will be done.
+ * The converted value will be returned.
+ */
+static ILJitValue ConvertValue(ILJITCoder *jitCoder, int opcode, int
isUnsigned,
+
int checkOverflow)
+{
+ ILJitValue value = jitCoder->jitStack[jitCoder->stackTop - 1];
+
+ value = ConvertSign(jitCoder, value, isUnsigned, checkOverflow);
+ switch(opcode)
+ {
+ case IL_OP_CONV_I1:
+ {
+ /* Convert to "int8" */
+ return jit_insn_convert(jitCoder->jitFunction,
+ value,
+
_IL_JIT_TYPE_SBYTE,
+
checkOverflow);
+ }
+ break;
+
+ case IL_OP_CONV_I2:
+ {
+ /* Convert to "int16" */
+ return jit_insn_convert(jitCoder->jitFunction,
+ value,
+
_IL_JIT_TYPE_INT16,
+
checkOverflow);
+ }
+ break;
+
+ case IL_OP_CONV_I4:
+ #ifdef IL_NATIVE_INT32
+ case IL_OP_CONV_I:
+ #endif
+ {
+ /* Convert to "int32" */
+ return jit_insn_convert(jitCoder->jitFunction,
+ value,
+
_IL_JIT_TYPE_INT32,
+
checkOverflow);
+
+ }
+ break;
+
+ case IL_OP_CONV_I8:
+ #ifdef IL_NATIVE_INT64
+ case IL_OP_CONV_I:
+ #endif
+ {
+ /* Convert to "int64" */
+ return jit_insn_convert(jitCoder->jitFunction,
+ value,
+
_IL_JIT_TYPE_INT64,
+
checkOverflow);
+ }
+ break;
+
+ case IL_OP_CONV_R4:
+ {
+ /* Convert to "float32" */
+ return jit_insn_convert(jitCoder->jitFunction,
+ value,
+
_IL_JIT_TYPE_SINGLE,
+
checkOverflow);
+ }
+ break;
+
+ case IL_OP_CONV_R8:
+ {
+ /* Convert to "float64" */
+ return jit_insn_convert(jitCoder->jitFunction,
+ value,
+
_IL_JIT_TYPE_DOUBLE,
+
checkOverflow);
+ }
+ break;
+
+ case IL_OP_CONV_U1:
+ {
+ /* Convert to "unsigned int8" */
+ return jit_insn_convert(jitCoder->jitFunction,
+ value,
+
_IL_JIT_TYPE_BYTE,
+
checkOverflow);
+ }
+ break;
+
+ case IL_OP_CONV_U2:
+ {
+ /* Convert to "unsigned int16" */
+ return jit_insn_convert(jitCoder->jitFunction,
+ value,
+
_IL_JIT_TYPE_UINT16,
+
checkOverflow);
+ }
+ break;
+
+ case IL_OP_CONV_U4:
+ #ifdef IL_NATIVE_INT32
+ case IL_OP_CONV_U:
+ #endif
+ {
+ /* Convert to "unsigned int32" */
+ return jit_insn_convert(jitCoder->jitFunction,
+ value,
+
_IL_JIT_TYPE_UINT32,
+
checkOverflow);
+ }
+ break;
+
+ case IL_OP_CONV_U8:
+ #ifdef IL_NATIVE_INT64
+ case IL_OP_CONV_U:
+ #endif
+ {
+ /* Convert to "unsigned int64" */
+ return jit_insn_convert(jitCoder->jitFunction,
+ value,
+
_IL_JIT_TYPE_UINT64,
+
checkOverflow);
+ }
+ break;
+
+ case IL_OP_CONV_R_UN:
+ {
+ /* Convert to "native float" with unsigned input */
+ return jit_insn_convert(jitCoder->jitFunction,
+ value,
+
_IL_JIT_TYPE_NFLOAT,
+
checkOverflow);
+ }
+ break;
+ }
+
+ /* Just to keep gcc happy. */
+ return value;
+}
+
+/*
* Handle a conversion opcode.
*/
static void JITCoder_Conv(ILCoder *coder, int opcode, ILEngineType type)
{
+ ILJITCoder *jitCoder = _ILCoderToILJITCoder(coder);
+ ILJitValue value;
+
+ /* Determine how to convert the value */
+ switch(opcode)
+ {
+ case IL_OP_CONV_I1:
+ {
+ /* Convert to "int8" */
+ value = ConvertValue(jitCoder, IL_OP_CONV_I1, 0, 0);
+ jitCoder->jitStack[jitCoder->stackTop - 1] =
+ jit_insn_convert(jitCoder->jitFunction,
+ value,
+
_IL_JIT_TYPE_INT32,
+ 0);
+ }
+ break;
+
+ case IL_OP_CONV_I2:
+ {
+ /* Convert to "int16" */
+ value = ConvertValue(jitCoder, IL_OP_CONV_I2, 0, 0);
+ jitCoder->jitStack[jitCoder->stackTop - 1] =
+ jit_insn_convert(jitCoder->jitFunction,
+ value,
+
_IL_JIT_TYPE_INT32,
+ 0);
+ }
+ break;
+
+ case IL_OP_CONV_I4:
+ #ifdef IL_NATIVE_INT32
+ case IL_OP_CONV_I:
+ #endif
+ {
+ /* Convert to "int32" */
+ value = ConvertValue(jitCoder, IL_OP_CONV_I4, 0, 0);
+ jitCoder->jitStack[jitCoder->stackTop - 1] = value;
+ }
+ break;
+
+ case IL_OP_CONV_I8:
+ #ifdef IL_NATIVE_INT64
+ case IL_OP_CONV_I:
+ #endif
+ {
+ /* Convert to "int64" */
+ value = ConvertValue(jitCoder, IL_OP_CONV_I8, 0, 0);
+ jitCoder->jitStack[jitCoder->stackTop - 1] = value;
+ }
+ break;
+
+ case IL_OP_CONV_R4:
+ {
+ /* Convert to "float32" */
+ value = ConvertValue(jitCoder, IL_OP_CONV_R4, 0, 0);
+ jitCoder->jitStack[jitCoder->stackTop - 1] =
+ jit_insn_convert(jitCoder->jitFunction,
+ value,
+
_IL_JIT_TYPE_NFLOAT,
+ 0);
+ }
+ break;
+
+ case IL_OP_CONV_R8:
+ {
+ /* Convert to "float64" */
+ value = ConvertValue(jitCoder, IL_OP_CONV_R8, 0, 0);
+ jitCoder->jitStack[jitCoder->stackTop - 1] =
+ jit_insn_convert(jitCoder->jitFunction,
+ value,
+
_IL_JIT_TYPE_NFLOAT,
+ 0);
+ }
+ break;
+
+ case IL_OP_CONV_U1:
+ {
+ /* Convert to "unsigned int8" */
+ value = ConvertValue(jitCoder, IL_OP_CONV_U1, 0, 0);
+ jitCoder->jitStack[jitCoder->stackTop - 1] =
+ jit_insn_convert(jitCoder->jitFunction,
+ value,
+
_IL_JIT_TYPE_UINT32,
+ 0);
+ }
+ break;
+
+ case IL_OP_CONV_U2:
+ {
+ /* Convert to "unsigned int16" */
+ value = ConvertValue(jitCoder, IL_OP_CONV_U2, 0, 0);
+ jitCoder->jitStack[jitCoder->stackTop - 1] =
+ jit_insn_convert(jitCoder->jitFunction,
+ value,
+
_IL_JIT_TYPE_UINT32,
+ 0);
+ }
+ break;
+
+ case IL_OP_CONV_U4:
+ #ifdef IL_NATIVE_INT32
+ case IL_OP_CONV_U:
+ #endif
+ {
+ /* Convert to "unsigned int32" */
+ value = ConvertValue(jitCoder, IL_OP_CONV_U8, 0, 0);
+ jitCoder->jitStack[jitCoder->stackTop - 1] = value;
+ }
+ break;
+
+ case IL_OP_CONV_U8:
+ #ifdef IL_NATIVE_INT64
+ case IL_OP_CONV_U:
+ #endif
+ {
+ /* Convert to "unsigned int64" */
+ value = ConvertValue(jitCoder, IL_OP_CONV_U8, 0, 0);
+ jitCoder->jitStack[jitCoder->stackTop - 1] = value;
+ }
+ break;
+
+ case IL_OP_CONV_R_UN:
+ {
+ /* Convert to "native float" with unsigned input */
+ value = ConvertValue(jitCoder, IL_OP_CONV_R_UN, 1, 0);
+ jitCoder->jitStack[jitCoder->stackTop - 1] = value;
+ }
+ break;
+
+ case IL_OP_CONV_OVF_I1_UN:
+ {
+ /* Convert to "int8" with unsigned input and overflow */
+ value = ConvertValue(jitCoder, IL_OP_CONV_I1, 1, 1);
+ jitCoder->jitStack[jitCoder->stackTop - 1] =
+ jit_insn_convert(jitCoder->jitFunction,
+ value,
+
_IL_JIT_TYPE_INT32,
+ 0);
+ }
+ break;
+
+ case IL_OP_CONV_OVF_I2_UN:
+ {
+ /* Convert to "int16" with unsigned input and overflow
*/
+ value = ConvertValue(jitCoder, IL_OP_CONV_I2, 1, 1);
+ jitCoder->jitStack[jitCoder->stackTop - 1] =
+ jit_insn_convert(jitCoder->jitFunction,
+ value,
+
_IL_JIT_TYPE_INT32,
+ 0);
+ }
+ break;
+
+ case IL_OP_CONV_OVF_I4_UN:
+ #ifdef IL_NATIVE_INT32
+ case IL_OP_CONV_OVF_I_UN:
+ #endif
+ {
+ /* Convert to "int32" with unsigned input and overflow
*/
+ value = ConvertValue(jitCoder, IL_OP_CONV_I4, 1, 1);
+ jitCoder->jitStack[jitCoder->stackTop - 1] = value;
+ }
+ break;
+
+ case IL_OP_CONV_OVF_I8_UN:
+ #ifdef IL_NATIVE_INT64
+ case IL_OP_CONV_OVF_I_UN:
+ #endif
+ {
+ /* Convert to "int64" with unsigned input and overflow
*/
+ value = ConvertValue(jitCoder, IL_OP_CONV_I8, 1, 1);
+ jitCoder->jitStack[jitCoder->stackTop - 1] = value;
+ }
+ break;
+
+ case IL_OP_CONV_OVF_U1_UN:
+ {
+ /* Convert to "unsigned int8" with unsigned input and
overflow */
+ value = ConvertValue(jitCoder, IL_OP_CONV_U1, 1, 1);
+ jitCoder->jitStack[jitCoder->stackTop - 1] =
+ jit_insn_convert(jitCoder->jitFunction,
+ value,
+
_IL_JIT_TYPE_UINT32,
+ 0);
+ }
+ break;
+
+ case IL_OP_CONV_OVF_U2_UN:
+ {
+ /* Convert to "unsigned int16" with unsigned input and
overflow */
+ value = ConvertValue(jitCoder, IL_OP_CONV_U2, 1, 1);
+ jitCoder->jitStack[jitCoder->stackTop - 1] =
+ jit_insn_convert(jitCoder->jitFunction,
+ value,
+
_IL_JIT_TYPE_UINT32,
+ 0);
+ }
+ break;
+
+ case IL_OP_CONV_OVF_U4_UN:
+ #ifdef IL_NATIVE_INT32
+ case IL_OP_CONV_OVF_U_UN:
+ #endif
+ {
+ /* Convert to "unsigned int32" with unsigned input and
overflow */
+ value = ConvertValue(jitCoder, IL_OP_CONV_U4, 1, 1);
+ jitCoder->jitStack[jitCoder->stackTop - 1] = value;
+ }
+ break;
+
+ case IL_OP_CONV_OVF_U8_UN:
+ #ifdef IL_NATIVE_INT64
+ case IL_OP_CONV_OVF_U_UN:
+ #endif
+ {
+ /* Convert to "unsigned int64" with unsigned input and
overflow */
+ value = ConvertValue(jitCoder, IL_OP_CONV_U8, 1, 1);
+ jitCoder->jitStack[jitCoder->stackTop - 1] = value;
+ }
+ break;
+
+ case IL_OP_CONV_OVF_I1:
+ {
+ /* Convert to "int8" with signed input and overflow */
+ value = ConvertValue(jitCoder, IL_OP_CONV_I1, 0, 1);
+ jitCoder->jitStack[jitCoder->stackTop - 1] =
+ jit_insn_convert(jitCoder->jitFunction,
+ value,
+
_IL_JIT_TYPE_INT32,
+ 0);
+ }
+ break;
+
+ case IL_OP_CONV_OVF_U1:
+ {
+ /* Convert to "unsigned int8" with signed input and
overflow */
+ value = ConvertValue(jitCoder, IL_OP_CONV_U1, 0, 1);
+ jitCoder->jitStack[jitCoder->stackTop - 1] =
+ jit_insn_convert(jitCoder->jitFunction,
+ value,
+
_IL_JIT_TYPE_UINT32,
+ 0);
+ }
+ break;
+
+ case IL_OP_CONV_OVF_I2:
+ {
+ /* Convert to "int16" with signed input and overflow */
+ value = ConvertValue(jitCoder, IL_OP_CONV_I2, 0, 1);
+ jitCoder->jitStack[jitCoder->stackTop - 1] =
+ jit_insn_convert(jitCoder->jitFunction,
+ value,
+
_IL_JIT_TYPE_INT32,
+ 0);
+ }
+ break;
+
+ case IL_OP_CONV_OVF_U2:
+ {
+ /* Convert to "unsigned int16" with signed input and
overflow */
+ value = ConvertValue(jitCoder, IL_OP_CONV_U2, 0, 1);
+ jitCoder->jitStack[jitCoder->stackTop - 1] =
+ jit_insn_convert(jitCoder->jitFunction,
+ value,
+
_IL_JIT_TYPE_UINT32,
+ 0);
+ }
+ break;
+
+ case IL_OP_CONV_OVF_I4:
+ #ifdef IL_NATIVE_INT32
+ case IL_OP_CONV_OVF_I:
+ #endif
+ {
+ /* Convert to "int32" with signed input and overflow */
+ value = ConvertValue(jitCoder, IL_OP_CONV_I4, 0, 1);
+ jitCoder->jitStack[jitCoder->stackTop - 1] = value;
+ }
+ break;
+
+ case IL_OP_CONV_OVF_U4:
+ #ifdef IL_NATIVE_INT32
+ case IL_OP_CONV_OVF_U:
+ #endif
+ {
+ /* Convert to "unsigned int32" with signed input and
overflow */
+ value = ConvertValue(jitCoder, IL_OP_CONV_U4, 0, 1);
+ jitCoder->jitStack[jitCoder->stackTop - 1] = value;
+ }
+ break;
+
+ case IL_OP_CONV_OVF_I8:
+ #ifdef IL_NATIVE_INT64
+ case IL_OP_CONV_OVF_I:
+ #endif
+ {
+ /* Convert to "int64" with signed input and overflow */
+ value = ConvertValue(jitCoder, IL_OP_CONV_I8, 0, 1);
+ jitCoder->jitStack[jitCoder->stackTop - 1] = value;
+ }
+ break;
+
+ case IL_OP_CONV_OVF_U8:
+ #ifdef IL_NATIVE_INT64
+ case IL_OP_CONV_OVF_U:
+ #endif
+ {
+ /* Convert to "unsigned int64" with signed input and
overflow */
+ value = ConvertValue(jitCoder, IL_OP_CONV_U8, 0, 1);
+ jitCoder->jitStack[jitCoder->stackTop - 1] = value;
+ }
+ break;
+ }
}
/*
@@ -33,6 +538,19 @@
static void JITCoder_ToPointer(ILCoder *coder, ILEngineType type1,
ILEngineStackItem
*type2)
{
+ ILJITCoder *jitCoder = _ILCoderToILJITCoder(coder);
+ ILJitValue *value;
+
+ if(!type2)
+ {
+ value = &(jitCoder->jitStack[jitCoder->stackTop - 1]);
+ }
+ else
+ {
+ value = &(jitCoder->jitStack[jitCoder->stackTop - 2]);
+ }
+ *value = jit_insn_convert(jitCoder->jitFunction,
+ *value,
_IL_JIT_TYPE_VPTR, 0);
}
/*
Index: pnet/engine/jitc_ptr.c
diff -u pnet/engine/jitc_ptr.c:1.1 pnet/engine/jitc_ptr.c:1.2
--- pnet/engine/jitc_ptr.c:1.1 Mon Dec 19 18:00:35 2005
+++ pnet/engine/jitc_ptr.c Wed Jan 4 18:54:39 2006
@@ -21,11 +21,345 @@
#ifdef IL_JITC_CODE
/*
+ * Validate the address.
+ */
+static void ValidateAddress(ILJITCoder *coder, ILJitValue address)
+{
+ jit_insn_check_null(coder->jitFunction, address);
+}
+
+/*
+ * Get the base pointer to the array data.
+ */
+static ILJitValue GetArrayBase(ILJITCoder *coder, ILJitValue array)
+{
+ return jit_insn_add_relative(coder->jitFunction, array, sizeof(void *));
+}
+
+/*
+ * Get the array length.
+ */
+static ILJitValue GetArrayLength(ILJITCoder *coder, ILJitValue array)
+{
+ ILJitValue len;
+
+ len = jit_insn_load_relative(coder->jitFunction, array, 0,
+
_IL_JIT_TYPE_UINT32);
+ return len;
+}
+
+/*
+ * Validate the array index.
+ */
+static void ValidateArrayIndex(ILJITCoder *coder, ILJitValue length,
+
ILJitValue index)
+{
+ jit_label_t label1 = jit_label_undefined;
+ jit_label_t label2 = jit_label_undefined;
+ ILJitValue constNull =
jit_value_create_nint_constant(coder->jitFunction,
+
_IL_JIT_TYPE_NINT,
+
(jit_nint)0);
+ ILJitValue temp = jit_insn_lt(coder->jitFunction, index, constNull);
+
+ jit_insn_branch_if(coder->jitFunction, temp, &label1);
+ temp = jit_insn_lt(coder->jitFunction, index, length);
+ jit_insn_branch_if(coder->jitFunction, temp, &label2);
+ jit_insn_label(coder->jitFunction, &label1);
+ /* TODO throw the System.IndexOutOfRange exception here. */
+
+ jit_insn_label(coder->jitFunction, &label2);
+
+
+}
+
+/*
+ * Handle the ldelem* instructions.
+ */
+static void LoadArrayElem(ILJITCoder *coder, ILJitType type)
+{
+ ILJitValue array = coder->jitStack[coder->stackTop - 2];
+ ILJitValue index = coder->jitStack[coder->stackTop - 1];
+ ILJitValue length;
+ ILJitValue value;
+ ILJitValue arrayBase;
+ ILJitType stackType = jit_type_promote_int(type);;
+
+ ValidateAddress(coder, array);
+ length = GetArrayLength(coder, array);
+ ValidateArrayIndex(coder, length, index);
+ arrayBase = GetArrayBase(coder, array);
+ if(type == stackType)
+ {
+ if((type == _IL_JIT_TYPE_SINGLE) || (type ==
_IL_JIT_TYPE_DOUBLE))
+ {
+ stackType = _IL_JIT_TYPE_NFLOAT;
+ }
+ }
+ value = jit_insn_load_elem(coder->jitFunction, arrayBase, index,
+ type);
+ if(type != stackType)
+ {
+ coder->jitStack[coder->stackTop - 2] =
+ jit_insn_convert(coder->jitFunction, value,
+ stackType, 0);
+ }
+ else
+ {
+ coder->jitStack[coder->stackTop - 2] = value;
+ }
+ JITC_ADJUST(coder, -1);
+}
+
+/*
+ * Handle the stelem* instructions.
+ */
+static void StoreArrayElem(ILJITCoder *coder, ILJitType type)
+{
+ ILJitValue array = coder->jitStack[coder->stackTop - 3];
+ ILJitValue index = coder->jitStack[coder->stackTop - 2];
+ ILJitValue value = coder->jitStack[coder->stackTop - 1];
+ ILJitValue length;
+ ILJitValue arrayBase;
+
+ ValidateAddress(coder, array);
+ length = GetArrayLength(coder, array);
+ ValidateArrayIndex(coder, length, index);
+ arrayBase = GetArrayBase(coder, array);
+
+ jit_insn_store_elem(coder->jitFunction, arrayBase, index, value);
+ JITC_ADJUST(coder, -3);
+}
+
+/*
+ * Handle the ldind* instructions.
+ */
+static void LoadRelative(ILJITCoder *coder, ILJitType type)
+{
+ ILJitValue ptr = coder->jitStack[coder->stackTop - 1];
+ ILJitValue value;
+ ILJitType stackType = jit_type_promote_int(type);;
+
+ ValidateAddress(coder, ptr);
+ if(type == stackType)
+ {
+ if((type == _IL_JIT_TYPE_SINGLE) || (type ==
_IL_JIT_TYPE_DOUBLE))
+ {
+ stackType = _IL_JIT_TYPE_NFLOAT;
+ }
+ }
+ value = jit_insn_load_relative(coder->jitFunction, ptr, (jit_nint)0,
type);
+ if(type != stackType)
+ {
+ coder->jitStack[coder->stackTop - 1] =
+ jit_insn_convert(coder->jitFunction, value,
+ stackType, 0);
+ }
+ else
+ {
+ coder->jitStack[coder->stackTop - 1] = value;
+ }
+}
+
+/*
+ * Handle the stind* instructions.
+ */
+static void StoreRelative(ILJITCoder *coder, ILJitType type)
+{
+ ILJitValue ptr = coder->jitStack[coder->stackTop - 2];
+ ILJitValue value = coder->jitStack[coder->stackTop - 1];
+ ILJitType valueType = jit_value_get_type(value);
+
+ ValidateAddress(coder, ptr);
+ if(valueType != type)
+ {
+ value = jit_insn_convert(coder->jitFunction, value, type, 0);
+ }
+ jit_insn_store_relative(coder->jitFunction, ptr, (jit_nint)0, value);
+ JITC_ADJUST(coder, -2);
+}
+
+/*
* Handle an array access opcode.
*/
static void JITCoder_ArrayAccess(ILCoder *coder, int opcode,
ILEngineType
indexType, ILType *elemType)
{
+ ILJITCoder *jitCoder = _ILCoderToILJITCoder(coder);
+ ILJitValue array;
+ ILJitValue index;
+ ILJitValue len;
+ ILJitValue value;
+ ILJitValue arrayBase;
+
+ switch(opcode)
+ {
+ case IL_OP_LDELEMA:
+ {
+ array = jitCoder->jitStack[jitCoder->stackTop - 2];
+ index = jitCoder->jitStack[jitCoder->stackTop - 1];
+
+ ValidateAddress(jitCoder, array);
+ len = GetArrayLength(jitCoder, array);
+ ValidateArrayIndex(jitCoder, array, index);
+ arrayBase = GetArrayBase(jitCoder, array);
+
+ ILJitType type = _ILJitGetReturnType(elemType,
jitCoder->process);
+
+ value =
jit_insn_load_elem_address(jitCoder->jitFunction, arrayBase,
+
index, type);
+ jitCoder->jitStack[jitCoder->stackTop - 2] = value;
+ JITC_ADJUST(jitCoder, -1);
+ }
+ break;
+
+ case IL_OP_LDELEM_I1:
+ {
+ /* Load a signed byte from an array */
+ LoadArrayElem(jitCoder, _IL_JIT_TYPE_SBYTE);
+ }
+ break;
+
+ case IL_OP_LDELEM_I2:
+ {
+ /* Load a signed short from an array */
+ LoadArrayElem(jitCoder, _IL_JIT_TYPE_INT16);
+ }
+ break;
+
+ case IL_OP_LDELEM_I4:
+ #ifdef IL_NATIVE_INT32
+ case IL_OP_LDELEM_I:
+ #endif
+ {
+ /* Load an integer from an array */
+ LoadArrayElem(jitCoder, _IL_JIT_TYPE_INT32);
+ }
+ break;
+
+ case IL_OP_LDELEM_I8:
+ #ifdef IL_NATIVE_INT64
+ case IL_OP_LDELEM_I:
+ #endif
+ {
+ /* Load a long from an array */
+ LoadArrayElem(jitCoder, _IL_JIT_TYPE_INT64);
+ }
+ break;
+
+ case IL_OP_LDELEM_U1:
+ {
+ /* Load an unsigned byte from an array */
+ LoadArrayElem(jitCoder, _IL_JIT_TYPE_BYTE);
+ }
+ break;
+
+ case IL_OP_LDELEM_U2:
+ {
+ /* Load an unsigned short from an array */
+ LoadArrayElem(jitCoder, _IL_JIT_TYPE_UINT16);
+ }
+ break;
+
+ case IL_OP_LDELEM_U4:
+ {
+ /* Load an unsigned integer from an array */
+ LoadArrayElem(jitCoder, _IL_JIT_TYPE_UINT32);
+ }
+ break;
+
+ case IL_OP_LDELEM_R4:
+ {
+ /* Load a 32-bit float from an array */
+ LoadArrayElem(jitCoder, _IL_JIT_TYPE_SINGLE);
+ }
+ break;
+
+ case IL_OP_LDELEM_R8:
+ {
+ /* Load a 64-bit float from an array */
+ LoadArrayElem(jitCoder, _IL_JIT_TYPE_DOUBLE);
+ }
+ break;
+
+ case IL_OP_LDELEM_REF:
+ {
+ /* Load a pointer from an array */
+ LoadArrayElem(jitCoder, _IL_JIT_TYPE_VPTR);
+ }
+ break;
+
+ case IL_OP_LDELEM:
+ {
+ ILJitType type = _ILJitGetReturnType(elemType,
jitCoder->process);
+ LoadArrayElem(jitCoder, type);
+ }
+ break;
+
+ case IL_OP_STELEM_I1:
+ {
+ /* Store a byte value to an array */
+ StoreArrayElem(jitCoder, _IL_JIT_TYPE_SBYTE);
+ }
+ break;
+
+ case IL_OP_STELEM_I2:
+ {
+ /* Store a short value to an array */
+ StoreArrayElem(jitCoder, _IL_JIT_TYPE_INT16);
+ }
+ break;
+
+ case IL_OP_STELEM_I4:
+ #ifdef IL_NATIVE_INT32
+ case IL_OP_STELEM_I:
+ #endif
+ {
+ /* Store an integer value to an array */
+ StoreArrayElem(jitCoder, _IL_JIT_TYPE_INT32);
+ }
+ break;
+
+ case IL_OP_STELEM_I8:
+ #ifdef IL_NATIVE_INT64
+ case IL_OP_STELEM_I:
+ #endif
+ {
+ /* Store a long value to an array */
+ StoreArrayElem(jitCoder, _IL_JIT_TYPE_INT64);
+ }
+ break;
+
+ case IL_OP_STELEM_R4:
+ {
+ /* Store a 32-bit floating point value to an array */
+ StoreArrayElem(jitCoder, _IL_JIT_TYPE_SINGLE);
+ }
+ break;
+
+ case IL_OP_STELEM_R8:
+ {
+ /* Store a 64-bit floating point value to an array */
+ StoreArrayElem(jitCoder, _IL_JIT_TYPE_DOUBLE);
+ }
+ break;
+
+ case IL_OP_STELEM_REF:
+ {
+ /* Store a pointer to an array */
+ /* TODO: Check if the types are assignmentcompatible. */
+ StoreArrayElem(jitCoder, _IL_JIT_TYPE_VPTR);
+ }
+ break;
+
+ case IL_OP_STELEM:
+ {
+ /* Store a pointer to an array */
+ /* TODO: Check if the types are assignmentcompatible. */
+ ILJitType type = _ILJitGetReturnType(elemType,
jitCoder->process);
+ StoreArrayElem(jitCoder, type);
+ }
+ break;
+ }
}
/*
@@ -33,6 +367,141 @@
*/
static void JITCoder_PtrAccess(ILCoder *coder, int opcode)
{
+ ILJITCoder *jitCoder = _ILCoderToILJITCoder(coder);
+
+ switch(opcode)
+ {
+ case IL_OP_LDIND_I1:
+ {
+ /* Load a signed byte from a pointer */
+ LoadRelative(jitCoder, _IL_JIT_TYPE_SBYTE);
+ }
+ break;
+
+ case IL_OP_LDIND_U1:
+ {
+ /* Load an unsigned byte from a pointer */
+ LoadRelative(jitCoder, _IL_JIT_TYPE_BYTE);
+ }
+ break;
+
+ case IL_OP_LDIND_I2:
+ {
+ /* Load a signed short from a pointer */
+ LoadRelative(jitCoder, _IL_JIT_TYPE_INT16);
+ }
+ break;
+
+ case IL_OP_LDIND_U2:
+ {
+ /* Load an unsigned short from a pointer */
+ LoadRelative(jitCoder, _IL_JIT_TYPE_UINT16);
+ }
+ break;
+
+ case IL_OP_LDIND_I4:
+ #ifdef IL_NATIVE_INT32
+ case IL_OP_LDIND_I:
+ #endif
+ {
+ /* Load an integer from a pointer */
+ LoadRelative(jitCoder, _IL_JIT_TYPE_INT32);
+ }
+ break;
+
+ case IL_OP_LDIND_U4:
+ {
+ /* Load an unsigned integer from a pointer */
+ LoadRelative(jitCoder, _IL_JIT_TYPE_UINT32);
+ }
+ break;
+
+ case IL_OP_LDIND_I8:
+ #ifdef IL_NATIVE_INT64
+ case IL_OP_LDIND_I:
+ #endif
+ {
+ /* Load a long from a pointer */
+ LoadRelative(jitCoder, _IL_JIT_TYPE_INT64);
+ }
+ break;
+
+ case IL_OP_LDIND_R4:
+ {
+ /* Load a 32-bit float from a pointer */
+ LoadRelative(jitCoder, _IL_JIT_TYPE_SINGLE);
+ }
+ break;
+
+ case IL_OP_LDIND_R8:
+ {
+ /* Load a 64-bit float from a pointer */
+ LoadRelative(jitCoder, _IL_JIT_TYPE_DOUBLE);
+ }
+ break;
+
+ case IL_OP_LDIND_REF:
+ {
+ /* Load a pointer from a pointer */
+ LoadRelative(jitCoder, _IL_JIT_TYPE_VPTR);
+ }
+ break;
+
+ case IL_OP_STIND_REF:
+ {
+ /* Store a pointer to a pointer */
+ StoreRelative(jitCoder, _IL_JIT_TYPE_VPTR);
+ }
+ break;
+
+ case IL_OP_STIND_I1:
+ {
+ /* Store a byte to a pointer */
+ StoreRelative(jitCoder, _IL_JIT_TYPE_SBYTE);
+ }
+ break;
+
+ case IL_OP_STIND_I2:
+ {
+ /* Store a short to a pointer */
+ StoreRelative(jitCoder, _IL_JIT_TYPE_INT16);
+ }
+ break;
+
+ case IL_OP_STIND_I4:
+ #ifdef IL_NATIVE_INT32
+ case IL_OP_STIND_I:
+ #endif
+ {
+ /* Store an integer to a pointer */
+ StoreRelative(jitCoder, _IL_JIT_TYPE_INT32);
+ }
+ break;
+
+ case IL_OP_STIND_I8:
+ #ifdef IL_NATIVE_INT64
+ case IL_OP_STIND_I:
+ #endif
+ {
+ /* Store a long to a pointer */
+ StoreRelative(jitCoder, _IL_JIT_TYPE_INT64);
+ }
+ break;
+
+ case IL_OP_STIND_R4:
+ {
+ /* Store a 32-bit float to a pointer */
+ StoreRelative(jitCoder, _IL_JIT_TYPE_SINGLE);
+ }
+ break;
+
+ case IL_OP_STIND_R8:
+ {
+ /* Store a 64-bit float to a pointer */
+ StoreRelative(jitCoder, _IL_JIT_TYPE_DOUBLE);
+ }
+ break;
+ }
}
/*
@@ -41,6 +510,36 @@
static void JITCoder_PtrAccessManaged(ILCoder *coder, int opcode,
ILClass *classInfo)
{
+ ILJITCoder *jitCoder = _ILCoderToILJITCoder(coder);
+ ILType *type = ILClassToType(classInfo);
+ ILJitType jitType = _ILJitGetReturnType(type, jitCoder->process);
+ ILJitValue address;
+
+ if(opcode == IL_OP_LDOBJ)
+ {
+ /* Load from a pointer */
+ address = jitCoder->jitStack[jitCoder->stackTop - 1];
+ ValidateAddress(jitCoder, address);
+ jitCoder->jitStack[jitCoder->stackTop - 1] =
+ jit_insn_load_relative(jitCoder->jitFunction, address,
(jit_nint)0,
+ jitType);
+ }
+ else
+ {
+ /* Store to a pointer */
+ ILJitValue object = jitCoder->jitStack[jitCoder->stackTop - 1];;
+
+ address = jitCoder->jitStack[jitCoder->stackTop - 2];
+ ValidateAddress(jitCoder, address);
+
+ if(jit_value_get_type(object) != jitType)
+ {
+ object = jit_insn_convert(jitCoder->jitFunction,
object, jitType, 0);
+ }
+ jit_insn_store_relative(jitCoder->jitFunction, address,
(jit_nint)0, object);
+ JITC_ADJUST(jitCoder, -2);
+ }
+
}
/*
@@ -56,6 +555,14 @@
*/
static void JITCoder_ArrayLength(ILCoder *coder)
{
+ ILJITCoder *jitCoder = _ILCoderToILJITCoder(coder);
+ ILJitValue array = jitCoder->jitStack[jitCoder->stackTop - 1];
+ ILJitValue len;
+
+ ValidateAddress(jitCoder, array);
+ len = GetArrayLength(jitCoder, array);
+ jitCoder->jitStack[jitCoder->stackTop - 1] =
+ jit_insn_convert(jitCoder->jitFunction, len,
_IL_JIT_TYPE_NUINT, 0);
}
/*
@@ -64,6 +571,46 @@
static void JITCoder_NewArray(ILCoder *coder, ILType *arrayType,
ILClass *arrayClass,
ILEngineType lengthType)
{
+ ILJITCoder *jitCoder = _ILCoderToILJITCoder(coder);
+ ILJitValue length = jitCoder->jitStack[jitCoder->stackTop - 1];
+ ILJitValue args[2];
+ ILMethod *ctor;
+ ILJitFunction jitFunction;
+ ILJitValue returnValue;
+ jit_label_t label = jit_label_undefined;
+ ILJitValue nullConst =
jit_value_create_nint_constant(jitCoder->jitFunction,
+
_IL_JIT_TYPE_VPTR, 0);
+ ILJitValue temp;
+
+ /* Find the allocation constructor within the array class.
+ We know that the class only has one method, so it must
+ be the constructor that we are looking for */
+ ctor = (ILMethod *)ILClassNextMemberByKind
+ (arrayClass, 0,
IL_META_MEMBERKIND_METHOD);
+
+ jitFunction = ILJitFunctionFromILMethod(ctor);
+ if(!jitFunction)
+ {
+ /* We have to layout the class first. */
+ if(!_LayoutClass(ILExecThreadCurrent(), arrayClass))
+ {
+ return;
+ }
+ jitFunction = ILJitFunctionFromILMethod(ctor);
+ }
+ args[0] = jit_value_get_param(jitCoder->jitFunction, 0);
+ args[1] = length;
+ JITC_ADJUST(jitCoder, -1);
+ SetMethodInThread(jitCoder->jitFunction, args[0], ctor);
+ /* Output code to call the array type's constructor */
+ returnValue = jit_insn_call(jitCoder->jitFunction, 0, jitFunction,
+ 0, args, 2, 0);
+ temp = jit_insn_ne(jitCoder->jitFunction, returnValue, nullConst);
+ jit_insn_branch_if(jitCoder->jitFunction, temp, &label);
+ _ILJitThrowCurrentException(jitCoder);
+ jit_insn_label(jitCoder->jitFunction, &label);
+ jitCoder->jitStack[jitCoder->stackTop] = returnValue;
+ JITC_ADJUST(jitCoder, 1);
}
/*
@@ -71,6 +618,10 @@
*/
static void JITCoder_CheckNull(ILCoder *coder)
{
+ ILJITCoder *jitCoder = _ILCoderToILJITCoder(coder);
+
+ jit_insn_check_null(jitCoder->jitFunction,
+
jitCoder->jitStack[jitCoder->stackTop - 1]);
}
#endif /* IL_JITC_CODE */
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- [dotgnu-pnet-commits] pnet ./ChangeLog engine/jitc.c engine/jitc.h en...,
Klaus Treichel <=