6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-12-14 11:32:34 +00:00
Code Issues Projects Releases Wiki Activity

Revert "Remove doesSectionRequireSymbols."

Browse Source 
This reverts commit r224985.

I am investigating why it made an Apple bot unhappy.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@225044 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Rafael Espindola 2014-12-31 16:06:48 +00:00
parent e883ee78f2
commit 937e781f49
19 changed files with 241 additions and 293 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
include/llvm/MC/MCAsmBackend.h
View File

@ -61,6 +61,12 @@ public:
/// markers. If not, data region directives will be ignored. /// markers. If not, data region directives will be ignored.
bool hasDataInCodeSupport() const { return HasDataInCodeSupport; } bool hasDataInCodeSupport() const { return HasDataInCodeSupport; }
/// doesSectionRequireSymbols - Check whether the given section requires that
/// all symbols (even temporaries) have symbol table entries.
virtual bool doesSectionRequireSymbols(const MCSection &Section) const {
return false;
}
/// @name Target Fixup Interfaces /// @name Target Fixup Interfaces
/// @{ /// @{

6
include/llvm/MC/MCAssembler.h
View File

@ -11,7 +11,6 @@
#define LLVM_MC_MCASSEMBLER_H #define LLVM_MC_MCASSEMBLER_H
#include "llvm/ADT/DenseMap.h" #include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/DenseSet.h"
#include "llvm/ADT/PointerIntPair.h" #include "llvm/ADT/PointerIntPair.h"
#include "llvm/ADT/SmallPtrSet.h" #include "llvm/ADT/SmallPtrSet.h"
#include "llvm/ADT/SmallString.h" #include "llvm/ADT/SmallString.h"
@ -882,8 +881,6 @@ private:
iplist<MCSymbolData> Symbols; iplist<MCSymbolData> Symbols;
DenseSet<const MCSymbol *> LocalsUsedInReloc;
/// The map of sections to their associated assembler backend data. /// The map of sections to their associated assembler backend data.
// //
// FIXME: Avoid this indirection? // FIXME: Avoid this indirection?
@ -983,9 +980,6 @@ private:
MCFragment &F, const MCFixup &Fixup); MCFragment &F, const MCFixup &Fixup);
public: public:
void addLocalUsedInReloc(const MCSymbol &Sym);
bool isLocalUsedInReloc(const MCSymbol &Sym) const;
/// Compute the effective fragment size assuming it is laid out at the given /// Compute the effective fragment size assuming it is laid out at the given
/// \p SectionAddress and \p FragmentOffset. /// \p SectionAddress and \p FragmentOffset.
uint64_t computeFragmentSize(const MCAsmLayout &Layout, uint64_t computeFragmentSize(const MCAsmLayout &Layout,

28
include/llvm/MC/MCMachObjectWriter.h
View File

@ -68,10 +68,12 @@ public:
/// @name API /// @name API
/// @{ /// @{
virtual void RecordRelocation(MachObjectWriter *Writer, MCAssembler &Asm, virtual void RecordRelocation(MachObjectWriter *Writer,
const MCAssembler &Asm,
const MCAsmLayout &Layout, const MCAsmLayout &Layout,
const MCFragment *Fragment, const MCFragment *Fragment,
const MCFixup &Fixup, MCValue Target, const MCFixup &Fixup,
MCValue Target,
uint64_t &FixedValue) = 0; uint64_t &FixedValue) = 0;
/// @} /// @}
@ -95,14 +97,8 @@ class MachObjectWriter : public MCObjectWriter {
/// @name Relocation Data /// @name Relocation Data
/// @{ /// @{
struct RelAndSymbol { llvm::DenseMap<const MCSectionData*,
const MCSymbolData *Sym; std::vector<MachO::any_relocation_info> > Relocations;
MachO::any_relocation_info MRE;
RelAndSymbol(const MCSymbolData *Sym, const MachO::any_relocation_info &MRE)
: Sym(Sym), MRE(MRE) {}
};
llvm::DenseMap<const MCSectionData *, std::vector<RelAndSymbol>> Relocations;
llvm::DenseMap<const MCSectionData*, unsigned> IndirectSymBase; llvm::DenseMap<const MCSectionData*, unsigned> IndirectSymBase;
/// @} /// @}
@ -217,15 +213,9 @@ public:
// - Input errors, where something cannot be correctly encoded. 'as' allows // - Input errors, where something cannot be correctly encoded. 'as' allows
// these through in many cases. // these through in many cases.
// Add a relocation to be output in the object file. At the time this is void addRelocation(const MCSectionData *SD,
// called, the symbol indexes are not know, so if the relocation refers
// to a symbol it should be passed as \p RelSymbol so that it can be updated
// afterwards. If the relocation doesn't refer to a symbol, nullptr should be
// used.
void addRelocation(const MCSymbolData *RelSymbol, const MCSectionData *SD,
MachO::any_relocation_info &MRE) { MachO::any_relocation_info &MRE) {
RelAndSymbol P(RelSymbol, MRE); Relocations[SD].push_back(MRE);
Relocations[SD].push_back(P);
} }
void RecordScatteredRelocation(const MCAssembler &Asm, void RecordScatteredRelocation(const MCAssembler &Asm,
@ -241,7 +231,7 @@ public:
const MCFixup &Fixup, MCValue Target, const MCFixup &Fixup, MCValue Target,
uint64_t &FixedValue); uint64_t &FixedValue);
void RecordRelocation(MCAssembler &Asm, const MCAsmLayout &Layout, void RecordRelocation(const MCAssembler &Asm, const MCAsmLayout &Layout,
const MCFragment *Fragment, const MCFixup &Fixup, const MCFragment *Fragment, const MCFixup &Fixup,
MCValue Target, bool &IsPCRel, MCValue Target, bool &IsPCRel,
uint64_t &FixedValue) override; uint64_t &FixedValue) override;

6
include/llvm/MC/MCObjectWriter.h
View File

@ -76,10 +76,12 @@ public:
/// post layout binding. The implementation is responsible for storing /// post layout binding. The implementation is responsible for storing
/// information about the relocation so that it can be emitted during /// information about the relocation so that it can be emitted during
/// WriteObject(). /// WriteObject().
virtual void RecordRelocation(MCAssembler &Asm, const MCAsmLayout &Layout, virtual void RecordRelocation(const MCAssembler &Asm,
const MCAsmLayout &Layout,
const MCFragment *Fragment, const MCFragment *Fragment,
const MCFixup &Fixup, MCValue Target, const MCFixup &Fixup, MCValue Target,
bool &IsPCRel, uint64_t &FixedValue) = 0; bool &IsPCRel,
uint64_t &FixedValue) = 0;
/// \brief Check whether the difference (A - B) between two symbol /// \brief Check whether the difference (A - B) between two symbol
/// references is fully resolved. /// references is fully resolved.

10
lib/MC/ELFObjectWriter.cpp
View File

@ -219,7 +219,7 @@ class ELFObjectWriter : public MCObjectWriter {
const MCSymbolData *SD, uint64_t C, const MCSymbolData *SD, uint64_t C,
unsigned Type) const; unsigned Type) const;
void RecordRelocation(MCAssembler &Asm, const MCAsmLayout &Layout, void RecordRelocation(const MCAssembler &Asm, const MCAsmLayout &Layout,
const MCFragment *Fragment, const MCFixup &Fixup, const MCFragment *Fragment, const MCFixup &Fixup,
MCValue Target, bool &IsPCRel, MCValue Target, bool &IsPCRel,
uint64_t &FixedValue) override; uint64_t &FixedValue) override;
@ -789,11 +789,13 @@ static const MCSymbol *getWeakRef(const MCSymbolRefExpr &Ref) {
return nullptr; return nullptr;
} }
void ELFObjectWriter::RecordRelocation(MCAssembler &Asm, void ELFObjectWriter::RecordRelocation(const MCAssembler &Asm,
const MCAsmLayout &Layout, const MCAsmLayout &Layout,
const MCFragment *Fragment, const MCFragment *Fragment,
const MCFixup &Fixup, MCValue Target, const MCFixup &Fixup,
bool &IsPCRel, uint64_t &FixedValue) { MCValue Target,
bool &IsPCRel,
uint64_t &FixedValue) {
const MCSectionData *FixupSection = Fragment->getParent(); const MCSectionData *FixupSection = Fragment->getParent();
uint64_t C = Target.getConstant(); uint64_t C = Target.getConstant();
uint64_t FixupOffset = Layout.getFragmentOffset(Fragment) + Fixup.getOffset(); uint64_t FixupOffset = Layout.getFragmentOffset(Fragment) + Fixup.getOffset();

17
lib/MC/MCAsmInfoDarwin.cpp
View File

@ -27,7 +27,22 @@ bool MCAsmInfoDarwin::isSectionAtomizableBySymbols(
// contain. // contain.
// Sections holding 2 byte strings require symbols in order to be atomized. // Sections holding 2 byte strings require symbols in order to be atomized.
// There is no dedicated section for 4 byte strings. // There is no dedicated section for 4 byte strings.
if (SMO.getType() == MachO::S_CSTRING_LITERALS) if (SMO.getKind().isMergeable1ByteCString())
return false;
if (SMO.getSegmentName() == "__TEXT" &&
SMO.getSectionName() == "__objc_classname" &&
SMO.getType() == MachO::S_CSTRING_LITERALS)
return false;
if (SMO.getSegmentName() == "__TEXT" &&
SMO.getSectionName() == "__objc_methname" &&
SMO.getType() == MachO::S_CSTRING_LITERALS)
return false;
if (SMO.getSegmentName() == "__TEXT" &&
SMO.getSectionName() == "__objc_methtype" &&
SMO.getType() == MachO::S_CSTRING_LITERALS)
return false; return false;
if (SMO.getSegmentName() == "__DATA" && SMO.getSectionName() == "__cfstring") if (SMO.getSegmentName() == "__DATA" && SMO.getSectionName() == "__cfstring")

16
lib/MC/MCAssembler.cpp
View File

@ -425,16 +425,6 @@ bool MCAssembler::isThumbFunc(const MCSymbol *Symbol) const {
return true; return true;
} }
void MCAssembler::addLocalUsedInReloc(const MCSymbol &Sym) {
assert(Sym.isTemporary());
LocalsUsedInReloc.insert(&Sym);
}
bool MCAssembler::isLocalUsedInReloc(const MCSymbol &Sym) const {
assert(Sym.isTemporary());
return LocalsUsedInReloc.count(&Sym);
}
bool MCAssembler::isSymbolLinkerVisible(const MCSymbol &Symbol) const { bool MCAssembler::isSymbolLinkerVisible(const MCSymbol &Symbol) const {
// Non-temporary labels should always be visible to the linker. // Non-temporary labels should always be visible to the linker.
if (!Symbol.isTemporary()) if (!Symbol.isTemporary())
@ -444,10 +434,8 @@ bool MCAssembler::isSymbolLinkerVisible(const MCSymbol &Symbol) const {
if (!Symbol.isInSection()) if (!Symbol.isInSection())
return false; return false;
if (isLocalUsedInReloc(Symbol)) // Otherwise, check if the section requires symbols even for temporary labels.
return true; return getBackend().doesSectionRequireSymbols(Symbol.getSection());
return false;
} }
const MCSymbolData *MCAssembler::getAtom(const MCSymbolData *SD) const { const MCSymbolData *MCAssembler::getAtom(const MCSymbolData *SD) const {

41
lib/MC/MachObjectWriter.cpp
View File

@ -448,11 +448,14 @@ void MachObjectWriter::WriteLinkerOptionsLoadCommand(
assert(OS.tell() - Start == Size); assert(OS.tell() - Start == Size);
} }
void MachObjectWriter::RecordRelocation(MCAssembler &Asm,
void MachObjectWriter::RecordRelocation(const MCAssembler &Asm,
const MCAsmLayout &Layout, const MCAsmLayout &Layout,
const MCFragment *Fragment, const MCFragment *Fragment,
const MCFixup &Fixup, MCValue Target, const MCFixup &Fixup,
bool &IsPCRel, uint64_t &FixedValue) { MCValue Target,
bool &IsPCRel,
uint64_t &FixedValue) {
TargetObjectWriter->RecordRelocation(this, Asm, Layout, Fragment, Fixup, TargetObjectWriter->RecordRelocation(this, Asm, Layout, Fragment, Fixup,
Target, FixedValue); Target, FixedValue);
} }
@ -613,22 +616,6 @@ void MachObjectWriter::ComputeSymbolTable(
ExternalSymbolData[i].SymbolData->setIndex(Index++); ExternalSymbolData[i].SymbolData->setIndex(Index++);
for (unsigned i = 0, e = UndefinedSymbolData.size(); i != e; ++i) for (unsigned i = 0, e = UndefinedSymbolData.size(); i != e; ++i)
UndefinedSymbolData[i].SymbolData->setIndex(Index++); UndefinedSymbolData[i].SymbolData->setIndex(Index++);
for (const MCSectionData &SD : Asm) {
std::vector<RelAndSymbol> &Relocs = Relocations[&SD];
for (RelAndSymbol &Rel : Relocs) {
if (!Rel.Sym)
continue;
// Set the Index and the IsExtern bit.
unsigned Index = Rel.Sym->getIndex();
assert(isInt<24>(Index));
if (IsLittleEndian)
Rel.MRE.r_word1 = (Rel.MRE.r_word1 & (-1 << 24)) | Index | (1 << 27);
else
Rel.MRE.r_word1 = (Rel.MRE.r_word1 & 0xff) | Index << 8 | (1 << 4);
}
}
} }
void MachObjectWriter::computeSectionAddresses(const MCAssembler &Asm, void MachObjectWriter::computeSectionAddresses(const MCAssembler &Asm,
@ -675,6 +662,10 @@ void MachObjectWriter::ExecutePostLayoutBinding(MCAssembler &Asm,
// Mark symbol difference expressions in variables (from .set or = directives) // Mark symbol difference expressions in variables (from .set or = directives)
// as absolute. // as absolute.
markAbsoluteVariableSymbols(Asm, Layout); markAbsoluteVariableSymbols(Asm, Layout);
// Compute symbol table information and bind symbol indices.
ComputeSymbolTable(Asm, LocalSymbolData, ExternalSymbolData,
UndefinedSymbolData);
} }
bool MachObjectWriter:: bool MachObjectWriter::
@ -758,10 +749,6 @@ IsSymbolRefDifferenceFullyResolvedImpl(const MCAssembler &Asm,
void MachObjectWriter::WriteObject(MCAssembler &Asm, void MachObjectWriter::WriteObject(MCAssembler &Asm,
const MCAsmLayout &Layout) { const MCAsmLayout &Layout) {
// Compute symbol table information and bind symbol indices.
ComputeSymbolTable(Asm, LocalSymbolData, ExternalSymbolData,
UndefinedSymbolData);
unsigned NumSections = Asm.size(); unsigned NumSections = Asm.size();
const MCAssembler::VersionMinInfoType &VersionInfo = const MCAssembler::VersionMinInfoType &VersionInfo =
Layout.getAssembler().getVersionMinInfo(); Layout.getAssembler().getVersionMinInfo();
@ -852,7 +839,7 @@ void MachObjectWriter::WriteObject(MCAssembler &Asm,
uint64_t RelocTableEnd = SectionDataStart + SectionDataFileSize; uint64_t RelocTableEnd = SectionDataStart + SectionDataFileSize;
for (MCAssembler::const_iterator it = Asm.begin(), for (MCAssembler::const_iterator it = Asm.begin(),
ie = Asm.end(); it != ie; ++it) { ie = Asm.end(); it != ie; ++it) {
std::vector<RelAndSymbol> &Relocs = Relocations[it]; std::vector<MachO::any_relocation_info> &Relocs = Relocations[it];
unsigned NumRelocs = Relocs.size(); unsigned NumRelocs = Relocs.size();
uint64_t SectionStart = SectionDataStart + getSectionAddress(it); uint64_t SectionStart = SectionDataStart + getSectionAddress(it);
WriteSection(Asm, Layout, *it, SectionStart, RelocTableEnd, NumRelocs); WriteSection(Asm, Layout, *it, SectionStart, RelocTableEnd, NumRelocs);
@ -946,10 +933,10 @@ void MachObjectWriter::WriteObject(MCAssembler &Asm,
ie = Asm.end(); it != ie; ++it) { ie = Asm.end(); it != ie; ++it) {
// Write the section relocation entries, in reverse order to match 'as' // Write the section relocation entries, in reverse order to match 'as'
// (approximately, the exact algorithm is more complicated than this). // (approximately, the exact algorithm is more complicated than this).
std::vector<RelAndSymbol> &Relocs = Relocations[it]; std::vector<MachO::any_relocation_info> &Relocs = Relocations[it];
for (unsigned i = 0, e = Relocs.size(); i != e; ++i) { for (unsigned i = 0, e = Relocs.size(); i != e; ++i) {
Write32(Relocs[e - i - 1].MRE.r_word0); Write32(Relocs[e - i - 1].r_word0);
Write32(Relocs[e - i - 1].MRE.r_word1); Write32(Relocs[e - i - 1].r_word1);
} }
} }

12
lib/MC/WinCOFFObjectWriter.cpp
View File

@ -175,7 +175,7 @@ public:
const MCFragment &FB, bool InSet, const MCFragment &FB, bool InSet,
bool IsPCRel) const override; bool IsPCRel) const override;
void RecordRelocation(MCAssembler &Asm, const MCAsmLayout &Layout, void RecordRelocation(const MCAssembler &Asm, const MCAsmLayout &Layout,
const MCFragment *Fragment, const MCFixup &Fixup, const MCFragment *Fragment, const MCFixup &Fixup,
MCValue Target, bool &IsPCRel, MCValue Target, bool &IsPCRel,
uint64_t &FixedValue) override; uint64_t &FixedValue) override;
@ -661,9 +661,13 @@ bool WinCOFFObjectWriter::IsSymbolRefDifferenceFullyResolvedImpl(
InSet, IsPCRel); InSet, IsPCRel);
} }
void WinCOFFObjectWriter::RecordRelocation( void WinCOFFObjectWriter::RecordRelocation(const MCAssembler &Asm,
MCAssembler &Asm, const MCAsmLayout &Layout, const MCFragment *Fragment, const MCAsmLayout &Layout,
const MCFixup &Fixup, MCValue Target, bool &IsPCRel, uint64_t &FixedValue) { const MCFragment *Fragment,
const MCFixup &Fixup,
MCValue Target,
bool &IsPCRel,
uint64_t &FixedValue) {
assert(Target.getSymA() && "Relocation must reference a symbol!"); assert(Target.getSymA() && "Relocation must reference a symbol!");
const MCSymbol &Symbol = Target.getSymA()->getSymbol(); const MCSymbol &Symbol = Target.getSymA()->getSymbol();

36
lib/Target/AArch64/MCTargetDesc/AArch64AsmBackend.cpp
View File

@ -317,6 +317,42 @@ public:
MachO::CPU_SUBTYPE_ARM64_ALL); MachO::CPU_SUBTYPE_ARM64_ALL);
} }
bool doesSectionRequireSymbols(const MCSection &Section) const override {
// Any section for which the linker breaks things into atoms needs to
// preserve symbols, including assembler local symbols, to identify
// those atoms. These sections are:
// Sections of type:
//
// S_CSTRING_LITERALS (e.g. __cstring)
// S_LITERAL_POINTERS (e.g. objc selector pointers)
// S_16BYTE_LITERALS, S_8BYTE_LITERALS, S_4BYTE_LITERALS
//
// Sections named:
//
// __TEXT,__eh_frame
// __TEXT,__ustring
// __DATA,__cfstring
// __DATA,__objc_classrefs
// __DATA,__objc_catlist
//
// FIXME: It would be better if the compiler used actual linker local
// symbols for each of these sections rather than preserving what
// are ostensibly assembler local symbols.
const MCSectionMachO &SMO = static_cast<const MCSectionMachO &>(Section);
return (SMO.getType() == MachO::S_CSTRING_LITERALS ||
SMO.getType() == MachO::S_4BYTE_LITERALS ||
SMO.getType() == MachO::S_8BYTE_LITERALS ||
SMO.getType() == MachO::S_16BYTE_LITERALS ||
SMO.getType() == MachO::S_LITERAL_POINTERS ||
(SMO.getSegmentName() == "__TEXT" &&
(SMO.getSectionName() == "__eh_frame" ||
SMO.getSectionName() == "__ustring")) ||
(SMO.getSegmentName() == "__DATA" &&
(SMO.getSectionName() == "__cfstring" ||
SMO.getSectionName() == "__objc_classrefs" ||
SMO.getSectionName() == "__objc_catlist")));
}
/// \brief Generate the compact unwind encoding from the CFI directives. /// \brief Generate the compact unwind encoding from the CFI directives.
uint32_t generateCompactUnwindEncoding( uint32_t generateCompactUnwindEncoding(
ArrayRef<MCCFIInstruction> Instrs) const override { ArrayRef<MCCFIInstruction> Instrs) const override {

50
lib/Target/AArch64/MCTargetDesc/AArch64MachObjectWriter.cpp
View File

@ -10,7 +10,6 @@
#include "MCTargetDesc/AArch64FixupKinds.h" #include "MCTargetDesc/AArch64FixupKinds.h"
#include "MCTargetDesc/AArch64MCTargetDesc.h" #include "MCTargetDesc/AArch64MCTargetDesc.h"
#include "llvm/ADT/Twine.h" #include "llvm/ADT/Twine.h"
#include "llvm/MC/MCAsmInfo.h"
#include "llvm/MC/MCAsmLayout.h" #include "llvm/MC/MCAsmLayout.h"
#include "llvm/MC/MCAssembler.h" #include "llvm/MC/MCAssembler.h"
#include "llvm/MC/MCContext.h" #include "llvm/MC/MCContext.h"
@ -34,7 +33,7 @@ public:
: MCMachObjectTargetWriter(true /* is64Bit */, CPUType, CPUSubtype, : MCMachObjectTargetWriter(true /* is64Bit */, CPUType, CPUSubtype,
/*UseAggressiveSymbolFolding=*/true) {} /*UseAggressiveSymbolFolding=*/true) {}
void RecordRelocation(MachObjectWriter *Writer, MCAssembler &Asm, void RecordRelocation(MachObjectWriter *Writer, const MCAssembler &Asm,
const MCAsmLayout &Layout, const MCFragment *Fragment, const MCAsmLayout &Layout, const MCFragment *Fragment,
const MCFixup &Fixup, MCValue Target, const MCFixup &Fixup, MCValue Target,
uint64_t &FixedValue) override; uint64_t &FixedValue) override;
@ -114,7 +113,7 @@ bool AArch64MachObjectWriter::getAArch64FixupKindMachOInfo(
} }
void AArch64MachObjectWriter::RecordRelocation( void AArch64MachObjectWriter::RecordRelocation(
MachObjectWriter *Writer, MCAssembler &Asm, const MCAsmLayout &Layout, MachObjectWriter *Writer, const MCAssembler &Asm, const MCAsmLayout &Layout,
const MCFragment *Fragment, const MCFixup &Fixup, MCValue Target, const MCFragment *Fragment, const MCFixup &Fixup, MCValue Target,
uint64_t &FixedValue) { uint64_t &FixedValue) {
unsigned IsPCRel = Writer->isFixupKindPCRel(Asm, Fixup.getKind()); unsigned IsPCRel = Writer->isFixupKindPCRel(Asm, Fixup.getKind());
@ -124,9 +123,9 @@ void AArch64MachObjectWriter::RecordRelocation(
unsigned Log2Size = 0; unsigned Log2Size = 0;
int64_t Value = 0; int64_t Value = 0;
unsigned Index = 0; unsigned Index = 0;
unsigned IsExtern = 0;
unsigned Type = 0; unsigned Type = 0;
unsigned Kind = Fixup.getKind(); unsigned Kind = Fixup.getKind();
const MCSymbolData *RelSymbol = nullptr;
FixupOffset += Fixup.getOffset(); FixupOffset += Fixup.getOffset();
@ -172,8 +171,10 @@ void AArch64MachObjectWriter::RecordRelocation(
// FIXME: Should this always be extern? // FIXME: Should this always be extern?
// SymbolNum of 0 indicates the absolute section. // SymbolNum of 0 indicates the absolute section.
Type = MachO::ARM64_RELOC_UNSIGNED; Type = MachO::ARM64_RELOC_UNSIGNED;
Index = 0;
if (IsPCRel) { if (IsPCRel) {
IsExtern = 1;
Asm.getContext().FatalError(Fixup.getLoc(), Asm.getContext().FatalError(Fixup.getLoc(),
"PC relative absolute relocation!"); "PC relative absolute relocation!");
@ -197,12 +198,15 @@ void AArch64MachObjectWriter::RecordRelocation(
Layout.getSymbolOffset(&B_SD) == Layout.getSymbolOffset(&B_SD) ==
Layout.getFragmentOffset(Fragment) + Fixup.getOffset()) { Layout.getFragmentOffset(Fragment) + Fixup.getOffset()) {
// SymB is the PC, so use a PC-rel pointer-to-GOT relocation. // SymB is the PC, so use a PC-rel pointer-to-GOT relocation.
Index = A_Base->getIndex();
IsExtern = 1;
Type = MachO::ARM64_RELOC_POINTER_TO_GOT; Type = MachO::ARM64_RELOC_POINTER_TO_GOT;
IsPCRel = 1; IsPCRel = 1;
MachO::any_relocation_info MRE; MachO::any_relocation_info MRE;
MRE.r_word0 = FixupOffset; MRE.r_word0 = FixupOffset;
MRE.r_word1 = (IsPCRel << 24) | (Log2Size << 25) | (Type << 28); MRE.r_word1 = ((Index << 0) | (IsPCRel << 24) | (Log2Size << 25) |
Writer->addRelocation(A_Base, Fragment->getParent(), MRE); (IsExtern << 27) | (Type << 28));
Writer->addRelocation(Fragment->getParent(), MRE);
return; return;
} else if (Target.getSymA()->getKind() != MCSymbolRefExpr::VK_None || } else if (Target.getSymA()->getKind() != MCSymbolRefExpr::VK_None ||
Target.getSymB()->getKind() != MCSymbolRefExpr::VK_None) Target.getSymB()->getKind() != MCSymbolRefExpr::VK_None)
@ -248,23 +252,21 @@ void AArch64MachObjectWriter::RecordRelocation(
? 0 ? 0
: Writer->getSymbolAddress(B_Base, Layout)); : Writer->getSymbolAddress(B_Base, Layout));
Index = A_Base->getIndex();
IsExtern = 1;
Type = MachO::ARM64_RELOC_UNSIGNED; Type = MachO::ARM64_RELOC_UNSIGNED;
MachO::any_relocation_info MRE; MachO::any_relocation_info MRE;
MRE.r_word0 = FixupOffset; MRE.r_word0 = FixupOffset;
MRE.r_word1 = (IsPCRel << 24) | (Log2Size << 25) | (Type << 28); MRE.r_word1 = ((Index << 0) | (IsPCRel << 24) | (Log2Size << 25) |
Writer->addRelocation(A_Base, Fragment->getParent(), MRE); (IsExtern << 27) | (Type << 28));
Writer->addRelocation(Fragment->getParent(), MRE);
RelSymbol = B_Base; Index = B_Base->getIndex();
IsExtern = 1;
Type = MachO::ARM64_RELOC_SUBTRACTOR; Type = MachO::ARM64_RELOC_SUBTRACTOR;
} else { // A + constant } else { // A + constant
const MCSymbol *Symbol = &Target.getSymA()->getSymbol(); const MCSymbol *Symbol = &Target.getSymA()->getSymbol();
if (Symbol->isTemporary() && Value) {
const MCSection &Sec = Symbol->getSection();
if (!Asm.getContext().getAsmInfo()->isSectionAtomizableBySymbols(Sec))
Asm.addLocalUsedInReloc(*Symbol);
}
const MCSymbolData &SD = Asm.getSymbolData(*Symbol); const MCSymbolData &SD = Asm.getSymbolData(*Symbol);
const MCSymbolData *Base = Asm.getAtom(&SD); const MCSymbolData *Base = Asm.getAtom(&SD);
const MCSectionMachO &Section = static_cast<const MCSectionMachO &>( const MCSectionMachO &Section = static_cast<const MCSectionMachO &>(
@ -308,7 +310,8 @@ void AArch64MachObjectWriter::RecordRelocation(
// sections, and for pointer-sized relocations (.quad), we allow section // sections, and for pointer-sized relocations (.quad), we allow section
// relocations. It's code sections that run into trouble. // relocations. It's code sections that run into trouble.
if (Base) { if (Base) {
RelSymbol = Base; Index = Base->getIndex();
IsExtern = 1;
// Add the local offset, if needed. // Add the local offset, if needed.
if (Base != &SD) if (Base != &SD)
@ -326,6 +329,7 @@ void AArch64MachObjectWriter::RecordRelocation(
const MCSectionData &SymSD = const MCSectionData &SymSD =
Asm.getSectionData(SD.getSymbol().getSection()); Asm.getSectionData(SD.getSymbol().getSection());
Index = SymSD.getOrdinal() + 1; Index = SymSD.getOrdinal() + 1;
IsExtern = 0;
Value += Writer->getSymbolAddress(&SD, Layout); Value += Writer->getSymbolAddress(&SD, Layout);
if (IsPCRel) if (IsPCRel)
@ -358,16 +362,16 @@ void AArch64MachObjectWriter::RecordRelocation(
MachO::any_relocation_info MRE; MachO::any_relocation_info MRE;
MRE.r_word0 = FixupOffset; MRE.r_word0 = FixupOffset;
MRE.r_word1 = MRE.r_word1 = ((Index << 0) | (IsPCRel << 24) | (Log2Size << 25) |
(Index << 0) | (IsPCRel << 24) | (Log2Size << 25) | (Type << 28); (IsExtern << 27) | (Type << 28));
Writer->addRelocation(RelSymbol, Fragment->getParent(), MRE); Writer->addRelocation(Fragment->getParent(), MRE);
// Now set up the Addend relocation. // Now set up the Addend relocation.
Type = MachO::ARM64_RELOC_ADDEND; Type = MachO::ARM64_RELOC_ADDEND;
Index = Value; Index = Value;
RelSymbol = nullptr;
IsPCRel = 0; IsPCRel = 0;
Log2Size = 2; Log2Size = 2;
IsExtern = 0;
// Put zero into the instruction itself. The addend is in the relocation. // Put zero into the instruction itself. The addend is in the relocation.
Value = 0; Value = 0;
@ -379,9 +383,9 @@ void AArch64MachObjectWriter::RecordRelocation(
// struct relocation_info (8 bytes) // struct relocation_info (8 bytes)
MachO::any_relocation_info MRE; MachO::any_relocation_info MRE;
MRE.r_word0 = FixupOffset; MRE.r_word0 = FixupOffset;
MRE.r_word1 = MRE.r_word1 = ((Index << 0) | (IsPCRel << 24) | (Log2Size << 25) |
(Index << 0) | (IsPCRel << 24) | (Log2Size << 25) | (Type << 28); (IsExtern << 27) | (Type << 28));
Writer->addRelocation(RelSymbol, Fragment->getParent(), MRE); Writer->addRelocation(Fragment->getParent(), MRE);
} }
MCObjectWriter *llvm::createAArch64MachObjectWriter(raw_ostream &OS, MCObjectWriter *llvm::createAArch64MachObjectWriter(raw_ostream &OS,

37
lib/Target/ARM/MCTargetDesc/ARMMachObjectWriter.cpp
View File

@ -54,10 +54,10 @@ public:
: MCMachObjectTargetWriter(Is64Bit, CPUType, CPUSubtype, : MCMachObjectTargetWriter(Is64Bit, CPUType, CPUSubtype,
/*UseAggressiveSymbolFolding=*/true) {} /*UseAggressiveSymbolFolding=*/true) {}
void RecordRelocation(MachObjectWriter *Writer, MCAssembler &Asm, void RecordRelocation(MachObjectWriter *Writer,
const MCAsmLayout &Layout, const MCFragment *Fragment, const MCAssembler &Asm, const MCAsmLayout &Layout,
const MCFixup &Fixup, MCValue Target, const MCFragment *Fragment, const MCFixup &Fixup,
uint64_t &FixedValue) override; MCValue Target, uint64_t &FixedValue) override;
}; };
} }
@ -232,7 +232,7 @@ RecordARMScatteredHalfRelocation(MachObjectWriter *Writer,
(IsPCRel << 30) | (IsPCRel << 30) |
MachO::R_SCATTERED); MachO::R_SCATTERED);
MRE.r_word1 = Value2; MRE.r_word1 = Value2;
Writer->addRelocation(nullptr, Fragment->getParent(), MRE); Writer->addRelocation(Fragment->getParent(), MRE);
} }
MachO::any_relocation_info MRE; MachO::any_relocation_info MRE;
@ -243,7 +243,7 @@ RecordARMScatteredHalfRelocation(MachObjectWriter *Writer,
(IsPCRel << 30) | (IsPCRel << 30) |
MachO::R_SCATTERED); MachO::R_SCATTERED);
MRE.r_word1 = Value; MRE.r_word1 = Value;
Writer->addRelocation(nullptr, Fragment->getParent(), MRE); Writer->addRelocation(Fragment->getParent(), MRE);
} }
void ARMMachObjectWriter::RecordARMScatteredRelocation(MachObjectWriter *Writer, void ARMMachObjectWriter::RecordARMScatteredRelocation(MachObjectWriter *Writer,
@ -297,7 +297,7 @@ void ARMMachObjectWriter::RecordARMScatteredRelocation(MachObjectWriter *Writer,
(IsPCRel << 30) | (IsPCRel << 30) |
MachO::R_SCATTERED); MachO::R_SCATTERED);
MRE.r_word1 = Value2; MRE.r_word1 = Value2;
Writer->addRelocation(nullptr, Fragment->getParent(), MRE); Writer->addRelocation(Fragment->getParent(), MRE);
} }
MachO::any_relocation_info MRE; MachO::any_relocation_info MRE;
@ -307,7 +307,7 @@ void ARMMachObjectWriter::RecordARMScatteredRelocation(MachObjectWriter *Writer,
(IsPCRel << 30) | (IsPCRel << 30) |
MachO::R_SCATTERED); MachO::R_SCATTERED);
MRE.r_word1 = Value; MRE.r_word1 = Value;
Writer->addRelocation(nullptr, Fragment->getParent(), MRE); Writer->addRelocation(Fragment->getParent(), MRE);
} }
bool ARMMachObjectWriter::requiresExternRelocation(MachObjectWriter *Writer, bool ARMMachObjectWriter::requiresExternRelocation(MachObjectWriter *Writer,
@ -351,10 +351,11 @@ bool ARMMachObjectWriter::requiresExternRelocation(MachObjectWriter *Writer,
} }
void ARMMachObjectWriter::RecordRelocation(MachObjectWriter *Writer, void ARMMachObjectWriter::RecordRelocation(MachObjectWriter *Writer,
MCAssembler &Asm, const MCAssembler &Asm,
const MCAsmLayout &Layout, const MCAsmLayout &Layout,
const MCFragment *Fragment, const MCFragment *Fragment,
const MCFixup &Fixup, MCValue Target, const MCFixup &Fixup,
MCValue Target,
uint64_t &FixedValue) { uint64_t &FixedValue) {
unsigned IsPCRel = Writer->isFixupKindPCRel(Asm, Fixup.getKind()); unsigned IsPCRel = Writer->isFixupKindPCRel(Asm, Fixup.getKind());
unsigned Log2Size; unsigned Log2Size;
@ -400,8 +401,8 @@ void ARMMachObjectWriter::RecordRelocation(MachObjectWriter *Writer,
// See <reloc.h>. // See <reloc.h>.
uint32_t FixupOffset = Layout.getFragmentOffset(Fragment)+Fixup.getOffset(); uint32_t FixupOffset = Layout.getFragmentOffset(Fragment)+Fixup.getOffset();
unsigned Index = 0; unsigned Index = 0;
unsigned IsExtern = 0;
unsigned Type = 0; unsigned Type = 0;
const MCSymbolData *RelSymbol = nullptr;
if (Target.isAbsolute()) { // constant if (Target.isAbsolute()) { // constant
// FIXME! // FIXME!
@ -421,7 +422,8 @@ void ARMMachObjectWriter::RecordRelocation(MachObjectWriter *Writer,
// Check whether we need an external or internal relocation. // Check whether we need an external or internal relocation.
if (requiresExternRelocation(Writer, Asm, *Fragment, RelocType, SD, if (requiresExternRelocation(Writer, Asm, *Fragment, RelocType, SD,
FixedValue)) { FixedValue)) {
RelSymbol = SD; IsExtern = 1;
Index = SD->getIndex();
// For external relocations, make sure to offset the fixup value to // For external relocations, make sure to offset the fixup value to
// compensate for the addend of the symbol address, if it was // compensate for the addend of the symbol address, if it was
@ -445,8 +447,11 @@ void ARMMachObjectWriter::RecordRelocation(MachObjectWriter *Writer,
// struct relocation_info (8 bytes) // struct relocation_info (8 bytes)
MachO::any_relocation_info MRE; MachO::any_relocation_info MRE;
MRE.r_word0 = FixupOffset; MRE.r_word0 = FixupOffset;
MRE.r_word1 = MRE.r_word1 = ((Index << 0) |
(Index << 0) | (IsPCRel << 24) | (Log2Size << 25) | (Type << 28); (IsPCRel << 24) |
(Log2Size << 25) |
(IsExtern << 27) |
(Type << 28));
// Even when it's not a scattered relocation, movw/movt always uses // Even when it's not a scattered relocation, movw/movt always uses
// a PAIR relocation. // a PAIR relocation.
@ -471,10 +476,10 @@ void ARMMachObjectWriter::RecordRelocation(MachObjectWriter *Writer,
(Log2Size << 25) | (Log2Size << 25) |
(MachO::ARM_RELOC_PAIR << 28)); (MachO::ARM_RELOC_PAIR << 28));
Writer->addRelocation(nullptr, Fragment->getParent(), MREPair); Writer->addRelocation(Fragment->getParent(), MREPair);
} }
Writer->addRelocation(RelSymbol, Fragment->getParent(), MRE); Writer->addRelocation(Fragment->getParent(), MRE);
} }
MCObjectWriter *llvm::createARMMachObjectWriter(raw_ostream &OS, MCObjectWriter *llvm::createARMMachObjectWriter(raw_ostream &OS,

16
lib/Target/PowerPC/MCTargetDesc/PPCMachObjectWriter.cpp
View File

@ -41,7 +41,7 @@ public:
: MCMachObjectTargetWriter(Is64Bit, CPUType, CPUSubtype, : MCMachObjectTargetWriter(Is64Bit, CPUType, CPUSubtype,
/*UseAggressiveSymbolFolding=*/Is64Bit) {} /*UseAggressiveSymbolFolding=*/Is64Bit) {}
void RecordRelocation(MachObjectWriter *Writer, MCAssembler &Asm, void RecordRelocation(MachObjectWriter *Writer, const MCAssembler &Asm,
const MCAsmLayout &Layout, const MCFragment *Fragment, const MCAsmLayout &Layout, const MCFragment *Fragment,
const MCFixup &Fixup, MCValue Target, const MCFixup &Fixup, MCValue Target,
uint64_t &FixedValue) override { uint64_t &FixedValue) override {
@ -282,7 +282,7 @@ bool PPCMachObjectWriter::RecordScatteredRelocation(
MachO::any_relocation_info MRE; MachO::any_relocation_info MRE;
makeScatteredRelocationInfo(MRE, other_half, MachO::GENERIC_RELOC_PAIR, makeScatteredRelocationInfo(MRE, other_half, MachO::GENERIC_RELOC_PAIR,
Log2Size, IsPCRel, Value2); Log2Size, IsPCRel, Value2);
Writer->addRelocation(nullptr, Fragment->getParent(), MRE); Writer->addRelocation(Fragment->getParent(), MRE);
} else { } else {
// If the offset is more than 24-bits, it won't fit in a scattered // If the offset is more than 24-bits, it won't fit in a scattered
// relocation offset field, so we fall back to using a non-scattered // relocation offset field, so we fall back to using a non-scattered
@ -296,7 +296,7 @@ bool PPCMachObjectWriter::RecordScatteredRelocation(
} }
MachO::any_relocation_info MRE; MachO::any_relocation_info MRE;
makeScatteredRelocationInfo(MRE, FixupOffset, Type, Log2Size, IsPCRel, Value); makeScatteredRelocationInfo(MRE, FixupOffset, Type, Log2Size, IsPCRel, Value);
Writer->addRelocation(nullptr, Fragment->getParent(), MRE); Writer->addRelocation(Fragment->getParent(), MRE);
return true; return true;
} }
@ -331,9 +331,9 @@ void PPCMachObjectWriter::RecordPPCRelocation(
// See <reloc.h>. // See <reloc.h>.
const uint32_t FixupOffset = getFixupOffset(Layout, Fragment, Fixup); const uint32_t FixupOffset = getFixupOffset(Layout, Fragment, Fixup);
unsigned Index = 0; unsigned Index = 0;
unsigned IsExtern = 0;
unsigned Type = RelocType; unsigned Type = RelocType;
const MCSymbolData *RelSymbol = nullptr;
if (Target.isAbsolute()) { // constant if (Target.isAbsolute()) { // constant
// SymbolNum of 0 indicates the absolute section. // SymbolNum of 0 indicates the absolute section.
// //
@ -355,7 +355,8 @@ void PPCMachObjectWriter::RecordPPCRelocation(
// Check whether we need an external or internal relocation. // Check whether we need an external or internal relocation.
if (Writer->doesSymbolRequireExternRelocation(SD)) { if (Writer->doesSymbolRequireExternRelocation(SD)) {
RelSymbol = SD; IsExtern = 1;
Index = SD->getIndex();
// For external relocations, make sure to offset the fixup value to // For external relocations, make sure to offset the fixup value to
// compensate for the addend of the symbol address, if it was // compensate for the addend of the symbol address, if it was
// undefined. This occurs with weak definitions, for example. // undefined. This occurs with weak definitions, for example.
@ -374,8 +375,9 @@ void PPCMachObjectWriter::RecordPPCRelocation(
// struct relocation_info (8 bytes) // struct relocation_info (8 bytes)
MachO::any_relocation_info MRE; MachO::any_relocation_info MRE;
makeRelocationInfo(MRE, FixupOffset, Index, IsPCRel, Log2Size, false, Type); makeRelocationInfo(MRE, FixupOffset, Index, IsPCRel, Log2Size, IsExtern,
Writer->addRelocation(RelSymbol, Fragment->getParent(), MRE); Type);
Writer->addRelocation(Fragment->getParent(), MRE);
} }
MCObjectWriter *llvm::createPPCMachObjectWriter(raw_ostream &OS, bool Is64Bit, MCObjectWriter *llvm::createPPCMachObjectWriter(raw_ostream &OS, bool Is64Bit,

2
lib/Target/R600/MCTargetDesc/AMDGPUAsmBackend.cpp
View File

@ -29,7 +29,7 @@ public:
const MCAsmLayout &Layout) override { const MCAsmLayout &Layout) override {
//XXX: Implement if necessary. //XXX: Implement if necessary.
} }
void RecordRelocation(MCAssembler &Asm, const MCAsmLayout &Layout, void RecordRelocation(const MCAssembler &Asm, const MCAsmLayout &Layout,
const MCFragment *Fragment, const MCFixup &Fixup, const MCFragment *Fragment, const MCFixup &Fixup,
MCValue Target, bool &IsPCRel, MCValue Target, bool &IsPCRel,
uint64_t &FixedValue) override { uint64_t &FixedValue) override {

13
lib/Target/X86/MCTargetDesc/X86AsmBackend.cpp
View File

@ -777,6 +777,19 @@ public:
MachO::CPU_TYPE_X86_64, Subtype); MachO::CPU_TYPE_X86_64, Subtype);
} }
bool doesSectionRequireSymbols(const MCSection &Section) const override {
// Temporary labels in the string literals sections require symbols. The
// issue is that the x86_64 relocation format does not allow symbol +
// offset, and so the linker does not have enough information to resolve the
// access to the appropriate atom unless an external relocation is used. For
// non-cstring sections, we expect the compiler to use a non-temporary label
// for anything that could have an addend pointing outside the symbol.
//
// See <rdar://problem/4765733>.
const MCSectionMachO &SMO = static_cast<const MCSectionMachO&>(Section);
return SMO.getType() == MachO::S_CSTRING_LITERALS;
}
/// \brief Generate the compact unwind encoding for the CFI instructions. /// \brief Generate the compact unwind encoding for the CFI instructions.
uint32_t generateCompactUnwindEncoding( uint32_t generateCompactUnwindEncoding(
ArrayRef<MCCFIInstruction> Instrs) const override { ArrayRef<MCCFIInstruction> Instrs) const override {

114
lib/Target/X86/MCTargetDesc/X86MachObjectWriter.cpp
View File

@ -10,7 +10,6 @@
#include "MCTargetDesc/X86MCTargetDesc.h" #include "MCTargetDesc/X86MCTargetDesc.h"
#include "MCTargetDesc/X86FixupKinds.h" #include "MCTargetDesc/X86FixupKinds.h"
#include "llvm/ADT/Twine.h" #include "llvm/ADT/Twine.h"
#include "llvm/MC/MCAsmInfo.h"
#include "llvm/MC/MCAsmLayout.h" #include "llvm/MC/MCAsmLayout.h"
#include "llvm/MC/MCAssembler.h" #include "llvm/MC/MCAssembler.h"
#include "llvm/MC/MCContext.h" #include "llvm/MC/MCContext.h"
@ -48,21 +47,23 @@ class X86MachObjectWriter : public MCMachObjectTargetWriter {
const MCFixup &Fixup, const MCFixup &Fixup,
MCValue Target, MCValue Target,
uint64_t &FixedValue); uint64_t &FixedValue);
void RecordX86_64Relocation(MachObjectWriter *Writer, MCAssembler &Asm, void RecordX86_64Relocation(MachObjectWriter *Writer,
const MCAssembler &Asm,
const MCAsmLayout &Layout, const MCAsmLayout &Layout,
const MCFragment *Fragment, const MCFixup &Fixup, const MCFragment *Fragment,
MCValue Target, uint64_t &FixedValue); const MCFixup &Fixup,
MCValue Target,
uint64_t &FixedValue);
public: public:
X86MachObjectWriter(bool Is64Bit, uint32_t CPUType, X86MachObjectWriter(bool Is64Bit, uint32_t CPUType,
uint32_t CPUSubtype) uint32_t CPUSubtype)
: MCMachObjectTargetWriter(Is64Bit, CPUType, CPUSubtype, : MCMachObjectTargetWriter(Is64Bit, CPUType, CPUSubtype,
/*UseAggressiveSymbolFolding=*/Is64Bit) {} /*UseAggressiveSymbolFolding=*/Is64Bit) {}
void RecordRelocation(MachObjectWriter *Writer, MCAssembler &Asm, void RecordRelocation(MachObjectWriter *Writer,
const MCAsmLayout &Layout, const MCFragment *Fragment, const MCAssembler &Asm, const MCAsmLayout &Layout,
const MCFixup &Fixup, MCValue Target, const MCFragment *Fragment, const MCFixup &Fixup,
uint64_t &FixedValue) override { MCValue Target, uint64_t &FixedValue) override {
if (Writer->is64Bit()) if (Writer->is64Bit())
RecordX86_64Relocation(Writer, Asm, Layout, Fragment, Fixup, Target, RecordX86_64Relocation(Writer, Asm, Layout, Fragment, Fixup, Target,
FixedValue); FixedValue);
@ -96,10 +97,13 @@ static unsigned getFixupKindLog2Size(unsigned Kind) {
} }
} }
void X86MachObjectWriter::RecordX86_64Relocation( void X86MachObjectWriter::RecordX86_64Relocation(MachObjectWriter *Writer,
MachObjectWriter *Writer, MCAssembler &Asm, const MCAsmLayout &Layout, const MCAssembler &Asm,
const MCFragment *Fragment, const MCFixup &Fixup, MCValue Target, const MCAsmLayout &Layout,
uint64_t &FixedValue) { const MCFragment *Fragment,
const MCFixup &Fixup,
MCValue Target,
uint64_t &FixedValue) {
unsigned IsPCRel = Writer->isFixupKindPCRel(Asm, Fixup.getKind()); unsigned IsPCRel = Writer->isFixupKindPCRel(Asm, Fixup.getKind());
unsigned IsRIPRel = isFixupKindRIPRel(Fixup.getKind()); unsigned IsRIPRel = isFixupKindRIPRel(Fixup.getKind());
unsigned Log2Size = getFixupKindLog2Size(Fixup.getKind()); unsigned Log2Size = getFixupKindLog2Size(Fixup.getKind());
@ -113,7 +117,6 @@ void X86MachObjectWriter::RecordX86_64Relocation(
unsigned Index = 0; unsigned Index = 0;
unsigned IsExtern = 0; unsigned IsExtern = 0;
unsigned Type = 0; unsigned Type = 0;
const MCSymbolData *RelSymbol = nullptr;
Value = Target.getConstant(); Value = Target.getConstant();
@ -129,6 +132,7 @@ void X86MachObjectWriter::RecordX86_64Relocation(
if (Target.isAbsolute()) { // constant if (Target.isAbsolute()) { // constant
// SymbolNum of 0 indicates the absolute section. // SymbolNum of 0 indicates the absolute section.
Type = MachO::X86_64_RELOC_UNSIGNED; Type = MachO::X86_64_RELOC_UNSIGNED;
Index = 0;
// FIXME: I believe this is broken, I don't think the linker can understand // FIXME: I believe this is broken, I don't think the linker can understand
// it. I think it would require a local relocation, but I'm not sure if that // it. I think it would require a local relocation, but I'm not sure if that
@ -189,30 +193,36 @@ void X86MachObjectWriter::RecordX86_64Relocation(
Value -= Writer->getSymbolAddress(&B_SD, Layout) - Value -= Writer->getSymbolAddress(&B_SD, Layout) -
(!B_Base ? 0 : Writer->getSymbolAddress(B_Base, Layout)); (!B_Base ? 0 : Writer->getSymbolAddress(B_Base, Layout));
if (!A_Base) if (A_Base) {
Index = A_Base->getIndex();
IsExtern = 1;
} else {
Index = A_SD.getFragment()->getParent()->getOrdinal() + 1; Index = A_SD.getFragment()->getParent()->getOrdinal() + 1;
IsExtern = 0;
}
Type = MachO::X86_64_RELOC_UNSIGNED; Type = MachO::X86_64_RELOC_UNSIGNED;
MachO::any_relocation_info MRE; MachO::any_relocation_info MRE;
MRE.r_word0 = FixupOffset; MRE.r_word0 = FixupOffset;
MRE.r_word1 = MRE.r_word1 = ((Index << 0) |
(Index << 0) | (IsPCRel << 24) | (Log2Size << 25) | (Type << 28); (IsPCRel << 24) |
Writer->addRelocation(A_Base, Fragment->getParent(), MRE); (Log2Size << 25) |
(IsExtern << 27) |
(Type << 28));
Writer->addRelocation(Fragment->getParent(), MRE);
if (B_Base) if (B_Base) {
RelSymbol = B_Base; Index = B_Base->getIndex();
else IsExtern = 1;
} else {
Index = B_SD.getFragment()->getParent()->getOrdinal() + 1; Index = B_SD.getFragment()->getParent()->getOrdinal() + 1;
IsExtern = 0;
}
Type = MachO::X86_64_RELOC_SUBTRACTOR; Type = MachO::X86_64_RELOC_SUBTRACTOR;
} else { } else {
const MCSymbol *Symbol = &Target.getSymA()->getSymbol(); const MCSymbol *Symbol = &Target.getSymA()->getSymbol();
if (Symbol->isTemporary() && Value) {
const MCSection &Sec = Symbol->getSection();
if (!Asm.getContext().getAsmInfo()->isSectionAtomizableBySymbols(Sec))
Asm.addLocalUsedInReloc(*Symbol);
}
const MCSymbolData &SD = Asm.getSymbolData(*Symbol); const MCSymbolData &SD = Asm.getSymbolData(*Symbol);
RelSymbol = Asm.getAtom(&SD); const MCSymbolData *Base = Asm.getAtom(&SD);
// Relocations inside debug sections always use local relocations when // Relocations inside debug sections always use local relocations when
// possible. This seems to be done because the debugger doesn't fully // possible. This seems to be done because the debugger doesn't fully
@ -222,20 +232,23 @@ void X86MachObjectWriter::RecordX86_64Relocation(
const MCSectionMachO &Section = static_cast<const MCSectionMachO&>( const MCSectionMachO &Section = static_cast<const MCSectionMachO&>(
Fragment->getParent()->getSection()); Fragment->getParent()->getSection());
if (Section.hasAttribute(MachO::S_ATTR_DEBUG)) if (Section.hasAttribute(MachO::S_ATTR_DEBUG))
RelSymbol = nullptr; Base = nullptr;
} }
// x86_64 almost always uses external relocations, except when there is no // x86_64 almost always uses external relocations, except when there is no
// symbol to use as a base address (a local symbol with no preceding // symbol to use as a base address (a local symbol with no preceding
// non-local symbol). // non-local symbol).
if (RelSymbol) { if (Base) {
Index = Base->getIndex();
IsExtern = 1;
// Add the local offset, if needed. // Add the local offset, if needed.
if (RelSymbol != &SD) if (Base != &SD)
Value += Value += Layout.getSymbolOffset(&SD) - Layout.getSymbolOffset(Base);
Layout.getSymbolOffset(&SD) - Layout.getSymbolOffset(RelSymbol);
} else if (Symbol->isInSection() && !Symbol->isVariable()) { } else if (Symbol->isInSection() && !Symbol->isVariable()) {
// The index is the section ordinal (1-based). // The index is the section ordinal (1-based).
Index = SD.getFragment()->getParent()->getOrdinal() + 1; Index = SD.getFragment()->getParent()->getOrdinal() + 1;
IsExtern = 0;
Value += Writer->getSymbolAddress(&SD, Layout); Value += Writer->getSymbolAddress(&SD, Layout);
if (IsPCRel) if (IsPCRel)
@ -334,9 +347,12 @@ void X86MachObjectWriter::RecordX86_64Relocation(
// struct relocation_info (8 bytes) // struct relocation_info (8 bytes)
MachO::any_relocation_info MRE; MachO::any_relocation_info MRE;
MRE.r_word0 = FixupOffset; MRE.r_word0 = FixupOffset;
MRE.r_word1 = (Index << 0) | (IsPCRel << 24) | (Log2Size << 25) | MRE.r_word1 = ((Index << 0) |
(IsExtern << 27) | (Type << 28); (IsPCRel << 24) |
Writer->addRelocation(RelSymbol, Fragment->getParent(), MRE); (Log2Size << 25) |
(IsExtern << 27) |
(Type << 28));
Writer->addRelocation(Fragment->getParent(), MRE);
} }
bool X86MachObjectWriter::RecordScatteredRelocation(MachObjectWriter *Writer, bool X86MachObjectWriter::RecordScatteredRelocation(MachObjectWriter *Writer,
@ -408,7 +424,7 @@ bool X86MachObjectWriter::RecordScatteredRelocation(MachObjectWriter *Writer,
(IsPCRel << 30) | (IsPCRel << 30) |
MachO::R_SCATTERED); MachO::R_SCATTERED);
MRE.r_word1 = Value2; MRE.r_word1 = Value2;
Writer->addRelocation(nullptr, Fragment->getParent(), MRE); Writer->addRelocation(Fragment->getParent(), MRE);
} else { } else {
// If the offset is more than 24-bits, it won't fit in a scattered // If the offset is more than 24-bits, it won't fit in a scattered
// relocation offset field, so we fall back to using a non-scattered // relocation offset field, so we fall back to using a non-scattered
@ -430,7 +446,7 @@ bool X86MachObjectWriter::RecordScatteredRelocation(MachObjectWriter *Writer,
(IsPCRel << 30) | (IsPCRel << 30) |
MachO::R_SCATTERED); MachO::R_SCATTERED);
MRE.r_word1 = Value; MRE.r_word1 = Value;
Writer->addRelocation(nullptr, Fragment->getParent(), MRE); Writer->addRelocation(Fragment->getParent(), MRE);
return true; return true;
} }
@ -451,6 +467,7 @@ void X86MachObjectWriter::RecordTLVPRelocation(MachObjectWriter *Writer,
// Get the symbol data. // Get the symbol data.
const MCSymbolData *SD_A = &Asm.getSymbolData(Target.getSymA()->getSymbol()); const MCSymbolData *SD_A = &Asm.getSymbolData(Target.getSymA()->getSymbol());
unsigned Index = SD_A->getIndex();
// We're only going to have a second symbol in pic mode and it'll be a // We're only going to have a second symbol in pic mode and it'll be a
// subtraction from the picbase. For 32-bit pic the addend is the difference // subtraction from the picbase. For 32-bit pic the addend is the difference
@ -473,9 +490,12 @@ void X86MachObjectWriter::RecordTLVPRelocation(MachObjectWriter *Writer,
// struct relocation_info (8 bytes) // struct relocation_info (8 bytes)
MachO::any_relocation_info MRE; MachO::any_relocation_info MRE;
MRE.r_word0 = Value; MRE.r_word0 = Value;
MRE.r_word1 = MRE.r_word1 = ((Index << 0) |
(IsPCRel << 24) | (Log2Size << 25) | (MachO::GENERIC_RELOC_TLV << 28); (IsPCRel << 24) |
Writer->addRelocation(SD_A, Fragment->getParent(), MRE); (Log2Size << 25) |
(1 << 27) | // r_extern
(MachO::GENERIC_RELOC_TLV << 28)); // r_type
Writer->addRelocation(Fragment->getParent(), MRE);
} }
void X86MachObjectWriter::RecordX86Relocation(MachObjectWriter *Writer, void X86MachObjectWriter::RecordX86Relocation(MachObjectWriter *Writer,
@ -526,8 +546,8 @@ void X86MachObjectWriter::RecordX86Relocation(MachObjectWriter *Writer,
// See <reloc.h>. // See <reloc.h>.
uint32_t FixupOffset = Layout.getFragmentOffset(Fragment)+Fixup.getOffset(); uint32_t FixupOffset = Layout.getFragmentOffset(Fragment)+Fixup.getOffset();
unsigned Index = 0; unsigned Index = 0;
unsigned IsExtern = 0;
unsigned Type = 0; unsigned Type = 0;
const MCSymbolData *RelSymbol = nullptr;
if (Target.isAbsolute()) { // constant if (Target.isAbsolute()) { // constant
// SymbolNum of 0 indicates the absolute section. // SymbolNum of 0 indicates the absolute section.
@ -548,7 +568,8 @@ void X86MachObjectWriter::RecordX86Relocation(MachObjectWriter *Writer,
// Check whether we need an external or internal relocation. // Check whether we need an external or internal relocation.
if (Writer->doesSymbolRequireExternRelocation(SD)) { if (Writer->doesSymbolRequireExternRelocation(SD)) {
RelSymbol = SD; IsExtern = 1;
Index = SD->getIndex();
// For external relocations, make sure to offset the fixup value to // For external relocations, make sure to offset the fixup value to
// compensate for the addend of the symbol address, if it was // compensate for the addend of the symbol address, if it was
// undefined. This occurs with weak definitions, for example. // undefined. This occurs with weak definitions, for example.
@ -570,9 +591,12 @@ void X86MachObjectWriter::RecordX86Relocation(MachObjectWriter *Writer,
// struct relocation_info (8 bytes) // struct relocation_info (8 bytes)
MachO::any_relocation_info MRE; MachO::any_relocation_info MRE;
MRE.r_word0 = FixupOffset; MRE.r_word0 = FixupOffset;
MRE.r_word1 = MRE.r_word1 = ((Index << 0) |
(Index << 0) | (IsPCRel << 24) | (Log2Size << 25) | (Type << 28); (IsPCRel << 24) |
Writer->addRelocation(RelSymbol, Fragment->getParent(), MRE); (Log2Size << 25) |
(IsExtern << 27) |
(Type << 28));
Writer->addRelocation(Fragment->getParent(), MRE);
} }
MCObjectWriter *llvm::createX86MachObjectWriter(raw_ostream &OS, MCObjectWriter *llvm::createX86MachObjectWriter(raw_ostream &OS,

59
test/MC/MachO/AArch64/mergeable.s
View File

@ -1,59 +0,0 @@
// RUN: llvm-mc -triple aarch64-apple-darwin14 %s -filetype=obj -o - | llvm-readobj -r --expand-relocs | FileCheck %s
// Test that we "S + K" produce a relocation with a symbol, but just S produces
// a relocation with the section.
.section __TEXT,__literal4,4byte_literals
L0:
.long 42
.section __TEXT,__cstring,cstring_literals
L1:
.asciz "42"
.section __DATA,__data
.quad L0
.quad L0 + 1
.quad L1
.quad L1 + 1
// CHECK: Relocations [
// CHECK-NEXT: Section __data {
// CHECK-NEXT: Relocation {
// CHECK-NEXT: Offset: 0x18
// CHECK-NEXT: PCRel: 0
// CHECK-NEXT: Length: 3
// CHECK-NEXT: Extern: 1
// CHECK-NEXT: Type: ARM64_RELOC_UNSIGNED (0)
// CHECK-NEXT: Symbol: L1
// CHECK-NEXT: Scattered: 0
// CHECK-NEXT: }
// CHECK-NEXT: Relocation {
// CHECK-NEXT: Offset: 0x10
// CHECK-NEXT: PCRel: 0
// CHECK-NEXT: Length: 3
// CHECK-NEXT: Extern: 0
// CHECK-NEXT: Type: ARM64_RELOC_UNSIGNED (0)
// CHECK-NEXT: Symbol: 0x3
// CHECK-NEXT: Scattered: 0
// CHECK-NEXT: }
// CHECK-NEXT: Relocation {
// CHECK-NEXT: Offset: 0x8
// CHECK-NEXT: PCRel: 0
// CHECK-NEXT: Length: 3
// CHECK-NEXT: Extern: 1
// CHECK-NEXT: Type: ARM64_RELOC_UNSIGNED (0)
// CHECK-NEXT: Symbol: L0
// CHECK-NEXT: Scattered: 0
// CHECK-NEXT: }
// CHECK-NEXT: Relocation {
// CHECK-NEXT: Offset: 0x0
// CHECK-NEXT: PCRel: 0
// CHECK-NEXT: Length: 3
// CHECK-NEXT: Extern: 0
// CHECK-NEXT: Type: ARM64_RELOC_UNSIGNED (0)
// CHECK-NEXT: Symbol: 0x2
// CHECK-NEXT: Scattered: 0
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: ]

59
test/MC/MachO/x86_64-mergeable.s
View File

@ -1,59 +0,0 @@
// RUN: llvm-mc -triple x86_64-apple-darwin14 %s -filetype=obj -o - | llvm-readobj -r --expand-relocs | FileCheck %s
// Test that we "S + K" produce a relocation with a symbol, but just S produces
// a relocation with the section.
.section __TEXT,__literal4,4byte_literals
L0:
.long 42
.section __TEXT,__cstring,cstring_literals
L1:
.asciz "42"
.section __DATA,__data
.quad L0
.quad L0 + 1
.quad L1
.quad L1 + 1
// CHECK: Relocations [
// CHECK-NEXT: Section __data {
// CHECK-NEXT: Relocation {
// CHECK-NEXT: Offset: 0x18
// CHECK-NEXT: PCRel: 0
// CHECK-NEXT: Length: 3
// CHECK-NEXT: Extern: 1
// CHECK-NEXT: Type: X86_64_RELOC_UNSIGNED (0)
// CHECK-NEXT: Symbol: L1
// CHECK-NEXT: Scattered: 0
// CHECK-NEXT: }
// CHECK-NEXT: Relocation {
// CHECK-NEXT: Offset: 0x10
// CHECK-NEXT: PCRel: 0
// CHECK-NEXT: Length: 3
// CHECK-NEXT: Extern: 0
// CHECK-NEXT: Type: X86_64_RELOC_UNSIGNED (0)
// CHECK-NEXT: Symbol: 0x3
// CHECK-NEXT: Scattered: 0
// CHECK-NEXT: }
// CHECK-NEXT: Relocation {
// CHECK-NEXT: Offset: 0x8
// CHECK-NEXT: PCRel: 0
// CHECK-NEXT: Length: 3
// CHECK-NEXT: Extern: 1
// CHECK-NEXT: Type: X86_64_RELOC_UNSIGNED (0)
// CHECK-NEXT: Symbol: L0
// CHECK-NEXT: Scattered: 0
// CHECK-NEXT: }
// CHECK-NEXT: Relocation {
// CHECK-NEXT: Offset: 0x0
// CHECK-NEXT: PCRel: 0
// CHECK-NEXT: Length: 3
// CHECK-NEXT: Extern: 0
// CHECK-NEXT: Type: X86_64_RELOC_UNSIGNED (0)
// CHECK-NEXT: Symbol: 0x2
// CHECK-NEXT: Scattered: 0
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: ]

6
test/MC/MachO/x86_64-symbols.s
View File

@ -121,12 +121,6 @@ D38:
//L39: //L39:
//D39: //D39:
.section foo, bar
.long L4 + 1
.long L35 + 1
.long L36 + 1
.long L37 + 1
.long L38 + 1
// CHECK: Symbols [ // CHECK: Symbols [
// CHECK-NEXT: Symbol { // CHECK-NEXT: Symbol {