[PowerPC] XCOFF exception section support on the integrated assembler path

[pscoro]

Summary

Continuation of https://reviews.llvm.org/D132146 (direct assembly path support, needs to merge first). Adds support to the integrated assembler path for emitting XCOFF exception sections. Both features need https://reviews.llvm.org/D133030 to merge first

[pscoro]

adding missing file change

[pscoro]

mostly formatting fixes

[pscoro]

rebase

[tschuett]

llvm/include/llvm/MC/MCObjectWriter.h

108

Is this going to be an XCOFF only function?

[pscoro]

llvm/include/llvm/MC/MCObjectWriter.h

108

Yes, exception sections are an XCOFF only feature. The specifics can be found in the XCOFF documentation: https://www.ibm.com/docs/en/aix/7.2?topic=formats-xcoff-object-file-format#d236277e7374

[tschuett]

llvm/include/llvm/MC/MCObjectWriter.h

108

In the other diff, there was a report_fatal_error if used by other than XCOFF.

[pscoro]

added addExceptionEntry fatal error if not XCOFF

[pscoro]

llvm/include/llvm/MC/MCObjectWriter.h

108

Yep, the other diff had a fatal error for emitXCOFFExceptDirective, a similar error was needed here, good catch thanks.

[shchenz]

llvm/include/llvm/MC/MCObjectWriter.h

111

Format here seems strange...

llvm/lib/MC/XCOFFObjectWriter.cpp

214

Move this field to ExceptionSectionEntry as the key.

220

Can we change this to a map? The key is the function symbol(The Symbol in ExceptionInfo struct) and the value is the ExceptionInfo struct which contains all entries for a function. So we don't need to go through all the functions exception table to find a ExceptionInfo for a given symbol? I saw too many such loops in your implementation that can be optimized out by using a map.

357

Can we use !ExceptionTable.empty() for this? getExceptionSectionSize() sounds like too heavy.

793

Can we explain why we need to add 0x0020 for 32-bit symbol?

796

If we are using a map for ExceptionTable, we can reuse writeSymbolEntry() and the last writeSymbolAuxCsectEntry() with legacy codes. Just need to do some special handling for the last parameter NumberOfAuxEntries for symbol which has except entries.

1102

Can optimize this by using a map.

1119

Maybe we need comments here for the +1? The first exception entry for a function.

1428

Please add comments here for the first section entry.

llvm/test/CodeGen/PowerPC/aix-xcoff-exception-section-debug.ll

2

nit: is the -O0 required?

7

For this test, if it is to test the Exception Auxiliary Entry aux symbol, maybe we can only keep one RUN line to only check the symbols. Other test points should be covered in other tests, right?

llvm/test/CodeGen/PowerPC/aix-xcoff-exception-section.ll

208

This is exactly the same with 32-bit? If so, we don't need to make another copy.

llvm/test/CodeGen/PowerPC/builtins-ppc-xlcompat-trap-annotations-td.ll

7

We should not remove the RUN line as it is the only one test for -filetype=obj. Maybe we can modify the check to a simple check, for example, ; OBJ-LABEL: test__trapd_annotation: to check that the case does not crash in obj mode now?

llvm/test/CodeGen/PowerPC/builtins-ppc-xlcompat-trap-annotations-tw.ll

14

ditto.

[DiggerLin]

llvm/lib/MC/XCOFFObjectWriter.cpp

220

agree with shchenz.

1139

line 1128-1134 can change to

Offset += (is64Bit()) ? (SymbolEntry.Entries.size() + 1) *
                              XCOFF::ExceptionSectionEntrySize64
                        : (SymbolEntry.Entries.size() + 1) *
                              XCOFF::ExceptionSectionEntrySize32;

1205

map also will improve the code efficiency here without a loop.

1221

bool hasExceptionSection() { return (bool) getExceptionSectionSize(); } }
and XCOFFObjectWriter::getExceptionSectionSize() loop for all ExceptionSection.ExceptionTable.

it is low efficiency here. I think you can use variable to calculate once at the begin of the function.

and there are several place calll hasExceptionSection() in the patch, maybe we can reimplement as
bool hasExceptionSection() { !ExceptionSection.ExceptionTable.empty();}

1222

Maybe better to add some comment here to explain the following code?

[pscoro]

optimizations

[pscoro]

llvm/include/llvm/MC/MCObjectWriter.h

111

I ran clang-format on these lines and no changes were made

llvm/lib/MC/XCOFFObjectWriter.cpp

796

Not entirely sure what you had in mind here. I can not search the exception map directly in writeSymbolEntry because the symbol is passed by name (stringref not MCSymbol) so I'd either have to change writeSymbolEntry's function signature or find the symbol in the map beforehand (what it is doing now). Let me know what you think of the code changes here and if more changes are needed.

1221

and there are several place calll hasExceptionSection() in the patch, maybe we can reimplement as bool hasExceptionSection() { !ExceptionSection.ExceptionTable.empty();}

Went ahead with this fix

1222

Made the above comment explain the number of entries in better detail

[pscoro]

changes to debug lit tests

[pscoro]

llvm/test/CodeGen/PowerPC/aix-xcoff-exception-section.ll

208

For some reason the order of the exception section entries is backwards on 64-bit, is this an issue? It shouldn't affect the correctness of the exception section

[DiggerLin]

llvm/include/llvm/MC/MCObjectWriter.h

111

need a test case for this code.

llvm/lib/MC/XCOFFObjectWriter.cpp

205

the unsigned is 4 bytes no matter in 32bit and 64bits.
the e_addr.e_paddr is 8bytes in 64bits. I do not think "unsigned TrapAddress" is enough to hold the data. should be change to uint64_t.

224

need assert assert(N.size() <= XCOFF::NameSize && "section name too long"); before memcpy as otherSectionEntry constructor.

227

I do not think we need the line , the default move constructor is generated by default in this scenario.

694

why delete the comment ?

810

add some comment to explain why +4 and +3 here.

858

nit: still can use writeWord(LineNumberPointer);

1119

change the code to

unsigned EntryNum=0;

for (auto it = ExceptionSection.ExceptionTable.begin(); it != ExceptionSection.ExceptionTable.end(); ++it)
  // The size() gets +1 to account for the initial entry containing the
  // symbol table index.
  EntryNum += it->second.Entries.size() + 1;

return    EntryNum * (is64Bit() ? XCOFF::ExceptionSectionEntrySize64 : XCOFF::ExceptionSectionEntrySize32);

it only need one time of multiplication ， it can improve the efficiency.

1139

Same reason as above. the function can change to

unsigned EntrtNum = 0;

for (auto it = ExceptionSection.ExceptionTable.begin(); it != ExceptionSection.ExceptionTable.end(); ++it) {
  if (Symbol == it->first)
    break;
  EntryNum += it->second.Entries.size() + 1;
}
return EntryNum * (is64Bit() ? XCOFF::ExceptionSectionEntrySize64 : XCOFF::ExceptionSectionEntrySize32);

1434

add comment to indicate this is 4 bytes padding when the entry is symbol index for 64bits.

1442

if (is64Bit()) {
  W.write<uint64_t>(TrapEntry.TrapAddress);
} else {
  W.write<uint32_t>(TrapEntry.TrapAddress);
}

change to

W.wrtieWord(TrapEntry.TrapAddress);

[DiggerLin]

llvm/test/CodeGen/PowerPC/aix-xcoff-exception-section-debug.ll

3

should be add a 32bit test case?

113

in order to simplify the test case, suggest to delete the checking symbol "Name: sub_test" from line 94-112.

llvm/test/CodeGen/PowerPC/aix-xcoff-exception-section.ll

2

same question as zhengchen put : "is the -O0 required?"

4

I think you have generate the %t.o in line 1, I do not think we need to generate again ? same problem in the following.

77

I do not think you need to check the section .text and .data

117

delete the unrelated the symbol check for the patch.

[pscoro]

optimizations and lit test fixes

[DiggerLin]

llvm/include/llvm/MC/MCObjectWriter.h

108

change "MCSymbol *Trap" to " const MCSymbol *Trap"

[DiggerLin]

llvm/lib/MC/XCOFFObjectWriter.cpp

204

I do not think you need to change the content of MCSymbol pointed by *Trap.

const MCSymbol *Trap;

will be better.

[DiggerLin]

llvm/lib/MC/XCOFFObjectWriter.cpp

797

we emit the xcoff object code as old interpret (SymbolRef.getVisibilityType() | 0x0020). ?

if we want to interpret as old version what about the code in line 818.

writeSymbolEntry(SymbolRef.getSymbolTableName(),
                     CSectionRef.Address + SymbolOffset, SectionIndex,
                     SymbolRef.getVisibilityType(),
                     SymbolRef.getStorageClass());

llvm/test/CodeGen/PowerPC/aix-xcoff-exception-section-debug.ll

2

Maybe better to add comment to explain the purpose of the new added test case.

llvm/test/CodeGen/PowerPC/aix-xcoff-exception-section.ll

2

Maybe better to add comment to explain the purpose of the new added test case.

6

is the test duplicate with

; RUN: llvm-readobj --section-headers %t.o | FileCheck %s --check-prefix=READ ?

[pscoro]

fixes

[pscoro]

llvm/lib/MC/XCOFFObjectWriter.cpp

797

