| Instruction* JavaJIT::invoke(Value *F, std::vector<llvm::Value*>& args, |
| const char* Name, |
| BasicBlock *InsertAtEnd) { |
| |
| Instruction* res = CallInst::Create(F, args.begin(), args.end(), Name, |
| InsertAtEnd); |
| |
| res->setMetadata("dbg", CreateLocation()); |
| |
| if (TheCompiler->hasExceptionsEnabled()) { |
| Value* threadId = getCurrentThread(intrinsics->JavaThreadType); |
| Value* geps[2] = { intrinsics->constantZero, |
| intrinsics->OffsetJavaExceptionInThreadConstant }; |
| |
| Value* javaExceptionPtr = GetElementPtrInst::Create(threadId, geps, |
| geps + 2, "", |
| currentBlock); |
| |
| // Get the Java exception. |
| Value* obj = 0; |
| |
| BasicBlock* ifNormal = createBasicBlock("no exception block"); |
| |
| Value* test = 0; |
| Constant* zero = intrinsics->JavaObjectNullConstant; |
| |
| // If F is a runtime intrinsic that does not access memory, use a hack |
| // that will prevent LLVM from moving the exception check: runtime |
| // intrinsics return the exception if an exception was raised. |
| if (F == intrinsics->InitialisationCheckFunction || |
| F == intrinsics->GetConstantPoolAtFunction || |
| F == intrinsics->GetArrayClassFunction || |
| F == intrinsics->GetClassDelegateeFunction) { |
| // Make the load volatile to force the instruction after the call. |
| // Otherwise, LLVM will merge the load with a previous load because |
| // the function is readnone. |
| obj = new LoadInst(javaExceptionPtr, "", true, currentBlock); |
| test = new BitCastInst(res, intrinsics->JavaObjectType, "", currentBlock); |
| test = new ICmpInst(*currentBlock, ICmpInst::ICMP_EQ, test, obj, ""); |
| Value* T = new ICmpInst(*currentBlock, ICmpInst::ICMP_NE, obj, zero, ""); |
| test = BinaryOperator::CreateAnd(test, T, "", currentBlock); |
| } else { |
| obj = new LoadInst(javaExceptionPtr, "", currentBlock); |
| test = new ICmpInst(*currentBlock, ICmpInst::ICMP_NE, obj, zero, ""); |
| } |
| |
| BranchInst::Create(currentExceptionBlock, ifNormal, test, currentBlock); |
| |
| |
| if (!currentExceptionBlock->empty()) { |
| Instruction* insn = currentExceptionBlock->begin(); |
| PHINode* node = dyn_cast<PHINode>(insn); |
| if (node) node->addIncoming(obj, currentBlock); |
| } |
| |
| currentBlock = ifNormal; |
| } |
| |
| return res; |
| } |
| |
| Instruction* JavaJIT::invoke(Value *F, Value* arg1, const char* Name, |
| BasicBlock *InsertAtEnd) { |
| |
| Instruction* res = CallInst::Create(F, arg1, Name, InsertAtEnd); |
| res->setMetadata("dbg", CreateLocation()); |
| |
| if (TheCompiler->hasExceptionsEnabled()) { |
| Value* threadId = getCurrentThread(intrinsics->JavaThreadType); |
| Value* geps[2] = { intrinsics->constantZero, |
| intrinsics->OffsetJavaExceptionInThreadConstant }; |
| |
| Value* javaExceptionPtr = GetElementPtrInst::Create(threadId, geps, |
| geps + 2, "", |
| currentBlock); |
| |
| // Get the Java exception. |
| Value* obj = 0; |
| |
| BasicBlock* ifNormal = createBasicBlock("no exception block"); |
| |
| Value* test = 0; |
| Constant* zero = intrinsics->JavaObjectNullConstant; |
| if (F == intrinsics->InitialisationCheckFunction || |
| F == intrinsics->GetConstantPoolAtFunction || |
| F == intrinsics->GetArrayClassFunction || |
| F == intrinsics->GetClassDelegateeFunction) { |
| obj = new LoadInst(javaExceptionPtr, "", true, currentBlock); |
| test = new BitCastInst(res, intrinsics->JavaObjectType, "", currentBlock); |
| test = new ICmpInst(*currentBlock, ICmpInst::ICMP_EQ, test, obj, ""); |
| Value* T = new ICmpInst(*currentBlock, ICmpInst::ICMP_NE, obj, zero, ""); |
| test = BinaryOperator::CreateAnd(test, T, "", currentBlock); |
| } else { |
| obj = new LoadInst(javaExceptionPtr, "", currentBlock); |
| test = new ICmpInst(*currentBlock, ICmpInst::ICMP_NE, obj, zero, ""); |
| } |
| |
| BranchInst::Create(currentExceptionBlock, ifNormal, test, currentBlock); |
| |
| if (!currentExceptionBlock->empty()) { |
| Instruction* insn = currentExceptionBlock->begin(); |
| PHINode* node = dyn_cast<PHINode>(insn); |
| if (node) node->addIncoming(obj, currentBlock); |
| } |
| |
| currentBlock = ifNormal; |
| } |
| |
| return res; |
| } |
| |
| Instruction* JavaJIT::invoke(Value *F, Value* arg1, Value* arg2, |
| const char* Name, BasicBlock *InsertAtEnd) { |
| |
| Value* args[2] = { arg1, arg2 }; |
| |
| Instruction* res = CallInst::Create(F, args, args + 2, Name, InsertAtEnd); |
| res->setMetadata("dbg", CreateLocation()); |
| |
| if (TheCompiler->hasExceptionsEnabled()) { |
| Value* threadId = getCurrentThread(intrinsics->JavaThreadType); |
| Value* geps[2] = { intrinsics->constantZero, |
| intrinsics->OffsetJavaExceptionInThreadConstant }; |
| |
| Value* javaExceptionPtr = GetElementPtrInst::Create(threadId, geps, |
| geps + 2, "", |
| currentBlock); |
| |
| // Get the Java exception. |
| Value* obj = 0; |
| |
| BasicBlock* ifNormal = createBasicBlock("no exception block"); |
| |
| Value* test = 0; |
| Constant* zero = intrinsics->JavaObjectNullConstant; |
| if (F == intrinsics->InitialisationCheckFunction || |
| F == intrinsics->GetConstantPoolAtFunction || |
| F == intrinsics->GetArrayClassFunction || |
| F == intrinsics->GetClassDelegateeFunction) { |
| obj = new LoadInst(javaExceptionPtr, "", true, currentBlock); |
| test = new BitCastInst(res, intrinsics->JavaObjectType, "", currentBlock); |
| test = new ICmpInst(*currentBlock, ICmpInst::ICMP_EQ, test, obj, ""); |
| Value* T = new ICmpInst(*currentBlock, ICmpInst::ICMP_NE, obj, zero, ""); |
| test = BinaryOperator::CreateAnd(test, T, "", currentBlock); |
| } else { |
| obj = new LoadInst(javaExceptionPtr, "", currentBlock); |
| test = new ICmpInst(*currentBlock, ICmpInst::ICMP_NE, obj, zero, ""); |
| } |
| |
| BranchInst::Create(currentExceptionBlock, ifNormal, test, currentBlock); |
| |
| if (!currentExceptionBlock->empty()) { |
| Instruction* insn = currentExceptionBlock->begin(); |
| PHINode* node = dyn_cast<PHINode>(insn); |
| if (node) node->addIncoming(obj, currentBlock); |
| } |
| |
| currentBlock = ifNormal; |
| } |
| |
| return res; |
| } |
| |
| Instruction* JavaJIT::invoke(Value *F, const char* Name, |
| BasicBlock *InsertAtEnd) { |
| Instruction* res = llvm::CallInst::Create(F, Name, InsertAtEnd); |
| res->setMetadata("dbg", CreateLocation()); |
| |
| if (TheCompiler->hasExceptionsEnabled()) { |
| Value* threadId = getCurrentThread(intrinsics->JavaThreadType); |
| Value* geps[2] = { intrinsics->constantZero, |
| intrinsics->OffsetJavaExceptionInThreadConstant }; |
| |
| Value* javaExceptionPtr = GetElementPtrInst::Create(threadId, geps, |
| geps + 2, "", |
| currentBlock); |
| |
| // Get the Java exception. |
| Value* obj = 0; |
| |
| BasicBlock* ifNormal = createBasicBlock("no exception block"); |
| |
| Value* test = 0; |
| Constant* zero = intrinsics->JavaObjectNullConstant; |
| if (F == intrinsics->InitialisationCheckFunction || |
| F == intrinsics->GetConstantPoolAtFunction || |
| F == intrinsics->GetArrayClassFunction || |
| F == intrinsics->GetClassDelegateeFunction) { |
| obj = new LoadInst(javaExceptionPtr, "", true, currentBlock); |
| test = new BitCastInst(res, intrinsics->JavaObjectType, "", currentBlock); |
| test = new ICmpInst(*currentBlock, ICmpInst::ICMP_EQ, test, obj, ""); |
| Value* T = new ICmpInst(*currentBlock, ICmpInst::ICMP_NE, obj, zero, ""); |
| test = BinaryOperator::CreateAnd(test, T, "", currentBlock); |
| } else { |
| obj = new LoadInst(javaExceptionPtr, "", currentBlock); |
| test = new ICmpInst(*currentBlock, ICmpInst::ICMP_NE, obj, zero, ""); |
| } |
| |
| BranchInst::Create(currentExceptionBlock, ifNormal, test, currentBlock); |
| |
| if (!currentExceptionBlock->empty()) { |
| Instruction* insn = currentExceptionBlock->begin(); |
| PHINode* node = dyn_cast<PHINode>(insn); |
| if (node) node->addIncoming(obj, currentBlock); |
| } |
| |
| currentBlock = ifNormal; |
| } |
| |
| return res; |
| } |
| |
| void JavaJIT::throwException(llvm::Function* F, Value* arg1) { |
| Instruction* obj = CallInst::Create(F, arg1, "", currentBlock); |
| obj->setMetadata("dbg", CreateLocation()); |
| |
| if (currentExceptionBlock != endExceptionBlock) { |
| Instruction* insn = currentExceptionBlock->begin(); |
| PHINode* node = dyn_cast<PHINode>(insn); |
| if (node) node->addIncoming(obj, currentBlock); |
| BranchInst::Create(currentExceptionBlock, currentBlock); |
| } else { |
| if (endNode) { |
| endNode->addIncoming(Constant::getNullValue(endNode->getType()), |
| currentBlock); |
| } |
| BranchInst::Create(endBlock, currentBlock); |
| } |
| } |
| |
| void JavaJIT::throwException(Value* obj) { |
| Value* threadId = getCurrentThread(intrinsics->JavaThreadType); |
| Value* geps[2] = { intrinsics->constantZero, |
| intrinsics->OffsetJavaExceptionInThreadConstant }; |
| |
| Value* javaExceptionPtr = GetElementPtrInst::Create(threadId, geps, |
| geps + 2, "", |
| currentBlock); |
| new StoreInst(obj, javaExceptionPtr, currentBlock); |
| if (currentExceptionBlock != endExceptionBlock) { |
| Instruction* insn = currentExceptionBlock->begin(); |
| PHINode* node = dyn_cast<PHINode>(insn); |
| if (node) node->addIncoming(obj, currentBlock); |
| BranchInst::Create(currentExceptionBlock, currentBlock); |
| } else { |
| if (endNode) { |
| endNode->addIncoming(Constant::getNullValue(endNode->getType()), |
| currentBlock); |
| } |
| BranchInst::Create(endBlock, currentBlock); |
| } |
| } |
| |
| void JavaJIT::throwException(llvm::Function* F, Value** args, |
| uint32 nbArgs) { |
| Instruction* obj = CallInst::Create(F, args, args + nbArgs, "", currentBlock); |
| obj->setMetadata("dbg", CreateLocation()); |
| |
| if (currentExceptionBlock != endExceptionBlock) { |
| Instruction* insn = currentExceptionBlock->begin(); |
| PHINode* node = dyn_cast<PHINode>(insn); |
| if (node) node->addIncoming(obj, currentBlock); |
| BranchInst::Create(currentExceptionBlock, currentBlock); |
| } else { |
| if (endNode) { |
| endNode->addIncoming(Constant::getNullValue(endNode->getType()), |
| currentBlock); |
| } |
| BranchInst::Create(endBlock, currentBlock); |
| } |
| } |
| |
| /// Handler - This class represents an exception handler. It is only needed |
| /// when parsing the .class file in the JIT, therefore it is only defined |
| /// here. The readExceptionTable function is the only function that makes |
| /// use of this class. |
| struct Handler { |
| |
| /// startpc - The bytecode number that begins the try clause. |
| uint32 startpc; |
| |
| /// endpc - The bytecode number that ends the try clause. |
| uint32 endpc; |
| |
| /// handlerpc - The bytecode number where the handler code starts. |
| uint32 handlerpc; |
| |
| /// catche - Index in the constant pool of the exception class. |
| uint16 catche; |
| |
| /// catchClass - The class of the exception: it must always be loaded before |
| /// reading the exception table so that we do not throw an exception |
| /// when compiling. |
| UserClass* catchClass; |
| |
| /// tester - The basic block that tests if the exception is handled by this |
| /// handler. If the handler is not the first of a list of handlers with the |
| /// same range, than this block is the catcher block. Otherwise, it is the |
| /// destination of the catcher block and of the handlers that do not handler |
| /// the exception. |
| llvm::BasicBlock* tester; |
| |
| /// javaHandler - The Java code that handles the exception. At this point, we |
| /// know we have caught and are handling the exception. The Java exception |
| /// object is the PHI node that begins this block. |
| llvm::BasicBlock* javaHandler; |
| |
| }; |
| |
| unsigned JavaJIT::readExceptionTable(Reader& reader, uint32 codeLen) { |
| |
| // This function uses currentBlock to simplify things. We save the current |
| // value of currentBlock to restore it at the end of the function |
| BasicBlock* temp = currentBlock; |
| |
| sint16 nbe = reader.readU2(); |
| sint16 sync = isSynchro(compilingMethod->access) ? 1 : 0; |
| nbe += sync; |
| |
| // Loop over all handlers in the bytecode to initialize their values. |
| Handler* handlers = (Handler*)alloca(sizeof(Handler) * (nbe - sync)); |
| for (uint16 i = 0; i < nbe - sync; ++i) { |
| Handler* ex = &handlers[i]; |
| ex->startpc = reader.readU2(); |
| ex->endpc = reader.readU2(); |
| ex->handlerpc = reader.readU2(); |
| |
| ex->catche = reader.readU2(); |
| |
| #ifndef ISOLATE_SHARING |
| if (ex->catche) { |
| UserClass* cl = |
| (UserClass*)(compilingClass->ctpInfo->isClassLoaded(ex->catche)); |
| // When loading the class, we made sure that all exception classes |
| // were loaded, so cl must have a value. |
| assert(cl && "exception class has not been loaded"); |
| ex->catchClass = cl; |
| } else { |
| ex->catchClass = Classpath::newThrowable; |
| } |
| #endif |
| |
| ex->tester = createBasicBlock("testException"); |
| |
| // PHI Node for the exception object |
| PHINode::Create(intrinsics->JavaObjectType, "", ex->tester); |
| |
| // Set the unwind destination of the instructions in the range of this |
| // handler to the test block of the handler. If an instruction already has |
| // a handler and thus is not the synchronize or regular end handler block, |
| // leave it as-is. |
| for (uint16 i = ex->startpc; i < ex->endpc; ++i) { |
| if (opcodeInfos[i].exceptionBlock == endExceptionBlock) { |
| opcodeInfos[i].exceptionBlock = ex->tester; |
| } |
| } |
| |
| // If the handler pc does not already have a block, create a new one. |
| if (!(opcodeInfos[ex->handlerpc].newBlock)) { |
| opcodeInfos[ex->handlerpc].newBlock = createBasicBlock("javaHandler"); |
| } |
| |
| // Set the Java handler for this exception. |
| ex->javaHandler = opcodeInfos[ex->handlerpc].newBlock; |
| opcodeInfos[ex->handlerpc].handler = true; |
| |
| if (ex->javaHandler->empty()) { |
| PHINode::Create(intrinsics->JavaObjectType, "", ex->javaHandler); |
| } |
| |
| } |
| |
| // Loop over all handlers to implement their tester. |
| for (sint16 i = 0; i < nbe - sync; ++i) { |
| Handler* cur = &handlers[i]; |
| BasicBlock* bbNext = 0; |
| PHINode* javaNode = 0; |
| currentExceptionBlock = opcodeInfos[cur->handlerpc].exceptionBlock; |
| |
| // Look out where we go if we're not the handler for the exception. |
| if (i + 1 != nbe - sync) { |
| Handler* next = &handlers[i + 1]; |
| if (!(cur->startpc >= next->startpc && cur->endpc <= next->endpc)) { |
| // If there is no handler to go to (either one that has the same range |
| // or one that contains the range), then we jump to the end handler. |
| bbNext = endExceptionBlock; |
| } else { |
| // If there's a handler to goto, we jump to its tester block and record |
| // the exception PHI node to give our exception to the tester. |
| bbNext = next->tester; |
| javaNode = dyn_cast<PHINode>(bbNext->begin()); |
| assert(javaNode); |
| } |
| } else { |
| // If there's no handler after us, we jump to the end handler. |
| bbNext = endExceptionBlock; |
| } |
| |
| currentBlock = cur->tester; |
| |
| assert(cur->catchClass && |
| "Class not loaded when reading the exception table"); |
| |
| Value* VTVar = TheCompiler->getVirtualTable(cur->catchClass->virtualVT); |
| |
| |
| #ifdef SERVICE |
| // Verifies that the current isolate is not stopped. If it is, we don't |
| // catch the exception but resume unwinding. |
| JnjvmClassLoader* loader = compilingClass->classLoader;; |
| if (loader != loader->bootstrapLoader) { |
| Value* threadId = getCurrentThread(intrinsics->MutatorThreadType); |
| Value* Isolate = GetElementPtrInst::Create(threadId, |
| intrinsics->constantFour, "", |
| currentBlock); |
| |
| Isolate = new LoadInst(Isolate, "", currentBlock); |
| Isolate = new BitCastInst(Isolate, intrinsics->ptrPtrType, "", currentBlock); |
| Value* Status = GetElementPtrInst::Create(Isolate, intrinsics->constantOne, "", |
| currentBlock); |
| Status = new LoadInst(Status, "", currentBlock); |
| Status = new PtrToIntInst(Status, Type::Int32Ty, "", currentBlock); |
| |
| Value* stopping = new ICmpInst(*currentBlock, ICmpInst::ICMP_EQ, Status, |
| intrinsics->constantOne, ""); |
| |
| BasicBlock* raiseBlock = createBasicBlock("raiseBlock"); |
| BasicBlock* continueBlock = createBasicBlock("continueBlock"); |
| BranchInst::Create(raiseBlock, continueBlock, stopping, currentBlock); |
| currentBlock = raiseBlock; |
| BranchInst::Create(endExceptionBlock, currentBlock); |
| |
| currentBlock = continueBlock; |
| } |
| #endif |
| |
| // Get the Java exception. |
| Value* obj = currentBlock->begin(); |
| |
| Value* objVT = CallInst::Create(intrinsics->GetVTFunction, obj, "", |
| currentBlock); |
| |
| uint32 depth = cur->catchClass->virtualVT->depth; |
| Value* depthCl = ConstantInt::get(Type::getInt32Ty(*llvmContext), depth); |
| Value* cmp = 0; |
| |
| if (depth >= JavaVirtualTable::getDisplayLength()) { |
| Value* classArgs[2] = { objVT, VTVar }; |
| |
| cmp = CallInst::Create(intrinsics->IsSecondaryClassFunction, |
| classArgs, classArgs + 2, "", |
| currentBlock); |
| |
| } else { |
| |
| Value* inDisplay = CallInst::Create(intrinsics->GetDisplayFunction, |
| objVT, "", currentBlock); |
| |
| Value* displayArgs[2] = { inDisplay, depthCl }; |
| Value* VTInDisplay = CallInst::Create(intrinsics->GetVTInDisplayFunction, |
| displayArgs, displayArgs + 2, "", |
| currentBlock); |
| |
| cmp = new ICmpInst(*currentBlock, ICmpInst::ICMP_EQ, VTInDisplay, VTVar, |
| ""); |
| } |
| |
| // Add the Java exception in the phi node of the handler. |
| Instruction* insn = cur->javaHandler->begin(); |
| PHINode* node = dyn_cast<PHINode>(insn); |
| assert(node && "malformed exceptions"); |
| node->addIncoming(obj, currentBlock); |
| |
| // Add the Java exception in the phi node of the next block. |
| if (javaNode) |
| javaNode->addIncoming(obj, currentBlock); |
| |
| // If we are catching this exception, then jump to the Java Handler, |
| // otherwise jump to our next handler. |
| BranchInst::Create(cur->javaHandler, bbNext, cmp, currentBlock); |
| |
| currentBlock = cur->javaHandler; |
| |
| // First thing in the handler: clear the exception. |
| Value* geps[2] = { intrinsics->constantZero, |
| intrinsics->OffsetJavaExceptionInThreadConstant }; |
| Value* threadId = getCurrentThread(intrinsics->JavaThreadType); |
| Value* javaExceptionPtr = GetElementPtrInst::Create(threadId, geps, |
| geps + 2, "", |
| currentBlock); |
| |
| // Clear exceptions. |
| new StoreInst(intrinsics->JavaObjectNullConstant, javaExceptionPtr, |
| currentBlock); |
| |
| #if defined(SERVICE) |
| |
| // Change the isolate we are currently running, now that we have catched |
| // the exception: the exception may have been thrown by another isolate. |
| Value* threadId = 0; |
| Value* OldIsolateID = 0; |
| Value* IsolateIDPtr = 0; |
| Value* OldIsolate = 0; |
| Value* NewIsolate = 0; |
| Value* IsolatePtr = 0; |
| currentBlock = cur->javaHandler; |
| if (loader != loader->bootstrapLoader) { |
| threadId = getCurrentThread(intrinsics->MutatorThreadType); |
| |
| IsolateIDPtr = GetElementPtrInst::Create(threadId, intrinsics->constantThree, |
| "", cur->javaHandler); |
| const Type* realType = PointerType::getUnqual(intrinsics->pointerSizeType); |
| IsolateIDPtr = new BitCastInst(IsolateIDPtr, realType, "", |
| cur->javaHandler); |
| OldIsolateID = new LoadInst(IsolateIDPtr, "", cur->javaHandler); |
| |
| Value* MyID = ConstantInt::get(intrinsics->pointerSizeType, |
| loader->getIsolate()->IsolateID); |
| |
| new StoreInst(MyID, IsolateIDPtr, cur->javaHandler); |
| IsolatePtr = GetElementPtrInst::Create(threadId, intrinsics->constantFour, "", |
| cur->javaHandler); |
| |
| OldIsolate = new LoadInst(IsolatePtr, "", cur->javaHandler); |
| NewIsolate = intrinsics->getIsolate(loader->getIsolate(), currentBlock); |
| new StoreInst(NewIsolate, IsolatePtr, cur->javaHandler); |
| |
| } |
| #endif |
| |
| } |
| |
| // Restore currentBlock. |
| currentBlock = temp; |
| return nbe; |
| |
| } |
| |
| void JavaJIT::finishExceptions() { |
| pred_iterator PI = pred_begin(endExceptionBlock); |
| pred_iterator PE = pred_end(endExceptionBlock); |
| if (PI == PE) { |
| endExceptionBlock->eraseFromParent(); |
| } else { |
| if (endNode) { |
| endNode->addIncoming(Constant::getNullValue(endNode->getType()), |
| endExceptionBlock); |
| } |
| BranchInst::Create(endBlock, endExceptionBlock); |
| } |
| |
| |
| PI = pred_begin(unifiedUnreachable); |
| PE = pred_end(unifiedUnreachable); |
| if (PI == PE) { |
| unifiedUnreachable->eraseFromParent(); |
| } else { |
| new UnreachableInst(*llvmContext, unifiedUnreachable); |
| } |
| |
| for (Function::iterator BI = llvmFunction->begin(), BE = llvmFunction->end(); |
| BI != BE; BI++) { |
| PI = pred_begin(BI); |
| PE = pred_end(BI); |
| if (PI == PE) { |
| Instruction* insn = BI->begin(); |
| PHINode* node = dyn_cast<PHINode>(insn); |
| if (node) { |
| node->replaceAllUsesWith(Constant::getNullValue(node->getType())); |
| node->eraseFromParent(); |
| } |
| } |
| } |
| |
| } |
