]> git.proxmox.com Git - qemu.git/blob - target-s390x/translate.c
projects / qemu.git / blob
? search:


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