#include #include "j3/j3.h" #include "j3/j3thread.h" #include "j3/j3reader.h" #include "j3/j3codegen.h" #include "j3/j3class.h" #include "j3/j3constants.h" #include "j3/j3classloader.h" #include "j3/j3method.h" #include "j3/j3mangler.h" #include "j3/j3jni.h" #include "j3/j3object.h" #include "j3/j3field.h" #include "j3/j3attribute.h" #include "llvm/ExecutionEngine/ExecutionEngine.h" #include "llvm/IR/Function.h" #include "llvm/IR/Module.h" #include "llvm/IR/Argument.h" #include "llvm/IR/Intrinsics.h" #include "llvm/Transforms/Utils/Cloning.h" #include "llvm/Support/CallSite.h" #include "llvm/DebugInfo.h" #include "llvm/DIBuilder.h" using namespace j3; #define _onEndPoint() ({ if(onEndPoint()) return; }) J3CodeGen::J3CodeGen(vmkit::BumpAllocator* _allocator, J3Method* m, uint32_t _mode) : builder(J3Thread::get()->vm()->llvmContext()), exceptions(this) { allocator = _allocator; mode = _mode; method = m; cl = method->cl()->asClass(); signature = method->signature(); loader = cl->loader(); vm = J3Thread::get()->vm(); access = method->access(); #if 0 /* usefull to debug a single function */ if( cl->name() == vm->names()->get("java.lang.Class") && method->name() == vm->names()->get("asSubclass") && method->signature()->name() == vm->names()->get("(IIILsun/util/calendar/BaseCalendar$Date;)J") ) { vm->options()->genDebugExecute = 2; vm->options()->debugTranslate = 3; vm->options()->debugExecute = 5; } else { vm->options()->genDebugExecute = 0; vm->options()->debugTranslate = 0; //vm->options()->debugExecute = 0; } #endif if(vm->options()->debugTranslate) fprintf(stderr, " translating bytecode of: %s::%s%s\n", cl->name()->cStr(), method->name()->cStr(), method->signature()->name()->cStr()); llvmFunction = method->llvmFunction(); module = llvmFunction ? llvmFunction->getParent() : new llvm::Module(method->llvmFunctionName(), builder.getContext()); bbCheckCastFailed = 0; bbNullCheckFailed = 0; topPendingBranchs = 0; isWide = 0; uintPtrTy = vm->dataLayout()->getIntPtrType(module->getContext()); nullValue = llvm::ConstantPointerNull::get((llvm::PointerType*)vm->typeJ3ObjectPtr); #define _x(name, id, forceInline) \ name = vm->introspectFunction(module, id); #include "j3/j3meta.def" #undef _x gvTypeInfo = vm->introspectGlobalValue(module, "typeinfo for void*"); gcRoot = vm->getGCRoot(module); #if 0 //stackMap = llvm::Intrinsic::getDeclaration(module, llvm::Intrinsic::experimental_stackmap); //patchPointVoid = llvm::Intrinsic::getDeclaration(module, llvm::Intrinsic::experimental_patchpoint_i64); { llvm::Type* ins[] = { builder.getInt64Ty(), builder.getInt32Ty(), builder.getInt8PtrTy(), builder.getInt32Ty() }; patchPointVoid = (llvm::Function*) module->getOrInsertFunction(llvm::Intrinsic::getName(llvm::Intrinsic::experimental_patchpoint_void), llvm::FunctionType::get(builder.getVoidTy(), ins, 1)); } #endif /* only translate of requested and not already translated */ if(withMethod() && !llvmFunction) { llvmFunction = buildFunction(method, 0); if(needGC()) llvmFunction->setGC("vmkit"); if(J3Cst::isNative(access)) generateNative(); else generateJava(); if(vm->options()->debugTranslate > 2) llvmFunction->dump(); } loader->prepareModule(module); uint32_t needsCaller = withCaller() && !signature->caller(access); if(needsCaller) signature->generateCallerIR(access, this, module, "generic-caller"); /* compile only if requested and not already compiled */ void* fnPtr; if(withMethod() && !onlyTranslate() && !method->fnPtr()) { loader->compileModule(module); fnPtr = (void*)loader->ee()->getFunctionAddress(llvmFunction->getName().data()); } else fnPtr = method->fnPtr(); if(needsCaller) signature->setCaller(access, (J3Signature::function_t)loader->ee()->getFunctionAddress("generic-caller")); method->markCompiled(llvmFunction, fnPtr); if(vm->options()->debugTranslate > 2) llvmFunction->dump(); } J3CodeGen::~J3CodeGen() { } void* J3CodeGen::operator new(size_t n, vmkit::BumpAllocator* _allocator) { return _allocator->allocate(n); } void J3CodeGen::operator delete(void* ptr) { } void J3CodeGen::translate(J3Method* method, uint32_t mode) { J3Thread::get()->vm()->lockCompiler(); vmkit::BumpAllocator* allocator = vmkit::BumpAllocator::create(); delete new(allocator) J3CodeGen(allocator, method, mode); vmkit::BumpAllocator::destroy(allocator); J3Thread::get()->vm()->unlockCompiler(); } uint32_t J3CodeGen::wideReadU1() { if(isWide) { isWide = 0; return codeReader->readU2(); } else return codeReader->readU1(); } uint32_t J3CodeGen::wideReadS1() { if(isWide) { isWide = 0; return codeReader->readS2(); } else return codeReader->readS1(); } llvm::Value* J3CodeGen::flatten(llvm::Value* v) { llvm::Type* type = v->getType(); if(type == vm->typeInteger->llvmType() || type == vm->typeLong->llvmType() || type == vm->typeFloat->llvmType() || type == vm->typeDouble->llvmType() || (type->isPointerTy() && (v->getType() == vm->typeJ3ObjectPtr))) return v; else if(type == vm->typeBoolean->llvmType() || type == vm->typeByte->llvmType() || type == vm->typeShort->llvmType()) return builder.CreateSExt(v, vm->typeInteger->llvmType()); else if(type == vm->typeCharacter->llvmType()) return builder.CreateZExt(v, vm->typeInteger->llvmType()); fprintf(stderr, " v: "); v->getType()->dump(); fprintf(stderr, "\n type: "); type->dump(); fprintf(stderr, "\n"); J3::internalError("should not happen"); } llvm::Value* J3CodeGen::unflatten(llvm::Value* v, llvm::Type* type) { if(type == vm->typeInteger->llvmType() || type == vm->typeLong->llvmType() || type == vm->typeFloat->llvmType() || type == vm->typeDouble->llvmType() || (type->isPointerTy() && type == v->getType())) return v; else if(type == vm->typeBoolean->llvmType() || type == vm->typeByte->llvmType() || type == vm->typeShort->llvmType()) return builder.CreateSExtOrTrunc(v, type); else if(type == vm->typeCharacter->llvmType()) return builder.CreateZExtOrTrunc(v, type); fprintf(stderr, " v: "); v->getType()->dump(); fprintf(stderr, "\n type: "); type->dump(); fprintf(stderr, "\n"); J3::internalError("should not happen"); } llvm::Function* J3CodeGen::buildFunction(J3Method* method, bool isStub) { const char* id = (useStub() && isStub && !method->fnPtr()) ? method->llvmStubName(cl) : method->llvmFunctionName(cl); loader->addSymbol(id, method); return (llvm::Function*)module->getOrInsertFunction(id, method->signature()->functionType(method->access())); } llvm::Value* J3CodeGen::typeDescriptor(J3ObjectType* objectType, llvm::Type* type) { const char* id = objectType->nativeName(); loader->addSymbol(id, objectType); llvm::Value* v = module->getOrInsertGlobal(id, vm->typeJ3ObjectType); return type == vm->typeJ3ObjectTypePtr ? v : builder.CreateBitCast(v, type); } llvm::Value* J3CodeGen::currentThread() { return builder.CreateCall(funcJ3ThreadGet); } void J3CodeGen::monitorEnter(llvm::Value* obj) { builder.CreateCall2(funcJ3ObjectMonitorEnter, obj, builder.CreateAlloca(vm->typeJ3LockRecord)); } void J3CodeGen::monitorExit(llvm::Value* obj) { builder.CreateCall(funcJ3ObjectMonitorExit, obj); } void J3CodeGen::resolveJ3ObjectType(J3ObjectType* cl) { if(!supposeClinited() && !cl->isResolved()) builder.CreateCall(funcJ3ObjectTypeResolve, typeDescriptor(cl, vm->typeJ3TypePtr)); } void J3CodeGen::initialiseJ3ObjectType(J3ObjectType* cl) { if(!supposeClinited() && !cl->isInitialised()) builder.CreateCall(funcJ3ObjectTypeInitialise, typeDescriptor(cl, vm->typeJ3TypePtr)); } llvm::Value* J3CodeGen::javaClass(J3ObjectType* type, bool doPush) { return builder.CreateCall3(funcJ3TypeJavaClass, typeDescriptor(type, vm->typeJ3TypePtr), builder.getInt1(doPush), builder.CreateIntToPtr(llvm::ConstantInt::get(uintPtrTy, (uintptr_t)0), vm->typeJ3ObjectHandlePtr)); } llvm::Value* J3CodeGen::handleToObject(llvm::Value* obj) { llvm::Value* gep[] = { builder.getInt32(0), builder.getInt32(J3ObjectHandle::gepObj) }; return builder.CreateLoad(builder.CreateGEP(obj, gep)); } llvm::Value* J3CodeGen::staticObject(J3Class* cl) { initialiseJ3ObjectType(cl); const char* id = cl->staticObjectId(); loader->addSymbol(id, cl->staticObjectSymbol()); return handleToObject(module->getOrInsertGlobal(id, vm->typeJ3ObjectHandle)); } llvm::Value* J3CodeGen::vt(llvm::Value* obj) { llvm::Value* gepVT[] = { builder.getInt32(0), builder.getInt32(J3Object::gepVT) }; llvm::Instruction* res = builder.CreateLoad(builder.CreateGEP(obj, gepVT)); res->setDebugLoc(llvm::DebugLoc::get(javaPC, 1, dbgInfo)); return res; } llvm::Value* J3CodeGen::vt(J3ObjectType* type) { type->resolve(); const char* id = type->vtId(); loader->addSymbol(id, type->vtSymbol()); return module->getOrInsertGlobal(id, vm->typeJ3VirtualTable); } llvm::Value* J3CodeGen::nullCheck(llvm::Value* obj) { if(!noRuntimeCheck() && exceptions.nodes[curExceptionNode]->landingPad) { llvm::BasicBlock* succeed = newBB("nullcheck-succeed"); if(!bbNullCheckFailed) { llvm::BasicBlock* prev = builder.GetInsertBlock(); bbNullCheckFailed = newBB("nullcheck-failed"); builder.SetInsertPoint(bbNullCheckFailed); builder.CreateInvoke(funcNullPointerException, bbRet, exceptions.nodes[curExceptionNode]->landingPad); builder.SetInsertPoint(prev); } builder.CreateCondBr(builder.CreateIsNotNull(obj), succeed, bbNullCheckFailed); builder.SetInsertPoint(succeed); } return obj; } #define nyi() J3::internalError("not yet implemented: '%s' (%d)", J3Cst::opcodeNames[bc], bc); void J3CodeGen::invoke(uint32_t access, J3Method* target, llvm::Value* func) { J3Signature* type = target->signature(); llvm::FunctionType* fType = target->signature()->functionType(access); uint32_t n = fType->getNumParams(); std::vector args; uint32_t i=n-1; for(llvm::FunctionType::param_iterator it=fType->param_begin(); it!=fType->param_end(); it++) args.push_back(unflatten(stack.top(i--), *it)); stack.drop(n); llvm::Instruction* res; if(exceptions.nodes[curExceptionNode]->landingPad) { //llvm::BasicBlock* after = forwardBranch("invoke-after", codeReader->tell(), 0, 0); llvm::BasicBlock* after = newBB("invoke-after"); res = builder.CreateInvoke(func, after, exceptions.nodes[curExceptionNode]->landingPad, args); builder.SetInsertPoint(after); } else { res = builder.CreateCall(func, args); } res->setDebugLoc(llvm::DebugLoc::get(javaPC, 0, dbgInfo)); if(!res->getType()->isVoidTy()) stack.push(flatten(res)); } void J3CodeGen::invokeInterface(uint32_t idx) { J3Method* target = cl->interfaceMethodAt(idx, 0); J3Signature* type = target->signature(); uint32_t index = target->interfaceIndex(); llvm::Value* thread = currentThread(); llvm::Value* gep[] = { builder.getInt32(0), builder.getInt32(J3Thread::gepInterfaceMethodIndex) }; builder.CreateStore(builder.getInt32(index), builder.CreateGEP(thread, gep)); llvm::Value* obj = nullCheck(stack.top(type->nbIns())); llvm::Value* gepFunc[] = { builder.getInt32(0), builder.getInt32(J3VirtualTable::gepInterfaceMethods), builder.getInt32(index % J3VirtualTable::nbInterfaceMethodTable) }; llvm::Value* func = builder.CreateBitCast(builder.CreateLoad(builder.CreateGEP(vt(obj), gepFunc)), target->signature()->functionType(target->access())->getPointerTo()); invoke(0, target, func); } void J3CodeGen::invokeVirtual(uint32_t idx) { J3Method* target = cl->methodAt(idx, 0); if(J3Cst::isFinal(target->cl()->access()) || J3Cst::isFinal(target->cl()->access())) invoke(0, target, buildFunction(target)); /* do not remove this optimization, mandatory for mmtk */ else { J3Signature* type = target->signature(); llvm::Value* funcEntry = funcEntry = builder.getInt32(target->index()); llvm::Value* obj = nullCheck(stack.top(type->nbIns())); llvm::Value* gepFunc[] = { builder.getInt32(0), builder.getInt32(J3VirtualTable::gepVirtualMethods), funcEntry }; llvm::Value* func = builder.CreateBitCast(builder.CreateLoad(builder.CreateGEP(vt(obj), gepFunc)), target->signature()->functionType(target->access())->getPointerTo()); invoke(0, target, func); } } void J3CodeGen::invokeStatic(uint32_t idx) { J3Method* target = cl->methodAt(idx, J3Cst::ACC_STATIC); invoke(J3Cst::ACC_STATIC, target, buildFunction(target)); } void J3CodeGen::invokeSpecial(uint32_t idx) { J3Method* target = cl->methodAt(idx, 0); invoke(0, target, buildFunction(target)); } llvm::Value* J3CodeGen::fieldOffset(llvm::Value* obj, J3Field* f) { return builder.CreateIntToPtr(builder.CreateAdd(builder.CreatePtrToInt(obj, uintPtrTy), llvm::ConstantInt::get(uintPtrTy, f->offset())), f->type()->llvmType()->getPointerTo()); } void J3CodeGen::get(llvm::Value* src, J3Field* f) { llvm::Value* res = flatten(builder.CreateLoad(fieldOffset(src, f))); stack.push(res); } void J3CodeGen::getField(uint32_t idx) { llvm::Value* obj = stack.pop(); J3Field* f = cl->fieldAt(idx, 0); get(nullCheck(obj), f); } void J3CodeGen::getStatic(uint32_t idx) { J3Field* f = cl->fieldAt(idx, J3Cst::ACC_STATIC); get(staticObject(f->layout()->asStaticLayout()->cl()), f); } void J3CodeGen::put(llvm::Value* dest, llvm::Value* val, J3Field* f) { builder.CreateStore(unflatten(val, f->type()->llvmType()), fieldOffset(dest, f)); } void J3CodeGen::putStatic(uint32_t idx) { J3Field* f = cl->fieldAt(idx, J3Cst::ACC_STATIC); put(staticObject(f->layout()->asStaticLayout()->cl()), stack.pop(), f); } void J3CodeGen::putField(uint32_t idx) { J3Field* f = cl->fieldAt(idx, 0); llvm::Value* val = stack.pop(); llvm::Value* obj = nullCheck(stack.pop()); put(obj, val, f); } void J3CodeGen::arrayBoundCheck(llvm::Value* obj, llvm::Value* idx) { if(!noRuntimeCheck()) { /* implement me */ } } llvm::Value* J3CodeGen::arrayContent(J3Type* cType, llvm::Value* array, llvm::Value* idx) { array = builder.CreateBitCast(array, vm->typeJ3ArrayObjectPtr); return builder.CreateGEP(builder.CreateBitCast(builder.CreateGEP(array, builder.getInt32(1)), cType->llvmType()->getPointerTo()), idx); } void J3CodeGen::arrayStore(J3Type* cType) { llvm::Value* val = stack.pop(); llvm::Value* idx = stack.pop(); llvm::Value* array = stack.pop(); arrayBoundCheck(array, idx); builder.CreateStore(unflatten(val, cType->llvmType()), arrayContent(cType, array, idx)); } void J3CodeGen::arrayLoad(J3Type* cType) { llvm::Value* idx = stack.pop(); llvm::Value* array = stack.pop(); arrayBoundCheck(array, idx); stack.push(flatten(builder.CreateLoad(arrayContent(cType, array, idx)))); } llvm::Value* J3CodeGen::arrayLengthPtr(llvm::Value* obj) { llvm::Value* gep[2] = { builder.getInt32(0), builder.getInt32(J3ArrayObject::gepLength) }; return builder.CreateGEP(builder.CreateBitCast(obj, vm->typeJ3ArrayObjectPtr), gep); } llvm::Value* J3CodeGen::arrayLength(llvm::Value* obj) { return builder.CreateLoad(arrayLengthPtr(obj)); } void J3CodeGen::newArray(J3ArrayClass* array) { initialiseJ3ObjectType(array); llvm::Value* length = stack.pop(); llvm::Value* nbb = builder.CreateAdd(llvm::ConstantInt::get(uintPtrTy, sizeof(J3ArrayObject)), builder.CreateMul(llvm::ConstantInt::get(uintPtrTy, 1 << array->component()->logSize()), builder.CreateZExtOrBitCast(length, uintPtrTy))); llvm::Value* res = builder.CreateCall2(funcJ3ObjectAllocate, vt(array), nbb); builder.CreateStore(length, arrayLengthPtr(res)); stack.push(res); } void J3CodeGen::newArray(uint8_t atype) { J3Primitive* prim = 0; switch(atype) { case J3Cst::T_BOOLEAN: prim = vm->typeBoolean; break; case J3Cst::T_CHAR: prim = vm->typeCharacter; break; case J3Cst::T_FLOAT: prim = vm->typeFloat; break; case J3Cst::T_DOUBLE: prim = vm->typeDouble; break; case J3Cst::T_BYTE: prim = vm->typeByte; break; case J3Cst::T_SHORT: prim = vm->typeShort; break; case J3Cst::T_INT: prim = vm->typeInteger; break; case J3Cst::T_LONG: prim = vm->typeLong; break; default: J3::classFormatError(cl, "wrong atype: %d\n", atype); } newArray(prim->getArray()); } void J3CodeGen::multianewArray() { J3ObjectType* base = cl->classAt(codeReader->readU2()); uint32_t dim = codeReader->readU1(); llvm::Value* values = builder.CreateAlloca(builder.getInt32Ty(), builder.getInt32(dim)); for(uint32_t i=0; itypeJ3ArrayClassPtr), builder.getInt32(dim), values)); } void J3CodeGen::newObject(J3Class* cl) { initialiseJ3ObjectType(cl); llvm::Value* size; cl->resolve(); size = builder.getInt64(cl->structSize()); llvm::Value* res = builder.CreateCall2(funcJ3ObjectAllocate, vt(cl), size); stack.push(res); } llvm::CallInst* J3CodeGen::isAssignableTo(llvm::Value* obj, J3ObjectType* type) { llvm::Value* vtType = vt(type); /* force the type resolution */ llvm::Value* vtObj = vt(obj); if(type->vt()->isPrimaryChecker()) return builder.CreateCall3(funcFastIsAssignableToPrimaryChecker, vtObj, vtType, builder.getInt32(type->vt()->offset())); else return builder.CreateCall2(funcFastIsAssignableToNonPrimaryChecker, vtObj, vtType); } void J3CodeGen::instanceof(llvm::Value* obj, J3ObjectType* type) { llvm::BasicBlock* after = forwardBranch("instanceof-after", codeReader->tell(), 0, 0); llvm::BasicBlock* nok = newBB("instanceof-null"); llvm::BasicBlock* test = newBB("instanceof"); builder.CreateCondBr(builder.CreateIsNull(obj), nok, test); builder.SetInsertPoint(nok); stack.push(builder.getInt32(0)); builder.CreateBr(after); stack.drop(1); builder.SetInsertPoint(test); llvm::CallInst* is = isAssignableTo(obj, type); stack.push(builder.CreateZExt(is, builder.getInt32Ty())); builder.CreateBr(after); } void J3CodeGen::checkCast(llvm::Value* obj, J3ObjectType* type) { if(!noRuntimeCheck()) { llvm::BasicBlock* succeed = forwardBranch("checkcast-succeed", codeReader->tell(), 0, 0); llvm::BasicBlock* test = newBB("checkcast"); builder.CreateCondBr(builder.CreateIsNull(obj), succeed, test); if(!bbCheckCastFailed) { bbCheckCastFailed = newBB("checkcast-failed"); builder.SetInsertPoint(bbCheckCastFailed); builder.CreateCall(funcClassCastException); builder.CreateBr(bbRet); } builder.SetInsertPoint(test); llvm::CallInst* is = isAssignableTo(obj, type); builder.CreateCondBr(is, succeed, bbCheckCastFailed); } } void J3CodeGen::floatToInteger(J3Type* ftype, J3Type* itype) { llvm::Value* min = llvm::ConstantFP::get(ftype->llvmType(), llvm::APInt::getSignedMinValue(itype->llvmType()->getPrimitiveSizeInBits()).getSExtValue()); llvm::Value* max = llvm::ConstantFP::get(ftype->llvmType(), llvm::APInt::getSignedMaxValue(itype->llvmType()->getPrimitiveSizeInBits()).getZExtValue()); llvm::Value* v = stack.pop(); llvm::Value* c = builder.CreateFCmpONE(v, v); v = builder.CreateSelect(c, llvm::ConstantFP::get(ftype->llvmType(), 0), v); /* nan => 0 */ c = builder.CreateFCmpOGE(v, max); v = builder.CreateSelect(c, max, v); c = builder.CreateFCmpOLE(v, min); v = builder.CreateSelect(c, min, v); stack.push(builder.CreateFPToSI(v, itype->llvmType())); } void J3CodeGen::compareLong() { llvm::Value* val2 = stack.pop(); llvm::Value* val1 = stack.pop(); llvm::Value* one = builder.getInt32(1); llvm::Value* zero = builder.getInt32(0); llvm::Value* minus = builder.getInt32(-1); llvm::Value* c = builder.CreateICmpSGT(val1, val2); llvm::Value* r = builder.CreateSelect(c, one, zero); c = builder.CreateICmpSLT(val1, val2); r = builder.CreateSelect(c, minus, r); stack.push(r); } void J3CodeGen::compareFP(bool isL) { llvm::Value* val2 = stack.pop(); llvm::Value* val1 = stack.pop(); llvm::Value* one = builder.getInt32(1); llvm::Value* zero = builder.getInt32(0); llvm::Value* minus = builder.getInt32(-1); llvm::Value* c = builder.CreateFCmpUGT(val1, val2); llvm::Value* r = builder.CreateSelect(c, one, zero); c = builder.CreateFCmpULT(val1, val2); r = builder.CreateSelect(c, minus, r); c = builder.CreateFCmpUNO(val1, val2); r = builder.CreateSelect(c, isL ? one : minus, r); stack.push(r); } void J3CodeGen::ldc(uint32_t idx) { llvm::Value* res; switch(cl->getCtpType(idx)) { case J3Cst::CONSTANT_Long: res = builder.getInt64(cl->longAt(idx)); break; case J3Cst::CONSTANT_Integer: res = builder.getInt32(cl->integerAt(idx)); break; case J3Cst::CONSTANT_Float: res = llvm::ConstantFP::get(builder.getFloatTy(), cl->floatAt(idx)); break; case J3Cst::CONSTANT_Double: res = llvm::ConstantFP::get(builder.getDoubleTy(), cl->doubleAt(idx)); break; case J3Cst::CONSTANT_Class: res = handleToObject(javaClass(cl->classAt(idx), 0)); break; case J3Cst::CONSTANT_String: res = handleToObject(builder.CreateLoad(module->getOrInsertGlobal(cl->stringAt(idx)->id(), vm->typeJ3ObjectHandlePtr))); break; default: J3::classFormatError(cl, "wrong ldc type: %d\n", cl->getCtpType(idx)); } stack.push(res); } void J3CodeGen::lookupSwitch() { codeReader->seek(((codeReader->tell() - 1) & -4) + 4, J3Reader::SeekSet); llvm::Value* val = stack.pop(); llvm::BasicBlock* def = forwardBranch("lookupswitch-default", javaPC + codeReader->readU4(), 1, 1); uint32_t n = codeReader->readU4(); for(uint32_t i=0; ireadS4(); llvm::BasicBlock* ok = forwardBranch("lookupswitch-match", javaPC + codeReader->readS4(), 1, 1); llvm::BasicBlock* nok = i == (n - 1) ? def : newBB("lookupswitch-next"); builder.CreateCondBr(builder.CreateICmpEQ(val, builder.getInt32(match)), ok, nok); builder.SetInsertPoint(nok); } } void J3CodeGen::tableSwitch() { codeReader->seek(((codeReader->tell() - 1) & -4) + 4, J3Reader::SeekSet); llvm::Value* val = stack.pop(); llvm::BasicBlock* def = forwardBranch("tableswitch-default", javaPC + codeReader->readU4(), 1, 1); int32_t low = codeReader->readU4(); int32_t high = codeReader->readU4(); llvm::SwitchInst* dispatch = builder.CreateSwitch(val, def, high - low + 1); for(uint32_t i=low; i<=high; i++) dispatch->addCase(builder.getInt32(i), forwardBranch("tableswitch-match", javaPC + codeReader->readU4(), 1, 1)); } llvm::BasicBlock* J3CodeGen::newBB(const char* name) { return llvm::BasicBlock::Create(llvmFunction->getContext(), name, llvmFunction); } void J3CodeGen::condBr(llvm::Value* op) { builder.CreateCondBr(op, forwardBranch("if-true", javaPC + codeReader->readS2(), 1, 1), forwardBranch("if-false", codeReader->tell(), 0, 0)); } llvm::BasicBlock* J3CodeGen::forwardBranch(const char* id, uint32_t pc, bool doAlloc, bool doPush) { llvm::BasicBlock* res = opInfos[pc].bb; if(res) return res; if(vm->options()->debugTranslate > 2) fprintf(stderr, " forward branch at %d\n", pc); if(opInfos[pc].insn) { //printf("split at %d (%s)\n", pc, id); llvm::Instruction* insn = opInfos[pc].insn; if(!insn) J3::classFormatError(cl, "jmp: not to an instruction"); insn = insn->getNextNode(); //fprintf(stderr, "--- instruction ---\n"); //insn->dump(); llvm::BasicBlock* before = insn->getParent(); llvm::BranchInst* fakeTerminator = 0; bool isSelf = builder.GetInsertBlock() == before; //fprintf(stderr, "--- before split ---\n"); //before->dump(); if(!before->getTerminator()) fakeTerminator = llvm::BranchInst::Create(bbRet, before); llvm::BasicBlock* after = before->splitBasicBlock(insn); if(fakeTerminator) fakeTerminator->eraseFromParent(); if(isSelf) builder.SetInsertPoint(after); //fprintf(stderr, "--- after split ---\n"); //before->dump(); //after->dump(); opInfos[pc].bb = after; return after; } else { llvm::BasicBlock* res = newBB(id); if(doAlloc) { opInfos[pc].metaStack = (llvm::Type**)allocator->allocate(sizeof(llvm::Type*)*stack.maxStack); memcpy(opInfos[pc].metaStack, stack.metaStack, sizeof(llvm::Type*)*stack.topStack); } opInfos[pc].bb = res; opInfos[pc].topStack = stack.topStack; if(doPush) pendingBranchs[topPendingBranchs++] = pc; return res; } } bool J3CodeGen::onEndPoint() { uint32_t pc; do { if(!topPendingBranchs) return 1; pc = pendingBranchs[--topPendingBranchs]; } while(opInfos[pc].insn); closeBB = 0; codeReader->seek(pc, codeReader->SeekSet); return 0; } void J3CodeGen::selectExceptionNode(uint32_t idx) { curExceptionNode = idx; if(!exceptions.nodes[idx]->isAdded) { exceptions.nodes[idx]->isAdded = 1; for(uint32_t i=0; inbEntries; i++) { J3ExceptionEntry* e = exceptions.nodes[idx]->entries[i]; if(!e->isAdded) { e->isAdded = 1; pendingBranchs[topPendingBranchs++] = e->handlerPC; } } } } llvm::Value* J3CodeGen::buildString(const char* msg) { std::vector elmts; uint32_t n; for(n=0; msg[n]; n++) elmts.push_back(builder.getInt8(msg[n])); elmts.push_back(builder.getInt8(0)); llvm::Constant* str = llvm::ConstantArray::get(llvm::ArrayType::get(builder.getInt8Ty(), n+1), elmts); llvm::Value* var = new llvm::GlobalVariable(*module, str->getType(), 1, llvm::GlobalVariable::InternalLinkage, str); llvm::Value* gep[] = { builder.getInt32(0), builder.getInt32(0) }; return builder.CreateGEP(var, gep); } void J3CodeGen::translate() { if(vm->options()->debugTranslate > 1) exceptions.dump(vm->options()->debugTranslate-1); stack.topStack = 0; _onEndPoint(); closeBB = 1; selectExceptionNode(0); while(codeReader->remaining()) { llvm::Value* val1; llvm::Value* val2; llvm::Value* val3; javaPC = codeReader->tell(); if(javaPC < exceptions.nodes[curExceptionNode]->pc || javaPC >= exceptions.nodes[curExceptionNode+1]->pc) { if(javaPC == exceptions.nodes[curExceptionNode+1]->pc) selectExceptionNode(curExceptionNode+1); else for(uint32_t i=0; ipc <= javaPC && javaPC < exceptions.nodes[i+1]->pc) { selectExceptionNode(i); break; } //printf("cur exception node: %d\n", curExceptionNode); } if(opInfos[javaPC].insn || opInfos[javaPC].bb) { if(closeBB && !builder.GetInsertBlock()->getTerminator()) { if(!opInfos[javaPC].bb) J3::internalError("random split???"); builder.CreateBr(opInfos[javaPC].bb); } } if(opInfos[javaPC].insn) { _onEndPoint(); javaPC = codeReader->tell(); } closeBB = 1; if(opInfos[javaPC].bb) { builder.SetInsertPoint(opInfos[javaPC].bb); //printf("Meta stack before: %p\n", metaStack); if(opInfos[javaPC].metaStack) { stack.metaStack = opInfos[javaPC].metaStack; stack.topStack = opInfos[javaPC].topStack; } else if(opInfos[javaPC].topStack == -1) { /* exception handling */ stack.metaStack[0] = vm->typeJ3ObjectPtr; stack.topStack = 1; } //printf("Meta stack after: %p\n", metaStack); } if(opInfos[javaPC].bb || builder.GetInsertBlock()->empty()) opInfos[javaPC].insn = builder.GetInsertBlock()->begin(); else opInfos[javaPC].insn = builder.GetInsertBlock()->end()->getPrevNode(); bc = codeReader->readU1(); switch(vm->options()->debugTranslate) { default: case 5: fprintf(stderr, "--------------------------------------------\n"); llvmFunction->dump(); case 4: stack.dump(); case 3: case 2: fprintf(stderr, " [%4d] decoding: %s\n", javaPC, J3Cst::opcodeNames[bc]); break; case 1: case 0: break; } genDebugOpcode(); switch(bc) { case J3Cst::BC_nop: /* 0x00 */ break; case J3Cst::BC_aconst_null: /* 0x01 */ stack.push(nullValue); break; case J3Cst::BC_iconst_m1: /* 0x02 */ case J3Cst::BC_iconst_0: /* 0x03 */ case J3Cst::BC_iconst_1: /* 0x04 */ case J3Cst::BC_iconst_2: /* 0x05 */ case J3Cst::BC_iconst_3: /* 0x06 */ case J3Cst::BC_iconst_4: /* 0x07 */ case J3Cst::BC_iconst_5: /* 0x08 */ stack.push(builder.getInt32(bc - J3Cst::BC_iconst_0)); break; case J3Cst::BC_lconst_0: /* 0x09 */ case J3Cst::BC_lconst_1: /* 0x0a */ stack.push(builder.getInt64(bc - J3Cst::BC_lconst_0)); break; case J3Cst::BC_fconst_0: /* 0x0b */ case J3Cst::BC_fconst_1: /* 0x0c */ case J3Cst::BC_fconst_2: /* 0x0d */ stack.push(llvm::ConstantFP::get(builder.getFloatTy(), (bc - J3Cst::BC_fconst_0))); break; case J3Cst::BC_dconst_0: /* 0x0e */ case J3Cst::BC_dconst_1: /* 0x0f */ stack.push(llvm::ConstantFP::get(builder.getDoubleTy(), (bc - J3Cst::BC_dconst_0))); break; case J3Cst::BC_bipush: /* 0x10 */ stack.push(builder.getInt32(codeReader->readS1())); break; case J3Cst::BC_sipush: /* 0x11 */ stack.push(builder.getInt32(codeReader->readS2())); break; case J3Cst::BC_ldc: /* 0x12 */ ldc(codeReader->readU1()); break; case J3Cst::BC_ldc_w: /* 0x13 */ case J3Cst::BC_ldc2_w: /* 0x14 */ ldc(codeReader->readU2()); break; case J3Cst::BC_iload: /* 0x15 wide */ stack.push(locals.at(wideReadU1(), vm->typeInteger->llvmType())); break; case J3Cst::BC_lload: /* 0x16 wide */ stack.push(locals.at(wideReadU1(), vm->typeLong->llvmType())); break; case J3Cst::BC_fload: /* 0x17 wide */ stack.push(locals.at(wideReadU1(), vm->typeFloat->llvmType())); break; case J3Cst::BC_dload: /* 0x18 wide */ stack.push(locals.at(wideReadU1(), vm->typeDouble->llvmType())); break; case J3Cst::BC_aload: /* 0x19 wide */ stack.push(locals.at(wideReadU1(), vm->objectClass->llvmType())); break; case J3Cst::BC_iload_0: /* 0x1a */ case J3Cst::BC_iload_1: /* 0x1b */ case J3Cst::BC_iload_2: /* 0x1c */ case J3Cst::BC_iload_3: /* 0x1d */ stack.push(locals.at(bc - J3Cst::BC_iload_0, vm->typeInteger->llvmType())); break; case J3Cst::BC_lload_0: /* 0x1e */ case J3Cst::BC_lload_1: /* 0x1f */ case J3Cst::BC_lload_2: /* 0x20 */ case J3Cst::BC_lload_3: /* 0x21 */ stack.push(locals.at(bc - J3Cst::BC_lload_0, vm->typeLong->llvmType())); break; case J3Cst::BC_fload_0: /* 0x22 */ case J3Cst::BC_fload_1: /* 0x23 */ case J3Cst::BC_fload_2: /* 0x24 */ case J3Cst::BC_fload_3: /* 0x25 */ stack.push(locals.at(bc - J3Cst::BC_fload_0, vm->typeFloat->llvmType())); break; case J3Cst::BC_dload_0: /* 0x26 */ case J3Cst::BC_dload_1: /* 0x27 */ case J3Cst::BC_dload_2: /* 0x28 */ case J3Cst::BC_dload_3: /* 0x29 */ stack.push(locals.at(bc - J3Cst::BC_dload_0, vm->typeDouble->llvmType())); break; case J3Cst::BC_aload_0: /* 0x2a */ case J3Cst::BC_aload_1: /* 0x2b */ case J3Cst::BC_aload_2: /* 0x2c */ case J3Cst::BC_aload_3: /* 0x2d */ stack.push(locals.at(bc - J3Cst::BC_aload_0, vm->objectClass->llvmType())); break; case J3Cst::BC_iaload: /* 0x2e */ arrayLoad(vm->typeInteger); break; case J3Cst::BC_laload: /* 0x2f */ arrayLoad(vm->typeLong); break; case J3Cst::BC_faload: /* 0x30 */ arrayLoad(vm->typeFloat); break; case J3Cst::BC_daload: /* 0x31 */ arrayLoad(vm->typeDouble); break; case J3Cst::BC_aaload: /* 0x32 */ arrayLoad(vm->objectClass); break; case J3Cst::BC_baload: /* 0x33 */ arrayLoad(vm->typeByte); break; case J3Cst::BC_caload: /* 0x34 */ arrayLoad(vm->typeCharacter); break; case J3Cst::BC_saload: /* 0x35 */ arrayLoad(vm->typeShort); break; case J3Cst::BC_istore: /* 0x36 wide */ case J3Cst::BC_lstore: /* 0x37 wide */ case J3Cst::BC_fstore: /* 0x38 wide */ case J3Cst::BC_dstore: /* 0x39 wide */ case J3Cst::BC_astore: /* 0x3a wide */ locals.setAt(stack.pop(), wideReadU1()); break; case J3Cst::BC_istore_0: /* 0x3b */ case J3Cst::BC_istore_1: /* 0x3c */ case J3Cst::BC_istore_2: /* 0x3d */ case J3Cst::BC_istore_3: /* 0x3e */ locals.setAt(stack.pop(), bc - J3Cst::BC_istore_0); break; case J3Cst::BC_lstore_0: /* 0x3f */ case J3Cst::BC_lstore_1: /* 0x40 */ case J3Cst::BC_lstore_2: /* 0x41 */ case J3Cst::BC_lstore_3: /* 0x42 */ locals.setAt(stack.pop(), bc - J3Cst::BC_lstore_0); break; case J3Cst::BC_fstore_0: /* 0x43 */ case J3Cst::BC_fstore_1: /* 0x44 */ case J3Cst::BC_fstore_2: /* 0x45 */ case J3Cst::BC_fstore_3: /* 0x46 */ locals.setAt(stack.pop(), bc - J3Cst::BC_fstore_0); break; case J3Cst::BC_dstore_0: /* 0x47 */ case J3Cst::BC_dstore_1: /* 0x48 */ case J3Cst::BC_dstore_2: /* 0x49 */ case J3Cst::BC_dstore_3: /* 0x4a */ locals.setAt(stack.pop(), bc - J3Cst::BC_dstore_0); break; case J3Cst::BC_astore_0: /* 0x4b */ case J3Cst::BC_astore_1: /* 0x4c */ case J3Cst::BC_astore_2: /* 0x4d */ case J3Cst::BC_astore_3: /* 0x4e */ locals.setAt(stack.pop(), bc - J3Cst::BC_astore_0); break; case J3Cst::BC_iastore: /* 0x4f */ arrayStore(vm->typeInteger); break; case J3Cst::BC_lastore: /* 0x50 */ arrayStore(vm->typeLong); break; case J3Cst::BC_fastore: /* 0x51 */ arrayStore(vm->typeFloat); break; case J3Cst::BC_dastore: /* 0x52 */ arrayStore(vm->typeDouble); break; case J3Cst::BC_aastore: /* 0x53 */ arrayStore(vm->objectClass); break; case J3Cst::BC_bastore: /* 0x54 */ arrayStore(vm->typeByte); break; case J3Cst::BC_castore: /* 0x55 */ arrayStore(vm->typeCharacter); break; case J3Cst::BC_sastore: /* 0x56 */ arrayStore(vm->typeShort); break; case J3Cst::BC_pop: /* 0x57 */ stack.pop(); break; case J3Cst::BC_pop2: /* 0x58 */ val1 = stack.pop(); if(!val1->getType()->isDoubleTy() && !val1->getType()->isIntegerTy(64)) stack.pop(); break; case J3Cst::BC_dup: /* 0x59 */ stack.push(stack.top()); break; case J3Cst::BC_dup_x1: /* 0x5a */ val1 = stack.pop(); val2 = stack.pop(); stack.push(val1); stack.push(val2); stack.push(val1); break; case J3Cst::BC_dup_x2: /* 0x5b */ val1 = stack.pop(); val2 = stack.pop(); if(val2->getType()->isDoubleTy() || val2->getType()->isIntegerTy(64)) { stack.push(val1); stack.push(val2); stack.push(val1); } else { val3 = stack.pop(); stack.push(val1); stack.push(val3); stack.push(val2); stack.push(val1); } break; case J3Cst::BC_dup2: /* 0x5c */ val1 = stack.top(); if(val1->getType()->isDoubleTy() || val1->getType()->isIntegerTy(64)) { stack.push(val1); } else { val2 = stack.top(1); stack.push(val2); stack.push(val1); } break; case J3Cst::BC_dup2_x1: /* 0x5d */ val1 = stack.pop(); val2 = stack.pop(); if(val1->getType()->isDoubleTy() || val1->getType()->isIntegerTy(64)) { stack.push(val1); stack.push(val2); stack.push(val1); } else { val3 = stack.pop(); stack.push(val2); stack.push(val1); stack.push(val3); stack.push(val2); stack.push(val1); } break; case J3Cst::BC_dup2_x2: /* 0x5e */ val1 = stack.pop(); val2 = stack.pop(); val3 = stack.pop(); if(val1->getType()->isDoubleTy() || val1->getType()->isIntegerTy(64)) { stack.push(val1); stack.push(val3); stack.push(val2); stack.push(val1); } else { llvm::Value* val4 = stack.pop(); stack.push(val2); stack.push(val1); stack.push(val4); stack.push(val3); stack.push(val2); stack.push(val1); } break; case J3Cst::BC_swap: /* 0x5f */ val1 = stack.pop(); val2 = stack.pop(); stack.push(val1); stack.push(val2); break; case J3Cst::BC_iadd: /* 0x60 */ case J3Cst::BC_ladd: /* 0x61 */ val2 = stack.pop(); val1 = stack.pop(); stack.push(builder.CreateAdd(val1, val2)); break; case J3Cst::BC_fadd: /* 0x62 */ case J3Cst::BC_dadd: /* 0x63 */ val2 = stack.pop(); val1 = stack.pop(); stack.push(builder.CreateFAdd(val1, val2)); break; case J3Cst::BC_isub: /* 0x64 */ case J3Cst::BC_lsub: /* 0x65 */ val2 = stack.pop(); val1 = stack.pop(); stack.push(builder.CreateSub(val1, val2)); break; case J3Cst::BC_fsub: /* 0x66 */ case J3Cst::BC_dsub: /* 0x67 */ val2 = stack.pop(); val1 = stack.pop(); stack.push(builder.CreateFSub(val1, val2)); break; case J3Cst::BC_imul: /* 0x68 */ case J3Cst::BC_lmul: /* 0x69 */ val2 = stack.pop(); val1 = stack.pop(); stack.push(builder.CreateMul(val1, val2)); break; case J3Cst::BC_fmul: /* 0x6a */ case J3Cst::BC_dmul: /* 0x6b */ val2 = stack.pop(); val1 = stack.pop(); stack.push(builder.CreateFMul(val1, val2)); break; case J3Cst::BC_idiv: /* 0x6c */ case J3Cst::BC_ldiv: /* 0x6d */ val2 = stack.pop(); val1 = stack.pop(); stack.push(builder.CreateSDiv(val1, val2)); break; case J3Cst::BC_fdiv: /* 0x6e */ case J3Cst::BC_ddiv: /* 0x6f */ val2 = stack.pop(); val1 = stack.pop(); stack.push(builder.CreateFDiv(val1, val2)); break; case J3Cst::BC_irem: /* 0x70 */ case J3Cst::BC_lrem: /* 0x71 */ val2 = stack.pop(); val1 = stack.pop(); stack.push(builder.CreateSRem(val1, val2)); break; case J3Cst::BC_frem: /* 0x72 */ case J3Cst::BC_drem: /* 0x73 */ val2 = stack.pop(); val1 = stack.pop(); stack.push(builder.CreateFRem(val1, val2)); break; case J3Cst::BC_ineg: /* 0x74 */ case J3Cst::BC_lneg: /* 0x75 */ stack.push(builder.CreateNeg(stack.pop())); break; case J3Cst::BC_fneg: /* 0x76 */ case J3Cst::BC_dneg: /* 0x77 */ stack.push(builder.CreateFNeg(stack.pop())); break; case J3Cst::BC_ishl: /* 0x78 */ val2 = stack.pop(); val1 = stack.pop(); stack.push(builder.CreateShl(val1, builder.CreateAnd(val2, 0x1f))); break; case J3Cst::BC_lshl: /* 0x79 */ val2 = stack.pop(); val1 = stack.pop(); stack.push(builder.CreateShl(val1, builder.CreateZExt(builder.CreateAnd(val2, 0x3f), builder.getInt64Ty()))); break; case J3Cst::BC_ishr: /* 0x7a */ val2 = stack.pop(); val1 = stack.pop(); stack.push(builder.CreateAShr(val1, builder.CreateAnd(val2, 0x1f))); break; case J3Cst::BC_lshr: /* 0x7b */ val2 = stack.pop(); val1 = stack.pop(); stack.push(builder.CreateAShr(val1, builder.CreateZExt(builder.CreateAnd(val2, 0x3f), builder.getInt64Ty()))); break; case J3Cst::BC_iushr: /* 0x7c */ val2 = stack.pop(); val1 = stack.pop(); stack.push(builder.CreateLShr(val1, builder.CreateAnd(val2, 0x1f))); break; case J3Cst::BC_lushr: /* 0x7d */ val2 = stack.pop(); val1 = stack.pop(); stack.push(builder.CreateLShr(val1, builder.CreateZExt(builder.CreateAnd(val2, 0x3f), builder.getInt64Ty()))); break; case J3Cst::BC_iand: /* 0x7e */ case J3Cst::BC_land: /* 0x7f */ val2 = stack.pop(); val1 = stack.pop(); stack.push(builder.CreateAnd(val1, val2)); break; case J3Cst::BC_ior: /* 0x80 */ case J3Cst::BC_lor: /* 0x81 */ val2 = stack.pop(); val1 = stack.pop(); stack.push(builder.CreateOr(val1, val2)); break; case J3Cst::BC_ixor: /* 0x82 */ case J3Cst::BC_lxor: /* 0x83 */ val2 = stack.pop(); val1 = stack.pop(); stack.push(builder.CreateXor(val1, val2)); break; case J3Cst::BC_iinc: /* 0x84 wide */ { uint32_t idx = wideReadU1(); int32_t val = wideReadS1(); locals.setAt(builder.CreateAdd(locals.at(idx, vm->typeInteger->llvmType()), builder.getInt32(val)), idx); } break; case J3Cst::BC_i2l: /* 0x85 */ stack.push(builder.CreateSExt(stack.pop(), vm->typeLong->llvmType())); break; case J3Cst::BC_i2f: /* 0x86 */ stack.push(builder.CreateSIToFP(stack.pop(), vm->typeFloat->llvmType())); break; case J3Cst::BC_i2d: /* 0x87 */ stack.push(builder.CreateSIToFP(stack.pop(), vm->typeDouble->llvmType())); break; case J3Cst::BC_l2i: /* 0x88 */ stack.push(builder.CreateTruncOrBitCast(stack.pop(), builder.getInt32Ty())); break; case J3Cst::BC_l2f: /* 0x89 */ stack.push(builder.CreateSIToFP(stack.pop(), vm->typeFloat->llvmType())); break; case J3Cst::BC_l2d: /* 0x8a */ stack.push(builder.CreateSIToFP(stack.pop(), vm->typeDouble->llvmType())); break; case J3Cst::BC_f2i: /* 0x8b */ floatToInteger(vm->typeFloat, vm->typeInteger); break; case J3Cst::BC_f2l: /* 0x8c */ floatToInteger(vm->typeFloat, vm->typeLong); break; case J3Cst::BC_f2d: /* 0x8d */ stack.push(builder.CreateFPExt(stack.pop(), vm->typeDouble->llvmType())); break; case J3Cst::BC_d2i: /* 0x8e */ floatToInteger(vm->typeDouble, vm->typeInteger); break; case J3Cst::BC_d2l: /* 0x8f */ floatToInteger(vm->typeDouble, vm->typeLong); break; case J3Cst::BC_d2f: /* 0x90 */ stack.push(builder.CreateFPTrunc(stack.pop(), vm->typeFloat->llvmType())); break; case J3Cst::BC_i2b: /* 0x91 */ stack.push(builder.CreateSExt(builder.CreateTrunc(stack.pop(), builder.getInt8Ty()), builder.getInt32Ty())); break; case J3Cst::BC_i2c: /* 0x92 */ stack.push(builder.CreateZExt(builder.CreateTrunc(stack.pop(), builder.getInt16Ty()), builder.getInt32Ty())); break; case J3Cst::BC_i2s: /* 0x93 */ stack.push(builder.CreateSExt(builder.CreateTrunc(stack.pop(), builder.getInt16Ty()), builder.getInt32Ty())); break; case J3Cst::BC_lcmp: /* 0x94 */ compareLong(); break; case J3Cst::BC_fcmpl: /* 0x95 */ compareFP(1); break; case J3Cst::BC_fcmpg: /* 0x96 */ compareFP(0); break; case J3Cst::BC_dcmpl: /* 0x97 */ compareFP(0); break; case J3Cst::BC_dcmpg: /* 0x98 */ compareFP(1); break; case J3Cst::BC_ifeq: /* 0x99 */ condBr(builder.CreateICmpEQ(stack.pop(), builder.getInt32(0))); break; case J3Cst::BC_ifne: /* 0x9a */ condBr(builder.CreateICmpNE(stack.pop(), builder.getInt32(0))); break; case J3Cst::BC_iflt: /* 0x9b */ condBr(builder.CreateICmpSLT(stack.pop(), builder.getInt32(0))); break; case J3Cst::BC_ifge: /* 0x9c */ condBr(builder.CreateICmpSGE(stack.pop(), builder.getInt32(0))); break; case J3Cst::BC_ifgt: /* 0x9d */ condBr(builder.CreateICmpSGT(stack.pop(), builder.getInt32(0))); break; case J3Cst::BC_ifle: /* 0x9e */ condBr(builder.CreateICmpSLE(stack.pop(), builder.getInt32(0))); break; case J3Cst::BC_if_icmpeq: /* 0x9f */ val2 = stack.pop(); val1 = stack.pop(); condBr(builder.CreateICmpEQ(val1, val2)); break; case J3Cst::BC_if_icmpne: /* 0xa0 */ val2 = stack.pop(); val1 = stack.pop(); condBr(builder.CreateICmpNE(val1, val2)); break; case J3Cst::BC_if_icmplt: /* 0xa1 */ val2 = stack.pop(); val1 = stack.pop(); condBr(builder.CreateICmpSLT(val1, val2)); break; case J3Cst::BC_if_icmpge: /* 0xa2 */ val2 = stack.pop(); val1 = stack.pop(); condBr(builder.CreateICmpSGE(val1, val2)); break; case J3Cst::BC_if_icmpgt: /* 0xa3 */ val2 = stack.pop(); val1 = stack.pop(); condBr(builder.CreateICmpSGT(val1, val2)); break; case J3Cst::BC_if_icmple: /* 0xa4 */ val2 = stack.pop(); val1 = stack.pop(); condBr(builder.CreateICmpSLE(val1, val2)); break; case J3Cst::BC_if_acmpeq: /* 0xa5 */ val2 = stack.pop(); val1 = stack.pop(); condBr(builder.CreateICmpEQ(val1, val2)); break; case J3Cst::BC_if_acmpne: /* 0xa6 */ val2 = stack.pop(); val1 = stack.pop(); condBr(builder.CreateICmpNE(val1, val2)); break; case J3Cst::BC_goto: /* 0xa7 */ builder.CreateBr(forwardBranch("goto", javaPC + codeReader->readS2(), 0, 1)); _onEndPoint(); break; case J3Cst::BC_jsr: nyi(); /* 0xa8 */ case J3Cst::BC_ret: /* wide */ nyi(); /* 0xa9 */ case J3Cst::BC_tableswitch: /* 0xaa */ tableSwitch(); _onEndPoint(); break; case J3Cst::BC_lookupswitch: lookupSwitch(); _onEndPoint(); break; case J3Cst::BC_ireturn: /* 0xac */ case J3Cst::BC_lreturn: /* 0xad */ case J3Cst::BC_freturn: /* 0xae */ case J3Cst::BC_dreturn: /* 0xaf */ case J3Cst::BC_areturn: /* 0xb0 */ ret.setAt(stack.pop(), 0); builder.CreateBr(bbRet); _onEndPoint(); break; case J3Cst::BC_return: /* 0xb1 */ builder.CreateBr(bbRet); _onEndPoint(); break; case J3Cst::BC_getstatic: /* 0xb2 */ getStatic(codeReader->readU2()); break; case J3Cst::BC_putstatic: /* 0xb3 */ putStatic(codeReader->readU2()); break; case J3Cst::BC_getfield: /* 0xb4 */ getField(codeReader->readU2()); break; case J3Cst::BC_putfield: /* 0xb5 */ putField(codeReader->readU2()); break; case J3Cst::BC_invokevirtual: /* 0xb6 */ invokeVirtual(codeReader->readU2()); break; case J3Cst::BC_invokespecial: /* 0xb7 */ invokeSpecial(codeReader->readU2()); break; case J3Cst::BC_invokestatic: /* 0xb8 */ invokeStatic(codeReader->readU2()); break; case J3Cst::BC_invokeinterface: /* 0xb9 */ invokeInterface(codeReader->readU2()); codeReader->readU2(); break; case J3Cst::BC_new: /* 0xbb */ newObject(cl->classAt(codeReader->readU2())->asClass()); break; case J3Cst::BC_newarray: /* 0xbc */ newArray(codeReader->readU1()); break; case J3Cst::BC_anewarray: /* 0xbd */ newArray(cl->classAt(codeReader->readU2())->getArray()); break; case J3Cst::BC_arraylength: /* 0xbe */ stack.push(arrayLength(stack.pop())); break; case J3Cst::BC_athrow: /* 0xbf */ { llvm::Value* excp = builder.CreateBitCast(stack.pop(), funcThrowException->getFunctionType()->getParamType(0)); if(exceptions.nodes[curExceptionNode]->landingPad) builder.CreateInvoke(funcThrowException, bbRet, exceptions.nodes[curExceptionNode]->landingPad, excp); else { builder.CreateCall(funcThrowException, excp); builder.CreateBr(bbRet); } _onEndPoint(); } break; case J3Cst::BC_checkcast: /* 0xc0 */ checkCast(stack.top(), cl->classAt(codeReader->readU2())); break; case J3Cst::BC_instanceof: /* 0xc1 */ instanceof(stack.pop(), cl->classAt(codeReader->readU2())); break; case J3Cst::BC_monitorenter: /* 0xc2 */ monitorEnter(stack.pop()); break; case J3Cst::BC_monitorexit: /* 0xc3 */ monitorExit(stack.pop()); break; case J3Cst::BC_wide: /* 0xc4 */ isWide = 1; break; case J3Cst::BC_multianewarray: /* 0xc5 */ multianewArray(); break; case J3Cst::BC_ifnull: /* 0xc6 */ condBr(builder.CreateIsNull(stack.pop())); break; case J3Cst::BC_ifnonnull: /* 0xc7 */ condBr(builder.CreateIsNotNull(stack.pop())); break; case J3Cst::BC_goto_w: nyi(); /* 0xc8 */ case J3Cst::BC_jsr_w: nyi(); /* 0xc9 */ case J3Cst::BC_breakpoint: /* 0xca */ case J3Cst::BC_impdep1: /* 0xfe */ case J3Cst::BC_impdep2: /* 0xff */ case J3Cst::BC_xxxunusedxxx1: /* 0xba */ default: J3::classFormatError(cl, "unknow opcode '%s' (%d)", J3Cst::opcodeNames[bc], bc); } } J3::classFormatError(cl, "the last bytecode does not return"); } #if 0 void J3CodeGen::explore() { printf(" exploring bytecode of: %s::%s%s\n", cl->name()->cStr(), method->name()->cStr(), method->signature()->cStr()); while(codeReader->remaining()) { bc = codeReader->readU1(); printf(" exploring: %s (%d)\n", J3Cst::opcodeNames[bc], bc); switch(bc) { #define eat(n) codeReader->seek(n, codeReader->SeekCur); #define defOpcode(id, val, effect) \ case J3Cst::BC_##id: effect; break; #include "j3/j3bc.def" default: J3::internalError("unknow opcode '%s' (%d)", J3Cst::opcodeNames[bc], bc); } } } #endif void J3CodeGen::generateJava() { llvm::BasicBlock* entry = newBB("entry"); builder.SetInsertPoint(entry); J3Attribute* attr = method->attributes()->lookup(vm->codeAttribute); if(!attr) J3::classFormatError(cl, "No Code attribute in %s %s", method->name()->cStr(), method->signature()->name()->cStr()); J3Reader reader(cl->bytes()); reader.seek(attr->offset(), reader.SeekSet); uint32_t length = reader.readU4(); if(!reader.adjustSize(length)) J3::classFormatError(cl, "Code attribute of %s %s is too large (%d)", method->name()->cStr(), method->signature()->name()->cStr(), length); llvm::DIBuilder* dbgBuilder = new llvm::DIBuilder(*module); dbgInfo = dbgBuilder->createFunction(llvm::DIDescriptor(), // Function scope llvmFunction->getName(), // Function name llvmFunction->getName(), // Mangled name llvm::DIFile(), // File where this variable is defined 0, // Line number dbgBuilder // Function type. ->createSubroutineType(llvm::DIFile(), // File in which this subroutine is defined llvm::DIArray()), // An array of subroutine parameter types. // This includes return type at 0th index. false, // True if this function is not externally visible false, // True if this is a function definition 0, // Set to the beginning of the scope this starts 0, false, llvmFunction ); uint32_t maxStack = reader.readU2(); uint32_t nbLocals = reader.readU2(); uint32_t codeLength = reader.readU4(); locals.init(this, nbLocals); stack.init(this, maxStack); ret.init(this, 1); genDebugEnterLeave(0); uint32_t n=0, pos=0; for(llvm::Function::arg_iterator cur=llvmFunction->arg_begin(); cur!=llvmFunction->arg_end(); cur++) { locals.setAt(flatten(cur), pos); pos += (cur->getType() == vm->typeLong->llvmType() || cur->getType() == vm->typeDouble->llvmType()) ? 2 : 1; } //builder.CreateCall(ziTry); pendingBranchs = (uint32_t*)allocator->allocate(sizeof(uint32_t) * codeLength); opInfos = (J3OpInfo*)allocator->allocate(sizeof(J3OpInfo) * codeLength); memset(opInfos, 0, sizeof(J3OpInfo) * codeLength); J3Reader codeReaderTmp(cl->bytes(), reader.tell(), codeLength); codeReader = &codeReaderTmp; bbRet = newBB("ret"); builder.SetInsertPoint(bbRet); genDebugEnterLeave(1); if(llvmFunction->getReturnType()->isVoidTy()) builder.CreateRetVoid(); else builder.CreateRet(unflatten(ret.at(0, llvmFunction->getReturnType()), llvmFunction->getReturnType())); if(J3Cst::isSynchronized(access)) { static bool echoDone = 0; if(!echoDone) { fprintf(stderr, "IMPLEMENT ME: synchronized java\n"); echoDone = 1; } } reader.seek(codeLength, reader.SeekCur); exceptions.read(&reader, codeLength); pendingBranchs[topPendingBranchs++] = codeReader->tell(); builder.SetInsertPoint(entry); translate(); locals.killUnused(); stack.killUnused(); ret.killUnused(); } llvm::Type* J3CodeGen::doNativeType(llvm::Type* type) { return type->isPointerTy() ? vm->typeJ3ObjectHandlePtr : type; } llvm::Function* J3CodeGen::lookupNative() { J3Mangler mangler(cl); mangler.mangle(mangler.javaId)->mangle(cl->name(), method->name()); uint32_t length = mangler.length(); mangler.mangle(method->signature()); void* fnPtr = method->nativeFnPtr(); if(!fnPtr) fnPtr = loader->lookupNativeFunctionPointer(method, mangler.cStr()); if(!fnPtr) { mangler.cStr()[length] = 0; fnPtr = loader->lookupNativeFunctionPointer(method, mangler.cStr()); } if(!fnPtr) J3::linkageError(method); std::vector nativeIns; llvm::Type* nativeOut; nativeIns.push_back(vm->typeJNIEnvPtr); if(J3Cst::isStatic(access)) nativeIns.push_back(doNativeType(vm->classClass->llvmType())); llvm::FunctionType* origFType = method->signature()->functionType(access); for(llvm::FunctionType::param_iterator it=origFType->param_begin(); it!=origFType->param_end(); it++) nativeIns.push_back(doNativeType(*it)); nativeOut = doNativeType(origFType->getReturnType()); char* buf = (char*)loader->allocator()->allocate(mangler.length()+1); memcpy(buf, mangler.cStr(), mangler.length()+1); llvm::FunctionType* fType = llvm::FunctionType::get(nativeOut, nativeIns, 0); llvm::Function* res = llvm::Function::Create(fType, llvm::GlobalValue::ExternalLinkage, buf, module); loader->addSymbol(buf, new(loader->allocator()) vmkit::NativeSymbol(0, fnPtr)); return res; } void J3CodeGen::generateNative() { builder.SetInsertPoint(newBB("entry")); std::vector args; llvm::Function* nat = lookupNative(); llvm::Value* res; llvm::Value* thread = currentThread(); llvm::Value* frame = builder.CreateCall(funcJ3ThreadTell, thread); if(J3Cst::isSynchronized(access)) { static bool echoDone = 0; if(!echoDone) { fprintf(stderr, "IMPLEMENT ME: synchronized java\n"); echoDone = 1; } } args.push_back(builder.CreateCall(funcJniEnv)); if(J3Cst::isStatic(access)) args.push_back(javaClass(cl, 1)); uint32_t selfDone = 0; for(llvm::Function::arg_iterator cur=llvmFunction->arg_begin(); cur!=llvmFunction->arg_end(); cur++) { llvm::Value* v = cur; args.push_back(v->getType()->isPointerTy() ? builder.CreateCall2(funcJ3ThreadPush, thread, v) : v); } res = builder.CreateCall(nat, args); builder.CreateCall(funcReplayException); if(llvmFunction->getReturnType()->isVoidTy()) { builder.CreateCall2(funcJ3ThreadRestore, thread, frame); builder.CreateRetVoid(); } else { if(llvmFunction->getReturnType()->isPointerTy()) { llvm::BasicBlock* ifnull = newBB("ifnull"); llvm::BasicBlock* ifnotnull = newBB("ifnotnull"); builder.CreateCondBr(builder.CreateIsNull(res), ifnull, ifnotnull); builder.SetInsertPoint(ifnull); builder.CreateCall2(funcJ3ThreadRestore, thread, frame); builder.CreateRet(nullValue); builder.SetInsertPoint(ifnotnull); res = handleToObject(res); builder.CreateCall2(funcJ3ThreadRestore, thread, frame); } builder.CreateRet(res); } }