blob: a2f2275384f2dca69d1d55c03d8e3974bc56aee5 [file] [log] [blame]
Chris Lattner4d326fa2003-12-20 01:46:27 +00001//===-- JIT.cpp - LLVM Just in Time Compiler ------------------------------===//
John Criswellb576c942003-10-20 19:43:21 +00002//
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//===----------------------------------------------------------------------===//
Chris Lattnerbd199fb2002-12-24 00:01:05 +00009//
Chris Lattner4d326fa2003-12-20 01:46:27 +000010// This tool implements a just-in-time compiler for LLVM, allowing direct
11// execution of LLVM bytecode in an efficient manner.
Chris Lattnerbd199fb2002-12-24 00:01:05 +000012//
13//===----------------------------------------------------------------------===//
14
Chris Lattner4d326fa2003-12-20 01:46:27 +000015#include "JIT.h"
Chris Lattnerc07ed132003-12-20 03:36:47 +000016#include "llvm/DerivedTypes.h"
Chris Lattner4d326fa2003-12-20 01:46:27 +000017#include "llvm/Function.h"
Chris Lattnerc07ed132003-12-20 03:36:47 +000018#include "llvm/GlobalVariable.h"
Misha Brukman0f4f7d92003-10-16 21:19:34 +000019#include "llvm/ModuleProvider.h"
Chris Lattner4d326fa2003-12-20 01:46:27 +000020#include "llvm/CodeGen/MachineCodeEmitter.h"
21#include "llvm/CodeGen/MachineFunction.h"
Brian Gaeke97222942003-09-05 19:39:22 +000022#include "llvm/ExecutionEngine/GenericValue.h"
Chris Lattnerbd199fb2002-12-24 00:01:05 +000023#include "llvm/Target/TargetMachine.h"
Chris Lattner4d326fa2003-12-20 01:46:27 +000024#include "llvm/Target/TargetJITInfo.h"
Chris Lattnerc07ed132003-12-20 03:36:47 +000025#include "Support/DynamicLinker.h"
Reid Spencer954da372004-07-04 12:19:56 +000026#include <iostream>
27
Chris Lattnerc19aade2003-12-08 08:06:28 +000028using namespace llvm;
Misha Brukmanabb027c2003-05-27 21:40:39 +000029
Chris Lattner4d326fa2003-12-20 01:46:27 +000030JIT::JIT(ModuleProvider *MP, TargetMachine &tm, TargetJITInfo &tji)
Chris Lattner1e60a912003-12-20 01:22:19 +000031 : ExecutionEngine(MP), TM(tm), TJI(tji), PM(MP) {
Chris Lattnerbd199fb2002-12-24 00:01:05 +000032 setTargetData(TM.getTargetData());
Misha Brukmanabb027c2003-05-27 21:40:39 +000033
34 // Initialize MCE
Misha Brukman906f5fa2003-06-02 03:23:16 +000035 MCE = createEmitter(*this);
Chris Lattner1e60a912003-12-20 01:22:19 +000036
Brian Gaeke50872d52004-04-14 17:45:52 +000037 // Add target data
38 PM.add (new TargetData (TM.getTargetData ()));
39
Chris Lattner4d326fa2003-12-20 01:46:27 +000040 // Compile LLVM Code down to machine code in the intermediate representation
41 TJI.addPassesToJITCompile(PM);
42
43 // Turn the machine code intermediate representation into bytes in memory that
44 // may be executed.
45 if (TM.addPassesToEmitMachineCode(PM, *MCE)) {
46 std::cerr << "lli: target '" << TM.getName()
47 << "' doesn't support machine code emission!\n";
48 abort();
49 }
Chris Lattnerbd199fb2002-12-24 00:01:05 +000050}
51
Chris Lattner4d326fa2003-12-20 01:46:27 +000052JIT::~JIT() {
53 delete MCE;
54 delete &TM;
55}
56
Brian Gaeke70975ee2003-09-05 18:42:01 +000057/// run - Start execution with the specified function and arguments.
Chris Lattner05a1a302003-08-21 21:32:12 +000058///
Chris Lattnerff0f1bb2003-12-26 06:13:47 +000059GenericValue JIT::runFunction(Function *F,
60 const std::vector<GenericValue> &ArgValues) {
Chris Lattnerb47130c2004-08-15 23:29:50 +000061 assert(F && "Function *F was null at entry to run()");
62 GenericValue rv;
63
64 void *FPtr = getPointerToFunction(F);
Chris Lattner7c45d782004-08-15 23:31:43 +000065 assert(FPtr && "Pointer to fn's code was null after getPointerToFunction");
Chris Lattnerd297aea2004-08-15 23:34:48 +000066 const Type *RetTy = F->getReturnType();
Chris Lattnerbd199fb2002-12-24 00:01:05 +000067
Chris Lattnerd297aea2004-08-15 23:34:48 +000068 // Handle some common cases first.
69 if (RetTy == Type::IntTy || RetTy == Type::UIntTy || RetTy == Type::VoidTy) {
70 if (ArgValues.size() == 3) {
71 int (*PF)(int, char **, const char **) =
72 (int(*)(int, char **, const char **))FPtr;
73
74 // Call the function.
75 rv.IntVal = PF(ArgValues[0].IntVal, (char **)GVTOP(ArgValues[1]),
76 (const char **)GVTOP(ArgValues[2]));
77 return rv;
78 } else if (ArgValues.size() == 1) {
79 int (*PF)(int) = (int(*)(int))FPtr;
80 rv.IntVal = PF(ArgValues[0].IntVal);
81 return rv;
82 } else if (ArgValues.size() == 0) {
83 int (*PF)() = (int(*)())FPtr;
84 rv.IntVal = PF();
85 return rv;
86 }
Chris Lattnerff0f1bb2003-12-26 06:13:47 +000087 }
Chris Lattnerbd199fb2002-12-24 00:01:05 +000088
Chris Lattnerb47130c2004-08-15 23:29:50 +000089 // FIXME: This code should handle a couple of common cases efficiently, but
90 // it should also implement the general case by code-gening a new anonymous
91 // nullary function to call.
92 std::cerr << "Sorry, unimplemented feature in the LLVM JIT. See LLVM"
93 << " PR#419\n for details.\n";
94 abort();
Brian Gaeke70975ee2003-09-05 18:42:01 +000095 return rv;
Chris Lattnerbd199fb2002-12-24 00:01:05 +000096}
Chris Lattner4d326fa2003-12-20 01:46:27 +000097
98/// runJITOnFunction - Run the FunctionPassManager full of
99/// just-in-time compilation passes on F, hopefully filling in
100/// GlobalAddress[F] with the address of F's machine code.
101///
102void JIT::runJITOnFunction(Function *F) {
103 static bool isAlreadyCodeGenerating = false;
104 assert(!isAlreadyCodeGenerating && "Error: Recursive compilation detected!");
105
106 // JIT the function
107 isAlreadyCodeGenerating = true;
108 PM.run(*F);
109 isAlreadyCodeGenerating = false;
Chris Lattnerc07ed132003-12-20 03:36:47 +0000110
111 // If the function referred to a global variable that had not yet been
112 // emitted, it allocates memory for the global, but doesn't emit it yet. Emit
113 // all of these globals now.
114 while (!PendingGlobals.empty()) {
115 const GlobalVariable *GV = PendingGlobals.back();
116 PendingGlobals.pop_back();
117 EmitGlobalVariable(GV);
118 }
Chris Lattner4d326fa2003-12-20 01:46:27 +0000119}
120
121/// getPointerToFunction - This method is used to get the address of the
122/// specified function, compiling it if neccesary.
123///
124void *JIT::getPointerToFunction(Function *F) {
Chris Lattnerc07ed132003-12-20 03:36:47 +0000125 if (void *Addr = getPointerToGlobalIfAvailable(F))
126 return Addr; // Check if function already code gen'd
Chris Lattner4d326fa2003-12-20 01:46:27 +0000127
128 // Make sure we read in the function if it exists in this Module
Chris Lattnerda79bd22004-02-01 00:32:35 +0000129 try {
130 MP->materializeFunction(F);
Reid Spencere2947532004-07-07 21:01:38 +0000131 } catch ( std::string& errmsg ) {
Reid Spencerf86cafd2004-07-07 21:20:28 +0000132 std::cerr << "Error reading bytecode file: " << errmsg << "\n";
Reid Spencere2947532004-07-07 21:01:38 +0000133 abort();
Chris Lattnerda79bd22004-02-01 00:32:35 +0000134 } catch (...) {
Reid Spencerf86cafd2004-07-07 21:20:28 +0000135 std::cerr << "Error reading bytecode file!\n";
Chris Lattnerda79bd22004-02-01 00:32:35 +0000136 abort();
137 }
Chris Lattner4d326fa2003-12-20 01:46:27 +0000138
Chris Lattnerc07ed132003-12-20 03:36:47 +0000139 if (F->isExternal()) {
140 void *Addr = getPointerToNamedFunction(F->getName());
141 addGlobalMapping(F, Addr);
142 return Addr;
143 }
Chris Lattner4d326fa2003-12-20 01:46:27 +0000144
145 runJITOnFunction(F);
Chris Lattnerc07ed132003-12-20 03:36:47 +0000146
147 void *Addr = getPointerToGlobalIfAvailable(F);
Chris Lattner4d326fa2003-12-20 01:46:27 +0000148 assert(Addr && "Code generation didn't add function to GlobalAddress table!");
149 return Addr;
150}
151
152// getPointerToFunctionOrStub - If the specified function has been
153// code-gen'd, return a pointer to the function. If not, compile it, or use
154// a stub to implement lazy compilation if available.
155//
156void *JIT::getPointerToFunctionOrStub(Function *F) {
157 // If we have already code generated the function, just return the address.
Chris Lattnerc07ed132003-12-20 03:36:47 +0000158 if (void *Addr = getPointerToGlobalIfAvailable(F))
159 return Addr;
Chris Lattner4d326fa2003-12-20 01:46:27 +0000160
161 // If the target supports "stubs" for functions, get a stub now.
162 if (void *Ptr = TJI.getJITStubForFunction(F, *MCE))
163 return Ptr;
164
165 // Otherwise, if the target doesn't support it, just codegen the function.
166 return getPointerToFunction(F);
167}
168
Chris Lattnerc07ed132003-12-20 03:36:47 +0000169/// getOrEmitGlobalVariable - Return the address of the specified global
170/// variable, possibly emitting it to memory if needed. This is used by the
171/// Emitter.
172void *JIT::getOrEmitGlobalVariable(const GlobalVariable *GV) {
173 void *Ptr = getPointerToGlobalIfAvailable(GV);
174 if (Ptr) return Ptr;
175
176 // If the global is external, just remember the address.
177 if (GV->isExternal()) {
178 Ptr = GetAddressOfSymbol(GV->getName().c_str());
179 if (Ptr == 0) {
180 std::cerr << "Could not resolve external global address: "
181 << GV->getName() << "\n";
182 abort();
183 }
184 } else {
185 // If the global hasn't been emitted to memory yet, allocate space. We will
186 // actually initialize the global after current function has finished
187 // compilation.
188 Ptr =new char[getTargetData().getTypeSize(GV->getType()->getElementType())];
189 PendingGlobals.push_back(GV);
190 }
191 addGlobalMapping(GV, Ptr);
192 return Ptr;
193}
194
195
Chris Lattner4d326fa2003-12-20 01:46:27 +0000196/// recompileAndRelinkFunction - This method is used to force a function
197/// which has already been compiled, to be compiled again, possibly
198/// after it has been modified. Then the entry to the old copy is overwritten
199/// with a branch to the new copy. If there was no old copy, this acts
200/// just like JIT::getPointerToFunction().
201///
202void *JIT::recompileAndRelinkFunction(Function *F) {
Chris Lattnerc07ed132003-12-20 03:36:47 +0000203 void *OldAddr = getPointerToGlobalIfAvailable(F);
Chris Lattner4d326fa2003-12-20 01:46:27 +0000204
Chris Lattnerc07ed132003-12-20 03:36:47 +0000205 // If it's not already compiled there is no reason to patch it up.
206 if (OldAddr == 0) { return getPointerToFunction(F); }
Chris Lattner4d326fa2003-12-20 01:46:27 +0000207
Chris Lattnerc07ed132003-12-20 03:36:47 +0000208 // Delete the old function mapping.
209 addGlobalMapping(F, 0);
210
Chris Lattnerc07ed132003-12-20 03:36:47 +0000211 // Recodegen the function
Chris Lattner4d326fa2003-12-20 01:46:27 +0000212 runJITOnFunction(F);
Chris Lattnerc07ed132003-12-20 03:36:47 +0000213
214 // Update state, forward the old function to the new function.
215 void *Addr = getPointerToGlobalIfAvailable(F);
Chris Lattner4d326fa2003-12-20 01:46:27 +0000216 assert(Addr && "Code generation didn't add function to GlobalAddress table!");
217 TJI.replaceMachineCodeForFunction(OldAddr, Addr);
218 return Addr;
219}