LLVM  3.7.0
ELFObjectWriter.cpp
Go to the documentation of this file.
1 //===- lib/MC/ELFObjectWriter.cpp - ELF File Writer -----------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements ELF object file writer information.
11 //
12 //===----------------------------------------------------------------------===//
13 
15 #include "llvm/ADT/STLExtras.h"
16 #include "llvm/ADT/SmallPtrSet.h"
17 #include "llvm/ADT/SmallString.h"
18 #include "llvm/ADT/StringMap.h"
19 #include "llvm/MC/MCAsmBackend.h"
20 #include "llvm/MC/MCAsmInfo.h"
21 #include "llvm/MC/MCAsmLayout.h"
22 #include "llvm/MC/MCAssembler.h"
23 #include "llvm/MC/MCContext.h"
24 #include "llvm/MC/MCExpr.h"
26 #include "llvm/MC/MCObjectWriter.h"
27 #include "llvm/MC/MCSectionELF.h"
28 #include "llvm/MC/MCSymbolELF.h"
29 #include "llvm/MC/MCValue.h"
32 #include "llvm/Support/Debug.h"
33 #include "llvm/Support/ELF.h"
34 #include "llvm/Support/Endian.h"
36 #include <vector>
37 using namespace llvm;
38 
39 #undef DEBUG_TYPE
40 #define DEBUG_TYPE "reloc-info"
41 
42 namespace {
43 
44 typedef DenseMap<const MCSectionELF *, uint32_t> SectionIndexMapTy;
45 
46 class ELFObjectWriter;
47 
48 class SymbolTableWriter {
49  ELFObjectWriter &EWriter;
50  bool Is64Bit;
51 
52  // indexes we are going to write to .symtab_shndx.
53  std::vector<uint32_t> ShndxIndexes;
54 
55  // The numbel of symbols written so far.
56  unsigned NumWritten;
57 
58  void createSymtabShndx();
59 
60  template <typename T> void write(T Value);
61 
62 public:
63  SymbolTableWriter(ELFObjectWriter &EWriter, bool Is64Bit);
64 
65  void writeSymbol(uint32_t name, uint8_t info, uint64_t value, uint64_t size,
66  uint8_t other, uint32_t shndx, bool Reserved);
67 
68  ArrayRef<uint32_t> getShndxIndexes() const { return ShndxIndexes; }
69 };
70 
71 class ELFObjectWriter : public MCObjectWriter {
72  static bool isFixupKindPCRel(const MCAssembler &Asm, unsigned Kind);
73  static uint64_t SymbolValue(const MCSymbol &Sym, const MCAsmLayout &Layout);
74  static bool isInSymtab(const MCAsmLayout &Layout, const MCSymbolELF &Symbol,
75  bool Used, bool Renamed);
76 
77  /// Helper struct for containing some precomputed information on symbols.
78  struct ELFSymbolData {
79  const MCSymbolELF *Symbol;
80  uint32_t SectionIndex;
82 
83  // Support lexicographic sorting.
84  bool operator<(const ELFSymbolData &RHS) const {
85  unsigned LHSType = Symbol->getType();
86  unsigned RHSType = RHS.Symbol->getType();
87  if (LHSType == ELF::STT_SECTION && RHSType != ELF::STT_SECTION)
88  return false;
89  if (LHSType != ELF::STT_SECTION && RHSType == ELF::STT_SECTION)
90  return true;
91  if (LHSType == ELF::STT_SECTION && RHSType == ELF::STT_SECTION)
92  return SectionIndex < RHS.SectionIndex;
93  return Name < RHS.Name;
94  }
95  };
96 
97  /// The target specific ELF writer instance.
98  std::unique_ptr<MCELFObjectTargetWriter> TargetObjectWriter;
99 
101 
103  Relocations;
104 
105  /// @}
106  /// @name Symbol Table Data
107  /// @{
108 
109  StringTableBuilder StrTabBuilder;
110 
111  /// @}
112 
113  // This holds the symbol table index of the last local symbol.
114  unsigned LastLocalSymbolIndex;
115  // This holds the .strtab section index.
116  unsigned StringTableIndex;
117  // This holds the .symtab section index.
118  unsigned SymbolTableIndex;
119 
120  // Sections in the order they are to be output in the section table.
121  std::vector<const MCSectionELF *> SectionTable;
122  unsigned addToSectionTable(const MCSectionELF *Sec);
123 
124  // TargetObjectWriter wrappers.
125  bool is64Bit() const { return TargetObjectWriter->is64Bit(); }
126  bool hasRelocationAddend() const {
127  return TargetObjectWriter->hasRelocationAddend();
128  }
129  unsigned GetRelocType(const MCValue &Target, const MCFixup &Fixup,
130  bool IsPCRel) const {
131  return TargetObjectWriter->GetRelocType(Target, Fixup, IsPCRel);
132  }
133 
134  void align(unsigned Alignment);
135 
136  public:
137  ELFObjectWriter(MCELFObjectTargetWriter *MOTW, raw_pwrite_stream &OS,
138  bool IsLittleEndian)
139  : MCObjectWriter(OS, IsLittleEndian), TargetObjectWriter(MOTW) {}
140 
141  void reset() override {
142  Renames.clear();
143  Relocations.clear();
144  StrTabBuilder.clear();
145  SectionTable.clear();
147  }
148 
149  ~ELFObjectWriter() override;
150 
151  void WriteWord(uint64_t W) {
152  if (is64Bit())
153  write64(W);
154  else
155  write32(W);
156  }
157 
158  template <typename T> void write(T Val) {
159  if (IsLittleEndian)
161  else
163  }
164 
165  void writeHeader(const MCAssembler &Asm);
166 
167  void writeSymbol(SymbolTableWriter &Writer, uint32_t StringIndex,
168  ELFSymbolData &MSD, const MCAsmLayout &Layout);
169 
170  // Start and end offset of each section
171  typedef std::map<const MCSectionELF *, std::pair<uint64_t, uint64_t>>
172  SectionOffsetsTy;
173 
174  bool shouldRelocateWithSymbol(const MCAssembler &Asm,
175  const MCSymbolRefExpr *RefA,
176  const MCSymbol *Sym, uint64_t C,
177  unsigned Type) const;
178 
179  void recordRelocation(MCAssembler &Asm, const MCAsmLayout &Layout,
180  const MCFragment *Fragment, const MCFixup &Fixup,
181  MCValue Target, bool &IsPCRel,
182  uint64_t &FixedValue) override;
183 
184  // Map from a signature symbol to the group section index
185  typedef DenseMap<const MCSymbol *, unsigned> RevGroupMapTy;
186 
187  /// Compute the symbol table data
188  ///
189  /// \param Asm - The assembler.
190  /// \param SectionIndexMap - Maps a section to its index.
191  /// \param RevGroupMap - Maps a signature symbol to the group section.
192  void computeSymbolTable(MCAssembler &Asm, const MCAsmLayout &Layout,
193  const SectionIndexMapTy &SectionIndexMap,
194  const RevGroupMapTy &RevGroupMap,
195  SectionOffsetsTy &SectionOffsets);
196 
197  MCSectionELF *createRelocationSection(MCContext &Ctx,
198  const MCSectionELF &Sec);
199 
200  const MCSectionELF *createStringTable(MCContext &Ctx);
201 
202  void executePostLayoutBinding(MCAssembler &Asm,
203  const MCAsmLayout &Layout) override;
204 
205  void writeSectionHeader(const MCAsmLayout &Layout,
206  const SectionIndexMapTy &SectionIndexMap,
207  const SectionOffsetsTy &SectionOffsets);
208 
209  void writeSectionData(const MCAssembler &Asm, MCSection &Sec,
210  const MCAsmLayout &Layout);
211 
212  void WriteSecHdrEntry(uint32_t Name, uint32_t Type, uint64_t Flags,
213  uint64_t Address, uint64_t Offset, uint64_t Size,
214  uint32_t Link, uint32_t Info, uint64_t Alignment,
215  uint64_t EntrySize);
216 
217  void writeRelocations(const MCAssembler &Asm, const MCSectionELF &Sec);
218 
219  bool isSymbolRefDifferenceFullyResolvedImpl(const MCAssembler &Asm,
220  const MCSymbol &SymA,
221  const MCFragment &FB,
222  bool InSet,
223  bool IsPCRel) const override;
224 
225  bool isWeak(const MCSymbol &Sym) const override;
226 
227  void writeObject(MCAssembler &Asm, const MCAsmLayout &Layout) override;
228  void writeSection(const SectionIndexMapTy &SectionIndexMap,
229  uint32_t GroupSymbolIndex, uint64_t Offset, uint64_t Size,
230  const MCSectionELF &Section);
231  };
232 }
233 
234 void ELFObjectWriter::align(unsigned Alignment) {
235  uint64_t Padding = OffsetToAlignment(OS.tell(), Alignment);
236  WriteZeros(Padding);
237 }
238 
239 unsigned ELFObjectWriter::addToSectionTable(const MCSectionELF *Sec) {
240  SectionTable.push_back(Sec);
241  StrTabBuilder.add(Sec->getSectionName());
242  return SectionTable.size();
243 }
244 
245 void SymbolTableWriter::createSymtabShndx() {
246  if (!ShndxIndexes.empty())
247  return;
248 
249  ShndxIndexes.resize(NumWritten);
250 }
251 
252 template <typename T> void SymbolTableWriter::write(T Value) {
253  EWriter.write(Value);
254 }
255 
256 SymbolTableWriter::SymbolTableWriter(ELFObjectWriter &EWriter, bool Is64Bit)
257  : EWriter(EWriter), Is64Bit(Is64Bit), NumWritten(0) {}
258 
259 void SymbolTableWriter::writeSymbol(uint32_t name, uint8_t info, uint64_t value,
260  uint64_t size, uint8_t other,
261  uint32_t shndx, bool Reserved) {
262  bool LargeIndex = shndx >= ELF::SHN_LORESERVE && !Reserved;
263 
264  if (LargeIndex)
265  createSymtabShndx();
266 
267  if (!ShndxIndexes.empty()) {
268  if (LargeIndex)
269  ShndxIndexes.push_back(shndx);
270  else
271  ShndxIndexes.push_back(0);
272  }
273 
274  uint16_t Index = LargeIndex ? uint16_t(ELF::SHN_XINDEX) : shndx;
275 
276  if (Is64Bit) {
277  write(name); // st_name
278  write(info); // st_info
279  write(other); // st_other
280  write(Index); // st_shndx
281  write(value); // st_value
282  write(size); // st_size
283  } else {
284  write(name); // st_name
285  write(uint32_t(value)); // st_value
286  write(uint32_t(size)); // st_size
287  write(info); // st_info
288  write(other); // st_other
289  write(Index); // st_shndx
290  }
291 
292  ++NumWritten;
293 }
294 
295 bool ELFObjectWriter::isFixupKindPCRel(const MCAssembler &Asm, unsigned Kind) {
296  const MCFixupKindInfo &FKI =
298 
299  return FKI.Flags & MCFixupKindInfo::FKF_IsPCRel;
300 }
301 
302 ELFObjectWriter::~ELFObjectWriter()
303 {}
304 
305 // Emit the ELF header.
306 void ELFObjectWriter::writeHeader(const MCAssembler &Asm) {
307  // ELF Header
308  // ----------
309  //
310  // Note
311  // ----
312  // emitWord method behaves differently for ELF32 and ELF64, writing
313  // 4 bytes in the former and 8 in the latter.
314 
315  writeBytes(ELF::ElfMagic); // e_ident[EI_MAG0] to e_ident[EI_MAG3]
316 
317  write8(is64Bit() ? ELF::ELFCLASS64 : ELF::ELFCLASS32); // e_ident[EI_CLASS]
318 
319  // e_ident[EI_DATA]
320  write8(isLittleEndian() ? ELF::ELFDATA2LSB : ELF::ELFDATA2MSB);
321 
322  write8(ELF::EV_CURRENT); // e_ident[EI_VERSION]
323  // e_ident[EI_OSABI]
324  write8(TargetObjectWriter->getOSABI());
325  write8(0); // e_ident[EI_ABIVERSION]
326 
327  WriteZeros(ELF::EI_NIDENT - ELF::EI_PAD);
328 
329  write16(ELF::ET_REL); // e_type
330 
331  write16(TargetObjectWriter->getEMachine()); // e_machine = target
332 
333  write32(ELF::EV_CURRENT); // e_version
334  WriteWord(0); // e_entry, no entry point in .o file
335  WriteWord(0); // e_phoff, no program header for .o
336  WriteWord(0); // e_shoff = sec hdr table off in bytes
337 
338  // e_flags = whatever the target wants
339  write32(Asm.getELFHeaderEFlags());
340 
341  // e_ehsize = ELF header size
342  write16(is64Bit() ? sizeof(ELF::Elf64_Ehdr) : sizeof(ELF::Elf32_Ehdr));
343 
344  write16(0); // e_phentsize = prog header entry size
345  write16(0); // e_phnum = # prog header entries = 0
346 
347  // e_shentsize = Section header entry size
348  write16(is64Bit() ? sizeof(ELF::Elf64_Shdr) : sizeof(ELF::Elf32_Shdr));
349 
350  // e_shnum = # of section header ents
351  write16(0);
352 
353  // e_shstrndx = Section # of '.shstrtab'
354  assert(StringTableIndex < ELF::SHN_LORESERVE);
355  write16(StringTableIndex);
356 }
357 
358 uint64_t ELFObjectWriter::SymbolValue(const MCSymbol &Sym,
359  const MCAsmLayout &Layout) {
360  if (Sym.isCommon() && Sym.isExternal())
361  return Sym.getCommonAlignment();
362 
363  uint64_t Res;
364  if (!Layout.getSymbolOffset(Sym, Res))
365  return 0;
366 
367  if (Layout.getAssembler().isThumbFunc(&Sym))
368  Res |= 1;
369 
370  return Res;
371 }
372 
373 void ELFObjectWriter::executePostLayoutBinding(MCAssembler &Asm,
374  const MCAsmLayout &Layout) {
375  // The presence of symbol versions causes undefined symbols and
376  // versions declared with @@@ to be renamed.
377 
378  for (const MCSymbol &A : Asm.symbols()) {
379  const auto &Alias = cast<MCSymbolELF>(A);
380  // Not an alias.
381  if (!Alias.isVariable())
382  continue;
383  auto *Ref = dyn_cast<MCSymbolRefExpr>(Alias.getVariableValue());
384  if (!Ref)
385  continue;
386  const auto &Symbol = cast<MCSymbolELF>(Ref->getSymbol());
387 
388  StringRef AliasName = Alias.getName();
389  size_t Pos = AliasName.find('@');
390  if (Pos == StringRef::npos)
391  continue;
392 
393  // Aliases defined with .symvar copy the binding from the symbol they alias.
394  // This is the first place we are able to copy this information.
395  Alias.setExternal(Symbol.isExternal());
396  Alias.setBinding(Symbol.getBinding());
397 
398  StringRef Rest = AliasName.substr(Pos);
399  if (!Symbol.isUndefined() && !Rest.startswith("@@@"))
400  continue;
401 
402  // FIXME: produce a better error message.
403  if (Symbol.isUndefined() && Rest.startswith("@@") &&
404  !Rest.startswith("@@@"))
405  report_fatal_error("A @@ version cannot be undefined");
406 
407  Renames.insert(std::make_pair(&Symbol, &Alias));
408  }
409 }
410 
411 static uint8_t mergeTypeForSet(uint8_t origType, uint8_t newType) {
412  uint8_t Type = newType;
413 
414  // Propagation rules:
415  // IFUNC > FUNC > OBJECT > NOTYPE
416  // TLS_OBJECT > OBJECT > NOTYPE
417  //
418  // dont let the new type degrade the old type
419  switch (origType) {
420  default:
421  break;
422  case ELF::STT_GNU_IFUNC:
423  if (Type == ELF::STT_FUNC || Type == ELF::STT_OBJECT ||
424  Type == ELF::STT_NOTYPE || Type == ELF::STT_TLS)
425  Type = ELF::STT_GNU_IFUNC;
426  break;
427  case ELF::STT_FUNC:
428  if (Type == ELF::STT_OBJECT || Type == ELF::STT_NOTYPE ||
429  Type == ELF::STT_TLS)
430  Type = ELF::STT_FUNC;
431  break;
432  case ELF::STT_OBJECT:
433  if (Type == ELF::STT_NOTYPE)
434  Type = ELF::STT_OBJECT;
435  break;
436  case ELF::STT_TLS:
437  if (Type == ELF::STT_OBJECT || Type == ELF::STT_NOTYPE ||
438  Type == ELF::STT_GNU_IFUNC || Type == ELF::STT_FUNC)
439  Type = ELF::STT_TLS;
440  break;
441  }
442 
443  return Type;
444 }
445 
446 void ELFObjectWriter::writeSymbol(SymbolTableWriter &Writer,
447  uint32_t StringIndex, ELFSymbolData &MSD,
448  const MCAsmLayout &Layout) {
449  const auto &Symbol = cast<MCSymbolELF>(*MSD.Symbol);
450  assert((!Symbol.getFragment() ||
451  (Symbol.getFragment()->getParent() == &Symbol.getSection())) &&
452  "The symbol's section doesn't match the fragment's symbol");
453  const MCSymbolELF *Base =
454  cast_or_null<MCSymbolELF>(Layout.getBaseSymbol(Symbol));
455 
456  // This has to be in sync with when computeSymbolTable uses SHN_ABS or
457  // SHN_COMMON.
458  bool IsReserved = !Base || Symbol.isCommon();
459 
460  // Binding and Type share the same byte as upper and lower nibbles
461  uint8_t Binding = Symbol.getBinding();
462  uint8_t Type = Symbol.getType();
463  if (Base) {
464  Type = mergeTypeForSet(Type, Base->getType());
465  }
466  uint8_t Info = (Binding << 4) | Type;
467 
468  // Other and Visibility share the same byte with Visibility using the lower
469  // 2 bits
470  uint8_t Visibility = Symbol.getVisibility();
471  uint8_t Other = Symbol.getOther() | Visibility;
472 
473  uint64_t Value = SymbolValue(*MSD.Symbol, Layout);
474  uint64_t Size = 0;
475 
476  const MCExpr *ESize = MSD.Symbol->getSize();
477  if (!ESize && Base)
478  ESize = Base->getSize();
479 
480  if (ESize) {
481  int64_t Res;
482  if (!ESize->evaluateKnownAbsolute(Res, Layout))
483  report_fatal_error("Size expression must be absolute.");
484  Size = Res;
485  }
486 
487  // Write out the symbol table entry
488  Writer.writeSymbol(StringIndex, Info, Value, Size, Other, MSD.SectionIndex,
489  IsReserved);
490 }
491 
492 // It is always valid to create a relocation with a symbol. It is preferable
493 // to use a relocation with a section if that is possible. Using the section
494 // allows us to omit some local symbols from the symbol table.
495 bool ELFObjectWriter::shouldRelocateWithSymbol(const MCAssembler &Asm,
496  const MCSymbolRefExpr *RefA,
497  const MCSymbol *S, uint64_t C,
498  unsigned Type) const {
499  const auto *Sym = cast_or_null<MCSymbolELF>(S);
500  // A PCRel relocation to an absolute value has no symbol (or section). We
501  // represent that with a relocation to a null section.
502  if (!RefA)
503  return false;
504 
505  MCSymbolRefExpr::VariantKind Kind = RefA->getKind();
506  switch (Kind) {
507  default:
508  break;
509  // The .odp creation emits a relocation against the symbol ".TOC." which
510  // create a R_PPC64_TOC relocation. However the relocation symbol name
511  // in final object creation should be NULL, since the symbol does not
512  // really exist, it is just the reference to TOC base for the current
513  // object file. Since the symbol is undefined, returning false results
514  // in a relocation with a null section which is the desired result.
515  case MCSymbolRefExpr::VK_PPC_TOCBASE:
516  return false;
517 
518  // These VariantKind cause the relocation to refer to something other than
519  // the symbol itself, like a linker generated table. Since the address of
520  // symbol is not relevant, we cannot replace the symbol with the
521  // section and patch the difference in the addend.
522  case MCSymbolRefExpr::VK_GOT:
523  case MCSymbolRefExpr::VK_PLT:
524  case MCSymbolRefExpr::VK_GOTPCREL:
525  case MCSymbolRefExpr::VK_Mips_GOT:
526  case MCSymbolRefExpr::VK_PPC_GOT_LO:
527  case MCSymbolRefExpr::VK_PPC_GOT_HI:
528  case MCSymbolRefExpr::VK_PPC_GOT_HA:
529  return true;
530  }
531 
532  // An undefined symbol is not in any section, so the relocation has to point
533  // to the symbol itself.
534  assert(Sym && "Expected a symbol");
535  if (Sym->isUndefined())
536  return true;
537 
538  unsigned Binding = Sym->getBinding();
539  switch(Binding) {
540  default:
541  llvm_unreachable("Invalid Binding");
542  case ELF::STB_LOCAL:
543  break;
544  case ELF::STB_WEAK:
545  // If the symbol is weak, it might be overridden by a symbol in another
546  // file. The relocation has to point to the symbol so that the linker
547  // can update it.
548  return true;
549  case ELF::STB_GLOBAL:
550  // Global ELF symbols can be preempted by the dynamic linker. The relocation
551  // has to point to the symbol for a reason analogous to the STB_WEAK case.
552  return true;
553  }
554 
555  // If a relocation points to a mergeable section, we have to be careful.
556  // If the offset is zero, a relocation with the section will encode the
557  // same information. With a non-zero offset, the situation is different.
558  // For example, a relocation can point 42 bytes past the end of a string.
559  // If we change such a relocation to use the section, the linker would think
560  // that it pointed to another string and subtracting 42 at runtime will
561  // produce the wrong value.
562  auto &Sec = cast<MCSectionELF>(Sym->getSection());
563  unsigned Flags = Sec.getFlags();
564  if (Flags & ELF::SHF_MERGE) {
565  if (C != 0)
566  return true;
567 
568  // It looks like gold has a bug (http://sourceware.org/PR16794) and can
569  // only handle section relocations to mergeable sections if using RELA.
570  if (!hasRelocationAddend())
571  return true;
572  }
573 
574  // Most TLS relocations use a got, so they need the symbol. Even those that
575  // are just an offset (@tpoff), require a symbol in gold versions before
576  // 5efeedf61e4fe720fd3e9a08e6c91c10abb66d42 (2014-09-26) which fixed
577  // http://sourceware.org/PR16773.
578  if (Flags & ELF::SHF_TLS)
579  return true;
580 
581  // If the symbol is a thumb function the final relocation must set the lowest
582  // bit. With a symbol that is done by just having the symbol have that bit
583  // set, so we would lose the bit if we relocated with the section.
584  // FIXME: We could use the section but add the bit to the relocation value.
585  if (Asm.isThumbFunc(Sym))
586  return true;
587 
588  if (TargetObjectWriter->needsRelocateWithSymbol(*Sym, Type))
589  return true;
590  return false;
591 }
592 
593 // True if the assembler knows nothing about the final value of the symbol.
594 // This doesn't cover the comdat issues, since in those cases the assembler
595 // can at least know that all symbols in the section will move together.
596 static bool isWeak(const MCSymbolELF &Sym) {
597  if (Sym.getType() == ELF::STT_GNU_IFUNC)
598  return true;
599 
600  switch (Sym.getBinding()) {
601  default:
602  llvm_unreachable("Unknown binding");
603  case ELF::STB_LOCAL:
604  return false;
605  case ELF::STB_GLOBAL:
606  return false;
607  case ELF::STB_WEAK:
608  case ELF::STB_GNU_UNIQUE:
609  return true;
610  }
611 }
612 
613 void ELFObjectWriter::recordRelocation(MCAssembler &Asm,
614  const MCAsmLayout &Layout,
615  const MCFragment *Fragment,
616  const MCFixup &Fixup, MCValue Target,
617  bool &IsPCRel, uint64_t &FixedValue) {
618  const MCSectionELF &FixupSection = cast<MCSectionELF>(*Fragment->getParent());
619  uint64_t C = Target.getConstant();
620  uint64_t FixupOffset = Layout.getFragmentOffset(Fragment) + Fixup.getOffset();
621 
622  if (const MCSymbolRefExpr *RefB = Target.getSymB()) {
623  assert(RefB->getKind() == MCSymbolRefExpr::VK_None &&
624  "Should not have constructed this");
625 
626  // Let A, B and C being the components of Target and R be the location of
627  // the fixup. If the fixup is not pcrel, we want to compute (A - B + C).
628  // If it is pcrel, we want to compute (A - B + C - R).
629 
630  // In general, ELF has no relocations for -B. It can only represent (A + C)
631  // or (A + C - R). If B = R + K and the relocation is not pcrel, we can
632  // replace B to implement it: (A - R - K + C)
633  if (IsPCRel)
635  Fixup.getLoc(),
636  "No relocation available to represent this relative expression");
637 
638  const auto &SymB = cast<MCSymbolELF>(RefB->getSymbol());
639 
640  if (SymB.isUndefined())
642  Fixup.getLoc(),
643  Twine("symbol '") + SymB.getName() +
644  "' can not be undefined in a subtraction expression");
645 
646  assert(!SymB.isAbsolute() && "Should have been folded");
647  const MCSection &SecB = SymB.getSection();
648  if (&SecB != &FixupSection)
650  Fixup.getLoc(), "Cannot represent a difference across sections");
651 
652  if (::isWeak(SymB))
654  Fixup.getLoc(), "Cannot represent a subtraction with a weak symbol");
655 
656  uint64_t SymBOffset = Layout.getSymbolOffset(SymB);
657  uint64_t K = SymBOffset - FixupOffset;
658  IsPCRel = true;
659  C -= K;
660  }
661 
662  // We either rejected the fixup or folded B into C at this point.
663  const MCSymbolRefExpr *RefA = Target.getSymA();
664  const auto *SymA = RefA ? cast<MCSymbolELF>(&RefA->getSymbol()) : nullptr;
665 
666  bool ViaWeakRef = false;
667  if (SymA && SymA->isVariable()) {
668  const MCExpr *Expr = SymA->getVariableValue();
669  if (const auto *Inner = dyn_cast<MCSymbolRefExpr>(Expr)) {
670  if (Inner->getKind() == MCSymbolRefExpr::VK_WEAKREF) {
671  SymA = cast<MCSymbolELF>(&Inner->getSymbol());
672  ViaWeakRef = true;
673  }
674  }
675  }
676 
677  unsigned Type = GetRelocType(Target, Fixup, IsPCRel);
678  bool RelocateWithSymbol = shouldRelocateWithSymbol(Asm, RefA, SymA, C, Type);
679  if (!RelocateWithSymbol && SymA && !SymA->isUndefined())
680  C += Layout.getSymbolOffset(*SymA);
681 
682  uint64_t Addend = 0;
683  if (hasRelocationAddend()) {
684  Addend = C;
685  C = 0;
686  }
687 
688  FixedValue = C;
689 
690  if (!RelocateWithSymbol) {
691  const MCSection *SecA =
692  (SymA && !SymA->isUndefined()) ? &SymA->getSection() : nullptr;
693  auto *ELFSec = cast_or_null<MCSectionELF>(SecA);
694  const auto *SectionSymbol =
695  ELFSec ? cast<MCSymbolELF>(ELFSec->getBeginSymbol()) : nullptr;
696  if (SectionSymbol)
697  SectionSymbol->setUsedInReloc();
698  ELFRelocationEntry Rec(FixupOffset, SectionSymbol, Type, Addend);
699  Relocations[&FixupSection].push_back(Rec);
700  return;
701  }
702 
703  if (SymA) {
704  if (const MCSymbolELF *R = Renames.lookup(SymA))
705  SymA = R;
706 
707  if (ViaWeakRef)
708  SymA->setIsWeakrefUsedInReloc();
709  else
710  SymA->setUsedInReloc();
711  }
712  ELFRelocationEntry Rec(FixupOffset, SymA, Type, Addend);
713  Relocations[&FixupSection].push_back(Rec);
714  return;
715 }
716 
717 bool ELFObjectWriter::isInSymtab(const MCAsmLayout &Layout,
718  const MCSymbolELF &Symbol, bool Used,
719  bool Renamed) {
720  if (Symbol.isVariable()) {
721  const MCExpr *Expr = Symbol.getVariableValue();
722  if (const MCSymbolRefExpr *Ref = dyn_cast<MCSymbolRefExpr>(Expr)) {
723  if (Ref->getKind() == MCSymbolRefExpr::VK_WEAKREF)
724  return false;
725  }
726  }
727 
728  if (Used)
729  return true;
730 
731  if (Renamed)
732  return false;
733 
734  if (Symbol.isVariable() && Symbol.isUndefined()) {
735  // FIXME: this is here just to diagnose the case of a var = commmon_sym.
736  Layout.getBaseSymbol(Symbol);
737  return false;
738  }
739 
740  if (Symbol.isUndefined() && !Symbol.isBindingSet())
741  return false;
742 
743  if (Symbol.isTemporary())
744  return false;
745 
746  if (Symbol.getType() == ELF::STT_SECTION)
747  return false;
748 
749  return true;
750 }
751 
752 void ELFObjectWriter::computeSymbolTable(
753  MCAssembler &Asm, const MCAsmLayout &Layout,
754  const SectionIndexMapTy &SectionIndexMap, const RevGroupMapTy &RevGroupMap,
755  SectionOffsetsTy &SectionOffsets) {
756  MCContext &Ctx = Asm.getContext();
757  SymbolTableWriter Writer(*this, is64Bit());
758 
759  // Symbol table
760  unsigned EntrySize = is64Bit() ? ELF::SYMENTRY_SIZE64 : ELF::SYMENTRY_SIZE32;
761  MCSectionELF *SymtabSection =
762  Ctx.getELFSection(".symtab", ELF::SHT_SYMTAB, 0, EntrySize, "");
763  SymtabSection->setAlignment(is64Bit() ? 8 : 4);
764  SymbolTableIndex = addToSectionTable(SymtabSection);
765 
766  align(SymtabSection->getAlignment());
767  uint64_t SecStart = OS.tell();
768 
769  // The first entry is the undefined symbol entry.
770  Writer.writeSymbol(0, 0, 0, 0, 0, 0, false);
771 
772  std::vector<ELFSymbolData> LocalSymbolData;
773  std::vector<ELFSymbolData> ExternalSymbolData;
774 
775  // Add the data for the symbols.
776  bool HasLargeSectionIndex = false;
777  for (const MCSymbol &S : Asm.symbols()) {
778  const auto &Symbol = cast<MCSymbolELF>(S);
779  bool Used = Symbol.isUsedInReloc();
780  bool WeakrefUsed = Symbol.isWeakrefUsedInReloc();
781  bool isSignature = Symbol.isSignature();
782 
783  if (!isInSymtab(Layout, Symbol, Used || WeakrefUsed || isSignature,
784  Renames.count(&Symbol)))
785  continue;
786 
787  if (Symbol.isTemporary() && Symbol.isUndefined())
788  Ctx.reportFatalError(SMLoc(), "Undefined temporary");
789 
790  ELFSymbolData MSD;
791  MSD.Symbol = cast<MCSymbolELF>(&Symbol);
792 
793  bool Local = Symbol.getBinding() == ELF::STB_LOCAL;
794  assert(Local || !Symbol.isTemporary());
795 
796  if (Symbol.isAbsolute()) {
797  MSD.SectionIndex = ELF::SHN_ABS;
798  } else if (Symbol.isCommon()) {
799  assert(!Local);
800  MSD.SectionIndex = ELF::SHN_COMMON;
801  } else if (Symbol.isUndefined()) {
802  if (isSignature && !Used) {
803  MSD.SectionIndex = RevGroupMap.lookup(&Symbol);
804  if (MSD.SectionIndex >= ELF::SHN_LORESERVE)
805  HasLargeSectionIndex = true;
806  } else {
807  MSD.SectionIndex = ELF::SHN_UNDEF;
808  }
809  } else {
810  const MCSectionELF &Section =
811  static_cast<const MCSectionELF &>(Symbol.getSection());
812  MSD.SectionIndex = SectionIndexMap.lookup(&Section);
813  assert(MSD.SectionIndex && "Invalid section index!");
814  if (MSD.SectionIndex >= ELF::SHN_LORESERVE)
815  HasLargeSectionIndex = true;
816  }
817 
818  // The @@@ in symbol version is replaced with @ in undefined symbols and @@
819  // in defined ones.
820  //
821  // FIXME: All name handling should be done before we get to the writer,
822  // including dealing with GNU-style version suffixes. Fixing this isn't
823  // trivial.
824  //
825  // We thus have to be careful to not perform the symbol version replacement
826  // blindly:
827  //
828  // The ELF format is used on Windows by the MCJIT engine. Thus, on
829  // Windows, the ELFObjectWriter can encounter symbols mangled using the MS
830  // Visual Studio C++ name mangling scheme. Symbols mangled using the MSVC
831  // C++ name mangling can legally have "@@@" as a sub-string. In that case,
832  // the EFLObjectWriter should not interpret the "@@@" sub-string as
833  // specifying GNU-style symbol versioning. The ELFObjectWriter therefore
834  // checks for the MSVC C++ name mangling prefix which is either "?", "@?",
835  // "__imp_?" or "__imp_@?".
836  //
837  // It would have been interesting to perform the MS mangling prefix check
838  // only when the target triple is of the form *-pc-windows-elf. But, it
839  // seems that this information is not easily accessible from the
840  // ELFObjectWriter.
841  StringRef Name = Symbol.getName();
842  SmallString<32> Buf;
843  if (!Name.startswith("?") && !Name.startswith("@?") &&
844  !Name.startswith("__imp_?") && !Name.startswith("__imp_@?")) {
845  // This symbol isn't following the MSVC C++ name mangling convention. We
846  // can thus safely interpret the @@@ in symbol names as specifying symbol
847  // versioning.
848  size_t Pos = Name.find("@@@");
849  if (Pos != StringRef::npos) {
850  Buf += Name.substr(0, Pos);
851  unsigned Skip = MSD.SectionIndex == ELF::SHN_UNDEF ? 2 : 1;
852  Buf += Name.substr(Pos + Skip);
853  Name = Buf;
854  }
855  }
856 
857  // Sections have their own string table
858  if (Symbol.getType() != ELF::STT_SECTION)
859  MSD.Name = StrTabBuilder.add(Name);
860 
861  if (Local)
862  LocalSymbolData.push_back(MSD);
863  else
864  ExternalSymbolData.push_back(MSD);
865  }
866 
867  // This holds the .symtab_shndx section index.
868  unsigned SymtabShndxSectionIndex = 0;
869 
870  if (HasLargeSectionIndex) {
871  MCSectionELF *SymtabShndxSection =
872  Ctx.getELFSection(".symtab_shndxr", ELF::SHT_SYMTAB_SHNDX, 0, 4, "");
873  SymtabShndxSectionIndex = addToSectionTable(SymtabShndxSection);
874  SymtabShndxSection->setAlignment(4);
875  }
876 
877  ArrayRef<std::string> FileNames = Asm.getFileNames();
878  for (const std::string &Name : FileNames)
879  StrTabBuilder.add(Name);
880 
881  StrTabBuilder.finalize(StringTableBuilder::ELF);
882 
883  for (const std::string &Name : FileNames)
884  Writer.writeSymbol(StrTabBuilder.getOffset(Name),
886  ELF::SHN_ABS, true);
887 
888  // Symbols are required to be in lexicographic order.
889  array_pod_sort(LocalSymbolData.begin(), LocalSymbolData.end());
890  array_pod_sort(ExternalSymbolData.begin(), ExternalSymbolData.end());
891 
892  // Set the symbol indices. Local symbols must come before all other
893  // symbols with non-local bindings.
894  unsigned Index = FileNames.size() + 1;
895 
896  for (ELFSymbolData &MSD : LocalSymbolData) {
897  unsigned StringIndex = MSD.Symbol->getType() == ELF::STT_SECTION
898  ? 0
899  : StrTabBuilder.getOffset(MSD.Name);
900  MSD.Symbol->setIndex(Index++);
901  writeSymbol(Writer, StringIndex, MSD, Layout);
902  }
903 
904  // Write the symbol table entries.
905  LastLocalSymbolIndex = Index;
906 
907  for (ELFSymbolData &MSD : ExternalSymbolData) {
908  unsigned StringIndex = StrTabBuilder.getOffset(MSD.Name);
909  MSD.Symbol->setIndex(Index++);
910  writeSymbol(Writer, StringIndex, MSD, Layout);
911  assert(MSD.Symbol->getBinding() != ELF::STB_LOCAL);
912  }
913 
914  uint64_t SecEnd = OS.tell();
915  SectionOffsets[SymtabSection] = std::make_pair(SecStart, SecEnd);
916 
917  ArrayRef<uint32_t> ShndxIndexes = Writer.getShndxIndexes();
918  if (ShndxIndexes.empty()) {
919  assert(SymtabShndxSectionIndex == 0);
920  return;
921  }
922  assert(SymtabShndxSectionIndex != 0);
923 
924  SecStart = OS.tell();
925  const MCSectionELF *SymtabShndxSection =
926  SectionTable[SymtabShndxSectionIndex - 1];
927  for (uint32_t Index : ShndxIndexes)
928  write(Index);
929  SecEnd = OS.tell();
930  SectionOffsets[SymtabShndxSection] = std::make_pair(SecStart, SecEnd);
931 }
932 
933 MCSectionELF *
934 ELFObjectWriter::createRelocationSection(MCContext &Ctx,
935  const MCSectionELF &Sec) {
936  if (Relocations[&Sec].empty())
937  return nullptr;
938 
939  const StringRef SectionName = Sec.getSectionName();
940  std::string RelaSectionName = hasRelocationAddend() ? ".rela" : ".rel";
941  RelaSectionName += SectionName;
942 
943  unsigned EntrySize;
944  if (hasRelocationAddend())
945  EntrySize = is64Bit() ? sizeof(ELF::Elf64_Rela) : sizeof(ELF::Elf32_Rela);
946  else
947  EntrySize = is64Bit() ? sizeof(ELF::Elf64_Rel) : sizeof(ELF::Elf32_Rel);
948 
949  unsigned Flags = 0;
950  if (Sec.getFlags() & ELF::SHF_GROUP)
951  Flags = ELF::SHF_GROUP;
952 
953  MCSectionELF *RelaSection = Ctx.createELFRelSection(
954  RelaSectionName, hasRelocationAddend() ? ELF::SHT_RELA : ELF::SHT_REL,
955  Flags, EntrySize, Sec.getGroup(), &Sec);
956  RelaSection->setAlignment(is64Bit() ? 8 : 4);
957  return RelaSection;
958 }
959 
962  const MCSection::FragmentListType &Fragments) {
963  SmallVector<char, 128> UncompressedData;
964  for (const MCFragment &F : Fragments) {
965  const SmallVectorImpl<char> *Contents;
966  switch (F.getKind()) {
967  case MCFragment::FT_Data:
968  Contents = &cast<MCDataFragment>(F).getContents();
969  break;
970  case MCFragment::FT_Dwarf:
971  Contents = &cast<MCDwarfLineAddrFragment>(F).getContents();
972  break;
973  case MCFragment::FT_DwarfFrame:
974  Contents = &cast<MCDwarfCallFrameFragment>(F).getContents();
975  break;
976  default:
978  "Not expecting any other fragment types in a debug_* section");
979  }
980  UncompressedData.append(Contents->begin(), Contents->end());
981  }
982  return UncompressedData;
983 }
984 
985 // Include the debug info compression header:
986 // "ZLIB" followed by 8 bytes representing the uncompressed size of the section,
987 // useful for consumers to preallocate a buffer to decompress into.
988 static bool
990  SmallVectorImpl<char> &CompressedContents) {
991  const StringRef Magic = "ZLIB";
992  if (Size <= Magic.size() + sizeof(Size) + CompressedContents.size())
993  return false;
995  sys::swapByteOrder(Size);
996  CompressedContents.insert(CompressedContents.begin(),
997  Magic.size() + sizeof(Size), 0);
998  std::copy(Magic.begin(), Magic.end(), CompressedContents.begin());
999  std::copy(reinterpret_cast<char *>(&Size),
1000  reinterpret_cast<char *>(&Size + 1),
1001  CompressedContents.begin() + Magic.size());
1002  return true;
1003 }
1004 
1005 void ELFObjectWriter::writeSectionData(const MCAssembler &Asm, MCSection &Sec,
1006  const MCAsmLayout &Layout) {
1007  MCSectionELF &Section = static_cast<MCSectionELF &>(Sec);
1008  StringRef SectionName = Section.getSectionName();
1009 
1010  // Compressing debug_frame requires handling alignment fragments which is
1011  // more work (possibly generalizing MCAssembler.cpp:writeFragment to allow
1012  // for writing to arbitrary buffers) for little benefit.
1013  if (!Asm.getContext().getAsmInfo()->compressDebugSections() ||
1014  !SectionName.startswith(".debug_") || SectionName == ".debug_frame") {
1015  Asm.writeSectionData(&Section, Layout);
1016  return;
1017  }
1018 
1019  // Gather the uncompressed data from all the fragments.
1020  const MCSection::FragmentListType &Fragments = Section.getFragmentList();
1021  SmallVector<char, 128> UncompressedData =
1022  getUncompressedData(Layout, Fragments);
1023 
1024  SmallVector<char, 128> CompressedContents;
1026  StringRef(UncompressedData.data(), UncompressedData.size()),
1027  CompressedContents);
1028  if (Success != zlib::StatusOK) {
1029  Asm.writeSectionData(&Section, Layout);
1030  return;
1031  }
1032 
1033  if (!prependCompressionHeader(UncompressedData.size(), CompressedContents)) {
1034  Asm.writeSectionData(&Section, Layout);
1035  return;
1036  }
1037  Asm.getContext().renameELFSection(&Section,
1038  (".z" + SectionName.drop_front(1)).str());
1039  OS << CompressedContents;
1040 }
1041 
1042 void ELFObjectWriter::WriteSecHdrEntry(uint32_t Name, uint32_t Type,
1043  uint64_t Flags, uint64_t Address,
1044  uint64_t Offset, uint64_t Size,
1045  uint32_t Link, uint32_t Info,
1046  uint64_t Alignment,
1047  uint64_t EntrySize) {
1048  write32(Name); // sh_name: index into string table
1049  write32(Type); // sh_type
1050  WriteWord(Flags); // sh_flags
1051  WriteWord(Address); // sh_addr
1052  WriteWord(Offset); // sh_offset
1053  WriteWord(Size); // sh_size
1054  write32(Link); // sh_link
1055  write32(Info); // sh_info
1056  WriteWord(Alignment); // sh_addralign
1057  WriteWord(EntrySize); // sh_entsize
1058 }
1059 
1060 void ELFObjectWriter::writeRelocations(const MCAssembler &Asm,
1061  const MCSectionELF &Sec) {
1062  std::vector<ELFRelocationEntry> &Relocs = Relocations[&Sec];
1063 
1064  // Sort the relocation entries. Most targets just sort by Offset, but some
1065  // (e.g., MIPS) have additional constraints.
1066  TargetObjectWriter->sortRelocs(Asm, Relocs);
1067 
1068  for (unsigned i = 0, e = Relocs.size(); i != e; ++i) {
1069  const ELFRelocationEntry &Entry = Relocs[e - i - 1];
1070  unsigned Index = Entry.Symbol ? Entry.Symbol->getIndex() : 0;
1071 
1072  if (is64Bit()) {
1073  write(Entry.Offset);
1074  if (TargetObjectWriter->isN64()) {
1075  write(uint32_t(Index));
1076 
1077  write(TargetObjectWriter->getRSsym(Entry.Type));
1078  write(TargetObjectWriter->getRType3(Entry.Type));
1079  write(TargetObjectWriter->getRType2(Entry.Type));
1080  write(TargetObjectWriter->getRType(Entry.Type));
1081  } else {
1082  struct ELF::Elf64_Rela ERE64;
1083  ERE64.setSymbolAndType(Index, Entry.Type);
1084  write(ERE64.r_info);
1085  }
1086  if (hasRelocationAddend())
1087  write(Entry.Addend);
1088  } else {
1089  write(uint32_t(Entry.Offset));
1090 
1091  struct ELF::Elf32_Rela ERE32;
1092  ERE32.setSymbolAndType(Index, Entry.Type);
1093  write(ERE32.r_info);
1094 
1095  if (hasRelocationAddend())
1096  write(uint32_t(Entry.Addend));
1097  }
1098  }
1099 }
1100 
1101 const MCSectionELF *ELFObjectWriter::createStringTable(MCContext &Ctx) {
1102  const MCSectionELF *StrtabSection = SectionTable[StringTableIndex - 1];
1103  OS << StrTabBuilder.data();
1104  return StrtabSection;
1105 }
1106 
1107 void ELFObjectWriter::writeSection(const SectionIndexMapTy &SectionIndexMap,
1108  uint32_t GroupSymbolIndex, uint64_t Offset,
1109  uint64_t Size, const MCSectionELF &Section) {
1110  uint64_t sh_link = 0;
1111  uint64_t sh_info = 0;
1112 
1113  switch(Section.getType()) {
1114  default:
1115  // Nothing to do.
1116  break;
1117 
1118  case ELF::SHT_DYNAMIC:
1119  llvm_unreachable("SHT_DYNAMIC in a relocatable object");
1120 
1121  case ELF::SHT_REL:
1122  case ELF::SHT_RELA: {
1123  sh_link = SymbolTableIndex;
1124  assert(sh_link && ".symtab not found");
1125  const MCSectionELF *InfoSection = Section.getAssociatedSection();
1126  sh_info = SectionIndexMap.lookup(InfoSection);
1127  break;
1128  }
1129 
1130  case ELF::SHT_SYMTAB:
1131  case ELF::SHT_DYNSYM:
1132  sh_link = StringTableIndex;
1133  sh_info = LastLocalSymbolIndex;
1134  break;
1135 
1136  case ELF::SHT_SYMTAB_SHNDX:
1137  sh_link = SymbolTableIndex;
1138  break;
1139 
1140  case ELF::SHT_GROUP:
1141  sh_link = SymbolTableIndex;
1142  sh_info = GroupSymbolIndex;
1143  break;
1144  }
1145 
1146  if (TargetObjectWriter->getEMachine() == ELF::EM_ARM &&
1147  Section.getType() == ELF::SHT_ARM_EXIDX)
1148  sh_link = SectionIndexMap.lookup(Section.getAssociatedSection());
1149 
1150  WriteSecHdrEntry(StrTabBuilder.getOffset(Section.getSectionName()),
1151  Section.getType(), Section.getFlags(), 0, Offset, Size,
1152  sh_link, sh_info, Section.getAlignment(),
1153  Section.getEntrySize());
1154 }
1155 
1156 void ELFObjectWriter::writeSectionHeader(
1157  const MCAsmLayout &Layout, const SectionIndexMapTy &SectionIndexMap,
1158  const SectionOffsetsTy &SectionOffsets) {
1159  const unsigned NumSections = SectionTable.size();
1160 
1161  // Null section first.
1162  uint64_t FirstSectionSize =
1163  (NumSections + 1) >= ELF::SHN_LORESERVE ? NumSections + 1 : 0;
1164  WriteSecHdrEntry(0, 0, 0, 0, 0, FirstSectionSize, 0, 0, 0, 0);
1165 
1166  for (const MCSectionELF *Section : SectionTable) {
1167  uint32_t GroupSymbolIndex;
1168  unsigned Type = Section->getType();
1169  if (Type != ELF::SHT_GROUP)
1170  GroupSymbolIndex = 0;
1171  else
1172  GroupSymbolIndex = Section->getGroup()->getIndex();
1173 
1174  const std::pair<uint64_t, uint64_t> &Offsets =
1175  SectionOffsets.find(Section)->second;
1176  uint64_t Size;
1177  if (Type == ELF::SHT_NOBITS)
1178  Size = Layout.getSectionAddressSize(Section);
1179  else
1180  Size = Offsets.second - Offsets.first;
1181 
1182  writeSection(SectionIndexMap, GroupSymbolIndex, Offsets.first, Size,
1183  *Section);
1184  }
1185 }
1186 
1187 void ELFObjectWriter::writeObject(MCAssembler &Asm,
1188  const MCAsmLayout &Layout) {
1189  MCContext &Ctx = Asm.getContext();
1190  MCSectionELF *StrtabSection =
1191  Ctx.getELFSection(".strtab", ELF::SHT_STRTAB, 0);
1192  StringTableIndex = addToSectionTable(StrtabSection);
1193 
1194  RevGroupMapTy RevGroupMap;
1195  SectionIndexMapTy SectionIndexMap;
1196 
1197  std::map<const MCSymbol *, std::vector<const MCSectionELF *>> GroupMembers;
1198 
1199  // Write out the ELF header ...
1200  writeHeader(Asm);
1201 
1202  // ... then the sections ...
1203  SectionOffsetsTy SectionOffsets;
1204  std::vector<MCSectionELF *> Groups;
1205  std::vector<MCSectionELF *> Relocations;
1206  for (MCSection &Sec : Asm) {
1207  MCSectionELF &Section = static_cast<MCSectionELF &>(Sec);
1208 
1209  align(Section.getAlignment());
1210 
1211  // Remember the offset into the file for this section.
1212  uint64_t SecStart = OS.tell();
1213 
1214  const MCSymbolELF *SignatureSymbol = Section.getGroup();
1215  writeSectionData(Asm, Section, Layout);
1216 
1217  uint64_t SecEnd = OS.tell();
1218  SectionOffsets[&Section] = std::make_pair(SecStart, SecEnd);
1219 
1220  MCSectionELF *RelSection = createRelocationSection(Ctx, Section);
1221 
1222  if (SignatureSymbol) {
1223  Asm.registerSymbol(*SignatureSymbol);
1224  unsigned &GroupIdx = RevGroupMap[SignatureSymbol];
1225  if (!GroupIdx) {
1226  MCSectionELF *Group = Ctx.createELFGroupSection(SignatureSymbol);
1227  GroupIdx = addToSectionTable(Group);
1228  Group->setAlignment(4);
1229  Groups.push_back(Group);
1230  }
1231  std::vector<const MCSectionELF *> &Members =
1232  GroupMembers[SignatureSymbol];
1233  Members.push_back(&Section);
1234  if (RelSection)
1235  Members.push_back(RelSection);
1236  }
1237 
1238  SectionIndexMap[&Section] = addToSectionTable(&Section);
1239  if (RelSection) {
1240  SectionIndexMap[RelSection] = addToSectionTable(RelSection);
1241  Relocations.push_back(RelSection);
1242  }
1243  }
1244 
1245  for (MCSectionELF *Group : Groups) {
1246  align(Group->getAlignment());
1247 
1248  // Remember the offset into the file for this section.
1249  uint64_t SecStart = OS.tell();
1250 
1251  const MCSymbol *SignatureSymbol = Group->getGroup();
1252  assert(SignatureSymbol);
1253  write(uint32_t(ELF::GRP_COMDAT));
1254  for (const MCSectionELF *Member : GroupMembers[SignatureSymbol]) {
1255  uint32_t SecIndex = SectionIndexMap.lookup(Member);
1256  write(SecIndex);
1257  }
1258 
1259  uint64_t SecEnd = OS.tell();
1260  SectionOffsets[Group] = std::make_pair(SecStart, SecEnd);
1261  }
1262 
1263  // Compute symbol table information.
1264  computeSymbolTable(Asm, Layout, SectionIndexMap, RevGroupMap, SectionOffsets);
1265 
1266  for (MCSectionELF *RelSection : Relocations) {
1267  align(RelSection->getAlignment());
1268 
1269  // Remember the offset into the file for this section.
1270  uint64_t SecStart = OS.tell();
1271 
1272  writeRelocations(Asm, *RelSection->getAssociatedSection());
1273 
1274  uint64_t SecEnd = OS.tell();
1275  SectionOffsets[RelSection] = std::make_pair(SecStart, SecEnd);
1276  }
1277 
1278  {
1279  uint64_t SecStart = OS.tell();
1280  const MCSectionELF *Sec = createStringTable(Ctx);
1281  uint64_t SecEnd = OS.tell();
1282  SectionOffsets[Sec] = std::make_pair(SecStart, SecEnd);
1283  }
1284 
1285  uint64_t NaturalAlignment = is64Bit() ? 8 : 4;
1286  align(NaturalAlignment);
1287 
1288  const unsigned SectionHeaderOffset = OS.tell();
1289 
1290  // ... then the section header table ...
1291  writeSectionHeader(Layout, SectionIndexMap, SectionOffsets);
1292 
1293  uint16_t NumSections = (SectionTable.size() + 1 >= ELF::SHN_LORESERVE)
1294  ? (uint16_t)ELF::SHN_UNDEF
1295  : SectionTable.size() + 1;
1296  if (sys::IsLittleEndianHost != IsLittleEndian)
1297  sys::swapByteOrder(NumSections);
1298  unsigned NumSectionsOffset;
1299 
1300  if (is64Bit()) {
1301  uint64_t Val = SectionHeaderOffset;
1302  if (sys::IsLittleEndianHost != IsLittleEndian)
1303  sys::swapByteOrder(Val);
1304  OS.pwrite(reinterpret_cast<char *>(&Val), sizeof(Val),
1305  offsetof(ELF::Elf64_Ehdr, e_shoff));
1306  NumSectionsOffset = offsetof(ELF::Elf64_Ehdr, e_shnum);
1307  } else {
1308  uint32_t Val = SectionHeaderOffset;
1309  if (sys::IsLittleEndianHost != IsLittleEndian)
1310  sys::swapByteOrder(Val);
1311  OS.pwrite(reinterpret_cast<char *>(&Val), sizeof(Val),
1312  offsetof(ELF::Elf32_Ehdr, e_shoff));
1313  NumSectionsOffset = offsetof(ELF::Elf32_Ehdr, e_shnum);
1314  }
1315  OS.pwrite(reinterpret_cast<char *>(&NumSections), sizeof(NumSections),
1316  NumSectionsOffset);
1317 }
1318 
1319 bool ELFObjectWriter::isSymbolRefDifferenceFullyResolvedImpl(
1320  const MCAssembler &Asm, const MCSymbol &SA, const MCFragment &FB,
1321  bool InSet, bool IsPCRel) const {
1322  const auto &SymA = cast<MCSymbolELF>(SA);
1323  if (IsPCRel) {
1324  assert(!InSet);
1325  if (::isWeak(SymA))
1326  return false;
1327  }
1328  return MCObjectWriter::isSymbolRefDifferenceFullyResolvedImpl(Asm, SymA, FB,
1329  InSet, IsPCRel);
1330 }
1331 
1332 bool ELFObjectWriter::isWeak(const MCSymbol &S) const {
1333  const auto &Sym = cast<MCSymbolELF>(S);
1334  if (::isWeak(Sym))
1335  return true;
1336 
1337  // It is invalid to replace a reference to a global in a comdat
1338  // with a reference to a local since out of comdat references
1339  // to a local are forbidden.
1340  // We could try to return false for more cases, like the reference
1341  // being in the same comdat or Sym being an alias to another global,
1342  // but it is not clear if it is worth the effort.
1343  if (Sym.getBinding() != ELF::STB_GLOBAL)
1344  return false;
1345 
1346  if (!Sym.isInSection())
1347  return false;
1348 
1349  const auto &Sec = cast<MCSectionELF>(Sym.getSection());
1350  return Sec.getGroup();
1351 }
1352 
1354  raw_pwrite_stream &OS,
1355  bool IsLittleEndian) {
1356  return new ELFObjectWriter(MOTW, OS, IsLittleEndian);
1357 }
bool evaluateKnownAbsolute(int64_t &Res, const MCAsmLayout &Layout) const
Definition: MCExpr.cpp:428
Instances of this class represent a uniqued identifier for a section in the current translation unit...
Definition: MCSection.h:48
const MCAsmInfo * getAsmInfo() const
Definition: MCContext.h:225
StringRef getSectionName() const
Definition: MCSectionELF.h:75
void setSymbolAndType(Elf32_Word s, unsigned char t)
Definition: Support/ELF.h:882
void swapByteOrder(T &Value)
const MCSymbol & getSymbol() const
Definition: MCExpr.h:328
SMLoc getLoc() const
Definition: MCFixup.h:108
bool isBindingSet() const
size_t size() const
size - Get the string size.
Definition: StringRef.h:113
This represents an "assembler immediate".
Definition: MCValue.h:44
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:39
MCSectionELF * getELFSection(StringRef Section, unsigned Type, unsigned Flags)
Definition: MCContext.h:311
size_t find(char C, size_t From=0) const
Search for the first character C in the string.
Definition: StringRef.h:240
void setAlignment(unsigned Value)
Definition: MCSection.h:125
LLVM_ATTRIBUTE_NORETURN void reportFatalError(SMLoc L, const Twine &Msg) const
Definition: MCContext.cpp:474
unsigned getFlags() const
Definition: MCSectionELF.h:77
StringRef substr(size_t Start, size_t N=npos) const
Return a reference to the substring from [Start, Start + N).
Definition: StringRef.h:405
Offsets
Offsets in bytes from the start of the input buffer.
Definition: SIInstrInfo.h:378
bool getSymbolOffset(const MCSymbol &S, uint64_t &Val) const
Get the offset of the given symbol, as computed in the current layout.
unsigned getEntrySize() const
Definition: MCSectionELF.h:78
F(f)
ELFYAML::ELF_STV Visibility
Definition: ELFYAML.cpp:590
void setSymbolAndType(Elf64_Word s, Elf64_Word t)
Definition: Support/ELF.h:919
bool isExternal() const
Definition: MCSymbol.h:389
unsigned getELFHeaderEFlags() const
ELF e_header flags.
Definition: MCAssembler.h:700
unsigned getAlignment() const
Definition: MCSection.h:124
static SmallVector< char, 128 > getUncompressedData(const MCAsmLayout &Layout, const MCSection::FragmentListType &Fragments)
MCContext & getContext() const
Definition: MCAssembler.h:731
Defines the object file and target independent interfaces used by the assembler backend to write nati...
LLVM_ATTRIBUTE_NORETURN void report_fatal_error(const char *reason, bool gen_crash_diag=true)
Reports a serious error, calling any installed error handler.
Encode information on a single operation to perform on a byte sequence (e.g., an encoded instruction)...
Definition: MCFixup.h:62
lazy value info
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:79
void renameELFSection(MCSectionELF *Section, StringRef Name)
Definition: MCContext.cpp:300
Encapsulates the layout of an assembly file at a particular point in time.
Definition: MCAsmLayout.h:29
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:98
const MCExpr * getVariableValue() const
getVariableValue() - Get the value for variable symbols.
Definition: MCSymbol.h:299
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:33
Status compress(StringRef InputBuffer, SmallVectorImpl< char > &CompressedBuffer, CompressionLevel Level=DefaultCompression)
Definition: Compression.cpp:49
Represent a reference to a symbol from inside an expression.
Definition: MCExpr.h:159
ELFYAML::ELF_STO Other
Definition: ELFYAML.cpp:591
ArrayRef< std::string > getFileNames()
Definition: MCAssembler.h:869
Context object for machine code objects.
Definition: MCContext.h:48
bool isInSection() const
isInSection - Check if this symbol is defined in some section (i.e., it is defined but not absolute)...
Definition: MCSymbol.h:255
static const bool IsLittleEndianHost
Definition: Host.h:38
Utility for building string tables with deduplicated suffixes.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: ArrayRef.h:31
const MCSymbolELF * getGroup() const
Definition: MCSectionELF.h:79
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition: SmallString.h:25
bool isThumbFunc(const MCSymbol *Func) const
Check whether a given symbol has been flagged with .thumb_func.
static uint8_t mergeTypeForSet(uint8_t origType, uint8_t newType)
bool isSignature() const
uint32_t getOffset() const
Definition: MCFixup.h:91
iterator begin() const
Definition: StringRef.h:90
const MCSymbol * getBaseSymbol(const MCSymbol &Symbol) const
If this symbol is equivalent to A + Constant, return A.
void array_pod_sort(IteratorTy Start, IteratorTy End)
array_pod_sort - This sorts an array with the specified start and end extent.
Definition: STLExtras.h:287
void writeSectionData(const MCSection *Section, const MCAsmLayout &Layout) const
Emit the section contents using the given object writer.
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
unsigned getType() const
static bool is64Bit(const char *name)
uint32_t getIndex() const
Get the (implementation defined) index.
Definition: MCSymbol.h:310
virtual void reset()
lifetime management
MCFixupKind
Extensible enumeration to represent the type of a fixup.
Definition: MCFixup.h:23
unsigned getBinding() const
Definition: MCSymbolELF.cpp:66
unsigned getCommonAlignment() const
Return the alignment of a 'common' symbol.
Definition: MCSymbol.h:357
uint64_t getSectionAddressSize(const MCSection *Sec) const
Get the address space size of the given section, as it effects layout.
const MCSectionELF * getAssociatedSection() const
Definition: MCSectionELF.h:89
MCSectionELF * createELFRelSection(StringRef Name, unsigned Type, unsigned Flags, unsigned EntrySize, const MCSymbolELF *Group, const MCSectionELF *Associated)
Definition: MCContext.cpp:316
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:129
void append(in_iter in_start, in_iter in_end)
Add the specified range to the end of the SmallVector.
Definition: SmallVector.h:416
const MCSymbolRefExpr * getSymB() const
Definition: MCValue.h:52
bool isAbsolute() const
isAbsolute - Check if this is an absolute symbol.
Definition: MCSymbol.h:261
PowerPC TLS Dynamic Call Fixup
static const char *const Magic
Definition: Archive.cpp:26
static const char ElfMagic[]
Definition: Support/ELF.h:46
bool startswith(StringRef Prefix) const
Check if this string starts with the given Prefix.
Definition: StringRef.h:215
StringRef drop_front(size_t N=1) const
Return a StringRef equal to 'this' but with the first N elements dropped.
Definition: StringRef.h:412
const MCSymbolRefExpr * getSymA() const
Definition: MCValue.h:51
bool isUsedInReloc() const
Definition: MCSymbol.h:216
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:861
MCSection & getSection() const
Get the section associated with a defined, non-absolute symbol.
Definition: MCSymbol.h:264
MCSection * getParent() const
Definition: MCAssembler.h:118
Target - Wrapper for Target specific information.
static bool isWeak(const MCSymbolELF &Sym)
bool isTemporary() const
isTemporary - Check if this is an assembler temporary symbol.
Definition: MCSymbol.h:222
LLVM_ATTRIBUTE_UNUSED_RESULT std::enable_if< !is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:285
bool compressDebugSections() const
Definition: MCAsmInfo.h:550
iterator insert(iterator I, T &&Elt)
Definition: SmallVector.h:481
void write(void *memory, value_type value)
Write a value to memory with a particular endianness.
Definition: Endian.h:73
#define Success
MCObjectWriter * createELFObjectWriter(MCELFObjectTargetWriter *MOTW, raw_pwrite_stream &OS, bool IsLittleEndian)
Construct a new ELF writer instance.
Adapter to write values to a stream in a particular byte order.
Definition: EndianStream.h:26
StringRef getName() const
getName - Get the symbol name.
Definition: MCSymbol.h:205
pointer data()
Return a pointer to the vector's buffer, even if empty().
Definition: SmallVector.h:134
MCAsmBackend & getBackend() const
Definition: MCAssembler.h:733
bool isCommon() const
Is this a 'common' symbol.
Definition: MCSymbol.h:378
void size_t size
MCSectionELF - This represents a section on linux, lots of unix variants and some bare metal systems...
Definition: MCSectionELF.h:30
uint64_t getFragmentOffset(const MCFragment *F) const
Get the offset of the given fragment inside its containing section.
symbol_range symbols()
Definition: MCAssembler.h:781
static bool prependCompressionHeader(uint64_t Size, SmallVectorImpl< char > &CompressedContents)
MCSectionELF * createELFGroupSection(const MCSymbolELF *Group)
Definition: MCContext.cpp:376
Target independent information on a fixup kind.
bool isVariable() const
isVariable - Check if this is a variable symbol.
Definition: MCSymbol.h:294
An abstract base class for streams implementations that also support a pwrite operation.
Definition: raw_ostream.h:321
VariantKind getKind() const
Definition: MCExpr.h:330
int64_t getConstant() const
Definition: MCValue.h:50
const ARM::ArchExtKind Kind
bool operator<(int64_t V1, const APSInt &V2)
Definition: APSInt.h:332
LLVM Value Representation.
Definition: Value.h:69
static const char * name
bool isWeakrefUsedInReloc() const
MCAssembler & getAssembler() const
Get the assembler object this is a layout for.
Definition: MCAsmLayout.h:51
uint64_t OffsetToAlignment(uint64_t Value, uint64_t Align)
Returns the offset to the next integer (mod 2**64) that is greater than or equal to Value and is a mu...
Definition: MathExtras.h:616
iterator end() const
Definition: StringRef.h:92
C - The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
unsigned getType() const
Definition: MCSectionELF.h:76
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:40
bool isUndefined() const
isUndefined - Check if this symbol undefined (i.e., implicitly defined).
Definition: MCSymbol.h:258
const MCSymbolELF * Symbol
Represents a location in source code.
Definition: SMLoc.h:23
virtual const MCFixupKindInfo & getFixupKindInfo(MCFixupKind Kind) const
Get information on a fixup kind.
MCSection::FragmentListType & getFragmentList()
Definition: MCSection.h:150
unsigned Flags
Flags describing additional information on this fixup kind.