We ran into an issue where this feature would not work without the 0x0020 bit set, which according to the documentation is part of the old xcoff implementation. It would make sense that the OR 0x0020 should be added to line 818 as well, but first I need to double check that my understanding is correct. Am I correct that this void XCOFFObjectWriter::writeSymbolEntryForCsectMemberLabel function is called with const Symbol SymbolRefs that are always function symbols? If this is the case, then I can add the 0x0020 to line 818 as well.

llvm/test/CodeGen/PowerPC/aix-xcoff-exception-section.ll

6

No, the output of llvm-readobj and llvm-objdump with --section-headers are not the same.

[DiggerLin]

llvm/test/CodeGen/PowerPC/aix-xcoff-exception-section.ll

6

you want to check the content of the .exception header? I think both check it.

[pscoro]

llvm/test/CodeGen/PowerPC/aix-xcoff-exception-section.ll

6

Yes, my thinking behind the llvm-objdump line was to test that the output of that command is correct in addition to the llvm-readobj output. I see that this is technically just testing that llvm-objdump is working correctly and isn't really adding anything to exception section testing, so I should just remove the llvm-objdump tests?

[DiggerLin]

llvm/test/CodeGen/PowerPC/aix-xcoff-exception-section.ll

6

I think we should keep llvm-readobj test. it have more detail info, at lease you also check following in the llvm-readobj test

; READ-NEXT: Type: STYP_EXCEPT (0x100)

[DiggerLin]

llvm/lib/MC/XCOFFObjectWriter.cpp

797

Am I correct that this void XCOFFObjectWriter::writeSymbolEntryForCsectMemberLabel function is called with const Symbol SymbolRefs that are always function symbols?

I think when -fdata-section is off, A global data symbol also enter into the function. You can write test case and test it.

[pscoro]

Removed unneeded llvm-objdump tests

[pscoro]

Replacing DenseMap usage with std::map to ensure a determinable order of exception entries

[tschuett]

In D134195#3895297, @pscoro wrote:

Replacing DenseMap usage with std::map to ensure a determinable order of exception entries

Could you please check whether you find something for your use case:
https://llvm.org/docs/ProgrammersManual.html#picking-the-right-data-structure-for-a-task

std::map is frowned upon in LLVM. It is very heap heavy.

[pscoro]

In D134195#3895476, @tschuett wrote:

In D134195#3895297, @pscoro wrote:

Replacing DenseMap usage with std::map to ensure a determinable order of exception entries

Could you please check whether you find something for your use case:
https://llvm.org/docs/ProgrammersManual.html#picking-the-right-data-structure-for-a-task

std::map is frowned upon in LLVM. It is very heap heavy.

I need a map data structure with a determinable order, I was looking at that page earlier when I settled on std::map. The only other option I saw was MapVector:

MapVector<KeyT,ValueT> provides a subset of the DenseMap interface. The main difference is that the iteration order is guaranteed to be the insertion order, making it an easy (but somewhat expensive) solution for non-deterministic iteration over maps of pointers.

I chose std::map over this because I thought MapVector would be too expensive, would you know if MapVector would be less expensive and preferable to std::map here?

[tschuett]

In D134195#3896249, @pscoro wrote:

In D134195#3895476, @tschuett wrote:

In D134195#3895297, @pscoro wrote:

Replacing DenseMap usage with std::map to ensure a determinable order of exception entries

Could you please check whether you find something for your use case:
https://llvm.org/docs/ProgrammersManual.html#picking-the-right-data-structure-for-a-task

std::map is frowned upon in LLVM. It is very heap heavy.

I need a map data structure with a determinable order, I was looking at that page earlier when I settled on std::map. The only other option I saw was MapVector:

MapVector<KeyT,ValueT> provides a subset of the DenseMap interface. The main difference is that the iteration order is guaranteed to be the insertion order, making it an easy (but somewhat expensive) solution for non-deterministic iteration over maps of pointers.

I chose std::map over this because I thought MapVector would be too expensive, would you know if MapVector would be less expensive and preferable to std::map here?

Unfortunately no.

[shchenz]

looks almost good to me. Just some nits left.

Please also make sure all @DiggerLin 's comments be addressed.

llvm/include/llvm/MC/MCObjectWriter.h

111

clang-format can not merge the string in different lines to one line? I don't think we need two lines here

llvm/lib/MC/XCOFFObjectWriter.cpp

1205

nit: alignment here

llvm/test/CodeGen/PowerPC/aix-xcoff-exception-section-debug.ll

5

do we still need -O0?

llvm/test/CodeGen/PowerPC/aix-xcoff-exception-section.ll

4

Ditto

llvm/test/CodeGen/PowerPC/builtins-ppc-xlcompat-trap-annotations-td.ll

7

This comment seems not be addressed?

[pscoro]

Addressed nits

[pscoro]

llvm/test/CodeGen/PowerPC/builtins-ppc-xlcompat-trap-annotations-td.ll

7

I can't add OBJ-LABEL because this isnt checking assembly labels but I added the equivalent for object files

[shchenz]

LGTM now. Please wait for some days in case other reviewers have comments.
Thanks for adding the new feature.

[DiggerLin]

llvm/lib/MC/XCOFFObjectWriter.cpp

694

sorry, I think you maybe have to delete the comment. since you have set "the function indicator" in writeSymbolEntryForCsectMemberLabel.

and I am not sure whether we need to set the "the function indicator" for SymbolType when there is no except auxiliary entry , if there is , we maybe need to add the a TODO comment on it.

[pscoro]

removing comment

[DiggerLin]

LGTM

llvm/test/CodeGen/PowerPC/builtins-ppc-xlcompat-trap-annotations-tw.ll

52

nit: delete last line

[pscoro]

Removed whitespace

[pscoro]

another determinable order fix for the exception map

[Esme]

FYI. I committed an NFC patch rG664cbfaf07e0 to format this patch.

llvm/include/llvm/BinaryFormat/XCOFF.h

 constexpr size_t AuxFileHeaderSize32 = 72;
 constexpr size_t AuxFileHeaderSize64 = 110;
 constexpr size_t AuxFileHeaderSizeShort = 28;
 constexpr size_t SectionHeaderSize32 = 40;
 constexpr size_t SectionHeaderSize64 = 72;
 constexpr size_t SymbolTableEntrySize = 18;
 constexpr size_t RelocationSerializationSize32 = 10;
 constexpr size_t RelocationSerializationSize64 = 14;
+constexpr size_t ExceptionSectionEntrySize32 = 6;
+constexpr size_t ExceptionSectionEntrySize64 = 10;
 constexpr uint16_t RelocOverflow = 65535;
 constexpr uint8_t AllocRegNo = 31;
 
 enum ReservedSectionNum : int16_t { N_DEBUG = -2, N_ABS = -1, N_UNDEF = 0 };
 
 enum MagicNumber : uint16_t { XCOFF32 = 0x01DF, XCOFF64 = 0x01F7 };
 
 // This field only exists in the XCOFF64 definition.

llvm/include/llvm/MC/MCObjectWriter.h

public:
   bool getEmitAddrsigSection() { return EmitAddrsigSection; }
 
   /// Record the given symbol in the address-significance table to be written
   /// diring writeObject().
   void addAddrsigSymbol(const MCSymbol *Sym) { AddrsigSyms.push_back(Sym); }
 
   std::vector<const MCSymbol *> &getAddrsigSyms() { return AddrsigSyms; }
 
+  virtual void addExceptionEntry(const MCSymbol *Symbol, const MCSymbol *Trap,
+                                 unsigned LanguageCode, unsigned ReasonCode,
+                                 unsigned FunctionSize, bool hasDebug) {
+    report_fatal_error("addExceptionEntry is only supported on XCOFF targets");
+  }
   /// Write the object file and returns the number of bytes written.
   ///
   /// This routine is called by the assembler after layout and relaxation is
   /// complete, fixups have been evaluated and applied, and relocations
   /// generated.
   virtual uint64_t writeObject(MCAssembler &Asm, const MCAsmLayout &Layout) = 0;
 
   /// @}

llvm/include/llvm/MC/MCStreamer.h

public:
   virtual void emitXCOFFRenameDirective(const MCSymbol *Name, StringRef Rename);
 
   /// Emit an XCOFF .except directive which adds information about
   /// a trap instruction to the object file exception section
   ///
   /// \param Symbol - The function containing the trap.
   /// \param Lang - The language code for the exception entry.
   /// \param Reason - The reason code for the exception entry.
