diff options
author | Chris Lattner <sabre@nondot.org> | 2009-07-22 00:05:44 +0000 |
---|---|---|
committer | Chris Lattner <sabre@nondot.org> | 2009-07-22 00:05:44 +0000 |
commit | 7cf12c7efd37dc12c3ed536a3f4c373dddac2b85 (patch) | |
tree | 9eaf5648fd1b7eb369792e52af192cbf59dbdb0e | |
parent | 9c5beed5f5a6da5bd86c7dee6f8f803e8960e6a6 (diff) | |
download | llvm-7cf12c7efd37dc12c3ed536a3f4c373dddac2b85.tar.gz llvm-7cf12c7efd37dc12c3ed536a3f4c373dddac2b85.tar.bz2 llvm-7cf12c7efd37dc12c3ed536a3f4c373dddac2b85.tar.xz |
reimplement Constant::ContainsRelocations as
Constant::getRelocationInfo(), which has a much simpler
to use API. It still should not be part of libvmcore, but
is better than it was. Also teach it to be smart about
hidden visibility.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@76700 91177308-0d34-0410-b5e6-96231b3b80d8
-rw-r--r-- | include/llvm/Constant.h | 35 | ||||
-rw-r--r-- | lib/CodeGen/MachineFunction.cpp | 14 | ||||
-rw-r--r-- | lib/Target/ELFTargetAsmInfo.cpp | 18 | ||||
-rw-r--r-- | lib/Target/TargetAsmInfo.cpp | 4 | ||||
-rw-r--r-- | lib/VMCore/Constants.cpp | 47 |
5 files changed, 51 insertions, 67 deletions
diff --git a/include/llvm/Constant.h b/include/llvm/Constant.h index 62b75a77fb..4314b2c026 100644 --- a/include/llvm/Constant.h +++ b/include/llvm/Constant.h @@ -20,20 +20,6 @@ namespace llvm { template<typename T> class SmallVectorImpl; class LLVMContext; - /// If object contains references to other objects, then relocations are - /// usually required for emission of such object (especially in PIC mode). One - /// usually distinguishes local and global relocations. Local relocations are - /// made wrt objects in the same module and these objects have local (internal - /// or private) linkage. Global relocations are made wrt externally visible - /// objects. In most cases local relocations can be resolved via so-called - /// 'pre-link' technique. - namespace Reloc { - const unsigned None = 0; - const unsigned Local = 1 << 0; ///< Local relocations are required - const unsigned Global = 1 << 1; ///< Global relocations are required - const unsigned LocalOrGlobal = Local | Global; - } - /// This is an important base class in LLVM. It provides the common facilities /// of all constant values in an LLVM program. A constant is a value that is /// immutable at runtime. Functions are constants because their address is @@ -73,12 +59,21 @@ public: /// true for things like constant expressions that could divide by zero. bool canTrap() const; - /// ContainsRelocations - Return true if the constant value contains - /// relocations which cannot be resolved at compile time. Note that answer is - /// not exclusive: there can be possibility that relocations of other kind are - /// required as well. - bool ContainsRelocations(unsigned Kind = Reloc::LocalOrGlobal) const; - + /// 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. + /// + /// FIXME: This really should not be in VMCore. + unsigned getRelocationInfo() const; + // Specialize get/setOperand for Constants as their operands are always // constants as well. Constant *getOperand(unsigned i) { diff --git a/lib/CodeGen/MachineFunction.cpp b/lib/CodeGen/MachineFunction.cpp index 682b8a7388..9d6669b085 100644 --- a/lib/CodeGen/MachineFunction.cpp +++ b/lib/CodeGen/MachineFunction.cpp @@ -547,19 +547,7 @@ const Type *MachineConstantPoolEntry::getType() const { unsigned MachineConstantPoolEntry::getRelocationInfo() const { if (isMachineConstantPoolEntry()) return Val.MachineCPVal->getRelocationInfo(); - - // 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; + return Val.ConstVal->getRelocationInfo(); } MachineConstantPool::~MachineConstantPool() { diff --git a/lib/Target/ELFTargetAsmInfo.cpp b/lib/Target/ELFTargetAsmInfo.cpp index 5deabee0ba..1bcfaf91ad 100644 --- a/lib/Target/ELFTargetAsmInfo.cpp +++ b/lib/Target/ELFTargetAsmInfo.cpp @@ -54,20 +54,20 @@ ELFTargetAsmInfo::SectionKindForGlobal(const GlobalValue *GV) const { // Decide, whether we need data.rel stuff const GlobalVariable* GVar = dyn_cast<GlobalVariable>(GV); - if (GVar->hasInitializer()) { + if (GVar->hasInitializer() && TM.getRelocationModel() != Reloc::Static) { Constant *C = GVar->getInitializer(); bool isConstant = GVar->isConstant(); - // By default - all relocations in PIC mode would force symbol to be // placed in r/w section. - if (TM.getRelocationModel() != Reloc::Static && - C->ContainsRelocations(Reloc::LocalOrGlobal)) - return (C->ContainsRelocations(Reloc::Global) ? - (isConstant ? - SectionKind::DataRelRO : SectionKind::DataRel) : - (isConstant ? - SectionKind::DataRelROLocal : SectionKind::DataRelLocal)); + switch (C->getRelocationInfo()) { + default: break; + case 1: + return isConstant ? SectionKind::DataRelROLocal : + SectionKind::DataRelLocal; + case 2: + return isConstant ? SectionKind::DataRelRO : SectionKind::DataRel; + } } return Kind; diff --git a/lib/Target/TargetAsmInfo.cpp b/lib/Target/TargetAsmInfo.cpp index 580c3fe4db..96814fee4c 100644 --- a/lib/Target/TargetAsmInfo.cpp +++ b/lib/Target/TargetAsmInfo.cpp @@ -202,13 +202,13 @@ TargetAsmInfo::SectionKindForGlobal(const GlobalValue *GV) const { if (isSuitableForBSS(GVar)) { // Variable can be easily put to BSS section. - return (isThreadLocal ? SectionKind::ThreadBSS : SectionKind::BSS); + return isThreadLocal ? SectionKind::ThreadBSS : SectionKind::BSS; } else if (GVar->isConstant() && !isThreadLocal) { // Now we know, that variable has initializer and it is constant. We need to // check its initializer to decide, which section to output it into. Also // note, there is no thread-local r/o section. Constant *C = GVar->getInitializer(); - if (C->ContainsRelocations(Reloc::LocalOrGlobal)) { + if (C->getRelocationInfo() != 0) { // Decide whether it is still possible to put symbol into r/o section. if (TM.getRelocationModel() != Reloc::Static) return SectionKind::Data; diff --git a/lib/VMCore/Constants.cpp b/lib/VMCore/Constants.cpp index e64b0c4ff5..2eb73398c5 100644 --- a/lib/VMCore/Constants.cpp +++ b/lib/VMCore/Constants.cpp @@ -101,34 +101,35 @@ bool Constant::canTrap() const { } } -/// ContainsRelocations - Return true if the constant value contains relocations -/// which cannot be resolved at compile time. Kind argument is used to filter -/// only 'interesting' sorts of relocations. -bool Constant::ContainsRelocations(unsigned Kind) const { - if (const GlobalValue* GV = dyn_cast<GlobalValue>(this)) { - bool isLocal = GV->hasLocalLinkage(); - if ((Kind & Reloc::Local) && isLocal) { - // Global has local linkage and 'local' kind of relocations are - // requested - return true; - } - - if ((Kind & Reloc::Global) && !isLocal) { - // Global has non-local linkage and 'global' kind of relocations are - // requested - return true; - } - return false; +/// 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. +/// +/// FIXME: This really should not be in VMCore. +unsigned 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. } - + + unsigned Result = 0; for (unsigned i = 0, e = getNumOperands(); i != e; ++i) - if (getOperand(i)->ContainsRelocations(Kind)) - return true; - - return false; + Result = std::max(Result, getOperand(i)->getRelocationInfo()); + + return Result; } + /// getVectorElements - This method, which is only valid on constant of vector /// type, returns the elements of the vector in the specified smallvector. /// This handles breaking down a vector undef into undef elements, etc. For |