blob: fbb941667b089cbea937f7fac46d99b0ee59b32a [file] [log] [blame]
Chris Lattner4d326fa2003-12-20 01:46:27 +00001//===-- JIT.h - Class definition for the JIT --------------------*- C++ -*-===//
Misha Brukmanf976c852005-04-21 22:55:34 +00002//
John Criswell856ba762003-10-21 15:17:13 +00003// The LLVM Compiler Infrastructure
4//
Chris Lattner4ee451d2007-12-29 20:36:04 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Misha Brukmanf976c852005-04-21 22:55:34 +00007//
John Criswell856ba762003-10-21 15:17:13 +00008//===----------------------------------------------------------------------===//
Chris Lattner836f6752002-12-24 00:01:22 +00009//
Chris Lattner4d326fa2003-12-20 01:46:27 +000010// This file defines the top-level JIT data structure.
Chris Lattner836f6752002-12-24 00:01:22 +000011//
12//===----------------------------------------------------------------------===//
13
Chris Lattner4d326fa2003-12-20 01:46:27 +000014#ifndef JIT_H
15#define JIT_H
Chris Lattner836f6752002-12-24 00:01:22 +000016
Brian Gaeke97222942003-09-05 19:39:22 +000017#include "llvm/ExecutionEngine/ExecutionEngine.h"
Chris Lattner836f6752002-12-24 00:01:22 +000018#include "llvm/PassManager.h"
Jeffrey Yasskine5f87982009-10-13 21:32:57 +000019#include "llvm/Support/ValueHandle.h"
Chris Lattner836f6752002-12-24 00:01:22 +000020
Brian Gaeked0fde302003-11-11 22:41:34 +000021namespace llvm {
22
Chris Lattner836f6752002-12-24 00:01:22 +000023class Function;
Daniel Dunbardeb052a2009-07-12 23:50:34 +000024struct JITEvent_EmittedFunctionDetails;
Chris Lattner836f6752002-12-24 00:01:22 +000025class MachineCodeEmitter;
Argyrios Kyrtzidisb3a847d2009-05-18 21:06:40 +000026class MachineCodeInfo;
Jeffrey Yasskindf5a7da2009-06-25 02:04:04 +000027class TargetJITInfo;
28class TargetMachine;
Chris Lattner836f6752002-12-24 00:01:22 +000029
Reid Spenceree448632005-07-12 15:51:55 +000030class JITState {
31private:
Brian Gaekec227c1f2003-08-13 18:16:50 +000032 FunctionPassManager PM; // Passes to compile a function
Jeffrey Yasskinf0356fe2010-01-27 20:34:15 +000033 Module *M; // Module used to create the PM
Chris Lattner836f6752002-12-24 00:01:22 +000034
Nate Begemand6b7a242009-02-18 08:31:02 +000035 /// PendingFunctions - Functions which have not been code generated yet, but
36 /// were called from a function being code generated.
Jeffrey Yasskine5f87982009-10-13 21:32:57 +000037 std::vector<AssertingVH<Function> > PendingFunctions;
Chris Lattnerc07ed132003-12-20 03:36:47 +000038
Reid Spenceree448632005-07-12 15:51:55 +000039public:
Jeffrey Yasskinf0356fe2010-01-27 20:34:15 +000040 explicit JITState(Module *M) : PM(M), M(M) {}
Reid Spenceree448632005-07-12 15:51:55 +000041
Chris Lattnerf7e968a2007-04-20 22:40:40 +000042 FunctionPassManager &getPM(const MutexGuard &L) {
Reid Spenceree448632005-07-12 15:51:55 +000043 return PM;
44 }
Jim Grosbach124d0332011-03-16 01:21:55 +000045
Jeffrey Yasskinf0356fe2010-01-27 20:34:15 +000046 Module *getModule() const { return M; }
Jeffrey Yasskine5f87982009-10-13 21:32:57 +000047 std::vector<AssertingVH<Function> > &getPendingFunctions(const MutexGuard &L){
Nate Begemand6b7a242009-02-18 08:31:02 +000048 return PendingFunctions;
Reid Spenceree448632005-07-12 15:51:55 +000049 }
50};
51
52
53class JIT : public ExecutionEngine {
Chris Lattner68feb222010-07-11 23:07:28 +000054 /// types
55 typedef ValueMap<const BasicBlock *, void *>
56 BasicBlockAddressMapTy;
57 /// data
Reid Spenceree448632005-07-12 15:51:55 +000058 TargetMachine &TM; // The current target we are compiling to
59 TargetJITInfo &TJI; // The JITInfo for the target we are compiling to
Bruno Cardoso Lopes434dd4f2009-06-01 19:57:37 +000060 JITCodeEmitter *JCE; // JCE object
Jeffrey Yasskindf5a7da2009-06-25 02:04:04 +000061 std::vector<JITEventListener*> EventListeners;
Reid Spenceree448632005-07-12 15:51:55 +000062
Jeffrey Yasskin489393d2009-07-08 21:59:57 +000063 /// AllocateGVsWithCode - Some applications require that global variables and
64 /// code be allocated into the same region of memory, in which case this flag
65 /// should be set to true. Doing so breaks freeMachineCodeForFunction.
66 bool AllocateGVsWithCode;
67
Jeffrey Yasskin40966a72010-02-11 01:07:39 +000068 /// True while the JIT is generating code. Used to assert against recursive
69 /// entry.
70 bool isAlreadyCodeGenerating;
71
Nate Begemanf049e072008-05-21 16:34:48 +000072 JITState *jitstate;
Reid Spenceree448632005-07-12 15:51:55 +000073
Chris Lattner68feb222010-07-11 23:07:28 +000074 /// BasicBlockAddressMap - A mapping between LLVM basic blocks and their
75 /// actualized version, only filled for basic blocks that have their address
76 /// taken.
77 BasicBlockAddressMapTy BasicBlockAddressMap;
78
79
Jeffrey Yasskinf0356fe2010-01-27 20:34:15 +000080 JIT(Module *M, TargetMachine &tm, TargetJITInfo &tji,
Dylan Noblesmith9ea47172011-12-12 04:20:36 +000081 JITMemoryManager *JMM, bool AllocateGVsWithCode);
Chris Lattner836f6752002-12-24 00:01:22 +000082public:
Chris Lattner4d326fa2003-12-20 01:46:27 +000083 ~JIT();
Chris Lattner836f6752002-12-24 00:01:22 +000084
Chris Lattner2fe4bb02006-03-22 06:07:50 +000085 static void Register() {
Jeffrey Yasskin46882612010-02-05 16:19:36 +000086 JITCtor = createJIT;
Chris Lattner2fe4bb02006-03-22 06:07:50 +000087 }
Jim Grosbach124d0332011-03-16 01:21:55 +000088
Chris Lattner890b4bd2004-11-20 03:11:07 +000089 /// getJITInfo - Return the target JIT information structure.
90 ///
91 TargetJITInfo &getJITInfo() const { return TJI; }
92
Brian Gaeke82d82772003-09-03 20:34:19 +000093 /// create - Create an return a new JIT compiler if there is one available
Chris Lattner726c1ef2006-03-23 05:22:51 +000094 /// for the current target. Otherwise, return null.
Brian Gaeke82d82772003-09-03 20:34:19 +000095 ///
Jeffrey Yasskinf0356fe2010-01-27 20:34:15 +000096 static ExecutionEngine *create(Module *M,
Reid Kleckner4b1511b2009-07-18 00:42:18 +000097 std::string *Err,
98 JITMemoryManager *JMM,
Bill Wendling98a366d2009-04-29 23:29:43 +000099 CodeGenOpt::Level OptLevel =
Jeffrey Yasskin489393d2009-07-08 21:59:57 +0000100 CodeGenOpt::Default,
Eric Christopher88b5aca2009-11-17 21:58:16 +0000101 bool GVsWithCode = true,
Evan Cheng43966132011-07-19 06:37:02 +0000102 Reloc::Model RM = Reloc::Default,
Evan Cheng34ad6db2011-07-20 07:51:56 +0000103 CodeModel::Model CMM = CodeModel::JITDefault) {
Jeffrey Yasskinf0356fe2010-01-27 20:34:15 +0000104 return ExecutionEngine::createJIT(M, Err, JMM, OptLevel, GVsWithCode,
Evan Cheng43966132011-07-19 06:37:02 +0000105 RM, CMM);
Chris Lattner34c94332007-12-06 01:34:04 +0000106 }
Brian Gaeke82d82772003-09-03 20:34:19 +0000107
Jeffrey Yasskinf0356fe2010-01-27 20:34:15 +0000108 virtual void addModule(Module *M);
Jim Grosbach124d0332011-03-16 01:21:55 +0000109
Jeffrey Yasskinf0356fe2010-01-27 20:34:15 +0000110 /// removeModule - Remove a Module from the list of modules. Returns true if
111 /// M is found.
112 virtual bool removeModule(Module *M);
Jeffrey Yasskinaad0d522009-12-17 21:35:29 +0000113
Dan Gohmance3c4132008-07-03 00:51:05 +0000114 /// runFunction - Start execution with the specified function and arguments.
Chris Lattner836f6752002-12-24 00:01:22 +0000115 ///
Chris Lattnerff0f1bb2003-12-26 06:13:47 +0000116 virtual GenericValue runFunction(Function *F,
117 const std::vector<GenericValue> &ArgValues);
Chris Lattner836f6752002-12-24 00:01:22 +0000118
Chris Lattner0d448c02003-01-13 01:00:48 +0000119 /// getPointerToNamedFunction - This method returns the address of the
120 /// specified function by using the dlsym function call. As such it is only
121 /// useful for resolving library symbols, not code generated symbols.
122 ///
Dan Gohman69f93782009-01-05 05:32:42 +0000123 /// If AbortOnFailure is false and no function with the given name is
124 /// found, this function silently returns a null pointer. Otherwise,
125 /// it prints a message to stderr and aborts.
126 ///
127 void *getPointerToNamedFunction(const std::string &Name,
128 bool AbortOnFailure = true);
Chris Lattner0d448c02003-01-13 01:00:48 +0000129
Chris Lattnerc309a762003-05-08 21:34:11 +0000130 // CompilationCallback - Invoked the first time that a call site is found,
131 // which causes lazy compilation of the target function.
Misha Brukmanf976c852005-04-21 22:55:34 +0000132 //
Chris Lattnerc309a762003-05-08 21:34:11 +0000133 static void CompilationCallback();
Chris Lattner22080f92003-05-14 13:53:40 +0000134
Chris Lattnerbba1b6d2003-06-01 23:24:36 +0000135 /// getPointerToFunction - This returns the address of the specified function,
136 /// compiling it if necessary.
Brian Gaeke55c0f022003-10-17 18:27:12 +0000137 ///
Brian Gaekec227c1f2003-08-13 18:16:50 +0000138 void *getPointerToFunction(Function *F);
Chris Lattnerbba1b6d2003-06-01 23:24:36 +0000139
Chris Lattner68feb222010-07-11 23:07:28 +0000140 /// addPointerToBasicBlock - Adds address of the specific basic block.
141 void addPointerToBasicBlock(const BasicBlock *BB, void *Addr);
142
143 /// clearPointerToBasicBlock - Removes address of specific basic block.
144 void clearPointerToBasicBlock(const BasicBlock *BB);
145
146 /// getPointerToBasicBlock - This returns the address of the specified basic
147 /// block, assuming function is compiled.
148 void *getPointerToBasicBlock(BasicBlock *BB);
Jim Grosbach124d0332011-03-16 01:21:55 +0000149
Chris Lattnerc07ed132003-12-20 03:36:47 +0000150 /// getOrEmitGlobalVariable - Return the address of the specified global
151 /// variable, possibly emitting it to memory if needed. This is used by the
152 /// Emitter.
153 void *getOrEmitGlobalVariable(const GlobalVariable *GV);
154
Chris Lattner993bdce2003-12-12 07:12:02 +0000155 /// getPointerToFunctionOrStub - If the specified function has been
156 /// code-gen'd, return a pointer to the function. If not, compile it, or use
157 /// a stub to implement lazy compilation if available.
158 ///
159 void *getPointerToFunctionOrStub(Function *F);
160
Brian Gaeke55c0f022003-10-17 18:27:12 +0000161 /// recompileAndRelinkFunction - This method is used to force a function
162 /// which has already been compiled, to be compiled again, possibly
163 /// after it has been modified. Then the entry to the old copy is overwritten
164 /// with a branch to the new copy. If there was no old copy, this acts
Chris Lattner4d326fa2003-12-20 01:46:27 +0000165 /// just like JIT::getPointerToFunction().
Brian Gaeke55c0f022003-10-17 18:27:12 +0000166 ///
167 void *recompileAndRelinkFunction(Function *F);
168
Misha Brukman895eddf2004-11-07 23:58:46 +0000169 /// freeMachineCodeForFunction - deallocate memory used to code-generate this
170 /// Function.
171 ///
172 void freeMachineCodeForFunction(Function *F);
173
Nate Begemand6b7a242009-02-18 08:31:02 +0000174 /// addPendingFunction - while jitting non-lazily, a called but non-codegen'd
Jim Grosbach124d0332011-03-16 01:21:55 +0000175 /// function was encountered. Add it to a pending list to be processed after
Nate Begemand6b7a242009-02-18 08:31:02 +0000176 /// the current function.
Reid Kleckner4b1511b2009-07-18 00:42:18 +0000177 ///
Nate Begemand6b7a242009-02-18 08:31:02 +0000178 void addPendingFunction(Function *F);
Reid Kleckner4b1511b2009-07-18 00:42:18 +0000179
Chris Lattnere7484012007-02-24 02:57:03 +0000180 /// getCodeEmitter - Return the code emitter this JIT is emitting into.
Reid Kleckner4b1511b2009-07-18 00:42:18 +0000181 ///
Bruno Cardoso Lopesa3f99f92009-05-30 20:51:52 +0000182 JITCodeEmitter *getCodeEmitter() const { return JCE; }
Reid Kleckner4b1511b2009-07-18 00:42:18 +0000183
Jeffrey Yasskinf0356fe2010-01-27 20:34:15 +0000184 static ExecutionEngine *createJIT(Module *M,
Reid Kleckner4b1511b2009-07-18 00:42:18 +0000185 std::string *ErrorStr,
Bill Wendling98a366d2009-04-29 23:29:43 +0000186 JITMemoryManager *JMM,
Eric Christopher88b5aca2009-11-17 21:58:16 +0000187 bool GVsWithCode,
Dylan Noblesmithc5b28582011-05-13 21:51:29 +0000188 TargetMachine *TM);
Argyrios Kyrtzidisb3a847d2009-05-18 21:06:40 +0000189
190 // Run the JIT on F and return information about the generated code
191 void runJITOnFunction(Function *F, MachineCodeInfo *MCI = 0);
192
Jeffrey Yasskindf5a7da2009-06-25 02:04:04 +0000193 virtual void RegisterJITEventListener(JITEventListener *L);
194 virtual void UnregisterJITEventListener(JITEventListener *L);
195 /// These functions correspond to the methods on JITEventListener. They
196 /// iterate over the registered listeners and call the corresponding method on
197 /// each.
198 void NotifyFunctionEmitted(
199 const Function &F, void *Code, size_t Size,
200 const JITEvent_EmittedFunctionDetails &Details);
Jeffrey Yasskin7a9034c2009-10-27 00:03:05 +0000201 void NotifyFreeingMachineCode(void *OldPtr);
Jeffrey Yasskindf5a7da2009-06-25 02:04:04 +0000202
Chris Lattner68feb222010-07-11 23:07:28 +0000203 BasicBlockAddressMapTy &
204 getBasicBlockAddressMap(const MutexGuard &) {
205 return BasicBlockAddressMap;
206 }
207
208
Chris Lattner836f6752002-12-24 00:01:22 +0000209private:
Reid Kleckner27632172009-09-20 23:52:43 +0000210 static JITCodeEmitter *createEmitter(JIT &J, JITMemoryManager *JMM,
211 TargetMachine &tm);
Dan Gohman21afcda2009-02-06 21:25:08 +0000212 void runJITOnFunctionUnlocked(Function *F, const MutexGuard &locked);
Nate Begemand6b7a242009-02-18 08:31:02 +0000213 void updateFunctionStub(Function *F);
Chris Lattner68feb222010-07-11 23:07:28 +0000214 void jitTheFunction(Function *F, const MutexGuard &locked);
Argyrios Kyrtzidisb3a847d2009-05-18 21:06:40 +0000215
Nicolas Geoffray46fa1392008-10-25 15:41:43 +0000216protected:
217
218 /// getMemoryforGV - Allocate memory for a global variable.
219 virtual char* getMemoryForGV(const GlobalVariable* GV);
220
Chris Lattner836f6752002-12-24 00:01:22 +0000221};
222
Brian Gaeked0fde302003-11-11 22:41:34 +0000223} // End llvm namespace
224
Chris Lattner836f6752002-12-24 00:01:22 +0000225#endif