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