--- valgrind/coregrind/m_debuginfo/readdwarf.c.jj	2009-07-13 15:18:35.596080042 +0200

+++ valgrind/coregrind/m_debuginfo/readdwarf.c	2009-07-13 15:54:43.576955651 +0200

@@ -1939,17 +1939,20 @@ typedef

          run_CF_instruction. */

       /* The LOC entry */

       Addr    loc;

-      /* The CFA entry.  This can be either reg+/-offset or an expr. */

-      Bool    cfa_is_regoff; /* True=>is reg+offset; False=>is expr */

-      Int     cfa_reg;

-      Int     cfa_off;  /* in bytes */

-      Int     cfa_expr_ix; /* index into cfa_exprs */

-      /* A stack of register unwind rules.  We need a stack of them,

-         rather than just one set of rules, in order to handle

+      /* We need a stack of these in order to handle

          DW_CFA_{remember,restore}_state. */

-      RegRule reg[N_RR_STACK][N_CFI_REGS];

-      Int     reg_sp; /* 0 <= reg_sp < N_RR_STACK; points at the

-                         currently-in-use rule set. */

+      struct UnwindContextState {

+          /* The CFA entry.  This can be either reg+/-offset or an expr. */

+          Bool    cfa_is_regoff; /* True=>is reg+offset; False=>is expr */

+          Int     cfa_reg;

+          Int     cfa_off;  /* in bytes */

+          Int     cfa_expr_ix; /* index into cfa_exprs */

+          /* Register unwind rules.  */

+          RegRule reg[N_CFI_REGS];

+      }

+      state[N_RR_STACK];

+      Int     state_sp; /* 0 <= state_sp < N_RR_STACK; points at the

+                           currently-in-use rule set. */

       /* array of CfiExpr, shared by reg[] and cfa_expr_ix */

       XArray* exprs;

    }

