RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2025-04-03 08:11:52 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Refactor running the JIT passes on a single function into the new method,

Browse Source 
runJITOnFunction().

Add new method for recompiling and patching in new versions of functions,
recompileAndRelinkFunction().

llvm-svn: 9199
This commit is contained in:
Brian Gaeke 2003-10-17 18:27:00 +00:00
parent a4bca57c6e
commit 7b9b6dbd63
1 changed files with 37 additions and 9 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
lib/ExecutionEngine/JIT/VM.cpp
View File

@ -37,11 +37,25 @@ void VM::setupPassManager() {
} }
} }
/// runJITOnFunction - Run the FunctionPassManager full of
/// just-in-time compilation passes on F, hopefully filling in
/// GlobalAddress[F] with the address of F's machine code.
///
void VM::runJITOnFunction (Function *F) {
static bool isAlreadyCodeGenerating = false;
assert(!isAlreadyCodeGenerating && "ERROR: RECURSIVE COMPILATION DETECTED!");
// JIT the function
isAlreadyCodeGenerating = true;
PM.run(*F);
isAlreadyCodeGenerating = false;
}
/// getPointerToFunction - This method is used to get the address of the /// getPointerToFunction - This method is used to get the address of the
/// specified function, compiling it if neccesary. /// specified function, compiling it if neccesary.
/// ///
void *VM::getPointerToFunction(Function *F) { void *VM::getPointerToFunction(Function *F) {
void *&Addr = GlobalAddress[F]; // Function already code gen'd void *&Addr = GlobalAddress[F]; // Check if function already code gen'd
if (Addr) return Addr; if (Addr) return Addr;
// Make sure we read in the function if it exists in this Module // Make sure we read in the function if it exists in this Module
@ -50,14 +64,28 @@ void *VM::getPointerToFunction(Function *F) {
if (F->isExternal()) if (F->isExternal())
return Addr = getPointerToNamedFunction(F->getName()); return Addr = getPointerToNamedFunction(F->getName());
static bool isAlreadyCodeGenerating = false; runJITOnFunction (F);
assert(!isAlreadyCodeGenerating && "ERROR: RECURSIVE COMPILATION DETECTED!");
// JIT the function
isAlreadyCodeGenerating = true;
PM.run(*F);
isAlreadyCodeGenerating = false;
assert(Addr && "Code generation didn't add function to GlobalAddress table!"); assert(Addr && "Code generation didn't add function to GlobalAddress table!");
return Addr; return Addr;
} }
/// recompileAndRelinkFunction - This method is used to force a function
/// which has already been compiled, to be compiled again, possibly
/// after it has been modified. Then the entry to the old copy is overwritten
/// with a branch to the new copy. If there was no old copy, this acts
/// just like VM::getPointerToFunction().
///
void *VM::recompileAndRelinkFunction(Function *F) {
void *&Addr = GlobalAddress[F]; // Check if function already code gen'd
// If it's not already compiled (this is kind of weird) there is no
// reason to patch it up.
if (!Addr) { return getPointerToFunction (F); }
void *OldAddr = Addr;
Addr = 0;
runJITOnFunction (F);
assert(Addr && "Code generation didn't add function to GlobalAddress table!");
TM.replaceMachineCodeForFunction (OldAddr, Addr);
return Addr;
}