22 using namespace XCOFF;
35 uintptr_t
Addr =
reinterpret_cast<uintptr_t
>(Ptr);
38 return reinterpret_cast<const T *
>(
Addr);
42 return reinterpret_cast<uintptr_t
>(
reinterpret_cast<const char *
>(
Base) +
46 template <
typename T>
static const T *
viewAs(uintptr_t
in) {
47 return reinterpret_cast<const T *
>(
in);
58 const T &DerivedXCOFFSectionHeader =
static_cast<const T &
>(*this);
63 const T &DerivedXCOFFSectionHeader =
static_cast<const T &
>(*this);
64 return DerivedXCOFFSectionHeader.Flags & SectionFlagsTypeMask;
69 return getSectionType() & SectionFlagsReservedMask;
72 template <
typename AddressType>
74 return Info & XR_SIGN_INDICATOR_MASK;
77 template <
typename AddressType>
79 return Info & XR_FIXUP_INDICATOR_MASK;
82 template <
typename AddressType>
86 return (
Info & XR_BIASED_LENGTH_MASK) + 1;
90 XCOFFObjectFile::getAdvancedSymbolEntryAddress(uintptr_t CurrentAddress,
96 XCOFFObjectFile::getSymbolAuxType(uintptr_t AuxEntryAddress)
const {
97 assert(
is64Bit() &&
"64-bit interface called on a 32-bit object file.");
98 return viewAs<XCOFF::SymbolAuxType>(
102 void XCOFFObjectFile::checkSectionAddress(uintptr_t
Addr,
103 uintptr_t TableAddress)
const {
104 if (
Addr < TableAddress)
107 uintptr_t Offset =
Addr - TableAddress;
108 if (Offset >= getSectionHeaderSize() * getNumberOfSections())
111 if (Offset % getSectionHeaderSize() != 0)
113 "Section header pointer does not point to a valid section header.");
116 const XCOFFSectionHeader32 *
117 XCOFFObjectFile::toSection32(DataRefImpl Ref)
const {
118 assert(!
is64Bit() &&
"32-bit interface called on 64-bit object file.");
120 checkSectionAddress(
Ref.p, getSectionHeaderTableAddress());
122 return viewAs<XCOFFSectionHeader32>(
Ref.p);
125 const XCOFFSectionHeader64 *
126 XCOFFObjectFile::toSection64(DataRefImpl Ref)
const {
127 assert(
is64Bit() &&
"64-bit interface called on a 32-bit object file.");
129 checkSectionAddress(Ref.p, getSectionHeaderTableAddress());
131 return viewAs<XCOFFSectionHeader64>(Ref.p);
135 assert(
Ref.p != 0 &&
"Symbol table pointer can not be nullptr!");
137 checkSymbolEntryPointer(
Ref.p);
143 assert(!
is64Bit() &&
"32-bit interface called on 64-bit object file.");
148 assert(
is64Bit() &&
"64-bit interface called on a 32-bit object file.");
153 assert(!
is64Bit() &&
"32-bit interface called on 64-bit object file.");
158 assert(
is64Bit() &&
"64-bit interface called on a 32-bit object file.");
162 template <
typename T>
const T *XCOFFObjectFile::sectionHeaderTable()
const {
163 return static_cast<const T *
>(SectionHeaderTable);
166 const XCOFFSectionHeader32 *
167 XCOFFObjectFile::sectionHeaderTable32()
const {
168 assert(!
is64Bit() &&
"32-bit interface called on 64-bit object file.");
169 return static_cast<const XCOFFSectionHeader32 *
>(SectionHeaderTable);
172 const XCOFFSectionHeader64 *
173 XCOFFObjectFile::sectionHeaderTable64()
const {
174 assert(
is64Bit() &&
"64-bit interface called on a 32-bit object file.");
175 return static_cast<const XCOFFSectionHeader64 *
>(SectionHeaderTable);
179 uintptr_t NextSymbolAddr = getAdvancedSymbolEntryAddress(
180 Symb.
p, toSymbolRef(Symb).getNumberOfAuxEntries() + 1);
184 if (NextSymbolAddr != getEndOfSymbolTableAddress())
185 checkSymbolEntryPointer(NextSymbolAddr);
187 Symb.
p = NextSymbolAddr;
191 XCOFFObjectFile::getStringTableEntry(
uint32_t Offset)
const {
200 if (StringTable.Data !=
nullptr && StringTable.Size > Offset)
201 return (StringTable.Data + Offset);
204 " in a string table with size 0x" +
212 StringTable.Size <= 4 ? 0 : StringTable.Size);
223 return toSymbolRef(Symb).getName();
227 return toSymbolRef(Symb).getValue();
231 return toSymbolRef(Symb).getValue();
240 if (!CsectAuxRefOrError)
244 Result = 1ULL << CsectAuxRefOrError.
get().getAlignmentLog2();
255 if (!CsectAuxRefOrError)
272 return SymbolRef::ST_Function;
275 return SymbolRef::ST_File;
279 return SymbolRef::ST_Other;
290 if (SymNameOrError) {
292 if (SymNameOrError.
get() ==
"TOC")
293 return SymbolRef::ST_Other;
298 SecName = XCOFFObjectFile::toSection64(SecDRIOrErr.
get())->getName();
300 SecName = XCOFFObjectFile::toSection32(SecDRIOrErr.
get())->getName();
302 if (SecName == SymNameOrError.
get())
303 return SymbolRef::ST_Other;
307 if (isSectionData(SecDRI) || isSectionBSS(SecDRI))
308 return SymbolRef::ST_Data;
311 return SymbolRef::ST_Debug;
313 return SymbolRef::ST_Other;
318 const int16_t SectNum = toSymbolRef(Symb).getSectionNumber();
321 return section_end();
331 const char *Ptr =
reinterpret_cast<const char *
>(Sec.
p);
332 Sec.
p =
reinterpret_cast<uintptr_t
>(Ptr + getSectionHeaderSize());
343 return toSection64(Sec)->VirtualAddress;
345 return toSection32(Sec)->VirtualAddress;
352 return toSection64(Sec) - sectionHeaderTable64() + 1;
354 return toSection32(Sec) - sectionHeaderTable32() + 1;
361 return toSection64(Sec)->SectionSize;
363 return toSection32(Sec)->SectionSize;
368 if (isSectionVirtual(Sec))
373 OffsetToRaw = toSection64(Sec)->FileOffsetToRawData;
375 OffsetToRaw = toSection32(Sec)->FileOffsetToRawData;
377 const uint8_t * ContentStart =
base() + OffsetToRaw;
379 if (
Error E = Binary::checkOffset(
400 for (
const auto &Sec64 : sections64())
402 OffsetToLoaderSection = Sec64.FileOffsetToRawData;
403 SizeOfLoaderSection = Sec64.SectionSize;
407 for (
const auto &Sec32 : sections32())
409 OffsetToLoaderSection = Sec32.FileOffsetToRawData;
410 SizeOfLoaderSection = Sec32.SectionSize;
416 if (!SizeOfLoaderSection)
419 uintptr_t LoderSectionStart =
420 reinterpret_cast<uintptr_t
>(
base() + OffsetToLoaderSection);
422 Binary::checkOffset(Data, LoderSectionStart, SizeOfLoaderSection))
424 ": loader section with offset 0x" +
427 " goes past the end of the file");
429 return LoderSectionStart;
432 bool XCOFFObjectFile::isSectionCompressed(
DataRefImpl Sec)
const {
456 return is64Bit() ? toSection64(Sec)->FileOffsetToRawData == 0
457 : toSection32(Sec)->FileOffsetToRawData == 0;
464 auto RelocationsOrErr =
465 relocations<XCOFFSectionHeader64, XCOFFRelocation64>(*SectionEntPtr);
466 if (
Error E = RelocationsOrErr.takeError()) {
471 Ret.p =
reinterpret_cast<uintptr_t
>(&*RelocationsOrErr.get().begin());
474 auto RelocationsOrErr =
475 relocations<XCOFFSectionHeader32, XCOFFRelocation32>(*SectionEntPtr);
476 if (
Error E = RelocationsOrErr.takeError()) {
481 Ret.p =
reinterpret_cast<uintptr_t
>(&*RelocationsOrErr.get().begin());
490 auto RelocationsOrErr =
491 relocations<XCOFFSectionHeader64, XCOFFRelocation64>(*SectionEntPtr);
492 if (
Error E = RelocationsOrErr.takeError()) {
497 Ret.p =
reinterpret_cast<uintptr_t
>(&*RelocationsOrErr.get().end());
500 auto RelocationsOrErr =
501 relocations<XCOFFSectionHeader32, XCOFFRelocation32>(*SectionEntPtr);
502 if (
Error E = RelocationsOrErr.takeError()) {
507 Ret.p =
reinterpret_cast<uintptr_t
>(&*RelocationsOrErr.get().end());
512 void XCOFFObjectFile::moveRelocationNext(
DataRefImpl &Rel)
const {
514 Rel.
p =
reinterpret_cast<uintptr_t
>(viewAs<XCOFFRelocation64>(Rel.
p) + 1);
516 Rel.
p =
reinterpret_cast<uintptr_t
>(viewAs<XCOFFRelocation32>(Rel.
p) + 1);
524 const uint16_t NumberOfSections = getNumberOfSections();
529 RelocAddress < Sec64->VirtualAddress + Sec64->
SectionSize) {
538 const uint16_t NumberOfSections = getNumberOfSections();
543 RelocAddress < Sec32->VirtualAddress + Sec32->
SectionSize) {
549 return InvalidRelocOffset;
558 if (Index >= getNumberOfSymbolTableEntries64())
564 if (Index >= getLogicalNumberOfSymbolTableEntries32())
568 SymDRI.
p = getSymbolEntryAddressByIndex(Index);
574 return viewAs<XCOFFRelocation64>(Rel.
p)->Type;
575 return viewAs<XCOFFRelocation32>(Rel.
p)->Type;
578 void XCOFFObjectFile::getRelocationTypeName(
588 Result.append(Res.
begin(), Res.
end());
593 uint32_t Result = SymbolRef::SF_None;
596 Result |= SymbolRef::SF_Absolute;
600 Result |= SymbolRef::SF_Global;
603 Result |= SymbolRef::SF_Weak;
608 if (CsectAuxEntOrErr) {
610 Result |= SymbolRef::SF_Common;
616 Result |= SymbolRef::SF_Undefined;
619 if (
is64Bit() || (auxiliaryHeader32() && (auxiliaryHeader32()->getVersion() ==
623 Result |= SymbolRef::SF_Hidden;
626 Result |= SymbolRef::SF_Exported;
633 SymDRI.
p =
reinterpret_cast<uintptr_t
>(SymbolTblPtr);
639 const uint32_t NumberOfSymbolTableEntries = getNumberOfSymbolTableEntries();
640 SymDRI.
p = getSymbolEntryAddressByIndex(NumberOfSymbolTableEntries);
646 DRI.
p = getSectionHeaderTableAddress();
653 getNumberOfSections() * getSectionHeaderSize());
657 uint8_t XCOFFObjectFile::getBytesInAddress()
const {
return is64Bit() ? 8 : 4; }
660 return is64Bit() ?
"aix5coff64-rs6000" :
"aixcoff-rs6000";
671 bool XCOFFObjectFile::isRelocatableObject()
const {
673 return !(fileHeader64()->Flags &
NoRelMask);
674 return !(fileHeader32()->Flags &
NoRelMask);
685 .
Case(
"dwinfo",
"debug_info")
686 .
Case(
"dwline",
"debug_line")
687 .
Case(
"dwpbnms",
"debug_pubnames")
688 .
Case(
"dwpbtyp",
"debug_pubtypes")
689 .
Case(
"dwarnge",
"debug_aranges")
690 .
Case(
"dwabrev",
"debug_abbrev")
691 .
Case(
"dwstr",
"debug_str")
692 .
Case(
"dwrnges",
"debug_ranges")
693 .
Case(
"dwloc",
"debug_loc")
694 .
Case(
"dwframe",
"debug_frame")
695 .
Case(
"dwmac",
"debug_macinfo")
699 size_t XCOFFObjectFile::getFileHeaderSize()
const {
703 size_t XCOFFObjectFile::getSectionHeaderSize()
const {
704 return is64Bit() ?
sizeof(XCOFFSectionHeader64) :
705 sizeof(XCOFFSectionHeader32);
709 return Binary::ID_XCOFF64 ==
getType();
715 uintptr_t StartPtr =
reinterpret_cast<uintptr_t
>(Start);
717 if (
Error E = Binary::checkOffset(
Data, StartPtr, Size))
721 " goes past the end of the file");
726 return is64Bit() ? fileHeader64()->Magic : fileHeader32()->Magic;
730 if (Num <= 0 || Num > getNumberOfSections())
732 "the section index (" +
Twine(Num) +
737 getSectionHeaderSize() * (Num - 1));
745 switch (SectionNum) {
756 getSectionNameInternal(SecRef.
get()));
767 return (SectionNumber <= 0 && SectionNumber >= -2);
770 uint16_t XCOFFObjectFile::getNumberOfSections()
const {
771 return is64Bit() ? fileHeader64()->NumberOfSections
772 : fileHeader32()->NumberOfSections;
775 int32_t XCOFFObjectFile::getTimeStamp()
const {
776 return is64Bit() ? fileHeader64()->TimeStamp : fileHeader32()->TimeStamp;
779 uint16_t XCOFFObjectFile::getOptionalHeaderSize()
const {
780 return is64Bit() ? fileHeader64()->AuxHeaderSize
781 : fileHeader32()->AuxHeaderSize;
784 uint32_t XCOFFObjectFile::getSymbolTableOffset32()
const {
785 return fileHeader32()->SymbolTableOffset;
788 int32_t XCOFFObjectFile::getRawNumberOfSymbolTableEntries32()
const {
792 return fileHeader32()->NumberOfSymTableEntries;
795 uint32_t XCOFFObjectFile::getLogicalNumberOfSymbolTableEntries32()
const {
796 return (fileHeader32()->NumberOfSymTableEntries >= 0
797 ? fileHeader32()->NumberOfSymTableEntries
801 uint64_t XCOFFObjectFile::getSymbolTableOffset64()
const {
802 return fileHeader64()->SymbolTableOffset;
805 uint32_t XCOFFObjectFile::getNumberOfSymbolTableEntries64()
const {
806 return fileHeader64()->NumberOfSymTableEntries;
809 uint32_t XCOFFObjectFile::getNumberOfSymbolTableEntries()
const {
810 return is64Bit() ? getNumberOfSymbolTableEntries64()
811 : getLogicalNumberOfSymbolTableEntries32();
814 uintptr_t XCOFFObjectFile::getEndOfSymbolTableAddress()
const {
815 const uint32_t NumberOfSymTableEntries = getNumberOfSymbolTableEntries();
816 return getWithOffset(
reinterpret_cast<uintptr_t
>(SymbolTblPtr),
820 void XCOFFObjectFile::checkSymbolEntryPointer(uintptr_t SymbolEntPtr)
const {
821 if (SymbolEntPtr <
reinterpret_cast<uintptr_t
>(SymbolTblPtr))
824 if (SymbolEntPtr >= getEndOfSymbolTableAddress())
827 ptrdiff_t Offset =
reinterpret_cast<const char *
>(SymbolEntPtr) -
828 reinterpret_cast<const char *
>(SymbolTblPtr);
832 "Symbol table entry position is not valid inside of symbol table.");
835 uint32_t XCOFFObjectFile::getSymbolIndex(uintptr_t SymbolEntPtr)
const {
836 return (
reinterpret_cast<const char *
>(SymbolEntPtr) -
837 reinterpret_cast<const char *
>(SymbolTblPtr)) /
847 if (!CsectAuxRefOrError)
860 uintptr_t XCOFFObjectFile::getSymbolEntryAddressByIndex(
uint32_t Index)
const {
861 return getAdvancedSymbolEntryAddress(
862 reinterpret_cast<uintptr_t
>(getPointerToSymbolTable()), Index);
866 XCOFFObjectFile::getSymbolNameByIndex(
uint32_t Index)
const {
867 const uint32_t NumberOfSymTableEntries = getNumberOfSymbolTableEntries();
869 if (Index >= NumberOfSymTableEntries)
871 " exceeds symbol count " +
872 Twine(NumberOfSymTableEntries));
875 SymDRI.
p = getSymbolEntryAddressByIndex(Index);
880 return is64Bit() ? fileHeader64()->Flags : fileHeader32()->Flags;
883 const char *XCOFFObjectFile::getSectionNameInternal(
DataRefImpl Sec)
const {
884 return is64Bit() ? toSection64(Sec)->Name : toSection32(Sec)->Name;
887 uintptr_t XCOFFObjectFile::getSectionHeaderTableAddress()
const {
888 return reinterpret_cast<uintptr_t
>(SectionHeaderTable);
892 return is64Bit() ? toSection64(Sec)->Flags : toSection32(Sec)->Flags;
901 assert(
is64Bit() &&
"64-bit interface called for non 64-bit file.");
908 assert(!
is64Bit() &&
"32-bit interface called for non 32-bit file.");
918 template <
typename T>
921 const T &Section =
static_cast<const T &
>(Sec);
923 return Section.NumberOfRelocations;
925 uint16_t SectionIndex = &Section - sectionHeaderTable<T>() + 1;
927 return Section.NumberOfRelocations;
930 Sec.NumberOfRelocations == SectionIndex)
931 return Sec.PhysicalAddress;
936 template <
typename Shdr,
typename Reloc>
938 uintptr_t RelocAddr =
getWithOffset(
reinterpret_cast<uintptr_t
>(FileHeader),
939 Sec.FileOffsetToRelocationInfo);
941 if (
Error E = NumRelocEntriesOrErr.takeError())
944 uint32_t NumRelocEntries = NumRelocEntriesOrErr.get();
947 "Relocation structure is incorrect");
948 auto RelocationOrErr =
949 getObject<Reloc>(
Data,
reinterpret_cast<void *
>(RelocAddr),
950 NumRelocEntries *
sizeof(Reloc));
951 if (!RelocationOrErr)
953 toString(RelocationOrErr.takeError()) +
": relocations with offset 0x" +
956 " go past the end of the file");
958 const Reloc *StartReloc = RelocationOrErr.get();
968 Obj->
Data,
reinterpret_cast<uintptr_t
>(Obj->
base() + Offset), 4)) {
979 return XCOFFStringTable{4,
nullptr};
981 auto StringTableOrErr =
982 getObject<char>(Obj->
Data, Obj->
base() + Offset, Size);
983 if (!StringTableOrErr)
985 ": string table with offset 0x" +
988 " goes past the end of the file");
990 const char *StringTablePtr = StringTableOrErr.get();
991 if (StringTablePtr[Size - 1] !=
'\0')
994 return XCOFFStringTable{
Size, StringTablePtr};
1001 if (!LoaderSectionAddrOrError)
1002 return LoaderSectionAddrOrError.
takeError();
1004 uintptr_t LoaderSectionAddr = LoaderSectionAddrOrError.
get();
1005 if (!LoaderSectionAddr)
1008 uint64_t OffsetToImportFileTable = 0;
1009 uint64_t LengthOfImportFileTable = 0;
1012 viewAs<LoaderSectionHeader64>(LoaderSectionAddr);
1017 viewAs<LoaderSectionHeader32>(LoaderSectionAddr);
1022 auto ImportTableOrErr = getObject<char>(
1024 reinterpret_cast<void *
>(LoaderSectionAddr + OffsetToImportFileTable),
1025 LengthOfImportFileTable);
1026 if (!ImportTableOrErr)
1028 toString(ImportTableOrErr.takeError()) +
1029 ": import file table with offset 0x" +
1032 " goes past the end of the file");
1034 const char *ImportTablePtr = ImportTableOrErr.get();
1035 if (ImportTablePtr[LengthOfImportFileTable - 1] !=
'\0')
1037 ": import file name table with offset 0x" +
1040 " must end with a null terminator");
1042 return StringRef(ImportTablePtr, LengthOfImportFileTable);
1048 std::unique_ptr<XCOFFObjectFile> Obj;
1052 const auto *
Base = Obj->base();
1056 auto FileHeaderOrErr =
1057 getObject<void>(
Data,
Base + CurOffset, Obj->getFileHeaderSize());
1058 if (
Error E = FileHeaderOrErr.takeError())
1060 Obj->FileHeader = FileHeaderOrErr.get();
1062 CurOffset += Obj->getFileHeaderSize();
1064 if (Obj->getOptionalHeaderSize()) {
1065 auto AuxiliaryHeaderOrErr =
1066 getObject<void>(
Data,
Base + CurOffset, Obj->getOptionalHeaderSize());
1067 if (
Error E = AuxiliaryHeaderOrErr.takeError())
1069 Obj->AuxiliaryHeader = AuxiliaryHeaderOrErr.get();
1072 CurOffset += Obj->getOptionalHeaderSize();
1075 if (Obj->getNumberOfSections()) {
1077 Obj->getNumberOfSections() * Obj->getSectionHeaderSize();
1078 auto SecHeadersOrErr =
1079 getObject<void>(
Data,
Base + CurOffset, SectionHeadersSize);
1080 if (!SecHeadersOrErr)
1082 ": section headers with offset 0x" +
1085 " go past the end of the file");
1087 Obj->SectionHeaderTable = SecHeadersOrErr.get();
1090 const uint32_t NumberOfSymbolTableEntries =
1091 Obj->getNumberOfSymbolTableEntries();
1094 if (NumberOfSymbolTableEntries == 0)
1098 CurOffset = Obj->is64Bit() ? Obj->getSymbolTableOffset64()
1099 : Obj->getSymbolTableOffset32();
1102 NumberOfSymbolTableEntries;
1103 auto SymTableOrErr =
1104 getObject<void *>(
Data,
Base + CurOffset, SymbolTableSize);
1107 toString(SymTableOrErr.takeError()) +
": symbol table with offset 0x" +
1111 Obj->SymbolTblPtr = SymTableOrErr.get();
1112 CurOffset += SymbolTableSize;
1115 Expected<XCOFFStringTable> StringTableOrErr =
1116 parseStringTable(Obj.get(), CurOffset);
1117 if (Error
E = StringTableOrErr.takeError())
1119 Obj->StringTable = StringTableOrErr.get();
1124 Expected<std::unique_ptr<ObjectFile>>
1127 return XCOFFObjectFile::create(
FileType, MemBufRef);
1138 if (!ExpCsectAuxEnt) {
1176 "Calling csect symbol interface with a non-csect symbol.");
1185 if (!NumberOfAuxEntries) {
1186 return createError(
"csect symbol \"" + *NameOrErr +
"\" with index " +
1187 Twine(SymbolIdx) +
" contains no auxiliary entry");
1190 if (!OwningObjectPtr->
is64Bit()) {
1200 for (uint8_t Index = NumberOfAuxEntries; Index > 0; --Index) {
1213 "a csect auxiliary entry has not been found for symbol \"" + *NameOrErr +
1214 "\" with index " +
Twine(SymbolIdx));
1221 return StringRef(
"Unimplemented Debug Name");
1250 if (Bytes.
size() < 4)
1256 #define GETVALUEWITHMASK(X) (Data & (TracebackTable::X))
1257 #define GETVALUEWITHMASKSHIFT(X, S) \
1258 ((Data & (TracebackTable::X)) >> (TracebackTable::S))
1269 const uint8_t *Ptr =
reinterpret_cast<const uint8_t *
>(TBvectorStrRef.
data());
1278 if (!VecParmsTypeOrError)
1281 VecParmsInfo = VecParmsTypeOrError.
get();
1298 NumberOfVectorParmsShift);
1304 #undef GETVALUEWITHMASK
1305 #undef GETVALUEWITHMASKSHIFT
1316 XCOFFTracebackTable::XCOFFTracebackTable(
const uint8_t *Ptr,
uint64_t &Size,
1332 if (Cur && (FixedParmsNum + FloatingParmsNum) > 0)
1333 ParamsTypeValue = DE.getU32(Cur);
1336 TraceBackTableOffset = DE.getU32(Cur);
1339 HandlerMask = DE.getU32(Cur);
1342 NumOfCtlAnchors = DE.getU32(Cur);
1343 if (Cur && NumOfCtlAnchors) {
1346 for (
uint32_t I = 0;
I < NumOfCtlAnchors && Cur; ++
I)
1347 Disp.push_back(DE.getU32(Cur));
1349 ControlledStorageInfoDisp =
std::move(Disp);
1354 uint16_t FunctionNameLen = DE.getU16(Cur);
1356 FunctionName = DE.getBytes(Cur, FunctionNameLen);
1360 AllocaRegister = DE.getU8(Cur);
1362 unsigned VectorParmsNum = 0;
1364 StringRef VectorExtRef = DE.getBytes(Cur, 6);
1367 if (!TBVecExtOrErr) {
1368 Err = TBVecExtOrErr.takeError();
1371 VecExt = TBVecExtOrErr.get();
1372 VectorParmsNum = VecExt.getValue().getNumberOfVectorParms();
1379 if (Cur && (FixedParmsNum + FloatingParmsNum) > 0) {
1380 Expected<SmallString<32>> ParmsTypeOrError =
1383 FloatingParmsNum, VectorParmsNum)
1384 :
parseParmsType(ParamsTypeValue, FixedParmsNum, FloatingParmsNum);
1386 if (!ParmsTypeOrError) {
1387 Err = ParmsTypeOrError.takeError();
1390 ParmsType = ParmsTypeOrError.get();
1394 ExtensionTable = DE.getU8(Cur);
1397 Err = Cur.takeError();
1402 #define GETBITWITHMASK(P, X) \
1403 (support::endian::read32be(TBPtr + (P)) & (TracebackTable::X))
1404 #define GETBITWITHMASKSHIFT(P, X, S) \
1405 ((support::endian::read32be(TBPtr + (P)) & (TracebackTable::X)) >> \
1406 (TracebackTable::S))
1445 return GETBITWITHMASK(0, IsFloatingPointOperationLogOrAbortEnabledMask);
1462 OnConditionDirectiveShift);
1499 NumberOfFixedParmsShift);
1504 NumberOfFloatingPointParmsShift);
1511 #undef GETBITWITHMASK
1512 #undef GETBITWITHMASKSHIFT