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/Constant.h"
  19 #include "llvm/Module.h"
  20 #include "llvm/Type.h"
  21 #include "llvm/CodeGen/MachineCodeEmitter.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/JITMemoryManager.h"
  28 #include "llvm/Target/TargetData.h"
  29 #include "llvm/Target/TargetJITInfo.h"
  30 #include "llvm/Target/TargetMachine.h"
  31 #include "llvm/Target/TargetOptions.h"
  32 #include "llvm/Support/Debug.h"
  33 #include "llvm/Support/MutexGuard.h"
  34 #include "llvm/System/Disassembler.h"
  35 #include "llvm/System/Memory.h"
  36 #include "llvm/Target/TargetInstrInfo.h"
  37 #include "llvm/ADT/Statistic.h"
  38 #include <algorithm>
  39 using namespace llvm;
  40
  41 STATISTIC(NumBytes, "Number of bytes of machine code compiled");
  42 STATISTIC(NumRelos, "Number of relocations applied");
  43 static JIT *TheJIT = 0;
  44
  45
  46 //===----------------------------------------------------------------------===//
  47 // JIT lazy compilation code.
  48 //
  49 namespace {
  50   class JITResolverState {
  51   private:
  52     /// FunctionToStubMap - Keep track of the stub created for a particular
  53     /// function so that we can reuse them if necessary.
  54     std::map<Function*, void*> FunctionToStubMap;
  55
  56     /// StubToFunctionMap - Keep track of the function that each stub
  57     /// corresponds to.
  58     std::map<void*, Function*> StubToFunctionMap;
  59
  60     /// GlobalToLazyPtrMap - Keep track of the lazy pointer created for a
  61     /// particular GlobalVariable so that we can reuse them if necessary.
  62     std::map<GlobalValue*, void*> GlobalToLazyPtrMap;
  63
  64   public:
  65     std::map<Function*, void*>& getFunctionToStubMap(const MutexGuard& locked) {
  66       assert(locked.holds(TheJIT->lock));
  67       return FunctionToStubMap;
  68     }
  69
  70     std::map<void*, Function*>& getStubToFunctionMap(const MutexGuard& locked) {
  71       assert(locked.holds(TheJIT->lock));
  72       return StubToFunctionMap;
  73     }
  74
  75     std::map<GlobalValue*, void*>&
  76     getGlobalToLazyPtrMap(const MutexGuard& locked) {
  77       assert(locked.holds(TheJIT->lock));
  78       return GlobalToLazyPtrMap;
  79     }
  80   };
  81
  82   /// JITResolver - Keep track of, and resolve, call sites for functions that
  83   /// have not yet been compiled.
  84   class JITResolver {
  85     /// LazyResolverFn - The target lazy resolver function that we actually
  86     /// rewrite instructions to use.
  87     TargetJITInfo::LazyResolverFn LazyResolverFn;
  88
  89     JITResolverState state;
  90
  91     /// ExternalFnToStubMap - This is the equivalent of FunctionToStubMap for
  92     /// external functions.
  93     std::map<void*, void*> ExternalFnToStubMap;
  94
  95     //map addresses to indexes in the GOT
  96     std::map<void*, unsigned> revGOTMap;
  97     unsigned nextGOTIndex;
  98
  99     static JITResolver *TheJITResolver;
 100   public:
 101     explicit JITResolver(JIT &jit) : nextGOTIndex(0) {
 102       TheJIT = &jit;
 103
 104       LazyResolverFn = jit.getJITInfo().getLazyResolverFunction(JITCompilerFn);
 105       assert(TheJITResolver == 0 && "Multiple JIT resolvers?");
 106       TheJITResolver = this;
 107     }
 108
 109     ~JITResolver() {
 110       TheJITResolver = 0;
 111     }
 112
 113     /// getFunctionStub - This returns a pointer to a function stub, creating
 114     /// one on demand as needed.
 115     void *getFunctionStub(Function *F);
 116
 117     /// getExternalFunctionStub - Return a stub for the function at the
 118     /// specified address, created lazily on demand.
 119     void *getExternalFunctionStub(void *FnAddr);
 120
 121     /// getGlobalValueLazyPtr - Return a lazy pointer containing the specified
 122     /// GV address.
 123     void *getGlobalValueLazyPtr(GlobalValue *V, void *GVAddress);
 124
 125     /// AddCallbackAtLocation - If the target is capable of rewriting an
 126     /// instruction without the use of a stub, record the location of the use so
 127     /// we know which function is being used at the location.
 128     void *AddCallbackAtLocation(Function *F, void *Location) {
 129       MutexGuard locked(TheJIT->lock);
 130       /// Get the target-specific JIT resolver function.
 131       state.getStubToFunctionMap(locked)[Location] = F;
 132       return (void*)(intptr_t)LazyResolverFn;
 133     }
 134
 135     /// getGOTIndexForAddress - Return a new or existing index in the GOT for
 136     /// an address.  This function only manages slots, it does not manage the
 137     /// contents of the slots or the memory associated with the GOT.
 138     unsigned getGOTIndexForAddr(void *addr);
 139
 140     /// JITCompilerFn - This function is called to resolve a stub to a compiled
 141     /// address.  If the LLVM Function corresponding to the stub has not yet
 142     /// been compiled, this function compiles it first.
 143     static void *JITCompilerFn(void *Stub);
 144   };
 145 }
 146
 147 JITResolver *JITResolver::TheJITResolver = 0;
 148
 149 /// getFunctionStub - This returns a pointer to a function stub, creating
 150 /// one on demand as needed.
 151 void *JITResolver::getFunctionStub(Function *F) {
 152   MutexGuard locked(TheJIT->lock);
 153
 154   // If we already have a stub for this function, recycle it.
 155   void *&Stub = state.getFunctionToStubMap(locked)[F];
 156   if (Stub) return Stub;
 157
 158   // Call the lazy resolver function unless we already KNOW it is an external
 159   // function, in which case we just skip the lazy resolution step.
 160   void *Actual = (void*)(intptr_t)LazyResolverFn;
 161   if (F->isDeclaration() && !F->hasNotBeenReadFromBitcode())
 162     Actual = TheJIT->getPointerToFunction(F);
 163
 164   // Otherwise, codegen a new stub.  For now, the stub will call the lazy
 165   // resolver function.
 166   Stub = TheJIT->getJITInfo().emitFunctionStub(F, Actual,
 167                                                *TheJIT->getCodeEmitter());
 168
 169   if (Actual != (void*)(intptr_t)LazyResolverFn) {
 170     // If we are getting the stub for an external function, we really want the
 171     // address of the stub in the GlobalAddressMap for the JIT, not the address
 172     // of the external function.
 173     TheJIT->updateGlobalMapping(F, Stub);
 174   }
 175
 176   DOUT << "JIT: Stub emitted at [" << Stub << "] for function '"
 177        << F->getName() << "'\n";
 178
 179   // Finally, keep track of the stub-to-Function mapping so that the
 180   // JITCompilerFn knows which function to compile!
 181   state.getStubToFunctionMap(locked)[Stub] = F;
 182   return Stub;
 183 }
 184
 185 /// getGlobalValueLazyPtr - Return a lazy pointer containing the specified
 186 /// GV address.
 187 void *JITResolver::getGlobalValueLazyPtr(GlobalValue *GV, void *GVAddress) {
 188   MutexGuard locked(TheJIT->lock);
 189
 190   // If we already have a stub for this global variable, recycle it.
 191   void *&LazyPtr = state.getGlobalToLazyPtrMap(locked)[GV];
 192   if (LazyPtr) return LazyPtr;
 193
 194   // Otherwise, codegen a new lazy pointer.
 195   LazyPtr = TheJIT->getJITInfo().emitGlobalValueLazyPtr(GV, GVAddress,
 196                                                     *TheJIT->getCodeEmitter());
 197
 198   DOUT << "JIT: Stub emitted at [" << LazyPtr << "] for GV '"
 199        << GV->getName() << "'\n";
 200
 201   return LazyPtr;
 202 }
 203
 204 /// getExternalFunctionStub - Return a stub for the function at the
 205 /// specified address, created lazily on demand.
 206 void *JITResolver::getExternalFunctionStub(void *FnAddr) {
 207   // If we already have a stub for this function, recycle it.
 208   void *&Stub = ExternalFnToStubMap[FnAddr];
 209   if (Stub) return Stub;
 210
 211   Stub = TheJIT->getJITInfo().emitFunctionStub(0, FnAddr,
 212                                                *TheJIT->getCodeEmitter());
 213
 214   DOUT << "JIT: Stub emitted at [" << Stub
 215        << "] for external function at '" << FnAddr << "'\n";
 216   return Stub;
 217 }
 218
 219 unsigned JITResolver::getGOTIndexForAddr(void* addr) {
 220   unsigned idx = revGOTMap[addr];
 221   if (!idx) {
 222     idx = ++nextGOTIndex;
 223     revGOTMap[addr] = idx;
 224     DOUT << "Adding GOT entry " << idx << " for addr " << addr << "\n";
 225   }
 226   return idx;
 227 }
 228
 229 /// JITCompilerFn - This function is called when a lazy compilation stub has
 230 /// been entered.  It looks up which function this stub corresponds to, compiles
 231 /// it if necessary, then returns the resultant function pointer.
 232 void *JITResolver::JITCompilerFn(void *Stub) {
 233   JITResolver &JR = *TheJITResolver;
 234
 235   MutexGuard locked(TheJIT->lock);
 236
 237   // The address given to us for the stub may not be exactly right, it might be
 238   // a little bit after the stub.  As such, use upper_bound to find it.
 239   std::map<void*, Function*>::iterator I =
 240     JR.state.getStubToFunctionMap(locked).upper_bound(Stub);
 241   assert(I != JR.state.getStubToFunctionMap(locked).begin() &&
 242          "This is not a known stub!");
 243   Function *F = (--I)->second;
 244
 245   // If we have already code generated the function, just return the address.
 246   void *Result = TheJIT->getPointerToGlobalIfAvailable(F);
 247
 248   if (!Result) {
 249     // Otherwise we don't have it, do lazy compilation now.
 250
 251     // If lazy compilation is disabled, emit a useful error message and abort.
 252     if (TheJIT->isLazyCompilationDisabled()) {
 253       cerr << "LLVM JIT requested to do lazy compilation of function '"
 254       << F->getName() << "' when lazy compiles are disabled!\n";
 255       abort();
 256     }
 257
 258     // We might like to remove the stub from the StubToFunction map.
 259     // We can't do that! Multiple threads could be stuck, waiting to acquire the
 260     // lock above. As soon as the 1st function finishes compiling the function,
 261     // the next one will be released, and needs to be able to find the function
 262     // it needs to call.
 263     //JR.state.getStubToFunctionMap(locked).erase(I);
 264
 265     DOUT << "JIT: Lazily resolving function '" << F->getName()
 266          << "' In stub ptr = " << Stub << " actual ptr = "
 267          << I->first << "\n";
 268
 269     Result = TheJIT->getPointerToFunction(F);
 270   }
 271
 272   // We don't need to reuse this stub in the future, as F is now compiled.
 273   JR.state.getFunctionToStubMap(locked).erase(F);
 274
 275   // FIXME: We could rewrite all references to this stub if we knew them.
 276
 277   // What we will do is set the compiled function address to map to the
 278   // same GOT entry as the stub so that later clients may update the GOT
 279   // if they see it still using the stub address.
 280   // Note: this is done so the Resolver doesn't have to manage GOT memory
 281   // Do this without allocating map space if the target isn't using a GOT
 282   if(JR.revGOTMap.find(Stub) != JR.revGOTMap.end())
 283     JR.revGOTMap[Result] = JR.revGOTMap[Stub];
 284
 285   return Result;
 286 }
 287
 288 //===----------------------------------------------------------------------===//
 289 // Function Index Support
 290
 291 // On MacOS we generate an index of currently JIT'd functions so that
 292 // performance tools can determine a symbol name and accurate code range for a
 293 // PC value.  Because performance tools are generally asynchronous, the code
 294 // below is written with the hope that it could be interrupted at any time and
 295 // have useful answers.  However, we don't go crazy with atomic operations, we
 296 // just do a "reasonable effort".
 297 #ifdef __APPLE__
 298 #define ENABLE_JIT_SYMBOL_TABLE 0
 299 #endif
 300
 301 /// JitSymbolEntry - Each function that is JIT compiled results in one of these
 302 /// being added to an array of symbols.  This indicates the name of the function
 303 /// as well as the address range it occupies.  This allows the client to map
 304 /// from a PC value to the name of the function.
 305 struct JitSymbolEntry {
 306   const char *FnName;   // FnName - a strdup'd string.
 307   void *FnStart;
 308   intptr_t FnSize;
 309 };
 310
 311
 312 struct JitSymbolTable {
 313   /// NextPtr - This forms a linked list of JitSymbolTable entries.  This
 314   /// pointer is not used right now, but might be used in the future.  Consider
 315   /// it reserved for future use.
 316   JitSymbolTable *NextPtr;
 317
 318   /// Symbols - This is an array of JitSymbolEntry entries.  Only the first
 319   /// 'NumSymbols' symbols are valid.
 320   JitSymbolEntry *Symbols;
 321
 322   /// NumSymbols - This indicates the number entries in the Symbols array that
 323   /// are valid.
 324   unsigned NumSymbols;
 325
 326   /// NumAllocated - This indicates the amount of space we have in the Symbols
 327   /// array.  This is a private field that should not be read by external tools.
 328   unsigned NumAllocated;
 329 };
 330
 331 #if ENABLE_JIT_SYMBOL_TABLE
 332 JitSymbolTable *__jitSymbolTable;
 333 #endif
 334
 335 static void AddFunctionToSymbolTable(const char *FnName,
 336                                      void *FnStart, intptr_t FnSize) {
 337   assert(FnName != 0 && FnStart != 0 && "Bad symbol to add");
 338   JitSymbolTable **SymTabPtrPtr = 0;
 339 #if !ENABLE_JIT_SYMBOL_TABLE
 340   return;
 341 #else
 342   SymTabPtrPtr = &__jitSymbolTable;
 343 #endif
 344
 345   // If this is the first entry in the symbol table, add the JitSymbolTable
 346   // index.
 347   if (*SymTabPtrPtr == 0) {
 348     JitSymbolTable *New = new JitSymbolTable();
 349     New->NextPtr = 0;
 350     New->Symbols = 0;
 351     New->NumSymbols = 0;
 352     New->NumAllocated = 0;
 353     *SymTabPtrPtr = New;
 354   }
 355
 356   JitSymbolTable *SymTabPtr = *SymTabPtrPtr;
 357
 358   // If we have space in the table, reallocate the table.
 359   if (SymTabPtr->NumSymbols >= SymTabPtr->NumAllocated) {
 360     // If we don't have space, reallocate the table.
 361     unsigned NewSize = std::max(64U, SymTabPtr->NumAllocated*2);
 362     JitSymbolEntry *NewSymbols = new JitSymbolEntry[NewSize];
 363     JitSymbolEntry *OldSymbols = SymTabPtr->Symbols;
 364
 365     // Copy the old entries over.
 366     memcpy(NewSymbols, OldSymbols,
 367            SymTabPtr->NumSymbols*sizeof(OldSymbols[0]));
 368
 369     // Swap the new symbols in, delete the old ones.
 370     SymTabPtr->Symbols = NewSymbols;
 371     SymTabPtr->NumAllocated = NewSize;
 372     delete [] OldSymbols;
 373   }
 374
 375   // Otherwise, we have enough space, just tack it onto the end of the array.
 376   JitSymbolEntry &Entry = SymTabPtr->Symbols[SymTabPtr->NumSymbols];
 377   Entry.FnName = strdup(FnName);
 378   Entry.FnStart = FnStart;
 379   Entry.FnSize = FnSize;
 380   ++SymTabPtr->NumSymbols;
 381 }
 382
 383 static void RemoveFunctionFromSymbolTable(void *FnStart) {
 384   assert(FnStart && "Invalid function pointer");
 385   JitSymbolTable **SymTabPtrPtr = 0;
 386 #if !ENABLE_JIT_SYMBOL_TABLE
 387   return;
 388 #else
 389   SymTabPtrPtr = &__jitSymbolTable;
 390 #endif
 391
 392   JitSymbolTable *SymTabPtr = *SymTabPtrPtr;
 393   JitSymbolEntry *Symbols = SymTabPtr->Symbols;
 394
 395   // Scan the table to find its index.  The table is not sorted, so do a linear
 396   // scan.
 397   unsigned Index;
 398   for (Index = 0; Symbols[Index].FnStart != FnStart; ++Index)
 399     assert(Index != SymTabPtr->NumSymbols && "Didn't find function!");
 400
 401   // Once we have an index, we know to nuke this entry, overwrite it with the
 402   // entry at the end of the array, making the last entry redundant.
 403   const char *OldName = Symbols[Index].FnName;
 404   Symbols[Index] = Symbols[SymTabPtr->NumSymbols-1];
 405   free((void*)OldName);
 406
 407   // Drop the number of symbols in the table.
 408   --SymTabPtr->NumSymbols;
 409
 410   // Finally, if we deleted the final symbol, deallocate the table itself.
 411   if (SymTabPtr->NumSymbols != 0)
 412     return;
 413
 414   *SymTabPtrPtr = 0;
 415   delete [] Symbols;
 416   delete SymTabPtr;
 417 }
 418
 419 //===----------------------------------------------------------------------===//
 420 // JITEmitter code.
 421 //
 422 namespace {
 423   /// JITEmitter - The JIT implementation of the MachineCodeEmitter, which is
 424   /// used to output functions to memory for execution.
 425   class JITEmitter : public MachineCodeEmitter {
 426     JITMemoryManager *MemMgr;
 427
 428     // When outputting a function stub in the context of some other function, we
 429     // save BufferBegin/BufferEnd/CurBufferPtr here.
 430     unsigned char *SavedBufferBegin, *SavedBufferEnd, *SavedCurBufferPtr;
 431
 432     /// Relocations - These are the relocations that the function needs, as
 433     /// emitted.
 434     std::vector<MachineRelocation> Relocations;
 435
 436     /// MBBLocations - This vector is a mapping from MBB ID's to their address.
 437     /// It is filled in by the StartMachineBasicBlock callback and queried by
 438     /// the getMachineBasicBlockAddress callback.
 439     std::vector<intptr_t> MBBLocations;
 440
 441     /// ConstantPool - The constant pool for the current function.
 442     ///
 443     MachineConstantPool *ConstantPool;
 444
 445     /// ConstantPoolBase - A pointer to the first entry in the constant pool.
 446     ///
 447     void *ConstantPoolBase;
 448
 449     /// JumpTable - The jump tables for the current function.
 450     ///
 451     MachineJumpTableInfo *JumpTable;
 452
 453     /// JumpTableBase - A pointer to the first entry in the jump table.
 454     ///
 455     void *JumpTableBase;
 456
 457     /// Resolver - This contains info about the currently resolved functions.
 458     JITResolver Resolver;
 459
 460     /// DE - The dwarf emitter for the jit.
 461     JITDwarfEmitter *DE;
 462
 463     /// LabelLocations - This vector is a mapping from Label ID's to their
 464     /// address.
 465     std::vector<intptr_t> LabelLocations;
 466
 467     /// MMI - Machine module info for exception informations
 468     MachineModuleInfo* MMI;
 469
 470   public:
 471     JITEmitter(JIT &jit, JITMemoryManager *JMM) : Resolver(jit) {
 472       MemMgr = JMM ? JMM : JITMemoryManager::CreateDefaultMemManager();
 473       if (jit.getJITInfo().needsGOT()) {
 474         MemMgr->AllocateGOT();
 475         DOUT << "JIT is managing a GOT\n";
 476       }
 477
 478       if (ExceptionHandling) DE = new JITDwarfEmitter(jit);
 479     }
 480     ~JITEmitter() {
 481       delete MemMgr;
 482       if (ExceptionHandling) delete DE;
 483     }
 484
 485     JITResolver &getJITResolver() { return Resolver; }
 486
 487     virtual void startFunction(MachineFunction &F);
 488     virtual bool finishFunction(MachineFunction &F);
 489
 490     void emitConstantPool(MachineConstantPool *MCP);
 491     void initJumpTableInfo(MachineJumpTableInfo *MJTI);
 492     void emitJumpTableInfo(MachineJumpTableInfo *MJTI);
 493
 494     virtual void startFunctionStub(const GlobalValue* F, unsigned StubSize,
 495                                    unsigned Alignment = 1);
 496     virtual void* finishFunctionStub(const GlobalValue *F);
 497
 498     virtual void addRelocation(const MachineRelocation &MR) {
 499       Relocations.push_back(MR);
 500     }
 501
 502     virtual void StartMachineBasicBlock(MachineBasicBlock *MBB) {
 503       if (MBBLocations.size() <= (unsigned)MBB->getNumber())
 504         MBBLocations.resize((MBB->getNumber()+1)*2);
 505       MBBLocations[MBB->getNumber()] = getCurrentPCValue();
 506     }
 507
 508     virtual intptr_t getConstantPoolEntryAddress(unsigned Entry) const;
 509     virtual intptr_t getJumpTableEntryAddress(unsigned Entry) const;
 510
 511     virtual intptr_t getMachineBasicBlockAddress(MachineBasicBlock *MBB) const {
 512       assert(MBBLocations.size() > (unsigned)MBB->getNumber() &&
 513              MBBLocations[MBB->getNumber()] && "MBB not emitted!");
 514       return MBBLocations[MBB->getNumber()];
 515     }
 516
 517     /// deallocateMemForFunction - Deallocate all memory for the specified
 518     /// function body.
 519     void deallocateMemForFunction(Function *F) {
 520       MemMgr->deallocateMemForFunction(F);
 521     }
 522
 523     virtual void emitLabel(uint64_t LabelID) {
 524       if (LabelLocations.size() <= LabelID)
 525         LabelLocations.resize((LabelID+1)*2);
 526       LabelLocations[LabelID] = getCurrentPCValue();
 527     }
 528
 529     virtual intptr_t getLabelAddress(uint64_t LabelID) const {
 530       assert(LabelLocations.size() > (unsigned)LabelID &&
 531              LabelLocations[LabelID] && "Label not emitted!");
 532       return LabelLocations[LabelID];
 533     }
 534
 535     virtual void setModuleInfo(MachineModuleInfo* Info) {
 536       MMI = Info;
 537       if (ExceptionHandling) DE->setModuleInfo(Info);
 538     }
 539
 540   private:
 541     void *getPointerToGlobal(GlobalValue *GV, void *Reference, bool NoNeedStub);
 542     void *getPointerToGVLazyPtr(GlobalValue *V, void *Reference,
 543                                 bool NoNeedStub);
 544   };
 545 }
 546
 547 void *JITEmitter::getPointerToGlobal(GlobalValue *V, void *Reference,
 548                                      bool DoesntNeedStub) {
 549   if (GlobalVariable *GV = dyn_cast<GlobalVariable>(V)) {
 550     /// FIXME: If we straightened things out, this could actually emit the
 551     /// global immediately instead of queuing it for codegen later!
 552     return TheJIT->getOrEmitGlobalVariable(GV);
 553   }
 554   if (GlobalAlias *GA = dyn_cast<GlobalAlias>(V))
 555     return TheJIT->getPointerToGlobal(GA->resolveAliasedGlobal());
 556
 557   // If we have already compiled the function, return a pointer to its body.
 558   Function *F = cast<Function>(V);
 559   void *ResultPtr = TheJIT->getPointerToGlobalIfAvailable(F);
 560   if (ResultPtr) return ResultPtr;
 561
 562   if (F->isDeclaration() && !F->hasNotBeenReadFromBitcode()) {
 563     // If this is an external function pointer, we can force the JIT to
 564     // 'compile' it, which really just adds it to the map.
 565     if (DoesntNeedStub)
 566       return TheJIT->getPointerToFunction(F);
 567
 568     return Resolver.getFunctionStub(F);
 569   }
 570
 571   // Okay, the function has not been compiled yet, if the target callback
 572   // mechanism is capable of rewriting the instruction directly, prefer to do
 573   // that instead of emitting a stub.
 574   if (DoesntNeedStub)
 575     return Resolver.AddCallbackAtLocation(F, Reference);
 576
 577   // Otherwise, we have to emit a lazy resolving stub.
 578   return Resolver.getFunctionStub(F);
 579 }
 580
 581 void *JITEmitter::getPointerToGVLazyPtr(GlobalValue *V, void *Reference,
 582                                         bool DoesntNeedStub) {
 583   // Make sure GV is emitted first.
 584   // FIXME: For now, if the GV is an external function we force the JIT to
 585   // compile it so the lazy pointer will contain the fully resolved address.
 586   void *GVAddress = getPointerToGlobal(V, Reference, true);
 587   return Resolver.getGlobalValueLazyPtr(V, GVAddress);
 588 }
 589
 590 static unsigned GetConstantPoolSizeInBytes(MachineConstantPool *MCP) {
 591   const std::vector<MachineConstantPoolEntry> &Constants = MCP->getConstants();
 592   if (Constants.empty()) return 0;
 593
 594   MachineConstantPoolEntry CPE = Constants.back();
 595   unsigned Size = CPE.Offset;
 596   const Type *Ty = CPE.isMachineConstantPoolEntry()
 597     ? CPE.Val.MachineCPVal->getType() : CPE.Val.ConstVal->getType();
 598   Size += TheJIT->getTargetData()->getABITypeSize(Ty);
 599   return Size;
 600 }
 601
 602 static unsigned GetJumpTableSizeInBytes(MachineJumpTableInfo *MJTI) {
 603   const std::vector<MachineJumpTableEntry> &JT = MJTI->getJumpTables();
 604   if (JT.empty()) return 0;
 605
 606   unsigned NumEntries = 0;
 607   for (unsigned i = 0, e = JT.size(); i != e; ++i)
 608     NumEntries += JT[i].MBBs.size();
 609
 610   unsigned EntrySize = MJTI->getEntrySize();
 611
 612   return NumEntries * EntrySize;
 613 }
 614
 615 static uintptr_t RoundUpToAlign(uintptr_t Size, unsigned Alignment) {
 616   if (Alignment == 0) Alignment = 1;
 617   // Since we do not know where the buffer will be allocated, be pessimistic.
 618   return Size + Alignment;
 619 }
 620
 621 void JITEmitter::startFunction(MachineFunction &F) {
 622   uintptr_t ActualSize = 0;
 623   if (MemMgr->NeedsExactSize()) {
 624     const TargetInstrInfo* TII = F.getTarget().getInstrInfo();
 625     MachineJumpTableInfo *MJTI = F.getJumpTableInfo();
 626     MachineConstantPool *MCP = F.getConstantPool();
 627
 628     // Ensure the constant pool/jump table info is at least 4-byte aligned.
 629     ActualSize = RoundUpToAlign(ActualSize, 16);
 630
 631     // Add the alignment of the constant pool
 632     ActualSize = RoundUpToAlign(ActualSize,
 633                                 1 << MCP->getConstantPoolAlignment());
 634
 635     // Add the constant pool size
 636     ActualSize += GetConstantPoolSizeInBytes(MCP);
 637
 638     // Add the aligment of the jump table info
 639     ActualSize = RoundUpToAlign(ActualSize, MJTI->getAlignment());
 640
 641     // Add the jump table size
 642     ActualSize += GetJumpTableSizeInBytes(MJTI);
 643
 644     // Add the alignment for the function
 645     ActualSize = RoundUpToAlign(ActualSize,
 646                                 std::max(F.getFunction()->getAlignment(), 8U));
 647
 648     // Add the function size
 649     ActualSize += TII->GetFunctionSizeInBytes(F);
 650   }
 651
 652   BufferBegin = CurBufferPtr = MemMgr->startFunctionBody(F.getFunction(),
 653                                                          ActualSize);
 654   BufferEnd = BufferBegin+ActualSize;
 655
 656   // Ensure the constant pool/jump table info is at least 4-byte aligned.
 657   emitAlignment(16);
 658
 659   emitConstantPool(F.getConstantPool());
 660   initJumpTableInfo(F.getJumpTableInfo());
 661
 662   // About to start emitting the machine code for the function.
 663   emitAlignment(std::max(F.getFunction()->getAlignment(), 8U));
 664   TheJIT->updateGlobalMapping(F.getFunction(), CurBufferPtr);
 665
 666   MBBLocations.clear();
 667 }
 668
 669 bool JITEmitter::finishFunction(MachineFunction &F) {
 670   if (CurBufferPtr == BufferEnd) {
 671     // FIXME: Allocate more space, then try again.
 672     cerr << "JIT: Ran out of space for generated machine code!\n";
 673     abort();
 674   }
 675
 676   emitJumpTableInfo(F.getJumpTableInfo());
 677
 678   // FnStart is the start of the text, not the start of the constant pool and
 679   // other per-function data.
 680   unsigned char *FnStart =
 681     (unsigned char *)TheJIT->getPointerToGlobalIfAvailable(F.getFunction());
 682   unsigned char *FnEnd   = CurBufferPtr;
 683
 684   MemMgr->endFunctionBody(F.getFunction(), BufferBegin, FnEnd);
 685   NumBytes += FnEnd-FnStart;
 686
 687   if (!Relocations.empty()) {
 688     NumRelos += Relocations.size();
 689
 690     // Resolve the relocations to concrete pointers.
 691     for (unsigned i = 0, e = Relocations.size(); i != e; ++i) {
 692       MachineRelocation &MR = Relocations[i];
 693       void *ResultPtr;
 694       if (MR.isString()) {
 695         ResultPtr = TheJIT->getPointerToNamedFunction(MR.getString());
 696
 697         // If the target REALLY wants a stub for this function, emit it now.
 698         if (!MR.doesntNeedStub())
 699           ResultPtr = Resolver.getExternalFunctionStub(ResultPtr);
 700       } else if (MR.isGlobalValue()) {
 701         ResultPtr = getPointerToGlobal(MR.getGlobalValue(),
 702                                        BufferBegin+MR.getMachineCodeOffset(),
 703                                        MR.doesntNeedStub());
 704       } else if (MR.isGlobalValueLazyPtr()) {
 705         ResultPtr = getPointerToGVLazyPtr(MR.getGlobalValue(),
 706                                           BufferBegin+MR.getMachineCodeOffset(),
 707                                           MR.doesntNeedStub());
 708       } else if (MR.isBasicBlock()) {
 709         ResultPtr = (void*)getMachineBasicBlockAddress(MR.getBasicBlock());
 710       } else if (MR.isConstantPoolIndex()) {
 711         ResultPtr=(void*)getConstantPoolEntryAddress(MR.getConstantPoolIndex());
 712       } else {
 713         assert(MR.isJumpTableIndex());
 714         ResultPtr=(void*)getJumpTableEntryAddress(MR.getJumpTableIndex());
 715       }
 716
 717       MR.setResultPointer(ResultPtr);
 718
 719       // if we are managing the GOT and the relocation wants an index,
 720       // give it one
 721       if (MR.isGOTRelative() && MemMgr->isManagingGOT()) {
 722         unsigned idx = Resolver.getGOTIndexForAddr(ResultPtr);
 723         MR.setGOTIndex(idx);
 724         if (((void**)MemMgr->getGOTBase())[idx] != ResultPtr) {
 725           DOUT << "GOT was out of date for " << ResultPtr
 726                << " pointing at " << ((void**)MemMgr->getGOTBase())[idx]
 727                << "\n";
 728           ((void**)MemMgr->getGOTBase())[idx] = ResultPtr;
 729         }
 730       }
 731     }
 732
 733     TheJIT->getJITInfo().relocate(BufferBegin, &Relocations[0],
 734                                   Relocations.size(), MemMgr->getGOTBase());
 735   }
 736
 737   // Update the GOT entry for F to point to the new code.
 738   if (MemMgr->isManagingGOT()) {
 739     unsigned idx = Resolver.getGOTIndexForAddr((void*)BufferBegin);
 740     if (((void**)MemMgr->getGOTBase())[idx] != (void*)BufferBegin) {
 741       DOUT << "GOT was out of date for " << (void*)BufferBegin
 742            << " pointing at " << ((void**)MemMgr->getGOTBase())[idx] << "\n";
 743       ((void**)MemMgr->getGOTBase())[idx] = (void*)BufferBegin;
 744     }
 745   }
 746
 747   // Invalidate the icache if necessary.
 748   sys::Memory::InvalidateInstructionCache(FnStart, FnEnd-FnStart);
 749
 750   // Add it to the JIT symbol table if the host wants it.
 751   AddFunctionToSymbolTable(F.getFunction()->getNameStart(),
 752                            FnStart, FnEnd-FnStart);
 753
 754   DOUT << "JIT: Finished CodeGen of [" << (void*)FnStart
 755        << "] Function: " << F.getFunction()->getName()
 756        << ": " << (FnEnd-FnStart) << " bytes of text, "
 757        << Relocations.size() << " relocations\n";
 758   Relocations.clear();
 759
 760 #ifndef NDEBUG
 761   if (sys::hasDisassembler())
 762     DOUT << "Disassembled code:\n"
 763          << sys::disassembleBuffer(FnStart, FnEnd-FnStart, (uintptr_t)FnStart);
 764 #endif
 765   if (ExceptionHandling) {
 766     uintptr_t ActualSize = 0;
 767     SavedBufferBegin = BufferBegin;
 768     SavedBufferEnd = BufferEnd;
 769     SavedCurBufferPtr = CurBufferPtr;
 770
 771     if (MemMgr->NeedsExactSize()) {
 772       ActualSize = DE->GetDwarfTableSizeInBytes(F, *this, FnStart, FnEnd);
 773     }
 774
 775     BufferBegin = CurBufferPtr = MemMgr->startExceptionTable(F.getFunction(),
 776                                                              ActualSize);
 777     BufferEnd = BufferBegin+ActualSize;
 778     unsigned char* FrameRegister = DE->EmitDwarfTable(F, *this, FnStart, FnEnd);
 779     MemMgr->endExceptionTable(F.getFunction(), BufferBegin, CurBufferPtr,
 780                               FrameRegister);
 781     BufferBegin = SavedBufferBegin;
 782     BufferEnd = SavedBufferEnd;
 783     CurBufferPtr = SavedCurBufferPtr;
 784
 785     TheJIT->RegisterTable(FrameRegister);
 786   }
 787   MMI->EndFunction();
 788
 789   return false;
 790 }
 791
 792 void JITEmitter::emitConstantPool(MachineConstantPool *MCP) {
 793   const std::vector<MachineConstantPoolEntry> &Constants = MCP->getConstants();
 794   if (Constants.empty()) return;
 795
 796   MachineConstantPoolEntry CPE = Constants.back();
 797   unsigned Size = CPE.Offset;
 798   const Type *Ty = CPE.isMachineConstantPoolEntry()
 799     ? CPE.Val.MachineCPVal->getType() : CPE.Val.ConstVal->getType();
 800   Size += TheJIT->getTargetData()->getABITypeSize(Ty);
 801
 802   unsigned Align = 1 << MCP->getConstantPoolAlignment();
 803   ConstantPoolBase = allocateSpace(Size, Align);
 804   ConstantPool = MCP;
 805
 806   if (ConstantPoolBase == 0) return;  // Buffer overflow.
 807
 808   DOUT << "JIT: Emitted constant pool at [" << ConstantPoolBase
 809        << "] (size: " << Size << ", alignment: " << Align << ")\n";
 810
 811   // Initialize the memory for all of the constant pool entries.
 812   for (unsigned i = 0, e = Constants.size(); i != e; ++i) {
 813     void *CAddr = (char*)ConstantPoolBase+Constants[i].Offset;
 814     if (Constants[i].isMachineConstantPoolEntry()) {
 815       // FIXME: add support to lower machine constant pool values into bytes!
 816       cerr << "Initialize memory with machine specific constant pool entry"
 817            << " has not been implemented!\n";
 818       abort();
 819     }
 820     TheJIT->InitializeMemory(Constants[i].Val.ConstVal, CAddr);
 821     DOUT << "JIT:   CP" << i << " at [" << CAddr << "]\n";
 822   }
 823 }
 824
 825 void JITEmitter::initJumpTableInfo(MachineJumpTableInfo *MJTI) {
 826   const std::vector<MachineJumpTableEntry> &JT = MJTI->getJumpTables();
 827   if (JT.empty()) return;
 828
 829   unsigned NumEntries = 0;
 830   for (unsigned i = 0, e = JT.size(); i != e; ++i)
 831     NumEntries += JT[i].MBBs.size();
 832
 833   unsigned EntrySize = MJTI->getEntrySize();
 834
 835   // Just allocate space for all the jump tables now.  We will fix up the actual
 836   // MBB entries in the tables after we emit the code for each block, since then
 837   // we will know the final locations of the MBBs in memory.
 838   JumpTable = MJTI;
 839   JumpTableBase = allocateSpace(NumEntries * EntrySize, MJTI->getAlignment());
 840 }
 841
 842 void JITEmitter::emitJumpTableInfo(MachineJumpTableInfo *MJTI) {
 843   const std::vector<MachineJumpTableEntry> &JT = MJTI->getJumpTables();
 844   if (JT.empty() || JumpTableBase == 0) return;
 845
 846   if (TargetMachine::getRelocationModel() == Reloc::PIC_) {
 847     assert(MJTI->getEntrySize() == 4 && "Cross JIT'ing?");
 848     // For each jump table, place the offset from the beginning of the table
 849     // to the target address.
 850     int *SlotPtr = (int*)JumpTableBase;
 851
 852     for (unsigned i = 0, e = JT.size(); i != e; ++i) {
 853       const std::vector<MachineBasicBlock*> &MBBs = JT[i].MBBs;
 854       // Store the offset of the basic block for this jump table slot in the
 855       // memory we allocated for the jump table in 'initJumpTableInfo'
 856       intptr_t Base = (intptr_t)SlotPtr;
 857       for (unsigned mi = 0, me = MBBs.size(); mi != me; ++mi) {
 858         intptr_t MBBAddr = getMachineBasicBlockAddress(MBBs[mi]);
 859         *SlotPtr++ = TheJIT->getJITInfo().getPICJumpTableEntry(MBBAddr, Base);
 860       }
 861     }
 862   } else {
 863     assert(MJTI->getEntrySize() == sizeof(void*) && "Cross JIT'ing?");
 864
 865     // For each jump table, map each target in the jump table to the address of
 866     // an emitted MachineBasicBlock.
 867     intptr_t *SlotPtr = (intptr_t*)JumpTableBase;
 868
 869     for (unsigned i = 0, e = JT.size(); i != e; ++i) {
 870       const std::vector<MachineBasicBlock*> &MBBs = JT[i].MBBs;
 871       // Store the address of the basic block for this jump table slot in the
 872       // memory we allocated for the jump table in 'initJumpTableInfo'
 873       for (unsigned mi = 0, me = MBBs.size(); mi != me; ++mi)
 874         *SlotPtr++ = getMachineBasicBlockAddress(MBBs[mi]);
 875     }
 876   }
 877 }
 878
 879 void JITEmitter::startFunctionStub(const GlobalValue* F, unsigned StubSize,
 880                                    unsigned Alignment) {
 881   SavedBufferBegin = BufferBegin;
 882   SavedBufferEnd = BufferEnd;
 883   SavedCurBufferPtr = CurBufferPtr;
 884
 885   BufferBegin = CurBufferPtr = MemMgr->allocateStub(F, StubSize, Alignment);
 886   BufferEnd = BufferBegin+StubSize+1;
 887 }
 888
 889 void *JITEmitter::finishFunctionStub(const GlobalValue* F) {
 890   NumBytes += getCurrentPCOffset();
 891   std::swap(SavedBufferBegin, BufferBegin);
 892   BufferEnd = SavedBufferEnd;
 893   CurBufferPtr = SavedCurBufferPtr;
 894   return SavedBufferBegin;
 895 }
 896
 897 // getConstantPoolEntryAddress - Return the address of the 'ConstantNum' entry
 898 // in the constant pool that was last emitted with the 'emitConstantPool'
 899 // method.
 900 //
 901 intptr_t JITEmitter::getConstantPoolEntryAddress(unsigned ConstantNum) const {
 902   assert(ConstantNum < ConstantPool->getConstants().size() &&
 903          "Invalid ConstantPoolIndex!");
 904   return (intptr_t)ConstantPoolBase +
 905          ConstantPool->getConstants()[ConstantNum].Offset;
 906 }
 907
 908 // getJumpTableEntryAddress - Return the address of the JumpTable with index
 909 // 'Index' in the jumpp table that was last initialized with 'initJumpTableInfo'
 910 //
 911 intptr_t JITEmitter::getJumpTableEntryAddress(unsigned Index) const {
 912   const std::vector<MachineJumpTableEntry> &JT = JumpTable->getJumpTables();
 913   assert(Index < JT.size() && "Invalid jump table index!");
 914
 915   unsigned Offset = 0;
 916   unsigned EntrySize = JumpTable->getEntrySize();
 917
 918   for (unsigned i = 0; i < Index; ++i)
 919     Offset += JT[i].MBBs.size();
 920
 921    Offset *= EntrySize;
 922
 923   return (intptr_t)((char *)JumpTableBase + Offset);
 924 }
 925
 926 //===----------------------------------------------------------------------===//
 927 //  Public interface to this file
 928 //===----------------------------------------------------------------------===//
 929
 930 MachineCodeEmitter *JIT::createEmitter(JIT &jit, JITMemoryManager *JMM) {
 931   return new JITEmitter(jit, JMM);
 932 }
 933
 934 // getPointerToNamedFunction - This function is used as a global wrapper to
 935 // JIT::getPointerToNamedFunction for the purpose of resolving symbols when
 936 // bugpoint is debugging the JIT. In that scenario, we are loading an .so and
 937 // need to resolve function(s) that are being mis-codegenerated, so we need to
 938 // resolve their addresses at runtime, and this is the way to do it.
 939 extern "C" {
 940   void *getPointerToNamedFunction(const char *Name) {
 941     if (Function *F = TheJIT->FindFunctionNamed(Name))
 942       return TheJIT->getPointerToFunction(F);
 943     return TheJIT->getPointerToNamedFunction(Name);
 944   }
 945 }
 946
 947 // getPointerToFunctionOrStub - If the specified function has been
 948 // code-gen'd, return a pointer to the function.  If not, compile it, or use
 949 // a stub to implement lazy compilation if available.
 950 //
 951 void *JIT::getPointerToFunctionOrStub(Function *F) {
 952   // If we have already code generated the function, just return the address.
 953   if (void *Addr = getPointerToGlobalIfAvailable(F))
 954     return Addr;
 955
 956   // Get a stub if the target supports it.
 957   assert(dynamic_cast<JITEmitter*>(MCE) && "Unexpected MCE?");
 958   JITEmitter *JE = static_cast<JITEmitter*>(getCodeEmitter());
 959   return JE->getJITResolver().getFunctionStub(F);
 960 }
 961
 962 /// freeMachineCodeForFunction - release machine code memory for given Function.
 963 ///
 964 void JIT::freeMachineCodeForFunction(Function *F) {
 965
 966   // Delete translation for this from the ExecutionEngine, so it will get
 967   // retranslated next time it is used.
 968   void *OldPtr = updateGlobalMapping(F, 0);
 969
 970   if (OldPtr)
 971     RemoveFunctionFromSymbolTable(OldPtr);
 972
 973   // Free the actual memory for the function body and related stuff.
 974   assert(dynamic_cast<JITEmitter*>(MCE) && "Unexpected MCE?");
 975   static_cast<JITEmitter*>(MCE)->deallocateMemForFunction(F);
 976 }
 977