diff options
author | Daniel Dunbar <daniel@zuster.org> | 2010-03-19 03:18:12 +0000 |
---|---|---|
committer | Daniel Dunbar <daniel@zuster.org> | 2010-03-19 03:18:12 +0000 |
commit | 939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6 (patch) | |
tree | 9d3a5cc46fc2f6a477f350eb62429831ffe37ead /lib | |
parent | 238698566311e9dba4092dfa6c0bfe253279702e (diff) | |
download | external_llvm-939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6.zip external_llvm-939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6.tar.gz external_llvm-939f8d7ca23b95acdd5d1e71a7579ee8d33e7fd6.tar.bz2 |
MC/Mach-O: Factor out isScatteredFixupFullyResolvedSimple predicate, and fix some corner cases.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@98924 91177308-0d34-0410-b5e6-96231b3b80d8
Diffstat (limited to 'lib')
-rw-r--r-- | lib/MC/MCAssembler.cpp | 67 |
1 files changed, 52 insertions, 15 deletions
diff --git a/lib/MC/MCAssembler.cpp b/lib/MC/MCAssembler.cpp index 065c49e..003f032 100644 --- a/lib/MC/MCAssembler.cpp +++ b/lib/MC/MCAssembler.cpp @@ -1010,6 +1010,44 @@ MCAssembler::MCAssembler(MCContext &_Context, TargetAsmBackend &_Backend, MCAssembler::~MCAssembler() { } +static bool isScatteredFixupFullyResolvedSimple(const MCAssembler &Asm, + const MCAsmFixup &Fixup, + const MCDataFragment *DF, + const MCValue Target, + const MCSection *BaseSection) { + // The effective fixup address is + // addr(atom(A)) + offset(A) + // - addr(atom(B)) - offset(B) + // - addr(<base symbol>) + <fixup offset from base symbol> + // and the offsets are not relocatable, so the fixup is fully resolved when + // addr(atom(A)) - addr(atom(B)) - addr(<base symbol>)) == 0. + // + // The simple (Darwin, except on x86_64) way of dealing with this was to + // assume that any reference to a temporary symbol *must* be a temporary + // symbol in the same atom, unless the sections differ. Therefore, any PCrel + // relocation to a temporary symbol (in the same section) is fully + // resolved. This also works in conjunction with absolutized .set, which + // requires the compiler to use .set to absolutize the differences between + // symbols which the compiler knows to be assembly time constants, so we don't + // need to worry about consider symbol differences fully resolved. + + // Non-relative fixups are only resolved if constant. + if (!BaseSection) + return Target.isAbsolute(); + + // Otherwise, relative fixups are only resolved if not a difference and the + // target is a temporary in the same section. + if (Target.isAbsolute() || Target.getSymB()) + return false; + + const MCSymbol *A = &Target.getSymA()->getSymbol(); + if (!A->isTemporary() || !A->isInSection() || + &A->getSection() != BaseSection) + return false; + + return true; +} + bool MCAssembler::isSymbolLinkerVisible(const MCSymbolData *SD) const { // Non-temporary labels should always be visible to the linker. if (!SD->getSymbol().isTemporary()) @@ -1036,34 +1074,33 @@ bool MCAssembler::EvaluateFixup(const MCAsmLayout &Layout, MCAsmFixup &Fixup, Value = Target.getConstant(); - // FIXME: This "resolved" check isn't quite right. The assumption is that if - // we have a PCrel access to a temporary, then that temporary is in the same - // atom, and so the value is resolved. We need explicit atom's to implement - // this more precisely. bool IsResolved = true, IsPCRel = isFixupKindPCRel(Fixup.Kind); if (const MCSymbolRefExpr *A = Target.getSymA()) { if (A->getSymbol().isDefined()) Value += getSymbolData(A->getSymbol()).getAddress(); else IsResolved = false; - - // With scattered symbols, we assume anything that isn't a PCrel temporary - // access can have an arbitrary value. - if (getBackend().hasScatteredSymbols() && - (!IsPCRel || !A->getSymbol().isTemporary())) - IsResolved = false; } if (const MCSymbolRefExpr *B = Target.getSymB()) { if (B->getSymbol().isDefined()) Value -= getSymbolData(B->getSymbol()).getAddress(); else IsResolved = false; + } - // With scattered symbols, we assume anything that isn't a PCrel temporary - // access can have an arbitrary value. - if (getBackend().hasScatteredSymbols() && - (!IsPCRel || !B->getSymbol().isTemporary())) - IsResolved = false; + // If we are using scattered symbols, determine whether this value is actually + // resolved; scattering may cause atoms to move. + if (IsResolved && getBackend().hasScatteredSymbols()) { + if (getBackend().hasReliableSymbolDifference()) { + llvm_report_error("FIXME: Not yet implemented"); + } else { + const MCSection *BaseSection = 0; + if (IsPCRel) + BaseSection = &DF->getParent()->getSection(); + + IsResolved = isScatteredFixupFullyResolvedSimple(*this, Fixup, DF, Target, + BaseSection); + } } if (IsPCRel) |