[llvm-commits] CVS: reopt/include/reopt/TraceJIT.h

[Brian Gaeke]

Changes in directory reopt/include/reopt:

TraceJIT.h added (r1.1)

---
Log message:

This header file containing the reoptimizer's JIT's public interface
was moved to include/reopt from lib/TraceJIT.


---
Diffs of the changes:  (+109 -0)

Index: reopt/include/reopt/TraceJIT.h
diff -c /dev/null reopt/include/reopt/TraceJIT.h:1.1
*** /dev/null	Wed Jun 30 01:33:27 2004
--- reopt/include/reopt/TraceJIT.h	Wed Jun 30 01:33:17 2004
***************
*** 0 ****
--- 1,109 ----
+ //===-- TraceJIT.h - Class definition for the TraceJIT ----------*- C++ -*-===//
+ // 
+ //                     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 defines the top-level TraceJIT data structure.
+ //
+ //===----------------------------------------------------------------------===//
+ 
+ #ifndef TRACEJIT_H
+ #define TRACEJIT_H
+ 
+ #include "llvm/ExecutionEngine/ExecutionEngine.h"
+ #include "llvm/PassManager.h"
+ #include "Support/DataTypes.h"
+ #include <map>
+ 
+ namespace llvm {
+ 
+ class Function;
+ class GlobalValue;
+ class Constant;
+ class TargetMachine;
+ class TargetJITInfo;
+ class MachineCodeEmitter;
+ class TraceFunction;
+ class UnpackTraceFunction;
+ 
+ class TraceJIT : public ExecutionEngine {
+   TargetMachine &TM;       // The current target we are compiling to
+   TargetJITInfo &TJI;      // The TargetJITInfo for the current target
+   
+   FunctionPassManager PM;   // Passes to compile a TraceFunction
+   MachineCodeEmitter *MCE;  // Optimized trace code emitter
+   UnpackTraceFunction *UTF; // TraceFunction unpacker
+ 
+   /// 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;
+ 
+   TraceJIT(ModuleProvider *MP, TargetMachine &tm, TargetJITInfo &tji);
+ public:
+   ~TraceJIT();
+ 
+   /// create - Create an return a new TraceJIT compiler if there is one available
+   /// for the current target.  Otherwise, return null.  If the TraceJIT is created
+   /// successfully, it takes responsibility for deleting the specified
+   /// IntrinsicLowering implementation.
+   ///
+   static TraceJIT *create(ModuleProvider *MP, IntrinsicLowering *IL = 0);
+ 
+   /// run - Start execution with the specified function and arguments.
+   ///
+   virtual GenericValue runFunction(Function *F,
+                                    const std::vector<GenericValue> &ArgValues);
+ 
+   /// getPointerToNamedFunction - This method returns the address of the
+   /// 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);
+ 
+   // CompilationCallback - Invoked the first time that a call site is found,
+   // which causes lazy compilation of the target function.
+   // 
+   static void CompilationCallback();
+ 
+   /// getPointerToFunction - This returns the address of the specified function,
+   /// compiling it if necessary.
+   ///
+   void *getPointerToFunction(Function *F);
+ 
+   /// getOrEmitGlobalVariable - Return the address of the specified global
+   /// variable, possibly emitting it to memory if needed.  This is used by the
+   /// Emitter.
+   void *getOrEmitGlobalVariable(const GlobalVariable *GV);
+ 
+   /// getPointerToFunctionOrStub - If the specified function has been
+   /// code-gen'd, return a pointer to the function.  If not, compile it, or use
+   /// a stub to implement lazy compilation if available.
+   ///
+   void *getPointerToFunctionOrStub(Function *F);
+ 
+   /// 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 TraceJIT::getPointerToFunction().
+   ///
+   void *recompileAndRelinkFunction(Function *F);
+ 
+   uint64_t compileTraceFunction (TraceFunction *TF);
+ 
+   MachineCodeEmitter *getEmitter() { return MCE; }
+ private:
+   void addPassesToReoptimizeTrace (FunctionPassManager &PM);
+   void maybeAddInternalGlobal (GlobalValue *GV, unsigned int &Counter);
+   void addInternalGlobalMappings (Module &M);
+   void runJITOnFunction (Function *F);
+ };
+ 
+ } // End llvm namespace
+ 
+ #endif