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
/// 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) {
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() {
// 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;
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;
}
}
-/// 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
projects / oota-llvm.git / commitdiff