diff --git a/include/dwarf.h b/include/dwarf.h
index e1f7825c..ab2f34bf 100644
--- a/include/dwarf.h
+++ b/include/dwarf.h
@@ -249,18 +249,24 @@ dwarf_where_t;
 #define DWARF_CFA_REG_COLUMN    DWARF_NUM_PRESERVED_REGS
 #define DWARF_CFA_OFF_COLUMN    (DWARF_NUM_PRESERVED_REGS + 1)
 
+typedef struct dwarf_reg_only_state
+  {
+    char where[DWARF_NUM_PRESERVED_REGS + 2];        /* how is the register saved? */
+    unw_word_t val[DWARF_NUM_PRESERVED_REGS + 2];             /* where it's saved */
+  }
+dwarf_reg_only_state_t;
+
 typedef struct dwarf_reg_state
   {
     unw_word_t ret_addr_column;	/* which column in rule table represents return address */
-    char where[DWARF_NUM_PRESERVED_REGS + 2];        /* how is the register saved? */
-    unw_word_t val[DWARF_NUM_PRESERVED_REGS + 2];             /* where it's saved */
+    dwarf_reg_only_state_t reg;
   }
 dwarf_reg_state_t;
 
 typedef struct dwarf_stackable_reg_state
   {
     struct dwarf_stackable_reg_state *next;       /* for rs_stack */
-    dwarf_reg_state_t state;
+    dwarf_reg_only_state_t state;
   }
 dwarf_stackable_reg_state_t;
 
diff --git a/src/aarch64/Gstash_frame.c b/src/aarch64/Gstash_frame.c
index 6a8d8ab3..6689af1a 100644
--- a/src/aarch64/Gstash_frame.c
+++ b/src/aarch64/Gstash_frame.c
@@ -36,13 +36,13 @@ tdep_stash_frame (struct dwarf_cursor *d, struct dwarf_reg_state *rs)
          " ra=0x%lx fp [where=%d val=%ld @0x%lx] lr [where=%d val=%ld @0x%lx] "
          "sp [where=%d val=%ld @0x%lx]\n",
          d->ip, d->cfa, f->frame_type,
-         rs->where[DWARF_CFA_REG_COLUMN],
-         rs->val[DWARF_CFA_REG_COLUMN],
-         rs->val[DWARF_CFA_OFF_COLUMN],
+         rs->reg.where[DWARF_CFA_REG_COLUMN],
+         rs->reg.val[DWARF_CFA_REG_COLUMN],
+         rs->reg.val[DWARF_CFA_OFF_COLUMN],
          DWARF_GET_LOC(d->loc[rs->ret_addr_column]),
