mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-10-02 02:55:35 +00:00
JIT: More nitty style tweakage, aka territory marking.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@118973 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
parent
afd693cff3
commit
48dd875be1
@ -41,6 +41,8 @@ class MutexGuard;
|
||||
class TargetData;
|
||||
class Type;
|
||||
|
||||
/// \brief Helper class for helping synchronize access to the global address map
|
||||
/// table.
|
||||
class ExecutionEngineState {
|
||||
public:
|
||||
struct AddressMapConfig : public ValueMapConfig<const GlobalValue*> {
|
||||
@ -70,8 +72,7 @@ private:
|
||||
public:
|
||||
ExecutionEngineState(ExecutionEngine &EE);
|
||||
|
||||
GlobalAddressMapTy &
|
||||
getGlobalAddressMap(const MutexGuard &) {
|
||||
GlobalAddressMapTy &getGlobalAddressMap(const MutexGuard &) {
|
||||
return GlobalAddressMap;
|
||||
}
|
||||
|
||||
@ -80,23 +81,41 @@ public:
|
||||
return GlobalAddressReverseMap;
|
||||
}
|
||||
|
||||
// Returns the address ToUnmap was mapped to.
|
||||
/// \brief Erase an entry from the mapping table.
|
||||
///
|
||||
/// \returns The address that \arg ToUnmap was happed to.
|
||||
void *RemoveMapping(const MutexGuard &, const GlobalValue *ToUnmap);
|
||||
};
|
||||
|
||||
|
||||
/// \brief Abstract interface for implementation execution of LLVM modules,
|
||||
/// designed to support both interpreter and just-in-time (JIT) compiler
|
||||
/// implementations.
|
||||
class ExecutionEngine {
|
||||
const TargetData *TD;
|
||||
/// The state object holding the global address mapping, which must be
|
||||
/// accessed synchronously.
|
||||
//
|
||||
// FIXME: There is no particular need the entire map needs to be
|
||||
// synchronized. Wouldn't a reader-writer design be better here?
|
||||
ExecutionEngineState EEState;
|
||||
|
||||
/// The target data for the platform for which execution is being performed.
|
||||
const TargetData *TD;
|
||||
|
||||
/// Whether lazy JIT compilation is enabled.
|
||||
bool CompilingLazily;
|
||||
|
||||
/// Whether JIT compilation of external global variables is allowed.
|
||||
bool GVCompilationDisabled;
|
||||
|
||||
/// Whether the JIT should perform lookups of external symbols (e.g.,
|
||||
/// using dlsym).
|
||||
bool SymbolSearchingDisabled;
|
||||
|
||||
friend class EngineBuilder; // To allow access to JITCtor and InterpCtor.
|
||||
|
||||
protected:
|
||||
/// Modules - This is a list of Modules that we are JIT'ing from. We use a
|
||||
/// smallvector to optimize for the case where there is only one module.
|
||||
/// The list of Modules that we are JIT'ing from. We use a SmallVector to
|
||||
/// optimize for the case where there is only one module.
|
||||
SmallVector<Module*, 1> Modules;
|
||||
|
||||
void setTargetData(const TargetData *td) {
|
||||
@ -104,11 +123,11 @@ protected:
|
||||
}
|
||||
|
||||
/// getMemoryforGV - Allocate memory for a global variable.
|
||||
virtual char* getMemoryForGV(const GlobalVariable* GV);
|
||||
virtual char *getMemoryForGV(const GlobalVariable *GV);
|
||||
|
||||
// To avoid having libexecutionengine depend on the JIT and interpreter
|
||||
// libraries, the JIT and Interpreter set these functions to ctor pointers
|
||||
// at startup time if they are linked in.
|
||||
// libraries, the JIT and Interpreter set these functions to ctor pointers at
|
||||
// startup time if they are linked in.
|
||||
static ExecutionEngine *(*JITCtor)(
|
||||
Module *M,
|
||||
std::string *ErrorStr,
|
||||
@ -123,8 +142,9 @@ protected:
|
||||
std::string *ErrorStr);
|
||||
|
||||
/// LazyFunctionCreator - If an unknown function is needed, this function
|
||||
/// pointer is invoked to create it. If this returns null, the JIT will abort.
|
||||
void* (*LazyFunctionCreator)(const std::string &);
|
||||
/// pointer is invoked to create it. If this returns null, the JIT will
|
||||
/// abort.
|
||||
void *(*LazyFunctionCreator)(const std::string &);
|
||||
|
||||
/// ExceptionTableRegister - If Exception Handling is set, the JIT will
|
||||
/// register dwarf tables with this function.
|
||||
@ -134,10 +154,10 @@ protected:
|
||||
std::vector<void*> AllExceptionTables;
|
||||
|
||||
public:
|
||||
/// lock - This lock is protects the ExecutionEngine, JIT, JITResolver and
|
||||
/// lock - This lock protects the ExecutionEngine, JIT, JITResolver and
|
||||
/// JITEmitter classes. It must be held while changing the internal state of
|
||||
/// any of those classes.
|
||||
sys::Mutex lock; // Used to make this class and subclasses thread-safe
|
||||
sys::Mutex lock;
|
||||
|
||||
//===--------------------------------------------------------------------===//
|
||||
// ExecutionEngine Startup
|
||||
@ -148,20 +168,18 @@ public:
|
||||
/// create - This is the factory method for creating an execution engine which
|
||||
/// is appropriate for the current machine. This takes ownership of the
|
||||
/// module.
|
||||
///
|
||||
/// \param GVsWithCode - Allocating globals with code breaks
|
||||
/// freeMachineCodeForFunction and is probably unsafe and bad for performance.
|
||||
/// However, we have clients who depend on this behavior, so we must support
|
||||
/// it. Eventually, when we're willing to break some backwards compatability,
|
||||
/// this flag should be flipped to false, so that by default
|
||||
/// freeMachineCodeForFunction works.
|
||||
static ExecutionEngine *create(Module *M,
|
||||
bool ForceInterpreter = false,
|
||||
std::string *ErrorStr = 0,
|
||||
CodeGenOpt::Level OptLevel =
|
||||
CodeGenOpt::Default,
|
||||
// Allocating globals with code breaks
|
||||
// freeMachineCodeForFunction and is probably
|
||||
// unsafe and bad for performance. However,
|
||||
// we have clients who depend on this
|
||||
// behavior, so we must support it.
|
||||
// Eventually, when we're willing to break
|
||||
// some backwards compatability, this flag
|
||||
// should be flipped to false, so that by
|
||||
// default freeMachineCodeForFunction works.
|
||||
bool GVsWithCode = true);
|
||||
|
||||
/// createJIT - This is the factory method for creating a JIT for the current
|
||||
@ -186,11 +204,10 @@ public:
|
||||
Modules.push_back(M);
|
||||
}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
//===--------------------------------------------------------------------===//
|
||||
|
||||
const TargetData *getTargetData() const { return TD; }
|
||||
|
||||
|
||||
/// removeModule - Remove a Module from the list of modules. Returns true if
|
||||
/// M is found.
|
||||
virtual bool removeModule(Module *M);
|
||||
@ -202,17 +219,19 @@ public:
|
||||
|
||||
/// runFunction - Execute the specified function with the specified arguments,
|
||||
/// and return the result.
|
||||
///
|
||||
virtual GenericValue runFunction(Function *F,
|
||||
const std::vector<GenericValue> &ArgValues) = 0;
|
||||
|
||||
/// runStaticConstructorsDestructors - This method is used to execute all of
|
||||
/// the static constructors or destructors for a program, depending on the
|
||||
/// value of isDtors.
|
||||
/// the static constructors or destructors for a program.
|
||||
///
|
||||
/// \param isDtors - Run the destructors instead of constructors.
|
||||
void runStaticConstructorsDestructors(bool isDtors);
|
||||
|
||||
/// runStaticConstructorsDestructors - This method is used to execute all of
|
||||
/// the static constructors or destructors for a module, depending on the
|
||||
/// value of isDtors.
|
||||
/// the static constructors or destructors for a particular module.
|
||||
///
|
||||
/// \param isDtors - Run the destructors instead of constructors.
|
||||
void runStaticConstructorsDestructors(Module *module, bool isDtors);
|
||||
|
||||
|
||||
@ -231,8 +250,8 @@ public:
|
||||
/// GlobalValue is destroyed.
|
||||
void addGlobalMapping(const GlobalValue *GV, void *Addr);
|
||||
|
||||
/// clearAllGlobalMappings - Clear all global mappings and start over again
|
||||
/// use in dynamic compilation scenarios when you want to move globals
|
||||
/// clearAllGlobalMappings - Clear all global mappings and start over again,
|
||||
/// for use in dynamic compilation scenarios to move globals.
|
||||
void clearAllGlobalMappings();
|
||||
|
||||
/// clearGlobalMappingsFromModule - Clear all global mappings that came from a
|
||||
@ -248,12 +267,10 @@ public:
|
||||
/// getPointerToGlobalIfAvailable - This returns the address of the specified
|
||||
/// global value if it is has already been codegen'd, otherwise it returns
|
||||
/// null.
|
||||
///
|
||||
void *getPointerToGlobalIfAvailable(const GlobalValue *GV);
|
||||
|
||||
/// getPointerToGlobal - This returns the address of the specified global
|
||||
/// value. This may involve code generation if it's a function.
|
||||
///
|
||||
void *getPointerToGlobal(const GlobalValue *GV);
|
||||
|
||||
/// getPointerToFunction - The different EE's represent function bodies in
|
||||
@ -261,20 +278,17 @@ public:
|
||||
/// pointer should look like. When F is destroyed, the ExecutionEngine will
|
||||
/// remove its global mapping and free any machine code. Be sure no threads
|
||||
/// are running inside F when that happens.
|
||||
///
|
||||
virtual void *getPointerToFunction(Function *F) = 0;
|
||||
|
||||
/// getPointerToBasicBlock - The different EE's represent basic blocks in
|
||||
/// different ways. Return the representation for a blockaddress of the
|
||||
/// specified block.
|
||||
///
|
||||
virtual void *getPointerToBasicBlock(BasicBlock *BB) = 0;
|
||||
|
||||
/// 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. See
|
||||
/// getPointerToFunction for the requirements on destroying F.
|
||||
///
|
||||
virtual void *getPointerToFunctionOrStub(Function *F) {
|
||||
// Default implementation, just codegen the function.
|
||||
return getPointerToFunction(F);
|
||||
@ -288,23 +302,25 @@ public:
|
||||
///
|
||||
const GlobalValue *getGlobalValueAtAddress(void *Addr);
|
||||
|
||||
|
||||
/// StoreValueToMemory - Stores the data in Val of type Ty at address Ptr.
|
||||
/// Ptr is the address of the memory at which to store Val, cast to
|
||||
/// GenericValue *. It is not a pointer to a GenericValue containing the
|
||||
/// address at which to store Val.
|
||||
void StoreValueToMemory(const GenericValue &Val, GenericValue *Ptr,
|
||||
const Type *Ty);
|
||||
|
||||
void InitializeMemory(const Constant *Init, void *Addr);
|
||||
|
||||
/// recompileAndRelinkFunction - This method is used to force a function
|
||||
/// which has already been compiled to be compiled again, possibly
|
||||
/// after it has been modified. Then the entry to the old copy is overwritten
|
||||
/// with a branch to the new copy. If there was no old copy, this acts
|
||||
/// just like VM::getPointerToFunction().
|
||||
///
|
||||
/// recompileAndRelinkFunction - This method is used to force a function which
|
||||
/// has already been compiled to be compiled again, possibly after it has been
|
||||
/// modified. Then the entry to the old copy is overwritten with a branch to
|
||||
/// the new copy. If there was no old copy, this acts just like
|
||||
/// VM::getPointerToFunction().
|
||||
virtual void *recompileAndRelinkFunction(Function *F) = 0;
|
||||
|
||||
/// freeMachineCodeForFunction - Release memory in the ExecutionEngine
|
||||
/// corresponding to the machine code emitted to execute this function, useful
|
||||
/// for garbage-collecting generated code.
|
||||
///
|
||||
virtual void freeMachineCodeForFunction(Function *F) = 0;
|
||||
|
||||
/// getOrEmitGlobalVariable - Return the address of the specified global
|
||||
@ -382,8 +398,8 @@ public:
|
||||
ExceptionTableDeregister = F;
|
||||
}
|
||||
|
||||
/// RegisterTable - Registers the given pointer as an exception table. It uses
|
||||
/// the ExceptionTableRegister function.
|
||||
/// RegisterTable - Registers the given pointer as an exception table. It
|
||||
/// uses the ExceptionTableRegister function.
|
||||
void RegisterTable(void* res) {
|
||||
if (ExceptionTableRegister) {
|
||||
ExceptionTableRegister(res);
|
||||
@ -400,9 +416,6 @@ protected:
|
||||
|
||||
void emitGlobals();
|
||||
|
||||
// EmitGlobalVariable - This method emits the specified global variable to the
|
||||
// address specified in GlobalAddresses, or allocates new memory if it's not
|
||||
// already in the map.
|
||||
void EmitGlobalVariable(const GlobalVariable *GV);
|
||||
|
||||
GenericValue getConstantValue(const Constant *C);
|
||||
@ -423,8 +436,7 @@ namespace EngineKind {
|
||||
/// stack-allocating a builder, chaining the various set* methods, and
|
||||
/// terminating it with a .create() call.
|
||||
class EngineBuilder {
|
||||
|
||||
private:
|
||||
private:
|
||||
Module *M;
|
||||
EngineKind::Kind WhichEngine;
|
||||
std::string *ErrorStr;
|
||||
@ -437,7 +449,6 @@ class EngineBuilder {
|
||||
SmallVector<std::string, 4> MAttrs;
|
||||
|
||||
/// InitEngine - Does the common initialization of default options.
|
||||
///
|
||||
void InitEngine() {
|
||||
WhichEngine = EngineKind::Either;
|
||||
ErrorStr = NULL;
|
||||
@ -447,7 +458,7 @@ class EngineBuilder {
|
||||
CMModel = CodeModel::Default;
|
||||
}
|
||||
|
||||
public:
|
||||
public:
|
||||
/// EngineBuilder - Constructor for EngineBuilder. If create() is called and
|
||||
/// is successful, the created engine takes ownership of the module.
|
||||
EngineBuilder(Module *m) : M(m) {
|
||||
|
@ -19,6 +19,7 @@
|
||||
#include "llvm/DerivedTypes.h"
|
||||
#include "llvm/Module.h"
|
||||
#include "llvm/ExecutionEngine/GenericValue.h"
|
||||
#include "llvm/ADT/SmallString.h"
|
||||
#include "llvm/ADT/Statistic.h"
|
||||
#include "llvm/Support/Debug.h"
|
||||
#include "llvm/Support/ErrorHandling.h"
|
||||
@ -68,24 +69,23 @@ ExecutionEngine::~ExecutionEngine() {
|
||||
|
||||
void ExecutionEngine::DeregisterAllTables() {
|
||||
if (ExceptionTableDeregister) {
|
||||
std::vector<void*>::iterator it = AllExceptionTables.begin();
|
||||
std::vector<void*>::iterator ite = AllExceptionTables.end();
|
||||
for (; it != ite; ++it)
|
||||
for (std::vector<void*>::iterator it = AllExceptionTables.begin(),
|
||||
ie = AllExceptionTables.end(); it != ie; ++it)
|
||||
ExceptionTableDeregister(*it);
|
||||
AllExceptionTables.clear();
|
||||
}
|
||||
}
|
||||
|
||||
namespace {
|
||||
// This class automatically deletes the memory block when the GlobalVariable is
|
||||
// destroyed.
|
||||
/// \brief Helper class which uses a value handler to automatically deletes the
|
||||
/// memory block when the GlobalVariable is destroyed.
|
||||
class GVMemoryBlock : public CallbackVH {
|
||||
GVMemoryBlock(const GlobalVariable *GV)
|
||||
: CallbackVH(const_cast<GlobalVariable*>(GV)) {}
|
||||
|
||||
public:
|
||||
// Returns the address the GlobalVariable should be written into. The
|
||||
// GVMemoryBlock object prefixes that.
|
||||
/// \brief Returns the address the GlobalVariable should be written into. The
|
||||
/// GVMemoryBlock object prefixes that.
|
||||
static char *Create(const GlobalVariable *GV, const TargetData& TD) {
|
||||
const Type *ElTy = GV->getType()->getElementType();
|
||||
size_t GVSize = (size_t)TD.getTypeAllocSize(ElTy);
|
||||
@ -107,11 +107,10 @@ public:
|
||||
};
|
||||
} // anonymous namespace
|
||||
|
||||
char* ExecutionEngine::getMemoryForGV(const GlobalVariable* GV) {
|
||||
char *ExecutionEngine::getMemoryForGV(const GlobalVariable *GV) {
|
||||
return GVMemoryBlock::Create(GV, *getTargetData());
|
||||
}
|
||||
|
||||
/// removeModule - Remove a Module from the list of modules.
|
||||
bool ExecutionEngine::removeModule(Module *M) {
|
||||
for(SmallVector<Module *, 1>::iterator I = Modules.begin(),
|
||||
E = Modules.end(); I != E; ++I) {
|
||||
@ -125,9 +124,6 @@ bool ExecutionEngine::removeModule(Module *M) {
|
||||
return false;
|
||||
}
|
||||
|
||||
/// FindFunctionNamed - Search all of the active modules to find the one that
|
||||
/// defines FnName. This is very slow operation and shouldn't be used for
|
||||
/// general code.
|
||||
Function *ExecutionEngine::FindFunctionNamed(const char *FnName) {
|
||||
for (unsigned i = 0, e = Modules.size(); i != e; ++i) {
|
||||
if (Function *F = Modules[i]->getFunction(FnName))
|
||||
@ -137,10 +133,13 @@ Function *ExecutionEngine::FindFunctionNamed(const char *FnName) {
|
||||
}
|
||||
|
||||
|
||||
void *ExecutionEngineState::RemoveMapping(
|
||||
const MutexGuard &, const GlobalValue *ToUnmap) {
|
||||
void *ExecutionEngineState::RemoveMapping(const MutexGuard &,
|
||||
const GlobalValue *ToUnmap) {
|
||||
GlobalAddressMapTy::iterator I = GlobalAddressMap.find(ToUnmap);
|
||||
void *OldVal;
|
||||
|
||||
// FIXME: This is silly, we shouldn't end up with a mapping -> 0 in the
|
||||
// GlobalAddressMap.
|
||||
if (I == GlobalAddressMap.end())
|
||||
OldVal = 0;
|
||||
else {
|
||||
@ -152,11 +151,6 @@ void *ExecutionEngineState::RemoveMapping(
|
||||
return OldVal;
|
||||
}
|
||||
|
||||
/// addGlobalMapping - Tell the execution engine that the specified global is
|
||||
/// at the specified location. This is used internally as functions are JIT'd
|
||||
/// and as global variables are laid out in memory. It can and should also be
|
||||
/// used by clients of the EE that want to have an LLVM global overlay
|
||||
/// existing data in memory.
|
||||
void ExecutionEngine::addGlobalMapping(const GlobalValue *GV, void *Addr) {
|
||||
MutexGuard locked(lock);
|
||||
|
||||
@ -166,7 +160,7 @@ void ExecutionEngine::addGlobalMapping(const GlobalValue *GV, void *Addr) {
|
||||
assert((CurVal == 0 || Addr == 0) && "GlobalMapping already established!");
|
||||
CurVal = Addr;
|
||||
|
||||
// If we are using the reverse mapping, add it too
|
||||
// If we are using the reverse mapping, add it too.
|
||||
if (!EEState.getGlobalAddressReverseMap(locked).empty()) {
|
||||
AssertingVH<const GlobalValue> &V =
|
||||
EEState.getGlobalAddressReverseMap(locked)[Addr];
|
||||
@ -175,8 +169,6 @@ void ExecutionEngine::addGlobalMapping(const GlobalValue *GV, void *Addr) {
|
||||
}
|
||||
}
|
||||
|
||||
/// clearAllGlobalMappings - Clear all global mappings and start over again
|
||||
/// use in dynamic compilation scenarios when you want to move globals
|
||||
void ExecutionEngine::clearAllGlobalMappings() {
|
||||
MutexGuard locked(lock);
|
||||
|
||||
@ -184,23 +176,16 @@ void ExecutionEngine::clearAllGlobalMappings() {
|
||||
EEState.getGlobalAddressReverseMap(locked).clear();
|
||||
}
|
||||
|
||||
/// clearGlobalMappingsFromModule - Clear all global mappings that came from a
|
||||
/// particular module, because it has been removed from the JIT.
|
||||
void ExecutionEngine::clearGlobalMappingsFromModule(Module *M) {
|
||||
MutexGuard locked(lock);
|
||||
|
||||
for (Module::iterator FI = M->begin(), FE = M->end(); FI != FE; ++FI) {
|
||||
for (Module::iterator FI = M->begin(), FE = M->end(); FI != FE; ++FI)
|
||||
EEState.RemoveMapping(locked, FI);
|
||||
}
|
||||
for (Module::global_iterator GI = M->global_begin(), GE = M->global_end();
|
||||
GI != GE; ++GI) {
|
||||
GI != GE; ++GI)
|
||||
EEState.RemoveMapping(locked, GI);
|
||||
}
|
||||
}
|
||||
|
||||
/// updateGlobalMapping - Replace an existing mapping for GV with a new
|
||||
/// address. This updates both maps as required. If "Addr" is null, the
|
||||
/// entry for the global is removed from the mappings.
|
||||
void *ExecutionEngine::updateGlobalMapping(const GlobalValue *GV, void *Addr) {
|
||||
MutexGuard locked(lock);
|
||||
|
||||
@ -208,9 +193,8 @@ void *ExecutionEngine::updateGlobalMapping(const GlobalValue *GV, void *Addr) {
|
||||
EEState.getGlobalAddressMap(locked);
|
||||
|
||||
// Deleting from the mapping?
|
||||
if (Addr == 0) {
|
||||
if (Addr == 0)
|
||||
return EEState.RemoveMapping(locked, GV);
|
||||
}
|
||||
|
||||
void *&CurVal = Map[GV];
|
||||
void *OldVal = CurVal;
|
||||
@ -219,7 +203,7 @@ void *ExecutionEngine::updateGlobalMapping(const GlobalValue *GV, void *Addr) {
|
||||
EEState.getGlobalAddressReverseMap(locked).erase(CurVal);
|
||||
CurVal = Addr;
|
||||
|
||||
// If we are using the reverse mapping, add it too
|
||||
// If we are using the reverse mapping, add it too.
|
||||
if (!EEState.getGlobalAddressReverseMap(locked).empty()) {
|
||||
AssertingVH<const GlobalValue> &V =
|
||||
EEState.getGlobalAddressReverseMap(locked)[Addr];
|
||||
@ -229,9 +213,6 @@ void *ExecutionEngine::updateGlobalMapping(const GlobalValue *GV, void *Addr) {
|
||||
return OldVal;
|
||||
}
|
||||
|
||||
/// getPointerToGlobalIfAvailable - This returns the address of the specified
|
||||
/// global value if it is has already been codegen'd, otherwise it returns null.
|
||||
///
|
||||
void *ExecutionEngine::getPointerToGlobalIfAvailable(const GlobalValue *GV) {
|
||||
MutexGuard locked(lock);
|
||||
|
||||
@ -240,9 +221,6 @@ void *ExecutionEngine::getPointerToGlobalIfAvailable(const GlobalValue *GV) {
|
||||
return I != EEState.getGlobalAddressMap(locked).end() ? I->second : 0;
|
||||
}
|
||||
|
||||
/// getGlobalValueAtAddress - Return the LLVM global value object that starts
|
||||
/// at the specified address.
|
||||
///
|
||||
const GlobalValue *ExecutionEngine::getGlobalValueAtAddress(void *Addr) {
|
||||
MutexGuard locked(lock);
|
||||
|
||||
@ -311,16 +289,9 @@ void *ArgvArray::reset(LLVMContext &C, ExecutionEngine *EE,
|
||||
return Array;
|
||||
}
|
||||
|
||||
|
||||
/// runStaticConstructorsDestructors - This method is used to execute all of
|
||||
/// the static constructors or destructors for a module, depending on the
|
||||
/// value of isDtors.
|
||||
void ExecutionEngine::runStaticConstructorsDestructors(Module *module,
|
||||
bool isDtors) {
|
||||
const char *Name = isDtors ? "llvm.global_dtors" : "llvm.global_ctors";
|
||||
|
||||
// Execute global ctors/dtors for each module in the program.
|
||||
|
||||
GlobalVariable *GV = module->getNamedGlobal(Name);
|
||||
|
||||
// If this global has internal linkage, or if it has a use, then it must be
|
||||
@ -333,32 +304,35 @@ void ExecutionEngine::runStaticConstructorsDestructors(Module *module,
|
||||
// the init priority, which we ignore.
|
||||
ConstantArray *InitList = dyn_cast<ConstantArray>(GV->getInitializer());
|
||||
if (!InitList) return;
|
||||
for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i)
|
||||
if (ConstantStruct *CS =
|
||||
dyn_cast<ConstantStruct>(InitList->getOperand(i))) {
|
||||
for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i) {
|
||||
ConstantStruct *CS =
|
||||
dyn_cast<ConstantStruct>(InitList->getOperand(i));
|
||||
if (!CS) continue;
|
||||
if (CS->getNumOperands() != 2) return; // Not array of 2-element structs.
|
||||
|
||||
Constant *FP = CS->getOperand(1);
|
||||
if (FP->isNullValue())
|
||||
break; // Found a null terminator, exit.
|
||||
|
||||
// Strip off constant expression casts.
|
||||
if (ConstantExpr *CE = dyn_cast<ConstantExpr>(FP))
|
||||
if (CE->isCast())
|
||||
FP = CE->getOperand(0);
|
||||
if (Function *F = dyn_cast<Function>(FP)) {
|
||||
|
||||
// Execute the ctor/dtor function!
|
||||
if (Function *F = dyn_cast<Function>(FP))
|
||||
runFunction(F, std::vector<GenericValue>());
|
||||
}
|
||||
|
||||
// FIXME: It is marginally lame that we just do nothing here if we see an
|
||||
// entry we don't recognize. It might not be unreasonable for the verifier
|
||||
// to not even allow this and just assert here.
|
||||
}
|
||||
}
|
||||
|
||||
/// runStaticConstructorsDestructors - This method is used to execute all of
|
||||
/// the static constructors or destructors for a program, depending on the
|
||||
/// value of isDtors.
|
||||
void ExecutionEngine::runStaticConstructorsDestructors(bool isDtors) {
|
||||
// Execute global ctors/dtors for each module in the program.
|
||||
for (unsigned m = 0, e = Modules.size(); m != e; ++m)
|
||||
runStaticConstructorsDestructors(Modules[m], isDtors);
|
||||
for (unsigned i = 0, e = Modules.size(); i != e; ++i)
|
||||
runStaticConstructorsDestructors(Modules[i], isDtors);
|
||||
}
|
||||
|
||||
#ifndef NDEBUG
|
||||
@ -372,9 +346,6 @@ static bool isTargetNullPtr(ExecutionEngine *EE, void *Loc) {
|
||||
}
|
||||
#endif
|
||||
|
||||
/// runFunctionAsMain - This is a helper function which wraps runFunction to
|
||||
/// handle the common task of starting up main with the specified argc, argv,
|
||||
/// and envp parameters.
|
||||
int ExecutionEngine::runFunctionAsMain(Function *Fn,
|
||||
const std::vector<std::string> &argv,
|
||||
const char * const * envp) {
|
||||
@ -386,31 +357,19 @@ int ExecutionEngine::runFunctionAsMain(Function *Fn,
|
||||
unsigned NumArgs = Fn->getFunctionType()->getNumParams();
|
||||
const FunctionType *FTy = Fn->getFunctionType();
|
||||
const Type* PPInt8Ty = Type::getInt8PtrTy(Fn->getContext())->getPointerTo();
|
||||
switch (NumArgs) {
|
||||
case 3:
|
||||
if (FTy->getParamType(2) != PPInt8Ty) {
|
||||
report_fatal_error("Invalid type for third argument of main() supplied");
|
||||
}
|
||||
// FALLS THROUGH
|
||||
case 2:
|
||||
if (FTy->getParamType(1) != PPInt8Ty) {
|
||||
report_fatal_error("Invalid type for second argument of main() supplied");
|
||||
}
|
||||
// FALLS THROUGH
|
||||
case 1:
|
||||
if (!FTy->getParamType(0)->isIntegerTy(32)) {
|
||||
report_fatal_error("Invalid type for first argument of main() supplied");
|
||||
}
|
||||
// FALLS THROUGH
|
||||
case 0:
|
||||
if (!FTy->getReturnType()->isIntegerTy() &&
|
||||
!FTy->getReturnType()->isVoidTy()) {
|
||||
report_fatal_error("Invalid return type of main() supplied");
|
||||
}
|
||||
break;
|
||||
default:
|
||||
|
||||
// Check the argument types.
|
||||
if (NumArgs > 3)
|
||||
report_fatal_error("Invalid number of arguments of main() supplied");
|
||||
}
|
||||
if (NumArgs >= 3 && FTy->getParamType(2) != PPInt8Ty)
|
||||
report_fatal_error("Invalid type for third argument of main() supplied");
|
||||
if (NumArgs >= 2 && FTy->getParamType(1) != PPInt8Ty)
|
||||
report_fatal_error("Invalid type for second argument of main() supplied");
|
||||
if (NumArgs >= 1 && !FTy->getParamType(0)->isIntegerTy(32))
|
||||
report_fatal_error("Invalid type for first argument of main() supplied");
|
||||
if (!FTy->getReturnType()->isIntegerTy() &&
|
||||
!FTy->getReturnType()->isVoidTy())
|
||||
report_fatal_error("Invalid return type of main() supplied");
|
||||
|
||||
ArgvArray CArgv;
|
||||
ArgvArray CEnv;
|
||||
@ -430,13 +389,10 @@ int ExecutionEngine::runFunctionAsMain(Function *Fn,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return runFunction(Fn, GVArgs).IntVal.getZExtValue();
|
||||
}
|
||||
|
||||
/// If possible, create a JIT, unless the caller specifically requests an
|
||||
/// Interpreter or there's an error. If even an Interpreter cannot be created,
|
||||
/// NULL is returned.
|
||||
///
|
||||
ExecutionEngine *ExecutionEngine::create(Module *M,
|
||||
bool ForceInterpreter,
|
||||
std::string *ErrorStr,
|
||||
@ -497,20 +453,17 @@ ExecutionEngine *EngineBuilder::create() {
|
||||
if (ErrorStr)
|
||||
*ErrorStr = "JIT has not been linked in.";
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/// getPointerToGlobal - This returns the address of the specified global
|
||||
/// value. This may involve code generation if it's a function.
|
||||
///
|
||||
void *ExecutionEngine::getPointerToGlobal(const GlobalValue *GV) {
|
||||
if (Function *F = const_cast<Function*>(dyn_cast<Function>(GV)))
|
||||
return getPointerToFunction(F);
|
||||
|
||||
MutexGuard locked(lock);
|
||||
void *p = EEState.getGlobalAddressMap(locked)[GV];
|
||||
if (p)
|
||||
return p;
|
||||
if (void *P = EEState.getGlobalAddressMap(locked)[GV])
|
||||
return P;
|
||||
|
||||
// Global variable might have been added since interpreter started.
|
||||
if (GlobalVariable *GVar =
|
||||
@ -518,12 +471,12 @@ void *ExecutionEngine::getPointerToGlobal(const GlobalValue *GV) {
|
||||
EmitGlobalVariable(GVar);
|
||||
else
|
||||
llvm_unreachable("Global hasn't had an address allocated yet!");
|
||||
|
||||
return EEState.getGlobalAddressMap(locked)[GV];
|
||||
}
|
||||
|
||||
/// This function converts a Constant* into a GenericValue. The interesting
|
||||
/// part is if C is a ConstantExpr.
|
||||
/// @brief Get a GenericValue for a Constant*
|
||||
/// \brief Converts a Constant* into a GenericValue, including handling of
|
||||
/// ConstantExpr values.
|
||||
GenericValue ExecutionEngine::getConstantValue(const Constant *C) {
|
||||
// If its undefined, return the garbage.
|
||||
if (isa<UndefValue>(C)) {
|
||||
@ -543,7 +496,7 @@ GenericValue ExecutionEngine::getConstantValue(const Constant *C) {
|
||||
return Result;
|
||||
}
|
||||
|
||||
// If the value is a ConstantExpr
|
||||
// Otherwise, if the value is a ConstantExpr...
|
||||
if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) {
|
||||
Constant *Op0 = CE->getOperand(0);
|
||||
switch (CE->getOpcode()) {
|
||||
@ -778,12 +731,14 @@ GenericValue ExecutionEngine::getConstantValue(const Constant *C) {
|
||||
default:
|
||||
break;
|
||||
}
|
||||
std::string msg;
|
||||
raw_string_ostream Msg(msg);
|
||||
Msg << "ConstantExpr not handled: " << *CE;
|
||||
report_fatal_error(Msg.str());
|
||||
|
||||
SmallString<256> Msg;
|
||||
raw_svector_ostream OS(Msg);
|
||||
OS << "ConstantExpr not handled: " << *CE;
|
||||
report_fatal_error(OS.str());
|
||||
}
|
||||
|
||||
// Otherwise, we have a simple constant.
|
||||
GenericValue Result;
|
||||
switch (C->getType()->getTypeID()) {
|
||||
case Type::FloatTyID:
|
||||
@ -814,11 +769,12 @@ GenericValue ExecutionEngine::getConstantValue(const Constant *C) {
|
||||
llvm_unreachable("Unknown constant pointer type!");
|
||||
break;
|
||||
default:
|
||||
std::string msg;
|
||||
raw_string_ostream Msg(msg);
|
||||
Msg << "ERROR: Constant unimplemented for type: " << *C->getType();
|
||||
report_fatal_error(Msg.str());
|
||||
SmallString<256> Msg;
|
||||
raw_svector_ostream OS(Msg);
|
||||
OS << "ERROR: Constant unimplemented for type: " << *C->getType();
|
||||
report_fatal_error(OS.str());
|
||||
}
|
||||
|
||||
return Result;
|
||||
}
|
||||
|
||||
@ -829,11 +785,11 @@ static void StoreIntToMemory(const APInt &IntVal, uint8_t *Dst,
|
||||
assert((IntVal.getBitWidth()+7)/8 >= StoreBytes && "Integer too small!");
|
||||
uint8_t *Src = (uint8_t *)IntVal.getRawData();
|
||||
|
||||
if (sys::isLittleEndianHost())
|
||||
if (sys::isLittleEndianHost()) {
|
||||
// Little-endian host - the source is ordered from LSB to MSB. Order the
|
||||
// destination from LSB to MSB: Do a straight copy.
|
||||
memcpy(Dst, Src, StoreBytes);
|
||||
else {
|
||||
} else {
|
||||
// Big-endian host - the source is an array of 64 bit words ordered from
|
||||
// LSW to MSW. Each word is ordered from MSB to LSB. Order the destination
|
||||
// from MSB to LSB: Reverse the word order, but not the bytes in a word.
|
||||
@ -848,10 +804,6 @@ static void StoreIntToMemory(const APInt &IntVal, uint8_t *Dst,
|
||||
}
|
||||
}
|
||||
|
||||
/// StoreValueToMemory - Stores the data in Val of type Ty at address Ptr. Ptr
|
||||
/// is the address of the memory at which to store Val, cast to GenericValue *.
|
||||
/// It is not a pointer to a GenericValue containing the address at which to
|
||||
/// store Val.
|
||||
void ExecutionEngine::StoreValueToMemory(const GenericValue &Val,
|
||||
GenericValue *Ptr, const Type *Ty) {
|
||||
const unsigned StoreBytes = getTargetData()->getTypeStoreSize(Ty);
|
||||
@ -942,16 +894,13 @@ void ExecutionEngine::LoadValueFromMemory(GenericValue &Result,
|
||||
break;
|
||||
}
|
||||
default:
|
||||
std::string msg;
|
||||
raw_string_ostream Msg(msg);
|
||||
Msg << "Cannot load value of type " << *Ty << "!";
|
||||
report_fatal_error(Msg.str());
|
||||
SmallString<256> Msg;
|
||||
raw_svector_ostream OS(Msg);
|
||||
OS << "Cannot load value of type " << *Ty << "!";
|
||||
report_fatal_error(OS.str());
|
||||
}
|
||||
}
|
||||
|
||||
// InitializeMemory - Recursive function to apply a Constant value into the
|
||||
// specified memory location...
|
||||
//
|
||||
void ExecutionEngine::InitializeMemory(const Constant *Init, void *Addr) {
|
||||
DEBUG(dbgs() << "JIT: Initializing " << Addr << " ");
|
||||
DEBUG(Init->dump());
|
||||
@ -984,20 +933,17 @@ void ExecutionEngine::InitializeMemory(const Constant *Init, void *Addr) {
|
||||
return;
|
||||
}
|
||||
|
||||
dbgs() << "Bad Type: " << *Init->getType() << "\n";
|
||||
DEBUG(dbgs() << "Bad Type: " << *Init->getType() << "\n");
|
||||
llvm_unreachable("Unknown constant type to initialize memory with!");
|
||||
}
|
||||
|
||||
/// EmitGlobals - Emit all of the global variables to memory, storing their
|
||||
/// addresses into GlobalAddress. This must make sure to copy the contents of
|
||||
/// their initializers into the memory.
|
||||
///
|
||||
void ExecutionEngine::emitGlobals() {
|
||||
|
||||
// Loop over all of the global variables in the program, allocating the memory
|
||||
// to hold them. If there is more than one module, do a prepass over globals
|
||||
// to figure out how the different modules should link together.
|
||||
//
|
||||
std::map<std::pair<std::string, const Type*>,
|
||||
const GlobalValue*> LinkedGlobalsMap;
|
||||
|
||||
@ -1123,18 +1069,20 @@ ExecutionEngineState::ExecutionEngineState(ExecutionEngine &EE)
|
||||
: EE(EE), GlobalAddressMap(this) {
|
||||
}
|
||||
|
||||
sys::Mutex *ExecutionEngineState::AddressMapConfig::getMutex(
|
||||
ExecutionEngineState *EES) {
|
||||
sys::Mutex *
|
||||
ExecutionEngineState::AddressMapConfig::getMutex(ExecutionEngineState *EES) {
|
||||
return &EES->EE.lock;
|
||||
}
|
||||
void ExecutionEngineState::AddressMapConfig::onDelete(
|
||||
ExecutionEngineState *EES, const GlobalValue *Old) {
|
||||
|
||||
void ExecutionEngineState::AddressMapConfig::onDelete(ExecutionEngineState *EES,
|
||||
const GlobalValue *Old) {
|
||||
void *OldVal = EES->GlobalAddressMap.lookup(Old);
|
||||
EES->GlobalAddressReverseMap.erase(OldVal);
|
||||
}
|
||||
|
||||
void ExecutionEngineState::AddressMapConfig::onRAUW(
|
||||
ExecutionEngineState *, const GlobalValue *, const GlobalValue *) {
|
||||
void ExecutionEngineState::AddressMapConfig::onRAUW(ExecutionEngineState *,
|
||||
const GlobalValue *,
|
||||
const GlobalValue *) {
|
||||
assert(false && "The ExecutionEngine doesn't know how to handle a"
|
||||
" RAUW on a value it has a global mapping for.");
|
||||
}
|
||||
|
Loading…
Reference in New Issue
Block a user