-  virtual void emitXCOFFExceptDirective(const MCSymbol *Symbol, MCSymbol *Trap,
+  virtual void emitXCOFFExceptDirective(const MCSymbol *Symbol, 
+                                        const MCSymbol *Trap,
                                         unsigned Lang, unsigned Reason,
                                         unsigned FunctionSize, bool hasDebug);
 
   /// Emit a XCOFF .ref directive which creates R_REF type entry in the
   /// relocation table for one or more symbols.
   ///
   /// \param Sym - The symbol on the .ref directive.
   virtual void emitXCOFFRefDirective(StringRef Sym);

llvm/include/llvm/MC/MCXCOFFStreamer.h

void emitXCOFFRefDirective(StringRef Name) override {
     report_fatal_error("emitXCOFFRefDirective is not implemented yet on object"
                        "generation path");
   }
   void emitXCOFFRenameDirective(const MCSymbol *Name,
                                 StringRef Rename) override {
     report_fatal_error("emitXCOFFRenameDirective is not implemented yet on "
                        "object generation path");
   }
-  void emitXCOFFExceptDirective(const MCSymbol *Symbol, MCSymbol *Trap,
+  void emitXCOFFExceptDirective(const MCSymbol *Symbol, const MCSymbol *Trap,
                                 unsigned Lang, unsigned Reason,
                                 unsigned FunctionSize, bool hasDebug) override;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_MC_MCXCOFFSTREAMER_H

llvm/lib/MC/MCAsmStreamer.cpp

public:
   void emitXCOFFSymbolLinkageWithVisibility(MCSymbol *Symbol,
                                             MCSymbolAttr Linakge,
                                             MCSymbolAttr Visibility) override;
   void emitXCOFFRenameDirective(const MCSymbol *Name,
                                 StringRef Rename) override;
 
   void emitXCOFFRefDirective(StringRef Name) override;
 
-  void emitXCOFFExceptDirective(const MCSymbol *Symbol, MCSymbol *Trap,
+  void emitXCOFFExceptDirective(const MCSymbol *Symbol, 
+                                const MCSymbol *Trap,
                                 unsigned Lang, unsigned Reason,
                                 unsigned FunctionSize, bool hasDebug) override;
 
   void emitELFSize(MCSymbol *Symbol, const MCExpr *Value) override;
   void emitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                         unsigned ByteAlignment) override;
 
   /// Emit a local common (.lcomm) symbol.

 }
 
 void MCAsmStreamer::emitXCOFFRefDirective(StringRef Name) {
   OS << "\t.ref " << Name;
   EmitEOL();
 }
 
 void MCAsmStreamer::emitXCOFFExceptDirective(const MCSymbol *Symbol,
-                                             MCSymbol *Trap, unsigned Lang,
+                                             const MCSymbol *Trap, 
+                                             unsigned Lang,
                                              unsigned Reason,
                                              unsigned FunctionSize,
                                              bool hasDebug) {
   OS << "\t.except\t";
   Symbol->print(OS, MAI);
   OS << ", " << Lang << ", " << Reason;
   EmitEOL();
 }

llvm/lib/MC/MCStreamer.cpp

llvm_unreachable("emitXCOFFRenameDirective is only supported on "
                    "XCOFF targets");
 }
 
 void MCStreamer::emitXCOFFRefDirective(StringRef Name) {
   llvm_unreachable("emitXCOFFRefDirective is only supported on XCOFF targets");
 }
 
 void MCStreamer::emitXCOFFExceptDirective(const MCSymbol *Symbol,
-                                          MCSymbol *Trap, unsigned Lang,
-                                          unsigned Reason,
+                                          const MCSymbol *Trap, 
+                                          unsigned Lang, unsigned Reason,
                                           unsigned FunctionSize,
                                           bool hasDebug) {
   report_fatal_error("emitXCOFFExceptDirective is only supported on "
                      "XCOFF targets");
 }
 
 void MCStreamer::emitELFSize(MCSymbol *Symbol, const MCExpr *Value) {}
 void MCStreamer::emitELFSymverDirective(const MCSymbol *OriginalSym,

llvm/lib/MC/MCXCOFFStreamer.cpp

void MCXCOFFStreamer::emitXCOFFSymbolLinkageWithVisibility(
   // When the caller passes `MCSA_Invalid` for the visibility, do not emit one.
   if (Visibility == MCSA_Invalid)
     return;
 
   emitSymbolAttribute(Symbol, Visibility);
 }
 
 void MCXCOFFStreamer::emitXCOFFExceptDirective(const MCSymbol *Symbol,
-                                               MCSymbol *Trap, unsigned Lang,
-                                               unsigned Reason,
+                                               const MCSymbol *Trap,
+                                               unsigned Lang, unsigned Reason,
                                                unsigned FunctionSize,
                                                bool hasDebug) {
-  report_fatal_error(
-      "emitXCOFFExceptDirective not yet supported for integrated "
-      "assembler path.");
+  getAssembler().getWriter().addExceptionEntry(Symbol, Trap, Lang, Reason,
+                                               FunctionSize, hasDebug);
 }
 
 void MCXCOFFStreamer::emitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                                        unsigned ByteAlignment) {
   getAssembler().registerSymbol(*Symbol);
   Symbol->setExternal(cast<MCSymbolXCOFF>(Symbol)->getStorageClass() !=
                       XCOFF::C_HIDEXT);
   Symbol->setCommon(Size, ByteAlignment);

llvm/lib/MC/XCOFFObjectWriter.cpp

 #include "llvm/MC/MCXCOFFObjectWriter.h"
 #include "llvm/MC/StringTableBuilder.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/EndianStream.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
 
 #include <deque>
+#include <map>
 
 using namespace llvm;
 
 // An XCOFF object file has a limited set of predefined sections. The most
 // important ones for us (right now) are:
 // .text --> contains program code and read-only data.
 // .data --> contains initialized data, function descriptors, and the TOC.
 // .bss  --> contains uninitialized data.
DwarfSectionEntry(StringRef N, int32_t Flags,
     memcpy(Name, N.data(), N.size());
   }
 
   DwarfSectionEntry(DwarfSectionEntry &&s) = default;
 
   virtual ~DwarfSectionEntry() = default;
 };
 