-         rs->where[FP], rs->val[FP], DWARF_GET_LOC(d->loc[FP]),
-         rs->where[LR], rs->val[LR], DWARF_GET_LOC(d->loc[LR]),
-         rs->where[SP], rs->val[SP], DWARF_GET_LOC(d->loc[SP]));
+         rs->reg.where[FP], rs->reg.val[FP], DWARF_GET_LOC(d->loc[FP]),
+         rs->reg.where[LR], rs->reg.val[LR], DWARF_GET_LOC(d->loc[LR]),
+         rs->reg.where[SP], rs->reg.val[SP], DWARF_GET_LOC(d->loc[SP]));
 
   /* A standard frame is defined as:
       - CFA is register-relative offset off FP or SP;
@@ -51,37 +51,37 @@ tdep_stash_frame (struct dwarf_cursor *d, struct dwarf_reg_state *rs)
       - LR is unsaved or saved at CFA+offset, offset != -1;
       - SP is unsaved or saved at CFA+offset, offset != -1.  */
   if (f->frame_type == UNW_AARCH64_FRAME_OTHER
-      && (rs->where[DWARF_CFA_REG_COLUMN] == DWARF_WHERE_REG)
-      && (rs->val[DWARF_CFA_REG_COLUMN] == FP
-          || rs->val[DWARF_CFA_REG_COLUMN] == SP)
-      && labs(rs->val[DWARF_CFA_OFF_COLUMN]) < (1 << 29)
+      && (rs->reg.where[DWARF_CFA_REG_COLUMN] == DWARF_WHERE_REG)
+      && (rs->reg.val[DWARF_CFA_REG_COLUMN] == FP
+          || rs->reg.val[DWARF_CFA_REG_COLUMN] == SP)
+      && labs(rs->reg.val[DWARF_CFA_OFF_COLUMN]) < (1 << 29)
       && rs->ret_addr_column == LR
-      && (rs->where[FP] == DWARF_WHERE_UNDEF
-          || rs->where[FP] == DWARF_WHERE_SAME
-          || (rs->where[FP] == DWARF_WHERE_CFAREL
-              && labs(rs->val[FP]) < (1 << 29)
-              && rs->val[FP]+1 != 0))
-      && (rs->where[LR] == DWARF_WHERE_UNDEF
-          || rs->where[LR] == DWARF_WHERE_SAME
-          || (rs->where[LR] == DWARF_WHERE_CFAREL
-              && labs(rs->val[LR]) < (1 << 29)
-              && rs->val[LR]+1 != 0))
-      && (rs->where[SP] == DWARF_WHERE_UNDEF
-          || rs->where[SP] == DWARF_WHERE_SAME
-          || (rs->where[SP] == DWARF_WHERE_CFAREL
-              && labs(rs->val[SP]) < (1 << 29)
-              && rs->val[SP]+1 != 0)))
+      && (rs->reg.where[FP] == DWARF_WHERE_UNDEF
+          || rs->reg.where[FP] == DWARF_WHERE_SAME
+          || (rs->reg.where[FP] == DWARF_WHERE_CFAREL
+              && labs(rs->reg.val[FP]) < (1 << 29)
+              && rs->reg.val[FP]+1 != 0))
+      && (rs->reg.where[LR] == DWARF_WHERE_UNDEF
+          || rs->reg.where[LR] == DWARF_WHERE_SAME
+          || (rs->reg.where[LR] == DWARF_WHERE_CFAREL
+              && labs(rs->reg.val[LR]) < (1 << 29)
+              && rs->reg.val[LR]+1 != 0))
+      && (rs->reg.where[SP] == DWARF_WHERE_UNDEF
+          || rs->reg.where[SP] == DWARF_WHERE_SAME
+          || (rs->reg.where[SP] == DWARF_WHERE_CFAREL
+              && labs(rs->reg.val[SP]) < (1 << 29)
+              && rs->reg.val[SP]+1 != 0)))
   {
     /* Save information for a standard frame. */
     f->frame_type = UNW_AARCH64_FRAME_STANDARD;
-    f->cfa_reg_sp = (rs->val[DWARF_CFA_REG_COLUMN] == SP);
-    f->cfa_reg_offset = rs->val[DWARF_CFA_OFF_COLUMN];
-    if (rs->where[FP] == DWARF_WHERE_CFAREL)
-      f->fp_cfa_offset = rs->val[FP];
-    if (rs->where[LR] == DWARF_WHERE_CFAREL)
-      f->lr_cfa_offset = rs->val[LR];
-    if (rs->where[SP] == DWARF_WHERE_CFAREL)
-      f->sp_cfa_offset = rs->val[SP];
+    f->cfa_reg_sp = (rs->reg.val[DWARF_CFA_REG_COLUMN] == SP);
+    f->cfa_reg_offset = rs->reg.val[DWARF_CFA_OFF_COLUMN];
+    if (rs->reg.where[FP] == DWARF_WHERE_CFAREL)
+      f->fp_cfa_offset = rs->reg.val[FP];
+    if (rs->reg.where[LR] == DWARF_WHERE_CFAREL)
+      f->lr_cfa_offset = rs->reg.val[LR];
+    if (rs->reg.where[SP] == DWARF_WHERE_CFAREL)
+      f->sp_cfa_offset = rs->reg.val[SP];
     Debug (4, " standard frame\n");
   }
   else
