Merge System into Support.

[oota-llvm.git] / include / llvm / Target / TargetJITInfo.h

diff --git a/include/llvm/Target/TargetJITInfo.h b/include/llvm/Target/TargetJITInfo.h
index c78a212540f752ffa8610f411ea5066ccd8adb35..b198eb62f0c6f135920e79074ac86002044321d2 100644 (file)
--- a/include/llvm/Target/TargetJITInfo.h
+++ b/include/llvm/Target/TargetJITInfo.h
@@ -17,14 +17,14 @@
 #ifndef LLVM_TARGET_TARGETJITINFO_H
 #define LLVM_TARGET_TARGETJITINFO_H
 
-#include <vector>
 #include <cassert>
+#include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/DataTypes.h"
 
 namespace llvm {
   class Function;
-  class MachineBasicBlock;
-  class MachineCodeEmitter;
+  class GlobalValue;
+  class JITCodeEmitter;
   class MachineRelocation;
 
   /// TargetJITInfo - Target specific information required by the Just-In-Time
@@ -40,24 +40,41 @@ 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!");
+    /// 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) {
+      assert(0 && "This target doesn't implement emitGlobalValueIndirectSym!");
       return 0;
     }
 
-    /// 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!");
+      StubLayout Result = {0, 0};
+      return Result;
+    }
+
+    /// 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) {
+    /// 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) {
       assert(0 && "This target doesn't implement emitFunctionStub!");
       return 0;
     }
 
     /// getPICJumpTableEntry - Returns the value of the jumptable entry for the
     /// specific basic block.
-    virtual intptr_t getPICJumpTableEntry(intptr_t BB, intptr_t JTBase) {
+    virtual uintptr_t getPICJumpTableEntry(uintptr_t BB, uintptr_t JTBase) {
       assert(0 && "This target doesn't implement getPICJumpTableEntry!");
       return 0;
     }
@@ -91,11 +108,32 @@ 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) {
+      assert(0 && "This target does not implement thread local storage!");
+      return 0;
+    }
 
     /// 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;
   };