1 //===- lib/MC/ELFObjectWriter.cpp - ELF File Writer -----------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements ELF object file writer information.
12 //===----------------------------------------------------------------------===//
14 #include "llvm/ADT/ArrayRef.h"
15 #include "llvm/ADT/DenseMap.h"
16 #include "llvm/ADT/STLExtras.h"
17 #include "llvm/ADT/SmallString.h"
18 #include "llvm/ADT/SmallVector.h"
19 #include "llvm/ADT/StringRef.h"
20 #include "llvm/ADT/Twine.h"
21 #include "llvm/BinaryFormat/ELF.h"
22 #include "llvm/MC/MCAsmBackend.h"
23 #include "llvm/MC/MCAsmInfo.h"
24 #include "llvm/MC/MCAsmLayout.h"
25 #include "llvm/MC/MCAssembler.h"
26 #include "llvm/MC/MCContext.h"
27 #include "llvm/MC/MCELFObjectWriter.h"
28 #include "llvm/MC/MCExpr.h"
29 #include "llvm/MC/MCFixup.h"
30 #include "llvm/MC/MCFixupKindInfo.h"
31 #include "llvm/MC/MCFragment.h"
32 #include "llvm/MC/MCObjectWriter.h"
33 #include "llvm/MC/MCSection.h"
34 #include "llvm/MC/MCSectionELF.h"
35 #include "llvm/MC/MCSymbol.h"
36 #include "llvm/MC/MCSymbolELF.h"
37 #include "llvm/MC/MCValue.h"
38 #include "llvm/MC/StringTableBuilder.h"
39 #include "llvm/Support/Allocator.h"
40 #include "llvm/Support/Casting.h"
41 #include "llvm/Support/Compression.h"
42 #include "llvm/Support/Endian.h"
43 #include "llvm/Support/Error.h"
44 #include "llvm/Support/ErrorHandling.h"
45 #include "llvm/Support/Host.h"
46 #include "llvm/Support/LEB128.h"
47 #include "llvm/Support/MathExtras.h"
48 #include "llvm/Support/SMLoc.h"
49 #include "llvm/Support/StringSaver.h"
50 #include "llvm/Support/SwapByteOrder.h"
51 #include "llvm/Support/raw_ostream.h"
65 #define DEBUG_TYPE "reloc-info"
69 using SectionIndexMapTy = DenseMap<const MCSectionELF *, uint32_t>;
71 class ELFObjectWriter;
74 bool isDwoSection(const MCSectionELF &Sec) {
75 return Sec.getSectionName().endswith(".dwo");
78 class SymbolTableWriter {
82 // indexes we are going to write to .symtab_shndx.
83 std::vector<uint32_t> ShndxIndexes;
85 // The numbel of symbols written so far.
88 void createSymtabShndx();
90 template <typename T> void write(T Value);
93 SymbolTableWriter(ELFWriter &EWriter, bool Is64Bit);
95 void writeSymbol(uint32_t name, uint8_t info, uint64_t value, uint64_t size,
96 uint8_t other, uint32_t shndx, bool Reserved);
98 ArrayRef<uint32_t> getShndxIndexes() const { return ShndxIndexes; }
102 ELFObjectWriter &OWriter;
103 support::endian::Writer W;
111 static uint64_t SymbolValue(const MCSymbol &Sym, const MCAsmLayout &Layout);
112 static bool isInSymtab(const MCAsmLayout &Layout, const MCSymbolELF &Symbol,
113 bool Used, bool Renamed);
115 /// Helper struct for containing some precomputed information on symbols.
116 struct ELFSymbolData {
117 const MCSymbolELF *Symbol;
118 uint32_t SectionIndex;
121 // Support lexicographic sorting.
122 bool operator<(const ELFSymbolData &RHS) const {
123 unsigned LHSType = Symbol->getType();
124 unsigned RHSType = RHS.Symbol->getType();
125 if (LHSType == ELF::STT_SECTION && RHSType != ELF::STT_SECTION)
127 if (LHSType != ELF::STT_SECTION && RHSType == ELF::STT_SECTION)
129 if (LHSType == ELF::STT_SECTION && RHSType == ELF::STT_SECTION)
130 return SectionIndex < RHS.SectionIndex;
131 return Name < RHS.Name;
136 /// @name Symbol Table Data
139 StringTableBuilder StrTabBuilder{StringTableBuilder::ELF};
143 // This holds the symbol table index of the last local symbol.
144 unsigned LastLocalSymbolIndex;
145 // This holds the .strtab section index.
146 unsigned StringTableIndex;
147 // This holds the .symtab section index.
148 unsigned SymbolTableIndex;
150 // Sections in the order they are to be output in the section table.
151 std::vector<const MCSectionELF *> SectionTable;
152 unsigned addToSectionTable(const MCSectionELF *Sec);
154 // TargetObjectWriter wrappers.
155 bool is64Bit() const;
156 bool hasRelocationAddend() const;
158 void align(unsigned Alignment);
160 bool maybeWriteCompression(uint64_t Size,
161 SmallVectorImpl<char> &CompressedContents,
162 bool ZLibStyle, unsigned Alignment);
165 ELFWriter(ELFObjectWriter &OWriter, raw_pwrite_stream &OS,
166 bool IsLittleEndian, DwoMode Mode)
168 W(OS, IsLittleEndian ? support::little : support::big), Mode(Mode) {}
170 void WriteWord(uint64_t Word) {
172 W.write<uint64_t>(Word);
174 W.write<uint32_t>(Word);
177 template <typename T> void write(T Val) {
181 void writeHeader(const MCAssembler &Asm);
183 void writeSymbol(SymbolTableWriter &Writer, uint32_t StringIndex,
184 ELFSymbolData &MSD, const MCAsmLayout &Layout);
186 // Start and end offset of each section
187 using SectionOffsetsTy =
188 std::map<const MCSectionELF *, std::pair<uint64_t, uint64_t>>;
190 // Map from a signature symbol to the group section index
191 using RevGroupMapTy = DenseMap<const MCSymbol *, unsigned>;
193 /// Compute the symbol table data
195 /// \param Asm - The assembler.
196 /// \param SectionIndexMap - Maps a section to its index.
197 /// \param RevGroupMap - Maps a signature symbol to the group section.
198 void computeSymbolTable(MCAssembler &Asm, const MCAsmLayout &Layout,
199 const SectionIndexMapTy &SectionIndexMap,
200 const RevGroupMapTy &RevGroupMap,
201 SectionOffsetsTy &SectionOffsets);
203 void writeAddrsigSection();
205 MCSectionELF *createRelocationSection(MCContext &Ctx,
206 const MCSectionELF &Sec);
208 const MCSectionELF *createStringTable(MCContext &Ctx);
210 void writeSectionHeader(const MCAsmLayout &Layout,
211 const SectionIndexMapTy &SectionIndexMap,
212 const SectionOffsetsTy &SectionOffsets);
214 void writeSectionData(const MCAssembler &Asm, MCSection &Sec,
215 const MCAsmLayout &Layout);
217 void WriteSecHdrEntry(uint32_t Name, uint32_t Type, uint64_t Flags,
218 uint64_t Address, uint64_t Offset, uint64_t Size,
219 uint32_t Link, uint32_t Info, uint64_t Alignment,
222 void writeRelocations(const MCAssembler &Asm, const MCSectionELF &Sec);
224 uint64_t writeObject(MCAssembler &Asm, const MCAsmLayout &Layout);
225 void writeSection(const SectionIndexMapTy &SectionIndexMap,
226 uint32_t GroupSymbolIndex, uint64_t Offset, uint64_t Size,
227 const MCSectionELF &Section);
230 class ELFObjectWriter : public MCObjectWriter {
231 /// The target specific ELF writer instance.
232 std::unique_ptr<MCELFObjectTargetWriter> TargetObjectWriter;
234 DenseMap<const MCSectionELF *, std::vector<ELFRelocationEntry>> Relocations;
236 DenseMap<const MCSymbolELF *, const MCSymbolELF *> Renames;
238 bool EmitAddrsigSection = false;
239 std::vector<const MCSymbol *> AddrsigSyms;
241 bool hasRelocationAddend() const;
243 bool shouldRelocateWithSymbol(const MCAssembler &Asm,
244 const MCSymbolRefExpr *RefA,
245 const MCSymbolELF *Sym, uint64_t C,
246 unsigned Type) const;
249 ELFObjectWriter(std::unique_ptr<MCELFObjectTargetWriter> MOTW)
250 : TargetObjectWriter(std::move(MOTW)) {}
252 void reset() override {
255 MCObjectWriter::reset();
258 bool isSymbolRefDifferenceFullyResolvedImpl(const MCAssembler &Asm,
259 const MCSymbol &SymA,
260 const MCFragment &FB, bool InSet,
261 bool IsPCRel) const override;
263 virtual bool checkRelocation(MCContext &Ctx, SMLoc Loc,
264 const MCSectionELF *From,
265 const MCSectionELF *To) {
269 void recordRelocation(MCAssembler &Asm, const MCAsmLayout &Layout,
270 const MCFragment *Fragment, const MCFixup &Fixup,
271 MCValue Target, uint64_t &FixedValue) override;
273 void executePostLayoutBinding(MCAssembler &Asm,
274 const MCAsmLayout &Layout) override;
276 void emitAddrsigSection() override { EmitAddrsigSection = true; }
277 void addAddrsigSymbol(const MCSymbol *Sym) override {
278 AddrsigSyms.push_back(Sym);
281 friend struct ELFWriter;
284 class ELFSingleObjectWriter : public ELFObjectWriter {
285 raw_pwrite_stream &OS;
289 ELFSingleObjectWriter(std::unique_ptr<MCELFObjectTargetWriter> MOTW,
290 raw_pwrite_stream &OS, bool IsLittleEndian)
291 : ELFObjectWriter(std::move(MOTW)), OS(OS),
292 IsLittleEndian(IsLittleEndian) {}
294 uint64_t writeObject(MCAssembler &Asm, const MCAsmLayout &Layout) override {
295 return ELFWriter(*this, OS, IsLittleEndian, ELFWriter::AllSections)
296 .writeObject(Asm, Layout);
299 friend struct ELFWriter;
302 class ELFDwoObjectWriter : public ELFObjectWriter {
303 raw_pwrite_stream &OS, &DwoOS;
307 ELFDwoObjectWriter(std::unique_ptr<MCELFObjectTargetWriter> MOTW,
308 raw_pwrite_stream &OS, raw_pwrite_stream &DwoOS,
310 : ELFObjectWriter(std::move(MOTW)), OS(OS), DwoOS(DwoOS),
311 IsLittleEndian(IsLittleEndian) {}
313 virtual bool checkRelocation(MCContext &Ctx, SMLoc Loc,
314 const MCSectionELF *From,
315 const MCSectionELF *To) override {
316 if (isDwoSection(*From)) {
317 Ctx.reportError(Loc, "A dwo section may not contain relocations");
320 if (To && isDwoSection(*To)) {
321 Ctx.reportError(Loc, "A relocation may not refer to a dwo section");
327 uint64_t writeObject(MCAssembler &Asm, const MCAsmLayout &Layout) override {
328 uint64_t Size = ELFWriter(*this, OS, IsLittleEndian, ELFWriter::NonDwoOnly)
329 .writeObject(Asm, Layout);
330 Size += ELFWriter(*this, DwoOS, IsLittleEndian, ELFWriter::DwoOnly)
331 .writeObject(Asm, Layout);
336 } // end anonymous namespace
338 void ELFWriter::align(unsigned Alignment) {
339 uint64_t Padding = OffsetToAlignment(W.OS.tell(), Alignment);
340 W.OS.write_zeros(Padding);
343 unsigned ELFWriter::addToSectionTable(const MCSectionELF *Sec) {
344 SectionTable.push_back(Sec);
345 StrTabBuilder.add(Sec->getSectionName());
346 return SectionTable.size();
349 void SymbolTableWriter::createSymtabShndx() {
350 if (!ShndxIndexes.empty())
353 ShndxIndexes.resize(NumWritten);
356 template <typename T> void SymbolTableWriter::write(T Value) {
357 EWriter.write(Value);
360 SymbolTableWriter::SymbolTableWriter(ELFWriter &EWriter, bool Is64Bit)
361 : EWriter(EWriter), Is64Bit(Is64Bit), NumWritten(0) {}
363 void SymbolTableWriter::writeSymbol(uint32_t name, uint8_t info, uint64_t value,
364 uint64_t size, uint8_t other,
365 uint32_t shndx, bool Reserved) {
366 bool LargeIndex = shndx >= ELF::SHN_LORESERVE && !Reserved;
371 if (!ShndxIndexes.empty()) {
373 ShndxIndexes.push_back(shndx);
375 ShndxIndexes.push_back(0);
378 uint16_t Index = LargeIndex ? uint16_t(ELF::SHN_XINDEX) : shndx;
381 write(name); // st_name
382 write(info); // st_info
383 write(other); // st_other
384 write(Index); // st_shndx
385 write(value); // st_value
386 write(size); // st_size
388 write(name); // st_name
389 write(uint32_t(value)); // st_value
390 write(uint32_t(size)); // st_size
391 write(info); // st_info
392 write(other); // st_other
393 write(Index); // st_shndx
399 bool ELFWriter::is64Bit() const {
400 return OWriter.TargetObjectWriter->is64Bit();
403 bool ELFWriter::hasRelocationAddend() const {
404 return OWriter.hasRelocationAddend();
407 // Emit the ELF header.
408 void ELFWriter::writeHeader(const MCAssembler &Asm) {
414 // emitWord method behaves differently for ELF32 and ELF64, writing
415 // 4 bytes in the former and 8 in the latter.
417 W.OS << ELF::ElfMagic; // e_ident[EI_MAG0] to e_ident[EI_MAG3]
419 W.OS << char(is64Bit() ? ELF::ELFCLASS64 : ELF::ELFCLASS32); // e_ident[EI_CLASS]
422 W.OS << char(W.Endian == support::little ? ELF::ELFDATA2LSB
425 W.OS << char(ELF::EV_CURRENT); // e_ident[EI_VERSION]
427 W.OS << char(OWriter.TargetObjectWriter->getOSABI());
428 W.OS << char(0); // e_ident[EI_ABIVERSION]
430 W.OS.write_zeros(ELF::EI_NIDENT - ELF::EI_PAD);
432 W.write<uint16_t>(ELF::ET_REL); // e_type
434 W.write<uint16_t>(OWriter.TargetObjectWriter->getEMachine()); // e_machine = target
436 W.write<uint32_t>(ELF::EV_CURRENT); // e_version
437 WriteWord(0); // e_entry, no entry point in .o file
438 WriteWord(0); // e_phoff, no program header for .o
439 WriteWord(0); // e_shoff = sec hdr table off in bytes
441 // e_flags = whatever the target wants
442 W.write<uint32_t>(Asm.getELFHeaderEFlags());
444 // e_ehsize = ELF header size
445 W.write<uint16_t>(is64Bit() ? sizeof(ELF::Elf64_Ehdr)
446 : sizeof(ELF::Elf32_Ehdr));
448 W.write<uint16_t>(0); // e_phentsize = prog header entry size
449 W.write<uint16_t>(0); // e_phnum = # prog header entries = 0
451 // e_shentsize = Section header entry size
452 W.write<uint16_t>(is64Bit() ? sizeof(ELF::Elf64_Shdr)
453 : sizeof(ELF::Elf32_Shdr));
455 // e_shnum = # of section header ents
456 W.write<uint16_t>(0);
458 // e_shstrndx = Section # of '.shstrtab'
459 assert(StringTableIndex < ELF::SHN_LORESERVE);
460 W.write<uint16_t>(StringTableIndex);
463 uint64_t ELFWriter::SymbolValue(const MCSymbol &Sym,
464 const MCAsmLayout &Layout) {
465 if (Sym.isCommon() && Sym.isExternal())
466 return Sym.getCommonAlignment();
469 if (!Layout.getSymbolOffset(Sym, Res))
472 if (Layout.getAssembler().isThumbFunc(&Sym))
478 static uint8_t mergeTypeForSet(uint8_t origType, uint8_t newType) {
479 uint8_t Type = newType;
481 // Propagation rules:
482 // IFUNC > FUNC > OBJECT > NOTYPE
483 // TLS_OBJECT > OBJECT > NOTYPE
485 // dont let the new type degrade the old type
489 case ELF::STT_GNU_IFUNC:
490 if (Type == ELF::STT_FUNC || Type == ELF::STT_OBJECT ||
491 Type == ELF::STT_NOTYPE || Type == ELF::STT_TLS)
492 Type = ELF::STT_GNU_IFUNC;
495 if (Type == ELF::STT_OBJECT || Type == ELF::STT_NOTYPE ||
496 Type == ELF::STT_TLS)
497 Type = ELF::STT_FUNC;
499 case ELF::STT_OBJECT:
500 if (Type == ELF::STT_NOTYPE)
501 Type = ELF::STT_OBJECT;
504 if (Type == ELF::STT_OBJECT || Type == ELF::STT_NOTYPE ||
505 Type == ELF::STT_GNU_IFUNC || Type == ELF::STT_FUNC)
513 void ELFWriter::writeSymbol(SymbolTableWriter &Writer, uint32_t StringIndex,
514 ELFSymbolData &MSD, const MCAsmLayout &Layout) {
515 const auto &Symbol = cast<MCSymbolELF>(*MSD.Symbol);
516 const MCSymbolELF *Base =
517 cast_or_null<MCSymbolELF>(Layout.getBaseSymbol(Symbol));
519 // This has to be in sync with when computeSymbolTable uses SHN_ABS or
521 bool IsReserved = !Base || Symbol.isCommon();
523 // Binding and Type share the same byte as upper and lower nibbles
524 uint8_t Binding = Symbol.getBinding();
525 uint8_t Type = Symbol.getType();
527 Type = mergeTypeForSet(Type, Base->getType());
529 uint8_t Info = (Binding << 4) | Type;
531 // Other and Visibility share the same byte with Visibility using the lower
533 uint8_t Visibility = Symbol.getVisibility();
534 uint8_t Other = Symbol.getOther() | Visibility;
536 uint64_t Value = SymbolValue(*MSD.Symbol, Layout);
539 const MCExpr *ESize = MSD.Symbol->getSize();
541 ESize = Base->getSize();
545 if (!ESize->evaluateKnownAbsolute(Res, Layout))
546 report_fatal_error("Size expression must be absolute.");
550 // Write out the symbol table entry
551 Writer.writeSymbol(StringIndex, Info, Value, Size, Other, MSD.SectionIndex,
555 // True if the assembler knows nothing about the final value of the symbol.
556 // This doesn't cover the comdat issues, since in those cases the assembler
557 // can at least know that all symbols in the section will move together.
558 static bool isWeak(const MCSymbolELF &Sym) {
559 if (Sym.getType() == ELF::STT_GNU_IFUNC)
562 switch (Sym.getBinding()) {
564 llvm_unreachable("Unknown binding");
567 case ELF::STB_GLOBAL:
570 case ELF::STB_GNU_UNIQUE:
575 bool ELFWriter::isInSymtab(const MCAsmLayout &Layout, const MCSymbolELF &Symbol,
576 bool Used, bool Renamed) {
577 if (Symbol.isVariable()) {
578 const MCExpr *Expr = Symbol.getVariableValue();
579 if (const MCSymbolRefExpr *Ref = dyn_cast<MCSymbolRefExpr>(Expr)) {
580 if (Ref->getKind() == MCSymbolRefExpr::VK_WEAKREF)
591 if (Symbol.isVariable() && Symbol.isUndefined()) {
592 // FIXME: this is here just to diagnose the case of a var = commmon_sym.
593 Layout.getBaseSymbol(Symbol);
597 if (Symbol.isUndefined() && !Symbol.isBindingSet())
600 if (Symbol.isTemporary())
603 if (Symbol.getType() == ELF::STT_SECTION)
609 void ELFWriter::computeSymbolTable(
610 MCAssembler &Asm, const MCAsmLayout &Layout,
611 const SectionIndexMapTy &SectionIndexMap, const RevGroupMapTy &RevGroupMap,
612 SectionOffsetsTy &SectionOffsets) {
613 MCContext &Ctx = Asm.getContext();
614 SymbolTableWriter Writer(*this, is64Bit());
617 unsigned EntrySize = is64Bit() ? ELF::SYMENTRY_SIZE64 : ELF::SYMENTRY_SIZE32;
618 MCSectionELF *SymtabSection =
619 Ctx.getELFSection(".symtab", ELF::SHT_SYMTAB, 0, EntrySize, "");
620 SymtabSection->setAlignment(is64Bit() ? 8 : 4);
621 SymbolTableIndex = addToSectionTable(SymtabSection);
623 align(SymtabSection->getAlignment());
624 uint64_t SecStart = W.OS.tell();
626 // The first entry is the undefined symbol entry.
627 Writer.writeSymbol(0, 0, 0, 0, 0, 0, false);
629 std::vector<ELFSymbolData> LocalSymbolData;
630 std::vector<ELFSymbolData> ExternalSymbolData;
632 // Add the data for the symbols.
633 bool HasLargeSectionIndex = false;
634 for (const MCSymbol &S : Asm.symbols()) {
635 const auto &Symbol = cast<MCSymbolELF>(S);
636 bool Used = Symbol.isUsedInReloc();
637 bool WeakrefUsed = Symbol.isWeakrefUsedInReloc();
638 bool isSignature = Symbol.isSignature();
640 if (!isInSymtab(Layout, Symbol, Used || WeakrefUsed || isSignature,
641 OWriter.Renames.count(&Symbol)))
644 if (Symbol.isTemporary() && Symbol.isUndefined()) {
645 Ctx.reportError(SMLoc(), "Undefined temporary symbol");
650 MSD.Symbol = cast<MCSymbolELF>(&Symbol);
652 bool Local = Symbol.getBinding() == ELF::STB_LOCAL;
653 assert(Local || !Symbol.isTemporary());
655 if (Symbol.isAbsolute()) {
656 MSD.SectionIndex = ELF::SHN_ABS;
657 } else if (Symbol.isCommon()) {
659 MSD.SectionIndex = ELF::SHN_COMMON;
660 } else if (Symbol.isUndefined()) {
661 if (isSignature && !Used) {
662 MSD.SectionIndex = RevGroupMap.lookup(&Symbol);
663 if (MSD.SectionIndex >= ELF::SHN_LORESERVE)
664 HasLargeSectionIndex = true;
666 MSD.SectionIndex = ELF::SHN_UNDEF;
669 const MCSectionELF &Section =
670 static_cast<const MCSectionELF &>(Symbol.getSection());
671 if (Mode == NonDwoOnly && isDwoSection(Section))
673 MSD.SectionIndex = SectionIndexMap.lookup(&Section);
674 assert(MSD.SectionIndex && "Invalid section index!");
675 if (MSD.SectionIndex >= ELF::SHN_LORESERVE)
676 HasLargeSectionIndex = true;
679 StringRef Name = Symbol.getName();
681 // Sections have their own string table
682 if (Symbol.getType() != ELF::STT_SECTION) {
684 StrTabBuilder.add(Name);
688 LocalSymbolData.push_back(MSD);
690 ExternalSymbolData.push_back(MSD);
693 // This holds the .symtab_shndx section index.
694 unsigned SymtabShndxSectionIndex = 0;
696 if (HasLargeSectionIndex) {
697 MCSectionELF *SymtabShndxSection =
698 Ctx.getELFSection(".symtab_shndxr", ELF::SHT_SYMTAB_SHNDX, 0, 4, "");
699 SymtabShndxSectionIndex = addToSectionTable(SymtabShndxSection);
700 SymtabShndxSection->setAlignment(4);
703 ArrayRef<std::string> FileNames = Asm.getFileNames();
704 for (const std::string &Name : FileNames)
705 StrTabBuilder.add(Name);
707 StrTabBuilder.finalize();
709 // File symbols are emitted first and handled separately from normal symbols,
710 // i.e. a non-STT_FILE symbol with the same name may appear.
711 for (const std::string &Name : FileNames)
712 Writer.writeSymbol(StrTabBuilder.getOffset(Name),
713 ELF::STT_FILE | ELF::STB_LOCAL, 0, 0, ELF::STV_DEFAULT,
716 // Symbols are required to be in lexicographic order.
717 array_pod_sort(LocalSymbolData.begin(), LocalSymbolData.end());
718 array_pod_sort(ExternalSymbolData.begin(), ExternalSymbolData.end());
720 // Set the symbol indices. Local symbols must come before all other
721 // symbols with non-local bindings.
722 unsigned Index = FileNames.size() + 1;
724 for (ELFSymbolData &MSD : LocalSymbolData) {
725 unsigned StringIndex = MSD.Symbol->getType() == ELF::STT_SECTION
727 : StrTabBuilder.getOffset(MSD.Name);
728 MSD.Symbol->setIndex(Index++);
729 writeSymbol(Writer, StringIndex, MSD, Layout);
732 // Write the symbol table entries.
733 LastLocalSymbolIndex = Index;
735 for (ELFSymbolData &MSD : ExternalSymbolData) {
736 unsigned StringIndex = StrTabBuilder.getOffset(MSD.Name);
737 MSD.Symbol->setIndex(Index++);
738 writeSymbol(Writer, StringIndex, MSD, Layout);
739 assert(MSD.Symbol->getBinding() != ELF::STB_LOCAL);
742 uint64_t SecEnd = W.OS.tell();
743 SectionOffsets[SymtabSection] = std::make_pair(SecStart, SecEnd);
745 ArrayRef<uint32_t> ShndxIndexes = Writer.getShndxIndexes();
746 if (ShndxIndexes.empty()) {
747 assert(SymtabShndxSectionIndex == 0);
750 assert(SymtabShndxSectionIndex != 0);
752 SecStart = W.OS.tell();
753 const MCSectionELF *SymtabShndxSection =
754 SectionTable[SymtabShndxSectionIndex - 1];
755 for (uint32_t Index : ShndxIndexes)
757 SecEnd = W.OS.tell();
758 SectionOffsets[SymtabShndxSection] = std::make_pair(SecStart, SecEnd);
761 void ELFWriter::writeAddrsigSection() {
762 for (const MCSymbol *Sym : OWriter.AddrsigSyms)
763 encodeULEB128(Sym->getIndex(), W.OS);
766 MCSectionELF *ELFWriter::createRelocationSection(MCContext &Ctx,
767 const MCSectionELF &Sec) {
768 if (OWriter.Relocations[&Sec].empty())
771 const StringRef SectionName = Sec.getSectionName();
772 std::string RelaSectionName = hasRelocationAddend() ? ".rela" : ".rel";
773 RelaSectionName += SectionName;
776 if (hasRelocationAddend())
777 EntrySize = is64Bit() ? sizeof(ELF::Elf64_Rela) : sizeof(ELF::Elf32_Rela);
779 EntrySize = is64Bit() ? sizeof(ELF::Elf64_Rel) : sizeof(ELF::Elf32_Rel);
782 if (Sec.getFlags() & ELF::SHF_GROUP)
783 Flags = ELF::SHF_GROUP;
785 MCSectionELF *RelaSection = Ctx.createELFRelSection(
786 RelaSectionName, hasRelocationAddend() ? ELF::SHT_RELA : ELF::SHT_REL,
787 Flags, EntrySize, Sec.getGroup(), &Sec);
788 RelaSection->setAlignment(is64Bit() ? 8 : 4);
792 // Include the debug info compression header.
793 bool ELFWriter::maybeWriteCompression(
794 uint64_t Size, SmallVectorImpl<char> &CompressedContents, bool ZLibStyle,
795 unsigned Alignment) {
798 is64Bit() ? sizeof(ELF::Elf32_Chdr) : sizeof(ELF::Elf64_Chdr);
799 if (Size <= HdrSize + CompressedContents.size())
801 // Platform specific header is followed by compressed data.
803 // Write Elf64_Chdr header.
804 write(static_cast<ELF::Elf64_Word>(ELF::ELFCOMPRESS_ZLIB));
805 write(static_cast<ELF::Elf64_Word>(0)); // ch_reserved field.
806 write(static_cast<ELF::Elf64_Xword>(Size));
807 write(static_cast<ELF::Elf64_Xword>(Alignment));
809 // Write Elf32_Chdr header otherwise.
810 write(static_cast<ELF::Elf32_Word>(ELF::ELFCOMPRESS_ZLIB));
811 write(static_cast<ELF::Elf32_Word>(Size));
812 write(static_cast<ELF::Elf32_Word>(Alignment));
817 // "ZLIB" followed by 8 bytes representing the uncompressed size of the section,
818 // useful for consumers to preallocate a buffer to decompress into.
819 const StringRef Magic = "ZLIB";
820 if (Size <= Magic.size() + sizeof(Size) + CompressedContents.size())
823 support::endian::write(W.OS, Size, support::big);
827 void ELFWriter::writeSectionData(const MCAssembler &Asm, MCSection &Sec,
828 const MCAsmLayout &Layout) {
829 MCSectionELF &Section = static_cast<MCSectionELF &>(Sec);
830 StringRef SectionName = Section.getSectionName();
832 auto &MC = Asm.getContext();
833 const auto &MAI = MC.getAsmInfo();
835 // Compressing debug_frame requires handling alignment fragments which is
836 // more work (possibly generalizing MCAssembler.cpp:writeFragment to allow
837 // for writing to arbitrary buffers) for little benefit.
838 bool CompressionEnabled =
839 MAI->compressDebugSections() != DebugCompressionType::None;
840 if (!CompressionEnabled || !SectionName.startswith(".debug_") ||
841 SectionName == ".debug_frame") {
842 Asm.writeSectionData(W.OS, &Section, Layout);
846 assert((MAI->compressDebugSections() == DebugCompressionType::Z ||
847 MAI->compressDebugSections() == DebugCompressionType::GNU) &&
848 "expected zlib or zlib-gnu style compression");
850 SmallVector<char, 128> UncompressedData;
851 raw_svector_ostream VecOS(UncompressedData);
852 Asm.writeSectionData(VecOS, &Section, Layout);
854 SmallVector<char, 128> CompressedContents;
855 if (Error E = zlib::compress(
856 StringRef(UncompressedData.data(), UncompressedData.size()),
857 CompressedContents)) {
858 consumeError(std::move(E));
859 W.OS << UncompressedData;
863 bool ZlibStyle = MAI->compressDebugSections() == DebugCompressionType::Z;
864 if (!maybeWriteCompression(UncompressedData.size(), CompressedContents,
865 ZlibStyle, Sec.getAlignment())) {
866 W.OS << UncompressedData;
871 // Set the compressed flag. That is zlib style.
872 Section.setFlags(Section.getFlags() | ELF::SHF_COMPRESSED);
874 // Add "z" prefix to section name. This is zlib-gnu style.
875 MC.renameELFSection(&Section, (".z" + SectionName.drop_front(1)).str());
876 W.OS << CompressedContents;
879 void ELFWriter::WriteSecHdrEntry(uint32_t Name, uint32_t Type, uint64_t Flags,
880 uint64_t Address, uint64_t Offset,
881 uint64_t Size, uint32_t Link, uint32_t Info,
882 uint64_t Alignment, uint64_t EntrySize) {
883 W.write<uint32_t>(Name); // sh_name: index into string table
884 W.write<uint32_t>(Type); // sh_type
885 WriteWord(Flags); // sh_flags
886 WriteWord(Address); // sh_addr
887 WriteWord(Offset); // sh_offset
888 WriteWord(Size); // sh_size
889 W.write<uint32_t>(Link); // sh_link
890 W.write<uint32_t>(Info); // sh_info
891 WriteWord(Alignment); // sh_addralign
892 WriteWord(EntrySize); // sh_entsize
895 void ELFWriter::writeRelocations(const MCAssembler &Asm,
896 const MCSectionELF &Sec) {
897 std::vector<ELFRelocationEntry> &Relocs = OWriter.Relocations[&Sec];
899 // We record relocations by pushing to the end of a vector. Reverse the vector
900 // to get the relocations in the order they were created.
901 // In most cases that is not important, but it can be for special sections
902 // (.eh_frame) or specific relocations (TLS optimizations on SystemZ).
903 std::reverse(Relocs.begin(), Relocs.end());
905 // Sort the relocation entries. MIPS needs this.
906 OWriter.TargetObjectWriter->sortRelocs(Asm, Relocs);
908 for (unsigned i = 0, e = Relocs.size(); i != e; ++i) {
909 const ELFRelocationEntry &Entry = Relocs[e - i - 1];
910 unsigned Index = Entry.Symbol ? Entry.Symbol->getIndex() : 0;
914 if (OWriter.TargetObjectWriter->getEMachine() == ELF::EM_MIPS) {
915 write(uint32_t(Index));
917 write(OWriter.TargetObjectWriter->getRSsym(Entry.Type));
918 write(OWriter.TargetObjectWriter->getRType3(Entry.Type));
919 write(OWriter.TargetObjectWriter->getRType2(Entry.Type));
920 write(OWriter.TargetObjectWriter->getRType(Entry.Type));
922 struct ELF::Elf64_Rela ERE64;
923 ERE64.setSymbolAndType(Index, Entry.Type);
926 if (hasRelocationAddend())
929 write(uint32_t(Entry.Offset));
931 struct ELF::Elf32_Rela ERE32;
932 ERE32.setSymbolAndType(Index, Entry.Type);
935 if (hasRelocationAddend())
936 write(uint32_t(Entry.Addend));
938 if (OWriter.TargetObjectWriter->getEMachine() == ELF::EM_MIPS) {
940 OWriter.TargetObjectWriter->getRType2(Entry.Type)) {
941 write(uint32_t(Entry.Offset));
943 ERE32.setSymbolAndType(0, RType);
948 OWriter.TargetObjectWriter->getRType3(Entry.Type)) {
949 write(uint32_t(Entry.Offset));
951 ERE32.setSymbolAndType(0, RType);
960 const MCSectionELF *ELFWriter::createStringTable(MCContext &Ctx) {
961 const MCSectionELF *StrtabSection = SectionTable[StringTableIndex - 1];
962 StrTabBuilder.write(W.OS);
963 return StrtabSection;
966 void ELFWriter::writeSection(const SectionIndexMapTy &SectionIndexMap,
967 uint32_t GroupSymbolIndex, uint64_t Offset,
968 uint64_t Size, const MCSectionELF &Section) {
969 uint64_t sh_link = 0;
970 uint64_t sh_info = 0;
972 switch(Section.getType()) {
977 case ELF::SHT_DYNAMIC:
978 llvm_unreachable("SHT_DYNAMIC in a relocatable object");
981 case ELF::SHT_RELA: {
982 sh_link = SymbolTableIndex;
983 assert(sh_link && ".symtab not found");
984 const MCSection *InfoSection = Section.getAssociatedSection();
985 sh_info = SectionIndexMap.lookup(cast<MCSectionELF>(InfoSection));
989 case ELF::SHT_SYMTAB:
990 sh_link = StringTableIndex;
991 sh_info = LastLocalSymbolIndex;
994 case ELF::SHT_SYMTAB_SHNDX:
995 case ELF::SHT_LLVM_CALL_GRAPH_PROFILE:
996 case ELF::SHT_LLVM_ADDRSIG:
997 sh_link = SymbolTableIndex;
1000 case ELF::SHT_GROUP:
1001 sh_link = SymbolTableIndex;
1002 sh_info = GroupSymbolIndex;
1006 if (Section.getFlags() & ELF::SHF_LINK_ORDER) {
1007 const MCSymbol *Sym = Section.getAssociatedSymbol();
1008 const MCSectionELF *Sec = cast<MCSectionELF>(&Sym->getSection());
1009 sh_link = SectionIndexMap.lookup(Sec);
1012 WriteSecHdrEntry(StrTabBuilder.getOffset(Section.getSectionName()),
1013 Section.getType(), Section.getFlags(), 0, Offset, Size,
1014 sh_link, sh_info, Section.getAlignment(),
1015 Section.getEntrySize());
1018 void ELFWriter::writeSectionHeader(
1019 const MCAsmLayout &Layout, const SectionIndexMapTy &SectionIndexMap,
1020 const SectionOffsetsTy &SectionOffsets) {
1021 const unsigned NumSections = SectionTable.size();
1023 // Null section first.
1024 uint64_t FirstSectionSize =
1025 (NumSections + 1) >= ELF::SHN_LORESERVE ? NumSections + 1 : 0;
1026 WriteSecHdrEntry(0, 0, 0, 0, 0, FirstSectionSize, 0, 0, 0, 0);
1028 for (const MCSectionELF *Section : SectionTable) {
1029 uint32_t GroupSymbolIndex;
1030 unsigned Type = Section->getType();
1031 if (Type != ELF::SHT_GROUP)
1032 GroupSymbolIndex = 0;
1034 GroupSymbolIndex = Section->getGroup()->getIndex();
1036 const std::pair<uint64_t, uint64_t> &Offsets =
1037 SectionOffsets.find(Section)->second;
1039 if (Type == ELF::SHT_NOBITS)
1040 Size = Layout.getSectionAddressSize(Section);
1042 Size = Offsets.second - Offsets.first;
1044 writeSection(SectionIndexMap, GroupSymbolIndex, Offsets.first, Size,
1049 uint64_t ELFWriter::writeObject(MCAssembler &Asm, const MCAsmLayout &Layout) {
1050 uint64_t StartOffset = W.OS.tell();
1052 MCContext &Ctx = Asm.getContext();
1053 MCSectionELF *StrtabSection =
1054 Ctx.getELFSection(".strtab", ELF::SHT_STRTAB, 0);
1055 StringTableIndex = addToSectionTable(StrtabSection);
1057 RevGroupMapTy RevGroupMap;
1058 SectionIndexMapTy SectionIndexMap;
1060 std::map<const MCSymbol *, std::vector<const MCSectionELF *>> GroupMembers;
1062 // Write out the ELF header ...
1065 // ... then the sections ...
1066 SectionOffsetsTy SectionOffsets;
1067 std::vector<MCSectionELF *> Groups;
1068 std::vector<MCSectionELF *> Relocations;
1069 for (MCSection &Sec : Asm) {
1070 MCSectionELF &Section = static_cast<MCSectionELF &>(Sec);
1071 if (Mode == NonDwoOnly && isDwoSection(Section))
1073 if (Mode == DwoOnly && !isDwoSection(Section))
1076 align(Section.getAlignment());
1078 // Remember the offset into the file for this section.
1079 uint64_t SecStart = W.OS.tell();
1081 const MCSymbolELF *SignatureSymbol = Section.getGroup();
1082 writeSectionData(Asm, Section, Layout);
1084 uint64_t SecEnd = W.OS.tell();
1085 SectionOffsets[&Section] = std::make_pair(SecStart, SecEnd);
1087 MCSectionELF *RelSection = createRelocationSection(Ctx, Section);
1089 if (SignatureSymbol) {
1090 Asm.registerSymbol(*SignatureSymbol);
1091 unsigned &GroupIdx = RevGroupMap[SignatureSymbol];
1093 MCSectionELF *Group = Ctx.createELFGroupSection(SignatureSymbol);
1094 GroupIdx = addToSectionTable(Group);
1095 Group->setAlignment(4);
1096 Groups.push_back(Group);
1098 std::vector<const MCSectionELF *> &Members =
1099 GroupMembers[SignatureSymbol];
1100 Members.push_back(&Section);
1102 Members.push_back(RelSection);
1105 SectionIndexMap[&Section] = addToSectionTable(&Section);
1107 SectionIndexMap[RelSection] = addToSectionTable(RelSection);
1108 Relocations.push_back(RelSection);
1112 MCSectionELF *CGProfileSection = nullptr;
1113 if (!Asm.CGProfile.empty()) {
1114 CGProfileSection = Ctx.getELFSection(".llvm.call-graph-profile",
1115 ELF::SHT_LLVM_CALL_GRAPH_PROFILE,
1116 ELF::SHF_EXCLUDE, 16, "");
1117 SectionIndexMap[CGProfileSection] = addToSectionTable(CGProfileSection);
1120 for (MCSectionELF *Group : Groups) {
1121 align(Group->getAlignment());
1123 // Remember the offset into the file for this section.
1124 uint64_t SecStart = W.OS.tell();
1126 const MCSymbol *SignatureSymbol = Group->getGroup();
1127 assert(SignatureSymbol);
1128 write(uint32_t(ELF::GRP_COMDAT));
1129 for (const MCSectionELF *Member : GroupMembers[SignatureSymbol]) {
1130 uint32_t SecIndex = SectionIndexMap.lookup(Member);
1134 uint64_t SecEnd = W.OS.tell();
1135 SectionOffsets[Group] = std::make_pair(SecStart, SecEnd);
1138 if (Mode == DwoOnly) {
1139 // dwo files don't have symbol tables or relocations, but they do have
1141 StrTabBuilder.finalize();
1143 MCSectionELF *AddrsigSection;
1144 if (OWriter.EmitAddrsigSection) {
1145 AddrsigSection = Ctx.getELFSection(".llvm_addrsig", ELF::SHT_LLVM_ADDRSIG,
1147 addToSectionTable(AddrsigSection);
1150 // Compute symbol table information.
1151 computeSymbolTable(Asm, Layout, SectionIndexMap, RevGroupMap,
1154 for (MCSectionELF *RelSection : Relocations) {
1155 align(RelSection->getAlignment());
1157 // Remember the offset into the file for this section.
1158 uint64_t SecStart = W.OS.tell();
1160 writeRelocations(Asm,
1161 cast<MCSectionELF>(*RelSection->getAssociatedSection()));
1163 uint64_t SecEnd = W.OS.tell();
1164 SectionOffsets[RelSection] = std::make_pair(SecStart, SecEnd);
1167 if (OWriter.EmitAddrsigSection) {
1168 uint64_t SecStart = W.OS.tell();
1169 writeAddrsigSection();
1170 uint64_t SecEnd = W.OS.tell();
1171 SectionOffsets[AddrsigSection] = std::make_pair(SecStart, SecEnd);
1175 if (CGProfileSection) {
1176 uint64_t SecStart = W.OS.tell();
1177 for (const MCAssembler::CGProfileEntry &CGPE : Asm.CGProfile) {
1178 W.write<uint32_t>(CGPE.From->getSymbol().getIndex());
1179 W.write<uint32_t>(CGPE.To->getSymbol().getIndex());
1180 W.write<uint64_t>(CGPE.Count);
1182 uint64_t SecEnd = W.OS.tell();
1183 SectionOffsets[CGProfileSection] = std::make_pair(SecStart, SecEnd);
1187 uint64_t SecStart = W.OS.tell();
1188 const MCSectionELF *Sec = createStringTable(Ctx);
1189 uint64_t SecEnd = W.OS.tell();
1190 SectionOffsets[Sec] = std::make_pair(SecStart, SecEnd);
1193 uint64_t NaturalAlignment = is64Bit() ? 8 : 4;
1194 align(NaturalAlignment);
1196 const uint64_t SectionHeaderOffset = W.OS.tell();
1198 // ... then the section header table ...
1199 writeSectionHeader(Layout, SectionIndexMap, SectionOffsets);
1201 uint16_t NumSections = support::endian::byte_swap<uint16_t>(
1202 (SectionTable.size() + 1 >= ELF::SHN_LORESERVE) ? (uint16_t)ELF::SHN_UNDEF
1203 : SectionTable.size() + 1,
1205 unsigned NumSectionsOffset;
1207 auto &Stream = static_cast<raw_pwrite_stream &>(W.OS);
1210 support::endian::byte_swap<uint64_t>(SectionHeaderOffset, W.Endian);
1211 Stream.pwrite(reinterpret_cast<char *>(&Val), sizeof(Val),
1212 offsetof(ELF::Elf64_Ehdr, e_shoff));
1213 NumSectionsOffset = offsetof(ELF::Elf64_Ehdr, e_shnum);
1216 support::endian::byte_swap<uint32_t>(SectionHeaderOffset, W.Endian);
1217 Stream.pwrite(reinterpret_cast<char *>(&Val), sizeof(Val),
1218 offsetof(ELF::Elf32_Ehdr, e_shoff));
1219 NumSectionsOffset = offsetof(ELF::Elf32_Ehdr, e_shnum);
1221 Stream.pwrite(reinterpret_cast<char *>(&NumSections), sizeof(NumSections),
1224 return W.OS.tell() - StartOffset;
1227 bool ELFObjectWriter::hasRelocationAddend() const {
1228 return TargetObjectWriter->hasRelocationAddend();
1231 void ELFObjectWriter::executePostLayoutBinding(MCAssembler &Asm,
1232 const MCAsmLayout &Layout) {
1233 // The presence of symbol versions causes undefined symbols and
1234 // versions declared with @@@ to be renamed.
1235 for (const std::pair<StringRef, const MCSymbol *> &P : Asm.Symvers) {
1236 StringRef AliasName = P.first;
1237 const auto &Symbol = cast<MCSymbolELF>(*P.second);
1238 size_t Pos = AliasName.find('@');
1239 assert(Pos != StringRef::npos);
1241 StringRef Prefix = AliasName.substr(0, Pos);
1242 StringRef Rest = AliasName.substr(Pos);
1243 StringRef Tail = Rest;
1244 if (Rest.startswith("@@@"))
1245 Tail = Rest.substr(Symbol.isUndefined() ? 2 : 1);
1248 cast<MCSymbolELF>(Asm.getContext().getOrCreateSymbol(Prefix + Tail));
1249 Asm.registerSymbol(*Alias);
1250 const MCExpr *Value = MCSymbolRefExpr::create(&Symbol, Asm.getContext());
1251 Alias->setVariableValue(Value);
1253 // Aliases defined with .symvar copy the binding from the symbol they alias.
1254 // This is the first place we are able to copy this information.
1255 Alias->setExternal(Symbol.isExternal());
1256 Alias->setBinding(Symbol.getBinding());
1258 if (!Symbol.isUndefined() && !Rest.startswith("@@@"))
1261 // FIXME: Get source locations for these errors or diagnose them earlier.
1262 if (Symbol.isUndefined() && Rest.startswith("@@") &&
1263 !Rest.startswith("@@@")) {
1264 Asm.getContext().reportError(SMLoc(), "versioned symbol " + AliasName +
1265 " must be defined");
1269 if (Renames.count(&Symbol) && Renames[&Symbol] != Alias) {
1270 Asm.getContext().reportError(
1271 SMLoc(), llvm::Twine("multiple symbol versions defined for ") +
1276 Renames.insert(std::make_pair(&Symbol, Alias));
1279 for (const MCSymbol *&Sym : AddrsigSyms) {
1280 if (const MCSymbol *R = Renames.lookup(cast<MCSymbolELF>(Sym)))
1282 Sym->setUsedInReloc();
1286 // It is always valid to create a relocation with a symbol. It is preferable
1287 // to use a relocation with a section if that is possible. Using the section
1288 // allows us to omit some local symbols from the symbol table.
1289 bool ELFObjectWriter::shouldRelocateWithSymbol(const MCAssembler &Asm,
1290 const MCSymbolRefExpr *RefA,
1291 const MCSymbolELF *Sym,
1293 unsigned Type) const {
1294 // A PCRel relocation to an absolute value has no symbol (or section). We
1295 // represent that with a relocation to a null section.
1299 MCSymbolRefExpr::VariantKind Kind = RefA->getKind();
1303 // The .odp creation emits a relocation against the symbol ".TOC." which
1304 // create a R_PPC64_TOC relocation. However the relocation symbol name
1305 // in final object creation should be NULL, since the symbol does not
1306 // really exist, it is just the reference to TOC base for the current
1307 // object file. Since the symbol is undefined, returning false results
1308 // in a relocation with a null section which is the desired result.
1309 case MCSymbolRefExpr::VK_PPC_TOCBASE:
1312 // These VariantKind cause the relocation to refer to something other than
1313 // the symbol itself, like a linker generated table. Since the address of
1314 // symbol is not relevant, we cannot replace the symbol with the
1315 // section and patch the difference in the addend.
1316 case MCSymbolRefExpr::VK_GOT:
1317 case MCSymbolRefExpr::VK_PLT:
1318 case MCSymbolRefExpr::VK_GOTPCREL:
1319 case MCSymbolRefExpr::VK_PPC_GOT_LO:
1320 case MCSymbolRefExpr::VK_PPC_GOT_HI:
1321 case MCSymbolRefExpr::VK_PPC_GOT_HA:
1325 // An undefined symbol is not in any section, so the relocation has to point
1326 // to the symbol itself.
1327 assert(Sym && "Expected a symbol");
1328 if (Sym->isUndefined())
1331 unsigned Binding = Sym->getBinding();
1334 llvm_unreachable("Invalid Binding");
1335 case ELF::STB_LOCAL:
1338 // If the symbol is weak, it might be overridden by a symbol in another
1339 // file. The relocation has to point to the symbol so that the linker
1342 case ELF::STB_GLOBAL:
1343 // Global ELF symbols can be preempted by the dynamic linker. The relocation
1344 // has to point to the symbol for a reason analogous to the STB_WEAK case.
1348 // If a relocation points to a mergeable section, we have to be careful.
1349 // If the offset is zero, a relocation with the section will encode the
1350 // same information. With a non-zero offset, the situation is different.
1351 // For example, a relocation can point 42 bytes past the end of a string.
1352 // If we change such a relocation to use the section, the linker would think
1353 // that it pointed to another string and subtracting 42 at runtime will
1354 // produce the wrong value.
1355 if (Sym->isInSection()) {
1356 auto &Sec = cast<MCSectionELF>(Sym->getSection());
1357 unsigned Flags = Sec.getFlags();
1358 if (Flags & ELF::SHF_MERGE) {
1362 // It looks like gold has a bug (http://sourceware.org/PR16794) and can
1363 // only handle section relocations to mergeable sections if using RELA.
1364 if (!hasRelocationAddend())
1368 // Most TLS relocations use a got, so they need the symbol. Even those that
1369 // are just an offset (@tpoff), require a symbol in gold versions before
1370 // 5efeedf61e4fe720fd3e9a08e6c91c10abb66d42 (2014-09-26) which fixed
1371 // http://sourceware.org/PR16773.
1372 if (Flags & ELF::SHF_TLS)
1376 // If the symbol is a thumb function the final relocation must set the lowest
1377 // bit. With a symbol that is done by just having the symbol have that bit
1378 // set, so we would lose the bit if we relocated with the section.
1379 // FIXME: We could use the section but add the bit to the relocation value.
1380 if (Asm.isThumbFunc(Sym))
1383 if (TargetObjectWriter->needsRelocateWithSymbol(*Sym, Type))
1388 void ELFObjectWriter::recordRelocation(MCAssembler &Asm,
1389 const MCAsmLayout &Layout,
1390 const MCFragment *Fragment,
1391 const MCFixup &Fixup, MCValue Target,
1392 uint64_t &FixedValue) {
1393 MCAsmBackend &Backend = Asm.getBackend();
1394 bool IsPCRel = Backend.getFixupKindInfo(Fixup.getKind()).Flags &
1395 MCFixupKindInfo::FKF_IsPCRel;
1396 const MCSectionELF &FixupSection = cast<MCSectionELF>(*Fragment->getParent());
1397 uint64_t C = Target.getConstant();
1398 uint64_t FixupOffset = Layout.getFragmentOffset(Fragment) + Fixup.getOffset();
1399 MCContext &Ctx = Asm.getContext();
1401 if (const MCSymbolRefExpr *RefB = Target.getSymB()) {
1402 // Let A, B and C being the components of Target and R be the location of
1403 // the fixup. If the fixup is not pcrel, we want to compute (A - B + C).
1404 // If it is pcrel, we want to compute (A - B + C - R).
1406 // In general, ELF has no relocations for -B. It can only represent (A + C)
1407 // or (A + C - R). If B = R + K and the relocation is not pcrel, we can
1408 // replace B to implement it: (A - R - K + C)
1412 "No relocation available to represent this relative expression");
1416 const auto &SymB = cast<MCSymbolELF>(RefB->getSymbol());
1418 if (SymB.isUndefined()) {
1419 Ctx.reportError(Fixup.getLoc(),
1420 Twine("symbol '") + SymB.getName() +
1421 "' can not be undefined in a subtraction expression");
1425 assert(!SymB.isAbsolute() && "Should have been folded");
1426 const MCSection &SecB = SymB.getSection();
1427 if (&SecB != &FixupSection) {
1428 Ctx.reportError(Fixup.getLoc(),
1429 "Cannot represent a difference across sections");
1433 uint64_t SymBOffset = Layout.getSymbolOffset(SymB);
1434 uint64_t K = SymBOffset - FixupOffset;
1439 // We either rejected the fixup or folded B into C at this point.
1440 const MCSymbolRefExpr *RefA = Target.getSymA();
1441 const auto *SymA = RefA ? cast<MCSymbolELF>(&RefA->getSymbol()) : nullptr;
1443 bool ViaWeakRef = false;
1444 if (SymA && SymA->isVariable()) {
1445 const MCExpr *Expr = SymA->getVariableValue();
1446 if (const auto *Inner = dyn_cast<MCSymbolRefExpr>(Expr)) {
1447 if (Inner->getKind() == MCSymbolRefExpr::VK_WEAKREF) {
1448 SymA = cast<MCSymbolELF>(&Inner->getSymbol());
1454 unsigned Type = TargetObjectWriter->getRelocType(Ctx, Target, Fixup, IsPCRel);
1455 uint64_t OriginalC = C;
1456 bool RelocateWithSymbol = shouldRelocateWithSymbol(Asm, RefA, SymA, C, Type);
1457 if (!RelocateWithSymbol && SymA && !SymA->isUndefined())
1458 C += Layout.getSymbolOffset(*SymA);
1460 uint64_t Addend = 0;
1461 if (hasRelocationAddend()) {
1468 const MCSectionELF *SecA = (SymA && SymA->isInSection())
1469 ? cast<MCSectionELF>(&SymA->getSection())
1471 if (!checkRelocation(Ctx, Fixup.getLoc(), &FixupSection, SecA))
1474 if (!RelocateWithSymbol) {
1475 const auto *SectionSymbol =
1476 SecA ? cast<MCSymbolELF>(SecA->getBeginSymbol()) : nullptr;
1478 SectionSymbol->setUsedInReloc();
1479 ELFRelocationEntry Rec(FixupOffset, SectionSymbol, Type, Addend, SymA,
1481 Relocations[&FixupSection].push_back(Rec);
1485 const auto *RenamedSymA = SymA;
1487 if (const MCSymbolELF *R = Renames.lookup(SymA))
1491 RenamedSymA->setIsWeakrefUsedInReloc();
1493 RenamedSymA->setUsedInReloc();
1495 ELFRelocationEntry Rec(FixupOffset, RenamedSymA, Type, Addend, SymA,
1497 Relocations[&FixupSection].push_back(Rec);
1500 bool ELFObjectWriter::isSymbolRefDifferenceFullyResolvedImpl(
1501 const MCAssembler &Asm, const MCSymbol &SA, const MCFragment &FB,
1502 bool InSet, bool IsPCRel) const {
1503 const auto &SymA = cast<MCSymbolELF>(SA);
1509 return MCObjectWriter::isSymbolRefDifferenceFullyResolvedImpl(Asm, SymA, FB,
1513 std::unique_ptr<MCObjectWriter>
1514 llvm::createELFObjectWriter(std::unique_ptr<MCELFObjectTargetWriter> MOTW,
1515 raw_pwrite_stream &OS, bool IsLittleEndian) {
1516 return llvm::make_unique<ELFSingleObjectWriter>(std::move(MOTW), OS,
1520 std::unique_ptr<MCObjectWriter>
1521 llvm::createELFDwoObjectWriter(std::unique_ptr<MCELFObjectTargetWriter> MOTW,
1522 raw_pwrite_stream &OS, raw_pwrite_stream &DwoOS,
1523 bool IsLittleEndian) {
1524 return llvm::make_unique<ELFDwoObjectWriter>(std::move(MOTW), OS, DwoOS,