libcxxabi/src/aix_state_tab_eh.inc

   1 //===----------------------------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //
   8 //  This file implements the personality and helper functions for the state
   9 //  table based EH used by IBM legacy compilers xlC and xlclang++ on AIX.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include <new>
  14 #include <stdio.h>
  15 #include <sys/debug.h>
  16
  17 #if !__has_cpp_attribute(clang::optnone)
  18 #error This file requires clang::optnone attribute support
  19 #endif
  20
  21 /*
  22   The legacy IBM xlC and xlclang++ compilers use the state table for EH
  23   instead of the range table. Destructors, or addresses of the possible catch
  24   sites or cleanup code are specified in the state table which is a finite
  25   state machine (FSM). Each function that has a state table also has an
  26   autolocal state variable. The state variable represents the current state
  27   of the function for EH and is found through the traceback table of the
  28   function during unwinding, which is located at the end of each function.
  29   The FSM is an array of state entries. Each state entry has the following
  30   fields:
  31
  32   * offset/address/pointer - the offset used to locate the object, or the
  33     address of a global object, or the address of the next state if it is an
  34     old conditional state change entry;
  35   * dtor/landing pad - address of the destructor function to invoke,
  36     or address of the catch block or cleanup code in the user code to branch to;
  37   * element count/action flag - the number of elements or the flag for actions;
  38   * element size - if the object is an array this is the size of one element
  39     of the array;
  40   * flags - flags used to control how fields in the entry are interpreted;
  41   * next state - the state to execute next after the action for this state is
  42     performed. The value of zero indicates the end of the state for this
  43     function.
  44
  45   The following is the description of 'element count/action flag' field.
  46 +-----------------------------------------------------------------------------+
  47 | value |      description       |                  action                    |
  48 +-------+------------------------+--------------------------------------------+
  49 | > 1   |   object is an array   | calls __cxa_vec_cleanup to run dtor for    |
  50 |       |                        | each member of the array                   |
  51 +-------+------------------------+--------------------------------------------+
  52 | 1, 0  |   object is a scalar   | calls dtor for the object                  |
  53 +-------+------------------------+--------------------------------------------+
  54 |  -1   |      begin catch       | branches to the handler which performes    |
  55 |       |                        | catch-match. If there is no catch that     |
  56 |       |                        | matches the exception it will be rethrown  |
  57 +-------+------------------------+--------------------------------------------+
  58 |  -2   |       end catch        | ends current catch block and continues     |
  59 |       |                        | attempting to catch the exception          |
  60 +-------+------------------------+--------------------------------------------+
  61 |  -3   |   delete the object    | calls the delete function of the object    |
  62 +-------+------------------------+--------------------------------------------+
  63 |  -4   |      cleanup label     | branches to the user code for cleaning up  |
  64 +-------+------------------------+--------------------------------------------+
  65 */
  66
  67 namespace __cxxabiv1 {
  68
  69 extern "C" {
  70
  71 // Macros for debugging the state table parsing.
  72 #ifdef NDEBUG
  73 #  define _LIBCXXABI_TRACE_STATETAB(msg, ...)
  74 #  define _LIBCXXABI_TRACE_STATETAB0(msg)
  75 #  define _LIBCXXABI_TRACE_STATETAB1(msg)
  76 #  define _LIBCXXABI_TRACING_STATETAB 0
  77 #else
  78 static bool state_tab_dbg() {
  79   static bool checked = false;
  80   static bool log = false;
  81   if (!checked) {
  82     log = (getenv("LIBCXXABI_PRINT_STATTAB") != NULL);
  83     checked = true;
  84   }
  85   return log;
  86 }
  87
  88 #  define _LIBCXXABI_TRACE_STATETAB(msg, ...)                                  \
  89      do {                                                                      \
  90        if (state_tab_dbg())                                                    \
  91          fprintf(stderr, "libcxxabi: " msg, __VA_ARGS__);                      \
  92      } while (0)
  93 #  define _LIBCXXABI_TRACE_STATETAB0(msg)                                      \
  94      do {                                                                      \
  95        if (state_tab_dbg())                                                    \
  96          fprintf(stderr, "libcxxabi: " msg);                                   \
  97      } while (0)
  98 #  define _LIBCXXABI_TRACE_STATETAB1(msg)                                      \
  99      do {                                                                      \
 100        if (state_tab_dbg())                                                    \
 101          fprintf(stderr, msg);                                                 \
 102      } while (0)
 103
 104 #  define _LIBCXXABI_TRACING_STATETAB state_tab_dbg()
 105 #endif // NDEBUG
 106
 107 namespace __state_table_eh {
 108
 109 using destruct_f = void (*)(void*);
 110
 111 // Definition of flags for the state table entry field 'action flag'.
 112 enum FSMEntryCount : intptr_t { beginCatch = -1, endCatch = -2, deleteObject = -3, cleanupLabel = -4, terminate = -5 };
 113
 114 // Definition of flags for the state table entry field 'flags'.
 115 enum FSMEntryFlag : int16_t {
 116   indirect = 0x100,                  // Object was thrown from a function where
 117                                      // the return value optimization was used.
 118   oldConditionalStateChange = 0x400, // State table entry is an indirect state
 119                                      // change, dereference the address in
 120                                      // offset as int for the target state.
 121                                      // This is deprecated. This indicates
 122                                      // the address is direct. (static local).
 123   conditionalStateChange = 0x800,    // State table entry is an indirect state
 124                                      // change, dereference the address in
 125                                      // offset as int for the target state.
 126                                      // The temporary is an automatic. State
 127                                      // change is used in cases such as
 128                                      // (b?(T1(),foo()):(T2(),foo())),throw 42;
 129                                      // which causes a conditional state change
 130                                      // so that we know if T1 or T2 need to be
 131                                      // destroyed.
 132   thisFlag = 0x01,                   // The address of the object for the
 133                                      // cleanup action is based on the
 134                                      // StateVariable::thisValue.
 135   vBaseFlag = 0x02,                  // The object is of a virtual base class.
 136   globalObj = 0x04                   // FSMEntry::address is the address of
 137                                      // a global object.
 138 };
 139
 140 namespace {
 141 // The finite state machine to be walked.
 142 struct FSMEntry {
 143   union {
 144     // Offset of the object within its stack frame or containing object.
 145     intptr_t offset;
 146     // Address of a global object.
 147     intptr_t address;
 148     // Address of the next state if it is an old conditional state change entry.
 149     intptr_t nextStatePtr;
 150   };
 151   union {
 152     // Address of the destructor function.
 153     void (*destructor)(void*, size_t);
 154     // The address of the catch block or cleanup code.
 155     void* landingPad;
 156   };
 157   union {
 158     // The flag for actions (when the value is negative).
 159     FSMEntryCount actionFlag;
 160     // The element count (when the value is positive or zero).
 161     size_t elementCount;
 162   };
 163   size_t elemSize;
 164   FSMEntryFlag flags;
 165   uint16_t nextState;
 166 };
 167
 168 struct FSM {
 169   uint32_t magic; // Magic number of the state table.
 170   int32_t numberOfStates;
 171   FSMEntry table[1]; // Actually table[numberOfStates].
 172 };
 173
 174 // The state variable on the stack.
 175 struct StateVariable {
 176   int32_t state;
 177   struct FSM* table;
 178   intptr_t thisValue;
 179   int32_t ignoreVBasePtrs;
 180 };
 181 } // namespace
 182
 183 // State table magic number
 184 enum FSMMagic : uint32_t {
 185   number = 0xbeefdead,  // State table generated by xlC compiler.
 186   number2 = 0xbeeedead, // State table generated by early version xlC compiler.
 187   number3 = 0x1cedbeef  // State table generated by xlclang++ compiler.
 188 };
 189
 190 constexpr size_t dtorArgument = 0x02; // Flag to destructor indicating to free
 191                                       // virtual bases, don't delete object.
 192
 193 static void invoke_destructor(FSMEntry* fsmEntry, void* addr) {
 194   _LIBCXXABI_TRACE_STATETAB("Destruct object=%p, fsmEntry=%p\n", addr, reinterpret_cast<void*>(fsmEntry));
 195   try {
 196     if (fsmEntry->elementCount == 1) {
 197       _LIBCXXABI_TRACE_STATETAB0("calling scalar destructor\n");
 198       (*fsmEntry->destructor)(addr, dtorArgument);
 199       _LIBCXXABI_TRACE_STATETAB0("returned from scalar destructor\n");
 200     } else {
 201       _LIBCXXABI_TRACE_STATETAB0("calling vector destructor\n");
 202       __cxa_vec_cleanup(addr, reinterpret_cast<size_t>(fsmEntry->elementCount), fsmEntry->elemSize,
 203                         reinterpret_cast<destruct_f>(fsmEntry->destructor));
 204       _LIBCXXABI_TRACE_STATETAB0("returned from vector destructor\n");
 205     }
 206   } catch (...) {
 207     _LIBCXXABI_TRACE_STATETAB0("Uncaught exception in destructor, terminating\n");
 208     std::terminate();
 209   }
 210 }
 211
 212 static void invoke_delete(FSMEntry* fsmEntry, void* addr) {
 213   char* objectAddress = *reinterpret_cast<char**>(addr);
 214
 215   _LIBCXXABI_TRACE_STATETAB("Delete object=%p, fsmEntry=%p\n", reinterpret_cast<void*>(objectAddress),
 216                             reinterpret_cast<void*>(fsmEntry));
 217   try {
 218     _LIBCXXABI_TRACE_STATETAB0("..calling delete()\n");
 219     // 'destructor' holds a function pointer to delete().
 220     (*fsmEntry->destructor)(objectAddress, fsmEntry->elemSize);
 221     _LIBCXXABI_TRACE_STATETAB0("..returned from delete()\n");
 222   } catch (...) {
 223     _LIBCXXABI_TRACE_STATETAB0("Uncaught exception in delete(), terminating\n");
 224     std::terminate();
 225   }
 226 }
 227
 228 // Get the frame address of the current function from its traceback table
 229 // which is at the end of each function.
 230 static uintptr_t get_frame_addr(_Unwind_Context* context) {
 231   int framePointerReg = 1; // default frame pointer == SP.
 232   uint32_t* p = reinterpret_cast<uint32_t*>(_Unwind_GetIP(context));
 233
 234   // Keep looking forward until a word of 0 is found. The traceback
 235   // table starts at the following word.
 236   while (*p)
 237     ++p;
 238   tbtable* TBTable = reinterpret_cast<tbtable*>(p + 1);
 239
 240   p = reinterpret_cast<uint32_t*>(&TBTable->tb_ext);
 241
 242   // Skip field parminfo if it exists.
 243   if (TBTable->tb.fixedparms || TBTable->tb.floatparms)
 244     ++p;
 245
 246   // Skip field tb_offset if it exists.
 247   if (TBTable->tb.has_tboff)
 248     ++p;
 249
 250   // Skip field hand_mask if it exists.
 251   if (TBTable->tb.int_hndl)
 252     ++p;
 253
 254   // Skip fields ctl_info and ctl_info_disp if they exist.
 255   if (TBTable->tb.has_ctl)
 256     p += 1 + *p;
 257
 258   // Skip fields name_len and name if exist.
 259   if (TBTable->tb.name_present) {
 260     const uint16_t name_len = *reinterpret_cast<uint16_t*>(p);
 261     p = reinterpret_cast<uint32_t*>(reinterpret_cast<char*>(p) + name_len + sizeof(uint16_t));
 262   }
 263
 264   if (TBTable->tb.uses_alloca)
 265     framePointerReg = *reinterpret_cast<char*>(p);
 266
 267   return _Unwind_GetGR(context, framePointerReg);
 268 }
 269
 270 // Calculate the object address from the FSM entry.
 271 static void* compute_addr_from_table(FSMEntry* fsmEntry, StateVariable* const state, _Unwind_Context* context) {
 272   void* addr;
 273   if (fsmEntry->flags & FSMEntryFlag::globalObj) {
 274     addr = reinterpret_cast<void*>(fsmEntry->address);
 275     _LIBCXXABI_TRACE_STATETAB("Address calculation (global obj) addr=fsmEntry->address=%p\n", addr);
 276   } else if (fsmEntry->flags & FSMEntryFlag::thisFlag) {
 277     addr = reinterpret_cast<void*>(state->thisValue + fsmEntry->offset);
 278     _LIBCXXABI_TRACE_STATETAB("Address calculation (this obj) fsmEntry->offset=%ld : "
 279                               "state->thisValue=%ld addr=(fsmEntry->offset+state->thisValue)=%p\n",
 280                               fsmEntry->offset, state->thisValue, addr);
 281   } else if (fsmEntry->flags & FSMEntryFlag::indirect) {
 282     addr = reinterpret_cast<void*>(
 283         *reinterpret_cast<char**>(get_frame_addr(context) + static_cast<uintptr_t>(fsmEntry->offset)));
 284     _LIBCXXABI_TRACE_STATETAB("Address calculation (indirect obj) addr=%p, fsmEntry->offset=%ld \n",
 285                               addr, fsmEntry->offset);
 286   } else {
 287     addr = reinterpret_cast<void*>(get_frame_addr(context) + static_cast<uintptr_t>(fsmEntry->offset));
 288     _LIBCXXABI_TRACE_STATETAB("Address calculation. (local obj) addr=fsmEntry->offset=%p\n",
 289                               addr);
 290   }
 291   return addr;
 292 }
 293
 294 static void scan_state_tab(scan_results& results, _Unwind_Action actions, bool native_exception,
 295                            _Unwind_Exception* unwind_exception, _Unwind_Context* context) {
 296   // Initialize results to found nothing but an error.
 297   results.ttypeIndex = 0;
 298   results.actionRecord = 0;
 299   results.languageSpecificData = 0;
 300   results.landingPad = 0;
 301   results.adjustedPtr = 0;
 302   results.reason = _URC_FATAL_PHASE1_ERROR;
 303
 304   // Check for consistent actions.
 305   if (actions & _UA_SEARCH_PHASE) {
 306     // Do Phase 1
 307     if (actions & (_UA_CLEANUP_PHASE | _UA_HANDLER_FRAME | _UA_FORCE_UNWIND)) {
 308       // None of these flags should be set during Phase 1.
 309       //   Client error
 310       results.reason = _URC_FATAL_PHASE1_ERROR;
 311       return;
 312     }
 313   } else if (actions & _UA_CLEANUP_PHASE) {
 314     if ((actions & _UA_HANDLER_FRAME) && (actions & _UA_FORCE_UNWIND)) {
 315       // _UA_HANDLER_FRAME should only be set if phase 1 found a handler.
 316       // If _UA_FORCE_UNWIND is set, phase 1 shouldn't have happened.
 317       //    Client error
 318       results.reason = _URC_FATAL_PHASE2_ERROR;
 319       return;
 320     }
 321   } else {
 322     // Neither _UA_SEARCH_PHASE nor _UA_CLEANUP_PHASE is set.
 323     //   Client error
 324     results.reason = _URC_FATAL_PHASE1_ERROR;
 325     return;
 326   }
 327
 328   if (_LIBCXXABI_TRACING_STATETAB) {
 329     _LIBCXXABI_TRACE_STATETAB1("\n");
 330     _LIBCXXABI_TRACE_STATETAB("%s: actions=%d (", __func__, actions);
 331
 332     if (_UA_SEARCH_PHASE & actions)
 333       _LIBCXXABI_TRACE_STATETAB1("_UA_SEARCH_PHASE ");
 334     if (_UA_CLEANUP_PHASE & actions)
 335       _LIBCXXABI_TRACE_STATETAB1("_UA_CLEANUP_PHASE ");
 336     if (_UA_HANDLER_FRAME & actions)
 337       _LIBCXXABI_TRACE_STATETAB1("_UA_HANDLER_FRAME ");
 338     if (_UA_FORCE_UNWIND & actions)
 339       _LIBCXXABI_TRACE_STATETAB1("_UA_FORCE_UNWIND ");
 340     _LIBCXXABI_TRACE_STATETAB1(")\n");
 341     _LIBCXXABI_TRACE_STATETAB("       unwind_exception=%p context=%p\n", reinterpret_cast<void*>(unwind_exception),
 342                               reinterpret_cast<void*>(context));
 343   }
 344
 345   // Start scan by getting state table address.
 346   StateVariable* const state = reinterpret_cast<StateVariable* const>(_Unwind_GetLanguageSpecificData(context));
 347   if (state->state <= 0) {
 348     // The state is not correct - give up on this routine.
 349     _LIBCXXABI_TRACE_STATETAB("state=%d and is <= 0), continue unwinding\n", state->state);
 350     results.reason = _URC_CONTINUE_UNWIND;
 351     return;
 352   }
 353   // Parse the state table.
 354   FSM* const fsm = state->table;
 355   FSMEntry* currFSMEntry;
 356
 357   if (fsm->magic != FSMMagic::number && fsm->magic != FSMMagic::number2 && fsm->magic != FSMMagic::number3) {
 358     // Something is wrong with the state table we found.
 359     if (_UA_SEARCH_PHASE & actions) {
 360       _LIBCXXABI_TRACE_STATETAB0("Invalid FSM table, return _URC_FATAL_PHASE1_ERROR\n");
 361       results.reason = _URC_FATAL_PHASE1_ERROR;
 362     } else if (_UA_CLEANUP_PHASE & actions) {
 363       _LIBCXXABI_TRACE_STATETAB0("Invalid FSM table, return _URC_FATAL_PHASE2_ERROR\n");
 364       results.reason = _URC_FATAL_PHASE2_ERROR;
 365     } else {
 366       // We should never get here.
 367       _LIBCXXABI_TRACE_STATETAB0("Invalid FSM table + RT Internal error, return _URC_FATAL_PHASE2_ERROR\n");
 368       results.reason = _URC_FATAL_PHASE2_ERROR;
 369     }
 370     return;
 371   }
 372
 373   if (_LIBCXXABI_TRACING_STATETAB) {
 374     // Print the state table for debugging purposes.
 375     _LIBCXXABI_TRACE_STATETAB("state->state=%d, state->ignoreVBasePtrs=%d\n", state->state, state->ignoreVBasePtrs);
 376     _LIBCXXABI_TRACE_STATETAB("fsm->magic=%#x, fsm->numberOfStates=%d\n", fsm->magic, fsm->numberOfStates);
 377     // Print out the FSM table.
 378     _LIBCXXABI_TRACE_STATETAB0("FSM table:\n");
 379     _LIBCXXABI_TRACE_STATETAB("%12s %10s %8s  %10s %7s %7s %7s %7s\n", "Entry Addr", "state", "Offset", "DTR/lpad",
 380                               "count", "el_size", "flags", "next");
 381     for (int i = 0; i < fsm->numberOfStates; i++) {
 382       currFSMEntry = &fsm->table[i];
 383       _LIBCXXABI_TRACE_STATETAB("%12p (%8d) %8ld  %10p %7ld "
 384                                 "%7ld %#7x %7d\n",
 385                                 reinterpret_cast<void*>(&currFSMEntry), i + 1, currFSMEntry->offset,
 386                                 reinterpret_cast<void*>(currFSMEntry->destructor),
 387                                 currFSMEntry->elementCount, currFSMEntry->elemSize, currFSMEntry->flags,
 388                                 currFSMEntry->nextState);
 389     }
 390   }
 391
 392   if (_UA_SEARCH_PHASE & actions) {
 393     // Start walking the state table. Use a local copy of state->state so when
 394     // we return from search phase we don't change the state number.
 395     int currState = state->state;
 396
 397     while (currState > 0) {
 398       currFSMEntry = &fsm->table[currState - 1];
 399       _LIBCXXABI_TRACE_STATETAB("Processing state=%d, flags=0x%hx\n", currState, currFSMEntry->flags);
 400
 401       if (currFSMEntry->actionFlag == FSMEntryCount::beginCatch) {
 402         // Found a catch handler.
 403         if (fsm->magic == FSMMagic::number) {
 404           _LIBCXXABI_TRACE_STATETAB0("Found a xlC catch handler, return _URC_FATAL_PHASE1_ERROR\n");
 405           // xlC catch handlers cannot be entered because they use a
 406           // proprietary EH runtime that is not interoperable.
 407           results.reason = _URC_FATAL_PHASE1_ERROR;
 408           return;
 409         }
 410         // xlclang++ compiled frames use CXA-abi EH calls and any catch
 411         // block will include a catch(...) block so it is safe to assume that
 412         // the handler is found without checking the catch match. The
 413         // catch(...) block will rethrow the exception if there isn't a
 414         // match.
 415         _LIBCXXABI_TRACE_STATETAB0("Found a catch handler, return _URC_HANDLER_FOUND\n");
 416         results.reason = _URC_HANDLER_FOUND;
 417         return;
 418       }
 419       if (currFSMEntry->actionFlag == FSMEntryCount::terminate) {
 420         _LIBCXXABI_TRACE_STATETAB0("Found the terminate state, return _URC_HANDLER_FOUND\n");
 421         results.reason = _URC_HANDLER_FOUND;
 422         return;
 423       }
 424       if (currFSMEntry->flags & FSMEntryFlag::oldConditionalStateChange) {
 425         // Deprecated conditional expression.
 426         currState = *reinterpret_cast<int*>(currFSMEntry->nextStatePtr);
 427         _LIBCXXABI_TRACE_STATETAB("Flag: FSMEntryFlag::oldConditionalStateChange, dereference "
 428                                   "currFSMEntry->nextStatePtr(%ld), set state=%d\n",
 429                                   currFSMEntry->nextStatePtr, currState);
 430         continue; // We are done this iteration of the loop, since
 431                   // we changed a state.
 432       }
 433       if (currFSMEntry->flags & FSMEntryFlag::conditionalStateChange) {
 434         void* addr = compute_addr_from_table(currFSMEntry, state, context);
 435         currState = *reinterpret_cast<int*>(addr);
 436         _LIBCXXABI_TRACE_STATETAB("Flag: FSMEntryFlag::conditionalStateChange, dereference "
 437                                   "addr(%p), set state=%d\n", addr, currState);
 438         continue; // We are done this iteration of the loop, since we
 439                   // changed the state.
 440       }
 441       // Go to the next state.
 442       currState = currFSMEntry->nextState;
 443     }
 444     _LIBCXXABI_TRACE_STATETAB0("No catch handler found, return _URC_CONTINUE_UNWIND\n");
 445     results.reason = _URC_CONTINUE_UNWIND;
 446     return;
 447   }
 448   if (_UA_CLEANUP_PHASE & actions) {
 449     // Start walking the state table.
 450     while (state->state > 0) {
 451       currFSMEntry = &fsm->table[state->state - 1];
 452
 453       if (currFSMEntry->actionFlag == FSMEntryCount::terminate) {
 454         _LIBCXXABI_TRACE_STATETAB0("Reached terminate state. Call terminate.\n");
 455         std::terminate();
 456       }
 457       // Perform action according to the currFSMEntry->actionFlag,
 458       // except when flag is FSMEntryFlag::conditionalStateChange or
 459       // FSMEntryFlag::oldConditionalStateChange.
 460       _LIBCXXABI_TRACE_STATETAB("Processing state=%d, flags=0x%hx\n", state->state, currFSMEntry->flags);
 461       if (currFSMEntry->flags & FSMEntryFlag::oldConditionalStateChange) {
 462         state->state = *reinterpret_cast<int*>(currFSMEntry->nextStatePtr);
 463         _LIBCXXABI_TRACE_STATETAB("Flag: FSMEntryFlag::oldConditionalStateChange, dereference "
 464                                   "currFSMEntry->nextStatePtr(%ld), set state=%d\n",
 465                                   currFSMEntry->nextStatePtr, state->state);
 466         continue; // We are done with this iteration of the loop, since we changed a state.
 467       }
 468       if (currFSMEntry->flags & FSMEntryFlag::conditionalStateChange) {
 469         // A conditional state table entry holds the address of a local
 470         // that holds the next state.
 471         void* addr = compute_addr_from_table(currFSMEntry, state, context);
 472         state->state = *reinterpret_cast<int*>(addr);
 473         _LIBCXXABI_TRACE_STATETAB("Flag: FSMEntryFlag::conditionalStateChange, dereference "
 474                                   "addr(%p), set state=%d\n", addr, state->state);
 475         continue; // We are done with this iteration of the loop, since we changed a state.
 476       }
 477       if (currFSMEntry->actionFlag == FSMEntryCount::beginCatch || currFSMEntry->actionFlag == FSMEntryCount::endCatch ||
 478           currFSMEntry->actionFlag == FSMEntryCount::cleanupLabel) {
 479
 480         _LIBCXXABI_TRACE_STATETAB(
 481             "FSMEntryCount::%s: handler %p/%p, return _URC_HANDLER_FOUND\n",
 482             (currFSMEntry->actionFlag == FSMEntryCount::beginCatch
 483                  ? "beginCatch"
 484                  : (currFSMEntry->actionFlag == FSMEntryCount::endCatch ? "endCatch" : "cleanupLabel")),
 485             currFSMEntry->landingPad, *reinterpret_cast<void**>(currFSMEntry->landingPad));
 486
 487         state->state = currFSMEntry->nextState;
 488         results.landingPad = reinterpret_cast<uintptr_t>(*reinterpret_cast<void**>(currFSMEntry->landingPad));
 489         results.reason = _URC_HANDLER_FOUND;
 490         return;
 491       }
 492       if (currFSMEntry->elementCount > 0) {
 493         if (currFSMEntry->flags & FSMEntryFlag::vBaseFlag && state->ignoreVBasePtrs) {
 494           _LIBCXXABI_TRACE_STATETAB0("Ignoring virtual base dtor.\n");
 495         } else {
 496           // We need to invoke the virtual base destructor. This must be
 497           // a frame from the legacy xlC compiler as the xlclang++ compiler
 498           // generates inline cleanup code rather than specifying
 499           // the destructor via the state table.
 500           void* addr = compute_addr_from_table(currFSMEntry, state, context);
 501
 502           // An extra indirect to get to the object according to the object
 503           // model used by the xlC compiler.
 504           addr = reinterpret_cast<void*>(*reinterpret_cast<char**>(addr));
 505           _LIBCXXABI_TRACE_STATETAB("Invoke dtor for object=%p\n", addr);
 506           invoke_destructor(currFSMEntry, addr);
 507         }
 508       } else if (currFSMEntry->actionFlag == FSMEntryCount::deleteObject) {
 509         void* addr = compute_addr_from_table(currFSMEntry, state, context);
 510         if (currFSMEntry->flags & FSMEntryFlag::vBaseFlag) {
 511           // We need to invoke the virtual base delete function. This must be
 512           // a frame from the legacy xlC compiler as the xlclang++ compiler
 513           // generates inline cleanup code rather than specifying
 514           // the delete function via the state table.
 515
 516           // An extra indirect to get to the object according to the object
 517           // model used by the xlC compiler.
 518           addr = reinterpret_cast<void*>(*reinterpret_cast<char**>(addr));
 519         }
 520         _LIBCXXABI_TRACE_STATETAB("Delete object at %p\n", addr);
 521         invoke_delete(currFSMEntry, addr);
 522       } else {
 523         _LIBCXXABI_TRACE_STATETAB("Unknown entry in FSM (count=%ld), ignored\n",
 524                                   currFSMEntry->elementCount);
 525       } // End of action switching.
 526
 527       // Go to next state.
 528       state->state = currFSMEntry->nextState;
 529     }
 530     _LIBCXXABI_TRACE_STATETAB0("No catch handler, return _URC_CONTINUE_UNWIND\n");
 531     results.reason = _URC_CONTINUE_UNWIND;
 532     return;
 533   }
 534   _LIBCXXABI_TRACE_STATETAB0("No state table entry for this exception, call_terminate()\n");
 535   // It is possible that no state table entry specify how to handle
 536   // this exception. By spec, terminate it immediately.
 537   call_terminate(native_exception, unwind_exception);
 538 }
 539
 540 // Personality routine for EH using the state table.
 541 _LIBCXXABI_FUNC_VIS _Unwind_Reason_Code
 542 __xlcxx_personality_v0(int version, _Unwind_Action actions, uint64_t exceptionClass,
 543                        _Unwind_Exception* unwind_exception, _Unwind_Context* context) {
 544   if (version != 1 || unwind_exception == 0 || context == 0)
 545     return _URC_FATAL_PHASE1_ERROR;
 546
 547   bool native_exception = (exceptionClass & get_vendor_and_language) == (kOurExceptionClass & get_vendor_and_language);
 548   scan_results results;
 549   scan_state_tab(results, actions, native_exception, unwind_exception, context);
 550   if (actions & _UA_SEARCH_PHASE) {
 551     // Phase 1 search:  All we're looking for in phase 1 is a handler that
 552     //   halts unwinding
 553     return results.reason;
 554   }
 555   if (actions & _UA_CLEANUP_PHASE) {
 556     // Phase 2 cleanup:
 557     if (results.reason == _URC_HANDLER_FOUND) {
 558       // Store the address of unwind_exception in the stack field
 559       // reserved for compilers (SP + 3 * sizeof(uintptr_t)) in the stack of
 560       // the caller of the function containing the landing pad (within the link
 561       // area for the call to the latter) for __xlc_exception_handle()
 562       // to retrieve when it is called by the landing pad.
 563       uintptr_t *currentSP = reinterpret_cast<uintptr_t*>(_Unwind_GetGR(context, 1));
 564       uintptr_t *callersSP = reinterpret_cast<uintptr_t*>(currentSP[0]);
 565       callersSP[3] = reinterpret_cast<uintptr_t>(unwind_exception);
 566       _LIBCXXABI_TRACE_STATETAB("Handshake: set unwind_exception=%p in stack=%p\n", reinterpret_cast<void*>(unwind_exception), reinterpret_cast<void*>(callersSP));
 567       // Jump to the handler.
 568       _Unwind_SetIP(context, results.landingPad);
 569       return _URC_INSTALL_CONTEXT;
 570     }
 571     // Did not find a handler. Return the results of the scan. Normally
 572     // _URC_CONTINUE_UNWIND, but could have been _URC_FATAL_PHASE2_ERROR.
 573     return results.reason;
 574   }
 575   // We were called improperly: neither a phase 1 or phase 2 search.
 576   return _URC_FATAL_PHASE1_ERROR;
 577 }
 578 } // namespace __state_table_eh
 579
 580 // The following are EH helper functions for xlclang++ compiled code.
 581
 582 // __xlc_catch_matchv2
 583 // Check whether the thrown object matches the catch handler's exception
 584 // declaration. If there is a match, the function returns true with adjusted
 585 // address of the thrown object. Otherwise, returns false.
 586 _LIBCXXABI_FUNC_VIS bool
 587 __xlc_catch_matchv2(_Unwind_Exception* exceptionObject, std::type_info* catchTypeInfo, void*& obj) {
 588   _LIBCXXABI_TRACE_STATETAB("Entering %s, exceptionObject=%p\n", __func__, reinterpret_cast<void*>(exceptionObject));
 589
 590   if (!__isOurExceptionClass(exceptionObject)) {
 591     _LIBCXXABI_TRACE_STATETAB0("No match, not a C++ exception\n");
 592     return false;
 593   }
 594
 595   __cxa_exception* exceptionHeader = 0;
 596
 597   if (__getExceptionClass(exceptionObject) == kOurDependentExceptionClass) {
 598     // Walk to the __cxa_dependent_exception primary exception for the
 599     // exception object and its type_info.
 600     __cxa_dependent_exception* dependentExceptionHeader =
 601         reinterpret_cast<__cxa_dependent_exception*>(exceptionObject + 1) - 1;
 602     exceptionHeader = reinterpret_cast<__cxa_exception*>(dependentExceptionHeader->primaryException) - 1;
 603     _LIBCXXABI_TRACE_STATETAB("exceptionObject 0x%p is a dependent, primary 0x%p\n",
 604                               reinterpret_cast<void*>(exceptionObject),
 605                               reinterpret_cast<void*>(&exceptionHeader->unwindHeader));
 606     exceptionObject = &exceptionHeader->unwindHeader;
 607   } else {
 608     _LIBCXXABI_TRACE_STATETAB("exceptionObject %p is NOT a dependent\n", reinterpret_cast<void*>(exceptionObject));
 609     exceptionHeader = reinterpret_cast<__cxa_exception*>(exceptionObject + 1) - 1;
 610   }
 611
 612   void* thrownObject = reinterpret_cast<void*>(exceptionObject + 1);
 613   std::type_info* throwTypeInfo = exceptionHeader->exceptionType;
 614
 615   // Get the type info for the thrown type and this catch clause and
 616   // see if the catch caluse can catch that type.
 617
 618   __cxxabiv1::__shim_type_info* catchType = reinterpret_cast<__cxxabiv1::__shim_type_info*>(catchTypeInfo);
 619   __cxxabiv1::__shim_type_info* throwType = reinterpret_cast<__cxxabiv1::__shim_type_info*>(throwTypeInfo);
 620   _LIBCXXABI_TRACE_STATETAB("UnwindException=%p, thrownObject=%p, throwTypeInfo=%p(%s), catchTypeInfo=%p(%s)\n",
 621                             reinterpret_cast<void*>(exceptionObject), thrownObject, reinterpret_cast<void*>(throwType),
 622                             throwType->name(), reinterpret_cast<void*>(catchType), catchType->name());
 623   if (catchType->can_catch(throwType, thrownObject)) {
 624     exceptionHeader->adjustedPtr = thrownObject;
 625     obj = thrownObject;
 626     _LIBCXXABI_TRACE_STATETAB("Match found for thrownObject=%p\n", thrownObject);
 627     return true;
 628   }
 629   _LIBCXXABI_TRACE_STATETAB0("No match\n");
 630   return false;
 631 }
 632
 633 // __xlc_throw_badexception
 634 // This function is for xlclang++. It allocates and throws a bad_exception.
 635 // During unwinding for this bad_exception, the previous exception which is
 636 // not matching the throw spec will be cleaned up. Thus having the same
 637 // effect as replace the top most exception (which is bad) with a bad_exception.
 638 _LIBCXXABI_FUNC_VIS void __xlc_throw_badexception() {
 639   _LIBCXXABI_TRACE_STATETAB("Entering function: %s\n\n", __func__);
 640   void* newexception = new (__cxa_allocate_exception(sizeof(std::bad_exception))) std::bad_exception;
 641   __cxa_throw(newexception, const_cast<std::type_info*>(&typeid(std::bad_exception)), 0);
 642 }
 643
 644 // force_a_stackframe
 645 // This function is called by __xlc_exception_handle() to ensure a stack frame
 646 // is created for __xlc_exception_handle().
 647 __attribute__((noinline, optnone))
 648 static void force_a_stackframe() {}
 649
 650 // __xlc_exception_handle
 651 // This function is for xlclang++. It returns the address of the exception
 652 // object stored in the reserved field in the stack of the caller of the
 653 // function that calls __xlc_exception_handle() (within the link area for the
 654 // call to the latter). The address is stored by the personality routine for
 655 // xlclang++ compiled code. The implementation of __xlc_exception_handle()
 656 // assumes a stack frame is created for it. The following ensures this
 657 // assumption holds true: 1) a call to force_a_stackframe() is made inside
 658 // __xlc_exception_handle() to make it non-leaf; and 2) optimizations are
 659 // disabled for this function with attribute 'optnone'. Note: this function
 660 // may not work as expected if these are changed.
 661 __attribute__((optnone))
 662 _LIBCXXABI_FUNC_VIS uintptr_t __xlc_exception_handle() {
 663   // Make a call to force_a_stackframe() so that the compiler creates a stack
 664   // frame for this function.
 665   force_a_stackframe();
 666
 667   // Get the SP of this function, i.e., __xlc_exception_handle().
 668   uintptr_t *lastStack;
 669   asm("mr %0, 1" : "=r"(lastStack));
 670   // Get the SP of the caller of __xlc_exception_handle().
 671   uintptr_t *callerStack = reinterpret_cast<uintptr_t*>(lastStack[0]);
 672   // Get the SP of the caller of the caller.
 673   uintptr_t *callerStack2 = reinterpret_cast<uintptr_t*>(callerStack[0]);
 674   uintptr_t exceptionObject = callerStack2[3];
 675   _LIBCXXABI_TRACE_STATETAB("Handshake: exceptionObject=%p from stack=%p\n", reinterpret_cast<void*>(exceptionObject), reinterpret_cast<void*>(callerStack2));
 676   return exceptionObject;
 677 }
 678
 679 // xlclang++ may generate calls to __Deleted_Virtual.
 680 _LIBCXXABI_FUNC_VIS void __Deleted_Virtual() { abort(); }
 681
 682 // __catchThrownException is called during AIX library initialization and
 683 // termination to handle exceptions.  An implementation is also provided in
 684 // libC.a(shrcore.o).  This implementation is provided for applications that
 685 // link with -lc++ (the xlclang++ or ibm-clang++ link default.)
 686 _LIBCXXABI_FUNC_VIS int
 687 __catchThrownException(void (*cdfunc)(void),   // function which may fail
 688                        void (*cleanup)(void*), // cleanup function
 689                        void* cleanuparg,       // parameter to cleanup function
 690                        int action) {           // control exception throwing and termination
 691   enum Action : int { None = 0, Rethrow = 1, Terminate = 2 };
 692   if (!cdfunc)
 693     return 0;
 694   if (action == Action::Rethrow && !cleanup) {
 695     // No cleanup and rethrow is effectively no-op.
 696     // Avoid the catch handler when possible to allow exceptions generated
 697     // from xlC binaries to flow through.
 698     (*cdfunc)();
 699     return 0;
 700   }
 701   try {
 702     (*cdfunc)();
 703   } catch (...) {
 704     if (action == Action::Terminate)
 705       std::terminate();
 706     if (cleanup)
 707       (*cleanup)(cleanuparg);
 708     if (action == Action::Rethrow)
 709       throw;
 710     assert(action == Action::None);
 711     return -1; // FAILED
 712   }
 713   return 0;
 714 }
 715
 716 }  // extern "C"
 717
 718 }  // __cxxabiv1