[AIX][XCOFF] print out the traceback info

[DiggerLin]

Summary

Adding a new option -traceback-table to print out the traceback info of xcoff ojbect file.

[jhenderson]

llvm/tools/llvm-objdump/llvm-objdump.cpp

3242–3243

I'd be okay with moving the "if traceback table, enable --disassemble" logic to here, like the other cases, and dropping the "if XCOFF" check. It will simplify the code slightly, as you can then drop the !TracebackTable check from the below if clause. It also means that disassembly is printed for both XCOFF and non-XCOFF objects in the same invocation of llvm-objdump, which is good for consistency.

(If you do this, it might be worth adding a trivial test case showing that disassembly is enabled for non-XCOFF objects with --traceback-table).

[DiggerLin]

address comment

[DiggerLin]

llvm/lib/Object/XCOFFObjectFile.cpp

1437

thanks ,fixed it.

llvm/tools/llvm-objdump/XCOFFDump.cpp

270

thanks, fixed it.

282

thanks

llvm/tools/llvm-objdump/llvm-objdump.cpp

1747

since the patch is a big patch and last for about 3 years, if I added the "XMC_GL" now, I also need to add a test case for "XMC_GL", it will let the patch bigger. Can I have a separate patch to deal with "XMC_GL"?

1803

in the line 1629 ,End already includes the SectionAddr

uint64_t End = std::min<uint64_t>(SectionAddr + SectSize, StopAddress);

3242–3243

Sorry that I can not understand the comment, I do not change code above your comment.

[jhenderson]

llvm/test/tools/llvm-objdump/XCOFF/disassemble-traceback-table-warning.test

2

5

Nit

15

Nit: normally, there isn't blank lines between parts of YAML.

36

