LLVM  15.0.0git
ELFObjectWriter.cpp
Go to the documentation of this file.
1 //===- lib/MC/ELFObjectWriter.cpp - ELF File Writer -----------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements ELF object file writer information.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "llvm/ADT/ArrayRef.h"
14 #include "llvm/ADT/DenseMap.h"
15 #include "llvm/ADT/STLExtras.h"
16 #include "llvm/ADT/SmallVector.h"
17 #include "llvm/ADT/StringRef.h"
18 #include "llvm/ADT/Twine.h"
19 #include "llvm/ADT/iterator.h"
20 #include "llvm/BinaryFormat/ELF.h"
21 #include "llvm/MC/MCAsmBackend.h"
22 #include "llvm/MC/MCAsmInfo.h"
23 #include "llvm/MC/MCAsmLayout.h"
24 #include "llvm/MC/MCAssembler.h"
25 #include "llvm/MC/MCContext.h"
27 #include "llvm/MC/MCExpr.h"
28 #include "llvm/MC/MCFixup.h"
30 #include "llvm/MC/MCFragment.h"
31 #include "llvm/MC/MCObjectWriter.h"
32 #include "llvm/MC/MCSection.h"
33 #include "llvm/MC/MCSectionELF.h"
34 #include "llvm/MC/MCSymbol.h"
35 #include "llvm/MC/MCSymbolELF.h"
37 #include "llvm/MC/MCValue.h"
39 #include "llvm/Support/Alignment.h"
40 #include "llvm/Support/Casting.h"
42 #include "llvm/Support/Endian.h"
44 #include "llvm/Support/Error.h"
46 #include "llvm/Support/Host.h"
47 #include "llvm/Support/LEB128.h"
49 #include "llvm/Support/SMLoc.h"
51 #include <algorithm>
52 #include <cassert>
53 #include <cstddef>
54 #include <cstdint>
55 #include <map>
56 #include <memory>
57 #include <string>
58 #include <utility>
59 #include <vector>
60 
61 using namespace llvm;
62 
63 #undef DEBUG_TYPE
64 #define DEBUG_TYPE "reloc-info"
65 
66 namespace {
67 
68 using SectionIndexMapTy = DenseMap<const MCSectionELF *, uint32_t>;
69 
70 class ELFObjectWriter;
71 struct ELFWriter;
72 
73 bool isDwoSection(const MCSectionELF &Sec) {
74  return Sec.getName().endswith(".dwo");
75 }
76 
77 class SymbolTableWriter {
78  ELFWriter &EWriter;
79  bool Is64Bit;
80 
81  // indexes we are going to write to .symtab_shndx.
82  std::vector<uint32_t> ShndxIndexes;
83 
84  // The numbel of symbols written so far.
85  unsigned NumWritten;
86 
87  void createSymtabShndx();
88 
89  template <typename T> void write(T Value);
90 
91 public:
92  SymbolTableWriter(ELFWriter &EWriter, bool Is64Bit);
93 
94  void writeSymbol(uint32_t name, uint8_t info, uint64_t value, uint64_t size,
95  uint8_t other, uint32_t shndx, bool Reserved);
96 
97  ArrayRef<uint32_t> getShndxIndexes() const { return ShndxIndexes; }
98 };
99 
100 struct ELFWriter {
101  ELFObjectWriter &OWriter;
103 
104  enum DwoMode {
105  AllSections,
106  NonDwoOnly,
107  DwoOnly,
108  } Mode;
109 
110  static uint64_t SymbolValue(const MCSymbol &Sym, const MCAsmLayout &Layout);
111  static bool isInSymtab(const MCAsmLayout &Layout, const MCSymbolELF &Symbol,
112  bool Used, bool Renamed);
113 
114  /// Helper struct for containing some precomputed information on symbols.
115  struct ELFSymbolData {
116  const MCSymbolELF *Symbol;
117  StringRef Name;
118  uint32_t SectionIndex;
119  uint32_t Order;
120  };
121 
122  /// @}
123  /// @name Symbol Table Data
124  /// @{
125 
127 
128  /// @}
129 
130  // This holds the symbol table index of the last local symbol.
131  unsigned LastLocalSymbolIndex;
132  // This holds the .strtab section index.
133  unsigned StringTableIndex;
134  // This holds the .symtab section index.
135  unsigned SymbolTableIndex;
136 
137  // Sections in the order they are to be output in the section table.
138  std::vector<const MCSectionELF *> SectionTable;
139  unsigned addToSectionTable(const MCSectionELF *Sec);
140 
141  // TargetObjectWriter wrappers.
142  bool is64Bit() const;
143  bool usesRela(const MCSectionELF &Sec) const;
144 
145  uint64_t align(unsigned Alignment);
146 
147  bool maybeWriteCompression(uint64_t Size,
148  SmallVectorImpl<char> &CompressedContents,
149  bool ZLibStyle, unsigned Alignment);
150 
151 public:
152  ELFWriter(ELFObjectWriter &OWriter, raw_pwrite_stream &OS,
153  bool IsLittleEndian, DwoMode Mode)
154  : OWriter(OWriter),
155  W(OS, IsLittleEndian ? support::little : support::big), Mode(Mode) {}
156 
157  void WriteWord(uint64_t Word) {
158  if (is64Bit())
159  W.write<uint64_t>(Word);
160  else
161  W.write<uint32_t>(Word);
162  }
163 
164  template <typename T> void write(T Val) {
165  W.write(Val);
166  }
167 
168  void writeHeader(const MCAssembler &Asm);
169 
170  void writeSymbol(SymbolTableWriter &Writer, uint32_t StringIndex,
171  ELFSymbolData &MSD, const MCAsmLayout &Layout);
172 
173  // Start and end offset of each section
174  using SectionOffsetsTy =
175  std::map<const MCSectionELF *, std::pair<uint64_t, uint64_t>>;
176 
177  // Map from a signature symbol to the group section index
178  using RevGroupMapTy = DenseMap<const MCSymbol *, unsigned>;
179 
180  /// Compute the symbol table data
181  ///
182  /// \param Asm - The assembler.
183  /// \param SectionIndexMap - Maps a section to its index.
184  /// \param RevGroupMap - Maps a signature symbol to the group section.
185  void computeSymbolTable(MCAssembler &Asm, const MCAsmLayout &Layout,
186  const SectionIndexMapTy &SectionIndexMap,
187  const RevGroupMapTy &RevGroupMap,
188  SectionOffsetsTy &SectionOffsets);
189 
190  void writeAddrsigSection();
191 
192  MCSectionELF *createRelocationSection(MCContext &Ctx,
193  const MCSectionELF &Sec);
194 
195  void writeSectionHeader(const MCAsmLayout &Layout,
196  const SectionIndexMapTy &SectionIndexMap,
197  const SectionOffsetsTy &SectionOffsets);
198 
199  void writeSectionData(const MCAssembler &Asm, MCSection &Sec,
200  const MCAsmLayout &Layout);
201 
202  void WriteSecHdrEntry(uint32_t Name, uint32_t Type, uint64_t Flags,
203  uint64_t Address, uint64_t Offset, uint64_t Size,
204  uint32_t Link, uint32_t Info, uint64_t Alignment,
205  uint64_t EntrySize);
206 
207  void writeRelocations(const MCAssembler &Asm, const MCSectionELF &Sec);
208 
209  uint64_t writeObject(MCAssembler &Asm, const MCAsmLayout &Layout);
210  void writeSection(const SectionIndexMapTy &SectionIndexMap,
211  uint32_t GroupSymbolIndex, uint64_t Offset, uint64_t Size,
212  const MCSectionELF &Section);
213 };
214 
215 class ELFObjectWriter : public MCObjectWriter {
216  /// The target specific ELF writer instance.
217  std::unique_ptr<MCELFObjectTargetWriter> TargetObjectWriter;
218 
220 
222 
223  bool SeenGnuAbi = false;
224 
225  bool hasRelocationAddend() const;
226 
227  bool shouldRelocateWithSymbol(const MCAssembler &Asm,
228  const MCSymbolRefExpr *RefA,
229  const MCSymbolELF *Sym, uint64_t C,
230  unsigned Type) const;
231 
232 public:
233  ELFObjectWriter(std::unique_ptr<MCELFObjectTargetWriter> MOTW)
234  : TargetObjectWriter(std::move(MOTW)) {}
235 
236  void reset() override {
237  SeenGnuAbi = false;
238  Relocations.clear();
239  Renames.clear();
241  }
242 
243  bool isSymbolRefDifferenceFullyResolvedImpl(const MCAssembler &Asm,
244  const MCSymbol &SymA,
245  const MCFragment &FB, bool InSet,
246  bool IsPCRel) const override;
247 
248  virtual bool checkRelocation(MCContext &Ctx, SMLoc Loc,
249  const MCSectionELF *From,
250  const MCSectionELF *To) {
251  return true;
252  }
253 
254  void recordRelocation(MCAssembler &Asm, const MCAsmLayout &Layout,
255  const MCFragment *Fragment, const MCFixup &Fixup,
256  MCValue Target, uint64_t &FixedValue) override;
257 
258  void executePostLayoutBinding(MCAssembler &Asm,
259  const MCAsmLayout &Layout) override;
260 
261  void markGnuAbi() override { SeenGnuAbi = true; }
262  bool seenGnuAbi() const { return SeenGnuAbi; }
263 
264  friend struct ELFWriter;
265 };
266 
267 class ELFSingleObjectWriter : public ELFObjectWriter {
268  raw_pwrite_stream &OS;
269  bool IsLittleEndian;
270 
271 public:
272  ELFSingleObjectWriter(std::unique_ptr<MCELFObjectTargetWriter> MOTW,
273  raw_pwrite_stream &OS, bool IsLittleEndian)
274  : ELFObjectWriter(std::move(MOTW)), OS(OS),
275  IsLittleEndian(IsLittleEndian) {}
276 
277  uint64_t writeObject(MCAssembler &Asm, const MCAsmLayout &Layout) override {
278  return ELFWriter(*this, OS, IsLittleEndian, ELFWriter::AllSections)
279  .writeObject(Asm, Layout);
280  }
281 
282  friend struct ELFWriter;
283 };
284 
285 class ELFDwoObjectWriter : public ELFObjectWriter {
286  raw_pwrite_stream &OS, &DwoOS;
287  bool IsLittleEndian;
288 
289 public:
290  ELFDwoObjectWriter(std::unique_ptr<MCELFObjectTargetWriter> MOTW,
292  bool IsLittleEndian)
293  : ELFObjectWriter(std::move(MOTW)), OS(OS), DwoOS(DwoOS),
294  IsLittleEndian(IsLittleEndian) {}
295 
296  virtual bool checkRelocation(MCContext &Ctx, SMLoc Loc,
297  const MCSectionELF *From,
298  const MCSectionELF *To) override {
299  if (isDwoSection(*From)) {
300  Ctx.reportError(Loc, "A dwo section may not contain relocations");
301  return false;
302  }
303  if (To && isDwoSection(*To)) {
304  Ctx.reportError(Loc, "A relocation may not refer to a dwo section");
305  return false;
306  }
307  return true;
308  }
309 
310  uint64_t writeObject(MCAssembler &Asm, const MCAsmLayout &Layout) override {
311  uint64_t Size = ELFWriter(*this, OS, IsLittleEndian, ELFWriter::NonDwoOnly)
312  .writeObject(Asm, Layout);
313  Size += ELFWriter(*this, DwoOS, IsLittleEndian, ELFWriter::DwoOnly)
314  .writeObject(Asm, Layout);
315  return Size;
316  }
317 };
318 
319 } // end anonymous namespace
320 
321 uint64_t ELFWriter::align(unsigned Alignment) {
322  uint64_t Offset = W.OS.tell(), NewOffset = alignTo(Offset, Alignment);
323  W.OS.write_zeros(NewOffset - Offset);
324  return NewOffset;
325 }
326 
327 unsigned ELFWriter::addToSectionTable(const MCSectionELF *Sec) {
328  SectionTable.push_back(Sec);
329  StrTabBuilder.add(Sec->getName());
330  return SectionTable.size();
331 }
332 
333 void SymbolTableWriter::createSymtabShndx() {
334  if (!ShndxIndexes.empty())
335  return;
336 
337  ShndxIndexes.resize(NumWritten);
338 }
339 
340 template <typename T> void SymbolTableWriter::write(T Value) {
341  EWriter.write(Value);
342 }
343 
344 SymbolTableWriter::SymbolTableWriter(ELFWriter &EWriter, bool Is64Bit)
345  : EWriter(EWriter), Is64Bit(Is64Bit), NumWritten(0) {}
346 
347 void SymbolTableWriter::writeSymbol(uint32_t name, uint8_t info, uint64_t value,
348  uint64_t size, uint8_t other,
349  uint32_t shndx, bool Reserved) {
350  bool LargeIndex = shndx >= ELF::SHN_LORESERVE && !Reserved;
351 
352  if (LargeIndex)
353  createSymtabShndx();
354 
355  if (!ShndxIndexes.empty()) {
356  if (LargeIndex)
357  ShndxIndexes.push_back(shndx);
358  else
359  ShndxIndexes.push_back(0);
360  }
361 
362  uint16_t Index = LargeIndex ? uint16_t(ELF::SHN_XINDEX) : shndx;
363 
364  if (Is64Bit) {
365  write(name); // st_name
366  write(info); // st_info
367  write(other); // st_other
368  write(Index); // st_shndx
369  write(value); // st_value
370  write(size); // st_size
371  } else {
372  write(name); // st_name
373  write(uint32_t(value)); // st_value
374  write(uint32_t(size)); // st_size
375  write(info); // st_info
376  write(other); // st_other
377  write(Index); // st_shndx
378  }
379 
380  ++NumWritten;
381 }
382 
383 bool ELFWriter::is64Bit() const {
384  return OWriter.TargetObjectWriter->is64Bit();
385 }
386 
387 bool ELFWriter::usesRela(const MCSectionELF &Sec) const {
388  return OWriter.hasRelocationAddend() &&
390 }
391 
392 // Emit the ELF header.
393 void ELFWriter::writeHeader(const MCAssembler &Asm) {
394  // ELF Header
395  // ----------
396  //
397  // Note
398  // ----
399  // emitWord method behaves differently for ELF32 and ELF64, writing
400  // 4 bytes in the former and 8 in the latter.
401 
402  W.OS << ELF::ElfMagic; // e_ident[EI_MAG0] to e_ident[EI_MAG3]
403 
404  W.OS << char(is64Bit() ? ELF::ELFCLASS64 : ELF::ELFCLASS32); // e_ident[EI_CLASS]
405 
406  // e_ident[EI_DATA]
407  W.OS << char(W.Endian == support::little ? ELF::ELFDATA2LSB
408  : ELF::ELFDATA2MSB);
409 
410  W.OS << char(ELF::EV_CURRENT); // e_ident[EI_VERSION]
411  // e_ident[EI_OSABI]
412  uint8_t OSABI = OWriter.TargetObjectWriter->getOSABI();
413  W.OS << char(OSABI == ELF::ELFOSABI_NONE && OWriter.seenGnuAbi()
414  ? int(ELF::ELFOSABI_GNU)
415  : OSABI);
416  // e_ident[EI_ABIVERSION]
417  W.OS << char(OWriter.TargetObjectWriter->getABIVersion());
418 
419  W.OS.write_zeros(ELF::EI_NIDENT - ELF::EI_PAD);
420 
421  W.write<uint16_t>(ELF::ET_REL); // e_type
422 
423  W.write<uint16_t>(OWriter.TargetObjectWriter->getEMachine()); // e_machine = target
424 
425  W.write<uint32_t>(ELF::EV_CURRENT); // e_version
426  WriteWord(0); // e_entry, no entry point in .o file
427  WriteWord(0); // e_phoff, no program header for .o
428  WriteWord(0); // e_shoff = sec hdr table off in bytes
429 
430  // e_flags = whatever the target wants
431  W.write<uint32_t>(Asm.getELFHeaderEFlags());
432 
433  // e_ehsize = ELF header size
434  W.write<uint16_t>(is64Bit() ? sizeof(ELF::Elf64_Ehdr)
435  : sizeof(ELF::Elf32_Ehdr));
436 
437  W.write<uint16_t>(0); // e_phentsize = prog header entry size
438  W.write<uint16_t>(0); // e_phnum = # prog header entries = 0
439 
440  // e_shentsize = Section header entry size
441  W.write<uint16_t>(is64Bit() ? sizeof(ELF::Elf64_Shdr)
442  : sizeof(ELF::Elf32_Shdr));
443 
444  // e_shnum = # of section header ents
445  W.write<uint16_t>(0);
446 
447  // e_shstrndx = Section # of '.strtab'
448  assert(StringTableIndex < ELF::SHN_LORESERVE);
449  W.write<uint16_t>(StringTableIndex);
450 }
451 
452 uint64_t ELFWriter::SymbolValue(const MCSymbol &Sym,
453  const MCAsmLayout &Layout) {
454  if (Sym.isCommon())
455  return Sym.getCommonAlignment();
456 
457  uint64_t Res;
458  if (!Layout.getSymbolOffset(Sym, Res))
459  return 0;
460 
461  if (Layout.getAssembler().isThumbFunc(&Sym))
462  Res |= 1;
463 
464  return Res;
465 }
466 
467 static uint8_t mergeTypeForSet(uint8_t origType, uint8_t newType) {
468  uint8_t Type = newType;
469 
470  // Propagation rules:
471  // IFUNC > FUNC > OBJECT > NOTYPE
472  // TLS_OBJECT > OBJECT > NOTYPE
473  //
474  // dont let the new type degrade the old type
475  switch (origType) {
476  default:
477  break;
478  case ELF::STT_GNU_IFUNC:
479  if (Type == ELF::STT_FUNC || Type == ELF::STT_OBJECT ||
482  break;
483  case ELF::STT_FUNC:
484  if (Type == ELF::STT_OBJECT || Type == ELF::STT_NOTYPE ||
485  Type == ELF::STT_TLS)
487  break;
488  case ELF::STT_OBJECT:
489  if (Type == ELF::STT_NOTYPE)
491  break;
492  case ELF::STT_TLS:
493  if (Type == ELF::STT_OBJECT || Type == ELF::STT_NOTYPE ||
495  Type = ELF::STT_TLS;
496  break;
497  }
498 
499  return Type;
500 }
501 
502 static bool isIFunc(const MCSymbolELF *Symbol) {
503  while (Symbol->getType() != ELF::STT_GNU_IFUNC) {
504  const MCSymbolRefExpr *Value;
505  if (!Symbol->isVariable() ||
506  !(Value = dyn_cast<MCSymbolRefExpr>(Symbol->getVariableValue())) ||
507  Value->getKind() != MCSymbolRefExpr::VK_None ||
509  return false;
510  Symbol = &cast<MCSymbolELF>(Value->getSymbol());
511  }
512  return true;
513 }
514 
515 void ELFWriter::writeSymbol(SymbolTableWriter &Writer, uint32_t StringIndex,
516  ELFSymbolData &MSD, const MCAsmLayout &Layout) {
517  const auto &Symbol = cast<MCSymbolELF>(*MSD.Symbol);
518  const MCSymbolELF *Base =
519  cast_or_null<MCSymbolELF>(Layout.getBaseSymbol(Symbol));
520 
521  // This has to be in sync with when computeSymbolTable uses SHN_ABS or
522  // SHN_COMMON.
523  bool IsReserved = !Base || Symbol.isCommon();
524 
525  // Binding and Type share the same byte as upper and lower nibbles
526  uint8_t Binding = Symbol.getBinding();
527  uint8_t Type = Symbol.getType();
528  if (isIFunc(&Symbol))
530  if (Base) {
531  Type = mergeTypeForSet(Type, Base->getType());
532  }
533  uint8_t Info = (Binding << 4) | Type;
534 
535  // Other and Visibility share the same byte with Visibility using the lower
536  // 2 bits
537  uint8_t Visibility = Symbol.getVisibility();
538  uint8_t Other = Symbol.getOther() | Visibility;
539 
540  uint64_t Value = SymbolValue(*MSD.Symbol, Layout);
541  uint64_t Size = 0;
542 
543  const MCExpr *ESize = MSD.Symbol->getSize();
544  if (!ESize && Base) {
545  // For expressions like .set y, x+1, if y's size is unset, inherit from x.
546  ESize = Base->getSize();
547 
548  // For `.size x, 2; y = x; .size y, 1; z = y; z1 = z; .symver y, y@v1`, z,
549  // z1, and y@v1's st_size equals y's. However, `Base` is `x` which will give
550  // us 2. Follow the MCSymbolRefExpr assignment chain, which covers most
551  // needs. MCBinaryExpr is not handled.
552  const MCSymbolELF *Sym = &Symbol;
553  while (Sym->isVariable()) {
554  if (auto *Expr =
555  dyn_cast<MCSymbolRefExpr>(Sym->getVariableValue(false))) {
556  Sym = cast<MCSymbolELF>(&Expr->getSymbol());
557  if (!Sym->getSize())
558  continue;
559  ESize = Sym->getSize();
560  }
561  break;
562  }
563  }
564 
565  if (ESize) {
566  int64_t Res;
567  if (!ESize->evaluateKnownAbsolute(Res, Layout))
568  report_fatal_error("Size expression must be absolute.");
569  Size = Res;
570  }
571 
572  // Write out the symbol table entry
573  Writer.writeSymbol(StringIndex, Info, Value, Size, Other, MSD.SectionIndex,
574  IsReserved);
575 }
576 
577 bool ELFWriter::isInSymtab(const MCAsmLayout &Layout, const MCSymbolELF &Symbol,
578  bool Used, bool Renamed) {
579  if (Symbol.isVariable()) {
580  const MCExpr *Expr = Symbol.getVariableValue();
581  // Target Expressions that are always inlined do not appear in the symtab
582  if (const auto *T = dyn_cast<MCTargetExpr>(Expr))
583  if (T->inlineAssignedExpr())
584  return false;
585  if (const MCSymbolRefExpr *Ref = dyn_cast<MCSymbolRefExpr>(Expr)) {
586  if (Ref->getKind() == MCSymbolRefExpr::VK_WEAKREF)
587  return false;
588  }
589  }
590 
591  if (Used)
592  return true;
593 
594  if (Renamed)
595  return false;
596 
597  if (Symbol.isVariable() && Symbol.isUndefined()) {
598  // FIXME: this is here just to diagnose the case of a var = commmon_sym.
599  Layout.getBaseSymbol(Symbol);
600  return false;
601  }
602 
603  if (Symbol.isTemporary())
604  return false;
605 
606  if (Symbol.getType() == ELF::STT_SECTION)
607  return false;
608 
609  return true;
610 }
611 
612 void ELFWriter::computeSymbolTable(
613  MCAssembler &Asm, const MCAsmLayout &Layout,
614  const SectionIndexMapTy &SectionIndexMap, const RevGroupMapTy &RevGroupMap,
615  SectionOffsetsTy &SectionOffsets) {
616  MCContext &Ctx = Asm.getContext();
617  SymbolTableWriter Writer(*this, is64Bit());
618 
619  // Symbol table
620  unsigned EntrySize = is64Bit() ? ELF::SYMENTRY_SIZE64 : ELF::SYMENTRY_SIZE32;
621  MCSectionELF *SymtabSection =
622  Ctx.getELFSection(".symtab", ELF::SHT_SYMTAB, 0, EntrySize);
623  SymtabSection->setAlignment(is64Bit() ? Align(8) : Align(4));
624  SymbolTableIndex = addToSectionTable(SymtabSection);
625 
626  uint64_t SecStart = align(SymtabSection->getAlignment());
627 
628  // The first entry is the undefined symbol entry.
629  Writer.writeSymbol(0, 0, 0, 0, 0, 0, false);
630 
631  std::vector<ELFSymbolData> LocalSymbolData;
632  std::vector<ELFSymbolData> ExternalSymbolData;
634  Asm.getFileNames();
635  for (const std::pair<std::string, size_t> &F : FileNames)
636  StrTabBuilder.add(F.first);
637 
638  // Add the data for the symbols.
639  bool HasLargeSectionIndex = false;
640  for (auto It : llvm::enumerate(Asm.symbols())) {
641  const auto &Symbol = cast<MCSymbolELF>(It.value());
642  bool Used = Symbol.isUsedInReloc();
643  bool WeakrefUsed = Symbol.isWeakrefUsedInReloc();
644  bool isSignature = Symbol.isSignature();
645 
646  if (!isInSymtab(Layout, Symbol, Used || WeakrefUsed || isSignature,
647  OWriter.Renames.count(&Symbol)))
648  continue;
649 
650  if (Symbol.isTemporary() && Symbol.isUndefined()) {
651  Ctx.reportError(SMLoc(), "Undefined temporary symbol " + Symbol.getName());
652  continue;
653  }
654 
655  ELFSymbolData MSD;
656  MSD.Symbol = cast<MCSymbolELF>(&Symbol);
657  MSD.Order = It.index();
658 
659  bool Local = Symbol.getBinding() == ELF::STB_LOCAL;
660  assert(Local || !Symbol.isTemporary());
661 
662  if (Symbol.isAbsolute()) {
663  MSD.SectionIndex = ELF::SHN_ABS;
664  } else if (Symbol.isCommon()) {
665  if (Symbol.isTargetCommon()) {
666  MSD.SectionIndex = Symbol.getIndex();
667  } else {
668  assert(!Local);
669  MSD.SectionIndex = ELF::SHN_COMMON;
670  }
671  } else if (Symbol.isUndefined()) {
672  if (isSignature && !Used) {
673  MSD.SectionIndex = RevGroupMap.lookup(&Symbol);
674  if (MSD.SectionIndex >= ELF::SHN_LORESERVE)
675  HasLargeSectionIndex = true;
676  } else {
677  MSD.SectionIndex = ELF::SHN_UNDEF;
678  }
679  } else {
680  const MCSectionELF &Section =
681  static_cast<const MCSectionELF &>(Symbol.getSection());
682 
683  // We may end up with a situation when section symbol is technically
684  // defined, but should not be. That happens because we explicitly
685  // pre-create few .debug_* sections to have accessors.
686  // And if these sections were not really defined in the code, but were
687  // referenced, we simply error out.
688  if (!Section.isRegistered()) {
689  assert(static_cast<const MCSymbolELF &>(Symbol).getType() ==
691  Ctx.reportError(SMLoc(),
692  "Undefined section reference: " + Symbol.getName());
693  continue;
694  }
695 
696  if (Mode == NonDwoOnly && isDwoSection(Section))
697  continue;
698  MSD.SectionIndex = SectionIndexMap.lookup(&Section);
699  assert(MSD.SectionIndex && "Invalid section index!");
700  if (MSD.SectionIndex >= ELF::SHN_LORESERVE)
701  HasLargeSectionIndex = true;
702  }
703 
704  StringRef Name = Symbol.getName();
705 
706  // Sections have their own string table
707  if (Symbol.getType() != ELF::STT_SECTION) {
708  MSD.Name = Name;
709  StrTabBuilder.add(Name);
710  }
711 
712  if (Local)
713  LocalSymbolData.push_back(MSD);
714  else
715  ExternalSymbolData.push_back(MSD);
716  }
717 
718  // This holds the .symtab_shndx section index.
719  unsigned SymtabShndxSectionIndex = 0;
720 
721  if (HasLargeSectionIndex) {
722  MCSectionELF *SymtabShndxSection =
723  Ctx.getELFSection(".symtab_shndx", ELF::SHT_SYMTAB_SHNDX, 0, 4);
724  SymtabShndxSectionIndex = addToSectionTable(SymtabShndxSection);
725  SymtabShndxSection->setAlignment(Align(4));
726  }
727 
728  StrTabBuilder.finalize();
729 
730  // Make the first STT_FILE precede previous local symbols.
731  unsigned Index = 1;
732  auto FileNameIt = FileNames.begin();
733  if (!FileNames.empty())
734  FileNames[0].second = 0;
735 
736  for (ELFSymbolData &MSD : LocalSymbolData) {
737  // Emit STT_FILE symbols before their associated local symbols.
738  for (; FileNameIt != FileNames.end() && FileNameIt->second <= MSD.Order;
739  ++FileNameIt) {
740  Writer.writeSymbol(StrTabBuilder.getOffset(FileNameIt->first),
742  ELF::SHN_ABS, true);
743  ++Index;
744  }
745 
746  unsigned StringIndex = MSD.Symbol->getType() == ELF::STT_SECTION
747  ? 0
748  : StrTabBuilder.getOffset(MSD.Name);
749  MSD.Symbol->setIndex(Index++);
750  writeSymbol(Writer, StringIndex, MSD, Layout);
751  }
752  for (; FileNameIt != FileNames.end(); ++FileNameIt) {
753  Writer.writeSymbol(StrTabBuilder.getOffset(FileNameIt->first),
755  ELF::SHN_ABS, true);
756  ++Index;
757  }
758 
759  // Write the symbol table entries.
760  LastLocalSymbolIndex = Index;
761 
762  for (ELFSymbolData &MSD : ExternalSymbolData) {
763  unsigned StringIndex = StrTabBuilder.getOffset(MSD.Name);
764  MSD.Symbol->setIndex(Index++);
765  writeSymbol(Writer, StringIndex, MSD, Layout);
766  assert(MSD.Symbol->getBinding() != ELF::STB_LOCAL);
767  }
768 
769  uint64_t SecEnd = W.OS.tell();
770  SectionOffsets[SymtabSection] = std::make_pair(SecStart, SecEnd);
771 
772  ArrayRef<uint32_t> ShndxIndexes = Writer.getShndxIndexes();
773  if (ShndxIndexes.empty()) {
774  assert(SymtabShndxSectionIndex == 0);
775  return;
776  }
777  assert(SymtabShndxSectionIndex != 0);
778 
779  SecStart = W.OS.tell();
780  const MCSectionELF *SymtabShndxSection =
781  SectionTable[SymtabShndxSectionIndex - 1];
782  for (uint32_t Index : ShndxIndexes)
783  write(Index);
784  SecEnd = W.OS.tell();
785  SectionOffsets[SymtabShndxSection] = std::make_pair(SecStart, SecEnd);
786 }
787 
788 void ELFWriter::writeAddrsigSection() {
789  for (const MCSymbol *Sym : OWriter.AddrsigSyms)
790  encodeULEB128(Sym->getIndex(), W.OS);
791 }
792 
793 MCSectionELF *ELFWriter::createRelocationSection(MCContext &Ctx,
794  const MCSectionELF &Sec) {
795  if (OWriter.Relocations[&Sec].empty())
796  return nullptr;
797 
798  const StringRef SectionName = Sec.getName();
799  bool Rela = usesRela(Sec);
800  std::string RelaSectionName = Rela ? ".rela" : ".rel";
801  RelaSectionName += SectionName;
802 
803  unsigned EntrySize;
804  if (Rela)
805  EntrySize = is64Bit() ? sizeof(ELF::Elf64_Rela) : sizeof(ELF::Elf32_Rela);
806  else
807  EntrySize = is64Bit() ? sizeof(ELF::Elf64_Rel) : sizeof(ELF::Elf32_Rel);
808 
809  unsigned Flags = ELF::SHF_INFO_LINK;
810  if (Sec.getFlags() & ELF::SHF_GROUP)
811  Flags = ELF::SHF_GROUP;
812 
813  MCSectionELF *RelaSection = Ctx.createELFRelSection(
814  RelaSectionName, Rela ? ELF::SHT_RELA : ELF::SHT_REL, Flags, EntrySize,
815  Sec.getGroup(), &Sec);
816  RelaSection->setAlignment(is64Bit() ? Align(8) : Align(4));
817  return RelaSection;
818 }
819 
820 // Include the debug info compression header.
821 bool ELFWriter::maybeWriteCompression(
822  uint64_t Size, SmallVectorImpl<char> &CompressedContents, bool ZLibStyle,
823  unsigned Alignment) {
824  if (ZLibStyle) {
825  uint64_t HdrSize =
826  is64Bit() ? sizeof(ELF::Elf32_Chdr) : sizeof(ELF::Elf64_Chdr);
827  if (Size <= HdrSize + CompressedContents.size())
828  return false;
829  // Platform specific header is followed by compressed data.
830  if (is64Bit()) {
831  // Write Elf64_Chdr header.
833  write(static_cast<ELF::Elf64_Word>(0)); // ch_reserved field.
834  write(static_cast<ELF::Elf64_Xword>(Size));
835  write(static_cast<ELF::Elf64_Xword>(Alignment));
836  } else {
837  // Write Elf32_Chdr header otherwise.
839  write(static_cast<ELF::Elf32_Word>(Size));
840  write(static_cast<ELF::Elf32_Word>(Alignment));
841  }
842  return true;
843  }
844 
845  // "ZLIB" followed by 8 bytes representing the uncompressed size of the section,
846  // useful for consumers to preallocate a buffer to decompress into.
847  const StringRef Magic = "ZLIB";
848  if (Size <= Magic.size() + sizeof(Size) + CompressedContents.size())
849  return false;
850  W.OS << Magic;
852  return true;
853 }
854 
855 void ELFWriter::writeSectionData(const MCAssembler &Asm, MCSection &Sec,
856  const MCAsmLayout &Layout) {
857  MCSectionELF &Section = static_cast<MCSectionELF &>(Sec);
858  StringRef SectionName = Section.getName();
859 
860  auto &MC = Asm.getContext();
861  const auto &MAI = MC.getAsmInfo();
862 
863  bool CompressionEnabled =
864  MAI->compressDebugSections() != DebugCompressionType::None;
865  if (!CompressionEnabled || !SectionName.startswith(".debug_")) {
866  Asm.writeSectionData(W.OS, &Section, Layout);
867  return;
868  }
869 
870  assert((MAI->compressDebugSections() == DebugCompressionType::Z ||
871  MAI->compressDebugSections() == DebugCompressionType::GNU) &&
872  "expected zlib or zlib-gnu style compression");
873 
874  SmallVector<char, 128> UncompressedData;
875  raw_svector_ostream VecOS(UncompressedData);
876  Asm.writeSectionData(VecOS, &Section, Layout);
877 
878  SmallVector<char, 128> CompressedContents;
879  zlib::compress(StringRef(UncompressedData.data(), UncompressedData.size()),
880  CompressedContents);
881 
882  bool ZlibStyle = MAI->compressDebugSections() == DebugCompressionType::Z;
883  if (!maybeWriteCompression(UncompressedData.size(), CompressedContents,
884  ZlibStyle, Sec.getAlignment())) {
885  W.OS << UncompressedData;
886  return;
887  }
888 
889  if (ZlibStyle) {
890  // Set the compressed flag. That is zlib style.
891  Section.setFlags(Section.getFlags() | ELF::SHF_COMPRESSED);
892  // Alignment field should reflect the requirements of
893  // the compressed section header.
894  Section.setAlignment(is64Bit() ? Align(8) : Align(4));
895  } else {
896  // Add "z" prefix to section name. This is zlib-gnu style.
897  MC.renameELFSection(&Section, (".z" + SectionName.drop_front(1)).str());
898  }
899  W.OS << CompressedContents;
900 }
901 
902 void ELFWriter::WriteSecHdrEntry(uint32_t Name, uint32_t Type, uint64_t Flags,
903  uint64_t Address, uint64_t Offset,
905  uint64_t Alignment, uint64_t EntrySize) {
906  W.write<uint32_t>(Name); // sh_name: index into string table
907  W.write<uint32_t>(Type); // sh_type
908  WriteWord(Flags); // sh_flags
909  WriteWord(Address); // sh_addr
910  WriteWord(Offset); // sh_offset
911  WriteWord(Size); // sh_size
912  W.write<uint32_t>(Link); // sh_link
913  W.write<uint32_t>(Info); // sh_info
914  WriteWord(Alignment); // sh_addralign
915  WriteWord(EntrySize); // sh_entsize
916 }
917 
918 void ELFWriter::writeRelocations(const MCAssembler &Asm,
919  const MCSectionELF &Sec) {
920  std::vector<ELFRelocationEntry> &Relocs = OWriter.Relocations[&Sec];
921 
922  // We record relocations by pushing to the end of a vector. Reverse the vector
923  // to get the relocations in the order they were created.
924  // In most cases that is not important, but it can be for special sections
925  // (.eh_frame) or specific relocations (TLS optimizations on SystemZ).
926  std::reverse(Relocs.begin(), Relocs.end());
927 
928  // Sort the relocation entries. MIPS needs this.
929  OWriter.TargetObjectWriter->sortRelocs(Asm, Relocs);
930 
931  const bool Rela = usesRela(Sec);
932  for (unsigned i = 0, e = Relocs.size(); i != e; ++i) {
933  const ELFRelocationEntry &Entry = Relocs[e - i - 1];
934  unsigned Index = Entry.Symbol ? Entry.Symbol->getIndex() : 0;
935 
936  if (is64Bit()) {
937  write(Entry.Offset);
938  if (OWriter.TargetObjectWriter->getEMachine() == ELF::EM_MIPS) {
939  write(uint32_t(Index));
940 
941  write(OWriter.TargetObjectWriter->getRSsym(Entry.Type));
942  write(OWriter.TargetObjectWriter->getRType3(Entry.Type));
943  write(OWriter.TargetObjectWriter->getRType2(Entry.Type));
944  write(OWriter.TargetObjectWriter->getRType(Entry.Type));
945  } else {
946  struct ELF::Elf64_Rela ERE64;
947  ERE64.setSymbolAndType(Index, Entry.Type);
948  write(ERE64.r_info);
949  }
950  if (Rela)
951  write(Entry.Addend);
952  } else {
953  write(uint32_t(Entry.Offset));
954 
955  struct ELF::Elf32_Rela ERE32;
956  ERE32.setSymbolAndType(Index, Entry.Type);
957  write(ERE32.r_info);
958 
959  if (Rela)
960  write(uint32_t(Entry.Addend));
961 
962  if (OWriter.TargetObjectWriter->getEMachine() == ELF::EM_MIPS) {
963  if (uint32_t RType =
964  OWriter.TargetObjectWriter->getRType2(Entry.Type)) {
965  write(uint32_t(Entry.Offset));
966 
967  ERE32.setSymbolAndType(0, RType);
968  write(ERE32.r_info);
969  write(uint32_t(0));
970  }
971  if (uint32_t RType =
972  OWriter.TargetObjectWriter->getRType3(Entry.Type)) {
973  write(uint32_t(Entry.Offset));
974 
975  ERE32.setSymbolAndType(0, RType);
976  write(ERE32.r_info);
977  write(uint32_t(0));
978  }
979  }
980  }
981  }
982 }
983 
984 void ELFWriter::writeSection(const SectionIndexMapTy &SectionIndexMap,
985  uint32_t GroupSymbolIndex, uint64_t Offset,
986  uint64_t Size, const MCSectionELF &Section) {
987  uint64_t sh_link = 0;
988  uint64_t sh_info = 0;
989 
990  switch(Section.getType()) {
991  default:
992  // Nothing to do.
993  break;
994 
995  case ELF::SHT_DYNAMIC:
996  llvm_unreachable("SHT_DYNAMIC in a relocatable object");
997 
998  case ELF::SHT_REL:
999  case ELF::SHT_RELA: {
1000  sh_link = SymbolTableIndex;
1001  assert(sh_link && ".symtab not found");
1002  const MCSection *InfoSection = Section.getLinkedToSection();
1003  sh_info = SectionIndexMap.lookup(cast<MCSectionELF>(InfoSection));
1004  break;
1005  }
1006 
1007  case ELF::SHT_SYMTAB:
1008  sh_link = StringTableIndex;
1009  sh_info = LastLocalSymbolIndex;
1010  break;
1011 
1012  case ELF::SHT_SYMTAB_SHNDX:
1014  case ELF::SHT_LLVM_ADDRSIG:
1015  sh_link = SymbolTableIndex;
1016  break;
1017 
1018  case ELF::SHT_GROUP:
1019  sh_link = SymbolTableIndex;
1020  sh_info = GroupSymbolIndex;
1021  break;
1022  }
1023 
1024  if (Section.getFlags() & ELF::SHF_LINK_ORDER) {
1025  // If the value in the associated metadata is not a definition, Sym will be
1026  // undefined. Represent this with sh_link=0.
1027  const MCSymbol *Sym = Section.getLinkedToSymbol();
1028  if (Sym && Sym->isInSection()) {
1029  const MCSectionELF *Sec = cast<MCSectionELF>(&Sym->getSection());
1030  sh_link = SectionIndexMap.lookup(Sec);
1031  }
1032  }
1033 
1034  WriteSecHdrEntry(StrTabBuilder.getOffset(Section.getName()),
1035  Section.getType(), Section.getFlags(), 0, Offset, Size,
1036  sh_link, sh_info, Section.getAlignment(),
1037  Section.getEntrySize());
1038 }
1039 
1040 void ELFWriter::writeSectionHeader(
1041  const MCAsmLayout &Layout, const SectionIndexMapTy &SectionIndexMap,
1042  const SectionOffsetsTy &SectionOffsets) {
1043  const unsigned NumSections = SectionTable.size();
1044 
1045  // Null section first.
1046  uint64_t FirstSectionSize =
1047  (NumSections + 1) >= ELF::SHN_LORESERVE ? NumSections + 1 : 0;
1048  WriteSecHdrEntry(0, 0, 0, 0, 0, FirstSectionSize, 0, 0, 0, 0);
1049 
1050  for (const MCSectionELF *Section : SectionTable) {
1051  uint32_t GroupSymbolIndex;
1052  unsigned Type = Section->getType();
1053  if (Type != ELF::SHT_GROUP)
1054  GroupSymbolIndex = 0;
1055  else
1056  GroupSymbolIndex = Section->getGroup()->getIndex();
1057 
1058  const std::pair<uint64_t, uint64_t> &Offsets =
1059  SectionOffsets.find(Section)->second;
1060  uint64_t Size;
1061  if (Type == ELF::SHT_NOBITS)
1063  else
1064  Size = Offsets.second - Offsets.first;
1065 
1066  writeSection(SectionIndexMap, GroupSymbolIndex, Offsets.first, Size,
1067  *Section);
1068  }
1069 }
1070 
1071 uint64_t ELFWriter::writeObject(MCAssembler &Asm, const MCAsmLayout &Layout) {
1072  uint64_t StartOffset = W.OS.tell();
1073 
1074  MCContext &Ctx = Asm.getContext();
1075  MCSectionELF *StrtabSection =
1076  Ctx.getELFSection(".strtab", ELF::SHT_STRTAB, 0);
1077  StringTableIndex = addToSectionTable(StrtabSection);
1078 
1079  RevGroupMapTy RevGroupMap;
1080  SectionIndexMapTy SectionIndexMap;
1081 
1082  std::map<const MCSymbol *, std::vector<const MCSectionELF *>> GroupMembers;
1083 
1084  // Write out the ELF header ...
1085  writeHeader(Asm);
1086 
1087  // ... then the sections ...
1088  SectionOffsetsTy SectionOffsets;
1089  std::vector<MCSectionELF *> Groups;
1090  std::vector<MCSectionELF *> Relocations;
1091  for (MCSection &Sec : Asm) {
1092  MCSectionELF &Section = static_cast<MCSectionELF &>(Sec);
1093  if (Mode == NonDwoOnly && isDwoSection(Section))
1094  continue;
1095  if (Mode == DwoOnly && !isDwoSection(Section))
1096  continue;
1097 
1098  // Remember the offset into the file for this section.
1099  const uint64_t SecStart = align(Section.getAlignment());
1100 
1101  const MCSymbolELF *SignatureSymbol = Section.getGroup();
1102  writeSectionData(Asm, Section, Layout);
1103 
1104  uint64_t SecEnd = W.OS.tell();
1105  SectionOffsets[&Section] = std::make_pair(SecStart, SecEnd);
1106 
1107  MCSectionELF *RelSection = createRelocationSection(Ctx, Section);
1108 
1109  if (SignatureSymbol) {
1110  unsigned &GroupIdx = RevGroupMap[SignatureSymbol];
1111  if (!GroupIdx) {
1112  MCSectionELF *Group =
1113  Ctx.createELFGroupSection(SignatureSymbol, Section.isComdat());
1114  GroupIdx = addToSectionTable(Group);
1115  Group->setAlignment(Align(4));
1116  Groups.push_back(Group);
1117  }
1118  std::vector<const MCSectionELF *> &Members =
1119  GroupMembers[SignatureSymbol];
1120  Members.push_back(&Section);
1121  if (RelSection)
1122  Members.push_back(RelSection);
1123  }
1124 
1125  SectionIndexMap[&Section] = addToSectionTable(&Section);
1126  if (RelSection) {
1127  SectionIndexMap[RelSection] = addToSectionTable(RelSection);
1128  Relocations.push_back(RelSection);
1129  }
1130 
1131  OWriter.TargetObjectWriter->addTargetSectionFlags(Ctx, Section);
1132  }
1133 
1134  for (MCSectionELF *Group : Groups) {
1135  // Remember the offset into the file for this section.
1136  const uint64_t SecStart = align(Group->getAlignment());
1137 
1138  const MCSymbol *SignatureSymbol = Group->getGroup();
1139  assert(SignatureSymbol);
1140  write(uint32_t(Group->isComdat() ? unsigned(ELF::GRP_COMDAT) : 0));
1141  for (const MCSectionELF *Member : GroupMembers[SignatureSymbol]) {
1142  uint32_t SecIndex = SectionIndexMap.lookup(Member);
1143  write(SecIndex);
1144  }
1145 
1146  uint64_t SecEnd = W.OS.tell();
1147  SectionOffsets[Group] = std::make_pair(SecStart, SecEnd);
1148  }
1149 
1150  if (Mode == DwoOnly) {
1151  // dwo files don't have symbol tables or relocations, but they do have
1152  // string tables.
1153  StrTabBuilder.finalize();
1154  } else {
1155  MCSectionELF *AddrsigSection;
1156  if (OWriter.EmitAddrsigSection) {
1157  AddrsigSection = Ctx.getELFSection(".llvm_addrsig", ELF::SHT_LLVM_ADDRSIG,
1159  addToSectionTable(AddrsigSection);
1160  }
1161 
1162  // Compute symbol table information.
1163  computeSymbolTable(Asm, Layout, SectionIndexMap, RevGroupMap,
1164  SectionOffsets);
1165 
1166  for (MCSectionELF *RelSection : Relocations) {
1167  // Remember the offset into the file for this section.
1168  const uint64_t SecStart = align(RelSection->getAlignment());
1169 
1170  writeRelocations(Asm,
1171  cast<MCSectionELF>(*RelSection->getLinkedToSection()));
1172 
1173  uint64_t SecEnd = W.OS.tell();
1174  SectionOffsets[RelSection] = std::make_pair(SecStart, SecEnd);
1175  }
1176 
1177  if (OWriter.EmitAddrsigSection) {
1178  uint64_t SecStart = W.OS.tell();
1179  writeAddrsigSection();
1180  uint64_t SecEnd = W.OS.tell();
1181  SectionOffsets[AddrsigSection] = std::make_pair(SecStart, SecEnd);
1182  }
1183  }
1184 
1185  {
1186  uint64_t SecStart = W.OS.tell();
1187  StrTabBuilder.write(W.OS);
1188  SectionOffsets[StrtabSection] = std::make_pair(SecStart, W.OS.tell());
1189  }
1190 
1191  const uint64_t SectionHeaderOffset = align(is64Bit() ? 8 : 4);
1192 
1193  // ... then the section header table ...
1194  writeSectionHeader(Layout, SectionIndexMap, SectionOffsets);
1195 
1196  uint16_t NumSections = support::endian::byte_swap<uint16_t>(
1197  (SectionTable.size() + 1 >= ELF::SHN_LORESERVE) ? (uint16_t)ELF::SHN_UNDEF
1198  : SectionTable.size() + 1,
1199  W.Endian);
1200  unsigned NumSectionsOffset;
1201 
1202  auto &Stream = static_cast<raw_pwrite_stream &>(W.OS);
1203  if (is64Bit()) {
1204  uint64_t Val =
1205  support::endian::byte_swap<uint64_t>(SectionHeaderOffset, W.Endian);
1206  Stream.pwrite(reinterpret_cast<char *>(&Val), sizeof(Val),
1207  offsetof(ELF::Elf64_Ehdr, e_shoff));
1208  NumSectionsOffset = offsetof(ELF::Elf64_Ehdr, e_shnum);
1209  } else {
1210  uint32_t Val =
1211  support::endian::byte_swap<uint32_t>(SectionHeaderOffset, W.Endian);
1212  Stream.pwrite(reinterpret_cast<char *>(&Val), sizeof(Val),
1213  offsetof(ELF::Elf32_Ehdr, e_shoff));
1214  NumSectionsOffset = offsetof(ELF::Elf32_Ehdr, e_shnum);
1215  }
1216  Stream.pwrite(reinterpret_cast<char *>(&NumSections), sizeof(NumSections),
1217  NumSectionsOffset);
1218 
1219  return W.OS.tell() - StartOffset;
1220 }
1221 
1222 bool ELFObjectWriter::hasRelocationAddend() const {
1223  return TargetObjectWriter->hasRelocationAddend();
1224 }
1225 
1226 void ELFObjectWriter::executePostLayoutBinding(MCAssembler &Asm,
1227  const MCAsmLayout &Layout) {
1228  // The presence of symbol versions causes undefined symbols and
1229  // versions declared with @@@ to be renamed.
1230  for (const MCAssembler::Symver &S : Asm.Symvers) {
1231  StringRef AliasName = S.Name;
1232  const auto &Symbol = cast<MCSymbolELF>(*S.Sym);
1233  size_t Pos = AliasName.find('@');
1234  assert(Pos != StringRef::npos);
1235 
1236  StringRef Prefix = AliasName.substr(0, Pos);
1237  StringRef Rest = AliasName.substr(Pos);
1238  StringRef Tail = Rest;
1239  if (Rest.startswith("@@@"))
1240  Tail = Rest.substr(Symbol.isUndefined() ? 2 : 1);
1241 
1242  auto *Alias =
1243  cast<MCSymbolELF>(Asm.getContext().getOrCreateSymbol(Prefix + Tail));
1244  Asm.registerSymbol(*Alias);
1245  const MCExpr *Value = MCSymbolRefExpr::create(&Symbol, Asm.getContext());
1246  Alias->setVariableValue(Value);
1247 
1248  // Aliases defined with .symvar copy the binding from the symbol they alias.
1249  // This is the first place we are able to copy this information.
1250  Alias->setBinding(Symbol.getBinding());
1251  Alias->setVisibility(Symbol.getVisibility());
1252  Alias->setOther(Symbol.getOther());
1253 
1254  if (!Symbol.isUndefined() && S.KeepOriginalSym)
1255  continue;
1256 
1257  if (Symbol.isUndefined() && Rest.startswith("@@") &&
1258  !Rest.startswith("@@@")) {
1259  Asm.getContext().reportError(S.Loc, "default version symbol " +
1260  AliasName + " must be defined");
1261  continue;
1262  }
1263 
1264  if (Renames.count(&Symbol) && Renames[&Symbol] != Alias) {
1265  Asm.getContext().reportError(S.Loc, Twine("multiple versions for ") +
1266  Symbol.getName());
1267  continue;
1268  }
1269 
1270  Renames.insert(std::make_pair(&Symbol, Alias));
1271  }
1272 
1273  for (const MCSymbol *&Sym : AddrsigSyms) {
1274  if (const MCSymbol *R = Renames.lookup(cast<MCSymbolELF>(Sym)))
1275  Sym = R;
1276  if (Sym->isInSection() && Sym->getName().startswith(".L"))
1277  Sym = Sym->getSection().getBeginSymbol();
1278  Sym->setUsedInReloc();
1279  }
1280 }
1281 
1282 // It is always valid to create a relocation with a symbol. It is preferable
1283 // to use a relocation with a section if that is possible. Using the section
1284 // allows us to omit some local symbols from the symbol table.
1285 bool ELFObjectWriter::shouldRelocateWithSymbol(const MCAssembler &Asm,
1286  const MCSymbolRefExpr *RefA,
1287  const MCSymbolELF *Sym,
1288  uint64_t C,
1289  unsigned Type) const {
1290  // A PCRel relocation to an absolute value has no symbol (or section). We
1291  // represent that with a relocation to a null section.
1292  if (!RefA)
1293  return false;
1294 
1296  switch (Kind) {
1297  default:
1298  break;
1299  // The .odp creation emits a relocation against the symbol ".TOC." which
1300  // create a R_PPC64_TOC relocation. However the relocation symbol name
1301  // in final object creation should be NULL, since the symbol does not
1302  // really exist, it is just the reference to TOC base for the current
1303  // object file. Since the symbol is undefined, returning false results
1304  // in a relocation with a null section which is the desired result.
1305  case MCSymbolRefExpr::VK_PPC_TOCBASE:
1306  return false;
1307 
1308  // These VariantKind cause the relocation to refer to something other than
1309  // the symbol itself, like a linker generated table. Since the address of
1310  // symbol is not relevant, we cannot replace the symbol with the
1311  // section and patch the difference in the addend.
1312  case MCSymbolRefExpr::VK_GOT:
1313  case MCSymbolRefExpr::VK_PLT:
1314  case MCSymbolRefExpr::VK_GOTPCREL:
1315  case MCSymbolRefExpr::VK_GOTPCREL_NORELAX:
1316  case MCSymbolRefExpr::VK_PPC_GOT_LO:
1317  case MCSymbolRefExpr::VK_PPC_GOT_HI:
1318  case MCSymbolRefExpr::VK_PPC_GOT_HA:
1319  return true;
1320  }
1321 
1322  // An undefined symbol is not in any section, so the relocation has to point
1323  // to the symbol itself.
1324  assert(Sym && "Expected a symbol");
1325  if (Sym->isUndefined())
1326  return true;
1327 
1328  unsigned Binding = Sym->getBinding();
1329  switch(Binding) {
1330  default:
1331  llvm_unreachable("Invalid Binding");
1332  case ELF::STB_LOCAL:
1333  break;
1334  case ELF::STB_WEAK:
1335  // If the symbol is weak, it might be overridden by a symbol in another
1336  // file. The relocation has to point to the symbol so that the linker
1337  // can update it.
1338  return true;
1339  case ELF::STB_GLOBAL:
1340  case ELF::STB_GNU_UNIQUE:
1341  // Global ELF symbols can be preempted by the dynamic linker. The relocation
1342  // has to point to the symbol for a reason analogous to the STB_WEAK case.
1343  return true;
1344  }
1345 
1346  // Keep symbol type for a local ifunc because it may result in an IRELATIVE
1347  // reloc that the dynamic loader will use to resolve the address at startup
1348  // time.
1349  if (Sym->getType() == ELF::STT_GNU_IFUNC)
1350  return true;
1351 
1352  // If a relocation points to a mergeable section, we have to be careful.
1353  // If the offset is zero, a relocation with the section will encode the
1354  // same information. With a non-zero offset, the situation is different.
1355  // For example, a relocation can point 42 bytes past the end of a string.
1356  // If we change such a relocation to use the section, the linker would think
1357  // that it pointed to another string and subtracting 42 at runtime will
1358  // produce the wrong value.
1359  if (Sym->isInSection()) {
1360  auto &Sec = cast<MCSectionELF>(Sym->getSection());
1361  unsigned Flags = Sec.getFlags();
1362  if (Flags & ELF::SHF_MERGE) {
1363  if (C != 0)
1364  return true;
1365 
1366  // gold<2.34 incorrectly ignored the addend for R_386_GOTOFF (9)
1367  // (http://sourceware.org/PR16794).
1368  if (TargetObjectWriter->getEMachine() == ELF::EM_386 &&
1369  Type == ELF::R_386_GOTOFF)
1370  return true;
1371 
1372  // ld.lld handles R_MIPS_HI16/R_MIPS_LO16 separately, not as a whole, so
1373  // it doesn't know that an R_MIPS_HI16 with implicit addend 1 and an
1374  // R_MIPS_LO16 with implicit addend -32768 represents 32768, which is in
1375  // range of a MergeInputSection. We could introduce a new RelExpr member
1376  // (like R_RISCV_PC_INDIRECT for R_RISCV_PCREL_HI20 / R_RISCV_PCREL_LO12)
1377  // but the complexity is unnecessary given that GNU as keeps the original
1378  // symbol for this case as well.
1379  if (TargetObjectWriter->getEMachine() == ELF::EM_MIPS &&
1380  !hasRelocationAddend())
1381  return true;
1382  }
1383 
1384  // Most TLS relocations use a got, so they need the symbol. Even those that
1385  // are just an offset (@tpoff), require a symbol in gold versions before
1386  // 5efeedf61e4fe720fd3e9a08e6c91c10abb66d42 (2014-09-26) which fixed
1387  // http://sourceware.org/PR16773.
1388  if (Flags & ELF::SHF_TLS)
1389  return true;
1390  }
1391 
1392  // If the symbol is a thumb function the final relocation must set the lowest
1393  // bit. With a symbol that is done by just having the symbol have that bit
1394  // set, so we would lose the bit if we relocated with the section.
1395  // FIXME: We could use the section but add the bit to the relocation value.
1396  if (Asm.isThumbFunc(Sym))
1397  return true;
1398 
1399  if (TargetObjectWriter->needsRelocateWithSymbol(*Sym, Type))
1400  return true;
1401  return false;
1402 }
1403 
1404 void ELFObjectWriter::recordRelocation(MCAssembler &Asm,
1405  const MCAsmLayout &Layout,
1406  const MCFragment *Fragment,
1407  const MCFixup &Fixup, MCValue Target,
1408  uint64_t &FixedValue) {
1409  MCAsmBackend &Backend = Asm.getBackend();
1410  bool IsPCRel = Backend.getFixupKindInfo(Fixup.getKind()).Flags &
1411  MCFixupKindInfo::FKF_IsPCRel;
1412  const MCSectionELF &FixupSection = cast<MCSectionELF>(*Fragment->getParent());
1413  uint64_t C = Target.getConstant();
1414  uint64_t FixupOffset = Layout.getFragmentOffset(Fragment) + Fixup.getOffset();
1415  MCContext &Ctx = Asm.getContext();
1416 
1417  if (const MCSymbolRefExpr *RefB = Target.getSymB()) {
1418  const auto &SymB = cast<MCSymbolELF>(RefB->getSymbol());
1419  if (SymB.isUndefined()) {
1420  Ctx.reportError(Fixup.getLoc(),
1421  Twine("symbol '") + SymB.getName() +
1422  "' can not be undefined in a subtraction expression");
1423  return;
1424  }
1425 
1426  assert(!SymB.isAbsolute() && "Should have been folded");
1427  const MCSection &SecB = SymB.getSection();
1428  if (&SecB != &FixupSection) {
1429  Ctx.reportError(Fixup.getLoc(),
1430  "Cannot represent a difference across sections");
1431  return;
1432  }
1433 
1434  assert(!IsPCRel && "should have been folded");
1435  IsPCRel = true;
1436  C += FixupOffset - Layout.getSymbolOffset(SymB);
1437  }
1438 
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;
1442 
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());
1449  ViaWeakRef = true;
1450  }
1451  }
1452  }
1453 
1454  const MCSectionELF *SecA = (SymA && SymA->isInSection())
1455  ? cast<MCSectionELF>(&SymA->getSection())
1456  : nullptr;
1457  if (!checkRelocation(Ctx, Fixup.getLoc(), &FixupSection, SecA))
1458  return;
1459 
1460  unsigned Type = TargetObjectWriter->getRelocType(Ctx, Target, Fixup, IsPCRel);
1461  const auto *Parent = cast<MCSectionELF>(Fragment->getParent());
1462  // Emiting relocation with sybmol for CG Profile to help with --cg-profile.
1463  bool RelocateWithSymbol =
1464  shouldRelocateWithSymbol(Asm, RefA, SymA, C, Type) ||
1465  (Parent->getType() == ELF::SHT_LLVM_CALL_GRAPH_PROFILE);
1466  uint64_t Addend = 0;
1467 
1468  FixedValue = !RelocateWithSymbol && SymA && !SymA->isUndefined()
1469  ? C + Layout.getSymbolOffset(*SymA)
1470  : C;
1471  if (hasRelocationAddend()) {
1472  Addend = FixedValue;
1473  FixedValue = 0;
1474  }
1475 
1476  if (!RelocateWithSymbol) {
1477  const auto *SectionSymbol =
1478  SecA ? cast<MCSymbolELF>(SecA->getBeginSymbol()) : nullptr;
1479  if (SectionSymbol)
1480  SectionSymbol->setUsedInReloc();
1481  ELFRelocationEntry Rec(FixupOffset, SectionSymbol, Type, Addend, SymA, C);
1482  Relocations[&FixupSection].push_back(Rec);
1483  return;
1484  }
1485 
1486  const MCSymbolELF *RenamedSymA = SymA;
1487  if (SymA) {
1488  if (const MCSymbolELF *R = Renames.lookup(SymA))
1489  RenamedSymA = R;
1490 
1491  if (ViaWeakRef)
1492  RenamedSymA->setIsWeakrefUsedInReloc();
1493  else
1494  RenamedSymA->setUsedInReloc();
1495  }
1496  ELFRelocationEntry Rec(FixupOffset, RenamedSymA, Type, Addend, SymA, C);
1497  Relocations[&FixupSection].push_back(Rec);
1498 }
1499 
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);
1504  if (IsPCRel) {
1505  assert(!InSet);
1506  if (SymA.getBinding() != ELF::STB_LOCAL ||
1507  SymA.getType() == ELF::STT_GNU_IFUNC)
1508  return false;
1509  }
1510  return MCObjectWriter::isSymbolRefDifferenceFullyResolvedImpl(Asm, SymA, FB,
1511  InSet, IsPCRel);
1512 }
1513 
1514 std::unique_ptr<MCObjectWriter>
1515 llvm::createELFObjectWriter(std::unique_ptr<MCELFObjectTargetWriter> MOTW,
1516  raw_pwrite_stream &OS, bool IsLittleEndian) {
1517  return std::make_unique<ELFSingleObjectWriter>(std::move(MOTW), OS,
1518  IsLittleEndian);
1519 }
1520 
1521 std::unique_ptr<MCObjectWriter>
1522 llvm::createELFDwoObjectWriter(std::unique_ptr<MCELFObjectTargetWriter> MOTW,
1524  bool IsLittleEndian) {
1525  return std::make_unique<ELFDwoObjectWriter>(std::move(MOTW), OS, DwoOS,
1526  IsLittleEndian);
1527 }
llvm::Check::Size
@ Size
Definition: FileCheck.h:77
llvm::MCSymbolRefExpr::getKind
VariantKind getKind() const
Definition: MCExpr.h:401
i
i
Definition: README.txt:29
llvm::alignTo
uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
Definition: Alignment.h:156
llvm::ELF::STT_FUNC
@ STT_FUNC
Definition: ELF.h:1205
Compression.h
llvm::StringRef::startswith
LLVM_NODISCARD bool startswith(StringRef Prefix) const
Check if this string starts with the given Prefix.
Definition: StringRef.h:290
MathExtras.h
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:17
llvm::MCSymbol
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:41
llvm::createELFObjectWriter
std::unique_ptr< MCObjectWriter > createELFObjectWriter(std::unique_ptr< MCELFObjectTargetWriter > MOTW, raw_pwrite_stream &OS, bool IsLittleEndian)
Construct a new ELF writer instance.
Definition: ELFObjectWriter.cpp:1515
llvm::MCAsmBackend::getFixupKindInfo
virtual const MCFixupKindInfo & getFixupKindInfo(MCFixupKind Kind) const
Get information on a fixup kind.
Definition: MCAsmBackend.cpp:82
MCTargetOptions.h
llvm::cl::Prefix
@ Prefix
Definition: CommandLine.h:160
llvm::StringRef::endswith
LLVM_NODISCARD bool endswith(StringRef Suffix) const
Check if this string ends with the given Suffix.
Definition: StringRef.h:301
T
llvm::MCContext
Context object for machine code objects.
Definition: MCContext.h:76
StringRef.h
is64Bit
static bool is64Bit(const char *name)
Definition: X86Disassembler.cpp:1018
llvm::write
Error write(MCStreamer &Out, ArrayRef< std::string > Inputs)
Definition: DWP.cpp:536
llvm::Target
Target - Wrapper for Target specific information.
Definition: TargetRegistry.h:145
MCSectionELF.h
Host.h
offsetof
#define offsetof(TYPE, MEMBER)
Definition: AMDHSAKernelDescriptor.h:23
llvm::MCSection::getBeginSymbol
MCSymbol * getBeginSymbol()
Definition: MCSection.h:129
llvm::StringRef::find
LLVM_NODISCARD size_t find(char C, size_t From=0) const
Search for the first character C in the string.
Definition: StringRef.h:319
llvm::SmallVector< char, 128 >
llvm::RISCVFenceField::W
@ W
Definition: RISCVBaseInfo.h:242
llvm::ELF::EI_PAD
@ EI_PAD
Definition: ELF.h:57
llvm::enumerate
detail::enumerator< R > enumerate(R &&TheRange)
Given an input range, returns a new range whose values are are pair (A,B) such that A is the 0-based ...
Definition: STLExtras.h:2057
llvm::MCSymbolELF::getSize
const MCExpr * getSize() const
Definition: MCSymbolELF.h:24
ErrorHandling.h
MCFragment.h
llvm::ELF::STT_GNU_IFUNC
@ STT_GNU_IFUNC
Definition: ELF.h:1210
llvm::MCSymbol::isUndefined
bool isUndefined(bool SetUsed=true) const
isUndefined - Check if this symbol undefined (i.e., implicitly defined).
Definition: MCSymbol.h:252
llvm::MCSectionELF::getGroup
const MCSymbolELF * getGroup() const
Definition: MCSectionELF.h:76
Error.h
llvm::ELF::SHF_TLS
@ SHF_TLS
Definition: ELF.h:1063
MCAssembler.h
llvm::ELF::SHT_SYMTAB_SHNDX
@ SHT_SYMTAB_SHNDX
Definition: ELF.h:970
llvm::ELF::SHT_STRTAB
@ SHT_STRTAB
Definition: ELF.h:957
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
DenseMap.h
llvm::ZeroCallUsedRegs::ZeroCallUsedRegsKind::Used
@ Used
llvm::reverse
auto reverse(ContainerTy &&C, std::enable_if_t< has_rbegin< ContainerTy >::value > *=nullptr)
Definition: STLExtras.h:380
Groups
static const X86InstrFMA3Group Groups[]
Definition: X86InstrFMA3Info.cpp:73
MCFixupKindInfo.h
Offset
uint64_t Offset
Definition: ELFObjHandler.cpp:79
llvm::ELFRelocationEntry
Definition: MCELFObjectWriter.h:30
llvm::ELF::STT_TLS
@ STT_TLS
Definition: ELF.h:1209
mergeTypeForSet
static uint8_t mergeTypeForSet(uint8_t origType, uint8_t newType)
Definition: ELFObjectWriter.cpp:467
llvm::codeview::Link
@ Link
Definition: CodeView.h:154
STLExtras.h
llvm::MCSectionELF
This represents a section on linux, lots of unix variants and some bare metal systems.
Definition: MCSectionELF.h:26
llvm::SPIRV::Decoration::Binding
@ Binding
llvm::support::endian::Writer
Adapter to write values to a stream in a particular byte order.
Definition: EndianStream.h:52
llvm::ELF::Elf64_Rela
Definition: ELF.h:1291
llvm::ArrayRef::empty
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:159
llvm::ELF::SHN_COMMON
@ SHN_COMMON
Definition: ELF.h:947
llvm::ELF::SYMENTRY_SIZE64
@ SYMENTRY_SIZE64
Definition: ELF.h:1186
llvm::ELF::SHF_INFO_LINK
@ SHF_INFO_LINK
Definition: ELF.h:1050
F
#define F(x, y, z)
Definition: MD5.cpp:55
llvm::RISCVFenceField::R
@ R
Definition: RISCVBaseInfo.h:241
llvm::MCAssembler::isThumbFunc
bool isThumbFunc(const MCSymbol *Func) const
Check whether a given symbol has been flagged with .thumb_func.
Definition: MCAssembler.cpp:135
llvm::ELF::SHF_COMPRESSED
@ SHF_COMPRESSED
Definition: ELF.h:1066
llvm::MCSymbolELF
Definition: MCSymbolELF.h:14
llvm::ARMBuildAttrs::Section
@ Section
Legacy Tags.
Definition: ARMBuildAttributes.h:82
llvm::StringRef::substr
LLVM_NODISCARD StringRef substr(size_t Start, size_t N=npos) const
Return a reference to the substring from [Start, Start + N).
Definition: StringRef.h:615
llvm::MCFragment
Definition: MCFragment.h:30
llvm::Intrinsic::getType
FunctionType * getType(LLVMContext &Context, ID id, ArrayRef< Type * > Tys=None)
Return the function type for an intrinsic.
Definition: Function.cpp:1375
StringTableBuilder.h
llvm::ELF::ELFOSABI_NONE
@ ELFOSABI_NONE
Definition: ELF.h:341
llvm::ELF::Elf32_Rel
Definition: ELF.h:1239
llvm::MCAsmBackend
Generic interface to target specific assembler backends.
Definition: MCAsmBackend.h:42
ELF.h
llvm::ELF::SHT_LLVM_CALL_GRAPH_PROFILE
@ SHT_LLVM_CALL_GRAPH_PROFILE
Definition: ELF.h:991
llvm::CallingConv::Tail
@ Tail
Tail - This calling convention attemps to make calls as fast as possible while guaranteeing that tail...
Definition: CallingConv.h:81
llvm::MCSymbol::getSection
MCSection & getSection() const
Get the section associated with a defined, non-absolute symbol.
Definition: MCSymbol.h:262
MCAsmBackend.h
llvm::MutableArrayRef
MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memo...
Definition: ArrayRef.h:306
llvm::SMLoc
Represents a location in source code.
Definition: SMLoc.h:23
llvm::ModRefInfo::Ref
@ Ref
The access may reference the value stored in memory.
llvm::ELF::Elf32_Rela::setSymbolAndType
void setSymbolAndType(Elf32_Word s, unsigned char t)
Definition: ELF.h:1266
llvm::support::little
@ little
Definition: Endian.h:27
llvm::ELF::STB_GLOBAL
@ STB_GLOBAL
Definition: ELF.h:1192
llvm::zlib::compress
void compress(StringRef InputBuffer, SmallVectorImpl< char > &CompressedBuffer, int Level=DefaultCompression)
Definition: Compression.cpp:49
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
Twine.h
MCSymbolELF.h
MCContext.h
llvm::SPIRV::ExecutionModel::Fragment
@ Fragment
MCSymbol.h
llvm::MCContext::getELFSection
MCSectionELF * getELFSection(const Twine &Section, unsigned Type, unsigned Flags)
Definition: MCContext.h:563
llvm::ELF::ELFCOMPRESS_ZLIB
@ ELFCOMPRESS_ZLIB
Definition: ELF.h:1777
llvm::MCSymbol::getVariableValue
const MCExpr * getVariableValue(bool SetUsed=true) const
getVariableValue - Get the value for variable symbols.
Definition: MCSymbol.h:298
llvm::dwarf::Index
Index
Definition: Dwarf.h:472
SMLoc.h
llvm::report_fatal_error
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:143
llvm::ELF::SHN_ABS
@ SHN_ABS
Definition: ELF.h:946
llvm::AMDGPU::ElfNote::SectionName
const char SectionName[]
Definition: AMDGPUPTNote.h:24
llvm::MCSymbolRefExpr::getSymbol
const MCSymbol & getSymbol() const
Definition: MCExpr.h:399
llvm::MCExpr::evaluateKnownAbsolute
bool evaluateKnownAbsolute(int64_t &Res, const MCAsmLayout &Layout) const
Definition: MCExpr.cpp:561
llvm::ELF::STV_DEFAULT
@ STV_DEFAULT
Definition: ELF.h:1221
Info
Analysis containing CSE Info
Definition: CSEInfo.cpp:27
isIFunc
static bool isIFunc(const MCSymbolELF *Symbol)
Definition: ELFObjectWriter.cpp:502
llvm::MCSymbol::getName
StringRef getName() const
getName - Get the symbol name.
Definition: MCSymbol.h:198
Align
uint64_t Align
Definition: ELFObjHandler.cpp:81
llvm::Align
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
llvm::ELF::STT_SECTION
@ STT_SECTION
Definition: ELF.h:1206
llvm::MCSectionELF::isComdat
bool isComdat() const
Definition: MCSectionELF.h:77
llvm::None
const NoneType None
Definition: None.h:24
llvm::MCFixupKindInfo::Flags
unsigned Flags
Flags describing additional information on this fixup kind.
Definition: MCFixupKindInfo.h:45
llvm::lltok::Kind
Kind
Definition: LLToken.h:18
llvm::MCSymbol::getIndex
uint32_t getIndex() const
Get the (implementation defined) index.
Definition: MCSymbol.h:309
llvm::ELF::SHT_NOBITS
@ SHT_NOBITS
Definition: ELF.h:962
llvm::ELF::SYMENTRY_SIZE32
@ SYMENTRY_SIZE32
Definition: ELF.h:1185
llvm::ELF::SHT_DYNAMIC
@ SHT_DYNAMIC
Definition: ELF.h:960
llvm::ELF::SHF_GROUP
@ SHF_GROUP
Definition: ELF.h:1060
llvm::MCAssembler
Definition: MCAssembler.h:73
llvm::MCSectionELF::getLinkedToSection
const MCSection * getLinkedToSection() const
Definition: MCSectionELF.h:89
llvm::AMDGPU::Hwreg::Offset
Offset
Definition: SIDefines.h:416
llvm::MCSymbolRefExpr::VariantKind
VariantKind
Definition: MCExpr.h:194
llvm::DenseMapBase< DenseMap< KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >, KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >::clear
void clear()
Definition: DenseMap.h:112
Index
uint32_t Index
Definition: ELFObjHandler.cpp:82
uint64_t
llvm::raw_pwrite_stream
An abstract base class for streams implementations that also support a pwrite operation.
Definition: raw_ostream.h:418
llvm::ELF::SHT_SYMTAB
@ SHT_SYMTAB
Definition: ELF.h:956
llvm::MCAsmLayout::getBaseSymbol
const MCSymbol * getBaseSymbol(const MCSymbol &Symbol) const
If this symbol is equivalent to A + Constant, return A.
Definition: MCFragment.cpp:162
llvm::ELF::STT_NOTYPE
@ STT_NOTYPE
Definition: ELF.h:1203
MCELFObjectWriter.h
llvm::ELF::STB_LOCAL
@ STB_LOCAL
Definition: ELF.h:1191
LEB128.h
move
compiles ldr LCPI1_0 ldr ldr mov lsr tst moveq r1 ldr LCPI1_1 and r0 bx lr It would be better to do something like to fold the shift into the conditional move
Definition: README.txt:546
llvm::numbers::e
constexpr double e
Definition: MathExtras.h:57
llvm::ELF::EM_MIPS
@ EM_MIPS
Definition: ELF.h:141
llvm::DenseMap
Definition: DenseMap.h:716
llvm::ELF::EV_CURRENT
@ EV_CURRENT
Definition: ELF.h:127
llvm::ELF::SHN_XINDEX
@ SHN_XINDEX
Definition: ELF.h:948
iterator.h
llvm::ELF::SHT_LLVM_ADDRSIG
@ SHT_LLVM_ADDRSIG
Definition: ELF.h:981
size
i< reg-> size
Definition: README.txt:166
ArrayRef.h
llvm::MCSymbol::isVariable
bool isVariable() const
isVariable - Check if this is a variable symbol.
Definition: MCSymbol.h:293
llvm::MCSymbol::setUsedInReloc
void setUsedInReloc() const
Definition: MCSymbol.h:208
llvm::MCContext::createELFGroupSection
MCSectionELF * createELFGroupSection(const MCSymbolELF *Group, bool IsComdat)
Definition: MCContext.cpp:599
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::ELF::SHF_LINK_ORDER
@ SHF_LINK_ORDER
Definition: ELF.h:1053
llvm::SPIRV::Decoration::Stream
@ Stream
llvm::MCContext::reportError
void reportError(SMLoc L, const Twine &Msg)
Definition: MCContext.cpp:1037
llvm::MCSymbolELF::setIsWeakrefUsedInReloc
void setIsWeakrefUsedInReloc() const
Definition: MCSymbolELF.cpp:170
Mode
SI Whole Quad Mode
Definition: SIWholeQuadMode.cpp:262
llvm::MCSymbol::isCommon
bool isCommon() const
Is this a 'common' symbol.
Definition: MCSymbol.h:382
llvm::ELF::SHT_RELA
@ SHT_RELA
Definition: ELF.h:958
llvm::MCSymbolRefExpr
Represent a reference to a symbol from inside an expression.
Definition: MCExpr.h:192
llvm::irsymtab::storage::Word
support::ulittle32_t Word
Definition: IRSymtab.h:52
info
lazy value info
Definition: LazyValueInfo.cpp:58
MCSection.h
llvm::size
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.
Definition: STLExtras.h:1598
llvm::ELF::Elf64_Rel
Definition: ELF.h:1275
llvm::ArrayRef< uint32_t >
llvm::MCSectionELF::getFlags
unsigned getFlags() const
Definition: MCSectionELF.h:73
MCAsmInfo.h
llvm::MCSection::getAlignment
unsigned getAlignment() const
Definition: MCSection.h:140
Fixup
PowerPC TLS Dynamic Call Fixup
Definition: PPCTLSDynamicCall.cpp:233
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
llvm::msf::Magic
static const char Magic[]
Definition: MSFCommon.h:23
llvm::ELF::ELFDATA2LSB
@ ELFDATA2LSB
Definition: ELF.h:335
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:143
llvm::MCAssembler::Symver
Definition: MCAssembler.h:228
uint32_t
MCFixup.h
llvm::MCObjectWriter
Defines the object file and target independent interfaces used by the assembler backend to write nati...
Definition: MCObjectWriter.h:34
llvm::MCSection
Instances of this class represent a uniqued identifier for a section in the current translation unit.
Definition: MCSection.h:39
S
add sub stmia L5 ldr r0 bl L_printf $stub Instead of a and a wouldn t it be better to do three moves *Return an aggregate type is even return S
Definition: README.txt:210
llvm::MCSymbolELF::getBinding
unsigned getBinding() const
Definition: MCSymbolELF.cpp:63
llvm::ELF::SHN_LORESERVE
@ SHN_LORESERVE
Definition: ELF.h:941
llvm::ELF::SHT_GROUP
@ SHT_GROUP
Definition: ELF.h:969
llvm::MCAsmLayout::getFragmentOffset
uint64_t getFragmentOffset(const MCFragment *F) const
Get the offset of the given fragment inside its containing section.
Definition: MCFragment.cpp:96
llvm::MCSymbol::getCommonAlignment
unsigned getCommonAlignment() const
Return the alignment of a 'common' symbol.
Definition: MCSymbol.h:359
llvm::ELF::STB_GNU_UNIQUE
@ STB_GNU_UNIQUE
Definition: ELF.h:1194
MCAsmLayout.h
llvm::MCSection::getName
StringRef getName() const
Definition: MCSection.h:124
llvm::pdb::PDB_DataKind::Local
@ Local
llvm::MCSection::setAlignment
void setAlignment(Align Value)
Definition: MCSection.h:141
name
static const char * name
Definition: SVEIntrinsicOpts.cpp:74
MCObjectWriter.h
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:83
Alignment.h
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:50
EndianStream.h
llvm::MCObjectWriter::reset
virtual void reset()
lifetime management
Definition: MCObjectWriter.h:47
uint16_t
llvm::MCAsmLayout
Encapsulates the layout of an assembly file at a particular point in time.
Definition: MCAsmLayout.h:28
llvm::ELF::Elf64_Rela::setSymbolAndType
void setSymbolAndType(Elf64_Word s, Elf64_Word t)
Definition: ELF.h:1302
llvm::ELF::SHF_MERGE
@ SHF_MERGE
Definition: ELF.h:1044
llvm::SectionName
Definition: DWARFSection.h:21
llvm::ELF::STT_OBJECT
@ STT_OBJECT
Definition: ELF.h:1204
llvm::ELF::ELFDATA2MSB
@ ELFDATA2MSB
Definition: ELF.h:336
Casting.h
isInSymtab
static bool isInSymtab(const MCSymbolWasm &Sym)
Definition: WasmObjectWriter.cpp:1315
llvm::ELF::Elf32_Ehdr
Definition: ELF.h:61
llvm::ELF::SHT_REL
@ SHT_REL
Definition: ELF.h:963
llvm::ELF::Elf32_Shdr
Definition: ELF.h:911
llvm::TargetStackID::Value
Value
Definition: TargetFrameLowering.h:27
llvm::createELFDwoObjectWriter
std::unique_ptr< MCObjectWriter > createELFDwoObjectWriter(std::unique_ptr< MCELFObjectTargetWriter > MOTW, raw_pwrite_stream &OS, raw_pwrite_stream &DwoOS, bool IsLittleEndian)
Definition: ELFObjectWriter.cpp:1522
llvm::ARCCC::Z
@ Z
Definition: ARCInfo.h:41
llvm::MCAsmLayout::getSymbolOffset
bool getSymbolOffset(const MCSymbol &S, uint64_t &Val) const
Get the offset of the given symbol, as computed in the current layout.
Definition: MCFragment.cpp:152
llvm::StringTableBuilder
Utility for building string tables with deduplicated suffixes.
Definition: StringTableBuilder.h:23
MCValue.h
llvm::ELF::ET_REL
@ ET_REL
Definition: ELF.h:116
llvm::ELF::Elf32_Rela
Definition: ELF.h:1255
llvm::MCSymbolELF::getType
unsigned getType() const
Definition: MCSymbolELF.cpp:122
llvm::ARMBuildAttrs::Symbol
@ Symbol
Definition: ARMBuildAttributes.h:83
llvm::ELF::Elf32_Chdr
Definition: ELF.h:1747
llvm::ELF::GRP_COMDAT
@ GRP_COMDAT
Definition: ELF.h:1138
llvm::ELF::ElfMagic
static const char ElfMagic[]
Definition: ELF.h:44
align
mov r0 ldr L5 sub r0 lr needed for prologue ldmia ip add bx lr r2 The last stmia stores r2 into the address passed in there is one additional stmia that stores and r2 to some stack location The store is dead The llvm gcc generated code looks like align
Definition: README.txt:236
llvm::ELF::EI_NIDENT
@ EI_NIDENT
Definition: ELF.h:58
llvm::ELF::SHN_UNDEF
@ SHN_UNDEF
Definition: ELF.h:940
SmallVector.h
llvm::StringTableBuilder::ELF
@ ELF
Definition: StringTableBuilder.h:26
llvm::MCSymbol::isInSection
bool isInSection() const
isInSection - Check if this symbol is defined in some section (i.e., it is defined but not absolute).
Definition: MCSymbol.h:247
llvm::ELF::Elf64_Ehdr
Definition: ELF.h:87
llvm::ELF::Elf64_Shdr
Definition: ELF.h:925
llvm::ELF::ELFCLASS64
@ ELFCLASS64
Definition: ELF.h:329
llvm::raw_svector_ostream
A raw_ostream that writes to an SmallVector or SmallString.
Definition: raw_ostream.h:662
llvm::encodeULEB128
unsigned encodeULEB128(uint64_t Value, raw_ostream &OS, unsigned PadTo=0)
Utility function to encode a ULEB128 value to an output stream.
Definition: LEB128.h:80
llvm::ELF::STT_FILE
@ STT_FILE
Definition: ELF.h:1207
llvm::SmallVectorImpl< char >
llvm::msgpack::Type
Type
MessagePack types as defined in the standard, with the exception of Integer being divided into a sign...
Definition: MsgPackReader.h:48
llvm::HexStyle::Asm
@ Asm
0ffh
Definition: MCInstPrinter.h:34
llvm::ELF::ELFOSABI_GNU
@ ELFOSABI_GNU
Definition: ELF.h:344
llvm::MCAsmLayout::getAssembler
MCAssembler & getAssembler() const
Get the assembler object this is a layout for.
Definition: MCAsmLayout.h:50
llvm::MCValue
This represents an "assembler immediate".
Definition: MCValue.h:36
llvm::MCContext::createELFRelSection
MCSectionELF * createELFRelSection(const Twine &Name, unsigned Type, unsigned Flags, unsigned EntrySize, const MCSymbolELF *Group, const MCSectionELF *RelInfoSection)
Definition: MCContext.cpp:525
From
BlockVerifier::State From
Definition: BlockVerifier.cpp:55
llvm::ELF::Elf64_Chdr
Definition: ELF.h:1754
llvm::MCAsmLayout::getSectionAddressSize
uint64_t getSectionAddressSize(const MCSection *Sec) const
Get the address space size of the given section, as it effects layout.
Definition: MCFragment.cpp:198
llvm::ELF::ELFCLASS32
@ ELFCLASS32
Definition: ELF.h:328
raw_ostream.h
llvm::SI::KernelInputOffsets::Offsets
Offsets
Offsets in bytes from the start of the input buffer.
Definition: SIInstrInfo.h:1320
Endian.h
MCExpr.h
llvm::MCFixup
Encode information on a single operation to perform on a byte sequence (e.g., an encoded instruction)...
Definition: MCFixup.h:71
llvm::ELF::EM_386
@ EM_386
Definition: ELF.h:136
llvm::Value
LLVM Value Representation.
Definition: Value.h:74
llvm::MCExpr
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:35
llvm::MCSectionELF::getType
unsigned getType() const
Definition: MCSectionELF.h:72
llvm::ELF::STB_WEAK
@ STB_WEAK
Definition: ELF.h:1193
llvm::support::big
@ big
Definition: Endian.h:27
llvm::ELF::SHF_EXCLUDE
@ SHF_EXCLUDE
Definition: ELF.h:1072
llvm::sampleprof::Base
@ Base
Definition: Discriminator.h:58
Other
Optional< std::vector< StOtherPiece > > Other
Definition: ELFYAML.cpp:1237
write
static void write(bool isBE, void *P, T V)
Definition: RuntimeDyldELF.cpp:37