diff --git a/include/llvm/ExecutionEngine/ExecutionEngine.h b/include/llvm/ExecutionEngine/ExecutionEngine.h index 752c92f47c7..0e51271c6f2 100644 --- a/include/llvm/ExecutionEngine/ExecutionEngine.h +++ b/include/llvm/ExecutionEngine/ExecutionEngine.h @@ -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 { @@ -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 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 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 &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. - /// + /// 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); @@ -392,7 +408,7 @@ public: } /// DeregisterAllTables - Deregisters all previously registered pointers to an - /// exception tables. It uses the ExceptionTableoDeregister function. + /// exception tables. It uses the ExceptionTableoDeregister function. void DeregisterAllTables(); protected: @@ -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 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) { diff --git a/lib/ExecutionEngine/ExecutionEngine.cpp b/lib/ExecutionEngine/ExecutionEngine.cpp index 275f02e34c2..fc5cb926e3b 100644 --- a/lib/ExecutionEngine/ExecutionEngine.cpp +++ b/lib/ExecutionEngine/ExecutionEngine.cpp @@ -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" @@ -51,7 +52,7 @@ ExecutionEngine *(*ExecutionEngine::InterpCtor)(Module *M, ExecutionEngine::ExecutionEngine(Module *M) : EEState(*this), LazyFunctionCreator(0), - ExceptionTableRegister(0), + ExceptionTableRegister(0), ExceptionTableDeregister(0) { CompilingLazily = false; GVCompilationDisabled = false; @@ -68,24 +69,23 @@ ExecutionEngine::~ExecutionEngine() { void ExecutionEngine::DeregisterAllTables() { if (ExceptionTableDeregister) { - std::vector::iterator it = AllExceptionTables.begin(); - std::vector::iterator ite = AllExceptionTables.end(); - for (; it != ite; ++it) + for (std::vector::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(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,13 +107,12 @@ 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::iterator I = Modules.begin(), + for(SmallVector::iterator I = Modules.begin(), E = Modules.end(); I != E; ++I) { Module *Found = *I; if (Found == M) { @@ -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,21 +151,16 @@ 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); - DEBUG(dbgs() << "JIT: Map \'" << GV->getName() + DEBUG(dbgs() << "JIT: Map \'" << GV->getName() << "\' to [" << Addr << "]\n";); void *&CurVal = EEState.getGlobalAddressMap(locked)[GV]; 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 &V = EEState.getGlobalAddressReverseMap(locked)[Addr]; @@ -175,32 +169,23 @@ 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); - + EEState.getGlobalAddressMap(locked).clear(); 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) { + for (Module::global_iterator GI = M->global_begin(), GE = M->global_end(); + 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,18 +193,17 @@ 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; if (CurVal && !EEState.getGlobalAddressReverseMap(locked).empty()) 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 &V = EEState.getGlobalAddressReverseMap(locked)[Addr]; @@ -229,20 +213,14 @@ 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); - + ExecutionEngineState::GlobalAddressMapTy::iterator I = EEState.getGlobalAddressMap(locked).find(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,54 +289,50 @@ 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); + GlobalVariable *GV = module->getNamedGlobal(Name); - // If this global has internal linkage, or if it has a use, then it must be - // an old-style (llvmgcc3) static ctor with __main linked in and in use. If - // this is the case, don't execute any of the global ctors, __main will do - // it. - if (!GV || GV->isDeclaration() || GV->hasLocalLinkage()) return; - - // Should be an array of '{ int, void ()* }' structs. The first value is - // the init priority, which we ignore. - ConstantArray *InitList = dyn_cast(GV->getInitializer()); - if (!InitList) return; - for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i) - if (ConstantStruct *CS = - dyn_cast(InitList->getOperand(i))) { - 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. - - if (ConstantExpr *CE = dyn_cast(FP)) - if (CE->isCast()) - FP = CE->getOperand(0); - if (Function *F = dyn_cast(FP)) { - // Execute the ctor/dtor function! - runFunction(F, std::vector()); - } - } + // If this global has internal linkage, or if it has a use, then it must be + // an old-style (llvmgcc3) static ctor with __main linked in and in use. If + // this is the case, don't execute any of the global ctors, __main will do + // it. + if (!GV || GV->isDeclaration() || GV->hasLocalLinkage()) return; + + // Should be an array of '{ int, void ()* }' structs. The first value is + // the init priority, which we ignore. + ConstantArray *InitList = dyn_cast(GV->getInitializer()); + if (!InitList) return; + for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i) { + ConstantStruct *CS = + dyn_cast(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(FP)) + if (CE->isCast()) + FP = CE->getOperand(0); + + // Execute the ctor/dtor function! + if (Function *F = dyn_cast(FP)) + runFunction(F, std::vector()); + + // 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 &argv, const char * const * envp) { @@ -386,32 +357,20 @@ 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: - report_fatal_error("Invalid number of arguments of main() supplied"); - } - + + // 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; if (NumArgs) { @@ -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, @@ -496,21 +452,18 @@ ExecutionEngine *EngineBuilder::create() { if ((WhichEngine & EngineKind::JIT) && ExecutionEngine::JITCtor == 0) { 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(dyn_cast(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(C)) { @@ -543,12 +496,12 @@ 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(C)) { Constant *Op0 = CE->getOperand(0); switch (CE->getOpcode()) { case Instruction::GetElementPtr: { - // Compute the index + // Compute the index GenericValue Result = getConstantValue(Op0); SmallVector Indices(CE->op_begin()+1, CE->op_end()); uint64_t Offset = @@ -597,7 +550,7 @@ GenericValue ExecutionEngine::getConstantValue(const Constant *C) { else if (CE->getType()->isX86_FP80Ty()) { const uint64_t zero[] = {0, 0}; APFloat apf = APFloat(APInt(80, 2, zero)); - (void)apf.convertFromAPInt(GV.IntVal, + (void)apf.convertFromAPInt(GV.IntVal, false, APFloat::rmNearestTiesToEven); GV.IntVal = apf.bitcastToAPInt(); @@ -613,7 +566,7 @@ GenericValue ExecutionEngine::getConstantValue(const Constant *C) { else if (CE->getType()->isX86_FP80Ty()) { const uint64_t zero[] = { 0, 0}; APFloat apf = APFloat(APInt(80, 2, zero)); - (void)apf.convertFromAPInt(GV.IntVal, + (void)apf.convertFromAPInt(GV.IntVal, true, APFloat::rmNearestTiesToEven); GV.IntVal = apf.bitcastToAPInt(); @@ -633,7 +586,7 @@ GenericValue ExecutionEngine::getConstantValue(const Constant *C) { uint64_t v; bool ignored; (void)apf.convertToInteger(&v, BitWidth, - CE->getOpcode()==Instruction::FPToSI, + CE->getOpcode()==Instruction::FPToSI, APFloat::rmTowardZero, &ignored); GV.IntVal = v; // endian? } @@ -666,7 +619,7 @@ GenericValue ExecutionEngine::getConstantValue(const Constant *C) { else if (DestTy->isDoubleTy()) GV.DoubleVal = GV.IntVal.bitsToDouble(); break; - case Type::FloatTyID: + case Type::FloatTyID: assert(DestTy->isIntegerTy(32) && "Invalid bitcast"); GV.IntVal.floatToBits(GV.FloatVal); break; @@ -722,9 +675,9 @@ GenericValue ExecutionEngine::getConstantValue(const Constant *C) { GV.FloatVal = LHS.FloatVal - RHS.FloatVal; break; case Instruction::FMul: GV.FloatVal = LHS.FloatVal * RHS.FloatVal; break; - case Instruction::FDiv: + case Instruction::FDiv: GV.FloatVal = LHS.FloatVal / RHS.FloatVal; break; - case Instruction::FRem: + case Instruction::FRem: GV.FloatVal = std::fmod(LHS.FloatVal,RHS.FloatVal); break; } break; @@ -737,9 +690,9 @@ GenericValue ExecutionEngine::getConstantValue(const Constant *C) { GV.DoubleVal = LHS.DoubleVal - RHS.DoubleVal; break; case Instruction::FMul: GV.DoubleVal = LHS.DoubleVal * RHS.DoubleVal; break; - case Instruction::FDiv: + case Instruction::FDiv: GV.DoubleVal = LHS.DoubleVal / RHS.DoubleVal; break; - case Instruction::FRem: + case Instruction::FRem: GV.DoubleVal = std::fmod(LHS.DoubleVal,RHS.DoubleVal); break; } break; @@ -761,11 +714,11 @@ GenericValue ExecutionEngine::getConstantValue(const Constant *C) { apfLHS.multiply(APFloat(RHS.IntVal), APFloat::rmNearestTiesToEven); GV.IntVal = apfLHS.bitcastToAPInt(); break; - case Instruction::FDiv: + case Instruction::FDiv: apfLHS.divide(APFloat(RHS.IntVal), APFloat::rmNearestTiesToEven); GV.IntVal = apfLHS.bitcastToAPInt(); break; - case Instruction::FRem: + case Instruction::FRem: apfLHS.mod(APFloat(RHS.IntVal), APFloat::rmNearestTiesToEven); GV.IntVal = apfLHS.bitcastToAPInt(); break; @@ -778,16 +731,18 @@ 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: - Result.FloatVal = cast(C)->getValueAPF().convertToFloat(); + case Type::FloatTyID: + Result.FloatVal = cast(C)->getValueAPF().convertToFloat(); break; case Type::DoubleTyID: Result.DoubleVal = cast(C)->getValueAPF().convertToDouble(); @@ -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, const GlobalValue*> LinkedGlobalsMap; @@ -1010,8 +956,8 @@ void ExecutionEngine::emitGlobals() { if (GV->hasLocalLinkage() || GV->isDeclaration() || GV->hasAppendingLinkage() || !GV->hasName()) continue;// Ignore external globals and globals with internal linkage. - - const GlobalValue *&GVEntry = + + const GlobalValue *&GVEntry = LinkedGlobalsMap[std::make_pair(GV->getName(), GV->getType())]; // If this is the first time we've seen this global, it is the canonical @@ -1020,13 +966,13 @@ void ExecutionEngine::emitGlobals() { GVEntry = GV; continue; } - + // If the existing global is strong, never replace it. if (GVEntry->hasExternalLinkage() || GVEntry->hasDLLImportLinkage() || GVEntry->hasDLLExportLinkage()) continue; - + // Otherwise, we know it's linkonce/weak, replace it if this is a strong // symbol. FIXME is this right for common? if (GV->hasExternalLinkage() || GVEntry->hasExternalWeakLinkage()) @@ -1034,7 +980,7 @@ void ExecutionEngine::emitGlobals() { } } } - + std::vector NonCanonicalGlobals; for (unsigned m = 0, e = Modules.size(); m != e; ++m) { Module &M = *Modules[m]; @@ -1042,7 +988,7 @@ void ExecutionEngine::emitGlobals() { I != E; ++I) { // In the multi-module case, see what this global maps to. if (!LinkedGlobalsMap.empty()) { - if (const GlobalValue *GVEntry = + if (const GlobalValue *GVEntry = LinkedGlobalsMap[std::make_pair(I->getName(), I->getType())]) { // If something else is the canonical global, ignore this one. if (GVEntry != &*I) { @@ -1051,7 +997,7 @@ void ExecutionEngine::emitGlobals() { } } } - + if (!I->isDeclaration()) { addGlobalMapping(I, getMemoryForGV(I)); } else { @@ -1066,7 +1012,7 @@ void ExecutionEngine::emitGlobals() { } } } - + // If there are multiple modules, map the non-canonical globals to their // canonical location. if (!NonCanonicalGlobals.empty()) { @@ -1079,14 +1025,14 @@ void ExecutionEngine::emitGlobals() { addGlobalMapping(GV, Ptr); } } - - // Now that all of the globals are set up in memory, loop through them all + + // Now that all of the globals are set up in memory, loop through them all // and initialize their contents. for (Module::const_global_iterator I = M.global_begin(), E = M.global_end(); I != E; ++I) { if (!I->isDeclaration()) { if (!LinkedGlobalsMap.empty()) { - if (const GlobalValue *GVEntry = + if (const GlobalValue *GVEntry = LinkedGlobalsMap[std::make_pair(I->getName(), I->getType())]) if (GVEntry != &*I) // Not the canonical variable. continue; @@ -1108,11 +1054,11 @@ void ExecutionEngine::EmitGlobalVariable(const GlobalVariable *GV) { GA = getMemoryForGV(GV); addGlobalMapping(GV, GA); } - + // Don't initialize if it's thread local, let the client do it. if (!GV->isThreadLocal()) InitializeMemory(GV->getInitializer(), GA); - + const Type *ElTy = GV->getType()->getElementType(); size_t GVSize = (size_t)getTargetData()->getTypeAllocSize(ElTy); NumInitBytes += (unsigned)GVSize; @@ -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."); }