Delete unnecessary elses.

[oota-llvm.git] / include / llvm / CodeGen / MachineRelocation.h

diff --git a/include/llvm/CodeGen/MachineRelocation.h b/include/llvm/CodeGen/MachineRelocation.h
index 80cd035445bb19695a87e414b6879e06bf2d7728..c5397819aee9606e48e79e5c9ac09cf74e71e40b 100644 (file)
--- 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.
-    isGVNonLazyPtr,   // Relocation of a Mac OS X NonLazy indirect reference.
+    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,14 +49,14 @@ 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 nonlazy 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
@@ -79,7 +79,7 @@ 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 GOTrelative = 0) {
@@ -96,19 +96,19 @@ public:
     return Result;
   }
 
-  /// MachineRelocation::getGVNonLazyPtr - Return a relocation entry for a
-  /// Mac OS X non-lazy GlobalValue indirect reference.
-  static MachineRelocation getGVNonLazyPtr(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 NeedStub = 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 = isGVNonLazyPtr;
+    Result.AddrType = isIndirectSym;
     Result.NeedStub = NeedStub;
     Result.GOTRelative = GOTrelative;
     Result.TargetResolve = false;
@@ -118,7 +118,7 @@ public:
 
   /// 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;
@@ -136,7 +136,7 @@ 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) {
     assert((RelocationType & ~63) == 0 && "Relocation type too large!");
@@ -155,7 +155,7 @@ public:
   /// MachineRelocation::getConstPool - Return a relocation entry for a constant
   /// pool entry.
   ///
-  static MachineRelocation getConstPool(intptr_t offset,unsigned RelocationType,
+  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!");
@@ -174,7 +174,7 @@ public:
   /// MachineRelocation::getJumpTable - Return a relocation entry for a jump
   /// table entry.
   ///
-  static MachineRelocation getJumpTable(intptr_t offset,unsigned RelocationType,
+  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!");
@@ -222,10 +222,10 @@ public:
     return AddrType == isGV;
   }
 
-  /// isGlobalValueNonLazyPtr - Return true if this relocation is the address
-  /// of a Mac OS X non-lazy indirect reference.
-  bool isGlobalValueNonLazyPtr() const {
-    return AddrType == isGVNonLazyPtr;
+  /// 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.
@@ -275,7 +275,7 @@ public:
   /// getGlobalValue - If this is a global value reference, return the
   /// referenced global.
   GlobalValue *getGlobalValue() const {
-    assert((isGlobalValue() || isGlobalValueNonLazyPtr()) &&
+    assert((isGlobalValue() || isIndirectSymbol()) &&
            "This is not a global value reference!");
     return Target.GV;
   }