14afac18fd4cae1b93907d7db03c5fdb7f2f66d64Misha Brukman//===-- ExecutionEngine.cpp - Common Implementation shared by EEs ---------===// 2edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman// 3b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// The LLVM Compiler Infrastructure 4b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// 54ee451de366474b9c228b4e5fa573795a715216dChris Lattner// This file is distributed under the University of Illinois Open Source 64ee451de366474b9c228b4e5fa573795a715216dChris Lattner// License. See LICENSE.TXT for details. 7edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman// 8b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell//===----------------------------------------------------------------------===// 9edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman// 10bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner// This file defines the common interface used by the various execution engine 11bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner// subclasses. 12bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner// 13bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner//===----------------------------------------------------------------------===// 14bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner 153785fad56eb90284d4e930d40e9306391630deb1Chris Lattner#define DEBUG_TYPE "jit" 160d5bd59553375dc85ac04c81ef48ef74c9e7193eJeffrey Yasskin#include "llvm/ExecutionEngine/ExecutionEngine.h" 17d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/ADT/SmallString.h" 18d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/ADT/Statistic.h" 19fd13129bdf7324b2e8181a653897269aaaecc4e8Chris Lattner#include "llvm/ExecutionEngine/GenericValue.h" 200b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Constants.h" 210b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/DataLayout.h" 220b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/DerivedTypes.h" 230b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Module.h" 240b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Operator.h" 25551ccae044b0ff658fe629dd67edd5ffe75d10e8Reid Spencer#include "llvm/Support/Debug.h" 26d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Support/DynamicLibrary.h" 2731e2466f159a887fed9139067a676f65adf2a8c3Torok Edwin#include "llvm/Support/ErrorHandling.h" 28d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Support/Host.h" 29e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattner#include "llvm/Support/MutexGuard.h" 30d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Support/TargetRegistry.h" 310d5bd59553375dc85ac04c81ef48ef74c9e7193eJeffrey Yasskin#include "llvm/Support/ValueHandle.h" 327d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin#include "llvm/Support/raw_ostream.h" 33c5b28580a94e247300e5d3ccf532e153f2ae6f12Dylan Noblesmith#include "llvm/Target/TargetMachine.h" 34ae9f3a3b7c915f725aef5a7250e88eaeddda03c6Anton Korobeynikov#include <cmath> 35ae9f3a3b7c915f725aef5a7250e88eaeddda03c6Anton Korobeynikov#include <cstring> 36c2ee9b9c7a6517f959aea31fa2c61631fe2f2903Chris Lattnerusing namespace llvm; 37bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner 3836343735cb23680c8f8675deafbbf825d46fd868Chris LattnerSTATISTIC(NumInitBytes, "Number of bytes of global vars initialized"); 3936343735cb23680c8f8675deafbbf825d46fd868Chris LattnerSTATISTIC(NumGlobals , "Number of global vars initialized"); 40bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner 414688261c20735f5ead2f08695acdeb727db31894Jeffrey YasskinExecutionEngine *(*ExecutionEngine::JITCtor)( 424688261c20735f5ead2f08695acdeb727db31894Jeffrey Yasskin Module *M, 434688261c20735f5ead2f08695acdeb727db31894Jeffrey Yasskin std::string *ErrorStr, 444688261c20735f5ead2f08695acdeb727db31894Jeffrey Yasskin JITMemoryManager *JMM, 454688261c20735f5ead2f08695acdeb727db31894Jeffrey Yasskin bool GVsWithCode, 46c5b28580a94e247300e5d3ccf532e153f2ae6f12Dylan Noblesmith TargetMachine *TM) = 0; 476d135972bf4e7fdc4de6b0538d6a3b91a06e3a5dDaniel DunbarExecutionEngine *(*ExecutionEngine::MCJITCtor)( 486d135972bf4e7fdc4de6b0538d6a3b91a06e3a5dDaniel Dunbar Module *M, 496d135972bf4e7fdc4de6b0538d6a3b91a06e3a5dDaniel Dunbar std::string *ErrorStr, 506d135972bf4e7fdc4de6b0538d6a3b91a06e3a5dDaniel Dunbar JITMemoryManager *JMM, 516d135972bf4e7fdc4de6b0538d6a3b91a06e3a5dDaniel Dunbar bool GVsWithCode, 52c5b28580a94e247300e5d3ccf532e153f2ae6f12Dylan Noblesmith TargetMachine *TM) = 0; 53f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey YasskinExecutionEngine *(*ExecutionEngine::InterpCtor)(Module *M, 544b1511b027ce0b648b3379f2891816c25b46f515Reid Kleckner std::string *ErrorStr) = 0; 552fe4bb06c6c40d16b7a5ae9cdf6bb6fe94d51be0Chris Lattner 56f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey YasskinExecutionEngine::ExecutionEngine(Module *M) 574c5b23b24f230607fa18a162519875a91a5e89e0Jeffrey Yasskin : EEState(*this), 58b35fd448cea32da671ecd3ecaad3cc637598c6e0Duncan Sands LazyFunctionCreator(0), 5948dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar ExceptionTableRegister(0), 60b35fd448cea32da671ecd3ecaad3cc637598c6e0Duncan Sands ExceptionTableDeregister(0) { 61dc85724f703bddf6988b6b3f20203beab775f32bJeffrey Yasskin CompilingLazily = false; 62446531e7bb4355117b070493ca8e81e4b123ef18Evan Cheng GVCompilationDisabled = false; 631b088f33107798c544e0a872df4cc1921581eb66Evan Cheng SymbolSearchingDisabled = false; 64f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin Modules.push_back(M); 65f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin assert(M && "Module is null?"); 6619684164a7b695b9dc22d879675e8d2b286ef7e5Misha Brukman} 6719684164a7b695b9dc22d879675e8d2b286ef7e5Misha Brukman 688e539488816c9e52bde0af475f72cd3e6407d558Brian GaekeExecutionEngine::~ExecutionEngine() { 69d4c0e62413ac4c81467ce59025c81210ea431752Reid Spencer clearAllGlobalMappings(); 70fe854034677f59baca1e38075e71f6efca247a03Chris Lattner for (unsigned i = 0, e = Modules.size(); i != e; ++i) 71fe854034677f59baca1e38075e71f6efca247a03Chris Lattner delete Modules[i]; 728e539488816c9e52bde0af475f72cd3e6407d558Brian Gaeke} 738e539488816c9e52bde0af475f72cd3e6407d558Brian Gaeke 74b35fd448cea32da671ecd3ecaad3cc637598c6e0Duncan Sandsvoid ExecutionEngine::DeregisterAllTables() { 75b35fd448cea32da671ecd3ecaad3cc637598c6e0Duncan Sands if (ExceptionTableDeregister) { 76515c67ee77f8d9c417efc0fe04615d269bfb70e4Eric Christopher DenseMap<const Function*, void*>::iterator it = AllExceptionTables.begin(); 77515c67ee77f8d9c417efc0fe04615d269bfb70e4Eric Christopher DenseMap<const Function*, void*>::iterator ite = AllExceptionTables.end(); 78515c67ee77f8d9c417efc0fe04615d269bfb70e4Eric Christopher for (; it != ite; ++it) 79515c67ee77f8d9c417efc0fe04615d269bfb70e4Eric Christopher ExceptionTableDeregister(it->second); 80b35fd448cea32da671ecd3ecaad3cc637598c6e0Duncan Sands AllExceptionTables.clear(); 81b35fd448cea32da671ecd3ecaad3cc637598c6e0Duncan Sands } 82b35fd448cea32da671ecd3ecaad3cc637598c6e0Duncan Sands} 83b35fd448cea32da671ecd3ecaad3cc637598c6e0Duncan Sands 8447b7112418a8c6ca23039ad5239cbc16091911a0Jeffrey Yasskinnamespace { 8548dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar/// \brief Helper class which uses a value handler to automatically deletes the 8648dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar/// memory block when the GlobalVariable is destroyed. 8747b7112418a8c6ca23039ad5239cbc16091911a0Jeffrey Yasskinclass GVMemoryBlock : public CallbackVH { 8847b7112418a8c6ca23039ad5239cbc16091911a0Jeffrey Yasskin GVMemoryBlock(const GlobalVariable *GV) 8947b7112418a8c6ca23039ad5239cbc16091911a0Jeffrey Yasskin : CallbackVH(const_cast<GlobalVariable*>(GV)) {} 9047b7112418a8c6ca23039ad5239cbc16091911a0Jeffrey Yasskin 9147b7112418a8c6ca23039ad5239cbc16091911a0Jeffrey Yasskinpublic: 9248dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar /// \brief Returns the address the GlobalVariable should be written into. The 9348dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar /// GVMemoryBlock object prefixes that. 943574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmow static char *Create(const GlobalVariable *GV, const DataLayout& TD) { 95db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *ElTy = GV->getType()->getElementType(); 9647b7112418a8c6ca23039ad5239cbc16091911a0Jeffrey Yasskin size_t GVSize = (size_t)TD.getTypeAllocSize(ElTy); 9747b7112418a8c6ca23039ad5239cbc16091911a0Jeffrey Yasskin void *RawMemory = ::operator new( 983574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmow DataLayout::RoundUpAlignment(sizeof(GVMemoryBlock), 9947b7112418a8c6ca23039ad5239cbc16091911a0Jeffrey Yasskin TD.getPreferredAlignment(GV)) 10047b7112418a8c6ca23039ad5239cbc16091911a0Jeffrey Yasskin + GVSize); 10147b7112418a8c6ca23039ad5239cbc16091911a0Jeffrey Yasskin new(RawMemory) GVMemoryBlock(GV); 10247b7112418a8c6ca23039ad5239cbc16091911a0Jeffrey Yasskin return static_cast<char*>(RawMemory) + sizeof(GVMemoryBlock); 10347b7112418a8c6ca23039ad5239cbc16091911a0Jeffrey Yasskin } 10447b7112418a8c6ca23039ad5239cbc16091911a0Jeffrey Yasskin 10547b7112418a8c6ca23039ad5239cbc16091911a0Jeffrey Yasskin virtual void deleted() { 10647b7112418a8c6ca23039ad5239cbc16091911a0Jeffrey Yasskin // We allocated with operator new and with some extra memory hanging off the 10747b7112418a8c6ca23039ad5239cbc16091911a0Jeffrey Yasskin // end, so don't just delete this. I'm not sure if this is actually 10847b7112418a8c6ca23039ad5239cbc16091911a0Jeffrey Yasskin // required. 10947b7112418a8c6ca23039ad5239cbc16091911a0Jeffrey Yasskin this->~GVMemoryBlock(); 11047b7112418a8c6ca23039ad5239cbc16091911a0Jeffrey Yasskin ::operator delete(this); 11147b7112418a8c6ca23039ad5239cbc16091911a0Jeffrey Yasskin } 11247b7112418a8c6ca23039ad5239cbc16091911a0Jeffrey Yasskin}; 11347b7112418a8c6ca23039ad5239cbc16091911a0Jeffrey Yasskin} // anonymous namespace 11447b7112418a8c6ca23039ad5239cbc16091911a0Jeffrey Yasskin 11548dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbarchar *ExecutionEngine::getMemoryForGV(const GlobalVariable *GV) { 1163574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmow return GVMemoryBlock::Create(GV, *getDataLayout()); 11746fa139e26be6ebc00be2fb45820c2560dd22a32Nicolas Geoffray} 11846fa139e26be6ebc00be2fb45820c2560dd22a32Nicolas Geoffray 119f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskinbool ExecutionEngine::removeModule(Module *M) { 12048dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar for(SmallVector<Module *, 1>::iterator I = Modules.begin(), 12173d0e211a39650fc7562e0f15ed21440dde2243aDevang Patel E = Modules.end(); I != E; ++I) { 122f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin Module *Found = *I; 123f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin if (Found == M) { 12473d0e211a39650fc7562e0f15ed21440dde2243aDevang Patel Modules.erase(I); 125f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin clearGlobalMappingsFromModule(M); 126f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin return true; 12760789e419e04c260e36af9a1add5ad316313e490Nate Begeman } 12860789e419e04c260e36af9a1add5ad316313e490Nate Begeman } 129f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin return false; 13060789e419e04c260e36af9a1add5ad316313e490Nate Begeman} 13160789e419e04c260e36af9a1add5ad316313e490Nate Begeman 132fe854034677f59baca1e38075e71f6efca247a03Chris LattnerFunction *ExecutionEngine::FindFunctionNamed(const char *FnName) { 133fe854034677f59baca1e38075e71f6efca247a03Chris Lattner for (unsigned i = 0, e = Modules.size(); i != e; ++i) { 134f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin if (Function *F = Modules[i]->getFunction(FnName)) 135fe854034677f59baca1e38075e71f6efca247a03Chris Lattner return F; 136fe854034677f59baca1e38075e71f6efca247a03Chris Lattner } 137fe854034677f59baca1e38075e71f6efca247a03Chris Lattner return 0; 138fe854034677f59baca1e38075e71f6efca247a03Chris Lattner} 139fe854034677f59baca1e38075e71f6efca247a03Chris Lattner 140fe854034677f59baca1e38075e71f6efca247a03Chris Lattner 14148dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbarvoid *ExecutionEngineState::RemoveMapping(const MutexGuard &, 14248dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar const GlobalValue *ToUnmap) { 14323e5fcfec4640955fec41dc8348f467adf1a3e56Jeffrey Yasskin GlobalAddressMapTy::iterator I = GlobalAddressMap.find(ToUnmap); 144c89d27a440370455336202b2a8f25eb9c73e67bcJeffrey Yasskin void *OldVal; 14548dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar 14648dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar // FIXME: This is silly, we shouldn't end up with a mapping -> 0 in the 14748dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar // GlobalAddressMap. 148c89d27a440370455336202b2a8f25eb9c73e67bcJeffrey Yasskin if (I == GlobalAddressMap.end()) 149c89d27a440370455336202b2a8f25eb9c73e67bcJeffrey Yasskin OldVal = 0; 150c89d27a440370455336202b2a8f25eb9c73e67bcJeffrey Yasskin else { 151c89d27a440370455336202b2a8f25eb9c73e67bcJeffrey Yasskin OldVal = I->second; 152c89d27a440370455336202b2a8f25eb9c73e67bcJeffrey Yasskin GlobalAddressMap.erase(I); 153c89d27a440370455336202b2a8f25eb9c73e67bcJeffrey Yasskin } 154c89d27a440370455336202b2a8f25eb9c73e67bcJeffrey Yasskin 155c89d27a440370455336202b2a8f25eb9c73e67bcJeffrey Yasskin GlobalAddressReverseMap.erase(OldVal); 156c89d27a440370455336202b2a8f25eb9c73e67bcJeffrey Yasskin return OldVal; 157c89d27a440370455336202b2a8f25eb9c73e67bcJeffrey Yasskin} 158c89d27a440370455336202b2a8f25eb9c73e67bcJeffrey Yasskin 159e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattnervoid ExecutionEngine::addGlobalMapping(const GlobalValue *GV, void *Addr) { 160e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattner MutexGuard locked(lock); 161bc4707a2554ac04ba006bf70035e7bc7270236a9Evan Cheng 16248dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar DEBUG(dbgs() << "JIT: Map \'" << GV->getName() 16393b67e40de356569493c285b86b138a3f11b5035Daniel Dunbar << "\' to [" << Addr << "]\n";); 16423e5fcfec4640955fec41dc8348f467adf1a3e56Jeffrey Yasskin void *&CurVal = EEState.getGlobalAddressMap(locked)[GV]; 165e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattner assert((CurVal == 0 || Addr == 0) && "GlobalMapping already established!"); 166e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattner CurVal = Addr; 16748dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar 16848dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar // If we are using the reverse mapping, add it too. 1694c5b23b24f230607fa18a162519875a91a5e89e0Jeffrey Yasskin if (!EEState.getGlobalAddressReverseMap(locked).empty()) { 1700d5bd59553375dc85ac04c81ef48ef74c9e7193eJeffrey Yasskin AssertingVH<const GlobalValue> &V = 1714c5b23b24f230607fa18a162519875a91a5e89e0Jeffrey Yasskin EEState.getGlobalAddressReverseMap(locked)[Addr]; 172e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattner assert((V == 0 || GV == 0) && "GlobalMapping already established!"); 173e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattner V = GV; 174e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattner } 175e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattner} 176e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattner 177e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattnervoid ExecutionEngine::clearAllGlobalMappings() { 178e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattner MutexGuard locked(lock); 17948dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar 1804c5b23b24f230607fa18a162519875a91a5e89e0Jeffrey Yasskin EEState.getGlobalAddressMap(locked).clear(); 1814c5b23b24f230607fa18a162519875a91a5e89e0Jeffrey Yasskin EEState.getGlobalAddressReverseMap(locked).clear(); 182e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattner} 183e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattner 184f049e07eb8930214941c72f8e4409df394de1567Nate Begemanvoid ExecutionEngine::clearGlobalMappingsFromModule(Module *M) { 185f049e07eb8930214941c72f8e4409df394de1567Nate Begeman MutexGuard locked(lock); 18648dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar 18748dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar for (Module::iterator FI = M->begin(), FE = M->end(); FI != FE; ++FI) 1884c5b23b24f230607fa18a162519875a91a5e89e0Jeffrey Yasskin EEState.RemoveMapping(locked, FI); 18948dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar for (Module::global_iterator GI = M->global_begin(), GE = M->global_end(); 19048dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar GI != GE; ++GI) 1914c5b23b24f230607fa18a162519875a91a5e89e0Jeffrey Yasskin EEState.RemoveMapping(locked, GI); 192f049e07eb8930214941c72f8e4409df394de1567Nate Begeman} 193f049e07eb8930214941c72f8e4409df394de1567Nate Begeman 194f4cc3096fd893cdef5b5c2664ebff8c13a07ad51Chris Lattnervoid *ExecutionEngine::updateGlobalMapping(const GlobalValue *GV, void *Addr) { 195e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattner MutexGuard locked(lock); 196f4cc3096fd893cdef5b5c2664ebff8c13a07ad51Chris Lattner 19723e5fcfec4640955fec41dc8348f467adf1a3e56Jeffrey Yasskin ExecutionEngineState::GlobalAddressMapTy &Map = 1984c5b23b24f230607fa18a162519875a91a5e89e0Jeffrey Yasskin EEState.getGlobalAddressMap(locked); 199f4cc3096fd893cdef5b5c2664ebff8c13a07ad51Chris Lattner 200e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattner // Deleting from the mapping? 20148dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar if (Addr == 0) 2024c5b23b24f230607fa18a162519875a91a5e89e0Jeffrey Yasskin return EEState.RemoveMapping(locked, GV); 20348dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar 20423e5fcfec4640955fec41dc8348f467adf1a3e56Jeffrey Yasskin void *&CurVal = Map[GV]; 205f4cc3096fd893cdef5b5c2664ebff8c13a07ad51Chris Lattner void *OldVal = CurVal; 206f4cc3096fd893cdef5b5c2664ebff8c13a07ad51Chris Lattner 2074c5b23b24f230607fa18a162519875a91a5e89e0Jeffrey Yasskin if (CurVal && !EEState.getGlobalAddressReverseMap(locked).empty()) 2084c5b23b24f230607fa18a162519875a91a5e89e0Jeffrey Yasskin EEState.getGlobalAddressReverseMap(locked).erase(CurVal); 209e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattner CurVal = Addr; 21048dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar 21148dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar // If we are using the reverse mapping, add it too. 2124c5b23b24f230607fa18a162519875a91a5e89e0Jeffrey Yasskin if (!EEState.getGlobalAddressReverseMap(locked).empty()) { 2130d5bd59553375dc85ac04c81ef48ef74c9e7193eJeffrey Yasskin AssertingVH<const GlobalValue> &V = 2144c5b23b24f230607fa18a162519875a91a5e89e0Jeffrey Yasskin EEState.getGlobalAddressReverseMap(locked)[Addr]; 215e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattner assert((V == 0 || GV == 0) && "GlobalMapping already established!"); 216e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattner V = GV; 217e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattner } 218f4cc3096fd893cdef5b5c2664ebff8c13a07ad51Chris Lattner return OldVal; 219e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattner} 220e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattner 221e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattnervoid *ExecutionEngine::getPointerToGlobalIfAvailable(const GlobalValue *GV) { 222e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattner MutexGuard locked(lock); 22348dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar 22423e5fcfec4640955fec41dc8348f467adf1a3e56Jeffrey Yasskin ExecutionEngineState::GlobalAddressMapTy::iterator I = 22523e5fcfec4640955fec41dc8348f467adf1a3e56Jeffrey Yasskin EEState.getGlobalAddressMap(locked).find(GV); 2264c5b23b24f230607fa18a162519875a91a5e89e0Jeffrey Yasskin return I != EEState.getGlobalAddressMap(locked).end() ? I->second : 0; 227e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattner} 228e7fd553b3be8b95dc0946cd3267bc2db859cd3d8Chris Lattner 22955d86482bd9fac6f90a7f6fb35c2f4dec9569fdbChris Lattnerconst GlobalValue *ExecutionEngine::getGlobalValueAtAddress(void *Addr) { 230ee448630bdf7eb6037fe2c50518d32010c433ca3Reid Spencer MutexGuard locked(lock); 231ee448630bdf7eb6037fe2c50518d32010c433ca3Reid Spencer 23255d86482bd9fac6f90a7f6fb35c2f4dec9569fdbChris Lattner // If we haven't computed the reverse mapping yet, do so first. 2334c5b23b24f230607fa18a162519875a91a5e89e0Jeffrey Yasskin if (EEState.getGlobalAddressReverseMap(locked).empty()) { 23423e5fcfec4640955fec41dc8348f467adf1a3e56Jeffrey Yasskin for (ExecutionEngineState::GlobalAddressMapTy::iterator 2354c5b23b24f230607fa18a162519875a91a5e89e0Jeffrey Yasskin I = EEState.getGlobalAddressMap(locked).begin(), 2364c5b23b24f230607fa18a162519875a91a5e89e0Jeffrey Yasskin E = EEState.getGlobalAddressMap(locked).end(); I != E; ++I) 237ab19da4bc087e79550ebe448d9edd4d8ed248388Daniel Dunbar EEState.getGlobalAddressReverseMap(locked).insert(std::make_pair( 238ab19da4bc087e79550ebe448d9edd4d8ed248388Daniel Dunbar I->second, I->first)); 23955d86482bd9fac6f90a7f6fb35c2f4dec9569fdbChris Lattner } 24055d86482bd9fac6f90a7f6fb35c2f4dec9569fdbChris Lattner 2410d5bd59553375dc85ac04c81ef48ef74c9e7193eJeffrey Yasskin std::map<void *, AssertingVH<const GlobalValue> >::iterator I = 2424c5b23b24f230607fa18a162519875a91a5e89e0Jeffrey Yasskin EEState.getGlobalAddressReverseMap(locked).find(Addr); 2434c5b23b24f230607fa18a162519875a91a5e89e0Jeffrey Yasskin return I != EEState.getGlobalAddressReverseMap(locked).end() ? I->second : 0; 24455d86482bd9fac6f90a7f6fb35c2f4dec9569fdbChris Lattner} 24587f03108f282a9b5f172f91679bd89ddbb5a65beChris Lattner 246b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskinnamespace { 247b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskinclass ArgvArray { 248b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin char *Array; 249b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin std::vector<char*> Values; 250b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskinpublic: 251b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin ArgvArray() : Array(NULL) {} 252b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin ~ArgvArray() { clear(); } 253b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin void clear() { 254b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin delete[] Array; 255b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin Array = NULL; 256b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin for (size_t I = 0, E = Values.size(); I != E; ++I) { 257b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin delete[] Values[I]; 258b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin } 259b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin Values.clear(); 260b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin } 261b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin /// Turn a vector of strings into a nice argv style array of pointers to null 262b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin /// terminated strings. 263b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin void *reset(LLVMContext &C, ExecutionEngine *EE, 264b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin const std::vector<std::string> &InputArgv); 265b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin}; 266b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin} // anonymous namespace 267b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskinvoid *ArgvArray::reset(LLVMContext &C, ExecutionEngine *EE, 268b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin const std::vector<std::string> &InputArgv) { 269b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin clear(); // Free the old contents. 270426c2bf5cdd2173e4a33aea8cb92cf684a724f4bChandler Carruth unsigned PtrSize = EE->getDataLayout()->getPointerSize(); 271b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin Array = new char[(InputArgv.size()+1)*PtrSize]; 27287f03108f282a9b5f172f91679bd89ddbb5a65beChris Lattner 273b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin DEBUG(dbgs() << "JIT: ARGV = " << (void*)Array << "\n"); 274db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *SBytePtr = Type::getInt8PtrTy(C); 27587f03108f282a9b5f172f91679bd89ddbb5a65beChris Lattner 27687f03108f282a9b5f172f91679bd89ddbb5a65beChris Lattner for (unsigned i = 0; i != InputArgv.size(); ++i) { 27787f03108f282a9b5f172f91679bd89ddbb5a65beChris Lattner unsigned Size = InputArgv[i].size()+1; 27887f03108f282a9b5f172f91679bd89ddbb5a65beChris Lattner char *Dest = new char[Size]; 279b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin Values.push_back(Dest); 280ae7c59a01286a3babbc6245dcb1049c7bcde2573David Greene DEBUG(dbgs() << "JIT: ARGV[" << i << "] = " << (void*)Dest << "\n"); 281edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 28287f03108f282a9b5f172f91679bd89ddbb5a65beChris Lattner std::copy(InputArgv[i].begin(), InputArgv[i].end(), Dest); 28387f03108f282a9b5f172f91679bd89ddbb5a65beChris Lattner Dest[Size-1] = 0; 284edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 285b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin // Endian safe: Array[i] = (PointerTy)Dest; 286b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin EE->StoreValueToMemory(PTOGV(Dest), (GenericValue*)(Array+i*PtrSize), 28787f03108f282a9b5f172f91679bd89ddbb5a65beChris Lattner SBytePtr); 28887f03108f282a9b5f172f91679bd89ddbb5a65beChris Lattner } 28987f03108f282a9b5f172f91679bd89ddbb5a65beChris Lattner 29087f03108f282a9b5f172f91679bd89ddbb5a65beChris Lattner // Null terminate it 29187f03108f282a9b5f172f91679bd89ddbb5a65beChris Lattner EE->StoreValueToMemory(PTOGV(0), 292b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin (GenericValue*)(Array+InputArgv.size()*PtrSize), 29387f03108f282a9b5f172f91679bd89ddbb5a65beChris Lattner SBytePtr); 294b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin return Array; 29587f03108f282a9b5f172f91679bd89ddbb5a65beChris Lattner} 29687f03108f282a9b5f172f91679bd89ddbb5a65beChris Lattner 297fbd39762e9db897ffd8e30ce7d387715cba6d4c1Chris Lattnervoid ExecutionEngine::runStaticConstructorsDestructors(Module *module, 298fbd39762e9db897ffd8e30ce7d387715cba6d4c1Chris Lattner bool isDtors) { 2999ca6cdaee91fddcd3ea57dedcd624c14c7a40f65Chris Lattner const char *Name = isDtors ? "llvm.global_dtors" : "llvm.global_ctors"; 30048dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar GlobalVariable *GV = module->getNamedGlobal(Name); 30148dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar 30248dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar // If this global has internal linkage, or if it has a use, then it must be 30348dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar // an old-style (llvmgcc3) static ctor with __main linked in and in use. If 30448dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar // this is the case, don't execute any of the global ctors, __main will do 30548dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar // it. 30648dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar if (!GV || GV->isDeclaration() || GV->hasLocalLinkage()) return; 30748dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar 308a040d47c74341327997a50e88bb8ad4ceda6989fNick Lewycky // Should be an array of '{ i32, void ()* }' structs. The first value is 30948dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar // the init priority, which we ignore. 3101ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner ConstantArray *InitList = dyn_cast<ConstantArray>(GV->getInitializer()); 3111ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner if (InitList == 0) 3125ea5c61589e62a1068746ddcc52c6aa39ec0f8b0Nick Lewycky return; 31348dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i) { 3141ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner ConstantStruct *CS = dyn_cast<ConstantStruct>(InitList->getOperand(i)); 3151ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner if (CS == 0) continue; 31648dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar 31748dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar Constant *FP = CS->getOperand(1); 31848dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar if (FP->isNullValue()) 3195ea5c61589e62a1068746ddcc52c6aa39ec0f8b0Nick Lewycky continue; // Found a sentinal value, ignore. 32048dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar 32148dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar // Strip off constant expression casts. 32248dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar if (ConstantExpr *CE = dyn_cast<ConstantExpr>(FP)) 32348dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar if (CE->isCast()) 32448dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar FP = CE->getOperand(0); 32548dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar 32648dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar // Execute the ctor/dtor function! 32748dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar if (Function *F = dyn_cast<Function>(FP)) 32848dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar runFunction(F, std::vector<GenericValue>()); 32948dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar 33048dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar // FIXME: It is marginally lame that we just do nothing here if we see an 33148dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar // entry we don't recognize. It might not be unreasonable for the verifier 33248dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar // to not even allow this and just assert here. 33348dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar } 33418314dc741ab7dc4db02b199af77f43bd8551fd2Evan Cheng} 33518314dc741ab7dc4db02b199af77f43bd8551fd2Evan Cheng 33618314dc741ab7dc4db02b199af77f43bd8551fd2Evan Chengvoid ExecutionEngine::runStaticConstructorsDestructors(bool isDtors) { 33718314dc741ab7dc4db02b199af77f43bd8551fd2Evan Cheng // Execute global ctors/dtors for each module in the program. 33848dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar for (unsigned i = 0, e = Modules.size(); i != e; ++i) 33948dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar runStaticConstructorsDestructors(Modules[i], isDtors); 3409ca6cdaee91fddcd3ea57dedcd624c14c7a40f65Chris Lattner} 3419ca6cdaee91fddcd3ea57dedcd624c14c7a40f65Chris Lattner 342b6e3d6ce709e9ed57df055b026e55d19e50df772Dan Gohman#ifndef NDEBUG 3438a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands/// isTargetNullPtr - Return whether the target pointer stored at Loc is null. 3448a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sandsstatic bool isTargetNullPtr(ExecutionEngine *EE, void *Loc) { 345426c2bf5cdd2173e4a33aea8cb92cf684a724f4bChandler Carruth unsigned PtrSize = EE->getDataLayout()->getPointerSize(); 3468a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands for (unsigned i = 0; i < PtrSize; ++i) 3478a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands if (*(i + (uint8_t*)Loc)) 3488a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands return false; 3498a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands return true; 3508a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands} 351b6e3d6ce709e9ed57df055b026e55d19e50df772Dan Gohman#endif 3528a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands 35387f03108f282a9b5f172f91679bd89ddbb5a65beChris Lattnerint ExecutionEngine::runFunctionAsMain(Function *Fn, 35487f03108f282a9b5f172f91679bd89ddbb5a65beChris Lattner const std::vector<std::string> &argv, 35587f03108f282a9b5f172f91679bd89ddbb5a65beChris Lattner const char * const * envp) { 35687f03108f282a9b5f172f91679bd89ddbb5a65beChris Lattner std::vector<GenericValue> GVArgs; 35787f03108f282a9b5f172f91679bd89ddbb5a65beChris Lattner GenericValue GVArgc; 3588fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer GVArgc.IntVal = APInt(32, argv.size()); 359499d8f0c3b212819515cdbcb98146fff6f9d877bAnton Korobeynikov 360499d8f0c3b212819515cdbcb98146fff6f9d877bAnton Korobeynikov // Check main() type 361f24d09933c0fa2dae141426f2c38c8925693c73fChris Lattner unsigned NumArgs = Fn->getFunctionType()->getNumParams(); 362db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner FunctionType *FTy = Fn->getFunctionType(); 363db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type* PPInt8Ty = Type::getInt8PtrTy(Fn->getContext())->getPointerTo(); 36448dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar 36548dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar // Check the argument types. 36648dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar if (NumArgs > 3) 36748dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar report_fatal_error("Invalid number of arguments of main() supplied"); 36848dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar if (NumArgs >= 3 && FTy->getParamType(2) != PPInt8Ty) 36948dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar report_fatal_error("Invalid type for third argument of main() supplied"); 37048dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar if (NumArgs >= 2 && FTy->getParamType(1) != PPInt8Ty) 37148dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar report_fatal_error("Invalid type for second argument of main() supplied"); 37248dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar if (NumArgs >= 1 && !FTy->getParamType(0)->isIntegerTy(32)) 37348dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar report_fatal_error("Invalid type for first argument of main() supplied"); 37448dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar if (!FTy->getReturnType()->isIntegerTy() && 37548dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar !FTy->getReturnType()->isVoidTy()) 37648dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar report_fatal_error("Invalid return type of main() supplied"); 37748dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar 378b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin ArgvArray CArgv; 379b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin ArgvArray CEnv; 380f24d09933c0fa2dae141426f2c38c8925693c73fChris Lattner if (NumArgs) { 381f24d09933c0fa2dae141426f2c38c8925693c73fChris Lattner GVArgs.push_back(GVArgc); // Arg #0 = argc. 382f24d09933c0fa2dae141426f2c38c8925693c73fChris Lattner if (NumArgs > 1) { 3831d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson // Arg #1 = argv. 384b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin GVArgs.push_back(PTOGV(CArgv.reset(Fn->getContext(), this, argv))); 3858a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands assert(!isTargetNullPtr(this, GVTOP(GVArgs[1])) && 386f24d09933c0fa2dae141426f2c38c8925693c73fChris Lattner "argv[0] was null after CreateArgv"); 387f24d09933c0fa2dae141426f2c38c8925693c73fChris Lattner if (NumArgs > 2) { 388f24d09933c0fa2dae141426f2c38c8925693c73fChris Lattner std::vector<std::string> EnvVars; 389f24d09933c0fa2dae141426f2c38c8925693c73fChris Lattner for (unsigned i = 0; envp[i]; ++i) 390f24d09933c0fa2dae141426f2c38c8925693c73fChris Lattner EnvVars.push_back(envp[i]); 3911d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson // Arg #2 = envp. 392b19383818bcaf65509f4050c81f75c8ee0624f8cJeffrey Yasskin GVArgs.push_back(PTOGV(CEnv.reset(Fn->getContext(), this, EnvVars))); 393f24d09933c0fa2dae141426f2c38c8925693c73fChris Lattner } 394f24d09933c0fa2dae141426f2c38c8925693c73fChris Lattner } 395f24d09933c0fa2dae141426f2c38c8925693c73fChris Lattner } 39648dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar 3978fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer return runFunction(Fn, GVArgs).IntVal.getZExtValue(); 39887f03108f282a9b5f172f91679bd89ddbb5a65beChris Lattner} 39987f03108f282a9b5f172f91679bd89ddbb5a65beChris Lattner 400f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey YasskinExecutionEngine *ExecutionEngine::create(Module *M, 401d4c0e62413ac4c81467ce59025c81210ea431752Reid Spencer bool ForceInterpreter, 402502f20b17ede40de84503010b7699b328a4f2867Evan Cheng std::string *ErrorStr, 403489393d7b92107cc3de17d8dbe7dd11ab7395fdcJeffrey Yasskin CodeGenOpt::Level OptLevel, 404489393d7b92107cc3de17d8dbe7dd11ab7395fdcJeffrey Yasskin bool GVsWithCode) { 4058e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson EngineBuilder EB = EngineBuilder(M) 4064b1511b027ce0b648b3379f2891816c25b46f515Reid Kleckner .setEngineKind(ForceInterpreter 4074b1511b027ce0b648b3379f2891816c25b46f515Reid Kleckner ? EngineKind::Interpreter 4084b1511b027ce0b648b3379f2891816c25b46f515Reid Kleckner : EngineKind::JIT) 4094b1511b027ce0b648b3379f2891816c25b46f515Reid Kleckner .setErrorStr(ErrorStr) 4104b1511b027ce0b648b3379f2891816c25b46f515Reid Kleckner .setOptLevel(OptLevel) 4118e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson .setAllocateGVsWithCode(GVsWithCode); 4128e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson 4138e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson return EB.create(); 4144b1511b027ce0b648b3379f2891816c25b46f515Reid Kleckner} 4154b1511b027ce0b648b3379f2891816c25b46f515Reid Kleckner 416f5895e95926c96574888d7eb20b62d2cffe86193Dylan Noblesmith/// createJIT - This is the factory method for creating a JIT for the current 417f5895e95926c96574888d7eb20b62d2cffe86193Dylan Noblesmith/// machine, it does not fall back to the interpreter. This takes ownership 418f5895e95926c96574888d7eb20b62d2cffe86193Dylan Noblesmith/// of the module. 419f5895e95926c96574888d7eb20b62d2cffe86193Dylan NoblesmithExecutionEngine *ExecutionEngine::createJIT(Module *M, 420f5895e95926c96574888d7eb20b62d2cffe86193Dylan Noblesmith std::string *ErrorStr, 421f5895e95926c96574888d7eb20b62d2cffe86193Dylan Noblesmith JITMemoryManager *JMM, 422d95e67dac029d48984b72889a96a1bb389b8ac71Dylan Noblesmith CodeGenOpt::Level OL, 423f5895e95926c96574888d7eb20b62d2cffe86193Dylan Noblesmith bool GVsWithCode, 424439661395fd2a2a832dba01c65bc88718528313cEvan Cheng Reloc::Model RM, 425f5895e95926c96574888d7eb20b62d2cffe86193Dylan Noblesmith CodeModel::Model CMM) { 426f5895e95926c96574888d7eb20b62d2cffe86193Dylan Noblesmith if (ExecutionEngine::JITCtor == 0) { 427f5895e95926c96574888d7eb20b62d2cffe86193Dylan Noblesmith if (ErrorStr) 428f5895e95926c96574888d7eb20b62d2cffe86193Dylan Noblesmith *ErrorStr = "JIT has not been linked in."; 429f5895e95926c96574888d7eb20b62d2cffe86193Dylan Noblesmith return 0; 430f5895e95926c96574888d7eb20b62d2cffe86193Dylan Noblesmith } 431f5895e95926c96574888d7eb20b62d2cffe86193Dylan Noblesmith 432f5895e95926c96574888d7eb20b62d2cffe86193Dylan Noblesmith // Use the defaults for extra parameters. Users can use EngineBuilder to 433f5895e95926c96574888d7eb20b62d2cffe86193Dylan Noblesmith // set them. 4348e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson EngineBuilder EB(M); 4358e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson EB.setEngineKind(EngineKind::JIT); 4368e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson EB.setErrorStr(ErrorStr); 4378e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson EB.setRelocationModel(RM); 4388e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson EB.setCodeModel(CMM); 4398e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson EB.setAllocateGVsWithCode(GVsWithCode); 4408e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson EB.setOptLevel(OL); 4418e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson EB.setJITMemoryManager(JMM); 442f5895e95926c96574888d7eb20b62d2cffe86193Dylan Noblesmith 443d40e103ea5bca8a223fc8261b3322b9454e9af12Peter Collingbourne // TODO: permit custom TargetOptions here 4448e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson TargetMachine *TM = EB.selectTarget(); 445f5895e95926c96574888d7eb20b62d2cffe86193Dylan Noblesmith if (!TM || (ErrorStr && ErrorStr->length() > 0)) return 0; 446f5895e95926c96574888d7eb20b62d2cffe86193Dylan Noblesmith 4479ea47179e647e806a2c67639bfead9d254514e59Dylan Noblesmith return ExecutionEngine::JITCtor(M, ErrorStr, JMM, GVsWithCode, TM); 448f5895e95926c96574888d7eb20b62d2cffe86193Dylan Noblesmith} 449f5895e95926c96574888d7eb20b62d2cffe86193Dylan Noblesmith 4508e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen AndersonExecutionEngine *EngineBuilder::create(TargetMachine *TM) { 4510f554492467064b3198df509227a3e902cf7cf1fBenjamin Kramer OwningPtr<TargetMachine> TheTM(TM); // Take ownership. 4520f554492467064b3198df509227a3e902cf7cf1fBenjamin Kramer 4536456d8639b6f3ede1bb1a90a5d33fe4e719ad4acNick Lewycky // Make sure we can resolve symbols in the program as well. The zero arg 4546456d8639b6f3ede1bb1a90a5d33fe4e719ad4acNick Lewycky // to the function tells DynamicLibrary to load the program, not a library. 4556456d8639b6f3ede1bb1a90a5d33fe4e719ad4acNick Lewycky if (sys::DynamicLibrary::LoadLibraryPermanently(0, ErrorStr)) 4566456d8639b6f3ede1bb1a90a5d33fe4e719ad4acNick Lewycky return 0; 4576456d8639b6f3ede1bb1a90a5d33fe4e719ad4acNick Lewycky 4584b1511b027ce0b648b3379f2891816c25b46f515Reid Kleckner // If the user specified a memory manager but didn't specify which engine to 4594b1511b027ce0b648b3379f2891816c25b46f515Reid Kleckner // create, we assume they only want the JIT, and we fail if they only want 4604b1511b027ce0b648b3379f2891816c25b46f515Reid Kleckner // the interpreter. 4614b1511b027ce0b648b3379f2891816c25b46f515Reid Kleckner if (JMM) { 462fbd39762e9db897ffd8e30ce7d387715cba6d4c1Chris Lattner if (WhichEngine & EngineKind::JIT) 4634b1511b027ce0b648b3379f2891816c25b46f515Reid Kleckner WhichEngine = EngineKind::JIT; 464fbd39762e9db897ffd8e30ce7d387715cba6d4c1Chris Lattner else { 465c72efbeb42a9eaa0a83b8bba4954dcaf9ae64103Chris Lattner if (ErrorStr) 466c72efbeb42a9eaa0a83b8bba4954dcaf9ae64103Chris Lattner *ErrorStr = "Cannot create an interpreter with a memory manager."; 467fbd39762e9db897ffd8e30ce7d387715cba6d4c1Chris Lattner return 0; 4684b1511b027ce0b648b3379f2891816c25b46f515Reid Kleckner } 4694b1511b027ce0b648b3379f2891816c25b46f515Reid Kleckner } 47082d8277ad5862b54341808812bb4016e52347060Brian Gaeke 4714b1511b027ce0b648b3379f2891816c25b46f515Reid Kleckner // Unless the interpreter was explicitly selected or the JIT is not linked, 4724b1511b027ce0b648b3379f2891816c25b46f515Reid Kleckner // try making a JIT. 4730f554492467064b3198df509227a3e902cf7cf1fBenjamin Kramer if ((WhichEngine & EngineKind::JIT) && TheTM) { 4749ea47179e647e806a2c67639bfead9d254514e59Dylan Noblesmith Triple TT(M->getTargetTriple()); 4758e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson if (!TM->getTarget().hasJIT()) { 4768e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson errs() << "WARNING: This target JIT is not designed for the host" 4778e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson << " you are running. If bad things happen, please choose" 4788e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson << " a different -march switch.\n"; 4798e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson } 4809ea47179e647e806a2c67639bfead9d254514e59Dylan Noblesmith 4818e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson if (UseMCJIT && ExecutionEngine::MCJITCtor) { 4828e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson ExecutionEngine *EE = 4838e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson ExecutionEngine::MCJITCtor(M, ErrorStr, JMM, 4840f554492467064b3198df509227a3e902cf7cf1fBenjamin Kramer AllocateGVsWithCode, TheTM.take()); 4858e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson if (EE) return EE; 4868e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson } else if (ExecutionEngine::JITCtor) { 4878e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson ExecutionEngine *EE = 4888e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson ExecutionEngine::JITCtor(M, ErrorStr, JMM, 4890f554492467064b3198df509227a3e902cf7cf1fBenjamin Kramer AllocateGVsWithCode, TheTM.take()); 4908e1fc56b2496270d1d6040cb648eef5d5aeb6079Owen Anderson if (EE) return EE; 491fbd39762e9db897ffd8e30ce7d387715cba6d4c1Chris Lattner } 4924b1511b027ce0b648b3379f2891816c25b46f515Reid Kleckner } 49382d8277ad5862b54341808812bb4016e52347060Brian Gaeke 4944b1511b027ce0b648b3379f2891816c25b46f515Reid Kleckner // If we can't make a JIT and we didn't request one specifically, try making 4954b1511b027ce0b648b3379f2891816c25b46f515Reid Kleckner // an interpreter instead. 496fbd39762e9db897ffd8e30ce7d387715cba6d4c1Chris Lattner if (WhichEngine & EngineKind::Interpreter) { 497fbd39762e9db897ffd8e30ce7d387715cba6d4c1Chris Lattner if (ExecutionEngine::InterpCtor) 498f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin return ExecutionEngine::InterpCtor(M, ErrorStr); 499c72efbeb42a9eaa0a83b8bba4954dcaf9ae64103Chris Lattner if (ErrorStr) 500c72efbeb42a9eaa0a83b8bba4954dcaf9ae64103Chris Lattner *ErrorStr = "Interpreter has not been linked in."; 501fbd39762e9db897ffd8e30ce7d387715cba6d4c1Chris Lattner return 0; 5024b1511b027ce0b648b3379f2891816c25b46f515Reid Kleckner } 503c72efbeb42a9eaa0a83b8bba4954dcaf9ae64103Chris Lattner 5048005bcd5e0c923881d82afcb813a7e537cd1b241Jim Grosbach if ((WhichEngine & EngineKind::JIT) && ExecutionEngine::JITCtor == 0 && 5058005bcd5e0c923881d82afcb813a7e537cd1b241Jim Grosbach ExecutionEngine::MCJITCtor == 0) { 506c72efbeb42a9eaa0a83b8bba4954dcaf9ae64103Chris Lattner if (ErrorStr) 507c72efbeb42a9eaa0a83b8bba4954dcaf9ae64103Chris Lattner *ErrorStr = "JIT has not been linked in."; 50848dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar } 50948dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar 510fbd39762e9db897ffd8e30ce7d387715cba6d4c1Chris Lattner return 0; 5118b5295b7bb8bf44f13df7fc8e38069d1218b1f94Chris Lattner} 5128b5295b7bb8bf44f13df7fc8e38069d1218b1f94Chris Lattner 513bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattnervoid *ExecutionEngine::getPointerToGlobal(const GlobalValue *GV) { 51437df460874e8d9d28e6833e5fb66a9aa8e1ef50aBrian Gaeke if (Function *F = const_cast<Function*>(dyn_cast<Function>(GV))) 515bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner return getPointerToFunction(F); 516bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner 517ee448630bdf7eb6037fe2c50518d32010c433ca3Reid Spencer MutexGuard locked(lock); 51848dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar if (void *P = EEState.getGlobalAddressMap(locked)[GV]) 51948dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar return P; 52068835dd5119150383938c701fc223077d2bc1e25Jeff Cohen 52168835dd5119150383938c701fc223077d2bc1e25Jeff Cohen // Global variable might have been added since interpreter started. 52268835dd5119150383938c701fc223077d2bc1e25Jeff Cohen if (GlobalVariable *GVar = 52368835dd5119150383938c701fc223077d2bc1e25Jeff Cohen const_cast<GlobalVariable *>(dyn_cast<GlobalVariable>(GV))) 52468835dd5119150383938c701fc223077d2bc1e25Jeff Cohen EmitGlobalVariable(GVar); 52568835dd5119150383938c701fc223077d2bc1e25Jeff Cohen else 526c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable("Global hasn't had an address allocated yet!"); 52748dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar 52823e5fcfec4640955fec41dc8348f467adf1a3e56Jeffrey Yasskin return EEState.getGlobalAddressMap(locked)[GV]; 529bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner} 530bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner 53148dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar/// \brief Converts a Constant* into a GenericValue, including handling of 53248dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar/// ConstantExpr values. 533bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris LattnerGenericValue ExecutionEngine::getConstantValue(const Constant *C) { 5343da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // If its undefined, return the garbage. 5355b3701256c6706182ebfaeed8d50a66c6afe2a40Jay Foad if (isa<UndefValue>(C)) { 5365b3701256c6706182ebfaeed8d50a66c6afe2a40Jay Foad GenericValue Result; 5375b3701256c6706182ebfaeed8d50a66c6afe2a40Jay Foad switch (C->getType()->getTypeID()) { 5385b3701256c6706182ebfaeed8d50a66c6afe2a40Jay Foad case Type::IntegerTyID: 5395b3701256c6706182ebfaeed8d50a66c6afe2a40Jay Foad case Type::X86_FP80TyID: 5405b3701256c6706182ebfaeed8d50a66c6afe2a40Jay Foad case Type::FP128TyID: 5415b3701256c6706182ebfaeed8d50a66c6afe2a40Jay Foad case Type::PPC_FP128TyID: 5425b3701256c6706182ebfaeed8d50a66c6afe2a40Jay Foad // Although the value is undefined, we still have to construct an APInt 5435b3701256c6706182ebfaeed8d50a66c6afe2a40Jay Foad // with the correct bit width. 5445b3701256c6706182ebfaeed8d50a66c6afe2a40Jay Foad Result.IntVal = APInt(C->getType()->getPrimitiveSizeInBits(), 0); 5455b3701256c6706182ebfaeed8d50a66c6afe2a40Jay Foad break; 5465b3701256c6706182ebfaeed8d50a66c6afe2a40Jay Foad default: 5475b3701256c6706182ebfaeed8d50a66c6afe2a40Jay Foad break; 5485b3701256c6706182ebfaeed8d50a66c6afe2a40Jay Foad } 5495b3701256c6706182ebfaeed8d50a66c6afe2a40Jay Foad return Result; 5505b3701256c6706182ebfaeed8d50a66c6afe2a40Jay Foad } 551d8c03bfa0a8cbcbf3ee31b0e9b52126c9dbafe2aChris Lattner 55248dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar // Otherwise, if the value is a ConstantExpr... 5533da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) { 554bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer Constant *Op0 = CE->getOperand(0); 555d8c03bfa0a8cbcbf3ee31b0e9b52126c9dbafe2aChris Lattner switch (CE->getOpcode()) { 556d8c03bfa0a8cbcbf3ee31b0e9b52126c9dbafe2aChris Lattner case Instruction::GetElementPtr: { 55748dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar // Compute the index 558bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer GenericValue Result = getConstantValue(Op0); 55998281a20503896349bd152e2dfe87435d3a6aadaNuno Lopes APInt Offset(TD->getPointerSizeInBits(), 0); 56098281a20503896349bd152e2dfe87435d3a6aadaNuno Lopes cast<GEPOperator>(CE)->accumulateConstantOffset(*TD, Offset); 561edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 5628fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer char* tmp = (char*) Result.PointerVal; 56398281a20503896349bd152e2dfe87435d3a6aadaNuno Lopes Result = PTOGV(tmp + Offset.getSExtValue()); 564d8c03bfa0a8cbcbf3ee31b0e9b52126c9dbafe2aChris Lattner return Result; 565d8c03bfa0a8cbcbf3ee31b0e9b52126c9dbafe2aChris Lattner } 566bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer case Instruction::Trunc: { 567bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer GenericValue GV = getConstantValue(Op0); 568bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer uint32_t BitWidth = cast<IntegerType>(CE->getType())->getBitWidth(); 569bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer GV.IntVal = GV.IntVal.trunc(BitWidth); 5703da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer return GV; 5713da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer } 572bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer case Instruction::ZExt: { 573bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer GenericValue GV = getConstantValue(Op0); 574bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer uint32_t BitWidth = cast<IntegerType>(CE->getType())->getBitWidth(); 575bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer GV.IntVal = GV.IntVal.zext(BitWidth); 576bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer return GV; 577bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer } 578bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer case Instruction::SExt: { 579bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer GenericValue GV = getConstantValue(Op0); 580bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer uint32_t BitWidth = cast<IntegerType>(CE->getType())->getBitWidth(); 581bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer GV.IntVal = GV.IntVal.sext(BitWidth); 582bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer return GV; 583bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer } 584bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer case Instruction::FPTrunc: { 5851abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen // FIXME long double 586bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer GenericValue GV = getConstantValue(Op0); 587bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer GV.FloatVal = float(GV.DoubleVal); 588bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer return GV; 589bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer } 590bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer case Instruction::FPExt:{ 5911abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen // FIXME long double 592bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer GenericValue GV = getConstantValue(Op0); 593bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer GV.DoubleVal = double(GV.FloatVal); 594bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer return GV; 595bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer } 596bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer case Instruction::UIToFP: { 597bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer GenericValue GV = getConstantValue(Op0); 598cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner if (CE->getType()->isFloatTy()) 599bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer GV.FloatVal = float(GV.IntVal.roundToDouble()); 600cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner else if (CE->getType()->isDoubleTy()) 601bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer GV.DoubleVal = GV.IntVal.roundToDouble(); 602cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner else if (CE->getType()->isX86_FP80Ty()) { 6033069cbf7b3ef9a31bbb8e434686b7259052c364aBenjamin Kramer APFloat apf = APFloat::getZero(APFloat::x87DoubleExtended); 60448dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar (void)apf.convertFromAPInt(GV.IntVal, 605628240649267597f3f27a51ab046b5841c24a953Dan Gohman false, 606628240649267597f3f27a51ab046b5841c24a953Dan Gohman APFloat::rmNearestTiesToEven); 6077111b02c734c992b8c97d9918118768026dad79eDale Johannesen GV.IntVal = apf.bitcastToAPInt(); 6081abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen } 609bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer return GV; 610bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer } 611bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer case Instruction::SIToFP: { 612bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer GenericValue GV = getConstantValue(Op0); 613cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner if (CE->getType()->isFloatTy()) 614bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer GV.FloatVal = float(GV.IntVal.signedRoundToDouble()); 615cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner else if (CE->getType()->isDoubleTy()) 616bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer GV.DoubleVal = GV.IntVal.signedRoundToDouble(); 617cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner else if (CE->getType()->isX86_FP80Ty()) { 6183069cbf7b3ef9a31bbb8e434686b7259052c364aBenjamin Kramer APFloat apf = APFloat::getZero(APFloat::x87DoubleExtended); 61948dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar (void)apf.convertFromAPInt(GV.IntVal, 620628240649267597f3f27a51ab046b5841c24a953Dan Gohman true, 621628240649267597f3f27a51ab046b5841c24a953Dan Gohman APFloat::rmNearestTiesToEven); 6227111b02c734c992b8c97d9918118768026dad79eDale Johannesen GV.IntVal = apf.bitcastToAPInt(); 6231abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen } 624bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer return GV; 625bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer } 626bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer case Instruction::FPToUI: // double->APInt conversion handles sign 627bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer case Instruction::FPToSI: { 628bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer GenericValue GV = getConstantValue(Op0); 629bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer uint32_t BitWidth = cast<IntegerType>(CE->getType())->getBitWidth(); 630cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner if (Op0->getType()->isFloatTy()) 631bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer GV.IntVal = APIntOps::RoundFloatToAPInt(GV.FloatVal, BitWidth); 632cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner else if (Op0->getType()->isDoubleTy()) 633bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer GV.IntVal = APIntOps::RoundDoubleToAPInt(GV.DoubleVal, BitWidth); 634cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner else if (Op0->getType()->isX86_FP80Ty()) { 6350a29cb045444c13160e90fe7942a9d7c720185edTim Northover APFloat apf = APFloat(APFloat::x87DoubleExtended, GV.IntVal); 6361abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen uint64_t v; 63723a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen bool ignored; 6381abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen (void)apf.convertToInteger(&v, BitWidth, 63948dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar CE->getOpcode()==Instruction::FPToSI, 64023a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen APFloat::rmTowardZero, &ignored); 6411abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen GV.IntVal = v; // endian? 6421abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen } 643bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer return GV; 644bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer } 645bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer case Instruction::PtrToInt: { 646bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer GenericValue GV = getConstantValue(Op0); 647bbc6e671b1a902c96aff152cc524a5ee6e253907Eli Friedman uint32_t PtrWidth = TD->getTypeSizeInBits(Op0->getType()); 648bbc6e671b1a902c96aff152cc524a5ee6e253907Eli Friedman assert(PtrWidth <= 64 && "Bad pointer width"); 649bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer GV.IntVal = APInt(PtrWidth, uintptr_t(GV.PointerVal)); 650bbc6e671b1a902c96aff152cc524a5ee6e253907Eli Friedman uint32_t IntWidth = TD->getTypeSizeInBits(CE->getType()); 651bbc6e671b1a902c96aff152cc524a5ee6e253907Eli Friedman GV.IntVal = GV.IntVal.zextOrTrunc(IntWidth); 652bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer return GV; 6533da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer } 6543da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case Instruction::IntToPtr: { 655bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer GenericValue GV = getConstantValue(Op0); 656b52fb876171e3670e7307fda4459ca005d49d9f5Micah Villmow uint32_t PtrWidth = TD->getTypeSizeInBits(CE->getType()); 657bbc6e671b1a902c96aff152cc524a5ee6e253907Eli Friedman GV.IntVal = GV.IntVal.zextOrTrunc(PtrWidth); 658bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer assert(GV.IntVal.getBitWidth() <= 64 && "Bad pointer width"); 659bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer GV.PointerVal = PointerTy(uintptr_t(GV.IntVal.getZExtValue())); 660bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer return GV; 661bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer } 662bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer case Instruction::BitCast: { 663bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer GenericValue GV = getConstantValue(Op0); 664db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type* DestTy = CE->getType(); 665bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer switch (Op0->getType()->getTypeID()) { 666c23197a26f34f559ea9797de51e187087c039c42Torok Edwin default: llvm_unreachable("Invalid bitcast operand"); 667bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer case Type::IntegerTyID: 668b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(DestTy->isFloatingPointTy() && "invalid bitcast"); 669cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner if (DestTy->isFloatTy()) 670bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer GV.FloatVal = GV.IntVal.bitsToFloat(); 671cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner else if (DestTy->isDoubleTy()) 672bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer GV.DoubleVal = GV.IntVal.bitsToDouble(); 673bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer break; 67448dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar case Type::FloatTyID: 675b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(DestTy->isIntegerTy(32) && "Invalid bitcast"); 676e4d19c9eb22899c9a555395d446a9ceef3bea7ebJay Foad GV.IntVal = APInt::floatToBits(GV.FloatVal); 677bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer break; 678bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer case Type::DoubleTyID: 679b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(DestTy->isIntegerTy(64) && "Invalid bitcast"); 680e4d19c9eb22899c9a555395d446a9ceef3bea7ebJay Foad GV.IntVal = APInt::doubleToBits(GV.DoubleVal); 681bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer break; 682bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer case Type::PointerTyID: 6831df9859c40492511b8aa4321eb76496005d3b75bDuncan Sands assert(DestTy->isPointerTy() && "Invalid bitcast"); 684bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer break; // getConstantValue(Op0) above already converted it 685bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer } 686bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer return GV; 687d8c03bfa0a8cbcbf3ee31b0e9b52126c9dbafe2aChris Lattner } 6889a23122b6a4decff3d3f10cb8d9b5ccebe5c7474Chris Lattner case Instruction::Add: 689ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::FAdd: 690bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer case Instruction::Sub: 691ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::FSub: 692bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer case Instruction::Mul: 693ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::FMul: 694bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer case Instruction::UDiv: 695bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer case Instruction::SDiv: 696bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer case Instruction::URem: 697bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer case Instruction::SRem: 698bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer case Instruction::And: 699bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer case Instruction::Or: 700bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer case Instruction::Xor: { 701bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer GenericValue LHS = getConstantValue(Op0); 702bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer GenericValue RHS = getConstantValue(CE->getOperand(1)); 703bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer GenericValue GV; 7045f90cb8c9838ab03feef93c9dacd5ff652e5d8d2Chris Lattner switch (CE->getOperand(0)->getType()->getTypeID()) { 705c23197a26f34f559ea9797de51e187087c039c42Torok Edwin default: llvm_unreachable("Bad add type!"); 706a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer case Type::IntegerTyID: 707bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer switch (CE->getOpcode()) { 708c23197a26f34f559ea9797de51e187087c039c42Torok Edwin default: llvm_unreachable("Invalid integer opcode"); 709bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer case Instruction::Add: GV.IntVal = LHS.IntVal + RHS.IntVal; break; 710bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer case Instruction::Sub: GV.IntVal = LHS.IntVal - RHS.IntVal; break; 711bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer case Instruction::Mul: GV.IntVal = LHS.IntVal * RHS.IntVal; break; 712bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer case Instruction::UDiv:GV.IntVal = LHS.IntVal.udiv(RHS.IntVal); break; 713bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer case Instruction::SDiv:GV.IntVal = LHS.IntVal.sdiv(RHS.IntVal); break; 714bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer case Instruction::URem:GV.IntVal = LHS.IntVal.urem(RHS.IntVal); break; 715bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer case Instruction::SRem:GV.IntVal = LHS.IntVal.srem(RHS.IntVal); break; 716bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer case Instruction::And: GV.IntVal = LHS.IntVal & RHS.IntVal; break; 717bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer case Instruction::Or: GV.IntVal = LHS.IntVal | RHS.IntVal; break; 718bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer case Instruction::Xor: GV.IntVal = LHS.IntVal ^ RHS.IntVal; break; 719bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer } 7205f90cb8c9838ab03feef93c9dacd5ff652e5d8d2Chris Lattner break; 7215f90cb8c9838ab03feef93c9dacd5ff652e5d8d2Chris Lattner case Type::FloatTyID: 722bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer switch (CE->getOpcode()) { 723c23197a26f34f559ea9797de51e187087c039c42Torok Edwin default: llvm_unreachable("Invalid float opcode"); 724ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::FAdd: 725bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer GV.FloatVal = LHS.FloatVal + RHS.FloatVal; break; 726ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::FSub: 727bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer GV.FloatVal = LHS.FloatVal - RHS.FloatVal; break; 728ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::FMul: 729bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer GV.FloatVal = LHS.FloatVal * RHS.FloatVal; break; 73048dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar case Instruction::FDiv: 731bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer GV.FloatVal = LHS.FloatVal / RHS.FloatVal; break; 73248dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar case Instruction::FRem: 73387565c1d779a1903d10ddd11d886c0f79ee430b5Chris Lattner GV.FloatVal = std::fmod(LHS.FloatVal,RHS.FloatVal); break; 734bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer } 7355f90cb8c9838ab03feef93c9dacd5ff652e5d8d2Chris Lattner break; 7365f90cb8c9838ab03feef93c9dacd5ff652e5d8d2Chris Lattner case Type::DoubleTyID: 737bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer switch (CE->getOpcode()) { 738c23197a26f34f559ea9797de51e187087c039c42Torok Edwin default: llvm_unreachable("Invalid double opcode"); 739ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::FAdd: 740bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer GV.DoubleVal = LHS.DoubleVal + RHS.DoubleVal; break; 741ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::FSub: 742bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer GV.DoubleVal = LHS.DoubleVal - RHS.DoubleVal; break; 743ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::FMul: 744bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer GV.DoubleVal = LHS.DoubleVal * RHS.DoubleVal; break; 74548dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar case Instruction::FDiv: 746bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer GV.DoubleVal = LHS.DoubleVal / RHS.DoubleVal; break; 74748dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar case Instruction::FRem: 74887565c1d779a1903d10ddd11d886c0f79ee430b5Chris Lattner GV.DoubleVal = std::fmod(LHS.DoubleVal,RHS.DoubleVal); break; 749bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer } 7505f90cb8c9838ab03feef93c9dacd5ff652e5d8d2Chris Lattner break; 7511abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen case Type::X86_FP80TyID: 7521abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen case Type::PPC_FP128TyID: 7531abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen case Type::FP128TyID: { 7540a29cb045444c13160e90fe7942a9d7c720185edTim Northover const fltSemantics &Sem = CE->getOperand(0)->getType()->getFltSemantics(); 7550a29cb045444c13160e90fe7942a9d7c720185edTim Northover APFloat apfLHS = APFloat(Sem, LHS.IntVal); 7561abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen switch (CE->getOpcode()) { 757ab19da4bc087e79550ebe448d9edd4d8ed248388Daniel Dunbar default: llvm_unreachable("Invalid long double opcode"); 758ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::FAdd: 7590a29cb045444c13160e90fe7942a9d7c720185edTim Northover apfLHS.add(APFloat(Sem, RHS.IntVal), APFloat::rmNearestTiesToEven); 7607111b02c734c992b8c97d9918118768026dad79eDale Johannesen GV.IntVal = apfLHS.bitcastToAPInt(); 7611abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen break; 762ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::FSub: 7630a29cb045444c13160e90fe7942a9d7c720185edTim Northover apfLHS.subtract(APFloat(Sem, RHS.IntVal), 7640a29cb045444c13160e90fe7942a9d7c720185edTim Northover APFloat::rmNearestTiesToEven); 7657111b02c734c992b8c97d9918118768026dad79eDale Johannesen GV.IntVal = apfLHS.bitcastToAPInt(); 7661abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen break; 767ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::FMul: 7680a29cb045444c13160e90fe7942a9d7c720185edTim Northover apfLHS.multiply(APFloat(Sem, RHS.IntVal), 7690a29cb045444c13160e90fe7942a9d7c720185edTim Northover APFloat::rmNearestTiesToEven); 7707111b02c734c992b8c97d9918118768026dad79eDale Johannesen GV.IntVal = apfLHS.bitcastToAPInt(); 7711abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen break; 77248dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar case Instruction::FDiv: 7730a29cb045444c13160e90fe7942a9d7c720185edTim Northover apfLHS.divide(APFloat(Sem, RHS.IntVal), 7740a29cb045444c13160e90fe7942a9d7c720185edTim Northover APFloat::rmNearestTiesToEven); 7757111b02c734c992b8c97d9918118768026dad79eDale Johannesen GV.IntVal = apfLHS.bitcastToAPInt(); 7761abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen break; 77748dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar case Instruction::FRem: 7780a29cb045444c13160e90fe7942a9d7c720185edTim Northover apfLHS.mod(APFloat(Sem, RHS.IntVal), 7790a29cb045444c13160e90fe7942a9d7c720185edTim Northover APFloat::rmNearestTiesToEven); 7807111b02c734c992b8c97d9918118768026dad79eDale Johannesen GV.IntVal = apfLHS.bitcastToAPInt(); 7811abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen break; 7821abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen } 7831abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen } 7841abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen break; 7855f90cb8c9838ab03feef93c9dacd5ff652e5d8d2Chris Lattner } 786bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer return GV; 787bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer } 7889a23122b6a4decff3d3f10cb8d9b5ccebe5c7474Chris Lattner default: 7899a23122b6a4decff3d3f10cb8d9b5ccebe5c7474Chris Lattner break; 7909a23122b6a4decff3d3f10cb8d9b5ccebe5c7474Chris Lattner } 79148dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar 79248dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar SmallString<256> Msg; 79348dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar raw_svector_ostream OS(Msg); 79448dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar OS << "ConstantExpr not handled: " << *CE; 79548dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar report_fatal_error(OS.str()); 7969a23122b6a4decff3d3f10cb8d9b5ccebe5c7474Chris Lattner } 797edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 79848dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar // Otherwise, we have a simple constant. 799bce30f1887631d606c44b8fdd185dcc42096ca60Reid Spencer GenericValue Result; 800f70c22b019494723d0e706f93d6542dfaa6e73a5Chris Lattner switch (C->getType()->getTypeID()) { 80148dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar case Type::FloatTyID: 80248dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar Result.FloatVal = cast<ConstantFP>(C)->getValueAPF().convertToFloat(); 8038fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer break; 8048fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer case Type::DoubleTyID: 80543421b3dd70af5b70e71816521f37502c397cc65Dale Johannesen Result.DoubleVal = cast<ConstantFP>(C)->getValueAPF().convertToDouble(); 8068fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer break; 8071abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen case Type::X86_FP80TyID: 8081abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen case Type::FP128TyID: 8091abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen case Type::PPC_FP128TyID: 8107111b02c734c992b8c97d9918118768026dad79eDale Johannesen Result.IntVal = cast <ConstantFP>(C)->getValueAPF().bitcastToAPInt(); 8111abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen break; 8128fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer case Type::IntegerTyID: 8138fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer Result.IntVal = cast<ConstantInt>(C)->getValue(); 814a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer break; 815bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner case Type::PointerTyID: 81640cf2f954e7d554872f6eca42c844bc065b02c11Reid Spencer if (isa<ConstantPointerNull>(C)) 817bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner Result.PointerVal = 0; 81840cf2f954e7d554872f6eca42c844bc065b02c11Reid Spencer else if (const Function *F = dyn_cast<Function>(C)) 81940cf2f954e7d554872f6eca42c844bc065b02c11Reid Spencer Result = PTOGV(getPointerToFunctionOrStub(const_cast<Function*>(F))); 820f32a6a3091e0b01d17926f4b1cf78972854b8cb5Chris Lattner else if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(C)) 82140cf2f954e7d554872f6eca42c844bc065b02c11Reid Spencer Result = PTOGV(getOrEmitGlobalVariable(const_cast<GlobalVariable*>(GV))); 822f32a6a3091e0b01d17926f4b1cf78972854b8cb5Chris Lattner else if (const BlockAddress *BA = dyn_cast<BlockAddress>(C)) 823f32a6a3091e0b01d17926f4b1cf78972854b8cb5Chris Lattner Result = PTOGV(getPointerToBasicBlock(const_cast<BasicBlock*>( 824f32a6a3091e0b01d17926f4b1cf78972854b8cb5Chris Lattner BA->getBasicBlock()))); 82540cf2f954e7d554872f6eca42c844bc065b02c11Reid Spencer else 826c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable("Unknown constant pointer type!"); 827bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner break; 828bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner default: 82948dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar SmallString<256> Msg; 83048dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar raw_svector_ostream OS(Msg); 83148dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar OS << "ERROR: Constant unimplemented for type: " << *C->getType(); 83248dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar report_fatal_error(OS.str()); 833bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner } 83448dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar 835bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner return Result; 836bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner} 837bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner 8388a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands/// StoreIntToMemory - Fills the StoreBytes bytes of memory starting from Dst 8398a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands/// with the integer held in IntVal. 8408a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sandsstatic void StoreIntToMemory(const APInt &IntVal, uint8_t *Dst, 8418a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands unsigned StoreBytes) { 8428a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands assert((IntVal.getBitWidth()+7)/8 >= StoreBytes && "Integer too small!"); 84359324297650c12a8dccf1a7ad650a9e895fdc17eRoman Divacky const uint8_t *Src = (const uint8_t *)IntVal.getRawData(); 8448a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands 84548dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar if (sys::isLittleEndianHost()) { 8468a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands // Little-endian host - the source is ordered from LSB to MSB. Order the 8478a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands // destination from LSB to MSB: Do a straight copy. 8488a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands memcpy(Dst, Src, StoreBytes); 84948dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar } else { 8508a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands // Big-endian host - the source is an array of 64 bit words ordered from 8518a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands // LSW to MSW. Each word is ordered from MSB to LSB. Order the destination 8528a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands // from MSB to LSB: Reverse the word order, but not the bytes in a word. 8538a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands while (StoreBytes > sizeof(uint64_t)) { 8548a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands StoreBytes -= sizeof(uint64_t); 8558a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands // May not be aligned so use memcpy. 8568a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands memcpy(Dst + StoreBytes, Src, sizeof(uint64_t)); 8578a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands Src += sizeof(uint64_t); 8588a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands } 8598a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands 8608a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands memcpy(Dst, Src + sizeof(uint64_t) - StoreBytes, StoreBytes); 8618a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands } 8628a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands} 8638a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands 86489687e3e4ac4aa602de7cce4a7fbc5f514e86615Evan Chengvoid ExecutionEngine::StoreValueToMemory(const GenericValue &Val, 865db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner GenericValue *Ptr, Type *Ty) { 8663574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmow const unsigned StoreBytes = getDataLayout()->getTypeStoreSize(Ty); 8671eff70451fbb079c1d5b8f45ff8c8a2b8f74d7baDuncan Sands 8688a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands switch (Ty->getTypeID()) { 8698a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands case Type::IntegerTyID: 8708a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands StoreIntToMemory(Val.IntVal, (uint8_t*)Ptr, StoreBytes); 8718fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer break; 8728fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer case Type::FloatTyID: 8738fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer *((float*)Ptr) = Val.FloatVal; 8748fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer break; 8758fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer case Type::DoubleTyID: 8768fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer *((double*)Ptr) = Val.DoubleVal; 8778fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer break; 8781f8c564d7df985082d7e728330979781f384d0e9Dale Johannesen case Type::X86_FP80TyID: 8791f8c564d7df985082d7e728330979781f384d0e9Dale Johannesen memcpy(Ptr, Val.IntVal.getRawData(), 10); 8801f8c564d7df985082d7e728330979781f384d0e9Dale Johannesen break; 8818a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands case Type::PointerTyID: 8828a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands // Ensure 64 bit target pointers are fully initialized on 32 bit hosts. 8838a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands if (StoreBytes != sizeof(PointerTy)) 88480d9e072625bc49dab4fa2da6c21bdd202509ee3Chandler Carruth memset(&(Ptr->PointerVal), 0, StoreBytes); 8858a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands 8868fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer *((PointerTy*)Ptr) = Val.PointerVal; 8878fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer break; 8888fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer default: 889ae7c59a01286a3babbc6245dcb1049c7bcde2573David Greene dbgs() << "Cannot store value of type " << *Ty << "!\n"; 890bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner } 8918a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands 8923574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmow if (sys::isLittleEndianHost() != getDataLayout()->isLittleEndian()) 8938a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands // Host and target are different endian - reverse the stored bytes. 8948a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands std::reverse((uint8_t*)Ptr, StoreBytes + (uint8_t*)Ptr); 8958a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands} 8968a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands 8978a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands/// LoadIntFromMemory - Loads the integer stored in the LoadBytes bytes starting 8988a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands/// from Src into IntVal, which is assumed to be wide enough and to hold zero. 8998a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sandsstatic void LoadIntFromMemory(APInt &IntVal, uint8_t *Src, unsigned LoadBytes) { 9008a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands assert((IntVal.getBitWidth()+7)/8 >= LoadBytes && "Integer too small!"); 901c2680bef3b4994017d83293bc1337b26be54ac77David Greene uint8_t *Dst = reinterpret_cast<uint8_t *>( 902c2680bef3b4994017d83293bc1337b26be54ac77David Greene const_cast<uint64_t *>(IntVal.getRawData())); 9038a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands 904b67c95834226fc44c435ca97dc5a536bccb30bbfChris Lattner if (sys::isLittleEndianHost()) 9058a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands // Little-endian host - the destination must be ordered from LSB to MSB. 9068a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands // The source is ordered from LSB to MSB: Do a straight copy. 9078a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands memcpy(Dst, Src, LoadBytes); 9088a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands else { 9098a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands // Big-endian - the destination is an array of 64 bit words ordered from 9108a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands // LSW to MSW. Each word must be ordered from MSB to LSB. The source is 9118a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands // ordered from MSB to LSB: Reverse the word order, but not the bytes in 9128a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands // a word. 9138a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands while (LoadBytes > sizeof(uint64_t)) { 9148a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands LoadBytes -= sizeof(uint64_t); 9158a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands // May not be aligned so use memcpy. 9168a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands memcpy(Dst, Src + LoadBytes, sizeof(uint64_t)); 9178a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands Dst += sizeof(uint64_t); 9188a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands } 9198a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands 9208a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands memcpy(Dst + sizeof(uint64_t) - LoadBytes, Src, LoadBytes); 9218a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands } 922bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner} 923bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner 9244afac18fd4cae1b93907d7db03c5fdb7f2f66d64Misha Brukman/// FIXME: document 9254afac18fd4cae1b93907d7db03c5fdb7f2f66d64Misha Brukman/// 9268a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sandsvoid ExecutionEngine::LoadValueFromMemory(GenericValue &Result, 92708bfe26f5a06bf9b0d6f8d2ceb5cb991d0d61842Duncan Sands GenericValue *Ptr, 928db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty) { 9293574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmow const unsigned LoadBytes = getDataLayout()->getTypeStoreSize(Ty); 9308a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands 9318a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands switch (Ty->getTypeID()) { 9328a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands case Type::IntegerTyID: 9331eff70451fbb079c1d5b8f45ff8c8a2b8f74d7baDuncan Sands // An APInt with all words initially zero. 9348a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands Result.IntVal = APInt(cast<IntegerType>(Ty)->getBitWidth(), 0); 9358a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands LoadIntFromMemory(Result.IntVal, (uint8_t*)Ptr, LoadBytes); 9368fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer break; 9378fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer case Type::FloatTyID: 9388fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer Result.FloatVal = *((float*)Ptr); 9398fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer break; 9408fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer case Type::DoubleTyID: 9418a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands Result.DoubleVal = *((double*)Ptr); 9428fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer break; 9438a43e9e5d751ab827ba3ff0cf862787d3263a484Duncan Sands case Type::PointerTyID: 9448fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer Result.PointerVal = *((PointerTy*)Ptr); 9458fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer break; 9461abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen case Type::X86_FP80TyID: { 9471abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen // This is endian dependent, but it will only work on x86 anyway. 9489e4635a5b8f56db607df2aca9cae1fc8d5a8bd36Duncan Sands // FIXME: Will not trap if loading a signaling NaN. 9491f8c564d7df985082d7e728330979781f384d0e9Dale Johannesen uint64_t y[2]; 9501f8c564d7df985082d7e728330979781f384d0e9Dale Johannesen memcpy(y, Ptr, 10); 9513ba292dbc2acee2d1052fb7ffe332e2164147b47Jeffrey Yasskin Result.IntVal = APInt(80, y); 9521abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen break; 9531abac0d725374cb6e527d2a735a5272a4f7913faDale Johannesen } 9548fb0f190a90f34b9d94d027ed8daf5f537e4b891Reid Spencer default: 95548dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar SmallString<256> Msg; 95648dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar raw_svector_ostream OS(Msg); 95748dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar OS << "Cannot load value of type " << *Ty << "!"; 95848dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar report_fatal_error(OS.str()); 959f88b9a639770327196b2a00f365155b954dd1d30Chris Lattner } 960f88b9a639770327196b2a00f365155b954dd1d30Chris Lattner} 961f88b9a639770327196b2a00f365155b954dd1d30Chris Lattner 962bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattnervoid ExecutionEngine::InitializeMemory(const Constant *Init, void *Addr) { 963ae7c59a01286a3babbc6245dcb1049c7bcde2573David Greene DEBUG(dbgs() << "JIT: Initializing " << Addr << " "); 964dd947ea3c5e020c33c58a31939561265b980a3adDale Johannesen DEBUG(Init->dump()); 9651ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner if (isa<UndefValue>(Init)) 966bd1d382cc47dfc43ee758714bc22ab5a750bad15Chris Lattner return; 9671ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner 9681ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner if (const ConstantVector *CP = dyn_cast<ConstantVector>(Init)) { 9697c2b7c7c75a3549b2d6933edf3110294a33ff2d4Robert Bocchino unsigned ElementSize = 9703574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmow getDataLayout()->getTypeAllocSize(CP->getType()->getElementType()); 9717c2b7c7c75a3549b2d6933edf3110294a33ff2d4Robert Bocchino for (unsigned i = 0, e = CP->getNumOperands(); i != e; ++i) 9727c2b7c7c75a3549b2d6933edf3110294a33ff2d4Robert Bocchino InitializeMemory(CP->getOperand(i), (char*)Addr+i*ElementSize); 9737c2b7c7c75a3549b2d6933edf3110294a33ff2d4Robert Bocchino return; 9741ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner } 9751ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner 9761ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner if (isa<ConstantAggregateZero>(Init)) { 9773574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmow memset(Addr, 0, (size_t)getDataLayout()->getTypeAllocSize(Init->getType())); 978b6e1dd70750d9b761779a00512e69c64a06ddfdeChris Lattner return; 9791ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner } 9801ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner 9811ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner if (const ConstantArray *CPA = dyn_cast<ConstantArray>(Init)) { 982edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman unsigned ElementSize = 9833574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmow getDataLayout()->getTypeAllocSize(CPA->getType()->getElementType()); 98415876bb28c9c0983279c30a123c13224648574c1Alkis Evlogimenos for (unsigned i = 0, e = CPA->getNumOperands(); i != e; ++i) 98515876bb28c9c0983279c30a123c13224648574c1Alkis Evlogimenos InitializeMemory(CPA->getOperand(i), (char*)Addr+i*ElementSize); 986bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner return; 9871ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner } 9881ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner 9891ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner if (const ConstantStruct *CPS = dyn_cast<ConstantStruct>(Init)) { 990bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner const StructLayout *SL = 9913574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmow getDataLayout()->getStructLayout(cast<StructType>(CPS->getType())); 99215876bb28c9c0983279c30a123c13224648574c1Alkis Evlogimenos for (unsigned i = 0, e = CPS->getNumOperands(); i != e; ++i) 993b1919e2f08ecb37140af676fd2916f8d5ed7df3dChris Lattner InitializeMemory(CPS->getOperand(i), (char*)Addr+SL->getElementOffset(i)); 994bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner return; 9951ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner } 9961ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner 9971ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner if (const ConstantDataSequential *CDS = 9981ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner dyn_cast<ConstantDataSequential>(Init)) { 9991ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner // CDS is already laid out in host memory order. 10001ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner StringRef Data = CDS->getRawDataValues(); 10011ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner memcpy(Addr, Data.data(), Data.size()); 10021ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner return; 10031ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner } 10041ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner 10051ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner if (Init->getType()->isFirstClassType()) { 1006638e378f2cb62c34f306f8eadd43039e20caede4Dan Gohman GenericValue Val = getConstantValue(Init); 1007638e378f2cb62c34f306f8eadd43039e20caede4Dan Gohman StoreValueToMemory(Val, (GenericValue*)Addr, Init->getType()); 1008638e378f2cb62c34f306f8eadd43039e20caede4Dan Gohman return; 1009bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner } 1010bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner 101148dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar DEBUG(dbgs() << "Bad Type: " << *Init->getType() << "\n"); 1012c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable("Unknown constant type to initialize memory with!"); 1013bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner} 1014bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner 1015bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner/// EmitGlobals - Emit all of the global variables to memory, storing their 1016bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner/// addresses into GlobalAddress. This must make sure to copy the contents of 1017bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner/// their initializers into the memory. 1018bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattnervoid ExecutionEngine::emitGlobals() { 1019bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner // Loop over all of the global variables in the program, allocating the memory 1020fe854034677f59baca1e38075e71f6efca247a03Chris Lattner // to hold them. If there is more than one module, do a prepass over globals 1021fe854034677f59baca1e38075e71f6efca247a03Chris Lattner // to figure out how the different modules should link together. 1022db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner std::map<std::pair<std::string, Type*>, 1023fe854034677f59baca1e38075e71f6efca247a03Chris Lattner const GlobalValue*> LinkedGlobalsMap; 1024fe854034677f59baca1e38075e71f6efca247a03Chris Lattner 1025fe854034677f59baca1e38075e71f6efca247a03Chris Lattner if (Modules.size() != 1) { 1026fe854034677f59baca1e38075e71f6efca247a03Chris Lattner for (unsigned m = 0, e = Modules.size(); m != e; ++m) { 1027f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin Module &M = *Modules[m]; 1028fe854034677f59baca1e38075e71f6efca247a03Chris Lattner for (Module::const_global_iterator I = M.global_begin(), 1029fe854034677f59baca1e38075e71f6efca247a03Chris Lattner E = M.global_end(); I != E; ++I) { 1030fe854034677f59baca1e38075e71f6efca247a03Chris Lattner const GlobalValue *GV = I; 1031bb46f52027416598a662dc1c58f48d9d56b1a65bRafael Espindola if (GV->hasLocalLinkage() || GV->isDeclaration() || 1032fe854034677f59baca1e38075e71f6efca247a03Chris Lattner GV->hasAppendingLinkage() || !GV->hasName()) 1033fe854034677f59baca1e38075e71f6efca247a03Chris Lattner continue;// Ignore external globals and globals with internal linkage. 103448dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar 103548dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar const GlobalValue *&GVEntry = 1036fe854034677f59baca1e38075e71f6efca247a03Chris Lattner LinkedGlobalsMap[std::make_pair(GV->getName(), GV->getType())]; 1037fe854034677f59baca1e38075e71f6efca247a03Chris Lattner 1038fe854034677f59baca1e38075e71f6efca247a03Chris Lattner // If this is the first time we've seen this global, it is the canonical 1039fe854034677f59baca1e38075e71f6efca247a03Chris Lattner // version. 1040fe854034677f59baca1e38075e71f6efca247a03Chris Lattner if (!GVEntry) { 1041fe854034677f59baca1e38075e71f6efca247a03Chris Lattner GVEntry = GV; 1042fe854034677f59baca1e38075e71f6efca247a03Chris Lattner continue; 1043fe854034677f59baca1e38075e71f6efca247a03Chris Lattner } 104448dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar 1045fe854034677f59baca1e38075e71f6efca247a03Chris Lattner // If the existing global is strong, never replace it. 1046b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov if (GVEntry->hasExternalLinkage() || 1047b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov GVEntry->hasDLLImportLinkage() || 1048b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov GVEntry->hasDLLExportLinkage()) 1049fe854034677f59baca1e38075e71f6efca247a03Chris Lattner continue; 105048dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar 1051fe854034677f59baca1e38075e71f6efca247a03Chris Lattner // Otherwise, we know it's linkonce/weak, replace it if this is a strong 1052aafce77b17d340aace52bcd49d1944109d82f14aDale Johannesen // symbol. FIXME is this right for common? 105378ee7b78c3c47b71c4b7a1475438d6574216a64bAnton Korobeynikov if (GV->hasExternalLinkage() || GVEntry->hasExternalWeakLinkage()) 1054fe854034677f59baca1e38075e71f6efca247a03Chris Lattner GVEntry = GV; 1055d8c03bfa0a8cbcbf3ee31b0e9b52126c9dbafe2aChris Lattner } 1056bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner } 1057fe854034677f59baca1e38075e71f6efca247a03Chris Lattner } 105848dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar 1059fe854034677f59baca1e38075e71f6efca247a03Chris Lattner std::vector<const GlobalValue*> NonCanonicalGlobals; 1060fe854034677f59baca1e38075e71f6efca247a03Chris Lattner for (unsigned m = 0, e = Modules.size(); m != e; ++m) { 1061f0356fe140af1a30587b9a86bcfb1b2c51b8ce20Jeffrey Yasskin Module &M = *Modules[m]; 1062fe854034677f59baca1e38075e71f6efca247a03Chris Lattner for (Module::const_global_iterator I = M.global_begin(), E = M.global_end(); 1063fe854034677f59baca1e38075e71f6efca247a03Chris Lattner I != E; ++I) { 1064fe854034677f59baca1e38075e71f6efca247a03Chris Lattner // In the multi-module case, see what this global maps to. 1065fe854034677f59baca1e38075e71f6efca247a03Chris Lattner if (!LinkedGlobalsMap.empty()) { 106648dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar if (const GlobalValue *GVEntry = 1067fe854034677f59baca1e38075e71f6efca247a03Chris Lattner LinkedGlobalsMap[std::make_pair(I->getName(), I->getType())]) { 1068fe854034677f59baca1e38075e71f6efca247a03Chris Lattner // If something else is the canonical global, ignore this one. 1069fe854034677f59baca1e38075e71f6efca247a03Chris Lattner if (GVEntry != &*I) { 1070fe854034677f59baca1e38075e71f6efca247a03Chris Lattner NonCanonicalGlobals.push_back(I); 1071fe854034677f59baca1e38075e71f6efca247a03Chris Lattner continue; 1072fe854034677f59baca1e38075e71f6efca247a03Chris Lattner } 1073fe854034677f59baca1e38075e71f6efca247a03Chris Lattner } 1074fe854034677f59baca1e38075e71f6efca247a03Chris Lattner } 107548dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar 10765cbf985dcbc89fba3208e7baf8b6f488b06d3ec9Reid Spencer if (!I->isDeclaration()) { 107746fa139e26be6ebc00be2fb45820c2560dd22a32Nicolas Geoffray addGlobalMapping(I, getMemoryForGV(I)); 1078fe854034677f59baca1e38075e71f6efca247a03Chris Lattner } else { 1079fe854034677f59baca1e38075e71f6efca247a03Chris Lattner // External variable reference. Try to use the dynamic loader to 1080fe854034677f59baca1e38075e71f6efca247a03Chris Lattner // get a pointer to it. 1081fe854034677f59baca1e38075e71f6efca247a03Chris Lattner if (void *SymAddr = 1082fbee579ed46016166d88b4defb81a2e7e253062dDaniel Dunbar sys::DynamicLibrary::SearchForAddressOfSymbol(I->getName())) 1083fe854034677f59baca1e38075e71f6efca247a03Chris Lattner addGlobalMapping(I, SymAddr); 1084fe854034677f59baca1e38075e71f6efca247a03Chris Lattner else { 108575361b69f3f327842b9dad69fa7f28ae3b688412Chris Lattner report_fatal_error("Could not resolve external global address: " 108631e2466f159a887fed9139067a676f65adf2a8c3Torok Edwin +I->getName()); 1087fe854034677f59baca1e38075e71f6efca247a03Chris Lattner } 1088fe854034677f59baca1e38075e71f6efca247a03Chris Lattner } 1089fe854034677f59baca1e38075e71f6efca247a03Chris Lattner } 109048dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar 1091fe854034677f59baca1e38075e71f6efca247a03Chris Lattner // If there are multiple modules, map the non-canonical globals to their 1092fe854034677f59baca1e38075e71f6efca247a03Chris Lattner // canonical location. 1093fe854034677f59baca1e38075e71f6efca247a03Chris Lattner if (!NonCanonicalGlobals.empty()) { 1094fe854034677f59baca1e38075e71f6efca247a03Chris Lattner for (unsigned i = 0, e = NonCanonicalGlobals.size(); i != e; ++i) { 1095fe854034677f59baca1e38075e71f6efca247a03Chris Lattner const GlobalValue *GV = NonCanonicalGlobals[i]; 1096fe854034677f59baca1e38075e71f6efca247a03Chris Lattner const GlobalValue *CGV = 1097fe854034677f59baca1e38075e71f6efca247a03Chris Lattner LinkedGlobalsMap[std::make_pair(GV->getName(), GV->getType())]; 1098fe854034677f59baca1e38075e71f6efca247a03Chris Lattner void *Ptr = getPointerToGlobalIfAvailable(CGV); 1099fe854034677f59baca1e38075e71f6efca247a03Chris Lattner assert(Ptr && "Canonical global wasn't codegen'd!"); 1100c8ed902298b79e8a740e4f707f13089cf5ce1295Nuno Lopes addGlobalMapping(GV, Ptr); 1101fe854034677f59baca1e38075e71f6efca247a03Chris Lattner } 1102fe854034677f59baca1e38075e71f6efca247a03Chris Lattner } 110348dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar 110448dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar // Now that all of the globals are set up in memory, loop through them all 1105a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer // and initialize their contents. 1106fe854034677f59baca1e38075e71f6efca247a03Chris Lattner for (Module::const_global_iterator I = M.global_begin(), E = M.global_end(); 1107fe854034677f59baca1e38075e71f6efca247a03Chris Lattner I != E; ++I) { 11085cbf985dcbc89fba3208e7baf8b6f488b06d3ec9Reid Spencer if (!I->isDeclaration()) { 1109fe854034677f59baca1e38075e71f6efca247a03Chris Lattner if (!LinkedGlobalsMap.empty()) { 111048dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar if (const GlobalValue *GVEntry = 1111fe854034677f59baca1e38075e71f6efca247a03Chris Lattner LinkedGlobalsMap[std::make_pair(I->getName(), I->getType())]) 1112fe854034677f59baca1e38075e71f6efca247a03Chris Lattner if (GVEntry != &*I) // Not the canonical variable. 1113fe854034677f59baca1e38075e71f6efca247a03Chris Lattner continue; 1114fe854034677f59baca1e38075e71f6efca247a03Chris Lattner } 1115fe854034677f59baca1e38075e71f6efca247a03Chris Lattner EmitGlobalVariable(I); 1116fe854034677f59baca1e38075e71f6efca247a03Chris Lattner } 1117fe854034677f59baca1e38075e71f6efca247a03Chris Lattner } 1118fe854034677f59baca1e38075e71f6efca247a03Chris Lattner } 111924b0a18c4357de0515c542e97edb2c2eacc543f2Chris Lattner} 112024b0a18c4357de0515c542e97edb2c2eacc543f2Chris Lattner 112124b0a18c4357de0515c542e97edb2c2eacc543f2Chris Lattner// EmitGlobalVariable - This method emits the specified global variable to the 112224b0a18c4357de0515c542e97edb2c2eacc543f2Chris Lattner// address specified in GlobalAddresses, or allocates new memory if it's not 112324b0a18c4357de0515c542e97edb2c2eacc543f2Chris Lattner// already in the map. 1124c07ed1387503d25c0b93fcf617f69329d73fc589Chris Lattnervoid ExecutionEngine::EmitGlobalVariable(const GlobalVariable *GV) { 112555d86482bd9fac6f90a7f6fb35c2f4dec9569fdbChris Lattner void *GA = getPointerToGlobalIfAvailable(GV); 112623c472436940aa7fc82ff99e8cca6788d08a8105Chris Lattner 112724b0a18c4357de0515c542e97edb2c2eacc543f2Chris Lattner if (GA == 0) { 112824b0a18c4357de0515c542e97edb2c2eacc543f2Chris Lattner // If it's not already specified, allocate memory for the global. 112946fa139e26be6ebc00be2fb45820c2560dd22a32Nicolas Geoffray GA = getMemoryForGV(GV); 113055d86482bd9fac6f90a7f6fb35c2f4dec9569fdbChris Lattner addGlobalMapping(GV, GA); 113124b0a18c4357de0515c542e97edb2c2eacc543f2Chris Lattner } 113248dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar 113346fa139e26be6ebc00be2fb45820c2560dd22a32Nicolas Geoffray // Don't initialize if it's thread local, let the client do it. 113446fa139e26be6ebc00be2fb45820c2560dd22a32Nicolas Geoffray if (!GV->isThreadLocal()) 113546fa139e26be6ebc00be2fb45820c2560dd22a32Nicolas Geoffray InitializeMemory(GV->getInitializer(), GA); 113648dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar 1137db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *ElTy = GV->getType()->getElementType(); 11383574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmow size_t GVSize = (size_t)getDataLayout()->getTypeAllocSize(ElTy); 1139813c8152825db530a6ef4ee86e8038bbee16deb3Chris Lattner NumInitBytes += (unsigned)GVSize; 114024b0a18c4357de0515c542e97edb2c2eacc543f2Chris Lattner ++NumGlobals; 1141bd199fb1148b9e16c4e6f3d0ee386c2505a55b71Chris Lattner} 11424c5b23b24f230607fa18a162519875a91a5e89e0Jeffrey Yasskin 114323e5fcfec4640955fec41dc8348f467adf1a3e56Jeffrey YasskinExecutionEngineState::ExecutionEngineState(ExecutionEngine &EE) 114423e5fcfec4640955fec41dc8348f467adf1a3e56Jeffrey Yasskin : EE(EE), GlobalAddressMap(this) { 114523e5fcfec4640955fec41dc8348f467adf1a3e56Jeffrey Yasskin} 11464c5b23b24f230607fa18a162519875a91a5e89e0Jeffrey Yasskin 114748dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbarsys::Mutex * 114848dd875be12006060260526e4a1df0bae48dd5c9Daniel DunbarExecutionEngineState::AddressMapConfig::getMutex(ExecutionEngineState *EES) { 114923e5fcfec4640955fec41dc8348f467adf1a3e56Jeffrey Yasskin return &EES->EE.lock; 115023e5fcfec4640955fec41dc8348f467adf1a3e56Jeffrey Yasskin} 115148dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar 115248dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbarvoid ExecutionEngineState::AddressMapConfig::onDelete(ExecutionEngineState *EES, 115348dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar const GlobalValue *Old) { 115423e5fcfec4640955fec41dc8348f467adf1a3e56Jeffrey Yasskin void *OldVal = EES->GlobalAddressMap.lookup(Old); 115523e5fcfec4640955fec41dc8348f467adf1a3e56Jeffrey Yasskin EES->GlobalAddressReverseMap.erase(OldVal); 11564c5b23b24f230607fa18a162519875a91a5e89e0Jeffrey Yasskin} 11574c5b23b24f230607fa18a162519875a91a5e89e0Jeffrey Yasskin 115848dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbarvoid ExecutionEngineState::AddressMapConfig::onRAUW(ExecutionEngineState *, 115948dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar const GlobalValue *, 116048dd875be12006060260526e4a1df0bae48dd5c9Daniel Dunbar const GlobalValue *) { 1161858143816d43e58b17bfd11cb1b57afbd7f0f893Craig Topper llvm_unreachable("The ExecutionEngine doesn't know how to handle a" 1162858143816d43e58b17bfd11cb1b57afbd7f0f893Craig Topper " RAUW on a value it has a global mapping for."); 11634c5b23b24f230607fa18a162519875a91a5e89e0Jeffrey Yasskin} 1164