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 @@ -392,6 +392,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 @@ -598,17 +598,20 @@ class XCOFFTracebackTable { const uint8_t *const TBPtr; + bool Is64BitObj; Optional> ParmsType; Optional TraceBackTableOffset; Optional HandlerMask; Optional NumOfCtlAnchors; - Optional> ControlledStorageInfoDisp; + Optional> ControlledStorageInfoDisp; Optional FunctionName; Optional AllocaRegister; Optional VecExt; Optional ExtensionTable; + Optional EhInfoDisp; - XCOFFTracebackTable(const uint8_t *Ptr, uint64_t &Size, Error &Err); + XCOFFTracebackTable(const uint8_t *Ptr, uint64_t &Size, Error &Err, + bool Is64Bit = false); public: /// Parse an XCOFF Traceback Table from \a Ptr with \a Size bytes. @@ -624,8 +627,8 @@ /// If the XCOFF Traceback Table is not parsed successfully or there are /// extra bytes that are not recognized, \a Size will be updated to be the /// size up to the end of the last successfully parsed field of the table. - static Expected create(const uint8_t *Ptr, - uint64_t &Size); + static Expected + create(const uint8_t *Ptr, uint64_t &Size, bool Is64Bits = false); uint8_t getVersion() const; uint8_t getLanguageID() const; @@ -664,13 +667,14 @@ } const Optional &getHandlerMask() const { return HandlerMask; } const Optional &getNumOfCtlAnchors() { return NumOfCtlAnchors; } - const Optional> &getControlledStorageInfoDisp() { + const Optional> &getControlledStorageInfoDisp() { return ControlledStorageInfoDisp; } const Optional &getFunctionName() const { return FunctionName; } const Optional &getAllocaRegister() const { return AllocaRegister; } const Optional &getVectorExt() const { return VecExt; } const Optional &getExtensionTable() const { return ExtensionTable; } + const Optional &getEhInfoDisp() const { return EhInfoDisp; } }; bool doesXCOFFTracebackTableBegin(ArrayRef Bytes); diff --git a/llvm/lib/BinaryFormat/XCOFF.cpp b/llvm/lib/BinaryFormat/XCOFF.cpp --- a/llvm/lib/BinaryFormat/XCOFF.cpp +++ b/llvm/lib/BinaryFormat/XCOFF.cpp @@ -176,7 +176,7 @@ Res += "TB_LONGTBTABLE2 "; // Two of the bits that haven't got used in the mask. - if (Flag & 0x06) + if (Flag & 0x06 || Flag == 0x0) Res += "Unknown "; // Pop the last space. 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 @@ -1108,18 +1108,18 @@ #undef GETVALUEWITHMASK #undef GETVALUEWITHMASKSHIFT -Expected XCOFFTracebackTable::create(const uint8_t *Ptr, - uint64_t &Size) { +Expected +XCOFFTracebackTable::create(const uint8_t *Ptr, uint64_t &Size, bool Is64Bit) { Error Err = Error::success(); - XCOFFTracebackTable TBT(Ptr, Size, Err); + XCOFFTracebackTable TBT(Ptr, Size, Err, Is64Bit); if (Err) return std::move(Err); return TBT; } XCOFFTracebackTable::XCOFFTracebackTable(const uint8_t *Ptr, uint64_t &Size, - Error &Err) - : TBPtr(Ptr) { + Error &Err, bool Is64Bit) + : TBPtr(Ptr), Is64BitObj(Is64Bit) { ErrorAsOutParameter EAO(&Err); DataExtractor DE(ArrayRef(Ptr, Size), /*IsLittleEndian=*/false, /*AddressSize=*/0); @@ -1145,10 +1145,10 @@ if (Cur && hasControlledStorage()) { NumOfCtlAnchors = DE.getU32(Cur); if (Cur && NumOfCtlAnchors) { - SmallVector Disp; + SmallVector Disp; Disp.reserve(NumOfCtlAnchors.getValue()); for (uint32_t I = 0; I < NumOfCtlAnchors && Cur; ++I) - Disp.push_back(DE.getU32(Cur)); + Disp.push_back(Is64BitObj ? DE.getU64(Cur) : DE.getU32(Cur)); if (Cur) ControlledStorageInfoDisp = std::move(Disp); } @@ -1174,6 +1174,8 @@ } VecExt = TBVecExtOrErr.get(); VectorParmsNum = VecExt.getValue().getNumberOfVectorParms(); + // Skip two bytes of padding after vector info. + DE.skip(Cur, 2); } } @@ -1194,9 +1196,18 @@ ParmsType = ParmsTypeOrError.get(); } - if (Cur && hasExtensionTable()) + if (Cur && hasExtensionTable()) { ExtensionTable = DE.getU8(Cur); + if (ExtensionTable.getValue() & ExtendedTBTableFlag::TB_EH_INFO) { + // eh_info displacement must be 4-byte aligned. + uint64_t Pos = Cur.tell(); + if (Pos % 4 != 0) + DE.skip(Cur, 4 - (Pos % 4)); + + EhInfoDisp = Is64BitObj ? DE.getU64(Cur) : DE.getU32(Cur); + } + } if (!Cur) Err = Cur.takeError(); diff --git a/llvm/test/CodeGen/PowerPC/aix-emit-tracebacktable-clobber-register.ll b/llvm/test/CodeGen/PowerPC/aix-emit-tracebacktable-clobber-register.ll --- a/llvm/test/CodeGen/PowerPC/aix-emit-tracebacktable-clobber-register.ll +++ b/llvm/test/CodeGen/PowerPC/aix-emit-tracebacktable-clobber-register.ll @@ -6,6 +6,11 @@ ; RUN: -mcpu=pwr4 -mattr=+altivec -vec-extabi < %s | \ ; RUN: FileCheck --check-prefixes=CHECK-FUNC,COMMON %s +; RUN: llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff -mcpu=pwr4 \ +; RUN: -mattr=+altivec -vec-extabi -xcoff-traceback-table=true -filetype=obj -o %t.o < %s +; RUN: llvm-objdump -D --traceback-table --symbol-description %t.o | \ +; RUN: FileCheck --check-prefix=OBJ-DIS %s + define float @bar() #0 { entry: %fvalue = alloca float, align 4 @@ -95,3 +100,48 @@ ; COMMON: .toc ; COMMON: L..C2: ; COMMON-NEXT: .tc __ehinfo.1[TC],__ehinfo.1 + + +; OBJ-DIS: 9c: 00 00 00 00 # Traceback table begin +; OBJ-DIS-NEXT: a0: 00 # Version = 0 +; OBJ-DIS-NEXT: a1: 09 # Language = CPlusPlus +; OBJ-DIS-NEXT: a2: 22 # -isGlobalLinkage, -isOutOfLineEpilogOrPrologue +; OBJ-DIS-NEXT: +hasTraceBackTableOffset, -isInternalProcedure +; OBJ-DIS-NEXT: -hasControlledStorage, -isTOCless +; OBJ-DIS-NEXT: +isFloatingPointPresent +; OBJ-DIS-NEXT: -isFloatingPointOperationLogOrAbortEnabled +; OBJ-DIS-NEXT: a3: 40 # -isInterruptHandler, +isFuncNamePresent, -isAllocaUsed +; OBJ-DIS-NEXT: OnConditionDirective = 0, -isCRSaved, -isLRSaved +; OBJ-DIS-NEXT: a4: 85 # +isBackChainStored, -isFixup, NumOfFPRsSaved = 5 +; OBJ-DIS-NEXT: a5: 04 # -hasExtensionTable, -hasVectorInfo, NumOfGPRsSaved = 4 +; OBJ-DIS-NEXT: a6: 00 # NumberOfFixedParms = 0 +; OBJ-DIS-NEXT: a7: 01 # NumberOfFPParms = 0, +hasParmsOnStack +; OBJ-DIS-NEXT: a8: 00 00 00 9c # TraceBackTableOffset = 156 +; OBJ-DIS-NEXT: ac: 00 03 # FunctionNameLen = 3 +; OBJ-DIS-NEXT: ae: 62 61 72 # FunctionName = bar +; OBJ-DIS-NEXT: b1: 60 00 00 # Paddings + +; OBJ-DIS: 11c: 00 00 00 00 # Traceback table begin +; OBJ-DIS-NEXT: 120: 00 # Version = 0 +; OBJ-DIS-NEXT: 121: 09 # Language = CPlusPlus +; OBJ-DIS-NEXT: 122: 20 # -isGlobalLinkage, -isOutOfLineEpilogOrPrologue +; OBJ-DIS-NEXT: +hasTraceBackTableOffset, -isInternalProcedure +; OBJ-DIS-NEXT: -hasControlledStorage, -isTOCless +; OBJ-DIS-NEXT: -isFloatingPointPresent +; OBJ-DIS-NEXT: -isFloatingPointOperationLogOrAbortEnabled +; OBJ-DIS-NEXT: 123: 40 # -isInterruptHandler, +isFuncNamePresent, -isAllocaUsed +; OBJ-DIS-NEXT: OnConditionDirective = 0, -isCRSaved, -isLRSaved +; OBJ-DIS-NEXT: 124: 80 # +isBackChainStored, -isFixup, NumOfFPRsSaved = 0 +; OBJ-DIS-NEXT: 125: c0 # +hasExtensionTable, +hasVectorInfo, NumOfGPRsSaved = 0 +; OBJ-DIS-NEXT: 126: 00 # NumberOfFixedParms = 0 +; OBJ-DIS-NEXT: 127: 01 # NumberOfFPParms = 0, +hasParmsOnStack +; OBJ-DIS-NEXT: 128: 00 00 00 5c # TraceBackTableOffset = 92 +; OBJ-DIS-NEXT: 12c: 00 04 # FunctionNameLen = 4 +; OBJ-DIS-NEXT: 12e: 66 6f 6f 76 # FunctionName = foov +; OBJ-DIS-NEXT: 132: 12 # NumberOfVRSaved = 4, +isVRSavedOnStack, -hasVarArgs +; OBJ-DIS-NEXT: 133: 01 # NumberOfVectorParms = 0, +hasVMXInstruction +; OBJ-DIS-NEXT: 134: 00 00 00 00 # VectorParmsInfoString = +; OBJ-DIS-NEXT: 138: 00 00 # Padding +; OBJ-DIS-NEXT: 13a: 08 # ExtensionTable = TB_EH_INFO +; OBJ-DIS-NEXT: 13b: 00 # Alignment padding for except info displacement +; OBJ-DIS-NEXT: 13c: 00 00 00 08 # Except info displacement 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 --implicit-check-not warning: --check-prefixes=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. + +# WARN: {{.*}}llvm-objdump: warning: '{{.*}}xcoff-invalid-traceback-table.o': failure parsing traceback table with address: 0x88 +# WARN-NEXT: >>> unexpected end of data at offset 0x78 while reading [0x12, 0x85) +# WARN-NEXT: >>> Raw traceback table data is: +# 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: ... 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,89 @@ +# 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 -qaltivec -qarch=pwr6 -o xcoff-traceback-table.o -c foo.c +## foo.c: + +## #include +## int AddNum(int a, int b) { +## return a+b; +## } +## 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: Disassembly of section .text:{{[[:space:]] *}} +CHECK-NEXT: 00000000 (idx: 12) .AddNum: +CHECK-NEXT: 0: 94 21 ff c0 stwu 1, -64(1) +CHECK-NEXT: 4: 90 61 00 58 stw 3, 88(1) +CHECK-NEXT: 8: 90 81 00 5c stw 4, 92(1) +CHECK-NEXT: c: 80 61 00 58 lwz 3, 88(1) +CHECK-NEXT: 10: 80 81 00 5c lwz 4, 92(1) +CHECK-NEXT: 14: 7c 63 22 14 add 3, 3, 4 +CHECK-NEXT: 18: 38 21 00 40 addi 1, 1, 64 +CHECK-NEXT: 1c: 4e 80 00 20 blr +CHECK-NEXT: 20: 00 00 00 00 # Traceback table begin +CHECK-NEXT: 24: 00 # Version = 0 +CHECK-NEXT: 25: 00 # Language = C +CHECK-NEXT: 26: 20 # -isGlobalLinkage, -isOutOfLineEpilogOrPrologue +CHECK-NEXT: +hasTraceBackTableOffset, -isInternalProcedure +CHECK-NEXT: -hasControlledStorage, -isTOCless +CHECK-NEXT: -isFloatingPointPresent +CHECK-NEXT: -isFloatingPointOperationLogOrAbortEnabled +CHECK-NEXT: 27: 40 # -isInterruptHandler, +isFuncNamePresent, -isAllocaUsed +CHECK-NEXT: OnConditionDirective = 0, -isCRSaved, -isLRSaved +CHECK-NEXT: 28: 80 # +isBackChainStored, -isFixup, NumOfFPRsSaved = 0 +CHECK-NEXT: 29: 00 # -hasExtensionTable, -hasVectorInfo, NumOfGPRsSaved = 0 +CHECK-NEXT: 2a: 02 # NumberOfFixedParms = 2 +CHECK-NEXT: 2b: 01 # NumberOfFPParms = 0, +hasParmsOnStack +CHECK-NEXT: 2c: 00 00 00 00 # ParmsType = i, i +CHECK-NEXT: 30: 00 00 00 20 # TraceBackTableOffset = 32 +CHECK-NEXT: 34: 00 06 # FunctionNameLen = 6 +CHECK-NEXT: 36: 41 64 64 4e # FunctionName = AddNum +CHECK-NEXT: 3a: 75 6d +CHECK-NEXT: 3c: 00 00 00 00 # Paddings + +CHECK: 00000040 (idx: 14) .foo: +CHECK-NEXT: 40: 93 e1 ff fc stw 31, -4(1) +CHECK-NEXT: 44: 93 c1 ff f8 stw 30, -8(1) +CHECK-NEXT: 48: 94 21 ff 80 stwu 1, -128(1) +CHECK-NEXT: 4c: 83 c2 00 08 lwz 30, 8(2) + +CHECK: f4: 00 00 00 00 # Traceback table begin +CHECK-NEXT: f8: 00 # Version = 0 +CHECK-NEXT: f9: 00 # Language = C +CHECK-NEXT: fa: 2a # -isGlobalLinkage, -isOutOfLineEpilogOrPrologue +CHECK-NEXT: +hasTraceBackTableOffset, -isInternalProcedure +CHECK-NEXT: +hasControlledStorage, -isTOCless +CHECK-NEXT: +isFloatingPointPresent +CHECK-NEXT: -isFloatingPointOperationLogOrAbortEnabled +CHECK-NEXT: fb: 60 # -isInterruptHandler, +isFuncNamePresent, +isAllocaUsed +CHECK-NEXT: OnConditionDirective = 0, -isCRSaved, -isLRSaved +CHECK-NEXT: fc: 80 # +isBackChainStored, -isFixup, NumOfFPRsSaved = 0 +CHECK-NEXT: fd: c2 # +hasExtensionTable, +hasVectorInfo, NumOfGPRsSaved = 2 +CHECK-NEXT: fe: 02 # NumberOfFixedParms = 2 +CHECK-NEXT: ff: 07 # NumberOfFPParms = 3, +hasParmsOnStack +CHECK-NEXT: 100: 2c 90 00 00 # ParmsType = i, f, d, i, f, v +CHECK-NEXT: 104: 00 00 00 b4 # TraceBackTableOffset = 180 +CHECK-NEXT: 108: 00 00 00 03 # NumOfCtlAnchors = 3 +CHECK-NEXT: 10c: 6f 00 00 01 ControlledStorageInfoDisp[0] = 1862270977 +CHECK-NEXT: 110: 00 00 00 0a ControlledStorageInfoDisp[1] = 10 +CHECK-NEXT: 114: 00 00 01 00 ControlledStorageInfoDisp[2] = 256 +CHECK-NEXT: 118: 00 03 # FunctionNameLen = 3 +CHECK-NEXT: 11a: 66 6f 6f # FunctionName = foo +CHECK-NEXT: 11d: 1f # AllocaRegister = 31 +CHECK-NEXT: 11e: 02 # NumberOfVRSaved = 0, +isVRSavedOnStack, -hasVarArgs +CHECK-NEXT: 11f: 03 # NumberOfVectorParms = 1, +hasVMXInstruction +CHECK-NEXT: 120: c0 00 00 00 # VectorParmsInfoString = vf +CHECK-NEXT: 124: 00 00 # Padding +CHECK-NEXT: 126: 20 # ExtensionTable = TB_SSP_CANARY + +CHECK: Disassembly of section .data:{{[[:space:]] *}} +CHECK-NEXT: 00000180 (idx: 24) AddNum[TC]: +CHECK-NEXT: 180: 00 00 01 8c diff --git a/llvm/tools/llvm-objdump/ObjdumpOpts.td b/llvm/tools/llvm-objdump/ObjdumpOpts.td --- a/llvm/tools/llvm-objdump/ObjdumpOpts.td +++ b/llvm/tools/llvm-objdump/ObjdumpOpts.td @@ -42,7 +42,11 @@ def symbol_description : Flag<["--"], "symbol-description">, HelpText<"Add symbol description for disassembly. This " - "option is for XCOFF files only.">; + "option is for XCOFF files only">; + +def traceback_table : Flag<["--"], "traceback-table">, + HelpText<"Decode traceback table for disassembly. This " + "option is for XCOFF files only">; def disassemble_symbols_EQ : Joined<["--"], "disassemble-symbols=">, HelpText<"List of symbols to disassemble. " diff --git a/llvm/tools/llvm-objdump/SourcePrinter.cpp b/llvm/tools/llvm-objdump/SourcePrinter.cpp --- a/llvm/tools/llvm-objdump/SourcePrinter.cpp +++ b/llvm/tools/llvm-objdump/SourcePrinter.cpp @@ -24,10 +24,6 @@ namespace llvm { namespace objdump { -unsigned getInstStartColumn(const MCSubtargetInfo &STI) { - return !ShowRawInsn ? 16 : STI.getTargetTriple().isX86() ? 40 : 24; -} - bool LiveVariable::liveAtAddress(object::SectionedAddress Addr) { if (LocExpr.Range == None) return false; 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 @@ -9,7 +9,9 @@ #ifndef LLVM_TOOLS_LLVM_OBJDUMP_XCOFFDUMP_H #define LLVM_TOOLS_LLVM_OBJDUMP_XCOFFDUMP_H +#include "llvm/MC/MCSubtargetInfo.h" #include "llvm/Object/XCOFFObjectFile.h" +#include "llvm/Support/FormattedStream.h" namespace llvm { @@ -28,6 +30,11 @@ Error getXCOFFRelocationValueString(const object::XCOFFObjectFile *Obj, const object::RelocationRef &RelRef, llvm::SmallVectorImpl &Result); + +void dumpTracebackTable(ArrayRef Bytes, uint64_t Address, + formatted_raw_ostream &OS, uint64_t End, + const MCSubtargetInfo &STI, + const object::ObjectFile *Obj); } // 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,14 @@ #include "llvm-objdump.h" #include "llvm/Demangle/Demangle.h" +#include "llvm/MC/MCInstPrinter.h" +#include "llvm/Support/Casting.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, @@ -94,3 +99,279 @@ return Result; } + +#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 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().getValue(); \ + } + +void objdump::dumpTracebackTable(ArrayRef Bytes, uint64_t Address, + formatted_raw_ostream &OS, uint64_t End, + const MCSubtargetInfo &STI, + const ObjectFile *Obj) { + uint64_t Index = 0; + unsigned TabStop = getInstStartColumn(STI) - 1; + // Print backtrace table boundary. + printRawData(Bytes.slice(Index, 4), Address, OS, STI); + OS << "\t# Traceback table begin\n"; + Index += 4; + + uint64_t Size = End - Address; + bool Is64Bit = cast(Obj)->is64Bit(); + + Expected TTOrErr = + XCOFFTracebackTable::create(Bytes.data() + Index, Size, Is64Bit); + + if (!TTOrErr) { + reportWarning(Twine("failure parsing traceback table with address: 0x") + + utohexstr(Address) + " \n>>> " + + toString(TTOrErr.takeError()) + + "\n>>> Raw traceback table data is:", + Obj->getFileName()); + + uint64_t LastNoZero = Index; + + // The value of Size has 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) { + printRawData(Bytes.slice(Index, 4), Address + Index, FOS, STI); + Index += 4; + errs() << "\n"; + } + + // Print all remaining zero as ... + if (Size - LastNoZero >= 8) + errs() << "\t\t...\n"; + + return; + } + + XCOFFTracebackTable TbTable = *TTOrErr; + + auto printBytes = [&](uint64_t n) { + printRawData(Bytes.slice(Index, n), Address + Index, OS, STI); + Index += n; + }; + + // Print the first byte of 8 bytes of mandatory fields. + printBytes(1); + OS << format("\t# Version = %i", TbTable.getVersion()) << "\n"; + + // Print the second byte of 8 bytes of mandatory fields. + printBytes(1); + TracebackTable::LanguageID LangId = + static_cast(TbTable.getLanguageID()); + OS << "\t# Language = " << getNameForTracebackTableLanguageId(LangId) << "\n"; + + // Print the third byte of 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 byte of 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 byte of 8 bytes of mandatory fields. + printBytes(1); + PRINTBOOL("\t#", TbTable, isBackChainStored); + PRINTBOOL(",", TbTable, isFixup); + PRINTGET(",", TbTable, NumOfFPRsSaved); + OS << "\n"; + + // Print the 6th byte of 8 bytes of mandatory fields. + printBytes(1); + PRINTBOOL("\t#", TbTable, hasExtensionTable); + PRINTBOOL(",", TbTable, hasVectorInfo); + PRINTGET(",", TbTable, NumOfGPRsSaved); + OS << "\n"; + + // Print the 7th byte of 8 bytes of mandatory fields. + printBytes(1); + PRINTGET("\t#", TbTable, NumberOfFixedParms); + OS << "\n"; + + // Print the 8th byte of 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 Disp = + TbTable.getControlledStorageInfoDisp().getValue(); + for (unsigned I = 0; I < Disp.size(); ++I) { + OS << "\n"; + printBytes(4); + OS << "\t ControlledStorageInfoDisp[" << I << "] = " << Disp[I]; + // Print another 4 bytes for 64 bit. + if (Is64Bit) { + OS << "\n"; + printBytes(4); + } + } + } + + // If there is a name, print the function name and function name length. + if (TbTable.isFuncNamePresent()) { + uint16_t FunctionNameLen = TbTable.getFunctionName().getValue().size(); + + assert(FunctionNameLen > 0 && + "The length of the function name must be greater than zero."); + + 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().getValue(); + HasPrinted = true; + } + } + } + + if (TbTable.isAllocaUsed()) { + OS << "\n"; + printBytes(1); + OS << format("\t# AllocaRegister = %u", + TbTable.getAllocaRegister().getValue()); + } + + if (TbTable.getVectorExt()) { + OS << "\n"; + TBVectorExt VecExt = TbTable.getVectorExt().getValue(); + // 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( + TbTable.getExtensionTable().getValue()); + 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 except info displacement"; + } + OS << "\n"; + printBytes(4); + OS << "\t# Except info displacement"; + // Print another 4 bytes for 64 bit.The displacement(address) is 8 bytes in + // 64 bit object file. + if (Is64Bit) { + OS << "\n"; + printBytes(4); + } + } + + if (End == Address + Index) { + OS << "\n"; + return; + } + + // Print all padding. + OS << "\n"; + Size = End - Address; + uint64_t Remaining = Size - Index; + if (Remaining >= 8) { + while (Remaining > 0 && Bytes[Size - Remaining] == 0) + --Remaining; + if (Remaining == 0) { + OS << "\t\t...\n"; + return; + } + } + + uint16_t AlignmentLen = 4 - Index % 4; + printRawData(Bytes.slice(Index, AlignmentLen), Address + Index, OS, STI); + OS << "\t# Paddings\n"; + Index += AlignmentLen; + while (Index < End - Address) { + printRawData(Bytes.slice(Index, 4), Address + Index, OS, STI); + OS << "\t# Padding\n"; + Index += 4; + } +} +#undef PRINTBOOL +#undef PRINTGET +#undef SPLIT +#undef PRINTOPTIONAL 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 @@ -12,9 +12,11 @@ #include "llvm/ADT/StringSet.h" #include "llvm/DebugInfo/DIContext.h" #include "llvm/MC/MCDisassembler/MCDisassembler.h" +#include "llvm/MC/MCSubtargetInfo.h" #include "llvm/Object/Archive.h" #include "llvm/Support/Compiler.h" #include "llvm/Support/DataTypes.h" +#include "llvm/Support/FormattedStream.h" namespace llvm { class StringRef; @@ -59,6 +61,7 @@ extern bool SectionContents; extern bool ShowRawInsn; extern bool SymbolDescription; +extern bool TracebackTable; extern bool SymbolTable; extern std::string TripleName; extern bool UnwindInfo; @@ -158,8 +161,11 @@ unsigned Index); SymbolInfoTy createSymbolInfo(const object::ObjectFile *Obj, const object::SymbolRef &Symbol); +unsigned getInstStartColumn(const MCSubtargetInfo &STI); +void printRawData(llvm::ArrayRef Bytes, uint64_t Address, + llvm::formatted_raw_ostream &OS, + llvm::MCSubtargetInfo const &STI); } // namespace objdump } // end namespace llvm - #endif 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 @@ -45,7 +45,6 @@ #include "llvm/MC/MCInstrInfo.h" #include "llvm/MC/MCObjectFileInfo.h" #include "llvm/MC/MCRegisterInfo.h" -#include "llvm/MC/MCSubtargetInfo.h" #include "llvm/MC/MCTargetOptions.h" #include "llvm/Object/Archive.h" #include "llvm/Object/COFF.h" @@ -181,6 +180,7 @@ bool objdump::Disassemble; bool objdump::DisassembleAll; bool objdump::SymbolDescription; +bool objdump::TracebackTable; static std::vector DisassembleSymbols; static bool DisassembleZeroes; static std::vector DisassemblerOptions; @@ -422,14 +422,32 @@ return false; } -namespace { - /// Get the column at which we want to start printing the instruction /// disassembly, taking into account anything which appears to the left of it. -unsigned getInstStartColumn(const MCSubtargetInfo &STI) { +unsigned objdump::getInstStartColumn(const MCSubtargetInfo &STI) { return !ShowRawInsn ? 16 : STI.getTargetTriple().isX86() ? 40 : 24; } +void objdump::printRawData(ArrayRef Bytes, uint64_t Address, + formatted_raw_ostream &OS, + MCSubtargetInfo const &STI) { + size_t Start = OS.tell(); + if (LeadingAddr) + OS << format("%8" PRIx64 ":", Address); + if (ShowRawInsn) { + 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 = getInstStartColumn(STI); + unsigned Column = OS.tell() - Start; + OS.indent(Column < TabStop - 1 ? TabStop - 1 - Column : 7 - Column % 8); +} + +namespace { + static bool isAArch64Elf(const ObjectFile *Obj) { const auto *Elf = dyn_cast(Obj); return Elf && Elf->getEMachine() == ELF::EM_AARCH64; @@ -469,19 +487,7 @@ SP->printSourceLine(OS, Address, ObjectFilename, LVP); LVP.printBetweenInsts(OS, false); - size_t Start = OS.tell(); - if (LeadingAddr) - OS << format("%8" PRIx64 ":", Address.Address); - if (ShowRawInsn) { - 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 = getInstStartColumn(STI); - unsigned Column = OS.tell() - Start; - OS.indent(Column < TabStop - 1 ? TabStop - 1 - Column : 7 - Column % 8); + printRawData(Bytes, Address.Address, OS, STI); if (MI) { // See MCInstPrinter::printInst. On targets where a PC relative immediate @@ -667,7 +673,7 @@ return BPFPrettyPrinterInst; } } -} +} // namespace static uint8_t getElfSymbolType(const ObjectFile *Obj, const SymbolRef &Sym) { assert(Obj->isELF()); @@ -948,7 +954,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(); @@ -966,7 +972,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); @@ -1394,6 +1400,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; @@ -1441,6 +1453,15 @@ } } + if (DumpTracebackTableForXCOFFFunction && + doesXCOFFTracebackTableBegin(Bytes.slice(Index, 4))) { + dumpTracebackTable(Bytes.slice(Index), + SectionAddr + Index + VMAAdjustment, FOS, End, + *STI, Obj); + Index = End; + continue; + } + // Print local label if there's any. auto Iter = AllLabels.find(SectionAddr + Index); if (Iter != AllLabels.end()) @@ -2518,6 +2539,7 @@ Disassemble = InputArgs.hasArg(OBJDUMP_disassemble); DisassembleAll = InputArgs.hasArg(OBJDUMP_disassemble_all); SymbolDescription = InputArgs.hasArg(OBJDUMP_symbol_description); + TracebackTable = InputArgs.hasArg(OBJDUMP_traceback_table); DisassembleSymbols = commaSeparatedValues(InputArgs, OBJDUMP_disassemble_symbols_EQ); DisassembleZeroes = InputArgs.hasArg(OBJDUMP_disassemble_zeroes); diff --git a/llvm/unittests/Object/XCOFFObjectFileTest.cpp b/llvm/unittests/Object/XCOFFObjectFileTest.cpp --- a/llvm/unittests/Object/XCOFFObjectFileTest.cpp +++ b/llvm/unittests/Object/XCOFFObjectFileTest.cpp @@ -158,10 +158,11 @@ } const uint8_t TBTableData[] = { - 0x00, 0x00, 0x2A, 0x60, 0x80, 0xc0, 0x03, 0x05, 0x48, 0xc4, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x02, 0x05, 0x05, 0x00, 0x00, - 0x06, 0x06, 0x00, 0x00, 0x00, 0x07, 0x61, 0x64, 0x64, 0x5f, 0x61, 0x6c, - 0x6c, 0x1f, 0x02, 0x05, 0xf0, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00}; + 0x00, 0x00, 0x2A, 0x60, 0x80, 0xc0, 0x03, 0x05, 0x48, 0xc4, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x02, + 0x05, 0x05, 0x00, 0x00, 0x06, 0x06, 0x00, 0x00, 0x00, 0x07, + 0x61, 0x64, 0x64, 0x5f, 0x61, 0x6c, 0x6c, 0x1f, 0x02, 0x05, + 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00}; TEST(XCOFFObjectFileTest, XCOFFTracebackTableAPIControlledStorageInfoDisp) { uint64_t Size = sizeof(TBTableData); @@ -175,12 +176,12 @@ ASSERT_TRUE(TT.getControlledStorageInfoDisp()); - SmallVector Disp = TT.getControlledStorageInfoDisp().getValue(); + SmallVector Disp = TT.getControlledStorageInfoDisp().getValue(); ASSERT_EQ(Disp.size(), 2UL); EXPECT_EQ(Disp[0], 0x05050000u); EXPECT_EQ(Disp[1], 0x06060000u); - EXPECT_EQ(Size, 45u); + EXPECT_EQ(Size, 47u); } TEST(XCOFFObjectFileTest, XCOFFTracebackTableAPIAllocaRegister) { @@ -225,15 +226,16 @@ EXPECT_EQ(TT.getExtensionTable().getValue(), ExtendedTBTableFlag::TB_SSP_CANARY); - EXPECT_EQ(Size, 45u); + EXPECT_EQ(Size, 47u); } TEST(XCOFFObjectFileTest, XCOFFTracebackTableAPIHasVectorInfo1) { const uint8_t TBTableData[] = { - 0x00, 0x00, 0x2A, 0x40, 0x80, 0xc0, 0x03, 0x05, 0x48, 0xc5, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x02, 0x05, 0x05, 0x00, 0x00, - 0x06, 0x06, 0x00, 0x00, 0x00, 0x07, 0x61, 0x64, 0x64, 0x5f, 0x61, 0x6c, - 0x6c, 0x11, 0x07, 0x90, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00}; + 0x00, 0x00, 0x2A, 0x40, 0x80, 0xc0, 0x03, 0x05, 0x48, 0xc5, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x02, + 0x05, 0x05, 0x00, 0x00, 0x06, 0x06, 0x00, 0x00, 0x00, 0x07, + 0x61, 0x64, 0x64, 0x5f, 0x61, 0x6c, 0x6c, 0x11, 0x07, 0x90, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00}; uint64_t Size = sizeof(TBTableData); Expected TTOrErr = XCOFFTracebackTable::create(TBTableData, Size); @@ -259,7 +261,7 @@ EXPECT_EQ(TT.getExtensionTable().getValue(), ExtendedTBTableFlag::TB_SSP_CANARY); - EXPECT_EQ(Size, 44u); + EXPECT_EQ(Size, 46u); } TEST(XCOFFObjectFileTest, XCOFFTracebackTableTruncatedAtMandatory) { @@ -388,15 +390,15 @@ } TEST(XCOFFObjectFileTest, XCOFFTracebackTableTruncatedAtExtLongTBTable) { - uint64_t Size = 44; + uint64_t Size = 46; Expected TTOrErr = XCOFFTracebackTable::create(TBTableData, Size); EXPECT_THAT_ERROR( TTOrErr.takeError(), FailedWithMessage( - "unexpected end of data at offset 0x2c while reading [0x2c, 0x2d)")); - EXPECT_EQ(Size, 44u); + "unexpected end of data at offset 0x2e while reading [0x2e, 0x2f)")); + EXPECT_EQ(Size, 46u); } TEST(XCOFFObjectFileTest, XCOFFGetCsectAuxRef32) { @@ -528,11 +530,12 @@ TEST(XCOFFObjectFileTest, XCOFFTracebackTableErrorAtParameterTypeWithVecInfo) { const uint8_t TBTableData[] = { - 0x00, 0x00, 0x2A, 0x40, 0x80, 0xc0, 0x03, 0x05, 0x48, 0xc0, 0x00, 0x10, - 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x02, 0x05, 0x05, 0x00, 0x00, - 0x06, 0x06, 0x00, 0x00, 0x00, 0x07, 0x61, 0x64, 0x64, 0x5f, 0x61, 0x6c, - 0x6c, 0x11, 0x07, 0x90, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00}; - uint64_t Size = 44; + 0x00, 0x00, 0x2A, 0x40, 0x80, 0xc0, 0x03, 0x05, 0x48, 0xc0, + 0x00, 0x10, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x02, + 0x05, 0x05, 0x00, 0x00, 0x06, 0x06, 0x00, 0x00, 0x00, 0x07, + 0x61, 0x64, 0x64, 0x5f, 0x61, 0x6c, 0x6c, 0x11, 0x07, 0x90, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00}; + uint64_t Size = 46; Expected TTOrErr = XCOFFTracebackTable::create(TBTableData, Size); @@ -544,11 +547,12 @@ TEST(XCOFFObjectFileTest, XCOFFTracebackTableErrorAtVecParameterType) { const uint8_t TBTableData[] = { - 0x00, 0x00, 0x2A, 0x40, 0x80, 0xc0, 0x03, 0x05, 0x48, 0xc0, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x02, 0x05, 0x05, 0x00, 0x00, - 0x06, 0x06, 0x00, 0x00, 0x00, 0x07, 0x61, 0x64, 0x64, 0x5f, 0x61, 0x6c, - 0x6c, 0x11, 0x07, 0x90, 0x00, 0x00, 0x20, 0x20, 0x00, 0x00, 0x00}; - uint64_t Size = 44; + 0x00, 0x00, 0x2A, 0x40, 0x80, 0xc0, 0x03, 0x05, 0x48, 0xc0, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x02, + 0x05, 0x05, 0x00, 0x00, 0x06, 0x06, 0x00, 0x00, 0x00, 0x07, + 0x61, 0x64, 0x64, 0x5f, 0x61, 0x6c, 0x6c, 0x11, 0x07, 0x90, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00}; + uint64_t Size = 46; Expected TTOrErr = XCOFFTracebackTable::create(TBTableData, Size);