Misha Brukman | 4afac18 | 2003-10-10 17:45:12 +0000 | [diff] [blame] | 1 | //===-- ExecutionEngine.cpp - Common Implementation shared by EEs ---------===// |
Misha Brukman | edf128a | 2005-04-21 22:36:52 +0000 | [diff] [blame] | 2 | // |
John Criswell | b576c94 | 2003-10-20 19:43:21 +0000 | [diff] [blame] | 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
Chris Lattner | 4ee451d | 2007-12-29 20:36:04 +0000 | [diff] [blame] | 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
Misha Brukman | edf128a | 2005-04-21 22:36:52 +0000 | [diff] [blame] | 7 | // |
John Criswell | b576c94 | 2003-10-20 19:43:21 +0000 | [diff] [blame] | 8 | //===----------------------------------------------------------------------===// |
Misha Brukman | edf128a | 2005-04-21 22:36:52 +0000 | [diff] [blame] | 9 | // |
Chris Lattner | bd199fb | 2002-12-24 00:01:05 +0000 | [diff] [blame] | 10 | // This file defines the common interface used by the various execution engine |
| 11 | // subclasses. |
| 12 | // |
| 13 | //===----------------------------------------------------------------------===// |
| 14 | |
Chris Lattner | 3785fad | 2003-08-05 17:00:32 +0000 | [diff] [blame] | 15 | #define DEBUG_TYPE "jit" |
Chris Lattner | bd199fb | 2002-12-24 00:01:05 +0000 | [diff] [blame] | 16 | #include "llvm/Constants.h" |
Misha Brukman | 1968416 | 2003-10-16 21:18:05 +0000 | [diff] [blame] | 17 | #include "llvm/DerivedTypes.h" |
Chris Lattner | bd199fb | 2002-12-24 00:01:05 +0000 | [diff] [blame] | 18 | #include "llvm/Module.h" |
Misha Brukman | 1968416 | 2003-10-16 21:18:05 +0000 | [diff] [blame] | 19 | #include "llvm/ModuleProvider.h" |
Reid Spencer | df5a37e | 2004-11-29 14:11:29 +0000 | [diff] [blame] | 20 | #include "llvm/ADT/Statistic.h" |
Duncan Sands | 8a43e9e | 2007-12-14 19:38:31 +0000 | [diff] [blame] | 21 | #include "llvm/Config/alloca.h" |
Misha Brukman | 1968416 | 2003-10-16 21:18:05 +0000 | [diff] [blame] | 22 | #include "llvm/ExecutionEngine/ExecutionEngine.h" |
Chris Lattner | fd13129 | 2003-09-05 20:08:15 +0000 | [diff] [blame] | 23 | #include "llvm/ExecutionEngine/GenericValue.h" |
Reid Spencer | 551ccae | 2004-09-01 22:55:40 +0000 | [diff] [blame] | 24 | #include "llvm/Support/Debug.h" |
Torok Edwin | 31e2466 | 2009-07-07 17:32:34 +0000 | [diff] [blame] | 25 | #include "llvm/Support/ErrorHandling.h" |
Chris Lattner | e7fd553 | 2006-05-08 22:00:52 +0000 | [diff] [blame] | 26 | #include "llvm/Support/MutexGuard.h" |
Torok Edwin | 7d696d8 | 2009-07-11 13:10:19 +0000 | [diff] [blame] | 27 | #include "llvm/Support/raw_ostream.h" |
Reid Spencer | df5a37e | 2004-11-29 14:11:29 +0000 | [diff] [blame] | 28 | #include "llvm/System/DynamicLibrary.h" |
Duncan Sands | 67f1c49 | 2007-12-12 23:03:45 +0000 | [diff] [blame] | 29 | #include "llvm/System/Host.h" |
Reid Spencer | df5a37e | 2004-11-29 14:11:29 +0000 | [diff] [blame] | 30 | #include "llvm/Target/TargetData.h" |
Anton Korobeynikov | ae9f3a3 | 2008-02-20 11:08:44 +0000 | [diff] [blame] | 31 | #include <cmath> |
| 32 | #include <cstring> |
Chris Lattner | c2ee9b9 | 2003-11-19 21:08:57 +0000 | [diff] [blame] | 33 | using namespace llvm; |
Chris Lattner | bd199fb | 2002-12-24 00:01:05 +0000 | [diff] [blame] | 34 | |
Chris Lattner | 3634373 | 2006-12-19 22:43:32 +0000 | [diff] [blame] | 35 | STATISTIC(NumInitBytes, "Number of bytes of global vars initialized"); |
| 36 | STATISTIC(NumGlobals , "Number of global vars initialized"); |
Chris Lattner | bd199fb | 2002-12-24 00:01:05 +0000 | [diff] [blame] | 37 | |
Reid Kleckner | 4b1511b | 2009-07-18 00:42:18 +0000 | [diff] [blame] | 38 | ExecutionEngine *(*ExecutionEngine::JITCtor)(ModuleProvider *MP, |
| 39 | std::string *ErrorStr, |
| 40 | JITMemoryManager *JMM, |
| 41 | CodeGenOpt::Level OptLevel, |
| 42 | bool GVsWithCode) = 0; |
| 43 | ExecutionEngine *(*ExecutionEngine::InterpCtor)(ModuleProvider *MP, |
| 44 | std::string *ErrorStr) = 0; |
Nicolas Geoffray | afe6c2b | 2008-02-13 18:39:37 +0000 | [diff] [blame] | 45 | ExecutionEngine::EERegisterFn ExecutionEngine::ExceptionTableRegister = 0; |
| 46 | |
Chris Lattner | 2fe4bb0 | 2006-03-22 06:07:50 +0000 | [diff] [blame] | 47 | |
Chris Lattner | d958a5a | 2007-10-22 02:50:12 +0000 | [diff] [blame] | 48 | ExecutionEngine::ExecutionEngine(ModuleProvider *P) : LazyFunctionCreator(0) { |
Chris Lattner | 3d6e33d | 2006-11-09 19:31:15 +0000 | [diff] [blame] | 49 | LazyCompilationDisabled = false; |
Evan Cheng | 446531e | 2008-09-24 16:25:55 +0000 | [diff] [blame] | 50 | GVCompilationDisabled = false; |
Evan Cheng | 1b088f3 | 2008-06-17 16:49:02 +0000 | [diff] [blame] | 51 | SymbolSearchingDisabled = false; |
Nate Begeman | d6b7a24 | 2009-02-18 08:31:02 +0000 | [diff] [blame] | 52 | DlsymStubsEnabled = false; |
Chris Lattner | fe85403 | 2006-08-16 01:24:12 +0000 | [diff] [blame] | 53 | Modules.push_back(P); |
Misha Brukman | 1968416 | 2003-10-16 21:18:05 +0000 | [diff] [blame] | 54 | assert(P && "ModuleProvider is null?"); |
| 55 | } |
| 56 | |
Brian Gaeke | 8e53948 | 2003-09-04 22:57:27 +0000 | [diff] [blame] | 57 | ExecutionEngine::~ExecutionEngine() { |
Reid Spencer | d4c0e62 | 2007-03-03 18:19:18 +0000 | [diff] [blame] | 58 | clearAllGlobalMappings(); |
Chris Lattner | fe85403 | 2006-08-16 01:24:12 +0000 | [diff] [blame] | 59 | for (unsigned i = 0, e = Modules.size(); i != e; ++i) |
| 60 | delete Modules[i]; |
Brian Gaeke | 8e53948 | 2003-09-04 22:57:27 +0000 | [diff] [blame] | 61 | } |
| 62 | |
Nicolas Geoffray | 46fa139 | 2008-10-25 15:41:43 +0000 | [diff] [blame] | 63 | char* ExecutionEngine::getMemoryForGV(const GlobalVariable* GV) { |
| 64 | const Type *ElTy = GV->getType()->getElementType(); |
Duncan Sands | 777d230 | 2009-05-09 07:06:46 +0000 | [diff] [blame] | 65 | size_t GVSize = (size_t)getTargetData()->getTypeAllocSize(ElTy); |
Nicolas Geoffray | 46fa139 | 2008-10-25 15:41:43 +0000 | [diff] [blame] | 66 | return new char[GVSize]; |
| 67 | } |
| 68 | |
Devang Patel | 73d0e21 | 2007-10-15 19:56:32 +0000 | [diff] [blame] | 69 | /// removeModuleProvider - Remove a ModuleProvider from the list of modules. |
Nate Begeman | 60789e4 | 2009-01-23 19:27:28 +0000 | [diff] [blame] | 70 | /// Relases the Module from the ModuleProvider, materializing it in the |
| 71 | /// process, and returns the materialized Module. |
Devang Patel | 73d0e21 | 2007-10-15 19:56:32 +0000 | [diff] [blame] | 72 | Module* ExecutionEngine::removeModuleProvider(ModuleProvider *P, |
| 73 | std::string *ErrInfo) { |
| 74 | for(SmallVector<ModuleProvider *, 1>::iterator I = Modules.begin(), |
| 75 | E = Modules.end(); I != E; ++I) { |
| 76 | ModuleProvider *MP = *I; |
| 77 | if (MP == P) { |
| 78 | Modules.erase(I); |
Nate Begeman | f049e07 | 2008-05-21 16:34:48 +0000 | [diff] [blame] | 79 | clearGlobalMappingsFromModule(MP->getModule()); |
Devang Patel | 73d0e21 | 2007-10-15 19:56:32 +0000 | [diff] [blame] | 80 | return MP->releaseModule(ErrInfo); |
| 81 | } |
| 82 | } |
| 83 | return NULL; |
| 84 | } |
| 85 | |
Nate Begeman | 60789e4 | 2009-01-23 19:27:28 +0000 | [diff] [blame] | 86 | /// deleteModuleProvider - Remove a ModuleProvider from the list of modules, |
| 87 | /// and deletes the ModuleProvider and owned Module. Avoids materializing |
| 88 | /// the underlying module. |
| 89 | void ExecutionEngine::deleteModuleProvider(ModuleProvider *P, |
| 90 | std::string *ErrInfo) { |
| 91 | for(SmallVector<ModuleProvider *, 1>::iterator I = Modules.begin(), |
| 92 | E = Modules.end(); I != E; ++I) { |
| 93 | ModuleProvider *MP = *I; |
| 94 | if (MP == P) { |
| 95 | Modules.erase(I); |
| 96 | clearGlobalMappingsFromModule(MP->getModule()); |
| 97 | delete MP; |
| 98 | return; |
| 99 | } |
| 100 | } |
| 101 | } |
| 102 | |
Chris Lattner | fe85403 | 2006-08-16 01:24:12 +0000 | [diff] [blame] | 103 | /// FindFunctionNamed - Search all of the active modules to find the one that |
| 104 | /// defines FnName. This is very slow operation and shouldn't be used for |
| 105 | /// general code. |
| 106 | Function *ExecutionEngine::FindFunctionNamed(const char *FnName) { |
| 107 | for (unsigned i = 0, e = Modules.size(); i != e; ++i) { |
Reid Spencer | 688b049 | 2007-02-05 21:19:13 +0000 | [diff] [blame] | 108 | if (Function *F = Modules[i]->getModule()->getFunction(FnName)) |
Chris Lattner | fe85403 | 2006-08-16 01:24:12 +0000 | [diff] [blame] | 109 | return F; |
| 110 | } |
| 111 | return 0; |
| 112 | } |
| 113 | |
| 114 | |
Chris Lattner | e7fd553 | 2006-05-08 22:00:52 +0000 | [diff] [blame] | 115 | /// addGlobalMapping - Tell the execution engine that the specified global is |
| 116 | /// at the specified location. This is used internally as functions are JIT'd |
| 117 | /// and as global variables are laid out in memory. It can and should also be |
| 118 | /// used by clients of the EE that want to have an LLVM global overlay |
| 119 | /// existing data in memory. |
| 120 | void ExecutionEngine::addGlobalMapping(const GlobalValue *GV, void *Addr) { |
| 121 | MutexGuard locked(lock); |
Evan Cheng | bc4707a | 2008-09-18 07:54:21 +0000 | [diff] [blame] | 122 | |
Evan Cheng | 366cf29 | 2008-11-07 22:30:29 +0000 | [diff] [blame] | 123 | DOUT << "JIT: Map \'" << GV->getNameStart() << "\' to [" << Addr << "]\n"; |
Chris Lattner | e7fd553 | 2006-05-08 22:00:52 +0000 | [diff] [blame] | 124 | void *&CurVal = state.getGlobalAddressMap(locked)[GV]; |
| 125 | assert((CurVal == 0 || Addr == 0) && "GlobalMapping already established!"); |
| 126 | CurVal = Addr; |
| 127 | |
| 128 | // If we are using the reverse mapping, add it too |
| 129 | if (!state.getGlobalAddressReverseMap(locked).empty()) { |
| 130 | const GlobalValue *&V = state.getGlobalAddressReverseMap(locked)[Addr]; |
| 131 | assert((V == 0 || GV == 0) && "GlobalMapping already established!"); |
| 132 | V = GV; |
| 133 | } |
| 134 | } |
| 135 | |
| 136 | /// clearAllGlobalMappings - Clear all global mappings and start over again |
| 137 | /// use in dynamic compilation scenarios when you want to move globals |
| 138 | void ExecutionEngine::clearAllGlobalMappings() { |
| 139 | MutexGuard locked(lock); |
| 140 | |
| 141 | state.getGlobalAddressMap(locked).clear(); |
| 142 | state.getGlobalAddressReverseMap(locked).clear(); |
| 143 | } |
| 144 | |
Nate Begeman | f049e07 | 2008-05-21 16:34:48 +0000 | [diff] [blame] | 145 | /// clearGlobalMappingsFromModule - Clear all global mappings that came from a |
| 146 | /// particular module, because it has been removed from the JIT. |
| 147 | void ExecutionEngine::clearGlobalMappingsFromModule(Module *M) { |
| 148 | MutexGuard locked(lock); |
| 149 | |
| 150 | for (Module::iterator FI = M->begin(), FE = M->end(); FI != FE; ++FI) { |
| 151 | state.getGlobalAddressMap(locked).erase(FI); |
| 152 | state.getGlobalAddressReverseMap(locked).erase(FI); |
| 153 | } |
| 154 | for (Module::global_iterator GI = M->global_begin(), GE = M->global_end(); |
| 155 | GI != GE; ++GI) { |
| 156 | state.getGlobalAddressMap(locked).erase(GI); |
| 157 | state.getGlobalAddressReverseMap(locked).erase(GI); |
| 158 | } |
| 159 | } |
| 160 | |
Chris Lattner | e7fd553 | 2006-05-08 22:00:52 +0000 | [diff] [blame] | 161 | /// updateGlobalMapping - Replace an existing mapping for GV with a new |
| 162 | /// address. This updates both maps as required. If "Addr" is null, the |
| 163 | /// entry for the global is removed from the mappings. |
Chris Lattner | f4cc309 | 2008-04-04 04:47:41 +0000 | [diff] [blame] | 164 | void *ExecutionEngine::updateGlobalMapping(const GlobalValue *GV, void *Addr) { |
Chris Lattner | e7fd553 | 2006-05-08 22:00:52 +0000 | [diff] [blame] | 165 | MutexGuard locked(lock); |
Chris Lattner | f4cc309 | 2008-04-04 04:47:41 +0000 | [diff] [blame] | 166 | |
| 167 | std::map<const GlobalValue*, void *> &Map = state.getGlobalAddressMap(locked); |
| 168 | |
Chris Lattner | e7fd553 | 2006-05-08 22:00:52 +0000 | [diff] [blame] | 169 | // Deleting from the mapping? |
| 170 | if (Addr == 0) { |
Chris Lattner | f4cc309 | 2008-04-04 04:47:41 +0000 | [diff] [blame] | 171 | std::map<const GlobalValue*, void *>::iterator I = Map.find(GV); |
| 172 | void *OldVal; |
| 173 | if (I == Map.end()) |
| 174 | OldVal = 0; |
| 175 | else { |
| 176 | OldVal = I->second; |
| 177 | Map.erase(I); |
| 178 | } |
| 179 | |
Chris Lattner | e7fd553 | 2006-05-08 22:00:52 +0000 | [diff] [blame] | 180 | if (!state.getGlobalAddressReverseMap(locked).empty()) |
| 181 | state.getGlobalAddressReverseMap(locked).erase(Addr); |
Chris Lattner | f4cc309 | 2008-04-04 04:47:41 +0000 | [diff] [blame] | 182 | return OldVal; |
Chris Lattner | e7fd553 | 2006-05-08 22:00:52 +0000 | [diff] [blame] | 183 | } |
| 184 | |
Chris Lattner | f4cc309 | 2008-04-04 04:47:41 +0000 | [diff] [blame] | 185 | void *&CurVal = Map[GV]; |
| 186 | void *OldVal = CurVal; |
| 187 | |
Chris Lattner | e7fd553 | 2006-05-08 22:00:52 +0000 | [diff] [blame] | 188 | if (CurVal && !state.getGlobalAddressReverseMap(locked).empty()) |
| 189 | state.getGlobalAddressReverseMap(locked).erase(CurVal); |
| 190 | CurVal = Addr; |
| 191 | |
| 192 | // If we are using the reverse mapping, add it too |
| 193 | if (!state.getGlobalAddressReverseMap(locked).empty()) { |
| 194 | const GlobalValue *&V = state.getGlobalAddressReverseMap(locked)[Addr]; |
| 195 | assert((V == 0 || GV == 0) && "GlobalMapping already established!"); |
| 196 | V = GV; |
| 197 | } |
Chris Lattner | f4cc309 | 2008-04-04 04:47:41 +0000 | [diff] [blame] | 198 | return OldVal; |
Chris Lattner | e7fd553 | 2006-05-08 22:00:52 +0000 | [diff] [blame] | 199 | } |
| 200 | |
| 201 | /// getPointerToGlobalIfAvailable - This returns the address of the specified |
| 202 | /// global value if it is has already been codegen'd, otherwise it returns null. |
| 203 | /// |
| 204 | void *ExecutionEngine::getPointerToGlobalIfAvailable(const GlobalValue *GV) { |
| 205 | MutexGuard locked(lock); |
| 206 | |
| 207 | std::map<const GlobalValue*, void*>::iterator I = |
| 208 | state.getGlobalAddressMap(locked).find(GV); |
| 209 | return I != state.getGlobalAddressMap(locked).end() ? I->second : 0; |
| 210 | } |
| 211 | |
Chris Lattner | 55d8648 | 2003-12-31 20:21:04 +0000 | [diff] [blame] | 212 | /// getGlobalValueAtAddress - Return the LLVM global value object that starts |
| 213 | /// at the specified address. |
| 214 | /// |
| 215 | const GlobalValue *ExecutionEngine::getGlobalValueAtAddress(void *Addr) { |
Reid Spencer | ee44863 | 2005-07-12 15:51:55 +0000 | [diff] [blame] | 216 | MutexGuard locked(lock); |
| 217 | |
Chris Lattner | 55d8648 | 2003-12-31 20:21:04 +0000 | [diff] [blame] | 218 | // If we haven't computed the reverse mapping yet, do so first. |
Reid Spencer | ee44863 | 2005-07-12 15:51:55 +0000 | [diff] [blame] | 219 | if (state.getGlobalAddressReverseMap(locked).empty()) { |
Chris Lattner | e7fd553 | 2006-05-08 22:00:52 +0000 | [diff] [blame] | 220 | for (std::map<const GlobalValue*, void *>::iterator |
| 221 | I = state.getGlobalAddressMap(locked).begin(), |
| 222 | E = state.getGlobalAddressMap(locked).end(); I != E; ++I) |
| 223 | state.getGlobalAddressReverseMap(locked).insert(std::make_pair(I->second, |
| 224 | I->first)); |
Chris Lattner | 55d8648 | 2003-12-31 20:21:04 +0000 | [diff] [blame] | 225 | } |
| 226 | |
| 227 | std::map<void *, const GlobalValue*>::iterator I = |
Reid Spencer | ee44863 | 2005-07-12 15:51:55 +0000 | [diff] [blame] | 228 | state.getGlobalAddressReverseMap(locked).find(Addr); |
| 229 | return I != state.getGlobalAddressReverseMap(locked).end() ? I->second : 0; |
Chris Lattner | 55d8648 | 2003-12-31 20:21:04 +0000 | [diff] [blame] | 230 | } |
Chris Lattner | 87f0310 | 2003-12-26 06:50:30 +0000 | [diff] [blame] | 231 | |
| 232 | // CreateArgv - Turn a vector of strings into a nice argv style array of |
| 233 | // pointers to null terminated strings. |
| 234 | // |
| 235 | static void *CreateArgv(ExecutionEngine *EE, |
| 236 | const std::vector<std::string> &InputArgv) { |
Owen Anderson | a69571c | 2006-05-03 01:29:57 +0000 | [diff] [blame] | 237 | unsigned PtrSize = EE->getTargetData()->getPointerSize(); |
Chris Lattner | 87f0310 | 2003-12-26 06:50:30 +0000 | [diff] [blame] | 238 | char *Result = new char[(InputArgv.size()+1)*PtrSize]; |
| 239 | |
Evan Cheng | eb5d95a | 2008-11-06 17:46:04 +0000 | [diff] [blame] | 240 | DOUT << "JIT: ARGV = " << (void*)Result << "\n"; |
Christopher Lamb | 43ad6b3 | 2007-12-17 01:12:55 +0000 | [diff] [blame] | 241 | const Type *SBytePtr = PointerType::getUnqual(Type::Int8Ty); |
Chris Lattner | 87f0310 | 2003-12-26 06:50:30 +0000 | [diff] [blame] | 242 | |
| 243 | for (unsigned i = 0; i != InputArgv.size(); ++i) { |
| 244 | unsigned Size = InputArgv[i].size()+1; |
| 245 | char *Dest = new char[Size]; |
Evan Cheng | eb5d95a | 2008-11-06 17:46:04 +0000 | [diff] [blame] | 246 | DOUT << "JIT: ARGV[" << i << "] = " << (void*)Dest << "\n"; |
Misha Brukman | edf128a | 2005-04-21 22:36:52 +0000 | [diff] [blame] | 247 | |
Chris Lattner | 87f0310 | 2003-12-26 06:50:30 +0000 | [diff] [blame] | 248 | std::copy(InputArgv[i].begin(), InputArgv[i].end(), Dest); |
| 249 | Dest[Size-1] = 0; |
Misha Brukman | edf128a | 2005-04-21 22:36:52 +0000 | [diff] [blame] | 250 | |
Chris Lattner | 87f0310 | 2003-12-26 06:50:30 +0000 | [diff] [blame] | 251 | // Endian safe: Result[i] = (PointerTy)Dest; |
| 252 | EE->StoreValueToMemory(PTOGV(Dest), (GenericValue*)(Result+i*PtrSize), |
| 253 | SBytePtr); |
| 254 | } |
| 255 | |
| 256 | // Null terminate it |
| 257 | EE->StoreValueToMemory(PTOGV(0), |
| 258 | (GenericValue*)(Result+InputArgv.size()*PtrSize), |
| 259 | SBytePtr); |
| 260 | return Result; |
| 261 | } |
| 262 | |
Chris Lattner | 9ca6cda | 2006-03-08 18:42:46 +0000 | [diff] [blame] | 263 | |
| 264 | /// runStaticConstructorsDestructors - This method is used to execute all of |
Evan Cheng | 18314dc | 2008-09-30 15:51:21 +0000 | [diff] [blame] | 265 | /// the static constructors or destructors for a module, depending on the |
Chris Lattner | 9ca6cda | 2006-03-08 18:42:46 +0000 | [diff] [blame] | 266 | /// value of isDtors. |
Evan Cheng | 18314dc | 2008-09-30 15:51:21 +0000 | [diff] [blame] | 267 | void ExecutionEngine::runStaticConstructorsDestructors(Module *module, bool isDtors) { |
Chris Lattner | 9ca6cda | 2006-03-08 18:42:46 +0000 | [diff] [blame] | 268 | const char *Name = isDtors ? "llvm.global_dtors" : "llvm.global_ctors"; |
Chris Lattner | 9ca6cda | 2006-03-08 18:42:46 +0000 | [diff] [blame] | 269 | |
Chris Lattner | fe85403 | 2006-08-16 01:24:12 +0000 | [diff] [blame] | 270 | // Execute global ctors/dtors for each module in the program. |
Chris Lattner | fe85403 | 2006-08-16 01:24:12 +0000 | [diff] [blame] | 271 | |
Evan Cheng | 18314dc | 2008-09-30 15:51:21 +0000 | [diff] [blame] | 272 | GlobalVariable *GV = module->getNamedGlobal(Name); |
| 273 | |
| 274 | // If this global has internal linkage, or if it has a use, then it must be |
| 275 | // an old-style (llvmgcc3) static ctor with __main linked in and in use. If |
| 276 | // this is the case, don't execute any of the global ctors, __main will do |
| 277 | // it. |
Rafael Espindola | bb46f52 | 2009-01-15 20:18:42 +0000 | [diff] [blame] | 278 | if (!GV || GV->isDeclaration() || GV->hasLocalLinkage()) return; |
Evan Cheng | 18314dc | 2008-09-30 15:51:21 +0000 | [diff] [blame] | 279 | |
| 280 | // Should be an array of '{ int, void ()* }' structs. The first value is |
| 281 | // the init priority, which we ignore. |
| 282 | ConstantArray *InitList = dyn_cast<ConstantArray>(GV->getInitializer()); |
| 283 | if (!InitList) return; |
| 284 | for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i) |
| 285 | if (ConstantStruct *CS = |
| 286 | dyn_cast<ConstantStruct>(InitList->getOperand(i))) { |
| 287 | if (CS->getNumOperands() != 2) return; // Not array of 2-element structs. |
| 288 | |
| 289 | Constant *FP = CS->getOperand(1); |
| 290 | if (FP->isNullValue()) |
| 291 | break; // Found a null terminator, exit. |
| 292 | |
| 293 | if (ConstantExpr *CE = dyn_cast<ConstantExpr>(FP)) |
| 294 | if (CE->isCast()) |
| 295 | FP = CE->getOperand(0); |
| 296 | if (Function *F = dyn_cast<Function>(FP)) { |
| 297 | // Execute the ctor/dtor function! |
| 298 | runFunction(F, std::vector<GenericValue>()); |
| 299 | } |
| 300 | } |
| 301 | } |
| 302 | |
| 303 | /// runStaticConstructorsDestructors - This method is used to execute all of |
| 304 | /// the static constructors or destructors for a program, depending on the |
| 305 | /// value of isDtors. |
| 306 | void ExecutionEngine::runStaticConstructorsDestructors(bool isDtors) { |
| 307 | // Execute global ctors/dtors for each module in the program. |
| 308 | for (unsigned m = 0, e = Modules.size(); m != e; ++m) |
| 309 | runStaticConstructorsDestructors(Modules[m]->getModule(), isDtors); |
Chris Lattner | 9ca6cda | 2006-03-08 18:42:46 +0000 | [diff] [blame] | 310 | } |
| 311 | |
Dan Gohman | b6e3d6c | 2008-08-26 01:38:29 +0000 | [diff] [blame] | 312 | #ifndef NDEBUG |
Duncan Sands | 8a43e9e | 2007-12-14 19:38:31 +0000 | [diff] [blame] | 313 | /// isTargetNullPtr - Return whether the target pointer stored at Loc is null. |
| 314 | static bool isTargetNullPtr(ExecutionEngine *EE, void *Loc) { |
| 315 | unsigned PtrSize = EE->getTargetData()->getPointerSize(); |
| 316 | for (unsigned i = 0; i < PtrSize; ++i) |
| 317 | if (*(i + (uint8_t*)Loc)) |
| 318 | return false; |
| 319 | return true; |
| 320 | } |
Dan Gohman | b6e3d6c | 2008-08-26 01:38:29 +0000 | [diff] [blame] | 321 | #endif |
Duncan Sands | 8a43e9e | 2007-12-14 19:38:31 +0000 | [diff] [blame] | 322 | |
Chris Lattner | 87f0310 | 2003-12-26 06:50:30 +0000 | [diff] [blame] | 323 | /// runFunctionAsMain - This is a helper function which wraps runFunction to |
| 324 | /// handle the common task of starting up main with the specified argc, argv, |
| 325 | /// and envp parameters. |
| 326 | int ExecutionEngine::runFunctionAsMain(Function *Fn, |
| 327 | const std::vector<std::string> &argv, |
| 328 | const char * const * envp) { |
| 329 | std::vector<GenericValue> GVArgs; |
| 330 | GenericValue GVArgc; |
Reid Spencer | 8fb0f19 | 2007-03-06 03:04:04 +0000 | [diff] [blame] | 331 | GVArgc.IntVal = APInt(32, argv.size()); |
Anton Korobeynikov | 499d8f0 | 2007-06-03 19:17:35 +0000 | [diff] [blame] | 332 | |
| 333 | // Check main() type |
Chris Lattner | f24d099 | 2004-08-16 01:05:35 +0000 | [diff] [blame] | 334 | unsigned NumArgs = Fn->getFunctionType()->getNumParams(); |
Anton Korobeynikov | 499d8f0 | 2007-06-03 19:17:35 +0000 | [diff] [blame] | 335 | const FunctionType *FTy = Fn->getFunctionType(); |
Christopher Lamb | 43ad6b3 | 2007-12-17 01:12:55 +0000 | [diff] [blame] | 336 | const Type* PPInt8Ty = |
| 337 | PointerType::getUnqual(PointerType::getUnqual(Type::Int8Ty)); |
Anton Korobeynikov | 499d8f0 | 2007-06-03 19:17:35 +0000 | [diff] [blame] | 338 | switch (NumArgs) { |
| 339 | case 3: |
| 340 | if (FTy->getParamType(2) != PPInt8Ty) { |
Torok Edwin | 7d696d8 | 2009-07-11 13:10:19 +0000 | [diff] [blame] | 341 | llvm_report_error("Invalid type for third argument of main() supplied"); |
Anton Korobeynikov | 499d8f0 | 2007-06-03 19:17:35 +0000 | [diff] [blame] | 342 | } |
Anton Korobeynikov | fb45086 | 2007-06-03 19:20:49 +0000 | [diff] [blame] | 343 | // FALLS THROUGH |
Anton Korobeynikov | 499d8f0 | 2007-06-03 19:17:35 +0000 | [diff] [blame] | 344 | case 2: |
| 345 | if (FTy->getParamType(1) != PPInt8Ty) { |
Torok Edwin | 7d696d8 | 2009-07-11 13:10:19 +0000 | [diff] [blame] | 346 | llvm_report_error("Invalid type for second argument of main() supplied"); |
Anton Korobeynikov | 499d8f0 | 2007-06-03 19:17:35 +0000 | [diff] [blame] | 347 | } |
Anton Korobeynikov | fb45086 | 2007-06-03 19:20:49 +0000 | [diff] [blame] | 348 | // FALLS THROUGH |
Anton Korobeynikov | 499d8f0 | 2007-06-03 19:17:35 +0000 | [diff] [blame] | 349 | case 1: |
| 350 | if (FTy->getParamType(0) != Type::Int32Ty) { |
Torok Edwin | 7d696d8 | 2009-07-11 13:10:19 +0000 | [diff] [blame] | 351 | llvm_report_error("Invalid type for first argument of main() supplied"); |
Anton Korobeynikov | 499d8f0 | 2007-06-03 19:17:35 +0000 | [diff] [blame] | 352 | } |
Anton Korobeynikov | fb45086 | 2007-06-03 19:20:49 +0000 | [diff] [blame] | 353 | // FALLS THROUGH |
Anton Korobeynikov | 499d8f0 | 2007-06-03 19:17:35 +0000 | [diff] [blame] | 354 | case 0: |
Chris Lattner | 45f3683 | 2009-02-04 17:48:18 +0000 | [diff] [blame] | 355 | if (!isa<IntegerType>(FTy->getReturnType()) && |
Anton Korobeynikov | 499d8f0 | 2007-06-03 19:17:35 +0000 | [diff] [blame] | 356 | FTy->getReturnType() != Type::VoidTy) { |
Torok Edwin | 7d696d8 | 2009-07-11 13:10:19 +0000 | [diff] [blame] | 357 | llvm_report_error("Invalid return type of main() supplied"); |
Anton Korobeynikov | 499d8f0 | 2007-06-03 19:17:35 +0000 | [diff] [blame] | 358 | } |
| 359 | break; |
| 360 | default: |
Torok Edwin | 7d696d8 | 2009-07-11 13:10:19 +0000 | [diff] [blame] | 361 | llvm_report_error("Invalid number of arguments of main() supplied"); |
Anton Korobeynikov | 499d8f0 | 2007-06-03 19:17:35 +0000 | [diff] [blame] | 362 | } |
| 363 | |
Chris Lattner | f24d099 | 2004-08-16 01:05:35 +0000 | [diff] [blame] | 364 | if (NumArgs) { |
| 365 | GVArgs.push_back(GVArgc); // Arg #0 = argc. |
| 366 | if (NumArgs > 1) { |
| 367 | GVArgs.push_back(PTOGV(CreateArgv(this, argv))); // Arg #1 = argv. |
Duncan Sands | 8a43e9e | 2007-12-14 19:38:31 +0000 | [diff] [blame] | 368 | assert(!isTargetNullPtr(this, GVTOP(GVArgs[1])) && |
Chris Lattner | f24d099 | 2004-08-16 01:05:35 +0000 | [diff] [blame] | 369 | "argv[0] was null after CreateArgv"); |
| 370 | if (NumArgs > 2) { |
| 371 | std::vector<std::string> EnvVars; |
| 372 | for (unsigned i = 0; envp[i]; ++i) |
| 373 | EnvVars.push_back(envp[i]); |
| 374 | GVArgs.push_back(PTOGV(CreateArgv(this, EnvVars))); // Arg #2 = envp. |
| 375 | } |
| 376 | } |
| 377 | } |
Reid Spencer | 8fb0f19 | 2007-03-06 03:04:04 +0000 | [diff] [blame] | 378 | return runFunction(Fn, GVArgs).IntVal.getZExtValue(); |
Chris Lattner | 87f0310 | 2003-12-26 06:50:30 +0000 | [diff] [blame] | 379 | } |
| 380 | |
Misha Brukman | 1968416 | 2003-10-16 21:18:05 +0000 | [diff] [blame] | 381 | /// If possible, create a JIT, unless the caller specifically requests an |
| 382 | /// Interpreter or there's an error. If even an Interpreter cannot be created, |
Misha Brukman | edf128a | 2005-04-21 22:36:52 +0000 | [diff] [blame] | 383 | /// NULL is returned. |
Misha Brukman | 4afac18 | 2003-10-10 17:45:12 +0000 | [diff] [blame] | 384 | /// |
Misha Brukman | edf128a | 2005-04-21 22:36:52 +0000 | [diff] [blame] | 385 | ExecutionEngine *ExecutionEngine::create(ModuleProvider *MP, |
Reid Spencer | d4c0e62 | 2007-03-03 18:19:18 +0000 | [diff] [blame] | 386 | bool ForceInterpreter, |
Evan Cheng | 502f20b | 2008-08-08 08:11:34 +0000 | [diff] [blame] | 387 | std::string *ErrorStr, |
Jeffrey Yasskin | 489393d | 2009-07-08 21:59:57 +0000 | [diff] [blame] | 388 | CodeGenOpt::Level OptLevel, |
| 389 | bool GVsWithCode) { |
Reid Kleckner | 4b1511b | 2009-07-18 00:42:18 +0000 | [diff] [blame] | 390 | return EngineBuilder(MP) |
| 391 | .setEngineKind(ForceInterpreter |
| 392 | ? EngineKind::Interpreter |
| 393 | : EngineKind::JIT) |
| 394 | .setErrorStr(ErrorStr) |
| 395 | .setOptLevel(OptLevel) |
| 396 | .setAllocateGVsWithCode(GVsWithCode) |
| 397 | .create(); |
| 398 | } |
Brian Gaeke | 82d8277 | 2003-09-03 20:34:19 +0000 | [diff] [blame] | 399 | |
Reid Kleckner | 4b1511b | 2009-07-18 00:42:18 +0000 | [diff] [blame] | 400 | ExecutionEngine *ExecutionEngine::create(Module *M) { |
| 401 | return EngineBuilder(M).create(); |
| 402 | } |
| 403 | |
| 404 | /// EngineBuilder - Overloaded constructor that automatically creates an |
| 405 | /// ExistingModuleProvider for an existing module. |
| 406 | EngineBuilder::EngineBuilder(Module *m) : MP(new ExistingModuleProvider(m)) { |
| 407 | InitEngine(); |
| 408 | } |
| 409 | |
| 410 | ExecutionEngine *EngineBuilder::create() { |
Nick Lewycky | 6456d86 | 2008-03-08 02:49:45 +0000 | [diff] [blame] | 411 | // Make sure we can resolve symbols in the program as well. The zero arg |
| 412 | // to the function tells DynamicLibrary to load the program, not a library. |
| 413 | if (sys::DynamicLibrary::LoadLibraryPermanently(0, ErrorStr)) |
| 414 | return 0; |
| 415 | |
Reid Kleckner | 4b1511b | 2009-07-18 00:42:18 +0000 | [diff] [blame] | 416 | // If the user specified a memory manager but didn't specify which engine to |
| 417 | // create, we assume they only want the JIT, and we fail if they only want |
| 418 | // the interpreter. |
| 419 | if (JMM) { |
| 420 | if (WhichEngine & EngineKind::JIT) { |
| 421 | WhichEngine = EngineKind::JIT; |
| 422 | } else { |
| 423 | *ErrorStr = "Cannot create an interpreter with a memory manager."; |
| 424 | } |
| 425 | } |
Brian Gaeke | 82d8277 | 2003-09-03 20:34:19 +0000 | [diff] [blame] | 426 | |
Reid Kleckner | 4b1511b | 2009-07-18 00:42:18 +0000 | [diff] [blame] | 427 | ExecutionEngine *EE = 0; |
| 428 | |
| 429 | // Unless the interpreter was explicitly selected or the JIT is not linked, |
| 430 | // try making a JIT. |
| 431 | if (WhichEngine & EngineKind::JIT && ExecutionEngine::JITCtor) { |
| 432 | EE = ExecutionEngine::JITCtor(MP, ErrorStr, JMM, OptLevel, |
| 433 | AllocateGVsWithCode); |
| 434 | } |
| 435 | |
| 436 | // If we can't make a JIT and we didn't request one specifically, try making |
| 437 | // an interpreter instead. |
| 438 | if (WhichEngine & EngineKind::Interpreter && EE == 0 && |
| 439 | ExecutionEngine::InterpCtor) { |
| 440 | EE = ExecutionEngine::InterpCtor(MP, ErrorStr); |
| 441 | } |
Chris Lattner | 7301178 | 2003-12-28 09:44:37 +0000 | [diff] [blame] | 442 | |
Brian Gaeke | 82d8277 | 2003-09-03 20:34:19 +0000 | [diff] [blame] | 443 | return EE; |
| 444 | } |
| 445 | |
Misha Brukman | 4afac18 | 2003-10-10 17:45:12 +0000 | [diff] [blame] | 446 | /// getPointerToGlobal - This returns the address of the specified global |
| 447 | /// value. This may involve code generation if it's a function. |
| 448 | /// |
Chris Lattner | bd199fb | 2002-12-24 00:01:05 +0000 | [diff] [blame] | 449 | void *ExecutionEngine::getPointerToGlobal(const GlobalValue *GV) { |
Brian Gaeke | 37df460 | 2003-08-13 18:16:14 +0000 | [diff] [blame] | 450 | if (Function *F = const_cast<Function*>(dyn_cast<Function>(GV))) |
Chris Lattner | bd199fb | 2002-12-24 00:01:05 +0000 | [diff] [blame] | 451 | return getPointerToFunction(F); |
| 452 | |
Reid Spencer | ee44863 | 2005-07-12 15:51:55 +0000 | [diff] [blame] | 453 | MutexGuard locked(lock); |
Jeff Cohen | 68835dd | 2006-02-07 05:11:57 +0000 | [diff] [blame] | 454 | void *p = state.getGlobalAddressMap(locked)[GV]; |
| 455 | if (p) |
| 456 | return p; |
| 457 | |
| 458 | // Global variable might have been added since interpreter started. |
| 459 | if (GlobalVariable *GVar = |
| 460 | const_cast<GlobalVariable *>(dyn_cast<GlobalVariable>(GV))) |
| 461 | EmitGlobalVariable(GVar); |
| 462 | else |
Torok Edwin | c23197a | 2009-07-14 16:55:14 +0000 | [diff] [blame] | 463 | llvm_unreachable("Global hasn't had an address allocated yet!"); |
Reid Spencer | ee44863 | 2005-07-12 15:51:55 +0000 | [diff] [blame] | 464 | return state.getGlobalAddressMap(locked)[GV]; |
Chris Lattner | bd199fb | 2002-12-24 00:01:05 +0000 | [diff] [blame] | 465 | } |
| 466 | |
Reid Spencer | 3da59db | 2006-11-27 01:05:10 +0000 | [diff] [blame] | 467 | /// This function converts a Constant* into a GenericValue. The interesting |
| 468 | /// part is if C is a ConstantExpr. |
Reid Spencer | ba28cb9 | 2007-08-11 15:57:56 +0000 | [diff] [blame] | 469 | /// @brief Get a GenericValue for a Constant* |
Chris Lattner | bd199fb | 2002-12-24 00:01:05 +0000 | [diff] [blame] | 470 | GenericValue ExecutionEngine::getConstantValue(const Constant *C) { |
Reid Spencer | 3da59db | 2006-11-27 01:05:10 +0000 | [diff] [blame] | 471 | // If its undefined, return the garbage. |
Reid Spencer | bce30f1 | 2007-03-06 22:23:15 +0000 | [diff] [blame] | 472 | if (isa<UndefValue>(C)) |
| 473 | return GenericValue(); |
Chris Lattner | d8c03bf | 2003-04-23 19:01:49 +0000 | [diff] [blame] | 474 | |
Reid Spencer | 3da59db | 2006-11-27 01:05:10 +0000 | [diff] [blame] | 475 | // If the value is a ConstantExpr |
| 476 | if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) { |
Reid Spencer | bce30f1 | 2007-03-06 22:23:15 +0000 | [diff] [blame] | 477 | Constant *Op0 = CE->getOperand(0); |
Chris Lattner | d8c03bf | 2003-04-23 19:01:49 +0000 | [diff] [blame] | 478 | switch (CE->getOpcode()) { |
| 479 | case Instruction::GetElementPtr: { |
Reid Spencer | 3da59db | 2006-11-27 01:05:10 +0000 | [diff] [blame] | 480 | // Compute the index |
Reid Spencer | bce30f1 | 2007-03-06 22:23:15 +0000 | [diff] [blame] | 481 | GenericValue Result = getConstantValue(Op0); |
Chris Lattner | 829621c | 2007-02-10 20:35:22 +0000 | [diff] [blame] | 482 | SmallVector<Value*, 8> Indices(CE->op_begin()+1, CE->op_end()); |
Chris Lattner | d8c03bf | 2003-04-23 19:01:49 +0000 | [diff] [blame] | 483 | uint64_t Offset = |
Reid Spencer | bce30f1 | 2007-03-06 22:23:15 +0000 | [diff] [blame] | 484 | TD->getIndexedOffset(Op0->getType(), &Indices[0], Indices.size()); |
Misha Brukman | edf128a | 2005-04-21 22:36:52 +0000 | [diff] [blame] | 485 | |
Reid Spencer | 8fb0f19 | 2007-03-06 03:04:04 +0000 | [diff] [blame] | 486 | char* tmp = (char*) Result.PointerVal; |
| 487 | Result = PTOGV(tmp + Offset); |
Chris Lattner | d8c03bf | 2003-04-23 19:01:49 +0000 | [diff] [blame] | 488 | return Result; |
| 489 | } |
Reid Spencer | bce30f1 | 2007-03-06 22:23:15 +0000 | [diff] [blame] | 490 | case Instruction::Trunc: { |
| 491 | GenericValue GV = getConstantValue(Op0); |
| 492 | uint32_t BitWidth = cast<IntegerType>(CE->getType())->getBitWidth(); |
| 493 | GV.IntVal = GV.IntVal.trunc(BitWidth); |
| 494 | return GV; |
| 495 | } |
| 496 | case Instruction::ZExt: { |
| 497 | GenericValue GV = getConstantValue(Op0); |
| 498 | uint32_t BitWidth = cast<IntegerType>(CE->getType())->getBitWidth(); |
| 499 | GV.IntVal = GV.IntVal.zext(BitWidth); |
| 500 | return GV; |
| 501 | } |
| 502 | case Instruction::SExt: { |
| 503 | GenericValue GV = getConstantValue(Op0); |
| 504 | uint32_t BitWidth = cast<IntegerType>(CE->getType())->getBitWidth(); |
| 505 | GV.IntVal = GV.IntVal.sext(BitWidth); |
| 506 | return GV; |
| 507 | } |
| 508 | case Instruction::FPTrunc: { |
Dale Johannesen | 1abac0d | 2007-09-17 18:44:13 +0000 | [diff] [blame] | 509 | // FIXME long double |
Reid Spencer | bce30f1 | 2007-03-06 22:23:15 +0000 | [diff] [blame] | 510 | GenericValue GV = getConstantValue(Op0); |
| 511 | GV.FloatVal = float(GV.DoubleVal); |
| 512 | return GV; |
| 513 | } |
| 514 | case Instruction::FPExt:{ |
Dale Johannesen | 1abac0d | 2007-09-17 18:44:13 +0000 | [diff] [blame] | 515 | // FIXME long double |
Reid Spencer | bce30f1 | 2007-03-06 22:23:15 +0000 | [diff] [blame] | 516 | GenericValue GV = getConstantValue(Op0); |
| 517 | GV.DoubleVal = double(GV.FloatVal); |
| 518 | return GV; |
| 519 | } |
| 520 | case Instruction::UIToFP: { |
| 521 | GenericValue GV = getConstantValue(Op0); |
| 522 | if (CE->getType() == Type::FloatTy) |
| 523 | GV.FloatVal = float(GV.IntVal.roundToDouble()); |
Dale Johannesen | 1abac0d | 2007-09-17 18:44:13 +0000 | [diff] [blame] | 524 | else if (CE->getType() == Type::DoubleTy) |
Reid Spencer | bce30f1 | 2007-03-06 22:23:15 +0000 | [diff] [blame] | 525 | GV.DoubleVal = GV.IntVal.roundToDouble(); |
Dale Johannesen | 910993e | 2007-09-21 22:09:37 +0000 | [diff] [blame] | 526 | else if (CE->getType() == Type::X86_FP80Ty) { |
Dale Johannesen | 1abac0d | 2007-09-17 18:44:13 +0000 | [diff] [blame] | 527 | const uint64_t zero[] = {0, 0}; |
| 528 | APFloat apf = APFloat(APInt(80, 2, zero)); |
Dan Gohman | 6282406 | 2008-02-29 01:27:13 +0000 | [diff] [blame] | 529 | (void)apf.convertFromAPInt(GV.IntVal, |
| 530 | false, |
| 531 | APFloat::rmNearestTiesToEven); |
Dale Johannesen | 7111b02 | 2008-10-09 18:53:47 +0000 | [diff] [blame] | 532 | GV.IntVal = apf.bitcastToAPInt(); |
Dale Johannesen | 1abac0d | 2007-09-17 18:44:13 +0000 | [diff] [blame] | 533 | } |
Reid Spencer | bce30f1 | 2007-03-06 22:23:15 +0000 | [diff] [blame] | 534 | return GV; |
| 535 | } |
| 536 | case Instruction::SIToFP: { |
| 537 | GenericValue GV = getConstantValue(Op0); |
| 538 | if (CE->getType() == Type::FloatTy) |
| 539 | GV.FloatVal = float(GV.IntVal.signedRoundToDouble()); |
Dale Johannesen | 1abac0d | 2007-09-17 18:44:13 +0000 | [diff] [blame] | 540 | else if (CE->getType() == Type::DoubleTy) |
Reid Spencer | bce30f1 | 2007-03-06 22:23:15 +0000 | [diff] [blame] | 541 | GV.DoubleVal = GV.IntVal.signedRoundToDouble(); |
Dale Johannesen | 1abac0d | 2007-09-17 18:44:13 +0000 | [diff] [blame] | 542 | else if (CE->getType() == Type::X86_FP80Ty) { |
| 543 | const uint64_t zero[] = { 0, 0}; |
| 544 | APFloat apf = APFloat(APInt(80, 2, zero)); |
Dan Gohman | 6282406 | 2008-02-29 01:27:13 +0000 | [diff] [blame] | 545 | (void)apf.convertFromAPInt(GV.IntVal, |
| 546 | true, |
| 547 | APFloat::rmNearestTiesToEven); |
Dale Johannesen | 7111b02 | 2008-10-09 18:53:47 +0000 | [diff] [blame] | 548 | GV.IntVal = apf.bitcastToAPInt(); |
Dale Johannesen | 1abac0d | 2007-09-17 18:44:13 +0000 | [diff] [blame] | 549 | } |
Reid Spencer | bce30f1 | 2007-03-06 22:23:15 +0000 | [diff] [blame] | 550 | return GV; |
| 551 | } |
| 552 | case Instruction::FPToUI: // double->APInt conversion handles sign |
| 553 | case Instruction::FPToSI: { |
| 554 | GenericValue GV = getConstantValue(Op0); |
| 555 | uint32_t BitWidth = cast<IntegerType>(CE->getType())->getBitWidth(); |
| 556 | if (Op0->getType() == Type::FloatTy) |
| 557 | GV.IntVal = APIntOps::RoundFloatToAPInt(GV.FloatVal, BitWidth); |
Dale Johannesen | 1abac0d | 2007-09-17 18:44:13 +0000 | [diff] [blame] | 558 | else if (Op0->getType() == Type::DoubleTy) |
Reid Spencer | bce30f1 | 2007-03-06 22:23:15 +0000 | [diff] [blame] | 559 | GV.IntVal = APIntOps::RoundDoubleToAPInt(GV.DoubleVal, BitWidth); |
Dale Johannesen | 1abac0d | 2007-09-17 18:44:13 +0000 | [diff] [blame] | 560 | else if (Op0->getType() == Type::X86_FP80Ty) { |
| 561 | APFloat apf = APFloat(GV.IntVal); |
| 562 | uint64_t v; |
Dale Johannesen | 23a9855 | 2008-10-09 23:00:39 +0000 | [diff] [blame] | 563 | bool ignored; |
Dale Johannesen | 1abac0d | 2007-09-17 18:44:13 +0000 | [diff] [blame] | 564 | (void)apf.convertToInteger(&v, BitWidth, |
| 565 | CE->getOpcode()==Instruction::FPToSI, |
Dale Johannesen | 23a9855 | 2008-10-09 23:00:39 +0000 | [diff] [blame] | 566 | APFloat::rmTowardZero, &ignored); |
Dale Johannesen | 1abac0d | 2007-09-17 18:44:13 +0000 | [diff] [blame] | 567 | GV.IntVal = v; // endian? |
| 568 | } |
Reid Spencer | bce30f1 | 2007-03-06 22:23:15 +0000 | [diff] [blame] | 569 | return GV; |
| 570 | } |
Reid Spencer | 3da59db | 2006-11-27 01:05:10 +0000 | [diff] [blame] | 571 | case Instruction::PtrToInt: { |
Reid Spencer | bce30f1 | 2007-03-06 22:23:15 +0000 | [diff] [blame] | 572 | GenericValue GV = getConstantValue(Op0); |
| 573 | uint32_t PtrWidth = TD->getPointerSizeInBits(); |
| 574 | GV.IntVal = APInt(PtrWidth, uintptr_t(GV.PointerVal)); |
| 575 | return GV; |
| 576 | } |
| 577 | case Instruction::IntToPtr: { |
| 578 | GenericValue GV = getConstantValue(Op0); |
| 579 | uint32_t PtrWidth = TD->getPointerSizeInBits(); |
| 580 | if (PtrWidth != GV.IntVal.getBitWidth()) |
| 581 | GV.IntVal = GV.IntVal.zextOrTrunc(PtrWidth); |
| 582 | assert(GV.IntVal.getBitWidth() <= 64 && "Bad pointer width"); |
| 583 | GV.PointerVal = PointerTy(uintptr_t(GV.IntVal.getZExtValue())); |
Reid Spencer | 3da59db | 2006-11-27 01:05:10 +0000 | [diff] [blame] | 584 | return GV; |
| 585 | } |
| 586 | case Instruction::BitCast: { |
Reid Spencer | bce30f1 | 2007-03-06 22:23:15 +0000 | [diff] [blame] | 587 | GenericValue GV = getConstantValue(Op0); |
| 588 | const Type* DestTy = CE->getType(); |
| 589 | switch (Op0->getType()->getTypeID()) { |
Torok Edwin | c23197a | 2009-07-14 16:55:14 +0000 | [diff] [blame] | 590 | default: llvm_unreachable("Invalid bitcast operand"); |
Reid Spencer | bce30f1 | 2007-03-06 22:23:15 +0000 | [diff] [blame] | 591 | case Type::IntegerTyID: |
| 592 | assert(DestTy->isFloatingPoint() && "invalid bitcast"); |
| 593 | if (DestTy == Type::FloatTy) |
| 594 | GV.FloatVal = GV.IntVal.bitsToFloat(); |
| 595 | else if (DestTy == Type::DoubleTy) |
| 596 | GV.DoubleVal = GV.IntVal.bitsToDouble(); |
| 597 | break; |
| 598 | case Type::FloatTyID: |
| 599 | assert(DestTy == Type::Int32Ty && "Invalid bitcast"); |
| 600 | GV.IntVal.floatToBits(GV.FloatVal); |
| 601 | break; |
| 602 | case Type::DoubleTyID: |
| 603 | assert(DestTy == Type::Int64Ty && "Invalid bitcast"); |
| 604 | GV.IntVal.doubleToBits(GV.DoubleVal); |
| 605 | break; |
| 606 | case Type::PointerTyID: |
| 607 | assert(isa<PointerType>(DestTy) && "Invalid bitcast"); |
| 608 | break; // getConstantValue(Op0) above already converted it |
| 609 | } |
| 610 | return GV; |
Chris Lattner | d8c03bf | 2003-04-23 19:01:49 +0000 | [diff] [blame] | 611 | } |
Chris Lattner | 9a23122 | 2003-05-14 17:51:49 +0000 | [diff] [blame] | 612 | case Instruction::Add: |
Dan Gohman | ae3a0be | 2009-06-04 22:49:04 +0000 | [diff] [blame] | 613 | case Instruction::FAdd: |
Reid Spencer | bce30f1 | 2007-03-06 22:23:15 +0000 | [diff] [blame] | 614 | case Instruction::Sub: |
Dan Gohman | ae3a0be | 2009-06-04 22:49:04 +0000 | [diff] [blame] | 615 | case Instruction::FSub: |
Reid Spencer | bce30f1 | 2007-03-06 22:23:15 +0000 | [diff] [blame] | 616 | case Instruction::Mul: |
Dan Gohman | ae3a0be | 2009-06-04 22:49:04 +0000 | [diff] [blame] | 617 | case Instruction::FMul: |
Reid Spencer | bce30f1 | 2007-03-06 22:23:15 +0000 | [diff] [blame] | 618 | case Instruction::UDiv: |
| 619 | case Instruction::SDiv: |
| 620 | case Instruction::URem: |
| 621 | case Instruction::SRem: |
| 622 | case Instruction::And: |
| 623 | case Instruction::Or: |
| 624 | case Instruction::Xor: { |
| 625 | GenericValue LHS = getConstantValue(Op0); |
| 626 | GenericValue RHS = getConstantValue(CE->getOperand(1)); |
| 627 | GenericValue GV; |
Chris Lattner | 5f90cb8 | 2004-07-11 08:01:11 +0000 | [diff] [blame] | 628 | switch (CE->getOperand(0)->getType()->getTypeID()) { |
Torok Edwin | c23197a | 2009-07-14 16:55:14 +0000 | [diff] [blame] | 629 | default: llvm_unreachable("Bad add type!"); |
Reid Spencer | a54b7cb | 2007-01-12 07:05:14 +0000 | [diff] [blame] | 630 | case Type::IntegerTyID: |
Reid Spencer | bce30f1 | 2007-03-06 22:23:15 +0000 | [diff] [blame] | 631 | switch (CE->getOpcode()) { |
Torok Edwin | c23197a | 2009-07-14 16:55:14 +0000 | [diff] [blame] | 632 | default: llvm_unreachable("Invalid integer opcode"); |
Reid Spencer | bce30f1 | 2007-03-06 22:23:15 +0000 | [diff] [blame] | 633 | case Instruction::Add: GV.IntVal = LHS.IntVal + RHS.IntVal; break; |
| 634 | case Instruction::Sub: GV.IntVal = LHS.IntVal - RHS.IntVal; break; |
| 635 | case Instruction::Mul: GV.IntVal = LHS.IntVal * RHS.IntVal; break; |
| 636 | case Instruction::UDiv:GV.IntVal = LHS.IntVal.udiv(RHS.IntVal); break; |
| 637 | case Instruction::SDiv:GV.IntVal = LHS.IntVal.sdiv(RHS.IntVal); break; |
| 638 | case Instruction::URem:GV.IntVal = LHS.IntVal.urem(RHS.IntVal); break; |
| 639 | case Instruction::SRem:GV.IntVal = LHS.IntVal.srem(RHS.IntVal); break; |
| 640 | case Instruction::And: GV.IntVal = LHS.IntVal & RHS.IntVal; break; |
| 641 | case Instruction::Or: GV.IntVal = LHS.IntVal | RHS.IntVal; break; |
| 642 | case Instruction::Xor: GV.IntVal = LHS.IntVal ^ RHS.IntVal; break; |
| 643 | } |
Chris Lattner | 5f90cb8 | 2004-07-11 08:01:11 +0000 | [diff] [blame] | 644 | break; |
| 645 | case Type::FloatTyID: |
Reid Spencer | bce30f1 | 2007-03-06 22:23:15 +0000 | [diff] [blame] | 646 | switch (CE->getOpcode()) { |
Torok Edwin | c23197a | 2009-07-14 16:55:14 +0000 | [diff] [blame] | 647 | default: llvm_unreachable("Invalid float opcode"); |
Dan Gohman | ae3a0be | 2009-06-04 22:49:04 +0000 | [diff] [blame] | 648 | case Instruction::FAdd: |
Reid Spencer | bce30f1 | 2007-03-06 22:23:15 +0000 | [diff] [blame] | 649 | GV.FloatVal = LHS.FloatVal + RHS.FloatVal; break; |
Dan Gohman | ae3a0be | 2009-06-04 22:49:04 +0000 | [diff] [blame] | 650 | case Instruction::FSub: |
Reid Spencer | bce30f1 | 2007-03-06 22:23:15 +0000 | [diff] [blame] | 651 | GV.FloatVal = LHS.FloatVal - RHS.FloatVal; break; |
Dan Gohman | ae3a0be | 2009-06-04 22:49:04 +0000 | [diff] [blame] | 652 | case Instruction::FMul: |
Reid Spencer | bce30f1 | 2007-03-06 22:23:15 +0000 | [diff] [blame] | 653 | GV.FloatVal = LHS.FloatVal * RHS.FloatVal; break; |
| 654 | case Instruction::FDiv: |
| 655 | GV.FloatVal = LHS.FloatVal / RHS.FloatVal; break; |
| 656 | case Instruction::FRem: |
| 657 | GV.FloatVal = ::fmodf(LHS.FloatVal,RHS.FloatVal); break; |
| 658 | } |
Chris Lattner | 5f90cb8 | 2004-07-11 08:01:11 +0000 | [diff] [blame] | 659 | break; |
| 660 | case Type::DoubleTyID: |
Reid Spencer | bce30f1 | 2007-03-06 22:23:15 +0000 | [diff] [blame] | 661 | switch (CE->getOpcode()) { |
Torok Edwin | c23197a | 2009-07-14 16:55:14 +0000 | [diff] [blame] | 662 | default: llvm_unreachable("Invalid double opcode"); |
Dan Gohman | ae3a0be | 2009-06-04 22:49:04 +0000 | [diff] [blame] | 663 | case Instruction::FAdd: |
Reid Spencer | bce30f1 | 2007-03-06 22:23:15 +0000 | [diff] [blame] | 664 | GV.DoubleVal = LHS.DoubleVal + RHS.DoubleVal; break; |
Dan Gohman | ae3a0be | 2009-06-04 22:49:04 +0000 | [diff] [blame] | 665 | case Instruction::FSub: |
Reid Spencer | bce30f1 | 2007-03-06 22:23:15 +0000 | [diff] [blame] | 666 | GV.DoubleVal = LHS.DoubleVal - RHS.DoubleVal; break; |
Dan Gohman | ae3a0be | 2009-06-04 22:49:04 +0000 | [diff] [blame] | 667 | case Instruction::FMul: |
Reid Spencer | bce30f1 | 2007-03-06 22:23:15 +0000 | [diff] [blame] | 668 | GV.DoubleVal = LHS.DoubleVal * RHS.DoubleVal; break; |
| 669 | case Instruction::FDiv: |
| 670 | GV.DoubleVal = LHS.DoubleVal / RHS.DoubleVal; break; |
| 671 | case Instruction::FRem: |
| 672 | GV.DoubleVal = ::fmod(LHS.DoubleVal,RHS.DoubleVal); break; |
| 673 | } |
Chris Lattner | 5f90cb8 | 2004-07-11 08:01:11 +0000 | [diff] [blame] | 674 | break; |
Dale Johannesen | 1abac0d | 2007-09-17 18:44:13 +0000 | [diff] [blame] | 675 | case Type::X86_FP80TyID: |
| 676 | case Type::PPC_FP128TyID: |
| 677 | case Type::FP128TyID: { |
| 678 | APFloat apfLHS = APFloat(LHS.IntVal); |
| 679 | switch (CE->getOpcode()) { |
Torok Edwin | c23197a | 2009-07-14 16:55:14 +0000 | [diff] [blame] | 680 | default: llvm_unreachable("Invalid long double opcode");llvm_unreachable(0); |
Dan Gohman | ae3a0be | 2009-06-04 22:49:04 +0000 | [diff] [blame] | 681 | case Instruction::FAdd: |
Dale Johannesen | 1abac0d | 2007-09-17 18:44:13 +0000 | [diff] [blame] | 682 | apfLHS.add(APFloat(RHS.IntVal), APFloat::rmNearestTiesToEven); |
Dale Johannesen | 7111b02 | 2008-10-09 18:53:47 +0000 | [diff] [blame] | 683 | GV.IntVal = apfLHS.bitcastToAPInt(); |
Dale Johannesen | 1abac0d | 2007-09-17 18:44:13 +0000 | [diff] [blame] | 684 | break; |
Dan Gohman | ae3a0be | 2009-06-04 22:49:04 +0000 | [diff] [blame] | 685 | case Instruction::FSub: |
Dale Johannesen | 1abac0d | 2007-09-17 18:44:13 +0000 | [diff] [blame] | 686 | apfLHS.subtract(APFloat(RHS.IntVal), APFloat::rmNearestTiesToEven); |
Dale Johannesen | 7111b02 | 2008-10-09 18:53:47 +0000 | [diff] [blame] | 687 | GV.IntVal = apfLHS.bitcastToAPInt(); |
Dale Johannesen | 1abac0d | 2007-09-17 18:44:13 +0000 | [diff] [blame] | 688 | break; |
Dan Gohman | ae3a0be | 2009-06-04 22:49:04 +0000 | [diff] [blame] | 689 | case Instruction::FMul: |
Dale Johannesen | 1abac0d | 2007-09-17 18:44:13 +0000 | [diff] [blame] | 690 | apfLHS.multiply(APFloat(RHS.IntVal), APFloat::rmNearestTiesToEven); |
Dale Johannesen | 7111b02 | 2008-10-09 18:53:47 +0000 | [diff] [blame] | 691 | GV.IntVal = apfLHS.bitcastToAPInt(); |
Dale Johannesen | 1abac0d | 2007-09-17 18:44:13 +0000 | [diff] [blame] | 692 | break; |
| 693 | case Instruction::FDiv: |
| 694 | apfLHS.divide(APFloat(RHS.IntVal), APFloat::rmNearestTiesToEven); |
Dale Johannesen | 7111b02 | 2008-10-09 18:53:47 +0000 | [diff] [blame] | 695 | GV.IntVal = apfLHS.bitcastToAPInt(); |
Dale Johannesen | 1abac0d | 2007-09-17 18:44:13 +0000 | [diff] [blame] | 696 | break; |
| 697 | case Instruction::FRem: |
| 698 | apfLHS.mod(APFloat(RHS.IntVal), APFloat::rmNearestTiesToEven); |
Dale Johannesen | 7111b02 | 2008-10-09 18:53:47 +0000 | [diff] [blame] | 699 | GV.IntVal = apfLHS.bitcastToAPInt(); |
Dale Johannesen | 1abac0d | 2007-09-17 18:44:13 +0000 | [diff] [blame] | 700 | break; |
| 701 | } |
| 702 | } |
| 703 | break; |
Chris Lattner | 5f90cb8 | 2004-07-11 08:01:11 +0000 | [diff] [blame] | 704 | } |
Reid Spencer | bce30f1 | 2007-03-06 22:23:15 +0000 | [diff] [blame] | 705 | return GV; |
| 706 | } |
Chris Lattner | 9a23122 | 2003-05-14 17:51:49 +0000 | [diff] [blame] | 707 | default: |
| 708 | break; |
| 709 | } |
Torok Edwin | 7d696d8 | 2009-07-11 13:10:19 +0000 | [diff] [blame] | 710 | std::string msg; |
| 711 | raw_string_ostream Msg(msg); |
| 712 | Msg << "ConstantExpr not handled: " << *CE; |
| 713 | llvm_report_error(Msg.str()); |
Chris Lattner | 9a23122 | 2003-05-14 17:51:49 +0000 | [diff] [blame] | 714 | } |
Misha Brukman | edf128a | 2005-04-21 22:36:52 +0000 | [diff] [blame] | 715 | |
Reid Spencer | bce30f1 | 2007-03-06 22:23:15 +0000 | [diff] [blame] | 716 | GenericValue Result; |
Chris Lattner | f70c22b | 2004-06-17 18:19:28 +0000 | [diff] [blame] | 717 | switch (C->getType()->getTypeID()) { |
Reid Spencer | 8fb0f19 | 2007-03-06 03:04:04 +0000 | [diff] [blame] | 718 | case Type::FloatTyID: |
Dale Johannesen | 43421b3 | 2007-09-06 18:13:44 +0000 | [diff] [blame] | 719 | Result.FloatVal = cast<ConstantFP>(C)->getValueAPF().convertToFloat(); |
Reid Spencer | a54b7cb | 2007-01-12 07:05:14 +0000 | [diff] [blame] | 720 | break; |
Reid Spencer | 8fb0f19 | 2007-03-06 03:04:04 +0000 | [diff] [blame] | 721 | case Type::DoubleTyID: |
Dale Johannesen | 43421b3 | 2007-09-06 18:13:44 +0000 | [diff] [blame] | 722 | Result.DoubleVal = cast<ConstantFP>(C)->getValueAPF().convertToDouble(); |
Reid Spencer | 8fb0f19 | 2007-03-06 03:04:04 +0000 | [diff] [blame] | 723 | break; |
Dale Johannesen | 1abac0d | 2007-09-17 18:44:13 +0000 | [diff] [blame] | 724 | case Type::X86_FP80TyID: |
| 725 | case Type::FP128TyID: |
| 726 | case Type::PPC_FP128TyID: |
Dale Johannesen | 7111b02 | 2008-10-09 18:53:47 +0000 | [diff] [blame] | 727 | Result.IntVal = cast <ConstantFP>(C)->getValueAPF().bitcastToAPInt(); |
Dale Johannesen | 1abac0d | 2007-09-17 18:44:13 +0000 | [diff] [blame] | 728 | break; |
Reid Spencer | 8fb0f19 | 2007-03-06 03:04:04 +0000 | [diff] [blame] | 729 | case Type::IntegerTyID: |
| 730 | Result.IntVal = cast<ConstantInt>(C)->getValue(); |
| 731 | break; |
Chris Lattner | bd199fb | 2002-12-24 00:01:05 +0000 | [diff] [blame] | 732 | case Type::PointerTyID: |
Reid Spencer | 40cf2f9 | 2004-07-18 00:41:27 +0000 | [diff] [blame] | 733 | if (isa<ConstantPointerNull>(C)) |
Chris Lattner | bd199fb | 2002-12-24 00:01:05 +0000 | [diff] [blame] | 734 | Result.PointerVal = 0; |
Reid Spencer | 40cf2f9 | 2004-07-18 00:41:27 +0000 | [diff] [blame] | 735 | else if (const Function *F = dyn_cast<Function>(C)) |
| 736 | Result = PTOGV(getPointerToFunctionOrStub(const_cast<Function*>(F))); |
| 737 | else if (const GlobalVariable* GV = dyn_cast<GlobalVariable>(C)) |
| 738 | Result = PTOGV(getOrEmitGlobalVariable(const_cast<GlobalVariable*>(GV))); |
| 739 | else |
Torok Edwin | c23197a | 2009-07-14 16:55:14 +0000 | [diff] [blame] | 740 | llvm_unreachable("Unknown constant pointer type!"); |
Chris Lattner | bd199fb | 2002-12-24 00:01:05 +0000 | [diff] [blame] | 741 | break; |
| 742 | default: |
Torok Edwin | 7d696d8 | 2009-07-11 13:10:19 +0000 | [diff] [blame] | 743 | std::string msg; |
| 744 | raw_string_ostream Msg(msg); |
| 745 | Msg << "ERROR: Constant unimplemented for type: " << *C->getType(); |
| 746 | llvm_report_error(Msg.str()); |
Chris Lattner | bd199fb | 2002-12-24 00:01:05 +0000 | [diff] [blame] | 747 | } |
| 748 | return Result; |
| 749 | } |
| 750 | |
Duncan Sands | 8a43e9e | 2007-12-14 19:38:31 +0000 | [diff] [blame] | 751 | /// StoreIntToMemory - Fills the StoreBytes bytes of memory starting from Dst |
| 752 | /// with the integer held in IntVal. |
| 753 | static void StoreIntToMemory(const APInt &IntVal, uint8_t *Dst, |
| 754 | unsigned StoreBytes) { |
| 755 | assert((IntVal.getBitWidth()+7)/8 >= StoreBytes && "Integer too small!"); |
| 756 | uint8_t *Src = (uint8_t *)IntVal.getRawData(); |
| 757 | |
Chris Lattner | b67c958 | 2009-01-22 19:53:00 +0000 | [diff] [blame] | 758 | if (sys::isLittleEndianHost()) |
Duncan Sands | 8a43e9e | 2007-12-14 19:38:31 +0000 | [diff] [blame] | 759 | // Little-endian host - the source is ordered from LSB to MSB. Order the |
| 760 | // destination from LSB to MSB: Do a straight copy. |
| 761 | memcpy(Dst, Src, StoreBytes); |
| 762 | else { |
| 763 | // Big-endian host - the source is an array of 64 bit words ordered from |
| 764 | // LSW to MSW. Each word is ordered from MSB to LSB. Order the destination |
| 765 | // from MSB to LSB: Reverse the word order, but not the bytes in a word. |
| 766 | while (StoreBytes > sizeof(uint64_t)) { |
| 767 | StoreBytes -= sizeof(uint64_t); |
| 768 | // May not be aligned so use memcpy. |
| 769 | memcpy(Dst + StoreBytes, Src, sizeof(uint64_t)); |
| 770 | Src += sizeof(uint64_t); |
| 771 | } |
| 772 | |
| 773 | memcpy(Dst, Src + sizeof(uint64_t) - StoreBytes, StoreBytes); |
| 774 | } |
| 775 | } |
| 776 | |
Nate Begeman | 37efe67 | 2006-04-22 18:53:45 +0000 | [diff] [blame] | 777 | /// StoreValueToMemory - Stores the data in Val of type Ty at address Ptr. Ptr |
| 778 | /// is the address of the memory at which to store Val, cast to GenericValue *. |
| 779 | /// It is not a pointer to a GenericValue containing the address at which to |
| 780 | /// store Val. |
Evan Cheng | 89687e3 | 2008-11-04 06:10:31 +0000 | [diff] [blame] | 781 | void ExecutionEngine::StoreValueToMemory(const GenericValue &Val, |
| 782 | GenericValue *Ptr, const Type *Ty) { |
Duncan Sands | 8a43e9e | 2007-12-14 19:38:31 +0000 | [diff] [blame] | 783 | const unsigned StoreBytes = getTargetData()->getTypeStoreSize(Ty); |
| 784 | |
Reid Spencer | 8fb0f19 | 2007-03-06 03:04:04 +0000 | [diff] [blame] | 785 | switch (Ty->getTypeID()) { |
Duncan Sands | 8a43e9e | 2007-12-14 19:38:31 +0000 | [diff] [blame] | 786 | case Type::IntegerTyID: |
| 787 | StoreIntToMemory(Val.IntVal, (uint8_t*)Ptr, StoreBytes); |
Reid Spencer | 8fb0f19 | 2007-03-06 03:04:04 +0000 | [diff] [blame] | 788 | break; |
Reid Spencer | 8fb0f19 | 2007-03-06 03:04:04 +0000 | [diff] [blame] | 789 | case Type::FloatTyID: |
| 790 | *((float*)Ptr) = Val.FloatVal; |
| 791 | break; |
| 792 | case Type::DoubleTyID: |
| 793 | *((double*)Ptr) = Val.DoubleVal; |
| 794 | break; |
Dale Johannesen | 1f8c564 | 2009-03-24 18:16:17 +0000 | [diff] [blame] | 795 | case Type::X86_FP80TyID: |
| 796 | memcpy(Ptr, Val.IntVal.getRawData(), 10); |
| 797 | break; |
Duncan Sands | 8a43e9e | 2007-12-14 19:38:31 +0000 | [diff] [blame] | 798 | case Type::PointerTyID: |
| 799 | // Ensure 64 bit target pointers are fully initialized on 32 bit hosts. |
| 800 | if (StoreBytes != sizeof(PointerTy)) |
| 801 | memset(Ptr, 0, StoreBytes); |
| 802 | |
Reid Spencer | 8fb0f19 | 2007-03-06 03:04:04 +0000 | [diff] [blame] | 803 | *((PointerTy*)Ptr) = Val.PointerVal; |
| 804 | break; |
| 805 | default: |
| 806 | cerr << "Cannot store value of type " << *Ty << "!\n"; |
Chris Lattner | bd199fb | 2002-12-24 00:01:05 +0000 | [diff] [blame] | 807 | } |
Duncan Sands | 8a43e9e | 2007-12-14 19:38:31 +0000 | [diff] [blame] | 808 | |
Chris Lattner | b67c958 | 2009-01-22 19:53:00 +0000 | [diff] [blame] | 809 | if (sys::isLittleEndianHost() != getTargetData()->isLittleEndian()) |
Duncan Sands | 8a43e9e | 2007-12-14 19:38:31 +0000 | [diff] [blame] | 810 | // Host and target are different endian - reverse the stored bytes. |
| 811 | std::reverse((uint8_t*)Ptr, StoreBytes + (uint8_t*)Ptr); |
| 812 | } |
| 813 | |
| 814 | /// LoadIntFromMemory - Loads the integer stored in the LoadBytes bytes starting |
| 815 | /// from Src into IntVal, which is assumed to be wide enough and to hold zero. |
| 816 | static void LoadIntFromMemory(APInt &IntVal, uint8_t *Src, unsigned LoadBytes) { |
| 817 | assert((IntVal.getBitWidth()+7)/8 >= LoadBytes && "Integer too small!"); |
| 818 | uint8_t *Dst = (uint8_t *)IntVal.getRawData(); |
| 819 | |
Chris Lattner | b67c958 | 2009-01-22 19:53:00 +0000 | [diff] [blame] | 820 | if (sys::isLittleEndianHost()) |
Duncan Sands | 8a43e9e | 2007-12-14 19:38:31 +0000 | [diff] [blame] | 821 | // Little-endian host - the destination must be ordered from LSB to MSB. |
| 822 | // The source is ordered from LSB to MSB: Do a straight copy. |
| 823 | memcpy(Dst, Src, LoadBytes); |
| 824 | else { |
| 825 | // Big-endian - the destination is an array of 64 bit words ordered from |
| 826 | // LSW to MSW. Each word must be ordered from MSB to LSB. The source is |
| 827 | // ordered from MSB to LSB: Reverse the word order, but not the bytes in |
| 828 | // a word. |
| 829 | while (LoadBytes > sizeof(uint64_t)) { |
| 830 | LoadBytes -= sizeof(uint64_t); |
| 831 | // May not be aligned so use memcpy. |
| 832 | memcpy(Dst, Src + LoadBytes, sizeof(uint64_t)); |
| 833 | Dst += sizeof(uint64_t); |
| 834 | } |
| 835 | |
| 836 | memcpy(Dst + sizeof(uint64_t) - LoadBytes, Src, LoadBytes); |
| 837 | } |
Chris Lattner | bd199fb | 2002-12-24 00:01:05 +0000 | [diff] [blame] | 838 | } |
| 839 | |
Misha Brukman | 4afac18 | 2003-10-10 17:45:12 +0000 | [diff] [blame] | 840 | /// FIXME: document |
| 841 | /// |
Duncan Sands | 8a43e9e | 2007-12-14 19:38:31 +0000 | [diff] [blame] | 842 | void ExecutionEngine::LoadValueFromMemory(GenericValue &Result, |
Duncan Sands | 08bfe26 | 2008-03-10 16:38:37 +0000 | [diff] [blame] | 843 | GenericValue *Ptr, |
| 844 | const Type *Ty) { |
Duncan Sands | 8a43e9e | 2007-12-14 19:38:31 +0000 | [diff] [blame] | 845 | const unsigned LoadBytes = getTargetData()->getTypeStoreSize(Ty); |
Duncan Sands | 1eff704 | 2007-12-10 17:43:13 +0000 | [diff] [blame] | 846 | |
Chris Lattner | b67c958 | 2009-01-22 19:53:00 +0000 | [diff] [blame] | 847 | if (sys::isLittleEndianHost() != getTargetData()->isLittleEndian()) { |
Duncan Sands | 8a43e9e | 2007-12-14 19:38:31 +0000 | [diff] [blame] | 848 | // Host and target are different endian - reverse copy the stored |
| 849 | // bytes into a buffer, and load from that. |
| 850 | uint8_t *Src = (uint8_t*)Ptr; |
| 851 | uint8_t *Buf = (uint8_t*)alloca(LoadBytes); |
| 852 | std::reverse_copy(Src, Src + LoadBytes, Buf); |
| 853 | Ptr = (GenericValue*)Buf; |
Reid Spencer | 8fb0f19 | 2007-03-06 03:04:04 +0000 | [diff] [blame] | 854 | } |
Duncan Sands | 8a43e9e | 2007-12-14 19:38:31 +0000 | [diff] [blame] | 855 | |
| 856 | switch (Ty->getTypeID()) { |
| 857 | case Type::IntegerTyID: |
| 858 | // An APInt with all words initially zero. |
| 859 | Result.IntVal = APInt(cast<IntegerType>(Ty)->getBitWidth(), 0); |
| 860 | LoadIntFromMemory(Result.IntVal, (uint8_t*)Ptr, LoadBytes); |
| 861 | break; |
Reid Spencer | 8fb0f19 | 2007-03-06 03:04:04 +0000 | [diff] [blame] | 862 | case Type::FloatTyID: |
| 863 | Result.FloatVal = *((float*)Ptr); |
| 864 | break; |
| 865 | case Type::DoubleTyID: |
Duncan Sands | 8a43e9e | 2007-12-14 19:38:31 +0000 | [diff] [blame] | 866 | Result.DoubleVal = *((double*)Ptr); |
Reid Spencer | 8fb0f19 | 2007-03-06 03:04:04 +0000 | [diff] [blame] | 867 | break; |
Duncan Sands | 8a43e9e | 2007-12-14 19:38:31 +0000 | [diff] [blame] | 868 | case Type::PointerTyID: |
Reid Spencer | 8fb0f19 | 2007-03-06 03:04:04 +0000 | [diff] [blame] | 869 | Result.PointerVal = *((PointerTy*)Ptr); |
| 870 | break; |
Dale Johannesen | 1abac0d | 2007-09-17 18:44:13 +0000 | [diff] [blame] | 871 | case Type::X86_FP80TyID: { |
| 872 | // This is endian dependent, but it will only work on x86 anyway. |
Duncan Sands | 9e4635a | 2007-12-15 17:37:40 +0000 | [diff] [blame] | 873 | // FIXME: Will not trap if loading a signaling NaN. |
Dale Johannesen | 1f8c564 | 2009-03-24 18:16:17 +0000 | [diff] [blame] | 874 | uint64_t y[2]; |
| 875 | memcpy(y, Ptr, 10); |
Duncan Sands | dd65a73 | 2007-11-28 10:36:19 +0000 | [diff] [blame] | 876 | Result.IntVal = APInt(80, 2, y); |
Dale Johannesen | 1abac0d | 2007-09-17 18:44:13 +0000 | [diff] [blame] | 877 | break; |
| 878 | } |
Reid Spencer | 8fb0f19 | 2007-03-06 03:04:04 +0000 | [diff] [blame] | 879 | default: |
Torok Edwin | 7d696d8 | 2009-07-11 13:10:19 +0000 | [diff] [blame] | 880 | std::string msg; |
| 881 | raw_string_ostream Msg(msg); |
| 882 | Msg << "Cannot load value of type " << *Ty << "!"; |
| 883 | llvm_report_error(Msg.str()); |
Chris Lattner | f88b9a6 | 2003-05-08 16:52:16 +0000 | [diff] [blame] | 884 | } |
Chris Lattner | f88b9a6 | 2003-05-08 16:52:16 +0000 | [diff] [blame] | 885 | } |
| 886 | |
Chris Lattner | bd199fb | 2002-12-24 00:01:05 +0000 | [diff] [blame] | 887 | // InitializeMemory - Recursive function to apply a Constant value into the |
| 888 | // specified memory location... |
| 889 | // |
| 890 | void ExecutionEngine::InitializeMemory(const Constant *Init, void *Addr) { |
Evan Cheng | eb5d95a | 2008-11-06 17:46:04 +0000 | [diff] [blame] | 891 | DOUT << "JIT: Initializing " << Addr << " "; |
Dale Johannesen | dd947ea | 2008-08-07 01:30:15 +0000 | [diff] [blame] | 892 | DEBUG(Init->dump()); |
Chris Lattner | bd1d382 | 2004-10-16 18:19:26 +0000 | [diff] [blame] | 893 | if (isa<UndefValue>(Init)) { |
| 894 | return; |
Reid Spencer | 9d6565a | 2007-02-15 02:26:10 +0000 | [diff] [blame] | 895 | } else if (const ConstantVector *CP = dyn_cast<ConstantVector>(Init)) { |
Robert Bocchino | 7c2b7c7 | 2006-01-20 18:18:40 +0000 | [diff] [blame] | 896 | unsigned ElementSize = |
Duncan Sands | 777d230 | 2009-05-09 07:06:46 +0000 | [diff] [blame] | 897 | getTargetData()->getTypeAllocSize(CP->getType()->getElementType()); |
Robert Bocchino | 7c2b7c7 | 2006-01-20 18:18:40 +0000 | [diff] [blame] | 898 | for (unsigned i = 0, e = CP->getNumOperands(); i != e; ++i) |
| 899 | InitializeMemory(CP->getOperand(i), (char*)Addr+i*ElementSize); |
| 900 | return; |
Chris Lattner | b6e1dd7 | 2008-02-15 00:57:28 +0000 | [diff] [blame] | 901 | } else if (isa<ConstantAggregateZero>(Init)) { |
Duncan Sands | 777d230 | 2009-05-09 07:06:46 +0000 | [diff] [blame] | 902 | memset(Addr, 0, (size_t)getTargetData()->getTypeAllocSize(Init->getType())); |
Chris Lattner | b6e1dd7 | 2008-02-15 00:57:28 +0000 | [diff] [blame] | 903 | return; |
Dan Gohman | 638e378 | 2008-05-20 03:20:09 +0000 | [diff] [blame] | 904 | } else if (const ConstantArray *CPA = dyn_cast<ConstantArray>(Init)) { |
| 905 | unsigned ElementSize = |
Duncan Sands | 777d230 | 2009-05-09 07:06:46 +0000 | [diff] [blame] | 906 | getTargetData()->getTypeAllocSize(CPA->getType()->getElementType()); |
Dan Gohman | 638e378 | 2008-05-20 03:20:09 +0000 | [diff] [blame] | 907 | for (unsigned i = 0, e = CPA->getNumOperands(); i != e; ++i) |
| 908 | InitializeMemory(CPA->getOperand(i), (char*)Addr+i*ElementSize); |
| 909 | return; |
| 910 | } else if (const ConstantStruct *CPS = dyn_cast<ConstantStruct>(Init)) { |
| 911 | const StructLayout *SL = |
| 912 | getTargetData()->getStructLayout(cast<StructType>(CPS->getType())); |
| 913 | for (unsigned i = 0, e = CPS->getNumOperands(); i != e; ++i) |
| 914 | InitializeMemory(CPS->getOperand(i), (char*)Addr+SL->getElementOffset(i)); |
| 915 | return; |
Chris Lattner | bd1d382 | 2004-10-16 18:19:26 +0000 | [diff] [blame] | 916 | } else if (Init->getType()->isFirstClassType()) { |
Chris Lattner | bd199fb | 2002-12-24 00:01:05 +0000 | [diff] [blame] | 917 | GenericValue Val = getConstantValue(Init); |
| 918 | StoreValueToMemory(Val, (GenericValue*)Addr, Init->getType()); |
| 919 | return; |
| 920 | } |
| 921 | |
Dan Gohman | 638e378 | 2008-05-20 03:20:09 +0000 | [diff] [blame] | 922 | cerr << "Bad Type: " << *Init->getType() << "\n"; |
Torok Edwin | c23197a | 2009-07-14 16:55:14 +0000 | [diff] [blame] | 923 | llvm_unreachable("Unknown constant type to initialize memory with!"); |
Chris Lattner | bd199fb | 2002-12-24 00:01:05 +0000 | [diff] [blame] | 924 | } |
| 925 | |
Chris Lattner | bd199fb | 2002-12-24 00:01:05 +0000 | [diff] [blame] | 926 | /// EmitGlobals - Emit all of the global variables to memory, storing their |
| 927 | /// addresses into GlobalAddress. This must make sure to copy the contents of |
| 928 | /// their initializers into the memory. |
| 929 | /// |
| 930 | void ExecutionEngine::emitGlobals() { |
Misha Brukman | edf128a | 2005-04-21 22:36:52 +0000 | [diff] [blame] | 931 | |
Chris Lattner | bd199fb | 2002-12-24 00:01:05 +0000 | [diff] [blame] | 932 | // Loop over all of the global variables in the program, allocating the memory |
Chris Lattner | fe85403 | 2006-08-16 01:24:12 +0000 | [diff] [blame] | 933 | // to hold them. If there is more than one module, do a prepass over globals |
| 934 | // to figure out how the different modules should link together. |
| 935 | // |
| 936 | std::map<std::pair<std::string, const Type*>, |
| 937 | const GlobalValue*> LinkedGlobalsMap; |
Misha Brukman | edf128a | 2005-04-21 22:36:52 +0000 | [diff] [blame] | 938 | |
Chris Lattner | fe85403 | 2006-08-16 01:24:12 +0000 | [diff] [blame] | 939 | if (Modules.size() != 1) { |
| 940 | for (unsigned m = 0, e = Modules.size(); m != e; ++m) { |
| 941 | Module &M = *Modules[m]->getModule(); |
| 942 | for (Module::const_global_iterator I = M.global_begin(), |
| 943 | E = M.global_end(); I != E; ++I) { |
| 944 | const GlobalValue *GV = I; |
Rafael Espindola | bb46f52 | 2009-01-15 20:18:42 +0000 | [diff] [blame] | 945 | if (GV->hasLocalLinkage() || GV->isDeclaration() || |
Chris Lattner | fe85403 | 2006-08-16 01:24:12 +0000 | [diff] [blame] | 946 | GV->hasAppendingLinkage() || !GV->hasName()) |
| 947 | continue;// Ignore external globals and globals with internal linkage. |
| 948 | |
| 949 | const GlobalValue *&GVEntry = |
| 950 | LinkedGlobalsMap[std::make_pair(GV->getName(), GV->getType())]; |
| 951 | |
| 952 | // If this is the first time we've seen this global, it is the canonical |
| 953 | // version. |
| 954 | if (!GVEntry) { |
| 955 | GVEntry = GV; |
| 956 | continue; |
| 957 | } |
| 958 | |
| 959 | // If the existing global is strong, never replace it. |
Anton Korobeynikov | b74ed07 | 2006-09-14 18:23:27 +0000 | [diff] [blame] | 960 | if (GVEntry->hasExternalLinkage() || |
| 961 | GVEntry->hasDLLImportLinkage() || |
| 962 | GVEntry->hasDLLExportLinkage()) |
Chris Lattner | fe85403 | 2006-08-16 01:24:12 +0000 | [diff] [blame] | 963 | continue; |
| 964 | |
| 965 | // Otherwise, we know it's linkonce/weak, replace it if this is a strong |
Dale Johannesen | aafce77 | 2008-05-14 20:12:51 +0000 | [diff] [blame] | 966 | // symbol. FIXME is this right for common? |
Anton Korobeynikov | 78ee7b7 | 2006-12-01 00:25:12 +0000 | [diff] [blame] | 967 | if (GV->hasExternalLinkage() || GVEntry->hasExternalWeakLinkage()) |
Chris Lattner | fe85403 | 2006-08-16 01:24:12 +0000 | [diff] [blame] | 968 | GVEntry = GV; |
Chris Lattner | d8c03bf | 2003-04-23 19:01:49 +0000 | [diff] [blame] | 969 | } |
Chris Lattner | bd199fb | 2002-12-24 00:01:05 +0000 | [diff] [blame] | 970 | } |
Chris Lattner | fe85403 | 2006-08-16 01:24:12 +0000 | [diff] [blame] | 971 | } |
| 972 | |
| 973 | std::vector<const GlobalValue*> NonCanonicalGlobals; |
| 974 | for (unsigned m = 0, e = Modules.size(); m != e; ++m) { |
| 975 | Module &M = *Modules[m]->getModule(); |
| 976 | for (Module::const_global_iterator I = M.global_begin(), E = M.global_end(); |
| 977 | I != E; ++I) { |
| 978 | // In the multi-module case, see what this global maps to. |
| 979 | if (!LinkedGlobalsMap.empty()) { |
| 980 | if (const GlobalValue *GVEntry = |
| 981 | LinkedGlobalsMap[std::make_pair(I->getName(), I->getType())]) { |
| 982 | // If something else is the canonical global, ignore this one. |
| 983 | if (GVEntry != &*I) { |
| 984 | NonCanonicalGlobals.push_back(I); |
| 985 | continue; |
| 986 | } |
| 987 | } |
| 988 | } |
| 989 | |
Reid Spencer | 5cbf985 | 2007-01-30 20:08:39 +0000 | [diff] [blame] | 990 | if (!I->isDeclaration()) { |
Nicolas Geoffray | 46fa139 | 2008-10-25 15:41:43 +0000 | [diff] [blame] | 991 | addGlobalMapping(I, getMemoryForGV(I)); |
Chris Lattner | fe85403 | 2006-08-16 01:24:12 +0000 | [diff] [blame] | 992 | } else { |
| 993 | // External variable reference. Try to use the dynamic loader to |
| 994 | // get a pointer to it. |
| 995 | if (void *SymAddr = |
Daniel Dunbar | fbee579 | 2009-07-21 08:54:24 +0000 | [diff] [blame] | 996 | sys::DynamicLibrary::SearchForAddressOfSymbol(I->getName())) |
Chris Lattner | fe85403 | 2006-08-16 01:24:12 +0000 | [diff] [blame] | 997 | addGlobalMapping(I, SymAddr); |
| 998 | else { |
Torok Edwin | 31e2466 | 2009-07-07 17:32:34 +0000 | [diff] [blame] | 999 | llvm_report_error("Could not resolve external global address: " |
| 1000 | +I->getName()); |
Chris Lattner | fe85403 | 2006-08-16 01:24:12 +0000 | [diff] [blame] | 1001 | } |
| 1002 | } |
| 1003 | } |
| 1004 | |
| 1005 | // If there are multiple modules, map the non-canonical globals to their |
| 1006 | // canonical location. |
| 1007 | if (!NonCanonicalGlobals.empty()) { |
| 1008 | for (unsigned i = 0, e = NonCanonicalGlobals.size(); i != e; ++i) { |
| 1009 | const GlobalValue *GV = NonCanonicalGlobals[i]; |
| 1010 | const GlobalValue *CGV = |
| 1011 | LinkedGlobalsMap[std::make_pair(GV->getName(), GV->getType())]; |
| 1012 | void *Ptr = getPointerToGlobalIfAvailable(CGV); |
| 1013 | assert(Ptr && "Canonical global wasn't codegen'd!"); |
Nuno Lopes | c8ed902 | 2008-10-14 10:04:52 +0000 | [diff] [blame] | 1014 | addGlobalMapping(GV, Ptr); |
Chris Lattner | fe85403 | 2006-08-16 01:24:12 +0000 | [diff] [blame] | 1015 | } |
| 1016 | } |
| 1017 | |
Reid Spencer | a54b7cb | 2007-01-12 07:05:14 +0000 | [diff] [blame] | 1018 | // Now that all of the globals are set up in memory, loop through them all |
| 1019 | // and initialize their contents. |
Chris Lattner | fe85403 | 2006-08-16 01:24:12 +0000 | [diff] [blame] | 1020 | for (Module::const_global_iterator I = M.global_begin(), E = M.global_end(); |
| 1021 | I != E; ++I) { |
Reid Spencer | 5cbf985 | 2007-01-30 20:08:39 +0000 | [diff] [blame] | 1022 | if (!I->isDeclaration()) { |
Chris Lattner | fe85403 | 2006-08-16 01:24:12 +0000 | [diff] [blame] | 1023 | if (!LinkedGlobalsMap.empty()) { |
| 1024 | if (const GlobalValue *GVEntry = |
| 1025 | LinkedGlobalsMap[std::make_pair(I->getName(), I->getType())]) |
| 1026 | if (GVEntry != &*I) // Not the canonical variable. |
| 1027 | continue; |
| 1028 | } |
| 1029 | EmitGlobalVariable(I); |
| 1030 | } |
| 1031 | } |
| 1032 | } |
Chris Lattner | 24b0a18 | 2003-12-20 02:45:37 +0000 | [diff] [blame] | 1033 | } |
| 1034 | |
| 1035 | // EmitGlobalVariable - This method emits the specified global variable to the |
| 1036 | // address specified in GlobalAddresses, or allocates new memory if it's not |
| 1037 | // already in the map. |
Chris Lattner | c07ed13 | 2003-12-20 03:36:47 +0000 | [diff] [blame] | 1038 | void ExecutionEngine::EmitGlobalVariable(const GlobalVariable *GV) { |
Chris Lattner | 55d8648 | 2003-12-31 20:21:04 +0000 | [diff] [blame] | 1039 | void *GA = getPointerToGlobalIfAvailable(GV); |
Chris Lattner | 23c4724 | 2004-02-08 19:33:23 +0000 | [diff] [blame] | 1040 | |
Chris Lattner | 24b0a18 | 2003-12-20 02:45:37 +0000 | [diff] [blame] | 1041 | if (GA == 0) { |
| 1042 | // If it's not already specified, allocate memory for the global. |
Nicolas Geoffray | 46fa139 | 2008-10-25 15:41:43 +0000 | [diff] [blame] | 1043 | GA = getMemoryForGV(GV); |
Chris Lattner | 55d8648 | 2003-12-31 20:21:04 +0000 | [diff] [blame] | 1044 | addGlobalMapping(GV, GA); |
Chris Lattner | 24b0a18 | 2003-12-20 02:45:37 +0000 | [diff] [blame] | 1045 | } |
Nicolas Geoffray | 46fa139 | 2008-10-25 15:41:43 +0000 | [diff] [blame] | 1046 | |
| 1047 | // Don't initialize if it's thread local, let the client do it. |
| 1048 | if (!GV->isThreadLocal()) |
| 1049 | InitializeMemory(GV->getInitializer(), GA); |
| 1050 | |
| 1051 | const Type *ElTy = GV->getType()->getElementType(); |
Duncan Sands | 777d230 | 2009-05-09 07:06:46 +0000 | [diff] [blame] | 1052 | size_t GVSize = (size_t)getTargetData()->getTypeAllocSize(ElTy); |
Chris Lattner | 813c815 | 2005-01-08 20:13:19 +0000 | [diff] [blame] | 1053 | NumInitBytes += (unsigned)GVSize; |
Chris Lattner | 24b0a18 | 2003-12-20 02:45:37 +0000 | [diff] [blame] | 1054 | ++NumGlobals; |
Chris Lattner | bd199fb | 2002-12-24 00:01:05 +0000 | [diff] [blame] | 1055 | } |