[AIX] llvm-readobj support a new option --exception-section for xcoff object file.

[DiggerLin]

Summary

llvm-readobj support a new option --exception-section for xcoff object file.

https://www.ibm.com/docs/en/aix/7.2?topic=formats-xcoff-object-file-format#XCOFF__iua3i23ajbau

[pscoro]

llvm/tools/llvm-readobj/XCOFFDumper.cpp

145

On the example I am running this just prints "Symbol Index: )", although I checked the individual SymIdx and SymName variables and they have the right values.

[DiggerLin]

fixed Paul Scoropan's report bug. thanks for Paul

[jhenderson]

I did wonder whether this should really just be reusing the existing --unwind option, but as I understand it, the XCOFF exception section isn't really about unwinding the stack or anything along those lines. Is that correct?

Rather than canned binaries, I think it wouldn't be too hard to add yaml2obj support for exception sections, so that you can create the input at test time.

Your commit message should be a grammatically correct sentence, with leading capital letter (i.e. "Add a new ..."), much like comments.

I've not really looked at the XCOFFObjectFile code changes or the testing just yet. Please don't forget to test error/warning paths, to show that the code can handle malformed inputs.

llvm/docs/CommandGuide/llvm-readobj.rst

335

I think you can simplify to the inline suggestion.

llvm/lib/Object/XCOFFObjectFile.cpp

94

This file hasn't been clang-formatted. Please fix.

1050–1053

I recommend folding this if into the assertions, possibly like the inline suggestion. Otherwise you have an empty if without assertions, which seems messy (although the optimizer should get rid of it in this case).

llvm/test/tools/llvm-readobj/XCOFF/exception-section.test

10

I think it would be more similar to other dumping formats to print this row as:
Symbol: .bar (12).

llvm/tools/llvm-readobj/XCOFFDumper.cpp

143

unwrapOrError should be considered deprecated in llvm-readobj, as it stops llvm-readobj from continuing, which is not useful for dumping tools, especially given that the error in this case won't prevent other files or sections from being dumped. Instead, prefer reporting problems as warnings (via reportUniqueWarning or equivalent). See the ELF dumper for good examples.

152

Ditto: don't use unwrapOrError.

llvm/tools/llvm-readobj/llvm-readobj.cpp

510–511

Is there a reasson you're not putting this up with the other XCOFF-specific dumping option?

[DiggerLin]

In D133030#3763317, @jhenderson wrote:

I did wonder whether this should really just be reusing the existing --unwind option, but as I understand it, the XCOFF exception section isn't really about unwinding the stack or anything along those lines. Is that correct?

yes, you are correct, the exception section is not for unwind. so we can not use the --unwind for it.

Rather than canned binaries, I think it wouldn't be too hard to add yaml2obj support for exception sections, so that you can create the input at test time.

yes, if I do the yaml2obj first , I need a tools to decode the object file generated by yaml2obj when I add a test for the yaml2obj, but there is not now. My propose is three steps:

1. using canned binaries in this patch,
2. write a second patch to yaml2obj support for exception sections(using the llvm-readobj --exception-section to test the second patch).
3. have another patch to modify the llvm/test/tools/llvm-readobj/XCOFF/exception-section.test which use the yaml2obj to generate xcoff object with exception sections and replace the canned binaries in the test case.

Your commit message should be a grammatically correct sentence, with leading capital letter (i.e. "Add a new ..."), much like comments.

I've not really looked at the XCOFFObjectFile code changes or the testing just yet. Please don't forget to test error/warning paths, to show that the code can handle malformed inputs.

[DiggerLin]

address James's comment.

llvm/lib/Object/XCOFFObjectFile.cpp

1050–1053

thanks for explain. fixed

llvm/test/tools/llvm-readobj/XCOFF/exception-section.test

10

according to https://www.ibm.com/docs/en/aix/7.2?topic=formats-xcoff-object-file-format#XCOFF__iua3i23ajbau

e_addr.e_symndx+
Symbol table index for function

the value of the field is for symbol index, so putting symbol index at first and putting symbol name in brackets are reasonable.

llvm/tools/llvm-readobj/llvm-readobj.cpp

510–511

If there are several options in the command line at the same time. I want to keep the output as order of content xcoff object file as much as possible.
If you do not agree with this, I can put the all the XCOFF-specific dumping option together.

[jhenderson]

In D133030#3763938, @DiggerLin wrote:

In D133030#3763317, @jhenderson wrote:

Rather than canned binaries, I think it wouldn't be too hard to add yaml2obj support for exception sections, so that you can create the input at test time.

yes, if I do the yaml2obj first , I need a tools to decode the object file generated by yaml2obj when I add a test for the yaml2obj, but there is not now. My propose is three steps:

1. using canned binaries in this patch,
2. write a second patch to yaml2obj support for exception sections(using the llvm-readobj --exception-section to test the second patch).
3. have another patch to modify the llvm/test/tools/llvm-readobj/XCOFF/exception-section.test which use the yaml2obj to generate xcoff object with exception sections and replace the canned binaries in the test case.

I think my preferred option would be to use yaml2bj/obj2yaml to test each other, with an additional manual step for now:

