JIT.h revision 895eddfad43f848d5accce1789aa80be0db459d3 
1//===-- JIT.h - Class definition for the JIT --------------------*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file was developed by the LLVM research group and is distributed under
6// the University of Illinois Open Source License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file defines the top-level JIT data structure.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef JIT_H
15#define JIT_H
16
17#include "llvm/ExecutionEngine/ExecutionEngine.h"
18#include "llvm/PassManager.h"
19#include <map>
20
21namespace llvm {
22
23class Function;
24class GlobalValue;
25class Constant;
26class TargetMachine;
27class TargetJITInfo;
28class MachineCodeEmitter;
29
30class JIT : public ExecutionEngine {
31  TargetMachine &TM;       // The current target we are compiling to
32  TargetJITInfo &TJI;      // The JITInfo for the target we are compiling to
33
34  FunctionPassManager PM;  // Passes to compile a function
35  MachineCodeEmitter *MCE; // MCE object
36
37  /// PendingGlobals - Global variables which have had memory allocated for them
38  /// while a function was code generated, but which have not been initialized
39  /// yet.
40  std::vector<const GlobalVariable*> PendingGlobals;
41
42  JIT(ModuleProvider *MP, TargetMachine &tm, TargetJITInfo &tji);
43public:
44  ~JIT();
45
46  /// create - Create an return a new JIT compiler if there is one available
47  /// for the current target.  Otherwise, return null.  If the JIT is created
48  /// successfully, it takes responsibility for deleting the specified
49  /// IntrinsicLowering implementation.
50  ///
51  static ExecutionEngine *create(ModuleProvider *MP, IntrinsicLowering *IL = 0);
52
53  /// run - Start execution with the specified function and arguments.
54  ///
55  virtual GenericValue runFunction(Function *F,
56                                   const std::vector<GenericValue> &ArgValues);
57
58  /// getPointerToNamedFunction - This method returns the address of the
59  /// specified function by using the dlsym function call.  As such it is only
60  /// useful for resolving library symbols, not code generated symbols.
61  ///
62  void *getPointerToNamedFunction(const std::string &Name);
63
64  // CompilationCallback - Invoked the first time that a call site is found,
65  // which causes lazy compilation of the target function.
66  //
67  static void CompilationCallback();
68
69  /// getPointerToFunction - This returns the address of the specified function,
70  /// compiling it if necessary.
71  ///
72  void *getPointerToFunction(Function *F);
73
74  /// getOrEmitGlobalVariable - Return the address of the specified global
75  /// variable, possibly emitting it to memory if needed.  This is used by the
76  /// Emitter.
77  void *getOrEmitGlobalVariable(const GlobalVariable *GV);
78
79  /// getPointerToFunctionOrStub - If the specified function has been
80  /// code-gen'd, return a pointer to the function.  If not, compile it, or use
81  /// a stub to implement lazy compilation if available.
82  ///
83  void *getPointerToFunctionOrStub(Function *F);
84
85  /// recompileAndRelinkFunction - This method is used to force a function
86  /// which has already been compiled, to be compiled again, possibly
87  /// after it has been modified. Then the entry to the old copy is overwritten
88  /// with a branch to the new copy. If there was no old copy, this acts
89  /// just like JIT::getPointerToFunction().
90  ///
91  void *recompileAndRelinkFunction(Function *F);
92
93  /// freeMachineCodeForFunction - deallocate memory used to code-generate this
94  /// Function.
95  ///
96  void freeMachineCodeForFunction(Function *F);
97
98private:
99  static MachineCodeEmitter *createEmitter(JIT &J);
100  void runJITOnFunction (Function *F);
101};
102
103} // End llvm namespace
104
105#endif
106