diff --git a/llvm/docs/CommandGuide/llvm-objdump.rst b/llvm/docs/CommandGuide/llvm-objdump.rst --- a/llvm/docs/CommandGuide/llvm-objdump.rst +++ b/llvm/docs/CommandGuide/llvm-objdump.rst @@ -372,6 +372,10 @@ Add symbol description to disassembly output. +.. option:: --traceback-table + + Decode traceback table for disassembly output. + BUGS ---- diff --git a/llvm/include/llvm/Object/XCOFFObjectFile.h b/llvm/include/llvm/Object/XCOFFObjectFile.h --- a/llvm/include/llvm/Object/XCOFFObjectFile.h +++ b/llvm/include/llvm/Object/XCOFFObjectFile.h @@ -404,7 +404,7 @@ TBVectorExt(StringRef TBvectorStrRef); public: - uint8_t geNumberOfVRSaved() const; + uint8_t getNumberOfVRSaved() const; bool isVRSavedOnStack() const; bool hasVarArgs() const; uint8_t getNumberOfVectorParms() const; diff --git a/llvm/lib/Object/XCOFFObjectFile.cpp b/llvm/lib/Object/XCOFFObjectFile.cpp --- a/llvm/lib/Object/XCOFFObjectFile.cpp +++ b/llvm/lib/Object/XCOFFObjectFile.cpp @@ -854,7 +854,7 @@ #define GETVALUEWITHMASK(X) (Data & (TracebackTable::X)) #define GETVALUEWITHMASKSHIFT(X, S) \ ((Data & (TracebackTable::X)) >> (TracebackTable::S)) -uint8_t TBVectorExt::geNumberOfVRSaved() const { +uint8_t TBVectorExt::getNumberOfVRSaved() const { return GETVALUEWITHMASKSHIFT(NumberOfVRSavedMask, NumberOfVRSavedShift); } diff --git a/llvm/test/tools/llvm-objdump/XCOFF/Inputs/xcoff-invalid-traceback-table.o b/llvm/test/tools/llvm-objdump/XCOFF/Inputs/xcoff-invalid-traceback-table.o new file mode 100644 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 GIT binary patch literal 0 Hc$@&1 | \ +# RUN: FileCheck --check-prefixes=CHECH,WARN %s + +## xcoff-invalid-traceback-table.o compiled with IBM XL C/C++ for AIX, V16.1.0 +## compiler command: xlc -o xcoff-invalid-traceback-table.o -c foo.c +## foo.c: +## float foo(int i1,float f1,double d1,int i2, float f2) { +## return i1+f1+d1+i2+f2; +## } +## And then modify the binary content of traceback table of the object file to make it as invalid trace back table. + +CHECK: 00000000 (idx: 12) .foo: +CHECK-NEXT: 0: 93 e1 ff fc stw 31, -4(1) +CHECK-NEXT: 4: 94 21 ff 90 stwu 1, -112(1) +CHECK-NEXT: 8: 83 e2 00 04 lwz 31, 4(2) + +CHECK: 70: c0 41 00 9c lfs 2, 156(1) +CHECK-NEXT: 74: fc 21 10 2a fadd 1, 1, 2 +CHECK-NEXT: 78: fc 20 08 18 frsp 1, 1 +CHECK-NEXT: 7c: 83 e1 00 6c lwz 31, 108(1) +CHECK-NEXT: 80: 38 21 00 70 addi 1, 1, 112 +CHECK-NEXT: 84: 4e 80 00 20 blr +CHECK-NEXT: 88: 00 00 00 00 # Traceback table begin +#WARN: Parse traceback table failure(The value in error msg is calculated based on traceback begin) +#WARN-NEXT: unexpected end of data at offset 0x78 while reading [0x12, 0x85) from traceback begin. +#WARN-NEXT: The raw data of traceback table as : +#WARN-NEXT: 8c: 00 00 22 40 +#WARN-NEXT: 90: 80 01 02 07 +#WARN-NEXT: 94: 5a 00 00 00 +#WARN-NEXT: 98: 00 00 00 88 +#WARN-NEXT: 9c: 00 73 66 6f +#WARN-NEXT: a0: 6f 00 00 00 +#WARN-NEXT: ... + +CHECK: Disassembly of section .data: +CHECK-NEXT: +CHECK-NEXT: 00000100 (idx: 22) foo[TC]: +CHECK-NEXT: 100: 00 00 01 08 diff --git a/llvm/test/tools/llvm-objdump/XCOFF/disassemble-traceback-table.test b/llvm/test/tools/llvm-objdump/XCOFF/disassemble-traceback-table.test new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-objdump/XCOFF/disassemble-traceback-table.test @@ -0,0 +1,62 @@ +# REQUIRES: powerpc-registered-target + +# RUN: llvm-objdump -D --traceback-table --symbol-description %p/Inputs/xcoff-traceback-table.o | \ +# RUN: FileCheck %s + +## xcoff-traceback-table.o compiled with IBM XL C/C++ for AIX, V16.1.0 +## compiler command: xlc -o xcoff-traceback-table.o -c foo.c +## foo.c: + +## #include +## vector float foo(int i1,float f1,double d1,int i2, float f2, vector float vf) { +## if (i1+f1+d1+i2+f2 > 0) +## return vec_abs(vf); +## } +## And modify the binary content of traceback table of the object file to add some +## ControlledStorageInfo, AllocaRegister, externsion table. + +CHECK: 00000000 (idx: 12) .foo: +CHECK-NEXT: 0: 93 e1 ff fc stw 31, -4(1) +CHECK-NEXT: 4: 93 c1 ff f8 stw 30, -8(1) +CHECK-NEXT: 8: 94 21 ff 80 stwu 1, -128(1) +CHECK-NEXT: c: 83 c2 00 04 lwz 30, 4(2) + +CHECK: 90: 7c 01 00 ce lvx 0, 1, 0 +CHECK-NEXT: 94: 38 00 00 10 li 0, 16 +CHECK-NEXT: 98: 7c 3e 00 ce lvx 1, 30, 0 +CHECK-NEXT: 9c: 10 00 0c 44 vandc 0, 0, 1 +CHECK-NEXT: a0: 10 40 00 2c vsldoi 2, 0, 0, 0 +CHECK-NEXT: a4: 48 00 00 04 b 0xa8 +CHECK-NEXT: a8: 83 c1 00 78 lwz 30, 120(1) +CHECK-NEXT: ac: 38 21 00 80 addi 1, 1, 128 +CHECK-NEXT: b0: 4e 80 00 20 blr +CHECK-NEXT: b4: 00 00 00 00 # Traceback table begin +CHECK-NEXT: b8: 00 # Version = 0 +CHECK-NEXT: b9: 00 # Language = C +CHECK-NEXT: ba: 2a # -isGlobalLinkage, -isOutOfLineEpilogOrPrologue, +hasTraceBackTableOffset +CHECK-NEXT: -isInternalProcedure, +hasControlledStorage, -isTOCless +CHECK-NEXT: +isFloatingPointPresent, -isFloatingPointOperationLogOrAbortEnabled +CHECK-NEXT: bb: 60 # -isInterruptHandler, +isFuncNamePresent, +isAllocaUsed +CHECK-NEXT: OnConditionDirective=0, -isCRSaved, -isLRSaved +CHECK-NEXT: bc: 80 # +isBackChainStored, -isFixup, NumOfFPRsSaved=0 +CHECK-NEXT: bd: c2 # +hasExtensionTable, +hasVectorInfo, NumOfGPRsSaved=2 +CHECK-NEXT: be: 02 # NumberOfFixedParms=2 +CHECK-NEXT: bf: 07 # NumberOfFPParms=3, +hasParmsOnStack +CHECK-NEXT: c0: 2c 90 00 00 # ParmsType=i, f, d, i, f, v +CHECK-NEXT: c4: 00 00 00 b4 # TraceBackTableOffset=180 +CHECK-NEXT: c8: 00 00 00 03 # NumOfCtlAnchors=3 +CHECK-NEXT: cc: 6f 00 00 01 ControlledStorageInfoDisp[0]=1862270977 +CHECK-NEXT: d0: 00 00 00 0a ControlledStorageInfoDisp[1]=10 +CHECK-NEXT: d4: 00 00 01 00 ControlledStorageInfoDisp[2]=256 +CHECK-NEXT: d8: 00 03 66 6f # FunctionNameLen =3; FunctionName =foo +CHECK-NEXT: dc: 6f +CHECK-NEXT: dd: 1f # AllocaRegister =31 +CHECK-NEXT: de: 02 # NumberOfVRSaved=0, +isVRSavedOnStack, -hasVarArgs +CHECK-NEXT: df: 03 # NumberOfVectorParms=1, +hasVMXInstruction +CHECK-NEXT: e0: c0 00 00 00 # VectorParmsInfoString=vf +CHECK-NEXT: e4: 20 # ExtensionTable =32 +CHECK-NEXT: ... + +CHECK: Disassembly of section .data: +CHECK: 00000100 (idx: 22) foo[TC]: +CHECK-NEXT: 100: 00 00 01 08 diff --git a/llvm/tools/llvm-objdump/XCOFFDump.h b/llvm/tools/llvm-objdump/XCOFFDump.h --- a/llvm/tools/llvm-objdump/XCOFFDump.h +++ b/llvm/tools/llvm-objdump/XCOFFDump.h @@ -10,6 +10,7 @@ #define LLVM_TOOLS_LLVM_OBJDUMP_XCOFFDUMP_H #include "llvm/Object/XCOFFObjectFile.h" +#include "llvm/Support/FormattedStream.h" namespace llvm { @@ -28,6 +29,12 @@ Error getXCOFFRelocationValueString(const object::XCOFFObjectFile *Obj, const object::RelocationRef &RelRef, llvm::SmallVectorImpl &Result); + +void formatTracebackTableOutput(ArrayRef Bytes, uint64_t Address, + formatted_raw_ostream &OS); + +void dumpTracebackTable(ArrayRef Bytes, uint64_t Address, + formatted_raw_ostream &OS, uint64_t End); } // namespace objdump } // namespace llvm #endif diff --git a/llvm/tools/llvm-objdump/XCOFFDump.cpp b/llvm/tools/llvm-objdump/XCOFFDump.cpp --- a/llvm/tools/llvm-objdump/XCOFFDump.cpp +++ b/llvm/tools/llvm-objdump/XCOFFDump.cpp @@ -15,9 +15,13 @@ #include "llvm-objdump.h" #include "llvm/Demangle/Demangle.h" +#include "llvm/MC/MCInstPrinter.h" +#include "llvm/Support/Endian.h" using namespace llvm; using namespace llvm::object; +using namespace llvm::XCOFF; +using namespace llvm::support; Error objdump::getXCOFFRelocationValueString(const XCOFFObjectFile *Obj, const RelocationRef &Rel, @@ -86,3 +90,265 @@ return Result; } + +void objdump::formatTracebackTableOutput(ArrayRef Bytes, + uint64_t Address, + formatted_raw_ostream &OS) { + size_t Start = OS.tell(); + if (!NoLeadingAddr) + OS << format("%8" PRIx64 ":", Address); + if (!NoShowRawInsn) { + OS << ' '; + dumpBytes(Bytes, OS); + } + + // The output of printInst starts with a tab. Print some spaces so that + // the tab has 1 column and advances to the target tab stop. + + unsigned TabStop = NoShowRawInsn ? 16 : 40; + unsigned Column = OS.tell() - Start; + OS.indent(Column < TabStop - 1 ? TabStop - 1 - Column : 7 - Column % 8); +} + +const char *SourceLanguageIdentifier[] = { + "C", "FORTRAN", "Pascal", "ADA", "PL/I", + "BASIC", "LISP", "COBOL", "Modulas2", "C++", + "RPG", "PL8", "Assembler", "Java", "Objective C"}; + +#define PRINTBOOL(Prefix, Obj, Field) \ + OS << Prefix << " " << ((Obj.Field()) ? "+" : "-") << #Field + +#define PRINTGET(Prefix, Obj, Field) \ + OS << Prefix << " " << #Field << "=" << (unsigned)(Obj.get##Field()) + +#define SPLIT \ + OS << "\n"; \ + OS.indent(TabStop) + +#define PRINTOUTBYTES(N) \ + formatTracebackTableOutput(Bytes.slice(Index, N), Address + Index, OS); \ + Index += N; + +void objdump::dumpTracebackTable(ArrayRef Bytes, uint64_t Address, + formatted_raw_ostream &OS, uint64_t End) { + uint64_t Index = 0; + unsigned TabStop = (NoShowRawInsn ? 16 : 40) - 1; + + // Print out backtrace table boundary. + formatTracebackTableOutput(Bytes.slice(Index, 4), Address, OS); + OS << "# Traceback table begin\n"; + Index += 4; + + uint64_t Size = End - Address; + + Expected TTOrErr = + XCOFFTracebackTable::create(Bytes.data() + Index, Size); + + if (!TTOrErr) { + outs().flush(); + WithColor::warning(errs(), "") + << " Parse traceback table failure(The value in error msg is " + "calculated based on traceback begin) \n" + << "\t" << toString(TTOrErr.takeError()) << " from traceback begin." + << "\n\tThe raw data of traceback table as : \n"; + + uint64_t LastNoZero = Index; + + // The value of Size been changed in function XCOFFTracebackTable::create() + Size = End - Address; + + for (uint64_t I = Index; I < Size; I = I + 4) { + if (support::endian::read32be(Bytes.slice(I, 4).data()) != 0) + LastNoZero = (I + 4) > Size ? Size : (I + 4); + } + + if (Size - LastNoZero <= 4) + LastNoZero = Size; + + formatted_raw_ostream FOS(errs()); + while (Index < LastNoZero) { + formatTracebackTableOutput(Bytes.slice(Index, 4), Address + Index, FOS); + Index += 4; + errs() << "\n"; + } + + // Print out all remaining zero as ... + if (Size - LastNoZero >= 8) + errs() << "\t\t...\n"; + + return; + } + + XCOFFTracebackTable TbTable = *TTOrErr; + + // Print out the first byte of 8 bytes of mandatory fields. + PRINTOUTBYTES(1) + OS << "# Version = " << (int)TbTable.getVersion() << "\n"; + + // Print out the second byte of 8 bytes of mandatory fields. + PRINTOUTBYTES(1) + unsigned LangId = TbTable.getLanguageID(); + OS << "# Language = " + << (LangId < sizeof(SourceLanguageIdentifier) / sizeof(char *) + ? SourceLanguageIdentifier[LangId] + : "Unknown") + << "\n"; + // Print out the third byte of 8 bytes of mandatory fields. + PRINTOUTBYTES(1) + PRINTBOOL("#", TbTable, isGlobalLinkage); + PRINTBOOL(",", TbTable, isOutOfLineEpilogOrPrologue); + PRINTBOOL(",", TbTable, hasTraceBackTableOffset); + SPLIT; + PRINTBOOL(" ", TbTable, isInternalProcedure); + PRINTBOOL(",", TbTable, hasControlledStorage); + PRINTBOOL(",", TbTable, isTOCless); + SPLIT; + PRINTBOOL(" ", TbTable, isFloatingPointPresent); + PRINTBOOL(",", TbTable, isFloatingPointOperationLogOrAbortEnabled); + OS << "\n"; + + // Print out the 4th byte of 8 bytes of mandatory fields. + PRINTOUTBYTES(1) + PRINTBOOL("#", TbTable, isInterruptHandler); + PRINTBOOL(",", TbTable, isFuncNamePresent); + PRINTBOOL(",", TbTable, isAllocaUsed); + SPLIT; + PRINTGET(" ", TbTable, OnConditionDirective); + PRINTBOOL(",", TbTable, isCRSaved); + PRINTBOOL(",", TbTable, isLRSaved); + OS << "\n"; + + // Print out the 5th byte of 8 bytes of mandatory fields. + PRINTOUTBYTES(1) + PRINTBOOL("#", TbTable, isBackChainStored); + PRINTBOOL(",", TbTable, isFixup); + PRINTGET(",", TbTable, NumOfFPRsSaved); + OS << "\n"; + + // Print out the 6th byte of 8 bytes of mandatory fields. + PRINTOUTBYTES(1) + PRINTBOOL("#", TbTable, hasExtensionTable); + PRINTBOOL(",", TbTable, hasVectorInfo); + PRINTGET(",", TbTable, NumOfGPRsSaved); + OS << "\n"; + + // Print out the 7th byte of 8 bytes of mandatory fields. + PRINTOUTBYTES(1) + PRINTGET("#", TbTable, NumberOfFixedParms); + OS << "\n"; + + // Print out the 8th byte of 8 bytes of mandatory fields. + PRINTOUTBYTES(1) + PRINTGET("#", TbTable, NumberOfFPParms); + PRINTBOOL(",", TbTable, hasParmsOnStack); + +#define PRINTOPTIONAL(Field) \ + if (TbTable.get##Field()) { \ + OS << "\n"; \ + formatTracebackTableOutput(Bytes.slice(Index, 4), Address + Index, OS); \ + Index += 4; \ + OS << "# " << #Field << "=" << TbTable.get##Field().getValue(); \ + } + + PRINTOPTIONAL(ParmsType); + PRINTOPTIONAL(TraceBackTableOffset); + PRINTOPTIONAL(HandlerMask); + PRINTOPTIONAL(NumOfCtlAnchors); + + if (TbTable.getControlledStorageInfoDisp()) { + SmallVector Disp = + TbTable.getControlledStorageInfoDisp().getValue(); + for (unsigned I = 0; I < Disp.size(); ++I) { + OS << "\n"; + PRINTOUTBYTES(4) + OS << " ControlledStorageInfoDisp[" << I << "]=" << Disp[I]; + } + } + + // Print out function name length and function name if there is. + if (TbTable.isFuncNamePresent()) { + bool HasPrinted = false; + uint16_t FunctionNameLen = TbTable.getFunctionName().getValue().size(); + + assert(FunctionNameLen > 0 && + "The length of function name must large than zero."); + + // Function name occupy two bytes. + uint16_t RemainingBytes = FunctionNameLen + 2; + while (RemainingBytes > 0) { + OS << "\n"; + uint16_t PrintLen = RemainingBytes >= 4 ? 4 : RemainingBytes; + formatTracebackTableOutput(Bytes.slice(Index, PrintLen), Address + Index, + OS); + Index += PrintLen; + RemainingBytes -= PrintLen; + + if (!HasPrinted) { + OS << "# FunctionNameLen =" << FunctionNameLen; + OS << "; FunctionName =" << TbTable.getFunctionName().getValue(); + HasPrinted = true; + } + } + } + + if (TbTable.isAllocaUsed()) { + OS << "\n"; + PRINTOUTBYTES(1) + OS << "# AllocaRegister =" + << (unsigned int)TbTable.getAllocaRegister().getValue(); + } + + if (TbTable.getVectorExt()) { + OS << "\n"; + TBVectorExt VecExt = TbTable.getVectorExt().getValue(); + // Print first byte of VectorExt. + PRINTOUTBYTES(1) + PRINTGET("#", VecExt, NumberOfVRSaved); + PRINTBOOL(",", VecExt, isVRSavedOnStack); + PRINTBOOL(",", VecExt, hasVarArgs); + OS << "\n"; + + // Print the second byte of VectorExt. + PRINTOUTBYTES(1) + PRINTGET("#", VecExt, NumberOfVectorParms); + PRINTBOOL(",", VecExt, hasVMXInstruction); + OS << "\n"; + + PRINTOUTBYTES(4) + OS << "# VectorParmsInfoString" + << "=" << VecExt.getVectorParmsInfoString(); + } + + if (TbTable.getExtensionTable()) { + OS << "\n"; + PRINTOUTBYTES(1) + OS << "# ExtensionTable =" + << (unsigned int)TbTable.getExtensionTable().getValue(); + } + + if (End == Address + Index) { + OS << "\n"; + return; + } + + // Print out all padding. + OS << "\n"; + if (End - Address + Index >= 8) + OS << "\t\t...\n"; + else { + uint16_t AlignmentLen = 4 - Index % 4; + formatTracebackTableOutput(Bytes.slice(Index, AlignmentLen), + Address + Index, OS); + OS << "# Padding\n"; + Index += AlignmentLen; + if (Index < End - Address) { + formatTracebackTableOutput(Bytes.slice(Index, 4), Address + Index, OS); + OS << "# Padding\n"; + } + } +} +#undef PRINTBOOL +#undef PRINTGET +#undef SPLIT +#undef PRINTOPTIONAL +#undef PRINTOUTBYTES diff --git a/llvm/tools/llvm-objdump/llvm-objdump.h b/llvm/tools/llvm-objdump/llvm-objdump.h --- a/llvm/tools/llvm-objdump/llvm-objdump.h +++ b/llvm/tools/llvm-objdump/llvm-objdump.h @@ -46,6 +46,7 @@ extern cl::opt SectionHeaders; extern cl::opt SectionContents; extern cl::opt SymbolDescription; +extern cl::opt TracebackTable; extern cl::opt SymbolTable; extern cl::opt TripleName; extern cl::opt UnwindInfo; diff --git a/llvm/tools/llvm-objdump/llvm-objdump.cpp b/llvm/tools/llvm-objdump/llvm-objdump.cpp --- a/llvm/tools/llvm-objdump/llvm-objdump.cpp +++ b/llvm/tools/llvm-objdump/llvm-objdump.cpp @@ -142,6 +142,12 @@ "option is for XCOFF files only"), cl::init(false), cl::cat(ObjdumpCat)); +cl::opt objdump::TracebackTable( + "traceback-table", + cl::desc("Decode traceback table for disassembly. This " + "option is for XCOFF files only"), + cl::init(false), cl::cat(ObjdumpCat)); + static cl::list DisassembleSymbols("disassemble-symbols", cl::CommaSeparated, cl::desc("List of symbols to disassemble. " @@ -1570,7 +1576,7 @@ const uint64_t Addr = unwrapOrError(Symbol.getAddress(), FileName); const StringRef Name = unwrapOrError(Symbol.getName(), FileName); - if (Obj->isXCOFF() && SymbolDescription) { + if (Obj->isXCOFF() && (SymbolDescription || TracebackTable)) { const auto *XCOFFObj = cast(Obj); DataRefImpl SymbolDRI = Symbol.getRawDataRefImpl(); @@ -1588,7 +1594,7 @@ static SymbolInfoTy createDummySymbolInfo(const ObjectFile *Obj, const uint64_t Addr, StringRef &Name, uint8_t Type) { - if (Obj->isXCOFF() && SymbolDescription) + if (Obj->isXCOFF() && (SymbolDescription || TracebackTable)) return SymbolInfoTy(Addr, Name, None, None, false); else return SymbolInfoTy(Addr, Name, Type); @@ -1933,6 +1939,12 @@ Symbols[SI].Type != ELF::STT_OBJECT && !DisassembleAll; bool DumpARMELFData = false; + bool DumpTracebackTableForXCOFFFunction = + Obj->isXCOFF() && Section.isText() && TracebackTable && + Symbols[SI].XCOFFSymInfo.StorageMappingClass && + (Symbols[SI].XCOFFSymInfo.StorageMappingClass.getValue() == + XCOFF::XMC_PR); + formatted_raw_ostream FOS(outs()); std::unordered_map AllLabels; @@ -1980,6 +1992,14 @@ } } + if (DumpTracebackTableForXCOFFFunction && + doesXCOFFTracebackTableBegin(Bytes.slice(Index, 4))) { + dumpTracebackTable(Bytes.slice(Index), + SectionAddr + Index + VMAAdjustment, FOS, End); + Index = End; + continue; + } + // Print local label if there's any. auto Iter = AllLabels.find(SectionAddr + Index); if (Iter != AllLabels.end())