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
13 #include "llvm/Object/XCOFFObjectFile.h"
14 #include "llvm/ADT/StringSwitch.h"
15 #include "llvm/Support/DataExtractor.h"
16 #include "llvm/TargetParser/SubtargetFeature.h"
17 #include <cstddef>
18 #include <cstring>
19
20 namespace llvm {
21
22 using namespace XCOFF;
23
24 namespace object {
25
26 static const uint8_t FunctionSym = 0x20;
27 static const uint16_t NoRelMask = 0x0001;
28 static 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.
32 template <typename T>
getObject(MemoryBufferRef M,const void * Ptr,const uint64_t Size=sizeof (T))33 static Expected<const T *> getObject(MemoryBufferRef M, const void *Ptr,
34 const uint64_t Size = sizeof(T)) {
35 uintptr_t Addr = reinterpret_cast<uintptr_t>(Ptr);
36 if (Error E = Binary::checkOffset(M, Addr, Size))
37 return std::move(E);
38 return reinterpret_cast<const T *>(Addr);
39 }
40
getWithOffset(uintptr_t Base,ptrdiff_t Offset)41 static uintptr_t getWithOffset(uintptr_t Base, ptrdiff_t Offset) {
42 return reinterpret_cast<uintptr_t>(reinterpret_cast<const char *>(Base) +
43 Offset);
44 }
45
viewAs(uintptr_t in)46 template <typename T> static const T *viewAs(uintptr_t in) {
47 return reinterpret_cast<const T *>(in);
48 }
49
generateXCOFFFixedNameStringRef(const char * Name)50 static StringRef generateXCOFFFixedNameStringRef(const char *Name) {
51 auto NulCharPtr =
52 static_cast<const char *>(memchr(Name, '\0', XCOFF::NameSize));
53 return NulCharPtr ? StringRef(Name, NulCharPtr - Name)
54 : StringRef(Name, XCOFF::NameSize);
55 }
56
getName() const57 template <typename T> StringRef XCOFFSectionHeader<T>::getName() const {
58 const T &DerivedXCOFFSectionHeader = static_cast<const T &>(*this);
59 return generateXCOFFFixedNameStringRef(DerivedXCOFFSectionHeader.Name);
60 }
61
getSectionType() const62 template <typename T> uint16_t XCOFFSectionHeader<T>::getSectionType() const {
63 const T &DerivedXCOFFSectionHeader = static_cast<const T &>(*this);
64 return DerivedXCOFFSectionHeader.Flags & SectionFlagsTypeMask;
65 }
66
67 template <typename T>
getSectionSubtype() const68 uint32_t XCOFFSectionHeader<T>::getSectionSubtype() const {
69 const T &DerivedXCOFFSectionHeader = static_cast<const T &>(*this);
70 return DerivedXCOFFSectionHeader.Flags & ~SectionFlagsTypeMask;
71 }
72
73 template <typename T>
isReservedSectionType() const74 bool XCOFFSectionHeader<T>::isReservedSectionType() const {
75 return getSectionType() & SectionFlagsReservedMask;
76 }
77
78 template <typename AddressType>
isRelocationSigned() const79 bool XCOFFRelocation<AddressType>::isRelocationSigned() const {
80 return Info & XR_SIGN_INDICATOR_MASK;
81 }
82
83 template <typename AddressType>
isFixupIndicated() const84 bool XCOFFRelocation<AddressType>::isFixupIndicated() const {
85 return Info & XR_FIXUP_INDICATOR_MASK;
86 }
87
88 template <typename AddressType>
getRelocatedLength() const89 uint8_t XCOFFRelocation<AddressType>::getRelocatedLength() const {
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
95 template struct ExceptionSectionEntry<support::ubig32_t>;
96 template struct ExceptionSectionEntry<support::ubig64_t>;
97
98 template <typename T>
getLoaderSecSymNameInStrTbl(const T * LoaderSecHeader,uint64_t Offset)99 Expected<StringRef> getLoaderSecSymNameInStrTbl(const T *LoaderSecHeader,
100 uint64_t Offset) {
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
getSymbolName(const LoaderSectionHeader32 * LoaderSecHeader32) const111 Expected<StringRef> LoaderSectionSymbolEntry32::getSymbolName(
112 const LoaderSectionHeader32 *LoaderSecHeader32) const {
113 const NameOffsetInStrTbl *NameInStrTbl =
114 reinterpret_cast<const NameOffsetInStrTbl *>(SymbolName);
115 if (NameInStrTbl->IsNameInStrTbl != XCOFFSymbolRef::NAME_IN_STR_TBL_MAGIC)
116 return generateXCOFFFixedNameStringRef(SymbolName);
117
118 return getLoaderSecSymNameInStrTbl(LoaderSecHeader32, NameInStrTbl->Offset);
119 }
120
getSymbolName(const LoaderSectionHeader64 * LoaderSecHeader64) const121 Expected<StringRef> LoaderSectionSymbolEntry64::getSymbolName(
122 const LoaderSectionHeader64 *LoaderSecHeader64) const {
123 return getLoaderSecSymNameInStrTbl(LoaderSecHeader64, Offset);
124 }
125
126 uintptr_t
getAdvancedSymbolEntryAddress(uintptr_t CurrentAddress,uint32_t Distance)127 XCOFFObjectFile::getAdvancedSymbolEntryAddress(uintptr_t CurrentAddress,
128 uint32_t Distance) {
129 return getWithOffset(CurrentAddress, Distance * XCOFF::SymbolTableEntrySize);
130 }
131
132 const XCOFF::SymbolAuxType *
getSymbolAuxType(uintptr_t AuxEntryAddress) const133 XCOFFObjectFile::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
checkSectionAddress(uintptr_t Addr,uintptr_t TableAddress) const139 void 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)
149 report_fatal_error(
150 "Section header pointer does not point to a valid section header.");
151 }
152
153 const XCOFFSectionHeader32 *
toSection32(DataRefImpl Ref) const154 XCOFFObjectFile::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
162 const XCOFFSectionHeader64 *
toSection64(DataRefImpl Ref) const163 XCOFFObjectFile::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);
169 }
170
toSymbolRef(DataRefImpl Ref) const171 XCOFFSymbolRef XCOFFObjectFile::toSymbolRef(DataRefImpl Ref) const {
172 assert(Ref.p != 0 && "Symbol table pointer can not be nullptr!");
173 #ifndef NDEBUG
174 checkSymbolEntryPointer(Ref.p);
175 #endif
176 return XCOFFSymbolRef(Ref, this);
177 }
178
fileHeader32() const179 const XCOFFFileHeader32 *XCOFFObjectFile::fileHeader32() const {
180 assert(!is64Bit() && "32-bit interface called on 64-bit object file.");
181 return static_cast<const XCOFFFileHeader32 *>(FileHeader);
182 }
183
fileHeader64() const184 const XCOFFFileHeader64 *XCOFFObjectFile::fileHeader64() const {
185 assert(is64Bit() && "64-bit interface called on a 32-bit object file.");
186 return static_cast<const XCOFFFileHeader64 *>(FileHeader);
187 }
188
auxiliaryHeader32() const189 const XCOFFAuxiliaryHeader32 *XCOFFObjectFile::auxiliaryHeader32() const {
190 assert(!is64Bit() && "32-bit interface called on 64-bit object file.");
191 return static_cast<const XCOFFAuxiliaryHeader32 *>(AuxiliaryHeader);
192 }
193
auxiliaryHeader64() const194 const XCOFFAuxiliaryHeader64 *XCOFFObjectFile::auxiliaryHeader64() const {
195 assert(is64Bit() && "64-bit interface called on a 32-bit object file.");
196 return static_cast<const XCOFFAuxiliaryHeader64 *>(AuxiliaryHeader);
197 }
198
sectionHeaderTable() const199 template <typename T> const T *XCOFFObjectFile::sectionHeaderTable() const {
200 return static_cast<const T *>(SectionHeaderTable);
201 }
202
203 const XCOFFSectionHeader32 *
sectionHeaderTable32() const204 XCOFFObjectFile::sectionHeaderTable32() const {
205 assert(!is64Bit() && "32-bit interface called on 64-bit object file.");
206 return static_cast<const XCOFFSectionHeader32 *>(SectionHeaderTable);
207 }
208
209 const XCOFFSectionHeader64 *
sectionHeaderTable64() const210 XCOFFObjectFile::sectionHeaderTable64() const {
211 assert(is64Bit() && "64-bit interface called on a 32-bit object file.");
212 return static_cast<const XCOFFSectionHeader64 *>(SectionHeaderTable);
213 }
214
moveSymbolNext(DataRefImpl & Symb) const215 void XCOFFObjectFile::moveSymbolNext(DataRefImpl &Symb) const {
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
227 Expected<StringRef>
getStringTableEntry(uint32_t Offset) const228 XCOFFObjectFile::getStringTableEntry(uint32_t Offset) const {
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
getStringTable() const245 StringRef XCOFFObjectFile::getStringTable() const {
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
252 Expected<StringRef>
getCFileName(const XCOFFFileAuxEnt * CFileEntPtr) const253 XCOFFObjectFile::getCFileName(const XCOFFFileAuxEnt *CFileEntPtr) const {
254 if (CFileEntPtr->NameInStrTbl.Magic != XCOFFSymbolRef::NAME_IN_STR_TBL_MAGIC)
255 return generateXCOFFFixedNameStringRef(CFileEntPtr->Name);
256 return getStringTableEntry(CFileEntPtr->NameInStrTbl.Offset);
257 }
258
getSymbolName(DataRefImpl Symb) const259 Expected<StringRef> XCOFFObjectFile::getSymbolName(DataRefImpl Symb) const {
260 return toSymbolRef(Symb).getName();
261 }
262
getSymbolAddress(DataRefImpl Symb) const263 Expected<uint64_t> XCOFFObjectFile::getSymbolAddress(DataRefImpl Symb) const {
264 return toSymbolRef(Symb).getValue();
265 }
266
getSymbolValueImpl(DataRefImpl Symb) const267 uint64_t XCOFFObjectFile::getSymbolValueImpl(DataRefImpl Symb) const {
268 return toSymbolRef(Symb).getValue();
269 }
270
getSymbolAlignment(DataRefImpl Symb) const271 uint32_t XCOFFObjectFile::getSymbolAlignment(DataRefImpl Symb) const {
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
getCommonSymbolSizeImpl(DataRefImpl Symb) const286 uint64_t XCOFFObjectFile::getCommonSymbolSizeImpl(DataRefImpl Symb) const {
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
304 Expected<SymbolRef::Type>
getSymbolType(DataRefImpl Symb) const305 XCOFFObjectFile::getSymbolType(DataRefImpl Symb) const {
306 XCOFFSymbolRef XCOFFSym = toSymbolRef(Symb);
307
308 Expected<bool> IsFunction = XCOFFSym.isFunction();
309 if (!IsFunction)
310 return IsFunction.takeError();
311
312 if (*IsFunction)
313 return SymbolRef::ST_Function;
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 =
323 getSectionByNum(XCOFFSym.getSectionNumber());
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
357 Expected<section_iterator>
getSymbolSection(DataRefImpl Symb) const358 XCOFFObjectFile::getSymbolSection(DataRefImpl Symb) const {
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
moveSectionNext(DataRefImpl & Sec) const371 void XCOFFObjectFile::moveSectionNext(DataRefImpl &Sec) const {
372 const char *Ptr = reinterpret_cast<const char *>(Sec.p);
373 Sec.p = reinterpret_cast<uintptr_t>(Ptr + getSectionHeaderSize());
374 }
375
getSectionName(DataRefImpl Sec) const376 Expected<StringRef> XCOFFObjectFile::getSectionName(DataRefImpl Sec) const {
377 return generateXCOFFFixedNameStringRef(getSectionNameInternal(Sec));
378 }
379
getSectionAddress(DataRefImpl Sec) const380 uint64_t XCOFFObjectFile::getSectionAddress(DataRefImpl Sec) const {
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
getSectionIndex(DataRefImpl Sec) const389 uint64_t XCOFFObjectFile::getSectionIndex(DataRefImpl Sec) const {
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
getSectionSize(DataRefImpl Sec) const398 uint64_t XCOFFObjectFile::getSectionSize(DataRefImpl Sec) const {
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
407 Expected<ArrayRef<uint8_t>>
getSectionContents(DataRefImpl Sec) const408 XCOFFObjectFile::getSectionContents(DataRefImpl Sec) const {
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);
420 if (Error E = Binary::checkOffset(
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
getSectionAlignment(DataRefImpl Sec) const430 uint64_t XCOFFObjectFile::getSectionAlignment(DataRefImpl Sec) const {
431 uint64_t Result = 0;
432 llvm_unreachable("Not yet implemented!");
433 return Result;
434 }
435
getSectionFileOffsetToRawData(DataRefImpl Sec) const436 uint64_t XCOFFObjectFile::getSectionFileOffsetToRawData(DataRefImpl Sec) const {
437 if (is64Bit())
438 return toSection64(Sec)->FileOffsetToRawData;
439
440 return toSection32(Sec)->FileOffsetToRawData;
441 }
442
getSectionFileOffsetToRawData(XCOFF::SectionTypeFlags SectType) const443 Expected<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
isSectionCompressed(DataRefImpl Sec) const490 bool XCOFFObjectFile::isSectionCompressed(DataRefImpl Sec) const {
491 return false;
492 }
493
isSectionText(DataRefImpl Sec) const494 bool XCOFFObjectFile::isSectionText(DataRefImpl Sec) const {
495 return getSectionFlags(Sec) & XCOFF::STYP_TEXT;
496 }
497
isSectionData(DataRefImpl Sec) const498 bool XCOFFObjectFile::isSectionData(DataRefImpl Sec) const {
499 uint32_t Flags = getSectionFlags(Sec);
500 return Flags & (XCOFF::STYP_DATA | XCOFF::STYP_TDATA);
501 }
502
isSectionBSS(DataRefImpl Sec) const503 bool XCOFFObjectFile::isSectionBSS(DataRefImpl Sec) const {
504 uint32_t Flags = getSectionFlags(Sec);
505 return Flags & (XCOFF::STYP_BSS | XCOFF::STYP_TBSS);
506 }
507
isDebugSection(DataRefImpl Sec) const508 bool XCOFFObjectFile::isDebugSection(DataRefImpl Sec) const {
509 uint32_t Flags = getSectionFlags(Sec);
510 return Flags & (XCOFF::STYP_DEBUG | XCOFF::STYP_DWARF);
511 }
512
isSectionVirtual(DataRefImpl Sec) const513 bool XCOFFObjectFile::isSectionVirtual(DataRefImpl Sec) const {
514 return is64Bit() ? toSection64(Sec)->FileOffsetToRawData == 0
515 : toSection32(Sec)->FileOffsetToRawData == 0;
516 }
517
section_rel_begin(DataRefImpl Sec) const518 relocation_iterator XCOFFObjectFile::section_rel_begin(DataRefImpl Sec) const {
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));
527 return relocation_iterator(RelocationRef());
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));
537 return relocation_iterator(RelocationRef());
538 }
539 Ret.p = reinterpret_cast<uintptr_t>(&*RelocationsOrErr.get().begin());
540 }
541 return relocation_iterator(RelocationRef(Ret, this));
542 }
543
section_rel_end(DataRefImpl Sec) const544 relocation_iterator XCOFFObjectFile::section_rel_end(DataRefImpl Sec) const {
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));
553 return relocation_iterator(RelocationRef());
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));
563 return relocation_iterator(RelocationRef());
564 }
565 Ret.p = reinterpret_cast<uintptr_t>(&*RelocationsOrErr.get().end());
566 }
567 return relocation_iterator(RelocationRef(Ret, this));
568 }
569
moveRelocationNext(DataRefImpl & Rel) const570 void XCOFFObjectFile::moveRelocationNext(DataRefImpl &Rel) const {
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
getRelocationOffset(DataRefImpl Rel) const577 uint64_t XCOFFObjectFile::getRelocationOffset(DataRefImpl Rel) const {
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
getRelocationSymbol(DataRefImpl Rel) const610 symbol_iterator XCOFFObjectFile::getRelocationSymbol(DataRefImpl Rel) const {
611 uint32_t Index;
612 if (is64Bit()) {
613 const XCOFFRelocation64 *Reloc = viewAs<XCOFFRelocation64>(Rel.p);
614 Index = Reloc->SymbolIndex;
615
616 if (Index >= getNumberOfSymbolTableEntries64())
617 return symbol_end();
618 } else {
619 const XCOFFRelocation32 *Reloc = viewAs<XCOFFRelocation32>(Rel.p);
620 Index = Reloc->SymbolIndex;
621
622 if (Index >= getLogicalNumberOfSymbolTableEntries32())
623 return symbol_end();
624 }
625 DataRefImpl SymDRI;
626 SymDRI.p = getSymbolEntryAddressByIndex(Index);
627 return symbol_iterator(SymbolRef(SymDRI, this));
628 }
629
getRelocationType(DataRefImpl Rel) const630 uint64_t XCOFFObjectFile::getRelocationType(DataRefImpl Rel) const {
631 if (is64Bit())
632 return viewAs<XCOFFRelocation64>(Rel.p)->Type;
633 return viewAs<XCOFFRelocation32>(Rel.p)->Type;
634 }
635
getRelocationTypeName(DataRefImpl Rel,SmallVectorImpl<char> & Result) const636 void XCOFFObjectFile::getRelocationTypeName(
637 DataRefImpl Rel, SmallVectorImpl<char> &Result) const {
638 StringRef Res;
639 if (is64Bit()) {
640 const XCOFFRelocation64 *Reloc = viewAs<XCOFFRelocation64>(Rel.p);
641 Res = XCOFF::getRelocationTypeString(Reloc->Type);
642 } else {
643 const XCOFFRelocation32 *Reloc = viewAs<XCOFFRelocation32>(Rel.p);
644 Res = XCOFF::getRelocationTypeString(Reloc->Type);
645 }
646 Result.append(Res.begin(), Res.end());
647 }
648
getSymbolFlags(DataRefImpl Symb) const649 Expected<uint32_t> XCOFFObjectFile::getSymbolFlags(DataRefImpl Symb) const {
650 XCOFFSymbolRef XCOFFSym = toSymbolRef(Symb);
651 uint32_t Result = SymbolRef::SF_None;
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() ==
678 NEW_XCOFF_INTERPRET))) {
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
symbol_begin() const689 basic_symbol_iterator XCOFFObjectFile::symbol_begin() const {
690 DataRefImpl SymDRI;
691 SymDRI.p = reinterpret_cast<uintptr_t>(SymbolTblPtr);
692 return basic_symbol_iterator(SymbolRef(SymDRI, this));
693 }
694
symbol_end() const695 basic_symbol_iterator XCOFFObjectFile::symbol_end() const {
696 DataRefImpl SymDRI;
697 const uint32_t NumberOfSymbolTableEntries = getNumberOfSymbolTableEntries();
698 SymDRI.p = getSymbolEntryAddressByIndex(NumberOfSymbolTableEntries);
699 return basic_symbol_iterator(SymbolRef(SymDRI, this));
700 }
701
symbols() const702 XCOFFObjectFile::xcoff_symbol_iterator_range XCOFFObjectFile::symbols() const {
703 return xcoff_symbol_iterator_range(symbol_begin(), symbol_end());
704 }
705
section_begin() const706 section_iterator XCOFFObjectFile::section_begin() const {
707 DataRefImpl DRI;
708 DRI.p = getSectionHeaderTableAddress();
709 return section_iterator(SectionRef(DRI, this));
710 }
711
section_end() const712 section_iterator XCOFFObjectFile::section_end() const {
713 DataRefImpl DRI;
714 DRI.p = getWithOffset(getSectionHeaderTableAddress(),
715 getNumberOfSections() * getSectionHeaderSize());
716 return section_iterator(SectionRef(DRI, this));
717 }
718
getBytesInAddress() const719 uint8_t XCOFFObjectFile::getBytesInAddress() const { return is64Bit() ? 8 : 4; }
720
getFileFormatName() const721 StringRef XCOFFObjectFile::getFileFormatName() const {
722 return is64Bit() ? "aix5coff64-rs6000" : "aixcoff-rs6000";
723 }
724
getArch() const725 Triple::ArchType XCOFFObjectFile::getArch() const {
726 return is64Bit() ? Triple::ppc64 : Triple::ppc;
727 }
728
getFeatures() const729 Expected<SubtargetFeatures> XCOFFObjectFile::getFeatures() const {
730 return SubtargetFeatures();
731 }
732
isRelocatableObject() const733 bool XCOFFObjectFile::isRelocatableObject() const {
734 if (is64Bit())
735 return !(fileHeader64()->Flags & NoRelMask);
736 return !(fileHeader32()->Flags & NoRelMask);
737 }
738
getStartAddress() const739 Expected<uint64_t> XCOFFObjectFile::getStartAddress() const {
740 if (AuxiliaryHeader == nullptr)
741 return 0;
742
743 return is64Bit() ? auxiliaryHeader64()->getEntryPointAddr()
744 : auxiliaryHeader32()->getEntryPointAddr();
745 }
746
mapDebugSectionName(StringRef Name) const747 StringRef XCOFFObjectFile::mapDebugSectionName(StringRef Name) const {
748 return StringSwitch<StringRef>(Name)
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
getFileHeaderSize() const763 size_t XCOFFObjectFile::getFileHeaderSize() const {
764 return is64Bit() ? sizeof(XCOFFFileHeader64) : sizeof(XCOFFFileHeader32);
765 }
766
getSectionHeaderSize() const767 size_t XCOFFObjectFile::getSectionHeaderSize() const {
768 return is64Bit() ? sizeof(XCOFFSectionHeader64) :
769 sizeof(XCOFFSectionHeader32);
770 }
771
is64Bit() const772 bool XCOFFObjectFile::is64Bit() const {
773 return Binary::ID_XCOFF64 == getType();
774 }
775
getRawData(const char * Start,uint64_t Size,StringRef Name) const776 Expected<StringRef> XCOFFObjectFile::getRawData(const char *Start,
777 uint64_t Size,
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
getMagic() const789 uint16_t XCOFFObjectFile::getMagic() const {
790 return is64Bit() ? fileHeader64()->Magic : fileHeader32()->Magic;
791 }
792
getSectionByNum(int16_t Num) const793 Expected<DataRefImpl> XCOFFObjectFile::getSectionByNum(int16_t Num) const {
794 if (Num <= 0 || Num > getNumberOfSections())
795 return createStringError(object_error::invalid_section_index,
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
805 DataRefImpl
getSectionByType(XCOFF::SectionTypeFlags SectType) const806 XCOFFObjectFile::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
821 Expected<StringRef>
getSymbolSectionName(XCOFFSymbolRef SymEntPtr) const822 XCOFFObjectFile::getSymbolSectionName(XCOFFSymbolRef SymEntPtr) const {
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)
835 return generateXCOFFFixedNameStringRef(
836 getSectionNameInternal(SecRef.get()));
837 return SecRef.takeError();
838 }
839 }
840
getSymbolSectionID(SymbolRef Sym) const841 unsigned XCOFFObjectFile::getSymbolSectionID(SymbolRef Sym) const {
842 XCOFFSymbolRef XCOFFSymRef(Sym.getRawDataRefImpl(), this);
843 return XCOFFSymRef.getSectionNumber();
844 }
845
isReservedSectionNumber(int16_t SectionNumber)846 bool XCOFFObjectFile::isReservedSectionNumber(int16_t SectionNumber) {
847 return (SectionNumber <= 0 && SectionNumber >= -2);
848 }
849
getNumberOfSections() const850 uint16_t XCOFFObjectFile::getNumberOfSections() const {
851 return is64Bit() ? fileHeader64()->NumberOfSections
852 : fileHeader32()->NumberOfSections;
853 }
854
getTimeStamp() const855 int32_t XCOFFObjectFile::getTimeStamp() const {
856 return is64Bit() ? fileHeader64()->TimeStamp : fileHeader32()->TimeStamp;
857 }
858
getOptionalHeaderSize() const859 uint16_t XCOFFObjectFile::getOptionalHeaderSize() const {
860 return is64Bit() ? fileHeader64()->AuxHeaderSize
861 : fileHeader32()->AuxHeaderSize;
862 }
863
getSymbolTableOffset32() const864 uint32_t XCOFFObjectFile::getSymbolTableOffset32() const {
865 return fileHeader32()->SymbolTableOffset;
866 }
867
getRawNumberOfSymbolTableEntries32() const868 int32_t XCOFFObjectFile::getRawNumberOfSymbolTableEntries32() const {
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.
872 return fileHeader32()->NumberOfSymTableEntries;
873 }
874
getLogicalNumberOfSymbolTableEntries32() const875 uint32_t XCOFFObjectFile::getLogicalNumberOfSymbolTableEntries32() const {
876 return (fileHeader32()->NumberOfSymTableEntries >= 0
877 ? fileHeader32()->NumberOfSymTableEntries
878 : 0);
879 }
880
getSymbolTableOffset64() const881 uint64_t XCOFFObjectFile::getSymbolTableOffset64() const {
882 return fileHeader64()->SymbolTableOffset;
883 }
884
getNumberOfSymbolTableEntries64() const885 uint32_t XCOFFObjectFile::getNumberOfSymbolTableEntries64() const {
886 return fileHeader64()->NumberOfSymTableEntries;
887 }
888
getNumberOfSymbolTableEntries() const889 uint32_t XCOFFObjectFile::getNumberOfSymbolTableEntries() const {
890 return is64Bit() ? getNumberOfSymbolTableEntries64()
891 : getLogicalNumberOfSymbolTableEntries32();
892 }
893
getEndOfSymbolTableAddress() const894 uintptr_t XCOFFObjectFile::getEndOfSymbolTableAddress() const {
895 const uint32_t NumberOfSymTableEntries = getNumberOfSymbolTableEntries();
896 return getWithOffset(reinterpret_cast<uintptr_t>(SymbolTblPtr),
897 XCOFF::SymbolTableEntrySize * NumberOfSymTableEntries);
898 }
899
checkSymbolEntryPointer(uintptr_t SymbolEntPtr) const900 void 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
910 if (Offset % XCOFF::SymbolTableEntrySize != 0)
911 report_fatal_error(
912 "Symbol table entry position is not valid inside of symbol table.");
913 }
914
getSymbolIndex(uintptr_t SymbolEntPtr) const915 uint32_t XCOFFObjectFile::getSymbolIndex(uintptr_t SymbolEntPtr) const {
916 return (reinterpret_cast<const char *>(SymbolEntPtr) -
917 reinterpret_cast<const char *>(SymbolTblPtr)) /
918 XCOFF::SymbolTableEntrySize;
919 }
920
getSymbolSize(DataRefImpl Symb) const921 uint64_t XCOFFObjectFile::getSymbolSize(DataRefImpl Symb) const {
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
getSymbolEntryAddressByIndex(uint32_t Index) const940 uintptr_t XCOFFObjectFile::getSymbolEntryAddressByIndex(uint32_t Index) const {
941 return getAdvancedSymbolEntryAddress(
942 reinterpret_cast<uintptr_t>(getPointerToSymbolTable()), Index);
943 }
944
945 Expected<StringRef>
getSymbolNameByIndex(uint32_t Index) const946 XCOFFObjectFile::getSymbolNameByIndex(uint32_t Index) const {
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;
955 SymDRI.p = getSymbolEntryAddressByIndex(Index);
956 return getSymbolName(SymDRI);
957 }
958
getFlags() const959 uint16_t XCOFFObjectFile::getFlags() const {
960 return is64Bit() ? fileHeader64()->Flags : fileHeader32()->Flags;
961 }
962
getSectionNameInternal(DataRefImpl Sec) const963 const char *XCOFFObjectFile::getSectionNameInternal(DataRefImpl Sec) const {
964 return is64Bit() ? toSection64(Sec)->Name : toSection32(Sec)->Name;
965 }
966
getSectionHeaderTableAddress() const967 uintptr_t XCOFFObjectFile::getSectionHeaderTableAddress() const {
968 return reinterpret_cast<uintptr_t>(SectionHeaderTable);
969 }
970
getSectionFlags(DataRefImpl Sec) const971 int32_t XCOFFObjectFile::getSectionFlags(DataRefImpl Sec) const {
972 return is64Bit() ? toSection64(Sec)->Flags : toSection32(Sec)->Flags;
973 }
974
XCOFFObjectFile(unsigned int Type,MemoryBufferRef Object)975 XCOFFObjectFile::XCOFFObjectFile(unsigned int Type, MemoryBufferRef Object)
976 : ObjectFile(Type, Object) {
977 assert(Type == Binary::ID_XCOFF32 || Type == Binary::ID_XCOFF64);
978 }
979
sections64() const980 ArrayRef<XCOFFSectionHeader64> XCOFFObjectFile::sections64() const {
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
sections32() const987 ArrayRef<XCOFFSectionHeader32> XCOFFObjectFile::sections32() const {
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.
998 template <typename T>
getNumberOfRelocationEntries(const XCOFFSectionHeader<T> & Sec) const999 Expected<uint32_t> XCOFFObjectFile::getNumberOfRelocationEntries(
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 }
1013 return errorCodeToError(object_error::parse_failed);
1014 }
1015
1016 template <typename Shdr, typename Reloc>
relocations(const Shdr & Sec) const1017 Expected<ArrayRef<Reloc>> XCOFFObjectFile::relocations(const Shdr &Sec) const {
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
1043 template <typename ExceptEnt>
getExceptionEntries() const1044 Expected<ArrayRef<ExceptEnt>> XCOFFObjectFile::getExceptionEntries() const {
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
1063 template Expected<ArrayRef<ExceptionSectionEntry32>>
1064 XCOFFObjectFile::getExceptionEntries() const;
1065 template Expected<ArrayRef<ExceptionSectionEntry64>>
1066 XCOFFObjectFile::getExceptionEntries() const;
1067
1068 Expected<XCOFFStringTable>
parseStringTable(const XCOFFObjectFile * Obj,uint64_t Offset)1069 XCOFFObjectFile::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.
1072 if (Error E = Binary::checkOffset(
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.
1079 uint32_t Size = support::endian::read32be(Obj->base() + Offset);
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" +
1092 Twine::utohexstr(Size) +
1093 " goes past the end of the file");
1094
1095 const char *StringTablePtr = StringTableOrErr.get();
1096 if (StringTablePtr[Size - 1] != '\0')
1097 return errorCodeToError(object_error::string_table_non_null_end);
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".
getImportFileTable() const1104 Expected<StringRef> XCOFFObjectFile::getImportFileTable() const {
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
1151 Expected<std::unique_ptr<XCOFFObjectFile>>
create(unsigned Type,MemoryBufferRef MBR)1152 XCOFFObjectFile::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 =
1207 static_cast<uint64_t>(XCOFF::SymbolTableEntrySize) *
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
1230 Expected<std::unique_ptr<ObjectFile>>
createXCOFFObjectFile(MemoryBufferRef MemBufRef,unsigned FileType)1231 ObjectFile::createXCOFFObjectFile(MemoryBufferRef MemBufRef,
1232 unsigned FileType) {
1233 return XCOFFObjectFile::create(FileType, MemBufRef);
1234 }
1235
tryGetCPUName() const1236 std::optional<StringRef> XCOFFObjectFile::tryGetCPUName() const {
1237 return StringRef("future");
1238 }
1239
isFunction() const1240 Expected<bool> XCOFFSymbolRef::isFunction() const {
1241 if (!isCsectSymbol())
1242 return false;
1243
1244 if (getSymbolType() & FunctionSym)
1245 return true;
1246
1247 Expected<XCOFFCsectAuxRef> ExpCsectAuxEnt = getXCOFFCsectAuxRef();
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
isCsectSymbol() const1306 bool XCOFFSymbolRef::isCsectSymbol() const {
1307 XCOFF::StorageClass SC = getStorageClass();
1308 return (SC == XCOFF::C_EXT || SC == XCOFF::C_WEAKEXT ||
1309 SC == XCOFF::C_HIDEXT);
1310 }
1311
getXCOFFCsectAuxRef() const1312 Expected<XCOFFCsectAuxRef> XCOFFSymbolRef::getXCOFFCsectAuxRef() const {
1313 assert(isCsectSymbol() &&
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.
1331 uintptr_t AuxAddr = XCOFFObjectFile::getAdvancedSymbolEntryAddress(
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) {
1339 uintptr_t AuxAddr = XCOFFObjectFile::getAdvancedSymbolEntryAddress(
1340 getEntryAddress(), Index);
1341 if (*getObject()->getSymbolAuxType(AuxAddr) ==
1342 XCOFF::SymbolAuxType::AUX_CSECT) {
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
getName() const1355 Expected<StringRef> XCOFFSymbolRef::getName() const {
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 !=
1363 XCOFFSymbolRef::NAME_IN_STR_TBL_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.
1373 template struct XCOFFSectionHeader<XCOFFSectionHeader32>;
1374 template struct XCOFFSectionHeader<XCOFFSectionHeader64>;
1375
1376 template struct XCOFFRelocation<llvm::support::ubig32_t>;
1377 template struct XCOFFRelocation<llvm::support::ubig64_t>;
1378
1379 template llvm::Expected<llvm::ArrayRef<llvm::object::XCOFFRelocation64>>
1380 llvm::object::XCOFFObjectFile::relocations<llvm::object::XCOFFSectionHeader64,
1381 llvm::object::XCOFFRelocation64>(
1382 llvm::object::XCOFFSectionHeader64 const &) const;
1383 template llvm::Expected<llvm::ArrayRef<llvm::object::XCOFFRelocation32>>
1384 llvm::object::XCOFFObjectFile::relocations<llvm::object::XCOFFSectionHeader32,
1385 llvm::object::XCOFFRelocation32>(
1386 llvm::object::XCOFFSectionHeader32 const &) const;
1387
doesXCOFFTracebackTableBegin(ArrayRef<uint8_t> Bytes)1388 bool doesXCOFFTracebackTableBegin(ArrayRef<uint8_t> Bytes) {
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
create(StringRef TBvectorStrRef)1399 Expected<TBVectorExt> TBVectorExt::create(StringRef TBvectorStrRef) {
1400 Error Err = Error::success();
1401 TBVectorExt TBTVecExt(TBvectorStrRef, Err);
1402 if (Err)
1403 return std::move(Err);
1404 return TBTVecExt;
1405 }
1406
TBVectorExt(StringRef TBvectorStrRef,Error & Err)1407 TBVectorExt::TBVectorExt(StringRef TBvectorStrRef, Error &Err) {
1408 const uint8_t *Ptr = reinterpret_cast<const uint8_t *>(TBvectorStrRef.data());
1409 Data = support::endian::read16be(Ptr);
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
getNumberOfVRSaved() const1423 uint8_t TBVectorExt::getNumberOfVRSaved() const {
1424 return GETVALUEWITHMASKSHIFT(NumberOfVRSavedMask, NumberOfVRSavedShift);
1425 }
1426
isVRSavedOnStack() const1427 bool TBVectorExt::isVRSavedOnStack() const {
1428 return GETVALUEWITHMASK(IsVRSavedOnStackMask);
1429 }
1430
hasVarArgs() const1431 bool TBVectorExt::hasVarArgs() const {
1432 return GETVALUEWITHMASK(HasVarArgsMask);
1433 }
1434
getNumberOfVectorParms() const1435 uint8_t TBVectorExt::getNumberOfVectorParms() const {
1436 return GETVALUEWITHMASKSHIFT(NumberOfVectorParmsMask,
1437 NumberOfVectorParmsShift);
1438 }
1439
hasVMXInstruction() const1440 bool TBVectorExt::hasVMXInstruction() const {
1441 return GETVALUEWITHMASK(HasVMXInstructionMask);
1442 }
1443 #undef GETVALUEWITHMASK
1444 #undef GETVALUEWITHMASKSHIFT
1445
1446 Expected<XCOFFTracebackTable>
create(const uint8_t * Ptr,uint64_t & Size,bool Is64Bit)1447 XCOFFTracebackTable::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
XCOFFTracebackTable(const uint8_t * Ptr,uint64_t & Size,Error & Err,bool Is64Bit)1455 XCOFFTracebackTable::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) {
1483 SmallVector<uint32_t, 8> Disp;
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 =
1522 hasVectorInfo()
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
getVersion() const1555 uint8_t XCOFFTracebackTable::getVersion() const {
1556 return GETBITWITHMASKSHIFT(0, VersionMask, VersionShift);
1557 }
1558
getLanguageID() const1559 uint8_t XCOFFTracebackTable::getLanguageID() const {
1560 return GETBITWITHMASKSHIFT(0, LanguageIdMask, LanguageIdShift);
1561 }
1562
isGlobalLinkage() const1563 bool XCOFFTracebackTable::isGlobalLinkage() const {
1564 return GETBITWITHMASK(0, IsGlobaLinkageMask);
1565 }
1566
isOutOfLineEpilogOrPrologue() const1567 bool XCOFFTracebackTable::isOutOfLineEpilogOrPrologue() const {
1568 return GETBITWITHMASK(0, IsOutOfLineEpilogOrPrologueMask);
1569 }
1570
hasTraceBackTableOffset() const1571 bool XCOFFTracebackTable::hasTraceBackTableOffset() const {
1572 return GETBITWITHMASK(0, HasTraceBackTableOffsetMask);
1573 }
1574
isInternalProcedure() const1575 bool XCOFFTracebackTable::isInternalProcedure() const {
1576 return GETBITWITHMASK(0, IsInternalProcedureMask);
1577 }
1578
hasControlledStorage() const1579 bool XCOFFTracebackTable::hasControlledStorage() const {
1580 return GETBITWITHMASK(0, HasControlledStorageMask);
1581 }
1582
isTOCless() const1583 bool XCOFFTracebackTable::isTOCless() const {
1584 return GETBITWITHMASK(0, IsTOClessMask);
1585 }
1586
isFloatingPointPresent() const1587 bool XCOFFTracebackTable::isFloatingPointPresent() const {
1588 return GETBITWITHMASK(0, IsFloatingPointPresentMask);
1589 }
1590
isFloatingPointOperationLogOrAbortEnabled() const1591 bool XCOFFTracebackTable::isFloatingPointOperationLogOrAbortEnabled() const {
1592 return GETBITWITHMASK(0, IsFloatingPointOperationLogOrAbortEnabledMask);
1593 }
1594
isInterruptHandler() const1595 bool XCOFFTracebackTable::isInterruptHandler() const {
1596 return GETBITWITHMASK(0, IsInterruptHandlerMask);
1597 }
1598
isFuncNamePresent() const1599 bool XCOFFTracebackTable::isFuncNamePresent() const {
1600 return GETBITWITHMASK(0, IsFunctionNamePresentMask);
1601 }
1602
isAllocaUsed() const1603 bool XCOFFTracebackTable::isAllocaUsed() const {
1604 return GETBITWITHMASK(0, IsAllocaUsedMask);
1605 }
1606
getOnConditionDirective() const1607 uint8_t XCOFFTracebackTable::getOnConditionDirective() const {
1608 return GETBITWITHMASKSHIFT(0, OnConditionDirectiveMask,
1609 OnConditionDirectiveShift);
1610 }
1611
isCRSaved() const1612 bool XCOFFTracebackTable::isCRSaved() const {
1613 return GETBITWITHMASK(0, IsCRSavedMask);
1614 }
1615
isLRSaved() const1616 bool XCOFFTracebackTable::isLRSaved() const {
1617 return GETBITWITHMASK(0, IsLRSavedMask);
1618 }
1619
isBackChainStored() const1620 bool XCOFFTracebackTable::isBackChainStored() const {
1621 return GETBITWITHMASK(4, IsBackChainStoredMask);
1622 }
1623
isFixup() const1624 bool XCOFFTracebackTable::isFixup() const {
1625 return GETBITWITHMASK(4, IsFixupMask);
1626 }
1627
getNumOfFPRsSaved() const1628 uint8_t XCOFFTracebackTable::getNumOfFPRsSaved() const {
1629 return GETBITWITHMASKSHIFT(4, FPRSavedMask, FPRSavedShift);
1630 }
1631
hasExtensionTable() const1632 bool XCOFFTracebackTable::hasExtensionTable() const {
1633 return GETBITWITHMASK(4, HasExtensionTableMask);
1634 }
1635
hasVectorInfo() const1636 bool XCOFFTracebackTable::hasVectorInfo() const {
1637 return GETBITWITHMASK(4, HasVectorInfoMask);
1638 }
1639
getNumOfGPRsSaved() const1640 uint8_t XCOFFTracebackTable::getNumOfGPRsSaved() const {
1641 return GETBITWITHMASKSHIFT(4, GPRSavedMask, GPRSavedShift);
1642 }
1643
getNumberOfFixedParms() const1644 uint8_t XCOFFTracebackTable::getNumberOfFixedParms() const {
1645 return GETBITWITHMASKSHIFT(4, NumberOfFixedParmsMask,
1646 NumberOfFixedParmsShift);
1647 }
1648
getNumberOfFPParms() const1649 uint8_t XCOFFTracebackTable::getNumberOfFPParms() const {
1650 return GETBITWITHMASKSHIFT(4, NumberOfFloatingPointParmsMask,
1651 NumberOfFloatingPointParmsShift);
1652 }
1653
hasParmsOnStack() const1654 bool XCOFFTracebackTable::hasParmsOnStack() const {
1655 return GETBITWITHMASK(4, HasParmsOnStackMask);
1656 }
1657
1658 #undef GETBITWITHMASK
1659 #undef GETBITWITHMASKSHIFT
1660 } // namespace object
1661 } // namespace llvm
1662