65#define DEBUG_TYPE "reloc-info"
78class SymbolTableWriter {
83 std::vector<uint32_t> ShndxIndexes;
88 void createSymtabShndx();
93 SymbolTableWriter(ELFWriter &EWriter,
bool Is64Bit);
102 ELFObjectWriter &OWriter;
113 bool Used,
bool Renamed);
116 struct ELFSymbolData {
132 unsigned LastLocalSymbolIndex = ~0u;
134 unsigned StringTableIndex = ~0u;
136 unsigned SymbolTableIndex = ~0u;
139 std::vector<const MCSectionELF *> SectionTable;
154 bool IsLittleEndian, DwoMode Mode)
166 template <
typename T>
void write(
T Val) {
172 void writeSymbol(SymbolTableWriter &Writer,
uint32_t StringIndex,
176 using SectionOffsetsTy =
177 std::map<const MCSectionELF *, std::pair<uint64_t, uint64_t>>;
188 const SectionIndexMapTy &SectionIndexMap,
189 const RevGroupMapTy &RevGroupMap,
190 SectionOffsetsTy &SectionOffsets);
192 void writeAddrsigSection();
200 const SectionIndexMapTy &SectionIndexMap,
201 const SectionOffsetsTy &SectionOffsets);
214 void writeSection(
const SectionIndexMapTy &SectionIndexMap,
221 std::unique_ptr<MCELFObjectTargetWriter> TargetObjectWriter;
227 bool SeenGnuAbi =
false;
229 std::optional<uint8_t> OverrideABIVersion;
231 bool hasRelocationAddend()
const;
235 unsigned Type)
const;
238 ELFObjectWriter(std::unique_ptr<MCELFObjectTargetWriter> MOTW)
239 : TargetObjectWriter(std::move(MOTW)) {}
241 void reset()
override {
243 OverrideABIVersion.reset();
252 bool IsPCRel)
const override;
267 void markGnuAbi()
override { SeenGnuAbi =
true; }
268 bool seenGnuAbi()
const {
return SeenGnuAbi; }
270 bool seenOverrideABIVersion()
const {
return OverrideABIVersion.has_value(); }
271 uint8_t getOverrideABIVersion()
const {
return OverrideABIVersion.value(); }
274 friend struct ELFWriter;
277class ELFSingleObjectWriter :
public ELFObjectWriter {
282 ELFSingleObjectWriter(std::unique_ptr<MCELFObjectTargetWriter> MOTW,
284 : ELFObjectWriter(std::move(MOTW)),
OS(
OS),
285 IsLittleEndian(IsLittleEndian) {}
288 return ELFWriter(*
this,
OS, IsLittleEndian, ELFWriter::AllSections)
289 .writeObject(Asm, Layout);
292 friend struct ELFWriter;
295class ELFDwoObjectWriter :
public ELFObjectWriter {
300 ELFDwoObjectWriter(std::unique_ptr<MCELFObjectTargetWriter> MOTW,
303 : ELFObjectWriter(std::move(MOTW)),
OS(
OS), DwoOS(DwoOS),
304 IsLittleEndian(IsLittleEndian) {}
309 Ctx.
reportError(Loc,
"A dwo section may not contain relocations");
313 Ctx.
reportError(Loc,
"A relocation may not refer to a dwo section");
320 uint64_t Size = ELFWriter(*
this,
OS, IsLittleEndian, ELFWriter::NonDwoOnly)
321 .writeObject(Asm, Layout);
322 Size += ELFWriter(*
this, DwoOS, IsLittleEndian, ELFWriter::DwoOnly)
323 .writeObject(Asm, Layout);
333 W.OS.write_zeros(NewOffset -
Offset);
337unsigned ELFWriter::addToSectionTable(
const MCSectionELF *Sec) {
338 SectionTable.push_back(Sec);
339 StrTabBuilder.add(Sec->
getName());
340 return SectionTable.size();
343void SymbolTableWriter::createSymtabShndx() {
344 if (!ShndxIndexes.empty())
347 ShndxIndexes.resize(NumWritten);
350template <
typename T>
void SymbolTableWriter::write(
T Value) {
351 EWriter.write(
Value);
354SymbolTableWriter::SymbolTableWriter(ELFWriter &EWriter,
bool Is64Bit)
355 : EWriter(EWriter), Is64Bit(Is64Bit), NumWritten(0) {}
365 if (!ShndxIndexes.empty()) {
367 ShndxIndexes.push_back(shndx);
369 ShndxIndexes.push_back(0);
393bool ELFWriter::is64Bit()
const {
394 return OWriter.TargetObjectWriter->is64Bit();
397bool ELFWriter::usesRela(
const MCSectionELF &Sec)
const {
398 return OWriter.hasRelocationAddend() &&
403void ELFWriter::writeHeader(
const MCAssembler &Asm) {
422 uint8_t OSABI = OWriter.TargetObjectWriter->getOSABI();
427 W.OS <<
char(OWriter.seenOverrideABIVersion()
428 ? OWriter.getOverrideABIVersion()
429 : OWriter.TargetObjectWriter->getABIVersion());
435 W.write<
uint16_t>(OWriter.TargetObjectWriter->getEMachine());
467 return Sym.getCommonAlignment()->value();
480 uint8_t
Type = newType;
517 if (!Symbol->isVariable() ||
518 !(
Value = dyn_cast<MCSymbolRefExpr>(Symbol->getVariableValue())) ||
522 Symbol = &cast<MCSymbolELF>(
Value->getSymbol());
527void ELFWriter::writeSymbol(SymbolTableWriter &Writer,
uint32_t StringIndex,
529 const auto &
Symbol = cast<MCSymbolELF>(*MSD.Symbol);
538 uint8_t Binding =
Symbol.getBinding();
545 uint8_t
Info = (Binding << 4) |
Type;
549 uint8_t Visibility =
Symbol.getVisibility();
555 const MCExpr *ESize = MSD.Symbol->getSize();
556 if (!ESize &&
Base) {
558 ESize =
Base->getSize();
565 while (
Sym->isVariable()) {
567 dyn_cast<MCSymbolRefExpr>(
Sym->getVariableValue(
false))) {
568 Sym = cast<MCSymbolELF>(&Expr->getSymbol());
571 ESize =
Sym->getSize();
585 Writer.writeSymbol(StringIndex, Info,
Value,
Size,
Other, MSD.SectionIndex,
590 bool Used,
bool Renamed) {
591 if (
Symbol.isVariable()) {
594 if (
const auto *
T = dyn_cast<MCTargetExpr>(Expr))
595 if (
T->inlineAssignedExpr())
624void ELFWriter::createMemtagRelocs(
MCAssembler &Asm) {
627 const auto &SymE = cast<MCSymbolELF>(
Sym);
628 if (!SymE.isMemtag())
630 if (MemtagRelocs ==
nullptr) {
631 MemtagRelocs = OWriter.TargetObjectWriter->getMemtagRelocsSection(
Asm.getContext());
632 if (MemtagRelocs ==
nullptr)
634 Asm.registerSection(*MemtagRelocs);
637 OWriter.Relocations[MemtagRelocs].push_back(Rec);
641void ELFWriter::computeSymbolTable(
643 const SectionIndexMapTy &SectionIndexMap,
const RevGroupMapTy &RevGroupMap,
644 SectionOffsetsTy &SectionOffsets) {
646 SymbolTableWriter Writer(*
this,
is64Bit());
653 SymbolTableIndex = addToSectionTable(SymtabSection);
658 Writer.writeSymbol(0, 0, 0, 0, 0, 0,
false);
660 std::vector<ELFSymbolData> LocalSymbolData;
661 std::vector<ELFSymbolData> ExternalSymbolData;
664 for (
const std::pair<std::string, size_t> &
F : FileNames)
665 StrTabBuilder.add(
F.first);
668 bool HasLargeSectionIndex =
false;
670 const auto &
Symbol = cast<MCSymbolELF>(It.value());
672 bool WeakrefUsed =
Symbol.isWeakrefUsedInReloc();
673 bool isSignature =
Symbol.isSignature();
675 if (!
isInSymtab(Layout, Symbol, Used || WeakrefUsed || isSignature,
676 OWriter.Renames.count(&Symbol)))
685 MSD.Symbol = cast<MCSymbolELF>(&Symbol);
686 MSD.Order = It.index();
691 if (
Symbol.isAbsolute()) {
693 }
else if (
Symbol.isCommon()) {
694 if (
Symbol.isTargetCommon()) {
695 MSD.SectionIndex =
Symbol.getIndex();
700 }
else if (
Symbol.isUndefined()) {
701 if (isSignature && !Used) {
702 MSD.SectionIndex = RevGroupMap.lookup(&Symbol);
704 HasLargeSectionIndex =
true;
721 "Undefined section reference: " +
Symbol.getName());
727 MSD.SectionIndex = SectionIndexMap.lookup(&Section);
728 assert(MSD.SectionIndex &&
"Invalid section index!");
730 HasLargeSectionIndex =
true;
738 StrTabBuilder.add(
Name);
742 LocalSymbolData.push_back(MSD);
744 ExternalSymbolData.push_back(MSD);
748 unsigned SymtabShndxSectionIndex = 0;
750 if (HasLargeSectionIndex) {
753 SymtabShndxSectionIndex = addToSectionTable(SymtabShndxSection);
757 StrTabBuilder.finalize();
761 auto FileNameIt = FileNames.begin();
762 if (!FileNames.empty())
763 FileNames[0].second = 0;
765 for (ELFSymbolData &MSD : LocalSymbolData) {
767 for (; FileNameIt != FileNames.end() && FileNameIt->second <= MSD.Order;
769 Writer.writeSymbol(StrTabBuilder.getOffset(FileNameIt->first),
777 : StrTabBuilder.getOffset(MSD.Name);
778 MSD.Symbol->setIndex(
Index++);
779 writeSymbol(Writer, StringIndex, MSD, Layout);
781 for (; FileNameIt != FileNames.end(); ++FileNameIt) {
782 Writer.writeSymbol(StrTabBuilder.getOffset(FileNameIt->first),
789 LastLocalSymbolIndex =
Index;
791 for (ELFSymbolData &MSD : ExternalSymbolData) {
792 unsigned StringIndex = StrTabBuilder.getOffset(MSD.Name);
793 MSD.Symbol->setIndex(
Index++);
794 writeSymbol(Writer, StringIndex, MSD, Layout);
799 SectionOffsets[SymtabSection] = std::make_pair(SecStart, SecEnd);
802 if (ShndxIndexes.
empty()) {
803 assert(SymtabShndxSectionIndex == 0);
806 assert(SymtabShndxSectionIndex != 0);
808 SecStart =
W.OS.tell();
810 SectionTable[SymtabShndxSectionIndex - 1];
813 SecEnd =
W.OS.tell();
814 SectionOffsets[SymtabShndxSection] = std::make_pair(SecStart, SecEnd);
817void ELFWriter::writeAddrsigSection() {
819 if (
Sym->getIndex() != 0)
825 if (OWriter.Relocations[&Sec].empty())
829 bool Rela = usesRela(Sec);
830 std::string RelaSectionName = Rela ?
".rela" :
".rel";
851bool ELFWriter::maybeWriteCompression(
856 if (
Size <= HdrSize + CompressedContents.
size())
878 auto &Ctx =
Asm.getContext();
881 : DebugCompressionType::None;
882 if (CompressionType == DebugCompressionType::None ||
884 Asm.writeSectionData(
W.OS, &Section, Layout);
890 Asm.writeSectionData(VecOS, &Section, Layout);
892 ArrayRef(
reinterpret_cast<uint8_t *
>(UncompressedData.
data()),
893 UncompressedData.
size());
897 switch (CompressionType) {
898 case DebugCompressionType::None:
900 case DebugCompressionType::Zlib:
903 case DebugCompressionType::Zstd:
909 if (!maybeWriteCompression(ChType, UncompressedData.
size(), Compressed,
911 W.OS << UncompressedData;
934 WriteWord(Alignment ? Alignment->value() : 0);
935 WriteWord(EntrySize);
938void ELFWriter::writeRelocations(
const MCAssembler &Asm,
940 std::vector<ELFRelocationEntry> &Relocs = OWriter.Relocations[&Sec];
943 OWriter.TargetObjectWriter->sortRelocs(Asm, Relocs);
945 const bool Rela = usesRela(Sec);
946 if (OWriter.TargetObjectWriter->getEMachine() ==
ELF::EM_MIPS) {
948 uint32_t Symidx = Entry.Symbol ? Entry.Symbol->getIndex() : 0;
952 write(OWriter.TargetObjectWriter->getRSsym(Entry.Type));
953 write(OWriter.TargetObjectWriter->getRType3(Entry.Type));
954 write(OWriter.TargetObjectWriter->getRType2(Entry.Type));
955 write(OWriter.TargetObjectWriter->getRType(Entry.Type));
966 OWriter.TargetObjectWriter->getRType2(Entry.Type)) {
973 OWriter.TargetObjectWriter->getRType3(Entry.Type)) {
984 uint32_t Symidx = Entry.Symbol ? Entry.Symbol->getIndex() : 0;
1003void ELFWriter::writeSection(
const SectionIndexMapTy &SectionIndexMap,
1019 sh_link = SymbolTableIndex;
1020 assert(sh_link &&
".symtab not found");
1022 sh_info = SectionIndexMap.lookup(cast<MCSectionELF>(InfoSection));
1027 sh_link = StringTableIndex;
1028 sh_info = LastLocalSymbolIndex;
1034 sh_link = SymbolTableIndex;
1038 sh_link = SymbolTableIndex;
1039 sh_info = GroupSymbolIndex;
1047 if (
Sym &&
Sym->isInSection()) {
1049 sh_link = SectionIndexMap.lookup(Sec);
1053 WriteSecHdrEntry(StrTabBuilder.getOffset(
Section.getName()),
1055 sh_link, sh_info,
Section.getAlign(),
1059void ELFWriter::writeSectionHeader(
1060 const MCAsmLayout &Layout,
const SectionIndexMapTy &SectionIndexMap,
1061 const SectionOffsetsTy &SectionOffsets) {
1062 const unsigned NumSections = SectionTable.size();
1067 WriteSecHdrEntry(0, 0, 0, 0, 0, FirstSectionSize, 0, 0, std::nullopt, 0);
1073 GroupSymbolIndex = 0;
1075 GroupSymbolIndex =
Section->getGroup()->getIndex();
1077 const std::pair<uint64_t, uint64_t> &
Offsets =
1078 SectionOffsets.find(Section)->second;
1085 writeSection(SectionIndexMap, GroupSymbolIndex,
Offsets.first,
Size,
1096 StringTableIndex = addToSectionTable(StrtabSection);
1098 createMemtagRelocs(Asm);
1100 RevGroupMapTy RevGroupMap;
1101 SectionIndexMapTy SectionIndexMap;
1103 std::map<const MCSymbol *, std::vector<const MCSectionELF *>> GroupMembers;
1109 SectionOffsetsTy SectionOffsets;
1110 std::vector<MCSectionELF *>
Groups;
1111 std::vector<MCSectionELF *> Relocations;
1123 writeSectionData(Asm, Section, Layout);
1126 SectionOffsets[&
Section] = std::make_pair(SecStart, SecEnd);
1128 MCSectionELF *RelSection = createRelocationSection(Ctx, Section);
1130 if (SignatureSymbol) {
1131 unsigned &GroupIdx = RevGroupMap[SignatureSymbol];
1135 GroupIdx = addToSectionTable(Group);
1139 std::vector<const MCSectionELF *> &Members =
1140 GroupMembers[SignatureSymbol];
1141 Members.push_back(&Section);
1143 Members.push_back(RelSection);
1146 SectionIndexMap[&
Section] = addToSectionTable(&Section);
1148 SectionIndexMap[RelSection] = addToSectionTable(RelSection);
1149 Relocations.push_back(RelSection);
1152 OWriter.TargetObjectWriter->addTargetSectionFlags(Ctx, Section);
1162 for (
const MCSectionELF *Member : GroupMembers[SignatureSymbol]) {
1163 uint32_t SecIndex = SectionIndexMap.lookup(Member);
1168 SectionOffsets[Group] = std::make_pair(SecStart, SecEnd);
1171 if (Mode == DwoOnly) {
1174 StrTabBuilder.finalize();
1177 if (OWriter.EmitAddrsigSection) {
1180 addToSectionTable(AddrsigSection);
1184 computeSymbolTable(Asm, Layout, SectionIndexMap, RevGroupMap,
1191 writeRelocations(Asm,
1195 SectionOffsets[RelSection] = std::make_pair(SecStart, SecEnd);
1198 if (OWriter.EmitAddrsigSection) {
1200 writeAddrsigSection();
1202 SectionOffsets[AddrsigSection] = std::make_pair(SecStart, SecEnd);
1208 StrTabBuilder.write(
W.OS);
1209 SectionOffsets[StrtabSection] = std::make_pair(SecStart,
W.OS.tell());
1215 writeSectionHeader(Layout, SectionIndexMap, SectionOffsets);
1217 uint16_t NumSections = support::endian::byte_swap<uint16_t>(
1219 : SectionTable.size() + 1,
1221 unsigned NumSectionsOffset;
1226 support::endian::byte_swap<uint64_t>(SectionHeaderOffset,
W.Endian);
1227 Stream.pwrite(
reinterpret_cast<char *
>(&Val),
sizeof(Val),
1232 support::endian::byte_swap<uint32_t>(SectionHeaderOffset,
W.Endian);
1233 Stream.pwrite(
reinterpret_cast<char *
>(&Val),
sizeof(Val),
1237 Stream.pwrite(
reinterpret_cast<char *
>(&NumSections),
sizeof(NumSections),
1240 return W.OS.tell() - StartOffset;
1243bool ELFObjectWriter::hasRelocationAddend()
const {
1244 return TargetObjectWriter->hasRelocationAddend();
1247void ELFObjectWriter::executePostLayoutBinding(
MCAssembler &Asm,
1253 const auto &
Symbol = cast<MCSymbolELF>(*S.
Sym);
1254 size_t Pos = AliasName.
find(
'@');
1264 cast<MCSymbolELF>(
Asm.getContext().getOrCreateSymbol(Prefix +
Tail));
1265 Asm.registerSymbol(*Alias);
1267 Alias->setVariableValue(
Value);
1271 Alias->setBinding(
Symbol.getBinding());
1272 Alias->setVisibility(
Symbol.getVisibility());
1273 Alias->setOther(
Symbol.getOther());
1280 Asm.getContext().reportError(S.
Loc,
"default version symbol " +
1281 AliasName +
" must be defined");
1285 if (Renames.count(&Symbol) && Renames[&Symbol] != Alias) {
1286 Asm.getContext().reportError(S.
Loc,
Twine(
"multiple versions for ") +
1291 Renames.insert(std::make_pair(&Symbol, Alias));
1295 if (
const MCSymbol *R = Renames.lookup(cast<MCSymbolELF>(
Sym)))
1297 if (
Sym->isInSection() &&
Sym->getName().starts_with(
".L"))
1298 Sym =
Sym->getSection().getBeginSymbol();
1299 Sym->setUsedInReloc();
1306bool ELFObjectWriter::shouldRelocateWithSymbol(
const MCAssembler &Asm,
1310 unsigned Type)
const {
1347 if (
Sym->isUndefined())
1356 if (
Sym->isMemtag())
1359 unsigned Binding =
Sym->getBinding();
1390 if (
Sym->isInSection()) {
1391 auto &Sec = cast<MCSectionELF>(
Sym->getSection());
1399 if (TargetObjectWriter->getEMachine() ==
ELF::EM_386 &&
1400 Type == ELF::R_386_GOTOFF)
1410 if (TargetObjectWriter->getEMachine() ==
ELF::EM_MIPS &&
1411 !hasRelocationAddend())
1427 if (
Asm.isThumbFunc(
Sym))
1430 if (TargetObjectWriter->needsRelocateWithSymbol(Val, *
Sym,
Type))
1435void ELFObjectWriter::recordRelocation(
MCAssembler &Asm,
1449 const auto &SymB = cast<MCSymbolELF>(RefB->getSymbol());
1450 if (SymB.isUndefined()) {
1452 Twine(
"symbol '") + SymB.getName() +
1453 "' can not be undefined in a subtraction expression");
1457 assert(!SymB.isAbsolute() &&
"Should have been folded");
1458 const MCSection &SecB = SymB.getSection();
1459 if (&SecB != &FixupSection) {
1461 "Cannot represent a difference across sections");
1465 assert(!IsPCRel &&
"should have been folded");
1472 const auto *SymA = RefA ? cast<MCSymbolELF>(&RefA->
getSymbol()) : nullptr;
1474 bool ViaWeakRef =
false;
1475 if (SymA && SymA->isVariable()) {
1476 const MCExpr *Expr = SymA->getVariableValue();
1477 if (
const auto *Inner = dyn_cast<MCSymbolRefExpr>(Expr)) {
1479 SymA = cast<MCSymbolELF>(&Inner->getSymbol());
1485 const MCSectionELF *SecA = (SymA && SymA->isInSection())
1486 ? cast<MCSectionELF>(&SymA->getSection())
1488 if (!checkRelocation(Ctx,
Fixup.getLoc(), &FixupSection, SecA))
1491 unsigned Type = TargetObjectWriter->getRelocType(Ctx,
Target,
Fixup, IsPCRel);
1492 const auto *Parent = cast<MCSectionELF>(Fragment->
getParent());
1494 bool RelocateWithSymbol =
1495 shouldRelocateWithSymbol(Asm,
Target, SymA,
C,
Type) ||
1499 FixedValue = !RelocateWithSymbol && SymA && !SymA->isUndefined()
1502 if (hasRelocationAddend()) {
1503 Addend = FixedValue;
1507 if (!RelocateWithSymbol) {
1508 const auto *SectionSymbol =
1511 SectionSymbol->setUsedInReloc();
1513 Relocations[&FixupSection].push_back(Rec);
1528 Relocations[&FixupSection].push_back(Rec);
1531bool ELFObjectWriter::isSymbolRefDifferenceFullyResolvedImpl(
1533 bool InSet,
bool IsPCRel)
const {
1534 const auto &SymA = cast<MCSymbolELF>(SA);
1545std::unique_ptr<MCObjectWriter>
1548 return std::make_unique<ELFSingleObjectWriter>(std::move(MOTW),
OS,
1552std::unique_ptr<MCObjectWriter>
1555 bool IsLittleEndian) {
1556 return std::make_unique<ELFDwoObjectWriter>(std::move(MOTW),
OS, DwoOS,
#define offsetof(TYPE, MEMBER)
BlockVerifier::State From
Analysis containing CSE Info
Given that RA is a live value
This file defines the DenseMap class.
static uint8_t mergeTypeForSet(uint8_t origType, uint8_t newType)
static bool isIFunc(const MCSymbolELF *Symbol)
std::optional< std::vector< StOtherPiece > > Other
PowerPC TLS Dynamic Call Fixup
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines the SmallVector class.
static SymbolRef::Type getType(const Symbol *Sym)
static bool isInSymtab(const MCSymbolWasm &Sym)
static bool isDwoSection(const MCSection &Sec)
static bool is64Bit(const char *name)
static const X86InstrFMA3Group Groups[]
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
bool empty() const
empty - Check if the array is empty.
Generic interface to target specific assembler backends.
virtual const MCFixupKindInfo & getFixupKindInfo(MCFixupKind Kind) const
Get information on a fixup kind.
Encapsulates the layout of an assembly file at a particular point in time.
const MCSymbol * getBaseSymbol(const MCSymbol &Symbol) const
If this symbol is equivalent to A + Constant, return A.
uint64_t getSectionAddressSize(const MCSection *Sec) const
Get the address space size of the given section, as it effects layout.
bool getSymbolOffset(const MCSymbol &S, uint64_t &Val) const
Get the offset of the given symbol, as computed in the current layout.
uint64_t getFragmentOffset(const MCFragment *F) const
Get the offset of the given fragment inside its containing section.
MCAssembler & getAssembler() const
Get the assembler object this is a layout for.
bool isThumbFunc(const MCSymbol *Func) const
Check whether a given symbol has been flagged with .thumb_func.
Context object for machine code objects.
MCSectionELF * createELFRelSection(const Twine &Name, unsigned Type, unsigned Flags, unsigned EntrySize, const MCSymbolELF *Group, const MCSectionELF *RelInfoSection)
MCSectionELF * getELFSection(const Twine &Section, unsigned Type, unsigned Flags)
void reportError(SMLoc L, const Twine &Msg)
const MCTargetOptions * getTargetOptions() const
MCSectionELF * createELFGroupSection(const MCSymbolELF *Group, bool IsComdat)
Base class for the full range of assembler expressions which are needed for parsing.
bool evaluateKnownAbsolute(int64_t &Res, const MCAsmLayout &Layout) const
Encode information on a single operation to perform on a byte sequence (e.g., an encoded instruction)...
MCSection * getParent() const
Defines the object file and target independent interfaces used by the assembler backend to write nati...
virtual void executePostLayoutBinding(MCAssembler &Asm, const MCAsmLayout &Layout)=0
Perform any late binding of symbols (for example, to assign symbol indices for use when generating re...
virtual void reset()
lifetime management
virtual void markGnuAbi()
ELF only. Mark that we have seen GNU ABI usage (e.g. SHF_GNU_RETAIN).
virtual bool isSymbolRefDifferenceFullyResolvedImpl(const MCAssembler &Asm, const MCSymbol &A, const MCSymbol &B, bool InSet) const
virtual void setOverrideABIVersion(uint8_t ABIVersion)
ELF only, override the default ABIVersion in the ELF header.
virtual void recordRelocation(MCAssembler &Asm, const MCAsmLayout &Layout, const MCFragment *Fragment, const MCFixup &Fixup, MCValue Target, uint64_t &FixedValue)=0
Record a relocation entry.
This represents a section on linux, lots of unix variants and some bare metal systems.
const MCSection * getLinkedToSection() const
unsigned getFlags() const
const MCSymbolELF * getGroup() const
Instances of this class represent a uniqued identifier for a section in the current translation unit.
void setAlignment(Align Value)
StringRef getName() const
MCSymbol * getBeginSymbol()
void setIsWeakrefUsedInReloc() const
Represent a reference to a symbol from inside an expression.
const MCSymbol & getSymbol() const
static const MCSymbolRefExpr * create(const MCSymbol *Symbol, MCContext &Ctx)
VariantKind getKind() const
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
void setUsedInReloc() const
DebugCompressionType CompressDebugSections
This represents an "assembler immediate".
const MCSymbolRefExpr * getSymA() const
MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memo...
Represents a location in source code.
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
pointer data()
Return a pointer to the vector's buffer, even if empty().
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
StringRef - Represent a constant reference to a string, i.e.
constexpr StringRef substr(size_t Start, size_t N=npos) const
Return a reference to the substring from [Start, Start + N).
bool starts_with(StringRef Prefix) const
Check if this string starts with the given Prefix.
size_t find(char C, size_t From=0) const
Search for the first character C in the string.
bool ends_with(StringRef Suffix) const
Check if this string ends with the given Suffix.
static constexpr size_t npos
Utility for building string tables with deduplicated suffixes.
Target - Wrapper for Target specific information.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
The instances of the Type class are immutable: once they are created, they are never changed.
LLVM Value Representation.
An abstract base class for streams implementations that also support a pwrite operation.
A raw_ostream that writes to an SmallVector or SmallString.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ Tail
Attemps to make calls as fast as possible while guaranteeing that tail call optimization can always b...
@ C
The default llvm calling convention, compatible with C.
static const char ElfMagic[]
@ SHT_LLVM_CALL_GRAPH_PROFILE
void compress(Params P, ArrayRef< uint8_t > Input, SmallVectorImpl< uint8_t > &Output)
StringRef toStringRef(const std::optional< DWARFFormValue > &V, StringRef Default={})
Take an optional DWARFFormValue and try to extract a string value from it.
This is an optimization pass for GlobalISel generic memory operations.
auto size(R &&Range, std::enable_if_t< std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< decltype(Range.begin())>::iterator_category >::value, void > *=nullptr)
Get the size of a range.
std::unique_ptr< MCObjectWriter > createELFObjectWriter(std::unique_ptr< MCELFObjectTargetWriter > MOTW, raw_pwrite_stream &OS, bool IsLittleEndian)
Construct a new ELF writer instance.
auto enumerate(FirstRange &&First, RestRanges &&...Rest)
Given two or more input ranges, returns a new range whose values are are tuples (A,...
std::unique_ptr< MCObjectWriter > createELFDwoObjectWriter(std::unique_ptr< MCELFObjectTargetWriter > MOTW, raw_pwrite_stream &OS, raw_pwrite_stream &DwoOS, bool IsLittleEndian)
Error write(MCStreamer &Out, ArrayRef< std::string > Inputs, OnCuIndexOverflow OverflowOptValue)
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
@ Ref
The access may reference the value stored in memory.
uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
unsigned encodeULEB128(uint64_t Value, raw_ostream &OS, unsigned PadTo=0)
Utility function to encode a ULEB128 value to an output stream.
This struct is a compact representation of a valid (non-zero power of two) alignment.
uint64_t value() const
This is a hole in the type system and should not be abused.
void setSymbolAndType(Elf32_Word s, unsigned char t)
void setSymbolAndType(Elf64_Word s, Elf64_Word t)
@ FKF_IsPCRel
Is this fixup kind PCrelative? This is used by the assembler backend to evaluate fixup values in a ta...
unsigned Flags
Flags describing additional information on this fixup kind.
This struct is a compact representation of a valid (power of two) or undefined (0) alignment.
Adapter to write values to a stream in a particular byte order.