LLVM 20.0.0git
XCOFFObjectFile.cpp
Go to the documentation of this file.
1//===--- XCOFFObjectFile.cpp - XCOFF object file implementation -----------===//
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 defines the XCOFFObjectFile class.
10//
11//===----------------------------------------------------------------------===//
12
17#include <cstddef>
18#include <cstring>
19
20namespace llvm {
21
22using namespace XCOFF;
23
24namespace object {
25
26static const uint8_t FunctionSym = 0x20;
27static const uint16_t NoRelMask = 0x0001;
28static const size_t SymbolAuxTypeOffset = 17;
29
30// Checks that [Ptr, Ptr + Size) bytes fall inside the memory buffer
31// 'M'. Returns a pointer to the underlying object on success.
32template <typename T>
34 const uint64_t Size = sizeof(T)) {
35 uintptr_t Addr = reinterpret_cast<uintptr_t>(Ptr);
37 return std::move(E);
38 return reinterpret_cast<const T *>(Addr);
39}
40
41static uintptr_t getWithOffset(uintptr_t Base, ptrdiff_t Offset) {
42 return reinterpret_cast<uintptr_t>(reinterpret_cast<const char *>(Base) +
43 Offset);
44}
45
46template <typename T> static const T *viewAs(uintptr_t in) {
47 return reinterpret_cast<const T *>(in);
48}
49
51 auto NulCharPtr =
52 static_cast<const char *>(memchr(Name, '\0', XCOFF::NameSize));
53 return NulCharPtr ? StringRef(Name, NulCharPtr - Name)
55}
56
57template <typename T> StringRef XCOFFSectionHeader<T>::getName() const {
58 const T &DerivedXCOFFSectionHeader = static_cast<const T &>(*this);
59 return generateXCOFFFixedNameStringRef(DerivedXCOFFSectionHeader.Name);
60}
61
62template <typename T> uint16_t XCOFFSectionHeader<T>::getSectionType() const {
63 const T &DerivedXCOFFSectionHeader = static_cast<const T &>(*this);
64 return DerivedXCOFFSectionHeader.Flags & SectionFlagsTypeMask;
65}
66
67template <typename T>
69 const T &DerivedXCOFFSectionHeader = static_cast<const T &>(*this);
70 return DerivedXCOFFSectionHeader.Flags & ~SectionFlagsTypeMask;
71}
72
73template <typename T>
75 return getSectionType() & SectionFlagsReservedMask;
76}
77
78template <typename AddressType>
81}
82
83template <typename AddressType>
86}
87
88template <typename AddressType>
90 // The relocation encodes the bit length being relocated minus 1. Add back
91 // the 1 to get the actual length being relocated.
92 return (Info & XR_BIASED_LENGTH_MASK) + 1;
93}
94
97
98template <typename T>
101 if (LoaderSecHeader->LengthOfStrTbl > Offset)
102 return (reinterpret_cast<const char *>(LoaderSecHeader) +
103 LoaderSecHeader->OffsetToStrTbl + Offset);
104
105 return createError("entry with offset 0x" + Twine::utohexstr(Offset) +
106 " in the loader section's string table with size 0x" +
107 Twine::utohexstr(LoaderSecHeader->LengthOfStrTbl) +
108 " is invalid");
109}
110
112 const LoaderSectionHeader32 *LoaderSecHeader32) const {
113 const NameOffsetInStrTbl *NameInStrTbl =
114 reinterpret_cast<const NameOffsetInStrTbl *>(SymbolName);
117
118 return getLoaderSecSymNameInStrTbl(LoaderSecHeader32, NameInStrTbl->Offset);
119}
120
122 const LoaderSectionHeader64 *LoaderSecHeader64) const {
123 return getLoaderSecSymNameInStrTbl(LoaderSecHeader64, Offset);
124}
125
126uintptr_t
128 uint32_t Distance) {
129 return getWithOffset(CurrentAddress, Distance * XCOFF::SymbolTableEntrySize);
130}
131
133XCOFFObjectFile::getSymbolAuxType(uintptr_t AuxEntryAddress) const {
134 assert(is64Bit() && "64-bit interface called on a 32-bit object file.");
135 return viewAs<XCOFF::SymbolAuxType>(
136 getWithOffset(AuxEntryAddress, SymbolAuxTypeOffset));
137}
138
139void XCOFFObjectFile::checkSectionAddress(uintptr_t Addr,
140 uintptr_t TableAddress) const {
141 if (Addr < TableAddress)
142 report_fatal_error("Section header outside of section header table.");
143
144 uintptr_t Offset = Addr - TableAddress;
145 if (Offset >= getSectionHeaderSize() * getNumberOfSections())
146 report_fatal_error("Section header outside of section header table.");
147
148 if (Offset % getSectionHeaderSize() != 0)
150 "Section header pointer does not point to a valid section header.");
151}
152
153const XCOFFSectionHeader32 *
154XCOFFObjectFile::toSection32(DataRefImpl Ref) const {
155 assert(!is64Bit() && "32-bit interface called on 64-bit object file.");
156#ifndef NDEBUG
157 checkSectionAddress(Ref.p, getSectionHeaderTableAddress());
158#endif
159 return viewAs<XCOFFSectionHeader32>(Ref.p);
160}
161
162const XCOFFSectionHeader64 *
163XCOFFObjectFile::toSection64(DataRefImpl Ref) const {
164 assert(is64Bit() && "64-bit interface called on a 32-bit object file.");
165#ifndef NDEBUG
166 checkSectionAddress(Ref.p, getSectionHeaderTableAddress());
167#endif
168 return viewAs<XCOFFSectionHeader64>(Ref.p);
172 assert(Ref.p != 0 && "Symbol table pointer can not be nullptr!");
173#ifndef NDEBUG
175#endif
176 return XCOFFSymbolRef(Ref, this);
177}
178
180 assert(!is64Bit() && "32-bit interface called on 64-bit object file.");
181 return static_cast<const XCOFFFileHeader32 *>(FileHeader);
182}
183
185 assert(is64Bit() && "64-bit interface called on a 32-bit object file.");
186 return static_cast<const XCOFFFileHeader64 *>(FileHeader);
187}
188
190 assert(!is64Bit() && "32-bit interface called on 64-bit object file.");
191 return static_cast<const XCOFFAuxiliaryHeader32 *>(AuxiliaryHeader);
192}
193
195 assert(is64Bit() && "64-bit interface called on a 32-bit object file.");
196 return static_cast<const XCOFFAuxiliaryHeader64 *>(AuxiliaryHeader);
197}
198
199template <typename T> const T *XCOFFObjectFile::sectionHeaderTable() const {
200 return static_cast<const T *>(SectionHeaderTable);
201}
202
203const XCOFFSectionHeader32 *
204XCOFFObjectFile::sectionHeaderTable32() const {
205 assert(!is64Bit() && "32-bit interface called on 64-bit object file.");
206 return static_cast<const XCOFFSectionHeader32 *>(SectionHeaderTable);
207}
208
209const XCOFFSectionHeader64 *
210XCOFFObjectFile::sectionHeaderTable64() const {
211 assert(is64Bit() && "64-bit interface called on a 32-bit object file.");
212 return static_cast<const XCOFFSectionHeader64 *>(SectionHeaderTable);
213}
214
216 uintptr_t NextSymbolAddr = getAdvancedSymbolEntryAddress(
217 Symb.p, toSymbolRef(Symb).getNumberOfAuxEntries() + 1);
218#ifndef NDEBUG
219 // This function is used by basic_symbol_iterator, which allows to
220 // point to the end-of-symbol-table address.
221 if (NextSymbolAddr != getEndOfSymbolTableAddress())
222 checkSymbolEntryPointer(NextSymbolAddr);
223#endif
224 Symb.p = NextSymbolAddr;
225}
226
229 // The byte offset is relative to the start of the string table.
230 // A byte offset value of 0 is a null or zero-length symbol
231 // name. A byte offset in the range 1 to 3 (inclusive) points into the length
232 // field; as a soft-error recovery mechanism, we treat such cases as having an
233 // offset of 0.
234 if (Offset < 4)
235 return StringRef(nullptr, 0);
236
237 if (StringTable.Data != nullptr && StringTable.Size > Offset)
238 return (StringTable.Data + Offset);
239
240 return createError("entry with offset 0x" + Twine::utohexstr(Offset) +
241 " in a string table with size 0x" +
242 Twine::utohexstr(StringTable.Size) + " is invalid");
243}
244
246 // If the size is less than or equal to 4, then the string table contains no
247 // string data.
248 return StringRef(StringTable.Data,
249 StringTable.Size <= 4 ? 0 : StringTable.Size);
250}
251
255 return generateXCOFFFixedNameStringRef(CFileEntPtr->Name);
256 return getStringTableEntry(CFileEntPtr->NameInStrTbl.Offset);
257}
258
260 return toSymbolRef(Symb).getName();
261}
262
264 return toSymbolRef(Symb).getValue();
265}
266
268 return toSymbolRef(Symb).getValue();
269}
270
272 uint64_t Result = 0;
273 XCOFFSymbolRef XCOFFSym = toSymbolRef(Symb);
274 if (XCOFFSym.isCsectSymbol()) {
275 Expected<XCOFFCsectAuxRef> CsectAuxRefOrError =
276 XCOFFSym.getXCOFFCsectAuxRef();
277 if (!CsectAuxRefOrError)
278 // TODO: report the error up the stack.
279 consumeError(CsectAuxRefOrError.takeError());
280 else
281 Result = 1ULL << CsectAuxRefOrError.get().getAlignmentLog2();
282 }
283 return Result;
284}
285
287 uint64_t Result = 0;
288 XCOFFSymbolRef XCOFFSym = toSymbolRef(Symb);
289 if (XCOFFSym.isCsectSymbol()) {
290 Expected<XCOFFCsectAuxRef> CsectAuxRefOrError =
291 XCOFFSym.getXCOFFCsectAuxRef();
292 if (!CsectAuxRefOrError)
293 // TODO: report the error up the stack.
294 consumeError(CsectAuxRefOrError.takeError());
295 else {
296 XCOFFCsectAuxRef CsectAuxRef = CsectAuxRefOrError.get();
297 assert(CsectAuxRef.getSymbolType() == XCOFF::XTY_CM);
298 Result = CsectAuxRef.getSectionOrLength();
299 }
300 }
301 return Result;
302}
303
306 XCOFFSymbolRef XCOFFSym = toSymbolRef(Symb);
307
308 Expected<bool> IsFunction = XCOFFSym.isFunction();
309 if (!IsFunction)
310 return IsFunction.takeError();
311
312 if (*IsFunction)
314
315 if (XCOFF::C_FILE == XCOFFSym.getStorageClass())
316 return SymbolRef::ST_File;
317
318 int16_t SecNum = XCOFFSym.getSectionNumber();
319 if (SecNum <= 0)
320 return SymbolRef::ST_Other;
321
322 Expected<DataRefImpl> SecDRIOrErr =
324
325 if (!SecDRIOrErr)
326 return SecDRIOrErr.takeError();
327
328 DataRefImpl SecDRI = SecDRIOrErr.get();
329
330 Expected<StringRef> SymNameOrError = XCOFFSym.getName();
331 if (SymNameOrError) {
332 // The "TOC" symbol is treated as SymbolRef::ST_Other.
333 if (SymNameOrError.get() == "TOC")
334 return SymbolRef::ST_Other;
335
336 // The symbol for a section name is treated as SymbolRef::ST_Other.
337 StringRef SecName;
338 if (is64Bit())
339 SecName = XCOFFObjectFile::toSection64(SecDRIOrErr.get())->getName();
340 else
341 SecName = XCOFFObjectFile::toSection32(SecDRIOrErr.get())->getName();
342
343 if (SecName == SymNameOrError.get())
344 return SymbolRef::ST_Other;
345 } else
346 return SymNameOrError.takeError();
347
348 if (isSectionData(SecDRI) || isSectionBSS(SecDRI))
349 return SymbolRef::ST_Data;
350
351 if (isDebugSection(SecDRI))
352 return SymbolRef::ST_Debug;
353
354 return SymbolRef::ST_Other;
355}
356
359 const int16_t SectNum = toSymbolRef(Symb).getSectionNumber();
360
361 if (isReservedSectionNumber(SectNum))
362 return section_end();
363
364 Expected<DataRefImpl> ExpSec = getSectionByNum(SectNum);
365 if (!ExpSec)
366 return ExpSec.takeError();
367
368 return section_iterator(SectionRef(ExpSec.get(), this));
369}
370
372 const char *Ptr = reinterpret_cast<const char *>(Sec.p);
373 Sec.p = reinterpret_cast<uintptr_t>(Ptr + getSectionHeaderSize());
374}
375
377 return generateXCOFFFixedNameStringRef(getSectionNameInternal(Sec));
378}
379
381 // Avoid ternary due to failure to convert the ubig32_t value to a unit64_t
382 // with MSVC.
383 if (is64Bit())
384 return toSection64(Sec)->VirtualAddress;
385
386 return toSection32(Sec)->VirtualAddress;
387}
388
390 // Section numbers in XCOFF are numbered beginning at 1. A section number of
391 // zero is used to indicate that a symbol is being imported or is undefined.
392 if (is64Bit())
393 return toSection64(Sec) - sectionHeaderTable64() + 1;
394 else
395 return toSection32(Sec) - sectionHeaderTable32() + 1;
396}
397
399 // Avoid ternary due to failure to convert the ubig32_t value to a unit64_t
400 // with MSVC.
401 if (is64Bit())
402 return toSection64(Sec)->SectionSize;
403
404 return toSection32(Sec)->SectionSize;
405}
406
409 if (isSectionVirtual(Sec))
410 return ArrayRef<uint8_t>();
411
412 uint64_t OffsetToRaw;
413 if (is64Bit())
414 OffsetToRaw = toSection64(Sec)->FileOffsetToRawData;
415 else
416 OffsetToRaw = toSection32(Sec)->FileOffsetToRawData;
417
418 const uint8_t * ContentStart = base() + OffsetToRaw;
419 uint64_t SectionSize = getSectionSize(Sec);
421 Data, reinterpret_cast<uintptr_t>(ContentStart), SectionSize))
422 return createError(
423 toString(std::move(E)) + ": section data with offset 0x" +
424 Twine::utohexstr(OffsetToRaw) + " and size 0x" +
425 Twine::utohexstr(SectionSize) + " goes past the end of the file");
426
427 return ArrayRef(ContentStart, SectionSize);
428}
429
431 uint64_t Result = 0;
432 llvm_unreachable("Not yet implemented!");
433 return Result;
434}
435
436uint64_t XCOFFObjectFile::getSectionFileOffsetToRawData(DataRefImpl Sec) const {
437 if (is64Bit())
438 return toSection64(Sec)->FileOffsetToRawData;
439
440 return toSection32(Sec)->FileOffsetToRawData;
441}
442
443Expected<uintptr_t> XCOFFObjectFile::getSectionFileOffsetToRawData(
444 XCOFF::SectionTypeFlags SectType) const {
445 DataRefImpl DRI = getSectionByType(SectType);
446
447 if (DRI.p == 0) // No section is not an error.
448 return 0;
449
450 uint64_t SectionOffset = getSectionFileOffsetToRawData(DRI);
451 uint64_t SizeOfSection = getSectionSize(DRI);
452
453 uintptr_t SectionStart = reinterpret_cast<uintptr_t>(base() + SectionOffset);
454 if (Error E = Binary::checkOffset(Data, SectionStart, SizeOfSection)) {
455 SmallString<32> UnknownType;
456 Twine(("<Unknown:") + Twine::utohexstr(SectType) + ">")
457 .toVector(UnknownType);
458 const char *SectionName = UnknownType.c_str();
459
460 switch (SectType) {
461#define ECASE(Value, String) \
462 case XCOFF::Value: \
463 SectionName = String; \
464 break
465
466 ECASE(STYP_PAD, "pad");
467 ECASE(STYP_DWARF, "dwarf");
468 ECASE(STYP_TEXT, "text");
469 ECASE(STYP_DATA, "data");
470 ECASE(STYP_BSS, "bss");
471 ECASE(STYP_EXCEPT, "expect");
472 ECASE(STYP_INFO, "info");
473 ECASE(STYP_TDATA, "tdata");
474 ECASE(STYP_TBSS, "tbss");
475 ECASE(STYP_LOADER, "loader");
476 ECASE(STYP_DEBUG, "debug");
477 ECASE(STYP_TYPCHK, "typchk");
478 ECASE(STYP_OVRFLO, "ovrflo");
479#undef ECASE
480 }
481 return createError(toString(std::move(E)) + ": " + SectionName +
482 " section with offset 0x" +
483 Twine::utohexstr(SectionOffset) + " and size 0x" +
484 Twine::utohexstr(SizeOfSection) +
485 " goes past the end of the file");
486 }
487 return SectionStart;
488}
489
491 return false;
492}
493
495 return getSectionFlags(Sec) & XCOFF::STYP_TEXT;
496}
497
499 uint32_t Flags = getSectionFlags(Sec);
500 return Flags & (XCOFF::STYP_DATA | XCOFF::STYP_TDATA);
501}
502
504 uint32_t Flags = getSectionFlags(Sec);
505 return Flags & (XCOFF::STYP_BSS | XCOFF::STYP_TBSS);
506}
507
509 uint32_t Flags = getSectionFlags(Sec);
510 return Flags & (XCOFF::STYP_DEBUG | XCOFF::STYP_DWARF);
511}
512
514 return is64Bit() ? toSection64(Sec)->FileOffsetToRawData == 0
515 : toSection32(Sec)->FileOffsetToRawData == 0;
519 DataRefImpl Ret;
520 if (is64Bit()) {
521 const XCOFFSectionHeader64 *SectionEntPtr = toSection64(Sec);
522 auto RelocationsOrErr =
523 relocations<XCOFFSectionHeader64, XCOFFRelocation64>(*SectionEntPtr);
524 if (Error E = RelocationsOrErr.takeError()) {
525 // TODO: report the error up the stack.
526 consumeError(std::move(E));
528 }
529 Ret.p = reinterpret_cast<uintptr_t>(&*RelocationsOrErr.get().begin());
530 } else {
531 const XCOFFSectionHeader32 *SectionEntPtr = toSection32(Sec);
532 auto RelocationsOrErr =
533 relocations<XCOFFSectionHeader32, XCOFFRelocation32>(*SectionEntPtr);
534 if (Error E = RelocationsOrErr.takeError()) {
535 // TODO: report the error up the stack.
536 consumeError(std::move(E));
538 }
539 Ret.p = reinterpret_cast<uintptr_t>(&*RelocationsOrErr.get().begin());
540 }
541 return relocation_iterator(RelocationRef(Ret, this));
542}
543
545 DataRefImpl Ret;
546 if (is64Bit()) {
547 const XCOFFSectionHeader64 *SectionEntPtr = toSection64(Sec);
548 auto RelocationsOrErr =
549 relocations<XCOFFSectionHeader64, XCOFFRelocation64>(*SectionEntPtr);
550 if (Error E = RelocationsOrErr.takeError()) {
551 // TODO: report the error up the stack.
552 consumeError(std::move(E));
554 }
555 Ret.p = reinterpret_cast<uintptr_t>(&*RelocationsOrErr.get().end());
556 } else {
557 const XCOFFSectionHeader32 *SectionEntPtr = toSection32(Sec);
558 auto RelocationsOrErr =
559 relocations<XCOFFSectionHeader32, XCOFFRelocation32>(*SectionEntPtr);
560 if (Error E = RelocationsOrErr.takeError()) {
561 // TODO: report the error up the stack.
562 consumeError(std::move(E));
564 }
565 Ret.p = reinterpret_cast<uintptr_t>(&*RelocationsOrErr.get().end());
566 }
567 return relocation_iterator(RelocationRef(Ret, this));
568}
569
571 if (is64Bit())
572 Rel.p = reinterpret_cast<uintptr_t>(viewAs<XCOFFRelocation64>(Rel.p) + 1);
573 else
574 Rel.p = reinterpret_cast<uintptr_t>(viewAs<XCOFFRelocation32>(Rel.p) + 1);
575}
576
578 if (is64Bit()) {
579 const XCOFFRelocation64 *Reloc = viewAs<XCOFFRelocation64>(Rel.p);
580 const XCOFFSectionHeader64 *Sec64 = sectionHeaderTable64();
581 const uint64_t RelocAddress = Reloc->VirtualAddress;
582 const uint16_t NumberOfSections = getNumberOfSections();
583 for (uint16_t I = 0; I < NumberOfSections; ++I) {
584 // Find which section this relocation belongs to, and get the
585 // relocation offset relative to the start of the section.
586 if (Sec64->VirtualAddress <= RelocAddress &&
587 RelocAddress < Sec64->VirtualAddress + Sec64->SectionSize) {
588 return RelocAddress - Sec64->VirtualAddress;
589 }
590 ++Sec64;
591 }
592 } else {
593 const XCOFFRelocation32 *Reloc = viewAs<XCOFFRelocation32>(Rel.p);
594 const XCOFFSectionHeader32 *Sec32 = sectionHeaderTable32();
595 const uint32_t RelocAddress = Reloc->VirtualAddress;
596 const uint16_t NumberOfSections = getNumberOfSections();
597 for (uint16_t I = 0; I < NumberOfSections; ++I) {
598 // Find which section this relocation belongs to, and get the
599 // relocation offset relative to the start of the section.
600 if (Sec32->VirtualAddress <= RelocAddress &&
601 RelocAddress < Sec32->VirtualAddress + Sec32->SectionSize) {
602 return RelocAddress - Sec32->VirtualAddress;
603 }
604 ++Sec32;
605 }
606 }
607 return InvalidRelocOffset;
608}
609
612 if (is64Bit()) {
613 const XCOFFRelocation64 *Reloc = viewAs<XCOFFRelocation64>(Rel.p);
614 Index = Reloc->SymbolIndex;
615
617 return symbol_end();
618 } else {
619 const XCOFFRelocation32 *Reloc = viewAs<XCOFFRelocation32>(Rel.p);
620 Index = Reloc->SymbolIndex;
621
623 return symbol_end();
624 }
625 DataRefImpl SymDRI;
627 return symbol_iterator(SymbolRef(SymDRI, this));
628}
629
631 if (is64Bit())
632 return viewAs<XCOFFRelocation64>(Rel.p)->Type;
633 return viewAs<XCOFFRelocation32>(Rel.p)->Type;
634}
635
637 DataRefImpl Rel, SmallVectorImpl<char> &Result) const {
638 StringRef Res;
639 if (is64Bit()) {
640 const XCOFFRelocation64 *Reloc = viewAs<XCOFFRelocation64>(Rel.p);
642 } else {
643 const XCOFFRelocation32 *Reloc = viewAs<XCOFFRelocation32>(Rel.p);
645 }
646 Result.append(Res.begin(), Res.end());
647}
648
650 XCOFFSymbolRef XCOFFSym = toSymbolRef(Symb);
652
653 if (XCOFFSym.getSectionNumber() == XCOFF::N_ABS)
654 Result |= SymbolRef::SF_Absolute;
655
656 XCOFF::StorageClass SC = XCOFFSym.getStorageClass();
657 if (XCOFF::C_EXT == SC || XCOFF::C_WEAKEXT == SC)
658 Result |= SymbolRef::SF_Global;
659
660 if (XCOFF::C_WEAKEXT == SC)
661 Result |= SymbolRef::SF_Weak;
662
663 if (XCOFFSym.isCsectSymbol()) {
664 Expected<XCOFFCsectAuxRef> CsectAuxEntOrErr =
665 XCOFFSym.getXCOFFCsectAuxRef();
666 if (CsectAuxEntOrErr) {
667 if (CsectAuxEntOrErr.get().getSymbolType() == XCOFF::XTY_CM)
668 Result |= SymbolRef::SF_Common;
669 } else
670 return CsectAuxEntOrErr.takeError();
671 }
672
673 if (XCOFFSym.getSectionNumber() == XCOFF::N_UNDEF)
674 Result |= SymbolRef::SF_Undefined;
675
676 // There is no visibility in old 32 bit XCOFF object file interpret.
677 if (is64Bit() || (auxiliaryHeader32() && (auxiliaryHeader32()->getVersion() ==
679 uint16_t SymType = XCOFFSym.getSymbolType();
680 if ((SymType & VISIBILITY_MASK) == SYM_V_HIDDEN)
681 Result |= SymbolRef::SF_Hidden;
682
683 if ((SymType & VISIBILITY_MASK) == SYM_V_EXPORTED)
684 Result |= SymbolRef::SF_Exported;
685 }
686 return Result;
687}
688
690 DataRefImpl SymDRI;
691 SymDRI.p = reinterpret_cast<uintptr_t>(SymbolTblPtr);
692 return basic_symbol_iterator(SymbolRef(SymDRI, this));
693}
694
696 DataRefImpl SymDRI;
697 const uint32_t NumberOfSymbolTableEntries = getNumberOfSymbolTableEntries();
698 SymDRI.p = getSymbolEntryAddressByIndex(NumberOfSymbolTableEntries);
699 return basic_symbol_iterator(SymbolRef(SymDRI, this));
700}
701
704}
705
707 DataRefImpl DRI;
708 DRI.p = getSectionHeaderTableAddress();
709 return section_iterator(SectionRef(DRI, this));
710}
711
713 DataRefImpl DRI;
714 DRI.p = getWithOffset(getSectionHeaderTableAddress(),
715 getNumberOfSections() * getSectionHeaderSize());
716 return section_iterator(SectionRef(DRI, this));
717}
718
719uint8_t XCOFFObjectFile::getBytesInAddress() const { return is64Bit() ? 8 : 4; }
720
722 return is64Bit() ? "aix5coff64-rs6000" : "aixcoff-rs6000";
723}
724
726 return is64Bit() ? Triple::ppc64 : Triple::ppc;
727}
728
730 return SubtargetFeatures();
731}
732
734 if (is64Bit())
735 return !(fileHeader64()->Flags & NoRelMask);
736 return !(fileHeader32()->Flags & NoRelMask);
737}
738
740 if (AuxiliaryHeader == nullptr)
741 return 0;
742
745}
746
749 .Case("dwinfo", "debug_info")
750 .Case("dwline", "debug_line")
751 .Case("dwpbnms", "debug_pubnames")
752 .Case("dwpbtyp", "debug_pubtypes")
753 .Case("dwarnge", "debug_aranges")
754 .Case("dwabrev", "debug_abbrev")
755 .Case("dwstr", "debug_str")
756 .Case("dwrnges", "debug_ranges")
757 .Case("dwloc", "debug_loc")
758 .Case("dwframe", "debug_frame")
759 .Case("dwmac", "debug_macinfo")
760 .Default(Name);
761}
762
763size_t XCOFFObjectFile::getFileHeaderSize() const {
764 return is64Bit() ? sizeof(XCOFFFileHeader64) : sizeof(XCOFFFileHeader32);
765}
766
767size_t XCOFFObjectFile::getSectionHeaderSize() const {
768 return is64Bit() ? sizeof(XCOFFSectionHeader64) :
769 sizeof(XCOFFSectionHeader32);
770}
771
773 return Binary::ID_XCOFF64 == getType();
774}
775
778 StringRef Name) const {
779 uintptr_t StartPtr = reinterpret_cast<uintptr_t>(Start);
780 // TODO: this path is untested.
781 if (Error E = Binary::checkOffset(Data, StartPtr, Size))
782 return createError(toString(std::move(E)) + ": " + Name.data() +
783 " data with offset 0x" + Twine::utohexstr(StartPtr) +
784 " and size 0x" + Twine::utohexstr(Size) +
785 " goes past the end of the file");
786 return StringRef(Start, Size);
787}
788
790 return is64Bit() ? fileHeader64()->Magic : fileHeader32()->Magic;
791}
792
794 if (Num <= 0 || Num > getNumberOfSections())
796 "the section index (" + Twine(Num) +
797 ") is invalid");
798
799 DataRefImpl DRI;
800 DRI.p = getWithOffset(getSectionHeaderTableAddress(),
801 getSectionHeaderSize() * (Num - 1));
802 return DRI;
803}
804
806XCOFFObjectFile::getSectionByType(XCOFF::SectionTypeFlags SectType) const {
807 DataRefImpl DRI;
808 auto GetSectionAddr = [&](const auto &Sections) -> uintptr_t {
809 for (const auto &Sec : Sections)
810 if (Sec.getSectionType() == SectType)
811 return reinterpret_cast<uintptr_t>(&Sec);
812 return uintptr_t(0);
813 };
814 if (is64Bit())
815 DRI.p = GetSectionAddr(sections64());
816 else
817 DRI.p = GetSectionAddr(sections32());
818 return DRI;
819}
820
821Expected<StringRef>
823 const int16_t SectionNum = SymEntPtr.getSectionNumber();
824
825 switch (SectionNum) {
826 case XCOFF::N_DEBUG:
827 return "N_DEBUG";
828 case XCOFF::N_ABS:
829 return "N_ABS";
830 case XCOFF::N_UNDEF:
831 return "N_UNDEF";
832 default:
833 Expected<DataRefImpl> SecRef = getSectionByNum(SectionNum);
834 if (SecRef)
836 getSectionNameInternal(SecRef.get()));
837 return SecRef.takeError();
838 }
839}
840
842 XCOFFSymbolRef XCOFFSymRef(Sym.getRawDataRefImpl(), this);
843 return XCOFFSymRef.getSectionNumber();
844}
845
846bool XCOFFObjectFile::isReservedSectionNumber(int16_t SectionNumber) {
847 return (SectionNumber <= 0 && SectionNumber >= -2);
848}
849
853}
854
857}
858
862}
863
866}
867
869 // As far as symbol table size is concerned, if this field is negative it is
870 // to be treated as a 0. However since this field is also used for printing we
871 // don't want to truncate any negative values.
873}
874
876 return (fileHeader32()->NumberOfSymTableEntries >= 0
877 ? fileHeader32()->NumberOfSymTableEntries
878 : 0);
879}
880
883}
884
887}
888
892}
893
894uintptr_t XCOFFObjectFile::getEndOfSymbolTableAddress() const {
895 const uint32_t NumberOfSymTableEntries = getNumberOfSymbolTableEntries();
896 return getWithOffset(reinterpret_cast<uintptr_t>(SymbolTblPtr),
897 XCOFF::SymbolTableEntrySize * NumberOfSymTableEntries);
898}
899
900void XCOFFObjectFile::checkSymbolEntryPointer(uintptr_t SymbolEntPtr) const {
901 if (SymbolEntPtr < reinterpret_cast<uintptr_t>(SymbolTblPtr))
902 report_fatal_error("Symbol table entry is outside of symbol table.");
903
904 if (SymbolEntPtr >= getEndOfSymbolTableAddress())
905 report_fatal_error("Symbol table entry is outside of symbol table.");
906
907 ptrdiff_t Offset = reinterpret_cast<const char *>(SymbolEntPtr) -
908 reinterpret_cast<const char *>(SymbolTblPtr);
909
912 "Symbol table entry position is not valid inside of symbol table.");
913}
914
915uint32_t XCOFFObjectFile::getSymbolIndex(uintptr_t SymbolEntPtr) const {
916 return (reinterpret_cast<const char *>(SymbolEntPtr) -
917 reinterpret_cast<const char *>(SymbolTblPtr)) /
919}
920
922 uint64_t Result = 0;
923 XCOFFSymbolRef XCOFFSym = toSymbolRef(Symb);
924 if (XCOFFSym.isCsectSymbol()) {
925 Expected<XCOFFCsectAuxRef> CsectAuxRefOrError =
926 XCOFFSym.getXCOFFCsectAuxRef();
927 if (!CsectAuxRefOrError)
928 // TODO: report the error up the stack.
929 consumeError(CsectAuxRefOrError.takeError());
930 else {
931 XCOFFCsectAuxRef CsectAuxRef = CsectAuxRefOrError.get();
932 uint8_t SymType = CsectAuxRef.getSymbolType();
933 if (SymType == XCOFF::XTY_SD || SymType == XCOFF::XTY_CM)
934 Result = CsectAuxRef.getSectionOrLength();
935 }
936 }
937 return Result;
938}
939
942 reinterpret_cast<uintptr_t>(getPointerToSymbolTable()), Index);
943}
944
947 const uint32_t NumberOfSymTableEntries = getNumberOfSymbolTableEntries();
948
949 if (Index >= NumberOfSymTableEntries)
950 return createError("symbol index " + Twine(Index) +
951 " exceeds symbol count " +
952 Twine(NumberOfSymTableEntries));
953
954 DataRefImpl SymDRI;
956 return getSymbolName(SymDRI);
957}
958
960 return is64Bit() ? fileHeader64()->Flags : fileHeader32()->Flags;
961}
962
963const char *XCOFFObjectFile::getSectionNameInternal(DataRefImpl Sec) const {
964 return is64Bit() ? toSection64(Sec)->Name : toSection32(Sec)->Name;
965}
966
967uintptr_t XCOFFObjectFile::getSectionHeaderTableAddress() const {
968 return reinterpret_cast<uintptr_t>(SectionHeaderTable);
969}
970
972 return is64Bit() ? toSection64(Sec)->Flags : toSection32(Sec)->Flags;
973}
974
975XCOFFObjectFile::XCOFFObjectFile(unsigned int Type, MemoryBufferRef Object)
976 : ObjectFile(Type, Object) {
978}
979
981 assert(is64Bit() && "64-bit interface called for non 64-bit file.");
982 const XCOFFSectionHeader64 *TablePtr = sectionHeaderTable64();
983 return ArrayRef<XCOFFSectionHeader64>(TablePtr,
984 TablePtr + getNumberOfSections());
985}
986
988 assert(!is64Bit() && "32-bit interface called for non 32-bit file.");
989 const XCOFFSectionHeader32 *TablePtr = sectionHeaderTable32();
990 return ArrayRef<XCOFFSectionHeader32>(TablePtr,
991 TablePtr + getNumberOfSections());
992}
993
994// In an XCOFF32 file, when the field value is 65535, then an STYP_OVRFLO
995// section header contains the actual count of relocation entries in the s_paddr
996// field. STYP_OVRFLO headers contain the section index of their corresponding
997// sections as their raw "NumberOfRelocations" field value.
998template <typename T>
1000 const XCOFFSectionHeader<T> &Sec) const {
1001 const T &Section = static_cast<const T &>(Sec);
1002 if (is64Bit())
1003 return Section.NumberOfRelocations;
1004
1005 uint16_t SectionIndex = &Section - sectionHeaderTable<T>() + 1;
1006 if (Section.NumberOfRelocations < XCOFF::RelocOverflow)
1007 return Section.NumberOfRelocations;
1008 for (const auto &Sec : sections32()) {
1009 if (Sec.Flags == XCOFF::STYP_OVRFLO &&
1010 Sec.NumberOfRelocations == SectionIndex)
1011 return Sec.PhysicalAddress;
1012 }
1014}
1015
1016template <typename Shdr, typename Reloc>
1018 uintptr_t RelocAddr = getWithOffset(reinterpret_cast<uintptr_t>(FileHeader),
1019 Sec.FileOffsetToRelocationInfo);
1020 auto NumRelocEntriesOrErr = getNumberOfRelocationEntries(Sec);
1021 if (Error E = NumRelocEntriesOrErr.takeError())
1022 return std::move(E);
1023
1024 uint32_t NumRelocEntries = NumRelocEntriesOrErr.get();
1025 static_assert((sizeof(Reloc) == XCOFF::RelocationSerializationSize64 ||
1026 sizeof(Reloc) == XCOFF::RelocationSerializationSize32),
1027 "Relocation structure is incorrect");
1028 auto RelocationOrErr =
1029 getObject<Reloc>(Data, reinterpret_cast<void *>(RelocAddr),
1030 NumRelocEntries * sizeof(Reloc));
1031 if (!RelocationOrErr)
1032 return createError(
1033 toString(RelocationOrErr.takeError()) + ": relocations with offset 0x" +
1034 Twine::utohexstr(Sec.FileOffsetToRelocationInfo) + " and size 0x" +
1035 Twine::utohexstr(NumRelocEntries * sizeof(Reloc)) +
1036 " go past the end of the file");
1037
1038 const Reloc *StartReloc = RelocationOrErr.get();
1039
1040 return ArrayRef<Reloc>(StartReloc, StartReloc + NumRelocEntries);
1041}
1042
1043template <typename ExceptEnt>
1045 assert((is64Bit() && sizeof(ExceptEnt) == sizeof(ExceptionSectionEntry64)) ||
1046 (!is64Bit() && sizeof(ExceptEnt) == sizeof(ExceptionSectionEntry32)));
1047
1048 Expected<uintptr_t> ExceptionSectOrErr =
1049 getSectionFileOffsetToRawData(XCOFF::STYP_EXCEPT);
1050 if (!ExceptionSectOrErr)
1051 return ExceptionSectOrErr.takeError();
1052
1053 DataRefImpl DRI = getSectionByType(XCOFF::STYP_EXCEPT);
1054 if (DRI.p == 0)
1055 return ArrayRef<ExceptEnt>();
1056
1057 ExceptEnt *ExceptEntStart =
1058 reinterpret_cast<ExceptEnt *>(*ExceptionSectOrErr);
1059 return ArrayRef<ExceptEnt>(
1060 ExceptEntStart, ExceptEntStart + getSectionSize(DRI) / sizeof(ExceptEnt));
1061}
1062
1067
1069XCOFFObjectFile::parseStringTable(const XCOFFObjectFile *Obj, uint64_t Offset) {
1070 // If there is a string table, then the buffer must contain at least 4 bytes
1071 // for the string table's size. Not having a string table is not an error.
1073 Obj->Data, reinterpret_cast<uintptr_t>(Obj->base() + Offset), 4)) {
1074 consumeError(std::move(E));
1075 return XCOFFStringTable{0, nullptr};
1076 }
1077
1078 // Read the size out of the buffer.
1080
1081 // If the size is less then 4, then the string table is just a size and no
1082 // string data.
1083 if (Size <= 4)
1084 return XCOFFStringTable{4, nullptr};
1085
1086 auto StringTableOrErr =
1087 getObject<char>(Obj->Data, Obj->base() + Offset, Size);
1088 if (!StringTableOrErr)
1089 return createError(toString(StringTableOrErr.takeError()) +
1090 ": string table with offset 0x" +
1091 Twine::utohexstr(Offset) + " and size 0x" +
1093 " goes past the end of the file");
1094
1095 const char *StringTablePtr = StringTableOrErr.get();
1096 if (StringTablePtr[Size - 1] != '\0')
1098
1099 return XCOFFStringTable{Size, StringTablePtr};
1100}
1101
1102// This function returns the import file table. Each entry in the import file
1103// table consists of: "path_name\0base_name\0archive_member_name\0".
1105 Expected<uintptr_t> LoaderSectionAddrOrError =
1106 getSectionFileOffsetToRawData(XCOFF::STYP_LOADER);
1107 if (!LoaderSectionAddrOrError)
1108 return LoaderSectionAddrOrError.takeError();
1109
1110 uintptr_t LoaderSectionAddr = LoaderSectionAddrOrError.get();
1111 if (!LoaderSectionAddr)
1112 return StringRef();
1113
1114 uint64_t OffsetToImportFileTable = 0;
1115 uint64_t LengthOfImportFileTable = 0;
1116 if (is64Bit()) {
1117 const LoaderSectionHeader64 *LoaderSec64 =
1118 viewAs<LoaderSectionHeader64>(LoaderSectionAddr);
1119 OffsetToImportFileTable = LoaderSec64->OffsetToImpid;
1120 LengthOfImportFileTable = LoaderSec64->LengthOfImpidStrTbl;
1121 } else {
1122 const LoaderSectionHeader32 *LoaderSec32 =
1123 viewAs<LoaderSectionHeader32>(LoaderSectionAddr);
1124 OffsetToImportFileTable = LoaderSec32->OffsetToImpid;
1125 LengthOfImportFileTable = LoaderSec32->LengthOfImpidStrTbl;
1126 }
1127
1128 auto ImportTableOrErr = getObject<char>(
1129 Data,
1130 reinterpret_cast<void *>(LoaderSectionAddr + OffsetToImportFileTable),
1131 LengthOfImportFileTable);
1132 if (!ImportTableOrErr)
1133 return createError(
1134 toString(ImportTableOrErr.takeError()) +
1135 ": import file table with offset 0x" +
1136 Twine::utohexstr(LoaderSectionAddr + OffsetToImportFileTable) +
1137 " and size 0x" + Twine::utohexstr(LengthOfImportFileTable) +
1138 " goes past the end of the file");
1139
1140 const char *ImportTablePtr = ImportTableOrErr.get();
1141 if (ImportTablePtr[LengthOfImportFileTable - 1] != '\0')
1142 return createError(
1143 ": import file name table with offset 0x" +
1144 Twine::utohexstr(LoaderSectionAddr + OffsetToImportFileTable) +
1145 " and size 0x" + Twine::utohexstr(LengthOfImportFileTable) +
1146 " must end with a null terminator");
1147
1148 return StringRef(ImportTablePtr, LengthOfImportFileTable);
1149}
1150
1152XCOFFObjectFile::create(unsigned Type, MemoryBufferRef MBR) {
1153 // Can't use std::make_unique because of the private constructor.
1154 std::unique_ptr<XCOFFObjectFile> Obj;
1155 Obj.reset(new XCOFFObjectFile(Type, MBR));
1156
1157 uint64_t CurOffset = 0;
1158 const auto *Base = Obj->base();
1159 MemoryBufferRef Data = Obj->Data;
1160
1161 // Parse file header.
1162 auto FileHeaderOrErr =
1163 getObject<void>(Data, Base + CurOffset, Obj->getFileHeaderSize());
1164 if (Error E = FileHeaderOrErr.takeError())
1165 return std::move(E);
1166 Obj->FileHeader = FileHeaderOrErr.get();
1167
1168 CurOffset += Obj->getFileHeaderSize();
1169
1170 if (Obj->getOptionalHeaderSize()) {
1171 auto AuxiliaryHeaderOrErr =
1172 getObject<void>(Data, Base + CurOffset, Obj->getOptionalHeaderSize());
1173 if (Error E = AuxiliaryHeaderOrErr.takeError())
1174 return std::move(E);
1175 Obj->AuxiliaryHeader = AuxiliaryHeaderOrErr.get();
1176 }
1177
1178 CurOffset += Obj->getOptionalHeaderSize();
1179
1180 // Parse the section header table if it is present.
1181 if (Obj->getNumberOfSections()) {
1182 uint64_t SectionHeadersSize =
1183 Obj->getNumberOfSections() * Obj->getSectionHeaderSize();
1184 auto SecHeadersOrErr =
1185 getObject<void>(Data, Base + CurOffset, SectionHeadersSize);
1186 if (!SecHeadersOrErr)
1187 return createError(toString(SecHeadersOrErr.takeError()) +
1188 ": section headers with offset 0x" +
1189 Twine::utohexstr(CurOffset) + " and size 0x" +
1190 Twine::utohexstr(SectionHeadersSize) +
1191 " go past the end of the file");
1192
1193 Obj->SectionHeaderTable = SecHeadersOrErr.get();
1194 }
1195
1196 const uint32_t NumberOfSymbolTableEntries =
1197 Obj->getNumberOfSymbolTableEntries();
1198
1199 // If there is no symbol table we are done parsing the memory buffer.
1200 if (NumberOfSymbolTableEntries == 0)
1201 return std::move(Obj);
1202
1203 // Parse symbol table.
1204 CurOffset = Obj->is64Bit() ? Obj->getSymbolTableOffset64()
1205 : Obj->getSymbolTableOffset32();
1206 const uint64_t SymbolTableSize =
1208 NumberOfSymbolTableEntries;
1209 auto SymTableOrErr =
1210 getObject<void *>(Data, Base + CurOffset, SymbolTableSize);
1211 if (!SymTableOrErr)
1212 return createError(
1213 toString(SymTableOrErr.takeError()) + ": symbol table with offset 0x" +
1214 Twine::utohexstr(CurOffset) + " and size 0x" +
1215 Twine::utohexstr(SymbolTableSize) + " goes past the end of the file");
1216
1217 Obj->SymbolTblPtr = SymTableOrErr.get();
1218 CurOffset += SymbolTableSize;
1219
1220 // Parse String table.
1221 Expected<XCOFFStringTable> StringTableOrErr =
1222 parseStringTable(Obj.get(), CurOffset);
1223 if (Error E = StringTableOrErr.takeError())
1224 return std::move(E);
1225 Obj->StringTable = StringTableOrErr.get();
1226
1227 return std::move(Obj);
1228}
1229
1230Expected<std::unique_ptr<ObjectFile>>
1232 unsigned FileType) {
1233 return XCOFFObjectFile::create(FileType, MemBufRef);
1234}
1235
1236std::optional<StringRef> XCOFFObjectFile::tryGetCPUName() const {
1237 return StringRef("future");
1238}
1239
1241 if (!isCsectSymbol())
1242 return false;
1243
1244 if (getSymbolType() & FunctionSym)
1245 return true;
1246
1248 if (!ExpCsectAuxEnt)
1249 return ExpCsectAuxEnt.takeError();
1250
1251 const XCOFFCsectAuxRef CsectAuxRef = ExpCsectAuxEnt.get();
1252
1253 if (CsectAuxRef.getStorageMappingClass() != XCOFF::XMC_PR &&
1254 CsectAuxRef.getStorageMappingClass() != XCOFF::XMC_GL)
1255 return false;
1256
1257 // A function definition should not be a common type symbol or an external
1258 // symbol.
1259 if (CsectAuxRef.getSymbolType() == XCOFF::XTY_CM ||
1260 CsectAuxRef.getSymbolType() == XCOFF::XTY_ER)
1261 return false;
1262
1263 // If the next symbol is an XTY_LD type symbol with the same address, this
1264 // XTY_SD symbol is not a function. Otherwise this is a function symbol for
1265 // -ffunction-sections.
1266 if (CsectAuxRef.getSymbolType() == XCOFF::XTY_SD) {
1267 // If this is a csect with size 0, it won't be a function definition.
1268 // This is used to work around the fact that LLVM always generates below
1269 // symbol for -ffunction-sections:
1270 // m 0x00000000 .text 1 unamex **No Symbol**
1271 // a4 0x00000000 0 0 SD PR 0 0
1272 // FIXME: remove or replace this meaningless symbol.
1273 if (getSize() == 0)
1274 return false;
1275
1276 xcoff_symbol_iterator NextIt(this);
1277 // If this is the last main symbol table entry, there won't be an XTY_LD
1278 // type symbol below.
1279 if (++NextIt == getObject()->symbol_end())
1280 return true;
1281
1282 if (cantFail(getAddress()) != cantFail(NextIt->getAddress()))
1283 return true;
1284
1285 // Check next symbol is XTY_LD. If so, this symbol is not a function.
1286 Expected<XCOFFCsectAuxRef> NextCsectAuxEnt = NextIt->getXCOFFCsectAuxRef();
1287 if (!NextCsectAuxEnt)
1288 return NextCsectAuxEnt.takeError();
1289
1290 if (NextCsectAuxEnt.get().getSymbolType() == XCOFF::XTY_LD)
1291 return false;
1292
1293 return true;
1294 }
1295
1296 if (CsectAuxRef.getSymbolType() == XCOFF::XTY_LD)
1297 return true;
1298
1299 return createError(
1300 "symbol csect aux entry with index " +
1301 Twine(getObject()->getSymbolIndex(CsectAuxRef.getEntryAddress())) +
1302 " has invalid symbol type " +
1303 Twine::utohexstr(CsectAuxRef.getSymbolType()));
1304}
1305
1308 return (SC == XCOFF::C_EXT || SC == XCOFF::C_WEAKEXT ||
1309 SC == XCOFF::C_HIDEXT);
1310}
1311
1314 "Calling csect symbol interface with a non-csect symbol.");
1315
1316 uint8_t NumberOfAuxEntries = getNumberOfAuxEntries();
1317
1318 Expected<StringRef> NameOrErr = getName();
1319 if (auto Err = NameOrErr.takeError())
1320 return std::move(Err);
1321
1322 uint32_t SymbolIdx = getObject()->getSymbolIndex(getEntryAddress());
1323 if (!NumberOfAuxEntries) {
1324 return createError("csect symbol \"" + *NameOrErr + "\" with index " +
1325 Twine(SymbolIdx) + " contains no auxiliary entry");
1326 }
1327
1328 if (!getObject()->is64Bit()) {
1329 // In XCOFF32, the csect auxilliary entry is always the last auxiliary
1330 // entry for the symbol.
1332 getEntryAddress(), NumberOfAuxEntries);
1333 return XCOFFCsectAuxRef(viewAs<XCOFFCsectAuxEnt32>(AuxAddr));
1334 }
1335
1336 // XCOFF64 uses SymbolAuxType to identify the auxiliary entry type.
1337 // We need to iterate through all the auxiliary entries to find it.
1338 for (uint8_t Index = NumberOfAuxEntries; Index > 0; --Index) {
1341 if (*getObject()->getSymbolAuxType(AuxAddr) ==
1343#ifndef NDEBUG
1344 getObject()->checkSymbolEntryPointer(AuxAddr);
1345#endif
1346 return XCOFFCsectAuxRef(viewAs<XCOFFCsectAuxEnt64>(AuxAddr));
1347 }
1348 }
1349
1350 return createError(
1351 "a csect auxiliary entry has not been found for symbol \"" + *NameOrErr +
1352 "\" with index " + Twine(SymbolIdx));
1353}
1354
1356 // A storage class value with the high-order bit on indicates that the name is
1357 // a symbolic debugger stabstring.
1358 if (getStorageClass() & 0x80)
1359 return StringRef("Unimplemented Debug Name");
1360
1361 if (!getObject()->is64Bit()) {
1362 if (getSymbol32()->NameInStrTbl.Magic !=
1364 return generateXCOFFFixedNameStringRef(getSymbol32()->SymbolName);
1365
1366 return getObject()->getStringTableEntry(getSymbol32()->NameInStrTbl.Offset);
1367 }
1368
1369 return getObject()->getStringTableEntry(getSymbol64()->Offset);
1370}
1371
1372// Explicitly instantiate template classes.
1375
1378
1387
1389 if (Bytes.size() < 4)
1390 return false;
1391
1392 return support::endian::read32be(Bytes.data()) == 0;
1393}
1394
1395#define GETVALUEWITHMASK(X) (Data & (TracebackTable::X))
1396#define GETVALUEWITHMASKSHIFT(X, S) \
1397 ((Data & (TracebackTable::X)) >> (TracebackTable::S))
1398
1400 Error Err = Error::success();
1401 TBVectorExt TBTVecExt(TBvectorStrRef, Err);
1402 if (Err)
1403 return std::move(Err);
1404 return TBTVecExt;
1405}
1406
1407TBVectorExt::TBVectorExt(StringRef TBvectorStrRef, Error &Err) {
1408 const uint8_t *Ptr = reinterpret_cast<const uint8_t *>(TBvectorStrRef.data());
1410 uint32_t VecParmsTypeValue = support::endian::read32be(Ptr + 2);
1411 unsigned ParmsNum =
1412 GETVALUEWITHMASKSHIFT(NumberOfVectorParmsMask, NumberOfVectorParmsShift);
1413
1414 ErrorAsOutParameter EAO(&Err);
1415 Expected<SmallString<32>> VecParmsTypeOrError =
1416 parseVectorParmsType(VecParmsTypeValue, ParmsNum);
1417 if (!VecParmsTypeOrError)
1418 Err = VecParmsTypeOrError.takeError();
1419 else
1420 VecParmsInfo = VecParmsTypeOrError.get();
1421}
1422
1424 return GETVALUEWITHMASKSHIFT(NumberOfVRSavedMask, NumberOfVRSavedShift);
1425}
1426
1428 return GETVALUEWITHMASK(IsVRSavedOnStackMask);
1429}
1430
1432 return GETVALUEWITHMASK(HasVarArgsMask);
1433}
1434
1436 return GETVALUEWITHMASKSHIFT(NumberOfVectorParmsMask,
1437 NumberOfVectorParmsShift);
1438}
1439
1441 return GETVALUEWITHMASK(HasVMXInstructionMask);
1442}
1443#undef GETVALUEWITHMASK
1444#undef GETVALUEWITHMASKSHIFT
1445
1447XCOFFTracebackTable::create(const uint8_t *Ptr, uint64_t &Size, bool Is64Bit) {
1448 Error Err = Error::success();
1449 XCOFFTracebackTable TBT(Ptr, Size, Err, Is64Bit);
1450 if (Err)
1451 return std::move(Err);
1452 return TBT;
1453}
1454
1455XCOFFTracebackTable::XCOFFTracebackTable(const uint8_t *Ptr, uint64_t &Size,
1456 Error &Err, bool Is64Bit)
1457 : TBPtr(Ptr), Is64BitObj(Is64Bit) {
1458 ErrorAsOutParameter EAO(&Err);
1459 DataExtractor DE(ArrayRef<uint8_t>(Ptr, Size), /*IsLittleEndian=*/false,
1460 /*AddressSize=*/0);
1461 DataExtractor::Cursor Cur(/*Offset=*/0);
1462
1463 // Skip 8 bytes of mandatory fields.
1464 DE.getU64(Cur);
1465
1466 unsigned FixedParmsNum = getNumberOfFixedParms();
1467 unsigned FloatingParmsNum = getNumberOfFPParms();
1468 uint32_t ParamsTypeValue = 0;
1469
1470 // Begin to parse optional fields.
1471 if (Cur && (FixedParmsNum + FloatingParmsNum) > 0)
1472 ParamsTypeValue = DE.getU32(Cur);
1473
1474 if (Cur && hasTraceBackTableOffset())
1475 TraceBackTableOffset = DE.getU32(Cur);
1476
1477 if (Cur && isInterruptHandler())
1478 HandlerMask = DE.getU32(Cur);
1479
1480 if (Cur && hasControlledStorage()) {
1481 NumOfCtlAnchors = DE.getU32(Cur);
1482 if (Cur && NumOfCtlAnchors) {
1484 Disp.reserve(*NumOfCtlAnchors);
1485 for (uint32_t I = 0; I < NumOfCtlAnchors && Cur; ++I)
1486 Disp.push_back(DE.getU32(Cur));
1487 if (Cur)
1488 ControlledStorageInfoDisp = std::move(Disp);
1489 }
1490 }
1491
1492 if (Cur && isFuncNamePresent()) {
1493 uint16_t FunctionNameLen = DE.getU16(Cur);
1494 if (Cur)
1495 FunctionName = DE.getBytes(Cur, FunctionNameLen);
1496 }
1497
1498 if (Cur && isAllocaUsed())
1499 AllocaRegister = DE.getU8(Cur);
1500
1501 unsigned VectorParmsNum = 0;
1502 if (Cur && hasVectorInfo()) {
1503 StringRef VectorExtRef = DE.getBytes(Cur, 6);
1504 if (Cur) {
1505 Expected<TBVectorExt> TBVecExtOrErr = TBVectorExt::create(VectorExtRef);
1506 if (!TBVecExtOrErr) {
1507 Err = TBVecExtOrErr.takeError();
1508 return;
1509 }
1510 VecExt = TBVecExtOrErr.get();
1511 VectorParmsNum = VecExt->getNumberOfVectorParms();
1512 // Skip two bytes of padding after vector info.
1513 DE.skip(Cur, 2);
1514 }
1515 }
1516
1517 // As long as there is no fixed-point or floating-point parameter, this
1518 // field remains not present even when hasVectorInfo gives true and
1519 // indicates the presence of vector parameters.
1520 if (Cur && (FixedParmsNum + FloatingParmsNum) > 0) {
1521 Expected<SmallString<32>> ParmsTypeOrError =
1523 ? parseParmsTypeWithVecInfo(ParamsTypeValue, FixedParmsNum,
1524 FloatingParmsNum, VectorParmsNum)
1525 : parseParmsType(ParamsTypeValue, FixedParmsNum, FloatingParmsNum);
1526
1527 if (!ParmsTypeOrError) {
1528 Err = ParmsTypeOrError.takeError();
1529 return;
1530 }
1531 ParmsType = ParmsTypeOrError.get();
1532 }
1533
1534 if (Cur && hasExtensionTable()) {
1535 ExtensionTable = DE.getU8(Cur);
1536
1537 if (*ExtensionTable & ExtendedTBTableFlag::TB_EH_INFO) {
1538 // eh_info displacement must be 4-byte aligned.
1539 Cur.seek(alignTo(Cur.tell(), 4));
1540 EhInfoDisp = Is64BitObj ? DE.getU64(Cur) : DE.getU32(Cur);
1541 }
1542 }
1543 if (!Cur)
1544 Err = Cur.takeError();
1545
1546 Size = Cur.tell();
1547}
1548
1549#define GETBITWITHMASK(P, X) \
1550 (support::endian::read32be(TBPtr + (P)) & (TracebackTable::X))
1551#define GETBITWITHMASKSHIFT(P, X, S) \
1552 ((support::endian::read32be(TBPtr + (P)) & (TracebackTable::X)) >> \
1553 (TracebackTable::S))
1554
1556 return GETBITWITHMASKSHIFT(0, VersionMask, VersionShift);
1557}
1558
1560 return GETBITWITHMASKSHIFT(0, LanguageIdMask, LanguageIdShift);
1561}
1562
1564 return GETBITWITHMASK(0, IsGlobaLinkageMask);
1565}
1566
1568 return GETBITWITHMASK(0, IsOutOfLineEpilogOrPrologueMask);
1569}
1570
1572 return GETBITWITHMASK(0, HasTraceBackTableOffsetMask);
1573}
1574
1576 return GETBITWITHMASK(0, IsInternalProcedureMask);
1577}
1578
1580 return GETBITWITHMASK(0, HasControlledStorageMask);
1581}
1582
1584 return GETBITWITHMASK(0, IsTOClessMask);
1585}
1586
1588 return GETBITWITHMASK(0, IsFloatingPointPresentMask);
1589}
1590
1592 return GETBITWITHMASK(0, IsFloatingPointOperationLogOrAbortEnabledMask);
1593}
1594
1596 return GETBITWITHMASK(0, IsInterruptHandlerMask);
1597}
1598
1600 return GETBITWITHMASK(0, IsFunctionNamePresentMask);
1601}
1602
1604 return GETBITWITHMASK(0, IsAllocaUsedMask);
1605}
1606
1608 return GETBITWITHMASKSHIFT(0, OnConditionDirectiveMask,
1609 OnConditionDirectiveShift);
1610}
1611
1613 return GETBITWITHMASK(0, IsCRSavedMask);
1614}
1615
1617 return GETBITWITHMASK(0, IsLRSavedMask);
1618}
1619
1621 return GETBITWITHMASK(4, IsBackChainStoredMask);
1622}
1623
1625 return GETBITWITHMASK(4, IsFixupMask);
1626}
1627
1629 return GETBITWITHMASKSHIFT(4, FPRSavedMask, FPRSavedShift);
1630}
1631
1633 return GETBITWITHMASK(4, HasExtensionTableMask);
1634}
1635
1637 return GETBITWITHMASK(4, HasVectorInfoMask);
1638}
1639
1641 return GETBITWITHMASKSHIFT(4, GPRSavedMask, GPRSavedShift);
1642}
1643
1645 return GETBITWITHMASKSHIFT(4, NumberOfFixedParmsMask,
1646 NumberOfFixedParmsShift);
1647}
1648
1650 return GETBITWITHMASKSHIFT(4, NumberOfFloatingPointParmsMask,
1651 NumberOfFloatingPointParmsShift);
1652}
1653
1655 return GETBITWITHMASK(4, HasParmsOnStackMask);
1656}
1657
1658#undef GETBITWITHMASK
1659#undef GETBITWITHMASKSHIFT
1660} // namespace object
1661} // namespace llvm
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
Analysis containing CSE Info
Definition: CSEInfo.cpp:27
Elf_Shdr Shdr
uint64_t Addr
std::string Name
uint64_t Size
Symbol * Sym
Definition: ELF_riscv.cpp:479
#define I(x, y, z)
Definition: MD5.cpp:58
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file implements the StringSwitch template, which mimics a switch() statement whose cases are str...
static bool is64Bit(const char *name)
#define GETVALUEWITHMASKSHIFT(X, S)
#define GETVALUEWITHMASK(X)
#define GETBITWITHMASKSHIFT(P, X, S)
#define GETBITWITHMASK(P, X)
#define ECASE(Value, String)
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:165
const T * data() const
Definition: ArrayRef.h:162
A class representing a position in a DataExtractor, as well as any error encountered during extractio...
Definition: DataExtractor.h:54
Helper for Errors used as out-parameters.
Definition: Error.h:1130
Lightweight error class with error context and mandatory checking.
Definition: Error.h:160
static ErrorSuccess success()
Create a success value.
Definition: Error.h:337
Tagged union holding either a T or a Error.
Definition: Error.h:481
Error takeError()
Take ownership of the stored error.
Definition: Error.h:608
reference get()
Returns a reference to the stored T value.
Definition: Error.h:578
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition: SmallString.h:26
const char * c_str()
Definition: SmallString.h:259
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: SmallVector.h:586
void reserve(size_type N)
Definition: SmallVector.h:676
void push_back(const T &Elt)
Definition: SmallVector.h:426
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1209
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
iterator begin() const
Definition: StringRef.h:111
constexpr const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:131
iterator end() const
Definition: StringRef.h:113
A switch()-like statement whose cases are string literals.
Definition: StringSwitch.h:44
StringSwitch & Case(StringLiteral S, T Value)
Definition: StringSwitch.h:69
R Default(T Value)
Definition: StringSwitch.h:182
Manages the enabling and disabling of subtarget specific features.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
static Twine utohexstr(const uint64_t &Val)
Definition: Twine.h:416
void toVector(SmallVectorImpl< char > &Out) const
Append the concatenated string into the given SmallString or SmallVector.
Definition: Twine.cpp:32
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
A range adaptor for a pair of iterators.
MemoryBufferRef Data
Definition: Binary.h:37
unsigned int getType() const
Definition: Binary.h:104
static Error checkOffset(MemoryBufferRef M, uintptr_t Addr, const uint64_t Size)
Definition: Binary.h:175
This class is the base class for all object file types.
Definition: ObjectFile.h:229
friend class RelocationRef
Definition: ObjectFile.h:287
friend class SymbolRef
Definition: ObjectFile.h:247
friend class SectionRef
Definition: ObjectFile.h:261
const uint8_t * base() const
Definition: ObjectFile.h:235
static Expected< std::unique_ptr< ObjectFile > > createXCOFFObjectFile(MemoryBufferRef Object, unsigned FileType)
This is a value type class that represents a single symbol in the list of symbols in the object file.
Definition: ObjectFile.h:168
Expected< uint64_t > getAddress() const
Returns the symbol virtual address (i.e.
Definition: ObjectFile.h:464
uint8_t getNumberOfVectorParms() const
static Expected< TBVectorExt > create(StringRef TBvectorStrRef)
uint8_t getNumberOfVRSaved() const
XCOFF::StorageMappingClass getStorageMappingClass() const
Expected< DataRefImpl > getSectionByNum(int16_t Num) const
uint8_t getBytesInAddress() const override
The number of bytes used to represent an address in this object file format.
const void * getPointerToSymbolTable() const
section_iterator section_begin() const override
uint32_t getSymbolIndex(uintptr_t SymEntPtr) const
relocation_iterator section_rel_end(DataRefImpl Sec) const override
Expected< StringRef > getCFileName(const XCOFFFileAuxEnt *CFileEntPtr) const
uintptr_t getSymbolEntryAddressByIndex(uint32_t SymbolTableIndex) const
bool isDebugSection(DataRefImpl Sec) const override
const XCOFFAuxiliaryHeader32 * auxiliaryHeader32() const
ArrayRef< XCOFFSectionHeader32 > sections32() const
void getRelocationTypeName(DataRefImpl Rel, SmallVectorImpl< char > &Result) const override
const XCOFFFileHeader64 * fileHeader64() const
ArrayRef< XCOFFSectionHeader64 > sections64() const
Expected< uint64_t > getStartAddress() const override
Expected< uint32_t > getSymbolFlags(DataRefImpl Symb) const override
uint32_t getSymbolTableOffset32() const
bool isSectionVirtual(DataRefImpl Sec) const override
bool isSectionBSS(DataRefImpl Sec) const override
Expected< StringRef > getSectionName(DataRefImpl Sec) const override
uint32_t getNumberOfSymbolTableEntries() const
bool isSectionData(DataRefImpl Sec) const override
uint64_t getRelocationOffset(DataRefImpl Rel) const override
uint64_t getSectionSize(DataRefImpl Sec) const override
symbol_iterator getRelocationSymbol(DataRefImpl Rel) const override
int32_t getSectionFlags(DataRefImpl Sec) const
Expected< StringRef > getSymbolName(DataRefImpl Symb) const override
const XCOFFFileHeader32 * fileHeader32() const
int32_t getRawNumberOfSymbolTableEntries32() const
Expected< SymbolRef::Type > getSymbolType(DataRefImpl Symb) const override
uint32_t getNumberOfSymbolTableEntries64() const
iterator_range< xcoff_symbol_iterator > xcoff_symbol_iterator_range
const XCOFFAuxiliaryHeader64 * auxiliaryHeader64() const
uint16_t getOptionalHeaderSize() const
uint64_t getCommonSymbolSizeImpl(DataRefImpl Symb) const override
XCOFFSymbolRef toSymbolRef(DataRefImpl Ref) const
basic_symbol_iterator symbol_begin() const override
Expected< StringRef > getSymbolNameByIndex(uint32_t SymbolTableIndex) const
unsigned getSymbolSectionID(SymbolRef Sym) const
uint64_t getSymbolTableOffset64() const
uint64_t getSymbolValueImpl(DataRefImpl Symb) const override
void moveRelocationNext(DataRefImpl &Rel) const override
Expected< StringRef > getImportFileTable() const
StringRef getFileFormatName() const override
Expected< uint32_t > getNumberOfRelocationEntries(const XCOFFSectionHeader< T > &Sec) const
bool isSectionCompressed(DataRefImpl Sec) const override
Expected< StringRef > getSymbolSectionName(XCOFFSymbolRef Ref) const
Expected< StringRef > getStringTableEntry(uint32_t Offset) const
static constexpr uint64_t InvalidRelocOffset
uint64_t getSectionAddress(DataRefImpl Sec) const override
Expected< ArrayRef< uint8_t > > getSectionContents(DataRefImpl Sec) const override
Expected< ArrayRef< ExceptEnt > > getExceptionEntries() const
Expected< SubtargetFeatures > getFeatures() const override
relocation_iterator section_rel_begin(DataRefImpl Sec) const override
uint64_t getSectionAlignment(DataRefImpl Sec) const override
void checkSymbolEntryPointer(uintptr_t SymbolEntPtr) const
StringRef mapDebugSectionName(StringRef Name) const override
Maps a debug section name to a standard DWARF section name.
basic_symbol_iterator symbol_end() const override
static uintptr_t getAdvancedSymbolEntryAddress(uintptr_t CurrentAddress, uint32_t Distance)
bool is64Bit() const override
const XCOFF::SymbolAuxType * getSymbolAuxType(uintptr_t AuxEntryAddress) const
Triple::ArchType getArch() const override
uint64_t getRelocationType(DataRefImpl Rel) const override
std::optional< StringRef > tryGetCPUName() const override
bool isSectionText(DataRefImpl Sec) const override
Expected< StringRef > getRawData(const char *Start, uint64_t Size, StringRef Name) const
uint64_t getSymbolSize(DataRefImpl Symb) const
void moveSymbolNext(DataRefImpl &Symb) const override
Expected< ArrayRef< Reloc > > relocations(const Shdr &Sec) const
uint64_t getSectionIndex(DataRefImpl Sec) const override
bool isRelocatableObject() const override
True if this is a relocatable object (.o/.obj).
void moveSectionNext(DataRefImpl &Sec) const override
Expected< section_iterator > getSymbolSection(DataRefImpl Symb) const override
section_iterator section_end() const override
uint32_t getLogicalNumberOfSymbolTableEntries32() const
xcoff_symbol_iterator_range symbols() const
uint32_t getSymbolAlignment(DataRefImpl Symb) const override
Expected< uint64_t > getSymbolAddress(DataRefImpl Symb) const override
Expected< XCOFFCsectAuxRef > getXCOFFCsectAuxRef() const
Expected< bool > isFunction() const
const XCOFFSymbolEntry64 * getSymbol64() const
const XCOFFSymbolEntry32 * getSymbol32() const
Expected< StringRef > getName() const
uint8_t getNumberOfAuxEntries() const
uintptr_t getEntryAddress() const
XCOFF::StorageClass getStorageClass() const
This class provides methods to extract traceback table data from a buffer.
static Expected< XCOFFTracebackTable > create(const uint8_t *Ptr, uint64_t &Size, bool Is64Bits=false)
Parse an XCOFF Traceback Table from Ptr with Size bytes.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
static constexpr uint8_t XR_BIASED_LENGTH_MASK
Definition: XCOFF.h:60
constexpr size_t RelocationSerializationSize32
Definition: XCOFF.h:39
static constexpr uint8_t XR_FIXUP_INDICATOR_MASK
Definition: XCOFF.h:57
constexpr uint16_t VISIBILITY_MASK
Definition: XCOFF.h:259
Expected< SmallString< 32 > > parseParmsTypeWithVecInfo(uint32_t Value, unsigned FixedParmsNum, unsigned FloatingParmsNum, unsigned VectorParmsNum)
Definition: XCOFF.cpp:188
static constexpr uint8_t XR_SIGN_INDICATOR_MASK
Definition: XCOFF.h:54
StringRef getRelocationTypeString(XCOFF::RelocationType Type)
Definition: XCOFF.cpp:53
Expected< SmallString< 32 > > parseParmsType(uint32_t Value, unsigned FixedParmsNum, unsigned FloatingParmsNum)
Definition: XCOFF.cpp:110
constexpr size_t RelocationSerializationSize64
Definition: XCOFF.h:40
Expected< SmallString< 32 > > parseVectorParmsType(uint32_t Value, unsigned ParmsNum)
Definition: XCOFF.cpp:240
SymbolAuxType
Definition: XCOFF.h:342
@ AUX_CSECT
Identifies a csect auxiliary entry.
Definition: XCOFF.h:347
@ SYM_V_HIDDEN
Definition: XCOFF.h:254
@ SYM_V_EXPORTED
Definition: XCOFF.h:256
constexpr size_t NameSize
Definition: XCOFF.h:29
constexpr uint16_t RelocOverflow
Definition: XCOFF.h:43
@ N_DEBUG
Definition: XCOFF.h:46
@ N_UNDEF
Definition: XCOFF.h:46
@ N_ABS
Definition: XCOFF.h:46
StorageClass
Definition: XCOFF.h:170
@ C_WEAKEXT
Definition: XCOFF.h:199
@ C_FILE
Definition: XCOFF.h:172
@ C_HIDEXT
Definition: XCOFF.h:206
@ XMC_GL
Global Linkage (Interfile Interface Code)
Definition: XCOFF.h:108
@ XMC_PR
Program Code.
Definition: XCOFF.h:105
@ NEW_XCOFF_INTERPRET
Definition: XCOFF.h:75
constexpr size_t SymbolTableEntrySize
Definition: XCOFF.h:38
@ XTY_CM
Common csect definition. For uninitialized storage.
Definition: XCOFF.h:245
@ XTY_SD
Csect definition for initialized storage.
Definition: XCOFF.h:242
@ XTY_LD
Label definition.
Definition: XCOFF.h:243
@ XTY_ER
External reference.
Definition: XCOFF.h:241
SectionTypeFlags
Definition: XCOFF.h:134
@ STYP_TYPCHK
Definition: XCOFF.h:146
@ STYP_LOADER
Definition: XCOFF.h:144
@ STYP_DWARF
Definition: XCOFF.h:136
@ STYP_DATA
Definition: XCOFF.h:138
@ STYP_INFO
Definition: XCOFF.h:141
@ STYP_TDATA
Definition: XCOFF.h:142
@ STYP_TEXT
Definition: XCOFF.h:137
@ STYP_DEBUG
Definition: XCOFF.h:145
@ STYP_PAD
Definition: XCOFF.h:135
@ STYP_EXCEPT
Definition: XCOFF.h:140
@ STYP_OVRFLO
Definition: XCOFF.h:147
@ STYP_BSS
Definition: XCOFF.h:139
@ STYP_TBSS
Definition: XCOFF.h:143
std::optional< const char * > toString(const std::optional< DWARFFormValue > &V)
Take an optional DWARFFormValue and try to extract a string value from it.
static Expected< const T * > getObject(MemoryBufferRef M, const void *Ptr, const uint64_t Size=sizeof(T))
bool doesXCOFFTracebackTableBegin(ArrayRef< uint8_t > Bytes)
Error createError(const Twine &Err)
Definition: Error.h:84
Expected< StringRef > getLoaderSecSymNameInStrTbl(const T *LoaderSecHeader, uint64_t Offset)
static const size_t SymbolAuxTypeOffset
static const uint16_t NoRelMask
content_iterator< SectionRef > section_iterator
Definition: ObjectFile.h:47
static const uint8_t FunctionSym
content_iterator< RelocationRef > relocation_iterator
Definition: ObjectFile.h:77
content_iterator< BasicSymbolRef > basic_symbol_iterator
Definition: SymbolicFile.h:143
static uintptr_t getWithOffset(uintptr_t Base, ptrdiff_t Offset)
static StringRef generateXCOFFFixedNameStringRef(const char *Name)
static const T * viewAs(uintptr_t in)
uint32_t read32be(const void *P)
Definition: Endian.h:434
uint16_t read16be(const void *P)
Definition: Endian.h:431
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:480
Error createStringError(std::error_code EC, char const *Fmt, const Ts &... Vals)
Create formatted StringError object.
Definition: Error.h:1286
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:167
@ Ref
The access may reference the value stored in memory.
void cantFail(Error Err, const char *Msg=nullptr)
Report a fatal error if Err is a failure value.
Definition: Error.h:756
uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
Definition: Alignment.h:155
Error errorCodeToError(std::error_code EC)
Helper for converting an std::error_code to a Error.
Definition: Error.cpp:111
void consumeError(Error Err)
Consume a Error without doing anything.
Definition: Error.h:1069
Expected< StringRef > getSymbolName(const LoaderSectionHeader32 *LoaderSecHeader) const
Expected< StringRef > getSymbolName(const LoaderSectionHeader64 *LoaderSecHeader) const
char Name[XCOFF::NameSize+XCOFF::FileNamePadSize]
support::big32_t NumberOfSymTableEntries
support::ubig16_t NumberOfSections
support::ubig32_t SymbolTableOffset
support::ubig64_t SymbolTableOffset
support::ubig32_t NumberOfSymTableEntries
support::ubig16_t NumberOfSections
XCOFF::RelocationType Type