X-Git-Url: http://plrg.eecs.uci.edu/git/?p=oota-llvm.git;a=blobdiff_plain;f=lib%2FExecutionEngine%2FExecutionEngine.cpp;h=226cd4fea0a8687473f9778a28ca7d939bb3eaf9;hp=d89a9bb4ac7e15122bc29ceeb66d6032e1cf4f6a;hb=c25e7581b9b8088910da31702d4ca21c4734c6d7;hpb=d958a5a9feea7239a73c2068f43f237db550f46e diff --git a/lib/ExecutionEngine/ExecutionEngine.cpp b/lib/ExecutionEngine/ExecutionEngine.cpp index d89a9bb4ac7..226cd4fea0a 100644 --- a/lib/ExecutionEngine/ExecutionEngine.cpp +++ b/lib/ExecutionEngine/ExecutionEngine.cpp @@ -2,8 +2,8 @@ // // 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. // //===----------------------------------------------------------------------===// // @@ -18,13 +18,18 @@ #include "llvm/Module.h" #include "llvm/ModuleProvider.h" #include "llvm/ADT/Statistic.h" +#include "llvm/Config/alloca.h" #include "llvm/ExecutionEngine/ExecutionEngine.h" #include "llvm/ExecutionEngine/GenericValue.h" #include "llvm/Support/Debug.h" +#include "llvm/Support/ErrorHandling.h" #include "llvm/Support/MutexGuard.h" +#include "llvm/Support/raw_ostream.h" #include "llvm/System/DynamicLibrary.h" +#include "llvm/System/Host.h" #include "llvm/Target/TargetData.h" -#include +#include +#include using namespace llvm; STATISTIC(NumInitBytes, "Number of bytes of global vars initialized"); @@ -32,27 +37,33 @@ STATISTIC(NumGlobals , "Number of global vars initialized"); ExecutionEngine::EECtorFn ExecutionEngine::JITCtor = 0; ExecutionEngine::EECtorFn ExecutionEngine::InterpCtor = 0; +ExecutionEngine::EERegisterFn ExecutionEngine::ExceptionTableRegister = 0; + ExecutionEngine::ExecutionEngine(ModuleProvider *P) : LazyFunctionCreator(0) { LazyCompilationDisabled = false; + GVCompilationDisabled = false; + SymbolSearchingDisabled = false; + DlsymStubsEnabled = false; Modules.push_back(P); assert(P && "ModuleProvider is null?"); } -ExecutionEngine::ExecutionEngine(Module *M) : LazyFunctionCreator(0) { - LazyCompilationDisabled = false; - assert(M && "Module is null?"); - Modules.push_back(new ExistingModuleProvider(M)); -} - ExecutionEngine::~ExecutionEngine() { clearAllGlobalMappings(); for (unsigned i = 0, e = Modules.size(); i != e; ++i) delete Modules[i]; } +char* ExecutionEngine::getMemoryForGV(const GlobalVariable* GV) { + const Type *ElTy = GV->getType()->getElementType(); + size_t GVSize = (size_t)getTargetData()->getTypeAllocSize(ElTy); + return new char[GVSize]; +} + /// removeModuleProvider - Remove a ModuleProvider from the list of modules. -/// Release module from ModuleProvider. +/// Relases the Module from the ModuleProvider, materializing it in the +/// process, and returns the materialized Module. Module* ExecutionEngine::removeModuleProvider(ModuleProvider *P, std::string *ErrInfo) { for(SmallVector::iterator I = Modules.begin(), @@ -60,12 +71,30 @@ Module* ExecutionEngine::removeModuleProvider(ModuleProvider *P, ModuleProvider *MP = *I; if (MP == P) { Modules.erase(I); + clearGlobalMappingsFromModule(MP->getModule()); return MP->releaseModule(ErrInfo); } } return NULL; } +/// deleteModuleProvider - Remove a ModuleProvider from the list of modules, +/// and deletes the ModuleProvider and owned Module. Avoids materializing +/// the underlying module. +void ExecutionEngine::deleteModuleProvider(ModuleProvider *P, + std::string *ErrInfo) { + for(SmallVector::iterator I = Modules.begin(), + E = Modules.end(); I != E; ++I) { + ModuleProvider *MP = *I; + if (MP == P) { + Modules.erase(I); + clearGlobalMappingsFromModule(MP->getModule()); + delete MP; + return; + } + } +} + /// 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. @@ -85,7 +114,8 @@ Function *ExecutionEngine::FindFunctionNamed(const char *FnName) { /// existing data in memory. void ExecutionEngine::addGlobalMapping(const GlobalValue *GV, void *Addr) { MutexGuard locked(lock); - + + DOUT << "JIT: Map \'" << GV->getNameStart() << "\' to [" << Addr << "]\n"; void *&CurVal = state.getGlobalAddressMap(locked)[GV]; assert((CurVal == 0 || Addr == 0) && "GlobalMapping already established!"); CurVal = Addr; @@ -107,21 +137,49 @@ void ExecutionEngine::clearAllGlobalMappings() { state.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) { + state.getGlobalAddressMap(locked).erase(FI); + state.getGlobalAddressReverseMap(locked).erase(FI); + } + for (Module::global_iterator GI = M->global_begin(), GE = M->global_end(); + GI != GE; ++GI) { + state.getGlobalAddressMap(locked).erase(GI); + state.getGlobalAddressReverseMap(locked).erase(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) { +void *ExecutionEngine::updateGlobalMapping(const GlobalValue *GV, void *Addr) { MutexGuard locked(lock); - + + std::map &Map = state.getGlobalAddressMap(locked); + // Deleting from the mapping? if (Addr == 0) { - state.getGlobalAddressMap(locked).erase(GV); + std::map::iterator I = Map.find(GV); + void *OldVal; + if (I == Map.end()) + OldVal = 0; + else { + OldVal = I->second; + Map.erase(I); + } + if (!state.getGlobalAddressReverseMap(locked).empty()) state.getGlobalAddressReverseMap(locked).erase(Addr); - return; + return OldVal; } - void *&CurVal = state.getGlobalAddressMap(locked)[GV]; + void *&CurVal = Map[GV]; + void *OldVal = CurVal; + if (CurVal && !state.getGlobalAddressReverseMap(locked).empty()) state.getGlobalAddressReverseMap(locked).erase(CurVal); CurVal = Addr; @@ -132,6 +190,7 @@ void ExecutionEngine::updateGlobalMapping(const GlobalValue *GV, void *Addr) { assert((V == 0 || GV == 0) && "GlobalMapping already established!"); V = GV; } + return OldVal; } /// getPointerToGlobalIfAvailable - This returns the address of the specified @@ -173,13 +232,13 @@ static void *CreateArgv(ExecutionEngine *EE, unsigned PtrSize = EE->getTargetData()->getPointerSize(); char *Result = new char[(InputArgv.size()+1)*PtrSize]; - DOUT << "ARGV = " << (void*)Result << "\n"; - const Type *SBytePtr = PointerType::get(Type::Int8Ty); + DOUT << "JIT: ARGV = " << (void*)Result << "\n"; + const Type *SBytePtr = PointerType::getUnqual(Type::Int8Ty); for (unsigned i = 0; i != InputArgv.size(); ++i) { unsigned Size = InputArgv[i].size()+1; char *Dest = new char[Size]; - DOUT << "ARGV[" << i << "] = " << (void*)Dest << "\n"; + DOUT << "JIT: ARGV[" << i << "] = " << (void*)Dest << "\n"; std::copy(InputArgv[i].begin(), InputArgv[i].end(), Dest); Dest[Size-1] = 0; @@ -198,44 +257,63 @@ static void *CreateArgv(ExecutionEngine *EE, /// runStaticConstructorsDestructors - This method is used to execute all of -/// the static constructors or destructors for a program, depending on the +/// the static constructors or destructors for a module, depending on the /// value of isDtors. -void ExecutionEngine::runStaticConstructorsDestructors(bool 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. - for (unsigned m = 0, e = Modules.size(); m != e; ++m) { - GlobalVariable *GV = Modules[m]->getModule()->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->hasInternalLinkage()) continue; - // 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) continue; - for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i) - if (ConstantStruct *CS = - dyn_cast(InitList->getOperand(i))) { - if (CS->getNumOperands() != 2) break; // 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()); - } - } - } + 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()); + } + } +} + +/// 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]->getModule(), isDtors); +} + +#ifndef NDEBUG +/// isTargetNullPtr - Return whether the target pointer stored at Loc is null. +static bool isTargetNullPtr(ExecutionEngine *EE, void *Loc) { + unsigned PtrSize = EE->getTargetData()->getPointerSize(); + for (unsigned i = 0; i < PtrSize; ++i) + if (*(i + (uint8_t*)Loc)) + return false; + return true; } +#endif /// runFunctionAsMain - This is a helper function which wraps runFunction to /// handle the common task of starting up main with the specified argc, argv, @@ -250,43 +328,39 @@ int ExecutionEngine::runFunctionAsMain(Function *Fn, // Check main() type unsigned NumArgs = Fn->getFunctionType()->getNumParams(); const FunctionType *FTy = Fn->getFunctionType(); - const Type* PPInt8Ty = PointerType::get(PointerType::get(Type::Int8Ty)); + const Type* PPInt8Ty = + PointerType::getUnqual(PointerType::getUnqual(Type::Int8Ty)); switch (NumArgs) { case 3: if (FTy->getParamType(2) != PPInt8Ty) { - cerr << "Invalid type for third argument of main() supplied\n"; - abort(); + llvm_report_error("Invalid type for third argument of main() supplied"); } // FALLS THROUGH case 2: if (FTy->getParamType(1) != PPInt8Ty) { - cerr << "Invalid type for second argument of main() supplied\n"; - abort(); + llvm_report_error("Invalid type for second argument of main() supplied"); } // FALLS THROUGH case 1: if (FTy->getParamType(0) != Type::Int32Ty) { - cerr << "Invalid type for first argument of main() supplied\n"; - abort(); + llvm_report_error("Invalid type for first argument of main() supplied"); } // FALLS THROUGH case 0: - if (FTy->getReturnType() != Type::Int32Ty && + if (!isa(FTy->getReturnType()) && FTy->getReturnType() != Type::VoidTy) { - cerr << "Invalid return type of main() supplied\n"; - abort(); + llvm_report_error("Invalid return type of main() supplied"); } break; default: - cerr << "Invalid number of arguments of main() supplied\n"; - abort(); + llvm_report_error("Invalid number of arguments of main() supplied"); } if (NumArgs) { GVArgs.push_back(GVArgc); // Arg #0 = argc. if (NumArgs > 1) { GVArgs.push_back(PTOGV(CreateArgv(this, argv))); // Arg #1 = argv. - assert(((char **)GVTOP(GVArgs[1]))[0] && + assert(!isTargetNullPtr(this, GVTOP(GVArgs[1])) && "argv[0] was null after CreateArgv"); if (NumArgs > 2) { std::vector EnvVars; @@ -305,25 +379,23 @@ int ExecutionEngine::runFunctionAsMain(Function *Fn, /// ExecutionEngine *ExecutionEngine::create(ModuleProvider *MP, bool ForceInterpreter, - std::string *ErrorStr) { + std::string *ErrorStr, + CodeGenOpt::Level OptLevel, + bool GVsWithCode) { ExecutionEngine *EE = 0; + // 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. + if (sys::DynamicLibrary::LoadLibraryPermanently(0, ErrorStr)) + return 0; + // Unless the interpreter was explicitly selected, try making a JIT. if (!ForceInterpreter && JITCtor) - EE = JITCtor(MP, ErrorStr); + EE = JITCtor(MP, ErrorStr, OptLevel, GVsWithCode); // If we can't make a JIT, make an interpreter instead. if (EE == 0 && InterpCtor) - EE = InterpCtor(MP, ErrorStr); - - if (EE) { - // 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. - if (sys::DynamicLibrary::LoadLibraryPermanently(0, ErrorStr)) { - delete EE; - return 0; - } - } + EE = InterpCtor(MP, ErrorStr, OptLevel, GVsWithCode); return EE; } @@ -349,7 +421,7 @@ void *ExecutionEngine::getPointerToGlobal(const GlobalValue *GV) { const_cast(dyn_cast(GV))) EmitGlobalVariable(GVar); else - assert(0 && "Global hasn't had an address allocated yet!"); + LLVM_UNREACHABLE("Global hasn't had an address allocated yet!"); return state.getGlobalAddressMap(locked)[GV]; } @@ -415,10 +487,10 @@ GenericValue ExecutionEngine::getConstantValue(const Constant *C) { else if (CE->getType() == Type::X86_FP80Ty) { const uint64_t zero[] = {0, 0}; APFloat apf = APFloat(APInt(80, 2, zero)); - (void)apf.convertFromZeroExtendedInteger(GV.IntVal.getRawData(), - GV.IntVal.getBitWidth(), false, - APFloat::rmNearestTiesToEven); - GV.IntVal = apf.convertToAPInt(); + (void)apf.convertFromAPInt(GV.IntVal, + false, + APFloat::rmNearestTiesToEven); + GV.IntVal = apf.bitcastToAPInt(); } return GV; } @@ -431,10 +503,10 @@ GenericValue ExecutionEngine::getConstantValue(const Constant *C) { else if (CE->getType() == Type::X86_FP80Ty) { const uint64_t zero[] = { 0, 0}; APFloat apf = APFloat(APInt(80, 2, zero)); - (void)apf.convertFromZeroExtendedInteger(GV.IntVal.getRawData(), - GV.IntVal.getBitWidth(), true, - APFloat::rmNearestTiesToEven); - GV.IntVal = apf.convertToAPInt(); + (void)apf.convertFromAPInt(GV.IntVal, + true, + APFloat::rmNearestTiesToEven); + GV.IntVal = apf.bitcastToAPInt(); } return GV; } @@ -449,9 +521,10 @@ GenericValue ExecutionEngine::getConstantValue(const Constant *C) { else if (Op0->getType() == Type::X86_FP80Ty) { APFloat apf = APFloat(GV.IntVal); uint64_t v; + bool ignored; (void)apf.convertToInteger(&v, BitWidth, CE->getOpcode()==Instruction::FPToSI, - APFloat::rmTowardZero); + APFloat::rmTowardZero, &ignored); GV.IntVal = v; // endian? } return GV; @@ -475,7 +548,7 @@ GenericValue ExecutionEngine::getConstantValue(const Constant *C) { GenericValue GV = getConstantValue(Op0); const Type* DestTy = CE->getType(); switch (Op0->getType()->getTypeID()) { - default: assert(0 && "Invalid bitcast operand"); + default: LLVM_UNREACHABLE("Invalid bitcast operand"); case Type::IntegerTyID: assert(DestTy->isFloatingPoint() && "invalid bitcast"); if (DestTy == Type::FloatTy) @@ -498,8 +571,11 @@ GenericValue ExecutionEngine::getConstantValue(const Constant *C) { return GV; } case Instruction::Add: + case Instruction::FAdd: case Instruction::Sub: + case Instruction::FSub: case Instruction::Mul: + case Instruction::FMul: case Instruction::UDiv: case Instruction::SDiv: case Instruction::URem: @@ -511,10 +587,10 @@ GenericValue ExecutionEngine::getConstantValue(const Constant *C) { GenericValue RHS = getConstantValue(CE->getOperand(1)); GenericValue GV; switch (CE->getOperand(0)->getType()->getTypeID()) { - default: assert(0 && "Bad add type!"); abort(); + default: LLVM_UNREACHABLE("Bad add type!"); case Type::IntegerTyID: switch (CE->getOpcode()) { - default: assert(0 && "Invalid integer opcode"); + default: LLVM_UNREACHABLE("Invalid integer opcode"); case Instruction::Add: GV.IntVal = LHS.IntVal + RHS.IntVal; break; case Instruction::Sub: GV.IntVal = LHS.IntVal - RHS.IntVal; break; case Instruction::Mul: GV.IntVal = LHS.IntVal * RHS.IntVal; break; @@ -529,12 +605,12 @@ GenericValue ExecutionEngine::getConstantValue(const Constant *C) { break; case Type::FloatTyID: switch (CE->getOpcode()) { - default: assert(0 && "Invalid float opcode"); abort(); - case Instruction::Add: + default: LLVM_UNREACHABLE("Invalid float opcode"); + case Instruction::FAdd: GV.FloatVal = LHS.FloatVal + RHS.FloatVal; break; - case Instruction::Sub: + case Instruction::FSub: GV.FloatVal = LHS.FloatVal - RHS.FloatVal; break; - case Instruction::Mul: + case Instruction::FMul: GV.FloatVal = LHS.FloatVal * RHS.FloatVal; break; case Instruction::FDiv: GV.FloatVal = LHS.FloatVal / RHS.FloatVal; break; @@ -544,12 +620,12 @@ GenericValue ExecutionEngine::getConstantValue(const Constant *C) { break; case Type::DoubleTyID: switch (CE->getOpcode()) { - default: assert(0 && "Invalid double opcode"); abort(); - case Instruction::Add: + default: LLVM_UNREACHABLE("Invalid double opcode"); + case Instruction::FAdd: GV.DoubleVal = LHS.DoubleVal + RHS.DoubleVal; break; - case Instruction::Sub: + case Instruction::FSub: GV.DoubleVal = LHS.DoubleVal - RHS.DoubleVal; break; - case Instruction::Mul: + case Instruction::FMul: GV.DoubleVal = LHS.DoubleVal * RHS.DoubleVal; break; case Instruction::FDiv: GV.DoubleVal = LHS.DoubleVal / RHS.DoubleVal; break; @@ -562,26 +638,26 @@ GenericValue ExecutionEngine::getConstantValue(const Constant *C) { case Type::FP128TyID: { APFloat apfLHS = APFloat(LHS.IntVal); switch (CE->getOpcode()) { - default: assert(0 && "Invalid long double opcode"); abort(); - case Instruction::Add: + default: LLVM_UNREACHABLE("Invalid long double opcode");llvm_unreachable(); + case Instruction::FAdd: apfLHS.add(APFloat(RHS.IntVal), APFloat::rmNearestTiesToEven); - GV.IntVal = apfLHS.convertToAPInt(); + GV.IntVal = apfLHS.bitcastToAPInt(); break; - case Instruction::Sub: + case Instruction::FSub: apfLHS.subtract(APFloat(RHS.IntVal), APFloat::rmNearestTiesToEven); - GV.IntVal = apfLHS.convertToAPInt(); + GV.IntVal = apfLHS.bitcastToAPInt(); break; - case Instruction::Mul: + case Instruction::FMul: apfLHS.multiply(APFloat(RHS.IntVal), APFloat::rmNearestTiesToEven); - GV.IntVal = apfLHS.convertToAPInt(); + GV.IntVal = apfLHS.bitcastToAPInt(); break; case Instruction::FDiv: apfLHS.divide(APFloat(RHS.IntVal), APFloat::rmNearestTiesToEven); - GV.IntVal = apfLHS.convertToAPInt(); + GV.IntVal = apfLHS.bitcastToAPInt(); break; case Instruction::FRem: apfLHS.mod(APFloat(RHS.IntVal), APFloat::rmNearestTiesToEven); - GV.IntVal = apfLHS.convertToAPInt(); + GV.IntVal = apfLHS.bitcastToAPInt(); break; } } @@ -592,8 +668,10 @@ GenericValue ExecutionEngine::getConstantValue(const Constant *C) { default: break; } - cerr << "ConstantExpr not handled: " << *CE << "\n"; - abort(); + std::string msg; + raw_string_ostream Msg(msg); + Msg << "ConstantExpr not handled: " << *CE; + llvm_report_error(Msg.str()); } GenericValue Result; @@ -607,7 +685,7 @@ GenericValue ExecutionEngine::getConstantValue(const Constant *C) { case Type::X86_FP80TyID: case Type::FP128TyID: case Type::PPC_FP128TyID: - Result.IntVal = cast (C)->getValueAPF().convertToAPInt(); + Result.IntVal = cast (C)->getValueAPF().bitcastToAPInt(); break; case Type::IntegerTyID: Result.IntVal = cast(C)->getValue(); @@ -620,110 +698,150 @@ GenericValue ExecutionEngine::getConstantValue(const Constant *C) { else if (const GlobalVariable* GV = dyn_cast(C)) Result = PTOGV(getOrEmitGlobalVariable(const_cast(GV))); else - assert(0 && "Unknown constant pointer type!"); + LLVM_UNREACHABLE("Unknown constant pointer type!"); break; default: - cerr << "ERROR: Constant unimplemented for type: " << *C->getType() << "\n"; - abort(); + std::string msg; + raw_string_ostream Msg(msg); + Msg << "ERROR: Constant unimplemented for type: " << *C->getType(); + llvm_report_error(Msg.str()); } return Result; } +/// StoreIntToMemory - Fills the StoreBytes bytes of memory starting from Dst +/// with the integer held in IntVal. +static void StoreIntToMemory(const APInt &IntVal, uint8_t *Dst, + unsigned StoreBytes) { + assert((IntVal.getBitWidth()+7)/8 >= StoreBytes && "Integer too small!"); + uint8_t *Src = (uint8_t *)IntVal.getRawData(); + + 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 { + // 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. + while (StoreBytes > sizeof(uint64_t)) { + StoreBytes -= sizeof(uint64_t); + // May not be aligned so use memcpy. + memcpy(Dst + StoreBytes, Src, sizeof(uint64_t)); + Src += sizeof(uint64_t); + } + + memcpy(Dst, Src + sizeof(uint64_t) - StoreBytes, StoreBytes); + } +} + /// 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) { +void ExecutionEngine::StoreValueToMemory(const GenericValue &Val, + GenericValue *Ptr, const Type *Ty) { + const unsigned StoreBytes = getTargetData()->getTypeStoreSize(Ty); + switch (Ty->getTypeID()) { - case Type::IntegerTyID: { - unsigned BitWidth = cast(Ty)->getBitWidth(); - GenericValue TmpVal = Val; - if (BitWidth <= 8) - *((uint8_t*)Ptr) = uint8_t(Val.IntVal.getZExtValue()); - else if (BitWidth <= 16) { - *((uint16_t*)Ptr) = uint16_t(Val.IntVal.getZExtValue()); - } else if (BitWidth <= 32) { - *((uint32_t*)Ptr) = uint32_t(Val.IntVal.getZExtValue()); - } else if (BitWidth <= 64) { - *((uint64_t*)Ptr) = uint64_t(Val.IntVal.getZExtValue()); - } else { - uint64_t *Dest = (uint64_t*)Ptr; - const uint64_t *Src = Val.IntVal.getRawData(); - for (uint32_t i = 0; i < Val.IntVal.getNumWords(); ++i) - Dest[i] = Src[i]; - } + case Type::IntegerTyID: + StoreIntToMemory(Val.IntVal, (uint8_t*)Ptr, StoreBytes); break; - } case Type::FloatTyID: *((float*)Ptr) = Val.FloatVal; break; case Type::DoubleTyID: *((double*)Ptr) = Val.DoubleVal; break; - case Type::X86_FP80TyID: { - uint16_t *Dest = (uint16_t*)Ptr; - const uint16_t *Src = (uint16_t*)Val.IntVal.getRawData(); - // This is endian dependent, but it will only work on x86 anyway. - Dest[0] = Src[4]; - Dest[1] = Src[0]; - Dest[2] = Src[1]; - Dest[3] = Src[2]; - Dest[4] = Src[3]; - break; - } - case Type::PointerTyID: + case Type::X86_FP80TyID: + memcpy(Ptr, Val.IntVal.getRawData(), 10); + break; + case Type::PointerTyID: + // Ensure 64 bit target pointers are fully initialized on 32 bit hosts. + if (StoreBytes != sizeof(PointerTy)) + memset(Ptr, 0, StoreBytes); + *((PointerTy*)Ptr) = Val.PointerVal; break; default: cerr << "Cannot store value of type " << *Ty << "!\n"; } + + if (sys::isLittleEndianHost() != getTargetData()->isLittleEndian()) + // Host and target are different endian - reverse the stored bytes. + std::reverse((uint8_t*)Ptr, StoreBytes + (uint8_t*)Ptr); +} + +/// LoadIntFromMemory - Loads the integer stored in the LoadBytes bytes starting +/// from Src into IntVal, which is assumed to be wide enough and to hold zero. +static void LoadIntFromMemory(APInt &IntVal, uint8_t *Src, unsigned LoadBytes) { + assert((IntVal.getBitWidth()+7)/8 >= LoadBytes && "Integer too small!"); + uint8_t *Dst = (uint8_t *)IntVal.getRawData(); + + if (sys::isLittleEndianHost()) + // Little-endian host - the destination must be ordered from LSB to MSB. + // The source is ordered from LSB to MSB: Do a straight copy. + memcpy(Dst, Src, LoadBytes); + else { + // Big-endian - the destination is an array of 64 bit words ordered from + // LSW to MSW. Each word must be ordered from MSB to LSB. The source is + // ordered from MSB to LSB: Reverse the word order, but not the bytes in + // a word. + while (LoadBytes > sizeof(uint64_t)) { + LoadBytes -= sizeof(uint64_t); + // May not be aligned so use memcpy. + memcpy(Dst, Src + LoadBytes, sizeof(uint64_t)); + Dst += sizeof(uint64_t); + } + + memcpy(Dst + sizeof(uint64_t) - LoadBytes, Src, LoadBytes); + } } /// FIXME: document /// -void ExecutionEngine::LoadValueFromMemory(GenericValue &Result, - GenericValue *Ptr, - const Type *Ty) { +void ExecutionEngine::LoadValueFromMemory(GenericValue &Result, + GenericValue *Ptr, + const Type *Ty) { + const unsigned LoadBytes = getTargetData()->getTypeStoreSize(Ty); + + if (sys::isLittleEndianHost() != getTargetData()->isLittleEndian()) { + // Host and target are different endian - reverse copy the stored + // bytes into a buffer, and load from that. + uint8_t *Src = (uint8_t*)Ptr; + uint8_t *Buf = (uint8_t*)alloca(LoadBytes); + std::reverse_copy(Src, Src + LoadBytes, Buf); + Ptr = (GenericValue*)Buf; + } + switch (Ty->getTypeID()) { - case Type::IntegerTyID: { - unsigned BitWidth = cast(Ty)->getBitWidth(); - if (BitWidth <= 8) - Result.IntVal = APInt(BitWidth, *((uint8_t*)Ptr)); - else if (BitWidth <= 16) { - Result.IntVal = APInt(BitWidth, *((uint16_t*)Ptr)); - } else if (BitWidth <= 32) { - Result.IntVal = APInt(BitWidth, *((uint32_t*)Ptr)); - } else if (BitWidth <= 64) { - Result.IntVal = APInt(BitWidth, *((uint64_t*)Ptr)); - } else - Result.IntVal = APInt(BitWidth, (BitWidth+63)/64, (uint64_t*)Ptr); + case Type::IntegerTyID: + // An APInt with all words initially zero. + Result.IntVal = APInt(cast(Ty)->getBitWidth(), 0); + LoadIntFromMemory(Result.IntVal, (uint8_t*)Ptr, LoadBytes); break; - } case Type::FloatTyID: Result.FloatVal = *((float*)Ptr); break; case Type::DoubleTyID: - Result.DoubleVal = *((double*)Ptr); + Result.DoubleVal = *((double*)Ptr); break; - case Type::PointerTyID: + case Type::PointerTyID: Result.PointerVal = *((PointerTy*)Ptr); break; case Type::X86_FP80TyID: { // This is endian dependent, but it will only work on x86 anyway. - uint16_t x[8], *p = (uint16_t*)Ptr; - x[0] = p[1]; - x[1] = p[2]; - x[2] = p[3]; - x[3] = p[4]; - x[4] = p[0]; - Result.IntVal = APInt(80, 2, x); + // FIXME: Will not trap if loading a signaling NaN. + uint64_t y[2]; + memcpy(y, Ptr, 10); + Result.IntVal = APInt(80, 2, y); break; } default: - cerr << "Cannot load value of type " << *Ty << "!\n"; - abort(); + std::string msg; + raw_string_ostream Msg(msg); + Msg << "Cannot load value of type " << *Ty << "!"; + llvm_report_error(Msg.str()); } } @@ -731,46 +849,39 @@ void ExecutionEngine::LoadValueFromMemory(GenericValue &Result, // specified memory location... // void ExecutionEngine::InitializeMemory(const Constant *Init, void *Addr) { + DOUT << "JIT: Initializing " << Addr << " "; + DEBUG(Init->dump()); if (isa(Init)) { return; } else if (const ConstantVector *CP = dyn_cast(Init)) { unsigned ElementSize = - getTargetData()->getTypeSize(CP->getType()->getElementType()); + getTargetData()->getTypeAllocSize(CP->getType()->getElementType()); for (unsigned i = 0, e = CP->getNumOperands(); i != e; ++i) InitializeMemory(CP->getOperand(i), (char*)Addr+i*ElementSize); return; - } else if (Init->getType()->isFirstClassType()) { - GenericValue Val = getConstantValue(Init); - StoreValueToMemory(Val, (GenericValue*)Addr, Init->getType()); - return; } else if (isa(Init)) { - memset(Addr, 0, (size_t)getTargetData()->getTypeSize(Init->getType())); + memset(Addr, 0, (size_t)getTargetData()->getTypeAllocSize(Init->getType())); return; - } - - switch (Init->getType()->getTypeID()) { - case Type::ArrayTyID: { - const ConstantArray *CPA = cast(Init); + } else if (const ConstantArray *CPA = dyn_cast(Init)) { unsigned ElementSize = - getTargetData()->getTypeSize(CPA->getType()->getElementType()); + getTargetData()->getTypeAllocSize(CPA->getType()->getElementType()); for (unsigned i = 0, e = CPA->getNumOperands(); i != e; ++i) InitializeMemory(CPA->getOperand(i), (char*)Addr+i*ElementSize); return; - } - - case Type::StructTyID: { - const ConstantStruct *CPS = cast(Init); + } else if (const ConstantStruct *CPS = dyn_cast(Init)) { const StructLayout *SL = getTargetData()->getStructLayout(cast(CPS->getType())); for (unsigned i = 0, e = CPS->getNumOperands(); i != e; ++i) InitializeMemory(CPS->getOperand(i), (char*)Addr+SL->getElementOffset(i)); return; + } else if (Init->getType()->isFirstClassType()) { + GenericValue Val = getConstantValue(Init); + StoreValueToMemory(Val, (GenericValue*)Addr, Init->getType()); + return; } - default: - cerr << "Bad Type: " << *Init->getType() << "\n"; - assert(0 && "Unknown constant type to initialize memory with!"); - } + cerr << "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 @@ -778,7 +889,6 @@ void ExecutionEngine::InitializeMemory(const Constant *Init, void *Addr) { /// their initializers into the memory. /// void ExecutionEngine::emitGlobals() { - const TargetData *TD = getTargetData(); // 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 @@ -793,7 +903,7 @@ void ExecutionEngine::emitGlobals() { for (Module::const_global_iterator I = M.global_begin(), E = M.global_end(); I != E; ++I) { const GlobalValue *GV = I; - if (GV->hasInternalLinkage() || GV->isDeclaration() || + if (GV->hasLocalLinkage() || GV->isDeclaration() || GV->hasAppendingLinkage() || !GV->hasName()) continue;// Ignore external globals and globals with internal linkage. @@ -814,7 +924,7 @@ void ExecutionEngine::emitGlobals() { continue; // Otherwise, we know it's linkonce/weak, replace it if this is a strong - // symbol. + // symbol. FIXME is this right for common? if (GV->hasExternalLinkage() || GVEntry->hasExternalWeakLinkage()) GVEntry = GV; } @@ -839,12 +949,7 @@ void ExecutionEngine::emitGlobals() { } if (!I->isDeclaration()) { - // Get the type of the global. - const Type *Ty = I->getType()->getElementType(); - - // Allocate some memory for it! - unsigned Size = TD->getTypeSize(Ty); - addGlobalMapping(I, new char[Size]); + addGlobalMapping(I, getMemoryForGV(I)); } else { // External variable reference. Try to use the dynamic loader to // get a pointer to it. @@ -852,9 +957,8 @@ void ExecutionEngine::emitGlobals() { sys::DynamicLibrary::SearchForAddressOfSymbol(I->getName().c_str())) addGlobalMapping(I, SymAddr); else { - cerr << "Could not resolve external global address: " - << I->getName() << "\n"; - abort(); + llvm_report_error("Could not resolve external global address: " + +I->getName()); } } } @@ -868,7 +972,7 @@ void ExecutionEngine::emitGlobals() { LinkedGlobalsMap[std::make_pair(GV->getName(), GV->getType())]; void *Ptr = getPointerToGlobalIfAvailable(CGV); assert(Ptr && "Canonical global wasn't codegen'd!"); - addGlobalMapping(GV, getPointerToGlobalIfAvailable(CGV)); + addGlobalMapping(GV, Ptr); } } @@ -894,17 +998,19 @@ void ExecutionEngine::emitGlobals() { // already in the map. void ExecutionEngine::EmitGlobalVariable(const GlobalVariable *GV) { void *GA = getPointerToGlobalIfAvailable(GV); - DOUT << "Global '" << GV->getName() << "' -> " << GA << "\n"; - const Type *ElTy = GV->getType()->getElementType(); - size_t GVSize = (size_t)getTargetData()->getTypeSize(ElTy); if (GA == 0) { // If it's not already specified, allocate memory for the global. - GA = new char[GVSize]; + GA = getMemoryForGV(GV); addGlobalMapping(GV, GA); } - - InitializeMemory(GV->getInitializer(), 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; ++NumGlobals; }