[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[dotgnu-pnet-commits] pnet ./ChangeLog engine/Makefile.am engine/jitc...
|
From: |
Klaus Treichel |
|
Subject: |
[dotgnu-pnet-commits] pnet ./ChangeLog engine/Makefile.am engine/jitc... |
|
Date: |
Mon, 17 Apr 2006 17:39:44 +0000 |
CVSROOT: /cvsroot/dotgnu-pnet
Module name: pnet
Branch:
Changes by: Klaus Treichel <address@hidden> 06/04/17 17:39:44
Modified files:
. : ChangeLog
engine : Makefile.am jitc.c jitc_call.c jitc_conv.c
jitc_labels.c jitc_locals.c jitc_obj.c
jitc_ptr.c jitc_setup.c jitc_var.c
Added files:
engine : jitc_alloc.c
Log message:
2006-04-17 Klaus Treichel <address@hidden>
* engine/Makefile.am: Add jitc_alloc.c to jitc.o sources.
* engine/jitc_alloc.c: Add object allocation functions.
* engine/jitc.c, engine/jitc_call.c, engine/jitc_conv.c,
engine/jitc_labels.c, engine/jitc_locals.c, engine/jitc_obj.c,
engine/jitc_ptr.c, engine/jitc_setup.c, engine/jitc_var.c: Replace the
calls of EngineAlloc with calls to the new allocation functions.
Add initialization of locals. Redo the value conversion.
CVSWeb URLs:
http://cvs.savannah.gnu.org/viewcvs/dotgnu-pnet/pnet/ChangeLog.diff?tr1=1.3313&tr2=1.3314&r1=text&r2=text
http://cvs.savannah.gnu.org/viewcvs/dotgnu-pnet/pnet/engine/Makefile.am.diff?tr1=1.83&tr2=1.84&r1=text&r2=text
http://cvs.savannah.gnu.org/viewcvs/dotgnu-pnet/pnet/engine/jitc.c.diff?tr1=1.29&tr2=1.30&r1=text&r2=text
http://cvs.savannah.gnu.org/viewcvs/dotgnu-pnet/pnet/engine/jitc_alloc.c?rev=1.1
http://cvs.savannah.gnu.org/viewcvs/dotgnu-pnet/pnet/engine/jitc_call.c.diff?tr1=1.12&tr2=1.13&r1=text&r2=text
http://cvs.savannah.gnu.org/viewcvs/dotgnu-pnet/pnet/engine/jitc_conv.c.diff?tr1=1.4&tr2=1.5&r1=text&r2=text
http://cvs.savannah.gnu.org/viewcvs/dotgnu-pnet/pnet/engine/jitc_labels.c.diff?tr1=1.1&tr2=1.2&r1=text&r2=text
http://cvs.savannah.gnu.org/viewcvs/dotgnu-pnet/pnet/engine/jitc_locals.c.diff?tr1=1.1&tr2=1.2&r1=text&r2=text
http://cvs.savannah.gnu.org/viewcvs/dotgnu-pnet/pnet/engine/jitc_obj.c.diff?tr1=1.14&tr2=1.15&r1=text&r2=text
http://cvs.savannah.gnu.org/viewcvs/dotgnu-pnet/pnet/engine/jitc_ptr.c.diff?tr1=1.8&tr2=1.9&r1=text&r2=text
http://cvs.savannah.gnu.org/viewcvs/dotgnu-pnet/pnet/engine/jitc_setup.c.diff?tr1=1.12&tr2=1.13&r1=text&r2=text
http://cvs.savannah.gnu.org/viewcvs/dotgnu-pnet/pnet/engine/jitc_var.c.diff?tr1=1.7&tr2=1.8&r1=text&r2=text
Patches:
Index: pnet/ChangeLog
diff -u pnet/ChangeLog:1.3313 pnet/ChangeLog:1.3314
--- pnet/ChangeLog:1.3313 Mon Apr 10 19:40:26 2006
+++ pnet/ChangeLog Mon Apr 17 17:39:44 2006
@@ -1,3 +1,15 @@
+2006-04-17 Klaus Treichel <address@hidden>
+
+ * engine/Makefile.am: Add jitc_alloc.c to jitc.o sources.
+
+ * engine/jitc_alloc.c: Add object allocation functions.
+
+ * engine/jitc.c, engine/jitc_call.c, engine/jitc_conv.c,
+ engine/jitc_labels.c, engine/jitc_locals.c, engine/jitc_obj.c,
+ engine/jitc_ptr.c, engine/jitc_setup.c, engine/jitc_var.c: Replace the
+ calls of EngineAlloc with calls to the new allocation functions.
+ Add initialization of locals. Redo the value conversion.
+
2006-04-10 Klaus Treichel <address@hidden>
* engine/jitc_ptr.c: Do some optimizations in the array index
verification
Index: pnet/engine/Makefile.am
diff -u pnet/engine/Makefile.am:1.83 pnet/engine/Makefile.am:1.84
--- pnet/engine/Makefile.am:1.83 Sun Mar 19 11:29:11 2006
+++ pnet/engine/Makefile.am Mon Apr 17 17:39:44 2006
@@ -14,6 +14,7 @@
INTERNAL_INCLUDES = int_table.c
JITC_INCLUDES = jitc.h \
+ jitc_alloc.c \
jitc_arith.c \
jitc_branch.c \
jitc_call.c \
Index: pnet/engine/jitc.c
diff -u pnet/engine/jitc.c:1.29 pnet/engine/jitc.c:1.30
--- pnet/engine/jitc.c:1.29 Sun Apr 9 16:30:44 2006
+++ pnet/engine/jitc.c Mon Apr 17 17:39:44 2006
@@ -63,6 +63,11 @@
*/
/* #define _IL_JIT_OPTIMIZE_NULLCHECKS 1 */
+/*
+ * To delay the initialization of the locals uncomment the following define.
+ */
+/* #define _IL_JIT_OPTIMIZE_INIT_LOCALS 1 */
+
#ifdef _IL_JIT_DUMP_FUNCTION
#ifndef _IL_JIT_ENABLE_DEBUG
#define _IL_JIT_ENABLE_DEBUG 1
@@ -112,10 +117,9 @@
*/
/*
- * ILObject *_ILEngineAlloc(ILExecThread *thread, ILClass *classInfo,
- * ILUInt32 size)
+ * ILObject *_ILJitAlloc(ILClass *classInfo, ILUInt32 size)
*/
-static ILJitType _ILJitSignature_ILEngineAlloc = 0;
+static ILJitType _ILJitSignature_ILJitAlloc = 0;
/*
* System_Array *_ILJitGetExceptionStackTrace(ILExecThread *thread)
@@ -157,6 +161,12 @@
static ILJitType _ILJitSignature_JitExceptionClearLast = 0;
/*
+ * void *malloc(size_t nbytes)
+ * This signature is used for GCAlloc and GCAllocAtomic too.
+ */
+static ILJitType _ILJitSignature_malloc = 0;
+
+/*
* Define offsetof macro if not present.
*/
#ifndef offsetof
@@ -248,6 +258,9 @@
/* Members to manage the local variables. */
ILJitLocalSlots jitLocals;
+#ifdef _IL_JIT_OPTIMIZE_INIT_LOCALS
+ int localsInitialized;
+#endif
/* Handle the labels. */
ILMemPool labelPool;
@@ -275,6 +288,19 @@
#define _ILCoderToILJITCoder(coder) ((ILJITCoder *)coder)
/*
+ * Generate the code to allocate the memory for an object.
+ * Returns the ILJitValue with the pointer to the new object.
+ */
+static ILJitValue _ILJitAllocGen(ILJITCoder *jitCoder, ILClass *classInfo,
+ ILUInt32 size);
+
+/*
+ * Generate the code to allocate the memory for an object.
+ * Returns the ILJitValue with the pointer to the new object.
+ */
+static ILJitValue _ILJitAllocObjectGen(ILJITCoder *jitCoder, ILClass
*classInfo);
+
+/*
* Initialize a ILJitTypes base structure
*/
#define _ILJitTypesInitBase(jitTypes, jitType) \
@@ -325,7 +351,31 @@
(typeKind == JIT_TYPE_NFLOAT))
/*
- * Check if the typeKind is a long.
+ * Check if the typeKind is an int (<=32 bit value).
+ */
+#ifdef IL_NATIVE_INT64
+#define _JIT_TYPEKIND_IS_INT(typeKind) \
+((typeKind == JIT_TYPE_INT) || \
+ (typeKind == JIT_TYPE_UINT) || \
+ (typeKind == JIT_TYPE_SHORT) || \
+ (typeKind == JIT_TYPE_USHORT) || \
+ (typeKind == JIT_TYPE_SBYTE) || \
+ (typeKind == JIT_TYPE_UBYTE))
+#else
+#define _JIT_TYPEKIND_IS_INT(typeKind) \
+((typeKind == JIT_TYPE_NINT) || \
+ (typeKind == JIT_TYPE_NUINT) || \
+ (typeKind == JIT_TYPE_INT) || \
+ (typeKind == JIT_TYPE_UINT) || \
+ (typeKind == JIT_TYPE_SHORT) || \
+ (typeKind == JIT_TYPE_USHORT) || \
+ (typeKind == JIT_TYPE_SBYTE) || \
+ (typeKind == JIT_TYPE_UBYTE) || \
+ (typeKind == JIT_TYPE_PTR))
+#endif
+
+/*
+ * Check if the typeKind is a long (64 bit value).
*/
#ifdef IL_NATIVE_INT64
#define _JIT_TYPEKIND_IS_LONG(typeKind) \
@@ -361,6 +411,12 @@
(typeKind == JIT_TYPE_SBYTE))
/*
+ * Check if the typeKind is a pointer type.
+ */
+#define _JIT_TYPEKIND_IS_POINTER(typeKind) \
+(typeKind == JIT_TYPE_PTR)
+
+/*
* Convert a value to the corresponding signed/unsigned type.
* Returns 1 if the value is converted 0 otherwise.
*/
@@ -464,6 +520,289 @@
}
/*
+ * Do the explicit conversion of an ILJitValue to the given target type.
+ * The value to convert is on the stack in it's source type. This means that no
+ * implicit conversion to the stacktype (either INT32, INT64 or a pointer type
+ * was done.
+ * Because of this we have to take into account that unsigned values with a
+ * length < 4 should have been zero extended to a size of an INT32 and signed
+ * values would have been sign extended.
+ */
+static ILJitValue _ILJitValueConvertExplicit(ILJitFunction func,
+
ILJitValue value,
+
ILJitType targetType,
+
int isUnsigned,
+
int overflowCheck)
+{
+ ILJitType sourceType = jit_value_get_type(value);
+ int sourceSize;
+ int sourceTypeKind;
+ int targetSize;
+ int targetTypeKind;
+
+ if(sourceType == targetType)
+ {
+ /* Nothing to do here. */
+ return value;
+ }
+ if(jit_type_is_struct(sourceType) || jit_type_is_union(sourceType))
+ {
+ /* something is wrong here. */
+ return value;
+ }
+ sourceTypeKind = jit_type_get_kind(sourceType);
+ targetTypeKind = jit_type_get_kind(targetType);
+ if(_JIT_TYPEKIND_IS_FLOAT(sourceTypeKind))
+ {
+ /* We can convert these values directly */
+ return jit_insn_convert(func, value, targetType, overflowCheck);
+ }
+ else
+ {
+ if(_JIT_TYPEKIND_IS_FLOAT(targetTypeKind))
+ {
+ if(_JIT_TYPEKIND_IS_SIGNED(sourceTypeKind))
+ {
+ if(isUnsigned)
+ {
+ AdjustSign(func, &value, 1,
overflowCheck);
+ }
+ }
+ else if(_JIT_TYPEKIND_IS_UNSIGNED(sourceTypeKind))
+ {
+ if(!isUnsigned)
+ {
+ AdjustSign(func, &value, 0,
overflowCheck);
+ }
+ }
+ else if(_JIT_TYPEKIND_IS_POINTER(sourceTypeKind))
+ {
+ if(isUnsigned)
+ {
+ value = jit_insn_convert(func, value,
_IL_JIT_TYPE_NUINT,
+
overflowCheck);
+ }
+ else
+ {
+ value = jit_insn_convert(func,
value, _IL_JIT_TYPE_NINT,
+
overflowCheck);
+ }
+ }
+ value = jit_insn_convert(func, value, targetType,
overflowCheck);
+ }
+ else
+ {
+ sourceSize = jit_type_get_size(sourceType);
+ targetSize = jit_type_get_size(targetType);
+
+ if(targetSize <= sourceSize)
+ {
+ /* The value is truncated or the sign is
changed. */
+ }
+ else
+ {
+ if(_JIT_TYPEKIND_IS_LONG(targetTypeKind))
+ {
+
if(_JIT_TYPEKIND_IS_SIGNED(targetTypeKind))
+ {
+ /* In this case we have to zero
extend unsigned source */
+ /* values to the size of an
INT32 first. */
+
if(_JIT_TYPEKIND_IS_UNSIGNED(sourceTypeKind))
+ {
+ /* We have to zero
extend the value to the */
+ /* size an INT32 first.
*/
+ /* I assume that
unsigned source values will be */
+ /* zero extended to the
target size. */
+ value =
jit_insn_convert(func, value,
+
_IL_JIT_TYPE_INT32,
+
overflowCheck);
+ }
+ else
if(_JIT_TYPEKIND_IS_POINTER(sourceTypeKind))
+ {
+ /* Pointers have to be
sign extended in this case. */
+ /* So we convert to a
signed NINT first. */
+ value =
jit_insn_convert(func, value,
+
_IL_JIT_TYPE_NINT,
+
overflowCheck);
+ }
+ }
+ else
if(_JIT_TYPEKIND_IS_UNSIGNED(targetTypeKind))
+ {
+
+ /* In this case we have to sign
extend signed source */
+ /* values to the size of an
INT32 first. */
+
if(_JIT_TYPEKIND_IS_SIGNED(sourceTypeKind))
+ {
+ /* We have to sign
extend the value to the */
+ /* size an INT32 first.
*/
+ /* I assume that signed
source values will be */
+ /* sign extended to the
target size. */
+ value =
jit_insn_convert(func, value,
+
_IL_JIT_TYPE_UINT32,
+
overflowCheck);
+ }
+ else
if(_JIT_TYPEKIND_IS_POINTER(sourceTypeKind))
+ {
+ /* Pointers have to be
zero extended in this case. */
+ /* So we convert to a
unsigned NUINT first. */
+ value =
jit_insn_convert(func, value,
+
_IL_JIT_TYPE_NUINT,
+
overflowCheck);
+ }
+ }
+#ifdef IL_NATIVE_INT64
+ else
if(_JIT_TYPEKIND_IS_POINTER(targetTypeKind))
+ {
+ /* This is not allowed in
explicit conversion. */
+ /* But we treat pointers like
unsigned values. */
+
if(_JIT_TYPEKIND_IS_SIGNED(sourceTypeKind))
+ {
+ AdjustSign(func,
&value, 1, overflowCheck);
+ }
+ }
+#endif
+ }
+ else
+ {
+ /* The value would have been zero- or
sign extended to */
+ /* the size of an INT32 depending on
the signedness of */
+ /* the value. Now we have the less or
the same size so */
+ /* we can safely simply convert to the
target type. */
+ }
+ }
+ value = jit_insn_convert(func, value, targetType,
overflowCheck);
+ }
+ }
+ return value;
+}
+
+/*
+ * Do the implicit conversion of an ILJitValue to the given target type.
+ * The value to convert is on the stack in it's source type. This means that no
+ * implicit conversion to the stacktype (either INT32, INT64 or a pointer type
+ * was done.
+ * Because of this we have to take into account that unsigned values with a
+ * length < 4 should have been zero extended to a size of an INT32 and signed
+ * values would have been sign extended.
+ */
+static ILJitValue _ILJitValueConvertImplicit(ILJitFunction func,
+
ILJitValue value,
+
ILJitType targetType)
+{
+ ILJitType sourceType = jit_value_get_type(value);
+ int sourceTypeKind;
+ int targetTypeKind;
+
+ if(sourceType == targetType)
+ {
+ /* Nothing to do here. */
+ return value;
+ }
+ if(jit_type_is_struct(sourceType) || jit_type_is_union(sourceType))
+ {
+ /* something is wrong here. */
+ return value;
+ }
+ sourceTypeKind = jit_type_get_kind(sourceType);
+ targetTypeKind = jit_type_get_kind(targetType);
+ if(_JIT_TYPEKIND_IS_FLOAT(sourceTypeKind))
+ {
+ /* We can convert these values directly */
+ return jit_insn_convert(func, value, targetType, 0);
+ }
+ else
+ {
+ if(_JIT_TYPEKIND_IS_FLOAT(targetTypeKind))
+ {
+ value = jit_insn_convert(func, value, targetType, 0);
+ }
+ else
+ {
+ int sourceSize = jit_type_get_size(sourceType);
+ int targetSize = jit_type_get_size(targetType);
+
+ if(targetSize <= sourceSize)
+ {
+ /* The value is truncated or the sign is
changed. */
+ }
+ else
+ {
+ if(_JIT_TYPEKIND_IS_LONG(targetTypeKind))
+ {
+
if(_JIT_TYPEKIND_IS_SIGNED(targetTypeKind))
+ {
+ /* In this case we have to zero
extend unsigned source */
+ /* values to the size of an
INT32 first. */
+
if(_JIT_TYPEKIND_IS_UNSIGNED(sourceTypeKind))
+ {
+ /* We have to zero
extend the value to the */
+ /* size an INT32 first.
*/
+ /* I assume that
unsigned source values will be */
+ /* zero extended to the
target size. */
+ value =
jit_insn_convert(func, value,
+
_IL_JIT_TYPE_INT32,
+
0);
+ }
+ else
if(_JIT_TYPEKIND_IS_POINTER(sourceTypeKind))
+ {
+ /* Pointers have to be
sign extended in this case. */
+ /* So we convert to a
signed NINT first. */
+ value =
jit_insn_convert(func, value,
+
_IL_JIT_TYPE_NINT,
+
0);
+ }
+ }
+ else
if(_JIT_TYPEKIND_IS_UNSIGNED(targetTypeKind))
+ {
+
+ /* In this case we have to sign
extend signed source */
+ /* values to the size of an
INT32 first. */
+
if(_JIT_TYPEKIND_IS_SIGNED(sourceTypeKind))
+ {
+ /* We have to sign
extend the value to the */
+ /* size an INT32 first.
*/
+ /* I assume that signed
source values will be */
+ /* sign extended to the
target size. */
+ value =
jit_insn_convert(func, value,
+
_IL_JIT_TYPE_UINT32,
+
0);
+ }
+ else
if(_JIT_TYPEKIND_IS_POINTER(sourceTypeKind))
+ {
+ /* Pointers have to be
zero extended in this case. */
+ /* So we convert to a
unsigned NUINT first. */
+ value =
jit_insn_convert(func, value,
+
_IL_JIT_TYPE_NUINT,
+
0);
+ }
+ }
+#ifdef IL_NATIVE_INT64
+ else
if(_JIT_TYPEKIND_IS_POINTER(targetTypeKind))
+ {
+ /* This is not allowed in
explicit conversion. */
+ /* But we treat pointers like
unsigned values. */
+
if(_JIT_TYPEKIND_IS_SIGNED(sourceTypeKind))
+ {
+ AdjustSign(func,
&value, 1, 0);
+ }
+ }
+#endif
+ }
+ else
+ {
+ /* The value would have been zero- or
sign extended to */
+ /* the size of an INT32 depending on
the signedness of */
+ /* the value. Now we have the less or
the same size so */
+ /* we can safely simply convert to the
target type. */
+ }
+ }
+ value = jit_insn_convert(func, value, targetType, 0);
+ }
+ }
+ return value;
+}
+
+/*
* Readjust the stack to normalize binary operands when
* I and I4 are mixed together. Also determine which of
* I4 or I8 to use if the operation involves I.
@@ -487,25 +826,6 @@
return;
}
- /* When converted to unsigned the values have to be extended with 0s. */
- /* So we have to adjust the sign first. */
- if(isUnsigned)
- {
- if(AdjustSign(coder->jitFunction, value1, isUnsigned, 0))
- {
- type1 = jit_value_get_type(*value1);
- newType1 = type1;
- type1Kind = jit_type_get_kind(type1);
- }
-
- if(AdjustSign(coder->jitFunction, value2, isUnsigned, 0))
- {
- type2 = jit_value_get_type(*value2);
- newType2 = type2;
- type2Kind = jit_type_get_kind(type2);
- }
- }
-
/* If the arguments mix I8 and I4, then cast the I4 value to I8 */
if(type1IsLong && !type2IsLong)
{
@@ -592,11 +912,13 @@
/* now do the conversion if necessairy. */
if(type1 != newType1)
{
- *value1 = jit_insn_convert(coder->jitFunction, *value1,
newType1, 0);
+ *value1 = _ILJitValueConvertImplicit(coder->jitFunction,
*value1,
+
newType1);
}
if(type2 != newType2)
{
- *value2 = jit_insn_convert(coder->jitFunction, *value2,
newType2, 0);
+ *value2 = _ILJitValueConvertImplicit(coder->jitFunction,
*value2,
+
newType2);
}
}
@@ -607,6 +929,11 @@
{
int result = 0;
+ /* Check if the class is allready layouted. */
+ if((info->userData) && !(((ILClassPrivate
*)(info->userData))->inLayout))
+ {
+ return 1;
+ }
METADATA_WRLOCK(thread);
result = _ILLayoutClass(_ILExecThreadProcess(thread), info);
METADATA_UNLOCK(thread);
@@ -1309,11 +1636,10 @@
/* Initialize the native method signatures. */
args[0] = _IL_JIT_TYPE_VPTR;
- args[1] = _IL_JIT_TYPE_VPTR;
- args[2] = _IL_JIT_TYPE_UINT32;
+ args[1] = _IL_JIT_TYPE_UINT32;
returnType = _IL_JIT_TYPE_VPTR;
- if(!(_ILJitSignature_ILEngineAlloc =
- jit_type_create_signature(IL_JIT_CALLCONV_CDECL, returnType,
args, 3, 1)))
+ if(!(_ILJitSignature_ILJitAlloc =
+ jit_type_create_signature(IL_JIT_CALLCONV_CDECL, returnType,
args, 2, 1)))
{
return 0;
}
@@ -1380,6 +1706,14 @@
return 0;
}
+ args[0] = _IL_JIT_TYPE_NINT;
+ returnType = _IL_JIT_TYPE_VPTR;
+ if(!(_ILJitSignature_malloc =
+ jit_type_create_signature(IL_JIT_CALLCONV_CDECL, returnType,
args, 1, 1)))
+ {
+ return 0;
+ }
+
return 1;
}
/*
@@ -2556,6 +2890,7 @@
return 0;
}
+#include "jitc_alloc.c"
#include "jitc_diag.c"
#include "jitc_locals.c"
#include "jitc_labels.c"
Index: pnet/engine/jitc_call.c
diff -u pnet/engine/jitc_call.c:1.12 pnet/engine/jitc_call.c:1.13
--- pnet/engine/jitc_call.c:1.12 Sun Apr 2 17:32:43 2006
+++ pnet/engine/jitc_call.c Mon Apr 17 17:39:44 2006
@@ -99,24 +99,7 @@
*/
static void _ILJitNewObj(ILJITCoder *coder, ILClass *info, ILJitValue *newArg)
{
- ILUInt32 objSize = _ILJitGetSizeOfClass(info);
- ILJitValue newObj;
- ILJitValue args[3];
- jit_label_t label1 = jit_label_undefined;
-
- args[0] = jit_value_get_param(coder->jitFunction, 0);
- args[1] = jit_value_create_nint_constant(coder->jitFunction,
-
jit_type_void_ptr, (jit_nint)info);
- args[2] = jit_value_create_nint_constant(coder->jitFunction,
-
jit_type_int, objSize);
- newObj = jit_insn_call_native(coder->jitFunction, "_ILEngineAlloc",
-
_ILEngineAlloc,
-
_ILJitSignature_ILEngineAlloc, args, 3,
-
JIT_CALL_NOTHROW);
- jit_insn_branch_if(coder->jitFunction, newObj, &label1);
- _ILJitThrowCurrentException(coder);
- jit_insn_label(coder->jitFunction, &label1);
- *newArg = newObj;
+ *newArg = _ILJitAllocObjectGen(coder, info);
}
/*
@@ -145,6 +128,7 @@
ILJitValue arrayBase;
ILJitValue boxObject;
ILJitValue boxValue;
+ ILJitValue boxObjectSize;
ILJitValue ptr;
jit_label_t labelException = jit_label_undefined;
jit_label_t label = jit_label_undefined;
@@ -477,20 +461,10 @@
0, paramType, 0);
info = ILClassResolve(info);
typeSize = ILSizeOfType(_thread, paramType);
-
- args[0] = thread;
- args[1] =
jit_value_create_nint_constant(jitCoder->jitFunction,
-
_IL_JIT_TYPE_VPTR, (jit_nint)info);
- args[2] =
jit_value_create_nint_constant(jitCoder->jitFunction,
+ boxObjectSize =
jit_value_create_nint_constant(jitCoder->jitFunction,
_IL_JIT_TYPE_UINT32, typeSize);
- boxObject = jit_insn_call_native(jitCoder->jitFunction,
-
"_ILEngineAlloc",
-
_ILEngineAlloc,
-
_ILJitSignature_ILEngineAlloc,
-
args, 3, JIT_CALL_NOTHROW);
- jit_insn_branch_if_not(jitCoder->jitFunction, boxObject,
-
&labelException);
+ boxObject = _ILJitAllocGen(jitCoder, info, typeSize);
if(boxValue)
{
jit_insn_store_relative(jitCoder->jitFunction,
boxObject, 0,
@@ -498,7 +472,7 @@
}
else
{
- jit_insn_memcpy(jitCoder->jitFunction,
boxObject, ptr, args[2]);
+ jit_insn_memcpy(jitCoder->jitFunction,
boxObject, ptr, boxObjectSize);
}
jit_insn_store_relative(jitCoder->jitFunction,
arrayBase, 0,
boxObject);
@@ -616,7 +590,7 @@
ILJITCoder *jitCoder = _ILCoderToILJITCoder(coder);
ILJitFunction jitFunction = ILJitFunctionFromILMethod(methodInfo);
int argCount = info->numBaseArgs + info->numVarArgs;
- ILJitValue jitParams[argCount + 1];
+ ILJitValue jitParams[argCount + 2];
ILJitValue returnValue;
char *methodName = 0;
ILInternalInfo fnInfo;
@@ -664,14 +638,15 @@
methodName = _ILJitFunctionGetMethodName(jitFunction);
#endif
+ if(info->hasParamArray)
+ {
+ ++argCount;
+ }
+
/* Check if the function is implemented in the engine. */
if(_ILJitFunctionIsInternal(jitCoder, methodInfo, &fnInfo, 0))
{
/* Call the engine function directly with the supplied args. */
- if(info->hasParamArray)
- {
- ++argCount;
- }
JITC_ADJUST(jitCoder, -argCount);
returnValue = _ILJitCallInternal(jitCoder->jitFunction,
methodInfo,
fnInfo.func, methodName,
Index: pnet/engine/jitc_conv.c
diff -u pnet/engine/jitc_conv.c:1.4 pnet/engine/jitc_conv.c:1.5
--- pnet/engine/jitc_conv.c:1.4 Sun Apr 9 16:30:44 2006
+++ pnet/engine/jitc_conv.c Mon Apr 17 17:39:44 2006
@@ -21,148 +21,6 @@
#ifdef IL_JITC_CODE
/*
- * 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];
-
- AdjustSign(jitCoder->jitFunction, &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)
@@ -176,14 +34,20 @@
case IL_OP_CONV_I1:
{
/* Convert to "int8" */
- value = ConvertValue(jitCoder, IL_OP_CONV_I1, 0, 0);
+ value =
_ILJitValueConvertExplicit(jitCoder->jitFunction,
+
value,
+
_IL_JIT_TYPE_SBYTE,
+
0, 0);
}
break;
case IL_OP_CONV_I2:
{
/* Convert to "int16" */
- value = ConvertValue(jitCoder, IL_OP_CONV_I2, 0, 0);
+ value =
_ILJitValueConvertExplicit(jitCoder->jitFunction,
+
value,
+
_IL_JIT_TYPE_INT16,
+
0, 0);
}
break;
@@ -193,7 +57,10 @@
#endif
{
/* Convert to "int32" */
- value = ConvertValue(jitCoder, IL_OP_CONV_I4, 0, 0);
+ value =
_ILJitValueConvertExplicit(jitCoder->jitFunction,
+
value,
+
_IL_JIT_TYPE_INT32,
+
0, 0);
}
break;
@@ -203,35 +70,50 @@
#endif
{
/* Convert to "int64" */
- value = ConvertValue(jitCoder, IL_OP_CONV_I8, 0, 0);
+ value =
_ILJitValueConvertExplicit(jitCoder->jitFunction,
+
value,
+
_IL_JIT_TYPE_INT64,
+
0, 0);
}
break;
case IL_OP_CONV_R4:
{
/* Convert to "float32" */
- value = ConvertValue(jitCoder, IL_OP_CONV_R4, 0, 0);
+ value =
_ILJitValueConvertExplicit(jitCoder->jitFunction,
+
value,
+
_IL_JIT_TYPE_SINGLE,
+
0, 0);
}
break;
case IL_OP_CONV_R8:
{
/* Convert to "float64" */
- value = ConvertValue(jitCoder, IL_OP_CONV_R8, 0, 0);
+ value =
_ILJitValueConvertExplicit(jitCoder->jitFunction,
+
value,
+
_IL_JIT_TYPE_DOUBLE,
+
0, 0);
}
break;
case IL_OP_CONV_U1:
{
/* Convert to "unsigned int8" */
- value = ConvertValue(jitCoder, IL_OP_CONV_U1, 0, 0);
+ value =
_ILJitValueConvertExplicit(jitCoder->jitFunction,
+
value,
+
_IL_JIT_TYPE_BYTE,
+
0, 0);
}
break;
case IL_OP_CONV_U2:
{
/* Convert to "unsigned int16" */
- value = ConvertValue(jitCoder, IL_OP_CONV_U2, 0, 0);
+ value =
_ILJitValueConvertExplicit(jitCoder->jitFunction,
+
value,
+
_IL_JIT_TYPE_UINT16,
+
0, 0);
}
break;
@@ -241,7 +123,10 @@
#endif
{
/* Convert to "unsigned int32" */
- value = ConvertValue(jitCoder, IL_OP_CONV_U4, 0, 0);
+ value =
_ILJitValueConvertExplicit(jitCoder->jitFunction,
+
value,
+
_IL_JIT_TYPE_UINT32,
+
0, 0);
}
break;
@@ -251,28 +136,40 @@
#endif
{
/* Convert to "unsigned int64" */
- value = ConvertValue(jitCoder, IL_OP_CONV_U8, 1, 0);
+ value =
_ILJitValueConvertExplicit(jitCoder->jitFunction,
+
value,
+
_IL_JIT_TYPE_UINT64,
+
0, 0);
}
break;
case IL_OP_CONV_R_UN:
{
/* Convert to "native float" with unsigned input */
- value = ConvertValue(jitCoder, IL_OP_CONV_R_UN, 1, 0);
+ value =
_ILJitValueConvertExplicit(jitCoder->jitFunction,
+
value,
+
_IL_JIT_TYPE_NFLOAT,
+
1, 0);
}
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);
+ value =
_ILJitValueConvertExplicit(jitCoder->jitFunction,
+
value,
+
_IL_JIT_TYPE_SBYTE,
+
1, 1);
}
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);
+ value =
_ILJitValueConvertExplicit(jitCoder->jitFunction,
+
value,
+
_IL_JIT_TYPE_INT16,
+
1, 1);
}
break;
@@ -282,7 +179,10 @@
#endif
{
/* Convert to "int32" with unsigned input and overflow
*/
- value = ConvertValue(jitCoder, IL_OP_CONV_I4, 1, 1);
+ value =
_ILJitValueConvertExplicit(jitCoder->jitFunction,
+
value,
+
_IL_JIT_TYPE_INT32,
+
1, 1);
}
break;
@@ -292,21 +192,30 @@
#endif
{
/* Convert to "int64" with unsigned input and overflow
*/
- value = ConvertValue(jitCoder, IL_OP_CONV_I8, 1, 1);
+ value =
_ILJitValueConvertExplicit(jitCoder->jitFunction,
+
value,
+
_IL_JIT_TYPE_INT64,
+
1, 1);
}
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);
+ value =
_ILJitValueConvertExplicit(jitCoder->jitFunction,
+
value,
+
_IL_JIT_TYPE_BYTE,
+
1, 1);
}
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);
+ value =
_ILJitValueConvertExplicit(jitCoder->jitFunction,
+
value,
+
_IL_JIT_TYPE_UINT16,
+
1, 1);
}
break;
@@ -316,7 +225,10 @@
#endif
{
/* Convert to "unsigned int32" with unsigned input and
overflow */
- value = ConvertValue(jitCoder, IL_OP_CONV_U4, 1, 1);
+ value =
_ILJitValueConvertExplicit(jitCoder->jitFunction,
+
value,
+
_IL_JIT_TYPE_UINT32,
+
1, 1);
}
break;
@@ -326,35 +238,50 @@
#endif
{
/* Convert to "unsigned int64" with unsigned input and
overflow */
- value = ConvertValue(jitCoder, IL_OP_CONV_U8, 1, 1);
+ value =
_ILJitValueConvertExplicit(jitCoder->jitFunction,
+
value,
+
_IL_JIT_TYPE_UINT64,
+
1, 1);
}
break;
case IL_OP_CONV_OVF_I1:
{
/* Convert to "int8" with signed input and overflow */
- value = ConvertValue(jitCoder, IL_OP_CONV_I1, 0, 1);
+ value =
_ILJitValueConvertExplicit(jitCoder->jitFunction,
+
value,
+
_IL_JIT_TYPE_SBYTE,
+
0, 1);
}
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);
+ value =
_ILJitValueConvertExplicit(jitCoder->jitFunction,
+
value,
+
_IL_JIT_TYPE_BYTE,
+
0, 1);
}
break;
case IL_OP_CONV_OVF_I2:
{
/* Convert to "int16" with signed input and overflow */
- value = ConvertValue(jitCoder, IL_OP_CONV_I2, 0, 1);
+ value =
_ILJitValueConvertExplicit(jitCoder->jitFunction,
+
value,
+
_IL_JIT_TYPE_INT16,
+
0, 1);
}
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);
+ value =
_ILJitValueConvertExplicit(jitCoder->jitFunction,
+
value,
+
_IL_JIT_TYPE_UINT16,
+
0, 1);
}
break;
@@ -364,7 +291,10 @@
#endif
{
/* Convert to "int32" with signed input and overflow */
- value = ConvertValue(jitCoder, IL_OP_CONV_I4, 0, 1);
+ value =
_ILJitValueConvertExplicit(jitCoder->jitFunction,
+
value,
+
_IL_JIT_TYPE_INT32,
+
0, 1);
}
break;
@@ -374,7 +304,10 @@
#endif
{
/* Convert to "unsigned int32" with signed input and
overflow */
- value = ConvertValue(jitCoder, IL_OP_CONV_U4, 0, 1);
+ value =
_ILJitValueConvertExplicit(jitCoder->jitFunction,
+
value,
+
_IL_JIT_TYPE_UINT32,
+
0, 1);
}
break;
@@ -384,7 +317,10 @@
#endif
{
/* Convert to "int64" with signed input and overflow */
- value = ConvertValue(jitCoder, IL_OP_CONV_I8, 0, 1);
+ value =
_ILJitValueConvertExplicit(jitCoder->jitFunction,
+
value,
+
_IL_JIT_TYPE_INT64,
+
0, 1);
}
break;
@@ -394,7 +330,10 @@
#endif
{
/* Convert to "unsigned int64" with signed input and
overflow */
- value = ConvertValue(jitCoder, IL_OP_CONV_U8, 1, 1);
+ value =
_ILJitValueConvertExplicit(jitCoder->jitFunction,
+
value,
+
_IL_JIT_TYPE_UINT64,
+
0, 1);
}
break;
}
Index: pnet/engine/jitc_labels.c
diff -u pnet/engine/jitc_labels.c:1.1 pnet/engine/jitc_labels.c:1.2
--- pnet/engine/jitc_labels.c:1.1 Sun Mar 19 11:29:11 2006
+++ pnet/engine/jitc_labels.c Mon Apr 17 17:39:44 2006
@@ -167,6 +167,17 @@
}
label->next = coder->labelList;
coder->labelList = label;
+#ifdef _IL_JIT_OPTIMIZE_INIT_LOCALS
+ if((coder->localsInitialized == 0) && (address != 0))
+ {
+ /* Initialize the locals. */
+ if(!_ILJitLocalsInit(coder))
+ {
+ return 0;
+ }
+ coder->localsInitialized = 1;
+ }
+#endif
}
else
{
Index: pnet/engine/jitc_locals.c
diff -u pnet/engine/jitc_locals.c:1.1 pnet/engine/jitc_locals.c:1.2
--- pnet/engine/jitc_locals.c:1.1 Wed Mar 8 21:03:52 2006
+++ pnet/engine/jitc_locals.c Mon Apr 17 17:39:44 2006
@@ -19,6 +19,12 @@
*/
/*
+ * definitions used in the slot's flags
+ */
+#define _IL_JIT_VALUE_NULLCHECKED 1
+#define _IL_JIT_VALUE_INITIALIZED 2
+
+/*
* Allocate enough space for "n" slots.
*/
#define _ILJitLocalsAlloc(s, n) \
@@ -104,6 +110,100 @@
}
/*
+ * Initialize the local value to 0.
+ */
+static int _ILJitLocalInit(ILJITCoder *coder, ILJitLocalSlot *slot)
+{
+ if((slot->flags & _IL_JIT_VALUE_INITIALIZED) == 0)
+ {
+ ILJitType type = jit_value_get_type(slot->value);
+
+ if(!jit_type_is_struct(type))
+ {
+ int typeKind = jit_type_get_kind(type);
+ ILJitValue constant = 0;
+
+ if(_JIT_TYPEKIND_IS_FLOAT(typeKind))
+ {
+ if(!(constant =
jit_value_create_nfloat_constant(coder->jitFunction,
+
type,
+
(jit_nfloat)0)))
+ {
+ return 0;
+ }
+ jit_insn_store(coder->jitFunction, slot->value,
constant);
+ }
+ else
+ {
+ if(_JIT_TYPEKIND_IS_LONG(typeKind))
+ {
+ if(!(constant =
jit_value_create_long_constant(coder->jitFunction,
+
type, (jit_long)0)))
+ {
+ return 0;
+ }
+ jit_insn_store(coder->jitFunction,
slot->value, constant);
+ }
+ else
+ {
+ if(!(constant =
jit_value_create_nint_constant(coder->jitFunction,
+
type, (jit_nint)0)))
+ {
+ return 0;
+ }
+ jit_insn_store(coder->jitFunction,
slot->value, constant);
+ }
+ }
+ }
+ slot->flags |= _IL_JIT_VALUE_INITIALIZED;
+ }
+ return 1;
+}
+
+/*
+ * Initialize the not yet initialized local values to 0 and move the
+ * initialization sequence to the start of the function.
+ */
+static int _ILJitLocalsInit(ILJITCoder *coder)
+{
+ ILUInt32 num = coder->jitLocals.numSlots;
+ ILUInt32 current;
+
+ if(num > 0)
+ {
+ jit_label_t startLabel = jit_label_undefined;
+ jit_label_t endLabel = jit_label_undefined;
+ ILJitLocalSlot *slot;
+
+ if(!jit_insn_label(coder->jitFunction, &startLabel))
+ {
+ return 0;
+ }
+
+ for(current = 0; current < num; ++current)
+ {
+ slot = &_ILJitLocalGet(coder, current);
+
+ if(!_ILJitLocalInit(coder, slot))
+ {
+ return 0;
+ }
+ }
+
+ if(!jit_insn_label(coder->jitFunction, &endLabel))
+ {
+ return 0;
+ }
+ if(!jit_insn_move_blocks_to_start(coder->jitFunction,
startLabel,
+
endLabel))
+ {
+ return 0;
+ }
+ }
+ return 1;
+}
+
+/*
* Create the slots for the declared local variables.
* Returns zero if out of memory.
*/
@@ -142,6 +242,14 @@
}
/* Record the number of used locals in the coder. */
coder->jitLocals.numSlots = num;
+
+#ifndef _IL_JIT_OPTIMIZE_INIT_LOCALS
+ /* Initialize the locals. */
+ if(!_ILJitLocalsInit(coder))
+ {
+ return 0;
+ }
+#endif
}
else
{
@@ -191,6 +299,90 @@
return 0;
}
+#ifdef _IL_JIT_OPTIMIZE_LOCALS
+
+/*
+ * Find the given value on the stack and replace it by a duplicate.
+ */
+static void _ILJitValueFindAndDup(ILJITCoder *coder, ILJitValue value)
+{
+ ILJitValue dupValue = 0;
+ ILInt32 stackPos = 0;
+
+ for(stackPos = 0; stackPos < coder->stackTop; ++stackPos)
+ {
+ if(coder->jitStack[stackPos] == value)
+ {
+ if(!dupValue)
+ {
+ dupValue = jit_insn_dup(coder->jitFunction,
value);
+ }
+ coder->jitStack[stackPos] = dupValue;
+ }
+ }
+}
+#endif
+
+/*
+ * Get the value of a local slot.
+ * The value in the local slot is initialized to 0 if it is not yet
initialized.
+ */
+static ILJitValue _ILJitLocalGetValue(ILJITCoder *coder, ILUInt32 localNum)
+{
+ ILJitLocalSlot *slot = &_ILJitLocalGet(coder, localNum);
+
+ if((slot->flags & _IL_JIT_VALUE_INITIALIZED) == 0)
+ {
+ _ILJitLocalInit(coder, slot);
+ }
+ return slot->value;
+}
+
+/*
+ * Store a value in a local variable.
+ */
+static void _ILJitLocalStoreValue(ILJITCoder *coder, ILUInt32 localNum,
+
ILJitValue value)
+{
+ ILJitLocalSlot *slot = &_ILJitLocalGet(coder, localNum);
+
+#ifdef _IL_JIT_OPTIMIZE_LOCALS
+ _ILJitValueFindAndDup(coder, slot->value);
+#endif
+
+ jit_insn_store(coder->jitFunction, slot->value, value);
+
+ slot->flags |= _IL_JIT_VALUE_INITIALIZED;
+ slot->flags &= ~_IL_JIT_VALUE_NULLCHECKED;
+}
+
+/*
+ * Get the value of a parameter slot.
+ */
+static ILJitValue _ILJitParamGetValue(ILJITCoder *coder, ILUInt32 paramNum)
+{
+ ILJitLocalSlot *slot = &_ILJitParamGet(coder, paramNum);
+
+ return slot->value;
+}
+
+/*
+ * Store a value in a parameter.
+ */
+static void _ILJitParamStoreValue(ILJITCoder *coder, ILUInt32 paramNum,
+
ILJitValue value)
+{
+ ILJitLocalSlot *slot = &_ILJitParamGet(coder, paramNum);
+
+#ifdef _IL_JIT_OPTIMIZE_LOCALS
+ _ILJitValueFindAndDup(coder, slot->value);
+#endif
+
+ jit_insn_store(coder->jitFunction, slot->value, value);
+
+ slot->flags &= ~_IL_JIT_VALUE_NULLCHECKED;
+}
+
/*
* Check if the given value is a parameter or local.
* Returns 1 if the value is either a param or local value or pointer to
@@ -224,41 +416,15 @@
return 0;
}
-#ifdef _IL_JIT_OPTIMIZE_LOCALS
-
-/*
- * Find the given value on the stack and replace it by a duplicate.
- */
-static void _ILJitValueFindAndDup(ILJITCoder *coder, ILJitValue value)
-{
- ILJitValue dupValue = 0;
- ILInt32 stackPos = 0;
-
- for(stackPos = 0; stackPos < coder->stackTop; ++stackPos)
- {
- if(coder->jitStack[stackPos] == value)
- {
- if(!dupValue)
- {
- dupValue = jit_insn_dup(coder->jitFunction,
value);
- }
- coder->jitStack[stackPos] = dupValue;
- }
- }
-}
-#endif
-
#ifdef _IL_JIT_OPTIMIZE_NULLCHECKS
-#define _IL_JIT_VALUE_NULLCHECKED 1
-
#define _ILJitValuesResetNullChecked(coder) \
_ILJitValuesSetFlags((coder), 0, _IL_JIT_VALUE_NULLCHECKED)
#endif
/*
* Find the slot for the given value.
- * Returns the slot with the valuewhen found otherwise 0.
+ * Returns the slot with the value when found otherwise 0.
*/
static ILJitLocalSlot *_ILJitValueFindSlot(ILJITCoder *coder, ILJitValue value)
{
Index: pnet/engine/jitc_obj.c
diff -u pnet/engine/jitc_obj.c:1.14 pnet/engine/jitc_obj.c:1.15
--- pnet/engine/jitc_obj.c:1.14 Sat Mar 25 07:06:54 2006
+++ pnet/engine/jitc_obj.c Mon Apr 17 17:39:44 2006
@@ -562,10 +562,8 @@
ILJitValue value = jitCoder->jitStack[jitCoder->stackTop - 1];
ILJitValue newObj;
- ILJitValue args[3];
ILType *type = ILClassToType(boxClass);
ILJitType jitType = _ILJitGetReturnType(type, jitCoder->process);
- jit_label_t label1 = jit_label_undefined;
if(valueType == ILEngineType_TypedRef)
{
@@ -600,20 +598,7 @@
#endif
/* Allocate the object. */
- args[0] = jit_value_get_param(jitCoder->jitFunction, 0);
- args[1] = jit_value_create_nint_constant(jitCoder->jitFunction,
- _IL_JIT_TYPE_VPTR,
(jit_nint)boxClass);
-
- args[2] = jit_value_create_nint_constant(jitCoder->jitFunction,
- _IL_JIT_TYPE_UINT32,
size);
-
- newObj = jit_insn_call_native(jitCoder->jitFunction, "_ILEngineAlloc",
-
_ILEngineAlloc, _ILJitSignature_ILEngineAlloc,
- args, 3,
JIT_CALL_NOTHROW);
-
- jit_insn_branch_if(jitCoder->jitFunction, newObj, &label1);
- _ILJitThrowCurrentException(jitCoder);
- jit_insn_label(jitCoder->jitFunction, &label1);
+ newObj = _ILJitAllocObjectGen(jitCoder, boxClass);
if(jit_value_get_type(value)!=jitType)
{
@@ -632,27 +617,9 @@
ILJitType jitType = _ILJitGetReturnType(smallerType, jitCoder->process);
ILJitValue newObj;
- ILJitValue args[3];
-
- jit_label_t label1 = jit_label_undefined;
/* Allocate memory */
- args[0] = jit_value_get_param(jitCoder->jitFunction, 0);
- args[1] = jit_value_create_nint_constant(jitCoder->jitFunction,
-
_IL_JIT_TYPE_VPTR,
-
(jit_nint)boxClass);
- args[2] = jit_value_create_nint_constant(jitCoder->jitFunction,
-
_IL_JIT_TYPE_UINT32,
-
jit_type_get_size(jitType));
-
- newObj = jit_insn_call_native(jitCoder->jitFunction, "_ILEngineAlloc",
-
_ILEngineAlloc, _ILJitSignature_ILEngineAlloc,
- args, 3, 0);
-
- jit_insn_branch_if(jitCoder->jitFunction, newObj, &label1);
- _ILJitThrowCurrentException(jitCoder);
- jit_insn_label(jitCoder->jitFunction, &label1);
-
+ newObj = _ILJitAllocGen(jitCoder, boxClass, jit_type_get_size(jitType));
/* If the smallerType is smaller then the initiale type then convert to
it. */
if(jit_value_get_type(value) != jitType)
Index: pnet/engine/jitc_ptr.c
diff -u pnet/engine/jitc_ptr.c:1.8 pnet/engine/jitc_ptr.c:1.9
--- pnet/engine/jitc_ptr.c:1.8 Mon Apr 10 19:40:26 2006
+++ pnet/engine/jitc_ptr.c Mon Apr 17 17:39:44 2006
@@ -102,7 +102,7 @@
/* Convert the value to the array type when needed. */
if(valueType != type)
{
- value = jit_insn_convert(coder->jitFunction, value, type, 0);
+ value = _ILJitValueConvertImplicit(coder->jitFunction, value,
type);
}
jit_insn_store_elem(coder->jitFunction, arrayBase, index, value);
JITC_ADJUST(coder, -3);
@@ -134,7 +134,7 @@
_ILJitCheckNull(coder, ptr);
if(valueType != type)
{
- value = jit_insn_convert(coder->jitFunction, value, type, 0);
+ value = _ILJitValueConvertImplicit(coder->jitFunction, value,
type);
}
jit_insn_store_relative(coder->jitFunction, ptr, (jit_nint)0, value);
JITC_ADJUST(coder, -2);
@@ -483,8 +483,10 @@
address = jitCoder->jitStack[jitCoder->stackTop - 1];
_ILJitCheckNull(jitCoder, address);
jitCoder->jitStack[jitCoder->stackTop - 1] =
- jit_insn_load_relative(jitCoder->jitFunction, address,
(jit_nint)0,
- jitType);
+ _ILJitValueConvertToStackType(jitCoder->jitFunction,
+
jit_insn_load_relative(jitCoder->jitFunction,
+
address, (jit_nint)0,
+
jitType));
}
else
{
@@ -496,7 +498,8 @@
if(jit_value_get_type(object) != jitType)
{
- object = jit_insn_convert(jitCoder->jitFunction,
object, jitType, 0);
+ object =
_ILJitValueConvertImplicit(jitCoder->jitFunction, object,
+
jitType);
}
jit_insn_store_relative(jitCoder->jitFunction, address,
(jit_nint)0, object);
JITC_ADJUST(jitCoder, -2);
@@ -524,7 +527,10 @@
_ILJitCheckNull(jitCoder, array);
len = GetArrayLength(jitCoder, array);
jitCoder->jitStack[jitCoder->stackTop - 1] =
- jit_insn_convert(jitCoder->jitFunction, len,
_IL_JIT_TYPE_NUINT, 0);
+ _ILJitValueConvertToStackType(jitCoder->jitFunction,
+
jit_insn_convert(jitCoder->jitFunction,
+
len,
+
_IL_JIT_TYPE_NUINT, 0));
}
/*
Index: pnet/engine/jitc_setup.c
diff -u pnet/engine/jitc_setup.c:1.12 pnet/engine/jitc_setup.c:1.13
--- pnet/engine/jitc_setup.c:1.12 Sun Mar 19 11:29:11 2006
+++ pnet/engine/jitc_setup.c Mon Apr 17 17:39:44 2006
@@ -59,6 +59,9 @@
{
return 0;
}
+#ifdef _IL_JIT_OPTIMIZE_INIT_LOCALS
+ coder->localsInitialized = 0;
+#endif
/* Ensure that the evaluation stack can hold at least the methods
maxStack */
/* items. */
Index: pnet/engine/jitc_var.c
diff -u pnet/engine/jitc_var.c:1.7 pnet/engine/jitc_var.c:1.8
--- pnet/engine/jitc_var.c:1.7 Wed Mar 8 21:03:52 2006
+++ pnet/engine/jitc_var.c Mon Apr 17 17:39:44 2006
@@ -86,7 +86,6 @@
ILEngineType
engineType, ILType *type)
{
ILJITCoder *jitCoder = _ILCoderToILJITCoder(coder);
- ILJitValue argValue = _ILJitParamValue(jitCoder, argNum);
#if !defined(IL_CONFIG_REDUCE_CODE) && !defined(IL_WITHOUT_TOOLS)
if (jitCoder->flags & IL_CODER_FLAG_STATS)
@@ -98,15 +97,11 @@
ILMutexUnlock(globalTraceMutex);
}
#endif
- JITC_ADJUST(jitCoder, -1);
-
-#ifdef _IL_JIT_OPTIMIZE_LOCALS
- _ILJitValueFindAndDup(jitCoder, argValue);
-#endif
- jit_insn_store(jitCoder->jitFunction, argValue,
- jitCoder->jitStack[jitCoder->stackTop]);
+ JITC_ADJUST(jitCoder, -1);
+ _ILJitParamStoreValue(jitCoder, argNum,
+
jitCoder->jitStack[jitCoder->stackTop]);
}
/*
@@ -116,7 +111,6 @@
ILEngineType
engineType, ILType *type)
{
ILJITCoder *jitCoder = _ILCoderToILJITCoder(coder);
- ILJitValue localValue = _ILJitLocalValue(jitCoder, localNum);
#if !defined(IL_CONFIG_REDUCE_CODE) && !defined(IL_WITHOUT_TOOLS)
if (jitCoder->flags & IL_CODER_FLAG_STATS)
@@ -131,13 +125,8 @@
JITC_ADJUST(jitCoder, -1);
-#ifdef _IL_JIT_OPTIMIZE_LOCALS
- _ILJitValueFindAndDup(jitCoder, localValue);
-#endif
-
- jit_insn_store(jitCoder->jitFunction, localValue,
- jitCoder->jitStack[jitCoder->stackTop]);
-
+ _ILJitLocalStoreValue(jitCoder, localNum,
+
jitCoder->jitStack[jitCoder->stackTop]);
}
/*
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- [dotgnu-pnet-commits] pnet ./ChangeLog engine/Makefile.am engine/jitc...,
Klaus Treichel <=