From 7cf12c7efd37dc12c3ed536a3f4c373dddac2b85 Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Wed, 22 Jul 2009 00:05:44 +0000 Subject: [PATCH] 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 --- include/llvm/Constant.h | 35 +++++++++++------------- lib/CodeGen/MachineFunction.cpp | 14 +--------- lib/Target/ELFTargetAsmInfo.cpp | 18 ++++++------- lib/Target/TargetAsmInfo.cpp | 4 +-- 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 62b75a77fb3..4314b2c026f 100644 --- a/include/llvm/Constant.h +++ b/include/llvm/Constant.h @@ -20,20 +20,6 @@ namespace llvm { template 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 682b8a7388a..9d6669b0852 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 5deabee0ba2..1bcfaf91ad0 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(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 580c3fe4db0..96814fee4c9 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 e64b0c4ff50..2eb73398c5b 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(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(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 -- 2.34.1