Please a) review the error message content and fix it (I'm not going to point it out - it should be obvious to you with a quick look), b) review the LLVM coding standards for formatting of error and warning messages and fix accordingly. If you're still not sure what needs to be changed, please ask, but I don't want to need to explain everything in detail when things should be obvious.

There's no need for the extra space indentation at the start of the CHECK line, i.e. it should be # WARN: {{.*}} etc. Also, there's no real need for the first {{.*}}: before warning:. Finally, it would be good to check the actual file name after warning:. You can add -D FILE=%t.o to the FileCheck invocation and then use [[FILE]] in place of the {{.*}} for the file path.

llvm/tools/llvm-objdump/llvm-objdump.cpp

3242–3243

In this version of the patch, at line 2834, you add a check for (O->isXCOFF() && TracebackTable) to cause disassembly to be printed. This is different to how other command-line options, such as -S (PrintSource) cause printDisassembly to be called, if --disassemble is specified. I think you should change how --traceback-table causes disassembly to be printed, to be the same as these other options.

By changing this, there are a few effects:

1. You can remove the change you made at line 2834.
2. You can remove the !TracebackTable check at line 3239, since it will be redundant.
3. If you use --traceback-table when you provide a non-XCOFF file, disassembly will be printed, even if the user hasn't specified --disassemble. There should be a new test case to show this behaviour.

Does that make things clearer?

[DiggerLin]

llvm/test/tools/llvm-objdump/XCOFF/disassemble-traceback-table-warning.test

2

thanks.

llvm/tools/llvm-objdump/llvm-objdump.cpp

3242–3243

thanks a lot for explain.

[DiggerLin]

llvm/test/tools/llvm-objdump/XCOFF/disassemble-traceback-table-warning.test

36

sorry for above mistake.

[jhenderson]

As a gentle reminder, please could you make sure you do a personal review of your own code before uploading a patch for review (including updates to an existing patch). If you are working in a company, it is generally a good idea to get a second person to take a look at your code within your company before pushing to the open source community for review. This will help reduce the number of silly mistakes, improving the time it takes to get a patch through review, due to fewer iterations of the patch being needed, and increasing the desire from LLVM community reviewers , such as myself, to review your code (which again will improve the time it takes to get a patch reviewed).

llvm/test/CodeGen/PowerPC/aix-emit-tracebacktable-clobber-register.ll

49

Please make a separate small commit to change the comment here that is emitted.

llvm/test/tools/llvm-objdump/X86/elf-disassemble.test

4

I think this case deserves a comment. To avoid confusing the issue, I'd move the RUN line to the end of the test (after the checks), and add a comment saying that this shows that disassembly is enabled by default for --traceback-table, or something to that effect.

llvm/test/tools/llvm-objdump/XCOFF/disassemble-traceback-table-warning.test

35

I think this line has trailing whitespace you can remove?

llvm/tools/llvm-objdump/llvm-objdump.cpp

3250

You don't need this anymore, because the Disassemble value is checked. See point 2 in my comment above.

[DiggerLin]

1. rebased to latest master , it including change Optional to std::optional. and changing test case based on patch https://reviews.llvm.org/D146071
2. address comment.

[DiggerLin]

In D89049#4276745, @jhenderson wrote:

As a gentle reminder, please could you make sure you do a personal review of your own code before uploading a patch for review (including updates to an existing patch). If you are working in a company, it is generally a good idea to get a second person to take a look at your code within your company before pushing to the open source community for review. This will help reduce the number of silly mistakes, improving the time it takes to get a patch through review, due to fewer iterations of the patch being needed, and increasing the desire from LLVM community reviewers , such as myself, to review your code (which again will improve the time it takes to get a patch reviewed).

I understand your frustration. In fact, every time when I update, I conduct a self-review, but I still have blind spots. I will ask my internal team member to do some review and reduce your work. Sorry for the inconvenient.

llvm/test/CodeGen/PowerPC/aix-emit-tracebacktable-clobber-register.ll

49

yes, I will do it in a separate patch.

llvm/test/tools/llvm-objdump/X86/elf-disassemble.test

4

I put it after the "# RUN: llvm-objdump %t.o -d | FileCheck %s --implicit-check-not=Disassembly" because option "--traceback-table" implies enable -d or "--disassemble" not implies enable "--disassemble-all".

llvm/tools/llvm-objdump/llvm-objdump.cpp

3250

thanks. actually, I take a reivew myself when I tried to update the patch, sorry for I do not find the error. thanks for your time.

[jhenderson]

Mostly looks fine now, apart from a few small things, but someone familiar with XCOFF needs to review this too.

llvm/test/tools/llvm-objdump/X86/elf-disassemble.test

6

Sorry, I should have mentioned this before: I reckon having a bit of extra info in the comment would be useful - see the inline edit.

llvm/tools/llvm-objdump/XCOFFDump.cpp

149

I'm going to assume that XCOFFTracebackTable::create actually needs to modify Size for some other use-case, rather than just taking it by value.

Rather than resetting the Size value a few lines down, I think it might be better to create a copy of the Size variable and pass that in, e.g:

// 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);

153

Don't print trailing whitespace.

171

Sorry, I missed this earlier: I don't like how you print the warning using reportWarning, and then go on to add more content to stderr outside the reportWarning function. This bakes in an assumption that reportWarning actually prints the warning to stderr. This is fine for now, but imagine if somebody wanted to add a --suppress-warnings option to llvm-objdump, or another option that changed where warnings are printed to. In those cases, the main warning would be hidden, but not the body of the message.

Better would be to use a single local stream that includes the initial part of the message and to which the rest of the warning content is printed. You then finish off this block with a call to reportWarning, passing in the whole string you built up, with the complete message.

[stephenpeckham]

The changes to the yaml2obj files allow valid XCOFF files to be generated. With the suggested changes, you can run "ld -r" on the generate object files.

Testing for this patch is difficult because the compiler doesn't generate all combinations of optional traceback-table fields.

llvm/lib/Object/XCOFFObjectFile.cpp

1464

This is not right. The only potential padding in a traceback table is before the EH value (if TB_EH_INFO is set), because the eh value must be aligned on a word boundary.

Removing DH.skip(2) will affect the tests.

An object with vector information and EH information will be displayed incorrectly.

llvm/test/tools/llvm-objdump/XCOFF/disassemble-invalid-traceback-table.test

24

SectionOrLength: 40
SymbolAlignmentAndType: 0x21

will generate a valid XCOFF file

llvm/test/tools/llvm-objdump/XCOFF/disassemble-traceback-table-warning.test

23

SymbolAlignmentAndType: 0x21
SetionOrLength: 0x24

32

SymbolAlignmentAndType: 0x21

llvm/test/tools/llvm-objdump/XCOFF/disassemble-traceback-table.test

29

SymbolAlignmentAndType: 0x21
SectionOrLength:0x24

38

SymbolAlignmentAndType: 0x21
SectionOrLength:0x38

llvm/tools/llvm-objdump/XCOFFDump.cpp

269

It's not critical, but I would use "# " in the output for the array of displacements.

[stephenpeckham]

I['m satisfied with the current state of the code. The updates I suggested to the test cases could be handled in another patch.

llvm/lib/Object/XCOFFObjectFile.cpp

1464

After additional investigation, I retract my previous comment. The LLVM compiler emits padding for the vector extension of the traceback table while the legacy compilers do not.

[DiggerLin]

llvm/tools/llvm-objdump/XCOFFDump.cpp

269

I will use '#' for the first one. ControlledStorageInfoDisp[0]

[DiggerLin]

llvm/test/tools/llvm-objdump/XCOFF/disassemble-invalid-traceback-table.test

7

I will delete the trail white space in next update.

28

I will align the warning(back a space) in next update.

[xingxue]

llvm/lib/Object/XCOFFObjectFile.cpp

1479

Wouldn't this dereference 0 if !ParmsTypeOrError is true?

llvm/tools/llvm-objdump/XCOFFDump.cpp

351

355

377

If the remaining bytes are paddings, why do we differentiate if a padding is zero or not? Can we just print ... or ... # Paddings for paddings?

llvm/tools/llvm-objdump/llvm-objdump.cpp

1803

in the line 1629 ,End already includes the SectionAddr

uint64_t End = std::min<uint64_t>(SectionAddr + SectSize, StopAddress);

@stephenpeckham's comment is still valid. Although End was initialized with SectionAddr added as you pointed out, SectionAddr was later subtracted from it in line 1649.

End -= SectionAddr;

[DiggerLin]

address xing's comment

[DiggerLin]

llvm/lib/Object/XCOFFObjectFile.cpp

1479

ParmsTypeOrError is an object of class Expected.

In https://github.com/llvm/llvm-project/blob/main/llvm/include/llvm/Support/Error.h#L559

there is definition of

  /// Return false if there is an error.
  explicit operator bool() {
#if LLVM_ENABLE_ABI_BREAKING_CHECKS
    Unchecked = HasError;
#endif
    return !HasError;
  }

!ParmsTypeOrError) means there is an error.

llvm/tools/llvm-objdump/XCOFFDump.cpp

377

it just to print out the "... # Paddings" if all the remaining is zero and there are 8 or more bytes remaining in the end.

otherwise, it will print all the bytes out with following code.

uint16_t AlignmentLen = 4 - Index % 4;
 printRawData(Bytes.slice(Index, AlignmentLen), Address + Index, OS, STI);
 OS << "\t# Padding\n";
 Index += AlignmentLen;
 while (Index < End - Address) {
   printRawData(Bytes.slice(Index, 4), Address + Index, OS, STI);
   OS << "\t# Padding\n";
   Index += 4;
 }

llvm/tools/llvm-objdump/llvm-objdump.cpp

1803

good catch , thanks. I will fix it.

[xingxue]

llvm/tools/llvm-objdump/XCOFFDump.cpp

377

I meant to print ... or ...\t# Paddings to indicate the rest are paddings regardless of whether a padding byte is zero or not. @stephenpeckham @jhenderson, what do you think?

[DiggerLin]

llvm/tools/llvm-objdump/XCOFFDump.cpp

377

Print out no-zero value will letting user know what is non-zero value of the padding(in our llvm xcoff ojbect writer, the padding will always zero for sections, if not zero means ,something wrong, and printing out non-zero will let user get more info)
@hubert.reinterpretcast , do you have any option on above xing's comment ?

[DiggerLin]

reformat padding output of traceback table based on the discussion with Xingxue and stephen packham offline.

[xingxue]

Thanks for working on this feature! LGTM once CI is fixed, which is a clang-format issue.

[jhenderson]

I plan on giving this another look through next week, as by then, I should have got past my high priority stuff at work. If you don't mind, please hold off submitting until then.

[DiggerLin]

In D89049#4348866, @jhenderson wrote:

I plan on giving this another look through next week, as by then, I should have got past my high priority stuff at work. If you don't mind, please hold off submitting until then.

OK, I will hold off submitting, thanks for your time.

[DiggerLin]

gentle ping. @jhenderson

[jhenderson]

Apologies @DiggerLin, I didn't have time to look last week as the critical work I was expecting to have finished by early last week has thrown up several issues that I need to resolve urgently. Due to UK bank holidays and personal time off` this week, it won't be until next week before I have time to look at this (at the earliest). I will try to prioritise this in the upstream reviews that I look at first though.

[DiggerLin]

In D89049#4380103, @jhenderson wrote:

Apologies @DiggerLin, I didn't have time to look last week as the critical work I was expecting to have finished by early last week has thrown up several issues that I need to resolve urgently. Due to UK bank holidays and personal time off` this week, it won't be until next week before I have time to look at this (at the earliest). I will try to prioritise this in the upstream reviews that I look at first though.

Thanks a lot , @jhenderson

[jhenderson]

Pre-merge check is complaining about clang-format. Please make sure to run clang-format on all your changes.

There are a lot of cases where you've used the .value() method of std::optional. I believe operator*()/operator->() are more typical ways of achieving the same thing (and according to cppreference.com, may even be more efficient).

llvm/lib/Object/XCOFFObjectFile.cpp

1435

Is this change needed?

1488

Is this an option?

llvm/test/tools/llvm-objdump/XCOFF/disassemble-invalid-traceback-table.test

2

Sorry, didn't spot this before.

llvm/test/tools/llvm-objdump/XCOFF/disassemble-traceback-table-warning.test

23

llvm/test/tools/llvm-objdump/XCOFF/disassemble-traceback-table.test

3–4

I don't think the part about llc is relevant. It will also go out-of-date if llc should ever be able to generate it in the future.

20

How much of this text data is actually important to the test? If a significant proportion of it is, it would be worth giving instructions on how to generate the machine code that this represents.

llvm/tools/llvm-objdump/XCOFFDump.cpp

137

As this is specific to XCOFFObjectFile, I think it would make sense to pass in XCOFFObjectFile, rather than ObjectFile, and do the cast outside this function.

303

?

313

?

318

?

[jhenderson]

llvm/tools/llvm-objdump/XCOFFDump.cpp

131

?

267

278

?

345

?

359–360

I think the comment can be simplified, as suggested. Please reflow appropriately.

377

I don't have a strong opinion on whether non-zero padding should be printed or not. I'm happy to defer to others on this.

383

Don't use else after a return.

390

This is more grammatically correct.

415

I'm not sure this comment makes sense (some of the bytes can be zero, just not the first one), but regardless, I don't think it's really needed.

418

Is this supposed to be duplicated?

420

Don't end a block with a blank line.

llvm/tools/llvm-objdump/llvm-objdump.cpp

1746

[DiggerLin]

llvm/lib/Object/XCOFFObjectFile.cpp

1435

yes , it is not necessary .

1488

yes. thanks

llvm/test/tools/llvm-objdump/XCOFF/disassemble-traceback-table.test

3–4

agree.

llvm/tools/llvm-objdump/XCOFFDump.cpp

278

thanks

418

yes, the code will make the output as

# CHECK-NEXT:      5b: 00               # Padding
# CHECK-NEXT:        ...
# CHECK-NEXT:      68: 01 00 00 00
# CHECK-NEXT:      72: 00 00 00 00
# CHECK-NEXT:        ...
# CHECK-NEXT:      90: 01 00 00 00

without the duplication code, above will be changed to

# CHECK-NEXT:      5b: 00               # Padding
# CHECK-NEXT:        ...
# CHECK-NEXT:      68: 01 00 00 00
# CHECK-NEXT:        ...
# CHECK-NEXT:      90: 01 00 00 00

[DiggerLin]

llvm/test/tools/llvm-objdump/XCOFF/disassemble-traceback-table.test

20

there are two functions in the test case. it test different traceback table fields. and it also test different padding format.

[DiggerLin]

address James' comment

[MaskRay]

llvm/tools/llvm-objdump/XCOFFDump.cpp

166

We don't usually add parens for (A + B) > C and ... ? : A + B.

176

Nit: here and throughout, you can use '\n' as it compiles to less machine code and is slightly faster.

[jhenderson]

llvm/test/tools/llvm-objdump/XCOFF/disassemble-traceback-table.test

42–45

(Strictly, you could use "data are" and be grammatically correct, but it sounds weird to a native speaker)

llvm/tools/llvm-objdump/XCOFFDump.cpp

355

415

Ping this comment?

418

The logic here is fairly intertwined, so I might be misunderstanding something, but if the aim is to ensure that there is always a set of zeros before the "...", I'm not convinced that this code achieves that. As far as I can tell, the first four bytes are printed and definitely have at least one non-zero byte involved. The second call though could print non-zero bytes too, so you'd end up with, e.g.:

5b: 00               # Padding
  ...
68: 01 00 00 00
72: 00 00 00 01
  ...
90: 01 00 00 00

If the next 12 bytes are then all 0, the ... will still be printed. I think?

418

I've gone back over the logic again and I'm finding it really hard to figure out. I'd like to summarise what my understanding of the goals of this code actually are, to make sure I understand things correctly:

1. Print a representation of the padding bytes from the end of the parsed data to the end of the full data.
2. Data is printed out in blocks of 4 bytes, aligned to the word boundary.
3. The first line may have fewer than 4 bytes, if the parsed data didn't end on a word boundary.
4. Consecutive blocks of 12 zeros or more are skipped and replaced with "...".
5. Any such skipped block must be preceded by a block of 4 bytes that are all zero.

Is this correct?

[DiggerLin]

llvm/test/tools/llvm-objdump/XCOFF/disassemble-traceback-table.test

42–45

thanks

llvm/tools/llvm-objdump/XCOFFDump.cpp

176

thanks

415

yes, some bytes can be zero in the code

// Print four bytes which has non-zero value.
 if (Print4BytesOrFewer())
   return;

I delete the comment. thanks

418

it will not print as above.

after print
72: 00 00 00 01

there is code " Index -= NextLineBytesNum;"

while (Index < Size) {
   Index -= NextLineBytesNum;

to reset the index to 0x72, so there is not more than 12 consecutive bytes of zeros.
it will print next line , like

5b: 00               # Padding
  ...
0x68: 01 00 00 00
0x72: 00 00 00 01 
0x76: 00 00 00 00  
   ...
0x90: 01 00 00 00

418

yes. you are correct!

Any such skipped block must be preceded by a block of 4 bytes that are all zero.

except for the first align padding like (which do not need a block of 4 bytes at first align padding)

5b: 00               # Padding
  ...

[jhenderson]

llvm/tools/llvm-objdump/XCOFFDump.cpp

355

You missed the space between "displacement" and "(address)". Unless that's a function call (i.e. a "function" called "displacement" with a "parameter" called "address"), there should always be a space before the opening parenthesis in English prose.

372

Having read through this code a few more times, I think we can simplify it in a few ways. Here's my attempt. There might be bugs/typos in it, but hopefully it gets the gist of what I'm thinking, even if it's not 100%.

Some things that motivated this:

• The initial if (Size - Index <= 4) line looks unnecessary to me. Everything else will just work wtihout it, I believe.
• Without too much difficulty, we can get rid of the special alignment printing.
• Print4BytesOrFewer is just PrintBytes with some extra stuff, so it should probably call PrintBytes.
• I also am not convinced that the Size == Index line belongs in Print4BytesOrFewer, although I see why it's being done. I think it would be more readable in the main code logic to pull it out.
• As Print4BytesOrFewer is specific to the Padding, it might be worth renaming it for clarity, e.g. PrintPaddingLine. However, after rewriting the code to all be in a single loop, I realised that we only needed one call to PrintBytes, so the lambda can disappear completely.

// Print all padding.
const char *LineSuffix = "\t# Padding\n";
while(Index < Size) {
  // Determine how many bytes to print (4, except for the first line, which will be just enough to align to the word boundary).
  uint64_t PrintSize = 4 - Index % 4;
  PrintSize = std::min(PrintSize, Size - Index);

  // Identify if the to-be printed line contains only zero-valued bytes.
  bool LastLinePrintedWasAllZero = true;
  for (size_t I = Index; I < Index + PrintSize; ++Index)
    LastLinePrintedWasAllZero &= Bytes[I] == 0;

  // Print the line.
  PrintBytes(PrintSize);
  OS << LineSuffix;
  LineSuffix = "\n";

  // If three or more consecutive lines would only contain 0-valued bytes, replace all after the first with "...".
  if (LastLinePrintedWasAllZero) {
    // Look to find the next non-zero byte. 
    auto NextNonZero = std::find_if_not(Bytes.begin() + Index, Bytes.begin() + Size, [](uint8_t Byte){ return Byte == 0; });
    // The next two lines won't both be all zero, so proceed as normal.
    if (NextNonZero < Bytes.begin() + Index + 8)
      continue;

    // The next two lines would both be all zero. Skip them and all subsequent zero-valued lines. Make sure we only skip full lines by rounding down to the word boundary (the last line is always considered a full line).
    OS << std::string(8, ' ') << "...\n";
    Index += std::distance(Bytes.begin() + Index, NextNonZero);
    if (Index == Size)
      return;
    Index = Index - Index % 4;
  }
}

394

Don't start blocks with a blank line.

[DiggerLin]

llvm/tools/llvm-objdump/XCOFFDump.cpp

372

thanks, I got some ideal from your code to simplify my code. But I kept most of my code.

for I think some part of my code is more efficient.

for example:

// Identify if the to-be printed line contains only zero-valued bytes.
  bool LastLinePrintedWasAllZero = true;
  for (size_t I = Index; I < Index + PrintSize; ++Index)
    LastLinePrintedWasAllZero &= Bytes[I] == 0;

  // If three or more consecutive lines would only contain 0-valued bytes, replace all after the first with "...".
  if (LastLinePrintedWasAllZero) {
    // Look to find the next non-zero byte. 
    auto NextNonZero = std::find_if_not(Bytes.begin() + Index, Bytes.begin() + Size, [](uint8_t Byte){ return Byte == 0; });

    // The next two lines won't both be all zero, so proceed as normal.
if (NextNonZero < Bytes.begin() + Index + 8)
      continue;

    // The next two lines would both be all zero. Skip them and all subsequent zero-valued lines. Make sure we only skip full lines by rounding down to the word boundary (the last line is always considered a full line).
    OS << std::string(8, ' ') << "...\n";

I use

// Set the 'CurIndex' back to the first byte of the previously printed line.

uint64_t CurIndex = Index - PrintSize;

// Count the number of consecutive bytes of zeros starting from the first
// byte of the previously printed line.
while (Bytes[CurIndex] == 0 && CurIndex < Size)
  ++CurIndex;

// If three or more consecutive lines would only contain 0-valued bytes,
// replace all after the first with "...".
if (CurIndex >= Index + 8) {
   OS << std::string(8, ' ') << "...\n";

and in the code

   // The next two lines won't both be all zero, so proceed as normal.
if (NextNonZero < Bytes.begin() + Index + 8)
      continue;

we already know that "the two line won't both be all zero" , we just need to print out immediately without to check all zero again.

I use code to print out the two lines immediately

while (Index < CurIndex )
   if (Print4BytesOrFewer())
     return;

[DiggerLin]

gentle ping @jhenderson

[jhenderson]

Ah, sorry. I wrote a lengthy comment last week with another suggested approach, but somehow failed to submit it.

llvm/tools/llvm-objdump/XCOFFDump.cpp

372

I see your point, but I'm still not a fan of how the code you've written is structured, as it makes it difficult to understand and see what is going on. How does the following attempt look? This ensures we inspect each line to see if it is all 0 or not once only, but also ensures we only have one location where we call PrintBytes, and only one Index tracker.

// Print all padding.
const char *LineSuffix = "\t# Padding\n";
auto IsWordZero = [&](uint64_t WordPos) {
  if (WordPos >= Size)
    return true;
  uint64_t LineLength = 4 - Index % 4;
  LineLength = std::min(4, Size - WordPos);
  return std::all_of(Bytes + WordPos, Bytes + WordPos + LineLength, [](uint8_t Byte){ return Byte == 0; });
};
bool AreWordsZero = { IsWordZero(Index), IsWordZero(Index + 4), IsWordZero(Index + 8) };
bool ShouldPrintCurrentWord = 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 = 4 - Index % 4;
  LineLength = std::min(LineLength , Size - Index);
  if (ShouldPrintLine) {
    // Print the line.
    printRawData(Bytes.slice(Index, LineLength), Address + Index, OS, STI);
    OS << LineSuffix;
    LineSuffix = "\n";
  }

  if (Index + LineLength == 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 (!ShouldPrintLine && !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);
  Index += LineLength;
}

This essentially uses a sliding window approach to keep track of the upcoming words and whether they are all zero or not, whilst also tracking whether a line should be printed or not. In addition to checking each byte only once to see if it is all zero, this code also only has only one place where Index is updated (hence the use of printRawBytes rather than PrintBytes), and one place where the data is printed (those two points are the main issues I have with your current code).

[DiggerLin]

llvm/tools/llvm-objdump/XCOFFDump.cpp

372

thanks, changed as suggestion.

[MaskRay]

llvm/test/CodeGen/PowerPC/aix-emit-tracebacktable-clobber-register.ll

12

You may want --strict-whitespace as well, otherwise the space formatting change in the code cannot be tested.

[MaskRay]

I just took a rough look. The new code and test look good to me.

llvm/tools/llvm-objdump/XCOFFDump.cpp

163

delete blank line

164

omit braces

187

move this to the first use site and delete the blank line after the declaration.

actually, it may be better to avoid this used-only-once variable.

278

delete blank line

llvm/tools/llvm-objdump/llvm-objdump.cpp

1746

Is there a risk that SI-1 == size_t(-1) ?

[MaskRay]

1 .print out the traceback info

if there is need of original object file of xcoff-invalid-traceback-table.o and xcoff-traceback-table.o when review, I send the the object file through email.

This patch adds a major feature but the description seems a bit too concise.

[DiggerLin]

address MaskRay's comment

[DiggerLin]

llvm/tools/llvm-objdump/llvm-objdump.cpp

1746

I do not think there is a risk

for (size_t SI = 0, SE = Symbols.size(); SI != SE;) {
    // Advance SI past all the symbols starting at the same address,
    // and make an ArrayRef of them.
    unsigned FirstSI = SI;
    uint64_t Start = Symbols[SI].Addr;
    ArrayRef<SymbolInfoTy> SymbolsHere;
    while (SI != SE && Symbols[SI].Addr == Start)
      ++SI;

while (SI != SE && Symbols[SI].Addr == Start)
  ++SI;

must be run when the code first time enter the loop. so after the ++SI, the SI must be large than 0.

[DiggerLin]

rebase the patch

[jhenderson]

Apart from a couple of nits, LGTM!! Thanks for the patience, and sorry I wasn't able to review particularly efficiently.

Please don't land this without further sign off from @MaskRay and possibly @stephenpeckham.

llvm/test/CodeGen/PowerPC/aix-emit-tracebacktable-clobber-register.ll

12

Did you miss this comment?

llvm/tools/llvm-objdump/XCOFFDump.cpp

287

FWIW, I think the blank line that was removed here is okay to be present. I think @MaskRay was suggesting that a variable that is declared and then used in an if statement immediately afterwards should not have a blank line between it and the if statement.

A blank line after a non-trivial if block is usually a good thing, if there is code after the if statement.

[DiggerLin]

add --strict-whitespace for test case aix-emit-tracebacktable-clobber-register.ll @MaskRay

[DiggerLin]

In D89049#4454961, @jhenderson wrote:

Apart from a couple of nits, LGTM!! Thanks for the patience, and sorry I wasn't able to review particularly efficiently.

I appreciate your thorough review and taking the time to provide your inputs. I have addressed the nits you mentioned, and I'm glad to hear that you found the overall work to be acceptable. I completely understand that reviewing is time-consuming, so there's no need to apologize. Your comments and patience are greatly appreciated! , Thanks for your times. @jhenderson

[MaskRay]

I only spot checked this and this looks good.

llvm/test/tools/llvm-objdump/XCOFF/disassemble-traceback-table.test

56

79

ditto. align

llvm/tools/llvm-objdump/ObjdumpOpts.td

66

I think it's time to use Group<grp_xcoff>;, then you can omit This option is for XCOFF files only since the options will be listed with a --help section named XCOFF. See grp_mach_o for an example.

[jhenderson]

llvm/tools/llvm-objdump/ObjdumpOpts.td

66

Makes sense to me (probably it should be a subsequent patch though).

[DiggerLin]

llvm/test/tools/llvm-objdump/XCOFF/disassemble-traceback-table.test

56

the original output as

00000000 (idx: 0) .AddNum[PR]:
       0: 94 21 ff c0   stwu 1, -64(1)
       4: 00 00 00 00   # Traceback table start


00000024 (idx: 2) .foo[PR]:
      24: 93 e1 ff fc   stw 31, -4(1)
      28: 00 00 00 00   # Traceback table start
      2c: 00            # Version = 0

00000000 (idx: 0) .AddNum[PR]:
00000024 (idx: 2) .foo[PR]:

are label, there start from column zero.

and the test case use --strict-whitespace
so I have to keep as

CHECK:00000000 (idx: 0) .AddNum[PR]:

llvm/tools/llvm-objdump/ObjdumpOpts.td

66

thanks. I will do it in subsequent patch for this comment.

[stephenpeckham]

I've skimmed through the latest changes and I didn't see any additional problems.

llvm/docs/CommandGuide/llvm-objdump.rst

 
 XCOFF ONLY OPTIONS AND COMMANDS
 ---------------------------------
 
 .. option:: --symbol-description
 
   Add symbol description to disassembly output.
 
+.. option:: --traceback-table
+
+  Decode traceback table in disassembly output. Implies :option:`--disassemble`.
+
 BUGS
 ----
 
 To report bugs, please visit <https://github.com/llvm/llvm-project/labels/tools:llvm-objdump/>.
 
 SEE ALSO
 --------
 
 :manpage:`llvm-nm(1)`, :manpage:`llvm-otool(1)`, :manpage:`llvm-readelf(1)`,
 :manpage:`llvm-readobj(1)`

llvm/include/llvm/Object/XCOFFObjectFile.h

 
 class TBVectorExt {
   uint16_t Data;
   SmallString<32> VecParmsInfo;
 
   TBVectorExt(StringRef TBvectorStrRef, Error &Err);
 
 public:
   static Expected<TBVectorExt> create(StringRef TBvectorStrRef);
   uint8_t getNumberOfVRSaved() const;
   bool isVRSavedOnStack() const;
   bool hasVarArgs() const;
   uint8_t getNumberOfVectorParms() const;
   bool hasVMXInstruction() const;
   SmallString<32> getVectorParmsInfo() const { return VecParmsInfo; };
 };
 
 /// This class provides methods to extract traceback table data from a buffer.
 /// The various accessors may reference the buffer provided via the constructor.
 
 class XCOFFTracebackTable {
   const uint8_t *const TBPtr;
+  bool Is64BitObj;
   std::optional<SmallString<32>> ParmsType;
   std::optional<uint32_t> TraceBackTableOffset;
   std::optional<uint32_t> HandlerMask;
   std::optional<uint32_t> NumOfCtlAnchors;
   std::optional<SmallVector<uint32_t, 8>> ControlledStorageInfoDisp;
   std::optional<StringRef> FunctionName;
   std::optional<uint8_t> AllocaRegister;
   std::optional<TBVectorExt> VecExt;
   std::optional<uint8_t> ExtensionTable;
+  std::optional<uint64_t> 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.
   /// Returns an XCOFFTracebackTable upon successful parsing, otherwise an
   /// Error is returned.
   ///
   /// \param[in] Ptr
   ///   A pointer that points just past the initial 4 bytes of zeros at the
   ///   beginning of an XCOFF Traceback Table.
   ///
   /// \param[in, out] Size
   ///    A pointer that points to the length of the XCOFF Traceback Table.
   ///    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<XCOFFTracebackTable> create(const uint8_t *Ptr,
-                                              uint64_t &Size);
+  static Expected<XCOFFTracebackTable>
+  create(const uint8_t *Ptr, uint64_t &Size, bool Is64Bits = false);
   uint8_t getVersion() const;
   uint8_t getLanguageID() const;
 
   bool isGlobalLinkage() const;
   bool isOutOfLineEpilogOrPrologue() const;
   bool hasTraceBackTableOffset() const;
   bool isInternalProcedure() const;
   bool hasControlledStorage() const;
public:
   bool isLRSaved() const;
 
   bool isBackChainStored() const;
   bool isFixup() const;
   uint8_t getNumOfFPRsSaved() const;
 
   bool hasVectorInfo() const;
   bool hasExtensionTable() const;
   uint8_t getNumOfGPRsSaved() const;
 
   uint8_t getNumberOfFixedParms() const;
 
   uint8_t getNumberOfFPParms() const;
   bool hasParmsOnStack() const;
 
   const std::optional<SmallString<32>> &getParmsType() const {
     return ParmsType;
public:
   }
   const std::optional<uint8_t> &getAllocaRegister() const {
     return AllocaRegister;
   }
   const std::optional<TBVectorExt> &getVectorExt() const { return VecExt; }
   const std::optional<uint8_t> &getExtensionTable() const {
     return ExtensionTable;
   }
+  const std::optional<uint64_t> &getEhInfoDisp() const { return EhInfoDisp; }
 };
 
 bool doesXCOFFTracebackTableBegin(ArrayRef<uint8_t> Bytes);
 } // namespace object
 } // namespace llvm
 
 #endif // LLVM_OBJECT_XCOFFOBJECTFILE_H

llvm/lib/Object/XCOFFObjectFile.cpp

 }
 
 bool TBVectorExt::hasVMXInstruction() const {
   return GETVALUEWITHMASK(HasVMXInstructionMask);
 }
 #undef GETVALUEWITHMASK
 #undef GETVALUEWITHMASKSHIFT
 
-Expected<XCOFFTracebackTable> XCOFFTracebackTable::create(const uint8_t *Ptr,
-                                                          uint64_t &Size) {
+Expected<XCOFFTracebackTable>
+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<uint8_t>(Ptr, Size), /*IsLittleEndian=*/false,
                    /*AddressSize=*/0);
   DataExtractor::Cursor Cur(/*Offset=*/0);
 
   // Skip 8 bytes of mandatory fields.
   DE.getU64(Cur);
 
XCOFFTracebackTable::XCOFFTracebackTable(const uint8_t *Ptr, uint64_t &Size,
 
   if (Cur && isInterruptHandler())
     HandlerMask = DE.getU32(Cur);
 
   if (Cur && hasControlledStorage()) {
     NumOfCtlAnchors = DE.getU32(Cur);
     if (Cur && NumOfCtlAnchors) {
       SmallVector<uint32_t, 8> Disp;
       Disp.reserve(*NumOfCtlAnchors);
       for (uint32_t I = 0; I < NumOfCtlAnchors && Cur; ++I)
         Disp.push_back(DE.getU32(Cur));
       if (Cur)
         ControlledStorageInfoDisp = std::move(Disp);
     }
   }
 
   if (Cur && isFuncNamePresent()) {
     uint16_t FunctionNameLen = DE.getU16(Cur);
     if (Cur)
if (Cur && hasVectorInfo()) {
     if (Cur) {
       Expected<TBVectorExt> TBVecExtOrErr = TBVectorExt::create(VectorExtRef);
       if (!TBVecExtOrErr) {
         Err = TBVecExtOrErr.takeError();
         return;
       }
       VecExt = TBVecExtOrErr.get();
       VectorParmsNum = VecExt->getNumberOfVectorParms();
+      // Skip two bytes of padding after vector info.
+      DE.skip(Cur, 2);
     }
   }
 
   // As long as there is no fixed-point or floating-point parameter, this
   // field remains not present even when hasVectorInfo gives true and
   // indicates the presence of vector parameters.
   if (Cur && (FixedParmsNum + FloatingParmsNum) > 0) {
     Expected<SmallString<32>> ParmsTypeOrError =
         hasVectorInfo()
             ? parseParmsTypeWithVecInfo(ParamsTypeValue, FixedParmsNum,
                                         FloatingParmsNum, VectorParmsNum)
             : parseParmsType(ParamsTypeValue, FixedParmsNum, FloatingParmsNum);
 
     if (!ParmsTypeOrError) {
       Err = ParmsTypeOrError.takeError();
       return;
     }
     ParmsType = ParmsTypeOrError.get();
   }
 
-  if (Cur && hasExtensionTable())
+  if (Cur && hasExtensionTable()) {
     ExtensionTable = DE.getU8(Cur);
 
+    if (*ExtensionTable & ExtendedTBTableFlag::TB_EH_INFO) {
+      // eh_info displacement must be 4-byte aligned.
+      Cur.seek(alignTo(Cur.tell(), 4));
+      EhInfoDisp = Is64BitObj ? DE.getU64(Cur) : DE.getU32(Cur);
+    }
+  }
   if (!Cur)
     Err = Cur.takeError();
 
   Size = Cur.tell();
 }
 
 #define GETBITWITHMASK(P, X)                                                   \
   (support::endian::read32be(TBPtr + (P)) & (TracebackTable::X))

llvm/test/CodeGen/PowerPC/aix-emit-tracebacktable-clobber-register.ll

 ; RUN: llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff -mcpu=pwr4 \
 ; RUN:     -mattr=+altivec -vec-extabi -xcoff-traceback-table=true < %s | \
 ; RUN:   FileCheck --check-prefixes=CHECK-ASM,COMMON %s
 
 ; RUN: llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff -function-sections \
 ; 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 --match-full-lines --strict-whitespace --check-prefixes=OBJ-DIS,NO-FUNC-SEC %s
+
+; RUN: llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff -mcpu=pwr4 \
+; RUN:     -mattr=+altivec -vec-extabi -xcoff-traceback-table=true -function-sections -filetype=obj -o %t_func.o  < %s
+; RUN: llvm-objdump -d --traceback-table --symbol-description %t_func.o | \
+; RUN:   FileCheck --match-full-lines --strict-whitespace --check-prefixes=OBJ-DIS,FUNC-SEC %s
+
 define float @bar() #0 {
 entry:
   %fvalue = alloca float, align 4
   %taken = alloca i32, align 4
   %data = alloca i32, align 4
   store float 1.000000e+00, ptr %fvalue, align 4
   %0 = load float, ptr %fvalue, align 4
   %1 = call float asm "fneg $0,$1\0A\09", "=b,b,~{f31},~{f30},~{f29},~{f28},~{f27}"(float %0)
entry:
   %taken = alloca <4 x i32>, align 16
   %data = alloca <4 x i32>, align 16
   store <4 x i32> <i32 123, i32 0, i32 0, i32 0>, ptr %data, align 16
   call void asm sideeffect "", "~{v31},~{v30},~{v29},~{v28}"() 
   %0 = load <4 x i32>, ptr %taken, align 16
   ret <4 x i32> %0
 }
 
 ; COMMON:       .vbyte  4, 0x00000000                   # Traceback table begin
 ; COMMON-NEXT:  .byte   0x00                            # Version = 0
 ; COMMON-NEXT:  .byte   0x09                            # Language = CPlusPlus
 ; COMMON-NEXT:  .byte   0x22                            # -IsGlobaLinkage, -IsOutOfLineEpilogOrPrologue
 ; COMMON-NEXT:                                        # +HasTraceBackTableOffset, -IsInternalProcedure
 ; COMMON-NEXT:                                        # -HasControlledStorage, -IsTOCless
 ; COMMON-NEXT:                                        # +IsFloatingPointPresent
 ; COMMON-NEXT:                                        # -IsFloatingPointOperationLogOrAbortEnabled
 ; COMMON-NEXT:  .byte   0x40                            # -IsInterruptHandler, +IsFunctionNamePresent, -IsAllocaUsed

 ; COMMON-NEXT:  .vbyte  4, 0
 ; COMMON-NEXT:  .vbyte  4, 0
 ; CHECK-ASM-NEXT:   .csect .text[PR],5
 ; CHECK-FUNC-NEXT:  .csect .foov[PR],5
 ; COMMON-NEXT:                                         # -- End function
 ; COMMON:       .toc
 ; COMMON:      L..C2:
 ; COMMON-NEXT:  .tc __ehinfo.1[TC],__ehinfo.1
+
+
+; OBJ-DIS:      9c: 00 00 00 00   # Traceback table start
+; 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: 05             # -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
+; NO-FUNC-SEC-NEXT:      b1: 60 00 00       # Padding
+; NO-FUNC-SEC-NEXT:      b4: 00 60 00 00  
+; NO-FUNC-SEC-NEXT:      b8: 00 60 00 00  
+; NO-FUNC-SEC-NEXT:      bc: 00 00 00 00  
+; FUNC-SEC-NEXT:      b1: 00 00 00      # Padding
+; FUNC-SEC-NEXT:        ...
+
+; OBJ-DIS:     11c: 00 00 00 00   # Traceback table start
+; 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: 00             # -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 eh info displacement
+; OBJ-DIS-NEXT:     13c: 00 00 00 08    # EH info displacement

llvm/test/tools/llvm-objdump/X86/elf-disassemble.test

 ## Show that disassembly is printed correctly, for only the desired sections.
 # RUN: yaml2obj %s -o %t.o
 # RUN: llvm-objdump %t.o -d | FileCheck %s --implicit-check-not=Disassembly
 # RUN: llvm-objdump %t.o --disassemble-all | FileCheck %s --check-prefixes=CHECK,ALL
 
+## Show that disassembly is enabled by default for --traceback-table, even for non-XCOFF objects.
+# RUN: llvm-objdump %t.o --traceback-table  | FileCheck %s --implicit-check-not=Disassembly
+
 # CHECK:       Disassembly of section .executable:
 # CHECK-EMPTY:
 # CHECK-NEXT:  0000000000001000 <.executable>:
 # CHECK-NEXT:         0: 90                            nop
 # ALL-EMPTY:
 # ALL-NEXT:    Disassembly of section .writable:
 # ALL-EMPTY:
 # ALL-NEXT:    0000000000002000 <.writable>:

llvm/test/tools/llvm-objdump/XCOFF/disassemble-invalid-traceback-table.test

+## Test that parsing of an invalid XCOFF traceback table with a too
+## big function name length causes an out of range error.
+
+# RUN: yaml2obj %s -o %t.o
+# RUN: llvm-objdump -d --traceback-table --symbol-description %t.o 2>&1 | \
+# RUN:   FileCheck -DFILE=%t.o --implicit-check-not="warning:" --check-prefixes=WARN %s
+
+--- !XCOFF
+FileHeader:
+  MagicNumber:       0x1DF
+Sections:
+  - Name:            .text
+    Flags:           [ STYP_TEXT ]
+    SectionData:     "4e8000200000000000002240800102075a000000000000880073666f6f0000000000000000000000"
+Symbols:
+  - Name:            .AddNum
+    Value:           0
+    Section:         .text
+    Type:            0x20
+    StorageClass:    C_EXT
+    AuxEntries:
+      - Type:                   AUX_CSECT
+        SectionOrLength: 0x28
+        SymbolAlignmentAndType: 0x21
+        StorageMappingClass:    XMC_PR
+
+# WARN:      warning: '[[FILE]]': failure parsing traceback table with address: 0x4
+# WARN-NEXT: >>> unexpected end of data at offset 0x24 while reading [0x12, 0x85)
+# WARN-NEXT: >>> Raw traceback table data is:
+# WARN-NEXT:       8: 00 00 22 40
+# WARN-NEXT:       c: 80 01 02 07
+# WARN-NEXT:      10: 5a 00 00 00
+# WARN-NEXT:      14: 00 00 00 88
+# WARN-NEXT:      18: 00 73 66 6f
+# WARN-NEXT:      1c: 6f 00 00 00
+# WARN-NEXT:         ...

llvm/test/tools/llvm-objdump/XCOFF/disassemble-traceback-table-warning.test

+## Test that "llvm-objdump --traceback-table" warn when a function name's length is 0.
+
+# RUN: yaml2obj %s -o %t.o
+# RUN: llvm-objdump -d --traceback-table --symbol-description %t.o 2>&1 |\
+# RUN:   FileCheck -DFILE=%t.o --implicit-check-not="warning:" --check-prefixes=WARN %s
+
+--- !XCOFF
+FileHeader:
+  MagicNumber:       0x1DF
+Sections:
+  - Name:            .text
+    Flags:           [ STYP_TEXT ]
+    SectionData:     "9421ffc0000000000000204080000201000000000000000400004164644e756d00000000"
+Symbols:
+  - Name:            .AddNum
+    Value:           0
+    Section:         .text
+    Type:            0x20
+    StorageClass:    C_EXT
+    AuxEntries:
+      - Type:                   AUX_CSECT
+        SectionOrLength:        0x24
+        SymbolAlignmentAndType: 0x21
+        StorageMappingClass:    XMC_PR
+
+# WARN: warning: '[[FILE]]': the length of the function name must be greater than zero if the isFuncNamePresent bit is set in the traceback table

llvm/test/tools/llvm-objdump/XCOFF/disassemble-traceback-table.test

+## Test that "llvm-objdump --traceback-table" decodes the ControlledStorageInfo,
+## AllocaRegister, and extension table of the traceback table.
+
+# RUN: yaml2obj %s -o %t.o
+# RUN: llvm-objdump -d --traceback-table --symbol-description %t.o | \
+# RUN:   FileCheck --match-full-lines --strict-whitespace %s
+
+## Show that --traceback-table implies --disassemble.
+# RUN: llvm-objdump --traceback-table --symbol-description %t.o | \
+# RUN:   FileCheck --match-full-lines --strict-whitespace %s
+
+--- !XCOFF
+FileHeader:
+  MagicNumber:       0x1DF
+Sections:
+  - Name:            .text
+    Flags:           [ STYP_TEXT ]
+    SectionData:     "9421ffc0000000000000204080000201000000000000000400064164644e756d0000000093e1fffc0000000000002a6080c202072c90000000000004000000036f0000010000000a000001000003666f6f1f0203c000000000002000000000000000000000000000010000000000000100000000000000000000000000123400000000"
+Symbols:
+  - Name:            .AddNum
+    Value:           0
+    Section:         .text
+    Type:            0x20
+    StorageClass:    C_EXT
+    AuxEntries:
+      - Type:                   AUX_CSECT
+        SectionOrLength:        0x24
+        SymbolAlignmentAndType: 0x21
+        StorageMappingClass:    XMC_PR
+  - Name:            .foo
+    Value:           0x24
+    Section:         .text
+    Type:            0x20
+    StorageClass:    C_EXT
+    AuxEntries:
+      - Type:                   AUX_CSECT
+        SectionOrLength:        0x5F
+        SymbolAlignmentAndType: 0x21
+        StorageMappingClass:    XMC_PR
+
+## The above .text section data is generated using the compiler command:
+##   xlc -o test.o -c test.c
+## We also modified the binary content of the traceback table in the object file to add vector information
+## for function "foo", including ControlledStorageInfo, AllocaRegister, and ExtensionTable.
+
+## test.c:
+## int AddNum(int i,intj) {
+##  return i+j;
+## }
+
+## float foo(int i1,float f1,double d1,int i2, float f2) {
+##    return i1+f1+d1+i2+f2;
+##   }
+
+# CHECK:00000000 (idx: 0) .AddNum[PR]:
+# CHECK-NEXT:       0: 94 21 ff c0    stwu 1, -64(1)
+# CHECK-NEXT:       4: 00 00 00 00    # Traceback table start
+# CHECK-NEXT:       8: 00             # Version = 0
+# CHECK-NEXT:       9: 00             # Language = C
+# CHECK-NEXT:       a: 20             # -isGlobalLinkage, -isOutOfLineEpilogOrPrologue
+# CHECK-NEXT:                           +hasTraceBackTableOffset, -isInternalProcedure
+# CHECK-NEXT:                           -hasControlledStorage, -isTOCless
+# CHECK-NEXT:                           -isFloatingPointPresent
+# CHECK-NEXT:                           -isFloatingPointOperationLogOrAbortEnabled
+# CHECK-NEXT:       b: 40             # -isInterruptHandler, +isFuncNamePresent, -isAllocaUsed
+# CHECK-NEXT:                           OnConditionDirective = 0, -isCRSaved, -isLRSaved
+# CHECK-NEXT:       c: 80             # +isBackChainStored, -isFixup, NumOfFPRsSaved = 0
+# CHECK-NEXT:       d: 00             # -hasExtensionTable, -hasVectorInfo, NumOfGPRsSaved = 0
+# CHECK-NEXT:       e: 02             # NumberOfFixedParms = 2
+# CHECK-NEXT:       f: 01             # NumberOfFPParms = 0, +hasParmsOnStack
+# CHECK-NEXT:      10: 00 00 00 00    # ParmsType = i, i
+# CHECK-NEXT:      14: 00 00 00 04    # TraceBackTableOffset = 4
+# CHECK-NEXT:      18: 00 06          # FunctionNameLen = 6
+# CHECK-NEXT:      1a: 41 64 64 4e    # FunctionName = AddNum
+# CHECK-NEXT:      1e: 75 6d        
+# CHECK-NEXT:      20: 00 00 00 00    # Padding
+
+# CHECK:00000024 (idx: 2) .foo[PR]:
+# CHECK-NEXT:      24: 93 e1 ff fc    stw 31, -4(1)
+# CHECK-NEXT:      28: 00 00 00 00    # Traceback table start
+# CHECK-NEXT:      2c: 00             # Version = 0
+# CHECK-NEXT:      2d: 00             # Language = C
+# CHECK-NEXT:      2e: 2a             # -isGlobalLinkage, -isOutOfLineEpilogOrPrologue
+# CHECK-NEXT:                           +hasTraceBackTableOffset, -isInternalProcedure
+# CHECK-NEXT:                           +hasControlledStorage, -isTOCless
+# CHECK-NEXT:                           +isFloatingPointPresent
+# CHECK-NEXT:                           -isFloatingPointOperationLogOrAbortEnabled
+# CHECK-NEXT:      2f: 60             # -isInterruptHandler, +isFuncNamePresent, +isAllocaUsed
+# CHECK-NEXT:                           OnConditionDirective = 0, -isCRSaved, -isLRSaved
+# CHECK-NEXT:      30: 80             # +isBackChainStored, -isFixup, NumOfFPRsSaved = 0
+# CHECK-NEXT:      31: c2             # +hasExtensionTable, +hasVectorInfo, NumOfGPRsSaved = 2
+# CHECK-NEXT:      32: 02             # NumberOfFixedParms = 2
+# CHECK-NEXT:      33: 07             # NumberOfFPParms = 3, +hasParmsOnStack
+# CHECK-NEXT:      34: 2c 90 00 00    # ParmsType = i, f, d, i, f, v
+# CHECK-NEXT:      38: 00 00 00 04    # TraceBackTableOffset = 4
+# CHECK-NEXT:      3c: 00 00 00 03    # NumOfCtlAnchors = 3
+# CHECK-NEXT:      40: 6f 00 00 01    # ControlledStorageInfoDisp[0] = 1862270977
+# CHECK-NEXT:      44: 00 00 00 0a      ControlledStorageInfoDisp[1] = 10
+# CHECK-NEXT:      48: 00 00 01 00      ControlledStorageInfoDisp[2] = 256
+# CHECK-NEXT:      4c: 00 03          # FunctionNameLen = 3
+# CHECK-NEXT:      4e: 66 6f 6f       # FunctionName = foo
+# CHECK-NEXT:      51: 1f             # AllocaRegister = 31
+# CHECK-NEXT:      52: 02             # NumberOfVRSaved = 0, +isVRSavedOnStack, -hasVarArgs
+# CHECK-NEXT:      53: 03             # NumberOfVectorParms = 1, +hasVMXInstruction
+# CHECK-NEXT:      54: c0 00 00 00    # VectorParmsInfoString = vf
+# CHECK-NEXT:      58: 00 00          # Padding
+# CHECK-NEXT:      5a: 20             # ExtensionTable = TB_SSP_CANARY
+# CHECK-NEXT:      5b: 00             # Padding
+# CHECK-NEXT:        ...
+# CHECK-NEXT:      68: 01 00 00 00  
+# CHECK-NEXT:      6c: 00 00 00 01  
+# CHECK-NEXT:      70: 00 00 00 00  
+# CHECK-NEXT:        ...
+# CHECK-NEXT:      7c: 00 12 34 00  
+# CHECK-NEXT:      80: 00 00 00 00  

llvm/tools/llvm-objdump/ObjdumpOpts.td

def disassemble : Flag<["--"], "disassemble">,
   HelpText<"Disassemble all executable sections found in the input files">;
 def : Flag<["-"], "d">, Alias<disassemble>, HelpText<"Alias for --disassemble">;
 
 def disassemble_all : Flag<["--"], "disassemble-all">,
   HelpText<"Disassemble all sections found in the input files">;
 def : Flag<["-"], "D">, Alias<disassemble_all>,
   HelpText<"Alias for --disassemble-all">;
 
 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 in disassembly. Implies --disassemble. "
+           "This option is for XCOFF files only">;
 
 def disassemble_symbols_EQ : Joined<["--"], "disassemble-symbols=">,
   HelpText<"List of symbols to disassemble. "
            "Accept demangled names when --demangle is "
            "specified, otherwise accept mangled names">;
 
 def disassemble_zeroes : Flag<["--"], "disassemble-zeroes">,
   HelpText<"Do not skip blocks of zeroes when disassembling">;
 def : Flag<["-"], "z">, Alias<disassemble_zeroes>,
   HelpText<"Alias for --disassemble-zeroes">;
 
 def disassembler_options_EQ : Joined<["--"], "disassembler-options=">,

llvm/tools/llvm-objdump/SourcePrinter.cpp

 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/Support/FormatVariadic.h"
 
 #define DEBUG_TYPE "objdump"
 
 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 == std::nullopt)
     return false;
   return LocExpr.Range->SectionIndex == Addr.SectionIndex &&
          LocExpr.Range->LowPC <= Addr.Address &&
          LocExpr.Range->HighPC > Addr.Address;
 }
 

