[libunwind] [SEH] Add initial support for AArch64

[mstorsjo]

Summary

This doesn't yet implement inspecting the .pdata/.xdata to find the LSDA pointer (in UnwindCursor::getInfoFromSEH), but normal C++ exception handling seems to run just fine without it. (The only place I can see where it's even referenced is in unwind_phase2_forced, and I can't find a codepath where libcxxabi would end up calling that.)

[cdavis5x]

LGTM, but I'd feel better if someone else signed off on this, too.

src/Unwind-seh.cpp

175–180

This looks suspicious for AArch64... I guess the values for UNW_ARM_R0 and UNW_ARM64_X0 are the same.

[mstorsjo]

src/Unwind-seh.cpp

175–180

Oh, good catch. Yes, they have the same values, but I shouldn't (and didn't intend to) rely on that.

[mstorsjo]

Using the right UNW_ARM64_X0/1 constants with unw_get_reg.

[mstorsjo]

Ping @mclow.lists - this got a LGTM from @cdavis5x last week

[mclow.lists]

LGTM.

include/__libunwind_config.h

 # elif defined(__ppc__)
 #  define _LIBUNWIND_TARGET_PPC 1
 #  define _LIBUNWIND_CONTEXT_SIZE 117
 #  define _LIBUNWIND_CURSOR_SIZE 124
 #  define _LIBUNWIND_HIGHEST_DWARF_REGISTER _LIBUNWIND_HIGHEST_DWARF_REGISTER_PPC
 # elif defined(__aarch64__)
 #  define _LIBUNWIND_TARGET_AARCH64 1
 #  define _LIBUNWIND_CONTEXT_SIZE 66
-#  define _LIBUNWIND_CURSOR_SIZE 78
+#  if defined(__SEH__)
+#    define _LIBUNWIND_CURSOR_SIZE 164
+#  else
+#    define _LIBUNWIND_CURSOR_SIZE 78
+#  endif
 #  define _LIBUNWIND_HIGHEST_DWARF_REGISTER _LIBUNWIND_HIGHEST_DWARF_REGISTER_ARM64
 # elif defined(__arm__)
 #  define _LIBUNWIND_TARGET_ARM 1
 #  if defined(__SEH__)
 #    define _LIBUNWIND_CONTEXT_SIZE 42
 #    define _LIBUNWIND_CURSOR_SIZE 80
 #  elif defined(__ARM_WMMX)
 #    define _LIBUNWIND_CONTEXT_SIZE 61

src/Unwind-seh.cpp

