X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FCodeGen%2FMachineRelocation.h;h=244b466e172826a465e2ed6143cd04cba3aa7b97;hb=7016cf66ee21ddf3f7823d4e332b2cb84953bebd;hp=689881b29163df8d06ea063fba02a43b8d616b36;hpb=be8c03fc66b75fa775e1f47d62a1b0d803fced1c;p=oota-llvm.git

diff --git a/include/llvm/CodeGen/MachineRelocation.h b/include/llvm/CodeGen/MachineRelocation.h
index 689881b2916..244b466e172 100644
--- a/include/llvm/CodeGen/MachineRelocation.h
+++ b/include/llvm/CodeGen/MachineRelocation.h
@@ -39,7 +39,7 @@ class MachineRelocation {
   enum AddressType {
     isResult,         // Relocation has be transformed into its result pointer.
     isGV,             // The Target.GV field is valid.
-    isGVLazyPtr,      // Relocation of a lazily resolved GV address.
+    isIndirectSym,    // Relocation of an indirect symbol.
     isBB,             // Relocation of BB address.
     isExtSym,         // The Target.ExtSym field is valid.
     isConstPool,      // Relocation of constant pool address.
@@ -49,24 +49,25 @@ class MachineRelocation {
   
   /// Offset - This is the offset from the start of the code buffer of the
   /// relocation to perform.
-  intptr_t Offset;
+  uintptr_t Offset;
   
   /// ConstantVal - A field that may be used by the target relocation type.
   intptr_t ConstantVal;
 
   union {
     void *Result;           // If this has been resolved to a resolved pointer
-    GlobalValue *GV;        // If this is a pointer to a GV or a GV lazy ptr
+    GlobalValue *GV;        // If this is a pointer to a GV or an indirect ref.
     MachineBasicBlock *MBB; // If this is a pointer to a LLVM BB
     const char *ExtSym;     // If this is a pointer to a named symbol
     unsigned Index;         // Constant pool / jump table index
     unsigned GOTIndex;      // Index in the GOT of this symbol/global
   } Target;
 
-  unsigned TargetReloType : 6; // The target relocation ID.
-  AddressType AddrType    : 4; // The field of Target to use.
-  bool NeedStub           : 1; // True if this relocation requires a stub.
+  unsigned TargetReloType : 6; // The target relocation ID
+  AddressType AddrType    : 4; // The field of Target to use
+  bool MayNeedFarStub     : 1; // True if this relocation may require a far-stub
   bool GOTRelative        : 1; // Should this relocation be relative to the GOT?
+  bool TargetResolve      : 1; // True if target should resolve the address
 
 public:
  // Relocation types used in a generic implementation.  Currently, relocation
@@ -78,9 +79,9 @@ public:
   
   /// MachineRelocation::getGV - Return a relocation entry for a GlobalValue.
   ///
-  static MachineRelocation getGV(intptr_t offset, unsigned RelocationType, 
+  static MachineRelocation getGV(uintptr_t offset, unsigned RelocationType, 
                                  GlobalValue *GV, intptr_t cst = 0,
-                                 bool NeedStub = 0,
+                                 bool MayNeedFarStub = 0,
                                  bool GOTrelative = 0) {
     assert((RelocationType & ~63) == 0 && "Relocation type too large!");
     MachineRelocation Result;
@@ -88,34 +89,36 @@ public:
     Result.ConstantVal = cst;
     Result.TargetReloType = RelocationType;
     Result.AddrType = isGV;
-    Result.NeedStub = NeedStub;
+    Result.MayNeedFarStub = MayNeedFarStub;
     Result.GOTRelative = GOTrelative;
+    Result.TargetResolve = false;
     Result.Target.GV = GV;
     return Result;
   }
 
-  /// MachineRelocation::getGVLazyPtr - Return a relocation entry for a
-  /// lazily resolved GlobalValue address.
-  static MachineRelocation getGVLazyPtr(intptr_t offset,
-                                 unsigned RelocationType, 
-                                 GlobalValue *GV, intptr_t cst = 0,
-                                 bool NeedStub = 0,
-                                 bool GOTrelative = 0) {
+  /// MachineRelocation::getIndirectSymbol - Return a relocation entry for an
+  /// indirect symbol.
+  static MachineRelocation getIndirectSymbol(uintptr_t offset,
+                                             unsigned RelocationType, 
+                                             GlobalValue *GV, intptr_t cst = 0,
+                                             bool MayNeedFarStub = 0,
+                                             bool GOTrelative = 0) {
     assert((RelocationType & ~63) == 0 && "Relocation type too large!");
     MachineRelocation Result;
     Result.Offset = offset;
     Result.ConstantVal = cst;
     Result.TargetReloType = RelocationType;
-    Result.AddrType = isGVLazyPtr;
-    Result.NeedStub = NeedStub;
+    Result.AddrType = isIndirectSym;
+    Result.MayNeedFarStub = MayNeedFarStub;
     Result.GOTRelative = GOTrelative;
+    Result.TargetResolve = false;
     Result.Target.GV = GV;
     return Result;
   }
 
   /// MachineRelocation::getBB - Return a relocation entry for a BB.
   ///
-  static MachineRelocation getBB(intptr_t offset,unsigned RelocationType,
+  static MachineRelocation getBB(uintptr_t offset,unsigned RelocationType,
                                  MachineBasicBlock *MBB, intptr_t cst = 0) {
     assert((RelocationType & ~63) == 0 && "Relocation type too large!");
     MachineRelocation Result;
@@ -123,8 +126,9 @@ public:
     Result.ConstantVal = cst;
     Result.TargetReloType = RelocationType;
     Result.AddrType = isBB;
-    Result.NeedStub = false;
+    Result.MayNeedFarStub = false;
     Result.GOTRelative = false;
+    Result.TargetResolve = false;
     Result.Target.MBB = MBB;
     return Result;
   }
@@ -132,17 +136,19 @@ public:
   /// MachineRelocation::getExtSym - Return a relocation entry for an external
   /// symbol, like "free".
   ///
-  static MachineRelocation getExtSym(intptr_t offset, unsigned RelocationType, 
+  static MachineRelocation getExtSym(uintptr_t offset, unsigned RelocationType, 
                                      const char *ES, intptr_t cst = 0,
-                                     bool GOTrelative = 0) {
+                                     bool GOTrelative = 0,
+                                     bool NeedStub = true) {
     assert((RelocationType & ~63) == 0 && "Relocation type too large!");
     MachineRelocation Result;
     Result.Offset = offset;
     Result.ConstantVal = cst;
     Result.TargetReloType = RelocationType;
     Result.AddrType = isExtSym;
-    Result.NeedStub = false;
+    Result.MayNeedFarStub = NeedStub;
     Result.GOTRelative = GOTrelative;
+    Result.TargetResolve = false;
     Result.Target.ExtSym = ES;
     return Result;
   }
@@ -150,16 +156,18 @@ public:
   /// MachineRelocation::getConstPool - Return a relocation entry for a constant
   /// pool entry.
   ///
-  static MachineRelocation getConstPool(intptr_t offset,unsigned RelocationType,
-                                        unsigned CPI, intptr_t cst = 0) {
+  static MachineRelocation getConstPool(uintptr_t offset,unsigned RelocationType,
+                                        unsigned CPI, intptr_t cst = 0,
+                                        bool letTargetResolve = false) {
     assert((RelocationType & ~63) == 0 && "Relocation type too large!");
     MachineRelocation Result;
     Result.Offset = offset;
     Result.ConstantVal = cst;
     Result.TargetReloType = RelocationType;
     Result.AddrType = isConstPool;
-    Result.NeedStub = false;
+    Result.MayNeedFarStub = false;
     Result.GOTRelative = false;
+    Result.TargetResolve = letTargetResolve;
     Result.Target.Index = CPI;
     return Result;
   }
@@ -167,16 +175,18 @@ public:
   /// MachineRelocation::getJumpTable - Return a relocation entry for a jump
   /// table entry.
   ///
-  static MachineRelocation getJumpTable(intptr_t offset,unsigned RelocationType,
-                                        unsigned JTI, intptr_t cst = 0) {
+  static MachineRelocation getJumpTable(uintptr_t offset,unsigned RelocationType,
+                                        unsigned JTI, intptr_t cst = 0,
+                                        bool letTargetResolve = false) {
     assert((RelocationType & ~63) == 0 && "Relocation type too large!");
     MachineRelocation Result;
     Result.Offset = offset;
     Result.ConstantVal = cst;
     Result.TargetReloType = RelocationType;
     Result.AddrType = isJumpTable;
-    Result.NeedStub = false;
+    Result.MayNeedFarStub = false;
     Result.GOTRelative = false;
+    Result.TargetResolve = letTargetResolve;
     Result.Target.Index = JTI;
     return Result;
   }
@@ -213,10 +223,10 @@ public:
     return AddrType == isGV;
   }
 
-  /// isGlobalValueVLazyPtr - Return true if this relocation is the address
-  /// of a lazily resolved GlobalValue.
-  bool isGlobalValueLazyPtr() const {
-    return AddrType == isGVLazyPtr;
+  /// isIndirectSymbol - Return true if this relocation is the address an
+  /// indirect symbol
+  bool isIndirectSymbol() const {
+    return AddrType == isIndirectSym;
   }
 
   /// isBasicBlock - Return true if this relocation is a basic block reference.
@@ -225,9 +235,9 @@ public:
     return AddrType == isBB;
   }
 
-  /// isString - Return true if this is a constant string.
+  /// isExternalSymbol - Return true if this is a constant string.
   ///
-  bool isString() const {
+  bool isExternalSymbol() const {
     return AddrType == isExtSym;
   }
 
@@ -249,18 +259,26 @@ public:
     return GOTRelative;
   }
 
-  /// doesntNeedStub - This function returns true if the JIT for this target
-  /// target is capable of directly handling the relocated GlobalValue reference
-  /// without using either a stub function or issuing an extra load to get the
-  /// GV address.
-  bool doesntNeedStub() const {
-    return !NeedStub;
+  /// mayNeedFarStub - This function returns true if the JIT for this target may
+  /// need either a stub function or an indirect global-variable load to handle
+  /// the relocated GlobalValue reference.  For example, the x86-64 call
+  /// instruction can only call functions within +/-2GB of the call site.
+  /// Anything farther away needs a longer mov+call sequence, which can't just
+  /// be written on top of the existing call.
+  bool mayNeedFarStub() const {
+    return MayNeedFarStub;
+  }
+
+  /// letTargetResolve - Return true if the target JITInfo is usually
+  /// responsible for resolving the address of this relocation.
+  bool letTargetResolve() const {
+    return TargetResolve;
   }
 
   /// getGlobalValue - If this is a global value reference, return the
   /// referenced global.
   GlobalValue *getGlobalValue() const {
-    assert((isGlobalValue() || isGlobalValueLazyPtr()) &&
+    assert((isGlobalValue() || isIndirectSymbol()) &&
            "This is not a global value reference!");
     return Target.GV;
   }
@@ -272,8 +290,8 @@ public:
 
   /// getString - If this is a string value, return the string reference.
   ///
-  const char *getString() const {
-    assert(isString() && "This is not a string reference!");
+  const char *getExternalSymbol() const {
+    assert(isExternalSymbol() && "This is not an external symbol reference!");
     return Target.ExtSym;
   }