[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

1764

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

1764

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

1248

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

1266

Isn't this on line 1248?

1277

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

1297

Suggestion: use flexible array member.

1308

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.

1312

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.

1318

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

1348

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

1402

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

[jasonliu]

libcxxabi/src/cxa_personality.cpp

1266

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

[hubert.reinterpretcast]

libcxxabi/src/cxa_personality.cpp

1776

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

1266

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

1277

Changed as suggested. Thanks!

1297

Use flexible array as suggested, thanks!

1308

Changed to use typed enum.

1312

Changed to use typed enum.

1318

Changed to use typed enum.

1348

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

1776

Good catch, thanks!

[cebowleratibm]

Early comments. Continuing to work through the review.

libcxxabi/src/cxa_personality.cpp

1246

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.

1277

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

1286

I suggest making this:

union {
  FSMEntryCount flag;
  intptr_t count;
}

which makes overlapping use of the memory more clear.

1288

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

[cebowleratibm]

Review in still on-going.

libcxxabi/src/cxa_personality.cpp

1308

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

1335

Suggest adding a comment.

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

1336

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.

1337

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.

1343

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

1399

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)

1507

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.

1512

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

1530

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

1545

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.

1552

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?

1555

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

1331

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.

1533

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.

1580

suggest "else if" -> "if"

1591

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.

1605

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.

1619

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

1625

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)

1638

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

1246

Added a high level description of the state table.

1277

Added namespace __state_table_eh.

1286

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

1288

Good point, changed to use type FSMEntryFlag. Thanks!

1308

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.

1331

Changed the naming and added comments as suggested, thanks!

1335

Added the comment as suggested, thanks!

1336

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

1337

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

1343

Changed as suggested, thanks.

1399

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

1507

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

1512

Same as the comment above.

1530

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.

1533

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

1545

Added the comment as suggested, thanks!

1552

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.

1555

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

1580

Changed as suggested.

1591

Changed as suggested, thanks!

1605

Changes as suggested, thanks.

1619

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.

1625

Added a table above to describe the actions.

1638

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

1254

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

1334

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

1384

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

uintptr_t elementCount
```?

1664

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.

1733

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.

1736

typo "onditionalStateChange"

1768

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

1254

Changes as suggested, thanks!

1334

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

1384

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.

1664

Modified comments as suggested, thanks!

1733

Added the comment as suggested, thanks!

1736

Fixed, thanks for catching it!

1768

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

1297

1299

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

1324

Prefer using to typedef

1357

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

1407

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

1410

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

Pick a snake_case function name.

1411

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

1431

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

1435

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

1449

1456

The coding standard prefers pre-increment ++p.

ditto below

1467

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

1476

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

1521

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.

1523

1825

Delete the comment since the _LIBCXXABI_TRACE_STATETAB self explains.

1886

delete blank line

[MaskRay]

libcxxabi/src/cxa_personality.cpp

1891

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

[MaskRay]

libcxxabi/src/cxa_personality.cpp

1435

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

[hubert.reinterpretcast]

libcxxabi/src/cxa_personality.cpp

1435

@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

1297

Changed as suggested, thanks!

1299

Added static and changed function name to state_tab_dbg. Thanks!

1324

Changed to use using, thanks!

1357

Used anonymous namespace for 3 local structures, thanks!

1407

Changed to use constexpr and renamed gRegisterNum to REG_EXCP_OBJ.

1410

Renamed __Invoke__Destructor and __Invoke__Delete to invoke_destructor and invoke_delete respectively.

1411

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]

1431

Fixed this and other occurrences, thanks!

1449

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.

1456

Fixed this and other occurrences, thanks for pointing out!

1467

Fixed, thanks!

1476

Fixed, thanks!

1521

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.

1523

Fixed, thanks!

1825

Done, thanks!

1886

Done.

1891

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

catch (...)
               //   old_exception_header
               throw be;
             }
         }
     }
     std::__terminate(t_handler);
 }
 
+#if defined(_AIX)
+
+#include <stdio.h>
+
+// 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