| //===-- XCOFFDump.cpp - XCOFF-specific dumper -----------------------------===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| /// |
| /// \file |
| /// This file implements the XCOFF-specific dumper for llvm-objdump. |
| /// |
| //===----------------------------------------------------------------------===// |
| |
| #include "XCOFFDump.h" |
| |
| #include "llvm-objdump.h" |
| #include "llvm/ADT/StringExtras.h" |
| #include "llvm/Demangle/Demangle.h" |
| #include "llvm/MC/MCInstPrinter.h" |
| #include "llvm/MC/MCSubtargetInfo.h" |
| #include "llvm/Support/Endian.h" |
| #include "llvm/Support/Format.h" |
| #include "llvm/Support/FormattedStream.h" |
| #include "llvm/Support/raw_ostream.h" |
| #include <algorithm> |
| |
| using namespace llvm; |
| using namespace llvm::object; |
| using namespace llvm::XCOFF; |
| using namespace llvm::support; |
| |
| namespace { |
| class XCOFFDumper : public objdump::Dumper { |
| enum PrintStyle { Hex, Number }; |
| const XCOFFObjectFile &Obj; |
| unsigned Width; |
| |
| public: |
| XCOFFDumper(const object::XCOFFObjectFile &O) : Dumper(O), Obj(O) {} |
| |
| private: |
| void printPrivateHeaders() override; |
| void printFileHeader(); |
| void printAuxiliaryHeader(); |
| void printLoaderSectionHeader(); |
| void printAuxiliaryHeader(const XCOFFAuxiliaryHeader32 *AuxHeader); |
| void printAuxiliaryHeader(const XCOFFAuxiliaryHeader64 *AuxHeader); |
| template <typename AuxHeaderMemberType, typename XCOFFAuxiliaryHeader> |
| void printAuxMemberHelper(PrintStyle Style, const char *MemberName, |
| const AuxHeaderMemberType &Member, |
| const XCOFFAuxiliaryHeader *AuxHeader, |
| uint16_t AuxSize, uint16_t &PartialFieldOffset, |
| const char *&PartialFieldName); |
| template <typename XCOFFAuxiliaryHeader> |
| void checkAndPrintAuxHeaderParseError(const char *PartialFieldName, |
| uint16_t PartialFieldOffset, |
| uint16_t AuxSize, |
| XCOFFAuxiliaryHeader &AuxHeader); |
| |
| void printBinary(StringRef Name, ArrayRef<uint8_t> Data); |
| void printHex(StringRef Name, uint64_t Value); |
| void printNumber(StringRef Name, uint64_t Value); |
| FormattedString formatName(StringRef Name); |
| void printStrHex(StringRef Name, StringRef Str, uint64_t Value); |
| }; |
| |
| void XCOFFDumper::printPrivateHeaders() { |
| printFileHeader(); |
| printAuxiliaryHeader(); |
| printLoaderSectionHeader(); |
| } |
| |
| FormattedString XCOFFDumper::formatName(StringRef Name) { |
| return FormattedString(Name, Width, FormattedString::JustifyLeft); |
| } |
| |
| void XCOFFDumper::printHex(StringRef Name, uint64_t Value) { |
| outs() << formatName(Name) << format_hex(Value, 0) << "\n"; |
| } |
| |
| void XCOFFDumper::printNumber(StringRef Name, uint64_t Value) { |
| outs() << formatName(Name) << format_decimal(Value, 0) << "\n"; |
| } |
| |
| void XCOFFDumper::printStrHex(StringRef Name, StringRef Str, uint64_t Value) { |
| outs() << formatName(Name) << Str << " (" << format_decimal(Value, 0) |
| << ")\n"; |
| } |
| |
| void XCOFFDumper::printBinary(StringRef Name, ArrayRef<uint8_t> Data) { |
| unsigned OrgWidth = Width; |
| Width = 0; |
| outs() << formatName(Name) << " (" << format_bytes(Data) << ")\n"; |
| Width = OrgWidth; |
| } |
| |
| void XCOFFDumper::printAuxiliaryHeader() { |
| Width = 36; |
| if (Obj.is64Bit()) |
| printAuxiliaryHeader(Obj.auxiliaryHeader64()); |
| else |
| printAuxiliaryHeader(Obj.auxiliaryHeader32()); |
| } |
| |
| template <typename AuxHeaderMemberType, typename XCOFFAuxiliaryHeader> |
| void XCOFFDumper::printAuxMemberHelper(PrintStyle Style, const char *MemberName, |
| const AuxHeaderMemberType &Member, |
| const XCOFFAuxiliaryHeader *AuxHeader, |
| uint16_t AuxSize, |
| uint16_t &PartialFieldOffset, |
| const char *&PartialFieldName) { |
| ptrdiff_t Offset = reinterpret_cast<const char *>(&Member) - |
| reinterpret_cast<const char *>(AuxHeader); |
| if (Offset + sizeof(Member) <= AuxSize) { |
| if (Style == Hex) |
| printHex(MemberName, Member); |
| else |
| printNumber(MemberName, Member); |
| } else if (Offset < AuxSize) { |
| PartialFieldOffset = Offset; |
| PartialFieldName = MemberName; |
| } |
| } |
| |
| template <typename XCOFFAuxiliaryHeader> |
| void XCOFFDumper::checkAndPrintAuxHeaderParseError( |
| const char *PartialFieldName, uint16_t PartialFieldOffset, uint16_t AuxSize, |
| XCOFFAuxiliaryHeader &AuxHeader) { |
| if (PartialFieldOffset < AuxSize) { |
| std::string Buf; |
| raw_string_ostream OS(Buf); |
| OS.flush(); |
| OS << FormattedString("Raw data", 0, FormattedString::JustifyLeft) << " (" |
| << format_bytes( |
| ArrayRef<uint8_t>(reinterpret_cast<const uint8_t *>(&AuxHeader) + |
| PartialFieldOffset, |
| AuxSize - PartialFieldOffset)) |
| << ")\n"; |
| reportUniqueWarning(Twine("only partial field for ") + PartialFieldName + |
| " at offset (" + Twine(PartialFieldOffset) + ")\n" + |
| OS.str()); |
| } else if (sizeof(AuxHeader) < AuxSize) { |
| printBinary( |
| "Extra raw data", |
| ArrayRef<uint8_t>(reinterpret_cast<const uint8_t *>(&AuxHeader) + |
| sizeof(AuxHeader), |
| AuxSize - sizeof(AuxHeader))); |
| } |
| } |
| |
| void XCOFFDumper::printAuxiliaryHeader( |
| const XCOFFAuxiliaryHeader32 *AuxHeader) { |
| if (AuxHeader == nullptr) |
| return; |
| outs() << "\n---Auxiliary Header:\n"; |
| uint16_t AuxSize = Obj.getOptionalHeaderSize(); |
| uint16_t PartialFieldOffset = AuxSize; |
| const char *PartialFieldName = nullptr; |
| |
| auto PrintAuxMember = [&](PrintStyle Style, const char *MemberName, |
| auto &Member) { |
| printAuxMemberHelper(Style, MemberName, Member, AuxHeader, AuxSize, |
| PartialFieldOffset, PartialFieldName); |
| }; |
| |
| PrintAuxMember(Hex, "Magic:", AuxHeader->AuxMagic); |
| PrintAuxMember(Hex, "Version:", AuxHeader->Version); |
| PrintAuxMember(Hex, "Size of .text section:", AuxHeader->TextSize); |
| PrintAuxMember(Hex, "Size of .data section:", AuxHeader->InitDataSize); |
| PrintAuxMember(Hex, "Size of .bss section:", AuxHeader->BssDataSize); |
| PrintAuxMember(Hex, "Entry point address:", AuxHeader->EntryPointAddr); |
| PrintAuxMember(Hex, ".text section start address:", AuxHeader->TextStartAddr); |
| PrintAuxMember(Hex, ".data section start address:", AuxHeader->DataStartAddr); |
| PrintAuxMember(Hex, "TOC anchor address:", AuxHeader->TOCAnchorAddr); |
| PrintAuxMember( |
| Number, "Section number of entryPoint:", AuxHeader->SecNumOfEntryPoint); |
| PrintAuxMember(Number, "Section number of .text:", AuxHeader->SecNumOfText); |
| PrintAuxMember(Number, "Section number of .data:", AuxHeader->SecNumOfData); |
| PrintAuxMember(Number, "Section number of TOC:", AuxHeader->SecNumOfTOC); |
| PrintAuxMember(Number, |
| "Section number of loader data:", AuxHeader->SecNumOfLoader); |
| PrintAuxMember(Number, "Section number of .bss:", AuxHeader->SecNumOfBSS); |
| PrintAuxMember(Hex, "Maxium alignment of .text:", AuxHeader->MaxAlignOfText); |
| PrintAuxMember(Hex, "Maxium alignment of .data:", AuxHeader->MaxAlignOfData); |
| PrintAuxMember(Hex, "Module type:", AuxHeader->ModuleType); |
| PrintAuxMember(Hex, "CPU type of objects:", AuxHeader->CpuFlag); |
| PrintAuxMember(Hex, "Maximum stack size:", AuxHeader->MaxStackSize); |
| PrintAuxMember(Hex, "Maximum data size:", AuxHeader->MaxDataSize); |
| PrintAuxMember(Hex, "Reserved for debugger:", AuxHeader->ReservedForDebugger); |
| PrintAuxMember(Hex, "Text page size:", AuxHeader->TextPageSize); |
| PrintAuxMember(Hex, "Data page size:", AuxHeader->DataPageSize); |
| PrintAuxMember(Hex, "Stack page size:", AuxHeader->StackPageSize); |
| if (offsetof(XCOFFAuxiliaryHeader32, FlagAndTDataAlignment) + |
| sizeof(XCOFFAuxiliaryHeader32::FlagAndTDataAlignment) <= |
| AuxSize) { |
| printHex("Flag:", AuxHeader->getFlag()); |
| printHex("Alignment of thread-local storage:", |
| AuxHeader->getTDataAlignment()); |
| } |
| |
| PrintAuxMember(Number, |
| "Section number for .tdata:", AuxHeader->SecNumOfTData); |
| PrintAuxMember(Number, "Section number for .tbss:", AuxHeader->SecNumOfTBSS); |
| |
| checkAndPrintAuxHeaderParseError(PartialFieldName, PartialFieldOffset, |
| AuxSize, *AuxHeader); |
| } |
| |
| void XCOFFDumper::printAuxiliaryHeader( |
| const XCOFFAuxiliaryHeader64 *AuxHeader) { |
| if (AuxHeader == nullptr) |
| return; |
| uint16_t AuxSize = Obj.getOptionalHeaderSize(); |
| outs() << "\n---Auxiliary Header:\n"; |
| uint16_t PartialFieldOffset = AuxSize; |
| const char *PartialFieldName = nullptr; |
| |
| auto PrintAuxMember = [&](PrintStyle Style, const char *MemberName, |
| auto &Member) { |
| printAuxMemberHelper(Style, MemberName, Member, AuxHeader, AuxSize, |
| PartialFieldOffset, PartialFieldName); |
| }; |
| |
| PrintAuxMember(Hex, "Magic:", AuxHeader->AuxMagic); |
| PrintAuxMember(Hex, "Version:", AuxHeader->Version); |
| PrintAuxMember(Hex, "Reserved for debugger:", AuxHeader->ReservedForDebugger); |
| PrintAuxMember(Hex, ".text section start address:", AuxHeader->TextStartAddr); |
| PrintAuxMember(Hex, ".data section start address:", AuxHeader->DataStartAddr); |
| PrintAuxMember(Hex, "TOC anchor address:", AuxHeader->TOCAnchorAddr); |
| PrintAuxMember( |
| Number, "Section number of entryPoint:", AuxHeader->SecNumOfEntryPoint); |
| PrintAuxMember(Number, "Section number of .text:", AuxHeader->SecNumOfText); |
| PrintAuxMember(Number, "Section number of .data:", AuxHeader->SecNumOfData); |
| PrintAuxMember(Number, "Section number of TOC:", AuxHeader->SecNumOfTOC); |
| PrintAuxMember(Number, |
| "Section number of loader data:", AuxHeader->SecNumOfLoader); |
| PrintAuxMember(Number, "Section number of .bss:", AuxHeader->SecNumOfBSS); |
| PrintAuxMember(Hex, "Maxium alignment of .text:", AuxHeader->MaxAlignOfText); |
| PrintAuxMember(Hex, "Maxium alignment of .data:", AuxHeader->MaxAlignOfData); |
| PrintAuxMember(Hex, "Module type:", AuxHeader->ModuleType); |
| PrintAuxMember(Hex, "CPU type of objects:", AuxHeader->CpuFlag); |
| PrintAuxMember(Hex, "Text page size:", AuxHeader->TextPageSize); |
| PrintAuxMember(Hex, "Data page size:", AuxHeader->DataPageSize); |
| PrintAuxMember(Hex, "Stack page size:", AuxHeader->StackPageSize); |
| if (offsetof(XCOFFAuxiliaryHeader64, FlagAndTDataAlignment) + |
| sizeof(XCOFFAuxiliaryHeader64::FlagAndTDataAlignment) <= |
| AuxSize) { |
| printHex("Flag:", AuxHeader->getFlag()); |
| printHex("Alignment of thread-local storage:", |
| AuxHeader->getTDataAlignment()); |
| } |
| PrintAuxMember(Hex, "Size of .text section:", AuxHeader->TextSize); |
| PrintAuxMember(Hex, "Size of .data section:", AuxHeader->InitDataSize); |
| PrintAuxMember(Hex, "Size of .bss section:", AuxHeader->BssDataSize); |
| PrintAuxMember(Hex, "Entry point address:", AuxHeader->EntryPointAddr); |
| PrintAuxMember(Hex, "Maximum stack size:", AuxHeader->MaxStackSize); |
| PrintAuxMember(Hex, "Maximum data size:", AuxHeader->MaxDataSize); |
| PrintAuxMember(Number, |
| "Section number for .tdata:", AuxHeader->SecNumOfTData); |
| PrintAuxMember(Number, "Section number for .tbss:", AuxHeader->SecNumOfTBSS); |
| PrintAuxMember(Hex, "Additional flags 64-bit XCOFF:", AuxHeader->XCOFF64Flag); |
| |
| checkAndPrintAuxHeaderParseError(PartialFieldName, PartialFieldOffset, |
| AuxSize, *AuxHeader); |
| } |
| |
| void XCOFFDumper::printLoaderSectionHeader() { |
| Expected<uintptr_t> LoaderSectionAddrOrError = |
| Obj.getSectionFileOffsetToRawData(XCOFF::STYP_LOADER); |
| if (!LoaderSectionAddrOrError) { |
| reportUniqueWarning(LoaderSectionAddrOrError.takeError()); |
| return; |
| } |
| uintptr_t LoaderSectionAddr = LoaderSectionAddrOrError.get(); |
| |
| if (LoaderSectionAddr == 0) |
| return; |
| |
| auto PrintLoadSecHeaderCommon = [&](const auto *LDHeader) { |
| printNumber("Version:", LDHeader->Version); |
| printNumber("NumberOfSymbolEntries:", LDHeader->NumberOfSymTabEnt); |
| printNumber("NumberOfRelocationEntries:", LDHeader->NumberOfRelTabEnt); |
| printNumber("LengthOfImportFileIDStringTable:", |
| LDHeader->LengthOfImpidStrTbl); |
| printNumber("NumberOfImportFileIDs:", LDHeader->NumberOfImpid); |
| printHex("OffsetToImportFileIDs:", LDHeader->OffsetToImpid); |
| printNumber("LengthOfStringTable:", LDHeader->LengthOfStrTbl); |
| printHex("OffsetToStringTable:", LDHeader->OffsetToStrTbl); |
| }; |
| |
| Width = 35; |
| outs() << "\n---Loader Section Header:\n"; |
| if (Obj.is64Bit()) { |
| const LoaderSectionHeader64 *LoaderSec64 = |
| reinterpret_cast<const LoaderSectionHeader64 *>(LoaderSectionAddr); |
| PrintLoadSecHeaderCommon(LoaderSec64); |
| printHex("OffsetToSymbolTable", LoaderSec64->OffsetToSymTbl); |
| printHex("OffsetToRelocationEntries", LoaderSec64->OffsetToRelEnt); |
| } else { |
| const LoaderSectionHeader32 *LoaderSec32 = |
| reinterpret_cast<const LoaderSectionHeader32 *>(LoaderSectionAddr); |
| PrintLoadSecHeaderCommon(LoaderSec32); |
| } |
| } |
| |
| void XCOFFDumper::printFileHeader() { |
| Width = 20; |
| outs() << "\n---File Header:\n"; |
| printHex("Magic:", Obj.getMagic()); |
| printNumber("NumberOfSections:", Obj.getNumberOfSections()); |
| |
| int32_t Timestamp = Obj.getTimeStamp(); |
| if (Timestamp > 0) { |
| // This handling of the timestamp assumes that the host system's time_t is |
| // compatible with AIX time_t. If a platform is not compatible, the lit |
| // tests will let us know. |
| time_t TimeDate = Timestamp; |
| |
| char FormattedTime[20] = {}; |
| |
| size_t BytesFormatted = std::strftime(FormattedTime, sizeof(FormattedTime), |
| "%F %T", std::gmtime(&TimeDate)); |
| assert(BytesFormatted && "The size of the buffer FormattedTime is less " |
| "than the size of the date/time string."); |
| (void)BytesFormatted; |
| printStrHex("Timestamp:", FormattedTime, Timestamp); |
| } else { |
| // Negative timestamp values are reserved for future use. |
| printStrHex("Timestamp:", Timestamp == 0 ? "None" : "Reserved Value", |
| Timestamp); |
| } |
| |
| // The number of symbol table entries is an unsigned value in 64-bit objects |
| // and a signed value (with negative values being 'reserved') in 32-bit |
| // objects. |
| if (Obj.is64Bit()) { |
| printHex("SymbolTableOffset:", Obj.getSymbolTableOffset64()); |
| printNumber("SymbolTableEntries:", Obj.getNumberOfSymbolTableEntries64()); |
| } else { |
| printHex("SymbolTableOffset:", Obj.getSymbolTableOffset32()); |
| int32_t SymTabEntries = Obj.getRawNumberOfSymbolTableEntries32(); |
| if (SymTabEntries >= 0) |
| printNumber("SymbolTableEntries:", SymTabEntries); |
| else |
| printStrHex("SymbolTableEntries:", "Reserved Value", SymTabEntries); |
| } |
| |
| printHex("OptionalHeaderSize:", Obj.getOptionalHeaderSize()); |
| printHex("Flags:", Obj.getFlags()); |
| } |
| |
| } // namespace |
| |
| std::unique_ptr<objdump::Dumper> |
| objdump::createXCOFFDumper(const object::XCOFFObjectFile &Obj) { |
| return std::make_unique<XCOFFDumper>(Obj); |
| } |
| |
| Error objdump::getXCOFFRelocationValueString(const XCOFFObjectFile &Obj, |
| const RelocationRef &Rel, |
| bool SymbolDescription, |
| SmallVectorImpl<char> &Result) { |
| symbol_iterator SymI = Rel.getSymbol(); |
| if (SymI == Obj.symbol_end()) |
| return make_error<GenericBinaryError>( |
| "invalid symbol reference in relocation entry", |
| object_error::parse_failed); |
| |
| Expected<StringRef> SymNameOrErr = SymI->getName(); |
| if (!SymNameOrErr) |
| return SymNameOrErr.takeError(); |
| |
| std::string SymName = |
| Demangle ? demangle(*SymNameOrErr) : SymNameOrErr->str(); |
| if (SymbolDescription) |
| SymName = getXCOFFSymbolDescription(createSymbolInfo(Obj, *SymI), SymName); |
| |
| Result.append(SymName.begin(), SymName.end()); |
| return Error::success(); |
| } |
| |
| std::optional<XCOFF::StorageMappingClass> |
| objdump::getXCOFFSymbolCsectSMC(const XCOFFObjectFile &Obj, |
| const SymbolRef &Sym) { |
| const XCOFFSymbolRef SymRef = Obj.toSymbolRef(Sym.getRawDataRefImpl()); |
| |
| if (!SymRef.isCsectSymbol()) |
| return std::nullopt; |
| |
| auto CsectAuxEntOrErr = SymRef.getXCOFFCsectAuxRef(); |
| if (!CsectAuxEntOrErr) |
| return std::nullopt; |
| |
| return CsectAuxEntOrErr.get().getStorageMappingClass(); |
| } |
| |
| std::optional<object::SymbolRef> |
| objdump::getXCOFFSymbolContainingSymbolRef(const XCOFFObjectFile &Obj, |
| const SymbolRef &Sym) { |
| const XCOFFSymbolRef SymRef = Obj.toSymbolRef(Sym.getRawDataRefImpl()); |
| if (!SymRef.isCsectSymbol()) |
| return std::nullopt; |
| |
| Expected<XCOFFCsectAuxRef> CsectAuxEntOrErr = SymRef.getXCOFFCsectAuxRef(); |
| if (!CsectAuxEntOrErr || !CsectAuxEntOrErr.get().isLabel()) |
| return std::nullopt; |
| uint32_t Idx = |
| static_cast<uint32_t>(CsectAuxEntOrErr.get().getSectionOrLength()); |
| DataRefImpl DRI; |
| DRI.p = Obj.getSymbolByIndex(Idx); |
| return SymbolRef(DRI, &Obj); |
| } |
| |
| bool objdump::isLabel(const XCOFFObjectFile &Obj, const SymbolRef &Sym) { |
| const XCOFFSymbolRef SymRef = Obj.toSymbolRef(Sym.getRawDataRefImpl()); |
| if (!SymRef.isCsectSymbol()) |
| return false; |
| |
| auto CsectAuxEntOrErr = SymRef.getXCOFFCsectAuxRef(); |
| if (!CsectAuxEntOrErr) |
| return false; |
| |
| return CsectAuxEntOrErr.get().isLabel(); |
| } |
| |
| std::string objdump::getXCOFFSymbolDescription(const SymbolInfoTy &SymbolInfo, |
| StringRef SymbolName) { |
| assert(SymbolInfo.isXCOFF() && "Must be a XCOFFSymInfo."); |
| |
| std::string Result; |
| // Dummy symbols have no symbol index. |
| if (SymbolInfo.XCOFFSymInfo.Index) |
| Result = |
| ("(idx: " + Twine(*SymbolInfo.XCOFFSymInfo.Index) + ") " + SymbolName) |
| .str(); |
| else |
| Result.append(SymbolName.begin(), SymbolName.end()); |
| |
| if (SymbolInfo.XCOFFSymInfo.StorageMappingClass && |
| !SymbolInfo.XCOFFSymInfo.IsLabel) { |
| const XCOFF::StorageMappingClass Smc = |
| *SymbolInfo.XCOFFSymInfo.StorageMappingClass; |
| Result.append(("[" + XCOFF::getMappingClassString(Smc) + "]").str()); |
| } |
| |
| return Result; |
| } |
| |
| #define PRINTBOOL(Prefix, Obj, Field) \ |
| OS << Prefix << " " << ((Obj.Field()) ? "+" : "-") << #Field |
| |
| #define PRINTGET(Prefix, Obj, Field) \ |
| OS << Prefix << " " << #Field << " = " \ |
| << static_cast<unsigned>(Obj.get##Field()) |
| |
| #define PRINTOPTIONAL(Field) \ |
| if (TbTable.get##Field()) { \ |
| OS << '\n'; \ |
| printRawData(Bytes.slice(Index, 4), Address + Index, OS, STI); \ |
| Index += 4; \ |
| OS << "\t# " << #Field << " = " << *TbTable.get##Field(); \ |
| } |
| |
| void objdump::dumpTracebackTable(ArrayRef<uint8_t> Bytes, uint64_t Address, |
| formatted_raw_ostream &OS, uint64_t End, |
| const MCSubtargetInfo &STI, |
| const XCOFFObjectFile *Obj) { |
| uint64_t Index = 0; |
| unsigned TabStop = getInstStartColumn(STI) - 1; |
| // Print traceback table boundary. |
| printRawData(Bytes.slice(Index, 4), Address, OS, STI); |
| OS << "\t# Traceback table start\n"; |
| Index += 4; |
| |
| uint64_t Size = End - Address; |
| bool Is64Bit = Obj->is64Bit(); |
| |
| // XCOFFTracebackTable::create modifies the size parameter, so ensure Size |
| // isn't changed. |
| uint64_t SizeCopy = End - Address; |
| Expected<XCOFFTracebackTable> TTOrErr = |
| XCOFFTracebackTable::create(Bytes.data() + Index, SizeCopy, Is64Bit); |
| |
| if (!TTOrErr) { |
| std::string WarningMsgStr; |
| raw_string_ostream WarningStream(WarningMsgStr); |
| WarningStream << "failure parsing traceback table with address: 0x" |
| << utohexstr(Address) + "\n>>> " |
| << toString(TTOrErr.takeError()) |
| << "\n>>> Raw traceback table data is:\n"; |
| |
| uint64_t LastNonZero = Index; |
| for (uint64_t I = Index; I < Size; I += 4) |
| if (support::endian::read32be(Bytes.slice(I, 4).data()) != 0) |
| LastNonZero = I + 4 > Size ? Size : I + 4; |
| |
| if (Size - LastNonZero <= 4) |
| LastNonZero = Size; |
| |
| formatted_raw_ostream FOS(WarningStream); |
| while (Index < LastNonZero) { |
| printRawData(Bytes.slice(Index, 4), Address + Index, FOS, STI); |
| Index += 4; |
| WarningStream << '\n'; |
| } |
| |
| // Print all remaining zeroes as ... |
| if (Size - LastNonZero >= 8) |
| WarningStream << "\t\t...\n"; |
| |
| reportWarning(WarningMsgStr, Obj->getFileName()); |
| return; |
| } |
| |
| auto PrintBytes = [&](uint64_t N) { |
| printRawData(Bytes.slice(Index, N), Address + Index, OS, STI); |
| Index += N; |
| }; |
| |
| XCOFFTracebackTable TbTable = *TTOrErr; |
| // Print the first of the 8 bytes of mandatory fields. |
| PrintBytes(1); |
| OS << format("\t# Version = %i", TbTable.getVersion()) << '\n'; |
| |
| // Print the second of the 8 bytes of mandatory fields. |
| PrintBytes(1); |
| TracebackTable::LanguageID LangId = |
| static_cast<TracebackTable::LanguageID>(TbTable.getLanguageID()); |
| OS << "\t# Language = " << getNameForTracebackTableLanguageId(LangId) << '\n'; |
| |
| auto Split = [&]() { |
| OS << '\n'; |
| OS.indent(TabStop); |
| }; |
| |
| // Print the third of the 8 bytes of mandatory fields. |
| PrintBytes(1); |
| PRINTBOOL("\t#", TbTable, isGlobalLinkage); |
| PRINTBOOL(",", TbTable, isOutOfLineEpilogOrPrologue); |
| Split(); |
| PRINTBOOL("\t ", TbTable, hasTraceBackTableOffset); |
| PRINTBOOL(",", TbTable, isInternalProcedure); |
| Split(); |
| PRINTBOOL("\t ", TbTable, hasControlledStorage); |
| PRINTBOOL(",", TbTable, isTOCless); |
| Split(); |
| PRINTBOOL("\t ", TbTable, isFloatingPointPresent); |
| Split(); |
| PRINTBOOL("\t ", TbTable, isFloatingPointOperationLogOrAbortEnabled); |
| OS << '\n'; |
| |
| // Print the 4th of the 8 bytes of mandatory fields. |
| PrintBytes(1); |
| PRINTBOOL("\t#", TbTable, isInterruptHandler); |
| PRINTBOOL(",", TbTable, isFuncNamePresent); |
| PRINTBOOL(",", TbTable, isAllocaUsed); |
| Split(); |
| PRINTGET("\t ", TbTable, OnConditionDirective); |
| PRINTBOOL(",", TbTable, isCRSaved); |
| PRINTBOOL(",", TbTable, isLRSaved); |
| OS << '\n'; |
| |
| // Print the 5th of the 8 bytes of mandatory fields. |
| PrintBytes(1); |
| PRINTBOOL("\t#", TbTable, isBackChainStored); |
| PRINTBOOL(",", TbTable, isFixup); |
| PRINTGET(",", TbTable, NumOfFPRsSaved); |
| OS << '\n'; |
| |
| // Print the 6th of the 8 bytes of mandatory fields. |
| PrintBytes(1); |
| PRINTBOOL("\t#", TbTable, hasExtensionTable); |
| PRINTBOOL(",", TbTable, hasVectorInfo); |
| PRINTGET(",", TbTable, NumOfGPRsSaved); |
| OS << '\n'; |
| |
| // Print the 7th of the 8 bytes of mandatory fields. |
| PrintBytes(1); |
| PRINTGET("\t#", TbTable, NumberOfFixedParms); |
| OS << '\n'; |
| |
| // Print the 8th of the 8 bytes of mandatory fields. |
| PrintBytes(1); |
| PRINTGET("\t#", TbTable, NumberOfFPParms); |
| PRINTBOOL(",", TbTable, hasParmsOnStack); |
| |
| PRINTOPTIONAL(ParmsType); |
| PRINTOPTIONAL(TraceBackTableOffset); |
| PRINTOPTIONAL(HandlerMask); |
| PRINTOPTIONAL(NumOfCtlAnchors); |
| |
| if (TbTable.getControlledStorageInfoDisp()) { |
| SmallVector<uint32_t, 8> Disp = *TbTable.getControlledStorageInfoDisp(); |
| for (unsigned I = 0; I < Disp.size(); ++I) { |
| OS << '\n'; |
| PrintBytes(4); |
| OS << "\t" << (I ? " " : "#") << " ControlledStorageInfoDisp[" << I |
| << "] = " << Disp[I]; |
| } |
| } |
| |
| // If there is a name, print the function name and function name length. |
| if (TbTable.isFuncNamePresent()) { |
| uint16_t FunctionNameLen = TbTable.getFunctionName()->size(); |
| if (FunctionNameLen == 0) { |
| OS << '\n'; |
| reportWarning( |
| "the length of the function name must be greater than zero if the " |
| "isFuncNamePresent bit is set in the traceback table", |
| Obj->getFileName()); |
| return; |
| } |
| |
| OS << '\n'; |
| PrintBytes(2); |
| OS << "\t# FunctionNameLen = " << FunctionNameLen; |
| |
| uint16_t RemainingBytes = FunctionNameLen; |
| bool HasPrinted = false; |
| while (RemainingBytes > 0) { |
| OS << '\n'; |
| uint16_t PrintLen = RemainingBytes >= 4 ? 4 : RemainingBytes; |
| printRawData(Bytes.slice(Index, PrintLen), Address + Index, OS, STI); |
| Index += PrintLen; |
| RemainingBytes -= PrintLen; |
| |
| if (!HasPrinted) { |
| OS << "\t# FunctionName = " << *TbTable.getFunctionName(); |
| HasPrinted = true; |
| } |
| } |
| } |
| |
| if (TbTable.isAllocaUsed()) { |
| OS << '\n'; |
| PrintBytes(1); |
| OS << format("\t# AllocaRegister = %u", *TbTable.getAllocaRegister()); |
| } |
| |
| if (TbTable.getVectorExt()) { |
| OS << '\n'; |
| TBVectorExt VecExt = *TbTable.getVectorExt(); |
| // Print first byte of VectorExt. |
| PrintBytes(1); |
| PRINTGET("\t#", VecExt, NumberOfVRSaved); |
| PRINTBOOL(",", VecExt, isVRSavedOnStack); |
| PRINTBOOL(",", VecExt, hasVarArgs); |
| OS << '\n'; |
| |
| // Print the second byte of VectorExt. |
| PrintBytes(1); |
| PRINTGET("\t#", VecExt, NumberOfVectorParms); |
| PRINTBOOL(",", VecExt, hasVMXInstruction); |
| OS << '\n'; |
| |
| PrintBytes(4); |
| OS << "\t# VectorParmsInfoString = " << VecExt.getVectorParmsInfo(); |
| |
| // There are two bytes of padding after vector info. |
| OS << '\n'; |
| PrintBytes(2); |
| OS << "\t# Padding"; |
| } |
| |
| if (TbTable.getExtensionTable()) { |
| OS << '\n'; |
| PrintBytes(1); |
| ExtendedTBTableFlag Flag = |
| static_cast<ExtendedTBTableFlag>(*TbTable.getExtensionTable()); |
| OS << "\t# ExtensionTable = " << getExtendedTBTableFlagString(Flag); |
| } |
| |
| if (TbTable.getEhInfoDisp()) { |
| // There are 4 bytes alignment before eh info displacement. |
| if (Index % 4) { |
| OS << '\n'; |
| PrintBytes(4 - Index % 4); |
| OS << "\t# Alignment padding for eh info displacement"; |
| } |
| OS << '\n'; |
| // The size of the displacement (address) is 4 bytes in 32-bit object files, |
| // and 8 bytes in 64-bit object files. |
| PrintBytes(4); |
| OS << "\t# EH info displacement"; |
| if (Is64Bit) { |
| OS << '\n'; |
| PrintBytes(4); |
| } |
| } |
| |
| OS << '\n'; |
| if (End == Address + Index) |
| return; |
| |
| Size = End - Address; |
| |
| const char *LineSuffix = "\t# Padding\n"; |
| auto IsWordZero = [&](uint64_t WordPos) { |
| if (WordPos >= Size) |
| return false; |
| uint64_t LineLength = std::min(4 - WordPos % 4, Size - WordPos); |
| return std::all_of(Bytes.begin() + WordPos, |
| Bytes.begin() + WordPos + LineLength, |
| [](uint8_t Byte) { return Byte == 0; }); |
| }; |
| |
| bool AreWordsZero[] = {IsWordZero(Index), IsWordZero(alignTo(Index, 4) + 4), |
| IsWordZero(alignTo(Index, 4) + 8)}; |
| bool ShouldPrintLine = true; |
| while (true) { |
| // Determine the length of the line (4, except for the first line, which |
| // will be just enough to align to the word boundary, and the last line, |
| // which will be the remainder of the data). |
| uint64_t LineLength = std::min(4 - Index % 4, Size - Index); |
| if (ShouldPrintLine) { |
| // Print the line. |
| printRawData(Bytes.slice(Index, LineLength), Address + Index, OS, STI); |
| OS << LineSuffix; |
| LineSuffix = "\n"; |
| } |
| |
| Index += LineLength; |
| if (Index == Size) |
| return; |
| |
| // For 3 or more consecutive lines of zeros, skip all but the first one, and |
| // replace them with "...". |
| if (AreWordsZero[0] && AreWordsZero[1] && AreWordsZero[2]) { |
| if (ShouldPrintLine) |
| OS << std::string(8, ' ') << "...\n"; |
| ShouldPrintLine = false; |
| } else if (!AreWordsZero[1]) { |
| // We have reached the end of a skipped block of zeros. |
| ShouldPrintLine = true; |
| } |
| AreWordsZero[0] = AreWordsZero[1]; |
| AreWordsZero[1] = AreWordsZero[2]; |
| AreWordsZero[2] = IsWordZero(Index + 8); |
| } |
| } |
| #undef PRINTBOOL |
| #undef PRINTGET |
| #undef PRINTOPTIONAL |
