add an API so target-independent codegen can determine if a constant
pool entry will require relocations against it. I implemented this
conservatively for ARM, someone who is knowledgable about it should
see if this can be improved.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@76678 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/include/llvm/CodeGen/MachineConstantPool.h b/include/llvm/CodeGen/MachineConstantPool.h
index 99996cf..acbbc66 100644
--- a/include/llvm/CodeGen/MachineConstantPool.h
+++ b/include/llvm/CodeGen/MachineConstantPool.h
@@ -41,8 +41,22 @@
/// getType - get type of this MachineConstantPoolValue.
///
- inline const Type *getType() const { return Ty; }
+ const Type *getType() const { return Ty; }
+
+ /// getRelocatationInfo - 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.
+ virtual unsigned getRelocatationInfo() const = 0;
+
virtual int getExistingMachineCPValue(MachineConstantPool *CP,
unsigned Alignment) = 0;
@@ -94,6 +108,19 @@
}
const Type *getType() const;
+
+ /// getRelocatationInfo - 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.
+ unsigned getRelocatationInfo() const;
};
/// The MachineConstantPool class keeps track of constants referenced by a
diff --git a/lib/CodeGen/MachineFunction.cpp b/lib/CodeGen/MachineFunction.cpp
index 599efb8..e6ae7dc 100644
--- a/lib/CodeGen/MachineFunction.cpp
+++ b/lib/CodeGen/MachineFunction.cpp
@@ -539,10 +539,29 @@
const Type *MachineConstantPoolEntry::getType() const {
if (isMachineConstantPoolEntry())
- return Val.MachineCPVal->getType();
+ return Val.MachineCPVal->getType();
return Val.ConstVal->getType();
}
+
+unsigned MachineConstantPoolEntry::getRelocatationInfo() const {
+ if (isMachineConstantPoolEntry())
+ return Val.MachineCPVal->getRelocatationInfo();
+
+ // FIXME: This API sucks.
+
+ // If no relocations, return 0.
+ if (!Val.ConstVal->ContainsRelocations())
+ return 0;
+
+ // If it contains no global relocations, return 1.
+ if (!Val.ConstVal->ContainsRelocations(Reloc::Global))
+ return 1;
+
+ // Otherwise, it has general relocations.
+ return 2;
+}
+
MachineConstantPool::~MachineConstantPool() {
for (unsigned i = 0, e = Constants.size(); i != e; ++i)
if (Constants[i].isMachineConstantPoolEntry())
diff --git a/lib/Target/ARM/ARMConstantPoolValue.h b/lib/Target/ARM/ARMConstantPoolValue.h
index abf7339..a930889 100644
--- a/lib/Target/ARM/ARMConstantPoolValue.h
+++ b/lib/Target/ARM/ARMConstantPoolValue.h
@@ -65,6 +65,13 @@
bool isStub() const { return Kind == ARMCP::CPStub; }
unsigned char getPCAdjustment() const { return PCAdjust; }
+ virtual unsigned getRelocatationInfo() const {
+ // FIXME: This is conservatively claiming that these entries require a
+ // relocation, we may be able to do better than this.
+ return 2;
+ }
+
+
virtual int getExistingMachineCPValue(MachineConstantPool *CP,
unsigned Alignment);