llvm/tools/llvm-objdump/XCOFFDump.h

 //===-- XCOFFDump.h ---------------------------------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_OBJDUMP_XCOFFDUMP_H
 #define LLVM_TOOLS_LLVM_OBJDUMP_XCOFFDUMP_H
 
 #include "llvm/Object/XCOFFObjectFile.h"
 
 namespace llvm {
 
+class formatted_raw_ostream;
+class MCSubtargetInfo;
 struct SymbolInfoTy;
 
 namespace objdump {
 std::optional<XCOFF::StorageMappingClass>
 getXCOFFSymbolCsectSMC(const object::XCOFFObjectFile &Obj,
                        const object::SymbolRef &Sym);
 
 std::optional<object::SymbolRef>
 getXCOFFSymbolContainingSymbolRef(const object::XCOFFObjectFile &Obj,
                                   const object::SymbolRef &Sym);
 
 bool isLabel(const object::XCOFFObjectFile &Obj, const object::SymbolRef &Sym);
 
 std::string getXCOFFSymbolDescription(const SymbolInfoTy &SymbolInfo,
                                       StringRef SymbolName);
 
 Error getXCOFFRelocationValueString(const object::XCOFFObjectFile &Obj,
                                     const object::RelocationRef &RelRef,
                                     llvm::SmallVectorImpl<char> &Result);
+
+void dumpTracebackTable(ArrayRef<uint8_t> Bytes, uint64_t Address,
+                        formatted_raw_ostream &OS, uint64_t End,
+                        const MCSubtargetInfo &STI,
+                        const object::XCOFFObjectFile *Obj);
 } // namespace objdump
 } // namespace llvm
 #endif

