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