lib/ExecutionEngine/JIT/JITEmitter.cpp

   1 //===-- JITEmitter.cpp - Write machine code to executable memory ----------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file defines a MachineCodeEmitter object that is used by the JIT to
  11 // write machine code to memory and remember where relocatable values are.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #define DEBUG_TYPE "jit"
  16 #include "JIT.h"
  17 #include "JITDwarfEmitter.h"
  18 #include "llvm/Constants.h"
  19 #include "llvm/Module.h"
  20 #include "llvm/DerivedTypes.h"
  21 #include "llvm/CodeGen/JITCodeEmitter.h"
  22 #include "llvm/CodeGen/MachineFunction.h"
  23 #include "llvm/CodeGen/MachineConstantPool.h"
  24 #include "llvm/CodeGen/MachineJumpTableInfo.h"
  25 #include "llvm/CodeGen/MachineModuleInfo.h"
  26 #include "llvm/CodeGen/MachineRelocation.h"
  27 #include "llvm/ExecutionEngine/GenericValue.h"
  28 #include "llvm/ExecutionEngine/JITEventListener.h"
  29 #include "llvm/ExecutionEngine/JITMemoryManager.h"
  30 #include "llvm/CodeGen/MachineCodeInfo.h"
  31 #include "llvm/Target/TargetData.h"
  32 #include "llvm/Target/TargetJITInfo.h"
  33 #include "llvm/Target/TargetMachine.h"
  34 #include "llvm/Target/TargetOptions.h"
  35 #include "llvm/Support/Debug.h"
  36 #include "llvm/Support/ErrorHandling.h"
  37 #include "llvm/Support/MutexGuard.h"
  38 #include "llvm/Support/ValueHandle.h"
  39 #include "llvm/Support/raw_ostream.h"
  40 #include "llvm/System/Disassembler.h"
  41 #include "llvm/System/Memory.h"
  42 #include "llvm/Target/TargetInstrInfo.h"
  43 #include "llvm/ADT/SmallPtrSet.h"
  44 #include "llvm/ADT/SmallVector.h"
  45 #include "llvm/ADT/Statistic.h"
  46 #include <algorithm>
  47 #ifndef NDEBUG
  48 #include <iomanip>
  49 #endif
  50 using namespace llvm;
  51
  52 STATISTIC(NumBytes, "Number of bytes of machine code compiled");
  53 STATISTIC(NumRelos, "Number of relocations applied");
  54 STATISTIC(NumRetries, "Number of retries with more memory");
  55 static JIT *TheJIT = 0;
  56
  57
  58 //===----------------------------------------------------------------------===//
  59 // JIT lazy compilation code.
  60 //
  61 namespace {
  62   class JITResolverState {
  63   public:
  64     typedef std::map<AssertingVH<Function>, void*> FunctionToStubMapTy;
  65     typedef std::map<void*, Function*> StubToFunctionMapTy;
  66     typedef std::map<AssertingVH<GlobalValue>, void*> GlobalToIndirectSymMapTy;
  67   private:
  68     /// FunctionToStubMap - Keep track of the stub created for a particular
  69     /// function so that we can reuse them if necessary.
  70     FunctionToStubMapTy FunctionToStubMap;
  71
  72     /// StubToFunctionMap - Keep track of the function that each stub
  73     /// corresponds to.
  74     StubToFunctionMapTy StubToFunctionMap;
  75
  76     /// GlobalToIndirectSymMap - Keep track of the indirect symbol created for a
  77     /// particular GlobalVariable so that we can reuse them if necessary.
  78     GlobalToIndirectSymMapTy GlobalToIndirectSymMap;
  79
  80   public:
  81     FunctionToStubMapTy& getFunctionToStubMap(const MutexGuard& locked) {
  82       assert(locked.holds(TheJIT->lock));
  83       return FunctionToStubMap;
  84     }
  85
  86     StubToFunctionMapTy& getStubToFunctionMap(const MutexGuard& locked) {
  87       assert(locked.holds(TheJIT->lock));
  88       return StubToFunctionMap;
  89     }
  90
  91     GlobalToIndirectSymMapTy& getGlobalToIndirectSymMap(const MutexGuard& locked) {
  92       assert(locked.holds(TheJIT->lock));
  93       return GlobalToIndirectSymMap;
  94     }
  95   };
  96
  97   /// JITResolver - Keep track of, and resolve, call sites for functions that
  98   /// have not yet been compiled.
  99   class JITResolver {
 100     typedef JITResolverState::FunctionToStubMapTy FunctionToStubMapTy;
 101     typedef JITResolverState::StubToFunctionMapTy StubToFunctionMapTy;
 102     typedef JITResolverState::GlobalToIndirectSymMapTy GlobalToIndirectSymMapTy;
 103
 104     /// LazyResolverFn - The target lazy resolver function that we actually
 105     /// rewrite instructions to use.
 106     TargetJITInfo::LazyResolverFn LazyResolverFn;
 107
 108     JITResolverState state;
 109
 110     /// ExternalFnToStubMap - This is the equivalent of FunctionToStubMap for
 111     /// external functions.
 112     std::map<void*, void*> ExternalFnToStubMap;
 113
 114     /// revGOTMap - map addresses to indexes in the GOT
 115     std::map<void*, unsigned> revGOTMap;
 116     unsigned nextGOTIndex;
 117
 118     static JITResolver *TheJITResolver;
 119   public:
 120     explicit JITResolver(JIT &jit) : nextGOTIndex(0) {
 121       TheJIT = &jit;
 122
 123       LazyResolverFn = jit.getJITInfo().getLazyResolverFunction(JITCompilerFn);
 124       assert(TheJITResolver == 0 && "Multiple JIT resolvers?");
 125       TheJITResolver = this;
 126     }
 127
 128     ~JITResolver() {
 129       TheJITResolver = 0;
 130     }
 131
 132     /// getFunctionStubIfAvailable - This returns a pointer to a function stub
 133     /// if it has already been created.
 134     void *getFunctionStubIfAvailable(Function *F);
 135
 136     /// getFunctionStub - This returns a pointer to a function stub, creating
 137     /// one on demand as needed.  If empty is true, create a function stub
 138     /// pointing at address 0, to be filled in later.
 139     void *getFunctionStub(Function *F);
 140
 141     /// getExternalFunctionStub - Return a stub for the function at the
 142     /// specified address, created lazily on demand.
 143     void *getExternalFunctionStub(void *FnAddr);
 144
 145     /// getGlobalValueIndirectSym - Return an indirect symbol containing the
 146     /// specified GV address.
 147     void *getGlobalValueIndirectSym(GlobalValue *V, void *GVAddress);
 148
 149     /// AddCallbackAtLocation - If the target is capable of rewriting an
 150     /// instruction without the use of a stub, record the location of the use so
 151     /// we know which function is being used at the location.
 152     void *AddCallbackAtLocation(Function *F, void *Location) {
 153       MutexGuard locked(TheJIT->lock);
 154       /// Get the target-specific JIT resolver function.
 155       state.getStubToFunctionMap(locked)[Location] = F;
 156       return (void*)(intptr_t)LazyResolverFn;
 157     }
 158
 159     void getRelocatableGVs(SmallVectorImpl<GlobalValue*> &GVs,
 160                            SmallVectorImpl<void*> &Ptrs);
 161
 162     GlobalValue *invalidateStub(void *Stub);
 163
 164     /// getGOTIndexForAddress - Return a new or existing index in the GOT for
 165     /// an address.  This function only manages slots, it does not manage the
 166     /// contents of the slots or the memory associated with the GOT.
 167     unsigned getGOTIndexForAddr(void *addr);
 168
 169     /// JITCompilerFn - This function is called to resolve a stub to a compiled
 170     /// address.  If the LLVM Function corresponding to the stub has not yet
 171     /// been compiled, this function compiles it first.
 172     static void *JITCompilerFn(void *Stub);
 173   };
 174 }
 175
 176 JITResolver *JITResolver::TheJITResolver = 0;
 177
 178 /// getFunctionStubIfAvailable - This returns a pointer to a function stub
 179 /// if it has already been created.
 180 void *JITResolver::getFunctionStubIfAvailable(Function *F) {
 181   MutexGuard locked(TheJIT->lock);
 182
 183   // If we already have a stub for this function, recycle it.
 184   void *&Stub = state.getFunctionToStubMap(locked)[F];
 185   return Stub;
 186 }
 187
 188 /// getFunctionStub - This returns a pointer to a function stub, creating
 189 /// one on demand as needed.
 190 void *JITResolver::getFunctionStub(Function *F) {
 191   MutexGuard locked(TheJIT->lock);
 192
 193   // If we already have a stub for this function, recycle it.
 194   void *&Stub = state.getFunctionToStubMap(locked)[F];
 195   if (Stub) return Stub;
 196
 197   // Call the lazy resolver function unless we are JIT'ing non-lazily, in which
 198   // case we must resolve the symbol now.
 199   void *Actual =  TheJIT->isLazyCompilationDisabled()
 200     ? (void *)0 : (void *)(intptr_t)LazyResolverFn;
 201
 202   // If this is an external declaration, attempt to resolve the address now
 203   // to place in the stub.
 204   if (F->isDeclaration() && !F->hasNotBeenReadFromBitcode()) {
 205     Actual = TheJIT->getPointerToFunction(F);
 206
 207     // If we resolved the symbol to a null address (eg. a weak external)
 208     // don't emit a stub. Return a null pointer to the application.  If dlsym
 209     // stubs are enabled, not being able to resolve the address is not
 210     // meaningful.
 211     if (!Actual && !TheJIT->areDlsymStubsEnabled()) return 0;
 212   }
 213
 214   // Codegen a new stub, calling the lazy resolver or the actual address of the
 215   // external function, if it was resolved.
 216   Stub = TheJIT->getJITInfo().emitFunctionStub(F, Actual,
 217                                                *TheJIT->getCodeEmitter());
 218
 219   if (Actual != (void*)(intptr_t)LazyResolverFn) {
 220     // If we are getting the stub for an external function, we really want the
 221     // address of the stub in the GlobalAddressMap for the JIT, not the address
 222     // of the external function.
 223     TheJIT->updateGlobalMapping(F, Stub);
 224   }
 225
 226   DEBUG(errs() << "JIT: Stub emitted at [" << Stub << "] for function '"
 227         << F->getName() << "'\n");
 228
 229   // Finally, keep track of the stub-to-Function mapping so that the
 230   // JITCompilerFn knows which function to compile!
 231   state.getStubToFunctionMap(locked)[Stub] = F;
 232
 233   // If we are JIT'ing non-lazily but need to call a function that does not
 234   // exist yet, add it to the JIT's work list so that we can fill in the stub
 235   // address later.
 236   if (!Actual && TheJIT->isLazyCompilationDisabled())
 237     if (!F->isDeclaration() || F->hasNotBeenReadFromBitcode())
 238       TheJIT->addPendingFunction(F);
 239
 240   return Stub;
 241 }
 242
 243 /// getGlobalValueIndirectSym - Return a lazy pointer containing the specified
 244 /// GV address.
 245 void *JITResolver::getGlobalValueIndirectSym(GlobalValue *GV, void *GVAddress) {
 246   MutexGuard locked(TheJIT->lock);
 247
 248   // If we already have a stub for this global variable, recycle it.
 249   void *&IndirectSym = state.getGlobalToIndirectSymMap(locked)[GV];
 250   if (IndirectSym) return IndirectSym;
 251
 252   // Otherwise, codegen a new indirect symbol.
 253   IndirectSym = TheJIT->getJITInfo().emitGlobalValueIndirectSym(GV, GVAddress,
 254                                                      *TheJIT->getCodeEmitter());
 255
 256   DEBUG(errs() << "JIT: Indirect symbol emitted at [" << IndirectSym
 257         << "] for GV '" << GV->getName() << "'\n");
 258
 259   return IndirectSym;
 260 }
 261
 262 /// getExternalFunctionStub - Return a stub for the function at the
 263 /// specified address, created lazily on demand.
 264 void *JITResolver::getExternalFunctionStub(void *FnAddr) {
 265   // If we already have a stub for this function, recycle it.
 266   void *&Stub = ExternalFnToStubMap[FnAddr];
 267   if (Stub) return Stub;
 268
 269   Stub = TheJIT->getJITInfo().emitFunctionStub(0, FnAddr,
 270                                                *TheJIT->getCodeEmitter());
 271
 272   DEBUG(errs() << "JIT: Stub emitted at [" << Stub
 273                << "] for external function at '" << FnAddr << "'\n");
 274   return Stub;
 275 }
 276
 277 unsigned JITResolver::getGOTIndexForAddr(void* addr) {
 278   unsigned idx = revGOTMap[addr];
 279   if (!idx) {
 280     idx = ++nextGOTIndex;
 281     revGOTMap[addr] = idx;
 282     DEBUG(errs() << "JIT: Adding GOT entry " << idx << " for addr ["
 283                  << addr << "]\n");
 284   }
 285   return idx;
 286 }
 287
 288 void JITResolver::getRelocatableGVs(SmallVectorImpl<GlobalValue*> &GVs,
 289                                     SmallVectorImpl<void*> &Ptrs) {
 290   MutexGuard locked(TheJIT->lock);
 291
 292   FunctionToStubMapTy &FM = state.getFunctionToStubMap(locked);
 293   GlobalToIndirectSymMapTy &GM = state.getGlobalToIndirectSymMap(locked);
 294
 295   for (FunctionToStubMapTy::iterator i = FM.begin(), e = FM.end(); i != e; ++i){
 296     Function *F = i->first;
 297     if (F->isDeclaration() && F->hasExternalLinkage()) {
 298       GVs.push_back(i->first);
 299       Ptrs.push_back(i->second);
 300     }
 301   }
 302   for (GlobalToIndirectSymMapTy::iterator i = GM.begin(), e = GM.end();
 303        i != e; ++i) {
 304     GVs.push_back(i->first);
 305     Ptrs.push_back(i->second);
 306   }
 307 }
 308
 309 GlobalValue *JITResolver::invalidateStub(void *Stub) {
 310   MutexGuard locked(TheJIT->lock);
 311
 312   FunctionToStubMapTy &FM = state.getFunctionToStubMap(locked);
 313   StubToFunctionMapTy &SM = state.getStubToFunctionMap(locked);
 314   GlobalToIndirectSymMapTy &GM = state.getGlobalToIndirectSymMap(locked);
 315
 316   // Look up the cheap way first, to see if it's a function stub we are
 317   // invalidating.  If so, remove it from both the forward and reverse maps.
 318   if (SM.find(Stub) != SM.end()) {
 319     Function *F = SM[Stub];
 320     SM.erase(Stub);
 321     FM.erase(F);
 322     return F;
 323   }
 324
 325   // Otherwise, it might be an indirect symbol stub.  Find it and remove it.
 326   for (GlobalToIndirectSymMapTy::iterator i = GM.begin(), e = GM.end();
 327        i != e; ++i) {
 328     if (i->second != Stub)
 329       continue;
 330     GlobalValue *GV = i->first;
 331     GM.erase(i);
 332     return GV;
 333   }
 334
 335   // Lastly, check to see if it's in the ExternalFnToStubMap.
 336   for (std::map<void *, void *>::iterator i = ExternalFnToStubMap.begin(),
 337        e = ExternalFnToStubMap.end(); i != e; ++i) {
 338     if (i->second != Stub)
 339       continue;
 340     ExternalFnToStubMap.erase(i);
 341     break;
 342   }
 343
 344   return 0;
 345 }
 346
 347 /// JITCompilerFn - This function is called when a lazy compilation stub has
 348 /// been entered.  It looks up which function this stub corresponds to, compiles
 349 /// it if necessary, then returns the resultant function pointer.
 350 void *JITResolver::JITCompilerFn(void *Stub) {
 351   JITResolver &JR = *TheJITResolver;
 352
 353   Function* F = 0;
 354   void* ActualPtr = 0;
 355
 356   {
 357     // Only lock for getting the Function. The call getPointerToFunction made
 358     // in this function might trigger function materializing, which requires
 359     // JIT lock to be unlocked.
 360     MutexGuard locked(TheJIT->lock);
 361
 362     // The address given to us for the stub may not be exactly right, it might be
 363     // a little bit after the stub.  As such, use upper_bound to find it.
 364     StubToFunctionMapTy::iterator I =
 365       JR.state.getStubToFunctionMap(locked).upper_bound(Stub);
 366     assert(I != JR.state.getStubToFunctionMap(locked).begin() &&
 367            "This is not a known stub!");
 368     F = (--I)->second;
 369     ActualPtr = I->first;
 370   }
 371
 372   // If we have already code generated the function, just return the address.
 373   void *Result = TheJIT->getPointerToGlobalIfAvailable(F);
 374
 375   if (!Result) {
 376     // Otherwise we don't have it, do lazy compilation now.
 377
 378     // If lazy compilation is disabled, emit a useful error message and abort.
 379     if (TheJIT->isLazyCompilationDisabled()) {
 380       llvm_report_error("LLVM JIT requested to do lazy compilation of function '"
 381                         + F->getName() + "' when lazy compiles are disabled!");
 382     }
 383
 384     // We might like to remove the stub from the StubToFunction map.
 385     // We can't do that! Multiple threads could be stuck, waiting to acquire the
 386     // lock above. As soon as the 1st function finishes compiling the function,
 387     // the next one will be released, and needs to be able to find the function
 388     // it needs to call.
 389     //JR.state.getStubToFunctionMap(locked).erase(I);
 390
 391     DEBUG(errs() << "JIT: Lazily resolving function '" << F->getName()
 392           << "' In stub ptr = " << Stub << " actual ptr = "
 393           << ActualPtr << "\n");
 394
 395     Result = TheJIT->getPointerToFunction(F);
 396   }
 397
 398   // Reacquire the lock to erase the stub in the map.
 399   MutexGuard locked(TheJIT->lock);
 400
 401   // We don't need to reuse this stub in the future, as F is now compiled.
 402   JR.state.getFunctionToStubMap(locked).erase(F);
 403
 404   // FIXME: We could rewrite all references to this stub if we knew them.
 405
 406   // What we will do is set the compiled function address to map to the
 407   // same GOT entry as the stub so that later clients may update the GOT
 408   // if they see it still using the stub address.
 409   // Note: this is done so the Resolver doesn't have to manage GOT memory
 410   // Do this without allocating map space if the target isn't using a GOT
 411   if(JR.revGOTMap.find(Stub) != JR.revGOTMap.end())
 412     JR.revGOTMap[Result] = JR.revGOTMap[Stub];
 413
 414   return Result;
 415 }
 416
 417 //===----------------------------------------------------------------------===//
 418 // JITEmitter code.
 419 //
 420 namespace {
 421   /// JITEmitter - The JIT implementation of the MachineCodeEmitter, which is
 422   /// used to output functions to memory for execution.
 423   class JITEmitter : public JITCodeEmitter {
 424     JITMemoryManager *MemMgr;
 425
 426     // When outputting a function stub in the context of some other function, we
 427     // save BufferBegin/BufferEnd/CurBufferPtr here.
 428     uint8_t *SavedBufferBegin, *SavedBufferEnd, *SavedCurBufferPtr;
 429
 430     // When reattempting to JIT a function after running out of space, we store
 431     // the estimated size of the function we're trying to JIT here, so we can
 432     // ask the memory manager for at least this much space.  When we
 433     // successfully emit the function, we reset this back to zero.
 434     uintptr_t SizeEstimate;
 435
 436     /// Relocations - These are the relocations that the function needs, as
 437     /// emitted.
 438     std::vector<MachineRelocation> Relocations;
 439
 440     /// MBBLocations - This vector is a mapping from MBB ID's to their address.
 441     /// It is filled in by the StartMachineBasicBlock callback and queried by
 442     /// the getMachineBasicBlockAddress callback.
 443     std::vector<uintptr_t> MBBLocations;
 444
 445     /// ConstantPool - The constant pool for the current function.
 446     ///
 447     MachineConstantPool *ConstantPool;
 448
 449     /// ConstantPoolBase - A pointer to the first entry in the constant pool.
 450     ///
 451     void *ConstantPoolBase;
 452
 453     /// ConstPoolAddresses - Addresses of individual constant pool entries.
 454     ///
 455     SmallVector<uintptr_t, 8> ConstPoolAddresses;
 456
 457     /// JumpTable - The jump tables for the current function.
 458     ///
 459     MachineJumpTableInfo *JumpTable;
 460
 461     /// JumpTableBase - A pointer to the first entry in the jump table.
 462     ///
 463     void *JumpTableBase;
 464
 465     /// Resolver - This contains info about the currently resolved functions.
 466     JITResolver Resolver;
 467
 468     /// DE - The dwarf emitter for the jit.
 469     JITDwarfEmitter *DE;
 470
 471     /// LabelLocations - This vector is a mapping from Label ID's to their
 472     /// address.
 473     std::vector<uintptr_t> LabelLocations;
 474
 475     /// MMI - Machine module info for exception informations
 476     MachineModuleInfo* MMI;
 477
 478     // GVSet - a set to keep track of which globals have been seen
 479     SmallPtrSet<const GlobalVariable*, 8> GVSet;
 480
 481     // CurFn - The llvm function being emitted.  Only valid during
 482     // finishFunction().
 483     const Function *CurFn;
 484
 485     /// Information about emitted code, which is passed to the
 486     /// JITEventListeners.  This is reset in startFunction and used in
 487     /// finishFunction.
 488     JITEvent_EmittedFunctionDetails EmissionDetails;
 489
 490     // CurFnStubUses - For a given Function, a vector of stubs that it
 491     // references.  This facilitates the JIT detecting that a stub is no
 492     // longer used, so that it may be deallocated.
 493     DenseMap<const Function *, SmallVector<void*, 1> > CurFnStubUses;
 494
 495     // StubFnRefs - For a given pointer to a stub, a set of Functions which
 496     // reference the stub.  When the count of a stub's references drops to zero,
 497     // the stub is unused.
 498     DenseMap<void *, SmallPtrSet<const Function*, 1> > StubFnRefs;
 499
 500     // ExtFnStubs - A map of external function names to stubs which have entries
 501     // in the JITResolver's ExternalFnToStubMap.
 502     StringMap<void *> ExtFnStubs;
 503
 504     DebugLocTuple PrevDLT;
 505
 506   public:
 507     JITEmitter(JIT &jit, JITMemoryManager *JMM)
 508         : SizeEstimate(0), Resolver(jit), MMI(0), CurFn(0) {
 509       MemMgr = JMM ? JMM : JITMemoryManager::CreateDefaultMemManager();
 510       if (jit.getJITInfo().needsGOT()) {
 511         MemMgr->AllocateGOT();
 512         DEBUG(errs() << "JIT is managing a GOT\n");
 513       }
 514
 515       if (DwarfExceptionHandling) DE = new JITDwarfEmitter(jit);
 516     }
 517     ~JITEmitter() {
 518       delete MemMgr;
 519       if (DwarfExceptionHandling) delete DE;
 520     }
 521
 522     /// classof - Methods for support type inquiry through isa, cast, and
 523     /// dyn_cast:
 524     ///
 525     static inline bool classof(const JITEmitter*) { return true; }
 526     static inline bool classof(const MachineCodeEmitter*) { return true; }
 527
 528     JITResolver &getJITResolver() { return Resolver; }
 529
 530     virtual void startFunction(MachineFunction &F);
 531     virtual bool finishFunction(MachineFunction &F);
 532
 533     void emitConstantPool(MachineConstantPool *MCP);
 534     void initJumpTableInfo(MachineJumpTableInfo *MJTI);
 535     void emitJumpTableInfo(MachineJumpTableInfo *MJTI);
 536
 537     virtual void startGVStub(const GlobalValue* GV, unsigned StubSize,
 538                                    unsigned Alignment = 1);
 539     virtual void startGVStub(const GlobalValue* GV, void *Buffer,
 540                              unsigned StubSize);
 541     virtual void* finishGVStub(const GlobalValue *GV);
 542
 543     /// allocateSpace - Reserves space in the current block if any, or
 544     /// allocate a new one of the given size.
 545     virtual void *allocateSpace(uintptr_t Size, unsigned Alignment);
 546
 547     /// allocateGlobal - Allocate memory for a global.  Unlike allocateSpace,
 548     /// this method does not allocate memory in the current output buffer,
 549     /// because a global may live longer than the current function.
 550     virtual void *allocateGlobal(uintptr_t Size, unsigned Alignment);
 551
 552     virtual void addRelocation(const MachineRelocation &MR) {
 553       Relocations.push_back(MR);
 554     }
 555
 556     virtual void StartMachineBasicBlock(MachineBasicBlock *MBB) {
 557       if (MBBLocations.size() <= (unsigned)MBB->getNumber())
 558         MBBLocations.resize((MBB->getNumber()+1)*2);
 559       MBBLocations[MBB->getNumber()] = getCurrentPCValue();
 560       DEBUG(errs() << "JIT: Emitting BB" << MBB->getNumber() << " at ["
 561                    << (void*) getCurrentPCValue() << "]\n");
 562     }
 563
 564     virtual uintptr_t getConstantPoolEntryAddress(unsigned Entry) const;
 565     virtual uintptr_t getJumpTableEntryAddress(unsigned Entry) const;
 566
 567     virtual uintptr_t getMachineBasicBlockAddress(MachineBasicBlock *MBB) const {
 568       assert(MBBLocations.size() > (unsigned)MBB->getNumber() &&
 569              MBBLocations[MBB->getNumber()] && "MBB not emitted!");
 570       return MBBLocations[MBB->getNumber()];
 571     }
 572
 573     /// retryWithMoreMemory - Log a retry and deallocate all memory for the
 574     /// given function.  Increase the minimum allocation size so that we get
 575     /// more memory next time.
 576     void retryWithMoreMemory(MachineFunction &F);
 577
 578     /// deallocateMemForFunction - Deallocate all memory for the specified
 579     /// function body.
 580     void deallocateMemForFunction(const Function *F);
 581
 582     /// AddStubToCurrentFunction - Mark the current function being JIT'd as
 583     /// using the stub at the specified address. Allows
 584     /// deallocateMemForFunction to also remove stubs no longer referenced.
 585     void AddStubToCurrentFunction(void *Stub);
 586
 587     /// getExternalFnStubs - Accessor for the JIT to find stubs emitted for
 588     /// MachineRelocations that reference external functions by name.
 589     const StringMap<void*> &getExternalFnStubs() const { return ExtFnStubs; }
 590
 591     virtual void processDebugLoc(DebugLoc DL);
 592
 593     virtual void emitLabel(uint64_t LabelID) {
 594       if (LabelLocations.size() <= LabelID)
 595         LabelLocations.resize((LabelID+1)*2);
 596       LabelLocations[LabelID] = getCurrentPCValue();
 597     }
 598
 599     virtual uintptr_t getLabelAddress(uint64_t LabelID) const {
 600       assert(LabelLocations.size() > (unsigned)LabelID &&
 601              LabelLocations[LabelID] && "Label not emitted!");
 602       return LabelLocations[LabelID];
 603     }
 604
 605     virtual void setModuleInfo(MachineModuleInfo* Info) {
 606       MMI = Info;
 607       if (DwarfExceptionHandling) DE->setModuleInfo(Info);
 608     }
 609
 610     void setMemoryExecutable() {
 611       MemMgr->setMemoryExecutable();
 612     }
 613
 614     JITMemoryManager *getMemMgr() const { return MemMgr; }
 615
 616   private:
 617     void *getPointerToGlobal(GlobalValue *GV, void *Reference, bool NoNeedStub);
 618     void *getPointerToGVIndirectSym(GlobalValue *V, void *Reference,
 619                                     bool NoNeedStub);
 620     unsigned addSizeOfGlobal(const GlobalVariable *GV, unsigned Size);
 621     unsigned addSizeOfGlobalsInConstantVal(const Constant *C, unsigned Size);
 622     unsigned addSizeOfGlobalsInInitializer(const Constant *Init, unsigned Size);
 623     unsigned GetSizeOfGlobalsInBytes(MachineFunction &MF);
 624   };
 625 }
 626
 627 void *JITEmitter::getPointerToGlobal(GlobalValue *V, void *Reference,
 628                                      bool DoesntNeedStub) {
 629   if (GlobalVariable *GV = dyn_cast<GlobalVariable>(V))
 630     return TheJIT->getOrEmitGlobalVariable(GV);
 631
 632   if (GlobalAlias *GA = dyn_cast<GlobalAlias>(V))
 633     return TheJIT->getPointerToGlobal(GA->resolveAliasedGlobal(false));
 634
 635   // If we have already compiled the function, return a pointer to its body.
 636   Function *F = cast<Function>(V);
 637   void *ResultPtr;
 638   if (!DoesntNeedStub && !TheJIT->isLazyCompilationDisabled()) {
 639     // Return the function stub if it's already created.
 640     ResultPtr = Resolver.getFunctionStubIfAvailable(F);
 641     if (ResultPtr)
 642       AddStubToCurrentFunction(ResultPtr);
 643   } else {
 644     ResultPtr = TheJIT->getPointerToGlobalIfAvailable(F);
 645   }
 646   if (ResultPtr) return ResultPtr;
 647
 648   // If this is an external function pointer, we can force the JIT to
 649   // 'compile' it, which really just adds it to the map.  In dlsym mode,
 650   // external functions are forced through a stub, regardless of reloc type.
 651   if (F->isDeclaration() && !F->hasNotBeenReadFromBitcode() &&
 652       DoesntNeedStub && !TheJIT->areDlsymStubsEnabled())
 653     return TheJIT->getPointerToFunction(F);
 654
 655   // Okay, the function has not been compiled yet, if the target callback
 656   // mechanism is capable of rewriting the instruction directly, prefer to do
 657   // that instead of emitting a stub.  This uses the lazy resolver, so is not
 658   // legal if lazy compilation is disabled.
 659   if (DoesntNeedStub && !TheJIT->isLazyCompilationDisabled())
 660     return Resolver.AddCallbackAtLocation(F, Reference);
 661
 662   // Otherwise, we have to emit a stub.
 663   void *StubAddr = Resolver.getFunctionStub(F);
 664
 665   // Add the stub to the current function's list of referenced stubs, so we can
 666   // deallocate them if the current function is ever freed.  It's possible to
 667   // return null from getFunctionStub in the case of a weak extern that fails
 668   // to resolve.
 669   if (StubAddr)
 670     AddStubToCurrentFunction(StubAddr);
 671
 672   return StubAddr;
 673 }
 674
 675 void *JITEmitter::getPointerToGVIndirectSym(GlobalValue *V, void *Reference,
 676                                             bool NoNeedStub) {
 677   // Make sure GV is emitted first, and create a stub containing the fully
 678   // resolved address.
 679   void *GVAddress = getPointerToGlobal(V, Reference, true);
 680   void *StubAddr = Resolver.getGlobalValueIndirectSym(V, GVAddress);
 681
 682   // Add the stub to the current function's list of referenced stubs, so we can
 683   // deallocate them if the current function is ever freed.
 684   AddStubToCurrentFunction(StubAddr);
 685
 686   return StubAddr;
 687 }
 688
 689 void JITEmitter::AddStubToCurrentFunction(void *StubAddr) {
 690   if (!TheJIT->areDlsymStubsEnabled())
 691     return;
 692
 693   assert(CurFn && "Stub added to current function, but current function is 0!");
 694
 695   SmallVectorImpl<void*> &StubsUsed = CurFnStubUses[CurFn];
 696   StubsUsed.push_back(StubAddr);
 697
 698   SmallPtrSet<const Function *, 1> &FnRefs = StubFnRefs[StubAddr];
 699   FnRefs.insert(CurFn);
 700 }
 701
 702 void JITEmitter::processDebugLoc(DebugLoc DL) {
 703   if (!DL.isUnknown()) {
 704     DebugLocTuple CurDLT = EmissionDetails.MF->getDebugLocTuple(DL);
 705
 706     if (CurDLT.CompileUnit != 0 && PrevDLT != CurDLT) {
 707       JITEvent_EmittedFunctionDetails::LineStart NextLine;
 708       NextLine.Address = getCurrentPCValue();
 709       NextLine.Loc = DL;
 710       EmissionDetails.LineStarts.push_back(NextLine);
 711     }
 712
 713     PrevDLT = CurDLT;
 714   }
 715 }
 716
 717 static unsigned GetConstantPoolSizeInBytes(MachineConstantPool *MCP,
 718                                            const TargetData *TD) {
 719   const std::vector<MachineConstantPoolEntry> &Constants = MCP->getConstants();
 720   if (Constants.empty()) return 0;
 721
 722   unsigned Size = 0;
 723   for (unsigned i = 0, e = Constants.size(); i != e; ++i) {
 724     MachineConstantPoolEntry CPE = Constants[i];
 725     unsigned AlignMask = CPE.getAlignment() - 1;
 726     Size = (Size + AlignMask) & ~AlignMask;
 727     const Type *Ty = CPE.getType();
 728     Size += TD->getTypeAllocSize(Ty);
 729   }
 730   return Size;
 731 }
 732
 733 static unsigned GetJumpTableSizeInBytes(MachineJumpTableInfo *MJTI) {
 734   const std::vector<MachineJumpTableEntry> &JT = MJTI->getJumpTables();
 735   if (JT.empty()) return 0;
 736
 737   unsigned NumEntries = 0;
 738   for (unsigned i = 0, e = JT.size(); i != e; ++i)
 739     NumEntries += JT[i].MBBs.size();
 740
 741   unsigned EntrySize = MJTI->getEntrySize();
 742
 743   return NumEntries * EntrySize;
 744 }
 745
 746 static uintptr_t RoundUpToAlign(uintptr_t Size, unsigned Alignment) {
 747   if (Alignment == 0) Alignment = 1;
 748   // Since we do not know where the buffer will be allocated, be pessimistic.
 749   return Size + Alignment;
 750 }
 751
 752 /// addSizeOfGlobal - add the size of the global (plus any alignment padding)
 753 /// into the running total Size.
 754
 755 unsigned JITEmitter::addSizeOfGlobal(const GlobalVariable *GV, unsigned Size) {
 756   const Type *ElTy = GV->getType()->getElementType();
 757   size_t GVSize = (size_t)TheJIT->getTargetData()->getTypeAllocSize(ElTy);
 758   size_t GVAlign =
 759       (size_t)TheJIT->getTargetData()->getPreferredAlignment(GV);
 760   DEBUG(errs() << "JIT: Adding in size " << GVSize << " alignment " << GVAlign);
 761   DEBUG(GV->dump());
 762   // Assume code section ends with worst possible alignment, so first
 763   // variable needs maximal padding.
 764   if (Size==0)
 765     Size = 1;
 766   Size = ((Size+GVAlign-1)/GVAlign)*GVAlign;
 767   Size += GVSize;
 768   return Size;
 769 }
 770
 771 /// addSizeOfGlobalsInConstantVal - find any globals that we haven't seen yet
 772 /// but are referenced from the constant; put them in GVSet and add their
 773 /// size into the running total Size.
 774
 775 unsigned JITEmitter::addSizeOfGlobalsInConstantVal(const Constant *C,
 776                                               unsigned Size) {
 777   // If its undefined, return the garbage.
 778   if (isa<UndefValue>(C))
 779     return Size;
 780
 781   // If the value is a ConstantExpr
 782   if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) {
 783     Constant *Op0 = CE->getOperand(0);
 784     switch (CE->getOpcode()) {
 785     case Instruction::GetElementPtr:
 786     case Instruction::Trunc:
 787     case Instruction::ZExt:
 788     case Instruction::SExt:
 789     case Instruction::FPTrunc:
 790     case Instruction::FPExt:
 791     case Instruction::UIToFP:
 792     case Instruction::SIToFP:
 793     case Instruction::FPToUI:
 794     case Instruction::FPToSI:
 795     case Instruction::PtrToInt:
 796     case Instruction::IntToPtr:
 797     case Instruction::BitCast: {
 798       Size = addSizeOfGlobalsInConstantVal(Op0, Size);
 799       break;
 800     }
 801     case Instruction::Add:
 802     case Instruction::FAdd:
 803     case Instruction::Sub:
 804     case Instruction::FSub:
 805     case Instruction::Mul:
 806     case Instruction::FMul:
 807     case Instruction::UDiv:
 808     case Instruction::SDiv:
 809     case Instruction::URem:
 810     case Instruction::SRem:
 811     case Instruction::And:
 812     case Instruction::Or:
 813     case Instruction::Xor: {
 814       Size = addSizeOfGlobalsInConstantVal(Op0, Size);
 815       Size = addSizeOfGlobalsInConstantVal(CE->getOperand(1), Size);
 816       break;
 817     }
 818     default: {
 819        std::string msg;
 820        raw_string_ostream Msg(msg);
 821        Msg << "ConstantExpr not handled: " << *CE;
 822        llvm_report_error(Msg.str());
 823     }
 824     }
 825   }
 826
 827   if (C->getType()->getTypeID() == Type::PointerTyID)
 828     if (const GlobalVariable* GV = dyn_cast<GlobalVariable>(C))
 829       if (GVSet.insert(GV))
 830         Size = addSizeOfGlobal(GV, Size);
 831
 832   return Size;
 833 }
 834
 835 /// addSizeOfGLobalsInInitializer - handle any globals that we haven't seen yet
 836 /// but are referenced from the given initializer.
 837
 838 unsigned JITEmitter::addSizeOfGlobalsInInitializer(const Constant *Init,
 839                                               unsigned Size) {
 840   if (!isa<UndefValue>(Init) &&
 841       !isa<ConstantVector>(Init) &&
 842       !isa<ConstantAggregateZero>(Init) &&
 843       !isa<ConstantArray>(Init) &&
 844       !isa<ConstantStruct>(Init) &&
 845       Init->getType()->isFirstClassType())
 846     Size = addSizeOfGlobalsInConstantVal(Init, Size);
 847   return Size;
 848 }
 849
 850 /// GetSizeOfGlobalsInBytes - walk the code for the function, looking for
 851 /// globals; then walk the initializers of those globals looking for more.
 852 /// If their size has not been considered yet, add it into the running total
 853 /// Size.
 854
 855 unsigned JITEmitter::GetSizeOfGlobalsInBytes(MachineFunction &MF) {
 856   unsigned Size = 0;
 857   GVSet.clear();
 858
 859   for (MachineFunction::iterator MBB = MF.begin(), E = MF.end();
 860        MBB != E; ++MBB) {
 861     for (MachineBasicBlock::const_iterator I = MBB->begin(), E = MBB->end();
 862          I != E; ++I) {
 863       const TargetInstrDesc &Desc = I->getDesc();
 864       const MachineInstr &MI = *I;
 865       unsigned NumOps = Desc.getNumOperands();
 866       for (unsigned CurOp = 0; CurOp < NumOps; CurOp++) {
 867         const MachineOperand &MO = MI.getOperand(CurOp);
 868         if (MO.isGlobal()) {
 869           GlobalValue* V = MO.getGlobal();
 870           const GlobalVariable *GV = dyn_cast<const GlobalVariable>(V);
 871           if (!GV)
 872             continue;
 873           // If seen in previous function, it will have an entry here.
 874           if (TheJIT->getPointerToGlobalIfAvailable(GV))
 875             continue;
 876           // If seen earlier in this function, it will have an entry here.
 877           // FIXME: it should be possible to combine these tables, by
 878           // assuming the addresses of the new globals in this module
 879           // start at 0 (or something) and adjusting them after codegen
 880           // complete.  Another possibility is to grab a marker bit in GV.
 881           if (GVSet.insert(GV))
 882             // A variable as yet unseen.  Add in its size.
 883             Size = addSizeOfGlobal(GV, Size);
 884         }
 885       }
 886     }
 887   }
 888   DEBUG(errs() << "JIT: About to look through initializers\n");
 889   // Look for more globals that are referenced only from initializers.
 890   // GVSet.end is computed each time because the set can grow as we go.
 891   for (SmallPtrSet<const GlobalVariable *, 8>::iterator I = GVSet.begin();
 892        I != GVSet.end(); I++) {
 893     const GlobalVariable* GV = *I;
 894     if (GV->hasInitializer())
 895       Size = addSizeOfGlobalsInInitializer(GV->getInitializer(), Size);
 896   }
 897
 898   return Size;
 899 }
 900
 901 void JITEmitter::startFunction(MachineFunction &F) {
 902   DEBUG(errs() << "JIT: Starting CodeGen of Function "
 903         << F.getFunction()->getName() << "\n");
 904
 905   uintptr_t ActualSize = 0;
 906   // Set the memory writable, if it's not already
 907   MemMgr->setMemoryWritable();
 908   if (MemMgr->NeedsExactSize()) {
 909     DEBUG(errs() << "JIT: ExactSize\n");
 910     const TargetInstrInfo* TII = F.getTarget().getInstrInfo();
 911     MachineJumpTableInfo *MJTI = F.getJumpTableInfo();
 912     MachineConstantPool *MCP = F.getConstantPool();
 913
 914     // Ensure the constant pool/jump table info is at least 4-byte aligned.
 915     ActualSize = RoundUpToAlign(ActualSize, 16);
 916
 917     // Add the alignment of the constant pool
 918     ActualSize = RoundUpToAlign(ActualSize, MCP->getConstantPoolAlignment());
 919
 920     // Add the constant pool size
 921     ActualSize += GetConstantPoolSizeInBytes(MCP, TheJIT->getTargetData());
 922
 923     // Add the aligment of the jump table info
 924     ActualSize = RoundUpToAlign(ActualSize, MJTI->getAlignment());
 925
 926     // Add the jump table size
 927     ActualSize += GetJumpTableSizeInBytes(MJTI);
 928
 929     // Add the alignment for the function
 930     ActualSize = RoundUpToAlign(ActualSize,
 931                                 std::max(F.getFunction()->getAlignment(), 8U));
 932
 933     // Add the function size
 934     ActualSize += TII->GetFunctionSizeInBytes(F);
 935
 936     DEBUG(errs() << "JIT: ActualSize before globals " << ActualSize << "\n");
 937     // Add the size of the globals that will be allocated after this function.
 938     // These are all the ones referenced from this function that were not
 939     // previously allocated.
 940     ActualSize += GetSizeOfGlobalsInBytes(F);
 941     DEBUG(errs() << "JIT: ActualSize after globals " << ActualSize << "\n");
 942   } else if (SizeEstimate > 0) {
 943     // SizeEstimate will be non-zero on reallocation attempts.
 944     ActualSize = SizeEstimate;
 945   }
 946
 947   BufferBegin = CurBufferPtr = MemMgr->startFunctionBody(F.getFunction(),
 948                                                          ActualSize);
 949   BufferEnd = BufferBegin+ActualSize;
 950
 951   // Ensure the constant pool/jump table info is at least 4-byte aligned.
 952   emitAlignment(16);
 953
 954   emitConstantPool(F.getConstantPool());
 955   initJumpTableInfo(F.getJumpTableInfo());
 956
 957   // About to start emitting the machine code for the function.
 958   emitAlignment(std::max(F.getFunction()->getAlignment(), 8U));
 959   TheJIT->updateGlobalMapping(F.getFunction(), CurBufferPtr);
 960
 961   MBBLocations.clear();
 962
 963   EmissionDetails.MF = &F;
 964   EmissionDetails.LineStarts.clear();
 965 }
 966
 967 bool JITEmitter::finishFunction(MachineFunction &F) {
 968   if (CurBufferPtr == BufferEnd) {
 969     // We must call endFunctionBody before retrying, because
 970     // deallocateMemForFunction requires it.
 971     MemMgr->endFunctionBody(F.getFunction(), BufferBegin, CurBufferPtr);
 972     retryWithMoreMemory(F);
 973     return true;
 974   }
 975
 976   emitJumpTableInfo(F.getJumpTableInfo());
 977
 978   // FnStart is the start of the text, not the start of the constant pool and
 979   // other per-function data.
 980   uint8_t *FnStart =
 981     (uint8_t *)TheJIT->getPointerToGlobalIfAvailable(F.getFunction());
 982
 983   // FnEnd is the end of the function's machine code.
 984   uint8_t *FnEnd = CurBufferPtr;
 985
 986   if (!Relocations.empty()) {
 987     CurFn = F.getFunction();
 988     NumRelos += Relocations.size();
 989
 990     // Resolve the relocations to concrete pointers.
 991     for (unsigned i = 0, e = Relocations.size(); i != e; ++i) {
 992       MachineRelocation &MR = Relocations[i];
 993       void *ResultPtr = 0;
 994       if (!MR.letTargetResolve()) {
 995         if (MR.isExternalSymbol()) {
 996           ResultPtr = TheJIT->getPointerToNamedFunction(MR.getExternalSymbol(),
 997                                                         false);
 998           DEBUG(errs() << "JIT: Map \'" << MR.getExternalSymbol() << "\' to ["
 999                        << ResultPtr << "]\n");
1000
1001           // If the target REALLY wants a stub for this function, emit it now.
1002           if (!MR.doesntNeedStub()) {
1003             if (!TheJIT->areDlsymStubsEnabled()) {
1004               ResultPtr = Resolver.getExternalFunctionStub(ResultPtr);
1005             } else {
1006               void *&Stub = ExtFnStubs[MR.getExternalSymbol()];
1007               if (!Stub) {
1008                 Stub = Resolver.getExternalFunctionStub((void *)&Stub);
1009                 AddStubToCurrentFunction(Stub);
1010               }
1011               ResultPtr = Stub;
1012             }
1013           }
1014         } else if (MR.isGlobalValue()) {
1015           ResultPtr = getPointerToGlobal(MR.getGlobalValue(),
1016                                          BufferBegin+MR.getMachineCodeOffset(),
1017                                          MR.doesntNeedStub());
1018         } else if (MR.isIndirectSymbol()) {
1019           ResultPtr = getPointerToGVIndirectSym(MR.getGlobalValue(),
1020                                           BufferBegin+MR.getMachineCodeOffset(),
1021                                           MR.doesntNeedStub());
1022         } else if (MR.isBasicBlock()) {
1023           ResultPtr = (void*)getMachineBasicBlockAddress(MR.getBasicBlock());
1024         } else if (MR.isConstantPoolIndex()) {
1025           ResultPtr = (void*)getConstantPoolEntryAddress(MR.getConstantPoolIndex());
1026         } else {
1027           assert(MR.isJumpTableIndex());
1028           ResultPtr=(void*)getJumpTableEntryAddress(MR.getJumpTableIndex());
1029         }
1030
1031         MR.setResultPointer(ResultPtr);
1032       }
1033
1034       // if we are managing the GOT and the relocation wants an index,
1035       // give it one
1036       if (MR.isGOTRelative() && MemMgr->isManagingGOT()) {
1037         unsigned idx = Resolver.getGOTIndexForAddr(ResultPtr);
1038         MR.setGOTIndex(idx);
1039         if (((void**)MemMgr->getGOTBase())[idx] != ResultPtr) {
1040           DEBUG(errs() << "JIT: GOT was out of date for " << ResultPtr
1041                        << " pointing at " << ((void**)MemMgr->getGOTBase())[idx]
1042                        << "\n");
1043           ((void**)MemMgr->getGOTBase())[idx] = ResultPtr;
1044         }
1045       }
1046     }
1047
1048     CurFn = 0;
1049     TheJIT->getJITInfo().relocate(BufferBegin, &Relocations[0],
1050                                   Relocations.size(), MemMgr->getGOTBase());
1051   }
1052
1053   // Update the GOT entry for F to point to the new code.
1054   if (MemMgr->isManagingGOT()) {
1055     unsigned idx = Resolver.getGOTIndexForAddr((void*)BufferBegin);
1056     if (((void**)MemMgr->getGOTBase())[idx] != (void*)BufferBegin) {
1057       DEBUG(errs() << "JIT: GOT was out of date for " << (void*)BufferBegin
1058                    << " pointing at " << ((void**)MemMgr->getGOTBase())[idx]
1059                    << "\n");
1060       ((void**)MemMgr->getGOTBase())[idx] = (void*)BufferBegin;
1061     }
1062   }
1063
1064   // CurBufferPtr may have moved beyond FnEnd, due to memory allocation for
1065   // global variables that were referenced in the relocations.
1066   MemMgr->endFunctionBody(F.getFunction(), BufferBegin, CurBufferPtr);
1067
1068   if (CurBufferPtr == BufferEnd) {
1069     retryWithMoreMemory(F);
1070     return true;
1071   } else {
1072     // Now that we've succeeded in emitting the function, reset the
1073     // SizeEstimate back down to zero.
1074     SizeEstimate = 0;
1075   }
1076
1077   BufferBegin = CurBufferPtr = 0;
1078   NumBytes += FnEnd-FnStart;
1079
1080   // Invalidate the icache if necessary.
1081   sys::Memory::InvalidateInstructionCache(FnStart, FnEnd-FnStart);
1082
1083   TheJIT->NotifyFunctionEmitted(*F.getFunction(), FnStart, FnEnd-FnStart,
1084                                 EmissionDetails);
1085
1086   DEBUG(errs() << "JIT: Finished CodeGen of [" << (void*)FnStart
1087         << "] Function: " << F.getFunction()->getName()
1088         << ": " << (FnEnd-FnStart) << " bytes of text, "
1089         << Relocations.size() << " relocations\n");
1090
1091   Relocations.clear();
1092   ConstPoolAddresses.clear();
1093
1094   // Mark code region readable and executable if it's not so already.
1095   MemMgr->setMemoryExecutable();
1096
1097   DEBUG(
1098     if (sys::hasDisassembler()) {
1099       errs() << "JIT: Disassembled code:\n";
1100       errs() << sys::disassembleBuffer(FnStart, FnEnd-FnStart,
1101                                        (uintptr_t)FnStart);
1102     } else {
1103       errs() << "JIT: Binary code:\n";
1104       uint8_t* q = FnStart;
1105       for (int i = 0; q < FnEnd; q += 4, ++i) {
1106         if (i == 4)
1107           i = 0;
1108         if (i == 0)
1109           errs() << "JIT: " << (long)(q - FnStart) << ": ";
1110         bool Done = false;
1111         for (int j = 3; j >= 0; --j) {
1112           if (q + j >= FnEnd)
1113             Done = true;
1114           else
1115             errs() << (unsigned short)q[j];
1116         }
1117         if (Done)
1118           break;
1119         errs() << ' ';
1120         if (i == 3)
1121           errs() << '\n';
1122       }
1123       errs()<< '\n';
1124     }
1125         );
1126
1127   if (DwarfExceptionHandling) {
1128     uintptr_t ActualSize = 0;
1129     SavedBufferBegin = BufferBegin;
1130     SavedBufferEnd = BufferEnd;
1131     SavedCurBufferPtr = CurBufferPtr;
1132
1133     if (MemMgr->NeedsExactSize()) {
1134       ActualSize = DE->GetDwarfTableSizeInBytes(F, *this, FnStart, FnEnd);
1135     }
1136
1137     BufferBegin = CurBufferPtr = MemMgr->startExceptionTable(F.getFunction(),
1138                                                              ActualSize);
1139     BufferEnd = BufferBegin+ActualSize;
1140     uint8_t* FrameRegister = DE->EmitDwarfTable(F, *this, FnStart, FnEnd);
1141     MemMgr->endExceptionTable(F.getFunction(), BufferBegin, CurBufferPtr,
1142                               FrameRegister);
1143     BufferBegin = SavedBufferBegin;
1144     BufferEnd = SavedBufferEnd;
1145     CurBufferPtr = SavedCurBufferPtr;
1146
1147     TheJIT->RegisterTable(FrameRegister);
1148   }
1149
1150   if (MMI)
1151     MMI->EndFunction();
1152
1153   return false;
1154 }
1155
1156 void JITEmitter::retryWithMoreMemory(MachineFunction &F) {
1157   DEBUG(errs() << "JIT: Ran out of space for native code.  Reattempting.\n");
1158   Relocations.clear();  // Clear the old relocations or we'll reapply them.
1159   ConstPoolAddresses.clear();
1160   ++NumRetries;
1161   deallocateMemForFunction(F.getFunction());
1162   // Try again with at least twice as much free space.
1163   SizeEstimate = (uintptr_t)(2 * (BufferEnd - BufferBegin));
1164 }
1165
1166 /// deallocateMemForFunction - Deallocate all memory for the specified
1167 /// function body.  Also drop any references the function has to stubs.
1168 void JITEmitter::deallocateMemForFunction(const Function *F) {
1169   MemMgr->deallocateMemForFunction(F);
1170
1171   // If the function did not reference any stubs, return.
1172   if (CurFnStubUses.find(F) == CurFnStubUses.end())
1173     return;
1174
1175   // For each referenced stub, erase the reference to this function, and then
1176   // erase the list of referenced stubs.
1177   SmallVectorImpl<void *> &StubList = CurFnStubUses[F];
1178   for (unsigned i = 0, e = StubList.size(); i != e; ++i) {
1179     void *Stub = StubList[i];
1180
1181     // If we already invalidated this stub for this function, continue.
1182     if (StubFnRefs.count(Stub) == 0)
1183       continue;
1184
1185     SmallPtrSet<const Function *, 1> &FnRefs = StubFnRefs[Stub];
1186     FnRefs.erase(F);
1187
1188     // If this function was the last reference to the stub, invalidate the stub
1189     // in the JITResolver.  Were there a memory manager deallocateStub routine,
1190     // we could call that at this point too.
1191     if (FnRefs.empty()) {
1192       DEBUG(errs() << "\nJIT: Invalidated Stub at [" << Stub << "]\n");
1193       StubFnRefs.erase(Stub);
1194
1195       // Invalidate the stub.  If it is a GV stub, update the JIT's global
1196       // mapping for that GV to zero, otherwise, search the string map of
1197       // external function names to stubs and remove the entry for this stub.
1198       GlobalValue *GV = Resolver.invalidateStub(Stub);
1199       if (GV) {
1200         TheJIT->updateGlobalMapping(GV, 0);
1201       } else {
1202         for (StringMapIterator<void*> i = ExtFnStubs.begin(),
1203              e = ExtFnStubs.end(); i != e; ++i) {
1204           if (i->second == Stub) {
1205             ExtFnStubs.erase(i);
1206             break;
1207           }
1208         }
1209       }
1210     }
1211   }
1212   CurFnStubUses.erase(F);
1213 }
1214
1215
1216 void* JITEmitter::allocateSpace(uintptr_t Size, unsigned Alignment) {
1217   if (BufferBegin)
1218     return JITCodeEmitter::allocateSpace(Size, Alignment);
1219
1220   // create a new memory block if there is no active one.
1221   // care must be taken so that BufferBegin is invalidated when a
1222   // block is trimmed
1223   BufferBegin = CurBufferPtr = MemMgr->allocateSpace(Size, Alignment);
1224   BufferEnd = BufferBegin+Size;
1225   return CurBufferPtr;
1226 }
1227
1228 void* JITEmitter::allocateGlobal(uintptr_t Size, unsigned Alignment) {
1229   // Delegate this call through the memory manager.
1230   return MemMgr->allocateGlobal(Size, Alignment);
1231 }
1232
1233 void JITEmitter::emitConstantPool(MachineConstantPool *MCP) {
1234   if (TheJIT->getJITInfo().hasCustomConstantPool())
1235     return;
1236
1237   const std::vector<MachineConstantPoolEntry> &Constants = MCP->getConstants();
1238   if (Constants.empty()) return;
1239
1240   unsigned Size = GetConstantPoolSizeInBytes(MCP, TheJIT->getTargetData());
1241   unsigned Align = MCP->getConstantPoolAlignment();
1242   ConstantPoolBase = allocateSpace(Size, Align);
1243   ConstantPool = MCP;
1244
1245   if (ConstantPoolBase == 0) return;  // Buffer overflow.
1246
1247   DEBUG(errs() << "JIT: Emitted constant pool at [" << ConstantPoolBase
1248                << "] (size: " << Size << ", alignment: " << Align << ")\n");
1249
1250   // Initialize the memory for all of the constant pool entries.
1251   unsigned Offset = 0;
1252   for (unsigned i = 0, e = Constants.size(); i != e; ++i) {
1253     MachineConstantPoolEntry CPE = Constants[i];
1254     unsigned AlignMask = CPE.getAlignment() - 1;
1255     Offset = (Offset + AlignMask) & ~AlignMask;
1256
1257     uintptr_t CAddr = (uintptr_t)ConstantPoolBase + Offset;
1258     ConstPoolAddresses.push_back(CAddr);
1259     if (CPE.isMachineConstantPoolEntry()) {
1260       // FIXME: add support to lower machine constant pool values into bytes!
1261       llvm_report_error("Initialize memory with machine specific constant pool"
1262                         "entry has not been implemented!");
1263     }
1264     TheJIT->InitializeMemory(CPE.Val.ConstVal, (void*)CAddr);
1265     DEBUG(errs() << "JIT:   CP" << i << " at [0x";
1266           errs().write_hex(CAddr) << "]\n");
1267
1268     const Type *Ty = CPE.Val.ConstVal->getType();
1269     Offset += TheJIT->getTargetData()->getTypeAllocSize(Ty);
1270   }
1271 }
1272
1273 void JITEmitter::initJumpTableInfo(MachineJumpTableInfo *MJTI) {
1274   if (TheJIT->getJITInfo().hasCustomJumpTables())
1275     return;
1276
1277   const std::vector<MachineJumpTableEntry> &JT = MJTI->getJumpTables();
1278   if (JT.empty()) return;
1279
1280   unsigned NumEntries = 0;
1281   for (unsigned i = 0, e = JT.size(); i != e; ++i)
1282     NumEntries += JT[i].MBBs.size();
1283
1284   unsigned EntrySize = MJTI->getEntrySize();
1285
1286   // Just allocate space for all the jump tables now.  We will fix up the actual
1287   // MBB entries in the tables after we emit the code for each block, since then
1288   // we will know the final locations of the MBBs in memory.
1289   JumpTable = MJTI;
1290   JumpTableBase = allocateSpace(NumEntries * EntrySize, MJTI->getAlignment());
1291 }
1292
1293 void JITEmitter::emitJumpTableInfo(MachineJumpTableInfo *MJTI) {
1294   if (TheJIT->getJITInfo().hasCustomJumpTables())
1295     return;
1296
1297   const std::vector<MachineJumpTableEntry> &JT = MJTI->getJumpTables();
1298   if (JT.empty() || JumpTableBase == 0) return;
1299
1300   if (TargetMachine::getRelocationModel() == Reloc::PIC_) {
1301     assert(MJTI->getEntrySize() == 4 && "Cross JIT'ing?");
1302     // For each jump table, place the offset from the beginning of the table
1303     // to the target address.
1304     int *SlotPtr = (int*)JumpTableBase;
1305
1306     for (unsigned i = 0, e = JT.size(); i != e; ++i) {
1307       const std::vector<MachineBasicBlock*> &MBBs = JT[i].MBBs;
1308       // Store the offset of the basic block for this jump table slot in the
1309       // memory we allocated for the jump table in 'initJumpTableInfo'
1310       uintptr_t Base = (uintptr_t)SlotPtr;
1311       for (unsigned mi = 0, me = MBBs.size(); mi != me; ++mi) {
1312         uintptr_t MBBAddr = getMachineBasicBlockAddress(MBBs[mi]);
1313         *SlotPtr++ = TheJIT->getJITInfo().getPICJumpTableEntry(MBBAddr, Base);
1314       }
1315     }
1316   } else {
1317     assert(MJTI->getEntrySize() == sizeof(void*) && "Cross JIT'ing?");
1318
1319     // For each jump table, map each target in the jump table to the address of
1320     // an emitted MachineBasicBlock.
1321     intptr_t *SlotPtr = (intptr_t*)JumpTableBase;
1322
1323     for (unsigned i = 0, e = JT.size(); i != e; ++i) {
1324       const std::vector<MachineBasicBlock*> &MBBs = JT[i].MBBs;
1325       // Store the address of the basic block for this jump table slot in the
1326       // memory we allocated for the jump table in 'initJumpTableInfo'
1327       for (unsigned mi = 0, me = MBBs.size(); mi != me; ++mi)
1328         *SlotPtr++ = getMachineBasicBlockAddress(MBBs[mi]);
1329     }
1330   }
1331 }
1332
1333 void JITEmitter::startGVStub(const GlobalValue* GV, unsigned StubSize,
1334                              unsigned Alignment) {
1335   SavedBufferBegin = BufferBegin;
1336   SavedBufferEnd = BufferEnd;
1337   SavedCurBufferPtr = CurBufferPtr;
1338
1339   BufferBegin = CurBufferPtr = MemMgr->allocateStub(GV, StubSize, Alignment);
1340   BufferEnd = BufferBegin+StubSize+1;
1341 }
1342
1343 void JITEmitter::startGVStub(const GlobalValue* GV, void *Buffer,
1344                              unsigned StubSize) {
1345   SavedBufferBegin = BufferBegin;
1346   SavedBufferEnd = BufferEnd;
1347   SavedCurBufferPtr = CurBufferPtr;
1348
1349   BufferBegin = CurBufferPtr = (uint8_t *)Buffer;
1350   BufferEnd = BufferBegin+StubSize+1;
1351 }
1352
1353 void *JITEmitter::finishGVStub(const GlobalValue* GV) {
1354   NumBytes += getCurrentPCOffset();
1355   std::swap(SavedBufferBegin, BufferBegin);
1356   BufferEnd = SavedBufferEnd;
1357   CurBufferPtr = SavedCurBufferPtr;
1358   return SavedBufferBegin;
1359 }
1360
1361 // getConstantPoolEntryAddress - Return the address of the 'ConstantNum' entry
1362 // in the constant pool that was last emitted with the 'emitConstantPool'
1363 // method.
1364 //
1365 uintptr_t JITEmitter::getConstantPoolEntryAddress(unsigned ConstantNum) const {
1366   assert(ConstantNum < ConstantPool->getConstants().size() &&
1367          "Invalid ConstantPoolIndex!");
1368   return ConstPoolAddresses[ConstantNum];
1369 }
1370
1371 // getJumpTableEntryAddress - Return the address of the JumpTable with index
1372 // 'Index' in the jumpp table that was last initialized with 'initJumpTableInfo'
1373 //
1374 uintptr_t JITEmitter::getJumpTableEntryAddress(unsigned Index) const {
1375   const std::vector<MachineJumpTableEntry> &JT = JumpTable->getJumpTables();
1376   assert(Index < JT.size() && "Invalid jump table index!");
1377
1378   unsigned Offset = 0;
1379   unsigned EntrySize = JumpTable->getEntrySize();
1380
1381   for (unsigned i = 0; i < Index; ++i)
1382     Offset += JT[i].MBBs.size();
1383
1384    Offset *= EntrySize;
1385
1386   return (uintptr_t)((char *)JumpTableBase + Offset);
1387 }
1388
1389 //===----------------------------------------------------------------------===//
1390 //  Public interface to this file
1391 //===----------------------------------------------------------------------===//
1392
1393 JITCodeEmitter *JIT::createEmitter(JIT &jit, JITMemoryManager *JMM) {
1394   return new JITEmitter(jit, JMM);
1395 }
1396
1397 // getPointerToNamedFunction - This function is used as a global wrapper to
1398 // JIT::getPointerToNamedFunction for the purpose of resolving symbols when
1399 // bugpoint is debugging the JIT. In that scenario, we are loading an .so and
1400 // need to resolve function(s) that are being mis-codegenerated, so we need to
1401 // resolve their addresses at runtime, and this is the way to do it.
1402 extern "C" {
1403   void *getPointerToNamedFunction(const char *Name) {
1404     if (Function *F = TheJIT->FindFunctionNamed(Name))
1405       return TheJIT->getPointerToFunction(F);
1406     return TheJIT->getPointerToNamedFunction(Name);
1407   }
1408 }
1409
1410 // getPointerToFunctionOrStub - If the specified function has been
1411 // code-gen'd, return a pointer to the function.  If not, compile it, or use
1412 // a stub to implement lazy compilation if available.
1413 //
1414 void *JIT::getPointerToFunctionOrStub(Function *F) {
1415   // If we have already code generated the function, just return the address.
1416   if (void *Addr = getPointerToGlobalIfAvailable(F))
1417     return Addr;
1418
1419   // Get a stub if the target supports it.
1420   assert(isa<JITEmitter>(JCE) && "Unexpected MCE?");
1421   JITEmitter *JE = cast<JITEmitter>(getCodeEmitter());
1422   return JE->getJITResolver().getFunctionStub(F);
1423 }
1424
1425 void JIT::updateFunctionStub(Function *F) {
1426   // Get the empty stub we generated earlier.
1427   assert(isa<JITEmitter>(JCE) && "Unexpected MCE?");
1428   JITEmitter *JE = cast<JITEmitter>(getCodeEmitter());
1429   void *Stub = JE->getJITResolver().getFunctionStub(F);
1430
1431   // Tell the target jit info to rewrite the stub at the specified address,
1432   // rather than creating a new one.
1433   void *Addr = getPointerToGlobalIfAvailable(F);
1434   getJITInfo().emitFunctionStubAtAddr(F, Addr, Stub, *getCodeEmitter());
1435 }
1436
1437 /// updateDlsymStubTable - Emit the data necessary to relocate the stubs
1438 /// that were emitted during code generation.
1439 ///
1440 void JIT::updateDlsymStubTable() {
1441   assert(isa<JITEmitter>(JCE) && "Unexpected MCE?");
1442   JITEmitter *JE = cast<JITEmitter>(getCodeEmitter());
1443
1444   SmallVector<GlobalValue*, 8> GVs;
1445   SmallVector<void*, 8> Ptrs;
1446   const StringMap<void *> &ExtFns = JE->getExternalFnStubs();
1447
1448   JE->getJITResolver().getRelocatableGVs(GVs, Ptrs);
1449
1450   unsigned nStubs = GVs.size() + ExtFns.size();
1451
1452   // If there are no relocatable stubs, return.
1453   if (nStubs == 0)
1454     return;
1455
1456   // If there are no new relocatable stubs, return.
1457   void *CurTable = JE->getMemMgr()->getDlsymTable();
1458   if (CurTable && (*(unsigned *)CurTable == nStubs))
1459     return;
1460
1461   // Calculate the size of the stub info
1462   unsigned offset = 4 + 4 * nStubs + sizeof(intptr_t) * nStubs;
1463
1464   SmallVector<unsigned, 8> Offsets;
1465   for (unsigned i = 0; i != GVs.size(); ++i) {
1466     Offsets.push_back(offset);
1467     offset += GVs[i]->getName().size() + 1;
1468   }
1469   for (StringMapConstIterator<void*> i = ExtFns.begin(), e = ExtFns.end();
1470        i != e; ++i) {
1471     Offsets.push_back(offset);
1472     offset += strlen(i->first()) + 1;
1473   }
1474
1475   // Allocate space for the new "stub", which contains the dlsym table.
1476   JE->startGVStub(0, offset, 4);
1477
1478   // Emit the number of records
1479   JE->emitInt32(nStubs);
1480
1481   // Emit the string offsets
1482   for (unsigned i = 0; i != nStubs; ++i)
1483     JE->emitInt32(Offsets[i]);
1484
1485   // Emit the pointers.  Verify that they are at least 2-byte aligned, and set
1486   // the low bit to 0 == GV, 1 == Function, so that the client code doing the
1487   // relocation can write the relocated pointer at the appropriate place in
1488   // the stub.
1489   for (unsigned i = 0; i != GVs.size(); ++i) {
1490     intptr_t Ptr = (intptr_t)Ptrs[i];
1491     assert((Ptr & 1) == 0 && "Stub pointers must be at least 2-byte aligned!");
1492
1493     if (isa<Function>(GVs[i]))
1494       Ptr |= (intptr_t)1;
1495
1496     if (sizeof(Ptr) == 8)
1497       JE->emitInt64(Ptr);
1498     else
1499       JE->emitInt32(Ptr);
1500   }
1501   for (StringMapConstIterator<void*> i = ExtFns.begin(), e = ExtFns.end();
1502        i != e; ++i) {
1503     intptr_t Ptr = (intptr_t)i->second | 1;
1504
1505     if (sizeof(Ptr) == 8)
1506       JE->emitInt64(Ptr);
1507     else
1508       JE->emitInt32(Ptr);
1509   }
1510
1511   // Emit the strings.
1512   for (unsigned i = 0; i != GVs.size(); ++i)
1513     JE->emitString(GVs[i]->getName());
1514   for (StringMapConstIterator<void*> i = ExtFns.begin(), e = ExtFns.end();
1515        i != e; ++i)
1516     JE->emitString(i->first());
1517
1518   // Tell the JIT memory manager where it is.  The JIT Memory Manager will
1519   // deallocate space for the old one, if one existed.
1520   JE->getMemMgr()->SetDlsymTable(JE->finishGVStub(0));
1521 }
1522
1523 /// freeMachineCodeForFunction - release machine code memory for given Function.
1524 ///
1525 void JIT::freeMachineCodeForFunction(Function *F) {
1526
1527   // Delete translation for this from the ExecutionEngine, so it will get
1528   // retranslated next time it is used.
1529   void *OldPtr = updateGlobalMapping(F, 0);
1530
1531   if (OldPtr)
1532     TheJIT->NotifyFreeingMachineCode(*F, OldPtr);
1533
1534   // Free the actual memory for the function body and related stuff.
1535   assert(isa<JITEmitter>(JCE) && "Unexpected MCE?");
1536   cast<JITEmitter>(JCE)->deallocateMemForFunction(F);
1537 }