[XCOFF][AIX] Generate LSDA data and compact unwind section on AIX

[jasonliu]

Summary

AIX uses the existing EH infrastructure in clang and llvm.
The major differences would be

1. AIX do not have CFI instructions.
2. AIX uses a new personality routine, named __xlcxx_personality_v1. It doesn't use the GCC personality rountine, because the interoperability is not there yet on AIX.
3. AIX do not use eh_frame sections. Instead, it would use a eh_info section (compat unwind section) to store the information about personality routine and LSDA data address.

[daltenty]

llvm/lib/CodeGen/AsmPrinter/AIXException.cpp

49

nit: Why not just call getPointerSize() instead? (getPointerSizeInBits() does getPointerSize()*8 under the hood anyway)

[daltenty]

llvm/lib/MC/MCObjectFileInfo.cpp

891

I think this may have been discussed elsewhere, but why do we want to emit this as a RW section?

[jasonliu]

llvm/lib/MC/MCObjectFileInfo.cpp

891

Yes, this has been discussed before. And it's a good question.
If we emit this as an RO section, then we could not put

.vbyte	4, GCC_except_table1
.vbyte	4, __xlcxx_personality_v1[DS]

into this csect directly.
If we do that, we would hit linker error during link time. It seems that for read only csects (RO, PR mapping classes), we could not have relocation types like R_POS or R_NEG because the result coming out of it is not link-time constant. And the relocation types in read only csects needs to be link time constant.

Extra work (both compiler and runtime) will be needed if we want to make this RO.

[daltenty]

llvm/lib/MC/MCObjectFileInfo.cpp

891

Thanks for clarifying. I guess we'd presumably need to add the TOC indirections to get to the LSDA and personality routine's function descriptor, similar to elsewhere.

Since this structure is version'd, seems like we have the flexibility to defer that work, so I guess that's OK.

[hubert.reinterpretcast]

2. AIX uses a new personality routine, named __xlcxx_personality_v1. It doesn't use the GCC personality rountine, because the intractability is not there yet on AIX.

@jasonliu, is "intractability" a typo/autocorrect problem?

[jasonliu]

llvm/lib/MC/MCObjectFileInfo.cpp

891

add the TOC indirections to get to the LSDA and personality routine's function descriptor

Yep, that's one potential way to solve it. The downside of it would be