llvm/tools/llvm-objdump/XCOFFDump.cpp

 /// This file implements the XCOFF-specific dumper for llvm-objdump.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "XCOFFDump.h"
 
 #include "llvm-objdump.h"
 #include "llvm/Demangle/Demangle.h"
+#include "llvm/MC/MCInstPrinter.h"
+#include "llvm/MC/MCSubtargetInfo.h"
+#include "llvm/Support/Casting.h"
+#include "llvm/Support/Endian.h"
+#include "llvm/Support/FormattedStream.h"
+#include <algorithm>
 
 using namespace llvm;
 using namespace llvm::object;
+using namespace llvm::XCOFF;
+using namespace llvm::support;
 
 Error objdump::getXCOFFRelocationValueString(const XCOFFObjectFile &Obj,
                                              const RelocationRef &Rel,
                                              SmallVectorImpl<char> &Result) {
   symbol_iterator SymI = Rel.getSymbol();
   if (SymI == Obj.symbol_end())
     return make_error<GenericBinaryError>(
         "invalid symbol reference in relocation entry",
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

llvm/tools/llvm-objdump/llvm-objdump.h

 //===--- llvm-objdump.h -----------------------------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_OBJDUMP_LLVM_OBJDUMP_H
 #define LLVM_TOOLS_LLVM_OBJDUMP_LLVM_OBJDUMP_H
 
 #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;
 class Twine;
 
 namespace opt {
 class Arg;
 } // namespace opt

 extern bool PrintLines;
 extern bool PrintSource;
 extern bool PrivateHeaders;
 extern bool Relocations;
 extern bool SectionHeaders;
 extern bool SectionContents;
 extern bool ShowRawInsn;
 extern bool SymbolDescription;
+extern bool TracebackTable;
 extern bool SymbolTable;
 extern std::string TripleName;
 extern bool UnwindInfo;
 
 extern StringSet<> FoundSectionSet;
 
 typedef std::function<bool(llvm::object::SectionRef const &)> FilterPredicate;
 

 }
 
 void invalidArgValue(const opt::Arg *A);
 
 std::string getFileNameForError(const object::Archive::Child &C,
                                 unsigned Index);
 SymbolInfoTy createSymbolInfo(const object::ObjectFile &Obj,
                               const object::SymbolRef &Symbol);
+unsigned getInstStartColumn(const MCSubtargetInfo &STI);
+void printRawData(llvm::ArrayRef<uint8_t> Bytes, uint64_t Address,
+                  llvm::formatted_raw_ostream &OS,
+                  llvm::MCSubtargetInfo const &STI);
 
 } // namespace objdump
 } // end namespace llvm
 
 #endif

