6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-06-17 04:24:00 +00:00
Code Issues Projects Releases Wiki Activity

Change MCExpr::EvaluateAsRelocatableImpl of variables to return the original

Browse Source 
variable if recursing fails to simplify it.

Factor AliasedSymbol to be a method of MCSymbol.

Update MCAssembler::EvaluateFixup to match the change in
EvaluateAsRelocatableImpl.

Remove the WeakRefExpr hack, as the object writer now sees the weakref with
no extra effort needed.

Nothing else is using MCTargetExpr, but keep it for now.

Now that the ELF writer sees relocations with aliases, handle

    .weak    foo2
foo2:
    .weak    bar2
    .set    bar2,foo2
    .quad    bar2

the same way gas does and produce a relocation with bar2.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@119152 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Rafael Espindola
2010-11-15 16:33:49 +00:00
parent d3443e99e4
commit 94ed5fca3f
7 changed files with 90 additions and 115 deletions
Download Patch File Download Diff File Expand all files Collapse all files

54
lib/MC/MCELFStreamer.cpp
View File

@ -240,49 +240,6 @@ void MCELFStreamer::EmitAssignment(MCSymbol *Symbol, const MCExpr *Value) {
Symbol->setVariableValue(AddValueSymbols(Value));
}
// This is a hack. To be able to implement weakrefs the writer has to be able
// to distinguish
// .weakref foo, bar
// .long foo
// from
// .weakref foo, bar
// .long bar
// since the first case should produce a weak undefined reference and the second
// one a strong one.
// If we created foo as a regular alias pointing to bar (foo = bar), then
// MCExpr::EvaluateAsRelocatable would recurse on foo and the writer would
// never see it used in a relocation.
// What we do is create a MCTargetExpr that when evaluated produces a symbol
// ref to a temporary symbol. This temporary symbol in turn is a variable
// that equals the original symbol (tmp = bar). With this hack the writer
// gets a relocation with tmp and can correctly implement weak references.
namespace {
class WeakRefExpr : public MCTargetExpr {
private:
const MCSymbolRefExpr *Alias;
explicit WeakRefExpr(const MCSymbolRefExpr *Alias_)
: MCTargetExpr(), Alias(Alias_) {}
public:
virtual void PrintImpl(raw_ostream &OS) const {
llvm_unreachable("Unimplemented");
}
virtual bool EvaluateAsRelocatableImpl(MCValue &Res,
const MCAsmLayout *Layout) const {
Res = MCValue::get(Alias, 0, 0);
return true;
}
static const WeakRefExpr *Create(const MCSymbol *Alias, MCContext &Ctx) {
const MCSymbolRefExpr *A = MCSymbolRefExpr::Create(Alias, Ctx);
return new (Ctx) WeakRefExpr(A);
}
};
} // end anonymous namespace
void MCELFStreamer::SwitchSection(const MCSection *Section) {
const MCSymbol *Grp = static_cast<const MCSectionELF *>(Section)->getGroup();
if (Grp)
@ -294,16 +251,7 @@ void MCELFStreamer::EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) {
getAssembler().getOrCreateSymbolData(*Symbol);
MCSymbolData &AliasSD = getAssembler().getOrCreateSymbolData(*Alias);
AliasSD.setFlags(AliasSD.getFlags() | ELF_Other_Weakref);
// Create the alias that actually points to Symbol
const MCSymbolRefExpr *SymRef = MCSymbolRefExpr::Create(Symbol, getContext());
MCSymbol *RealAlias = getContext().CreateTempSymbol();
RealAlias->setVariableValue(SymRef);
MCSymbolData &RealAliasSD = getAssembler().getOrCreateSymbolData(*RealAlias);
RealAliasSD.setFlags(RealAliasSD.getFlags() | ELF_Other_Weakref);
const MCExpr *Value = WeakRefExpr::Create(RealAlias, getContext());
const MCExpr *Value = MCSymbolRefExpr::Create(Symbol, getContext());
Alias->setVariableValue(Value);
}