From b3a847db0b991d3210706a2580428fdc2b6bf037 Mon Sep 17 00:00:00 2001 From: Argyrios Kyrtzidis Date: Mon, 18 May 2009 21:06:40 +0000 Subject: [PATCH] Allow the JIT ExecutionEngine to report details about the generated machine code. Introduce a new class (MachineCodeInfo) that the JIT can fill in with details. Right now, just the address and the size of the machine code are reported. Patch by Evan Phoenix! git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@72040 91177308-0d34-0410-b5e6-96231b3b80d8 --- .../llvm/ExecutionEngine/ExecutionEngine.h | 4 +++ lib/ExecutionEngine/JIT/JIT.cpp | 8 +++++- lib/ExecutionEngine/JIT/JIT.h | 11 +++++--- lib/ExecutionEngine/JIT/JITEmitter.cpp | 25 +++++++++++++++++-- 4 files changed, 42 insertions(+), 6 deletions(-) diff --git a/include/llvm/ExecutionEngine/ExecutionEngine.h b/include/llvm/ExecutionEngine/ExecutionEngine.h index 5df11f33ba0..0d171f6764d 100644 --- a/include/llvm/ExecutionEngine/ExecutionEngine.h +++ b/include/llvm/ExecutionEngine/ExecutionEngine.h @@ -35,6 +35,7 @@ class TargetData; class Type; class MutexGuard; class JITMemoryManager; +class MachineCodeInfo; class ExecutionEngineState { private: @@ -241,6 +242,9 @@ public: return getPointerToFunction(F); } + // The JIT overrides a version that actually does this. + virtual void runJITOnFunction(Function *F, MachineCodeInfo *MCI = 0) { } + /// getGlobalValueAtAddress - Return the LLVM global value object that starts /// at the specified address. /// diff --git a/lib/ExecutionEngine/JIT/JIT.cpp b/lib/ExecutionEngine/JIT/JIT.cpp index 21e670aadc9..522a08dd783 100644 --- a/lib/ExecutionEngine/JIT/JIT.cpp +++ b/lib/ExecutionEngine/JIT/JIT.cpp @@ -21,6 +21,7 @@ #include "llvm/ModuleProvider.h" #include "llvm/CodeGen/MachineCodeEmitter.h" #include "llvm/ExecutionEngine/GenericValue.h" +#include "llvm/CodeGen/MachineCodeInfo.h" #include "llvm/Target/TargetData.h" #include "llvm/Target/TargetMachine.h" #include "llvm/Target/TargetJITInfo.h" @@ -512,9 +513,14 @@ GenericValue JIT::runFunction(Function *F, /// just-in-time compilation passes on F, hopefully filling in /// GlobalAddress[F] with the address of F's machine code. /// -void JIT::runJITOnFunction(Function *F) { +void JIT::runJITOnFunction(Function *F, MachineCodeInfo *MCI) { MutexGuard locked(lock); + + registerMachineCodeInfo(MCI); + runJITOnFunctionUnlocked(F, locked); + + registerMachineCodeInfo(0); } void JIT::runJITOnFunctionUnlocked(Function *F, const MutexGuard &locked) { diff --git a/lib/ExecutionEngine/JIT/JIT.h b/lib/ExecutionEngine/JIT/JIT.h index d5646063e98..02955ab3ad8 100644 --- a/lib/ExecutionEngine/JIT/JIT.h +++ b/lib/ExecutionEngine/JIT/JIT.h @@ -23,6 +23,7 @@ class Function; class TargetMachine; class TargetJITInfo; class MachineCodeEmitter; +class MachineCodeInfo; class JITState { private: @@ -151,14 +152,18 @@ public: static ExecutionEngine *createJIT(ModuleProvider *MP, std::string *Err, JITMemoryManager *JMM, CodeGenOpt::Level OptLevel); - + + + // Run the JIT on F and return information about the generated code + void runJITOnFunction(Function *F, MachineCodeInfo *MCI = 0); + private: static MachineCodeEmitter *createEmitter(JIT &J, JITMemoryManager *JMM); - void runJITOnFunction(Function *F); + void registerMachineCodeInfo(MachineCodeInfo *MCI); void runJITOnFunctionUnlocked(Function *F, const MutexGuard &locked); void updateFunctionStub(Function *F); void updateDlsymStubTable(); - + protected: /// getMemoryforGV - Allocate memory for a global variable. diff --git a/lib/ExecutionEngine/JIT/JITEmitter.cpp b/lib/ExecutionEngine/JIT/JITEmitter.cpp index 58563563887..fe1d96ad19a 100644 --- a/lib/ExecutionEngine/JIT/JITEmitter.cpp +++ b/lib/ExecutionEngine/JIT/JITEmitter.cpp @@ -26,6 +26,7 @@ #include "llvm/CodeGen/MachineRelocation.h" #include "llvm/ExecutionEngine/JITMemoryManager.h" #include "llvm/ExecutionEngine/GenericValue.h" +#include "llvm/CodeGen/MachineCodeInfo.h" #include "llvm/Target/TargetData.h" #include "llvm/Target/TargetJITInfo.h" #include "llvm/Target/TargetMachine.h" @@ -614,9 +615,12 @@ namespace { // ExtFnStubs - A map of external function names to stubs which have entries // in the JITResolver's ExternalFnToStubMap. StringMap ExtFnStubs; - + + // MCI - A pointer to a MachineCodeInfo object to update with information. + MachineCodeInfo *MCI; + public: - JITEmitter(JIT &jit, JITMemoryManager *JMM) : Resolver(jit), CurFn(0) { + JITEmitter(JIT &jit, JITMemoryManager *JMM) : Resolver(jit), CurFn(0), MCI(0) { MemMgr = JMM ? JMM : JITMemoryManager::CreateDefaultMemManager(); if (jit.getJITInfo().needsGOT()) { MemMgr->AllocateGOT(); @@ -712,6 +716,10 @@ namespace { JITMemoryManager *getMemMgr(void) const { return MemMgr; } + void setMachineCodeInfo(MachineCodeInfo *mci) { + MCI = mci; + } + private: void *getPointerToGlobal(GlobalValue *GV, void *Reference, bool NoNeedStub); void *getPointerToGVIndirectSym(GlobalValue *V, void *Reference, @@ -1155,6 +1163,12 @@ bool JITEmitter::finishFunction(MachineFunction &F) { << "] Function: " << F.getFunction()->getName() << ": " << (FnEnd-FnStart) << " bytes of text, " << Relocations.size() << " relocations\n"; + + if (MCI) { + MCI->setAddress(FnStart); + MCI->setSize(FnEnd-FnStart); + } + Relocations.clear(); ConstPoolAddresses.clear(); @@ -1478,6 +1492,13 @@ void *JIT::getPointerToFunctionOrStub(Function *F) { return JE->getJITResolver().getFunctionStub(F); } +void JIT::registerMachineCodeInfo(MachineCodeInfo *mc) { + assert(isa(MCE) && "Unexpected MCE?"); + JITEmitter *JE = cast(getCodeEmitter()); + + JE->setMachineCodeInfo(mc); +} + void JIT::updateFunctionStub(Function *F) { // Get the empty stub we generated earlier. assert(isa(MCE) && "Unexpected MCE?"); -- 2.34.1