/* * Copyright (C) 2012 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /*! \file LowerJump.cpp \brief This file lowers the following bytecodes: IF_XXX, GOTO */ #include <math.h> #include "libdex/DexOpcodes.h" #include "libdex/DexFile.h" #include "Lower.h" #include "NcgAot.h" #include "enc_wrapper.h" #include "interp/InterpDefs.h" #include "NcgHelper.h" LabelMap* globalMap; LabelMap* globalShortMap;//make sure for each bytecode, there is no duplicated label LabelMap* globalWorklist = NULL; LabelMap* globalShortWorklist; int globalMapNum; int globalWorklistNum; int globalDataWorklistNum; int VMAPIWorklistNum; int globalPCWorklistNum; int chainingWorklistNum; LabelMap* globalDataWorklist = NULL; LabelMap* globalPCWorklist = NULL; LabelMap* chainingWorklist = NULL; LabelMap* VMAPIWorklist = NULL; char* ncgClassData; char* ncgClassDataPtr; char* ncgMethodData; char* ncgMethodDataPtr; int ncgClassNum; int ncgMethodNum; NCGWorklist* globalNCGWorklist; DataWorklist* methodDataWorklist; #ifdef ENABLE_TRACING MapWorklist* methodMapWorklist; #endif /*! \brief search globalShortMap to find the entry for the given label */ LabelMap* findItemForShortLabel(const char* label) { LabelMap* ptr = globalShortMap; while(ptr != NULL) { if(!strcmp(label, ptr->label)) { return ptr; } ptr = ptr->nextItem; } return NULL; } //assume size of "jump reg" is 2 #define JUMP_REG_SIZE 2 #define ADD_REG_REG_SIZE 3 /*! \brief update value of the immediate in the given jump instruction check whether the immediate is out of range for the pre-set size */ int updateJumpInst(char* jumpInst, OpndSize immSize, int relativeNCG) { #ifdef DEBUG_NCG_JUMP ALOGI("update jump inst @ %p with %d", jumpInst, relativeNCG); #endif if(immSize == OpndSize_8) { //-128 to 127 if(relativeNCG >= 128 || relativeNCG < -128) { ALOGE("pre-allocated space for a forward jump is not big enough"); dvmAbort(); } } if(immSize == OpndSize_16) { //-2^16 to 2^16-1 if(relativeNCG >= 32768 || relativeNCG < -32768) { ALOGE("pre-allocated space for a forward jump is not big enough"); dvmAbort(); } } encoder_update_imm(relativeNCG, jumpInst); return 0; } /*! \brief insert a label It takes argument checkDup, if checkDup is true, an entry is created in globalShortMap, entries in globalShortWorklist are checked, if there exists a match, the immediate in the jump instruction is updated and the entry is removed from globalShortWorklist; otherwise, an entry is created in globalMap. */ int insertLabel(const char* label, bool checkDup) { LabelMap* item = NULL; if(!checkDup) { item = (LabelMap*)malloc(sizeof(LabelMap)); if(item == NULL) { ALOGE("Memory allocation failed"); return -1; } snprintf(item->label, LABEL_SIZE, "%s", label); item->codePtr = stream; item->nextItem = globalMap; globalMap = item; #ifdef DEBUG_NCG_CODE_SIZE ALOGI("insert global label %s %p", label, stream); #endif globalMapNum++; return 0; } item = (LabelMap*)malloc(sizeof(LabelMap)); if(item == NULL) { ALOGE("Memory allocation failed"); return -1; } snprintf(item->label, LABEL_SIZE, "%s", label); item->codePtr = stream; item->nextItem = globalShortMap; globalShortMap = item; #ifdef DEBUG_NCG ALOGI("insert short-term label %s %p", label, stream); #endif LabelMap* ptr = globalShortWorklist; LabelMap* ptr_prevItem = NULL; while(ptr != NULL) { if(!strcmp(ptr->label, label)) { //perform work int relativeNCG = stream - ptr->codePtr; unsigned instSize = encoder_get_inst_size(ptr->codePtr); relativeNCG -= instSize; //size of the instruction #ifdef DEBUG_NCG ALOGI("perform work short-term %p for label %s relative %d", ptr->codePtr, label, relativeNCG); #endif updateJumpInst(ptr->codePtr, ptr->size, relativeNCG); //remove work if(ptr_prevItem == NULL) { globalShortWorklist = ptr->nextItem; free(ptr); ptr = globalShortWorklist; //ptr_prevItem is still NULL } else { ptr_prevItem->nextItem = ptr->nextItem; free(ptr); ptr = ptr_prevItem->nextItem; } } else { ptr_prevItem = ptr; ptr = ptr->nextItem; } } //while return 0; } /*! \brief search globalMap to find the entry for the given label */ char* findCodeForLabel(const char* label) { LabelMap* ptr = globalMap; while(ptr != NULL) { if(!strcmp(label, ptr->label)) { return ptr->codePtr; } ptr = ptr->nextItem; } return NULL; } /*! \brief search globalShortMap to find the entry for the given label */ char* findCodeForShortLabel(const char* label) { LabelMap* ptr = globalShortMap; while(ptr != NULL) { if(!strcmp(label, ptr->label)) { return ptr->codePtr; } ptr = ptr->nextItem; } return NULL; } int insertLabelWorklist(const char* label, OpndSize immSize) { LabelMap* item = (LabelMap*)malloc(sizeof(LabelMap)); if(item == NULL) { ALOGE("Memory allocation failed"); return -1; } snprintf(item->label, LABEL_SIZE, "%s", label); item->codePtr = stream; item->size = immSize; item->nextItem = globalWorklist; globalWorklist = item; #ifdef DEBUG_NCG ALOGI("insert globalWorklist: %s %p", label, stream); #endif return 0; } int insertShortWorklist(const char* label, OpndSize immSize) { LabelMap* item = (LabelMap*)malloc(sizeof(LabelMap)); if(item == NULL) { ALOGE("Memory allocation failed"); return -1; } snprintf(item->label, LABEL_SIZE, "%s", label); item->codePtr = stream; item->size = immSize; item->nextItem = globalShortWorklist; globalShortWorklist = item; #ifdef DEBUG_NCG ALOGI("insert globalShortWorklist: %s %p", label, stream); #endif return 0; } /*! \brief free memory allocated for globalMap */ void freeLabelMap() { LabelMap* ptr = globalMap; while(ptr != NULL) { globalMap = ptr->nextItem; free(ptr); ptr = globalMap; } } /*! \brief free memory allocated for globalShortMap */ void freeShortMap() { LabelMap* ptr = globalShortMap; while(ptr != NULL) { globalShortMap = ptr->nextItem; free(ptr); ptr = globalShortMap; } globalShortMap = NULL; } int insertGlobalPCWorklist(char * offset, char * codeStart) { LabelMap* item = (LabelMap*)malloc(sizeof(LabelMap)); if(item == NULL) { ALOGE("Memory allocation failed"); return -1; } snprintf(item->label, LABEL_SIZE, "%s", "export_pc"); item->size = OpndSize_32; item->codePtr = offset; //points to the immediate operand item->addend = codeStart - streamMethodStart; //relative code pointer item->nextItem = globalPCWorklist; globalPCWorklist = item; globalPCWorklistNum ++; #ifdef DEBUG_NCG ALOGI("insert globalPCWorklist: %p %p %p %x %p", globalDvmNcg->streamCode, codeStart, streamCode, item->addend, item->codePtr); #endif return 0; } int insertChainingWorklist(int bbId, char * codeStart) { LabelMap* item = (LabelMap*)malloc(sizeof(LabelMap)); if(item == NULL) { ALOGE("Memory allocation failed"); return -1; } item->size = OpndSize_32; item->codePtr = codeStart; //points to the move instruction item->addend = bbId; //relative code pointer item->nextItem = chainingWorklist; chainingWorklist = item; #ifdef DEBUG_NCG ALOGI("insertChainingWorklist: %p basic block %d", codeStart, bbId); #endif return 0; } int insertGlobalDataWorklist(char * offset, const char* label) { LabelMap* item = (LabelMap*)malloc(sizeof(LabelMap)); if(item == NULL) { ALOGE("Memory allocation failed"); return -1; } snprintf(item->label, LABEL_SIZE, "%s", label); item->codePtr = offset; item->size = OpndSize_32; item->nextItem = globalDataWorklist; globalDataWorklist = item; globalDataWorklistNum ++; #ifdef DEBUG_NCG ALOGI("insert globalDataWorklist: %s %p", label, offset); #endif return 0; } int insertVMAPIWorklist(char * offset, const char* label) { LabelMap* item = (LabelMap*)malloc(sizeof(LabelMap)); if(item == NULL) { ALOGE("Memory allocation failed"); return -1; } snprintf(item->label, LABEL_SIZE, "%s", label); item->codePtr = offset; item->size = OpndSize_32; item->nextItem = VMAPIWorklist; VMAPIWorklist = item; VMAPIWorklistNum ++; #ifdef DEBUG_NCG ALOGI("insert VMAPIWorklist: %s %p", label, offset); #endif return 0; } //////////////////////////////////////////////// int updateImmRMInst(char* moveInst, const char* label, int relativeNCG); //forward declaration //////////////////// performLabelWorklist is defined differently for code cache void performChainingWorklist() { LabelMap* ptr = chainingWorklist; while(ptr != NULL) { int tmpNCG = traceLabelList[ptr->addend].lop.generic.offset; char* NCGaddr = streamMethodStart + tmpNCG; updateImmRMInst(ptr->codePtr, "", (int)NCGaddr); chainingWorklist = ptr->nextItem; free(ptr); ptr = chainingWorklist; } } void freeChainingWorklist() { LabelMap* ptr = chainingWorklist; while(ptr != NULL) { chainingWorklist = ptr->nextItem; free(ptr); ptr = chainingWorklist; } } //Work only for initNCG void performLabelWorklist() { LabelMap* ptr = globalWorklist; while(ptr != NULL) { #ifdef DEBUG_NCG ALOGI("perform work global %p for label %s", ptr->codePtr, ptr->label); #endif char* targetCode = findCodeForLabel(ptr->label); assert(targetCode != NULL); int relativeNCG = targetCode - ptr->codePtr; unsigned instSize = encoder_get_inst_size(ptr->codePtr); relativeNCG -= instSize; //size of the instruction updateJumpInst(ptr->codePtr, ptr->size, relativeNCG); globalWorklist = ptr->nextItem; free(ptr); ptr = globalWorklist; } } void freeLabelWorklist() { LabelMap* ptr = globalWorklist; while(ptr != NULL) { globalWorklist = ptr->nextItem; free(ptr); ptr = globalWorklist; } } /////////////////////////////////////////////////// /*! \brief update value of the immediate in the given move instruction */ int updateImmRMInst(char* moveInst, const char* label, int relativeNCG) { #ifdef DEBUG_NCG ALOGI("perform work ImmRM inst @ %p for label %s with %d", moveInst, label, relativeNCG); #endif encoder_update_imm_rm(relativeNCG, moveInst); return 0; } //! maximum instruction size for jump,jcc,call: 6 for jcc rel32 #define MAX_JCC_SIZE 6 //! minimum instruction size for jump,jcc,call: 2 #define MIN_JCC_SIZE 2 /*! \brief estimate size of the immediate Somehow, 16 bit jump does not work. This function will return either 8 bit or 32 bit EXAMPLE: native code at A: ... native code at B: jump relOffset (target is A) native code at B': --> relOffset = A - B' = A - B - size of the jump instruction Argument "target" is equal to A - B. To determine size of the immediate, we check tha value of "target - size of the jump instructoin" */ OpndSize estOpndSizeFromImm(int target) { if(target-MIN_JCC_SIZE < 128 && target-MAX_JCC_SIZE >= -128) return OpndSize_8; #ifdef SUPPORT_IMM_16 if(target-MIN_JCC_SIZE < 32768 && target-MAX_JCC_SIZE >= -32768) return OpndSize_16; #endif return OpndSize_32; } /*! \brief return size of a jump or call instruction */ unsigned getJmpCallInstSize(OpndSize size, JmpCall_type type) { if(type == JmpCall_uncond) { if(size == OpndSize_8) return 2; if(size == OpndSize_16) return 4; return 5; } if(type == JmpCall_cond) { if(size == OpndSize_8) return 2; if(size == OpndSize_16) return 5; return 6; } if(type == JmpCall_reg) { assert(size == OpndSize_32); return JUMP_REG_SIZE; } if(type == JmpCall_call) { assert(size != OpndSize_8); if(size == OpndSize_16) return 4; return 5; } return 0; } /*! \brief check whether a branch target is already handled, if yes, return the size of the immediate; otherwise, call insertShortWorklist or insertLabelWorklist. If the branch target is not handled, call insertShortWorklist or insertLabelWorklist depending on isShortTerm, unknown is set to true, immSize is set to 32 if isShortTerm is false, set to 32 if isShortTerm is true and target is check_cast_null, set to 8 otherwise. If the branch target is handled, call estOpndSizeFromImm to set immSize for jump instruction, returns the value of the immediate */ int getRelativeOffset(const char* target, bool isShortTerm, JmpCall_type type, bool* unknown, OpndSize* immSize) { char* targetPtrInStream = NULL; if(isShortTerm) targetPtrInStream = findCodeForShortLabel(target); else targetPtrInStream = findCodeForLabel(target); int relOffset; *unknown = false; if(targetPtrInStream == NULL) { //branch target is not handled yet relOffset = 0; *unknown = true; if(isShortTerm) { /* for backward jump, at this point, we don't know how far the target is from this jump since the lable is only used within a single bytecode, we assume OpndSize_8 is big enough but there are special cases where we should use 32 bit offset */ if(!strcmp(target, ".check_cast_null") || !strcmp(target, ".stackOverflow") || !strcmp(target, ".invokeChain") || !strcmp(target, ".new_instance_done") || !strcmp(target, ".new_array_done") || !strcmp(target, ".fill_array_data_done") || !strcmp(target, ".inlined_string_compare_done") || !strncmp(target, "after_exception", 15)) { #ifdef SUPPORT_IMM_16 *immSize = OpndSize_16; #else *immSize = OpndSize_32; #endif } else { *immSize = OpndSize_8; } #ifdef DEBUG_NCG_JUMP ALOGI("insert to short worklist %s %d", target, *immSize); #endif insertShortWorklist(target, *immSize); } else { #ifdef SUPPORT_IMM_16 *immSize = OpndSize_16; #else *immSize = OpndSize_32; #endif insertLabelWorklist(target, *immSize); } if(type == JmpCall_call) { //call sz16 does not work in gdb *immSize = OpndSize_32; } return 0; } else if (!isShortTerm) { #ifdef SUPPORT_IMM_16 *immSize = OpndSize_16; #else *immSize = OpndSize_32; #endif insertLabelWorklist(target, *immSize); } #ifdef DEBUG_NCG ALOGI("backward branch @ %p for label %s", stream, target); #endif relOffset = targetPtrInStream - stream; if(type == JmpCall_call) *immSize = OpndSize_32; else *immSize = estOpndSizeFromImm(relOffset); relOffset -= getJmpCallInstSize(*immSize, type); return relOffset; } /*! \brief generate a single native instruction "jcc imm" to jump to a label */ void conditional_jump(ConditionCode cc, const char* target, bool isShortTerm) { if(jumpToException(target) && currentExceptionBlockIdx >= 0) { //jump to the exceptionThrow block condJumpToBasicBlock(stream, cc, currentExceptionBlockIdx); return; } Mnemonic m = (Mnemonic)(Mnemonic_Jcc + cc); bool unknown; OpndSize size; int imm = 0; imm = getRelativeOffset(target, isShortTerm, JmpCall_cond, &unknown, &size); dump_label(m, size, imm, target, isShortTerm); } /*! \brief generate a single native instruction "jmp imm" to jump to ".invokeArgsDone" */ void goto_invokeArgsDone() { unconditional_jump_global_API(".invokeArgsDone", false); } /*! \brief generate a single native instruction "jmp imm" to jump to a label If the target is ".invokeArgsDone" and mode is NCG O1, extra work is performed to dump content of virtual registers to memory. */ void unconditional_jump(const char* target, bool isShortTerm) { if(jumpToException(target) && currentExceptionBlockIdx >= 0) { //jump to the exceptionThrow block jumpToBasicBlock(stream, currentExceptionBlockIdx); return; } Mnemonic m = Mnemonic_JMP; bool unknown; OpndSize size; if(gDvm.executionMode == kExecutionModeNcgO1) { //for other three labels used by JIT: invokeArgsDone_formal, _native, _jit if(!strncmp(target, ".invokeArgsDone", 15)) { touchEcx(); //keep ecx live, if ecx was spilled, it is loaded here beforeCall(target); // } if(!strcmp(target, ".invokeArgsDone")) { nextVersionOfHardReg(PhysicalReg_EDX, 1); //edx will be used in a function call("ncgGetEIP"); //must be immediately before JMP } } int imm = 0; imm = getRelativeOffset(target, isShortTerm, JmpCall_uncond, &unknown, &size); dump_label(m, size, imm, target, isShortTerm); if(gDvm.executionMode == kExecutionModeNcgO1) { if(!strncmp(target, ".invokeArgsDone", 15)) { afterCall(target); //un-spill before executing the next bytecode } } } /*! \brief generate a single native instruction "jcc imm" */ void conditional_jump_int(ConditionCode cc, int target, OpndSize size) { Mnemonic m = (Mnemonic)(Mnemonic_Jcc + cc); dump_ncg(m, size, target); } /*! \brief generate a single native instruction "jmp imm" */ void unconditional_jump_int(int target, OpndSize size) { Mnemonic m = Mnemonic_JMP; dump_ncg(m, size, target); } /*! \brief generate a single native instruction "jmp reg" */ void unconditional_jump_reg(int reg, bool isPhysical) { dump_reg(Mnemonic_JMP, ATOM_NORMAL, OpndSize_32, reg, isPhysical, LowOpndRegType_gp); } /*! \brief generate a single native instruction to call a function If mode is NCG O1, extra work is performed to dump content of virtual registers to memory. */ void call(const char* target) { if(gDvm.executionMode == kExecutionModeNcgO1) { beforeCall(target); } Mnemonic m = Mnemonic_CALL; bool dummy; OpndSize size; int relOffset = 0; relOffset = getRelativeOffset(target, false, JmpCall_call, &dummy, &size); dump_label(m, size, relOffset, target, false); if(gDvm.executionMode == kExecutionModeNcgO1) { afterCall(target); } } /*! \brief generate a single native instruction to call a function */ void call_reg(int reg, bool isPhysical) { Mnemonic m = Mnemonic_CALL; dump_reg(m, ATOM_NORMAL, OpndSize_32, reg, isPhysical, LowOpndRegType_gp); } void call_reg_noalloc(int reg, bool isPhysical) { Mnemonic m = Mnemonic_CALL; dump_reg_noalloc(m, OpndSize_32, reg, isPhysical, LowOpndRegType_gp); } /*! \brief generate a single native instruction to call a function */ void call_mem(int disp, int reg, bool isPhysical) { Mnemonic m = Mnemonic_CALL; dump_mem(m, ATOM_NORMAL, OpndSize_32, disp, reg, isPhysical); } /*! \brief insert an entry to globalNCGWorklist */ int insertNCGWorklist(s4 relativePC, OpndSize immSize) { int offsetNCG2 = stream - streamMethodStart; #ifdef DEBUG_NCG ALOGI("insert NCGWorklist (goto forward) @ %p offsetPC %x relativePC %x offsetNCG %x", stream, offsetPC, relativePC, offsetNCG2); #endif NCGWorklist* item = (NCGWorklist*)malloc(sizeof(NCGWorklist)); if(item == NULL) { ALOGE("Memory allocation failed"); return -1; } item->relativePC = relativePC; item->offsetPC = offsetPC; item->offsetNCG = offsetNCG2; item->codePtr = stream; item->size = immSize; item->nextItem = globalNCGWorklist; globalNCGWorklist = item; return 0; } #ifdef ENABLE_TRACING int insertMapWorklist(s4 BCOffset, s4 NCGOffset, int isStartOfPC) { return 0; } #endif /*! \brief insert an entry to methodDataWorklist This function is used by bytecode FILL_ARRAY_DATA, PACKED_SWITCH, SPARSE_SWITCH */ int insertDataWorklist(s4 relativePC, char* codePtr1) { //insert according to offsetPC+relativePC, smallest at the head DataWorklist* item = (DataWorklist*)malloc(sizeof(DataWorklist)); if(item == NULL) { ALOGE("Memory allocation failed"); return -1; } item->relativePC = relativePC; item->offsetPC = offsetPC; item->codePtr = codePtr1; item->codePtr2 = stream; //jump_reg for switch DataWorklist* ptr = methodDataWorklist; DataWorklist* prev_ptr = NULL; while(ptr != NULL) { int tmpPC = ptr->offsetPC + ptr->relativePC; int tmpPC2 = relativePC + offsetPC; if(tmpPC2 < tmpPC) { break; } prev_ptr = ptr; ptr = ptr->nextItem; } //insert item before ptr if(prev_ptr != NULL) { prev_ptr->nextItem = item; } else methodDataWorklist = item; item->nextItem = ptr; return 0; } /*! \brief work on globalNCGWorklist */ int performNCGWorklist() { NCGWorklist* ptr = globalNCGWorklist; while(ptr != NULL) { ALOGV("perform NCG worklist: @ %p target block %d target NCG %x", ptr->codePtr, ptr->relativePC, traceLabelList[ptr->relativePC].lop.generic.offset); int tmpNCG = traceLabelList[ptr->relativePC].lop.generic.offset; assert(tmpNCG >= 0); int relativeNCG = tmpNCG - ptr->offsetNCG; unsigned instSize = encoder_get_inst_size(ptr->codePtr); relativeNCG -= instSize; updateJumpInst(ptr->codePtr, ptr->size, relativeNCG); globalNCGWorklist = ptr->nextItem; free(ptr); ptr = globalNCGWorklist; } return 0; } void freeNCGWorklist() { NCGWorklist* ptr = globalNCGWorklist; while(ptr != NULL) { globalNCGWorklist = ptr->nextItem; free(ptr); ptr = globalNCGWorklist; } } /*! \brief used by bytecode SWITCH targetPC points to start of the data section Code sequence for SWITCH call ncgGetEIP @codeInst: add_reg_reg %eax, %edx jump_reg %edx This function returns the offset in native code between add_reg_reg and the data section */ int getRelativeNCGForSwitch(int targetPC, char* codeInst) { int tmpNCG = mapFromBCtoNCG[targetPC]; int offsetNCG2 = codeInst - streamMethodStart; int relativeOff = tmpNCG - offsetNCG2; return relativeOff; } /*! \brief work on methodDataWorklist */ int performDataWorklist() { DataWorklist* ptr = methodDataWorklist; if(ptr == NULL) return 0; char* codeCacheEnd = ((char *) gDvmJit.codeCache) + gDvmJit.codeCacheSize - CODE_CACHE_PADDING; u2 insnsSize = dvmGetMethodInsnsSize(currentMethod); //bytecode //align stream to multiple of 4 int alignBytes = (int)stream & 3; if(alignBytes != 0) alignBytes = 4-alignBytes; stream += alignBytes; while(ptr != NULL) { int tmpPC = ptr->offsetPC + ptr->relativePC; int endPC = insnsSize; if(ptr->nextItem != NULL) endPC = ptr->nextItem->offsetPC + ptr->nextItem->relativePC; mapFromBCtoNCG[tmpPC] = stream - streamMethodStart; //offsetNCG in byte //handle fill_array_data, packed switch & sparse switch u2 tmpInst = *(currentMethod->insns + ptr->offsetPC); u2* sizePtr; s4* entryPtr_bytecode; u2 tSize, iVer; u4 sz; if (gDvmJit.codeCacheFull == true) { // We are out of code cache space. Skip writing data/code to // code cache. Simply free the item. methodDataWorklist = ptr->nextItem; free(ptr); ptr = methodDataWorklist; } switch (INST_INST(tmpInst)) { case OP_FILL_ARRAY_DATA: sz = (endPC-tmpPC)*sizeof(u2); if ((stream + sz) < codeCacheEnd) { memcpy(stream, (u2*)currentMethod->insns+tmpPC, sz); #ifdef DEBUG_NCG_CODE_SIZE ALOGI("copy data section to stream %p: start at %d, %d bytes", stream, tmpPC, sz); #endif #ifdef DEBUG_NCG ALOGI("update data section at %p with %d", ptr->codePtr, stream-ptr->codePtr); #endif updateImmRMInst(ptr->codePtr, "", stream - ptr->codePtr); stream += sz; } else { gDvmJit.codeCacheFull = true; } break; case OP_PACKED_SWITCH: updateImmRMInst(ptr->codePtr, "", stream-ptr->codePtr); sizePtr = (u2*)currentMethod->insns+tmpPC + 1 /*signature*/; entryPtr_bytecode = (s4*)(sizePtr + 1 /*size*/ + 2 /*firstKey*/); tSize = *(sizePtr); sz = tSize * 4; /* expected size needed in stream */ if ((stream + sz) < codeCacheEnd) { for(iVer = 0; iVer < tSize; iVer++) { //update entries s4 relativePC = *entryPtr_bytecode; //relative to ptr->offsetPC //need stream, offsetPC, int relativeNCG = getRelativeNCGForSwitch(relativePC+ptr->offsetPC, ptr->codePtr2); #ifdef DEBUG_NCG_CODE_SIZE ALOGI("convert target from %d to %d", relativePC+ptr->offsetPC, relativeNCG); #endif *((s4*)stream) = relativeNCG; stream += 4; entryPtr_bytecode++; } } else { gDvmJit.codeCacheFull = true; } break; case OP_SPARSE_SWITCH: updateImmRMInst(ptr->codePtr, "", stream-ptr->codePtr); sizePtr = (u2*)currentMethod->insns+tmpPC + 1 /*signature*/; s4* keyPtr_bytecode = (s4*)(sizePtr + 1 /*size*/); tSize = *(sizePtr); entryPtr_bytecode = (s4*)(keyPtr_bytecode + tSize); sz = tSize * (sizeof(s4) + 4); /* expected size needed in stream */ if ((stream + sz) < codeCacheEnd) { memcpy(stream, keyPtr_bytecode, tSize*sizeof(s4)); stream += tSize*sizeof(s4); for(iVer = 0; iVer < tSize; iVer++) { //update entries s4 relativePC = *entryPtr_bytecode; //relative to ptr->offsetPC //need stream, offsetPC, int relativeNCG = getRelativeNCGForSwitch(relativePC+ptr->offsetPC, ptr->codePtr2); *((s4*)stream) = relativeNCG; stream += 4; entryPtr_bytecode++; } } else { gDvmJit.codeCacheFull = true; } break; } //remove the item methodDataWorklist = ptr->nextItem; free(ptr); ptr = methodDataWorklist; } return 0; } void freeDataWorklist() { DataWorklist* ptr = methodDataWorklist; while(ptr != NULL) { methodDataWorklist = ptr->nextItem; free(ptr); ptr = methodDataWorklist; } } ////////////////////////// /*! \brief check whether a branch target (specified by relative offset in bytecode) is already handled, if yes, return the size of the immediate; otherwise, call insertNCGWorklist. If the branch target is not handled, call insertNCGWorklist, unknown is set to true, immSize is set to 32. If the branch target is handled, call estOpndSizeFromImm to set immSize for jump instruction, returns the value of the immediate */ int getRelativeNCG(s4 tmp, JmpCall_type type, bool* unknown, OpndSize* size) {//tmp: relativePC int tmpNCG = traceLabelList[tmp].lop.generic.offset; *unknown = false; if(tmpNCG <0) { *unknown = true; #ifdef SUPPORT_IMM_16 *size = OpndSize_16; #else *size = OpndSize_32; #endif insertNCGWorklist(tmp, *size); return 0; } int offsetNCG2 = stream - streamMethodStart; #ifdef DEBUG_NCG ALOGI("goto backward @ %p offsetPC %d relativePC %d offsetNCG %d relativeNCG %d", stream, offsetPC, tmp, offsetNCG2, tmpNCG-offsetNCG2); #endif int relativeOff = tmpNCG - offsetNCG2; *size = estOpndSizeFromImm(relativeOff); return relativeOff - getJmpCallInstSize(*size, type); } /*! \brief a helper function to handle backward branch input: jump target in %eax; at end of the function, jump to %eax */ int common_backwardBranch() { insertLabel("common_backwardBranch", false); spill_reg(PhysicalReg_EAX, true); call("common_periodicChecks_entry"); unspill_reg(PhysicalReg_EAX, true); unconditional_jump_reg(PhysicalReg_EAX, true); return 0; } //when this is called from JIT, there is no need to check GC int common_goto(s4 tmp) { //tmp: target basic block id bool unknown; OpndSize size; constVREndOfBB(); globalVREndOfBB(currentMethod); int relativeNCG = tmp; relativeNCG = getRelativeNCG(tmp, JmpCall_uncond, &unknown, &size); unconditional_jump_int(relativeNCG, size); return 1; } int common_if(s4 tmp, ConditionCode cc_next, ConditionCode cc) { bool unknown; OpndSize size; int relativeNCG = traceCurrentBB->taken ? traceCurrentBB->taken->id : 0; if(traceCurrentBB->taken) relativeNCG = getRelativeNCG(traceCurrentBB->taken->id, JmpCall_cond, &unknown, &size); conditional_jump_int(cc, relativeNCG, size); relativeNCG = traceCurrentBB->fallThrough ? traceCurrentBB->fallThrough->id : 0; if(traceCurrentBB->fallThrough) relativeNCG = getRelativeNCG(traceCurrentBB->fallThrough->id, JmpCall_uncond, &unknown, &size); unconditional_jump_int(relativeNCG, size); return 2; } /*! \brief helper function to handle null object error */ int common_errNullObject() { insertLabel("common_errNullObject", false); move_imm_to_reg(OpndSize_32, 0, PhysicalReg_EAX, true); move_imm_to_reg(OpndSize_32, LstrNullPointerException, PhysicalReg_ECX, true); unconditional_jump("common_throw", false); return 0; } /*! \brief helper function to handle string index error */ int common_StringIndexOutOfBounds() { insertLabel("common_StringIndexOutOfBounds", false); move_imm_to_reg(OpndSize_32, 0, PhysicalReg_EAX, true); move_imm_to_reg(OpndSize_32, LstrStringIndexOutOfBoundsException, PhysicalReg_ECX, true); unconditional_jump("common_throw", false); return 0; } /*! \brief helper function to handle array index error */ int common_errArrayIndex() { insertLabel("common_errArrayIndex", false); move_imm_to_reg(OpndSize_32, 0, PhysicalReg_EAX, true); move_imm_to_reg(OpndSize_32, LstrArrayIndexException, PhysicalReg_ECX, true); unconditional_jump("common_throw", false); return 0; } /*! \brief helper function to handle array store error */ int common_errArrayStore() { insertLabel("common_errArrayStore", false); move_imm_to_reg(OpndSize_32, 0, PhysicalReg_EAX, true); move_imm_to_reg(OpndSize_32, LstrArrayStoreException, PhysicalReg_ECX, true); unconditional_jump("common_throw", false); return 0; } /*! \brief helper function to handle negative array size error */ int common_errNegArraySize() { insertLabel("common_errNegArraySize", false); move_imm_to_reg(OpndSize_32, 0, PhysicalReg_EAX, true); move_imm_to_reg(OpndSize_32, LstrNegativeArraySizeException, PhysicalReg_ECX, true); unconditional_jump("common_throw", false); return 0; } /*! \brief helper function to handle divide-by-zero error */ int common_errDivideByZero() { insertLabel("common_errDivideByZero", false); move_imm_to_reg(OpndSize_32, LstrDivideByZero, PhysicalReg_EAX, true); move_imm_to_reg(OpndSize_32, LstrArithmeticException, PhysicalReg_ECX, true); unconditional_jump("common_throw", false); return 0; } /*! \brief helper function to handle no such method error */ int common_errNoSuchMethod() { insertLabel("common_errNoSuchMethod", false); move_imm_to_reg(OpndSize_32, 0, PhysicalReg_EAX, true); move_imm_to_reg(OpndSize_32, LstrNoSuchMethodError, PhysicalReg_ECX, true); unconditional_jump("common_throw", false); return 0; } int call_dvmFindCatchBlock(); #define P_GPR_1 PhysicalReg_ESI //self callee-saved #define P_GPR_2 PhysicalReg_EBX //exception callee-saved #define P_GPR_3 PhysicalReg_EAX //method that caused exception /*! \brief helper function common_exceptionThrown */ int common_exceptionThrown() { insertLabel("common_exceptionThrown", false); typedef void (*vmHelper)(int); vmHelper funcPtr = dvmJitToExceptionThrown; move_imm_to_reg(OpndSize_32, (int)funcPtr, C_SCRATCH_1, isScratchPhysical); unconditional_jump_reg(C_SCRATCH_1, isScratchPhysical); return 0; } #undef P_GPR_1 #undef P_GPR_2 #undef P_GPR_3 /*! \brief helper function to throw an exception with message INPUT: obj_reg(%eax), exceptionPtrReg(%ecx) SCRATCH: C_SCRATCH_1(%esi) & C_SCRATCH_2(%edx) OUTPUT: no */ int throw_exception_message(int exceptionPtrReg, int obj_reg, bool isPhysical, int startLR/*logical register index*/, bool startPhysical) { insertLabel("common_throw_message", false); scratchRegs[0] = PhysicalReg_ESI; scratchRegs[1] = PhysicalReg_EDX; scratchRegs[2] = PhysicalReg_Null; scratchRegs[3] = PhysicalReg_Null; move_mem_to_reg(OpndSize_32, offObject_clazz, obj_reg, isPhysical, C_SCRATCH_1, isScratchPhysical); move_mem_to_reg(OpndSize_32, offClassObject_descriptor, C_SCRATCH_1, isScratchPhysical, C_SCRATCH_2, isScratchPhysical); load_effective_addr(-8, PhysicalReg_ESP, true, PhysicalReg_ESP, true); move_reg_to_mem(OpndSize_32, C_SCRATCH_2, isScratchPhysical, 4, PhysicalReg_ESP, true); move_reg_to_mem(OpndSize_32, exceptionPtrReg, true, 0, PhysicalReg_ESP, true); call_dvmThrowWithMessage(); load_effective_addr(8, PhysicalReg_ESP, true, PhysicalReg_ESP, true); unconditional_jump("common_exceptionThrown", false); return 0; } /*! \brief helper function to throw an exception scratch: C_SCRATCH_1(%edx) */ int throw_exception(int exceptionPtrReg, int immReg, int startLR/*logical register index*/, bool startPhysical) { insertLabel("common_throw", false); scratchRegs[0] = PhysicalReg_EDX; scratchRegs[1] = PhysicalReg_Null; scratchRegs[2] = PhysicalReg_Null; scratchRegs[3] = PhysicalReg_Null; load_effective_addr(-8, PhysicalReg_ESP, true, PhysicalReg_ESP, true); move_reg_to_mem(OpndSize_32, immReg, true, 4, PhysicalReg_ESP, true); move_reg_to_mem(OpndSize_32, exceptionPtrReg, true, 0, PhysicalReg_ESP, true); call_dvmThrow(); load_effective_addr(8, PhysicalReg_ESP, true, PhysicalReg_ESP, true); unconditional_jump("common_exceptionThrown", false); return 0; } //! lower bytecode GOTO //! int op_goto() { s2 tmp = traceCurrentBB->taken->id; int retval = common_goto(tmp); rPC += 1; return retval; } //! lower bytecode GOTO_16 //! int op_goto_16() { s2 tmp = traceCurrentBB->taken->id; int retval = common_goto(tmp); rPC += 2; return retval; } //! lower bytecode GOTO_32 //! int op_goto_32() { s2 tmp = traceCurrentBB->taken->id; int retval = common_goto((s4)tmp); rPC += 3; return retval; } #define P_GPR_1 PhysicalReg_EBX //! lower bytecode PACKED_SWITCH //! int op_packed_switch() { u4 tmp = (u4)FETCH(1); tmp |= (u4)FETCH(2) << 16; u2 vA = INST_AA(inst); #ifdef DEBUG_EACH_BYTECODE u2 tSize = 0; s4 firstKey = 0; s4* entries = NULL; #else u2* switchData = rPC + (s4)tmp; if (*switchData++ != kPackedSwitchSignature) { /* should have been caught by verifier */ dvmThrowInternalError( "bad packed switch magic"); return 0; //no_op } u2 tSize = *switchData++; assert(tSize > 0); s4 firstKey = *switchData++; firstKey |= (*switchData++) << 16; s4* entries = (s4*) switchData; assert(((u4)entries & 0x3) == 0); #endif get_virtual_reg(vA, OpndSize_32, 1, false); //dvmNcgHandlePackedSwitch: testVal, size, first_key, targets load_effective_addr(-16, PhysicalReg_ESP, true, PhysicalReg_ESP, true); move_imm_to_mem(OpndSize_32, tSize, 8, PhysicalReg_ESP, true); move_imm_to_mem(OpndSize_32, firstKey, 4, PhysicalReg_ESP, true); /* "entries" is constant for JIT it is the 1st argument to dvmJitHandlePackedSwitch */ move_imm_to_mem(OpndSize_32, (int)entries, 0, PhysicalReg_ESP, true); move_reg_to_mem(OpndSize_32, 1, false, 12, PhysicalReg_ESP, true); //if value out of range, fall through (no_op) //return targets[testVal - first_key] scratchRegs[0] = PhysicalReg_SCRATCH_1; call_dvmJitHandlePackedSwitch(); load_effective_addr(16, PhysicalReg_ESP, true, PhysicalReg_ESP, true); //TODO: eax should be absolute address, call globalVREndOfBB, constVREndOfBB //conditional_jump_global_API(Condition_LE, "common_backwardBranch", false); constVREndOfBB(); globalVREndOfBB(currentMethod); //update GG VRs //get rPC, %eax has the relative PC offset alu_binary_imm_reg(OpndSize_32, add_opc, (int)rPC, PhysicalReg_EAX, true); scratchRegs[0] = PhysicalReg_SCRATCH_2; jumpToInterpNoChain(); rPC += 3; return 0; } #undef P_GPR_1 #define P_GPR_1 PhysicalReg_EBX //! lower bytecode SPARSE_SWITCH //! int op_sparse_switch() { u4 tmp = (u4)FETCH(1); tmp |= (u4)FETCH(2) << 16; u2 vA = INST_AA(inst); #ifdef DEBUG_EACH_BYTECODE u2 tSize = 0; const s4* keys = NULL; s4* entries = NULL; #else u2* switchData = rPC + (s4)tmp; if (*switchData++ != kSparseSwitchSignature) { /* should have been caught by verifier */ dvmThrowInternalError( "bad sparse switch magic"); return 0; //no_op } u2 tSize = *switchData++; assert(tSize > 0); const s4* keys = (const s4*) switchData; assert(((u4)keys & 0x3) == 0); s4* entries = (s4*)switchData + tSize; assert(((u4)entries & 0x3) == 0); #endif get_virtual_reg(vA, OpndSize_32, 1, false); //dvmNcgHandleSparseSwitch: keys, size, testVal load_effective_addr(-12, PhysicalReg_ESP, true, PhysicalReg_ESP, true); move_imm_to_mem(OpndSize_32, tSize, 4, PhysicalReg_ESP, true); /* "keys" is constant for JIT it is the 1st argument to dvmJitHandleSparseSwitch */ move_imm_to_mem(OpndSize_32, (int)keys, 0, PhysicalReg_ESP, true); move_reg_to_mem(OpndSize_32, 1, false, 8, PhysicalReg_ESP, true); scratchRegs[0] = PhysicalReg_SCRATCH_1; //if testVal is in keys, return the corresponding target //otherwise, fall through (no_op) call_dvmJitHandleSparseSwitch(); load_effective_addr(12, PhysicalReg_ESP, true, PhysicalReg_ESP, true); //TODO: eax should be absolute address, call globalVREndOfBB constVREndOfBB //conditional_jump_global_API(Condition_LE, "common_backwardBranch", false); constVREndOfBB(); globalVREndOfBB(currentMethod); //get rPC, %eax has the relative PC offset alu_binary_imm_reg(OpndSize_32, add_opc, (int)rPC, PhysicalReg_EAX, true); scratchRegs[0] = PhysicalReg_SCRATCH_2; jumpToInterpNoChain(); rPC += 3; return 0; } #undef P_GPR_1 #define P_GPR_1 PhysicalReg_EBX //! lower bytecode IF_EQ //! int op_if_eq() { u2 vA = INST_A(inst); u2 vB = INST_B(inst); s2 tmp = (s2)FETCH(1); get_virtual_reg(vA, OpndSize_32, 1, false); compare_VR_reg(OpndSize_32, vB, 1, false); constVREndOfBB(); globalVREndOfBB(currentMethod); common_if(tmp, Condition_NE, Condition_E); rPC += 2; return 0; } //! lower bytecode IF_NE //! int op_if_ne() { u2 vA = INST_A(inst); u2 vB = INST_B(inst); s2 tmp = (s2)FETCH(1); get_virtual_reg(vA, OpndSize_32, 1, false); compare_VR_reg(OpndSize_32, vB, 1, false); constVREndOfBB(); globalVREndOfBB(currentMethod); common_if(tmp, Condition_E, Condition_NE); rPC += 2; return 0; } //! lower bytecode IF_LT //! int op_if_lt() { u2 vA = INST_A(inst); u2 vB = INST_B(inst); s2 tmp = (s2)FETCH(1); get_virtual_reg(vA, OpndSize_32, 1, false); compare_VR_reg(OpndSize_32, vB, 1, false); constVREndOfBB(); globalVREndOfBB(currentMethod); common_if(tmp, Condition_GE, Condition_L); rPC += 2; return 0; } //! lower bytecode IF_GE //! int op_if_ge() { u2 vA = INST_A(inst); u2 vB = INST_B(inst); s2 tmp = (s2)FETCH(1); get_virtual_reg(vA, OpndSize_32, 1, false); compare_VR_reg(OpndSize_32, vB, 1, false); constVREndOfBB(); globalVREndOfBB(currentMethod); common_if(tmp, Condition_L, Condition_GE); rPC += 2; return 0; } //! lower bytecode IF_GT //! int op_if_gt() { u2 vA = INST_A(inst); u2 vB = INST_B(inst); s2 tmp = (s2)FETCH(1); get_virtual_reg(vA, OpndSize_32, 1, false); compare_VR_reg(OpndSize_32, vB, 1, false); constVREndOfBB(); globalVREndOfBB(currentMethod); common_if(tmp, Condition_LE, Condition_G); rPC += 2; return 0; } //! lower bytecode IF_LE //! int op_if_le() { u2 vA = INST_A(inst); u2 vB = INST_B(inst); s2 tmp = (s2)FETCH(1); get_virtual_reg(vA, OpndSize_32, 1, false); compare_VR_reg(OpndSize_32, vB, 1, false); constVREndOfBB(); globalVREndOfBB(currentMethod); common_if(tmp, Condition_G, Condition_LE); rPC += 2; return 0; } #undef P_GPR_1 //! lower bytecode IF_EQZ //! int op_if_eqz() { u2 vA = INST_AA(inst); s2 tmp = (s2)FETCH(1); compare_imm_VR(OpndSize_32, 0, vA); constVREndOfBB(); globalVREndOfBB(currentMethod); common_if(tmp, Condition_NE, Condition_E); rPC += 2; return 0; } //! lower bytecode IF_NEZ //! int op_if_nez() { u2 vA = INST_AA(inst); s2 tmp = (s2)FETCH(1); compare_imm_VR(OpndSize_32, 0, vA); constVREndOfBB(); globalVREndOfBB(currentMethod); common_if(tmp, Condition_E, Condition_NE); rPC += 2; return 0; } //! lower bytecode IF_LTZ //! int op_if_ltz() { u2 vA = INST_AA(inst); s2 tmp = (s2)FETCH(1); compare_imm_VR(OpndSize_32, 0, vA); constVREndOfBB(); globalVREndOfBB(currentMethod); common_if(tmp, Condition_GE, Condition_L); rPC += 2; return 0; } //! lower bytecode IF_GEZ //! int op_if_gez() { u2 vA = INST_AA(inst); s2 tmp = (s2)FETCH(1); compare_imm_VR(OpndSize_32, 0, vA); constVREndOfBB(); globalVREndOfBB(currentMethod); common_if(tmp, Condition_L, Condition_GE); rPC += 2; return 0; } //! lower bytecode IF_GTZ //! int op_if_gtz() { u2 vA = INST_AA(inst); s2 tmp = (s2)FETCH(1); compare_imm_VR(OpndSize_32, 0, vA); constVREndOfBB(); globalVREndOfBB(currentMethod); common_if(tmp, Condition_LE, Condition_G); rPC += 2; return 0; } //! lower bytecode IF_LEZ //! int op_if_lez() { u2 vA = INST_AA(inst); s2 tmp = (s2)FETCH(1); compare_imm_VR(OpndSize_32, 0, vA); constVREndOfBB(); globalVREndOfBB(currentMethod); common_if(tmp, Condition_G, Condition_LE); rPC += 2; return 0; } #define P_GPR_1 PhysicalReg_ECX #define P_GPR_2 PhysicalReg_EBX /*! \brief helper function common_periodicChecks4 to check GC request BCOffset in %edx */ int common_periodicChecks4() { insertLabel("common_periodicChecks4", false); #if (!defined(ENABLE_TRACING)) get_self_pointer(PhysicalReg_ECX, true); move_mem_to_reg(OpndSize_32, offsetof(Thread, suspendCount), PhysicalReg_ECX, true, PhysicalReg_EAX, true); compare_imm_reg(OpndSize_32, 0, PhysicalReg_EAX, true); //suspendCount conditional_jump(Condition_NE, "common_handleSuspend4", true); //called once x86_return(); insertLabel("common_handleSuspend4", true); push_reg_to_stack(OpndSize_32, PhysicalReg_ECX, true); call_dvmCheckSuspendPending(); load_effective_addr(4, PhysicalReg_ESP, true, PhysicalReg_ESP, true); x86_return(); #else /////////////////// //get debuggerActive: 3 memory accesses, and $7 move_mem_to_reg(OpndSize_32, offGlue_pSelfSuspendCount, PhysicalReg_Glue, true, P_GPR_1, true); move_mem_to_reg(OpndSize_32, offGlue_pIntoDebugger, PhysicalReg_Glue, true, P_GPR_2, true); compare_imm_mem(OpndSize_32, 0, 0, P_GPR_1, true); //suspendCount conditional_jump(Condition_NE, "common_handleSuspend4_1", true); //called once compare_imm_mem(OpndSize_32, 0, 0, P_GPR_2, true); //debugger active conditional_jump(Condition_NE, "common_debuggerActive4", true); //recover registers and return x86_return(); insertLabel("common_handleSuspend4_1", true); push_mem_to_stack(OpndSize_32, offGlue_self, PhysicalReg_Glue, true); call_dvmCheckSuspendPending(); load_effective_addr(4, PhysicalReg_ESP, true, PhysicalReg_ESP, true); x86_return(); insertLabel("common_debuggerActive4", true); //%edx: offsetBC (at run time, get method->insns_bytecode, then calculate BCPointer) move_mem_to_reg(OpndSize_32, offGlue_method, PhysicalReg_Glue, true, P_GPR_1, true); move_mem_to_reg(OpndSize_32, offMethod_insns_bytecode, P_GPR_1, true, P_GPR_2, true); alu_binary_reg_reg(OpndSize_32, add_opc, P_GPR_2, true, PhysicalReg_EDX, true); move_imm_to_mem(OpndSize_32, 0, offGlue_entryPoint, PhysicalReg_Glue, true); unconditional_jump("common_gotoBail", false); //update glue->rPC with edx #endif return 0; } //input: %edx PC adjustment //CHECK: should %edx be saved before calling dvmCheckSuspendPending? /*! \brief helper function common_periodicChecks_entry to check GC request */ int common_periodicChecks_entry() { insertLabel("common_periodicChecks_entry", false); scratchRegs[0] = PhysicalReg_ESI; scratchRegs[1] = PhysicalReg_EAX; scratchRegs[2] = PhysicalReg_Null; scratchRegs[3] = PhysicalReg_Null; get_suspendCount(P_GPR_1, true); //get debuggerActive: 3 memory accesses, and $7 #if 0 //defined(WITH_DEBUGGER) get_debuggerActive(P_GPR_2, true); #endif compare_imm_reg(OpndSize_32, 0, P_GPR_1, true); //suspendCount conditional_jump(Condition_NE, "common_handleSuspend", true); //called once #if 0 //defined(WITH_DEBUGGER) #ifdef NCG_DEBUG compare_imm_reg(OpndSize_32, 0, P_GPR_2, true); //debugger active conditional_jump(Condition_NE, "common_debuggerActive", true); #endif #endif //recover registers and return x86_return(); insertLabel("common_handleSuspend", true); get_self_pointer(P_GPR_1, true); load_effective_addr(-4, PhysicalReg_ESP, true, PhysicalReg_ESP, true); move_reg_to_mem(OpndSize_32, P_GPR_1, true, 0, PhysicalReg_ESP, true); call_dvmCheckSuspendPending(); load_effective_addr(4, PhysicalReg_ESP, true, PhysicalReg_ESP, true); x86_return(); #ifdef NCG_DEBUG insertLabel("common_debuggerActive", true); //adjust PC!!! use 0(%esp) TODO set_glue_entryPoint_imm(0); //kInterpEntryInstr); unconditional_jump("common_gotoBail", false); #endif return 0; } #undef P_GPR_1 #undef P_GPR_2 /*! \brief helper function common_gotoBail input: %edx: BCPointer %esi: Glue set %eax to 1 (switch interpreter = true), recover the callee-saved registers and return */ int common_gotoBail() { insertLabel("common_gotoBail", false); //scratchRegs[0] = PhysicalReg_EDX; scratchRegs[1] = PhysicalReg_ESI; //scratchRegs[2] = PhysicalReg_Null; scratchRegs[3] = PhysicalReg_Null; //save_pc_fp_to_glue(); get_self_pointer(PhysicalReg_EAX, true); move_reg_to_mem(OpndSize_32, PhysicalReg_FP, true, offsetof(Thread, interpSave.curFrame), PhysicalReg_EAX, true); move_reg_to_mem(OpndSize_32, PhysicalReg_EDX, true, offsetof(Thread, interpSave.pc), PhysicalReg_EAX, true); move_mem_to_reg(OpndSize_32, offsetof(Thread, interpSave.bailPtr), PhysicalReg_EAX, true, PhysicalReg_ESP, true); move_reg_to_reg(OpndSize_32, PhysicalReg_ESP, true, PhysicalReg_EBP, true); load_effective_addr(FRAME_SIZE-4, PhysicalReg_EBP, true, PhysicalReg_EBP, true); move_imm_to_reg(OpndSize_32, 1, PhysicalReg_EAX, true); //return value move_mem_to_reg(OpndSize_32, -4, PhysicalReg_EBP, true, PhysicalReg_EDI, true); move_mem_to_reg(OpndSize_32, -8, PhysicalReg_EBP, true, PhysicalReg_ESI, true); move_mem_to_reg(OpndSize_32, -12, PhysicalReg_EBP, true, PhysicalReg_EBX, true); move_reg_to_reg(OpndSize_32, PhysicalReg_EBP, true, PhysicalReg_ESP, true); move_mem_to_reg(OpndSize_32, 0, PhysicalReg_ESP, true, PhysicalReg_EBP, true); load_effective_addr(4, PhysicalReg_ESP, true, PhysicalReg_ESP, true); x86_return(); return 0; } /*! \brief helper function common_gotoBail_0 set %eax to 0, recover the callee-saved registers and return */ int common_gotoBail_0() { insertLabel("common_gotoBail_0", false); get_self_pointer(PhysicalReg_EAX, true); move_reg_to_mem(OpndSize_32, PhysicalReg_FP, true, offsetof(Thread, interpSave.curFrame), PhysicalReg_EAX, true); move_reg_to_mem(OpndSize_32, PhysicalReg_EDX, true, offsetof(Thread, interpSave.pc), PhysicalReg_EAX, true); /* movl offThread_bailPtr(%ecx),%esp # Restore "setjmp" esp movl %esp,%ebp addl $(FRAME_SIZE-4), %ebp # Restore %ebp at point of setjmp movl EDI_SPILL(%ebp),%edi movl ESI_SPILL(%ebp),%esi movl EBX_SPILL(%ebp),%ebx movl %ebp, %esp # strip frame pop %ebp # restore caller's ebp ret # return to dvmMterpStdRun's caller */ move_mem_to_reg(OpndSize_32, offsetof(Thread, interpSave.bailPtr), PhysicalReg_EAX, true, PhysicalReg_ESP, true); move_reg_to_reg(OpndSize_32, PhysicalReg_ESP, true, PhysicalReg_EBP, true); load_effective_addr(FRAME_SIZE-4, PhysicalReg_EBP, true, PhysicalReg_EBP, true); move_imm_to_reg(OpndSize_32, 0, PhysicalReg_EAX, true); //return value move_mem_to_reg(OpndSize_32, -4, PhysicalReg_EBP, true, PhysicalReg_EDI, true); move_mem_to_reg(OpndSize_32, -8, PhysicalReg_EBP, true, PhysicalReg_ESI, true); move_mem_to_reg(OpndSize_32, -12, PhysicalReg_EBP, true, PhysicalReg_EBX, true); move_reg_to_reg(OpndSize_32, PhysicalReg_EBP, true, PhysicalReg_ESP, true); move_mem_to_reg(OpndSize_32, 0, PhysicalReg_ESP, true, PhysicalReg_EBP, true); load_effective_addr(4, PhysicalReg_ESP, true, PhysicalReg_ESP, true); x86_return(); return 0; }