diff --git a/src/arm/Gstash_frame.c b/src/arm/Gstash_frame.c
index 576273be..c5a76b86 100644
--- a/src/arm/Gstash_frame.c
+++ b/src/arm/Gstash_frame.c
@@ -36,13 +36,13 @@ tdep_stash_frame (struct dwarf_cursor *d, struct dwarf_reg_state *rs)
          " ra=0x%x r7 [where=%d val=%d @0x%x] lr [where=%d val=%d @0x%x] "
          "sp [where=%d val=%d @0x%x]\n",
          d->ip, d->cfa, f->frame_type,
-         rs->where[DWARF_CFA_REG_COLUMN],
-         rs->val[DWARF_CFA_REG_COLUMN],
-         rs->val[DWARF_CFA_OFF_COLUMN],
+         rs->reg.where[DWARF_CFA_REG_COLUMN],
+         rs->reg.val[DWARF_CFA_REG_COLUMN],
+         rs->reg.val[DWARF_CFA_OFF_COLUMN],
          DWARF_GET_LOC(d->loc[rs->ret_addr_column]),
-         rs->where[R7], rs->val[R7], DWARF_GET_LOC(d->loc[R7]),
-         rs->where[LR], rs->val[LR], DWARF_GET_LOC(d->loc[LR]),
-         rs->where[SP], rs->val[SP], DWARF_GET_LOC(d->loc[SP]));
+         rs->reg.where[R7], rs->reg.val[R7], DWARF_GET_LOC(d->loc[R7]),
+         rs->reg.where[LR], rs->reg.val[LR], DWARF_GET_LOC(d->loc[LR]),
+         rs->reg.where[SP], rs->reg.val[SP], DWARF_GET_LOC(d->loc[SP]));
 
   /* A standard frame is defined as:
       - CFA is register-relative offset off R7 or SP;
@@ -51,37 +51,37 @@ tdep_stash_frame (struct dwarf_cursor *d, struct dwarf_reg_state *rs)
       - LR is unsaved or saved at CFA+offset, offset != -1;
       - SP is unsaved or saved at CFA+offset, offset != -1.  */
   if (f->frame_type == UNW_ARM_FRAME_OTHER
-      && (rs->where[DWARF_CFA_REG_COLUMN] == DWARF_WHERE_REG)
-      && (rs->val[DWARF_CFA_REG_COLUMN] == R7
-          || rs->val[DWARF_CFA_REG_COLUMN] == SP)
-      && labs(rs->val[DWARF_CFA_OFF_COLUMN]) < (1 << 29)
+      && (rs->reg.where[DWARF_CFA_REG_COLUMN] == DWARF_WHERE_REG)
+      && (rs->reg.val[DWARF_CFA_REG_COLUMN] == R7
+          || rs->reg.val[DWARF_CFA_REG_COLUMN] == SP)
+      && labs(rs->reg.val[DWARF_CFA_OFF_COLUMN]) < (1 << 29)
       && rs->ret_addr_column == LR
-      && (rs->where[R7] == DWARF_WHERE_UNDEF
-          || rs->where[R7] == DWARF_WHERE_SAME
-          || (rs->where[R7] == DWARF_WHERE_CFAREL
-              && labs(rs->val[R7]) < (1 << 29)
-              && rs->val[R7]+1 != 0))
-      && (rs->where[LR] == DWARF_WHERE_UNDEF
-          || rs->where[LR] == DWARF_WHERE_SAME
-          || (rs->where[LR] == DWARF_WHERE_CFAREL
-              && labs(rs->val[LR]) < (1 << 29)
-              && rs->val[LR]+1 != 0))
-      && (rs->where[SP] == DWARF_WHERE_UNDEF
-          || rs->where[SP] == DWARF_WHERE_SAME
-          || (rs->where[SP] == DWARF_WHERE_CFAREL
-              && labs(rs->val[SP]) < (1 << 29)
-              && rs->val[SP]+1 != 0)))
+      && (rs->reg.where[R7] == DWARF_WHERE_UNDEF
+          || rs->reg.where[R7] == DWARF_WHERE_SAME
+          || (rs->reg.where[R7] == DWARF_WHERE_CFAREL
+              && labs(rs->reg.val[R7]) < (1 << 29)
+              && rs->reg.val[R7]+1 != 0))
+      && (rs->reg.where[LR] == DWARF_WHERE_UNDEF
+          || rs->reg.where[LR] == DWARF_WHERE_SAME
+          || (rs->reg.where[LR] == DWARF_WHERE_CFAREL
+              && labs(rs->reg.val[LR]) < (1 << 29)
+              && rs->reg.val[LR]+1 != 0))
+      && (rs->reg.where[SP] == DWARF_WHERE_UNDEF
+          || rs->reg.where[SP] == DWARF_WHERE_SAME
+          || (rs->reg.where[SP] == DWARF_WHERE_CFAREL
+              && labs(rs->reg.val[SP]) < (1 << 29)
+              && rs->reg.val[SP]+1 != 0)))
   {
     /* Save information for a standard frame. */
     f->frame_type = UNW_ARM_FRAME_STANDARD;
-    f->cfa_reg_sp = (rs->val[DWARF_CFA_REG_COLUMN] == SP);
-    f->cfa_reg_offset = rs->val[DWARF_CFA_OFF_COLUMN];
-    if (rs->where[R7] == DWARF_WHERE_CFAREL)
-      f->r7_cfa_offset = rs->val[R7];
-    if (rs->where[LR] == DWARF_WHERE_CFAREL)
-      f->lr_cfa_offset = rs->val[LR];
-    if (rs->where[SP] == DWARF_WHERE_CFAREL)
-      f->sp_cfa_offset = rs->val[SP];
+    f->cfa_reg_sp = (rs->reg.val[DWARF_CFA_REG_COLUMN] == SP);
+    f->cfa_reg_offset = rs->reg.val[DWARF_CFA_OFF_COLUMN];
+    if (rs->reg.where[R7] == DWARF_WHERE_CFAREL)
+      f->r7_cfa_offset = rs->reg.val[R7];
+    if (rs->reg.where[LR] == DWARF_WHERE_CFAREL)
+      f->lr_cfa_offset = rs->reg.val[LR];
+    if (rs->reg.where[SP] == DWARF_WHERE_CFAREL)
+      f->sp_cfa_offset = rs->reg.val[SP];
     Debug (4, " standard frame\n");
   }
   else
