rendered paste body/*
* jitc_obj.c - Coder implementation for JIT object operations.
*
* Copyright (C) 2001 Southern Storm Software, Pty Ltd.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifdef IL_JITC_CODE
/*
* Get a ILJitValue with a pointer to the class' static area.
*/
static ILJitValue _ILJitGetClassStaticArea(ILExecThread *thread,
ILJitFunction func,
ILField *field)
{
/* Get the static data area for a particular class */
ILClass *classInfo = ILField_Owner(field);
void *classStaticData = ((ILClassPrivate *)(classInfo->userData))->staticData;
ILJitValue staticData;
if(!classStaticData)
{
if(((ILClassPrivate *)(classInfo->userData))->managedStatic)
{
classStaticData = _ILEngineAlloc(thread, 0,
((ILClassPrivate *)(classInfo->userData))->staticSize);
}
else
{
/* There are no managed fields in the static area,
so use atomic allocation */
classStaticData = _ILEngineAllocAtomic(thread, 0,
((ILClassPrivate *)(classInfo->userData))->staticSize);
}
if(!classStaticData)
{
jit_exception_builtin(JIT_RESULT_OUT_OF_MEMORY);
}
else
{
((ILClassPrivate *)(classInfo->userData))->staticData = classStaticData;
}
}
staticData = jit_value_create_nint_constant(func, _IL_JIT_TYPE_VPTR,
(jit_nint)classStaticData);
return staticData;
}
static void JITCoder_CastClass(ILCoder *coder, ILClass *classInfo,
int throwException)
{
ILJITCoder *jitCoder = _ILCoderToILJITCoder(coder);
ILJitValue classTo = jit_value_create_nint_constant(jitCoder->jitFunction,
_IL_JIT_TYPE_VPTR,
(jit_nint)classInfo);
ILJitValue object = jitCoder->jitStack[jitCoder->stackTop - 1];
jit_label_t label = jit_label_undefined;
ILJitValue args[3];
ILJitValue returnValue;
jit_insn_branch_if_not(jitCoder->jitFunction, object, &label);
if(ILClass_IsInterface(classInfo))
{
/* We are casting to an interface */
args[0] = object;
args[1] = classTo;
returnValue = jit_insn_call_native(jitCoder->jitFunction, 0,
ILRuntimeClassImplements,
_ILJitSignature_ILRuntimeClassImplements,
args, 2, 0);
jit_insn_branch_if(jitCoder->jitFunction, returnValue, &label);
if(throwException)
{
/* TODO: Throw an InvalidCastException here. */
}
else
{
ILJitValue nullPointer =
jit_value_create_nint_constant(jitCoder->jitFunction,
_IL_JIT_TYPE_VPTR,
(jit_nint)0);
jitCoder->jitStack[jitCoder->stackTop - 1] = nullPointer;
}
}
else
{
args[0] = jit_value_get_param(jitCoder->jitFunction, 0);
args[1] = object;
args[2] = classTo;
returnValue = jit_insn_call_native(jitCoder->jitFunction, 0,
ILRuntimeCanCastClass,
_ILJitSignature_ILRuntimeCanCastClass,
args, 3, 0);
jit_insn_branch_if(jitCoder->jitFunction, returnValue, &label);
if(throwException)
{
/* TODO: Throw an InvalidCastException here. */
}
else
{
ILJitValue nullPointer =
jit_value_create_nint_constant(jitCoder->jitFunction,
_IL_JIT_TYPE_VPTR,
(jit_nint)0);
jitCoder->jitStack[jitCoder->stackTop - 1] = nullPointer;
}
}
jit_insn_label(jitCoder->jitFunction, &label);
}
static void JITCoder_LoadField(ILCoder *coder, ILEngineType ptrType,
ILType *objectType, ILField *field,
ILType *fieldType)
{
}
static void JITCoder_LoadThisField(ILCoder *coder, ILField *field,
ILType *fieldType)
{
}
static void JITCoder_LoadStaticField(ILCoder *coder, ILField *field,
ILType *fieldType)
{
}
static void JITCoder_LoadFieldAddr(ILCoder *coder, ILEngineType ptrType,
ILType *objectType, ILField *field,
ILType *fieldType)
{
}
static void JITCoder_LoadStaticFieldAddr(ILCoder *coder, ILField *field,
ILType *fieldType)
{
}
static void JITCoder_StoreField(ILCoder *coder, ILEngineType ptrType,
ILType *objectType, ILField *field,
ILType *fieldType, ILEngineType valueType)
{
}
static void JITCoder_StoreStaticField(ILCoder *coder, ILField *field,
ILType *fieldType, ILEngineType valueType)
{
}
static void JITCoder_CopyObject(ILCoder *coder, ILEngineType destPtrType,
ILEngineType srcPtrType, ILClass *classInfo)
{
}
static void JITCoder_CopyBlock(ILCoder *coder, ILEngineType destPtrType,
ILEngineType srcPtrType)
{
}
static void JITCoder_InitObject(ILCoder *coder, ILEngineType ptrType,
ILClass *classInfo)
{
}
static void JITCoder_InitBlock(ILCoder *coder, ILEngineType ptrType)
{
}
static void JITCoder_Box(ILCoder *coder, ILClass *boxClass,
ILEngineType valueType, ILUInt32 size)
{
ILJITCoder *jitCoder = _ILCoderToILJITCoder(coder);
ILJitValue newObj;
ILJitValue args[3];
jit_label_t label1 = jit_label_undefined;
jit_label_t label2 = 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,
jit_type_int, size);
newObj = jit_insn_call_native(jitCoder->jitFunction, 0, _ILEngineAlloc,
_ILJitSignature_ILEngineAlloc, args, 3, 0);
jit_insn_branch_if(jitCoder->jitFunction, newObj, &label1);
_ILJitThrowCurrentException(jitCoder);
jit_insn_label(jitCoder->jitFunction, &label1);
jit_value_t const_size = jit_value_create_nint_constant(jitCoder->jitFunction,
jit_type_uint, (jit_nint)size);
/* Memcpy. */
if(valueType != ILEngineType_TypedRef)
{
ILJitValue value = jitCoder->jitStack[jitCoder->stackTop - 1];
ILType *type = ILClassToType(boxClass);
ILJitType jitType = _ILJitGetReturnType(type, jitCoder->process);
if(jit_value_get_type(value)!=jitType)
{
value = jit_insn_convert(jitCoder->jitFunction, value, jitType, 1);
}
/* Box a managed value */
jit_insn_store_relative(jitCoder->jitFunction,
newObj,
0,
value);
}
else
{
/* Box a typed reference after we unpack it */
jit_value_t result = jit_insn_memcpy(jitCoder->jitFunction,
newObj,
jitCoder->jitStack[jitCoder->stackTop - 1],
(jit_nint)const_size);
jit_insn_branch_if(jitCoder->jitFunction, result, &label2);
_ILJitThrowCurrentException(jitCoder);
jit_insn_label(jitCoder->jitFunction, &label2);
}
jitCoder->jitStack[jitCoder->stackTop - 1] = newObj;
}
static void JITCoder_BoxSmaller(ILCoder *coder, ILClass *boxClass,
ILEngineType valueType, ILType *smallerType)
{
ILJITCoder *jitCoder = _ILCoderToILJITCoder(coder);
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,
jit_type_int, 8);
newObj = jit_insn_call_native(jitCoder->jitFunction, 0, _ILEngineAlloc,
_ILJitSignature_ILEngineAlloc, args, 3, 0);
jit_insn_branch_if(jitCoder->jitFunction, newObj, &label1);
_ILJitThrowCurrentException(jitCoder);
jit_insn_label(jitCoder->jitFunction, &label1);
ILJitValue value = jitCoder->jitStack[jitCoder->stackTop - 1];
ILJitType jitType = _ILJitGetReturnType(smallerType, jitCoder->process);
if(jit_value_get_type(value)!=jitType) /* If the smallerType is really smaller then convert to it. */
{
value = jit_insn_convert(jitCoder->jitFunction, value, jitType, 1);
}
jit_insn_store_relative(jitCoder->jitFunction,
newObj,
0,
value);
jitCoder->jitStack[jitCoder->stackTop - 1] = newObj;
}
static void JITCoder_Unbox(ILCoder *coder, ILClass *boxClass)
{
// DO NOTHING
}
static void JITCoder_MakeTypedRef(ILCoder *coder, ILClass *classInfo)
{
// DO NOTHING as TypedRef in the stack is _ILJitType_VPTR
}
static void JITCoder_RefAnyVal(ILCoder *coder, ILClass *classInfo)
{
// DO NOTHING
}
static void JITCoder_RefAnyType(ILCoder *coder)
{
// Retrieve the type
// DO NOTHING ???
}
static void JITCoder_PushToken(ILCoder *coder, ILProgramItem *item)
{
ILJITCoder *jitCoder = _ILCoderToILJITCoder(coder);
ILJitValue token = jit_value_create_nint_constant(jitCoder->jitFunction,
_IL_JIT_TYPE_VPTR,
(jit_nint)item);
jitCoder->jitStack[jitCoder->stackTop] = token;
JITC_ADJUST(jitCoder, 1);
}
static void JITCoder_SizeOf(ILCoder *coder, ILType *type)
{
ILUInt32 size;
size = _ILSizeOfTypeLocked(jitCoder->process, type);
jit_value_t const_size = jit_value_create_nint_constant(jitCoder->jitFunction,
jit_type_uint, (jit_nint)size);
jitCoder->jitStack[jitCoder->stackTop - 1] = const_size;
}
static void JITCoder_ArgList(ILCoder *coder)
{
// methodInfo->numVarArgs;
//
}
#endif /* IL_JITC_CODE */