make Constant::getRelocationInfo return an enum, as suggested by Duncan.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@76938 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/llvm/CodeGen/MachineConstantPool.h b/include/llvm/CodeGen/MachineConstantPool.h
index 5ae641f..59d8e63 100644 (file)
--- a/include/llvm/CodeGen/MachineConstantPool.h
+++ b/include/llvm/CodeGen/MachineConstantPool.h
@@ -47,14 +47,7 @@ public:
   /// getRelocationInfo - This method classifies the entry according to
   /// whether or not it may generate a relocation entry.  This must be
   /// conservative, so if it might codegen to a relocatable entry, it should say
-  /// so.  The return values are:
-  /// 
-  ///  0: This constant pool entry is guaranteed to never have a relocation
-  ///     applied to it (because it holds a simple constant like '4').
-  ///  1: This entry has relocations, but the entries are guaranteed to be
-  ///     resolvable by the static linker, so the dynamic linker will never see
-  ///     them.
-  ///  2: This entry may have arbitrary relocations. 
+  /// so.  The return values are the same as Constant::getRelocationInfo().
   virtual unsigned getRelocationInfo() const = 0;
   
   virtual int getExistingMachineCPValue(MachineConstantPool *CP,

diff --git a/include/llvm/Constant.h b/include/llvm/Constant.h
index 4314b2c..80c88b6 100644 (file)
--- a/include/llvm/Constant.h
+++ b/include/llvm/Constant.h
@@ -59,20 +59,27 @@ public:
   /// true for things like constant expressions that could divide by zero.
   bool canTrap() const;
 
+  enum PossibleRelocationsTy {
+    NoRelocation = 0,
+    LocalRelocation = 1,
+    GlobalRelocations = 2
+  };
+  
   /// getRelocationInfo - This method classifies the entry according to
   /// whether or not it may generate a relocation entry.  This must be
   /// conservative, so if it might codegen to a relocatable entry, it should say
   /// so.  The return values are:
   /// 
-  ///  0: This constant pool entry is guaranteed to never have a relocation
-  ///     applied to it (because it holds a simple constant like '4').
-  ///  1: This entry has relocations, but the entries are guaranteed to be
-  ///     resolvable by the static linker, so the dynamic linker will never see
-  ///     them.
-  ///  2: This entry may have arbitrary relocations.
+  ///  NoRelocation: This constant pool entry is guaranteed to never have a
+  ///     relocation applied to it (because it holds a simple constant like
+  ///     '4').
+  ///  LocalRelocation: This entry has relocations, but the entries are
+  ///     guaranteed to be resolvable by the static linker, so the dynamic
+  ///     linker will never see them.
+  ///  GlobalRelocations: This entry may have arbitrary relocations.
   ///
   /// FIXME: This really should not be in VMCore.
-  unsigned getRelocationInfo() const;
+  PossibleRelocationsTy getRelocationInfo() const;
   
   // Specialize get/setOperand for Constants as their operands are always
   // constants as well.

diff --git a/lib/Target/ELFTargetAsmInfo.cpp b/lib/Target/ELFTargetAsmInfo.cpp
index 9e7bb4a..284f4cb 100644 (file)
--- a/lib/Target/ELFTargetAsmInfo.cpp
+++ b/lib/Target/ELFTargetAsmInfo.cpp
@@ -62,10 +62,10 @@ ELFTargetAsmInfo::SectionKindForGlobal(const GlobalValue *GV) const {
     // placed in r/w section.
     switch (C->getRelocationInfo()) {
     default: break;
-    case 1:
+    case Constant::LocalRelocation:
       return isConstant ? SectionKind::DataRelROLocal :
                           SectionKind::DataRelLocal;
-    case 2:
+    case Constant::GlobalRelocations:
       return isConstant ? SectionKind::DataRelRO : SectionKind::DataRel;
     }
   }

diff --git a/lib/VMCore/Constants.cpp b/lib/VMCore/Constants.cpp
index 74c3115..f94cd9e 100644 (file)
--- a/lib/VMCore/Constants.cpp
+++ b/lib/VMCore/Constants.cpp
@@ -107,22 +107,23 @@ bool Constant::canTrap() const {
 /// conservative, so if it might codegen to a relocatable entry, it should say
 /// so.  The return values are:
 /// 
-///  0: This constant pool entry is guaranteed to never have a relocation
-///     applied to it (because it holds a simple constant like '4').
-///  1: This entry has relocations, but the entries are guaranteed to be
-///     resolvable by the static linker, so the dynamic linker will never see
-///     them.
-///  2: This entry may have arbitrary relocations.
+///  NoRelocation: This constant pool entry is guaranteed to never have a
+///     relocation applied to it (because it holds a simple constant like
+///     '4').
+///  LocalRelocation: This entry has relocations, but the entries are
+///     guaranteed to be resolvable by the static linker, so the dynamic
+///     linker will never see them.
+///  GlobalRelocations: This entry may have arbitrary relocations.
 ///
 /// FIXME: This really should not be in VMCore.
-unsigned Constant::getRelocationInfo() const {
-  if (const GlobalValue* GV = dyn_cast<GlobalValue>(this)) {
+Constant::PossibleRelocationsTy Constant::getRelocationInfo() const {
+  if (const GlobalValue *GV = dyn_cast<GlobalValue>(this)) {
     if (GV->hasLocalLinkage() || GV->hasHiddenVisibility())
-      return 1;  // Local to this file/library.
-    return 2;    // Global reference.
+      return LocalRelocation;  // Local to this file/library.
+    return GlobalRelocations;    // Global reference.
   }
   
-  unsigned Result = 0;
+  PossibleRelocationsTy Result = NoRelocation;
   for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
     Result = std::max(Result, getOperand(i)->getRelocationInfo());