diff --git a/src/dwarf/Gparser.c b/src/dwarf/Gparser.c
index b1f9dd04..6246b5ee 100644
--- a/src/dwarf/Gparser.c
+++ b/src/dwarf/Gparser.c
@@ -55,8 +55,8 @@ static inline void
 set_reg (dwarf_state_record_t *sr, unw_word_t regnum, dwarf_where_t where,
          unw_word_t val)
 {
-  sr->rs_current.where[regnum] = where;
-  sr->rs_current.val[regnum] = val;
+  sr->rs_current.reg.where[regnum] = where;
+  sr->rs_current.reg.val[regnum] = val;
 }
 
 static inline int
@@ -218,8 +218,8 @@ run_cfi_program (struct dwarf_cursor *c, dwarf_state_record_t *sr,
               ret = -UNW_EINVAL;
               break;
             }
-          sr->rs_current.where[regnum] = sr->rs_initial.where[regnum];
-          sr->rs_current.val[regnum] = sr->rs_initial.val[regnum];
+          sr->rs_current.reg.where[regnum] = sr->rs_initial.reg.where[regnum];
+          sr->rs_current.reg.val[regnum] = sr->rs_initial.reg.val[regnum];
           Debug (15, "CFA_restore r%lu\n", (long) regnum);
           break;
 
@@ -233,8 +233,8 @@ run_cfi_program (struct dwarf_cursor *c, dwarf_state_record_t *sr,
               ret = -UNW_EINVAL;
               break;
             }
