[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

1769

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

1769

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

1253

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

1271

Isn't this on line 1248?

1282

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

1302

Suggestion: use flexible array member.

1313

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.

1317

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.

1323

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

1353

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

1407

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

[jasonliu]

libcxxabi/src/cxa_personality.cpp

1271

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

[hubert.reinterpretcast]

libcxxabi/src/cxa_personality.cpp

1781

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

1271

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

1282

Changed as suggested. Thanks!

1302

Use flexible array as suggested, thanks!

1313

Changed to use typed enum.

1317

Changed to use typed enum.

1323

Changed to use typed enum.

1353

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

1781

Good catch, thanks!

[cebowleratibm]

Early comments. Continuing to work through the review.

libcxxabi/src/cxa_personality.cpp

1251

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.

1282

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

1291

I suggest making this:

union {
  FSMEntryCount flag;
  intptr_t count;
}

which makes overlapping use of the memory more clear.

1293

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

[cebowleratibm]

Review in still on-going.

libcxxabi/src/cxa_personality.cpp

1313

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

1340

Suggest adding a comment.

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

1341

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.

1342

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.

1348

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

1404

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)

1512

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.

1517

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

1535

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

1550

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.

1557

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?

1560

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

1336

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.

1538

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.

1585

suggest "else if" -> "if"

1596

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.

1610

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.

1624

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

1630

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)

1643

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

1251

Added a high level description of the state table.

1282

Added namespace __state_table_eh.

1291

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;
};

1293

Good point, changed to use type FSMEntryFlag. Thanks!

1313

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.

1336

Changed the naming and added comments as suggested, thanks!

1340

Added the comment as suggested, thanks!

1341

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

1342

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

1348

Changed as suggested, thanks.

1404

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

1512

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

1517

Same as the comment above.

1535

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.

1538

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

1550

Added the comment as suggested, thanks!

1557

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.

1560

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

1585

Changed as suggested.

1596

Changed as suggested, thanks!

1610

Changes as suggested, thanks.

1624

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.

1630

Added a table above to describe the actions.

1643

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

1259

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

1339

"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.

1389

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

