RPCSX/llvm
1
0
Fork 0
mirror of https://github.com/RPCSX/llvm.git synced 2024-11-25 12:50:00 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

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

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@76938 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2009-07-24 03:27:21 +00:00
parent ad733cd851
commit 083a1e0597
4 changed files with 29 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
include/llvm/CodeGen/MachineConstantPool.h
View File

@ -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,

21
include/llvm/Constant.h
View File

@ -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.

4
lib/Target/ELFTargetAsmInfo.cpp
View File

@ -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;
}
}

23
lib/VMCore/Constants.cpp
View File

@ -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());