1. We might have more TC entries than we desired.
2. A small performance penalty to pay for the extra indirection. (But since we already on the EH path, and it's slow anyway, might not be that big of a deal).

But as you already mentioned, we don't have to solve this issue right now.

[jasonliu]

In D91455#2424584, @hubert.reinterpretcast wrote:

2. AIX uses a new personality routine, named __xlcxx_personality_v1. It doesn't use the GCC personality rountine, because the intractability is not there yet on AIX.

@jasonliu, is "intractability" a typo/autocorrect problem?

Yep. Fixed!

[jasonliu]

Address comment.

[daltenty]

llvm/lib/CodeGen/AsmPrinter/AIXException.cpp

69

This logic seems very similar to the base class.

The pattern there and in other instance of EHStreamer seems to be to make these queries in beginFunction, store the results in a member and just early exit if we have nothing to emit in endFunction, etc. Is that something we should be doing here? (e.g. presumably the traceback emission will want to know if we plan to emit anything so it can emit the appropriate info)

[jasonliu]

llvm/lib/CodeGen/AsmPrinter/AIXException.cpp

69

I agree that this is a query that we want to share with the traceback table emission.
Presumably, we need to do the traceback table emission somewhere in PPCAIXAsmPrinter.
So that means we would need to have a query that could accessible from PPCAIXAsmPrinter and here.
And there are other EHStreamer that have similar queries (but not all of them), so this makes it trickier to get it right if we want to do it for all platforms.
I was hoping to address this issue when we actually do the traceback table emission for EH info so that we could keep the scope of the patch reasonable.

[daltenty]

LGTM

llvm/lib/CodeGen/AsmPrinter/AIXException.cpp

69

Thanks, I think that helps explain the structure here. This should be amenable to later refactoring, so that sounds good for now.

[hubert.reinterpretcast]

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

109–110

Is there a plan to update the annotation output here?

[hubert.reinterpretcast]

llvm/lib/CodeGen/AsmPrinter/AIXException.cpp

36

Typo: missing space.

[jasonliu]

Address comments.

[jasonliu]

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

109–110

updated to address comment.

[hubert.reinterpretcast]

LGTM; thanks.

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

109–110

Thanks.

clang/lib/CodeGen/CGCleanup.h

struct EHPersonality {
   static const EHPersonality NeXT_ObjC;
   static const EHPersonality GNU_CPlusPlus;
   static const EHPersonality GNU_CPlusPlus_SJLJ;
   static const EHPersonality GNU_CPlusPlus_SEH;
   static const EHPersonality MSVC_except_handler;
   static const EHPersonality MSVC_C_specific_handler;
   static const EHPersonality MSVC_CxxFrameHandler3;
   static const EHPersonality GNU_Wasm_CPlusPlus;
+  static const EHPersonality XL_CPlusPlus;
 
   /// Does this personality use landingpads or the family of pad instructions
   /// designed to form funclets?
   bool usesFuncletPads() const {
     return isMSVCPersonality() || isWasmPersonality();
   }
 
   bool isMSVCPersonality() const {

clang/lib/CodeGen/CGException.cpp

 const EHPersonality
 EHPersonality::MSVC_except_handler = { "_except_handler3", nullptr };
 const EHPersonality
 EHPersonality::MSVC_C_specific_handler = { "__C_specific_handler", nullptr };
 const EHPersonality
 EHPersonality::MSVC_CxxFrameHandler3 = { "__CxxFrameHandler3", nullptr };
 const EHPersonality
 EHPersonality::GNU_Wasm_CPlusPlus = { "__gxx_wasm_personality_v0", nullptr };
+const EHPersonality EHPersonality::XL_CPlusPlus = {"__xlcxx_personality_v1",
+                                                   nullptr};
 
 static const EHPersonality &getCPersonality(const TargetInfo &Target,
                                             const LangOptions &L) {
   const llvm::Triple &T = Target.getTriple();
   if (T.isWindowsMSVCEnvironment())
     return EHPersonality::MSVC_CxxFrameHandler3;
   if (L.SjLjExceptions)
     return EHPersonality::GNU_C_SJLJ;
static const EHPersonality &getObjCPersonality(const TargetInfo &Target,
   llvm_unreachable("bad runtime kind");
 }
 
 static const EHPersonality &getCXXPersonality(const TargetInfo &Target,
                                               const LangOptions &L) {
   const llvm::Triple &T = Target.getTriple();
   if (T.isWindowsMSVCEnvironment())
     return EHPersonality::MSVC_CxxFrameHandler3;
+  if (T.isOSAIX())
+    return EHPersonality::XL_CPlusPlus;
   if (L.SjLjExceptions)
     return EHPersonality::GNU_CPlusPlus_SJLJ;
   if (L.DWARFExceptions)
     return EHPersonality::GNU_CPlusPlus;
   if (L.SEHExceptions)
     return EHPersonality::GNU_CPlusPlus_SEH;
   if (L.WasmExceptions)
     return EHPersonality::GNU_Wasm_CPlusPlus;

clang/test/CodeGenCXX/personality.cpp

 // RUN: %clang_cc1 -triple i686-unknown-linux-gnu -fexceptions -fcxx-exceptions -S -emit-llvm %s -o - | FileCheck %s -check-prefix CHECK-GNU
 // RUN: %clang_cc1 -triple i686-unknown-linux-gnu -fexceptions -fdwarf-exceptions -fcxx-exceptions -S -emit-llvm %s -o - | FileCheck %s -check-prefix CHECK-GNU-DWARF
 // RUN: %clang_cc1 -triple i686-unknown-linux-gnu -fexceptions -fseh-exceptions -fcxx-exceptions -S -emit-llvm %s -o - | FileCheck %s -check-prefix CHECK-GNU-SEH
 // RUN: %clang_cc1 -triple i686-unknown-linux-gnu -fexceptions -fsjlj-exceptions -fcxx-exceptions -S -emit-llvm %s -o - | FileCheck %s -check-prefix CHECK-GNU-SJLJ
 
 // RUN: %clang_cc1 -triple i686-unknown-windows-msvc -fexceptions -fcxx-exceptions -S -emit-llvm %s -o - | FileCheck %s -check-prefix CHECK-WIN
 // RUN: %clang_cc1 -triple i686-unknown-windows-msvc -D __SEH_EXCEPTIONS__ -fms-extensions -fexceptions -fcxx-exceptions -S -emit-llvm %s -o - | FileCheck %s -check-prefix CHECK-WIN-SEH-X86
 // RUN: %clang_cc1 -triple x86_64-unknown-windows-msvc -D __SEH_EXCEPTIONS__ -fms-extensions -fexceptions -fcxx-exceptions -S -emit-llvm %s -o - | FileCheck %s -check-prefix CHECK-WIN-SEH-X64
 
 // RUN: %clang_cc1 -triple i686-unknown-windows-gnu -fexceptions -fcxx-exceptions -S -emit-llvm %s -o - | FileCheck %s -check-prefix CHECK-GNU
 // RUN: %clang_cc1 -triple i686-unknown-windows-gnu -fexceptions -fdwarf-exceptions -fcxx-exceptions -S -emit-llvm %s -o - | FileCheck %s -check-prefix CHECK-GNU-DWARF
 // RUN: %clang_cc1 -triple i686-unknown-windows-gnu -fexceptions -fseh-exceptions -fcxx-exceptions -S -emit-llvm %s -o - | FileCheck %s -check-prefix CHECK-GNU-SEH
 // RUN: %clang_cc1 -triple i686-unknown-windows-gnu -fexceptions -fsjlj-exceptions -fcxx-exceptions -S -emit-llvm %s -o - | FileCheck %s -check-prefix CHECK-GNU-SJLJ
 
+// RUN: %clang_cc1 -triple powerpc-unknown-aix-xcoff -fexceptions -fcxx-exceptions -S -emit-llvm %s -o - | FileCheck %s -check-prefix CHECK-AIX
+// RUN: %clang_cc1 -triple powerpc64-unknown-aix-xcoff -fexceptions -fcxx-exceptions -S -emit-llvm %s -o - | FileCheck %s -check-prefix CHECK-AIX
+
 extern void g();
 
 // CHECK-GNU: personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
 // CHECK-GNU-DWARF: personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
 // CHECK-GNU-SEH: personality i8* bitcast (i32 (...)* @__gxx_personality_seh0 to i8*)
 // CHECK-GNU-SJLJ: personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
 
 // CHECK-WIN: personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
 
+// CHECK-AIX: personality i8* bitcast (i32 (...)* @__xlcxx_personality_v1 to i8*)
+
 void f() {
   try {
     g();
   } catch (...) {
   }
 }
 
 #if defined(__SEH_EXCEPTIONS__)

llvm/include/llvm/Analysis/EHPersonalities.h

enum class EHPersonality {
   GNU_CXX,
   GNU_CXX_SjLj,
   GNU_ObjC,
   MSVC_X86SEH,
   MSVC_TableSEH,
   MSVC_CXX,
   CoreCLR,
   Rust,
-  Wasm_CXX
+  Wasm_CXX,
+  XL_CXX
 };
 
 /// See if the given exception handling personality function is one
 /// that we understand.  If so, return a description of it; otherwise return
 /// Unknown.
 EHPersonality classifyEHPersonality(const Value *Pers);
 
 StringRef getEHPersonalityName(EHPersonality Pers);

llvm/include/llvm/CodeGen/AsmPrinter.h

public:
   /// assembly output is enabled, we output comments describing the encoding.
   /// Desc is a string saying what the encoding is specifying (e.g. "LSDA").
   void emitEncodingByte(unsigned Val, const char *Desc = nullptr) const;
 
   /// Return the size of the encoding in bytes.
   unsigned GetSizeOfEncodedValue(unsigned Encoding) const;
 
   /// Emit reference to a ttype global with a specified encoding.
-  void emitTTypeReference(const GlobalValue *GV, unsigned Encoding) const;
+  virtual void emitTTypeReference(const GlobalValue *GV, unsigned Encoding);
 
   /// Emit a reference to a symbol for use in dwarf. Different object formats
   /// represent this in different ways. Some use a relocation others encode
   /// the label offset in its section.
   void emitDwarfSymbolReference(const MCSymbol *Label,
                                 bool ForceOffset = false) const;
 
   /// Emit the 4- or 8-byte offset of a string from the start of its section.

llvm/include/llvm/MC/MCTargetOptions.h

 
 enum class ExceptionHandling {
   None,     ///< No exception support
   DwarfCFI, ///< DWARF-like instruction based exceptions
   SjLj,     ///< setjmp/longjmp based exceptions
   ARM,      ///< ARM EHABI
   WinEH,    ///< Windows Exception Handling
   Wasm,     ///< WebAssembly Exception Handling
+  AIX,      ///< AIX Exception Handling
 };
 
 enum class DebugCompressionType {
   None, ///< No compression
   GNU,  ///< zlib-gnu style compression
   Z,    ///< zlib style complession
 };
 

llvm/lib/Analysis/EHPersonalities.cpp

return StringSwitch<EHPersonality>(F->getName())
       .Case("__objc_personality_v0", EHPersonality::GNU_ObjC)
       .Case("_except_handler3", EHPersonality::MSVC_X86SEH)
       .Case("_except_handler4", EHPersonality::MSVC_X86SEH)
       .Case("__C_specific_handler", EHPersonality::MSVC_TableSEH)
       .Case("__CxxFrameHandler3", EHPersonality::MSVC_CXX)
       .Case("ProcessCLRException", EHPersonality::CoreCLR)
       .Case("rust_eh_personality", EHPersonality::Rust)
       .Case("__gxx_wasm_personality_v0", EHPersonality::Wasm_CXX)
+      .Case("__xlcxx_personality_v1", EHPersonality::XL_CXX)
       .Default(EHPersonality::Unknown);
 }
 
 StringRef llvm::getEHPersonalityName(EHPersonality Pers) {
   switch (Pers) {
   case EHPersonality::GNU_Ada:       return "__gnat_eh_personality";
   case EHPersonality::GNU_CXX:       return "__gxx_personality_v0";
   case EHPersonality::GNU_CXX_SjLj:  return "__gxx_personality_sj0";
   case EHPersonality::GNU_C:         return "__gcc_personality_v0";
   case EHPersonality::GNU_C_SjLj:    return "__gcc_personality_sj0";
   case EHPersonality::GNU_ObjC:      return "__objc_personality_v0";
   case EHPersonality::MSVC_X86SEH:   return "_except_handler3";
   case EHPersonality::MSVC_TableSEH:
     return "__C_specific_handler";
   case EHPersonality::MSVC_CXX:      return "__CxxFrameHandler3";
   case EHPersonality::CoreCLR:       return "ProcessCLRException";
   case EHPersonality::Rust:          return "rust_eh_personality";
   case EHPersonality::Wasm_CXX:      return "__gxx_wasm_personality_v0";
+  case EHPersonality::XL_CXX:
+    return "__xlcxx_personality_v1";
   case EHPersonality::Unknown:       llvm_unreachable("Unknown EHPersonality!");
   }
 
   llvm_unreachable("Invalid EHPersonality!");
 }
 
 EHPersonality llvm::getDefaultEHPersonality(const Triple &T) {
   return EHPersonality::GNU_C;

llvm/lib/CodeGen/AsmPrinter/AIXException.cpp

+//===-- CodeGen/AsmPrinter/AIXException.cpp - AIX Exception Impl ----------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains support for writing AIX exception info into asm files.
+//
+//===----------------------------------------------------------------------===//
+
+#include "DwarfException.h"
+#include "llvm/CodeGen/AsmPrinter.h"
+#include "llvm/CodeGen/MachineModuleInfo.h"
+#include "llvm/MC/MCSectionXCOFF.h"
+#include "llvm/MC/MCStreamer.h"
+#include "llvm/Target/TargetLoweringObjectFile.h"
+#include "llvm/Target/TargetMachine.h"
+
+namespace llvm {
+
+AIXException::AIXException(AsmPrinter *A) : DwarfCFIExceptionBase(A) {}
+
+void AIXException::emitExceptionInfoTable(const MCSymbol *LSDA,
+                                          const MCSymbol *PerSym) {
+  // Generate EH Info Table.
+  // The EH Info Table, aka, 'compat unwind section' on AIX, have the following
+  // format: struct eh_info_t {
+  //   unsigned version;           /* EH info verion 0 */
+  // #if defined(__64BIT__)
+  //   char _pad[4];               /* padding */
+  // #endif
+  //   unsigned long lsda;         /* Pointer to LSDA */
+  //   unsigned long personality;  /* Pointer to the personality routine */
+  //   }
+
+  Asm->OutStreamer->SwitchSection(
+      Asm->getObjFileLowering().getCompactUnwindSection());
+  MCSymbol *EHInfoLabel = MMI->getContext().getOrCreateSymbol(
+      "__ehinfo." + Twine(Asm->getFunctionNumber()));
+  Asm->OutStreamer->emitLabel(EHInfoLabel);
+
+  // Version number.
+  Asm->emitInt32(0);
+
+  const DataLayout &DL = MMI->getModule()->getDataLayout();
+  const unsigned PointerSize = DL.getPointerSize();
+
+  // Add necessary paddings in 64 bit mode.
+  Asm->OutStreamer->emitValueToAlignment(PointerSize);
+
+  // LSDA location.
+  Asm->OutStreamer->emitValue(MCSymbolRefExpr::create(LSDA, Asm->OutContext),
+                              PointerSize);
+
+  // Personality routine.
+  Asm->OutStreamer->emitValue(MCSymbolRefExpr::create(PerSym, Asm->OutContext),
+                              PointerSize);
+}
+
+void AIXException::endFunction(const MachineFunction *MF) {
+  const Function &F = MF->getFunction();
+  bool HasLandingPads = !MF->getLandingPads().empty();
+  const Function *Per = nullptr;
+  if (F.hasPersonalityFn())
+    Per = dyn_cast<Function>(F.getPersonalityFn()->stripPointerCasts());
+  bool EmitEHBlock =
+      HasLandingPads || (F.hasPersonalityFn() &&
+                         !isNoOpWithoutInvoke(classifyEHPersonality(Per)) &&
+                         F.needsUnwindTableEntry());
+
+  if (!EmitEHBlock)
+    return;
+
+  const MCSymbol *LSDALabel = emitExceptionTable();
+  const MCSymbol *PerSym = Asm->TM.getSymbol(Per);
+
+  emitExceptionInfoTable(LSDALabel, PerSym);
+}
+
+} // End of namespace llvm

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

case ExceptionHandling::WinEH:
     case WinEH::EncodingType::Itanium:
       ES = new WinException(this);
       break;
     }
     break;
   case ExceptionHandling::Wasm:
     ES = new WasmException(this);
     break;
+  case ExceptionHandling::AIX:
+    ES = new AIXException(this);
+    break;
   }
   if (ES)
     Handlers.emplace_back(std::unique_ptr<EHStreamer>(ES), EHTimerName,
                           EHTimerDescription, DWARFGroupName,
                           DWARFGroupDescription);
 
   // Emit tables for any value of cfguard flag (i.e. cfguard=1 or cfguard=2).
   if (mdconst::extract_or_null<ConstantInt>(M.getModuleFlag("cfguard")))

llvm/lib/CodeGen/AsmPrinter/AsmPrinterDwarf.cpp

case dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4
       :
     return "indirect pcrel sdata4";
   case dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_udata8
       :
     return "indirect pcrel udata8";
   case dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata8
       :
     return "indirect pcrel sdata8";
+  case dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_datarel |
+      dwarf::DW_EH_PE_sdata4:
+    return "indirect datarel sdata4";
+  case dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_datarel |
+      dwarf::DW_EH_PE_sdata8:
+    return "indirect datarel sdata8";
   }
 
   return "<unknown encoding>";
 }
 
 /// EmitEncodingByte - Emit a .byte 42 directive that corresponds to an
 /// encoding.  If verbose assembly output is enabled, we output comments
 /// describing the encoding.  Desc is an optional string saying what the
case dwarf::DW_EH_PE_udata2:
     return 2;
   case dwarf::DW_EH_PE_udata4:
     return 4;
   case dwarf::DW_EH_PE_udata8:
     return 8;
   }
 }
 
