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