JIT.cpp revision f0356fe140af1a30587b9a86bcfb1b2c51b8ce20 
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/Constants.h"
17#include "llvm/DerivedTypes.h"
18#include "llvm/Function.h"
19#include "llvm/GlobalVariable.h"
20#include "llvm/Instructions.h"
21#include "llvm/CodeGen/JITCodeEmitter.h"
22#include "llvm/CodeGen/MachineCodeInfo.h"
23#include "llvm/ExecutionEngine/GenericValue.h"
24#include "llvm/ExecutionEngine/JITEventListener.h"
25#include "llvm/Target/TargetData.h"
26#include "llvm/Target/TargetMachine.h"
27#include "llvm/Target/TargetJITInfo.h"
28#include "llvm/Support/Dwarf.h"
29#include "llvm/Support/ErrorHandling.h"
30#include "llvm/Support/MutexGuard.h"
31#include "llvm/System/DynamicLibrary.h"
32#include "llvm/Config/config.h"
33
34using namespace llvm;
35
36#ifdef __APPLE__
37// Apple gcc defaults to -fuse-cxa-atexit (i.e. calls __cxa_atexit instead
38// of atexit). It passes the address of linker generated symbol __dso_handle
39// to the function.
40// This configuration change happened at version 5330.
41# include <AvailabilityMacros.h>
42# if defined(MAC_OS_X_VERSION_10_4) && \
43     ((MAC_OS_X_VERSION_MIN_REQUIRED > MAC_OS_X_VERSION_10_4) || \
44      (MAC_OS_X_VERSION_MIN_REQUIRED == MAC_OS_X_VERSION_10_4 && \
45       __APPLE_CC__ >= 5330))
46#  ifndef HAVE___DSO_HANDLE
47#   define HAVE___DSO_HANDLE 1
48#  endif
49# endif
50#endif
51
52#if HAVE___DSO_HANDLE
53extern void *__dso_handle __attribute__ ((__visibility__ ("hidden")));
54#endif
55
56namespace {
57
58static struct RegisterJIT {
59  RegisterJIT() { JIT::Register(); }
60} JITRegistrator;
61
62}
63
64extern "C" void LLVMLinkInJIT() {
65}
66
67
68#if defined(__GNUC__) && !defined(__ARM__EABI__)
69
70// libgcc defines the __register_frame function to dynamically register new
71// dwarf frames for exception handling. This functionality is not portable
72// across compilers and is only provided by GCC. We use the __register_frame
73// function here so that code generated by the JIT cooperates with the unwinding
74// runtime of libgcc. When JITting with exception handling enable, LLVM
75// generates dwarf frames and registers it to libgcc with __register_frame.
76//
77// The __register_frame function works with Linux.
78//
79// Unfortunately, this functionality seems to be in libgcc after the unwinding
80// library of libgcc for darwin was written. The code for darwin overwrites the
81// value updated by __register_frame with a value fetched with "keymgr".
82// "keymgr" is an obsolete functionality, which should be rewritten some day.
83// In the meantime, since "keymgr" is on all libgccs shipped with apple-gcc, we
84// need a workaround in LLVM which uses the "keymgr" to dynamically modify the
85// values of an opaque key, used by libgcc to find dwarf tables.
86
87extern "C" void __register_frame(void*);
88
89#if defined(__APPLE__) && MAC_OS_X_VERSION_MAX_ALLOWED <= 1050
90# define USE_KEYMGR 1
91#else
92# define USE_KEYMGR 0
93#endif
94
95#if USE_KEYMGR
96
97namespace {
98
99// LibgccObject - This is the structure defined in libgcc. There is no #include
100// provided for this structure, so we also define it here. libgcc calls it
101// "struct object". The structure is undocumented in libgcc.
102struct LibgccObject {
103  void *unused1;
104  void *unused2;
105  void *unused3;
106
107  /// frame - Pointer to the exception table.
108  void *frame;
109
110  /// encoding -  The encoding of the object?
111  union {
112    struct {
113      unsigned long sorted : 1;
114      unsigned long from_array : 1;
115      unsigned long mixed_encoding : 1;
116      unsigned long encoding : 8;
117      unsigned long count : 21;
118    } b;
119    size_t i;
120  } encoding;
121
122  /// fde_end - libgcc defines this field only if some macro is defined. We
123  /// include this field even if it may not there, to make libgcc happy.
124  char *fde_end;
125
126  /// next - At least we know it's a chained list!
127  struct LibgccObject *next;
128};
129
130// "kemgr" stuff. Apparently, all frame tables are stored there.
131extern "C" void _keymgr_set_and_unlock_processwide_ptr(int, void *);
132extern "C" void *_keymgr_get_and_lock_processwide_ptr(int);
133#define KEYMGR_GCC3_DW2_OBJ_LIST        302     /* Dwarf2 object list  */
134
135/// LibgccObjectInfo - libgcc defines this struct as km_object_info. It
136/// probably contains all dwarf tables that are loaded.
137struct LibgccObjectInfo {
138
139  /// seenObjects - LibgccObjects already parsed by the unwinding runtime.
140  ///
141  struct LibgccObject* seenObjects;
142
143  /// unseenObjects - LibgccObjects not parsed yet by the unwinding runtime.
144  ///
145  struct LibgccObject* unseenObjects;
146
147  unsigned unused[2];
148};
149
150/// darwin_register_frame - Since __register_frame does not work with darwin's
151/// libgcc,we provide our own function, which "tricks" libgcc by modifying the
152/// "Dwarf2 object list" key.
153void DarwinRegisterFrame(void* FrameBegin) {
154  // Get the key.
155  LibgccObjectInfo* LOI = (struct LibgccObjectInfo*)
156    _keymgr_get_and_lock_processwide_ptr(KEYMGR_GCC3_DW2_OBJ_LIST);
157  assert(LOI && "This should be preallocated by the runtime");
158
159  // Allocate a new LibgccObject to represent this frame. Deallocation of this
160  // object may be impossible: since darwin code in libgcc was written after
161  // the ability to dynamically register frames, things may crash if we
162  // deallocate it.
163  struct LibgccObject* ob = (struct LibgccObject*)
164    malloc(sizeof(struct LibgccObject));
165
166  // Do like libgcc for the values of the field.
167  ob->unused1 = (void *)-1;
168  ob->unused2 = 0;
169  ob->unused3 = 0;
170  ob->frame = FrameBegin;
171  ob->encoding.i = 0;
172  ob->encoding.b.encoding = llvm::dwarf::DW_EH_PE_omit;
173
174  // Put the info on both places, as libgcc uses the first or the the second
175  // field. Note that we rely on having two pointers here. If fde_end was a
176  // char, things would get complicated.
177  ob->fde_end = (char*)LOI->unseenObjects;
178  ob->next = LOI->unseenObjects;
179
180  // Update the key's unseenObjects list.
181  LOI->unseenObjects = ob;
182
183  // Finally update the "key". Apparently, libgcc requires it.
184  _keymgr_set_and_unlock_processwide_ptr(KEYMGR_GCC3_DW2_OBJ_LIST,
185                                         LOI);
186
187}
188
189}
190#endif // __APPLE__
191#endif // __GNUC__
192
193/// createJIT - This is the factory method for creating a JIT for the current
194/// machine, it does not fall back to the interpreter.  This takes ownership
195/// of the module.
196ExecutionEngine *ExecutionEngine::createJIT(Module *M,
197                                            std::string *ErrorStr,
198                                            JITMemoryManager *JMM,
199                                            CodeGenOpt::Level OptLevel,
200                                            bool GVsWithCode,
201					    CodeModel::Model CMM) {
202  return JIT::createJIT(M, ErrorStr, JMM, OptLevel, GVsWithCode, CMM);
203}
204
205ExecutionEngine *JIT::createJIT(Module *M,
206                                std::string *ErrorStr,
207                                JITMemoryManager *JMM,
208                                CodeGenOpt::Level OptLevel,
209                                bool GVsWithCode,
210                                CodeModel::Model CMM) {
211  // Make sure we can resolve symbols in the program as well. The zero arg
212  // to the function tells DynamicLibrary to load the program, not a library.
213  if (sys::DynamicLibrary::LoadLibraryPermanently(0, ErrorStr))
214    return 0;
215
216  // Pick a target either via -march or by guessing the native arch.
217  TargetMachine *TM = JIT::selectTarget(M, ErrorStr);
218  if (!TM || (ErrorStr && ErrorStr->length() > 0)) return 0;
219  TM->setCodeModel(CMM);
220
221  // If the target supports JIT code generation, create a the JIT.
222  if (TargetJITInfo *TJ = TM->getJITInfo()) {
223    return new JIT(M, *TM, *TJ, JMM, OptLevel, GVsWithCode);
224  } else {
225    if (ErrorStr)
226      *ErrorStr = "target does not support JIT code generation";
227    return 0;
228  }
229}
230
231JIT::JIT(Module *M, TargetMachine &tm, TargetJITInfo &tji,
232         JITMemoryManager *JMM, CodeGenOpt::Level OptLevel, bool GVsWithCode)
233  : ExecutionEngine(M), TM(tm), TJI(tji), AllocateGVsWithCode(GVsWithCode) {
234  setTargetData(TM.getTargetData());
235
236  jitstate = new JITState(M);
237
238  // Initialize JCE
239  JCE = createEmitter(*this, JMM, TM);
240
241  // Add target data
242  MutexGuard locked(lock);
243  FunctionPassManager &PM = jitstate->getPM(locked);
244  PM.add(new TargetData(*TM.getTargetData()));
245
246  // Turn the machine code intermediate representation into bytes in memory that
247  // may be executed.
248  if (TM.addPassesToEmitMachineCode(PM, *JCE, OptLevel)) {
249    llvm_report_error("Target does not support machine code emission!");
250  }
251
252  // Register routine for informing unwinding runtime about new EH frames
253#if defined(__GNUC__) && !defined(__ARM_EABI__)
254#if USE_KEYMGR
255  struct LibgccObjectInfo* LOI = (struct LibgccObjectInfo*)
256    _keymgr_get_and_lock_processwide_ptr(KEYMGR_GCC3_DW2_OBJ_LIST);
257
258  // The key is created on demand, and libgcc creates it the first time an
259  // exception occurs. Since we need the key to register frames, we create
260  // it now.
261  if (!LOI)
262    LOI = (LibgccObjectInfo*)calloc(sizeof(struct LibgccObjectInfo), 1);
263  _keymgr_set_and_unlock_processwide_ptr(KEYMGR_GCC3_DW2_OBJ_LIST, LOI);
264  InstallExceptionTableRegister(DarwinRegisterFrame);
265#else
266  InstallExceptionTableRegister(__register_frame);
267#endif // __APPLE__
268#endif // __GNUC__
269
270  // Initialize passes.
271  PM.doInitialization();
272}
273
274JIT::~JIT() {
275  delete jitstate;
276  delete JCE;
277  delete &TM;
278}
279
280/// addModule - Add a new Module to the JIT.  If we previously removed the last
281/// Module, we need re-initialize jitstate with a valid Module.
282void JIT::addModule(Module *M) {
283  MutexGuard locked(lock);
284
285  if (Modules.empty()) {
286    assert(!jitstate && "jitstate should be NULL if Modules vector is empty!");
287
288    jitstate = new JITState(M);
289
290    FunctionPassManager &PM = jitstate->getPM(locked);
291    PM.add(new TargetData(*TM.getTargetData()));
292
293    // Turn the machine code intermediate representation into bytes in memory
294    // that may be executed.
295    if (TM.addPassesToEmitMachineCode(PM, *JCE, CodeGenOpt::Default)) {
296      llvm_report_error("Target does not support machine code emission!");
297    }
298
299    // Initialize passes.
300    PM.doInitialization();
301  }
302
303  ExecutionEngine::addModule(M);
304}
305
306/// removeModule - If we are removing the last Module, invalidate the jitstate
307/// since the PassManager it contains references a released Module.
308bool JIT::removeModule(Module *M) {
309  bool result = ExecutionEngine::removeModule(M);
310
311  MutexGuard locked(lock);
312
313  if (jitstate->getModule() == M) {
314    delete jitstate;
315    jitstate = 0;
316  }
317
318  if (!jitstate && !Modules.empty()) {
319    jitstate = new JITState(Modules[0]);
320
321    FunctionPassManager &PM = jitstate->getPM(locked);
322    PM.add(new TargetData(*TM.getTargetData()));
323
324    // Turn the machine code intermediate representation into bytes in memory
325    // that may be executed.
326    if (TM.addPassesToEmitMachineCode(PM, *JCE, CodeGenOpt::Default)) {
327      llvm_report_error("Target does not support machine code emission!");
328    }
329
330    // Initialize passes.
331    PM.doInitialization();
332  }
333  return result;
334}
335
336/// run - Start execution with the specified function and arguments.
337///
338GenericValue JIT::runFunction(Function *F,
339                              const std::vector<GenericValue> &ArgValues) {
340  assert(F && "Function *F was null at entry to run()");
341
342  void *FPtr = getPointerToFunction(F);
343  assert(FPtr && "Pointer to fn's code was null after getPointerToFunction");
344  const FunctionType *FTy = F->getFunctionType();
345  const Type *RetTy = FTy->getReturnType();
346
347  assert((FTy->getNumParams() == ArgValues.size() ||
348          (FTy->isVarArg() && FTy->getNumParams() <= ArgValues.size())) &&
349         "Wrong number of arguments passed into function!");
350  assert(FTy->getNumParams() == ArgValues.size() &&
351         "This doesn't support passing arguments through varargs (yet)!");
352
353  // Handle some common cases first.  These cases correspond to common `main'
354  // prototypes.
355  if (RetTy->isInteger(32) || RetTy->isVoidTy()) {
356    switch (ArgValues.size()) {
357    case 3:
358      if (FTy->getParamType(0)->isInteger(32) &&
359          isa<PointerType>(FTy->getParamType(1)) &&
360          isa<PointerType>(FTy->getParamType(2))) {
361        int (*PF)(int, char **, const char **) =
362          (int(*)(int, char **, const char **))(intptr_t)FPtr;
363
364        // Call the function.
365        GenericValue rv;
366        rv.IntVal = APInt(32, PF(ArgValues[0].IntVal.getZExtValue(),
367                                 (char **)GVTOP(ArgValues[1]),
368                                 (const char **)GVTOP(ArgValues[2])));
369        return rv;
370      }
371      break;
372    case 2:
373      if (FTy->getParamType(0)->isInteger(32) &&
374          isa<PointerType>(FTy->getParamType(1))) {
375        int (*PF)(int, char **) = (int(*)(int, char **))(intptr_t)FPtr;
376
377        // Call the function.
378        GenericValue rv;
379        rv.IntVal = APInt(32, PF(ArgValues[0].IntVal.getZExtValue(),
380                                 (char **)GVTOP(ArgValues[1])));
381        return rv;
382      }
383      break;
384    case 1:
385      if (FTy->getNumParams() == 1 &&
386          FTy->getParamType(0)->isInteger(32)) {
387        GenericValue rv;
388        int (*PF)(int) = (int(*)(int))(intptr_t)FPtr;
389        rv.IntVal = APInt(32, PF(ArgValues[0].IntVal.getZExtValue()));
390        return rv;
391      }
392      break;
393    }
394  }
395
396  // Handle cases where no arguments are passed first.
397  if (ArgValues.empty()) {
398    GenericValue rv;
399    switch (RetTy->getTypeID()) {
400    default: llvm_unreachable("Unknown return type for function call!");
401    case Type::IntegerTyID: {
402      unsigned BitWidth = cast<IntegerType>(RetTy)->getBitWidth();
403      if (BitWidth == 1)
404        rv.IntVal = APInt(BitWidth, ((bool(*)())(intptr_t)FPtr)());
405      else if (BitWidth <= 8)
406        rv.IntVal = APInt(BitWidth, ((char(*)())(intptr_t)FPtr)());
407      else if (BitWidth <= 16)
408        rv.IntVal = APInt(BitWidth, ((short(*)())(intptr_t)FPtr)());
409      else if (BitWidth <= 32)
410        rv.IntVal = APInt(BitWidth, ((int(*)())(intptr_t)FPtr)());
411      else if (BitWidth <= 64)
412        rv.IntVal = APInt(BitWidth, ((int64_t(*)())(intptr_t)FPtr)());
413      else
414        llvm_unreachable("Integer types > 64 bits not supported");
415      return rv;
416    }
417    case Type::VoidTyID:
418      rv.IntVal = APInt(32, ((int(*)())(intptr_t)FPtr)());
419      return rv;
420    case Type::FloatTyID:
421      rv.FloatVal = ((float(*)())(intptr_t)FPtr)();
422      return rv;
423    case Type::DoubleTyID:
424      rv.DoubleVal = ((double(*)())(intptr_t)FPtr)();
425      return rv;
426    case Type::X86_FP80TyID:
427    case Type::FP128TyID:
428    case Type::PPC_FP128TyID:
429      llvm_unreachable("long double not supported yet");
430      return rv;
431    case Type::PointerTyID:
432      return PTOGV(((void*(*)())(intptr_t)FPtr)());
433    }
434  }
435
436  // Okay, this is not one of our quick and easy cases.  Because we don't have a
437  // full FFI, we have to codegen a nullary stub function that just calls the
438  // function we are interested in, passing in constants for all of the
439  // arguments.  Make this function and return.
440
441  // First, create the function.
442  FunctionType *STy=FunctionType::get(RetTy, false);
443  Function *Stub = Function::Create(STy, Function::InternalLinkage, "",
444                                    F->getParent());
445
446  // Insert a basic block.
447  BasicBlock *StubBB = BasicBlock::Create(F->getContext(), "", Stub);
448
449  // Convert all of the GenericValue arguments over to constants.  Note that we
450  // currently don't support varargs.
451  SmallVector<Value*, 8> Args;
452  for (unsigned i = 0, e = ArgValues.size(); i != e; ++i) {
453    Constant *C = 0;
454    const Type *ArgTy = FTy->getParamType(i);
455    const GenericValue &AV = ArgValues[i];
456    switch (ArgTy->getTypeID()) {
457    default: llvm_unreachable("Unknown argument type for function call!");
458    case Type::IntegerTyID:
459        C = ConstantInt::get(F->getContext(), AV.IntVal);
460        break;
461    case Type::FloatTyID:
462        C = ConstantFP::get(F->getContext(), APFloat(AV.FloatVal));
463        break;
464    case Type::DoubleTyID:
465        C = ConstantFP::get(F->getContext(), APFloat(AV.DoubleVal));
466        break;
467    case Type::PPC_FP128TyID:
468    case Type::X86_FP80TyID:
469    case Type::FP128TyID:
470        C = ConstantFP::get(F->getContext(), APFloat(AV.IntVal));
471        break;
472    case Type::PointerTyID:
473      void *ArgPtr = GVTOP(AV);
474      if (sizeof(void*) == 4)
475        C = ConstantInt::get(Type::getInt32Ty(F->getContext()),
476                             (int)(intptr_t)ArgPtr);
477      else
478        C = ConstantInt::get(Type::getInt64Ty(F->getContext()),
479                             (intptr_t)ArgPtr);
480      // Cast the integer to pointer
481      C = ConstantExpr::getIntToPtr(C, ArgTy);
482      break;
483    }
484    Args.push_back(C);
485  }
486
487  CallInst *TheCall = CallInst::Create(F, Args.begin(), Args.end(),
488                                       "", StubBB);
489  TheCall->setCallingConv(F->getCallingConv());
490  TheCall->setTailCall();
491  if (!TheCall->getType()->isVoidTy())
492    // Return result of the call.
493    ReturnInst::Create(F->getContext(), TheCall, StubBB);
494  else
495    ReturnInst::Create(F->getContext(), StubBB);           // Just return void.
496
497  // Finally, return the value returned by our nullary stub function.
498  return runFunction(Stub, std::vector<GenericValue>());
499}
500
501void JIT::RegisterJITEventListener(JITEventListener *L) {
502  if (L == NULL)
503    return;
504  MutexGuard locked(lock);
505  EventListeners.push_back(L);
506}
507void JIT::UnregisterJITEventListener(JITEventListener *L) {
508  if (L == NULL)
509    return;
510  MutexGuard locked(lock);
511  std::vector<JITEventListener*>::reverse_iterator I=
512      std::find(EventListeners.rbegin(), EventListeners.rend(), L);
513  if (I != EventListeners.rend()) {
514    std::swap(*I, EventListeners.back());
515    EventListeners.pop_back();
516  }
517}
518void JIT::NotifyFunctionEmitted(
519    const Function &F,
520    void *Code, size_t Size,
521    const JITEvent_EmittedFunctionDetails &Details) {
522  MutexGuard locked(lock);
523  for (unsigned I = 0, S = EventListeners.size(); I < S; ++I) {
524    EventListeners[I]->NotifyFunctionEmitted(F, Code, Size, Details);
525  }
526}
527
528void JIT::NotifyFreeingMachineCode(void *OldPtr) {
529  MutexGuard locked(lock);
530  for (unsigned I = 0, S = EventListeners.size(); I < S; ++I) {
531    EventListeners[I]->NotifyFreeingMachineCode(OldPtr);
532  }
533}
534
535/// runJITOnFunction - Run the FunctionPassManager full of
536/// just-in-time compilation passes on F, hopefully filling in
537/// GlobalAddress[F] with the address of F's machine code.
538///
539void JIT::runJITOnFunction(Function *F, MachineCodeInfo *MCI) {
540  MutexGuard locked(lock);
541
542  class MCIListener : public JITEventListener {
543    MachineCodeInfo *const MCI;
544   public:
545    MCIListener(MachineCodeInfo *mci) : MCI(mci) {}
546    virtual void NotifyFunctionEmitted(const Function &,
547                                       void *Code, size_t Size,
548                                       const EmittedFunctionDetails &) {
549      MCI->setAddress(Code);
550      MCI->setSize(Size);
551    }
552  };
553  MCIListener MCIL(MCI);
554  if (MCI)
555    RegisterJITEventListener(&MCIL);
556
557  runJITOnFunctionUnlocked(F, locked);
558
559  if (MCI)
560    UnregisterJITEventListener(&MCIL);
561}
562
563void JIT::runJITOnFunctionUnlocked(Function *F, const MutexGuard &locked) {
564  static bool isAlreadyCodeGenerating = false;
565  assert(!isAlreadyCodeGenerating && "Error: Recursive compilation detected!");
566
567  // JIT the function
568  isAlreadyCodeGenerating = true;
569  jitstate->getPM(locked).run(*F);
570  isAlreadyCodeGenerating = false;
571
572  // If the function referred to another function that had not yet been
573  // read from bitcode, and we are jitting non-lazily, emit it now.
574  while (!jitstate->getPendingFunctions(locked).empty()) {
575    Function *PF = jitstate->getPendingFunctions(locked).back();
576    jitstate->getPendingFunctions(locked).pop_back();
577
578    assert(!PF->hasAvailableExternallyLinkage() &&
579           "Externally-defined function should not be in pending list.");
580
581    // JIT the function
582    isAlreadyCodeGenerating = true;
583    jitstate->getPM(locked).run(*PF);
584    isAlreadyCodeGenerating = false;
585
586    // Now that the function has been jitted, ask the JITEmitter to rewrite
587    // the stub with real address of the function.
588    updateFunctionStub(PF);
589  }
590}
591
592/// getPointerToFunction - This method is used to get the address of the
593/// specified function, compiling it if neccesary.
594///
595void *JIT::getPointerToFunction(Function *F) {
596
597  if (void *Addr = getPointerToGlobalIfAvailable(F))
598    return Addr;   // Check if function already code gen'd
599
600  MutexGuard locked(lock);
601
602  // Now that this thread owns the lock, make sure we read in the function if it
603  // exists in this Module.
604  std::string ErrorMsg;
605  if (F->Materialize(&ErrorMsg)) {
606    llvm_report_error("Error reading function '" + F->getName()+
607                      "' from bitcode file: " + ErrorMsg);
608  }
609
610  // ... and check if another thread has already code gen'd the function.
611  if (void *Addr = getPointerToGlobalIfAvailable(F))
612    return Addr;
613
614  if (F->isDeclaration() || F->hasAvailableExternallyLinkage()) {
615    bool AbortOnFailure = !F->hasExternalWeakLinkage();
616    void *Addr = getPointerToNamedFunction(F->getName(), AbortOnFailure);
617    addGlobalMapping(F, Addr);
618    return Addr;
619  }
620
621  runJITOnFunctionUnlocked(F, locked);
622
623  void *Addr = getPointerToGlobalIfAvailable(F);
624  assert(Addr && "Code generation didn't add function to GlobalAddress table!");
625  return Addr;
626}
627
628/// getOrEmitGlobalVariable - Return the address of the specified global
629/// variable, possibly emitting it to memory if needed.  This is used by the
630/// Emitter.
631void *JIT::getOrEmitGlobalVariable(const GlobalVariable *GV) {
632  MutexGuard locked(lock);
633
634  void *Ptr = getPointerToGlobalIfAvailable(GV);
635  if (Ptr) return Ptr;
636
637  // If the global is external, just remember the address.
638  if (GV->isDeclaration() || GV->hasAvailableExternallyLinkage()) {
639#if HAVE___DSO_HANDLE
640    if (GV->getName() == "__dso_handle")
641      return (void*)&__dso_handle;
642#endif
643    Ptr = sys::DynamicLibrary::SearchForAddressOfSymbol(GV->getName());
644    if (Ptr == 0) {
645      llvm_report_error("Could not resolve external global address: "
646                        +GV->getName());
647    }
648    addGlobalMapping(GV, Ptr);
649  } else {
650    // If the global hasn't been emitted to memory yet, allocate space and
651    // emit it into memory.
652    Ptr = getMemoryForGV(GV);
653    addGlobalMapping(GV, Ptr);
654    EmitGlobalVariable(GV);  // Initialize the variable.
655  }
656  return Ptr;
657}
658
659/// recompileAndRelinkFunction - This method is used to force a function
660/// which has already been compiled, to be compiled again, possibly
661/// after it has been modified. Then the entry to the old copy is overwritten
662/// with a branch to the new copy. If there was no old copy, this acts
663/// just like JIT::getPointerToFunction().
664///
665void *JIT::recompileAndRelinkFunction(Function *F) {
666  void *OldAddr = getPointerToGlobalIfAvailable(F);
667
668  // If it's not already compiled there is no reason to patch it up.
669  if (OldAddr == 0) { return getPointerToFunction(F); }
670
671  // Delete the old function mapping.
672  addGlobalMapping(F, 0);
673
674  // Recodegen the function
675  runJITOnFunction(F);
676
677  // Update state, forward the old function to the new function.
678  void *Addr = getPointerToGlobalIfAvailable(F);
679  assert(Addr && "Code generation didn't add function to GlobalAddress table!");
680  TJI.replaceMachineCodeForFunction(OldAddr, Addr);
681  return Addr;
682}
683
684/// getMemoryForGV - This method abstracts memory allocation of global
685/// variable so that the JIT can allocate thread local variables depending
686/// on the target.
687///
688char* JIT::getMemoryForGV(const GlobalVariable* GV) {
689  char *Ptr;
690
691  // GlobalVariable's which are not "constant" will cause trouble in a server
692  // situation. It's returned in the same block of memory as code which may
693  // not be writable.
694  if (isGVCompilationDisabled() && !GV->isConstant()) {
695    llvm_report_error("Compilation of non-internal GlobalValue is disabled!");
696  }
697
698  // Some applications require globals and code to live together, so they may
699  // be allocated into the same buffer, but in general globals are allocated
700  // through the memory manager which puts them near the code but not in the
701  // same buffer.
702  const Type *GlobalType = GV->getType()->getElementType();
703  size_t S = getTargetData()->getTypeAllocSize(GlobalType);
704  size_t A = getTargetData()->getPreferredAlignment(GV);
705  if (GV->isThreadLocal()) {
706    MutexGuard locked(lock);
707    Ptr = TJI.allocateThreadLocalMemory(S);
708  } else if (TJI.allocateSeparateGVMemory()) {
709    if (A <= 8) {
710      Ptr = (char*)malloc(S);
711    } else {
712      // Allocate S+A bytes of memory, then use an aligned pointer within that
713      // space.
714      Ptr = (char*)malloc(S+A);
715      unsigned MisAligned = ((intptr_t)Ptr & (A-1));
716      Ptr = Ptr + (MisAligned ? (A-MisAligned) : 0);
717    }
718  } else if (AllocateGVsWithCode) {
719    Ptr = (char*)JCE->allocateSpace(S, A);
720  } else {
721    Ptr = (char*)JCE->allocateGlobal(S, A);
722  }
723  return Ptr;
724}
725
726void JIT::addPendingFunction(Function *F) {
727  MutexGuard locked(lock);
728  jitstate->getPendingFunctions(locked).push_back(F);
729}
730
731
732JITEventListener::~JITEventListener() {}
733