/3rd_party/llvm/lib/ExecutionEngine/JIT/JIT.cpp

  1//===-- JIT.cpp - LLVM Just in Time Compiler ------------------------------===//
  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 tool implements a just-in-time compiler for LLVM, allowing direct
 11// execution of LLVM bitcode in an efficient manner.
 12//
 13//===----------------------------------------------------------------------===//
 14
 15#include "JIT.h"
 16#include "llvm/ADT/SmallPtrSet.h"
 17#include "llvm/CodeGen/JITCodeEmitter.h"
 18#include "llvm/CodeGen/MachineCodeInfo.h"
 19#include "llvm/Config/config.h"
 20#include "llvm/ExecutionEngine/GenericValue.h"
 21#include "llvm/ExecutionEngine/JITEventListener.h"
 22#include "llvm/ExecutionEngine/JITMemoryManager.h"
 23#include "llvm/IR/Constants.h"
 24#include "llvm/IR/DataLayout.h"
 25#include "llvm/IR/DerivedTypes.h"
 26#include "llvm/IR/Function.h"
 27#include "llvm/IR/GlobalVariable.h"
 28#include "llvm/IR/Instructions.h"
 29#include "llvm/Support/Dwarf.h"
 30#include "llvm/Support/DynamicLibrary.h"
 31#include "llvm/Support/ErrorHandling.h"
 32#include "llvm/Support/ManagedStatic.h"
 33#include "llvm/Support/MutexGuard.h"
 34#include "llvm/Target/TargetJITInfo.h"
 35#include "llvm/Target/TargetMachine.h"
 36
 37using namespace llvm;
 38
 39#ifdef __APPLE__
 40// Apple gcc defaults to -fuse-cxa-atexit (i.e. calls __cxa_atexit instead
 41// of atexit). It passes the address of linker generated symbol __dso_handle
 42// to the function.
 43// This configuration change happened at version 5330.
 44# include <AvailabilityMacros.h>
 45# if defined(MAC_OS_X_VERSION_10_4) && \
 46     ((MAC_OS_X_VERSION_MIN_REQUIRED > MAC_OS_X_VERSION_10_4) || \
 47      (MAC_OS_X_VERSION_MIN_REQUIRED == MAC_OS_X_VERSION_10_4 && \
 48       __APPLE_CC__ >= 5330))
 49#  ifndef HAVE___DSO_HANDLE
 50#   define HAVE___DSO_HANDLE 1
 51#  endif
 52# endif
 53#endif
 54
 55#if HAVE___DSO_HANDLE
 56extern void *__dso_handle __attribute__ ((__visibility__ ("hidden")));
 57#endif
 58
 59namespace {
 60
 61static struct RegisterJIT {
 62  RegisterJIT() { JIT::Register(); }
 63} JITRegistrator;
 64
 65}
 66
 67extern "C" void LLVMLinkInJIT() {
 68}
 69
 70/// createJIT - This is the factory method for creating a JIT for the current
 71/// machine, it does not fall back to the interpreter.  This takes ownership
 72/// of the module.
 73ExecutionEngine *JIT::createJIT(Module *M,
 74                                std::string *ErrorStr,
 75                                JITMemoryManager *JMM,
 76                                bool GVsWithCode,
 77                                TargetMachine *TM) {
 78  // Try to register the program as a source of symbols to resolve against.
 79  //
 80  // FIXME: Don't do this here.
 81  sys::DynamicLibrary::LoadLibraryPermanently(0, NULL);
 82
 83  // If the target supports JIT code generation, create the JIT.
 84  if (TargetJITInfo *TJ = TM->getJITInfo()) {
 85    return new JIT(M, *TM, *TJ, JMM, GVsWithCode);
 86  } else {
 87    if (ErrorStr)
 88      *ErrorStr = "target does not support JIT code generation";
 89    return 0;
 90  }
 91}
 92
 93namespace {
 94/// This class supports the global getPointerToNamedFunction(), which allows
 95/// bugpoint or gdb users to search for a function by name without any context.
 96class JitPool {
 97  SmallPtrSet<JIT*, 1> JITs;  // Optimize for process containing just 1 JIT.
 98  mutable sys::Mutex Lock;
 99public:
100  void Add(JIT *jit) {
101    MutexGuard guard(Lock);
102    JITs.insert(jit);
103  }
104  void Remove(JIT *jit) {
105    MutexGuard guard(Lock);
106    JITs.erase(jit);
107  }
108  void *getPointerToNamedFunction(const char *Name) const {
109    MutexGuard guard(Lock);
110    assert(JITs.size() != 0 && "No Jit registered");
111    //search function in every instance of JIT
112    for (SmallPtrSet<JIT*, 1>::const_iterator Jit = JITs.begin(),
113           end = JITs.end();
114         Jit != end; ++Jit) {
115      if (Function *F = (*Jit)->FindFunctionNamed(Name))
116        return (*Jit)->getPointerToFunction(F);
117    }
118    // The function is not available : fallback on the first created (will
119    // search in symbol of the current program/library)
120    return (*JITs.begin())->getPointerToNamedFunction(Name);
121  }
122};
123ManagedStatic<JitPool> AllJits;
124}
125extern "C" {
126  // getPointerToNamedFunction - This function is used as a global wrapper to
127  // JIT::getPointerToNamedFunction for the purpose of resolving symbols when
128  // bugpoint is debugging the JIT. In that scenario, we are loading an .so and
129  // need to resolve function(s) that are being mis-codegenerated, so we need to
130  // resolve their addresses at runtime, and this is the way to do it.
131  void *getPointerToNamedFunction(const char *Name) {
132    return AllJits->getPointerToNamedFunction(Name);
133  }
134}
135
136JIT::JIT(Module *M, TargetMachine &tm, TargetJITInfo &tji,
137         JITMemoryManager *jmm, bool GVsWithCode)
138  : ExecutionEngine(M), TM(tm), TJI(tji),
139    JMM(jmm ? jmm : JITMemoryManager::CreateDefaultMemManager()),
140    AllocateGVsWithCode(GVsWithCode), isAlreadyCodeGenerating(false) {
141  setDataLayout(TM.getDataLayout());
142
143  jitstate = new JITState(M);
144
145  // Initialize JCE
146  JCE = createEmitter(*this, JMM, TM);
147
148  // Register in global list of all JITs.
149  AllJits->Add(this);
150
151  // Add target data
152  MutexGuard locked(lock);
153  FunctionPassManager &PM = jitstate->getPM(locked);
154  PM.add(new DataLayout(*TM.getDataLayout()));
155
156  // Turn the machine code intermediate representation into bytes in memory that
157  // may be executed.
158  if (TM.addPassesToEmitMachineCode(PM, *JCE)) {
159    report_fatal_error("Target does not support machine code emission!");
160  }
161
162  // Initialize passes.
163  PM.doInitialization();
164}
165
166JIT::~JIT() {
167  // Cleanup.
168  AllJits->Remove(this);
169  delete jitstate;
170  delete JCE;
171  // JMM is a ownership of JCE, so we no need delete JMM here.
172  delete &TM;
173}
174
175/// addModule - Add a new Module to the JIT.  If we previously removed the last
176/// Module, we need re-initialize jitstate with a valid Module.
177void JIT::addModule(Module *M) {
178  MutexGuard locked(lock);
179
180  if (Modules.empty()) {
181    assert(!jitstate && "jitstate should be NULL if Modules vector is empty!");
182
183    jitstate = new JITState(M);
184
185    FunctionPassManager &PM = jitstate->getPM(locked);
186    PM.add(new DataLayout(*TM.getDataLayout()));
187
188    // Turn the machine code intermediate representation into bytes in memory
189    // that may be executed.
190    if (TM.addPassesToEmitMachineCode(PM, *JCE)) {
191      report_fatal_error("Target does not support machine code emission!");
192    }
193
194    // Initialize passes.
195    PM.doInitialization();
196  }
197
198  ExecutionEngine::addModule(M);
199}
200
201/// removeModule - If we are removing the last Module, invalidate the jitstate
202/// since the PassManager it contains references a released Module.
203bool JIT::removeModule(Module *M) {
204  bool result = ExecutionEngine::removeModule(M);
205
206  MutexGuard locked(lock);
207
208  if (jitstate && jitstate->getModule() == M) {
209    delete jitstate;
210    jitstate = 0;
211  }
212
213  if (!jitstate && !Modules.empty()) {
214    jitstate = new JITState(Modules[0]);
215
216    FunctionPassManager &PM = jitstate->getPM(locked);
217    PM.add(new DataLayout(*TM.getDataLayout()));
218
219    // Turn the machine code intermediate representation into bytes in memory
220    // that may be executed.
221    if (TM.addPassesToEmitMachineCode(PM, *JCE)) {
222      report_fatal_error("Target does not support machine code emission!");
223    }
224
225    // Initialize passes.
226    PM.doInitialization();
227  }
228  return result;
229}
230
231/// run - Start execution with the specified function and arguments.
232///
233GenericValue JIT::runFunction(Function *F,
234                              const std::vector<GenericValue> &ArgValues) {
235  assert(F && "Function *F was null at entry to run()");
236
237  void *FPtr = getPointerToFunction(F);
238  assert(FPtr && "Pointer to fn's code was null after getPointerToFunction");
239  FunctionType *FTy = F->getFunctionType();
240  Type *RetTy = FTy->getReturnType();
241
242  assert((FTy->getNumParams() == ArgValues.size() ||
243          (FTy->isVarArg() && FTy->getNumParams() <= ArgValues.size())) &&
244         "Wrong number of arguments passed into function!");
245  assert(FTy->getNumParams() == ArgValues.size() &&
246         "This doesn't support passing arguments through varargs (yet)!");
247
248  // Handle some common cases first.  These cases correspond to common `main'
249  // prototypes.
250  if (RetTy->isIntegerTy(32) || RetTy->isVoidTy()) {
251    switch (ArgValues.size()) {
252    case 3:
253      if (FTy->getParamType(0)->isIntegerTy(32) &&
254          FTy->getParamType(1)->isPointerTy() &&
255          FTy->getParamType(2)->isPointerTy()) {
256        int (*PF)(int, char **, const char **) =
257          (int(*)(int, char **, const char **))(intptr_t)FPtr;
258
259        // Call the function.
260        GenericValue rv;
261        rv.IntVal = APInt(32, PF(ArgValues[0].IntVal.getZExtValue(),
262                                 (char **)GVTOP(ArgValues[1]),
263                                 (const char **)GVTOP(ArgValues[2])));
264        return rv;
265      }
266      break;
267    case 2:
268      if (FTy->getParamType(0)->isIntegerTy(32) &&
269          FTy->getParamType(1)->isPointerTy()) {
270        int (*PF)(int, char **) = (int(*)(int, char **))(intptr_t)FPtr;
271
272        // Call the function.
273        GenericValue rv;
274        rv.IntVal = APInt(32, PF(ArgValues[0].IntVal.getZExtValue(),
275                                 (char **)GVTOP(ArgValues[1])));
276        return rv;
277      }
278      break;
279    case 1:
280      if (FTy->getParamType(0)->isIntegerTy(32)) {
281        GenericValue rv;
282        int (*PF)(int) = (int(*)(int))(intptr_t)FPtr;
283        rv.IntVal = APInt(32, PF(ArgValues[0].IntVal.getZExtValue()));
284        return rv;
285      }
286      if (FTy->getParamType(0)->isPointerTy()) {
287        GenericValue rv;
288        int (*PF)(char *) = (int(*)(char *))(intptr_t)FPtr;
289        rv.IntVal = APInt(32, PF((char*)GVTOP(ArgValues[0])));
290        return rv;
291      }
292      break;
293    }
294  }
295
296  // Handle cases where no arguments are passed first.
297  if (ArgValues.empty()) {
298    GenericValue rv;
299    switch (RetTy->getTypeID()) {
300    default: llvm_unreachable("Unknown return type for function call!");
301    case Type::IntegerTyID: {
302      unsigned BitWidth = cast<IntegerType>(RetTy)->getBitWidth();
303      if (BitWidth == 1)
304        rv.IntVal = APInt(BitWidth, ((bool(*)())(intptr_t)FPtr)());
305      else if (BitWidth <= 8)
306        rv.IntVal = APInt(BitWidth, ((char(*)())(intptr_t)FPtr)());
307      else if (BitWidth <= 16)
308        rv.IntVal = APInt(BitWidth, ((short(*)())(intptr_t)FPtr)());
309      else if (BitWidth <= 32)
310        rv.IntVal = APInt(BitWidth, ((int(*)())(intptr_t)FPtr)());
311      else if (BitWidth <= 64)
312        rv.IntVal = APInt(BitWidth, ((int64_t(*)())(intptr_t)FPtr)());
313      else
314        llvm_unreachable("Integer types > 64 bits not supported");
315      return rv;
316    }
317    case Type::VoidTyID:
318      rv.IntVal = APInt(32, ((int(*)())(intptr_t)FPtr)());
319      return rv;
320    case Type::FloatTyID:
321      rv.FloatVal = ((float(*)())(intptr_t)FPtr)();
322      return rv;
323    case Type::DoubleTyID:
324      rv.DoubleVal = ((double(*)())(intptr_t)FPtr)();
325      return rv;
326    case Type::X86_FP80TyID:
327    case Type::FP128TyID:
328    case Type::PPC_FP128TyID:
329      llvm_unreachable("long double not supported yet");
330    case Type::PointerTyID:
331      return PTOGV(((void*(*)())(intptr_t)FPtr)());
332    }
333  }
334
335  // Okay, this is not one of our quick and easy cases.  Because we don't have a
336  // full FFI, we have to codegen a nullary stub function that just calls the
337  // function we are interested in, passing in constants for all of the
338  // arguments.  Make this function and return.
339
340  // First, create the function.
341  FunctionType *STy=FunctionType::get(RetTy, false);
342  Function *Stub = Function::Create(STy, Function::InternalLinkage, "",
343                                    F->getParent());
344
345  // Insert a basic block.
346  BasicBlock *StubBB = BasicBlock::Create(F->getContext(), "", Stub);
347
348  // Convert all of the GenericValue arguments over to constants.  Note that we
349  // currently don't support varargs.
350  SmallVector<Value*, 8> Args;
351  for (unsigned i = 0, e = ArgValues.size(); i != e; ++i) {
352    Constant *C = 0;
353    Type *ArgTy = FTy->getParamType(i);
354    const GenericValue &AV = ArgValues[i];
355    switch (ArgTy->getTypeID()) {
356    default: llvm_unreachable("Unknown argument type for function call!");
357    case Type::IntegerTyID:
358        C = ConstantInt::get(F->getContext(), AV.IntVal);
359        break;
360    case Type::FloatTyID:
361        C = ConstantFP::get(F->getContext(), APFloat(AV.FloatVal));
362        break;
363    case Type::DoubleTyID:
364        C = ConstantFP::get(F->getContext(), APFloat(AV.DoubleVal));
365        break;
366    case Type::PPC_FP128TyID:
367    case Type::X86_FP80TyID:
368    case Type::FP128TyID:
369        C = ConstantFP::get(F->getContext(), APFloat(ArgTy->getFltSemantics(),
370                                                     AV.IntVal));
371        break;
372    case Type::PointerTyID:
373      void *ArgPtr = GVTOP(AV);
374      if (sizeof(void*) == 4)
375        C = ConstantInt::get(Type::getInt32Ty(F->getContext()),
376                             (int)(intptr_t)ArgPtr);
377      else
378        C = ConstantInt::get(Type::getInt64Ty(F->getContext()),
379                             (intptr_t)ArgPtr);
380      // Cast the integer to pointer
381      C = ConstantExpr::getIntToPtr(C, ArgTy);
382      break;
383    }
384    Args.push_back(C);
385  }
386
387  CallInst *TheCall = CallInst::Create(F, Args, "", StubBB);
388  TheCall->setCallingConv(F->getCallingConv());
389  TheCall->setTailCall();
390  if (!TheCall->getType()->isVoidTy())
391    // Return result of the call.
392    ReturnInst::Create(F->getContext(), TheCall, StubBB);
393  else
394    ReturnInst::Create(F->getContext(), StubBB);           // Just return void.
395
396  // Finally, call our nullary stub function.
397  GenericValue Result = runFunction(Stub, std::vector<GenericValue>());
398  // Erase it, since no other function can have a reference to it.
399  Stub->eraseFromParent();
400  // And return the result.
401  return Result;
402}
403
404void JIT::RegisterJITEventListener(JITEventListener *L) {
405  if (L == NULL)
406    return;
407  MutexGuard locked(lock);
408  EventListeners.push_back(L);
409}
410void JIT::UnregisterJITEventListener(JITEventListener *L) {
411  if (L == NULL)
412    return;
413  MutexGuard locked(lock);
414  std::vector<JITEventListener*>::reverse_iterator I=
415      std::find(EventListeners.rbegin(), EventListeners.rend(), L);
416  if (I != EventListeners.rend()) {
417    std::swap(*I, EventListeners.back());
418    EventListeners.pop_back();
419  }
420}
421void JIT::NotifyFunctionEmitted(
422    const Function &F,
423    void *Code, size_t Size,
424    const JITEvent_EmittedFunctionDetails &Details) {
425  MutexGuard locked(lock);
426  for (unsigned I = 0, S = EventListeners.size(); I < S; ++I) {
427    EventListeners[I]->NotifyFunctionEmitted(F, Code, Size, Details);
428  }
429}
430
431void JIT::NotifyFreeingMachineCode(void *OldPtr) {
432  MutexGuard locked(lock);
433  for (unsigned I = 0, S = EventListeners.size(); I < S; ++I) {
434    EventListeners[I]->NotifyFreeingMachineCode(OldPtr);
435  }
436}
437
438/// runJITOnFunction - Run the FunctionPassManager full of
439/// just-in-time compilation passes on F, hopefully filling in
440/// GlobalAddress[F] with the address of F's machine code.
441///
442void JIT::runJITOnFunction(Function *F, MachineCodeInfo *MCI) {
443  MutexGuard locked(lock);
444
445  class MCIListener : public JITEventListener {
446    MachineCodeInfo *const MCI;
447   public:
448    MCIListener(MachineCodeInfo *mci) : MCI(mci) {}
449    virtual void NotifyFunctionEmitted(const Function &,
450                                       void *Code, size_t Size,
451                                       const EmittedFunctionDetails &) {
452      MCI->setAddress(Code);
453      MCI->setSize(Size);
454    }
455  };
456  MCIListener MCIL(MCI);
457  if (MCI)
458    RegisterJITEventListener(&MCIL);
459
460  runJITOnFunctionUnlocked(F, locked);
461
462  if (MCI)
463    UnregisterJITEventListener(&MCIL);
464}
465
466void JIT::runJITOnFunctionUnlocked(Function *F, const MutexGuard &locked) {
467  assert(!isAlreadyCodeGenerating && "Error: Recursive compilation detected!");
468
469  jitTheFunction(F, locked);
470
471  // If the function referred to another function that had not yet been
472  // read from bitcode, and we are jitting non-lazily, emit it now.
473  while (!jitstate->getPendingFunctions(locked).empty()) {
474    Function *PF = jitstate->getPendingFunctions(locked).back();
475    jitstate->getPendingFunctions(locked).pop_back();
476
477    assert(!PF->hasAvailableExternallyLinkage() &&
478           "Externally-defined function should not be in pending list.");
479
480    jitTheFunction(PF, locked);
481
482    // Now that the function has been jitted, ask the JITEmitter to rewrite
483    // the stub with real address of the function.
484    updateFunctionStub(PF);
485  }
486}
487
488void JIT::jitTheFunction(Function *F, const MutexGuard &locked) {
489  isAlreadyCodeGenerating = true;
490  jitstate->getPM(locked).run(*F);
491  isAlreadyCodeGenerating = false;
492
493  // clear basic block addresses after this function is done
494  getBasicBlockAddressMap(locked).clear();
495}
496
497/// getPointerToFunction - This method is used to get the address of the
498/// specified function, compiling it if necessary.
499///
500void *JIT::getPointerToFunction(Function *F) {
501
502  if (void *Addr = getPointerToGlobalIfAvailable(F))
503    return Addr;   // Check if function already code gen'd
504
505  MutexGuard locked(lock);
506
507  // Now that this thread owns the lock, make sure we read in the function if it
508  // exists in this Module.
509  std::string ErrorMsg;
510  if (F->Materialize(&ErrorMsg)) {
511    report_fatal_error("Error reading function '" + F->getName()+
512                      "' from bitcode file: " + ErrorMsg);
513  }
514
515  // ... and check if another thread has already code gen'd the function.
516  if (void *Addr = getPointerToGlobalIfAvailable(F))
517    return Addr;
518
519  if (F->isDeclaration() || F->hasAvailableExternallyLinkage()) {
520    bool AbortOnFailure = !F->hasExternalWeakLinkage();
521    void *Addr = getPointerToNamedFunction(F->getName(), AbortOnFailure);
522    addGlobalMapping(F, Addr);
523    return Addr;
524  }
525
526  runJITOnFunctionUnlocked(F, locked);
527
528  void *Addr = getPointerToGlobalIfAvailable(F);
529  assert(Addr && "Code generation didn't add function to GlobalAddress table!");
530  return Addr;
531}
532
533void JIT::addPointerToBasicBlock(const BasicBlock *BB, void *Addr) {
534  MutexGuard locked(lock);
535
536  BasicBlockAddressMapTy::iterator I =
537    getBasicBlockAddressMap(locked).find(BB);
538  if (I == getBasicBlockAddressMap(locked).end()) {
539    getBasicBlockAddressMap(locked)[BB] = Addr;
540  } else {
541    // ignore repeats: some BBs can be split into few MBBs?
542  }
543}
544
545void JIT::clearPointerToBasicBlock(const BasicBlock *BB) {
546  MutexGuard locked(lock);
547  getBasicBlockAddressMap(locked).erase(BB);
548}
549
550void *JIT::getPointerToBasicBlock(BasicBlock *BB) {
551  // make sure it's function is compiled by JIT
552  (void)getPointerToFunction(BB->getParent());
553
554  // resolve basic block address
555  MutexGuard locked(lock);
556
557  BasicBlockAddressMapTy::iterator I =
558    getBasicBlockAddressMap(locked).find(BB);
559  if (I != getBasicBlockAddressMap(locked).end()) {
560    return I->second;
561  } else {
562    llvm_unreachable("JIT does not have BB address for address-of-label, was"
563                     " it eliminated by optimizer?");
564  }
565}
566
567void *JIT::getPointerToNamedFunction(const std::string &Name,
568                                     bool AbortOnFailure){
569  if (!isSymbolSearchingDisabled()) {
570    void *ptr = JMM->getPointerToNamedFunction(Name, false);
571    if (ptr)
572      return ptr;
573  }
574
575  /// If a LazyFunctionCreator is installed, use it to get/create the function.
576  if (LazyFunctionCreator)
577    if (void *RP = LazyFunctionCreator(Name))
578      return RP;
579
580  if (AbortOnFailure) {
581    report_fatal_error("Program used external function '"+Name+
582                      "' which could not be resolved!");
583  }
584  return 0;
585}
586
587
588/// getOrEmitGlobalVariable - Return the address of the specified global
589/// variable, possibly emitting it to memory if needed.  This is used by the
590/// Emitter.
591void *JIT::getOrEmitGlobalVariable(const GlobalVariable *GV) {
592  MutexGuard locked(lock);
593
594  void *Ptr = getPointerToGlobalIfAvailable(GV);
595  if (Ptr) return Ptr;
596
597  // If the global is external, just remember the address.
598  if (GV->isDeclaration() || GV->hasAvailableExternallyLinkage()) {
599#if HAVE___DSO_HANDLE
600    if (GV->getName() == "__dso_handle")
601      return (void*)&__dso_handle;
602#endif
603    Ptr = sys::DynamicLibrary::SearchForAddressOfSymbol(GV->getName());
604    if (Ptr == 0) {
605      report_fatal_error("Could not resolve external global address: "
606                        +GV->getName());
607    }
608    addGlobalMapping(GV, Ptr);
609  } else {
610    // If the global hasn't been emitted to memory yet, allocate space and
611    // emit it into memory.
612    Ptr = getMemoryForGV(GV);
613    addGlobalMapping(GV, Ptr);
614    EmitGlobalVariable(GV);  // Initialize the variable.
615  }
616  return Ptr;
617}
618
619/// recompileAndRelinkFunction - This method is used to force a function
620/// which has already been compiled, to be compiled again, possibly
621/// after it has been modified. Then the entry to the old copy is overwritten
622/// with a branch to the new copy. If there was no old copy, this acts
623/// just like JIT::getPointerToFunction().
624///
625void *JIT::recompileAndRelinkFunction(Function *F) {
626  void *OldAddr = getPointerToGlobalIfAvailable(F);
627
628  // If it's not already compiled there is no reason to patch it up.
629  if (OldAddr == 0) { return getPointerToFunction(F); }
630
631  // Delete the old function mapping.
632  addGlobalMapping(F, 0);
633
634  // Recodegen the function
635  runJITOnFunction(F);
636
637  // Update state, forward the old function to the new function.
638  void *Addr = getPointerToGlobalIfAvailable(F);
639  assert(Addr && "Code generation didn't add function to GlobalAddress table!");
640  TJI.replaceMachineCodeForFunction(OldAddr, Addr);
641  return Addr;
642}
643
644/// getMemoryForGV - This method abstracts memory allocation of global
645/// variable so that the JIT can allocate thread local variables depending
646/// on the target.
647///
648char* JIT::getMemoryForGV(const GlobalVariable* GV) {
649  char *Ptr;
650
651  // GlobalVariable's which are not "constant" will cause trouble in a server
652  // situation. It's returned in the same block of memory as code which may
653  // not be writable.
654  if (isGVCompilationDisabled() && !GV->isConstant()) {
655    report_fatal_error("Compilation of non-internal GlobalValue is disabled!");
656  }
657
658  // Some applications require globals and code to live together, so they may
659  // be allocated into the same buffer, but in general globals are allocated
660  // through the memory manager which puts them near the code but not in the
661  // same buffer.
662  Type *GlobalType = GV->getType()->getElementType();
663  size_t S = getDataLayout()->getTypeAllocSize(GlobalType);
664  size_t A = getDataLayout()->getPreferredAlignment(GV);
665  if (GV->isThreadLocal()) {
666    MutexGuard locked(lock);
667    Ptr = TJI.allocateThreadLocalMemory(S);
668  } else if (TJI.allocateSeparateGVMemory()) {
669    if (A <= 8) {
670      Ptr = (char*)malloc(S);
671    } else {
672      // Allocate S+A bytes of memory, then use an aligned pointer within that
673      // space.
674      Ptr = (char*)malloc(S+A);
675      unsigned MisAligned = ((intptr_t)Ptr & (A-1));
676      Ptr = Ptr + (MisAligned ? (A-MisAligned) : 0);
677    }
678  } else if (AllocateGVsWithCode) {
679    Ptr = (char*)JCE->allocateSpace(S, A);
680  } else {
681    Ptr = (char*)JCE->allocateGlobal(S, A);
682  }
683  return Ptr;
684}
685
686void JIT::addPendingFunction(Function *F) {
687  MutexGuard locked(lock);
688  jitstate->getPendingFunctions(locked).push_back(F);
689}
690
691
692JITEventListener::~JITEventListener() {}