@@ -1959,18 +1962,20 @@ static void ppUnwindContext ( UnwindCont

 {

    Int j, i;

    VG_(printf)("0x%llx: ", (ULong)ctx->loc);

-   if (ctx->cfa_is_regoff) {

-      VG_(printf)("%d(r%d) ",  ctx->cfa_off, ctx->cfa_reg);

-   } else {

-      vg_assert(ctx->exprs);

-      VG_(printf)("{");

-      ML_(ppCfiExpr)( ctx->exprs, ctx->cfa_expr_ix );

-      VG_(printf)("} ");

-   }

-   for (j = 0; j <= ctx->reg_sp; j++) {

+   for (j = 0; j <= ctx->state_sp; j++) {

+      struct UnwindContextState* ctxs = &ctx->state[j];

       VG_(printf)("%s[%d]={ ", j > 0 ? " " : "", j);

+      if (ctxs->cfa_is_regoff) {

+         VG_(printf)("%d(r%d) ", ctxs->cfa_off, ctxs->cfa_reg);

+      } else {

+         vg_assert(ctx->exprs);

+         VG_(printf)("{");

+         ML_(ppCfiExpr)( ctx->exprs, ctxs->cfa_expr_ix );

+         VG_(printf)("} ");

+      }

+      VG_(printf)("{ ");

       for (i = 0; i < N_CFI_REGS; i++)

-         ppRegRule(ctx->exprs, &ctx->reg[j][i]);

+         ppRegRule(ctx->exprs, &ctxs->reg[i]);

       VG_(printf)("}");

    }

    VG_(printf)("\n");

@@ -1980,21 +1985,22 @@ static void initUnwindContext ( /*OUT*/U

 {

    Int j, i;

    VG_(memset)(ctx, 0, sizeof(*ctx));

-   ctx->code_a_f      = 0;

+   /* ctx->code_a_f   = 0;

    ctx->data_a_f      = 0;

-   ctx->initloc       = 0;

+   ctx->initloc       = 0; */

    ctx->ra_reg        = RA_REG_DEFAULT;

-   ctx->loc           = 0;

-   ctx->cfa_is_regoff = True;

-   ctx->cfa_reg       = 0;

-   ctx->cfa_off       = 0;

-   ctx->cfa_expr_ix   = 0;

+   /* ctx->loc        = 0;

    ctx->exprs         = NULL;

-   ctx->reg_sp        = 0;

+   ctx->state_sp        = 0; */

    for (j = 0; j < N_RR_STACK; j++) {

+      ctx->state[j].cfa_is_regoff = True;

+      /* ctx->state[j].cfa_reg    = 0;

+      ctx->state[j].cfa_off       = 0;

+      ctx->state[j].cfa_expr_ix   = 0; */

       for (i = 0; i < N_CFI_REGS; i++) {

-         ctx->reg[j][i].tag = RR_Undef;

-         ctx->reg[j][i].arg = 0;

+         if (RR_Undef != 0)

+           ctx->state[j].reg[i].tag = RR_Undef;

+         /* ctx->state[j].reg[i].arg = 0; */

       }

    }

 }

@@ -2048,10 +2054,17 @@ static Bool summarise_context( /*OUT*/Di

                                struct _DebugInfo* debuginfo )

 {

    Int why = 0;

+   struct UnwindContextState* ctxs;

    initCfiSI(si);

+   /* Guard against obviously stupid settings of the reg-rule stack

+      pointer. */

+   if (ctx->state_sp < 0)           { why = 8; goto failed; }

+   if (ctx->state_sp >= N_RR_STACK) { why = 9; goto failed; }

+   ctxs = &ctx->state[ctx->state_sp];

+

    /* How to generate the CFA */

-   if (!ctx->cfa_is_regoff) {

+   if (!ctxs->cfa_is_regoff) {

       /* it was set by DW_CFA_def_cfa_expression; try to convert */

       XArray *src, *dst;

       Int    conv;

@@ -2064,7 +2077,7 @@ static Bool summarise_context( /*OUT*/Di

          debuginfo->cfsi_exprs = dst;

       }

       conv = copy_convert_CfiExpr_tree

-                    ( dst, ctx, ctx->cfa_expr_ix );

+                    ( dst, ctx, ctxs->cfa_expr_ix );

       vg_assert(conv >= -1);

       if (conv == -1) { why = 6; goto failed; }

       si->cfa_how = CFIC_EXPR;

@@ -2072,13 +2085,13 @@ static Bool summarise_context( /*OUT*/Di

       if (0 && debuginfo->ddump_frames)

          ML_(ppCfiExpr)(dst, conv);

    } else

-   if (ctx->cfa_is_regoff && ctx->cfa_reg == SP_REG) {

+   if (ctxs->cfa_is_regoff && ctxs->cfa_reg == SP_REG) {

       si->cfa_how = CFIC_SPREL;

-      si->cfa_off = ctx->cfa_off;

+      si->cfa_off = ctxs->cfa_off;

    } else

-   if (ctx->cfa_is_regoff && ctx->cfa_reg == FP_REG) {

+   if (ctxs->cfa_is_regoff && ctxs->cfa_reg == FP_REG) {

       si->cfa_how = CFIC_FPREL;

-      si->cfa_off = ctx->cfa_off;

+      si->cfa_off = ctxs->cfa_off;

    } else {

       why = 1;

       goto failed;

@@ -2121,15 +2134,10 @@ static Bool summarise_context( /*OUT*/Di

          why = 2; goto failed; /* otherwise give up */        \

    }

-   /* Guard against obviously stupid settings of the reg-rule stack

-      pointer. */

-   if (ctx->reg_sp < 0)           { why = 8; goto failed; }

-   if (ctx->reg_sp >= N_RR_STACK) { why = 9; goto failed; }

-

    SUMMARISE_HOW(si->ra_how, si->ra_off,

-                             ctx->reg[ctx->reg_sp][ctx->ra_reg] );

+                             ctxs->reg[ctx->ra_reg] );

    SUMMARISE_HOW(si->fp_how, si->fp_off,

-                             ctx->reg[ctx->reg_sp][FP_REG] );

+                             ctxs->reg[FP_REG] );

 #  undef SUMMARISE_HOW

@@ -2140,7 +2148,7 @@ static Bool summarise_context( /*OUT*/Di

    /* also, gcc says "Undef" for %{e,r}bp when it is unchanged.  So

       .. */

-   if (ctx->reg[ctx->reg_sp][FP_REG].tag == RR_Undef)

+   if (ctxs->reg[FP_REG].tag == RR_Undef)

       si->fp_how = CFIR_SAME;

    /* knock out some obviously stupid cases */

@@ -2227,22 +2235,24 @@ static Int copy_convert_CfiExpr_tree ( X

 static void ppUnwindContext_summary ( UnwindContext* ctx )

 {

+   struct UnwindContextState* ctxs = &ctx->state[ctx->state_sp];

+

    VG_(printf)("0x%llx-1: ", (ULong)ctx->loc);

-   if (ctx->cfa_reg == SP_REG) {

-      VG_(printf)("SP/CFA=%d+SP   ", ctx->cfa_off);

+   if (ctxs->cfa_reg == SP_REG) {

+      VG_(printf)("SP/CFA=%d+SP   ", ctxs->cfa_off);

    } else

-   if (ctx->cfa_reg == FP_REG) {

-      VG_(printf)("SP/CFA=%d+FP   ", ctx->cfa_off);

+   if (ctxs->cfa_reg == FP_REG) {

+      VG_(printf)("SP/CFA=%d+FP   ", ctxs->cfa_off);

    } else {

       VG_(printf)("SP/CFA=unknown  ");

    }

    VG_(printf)("RA=");

-   ppRegRule( ctx->exprs, &ctx->reg[ctx->reg_sp][ctx->ra_reg] );

+   ppRegRule( ctx->exprs, &ctxs->reg[ctx->ra_reg] );

    VG_(printf)("FP=");

-   ppRegRule( ctx->exprs, &ctx->reg[ctx->reg_sp][FP_REG] );

+   ppRegRule( ctx->exprs, &ctxs->reg[FP_REG] );

    VG_(printf)("\n");

 }

@@ -2510,6 +2520,7 @@ static Int dwarfexpr_to_dag ( UnwindCont

    Int sp; /* # of top element: valid is -1 .. N_EXPR_STACK-1 */

    Int stack[N_EXPR_STACK];  /* indices into ctx->exprs */

+   struct UnwindContextState* ctxs = &ctx->state[ctx->state_sp];

    XArray* dst   = ctx->exprs;

    UChar*  limit = expr + exprlen;

@@ -2521,17 +2532,17 @@ static Int dwarfexpr_to_dag ( UnwindCont

    /* Synthesise the CFA as a CfiExpr */

    if (push_cfa_at_start) {

-      if (ctx->cfa_is_regoff) {

+      if (ctxs->cfa_is_regoff) {

          /* cfa is reg +/- offset */

          ix = ML_(CfiExpr_Binop)( dst,

                  Cop_Add,

-                 ML_(CfiExpr_DwReg)( dst, ctx->cfa_reg ),

-                 ML_(CfiExpr_Const)( dst, (UWord)(Word)ctx->cfa_off )

+                 ML_(CfiExpr_DwReg)( dst, ctxs->cfa_reg ),

+                 ML_(CfiExpr_Const)( dst, (UWord)(Word)ctxs->cfa_off )

               );

          PUSH(ix);

       } else {

          /* CFA is already an expr; use its root node */

-         PUSH(ctx->cfa_expr_ix);

+         PUSH(ctxs->cfa_expr_ix);

       }

    }

@@ -2686,11 +2697,13 @@ static Int run_CF_instruction ( /*MOD*/U

    UChar  hi2 = (instr[i] >> 6) & 3;

    UChar  lo6 = instr[i] & 0x3F;

    Addr   printing_bias = ((Addr)ctx->initloc) - ((Addr)di->text_bias);

+   struct UnwindContextState* ctxs;

    i++;

-   if (ctx->reg_sp < 0 || ctx->reg_sp >= N_RR_STACK)

+   if (ctx->state_sp < 0 || ctx->state_sp >= N_RR_STACK)

       return 0; /* bogus reg-rule stack pointer */

+   ctxs = &ctx->state[ctx->state_sp];

    if (hi2 == DW_CFA_advance_loc) {

       delta = (UInt)lo6;

       ctx->loc += delta;

@@ -2707,13 +2720,13 @@ static Int run_CF_instruction ( /*MOD*/U

       reg = (Int)lo6;

       if (reg < 0 || reg >= N_CFI_REGS) 

          return 0; /* fail */

-      ctx->reg[ctx->reg_sp][reg].tag = RR_CFAOff;

-      ctx->reg[ctx->reg_sp][reg].arg = off * ctx->data_a_f;

+      ctxs->reg[reg].tag = RR_CFAOff;

+      ctxs->reg[reg].arg = off * ctx->data_a_f;

       if (di->ddump_frames)

          VG_(printf)("  DW_CFA_offset: r%d at cfa%s%d\n",

                      (Int)reg,

-                     ctx->reg[ctx->reg_sp][reg].arg < 0 ? "" : "+", 

-                     (Int)ctx->reg[ctx->reg_sp][reg].arg );

+                     ctxs->reg[reg].arg < 0 ? "" : "+", 

+                     (Int)ctxs->reg[reg].arg );

       return i;

    }

@@ -2723,7 +2736,7 @@ static Int run_CF_instruction ( /*MOD*/U

          return 0; /* fail */

       if (restore_ctx == NULL)

          return 0; /* fail */

-      ctx->reg[ctx->reg_sp][reg] = restore_ctx->reg[ctx->reg_sp][reg];

+      ctxs->reg[reg] = restore_ctx->state[restore_ctx->state_sp].reg[reg];

       if (di->ddump_frames)

          VG_(printf)("  DW_CFA_restore: r%d\n", (Int)reg);

       return i;

@@ -2777,10 +2791,10 @@ static Int run_CF_instruction ( /*MOD*/U

          i += nleb;

          if (reg < 0 || reg >= N_CFI_REGS) 

             return 0; /* fail */

-         ctx->cfa_is_regoff = True;

-         ctx->cfa_expr_ix   = 0;

-         ctx->cfa_reg       = reg;

-         ctx->cfa_off       = off;

+         ctxs->cfa_is_regoff = True;

+         ctxs->cfa_expr_ix   = 0;

+         ctxs->cfa_reg       = reg;

+         ctxs->cfa_off       = off;

          if (di->ddump_frames)

             VG_(printf)("  DW_CFA_def_cfa: r%d ofs %d\n", (Int)reg, (Int)off);

          break;

@@ -2792,10 +2806,10 @@ static Int run_CF_instruction ( /*MOD*/U

          i += nleb;

          if (reg < 0 || reg >= N_CFI_REGS)

             return 0; /* fail */

-         ctx->cfa_is_regoff = True;

-         ctx->cfa_expr_ix   = 0;

-         ctx->cfa_reg       = reg;

-         ctx->cfa_off       = off * ctx->data_a_f;

+         ctxs->cfa_is_regoff = True;

+         ctxs->cfa_expr_ix   = 0;

+         ctxs->cfa_reg       = reg;

+         ctxs->cfa_off       = off * ctx->data_a_f;

          if (di->ddump_frames)

             VG_(printf)("  rci:DW_CFA_def_cfa_sf\n");

          break;

@@ -2809,8 +2823,8 @@ static Int run_CF_instruction ( /*MOD*/U

             return 0; /* fail */

          if (reg2 < 0 || reg2 >= N_CFI_REGS) 

             return 0; /* fail */

-         ctx->reg[ctx->reg_sp][reg].tag = RR_Reg;

-         ctx->reg[ctx->reg_sp][reg].arg = reg2;

+         ctxs->reg[reg].tag = RR_Reg;

+         ctxs->reg[reg].arg = reg2;

          if (di->ddump_frames)

             VG_(printf)("  DW_CFA_register: r%d in r%d\n", 

                         (Int)reg, (Int)reg2);

@@ -2823,8 +2837,8 @@ static Int run_CF_instruction ( /*MOD*/U

          i += nleb;

          if (reg < 0 || reg >= N_CFI_REGS)

             return 0; /* fail */

-         ctx->reg[ctx->reg_sp][reg].tag = RR_CFAOff;

-         ctx->reg[ctx->reg_sp][reg].arg = off * ctx->data_a_f;

+         ctxs->reg[reg].tag = RR_CFAOff;

+         ctxs->reg[reg].arg = off * ctx->data_a_f;

          if (di->ddump_frames)

             VG_(printf)("  rci:DW_CFA_offset_extended\n");

          break;

@@ -2836,13 +2850,13 @@ static Int run_CF_instruction ( /*MOD*/U

          i += nleb;

          if (reg < 0 || reg >= N_CFI_REGS) 

             return 0; /* fail */

-         ctx->reg[ctx->reg_sp][reg].tag = RR_CFAOff;

-         ctx->reg[ctx->reg_sp][reg].arg = off * ctx->data_a_f;

+         ctxs->reg[reg].tag = RR_CFAOff;

+         ctxs->reg[reg].arg = off * ctx->data_a_f;

          if (di->ddump_frames)

             VG_(printf)("  DW_CFA_offset_extended_sf: r%d at cfa%s%d\n", 

                         reg,

-                        ctx->reg[ctx->reg_sp][reg].arg < 0 ? "" : "+", 

-                        (Int)ctx->reg[ctx->reg_sp][reg].arg);

+                        ctxs->reg[reg].arg < 0 ? "" : "+", 

+                        (Int)ctxs->reg[reg].arg);

          break;

       case DW_CFA_GNU_negative_offset_extended:

@@ -2852,8 +2866,8 @@ static Int run_CF_instruction ( /*MOD*/U

          i += nleb;

          if (reg < 0 || reg >= N_CFI_REGS)

             return 0; /* fail */

-         ctx->reg[ctx->reg_sp][reg].tag = RR_CFAOff;

-         ctx->reg[ctx->reg_sp][reg].arg = (-off) * ctx->data_a_f;

+         ctxs->reg[reg].tag = RR_CFAOff;

+         ctxs->reg[reg].arg = (-off) * ctx->data_a_f;

          if (di->ddump_frames)

             VG_(printf)("  rci:DW_CFA_GNU_negative_offset_extended\n");

          break;

@@ -2865,7 +2879,7 @@ static Int run_CF_instruction ( /*MOD*/U

             return 0; /* fail */

 	 if (restore_ctx == NULL)

 	    return 0; /* fail */

-	 ctx->reg[ctx->reg_sp][reg] = restore_ctx->reg[ctx->reg_sp][reg];

+	 ctxs->reg[reg] = restore_ctx->state[restore_ctx->state_sp].reg[reg];

          if (di->ddump_frames)

             VG_(printf)("  rci:DW_CFA_restore_extended\n");

          break;

@@ -2877,8 +2891,8 @@ static Int run_CF_instruction ( /*MOD*/U

          i += nleb;

          if (reg < 0 || reg >= N_CFI_REGS)

             return 0; /* fail */

-         ctx->reg[ctx->reg_sp][reg].tag = RR_CFAValOff;

-         ctx->reg[ctx->reg_sp][reg].arg = off * ctx->data_a_f;

+         ctxs->reg[reg].tag = RR_CFAValOff;

+         ctxs->reg[reg].arg = off * ctx->data_a_f;

          if (di->ddump_frames)

             VG_(printf)("  rci:DW_CFA_val_offset\n");

          break;

@@ -2890,8 +2904,8 @@ static Int run_CF_instruction ( /*MOD*/U

          i += nleb;

          if (reg < 0 || reg >= N_CFI_REGS)

             return 0; /* fail */

-         ctx->reg[ctx->reg_sp][reg].tag = RR_CFAValOff;

-         ctx->reg[ctx->reg_sp][reg].arg = off * ctx->data_a_f;

+         ctxs->reg[reg].tag = RR_CFAValOff;

+         ctxs->reg[reg].arg = off * ctx->data_a_f;

          if (di->ddump_frames)

             VG_(printf)("  rci:DW_CFA_val_offset_sf\n");

          break;

@@ -2901,9 +2915,9 @@ static Int run_CF_instruction ( /*MOD*/U

          i += nleb;

          if (reg < 0 || reg >= N_CFI_REGS) 

             return 0; /* fail */

-         ctx->cfa_is_regoff = True;

-         ctx->cfa_expr_ix   = 0;

-         ctx->cfa_reg       = reg;

+         ctxs->cfa_is_regoff = True;

+         ctxs->cfa_expr_ix   = 0;

+         ctxs->cfa_reg       = reg;

          /* ->cfa_off unchanged */

          if (di->ddump_frames)

             VG_(printf)("  DW_CFA_def_cfa_reg: r%d\n", (Int)reg );

@@ -2912,10 +2926,10 @@ static Int run_CF_instruction ( /*MOD*/U

       case DW_CFA_def_cfa_offset:

          off = read_leb128( &instr[i], &nleb, 0);

          i += nleb;

-         ctx->cfa_is_regoff = True;

-         ctx->cfa_expr_ix   = 0;

+         ctxs->cfa_is_regoff = True;

+         ctxs->cfa_expr_ix   = 0;

          /* ->reg is unchanged */

-         ctx->cfa_off       = off;

+         ctxs->cfa_off       = off;

          if (di->ddump_frames)

             VG_(printf)("  DW_CFA_def_cfa_offset: %d\n", (Int)off);

          break;

@@ -2923,12 +2937,12 @@ static Int run_CF_instruction ( /*MOD*/U

       case DW_CFA_def_cfa_offset_sf:

          off = read_leb128( &instr[i], &nleb, 1);

          i += nleb;

-         ctx->cfa_is_regoff = True;

-         ctx->cfa_expr_ix   = 0;

+         ctxs->cfa_is_regoff = True;

+         ctxs->cfa_expr_ix   = 0;

          /* ->reg is unchanged */

-         ctx->cfa_off       = off * ctx->data_a_f;

+         ctxs->cfa_off       = off * ctx->data_a_f;

          if (di->ddump_frames)

-            VG_(printf)("  DW_CFA_def_cfa_offset_sf: %d\n", ctx->cfa_off);

+            VG_(printf)("  DW_CFA_def_cfa_offset_sf: %d\n", ctxs->cfa_off);

          break;

       case DW_CFA_undefined:

@@ -2936,8 +2950,8 @@ static Int run_CF_instruction ( /*MOD*/U

          i += nleb;

          if (reg < 0 || reg >= N_CFI_REGS) 

             return 0; /* fail */

-         ctx->reg[ctx->reg_sp][reg].tag = RR_Undef;

-         ctx->reg[ctx->reg_sp][reg].arg = 0;

+         ctxs->reg[reg].tag = RR_Undef;

+         ctxs->reg[reg].arg = 0;

          if (di->ddump_frames)

             VG_(printf)("  rci:DW_CFA_undefined\n");

          break;

@@ -2981,8 +2995,8 @@ static Int run_CF_instruction ( /*MOD*/U

             return 0; /* fail */

          /* Add an extra dereference */

          j = ML_(CfiExpr_Deref)( ctx->exprs, j );

-         ctx->reg[ctx->reg_sp][reg].tag = RR_ValExpr;

-         ctx->reg[ctx->reg_sp][reg].arg = j;

+         ctxs->reg[reg].tag = RR_ValExpr;

+         ctxs->reg[reg].arg = j;

          break;

       case DW_CFA_val_expression:

@@ -3010,8 +3024,8 @@ static Int run_CF_instruction ( /*MOD*/U

          }

          if (j == -1)

             return 0; /* fail */

-         ctx->reg[ctx->reg_sp][reg].tag = RR_ValExpr;

-         ctx->reg[ctx->reg_sp][reg].arg = j;

+         ctxs->reg[reg].tag = RR_ValExpr;

+         ctxs->reg[reg].arg = j;

          break;

       case DW_CFA_def_cfa_expression:

@@ -3027,10 +3041,10 @@ static Int run_CF_instruction ( /*MOD*/U

                                 di->ddump_frames);

          if (di->ddump_frames)

             VG_(printf)(")\n");

-         ctx->cfa_is_regoff = False;

-         ctx->cfa_reg       = 0;

-         ctx->cfa_off       = 0;

-         ctx->cfa_expr_ix   = j;

+         ctxs->cfa_is_regoff = False;

+         ctxs->cfa_reg       = 0;

+         ctxs->cfa_off       = 0;

+         ctxs->cfa_expr_ix   = j;

          break;

       case DW_CFA_GNU_window_save:

@@ -3044,17 +3058,17 @@ static Int run_CF_instruction ( /*MOD*/U

          if (di->ddump_frames)

             VG_(printf)("  DW_CFA_remember_state\n");

          /* we just checked this at entry, so: */

-         vg_assert(ctx->reg_sp >= 0 && ctx->reg_sp < N_RR_STACK);

-         ctx->reg_sp++;

-         if (ctx->reg_sp == N_RR_STACK) {

+         vg_assert(ctx->state_sp >= 0 && ctx->state_sp < N_RR_STACK);

+         ctx->state_sp++;

+         if (ctx->state_sp == N_RR_STACK) {

             /* stack overflow.  We're hosed. */

             VG_(message)(Vg_DebugMsg, "DWARF2 CFI reader: N_RR_STACK is "

                                       "too low; increase and recompile.");

             i = 0; /* indicate failure */

          } else {

-            VG_(memcpy)(/*dst*/&ctx->reg[ctx->reg_sp],

-                        /*src*/&ctx->reg[ctx->reg_sp - 1],

-                        sizeof(ctx->reg[ctx->reg_sp]) );

+            VG_(memcpy)(/*dst*/&ctx->state[ctx->state_sp],

+                        /*src*/&ctx->state[ctx->state_sp - 1],

+                        sizeof(ctx->state[ctx->state_sp]) );

          }

          break;

@@ -3062,13 +3076,13 @@ static Int run_CF_instruction ( /*MOD*/U

          if (di->ddump_frames)

             VG_(printf)("  DW_CFA_restore_state\n");

          /* we just checked this at entry, so: */

-         vg_assert(ctx->reg_sp >= 0 && ctx->reg_sp < N_RR_STACK);

-         if (ctx->reg_sp == 0) {

+         vg_assert(ctx->state_sp >= 0 && ctx->state_sp < N_RR_STACK);

+         if (ctx->state_sp == 0) {

             /* stack overflow.  Give up. */

             i = 0; /* indicate failure */

          } else {

             /* simply fall back to previous entry */

-            ctx->reg_sp--;

+            ctx->state_sp--;

          }

          break;