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