//===-- JIT.cpp - LLVM Just in Time Compiler ------------------------------===//
-//
+//
// The LLVM Compiler Infrastructure
//
-// This file was developed by the LLVM research group and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
//===----------------------------------------------------------------------===//
//
// This tool implements a just-in-time compiler for LLVM, allowing direct
-// execution of LLVM bytecode in an efficient manner.
+// execution of LLVM bitcode in an efficient manner.
//
//===----------------------------------------------------------------------===//
#include "llvm/CodeGen/MachineCodeEmitter.h"
#include "llvm/CodeGen/MachineFunction.h"
#include "llvm/ExecutionEngine/GenericValue.h"
+#include "llvm/Support/MutexGuard.h"
+#include "llvm/System/DynamicLibrary.h"
+#include "llvm/Target/TargetData.h"
#include "llvm/Target/TargetMachine.h"
#include "llvm/Target/TargetJITInfo.h"
-#include "llvm/Support/DynamicLinker.h"
-#include <iostream>
+
+#include "llvm/Config/config.h"
using namespace llvm;
-JIT::JIT(ModuleProvider *MP, TargetMachine &tm, TargetJITInfo &tji)
- : ExecutionEngine(MP), TM(tm), TJI(tji), PM(MP) {
+#ifdef __APPLE__
+// Apple gcc defaults to -fuse-cxa-atexit (i.e. calls __cxa_atexit instead
+// of atexit). It passes the address of linker generated symbol __dso_handle
+// to the function.
+// This configuration change happened at version 5330.
+# include <AvailabilityMacros.h>
+# if defined(MAC_OS_X_VERSION_10_4) && \
+ ((MAC_OS_X_VERSION_MIN_REQUIRED > MAC_OS_X_VERSION_10_4) || \
+ (MAC_OS_X_VERSION_MIN_REQUIRED == MAC_OS_X_VERSION_10_4 && \
+ __APPLE_CC__ >= 5330))
+# ifndef HAVE___DSO_HANDLE
+# define HAVE___DSO_HANDLE 1
+# endif
+# endif
+#endif
+
+#if HAVE___DSO_HANDLE
+extern void *__dso_handle __attribute__ ((__visibility__ ("hidden")));
+#endif
+
+namespace {
+
+static struct RegisterJIT {
+ RegisterJIT() { JIT::Register(); }
+} JITRegistrator;
+
+}
+
+namespace llvm {
+ void LinkInJIT() {
+ }
+}
+
+#if defined (__GNUC__)
+extern "C" void __register_frame(void*);
+#endif
+
+/// createJIT - This is the factory method for creating a JIT for the current
+/// machine, it does not fall back to the interpreter. This takes ownership
+/// of the module provider.
+ExecutionEngine *ExecutionEngine::createJIT(ModuleProvider *MP,
+ std::string *ErrorStr,
+ JITMemoryManager *JMM) {
+ ExecutionEngine *EE = JIT::createJIT(MP, ErrorStr, JMM);
+ if (!EE) return 0;
+
+ // Register routine for informing unwinding runtime about new EH frames
+#if defined(__GNUC__)
+ EE->InstallExceptionTableRegister(__register_frame);
+#endif
+
+ // Make sure we can resolve symbols in the program as well. The zero arg
+ // to the function tells DynamicLibrary to load the program, not a library.
+ sys::DynamicLibrary::LoadLibraryPermanently(0, ErrorStr);
+ return EE;
+}
+
+JIT::JIT(ModuleProvider *MP, TargetMachine &tm, TargetJITInfo &tji,
+ JITMemoryManager *JMM)
+ : ExecutionEngine(MP), TM(tm), TJI(tji) {
setTargetData(TM.getTargetData());
+ jitstate = new JITState(MP);
+
// Initialize MCE
- MCE = createEmitter(*this);
-
- // Add target data
- PM.add(new TargetData(TM.getTargetData()));
+ MCE = createEmitter(*this, JMM);
- // Compile LLVM Code down to machine code in the intermediate representation
- TJI.addPassesToJITCompile(PM);
+ // Add target data
+ MutexGuard locked(lock);
+ FunctionPassManager &PM = jitstate->getPM(locked);
+ PM.add(new TargetData(*TM.getTargetData()));
// Turn the machine code intermediate representation into bytes in memory that
// may be executed.
- if (TM.addPassesToEmitMachineCode(PM, *MCE)) {
- std::cerr << "Target '" << TM.getName()
- << "' doesn't support machine code emission!\n";
+ if (TM.addPassesToEmitMachineCode(PM, *MCE, false /*fast*/)) {
+ cerr << "Target does not support machine code emission!\n";
abort();
}
+
+ // Initialize passes.
+ PM.doInitialization();
}
JIT::~JIT() {
+ delete jitstate;
delete MCE;
delete &TM;
}
+/// addModuleProvider - Add a new ModuleProvider to the JIT. If we previously
+/// removed the last ModuleProvider, we need re-initialize jitstate with a valid
+/// ModuleProvider.
+void JIT::addModuleProvider(ModuleProvider *MP) {
+ MutexGuard locked(lock);
+
+ if (Modules.empty()) {
+ assert(!jitstate && "jitstate should be NULL if Modules vector is empty!");
+
+ jitstate = new JITState(MP);
+
+ FunctionPassManager &PM = jitstate->getPM(locked);
+ PM.add(new TargetData(*TM.getTargetData()));
+
+ // Turn the machine code intermediate representation into bytes in memory
+ // that may be executed.
+ if (TM.addPassesToEmitMachineCode(PM, *MCE, false /*fast*/)) {
+ cerr << "Target does not support machine code emission!\n";
+ abort();
+ }
+
+ // Initialize passes.
+ PM.doInitialization();
+ }
+
+ ExecutionEngine::addModuleProvider(MP);
+}
+
+/// removeModuleProvider - If we are removing the last ModuleProvider,
+/// invalidate the jitstate since the PassManager it contains references a
+/// released ModuleProvider.
+Module *JIT::removeModuleProvider(ModuleProvider *MP, std::string *E) {
+ Module *result = ExecutionEngine::removeModuleProvider(MP, E);
+
+ MutexGuard locked(lock);
+ if (Modules.empty()) {
+ delete jitstate;
+ jitstate = 0;
+ }
+
+ return result;
+}
+
/// run - Start execution with the specified function and arguments.
///
GenericValue JIT::runFunction(Function *F,
// Handle some common cases first. These cases correspond to common `main'
// prototypes.
- if (RetTy == Type::IntTy || RetTy == Type::UIntTy || RetTy == Type::VoidTy) {
+ if (RetTy == Type::Int32Ty || RetTy == Type::VoidTy) {
switch (ArgValues.size()) {
case 3:
- if ((FTy->getParamType(0) == Type::IntTy ||
- FTy->getParamType(0) == Type::UIntTy) &&
+ if (FTy->getParamType(0) == Type::Int32Ty &&
isa<PointerType>(FTy->getParamType(1)) &&
isa<PointerType>(FTy->getParamType(2))) {
int (*PF)(int, char **, const char **) =
- (int(*)(int, char **, const char **))FPtr;
+ (int(*)(int, char **, const char **))(intptr_t)FPtr;
// Call the function.
GenericValue rv;
- rv.IntVal = PF(ArgValues[0].IntVal, (char **)GVTOP(ArgValues[1]),
- (const char **)GVTOP(ArgValues[2]));
+ rv.IntVal = APInt(32, PF(ArgValues[0].IntVal.getZExtValue(),
+ (char **)GVTOP(ArgValues[1]),
+ (const char **)GVTOP(ArgValues[2])));
return rv;
}
break;
case 2:
- if ((FTy->getParamType(0) == Type::IntTy ||
- FTy->getParamType(0) == Type::UIntTy) &&
+ if (FTy->getParamType(0) == Type::Int32Ty &&
isa<PointerType>(FTy->getParamType(1))) {
- int (*PF)(int, char **) = (int(*)(int, char **))FPtr;
+ int (*PF)(int, char **) = (int(*)(int, char **))(intptr_t)FPtr;
// Call the function.
GenericValue rv;
- rv.IntVal = PF(ArgValues[0].IntVal, (char **)GVTOP(ArgValues[1]));
+ rv.IntVal = APInt(32, PF(ArgValues[0].IntVal.getZExtValue(),
+ (char **)GVTOP(ArgValues[1])));
return rv;
}
break;
case 1:
if (FTy->getNumParams() == 1 &&
- (FTy->getParamType(0) == Type::IntTy ||
- FTy->getParamType(0) == Type::UIntTy)) {
+ FTy->getParamType(0) == Type::Int32Ty) {
GenericValue rv;
- int (*PF)(int) = (int(*)(int))FPtr;
- rv.IntVal = PF(ArgValues[0].IntVal);
+ int (*PF)(int) = (int(*)(int))(intptr_t)FPtr;
+ rv.IntVal = APInt(32, PF(ArgValues[0].IntVal.getZExtValue()));
return rv;
}
break;
GenericValue rv;
switch (RetTy->getTypeID()) {
default: assert(0 && "Unknown return type for function call!");
- case Type::BoolTyID:
- rv.BoolVal = ((bool(*)())FPtr)();
- return rv;
- case Type::SByteTyID:
- case Type::UByteTyID:
- rv.SByteVal = ((char(*)())FPtr)();
- return rv;
- case Type::ShortTyID:
- case Type::UShortTyID:
- rv.ShortVal = ((short(*)())FPtr)();
+ case Type::IntegerTyID: {
+ unsigned BitWidth = cast<IntegerType>(RetTy)->getBitWidth();
+ if (BitWidth == 1)
+ rv.IntVal = APInt(BitWidth, ((bool(*)())(intptr_t)FPtr)());
+ else if (BitWidth <= 8)
+ rv.IntVal = APInt(BitWidth, ((char(*)())(intptr_t)FPtr)());
+ else if (BitWidth <= 16)
+ rv.IntVal = APInt(BitWidth, ((short(*)())(intptr_t)FPtr)());
+ else if (BitWidth <= 32)
+ rv.IntVal = APInt(BitWidth, ((int(*)())(intptr_t)FPtr)());
+ else if (BitWidth <= 64)
+ rv.IntVal = APInt(BitWidth, ((int64_t(*)())(intptr_t)FPtr)());
+ else
+ assert(0 && "Integer types > 64 bits not supported");
return rv;
+ }
case Type::VoidTyID:
- case Type::IntTyID:
- case Type::UIntTyID:
- rv.IntVal = ((int(*)())FPtr)();
- return rv;
- case Type::LongTyID:
- case Type::ULongTyID:
- rv.LongVal = ((int64_t(*)())FPtr)();
+ rv.IntVal = APInt(32, ((int(*)())(intptr_t)FPtr)());
return rv;
case Type::FloatTyID:
- rv.FloatVal = ((float(*)())FPtr)();
+ rv.FloatVal = ((float(*)())(intptr_t)FPtr)();
return rv;
case Type::DoubleTyID:
- rv.DoubleVal = ((double(*)())FPtr)();
+ rv.DoubleVal = ((double(*)())(intptr_t)FPtr)();
+ return rv;
+ case Type::X86_FP80TyID:
+ case Type::FP128TyID:
+ case Type::PPC_FP128TyID:
+ assert(0 && "long double not supported yet");
return rv;
case Type::PointerTyID:
- return PTOGV(((void*(*)())FPtr)());
+ return PTOGV(((void*(*)())(intptr_t)FPtr)());
}
}
// First, create the function.
FunctionType *STy=FunctionType::get(RetTy, std::vector<const Type*>(), false);
- Function *Stub = new Function(STy, Function::InternalLinkage, "",
- F->getParent());
+ Function *Stub = Function::Create(STy, Function::InternalLinkage, "",
+ F->getParent());
// Insert a basic block.
- BasicBlock *StubBB = new BasicBlock("", Stub);
+ BasicBlock *StubBB = BasicBlock::Create("", Stub);
// Convert all of the GenericValue arguments over to constants. Note that we
// currently don't support varargs.
- std::vector<Value*> Args;
+ SmallVector<Value*, 8> Args;
for (unsigned i = 0, e = ArgValues.size(); i != e; ++i) {
Constant *C = 0;
const Type *ArgTy = FTy->getParamType(i);
const GenericValue &AV = ArgValues[i];
switch (ArgTy->getTypeID()) {
default: assert(0 && "Unknown argument type for function call!");
- case Type::BoolTyID: C = ConstantBool::get(AV.BoolVal); break;
- case Type::SByteTyID: C = ConstantSInt::get(ArgTy, AV.SByteVal); break;
- case Type::UByteTyID: C = ConstantUInt::get(ArgTy, AV.UByteVal); break;
- case Type::ShortTyID: C = ConstantSInt::get(ArgTy, AV.ShortVal); break;
- case Type::UShortTyID: C = ConstantUInt::get(ArgTy, AV.UShortVal); break;
- case Type::IntTyID: C = ConstantSInt::get(ArgTy, AV.IntVal); break;
- case Type::UIntTyID: C = ConstantUInt::get(ArgTy, AV.UIntVal); break;
- case Type::LongTyID: C = ConstantSInt::get(ArgTy, AV.LongVal); break;
- case Type::ULongTyID: C = ConstantUInt::get(ArgTy, AV.ULongVal); break;
- case Type::FloatTyID: C = ConstantFP ::get(ArgTy, AV.FloatVal); break;
- case Type::DoubleTyID: C = ConstantFP ::get(ArgTy, AV.DoubleVal); break;
+ case Type::IntegerTyID:
+ C = ConstantInt::get(AV.IntVal);
+ break;
+ case Type::FloatTyID:
+ C = ConstantFP::get(APFloat(AV.FloatVal));
+ break;
+ case Type::DoubleTyID:
+ C = ConstantFP::get(APFloat(AV.DoubleVal));
+ break;
+ case Type::PPC_FP128TyID:
+ case Type::X86_FP80TyID:
+ case Type::FP128TyID:
+ C = ConstantFP::get(APFloat(AV.IntVal));
+ break;
case Type::PointerTyID:
void *ArgPtr = GVTOP(AV);
- if (sizeof(void*) == 4) {
- C = ConstantSInt::get(Type::IntTy, (int)(intptr_t)ArgPtr);
- } else {
- C = ConstantSInt::get(Type::LongTy, (intptr_t)ArgPtr);
- }
- C = ConstantExpr::getCast(C, ArgTy); // Cast the integer to pointer
+ if (sizeof(void*) == 4)
+ C = ConstantInt::get(Type::Int32Ty, (int)(intptr_t)ArgPtr);
+ else
+ C = ConstantInt::get(Type::Int64Ty, (intptr_t)ArgPtr);
+ C = ConstantExpr::getIntToPtr(C, ArgTy); // Cast the integer to pointer
break;
}
Args.push_back(C);
}
- Value *TheCall = new CallInst(F, Args, "", StubBB);
+ CallInst *TheCall = CallInst::Create(F, Args.begin(), Args.end(),
+ "", StubBB);
+ TheCall->setTailCall();
if (TheCall->getType() != Type::VoidTy)
- new ReturnInst(TheCall, StubBB); // Return result of the call.
+ ReturnInst::Create(TheCall, StubBB); // Return result of the call.
else
- new ReturnInst(StubBB); // Just return void.
+ ReturnInst::Create(StubBB); // Just return void.
// Finally, return the value returned by our nullary stub function.
return runFunction(Stub, std::vector<GenericValue>());
///
void JIT::runJITOnFunction(Function *F) {
static bool isAlreadyCodeGenerating = false;
+
+ MutexGuard locked(lock);
assert(!isAlreadyCodeGenerating && "Error: Recursive compilation detected!");
// JIT the function
isAlreadyCodeGenerating = true;
- PM.run(*F);
+ jitstate->getPM(locked).run(*F);
isAlreadyCodeGenerating = false;
// If the function referred to a global variable that had not yet been
// emitted, it allocates memory for the global, but doesn't emit it yet. Emit
// all of these globals now.
- while (!PendingGlobals.empty()) {
- const GlobalVariable *GV = PendingGlobals.back();
- PendingGlobals.pop_back();
+ while (!jitstate->getPendingGlobals(locked).empty()) {
+ const GlobalVariable *GV = jitstate->getPendingGlobals(locked).back();
+ jitstate->getPendingGlobals(locked).pop_back();
EmitGlobalVariable(GV);
}
}
/// specified function, compiling it if neccesary.
///
void *JIT::getPointerToFunction(Function *F) {
+
if (void *Addr = getPointerToGlobalIfAvailable(F))
return Addr; // Check if function already code gen'd
- // Make sure we read in the function if it exists in this Module
- try {
- MP->materializeFunction(F);
- } catch ( std::string& errmsg ) {
- std::cerr << "Error reading bytecode file: " << errmsg << "\n";
- abort();
- } catch (...) {
- std::cerr << "Error reading bytecode file!\n";
- abort();
+ // Make sure we read in the function if it exists in this Module.
+ if (F->hasNotBeenReadFromBitcode()) {
+ // Determine the module provider this function is provided by.
+ Module *M = F->getParent();
+ ModuleProvider *MP = 0;
+ for (unsigned i = 0, e = Modules.size(); i != e; ++i) {
+ if (Modules[i]->getModule() == M) {
+ MP = Modules[i];
+ break;
+ }
+ }
+ assert(MP && "Function isn't in a module we know about!");
+
+ std::string ErrorMsg;
+ if (MP->materializeFunction(F, &ErrorMsg)) {
+ cerr << "Error reading function '" << F->getName()
+ << "' from bitcode file: " << ErrorMsg << "\n";
+ abort();
+ }
+ }
+
+ if (void *Addr = getPointerToGlobalIfAvailable(F)) {
+ return Addr;
}
- if (F->isExternal()) {
+ MutexGuard locked(lock);
+
+ if (F->isDeclaration()) {
void *Addr = getPointerToNamedFunction(F->getName());
addGlobalMapping(F, Addr);
return Addr;
return Addr;
}
-// getPointerToFunctionOrStub - If the specified function has been
-// code-gen'd, return a pointer to the function. If not, compile it, or use
-// a stub to implement lazy compilation if available.
-//
-void *JIT::getPointerToFunctionOrStub(Function *F) {
- // If we have already code generated the function, just return the address.
- if (void *Addr = getPointerToGlobalIfAvailable(F))
- return Addr;
-
- // If the target supports "stubs" for functions, get a stub now.
- if (void *Ptr = TJI.getJITStubForFunction(F, *MCE))
- return Ptr;
-
- // Otherwise, if the target doesn't support it, just codegen the function.
- return getPointerToFunction(F);
-}
-
/// getOrEmitGlobalVariable - Return the address of the specified global
/// variable, possibly emitting it to memory if needed. This is used by the
/// Emitter.
void *JIT::getOrEmitGlobalVariable(const GlobalVariable *GV) {
+ MutexGuard locked(lock);
+
void *Ptr = getPointerToGlobalIfAvailable(GV);
if (Ptr) return Ptr;
// If the global is external, just remember the address.
- if (GV->isExternal()) {
- Ptr = GetAddressOfSymbol(GV->getName().c_str());
+ if (GV->isDeclaration()) {
+#if HAVE___DSO_HANDLE
+ if (GV->getName() == "__dso_handle")
+ return (void*)&__dso_handle;
+#endif
+ Ptr = sys::DynamicLibrary::SearchForAddressOfSymbol(GV->getName().c_str());
if (Ptr == 0) {
- std::cerr << "Could not resolve external global address: "
- << GV->getName() << "\n";
+ cerr << "Could not resolve external global address: "
+ << GV->getName() << "\n";
abort();
}
} else {
// If the global hasn't been emitted to memory yet, allocate space. We will
// actually initialize the global after current function has finished
// compilation.
- Ptr =new char[getTargetData().getTypeSize(GV->getType()->getElementType())];
- PendingGlobals.push_back(GV);
+ const Type *GlobalType = GV->getType()->getElementType();
+ size_t S = getTargetData()->getABITypeSize(GlobalType);
+ size_t A = getTargetData()->getPreferredAlignment(GV);
+ if (A <= 8) {
+ Ptr = malloc(S);
+ } else {
+ // Allocate S+A bytes of memory, then use an aligned pointer within that
+ // space.
+ Ptr = malloc(S+A);
+ unsigned MisAligned = ((intptr_t)Ptr & (A-1));
+ Ptr = (char*)Ptr + (MisAligned ? (A-MisAligned) : 0);
+ }
+ jitstate->getPendingGlobals(locked).push_back(GV);
}
addGlobalMapping(GV, Ptr);
return Ptr;
return Addr;
}
-/// freeMachineCodeForFunction - release machine code memory for given Function
-///
-void JIT::freeMachineCodeForFunction(Function *F) {
- // currently a no-op
-}
projects / oota-llvm.git / blobdiff