uintptr_t elementCount
```?

1669

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.

1738

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.

1741

typo "onditionalStateChange"

1773

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

1259

Changes as suggested, thanks!

1339

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

1389

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.

1669

Modified comments as suggested, thanks!

1738

Added the comment as suggested, thanks!

1741

Fixed, thanks for catching it!

1773

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

1302

1304

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

1329

Prefer using to typedef

1362

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

1412

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

1415

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

Pick a snake_case function name.

1416

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

1436

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

1440

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

1454

1461

The coding standard prefers pre-increment ++p.

ditto below

1472

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

1481

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

1526

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.

1528

1830

Delete the comment since the _LIBCXXABI_TRACE_STATETAB self explains.

1891

delete blank line

[MaskRay]

libcxxabi/src/cxa_personality.cpp

1896

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

[MaskRay]

libcxxabi/src/cxa_personality.cpp

1440

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

[hubert.reinterpretcast]

libcxxabi/src/cxa_personality.cpp

1440

@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

1302

Changed as suggested, thanks!

1304

Added static and changed function name to state_tab_dbg. Thanks!

1329

Changed to use using, thanks!

1362

Used anonymous namespace for 3 local structures, thanks!

1412

Changed to use constexpr and renamed gRegisterNum to REG_EXCP_OBJ.

1415

Renamed __Invoke__Destructor and __Invoke__Delete to invoke_destructor and invoke_delete respectively.

1416

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]

1436

Fixed this and other occurrences, thanks!

1454

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.

1461

Fixed this and other occurrences, thanks for pointing out!

1472

Fixed, thanks!

1481

Fixed, thanks!

1526

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.

1528

Fixed, thanks!

1830

Done, thanks!

1891

Done.

1896

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

63 ↗

(On Diff #429322)

66 ↗

(On Diff #429322)

70 ↗

(On Diff #429322)

#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

63 ↗

(On Diff #429322)

Fixed, thanks!

66 ↗

(On Diff #429322)

Fixed, thanks!

70 ↗

(On Diff #429322)

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/cxa_personality.cpp

readSLEB128(const uint8_t** data)
     return static_cast<intptr_t>(result);
 }
 
 /// Read a pointer encoded value and advance pointer
 /// See Variable Length Data in:
 /// @link http://dwarfstd.org/Dwarf3.pdf @unlink
 /// @param data reference variable holding memory pointer to decode from
 /// @param encoding dwarf encoding type
+/// @param base for adding relative offset, default to 0
 /// @returns decoded value
-static
-uintptr_t
-readEncodedPointer(const uint8_t** data, uint8_t encoding)
-{
-    uintptr_t result = 0;
-    if (encoding == DW_EH_PE_omit)
-        return result;
-    const uint8_t* p = *data;
-    // first get value
-    switch (encoding & 0x0F)
-    {
-    case DW_EH_PE_absptr:
-        result = readPointerHelper<uintptr_t>(p);
-        break;
-    case DW_EH_PE_uleb128:
-        result = readULEB128(&p);
-        break;
-    case DW_EH_PE_sleb128:
-        result = static_cast<uintptr_t>(readSLEB128(&p));
-        break;
-    case DW_EH_PE_udata2:
-        result = readPointerHelper<uint16_t>(p);
-        break;
-    case DW_EH_PE_udata4:
-        result = readPointerHelper<uint32_t>(p);
-        break;
-    case DW_EH_PE_udata8:
-        result = readPointerHelper<uint64_t>(p);
-        break;
-    case DW_EH_PE_sdata2:
-        result = readPointerHelper<int16_t>(p);
-        break;
-    case DW_EH_PE_sdata4:
-        result = readPointerHelper<int32_t>(p);
-        break;
-    case DW_EH_PE_sdata8:
-        result = readPointerHelper<int64_t>(p);
-        break;
-    default:
-        // not supported
-        abort();
-        break;
-    }
-    // then add relative offset
-    switch (encoding & 0x70)
-    {
-    case DW_EH_PE_absptr:
-        // do nothing
-        break;
-    case DW_EH_PE_pcrel:
-        if (result)
-            result += (uintptr_t)(*data);
-        break;
-    case DW_EH_PE_textrel:
-    case DW_EH_PE_datarel:
-    case DW_EH_PE_funcrel:
-    case DW_EH_PE_aligned:
-    default:
-        // not supported
-        abort();
-        break;
-    }
-    // then apply indirection
-    if (result && (encoding & DW_EH_PE_indirect))
-        result = *((uintptr_t*)result);
-    *data = p;
-    return result;
+static uintptr_t readEncodedPointer(const uint8_t** data, uint8_t encoding,
+                                    uintptr_t base = 0) {
+  switch (encoding & 0x0F) {
+  switch (encoding & 0x70) {
+    assert((base != 0) && "DW_EH_PE_datarel is invalid with a base of 0");
+    if (result)
+      result += base;
+    break;
+  case DW_EH_PE_textrel:
 }
 
 static
 void
 call_terminate(bool native_exception, _Unwind_Exception* unwind_exception)
 {
     __cxa_begin_catch(unwind_exception);
     if (native_exception)
assert(((ttypeEncoding == DW_EH_PE_absptr) ||  // LLVM or GCC 4.6
            "Unexpected TTypeEncoding");
     (void)ttypeEncoding;
 
     const uint8_t* ttypePtr = classInfo - ttypeIndex * sizeof(uintptr_t);
     return reinterpret_cast<const __shim_type_info *>(
         read_target2_value(ttypePtr));
 }
 #else // !defined(_LIBCXXABI_ARM_EHABI)
-static
-const __shim_type_info*
+static const __shim_type_info*
 get_shim_type_info(uint64_t ttypeIndex, const uint8_t* classInfo,
                    uint8_t ttypeEncoding, bool native_exception,
-                   _Unwind_Exception* unwind_exception)
-{
-    if (classInfo == 0)
-    {
-        // this should not happen.  Indicates corrupted eh_table.
-        call_terminate(native_exception, unwind_exception);
-    }
-    switch (ttypeEncoding & 0x0F)
-    {
-    case DW_EH_PE_absptr:
-        ttypeIndex *= sizeof(void*);
-        break;
-    case DW_EH_PE_udata2:
-    case DW_EH_PE_sdata2:
-        ttypeIndex *= 2;
-        break;
-    case DW_EH_PE_udata4:
-    case DW_EH_PE_sdata4:
-        ttypeIndex *= 4;
-        break;
-    case DW_EH_PE_udata8:
-    case DW_EH_PE_sdata8:
-        ttypeIndex *= 8;
-        break;
-    default:
-        // this should not happen.   Indicates corrupted eh_table.
-        call_terminate(native_exception, unwind_exception);
-    }
-    classInfo -= ttypeIndex;
-    return (const __shim_type_info*)readEncodedPointer(&classInfo, ttypeEncoding);
+                   _Unwind_Exception* unwind_exception, uintptr_t base = 0) {
+  if (classInfo == 0) {
+  switch (ttypeEncoding & 0x0F) {
+  return (const __shim_type_info*)readEncodedPointer(&classInfo, ttypeEncoding,
+                                                     base);
 }
 #endif // !defined(_LIBCXXABI_ARM_EHABI)
 
 /*
     This is checking a thrown exception type, excpType, against a possibly empty
     list of catchType's which make up an exception spec.
 
     An exception spec acts like a catch handler, but in reverse.  This "catch
while (true)
             static_cast<const __shim_type_info*>(read_target2_value(ttypePtr));
         void* tempPtr = adjustedPtr;
         if (catchType->can_catch(excpType, tempPtr))
             return false;
     }
     return true;
 }
 #else
-static
-bool
-exception_spec_can_catch(int64_t specIndex, const uint8_t* classInfo,
-                         uint8_t ttypeEncoding, const __shim_type_info* excpType,
-                         void* adjustedPtr, _Unwind_Exception* unwind_exception)
-{
-    if (classInfo == 0)
-    {
-        // this should not happen.   Indicates corrupted eh_table.
-        call_terminate(false, unwind_exception);
-    }
-    // specIndex is negative of 1-based byte offset into classInfo;
-    specIndex = -specIndex;
-    --specIndex;
-    const uint8_t* temp = classInfo + specIndex;
-    // If any type in the spec list can catch excpType, return false, else return true
-    //    adjustments to adjustedPtr are ignored.
-    while (true)
-    {
-        uint64_t ttypeIndex = readULEB128(&temp);
-        if (ttypeIndex == 0)
-            break;
-        const __shim_type_info* catchType = get_shim_type_info(ttypeIndex,
-                                                               classInfo,
-                                                               ttypeEncoding,
-                                                               true,
-                                                               unwind_exception);
-        void* tempPtr = adjustedPtr;
-        if (catchType->can_catch(excpType, tempPtr))
-            return false;
-    }
-    return true;
+static bool exception_spec_can_catch(
+    int64_t specIndex, const uint8_t* classInfo, uint8_t ttypeEncoding,
+    const __shim_type_info* excpType, void* adjustedPtr,
+    _Unwind_Exception* unwind_exception, uintptr_t base = 0) {
+  if (classInfo == 0) {
+  while (true) {
+    const __shim_type_info* catchType = get_shim_type_info(
+        ttypeIndex, classInfo, ttypeEncoding, true, unwind_exception, base);
 }
 #endif
 
 static
 void*
 get_thrown_object_ptr(_Unwind_Exception* unwind_exception)
 {
     // Even for foreign exceptions, the exception object is *probably* at unwind_exception + 1

 
 static
 void
 set_registers(_Unwind_Exception* unwind_exception, _Unwind_Context* context,
               const scan_results& results)
 {
 #if defined(__USING_SJLJ_EXCEPTIONS__)
 #define __builtin_eh_return_data_regno(regno) regno
+#elif defined(__ibmxl__)
+// IBM xlclang++ compiler does not support __builtin_eh_return_data_regno.
+#define __builtin_eh_return_data_regno(regno) regno + 3
 #endif
   _Unwind_SetGR(context, __builtin_eh_return_data_regno(0),
                 reinterpret_cast<uintptr_t>(unwind_exception));
   _Unwind_SetGR(context, __builtin_eh_return_data_regno(1),
                 static_cast<uintptr_t>(results.ttypeIndex));
   _Unwind_SetIP(context, results.landingPad);
 }
 
static void scan_eh_tab(scan_results &results, _Unwind_Action actions,
     const uint8_t *lsda = (const uint8_t *)_Unwind_GetLanguageSpecificData(context);
     if (lsda == 0)
     {
         // There is no exception table
         results.reason = _URC_CONTINUE_UNWIND;
         return;
     }
     results.languageSpecificData = lsda;
+#if defined(_AIX)
+    uintptr_t base = _Unwind_GetDataRelBase(context);
+#else
+    uintptr_t base = 0;
+#endif
     // Get the current instruction pointer and offset it before next
     // instruction in the current frame which threw the exception.
     uintptr_t ip = _Unwind_GetIP(context) - 1;
     // Get beginning current frame's code (as defined by the
     // emitted dwarf code)
     uintptr_t funcStart = _Unwind_GetRegionStart(context);
 #ifdef __USING_SJLJ_EXCEPTIONS__
     if (ip == uintptr_t(-1))
#endif  // __USING_SJLJ_EXCEPTIONS__
             while (true)
             {
                 const uint8_t* actionRecord = action;
                 int64_t ttypeIndex = readSLEB128(&action);
                 if (ttypeIndex > 0)
                 {
                     // Found a catch, does it actually catch?
                     // First check for catch (...)
-                    const __shim_type_info* catchType =
-                        get_shim_type_info(static_cast<uint64_t>(ttypeIndex),
-                                           classInfo, ttypeEncoding,
-                                           native_exception, unwind_exception);
+                    const __shim_type_info* catchType = get_shim_type_info(
+                        static_cast<uint64_t>(ttypeIndex), classInfo,
+                        ttypeEncoding, native_exception, unwind_exception,
+                        base);
                     if (catchType == 0)
                     {
                         // Found catch (...) catches everything, including
                         // foreign exceptions. This is search phase, cleanup
                         // phase with foreign exception, or forced unwinding.
                         assert(actions & (_UA_SEARCH_PHASE | _UA_HANDLER_FRAME |
                                           _UA_FORCE_UNWIND));
                         results.ttypeIndex = ttypeIndex;
#endif  // __USING_SJLJ_EXCEPTIONS__
                         void* adjustedPtr = get_thrown_object_ptr(unwind_exception);
                         const __shim_type_info* excpType =
                             static_cast<const __shim_type_info*>(exception_header->exceptionType);
                         if (adjustedPtr == 0 || excpType == 0)
                         {
                             // Something very bad happened
                             call_terminate(native_exception, unwind_exception);
                         }
-                        if (exception_spec_can_catch(ttypeIndex, classInfo,
-                                                     ttypeEncoding, excpType,
-                                                     adjustedPtr, unwind_exception))
-                        {
-                            // Native exception caught by exception
-                            // specification.
-                            assert(actions & _UA_SEARCH_PHASE);
-                            results.ttypeIndex = ttypeIndex;
-                            results.actionRecord = actionRecord;
-                            results.adjustedPtr = adjustedPtr;
-                            results.reason = _URC_HANDLER_FOUND;
-                            return;
+                        if (exception_spec_can_catch(
+                                ttypeIndex, classInfo, ttypeEncoding, excpType,
+                                adjustedPtr, unwind_exception, base)) {
                         }
                     } else {
                         // foreign exception caught by exception spec
                         results.ttypeIndex = ttypeIndex;
                         results.actionRecord = actionRecord;
                         results.adjustedPtr =
                             get_thrown_object_ptr(unwind_exception);
                         results.reason = _URC_HANDLER_FOUND;
if (actions == (_UA_CLEANUP_PHASE | _UA_HANDLER_FRAME) &&
         results.actionRecord = exception_header->actionRecord;
         results.languageSpecificData = exception_header->languageSpecificData;
         results.landingPad =
             reinterpret_cast<uintptr_t>(exception_header->catchTemp);
         results.adjustedPtr = exception_header->adjustedPtr;
 
         // Jump to the handler.
         set_registers(unwind_exception, context, results);
+#if defined(_AIX)
+        // Cache ttype base for __cxa_call_unexpected.
+        if (results.ttypeIndex < 0) {
+          exception_header->catchTemp = (void*)_Unwind_GetDataRelBase(context);
+        }
+#endif
         return _URC_INSTALL_CONTEXT;
     }
 
     // In other cases we need to scan LSDA.
     scan_eh_tab(results, actions, native_exception, unwind_exception, context);
     if (results.reason == _URC_CONTINUE_UNWIND ||
         results.reason == _URC_FATAL_PHASE1_ERROR)
         return results.reason;
if (actions & _UA_SEARCH_PHASE)
             exc->adjustedPtr = results.adjustedPtr;
         }
         return _URC_HANDLER_FOUND;
     }
 
     assert(actions & _UA_CLEANUP_PHASE);
     assert(results.reason == _URC_HANDLER_FOUND);
     set_registers(unwind_exception, context, results);
+#if defined(_AIX)
+    // Cache ttype base for __cxa_call_unexpected.
+    if (results.ttypeIndex < 0) {
+      __cxa_exception* exception_header =
+          (__cxa_exception*)(unwind_exception + 1) - 1;
+      exception_header->catchTemp = (void*)_Unwind_GetDataRelBase(context);
+    }
+#endif
     return _URC_INSTALL_CONTEXT;
 }
 
 #if defined(__SEH__) && !defined(__USING_SJLJ_EXCEPTIONS__)
 extern "C" _LIBCXXABI_FUNC_VIS EXCEPTION_DISPOSITION
 __gxx_personality_seh0(PEXCEPTION_RECORD ms_exc, void *this_frame,
                        PCONTEXT ms_orig_context, PDISPATCHER_CONTEXT ms_disp)
 {
if (unwind_exception == 0)
         call_terminate(false, unwind_exception);
     __cxa_begin_catch(unwind_exception);
     bool native_old_exception = __isOurExceptionClass(unwind_exception);
     std::unexpected_handler u_handler;
     std::terminate_handler t_handler;
     __cxa_exception* old_exception_header = 0;
     int64_t ttypeIndex;
     const uint8_t* lsda;
+    uintptr_t base = 0;
+
     if (native_old_exception)
     {
         old_exception_header = (__cxa_exception*)(unwind_exception+1) - 1;
         t_handler = old_exception_header->terminateHandler;
         u_handler = old_exception_header->unexpectedHandler;
         // If std::__unexpected(u_handler) rethrows the same exception,
         //   these values get overwritten by the rethrow.  So save them now:
 #if defined(_LIBCXXABI_ARM_EHABI)
         ttypeIndex = (int64_t)(int32_t)unwind_exception->barrier_cache.bitpattern[4];
         lsda = (const uint8_t*)unwind_exception->barrier_cache.bitpattern[2];
 #else
         ttypeIndex = old_exception_header->handlerSwitchValue;
         lsda = old_exception_header->languageSpecificData;
+        base = (uintptr_t)old_exception_header->catchTemp;
 #endif
     }
     else
     {
         t_handler = std::get_terminate();
         u_handler = std::get_unexpected();
     }
     try
     {
         std::__unexpected(u_handler);
     }
     catch (...)
     {
         // If the old exception is foreign, then all we can do is terminate.
         //   We have no way to recover the needed old exception spec.  There's
         //   no way to pass that information here.  And the personality routine
         //   can't call us directly and do anything but terminate() if we throw
         //   from here.
         if (native_old_exception)
         {
-            // Have:
-            //   old_exception_header->languageSpecificData
-            //   old_exception_header->actionRecord
-            // Need
-            //   const uint8_t* classInfo
-            //   uint8_t ttypeEncoding
-            uint8_t lpStartEncoding = *lsda++;
-            const uint8_t* lpStart = (const uint8_t*)readEncodedPointer(&lsda, lpStartEncoding);
-            (void)lpStart;  // purposefully unused.  Just needed to increment lsda.
-            uint8_t ttypeEncoding = *lsda++;
-            if (ttypeEncoding == DW_EH_PE_omit)
-                std::__terminate(t_handler);
-            uintptr_t classInfoOffset = readULEB128(&lsda);
-            const uint8_t* classInfo = lsda + classInfoOffset;
-            // Is this new exception catchable by the exception spec at ttypeIndex?
-            // The answer is obviously yes if the new and old exceptions are the same exception
-            // If no
-            //    throw;
-            __cxa_eh_globals* globals = __cxa_get_globals_fast();
-            __cxa_exception* new_exception_header = globals->caughtExceptions;
-            if (new_exception_header == 0)
-                // This shouldn't be able to happen!
-                std::__terminate(t_handler);
-            bool native_new_exception = __isOurExceptionClass(&new_exception_header->unwindHeader);
-            void* adjustedPtr;
-            if (native_new_exception && (new_exception_header != old_exception_header))
-            {
-                const __shim_type_info* excpType =
-                    static_cast<const __shim_type_info*>(new_exception_header->exceptionType);
-                adjustedPtr =
-                    __getExceptionClass(&new_exception_header->unwindHeader) == kOurDependentExceptionClass ?
-                        ((__cxa_dependent_exception*)new_exception_header)->primaryException :
-                        new_exception_header + 1;
-                if (!exception_spec_can_catch(ttypeIndex, classInfo, ttypeEncoding,
-                                              excpType, adjustedPtr, unwind_exception))
-                {
-                    // We need to __cxa_end_catch, but for the old exception,
-                    //   not the new one.  This is a little tricky ...
-                    // Disguise new_exception_header as a rethrown exception, but
-                    //   don't actually rethrow it.  This means you can temporarily
-                    //   end the catch clause enclosing new_exception_header without
-                    //   __cxa_end_catch destroying new_exception_header.
-                    new_exception_header->handlerCount = -new_exception_header->handlerCount;
-                    globals->uncaughtExceptions += 1;
-                    // Call __cxa_end_catch for new_exception_header
-                    __cxa_end_catch();
-                    // Call __cxa_end_catch for old_exception_header
-                    __cxa_end_catch();
-                    // Renter this catch clause with new_exception_header
-                    __cxa_begin_catch(&new_exception_header->unwindHeader);
-                    // Rethrow new_exception_header
-                    throw;
-                }
-            }
+          //   old_exception_header->catchTemp, i.e., ttype_base
+          const uint8_t* lpStart =
+              (const uint8_t*)readEncodedPointer(&lsda, lpStartEncoding);
+          (void)lpStart; // purposefully unused.  Just needed to increment lsda.
+          bool native_new_exception =
+              __isOurExceptionClass(&new_exception_header->unwindHeader);
+          if (native_new_exception &&
+              (new_exception_header != old_exception_header)) {
+                static_cast<const __shim_type_info*>(
+                    new_exception_header->exceptionType);
+                __getExceptionClass(&new_exception_header->unwindHeader) ==
+                        kOurDependentExceptionClass
+                    ? ((__cxa_dependent_exception*)new_exception_header)
+                          ->primaryException
+                    : new_exception_header + 1;
+                                          excpType, adjustedPtr,
+                                          unwind_exception, base)) {
+              new_exception_header->handlerCount =
+                  -new_exception_header->handlerCount;
             // Will a std::bad_exception be catchable by the exception spec at
             //   ttypeIndex?
             // If no
             //    throw std::bad_exception();
             const __shim_type_info* excpType =
                 static_cast<const __shim_type_info*>(&typeid(std::bad_exception));
             std::bad_exception be;
             adjustedPtr = &be;
             if (!exception_spec_can_catch(ttypeIndex, classInfo, ttypeEncoding,
-                                          excpType, adjustedPtr, unwind_exception))
-            {
-                // We need to __cxa_end_catch for both the old exception and the
-                //   new exception.  Technically we should do it in that order.
-                //   But it is expedient to do it in the opposite order:
-                // Call __cxa_end_catch for new_exception_header
-                __cxa_end_catch();
-                // Throw std::bad_exception will __cxa_end_catch for
-                //   old_exception_header
-                throw be;
+                                          excpType, adjustedPtr,
+                                          unwind_exception, base)) {
             }
         }
     }
     std::__terminate(t_handler);
 }
 
+#if defined(_AIX)
+// Macros for debugging state table parsing.
+#ifdef NDEBUG
+#define _LIBCXXABI_TRACE_STATETAB(_args...)
+#define _LIBCXXABI_TRACE_STATETAB0(_args...)
+#define _LIBCXXABI_TRACING_STATETAB (0)
+#else
+bool StateTabDbg() {
+  static bool checked = false;
+  static bool log = false;
+  if (!checked) {
+    log = (getenv("LIBCXXABI_PRINT_STATTAB") != NULL);
+    checked = true;
+  }
+  return log;
+}
+
+#define _LIBCXXABI_TRACE_STATETAB(_args...)                                    \
+  do {                                                                         \
+    if (StateTabDbg())                                                         \
+      fprintf(stderr, "libcxxabi: " _args);                                    \
+  } while (0)
+#define _LIBCXXABI_TRACE_STATETAB0(_args...)                                   \
+  do {                                                                         \
+    if (StateTabDbg())                                                         \
+      fprintf(stderr, _args);                                                  \
+  } while (0)
+#define _LIBCXXABI_TRACING_STATETAB StateTabDbg()
+#endif
+
+typedef void (*destruct_f)(void*);
+
+// The finite state machine to be walked.
+struct FSM_Entry {
+  long offset;
+  union {
+    void (*destructor)(void*, size_t);
+    void* catch_block;
+  };
+  long count;
+  size_t elem_size;
+  unsigned short flags;
+  unsigned short next_state;
+};
+
+struct FSM {
+  unsigned int magic;
+  int number_of_states;
+  FSM_Entry table[1]; // Actually table[number_of_states]
+};
+
+// The state variable on the stack
+struct StateVariable {
+  int state;
+  struct FSM* table;
+  long this_value;
+  int ignore_vbase_ptrs;
+};
+
+#define FSM_MAGIC 0xbeefdead
+#define FSM_MAGIC2 0xbeeedead
+#define FSM_MAGIC3 0x1cedbeef
+
+#define BEGIN_CATCH_COUNT -1
+#define END_CATCH_COUNT -2
+#define DELETE_OBJECT_COUNT -3
+#define INLINE_DESTRUCTOR_COUNT -4
+#define TERMINATE_COUNT -5
+
+#define STATE_CHANGE_OLD                                                       \
+  0x400 // State table entry is an indirect state                              \
+        // change, dereference the address in                                  \
+        // offset as int for the target state.                                 \
+        // This is deplicated. This indicate                                   \
+        // the address is direct. (static local)
+#define STATE_CHANGE                                                           \
+  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.
+
+#define THIS_FLAG 0x01
+#define VBASE_FLAG 0x02
+#define GLOBAL_OBJ 0x04
+
+#define INDIRECT                                                               \
+  0x100                  // Object was thrown from a function                  \
+                         // where the return value optimization                \
+                         // was used.
+#define DTR_ARGUMENT 0x2 // Free virtual bases, don't delete object
+
+static void __Invoke__Destructor(FSM_Entry* fsmEntry, void* addr) {
+  _LIBCXXABI_TRACE_STATETAB("Deallocate object=%p, fsmEntry=%p\n", addr,
+                            (void*)fsmEntry);
+  try {
+    if (fsmEntry->count == 1) {
+      _LIBCXXABI_TRACE_STATETAB("calling scaler destructor\n");
+      (*fsmEntry->destructor)(addr, DTR_ARGUMENT);
+      _LIBCXXABI_TRACE_STATETAB("returned from scaler destructor\n");
+    } else {
+      _LIBCXXABI_TRACE_STATETAB("calling vector destructor\n");
+      __cxa_vec_cleanup(addr, (size_t)fsmEntry->count, fsmEntry->elem_size,
+                        (destruct_f)fsmEntry->destructor);
+      _LIBCXXABI_TRACE_STATETAB("returned from vector destructor\n");
+    }
+  } catch (...) {
+    _LIBCXXABI_TRACE_STATETAB("Uncaught exception in destructor, "
+                              "terminating\n");
+    std::terminate();
+  }
+}
+
+static void __Invoke__Delete(FSM_Entry* fsmEntry, void* addr) {
+  char* objectAddress = *(char**)addr;
+
+  _LIBCXXABI_TRACE_STATETAB("Delete object=%p, fsmEntry=%p\n",
+                            (void*)objectAddress, (void*)fsmEntry);
+  try {
+    _LIBCXXABI_TRACE_STATETAB("..calling delete()\n");
+    // 'destructor' holds a function pointer to delete().
+    (*fsmEntry->destructor)(objectAddress, fsmEntry->elem_size);
+    _LIBCXXABI_TRACE_STATETAB("..returned from delete()\n");
+  } catch (...) {
+    _LIBCXXABI_TRACE_STATETAB("Uncaught exception in delete(), "
+                              "terminating\n");
+    std::terminate();
+  }
+}
+
+// __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, return false.
+extern "C" bool __xlc_catch_matchv2(_Unwind_Exception* exceptionObject,
+                                    std::type_info* catch_ti, void*& obj) {
+  _LIBCXXABI_TRACE_STATETAB("Entering %s, exceptionObject=%p\n", __func__,
+                            (void*)exceptionObject);
+
+  if (!__isOurExceptionClass(exceptionObject)) {
+    // If it is not a c++ exception, return 0 to indicate no match
+    _LIBCXXABI_TRACE_STATETAB("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 =
+        (__cxa_dependent_exception*)(exceptionObject + 1) - 1;
+    exceptionHeader = static_cast<__cxa_exception*>(
+                          dependentExceptionHeader->primaryException) -
+                      1;
+    _LIBCXXABI_TRACE_STATETAB("exceptionObject 0x%p is a dependent, "
+                              "primary 0x%p\n",
+                              (void*)exceptionObject,
+                              (void*)&exceptionHeader->unwindHeader);
+    exceptionObject = &exceptionHeader->unwindHeader;
+  } else {
+    _LIBCXXABI_TRACE_STATETAB("exceptionObject %p is NOT a dependent\n",
+                              (void*)exceptionObject);
+    exceptionHeader = ((__cxa_exception*)(exceptionObject + 1) - 1);
+  }
+
+  void* thrownObject = (void*)(exceptionObject + 1);
+  std::type_info* throw_ti = 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 =
+      static_cast<__cxxabiv1::__shim_type_info*>(catch_ti);
+  __cxxabiv1::__shim_type_info* throwType =
+      static_cast<__cxxabiv1::__shim_type_info*>(throw_ti);
+  _LIBCXXABI_TRACE_STATETAB("UnwindException=%p thrownObject=%p "
+                            "t-ti=%p(%s) c-ti=%p(%s)\n",
+                            (void*)exceptionObject, thrownObject,
+                            (void*)throwType, throwType->name(),
+                            (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_STATETAB("No match\n");
+  return false;
+}
+
+const uint32_t gRegisterNum = 14; // The GPR to pass the exception object
+                                  // address for xlclang++ compiled code.
+
+// Calculate the object address from the FSM entry
+static void* compute_obj_addr(FSM_Entry* fsmEntry, StateVariable* const state) {
+  void* addr;
+  if (fsmEntry->flags & GLOBAL_OBJ) {
+    addr = (void*)fsmEntry->offset;
+    _LIBCXXABI_TRACE_STATETAB("Address calculation (global obj) "
+                              "addr=currEntry->offset=%p\n",
+                              addr);
+  } else if (fsmEntry->flags & THIS_FLAG) {
+    addr = (void*)(fsmEntry->offset + state->this_value);
+    _LIBCXXABI_TRACE_STATETAB("Address calculation (this obj) "
+                              "currEntry->offset=%ld : "
+                              "state->this_value=%ld addr="
+                              "(currEntry-->offset+state->this_value)=%p\n",
+                              fsmEntry->offset, state->this_value, addr);
+  } else if (fsmEntry->flags & INDIRECT) {
+    addr = (void*)*(char**)(fsmEntry->offset);
+    _LIBCXXABI_TRACE_STATETAB("Address calculation (indirect obj) "
+                              "addr=%p, fsmEntry->offset=%ld \n",
+                              addr, fsmEntry->offset);
+  } else {
+    addr = (void*)(fsmEntry->offset);
+    _LIBCXXABI_TRACE_STATETAB("Address calculation. (local obj) "
+                              "addr=currEntry->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_STATETAB0("\n");
+    _LIBCXXABI_TRACE_STATETAB("%s: actions=%d (", __func__, actions);
+
+    if (_UA_SEARCH_PHASE & actions)
+      _LIBCXXABI_TRACE_STATETAB0("_UA_SEARCH_PHASE ");
+    if (_UA_CLEANUP_PHASE & actions)
+      _LIBCXXABI_TRACE_STATETAB0("_UA_CLEANUP_PHASE ");
+    if (_UA_HANDLER_FRAME & actions)
+      _LIBCXXABI_TRACE_STATETAB0("_UA_HANDLER_FRAME ");
+    if (_UA_FORCE_UNWIND & actions)
+      _LIBCXXABI_TRACE_STATETAB0("_UA_FORCE_UNWIND ");
+    _LIBCXXABI_TRACE_STATETAB0(")\n");
+    _LIBCXXABI_TRACE_STATETAB("       unwind_exception=%p context=%p\n",
+                              (void*)unwind_exception, (void*)context);
+  }
+
+  // Start scan by getting state table address
+  StateVariable* const state =
+      (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;
+
+  _LIBCXXABI_TRACE_STATETAB("state->state=%d, state->ignore_vbase_ptrs=%d\n",
+                            state->state, state->ignore_vbase_ptrs);
+
+  // The magic number is FSM_MAGIC3 for xlclang++.
+  _LIBCXXABI_TRACE_STATETAB("fsm->magic=%#x, fsm->number_of_states=%d\n",
+                            fsm->magic, fsm->number_of_states);
+
+  if (fsm->magic == FSM_MAGIC || fsm->magic == FSM_MAGIC2 ||
+      fsm->magic == FSM_MAGIC3) {
+    // Debug display of the FSM table.
+    if (_LIBCXXABI_TRACING_STATETAB) {
+      // Print out the FSM table.
+      _LIBCXXABI_TRACE_STATETAB("FSM table:\n");
+      _LIBCXXABI_TRACE_STATETAB("%12s %10s %8s  %10s %7s %7s %7s %7s\n",
+                                "Entry Addr", "state", "Offset", "DTR addr",
+                                "count", "el_size", "flags", "next");
+      for (int i = 0; i < fsm->number_of_states; i++) {
+        FSM_Entry& f = fsm->table[i];
+        _LIBCXXABI_TRACE_STATETAB("%12p (%8d) %8ld  %10p %7ld "
+                                  "%7ld %#7x %7d\n",
+                                  (void*)&f, i + 1, f.offset,
+                                  (void*)f.destructor, f.count, f.elem_size,
+                                  f.flags, f.next_state);
+      }
+    }
+  } else {
+    // Something is wrong the the state table we found.
+    if (_UA_SEARCH_PHASE & actions) {
+      _LIBCXXABI_TRACE_STATETAB("Invalid FSM table, "
+                                "return _URC_FATAL_PHASE1_ERROR\n");
+      results.reason = _URC_FATAL_PHASE1_ERROR;
+      return;
+    } else if (_UA_CLEANUP_PHASE & actions) {
+      _LIBCXXABI_TRACE_STATETAB("Invalid FSM table, "
+                                "return _URC_FATAL_PHASE2_ERROR\n");
+      results.reason = _URC_FATAL_PHASE2_ERROR;
+      return;
+    } else {
+      // We should never get here.
+      _LIBCXXABI_TRACE_STATETAB("Invalid FSM table + RT Internal error,"
+                                " return _URC_FATAL_PHASE2_ERROR\n");
+      results.reason = _URC_FATAL_PHASE2_ERROR;
+      return;
+    }
+  }
+
+  if (_UA_SEARCH_PHASE & actions) {
+    // Start walking the 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) {
+      FSM_Entry* currEntry = &fsm->table[currState - 1];
+      _LIBCXXABI_TRACE_STATETAB("Processing state=%d, flags=0x%hx\n", currState,
+                                currEntry->flags);
+
+      void* addr = compute_obj_addr(currEntry, state);
+
+      if (currEntry->count == BEGIN_CATCH_COUNT) {
+        // Found a catch handler.
+        _LIBCXXABI_TRACE_STATETAB("Found a catch handler, "
+                                  "return _URC_HANDLER_FOUND\n");
+        results.reason = _URC_HANDLER_FOUND;
+        return;
+      } else if (currEntry->count == TERMINATE_COUNT) {
+        _LIBCXXABI_TRACE_STATETAB("Found the terminate state, "
+                                  "return _URC_HANDLER_FOUND\n");
+        results.reason = _URC_HANDLER_FOUND;
+        return;
+      } else if (currEntry->flags & STATE_CHANGE_OLD) {
+        // Deplicated conditional expression.
+        currState = *((int*)(currEntry->offset));
+        _LIBCXXABI_TRACE_STATETAB("Flag: STATE_CHANGE_OLD, dereference "
+                                  "currEntry->offset(%ld), set state=%d\n",
+                                  currEntry->offset, currState);
+        continue; // We are done this iteration of the loop, since
+                  // we changed a state.
+      } else if (currEntry->flags & STATE_CHANGE) {
+        state->state = *((int*)(addr));
+        _LIBCXXABI_TRACE_STATETAB("Flag: STATE_CHANGE, dereference "
+                                  "addr(%p), set state=%d\n",
+                                  addr, state->state);
+        continue; // We are done this iteration of the loop, since we
+                  // changed the state.
+      }
+
+      // Go to the next state.
+      currState = currEntry->next_state;
+    }
+    _LIBCXXABI_TRACE_STATETAB("No catch handler found, "
+                              "return _URC_CONTINUE_UNWIND\n");
+    results.reason = _URC_CONTINUE_UNWIND;
+    return;
+  } else if (_UA_CLEANUP_PHASE & actions) {
+    // Start walking the table.
+    while (state->state > 0) {
+      FSM_Entry* currEntry = &fsm->table[state->state - 1];
+
+      if (currEntry->count == TERMINATE_COUNT) {
+        _LIBCXXABI_TRACE_STATETAB("Reached terminate state. "
+                                  "Call terminate.\n");
+        std::terminate();
+      }
+
+      void* addr = compute_obj_addr(currEntry, state);
+
+      // Perform action according to the currEntry->count,
+      // except when flag is STATE_CHANGE or STATE_CHANGE_OLD.
+      _LIBCXXABI_TRACE_STATETAB("Processing state=%d, flags=0x%hx\n",
+                                state->state, currEntry->flags);
+      if (currEntry->flags & STATE_CHANGE_OLD) {
+        state->state = *((int*)(currEntry->offset));
+        _LIBCXXABI_TRACE_STATETAB("Flag: STATE_CHANGE_OLD, dereference "
+                                  "currEntry->offset(%ld), set state=%d\n",
+                                  currEntry->offset, state->state);
+        continue; // We are done with this iteration of the loop, since
+                  // we changed a state.
+      } else if (currEntry->flags & STATE_CHANGE) {
+        state->state = *((int*)(addr));
+        _LIBCXXABI_TRACE_STATETAB("Flag: STATE_CHANGE, 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.
+      } else if (currEntry->count > 0) {
+        if (currEntry->flags & VBASE_FLAG && state->ignore_vbase_ptrs) {
+          _LIBCXXABI_TRACE_STATETAB("Ignoring virtual base dtor.\n");
+        } else {
+          _LIBCXXABI_TRACE_STATETAB("Invoke dtor for object=%p\n", addr);
+          __Invoke__Destructor(currEntry, addr);
+        }
+      } else if (currEntry->count == DELETE_OBJECT_COUNT) {
+        _LIBCXXABI_TRACE_STATETAB("Delete object at %p\n", addr);
+        __Invoke__Delete(currEntry, addr);
+      } else if (currEntry->count == BEGIN_CATCH_COUNT) {
+        // Branch to the landing pad to see if the exception can be
+        // caught.
+        _LIBCXXABI_TRACE_STATETAB("BEGIN_CATCH_COUNT: handler "
+                                  "%p/%p, return _URC_HANDLER_FOUND\n",
+                                  currEntry->catch_block,
+                                  *(void**)(currEntry->catch_block));
+        _LIBCXXABI_TRACE_STATETAB("Changed to state=%d\n", state->state);
+        state->state = currEntry->next_state;
+        results.landingPad = (uintptr_t) * (void**)(currEntry->catch_block);
+        results.reason = _URC_HANDLER_FOUND;
+        return;
+      } else if (currEntry->count == END_CATCH_COUNT) {
+        // End current catch block and branch to the landing pad.
+        _LIBCXXABI_TRACE_STATETAB("END_CATCH_COUNT: handler "
+                                  "%p/%p, return _URC_HANDLER_FOUND\n",
+                                  currEntry->catch_block,
+                                  *(void**)(currEntry->catch_block));
+        _LIBCXXABI_TRACE_STATETAB("Changed to state=%d\n", state->state);
+        state->state = currEntry->next_state;
+        results.landingPad = (uintptr_t) * (void**)(currEntry->catch_block);
+        results.reason = _URC_HANDLER_FOUND;
+        return;
+      } else if (currEntry->count == INLINE_DESTRUCTOR_COUNT) {
+        // Branch to user code to perform the action and eventually
+        // the inline unwinding will call _Unwind_resume.
+        _LIBCXXABI_TRACE_STATETAB("INLINE_DESTRUCTOR_COUNT: handler "
+                                  "%p/%p, return _URC_HANDLER_FOUND\n",
+                                  currEntry->catch_block,
+                                  *(void**)(currEntry->catch_block));
+        _LIBCXXABI_TRACE_STATETAB("Changed to state=%d\n", state->state);
+        state->state = currEntry->next_state;
+        results.landingPad = (uintptr_t) * (void**)(currEntry->catch_block);
+        results.reason = _URC_HANDLER_FOUND;
+        return;
+      } else {
+        _LIBCXXABI_TRACE_STATETAB("Unknown entry in FSM (count=%ld), "
+                                  "ignored\n",
+                                  currEntry->count);
+      } // End of action switching
+
+      // Go to next state.
+      state->state = currEntry->next_state;
+    }
+    _LIBCXXABI_TRACE_STATETAB("No catch handler, "
+                              "return _URC_CONTINUE_UNWIND\n");
+    results.reason = _URC_CONTINUE_UNWIND;
+    return;
+  }
+  _LIBCXXABI_TRACE_STATETAB("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 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, gRegisterNum,
+                    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;
+}
+
+// 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")));
+
+// __xlc_throw_badexception
+// This function is for xlclang++. It allocates and throws a badexception.
+// During unwinding for this badexception, 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 badexception.
+extern "C" void __xlc_throw_badexception() {
+  _LIBCXXABI_TRACE_STATETAB("Entering function: %s\n\n", __func__);
+  void* newexception = __cxa_allocate_exception(sizeof(std::bad_exception));
+  __cxa_throw(newexception, (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() {
+  //register unsigned long exceptionObject asm("r14");
+  uintptr_t exceptionObject;
+
+  asm("mr %0, 14" : "=r"(exceptionObject));
+  return exceptionObject;
+}
+
+// This function is for xlclang++.
+void __UnsupportedConditionalExpressionDestruction(void* addr, long flag) {
+  // We want to die instead of randomlly picking b or c to destory, which
+  // will be confusing for the user.
+  abort();
+}
+
+// This function is for xlclang++. It aborts when a deleted virtual
+// function is called.
+void __Deleted_Virtual() { abort(); }
+#endif // defined(_AIX)
+
 }  // extern "C"
 
 }  // __cxxabiv1