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!

llvm-svn: 72040

llvm/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.
   ///

llvm/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) {

llvm/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.

llvm/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<void *> 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<JITEmitter>(MCE) && "Unexpected MCE?");
+  JITEmitter *JE = cast<JITEmitter>(getCodeEmitter());
+
+  JE->setMachineCodeInfo(mc);
+}
+
 void JIT::updateFunctionStub(Function *F) {
   // Get the empty stub we generated earlier.
   assert(isa<JITEmitter>(MCE) && "Unexpected MCE?");