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