1. Write yaml2obj code for the desired behaviour, and obj2yaml code which can convert the object back into YAML, which you can then check with FileCheck.
2. After running the test, use your system tools to manually check the temporary object file created by the test looks correct. If so, land this change.
3. In a second patch (this one), use yaml2obj to create your test inputs and verify that llvm-readobj can dump them correctly.
4. You could also manually verify using your system tools that the input looks as you would expect again.
5. Add llvm-readobj checks to your yaml2obj tests.

llvm/test/tools/llvm-readobj/XCOFF/exception-section.test

10

This isn't any different to how ELF is usually dumped. For example, when dumping ELF relocations (see for example https://github.com/llvm/llvm-project/blob/main/llvm/test/tools/llvm-readobj/ELF/relocations.test), the ELF format refers to a symbol index, but the printout displays the symbol name. In general, if a user is trying to find out information, it is more likely that they are interested in the symbol not the index of that symbol, so printing the name first is the more useful thing.

llvm/test/tools/llvm-readobj/XCOFF/invalid-exception-section.test

2

4

dd isn't used anywhere else in the tests as far as I can tell, which means adding it might break some users who do not have that tool. Instead, you can use python to achieve the same effect, by reading in the file and modifying the specific bytes.

(Although this is where yaml2obj is more useful)

5

Use echo not printf.

8

llvm/tools/llvm-readobj/XCOFFDumper.cpp

144

I don't think you've tested this warning?

llvm/tools/llvm-readobj/llvm-readobj.cpp

510–511

Okay, your explanation makes sense, thanks. Please put it in comments somewhere in the file, e.g. "this data appears early in XCOFF files so display it first" etc.

[jhenderson]

llvm/include/llvm/Object/XCOFFObjectFile.h

231

Why the public directive? It makes it look like the fields are private, except they aren't because this is a struct.

238

I'd also consider replacing Reason with Reason != 0. This makes it a mirror of the getSymbolIndex function.

249–250

Why the duplication? In fact, why the extern template at all?

llvm/lib/Object/XCOFFObjectFile.cpp

407

I think it would help the understandability of these changes if the refactoring was split into a separate prerequisite patch. You'd thus have two patches (well three if you include the yaml2obj patch discussed out of line):

1. NFC refactoring to make the loader section code reusable.
2. Implementation of the exception section.

430

436–437

I'd use the slightly shorter names SectionOffset and SectionSize.

442

Don't start blocks with a blank line.

446–451

All the magic numbers make this code completely opaque. Why "3", why "16", why "1" etc. I think you'd be better off assigning them to const variables so you can name them.

Also, I think the consensus is that lambdas should have name style like variables, because they are function objects rather than pure functions. In other words, I'd name this GetSectionName (no need to abbreviate).

808–812

Could a template function (or auto lambda) allow you to avoid this duplication (passing in the sections32/sections64 functions as parameters)?

1044

Probably delete this blank line.

1050–1051

This assertion is independent of finding the section, so should probably the first line of the function.

[DiggerLin]

address comment.

llvm/include/llvm/Object/XCOFFObjectFile.h

231

just for readable to separate the data member and function.

249–250

"extern template" means the template is initiated somewhere.
for the template has member function. without the "extern template". there maybe member function maybe be initiate in different compile unit. it waste the the code.

llvm/lib/Object/XCOFFObjectFile.cpp

407

the function getLoaderSectionAddress is mapped into getSectionFileOffsetToRawData(XCOFF::STYP_LOADER).

and the function getSectionFileOffsetToRawData has more functionality than only get getLoaderSectionAddress. if split into two patch. I do not think it is NFC patch.

446–451

the functionality of the mapping the value SectionTypeFlags into string.

https://github.com/llvm/llvm-project/blob/main/llvm/include/llvm/BinaryFormat/XCOFF.h

808–812

good idea.

[jhenderson]

llvm/include/llvm/Object/XCOFFObjectFile.h

231

just for readable to separate the data member and function.

The addition of an explicit and unnecessary public makes things less readable for me, not more. If you wish to explicitly call out that the method is public, put the method before the members and label the whole struct with public.

Also nit: add a blank line between your methods, where your methods are multi line.

249–250

We don't bother with extern templates in many other places, so I'm not sure why you felt that this particular case needed it?

Actually, after writing that, I see it's the same for other XCOFFObjectFile declarations, so it's probably not worth me worrying about in this patch, although it's still the case that there's limited use of this feature outside this file. I'd still like to know why you feel like these structs need it specifically, when in most cases within LLVM we don't bother.

llvm/lib/Object/XCOFFObjectFile.cpp

407

All the more reason to split this up then: if the first patch isn't a pure refactor, and adds new functionality, that functionality should be added and tested for the loader section. If on the other hand it is not used, the additional functionality can be added in the second patch.

446–451

Correct me if I'm wrong, but it looks to me like this is just an over-complicated way of mapping the section type values to section names. Wouldn't a switch statement be significantly clearer? Something like:

StringRef getSectionName(int32_t SectType) {
  switch(SectType) {
  case STYP_PAD:
    return "pad";
  case STYPE_DWARF:
    return "dwarf";
  ...
  default:
    return "<unknown: " + SectType + ">";
  }
}