-          sr->rs_current.where[regnum] = sr->rs_initial.where[regnum];
-          sr->rs_current.val[regnum] = sr->rs_initial.val[regnum];
+          sr->rs_current.reg.where[regnum] = sr->rs_initial.reg.where[regnum];
+          sr->rs_current.reg.val[regnum] = sr->rs_initial.reg.val[regnum];
           Debug (15, "CFA_restore_extended r%lu\n", (long) regnum);
           break;
 
@@ -785,32 +785,32 @@ apply_reg_state (struct dwarf_cursor *c, struct dwarf_reg_state *rs)
   /* Evaluate the CFA first, because it may be referred to by other
      expressions.  */
 
-  if (rs->where[DWARF_CFA_REG_COLUMN] == DWARF_WHERE_REG)
+  if (rs->reg.where[DWARF_CFA_REG_COLUMN] == DWARF_WHERE_REG)
     {
       /* CFA is equal to [reg] + offset: */
 
       /* As a special-case, if the stack-pointer is the CFA and the
          stack-pointer wasn't saved, popping the CFA implicitly pops
          the stack-pointer as well.  */
-      if ((rs->val[DWARF_CFA_REG_COLUMN] == UNW_TDEP_SP)
-          && (UNW_TDEP_SP < ARRAY_SIZE(rs->val))
-          && (rs->where[UNW_TDEP_SP] == DWARF_WHERE_SAME))
+      if ((rs->reg.val[DWARF_CFA_REG_COLUMN] == UNW_TDEP_SP)
+          && (UNW_TDEP_SP < ARRAY_SIZE(rs->reg.val))
+          && (rs->reg.where[UNW_TDEP_SP] == DWARF_WHERE_SAME))
           cfa = c->cfa;
       else
         {
-          regnum = dwarf_to_unw_regnum (rs->val[DWARF_CFA_REG_COLUMN]);
+          regnum = dwarf_to_unw_regnum (rs->reg.val[DWARF_CFA_REG_COLUMN]);
           if ((ret = unw_get_reg ((unw_cursor_t *) c, regnum, &cfa)) < 0)
             return ret;
         }
-      cfa += rs->val[DWARF_CFA_OFF_COLUMN];
+      cfa += rs->reg.val[DWARF_CFA_OFF_COLUMN];
     }
   else
     {
       /* CFA is equal to EXPR: */
 
-      assert (rs->where[DWARF_CFA_REG_COLUMN] == DWARF_WHERE_EXPR);
+      assert (rs->reg.where[DWARF_CFA_REG_COLUMN] == DWARF_WHERE_EXPR);
 
-      addr = rs->val[DWARF_CFA_REG_COLUMN];
+      addr = rs->reg.val[DWARF_CFA_REG_COLUMN];
       if ((ret = eval_location_expr (c, as, a, addr, &cfa_loc, arg)) < 0)
         return ret;
       /* the returned location better be a memory location... */
@@ -821,7 +821,7 @@ apply_reg_state (struct dwarf_cursor *c, struct dwarf_reg_state *rs)
 
   for (i = 0; i < DWARF_NUM_PRESERVED_REGS; ++i)
     {
-      switch ((dwarf_where_t) rs->where[i])
+      switch ((dwarf_where_t) rs->reg.where[i])
         {
         case DWARF_WHERE_UNDEF:
           c->loc[i] = DWARF_NULL_LOC;
@@ -831,21 +831,21 @@ apply_reg_state (struct dwarf_cursor *c, struct dwarf_reg_state *rs)
           break;
 
         case DWARF_WHERE_CFAREL:
-          c->loc[i] = DWARF_MEM_LOC (c, cfa + rs->val[i]);
+          c->loc[i] = DWARF_MEM_LOC (c, cfa + rs->reg.val[i]);
           break;
 
         case DWARF_WHERE_REG:
-          c->loc[i] = DWARF_REG_LOC (c, dwarf_to_unw_regnum (rs->val[i]));
+          c->loc[i] = DWARF_REG_LOC (c, dwarf_to_unw_regnum (rs->reg.val[i]));
           break;
 
         case DWARF_WHERE_EXPR:
-          addr = rs->val[i];
+          addr = rs->reg.val[i];
           if ((ret = eval_location_expr (c, as, a, addr, c->loc + i, arg)) < 0)
             return ret;
           break;
 
         case DWARF_WHERE_VAL_EXPR:
-          addr = rs->val[i];
+          addr = rs->reg.val[i];
           if ((ret = eval_location_expr (c, as, a, addr, c->loc + i, arg)) < 0)
             return ret;
           c->loc[i] = DWARF_VAL_LOC (c, DWARF_GET_LOC (c->loc[i]));
diff --git a/src/x86_64/Gstash_frame.c b/src/x86_64/Gstash_frame.c
index e893227c..2c7bc312 100644
--- a/src/x86_64/Gstash_frame.c
+++ b/src/x86_64/Gstash_frame.c
@@ -34,20 +34,20 @@ tdep_stash_frame (struct dwarf_cursor *d, struct dwarf_reg_state *rs)
   Debug (4, "ip=0x%lx cfa=0x%lx type %d cfa [where=%d val=%ld] cfaoff=%ld"
          " ra=0x%lx rbp [where=%d val=%ld @0x%lx] rsp [where=%d val=%ld @0x%lx]\n",
          d->ip, d->cfa, f->frame_type,
-         rs->where[DWARF_CFA_REG_COLUMN],
-         rs->val[DWARF_CFA_REG_COLUMN],
-         rs->val[DWARF_CFA_OFF_COLUMN],
+         rs->reg.where[DWARF_CFA_REG_COLUMN],
+         rs->reg.val[DWARF_CFA_REG_COLUMN],
+         rs->reg.val[DWARF_CFA_OFF_COLUMN],
          DWARF_GET_LOC(d->loc[rs->ret_addr_column]),
-         rs->where[RBP], rs->val[RBP], DWARF_GET_LOC(d->loc[RBP]),
-         rs->where[RSP], rs->val[RSP], DWARF_GET_LOC(d->loc[RSP]));
+         rs->reg.where[RBP], rs->reg.val[RBP], DWARF_GET_LOC(d->loc[RBP]),
+         rs->reg.where[RSP], rs->reg.val[RSP], DWARF_GET_LOC(d->loc[RSP]));
 
-  if (rs->where[DWARF_CFA_REG_COLUMN] == DWARF_WHERE_EXPR &&
-    rs->where[RBP] == DWARF_WHERE_EXPR) {
+  if (rs->reg.where[DWARF_CFA_REG_COLUMN] == DWARF_WHERE_EXPR &&
+    rs->reg.where[RBP] == DWARF_WHERE_EXPR) {
     /* Check for GCC generated alignment frame for rsp.  A simple
      * def_cfa_expr that loads a constant offset from rbp, where the
      * addres of the rip was pushed on the stack */
-    unw_word_t cfa_addr = rs->val[DWARF_CFA_REG_COLUMN];
-    unw_word_t rbp_addr = rs->val[RBP];
+    unw_word_t cfa_addr = rs->reg.val[DWARF_CFA_REG_COLUMN];
+    unw_word_t rbp_addr = rs->reg.val[RBP];
     unw_word_t cfa_offset;
 
     int ret = dwarf_stack_aligned(d, cfa_addr, rbp_addr, &cfa_offset);
@@ -64,30 +64,30 @@ tdep_stash_frame (struct dwarf_cursor *d, struct dwarf_reg_state *rs)
       - RBP is unsaved or saved at CFA+offset, offset != -1;
       - RSP is unsaved or saved at CFA+offset, offset != -1.  */
   if (f->frame_type == UNW_X86_64_FRAME_OTHER
-      && (rs->where[DWARF_CFA_REG_COLUMN] == DWARF_WHERE_REG)
-      && (rs->val[DWARF_CFA_REG_COLUMN] == RBP
-          || rs->val[DWARF_CFA_REG_COLUMN] == RSP)
-      && labs((long) rs->val[DWARF_CFA_OFF_COLUMN]) < (1 << 28)
+      && (rs->reg.where[DWARF_CFA_REG_COLUMN] == DWARF_WHERE_REG)
+      && (rs->reg.val[DWARF_CFA_REG_COLUMN] == RBP
+          || rs->reg.val[DWARF_CFA_REG_COLUMN] == RSP)
+      && labs((long) rs->reg.val[DWARF_CFA_OFF_COLUMN]) < (1 << 28)
       && DWARF_GET_LOC(d->loc[rs->ret_addr_column]) == d->cfa-8
-      && (rs->where[RBP] == DWARF_WHERE_UNDEF
-          || rs->where[RBP] == DWARF_WHERE_SAME
-          || (rs->where[RBP] == DWARF_WHERE_CFAREL
-              && labs((long) rs->val[RBP]) < (1 << 14)
-              && rs->val[RBP]+1 != 0))
-      && (rs->where[RSP] == DWARF_WHERE_UNDEF
-          || rs->where[RSP] == DWARF_WHERE_SAME
-          || (rs->where[RSP] == DWARF_WHERE_CFAREL
-              && labs((long) rs->val[RSP]) < (1 << 14)
-              && rs->val[RSP]+1 != 0)))
+      && (rs->reg.where[RBP] == DWARF_WHERE_UNDEF
+          || rs->reg.where[RBP] == DWARF_WHERE_SAME
+          || (rs->reg.where[RBP] == DWARF_WHERE_CFAREL
+              && labs((long) rs->reg.val[RBP]) < (1 << 14)
+              && rs->reg.val[RBP]+1 != 0))
+      && (rs->reg.where[RSP] == DWARF_WHERE_UNDEF
+          || rs->reg.where[RSP] == DWARF_WHERE_SAME
+          || (rs->reg.where[RSP] == DWARF_WHERE_CFAREL
+              && labs((long) rs->reg.val[RSP]) < (1 << 14)
+              && rs->reg.val[RSP]+1 != 0)))
   {
     /* Save information for a standard frame. */
     f->frame_type = UNW_X86_64_FRAME_STANDARD;
-    f->cfa_reg_rsp = (rs->val[DWARF_CFA_REG_COLUMN] == RSP);
-    f->cfa_reg_offset = rs->val[DWARF_CFA_OFF_COLUMN];
-    if (rs->where[RBP] == DWARF_WHERE_CFAREL)
-      f->rbp_cfa_offset = rs->val[RBP];
-    if (rs->where[RSP] == DWARF_WHERE_CFAREL)
-      f->rsp_cfa_offset = rs->val[RSP];
+    f->cfa_reg_rsp = (rs->reg.val[DWARF_CFA_REG_COLUMN] == RSP);
+    f->cfa_reg_offset = rs->reg.val[DWARF_CFA_OFF_COLUMN];
+    if (rs->reg.where[RBP] == DWARF_WHERE_CFAREL)
+      f->rbp_cfa_offset = rs->reg.val[RBP];
+    if (rs->reg.where[RSP] == DWARF_WHERE_CFAREL)
+      f->rsp_cfa_offset = rs->reg.val[RSP];
     Debug (4, " standard frame\n");
   }
 
diff --git a/tests/Ltest-init-local-signal.c b/tests/Ltest-init-local-signal.c
index c77ad1ed..b834d44d 100644
--- a/tests/Ltest-init-local-signal.c
+++ b/tests/Ltest-init-local-signal.c
@@ -35,6 +35,7 @@ void handler(int num, siginfo_t* info, void* ucontext) {
   int ucontext_steps = stepper(&c);
 
   ret = unw_init_local(&c, &context);
+  (void)ret;
   assert(!ret);
   int getcontext_steps = stepper(&c);
   if (ucontext_steps == getcontext_steps - 2) {
@@ -54,4 +55,5 @@ int main(){
   sigaction(SIGSEGV, &a, NULL);
 
   foo(NULL);
+  return 0;
 }