0029-target-m68k-avoid-using-cpu_single_env.patch

   1 From 5560cd783146734a60c446f43227044cbb580edd Mon Sep 17 00:00:00 2001
   2 From: Blue Swirl <blauwirbel@gmail.com>
   3 Date: Sat, 8 Sep 2012 10:48:20 +0000
   4 Subject: [PATCH] target-m68k: avoid using cpu_single_env
   5
   6 Pass around CPUState instead of using global cpu_single_env.
   7
   8 Signed-off-by: Blue Swirl <blauwirbel@gmail.com>
   9 Signed-off-by: Michael Roth <mdroth@linux.vnet.ibm.com>
  10 ---
  11  target-m68k/translate.c | 270 +++++++++++++++++++++++++-----------------------
  12  1 file changed, 140 insertions(+), 130 deletions(-)
  13
  14 diff --git a/target-m68k/translate.c b/target-m68k/translate.c
  15 index 10bb303..fb707f2 100644
  16 --- a/target-m68k/translate.c
  17 +++ b/target-m68k/translate.c
  18 @@ -150,18 +150,24 @@ static void *gen_throws_exception;
  19  #define OS_SINGLE 4
  20  #define OS_DOUBLE 5
  21
  22 -typedef void (*disas_proc)(DisasContext *, uint16_t);
  23 +typedef void (*disas_proc)(CPUM68KState *env, DisasContext *s, uint16_t insn);
  24
  25  #ifdef DEBUG_DISPATCH
  26 -#define DISAS_INSN(name) \
  27 -  static void real_disas_##name (DisasContext *s, uint16_t insn); \
  28 -  static void disas_##name (DisasContext *s, uint16_t insn) { \
  29 -    qemu_log("Dispatch " #name "\n"); \
  30 -    real_disas_##name(s, insn); } \
  31 -  static void real_disas_##name (DisasContext *s, uint16_t insn)
  32 +#define DISAS_INSN(name)                                                \
  33 +    static void real_disas_##name(CPUM68KState *env, DisasContext *s,   \
  34 +                                  uint16_t insn);                       \
  35 +    static void disas_##name(CPUM68KState *env, DisasContext *s,        \
  36 +                             uint16_t insn)                             \
  37 +    {                                                                   \
  38 +        qemu_log("Dispatch " #name "\n");                               \
  39 +        real_disas_##name(s, env, insn);                                \
  40 +    }                                                                   \
  41 +    static void real_disas_##name(CPUM68KState *env, DisasContext *s,   \
  42 +                                  uint16_t insn)
  43  #else
  44 -#define DISAS_INSN(name) \
  45 -  static void disas_##name (DisasContext *s, uint16_t insn)
  46 +#define DISAS_INSN(name)                                                \
  47 +    static void disas_##name(CPUM68KState *env, DisasContext *s,        \
  48 +                             uint16_t insn)
  49  #endif
  50
  51  /* Generate a load from the specified address.  Narrow values are
  52 @@ -257,12 +263,12 @@ static TCGv gen_ldst(DisasContext *s, int opsize, TCGv addr, TCGv val,
  53  }
  54
  55  /* Read a 32-bit immediate constant.  */
  56 -static inline uint32_t read_im32(DisasContext *s)
  57 +static inline uint32_t read_im32(CPUM68KState *env, DisasContext *s)
  58  {
  59      uint32_t im;
  60 -    im = ((uint32_t)cpu_lduw_code(cpu_single_env, s->pc)) << 16;
  61 +    im = ((uint32_t)cpu_lduw_code(env, s->pc)) << 16;
  62      s->pc += 2;
  63 -    im |= cpu_lduw_code(cpu_single_env, s->pc);
  64 +    im |= cpu_lduw_code(env, s->pc);
  65      s->pc += 2;
  66      return im;
  67  }
  68 @@ -288,7 +294,8 @@ static TCGv gen_addr_index(uint16_t ext, TCGv tmp)
  69
  70  /* Handle a base + index + displacement effective addresss.
  71     A NULL_QREG base means pc-relative.  */
  72 -static TCGv gen_lea_indexed(DisasContext *s, int opsize, TCGv base)
  73 +static TCGv gen_lea_indexed(CPUM68KState *env, DisasContext *s, int opsize,
  74 +                            TCGv base)
  75  {
  76      uint32_t offset;
  77      uint16_t ext;
  78 @@ -297,7 +304,7 @@ static TCGv gen_lea_indexed(DisasContext *s, int opsize, TCGv base)
  79      uint32_t bd, od;
  80
  81      offset = s->pc;
  82 -    ext = cpu_lduw_code(cpu_single_env, s->pc);
  83 +    ext = cpu_lduw_code(env, s->pc);
  84      s->pc += 2;
  85
  86      if ((ext & 0x800) == 0 && !m68k_feature(s->env, M68K_FEATURE_WORD_INDEX))
  87 @@ -311,10 +318,10 @@ static TCGv gen_lea_indexed(DisasContext *s, int opsize, TCGv base)
  88          if ((ext & 0x30) > 0x10) {
  89              /* base displacement */
  90              if ((ext & 0x30) == 0x20) {
  91 -                bd = (int16_t)cpu_lduw_code(cpu_single_env, s->pc);
  92 +                bd = (int16_t)cpu_lduw_code(env, s->pc);
  93                  s->pc += 2;
  94              } else {
  95 -                bd = read_im32(s);
  96 +                bd = read_im32(env, s);
  97              }
  98          } else {
  99              bd = 0;
 100 @@ -360,10 +367,10 @@ static TCGv gen_lea_indexed(DisasContext *s, int opsize, TCGv base)
 101              if ((ext & 3) > 1) {
 102                  /* outer displacement */
 103                  if ((ext & 3) == 2) {
 104 -                    od = (int16_t)cpu_lduw_code(cpu_single_env, s->pc);
 105 +                    od = (int16_t)cpu_lduw_code(env, s->pc);
 106                      s->pc += 2;
 107                  } else {
 108 -                    od = read_im32(s);
 109 +                    od = read_im32(env, s);
 110                  }
 111              } else {
 112                  od = 0;
 113 @@ -492,7 +499,8 @@ static inline TCGv gen_extend(TCGv val, int opsize, int sign)
 114
 115  /* Generate code for an "effective address".  Does not adjust the base
 116     register for autoincrement addressing modes.  */
 117 -static TCGv gen_lea(DisasContext *s, uint16_t insn, int opsize)
 118 +static TCGv gen_lea(CPUM68KState *env, DisasContext *s, uint16_t insn,
 119 +                    int opsize)
 120  {
 121      TCGv reg;
 122      TCGv tmp;
 123 @@ -514,29 +522,29 @@ static TCGv gen_lea(DisasContext *s, uint16_t insn, int opsize)
 124      case 5: /* Indirect displacement.  */
 125          reg = AREG(insn, 0);
 126          tmp = tcg_temp_new();
 127 -        ext = cpu_lduw_code(cpu_single_env, s->pc);
 128 +        ext = cpu_lduw_code(env, s->pc);
 129          s->pc += 2;
 130          tcg_gen_addi_i32(tmp, reg, (int16_t)ext);
 131          return tmp;
 132      case 6: /* Indirect index + displacement.  */
 133          reg = AREG(insn, 0);
 134 -        return gen_lea_indexed(s, opsize, reg);
 135 +        return gen_lea_indexed(env, s, opsize, reg);
 136      case 7: /* Other */
 137          switch (insn & 7) {
 138          case 0: /* Absolute short.  */
 139 -            offset = cpu_ldsw_code(cpu_single_env, s->pc);
 140 +            offset = cpu_ldsw_code(env, s->pc);
 141              s->pc += 2;
 142              return tcg_const_i32(offset);
 143          case 1: /* Absolute long.  */
 144 -            offset = read_im32(s);
 145 +            offset = read_im32(env, s);
 146              return tcg_const_i32(offset);
 147          case 2: /* pc displacement  */
 148              offset = s->pc;
 149 -            offset += cpu_ldsw_code(cpu_single_env, s->pc);
 150 +            offset += cpu_ldsw_code(env, s->pc);
 151              s->pc += 2;
 152              return tcg_const_i32(offset);
 153          case 3: /* pc index+displacement.  */
 154 -            return gen_lea_indexed(s, opsize, NULL_QREG);
 155 +            return gen_lea_indexed(env, s, opsize, NULL_QREG);
 156          case 4: /* Immediate.  */
 157          default:
 158              return NULL_QREG;
 159 @@ -548,15 +556,16 @@ static TCGv gen_lea(DisasContext *s, uint16_t insn, int opsize)
 160
 161  /* Helper function for gen_ea. Reuse the computed address between the
 162     for read/write operands.  */
 163 -static inline TCGv gen_ea_once(DisasContext *s, uint16_t insn, int opsize,
 164 -                              TCGv val, TCGv *addrp, ea_what what)
 165 +static inline TCGv gen_ea_once(CPUM68KState *env, DisasContext *s,
 166 +                               uint16_t insn, int opsize, TCGv val,
 167 +                               TCGv *addrp, ea_what what)
 168  {
 169      TCGv tmp;
 170
 171      if (addrp && what == EA_STORE) {
 172          tmp = *addrp;
 173      } else {
 174 -        tmp = gen_lea(s, insn, opsize);
 175 +        tmp = gen_lea(env, s, insn, opsize);
 176          if (IS_NULL_QREG(tmp))
 177              return tmp;
 178          if (addrp)
 179 @@ -568,8 +577,8 @@ static inline TCGv gen_ea_once(DisasContext *s, uint16_t insn, int opsize,
 180  /* Generate code to load/store a value ito/from an EA.  If VAL > 0 this is
 181     a write otherwise it is a read (0 == sign extend, -1 == zero extend).
 182     ADDRP is non-null for readwrite operands.  */
 183 -static TCGv gen_ea(DisasContext *s, uint16_t insn, int opsize, TCGv val,
 184 -                   TCGv *addrp, ea_what what)
 185 +static TCGv gen_ea(CPUM68KState *env, DisasContext *s, uint16_t insn,
 186 +                   int opsize, TCGv val, TCGv *addrp, ea_what what)
 187  {
 188      TCGv reg;
 189      TCGv result;
 190 @@ -609,7 +618,7 @@ static TCGv gen_ea(DisasContext *s, uint16_t insn, int opsize, TCGv val,
 191              if (addrp && what == EA_STORE) {
 192                  tmp = *addrp;
 193              } else {
 194 -                tmp = gen_lea(s, insn, opsize);
 195 +                tmp = gen_lea(env, s, insn, opsize);
 196                  if (IS_NULL_QREG(tmp))
 197                      return tmp;
 198                  if (addrp)
 199 @@ -626,35 +635,35 @@ static TCGv gen_ea(DisasContext *s, uint16_t insn, int opsize, TCGv val,
 200          return result;
 201      case 5: /* Indirect displacement.  */
 202      case 6: /* Indirect index + displacement.  */
 203 -        return gen_ea_once(s, insn, opsize, val, addrp, what);
 204 +        return gen_ea_once(env, s, insn, opsize, val, addrp, what);
 205      case 7: /* Other */
 206          switch (insn & 7) {
 207          case 0: /* Absolute short.  */
 208          case 1: /* Absolute long.  */
 209          case 2: /* pc displacement  */
 210          case 3: /* pc index+displacement.  */
 211 -            return gen_ea_once(s, insn, opsize, val, addrp, what);
 212 +            return gen_ea_once(env, s, insn, opsize, val, addrp, what);
 213          case 4: /* Immediate.  */
 214              /* Sign extend values for consistency.  */
 215              switch (opsize) {
 216              case OS_BYTE:
 217                  if (what == EA_LOADS) {
 218 -                    offset = cpu_ldsb_code(cpu_single_env, s->pc + 1);
 219 +                    offset = cpu_ldsb_code(env, s->pc + 1);
 220                  } else {
 221 -                    offset = cpu_ldub_code(cpu_single_env, s->pc + 1);
 222 +                    offset = cpu_ldub_code(env, s->pc + 1);
 223                  }
 224                  s->pc += 2;
 225                  break;
 226              case OS_WORD:
 227                  if (what == EA_LOADS) {
 228 -                    offset = cpu_ldsw_code(cpu_single_env, s->pc);
 229 +                    offset = cpu_ldsw_code(env, s->pc);
 230                  } else {
 231 -                    offset = cpu_lduw_code(cpu_single_env, s->pc);
 232 +                    offset = cpu_lduw_code(env, s->pc);
 233                  }
 234                  s->pc += 2;
 235                  break;
 236              case OS_LONG:
 237 -                offset = read_im32(s);
 238 +                offset = read_im32(env, s);
 239                  break;
 240              default:
 241                  qemu_assert(0, "Bad immediate operand");
 242 @@ -825,20 +834,21 @@ static inline void gen_addr_fault(DisasContext *s)
 243      gen_exception(s, s->insn_pc, EXCP_ADDRESS);
 244  }
 245
 246 -#define SRC_EA(result, opsize, op_sign, addrp) do { \
 247 -    result = gen_ea(s, insn, opsize, NULL_QREG, addrp, op_sign ? EA_LOADS : EA_LOADU); \
 248 -    if (IS_NULL_QREG(result)) { \
 249 -        gen_addr_fault(s); \
 250 -        return; \
 251 -    } \
 252 +#define SRC_EA(env, result, opsize, op_sign, addrp) do {                \
 253 +        result = gen_ea(env, s, insn, opsize, NULL_QREG, addrp,         \
 254 +                        op_sign ? EA_LOADS : EA_LOADU);                 \
 255 +        if (IS_NULL_QREG(result)) {                                     \
 256 +            gen_addr_fault(s);                                          \
 257 +            return;                                                     \
 258 +        }                                                               \
 259      } while (0)
 260
 261 -#define DEST_EA(insn, opsize, val, addrp) do { \
 262 -    TCGv ea_result = gen_ea(s, insn, opsize, val, addrp, EA_STORE); \
 263 -    if (IS_NULL_QREG(ea_result)) { \
 264 -        gen_addr_fault(s); \
 265 -        return; \
 266 -    } \
 267 +#define DEST_EA(env, insn, opsize, val, addrp) do {                     \
 268 +        TCGv ea_result = gen_ea(env, s, insn, opsize, val, addrp, EA_STORE); \
 269 +        if (IS_NULL_QREG(ea_result)) {                                  \
 270 +            gen_addr_fault(s);                                          \
 271 +            return;                                                     \
 272 +        }                                                               \
 273      } while (0)
 274
 275  /* Generate a jump to an immediate address.  */
 276 @@ -874,8 +884,7 @@ DISAS_INSN(undef_fpu)
 277  DISAS_INSN(undef)
 278  {
 279      gen_exception(s, s->pc - 2, EXCP_UNSUPPORTED);
 280 -    cpu_abort(cpu_single_env, "Illegal instruction: %04x @ %08x",
 281 -              insn, s->pc - 2);
 282 +    cpu_abort(env, "Illegal instruction: %04x @ %08x", insn, s->pc - 2);
 283  }
 284
 285  DISAS_INSN(mulw)
 286 @@ -892,7 +901,7 @@ DISAS_INSN(mulw)
 287          tcg_gen_ext16s_i32(tmp, reg);
 288      else
 289          tcg_gen_ext16u_i32(tmp, reg);
 290 -    SRC_EA(src, OS_WORD, sign, NULL);
 291 +    SRC_EA(env, src, OS_WORD, sign, NULL);
 292      tcg_gen_mul_i32(tmp, tmp, src);
 293      tcg_gen_mov_i32(reg, tmp);
 294      /* Unlike m68k, coldfire always clears the overflow bit.  */
 295 @@ -913,7 +922,7 @@ DISAS_INSN(divw)
 296      } else {
 297          tcg_gen_ext16u_i32(QREG_DIV1, reg);
 298      }
 299 -    SRC_EA(src, OS_WORD, sign, NULL);
 300 +    SRC_EA(env, src, OS_WORD, sign, NULL);
 301      tcg_gen_mov_i32(QREG_DIV2, src);
 302      if (sign) {
 303          gen_helper_divs(cpu_env, tcg_const_i32(1));
 304 @@ -936,7 +945,7 @@ DISAS_INSN(divl)
 305      TCGv reg;
 306      uint16_t ext;
 307
 308 -    ext = cpu_lduw_code(cpu_single_env, s->pc);
 309 +    ext = cpu_lduw_code(env, s->pc);
 310      s->pc += 2;
 311      if (ext & 0x87f8) {
 312          gen_exception(s, s->pc - 4, EXCP_UNSUPPORTED);
 313 @@ -945,7 +954,7 @@ DISAS_INSN(divl)
 314      num = DREG(ext, 12);
 315      reg = DREG(ext, 0);
 316      tcg_gen_mov_i32(QREG_DIV1, num);
 317 -    SRC_EA(den, OS_LONG, 0, NULL);
 318 +    SRC_EA(env, den, OS_LONG, 0, NULL);
 319      tcg_gen_mov_i32(QREG_DIV2, den);
 320      if (ext & 0x0800) {
 321          gen_helper_divs(cpu_env, tcg_const_i32(0));
 322 @@ -975,11 +984,11 @@ DISAS_INSN(addsub)
 323      reg = DREG(insn, 9);
 324      dest = tcg_temp_new();
 325      if (insn & 0x100) {
 326 -        SRC_EA(tmp, OS_LONG, 0, &addr);
 327 +        SRC_EA(env, tmp, OS_LONG, 0, &addr);
 328          src = reg;
 329      } else {
 330          tmp = reg;
 331 -        SRC_EA(src, OS_LONG, 0, NULL);
 332 +        SRC_EA(env, src, OS_LONG, 0, NULL);
 333      }
 334      if (add) {
 335          tcg_gen_add_i32(dest, tmp, src);
 336 @@ -992,7 +1001,7 @@ DISAS_INSN(addsub)
 337      }
 338      gen_update_cc_add(dest, src);
 339      if (insn & 0x100) {
 340 -        DEST_EA(insn, OS_LONG, dest, &addr);
 341 +        DEST_EA(env, insn, OS_LONG, dest, &addr);
 342      } else {
 343          tcg_gen_mov_i32(reg, dest);
 344      }
 345 @@ -1022,7 +1031,7 @@ DISAS_INSN(bitop_reg)
 346      else
 347          opsize = OS_LONG;
 348      op = (insn >> 6) & 3;
 349 -    SRC_EA(src1, opsize, 0, op ? &addr: NULL);
 350 +    SRC_EA(env, src1, opsize, 0, op ? &addr: NULL);
 351      src2 = DREG(insn, 9);
 352      dest = tcg_temp_new();
 353
 354 @@ -1057,7 +1066,7 @@ DISAS_INSN(bitop_reg)
 355          break;
 356      }
 357      if (op)
 358 -        DEST_EA(insn, opsize, dest, &addr);
 359 +        DEST_EA(env, insn, opsize, dest, &addr);
 360  }
 361
 362  DISAS_INSN(sats)
 363 @@ -1088,9 +1097,9 @@ DISAS_INSN(movem)
 364      TCGv tmp;
 365      int is_load;
 366
 367 -    mask = cpu_lduw_code(cpu_single_env, s->pc);
 368 +    mask = cpu_lduw_code(env, s->pc);
 369      s->pc += 2;
 370 -    tmp = gen_lea(s, insn, OS_LONG);
 371 +    tmp = gen_lea(env, s, insn, OS_LONG);
 372      if (IS_NULL_QREG(tmp)) {
 373          gen_addr_fault(s);
 374          return;
 375 @@ -1132,14 +1141,14 @@ DISAS_INSN(bitop_im)
 376          opsize = OS_LONG;
 377      op = (insn >> 6) & 3;
 378
 379 -    bitnum = cpu_lduw_code(cpu_single_env, s->pc);
 380 +    bitnum = cpu_lduw_code(env, s->pc);
 381      s->pc += 2;
 382      if (bitnum & 0xff00) {
 383 -        disas_undef(s, insn);
 384 +        disas_undef(env, s, insn);
 385          return;
 386      }
 387
 388 -    SRC_EA(src1, opsize, 0, op ? &addr: NULL);
 389 +    SRC_EA(env, src1, opsize, 0, op ? &addr: NULL);
 390
 391      gen_flush_flags(s);
 392      if (opsize == OS_BYTE)
 393 @@ -1174,7 +1183,7 @@ DISAS_INSN(bitop_im)
 394          default: /* btst */
 395              break;
 396          }
 397 -        DEST_EA(insn, opsize, tmp, &addr);
 398 +        DEST_EA(env, insn, opsize, tmp, &addr);
 399      }
 400  }
 401
 402 @@ -1187,8 +1196,8 @@ DISAS_INSN(arith_im)
 403      TCGv addr;
 404
 405      op = (insn >> 9) & 7;
 406 -    SRC_EA(src1, OS_LONG, 0, (op == 6) ? NULL : &addr);
 407 -    im = read_im32(s);
 408 +    SRC_EA(env, src1, OS_LONG, 0, (op == 6) ? NULL : &addr);
 409 +    im = read_im32(env, s);
 410      dest = tcg_temp_new();
 411      switch (op) {
 412      case 0: /* ori */
 413 @@ -1227,7 +1236,7 @@ DISAS_INSN(arith_im)
 414          abort();
 415      }
 416      if (op != 6) {
 417 -        DEST_EA(insn, OS_LONG, dest, &addr);
 418 +        DEST_EA(env, insn, OS_LONG, dest, &addr);
 419      }
 420  }
 421
 422 @@ -1259,7 +1268,7 @@ DISAS_INSN(move)
 423      default:
 424          abort();
 425      }
 426 -    SRC_EA(src, opsize, 1, NULL);
 427 +    SRC_EA(env, src, opsize, 1, NULL);
 428      op = (insn >> 6) & 7;
 429      if (op == 1) {
 430          /* movea */
 431 @@ -1270,7 +1279,7 @@ DISAS_INSN(move)
 432          /* normal move */
 433          uint16_t dest_ea;
 434          dest_ea = ((insn >> 9) & 7) | (op << 3);
 435 -        DEST_EA(dest_ea, opsize, src, NULL);
 436 +        DEST_EA(env, dest_ea, opsize, src, NULL);
 437          /* This will be correct because loads sign extend.  */
 438          gen_logic_cc(s, src);
 439      }
 440 @@ -1291,7 +1300,7 @@ DISAS_INSN(lea)
 441      TCGv tmp;
 442
 443      reg = AREG(insn, 9);
 444 -    tmp = gen_lea(s, insn, OS_LONG);
 445 +    tmp = gen_lea(env, s, insn, OS_LONG);
 446      if (IS_NULL_QREG(tmp)) {
 447          gen_addr_fault(s);
 448          return;
 449 @@ -1316,7 +1325,7 @@ DISAS_INSN(clr)
 450      default:
 451          abort();
 452      }
 453 -    DEST_EA(insn, opsize, tcg_const_i32(0), NULL);
 454 +    DEST_EA(env, insn, opsize, tcg_const_i32(0), NULL);
 455      gen_logic_cc(s, tcg_const_i32(0));
 456  }
 457
 458 @@ -1365,7 +1374,8 @@ static void gen_set_sr_im(DisasContext *s, uint16_t val, int ccr_only)
 459      }
 460  }
 461
 462 -static void gen_set_sr(DisasContext *s, uint16_t insn, int ccr_only)
 463 +static void gen_set_sr(CPUM68KState *env, DisasContext *s, uint16_t insn,
 464 +                       int ccr_only)
 465  {
 466      TCGv tmp;
 467      TCGv reg;
 468 @@ -1385,17 +1395,17 @@ static void gen_set_sr(DisasContext *s, uint16_t insn, int ccr_only)
 469      else if ((insn & 0x3f) == 0x3c)
 470        {
 471          uint16_t val;
 472 -        val = cpu_lduw_code(cpu_single_env, s->pc);
 473 +        val = cpu_lduw_code(env, s->pc);
 474          s->pc += 2;
 475          gen_set_sr_im(s, val, ccr_only);
 476        }
 477      else
 478 -        disas_undef(s, insn);
 479 +        disas_undef(env, s, insn);
 480  }
 481
 482  DISAS_INSN(move_to_ccr)
 483  {
 484 -    gen_set_sr(s, insn, 1);
 485 +    gen_set_sr(env, s, insn, 1);
 486  }
 487
 488  DISAS_INSN(not)
 489 @@ -1426,7 +1436,7 @@ DISAS_INSN(pea)
 490  {
 491      TCGv tmp;
 492
 493 -    tmp = gen_lea(s, insn, OS_LONG);
 494 +    tmp = gen_lea(env, s, insn, OS_LONG);
 495      if (IS_NULL_QREG(tmp)) {
 496          gen_addr_fault(s);
 497          return;
 498 @@ -1472,7 +1482,7 @@ DISAS_INSN(tst)
 499      default:
 500          abort();
 501      }
 502 -    SRC_EA(tmp, opsize, 1, NULL);
 503 +    SRC_EA(env, tmp, opsize, 1, NULL);
 504      gen_logic_cc(s, tmp);
 505  }
 506
 507 @@ -1494,10 +1504,10 @@ DISAS_INSN(tas)
 508      TCGv addr;
 509
 510      dest = tcg_temp_new();
 511 -    SRC_EA(src1, OS_BYTE, 1, &addr);
 512 +    SRC_EA(env, src1, OS_BYTE, 1, &addr);
 513      gen_logic_cc(s, src1);
 514      tcg_gen_ori_i32(dest, src1, 0x80);
 515 -    DEST_EA(insn, OS_BYTE, dest, &addr);
 516 +    DEST_EA(env, insn, OS_BYTE, dest, &addr);
 517  }
 518
 519  DISAS_INSN(mull)
 520 @@ -1509,14 +1519,14 @@ DISAS_INSN(mull)
 521
 522      /* The upper 32 bits of the product are discarded, so
 523         muls.l and mulu.l are functionally equivalent.  */
 524 -    ext = cpu_lduw_code(cpu_single_env, s->pc);
 525 +    ext = cpu_lduw_code(env, s->pc);
 526      s->pc += 2;
 527      if (ext & 0x87ff) {
 528          gen_exception(s, s->pc - 4, EXCP_UNSUPPORTED);
 529          return;
 530      }
 531      reg = DREG(ext, 12);
 532 -    SRC_EA(src1, OS_LONG, 0, NULL);
 533 +    SRC_EA(env, src1, OS_LONG, 0, NULL);
 534      dest = tcg_temp_new();
 535      tcg_gen_mul_i32(dest, src1, reg);
 536      tcg_gen_mov_i32(reg, dest);
 537 @@ -1530,7 +1540,7 @@ DISAS_INSN(link)
 538      TCGv reg;
 539      TCGv tmp;
 540
 541 -    offset = cpu_ldsw_code(cpu_single_env, s->pc);
 542 +    offset = cpu_ldsw_code(env, s->pc);
 543      s->pc += 2;
 544      reg = AREG(insn, 0);
 545      tmp = tcg_temp_new();
 546 @@ -1574,7 +1584,7 @@ DISAS_INSN(jump)
 547
 548      /* Load the target address first to ensure correct exception
 549         behavior.  */
 550 -    tmp = gen_lea(s, insn, OS_LONG);
 551 +    tmp = gen_lea(env, s, insn, OS_LONG);
 552      if (IS_NULL_QREG(tmp)) {
 553          gen_addr_fault(s);
 554          return;
 555 @@ -1594,7 +1604,7 @@ DISAS_INSN(addsubq)
 556      int val;
 557      TCGv addr;
 558
 559 -    SRC_EA(src1, OS_LONG, 0, &addr);
 560 +    SRC_EA(env, src1, OS_LONG, 0, &addr);
 561      val = (insn >> 9) & 7;
 562      if (val == 0)
 563          val = 8;
 564 @@ -1621,7 +1631,7 @@ DISAS_INSN(addsubq)
 565          }
 566          gen_update_cc_add(dest, src2);
 567      }
 568 -    DEST_EA(insn, OS_LONG, dest, &addr);
 569 +    DEST_EA(env, insn, OS_LONG, dest, &addr);
 570  }
 571
 572  DISAS_INSN(tpf)
 573 @@ -1636,7 +1646,7 @@ DISAS_INSN(tpf)
 574      case 4: /* No extension words.  */
 575          break;
 576      default:
 577 -        disas_undef(s, insn);
 578 +        disas_undef(env, s, insn);
 579      }
 580  }
 581
 582 @@ -1651,10 +1661,10 @@ DISAS_INSN(branch)
 583      op = (insn >> 8) & 0xf;
 584      offset = (int8_t)insn;
 585      if (offset == 0) {
 586 -        offset = cpu_ldsw_code(cpu_single_env, s->pc);
 587 +        offset = cpu_ldsw_code(env, s->pc);
 588          s->pc += 2;
 589      } else if (offset == -1) {
 590 -        offset = read_im32(s);
 591 +        offset = read_im32(env, s);
 592      }
 593      if (op == 1) {
 594          /* bsr */
 595 @@ -1693,7 +1703,7 @@ DISAS_INSN(mvzs)
 596          opsize = OS_WORD;
 597      else
 598          opsize = OS_BYTE;
 599 -    SRC_EA(src, opsize, (insn & 0x80) == 0, NULL);
 600 +    SRC_EA(env, src, opsize, (insn & 0x80) == 0, NULL);
 601      reg = DREG(insn, 9);
 602      tcg_gen_mov_i32(reg, src);
 603      gen_logic_cc(s, src);
 604 @@ -1709,11 +1719,11 @@ DISAS_INSN(or)
 605      reg = DREG(insn, 9);
 606      dest = tcg_temp_new();
 607      if (insn & 0x100) {
 608 -        SRC_EA(src, OS_LONG, 0, &addr);
 609 +        SRC_EA(env, src, OS_LONG, 0, &addr);
 610          tcg_gen_or_i32(dest, src, reg);
 611 -        DEST_EA(insn, OS_LONG, dest, &addr);
 612 +        DEST_EA(env, insn, OS_LONG, dest, &addr);
 613      } else {
 614 -        SRC_EA(src, OS_LONG, 0, NULL);
 615 +        SRC_EA(env, src, OS_LONG, 0, NULL);
 616          tcg_gen_or_i32(dest, src, reg);
 617          tcg_gen_mov_i32(reg, dest);
 618      }
 619 @@ -1725,7 +1735,7 @@ DISAS_INSN(suba)
 620      TCGv src;
 621      TCGv reg;
 622
 623 -    SRC_EA(src, OS_LONG, 0, NULL);
 624 +    SRC_EA(env, src, OS_LONG, 0, NULL);
 625      reg = AREG(insn, 9);
 626      tcg_gen_sub_i32(reg, reg, src);
 627  }
 628 @@ -1751,7 +1761,7 @@ DISAS_INSN(mov3q)
 629          val = -1;
 630      src = tcg_const_i32(val);
 631      gen_logic_cc(s, src);
 632 -    DEST_EA(insn, OS_LONG, src, NULL);
 633 +    DEST_EA(env, insn, OS_LONG, src, NULL);
 634  }
 635
 636  DISAS_INSN(cmp)
 637 @@ -1779,7 +1789,7 @@ DISAS_INSN(cmp)
 638      default:
 639          abort();
 640      }
 641 -    SRC_EA(src, opsize, 1, NULL);
 642 +    SRC_EA(env, src, opsize, 1, NULL);
 643      reg = DREG(insn, 9);
 644      dest = tcg_temp_new();
 645      tcg_gen_sub_i32(dest, reg, src);
 646 @@ -1798,7 +1808,7 @@ DISAS_INSN(cmpa)
 647      } else {
 648          opsize = OS_WORD;
 649      }
 650 -    SRC_EA(src, opsize, 1, NULL);
 651 +    SRC_EA(env, src, opsize, 1, NULL);
 652      reg = AREG(insn, 9);
 653      dest = tcg_temp_new();
 654      tcg_gen_sub_i32(dest, reg, src);
 655 @@ -1813,12 +1823,12 @@ DISAS_INSN(eor)
 656      TCGv dest;
 657      TCGv addr;
 658
 659 -    SRC_EA(src, OS_LONG, 0, &addr);
 660 +    SRC_EA(env, src, OS_LONG, 0, &addr);
 661      reg = DREG(insn, 9);
 662      dest = tcg_temp_new();
 663      tcg_gen_xor_i32(dest, src, reg);
 664      gen_logic_cc(s, dest);
 665 -    DEST_EA(insn, OS_LONG, dest, &addr);
 666 +    DEST_EA(env, insn, OS_LONG, dest, &addr);
 667  }
 668
 669  DISAS_INSN(and)
 670 @@ -1831,11 +1841,11 @@ DISAS_INSN(and)
 671      reg = DREG(insn, 9);
 672      dest = tcg_temp_new();
 673      if (insn & 0x100) {
 674 -        SRC_EA(src, OS_LONG, 0, &addr);
 675 +        SRC_EA(env, src, OS_LONG, 0, &addr);
 676          tcg_gen_and_i32(dest, src, reg);
 677 -        DEST_EA(insn, OS_LONG, dest, &addr);
 678 +        DEST_EA(env, insn, OS_LONG, dest, &addr);
 679      } else {
 680 -        SRC_EA(src, OS_LONG, 0, NULL);
 681 +        SRC_EA(env, src, OS_LONG, 0, NULL);
 682          tcg_gen_and_i32(dest, src, reg);
 683          tcg_gen_mov_i32(reg, dest);
 684      }
 685 @@ -1847,7 +1857,7 @@ DISAS_INSN(adda)
 686      TCGv src;
 687      TCGv reg;
 688
 689 -    SRC_EA(src, OS_LONG, 0, NULL);
 690 +    SRC_EA(env, src, OS_LONG, 0, NULL);
 691      reg = AREG(insn, 9);
 692      tcg_gen_add_i32(reg, reg, src);
 693  }
 694 @@ -1936,13 +1946,13 @@ DISAS_INSN(strldsr)
 695      uint32_t addr;
 696
 697      addr = s->pc - 2;
 698 -    ext = cpu_lduw_code(cpu_single_env, s->pc);
 699 +    ext = cpu_lduw_code(env, s->pc);
 700      s->pc += 2;
 701      if (ext != 0x46FC) {
 702          gen_exception(s, addr, EXCP_UNSUPPORTED);
 703          return;
 704      }
 705 -    ext = cpu_lduw_code(cpu_single_env, s->pc);
 706 +    ext = cpu_lduw_code(env, s->pc);
 707      s->pc += 2;
 708      if (IS_USER(s) || (ext & SR_S) == 0) {
 709          gen_exception(s, addr, EXCP_PRIVILEGE);
 710 @@ -1972,7 +1982,7 @@ DISAS_INSN(move_to_sr)
 711          gen_exception(s, s->pc - 2, EXCP_PRIVILEGE);
 712          return;
 713      }
 714 -    gen_set_sr(s, insn, 0);
 715 +    gen_set_sr(env, s, insn, 0);
 716      gen_lookup_tb(s);
 717  }
 718
 719 @@ -2010,7 +2020,7 @@ DISAS_INSN(stop)
 720          return;
 721      }
 722
 723 -    ext = cpu_lduw_code(cpu_single_env, s->pc);
 724 +    ext = cpu_lduw_code(env, s->pc);
 725      s->pc += 2;
 726
 727      gen_set_sr_im(s, ext, 0);
 728 @@ -2037,7 +2047,7 @@ DISAS_INSN(movec)
 729          return;
 730      }
 731
 732 -    ext = cpu_lduw_code(cpu_single_env, s->pc);
 733 +    ext = cpu_lduw_code(env, s->pc);
 734      s->pc += 2;
 735
 736      if (ext & 0x8000) {
 737 @@ -2102,7 +2112,7 @@ DISAS_INSN(fpu)
 738      int set_dest;
 739      int opsize;
 740
 741 -    ext = cpu_lduw_code(cpu_single_env, s->pc);
 742 +    ext = cpu_lduw_code(env, s->pc);
 743      s->pc += 2;
 744      opmode = ext & 0x7f;
 745      switch ((ext >> 13) & 7) {
 746 @@ -2138,7 +2148,7 @@ DISAS_INSN(fpu)
 747                  tcg_gen_addi_i32(tmp32, tmp32, -8);
 748                  break;
 749              case 5:
 750 -                offset = cpu_ldsw_code(cpu_single_env, s->pc);
 751 +                offset = cpu_ldsw_code(env, s->pc);
 752                  s->pc += 2;
 753                  tcg_gen_addi_i32(tmp32, tmp32, offset);
 754                  break;
 755 @@ -2164,7 +2174,7 @@ DISAS_INSN(fpu)
 756          default:
 757              goto undef;
 758          }
 759 -        DEST_EA(insn, opsize, tmp32, NULL);
 760 +        DEST_EA(env, insn, opsize, tmp32, NULL);
 761          tcg_temp_free_i32(tmp32);
 762          return;
 763      case 4: /* fmove to control register.  */
 764 @@ -2192,7 +2202,7 @@ DISAS_INSN(fpu)
 765                        (ext >> 10) & 7);
 766              goto undef;
 767          }
 768 -        DEST_EA(insn, OS_LONG, tmp32, NULL);
 769 +        DEST_EA(env, insn, OS_LONG, tmp32, NULL);
 770          break;
 771      case 6: /* fmovem */
 772      case 7:
 773 @@ -2202,7 +2212,7 @@ DISAS_INSN(fpu)
 774              int i;
 775              if ((ext & 0x1f00) != 0x1000 || (ext & 0xff) == 0)
 776                  goto undef;
 777 -            tmp32 = gen_lea(s, insn, OS_LONG);
 778 +            tmp32 = gen_lea(env, s, insn, OS_LONG);
 779              if (IS_NULL_QREG(tmp32)) {
 780                  gen_addr_fault(s);
 781                  return;
 782 @@ -2252,12 +2262,12 @@ DISAS_INSN(fpu)
 783                  tcg_gen_addi_i32(tmp32, tmp32, -8);
 784                  break;
 785              case 5:
 786 -                offset = cpu_ldsw_code(cpu_single_env, s->pc);
 787 +                offset = cpu_ldsw_code(env, s->pc);
 788                  s->pc += 2;
 789                  tcg_gen_addi_i32(tmp32, tmp32, offset);
 790                  break;
 791              case 7:
 792 -                offset = cpu_ldsw_code(cpu_single_env, s->pc);
 793 +                offset = cpu_ldsw_code(env, s->pc);
 794                  offset += s->pc - 2;
 795                  s->pc += 2;
 796                  tcg_gen_addi_i32(tmp32, tmp32, offset);
 797 @@ -2277,7 +2287,7 @@ DISAS_INSN(fpu)
 798              }
 799              tcg_temp_free_i32(tmp32);
 800          } else {
 801 -            SRC_EA(tmp32, opsize, 1, NULL);
 802 +            SRC_EA(env, tmp32, opsize, 1, NULL);
 803              src = tcg_temp_new_i64();
 804              switch (opsize) {
 805              case OS_LONG:
 806 @@ -2372,7 +2382,7 @@ DISAS_INSN(fpu)
 807  undef:
 808      /* FIXME: Is this right for offset addressing modes?  */
 809      s->pc -= 2;
 810 -    disas_undef_fpu(s, insn);
 811 +    disas_undef_fpu(env, s, insn);
 812  }
 813
 814  DISAS_INSN(fbcc)
 815 @@ -2383,10 +2393,10 @@ DISAS_INSN(fbcc)
 816      int l1;
 817
 818      addr = s->pc;
 819 -    offset = cpu_ldsw_code(cpu_single_env, s->pc);
 820 +    offset = cpu_ldsw_code(env, s->pc);
 821      s->pc += 2;
 822      if (insn & (1 << 6)) {
 823 -        offset = (offset << 16) | cpu_lduw_code(cpu_single_env, s->pc);
 824 +        offset = (offset << 16) | cpu_lduw_code(env, s->pc);
 825          s->pc += 2;
 826      }
 827
 828 @@ -2508,18 +2518,18 @@ DISAS_INSN(mac)
 829          s->done_mac = 1;
 830      }
 831
 832 -    ext = cpu_lduw_code(cpu_single_env, s->pc);
 833 +    ext = cpu_lduw_code(env, s->pc);
 834      s->pc += 2;
 835
 836      acc = ((insn >> 7) & 1) | ((ext >> 3) & 2);
 837      dual = ((insn & 0x30) != 0 && (ext & 3) != 0);
 838      if (dual && !m68k_feature(s->env, M68K_FEATURE_CF_EMAC_B)) {
 839 -        disas_undef(s, insn);
 840 +        disas_undef(env, s, insn);
 841          return;
 842      }
 843      if (insn & 0x30) {
 844          /* MAC with load.  */
 845 -        tmp = gen_lea(s, insn, OS_LONG);
 846 +        tmp = gen_lea(env, s, insn, OS_LONG);
 847          addr = tcg_temp_new();
 848          tcg_gen_and_i32(addr, tmp, QREG_MAC_MASK);
 849          /* Load the value now to ensure correct exception behavior.
 850 @@ -2733,7 +2743,7 @@ DISAS_INSN(to_mac)
 851      int accnum;
 852      accnum = (insn >> 9) & 3;
 853      acc = MACREG(accnum);
 854 -    SRC_EA(val, OS_LONG, 0, NULL);
 855 +    SRC_EA(env, val, OS_LONG, 0, NULL);
 856      if (s->env->macsr & MACSR_FI) {
 857          tcg_gen_ext_i32_i64(acc, val);
 858          tcg_gen_shli_i64(acc, acc, 8);
 859 @@ -2750,7 +2760,7 @@ DISAS_INSN(to_mac)
 860  DISAS_INSN(to_macsr)
 861  {
 862      TCGv val;
 863 -    SRC_EA(val, OS_LONG, 0, NULL);
 864 +    SRC_EA(env, val, OS_LONG, 0, NULL);
 865      gen_helper_set_macsr(cpu_env, val);
 866      gen_lookup_tb(s);
 867  }
 868 @@ -2758,7 +2768,7 @@ DISAS_INSN(to_macsr)
 869  DISAS_INSN(to_mask)
 870  {
 871      TCGv val;
 872 -    SRC_EA(val, OS_LONG, 0, NULL);
 873 +    SRC_EA(env, val, OS_LONG, 0, NULL);
 874      tcg_gen_ori_i32(QREG_MAC_MASK, val, 0xffff0000);
 875  }
 876
 877 @@ -2766,7 +2776,7 @@ DISAS_INSN(to_mext)
 878  {
 879      TCGv val;
 880      TCGv acc;
 881 -    SRC_EA(val, OS_LONG, 0, NULL);
 882 +    SRC_EA(env, val, OS_LONG, 0, NULL);
 883      acc = tcg_const_i32((insn & 0x400) ? 2 : 0);
 884      if (s->env->macsr & MACSR_FI)
 885          gen_helper_set_mac_extf(cpu_env, val, acc);
 886 @@ -2943,10 +2953,10 @@ static void disas_m68k_insn(CPUM68KState * env, DisasContext *s)
 887  {
 888      uint16_t insn;
 889
 890 -    insn = cpu_lduw_code(cpu_single_env, s->pc);
 891 +    insn = cpu_lduw_code(env, s->pc);
 892      s->pc += 2;
 893
 894 -    opcode_table[insn](s, insn);
 895 +    opcode_table[insn](env, s, insn);
 896  }
 897
 898  /* generate intermediate code for basic block 'tb'.  */
 899 --
 900 1.7.12.1
 901