0035-target-cris-Avoid-AREG0-for-helpers.patch

   1 From 1e3916b0cbfd39cb3fc8996423d5574068583145 Mon Sep 17 00:00:00 2001
   2 From: Aurelien Jarno <aurelien@aurel32.net>
   3 Date: Thu, 30 Aug 2012 16:56:39 +0200
   4 Subject: [PATCH] target-cris: Avoid AREG0 for helpers
   5
   6 Add an explicit CPUCRISState parameter instead of relying on AREG0.
   7
   8 Signed-off-by: Blue Swirl <blauwirbel@gmail.com>
   9 Signed-off-by: Aurelien Jarno <aurelien@aurel32.net>
  10 Signed-off-by: Michael Roth <mdroth@linux.vnet.ibm.com>
  11 ---
  12  target-cris/helper.h        | 37 +++++++++++----------
  13  target-cris/op_helper.c     | 80 ++++++++++++++++++++++++---------------------
  14  target-cris/translate.c     | 44 +++++++++++++------------
  15  target-cris/translate_v10.c |  4 +--
  16  4 files changed, 88 insertions(+), 77 deletions(-)
  17
  18 diff --git a/target-cris/helper.h b/target-cris/helper.h
  19 index 093063a..99fb326 100644
  20 --- a/target-cris/helper.h
  21 +++ b/target-cris/helper.h
  22 @@ -1,26 +1,29 @@
  23  #include "def-helper.h"
  24
  25 -DEF_HELPER_1(raise_exception, void, i32)
  26 -DEF_HELPER_1(tlb_flush_pid, void, i32)
  27 -DEF_HELPER_1(spc_write, void, i32)
  28 +DEF_HELPER_2(raise_exception, void, env, i32)
  29 +DEF_HELPER_2(tlb_flush_pid, void, env, i32)
  30 +DEF_HELPER_2(spc_write, void, env, i32)
  31  DEF_HELPER_3(dump, void, i32, i32, i32)
  32 -DEF_HELPER_0(rfe, void);
  33 -DEF_HELPER_0(rfn, void);
  34 +DEF_HELPER_1(rfe, void, env);
  35 +DEF_HELPER_1(rfn, void, env);
  36
  37 -DEF_HELPER_2(movl_sreg_reg, void, i32, i32)
  38 -DEF_HELPER_2(movl_reg_sreg, void, i32, i32)
  39 +DEF_HELPER_3(movl_sreg_reg, void, env, i32, i32)
  40 +DEF_HELPER_3(movl_reg_sreg, void, env, i32, i32)
  41
  42  DEF_HELPER_FLAGS_1(lz, TCG_CALL_PURE, i32, i32);
  43 -DEF_HELPER_FLAGS_3(btst, TCG_CALL_PURE, i32, i32, i32, i32);
  44 +DEF_HELPER_FLAGS_4(btst, TCG_CALL_PURE, i32, env, i32, i32, i32);
  45
  46 -DEF_HELPER_FLAGS_3(evaluate_flags_muls, TCG_CALL_PURE, i32, i32, i32, i32)
  47 -DEF_HELPER_FLAGS_3(evaluate_flags_mulu, TCG_CALL_PURE, i32, i32, i32, i32)
  48 -DEF_HELPER_FLAGS_4(evaluate_flags_mcp, TCG_CALL_PURE, i32, i32, i32, i32, i32)
  49 -DEF_HELPER_FLAGS_4(evaluate_flags_alu_4, TCG_CALL_PURE, i32, i32, i32, i32, i32)
  50 -DEF_HELPER_FLAGS_4(evaluate_flags_sub_4, TCG_CALL_PURE, i32, i32, i32, i32, i32)
  51 -DEF_HELPER_FLAGS_2(evaluate_flags_move_4, TCG_CALL_PURE, i32, i32, i32)
  52 -DEF_HELPER_FLAGS_2(evaluate_flags_move_2, TCG_CALL_PURE, i32, i32, i32)
  53 -DEF_HELPER_0(evaluate_flags, void)
  54 -DEF_HELPER_0(top_evaluate_flags, void)
  55 +DEF_HELPER_FLAGS_4(evaluate_flags_muls, TCG_CALL_PURE, i32, env, i32, i32, i32)
  56 +DEF_HELPER_FLAGS_4(evaluate_flags_mulu, TCG_CALL_PURE, i32, env, i32, i32, i32)
  57 +DEF_HELPER_FLAGS_5(evaluate_flags_mcp, TCG_CALL_PURE, i32, env,
  58 +                                                      i32, i32, i32, i32)
  59 +DEF_HELPER_FLAGS_5(evaluate_flags_alu_4, TCG_CALL_PURE, i32, env,
  60 +                                                        i32, i32, i32, i32)
  61 +DEF_HELPER_FLAGS_5(evaluate_flags_sub_4, TCG_CALL_PURE, i32, env,
  62 +                                                        i32, i32, i32, i32)
  63 +DEF_HELPER_FLAGS_3(evaluate_flags_move_4, TCG_CALL_PURE, i32, env, i32, i32)
  64 +DEF_HELPER_FLAGS_3(evaluate_flags_move_2, TCG_CALL_PURE, i32, env, i32, i32)
  65 +DEF_HELPER_1(evaluate_flags, void, env)
  66 +DEF_HELPER_1(top_evaluate_flags, void, env)
  67
  68  #include "def-helper.h"
  69 diff --git a/target-cris/op_helper.c b/target-cris/op_helper.c
  70 index ac7c98c..5ca85a0 100644
  71 --- a/target-cris/op_helper.c
  72 +++ b/target-cris/op_helper.c
  73 @@ -79,7 +79,7 @@ void tlb_fill(CPUCRISState *env1, target_ulong addr, int is_write, int mmu_idx,
  74                  cpu_restore_state(tb, env, retaddr);
  75
  76                 /* Evaluate flags after retranslation.  */
  77 -                helper_top_evaluate_flags();
  78 +                helper_top_evaluate_flags(env);
  79              }
  80          }
  81          cpu_loop_exit(env);
  82 @@ -89,13 +89,13 @@ void tlb_fill(CPUCRISState *env1, target_ulong addr, int is_write, int mmu_idx,
  83
  84  #endif
  85
  86 -void helper_raise_exception(uint32_t index)
  87 +void helper_raise_exception(CPUCRISState *env, uint32_t index)
  88  {
  89         env->exception_index = index;
  90          cpu_loop_exit(env);
  91  }
  92
  93 -void helper_tlb_flush_pid(uint32_t pid)
  94 +void helper_tlb_flush_pid(CPUCRISState *env, uint32_t pid)
  95  {
  96  #if !defined(CONFIG_USER_ONLY)
  97         pid &= 0xff;
  98 @@ -104,7 +104,7 @@ void helper_tlb_flush_pid(uint32_t pid)
  99  #endif
 100  }
 101
 102 -void helper_spc_write(uint32_t new_spc)
 103 +void helper_spc_write(CPUCRISState *env, uint32_t new_spc)
 104  {
 105  #if !defined(CONFIG_USER_ONLY)
 106         tlb_flush_page(env, env->pregs[PR_SPC]);
 107 @@ -121,7 +121,7 @@ void helper_dump(uint32_t a0, uint32_t a1, uint32_t a2)
 108  #define EXTRACT_FIELD(src, start, end) \
 109             (((src) >> start) & ((1 << (end - start + 1)) - 1))
 110
 111 -void helper_movl_sreg_reg (uint32_t sreg, uint32_t reg)
 112 +void helper_movl_sreg_reg(CPUCRISState *env, uint32_t sreg, uint32_t reg)
 113  {
 114         uint32_t srs;
 115         srs = env->pregs[PR_SRS];
 116 @@ -171,7 +171,7 @@ void helper_movl_sreg_reg (uint32_t sreg, uint32_t reg)
 117  #endif
 118  }
 119
 120 -void helper_movl_reg_sreg (uint32_t reg, uint32_t sreg)
 121 +void helper_movl_reg_sreg(CPUCRISState *env, uint32_t reg, uint32_t sreg)
 122  {
 123         uint32_t srs;
 124         env->pregs[PR_SRS] &= 3;
 125 @@ -216,7 +216,7 @@ static void cris_ccs_rshift(CPUCRISState *env)
 126         env->pregs[PR_CCS] = ccs;
 127  }
 128
 129 -void helper_rfe(void)
 130 +void helper_rfe(CPUCRISState *env)
 131  {
 132         int rflag = env->pregs[PR_CCS] & R_FLAG;
 133
 134 @@ -232,7 +232,7 @@ void helper_rfe(void)
 135                 env->pregs[PR_CCS] |= P_FLAG;
 136  }
 137
 138 -void helper_rfn(void)
 139 +void helper_rfn(CPUCRISState *env)
 140  {
 141         int rflag = env->pregs[PR_CCS] & R_FLAG;
 142
 143 @@ -256,7 +256,7 @@ uint32_t helper_lz(uint32_t t0)
 144         return clz32(t0);
 145  }
 146
 147 -uint32_t helper_btst(uint32_t t0, uint32_t t1, uint32_t ccs)
 148 +uint32_t helper_btst(CPUCRISState *env, uint32_t t0, uint32_t t1, uint32_t ccs)
 149  {
 150         /* FIXME: clean this up.  */
 151
 152 @@ -284,7 +284,8 @@ uint32_t helper_btst(uint32_t t0, uint32_t t1, uint32_t ccs)
 153         return ccs;
 154  }
 155
 156 -static inline uint32_t evaluate_flags_writeback(uint32_t flags, uint32_t ccs)
 157 +static inline uint32_t evaluate_flags_writeback(CPUCRISState *env,
 158 +                                                uint32_t flags, uint32_t ccs)
 159  {
 160         unsigned int x, z, mask;
 161
 162 @@ -303,7 +304,8 @@ static inline uint32_t evaluate_flags_writeback(uint32_t flags, uint32_t ccs)
 163         return ccs;
 164  }
 165
 166 -uint32_t helper_evaluate_flags_muls(uint32_t ccs, uint32_t res, uint32_t mof)
 167 +uint32_t helper_evaluate_flags_muls(CPUCRISState *env,
 168 +                                    uint32_t ccs, uint32_t res, uint32_t mof)
 169  {
 170         uint32_t flags = 0;
 171         int64_t tmp;
 172 @@ -321,10 +323,11 @@ uint32_t helper_evaluate_flags_muls(uint32_t ccs, uint32_t res, uint32_t mof)
 173         if ((dneg && mof != -1)
 174             || (!dneg && mof != 0))
 175                 flags |= V_FLAG;
 176 -       return evaluate_flags_writeback(flags, ccs);
 177 +        return evaluate_flags_writeback(env, flags, ccs);
 178  }
 179
 180 -uint32_t helper_evaluate_flags_mulu(uint32_t ccs, uint32_t res, uint32_t mof)
 181 +uint32_t helper_evaluate_flags_mulu(CPUCRISState *env,
 182 +                                    uint32_t ccs, uint32_t res, uint32_t mof)
 183  {
 184         uint32_t flags = 0;
 185         uint64_t tmp;
 186 @@ -339,10 +342,10 @@ uint32_t helper_evaluate_flags_mulu(uint32_t ccs, uint32_t res, uint32_t mof)
 187         if (mof)
 188                 flags |= V_FLAG;
 189
 190 -       return evaluate_flags_writeback(flags, ccs);
 191 +        return evaluate_flags_writeback(env, flags, ccs);
 192  }
 193
 194 -uint32_t helper_evaluate_flags_mcp(uint32_t ccs,
 195 +uint32_t helper_evaluate_flags_mcp(CPUCRISState *env, uint32_t ccs,
 196                                    uint32_t src, uint32_t dst, uint32_t res)
 197  {
 198         uint32_t flags = 0;
 199 @@ -368,10 +371,10 @@ uint32_t helper_evaluate_flags_mcp(uint32_t ccs,
 200                         flags |= R_FLAG;
 201         }
 202
 203 -       return evaluate_flags_writeback(flags, ccs);
 204 +        return evaluate_flags_writeback(env, flags, ccs);
 205  }
 206
 207 -uint32_t helper_evaluate_flags_alu_4(uint32_t ccs,
 208 +uint32_t helper_evaluate_flags_alu_4(CPUCRISState *env, uint32_t ccs,
 209                                      uint32_t src, uint32_t dst, uint32_t res)
 210  {
 211         uint32_t flags = 0;
 212 @@ -397,10 +400,10 @@ uint32_t helper_evaluate_flags_alu_4(uint32_t ccs,
 213                         flags |= C_FLAG;
 214         }
 215
 216 -       return evaluate_flags_writeback(flags, ccs);
 217 +        return evaluate_flags_writeback(env, flags, ccs);
 218  }
 219
 220 -uint32_t helper_evaluate_flags_sub_4(uint32_t ccs,
 221 +uint32_t helper_evaluate_flags_sub_4(CPUCRISState *env, uint32_t ccs,
 222                                      uint32_t src, uint32_t dst, uint32_t res)
 223  {
 224         uint32_t flags = 0;
 225 @@ -427,10 +430,11 @@ uint32_t helper_evaluate_flags_sub_4(uint32_t ccs,
 226         }
 227
 228         flags ^= C_FLAG;
 229 -       return evaluate_flags_writeback(flags, ccs);
 230 +        return evaluate_flags_writeback(env, flags, ccs);
 231  }
 232
 233 -uint32_t helper_evaluate_flags_move_4(uint32_t ccs, uint32_t res)
 234 +uint32_t helper_evaluate_flags_move_4(CPUCRISState *env,
 235 +                                      uint32_t ccs, uint32_t res)
 236  {
 237         uint32_t flags = 0;
 238
 239 @@ -439,9 +443,10 @@ uint32_t helper_evaluate_flags_move_4(uint32_t ccs, uint32_t res)
 240         else if (res == 0L)
 241                 flags |= Z_FLAG;
 242
 243 -       return evaluate_flags_writeback(flags, ccs);
 244 +        return evaluate_flags_writeback(env, flags, ccs);
 245  }
 246 -uint32_t helper_evaluate_flags_move_2(uint32_t ccs, uint32_t res)
 247 +uint32_t helper_evaluate_flags_move_2(CPUCRISState *env,
 248 +                                      uint32_t ccs, uint32_t res)
 249  {
 250         uint32_t flags = 0;
 251
 252 @@ -450,12 +455,12 @@ uint32_t helper_evaluate_flags_move_2(uint32_t ccs, uint32_t res)
 253         else if (res == 0)
 254                 flags |= Z_FLAG;
 255
 256 -       return evaluate_flags_writeback(flags, ccs);
 257 +        return evaluate_flags_writeback(env, flags, ccs);
 258  }
 259
 260  /* TODO: This is expensive. We could split things up and only evaluate part of
 261     CCR on a need to know basis. For now, we simply re-evaluate everything.  */
 262 -void  helper_evaluate_flags(void)
 263 +void helper_evaluate_flags(CPUCRISState *env)
 264  {
 265         uint32_t src, dst, res;
 266         uint32_t flags = 0;
 267 @@ -571,25 +576,26 @@ void  helper_evaluate_flags(void)
 268         if (env->cc_op == CC_OP_SUB || env->cc_op == CC_OP_CMP)
 269                 flags ^= C_FLAG;
 270
 271 -       env->pregs[PR_CCS] = evaluate_flags_writeback(flags, env->pregs[PR_CCS]);
 272 +        env->pregs[PR_CCS] = evaluate_flags_writeback(env, flags,
 273 +                                                      env->pregs[PR_CCS]);
 274  }
 275
 276 -void helper_top_evaluate_flags(void)
 277 +void helper_top_evaluate_flags(CPUCRISState *env)
 278  {
 279         switch (env->cc_op)
 280         {
 281                 case CC_OP_MCP:
 282 -                       env->pregs[PR_CCS] = helper_evaluate_flags_mcp(
 283 +                        env->pregs[PR_CCS] = helper_evaluate_flags_mcp(env,
 284                                         env->pregs[PR_CCS], env->cc_src,
 285                                         env->cc_dest, env->cc_result);
 286                         break;
 287                 case CC_OP_MULS:
 288 -                       env->pregs[PR_CCS] = helper_evaluate_flags_muls(
 289 +                        env->pregs[PR_CCS] = helper_evaluate_flags_muls(env,
 290                                         env->pregs[PR_CCS], env->cc_result,
 291                                         env->pregs[PR_MOF]);
 292                         break;
 293                 case CC_OP_MULU:
 294 -                       env->pregs[PR_CCS] = helper_evaluate_flags_mulu(
 295 +                        env->pregs[PR_CCS] = helper_evaluate_flags_mulu(env,
 296                                         env->pregs[PR_CCS], env->cc_result,
 297                                         env->pregs[PR_MOF]);
 298                         break;
 299 @@ -604,18 +610,18 @@ void helper_top_evaluate_flags(void)
 300                 {
 301                         case 4:
 302                                 env->pregs[PR_CCS] =
 303 -                                       helper_evaluate_flags_move_4(
 304 +                                        helper_evaluate_flags_move_4(env,
 305                                                         env->pregs[PR_CCS],
 306                                                         env->cc_result);
 307                                 break;
 308                         case 2:
 309                                 env->pregs[PR_CCS] =
 310 -                                       helper_evaluate_flags_move_2(
 311 +                                        helper_evaluate_flags_move_2(env,
 312                                                         env->pregs[PR_CCS],
 313                                                         env->cc_result);
 314                                 break;
 315                         default:
 316 -                               helper_evaluate_flags();
 317 +                                helper_evaluate_flags(env);
 318                                 break;
 319                 }
 320                 break;
 321 @@ -626,12 +632,12 @@ void helper_top_evaluate_flags(void)
 322                 case CC_OP_CMP:
 323                         if (env->cc_size == 4)
 324                                 env->pregs[PR_CCS] =
 325 -                                       helper_evaluate_flags_sub_4(
 326 +                                        helper_evaluate_flags_sub_4(env,
 327                                                 env->pregs[PR_CCS],
 328                                                 env->cc_src, env->cc_dest,
 329                                                 env->cc_result);
 330                         else
 331 -                               helper_evaluate_flags();
 332 +                                helper_evaluate_flags(env);
 333                         break;
 334                 default:
 335                 {
 336 @@ -639,13 +645,13 @@ void helper_top_evaluate_flags(void)
 337                         {
 338                         case 4:
 339                                 env->pregs[PR_CCS] =
 340 -                                       helper_evaluate_flags_alu_4(
 341 +                                        helper_evaluate_flags_alu_4(env,
 342                                                 env->pregs[PR_CCS],
 343                                                 env->cc_src, env->cc_dest,
 344                                                 env->cc_result);
 345                                 break;
 346                         default:
 347 -                               helper_evaluate_flags();
 348 +                                helper_evaluate_flags(env);
 349                                 break;
 350                         }
 351                 }
 352 diff --git a/target-cris/translate.c b/target-cris/translate.c
 353 index ad31877..283dd98 100644
 354 --- a/target-cris/translate.c
 355 +++ b/target-cris/translate.c
 356 @@ -211,9 +211,9 @@ static inline void t_gen_mov_preg_TN(DisasContext *dc, int r, TCGv tn)
 357                 tcg_gen_andi_tl(cpu_PR[r], tn, 3);
 358         else {
 359                 if (r == PR_PID)
 360 -                       gen_helper_tlb_flush_pid(tn);
 361 +                        gen_helper_tlb_flush_pid(cpu_env, tn);
 362                 if (dc->tb_flags & S_FLAG && r == PR_SPC)
 363 -                       gen_helper_spc_write(tn);
 364 +                        gen_helper_spc_write(cpu_env, tn);
 365                 else if (r == PR_CCS)
 366                         dc->cpustate_changed = 1;
 367                 tcg_gen_mov_tl(cpu_PR[r], tn);
 368 @@ -278,7 +278,7 @@ static void cris_lock_irq(DisasContext *dc)
 369  static inline void t_gen_raise_exception(uint32_t index)
 370  {
 371          TCGv_i32 tmp = tcg_const_i32(index);
 372 -       gen_helper_raise_exception(tmp);
 373 +        gen_helper_raise_exception(cpu_env, tmp);
 374          tcg_temp_free_i32(tmp);
 375  }
 376
 377 @@ -624,17 +624,17 @@ static void cris_evaluate_flags(DisasContext *dc)
 378         switch (dc->cc_op)
 379         {
 380         case CC_OP_MCP:
 381 -               gen_helper_evaluate_flags_mcp(cpu_PR[PR_CCS],
 382 +                gen_helper_evaluate_flags_mcp(cpu_PR[PR_CCS], cpu_env,
 383                                         cpu_PR[PR_CCS], cc_src,
 384                                         cc_dest, cc_result);
 385                 break;
 386         case CC_OP_MULS:
 387 -               gen_helper_evaluate_flags_muls(cpu_PR[PR_CCS],
 388 +                gen_helper_evaluate_flags_muls(cpu_PR[PR_CCS], cpu_env,
 389                                         cpu_PR[PR_CCS], cc_result,
 390                                         cpu_PR[PR_MOF]);
 391                 break;
 392         case CC_OP_MULU:
 393 -               gen_helper_evaluate_flags_mulu(cpu_PR[PR_CCS],
 394 +                gen_helper_evaluate_flags_mulu(cpu_PR[PR_CCS], cpu_env,
 395                                         cpu_PR[PR_CCS], cc_result,
 396                                         cpu_PR[PR_MOF]);
 397                 break;
 398 @@ -648,15 +648,15 @@ static void cris_evaluate_flags(DisasContext *dc)
 399                 switch (dc->cc_size)
 400                 {
 401                 case 4:
 402 -                       gen_helper_evaluate_flags_move_4(cpu_PR[PR_CCS],
 403 -                                               cpu_PR[PR_CCS], cc_result);
 404 +                        gen_helper_evaluate_flags_move_4(cpu_PR[PR_CCS],
 405 +                                           cpu_env, cpu_PR[PR_CCS], cc_result);
 406                         break;
 407                 case 2:
 408 -                       gen_helper_evaluate_flags_move_2(cpu_PR[PR_CCS],
 409 -                                               cpu_PR[PR_CCS], cc_result);
 410 +                        gen_helper_evaluate_flags_move_2(cpu_PR[PR_CCS],
 411 +                                           cpu_env, cpu_PR[PR_CCS], cc_result);
 412                         break;
 413                 default:
 414 -                       gen_helper_evaluate_flags();
 415 +                        gen_helper_evaluate_flags(cpu_env);
 416                         break;
 417                 }
 418                 break;
 419 @@ -666,21 +666,21 @@ static void cris_evaluate_flags(DisasContext *dc)
 420         case CC_OP_SUB:
 421         case CC_OP_CMP:
 422                 if (dc->cc_size == 4)
 423 -                       gen_helper_evaluate_flags_sub_4(cpu_PR[PR_CCS],
 424 +                        gen_helper_evaluate_flags_sub_4(cpu_PR[PR_CCS], cpu_env,
 425                                 cpu_PR[PR_CCS], cc_src, cc_dest, cc_result);
 426                 else
 427 -                       gen_helper_evaluate_flags();
 428 +                        gen_helper_evaluate_flags(cpu_env);
 429
 430                 break;
 431         default:
 432                 switch (dc->cc_size)
 433                 {
 434                         case 4:
 435 -                       gen_helper_evaluate_flags_alu_4(cpu_PR[PR_CCS],
 436 +                        gen_helper_evaluate_flags_alu_4(cpu_PR[PR_CCS], cpu_env,
 437                                 cpu_PR[PR_CCS], cc_src, cc_dest, cc_result);
 438                                 break;
 439                         default:
 440 -                               gen_helper_evaluate_flags();
 441 +                                gen_helper_evaluate_flags(cpu_env);
 442                                 break;
 443                 }
 444                 break;
 445 @@ -1475,7 +1475,7 @@ static int dec_btstq(DisasContext *dc)
 446
 447         cris_cc_mask(dc, CC_MASK_NZ);
 448         cris_evaluate_flags(dc);
 449 -       gen_helper_btst(cpu_PR[PR_CCS], cpu_R[dc->op2],
 450 +        gen_helper_btst(cpu_PR[PR_CCS], cpu_env, cpu_R[dc->op2],
 451                         tcg_const_tl(dc->op1), cpu_PR[PR_CCS]);
 452         cris_alu(dc, CC_OP_MOVE,
 453                  cpu_R[dc->op2], cpu_R[dc->op2], cpu_R[dc->op2], 4);
 454 @@ -1925,7 +1925,7 @@ static int dec_btst_r(DisasContext *dc)
 455                     dc->op1, dc->op2);
 456         cris_cc_mask(dc, CC_MASK_NZ);
 457         cris_evaluate_flags(dc);
 458 -       gen_helper_btst(cpu_PR[PR_CCS], cpu_R[dc->op2],
 459 +        gen_helper_btst(cpu_PR[PR_CCS], cpu_env, cpu_R[dc->op2],
 460                         cpu_R[dc->op1], cpu_PR[PR_CCS]);
 461         cris_alu(dc, CC_OP_MOVE, cpu_R[dc->op2],
 462                  cpu_R[dc->op2], cpu_R[dc->op2], 4);
 463 @@ -2135,14 +2135,16 @@ static int dec_move_rs(DisasContext *dc)
 464  {
 465         LOG_DIS("move $r%u, $s%u\n", dc->op1, dc->op2);
 466         cris_cc_mask(dc, 0);
 467 -       gen_helper_movl_sreg_reg(tcg_const_tl(dc->op2), tcg_const_tl(dc->op1));
 468 +        gen_helper_movl_sreg_reg(cpu_env, tcg_const_tl(dc->op2),
 469 +                                 tcg_const_tl(dc->op1));
 470         return 2;
 471  }
 472  static int dec_move_sr(DisasContext *dc)
 473  {
 474         LOG_DIS("move $s%u, $r%u\n", dc->op2, dc->op1);
 475         cris_cc_mask(dc, 0);
 476 -       gen_helper_movl_reg_sreg(tcg_const_tl(dc->op1), tcg_const_tl(dc->op2));
 477 +        gen_helper_movl_reg_sreg(cpu_env, tcg_const_tl(dc->op1),
 478 +                                 tcg_const_tl(dc->op2));
 479         return 2;
 480  }
 481
 482 @@ -2906,14 +2908,14 @@ static int dec_rfe_etc(DisasContext *dc)
 483                         /* rfe.  */
 484                         LOG_DIS("rfe\n");
 485                         cris_evaluate_flags(dc);
 486 -                       gen_helper_rfe();
 487 +                        gen_helper_rfe(cpu_env);
 488                         dc->is_jmp = DISAS_UPDATE;
 489                         break;
 490                 case 5:
 491                         /* rfn.  */
 492                         LOG_DIS("rfn\n");
 493                         cris_evaluate_flags(dc);
 494 -                       gen_helper_rfn();
 495 +                        gen_helper_rfn(cpu_env);
 496                         dc->is_jmp = DISAS_UPDATE;
 497                         break;
 498                 case 6:
 499 diff --git a/target-cris/translate_v10.c b/target-cris/translate_v10.c
 500 index 3629629..9a39c6a 100644
 501 --- a/target-cris/translate_v10.c
 502 +++ b/target-cris/translate_v10.c
 503 @@ -289,7 +289,7 @@ static unsigned int dec10_quick_imm(DisasContext *dc)
 504              } else {
 505                  /* BTST */
 506                  cris_update_cc_op(dc, CC_OP_FLAGS, 4);
 507 -                gen_helper_btst(cpu_PR[PR_CCS], cpu_R[dc->dst],
 508 +                gen_helper_btst(cpu_PR[PR_CCS], cpu_env, cpu_R[dc->dst],
 509                             tcg_const_tl(imm), cpu_PR[PR_CCS]);
 510              }
 511              break;
 512 @@ -723,7 +723,7 @@ static unsigned int dec10_reg(DisasContext *dc)
 513                  LOG_DIS("btst $r%d, $r%d sz=%d\n", dc->src, dc->dst, size);
 514                  cris_cc_mask(dc, CC_MASK_NZVC);
 515                  cris_update_cc_op(dc, CC_OP_FLAGS, 4);
 516 -                gen_helper_btst(cpu_PR[PR_CCS], cpu_R[dc->dst],
 517 +                gen_helper_btst(cpu_PR[PR_CCS], cpu_env, cpu_R[dc->dst],
 518                             cpu_R[dc->src], cpu_PR[PR_CCS]);
 519                  break;
 520              case CRISV10_REG_DSTEP:
 521 --
 522 1.7.12.1
 523