(The default case covers the situation where a user provides a type that isn't a known type, but could be replaced by something else appropriate).

llvm/test/tools/llvm-readobj/XCOFF/exception-section.test

19

It would probably help readers/maintainers if this had some small comments in the lines immediately below with arrows pointing up at the start of each field in the data. There are several examples of this in the yaml2obj DWARF tests.

Something like:

SectionData: "0000000000000000003400030000005c0002000000010000000001140002000001400002"
              ^        ^-FieldName
              +-SymIndex

(add more labels with field names as appropriate).

26

Nit: get rid of double blank line. Same in the other test.

llvm/test/tools/llvm-readobj/XCOFF/invalid-exception-section.test

8

Not addressed, and now duplicated in the invalid_sym case too.

21–25

Do you need any symbols at all for this test case? If so, would 1 suffice?

36

Do you really need this much data for this test case? A single entry would surely be sufficient, and you wouldn't even need any symbols at all.

[DiggerLin]

address comment.

llvm/include/llvm/Object/XCOFFObjectFile.h

249–250

in the patch, it only llvm-readobj/XCOFFDumper.cpp used the member functions of ExceptionSectionEntry. but I instanced the member functions of ExceptionSectionEntry in the XCOFFObjectFile.cpp instead other files. just because we still want to implement the decode the Exception Section in llvm-objdump later, I am not sure whether we use use the member functions of ExceptionSectionEntry in XCOFFObjectFile.cpp later. I only instanced the ExceptionSectionEntry in the XCOFFObjectFile.cpp explicitly and extern instanced the ExceptionSectionEntry explicitly, It will guarantee the members functions of ExceptionSectionEntry only be instantiated once.

llvm/lib/Object/XCOFFObjectFile.cpp

407

for the in the patch https://reviews.llvm.org/D110320 and https://reviews.llvm.org/D106643 , in the getLoaderSectionAddress(). there is no test case for the code "return createError(toString(std::move(E)) +

": loader section with offset 0x" +
Twine::utohexstr(OffsetToLoaderSection) +
" and size 0x" + Twine::utohexstr(SizeOfLoaderSection) +
" goes past the end of the file");

"
I do not think we will used a canned invalid xcoff object file to test invalid loader Section.

I will not touch the code the getLoaderSectionAddress() in current patch.
and After the current patch landed, I will create a new NFC patch to refactor the getLoaderSectionAddress().(which will delete the function getLoaderSectionAddress())

446–451

yes, it is mapping the section type values to section names, I think your way is easy to understand but much more code(at lease 30 lines codes, at least 20 lines more codes). and if the enum of SectType has 100 different value, that means I have to write about 200 lines?

llvm/test/tools/llvm-readobj/XCOFF/invalid-exception-section.test

21–25

yes,agree.

36

agree, thanks

[jhenderson]

llvm/include/llvm/Object/XCOFFObjectFile.h

249–250

Right, I understand what the extern template achieves, but your answer doesn't explain why this struct is special compared to many other classes and structs in LLVM that don't use extern template.

Anyway, like I said, this is a discussion for another time.

llvm/lib/Object/XCOFFObjectFile.cpp

407

Sounds reasonable to me.

446–451

If the code is simpler to understand, you should always prefer that approach to the opaque option, even if the opaque option is many fewer lines of code. The switch/case approach may well be more efficient too, since compilers can easily optimize a switch case into a single jump.

Listing them out, the advantages of switch/case are:

• Easy to follow.
• Clear mapping of value to name (doesn't require maintaining two parallel but intrinsically linked arrays/enums).
• Improved compiler diagnostics (e.g. compilers can warn if no default case and not all cases in an enum are covered).
• Potentially improved performance.

The advantage of the existing approach:

• Fewer lines of code.

SectType doesn't have 100 values, so your argument is a false comparison. Regardless, even if it did, you'd still have to have a 100 element array and make sure that the order in that array exactly matched the order of the enum values, so it's not exactly like it's any more maintainable.

457

[jhenderson]

llvm/lib/Object/XCOFFObjectFile.cpp

454

SectionName is unitialized if this function is called with an unknown section type. Either add a default case to the switch, or, preferably (in my opinion), assign it to some other initial value, preferably that includes the section type value, so that a user can see what the input is that is passed in but has gone wrong.

If there's a straightforward way to test this, e.g. using a gtest unit test, than that would be good, but I accept that this might not be the case at the moment.

472

[DiggerLin]

address comment

[DiggerLin]

llvm/lib/Object/XCOFFObjectFile.cpp

454

For in the code, I have covered all the enumeration values.
if I use a default label, there will be compile error as "error in switch which covers all enumeration values [-Werror,-Wcovered-switch-default]"

[jhenderson]

llvm/lib/Object/XCOFFObjectFile.cpp

454

256 is unnecessarily large, given the maximum possible size of any of these names. Reduce it so that the typical max size is the maximum size of one of the normal cases.

455

The <unknown:0x1234> style is used in other places, so I think it's reasonable to use it here. On ELF, we use hex numbers for the section type too. You may wish to do that here too.

[jhenderson]

One remaining nit, otherwise LGTM.

llvm/lib/Object/XCOFFObjectFile.cpp

455

Do you need to add the 0x explicitly? I haven't looked at uthexstr, so it might not need it, but I think we should have the 0x to make it clear it is in hex.

[DiggerLin]

llvm/lib/Object/XCOFFObjectFile.cpp

455

Twine::utohexstr will have "0x" as prefix.

llvm/docs/CommandGuide/llvm-readobj.rst

 ----------------------
 
 The following options are implemented only for the XCOFF file format.
 
 .. option:: --auxiliary-header
 
   Display XCOFF Auxiliary header.
 
+.. option:: --exception-section
+
+  Display XCOFF exception section entries.
+
 EXIT STATUS
 -----------
 
 :program:`llvm-readobj` returns 0 under normal operation. It returns a non-zero
 exit code if there were any errors.
 
 SEE ALSO
 --------
 
 :manpage:`llvm-nm(1)`, :manpage:`llvm-objdump(1)`, :manpage:`llvm-readelf(1)`

llvm/include/llvm/Object/XCOFFObjectFile.h

struct LoaderSectionHeader64 {
   support::ubig32_t LengthOfStrTbl;
   support::big64_t OffsetToImpid;
   support::big64_t OffsetToStrTbl;
   support::big64_t OffsetToSymTbl;
   char Padding[16];
   support::big32_t OffsetToRelEnt;
 };
 
+template <typename AddressType> struct ExceptionSectionEntry {
+  union {
+    support::ubig32_t SymbolIdx;
+    AddressType TrapInstAddr;
+  };
+  uint8_t LangId;
+  uint8_t Reason;
+
+  uint32_t getSymbolIndex() const {
+    assert(Reason == 0 && "Get symbol table index of the function only when "
+                          "the e_reason field is 0.");
+    return SymbolIdx;
+  }
+
+  uint64_t getTrapInstAddr() const {
+    assert(Reason != 0 && "Zero is not a valid trap exception reason code.");
+    return TrapInstAddr;
+  }
+  uint8_t getLangID() const { return LangId; }
+  uint8_t getReason() const { return Reason; }
+};
+
+typedef ExceptionSectionEntry<support::ubig32_t> ExceptionSectionEntry32;
+typedef ExceptionSectionEntry<support::ubig64_t> ExceptionSectionEntry64;
+
+// Explicit extern template declarations.
+extern template struct ExceptionSectionEntry<support::ubig32_t>;
+extern template struct ExceptionSectionEntry<support::ubig64_t>;
+
 struct XCOFFStringTable {
   uint32_t Size;
   const char *Data;
 };
 
 struct XCOFFCsectAuxEnt32 {
   support::ubig32_t SectionOrLength;
   support::ubig32_t ParameterHashIndex;
private:
   size_t getSectionHeaderSize() const;
 
   const XCOFFSectionHeader32 *toSection32(DataRefImpl Ref) const;
   const XCOFFSectionHeader64 *toSection64(DataRefImpl Ref) const;
   uintptr_t getSectionHeaderTableAddress() const;
   uintptr_t getEndOfSymbolTableAddress() const;
   Expected<uintptr_t> getLoaderSectionAddress() const;
 
+  DataRefImpl getSectionByType(XCOFF::SectionTypeFlags SectType) const;
+  uint64_t getSectionFileOffsetToRawData(DataRefImpl Sec) const;
+  Expected<uintptr_t>
+  getSectionFileOffsetToRawData(XCOFF::SectionTypeFlags SectType) const;
+
   // This returns a pointer to the start of the storage for the name field of
   // the 32-bit or 64-bit SectionHeader struct. This string is *not* necessarily
   // null-terminated.
   const char *getSectionNameInternal(DataRefImpl Sec) const;
 
   static bool isReservedSectionNumber(int16_t SectionNumber);
 
   // Constructor and "create" factory function. The constructor is only a thin
public:
   getNumberOfRelocationEntries(const XCOFFSectionHeader<T> &Sec) const;
 
   template <typename Shdr, typename Reloc>
   Expected<ArrayRef<Reloc>> relocations(const Shdr &Sec) const;
 
   // Loader section related interfaces.
   Expected<StringRef> getImportFileTable() const;
 
+  // Exception-related interface.
+  template <typename ExceptEnt>
+  Expected<ArrayRef<ExceptEnt>> getExceptionEntries() const;
+
   // This function returns string table entry.
   Expected<StringRef> getStringTableEntry(uint32_t Offset) const;
 
   // This function returns the string table.
   StringRef getStringTable() const;
 
   const XCOFF::SymbolAuxType *getSymbolAuxType(uintptr_t AuxEntryAddress) const;
 

llvm/lib/Object/XCOFFObjectFile.cpp

 
 template <typename AddressType>
 uint8_t XCOFFRelocation<AddressType>::getRelocatedLength() const {
   // The relocation encodes the bit length being relocated minus 1. Add back
   // the 1 to get the actual length being relocated.
   return (Info & XR_BIASED_LENGTH_MASK) + 1;
 }
 
+template struct ExceptionSectionEntry<support::ubig32_t>;
+template struct ExceptionSectionEntry<support::ubig64_t>;
+
 uintptr_t
 XCOFFObjectFile::getAdvancedSymbolEntryAddress(uintptr_t CurrentAddress,
                                                uint32_t Distance) {
   return getWithOffset(CurrentAddress, Distance * XCOFF::SymbolTableEntrySize);
 }
 
 const XCOFF::SymbolAuxType *
 XCOFFObjectFile::getSymbolAuxType(uintptr_t AuxEntryAddress) const {
   assert(is64Bit() && "64-bit interface called on a 32-bit object file.");
   return viewAs<XCOFF::SymbolAuxType>(
       getWithOffset(AuxEntryAddress, SymbolAuxTypeOffset));

 }
 
 uint64_t XCOFFObjectFile::getSectionAlignment(DataRefImpl Sec) const {
   uint64_t Result = 0;
   llvm_unreachable("Not yet implemented!");
   return Result;
 }
 
+uint64_t XCOFFObjectFile::getSectionFileOffsetToRawData(DataRefImpl Sec) const {
+  if (is64Bit())
+    return toSection64(Sec)->FileOffsetToRawData;
+
+  return toSection32(Sec)->FileOffsetToRawData;
+}
+
 Expected<uintptr_t> XCOFFObjectFile::getLoaderSectionAddress() const {
   uint64_t OffsetToLoaderSection = 0;
   uint64_t SizeOfLoaderSection = 0;
 
   if (is64Bit()) {
     for (const auto &Sec64 : sections64())
       if (Sec64.getSectionType() == XCOFF::STYP_LOADER) {
         OffsetToLoaderSection = Sec64.FileOffsetToRawData;
         SizeOfLoaderSection = Sec64.SectionSize;
         break;
       }
   } else {
     for (const auto &Sec32 : sections32())
       if (Sec32.getSectionType() == XCOFF::STYP_LOADER) {
         OffsetToLoaderSection = Sec32.FileOffsetToRawData;
         SizeOfLoaderSection = Sec32.SectionSize;
         break;
       }
   }
 
   // No loader section is not an error.
   if (!SizeOfLoaderSection)
     return 0;
 
   uintptr_t LoderSectionStart =
       reinterpret_cast<uintptr_t>(base() + OffsetToLoaderSection);
   if (Error E =
           Binary::checkOffset(Data, LoderSectionStart, SizeOfLoaderSection))
     return createError(toString(std::move(E)) +
                        ": loader section with offset 0x" +
                        Twine::utohexstr(OffsetToLoaderSection) +
                        " and size 0x" + Twine::utohexstr(SizeOfLoaderSection) +
                        " goes past the end of the file");
 
   return LoderSectionStart;
 }
 
+Expected<uintptr_t> XCOFFObjectFile::getSectionFileOffsetToRawData(
+    XCOFF::SectionTypeFlags SectType) const {
+  DataRefImpl DRI = getSectionByType(SectType);
+
+  if (DRI.p == 0) // No section is not an error.
+    return 0;
+
+  uint64_t SectionOffset = getSectionFileOffsetToRawData(DRI);
+  uint64_t SizeOfSection = getSectionSize(DRI);
+
+  uintptr_t SectionStart = reinterpret_cast<uintptr_t>(base() + SectionOffset);
+  if (Error E = Binary::checkOffset(Data, SectionStart, SizeOfSection)) {
+    SmallString<32> UnknownType;
+    Twine(("<Unknown:") + Twine::utohexstr(SectType) + ">")
+        .toVector(UnknownType);
+    const char *SectionName = UnknownType.c_str();
+
+    switch (SectType) {
+#define ECASE(Value, String)                                                   \
+  case XCOFF::Value:                                                           \
+    SectionName = String;                                                      \
+    break
+
+      ECASE(STYP_PAD, "pad");
+      ECASE(STYP_DWARF, "dwarf");
+      ECASE(STYP_TEXT, "text");
+      ECASE(STYP_DATA, "data");
+      ECASE(STYP_BSS, "bss");
+      ECASE(STYP_EXCEPT, "expect");
+      ECASE(STYP_INFO, "info");
+      ECASE(STYP_TDATA, "tdata");
+      ECASE(STYP_TBSS, "tbss");
+      ECASE(STYP_LOADER, "loader");
+      ECASE(STYP_DEBUG, "debug");
+      ECASE(STYP_TYPCHK, "typchk");
+      ECASE(STYP_OVRFLO, "ovrflo");
+#undef ECASE
+    }
+    return createError(toString(std::move(E)) + ": " + SectionName +
+                       " section with offset 0x" +
+                       Twine::utohexstr(SectionOffset) + " and size 0x" +
+                       Twine::utohexstr(SizeOfSection) +
+                       " goes past the end of the file");
+  }
+  return SectionStart;
+}
+
 bool XCOFFObjectFile::isSectionCompressed(DataRefImpl Sec) const {
   return false;
 }
 
 bool XCOFFObjectFile::isSectionText(DataRefImpl Sec) const {
   return getSectionFlags(Sec) & XCOFF::STYP_TEXT;
 }
 
return createStringError(object_error::invalid_section_index,
                                  ") is invalid");
 
   DataRefImpl DRI;
   DRI.p = getWithOffset(getSectionHeaderTableAddress(),
                         getSectionHeaderSize() * (Num - 1));
   return DRI;
 }
 
+DataRefImpl
+XCOFFObjectFile::getSectionByType(XCOFF::SectionTypeFlags SectType) const {
+  DataRefImpl DRI;
+  auto GetSectionAddr = [&](const auto &Sections) {
+    for (const auto &Sec : Sections)
+      if (Sec.getSectionType() == SectType)
+        return reinterpret_cast<uintptr_t>(&Sec);
+    return 0ul;
+  };
+  if (is64Bit())
+    DRI.p = GetSectionAddr(sections64());
+  else
+    DRI.p = GetSectionAddr(sections32());
+  return DRI;
+}
+
 Expected<StringRef>
 XCOFFObjectFile::getSymbolSectionName(XCOFFSymbolRef SymEntPtr) const {
   const int16_t SectionNum = SymEntPtr.getSectionNumber();
 
   switch (SectionNum) {
   case XCOFF::N_DEBUG:
     return "N_DEBUG";
   case XCOFF::N_ABS:
return createError(
         Twine::utohexstr(NumRelocEntries * sizeof(Reloc)) +
         " go past the end of the file");
 
   const Reloc *StartReloc = RelocationOrErr.get();
 
   return ArrayRef<Reloc>(StartReloc, StartReloc + NumRelocEntries);
 }
 
+template <typename ExceptEnt>
+Expected<ArrayRef<ExceptEnt>> XCOFFObjectFile::getExceptionEntries() const {
+  assert(is64Bit() && sizeof(ExceptEnt) == sizeof(ExceptionSectionEntry64) ||
+         !is64Bit() && sizeof(ExceptEnt) == sizeof(ExceptionSectionEntry32));
+
+  Expected<uintptr_t> ExceptionSectOrErr =
+      getSectionFileOffsetToRawData(XCOFF::STYP_EXCEPT);
+  if (!ExceptionSectOrErr)
+    return ExceptionSectOrErr.takeError();
+
+  DataRefImpl DRI = getSectionByType(XCOFF::STYP_EXCEPT);
+  if (DRI.p == 0)
+    return ArrayRef<ExceptEnt>();
+
+  ExceptEnt *ExceptEntStart =
+      reinterpret_cast<ExceptEnt *>(*ExceptionSectOrErr);
+  return ArrayRef<ExceptEnt>(
+      ExceptEntStart, ExceptEntStart + getSectionSize(DRI) / sizeof(ExceptEnt));
+}
+
+template Expected<ArrayRef<ExceptionSectionEntry32>>
+XCOFFObjectFile::getExceptionEntries() const;
+template Expected<ArrayRef<ExceptionSectionEntry64>>
+XCOFFObjectFile::getExceptionEntries() const;
+
 Expected<XCOFFStringTable>
 XCOFFObjectFile::parseStringTable(const XCOFFObjectFile *Obj, uint64_t Offset) {
   // If there is a string table, then the buffer must contain at least 4 bytes
   // for the string table's size. Not having a string table is not an error.
   if (Error E = Binary::checkOffset(
           Obj->Data, reinterpret_cast<uintptr_t>(Obj->base() + Offset), 4)) {
     consumeError(std::move(E));
     return XCOFFStringTable{0, nullptr};

llvm/test/tools/llvm-readobj/XCOFF/exception-section.test

+## Test the --exception-section option.
+
+# RUN: yaml2obj --docnum=1 %s -o %t_xcoff32.o
+# RUN: yaml2obj --docnum=2  %s -o %t_xcoff64.o
+# RUN: llvm-readobj --exception-section %t_xcoff32.o |\
+# RUN:   FileCheck %s --check-prefixes=CHECK
+# RUN: llvm-readobj --exception-section %t_xcoff64.o |\
+# RUN:   FileCheck %s --check-prefixes=CHECK
+
+--- !XCOFF
+FileHeader:
+  MagicNumber:       0x1DF
+Sections:
+  - Name:            .text
+    Flags:           [ STYP_TEXT ]
+  - Name:            .except
+    Flags:           [ STYP_EXCEPT ]
+    SectionData:     "000000000000000000340003"
+##                    ^-------                   -SymbolIndex=0
+##                            ^-                 -LangID=0
+##                              ^-               -Reason=0
+##                                ^-------       -Trap Instr Addr=0x34
+##                                        ^-     -LangID=0
+##                                          ^-   -Reason=3
+Symbols:
+  - Name:            .bar
+    Section:         .text
+
+--- !XCOFF
+FileHeader:
+  MagicNumber:       0x1F7
+Sections:
+  - Name:            .text
+    Flags:           [ STYP_TEXT ]
+  - Name:            .except
+    Flags:           [ STYP_EXCEPT ]
+    SectionData:     "0000000000000000000000000000000000340003"
+##                    ^---------------                            -SymbolIndex=0
+##                                    ^-                          -LangID=0
+##                                      ^-                        -Reason=0
+##                                        ^--------------         -Trap Instr Addr=0x34
+##                                                       ^-       -LangID=0
+##                                                         ^-     -Reason=3
+Symbols:
+  - Name:            .bar
+    Section:         .text
+
+# CHECK:       Exception section {
+# CHECK-NEXT:   Symbol: .bar (0)
+# CHECK-NEXT:   LangID: 0
+# CHECK-NEXT:   Reason: 0
+# CHECK-NEXT:   Trap Instr Addr: 0x34
+# CHECK-NEXT:   LangID: 0
+# CHECK-NEXT:   Reason: 3
+# CHECK-NEXT: }

llvm/test/tools/llvm-readobj/XCOFF/invalid-exception-section.test

+## Test decoding an invalid exception section and symbol index. 
+
+# RUN: yaml2obj --docnum=1 %s -o %t_invalid_size.o
+# RUN: yaml2obj --docnum=2 %s -o %t_invalid_sym.o
+# RUN: llvm-readobj --exception-section %t_invalid_size.o 2>&1 |\
+# RUN:   FileCheck -DFILE=%t_invalid_size.o %s --check-prefixes=CHECK-WARN-SIZE
+# RUN: llvm-readobj --exception-section %t_invalid_sym.o 2>&1 |\
+# RUN:   FileCheck -DFILE=%t_invalid_sym.o %s --check-prefixes=CHECK-WARN-SYM
+
+--- !XCOFF
+FileHeader:
+  MagicNumber:       0x1DF
+Sections:
+  - Name:            .text
+    Flags:           [ STYP_TEXT ]
+  - Name:            .except
+    Size:            1000
+    Flags:           [ STYP_EXCEPT ]
+    SectionData:     "000000000000"
+Symbols:
+  - Name:            .bar
+    Section:         .text
+
+--- !XCOFF
+FileHeader:
+  MagicNumber:       0x1F7
+Sections:
+  - Name:            .text
+    Flags:           [ STYP_TEXT ]
+  - Name:            .except
+    Flags:           [ STYP_EXCEPT ]
+    SectionData:     "00000004000000000000"
+Symbols:
+  - Name:            .bar
+    Section:         .text
+
+# CHECK-WARN-SIZE: warning: '[[FILE]]': The end of the file was unexpectedly encountered: expect section with offset 0x64 and size 0x3e8 goes past the end of the file
+# CHECK-WARN-SYM:  warning: '[[FILE]]': symbol index 4 exceeds symbol count 1

llvm/tools/llvm-readobj/ObjDumper.h

public:
   mergeCodeViewTypes(llvm::codeview::MergingTypeTableBuilder &CVIDs,
                      llvm::codeview::MergingTypeTableBuilder &CVTypes,
                      llvm::codeview::GlobalTypeTableBuilder &GlobalCVIDs,
                      llvm::codeview::GlobalTypeTableBuilder &GlobalCVTypes,
                      bool GHash) {}
 
   // Only implement for XCOFF
   virtual void printAuxiliaryHeader() {}
+  virtual void printExceptionSection() {}
 
   // Only implemented for MachO.
   virtual void printMachODataInCode() { }
   virtual void printMachOVersionMin() { }
   virtual void printMachODysymtab() { }
   virtual void printMachOSegment() { }
   virtual void printMachOIndirectSymbols() { }
   virtual void printMachOLinkerOptions() { }

llvm/tools/llvm-readobj/Opts.td

 def coff_imports : FF<"coff-imports", "Display import table">, Group<grp_coff>;
 def coff_load_config : FF<"coff-load-config", "Display load config">, Group<grp_coff>;
 def coff_resources : FF<"coff-resources", "Display .rsrc section">, Group<grp_coff>;
 def coff_tls_directory : FF<"coff-tls-directory", "Display TLS directory">, Group<grp_coff>;
 
 // XCOFF specific options.
 def grp_xcoff : OptionGroup<"kind">, HelpText<"OPTIONS (XCOFF specific)">;
 def auxiliary_header : FF<"auxiliary-header" , "Display the auxiliary header">, Group<grp_xcoff>;
+def exception_section : FF<"exception-section" , "Display the exception section entries">, Group<grp_xcoff>;
 
 def help : FF<"help", "Display this help">;
 def version : FF<"version", "Display the version">;
 
 // Ignored for GNU readelf compatibility.
 def wide : FF<"wide", "Ignored for GNU readelf compatibility">;
 def : F<"W", "Ignored for GNU readelf compatibility">, Alias<wide>;
 

llvm/tools/llvm-readobj/XCOFFDumper.cpp

public:
   void printSectionHeaders() override;
   void printRelocations() override;
   void printSymbols() override;
   void printDynamicSymbols() override;
   void printUnwindInfo() override;
   void printStackMap() const override;
   void printNeededLibraries() override;
   void printStringTable() override;
+  void printExceptionSection() override;
 
   ScopedPrinter &getScopedPrinter() const { return W; }
 
 private:
   template <typename T> void printSectionHeaders(ArrayRef<T> Sections);
   template <typename T> void printGenericSectionHeader(T &Sec) const;
   template <typename T> void printOverflowSectionHeader(T &Sec) const;
+  template <typename T>
+  void printExceptionSectionEntry(const T &ExceptionSectEnt) const;
+  template <typename T> void printExceptionSectionEntries() const;
   template <typename T> const T *getAuxEntPtr(uintptr_t AuxAddress);
   void printFileAuxEnt(const XCOFFFileAuxEnt *AuxEntPtr);
   void printCsectAuxEnt(XCOFFCsectAuxRef AuxEntRef);
   void printSectAuxEntForStat(const XCOFFSectAuxEntForStat *AuxEntPtr);
   void printExceptionAuxEnt(const XCOFFExceptionAuxEnt *AuxEntPtr);
   void printFunctionAuxEnt(const XCOFFFunctionAuxEnt32 *AuxEntPtr);
   void printFunctionAuxEnt(const XCOFFFunctionAuxEnt64 *AuxEntPtr);
   void printBlockAuxEnt(const XCOFFBlockAuxEnt32 *AuxEntPtr);

 
 void XCOFFDumper::printSectionHeaders() {
   if (Obj.is64Bit())
     printSectionHeaders(Obj.sections64());
   else
     printSectionHeaders(Obj.sections32());
 }
 
+template <typename T>
+void XCOFFDumper::printExceptionSectionEntry(const T &ExceptionSectEnt) const {
+  if (ExceptionSectEnt.getReason())
+    W.printHex("Trap Instr Addr", ExceptionSectEnt.getTrapInstAddr());
+  else {
+    uint32_t SymIdx = ExceptionSectEnt.getSymbolIndex();
+    Expected<StringRef> ErrOrSymbolName = Obj.getSymbolNameByIndex(SymIdx);
+    if (Error E = ErrOrSymbolName.takeError()) {
+      reportUniqueWarning(std::move(E));
+      return;
+    }
+    StringRef SymName = *ErrOrSymbolName;
+
+    W.printNumber("Symbol", SymName, SymIdx);
+  }
+  W.printNumber("LangID", ExceptionSectEnt.getLangID());
+  W.printNumber("Reason", ExceptionSectEnt.getReason());
+}
+
+template <typename T> void XCOFFDumper::printExceptionSectionEntries() const {
+  Expected<ArrayRef<T>> ExceptSectEntsOrErr = Obj.getExceptionEntries<T>();
+  if (Error E = ExceptSectEntsOrErr.takeError()) {
+    reportUniqueWarning(std::move(E));
+    return;
+  }
+  ArrayRef<T> ExceptSectEnts = *ExceptSectEntsOrErr;
+
+  DictScope DS(W, "Exception section");
+  if (ExceptSectEnts.empty())
+    return;
+  for (auto &Ent : ExceptSectEnts)
+    printExceptionSectionEntry(Ent);
+}
+
+void XCOFFDumper::printExceptionSection() {
+  if (Obj.is64Bit())
+    printExceptionSectionEntries<ExceptionSectionEntry64>();
+  else
+    printExceptionSectionEntries<ExceptionSectionEntry32>();
+}
+
 void XCOFFDumper::printRelocations() {
   if (Obj.is64Bit())
     printRelocations<XCOFFSectionHeader64, XCOFFRelocation64>(Obj.sections64());
   else
     printRelocations<XCOFFSectionHeader32, XCOFFRelocation32>(Obj.sections32());
 }
 
 const EnumEntry<XCOFF::RelocationType> RelocationTypeNameclass[] = {

llvm/tools/llvm-readobj/llvm-readobj.cpp

 static bool COFFExports;
 static bool COFFImports;
 static bool COFFLoadConfig;
 static bool COFFResources;
 static bool COFFTLSDirectory;
 
 // XCOFF specific options.
 static bool XCOFFAuxiliaryHeader;
+static bool XCOFFExceptionSection;
 
 OutputStyleTy Output = OutputStyleTy::LLVM;
 static std::vector<std::string> InputFilenames;
 } // namespace opts
 
 static StringRef ToolName;
 
 namespace llvm {
static void parseOptions(const opt::InputArgList &Args) {
   opts::COFFExports = Args.hasArg(OPT_coff_exports);
   opts::COFFImports = Args.hasArg(OPT_coff_imports);
   opts::COFFLoadConfig = Args.hasArg(OPT_coff_load_config);
   opts::COFFResources = Args.hasArg(OPT_coff_resources);
   opts::COFFTLSDirectory = Args.hasArg(OPT_coff_tls_directory);
 
   // XCOFF specific options.
   opts::XCOFFAuxiliaryHeader = Args.hasArg(OPT_auxiliary_header);
+  opts::XCOFFExceptionSection = Args.hasArg(OPT_exception_section);
 
   opts::InputFilenames = Args.getAllArgValues(OPT_INPUT);
 }
 
 namespace {
 struct ReadObjTypeTableBuilder {
   ReadObjTypeTableBuilder()
       : IDTable(Allocator), TypeTable(Allocator), GlobalIDTable(Allocator),
if (Dumper->canCompareSymbols()) {
                     FileStr);
     }
   }
   Dumper->printFileSummary(FileStr, Obj, opts::InputFilenames, A);
 
   if (opts::FileHeaders)
     Dumper->printFileHeaders();
 
+  // Auxiliary header in XOCFF is right after the file header, so print the data
+  // here.
   if (Obj.isXCOFF() && opts::XCOFFAuxiliaryHeader)
     Dumper->printAuxiliaryHeader();
 
   // This is only used for ELF currently. In some cases, when an object is
   // corrupt (e.g. truncated), we can't dump anything except the file header.
   if (!ContentErrString.empty())
     reportError(createError(ContentErrString), FileStr);
 
if (opts::MachOSegment)
       Dumper->printMachOSegment();
     if (opts::MachOVersionMin)
       Dumper->printMachOVersionMin();
     if (opts::MachODysymtab)
       Dumper->printMachODysymtab();
     if (opts::CGProfile)
       Dumper->printCGProfile();
   }
+
+  if (Obj.isXCOFF() && opts::XCOFFExceptionSection)
+    Dumper->printExceptionSection();
+
   if (opts::PrintStackMap)
     Dumper->printStackMap();
   if (opts::PrintStackSizes)
     Dumper->printStackSizes();
 }
 
 /// Dumps each object file in \a Arc;
 static void dumpArchive(const Archive *Arc, ScopedPrinter &Writer) {