-void AsmPrinter::emitTTypeReference(const GlobalValue *GV,
-                                    unsigned Encoding) const {
+void AsmPrinter::emitTTypeReference(const GlobalValue *GV, unsigned Encoding) {
   if (GV) {
     const TargetLoweringObjectFile &TLOF = getObjFileLowering();
 
     const MCExpr *Exp =
         TLOF.getTTypeGlobalReference(GV, Encoding, TM, MMI, *OutStreamer);
     OutStreamer->emitValue(Exp, GetSizeOfEncodedValue(Encoding));
   } else
     OutStreamer->emitIntValue(0, GetSizeOfEncodedValue(Encoding));

llvm/lib/CodeGen/AsmPrinter/CMakeLists.txt

 add_llvm_component_library(LLVMAsmPrinter
   AccelTable.cpp
   AddressPool.cpp
+  AIXException.cpp
   ARMException.cpp
   AsmPrinter.cpp
   AsmPrinterDwarf.cpp
   AsmPrinterInlineAsm.cpp
   DbgEntityHistoryCalculator.cpp
   DebugHandlerBase.cpp
   DebugLocStream.cpp
   DIE.cpp

llvm/lib/CodeGen/AsmPrinter/DwarfException.h

public:
 
   /// Gather pre-function exception information.  Assumes being emitted
   /// immediately after the function entry point.
   void beginFunction(const MachineFunction *MF) override;
 
   /// Gather and emit post-function exception information.
   void endFunction(const MachineFunction *) override;
 };
+
+class LLVM_LIBRARY_VISIBILITY AIXException : public DwarfCFIExceptionBase {
+  /// This is AIX's compat unwind section, which unwinder would use
+  /// to find the location of LSDA area and personality rountine.
+  void emitExceptionInfoTable(const MCSymbol *LSDA, const MCSymbol *PerSym);
+
+public:
+  AIXException(AsmPrinter *A);
+
+  void endModule() override {}
+  void beginFunction(const MachineFunction *MF) override {}
+
+  void endFunction(const MachineFunction *MF) override;
+};
 } // End of namespace llvm
 
 #endif

llvm/lib/CodeGen/AsmPrinter/EHStreamer.cpp

for (const auto &MI : MBB) {
         // Nope, it was just some random label.
         continue;
 
       const PadRange &P = L->second;
       const LandingPadInfo *LandingPad = LandingPads[P.PadIndex];
       assert(BeginLabel == LandingPad->BeginLabels[P.RangeIndex] &&
              "Inconsistent landing pad map!");
 
-      // For Dwarf exception handling (SjLj handling doesn't use this). If some
-      // instruction between the previous try-range and this one may throw,
-      // create a call-site entry with no landing pad for the region between the
-      // try-ranges.
-      if (SawPotentiallyThrowing && Asm->MAI->usesCFIForEH()) {
+      // For Dwarf and AIX exception handling (SjLj handling doesn't use this).
+      // If some instruction between the previous try-range and this one may
+      // throw, create a call-site entry with no landing pad for the region
+      // between the try-ranges.
+      if (SawPotentiallyThrowing &&
+          (Asm->MAI->usesCFIForEH() ||
+           Asm->MAI->getExceptionHandlingType() == ExceptionHandling::AIX)) {
         CallSites.push_back({LastLabel, BeginLabel, nullptr, 0});
         PreviousIsInvoke = false;
       }
 
       LastLabel = LandingPad->EndLabels[P.RangeIndex];
       assert(BeginLabel && LastLabel && "Invalid landing pad!");
 
       if (!LandingPad->LandingPadLabel) {

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

MCSection *TargetLoweringObjectFileXCOFF::getSectionForConstant(
     Align &Alignment) const {
   //TODO: Enable emiting constant pool to unique sections when we support it.
   return ReadOnlySection;
 }
 
 void TargetLoweringObjectFileXCOFF::Initialize(MCContext &Ctx,
                                                const TargetMachine &TgtM) {
   TargetLoweringObjectFile::Initialize(Ctx, TgtM);
-  TTypeEncoding = 0;
+  TTypeEncoding =
+      dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_datarel |
+      (TgtM.getTargetTriple().isArch32Bit() ? dwarf::DW_EH_PE_sdata4
+                                            : dwarf::DW_EH_PE_sdata8);
   PersonalityEncoding = 0;
   LSDAEncoding = 0;
+  CallSiteEncoding = dwarf::DW_EH_PE_udata4;
 }
 
 MCSection *TargetLoweringObjectFileXCOFF::getStaticCtorSection(
   unsigned Priority, const MCSymbol *KeySym) const {
   report_fatal_error("no static constructor section on AIX");
 }
 
 MCSection *TargetLoweringObjectFileXCOFF::getStaticDtorSection(

llvm/lib/CodeGen/TargetPassConfig.cpp

case ExceptionHandling::SjLj:
     // catch info can get misplaced when a selector ends up more than one block
     // removed from the parent invoke(s). This could happen when a landing
     // pad is shared by multiple invokes and is also a target of a normal
     // edge from elsewhere.
     addPass(createSjLjEHPreparePass(TM));
     LLVM_FALLTHROUGH;
   case ExceptionHandling::DwarfCFI:
   case ExceptionHandling::ARM:
+  case ExceptionHandling::AIX:
     addPass(createDwarfEHPass(getOptLevel()));
     break;
   case ExceptionHandling::WinEH:
     // We support using both GCC-style and MSVC-style exceptions on Windows, so
     // add both preparation passes. Each pass will only actually run if it
     // recognizes the personality function.
     addPass(createWinEHPass());
     addPass(createDwarfEHPass(getOptLevel()));

llvm/lib/MC/MCAsmInfoXCOFF.cpp

MCAsmInfoXCOFF::MCAsmInfoXCOFF() {
   Data16bitsDirective = "\t.vbyte\t2, ";
   Data32bitsDirective = "\t.vbyte\t4, ";
 
   COMMDirectiveAlignmentIsInBytes = false;
   LCOMMDirectiveAlignmentType = LCOMM::Log2Alignment;
   HasDotTypeDotSizeDirective = false;
   UseIntegratedAssembler = false;
   NeedsFunctionDescriptors = true;
+
+  ExceptionsType = ExceptionHandling::AIX;
 }
 
 bool MCAsmInfoXCOFF::isAcceptableChar(char C) const {
   // QualName is allowed for a MCSymbolXCOFF, and
   // QualName contains '[' and ']'.
   if (C == '[' || C == ']')
     return true;
 
   // For AIX assembler, symbols may consist of numeric digits,
   // underscores, periods, uppercase or lowercase letters, or
   // any combination of these.
   return isAlnum(C) || C == '_' || C == '.';
 }

llvm/lib/MC/MCObjectFileInfo.cpp

void MCObjectFileInfo::initXCOFFMCObjectFileInfo(const Triple &T) {
 
   TOCBaseSection =
       Ctx->getXCOFFSection("TOC", XCOFF::StorageMappingClass::XMC_TC0,
                            XCOFF::XTY_SD, SectionKind::getData());
 
   // The TOC-base always has 0 size, but 4 byte alignment.
   TOCBaseSection->setAlignment(Align(4));
 
+  LSDASection = Ctx->getXCOFFSection(".gcc_except_table",
+                                     XCOFF::StorageMappingClass::XMC_RO,
+                                     XCOFF::XTY_SD, SectionKind::getReadOnly());
+
+  CompactUnwindSection =
+      Ctx->getXCOFFSection(".eh_info_table", XCOFF::StorageMappingClass::XMC_RW,
+                           XCOFF::XTY_SD, SectionKind::getData());
+
   // DWARF sections for XCOFF are not csects. They are special STYP_DWARF
   // sections, and the individual DWARF sections are distinguished by their
   // section subtype.
   // TODO: Populate the DWARF sections appropriately.
   DwarfAbbrevSection = nullptr;   // SSUBTYP_DWABREV
   DwarfInfoSection = nullptr;     // SSUBTYP_DWINFO
   DwarfLineSection = nullptr;     // SSUBTYP_DWLINE
   DwarfFrameSection = nullptr;    // SSUBTYP_DWFRAME

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

public:
 
   void emitEndOfAsmFile(Module &) override;
 
   void emitLinkage(const GlobalValue *GV, MCSymbol *GVSym) const override;
 
   void emitInstruction(const MachineInstr *MI) override;
 
   bool doFinalization(Module &M) override;
+
+  void emitTTypeReference(const GlobalValue *GV, unsigned Encoding) override;
 };
 
 } // end anonymous namespace
 
 void PPCAsmPrinter::PrintSymbolOperand(const MachineOperand &MO,
                                        raw_ostream &O) {
   // Computing the address of a global symbol, not calling it.
   const GlobalValue *GV = MO.getGlobal();
llvm::GlobalAlias::create(
         (IsCtor ? llvm::Twine("__sinit") : llvm::Twine("__sterm")) +
             llvm::Twine(convertToSinitPriority(S.Priority)) +
             llvm::Twine("_", FormatIndicatorAndUniqueModId) +
             llvm::Twine("_", llvm::utostr(Index++)),
         cast<Function>(S.Func));
   }
 }
 
+void PPCAIXAsmPrinter::emitTTypeReference(const GlobalValue *GV,
+                                          unsigned Encoding) {
+  if (GV) {
+    MCSymbol *TypeInfoSym = TM.getSymbol(GV);
+    MCSymbol *TOCEntry = lookUpOrCreateTOCEntry(TypeInfoSym);
+    const MCSymbol *TOCBaseSym =
+        cast<MCSectionXCOFF>(getObjFileLowering().getTOCBaseSection())
+            ->getQualNameSymbol();
+    auto &Ctx = OutStreamer->getContext();
+    const MCExpr *Exp =
+        MCBinaryExpr::createSub(MCSymbolRefExpr::create(TOCEntry, Ctx),
+                                MCSymbolRefExpr::create(TOCBaseSym, Ctx), Ctx);
+    OutStreamer->emitValue(Exp, GetSizeOfEncodedValue(Encoding));
+  } else
+    OutStreamer->emitIntValue(0, GetSizeOfEncodedValue(Encoding));
+}
+
 // Return a pass that prints the PPC assembly code for a MachineFunction to the
 // given output stream.
 static AsmPrinter *
 createPPCAsmPrinterPass(TargetMachine &tm,
                         std::unique_ptr<MCStreamer> &&Streamer) {
   if (tm.getTargetTriple().isOSAIX())
     return new PPCAIXAsmPrinter(tm, std::move(Streamer));
 

llvm/lib/Transforms/InstCombine/InstructionCombining.cpp

static bool isCatchAll(EHPersonality Personality, Constant *TypeInfo) {
   case EHPersonality::GNU_CXX:
   case EHPersonality::GNU_CXX_SjLj:
   case EHPersonality::GNU_ObjC:
   case EHPersonality::MSVC_X86SEH:
   case EHPersonality::MSVC_TableSEH:
   case EHPersonality::MSVC_CXX:
   case EHPersonality::CoreCLR:
   case EHPersonality::Wasm_CXX:
+  case EHPersonality::XL_CXX:
     return TypeInfo->isNullValue();
   }
   llvm_unreachable("invalid enum");
 }
 
 static bool shorter_filter(const Value *LHS, const Value *RHS) {
   return
     cast<ArrayType>(LHS->getType())->getNumElements()

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

+; RUN: llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff -mcpu=pwr4 \
+; RUN:     -mattr=-altivec < %s | \
+; RUN:   FileCheck --check-prefixes=ASM,ASM32 %s
+
+; RUN: llc -verify-machineinstrs -mtriple powerpc64-ibm-aix-xcoff -mcpu=pwr4 \
+; RUN:     -mattr=-altivec < %s | \
+; RUN:   FileCheck --check-prefixes=ASM,ASM64 %s
+
+@_ZTIi = external constant i8*
+
+define void @_Z9throwFuncv() {
+entry:
+  %exception = call i8* @__cxa_allocate_exception(i32 4) #2
+  %0 = bitcast i8* %exception to i32*
+  store i32 1, i32* %0, align 16
+  call void @__cxa_throw(i8* %exception, i8* bitcast (i8** @_ZTIi to i8*), i8* null) #3
+  unreachable
+}
+
+; ASM:    ._Z9throwFuncv:
+; ASM:      bl .__cxa_allocate_exception[PR]
+; ASM:      nop
+; ASM32:    lwz 4, L..C0(2)
+; ASM64:    ld 4, L..C0(2)
+; ASM:      bl .__cxa_throw[PR]
+; ASM:      nop
+
+define i32 @_Z9catchFuncv() personality i8* bitcast (i32 (...)* @__xlcxx_personality_v1 to i8*) {
+entry:
+  %retval = alloca i32, align 4
+  %exn.slot = alloca i8*, align 4
+  %ehselector.slot = alloca i32, align 4
+  %0 = alloca i32, align 4
+  invoke void @_Z9throwFuncv()
+          to label %invoke.cont unwind label %lpad
+
+invoke.cont:                                      ; preds = %entry
+  br label %try.cont
+
+lpad:                                             ; preds = %entry
+  %1 = landingpad { i8*, i32 }
+          catch i8* bitcast (i8** @_ZTIi to i8*)
+  %2 = extractvalue { i8*, i32 } %1, 0
+  store i8* %2, i8** %exn.slot, align 4
+  %3 = extractvalue { i8*, i32 } %1, 1
+  store i32 %3, i32* %ehselector.slot, align 4
+  br label %catch.dispatch
+
+catch.dispatch:                                   ; preds = %lpad
+  %sel = load i32, i32* %ehselector.slot, align 4
+  %4 = call i32 @llvm.eh.typeid.for(i8* bitcast (i8** @_ZTIi to i8*)) #2
+  %matches = icmp eq i32 %sel, %4
+  br i1 %matches, label %catch, label %eh.resume
+
+catch:                                            ; preds = %catch.dispatch
+  %exn = load i8*, i8** %exn.slot, align 4
+  %5 = call i8* @__cxa_begin_catch(i8* %exn) #2
+  %6 = bitcast i8* %5 to i32*
+  %7 = load i32, i32* %6, align 4
+  store i32 %7, i32* %0, align 4
+  store i32 2, i32* %retval, align 4
+  call void @__cxa_end_catch() #2
+  br label %return
+
+try.cont:                                         ; preds = %invoke.cont
+  store i32 1, i32* %retval, align 4
+  br label %return
+
+return:                                           ; preds = %try.cont, %catch
+  %8 = load i32, i32* %retval, align 4
+  ret i32 %8
+
+eh.resume:                                        ; preds = %catch.dispatch
+  %exn1 = load i8*, i8** %exn.slot, align 4
+  %sel2 = load i32, i32* %ehselector.slot, align 4
+  %lpad.val = insertvalue { i8*, i32 } undef, i8* %exn1, 0
+  %lpad.val3 = insertvalue { i8*, i32 } %lpad.val, i32 %sel2, 1
+  resume { i8*, i32 } %lpad.val3
+}
+
+; ASM:  ._Z9catchFuncv:
+; ASM:  L..func_begin0:
+; ASM:  # %bb.0:                                # %entry
+; ASM:    mflr 0
+; ASM:  L..tmp0:
+; ASM:    bl ._Z9throwFuncv
+; ASM:    nop
+; ASM:  L..tmp1:
+; ASM:  # %bb.1:                                # %invoke.cont
+; ASM:    li 3, 1
+; ASM:  L..BB1_2:                               # %return
+; ASM:    mtlr 0
+; ASM:    blr
+; ASM:  L..BB1_3:                               # %lpad
+; ASM:  L..tmp2:
+; ASM:    bl .__cxa_begin_catch[PR]
+; ASM:    nop
+; ASM:    bl .__cxa_end_catch[PR]
+; ASM:    nop
+; ASM:    b L..BB1_2
+; ASM:  L..func_end0:
+
+; ASM:    .csect .gcc_except_table[RO],2
+; ASM:    .align  2
+; ASM:  GCC_except_table1:
+; ASM:  L..exception0:
+; ASM:    .byte 255                             # @LPStart Encoding = omit
+; ASM32:  .byte 187                             # @TType Encoding = indirect datarel sdata4
+; ASM64:  .byte 188                             # @TType Encoding = indirect datarel sdata8
+; ASM:    .uleb128 L..ttbase0-L..ttbaseref0
+; ASM:  L..ttbaseref0:
+; ASM:    .byte 3                               # Call site Encoding = udata4
+; ASM:    .uleb128 L..cst_end0-L..cst_begin0
+; ASM:  L..cst_begin0:
+; ASM:    .vbyte  4, L..tmp0-L..func_begin0       # >> Call Site 1 <<
+; ASM:    .vbyte  4, L..tmp1-L..tmp0              #   Call between L..tmp0 and L..tmp1
+; ASM:    .vbyte  4, L..tmp2-L..func_begin0       #     jumps to L..tmp2
+; ASM:    .byte 1                               #   On action: 1
+; ASM:    .vbyte  4, L..tmp1-L..func_begin0       # >> Call Site 2 <<
+; ASM:    .vbyte  4, L..func_end0-L..tmp1         #   Call between L..tmp1 and L..func_end0
+; ASM:    .vbyte  4, 0                            #     has no landing pad
+; ASM:    .byte 0                               #   On action: cleanup
+; ASM:  L..cst_end0:
+; ASM:    .byte 1                               # >> Action Record 1 <<
+; ASM:                                          #   Catch TypeInfo 1
+; ASM:    .byte 0                               #   No further actions
+; ASM:    .align  2
+; ASM:                                          # >> Catch TypeInfos <<
+; ASM32:  .vbyte  4, L..C0-TOC[TC0]               # TypeInfo 1
+; ASM64:  .vbyte  8, L..C0-TOC[TC0]               # TypeInfo 1
+; ASM:  L..ttbase0:
+; ASM:    .align  2
+; ASM:    .csect .eh_info_table[RW],2
+; ASM:  __ehinfo.1:
+; ASM:    .vbyte  4, 0
+; ASM32:  .align  2
+; ASM32:  .vbyte  4, GCC_except_table1
+; ASM32:  .vbyte  4, __xlcxx_personality_v1[DS]
+; ASM64:  .align  3
+; ASM64:  .vbyte  8, GCC_except_table1
+; ASM64:  .vbyte  8, __xlcxx_personality_v1[DS]
+
+; ASM:    .toc
+; ASM:  L..C0:
+; ASM:    .tc _ZTIi[TC],_ZTIi[UA]
+
+declare i8* @__cxa_allocate_exception(i32)
+declare void @__cxa_throw(i8*, i8*, i8*)
+declare i32 @__xlcxx_personality_v1(...)
+declare i32 @llvm.eh.typeid.for(i8*)
+declare i8* @__cxa_begin_catch(i8*)
+declare void @__cxa_end_catch()