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;
153 bool IsLittleEndian, DwoMode Mode)
165 template <
typename T>
void write(
T Val) {
171 void writeSymbol(SymbolTableWriter &Writer,
uint32_t StringIndex,
175 using SectionOffsetsTy =
176 std::map<const MCSectionELF *, std::pair<uint64_t, uint64_t>>;
187 const SectionIndexMapTy &SectionIndexMap,
188 const RevGroupMapTy &RevGroupMap,
189 SectionOffsetsTy &SectionOffsets);
191 void writeAddrsigSection();
199 const SectionIndexMapTy &SectionIndexMap,
200 const SectionOffsetsTy &SectionOffsets);
213 void writeSection(
const SectionIndexMapTy &SectionIndexMap,
220 std::unique_ptr<MCELFObjectTargetWriter> TargetObjectWriter;
226 bool SeenGnuAbi =
false;
228 std::optional<uint8_t> OverrideABIVersion;
230 bool hasRelocationAddend()
const;
234 unsigned Type)
const;
237 ELFObjectWriter(std::unique_ptr<MCELFObjectTargetWriter> MOTW)
238 : TargetObjectWriter(std::move(MOTW)) {}
240 void reset()
override {
242 OverrideABIVersion.reset();
251 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();
398void ELFWriter::writeHeader(
const MCAssembler &Asm) {
417 uint8_t OSABI = OWriter.TargetObjectWriter->getOSABI();
422 W.OS <<
char(OWriter.seenOverrideABIVersion()
423 ? OWriter.getOverrideABIVersion()
424 : OWriter.TargetObjectWriter->getABIVersion());
430 W.write<
uint16_t>(OWriter.TargetObjectWriter->getEMachine());
462 return Sym.getCommonAlignment()->value();
475 uint8_t
Type = newType;
512 if (!Symbol->isVariable() ||
513 !(
Value = dyn_cast<MCSymbolRefExpr>(Symbol->getVariableValue())) ||
517 Symbol = &cast<MCSymbolELF>(
Value->getSymbol());
522void ELFWriter::writeSymbol(SymbolTableWriter &Writer,
uint32_t StringIndex,
524 const auto &
Symbol = cast<MCSymbolELF>(*MSD.Symbol);
533 uint8_t Binding =
Symbol.getBinding();
540 uint8_t
Info = (Binding << 4) |
Type;
544 uint8_t Visibility =
Symbol.getVisibility();
550 const MCExpr *ESize = MSD.Symbol->getSize();
551 if (!ESize &&
Base) {
553 ESize =
Base->getSize();
560 while (
Sym->isVariable()) {
562 dyn_cast<MCSymbolRefExpr>(
Sym->getVariableValue(
false))) {
563 Sym = cast<MCSymbolELF>(&Expr->getSymbol());
566 ESize =
Sym->getSize();
580 Writer.writeSymbol(StringIndex, Info,
Value,
Size,
Other, MSD.SectionIndex,
585 bool Used,
bool Renamed) {
586 if (
Symbol.isVariable()) {
589 if (
const auto *
T = dyn_cast<MCTargetExpr>(Expr))
590 if (
T->inlineAssignedExpr())
619void ELFWriter::createMemtagRelocs(
MCAssembler &Asm) {
622 const auto &SymE = cast<MCSymbolELF>(
Sym);
623 if (!SymE.isMemtag())
625 if (MemtagRelocs ==
nullptr) {
626 MemtagRelocs = OWriter.TargetObjectWriter->getMemtagRelocsSection(
Asm.getContext());
627 if (MemtagRelocs ==
nullptr)
629 Asm.registerSection(*MemtagRelocs);
632 OWriter.Relocations[MemtagRelocs].push_back(Rec);
636void ELFWriter::computeSymbolTable(
638 const SectionIndexMapTy &SectionIndexMap,
const RevGroupMapTy &RevGroupMap,
639 SectionOffsetsTy &SectionOffsets) {
641 SymbolTableWriter Writer(*
this,
is64Bit());
648 SymbolTableIndex = addToSectionTable(SymtabSection);
653 Writer.writeSymbol(0, 0, 0, 0, 0, 0,
false);
655 std::vector<ELFSymbolData> LocalSymbolData;
656 std::vector<ELFSymbolData> ExternalSymbolData;
659 for (
const std::pair<std::string, size_t> &
F : FileNames)
660 StrTabBuilder.add(
F.first);
663 bool HasLargeSectionIndex =
false;
665 const auto &
Symbol = cast<MCSymbolELF>(It.value());
667 bool WeakrefUsed =
Symbol.isWeakrefUsedInReloc();
668 bool isSignature =
Symbol.isSignature();
670 if (!
isInSymtab(Layout, Symbol, Used || WeakrefUsed || isSignature,
671 OWriter.Renames.count(&Symbol)))
680 MSD.Symbol = cast<MCSymbolELF>(&Symbol);
681 MSD.Order = It.index();
686 if (
Symbol.isAbsolute()) {
688 }
else if (
Symbol.isCommon()) {
689 if (
Symbol.isTargetCommon()) {
690 MSD.SectionIndex =
Symbol.getIndex();
695 }
else if (
Symbol.isUndefined()) {
696 if (isSignature && !Used) {
697 MSD.SectionIndex = RevGroupMap.lookup(&Symbol);
699 HasLargeSectionIndex =
true;
716 "Undefined section reference: " +
Symbol.getName());
722 MSD.SectionIndex = SectionIndexMap.lookup(&Section);
723 assert(MSD.SectionIndex &&
"Invalid section index!");
725 HasLargeSectionIndex =
true;
733 StrTabBuilder.add(
Name);
737 LocalSymbolData.push_back(MSD);
739 ExternalSymbolData.push_back(MSD);
743 unsigned SymtabShndxSectionIndex = 0;
745 if (HasLargeSectionIndex) {
748 SymtabShndxSectionIndex = addToSectionTable(SymtabShndxSection);
752 StrTabBuilder.finalize();
756 auto FileNameIt = FileNames.begin();
757 if (!FileNames.empty())
758 FileNames[0].second = 0;
760 for (ELFSymbolData &MSD : LocalSymbolData) {
762 for (; FileNameIt != FileNames.end() && FileNameIt->second <= MSD.Order;
764 Writer.writeSymbol(StrTabBuilder.getOffset(FileNameIt->first),
772 : StrTabBuilder.getOffset(MSD.Name);
773 MSD.Symbol->setIndex(
Index++);
774 writeSymbol(Writer, StringIndex, MSD, Layout);
776 for (; FileNameIt != FileNames.end(); ++FileNameIt) {
777 Writer.writeSymbol(StrTabBuilder.getOffset(FileNameIt->first),
784 LastLocalSymbolIndex =
Index;
786 for (ELFSymbolData &MSD : ExternalSymbolData) {
787 unsigned StringIndex = StrTabBuilder.getOffset(MSD.Name);
788 MSD.Symbol->setIndex(
Index++);
789 writeSymbol(Writer, StringIndex, MSD, Layout);
794 SectionOffsets[SymtabSection] = std::make_pair(SecStart, SecEnd);
797 if (ShndxIndexes.
empty()) {
798 assert(SymtabShndxSectionIndex == 0);
801 assert(SymtabShndxSectionIndex != 0);
803 SecStart =
W.OS.tell();
805 SectionTable[SymtabShndxSectionIndex - 1];
808 SecEnd =
W.OS.tell();
809 SectionOffsets[SymtabShndxSection] = std::make_pair(SecStart, SecEnd);
812void ELFWriter::writeAddrsigSection() {
814 if (
Sym->getIndex() != 0)
820 if (OWriter.Relocations[&Sec].empty())
828 const bool Rela = OWriter.usesRela(Sec);
844bool ELFWriter::maybeWriteCompression(
849 if (
Size <= HdrSize + CompressedContents.
size())
871 auto &Ctx =
Asm.getContext();
874 : DebugCompressionType::None;
875 if (CompressionType == DebugCompressionType::None ||
877 Asm.writeSectionData(
W.OS, &Section, Layout);
883 Asm.writeSectionData(VecOS, &Section, Layout);
885 ArrayRef(
reinterpret_cast<uint8_t *
>(UncompressedData.
data()),
886 UncompressedData.
size());
890 switch (CompressionType) {
891 case DebugCompressionType::None:
893 case DebugCompressionType::Zlib:
896 case DebugCompressionType::Zstd:
902 if (!maybeWriteCompression(ChType, UncompressedData.
size(), Compressed,
904 W.OS << UncompressedData;
927 WriteWord(Alignment ? Alignment->value() : 0);
928 WriteWord(EntrySize);
931void ELFWriter::writeRelocations(
const MCAssembler &Asm,
933 std::vector<ELFRelocationEntry> &Relocs = OWriter.Relocations[&Sec];
934 const bool Rela = OWriter.usesRela(Sec);
937 OWriter.TargetObjectWriter->sortRelocs(Asm, Relocs);
939 if (OWriter.TargetObjectWriter->getEMachine() ==
ELF::EM_MIPS) {
941 uint32_t Symidx = Entry.Symbol ? Entry.Symbol->getIndex() : 0;
945 write(OWriter.TargetObjectWriter->getRSsym(Entry.Type));
946 write(OWriter.TargetObjectWriter->getRType3(Entry.Type));
947 write(OWriter.TargetObjectWriter->getRType2(Entry.Type));
948 write(OWriter.TargetObjectWriter->getRType(Entry.Type));
959 OWriter.TargetObjectWriter->getRType2(Entry.Type)) {
966 OWriter.TargetObjectWriter->getRType3(Entry.Type)) {
977 uint32_t Symidx = Entry.Symbol ? Entry.Symbol->getIndex() : 0;
996void ELFWriter::writeSection(
const SectionIndexMapTy &SectionIndexMap,
1012 sh_link = SymbolTableIndex;
1013 assert(sh_link &&
".symtab not found");
1015 sh_info = SectionIndexMap.lookup(cast<MCSectionELF>(InfoSection));
1020 sh_link = StringTableIndex;
1021 sh_info = LastLocalSymbolIndex;
1027 sh_link = SymbolTableIndex;
1031 sh_link = SymbolTableIndex;
1032 sh_info = GroupSymbolIndex;
1040 if (
Sym &&
Sym->isInSection()) {
1042 sh_link = SectionIndexMap.lookup(Sec);
1046 WriteSecHdrEntry(StrTabBuilder.getOffset(
Section.getName()),
1048 sh_link, sh_info,
Section.getAlign(),
1052void ELFWriter::writeSectionHeader(
1053 const MCAsmLayout &Layout,
const SectionIndexMapTy &SectionIndexMap,
1054 const SectionOffsetsTy &SectionOffsets) {
1055 const unsigned NumSections = SectionTable.size();
1060 WriteSecHdrEntry(0, 0, 0, 0, 0, FirstSectionSize, 0, 0, std::nullopt, 0);
1066 GroupSymbolIndex = 0;
1068 GroupSymbolIndex =
Section->getGroup()->getIndex();
1070 const std::pair<uint64_t, uint64_t> &
Offsets =
1071 SectionOffsets.find(Section)->second;
1078 writeSection(SectionIndexMap, GroupSymbolIndex,
Offsets.first,
Size,
1089 StringTableIndex = addToSectionTable(StrtabSection);
1091 createMemtagRelocs(Asm);
1093 RevGroupMapTy RevGroupMap;
1094 SectionIndexMapTy SectionIndexMap;
1096 std::map<const MCSymbol *, std::vector<const MCSectionELF *>> GroupMembers;
1102 SectionOffsetsTy SectionOffsets;
1103 std::vector<MCSectionELF *>
Groups;
1104 std::vector<MCSectionELF *> Relocations;
1116 writeSectionData(Asm, Section, Layout);
1119 SectionOffsets[&
Section] = std::make_pair(SecStart, SecEnd);
1121 MCSectionELF *RelSection = createRelocationSection(Ctx, Section);
1123 if (SignatureSymbol) {
1124 unsigned &GroupIdx = RevGroupMap[SignatureSymbol];
1128 GroupIdx = addToSectionTable(Group);
1132 std::vector<const MCSectionELF *> &Members =
1133 GroupMembers[SignatureSymbol];
1134 Members.push_back(&Section);
1136 Members.push_back(RelSection);
1139 SectionIndexMap[&
Section] = addToSectionTable(&Section);
1141 SectionIndexMap[RelSection] = addToSectionTable(RelSection);
1142 Relocations.push_back(RelSection);
1145 OWriter.TargetObjectWriter->addTargetSectionFlags(Ctx, Section);
1155 for (
const MCSectionELF *Member : GroupMembers[SignatureSymbol]) {
1156 uint32_t SecIndex = SectionIndexMap.lookup(Member);
1161 SectionOffsets[Group] = std::make_pair(SecStart, SecEnd);
1164 if (Mode == DwoOnly) {
1167 StrTabBuilder.finalize();
1170 if (OWriter.EmitAddrsigSection) {
1173 addToSectionTable(AddrsigSection);
1177 computeSymbolTable(Asm, Layout, SectionIndexMap, RevGroupMap,
1184 writeRelocations(Asm,
1188 SectionOffsets[RelSection] = std::make_pair(SecStart, SecEnd);
1191 if (OWriter.EmitAddrsigSection) {
1193 writeAddrsigSection();
1195 SectionOffsets[AddrsigSection] = std::make_pair(SecStart, SecEnd);
1201 StrTabBuilder.write(
W.OS);
1202 SectionOffsets[StrtabSection] = std::make_pair(SecStart,
W.OS.tell());
1208 writeSectionHeader(Layout, SectionIndexMap, SectionOffsets);
1210 uint16_t NumSections = support::endian::byte_swap<uint16_t>(
1212 : SectionTable.size() + 1,
1214 unsigned NumSectionsOffset;
1219 support::endian::byte_swap<uint64_t>(SectionHeaderOffset,
W.Endian);
1220 Stream.pwrite(
reinterpret_cast<char *
>(&Val),
sizeof(Val),
1225 support::endian::byte_swap<uint32_t>(SectionHeaderOffset,
W.Endian);
1226 Stream.pwrite(
reinterpret_cast<char *
>(&Val),
sizeof(Val),
1230 Stream.pwrite(
reinterpret_cast<char *
>(&NumSections),
sizeof(NumSections),
1233 return W.OS.tell() - StartOffset;
1236bool ELFObjectWriter::hasRelocationAddend()
const {
1237 return TargetObjectWriter->hasRelocationAddend();
1240void ELFObjectWriter::executePostLayoutBinding(
MCAssembler &Asm,
1246 const auto &
Symbol = cast<MCSymbolELF>(*S.
Sym);
1247 size_t Pos = AliasName.
find(
'@');
1257 cast<MCSymbolELF>(
Asm.getContext().getOrCreateSymbol(Prefix +
Tail));
1258 Asm.registerSymbol(*Alias);
1260 Alias->setVariableValue(
Value);
1264 Alias->setBinding(
Symbol.getBinding());
1265 Alias->setVisibility(
Symbol.getVisibility());
1266 Alias->setOther(
Symbol.getOther());
1273 Asm.getContext().reportError(S.
Loc,
"default version symbol " +
1274 AliasName +
" must be defined");
1278 if (Renames.count(&Symbol) && Renames[&Symbol] != Alias) {
1279 Asm.getContext().reportError(S.
Loc,
Twine(
"multiple versions for ") +
1284 Renames.insert(std::make_pair(&Symbol, Alias));
1288 if (
const MCSymbol *R = Renames.lookup(cast<MCSymbolELF>(
Sym)))
1290 if (
Sym->isInSection() &&
Sym->getName().starts_with(
".L"))
1291 Sym =
Sym->getSection().getBeginSymbol();
1292 Sym->setUsedInReloc();
1299bool ELFObjectWriter::shouldRelocateWithSymbol(
const MCAssembler &Asm,
1303 unsigned Type)
const {
1340 if (
Sym->isUndefined())
1349 if (
Sym->isMemtag())
1352 unsigned Binding =
Sym->getBinding();
1383 if (
Sym->isInSection()) {
1384 auto &Sec = cast<MCSectionELF>(
Sym->getSection());
1392 if (TargetObjectWriter->getEMachine() ==
ELF::EM_386 &&
1393 Type == ELF::R_386_GOTOFF)
1403 if (TargetObjectWriter->getEMachine() ==
ELF::EM_MIPS &&
1404 !hasRelocationAddend())
1420 if (
Asm.isThumbFunc(
Sym))
1423 if (TargetObjectWriter->needsRelocateWithSymbol(Val, *
Sym,
Type))
1428void ELFObjectWriter::recordRelocation(
MCAssembler &Asm,
1442 const auto &SymB = cast<MCSymbolELF>(RefB->getSymbol());
1443 if (SymB.isUndefined()) {
1445 Twine(
"symbol '") + SymB.getName() +
1446 "' can not be undefined in a subtraction expression");
1450 assert(!SymB.isAbsolute() &&
"Should have been folded");
1451 const MCSection &SecB = SymB.getSection();
1452 if (&SecB != &FixupSection) {
1454 "Cannot represent a difference across sections");
1458 assert(!IsPCRel &&
"should have been folded");
1465 const auto *SymA = RefA ? cast<MCSymbolELF>(&RefA->
getSymbol()) : nullptr;
1467 bool ViaWeakRef =
false;
1468 if (SymA && SymA->isVariable()) {
1469 const MCExpr *Expr = SymA->getVariableValue();
1470 if (
const auto *Inner = dyn_cast<MCSymbolRefExpr>(Expr)) {
1472 SymA = cast<MCSymbolELF>(&Inner->getSymbol());
1478 const MCSectionELF *SecA = (SymA && SymA->isInSection())
1479 ? cast<MCSectionELF>(&SymA->getSection())
1481 if (!checkRelocation(Ctx,
Fixup.getLoc(), &FixupSection, SecA))
1484 unsigned Type = TargetObjectWriter->getRelocType(Ctx,
Target,
Fixup, IsPCRel);
1485 const auto *Parent = cast<MCSectionELF>(Fragment->
getParent());
1487 bool RelocateWithSymbol =
1488 shouldRelocateWithSymbol(Asm,
Target, SymA,
C,
Type) ||
1492 FixedValue = !RelocateWithSymbol && SymA && !SymA->isUndefined()
1495 if (usesRela(FixupSection)) {
1496 Addend = FixedValue;
1500 if (!RelocateWithSymbol) {
1501 const auto *SectionSymbol =
1504 SectionSymbol->setUsedInReloc();
1506 Relocations[&FixupSection].push_back(Rec);
1521 Relocations[&FixupSection].push_back(Rec);
1524bool ELFObjectWriter::usesRela(
const MCSectionELF &Sec)
const {
1525 return hasRelocationAddend() &&
1529bool ELFObjectWriter::isSymbolRefDifferenceFullyResolvedImpl(
1531 bool InSet,
bool IsPCRel)
const {
1532 const auto &SymA = cast<MCSymbolELF>(SA);
1543std::unique_ptr<MCObjectWriter>
1546 return std::make_unique<ELFSingleObjectWriter>(std::move(MOTW),
OS,
1550std::unique_ptr<MCObjectWriter>
1553 bool IsLittleEndian) {
1554 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.