| //===---- JavaJITOpcodes.cpp - Reads and compiles opcodes -----------------===// |
| // |
| // The VMKit project |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #define JNJVM_COMPILE 2 |
| #define JNJVM_EXECUTE 1 |
| |
| |
| #include <cstring> |
| #include <queue> |
| |
| #include <llvm/IR/Constants.h> |
| #include <llvm/IR/DerivedTypes.h> |
| #include <llvm/IR/Function.h> |
| #include <llvm/IR/Instructions.h> |
| #include <llvm/IR/Module.h> |
| #include <llvm/IR/Type.h> |
| |
| #include "vmkit/JIT.h" |
| |
| #include "debug.h" |
| |
| #include "JavaArray.h" |
| #include "JavaClass.h" |
| #include "JavaConstantPool.h" |
| #include "JavaObject.h" |
| #include "JavaJIT.h" |
| #include "JavaThread.h" |
| #include "JavaTypes.h" |
| #include "Jnjvm.h" |
| #include "Reader.h" |
| |
| #include "j3/J3Intrinsics.h" |
| |
| #include "j3/OpcodeNames.def" |
| |
| using namespace j3; |
| using namespace llvm; |
| |
| uint8 arrayType(JavaMethod* meth, unsigned int t) { |
| if (t == JavaArray::T_CHAR) { |
| return I_CHAR; |
| } else if (t == JavaArray::T_BOOLEAN) { |
| return I_BOOL; |
| } else if (t == JavaArray::T_INT) { |
| return I_INT; |
| } else if (t == JavaArray::T_SHORT) { |
| return I_SHORT; |
| } else if (t == JavaArray::T_BYTE) { |
| return I_BYTE; |
| } else if (t == JavaArray::T_FLOAT) { |
| return I_FLOAT; |
| } else if (t == JavaArray::T_LONG) { |
| return I_LONG; |
| } else if (t == JavaArray::T_DOUBLE) { |
| return I_DOUBLE; |
| } else { |
| fprintf(stderr, "I haven't verified your class file and it's malformed:" |
| " unknown array type %d in %s.%s!\n", t, |
| UTF8Buffer(meth->classDef->name).cString(), |
| UTF8Buffer(meth->name).cString()); |
| abort(); |
| } |
| } |
| |
| static inline uint32 WREAD_U1(Reader& reader, bool init, uint32 &i, bool& wide) { |
| if (wide) { |
| wide = init; |
| i += 2; |
| return reader.readU2(); |
| } else { |
| i += 1; |
| return reader.readU1(); |
| } |
| } |
| |
| static inline sint32 WREAD_S1(Reader& reader, bool init, uint32 &i, bool &wide) { |
| if (wide) { |
| wide = init; |
| i += 2; |
| return reader.readS2(); |
| } else { |
| i += 1; |
| return reader.readS1(); |
| } |
| } |
| |
| static inline uint32 WCALC(uint32 n, bool& wide) { |
| if (wide) { |
| wide = false; |
| return n << 1; |
| } else { |
| return n; |
| } |
| } |
| |
| /** |
| * Used in JavaJIT::findUnreachableCode to find the next instruction in the array of bytecode. |
| */ |
| static uint8 sum [] = { |
| 2, |
| 3, |
| 2, |
| 3, |
| 3, |
| 2, |
| 2, |
| 2, |
| 2, |
| 2 |
| }; |
| static uint8 sum2 [] = { |
| 3, |
| 3, |
| 3, |
| 3, |
| 3, |
| 3, |
| 3, |
| 5, |
| 5, |
| 3, |
| 2, |
| 3, |
| 1, |
| 1, |
| 3, |
| 3, |
| 1, |
| 1 |
| }; |
| |
| void JavaJIT::findUnreachableCode(Reader& reader, uint32 codeLen) { |
| std::queue<uint32> queue; |
| queue.push(0); |
| opcodeInfos[0].isReachable = true; |
| |
| for (unsigned i = 0; i < codeLen; ++i) { |
| if (opcodeInfos[i].isReachable) |
| queue.push(i); |
| } |
| |
| uint32 start = reader.cursor; |
| while (queue.size()) { |
| // pick one index from the queue |
| uint32 i_opcode = queue.front(); |
| queue.pop(); |
| // read the opcode at this position |
| reader.cursor = start + i_opcode; |
| uint8 bytecode = reader.readU1(); |
| // if the opcode is a section which has a handle other than the endBlockHandler then we must add the initial instruction of that handler to the queue |
| if (opcodeInfos[i_opcode].handlerPC) { |
| uint16 pc = opcodeInfos[i_opcode].handlerPC; |
| if (pc < codeLen && !opcodeInfos[pc].isReachable) { |
| opcodeInfos[pc].isReachable = true; |
| queue.push(pc); |
| } |
| } |
| // |
| // if the opcode does not involve a branch then mark the next instruction as reachable (DONE) |
| // if the opcode is an unconditional branch then mark the target as reachable (DONE) |
| // if the opcode is a conditional branch then mark the target and the next instruction as reachable (DONE) |
| // if it is a ret instruction then I don't know what to do. |
| // if it is a jsr instruction then mark the target as reachable (DONE) |
| // if it is tableswitch instruction then mark all cases as reachable (DONE) |
| // if it is lookupswitch instruction then mark all cases as reachable (DONE) |
| // wide instruction (DONE) |
| if (bytecode < IFEQ) { |
| uint32 next_index = 1; |
| if (bytecode >= BIPUSH && bytecode <= ALOAD) |
| next_index = sum[bytecode - BIPUSH]; |
| else if (bytecode >= ISTORE && bytecode <= ASTORE) |
| next_index = 2; |
| else if (bytecode == IINC) |
| next_index = 3; |
| next_index += i_opcode; |
| if (next_index < codeLen && !opcodeInfos[next_index].isReachable) { |
| opcodeInfos[next_index].isReachable = true; |
| queue.push(next_index); |
| } |
| } |
| else if (bytecode >= IFEQ && bytecode <= IF_ACMPNE) { |
| uint32 next_index = 3 + i_opcode; |
| if (next_index < codeLen && !opcodeInfos[next_index].isReachable) { |
| opcodeInfos[next_index].isReachable = true; |
| queue.push(next_index); |
| } |
| uint16 b1 = reader.readU1(); |
| uint8 b2 = reader.readU1(); |
| sint16 step = (b1 << 8) | b2; |
| next_index = i_opcode + step; |
| if (next_index < codeLen && !opcodeInfos[next_index].isReachable) { |
| opcodeInfos[next_index].isReachable = true; |
| queue.push(next_index); |
| } |
| } |
| else if (bytecode >= GETSTATIC && bytecode <= MONITOREXIT && bytecode != ATHROW) { |
| uint32 next_index = sum2[bytecode - GETSTATIC] + i_opcode; |
| if (next_index < codeLen && !opcodeInfos[next_index].isReachable) { |
| opcodeInfos[next_index].isReachable = true; |
| queue.push(next_index); |
| } |
| } |
| else { |
| uint32 x; |
| sint32 defaultIndex,lowIndex, highIndex; |
| uint32 next_index = codeLen; |
| sint16 step; |
| sint32 step32; |
| uint16 b1; |
| uint8 b2,b3,b4; |
| switch (bytecode) { |
| case GOTO: |
| step = reader.readS2(); |
| next_index = i_opcode + step; |
| break; |
| case GOTO_W: |
| step32 = reader.readS4(); |
| next_index = step32 + i_opcode; |
| break; |
| case MULTIANEWARRAY: |
| next_index = i_opcode + 4; |
| break; |
| case IFNULL: |
| case IFNONNULL: |
| case JSR: |
| next_index = i_opcode + 3; |
| if (next_index < codeLen && !opcodeInfos[next_index].isReachable) { |
| opcodeInfos[next_index].isReachable = true; |
| queue.push(next_index); |
| } |
| step = reader.readS2(); |
| next_index = i_opcode + step; |
| break; |
| case JSR_W: |
| next_index = i_opcode + 5; |
| if (next_index < codeLen && !opcodeInfos[next_index].isReachable) { |
| opcodeInfos[next_index].isReachable = true; |
| queue.push(next_index); |
| } |
| step32 = reader.readS4(); |
| next_index = step32 + i_opcode; |
| break; |
| case WIDE: |
| if (i_opcode + 1 < codeLen && !opcodeInfos[i_opcode + 1].isReachable) { |
| opcodeInfos[i_opcode + 1].isReachable = true; |
| queue.push(i_opcode + 1); |
| } |
| b2 = reader.readU1(); |
| next_index = i_opcode + ((b2 == IINC)?6:4); |
| break; |
| case TABLESWITCH: |
| //break; |
| x = i_opcode & 0x03; // remainder of division by 4 |
| reader.cursor = start + 4 - x + i_opcode; |
| // default |
| step32 = reader.readS4(); |
| defaultIndex = step32 + i_opcode; |
| if (defaultIndex < codeLen && !opcodeInfos[defaultIndex].isReachable) { |
| opcodeInfos[defaultIndex].isReachable = true; |
| queue.push(defaultIndex); |
| } |
| // low |
| lowIndex = reader.readS4(); |
| // high |
| highIndex = reader.readS4(); |
| // all options |
| for (int i = 0 ; i < highIndex - lowIndex + 1 ; i++) { |
| step32 = reader.readS4(); |
| next_index = step32 + i_opcode; |
| if (next_index < codeLen && !opcodeInfos[next_index].isReachable) { |
| opcodeInfos[next_index].isReachable = true; |
| queue.push(next_index); |
| } |
| } |
| next_index = codeLen; |
| break; |
| case LOOKUPSWITCH: |
| //break; |
| x = i_opcode & 0x03; // remainder of division by 4 |
| reader.cursor = start + 4 - x + i_opcode; |
| // default |
| step32 = reader.readS4();//(defaultIndex << 24) | (b2 << 16) | (b3 << 8) | b4; |
| defaultIndex = step32 + i_opcode; |
| if (defaultIndex < codeLen && !opcodeInfos[defaultIndex].isReachable) { |
| opcodeInfos[defaultIndex].isReachable = true; |
| queue.push(defaultIndex); |
| } |
| // npairs |
| lowIndex = reader.readS4(); |
| // all options |
| for (int i = 0 ; i < lowIndex ; i++) { |
| reader.cursor += 4; // skipping match |
| // offset |
| step32 = reader.readS4(); |
| next_index = step32 + i_opcode; |
| if (next_index < codeLen && !opcodeInfos[next_index].isReachable) { |
| opcodeInfos[next_index].isReachable = true; |
| queue.push(next_index); |
| } |
| } |
| next_index = codeLen; |
| break; |
| default: |
| break; |
| } |
| if (next_index < codeLen && !opcodeInfos[next_index].isReachable) { |
| opcodeInfos[next_index].isReachable = true; |
| queue.push(next_index); |
| } |
| } |
| } // end while |
| } |
| |
| void JavaJIT::compileOpcodes(Reader& reader, uint32 codeLength) { |
| bool wide = false; |
| uint32 jsrIndex = 0; |
| uint32 start = reader.cursor; |
| // Some compilers like Scala and Kotlin produce unreachable code. |
| if (!opcodeInfos[0].isReachable) { |
| findUnreachableCode(reader, codeLength); |
| reader.cursor = start; |
| } |
| |
| vmkit::ThreadAllocator allocator; |
| for(uint32 i = 0; i < codeLength; ++i) { |
| if (!opcodeInfos[i].isReachable && !opcodeInfos[i].handler) { |
| continue; |
| } |
| reader.cursor = start + i; |
| uint8 bytecode = reader.readU1(); |
| |
| PRINT_DEBUG(JNJVM_COMPILE, 1, DARK_BLUE, "\t[at %5d] %-5d ", i, |
| bytecode); |
| PRINT_DEBUG(JNJVM_COMPILE, 1, LIGHT_BLUE, " compiling "); |
| PRINT_DEBUG(JNJVM_COMPILE, 1, LIGHT_CYAN, OpcodeNames[bytecode]); |
| PRINT_DEBUG(JNJVM_COMPILE, 1, LIGHT_BLUE, "\n"); |
| |
| Opinfo* opinfo = &(opcodeInfos[i]); |
| if (opinfo->newBlock) { |
| if (currentBlock->getTerminator() == 0) { |
| // Load the exception object if we have branched to a handler. |
| bool b = false; |
| if (opinfo->handler) { |
| Instruction* I = opinfo->newBlock->begin(); |
| PHINode * node = dyn_cast<PHINode>(I); |
| if (!node) { |
| //llvmFunction->dump(); |
| //Value* obj = pop(); |
| //PHINode* node = PHINode::Create(obj->getType(), 0, "jaja", opinfo->newBlock); |
| //node->addIncoming(obj, currentBlock); |
| // if we were in a handler and now we are in a new handler we simulate a throw |
| llvm::Value* arg = pop(); |
| throwException(arg); |
| b = true; |
| // Original Code |
| //assert(node && "Handler marlformed"); |
| } |
| else { |
| |
| Value* obj = pop(); |
| node->addIncoming(obj, currentBlock); |
| } |
| } |
| if (!b) |
| branch(*opinfo, currentBlock); |
| } |
| |
| currentBlock = opinfo->newBlock; |
| |
| stack.clear(); |
| if (opinfo->handler) { |
| // If it's a handler, put the exception object in the stack. |
| Value* javaExceptionPtr = getJavaExceptionPtr(getJavaThreadPtr(getMutatorThreadPtr())); |
| Value* obj = new LoadInst(javaExceptionPtr, "pendingException", currentBlock); |
| new StoreInst(obj, objectStack[0], "", currentBlock); |
| // And clear the exception. |
| new StoreInst(intrinsics->JavaObjectNullConstant, javaExceptionPtr, currentBlock); |
| stack.push_back(MetaInfo(upcalls->OfObject, NOP)); |
| currentStackIndex = 1; |
| } else { |
| stack = opinfo->stack; |
| currentStackIndex = stack.size(); |
| } |
| |
| if (opinfo->backEdge) { |
| checkYieldPoint(); |
| } |
| } |
| |
| currentExceptionBlock = opinfo->exceptionBlock; |
| |
| currentBytecodeIndex = i; |
| currentBytecode = bytecode; |
| |
| // To prevent a gcj bug with useless goto |
| if (currentBlock->getTerminator() != 0) { |
| currentBlock = createBasicBlock("gcj bug"); |
| } |
| |
| #if JNJVM_EXECUTE > 1 |
| { |
| Value* args[3] = { |
| ConstantInt::get(Type::getInt32Ty(*llvmContext), (int64_t)bytecode), |
| ConstantInt::get(Type::getInt32Ty(*llvmContext), (int64_t)i), |
| TheCompiler->getMethodInClass(compilingMethod) |
| }; |
| |
| |
| CallInst::Create(intrinsics->PrintExecutionFunction, args, "", |
| currentBlock); |
| } |
| #endif |
| |
| switch (bytecode) { |
| |
| case NOP : break; |
| |
| case ACONST_NULL : |
| push(intrinsics->JavaObjectNullConstant, false); |
| break; |
| |
| case ICONST_M1 : |
| push(intrinsics->constantMinusOne, false); |
| break; |
| |
| case ICONST_0 : |
| push(intrinsics->constantZero, false); |
| break; |
| |
| case ICONST_1 : |
| push(intrinsics->constantOne, false); |
| break; |
| |
| case ICONST_2 : |
| push(intrinsics->constantTwo, false); |
| break; |
| |
| case ICONST_3 : |
| push(intrinsics->constantThree, false); |
| break; |
| |
| case ICONST_4 : |
| push(intrinsics->constantFour, false); |
| break; |
| |
| case ICONST_5 : |
| push(intrinsics->constantFive, false); |
| break; |
| |
| case LCONST_0 : |
| push(intrinsics->constantLongZero, false); |
| push(intrinsics->constantZero, false); |
| break; |
| |
| case LCONST_1 : |
| push(intrinsics->constantLongOne, false); |
| push(intrinsics->constantZero, false); |
| break; |
| |
| case FCONST_0 : |
| push(intrinsics->constantFloatZero, false); |
| break; |
| |
| case FCONST_1 : |
| push(intrinsics->constantFloatOne, false); |
| break; |
| |
| case FCONST_2 : |
| push(intrinsics->constantFloatTwo, false); |
| break; |
| |
| case DCONST_0 : |
| push(intrinsics->constantDoubleZero, false); |
| push(intrinsics->constantZero, false); |
| break; |
| |
| case DCONST_1 : |
| push(intrinsics->constantDoubleOne, false); |
| push(intrinsics->constantZero, false); |
| break; |
| |
| case BIPUSH : |
| push(ConstantExpr::getSExt(ConstantInt::get(Type::getInt8Ty(*llvmContext), |
| reader.readU1()), |
| Type::getInt32Ty(*llvmContext)), false); |
| i++; |
| break; |
| |
| case SIPUSH : |
| push(ConstantExpr::getSExt(ConstantInt::get(Type::getInt16Ty(*llvmContext), |
| reader.readS2()), |
| Type::getInt32Ty(*llvmContext)), false); |
| i += 2; |
| break; |
| |
| case LDC : |
| loadConstant(reader.readU1()); |
| i++; |
| break; |
| |
| case LDC_W : |
| loadConstant(reader.readS2()); |
| i += 2; |
| break; |
| |
| case LDC2_W : |
| loadConstant(reader.readS2()); |
| i += 2; |
| push(intrinsics->constantZero, false); |
| break; |
| |
| case ILOAD : |
| push(new LoadInst(intLocals[WREAD_U1(reader, false, i, wide)], "", false, |
| currentBlock), false); |
| break; |
| |
| case LLOAD : |
| push(new LoadInst(longLocals[WREAD_U1(reader, false, i, wide)], "", false, |
| currentBlock), false); |
| push(intrinsics->constantZero, false); |
| break; |
| |
| case FLOAD : |
| push(new LoadInst(floatLocals[WREAD_U1(reader, false, i, wide)], "", false, |
| currentBlock), false); |
| break; |
| |
| case DLOAD : |
| push(new LoadInst(doubleLocals[WREAD_U1(reader, false, i, wide)], "", false, |
| currentBlock), false); |
| push(intrinsics->constantZero, false); |
| break; |
| |
| case ALOAD : |
| push(new LoadInst(objectLocals[WREAD_U1(reader, false, i, wide)], "", |
| false, currentBlock), false); |
| break; |
| |
| case ILOAD_0 : |
| push(new LoadInst(intLocals[0], "", false, currentBlock), false); |
| break; |
| |
| case ILOAD_1 : |
| push(new LoadInst(intLocals[1], "", false, currentBlock), false); |
| break; |
| |
| case ILOAD_2 : |
| push(new LoadInst(intLocals[2], "", false, currentBlock), false); |
| break; |
| |
| case ILOAD_3 : |
| push(new LoadInst(intLocals[3], "", false, currentBlock), false); |
| break; |
| |
| case LLOAD_0 : |
| push(new LoadInst(longLocals[0], "", false, currentBlock), |
| false); |
| push(intrinsics->constantZero, false); |
| break; |
| |
| case LLOAD_1 : |
| push(new LoadInst(longLocals[1], "", false, currentBlock), |
| false); |
| push(intrinsics->constantZero, false); |
| break; |
| |
| case LLOAD_2 : |
| push(new LoadInst(longLocals[2], "", false, currentBlock), |
| false); |
| push(intrinsics->constantZero, false); |
| break; |
| |
| case LLOAD_3 : |
| push(new LoadInst(longLocals[3], "", false, currentBlock), |
| false); |
| push(intrinsics->constantZero, false); |
| break; |
| |
| case FLOAD_0 : |
| push(new LoadInst(floatLocals[0], "", false, currentBlock), |
| false); |
| break; |
| |
| case FLOAD_1 : |
| push(new LoadInst(floatLocals[1], "", false, currentBlock), |
| false); |
| break; |
| |
| case FLOAD_2 : |
| push(new LoadInst(floatLocals[2], "", false, currentBlock), |
| false); |
| break; |
| |
| case FLOAD_3 : |
| push(new LoadInst(floatLocals[3], "", false, currentBlock), |
| false); |
| break; |
| |
| case DLOAD_0 : |
| push(new LoadInst(doubleLocals[0], "", false, currentBlock), |
| false); |
| push(intrinsics->constantZero, false); |
| break; |
| |
| case DLOAD_1 : |
| push(new LoadInst(doubleLocals[1], "", false, currentBlock), |
| false); |
| push(intrinsics->constantZero, false); |
| break; |
| |
| case DLOAD_2 : |
| push(new LoadInst(doubleLocals[2], "", false, currentBlock), |
| false); |
| push(intrinsics->constantZero, false); |
| break; |
| |
| case DLOAD_3 : |
| push(new LoadInst(doubleLocals[3], "", false, currentBlock), |
| false); |
| push(intrinsics->constantZero, false); |
| break; |
| |
| case ALOAD_0 : |
| push(new LoadInst(objectLocals[0], "", false, currentBlock), |
| false); |
| break; |
| |
| case ALOAD_1 : |
| push(new LoadInst(objectLocals[1], "", false, currentBlock), |
| false); |
| break; |
| |
| case ALOAD_2 : |
| push(new LoadInst(objectLocals[2], "", false, currentBlock), |
| false); |
| break; |
| |
| case ALOAD_3 : |
| push(new LoadInst(objectLocals[3], "", false, currentBlock), |
| false); |
| break; |
| |
| case IALOAD : { |
| Value* index = pop(); |
| Value* obj = pop(); |
| Value* ptr = verifyAndComputePtr(obj, index, |
| intrinsics->JavaArraySInt32Type); |
| push(new LoadInst(ptr, "", currentBlock), false); |
| break; |
| } |
| |
| case LALOAD : { |
| Value* index = pop(); |
| Value* obj = pop(); |
| Value* ptr = verifyAndComputePtr(obj, index, |
| intrinsics->JavaArrayLongType); |
| push(new LoadInst(ptr, "", currentBlock), false); |
| push(intrinsics->constantZero, false); |
| break; |
| } |
| |
| case FALOAD : { |
| Value* index = pop(); |
| Value* obj = pop(); |
| Value* ptr = verifyAndComputePtr(obj, index, |
| intrinsics->JavaArrayFloatType); |
| push(new LoadInst(ptr, "", currentBlock), false); |
| break; |
| } |
| |
| case DALOAD : { |
| Value* index = pop(); |
| Value* obj = pop(); |
| Value* ptr = verifyAndComputePtr(obj, index, |
| intrinsics->JavaArrayDoubleType); |
| push(new LoadInst(ptr, "", currentBlock), false); |
| push(intrinsics->constantZero, false); |
| break; |
| } |
| |
| case AALOAD : { |
| Value* index = pop(); |
| CommonClass* cl = topTypeInfo(); |
| Value* obj = pop(); |
| Value* ptr = verifyAndComputePtr(obj, index, |
| intrinsics->JavaArrayObjectType); |
| |
| if (cl->isArray()) cl = cl->asArrayClass()->baseClass(); |
| push(new LoadInst(ptr, "", currentBlock), false, cl); |
| break; |
| } |
| |
| case BALOAD : { |
| Value* index = pop(); |
| Value* obj = pop(); |
| Value* ptr = verifyAndComputePtr(obj, index, |
| intrinsics->JavaArraySInt8Type); |
| Value* val = new LoadInst(ptr, "", currentBlock); |
| push(new SExtInst(val, Type::getInt32Ty(*llvmContext), "", currentBlock), |
| false); |
| break; |
| } |
| |
| case CALOAD : { |
| Value* index = pop(); |
| Value* obj = pop(); |
| Value* ptr = verifyAndComputePtr(obj, index, |
| intrinsics->JavaArrayUInt16Type); |
| Value* val = new LoadInst(ptr, "", currentBlock); |
| push(new ZExtInst(val, Type::getInt32Ty(*llvmContext), "", currentBlock), |
| false); |
| break; |
| } |
| |
| case SALOAD : { |
| Value* index = pop(); |
| Value* obj = pop(); |
| Value* ptr = verifyAndComputePtr(obj, index, |
| intrinsics->JavaArraySInt16Type); |
| Value* val = new LoadInst(ptr, "", currentBlock); |
| push(new SExtInst(val, Type::getInt32Ty(*llvmContext), "", currentBlock), |
| false); |
| break; |
| } |
| |
| case ISTORE : { |
| Value* val = popAsInt(); |
| new StoreInst(val, intLocals[WREAD_U1(reader, false, i, wide)], |
| false, currentBlock); |
| break; |
| } |
| |
| case LSTORE : |
| pop(); // remove the 0 on the stack |
| new StoreInst(pop(), longLocals[WREAD_U1(reader, false, i, wide)], |
| false, currentBlock); |
| break; |
| |
| case FSTORE : |
| new StoreInst(pop(), floatLocals[WREAD_U1(reader, false, i, wide)], |
| false, currentBlock); |
| break; |
| |
| case DSTORE : |
| pop(); // remove the 0 on the stack |
| new StoreInst(pop(), doubleLocals[WREAD_U1(reader, false, i, wide)], |
| false, currentBlock); |
| break; |
| |
| case ASTORE : { |
| CommonClass* cl = topTypeInfo(); |
| Instruction* V = |
| new StoreInst(pop(), objectLocals[WREAD_U1(reader, false, i, wide)], |
| false, currentBlock); |
| addHighLevelType(V, cl); |
| break; |
| } |
| case ISTORE_0 : { |
| Value* val = pop(); |
| if (val->getType() != Type::getInt32Ty(*llvmContext)) // int8 and int16 |
| val = new ZExtInst(val, Type::getInt32Ty(*llvmContext), "", currentBlock); |
| new StoreInst(val, intLocals[0], false, currentBlock); |
| break; |
| } |
| |
| case ISTORE_1 : { |
| Value* val = pop(); |
| if (val->getType() != Type::getInt32Ty(*llvmContext)) // int8 and int16 |
| val = new ZExtInst(val, Type::getInt32Ty(*llvmContext), "", currentBlock); |
| new StoreInst(val, intLocals[1], false, currentBlock); |
| break; |
| } |
| |
| case ISTORE_2 : { |
| Value* val = pop(); |
| if (val->getType() != Type::getInt32Ty(*llvmContext)) // int8 and int16 |
| val = new ZExtInst(val, Type::getInt32Ty(*llvmContext), "", currentBlock); |
| new StoreInst(val, intLocals[2], false, currentBlock); |
| break; |
| } |
| |
| case ISTORE_3 : { |
| Value* val = pop(); |
| if (val->getType() != Type::getInt32Ty(*llvmContext)) // int8 and int16 |
| val = new ZExtInst(val, Type::getInt32Ty(*llvmContext), "", currentBlock); |
| new StoreInst(val, intLocals[3], false, currentBlock); |
| break; |
| } |
| |
| case LSTORE_0 : |
| pop(); // remove the 0 on the stack |
| new StoreInst(pop(), longLocals[0], false, currentBlock); |
| break; |
| |
| case LSTORE_1 : |
| pop(); // remove the 0 on the stack |
| new StoreInst(pop(), longLocals[1], false, currentBlock); |
| break; |
| |
| case LSTORE_2 : |
| pop(); // remove the 0 on the stack |
| new StoreInst(pop(), longLocals[2], false, currentBlock); |
| break; |
| |
| case LSTORE_3 : |
| pop(); // remove the 0 on the stack |
| new StoreInst(pop(), longLocals[3], false, currentBlock); |
| break; |
| |
| case FSTORE_0 : |
| new StoreInst(pop(), floatLocals[0], false, currentBlock); |
| break; |
| |
| case FSTORE_1 : |
| new StoreInst(pop(), floatLocals[1], false, currentBlock); |
| break; |
| |
| case FSTORE_2 : |
| new StoreInst(pop(), floatLocals[2], false, currentBlock); |
| break; |
| |
| case FSTORE_3 : |
| new StoreInst(pop(), floatLocals[3], false, currentBlock); |
| break; |
| |
| case DSTORE_0 : |
| pop(); // remove the 0 on the stack |
| new StoreInst(pop(), doubleLocals[0], false, currentBlock); |
| break; |
| |
| case DSTORE_1 : |
| pop(); // remove the 0 on the stack |
| new StoreInst(pop(), doubleLocals[1], false, currentBlock); |
| break; |
| |
| case DSTORE_2 : |
| pop(); // remove the 0 on the stack |
| new StoreInst(pop(), doubleLocals[2], false, currentBlock); |
| break; |
| |
| case DSTORE_3 : |
| pop(); // remove the 0 on the stack |
| new StoreInst(pop(), doubleLocals[3], false, currentBlock); |
| break; |
| |
| case ASTORE_0 : { |
| CommonClass* cl = topTypeInfo(); |
| Instruction* V = new StoreInst(pop(), objectLocals[0], false, |
| currentBlock); |
| addHighLevelType(V, cl); |
| break; |
| } |
| |
| case ASTORE_1 : { |
| CommonClass* cl = topTypeInfo(); |
| Instruction* V = new StoreInst(pop(), objectLocals[1], false, |
| currentBlock); |
| addHighLevelType(V, cl); |
| break; |
| } |
| |
| case ASTORE_2 : { |
| CommonClass* cl = topTypeInfo(); |
| Instruction* V = new StoreInst(pop(), objectLocals[2], false, |
| currentBlock); |
| addHighLevelType(V, cl); |
| break; |
| } |
| |
| case ASTORE_3 : { |
| CommonClass* cl = topTypeInfo(); |
| Instruction* V = new StoreInst(pop(), objectLocals[3], false, |
| currentBlock); |
| addHighLevelType(V, cl); |
| break; |
| } |
| |
| case IASTORE : { |
| Value* val = popAsInt(); |
| Value* index = popAsInt(); |
| Value* obj = pop(); |
| Value* ptr = verifyAndComputePtr(obj, index, |
| intrinsics->JavaArraySInt32Type); |
| new StoreInst(val, ptr, false, currentBlock); |
| break; |
| } |
| |
| case LASTORE : { |
| pop(); // remove the 0 on stack |
| Value* val = pop(); |
| Value* index = pop(); |
| Value* obj = pop(); |
| Value* ptr = verifyAndComputePtr(obj, index, |
| intrinsics->JavaArrayLongType); |
| new StoreInst(val, ptr, false, currentBlock); |
| break; |
| } |
| |
| case FASTORE : { |
| Value* val = pop(); |
| Value* index = pop(); |
| Value* obj = pop(); |
| Value* ptr = verifyAndComputePtr(obj, index, |
| intrinsics->JavaArrayFloatType); |
| new StoreInst(val, ptr, false, currentBlock); |
| break; |
| } |
| |
| case DASTORE : { |
| pop(); // remove the 0 on stack |
| Value* val = pop(); |
| Value* index = pop(); |
| Value* obj = pop(); |
| Value* ptr = verifyAndComputePtr(obj, index, |
| intrinsics->JavaArrayDoubleType); |
| new StoreInst(val, ptr, false, currentBlock); |
| break; |
| } |
| |
| case AASTORE : { |
| if (TheCompiler->hasExceptionsEnabled()) { |
| // Get val and object and don't pop them: IsSubclassOfFunction |
| // may go into runtime and we don't want values in registers at that |
| // point. |
| Value* val = new LoadInst(objectStack[currentStackIndex - 1], "", |
| false, |
| currentBlock); |
| Value* obj = new LoadInst(objectStack[currentStackIndex - 3], "", |
| false, |
| currentBlock); |
| JITVerifyNull(obj); |
| |
| |
| |
| Value* res = 0; |
| if (TheCompiler->isStaticCompiling()) { |
| BasicBlock* endBlock = createBasicBlock("end array store check"); |
| BasicBlock* checkBlock = createBasicBlock("array store check"); |
| BasicBlock* exceptionBlock = |
| createBasicBlock("array store exception"); |
| Value* cmp = new ICmpInst(*currentBlock, ICmpInst::ICMP_EQ, val, |
| intrinsics->JavaObjectNullConstant, ""); |
| |
| |
| BranchInst::Create(endBlock, checkBlock, cmp, currentBlock); |
| currentBlock = checkBlock; |
| |
| Value* valVT = CallInst::Create(intrinsics->GetVTFunction, val, "", |
| currentBlock); |
| |
| Value* objVT = CallInst::Create(intrinsics->GetVTFunction, obj, "", |
| currentBlock); |
| objVT = CallInst::Create(intrinsics->GetBaseClassVTFromVTFunction, objVT, |
| "", currentBlock); |
| |
| Value* VTArgs[2] = { valVT, objVT }; |
| |
| res = CallInst::Create( |
| (TheCompiler->isStaticCompiling())? |
| intrinsics->IsSubclassOfFunction: |
| intrinsics->IsSubclassOfFunctionInner, |
| VTArgs, "", currentBlock); |
| BranchInst::Create(endBlock, exceptionBlock, res, currentBlock); |
| |
| currentBlock = exceptionBlock; |
| throwRuntimeException(intrinsics->ArrayStoreExceptionFunction, VTArgs, 2); |
| currentBlock = endBlock; |
| } |
| else { |
| Value* objects[2] = {val, obj}; |
| res = CallInst::Create(intrinsics->CheckIfAssignable, objects, "", currentBlock); |
| } |
| |
| |
| } |
| Value* val = pop(); |
| Value* index = pop(); |
| Value* obj = pop(); |
| Value* ptr = verifyAndComputePtr(obj, index, |
| intrinsics->JavaArrayObjectType, false); |
| if (vmkit::Collector::needsWriteBarrier()) { |
| ptr = new BitCastInst(ptr, intrinsics->ptrPtrType, "", currentBlock); |
| val = new BitCastInst(val, intrinsics->ptrType, "", currentBlock); |
| obj = new BitCastInst(obj, intrinsics->ptrType, "", currentBlock); |
| Value* args[3] = { obj, ptr, val }; |
| CallInst::Create(intrinsics->ArrayWriteBarrierFunction, args, "", currentBlock); |
| } else { |
| new StoreInst(val, ptr, false, currentBlock); |
| } |
| break; |
| } |
| |
| case BASTORE : { |
| Value* val = pop(); |
| if (val->getType() != Type::getInt8Ty(*llvmContext)) { |
| val = new TruncInst(val, Type::getInt8Ty(*llvmContext), "", currentBlock); |
| } |
| Value* index = pop(); |
| Value* obj = pop(); |
| Value* ptr = verifyAndComputePtr(obj, index, |
| intrinsics->JavaArraySInt8Type); |
| new StoreInst(val, ptr, false, currentBlock); |
| break; |
| } |
| |
| case CASTORE : { |
| Value* val = pop(); |
| Type* type = val->getType(); |
| if (type == Type::getInt32Ty(*llvmContext)) { |
| val = new TruncInst(val, Type::getInt16Ty(*llvmContext), "", currentBlock); |
| } else if (type == Type::getInt8Ty(*llvmContext)) { |
| val = new ZExtInst(val, Type::getInt16Ty(*llvmContext), "", currentBlock); |
| } |
| Value* index = pop(); |
| Value* obj = pop(); |
| Value* ptr = verifyAndComputePtr(obj, index, |
| intrinsics->JavaArrayUInt16Type); |
| new StoreInst(val, ptr, false, currentBlock); |
| break; |
| } |
| |
| case SASTORE : { |
| Value* val = pop(); |
| Type* type = val->getType(); |
| if (type == Type::getInt32Ty(*llvmContext)) { |
| val = new TruncInst(val, Type::getInt16Ty(*llvmContext), "", currentBlock); |
| } else if (type == Type::getInt8Ty(*llvmContext)) { |
| val = new SExtInst(val, Type::getInt16Ty(*llvmContext), "", currentBlock); |
| } |
| Value* index = pop(); |
| Value* obj = pop(); |
| Value* ptr = verifyAndComputePtr(obj, index, |
| intrinsics->JavaArraySInt16Type); |
| new StoreInst(val, ptr, false, currentBlock); |
| break; |
| } |
| |
| case POP : |
| pop(); |
| break; |
| |
| case POP2 : |
| pop(); pop(); |
| break; |
| |
| case DUP : |
| // TODO: The following bytecodes should push a MetaInfo. |
| push(top(), false, topTypeInfo()); |
| break; |
| |
| case DUP_X1 : { |
| CommonClass* oneCl = topTypeInfo(); |
| Value* one = pop(); |
| CommonClass* twoCl = topTypeInfo(); |
| Value* two = pop(); |
| |
| push(one, false, oneCl); |
| push(two, false, twoCl); |
| push(one, false, oneCl); |
| break; |
| } |
| |
| case DUP_X2 : { |
| CommonClass* oneCl = topTypeInfo(); |
| Value* one = pop(); |
| CommonClass* twoCl = topTypeInfo(); |
| Value* two = pop(); |
| CommonClass* threeCl = topTypeInfo(); |
| Value* three = pop(); |
| |
| push(one, false, oneCl); |
| push(three, false, threeCl); |
| push(two, false, twoCl); |
| push(one, false, oneCl); |
| break; |
| } |
| |
| case DUP2 : { |
| CommonClass* oneCl = topTypeInfo(); |
| Value* one = pop(); |
| CommonClass* twoCl = topTypeInfo(); |
| Value* two = pop(); |
| |
| push(two, false, twoCl); |
| push(one, false, oneCl); |
| push(two, false, twoCl); |
| push(one, false, oneCl); |
| break; |
| } |
| |
| case DUP2_X1 : { |
| CommonClass* oneCl = topTypeInfo(); |
| Value* one = pop(); |
| CommonClass* twoCl = topTypeInfo(); |
| Value* two = pop(); |
| CommonClass* threeCl = topTypeInfo(); |
| Value* three = pop(); |
| |
| push(two, false, twoCl); |
| push(one, false, oneCl); |
| |
| push(three, false, threeCl); |
| push(two, false, twoCl); |
| push(one, false, oneCl); |
| |
| break; |
| } |
| |
| case DUP2_X2 : { |
| CommonClass* oneCl = topTypeInfo(); |
| Value* one = pop(); |
| CommonClass* twoCl = topTypeInfo(); |
| Value* two = pop(); |
| CommonClass* threeCl = topTypeInfo(); |
| Value* three = pop(); |
| CommonClass* fourCl = topTypeInfo(); |
| Value* four = pop(); |
| |
| push(two, false, twoCl); |
| push(one, false, oneCl); |
| |
| push(four, false, fourCl); |
| push(three, false, threeCl); |
| push(two, false, twoCl); |
| push(one, false, oneCl); |
| |
| break; |
| } |
| |
| case SWAP : { |
| CommonClass* oneCl = topTypeInfo(); |
| Value* one = pop(); |
| CommonClass* twoCl = topTypeInfo(); |
| Value* two = pop(); |
| push(one, false, oneCl); |
| push(two, false, twoCl); |
| break; |
| } |
| |
| case IADD : { |
| Value* val2 = popAsInt(); |
| Value* val1 = popAsInt(); |
| push(BinaryOperator::CreateAdd(val1, val2, "", currentBlock), |
| false); |
| break; |
| } |
| |
| case LADD : { |
| pop(); |
| llvm::Value* val2 = pop(); |
| pop(); |
| llvm::Value* val1 = pop(); |
| push(BinaryOperator::CreateAdd(val1, val2, "", currentBlock), |
| false); |
| push(intrinsics->constantZero, false); |
| break; |
| } |
| |
| case FADD : { |
| Value* val2 = pop(); |
| Value* val1 = pop(); |
| push(BinaryOperator::CreateFAdd(val1, val2, "", currentBlock), |
| false); |
| break; |
| } |
| |
| case DADD : { |
| pop(); |
| llvm::Value* val2 = pop(); |
| pop(); |
| llvm::Value* val1 = pop(); |
| push(BinaryOperator::CreateFAdd(val1, val2, "", currentBlock), |
| false); |
| push(intrinsics->constantZero, false); |
| break; |
| } |
| |
| case ISUB : { |
| Value* val2 = popAsInt(); |
| Value* val1 = popAsInt(); |
| push(BinaryOperator::CreateSub(val1, val2, "", currentBlock), |
| false); |
| break; |
| } |
| case LSUB : { |
| pop(); |
| llvm::Value* val2 = pop(); |
| pop(); |
| llvm::Value* val1 = pop(); |
| push(BinaryOperator::CreateSub(val1, val2, "", currentBlock), |
| false); |
| push(intrinsics->constantZero, false); |
| break; |
| } |
| |
| case FSUB : { |
| Value* val2 = pop(); |
| Value* val1 = pop(); |
| push(BinaryOperator::CreateFSub(val1, val2, "", currentBlock), |
| false); |
| break; |
| } |
| |
| case DSUB : { |
| pop(); |
| llvm::Value* val2 = pop(); |
| pop(); |
| llvm::Value* val1 = pop(); |
| push(BinaryOperator::CreateFSub(val1, val2, "", currentBlock), |
| false); |
| push(intrinsics->constantZero, false); |
| break; |
| } |
| |
| case IMUL : { |
| Value* val2 = popAsInt(); |
| Value* val1 = popAsInt(); |
| push(BinaryOperator::CreateMul(val1, val2, "", currentBlock), |
| false); |
| break; |
| } |
| |
| case LMUL : { |
| pop(); |
| llvm::Value* val2 = pop(); |
| pop(); |
| llvm::Value* val1 = pop(); |
| push(BinaryOperator::CreateMul(val1, val2, "", currentBlock), |
| false); |
| push(intrinsics->constantZero, false); |
| break; |
| } |
| |
| case FMUL : { |
| Value* val2 = pop(); |
| Value* val1 = pop(); |
| push(BinaryOperator::CreateFMul(val1, val2, "", currentBlock), |
| false); |
| break; |
| } |
| |
| case DMUL : { |
| pop(); |
| llvm::Value* val2 = pop(); |
| pop(); |
| llvm::Value* val1 = pop(); |
| push(BinaryOperator::CreateFMul(val1, val2, "", currentBlock), |
| false); |
| push(intrinsics->constantZero, false); |
| break; |
| } |
| |
| case IDIV : { |
| Value* val2 = popAsInt(); |
| Value* val1 = popAsInt(); |
| if (TheCompiler->hasExceptionsEnabled()) { |
| Value* cmp = new ICmpInst(*currentBlock, ICmpInst::ICMP_EQ, val2, |
| intrinsics->constantZero, ""); |
| BasicBlock* ifFalse = createBasicBlock("non null div"); |
| BasicBlock* ifTrue = createBasicBlock("null div"); |
| |
| BranchInst::Create(ifTrue, ifFalse, cmp, currentBlock); |
| currentBlock = ifTrue; |
| throwRuntimeException(intrinsics->ArithmeticExceptionFunction, 0, 0); |
| currentBlock = ifFalse; |
| } |
| Value* cmp = new ICmpInst(*currentBlock, ICmpInst::ICMP_EQ, val2, |
| intrinsics->constantMinusOne, ""); |
| BasicBlock* ifFalse = createBasicBlock("non -1 div"); |
| BasicBlock* ifTrue = createBasicBlock("-1 div"); |
| BasicBlock* endBlock = createBasicBlock("End division"); |
| PHINode* node = PHINode::Create(val1->getType(), 2, "", endBlock); |
| BranchInst::Create(ifTrue, ifFalse, cmp, currentBlock); |
| currentBlock = ifTrue; |
| node->addIncoming(BinaryOperator::CreateSub(intrinsics->constantZero, |
| val1, "", currentBlock), |
| currentBlock); |
| BranchInst::Create(endBlock, currentBlock); |
| currentBlock = ifFalse; |
| node->addIncoming( |
| BinaryOperator::CreateSDiv(val1, val2, "", currentBlock), |
| currentBlock); |
| BranchInst::Create(endBlock, currentBlock); |
| currentBlock = endBlock; |
| push(node, false); |
| break; |
| } |
| |
| case LDIV : { |
| pop(); |
| llvm::Value* val2 = pop(); |
| pop(); |
| llvm::Value* val1 = pop(); |
| if (TheCompiler->hasExceptionsEnabled()) { |
| Value* cmp = new ICmpInst(*currentBlock, ICmpInst::ICMP_EQ, val2, |
| intrinsics->constantLongZero, ""); |
| BasicBlock* ifFalse = createBasicBlock("non null div"); |
| BasicBlock* ifTrue = createBasicBlock("null div"); |
| |
| BranchInst::Create(ifTrue, ifFalse, cmp, currentBlock); |
| currentBlock = ifTrue; |
| throwRuntimeException(intrinsics->ArithmeticExceptionFunction, 0, 0); |
| currentBlock = ifFalse; |
| } |
| push(BinaryOperator::CreateSDiv(val1, val2, "", currentBlock), |
| false); |
| push(intrinsics->constantZero, false); |
| break; |
| } |
| |
| case FDIV : { |
| Value* val2 = pop(); |
| Value* val1 = pop(); |
| push(BinaryOperator::CreateFDiv(val1, val2, "", currentBlock), |
| false); |
| break; |
| } |
| |
| case DDIV : { |
| pop(); |
| llvm::Value* val2 = pop(); |
| pop(); |
| llvm::Value* val1 = pop(); |
| push(BinaryOperator::CreateFDiv(val1, val2, "", currentBlock), |
| false); |
| push(intrinsics->constantZero, false); |
| break; |
| } |
| |
| case IREM : { |
| Value* val2 = popAsInt(); |
| Value* val1 = popAsInt(); |
| if (TheCompiler->hasExceptionsEnabled()) { |
| Value* cmp = new ICmpInst(*currentBlock, ICmpInst::ICMP_EQ, val2, |
| intrinsics->constantZero, ""); |
| BasicBlock* ifFalse = createBasicBlock("non null rem"); |
| BasicBlock* ifTrue = createBasicBlock("null rem"); |
| |
| BranchInst::Create(ifTrue, ifFalse, cmp, currentBlock); |
| currentBlock = ifTrue; |
| throwRuntimeException(intrinsics->ArithmeticExceptionFunction, 0, 0); |
| currentBlock = ifFalse; |
| } |
| Value* cmp = new ICmpInst(*currentBlock, ICmpInst::ICMP_EQ, val2, |
| intrinsics->constantMinusOne, ""); |
| BasicBlock* ifFalse = createBasicBlock("non -1 rem"); |
| BasicBlock* endBlock = createBasicBlock("end block"); |
| PHINode* node = PHINode::Create(val1->getType(), 2, "", endBlock); |
| node->addIncoming(intrinsics->constantZero, currentBlock); |
| BranchInst::Create(endBlock, ifFalse, cmp, currentBlock); |
| currentBlock = ifFalse; |
| node->addIncoming( |
| BinaryOperator::CreateSRem(val1, val2, "", currentBlock), |
| currentBlock); |
| BranchInst::Create(endBlock, currentBlock); |
| currentBlock = endBlock; |
| push(node, false); |
| break; |
| } |
| |
| case LREM : { |
| pop(); |
| llvm::Value* val2 = pop(); |
| pop(); |
| llvm::Value* val1 = pop(); |
| if (TheCompiler->hasExceptionsEnabled()) { |
| Value* cmp = new ICmpInst(*currentBlock, ICmpInst::ICMP_EQ, val2, |
| intrinsics->constantLongZero, ""); |
| BasicBlock* ifFalse = createBasicBlock("non null div"); |
| BasicBlock* ifTrue = createBasicBlock("null div"); |
| |
| BranchInst::Create(ifTrue, ifFalse, cmp, currentBlock); |
| currentBlock = ifTrue; |
| throwRuntimeException(intrinsics->ArithmeticExceptionFunction, 0, 0); |
| currentBlock = ifFalse; |
| } |
| push(BinaryOperator::CreateSRem(val1, val2, "", currentBlock), |
| false); |
| push(intrinsics->constantZero, false); |
| break; |
| } |
| |
| case FREM : { |
| Value* val2 = pop(); |
| Value* val1 = pop(); |
| push(BinaryOperator::CreateFRem(val1, val2, "", currentBlock), |
| false); |
| break; |
| } |
| |
| case DREM : { |
| pop(); |
| llvm::Value* val2 = pop(); |
| pop(); |
| llvm::Value* val1 = pop(); |
| push(BinaryOperator::CreateFRem(val1, val2, "", currentBlock), |
| false); |
| push(intrinsics->constantZero, false); |
| break; |
| } |
| |
| case INEG : |
| push(BinaryOperator::CreateSub( |
| intrinsics->constantZero, |
| popAsInt(), "", currentBlock), |
| false); |
| break; |
| |
| case LNEG : { |
| pop(); |
| push(BinaryOperator::CreateSub( |
| intrinsics->constantLongZero, |
| pop(), "", currentBlock), false); |
| push(intrinsics->constantZero, false); |
| break; |
| } |
| |
| case FNEG : |
| push(BinaryOperator::CreateFSub( |
| intrinsics->constantFloatMinusZero, |
| pop(), "", currentBlock), false); |
| break; |
| |
| case DNEG : { |
| pop(); |
| push(BinaryOperator::CreateFSub( |
| intrinsics->constantDoubleMinusZero, |
| pop(), "", currentBlock), false); |
| push(intrinsics->constantZero, false); |
| break; |
| } |
| |
| case ISHL : { |
| Value* val2 = popAsInt(); |
| Value* val1 = popAsInt(); |
| Value* mask = ConstantInt::get(Type::getInt32Ty(*llvmContext), 0x1F); |
| val2 = BinaryOperator::CreateAnd(val2, mask, "", currentBlock); |
| push(BinaryOperator::CreateShl(val1, val2, "", currentBlock), |
| false); |
| break; |
| } |
| |
| case LSHL : { |
| Value* val2 = new ZExtInst(pop(), Type::getInt64Ty(*llvmContext), "", currentBlock); |
| Value* mask = ConstantInt::get(Type::getInt64Ty(*llvmContext), 0x3F); |
| val2 = BinaryOperator::CreateAnd(val2, mask, "", currentBlock); |
| pop(); // remove the 0 on the stack |
| Value* val1 = pop(); |
| push(BinaryOperator::CreateShl(val1, val2, "", currentBlock), |
| false); |
| push(intrinsics->constantZero, false); |
| break; |
| } |
| |
| case ISHR : { |
| Value* val2 = popAsInt(); |
| Value* val1 = popAsInt(); |
| Value* mask = ConstantInt::get(Type::getInt32Ty(*llvmContext), 0x1F); |
| val2 = BinaryOperator::CreateAnd(val2, mask, "", currentBlock); |
| push(BinaryOperator::CreateAShr(val1, val2, "", currentBlock), |
| false); |
| break; |
| } |
| |
| case LSHR : { |
| Value* val2 = new ZExtInst(pop(), Type::getInt64Ty(*llvmContext), "", currentBlock); |
| Value* mask = ConstantInt::get(Type::getInt64Ty(*llvmContext), 0x3F); |
| val2 = BinaryOperator::CreateAnd(val2, mask, "", currentBlock); |
| pop(); // remove the 0 on the stack |
| Value* val1 = pop(); |
| push(BinaryOperator::CreateAShr(val1, val2, "", currentBlock), |
| false); |
| push(intrinsics->constantZero, false); |
| break; |
| } |
| |
| case IUSHR : { |
| Value* val2 = popAsInt(); |
| Value* val1 = popAsInt(); |
| Value* mask = ConstantInt::get(Type::getInt32Ty(*llvmContext), 0x1F); |
| val2 = BinaryOperator::CreateAnd(val2, mask, "", currentBlock); |
| push(BinaryOperator::CreateLShr(val1, val2, "", currentBlock), |
| false); |
| break; |
| } |
| |
| case LUSHR : { |
| Value* val2 = new ZExtInst(pop(), Type::getInt64Ty(*llvmContext), "", currentBlock); |
| Value* mask = ConstantInt::get(Type::getInt64Ty(*llvmContext), 0x3F); |
| val2 = BinaryOperator::CreateAnd(val2, mask, "", currentBlock); |
| pop(); // remove the 0 on the stack |
| Value* val1 = pop(); |
| push(BinaryOperator::CreateLShr(val1, val2, "", currentBlock), |
| false); |
| push(intrinsics->constantZero, false); |
| break; |
| } |
| |
| case IAND : { |
| Value* val2 = popAsInt(); |
| Value* val1 = popAsInt(); |
| push(BinaryOperator::CreateAnd(val1, val2, "", currentBlock), |
| false); |
| break; |
| } |
| |
| case LAND : { |
| pop(); |
| Value* val2 = pop(); |
| pop(); // remove the 0 on the stack |
| Value* val1 = pop(); |
| push(BinaryOperator::CreateAnd(val1, val2, "", currentBlock), |
| false); |
| push(intrinsics->constantZero, false); |
| break; |
| } |
| |
| case IOR : { |
| Value* val2 = popAsInt(); |
| Value* val1 = popAsInt(); |
| push(BinaryOperator::CreateOr(val1, val2, "", currentBlock), |
| false); |
| break; |
| } |
| |
| case LOR : { |
| pop(); |
| Value* val2 = pop(); |
| pop(); // remove the 0 on the stack |
| Value* val1 = pop(); |
| push(BinaryOperator::CreateOr(val1, val2, "", currentBlock), |
| false); |
| push(intrinsics->constantZero, false); |
| break; |
| } |
| |
| case IXOR : { |
| Value* val2 = popAsInt(); |
| Value* val1 = popAsInt(); |
| push(BinaryOperator::CreateXor(val1, val2, "", currentBlock), |
| false); |
| break; |
| } |
| |
| case LXOR : { |
| pop(); |
| Value* val2 = pop(); |
| pop(); // remove the 0 on the stack |
| Value* val1 = pop(); |
| push(BinaryOperator::CreateXor(val1, val2, "", currentBlock), |
| false); |
| push(intrinsics->constantZero, false); |
| break; |
| } |
| |
| case IINC : { |
| uint16 idx = WREAD_U1(reader, true, i, wide); |
| sint16 val = WREAD_S1(reader, false, i, wide); |
| llvm::Value* add = BinaryOperator::CreateAdd( |
| new LoadInst(intLocals[idx], "", currentBlock), |
| ConstantInt::get(Type::getInt32Ty(*llvmContext), val), "", |
| currentBlock); |
| new StoreInst(add, intLocals[idx], false, currentBlock); |
| break; |
| } |
| |
| case I2L : |
| push(new SExtInst(pop(), llvm::Type::getInt64Ty(*llvmContext), "", currentBlock), |
| false); |
| push(intrinsics->constantZero, false); |
| break; |
| |
| case I2F : |
| push(new SIToFPInst(pop(), llvm::Type::getFloatTy(*llvmContext), "", currentBlock), |
| false); |
| break; |
| |
| case I2D : |
| push(new SIToFPInst(pop(), llvm::Type::getDoubleTy(*llvmContext), "", currentBlock), |
| false); |
| push(intrinsics->constantZero, false); |
| break; |
| |
| case L2I : |
| pop(); |
| push(new TruncInst(pop(), llvm::Type::getInt32Ty(*llvmContext), "", currentBlock), |
| false); |
| break; |
| |
| case L2F : |
| pop(); |
| push(new SIToFPInst(pop(), llvm::Type::getFloatTy(*llvmContext), "", currentBlock), |
| false); |
| break; |
| |
| case L2D : |
| pop(); |
| push(new SIToFPInst(pop(), llvm::Type::getDoubleTy(*llvmContext), "", currentBlock), |
| false); |
| push(intrinsics->constantZero, false); |
| break; |
| |
| case F2I : { |
| llvm::Value* val = pop(); |
| llvm::Value* test = new FCmpInst(*currentBlock, FCmpInst::FCMP_ONE, |
| val, val, ""); |
| |
| BasicBlock* res = createBasicBlock("F2I"); |
| PHINode* node = PHINode::Create(llvm::Type::getInt32Ty(*llvmContext), 4, "", res); |
| node->addIncoming(intrinsics->constantZero, currentBlock); |
| BasicBlock* cont = createBasicBlock("F2I"); |
| |
| BranchInst::Create(res, cont, test, currentBlock); |
| |
| currentBlock = cont; |
| |
| test = new FCmpInst(*currentBlock, FCmpInst::FCMP_OGE, val, |
| intrinsics->constantMaxIntFloat, ""); |
| |
| cont = createBasicBlock("F2I"); |
| |
| BranchInst::Create(res, cont, test, currentBlock); |
| node->addIncoming(intrinsics->constantMaxInt, |
| currentBlock); |
| |
| currentBlock = cont; |
| |
| test = new FCmpInst(*currentBlock, FCmpInst::FCMP_OLE, val, |
| intrinsics->constantMinIntFloat, ""); |
| |
| cont = createBasicBlock("F2I"); |
| |
| BranchInst::Create(res, cont, test, currentBlock); |
| node->addIncoming(intrinsics->constantMinInt, currentBlock); |
| |
| currentBlock = cont; |
| llvm::Value* newVal = new FPToSIInst(val, Type::getInt32Ty(*llvmContext), "", |
| currentBlock); |
| BranchInst::Create(res, currentBlock); |
| |
| node->addIncoming(newVal, currentBlock); |
| |
| currentBlock = res; |
| |
| push(node, false); |
| break; |
| } |
| |
| case F2L : { |
| llvm::Value* val = pop(); |
| llvm::Value* test = new FCmpInst(*currentBlock, FCmpInst::FCMP_ONE, |
| val, val, ""); |
| |
| BasicBlock* res = createBasicBlock("F2L"); |
| PHINode* node = PHINode::Create(Type::getInt64Ty(*llvmContext), 4, "", res); |
| node->addIncoming(intrinsics->constantLongZero, currentBlock); |
| BasicBlock* cont = createBasicBlock("F2L"); |
| |
| BranchInst::Create(res, cont, test, currentBlock); |
| |
| currentBlock = cont; |
| |
| test = new FCmpInst(*currentBlock, FCmpInst::FCMP_OGE, val, |
| intrinsics->constantMaxLongFloat, ""); |
| |
| cont = createBasicBlock("F2L"); |
| |
| BranchInst::Create(res, cont, test, currentBlock); |
| node->addIncoming(intrinsics->constantMaxLong, currentBlock); |
| |
| currentBlock = cont; |
| |
| test = new FCmpInst(*currentBlock, FCmpInst::FCMP_OLE, val, |
| intrinsics->constantMinLongFloat, ""); |
| |
| cont = createBasicBlock("F2L"); |
| |
| BranchInst::Create(res, cont, test, currentBlock); |
| node->addIncoming(intrinsics->constantMinLong, currentBlock); |
| |
| currentBlock = cont; |
| llvm::Value* newVal = new FPToSIInst(val, Type::getInt64Ty(*llvmContext), "", |
| currentBlock); |
| BranchInst::Create(res, currentBlock); |
| |
| node->addIncoming(newVal, currentBlock); |
| |
| currentBlock = res; |
| |
| push(node, false); |
| push(intrinsics->constantZero, false); |
| break; |
| } |
| |
| case F2D : |
| push(new FPExtInst(pop(), llvm::Type::getDoubleTy(*llvmContext), "", currentBlock), |
| false); |
| push(intrinsics->constantZero, false); |
| break; |
| |
| case D2I : { |
| pop(); // remove the 0 on the stack |
| llvm::Value* val = pop(); |
| llvm::Value* test = new FCmpInst(*currentBlock, FCmpInst::FCMP_ONE, |
| val, val, ""); |
| |
| BasicBlock* res = createBasicBlock("D2I"); |
| PHINode* node = PHINode::Create(Type::getInt32Ty(*llvmContext), 4, "", res); |
| node->addIncoming(intrinsics->constantZero, currentBlock); |
| BasicBlock* cont = createBasicBlock("D2I"); |
| |
| BranchInst::Create(res, cont, test, currentBlock); |
| |
| currentBlock = cont; |
| |
| test = new FCmpInst(*currentBlock, FCmpInst::FCMP_OGE, val, |
| intrinsics->constantMaxIntDouble, ""); |
| |
| cont = createBasicBlock("D2I"); |
| |
| BranchInst::Create(res, cont, test, currentBlock); |
| node->addIncoming(intrinsics->constantMaxInt, currentBlock); |
| |
| currentBlock = cont; |
| |
| test = new FCmpInst(*currentBlock, FCmpInst::FCMP_OLE, val, |
| intrinsics->constantMinIntDouble, ""); |
| |
| cont = createBasicBlock("D2I"); |
| |
| BranchInst::Create(res, cont, test, currentBlock); |
| node->addIncoming(intrinsics->constantMinInt, currentBlock); |
| |
| currentBlock = cont; |
| llvm::Value* newVal = new FPToSIInst(val, Type::getInt32Ty(*llvmContext), "", |
| currentBlock); |
| BranchInst::Create(res, currentBlock); |
| |
| node->addIncoming(newVal, currentBlock); |
| |
| currentBlock = res; |
| |
| push(node, false); |
| |
| break; |
| } |
| |
| case D2L : { |
| pop(); // remove the 0 on the stack |
| llvm::Value* val = pop(); |
| llvm::Value* test = new FCmpInst(*currentBlock, FCmpInst::FCMP_ONE, |
| val, val, ""); |
| |
| BasicBlock* res = createBasicBlock("D2L"); |
| PHINode* node = PHINode::Create(Type::getInt64Ty(*llvmContext), 4, "", res); |
| node->addIncoming(intrinsics->constantLongZero, currentBlock); |
| BasicBlock* cont = createBasicBlock("D2L"); |
| |
| BranchInst::Create(res, cont, test, currentBlock); |
| |
| currentBlock = cont; |
| |
| test = new FCmpInst(*currentBlock, FCmpInst::FCMP_OGE, val, |
| intrinsics->constantMaxLongDouble, ""); |
| |
| cont = createBasicBlock("D2L"); |
| |
| BranchInst::Create(res, cont, test, currentBlock); |
| node->addIncoming(intrinsics->constantMaxLong, currentBlock); |
| |
| currentBlock = cont; |
| |
| test = |
| new FCmpInst(*currentBlock, FCmpInst::FCMP_OLE, val, |
| intrinsics->constantMinLongDouble, ""); |
| |
| cont = createBasicBlock("D2L"); |
| |
| BranchInst::Create(res, cont, test, currentBlock); |
| node->addIncoming(intrinsics->constantMinLong, currentBlock); |
| |
| currentBlock = cont; |
| llvm::Value* newVal = new FPToSIInst(val, Type::getInt64Ty(*llvmContext), "", |
| currentBlock); |
| BranchInst::Create(res, currentBlock); |
| |
| node->addIncoming(newVal, currentBlock); |
| |
| currentBlock = res; |
| |
| push(node, false); |
| push(intrinsics->constantZero, false); |
| break; |
| } |
| |
| case D2F : |
| pop(); // remove the 0 on the stack |
| push(new FPTruncInst(pop(), llvm::Type::getFloatTy(*llvmContext), "", currentBlock), |
| false); |
| break; |
| |
| case I2B : { |
| Value* val = pop(); |
| if (val->getType() == Type::getInt32Ty(*llvmContext)) { |
| val = new TruncInst(val, llvm::Type::getInt8Ty(*llvmContext), "", currentBlock); |
| } |
| push(new SExtInst(val, llvm::Type::getInt32Ty(*llvmContext), "", currentBlock), |
| false); |
| break; |
| } |
| |
| case I2C : { |
| Value* val = pop(); |
| if (val->getType() == Type::getInt32Ty(*llvmContext)) { |
| val = new TruncInst(val, llvm::Type::getInt16Ty(*llvmContext), "", currentBlock); |
| } |
| push(new ZExtInst(val, llvm::Type::getInt32Ty(*llvmContext), "", currentBlock), |
| false); |
| break; |
| } |
| |
| case I2S : { |
| Value* val = pop(); |
| if (val->getType() == Type::getInt32Ty(*llvmContext)) { |
| val = new TruncInst(val, llvm::Type::getInt16Ty(*llvmContext), "", currentBlock); |
| } |
| push(new SExtInst(val, llvm::Type::getInt32Ty(*llvmContext), "", currentBlock), |
| false); |
| break; |
| } |
| |
| case LCMP : { |
| pop(); |
| llvm::Value* val2 = pop(); |
| pop(); |
| llvm::Value* val1 = pop(); |
| |
| llvm::Value* test = new ICmpInst(*currentBlock, ICmpInst::ICMP_EQ, val1, |
| val2, ""); |
| |
| BasicBlock* cont = createBasicBlock("LCMP"); |
| BasicBlock* res = createBasicBlock("LCMP"); |
| PHINode* node = PHINode::Create(Type::getInt32Ty(*llvmContext), 2, "", res); |
| node->addIncoming(intrinsics->constantZero, currentBlock); |
| |
| BranchInst::Create(res, cont, test, currentBlock); |
| currentBlock = cont; |
| |
| test = new ICmpInst(*currentBlock, ICmpInst::ICMP_SLT, val1, val2, ""); |
| node->addIncoming(intrinsics->constantMinusOne, currentBlock); |
| |
| cont = createBasicBlock("LCMP"); |
| BranchInst::Create(res, cont, test, currentBlock); |
| currentBlock = cont; |
| node->addIncoming(intrinsics->constantOne, currentBlock); |
| BranchInst::Create(res, currentBlock); |
| currentBlock = res; |
| |
| push(node, false); |
| break; |
| } |
| |
| case FCMPL : { |
| llvm::Value* val2 = pop(); |
| llvm::Value* val1 = pop(); |
| compareFP(val1, val2, Type::getFloatTy(*llvmContext), false); |
| break; |
| } |
| |
| case FCMPG : { |
| llvm::Value* val2 = pop(); |
| llvm::Value* val1 = pop(); |
| compareFP(val1, val2, Type::getFloatTy(*llvmContext), true); |
| break; |
| } |
| |
| case DCMPL : { |
| pop(); |
| llvm::Value* val2 = pop(); |
| pop(); |
| llvm::Value* val1 = pop(); |
| |
| compareFP(val1, val2, Type::getDoubleTy(*llvmContext), false); |
| break; |
| } |
| |
| case DCMPG : { |
| pop(); |
| llvm::Value* val2 = pop(); |
| pop(); |
| llvm::Value* val1 = pop(); |
| |
| compareFP(val1, val2, Type::getDoubleTy(*llvmContext), false); |
| break; |
| } |
| |
| case IFEQ : { |
| uint32 tmp = i; |
| Opinfo& ifTrueInfo = opcodeInfos[tmp + reader.readS2()]; |
| i += 2; |
| BasicBlock* ifTrue = ifTrueInfo.newBlock; |
| |
| Value* op = pop(); |
| Type* type = op->getType(); |
| Constant* val = Constant::getNullValue(type); |
| llvm::Value* test = new ICmpInst(*currentBlock, ICmpInst::ICMP_EQ, op, |
| val, ""); |
| BasicBlock* ifFalse = createBasicBlock("false IFEQ"); |
| branch(test, ifTrue, ifFalse, currentBlock, ifTrueInfo); |
| currentBlock = ifFalse; |
| break; |
| } |
| |
| case IFNE : { |
| uint32 tmp = i; |
| Opinfo& ifTrueInfo = opcodeInfos[tmp + reader.readS2()]; |
| i += 2; |
| BasicBlock* ifTrue = ifTrueInfo.newBlock; |
| |
| Value* op = pop(); |
| Type* type = op->getType(); |
| Constant* val = Constant::getNullValue(type); |
| llvm::Value* test = new ICmpInst(*currentBlock, ICmpInst::ICMP_NE, op, |
| val, ""); |
| BasicBlock* ifFalse = createBasicBlock("false IFNE"); |
| branch(test, ifTrue, ifFalse, currentBlock, ifTrueInfo); |
| currentBlock = ifFalse; |
| break; |
| } |
| |
| case IFLT : { |
| uint32 tmp = i; |
| Opinfo& ifTrueInfo = opcodeInfos[tmp + reader.readS2()]; |
| i += 2; |
| BasicBlock* ifTrue = ifTrueInfo.newBlock; |
| Value* op = pop(); |
| Type* type = op->getType(); |
| Constant* val = Constant::getNullValue(type); |
| llvm::Value* test = new ICmpInst(*currentBlock, ICmpInst::ICMP_SLT, op, |
| val, ""); |
| BasicBlock* ifFalse = createBasicBlock("false IFLT"); |
| branch(test, ifTrue, ifFalse, currentBlock, ifTrueInfo); |
| currentBlock = ifFalse; |
| break; |
| } |
| |
| case IFGE : { |
| uint32 tmp = i; |
| Opinfo& ifTrueInfo = opcodeInfos[tmp + reader.readS2()]; |
| i += 2; |
| BasicBlock* ifTrue = ifTrueInfo.newBlock; |
| Value* op = pop(); |
| Type* type = op->getType(); |
| Constant* val = Constant::getNullValue(type); |
| llvm::Value* test = new ICmpInst(*currentBlock, ICmpInst::ICMP_SGE, op, |
| val, ""); |
| BasicBlock* ifFalse = createBasicBlock("false IFGE"); |
| branch(test, ifTrue, ifFalse, currentBlock, ifTrueInfo); |
| currentBlock = ifFalse; |
| break; |
| } |
| |
| case IFGT : { |
| uint32 tmp = i; |
| Opinfo& ifTrueInfo = opcodeInfos[tmp + reader.readS2()]; |
| i += 2; |
| BasicBlock* ifTrue = ifTrueInfo.newBlock; |
| Value* op = pop(); |
| Type* type = op->getType(); |
| Constant* val = Constant::getNullValue(type); |
| llvm::Value* test = new ICmpInst(*currentBlock, ICmpInst::ICMP_SGT, op, |
| val, ""); |
| BasicBlock* ifFalse = createBasicBlock("false IFGT"); |
| branch(test, ifTrue, ifFalse, currentBlock, ifTrueInfo); |
| currentBlock = ifFalse; |
| break; |
| } |
| |
| case IFLE : { |
| uint32 tmp = i; |
| Opinfo& ifTrueInfo = opcodeInfos[tmp + reader.readS2()]; |
| i += 2; |
| BasicBlock* ifTrue = ifTrueInfo.newBlock; |
| Value* op = pop(); |
| Type* type = op->getType(); |
| Constant* val = Constant::getNullValue(type); |
| llvm::Value* test = new ICmpInst(*currentBlock, ICmpInst::ICMP_SLE, op, |
| val, ""); |
| BasicBlock* ifFalse = createBasicBlock("false IFLE"); |
| branch(test, ifTrue, ifFalse, currentBlock, ifTrueInfo); |
| currentBlock = ifFalse; |
| break; |
| } |
| |
| case IF_ICMPEQ : { |
| Value *val2 = popAsInt(); |
| Value *val1 = popAsInt(); |
| uint32 tmp = i; |
| Opinfo& ifTrueInfo = opcodeInfos[tmp + reader.readS2()]; |
| i += 2; |
| BasicBlock* ifTrue = ifTrueInfo.newBlock; |
| llvm::Value* test = new ICmpInst(*currentBlock, ICmpInst::ICMP_EQ, val1, |
| val2, ""); |
| BasicBlock* ifFalse = createBasicBlock("false IF_ICMPEQ"); |
| branch(test, ifTrue, ifFalse, currentBlock, ifTrueInfo); |
| currentBlock = ifFalse; |
| break; |
| } |
| |
| case IF_ICMPNE : { |
| Value *val2 = popAsInt(); |
| Value *val1 = popAsInt(); |
| uint32 tmp = i; |
| Opinfo& ifTrueInfo = opcodeInfos[tmp + reader.readS2()]; |
| i += 2; |
| BasicBlock* ifTrue = ifTrueInfo.newBlock; |
| llvm::Value* test = new ICmpInst(*currentBlock, ICmpInst::ICMP_NE, val1, |
| val2, ""); |
| BasicBlock* ifFalse = createBasicBlock("false IF_ICMPNE"); |
| branch(test, ifTrue, ifFalse, currentBlock, ifTrueInfo); |
| currentBlock = ifFalse; |
| break; |
| } |
| |
| case IF_ICMPLT : { |
| Value *val2 = popAsInt(); |
| Value *val1 = popAsInt(); |
| uint32 tmp = i; |
| Opinfo& ifTrueInfo = opcodeInfos[tmp + reader.readS2()]; |
| i += 2; |
| BasicBlock* ifTrue = ifTrueInfo.newBlock; |
| llvm::Value* test = new ICmpInst(*currentBlock, ICmpInst::ICMP_SLT, |
| val1, val2, ""); |
| BasicBlock* ifFalse = createBasicBlock("false IF_IFCMPLT"); |
| branch(test, ifTrue, ifFalse, currentBlock, ifTrueInfo); |
| currentBlock = ifFalse; |
| break; |
| } |
| |
| case IF_ICMPGE : { |
| Value *val2 = popAsInt(); |
| Value *val1 = popAsInt(); |
| uint32 tmp = i; |
| Opinfo& ifTrueInfo = opcodeInfos[tmp + reader.readS2()]; |
| i += 2; |
| BasicBlock* ifTrue = ifTrueInfo.newBlock; |
| llvm::Value* test = new ICmpInst(*currentBlock, ICmpInst::ICMP_SGE, |
| val1, val2, ""); |
| BasicBlock* ifFalse = createBasicBlock("false IF_ICMPGE"); |
| branch(test, ifTrue, ifFalse, currentBlock, ifTrueInfo); |
| currentBlock = ifFalse; |
| break; |
| } |
| |
| case IF_ICMPGT : { |
| Value *val2 = popAsInt(); |
| Value *val1 = popAsInt(); |
| uint32 tmp = i; |
| Opinfo& ifTrueInfo = opcodeInfos[tmp + reader.readS2()]; |
| i += 2; |
| BasicBlock* ifTrue = ifTrueInfo.newBlock; |
| llvm::Value* test = new ICmpInst(*currentBlock, ICmpInst::ICMP_SGT, |
| val1, val2, ""); |
| BasicBlock* ifFalse = createBasicBlock("false IF_ICMPGT"); |
| branch(test, ifTrue, ifFalse, currentBlock, ifTrueInfo); |
| currentBlock = ifFalse; |
| break; |
| } |
| |
| case IF_ICMPLE : { |
| Value *val2 = popAsInt(); |
| Value *val1 = popAsInt(); |
| uint32 tmp = i; |
| Opinfo& ifTrueInfo = opcodeInfos[tmp + reader.readS2()]; |
| i += 2; |
| BasicBlock* ifTrue = ifTrueInfo.newBlock; |
| llvm::Value* test = new ICmpInst(*currentBlock, ICmpInst::ICMP_SLE, |
| val1, val2, ""); |
| BasicBlock* ifFalse = createBasicBlock("false IF_ICMPLE"); |
| branch(test, ifTrue, ifFalse, currentBlock, ifTrueInfo); |
| currentBlock = ifFalse; |
| break; |
| } |
| |
| case IF_ACMPEQ : { |
| Value *val2 = pop(); |
| Value *val1 = pop(); |
| uint32 tmp = i; |
| Opinfo& ifTrueInfo = opcodeInfos[tmp + reader.readS2()]; |
| i += 2; |
| BasicBlock* ifTrue = ifTrueInfo.newBlock; |
| llvm::Value* test = new ICmpInst(*currentBlock, ICmpInst::ICMP_EQ, |
| val1, val2, ""); |
| BasicBlock* ifFalse = createBasicBlock("false IF_ACMPEQ"); |
| branch(test, ifTrue, ifFalse, currentBlock, ifTrueInfo); |
| currentBlock = ifFalse; |
| break; |
| } |
| |
| case IF_ACMPNE : { |
| Value *val2 = pop(); |
| Value *val1 = pop(); |
| uint32 tmp = i; |
| Opinfo& ifTrueInfo = opcodeInfos[tmp + reader.readS2()]; |
| i += 2; |
| BasicBlock* ifTrue = ifTrueInfo.newBlock; |
| llvm::Value* test = new ICmpInst(*currentBlock, ICmpInst::ICMP_NE, |
| val1, val2, ""); |
| BasicBlock* ifFalse = createBasicBlock("false IF_ACMPNE"); |
| branch(test, ifTrue, ifFalse, currentBlock, ifTrueInfo); |
| currentBlock = ifFalse; |
| break; |
| } |
| |
| case GOTO : { |
| uint32 tmp = i; |
| branch(opcodeInfos[tmp + reader.readS2()], |
| currentBlock); |
| i += 2; |
| break; |
| } |
| |
| case JSR : { |
| uint32 tmp = i; |
| uint32 index = jsrIndex | 1; |
| jsrIndex += 2; |
| Value* expr = ConstantExpr::getIntToPtr( |
| ConstantInt::get(Type::getInt64Ty(*llvmContext), |
| uint64_t (index)), |
| intrinsics->JavaObjectType); |
| push(expr, false); |
| branch(opcodeInfos[tmp + reader.readS2()], currentBlock); |
| i += 2; |
| break; |
| } |
| |
| case RET : { |
| uint8 local = reader.readU1(); |
| i += 1; |
| Value* _val = new LoadInst( |
| objectLocals[local], "", false, currentBlock); |
| Value* val = new PtrToIntInst(_val, Type::getInt32Ty(*llvmContext), "", currentBlock); |
| SwitchInst* inst = SwitchInst::Create(val, jsrs[0], jsrs.size(), |
| currentBlock); |
| |
| uint32 index = 0; |
| for (std::vector<BasicBlock*>::iterator i = jsrs.begin(), |
| e = jsrs.end(); i!= e; ++i, index += 2) { |
| inst->addCase(ConstantInt::get(Type::getInt32Ty(*llvmContext), index | 1), *i); |
| } |
| |
| break; |
| } |
| |
| case TABLESWITCH : { |
| uint32 tmp = i; |
| uint32 reste = (i + 1) & 3; |
| uint32 filled = reste ? (4 - reste) : 0; |
| i += filled; |
| reader.cursor += filled; |
| Opinfo& def = opcodeInfos[tmp + reader.readU4()]; |
| i += 4; |
| |
| sint32 low = reader.readS4(); |
| i += 4; |
| sint32 high = reader.readS4() + 1; |
| i += 4; |
| |
| Value* index = pop(); |
| |
| Type* type = index->getType(); |
| for (sint32 cur = low; cur < high; ++cur) { |
| Value* cmp = new ICmpInst(*currentBlock, ICmpInst::ICMP_EQ, |
| ConstantInt::get(type, cur), index, ""); |
| BasicBlock* falseBlock = createBasicBlock("continue tableswitch"); |
| Opinfo& info = opcodeInfos[tmp + reader.readU4()]; |
| i += 4; |
| branch(cmp, info.newBlock, falseBlock, currentBlock, info); |
| currentBlock = falseBlock; |
| } |
| |
| |
| branch(def, currentBlock); |
| i = tmp + 12 + filled + ((high - low) << 2); |
| |
| break; |
| } |
| |
| case LOOKUPSWITCH : { |
| uint32 tmp = i; |
| uint32 filled = (3 - i) & 3; |
| i += filled; |
| reader.cursor += filled; |
| Opinfo& def = opcodeInfos[tmp + reader.readU4()]; |
| i += 4; |
| uint32 nbs = reader.readU4(); |
| i += 4; |
| |
| Value* key = pop(); |
| for (uint32 cur = 0; cur < nbs; ++cur) { |
| Value* val = ConstantInt::get(Type::getInt32Ty(*llvmContext), reader.readU4()); |
| i += 4; |
| Value* cmp = new ICmpInst(*currentBlock, ICmpInst::ICMP_EQ, val, key, |
| ""); |
| BasicBlock* falseBlock = createBasicBlock("continue lookupswitch"); |
| Opinfo& info = opcodeInfos[tmp + reader.readU4()]; |
| i += 4; |
| branch(cmp, info.newBlock, falseBlock, currentBlock, info); |
| currentBlock = falseBlock; |
| } |
| branch(def, currentBlock); |
| i = tmp + 8 + filled + (nbs << 3); |
| break; |
| } |
| case IRETURN : { |
| Value* val = pop(); |
| assert(val->getType()->isIntegerTy()); |
| convertValue(val, endNode->getType(), currentBlock, false); |
| endNode->addIncoming(val, currentBlock); |
| BranchInst::Create(endBlock, currentBlock); |
| break; |
| } |
| case LRETURN : |
| pop(); // remove the 0 on the stack |
| endNode->addIncoming(pop(), currentBlock); |
| BranchInst::Create(endBlock, currentBlock); |
| break; |
| |
| case FRETURN : |
| endNode->addIncoming(pop(), currentBlock); |
| BranchInst::Create(endBlock, currentBlock); |
| break; |
| |
| case DRETURN : |
| pop(); // remove the 0 on the stack |
| endNode->addIncoming(pop(), currentBlock); |
| BranchInst::Create(endBlock, currentBlock); |
| break; |
| |
| case ARETURN : |
| endNode->addIncoming(pop(), currentBlock); |
| BranchInst::Create(endBlock, currentBlock); |
| break; |
| |
| case RETURN : { |
| // Prevent a javac bug. |
| if (endNode != 0) { |
| endNode->addIncoming(Constant::getNullValue(endNode->getType()), |
| currentBlock); |
| } |
| BranchInst::Create(endBlock, currentBlock); |
| break; |
| } |
| |
| case GETSTATIC : { |
| uint16 index = reader.readU2(); |
| i += 2; |
| getStaticField(index); |
| break; |
| } |
| |
| case PUTSTATIC : { |
| uint16 index = reader.readU2(); |
| i += 2; |
| setStaticField(index); |
| break; |
| } |
| |
| case GETFIELD : { |
| uint16 index = reader.readU2(); |
| i += 2; |
| getVirtualField(index); |
| break; |
| } |
| |
| case PUTFIELD : { |
| uint16 index = reader.readU2(); |
| i += 2; |
| setVirtualField(index); |
| break; |
| } |
| |
| case INVOKEVIRTUAL : { |
| uint16 index = reader.readU2(); |
| i += 2; |
| invokeVirtual(index); |
| break; |
| } |
| |
| case INVOKESPECIAL : { |
| uint16 index = reader.readU2(); |
| i += 2; |
| invokeSpecial(index); |
| break; |
| } |
| |
| case INVOKESTATIC : { |
| uint16 index = reader.readU2(); |
| i += 2; |
| invokeStatic(index); |
| break; |
| } |
| |
| case INVOKEINTERFACE : { |
| uint16 index = reader.readU2(); |
| i += 2; |
| invokeInterface(index); |
| i += 2; |
| break; |
| } |
| |
| case NEW : { |
| uint16 index = reader.readU2(); |
| i += 2; |
| invokeNew(index); |
| break; |
| } |
| |
| case NEWARRAY : |
| case ANEWARRAY : { |
| |
| Constant* sizeElement = 0; |
| Value* TheVT = 0; |
| Value* valCl = 0; |
| UserClassArray* dcl = 0; |
| |
| if (bytecode == NEWARRAY) { |
| uint8 id = reader.readU1(); |
| i += 1; |
| uint8 charId = arrayType(compilingMethod, id); |
| JnjvmBootstrapLoader* loader = |
| compilingClass->classLoader->bootstrapLoader; |
| dcl = loader->getArrayClass(id); |
| valCl = TheCompiler->getNativeClass(dcl); |
| |
| LLVMAssessorInfo& LAI = TheCompiler->AssessorInfo[charId]; |
| sizeElement = ConstantInt::get(Type::getInt32Ty(*llvmContext), |
| LAI.logSizeInBytesConstant); |
| if (TheCompiler->isStaticCompiling() && |
| valCl->getType() != intrinsics->JavaClassArrayType) { |
| valCl = new LoadInst(valCl, "", currentBlock); |
| TheVT = CallInst::Create(intrinsics->GetVTFromClassArrayFunction, |
| valCl, "", currentBlock); |
| } else { |
| TheVT = TheCompiler->getVirtualTable(dcl->virtualVT); |
| } |
| } else { |
| uint16 index = reader.readU2(); |
| i += 2; |
| CommonClass* cl = |
| compilingClass->ctpInfo->getMethodClassIfLoaded(index); |
| |
| if (cl && (!cl->isClass() || cl->asClass()->isResolved())) { |
| JnjvmClassLoader* JCL = cl->classLoader; |
| const UTF8* arrayName = JCL->constructArrayName(1, cl->name); |
| |
| dcl = JCL->constructArray(arrayName); |
| valCl = TheCompiler->getNativeClass(dcl); |
| |
| // If we're static compiling and the class is not a class we |
| // are compiling, the result of getNativeClass is a pointer to |
| // the class. Load it. |
| if (TheCompiler->isStaticCompiling() && |
| valCl->getType() != intrinsics->JavaClassArrayType) { |
| valCl = new LoadInst(valCl, "", currentBlock); |
| TheVT = CallInst::Create(intrinsics->GetVTFromClassArrayFunction, |
| valCl, "", currentBlock); |
| } else { |
| TheVT = TheCompiler->getVirtualTable(dcl->virtualVT); |
| } |
| |
| } else { |
| Type* Ty = |
| PointerType::getUnqual(intrinsics->VTType); |
| Value* args[3]= { TheCompiler->getNativeClass(compilingClass), |
| ConstantInt::get(Type::getInt32Ty(*llvmContext), index), |
| Constant::getNullValue(Ty) }; |
| TheVT = CallInst::Create(intrinsics->GetArrayClassFunction, args, |
| "", currentBlock); |
| } |
| |
| sizeElement = intrinsics->constantPtrLogSize; |
| } |
| Value* arg1 = popAsInt(); |
| |
| if (TheCompiler->hasExceptionsEnabled()) { |
| Value* cmp = new ICmpInst(*currentBlock, ICmpInst::ICMP_SLT, arg1, |
| intrinsics->constantZero, ""); |
| |
| BasicBlock* BB1 = createBasicBlock(""); |
| BasicBlock* BB2 = createBasicBlock(""); |
| |
| BranchInst::Create(BB1, BB2, cmp, currentBlock); |
| currentBlock = BB1; |
| throwRuntimeException(intrinsics->NegativeArraySizeExceptionFunction, arg1); |
| currentBlock = BB2; |
| |
| cmp = new ICmpInst(*currentBlock, ICmpInst::ICMP_SGT, arg1, |
| intrinsics->MaxArraySizeConstant, ""); |
| |
| BB1 = createBasicBlock(""); |
| BB2 = createBasicBlock(""); |
| |
| BranchInst::Create(BB1, BB2, cmp, currentBlock); |
| currentBlock = BB1; |
| throwRuntimeException(intrinsics->OutOfMemoryErrorFunction, arg1); |
| currentBlock = BB2; |
| } |
| |
| Value* mult = BinaryOperator::CreateShl(arg1, sizeElement, "", |
| currentBlock); |
| Value* size = |
| BinaryOperator::CreateAdd(intrinsics->JavaArraySizeConstant, mult, |
| "", currentBlock); |
| TheVT = new BitCastInst(TheVT, intrinsics->ptrType, "", currentBlock); |
| Instruction* res = invoke(intrinsics->VTAllocateFunction, size, TheVT, "", |
| currentBlock); |
| Value* cast = new BitCastInst(res, intrinsics->JavaArrayType, "", |
| currentBlock); |
| |
| // Set the size |
| Value* gep4[2] = { intrinsics->constantZero, |
| intrinsics->JavaArraySizeOffsetConstant }; |
| Value* GEP = GetElementPtrInst::Create(cast, gep4, "", currentBlock); |
| |
| arg1 = new IntToPtrInst(arg1, intrinsics->ptrType, "", currentBlock); |
| new StoreInst(arg1, GEP, currentBlock); |
| |
| addHighLevelType(res, dcl ? dcl : upcalls->ArrayOfObject); |
| res = new BitCastInst(res, intrinsics->JavaObjectType, "", currentBlock); |
| push(res, false, dcl ? dcl : upcalls->ArrayOfObject); |
| |
| break; |
| } |
| |
| case ARRAYLENGTH : { |
| Value* val = pop(); |
| JITVerifyNull(val); |
| push(arraySize(val), false); |
| break; |
| } |
| |
| case ATHROW : { |
| llvm::Value* arg = pop(); |
| throwException(arg); |
| break; |
| } |
| |
| case CHECKCAST : |
| if (!TheCompiler->hasExceptionsEnabled()) { |
| i += 2; |
| reader.cursor += 2; |
| break; |
| } |
| |
| case INSTANCEOF : { |
| |
| bool checkcast = (bytecode == CHECKCAST); |
| |
| BasicBlock* exceptionCheckcast = 0; |
| BasicBlock* endCheckcast = 0; |
| |
| uint16 index = reader.readU2(); |
| i += 2; |
| UserCommonClass* cl = 0; |
| Value* clVar = getResolvedCommonClass(index, true, &cl); |
| Value* obj = top(); |
| Value* args[2] = { obj, clVar }; |
| Value* cmp = new ICmpInst(*currentBlock, ICmpInst::ICMP_EQ, obj, |
| intrinsics->JavaObjectNullConstant, ""); |
| BasicBlock* endBlock = createBasicBlock("end type compare"); |
| PHINode* node = PHINode::Create(Type::getInt1Ty(*llvmContext), 2, "", endBlock); |
| |
| if (checkcast) { |
| exceptionCheckcast = createBasicBlock("false checkcast"); |
| |
| |
| endCheckcast = createBasicBlock("null checkcast"); |
| BasicBlock* ifFalse = createBasicBlock("non null checkcast"); |
| |
| BranchInst::Create(endCheckcast, ifFalse, cmp, currentBlock); |
| currentBlock = exceptionCheckcast; |
| throwRuntimeException(intrinsics->ClassCastExceptionFunction, args, 2); |
| currentBlock = ifFalse; |
| } else { |
| BasicBlock* ifFalse = createBasicBlock("false type compare"); |
| BranchInst::Create(endBlock, ifFalse, cmp, currentBlock); |
| node->addIncoming(ConstantInt::getFalse(*llvmContext), currentBlock); |
| currentBlock = ifFalse; |
| } |
| |
| Value* TheVT = 0; |
| if (!cl || TheCompiler->isStaticCompiling()) { |
| TheVT = CallInst::Create(intrinsics->GetVTFromCommonClassFunction, |
| clVar, "", currentBlock); |
| } else { |
| TheVT = TheCompiler->getVirtualTable(cl->virtualVT); |
| } |
| |
| |
| Value* objVT = CallInst::Create(intrinsics->GetVTFunction, obj, "", |
| currentBlock); |
| Value* classArgs[2] = { objVT, TheVT }; |
| |
| Value* res = 0; |
| if (cl) { |
| if (cl->isSecondaryClass()) { |
| if (TheCompiler->isStaticCompiling()) |
| res = CallInst::Create(intrinsics->IsSecondaryClassFunction, |
| classArgs, "", currentBlock); |
| else |
| res = CallInst::Create(intrinsics->IsSecondaryClassFunctionInner, |
| classArgs, "", currentBlock); |
| } else { |
| Value* inDisplay = CallInst::Create(intrinsics->GetDisplayFunction, |
| objVT, "", currentBlock); |
| |
| uint32 depth = cl->virtualVT->depth; |
| ConstantInt* CI = ConstantInt::get(Type::getInt32Ty(*llvmContext), depth); |
| Value* displayArgs[2] = { inDisplay, CI }; |
| Value* VTInDisplay = |
| CallInst::Create(intrinsics->GetVTInDisplayFunction, |
| displayArgs, "", currentBlock); |
| |
| res = new ICmpInst(*currentBlock, ICmpInst::ICMP_EQ, VTInDisplay, |
| TheVT, ""); |
| } |
| } else { |
| if (TheCompiler->isStaticCompiling()) |
| res = CallInst::Create(intrinsics->IsSubclassOfFunction, |
| classArgs, "", currentBlock); |
| else |
| res = CallInst::Create(intrinsics->IsSubclassOfFunctionInner, |
| classArgs, "", currentBlock); |
| } |
| |
| node->addIncoming(res, currentBlock); |
| BranchInst::Create(endBlock, currentBlock); |
| currentBlock = endBlock; |
| |
| if (checkcast) { |
| BranchInst::Create(endCheckcast, exceptionCheckcast, node, |
| currentBlock); |
| currentBlock = endCheckcast; |
| } else { |
| pop(); |
| push(new ZExtInst(node, Type::getInt32Ty(*llvmContext), "", currentBlock), |
| false); |
| } |
| |
| break; |
| } |
| |
| case MONITORENTER : { |
| bool thisReference = isThisReference(currentStackIndex - 1); |
| Value* obj = pop(); |
| if (!thisReference) JITVerifyNull(obj); |
| monitorEnter(obj); |
| break; |
| } |
| |
| case MONITOREXIT : { |
| bool thisReference = isThisReference(currentStackIndex - 1); |
| Value* obj = pop(); |
| if (!thisReference) JITVerifyNull(obj); |
| monitorExit(obj); |
| break; |
| } |
| |
| case MULTIANEWARRAY : { |
| uint16 index = reader.readU2(); |
| i += 2; |
| uint8 dim = reader.readU1(); |
| i += 1; |
| |
| UserCommonClass* dcl = 0; |
| Value* valCl = getResolvedCommonClass(index, true, &dcl); |
| Value** args = (Value**)allocator.Allocate(sizeof(Value*) * (dim + 2)); |
| args[0] = valCl; |
| args[1] = ConstantInt::get(Type::getInt32Ty(*llvmContext), dim); |
| |
| for (int cur = dim + 1; cur >= 2; --cur) |
| args[cur] = pop(); |
| |
| std::vector<Value*> Args; |
| for (sint32 v = 0; v < dim + 2; ++v) { |
| Args.push_back(args[v]); |
| } |
| push(invoke(intrinsics->MultiCallNewFunction, Args, "", currentBlock), |
| false, dcl ? dcl : upcalls->ArrayOfObject); |
| break; |
| } |
| |
| case WIDE : |
| wide = true; |
| break; |
| |
| case IFNULL : { |
| uint32 tmp = i; |
| llvm::Value* val = pop(); |
| Constant* nil = Constant::getNullValue(val->getType()); |
| llvm::Value* test = new ICmpInst(*currentBlock, ICmpInst::ICMP_EQ, val, |
| nil, ""); |
| BasicBlock* ifFalse = createBasicBlock("true IFNULL"); |
| Opinfo& ifTrueInfo = opcodeInfos[tmp + reader.readS2()]; |
| i += 2; |
| BasicBlock* ifTrue = ifTrueInfo.newBlock; |
| branch(test, ifTrue, ifFalse, currentBlock, ifTrueInfo); |
| currentBlock = ifFalse; |
| break; |
| } |
| |
| case IFNONNULL : { |
| uint32 tmp = i; |
| llvm::Value* val = pop(); |
| Constant* nil = Constant::getNullValue(val->getType()); |
| llvm::Value* test = new ICmpInst(*currentBlock, ICmpInst::ICMP_NE, val, |
| nil, ""); |
| BasicBlock* ifFalse = createBasicBlock("false IFNONNULL"); |
| Opinfo& ifTrueInfo = opcodeInfos[tmp + reader.readS2()]; |
| i += 2; |
| BasicBlock* ifTrue = ifTrueInfo.newBlock; |
| branch(test, ifTrue, ifFalse, currentBlock, ifTrueInfo); |
| currentBlock = ifFalse; |
| break; |
| } |
| |
| default : { |
| fprintf(stderr, "I haven't verified your class file and it's malformed:" |
| " unknown bytecode %d in %s.%s\n!", bytecode, |
| UTF8Buffer(compilingClass->name).cString(), |
| UTF8Buffer(compilingMethod->name).cString()); |
| abort(); |
| } |
| } |
| } |
| } |
| |
| void JavaJIT::exploreOpcodes(Reader& reader, uint32 codeLength) { |
| PRINT_DEBUG(JNJVM_COMPILE, 1, DARK_YELLOW, "exploreOpcodes %d \n", codeLength); |
| |
| bool wide = false; |
| uint32 start = reader.cursor; |
| for(uint32 i = 0; i < codeLength; ++i) { |
| reader.cursor = start + i; |
| uint8 bytecode = reader.readU1(); |
| |
| PRINT_DEBUG(JNJVM_COMPILE, 1, DARK_CYAN, "\t[at %5d] %-5d ", i, |
| bytecode); |
| PRINT_DEBUG(JNJVM_COMPILE, 1, LIGHT_BLUE, "exploring "); |
| PRINT_DEBUG(JNJVM_COMPILE, 1, LIGHT_CYAN, OpcodeNames[bytecode]); |
| PRINT_DEBUG(JNJVM_COMPILE, 1, LIGHT_BLUE, "\n"); |
| |
| switch (bytecode) { |
| |
| case NOP : |
| case ACONST_NULL : |
| case ICONST_M1 : |
| case ICONST_0 : |
| case ICONST_1 : |
| case ICONST_2 : |
| case ICONST_3 : |
| case ICONST_4 : |
| case ICONST_5 : |
| case LCONST_0 : |
| case LCONST_1 : |
| case FCONST_0 : |
| case FCONST_1 : |
| case FCONST_2 : |
| case DCONST_0 : |
| case DCONST_1 : break; |
| |
| case BIPUSH : ++i; break; |
| |
| case SIPUSH : i += 2; break; |
| |
| case LDC : ++i; break; |
| |
| case LDC_W : |
| case LDC2_W : i += 2; break; |
| |
| case ILOAD : |
| case LLOAD : |
| case FLOAD : |
| case DLOAD : |
| case ALOAD : |
| i += WCALC(1, wide); |
| break; |
| |
| case ILOAD_0 : |
| case ILOAD_1 : |
| case ILOAD_2 : |
| case ILOAD_3 : |
| case LLOAD_0 : |
| case LLOAD_1 : |
| case LLOAD_2 : |
| case LLOAD_3 : |
| case FLOAD_0 : |
| case FLOAD_1 : |
| case FLOAD_2 : |
| case FLOAD_3 : |
| case DLOAD_0 : |
| case DLOAD_1 : |
| case DLOAD_2 : |
| case DLOAD_3 : |
| case ALOAD_0 : |
| case ALOAD_1 : |
| case ALOAD_2 : |
| case ALOAD_3 : |
| case IALOAD : |
| case LALOAD : |
| case FALOAD : |
| case DALOAD : |
| case AALOAD : |
| case BALOAD : |
| case CALOAD : |
| case SALOAD : break; |
| |
| case ISTORE : |
| case LSTORE : |
| case FSTORE : |
| case DSTORE : |
| case ASTORE : |
| i += WCALC(1, wide); |
| break; |
| |
| case ISTORE_0 : |
| case ISTORE_1 : |
| case ISTORE_2 : |
| case ISTORE_3 : |
| case LSTORE_0 : |
| case LSTORE_1 : |
| case LSTORE_2 : |
| case LSTORE_3 : |
| case FSTORE_0 : |
| case FSTORE_1 : |
| case FSTORE_2 : |
| case FSTORE_3 : |
| case DSTORE_0 : |
| case DSTORE_1 : |
| case DSTORE_2 : |
| case DSTORE_3 : |
| case ASTORE_1 : |
| case ASTORE_2 : |
| case ASTORE_3 : |
| case IASTORE : |
| case LASTORE : |
| case FASTORE : |
| case DASTORE : |
| case AASTORE : |
| case BASTORE : |
| case CASTORE : |
| case SASTORE : |
| case POP : |
| case POP2 : |
| case DUP : |
| case DUP_X1 : |
| case DUP_X2 : |
| case DUP2 : |
| case DUP2_X1 : |
| case DUP2_X2 : |
| case SWAP : |
| case IADD : |
| case LADD : |
| case FADD : |
| case DADD : |
| case ISUB : |
| case LSUB : |
| case FSUB : |
| case DSUB : |
| case IMUL : |
| case LMUL : |
| case FMUL : |
| case DMUL : |
| case IDIV : |
| case LDIV : |
| case FDIV : |
| case DDIV : |
| case IREM : |
| case LREM : |
| case FREM : |
| case DREM : |
| case INEG : |
| case LNEG : |
| case FNEG : |
| case DNEG : |
| case ISHL : |
| case LSHL : |
| case ISHR : |
| case LSHR : |
| case IUSHR : |
| case LUSHR : |
| case IAND : |
| case LAND : |
| case IOR : |
| case LOR : |
| case IXOR : |
| case LXOR : break; |
| |
| case ASTORE_0 : |
| if (!isStatic(compilingMethod->access)) overridesThis = true; |
| break; |
| |
| case IINC : |
| i += WCALC(2, wide); |
| break; |
| |
| case I2L : |
| case I2F : |
| case I2D : |
| case L2I : |
| case L2F : |
| case L2D : |
| case F2I : |
| case F2L : |
| case F2D : |
| case D2I : |
| case D2L : |
| case D2F : |
| case I2B : |
| case I2C : |
| case I2S : |
| case LCMP : |
| case FCMPL : |
| case FCMPG : |
| case DCMPL : |
| case DCMPG : break; |
| |
| case IFEQ : |
| case IFNE : |
| case IFLT : |
| case IFGE : |
| case IFGT : |
| case IFLE : |
| case IF_ICMPEQ : |
| case IF_ICMPNE : |
| case IF_ICMPLT : |
| case IF_ICMPGE : |
| case IF_ICMPGT : |
| case IF_ICMPLE : |
| case IF_ACMPEQ : |
| case IF_ACMPNE : |
| case GOTO : |
| case IFNULL : |
| case IFNONNULL : { |
| uint32 tmp = i; |
| uint16 index = tmp + reader.readU2(); |
| if (index < i) opcodeInfos[index].backEdge = true; |
| i += 2; |
| if (!(opcodeInfos[index].newBlock)) |
| opcodeInfos[index].newBlock = createBasicBlock(""); |
| break; |
| } |
| |
| case JSR : { |
| uint32 tmp = i; |
| uint16 index = tmp + reader.readU2(); |
| i += 2; |
| if (!(opcodeInfos[index].newBlock)) { |
| BasicBlock* block = createBasicBlock("JSR"); |
| opcodeInfos[index].newBlock = block; |
| } |
| if (!(opcodeInfos[tmp + 3].newBlock)) { |
| BasicBlock* block = createBasicBlock("JSR2"); |
| jsrs.push_back(block); |
| opcodeInfos[tmp + 3].newBlock = block; |
| } else { |
| jsrs.push_back(opcodeInfos[tmp + 3].newBlock); |
| } |
| break; |
| } |
| |
| case RET : ++i; break; |
| |
| case TABLESWITCH : { |
| uint32 tmp = i; |
| uint32 reste = (i + 1) & 3; |
| uint32 filled = reste ? (4 - reste) : 0; |
| i += filled; |
| reader.cursor += filled; |
| uint32 index = tmp + reader.readU4(); |
| i += 4; |
| if (!(opcodeInfos[index].newBlock)) { |
| BasicBlock* block = createBasicBlock("tableswitch"); |
| opcodeInfos[index].newBlock = block; |
| } |
| uint32 low = reader.readU4(); |
| i += 4; |
| uint32 high = reader.readU4() + 1; |
| i += 4; |
| uint32 depl = high - low; |
| for (uint32 cur = 0; cur < depl; ++cur) { |
| uint32 index2 = tmp + reader.readU4(); |
| i += 4; |
| if (!(opcodeInfos[index2].newBlock)) { |
| BasicBlock* block = createBasicBlock("tableswitch"); |
| opcodeInfos[index2].newBlock = block; |
| } |
| } |
| i = tmp + 12 + filled + (depl << 2); |
| break; |
| } |
| |
| case LOOKUPSWITCH : { |
| uint32 tmp = i; |
| uint32 filled = (3 - i) & 3; |
| i += filled; |
| reader.cursor += filled; |
| uint32 index = tmp + reader.readU4(); |
| i += 4; |
| if (!(opcodeInfos[index].newBlock)) { |
| BasicBlock* block = createBasicBlock("tableswitch"); |
| opcodeInfos[index].newBlock = block; |
| } |
| uint32 nbs = reader.readU4(); |
| i += 4; |
| for (uint32 cur = 0; cur < nbs; ++cur) { |
| i += 4; |
| reader.cursor += 4; |
| uint32 index2 = tmp + reader.readU4(); |
| i += 4; |
| if (!(opcodeInfos[index2].newBlock)) { |
| BasicBlock* block = createBasicBlock("tableswitch"); |
| opcodeInfos[index2].newBlock = block; |
| } |
| } |
| |
| i = tmp + 8 + filled + (nbs << 3); |
| break; |
| } |
| |
| case IRETURN : |
| case LRETURN : |
| case FRETURN : |
| case DRETURN : |
| case ARETURN : |
| case RETURN : break; |
| |
| case GETSTATIC : |
| case PUTSTATIC : |
| case GETFIELD : |
| case PUTFIELD : |
| case INVOKEVIRTUAL : |
| case INVOKESPECIAL : |
| case INVOKESTATIC : |
| i += 2; |
| break; |
| |
| case INVOKEINTERFACE : |
| i += 4; |
| break; |
| |
| case NEW : |
| i += 2; |
| break; |
| |
| case NEWARRAY : |
| ++i; |
| break; |
| |
| case ANEWARRAY : |
| i += 2; |
| break; |
| |
| case ARRAYLENGTH : |
| case ATHROW : break; |
| |
| case CHECKCAST : |
| i += 2; |
| break; |
| |
| case INSTANCEOF : |
| i += 2; |
| break; |
| |
| case MONITORENTER : |
| break; |
| |
| case MONITOREXIT : |
| break; |
| |
| case MULTIANEWARRAY : |
| i += 3; |
| break; |
| |
| case WIDE : |
| wide = true; |
| break; |
| |
| default : { |
| fprintf(stderr, "I haven't verified your class file and it's malformed:" |
| " unknown bytecode %d in %s.%s!\n", bytecode, |
| UTF8Buffer(compilingClass->name).cString(), |
| UTF8Buffer(compilingMethod->name).cString()); |
| abort(); |
| } |
| } |
| } |
| } |
| |
| bool JavaJIT::canInlineLoadConstant(uint16 index) { |
| JavaConstantPool* ctpInfo = compilingClass->ctpInfo; |
| uint8 type = ctpInfo->typeAt(index); |
| if (type == JavaConstantPool::ConstantString |
| || type == JavaConstantPool::ConstantClass) { |
| return false; |
| } else { |
| return true; |
| } |
| } |
| |
| static uint8 getReceiver(const std::vector<uint8>& stack, Signdef* signature) { |
| uint32_t index = stack.size() - 1; |
| Typedef* const* arguments = signature->getArgumentsType(); |
| for (uint32 i = 0; i < signature->nbArguments; i++) { |
| index--; |
| if (arguments[i]->isDouble() || arguments[i]->isLong()) { |
| index--; |
| } |
| } |
| return stack[index]; |
| } |
| |
| static void updateStack(std::vector<uint8>& stack, Signdef* signature, uint8 bytecode) { |
| Typedef* const* arguments = signature->getArgumentsType(); |
| if (bytecode != INVOKESTATIC) { |
| stack.pop_back(); |
| } |
| for (uint32 i = 0; i < signature->nbArguments; i++) { |
| stack.pop_back(); |
| if (arguments[i]->isDouble() || arguments[i]->isLong()) { |
| stack.pop_back(); |
| } |
| } |
| if (!signature->getReturnType()->isVoid()) { |
| stack.push_back(bytecode); |
| if (signature->getReturnType()->isLong() |
| || signature->getReturnType()->isDouble()) { |
| stack.push_back(bytecode); |
| } |
| } |
| } |
| |
| bool JavaJIT::analyzeForInlining(Reader& reader, uint32 codeLength) { |
| JavaConstantPool* ctpInfo = compilingClass->ctpInfo; |
| bool wide = false; |
| uint32 start = reader.cursor; |
| std::vector<uint8_t> stack; |
| for(uint32 i = 0; i < codeLength; ++i) { |
| reader.cursor = start + i; |
| uint8 bytecode = reader.readU1(); |
| |
| switch (bytecode) { |
| case NOP : |
| break; |
| |
| case ACONST_NULL : |
| case ICONST_M1 : |
| case ICONST_0 : |
| case ICONST_1 : |
| case ICONST_2 : |
| case ICONST_3 : |
| case ICONST_4 : |
| case ICONST_5 : |
| case FCONST_0 : |
| case FCONST_1 : |
| case FCONST_2 : |
| stack.push_back(bytecode); |
| break; |
| |
| case LCONST_0 : |
| case LCONST_1 : |
| case DCONST_0 : |
| case DCONST_1 : |
| stack.push_back(bytecode); |
| stack.push_back(bytecode); |
| break; |
| |
| case BIPUSH : |
| ++i; |
| stack.push_back(bytecode); |
| break; |
| |
| case SIPUSH : |
| i += 2; |
| stack.push_back(bytecode); |
| break; |
| |
| case LDC : |
| i++; |
| stack.push_back(bytecode); |
| if (!canInlineLoadConstant(reader.readU1())) return false; |
| break; |
| |
| case LDC_W : |
| i += 2; |
| stack.push_back(bytecode); |
| if (!canInlineLoadConstant(reader.readS2())) return false; |
| break; |
| |
| |
| case LDC2_W : |
| i += 2; |
| stack.push_back(bytecode); |
| stack.push_back(bytecode); |
| if (!canInlineLoadConstant(reader.readS2())) return false; |
| break; |
| |
| case ILOAD : |
| case FLOAD : |
| case ALOAD : |
| i += WCALC(1, wide); |
| stack.push_back(bytecode); |
| break; |
| |
| case LLOAD : |
| case DLOAD : |
| i += WCALC(1, wide); |
| stack.push_back(bytecode); |
| stack.push_back(bytecode); |
| break; |
| |
| case ILOAD_0 : |
| case ILOAD_1 : |
| case ILOAD_2 : |
| case ILOAD_3 : |
| case FLOAD_0 : |
| case FLOAD_1 : |
| case FLOAD_2 : |
| case FLOAD_3 : |
| case ALOAD_0 : |
| case ALOAD_1 : |
| case ALOAD_2 : |
| case ALOAD_3 : |
| stack.push_back(bytecode); |
| break; |
| |
| case LLOAD_0 : |
| case LLOAD_1 : |
| case LLOAD_2 : |
| case LLOAD_3 : |
| case DLOAD_0 : |
| case DLOAD_1 : |
| case DLOAD_2 : |
| case DLOAD_3 : |
| stack.push_back(bytecode); |
| stack.push_back(bytecode); |
| break; |
| |
| case IALOAD : |
| case FALOAD : |
| case AALOAD : |
| case BALOAD : |
| case CALOAD : |
| case SALOAD : |
| stack.pop_back(); |
| stack.pop_back(); |
| stack.push_back(bytecode); |
| return false; |
| |
| case LALOAD : |
| case DALOAD : |
| stack.pop_back(); |
| stack.pop_back(); |
| stack.push_back(bytecode); |
| stack.push_back(bytecode); |
| return false; |
| |
| case ISTORE : |
| case FSTORE : |
| case ASTORE : |
| stack.pop_back(); |
| i += WCALC(1, wide); |
| break; |
| |
| case LSTORE : |
| case DSTORE : |
| stack.pop_back(); |
| stack.pop_back(); |
| i += WCALC(1, wide); |
| break; |
| |
| case ISTORE_0 : |
| case ISTORE_1 : |
| case ISTORE_2 : |
| case ISTORE_3 : |
| case FSTORE_0 : |
| case FSTORE_1 : |
| case FSTORE_2 : |
| case FSTORE_3 : |
| case ASTORE_1 : |
| case ASTORE_2 : |
| case ASTORE_3 : |
| stack.pop_back(); |
| break; |
| |
| case ASTORE_0 : |
| stack.pop_back(); |
| if (!isStatic(compilingMethod->access)) return false; |
| break; |
| |
| case DSTORE_0 : |
| case DSTORE_1 : |
| case DSTORE_2 : |
| case DSTORE_3 : |
| case LSTORE_0 : |
| case LSTORE_1 : |
| case LSTORE_2 : |
| case LSTORE_3 : |
| stack.pop_back(); |
| stack.pop_back(); |
| break; |
| |
| case IASTORE : |
| case FASTORE : |
| case AASTORE : |
| case BASTORE : |
| case CASTORE : |
| case SASTORE : |
| stack.pop_back(); |
| stack.pop_back(); |
| stack.pop_back(); |
| return false; |
| |
| case LASTORE : |
| case DASTORE : |
| stack.pop_back(); |
| stack.pop_back(); |
| stack.pop_back(); |
| stack.pop_back(); |
| return false; |
| |
| case POP : |
| stack.pop_back(); |
| break; |
| |
| case POP2 : |
| stack.pop_back(); |
| stack.pop_back(); |
| break; |
| |
| case DUP : |
| stack.push_back(stack.back()); |
| break; |
| |
| case DUP_X1 : { |
| uint8 one = stack.back(); stack.pop_back(); |
| uint8 two = stack.back(); stack.pop_back(); |
| |
| stack.push_back(one); |
| stack.push_back(two); |
| stack.push_back(one); |
| break; |
| } |
| |
| case DUP_X2 : { |
| uint8 one = stack.back(); stack.pop_back(); |
| uint8 two = stack.back(); stack.pop_back(); |
| uint8 three = stack.back(); stack.pop_back(); |
| |
| stack.push_back(one); |
| stack.push_back(three); |
| stack.push_back(two); |
| stack.push_back(one); |
| break; |
| } |
| |
| case DUP2 : { |
| uint8 one = stack.back(); stack.pop_back(); |
| uint8 two = stack.back(); stack.pop_back(); |
| |
| stack.push_back(two); |
| stack.push_back(one); |
| stack.push_back(two); |
| stack.push_back(one); |
| break; |
| } |
| |
| case DUP2_X1 : { |
| uint8 one = stack.back(); stack.pop_back(); |
| uint8 two = stack.back(); stack.pop_back(); |
| uint8 three = stack.back(); stack.pop_back(); |
| |
| stack.push_back(two); |
| stack.push_back(one); |
| stack.push_back(three); |
| stack.push_back(two); |
| stack.push_back(one); |
| |
| break; |
| } |
| |
| case DUP2_X2 : { |
| uint8 one = stack.back(); stack.pop_back(); |
| uint8 two = stack.back(); stack.pop_back(); |
| uint8 three = stack.back(); stack.pop_back(); |
| uint8 four = stack.back(); stack.pop_back(); |
| |
| stack.push_back(two); |
| stack.push_back(one); |
| stack.push_back(four); |
| stack.push_back(three); |
| stack.push_back(two); |
| stack.push_back(one); |
| |
| break; |
| } |
| |
| case SWAP : { |
| uint8 one = stack.back(); stack.pop_back(); |
| uint8 two = stack.back(); stack.pop_back(); |
| stack.push_back(one); |
| stack.push_back(two); |
| break; |
| } |
| |
| case IADD : |
| case FADD : |
| case ISUB : |
| case FSUB : |
| case IMUL : |
| case FMUL : |
| case FDIV : |
| case FREM : |
| case ISHL : |
| case ISHR : |
| case IUSHR : |
| case IAND : |
| case IOR : |
| case IXOR : |
| stack.pop_back(); |
| stack.pop_back(); |
| stack.push_back(bytecode); |
| break; |
| |
| case LADD : |
| case DADD : |
| case DDIV : |
| case LMUL : |
| case DMUL : |
| case DREM : |
| case LSUB : |
| case DSUB : |
| stack.pop_back(); |
| stack.pop_back(); |
| stack.push_back(bytecode); |
| stack.push_back(bytecode); |
| break; |
| |
| case IREM : |
| case IDIV : |
| case LREM : |
| case LDIV : |
| return false; |
| |
| case INEG : |
| case FNEG : |
| stack.pop_back(); |
| stack.push_back(bytecode); |
| break; |
| |
| case LNEG : |
| case DNEG : |
| stack.pop_back(); |
| stack.pop_back(); |
| stack.push_back(bytecode); |
| stack.push_back(bytecode); |
| break; |
| |
| case LSHL : |
| case LSHR : |
| case LUSHR : |
| case LAND : |
| case LOR : |
| case LXOR : |
| stack.pop_back(); |
| stack.pop_back(); |
| stack.pop_back(); |
| stack.push_back(bytecode); |
| stack.push_back(bytecode); |
| break; |
| |
| case IINC : |
| i += WCALC(2, wide); |
| break; |
| |
| case I2L : |
| case I2D : |
| case F2L : |
| case F2D : |
| stack.pop_back(); |
| stack.push_back(bytecode); |
| stack.push_back(bytecode); |
| break; |
| |
| case I2F : |
| case F2I : |
| case I2B : |
| case I2C : |
| case I2S : |
| stack.pop_back(); |
| stack.push_back(bytecode); |
| break; |
| |
| case L2I : |
| case L2F : |
| case D2I : |
| case D2F : |
| stack.pop_back(); |
| stack.pop_back(); |
| stack.push_back(bytecode); |
| break; |
| |
| case L2D : |
| case D2L : |
| stack.pop_back(); |
| stack.pop_back(); |
| stack.push_back(bytecode); |
| stack.push_back(bytecode); |
| break; |
| |
| case FCMPL : |
| case FCMPG : |
| stack.pop_back(); |
| stack.pop_back(); |
| stack.push_back(bytecode); |
| break; |
| |
| case LCMP : |
| case DCMPL : |
| case DCMPG : |
| stack.pop_back(); |
| stack.pop_back(); |
| stack.pop_back(); |
| stack.pop_back(); |
| stack.push_back(bytecode); |
| break; |
| |
| case IFEQ : |
| case IFNE : |
| case IFLT : |
| case IFGE : |
| case IFGT : |
| case IFLE : { |
| i += 2; |
| stack.pop_back(); |
| if (stack.size() > 0) return false; |
| break; |
| } |
| |
| case IF_ICMPEQ : |
| case IF_ICMPNE : |
| case IF_ICMPLT : |
| case IF_ICMPGE : |
| case IF_ICMPGT : |
| case IF_ICMPLE : |
| case IF_ACMPEQ : |
| case IF_ACMPNE : { |
| i += 2; |
| stack.pop_back(); |
| stack.pop_back(); |
| if (stack.size() > 0) return false; |
| break; |
| } |
| case GOTO : { |
| i += 2; |
| if (stack.size() > 0) return false; |
| break; |
| } |
| |
| case JSR : { |
| i += 2; |
| return false; |
| } |
| |
| case RET : { |
| ++i; |
| return false; |
| } |
| |
| case TABLESWITCH : { |
| stack.pop_back(); |
| if (stack.size() > 0) return false; |
| uint32 tmp = i; |
| uint32 reste = (i + 1) & 3; |
| uint32 filled = reste ? (4 - reste) : 0; |
| i += filled; |
| reader.cursor += filled; |
| reader.readU4(); |
| i += 4; |
| |
| sint32 low = reader.readS4(); |
| i += 4; |
| sint32 high = reader.readS4() + 1; |
| i += 4; |
| for (sint32 cur = low; cur < high; ++cur) { |
| reader.readU4(); |
| i += 4; |
| } |
| |
| i = tmp + 12 + filled + ((high - low) << 2); |
| break; |
| } |
| |
| case LOOKUPSWITCH : { |
| stack.pop_back(); |
| if (stack.size() > 0) return false; |
| uint32 tmp = i; |
| uint32 filled = (3 - i) & 3; |
| i += filled; |
| reader.cursor += filled; |
| reader.readU4(); |
| i += 4; |
| uint32 nbs = reader.readU4(); |
| i += 4; |
| for (uint32 cur = 0; cur < nbs; ++cur) { |
| i += 4; |
| reader.cursor += 4; |
| reader.readU4(); |
| i += 4; |
| } |
| |
| i = tmp + 8 + filled + (nbs << 3); |
| break; |
| } |
| |
| case IRETURN : |
| case FRETURN : |
| case ARETURN : |
| stack.pop_back(); |
| break; |
| |
| case RETURN : |
| break; |
| |
| case LRETURN : |
| case DRETURN : |
| stack.pop_back(); |
| stack.pop_back(); |
| break; |
| |
| case GETSTATIC : |
| case PUTSTATIC : { |
| uint16 index = reader.readU2(); |
| Typedef* sign = ctpInfo->infoOfField(index); |
| JavaField* field = ctpInfo->lookupField(index, true); |
| if (field == NULL) return false; |
| if (needsInitialisationCheck(field->classDef)) return false; |
| if (bytecode == GETSTATIC) { |
| stack.push_back(bytecode); |
| if (sign->isDouble() || sign->isLong()) { |
| stack.push_back(bytecode); |
| } |
| } else { |
| stack.pop_back(); |
| if (sign->isDouble() || sign->isLong()) { |
| stack.pop_back(); |
| } |
| } |
| i += 2; |
| break; |
| } |
| |
| case PUTFIELD : { |
| if (isStatic(compilingMethod->access)) return false; |
| i += 2; |
| stack.pop_back(); // value |
| uint16 index = reader.readU2(); |
| Typedef* sign = ctpInfo->infoOfField(index); |
| if (sign->isDouble() || sign->isLong()) { |
| stack.pop_back(); // value |
| } |
| if (stack.back() != ALOAD_0) return false; |
| stack.pop_back(); // object |
| break; |
| } |
| |
| case GETFIELD : { |
| if (isStatic(compilingMethod->access)) return false; |
| if (stack.back() != ALOAD_0) return false; |
| i += 2; |
| stack.pop_back(); // object |
| uint16 index = reader.readU2(); |
| Typedef* sign = ctpInfo->infoOfField(index); |
| stack.push_back(bytecode); |
| if (sign->isDouble() || sign->isLong()) { |
| stack.push_back(bytecode); |
| } |
| break; |
| } |
| |
| case INVOKEVIRTUAL : { |
| if (isStatic(compilingMethod->access)) return false; |
| uint16 index = reader.readU2(); |
| CommonClass* cl = NULL; |
| JavaMethod* meth = NULL; |
| ctpInfo->infoOfMethod(index, ACC_VIRTUAL, cl, meth); |
| i += 2; |
| if (meth == NULL) return false; |
| if (getReceiver(stack, meth->getSignature()) != ALOAD_0) return false; |
| bool customized = false; |
| if (!(isFinal(cl->access) || isFinal(meth->access))) { |
| if (customizeFor == NULL) return false; |
| if (!customizeFor->isSubclassOf(cl)) return false; |
| meth = customizeFor->lookupMethodDontThrow( |
| meth->name, meth->type, false, true, NULL); |
| assert(meth); |
| assert(!meth->classDef->isInterface()); |
| assert(!isAbstract(meth->access)); |
| customized = true; |
| } |
| if (!canBeInlined(meth, customized)) return false; |
| updateStack(stack, meth->getSignature(), bytecode); |
| break; |
| } |
| |
| case INVOKESPECIAL : { |
| if (isStatic(compilingMethod->access)) return false; |
| uint16 index = reader.readU2(); |
| CommonClass* cl = NULL; |
| JavaMethod* meth = NULL; |
| ctpInfo->infoOfMethod(index, ACC_VIRTUAL, cl, meth); |
| i += 2; |
| if (meth == NULL) return false; |
| if (getReceiver(stack, meth->getSignature()) != ALOAD_0) return false; |
| if (!canBeInlined(meth, false)) return false; |
| updateStack(stack, meth->getSignature(), bytecode); |
| break; |
| } |
| |
| case INVOKESTATIC : { |
| uint16 index = reader.readU2(); |
| CommonClass* cl = NULL; |
| JavaMethod* meth = NULL; |
| ctpInfo->infoOfMethod(index, ACC_STATIC, cl, meth); |
| i += 2; |
| if (meth == NULL) return false; |
| if (!canBeInlined(meth, false)) return false; |
| if (needsInitialisationCheck(cl->asClass())) return false; |
| updateStack(stack, meth->getSignature(), bytecode); |
| break; |
| } |
| |
| case INVOKEINTERFACE : |
| i += 4; |
| return false; |
| |
| case NEW : |
| i += 2; |
| return false; |
| |
| case NEWARRAY : |
| ++i; |
| return false; |
| |
| case ANEWARRAY : |
| i += 2; |
| return false; |
| |
| case ARRAYLENGTH : |
| stack.pop_back(); |
| stack.push_back(bytecode); |
| return false; |
| |
| case ATHROW : |
| return false; |
| |
| case CHECKCAST : |
| i += 2; |
| return false; |
| |
| case INSTANCEOF : |
| i += 2; |
| return false; |
| |
| case MONITORENTER : |
| case MONITOREXIT : |
| return false; |
| |
| case MULTIANEWARRAY : |
| i += 3; |
| return false; |
| |
| case WIDE : |
| wide = true; |
| break; |
| |
| case IFNULL : |
| case IFNONNULL : |
| stack.pop_back(); |
| i += 2; |
| if (stack.size() > 0) return false; |
| break; |
| |
| default : |
| return false; |
| } |
| } |
| return true; |
| } |
