[libunwind] Fix existing code for SEH on ARM to compile correctly

[mstorsjo]

Summary

Even though SEH for ARM is incomplete, make what code already exists at least compile correctly.

The _LIBUNWIND_CURSOR_SIZE wasn't correct.

ARM (and AArch64) have a DISPATCHER_CONTEXT field named TargetPc instead of TargetIp.

For the libunwind.h UNW_* constants, there is no UNW_ARM_PC, only UNW_ARM_IP.

Don't use 'r' as loop variable when 'r' already is a Registers_arm member.

libunwind/trunk/include/__libunwind_config.h

 #  define _LIBUNWIND_TARGET_AARCH64 1
 #  define _LIBUNWIND_CONTEXT_SIZE 66
 #  define _LIBUNWIND_CURSOR_SIZE 78
 #  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 85
+#    define _LIBUNWIND_CURSOR_SIZE 80
 #  elif defined(__ARM_WMMX)
 #    define _LIBUNWIND_CONTEXT_SIZE 61
 #    define _LIBUNWIND_CURSOR_SIZE 68
 #  else
 #    define _LIBUNWIND_CONTEXT_SIZE 42
 #    define _LIBUNWIND_CURSOR_SIZE 49
 #  endif
 #  define _LIBUNWIND_HIGHEST_DWARF_REGISTER _LIBUNWIND_HIGHEST_DWARF_REGISTER_ARM

libunwind/trunk/src/Unwind-seh.cpp

case _URC_INSTALL_CONTEXT: {
     // If we were called by __libunwind_seh_personality(), indicate that
     // a handler was found; otherwise, it's time to initiate a collided
     // unwind to the target.
     if (ours && !IS_UNWINDING(ms_exc->ExceptionFlags) && ms_exc->NumberParameters > 1)
       return 4 /* ExecptionExecuteHandler in mingw */;
     // This should never happen in phase 1.
     if (!IS_UNWINDING(ms_exc->ExceptionFlags))
       _LIBUNWIND_ABORT("Personality installed context during phase 1!");
-    exc->private_[2] = disp->TargetIp;
 #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]);
 #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__)
+    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);
     _LIBUNWIND_ABORT("RtlUnwindEx() failed");
   }

libunwind/trunk/src/UnwindCursor.hpp

#elif defined(_LIBUNWIND_TARGET_ARM)
   _msContext.R7 = r.getRegister(UNW_ARM_R7);
   _msContext.R8 = r.getRegister(UNW_ARM_R8);
   _msContext.R9 = r.getRegister(UNW_ARM_R9);
   _msContext.R10 = r.getRegister(UNW_ARM_R10);
   _msContext.R11 = r.getRegister(UNW_ARM_R11);
   _msContext.R12 = r.getRegister(UNW_ARM_R12);
   _msContext.Sp = r.getRegister(UNW_ARM_SP);
   _msContext.Lr = r.getRegister(UNW_ARM_LR);
-  _msContext.Pc = r.getRegister(UNW_ARM_PC);
-  for (int r = UNW_ARM_D0; r <= UNW_ARM_D31; ++r) {
+  _msContext.Pc = r.getRegister(UNW_ARM_IP);
+  for (int i = UNW_ARM_D0; i <= UNW_ARM_D31; ++i) {
     union {
       uint64_t w;
       double d;
     } d;
-    d.d = r.getFloatRegister(r);
-    _msContext.D[r - UNW_ARM_D0] = d.w;
+    d.d = r.getFloatRegister(i);
+    _msContext.D[i - UNW_ARM_D0] = d.w;
   }
 #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),
#elif defined(_LIBUNWIND_TARGET_ARM)
   case UNW_ARM_R9: return _msContext.R9;
   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_PC: return _msContext.Pc;
+  case UNW_ARM_IP: return _msContext.Pc;
 #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_R9: _msContext.R9 = value; break;
   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_PC: _msContext.Pc = value; break;
+  case UNW_ARM_IP: _msContext.Pc = value; break;
 #endif
   default:
     _LIBUNWIND_ABORT("unsupported register");
   }
 }
 
 template <typename A, typename R>
 bool UnwindCursor<A, R>::validFloatReg(int regNum) {
#elif defined(_LIBUNWIND_TARGET_ARM)
   case UNW_ARM_R9: return "r9";
   case UNW_ARM_R10: return "r10";
   case UNW_ARM_R11: return "r11";
   case UNW_ARM_R12: return "r12";
   case UNW_REG_SP:
   case UNW_ARM_SP: return "sp";
   case UNW_ARM_LR: return "lr";
   case UNW_REG_IP:
-  case UNW_ARM_PC: return "pc";
+  case UNW_ARM_IP: return "pc";
   case UNW_ARM_S0: return "s0";
   case UNW_ARM_S1: return "s1";
   case UNW_ARM_S2: return "s2";
   case UNW_ARM_S3: return "s3";
   case UNW_ARM_S4: return "s4";
   case UNW_ARM_S5: return "s5";
   case UNW_ARM_S6: return "s6";
   case UNW_ARM_S7: return "s7";