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