_GCC_specific_handler(PEXCEPTION_RECORD ms_exc, PVOID frame, PCONTEXT ms_ctx,
   if (ms_exc->ExceptionCode == STATUS_GCC_UNWIND) {
     if (IS_TARGET_UNWIND(ms_exc->ExceptionFlags)) {
       // Set up the upper return value (the lower one and the target PC
       // were set in the call to RtlUnwindEx()) for the landing pad.
 #ifdef __x86_64__
       disp->ContextRecord->Rdx = ms_exc->ExceptionInformation[3];
 #elif defined(__arm__)
       disp->ContextRecord->R1 = ms_exc->ExceptionInformation[3];
+#elif defined(__aarch64__)
+      disp->ContextRecord->X1 = ms_exc->ExceptionInformation[3];
 #endif
     }
     // This is the collided unwind to the landing pad. Nothing to do.
     return ExceptionContinueSearch;
   }
 
   if (ms_exc->ExceptionCode == STATUS_GCC_THROW) {
     // This is (probably) a libunwind-controlled exception/unwind. Recover the
case _URC_INSTALL_CONTEXT: {
     if (!IS_UNWINDING(ms_exc->ExceptionFlags))
       _LIBUNWIND_ABORT("Personality installed context during phase 1!");
 #ifdef __x86_64__
     exc->private_[2] = disp->TargetIp;
     unw_get_reg(&cursor, UNW_X86_64_RAX, &retval);
     unw_get_reg(&cursor, UNW_X86_64_RDX, &exc->private_[3]);
 #elif defined(__arm__)
     exc->private_[2] = disp->TargetPc;
     unw_get_reg(&cursor, UNW_ARM_R0, &retval);
     unw_get_reg(&cursor, UNW_ARM_R1, &exc->private_[3]);
+#elif defined(__aarch64__)
+    exc->private_[2] = disp->TargetPc;
+    unw_get_reg(&cursor, UNW_ARM64_X0, &retval);
+    unw_get_reg(&cursor, UNW_ARM64_X1, &exc->private_[3]);
 #endif
     unw_get_reg(&cursor, UNW_REG_IP, &target);
     ms_exc->ExceptionCode = STATUS_GCC_UNWIND;
 #ifdef __x86_64__
     ms_exc->ExceptionInformation[2] = disp->TargetIp;
-#elif defined(__arm__)
+#elif defined(__arm__) || defined(__aarch64__)
     ms_exc->ExceptionInformation[2] = disp->TargetPc;
 #endif
     ms_exc->ExceptionInformation[3] = exc->private_[3];
     // Give NTRTL some scratch space to keep track of the collided unwind.
     // Don't use the one that was passed in; we don't want to overwrite the
     // context in the DISPATCHER_CONTEXT.
     CONTEXT new_ctx;
     RtlUnwindEx(frame, (PVOID)target, ms_exc, (PVOID)retval, &new_ctx, disp->HistoryTable);
#ifdef _LIBUNWIND_TARGET_X86_64
   co->setInfoBasedOnIPRegister();
   return UNW_ESUCCESS;
 #elif defined(_LIBUNWIND_TARGET_ARM)
   new ((void *)cursor) UnwindCursor<LocalAddressSpace, Registers_arm>(
       context, LocalAddressSpace::sThisAddressSpace);
   auto *co = reinterpret_cast<AbstractUnwindCursor *>(cursor);
   co->setInfoBasedOnIPRegister();
   return UNW_ESUCCESS;
+#elif defined(_LIBUNWIND_TARGET_AARCH64)
+  new ((void *)cursor) UnwindCursor<LocalAddressSpace, Registers_arm64>(
+      context, LocalAddressSpace::sThisAddressSpace);
+  auto *co = reinterpret_cast<AbstractUnwindCursor *>(cursor);
+  co->setInfoBasedOnIPRegister();
+  return UNW_ESUCCESS;
 #else
   return UNW_EINVAL;
 #endif
 }
 
 static DISPATCHER_CONTEXT *
 _unw_seh_get_disp_ctx(unw_cursor_t *cursor) {
 #ifdef _LIBUNWIND_TARGET_X86_64
   return reinterpret_cast<UnwindCursor<LocalAddressSpace, Registers_x86_64> *>(cursor)->getDispatcherContext();
 #elif defined(_LIBUNWIND_TARGET_ARM)
   return reinterpret_cast<UnwindCursor<LocalAddressSpace, Registers_arm> *>(cursor)->getDispatcherContext();
+#elif defined(_LIBUNWIND_TARGET_AARCH64)
+  return reinterpret_cast<UnwindCursor<LocalAddressSpace, Registers_arm64> *>(cursor)->getDispatcherContext();
 #else
   return nullptr;
 #endif
 }
 
 static void
 _unw_seh_set_disp_ctx(unw_cursor_t *cursor, DISPATCHER_CONTEXT *disp) {
 #ifdef _LIBUNWIND_TARGET_X86_64
   reinterpret_cast<UnwindCursor<LocalAddressSpace, Registers_x86_64> *>(cursor)->setDispatcherContext(disp);
 #elif defined(_LIBUNWIND_TARGET_ARM)
   reinterpret_cast<UnwindCursor<LocalAddressSpace, Registers_arm> *>(cursor)->setDispatcherContext(disp);
+#elif defined(_LIBUNWIND_TARGET_AARCH64)
+  reinterpret_cast<UnwindCursor<LocalAddressSpace, Registers_arm64> *>(cursor)->setDispatcherContext(disp);
 #endif
 }
 
 #endif // defined(_LIBUNWIND_SUPPORT_SEH_UNWIND)

src/UnwindCursor.hpp

#elif defined(_LIBUNWIND_TARGET_ARM)
   for (int i = UNW_ARM_D0; i <= UNW_ARM_D31; ++i) {
     union {
       uint64_t w;
       double d;
     } d;
     d.d = r.getFloatRegister(i);
     _msContext.D[i - UNW_ARM_D0] = d.w;
   }
+#elif defined(_LIBUNWIND_TARGET_AARCH64)
+  for (int i = UNW_ARM64_X0; i <= UNW_ARM64_X30; ++i)
+    _msContext.X[i - UNW_ARM64_X0] = r.getRegister(i);
+  _msContext.Sp = r.getRegister(UNW_REG_SP);
+  _msContext.Pc = r.getRegister(UNW_REG_IP);
+  for (int i = UNW_ARM64_D0; i <= UNW_ARM64_D31; ++i)
+    _msContext.V[i - UNW_ARM64_D0].D[0] = r.getFloatRegister(i);
 #endif
 }
 
 template <typename A, typename R>
 UnwindCursor<A, R>::UnwindCursor(CONTEXT *context, A &as)
     : _addressSpace(as), _unwindInfoMissing(false) {
   static_assert((check_fit<UnwindCursor<A, R>, unw_cursor_t>::does_fit),
                 "UnwindCursor<> does not fit in unw_cursor_t");
   memset(&_info, 0, sizeof(_info));
   memset(&_histTable, 0, sizeof(_histTable));
   _dispContext.ContextRecord = &_msContext;
   _dispContext.HistoryTable = &_histTable;
   _msContext = *context;
 }
 
 
 template <typename A, typename R>
 bool UnwindCursor<A, R>::validReg(int regNum) {
   if (regNum == UNW_REG_IP || regNum == UNW_REG_SP) return true;
 #if defined(_LIBUNWIND_TARGET_X86_64)
   if (regNum >= UNW_X86_64_RAX && regNum <= UNW_X86_64_R15) return true;
 #elif defined(_LIBUNWIND_TARGET_ARM)
   if (regNum >= UNW_ARM_R0 && regNum <= UNW_ARM_R15) return true;
+#elif defined(_LIBUNWIND_TARGET_AARCH64)
+  if (regNum >= UNW_ARM64_X0 && regNum <= UNW_ARM64_X30) return true;
 #endif
   return false;
 }
 
 template <typename A, typename R>
 unw_word_t UnwindCursor<A, R>::getReg(int regNum) {
   switch (regNum) {
 #if defined(_LIBUNWIND_TARGET_X86_64)
#elif defined(_LIBUNWIND_TARGET_ARM)
   case UNW_ARM_R10: return _msContext.R10;
   case UNW_ARM_R11: return _msContext.R11;
   case UNW_ARM_R12: return _msContext.R12;
   case UNW_REG_SP:
   case UNW_ARM_SP: return _msContext.Sp;
   case UNW_ARM_LR: return _msContext.Lr;
   case UNW_REG_IP:
   case UNW_ARM_IP: return _msContext.Pc;
+#elif defined(_LIBUNWIND_TARGET_AARCH64)
+  case UNW_REG_SP: return _msContext.Sp;
+  case UNW_REG_IP: return _msContext.Pc;
+  default: return _msContext.X[regNum - UNW_ARM64_X0];
 #endif
   }
   _LIBUNWIND_ABORT("unsupported register");
 }
 
 template <typename A, typename R>
 void UnwindCursor<A, R>::setReg(int regNum, unw_word_t value) {
   switch (regNum) {
#elif defined(_LIBUNWIND_TARGET_ARM)
   case UNW_ARM_R10: _msContext.R10 = value; break;
   case UNW_ARM_R11: _msContext.R11 = value; break;
   case UNW_ARM_R12: _msContext.R12 = value; break;
   case UNW_REG_SP:
   case UNW_ARM_SP: _msContext.Sp = value; break;
   case UNW_ARM_LR: _msContext.Lr = value; break;
   case UNW_REG_IP:
   case UNW_ARM_IP: _msContext.Pc = value; break;
+#elif defined(_LIBUNWIND_TARGET_AARCH64)
+  case UNW_REG_SP: _msContext.Sp = value; break;
+  case UNW_REG_IP: _msContext.Pc = value; break;
+  case UNW_ARM64_X0:
+  case UNW_ARM64_X1:
+  case UNW_ARM64_X2:
+  case UNW_ARM64_X3:
+  case UNW_ARM64_X4:
+  case UNW_ARM64_X5:
+  case UNW_ARM64_X6:
+  case UNW_ARM64_X7:
+  case UNW_ARM64_X8:
+  case UNW_ARM64_X9:
+  case UNW_ARM64_X10:
+  case UNW_ARM64_X11:
+  case UNW_ARM64_X12:
+  case UNW_ARM64_X13:
+  case UNW_ARM64_X14:
+  case UNW_ARM64_X15:
+  case UNW_ARM64_X16:
+  case UNW_ARM64_X17:
+  case UNW_ARM64_X18:
+  case UNW_ARM64_X19:
+  case UNW_ARM64_X20:
+  case UNW_ARM64_X21:
+  case UNW_ARM64_X22:
+  case UNW_ARM64_X23:
+  case UNW_ARM64_X24:
+  case UNW_ARM64_X25:
+  case UNW_ARM64_X26:
+  case UNW_ARM64_X27:
+  case UNW_ARM64_X28:
+  case UNW_ARM64_FP:
+  case UNW_ARM64_LR: _msContext.X[regNum - UNW_ARM64_X0] = value; break;
 #endif
   default:
     _LIBUNWIND_ABORT("unsupported register");
   }
 }
 
 template <typename A, typename R>
 bool UnwindCursor<A, R>::validFloatReg(int regNum) {
 #if defined(_LIBUNWIND_TARGET_ARM)
   if (regNum >= UNW_ARM_S0 && regNum <= UNW_ARM_S31) return true;
   if (regNum >= UNW_ARM_D0 && regNum <= UNW_ARM_D31) return true;
+#elif defined(_LIBUNWIND_TARGET_AARCH64)
+  if (regNum >= UNW_ARM64_D0 && regNum <= UNW_ARM64_D31) return true;
 #endif
   return false;
 }
 
 template <typename A, typename R>
 unw_fpreg_t UnwindCursor<A, R>::getFloatReg(int regNum) {
 #if defined(_LIBUNWIND_TARGET_ARM)
   if (regNum >= UNW_ARM_S0 && regNum <= UNW_ARM_S31) {
     union {
       uint32_t w;
       float f;
     } d;
     d.w = _msContext.S[regNum - UNW_ARM_S0];
     return d.f;
   }
   if (regNum >= UNW_ARM_D0 && regNum <= UNW_ARM_D31) {
     union {
       uint64_t w;
       double d;
     } d;
     d.w = _msContext.D[regNum - UNW_ARM_D0];
     return d.d;
   }
   _LIBUNWIND_ABORT("unsupported float register");
+#elif defined(_LIBUNWIND_TARGET_AARCH64)
+  return _msContext.V[regNum - UNW_ARM64_D0].D[0];
 #else
   _LIBUNWIND_ABORT("float registers unimplemented");
 #endif
 }
 
 template <typename A, typename R>
 void UnwindCursor<A, R>::setFloatReg(int regNum, unw_fpreg_t value) {
 #if defined(_LIBUNWIND_TARGET_ARM)
if (regNum >= UNW_ARM_D0 && regNum <= UNW_ARM_D31) {
     union {
       uint64_t w;
       double d;
     } d;
     d.d = value;
     _msContext.D[regNum - UNW_ARM_D0] = d.w;
   }
   _LIBUNWIND_ABORT("unsupported float register");
+#elif defined(_LIBUNWIND_TARGET_AARCH64)
+  _msContext.V[regNum - UNW_ARM64_D0].D[0] = value;
 #else
   _LIBUNWIND_ABORT("float registers unimplemented");
 #endif
 }
 
 template <typename A, typename R> void UnwindCursor<A, R>::jumpto() {
   RtlRestoreContext(&_msContext, nullptr);
 }