llvm/tools/llvm-objdump/llvm-objdump.cpp

 #include "llvm/MC/MCDisassembler/MCDisassembler.h"
 #include "llvm/MC/MCDisassembler/MCRelocationInfo.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstPrinter.h"
 #include "llvm/MC/MCInstrAnalysis.h"
 #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/MC/TargetRegistry.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/BuildID.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Object/COFFImportFile.h"
 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/Object/ELFTypes.h"

 static uint64_t AdjustVMA;
 static bool AllHeaders;
 static std::string ArchName;
 bool objdump::ArchiveHeaders;
 bool objdump::Demangle;
 bool objdump::Disassemble;
 bool objdump::DisassembleAll;
 bool objdump::SymbolDescription;
+bool objdump::TracebackTable;
 static std::vector<std::string> DisassembleSymbols;
 static bool DisassembleZeroes;
 static std::vector<std::string> DisassemblerOptions;
 DIDumpType objdump::DwarfDumpType;
 static bool DynamicRelocations;
 static bool FaultMapSection;
 static bool FileHeaders;
 bool objdump::SectionContents;
if (Type == MachO::X86_64_RELOC_UNSIGNED && Rel.d.a > 0) {
       if (PrevType == MachO::X86_64_RELOC_SUBTRACTOR)
         return true;
     }
   }
 
   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;
 }
 
