/* * Handle a label. */ static void JITCoder_Label(ILCoder *coder, ILUInt32 offset) { ILJITCoder *jitCoder = _ILCoderToILJITCoder(coder); ILJITLabel *label = _ILJitLabelGet(jitCoder, offset, _IL_JIT_LABEL_NORMAL); if(label) { _ILJitValuesResetNullChecked(jitCoder); if(label->labelType == _IL_JIT_LABEL_STARTFINALLY) { #if !defined(IL_CONFIG_REDUCE_CODE) && !defined(IL_WITHOUT_TOOLS) if (jitCoder->flags & IL_CODER_FLAG_STATS) { ILMutexLock(globalTraceMutex); fprintf(stdout, "StartFinally: %i\n", offset); ILMutexUnlock(globalTraceMutex); } #endif jit_insn_start_finally(jitCoder->jitFunction, &(label->label)); } else { #if !defined(IL_CONFIG_REDUCE_CODE) && !defined(IL_WITHOUT_TOOLS) if (jitCoder->flags & IL_CODER_FLAG_STATS) { ILMutexLock(globalTraceMutex); fprintf(stdout, "Label: %i\n", offset); ILMutexUnlock(globalTraceMutex); } #endif _ILJitLabelRestoreStack(jitCoder, label); jit_insn_label(jitCoder->jitFunction, &(label->label)); } } }
/* * Inline function to get the character at the specified indexe in a * string. */ static int _ILJitSystemStringChars(ILJITCoder *jitCoder, ILMethod *method, ILCoderMethodInfo *methodInfo, ILJitStackItem *args, ILInt32 numArgs) { ILJitFunction jitFunction = ILJitFunctionFromILMethod(method); ILClass *stringClass = ILMethod_Owner(method); ILJitValue length; ILJitValue stringBase; ILJitValue returnValue; if(!jitFunction) { /* We need to layout the class first. */ if(!_LayoutClass(ILExecThreadCurrent(), stringClass)) { return 0; } if(!(jitFunction = ILJitFunctionFromILMethod(method))) { return 0; } } #if !defined(IL_CONFIG_REDUCE_CODE) && !defined(IL_WITHOUT_TOOLS) && defined(_IL_JIT_ENABLE_DEBUG) if(jitCoder->flags & IL_CODER_FLAG_STATS) { ILMutexLock(globalTraceMutex); fprintf(stdout, "Inline System.String::get_Chars\n"); ILMutexUnlock(globalTraceMutex); } #endif _ILJitStackItemCheckNull(jitCoder, args[0]); length = _ILJitStringGetLength(jitCoder->jitFunction, _ILJitStackItemValue(args[0])); JITC_START_CHECK_STRING_INDEX(jitCoder, length, _ILJitStackItemValue(args[1])) stringBase = _ILJitStringGetStart(jitCoder->jitFunction, _ILJitStackItemValue(args[0])); returnValue = jit_insn_load_elem(jitCoder->jitFunction, stringBase, _ILJitStackItemValue(args[1]), _IL_JIT_TYPE_CHAR); JITC_END_CHECK_STRING_INDEX(jitCoder) _ILJitStackPushValue(jitCoder, returnValue); return 1; }
/* * Output a branch instruction using a JIT coder. */ static void JITCoder_Branch(ILCoder *coder, int opcode, ILUInt32 dest, ILEngineType type1, ILEngineType type2) { ILJITCoder *jitCoder = _ILCoderToILJITCoder(coder); ILJITLabel *label = 0; ILJitValue temp = 0; _ILJitStackItemNew(value2); _ILJitStackItemNew(value1); #if !defined(IL_CONFIG_REDUCE_CODE) && !defined(IL_WITHOUT_TOOLS) if (jitCoder->flags & IL_CODER_FLAG_STATS) { ILMutexLock(globalTraceMutex); fprintf(stdout, "Branch: %i\n", dest); ILMutexUnlock(globalTraceMutex); } #endif /* Determine what form of branch to use */ switch(opcode) { case IL_OP_BR: case IL_OP_BR_S: case IL_OP_LEAVE: case IL_OP_LEAVE_S: { /* Unconditional branch */ label = _ILJitLabelGet(jitCoder, dest, _IL_JIT_LABEL_NORMAL); jit_insn_branch(jitCoder->jitFunction, &(label->label)); } break; case IL_OP_BRTRUE_S: case IL_OP_BRTRUE: { /* Branch if the top-most stack item is true */ _ILJitStackPop(jitCoder, value1); label = _ILJitLabelGet(jitCoder, dest, _IL_JIT_LABEL_NORMAL); jit_insn_branch_if(jitCoder->jitFunction, _ILJitStackItemValue(value1), &(label->label)); } break; case IL_OP_BRFALSE_S: case IL_OP_BRFALSE: { /* Branch if the top-most stack item is false */ _ILJitStackPop(jitCoder, value1); label = _ILJitLabelGet(jitCoder, dest, _IL_JIT_LABEL_NORMAL); jit_insn_branch_if_not(jitCoder->jitFunction, _ILJitStackItemValue(value1), &(label->label)); } break; default: { _ILJitStackPop(jitCoder, value2); _ILJitStackPop(jitCoder, value1); label = _ILJitLabelGet(jitCoder, dest, _IL_JIT_LABEL_NORMAL); switch(opcode) { case IL_OP_BEQ: case IL_OP_BEQ_S: { /* Equality testing branch */ temp = OutputCompare(jitCoder, IL_OP_BEQ, &(_ILJitStackItemValue(value1)), &(_ILJitStackItemValue(value2))); jit_insn_branch_if(jitCoder->jitFunction, temp, &(label->label)); } break; case IL_OP_BNE_UN: case IL_OP_BNE_UN_S: { /* Unsigned inequality testing branch */ temp = OutputCompare(jitCoder, IL_OP_BNE_UN, &(_ILJitStackItemValue(value1)), &(_ILJitStackItemValue(value2))); jit_insn_branch_if(jitCoder->jitFunction, temp, &(label->label)); } break; case IL_OP_BGT: case IL_OP_BGT_S: { /* Signed greater than testing branch */ temp = OutputCompare(jitCoder, IL_OP_BGT, &(_ILJitStackItemValue(value1)), &(_ILJitStackItemValue(value2))); jit_insn_branch_if(jitCoder->jitFunction, temp, &(label->label)); } break; case IL_OP_BGT_UN: case IL_OP_BGT_UN_S: { /* Unsigned greater than testing branch */ temp = OutputCompare(jitCoder, IL_OP_BGT_UN, &(_ILJitStackItemValue(value1)), &(_ILJitStackItemValue(value2))); jit_insn_branch_if(jitCoder->jitFunction, temp, &(label->label)); } break; case IL_OP_BGE: case IL_OP_BGE_S: { /* Signed greater than or equal testing branch */ temp = OutputCompare(jitCoder, IL_OP_BGE, &(_ILJitStackItemValue(value1)), &(_ILJitStackItemValue(value2))); jit_insn_branch_if(jitCoder->jitFunction, temp, &(label->label)); } break; case IL_OP_BGE_UN: case IL_OP_BGE_UN_S: { /* Unsigned greater than or equal testing branch */ temp = OutputCompare(jitCoder, IL_OP_BGE_UN, &(_ILJitStackItemValue(value1)), &(_ILJitStackItemValue(value2))); jit_insn_branch_if(jitCoder->jitFunction, temp, &(label->label)); } break; case IL_OP_BLT: case IL_OP_BLT_S: { /* Signed less than testing branch */ temp = OutputCompare(jitCoder, IL_OP_BLT, &(_ILJitStackItemValue(value1)), &(_ILJitStackItemValue(value2))); jit_insn_branch_if(jitCoder->jitFunction, temp, &(label->label)); } break; case IL_OP_BLT_UN: case IL_OP_BLT_UN_S: { /* Unsigned less than testing branch */ temp = OutputCompare(jitCoder, IL_OP_BLT_UN, &(_ILJitStackItemValue(value1)), &(_ILJitStackItemValue(value2))); jit_insn_branch_if(jitCoder->jitFunction, temp, &(label->label)); } break; case IL_OP_BLE: case IL_OP_BLE_S: { /* Signed less than or equal testing branch */ temp = OutputCompare(jitCoder, IL_OP_BLE, &(_ILJitStackItemValue(value1)), &(_ILJitStackItemValue(value2))); jit_insn_branch_if(jitCoder->jitFunction, temp, &(label->label)); } break; case IL_OP_BLE_UN: case IL_OP_BLE_UN_S: { /* Unsigned less than or equal testing branch */ temp = OutputCompare(jitCoder, IL_OP_BLE_UN, &(_ILJitStackItemValue(value1)), &(_ILJitStackItemValue(value2))); jit_insn_branch_if(jitCoder->jitFunction, temp, &(label->label)); } break; } } break; } }
/* * Destroy the engine. */ void ILExecEngineDestroy(ILExecEngine *engine) { int count; ILExecProcess *process; ILQueueEntry *unloadQueue, *destroyQueue; unloadQueue = ILQueueCreate(); destroyQueue = ILQueueCreate(); /* Lock the engine process list*/ ILMutexLock(engine->processLock); count = 0; /* Walk all the application domains and collect them */ process = engine->firstProcess; while (process) { if (process != engine->defaultProcess) { if(process->state < _IL_PROCESS_STATE_UNLOADING) { ILQueueAdd(&unloadQueue, process); } ILQueueAdd(&destroyQueue, process); count++; } /* Move onto the next process */ process = process->nextProcess; } /* Unlock the engine process list */ ILMutexUnlock(engine->processLock); if ((!unloadQueue || !destroyQueue) && count != 0) { /* Probably ran out of memory trying to build the unload and destroy queue */ return; } /* unload all processes */ while (unloadQueue) { process = (ILExecProcess *)ILQueueRemove(&unloadQueue); ILExecProcessUnload(process); } /* now destroy the processes */ while (destroyQueue) { process = (ILExecProcess *)ILQueueRemove(&destroyQueue); ILExecProcessDestroy(process); } /* now unload and destroy the default process */ if(engine->defaultProcess) { ILExecProcessUnload(engine->defaultProcess); ILExecProcessDestroy(engine->defaultProcess); } if (engine->processLock) { /* Destroy the process list lock */ ILMutexDestroy(engine->processLock); } /* Free the engine block itself */ ILGCFreePersistent(engine); }
/* * Inline function to create a new string with the given length */ static int _ILJitSystemStringNew(ILJITCoder *jitCoder, ILMethod *method, ILCoderMethodInfo *methodInfo, ILJitStackItem *args, ILInt32 numArgs) { ILJitFunction jitFunction = ILJitFunctionFromILMethod(method); ILClass *stringClass = ILMethod_Owner(method); ILJitValue newString; ILJitValue callArgs[2]; if(!jitFunction) { /* We need to layout the class first. */ if(!_LayoutClass(ILExecThreadCurrent(), stringClass)) { return 0; } if(!(jitFunction = ILJitFunctionFromILMethod(method))) { return 0; } } #if !defined(IL_CONFIG_REDUCE_CODE) && !defined(IL_WITHOUT_TOOLS) && defined(_IL_JIT_ENABLE_DEBUG) if(jitCoder->flags & IL_CODER_FLAG_STATS) { ILMutexLock(globalTraceMutex); fprintf(stdout, "Inline System.String::NewString\n"); ILMutexUnlock(globalTraceMutex); } #endif /* We call the alloc functions. */ /* They thow an out of memory exception so we don't need to care. */ callArgs[0] = jit_value_create_nint_constant(jitCoder->jitFunction, _IL_JIT_TYPE_VPTR, (jit_nint)stringClass); if(!callArgs[0]) { return 0; } callArgs[1] = _ILJitValueConvertImplicit(jitCoder->jitFunction, _ILJitStackItemValue(args[0]), _IL_JIT_TYPE_UINT32); if(!callArgs[1]) { return 0; } newString = jit_insn_call_native(jitCoder->jitFunction, "_ILJitStringAlloc", _ILJitStringAlloc, _ILJitSignature_ILJitStringAlloc, callArgs, 2, 0); if(!newString) { return 0; } _ILJitStackPushValue(jitCoder, newString); return 1; }