+struct ExceptionTableEntry {
+  const MCSymbol *Trap;
+  uint64_t TrapAddress;
+  unsigned Lang;
+  unsigned Reason;
+
+  ExceptionTableEntry(const MCSymbol *Trap, unsigned Lang, unsigned Reason) :
+                      Trap(Trap), Lang(Lang), Reason(Reason) {}
+};
+
+struct ExceptionInfo {
+  const MCSymbol *FunctionSymbol;
+  unsigned FunctionSize;
+  std::vector<ExceptionTableEntry> Entries;
+};
+
+struct ExceptionSectionEntry : public SectionEntry {
+  std::map<const StringRef, ExceptionInfo> ExceptionTable;
+  bool isDebugEnabled = false;
+
+  ExceptionSectionEntry(StringRef N, int32_t Flags) :
+                        SectionEntry(N, Flags | XCOFF::STYP_EXCEPT) {
+    assert(N.size() <= XCOFF::NameSize && "Section too long.");
+    memcpy(Name, N.data(), N.size());
+  }
+
+  virtual ~ExceptionSectionEntry() = default;
+};
+
 class XCOFFObjectWriter : public MCObjectWriter {
 
   uint32_t SymbolTableEntryCount = 0;
   uint64_t SymbolTableOffset = 0;
   uint16_t SectionCount = 0;
   uint64_t RelocationEntryOffset = 0;
   std::vector<std::pair<std::string, size_t>> FileNames;
   bool HasVisibility = false;
class XCOFFObjectWriter : public MCObjectWriter {
 
   // All the XCOFF sections, in the order they will appear in the section header
   // table.
   std::array<CsectSectionEntry *const, 5> Sections{
       {&Text, &Data, &BSS, &TData, &TBSS}};
 
   std::vector<DwarfSectionEntry> DwarfSections;
 
+  ExceptionSectionEntry ExceptionSection;
+
   CsectGroup &getCsectGroup(const MCSectionXCOFF *MCSec);
 
   void reset() override;
 
   void executePostLayoutBinding(MCAssembler &, const MCAsmLayout &) override;
 
   void recordRelocation(MCAssembler &, const MCAsmLayout &, const MCFragment *,
                         const MCFixup &, MCValue, uint64_t &) override;
class XCOFFObjectWriter : public MCObjectWriter {
   void writeSectionForControlSectionEntry(const MCAssembler &Asm,
                                           const MCAsmLayout &Layout,
                                           const CsectSectionEntry &CsectEntry,
                                           uint64_t &CurrentAddressLocation);
   void writeSectionForDwarfSectionEntry(const MCAssembler &Asm,
                                         const MCAsmLayout &Layout,
                                         const DwarfSectionEntry &DwarfEntry,
                                         uint64_t &CurrentAddressLocation);
+  void writeSectionForExceptionSectionEntry(const MCAssembler &Asm,
+                                const MCAsmLayout &Layout,
+                                ExceptionSectionEntry &ExceptionEntry,
+                                uint64_t &CurrentAddressLocation);
   void writeSymbolTable(const MCAsmLayout &Layout);
   void writeSymbolAuxDwarfEntry(uint64_t LengthOfSectionPortion,
                                 uint64_t NumberOfRelocEnt = 0);
   void writeSymbolAuxCsectEntry(uint64_t SectionOrLength,
                                 uint8_t SymbolAlignmentAndType,
                                 uint8_t StorageMappingClass);
+  void writeSymbolAuxFunctionEntry(uint32_t EntryOffset,
+                                   uint32_t FunctionSize,
+                                   uint64_t LineNumberPointer,
+                                   uint32_t EndIndex);
+  void writeSymbolAuxExceptionEntry(uint64_t EntryOffset,
+                                    uint32_t FunctionSize, uint32_t EndIndex);
   void writeSymbolEntry(StringRef SymbolName, uint64_t Value,
                         int16_t SectionNumber, uint16_t SymbolType,
                         uint8_t StorageClass, uint8_t NumberOfAuxEntries = 1);
   void writeRelocations();
   void writeRelocation(XCOFFRelocation Reloc, const XCOFFSection &Section);
 
   // Called after all the csects and symbols have been processed by
   // `executePostLayoutBinding`, this function handles building up the majority
   // of the structures in the object file representation. Namely:
   // *) Calculates physical/virtual addresses, raw-pointer offsets, and section
   //    sizes.
   // *) Assigns symbol table indices.
   // *) Builds up the section header table by adding any non-empty sections to
   //    `Sections`.
   void assignAddressesAndIndices(const MCAsmLayout &);
   void finalizeSectionInfo();
+  void addExceptionEntry(const MCSymbol *Symbol, const MCSymbol *Trap,
+                         unsigned LanguageCode, unsigned ReasonCode,
+                         unsigned FunctionSize, bool hasDebug) override;
+  bool hasExceptionSection() {
+    return !ExceptionSection.ExceptionTable.empty();
+  }
+  unsigned getExceptionSectionSize();
+  unsigned getExceptionOffset(const MCSymbol *Symbol);
 
   size_t auxiliaryHeaderSize() const {
     // 64-bit object files have no auxiliary header.
     return HasVisibility && !is64Bit() ? XCOFF::AuxFileHeaderSizeShort : 0;
   }
 
 public:
   XCOFFObjectWriter(std::unique_ptr<MCXCOFFObjectTargetWriter> MOTW,
: W(OS, support::big), TargetObjectWriter(std::move(MOTW)),
            CsectGroups{&ProgramCodeCsects, &ReadOnlyCsects}),
       Data(".data", XCOFF::STYP_DATA, /* IsVirtual */ false,
            CsectGroups{&DataCsects, &FuncDSCsects, &TOCCsects}),
       BSS(".bss", XCOFF::STYP_BSS, /* IsVirtual */ true,
           CsectGroups{&BSSCsects}),
       TData(".tdata", XCOFF::STYP_TDATA, /* IsVirtual */ false,
             CsectGroups{&TDataCsects}),
       TBSS(".tbss", XCOFF::STYP_TBSS, /* IsVirtual */ true,
-           CsectGroups{&TBSSCsects}) {}
+           CsectGroups{&TBSSCsects}),
+      ExceptionSection(".except", XCOFF::STYP_EXCEPT) {}
 
 void XCOFFObjectWriter::reset() {
   // Clear the mappings we created.
   SymbolIndexMap.clear();
   SectionMap.clear();
 
   UndefinedCsects.clear();
   // Reset any sections we have written to, and empty the section header table.
   for (auto *Sec : Sections)
     Sec->reset();
   for (auto &DwarfSec : DwarfSections)
     DwarfSec.reset();
+  ExceptionSection.reset();
 
   // Reset states in XCOFFObjectWriter.
   SymbolTableEntryCount = 0;
   SymbolTableOffset = 0;
   SectionCount = 0;
   RelocationEntryOffset = 0;
   Strings.clear();
 
void XCOFFObjectWriter::writeSections(const MCAssembler &Asm,
                                       const MCAsmLayout &Layout) {
   uint64_t CurrentAddressLocation = 0;
   for (const auto *Section : Sections)
     writeSectionForControlSectionEntry(Asm, Layout, *Section,
                                        CurrentAddressLocation);
   for (const auto &DwarfSection : DwarfSections)
     writeSectionForDwarfSectionEntry(Asm, Layout, DwarfSection,
                                      CurrentAddressLocation);
+  writeSectionForExceptionSectionEntry(Asm, Layout, ExceptionSection,
+                                       CurrentAddressLocation);
 }
 
 uint64_t XCOFFObjectWriter::writeObject(MCAssembler &Asm,
                                         const MCAsmLayout &Layout) {
   // We always emit a timestamp of 0 for reproducibility, so ensure incremental
   // linking is not enabled, in case, like with Windows COFF, such a timestamp
   // is incompatible with incremental linking of XCOFF.
   if (Asm.isIncrementalLinkerCompatible())
void XCOFFObjectWriter::writeSymbolEntry(StringRef SymbolName, uint64_t Value,
   if (is64Bit()) {
     W.write<uint64_t>(Value);
     W.write<uint32_t>(Strings.getOffset(SymbolName));
   } else {
     writeSymbolName(SymbolName);
     W.write<uint32_t>(Value);
   }
   W.write<int16_t>(SectionNumber);
-  // TODO Set the function indicator (bit 10, 0x0020) for functions
-  // when debugging is enabled.
   W.write<uint16_t>(SymbolType);
   W.write<uint8_t>(StorageClass);
   W.write<uint8_t>(NumberOfAuxEntries);
 }
 
 void XCOFFObjectWriter::writeSymbolAuxCsectEntry(uint64_t SectionOrLength,
                                                  uint8_t SymbolAlignmentAndType,
                                                  uint8_t StorageMappingClass) {
   W.write<uint32_t>(is64Bit() ? Lo_32(SectionOrLength) : SectionOrLength);

 }
 
 void XCOFFObjectWriter::writeSymbolEntryForCsectMemberLabel(
     const Symbol &SymbolRef, const XCOFFSection &CSectionRef,
     int16_t SectionIndex, uint64_t SymbolOffset) {
   assert(SymbolOffset <= MaxRawDataSize - CSectionRef.Address &&
          "Symbol address overflowed.");
 
+  auto Entry = ExceptionSection.ExceptionTable.find(SymbolRef.MCSym->getName());
+  if (Entry != ExceptionSection.ExceptionTable.end()) {
     writeSymbolEntry(SymbolRef.getSymbolTableName(),
                      CSectionRef.Address + SymbolOffset, SectionIndex,
-                   SymbolRef.getVisibilityType(), SymbolRef.getStorageClass());
-
+                     // In the old version of the 32-bit XCOFF interpretation,
+                     // symbols may require bit 10 (0x0020) to be set if the
+                     // symbol is a function, otherwise the bit should be 0.
+                     is64Bit() ? SymbolRef.getVisibilityType()
+                               : SymbolRef.getVisibilityType() | 0x0020,
+                     SymbolRef.getStorageClass(),
+                     (is64Bit() && ExceptionSection.isDebugEnabled) ? 3 : 2);
+    if (is64Bit() && ExceptionSection.isDebugEnabled) {
+      // On 64 bit with debugging enabled, we have a csect, exception, and
+      // function auxilliary entries, so we must increment symbol index by 4.
+      writeSymbolAuxExceptionEntry(
+          ExceptionSection.FileOffsetToData +
+              getExceptionOffset(Entry->second.FunctionSymbol),
+          Entry->second.FunctionSize,
+          SymbolIndexMap[Entry->second.FunctionSymbol] + 4);
+    }
+    // For exception section entries, csect and function auxilliary entries
+    // must exist. On 64-bit there is also an exception auxilliary entry.
+    writeSymbolAuxFunctionEntry(
+        ExceptionSection.FileOffsetToData +
+            getExceptionOffset(Entry->second.FunctionSymbol),
+        Entry->second.FunctionSize, 0,
+        (is64Bit() && ExceptionSection.isDebugEnabled)
+            ? SymbolIndexMap[Entry->second.FunctionSymbol] + 4
+            : SymbolIndexMap[Entry->second.FunctionSymbol] + 3);
+  } else {
+    writeSymbolEntry(SymbolRef.getSymbolTableName(),
+                     CSectionRef.Address + SymbolOffset, SectionIndex,
+                     SymbolRef.getVisibilityType(),
+                     SymbolRef.getStorageClass());
+  }
   writeSymbolAuxCsectEntry(CSectionRef.SymbolTableIndex, XCOFF::XTY_LD,
                            CSectionRef.MCSec->getMappingClass());
 }
 
 void XCOFFObjectWriter::writeSymbolEntryForDwarfSection(
     const XCOFFSection &DwarfSectionRef, int16_t SectionIndex) {
   assert(DwarfSectionRef.MCSec->isDwarfSect() && "Not a DWARF section!");
 
   writeSymbolEntry(DwarfSectionRef.getSymbolTableName(), /*Value=*/0,
                    SectionIndex, /*SymbolType=*/0, XCOFF::C_DWARF);
 
   writeSymbolAuxDwarfEntry(DwarfSectionRef.Size);
 }
 
 void XCOFFObjectWriter::writeSymbolEntryForControlSection(
     const XCOFFSection &CSectionRef, int16_t SectionIndex,
     XCOFF::StorageClass StorageClass) {
   writeSymbolEntry(CSectionRef.getSymbolTableName(), CSectionRef.Address,
                    SectionIndex, CSectionRef.getVisibilityType(), StorageClass);
 
   writeSymbolAuxCsectEntry(CSectionRef.Size, getEncodedType(CSectionRef.MCSec),
                            CSectionRef.MCSec->getMappingClass());
 }
 
+void XCOFFObjectWriter::writeSymbolAuxFunctionEntry(uint32_t EntryOffset,
+                                                    uint32_t FunctionSize,
+                                                    uint64_t LineNumberPointer,
+                                                    uint32_t EndIndex) {
+  if (is64Bit())
+    writeWord(LineNumberPointer);
+  else
+    W.write<uint32_t>(EntryOffset);
+  W.write<uint32_t>(FunctionSize);
+  if (!is64Bit())
+    writeWord(LineNumberPointer);
+  W.write<uint32_t>(EndIndex);
+  if (is64Bit()) {
+    W.OS.write_zeros(1);
+    W.write<uint8_t>(XCOFF::AUX_FCN);
+  } else {
+    W.OS.write_zeros(2);
+  }
+}
+
+void XCOFFObjectWriter::writeSymbolAuxExceptionEntry(uint64_t EntryOffset,
+                                                     uint32_t FunctionSize,
+                                                     uint32_t EndIndex) {
+  assert(is64Bit() && "Exception auxilliary entries are 64-bit only.");
+  W.write<uint64_t>(EntryOffset);
+  W.write<uint32_t>(FunctionSize);
+  W.write<uint32_t>(EndIndex);
+  W.OS.write_zeros(1); // Pad (unused)
+  W.write<uint8_t>(XCOFF::AUX_EXCEPT);
+}
+
 void XCOFFObjectWriter::writeFileHeader() {
   W.write<uint16_t>(is64Bit() ? XCOFF::XCOFF64 : XCOFF::XCOFF32);
   W.write<uint16_t>(SectionCount);
   W.write<int32_t>(0); // TimeStamp
   writeWord(SymbolTableOffset);
   if (is64Bit()) {
     W.write<uint16_t>(auxiliaryHeaderSize());
     W.write<uint16_t>(0); // Flags
auto writeSectionHeader = [&](const SectionEntry *Sec, bool IsDwarf) {
 
     return true;
   };
 
   for (const auto *CsectSec : Sections)
     writeSectionHeader(CsectSec, /* IsDwarf */ false);
   for (const auto &DwarfSec : DwarfSections)
     writeSectionHeader(&DwarfSec, /* IsDwarf */ true);
+  if (hasExceptionSection())
+    writeSectionHeader(&ExceptionSection, false);
 }
 
 void XCOFFObjectWriter::writeRelocation(XCOFFRelocation Reloc,
                                         const XCOFFSection &Section) {
   if (Section.MCSec->isCsect())
     writeWord(Section.Address + Reloc.FixupOffsetInCsect);
   else {
     // DWARF sections' address is set to 0.
for (auto &DwarfSec : DwarfSections)
     calcOffsetToRelocations(&DwarfSec, /* IsDwarf */ true);
 
   // TODO Error check that the number of symbol table entries fits in 32-bits
   // signed ...
   if (SymbolTableEntryCount)
     SymbolTableOffset = RawPointer;
 }
 
+void XCOFFObjectWriter::addExceptionEntry(const MCSymbol *Symbol,
+                                          const MCSymbol *Trap, 
+                                          unsigned LanguageCode,
+                                          unsigned ReasonCode,
+                                          unsigned FunctionSize,
+                                          bool hasDebug) {
+  // If a module had debug info, debugging is enabled and XCOFF emits the
+  // exception auxilliary entry.
+  if (hasDebug)
+    ExceptionSection.isDebugEnabled = true;
+  auto Entry = ExceptionSection.ExceptionTable.find(Symbol->getName());
+  if (Entry != ExceptionSection.ExceptionTable.end()) {
+    Entry->second.Entries.push_back(
+        ExceptionTableEntry(Trap, LanguageCode, ReasonCode));
+    return;
+  }
+  ExceptionInfo NewEntry;
+  NewEntry.FunctionSymbol = Symbol;
+  NewEntry.FunctionSize = FunctionSize;
+  NewEntry.Entries.push_back(
+      ExceptionTableEntry(Trap, LanguageCode, ReasonCode));
+  ExceptionSection.ExceptionTable.insert(
+      std::pair<const StringRef, ExceptionInfo>(Symbol->getName(), NewEntry));
+}
+
+unsigned XCOFFObjectWriter::getExceptionSectionSize() {
+  unsigned EntryNum=0;
+
+  for (auto it = ExceptionSection.ExceptionTable.begin();
+      it != ExceptionSection.ExceptionTable.end(); ++it)
+    // The size() gets +1 to account for the initial entry containing the
+    // symbol table index.
+    EntryNum += it->second.Entries.size() + 1;
+
+  return EntryNum * (is64Bit() ? XCOFF::ExceptionSectionEntrySize64 :
+      XCOFF::ExceptionSectionEntrySize32);
+}
+
+unsigned XCOFFObjectWriter::getExceptionOffset(const MCSymbol *Symbol) {
+  unsigned EntryNum = 0;
+  for (auto it = ExceptionSection.ExceptionTable.begin();
+      it != ExceptionSection.ExceptionTable.end(); ++it) {
+    if (Symbol == it->second.FunctionSymbol)
+      break;
+    EntryNum += it->second.Entries.size() + 1;
+  }
+  return EntryNum * (is64Bit() ? XCOFF::ExceptionSectionEntrySize64 :
+      XCOFF::ExceptionSectionEntrySize32);
+}
+
 void XCOFFObjectWriter::assignAddressesAndIndices(const MCAsmLayout &Layout) {
   // The symbol table starts with all the C_FILE symbols.
   uint32_t SymbolTableIndex = FileNames.size();
 
   // Calculate indices for undefined symbols.
   for (auto &Csect : UndefinedCsects) {
     Csect.Size = 0;
     Csect.Address = 0;
for (auto *Group : Section->Groups) {
         Csect.Size = Layout.getSectionAddressSize(MCSec);
         Address = Csect.Address + Csect.Size;
         Csect.SymbolTableIndex = SymbolTableIndex;
         SymbolIndexMap[MCSec->getQualNameSymbol()] = Csect.SymbolTableIndex;
         // 1 main and 1 auxiliary symbol table entry for the csect.
         SymbolTableIndex += 2;
 
         for (auto &Sym : Csect.Syms) {
+          bool hasExceptEntry = false;
+          auto Entry =
+              ExceptionSection.ExceptionTable.find(Sym.MCSym->getName());
+          if(Entry != ExceptionSection.ExceptionTable.end()) {
+            hasExceptEntry = true;
+            for (auto &TrapEntry : Entry->second.Entries) {
+              TrapEntry.TrapAddress = Layout.getSymbolOffset(*(Sym.MCSym)) +
+                                      TrapEntry.Trap->getOffset();
+              }
+          }
           Sym.SymbolTableIndex = SymbolTableIndex;
           SymbolIndexMap[Sym.MCSym] = Sym.SymbolTableIndex;
           // 1 main and 1 auxiliary symbol table entry for each contained
-          // symbol.
+          // symbol. For symbols with exception section entries, a function
+          // auxilliary entry is needed, and on 64-bit XCOFF with debugging
+          // enabled, an additional exception auxilliary entry is needed.
           SymbolTableIndex += 2;
+          if (hasExceptionSection() && hasExceptEntry) {
+            if (is64Bit() && ExceptionSection.isDebugEnabled)
+              SymbolTableIndex += 2;
+            else
+              SymbolTableIndex += 1;
+          }
         }
       }
 
       if (!SectionAddressSet) {
         Section->Address = Group->front().Address;
         SectionAddressSet = true;
       }
     }
void XCOFFObjectWriter::assignAddressesAndIndices(const MCAsmLayout &Layout) {
   }
   if (LastDwarfSection) {
     // Make the final DWARF section address align to the default section
     // alignment for follow contents.
     Address = alignTo(LastDwarfSection->Address + LastDwarfSection->Size,
                       DefaultSectionAlign);
     LastDwarfSection->MemorySize = Address - LastDwarfSection->Address;
   }
-
+  if (hasExceptionSection()) {
+    ExceptionSection.Index = SectionIndex++;
+    SectionCount++;
+    ExceptionSection.Address = 0;
+    ExceptionSection.Size = getExceptionSectionSize();
+    Address += ExceptionSection.Size;
+    Address = alignTo(Address, DefaultSectionAlign);
+  }
   SymbolTableEntryCount = SymbolTableIndex;
 
   // Calculate the RawPointer value for each section.
   uint64_t RawPointer =
       (is64Bit() ? (XCOFF::FileHeaderSize64 +
                     SectionCount * XCOFF::SectionHeaderSize64)
                  : (XCOFF::FileHeaderSize32 +
                     SectionCount * XCOFF::SectionHeaderSize32)) +
for (auto &DwarfSection : DwarfSections) {
     DwarfSection.FileOffsetToData = RawPointer;
 
     RawPointer += DwarfSection.MemorySize;
 
     assert(RawPointer <= MaxRawDataSize &&
            "Section raw data overflowed this object file.");
   }
 
+  if (hasExceptionSection()) {
+    ExceptionSection.FileOffsetToData = RawPointer;
+    RawPointer += ExceptionSection.Size;
+
+    assert(RawPointer <= MaxRawDataSize &&
+           "Section raw data overflowed this object file.");
+  }
+
   RelocationEntryOffset = RawPointer;
 }
 
 void XCOFFObjectWriter::writeSectionForControlSectionEntry(
     const MCAssembler &Asm, const MCAsmLayout &Layout,
     const CsectSectionEntry &CsectEntry, uint64_t &CurrentAddressLocation) {
   // Nothing to write for this Section.
   if (CsectEntry.Index == SectionEntry::UninitializedIndex)
void XCOFFObjectWriter::writeSectionForDwarfSectionEntry(
   uint32_t Mod = CurrentAddressLocation % DefaultSectionAlign;
   uint32_t TailPaddingSize = Mod ? DefaultSectionAlign - Mod : 0;
   if (TailPaddingSize)
     W.OS.write_zeros(TailPaddingSize);
 
   CurrentAddressLocation += TailPaddingSize;
 }
 
+void XCOFFObjectWriter::writeSectionForExceptionSectionEntry(
+    const MCAssembler &Asm, const MCAsmLayout &Layout,
+    ExceptionSectionEntry &ExceptionEntry, uint64_t &CurrentAddressLocation) {
+  for (auto it = ExceptionEntry.ExceptionTable.begin();
+       it != ExceptionEntry.ExceptionTable.end(); it++) {
+    // For every symbol that has exception entries, you must start the entries
+    // with an initial symbol table index entry
+    W.write<uint32_t>(SymbolIndexMap[it->second.FunctionSymbol]);
+    if (is64Bit()) {
+      // 4-byte padding on 64-bit.
+      W.OS.write_zeros(4);
+    }
+    W.OS.write_zeros(2);
+    for (auto &TrapEntry : it->second.Entries) {
+      writeWord(TrapEntry.TrapAddress);
+      W.write<uint8_t>(TrapEntry.Lang);
+      W.write<uint8_t>(TrapEntry.Reason);
+    }
+  }
+
+  CurrentAddressLocation += getExceptionSectionSize();
+}
+
 // Takes the log base 2 of the alignment and shifts the result into the 5 most
 // significant bits of a byte, then or's in the csect type into the least
 // significant 3 bits.
 uint8_t getEncodedType(const MCSectionXCOFF *Sec) {
   unsigned Align = Sec->getAlignment();
   assert(isPowerOf2_32(Align) && "Alignment must be a power of 2.");
   unsigned Log2Align = Log2_32(Align);
   // Result is a number in the range [0, 31] which fits in the 5 least

llvm/test/CodeGen/PowerPC/aix-xcoff-exception-section-debug.ll

+; This file contains exception section testing for when debug information is present.
+; The 32-bit test should not print exception auxilliary entries because they are a 64-bit only feature.
+; Exception auxilliary entries are present in the 64-bit tests because 64-bit && debug enabled are the requirements.
+; RUN: llc -mtriple=powerpc-ibm-aix-xcoff -filetype=obj -o %t_32.o < %s
+; RUN: llvm-readobj --syms %t_32.o | FileCheck %s --check-prefix=SYMS32
+; RUN: llc -mtriple=powerpc64-unknown-aix -filetype=obj -o %t_32.o < %s
+; RUN: llvm-readobj --syms %t_32.o | FileCheck %s --check-prefix=SYMS64
+
+; If any debug information is included in a module and is XCOFF64, exception auxilliary entries are emitted
+
+!llvm.module.flags = !{!0, !1}
+!llvm.dbg.cu = !{!2}
+
+!0 = !{i32 2, !"Dwarf Version", i32 3}
+!1 = !{i32 2, !"Debug Info Version", i32 3}
+!2 = distinct !DICompileUnit(language: DW_LANG_Fortran95, file: !3, producer: "ASTI IR translator", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, splitDebugInlining: false)
+!3 = !DIFile(filename: "t.f", directory: ".")
+!4 = distinct !DISubprogram(name: "test__trap_annotation_debug", linkageName: "test__trap_annotation_debug", scope: !3, file: !3, line: 1, type: !5, scopeLine: 1, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !2, retainedNodes: !6)
+!5 = !DISubroutineType(types: !6)
+!6 = !{}
+!7 = !DILocation(line: 4, column: 1, scope: !4)
+!8 = !{!"ppc-trap-reason", !"1", !"2"}
+declare void @llvm.ppc.trap(i32 %a)
+define dso_local void @sub_test() {
+  call void @llvm.ppc.trap(i32 1), !annotation !8
+  ret void
+}
+define dso_local void @test__trap_annotation_debug(i32 %a) !dbg !4 {
+  call void @llvm.ppc.trap(i32 %a), !annotation !8
+  call void @sub_test()
+  call void @llvm.ppc.trap(i32 %a), !annotation !8
+  ret void
+}
+
+; SYMS32:           Index: [[#IND:]]{{.*}}{{[[:space:]] *}}Name: .sub_test
+; SYMS32-NEXT:      Value (RelocatableAddress): 0x0
+; SYMS32-NEXT:      Section: .text
+; SYMS32-NEXT:      Type: 0x20
+; SYMS32-NEXT:      StorageClass: C_EXT (0x2)
+; SYMS32-NEXT:      NumberOfAuxEntries: 2
+; SYMS32-NEXT:      Function Auxiliary Entry {
+; SYMS32-NEXT:        Index: [[#IND+1]]
+; SYMS32-NEXT:        OffsetToExceptionTable: 0x2A8
+; SYMS32-NEXT:        SizeOfFunction: 0xC
+; SYMS32-NEXT:        PointerToLineNum: 0x0
+; SYMS32-NEXT:        SymbolIndexOfNextBeyond: [[#IND+3]] 
+; SYMS32-NEXT:      }
+; SYMS32-NEXT:      CSECT Auxiliary Entry {
+; SYMS32-NEXT:        Index: [[#IND+2]]
+; SYMS32-NEXT:        ContainingCsectSymbolIndex: 1
+; SYMS32-NEXT:        ParameterHashIndex: 0x0
+; SYMS32-NEXT:        TypeChkSectNum: 0x0
+; SYMS32-NEXT:        SymbolAlignmentLog2: 0
+; SYMS32-NEXT:        SymbolType: XTY_LD (0x2)
+; SYMS32-NEXT:        StorageMappingClass: XMC_PR (0x0)
+; SYMS32-NEXT:        StabInfoIndex: 0x0
+; SYMS32-NEXT:        StabSectNum: 0x0
+; SYMS32-NEXT:      }
+; SYMS32-NEXT:    }
+; SYMS32-NEXT:    Symbol {
+; SYMS32-NEXT:      Index: [[#IND+3]]
+; SYMS32-NEXT:      Name: .test__trap_annotation
+; SYMS32-NEXT:      Value (RelocatableAddress): 0x28
+; SYMS32-NEXT:      Section: .text
+; SYMS32-NEXT:      Type: 0x20
+; SYMS32-NEXT:      StorageClass: C_EXT (0x2)
+; SYMS32-NEXT:      NumberOfAuxEntries: 2
+; SYMS32-NEXT:      Function Auxiliary Entry {
+; SYMS32-NEXT:        Index: [[#IND+4]]
+; SYMS32-NEXT:        OffsetToExceptionTable: 0x2B4
+; SYMS32-NEXT:        SizeOfFunction: 0x34
+; SYMS32-NEXT:        PointerToLineNum: 0x0
+; SYMS32-NEXT:        SymbolIndexOfNextBeyond: [[#IND+6]]
+; SYMS32-NEXT:      }
+; SYMS32-NEXT:      CSECT Auxiliary Entry {
+; SYMS32-NEXT:        Index: [[#IND+5]]
+; SYMS32-NEXT:        ContainingCsectSymbolIndex: 1
+; SYMS32-NEXT:        ParameterHashIndex: 0x0
+; SYMS32-NEXT:        TypeChkSectNum: 0x0
+; SYMS32-NEXT:        SymbolAlignmentLog2: 0
+; SYMS32-NEXT:        SymbolType: XTY_LD (0x2)
+; SYMS32-NEXT:        StorageMappingClass: XMC_PR (0x0)
+; SYMS32-NEXT:        StabInfoIndex: 0x0
+; SYMS32-NEXT:        StabSectNum: 0x0
+; SYMS32-NEXT:      }
+; SYMS32-NEXT:    }
+
+; SYMS64:           Index: [[#IND:]]{{.*}}{{[[:space:]] *}}Name: .sub_test
+; SYMS64-NEXT:      Value (RelocatableAddress): 0x0
+; SYMS64-NEXT:      Section: .text
+; SYMS64-NEXT:      Type: 0x0
+; SYMS64-NEXT:      StorageClass: C_EXT (0x2)
+; SYMS64-NEXT:      NumberOfAuxEntries: 3
+; SYMS64-NEXT:      Exception Auxiliary Entry {
+; SYMS64-NEXT:        Index: [[#IND+1]]
+; SYMS64-NEXT:        OffsetToExceptionTable: 0x398
+; SYMS64-NEXT:        SizeOfFunction: 0x18
+; SYMS64-NEXT:        SymbolIndexOfNextBeyond: [[#IND+4]]
+; SYMS64-NEXT:        Auxiliary Type: AUX_EXCEPT (0xFF)
+; SYMS64-NEXT:      }
+; SYMS64-NEXT:      Function Auxiliary Entry {
+; SYMS64-NEXT:        Index: [[#IND+2]]
+; SYMS64-NEXT:        SizeOfFunction: 0x18
+; SYMS64-NEXT:        PointerToLineNum: 0x0
+; SYMS64-NEXT:        SymbolIndexOfNextBeyond: [[#IND+4]]
+; SYMS64-NEXT:        Auxiliary Type: AUX_FCN (0xFE)
+; SYMS64-NEXT:      }
+; SYMS64-NEXT:      CSECT Auxiliary Entry {
+; SYMS64-NEXT:        Index: [[#IND+3]]
+; SYMS64-NEXT:        ContainingCsectSymbolIndex: 1
+; SYMS64-NEXT:        ParameterHashIndex: 0x0
+; SYMS64-NEXT:        TypeChkSectNum: 0x0
+; SYMS64-NEXT:        SymbolAlignmentLog2: 0
+; SYMS64-NEXT:        SymbolType: XTY_LD (0x2)
+; SYMS64-NEXT:        StorageMappingClass: XMC_PR (0x0)
+; SYMS64-NEXT:        Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NEXT:      }
+; SYMS64-NEXT:    }
+; SYMS64-NEXT:    Symbol {
+; SYMS64-NEXT:      Index: [[#IND+4]]
+; SYMS64-NEXT:      Name: .test__trap_annotation_debug
+; SYMS64-NEXT:      Value (RelocatableAddress): 0x28
+; SYMS64-NEXT:      Section: .text
+; SYMS64-NEXT:      Type: 0x0
+; SYMS64-NEXT:      StorageClass: C_EXT (0x2)
+; SYMS64-NEXT:      NumberOfAuxEntries: 3
+; SYMS64-NEXT:      Exception Auxiliary Entry {
+; SYMS64-NEXT:        Index: [[#IND+5]]
+; SYMS64-NEXT:        OffsetToExceptionTable: 0x3AC
+; SYMS64-NEXT:        SizeOfFunction: 0x68
+; SYMS64-NEXT:        SymbolIndexOfNextBeyond: [[#IND+8]]
+; SYMS64-NEXT:        Auxiliary Type: AUX_EXCEPT (0xFF)
+; SYMS64-NEXT:      }
+; SYMS64-NEXT:      Function Auxiliary Entry {
+; SYMS64-NEXT:        Index: [[#IND+6]]
+; SYMS64-NEXT:        SizeOfFunction: 0x68
+; SYMS64-NEXT:        PointerToLineNum: 0x0
+; SYMS64-NEXT:        SymbolIndexOfNextBeyond: [[#IND+8]]
+; SYMS64-NEXT:        Auxiliary Type: AUX_FCN (0xFE)
+; SYMS64-NEXT:      }
+; SYMS64-NEXT:      CSECT Auxiliary Entry {
+; SYMS64-NEXT:        Index: [[#IND+7]]
+; SYMS64-NEXT:        ContainingCsectSymbolIndex: 1
+; SYMS64-NEXT:        ParameterHashIndex: 0x0
+; SYMS64-NEXT:        TypeChkSectNum: 0x0
+; SYMS64-NEXT:        SymbolAlignmentLog2: 0
+; SYMS64-NEXT:        SymbolType: XTY_LD (0x2)
+; SYMS64-NEXT:        StorageMappingClass: XMC_PR (0x0)
+; SYMS64-NEXT:        Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NEXT:      }
+; SYMS64-NEXT:    }

llvm/test/CodeGen/PowerPC/aix-xcoff-exception-section.ll

+; Testing 32-bit and 64-bit exception section entries, no exception auxilliary
+; entries should be produced as no debug information is specified.
+; RUN: llc -mtriple=powerpc-ibm-aix-xcoff -filetype=obj -o %t_32.o < %s
+; RUN: llvm-readobj --exception-section %t_32.o | FileCheck %s --check-prefix=EXCEPT
+; RUN: llvm-readobj --section-headers %t_32.o | FileCheck %s --check-prefix=READ
+; RUN: llvm-readobj --syms %t_32.o | FileCheck %s --check-prefix=SYMS
+
+; RUN: llc -mtriple=powerpc64-unknown-aix -filetype=obj -o %t_64.o < %s
+; RUN: llvm-readobj --exception-section %t_64.o | FileCheck %s --check-prefix=EXCEPT64
+; RUN: llvm-readobj --section-headers %t_64.o | FileCheck %s --check-prefix=READ64
+; RUN: llvm-readobj --syms %t_64.o | FileCheck %s --check-prefix=SYMS64
+
+!1 = !{!"ppc-trap-reason", !"1", !"2"}
+declare void @llvm.ppc.trap(i32 %a)
+define dso_local void @sub_test() {
+  call void @llvm.ppc.trap(i32 1), !annotation !1
+  ret void
+}
+define dso_local void @test__trap_annotation(i32 %a) {
+  call void @llvm.ppc.trap(i32 %a), !annotation !1
+  call void @sub_test()
+  call void @llvm.ppc.trap(i32 %a), !annotation !1
+  ret void
+}
+
+; EXCEPT:       Exception section {
+; EXCEPT-NEXT:    Symbol: .sub_test (3)
+; EXCEPT-NEXT:    LangID: 0
+; EXCEPT-NEXT:    Reason: 0
+; EXCEPT-NEXT:    Trap Instr Addr: 0x4
+; EXCEPT-NEXT:    LangID: 1
+; EXCEPT-NEXT:    Reason: 2
+; EXCEPT-NEXT:    Symbol: .test__trap_annotation (6)
+; EXCEPT-NEXT:    LangID: 0
+; EXCEPT-NEXT:    Reason: 0
+; EXCEPT-NEXT:    Trap Instr Addr: 0x3C
+; EXCEPT-NEXT:    LangID: 1
+; EXCEPT-NEXT:    Reason: 2
+; EXCEPT-NEXT:    Trap Instr Addr: 0x44
+; EXCEPT-NEXT:    LangID: 1
+; EXCEPT-NEXT:    Reason: 2
+; EXCEPT-NEXT:  }
+
+; There are multiple "Section {" lines in the readobj output so we need to start this READ check
+; on a unique line (Type: STYP_DATA (0x40)) so that the checks know where to start reading
+; READ:           Type: STYP_DATA (0x40)
+; READ-NEXT:    }
+; READ-NEXT:    Section {
+; READ-NEXT:      Index: 3
+; READ-NEXT:      Name: .except
+; READ-NEXT:      PhysicalAddress: 0x0
+; READ-NEXT:      VirtualAddress: 0x0
+; READ-NEXT:      Size: 0x1E
+; READ-NEXT:      RawDataOffset: 0x12C
+; READ-NEXT:      RelocationPointer: 0x0
+; READ-NEXT:      LineNumberPointer: 0x0
+; READ-NEXT:      NumberOfRelocations: 0
+; READ-NEXT:      NumberOfLineNumbers: 0
+; READ-NEXT:      Type: STYP_EXCEPT (0x100)
+; READ-NEXT:    }
+; READ-NEXT:  ]
+
+; SYMS:           Index: [[#IND:]]{{.*}}{{[[:space:]] *}}Name: .sub_test
+; SYMS-NEXT:      Value (RelocatableAddress): 0x0
+; SYMS-NEXT:      Section: .text
+; SYMS-NEXT:      Type: 0x20
+; SYMS-NEXT:      StorageClass: C_EXT (0x2)
+; SYMS-NEXT:      NumberOfAuxEntries: 2
+; SYMS-NEXT:      Function Auxiliary Entry {
+; SYMS-NEXT:        Index: [[#IND+1]]
+; SYMS-NEXT:        OffsetToExceptionTable: 0x12C
+; SYMS-NEXT:        SizeOfFunction: 0xC
+; SYMS-NEXT:        PointerToLineNum: 0x0
+; SYMS-NEXT:        SymbolIndexOfNextBeyond: [[#IND+3]]
+; SYMS-NEXT:      }
+; SYMS-NEXT:      CSECT Auxiliary Entry {
+; SYMS-NEXT:        Index: [[#IND+2]]
+; SYMS-NEXT:        ContainingCsectSymbolIndex: 1
+; SYMS-NEXT:        ParameterHashIndex: 0x0
+; SYMS-NEXT:        TypeChkSectNum: 0x0
+; SYMS-NEXT:        SymbolAlignmentLog2: 0
+; SYMS-NEXT:        SymbolType: XTY_LD (0x2)
+; SYMS-NEXT:        StorageMappingClass: XMC_PR (0x0)
+; SYMS-NEXT:        StabInfoIndex: 0x0
+; SYMS-NEXT:        StabSectNum: 0x0
+; SYMS-NEXT:      }
+; SYMS-NEXT:    }
+; SYMS-NEXT:    Symbol {
+; SYMS-NEXT:      Index: [[#IND+3]]
+; SYMS-NEXT:      Name: .test__trap_annotation
+; SYMS-NEXT:      Value (RelocatableAddress): 0x28
+; SYMS-NEXT:      Section: .text
+; SYMS-NEXT:      Type: 0x20
+; SYMS-NEXT:      StorageClass: C_EXT (0x2)
+; SYMS-NEXT:      NumberOfAuxEntries: 2
+; SYMS-NEXT:      Function Auxiliary Entry {
+; SYMS-NEXT:        Index: [[#IND+4]]
+; SYMS-NEXT:        OffsetToExceptionTable: 0x138
+; SYMS-NEXT:        SizeOfFunction: 0x34
+; SYMS-NEXT:        PointerToLineNum: 0x0
+; SYMS-NEXT:        SymbolIndexOfNextBeyond: [[#IND+6]]
+; SYMS-NEXT:      }
+; SYMS-NEXT:      CSECT Auxiliary Entry {
+; SYMS-NEXT:        Index: [[#IND+5]]
+; SYMS-NEXT:        ContainingCsectSymbolIndex: 1
+; SYMS-NEXT:        ParameterHashIndex: 0x0
+; SYMS-NEXT:        TypeChkSectNum: 0x0
+; SYMS-NEXT:        SymbolAlignmentLog2: 0
+; SYMS-NEXT:        SymbolType: XTY_LD (0x2)
+; SYMS-NEXT:        StorageMappingClass: XMC_PR (0x0)
+; SYMS-NEXT:        StabInfoIndex: 0x0
+; SYMS-NEXT:        StabSectNum: 0x0
+; SYMS-NEXT:      }
+; SYMS-NEXT:    }
+
+; EXCEPT64:       Exception section {
+; EXCEPT64-NEXT:    Symbol: .sub_test (3)
+; EXCEPT64-NEXT:    LangID: 0
+; EXCEPT64-NEXT:    Reason: 0
+; EXCEPT64-NEXT:    Trap Instr Addr: 0x4
+; EXCEPT64-NEXT:    LangID: 1
+; EXCEPT64-NEXT:    Reason: 2
+; EXCEPT64-NEXT:    Symbol: .test__trap_annotation (6)
+; EXCEPT64-NEXT:    LangID: 0
+; EXCEPT64-NEXT:    Reason: 0
+; EXCEPT64-NEXT:    Trap Instr Addr: 0x3C
+; EXCEPT64-NEXT:    LangID: 1
+; EXCEPT64-NEXT:    Reason: 2
+; EXCEPT64-NEXT:    Trap Instr Addr: 0x44
+; EXCEPT64-NEXT:    LangID: 1
+; EXCEPT64-NEXT:    Reason: 2
+; EXCEPT64-NEXT:  }
+
+; READ64:           Type: STYP_DATA (0x40)
+; READ64-NEXT:    }
+; READ64-NEXT:    Section {
+; READ64-NEXT:      Index: 3
+; READ64-NEXT:      Name: .except
+; READ64-NEXT:      PhysicalAddress: 0x0
+; READ64-NEXT:      VirtualAddress: 0x0
+; READ64-NEXT:      Size: 0x32
+; READ64-NEXT:      RawDataOffset: 0x1A8
+; READ64-NEXT:      RelocationPointer: 0x0
+; READ64-NEXT:      LineNumberPointer: 0x0
+; READ64-NEXT:      NumberOfRelocations: 0
+; READ64-NEXT:      NumberOfLineNumbers: 0
+; READ64-NEXT:      Type: STYP_EXCEPT (0x100)
+; READ64-NEXT:    }
+; READ64-NEXT:  ]
+
+; SYMS64:           Index: [[#IND:]]{{.*}}{{[[:space:]] *}}Name: .sub_test
+; SYMS64-NEXT:      Value (RelocatableAddress): 0x0
+; SYMS64-NEXT:      Section: .text
+; SYMS64-NEXT:      Type: 0x0
+; SYMS64-NEXT:      StorageClass: C_EXT (0x2)
+; SYMS64-NEXT:      NumberOfAuxEntries: 2
+; SYMS64-NEXT:      Function Auxiliary Entry {
+; SYMS64-NEXT:        Index: [[#IND+1]]
+; SYMS64-NEXT:        SizeOfFunction: 0x18
+; SYMS64-NEXT:        PointerToLineNum: 0x0
+; SYMS64-NEXT:        SymbolIndexOfNextBeyond: [[#IND+3]]
+; SYMS64-NEXT:        Auxiliary Type: AUX_FCN (0xFE)
+; SYMS64-NEXT:      }
+; SYMS64-NEXT:      CSECT Auxiliary Entry {
+; SYMS64-NEXT:        Index: [[#IND+2]]
+; SYMS64-NEXT:        ContainingCsectSymbolIndex: 1
+; SYMS64-NEXT:        ParameterHashIndex: 0x0
+; SYMS64-NEXT:        TypeChkSectNum: 0x0
+; SYMS64-NEXT:        SymbolAlignmentLog2: 0
+; SYMS64-NEXT:        SymbolType: XTY_LD (0x2)
+; SYMS64-NEXT:        StorageMappingClass: XMC_PR (0x0)
+; SYMS64-NEXT:        Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NEXT:      }
+; SYMS64-NEXT:    }
+; SYMS64-NEXT:    Symbol {
+; SYMS64-NEXT:      Index: [[#IND+3]]
+; SYMS64-NEXT:      Name: .test__trap_annotation
+; SYMS64-NEXT:      Value (RelocatableAddress): 0x28
+; SYMS64-NEXT:      Section: .text
+; SYMS64-NEXT:      Type: 0x0
+; SYMS64-NEXT:      StorageClass: C_EXT (0x2)
+; SYMS64-NEXT:      NumberOfAuxEntries: 2
+; SYMS64-NEXT:      Function Auxiliary Entry {
+; SYMS64-NEXT:        Index: [[#IND+4]]
+; SYMS64-NEXT:        SizeOfFunction: 0x68
+; SYMS64-NEXT:        PointerToLineNum: 0x0
+; SYMS64-NEXT:        SymbolIndexOfNextBeyond: [[#IND+6]]
+; SYMS64-NEXT:        Auxiliary Type: AUX_FCN (0xFE)
+; SYMS64-NEXT:      }
+; SYMS64-NEXT:      CSECT Auxiliary Entry {
+; SYMS64-NEXT:        Index: [[#IND+5]]
+; SYMS64-NEXT:        ContainingCsectSymbolIndex: 1
+; SYMS64-NEXT:        ParameterHashIndex: 0x0
+; SYMS64-NEXT:        TypeChkSectNum: 0x0
+; SYMS64-NEXT:        SymbolAlignmentLog2: 0
+; SYMS64-NEXT:        SymbolType: XTY_LD (0x2)
+; SYMS64-NEXT:        StorageMappingClass: XMC_PR (0x0)
+; SYMS64-NEXT:        Auxiliary Type: AUX_CSECT (0xFB)
+; SYMS64-NEXT:      }
+; SYMS64-NEXT:    }

llvm/test/CodeGen/PowerPC/builtins-ppc-xlcompat-trap-annotations-td.ll

 ; RUN: llc -verify-machineinstrs -mtriple=powerpc64le-unknown-linux-gnu \
 ; RUN:   --ppc-asm-full-reg-names -mcpu=pwr8 < %s | FileCheck %s
 ; RUN: llc -verify-machineinstrs -mtriple=powerpc64-unknown-linux-gnu \
 ; RUN:   --ppc-asm-full-reg-names -mcpu=pwr7 < %s | FileCheck %s
 ; RUN: llc -verify-machineinstrs -mtriple=powerpc64-unknown-aix \
 ; RUN:   --ppc-asm-full-reg-names -mcpu=pwr8 < %s | FileCheck %s -check-prefix=AIX
-; RUN: not --crash llc -verify-machineinstrs -mtriple=powerpc64-unknown-aix \
-; RUN:   --ppc-asm-full-reg-names -mcpu=pwr8 --filetype=obj -o /dev/null %s 2>&1 | FileCheck %s -check-prefix=OBJ
+; RUN: llc -mtriple=powerpc64-unknown-aix -filetype=obj -o %t_64.o < %s
+; RUN: llvm-readobj --exception-section %t_64.o | FileCheck %s --check-prefix=OBJ64
 
-; OBJ: LLVM ERROR: emitXCOFFExceptDirective not yet supported for integrated assembler path.
+; Check that we do not crash in object mode
+; OBJ64:       Exception section {
+; OBJ64-NEXT:    Symbol: .test__tdw_annotation (6)
 
 !1 = !{!"ppc-trap-reason", !"1", !"2"}
 declare void @llvm.ppc.trapd(i64 %a)
 declare void @llvm.ppc.tdw(i64 %a, i64 %b, i32 immarg)
 
 define dso_local void @test__trapd_annotation(i64 %a) {
 ; CHECK-LABEL: test__trapd_annotation:
 ; CHECK:       # %bb.0:

llvm/test/CodeGen/PowerPC/builtins-ppc-xlcompat-trap-annotations-tw.ll

 ; RUN: llc -verify-machineinstrs -mtriple=powerpc64le-unknown-linux-gnu \
 ; RUN:   --ppc-asm-full-reg-names -mcpu=pwr8 < %s | FileCheck %s
 ; RUN: llc -verify-machineinstrs -mtriple=powerpc64-unknown-linux-gnu \
 ; RUN:   --ppc-asm-full-reg-names -mcpu=pwr7 < %s | FileCheck %s
 ; RUN: llc -verify-machineinstrs -mtriple=powerpc-unknown-linux-gnu \
 ; RUN:   --ppc-asm-full-reg-names -mcpu=pwr7 < %s | FileCheck %s
 ; RUN: llc -verify-machineinstrs -mtriple=powerpc-unknown-aix \
 ; RUN:   --ppc-asm-full-reg-names -mcpu=pwr8 < %s | FileCheck %s -check-prefix=AIX
 ; RUN: llc -verify-machineinstrs -mtriple=powerpc64-unknown-aix \
 ; RUN:   --ppc-asm-full-reg-names -mcpu=pwr8 < %s | FileCheck %s -check-prefix=AIX
-; RUN: not --crash llc -verify-machineinstrs -mtriple=powerpc64-unknown-aix \
-; RUN:   --ppc-asm-full-reg-names -mcpu=pwr8 --filetype=obj -o /dev/null %s 2>&1 | FileCheck %s -check-prefix=OBJ
+; RUN: llc -mtriple=powerpc-ibm-aix-xcoff -filetype=obj -o %t_32.o < %s
+; RUN: llvm-readobj --exception-section %t_32.o | FileCheck %s --check-prefix=OBJ
 
-; OBJ: LLVM ERROR: emitXCOFFExceptDirective not yet supported for integrated assembler path.
+; Check that we do not crash in object mode
+; OBJ:       Exception section {
+; OBJ-NEXT:    Symbol: .test__trap_annotation (3)
 
 !1 = !{!"ppc-trap-reason", !"1", !"2"}
 declare void @llvm.ppc.trap(i32 %a)
 declare void @llvm.ppc.tw(i32 %a, i32 %b, i32 immarg)
 define dso_local void @test__trap_annotation(i32 %a) {
 ; CHECK-LABEL: test__trap_annotation:
 ; CHECK:       # %bb.0:
 ; CHECK-NEXT:    twi 24, r3, 0

 ; AIX-LABEL: test__tw_annotation:
 ; AIX:       # %bb.0:
 ; AIX-NEXT:  L..tmp1:
 ; AIX-NEXT:    .except .test__tw_annotation, 1, 2
 ; AIX-NEXT:    twi 0, r3, 4
 ; AIX-NEXT:    blr
   call void @llvm.ppc.tw(i32 4, i32 %a, i32 0), !annotation !1
   ret void
 }