X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FTarget%2FTargetJITInfo.h;h=f9bd0fb9f9818fd469082ff55c61434c285bad0e;hb=cf70590c38ef580758c8a255519959fc7160fdb2;hp=3be6cb79ce9141cc9efb00914747ebdfcdb03515;hpb=be8c03fc66b75fa775e1f47d62a1b0d803fced1c;p=oota-llvm.git

diff --git a/include/llvm/Target/TargetJITInfo.h b/include/llvm/Target/TargetJITInfo.h
index 3be6cb79ce9..f9bd0fb9f98 100644
--- a/include/llvm/Target/TargetJITInfo.h
+++ b/include/llvm/Target/TargetJITInfo.h
@@ -17,19 +17,20 @@
 #ifndef LLVM_TARGET_TARGETJITINFO_H
 #define LLVM_TARGET_TARGETJITINFO_H
 
+#include "llvm/Support/DataTypes.h"
+#include "llvm/Support/ErrorHandling.h"
 #include <cassert>
-#include <vector>
 
 namespace llvm {
   class Function;
-  class FunctionPassManager;
-  class MachineBasicBlock;
-  class MachineCodeEmitter;
+  class GlobalValue;
+  class JITCodeEmitter;
   class MachineRelocation;
 
   /// TargetJITInfo - Target specific information required by the Just-In-Time
   /// code generator.
   class TargetJITInfo {
+    virtual void anchor();
   public:
     virtual ~TargetJITInfo() {}
 
@@ -40,19 +41,39 @@ namespace llvm {
     ///
     virtual void replaceMachineCodeForFunction(void *Old, void *New) = 0;
 
-    /// emitGlobalValueLazyPtr - Use the specified MachineCodeEmitter object to
-    /// emit a lazy pointer which contains the address of the specified GV.
-    virtual void *emitGlobalValueLazyPtr(void *GV, MachineCodeEmitter &MCE) {
-      assert(0 && "This target doesn't implement emitGlobalValueLazyPtr!");
-      return 0;
+    /// emitGlobalValueIndirectSym - Use the specified JITCodeEmitter object
+    /// to emit an indirect symbol which contains the address of the specified
+    /// ptr.
+    virtual void *emitGlobalValueIndirectSym(const GlobalValue* GV, void *ptr,
+                                             JITCodeEmitter &JCE) {
+      llvm_unreachable("This target doesn't implement "
+                       "emitGlobalValueIndirectSym!");
     }
 
-    /// emitFunctionStub - Use the specified MachineCodeEmitter object to emit a
+    /// Records the required size and alignment for a call stub in bytes.
+    struct StubLayout {
+      size_t Size;
+      size_t Alignment;
+    };
+    /// Returns the maximum size and alignment for a call stub on this target.
+    virtual StubLayout getStubLayout() {
+      llvm_unreachable("This target doesn't implement getStubLayout!");
+    }
+
+    /// emitFunctionStub - Use the specified JITCodeEmitter object to emit a
     /// small native function that simply calls the function at the specified
-    /// address.  Return the address of the resultant function.
-    virtual void *emitFunctionStub(void *Fn, MachineCodeEmitter &MCE) {
-      assert(0 && "This target doesn't implement emitFunctionStub!");
-      return 0;
+    /// address.  The JITCodeEmitter must already have storage allocated for the
+    /// stub.  Return the address of the resultant function, which may have been
+    /// aligned from the address the JCE was set up to emit at.
+    virtual void *emitFunctionStub(const Function* F, void *Target,
+                                   JITCodeEmitter &JCE) {
+      llvm_unreachable("This target doesn't implement emitFunctionStub!");
+    }
+
+    /// getPICJumpTableEntry - Returns the value of the jumptable entry for the
+    /// specific basic block.
+    virtual uintptr_t getPICJumpTableEntry(uintptr_t BB, uintptr_t JTBase) {
+      llvm_unreachable("This target doesn't implement getPICJumpTableEntry!");
     }
 
     /// LazyResolverFn - This typedef is used to represent the function that
@@ -73,8 +94,7 @@ namespace llvm {
     /// function, and giving the JIT the target function used to do the lazy
     /// resolving.
     virtual LazyResolverFn getLazyResolverFunction(JITCompilerFn) {
-      assert(0 && "Not implemented for this target!");
-      return 0;
+      llvm_unreachable("Not implemented for this target!");
     }
 
     /// relocate - Before the JIT can run a block of code that has been emitted,
@@ -84,11 +104,31 @@ namespace llvm {
                           unsigned NumRelocs, unsigned char* GOTBase) {
       assert(NumRelocs == 0 && "This target does not have relocations!");
     }
+    
+
+    /// allocateThreadLocalMemory - Each target has its own way of
+    /// handling thread local variables. This method returns a value only
+    /// meaningful to the target.
+    virtual char* allocateThreadLocalMemory(size_t size) {
+      llvm_unreachable("This target does not implement thread local storage!");
+    }
 
     /// needsGOT - Allows a target to specify that it would like the
-    // JIT to manage a GOT for it.
+    /// JIT to manage a GOT for it.
     bool needsGOT() const { return useGOT; }
 
+    /// hasCustomConstantPool - Allows a target to specify that constant
+    /// pool address resolution is handled by the target.
+    virtual bool hasCustomConstantPool() const { return false; }
+
+    /// hasCustomJumpTables - Allows a target to specify that jumptables
+    /// are emitted by the target.
+    virtual bool hasCustomJumpTables() const { return false; }
+
+    /// allocateSeparateGVMemory - If true, globals should be placed in
+    /// separately allocated heap memory rather than in the same
+    /// code memory allocated by JITCodeEmitter.
+    virtual bool allocateSeparateGVMemory() const { return false; }
   protected:
     bool useGOT;
   };