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