+static void AlignToInstStartColumn(size_t Start, const MCSubtargetInfo &STI,
+                                   raw_ostream &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);
+}
+
+void objdump::printRawData(ArrayRef<uint8_t> 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);
+  }
+  AlignToInstStartColumn(Start, STI, OS);
+}
+
+namespace {
+
 static bool isAArch64Elf(const ObjectFile &Obj) {
   const auto *Elf = dyn_cast<ELFObjectFileBase>(&Obj);
   return Elf && Elf->getEMachine() == ELF::EM_AARCH64;
 }
 
 static bool isArmElf(const ObjectFile &Obj) {
   const auto *Elf = dyn_cast<ELFObjectFileBase>(&Obj);
   return Elf && Elf->getEMachine() == ELF::EM_ARM;
static void printRelocation(formatted_raw_ostream &OS, StringRef FileName,
   if (Error E = getRelocationValueString(Rel, Val))
     reportError(std::move(E), FileName);
   OS << (Is64Bits || !LeadingAddr ? "\t\t" : "\t\t\t");
   if (LeadingAddr)
     OS << format(Fmt.data(), Address);
   OS << Name << "\t" << Val;
 }
 
-static void AlignToInstStartColumn(size_t Start, const MCSubtargetInfo &STI,
-                                   raw_ostream &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);
-}
-
 class PrettyPrinter {
 public:
   virtual ~PrettyPrinter() = default;
   virtual void
   printInst(MCInstPrinter &IP, const MCInst *MI, ArrayRef<uint8_t> Bytes,
             object::SectionedAddress Address, formatted_raw_ostream &OS,
             StringRef Annot, MCSubtargetInfo const &STI, SourcePrinter *SP,
             StringRef ObjectFilename, std::vector<RelocationRef> *Rels,
             LiveVariablePrinter &LVP) {
     if (SP && (PrintSource || PrintLines))
       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);
-    }
-
-    AlignToInstStartColumn(Start, STI, OS);
+    printRawData(Bytes, Address.Address, OS, STI);
 
     if (MI) {
       // See MCInstPrinter::printInst. On targets where a PC relative immediate
       // is relative to the next instruction and the length of a MCInst is
       // difficult to measure (x86), this is the address of the next
       // instruction.
       uint64_t Addr =
           Address.Address + (STI.getTargetTriple().isX86() ? Bytes.size() : 0);
PrettyPrinter &selectPrettyPrinter(Triple const &Triple) {
   case Triple::thumbeb:
     return ARMPrettyPrinterInst;
   case Triple::aarch64:
   case Triple::aarch64_be:
   case Triple::aarch64_32:
     return AArch64PrettyPrinterInst;
   }
 }
-}
+} // namespace
 
 static uint8_t getElfSymbolType(const ObjectFile &Obj, const SymbolRef &Sym) {
   assert(Obj.isELF());
   if (auto *Elf32LEObj = dyn_cast<ELF32LEObjectFile>(&Obj))
     return unwrapOrError(Elf32LEObj->getSymbol(Sym.getRawDataRefImpl()),
                          Obj.getFileName())
         ->getType();
   if (auto *Elf64LEObj = dyn_cast<ELF64LEObjectFile>(&Obj))

 }
 
 SymbolInfoTy objdump::createSymbolInfo(const ObjectFile &Obj,
                                        const SymbolRef &Symbol) {
   const StringRef FileName = Obj.getFileName();
   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<XCOFFObjectFile>(Obj);
     DataRefImpl SymbolDRI = Symbol.getRawDataRefImpl();
 
     const uint32_t SymbolIndex = XCOFFObj.getSymbolIndex(SymbolDRI.p);
     std::optional<XCOFF::StorageMappingClass> Smc =
         getXCOFFSymbolCsectSMC(XCOFFObj, Symbol);
     return SymbolInfoTy(Addr, Name, Smc, SymbolIndex,
                         isLabel(XCOFFObj, Symbol));
   } else if (Obj.isXCOFF()) {
     const SymbolRef::Type SymType = unwrapOrError(Symbol.getType(), FileName);
     return SymbolInfoTy(Addr, Name, SymType, true);
   } else
     return SymbolInfoTy(Addr, Name,
                         Obj.isELF() ? getElfSymbolType(Obj, Symbol)
                                     : (uint8_t)ELF::STT_NOTYPE);
 }
 
 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, std::nullopt, std::nullopt, false);
   else
     return SymbolInfoTy(Addr, Name, Type);
 }
 
 static void
 collectBBAddrMapLabels(const std::unordered_map<uint64_t, BBAddrMap> &AddrToBBAddrMap,
                        uint64_t SectionAddr, uint64_t Start, uint64_t End,
for (size_t SI = 0, SE = Symbols.size(); SI != SE;) {
 
       if (DisassembleAsData) {
         dumpELFData(SectionAddr, Index, End, Bytes);
         Index = End;
         continue;
       }
 
       bool DumpARMELFData = false;
+      bool DumpTracebackTableForXCOFFFunction =
+          Obj.isXCOFF() && Section.isText() && TracebackTable &&
+          Symbols[SI - 1].XCOFFSymInfo.StorageMappingClass &&
+          (*Symbols[SI - 1].XCOFFSymInfo.StorageMappingClass == XCOFF::XMC_PR);
+
       formatted_raw_ostream FOS(outs());
 
       std::unordered_map<uint64_t, std::string> AllLabels;
       std::unordered_map<uint64_t, std::vector<std::string>> BBAddrMapLabels;
       if (SymbolizeOperands) {
         collectLocalBranchTargets(Bytes, MIA, DisAsm, IP, PrimarySTI,
                                   SectionAddr, Index, End, AllLabels);
         collectBBAddrMapLabels(AddrToBBAddrMap, SectionAddr, Index, End,
for (size_t SI = 0, SE = Symbols.size(); SI != SE;) {
             if (size_t N =
                     countSkippableZeroBytes(Bytes.slice(Index, MaxOffset))) {
               FOS << "\t\t..." << '\n';
               Index += N;
               continue;
             }
           }
 
+          if (DumpTracebackTableForXCOFFFunction &&
+              doesXCOFFTracebackTableBegin(Bytes.slice(Index, 4))) {
+            dumpTracebackTable(Bytes.slice(Index),
+                               SectionAddr + Index + VMAAdjustment, FOS,
+                               SectionAddr + End + VMAAdjustment, *STI,
+                               cast<XCOFFObjectFile>(&Obj));
+            Index = End;
+            continue;
+          }
+
           // Print local label if there's any.
           auto Iter1 = BBAddrMapLabels.find(SectionAddr + Index);
           if (Iter1 != BBAddrMapLabels.end()) {
             for (StringRef Label : Iter1->second)
               FOS << "<" << Label << ">:\n";
           } else {
             auto Iter2 = AllLabels.find(SectionAddr + Index);
             if (Iter2 != AllLabels.end())
static void parseObjdumpOptions(const llvm::opt::InputArgList &InputArgs) {
   parseIntArg(InputArgs, OBJDUMP_adjust_vma_EQ, AdjustVMA);
   AllHeaders = InputArgs.hasArg(OBJDUMP_all_headers);
   ArchName = InputArgs.getLastArgValue(OBJDUMP_arch_name_EQ).str();
   ArchiveHeaders = InputArgs.hasArg(OBJDUMP_archive_headers);
   Demangle = InputArgs.hasArg(OBJDUMP_demangle);
   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);
   if (const opt::Arg *A = InputArgs.getLastArg(OBJDUMP_dwarf_EQ)) {
     DwarfDumpType = StringSwitch<DIDumpType>(A->getValue())
                         .Case("frames", DIDT_DebugFrame)
                         .Default(DIDT_Null);
     if (DwarfDumpType == DIDT_Null)
int main(int argc, char **argv) {
   // Removes trailing separators from prefix.
   while (!Prefix.empty() && sys::path::is_separator(Prefix.back()))
     Prefix.pop_back();
 
   if (AllHeaders)
     ArchiveHeaders = FileHeaders = PrivateHeaders = Relocations =
         SectionHeaders = SymbolTable = true;
 
-  if (DisassembleAll || PrintSource || PrintLines ||
+  if (DisassembleAll || PrintSource || PrintLines || TracebackTable ||
       !DisassembleSymbols.empty())
     Disassemble = true;
 
   if (!ArchiveHeaders && !Disassemble && DwarfDumpType == DIDT_Null &&
       !DynamicRelocations && !FileHeaders && !PrivateHeaders && !RawClangAST &&
       !Relocations && !SectionHeaders && !SectionContents && !SymbolTable &&
       !DynamicSymbolTable && !UnwindInfo && !FaultMapSection && !Offloading &&
       !(MachOOpt &&
         (Bind || DataInCode || ChainedFixups || DyldInfo || DylibId ||
          DylibsUsed || ExportsTrie || FirstPrivateHeader ||
          FunctionStartsType != FunctionStartsMode::None || IndirectSymbols ||
          InfoPlist || LazyBind || LinkOptHints || ObjcMetaData || Rebase ||
          Rpaths || UniversalHeaders || WeakBind || !FilterSections.empty()))) {
     T->printHelp(ToolName);
     return 2;
   }

llvm/unittests/Object/XCOFFObjectFileTest.cpp

TEST(XCOFFObjectFileTest, XCOFFTracebackTableAPIParmsType) {
   ASSERT_THAT_EXPECTED(TTOrErr4, Succeeded());
   XCOFFTracebackTable TT4 = *TTOrErr4;
   ASSERT_TRUE(TT4.getParmsType());
   EXPECT_EQ(*TT4.getParmsType(),
             "f, f, d, i, i, f, f, f, f, f, f, f, f, f, f, f, f, ...");
 }
 
 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);
   Expected<XCOFFTracebackTable> TTOrErr =
       XCOFFTracebackTable::create(TBTableData, Size);
   ASSERT_THAT_EXPECTED(TTOrErr, Succeeded());
   XCOFFTracebackTable TT = *TTOrErr;
   EXPECT_TRUE(TT.hasControlledStorage());
   ASSERT_TRUE(TT.getNumOfCtlAnchors());
   EXPECT_EQ(*TT.getNumOfCtlAnchors(), 2u);
 
   ASSERT_TRUE(TT.getControlledStorageInfoDisp());
 
   SmallVector<uint32_t, 8> Disp = *TT.getControlledStorageInfoDisp();
 
   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) {
   uint64_t Size = sizeof(TBTableData);
   Expected<XCOFFTracebackTable> TTOrErr =
       XCOFFTracebackTable::create(TBTableData, Size);
   ASSERT_THAT_EXPECTED(TTOrErr, Succeeded());
   XCOFFTracebackTable TT = *TTOrErr;
TEST(XCOFFObjectFileTest, XCOFFTracebackTableAPIHasVectorInfo) {
   EXPECT_EQ(VecExt.getNumberOfVectorParms(), 2u);
   EXPECT_TRUE(VecExt.hasVMXInstruction());
 
   EXPECT_EQ(VecExt.getVectorParmsInfo(), "vf, vf");
 
   ASSERT_TRUE(TT.getExtensionTable());
   EXPECT_EQ(*TT.getExtensionTable(), 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<XCOFFTracebackTable> TTOrErr =
       XCOFFTracebackTable::create(TBTableData, Size);
   ASSERT_THAT_EXPECTED(TTOrErr, Succeeded());
   XCOFFTracebackTable TT = *TTOrErr;
 
   ASSERT_TRUE(TT.getParmsType());
   EXPECT_EQ(*TT.getParmsType(), "v, i, f, i, d, i, v, v");
 
   ASSERT_TRUE(TT.getVectorExt());
   TBVectorExt VecExt = *TT.getVectorExt();
 
   EXPECT_EQ(VecExt.getNumberOfVRSaved(), 4);
   EXPECT_FALSE(VecExt.isVRSavedOnStack());
   EXPECT_TRUE(VecExt.hasVarArgs());
 
   EXPECT_EQ(VecExt.getNumberOfVectorParms(), 3u);
   EXPECT_TRUE(VecExt.hasVMXInstruction());
 
   EXPECT_EQ(VecExt.getVectorParmsInfo(), "vi, vs, vc");
 
   ASSERT_TRUE(TT.getExtensionTable());
   EXPECT_EQ(*TT.getExtensionTable(), ExtendedTBTableFlag::TB_SSP_CANARY);
 
-  EXPECT_EQ(Size, 44u);
+  EXPECT_EQ(Size, 46u);
 }
 
 TEST(XCOFFObjectFileTest, XCOFFTracebackTableTruncatedAtMandatory) {
   uint64_t Size = 6;
   Expected<XCOFFTracebackTable> TTOrErr =
       XCOFFTracebackTable::create(TBTableData, Size);
   EXPECT_THAT_ERROR(
       TTOrErr.takeError(),
TEST(XCOFFObjectFileTest, XCOFFTracebackTableTruncatedAtVectorInfoParmsInfo) {
   EXPECT_THAT_ERROR(
       TTOrErr.takeError(),
       FailedWithMessage(
           "unexpected end of data at offset 0x2b while reading [0x26, 0x2c)"));
   EXPECT_EQ(Size, 38u);
 }
 
 TEST(XCOFFObjectFileTest, XCOFFTracebackTableTruncatedAtExtLongTBTable) {
-  uint64_t Size = 44;
+  uint64_t Size = 46;
   Expected<XCOFFTracebackTable> 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) {
   uint8_t XCOFF32Binary[] = {
       // File header.
       0x01, 0xdf, 0x00, 0x01, 0x5f, 0x58, 0xf8, 0x95, 0x00, 0x00, 0x00, 0x3c,
       0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
 
TEST(XCOFFObjectFileTest, XCOFFTracebackTableErrorAtParameterType) {
   EXPECT_THAT_ERROR(
       TTOrErr.takeError(),
       FailedWithMessage("ParmsType encodes can not map to ParmsNum parameters "
                         "in parseParmsType."));
 }
 
 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<XCOFFTracebackTable> TTOrErr =
       XCOFFTracebackTable::create(TBTableData, Size);
 
   EXPECT_THAT_ERROR(
       TTOrErr.takeError(),
       FailedWithMessage("ParmsType encodes can not map to ParmsNum parameters "
                         "in parseParmsTypeWithVecInfo."));
 }
 
 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<XCOFFTracebackTable> TTOrErr =
       XCOFFTracebackTable::create(TBTableData, Size);
 
   EXPECT_THAT_ERROR(TTOrErr.takeError(),
                     FailedWithMessage("ParmsType encodes more than ParmsNum "
                                       "parameters in parseVectorParmsType."));
 }