Allow the JIT ExecutionEngine to report details about the generated machine code.

[oota-llvm.git] / lib / ExecutionEngine / JIT / JIT.h

diff --git a/lib/ExecutionEngine/JIT/JIT.h b/lib/ExecutionEngine/JIT/JIT.h
index 5a3d6614dbc07d0c4d015149341ec668e83d2876..02955ab3ad8dd02f1fdb5bf4b87bbbb4099c2c06 100644 (file)
--- a/lib/ExecutionEngine/JIT/JIT.h
+++ b/lib/ExecutionEngine/JIT/JIT.h
@@ -2,8 +2,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file was developed by the LLVM research group and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
@@ -16,35 +16,34 @@
 
 #include "llvm/ExecutionEngine/ExecutionEngine.h"
 #include "llvm/PassManager.h"
-#include <map>
 
 namespace llvm {
 
 class Function;
-class GlobalValue;
-class Constant;
 class TargetMachine;
 class TargetJITInfo;
 class MachineCodeEmitter;
+class MachineCodeInfo;
 
 class JITState {
 private:
   FunctionPassManager PM;  // Passes to compile a function
+  ModuleProvider *MP;      // ModuleProvider used to create the PM
 
-  /// PendingGlobals - Global variables which have had memory allocated for them
-  /// while a function was code generated, but which have not been initialized
-  /// yet.
-  std::vector<const GlobalVariable*> PendingGlobals;
+  /// PendingFunctions - Functions which have not been code generated yet, but
+  /// were called from a function being code generated.
+  std::vector<Function*> PendingFunctions;
 
 public:
-  JITState(ModuleProvider *MP) : PM(MP) {}
+  explicit JITState(ModuleProvider *MP) : PM(MP), MP(MP) {}
 
   FunctionPassManager &getPM(const MutexGuard &L) {
     return PM;
   }
-
-  std::vector<const GlobalVariable*> &getPendingGlobals(const MutexGuard &L) {
-    return PendingGlobals;
+  
+  ModuleProvider *getMP() const { return MP; }
+  std::vector<Function*> &getPendingFunctions(const MutexGuard &L) {
+    return PendingFunctions;
   }
 };
 
@@ -54,9 +53,10 @@ class JIT : public ExecutionEngine {
   TargetJITInfo &TJI;      // The JITInfo for the target we are compiling to
   MachineCodeEmitter *MCE; // MCE object
 
-  JITState jitstate;
+  JITState *jitstate;
 
-  JIT(ModuleProvider *MP, TargetMachine &tm, TargetJITInfo &tji);
+  JIT(ModuleProvider *MP, TargetMachine &tm, TargetJITInfo &tji, 
+      JITMemoryManager *JMM, CodeGenOpt::Level OptLevel);
 public:
   ~JIT();
 
@@ -71,9 +71,26 @@ public:
   /// create - Create an return a new JIT compiler if there is one available
   /// for the current target.  Otherwise, return null.
   ///
-  static ExecutionEngine *create(ModuleProvider *MP, std::string* = 0);
+  static ExecutionEngine *create(ModuleProvider *MP, std::string *Err,
+                                 CodeGenOpt::Level OptLevel =
+                                   CodeGenOpt::Default) {
+    return createJIT(MP, Err, 0, OptLevel);
+  }
 
-  /// run - Start execution with the specified function and arguments.
+  virtual void addModuleProvider(ModuleProvider *MP);
+  
+  /// removeModuleProvider - Remove a ModuleProvider from the list of modules.
+  /// Relases the Module from the ModuleProvider, materializing it in the
+  /// process, and returns the materialized Module.
+  virtual Module *removeModuleProvider(ModuleProvider *MP,
+                                       std::string *ErrInfo = 0);
+
+  /// deleteModuleProvider - Remove a ModuleProvider from the list of modules,
+  /// and deletes the ModuleProvider and owned Module.  Avoids materializing 
+  /// the underlying module.
+  virtual void deleteModuleProvider(ModuleProvider *P,std::string *ErrInfo = 0);
+
+  /// runFunction - Start execution with the specified function and arguments.
   ///
   virtual GenericValue runFunction(Function *F,
                                    const std::vector<GenericValue> &ArgValues);
@@ -82,7 +99,12 @@ public:
   /// specified function by using the dlsym function call.  As such it is only
   /// useful for resolving library symbols, not code generated symbols.
   ///
-  void *getPointerToNamedFunction(const std::string &Name);
+  /// If AbortOnFailure is false and no function with the given name is
+  /// found, this function silently returns a null pointer. Otherwise,
+  /// it prints a message to stderr and aborts.
+  ///
+  void *getPointerToNamedFunction(const std::string &Name,
+                                  bool AbortOnFailure = true);
 
   // CompilationCallback - Invoked the first time that a call site is found,
   // which causes lazy compilation of the target function.
@@ -118,11 +140,35 @@ public:
   ///
   void freeMachineCodeForFunction(Function *F);
 
+  /// addPendingFunction - while jitting non-lazily, a called but non-codegen'd
+  /// function was encountered.  Add it to a pending list to be processed after 
+  /// the current function.
+  /// 
+  void addPendingFunction(Function *F);
+  
   /// getCodeEmitter - Return the code emitter this JIT is emitting into.
   MachineCodeEmitter *getCodeEmitter() const { return MCE; }
+  
+  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);
-  void runJITOnFunction (Function *F);
+  static MachineCodeEmitter *createEmitter(JIT &J, JITMemoryManager *JMM);
+  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.
+  virtual char* getMemoryForGV(const GlobalVariable* GV);
+
 };
 
 } // End llvm namespace