[libc++abi][AIX] add personality and helper functions for the state table EH

[xingxue]

Summary

This patch adds the personality and helper functions for the state table based EH used by IBM legacy compilers xlC and xlclang++ on AIX.

• A high level description of the state table based EH is provided in the code comments.

• Function scan_state_tab() is added to scan the state table. It is invoked by the state table personality routine __xlcxx_personality_v0() and returns scan_results like scan_eh_tab() does.

• A couple of EH helper functions used by xlC and xlclang++ generated code are also added, e.g., __xlc_catch_matchv2() which checks whether the thrown object matches the catch handler's exception type.

• Debugging macros _LIBCXXABI_TRACE_STATETAB, _LIBCXXABI_TRACE_STATETAB0, and _LIBCXXABI_TRACING_STATETAB are added to dump state table scanning traces if environment variable LIBCXXABI_PRINT_STATTAB is set.

• The state variable and state table data is the LSDA found from the traceback table of the function during unwinding (see https://reviews.llvm.org/D100132).

• No issues were found when running tests of the libunwind and libcxxabi test suites. LIT test cases have been added for code specific to AIX EH.

[jasonliu]

libcxxabi/src/cxa_personality.cpp

1814

This should be marked as "always inline" to reduce the call overhead.

[xingxue]

In D100504#2703703, @MaskRay wrote:

In sanitizer runtime, we create separate files and duplicate some needed functions when a platform has sufficient different implementation. See compiler-rt/lib/sanitizer_common/*.cpp and compiler-lib/lib/lsan/lsan_*.cpp for examples.

I have simplified the Itanium LSDA a lot. From my experience the code sharing with arm EHABI actually made it really different to refactor.

@MaskRay Thanks for pointing out the sanitizer files! We will take a look. Yeah, scan_eh_tab and gxx_personality_v0 are much simpler now.

[xingxue]

Changes:

• Split off changes for enabling calculating relative addresses with the DW_EH_PE_datarel encoding using a base (https://reviews.llvm.org/D101298).
• Reverted to making __xlcxx_personality_v1 an alias of __gxx_personality_v0.

[xingxue]

libcxxabi/src/cxa_personality.cpp

1814

Reverted to making __xlcxx_personality_v1 an alias of __gxx_personality_v0.

[cebowleratibm]

Are there any tests planned for this patch? We would have to commit XL binaries, or I think a better approach would be to write C code with a user defined eh fsm table.

libcxxabi/src/cxa_personality.cpp

1298

I think this inclusion is better at the top of the file.

1316

Isn't this on line 1248?

1327

I find it a bit awkward to see the matching #ifdef
suggest: #endif // NDEBUG

1347

Suggestion: use flexible array member.

1358

I don't see a compelling reason to use macros for these values. I suggest a typed enum for FSM::magic that defines the FSM_MAGIC values as eumerators.

1362

I don't see a compelling reason to use macros for these values. I suggest a typed enum that defines these values as enumerators, then union that with a size_t member. I think this makes the contract FSMEntry::count more clear.

1368

suggest: FSMEntry::flags should be typed enum and define these flag values as enumerators.

1398

is it appropriate to assert that count won't be [-5, -1] or can those count values legitimately show up here?

1452

I don't think a line break is needed here.

[jasonliu]

libcxxabi/src/cxa_personality.cpp

1316

Yes. It wasn't there before my comment. Xing addressed my comment. Thanks.

[hubert.reinterpretcast]

libcxxabi/src/cxa_personality.cpp

1826

I think a call to placement-new should be added.

[xingxue]

Addressed comments:

• Move the include of AIX headers to the top of the file.
• Use flexible array in struct FSM.
• Use typed enum in place of macros.
• Use placement-new in function __cxa_allocate_exception() to get object newexception constructed properly.

Other:

• The personality for the state table terminates unwinding when it finds a catch handler compiled by the legacy xlC compiler.
• Move EH helper functions for xlclang++ compiled code to the same code section.

[xingxue]

libcxxabi/src/cxa_personality.cpp

1316

Including of headers for AIX is moved to the top of the file.

1327

Changed as suggested. Thanks!

1347

Use flexible array as suggested, thanks!

1358

Changed to use typed enum.

1362

Changed to use typed enum.

1368

Changed to use typed enum.

1398

When __Invoke__Destructor() is called, fsmEntry->count is greater than 0. See line 1662.

1826

Good catch, thanks!

[cebowleratibm]

Early comments. Continuing to work through the review.

libcxxabi/src/cxa_personality.cpp

1304

Because the "state table" we're referring to is an IBM proprietary implementation there ought to be an abstract description of what it is and which compilers generate it.

1335

suggest namespacing all of the types that pertain to the "state table" implementation.

1344

I suggest making this:

union {
  FSMEntryCount flag;
  intptr_t count;
}

which makes overlapping use of the memory more clear.

1346

should the flags be of type FSMEntryFlag? Noting FSMEntryFlag has type int16_t

[cebowleratibm]

Review in still on-going.

libcxxabi/src/cxa_personality.cpp

1366

why number0, 2 3? reads as though there a missing number1

1393

Suggest adding a comment.

The address of the object for the cleanup action is based on the StateVariable::thisValue

1394

Also suggest adding a comment but I don't have a suggestion at this time. It looks like it tells the unwinder an extra indirect is required to arrive at the virtual base to evaluate the address of the object for the cleanup action.

1395

Although I know this wasn't documented in the internal IBM source I think we should provide a comment

// The table entry offset is the start address of the object.

1401

this is only used in InvokeDestructor. I recommend a static const local. The preprocessor is not needed here.

1457

The XL code adds in the value in the frame pointer register, which you're no longer doing here. Can you explain the difference? (same question for the else path below)

1565

Noting a behaviour difference to confirm: I expect the legacy IBM code would have quietly skipped over the frame. This return would force fail the unwind.

1570

Likewise, the legacy IBM unwinder would quietly skip over the frame.

1588

Minor suggestion: "Processing" -> "Searching" or similar so that the log more clearly denotes the search phase.

1603

The missing catch matching logic is ominous. Suggest adding a comment that we know that any XL compiled catch handler always appended a catch(...) handler so we know that any catch will match the exception.

1610

Are we better to delay the call to terminate and begin the cleanup phase or is it better to call terminate before any cleanup actions are performed?

1613

I also suggest adding a union type for the conditional state table entry so that the code reads cleaner rather than chasing seemingly random fields in the code. (we happen to know the offset field holds a pointer to the state before the conditional state?)

[cebowleratibm]

More comments.

libcxxabi/src/cxa_personality.cpp

1389

IMO "stateChange" is poorly named. These flags exist for handling conditional state changes so that we know which path was taken at runtime. Suggest "conditionalStateChange" and "oldConditionalStateChange"

Ex: "(b ? (T1(), foo()) : (T2(), foo())), throw 42;" This causes us to encounter a conditional state change so that we know if T1 or T2 need to be destroyed. I think the comments should be more helpful.

1591

addr is only used on the FSMEntryFlag::stateChange code path. I think it's better to push this down into that path so that we're not evaluating garbage addresses on the other paths, even if they're not used it's just something to go wrong in the future.

It's also unnecessary to call the general compute_obj_addr on this path as we know exactly how to find the next state from the conditional state table entry. Suggest a new function compute_next_state or similar and use this function on both the search and cleanup phases.

1638

suggest "else if" -> "if"

1649

similar comment to what I had for the search phase: some of the paths don't have meaningful address value computations. I think it's better to split those paths above the call to compute_obj_addr so that we only evaluate it on the paths where it's meaningful.

1663

I suggest changing the "else if" to an "if" because the preceding block always exits the if-stmt. Applies to multiple "else if"s here.

1677

The IBM XL proprietary unwinder adds an extra indirect when vBaseFlag is set. I don't see that logic in compute_obj_addr.

1683

The comment is a bit misleading. We know that the catch will handle the exception and rethrow it if there's no catch match (I don't think this is valid behaviour, however, we're simply replicating what the XL behaviour was)

1696

Aside from the trace statements I believe the beginCatch, endCatch and inlineDestructor paths do exactly the same thing: retrieve the landing pad address from the entry catchBlock and install the handler. I think it's best to share the code path for these 3 cases.

[xingxue]

Addressed comments.

• Used unions where the same memory is used for different purposes to make overlapping use of the memory more clear.
• Renamed variables to be more descriptive.
• Added a high level description of the state table based EH.
• Added comments in various locations.
• Fixed a problem where the frame pointer is needed to calculate the address.
• Fixed the address calculation of virtual base object for calling destructor or deletor to be based on the IBM object model used by the proprietary xlC compiler because these paths are only used for xlC generated code.
• Commoned up some code to reduce redundancy.

[xingxue]

libcxxabi/src/cxa_personality.cpp

1304

Added a high level description of the state table.

1335

Added namespace __state_table_eh.

1344

Changed to:

union {
  // The flag for actions (when the value is negative).
  FSMEntryCount actionFlag;
  // The element count (when the value is positive or zero).
  intptr_t elementCount;
};

Also changed to use a union for the offset field.

union {
  // Offset of the object within its stack frame or containing object.
  intptr_t offset;
  // Address of a global object.
  intptr_t address;
  // Address of the next state if it is an old conditional state change entry.
  intptr_t nextStatePtr;
};

1346

Good point, changed to use type FSMEntryFlag. Thanks!

1366

These are mapped from the legacy runtime (FSM_MAGIC, FSM_MAGIC2, and FSM_MAGIC3) except that 'FSM_MAGIC' should have been mirrored to number rather than number0. Changed from number0 to number.

1389

Changed the naming and added comments as suggested, thanks!

1393

Added the comment as suggested, thanks!

1394

Added the comment "The object is of a virtual base class.".

1395

Changed as suggested. Also added description of the state table fields.

1401

Changed as suggested, thanks.

1457

Good catch, fixed. Thanks and sorry for my oversight.

1565

The state table is corrupted when this branch is entered so it makes sense to hard stop rather than quietly ignoring the frame IMHO.

1570

Same as the comment above.

1588

The debugging statement at the beginning of this function (line 1499) prints out the current action, search or cleanup. Then "Processing state=" is printed in a loop that processes the states.

1591

Changed to call compute_obj_addr only in paths where addr is used.

1603

Added the comment as suggested, thanks!

1610

The legacy runtime EH has one phase and performs cleanups while unwinding the stack. I am inclined to be consistent with that behavior because this code is dealing with the frame generated by the legacy compilers. xlC or xlclang++. We can do it the other way if you think that is better.

1613

Fixed. Also added a union member nextStatePtr in structure FSMEntry.

1638

Changed as suggested.

1649

Changed as suggested, thanks!

1663

Changes as suggested, thanks.

1677

Good catch! The IBM XL proprietary compiler xlC uses the IBM object model which needs an extra indirect and the CXA model used by xlclang++ does not. Fortunately, the xlclang++ compiler generates inline destructor and therefore, we can safely assume it is an xlC generated frame when it gets here. Changing to have an extra indirect.

1683

Added a table above to describe the actions.

1696

Changed as suggested, thanks!

[cebowleratibm]

Looks good. I didn't find any semantic issues but I did have a number of suggestions on further refinements for clarity of the code. A vast improvement over the proprietary XL code btw! Thanks Xing.

libcxxabi/src/cxa_personality.cpp

1312

Clarification suggestions:
suggest "...also has an autolocal state variable"
suggest "...and is found through the traceback table..."

1392

"inline destructor" is an XL proprietary term. What we're really saying is there's a label in the state table entry and the runtime should simply install the "landing pad".

I would suggest: "landingPadHandler" or similar and also replace the term "inline destructor" in any of the comments.

1442

There's an implicit expectation that size_t and intptr_t are the same size. Is it better to use

uintptr_t elementCount
```?

1722

Suggest removing "xlC" from reference here since xlC frames are handled by the code block above.

Suggest further comment clarification: It's important to note that xlclang++ compiled frames use cxa-abi EH calls and we know that any catch block will include a catch(...) so we can safely say handler found without running a catch match. Unfortunately this makes the search phase less useful but it's all we can do and no worse than the current runtime EH for xlclang++ programs.

1791

The code reads strange here: "compute_obj_addr", what object is in the state table entry?

Perhaps a comment like: A conditional state table entry holds the address of a local that holds the next state to unwind to.

1794

typo "onditionalStateChange"

1826

compute_obj_addr seems to be overloaded for "computeMagicalAddress" and the caller happens to know what the address means based on a bunch of flags.

Either only call compute_obj_addr when there is an actual object address returned or change the name of the function to something like "compute_addr_from_table" so that the name doesn't imply it always returns an object address.

[xingxue]

Addressed comments.

• Updated code comments;
• Renamed variable inlineDestructor to cleanupLabel. Replaced the term "inline destructor" with "cleanup code";
• Renamed function compute_obj_addr to compute_addr_from_table.

[xingxue]

libcxxabi/src/cxa_personality.cpp

1312

Changes as suggested, thanks!

1392

Changed inline_destructor to cleanupLabel as discussed off line. Term "inline destructor" has been changed in comments as well.

1442

uintptr_t is a type that is guaranteed to hold pointer void*, whether it is 32-bit or 64-bit. elementCount is a count so I think size_t is better.

1722

Modified comments as suggested, thanks!

1791

Added the comment as suggested, thanks!

1794

Fixed, thanks for catching it!

1826

Changed compute_obj_addr to compute_addr_from_table.

[xingxue]

Fixed format according to git-clang-format.

[cebowleratibm]

I've had a thorough review and access to the proprietary XL "state table EH" code and I believe this patch is ready to land, nonetheless, I do not have the authority to grant permission to commit this patch. This patch should not affect targets other than AIX and Xing has already run thorough proprietary test coverage against this implementation. Essentially this is a tidied-up version of the EH runtime support we already provide with the libc++ we distribute for AIX.

[ldionne]

@MaskRay Does this look reasonable to you?

[MaskRay]

In D100504#3419067, @ldionne wrote:

@MaskRay Does this look reasonable to you?

Sorry for the belated response. I was on trips for the past two weeks and spent little time on reading patches.

I know nearly nothing about AIX. scan_state_tab and the personality routine have similar structures with the Itanium implementation, and the structure looks good to me.
There are many many extra stuff specific to AIX. I think we need to leave that to the domain expert.
Left some code styles comments inline.
From the structure of the file cxa_personality.cpp, I think it is cleaner to move the large AIX #ifdef #endif to a separate file.
The separate file can be a .cpp file, or if the impl needs to reuse many static functions, an .inc file (llvm and compiler-rt have a dozen .inc files. I can see that libc++/libc++abi haven't adopted this type of files yet).

libcxxabi/src/cxa_personality.cpp

1355

1357

Add static? Function naming generally uses snake_case in this file.

1382

Prefer using to typedef

1415

See https://llvm.org/docs/CodingStandards.html#anonymous-namespaces

1465

Just use constexpr. The non-template variable of non-volatile const-qualified type having namespace-scope has internal linkage even in the absence of static. Also fix the style of gRegisterNum

1468

Try avoiding __ (reserved identifiers) for functions not specified by ABI.

Pick a snake_case function name.

1469

reinterpret_cast<void*> can be removed. This applies to many places in the file.

1489

*reinterpret_cast does not need parentheses. This applies to many places in the file.

1493

I don't think the personality impl is supposed to use try catch. You may use other mechanisms to avoid try catch.

1507

1514

The coding standard prefers pre-increment ++p.

ditto below

1525

drop parentheses https://llvm.org/docs/CodingStandards.html#don-t-use-braces-on-simple-single-statement-bodies-of-if-else-loop-statements

1534

drop parentheses https://llvm.org/docs/CodingStandards.html#don-t-use-braces-on-simple-single-statement-bodies-of-if-else-loop-statements

1579

The function is called only once and is not necessarily in a separate function.

For the Itanium impl, I think some if conditions can be reworked to simplify overall complexity.

You can try placing the whole body into __xlcxx_personality_v0 and check whether the total number of if branches can be decreased.

1581

1883

Delete the comment since the _LIBCXXABI_TRACE_STATETAB self explains.

1944

delete blank line

[MaskRay]

libcxxabi/src/cxa_personality.cpp

1949

xlclang++ may generate calls to __Deleted_Virtual may be clearer.

[MaskRay]

libcxxabi/src/cxa_personality.cpp

1493

You can use something like st_terminate in cxa_vector.cpp to catch exceptions in destructors.

[hubert.reinterpretcast]

libcxxabi/src/cxa_personality.cpp

1493

@MaskRay, is there a specific reason you can give for why try/catch should not be used here?

It may be worth noting that the expected build compiler for this code uses a personality routine that is not the one being implemented here. It may also be worth noting that this is less part of the personality routine and more an action that could be thought of as taking place in the corresponding application frame's context (except that, instead of transferring control to code in that frame, the encoded action is called from the personality routine).

That a search phase triggered by throwing an exception during a stack unwinding action finds this try/catch seems compatible with the behaviour seen with other implementations: Unwinding for the new exception happens until the stack unwinding action actually exits via an exception.

It is not the case that entry into this personality routine necessarily means that a new search phase will find a frame with a handler. It is a desirable property that this try/catch is present for the new search phase to consider that there is a handler (and thus perform unwinding).

As for the st_terminate suggestion, the current usage of st_terminate seems to be the source of https://github.com/llvm/llvm-project/issues/55032. That is, entering a handler prior to the call to terminate, as the code here does, is desirable.

[xingxue]

Addressed comments. Moved the implementation for AIX state table based EH into a separate file aix_state_tab_eh.inc as suggested.

[xingxue]

libcxxabi/src/cxa_personality.cpp

1355

Changed as suggested, thanks!

1357

Added static and changed function name to state_tab_dbg. Thanks!

1382

Changed to use using, thanks!

1415

Used anonymous namespace for 3 local structures, thanks!

1465

Changed to use constexpr and renamed gRegisterNum to REG_EXCP_OBJ.

1468

Renamed __Invoke__Destructor and __Invoke__Delete to invoke_destructor and invoke_delete respectively.

1469

The compiler issues a warning if reinterpret_cast<void*> is removed.

warning: format specifies type 'void *' but the argument has type '__cxxabiv1::__state_table_eh::FSMEntry *' [-Wformat-pedantic]

1489

Fixed this and other occurrences, thanks!

1507

get_frame_addr calls _Unwind_GetIP and _Unwind_GetGR with context as an argument. Adding const will cause mismatches because _Unwind_GetIP and _Unwind_GetGR do not have the const qualifier for argument context.

1514

Fixed this and other occurrences, thanks for pointing out!

1525

Fixed, thanks!

1534

Fixed, thanks!

1579

Function scan_state_tab is indeed called only once. It is separated from __xlcxx_personality_v0 so that the structure of the state table personality is the same as that of the Itanium personality. This makes the code easier to compare and understand.

I tried to place the whole body into __xlcxx_personality_v0 and the number of if branches is decreased by 2. These if branches are ones in the original __xlcxx_personality_v0 code because it now returns directly from the code in scan_state_tab without going through __xlcxx_personality_v0.

With that, I am inclined to keep the structure as is.

1581

Fixed, thanks!

1883

Done, thanks!

1944

Done.

1949

Changed as suggested, thanks!

[xingxue]

Fixed problems in pre-merg check.

• Avoid using GCC extension named variadic macros;
• Avoid using C99 feature flexible array members.

[xingxue]

Hi @MaskRay, Do you have further comments?

[MaskRay]

libcxxabi/src/aix_state_tab_eh.inc

64

67

71

#ifdef NDEBUG.

It is not nested, and should have spaces between # and ifdef.

[xingxue]

Addressed comments:

• Fixed formatting.

[xingxue]

libcxxabi/src/aix_state_tab_eh.inc

64

Fixed, thanks!

67

Fixed, thanks!

71

Fixed, thanks!

[xingxue]

Hi @MaskRay, Do you have further comments? If not, would you be able to approve this patch? My colleague @cebowleratibm, who is an AIX compiler and runtime expert, has done a thorough review of AIX specific contents and approved it (see comment https://reviews.llvm.org/D100504#3414984). This implementation has been run through the proprietary test coverage and included in the IBM Open XL C/C++ for AIX V17.1 compiler released in Sept. 2021.

[MaskRay]

but you need some from #libc_abi

[xingxue]

Thanks very much, @MaskRay!
@ldionne Do you have further comments? If not, would you be able to approve for #libc_abi?

[ldionne]

Deferring to @MaskRay for approval. The AIX-specific contact surface with libc++abi has been reduced to the minimum via the #include, which I like.

[xingxue]

@MaskRay, @cebowleratibm, @ldionne, @hubert.reinterpretcast, @jasonliu: Thank you so much for your help, time and effort in reviewing, and constructive suggestions. All of these make the patch much better than it was. Thanks again!

libcxxabi/src/aix_state_tab_eh.inc

+//===----------------------------------------------------------------------===//
+//
+// 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 implements the personality and helper functions for the state
+//  table based EH used by IBM legacy compilers xlC and xlclang++ on AIX.
+//
+//===----------------------------------------------------------------------===//
+
+#include <new>
+#include <stdio.h>
+#include <sys/debug.h>
+
+/*
+  The legacy IBM xlC and xlclang++ compilers use the state table for EH
+  instead of the range table. Destructors, or addresses of the possible catch
+  sites or cleanup code are specified in the state table which is a finite
+  state machine (FSM). Each function that has a state table also has an
+  autolocal state variable. The state variable represents the current state
+  of the function for EH and is found through the traceback table of the
+  function during unwinding, which is located at the end of each function.
+  The FSM is an array of state entries. Each state entry has the following
+  fields:
+
+  * offset/address/pointer - the offset used to locate the object, or the
+    address of a global object, or the address of the next state if it is an
+    old conditional state change entry;
+  * dtor/landing pad - address of the destructor function to invoke,
+    or address of the catch block or cleanup code in the user code to branch to;
+  * element count/action flag - the number of elements or the flag for actions;
+  * element size - if the object is an array this is the size of one element
+    of the array;
+  * flags - flags used to control how fields in the entry are interpreted;
+  * next state - the state to execute next after the action for this state is
+    performed. The value of zero indicates the end of the state for this
+    function.
+
+  The following is the description of 'element count/action flag' field.
++-----------------------------------------------------------------------------+
+| value |      description       |                  action                    |
++-------+------------------------+--------------------------------------------+
+| > 1   |   object is an array   | calls __cxa_vec_cleanup to run dtor for    |
+|       |                        | each member of the array                   |
++-------+------------------------+--------------------------------------------+
+| 1, 0  |   object is a scalar   | calls dtor for the object                  |
++-------+------------------------+--------------------------------------------+
+|  -1   |      begin catch       | branches to the handler which performes    |
+|       |                        | catch-match. If there is no catch that     |
+|       |                        | matches the exception it will be rethrown  |
++-------+------------------------+--------------------------------------------+
+|  -2   |       end catch        | ends current catch block and continues     |
+|       |                        | attempting to catch the exception          |
++-------+------------------------+--------------------------------------------+
+|  -3   |   delete the object    | calls the delete function of the object    |
++-------+------------------------+--------------------------------------------+
+|  -4   |      cleanup label     | branches to the user code for cleaning up  |
++-------+------------------------+--------------------------------------------+
+*/
+
+namespace __cxxabiv1 {
+
+extern "C" {
+
+// Macros for debugging the state table parsing.
+#ifdef NDEBUG
+#  define _LIBCXXABI_TRACE_STATETAB(msg, ...)
+#  define _LIBCXXABI_TRACE_STATETAB0(msg)
+#  define _LIBCXXABI_TRACE_STATETAB1(msg)
+#  define _LIBCXXABI_TRACING_STATETAB 0
+#else
+static bool state_tab_dbg() {
+  static bool checked = false;
+  static bool log = false;
+  if (!checked) {
+    log = (getenv("LIBCXXABI_PRINT_STATTAB") != NULL);
+    checked = true;
+  }
+  return log;
+}
+
+#  define _LIBCXXABI_TRACE_STATETAB(msg, ...)                                  \
+     do {                                                                      \
+       if (state_tab_dbg())                                                    \
+         fprintf(stderr, "libcxxabi: " msg, __VA_ARGS__);                      \
+     } while (0)
+#  define _LIBCXXABI_TRACE_STATETAB0(msg)                                      \
+     do {                                                                      \
+       if (state_tab_dbg())                                                    \
+         fprintf(stderr, "libcxxabi: " msg);                                   \
+     } while (0)
+#  define _LIBCXXABI_TRACE_STATETAB1(msg)                                      \
+     do {                                                                      \
+       if (state_tab_dbg())                                                    \
+         fprintf(stderr, msg);                                                 \
+     } while (0)
+
+#  define _LIBCXXABI_TRACING_STATETAB state_tab_dbg()
+#endif // NDEBUG
+
+namespace __state_table_eh {
+
+using destruct_f = void (*)(void*);
+
+// Definition of flags for the state table entry field 'action flag'.
+enum FSMEntryCount : intptr_t { beginCatch = -1, endCatch = -2, deleteObject = -3, cleanupLabel = -4, terminate = -5 };
+
+// Definition of flags for the state table entry field 'flags'.
+enum FSMEntryFlag : int16_t {
+  indirect = 0x100,                  // Object was thrown from a function where
+                                     // the return value optimization was used.
+  oldConditionalStateChange = 0x400, // State table entry is an indirect state
+                                     // change, dereference the address in
+                                     // offset as int for the target state.
+                                     // This is deprecated. This indicates
+                                     // the address is direct. (static local).
+  conditionalStateChange = 0x800,    // State table entry is an indirect state
+                                     // change, dereference the address in
+                                     // offset as int for the target state.
+                                     // The temporary is an automatic. State
+                                     // change is used in cases such as
+                                     // (b?(T1(),foo()):(T2(),foo())),throw 42;
+                                     // which causes a conditional state change
+                                     // so that we know if T1 or T2 need to be
+                                     // destroyed.
+  thisFlag = 0x01,                   // The address of the object for the
+                                     // cleanup action is based on the
+                                     // StateVariable::thisValue.
+  vBaseFlag = 0x02,                  // The object is of a virtual base class.
+  globalObj = 0x04                   // FSMEntry::address is the address of
+                                     // a global object.
+};
+
+namespace {
+// The finite state machine to be walked.
+struct FSMEntry {
+  union {
+    // Offset of the object within its stack frame or containing object.
+    intptr_t offset;
+    // Address of a global object.
+    intptr_t address;
+    // Address of the next state if it is an old conditional state change entry.
+    intptr_t nextStatePtr;
+  };
+  union {
+    // Address of the destructor function.
+    void (*destructor)(void*, size_t);
+    // The address of the catch block or cleanup code.
+    void* landingPad;
+  };
+  union {
+    // The flag for actions (when the value is negative).
+    FSMEntryCount actionFlag;
+    // The element count (when the value is positive or zero).
+    size_t elementCount;
+  };
+  size_t elemSize;
+  FSMEntryFlag flags;
+  uint16_t nextState;
+};
+
+struct FSM {
+  uint32_t magic; // Magic number of the state table.
+  int32_t numberOfStates;
+  FSMEntry table[1]; // Actually table[numberOfStates].
+};
+
+// The state variable on the stack.
+struct StateVariable {
+  int32_t state;
+  struct FSM* table;
+  intptr_t thisValue;
+  int32_t ignoreVBasePtrs;
+};
+} // namespace
+
+// State table magic number
+enum FSMMagic : uint32_t {
+  number = 0xbeefdead,  // State table generated by xlC compiler.
+  number2 = 0xbeeedead, // State table generated by early version xlC compiler.
+  number3 = 0x1cedbeef  // State table generated by xlclang++ compiler.
+};
+
+constexpr uint32_t REG_EXCP_OBJ = 14; // Register to pass the address of the exception
+                                      // object from the personality to xlclang++
+                                      // compiled code.
+
+constexpr size_t dtorArgument = 0x02; // Flag to destructor indicating to free
+                                      // virtual bases, don't delete object.
+
+static void invoke_destructor(FSMEntry* fsmEntry, void* addr) {
+  _LIBCXXABI_TRACE_STATETAB("Destruct object=%p, fsmEntry=%p\n", addr, reinterpret_cast<void*>(fsmEntry));
+  try {
+    if (fsmEntry->elementCount == 1) {
+      _LIBCXXABI_TRACE_STATETAB0("calling scalar destructor\n");
+      (*fsmEntry->destructor)(addr, dtorArgument);
+      _LIBCXXABI_TRACE_STATETAB0("returned from scalar destructor\n");
+    } else {
+      _LIBCXXABI_TRACE_STATETAB0("calling vector destructor\n");
+      __cxa_vec_cleanup(addr, reinterpret_cast<size_t>(fsmEntry->elementCount), fsmEntry->elemSize,
+                        reinterpret_cast<destruct_f>(fsmEntry->destructor));
+      _LIBCXXABI_TRACE_STATETAB0("returned from vector destructor\n");
+    }
+  } catch (...) {
+    _LIBCXXABI_TRACE_STATETAB0("Uncaught exception in destructor, terminating\n");
+    std::terminate();
+  }
+}
+
+static void invoke_delete(FSMEntry* fsmEntry, void* addr) {
+  char* objectAddress = *reinterpret_cast<char**>(addr);
+
+  _LIBCXXABI_TRACE_STATETAB("Delete object=%p, fsmEntry=%p\n", reinterpret_cast<void*>(objectAddress),
+                            reinterpret_cast<void*>(fsmEntry));
+  try {
+    _LIBCXXABI_TRACE_STATETAB0("..calling delete()\n");
+    // 'destructor' holds a function pointer to delete().
+    (*fsmEntry->destructor)(objectAddress, fsmEntry->elemSize);
+    _LIBCXXABI_TRACE_STATETAB0("..returned from delete()\n");
+  } catch (...) {
+    _LIBCXXABI_TRACE_STATETAB0("Uncaught exception in delete(), terminating\n");
+    std::terminate();
+  }
+}
+
+// Get the frame address of the current function from its traceback table
+// which is at the end of each function.
+static uintptr_t get_frame_addr(_Unwind_Context* context) {
+  int framePointerReg = 1; // default frame pointer == SP.
+  uint32_t* p = reinterpret_cast<uint32_t*>(_Unwind_GetIP(context));
+
+  // Keep looking forward until a word of 0 is found. The traceback
+  // table starts at the following word.
+  while (*p)
+    ++p;
+  tbtable* TBTable = reinterpret_cast<tbtable*>(p + 1);
+
+  p = reinterpret_cast<uint32_t*>(&TBTable->tb_ext);
+
+  // Skip field parminfo if it exists.
+  if (TBTable->tb.fixedparms || TBTable->tb.floatparms)
+    ++p;
+
+  // Skip field tb_offset if it exists.
+  if (TBTable->tb.has_tboff)
+    ++p;
+
+  // Skip field hand_mask if it exists.
+  if (TBTable->tb.int_hndl)
+    ++p;
+
+  // Skip fields ctl_info and ctl_info_disp if they exist.
+  if (TBTable->tb.has_ctl)
+    p += 1 + *p;
+
+  // Skip fields name_len and name if exist.
+  if (TBTable->tb.name_present) {
+    const uint16_t name_len = *reinterpret_cast<uint16_t*>(p);
+    p = reinterpret_cast<uint32_t*>(reinterpret_cast<char*>(p) + name_len + sizeof(uint16_t));
+  }
+
+  if (TBTable->tb.uses_alloca)
+    framePointerReg = *reinterpret_cast<char*>(p);
+
+  return _Unwind_GetGR(context, framePointerReg);
+}
+
+// Calculate the object address from the FSM entry.
+static void* compute_addr_from_table(FSMEntry* fsmEntry, StateVariable* const state, _Unwind_Context* context) {
+  void* addr;
+  if (fsmEntry->flags & FSMEntryFlag::globalObj) {
+    addr = reinterpret_cast<void*>(fsmEntry->address);
+    _LIBCXXABI_TRACE_STATETAB("Address calculation (global obj) addr=fsmEntry->address=%p\n", addr);
+  } else if (fsmEntry->flags & FSMEntryFlag::thisFlag) {
+    addr = reinterpret_cast<void*>(state->thisValue + fsmEntry->offset);
+    _LIBCXXABI_TRACE_STATETAB("Address calculation (this obj) fsmEntry->offset=%ld : "
+                              "state->thisValue=%ld addr=(fsmEntry->offset+state->thisValue)=%p\n",
+                              fsmEntry->offset, state->thisValue, addr);
+  } else if (fsmEntry->flags & FSMEntryFlag::indirect) {
+    addr = reinterpret_cast<void*>(
+        *reinterpret_cast<char**>(get_frame_addr(context) + static_cast<uintptr_t>(fsmEntry->offset)));
+    _LIBCXXABI_TRACE_STATETAB("Address calculation (indirect obj) addr=%p, fsmEntry->offset=%ld \n",
+                              addr, fsmEntry->offset);
+  } else {
+    addr = reinterpret_cast<void*>(get_frame_addr(context) + static_cast<uintptr_t>(fsmEntry->offset));
+    _LIBCXXABI_TRACE_STATETAB("Address calculation. (local obj) addr=fsmEntry->offset=%p\n",
+                              addr);
+  }
+  return addr;
+}
+
+static void scan_state_tab(scan_results& results, _Unwind_Action actions, bool native_exception,
+                           _Unwind_Exception* unwind_exception, _Unwind_Context* context) {
+  // Initialize results to found nothing but an error.
+  results.ttypeIndex = 0;
+  results.actionRecord = 0;
+  results.languageSpecificData = 0;
+  results.landingPad = 0;
+  results.adjustedPtr = 0;
+  results.reason = _URC_FATAL_PHASE1_ERROR;
+
+  // Check for consistent actions.
+  if (actions & _UA_SEARCH_PHASE) {
+    // Do Phase 1
+    if (actions & (_UA_CLEANUP_PHASE | _UA_HANDLER_FRAME | _UA_FORCE_UNWIND)) {
+      // None of these flags should be set during Phase 1.
+      //   Client error
+      results.reason = _URC_FATAL_PHASE1_ERROR;
+      return;
+    }
+  } else if (actions & _UA_CLEANUP_PHASE) {
+    if ((actions & _UA_HANDLER_FRAME) && (actions & _UA_FORCE_UNWIND)) {
+      // _UA_HANDLER_FRAME should only be set if phase 1 found a handler.
+      // If _UA_FORCE_UNWIND is set, phase 1 shouldn't have happened.
+      //    Client error
+      results.reason = _URC_FATAL_PHASE2_ERROR;
+      return;
+    }
+  } else {
+    // Neither _UA_SEARCH_PHASE nor _UA_CLEANUP_PHASE is set.
+    //   Client error
+    results.reason = _URC_FATAL_PHASE1_ERROR;
+    return;
+  }
+
+  if (_LIBCXXABI_TRACING_STATETAB) {
+    _LIBCXXABI_TRACE_STATETAB1("\n");
+    _LIBCXXABI_TRACE_STATETAB("%s: actions=%d (", __func__, actions);
+
+    if (_UA_SEARCH_PHASE & actions)
+      _LIBCXXABI_TRACE_STATETAB1("_UA_SEARCH_PHASE ");
+    if (_UA_CLEANUP_PHASE & actions)
+      _LIBCXXABI_TRACE_STATETAB1("_UA_CLEANUP_PHASE ");
+    if (_UA_HANDLER_FRAME & actions)
+      _LIBCXXABI_TRACE_STATETAB1("_UA_HANDLER_FRAME ");
+    if (_UA_FORCE_UNWIND & actions)
+      _LIBCXXABI_TRACE_STATETAB1("_UA_FORCE_UNWIND ");
+    _LIBCXXABI_TRACE_STATETAB1(")\n");
+    _LIBCXXABI_TRACE_STATETAB("       unwind_exception=%p context=%p\n", reinterpret_cast<void*>(unwind_exception),
+                              reinterpret_cast<void*>(context));
+  }
+
+  // Start scan by getting state table address.
+  StateVariable* const state = reinterpret_cast<StateVariable* const>(_Unwind_GetLanguageSpecificData(context));
+  if (state->state <= 0) {
+    // The state is not correct - give up on this routine.
+    _LIBCXXABI_TRACE_STATETAB("state=%d and is <= 0), continue unwinding\n", state->state);
+    results.reason = _URC_CONTINUE_UNWIND;
+    return;
+  }
+  // Parse the state table.
+  FSM* const fsm = state->table;
+  FSMEntry* currFSMEntry;
+
+  if (fsm->magic != FSMMagic::number && fsm->magic != FSMMagic::number2 && fsm->magic != FSMMagic::number3) {
+    // Something is wrong with the state table we found.
+    if (_UA_SEARCH_PHASE & actions) {
+      _LIBCXXABI_TRACE_STATETAB0("Invalid FSM table, return _URC_FATAL_PHASE1_ERROR\n");
+      results.reason = _URC_FATAL_PHASE1_ERROR;
+    } else if (_UA_CLEANUP_PHASE & actions) {
+      _LIBCXXABI_TRACE_STATETAB0("Invalid FSM table, return _URC_FATAL_PHASE2_ERROR\n");
+      results.reason = _URC_FATAL_PHASE2_ERROR;
+    } else {
+      // We should never get here.
+      _LIBCXXABI_TRACE_STATETAB0("Invalid FSM table + RT Internal error, return _URC_FATAL_PHASE2_ERROR\n");
+      results.reason = _URC_FATAL_PHASE2_ERROR;
+    }
+    return;
+  }
+
+  if (_LIBCXXABI_TRACING_STATETAB) {
+    // Print the state table for debugging purposes.
+    _LIBCXXABI_TRACE_STATETAB("state->state=%d, state->ignoreVBasePtrs=%d\n", state->state, state->ignoreVBasePtrs);
+    _LIBCXXABI_TRACE_STATETAB("fsm->magic=%#x, fsm->numberOfStates=%d\n", fsm->magic, fsm->numberOfStates);
+    // Print out the FSM table.
+    _LIBCXXABI_TRACE_STATETAB0("FSM table:\n");
+    _LIBCXXABI_TRACE_STATETAB("%12s %10s %8s  %10s %7s %7s %7s %7s\n", "Entry Addr", "state", "Offset", "DTR/lpad",
+                              "count", "el_size", "flags", "next");
+    for (int i = 0; i < fsm->numberOfStates; i++) {
+      currFSMEntry = &fsm->table[i];
+      _LIBCXXABI_TRACE_STATETAB("%12p (%8d) %8ld  %10p %7ld "
+                                "%7ld %#7x %7d\n",
+                                reinterpret_cast<void*>(&currFSMEntry), i + 1, currFSMEntry->offset,
+                                reinterpret_cast<void*>(currFSMEntry->destructor),
+                                currFSMEntry->elementCount, currFSMEntry->elemSize, currFSMEntry->flags,
+                                currFSMEntry->nextState);
+    }
+  }
+
+  if (_UA_SEARCH_PHASE & actions) {
+    // Start walking the state table. Use a local copy of state->state so when
+    // we return from search phase we don't change the state number.
+    int currState = state->state;
+
+    while (currState > 0) {
+      currFSMEntry = &fsm->table[currState - 1];
+      _LIBCXXABI_TRACE_STATETAB("Processing state=%d, flags=0x%hx\n", currState, currFSMEntry->flags);
+
+      if (currFSMEntry->actionFlag == FSMEntryCount::beginCatch) {
+        // Found a catch handler.
+        if (fsm->magic == FSMMagic::number) {
+          _LIBCXXABI_TRACE_STATETAB0("Found a xlC catch handler, return _URC_FATAL_PHASE1_ERROR\n");
+          // xlC catch handlers cannot be entered because they use a
+          // proprietary EH runtime that is not interoperable.
+          results.reason = _URC_FATAL_PHASE1_ERROR;
+          return;
+        }
+        // xlclang++ compiled frames use CXA-abi EH calls and any catch
+        // block will include a catch(...) block so it is safe to assume that
+        // the handler is found without checking the catch match. The
+        // catch(...) block will rethrow the exception if there isn't a
+        // match.
+        _LIBCXXABI_TRACE_STATETAB0("Found a catch handler, return _URC_HANDLER_FOUND\n");
+        results.reason = _URC_HANDLER_FOUND;
+        return;
+      }
+      if (currFSMEntry->actionFlag == FSMEntryCount::terminate) {
+        _LIBCXXABI_TRACE_STATETAB0("Found the terminate state, return _URC_HANDLER_FOUND\n");
+        results.reason = _URC_HANDLER_FOUND;
+        return;
+      }
+      if (currFSMEntry->flags & FSMEntryFlag::oldConditionalStateChange) {
+        // Deprecated conditional expression.
+        currState = *reinterpret_cast<int*>(currFSMEntry->nextStatePtr);
+        _LIBCXXABI_TRACE_STATETAB("Flag: FSMEntryFlag::oldConditionalStateChange, dereference "
+                                  "currFSMEntry->nextStatePtr(%ld), set state=%d\n",
+                                  currFSMEntry->nextStatePtr, currState);
+        continue; // We are done this iteration of the loop, since
+                  // we changed a state.
+      }
+      if (currFSMEntry->flags & FSMEntryFlag::conditionalStateChange) {
+        void* addr = compute_addr_from_table(currFSMEntry, state, context);
+        currState = *reinterpret_cast<int*>(addr);
+        _LIBCXXABI_TRACE_STATETAB("Flag: FSMEntryFlag::conditionalStateChange, dereference "
+                                  "addr(%p), set state=%d\n", addr, currState);
+        continue; // We are done this iteration of the loop, since we
+                  // changed the state.
+      }
+      // Go to the next state.
+      currState = currFSMEntry->nextState;
+    }
+    _LIBCXXABI_TRACE_STATETAB0("No catch handler found, return _URC_CONTINUE_UNWIND\n");
+    results.reason = _URC_CONTINUE_UNWIND;
+    return;
+  }
+  if (_UA_CLEANUP_PHASE & actions) {
+    // Start walking the state table.
+    while (state->state > 0) {
+      currFSMEntry = &fsm->table[state->state - 1];
+
+      if (currFSMEntry->actionFlag == FSMEntryCount::terminate) {
+        _LIBCXXABI_TRACE_STATETAB0("Reached terminate state. Call terminate.\n");
+        std::terminate();
+      }
+      // Perform action according to the currFSMEntry->actionFlag,
+      // except when flag is FSMEntryFlag::conditionalStateChange or
+      // FSMEntryFlag::oldConditionalStateChange.
+      _LIBCXXABI_TRACE_STATETAB("Processing state=%d, flags=0x%hx\n", state->state, currFSMEntry->flags);
+      if (currFSMEntry->flags & FSMEntryFlag::oldConditionalStateChange) {
+        state->state = *reinterpret_cast<int*>(currFSMEntry->nextStatePtr);
+        _LIBCXXABI_TRACE_STATETAB("Flag: FSMEntryFlag::oldConditionalStateChange, dereference "
+                                  "currFSMEntry->nextStatePtr(%ld), set state=%d\n",
+                                  currFSMEntry->nextStatePtr, state->state);
+        continue; // We are done with this iteration of the loop, since we changed a state.
+      }
+      if (currFSMEntry->flags & FSMEntryFlag::conditionalStateChange) {
+        // A conditional state table entry holds the address of a local
+        // that holds the next state.
+        void* addr = compute_addr_from_table(currFSMEntry, state, context);
+        state->state = *reinterpret_cast<int*>(addr);
+        _LIBCXXABI_TRACE_STATETAB("Flag: FSMEntryFlag::conditionalStateChange, dereference "
+                                  "addr(%p), set state=%d\n", addr, state->state);
+        continue; // We are done with this iteration of the loop, since we changed a state.
+      }
+      if (currFSMEntry->actionFlag == FSMEntryCount::beginCatch || currFSMEntry->actionFlag == FSMEntryCount::endCatch ||
+          currFSMEntry->actionFlag == FSMEntryCount::cleanupLabel) {
+
+        _LIBCXXABI_TRACE_STATETAB(
+            "FSMEntryCount::%s: handler %p/%p, return _URC_HANDLER_FOUND\n",
+            (currFSMEntry->actionFlag == FSMEntryCount::beginCatch
+                 ? "beginCatch"
+                 : (currFSMEntry->actionFlag == FSMEntryCount::endCatch ? "endCatch" : "cleanupLabel")),
+            currFSMEntry->landingPad, *reinterpret_cast<void**>(currFSMEntry->landingPad));
+
+        state->state = currFSMEntry->nextState;
+        results.landingPad = reinterpret_cast<uintptr_t>(*reinterpret_cast<void**>(currFSMEntry->landingPad));
+        results.reason = _URC_HANDLER_FOUND;
+        return;
+      }
+      if (currFSMEntry->elementCount > 0) {
+        if (currFSMEntry->flags & FSMEntryFlag::vBaseFlag && state->ignoreVBasePtrs) {
+          _LIBCXXABI_TRACE_STATETAB0("Ignoring virtual base dtor.\n");
+        } else {
+          // We need to invoke the virtual base destructor. This must be
+          // a frame from the legacy xlC compiler as the xlclang++ compiler
+          // generates inline cleanup code rather than specifying
+          // the destructor via the state table.
+          void* addr = compute_addr_from_table(currFSMEntry, state, context);
+
+          // An extra indirect to get to the object according to the object
+          // model used by the xlC compiler.
+          addr = reinterpret_cast<void*>(*reinterpret_cast<char**>(addr));
+          _LIBCXXABI_TRACE_STATETAB("Invoke dtor for object=%p\n", addr);
+          invoke_destructor(currFSMEntry, addr);
+        }
+      } else if (currFSMEntry->actionFlag == FSMEntryCount::deleteObject) {
+        void* addr = compute_addr_from_table(currFSMEntry, state, context);
+        if (currFSMEntry->flags & FSMEntryFlag::vBaseFlag) {
+          // We need to invoke the virtual base delete function. This must be
+          // a frame from the legacy xlC compiler as the xlclang++ compiler
+          // generates inline cleanup code rather than specifying
+          // the delete function via the state table.
+
+          // An extra indirect to get to the object according to the object
+          // model used by the xlC compiler.
+          addr = reinterpret_cast<void*>(*reinterpret_cast<char**>(addr));
+        }
+        _LIBCXXABI_TRACE_STATETAB("Delete object at %p\n", addr);
+        invoke_delete(currFSMEntry, addr);
+      } else {
+        _LIBCXXABI_TRACE_STATETAB("Unknown entry in FSM (count=%ld), ignored\n",
+                                  currFSMEntry->elementCount);
+      } // End of action switching.
+
+      // Go to next state.
+      state->state = currFSMEntry->nextState;
+    }
+    _LIBCXXABI_TRACE_STATETAB0("No catch handler, return _URC_CONTINUE_UNWIND\n");
+    results.reason = _URC_CONTINUE_UNWIND;
+    return;
+  }
+  _LIBCXXABI_TRACE_STATETAB0("No state table entry for this exception, call_terminate()\n");
+  // It is possible that no state table entry specify how to handle
+  // this exception. By spec, terminate it immediately.
+  call_terminate(native_exception, unwind_exception);
+}
+
+// Personality routine for EH using the state table.
+_Unwind_Reason_Code __xlcxx_personality_v0(int version, _Unwind_Action actions, uint64_t exceptionClass,
+                                           _Unwind_Exception* unwind_exception, _Unwind_Context* context) {
+  if (version != 1 || unwind_exception == 0 || context == 0)
+    return _URC_FATAL_PHASE1_ERROR;
+
+  bool native_exception = (exceptionClass & get_vendor_and_language) == (kOurExceptionClass & get_vendor_and_language);
+  scan_results results;
+  scan_state_tab(results, actions, native_exception, unwind_exception, context);
+  if (actions & _UA_SEARCH_PHASE) {
+    // Phase 1 search:  All we're looking for in phase 1 is a handler that
+    //   halts unwinding
+    return results.reason;
+  }
+  if (actions & _UA_CLEANUP_PHASE) {
+    // Phase 2 cleanup:
+    if (results.reason == _URC_HANDLER_FOUND) {
+      // Jump to the handler.
+      _Unwind_SetGR(context, REG_EXCP_OBJ, reinterpret_cast<uintptr_t>(unwind_exception));
+      _Unwind_SetIP(context, results.landingPad);
+      return _URC_INSTALL_CONTEXT;
+    }
+    // Did not find a handler. Return the results of the scan. Normally
+    // _URC_CONTINUE_UNWIND, but could have been _URC_FATAL_PHASE2_ERROR.
+    return results.reason;
+  }
+  // We were called improperly: neither a phase 1 or phase 2 search.
+  return _URC_FATAL_PHASE1_ERROR;
+}
+} // namespace __state_table_eh
+
+// The following are EH helper functions for xlclang++ compiled code.
+
+// __xlc_catch_matchv2
+// Check whether the thrown object matches the catch handler's exception
+// declaration. If there is a match, the function returns true with adjusted
+// address of the thrown object. Otherwise, returns false.
+bool __xlc_catch_matchv2(_Unwind_Exception* exceptionObject, std::type_info* catchTypeInfo, void*& obj) {
+  _LIBCXXABI_TRACE_STATETAB("Entering %s, exceptionObject=%p\n", __func__, reinterpret_cast<void*>(exceptionObject));
+
+  if (!__isOurExceptionClass(exceptionObject)) {
+    _LIBCXXABI_TRACE_STATETAB0("No match, not a C++ exception\n");
+    return false;
+  }
+
+  __cxa_exception* exceptionHeader = 0;
+
+  if (__getExceptionClass(exceptionObject) == kOurDependentExceptionClass) {
+    // Walk to the __cxa_dependent_exception primary exception for the
+    // exception object and its type_info.
+    __cxa_dependent_exception* dependentExceptionHeader =
+        reinterpret_cast<__cxa_dependent_exception*>(exceptionObject + 1) - 1;
+    exceptionHeader = reinterpret_cast<__cxa_exception*>(dependentExceptionHeader->primaryException) - 1;
+    _LIBCXXABI_TRACE_STATETAB("exceptionObject 0x%p is a dependent, primary 0x%p\n",
+                              reinterpret_cast<void*>(exceptionObject),
+                              reinterpret_cast<void*>(&exceptionHeader->unwindHeader));
+    exceptionObject = &exceptionHeader->unwindHeader;
+  } else {
+    _LIBCXXABI_TRACE_STATETAB("exceptionObject %p is NOT a dependent\n", reinterpret_cast<void*>(exceptionObject));
+    exceptionHeader = reinterpret_cast<__cxa_exception*>(exceptionObject + 1) - 1;
+  }
+
+  void* thrownObject = reinterpret_cast<void*>(exceptionObject + 1);
+  std::type_info* throwTypeInfo = exceptionHeader->exceptionType;
+
+  // Get the type info for the thrown type and this catch clause and
+  // see if the catch caluse can catch that type.
+
+  __cxxabiv1::__shim_type_info* catchType = reinterpret_cast<__cxxabiv1::__shim_type_info*>(catchTypeInfo);
+  __cxxabiv1::__shim_type_info* throwType = reinterpret_cast<__cxxabiv1::__shim_type_info*>(throwTypeInfo);
+  _LIBCXXABI_TRACE_STATETAB("UnwindException=%p, thrownObject=%p, throwTypeInfo=%p(%s), catchTypeInfo=%p(%s)\n",
+                            reinterpret_cast<void*>(exceptionObject), thrownObject, reinterpret_cast<void*>(throwType),
+                            throwType->name(), reinterpret_cast<void*>(catchType), catchType->name());
+  if (catchType->can_catch(throwType, thrownObject)) {
+    exceptionHeader->adjustedPtr = thrownObject;
+    obj = thrownObject;
+    _LIBCXXABI_TRACE_STATETAB("Match found for thrownObject=%p\n", thrownObject);
+    return true;
+  }
+  _LIBCXXABI_TRACE_STATETAB0("No match\n");
+  return false;
+}
+
+// __xlc_throw_badexception
+// This function is for xlclang++. It allocates and throws a bad_exception.
+// During unwinding for this bad_exception, the previous exception which is
+// not matching the throw spec will be cleaned up. Thus having the same
+// effect as replace the top most exception (which is bad) with a bad_exception.
+void __xlc_throw_badexception() {
+  _LIBCXXABI_TRACE_STATETAB("Entering function: %s\n\n", __func__);
+  void* newexception = new (__cxa_allocate_exception(sizeof(std::bad_exception))) std::bad_exception;
+  __cxa_throw(newexception, const_cast<std::type_info*>(&typeid(std::bad_exception)), 0);
+}
+
+// __xlc_exception_handle
+// This function is for xlclang++. It returns the address of the exception
+// object set in gpr14 by the personality routine for xlclang++ compiled code.
+uintptr_t __xlc_exception_handle() {
+  uintptr_t exceptionObject;
+  asm("mr %0, 14" : "=r"(exceptionObject));
+  return exceptionObject;
+}
+
+// xlclang++ may generate calls to __Deleted_Virtual.
+void __Deleted_Virtual() { abort(); }
+
+// __catchThrownException is called during AIX library initialization and
+// termination to handle exceptions.  An implementation is also provided in
+// libC.a(shrcore.o).  This implementation is provided for applications that
+// link with -lc++ (the xlclang++ or ibm-clang++ link default.)
+int __catchThrownException(void (*cdfunc)(void),   // function which may fail
+                           void (*cleanup)(void*), // cleanup function
+                           void* cleanuparg,       // parameter to cleanup function
+                           int action) {           // control exception throwing and termination
+  enum Action : int { None = 0, Rethrow = 1, Terminate = 2 };
+  if (!cdfunc)
+    return 0;
+  if (action == Action::Rethrow && !cleanup) {
+    // No cleanup and rethrow is effectively no-op.
+    // Avoid the catch handler when possible to allow exceptions generated
+    // from xlC binaries to flow through.
+    (*cdfunc)();
+    return 0;
+  }
+  try {
+    (*cdfunc)();
+  } catch (...) {
+    if (action == Action::Terminate)
+      std::terminate();
+    if (cleanup)
+      (*cleanup)(cleanuparg);
+    if (action == Action::Rethrow)
+      throw;
+    assert(action == Action::None);
+    return -1; // FAILED
+  }
+  return 0;
+}
+
+}  // extern "C"
+
+}  // __cxxabiv1

libcxxabi/src/cxa_personality.cpp

catch (...)
             }
         }
     }
     std::__terminate(t_handler);
 }
 
 #if defined(_AIX)
 // Personality routine for EH using the range table. Make it an alias of
 // __gxx_personality_v0().
 _LIBCXXABI_FUNC_VIS _Unwind_Reason_Code __xlcxx_personality_v1(
     int version, _Unwind_Action actions, uint64_t exceptionClass,
     _Unwind_Exception* unwind_exception, _Unwind_Context* context)
     __attribute__((__alias__("__gxx_personality_v0")));
 #endif
 
 }  // extern "C"
 
 }  // __cxxabiv1
+
+#if defined(_AIX)
+// Include implementation of the personality and helper functions for the
+// state table based EH used by IBM legacy compilers xlC and xlclang++ on AIX.
+#  include "aix_state_tab_eh.inc"
+#endif