LLVM  10.0.0svn
XCOFFObjectWriter.cpp
Go to the documentation of this file.
1 //===-- lib/MC/XCOFFObjectWriter.cpp - XCOFF 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 XCOFF object file writer information.
10 //
11 //===----------------------------------------------------------------------===//
12 
14 #include "llvm/MC/MCAsmLayout.h"
15 #include "llvm/MC/MCAssembler.h"
16 #include "llvm/MC/MCObjectWriter.h"
17 #include "llvm/MC/MCSectionXCOFF.h"
18 #include "llvm/MC/MCSymbolXCOFF.h"
19 #include "llvm/MC/MCValue.h"
22 #include "llvm/Support/Error.h"
24 
25 #include <deque>
26 
27 using namespace llvm;
28 
29 // An XCOFF object file has a limited set of predefined sections. The most
30 // important ones for us (right now) are:
31 // .text --> contains program code and read-only data.
32 // .data --> contains initialized data, function descriptors, and the TOC.
33 // .bss --> contains uninitialized data.
34 // Each of these sections is composed of 'Control Sections'. A Control Section
35 // is more commonly referred to as a csect. A csect is an indivisible unit of
36 // code or data, and acts as a container for symbols. A csect is mapped
37 // into a section based on its storage-mapping class, with the exception of
38 // XMC_RW which gets mapped to either .data or .bss based on whether it's
39 // explicitly initialized or not.
40 //
41 // We don't represent the sections in the MC layer as there is nothing
42 // interesting about them at at that level: they carry information that is
43 // only relevant to the ObjectWriter, so we materialize them in this class.
44 namespace {
45 
46 constexpr unsigned DefaultSectionAlign = 4;
47 
48 // Packs the csect's alignment and type into a byte.
49 uint8_t getEncodedType(const MCSectionXCOFF *);
50 
51 // Wrapper around an MCSymbolXCOFF.
52 struct Symbol {
53  const MCSymbolXCOFF *const MCSym;
54  uint32_t SymbolTableIndex;
55 
56  XCOFF::StorageClass getStorageClass() const {
57  return MCSym->getStorageClass();
58  }
59  StringRef getName() const { return MCSym->getName(); }
60  Symbol(const MCSymbolXCOFF *MCSym) : MCSym(MCSym), SymbolTableIndex(-1) {}
61 };
62 
63 // Wrapper for an MCSectionXCOFF.
64 struct ControlSection {
65  const MCSectionXCOFF *const MCCsect;
66  uint32_t SymbolTableIndex;
68  uint32_t Size;
69 
71  StringRef getName() const { return MCCsect->getSectionName(); }
72  ControlSection(const MCSectionXCOFF *MCSec)
73  : MCCsect(MCSec), SymbolTableIndex(-1), Address(-1), Size(0) {}
74 };
75 
76 // Represents the data related to a section excluding the csects that make up
77 // the raw data of the section. The csects are stored separately as not all
78 // sections contain csects, and some sections contain csects which are better
79 // stored separately, e.g. the .data section containing read-write, descriptor,
80 // TOCBase and TOC-entry csects.
81 struct Section {
82  char Name[XCOFF::NameSize];
83  // The physical/virtual address of the section. For an object file
84  // these values are equivalent.
86  uint32_t Size;
87  uint32_t FileOffsetToData;
88  uint32_t FileOffsetToRelocations;
89  uint32_t RelocationCount;
90  int32_t Flags;
91 
92  int16_t Index;
93 
94  // Virtual sections do not need storage allocated in the object file.
95  const bool IsVirtual;
96 
97  void reset() {
98  Address = 0;
99  Size = 0;
100  FileOffsetToData = 0;
101  FileOffsetToRelocations = 0;
102  RelocationCount = 0;
103  Index = -1;
104  }
105 
106  Section(const char *N, XCOFF::SectionTypeFlags Flags, bool IsVirtual)
107  : Address(0), Size(0), FileOffsetToData(0), FileOffsetToRelocations(0),
108  RelocationCount(0), Flags(Flags), Index(-1), IsVirtual(IsVirtual) {
109  strncpy(Name, N, XCOFF::NameSize);
110  }
111 };
112 
113 class XCOFFObjectWriter : public MCObjectWriter {
114  // Type to be used for a container representing a set of csects with
115  // (approximately) the same storage mapping class. For example all the csects
116  // with a storage mapping class of `xmc_pr` will get placed into the same
117  // container.
118  using CsectGroup = std::deque<ControlSection>;
119 
121  std::unique_ptr<MCXCOFFObjectTargetWriter> TargetObjectWriter;
122  StringTableBuilder Strings;
123 
124  // The non-empty sections, in the order they will appear in the section header
125  // table.
126  std::vector<Section *> Sections;
127 
128  // The Predefined sections.
129  Section Text;
130  Section BSS;
131 
132  // CsectGroups. These store the csects which make up different parts of
133  // the sections. Should have one for each set of csects that get mapped into
134  // the same section and get handled in a 'similar' way.
135  CsectGroup ProgramCodeCsects;
136  CsectGroup BSSCsects;
137 
138  uint32_t SymbolTableEntryCount = 0;
139  uint32_t SymbolTableOffset = 0;
140 
141  virtual void reset() override;
142 
143  void executePostLayoutBinding(MCAssembler &, const MCAsmLayout &) override;
144 
145  void recordRelocation(MCAssembler &, const MCAsmLayout &, const MCFragment *,
146  const MCFixup &, MCValue, uint64_t &) override;
147 
148  uint64_t writeObject(MCAssembler &, const MCAsmLayout &) override;
149 
150  static bool nameShouldBeInStringTable(const StringRef &);
151  void writeSymbolName(const StringRef &);
152  void writeSymbolTableEntryForCsectMemberLabel(const Symbol &,
153  const ControlSection &, int16_t,
154  uint64_t);
155  void writeSymbolTableEntryForControlSection(const ControlSection &, int16_t,
157  void writeFileHeader();
158  void writeSectionHeaderTable();
159  void writeSections(const MCAssembler &Asm, const MCAsmLayout &Layout);
160  void writeSymbolTable(const MCAsmLayout &Layout);
161 
162  // Called after all the csects and symbols have been processed by
163  // `executePostLayoutBinding`, this function handles building up the majority
164  // of the structures in the object file representation. Namely:
165  // *) Calculates physical/virtual addresses, raw-pointer offsets, and section
166  // sizes.
167  // *) Assigns symbol table indices.
168  // *) Builds up the section header table by adding any non-empty sections to
169  // `Sections`.
170  void assignAddressesAndIndices(const MCAsmLayout &);
171 
172  bool
173  needsAuxiliaryHeader() const { /* TODO aux header support not implemented. */
174  return false;
175  }
176 
177  // Returns the size of the auxiliary header to be written to the object file.
178  size_t auxiliaryHeaderSize() const {
179  assert(!needsAuxiliaryHeader() &&
180  "Auxiliary header support not implemented.");
181  return 0;
182  }
183 
184 public:
185  XCOFFObjectWriter(std::unique_ptr<MCXCOFFObjectTargetWriter> MOTW,
186  raw_pwrite_stream &OS);
187 };
188 
189 XCOFFObjectWriter::XCOFFObjectWriter(
190  std::unique_ptr<MCXCOFFObjectTargetWriter> MOTW, raw_pwrite_stream &OS)
191  : W(OS, support::big), TargetObjectWriter(std::move(MOTW)),
192  Strings(StringTableBuilder::XCOFF),
193  Text(".text", XCOFF::STYP_TEXT, /* IsVirtual */ false),
194  BSS(".bss", XCOFF::STYP_BSS, /* IsVirtual */ true) {}
195 
196 void XCOFFObjectWriter::reset() {
197  // Reset any sections we have written to, and empty the section header table.
198  for (auto *Sec : Sections)
199  Sec->reset();
200  Sections.clear();
201 
202  // Clear any csects we have stored.
203  ProgramCodeCsects.clear();
204  BSSCsects.clear();
205 
206  // Reset the symbol table and string table.
207  SymbolTableEntryCount = 0;
208  SymbolTableOffset = 0;
209  Strings.clear();
210 
212 }
213 
214 void XCOFFObjectWriter::executePostLayoutBinding(MCAssembler &Asm,
215  const MCAsmLayout &Layout) {
216  if (TargetObjectWriter->is64Bit())
217  report_fatal_error("64-bit XCOFF object files are not supported yet.");
218 
219  // Maps the MC Section representation to its corresponding ControlSection
220  // wrapper. Needed for finding the ControlSection to insert an MCSymbol into
221  // from its containing MCSectionXCOFF.
223 
224  for (const auto &S : Asm) {
225  const auto *MCSec = cast<const MCSectionXCOFF>(&S);
226  assert(WrapperMap.find(MCSec) == WrapperMap.end() &&
227  "Cannot add a csect twice.");
228 
229  // If the name does not fit in the storage provided in the symbol table
230  // entry, add it to the string table.
231  if (nameShouldBeInStringTable(MCSec->getSectionName()))
232  Strings.add(MCSec->getSectionName());
233 
234  switch (MCSec->getMappingClass()) {
235  case XCOFF::XMC_PR:
236  assert(XCOFF::XTY_SD == MCSec->getCSectType() &&
237  "Only an initialized csect can contain program code.");
238  ProgramCodeCsects.emplace_back(MCSec);
239  WrapperMap[MCSec] = &ProgramCodeCsects.back();
240  break;
241  case XCOFF::XMC_RW:
242  if (XCOFF::XTY_CM == MCSec->getCSectType()) {
243  BSSCsects.emplace_back(MCSec);
244  WrapperMap[MCSec] = &BSSCsects.back();
245  break;
246  }
247  report_fatal_error("Unhandled mapping of read-write csect to section.");
248  case XCOFF::XMC_TC0:
249  // TODO FIXME Handle emiting the TOC base.
250  break;
251  case XCOFF::XMC_BS:
252  assert(XCOFF::XTY_CM == MCSec->getCSectType() &&
253  "Mapping invalid csect. CSECT with bss storage class must be "
254  "common type.");
255  BSSCsects.emplace_back(MCSec);
256  WrapperMap[MCSec] = &BSSCsects.back();
257  break;
258  default:
259  report_fatal_error("Unhandled mapping of csect to section.");
260  }
261  }
262 
263  for (const MCSymbol &S : Asm.symbols()) {
264  // Nothing to do for temporary symbols.
265  if (S.isTemporary())
266  continue;
267  const MCSymbolXCOFF *XSym = cast<MCSymbolXCOFF>(&S);
268 
269  // Map the symbol into its containing csect.
270  const MCSectionXCOFF *ContainingCsect = XSym->getContainingCsect();
271  assert(WrapperMap.find(ContainingCsect) != WrapperMap.end() &&
272  "Expected containing csect to exist in map");
273 
274  // Lookup the containing csect and add the symbol to it.
275  WrapperMap[ContainingCsect]->Syms.emplace_back(XSym);
276 
277  // If the name does not fit in the storage provided in the symbol table
278  // entry, add it to the string table.
279  if (nameShouldBeInStringTable(XSym->getName()))
280  Strings.add(XSym->getName());
281  }
282 
283  Strings.finalize();
284  assignAddressesAndIndices(Layout);
285 }
286 
287 void XCOFFObjectWriter::recordRelocation(MCAssembler &, const MCAsmLayout &,
288  const MCFragment *, const MCFixup &,
289  MCValue, uint64_t &) {
290  report_fatal_error("XCOFF relocations not supported.");
291 }
292 
293 void XCOFFObjectWriter::writeSections(const MCAssembler &Asm,
294  const MCAsmLayout &Layout) {
295  // Write the program code control sections one at a time.
296  uint32_t CurrentAddressLocation = Text.Address;
297  for (const auto &Csect : ProgramCodeCsects) {
298  if (uint32_t PaddingSize = Csect.Address - CurrentAddressLocation)
299  W.OS.write_zeros(PaddingSize);
300  Asm.writeSectionData(W.OS, Csect.MCCsect, Layout);
301  CurrentAddressLocation = Csect.Address + Csect.Size;
302  }
303 
304  if (Text.Index != -1) {
305  // The size of the tail padding in a section is the end virtual address of
306  // the current section minus the the end virtual address of the last csect
307  // in that section.
308  if (uint32_t PaddingSize =
309  Text.Address + Text.Size - CurrentAddressLocation)
310  W.OS.write_zeros(PaddingSize);
311  }
312 }
313 
314 uint64_t XCOFFObjectWriter::writeObject(MCAssembler &Asm,
315  const MCAsmLayout &Layout) {
316  // We always emit a timestamp of 0 for reproducibility, so ensure incremental
317  // linking is not enabled, in case, like with Windows COFF, such a timestamp
318  // is incompatible with incremental linking of XCOFF.
320  report_fatal_error("Incremental linking not supported for XCOFF.");
321 
322  if (TargetObjectWriter->is64Bit())
323  report_fatal_error("64-bit XCOFF object files are not supported yet.");
324 
325  uint64_t StartOffset = W.OS.tell();
326 
327  writeFileHeader();
328  writeSectionHeaderTable();
329  writeSections(Asm, Layout);
330  // TODO writeRelocations();
331 
332  writeSymbolTable(Layout);
333  // Write the string table.
334  Strings.write(W.OS);
335 
336  return W.OS.tell() - StartOffset;
337 }
338 
339 bool XCOFFObjectWriter::nameShouldBeInStringTable(const StringRef &SymbolName) {
340  return SymbolName.size() > XCOFF::NameSize;
341 }
342 
343 void XCOFFObjectWriter::writeSymbolName(const StringRef &SymbolName) {
344  if (nameShouldBeInStringTable(SymbolName)) {
345  W.write<int32_t>(0);
346  W.write<uint32_t>(Strings.getOffset(SymbolName));
347  } else {
348  char Name[XCOFF::NameSize];
349  std::strncpy(Name, SymbolName.data(), XCOFF::NameSize);
350  ArrayRef<char> NameRef(Name, XCOFF::NameSize);
351  W.write(NameRef);
352  }
353 }
354 
355 void XCOFFObjectWriter::writeSymbolTableEntryForCsectMemberLabel(
356  const Symbol &SymbolRef, const ControlSection &CSectionRef,
357  int16_t SectionIndex, uint64_t SymbolOffset) {
358  // Name or Zeros and string table offset
359  writeSymbolName(SymbolRef.getName());
360  assert(SymbolOffset <= UINT32_MAX - CSectionRef.Address &&
361  "Symbol address overflows.");
362  W.write<uint32_t>(CSectionRef.Address + SymbolOffset);
363  W.write<int16_t>(SectionIndex);
364  // Basic/Derived type. See the description of the n_type field for symbol
365  // table entries for a detailed description. Since we don't yet support
366  // visibility, and all other bits are either optionally set or reserved, this
367  // is always zero.
368  // TODO FIXME How to assert a symbol's visibilty is default?
369  // TODO Set the function indicator (bit 10, 0x0020) for functions
370  // when debugging is enabled.
371  W.write<uint16_t>(0);
372  W.write<uint8_t>(SymbolRef.getStorageClass());
373  // Always 1 aux entry for now.
374  W.write<uint8_t>(1);
375 
376  // Now output the auxiliary entry.
377  W.write<uint32_t>(CSectionRef.SymbolTableIndex);
378  // Parameter typecheck hash. Not supported.
379  W.write<uint32_t>(0);
380  // Typecheck section number. Not supported.
381  W.write<uint16_t>(0);
382  // Symbol type: Label
383  W.write<uint8_t>(XCOFF::XTY_LD);
384  // Storage mapping class.
385  W.write<uint8_t>(CSectionRef.MCCsect->getMappingClass());
386  // Reserved (x_stab).
387  W.write<uint32_t>(0);
388  // Reserved (x_snstab).
389  W.write<uint16_t>(0);
390 }
391 
392 void XCOFFObjectWriter::writeSymbolTableEntryForControlSection(
393  const ControlSection &CSectionRef, int16_t SectionIndex,
395  // n_name, n_zeros, n_offset
396  writeSymbolName(CSectionRef.getName());
397  // n_value
398  W.write<uint32_t>(CSectionRef.Address);
399  // n_scnum
400  W.write<int16_t>(SectionIndex);
401  // Basic/Derived type. See the description of the n_type field for symbol
402  // table entries for a detailed description. Since we don't yet support
403  // visibility, and all other bits are either optionally set or reserved, this
404  // is always zero.
405  // TODO FIXME How to assert a symbol's visibilty is default?
406  // TODO Set the function indicator (bit 10, 0x0020) for functions
407  // when debugging is enabled.
408  W.write<uint16_t>(0);
409  // n_sclass
410  W.write<uint8_t>(StorageClass);
411  // Always 1 aux entry for now.
412  W.write<uint8_t>(1);
413 
414  // Now output the auxiliary entry.
415  W.write<uint32_t>(CSectionRef.Size);
416  // Parameter typecheck hash. Not supported.
417  W.write<uint32_t>(0);
418  // Typecheck section number. Not supported.
419  W.write<uint16_t>(0);
420  // Symbol type.
421  W.write<uint8_t>(getEncodedType(CSectionRef.MCCsect));
422  // Storage mapping class.
423  W.write<uint8_t>(CSectionRef.MCCsect->getMappingClass());
424  // Reserved (x_stab).
425  W.write<uint32_t>(0);
426  // Reserved (x_snstab).
427  W.write<uint16_t>(0);
428 }
429 
430 void XCOFFObjectWriter::writeFileHeader() {
431  // Magic.
432  W.write<uint16_t>(0x01df);
433  // Number of sections.
434  W.write<uint16_t>(Sections.size());
435  // Timestamp field. For reproducible output we write a 0, which represents no
436  // timestamp.
437  W.write<int32_t>(0);
438  // Byte Offset to the start of the symbol table.
439  W.write<uint32_t>(SymbolTableOffset);
440  // Number of entries in the symbol table.
441  W.write<int32_t>(SymbolTableEntryCount);
442  // Size of the optional header.
443  W.write<uint16_t>(0);
444  // Flags.
445  W.write<uint16_t>(0);
446 }
447 
448 void XCOFFObjectWriter::writeSectionHeaderTable() {
449  for (const auto *Sec : Sections) {
450  // Write Name.
451  ArrayRef<char> NameRef(Sec->Name, XCOFF::NameSize);
452  W.write(NameRef);
453 
454  // Write the Physical Address and Virtual Address. In an object file these
455  // are the same.
456  W.write<uint32_t>(Sec->Address);
457  W.write<uint32_t>(Sec->Address);
458 
459  W.write<uint32_t>(Sec->Size);
460  W.write<uint32_t>(Sec->FileOffsetToData);
461 
462  // Relocation pointer and Lineno pointer. Not supported yet.
463  W.write<uint32_t>(0);
464  W.write<uint32_t>(0);
465 
466  // Relocation and line-number counts. Not supported yet.
467  W.write<uint16_t>(0);
468  W.write<uint16_t>(0);
469 
470  W.write<int32_t>(Sec->Flags);
471  }
472 }
473 
475  // Print out symbol table for the program code.
476  for (const auto &Csect : ProgramCodeCsects) {
477  // Write out the control section first and then each symbol in it.
478  writeSymbolTableEntryForControlSection(Csect, Text.Index,
479  Csect.MCCsect->getStorageClass());
480  for (const auto &Sym : Csect.Syms)
481  writeSymbolTableEntryForCsectMemberLabel(
482  Sym, Csect, Text.Index, Layout.getSymbolOffset(*Sym.MCSym));
483  }
484 
485  // The BSS Section is special in that the csects must contain a single symbol,
486  // and the contained symbol cannot be represented in the symbol table as a
487  // label definition.
488  for (auto &Csect : BSSCsects) {
489  assert(Csect.Syms.size() == 1 &&
490  "Uninitialized csect cannot contain more then 1 symbol.");
491  Symbol &Sym = Csect.Syms.back();
492  writeSymbolTableEntryForControlSection(Csect, BSS.Index,
493  Sym.getStorageClass());
494  }
495 }
496 
497 void XCOFFObjectWriter::assignAddressesAndIndices(const MCAsmLayout &Layout) {
498  // The address corrresponds to the address of sections and symbols in the
499  // object file. We place the shared address 0 immediately after the
500  // section header table.
501  uint32_t Address = 0;
502  // Section indices are 1-based in XCOFF.
503  int16_t SectionIndex = 1;
504  // The first symbol table entry is for the file name. We are not emitting it
505  // yet, so start at index 0.
506  uint32_t SymbolTableIndex = 0;
507 
508  // Text section comes first.
509  if (!ProgramCodeCsects.empty()) {
510  Sections.push_back(&Text);
511  Text.Index = SectionIndex++;
512  for (auto &Csect : ProgramCodeCsects) {
513  const MCSectionXCOFF *MCSec = Csect.MCCsect;
514  Csect.Address = alignTo(Address, MCSec->getAlignment());
515  Csect.Size = Layout.getSectionAddressSize(MCSec);
516  Address = Csect.Address + Csect.Size;
517  Csect.SymbolTableIndex = SymbolTableIndex;
518  // 1 main and 1 auxiliary symbol table entry for the csect.
519  SymbolTableIndex += 2;
520  for (auto &Sym : Csect.Syms) {
521  Sym.SymbolTableIndex = SymbolTableIndex;
522  // 1 main and 1 auxiliary symbol table entry for each contained symbol
523  SymbolTableIndex += 2;
524  }
525  }
526  Address = alignTo(Address, DefaultSectionAlign);
527 
528  // The first csect of a section can be aligned by adjusting the virtual
529  // address of its containing section instead of writing zeroes into the
530  // object file.
531  Text.Address = ProgramCodeCsects.front().Address;
532 
533  Text.Size = Address - Text.Address;
534  }
535 
536  // Data section Second. TODO
537 
538  // BSS Section third.
539  if (!BSSCsects.empty()) {
540  Sections.push_back(&BSS);
541  BSS.Index = SectionIndex++;
542  for (auto &Csect : BSSCsects) {
543  const MCSectionXCOFF *MCSec = Csect.MCCsect;
544  Csect.Address = alignTo(Address, MCSec->getAlignment());
545  Csect.Size = Layout.getSectionAddressSize(MCSec);
546  Address = Csect.Address + Csect.Size;
547  Csect.SymbolTableIndex = SymbolTableIndex;
548  // 1 main and 1 auxiliary symbol table entry for the csect.
549  SymbolTableIndex += 2;
550 
551  assert(Csect.Syms.size() == 1 &&
552  "csect in the BSS can only contain a single symbol.");
553  Csect.Syms[0].SymbolTableIndex = Csect.SymbolTableIndex;
554  }
555  // Pad out Address to the default alignment. This is to match how the system
556  // assembler handles the .bss section. Its size is always a multiple of 4.
557  Address = alignTo(Address, DefaultSectionAlign);
558 
559  BSS.Address = BSSCsects.front().Address;
560  BSS.Size = Address - BSS.Address;
561  }
562 
563  SymbolTableEntryCount = SymbolTableIndex;
564 
565  // Calculate the RawPointer value for each section.
566  uint64_t RawPointer = sizeof(XCOFF::FileHeader32) + auxiliaryHeaderSize() +
567  Sections.size() * sizeof(XCOFF::SectionHeader32);
568  for (auto *Sec : Sections) {
569  if (!Sec->IsVirtual) {
570  Sec->FileOffsetToData = RawPointer;
571  RawPointer += Sec->Size;
572  }
573  }
574 
575  // TODO Add in Relocation storage to the RawPointer Calculation.
576  // TODO What to align the SymbolTable to?
577  // TODO Error check that the number of symbol table entries fits in 32-bits
578  // signed ...
579  if (SymbolTableEntryCount)
580  SymbolTableOffset = RawPointer;
581 }
582 
583 // Takes the log base 2 of the alignment and shifts the result into the 5 most
584 // significant bits of a byte, then or's in the csect type into the least
585 // significant 3 bits.
586 uint8_t getEncodedType(const MCSectionXCOFF *Sec) {
587  unsigned Align = Sec->getAlignment();
588  assert(isPowerOf2_32(Align) && "Alignment must be a power of 2.");
589  unsigned Log2Align = Log2_32(Align);
590  // Result is a number in the range [0, 31] which fits in the 5 least
591  // significant bits. Shift this value into the 5 most significant bits, and
592  // bitwise-or in the csect type.
593  uint8_t EncodedAlign = Log2Align << 3;
594  return EncodedAlign | Sec->getCSectType();
595 }
596 
597 } // end anonymous namespace
598 
599 std::unique_ptr<MCObjectWriter>
600 llvm::createXCOFFObjectWriter(std::unique_ptr<MCXCOFFObjectTargetWriter> MOTW,
601  raw_pwrite_stream &OS) {
602  return std::make_unique<XCOFFObjectWriter>(std::move(MOTW), OS);
603 }
LLVM_ATTRIBUTE_NORETURN void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:139
This class represents lattice values for constants.
Definition: AllocatorList.h:23
This represents an "assembler immediate".
Definition: MCValue.h:39
uint64_t getSectionAddressSize(const MCSection *Sec) const
Get the address space size of the given section, as it effects layout.
Definition: MCFragment.cpp:175
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:41
amdgpu Simplify well known AMD library false FunctionCallee Value const Twine & Name
TOC Anchor for TOC Addressability.
Definition: XCOFF.h:43
raw_ostream & write_zeros(unsigned NumZeros)
write_zeros - Insert &#39;NumZeros&#39; nulls.
block Block Frequency true
Read Write Data.
Definition: XCOFF.h:42
COFF::SymbolStorageClass StorageClass
Definition: COFFYAML.cpp:356
Defines the object file and target independent interfaces used by the assembler backend to write nati...
Encode information on a single operation to perform on a byte sequence (e.g., an encoded instruction)...
Definition: MCFixup.h:77
unsigned getAlignment() const
Definition: MCSection.h:121
Definition: BitVector.h:937
constexpr char SymbolName[]
Key for Kernel::Metadata::mSymbolName.
Encapsulates the layout of an assembly file at a particular point in time.
Definition: MCAsmLayout.h:28
static StringRef getName(Value *V)
SectionTypeFlags
Definition: XCOFF.h:58
void write(raw_ostream &OS) const
StorageClass
Definition: XCOFF.h:76
Utility for building string tables with deduplicated suffixes.
size_t add(CachedHashStringRef S)
Add a string to the builder.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:32
LLVM_NODISCARD size_t size() const
size - Get the string size.
Definition: StringRef.h:144
Common csect definition. For uninitialized storage.
Definition: XCOFF.h:148
Program Code.
Definition: XCOFF.h:30
constexpr bool isPowerOf2_32(uint32_t Value)
Return true if the argument is a power of two > 0.
Definition: MathExtras.h:465
virtual void reset()
lifetime management
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:129
Label definition.
Definition: XCOFF.h:146
MCSectionXCOFF * getContainingCsect() const
Definition: MCSymbolXCOFF.h:45
void writeSectionData(raw_ostream &OS, const MCSection *Section, const MCAsmLayout &Layout) const
Emit the section contents to OS.
void finalize()
Analyze the strings and build the final table.
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:40
std::unique_ptr< MCObjectWriter > createXCOFFObjectWriter(std::unique_ptr< MCXCOFFObjectTargetWriter > MOTW, raw_pwrite_stream &OS)
XCOFF::SymbolType getCSectType() const
BSS class (uninitialized static internal)
Definition: XCOFF.h:48
size_t getOffset(CachedHashStringRef S) const
Get the offest of a string in the string table.
void write(ArrayRef< value_type > Val)
Definition: EndianStream.h:55
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:837
unsigned Log2_32(uint32_t Value)
Return the floor log base 2 of the specified value, -1 if the value is zero.
Definition: MathExtras.h:585
Csect definition for initialized storage.
Definition: XCOFF.h:145
Adapter to write values to a stream in a particular byte order.
Definition: EndianStream.h:51
uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
Definition: Alignment.h:163
static void writeSymbolTable(raw_ostream &Out, object::Archive::Kind Kind, bool Deterministic, ArrayRef< MemberData > Members, StringRef StringTable)
#define N
StringRef getSectionName() const
uint32_t Size
Definition: Profile.cpp:46
StringRef getName() const
getName - Get the symbol name.
Definition: MCSymbol.h:204
An abstract base class for streams implementations that also support a pwrite operation.
Definition: raw_ostream.h:359
LLVM_NODISCARD const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:136
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
bool isIncrementalLinkerCompatible() const
Definition: MCAssembler.h:313
XCOFF::StorageClass getStorageClass() const
Definition: MCSymbolXCOFF.h:32
uint64_t tell() const
tell - Return the current offset with the file.
Definition: raw_ostream.h:111
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48