target-s390x/translate.c

   1 /*
   2  *  S/390 translation
   3  *
   4  *  Copyright (c) 2009 Ulrich Hecht
   5  *  Copyright (c) 2010 Alexander Graf
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 /* #define DEBUG_INLINE_BRANCHES */
  22 #define S390X_DEBUG_DISAS
  23 /* #define S390X_DEBUG_DISAS_VERBOSE */
  24
  25 #ifdef S390X_DEBUG_DISAS_VERBOSE
  26 #  define LOG_DISAS(...) qemu_log(__VA_ARGS__)
  27 #else
  28 #  define LOG_DISAS(...) do { } while (0)
  29 #endif
  30
  31 #include "cpu.h"
  32 #include "disas/disas.h"
  33 #include "tcg-op.h"
  34 #include "qemu/log.h"
  35 #include "qemu/host-utils.h"
  36
  37 /* global register indexes */
  38 static TCGv_ptr cpu_env;
  39
  40 #include "exec/gen-icount.h"
  41 #include "helper.h"
  42 #define GEN_HELPER 1
  43 #include "helper.h"
  44
  45
  46 /* Information that (most) every instruction needs to manipulate.  */
  47 typedef struct DisasContext DisasContext;
  48 typedef struct DisasInsn DisasInsn;
  49 typedef struct DisasFields DisasFields;
  50
  51 struct DisasContext {
  52     struct TranslationBlock *tb;
  53     const DisasInsn *insn;
  54     DisasFields *fields;
  55     uint64_t pc, next_pc;
  56     enum cc_op cc_op;
  57     bool singlestep_enabled;
  58     int is_jmp;
  59 };
  60
  61 /* Information carried about a condition to be evaluated.  */
  62 typedef struct {
  63     TCGCond cond:8;
  64     bool is_64;
  65     bool g1;
  66     bool g2;
  67     union {
  68         struct { TCGv_i64 a, b; } s64;
  69         struct { TCGv_i32 a, b; } s32;
  70     } u;
  71 } DisasCompare;
  72
  73 #define DISAS_EXCP 4
  74
  75 static void gen_op_calc_cc(DisasContext *s);
  76
  77 #ifdef DEBUG_INLINE_BRANCHES
  78 static uint64_t inline_branch_hit[CC_OP_MAX];
  79 static uint64_t inline_branch_miss[CC_OP_MAX];
  80 #endif
  81
  82 static inline void debug_insn(uint64_t insn)
  83 {
  84     LOG_DISAS("insn: 0x%" PRIx64 "\n", insn);
  85 }
  86
  87 static inline uint64_t pc_to_link_info(DisasContext *s, uint64_t pc)
  88 {
  89     if (!(s->tb->flags & FLAG_MASK_64)) {
  90         if (s->tb->flags & FLAG_MASK_32) {
  91             return pc | 0x80000000;
  92         }
  93     }
  94     return pc;
  95 }
  96
  97 void cpu_dump_state(CPUS390XState *env, FILE *f, fprintf_function cpu_fprintf,
  98                     int flags)
  99 {
 100     int i;
 101
 102     if (env->cc_op > 3) {
 103         cpu_fprintf(f, "PSW=mask %016" PRIx64 " addr %016" PRIx64 " cc %15s\n",
 104                     env->psw.mask, env->psw.addr, cc_name(env->cc_op));
 105     } else {
 106         cpu_fprintf(f, "PSW=mask %016" PRIx64 " addr %016" PRIx64 " cc %02x\n",
 107                     env->psw.mask, env->psw.addr, env->cc_op);
 108     }
 109
 110     for (i = 0; i < 16; i++) {
 111         cpu_fprintf(f, "R%02d=%016" PRIx64, i, env->regs[i]);
 112         if ((i % 4) == 3) {
 113             cpu_fprintf(f, "\n");
 114         } else {
 115             cpu_fprintf(f, " ");
 116         }
 117     }
 118
 119     for (i = 0; i < 16; i++) {
 120         cpu_fprintf(f, "F%02d=%016" PRIx64, i, env->fregs[i].ll);
 121         if ((i % 4) == 3) {
 122             cpu_fprintf(f, "\n");
 123         } else {
 124             cpu_fprintf(f, " ");
 125         }
 126     }
 127
 128 #ifndef CONFIG_USER_ONLY
 129     for (i = 0; i < 16; i++) {
 130         cpu_fprintf(f, "C%02d=%016" PRIx64, i, env->cregs[i]);
 131         if ((i % 4) == 3) {
 132             cpu_fprintf(f, "\n");
 133         } else {
 134             cpu_fprintf(f, " ");
 135         }
 136     }
 137 #endif
 138
 139 #ifdef DEBUG_INLINE_BRANCHES
 140     for (i = 0; i < CC_OP_MAX; i++) {
 141         cpu_fprintf(f, "  %15s = %10ld\t%10ld\n", cc_name(i),
 142                     inline_branch_miss[i], inline_branch_hit[i]);
 143     }
 144 #endif
 145
 146     cpu_fprintf(f, "\n");
 147 }
 148
 149 static TCGv_i64 psw_addr;
 150 static TCGv_i64 psw_mask;
 151
 152 static TCGv_i32 cc_op;
 153 static TCGv_i64 cc_src;
 154 static TCGv_i64 cc_dst;
 155 static TCGv_i64 cc_vr;
 156
 157 static char cpu_reg_names[32][4];
 158 static TCGv_i64 regs[16];
 159 static TCGv_i64 fregs[16];
 160
 161 static uint8_t gen_opc_cc_op[OPC_BUF_SIZE];
 162
 163 void s390x_translate_init(void)
 164 {
 165     int i;
 166
 167     cpu_env = tcg_global_reg_new_ptr(TCG_AREG0, "env");
 168     psw_addr = tcg_global_mem_new_i64(TCG_AREG0,
 169                                       offsetof(CPUS390XState, psw.addr),
 170                                       "psw_addr");
 171     psw_mask = tcg_global_mem_new_i64(TCG_AREG0,
 172                                       offsetof(CPUS390XState, psw.mask),
 173                                       "psw_mask");
 174
 175     cc_op = tcg_global_mem_new_i32(TCG_AREG0, offsetof(CPUS390XState, cc_op),
 176                                    "cc_op");
 177     cc_src = tcg_global_mem_new_i64(TCG_AREG0, offsetof(CPUS390XState, cc_src),
 178                                     "cc_src");
 179     cc_dst = tcg_global_mem_new_i64(TCG_AREG0, offsetof(CPUS390XState, cc_dst),
 180                                     "cc_dst");
 181     cc_vr = tcg_global_mem_new_i64(TCG_AREG0, offsetof(CPUS390XState, cc_vr),
 182                                    "cc_vr");
 183
 184     for (i = 0; i < 16; i++) {
 185         snprintf(cpu_reg_names[i], sizeof(cpu_reg_names[0]), "r%d", i);
 186         regs[i] = tcg_global_mem_new(TCG_AREG0,
 187                                      offsetof(CPUS390XState, regs[i]),
 188                                      cpu_reg_names[i]);
 189     }
 190
 191     for (i = 0; i < 16; i++) {
 192         snprintf(cpu_reg_names[i + 16], sizeof(cpu_reg_names[0]), "f%d", i);
 193         fregs[i] = tcg_global_mem_new(TCG_AREG0,
 194                                       offsetof(CPUS390XState, fregs[i].d),
 195                                       cpu_reg_names[i + 16]);
 196     }
 197
 198     /* register helpers */
 199 #define GEN_HELPER 2
 200 #include "helper.h"
 201 }
 202
 203 static inline TCGv_i64 load_reg(int reg)
 204 {
 205     TCGv_i64 r = tcg_temp_new_i64();
 206     tcg_gen_mov_i64(r, regs[reg]);
 207     return r;
 208 }
 209
 210 static inline TCGv_i64 load_freg(int reg)
 211 {
 212     TCGv_i64 r = tcg_temp_new_i64();
 213     tcg_gen_mov_i64(r, fregs[reg]);
 214     return r;
 215 }
 216
 217 static inline TCGv_i32 load_freg32(int reg)
 218 {
 219     TCGv_i32 r = tcg_temp_new_i32();
 220 #if HOST_LONG_BITS == 32
 221     tcg_gen_mov_i32(r, TCGV_HIGH(fregs[reg]));
 222 #else
 223     tcg_gen_shri_i64(MAKE_TCGV_I64(GET_TCGV_I32(r)), fregs[reg], 32);
 224 #endif
 225     return r;
 226 }
 227
 228 static inline TCGv_i64 load_freg32_i64(int reg)
 229 {
 230     TCGv_i64 r = tcg_temp_new_i64();
 231     tcg_gen_shri_i64(r, fregs[reg], 32);
 232     return r;
 233 }
 234
 235 static inline TCGv_i32 load_reg32(int reg)
 236 {
 237     TCGv_i32 r = tcg_temp_new_i32();
 238     tcg_gen_trunc_i64_i32(r, regs[reg]);
 239     return r;
 240 }
 241
 242 static inline TCGv_i64 load_reg32_i64(int reg)
 243 {
 244     TCGv_i64 r = tcg_temp_new_i64();
 245     tcg_gen_ext32s_i64(r, regs[reg]);
 246     return r;
 247 }
 248
 249 static inline void store_reg(int reg, TCGv_i64 v)
 250 {
 251     tcg_gen_mov_i64(regs[reg], v);
 252 }
 253
 254 static inline void store_freg(int reg, TCGv_i64 v)
 255 {
 256     tcg_gen_mov_i64(fregs[reg], v);
 257 }
 258
 259 static inline void store_reg32(int reg, TCGv_i32 v)
 260 {
 261     /* 32 bit register writes keep the upper half */
 262 #if HOST_LONG_BITS == 32
 263     tcg_gen_mov_i32(TCGV_LOW(regs[reg]), v);
 264 #else
 265     tcg_gen_deposit_i64(regs[reg], regs[reg],
 266                         MAKE_TCGV_I64(GET_TCGV_I32(v)), 0, 32);
 267 #endif
 268 }
 269
 270 static inline void store_reg32_i64(int reg, TCGv_i64 v)
 271 {
 272     /* 32 bit register writes keep the upper half */
 273     tcg_gen_deposit_i64(regs[reg], regs[reg], v, 0, 32);
 274 }
 275
 276 static inline void store_reg32h_i64(int reg, TCGv_i64 v)
 277 {
 278     tcg_gen_deposit_i64(regs[reg], regs[reg], v, 32, 32);
 279 }
 280
 281 static inline void store_freg32(int reg, TCGv_i32 v)
 282 {
 283     /* 32 bit register writes keep the lower half */
 284 #if HOST_LONG_BITS == 32
 285     tcg_gen_mov_i32(TCGV_HIGH(fregs[reg]), v);
 286 #else
 287     tcg_gen_deposit_i64(fregs[reg], fregs[reg],
 288                         MAKE_TCGV_I64(GET_TCGV_I32(v)), 32, 32);
 289 #endif
 290 }
 291
 292 static inline void store_freg32_i64(int reg, TCGv_i64 v)
 293 {
 294     tcg_gen_deposit_i64(fregs[reg], fregs[reg], v, 32, 32);
 295 }
 296
 297 static inline void return_low128(TCGv_i64 dest)
 298 {
 299     tcg_gen_ld_i64(dest, cpu_env, offsetof(CPUS390XState, retxl));
 300 }
 301
 302 static inline void update_psw_addr(DisasContext *s)
 303 {
 304     /* psw.addr */
 305     tcg_gen_movi_i64(psw_addr, s->pc);
 306 }
 307
 308 static inline void potential_page_fault(DisasContext *s)
 309 {
 310 #ifndef CONFIG_USER_ONLY
 311     update_psw_addr(s);
 312     gen_op_calc_cc(s);
 313 #endif
 314 }
 315
 316 static inline uint64_t ld_code2(CPUS390XState *env, uint64_t pc)
 317 {
 318     return (uint64_t)cpu_lduw_code(env, pc);
 319 }
 320
 321 static inline uint64_t ld_code4(CPUS390XState *env, uint64_t pc)
 322 {
 323     return (uint64_t)(uint32_t)cpu_ldl_code(env, pc);
 324 }
 325
 326 static inline uint64_t ld_code6(CPUS390XState *env, uint64_t pc)
 327 {
 328     return (ld_code2(env, pc) << 32) | ld_code4(env, pc + 2);
 329 }
 330
 331 static inline int get_mem_index(DisasContext *s)
 332 {
 333     switch (s->tb->flags & FLAG_MASK_ASC) {
 334     case PSW_ASC_PRIMARY >> 32:
 335         return 0;
 336     case PSW_ASC_SECONDARY >> 32:
 337         return 1;
 338     case PSW_ASC_HOME >> 32:
 339         return 2;
 340     default:
 341         tcg_abort();
 342         break;
 343     }
 344 }
 345
 346 static void gen_exception(int excp)
 347 {
 348     TCGv_i32 tmp = tcg_const_i32(excp);
 349     gen_helper_exception(cpu_env, tmp);
 350     tcg_temp_free_i32(tmp);
 351 }
 352
 353 static void gen_program_exception(DisasContext *s, int code)
 354 {
 355     TCGv_i32 tmp;
 356
 357     /* Remember what pgm exeption this was.  */
 358     tmp = tcg_const_i32(code);
 359     tcg_gen_st_i32(tmp, cpu_env, offsetof(CPUS390XState, int_pgm_code));
 360     tcg_temp_free_i32(tmp);
 361
 362     tmp = tcg_const_i32(s->next_pc - s->pc);
 363     tcg_gen_st_i32(tmp, cpu_env, offsetof(CPUS390XState, int_pgm_ilen));
 364     tcg_temp_free_i32(tmp);
 365
 366     /* Advance past instruction.  */
 367     s->pc = s->next_pc;
 368     update_psw_addr(s);
 369
 370     /* Save off cc.  */
 371     gen_op_calc_cc(s);
 372
 373     /* Trigger exception.  */
 374     gen_exception(EXCP_PGM);
 375
 376     /* End TB here.  */
 377     s->is_jmp = DISAS_EXCP;
 378 }
 379
 380 static inline void gen_illegal_opcode(DisasContext *s)
 381 {
 382     gen_program_exception(s, PGM_SPECIFICATION);
 383 }
 384
 385 static inline void check_privileged(DisasContext *s)
 386 {
 387     if (s->tb->flags & (PSW_MASK_PSTATE >> 32)) {
 388         gen_program_exception(s, PGM_PRIVILEGED);
 389     }
 390 }
 391
 392 static TCGv_i64 get_address(DisasContext *s, int x2, int b2, int d2)
 393 {
 394     TCGv_i64 tmp;
 395
 396     /* 31-bitify the immediate part; register contents are dealt with below */
 397     if (!(s->tb->flags & FLAG_MASK_64)) {
 398         d2 &= 0x7fffffffUL;
 399     }
 400
 401     if (x2) {
 402         if (d2) {
 403             tmp = tcg_const_i64(d2);
 404             tcg_gen_add_i64(tmp, tmp, regs[x2]);
 405         } else {
 406             tmp = load_reg(x2);
 407         }
 408         if (b2) {
 409             tcg_gen_add_i64(tmp, tmp, regs[b2]);
 410         }
 411     } else if (b2) {
 412         if (d2) {
 413             tmp = tcg_const_i64(d2);
 414             tcg_gen_add_i64(tmp, tmp, regs[b2]);
 415         } else {
 416             tmp = load_reg(b2);
 417         }
 418     } else {
 419         tmp = tcg_const_i64(d2);
 420     }
 421
 422     /* 31-bit mode mask if there are values loaded from registers */
 423     if (!(s->tb->flags & FLAG_MASK_64) && (x2 || b2)) {
 424         tcg_gen_andi_i64(tmp, tmp, 0x7fffffffUL);
 425     }
 426
 427     return tmp;
 428 }
 429
 430 static inline void gen_op_movi_cc(DisasContext *s, uint32_t val)
 431 {
 432     s->cc_op = CC_OP_CONST0 + val;
 433 }
 434
 435 static void gen_op_update1_cc_i64(DisasContext *s, enum cc_op op, TCGv_i64 dst)
 436 {
 437     tcg_gen_discard_i64(cc_src);
 438     tcg_gen_mov_i64(cc_dst, dst);
 439     tcg_gen_discard_i64(cc_vr);
 440     s->cc_op = op;
 441 }
 442
 443 static void gen_op_update1_cc_i32(DisasContext *s, enum cc_op op, TCGv_i32 dst)
 444 {
 445     tcg_gen_discard_i64(cc_src);
 446     tcg_gen_extu_i32_i64(cc_dst, dst);
 447     tcg_gen_discard_i64(cc_vr);
 448     s->cc_op = op;
 449 }
 450
 451 static void gen_op_update2_cc_i64(DisasContext *s, enum cc_op op, TCGv_i64 src,
 452                                   TCGv_i64 dst)
 453 {
 454     tcg_gen_mov_i64(cc_src, src);
 455     tcg_gen_mov_i64(cc_dst, dst);
 456     tcg_gen_discard_i64(cc_vr);
 457     s->cc_op = op;
 458 }
 459
 460 static void gen_op_update2_cc_i32(DisasContext *s, enum cc_op op, TCGv_i32 src,
 461                                   TCGv_i32 dst)
 462 {
 463     tcg_gen_extu_i32_i64(cc_src, src);
 464     tcg_gen_extu_i32_i64(cc_dst, dst);
 465     tcg_gen_discard_i64(cc_vr);
 466     s->cc_op = op;
 467 }
 468
 469 static void gen_op_update3_cc_i64(DisasContext *s, enum cc_op op, TCGv_i64 src,
 470                                   TCGv_i64 dst, TCGv_i64 vr)
 471 {
 472     tcg_gen_mov_i64(cc_src, src);
 473     tcg_gen_mov_i64(cc_dst, dst);
 474     tcg_gen_mov_i64(cc_vr, vr);
 475     s->cc_op = op;
 476 }
 477
 478 static inline void set_cc_nz_u32(DisasContext *s, TCGv_i32 val)
 479 {
 480     gen_op_update1_cc_i32(s, CC_OP_NZ, val);
 481 }
 482
 483 static inline void set_cc_nz_u64(DisasContext *s, TCGv_i64 val)
 484 {
 485     gen_op_update1_cc_i64(s, CC_OP_NZ, val);
 486 }
 487
 488 static inline void gen_set_cc_nz_f32(DisasContext *s, TCGv_i64 val)
 489 {
 490     gen_op_update1_cc_i64(s, CC_OP_NZ_F32, val);
 491 }
 492
 493 static inline void gen_set_cc_nz_f64(DisasContext *s, TCGv_i64 val)
 494 {
 495     gen_op_update1_cc_i64(s, CC_OP_NZ_F64, val);
 496 }
 497
 498 static inline void gen_set_cc_nz_f128(DisasContext *s, TCGv_i64 vh, TCGv_i64 vl)
 499 {
 500     gen_op_update2_cc_i64(s, CC_OP_NZ_F128, vh, vl);
 501 }
 502
 503 static inline void cmp_32(DisasContext *s, TCGv_i32 v1, TCGv_i32 v2,
 504                           enum cc_op cond)
 505 {
 506     gen_op_update2_cc_i32(s, cond, v1, v2);
 507 }
 508
 509 static inline void cmp_64(DisasContext *s, TCGv_i64 v1, TCGv_i64 v2,
 510                           enum cc_op cond)
 511 {
 512     gen_op_update2_cc_i64(s, cond, v1, v2);
 513 }
 514
 515 static inline void cmp_s32(DisasContext *s, TCGv_i32 v1, TCGv_i32 v2)
 516 {
 517     cmp_32(s, v1, v2, CC_OP_LTGT_32);
 518 }
 519
 520 static inline void cmp_u32(DisasContext *s, TCGv_i32 v1, TCGv_i32 v2)
 521 {
 522     cmp_32(s, v1, v2, CC_OP_LTUGTU_32);
 523 }
 524
 525 static inline void cmp_s32c(DisasContext *s, TCGv_i32 v1, int32_t v2)
 526 {
 527     /* XXX optimize for the constant? put it in s? */
 528     TCGv_i32 tmp = tcg_const_i32(v2);
 529     cmp_32(s, v1, tmp, CC_OP_LTGT_32);
 530     tcg_temp_free_i32(tmp);
 531 }
 532
 533 static inline void cmp_u32c(DisasContext *s, TCGv_i32 v1, uint32_t v2)
 534 {
 535     TCGv_i32 tmp = tcg_const_i32(v2);
 536     cmp_32(s, v1, tmp, CC_OP_LTUGTU_32);
 537     tcg_temp_free_i32(tmp);
 538 }
 539
 540 static inline void cmp_s64(DisasContext *s, TCGv_i64 v1, TCGv_i64 v2)
 541 {
 542     cmp_64(s, v1, v2, CC_OP_LTGT_64);
 543 }
 544
 545 static inline void cmp_u64(DisasContext *s, TCGv_i64 v1, TCGv_i64 v2)
 546 {
 547     cmp_64(s, v1, v2, CC_OP_LTUGTU_64);
 548 }
 549
 550 static inline void cmp_s64c(DisasContext *s, TCGv_i64 v1, int64_t v2)
 551 {
 552     TCGv_i64 tmp = tcg_const_i64(v2);
 553     cmp_s64(s, v1, tmp);
 554     tcg_temp_free_i64(tmp);
 555 }
 556
 557 static inline void cmp_u64c(DisasContext *s, TCGv_i64 v1, uint64_t v2)
 558 {
 559     TCGv_i64 tmp = tcg_const_i64(v2);
 560     cmp_u64(s, v1, tmp);
 561     tcg_temp_free_i64(tmp);
 562 }
 563
 564 static inline void set_cc_s32(DisasContext *s, TCGv_i32 val)
 565 {
 566     gen_op_update1_cc_i32(s, CC_OP_LTGT0_32, val);
 567 }
 568
 569 static inline void set_cc_s64(DisasContext *s, TCGv_i64 val)
 570 {
 571     gen_op_update1_cc_i64(s, CC_OP_LTGT0_64, val);
 572 }
 573
 574 /* CC value is in env->cc_op */
 575 static inline void set_cc_static(DisasContext *s)
 576 {
 577     tcg_gen_discard_i64(cc_src);
 578     tcg_gen_discard_i64(cc_dst);
 579     tcg_gen_discard_i64(cc_vr);
 580     s->cc_op = CC_OP_STATIC;
 581 }
 582
 583 static inline void gen_op_set_cc_op(DisasContext *s)
 584 {
 585     if (s->cc_op != CC_OP_DYNAMIC && s->cc_op != CC_OP_STATIC) {
 586         tcg_gen_movi_i32(cc_op, s->cc_op);
 587     }
 588 }
 589
 590 static inline void gen_update_cc_op(DisasContext *s)
 591 {
 592     gen_op_set_cc_op(s);
 593 }
 594
 595 /* calculates cc into cc_op */
 596 static void gen_op_calc_cc(DisasContext *s)
 597 {
 598     TCGv_i32 local_cc_op = tcg_const_i32(s->cc_op);
 599     TCGv_i64 dummy = tcg_const_i64(0);
 600
 601     switch (s->cc_op) {
 602     case CC_OP_CONST0:
 603     case CC_OP_CONST1:
 604     case CC_OP_CONST2:
 605     case CC_OP_CONST3:
 606         /* s->cc_op is the cc value */
 607         tcg_gen_movi_i32(cc_op, s->cc_op - CC_OP_CONST0);
 608         break;
 609     case CC_OP_STATIC:
 610         /* env->cc_op already is the cc value */
 611         break;
 612     case CC_OP_NZ:
 613     case CC_OP_ABS_64:
 614     case CC_OP_NABS_64:
 615     case CC_OP_ABS_32:
 616     case CC_OP_NABS_32:
 617     case CC_OP_LTGT0_32:
 618     case CC_OP_LTGT0_64:
 619     case CC_OP_COMP_32:
 620     case CC_OP_COMP_64:
 621     case CC_OP_NZ_F32:
 622     case CC_OP_NZ_F64:
 623     case CC_OP_FLOGR:
 624         /* 1 argument */
 625         gen_helper_calc_cc(cc_op, cpu_env, local_cc_op, dummy, cc_dst, dummy);
 626         break;
 627     case CC_OP_ICM:
 628     case CC_OP_LTGT_32:
 629     case CC_OP_LTGT_64:
 630     case CC_OP_LTUGTU_32:
 631     case CC_OP_LTUGTU_64:
 632     case CC_OP_TM_32:
 633     case CC_OP_TM_64:
 634     case CC_OP_SLA_32:
 635     case CC_OP_SLA_64:
 636     case CC_OP_NZ_F128:
 637         /* 2 arguments */
 638         gen_helper_calc_cc(cc_op, cpu_env, local_cc_op, cc_src, cc_dst, dummy);
 639         break;
 640     case CC_OP_ADD_64:
 641     case CC_OP_ADDU_64:
 642     case CC_OP_ADDC_64:
 643     case CC_OP_SUB_64:
 644     case CC_OP_SUBU_64:
 645     case CC_OP_SUBB_64:
 646     case CC_OP_ADD_32:
 647     case CC_OP_ADDU_32:
 648     case CC_OP_ADDC_32:
 649     case CC_OP_SUB_32:
 650     case CC_OP_SUBU_32:
 651     case CC_OP_SUBB_32:
 652         /* 3 arguments */
 653         gen_helper_calc_cc(cc_op, cpu_env, local_cc_op, cc_src, cc_dst, cc_vr);
 654         break;
 655     case CC_OP_DYNAMIC:
 656         /* unknown operation - assume 3 arguments and cc_op in env */
 657         gen_helper_calc_cc(cc_op, cpu_env, cc_op, cc_src, cc_dst, cc_vr);
 658         break;
 659     default:
 660         tcg_abort();
 661     }
 662
 663     tcg_temp_free_i32(local_cc_op);
 664     tcg_temp_free_i64(dummy);
 665
 666     /* We now have cc in cc_op as constant */
 667     set_cc_static(s);
 668 }
 669
 670 static inline void decode_rr(DisasContext *s, uint64_t insn, int *r1, int *r2)
 671 {
 672     debug_insn(insn);
 673
 674     *r1 = (insn >> 4) & 0xf;
 675     *r2 = insn & 0xf;
 676 }
 677
 678 static inline TCGv_i64 decode_rx(DisasContext *s, uint64_t insn, int *r1,
 679                                  int *x2, int *b2, int *d2)
 680 {
 681     debug_insn(insn);
 682
 683     *r1 = (insn >> 20) & 0xf;
 684     *x2 = (insn >> 16) & 0xf;
 685     *b2 = (insn >> 12) & 0xf;
 686     *d2 = insn & 0xfff;
 687
 688     return get_address(s, *x2, *b2, *d2);
 689 }
 690
 691 static inline void decode_rs(DisasContext *s, uint64_t insn, int *r1, int *r3,
 692                              int *b2, int *d2)
 693 {
 694     debug_insn(insn);
 695
 696     *r1 = (insn >> 20) & 0xf;
 697     /* aka m3 */
 698     *r3 = (insn >> 16) & 0xf;
 699     *b2 = (insn >> 12) & 0xf;
 700     *d2 = insn & 0xfff;
 701 }
 702
 703 static inline TCGv_i64 decode_si(DisasContext *s, uint64_t insn, int *i2,
 704                                  int *b1, int *d1)
 705 {
 706     debug_insn(insn);
 707
 708     *i2 = (insn >> 16) & 0xff;
 709     *b1 = (insn >> 12) & 0xf;
 710     *d1 = insn & 0xfff;
 711
 712     return get_address(s, 0, *b1, *d1);
 713 }
 714
 715 static int use_goto_tb(DisasContext *s, uint64_t dest)
 716 {
 717     /* NOTE: we handle the case where the TB spans two pages here */
 718     return (((dest & TARGET_PAGE_MASK) == (s->tb->pc & TARGET_PAGE_MASK)
 719              || (dest & TARGET_PAGE_MASK) == ((s->pc - 1) & TARGET_PAGE_MASK))
 720             && !s->singlestep_enabled
 721             && !(s->tb->cflags & CF_LAST_IO));
 722 }
 723
 724 static inline void gen_goto_tb(DisasContext *s, int tb_num, target_ulong pc)
 725 {
 726     gen_update_cc_op(s);
 727
 728     if (use_goto_tb(s, pc)) {
 729         tcg_gen_goto_tb(tb_num);
 730         tcg_gen_movi_i64(psw_addr, pc);
 731         tcg_gen_exit_tb((tcg_target_long)s->tb + tb_num);
 732     } else {
 733         /* jump to another page: currently not optimized */
 734         tcg_gen_movi_i64(psw_addr, pc);
 735         tcg_gen_exit_tb(0);
 736     }
 737 }
 738
 739 static inline void account_noninline_branch(DisasContext *s, int cc_op)
 740 {
 741 #ifdef DEBUG_INLINE_BRANCHES
 742     inline_branch_miss[cc_op]++;
 743 #endif
 744 }
 745
 746 static inline void account_inline_branch(DisasContext *s, int cc_op)
 747 {
 748 #ifdef DEBUG_INLINE_BRANCHES
 749     inline_branch_hit[cc_op]++;
 750 #endif
 751 }
 752
 753 /* Table of mask values to comparison codes, given a comparison as input.
 754    For a true comparison CC=3 will never be set, but we treat this
 755    conservatively for possible use when CC=3 indicates overflow.  */
 756 static const TCGCond ltgt_cond[16] = {
 757     TCG_COND_NEVER,  TCG_COND_NEVER,     /*    |    |    | x */
 758     TCG_COND_GT,     TCG_COND_NEVER,     /*    |    | GT | x */
 759     TCG_COND_LT,     TCG_COND_NEVER,     /*    | LT |    | x */
 760     TCG_COND_NE,     TCG_COND_NEVER,     /*    | LT | GT | x */
 761     TCG_COND_EQ,     TCG_COND_NEVER,     /* EQ |    |    | x */
 762     TCG_COND_GE,     TCG_COND_NEVER,     /* EQ |    | GT | x */
 763     TCG_COND_LE,     TCG_COND_NEVER,     /* EQ | LT |    | x */
 764     TCG_COND_ALWAYS, TCG_COND_ALWAYS,    /* EQ | LT | GT | x */
 765 };
 766
 767 /* Table of mask values to comparison codes, given a logic op as input.
 768    For such, only CC=0 and CC=1 should be possible.  */
 769 static const TCGCond nz_cond[16] = {
 770     /*    |    | x | x */
 771     TCG_COND_NEVER, TCG_COND_NEVER, TCG_COND_NEVER, TCG_COND_NEVER,
 772     /*    | NE | x | x */
 773     TCG_COND_NE, TCG_COND_NE, TCG_COND_NE, TCG_COND_NE,
 774     /* EQ |    | x | x */
 775     TCG_COND_EQ, TCG_COND_EQ, TCG_COND_EQ, TCG_COND_EQ,
 776     /* EQ | NE | x | x */
 777     TCG_COND_ALWAYS, TCG_COND_ALWAYS, TCG_COND_ALWAYS, TCG_COND_ALWAYS,
 778 };
 779
 780 /* Interpret MASK in terms of S->CC_OP, and fill in C with all the
 781    details required to generate a TCG comparison.  */
 782 static void disas_jcc(DisasContext *s, DisasCompare *c, uint32_t mask)
 783 {
 784     TCGCond cond;
 785     enum cc_op old_cc_op = s->cc_op;
 786
 787     if (mask == 15 || mask == 0) {
 788         c->cond = (mask ? TCG_COND_ALWAYS : TCG_COND_NEVER);
 789         c->u.s32.a = cc_op;
 790         c->u.s32.b = cc_op;
 791         c->g1 = c->g2 = true;
 792         c->is_64 = false;
 793         return;
 794     }
 795
 796     /* Find the TCG condition for the mask + cc op.  */
 797     switch (old_cc_op) {
 798     case CC_OP_LTGT0_32:
 799     case CC_OP_LTGT0_64:
 800     case CC_OP_LTGT_32:
 801     case CC_OP_LTGT_64:
 802         cond = ltgt_cond[mask];
 803         if (cond == TCG_COND_NEVER) {
 804             goto do_dynamic;
 805         }
 806         account_inline_branch(s, old_cc_op);
 807         break;
 808
 809     case CC_OP_LTUGTU_32:
 810     case CC_OP_LTUGTU_64:
 811         cond = tcg_unsigned_cond(ltgt_cond[mask]);
 812         if (cond == TCG_COND_NEVER) {
 813             goto do_dynamic;
 814         }
 815         account_inline_branch(s, old_cc_op);
 816         break;
 817
 818     case CC_OP_NZ:
 819         cond = nz_cond[mask];
 820         if (cond == TCG_COND_NEVER) {
 821             goto do_dynamic;
 822         }
 823         account_inline_branch(s, old_cc_op);
 824         break;
 825
 826     case CC_OP_TM_32:
 827     case CC_OP_TM_64:
 828         switch (mask) {
 829         case 8:
 830             cond = TCG_COND_EQ;
 831             break;
 832         case 4 | 2 | 1:
 833             cond = TCG_COND_NE;
 834             break;
 835         default:
 836             goto do_dynamic;
 837         }
 838         account_inline_branch(s, old_cc_op);
 839         break;
 840
 841     case CC_OP_ICM:
 842         switch (mask) {
 843         case 8:
 844             cond = TCG_COND_EQ;
 845             break;
 846         case 4 | 2 | 1:
 847         case 4 | 2:
 848             cond = TCG_COND_NE;
 849             break;
 850         default:
 851             goto do_dynamic;
 852         }
 853         account_inline_branch(s, old_cc_op);
 854         break;
 855
 856     case CC_OP_FLOGR:
 857         switch (mask & 0xa) {
 858         case 8: /* src == 0 -> no one bit found */
 859             cond = TCG_COND_EQ;
 860             break;
 861         case 2: /* src != 0 -> one bit found */
 862             cond = TCG_COND_NE;
 863             break;
 864         default:
 865             goto do_dynamic;
 866         }
 867         account_inline_branch(s, old_cc_op);
 868         break;
 869
 870     default:
 871     do_dynamic:
 872         /* Calculate cc value.  */
 873         gen_op_calc_cc(s);
 874         /* FALLTHRU */
 875
 876     case CC_OP_STATIC:
 877         /* Jump based on CC.  We'll load up the real cond below;
 878            the assignment here merely avoids a compiler warning.  */
 879         account_noninline_branch(s, old_cc_op);
 880         old_cc_op = CC_OP_STATIC;
 881         cond = TCG_COND_NEVER;
 882         break;
 883     }
 884
 885     /* Load up the arguments of the comparison.  */
 886     c->is_64 = true;
 887     c->g1 = c->g2 = false;
 888     switch (old_cc_op) {
 889     case CC_OP_LTGT0_32:
 890         c->is_64 = false;
 891         c->u.s32.a = tcg_temp_new_i32();
 892         tcg_gen_trunc_i64_i32(c->u.s32.a, cc_dst);
 893         c->u.s32.b = tcg_const_i32(0);
 894         break;
 895     case CC_OP_LTGT_32:
 896     case CC_OP_LTUGTU_32:
 897         c->is_64 = false;
 898         c->u.s32.a = tcg_temp_new_i32();
 899         tcg_gen_trunc_i64_i32(c->u.s32.a, cc_src);
 900         c->u.s32.b = tcg_temp_new_i32();
 901         tcg_gen_trunc_i64_i32(c->u.s32.b, cc_dst);
 902         break;
 903
 904     case CC_OP_LTGT0_64:
 905     case CC_OP_NZ:
 906     case CC_OP_FLOGR:
 907         c->u.s64.a = cc_dst;
 908         c->u.s64.b = tcg_const_i64(0);
 909         c->g1 = true;
 910         break;
 911     case CC_OP_LTGT_64:
 912     case CC_OP_LTUGTU_64:
 913         c->u.s64.a = cc_src;
 914         c->u.s64.b = cc_dst;
 915         c->g1 = c->g2 = true;
 916         break;
 917
 918     case CC_OP_TM_32:
 919     case CC_OP_TM_64:
 920     case CC_OP_ICM:
 921         c->u.s64.a = tcg_temp_new_i64();
 922         c->u.s64.b = tcg_const_i64(0);
 923         tcg_gen_and_i64(c->u.s64.a, cc_src, cc_dst);
 924         break;
 925
 926     case CC_OP_STATIC:
 927         c->is_64 = false;
 928         c->u.s32.a = cc_op;
 929         c->g1 = true;
 930         switch (mask) {
 931         case 0x8 | 0x4 | 0x2: /* cc != 3 */
 932             cond = TCG_COND_NE;
 933             c->u.s32.b = tcg_const_i32(3);
 934             break;
 935         case 0x8 | 0x4 | 0x1: /* cc != 2 */
 936             cond = TCG_COND_NE;
 937             c->u.s32.b = tcg_const_i32(2);
 938             break;
 939         case 0x8 | 0x2 | 0x1: /* cc != 1 */
 940             cond = TCG_COND_NE;
 941             c->u.s32.b = tcg_const_i32(1);
 942             break;
 943         case 0x8 | 0x2: /* cc == 0 || cc == 2 => (cc & 1) == 0 */
 944             cond = TCG_COND_EQ;
 945             c->g1 = false;
 946             c->u.s32.a = tcg_temp_new_i32();
 947             c->u.s32.b = tcg_const_i32(0);
 948             tcg_gen_andi_i32(c->u.s32.a, cc_op, 1);
 949             break;
 950         case 0x8 | 0x4: /* cc < 2 */
 951             cond = TCG_COND_LTU;
 952             c->u.s32.b = tcg_const_i32(2);
 953             break;
 954         case 0x8: /* cc == 0 */
 955             cond = TCG_COND_EQ;
 956             c->u.s32.b = tcg_const_i32(0);
 957             break;
 958         case 0x4 | 0x2 | 0x1: /* cc != 0 */
 959             cond = TCG_COND_NE;
 960             c->u.s32.b = tcg_const_i32(0);
 961             break;
 962         case 0x4 | 0x1: /* cc == 1 || cc == 3 => (cc & 1) != 0 */
 963             cond = TCG_COND_NE;
 964             c->g1 = false;
 965             c->u.s32.a = tcg_temp_new_i32();
 966             c->u.s32.b = tcg_const_i32(0);
 967             tcg_gen_andi_i32(c->u.s32.a, cc_op, 1);
 968             break;
 969         case 0x4: /* cc == 1 */
 970             cond = TCG_COND_EQ;
 971             c->u.s32.b = tcg_const_i32(1);
 972             break;
 973         case 0x2 | 0x1: /* cc > 1 */
 974             cond = TCG_COND_GTU;
 975             c->u.s32.b = tcg_const_i32(1);
 976             break;
 977         case 0x2: /* cc == 2 */
 978             cond = TCG_COND_EQ;
 979             c->u.s32.b = tcg_const_i32(2);
 980             break;
 981         case 0x1: /* cc == 3 */
 982             cond = TCG_COND_EQ;
 983             c->u.s32.b = tcg_const_i32(3);
 984             break;
 985         default:
 986             /* CC is masked by something else: (8 >> cc) & mask.  */
 987             cond = TCG_COND_NE;
 988             c->g1 = false;
 989             c->u.s32.a = tcg_const_i32(8);
 990             c->u.s32.b = tcg_const_i32(0);
 991             tcg_gen_shr_i32(c->u.s32.a, c->u.s32.a, cc_op);
 992             tcg_gen_andi_i32(c->u.s32.a, c->u.s32.a, mask);
 993             break;
 994         }
 995         break;
 996
 997     default:
 998         abort();
 999     }
1000     c->cond = cond;
1001 }
1002
1003 static void free_compare(DisasCompare *c)
1004 {
1005     if (!c->g1) {
1006         if (c->is_64) {
1007             tcg_temp_free_i64(c->u.s64.a);
1008         } else {
1009             tcg_temp_free_i32(c->u.s32.a);
1010         }
1011     }
1012     if (!c->g2) {
1013         if (c->is_64) {
1014             tcg_temp_free_i64(c->u.s64.b);
1015         } else {
1016             tcg_temp_free_i32(c->u.s32.b);
1017         }
1018     }
1019 }
1020
1021 static void disas_b2(CPUS390XState *env, DisasContext *s, int op,
1022                      uint32_t insn)
1023 {
1024 #ifndef CONFIG_USER_ONLY
1025     switch (op) {
1026     default:
1027 #endif
1028         LOG_DISAS("illegal b2 operation 0x%x\n", op);
1029         gen_illegal_opcode(s);
1030 #ifndef CONFIG_USER_ONLY
1031         break;
1032     }
1033 #endif
1034 }
1035
1036 static void disas_s390_insn(CPUS390XState *env, DisasContext *s)
1037 {
1038     unsigned char opc;
1039     uint64_t insn;
1040     int op;
1041
1042     opc = cpu_ldub_code(env, s->pc);
1043     LOG_DISAS("opc 0x%x\n", opc);
1044
1045     switch (opc) {
1046     case 0xb2:
1047         insn = ld_code4(env, s->pc);
1048         op = (insn >> 16) & 0xff;
1049         disas_b2(env, s, op, insn);
1050         break;
1051     default:
1052         qemu_log_mask(LOG_UNIMP, "unimplemented opcode 0x%x\n", opc);
1053         gen_illegal_opcode(s);
1054         break;
1055     }
1056 }
1057
1058 /* ====================================================================== */
1059 /* Define the insn format enumeration.  */
1060 #define F0(N)                         FMT_##N,
1061 #define F1(N, X1)                     F0(N)
1062 #define F2(N, X1, X2)                 F0(N)
1063 #define F3(N, X1, X2, X3)             F0(N)
1064 #define F4(N, X1, X2, X3, X4)         F0(N)
1065 #define F5(N, X1, X2, X3, X4, X5)     F0(N)
1066
1067 typedef enum {
1068 #include "insn-format.def"
1069 } DisasFormat;
1070
1071 #undef F0
1072 #undef F1
1073 #undef F2
1074 #undef F3
1075 #undef F4
1076 #undef F5
1077
1078 /* Define a structure to hold the decoded fields.  We'll store each inside
1079    an array indexed by an enum.  In order to conserve memory, we'll arrange
1080    for fields that do not exist at the same time to overlap, thus the "C"
1081    for compact.  For checking purposes there is an "O" for original index
1082    as well that will be applied to availability bitmaps.  */
1083
1084 enum DisasFieldIndexO {
1085     FLD_O_r1,
1086     FLD_O_r2,
1087     FLD_O_r3,
1088     FLD_O_m1,
1089     FLD_O_m3,
1090     FLD_O_m4,
1091     FLD_O_b1,
1092     FLD_O_b2,
1093     FLD_O_b4,
1094     FLD_O_d1,
1095     FLD_O_d2,
1096     FLD_O_d4,
1097     FLD_O_x2,
1098     FLD_O_l1,
1099     FLD_O_l2,
1100     FLD_O_i1,
1101     FLD_O_i2,
1102     FLD_O_i3,
1103     FLD_O_i4,
1104     FLD_O_i5
1105 };
1106
1107 enum DisasFieldIndexC {
1108     FLD_C_r1 = 0,
1109     FLD_C_m1 = 0,
1110     FLD_C_b1 = 0,
1111     FLD_C_i1 = 0,
1112
1113     FLD_C_r2 = 1,
1114     FLD_C_b2 = 1,
1115     FLD_C_i2 = 1,
1116
1117     FLD_C_r3 = 2,
1118     FLD_C_m3 = 2,
1119     FLD_C_i3 = 2,
1120
1121     FLD_C_m4 = 3,
1122     FLD_C_b4 = 3,
1123     FLD_C_i4 = 3,
1124     FLD_C_l1 = 3,
1125
1126     FLD_C_i5 = 4,
1127     FLD_C_d1 = 4,
1128
1129     FLD_C_d2 = 5,
1130
1131     FLD_C_d4 = 6,
1132     FLD_C_x2 = 6,
1133     FLD_C_l2 = 6,
1134
1135     NUM_C_FIELD = 7
1136 };
1137
1138 struct DisasFields {
1139     unsigned op:8;
1140     unsigned op2:8;
1141     unsigned presentC:16;
1142     unsigned int presentO;
1143     int c[NUM_C_FIELD];
1144 };
1145
1146 /* This is the way fields are to be accessed out of DisasFields.  */
1147 #define have_field(S, F)  have_field1((S), FLD_O_##F)
1148 #define get_field(S, F)   get_field1((S), FLD_O_##F, FLD_C_##F)
1149
1150 static bool have_field1(const DisasFields *f, enum DisasFieldIndexO c)
1151 {
1152     return (f->presentO >> c) & 1;
1153 }
1154
1155 static int get_field1(const DisasFields *f, enum DisasFieldIndexO o,
1156                       enum DisasFieldIndexC c)
1157 {
1158     assert(have_field1(f, o));
1159     return f->c[c];
1160 }
1161
1162 /* Describe the layout of each field in each format.  */
1163 typedef struct DisasField {
1164     unsigned int beg:8;
1165     unsigned int size:8;
1166     unsigned int type:2;
1167     unsigned int indexC:6;
1168     enum DisasFieldIndexO indexO:8;
1169 } DisasField;
1170
1171 typedef struct DisasFormatInfo {
1172     DisasField op[NUM_C_FIELD];
1173 } DisasFormatInfo;
1174
1175 #define R(N, B)       {  B,  4, 0, FLD_C_r##N, FLD_O_r##N }
1176 #define M(N, B)       {  B,  4, 0, FLD_C_m##N, FLD_O_m##N }
1177 #define BD(N, BB, BD) { BB,  4, 0, FLD_C_b##N, FLD_O_b##N }, \
1178                       { BD, 12, 0, FLD_C_d##N, FLD_O_d##N }
1179 #define BXD(N)        { 16,  4, 0, FLD_C_b##N, FLD_O_b##N }, \
1180                       { 12,  4, 0, FLD_C_x##N, FLD_O_x##N }, \
1181                       { 20, 12, 0, FLD_C_d##N, FLD_O_d##N }
1182 #define BDL(N)        { 16,  4, 0, FLD_C_b##N, FLD_O_b##N }, \
1183                       { 20, 20, 2, FLD_C_d##N, FLD_O_d##N }
1184 #define BXDL(N)       { 16,  4, 0, FLD_C_b##N, FLD_O_b##N }, \
1185                       { 12,  4, 0, FLD_C_x##N, FLD_O_x##N }, \
1186                       { 20, 20, 2, FLD_C_d##N, FLD_O_d##N }
1187 #define I(N, B, S)    {  B,  S, 1, FLD_C_i##N, FLD_O_i##N }
1188 #define L(N, B, S)    {  B,  S, 0, FLD_C_l##N, FLD_O_l##N }
1189
1190 #define F0(N)                     { { } },
1191 #define F1(N, X1)                 { { X1 } },
1192 #define F2(N, X1, X2)             { { X1, X2 } },
1193 #define F3(N, X1, X2, X3)         { { X1, X2, X3 } },
1194 #define F4(N, X1, X2, X3, X4)     { { X1, X2, X3, X4 } },
1195 #define F5(N, X1, X2, X3, X4, X5) { { X1, X2, X3, X4, X5 } },
1196
1197 static const DisasFormatInfo format_info[] = {
1198 #include "insn-format.def"
1199 };
1200
1201 #undef F0
1202 #undef F1
1203 #undef F2
1204 #undef F3
1205 #undef F4
1206 #undef F5
1207 #undef R
1208 #undef M
1209 #undef BD
1210 #undef BXD
1211 #undef BDL
1212 #undef BXDL
1213 #undef I
1214 #undef L
1215
1216 /* Generally, we'll extract operands into this structures, operate upon
1217    them, and store them back.  See the "in1", "in2", "prep", "wout" sets
1218    of routines below for more details.  */
1219 typedef struct {
1220     bool g_out, g_out2, g_in1, g_in2;
1221     TCGv_i64 out, out2, in1, in2;
1222     TCGv_i64 addr1;
1223 } DisasOps;
1224
1225 /* Return values from translate_one, indicating the state of the TB.  */
1226 typedef enum {
1227     /* Continue the TB.  */
1228     NO_EXIT,
1229     /* We have emitted one or more goto_tb.  No fixup required.  */
1230     EXIT_GOTO_TB,
1231     /* We are not using a goto_tb (for whatever reason), but have updated
1232        the PC (for whatever reason), so there's no need to do it again on
1233        exiting the TB.  */
1234     EXIT_PC_UPDATED,
1235     /* We are exiting the TB, but have neither emitted a goto_tb, nor
1236        updated the PC for the next instruction to be executed.  */
1237     EXIT_PC_STALE,
1238     /* We are ending the TB with a noreturn function call, e.g. longjmp.
1239        No following code will be executed.  */
1240     EXIT_NORETURN,
1241 } ExitStatus;
1242
1243 typedef enum DisasFacility {
1244     FAC_Z,                  /* zarch (default) */
1245     FAC_CASS,               /* compare and swap and store */
1246     FAC_CASS2,              /* compare and swap and store 2*/
1247     FAC_DFP,                /* decimal floating point */
1248     FAC_DFPR,               /* decimal floating point rounding */
1249     FAC_DO,                 /* distinct operands */
1250     FAC_EE,                 /* execute extensions */
1251     FAC_EI,                 /* extended immediate */
1252     FAC_FPE,                /* floating point extension */
1253     FAC_FPSSH,              /* floating point support sign handling */
1254     FAC_FPRGR,              /* FPR-GR transfer */
1255     FAC_GIE,                /* general instructions extension */
1256     FAC_HFP_MA,             /* HFP multiply-and-add/subtract */
1257     FAC_HW,                 /* high-word */
1258     FAC_IEEEE_SIM,          /* IEEE exception sumilation */
1259     FAC_LOC,                /* load/store on condition */
1260     FAC_LD,                 /* long displacement */
1261     FAC_PC,                 /* population count */
1262     FAC_SCF,                /* store clock fast */
1263     FAC_SFLE,               /* store facility list extended */
1264 } DisasFacility;
1265
1266 struct DisasInsn {
1267     unsigned opc:16;
1268     DisasFormat fmt:6;
1269     DisasFacility fac:6;
1270
1271     const char *name;
1272
1273     void (*help_in1)(DisasContext *, DisasFields *, DisasOps *);
1274     void (*help_in2)(DisasContext *, DisasFields *, DisasOps *);
1275     void (*help_prep)(DisasContext *, DisasFields *, DisasOps *);
1276     void (*help_wout)(DisasContext *, DisasFields *, DisasOps *);
1277     void (*help_cout)(DisasContext *, DisasOps *);
1278     ExitStatus (*help_op)(DisasContext *, DisasOps *);
1279
1280     uint64_t data;
1281 };
1282
1283 /* ====================================================================== */
1284 /* Miscelaneous helpers, used by several operations.  */
1285
1286 static void help_l2_shift(DisasContext *s, DisasFields *f,
1287                           DisasOps *o, int mask)
1288 {
1289     int b2 = get_field(f, b2);
1290     int d2 = get_field(f, d2);
1291
1292     if (b2 == 0) {
1293         o->in2 = tcg_const_i64(d2 & mask);
1294     } else {
1295         o->in2 = get_address(s, 0, b2, d2);
1296         tcg_gen_andi_i64(o->in2, o->in2, mask);
1297     }
1298 }
1299
1300 static ExitStatus help_goto_direct(DisasContext *s, uint64_t dest)
1301 {
1302     if (dest == s->next_pc) {
1303         return NO_EXIT;
1304     }
1305     if (use_goto_tb(s, dest)) {
1306         gen_update_cc_op(s);
1307         tcg_gen_goto_tb(0);
1308         tcg_gen_movi_i64(psw_addr, dest);
1309         tcg_gen_exit_tb((tcg_target_long)s->tb);
1310         return EXIT_GOTO_TB;
1311     } else {
1312         tcg_gen_movi_i64(psw_addr, dest);
1313         return EXIT_PC_UPDATED;
1314     }
1315 }
1316
1317 static ExitStatus help_branch(DisasContext *s, DisasCompare *c,
1318                               bool is_imm, int imm, TCGv_i64 cdest)
1319 {
1320     ExitStatus ret;
1321     uint64_t dest = s->pc + 2 * imm;
1322     int lab;
1323
1324     /* Take care of the special cases first.  */
1325     if (c->cond == TCG_COND_NEVER) {
1326         ret = NO_EXIT;
1327         goto egress;
1328     }
1329     if (is_imm) {
1330         if (dest == s->next_pc) {
1331             /* Branch to next.  */
1332             ret = NO_EXIT;
1333             goto egress;
1334         }
1335         if (c->cond == TCG_COND_ALWAYS) {
1336             ret = help_goto_direct(s, dest);
1337             goto egress;
1338         }
1339     } else {
1340         if (TCGV_IS_UNUSED_I64(cdest)) {
1341             /* E.g. bcr %r0 -> no branch.  */
1342             ret = NO_EXIT;
1343             goto egress;
1344         }
1345         if (c->cond == TCG_COND_ALWAYS) {
1346             tcg_gen_mov_i64(psw_addr, cdest);
1347             ret = EXIT_PC_UPDATED;
1348             goto egress;
1349         }
1350     }
1351
1352     if (use_goto_tb(s, s->next_pc)) {
1353         if (is_imm && use_goto_tb(s, dest)) {
1354             /* Both exits can use goto_tb.  */
1355             gen_update_cc_op(s);
1356
1357             lab = gen_new_label();
1358             if (c->is_64) {
1359                 tcg_gen_brcond_i64(c->cond, c->u.s64.a, c->u.s64.b, lab);
1360             } else {
1361                 tcg_gen_brcond_i32(c->cond, c->u.s32.a, c->u.s32.b, lab);
1362             }
1363
1364             /* Branch not taken.  */
1365             tcg_gen_goto_tb(0);
1366             tcg_gen_movi_i64(psw_addr, s->next_pc);
1367             tcg_gen_exit_tb((tcg_target_long)s->tb + 0);
1368
1369             /* Branch taken.  */
1370             gen_set_label(lab);
1371             tcg_gen_goto_tb(1);
1372             tcg_gen_movi_i64(psw_addr, dest);
1373             tcg_gen_exit_tb((tcg_target_long)s->tb + 1);
1374
1375             ret = EXIT_GOTO_TB;
1376         } else {
1377             /* Fallthru can use goto_tb, but taken branch cannot.  */
1378             /* Store taken branch destination before the brcond.  This
1379                avoids having to allocate a new local temp to hold it.
1380                We'll overwrite this in the not taken case anyway.  */
1381             if (!is_imm) {
1382                 tcg_gen_mov_i64(psw_addr, cdest);
1383             }
1384
1385             lab = gen_new_label();
1386             if (c->is_64) {
1387                 tcg_gen_brcond_i64(c->cond, c->u.s64.a, c->u.s64.b, lab);
1388             } else {
1389                 tcg_gen_brcond_i32(c->cond, c->u.s32.a, c->u.s32.b, lab);
1390             }
1391
1392             /* Branch not taken.  */
1393             gen_update_cc_op(s);
1394             tcg_gen_goto_tb(0);
1395             tcg_gen_movi_i64(psw_addr, s->next_pc);
1396             tcg_gen_exit_tb((tcg_target_long)s->tb + 0);
1397
1398             gen_set_label(lab);
1399             if (is_imm) {
1400                 tcg_gen_movi_i64(psw_addr, dest);
1401             }
1402             ret = EXIT_PC_UPDATED;
1403         }
1404     } else {
1405         /* Fallthru cannot use goto_tb.  This by itself is vanishingly rare.
1406            Most commonly we're single-stepping or some other condition that
1407            disables all use of goto_tb.  Just update the PC and exit.  */
1408
1409         TCGv_i64 next = tcg_const_i64(s->next_pc);
1410         if (is_imm) {
1411             cdest = tcg_const_i64(dest);
1412         }
1413
1414         if (c->is_64) {
1415             tcg_gen_movcond_i64(c->cond, psw_addr, c->u.s64.a, c->u.s64.b,
1416                                 cdest, next);
1417         } else {
1418             TCGv_i32 t0 = tcg_temp_new_i32();
1419             TCGv_i64 t1 = tcg_temp_new_i64();
1420             TCGv_i64 z = tcg_const_i64(0);
1421             tcg_gen_setcond_i32(c->cond, t0, c->u.s32.a, c->u.s32.b);
1422             tcg_gen_extu_i32_i64(t1, t0);
1423             tcg_temp_free_i32(t0);
1424             tcg_gen_movcond_i64(TCG_COND_NE, psw_addr, t1, z, cdest, next);
1425             tcg_temp_free_i64(t1);
1426             tcg_temp_free_i64(z);
1427         }
1428
1429         if (is_imm) {
1430             tcg_temp_free_i64(cdest);
1431         }
1432         tcg_temp_free_i64(next);
1433
1434         ret = EXIT_PC_UPDATED;
1435     }
1436
1437  egress:
1438     free_compare(c);
1439     return ret;
1440 }
1441
1442 /* ====================================================================== */
1443 /* The operations.  These perform the bulk of the work for any insn,
1444    usually after the operands have been loaded and output initialized.  */
1445
1446 static ExitStatus op_abs(DisasContext *s, DisasOps *o)
1447 {
1448     gen_helper_abs_i64(o->out, o->in2);
1449     return NO_EXIT;
1450 }
1451
1452 static ExitStatus op_absf32(DisasContext *s, DisasOps *o)
1453 {
1454     tcg_gen_andi_i64(o->out, o->in2, 0x7fffffffull);
1455     return NO_EXIT;
1456 }
1457
1458 static ExitStatus op_absf64(DisasContext *s, DisasOps *o)
1459 {
1460     tcg_gen_andi_i64(o->out, o->in2, 0x7fffffffffffffffull);
1461     return NO_EXIT;
1462 }
1463
1464 static ExitStatus op_absf128(DisasContext *s, DisasOps *o)
1465 {
1466     tcg_gen_andi_i64(o->out, o->in1, 0x7fffffffffffffffull);
1467     tcg_gen_mov_i64(o->out2, o->in2);
1468     return NO_EXIT;
1469 }
1470
1471 static ExitStatus op_add(DisasContext *s, DisasOps *o)
1472 {
1473     tcg_gen_add_i64(o->out, o->in1, o->in2);
1474     return NO_EXIT;
1475 }
1476
1477 static ExitStatus op_addc(DisasContext *s, DisasOps *o)
1478 {
1479     TCGv_i64 cc;
1480
1481     tcg_gen_add_i64(o->out, o->in1, o->in2);
1482
1483     /* XXX possible optimization point */
1484     gen_op_calc_cc(s);
1485     cc = tcg_temp_new_i64();
1486     tcg_gen_extu_i32_i64(cc, cc_op);
1487     tcg_gen_shri_i64(cc, cc, 1);
1488
1489     tcg_gen_add_i64(o->out, o->out, cc);
1490     tcg_temp_free_i64(cc);
1491     return NO_EXIT;
1492 }
1493
1494 static ExitStatus op_aeb(DisasContext *s, DisasOps *o)
1495 {
1496     gen_helper_aeb(o->out, cpu_env, o->in1, o->in2);
1497     return NO_EXIT;
1498 }
1499
1500 static ExitStatus op_adb(DisasContext *s, DisasOps *o)
1501 {
1502     gen_helper_adb(o->out, cpu_env, o->in1, o->in2);
1503     return NO_EXIT;
1504 }
1505
1506 static ExitStatus op_axb(DisasContext *s, DisasOps *o)
1507 {
1508     gen_helper_axb(o->out, cpu_env, o->out, o->out2, o->in1, o->in2);
1509     return_low128(o->out2);
1510     return NO_EXIT;
1511 }
1512
1513 static ExitStatus op_and(DisasContext *s, DisasOps *o)
1514 {
1515     tcg_gen_and_i64(o->out, o->in1, o->in2);
1516     return NO_EXIT;
1517 }
1518
1519 static ExitStatus op_andi(DisasContext *s, DisasOps *o)
1520 {
1521     int shift = s->insn->data & 0xff;
1522     int size = s->insn->data >> 8;
1523     uint64_t mask = ((1ull << size) - 1) << shift;
1524
1525     assert(!o->g_in2);
1526     tcg_gen_shli_i64(o->in2, o->in2, shift);
1527     tcg_gen_ori_i64(o->in2, o->in2, ~mask);
1528     tcg_gen_and_i64(o->out, o->in1, o->in2);
1529
1530     /* Produce the CC from only the bits manipulated.  */
1531     tcg_gen_andi_i64(cc_dst, o->out, mask);
1532     set_cc_nz_u64(s, cc_dst);
1533     return NO_EXIT;
1534 }
1535
1536 static ExitStatus op_bas(DisasContext *s, DisasOps *o)
1537 {
1538     tcg_gen_movi_i64(o->out, pc_to_link_info(s, s->next_pc));
1539     if (!TCGV_IS_UNUSED_I64(o->in2)) {
1540         tcg_gen_mov_i64(psw_addr, o->in2);
1541         return EXIT_PC_UPDATED;
1542     } else {
1543         return NO_EXIT;
1544     }
1545 }
1546
1547 static ExitStatus op_basi(DisasContext *s, DisasOps *o)
1548 {
1549     tcg_gen_movi_i64(o->out, pc_to_link_info(s, s->next_pc));
1550     return help_goto_direct(s, s->pc + 2 * get_field(s->fields, i2));
1551 }
1552
1553 static ExitStatus op_bc(DisasContext *s, DisasOps *o)
1554 {
1555     int m1 = get_field(s->fields, m1);
1556     bool is_imm = have_field(s->fields, i2);
1557     int imm = is_imm ? get_field(s->fields, i2) : 0;
1558     DisasCompare c;
1559
1560     disas_jcc(s, &c, m1);
1561     return help_branch(s, &c, is_imm, imm, o->in2);
1562 }
1563
1564 static ExitStatus op_bct32(DisasContext *s, DisasOps *o)
1565 {
1566     int r1 = get_field(s->fields, r1);
1567     bool is_imm = have_field(s->fields, i2);
1568     int imm = is_imm ? get_field(s->fields, i2) : 0;
1569     DisasCompare c;
1570     TCGv_i64 t;
1571
1572     c.cond = TCG_COND_NE;
1573     c.is_64 = false;
1574     c.g1 = false;
1575     c.g2 = false;
1576
1577     t = tcg_temp_new_i64();
1578     tcg_gen_subi_i64(t, regs[r1], 1);
1579     store_reg32_i64(r1, t);
1580     c.u.s32.a = tcg_temp_new_i32();
1581     c.u.s32.b = tcg_const_i32(0);
1582     tcg_gen_trunc_i64_i32(c.u.s32.a, t);
1583     tcg_temp_free_i64(t);
1584
1585     return help_branch(s, &c, is_imm, imm, o->in2);
1586 }
1587
1588 static ExitStatus op_bct64(DisasContext *s, DisasOps *o)
1589 {
1590     int r1 = get_field(s->fields, r1);
1591     bool is_imm = have_field(s->fields, i2);
1592     int imm = is_imm ? get_field(s->fields, i2) : 0;
1593     DisasCompare c;
1594
1595     c.cond = TCG_COND_NE;
1596     c.is_64 = true;
1597     c.g1 = true;
1598     c.g2 = false;
1599
1600     tcg_gen_subi_i64(regs[r1], regs[r1], 1);
1601     c.u.s64.a = regs[r1];
1602     c.u.s64.b = tcg_const_i64(0);
1603
1604     return help_branch(s, &c, is_imm, imm, o->in2);
1605 }
1606
1607 static ExitStatus op_ceb(DisasContext *s, DisasOps *o)
1608 {
1609     gen_helper_ceb(cc_op, cpu_env, o->in1, o->in2);
1610     set_cc_static(s);
1611     return NO_EXIT;
1612 }
1613
1614 static ExitStatus op_cdb(DisasContext *s, DisasOps *o)
1615 {
1616     gen_helper_cdb(cc_op, cpu_env, o->in1, o->in2);
1617     set_cc_static(s);
1618     return NO_EXIT;
1619 }
1620
1621 static ExitStatus op_cxb(DisasContext *s, DisasOps *o)
1622 {
1623     gen_helper_cxb(cc_op, cpu_env, o->out, o->out2, o->in1, o->in2);
1624     set_cc_static(s);
1625     return NO_EXIT;
1626 }
1627
1628 static ExitStatus op_cfeb(DisasContext *s, DisasOps *o)
1629 {
1630     TCGv_i32 m3 = tcg_const_i32(get_field(s->fields, m3));
1631     gen_helper_cfeb(o->out, cpu_env, o->in2, m3);
1632     tcg_temp_free_i32(m3);
1633     gen_set_cc_nz_f32(s, o->in2);
1634     return NO_EXIT;
1635 }
1636
1637 static ExitStatus op_cfdb(DisasContext *s, DisasOps *o)
1638 {
1639     TCGv_i32 m3 = tcg_const_i32(get_field(s->fields, m3));
1640     gen_helper_cfdb(o->out, cpu_env, o->in2, m3);
1641     tcg_temp_free_i32(m3);
1642     gen_set_cc_nz_f64(s, o->in2);
1643     return NO_EXIT;
1644 }
1645
1646 static ExitStatus op_cfxb(DisasContext *s, DisasOps *o)
1647 {
1648     TCGv_i32 m3 = tcg_const_i32(get_field(s->fields, m3));
1649     gen_helper_cfxb(o->out, cpu_env, o->in1, o->in2, m3);
1650     tcg_temp_free_i32(m3);
1651     gen_set_cc_nz_f128(s, o->in1, o->in2);
1652     return NO_EXIT;
1653 }
1654
1655 static ExitStatus op_cgeb(DisasContext *s, DisasOps *o)
1656 {
1657     TCGv_i32 m3 = tcg_const_i32(get_field(s->fields, m3));
1658     gen_helper_cgeb(o->out, cpu_env, o->in2, m3);
1659     tcg_temp_free_i32(m3);
1660     gen_set_cc_nz_f32(s, o->in2);
1661     return NO_EXIT;
1662 }
1663
1664 static ExitStatus op_cgdb(DisasContext *s, DisasOps *o)
1665 {
1666     TCGv_i32 m3 = tcg_const_i32(get_field(s->fields, m3));
1667     gen_helper_cgdb(o->out, cpu_env, o->in2, m3);
1668     tcg_temp_free_i32(m3);
1669     gen_set_cc_nz_f64(s, o->in2);
1670     return NO_EXIT;
1671 }
1672
1673 static ExitStatus op_cgxb(DisasContext *s, DisasOps *o)
1674 {
1675     TCGv_i32 m3 = tcg_const_i32(get_field(s->fields, m3));
1676     gen_helper_cgxb(o->out, cpu_env, o->in1, o->in2, m3);
1677     tcg_temp_free_i32(m3);
1678     gen_set_cc_nz_f128(s, o->in1, o->in2);
1679     return NO_EXIT;
1680 }
1681
1682 static ExitStatus op_cegb(DisasContext *s, DisasOps *o)
1683 {
1684     TCGv_i32 m3 = tcg_const_i32(get_field(s->fields, m3));
1685     gen_helper_cegb(o->out, cpu_env, o->in2, m3);
1686     tcg_temp_free_i32(m3);
1687     return NO_EXIT;
1688 }
1689
1690 static ExitStatus op_cdgb(DisasContext *s, DisasOps *o)
1691 {
1692     TCGv_i32 m3 = tcg_const_i32(get_field(s->fields, m3));
1693     gen_helper_cdgb(o->out, cpu_env, o->in2, m3);
1694     tcg_temp_free_i32(m3);
1695     return NO_EXIT;
1696 }
1697
1698 static ExitStatus op_cxgb(DisasContext *s, DisasOps *o)
1699 {
1700     TCGv_i32 m3 = tcg_const_i32(get_field(s->fields, m3));
1701     gen_helper_cxgb(o->out, cpu_env, o->in2, m3);
1702     tcg_temp_free_i32(m3);
1703     return_low128(o->out2);
1704     return NO_EXIT;
1705 }
1706
1707 static ExitStatus op_cksm(DisasContext *s, DisasOps *o)
1708 {
1709     int r2 = get_field(s->fields, r2);
1710     TCGv_i64 len = tcg_temp_new_i64();
1711
1712     potential_page_fault(s);
1713     gen_helper_cksm(len, cpu_env, o->in1, o->in2, regs[r2 + 1]);
1714     set_cc_static(s);
1715     return_low128(o->out);
1716
1717     tcg_gen_add_i64(regs[r2], regs[r2], len);
1718     tcg_gen_sub_i64(regs[r2 + 1], regs[r2 + 1], len);
1719     tcg_temp_free_i64(len);
1720
1721     return NO_EXIT;
1722 }
1723
1724 static ExitStatus op_clc(DisasContext *s, DisasOps *o)
1725 {
1726     int l = get_field(s->fields, l1);
1727     TCGv_i32 vl;
1728
1729     switch (l + 1) {
1730     case 1:
1731         tcg_gen_qemu_ld8u(cc_src, o->addr1, get_mem_index(s));
1732         tcg_gen_qemu_ld8u(cc_dst, o->in2, get_mem_index(s));
1733         break;
1734     case 2:
1735         tcg_gen_qemu_ld16u(cc_src, o->addr1, get_mem_index(s));
1736         tcg_gen_qemu_ld16u(cc_dst, o->in2, get_mem_index(s));
1737         break;
1738     case 4:
1739         tcg_gen_qemu_ld32u(cc_src, o->addr1, get_mem_index(s));
1740         tcg_gen_qemu_ld32u(cc_dst, o->in2, get_mem_index(s));
1741         break;
1742     case 8:
1743         tcg_gen_qemu_ld64(cc_src, o->addr1, get_mem_index(s));
1744         tcg_gen_qemu_ld64(cc_dst, o->in2, get_mem_index(s));
1745         break;
1746     default:
1747         potential_page_fault(s);
1748         vl = tcg_const_i32(l);
1749         gen_helper_clc(cc_op, cpu_env, vl, o->addr1, o->in2);
1750         tcg_temp_free_i32(vl);
1751         set_cc_static(s);
1752         return NO_EXIT;
1753     }
1754     gen_op_update2_cc_i64(s, CC_OP_LTUGTU_64, cc_src, cc_dst);
1755     return NO_EXIT;
1756 }
1757
1758 static ExitStatus op_clcle(DisasContext *s, DisasOps *o)
1759 {
1760     TCGv_i32 r1 = tcg_const_i32(get_field(s->fields, r1));
1761     TCGv_i32 r3 = tcg_const_i32(get_field(s->fields, r3));
1762     potential_page_fault(s);
1763     gen_helper_clcle(cc_op, cpu_env, r1, o->in2, r3);
1764     tcg_temp_free_i32(r1);
1765     tcg_temp_free_i32(r3);
1766     set_cc_static(s);
1767     return NO_EXIT;
1768 }
1769
1770 static ExitStatus op_clm(DisasContext *s, DisasOps *o)
1771 {
1772     TCGv_i32 m3 = tcg_const_i32(get_field(s->fields, m3));
1773     TCGv_i32 t1 = tcg_temp_new_i32();
1774     tcg_gen_trunc_i64_i32(t1, o->in1);
1775     potential_page_fault(s);
1776     gen_helper_clm(cc_op, cpu_env, t1, m3, o->in2);
1777     set_cc_static(s);
1778     tcg_temp_free_i32(t1);
1779     tcg_temp_free_i32(m3);
1780     return NO_EXIT;
1781 }
1782
1783 static ExitStatus op_clst(DisasContext *s, DisasOps *o)
1784 {
1785     potential_page_fault(s);
1786     gen_helper_clst(o->in1, cpu_env, regs[0], o->in1, o->in2);
1787     set_cc_static(s);
1788     return_low128(o->in2);
1789     return NO_EXIT;
1790 }
1791
1792 static ExitStatus op_cs(DisasContext *s, DisasOps *o)
1793 {
1794     int r3 = get_field(s->fields, r3);
1795     potential_page_fault(s);
1796     gen_helper_cs(o->out, cpu_env, o->in1, o->in2, regs[r3]);
1797     set_cc_static(s);
1798     return NO_EXIT;
1799 }
1800
1801 static ExitStatus op_csg(DisasContext *s, DisasOps *o)
1802 {
1803     int r3 = get_field(s->fields, r3);
1804     potential_page_fault(s);
1805     gen_helper_csg(o->out, cpu_env, o->in1, o->in2, regs[r3]);
1806     set_cc_static(s);
1807     return NO_EXIT;
1808 }
1809
1810 #ifndef CONFIG_USER_ONLY
1811 static ExitStatus op_csp(DisasContext *s, DisasOps *o)
1812 {
1813     TCGv_i32 r1 = tcg_const_i32(get_field(s->fields, r1));
1814     check_privileged(s);
1815     gen_helper_csp(cc_op, cpu_env, r1, o->in2);
1816     tcg_temp_free_i32(r1);
1817     set_cc_static(s);
1818     return NO_EXIT;
1819 }
1820 #endif
1821
1822 static ExitStatus op_cds(DisasContext *s, DisasOps *o)
1823 {
1824     int r3 = get_field(s->fields, r3);
1825     TCGv_i64 in3 = tcg_temp_new_i64();
1826     tcg_gen_deposit_i64(in3, regs[r3 + 1], regs[r3], 32, 32);
1827     potential_page_fault(s);
1828     gen_helper_csg(o->out, cpu_env, o->in1, o->in2, in3);
1829     tcg_temp_free_i64(in3);
1830     set_cc_static(s);
1831     return NO_EXIT;
1832 }
1833
1834 static ExitStatus op_cdsg(DisasContext *s, DisasOps *o)
1835 {
1836     TCGv_i32 r1 = tcg_const_i32(get_field(s->fields, r1));
1837     TCGv_i32 r3 = tcg_const_i32(get_field(s->fields, r3));
1838     potential_page_fault(s);
1839     /* XXX rewrite in tcg */
1840     gen_helper_cdsg(cc_op, cpu_env, r1, o->in2, r3);
1841     set_cc_static(s);
1842     return NO_EXIT;
1843 }
1844
1845 static ExitStatus op_cvd(DisasContext *s, DisasOps *o)
1846 {
1847     TCGv_i64 t1 = tcg_temp_new_i64();
1848     TCGv_i32 t2 = tcg_temp_new_i32();
1849     tcg_gen_trunc_i64_i32(t2, o->in1);
1850     gen_helper_cvd(t1, t2);
1851     tcg_temp_free_i32(t2);
1852     tcg_gen_qemu_st64(t1, o->in2, get_mem_index(s));
1853     tcg_temp_free_i64(t1);
1854     return NO_EXIT;
1855 }
1856
1857 #ifndef CONFIG_USER_ONLY
1858 static ExitStatus op_diag(DisasContext *s, DisasOps *o)
1859 {
1860     TCGv_i32 tmp;
1861
1862     check_privileged(s);
1863     potential_page_fault(s);
1864
1865     /* We pretend the format is RX_a so that D2 is the field we want.  */
1866     tmp = tcg_const_i32(get_field(s->fields, d2) & 0xfff);
1867     gen_helper_diag(regs[2], cpu_env, tmp, regs[2], regs[1]);
1868     tcg_temp_free_i32(tmp);
1869     return NO_EXIT;
1870 }
1871 #endif
1872
1873 static ExitStatus op_divs32(DisasContext *s, DisasOps *o)
1874 {
1875     gen_helper_divs32(o->out2, cpu_env, o->in1, o->in2);
1876     return_low128(o->out);
1877     return NO_EXIT;
1878 }
1879
1880 static ExitStatus op_divu32(DisasContext *s, DisasOps *o)
1881 {
1882     gen_helper_divu32(o->out2, cpu_env, o->in1, o->in2);
1883     return_low128(o->out);
1884     return NO_EXIT;
1885 }
1886
1887 static ExitStatus op_divs64(DisasContext *s, DisasOps *o)
1888 {
1889     gen_helper_divs64(o->out2, cpu_env, o->in1, o->in2);
1890     return_low128(o->out);
1891     return NO_EXIT;
1892 }
1893
1894 static ExitStatus op_divu64(DisasContext *s, DisasOps *o)
1895 {
1896     gen_helper_divu64(o->out2, cpu_env, o->out, o->out2, o->in2);
1897     return_low128(o->out);
1898     return NO_EXIT;
1899 }
1900
1901 static ExitStatus op_deb(DisasContext *s, DisasOps *o)
1902 {
1903     gen_helper_deb(o->out, cpu_env, o->in1, o->in2);
1904     return NO_EXIT;
1905 }
1906
1907 static ExitStatus op_ddb(DisasContext *s, DisasOps *o)
1908 {
1909     gen_helper_ddb(o->out, cpu_env, o->in1, o->in2);
1910     return NO_EXIT;
1911 }
1912
1913 static ExitStatus op_dxb(DisasContext *s, DisasOps *o)
1914 {
1915     gen_helper_dxb(o->out, cpu_env, o->out, o->out2, o->in1, o->in2);
1916     return_low128(o->out2);
1917     return NO_EXIT;
1918 }
1919
1920 static ExitStatus op_ear(DisasContext *s, DisasOps *o)
1921 {
1922     int r2 = get_field(s->fields, r2);
1923     tcg_gen_ld32u_i64(o->out, cpu_env, offsetof(CPUS390XState, aregs[r2]));
1924     return NO_EXIT;
1925 }
1926
1927 static ExitStatus op_efpc(DisasContext *s, DisasOps *o)
1928 {
1929     tcg_gen_ld32u_i64(o->out, cpu_env, offsetof(CPUS390XState, fpc));
1930     return NO_EXIT;
1931 }
1932
1933 static ExitStatus op_ex(DisasContext *s, DisasOps *o)
1934 {
1935     /* ??? Perhaps a better way to implement EXECUTE is to set a bit in
1936        tb->flags, (ab)use the tb->cs_base field as the address of
1937        the template in memory, and grab 8 bits of tb->flags/cflags for
1938        the contents of the register.  We would then recognize all this
1939        in gen_intermediate_code_internal, generating code for exactly
1940        one instruction.  This new TB then gets executed normally.
1941
1942        On the other hand, this seems to be mostly used for modifying
1943        MVC inside of memcpy, which needs a helper call anyway.  So
1944        perhaps this doesn't bear thinking about any further.  */
1945
1946     TCGv_i64 tmp;
1947
1948     update_psw_addr(s);
1949     gen_op_calc_cc(s);
1950
1951     tmp = tcg_const_i64(s->next_pc);
1952     gen_helper_ex(cc_op, cpu_env, cc_op, o->in1, o->in2, tmp);
1953     tcg_temp_free_i64(tmp);
1954
1955     set_cc_static(s);
1956     return NO_EXIT;
1957 }
1958
1959 static ExitStatus op_flogr(DisasContext *s, DisasOps *o)
1960 {
1961     /* We'll use the original input for cc computation, since we get to
1962        compare that against 0, which ought to be better than comparing
1963        the real output against 64.  It also lets cc_dst be a convenient
1964        temporary during our computation.  */
1965     gen_op_update1_cc_i64(s, CC_OP_FLOGR, o->in2);
1966
1967     /* R1 = IN ? CLZ(IN) : 64.  */
1968     gen_helper_clz(o->out, o->in2);
1969
1970     /* R1+1 = IN & ~(found bit).  Note that we may attempt to shift this
1971        value by 64, which is undefined.  But since the shift is 64 iff the
1972        input is zero, we still get the correct result after and'ing.  */
1973     tcg_gen_movi_i64(o->out2, 0x8000000000000000ull);
1974     tcg_gen_shr_i64(o->out2, o->out2, o->out);
1975     tcg_gen_andc_i64(o->out2, cc_dst, o->out2);
1976     return NO_EXIT;
1977 }
1978
1979 static ExitStatus op_icm(DisasContext *s, DisasOps *o)
1980 {
1981     int m3 = get_field(s->fields, m3);
1982     int pos, len, base = s->insn->data;
1983     TCGv_i64 tmp = tcg_temp_new_i64();
1984     uint64_t ccm;
1985
1986     switch (m3) {
1987     case 0xf:
1988         /* Effectively a 32-bit load.  */
1989         tcg_gen_qemu_ld32u(tmp, o->in2, get_mem_index(s));
1990         len = 32;
1991         goto one_insert;
1992
1993     case 0xc:
1994     case 0x6:
1995     case 0x3:
1996         /* Effectively a 16-bit load.  */
1997         tcg_gen_qemu_ld16u(tmp, o->in2, get_mem_index(s));
1998         len = 16;
1999         goto one_insert;
2000
2001     case 0x8:
2002     case 0x4:
2003     case 0x2:
2004     case 0x1:
2005         /* Effectively an 8-bit load.  */
2006         tcg_gen_qemu_ld8u(tmp, o->in2, get_mem_index(s));
2007         len = 8;
2008         goto one_insert;
2009
2010     one_insert:
2011         pos = base + ctz32(m3) * 8;
2012         tcg_gen_deposit_i64(o->out, o->out, tmp, pos, len);
2013         ccm = ((1ull << len) - 1) << pos;
2014         break;
2015
2016     default:
2017         /* This is going to be a sequence of loads and inserts.  */
2018         pos = base + 32 - 8;
2019         ccm = 0;
2020         while (m3) {
2021             if (m3 & 0x8) {
2022                 tcg_gen_qemu_ld8u(tmp, o->in2, get_mem_index(s));
2023                 tcg_gen_addi_i64(o->in2, o->in2, 1);
2024                 tcg_gen_deposit_i64(o->out, o->out, tmp, pos, 8);
2025                 ccm |= 0xff << pos;
2026             }
2027             m3 = (m3 << 1) & 0xf;
2028             pos -= 8;
2029         }
2030         break;
2031     }
2032
2033     tcg_gen_movi_i64(tmp, ccm);
2034     gen_op_update2_cc_i64(s, CC_OP_ICM, tmp, o->out);
2035     tcg_temp_free_i64(tmp);
2036     return NO_EXIT;
2037 }
2038
2039 static ExitStatus op_insi(DisasContext *s, DisasOps *o)
2040 {
2041     int shift = s->insn->data & 0xff;
2042     int size = s->insn->data >> 8;
2043     tcg_gen_deposit_i64(o->out, o->in1, o->in2, shift, size);
2044     return NO_EXIT;
2045 }
2046
2047 static ExitStatus op_ipm(DisasContext *s, DisasOps *o)
2048 {
2049     TCGv_i64 t1;
2050
2051     gen_op_calc_cc(s);
2052     tcg_gen_andi_i64(o->out, o->out, ~0xff000000ull);
2053
2054     t1 = tcg_temp_new_i64();
2055     tcg_gen_shli_i64(t1, psw_mask, 20);
2056     tcg_gen_shri_i64(t1, t1, 36);
2057     tcg_gen_or_i64(o->out, o->out, t1);
2058
2059     tcg_gen_extu_i32_i64(t1, cc_op);
2060     tcg_gen_shli_i64(t1, t1, 28);
2061     tcg_gen_or_i64(o->out, o->out, t1);
2062     tcg_temp_free_i64(t1);
2063     return NO_EXIT;
2064 }
2065
2066 #ifndef CONFIG_USER_ONLY
2067 static ExitStatus op_ipte(DisasContext *s, DisasOps *o)
2068 {
2069     check_privileged(s);
2070     gen_helper_ipte(cpu_env, o->in1, o->in2);
2071     return NO_EXIT;
2072 }
2073
2074 static ExitStatus op_iske(DisasContext *s, DisasOps *o)
2075 {
2076     check_privileged(s);
2077     gen_helper_iske(o->out, cpu_env, o->in2);
2078     return NO_EXIT;
2079 }
2080 #endif
2081
2082 static ExitStatus op_ldeb(DisasContext *s, DisasOps *o)
2083 {
2084     gen_helper_ldeb(o->out, cpu_env, o->in2);
2085     return NO_EXIT;
2086 }
2087
2088 static ExitStatus op_ledb(DisasContext *s, DisasOps *o)
2089 {
2090     gen_helper_ledb(o->out, cpu_env, o->in2);
2091     return NO_EXIT;
2092 }
2093
2094 static ExitStatus op_ldxb(DisasContext *s, DisasOps *o)
2095 {
2096     gen_helper_ldxb(o->out, cpu_env, o->in1, o->in2);
2097     return NO_EXIT;
2098 }
2099
2100 static ExitStatus op_lexb(DisasContext *s, DisasOps *o)
2101 {
2102     gen_helper_lexb(o->out, cpu_env, o->in1, o->in2);
2103     return NO_EXIT;
2104 }
2105
2106 static ExitStatus op_lxdb(DisasContext *s, DisasOps *o)
2107 {
2108     gen_helper_lxdb(o->out, cpu_env, o->in2);
2109     return_low128(o->out2);
2110     return NO_EXIT;
2111 }
2112
2113 static ExitStatus op_lxeb(DisasContext *s, DisasOps *o)
2114 {
2115     gen_helper_lxeb(o->out, cpu_env, o->in2);
2116     return_low128(o->out2);
2117     return NO_EXIT;
2118 }
2119
2120 static ExitStatus op_llgt(DisasContext *s, DisasOps *o)
2121 {
2122     tcg_gen_andi_i64(o->out, o->in2, 0x7fffffff);
2123     return NO_EXIT;
2124 }
2125
2126 static ExitStatus op_ld8s(DisasContext *s, DisasOps *o)
2127 {
2128     tcg_gen_qemu_ld8s(o->out, o->in2, get_mem_index(s));
2129     return NO_EXIT;
2130 }
2131
2132 static ExitStatus op_ld8u(DisasContext *s, DisasOps *o)
2133 {
2134     tcg_gen_qemu_ld8u(o->out, o->in2, get_mem_index(s));
2135     return NO_EXIT;
2136 }
2137
2138 static ExitStatus op_ld16s(DisasContext *s, DisasOps *o)
2139 {
2140     tcg_gen_qemu_ld16s(o->out, o->in2, get_mem_index(s));
2141     return NO_EXIT;
2142 }
2143
2144 static ExitStatus op_ld16u(DisasContext *s, DisasOps *o)
2145 {
2146     tcg_gen_qemu_ld16u(o->out, o->in2, get_mem_index(s));
2147     return NO_EXIT;
2148 }
2149
2150 static ExitStatus op_ld32s(DisasContext *s, DisasOps *o)
2151 {
2152     tcg_gen_qemu_ld32s(o->out, o->in2, get_mem_index(s));
2153     return NO_EXIT;
2154 }
2155
2156 static ExitStatus op_ld32u(DisasContext *s, DisasOps *o)
2157 {
2158     tcg_gen_qemu_ld32u(o->out, o->in2, get_mem_index(s));
2159     return NO_EXIT;
2160 }
2161
2162 static ExitStatus op_ld64(DisasContext *s, DisasOps *o)
2163 {
2164     tcg_gen_qemu_ld64(o->out, o->in2, get_mem_index(s));
2165     return NO_EXIT;
2166 }
2167
2168 #ifndef CONFIG_USER_ONLY
2169 static ExitStatus op_lctl(DisasContext *s, DisasOps *o)
2170 {
2171     TCGv_i32 r1 = tcg_const_i32(get_field(s->fields, r1));
2172     TCGv_i32 r3 = tcg_const_i32(get_field(s->fields, r3));
2173     check_privileged(s);
2174     potential_page_fault(s);
2175     gen_helper_lctl(cpu_env, r1, o->in2, r3);
2176     tcg_temp_free_i32(r1);
2177     tcg_temp_free_i32(r3);
2178     return NO_EXIT;
2179 }
2180
2181 static ExitStatus op_lctlg(DisasContext *s, DisasOps *o)
2182 {
2183     TCGv_i32 r1 = tcg_const_i32(get_field(s->fields, r1));
2184     TCGv_i32 r3 = tcg_const_i32(get_field(s->fields, r3));
2185     check_privileged(s);
2186     potential_page_fault(s);
2187     gen_helper_lctlg(cpu_env, r1, o->in2, r3);
2188     tcg_temp_free_i32(r1);
2189     tcg_temp_free_i32(r3);
2190     return NO_EXIT;
2191 }
2192 static ExitStatus op_lra(DisasContext *s, DisasOps *o)
2193 {
2194     check_privileged(s);
2195     potential_page_fault(s);
2196     gen_helper_lra(o->out, cpu_env, o->in2);
2197     set_cc_static(s);
2198     return NO_EXIT;
2199 }
2200
2201 static ExitStatus op_lpsw(DisasContext *s, DisasOps *o)
2202 {
2203     TCGv_i64 t1, t2;
2204
2205     check_privileged(s);
2206
2207     t1 = tcg_temp_new_i64();
2208     t2 = tcg_temp_new_i64();
2209     tcg_gen_qemu_ld32u(t1, o->in2, get_mem_index(s));
2210     tcg_gen_addi_i64(o->in2, o->in2, 4);
2211     tcg_gen_qemu_ld32u(t2, o->in2, get_mem_index(s));
2212     /* Convert the 32-bit PSW_MASK into the 64-bit PSW_MASK.  */
2213     tcg_gen_shli_i64(t1, t1, 32);
2214     gen_helper_load_psw(cpu_env, t1, t2);
2215     tcg_temp_free_i64(t1);
2216     tcg_temp_free_i64(t2);
2217     return EXIT_NORETURN;
2218 }
2219
2220 static ExitStatus op_lpswe(DisasContext *s, DisasOps *o)
2221 {
2222     TCGv_i64 t1, t2;
2223
2224     check_privileged(s);
2225
2226     t1 = tcg_temp_new_i64();
2227     t2 = tcg_temp_new_i64();
2228     tcg_gen_qemu_ld64(t1, o->in2, get_mem_index(s));
2229     tcg_gen_addi_i64(o->in2, o->in2, 8);
2230     tcg_gen_qemu_ld64(t2, o->in2, get_mem_index(s));
2231     gen_helper_load_psw(cpu_env, t1, t2);
2232     tcg_temp_free_i64(t1);
2233     tcg_temp_free_i64(t2);
2234     return EXIT_NORETURN;
2235 }
2236 #endif
2237
2238 static ExitStatus op_lam(DisasContext *s, DisasOps *o)
2239 {
2240     TCGv_i32 r1 = tcg_const_i32(get_field(s->fields, r1));
2241     TCGv_i32 r3 = tcg_const_i32(get_field(s->fields, r3));
2242     potential_page_fault(s);
2243     gen_helper_lam(cpu_env, r1, o->in2, r3);
2244     tcg_temp_free_i32(r1);
2245     tcg_temp_free_i32(r3);
2246     return NO_EXIT;
2247 }
2248
2249 static ExitStatus op_lm32(DisasContext *s, DisasOps *o)
2250 {
2251     int r1 = get_field(s->fields, r1);
2252     int r3 = get_field(s->fields, r3);
2253     TCGv_i64 t = tcg_temp_new_i64();
2254     TCGv_i64 t4 = tcg_const_i64(4);
2255
2256     while (1) {
2257         tcg_gen_qemu_ld32u(t, o->in2, get_mem_index(s));
2258         store_reg32_i64(r1, t);
2259         if (r1 == r3) {
2260             break;
2261         }
2262         tcg_gen_add_i64(o->in2, o->in2, t4);
2263         r1 = (r1 + 1) & 15;
2264     }
2265
2266     tcg_temp_free_i64(t);
2267     tcg_temp_free_i64(t4);
2268     return NO_EXIT;
2269 }
2270
2271 static ExitStatus op_lmh(DisasContext *s, DisasOps *o)
2272 {
2273     int r1 = get_field(s->fields, r1);
2274     int r3 = get_field(s->fields, r3);
2275     TCGv_i64 t = tcg_temp_new_i64();
2276     TCGv_i64 t4 = tcg_const_i64(4);
2277
2278     while (1) {
2279         tcg_gen_qemu_ld32u(t, o->in2, get_mem_index(s));
2280         store_reg32h_i64(r1, t);
2281         if (r1 == r3) {
2282             break;
2283         }
2284         tcg_gen_add_i64(o->in2, o->in2, t4);
2285         r1 = (r1 + 1) & 15;
2286     }
2287
2288     tcg_temp_free_i64(t);
2289     tcg_temp_free_i64(t4);
2290     return NO_EXIT;
2291 }
2292
2293 static ExitStatus op_lm64(DisasContext *s, DisasOps *o)
2294 {
2295     int r1 = get_field(s->fields, r1);
2296     int r3 = get_field(s->fields, r3);
2297     TCGv_i64 t8 = tcg_const_i64(8);
2298
2299     while (1) {
2300         tcg_gen_qemu_ld64(regs[r1], o->in2, get_mem_index(s));
2301         if (r1 == r3) {
2302             break;
2303         }
2304         tcg_gen_add_i64(o->in2, o->in2, t8);
2305         r1 = (r1 + 1) & 15;
2306     }
2307
2308     tcg_temp_free_i64(t8);
2309     return NO_EXIT;
2310 }
2311
2312 static ExitStatus op_mov2(DisasContext *s, DisasOps *o)
2313 {
2314     o->out = o->in2;
2315     o->g_out = o->g_in2;
2316     TCGV_UNUSED_I64(o->in2);
2317     o->g_in2 = false;
2318     return NO_EXIT;
2319 }
2320
2321 static ExitStatus op_movx(DisasContext *s, DisasOps *o)
2322 {
2323     o->out = o->in1;
2324     o->out2 = o->in2;
2325     o->g_out = o->g_in1;
2326     o->g_out2 = o->g_in2;
2327     TCGV_UNUSED_I64(o->in1);
2328     TCGV_UNUSED_I64(o->in2);
2329     o->g_in1 = o->g_in2 = false;
2330     return NO_EXIT;
2331 }
2332
2333 static ExitStatus op_mvc(DisasContext *s, DisasOps *o)
2334 {
2335     TCGv_i32 l = tcg_const_i32(get_field(s->fields, l1));
2336     potential_page_fault(s);
2337     gen_helper_mvc(cpu_env, l, o->addr1, o->in2);
2338     tcg_temp_free_i32(l);
2339     return NO_EXIT;
2340 }
2341
2342 static ExitStatus op_mvcl(DisasContext *s, DisasOps *o)
2343 {
2344     TCGv_i32 r1 = tcg_const_i32(get_field(s->fields, r1));
2345     TCGv_i32 r2 = tcg_const_i32(get_field(s->fields, r2));
2346     potential_page_fault(s);
2347     gen_helper_mvcl(cc_op, cpu_env, r1, r2);
2348     tcg_temp_free_i32(r1);
2349     tcg_temp_free_i32(r2);
2350     set_cc_static(s);
2351     return NO_EXIT;
2352 }
2353
2354 static ExitStatus op_mvcle(DisasContext *s, DisasOps *o)
2355 {
2356     TCGv_i32 r1 = tcg_const_i32(get_field(s->fields, r1));
2357     TCGv_i32 r3 = tcg_const_i32(get_field(s->fields, r3));
2358     potential_page_fault(s);
2359     gen_helper_mvcle(cc_op, cpu_env, r1, o->in2, r3);
2360     tcg_temp_free_i32(r1);
2361     tcg_temp_free_i32(r3);
2362     set_cc_static(s);
2363     return NO_EXIT;
2364 }
2365
2366 #ifndef CONFIG_USER_ONLY
2367 static ExitStatus op_mvcp(DisasContext *s, DisasOps *o)
2368 {
2369     int r1 = get_field(s->fields, l1);
2370     check_privileged(s);
2371     potential_page_fault(s);
2372     gen_helper_mvcp(cc_op, cpu_env, regs[r1], o->addr1, o->in2);
2373     set_cc_static(s);
2374     return NO_EXIT;
2375 }
2376
2377 static ExitStatus op_mvcs(DisasContext *s, DisasOps *o)
2378 {
2379     int r1 = get_field(s->fields, l1);
2380     check_privileged(s);
2381     potential_page_fault(s);
2382     gen_helper_mvcs(cc_op, cpu_env, regs[r1], o->addr1, o->in2);
2383     set_cc_static(s);
2384     return NO_EXIT;
2385 }
2386 #endif
2387
2388 static ExitStatus op_mvpg(DisasContext *s, DisasOps *o)
2389 {
2390     potential_page_fault(s);
2391     gen_helper_mvpg(cpu_env, regs[0], o->in1, o->in2);
2392     set_cc_static(s);
2393     return NO_EXIT;
2394 }
2395
2396 static ExitStatus op_mvst(DisasContext *s, DisasOps *o)
2397 {
2398     potential_page_fault(s);
2399     gen_helper_mvst(o->in1, cpu_env, regs[0], o->in1, o->in2);
2400     set_cc_static(s);
2401     return_low128(o->in2);
2402     return NO_EXIT;
2403 }
2404
2405 static ExitStatus op_mul(DisasContext *s, DisasOps *o)
2406 {
2407     tcg_gen_mul_i64(o->out, o->in1, o->in2);
2408     return NO_EXIT;
2409 }
2410
2411 static ExitStatus op_mul128(DisasContext *s, DisasOps *o)
2412 {
2413     gen_helper_mul128(o->out, cpu_env, o->in1, o->in2);
2414     return_low128(o->out2);
2415     return NO_EXIT;
2416 }
2417
2418 static ExitStatus op_meeb(DisasContext *s, DisasOps *o)
2419 {
2420     gen_helper_meeb(o->out, cpu_env, o->in1, o->in2);
2421     return NO_EXIT;
2422 }
2423
2424 static ExitStatus op_mdeb(DisasContext *s, DisasOps *o)
2425 {
2426     gen_helper_mdeb(o->out, cpu_env, o->in1, o->in2);
2427     return NO_EXIT;
2428 }
2429
2430 static ExitStatus op_mdb(DisasContext *s, DisasOps *o)
2431 {
2432     gen_helper_mdb(o->out, cpu_env, o->in1, o->in2);
2433     return NO_EXIT;
2434 }
2435
2436 static ExitStatus op_mxb(DisasContext *s, DisasOps *o)
2437 {
2438     gen_helper_mxb(o->out, cpu_env, o->out, o->out2, o->in1, o->in2);
2439     return_low128(o->out2);
2440     return NO_EXIT;
2441 }
2442
2443 static ExitStatus op_mxdb(DisasContext *s, DisasOps *o)
2444 {
2445     gen_helper_mxdb(o->out, cpu_env, o->out, o->out2, o->in2);
2446     return_low128(o->out2);
2447     return NO_EXIT;
2448 }
2449
2450 static ExitStatus op_maeb(DisasContext *s, DisasOps *o)
2451 {
2452     TCGv_i64 r3 = load_freg32_i64(get_field(s->fields, r3));
2453     gen_helper_maeb(o->out, cpu_env, o->in1, o->in2, r3);
2454     tcg_temp_free_i64(r3);
2455     return NO_EXIT;
2456 }
2457
2458 static ExitStatus op_madb(DisasContext *s, DisasOps *o)
2459 {
2460     int r3 = get_field(s->fields, r3);
2461     gen_helper_madb(o->out, cpu_env, o->in1, o->in2, fregs[r3]);
2462     return NO_EXIT;
2463 }
2464
2465 static ExitStatus op_mseb(DisasContext *s, DisasOps *o)
2466 {
2467     TCGv_i64 r3 = load_freg32_i64(get_field(s->fields, r3));
2468     gen_helper_mseb(o->out, cpu_env, o->in1, o->in2, r3);
2469     tcg_temp_free_i64(r3);
2470     return NO_EXIT;
2471 }
2472
2473 static ExitStatus op_msdb(DisasContext *s, DisasOps *o)
2474 {
2475     int r3 = get_field(s->fields, r3);
2476     gen_helper_msdb(o->out, cpu_env, o->in1, o->in2, fregs[r3]);
2477     return NO_EXIT;
2478 }
2479
2480 static ExitStatus op_nabs(DisasContext *s, DisasOps *o)
2481 {
2482     gen_helper_nabs_i64(o->out, o->in2);
2483     return NO_EXIT;
2484 }
2485
2486 static ExitStatus op_nabsf32(DisasContext *s, DisasOps *o)
2487 {
2488     tcg_gen_ori_i64(o->out, o->in2, 0x80000000ull);
2489     return NO_EXIT;
2490 }
2491
2492 static ExitStatus op_nabsf64(DisasContext *s, DisasOps *o)
2493 {
2494     tcg_gen_ori_i64(o->out, o->in2, 0x8000000000000000ull);
2495     return NO_EXIT;
2496 }
2497
2498 static ExitStatus op_nabsf128(DisasContext *s, DisasOps *o)
2499 {
2500     tcg_gen_ori_i64(o->out, o->in1, 0x8000000000000000ull);
2501     tcg_gen_mov_i64(o->out2, o->in2);
2502     return NO_EXIT;
2503 }
2504
2505 static ExitStatus op_nc(DisasContext *s, DisasOps *o)
2506 {
2507     TCGv_i32 l = tcg_const_i32(get_field(s->fields, l1));
2508     potential_page_fault(s);
2509     gen_helper_nc(cc_op, cpu_env, l, o->addr1, o->in2);
2510     tcg_temp_free_i32(l);
2511     set_cc_static(s);
2512     return NO_EXIT;
2513 }
2514
2515 static ExitStatus op_neg(DisasContext *s, DisasOps *o)
2516 {
2517     tcg_gen_neg_i64(o->out, o->in2);
2518     return NO_EXIT;
2519 }
2520
2521 static ExitStatus op_negf32(DisasContext *s, DisasOps *o)
2522 {
2523     tcg_gen_xori_i64(o->out, o->in2, 0x80000000ull);
2524     return NO_EXIT;
2525 }
2526
2527 static ExitStatus op_negf64(DisasContext *s, DisasOps *o)
2528 {
2529     tcg_gen_xori_i64(o->out, o->in2, 0x8000000000000000ull);
2530     return NO_EXIT;
2531 }
2532
2533 static ExitStatus op_negf128(DisasContext *s, DisasOps *o)
2534 {
2535     tcg_gen_xori_i64(o->out, o->in1, 0x8000000000000000ull);
2536     tcg_gen_mov_i64(o->out2, o->in2);
2537     return NO_EXIT;
2538 }
2539
2540 static ExitStatus op_oc(DisasContext *s, DisasOps *o)
2541 {
2542     TCGv_i32 l = tcg_const_i32(get_field(s->fields, l1));
2543     potential_page_fault(s);
2544     gen_helper_oc(cc_op, cpu_env, l, o->addr1, o->in2);
2545     tcg_temp_free_i32(l);
2546     set_cc_static(s);
2547     return NO_EXIT;
2548 }
2549
2550 static ExitStatus op_or(DisasContext *s, DisasOps *o)
2551 {
2552     tcg_gen_or_i64(o->out, o->in1, o->in2);
2553     return NO_EXIT;
2554 }
2555
2556 static ExitStatus op_ori(DisasContext *s, DisasOps *o)
2557 {
2558     int shift = s->insn->data & 0xff;
2559     int size = s->insn->data >> 8;
2560     uint64_t mask = ((1ull << size) - 1) << shift;
2561
2562     assert(!o->g_in2);
2563     tcg_gen_shli_i64(o->in2, o->in2, shift);
2564     tcg_gen_or_i64(o->out, o->in1, o->in2);
2565
2566     /* Produce the CC from only the bits manipulated.  */
2567     tcg_gen_andi_i64(cc_dst, o->out, mask);
2568     set_cc_nz_u64(s, cc_dst);
2569     return NO_EXIT;
2570 }
2571
2572 #ifndef CONFIG_USER_ONLY
2573 static ExitStatus op_ptlb(DisasContext *s, DisasOps *o)
2574 {
2575     check_privileged(s);
2576     gen_helper_ptlb(cpu_env);
2577     return NO_EXIT;
2578 }
2579 #endif
2580
2581 static ExitStatus op_rev16(DisasContext *s, DisasOps *o)
2582 {
2583     tcg_gen_bswap16_i64(o->out, o->in2);
2584     return NO_EXIT;
2585 }
2586
2587 static ExitStatus op_rev32(DisasContext *s, DisasOps *o)
2588 {
2589     tcg_gen_bswap32_i64(o->out, o->in2);
2590     return NO_EXIT;
2591 }
2592
2593 static ExitStatus op_rev64(DisasContext *s, DisasOps *o)
2594 {
2595     tcg_gen_bswap64_i64(o->out, o->in2);
2596     return NO_EXIT;
2597 }
2598
2599 static ExitStatus op_rll32(DisasContext *s, DisasOps *o)
2600 {
2601     TCGv_i32 t1 = tcg_temp_new_i32();
2602     TCGv_i32 t2 = tcg_temp_new_i32();
2603     TCGv_i32 to = tcg_temp_new_i32();
2604     tcg_gen_trunc_i64_i32(t1, o->in1);
2605     tcg_gen_trunc_i64_i32(t2, o->in2);
2606     tcg_gen_rotl_i32(to, t1, t2);
2607     tcg_gen_extu_i32_i64(o->out, to);
2608     tcg_temp_free_i32(t1);
2609     tcg_temp_free_i32(t2);
2610     tcg_temp_free_i32(to);
2611     return NO_EXIT;
2612 }
2613
2614 static ExitStatus op_rll64(DisasContext *s, DisasOps *o)
2615 {
2616     tcg_gen_rotl_i64(o->out, o->in1, o->in2);
2617     return NO_EXIT;
2618 }
2619
2620 #ifndef CONFIG_USER_ONLY
2621 static ExitStatus op_rrbe(DisasContext *s, DisasOps *o)
2622 {
2623     check_privileged(s);
2624     gen_helper_rrbe(cc_op, cpu_env, o->in2);
2625     set_cc_static(s);
2626     return NO_EXIT;
2627 }
2628
2629 static ExitStatus op_sacf(DisasContext *s, DisasOps *o)
2630 {
2631     check_privileged(s);
2632     gen_helper_sacf(cpu_env, o->in2);
2633     /* Addressing mode has changed, so end the block.  */
2634     return EXIT_PC_STALE;
2635 }
2636 #endif
2637
2638 static ExitStatus op_sar(DisasContext *s, DisasOps *o)
2639 {
2640     int r1 = get_field(s->fields, r1);
2641     tcg_gen_st32_i64(o->in2, cpu_env, offsetof(CPUS390XState, aregs[r1]));
2642     return NO_EXIT;
2643 }
2644
2645 static ExitStatus op_seb(DisasContext *s, DisasOps *o)
2646 {
2647     gen_helper_seb(o->out, cpu_env, o->in1, o->in2);
2648     return NO_EXIT;
2649 }
2650
2651 static ExitStatus op_sdb(DisasContext *s, DisasOps *o)
2652 {
2653     gen_helper_sdb(o->out, cpu_env, o->in1, o->in2);
2654     return NO_EXIT;
2655 }
2656
2657 static ExitStatus op_sxb(DisasContext *s, DisasOps *o)
2658 {
2659     gen_helper_sxb(o->out, cpu_env, o->out, o->out2, o->in1, o->in2);
2660     return_low128(o->out2);
2661     return NO_EXIT;
2662 }
2663
2664 static ExitStatus op_sqeb(DisasContext *s, DisasOps *o)
2665 {
2666     gen_helper_sqeb(o->out, cpu_env, o->in2);
2667     return NO_EXIT;
2668 }
2669
2670 static ExitStatus op_sqdb(DisasContext *s, DisasOps *o)
2671 {
2672     gen_helper_sqdb(o->out, cpu_env, o->in2);
2673     return NO_EXIT;
2674 }
2675
2676 static ExitStatus op_sqxb(DisasContext *s, DisasOps *o)
2677 {
2678     gen_helper_sqxb(o->out, cpu_env, o->in1, o->in2);
2679     return_low128(o->out2);
2680     return NO_EXIT;
2681 }
2682
2683 #ifndef CONFIG_USER_ONLY
2684 static ExitStatus op_servc(DisasContext *s, DisasOps *o)
2685 {
2686     check_privileged(s);
2687     potential_page_fault(s);
2688     gen_helper_servc(cc_op, cpu_env, o->in2, o->in1);
2689     set_cc_static(s);
2690     return NO_EXIT;
2691 }
2692
2693 static ExitStatus op_sigp(DisasContext *s, DisasOps *o)
2694 {
2695     TCGv_i32 r1 = tcg_const_i32(get_field(s->fields, r1));
2696     check_privileged(s);
2697     potential_page_fault(s);
2698     gen_helper_sigp(cc_op, cpu_env, o->in2, r1, o->in1);
2699     tcg_temp_free_i32(r1);
2700     return NO_EXIT;
2701 }
2702 #endif
2703
2704 static ExitStatus op_sla(DisasContext *s, DisasOps *o)
2705 {
2706     uint64_t sign = 1ull << s->insn->data;
2707     enum cc_op cco = s->insn->data == 31 ? CC_OP_SLA_32 : CC_OP_SLA_64;
2708     gen_op_update2_cc_i64(s, cco, o->in1, o->in2);
2709     tcg_gen_shl_i64(o->out, o->in1, o->in2);
2710     /* The arithmetic left shift is curious in that it does not affect
2711        the sign bit.  Copy that over from the source unchanged.  */
2712     tcg_gen_andi_i64(o->out, o->out, ~sign);
2713     tcg_gen_andi_i64(o->in1, o->in1, sign);
2714     tcg_gen_or_i64(o->out, o->out, o->in1);
2715     return NO_EXIT;
2716 }
2717
2718 static ExitStatus op_sll(DisasContext *s, DisasOps *o)
2719 {
2720     tcg_gen_shl_i64(o->out, o->in1, o->in2);
2721     return NO_EXIT;
2722 }
2723
2724 static ExitStatus op_sra(DisasContext *s, DisasOps *o)
2725 {
2726     tcg_gen_sar_i64(o->out, o->in1, o->in2);
2727     return NO_EXIT;
2728 }
2729
2730 static ExitStatus op_srl(DisasContext *s, DisasOps *o)
2731 {
2732     tcg_gen_shr_i64(o->out, o->in1, o->in2);
2733     return NO_EXIT;
2734 }
2735
2736 static ExitStatus op_sfpc(DisasContext *s, DisasOps *o)
2737 {
2738     gen_helper_sfpc(cpu_env, o->in2);
2739     return NO_EXIT;
2740 }
2741
2742 #ifndef CONFIG_USER_ONLY
2743 static ExitStatus op_spka(DisasContext *s, DisasOps *o)
2744 {
2745     check_privileged(s);
2746     tcg_gen_shri_i64(o->in2, o->in2, 4);
2747     tcg_gen_deposit_i64(psw_mask, psw_mask, o->in2, PSW_SHIFT_KEY - 4, 4);
2748     return NO_EXIT;
2749 }
2750
2751 static ExitStatus op_sske(DisasContext *s, DisasOps *o)
2752 {
2753     check_privileged(s);
2754     gen_helper_sske(cpu_env, o->in1, o->in2);
2755     return NO_EXIT;
2756 }
2757
2758 static ExitStatus op_ssm(DisasContext *s, DisasOps *o)
2759 {
2760     check_privileged(s);
2761     tcg_gen_deposit_i64(psw_mask, psw_mask, o->in2, 56, 8);
2762     return NO_EXIT;
2763 }
2764
2765 static ExitStatus op_stap(DisasContext *s, DisasOps *o)
2766 {
2767     check_privileged(s);
2768     /* ??? Surely cpu address != cpu number.  In any case the previous
2769        version of this stored more than the required half-word, so it
2770        is unlikely this has ever been tested.  */
2771     tcg_gen_ld32u_i64(o->out, cpu_env, offsetof(CPUS390XState, cpu_num));
2772     return NO_EXIT;
2773 }
2774
2775 static ExitStatus op_stck(DisasContext *s, DisasOps *o)
2776 {
2777     gen_helper_stck(o->out, cpu_env);
2778     /* ??? We don't implement clock states.  */
2779     gen_op_movi_cc(s, 0);
2780     return NO_EXIT;
2781 }
2782
2783 static ExitStatus op_stcke(DisasContext *s, DisasOps *o)
2784 {
2785     TCGv_i64 c1 = tcg_temp_new_i64();
2786     TCGv_i64 c2 = tcg_temp_new_i64();
2787     gen_helper_stck(c1, cpu_env);
2788     /* Shift the 64-bit value into its place as a zero-extended
2789        104-bit value.  Note that "bit positions 64-103 are always
2790        non-zero so that they compare differently to STCK"; we set
2791        the least significant bit to 1.  */
2792     tcg_gen_shli_i64(c2, c1, 56);
2793     tcg_gen_shri_i64(c1, c1, 8);
2794     tcg_gen_ori_i64(c2, c2, 0x10000);
2795     tcg_gen_qemu_st64(c1, o->in2, get_mem_index(s));
2796     tcg_gen_addi_i64(o->in2, o->in2, 8);
2797     tcg_gen_qemu_st64(c2, o->in2, get_mem_index(s));
2798     tcg_temp_free_i64(c1);
2799     tcg_temp_free_i64(c2);
2800     /* ??? We don't implement clock states.  */
2801     gen_op_movi_cc(s, 0);
2802     return NO_EXIT;
2803 }
2804
2805 static ExitStatus op_sckc(DisasContext *s, DisasOps *o)
2806 {
2807     check_privileged(s);
2808     gen_helper_sckc(cpu_env, o->in2);
2809     return NO_EXIT;
2810 }
2811
2812 static ExitStatus op_stckc(DisasContext *s, DisasOps *o)
2813 {
2814     check_privileged(s);
2815     gen_helper_stckc(o->out, cpu_env);
2816     return NO_EXIT;
2817 }
2818
2819 static ExitStatus op_stctg(DisasContext *s, DisasOps *o)
2820 {
2821     TCGv_i32 r1 = tcg_const_i32(get_field(s->fields, r1));
2822     TCGv_i32 r3 = tcg_const_i32(get_field(s->fields, r3));
2823     check_privileged(s);
2824     potential_page_fault(s);
2825     gen_helper_stctg(cpu_env, r1, o->in2, r3);
2826     tcg_temp_free_i32(r1);
2827     tcg_temp_free_i32(r3);
2828     return NO_EXIT;
2829 }
2830
2831 static ExitStatus op_stctl(DisasContext *s, DisasOps *o)
2832 {
2833     TCGv_i32 r1 = tcg_const_i32(get_field(s->fields, r1));
2834     TCGv_i32 r3 = tcg_const_i32(get_field(s->fields, r3));
2835     check_privileged(s);
2836     potential_page_fault(s);
2837     gen_helper_stctl(cpu_env, r1, o->in2, r3);
2838     tcg_temp_free_i32(r1);
2839     tcg_temp_free_i32(r3);
2840     return NO_EXIT;
2841 }
2842
2843 static ExitStatus op_stidp(DisasContext *s, DisasOps *o)
2844 {
2845     check_privileged(s);
2846     tcg_gen_ld32u_i64(o->out, cpu_env, offsetof(CPUS390XState, cpu_num));
2847     return NO_EXIT;
2848 }
2849
2850 static ExitStatus op_spt(DisasContext *s, DisasOps *o)
2851 {
2852     check_privileged(s);
2853     gen_helper_spt(cpu_env, o->in2);
2854     return NO_EXIT;
2855 }
2856
2857 static ExitStatus op_stfl(DisasContext *s, DisasOps *o)
2858 {
2859     TCGv_i64 f, a;
2860     /* We really ought to have more complete indication of facilities
2861        that we implement.  Address this when STFLE is implemented.  */
2862     check_privileged(s);
2863     f = tcg_const_i64(0xc0000000);
2864     a = tcg_const_i64(200);
2865     tcg_gen_qemu_st32(f, a, get_mem_index(s));
2866     tcg_temp_free_i64(f);
2867     tcg_temp_free_i64(a);
2868     return NO_EXIT;
2869 }
2870
2871 static ExitStatus op_stpt(DisasContext *s, DisasOps *o)
2872 {
2873     check_privileged(s);
2874     gen_helper_stpt(o->out, cpu_env);
2875     return NO_EXIT;
2876 }
2877
2878 static ExitStatus op_stsi(DisasContext *s, DisasOps *o)
2879 {
2880     check_privileged(s);
2881     potential_page_fault(s);
2882     gen_helper_stsi(cc_op, cpu_env, o->in2, regs[0], regs[1]);
2883     set_cc_static(s);
2884     return NO_EXIT;
2885 }
2886
2887 static ExitStatus op_spx(DisasContext *s, DisasOps *o)
2888 {
2889     check_privileged(s);
2890     gen_helper_spx(cpu_env, o->in2);
2891     return NO_EXIT;
2892 }
2893
2894 static ExitStatus op_subchannel(DisasContext *s, DisasOps *o)
2895 {
2896     check_privileged(s);
2897     /* Not operational.  */
2898     gen_op_movi_cc(s, 3);
2899     return NO_EXIT;
2900 }
2901
2902 static ExitStatus op_stpx(DisasContext *s, DisasOps *o)
2903 {
2904     check_privileged(s);
2905     tcg_gen_ld_i64(o->out, cpu_env, offsetof(CPUS390XState, psa));
2906     tcg_gen_andi_i64(o->out, o->out, 0x7fffe000);
2907     return NO_EXIT;
2908 }
2909
2910 static ExitStatus op_stnosm(DisasContext *s, DisasOps *o)
2911 {
2912     uint64_t i2 = get_field(s->fields, i2);
2913     TCGv_i64 t;
2914
2915     check_privileged(s);
2916
2917     /* It is important to do what the instruction name says: STORE THEN.
2918        If we let the output hook perform the store then if we fault and
2919        restart, we'll have the wrong SYSTEM MASK in place.  */
2920     t = tcg_temp_new_i64();
2921     tcg_gen_shri_i64(t, psw_mask, 56);
2922     tcg_gen_qemu_st8(t, o->addr1, get_mem_index(s));
2923     tcg_temp_free_i64(t);
2924
2925     if (s->fields->op == 0xac) {
2926         tcg_gen_andi_i64(psw_mask, psw_mask,
2927                          (i2 << 56) | 0x00ffffffffffffffull);
2928     } else {
2929         tcg_gen_ori_i64(psw_mask, psw_mask, i2 << 56);
2930     }
2931     return NO_EXIT;
2932 }
2933
2934 static ExitStatus op_stura(DisasContext *s, DisasOps *o)
2935 {
2936     check_privileged(s);
2937     potential_page_fault(s);
2938     gen_helper_stura(cpu_env, o->in2, o->in1);
2939     return NO_EXIT;
2940 }
2941 #endif
2942
2943 static ExitStatus op_st8(DisasContext *s, DisasOps *o)
2944 {
2945     tcg_gen_qemu_st8(o->in1, o->in2, get_mem_index(s));
2946     return NO_EXIT;
2947 }
2948
2949 static ExitStatus op_st16(DisasContext *s, DisasOps *o)
2950 {
2951     tcg_gen_qemu_st16(o->in1, o->in2, get_mem_index(s));
2952     return NO_EXIT;
2953 }
2954
2955 static ExitStatus op_st32(DisasContext *s, DisasOps *o)
2956 {
2957     tcg_gen_qemu_st32(o->in1, o->in2, get_mem_index(s));
2958     return NO_EXIT;
2959 }
2960
2961 static ExitStatus op_st64(DisasContext *s, DisasOps *o)
2962 {
2963     tcg_gen_qemu_st64(o->in1, o->in2, get_mem_index(s));
2964     return NO_EXIT;
2965 }
2966
2967 static ExitStatus op_stam(DisasContext *s, DisasOps *o)
2968 {
2969     TCGv_i32 r1 = tcg_const_i32(get_field(s->fields, r1));
2970     TCGv_i32 r3 = tcg_const_i32(get_field(s->fields, r3));
2971     potential_page_fault(s);
2972     gen_helper_stam(cpu_env, r1, o->in2, r3);
2973     tcg_temp_free_i32(r1);
2974     tcg_temp_free_i32(r3);
2975     return NO_EXIT;
2976 }
2977
2978 static ExitStatus op_stcm(DisasContext *s, DisasOps *o)
2979 {
2980     int m3 = get_field(s->fields, m3);
2981     int pos, base = s->insn->data;
2982     TCGv_i64 tmp = tcg_temp_new_i64();
2983
2984     pos = base + ctz32(m3) * 8;
2985     switch (m3) {
2986     case 0xf:
2987         /* Effectively a 32-bit store.  */
2988         tcg_gen_shri_i64(tmp, o->in1, pos);
2989         tcg_gen_qemu_st32(tmp, o->in2, get_mem_index(s));
2990         break;
2991
2992     case 0xc:
2993     case 0x6:
2994     case 0x3:
2995         /* Effectively a 16-bit store.  */
2996         tcg_gen_shri_i64(tmp, o->in1, pos);
2997         tcg_gen_qemu_st16(tmp, o->in2, get_mem_index(s));
2998         break;
2999
3000     case 0x8:
3001     case 0x4:
3002     case 0x2:
3003     case 0x1:
3004         /* Effectively an 8-bit store.  */
3005         tcg_gen_shri_i64(tmp, o->in1, pos);
3006         tcg_gen_qemu_st8(tmp, o->in2, get_mem_index(s));
3007         break;
3008
3009     default:
3010         /* This is going to be a sequence of shifts and stores.  */
3011         pos = base + 32 - 8;
3012         while (m3) {
3013             if (m3 & 0x8) {
3014                 tcg_gen_shri_i64(tmp, o->in1, pos);
3015                 tcg_gen_qemu_st8(tmp, o->in2, get_mem_index(s));
3016                 tcg_gen_addi_i64(o->in2, o->in2, 1);
3017             }
3018             m3 = (m3 << 1) & 0xf;
3019             pos -= 8;
3020         }
3021         break;
3022     }
3023     tcg_temp_free_i64(tmp);
3024     return NO_EXIT;
3025 }
3026
3027 static ExitStatus op_stm(DisasContext *s, DisasOps *o)
3028 {
3029     int r1 = get_field(s->fields, r1);
3030     int r3 = get_field(s->fields, r3);
3031     int size = s->insn->data;
3032     TCGv_i64 tsize = tcg_const_i64(size);
3033
3034     while (1) {
3035         if (size == 8) {
3036             tcg_gen_qemu_st64(regs[r1], o->in2, get_mem_index(s));
3037         } else {
3038             tcg_gen_qemu_st32(regs[r1], o->in2, get_mem_index(s));
3039         }
3040         if (r1 == r3) {
3041             break;
3042         }
3043         tcg_gen_add_i64(o->in2, o->in2, tsize);
3044         r1 = (r1 + 1) & 15;
3045     }
3046
3047     tcg_temp_free_i64(tsize);
3048     return NO_EXIT;
3049 }
3050
3051 static ExitStatus op_stmh(DisasContext *s, DisasOps *o)
3052 {
3053     int r1 = get_field(s->fields, r1);
3054     int r3 = get_field(s->fields, r3);
3055     TCGv_i64 t = tcg_temp_new_i64();
3056     TCGv_i64 t4 = tcg_const_i64(4);
3057     TCGv_i64 t32 = tcg_const_i64(32);
3058
3059     while (1) {
3060         tcg_gen_shl_i64(t, regs[r1], t32);
3061         tcg_gen_qemu_st32(t, o->in2, get_mem_index(s));
3062         if (r1 == r3) {
3063             break;
3064         }
3065         tcg_gen_add_i64(o->in2, o->in2, t4);
3066         r1 = (r1 + 1) & 15;
3067     }
3068
3069     tcg_temp_free_i64(t);
3070     tcg_temp_free_i64(t4);
3071     tcg_temp_free_i64(t32);
3072     return NO_EXIT;
3073 }
3074
3075 static ExitStatus op_srst(DisasContext *s, DisasOps *o)
3076 {
3077     potential_page_fault(s);
3078     gen_helper_srst(o->in1, cpu_env, regs[0], o->in1, o->in2);
3079     set_cc_static(s);
3080     return_low128(o->in2);
3081     return NO_EXIT;
3082 }
3083
3084 static ExitStatus op_sub(DisasContext *s, DisasOps *o)
3085 {
3086     tcg_gen_sub_i64(o->out, o->in1, o->in2);
3087     return NO_EXIT;
3088 }
3089
3090 static ExitStatus op_subb(DisasContext *s, DisasOps *o)
3091 {
3092     TCGv_i64 cc;
3093
3094     assert(!o->g_in2);
3095     tcg_gen_not_i64(o->in2, o->in2);
3096     tcg_gen_add_i64(o->out, o->in1, o->in2);
3097
3098     /* XXX possible optimization point */
3099     gen_op_calc_cc(s);
3100     cc = tcg_temp_new_i64();
3101     tcg_gen_extu_i32_i64(cc, cc_op);
3102     tcg_gen_shri_i64(cc, cc, 1);
3103     tcg_gen_add_i64(o->out, o->out, cc);
3104     tcg_temp_free_i64(cc);
3105     return NO_EXIT;
3106 }
3107
3108 static ExitStatus op_svc(DisasContext *s, DisasOps *o)
3109 {
3110     TCGv_i32 t;
3111
3112     update_psw_addr(s);
3113     gen_op_calc_cc(s);
3114
3115     t = tcg_const_i32(get_field(s->fields, i1) & 0xff);
3116     tcg_gen_st_i32(t, cpu_env, offsetof(CPUS390XState, int_svc_code));
3117     tcg_temp_free_i32(t);
3118
3119     t = tcg_const_i32(s->next_pc - s->pc);
3120     tcg_gen_st_i32(t, cpu_env, offsetof(CPUS390XState, int_svc_ilen));
3121     tcg_temp_free_i32(t);
3122
3123     gen_exception(EXCP_SVC);
3124     return EXIT_NORETURN;
3125 }
3126
3127 static ExitStatus op_tceb(DisasContext *s, DisasOps *o)
3128 {
3129     gen_helper_tceb(cc_op, o->in1, o->in2);
3130     set_cc_static(s);
3131     return NO_EXIT;
3132 }
3133
3134 static ExitStatus op_tcdb(DisasContext *s, DisasOps *o)
3135 {
3136     gen_helper_tcdb(cc_op, o->in1, o->in2);
3137     set_cc_static(s);
3138     return NO_EXIT;
3139 }
3140
3141 static ExitStatus op_tcxb(DisasContext *s, DisasOps *o)
3142 {
3143     gen_helper_tcxb(cc_op, o->out, o->out2, o->in2);
3144     set_cc_static(s);
3145     return NO_EXIT;
3146 }
3147
3148 #ifndef CONFIG_USER_ONLY
3149 static ExitStatus op_tprot(DisasContext *s, DisasOps *o)
3150 {
3151     potential_page_fault(s);
3152     gen_helper_tprot(cc_op, o->addr1, o->in2);
3153     set_cc_static(s);
3154     return NO_EXIT;
3155 }
3156 #endif
3157
3158 static ExitStatus op_tr(DisasContext *s, DisasOps *o)
3159 {
3160     TCGv_i32 l = tcg_const_i32(get_field(s->fields, l1));
3161     potential_page_fault(s);
3162     gen_helper_tr(cpu_env, l, o->addr1, o->in2);
3163     tcg_temp_free_i32(l);
3164     set_cc_static(s);
3165     return NO_EXIT;
3166 }
3167
3168 static ExitStatus op_unpk(DisasContext *s, DisasOps *o)
3169 {
3170     TCGv_i32 l = tcg_const_i32(get_field(s->fields, l1));
3171     potential_page_fault(s);
3172     gen_helper_unpk(cpu_env, l, o->addr1, o->in2);
3173     tcg_temp_free_i32(l);
3174     return NO_EXIT;
3175 }
3176
3177 static ExitStatus op_xc(DisasContext *s, DisasOps *o)
3178 {
3179     TCGv_i32 l = tcg_const_i32(get_field(s->fields, l1));
3180     potential_page_fault(s);
3181     gen_helper_xc(cc_op, cpu_env, l, o->addr1, o->in2);
3182     tcg_temp_free_i32(l);
3183     set_cc_static(s);
3184     return NO_EXIT;
3185 }
3186
3187 static ExitStatus op_xor(DisasContext *s, DisasOps *o)
3188 {
3189     tcg_gen_xor_i64(o->out, o->in1, o->in2);
3190     return NO_EXIT;
3191 }
3192
3193 static ExitStatus op_xori(DisasContext *s, DisasOps *o)
3194 {
3195     int shift = s->insn->data & 0xff;
3196     int size = s->insn->data >> 8;
3197     uint64_t mask = ((1ull << size) - 1) << shift;
3198
3199     assert(!o->g_in2);
3200     tcg_gen_shli_i64(o->in2, o->in2, shift);
3201     tcg_gen_xor_i64(o->out, o->in1, o->in2);
3202
3203     /* Produce the CC from only the bits manipulated.  */
3204     tcg_gen_andi_i64(cc_dst, o->out, mask);
3205     set_cc_nz_u64(s, cc_dst);
3206     return NO_EXIT;
3207 }
3208
3209 static ExitStatus op_zero(DisasContext *s, DisasOps *o)
3210 {
3211     o->out = tcg_const_i64(0);
3212     return NO_EXIT;
3213 }
3214
3215 static ExitStatus op_zero2(DisasContext *s, DisasOps *o)
3216 {
3217     o->out = tcg_const_i64(0);
3218     o->out2 = o->out;
3219     o->g_out2 = true;
3220     return NO_EXIT;
3221 }
3222
3223 /* ====================================================================== */
3224 /* The "Cc OUTput" generators.  Given the generated output (and in some cases
3225    the original inputs), update the various cc data structures in order to
3226    be able to compute the new condition code.  */
3227
3228 static void cout_abs32(DisasContext *s, DisasOps *o)
3229 {
3230     gen_op_update1_cc_i64(s, CC_OP_ABS_32, o->out);
3231 }
3232
3233 static void cout_abs64(DisasContext *s, DisasOps *o)
3234 {
3235     gen_op_update1_cc_i64(s, CC_OP_ABS_64, o->out);
3236 }
3237
3238 static void cout_adds32(DisasContext *s, DisasOps *o)
3239 {
3240     gen_op_update3_cc_i64(s, CC_OP_ADD_32, o->in1, o->in2, o->out);
3241 }
3242
3243 static void cout_adds64(DisasContext *s, DisasOps *o)
3244 {
3245     gen_op_update3_cc_i64(s, CC_OP_ADD_64, o->in1, o->in2, o->out);
3246 }
3247
3248 static void cout_addu32(DisasContext *s, DisasOps *o)
3249 {
3250     gen_op_update3_cc_i64(s, CC_OP_ADDU_32, o->in1, o->in2, o->out);
3251 }
3252
3253 static void cout_addu64(DisasContext *s, DisasOps *o)
3254 {
3255     gen_op_update3_cc_i64(s, CC_OP_ADDU_64, o->in1, o->in2, o->out);
3256 }
3257
3258 static void cout_addc32(DisasContext *s, DisasOps *o)
3259 {
3260     gen_op_update3_cc_i64(s, CC_OP_ADDC_32, o->in1, o->in2, o->out);
3261 }
3262
3263 static void cout_addc64(DisasContext *s, DisasOps *o)
3264 {
3265     gen_op_update3_cc_i64(s, CC_OP_ADDC_64, o->in1, o->in2, o->out);
3266 }
3267
3268 static void cout_cmps32(DisasContext *s, DisasOps *o)
3269 {
3270     gen_op_update2_cc_i64(s, CC_OP_LTGT_32, o->in1, o->in2);
3271 }
3272
3273 static void cout_cmps64(DisasContext *s, DisasOps *o)
3274 {
3275     gen_op_update2_cc_i64(s, CC_OP_LTGT_64, o->in1, o->in2);
3276 }
3277
3278 static void cout_cmpu32(DisasContext *s, DisasOps *o)
3279 {
3280     gen_op_update2_cc_i64(s, CC_OP_LTUGTU_32, o->in1, o->in2);
3281 }
3282
3283 static void cout_cmpu64(DisasContext *s, DisasOps *o)
3284 {
3285     gen_op_update2_cc_i64(s, CC_OP_LTUGTU_64, o->in1, o->in2);
3286 }
3287
3288 static void cout_f32(DisasContext *s, DisasOps *o)
3289 {
3290     gen_op_update1_cc_i64(s, CC_OP_NZ_F32, o->out);
3291 }
3292
3293 static void cout_f64(DisasContext *s, DisasOps *o)
3294 {
3295     gen_op_update1_cc_i64(s, CC_OP_NZ_F64, o->out);
3296 }
3297
3298 static void cout_f128(DisasContext *s, DisasOps *o)
3299 {
3300     gen_op_update2_cc_i64(s, CC_OP_NZ_F128, o->out, o->out2);
3301 }
3302
3303 static void cout_nabs32(DisasContext *s, DisasOps *o)
3304 {
3305     gen_op_update1_cc_i64(s, CC_OP_NABS_32, o->out);
3306 }
3307
3308 static void cout_nabs64(DisasContext *s, DisasOps *o)
3309 {
3310     gen_op_update1_cc_i64(s, CC_OP_NABS_64, o->out);
3311 }
3312
3313 static void cout_neg32(DisasContext *s, DisasOps *o)
3314 {
3315     gen_op_update1_cc_i64(s, CC_OP_COMP_32, o->out);
3316 }
3317
3318 static void cout_neg64(DisasContext *s, DisasOps *o)
3319 {
3320     gen_op_update1_cc_i64(s, CC_OP_COMP_64, o->out);
3321 }
3322
3323 static void cout_nz32(DisasContext *s, DisasOps *o)
3324 {
3325     tcg_gen_ext32u_i64(cc_dst, o->out);
3326     gen_op_update1_cc_i64(s, CC_OP_NZ, cc_dst);
3327 }
3328
3329 static void cout_nz64(DisasContext *s, DisasOps *o)
3330 {
3331     gen_op_update1_cc_i64(s, CC_OP_NZ, o->out);
3332 }
3333
3334 static void cout_s32(DisasContext *s, DisasOps *o)
3335 {
3336     gen_op_update1_cc_i64(s, CC_OP_LTGT0_32, o->out);
3337 }
3338
3339 static void cout_s64(DisasContext *s, DisasOps *o)
3340 {
3341     gen_op_update1_cc_i64(s, CC_OP_LTGT0_64, o->out);
3342 }
3343
3344 static void cout_subs32(DisasContext *s, DisasOps *o)
3345 {
3346     gen_op_update3_cc_i64(s, CC_OP_SUB_32, o->in1, o->in2, o->out);
3347 }
3348
3349 static void cout_subs64(DisasContext *s, DisasOps *o)
3350 {
3351     gen_op_update3_cc_i64(s, CC_OP_SUB_64, o->in1, o->in2, o->out);
3352 }
3353
3354 static void cout_subu32(DisasContext *s, DisasOps *o)
3355 {
3356     gen_op_update3_cc_i64(s, CC_OP_SUBU_32, o->in1, o->in2, o->out);
3357 }
3358
3359 static void cout_subu64(DisasContext *s, DisasOps *o)
3360 {
3361     gen_op_update3_cc_i64(s, CC_OP_SUBU_64, o->in1, o->in2, o->out);
3362 }
3363
3364 static void cout_subb32(DisasContext *s, DisasOps *o)
3365 {
3366     gen_op_update3_cc_i64(s, CC_OP_SUBB_32, o->in1, o->in2, o->out);
3367 }
3368
3369 static void cout_subb64(DisasContext *s, DisasOps *o)
3370 {
3371     gen_op_update3_cc_i64(s, CC_OP_SUBB_64, o->in1, o->in2, o->out);
3372 }
3373
3374 static void cout_tm32(DisasContext *s, DisasOps *o)
3375 {
3376     gen_op_update2_cc_i64(s, CC_OP_TM_32, o->in1, o->in2);
3377 }
3378
3379 static void cout_tm64(DisasContext *s, DisasOps *o)
3380 {
3381     gen_op_update2_cc_i64(s, CC_OP_TM_64, o->in1, o->in2);
3382 }
3383
3384 /* ====================================================================== */
3385 /* The "PREPeration" generators.  These initialize the DisasOps.OUT fields
3386    with the TCG register to which we will write.  Used in combination with
3387    the "wout" generators, in some cases we need a new temporary, and in
3388    some cases we can write to a TCG global.  */
3389
3390 static void prep_new(DisasContext *s, DisasFields *f, DisasOps *o)
3391 {
3392     o->out = tcg_temp_new_i64();
3393 }
3394
3395 static void prep_new_P(DisasContext *s, DisasFields *f, DisasOps *o)
3396 {
3397     o->out = tcg_temp_new_i64();
3398     o->out2 = tcg_temp_new_i64();
3399 }
3400
3401 static void prep_r1(DisasContext *s, DisasFields *f, DisasOps *o)
3402 {
3403     o->out = regs[get_field(f, r1)];
3404     o->g_out = true;
3405 }
3406
3407 static void prep_r1_P(DisasContext *s, DisasFields *f, DisasOps *o)
3408 {
3409     /* ??? Specification exception: r1 must be even.  */
3410     int r1 = get_field(f, r1);
3411     o->out = regs[r1];
3412     o->out2 = regs[(r1 + 1) & 15];
3413     o->g_out = o->g_out2 = true;
3414 }
3415
3416 static void prep_f1(DisasContext *s, DisasFields *f, DisasOps *o)
3417 {
3418     o->out = fregs[get_field(f, r1)];
3419     o->g_out = true;
3420 }
3421
3422 static void prep_x1(DisasContext *s, DisasFields *f, DisasOps *o)
3423 {
3424     /* ??? Specification exception: r1 must be < 14.  */
3425     int r1 = get_field(f, r1);
3426     o->out = fregs[r1];
3427     o->out2 = fregs[(r1 + 2) & 15];
3428     o->g_out = o->g_out2 = true;
3429 }
3430
3431 /* ====================================================================== */
3432 /* The "Write OUTput" generators.  These generally perform some non-trivial
3433    copy of data to TCG globals, or to main memory.  The trivial cases are
3434    generally handled by having a "prep" generator install the TCG global
3435    as the destination of the operation.  */
3436
3437 static void wout_r1(DisasContext *s, DisasFields *f, DisasOps *o)
3438 {
3439     store_reg(get_field(f, r1), o->out);
3440 }
3441
3442 static void wout_r1_8(DisasContext *s, DisasFields *f, DisasOps *o)
3443 {
3444     int r1 = get_field(f, r1);
3445     tcg_gen_deposit_i64(regs[r1], regs[r1], o->out, 0, 8);
3446 }
3447
3448 static void wout_r1_16(DisasContext *s, DisasFields *f, DisasOps *o)
3449 {
3450     int r1 = get_field(f, r1);
3451     tcg_gen_deposit_i64(regs[r1], regs[r1], o->out, 0, 16);
3452 }
3453
3454 static void wout_r1_32(DisasContext *s, DisasFields *f, DisasOps *o)
3455 {
3456     store_reg32_i64(get_field(f, r1), o->out);
3457 }
3458
3459 static void wout_r1_P32(DisasContext *s, DisasFields *f, DisasOps *o)
3460 {
3461     /* ??? Specification exception: r1 must be even.  */
3462     int r1 = get_field(f, r1);
3463     store_reg32_i64(r1, o->out);
3464     store_reg32_i64((r1 + 1) & 15, o->out2);
3465 }
3466
3467 static void wout_r1_D32(DisasContext *s, DisasFields *f, DisasOps *o)
3468 {
3469     /* ??? Specification exception: r1 must be even.  */
3470     int r1 = get_field(f, r1);
3471     store_reg32_i64((r1 + 1) & 15, o->out);
3472     tcg_gen_shri_i64(o->out, o->out, 32);
3473     store_reg32_i64(r1, o->out);
3474 }
3475
3476 static void wout_e1(DisasContext *s, DisasFields *f, DisasOps *o)
3477 {
3478     store_freg32_i64(get_field(f, r1), o->out);
3479 }
3480
3481 static void wout_f1(DisasContext *s, DisasFields *f, DisasOps *o)
3482 {
3483     store_freg(get_field(f, r1), o->out);
3484 }
3485
3486 static void wout_x1(DisasContext *s, DisasFields *f, DisasOps *o)
3487 {
3488     /* ??? Specification exception: r1 must be < 14.  */
3489     int f1 = get_field(s->fields, r1);
3490     store_freg(f1, o->out);
3491     store_freg((f1 + 2) & 15, o->out2);
3492 }
3493
3494 static void wout_cond_r1r2_32(DisasContext *s, DisasFields *f, DisasOps *o)
3495 {
3496     if (get_field(f, r1) != get_field(f, r2)) {
3497         store_reg32_i64(get_field(f, r1), o->out);
3498     }
3499 }
3500
3501 static void wout_cond_e1e2(DisasContext *s, DisasFields *f, DisasOps *o)
3502 {
3503     if (get_field(f, r1) != get_field(f, r2)) {
3504         store_freg32_i64(get_field(f, r1), o->out);
3505     }
3506 }
3507
3508 static void wout_m1_8(DisasContext *s, DisasFields *f, DisasOps *o)
3509 {
3510     tcg_gen_qemu_st8(o->out, o->addr1, get_mem_index(s));
3511 }
3512
3513 static void wout_m1_16(DisasContext *s, DisasFields *f, DisasOps *o)
3514 {
3515     tcg_gen_qemu_st16(o->out, o->addr1, get_mem_index(s));
3516 }
3517
3518 static void wout_m1_32(DisasContext *s, DisasFields *f, DisasOps *o)
3519 {
3520     tcg_gen_qemu_st32(o->out, o->addr1, get_mem_index(s));
3521 }
3522
3523 static void wout_m1_64(DisasContext *s, DisasFields *f, DisasOps *o)
3524 {
3525     tcg_gen_qemu_st64(o->out, o->addr1, get_mem_index(s));
3526 }
3527
3528 static void wout_m2_32(DisasContext *s, DisasFields *f, DisasOps *o)
3529 {
3530     tcg_gen_qemu_st32(o->out, o->in2, get_mem_index(s));
3531 }
3532
3533 /* ====================================================================== */
3534 /* The "INput 1" generators.  These load the first operand to an insn.  */
3535
3536 static void in1_r1(DisasContext *s, DisasFields *f, DisasOps *o)
3537 {
3538     o->in1 = load_reg(get_field(f, r1));
3539 }
3540
3541 static void in1_r1_o(DisasContext *s, DisasFields *f, DisasOps *o)
3542 {
3543     o->in1 = regs[get_field(f, r1)];
3544     o->g_in1 = true;
3545 }
3546
3547 static void in1_r1_32s(DisasContext *s, DisasFields *f, DisasOps *o)
3548 {
3549     o->in1 = tcg_temp_new_i64();
3550     tcg_gen_ext32s_i64(o->in1, regs[get_field(f, r1)]);
3551 }
3552
3553 static void in1_r1_32u(DisasContext *s, DisasFields *f, DisasOps *o)
3554 {
3555     o->in1 = tcg_temp_new_i64();
3556     tcg_gen_ext32u_i64(o->in1, regs[get_field(f, r1)]);
3557 }
3558
3559 static void in1_r1_sr32(DisasContext *s, DisasFields *f, DisasOps *o)
3560 {
3561     o->in1 = tcg_temp_new_i64();
3562     tcg_gen_shri_i64(o->in1, regs[get_field(f, r1)], 32);
3563 }
3564
3565 static void in1_r1p1(DisasContext *s, DisasFields *f, DisasOps *o)
3566 {
3567     /* ??? Specification exception: r1 must be even.  */
3568     int r1 = get_field(f, r1);
3569     o->in1 = load_reg((r1 + 1) & 15);
3570 }
3571
3572 static void in1_r1p1_32s(DisasContext *s, DisasFields *f, DisasOps *o)
3573 {
3574     /* ??? Specification exception: r1 must be even.  */
3575     int r1 = get_field(f, r1);
3576     o->in1 = tcg_temp_new_i64();
3577     tcg_gen_ext32s_i64(o->in1, regs[(r1 + 1) & 15]);
3578 }
3579
3580 static void in1_r1p1_32u(DisasContext *s, DisasFields *f, DisasOps *o)
3581 {
3582     /* ??? Specification exception: r1 must be even.  */
3583     int r1 = get_field(f, r1);
3584     o->in1 = tcg_temp_new_i64();
3585     tcg_gen_ext32u_i64(o->in1, regs[(r1 + 1) & 15]);
3586 }
3587
3588 static void in1_r1_D32(DisasContext *s, DisasFields *f, DisasOps *o)
3589 {
3590     /* ??? Specification exception: r1 must be even.  */
3591     int r1 = get_field(f, r1);
3592     o->in1 = tcg_temp_new_i64();
3593     tcg_gen_concat32_i64(o->in1, regs[r1 + 1], regs[r1]);
3594 }
3595
3596 static void in1_r2(DisasContext *s, DisasFields *f, DisasOps *o)
3597 {
3598     o->in1 = load_reg(get_field(f, r2));
3599 }
3600
3601 static void in1_r3(DisasContext *s, DisasFields *f, DisasOps *o)
3602 {
3603     o->in1 = load_reg(get_field(f, r3));
3604 }
3605
3606 static void in1_r3_o(DisasContext *s, DisasFields *f, DisasOps *o)
3607 {
3608     o->in1 = regs[get_field(f, r3)];
3609     o->g_in1 = true;
3610 }
3611
3612 static void in1_r3_32s(DisasContext *s, DisasFields *f, DisasOps *o)
3613 {
3614     o->in1 = tcg_temp_new_i64();
3615     tcg_gen_ext32s_i64(o->in1, regs[get_field(f, r3)]);
3616 }
3617
3618 static void in1_r3_32u(DisasContext *s, DisasFields *f, DisasOps *o)
3619 {
3620     o->in1 = tcg_temp_new_i64();
3621     tcg_gen_ext32u_i64(o->in1, regs[get_field(f, r3)]);
3622 }
3623
3624 static void in1_e1(DisasContext *s, DisasFields *f, DisasOps *o)
3625 {
3626     o->in1 = load_freg32_i64(get_field(f, r1));
3627 }
3628
3629 static void in1_f1_o(DisasContext *s, DisasFields *f, DisasOps *o)
3630 {
3631     o->in1 = fregs[get_field(f, r1)];
3632     o->g_in1 = true;
3633 }
3634
3635 static void in1_x1_o(DisasContext *s, DisasFields *f, DisasOps *o)
3636 {
3637     /* ??? Specification exception: r1 must be < 14.  */
3638     int r1 = get_field(f, r1);
3639     o->out = fregs[r1];
3640     o->out2 = fregs[(r1 + 2) & 15];
3641     o->g_out = o->g_out2 = true;
3642 }
3643
3644 static void in1_la1(DisasContext *s, DisasFields *f, DisasOps *o)
3645 {
3646     o->addr1 = get_address(s, 0, get_field(f, b1), get_field(f, d1));
3647 }
3648
3649 static void in1_la2(DisasContext *s, DisasFields *f, DisasOps *o)
3650 {
3651     int x2 = have_field(f, x2) ? get_field(f, x2) : 0;
3652     o->addr1 = get_address(s, x2, get_field(f, b2), get_field(f, d2));
3653 }
3654
3655 static void in1_m1_8u(DisasContext *s, DisasFields *f, DisasOps *o)
3656 {
3657     in1_la1(s, f, o);
3658     o->in1 = tcg_temp_new_i64();
3659     tcg_gen_qemu_ld8u(o->in1, o->addr1, get_mem_index(s));
3660 }
3661
3662 static void in1_m1_16s(DisasContext *s, DisasFields *f, DisasOps *o)
3663 {
3664     in1_la1(s, f, o);
3665     o->in1 = tcg_temp_new_i64();
3666     tcg_gen_qemu_ld16s(o->in1, o->addr1, get_mem_index(s));
3667 }
3668
3669 static void in1_m1_16u(DisasContext *s, DisasFields *f, DisasOps *o)
3670 {
3671     in1_la1(s, f, o);
3672     o->in1 = tcg_temp_new_i64();
3673     tcg_gen_qemu_ld16u(o->in1, o->addr1, get_mem_index(s));
3674 }
3675
3676 static void in1_m1_32s(DisasContext *s, DisasFields *f, DisasOps *o)
3677 {
3678     in1_la1(s, f, o);
3679     o->in1 = tcg_temp_new_i64();
3680     tcg_gen_qemu_ld32s(o->in1, o->addr1, get_mem_index(s));
3681 }
3682
3683 static void in1_m1_32u(DisasContext *s, DisasFields *f, DisasOps *o)
3684 {
3685     in1_la1(s, f, o);
3686     o->in1 = tcg_temp_new_i64();
3687     tcg_gen_qemu_ld32u(o->in1, o->addr1, get_mem_index(s));
3688 }
3689
3690 static void in1_m1_64(DisasContext *s, DisasFields *f, DisasOps *o)
3691 {
3692     in1_la1(s, f, o);
3693     o->in1 = tcg_temp_new_i64();
3694     tcg_gen_qemu_ld64(o->in1, o->addr1, get_mem_index(s));
3695 }
3696
3697 /* ====================================================================== */
3698 /* The "INput 2" generators.  These load the second operand to an insn.  */
3699
3700 static void in2_r1_o(DisasContext *s, DisasFields *f, DisasOps *o)
3701 {
3702     o->in2 = regs[get_field(f, r1)];
3703     o->g_in2 = true;
3704 }
3705
3706 static void in2_r1_16u(DisasContext *s, DisasFields *f, DisasOps *o)
3707 {
3708     o->in2 = tcg_temp_new_i64();
3709     tcg_gen_ext16u_i64(o->in2, regs[get_field(f, r1)]);
3710 }
3711
3712 static void in2_r1_32u(DisasContext *s, DisasFields *f, DisasOps *o)
3713 {
3714     o->in2 = tcg_temp_new_i64();
3715     tcg_gen_ext32u_i64(o->in2, regs[get_field(f, r1)]);
3716 }
3717
3718 static void in2_r2(DisasContext *s, DisasFields *f, DisasOps *o)
3719 {
3720     o->in2 = load_reg(get_field(f, r2));
3721 }
3722
3723 static void in2_r2_o(DisasContext *s, DisasFields *f, DisasOps *o)
3724 {
3725     o->in2 = regs[get_field(f, r2)];
3726     o->g_in2 = true;
3727 }
3728
3729 static void in2_r2_nz(DisasContext *s, DisasFields *f, DisasOps *o)
3730 {
3731     int r2 = get_field(f, r2);
3732     if (r2 != 0) {
3733         o->in2 = load_reg(r2);
3734     }
3735 }
3736
3737 static void in2_r2_8s(DisasContext *s, DisasFields *f, DisasOps *o)
3738 {
3739     o->in2 = tcg_temp_new_i64();
3740     tcg_gen_ext8s_i64(o->in2, regs[get_field(f, r2)]);
3741 }
3742
3743 static void in2_r2_8u(DisasContext *s, DisasFields *f, DisasOps *o)
3744 {
3745     o->in2 = tcg_temp_new_i64();
3746     tcg_gen_ext8u_i64(o->in2, regs[get_field(f, r2)]);
3747 }
3748
3749 static void in2_r2_16s(DisasContext *s, DisasFields *f, DisasOps *o)
3750 {
3751     o->in2 = tcg_temp_new_i64();
3752     tcg_gen_ext16s_i64(o->in2, regs[get_field(f, r2)]);
3753 }
3754
3755 static void in2_r2_16u(DisasContext *s, DisasFields *f, DisasOps *o)
3756 {
3757     o->in2 = tcg_temp_new_i64();
3758     tcg_gen_ext16u_i64(o->in2, regs[get_field(f, r2)]);
3759 }
3760
3761 static void in2_r3(DisasContext *s, DisasFields *f, DisasOps *o)
3762 {
3763     o->in2 = load_reg(get_field(f, r3));
3764 }
3765
3766 static void in2_r2_32s(DisasContext *s, DisasFields *f, DisasOps *o)
3767 {
3768     o->in2 = tcg_temp_new_i64();
3769     tcg_gen_ext32s_i64(o->in2, regs[get_field(f, r2)]);
3770 }
3771
3772 static void in2_r2_32u(DisasContext *s, DisasFields *f, DisasOps *o)
3773 {
3774     o->in2 = tcg_temp_new_i64();
3775     tcg_gen_ext32u_i64(o->in2, regs[get_field(f, r2)]);
3776 }
3777
3778 static void in2_e2(DisasContext *s, DisasFields *f, DisasOps *o)
3779 {
3780     o->in2 = load_freg32_i64(get_field(f, r2));
3781 }
3782
3783 static void in2_f2_o(DisasContext *s, DisasFields *f, DisasOps *o)
3784 {
3785     o->in2 = fregs[get_field(f, r2)];
3786     o->g_in2 = true;
3787 }
3788
3789 static void in2_x2_o(DisasContext *s, DisasFields *f, DisasOps *o)
3790 {
3791     /* ??? Specification exception: r1 must be < 14.  */
3792     int r2 = get_field(f, r2);
3793     o->in1 = fregs[r2];
3794     o->in2 = fregs[(r2 + 2) & 15];
3795     o->g_in1 = o->g_in2 = true;
3796 }
3797
3798 static void in2_ra2(DisasContext *s, DisasFields *f, DisasOps *o)
3799 {
3800     o->in2 = get_address(s, 0, get_field(f, r2), 0);
3801 }
3802
3803 static void in2_a2(DisasContext *s, DisasFields *f, DisasOps *o)
3804 {
3805     int x2 = have_field(f, x2) ? get_field(f, x2) : 0;
3806     o->in2 = get_address(s, x2, get_field(f, b2), get_field(f, d2));
3807 }
3808
3809 static void in2_ri2(DisasContext *s, DisasFields *f, DisasOps *o)
3810 {
3811     o->in2 = tcg_const_i64(s->pc + (int64_t)get_field(f, i2) * 2);
3812 }
3813
3814 static void in2_sh32(DisasContext *s, DisasFields *f, DisasOps *o)
3815 {
3816     help_l2_shift(s, f, o, 31);
3817 }
3818
3819 static void in2_sh64(DisasContext *s, DisasFields *f, DisasOps *o)
3820 {
3821     help_l2_shift(s, f, o, 63);
3822 }
3823
3824 static void in2_m2_8u(DisasContext *s, DisasFields *f, DisasOps *o)
3825 {
3826     in2_a2(s, f, o);
3827     tcg_gen_qemu_ld8u(o->in2, o->in2, get_mem_index(s));
3828 }
3829
3830 static void in2_m2_16s(DisasContext *s, DisasFields *f, DisasOps *o)
3831 {
3832     in2_a2(s, f, o);
3833     tcg_gen_qemu_ld16s(o->in2, o->in2, get_mem_index(s));
3834 }
3835
3836 static void in2_m2_16u(DisasContext *s, DisasFields *f, DisasOps *o)
3837 {
3838     in2_a2(s, f, o);
3839     tcg_gen_qemu_ld16u(o->in2, o->in2, get_mem_index(s));
3840 }
3841
3842 static void in2_m2_32s(DisasContext *s, DisasFields *f, DisasOps *o)
3843 {
3844     in2_a2(s, f, o);
3845     tcg_gen_qemu_ld32s(o->in2, o->in2, get_mem_index(s));
3846 }
3847
3848 static void in2_m2_32u(DisasContext *s, DisasFields *f, DisasOps *o)
3849 {
3850     in2_a2(s, f, o);
3851     tcg_gen_qemu_ld32u(o->in2, o->in2, get_mem_index(s));
3852 }
3853
3854 static void in2_m2_64(DisasContext *s, DisasFields *f, DisasOps *o)
3855 {
3856     in2_a2(s, f, o);
3857     tcg_gen_qemu_ld64(o->in2, o->in2, get_mem_index(s));
3858 }
3859
3860 static void in2_mri2_16u(DisasContext *s, DisasFields *f, DisasOps *o)
3861 {
3862     in2_ri2(s, f, o);
3863     tcg_gen_qemu_ld16u(o->in2, o->in2, get_mem_index(s));
3864 }
3865
3866 static void in2_mri2_32s(DisasContext *s, DisasFields *f, DisasOps *o)
3867 {
3868     in2_ri2(s, f, o);
3869     tcg_gen_qemu_ld32s(o->in2, o->in2, get_mem_index(s));
3870 }
3871
3872 static void in2_mri2_32u(DisasContext *s, DisasFields *f, DisasOps *o)
3873 {
3874     in2_ri2(s, f, o);
3875     tcg_gen_qemu_ld32u(o->in2, o->in2, get_mem_index(s));
3876 }
3877
3878 static void in2_mri2_64(DisasContext *s, DisasFields *f, DisasOps *o)
3879 {
3880     in2_ri2(s, f, o);
3881     tcg_gen_qemu_ld64(o->in2, o->in2, get_mem_index(s));
3882 }
3883
3884 static void in2_i2(DisasContext *s, DisasFields *f, DisasOps *o)
3885 {
3886     o->in2 = tcg_const_i64(get_field(f, i2));
3887 }
3888
3889 static void in2_i2_8u(DisasContext *s, DisasFields *f, DisasOps *o)
3890 {
3891     o->in2 = tcg_const_i64((uint8_t)get_field(f, i2));
3892 }
3893
3894 static void in2_i2_16u(DisasContext *s, DisasFields *f, DisasOps *o)
3895 {
3896     o->in2 = tcg_const_i64((uint16_t)get_field(f, i2));
3897 }
3898
3899 static void in2_i2_32u(DisasContext *s, DisasFields *f, DisasOps *o)
3900 {
3901     o->in2 = tcg_const_i64((uint32_t)get_field(f, i2));
3902 }
3903
3904 static void in2_i2_16u_shl(DisasContext *s, DisasFields *f, DisasOps *o)
3905 {
3906     uint64_t i2 = (uint16_t)get_field(f, i2);
3907     o->in2 = tcg_const_i64(i2 << s->insn->data);
3908 }
3909
3910 static void in2_i2_32u_shl(DisasContext *s, DisasFields *f, DisasOps *o)
3911 {
3912     uint64_t i2 = (uint32_t)get_field(f, i2);
3913     o->in2 = tcg_const_i64(i2 << s->insn->data);
3914 }
3915
3916 /* ====================================================================== */
3917
3918 /* Find opc within the table of insns.  This is formulated as a switch
3919    statement so that (1) we get compile-time notice of cut-paste errors
3920    for duplicated opcodes, and (2) the compiler generates the binary
3921    search tree, rather than us having to post-process the table.  */
3922
3923 #define C(OPC, NM, FT, FC, I1, I2, P, W, OP, CC) \
3924     D(OPC, NM, FT, FC, I1, I2, P, W, OP, CC, 0)
3925
3926 #define D(OPC, NM, FT, FC, I1, I2, P, W, OP, CC, D) insn_ ## NM,
3927
3928 enum DisasInsnEnum {
3929 #include "insn-data.def"
3930 };
3931
3932 #undef D
3933 #define D(OPC, NM, FT, FC, I1, I2, P, W, OP, CC, D) { \
3934     .opc = OPC,                           \
3935     .fmt = FMT_##FT,                      \
3936     .fac = FAC_##FC,                      \
3937     .name = #NM,                          \
3938     .help_in1 = in1_##I1,                 \
3939     .help_in2 = in2_##I2,                 \
3940     .help_prep = prep_##P,                \
3941     .help_wout = wout_##W,                \
3942     .help_cout = cout_##CC,               \
3943     .help_op = op_##OP,                   \
3944     .data = D                             \
3945  },
3946
3947 /* Allow 0 to be used for NULL in the table below.  */
3948 #define in1_0  NULL
3949 #define in2_0  NULL
3950 #define prep_0  NULL
3951 #define wout_0  NULL
3952 #define cout_0  NULL
3953 #define op_0  NULL
3954
3955 static const DisasInsn insn_info[] = {
3956 #include "insn-data.def"
3957 };
3958
3959 #undef D
3960 #define D(OPC, NM, FT, FC, I1, I2, P, W, OP, CC, D) \
3961     case OPC: return &insn_info[insn_ ## NM];
3962
3963 static const DisasInsn *lookup_opc(uint16_t opc)
3964 {
3965     switch (opc) {
3966 #include "insn-data.def"
3967     default:
3968         return NULL;
3969     }
3970 }
3971
3972 #undef D
3973 #undef C
3974
3975 /* Extract a field from the insn.  The INSN should be left-aligned in
3976    the uint64_t so that we can more easily utilize the big-bit-endian
3977    definitions we extract from the Principals of Operation.  */
3978
3979 static void extract_field(DisasFields *o, const DisasField *f, uint64_t insn)
3980 {
3981     uint32_t r, m;
3982
3983     if (f->size == 0) {
3984         return;
3985     }
3986
3987     /* Zero extract the field from the insn.  */
3988     r = (insn << f->beg) >> (64 - f->size);
3989
3990     /* Sign-extend, or un-swap the field as necessary.  */
3991     switch (f->type) {
3992     case 0: /* unsigned */
3993         break;
3994     case 1: /* signed */
3995         assert(f->size <= 32);
3996         m = 1u << (f->size - 1);
3997         r = (r ^ m) - m;
3998         break;
3999     case 2: /* dl+dh split, signed 20 bit. */
4000         r = ((int8_t)r << 12) | (r >> 8);
4001         break;
4002     default:
4003         abort();
4004     }
4005
4006     /* Validate that the "compressed" encoding we selected above is valid.
4007        I.e. we havn't make two different original fields overlap.  */
4008     assert(((o->presentC >> f->indexC) & 1) == 0);
4009     o->presentC |= 1 << f->indexC;
4010     o->presentO |= 1 << f->indexO;
4011
4012     o->c[f->indexC] = r;
4013 }
4014
4015 /* Lookup the insn at the current PC, extracting the operands into O and
4016    returning the info struct for the insn.  Returns NULL for invalid insn.  */
4017
4018 static const DisasInsn *extract_insn(CPUS390XState *env, DisasContext *s,
4019                                      DisasFields *f)
4020 {
4021     uint64_t insn, pc = s->pc;
4022     int op, op2, ilen;
4023     const DisasInsn *info;
4024
4025     insn = ld_code2(env, pc);
4026     op = (insn >> 8) & 0xff;
4027     ilen = get_ilen(op);
4028     s->next_pc = s->pc + ilen;
4029
4030     switch (ilen) {
4031     case 2:
4032         insn = insn << 48;
4033         break;
4034     case 4:
4035         insn = ld_code4(env, pc) << 32;
4036         break;
4037     case 6:
4038         insn = (insn << 48) | (ld_code4(env, pc + 2) << 16);
4039         break;
4040     default:
4041         abort();
4042     }
4043
4044     /* We can't actually determine the insn format until we've looked up
4045        the full insn opcode.  Which we can't do without locating the
4046        secondary opcode.  Assume by default that OP2 is at bit 40; for
4047        those smaller insns that don't actually have a secondary opcode
4048        this will correctly result in OP2 = 0. */
4049     switch (op) {
4050     case 0x01: /* E */
4051     case 0x80: /* S */
4052     case 0x82: /* S */
4053     case 0x93: /* S */
4054     case 0xb2: /* S, RRF, RRE */
4055     case 0xb3: /* RRE, RRD, RRF */
4056     case 0xb9: /* RRE, RRF */
4057     case 0xe5: /* SSE, SIL */
4058         op2 = (insn << 8) >> 56;
4059         break;
4060     case 0xa5: /* RI */
4061     case 0xa7: /* RI */
4062     case 0xc0: /* RIL */
4063     case 0xc2: /* RIL */
4064     case 0xc4: /* RIL */
4065     case 0xc6: /* RIL */
4066     case 0xc8: /* SSF */
4067     case 0xcc: /* RIL */
4068         op2 = (insn << 12) >> 60;
4069         break;
4070     case 0xd0 ... 0xdf: /* SS */
4071     case 0xe1: /* SS */
4072     case 0xe2: /* SS */
4073     case 0xe8: /* SS */
4074     case 0xe9: /* SS */
4075     case 0xea: /* SS */
4076     case 0xee ... 0xf3: /* SS */
4077     case 0xf8 ... 0xfd: /* SS */
4078         op2 = 0;
4079         break;
4080     default:
4081         op2 = (insn << 40) >> 56;
4082         break;
4083     }
4084
4085     memset(f, 0, sizeof(*f));
4086     f->op = op;
4087     f->op2 = op2;
4088
4089     /* Lookup the instruction.  */
4090     info = lookup_opc(op << 8 | op2);
4091
4092     /* If we found it, extract the operands.  */
4093     if (info != NULL) {
4094         DisasFormat fmt = info->fmt;
4095         int i;
4096
4097         for (i = 0; i < NUM_C_FIELD; ++i) {
4098             extract_field(f, &format_info[fmt].op[i], insn);
4099         }
4100     }
4101     return info;
4102 }
4103
4104 static ExitStatus translate_one(CPUS390XState *env, DisasContext *s)
4105 {
4106     const DisasInsn *insn;
4107     ExitStatus ret = NO_EXIT;
4108     DisasFields f;
4109     DisasOps o;
4110
4111     insn = extract_insn(env, s, &f);
4112
4113     /* If not found, try the old interpreter.  This includes ILLOPC.  */
4114     if (insn == NULL) {
4115         disas_s390_insn(env, s);
4116         switch (s->is_jmp) {
4117         case DISAS_NEXT:
4118             ret = NO_EXIT;
4119             break;
4120         case DISAS_TB_JUMP:
4121             ret = EXIT_GOTO_TB;
4122             break;
4123         case DISAS_JUMP:
4124             ret = EXIT_PC_UPDATED;
4125             break;
4126         case DISAS_EXCP:
4127             ret = EXIT_NORETURN;
4128             break;
4129         default:
4130             abort();
4131         }
4132
4133         s->pc = s->next_pc;
4134         return ret;
4135     }
4136
4137     /* Set up the strutures we use to communicate with the helpers. */
4138     s->insn = insn;
4139     s->fields = &f;
4140     o.g_out = o.g_out2 = o.g_in1 = o.g_in2 = false;
4141     TCGV_UNUSED_I64(o.out);
4142     TCGV_UNUSED_I64(o.out2);
4143     TCGV_UNUSED_I64(o.in1);
4144     TCGV_UNUSED_I64(o.in2);
4145     TCGV_UNUSED_I64(o.addr1);
4146
4147     /* Implement the instruction.  */
4148     if (insn->help_in1) {
4149         insn->help_in1(s, &f, &o);
4150     }
4151     if (insn->help_in2) {
4152         insn->help_in2(s, &f, &o);
4153     }
4154     if (insn->help_prep) {
4155         insn->help_prep(s, &f, &o);
4156     }
4157     if (insn->help_op) {
4158         ret = insn->help_op(s, &o);
4159     }
4160     if (insn->help_wout) {
4161         insn->help_wout(s, &f, &o);
4162     }
4163     if (insn->help_cout) {
4164         insn->help_cout(s, &o);
4165     }
4166
4167     /* Free any temporaries created by the helpers.  */
4168     if (!TCGV_IS_UNUSED_I64(o.out) && !o.g_out) {
4169         tcg_temp_free_i64(o.out);
4170     }
4171     if (!TCGV_IS_UNUSED_I64(o.out2) && !o.g_out2) {
4172         tcg_temp_free_i64(o.out2);
4173     }
4174     if (!TCGV_IS_UNUSED_I64(o.in1) && !o.g_in1) {
4175         tcg_temp_free_i64(o.in1);
4176     }
4177     if (!TCGV_IS_UNUSED_I64(o.in2) && !o.g_in2) {
4178         tcg_temp_free_i64(o.in2);
4179     }
4180     if (!TCGV_IS_UNUSED_I64(o.addr1)) {
4181         tcg_temp_free_i64(o.addr1);
4182     }
4183
4184     /* Advance to the next instruction.  */
4185     s->pc = s->next_pc;
4186     return ret;
4187 }
4188
4189 static inline void gen_intermediate_code_internal(CPUS390XState *env,
4190                                                   TranslationBlock *tb,
4191                                                   int search_pc)
4192 {
4193     DisasContext dc;
4194     target_ulong pc_start;
4195     uint64_t next_page_start;
4196     uint16_t *gen_opc_end;
4197     int j, lj = -1;
4198     int num_insns, max_insns;
4199     CPUBreakpoint *bp;
4200     ExitStatus status;
4201     bool do_debug;
4202
4203     pc_start = tb->pc;
4204
4205     /* 31-bit mode */
4206     if (!(tb->flags & FLAG_MASK_64)) {
4207         pc_start &= 0x7fffffff;
4208     }
4209
4210     dc.tb = tb;
4211     dc.pc = pc_start;
4212     dc.cc_op = CC_OP_DYNAMIC;
4213     do_debug = dc.singlestep_enabled = env->singlestep_enabled;
4214     dc.is_jmp = DISAS_NEXT;
4215
4216     gen_opc_end = tcg_ctx.gen_opc_buf + OPC_MAX_SIZE;
4217
4218     next_page_start = (pc_start & TARGET_PAGE_MASK) + TARGET_PAGE_SIZE;
4219
4220     num_insns = 0;
4221     max_insns = tb->cflags & CF_COUNT_MASK;
4222     if (max_insns == 0) {
4223         max_insns = CF_COUNT_MASK;
4224     }
4225
4226     gen_icount_start();
4227
4228     do {
4229         if (search_pc) {
4230             j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
4231             if (lj < j) {
4232                 lj++;
4233                 while (lj < j) {
4234                     tcg_ctx.gen_opc_instr_start[lj++] = 0;
4235                 }
4236             }
4237             tcg_ctx.gen_opc_pc[lj] = dc.pc;
4238             gen_opc_cc_op[lj] = dc.cc_op;
4239             tcg_ctx.gen_opc_instr_start[lj] = 1;
4240             tcg_ctx.gen_opc_icount[lj] = num_insns;
4241         }
4242         if (++num_insns == max_insns && (tb->cflags & CF_LAST_IO)) {
4243             gen_io_start();
4244         }
4245
4246         if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP | CPU_LOG_TB_OP_OPT))) {
4247             tcg_gen_debug_insn_start(dc.pc);
4248         }
4249
4250         status = NO_EXIT;
4251         if (unlikely(!QTAILQ_EMPTY(&env->breakpoints))) {
4252             QTAILQ_FOREACH(bp, &env->breakpoints, entry) {
4253                 if (bp->pc == dc.pc) {
4254                     status = EXIT_PC_STALE;
4255                     do_debug = true;
4256                     break;
4257                 }
4258             }
4259         }
4260         if (status == NO_EXIT) {
4261             status = translate_one(env, &dc);
4262         }
4263
4264         /* If we reach a page boundary, are single stepping,
4265            or exhaust instruction count, stop generation.  */
4266         if (status == NO_EXIT
4267             && (dc.pc >= next_page_start
4268                 || tcg_ctx.gen_opc_ptr >= gen_opc_end
4269                 || num_insns >= max_insns
4270                 || singlestep
4271                 || env->singlestep_enabled)) {
4272             status = EXIT_PC_STALE;
4273         }
4274     } while (status == NO_EXIT);
4275
4276     if (tb->cflags & CF_LAST_IO) {
4277         gen_io_end();
4278     }
4279
4280     switch (status) {
4281     case EXIT_GOTO_TB:
4282     case EXIT_NORETURN:
4283         break;
4284     case EXIT_PC_STALE:
4285         update_psw_addr(&dc);
4286         /* FALLTHRU */
4287     case EXIT_PC_UPDATED:
4288         if (singlestep && dc.cc_op != CC_OP_DYNAMIC) {
4289             gen_op_calc_cc(&dc);
4290         } else {
4291             /* Next TB starts off with CC_OP_DYNAMIC,
4292                so make sure the cc op type is in env */
4293             gen_op_set_cc_op(&dc);
4294         }
4295         if (do_debug) {
4296             gen_exception(EXCP_DEBUG);
4297         } else {
4298             /* Generate the return instruction */
4299             tcg_gen_exit_tb(0);
4300         }
4301         break;
4302     default:
4303         abort();
4304     }
4305
4306     gen_icount_end(tb, num_insns);
4307     *tcg_ctx.gen_opc_ptr = INDEX_op_end;
4308     if (search_pc) {
4309         j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
4310         lj++;
4311         while (lj <= j) {
4312             tcg_ctx.gen_opc_instr_start[lj++] = 0;
4313         }
4314     } else {
4315         tb->size = dc.pc - pc_start;
4316         tb->icount = num_insns;
4317     }
4318
4319 #if defined(S390X_DEBUG_DISAS)
4320     if (qemu_loglevel_mask(CPU_LOG_TB_IN_ASM)) {
4321         qemu_log("IN: %s\n", lookup_symbol(pc_start));
4322         log_target_disas(env, pc_start, dc.pc - pc_start, 1);
4323         qemu_log("\n");
4324     }
4325 #endif
4326 }
4327
4328 void gen_intermediate_code (CPUS390XState *env, struct TranslationBlock *tb)
4329 {
4330     gen_intermediate_code_internal(env, tb, 0);
4331 }
4332
4333 void gen_intermediate_code_pc (CPUS390XState *env, struct TranslationBlock *tb)
4334 {
4335     gen_intermediate_code_internal(env, tb, 1);
4336 }
4337
4338 void restore_state_to_opc(CPUS390XState *env, TranslationBlock *tb, int pc_pos)
4339 {
4340     int cc_op;
4341     env->psw.addr = tcg_ctx.gen_opc_pc[pc_pos];
4342     cc_op = gen_opc_cc_op[pc_pos];
4343     if ((cc_op != CC_OP_DYNAMIC) && (cc_op != CC_OP_STATIC)) {
4344         env->cc_op = cc_op;
4345     }
4346 }