1 /* Target-dependent code for s390.
3 Copyright (C) 2001-2018 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program 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
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "arch-utils.h"
24 #include "dwarf2-frame.h"
27 #include "frame-base.h"
28 #include "frame-unwind.h"
32 #include "linux-tdep.h"
35 #include "record-full.h"
37 #include "reggroups.h"
38 #include "s390-tdep.h"
39 #include "target-descriptions.h"
40 #include "trad-frame.h"
43 #include "features/s390-linux32.c"
44 #include "features/s390x-linux64.c"
46 /* Holds the current set of options to be passed to the disassembler. */
47 static char *s390_disassembler_options;
51 constexpr gdb_byte s390_break_insn[] = { 0x0, 0x1 };
53 typedef BP_MANIPULATION (s390_break_insn) s390_breakpoint;
55 /* Decoding S/390 instructions. */
57 /* Read a single instruction from address AT. */
60 s390_readinstruction (bfd_byte instr[], CORE_ADDR at)
62 static int s390_instrlen[] = { 2, 4, 4, 6 };
65 if (target_read_memory (at, &instr[0], 2))
67 instrlen = s390_instrlen[instr[0] >> 6];
70 if (target_read_memory (at + 2, &instr[2], instrlen - 2))
76 /* The functions below are for recognizing and decoding S/390
77 instructions of various formats. Each of them checks whether INSN
78 is an instruction of the given format, with the specified opcodes.
79 If it is, it sets the remaining arguments to the values of the
80 instruction's fields, and returns a non-zero value; otherwise, it
83 These functions' arguments appear in the order they appear in the
84 instruction, not in the machine-language form. So, opcodes always
85 come first, even though they're sometimes scattered around the
86 instructions. And displacements appear before base and extension
87 registers, as they do in the assembly syntax, not at the end, as
88 they do in the machine language.
90 Test for RI instruction format. */
93 is_ri (bfd_byte *insn, int op1, int op2, unsigned int *r1, int *i2)
95 if (insn[0] == op1 && (insn[1] & 0xf) == op2)
97 *r1 = (insn[1] >> 4) & 0xf;
98 /* i2 is a 16-bit signed quantity. */
99 *i2 = (((insn[2] << 8) | insn[3]) ^ 0x8000) - 0x8000;
106 /* Test for RIL instruction format. See comment on is_ri for details. */
109 is_ril (bfd_byte *insn, int op1, int op2,
110 unsigned int *r1, int *i2)
112 if (insn[0] == op1 && (insn[1] & 0xf) == op2)
114 *r1 = (insn[1] >> 4) & 0xf;
115 /* i2 is a signed quantity. If the host 'int' is 32 bits long,
116 no sign extension is necessary, but we don't want to assume
118 *i2 = (((insn[2] << 24)
121 | (insn[5])) ^ 0x80000000) - 0x80000000;
128 /* Test for RR instruction format. See comment on is_ri for details. */
131 is_rr (bfd_byte *insn, int op, unsigned int *r1, unsigned int *r2)
135 *r1 = (insn[1] >> 4) & 0xf;
143 /* Test for RRE instruction format. See comment on is_ri for details. */
146 is_rre (bfd_byte *insn, int op, unsigned int *r1, unsigned int *r2)
148 if (((insn[0] << 8) | insn[1]) == op)
150 /* Yes, insn[3]. insn[2] is unused in RRE format. */
151 *r1 = (insn[3] >> 4) & 0xf;
159 /* Test for RS instruction format. See comment on is_ri for details. */
162 is_rs (bfd_byte *insn, int op,
163 unsigned int *r1, unsigned int *r3, int *d2, unsigned int *b2)
167 *r1 = (insn[1] >> 4) & 0xf;
169 *b2 = (insn[2] >> 4) & 0xf;
170 *d2 = ((insn[2] & 0xf) << 8) | insn[3];
177 /* Test for RSY instruction format. See comment on is_ri for details. */
180 is_rsy (bfd_byte *insn, int op1, int op2,
181 unsigned int *r1, unsigned int *r3, int *d2, unsigned int *b2)
186 *r1 = (insn[1] >> 4) & 0xf;
188 *b2 = (insn[2] >> 4) & 0xf;
189 /* The 'long displacement' is a 20-bit signed integer. */
190 *d2 = ((((insn[2] & 0xf) << 8) | insn[3] | (insn[4] << 12))
191 ^ 0x80000) - 0x80000;
198 /* Test for RX instruction format. See comment on is_ri for details. */
201 is_rx (bfd_byte *insn, int op,
202 unsigned int *r1, int *d2, unsigned int *x2, unsigned int *b2)
206 *r1 = (insn[1] >> 4) & 0xf;
208 *b2 = (insn[2] >> 4) & 0xf;
209 *d2 = ((insn[2] & 0xf) << 8) | insn[3];
216 /* Test for RXY instruction format. See comment on is_ri for details. */
219 is_rxy (bfd_byte *insn, int op1, int op2,
220 unsigned int *r1, int *d2, unsigned int *x2, unsigned int *b2)
225 *r1 = (insn[1] >> 4) & 0xf;
227 *b2 = (insn[2] >> 4) & 0xf;
228 /* The 'long displacement' is a 20-bit signed integer. */
229 *d2 = ((((insn[2] & 0xf) << 8) | insn[3] | (insn[4] << 12))
230 ^ 0x80000) - 0x80000;
237 /* A helper for s390_software_single_step, decides if an instruction
238 is a partial-execution instruction that needs to be executed until
239 completion when in record mode. If it is, returns 1 and writes
240 instruction length to a pointer. */
243 s390_is_partial_instruction (struct gdbarch *gdbarch, CORE_ADDR loc, int *len)
245 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
248 insn = read_memory_integer (loc, 2, byte_order);
252 case 0xa8: /* MVCLE */
258 insn = read_memory_integer (loc + 4, 2, byte_order);
259 if ((insn & 0xff) == 0x8e)
271 case 0xb255: /* MVST */
272 case 0xb263: /* CMPSC */
273 case 0xb2a5: /* TRE */
274 case 0xb2a6: /* CU21 */
275 case 0xb2a7: /* CU12 */
276 case 0xb9b0: /* CU14 */
277 case 0xb9b1: /* CU24 */
278 case 0xb9b2: /* CU41 */
279 case 0xb9b3: /* CU42 */
280 case 0xb92a: /* KMF */
281 case 0xb92b: /* KMO */
282 case 0xb92f: /* KMC */
283 case 0xb92d: /* KMCTR */
284 case 0xb92e: /* KM */
285 case 0xb93c: /* PPNO */
286 case 0xb990: /* TRTT */
287 case 0xb991: /* TRTO */
288 case 0xb992: /* TROT */
289 case 0xb993: /* TROO */
297 /* Implement the "software_single_step" gdbarch method, needed to single step
298 through instructions like MVCLE in record mode, to make sure they are
299 executed to completion. Without that, record will save the full length
300 of destination buffer on every iteration, even though the CPU will only
301 process about 4kiB of it each time, leading to O(n**2) memory and time
304 static std::vector<CORE_ADDR>
305 s390_software_single_step (struct regcache *regcache)
307 struct gdbarch *gdbarch = regcache->arch ();
308 CORE_ADDR loc = regcache_read_pc (regcache);
309 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
313 /* Special handling only if recording. */
314 if (!record_full_is_used ())
317 /* First, match a partial instruction. */
318 if (!s390_is_partial_instruction (gdbarch, loc, &len))
323 /* Second, look for a branch back to it. */
324 insn = read_memory_integer (loc, 2, byte_order);
325 if (insn != 0xa714) /* BRC with mask 1 */
328 insn = read_memory_integer (loc + 2, 2, byte_order);
329 if (insn != (uint16_t) -(len / 2))
334 /* Found it, step past the whole thing. */
338 /* Displaced stepping. */
340 /* Return true if INSN is a non-branch RIL-b or RIL-c format
344 is_non_branch_ril (gdb_byte *insn)
346 gdb_byte op1 = insn[0];
350 gdb_byte op2 = insn[1] & 0x0f;
354 case 0x02: /* llhrl */
355 case 0x04: /* lghrl */
356 case 0x05: /* lhrl */
357 case 0x06: /* llghrl */
358 case 0x07: /* sthrl */
359 case 0x08: /* lgrl */
360 case 0x0b: /* stgrl */
361 case 0x0c: /* lgfrl */
363 case 0x0e: /* llgfrl */
364 case 0x0f: /* strl */
368 else if (op1 == 0xc6)
370 gdb_byte op2 = insn[1] & 0x0f;
374 case 0x00: /* exrl */
375 case 0x02: /* pfdrl */
376 case 0x04: /* cghrl */
377 case 0x05: /* chrl */
378 case 0x06: /* clghrl */
379 case 0x07: /* clhrl */
380 case 0x08: /* cgrl */
381 case 0x0a: /* clgrl */
382 case 0x0c: /* cgfrl */
384 case 0x0e: /* clgfrl */
385 case 0x0f: /* clrl */
393 typedef buf_displaced_step_closure s390_displaced_step_closure;
395 /* Implementation of gdbarch_displaced_step_copy_insn. */
397 static struct displaced_step_closure *
398 s390_displaced_step_copy_insn (struct gdbarch *gdbarch,
399 CORE_ADDR from, CORE_ADDR to,
400 struct regcache *regs)
402 size_t len = gdbarch_max_insn_length (gdbarch);
403 std::unique_ptr<s390_displaced_step_closure> closure
404 (new s390_displaced_step_closure (len));
405 gdb_byte *buf = closure->buf.data ();
407 read_memory (from, buf, len);
409 /* Adjust the displacement field of PC-relative RIL instructions,
410 except branches. The latter are handled in the fixup hook. */
411 if (is_non_branch_ril (buf))
415 offset = extract_signed_integer (buf + 2, 4, BFD_ENDIAN_BIG);
416 offset = (from - to + offset * 2) / 2;
418 /* If the instruction is too far from the jump pad, punt. This
419 will usually happen with instructions in shared libraries.
420 We could probably support these by rewriting them to be
421 absolute or fully emulating them. */
422 if (offset < INT32_MIN || offset > INT32_MAX)
424 /* Let the core fall back to stepping over the breakpoint
428 fprintf_unfiltered (gdb_stdlog,
429 "displaced: can't displaced step "
430 "RIL instruction: offset %s out of range\n",
437 store_signed_integer (buf + 2, 4, BFD_ENDIAN_BIG, offset);
440 write_memory (to, buf, len);
444 fprintf_unfiltered (gdb_stdlog, "displaced: copy %s->%s: ",
445 paddress (gdbarch, from), paddress (gdbarch, to));
446 displaced_step_dump_bytes (gdb_stdlog, buf, len);
449 return closure.release ();
452 /* Fix up the state of registers and memory after having single-stepped
453 a displaced instruction. */
456 s390_displaced_step_fixup (struct gdbarch *gdbarch,
457 struct displaced_step_closure *closure_,
458 CORE_ADDR from, CORE_ADDR to,
459 struct regcache *regs)
461 /* Our closure is a copy of the instruction. */
462 s390_displaced_step_closure *closure
463 = (s390_displaced_step_closure *) closure_;
464 gdb_byte *insn = closure->buf.data ();
465 static int s390_instrlen[] = { 2, 4, 4, 6 };
466 int insnlen = s390_instrlen[insn[0] >> 6];
468 /* Fields for various kinds of instructions. */
469 unsigned int b2, r1, r2, x2, r3;
472 /* Get current PC and addressing mode bit. */
473 CORE_ADDR pc = regcache_read_pc (regs);
476 if (register_size (gdbarch, S390_PSWA_REGNUM) == 4)
478 regcache_cooked_read_unsigned (regs, S390_PSWA_REGNUM, &amode);
483 fprintf_unfiltered (gdb_stdlog,
484 "displaced: (s390) fixup (%s, %s) pc %s len %d amode 0x%x\n",
485 paddress (gdbarch, from), paddress (gdbarch, to),
486 paddress (gdbarch, pc), insnlen, (int) amode);
488 /* Handle absolute branch and save instructions. */
489 if (is_rr (insn, op_basr, &r1, &r2)
490 || is_rx (insn, op_bas, &r1, &d2, &x2, &b2))
492 /* Recompute saved return address in R1. */
493 regcache_cooked_write_unsigned (regs, S390_R0_REGNUM + r1,
494 amode | (from + insnlen));
497 /* Handle absolute branch instructions. */
498 else if (is_rr (insn, op_bcr, &r1, &r2)
499 || is_rx (insn, op_bc, &r1, &d2, &x2, &b2)
500 || is_rr (insn, op_bctr, &r1, &r2)
501 || is_rre (insn, op_bctgr, &r1, &r2)
502 || is_rx (insn, op_bct, &r1, &d2, &x2, &b2)
503 || is_rxy (insn, op1_bctg, op2_brctg, &r1, &d2, &x2, &b2)
504 || is_rs (insn, op_bxh, &r1, &r3, &d2, &b2)
505 || is_rsy (insn, op1_bxhg, op2_bxhg, &r1, &r3, &d2, &b2)
506 || is_rs (insn, op_bxle, &r1, &r3, &d2, &b2)
507 || is_rsy (insn, op1_bxleg, op2_bxleg, &r1, &r3, &d2, &b2))
509 /* Update PC iff branch was *not* taken. */
510 if (pc == to + insnlen)
511 regcache_write_pc (regs, from + insnlen);
514 /* Handle PC-relative branch and save instructions. */
515 else if (is_ri (insn, op1_bras, op2_bras, &r1, &i2)
516 || is_ril (insn, op1_brasl, op2_brasl, &r1, &i2))
519 regcache_write_pc (regs, pc - to + from);
520 /* Recompute saved return address in R1. */
521 regcache_cooked_write_unsigned (regs, S390_R0_REGNUM + r1,
522 amode | (from + insnlen));
525 /* Handle LOAD ADDRESS RELATIVE LONG. */
526 else if (is_ril (insn, op1_larl, op2_larl, &r1, &i2))
529 regcache_write_pc (regs, from + insnlen);
530 /* Recompute output address in R1. */
531 regcache_cooked_write_unsigned (regs, S390_R0_REGNUM + r1,
532 amode | (from + i2 * 2));
535 /* If we executed a breakpoint instruction, point PC right back at it. */
536 else if (insn[0] == 0x0 && insn[1] == 0x1)
537 regcache_write_pc (regs, from);
539 /* For any other insn, adjust PC by negated displacement. PC then
540 points right after the original instruction, except for PC-relative
541 branches, where it points to the adjusted branch target. */
543 regcache_write_pc (regs, pc - to + from);
546 fprintf_unfiltered (gdb_stdlog,
547 "displaced: (s390) pc is now %s\n",
548 paddress (gdbarch, regcache_read_pc (regs)));
551 /* Implement displaced_step_hw_singlestep gdbarch method. */
554 s390_displaced_step_hw_singlestep (struct gdbarch *gdbarch,
555 struct displaced_step_closure *closure)
560 /* Prologue analysis. */
562 struct s390_prologue_data {
565 struct pv_area *stack;
567 /* The size and byte-order of a GPR or FPR. */
570 enum bfd_endian byte_order;
572 /* The general-purpose registers. */
573 pv_t gpr[S390_NUM_GPRS];
575 /* The floating-point registers. */
576 pv_t fpr[S390_NUM_FPRS];
578 /* The offset relative to the CFA where the incoming GPR N was saved
579 by the function prologue. 0 if not saved or unknown. */
580 int gpr_slot[S390_NUM_GPRS];
582 /* Likewise for FPRs. */
583 int fpr_slot[S390_NUM_FPRS];
585 /* Nonzero if the backchain was saved. This is assumed to be the
586 case when the incoming SP is saved at the current SP location. */
587 int back_chain_saved_p;
590 /* Return the effective address for an X-style instruction, like:
594 Here, X2 and B2 are registers, and D2 is a signed 20-bit
595 constant; the effective address is the sum of all three. If either
596 X2 or B2 are zero, then it doesn't contribute to the sum --- this
597 means that r0 can't be used as either X2 or B2. */
600 s390_addr (struct s390_prologue_data *data,
601 int d2, unsigned int x2, unsigned int b2)
605 result = pv_constant (d2);
607 result = pv_add (result, data->gpr[x2]);
609 result = pv_add (result, data->gpr[b2]);
614 /* Do a SIZE-byte store of VALUE to D2(X2,B2). */
617 s390_store (struct s390_prologue_data *data,
618 int d2, unsigned int x2, unsigned int b2, CORE_ADDR size,
621 pv_t addr = s390_addr (data, d2, x2, b2);
624 /* Check whether we are storing the backchain. */
625 offset = pv_subtract (data->gpr[S390_SP_REGNUM - S390_R0_REGNUM], addr);
627 if (pv_is_constant (offset) && offset.k == 0)
628 if (size == data->gpr_size
629 && pv_is_register_k (value, S390_SP_REGNUM, 0))
631 data->back_chain_saved_p = 1;
635 /* Check whether we are storing a register into the stack. */
636 if (!data->stack->store_would_trash (addr))
637 data->stack->store (addr, size, value);
639 /* Note: If this is some store we cannot identify, you might think we
640 should forget our cached values, as any of those might have been hit.
642 However, we make the assumption that the register save areas are only
643 ever stored to once in any given function, and we do recognize these
644 stores. Thus every store we cannot recognize does not hit our data. */
647 /* Do a SIZE-byte load from D2(X2,B2). */
650 s390_load (struct s390_prologue_data *data,
651 int d2, unsigned int x2, unsigned int b2, CORE_ADDR size)
654 pv_t addr = s390_addr (data, d2, x2, b2);
656 /* If it's a load from an in-line constant pool, then we can
657 simulate that, under the assumption that the code isn't
658 going to change between the time the processor actually
659 executed it creating the current frame, and the time when
660 we're analyzing the code to unwind past that frame. */
661 if (pv_is_constant (addr))
663 struct target_section *secp;
664 secp = target_section_by_addr (¤t_target, addr.k);
666 && (bfd_get_section_flags (secp->the_bfd_section->owner,
667 secp->the_bfd_section)
669 return pv_constant (read_memory_integer (addr.k, size,
673 /* Check whether we are accessing one of our save slots. */
674 return data->stack->fetch (addr, size);
677 /* Function for finding saved registers in a 'struct pv_area'; we pass
678 this to pv_area::scan.
680 If VALUE is a saved register, ADDR says it was saved at a constant
681 offset from the frame base, and SIZE indicates that the whole
682 register was saved, record its offset in the reg_offset table in
686 s390_check_for_saved (void *data_untyped, pv_t addr,
687 CORE_ADDR size, pv_t value)
689 struct s390_prologue_data *data = (struct s390_prologue_data *) data_untyped;
692 if (!pv_is_register (addr, S390_SP_REGNUM))
695 offset = 16 * data->gpr_size + 32 - addr.k;
697 /* If we are storing the original value of a register, we want to
698 record the CFA offset. If the same register is stored multiple
699 times, the stack slot with the highest address counts. */
701 for (i = 0; i < S390_NUM_GPRS; i++)
702 if (size == data->gpr_size
703 && pv_is_register_k (value, S390_R0_REGNUM + i, 0))
704 if (data->gpr_slot[i] == 0
705 || data->gpr_slot[i] > offset)
707 data->gpr_slot[i] = offset;
711 for (i = 0; i < S390_NUM_FPRS; i++)
712 if (size == data->fpr_size
713 && pv_is_register_k (value, S390_F0_REGNUM + i, 0))
714 if (data->fpr_slot[i] == 0
715 || data->fpr_slot[i] > offset)
717 data->fpr_slot[i] = offset;
722 /* Analyze the prologue of the function starting at START_PC, continuing at
723 most until CURRENT_PC. Initialize DATA to hold all information we find
724 out about the state of the registers and stack slots. Return the address
725 of the instruction after the last one that changed the SP, FP, or back
726 chain; or zero on error. */
729 s390_analyze_prologue (struct gdbarch *gdbarch,
731 CORE_ADDR current_pc,
732 struct s390_prologue_data *data)
734 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
737 The address of the instruction after the last one that changed
738 the SP, FP, or back chain; zero if we got an error trying to
740 CORE_ADDR result = start_pc;
742 /* The current PC for our abstract interpretation. */
745 /* The address of the next instruction after that. */
748 pv_area stack (S390_SP_REGNUM, gdbarch_addr_bit (gdbarch));
749 scoped_restore restore_stack = make_scoped_restore (&data->stack, &stack);
751 /* Set up everything's initial value. */
755 /* For the purpose of prologue tracking, we consider the GPR size to
756 be equal to the ABI word size, even if it is actually larger
757 (i.e. when running a 32-bit binary under a 64-bit kernel). */
758 data->gpr_size = word_size;
760 data->byte_order = gdbarch_byte_order (gdbarch);
762 for (i = 0; i < S390_NUM_GPRS; i++)
763 data->gpr[i] = pv_register (S390_R0_REGNUM + i, 0);
765 for (i = 0; i < S390_NUM_FPRS; i++)
766 data->fpr[i] = pv_register (S390_F0_REGNUM + i, 0);
768 for (i = 0; i < S390_NUM_GPRS; i++)
769 data->gpr_slot[i] = 0;
771 for (i = 0; i < S390_NUM_FPRS; i++)
772 data->fpr_slot[i] = 0;
774 data->back_chain_saved_p = 0;
777 /* Start interpreting instructions, until we hit the frame's
778 current PC or the first branch instruction. */
779 for (pc = start_pc; pc > 0 && pc < current_pc; pc = next_pc)
781 bfd_byte insn[S390_MAX_INSTR_SIZE];
782 int insn_len = s390_readinstruction (insn, pc);
784 bfd_byte dummy[S390_MAX_INSTR_SIZE] = { 0 };
785 bfd_byte *insn32 = word_size == 4 ? insn : dummy;
786 bfd_byte *insn64 = word_size == 8 ? insn : dummy;
788 /* Fields for various kinds of instructions. */
789 unsigned int b2, r1, r2, x2, r3;
792 /* The values of SP and FP before this instruction,
793 for detecting instructions that change them. */
794 pv_t pre_insn_sp, pre_insn_fp;
795 /* Likewise for the flag whether the back chain was saved. */
796 int pre_insn_back_chain_saved_p;
798 /* If we got an error trying to read the instruction, report it. */
805 next_pc = pc + insn_len;
807 pre_insn_sp = data->gpr[S390_SP_REGNUM - S390_R0_REGNUM];
808 pre_insn_fp = data->gpr[S390_FRAME_REGNUM - S390_R0_REGNUM];
809 pre_insn_back_chain_saved_p = data->back_chain_saved_p;
811 /* LHI r1, i2 --- load halfword immediate. */
812 /* LGHI r1, i2 --- load halfword immediate (64-bit version). */
813 /* LGFI r1, i2 --- load fullword immediate. */
814 if (is_ri (insn32, op1_lhi, op2_lhi, &r1, &i2)
815 || is_ri (insn64, op1_lghi, op2_lghi, &r1, &i2)
816 || is_ril (insn, op1_lgfi, op2_lgfi, &r1, &i2))
817 data->gpr[r1] = pv_constant (i2);
819 /* LR r1, r2 --- load from register. */
820 /* LGR r1, r2 --- load from register (64-bit version). */
821 else if (is_rr (insn32, op_lr, &r1, &r2)
822 || is_rre (insn64, op_lgr, &r1, &r2))
823 data->gpr[r1] = data->gpr[r2];
825 /* L r1, d2(x2, b2) --- load. */
826 /* LY r1, d2(x2, b2) --- load (long-displacement version). */
827 /* LG r1, d2(x2, b2) --- load (64-bit version). */
828 else if (is_rx (insn32, op_l, &r1, &d2, &x2, &b2)
829 || is_rxy (insn32, op1_ly, op2_ly, &r1, &d2, &x2, &b2)
830 || is_rxy (insn64, op1_lg, op2_lg, &r1, &d2, &x2, &b2))
831 data->gpr[r1] = s390_load (data, d2, x2, b2, data->gpr_size);
833 /* ST r1, d2(x2, b2) --- store. */
834 /* STY r1, d2(x2, b2) --- store (long-displacement version). */
835 /* STG r1, d2(x2, b2) --- store (64-bit version). */
836 else if (is_rx (insn32, op_st, &r1, &d2, &x2, &b2)
837 || is_rxy (insn32, op1_sty, op2_sty, &r1, &d2, &x2, &b2)
838 || is_rxy (insn64, op1_stg, op2_stg, &r1, &d2, &x2, &b2))
839 s390_store (data, d2, x2, b2, data->gpr_size, data->gpr[r1]);
841 /* STD r1, d2(x2,b2) --- store floating-point register. */
842 else if (is_rx (insn, op_std, &r1, &d2, &x2, &b2))
843 s390_store (data, d2, x2, b2, data->fpr_size, data->fpr[r1]);
845 /* STM r1, r3, d2(b2) --- store multiple. */
846 /* STMY r1, r3, d2(b2) --- store multiple (long-displacement
848 /* STMG r1, r3, d2(b2) --- store multiple (64-bit version). */
849 else if (is_rs (insn32, op_stm, &r1, &r3, &d2, &b2)
850 || is_rsy (insn32, op1_stmy, op2_stmy, &r1, &r3, &d2, &b2)
851 || is_rsy (insn64, op1_stmg, op2_stmg, &r1, &r3, &d2, &b2))
853 for (; r1 <= r3; r1++, d2 += data->gpr_size)
854 s390_store (data, d2, 0, b2, data->gpr_size, data->gpr[r1]);
857 /* AHI r1, i2 --- add halfword immediate. */
858 /* AGHI r1, i2 --- add halfword immediate (64-bit version). */
859 /* AFI r1, i2 --- add fullword immediate. */
860 /* AGFI r1, i2 --- add fullword immediate (64-bit version). */
861 else if (is_ri (insn32, op1_ahi, op2_ahi, &r1, &i2)
862 || is_ri (insn64, op1_aghi, op2_aghi, &r1, &i2)
863 || is_ril (insn32, op1_afi, op2_afi, &r1, &i2)
864 || is_ril (insn64, op1_agfi, op2_agfi, &r1, &i2))
865 data->gpr[r1] = pv_add_constant (data->gpr[r1], i2);
867 /* ALFI r1, i2 --- add logical immediate. */
868 /* ALGFI r1, i2 --- add logical immediate (64-bit version). */
869 else if (is_ril (insn32, op1_alfi, op2_alfi, &r1, &i2)
870 || is_ril (insn64, op1_algfi, op2_algfi, &r1, &i2))
871 data->gpr[r1] = pv_add_constant (data->gpr[r1],
872 (CORE_ADDR)i2 & 0xffffffff);
874 /* AR r1, r2 -- add register. */
875 /* AGR r1, r2 -- add register (64-bit version). */
876 else if (is_rr (insn32, op_ar, &r1, &r2)
877 || is_rre (insn64, op_agr, &r1, &r2))
878 data->gpr[r1] = pv_add (data->gpr[r1], data->gpr[r2]);
880 /* A r1, d2(x2, b2) -- add. */
881 /* AY r1, d2(x2, b2) -- add (long-displacement version). */
882 /* AG r1, d2(x2, b2) -- add (64-bit version). */
883 else if (is_rx (insn32, op_a, &r1, &d2, &x2, &b2)
884 || is_rxy (insn32, op1_ay, op2_ay, &r1, &d2, &x2, &b2)
885 || is_rxy (insn64, op1_ag, op2_ag, &r1, &d2, &x2, &b2))
886 data->gpr[r1] = pv_add (data->gpr[r1],
887 s390_load (data, d2, x2, b2, data->gpr_size));
889 /* SLFI r1, i2 --- subtract logical immediate. */
890 /* SLGFI r1, i2 --- subtract logical immediate (64-bit version). */
891 else if (is_ril (insn32, op1_slfi, op2_slfi, &r1, &i2)
892 || is_ril (insn64, op1_slgfi, op2_slgfi, &r1, &i2))
893 data->gpr[r1] = pv_add_constant (data->gpr[r1],
894 -((CORE_ADDR)i2 & 0xffffffff));
896 /* SR r1, r2 -- subtract register. */
897 /* SGR r1, r2 -- subtract register (64-bit version). */
898 else if (is_rr (insn32, op_sr, &r1, &r2)
899 || is_rre (insn64, op_sgr, &r1, &r2))
900 data->gpr[r1] = pv_subtract (data->gpr[r1], data->gpr[r2]);
902 /* S r1, d2(x2, b2) -- subtract. */
903 /* SY r1, d2(x2, b2) -- subtract (long-displacement version). */
904 /* SG r1, d2(x2, b2) -- subtract (64-bit version). */
905 else if (is_rx (insn32, op_s, &r1, &d2, &x2, &b2)
906 || is_rxy (insn32, op1_sy, op2_sy, &r1, &d2, &x2, &b2)
907 || is_rxy (insn64, op1_sg, op2_sg, &r1, &d2, &x2, &b2))
908 data->gpr[r1] = pv_subtract (data->gpr[r1],
909 s390_load (data, d2, x2, b2, data->gpr_size));
911 /* LA r1, d2(x2, b2) --- load address. */
912 /* LAY r1, d2(x2, b2) --- load address (long-displacement version). */
913 else if (is_rx (insn, op_la, &r1, &d2, &x2, &b2)
914 || is_rxy (insn, op1_lay, op2_lay, &r1, &d2, &x2, &b2))
915 data->gpr[r1] = s390_addr (data, d2, x2, b2);
917 /* LARL r1, i2 --- load address relative long. */
918 else if (is_ril (insn, op1_larl, op2_larl, &r1, &i2))
919 data->gpr[r1] = pv_constant (pc + i2 * 2);
921 /* BASR r1, 0 --- branch and save.
922 Since r2 is zero, this saves the PC in r1, but doesn't branch. */
923 else if (is_rr (insn, op_basr, &r1, &r2)
925 data->gpr[r1] = pv_constant (next_pc);
927 /* BRAS r1, i2 --- branch relative and save. */
928 else if (is_ri (insn, op1_bras, op2_bras, &r1, &i2))
930 data->gpr[r1] = pv_constant (next_pc);
931 next_pc = pc + i2 * 2;
933 /* We'd better not interpret any backward branches. We'll
939 /* BRC/BRCL -- branch relative on condition. Ignore "branch
940 never", branch to following instruction, and "conditional
941 trap" (BRC +2). Otherwise terminate search. */
942 else if (is_ri (insn, op1_brc, op2_brc, &r1, &i2))
944 if (r1 != 0 && i2 != 1 && i2 != 2)
947 else if (is_ril (insn, op1_brcl, op2_brcl, &r1, &i2))
949 if (r1 != 0 && i2 != 3)
953 /* Terminate search when hitting any other branch instruction. */
954 else if (is_rr (insn, op_basr, &r1, &r2)
955 || is_rx (insn, op_bas, &r1, &d2, &x2, &b2)
956 || is_rr (insn, op_bcr, &r1, &r2)
957 || is_rx (insn, op_bc, &r1, &d2, &x2, &b2)
958 || is_ril (insn, op1_brasl, op2_brasl, &r2, &i2))
963 /* An instruction we don't know how to simulate. The only
964 safe thing to do would be to set every value we're tracking
965 to 'unknown'. Instead, we'll be optimistic: we assume that
966 we *can* interpret every instruction that the compiler uses
967 to manipulate any of the data we're interested in here --
968 then we can just ignore anything else. */
971 /* Record the address after the last instruction that changed
972 the FP, SP, or backlink. Ignore instructions that changed
973 them back to their original values --- those are probably
974 restore instructions. (The back chain is never restored,
977 pv_t sp = data->gpr[S390_SP_REGNUM - S390_R0_REGNUM];
978 pv_t fp = data->gpr[S390_FRAME_REGNUM - S390_R0_REGNUM];
980 if ((! pv_is_identical (pre_insn_sp, sp)
981 && ! pv_is_register_k (sp, S390_SP_REGNUM, 0)
982 && sp.kind != pvk_unknown)
983 || (! pv_is_identical (pre_insn_fp, fp)
984 && ! pv_is_register_k (fp, S390_FRAME_REGNUM, 0)
985 && fp.kind != pvk_unknown)
986 || pre_insn_back_chain_saved_p != data->back_chain_saved_p)
991 /* Record where all the registers were saved. */
992 data->stack->scan (s390_check_for_saved, data);
997 /* Advance PC across any function entry prologue instructions to reach
1001 s390_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
1003 struct s390_prologue_data data;
1004 CORE_ADDR skip_pc, func_addr;
1006 if (find_pc_partial_function (pc, NULL, &func_addr, NULL))
1008 CORE_ADDR post_prologue_pc
1009 = skip_prologue_using_sal (gdbarch, func_addr);
1010 if (post_prologue_pc != 0)
1011 return std::max (pc, post_prologue_pc);
1014 skip_pc = s390_analyze_prologue (gdbarch, pc, (CORE_ADDR)-1, &data);
1015 return skip_pc ? skip_pc : pc;
1018 /* Register handling. */
1020 /* ABI call-saved register information. */
1023 s390_register_call_saved (struct gdbarch *gdbarch, int regnum)
1025 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1029 case ABI_LINUX_S390:
1030 if ((regnum >= S390_R6_REGNUM && regnum <= S390_R15_REGNUM)
1031 || regnum == S390_F4_REGNUM || regnum == S390_F6_REGNUM
1032 || regnum == S390_A0_REGNUM)
1037 case ABI_LINUX_ZSERIES:
1038 if ((regnum >= S390_R6_REGNUM && regnum <= S390_R15_REGNUM)
1039 || (regnum >= S390_F8_REGNUM && regnum <= S390_F15_REGNUM)
1040 || (regnum >= S390_A0_REGNUM && regnum <= S390_A1_REGNUM))
1049 /* The "guess_tracepoint_registers" gdbarch method. */
1052 s390_guess_tracepoint_registers (struct gdbarch *gdbarch,
1053 struct regcache *regcache,
1056 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1057 int sz = register_size (gdbarch, S390_PSWA_REGNUM);
1058 gdb_byte *reg = (gdb_byte *) alloca (sz);
1059 ULONGEST pswm, pswa;
1061 /* Set PSWA from the location and a default PSWM (the only part we're
1062 unlikely to get right is the CC). */
1063 if (tdep->abi == ABI_LINUX_S390)
1065 /* 31-bit PSWA needs high bit set (it's very unlikely the target
1066 was in 24-bit mode). */
1067 pswa = addr | 0x80000000UL;
1068 pswm = 0x070d0000UL;
1073 pswm = 0x0705000180000000ULL;
1076 store_unsigned_integer (reg, sz, gdbarch_byte_order (gdbarch), pswa);
1077 regcache_raw_supply (regcache, S390_PSWA_REGNUM, reg);
1079 store_unsigned_integer (reg, sz, gdbarch_byte_order (gdbarch), pswm);
1080 regcache_raw_supply (regcache, S390_PSWM_REGNUM, reg);
1083 /* Return the name of register REGNO. Return the empty string for
1084 registers that shouldn't be visible. */
1087 s390_register_name (struct gdbarch *gdbarch, int regnum)
1089 if (regnum >= S390_V0_LOWER_REGNUM
1090 && regnum <= S390_V15_LOWER_REGNUM)
1092 return tdesc_register_name (gdbarch, regnum);
1095 /* DWARF Register Mapping. */
1097 static const short s390_dwarf_regmap[] =
1099 /* 0-15: General Purpose Registers. */
1100 S390_R0_REGNUM, S390_R1_REGNUM, S390_R2_REGNUM, S390_R3_REGNUM,
1101 S390_R4_REGNUM, S390_R5_REGNUM, S390_R6_REGNUM, S390_R7_REGNUM,
1102 S390_R8_REGNUM, S390_R9_REGNUM, S390_R10_REGNUM, S390_R11_REGNUM,
1103 S390_R12_REGNUM, S390_R13_REGNUM, S390_R14_REGNUM, S390_R15_REGNUM,
1105 /* 16-31: Floating Point Registers / Vector Registers 0-15. */
1106 S390_F0_REGNUM, S390_F2_REGNUM, S390_F4_REGNUM, S390_F6_REGNUM,
1107 S390_F1_REGNUM, S390_F3_REGNUM, S390_F5_REGNUM, S390_F7_REGNUM,
1108 S390_F8_REGNUM, S390_F10_REGNUM, S390_F12_REGNUM, S390_F14_REGNUM,
1109 S390_F9_REGNUM, S390_F11_REGNUM, S390_F13_REGNUM, S390_F15_REGNUM,
1111 /* 32-47: Control Registers (not mapped). */
1112 -1, -1, -1, -1, -1, -1, -1, -1,
1113 -1, -1, -1, -1, -1, -1, -1, -1,
1115 /* 48-63: Access Registers. */
1116 S390_A0_REGNUM, S390_A1_REGNUM, S390_A2_REGNUM, S390_A3_REGNUM,
1117 S390_A4_REGNUM, S390_A5_REGNUM, S390_A6_REGNUM, S390_A7_REGNUM,
1118 S390_A8_REGNUM, S390_A9_REGNUM, S390_A10_REGNUM, S390_A11_REGNUM,
1119 S390_A12_REGNUM, S390_A13_REGNUM, S390_A14_REGNUM, S390_A15_REGNUM,
1121 /* 64-65: Program Status Word. */
1125 /* 66-67: Reserved. */
1128 /* 68-83: Vector Registers 16-31. */
1129 S390_V16_REGNUM, S390_V18_REGNUM, S390_V20_REGNUM, S390_V22_REGNUM,
1130 S390_V17_REGNUM, S390_V19_REGNUM, S390_V21_REGNUM, S390_V23_REGNUM,
1131 S390_V24_REGNUM, S390_V26_REGNUM, S390_V28_REGNUM, S390_V30_REGNUM,
1132 S390_V25_REGNUM, S390_V27_REGNUM, S390_V29_REGNUM, S390_V31_REGNUM,
1134 /* End of "official" DWARF registers. The remainder of the map is
1135 for GDB internal use only. */
1137 /* GPR Lower Half Access. */
1138 S390_R0_REGNUM, S390_R1_REGNUM, S390_R2_REGNUM, S390_R3_REGNUM,
1139 S390_R4_REGNUM, S390_R5_REGNUM, S390_R6_REGNUM, S390_R7_REGNUM,
1140 S390_R8_REGNUM, S390_R9_REGNUM, S390_R10_REGNUM, S390_R11_REGNUM,
1141 S390_R12_REGNUM, S390_R13_REGNUM, S390_R14_REGNUM, S390_R15_REGNUM,
1144 enum { s390_dwarf_reg_r0l = ARRAY_SIZE (s390_dwarf_regmap) - 16 };
1146 /* Convert DWARF register number REG to the appropriate register
1147 number used by GDB. */
1150 s390_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int reg)
1152 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1155 /* In a 32-on-64 debug scenario, debug info refers to the full
1156 64-bit GPRs. Note that call frame information still refers to
1157 the 32-bit lower halves, because s390_adjust_frame_regnum uses
1158 special register numbers to access GPRs. */
1159 if (tdep->gpr_full_regnum != -1 && reg >= 0 && reg < 16)
1160 return tdep->gpr_full_regnum + reg;
1162 if (reg >= 0 && reg < ARRAY_SIZE (s390_dwarf_regmap))
1163 gdb_reg = s390_dwarf_regmap[reg];
1165 if (tdep->v0_full_regnum == -1)
1167 if (gdb_reg >= S390_V16_REGNUM && gdb_reg <= S390_V31_REGNUM)
1172 if (gdb_reg >= S390_F0_REGNUM && gdb_reg <= S390_F15_REGNUM)
1173 gdb_reg = gdb_reg - S390_F0_REGNUM + tdep->v0_full_regnum;
1179 /* Pseudo registers. */
1181 /* Check whether REGNUM indicates a coupled general purpose register.
1182 These pseudo-registers are composed of two adjacent gprs. */
1185 regnum_is_gpr_full (struct gdbarch_tdep *tdep, int regnum)
1187 return (tdep->gpr_full_regnum != -1
1188 && regnum >= tdep->gpr_full_regnum
1189 && regnum <= tdep->gpr_full_regnum + 15);
1192 /* Check whether REGNUM indicates a full vector register (v0-v15).
1193 These pseudo-registers are composed of f0-f15 and v0l-v15l. */
1196 regnum_is_vxr_full (struct gdbarch_tdep *tdep, int regnum)
1198 return (tdep->v0_full_regnum != -1
1199 && regnum >= tdep->v0_full_regnum
1200 && regnum <= tdep->v0_full_regnum + 15);
1203 /* 'float' values are stored in the upper half of floating-point
1204 registers, even though we are otherwise a big-endian platform. The
1205 same applies to a 'float' value within a vector. */
1207 static struct value *
1208 s390_value_from_register (struct gdbarch *gdbarch, struct type *type,
1209 int regnum, struct frame_id frame_id)
1211 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1212 struct value *value = default_value_from_register (gdbarch, type,
1214 check_typedef (type);
1216 if ((regnum >= S390_F0_REGNUM && regnum <= S390_F15_REGNUM
1217 && TYPE_LENGTH (type) < 8)
1218 || regnum_is_vxr_full (tdep, regnum)
1219 || (regnum >= S390_V16_REGNUM && regnum <= S390_V31_REGNUM))
1220 set_value_offset (value, 0);
1225 /* Implement pseudo_register_name tdesc method. */
1228 s390_pseudo_register_name (struct gdbarch *gdbarch, int regnum)
1230 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1232 if (regnum == tdep->pc_regnum)
1235 if (regnum == tdep->cc_regnum)
1238 if (regnum_is_gpr_full (tdep, regnum))
1240 static const char *full_name[] = {
1241 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1242 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
1244 return full_name[regnum - tdep->gpr_full_regnum];
1247 if (regnum_is_vxr_full (tdep, regnum))
1249 static const char *full_name[] = {
1250 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
1251 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15"
1253 return full_name[regnum - tdep->v0_full_regnum];
1256 internal_error (__FILE__, __LINE__, _("invalid regnum"));
1259 /* Implement pseudo_register_type tdesc method. */
1261 static struct type *
1262 s390_pseudo_register_type (struct gdbarch *gdbarch, int regnum)
1264 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1266 if (regnum == tdep->pc_regnum)
1267 return builtin_type (gdbarch)->builtin_func_ptr;
1269 if (regnum == tdep->cc_regnum)
1270 return builtin_type (gdbarch)->builtin_int;
1272 if (regnum_is_gpr_full (tdep, regnum))
1273 return builtin_type (gdbarch)->builtin_uint64;
1275 if (regnum_is_vxr_full (tdep, regnum))
1276 return tdesc_find_type (gdbarch, "vec128");
1278 internal_error (__FILE__, __LINE__, _("invalid regnum"));
1281 /* Implement pseudo_register_read gdbarch method. */
1283 static enum register_status
1284 s390_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
1285 int regnum, gdb_byte *buf)
1287 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1288 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1289 int regsize = register_size (gdbarch, regnum);
1292 if (regnum == tdep->pc_regnum)
1294 enum register_status status;
1296 status = regcache->raw_read (S390_PSWA_REGNUM, &val);
1297 if (status == REG_VALID)
1299 if (register_size (gdbarch, S390_PSWA_REGNUM) == 4)
1301 store_unsigned_integer (buf, regsize, byte_order, val);
1306 if (regnum == tdep->cc_regnum)
1308 enum register_status status;
1310 status = regcache->raw_read (S390_PSWM_REGNUM, &val);
1311 if (status == REG_VALID)
1313 if (register_size (gdbarch, S390_PSWA_REGNUM) == 4)
1314 val = (val >> 12) & 3;
1316 val = (val >> 44) & 3;
1317 store_unsigned_integer (buf, regsize, byte_order, val);
1322 if (regnum_is_gpr_full (tdep, regnum))
1324 enum register_status status;
1327 regnum -= tdep->gpr_full_regnum;
1329 status = regcache->raw_read (S390_R0_REGNUM + regnum, &val);
1330 if (status == REG_VALID)
1331 status = regcache->raw_read (S390_R0_UPPER_REGNUM + regnum,
1333 if (status == REG_VALID)
1335 val |= val_upper << 32;
1336 store_unsigned_integer (buf, regsize, byte_order, val);
1341 if (regnum_is_vxr_full (tdep, regnum))
1343 enum register_status status;
1345 regnum -= tdep->v0_full_regnum;
1347 status = regcache->raw_read (S390_F0_REGNUM + regnum, buf);
1348 if (status == REG_VALID)
1349 status = regcache->raw_read (S390_V0_LOWER_REGNUM + regnum, buf + 8);
1353 internal_error (__FILE__, __LINE__, _("invalid regnum"));
1356 /* Implement pseudo_register_write gdbarch method. */
1359 s390_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
1360 int regnum, const gdb_byte *buf)
1362 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1363 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1364 int regsize = register_size (gdbarch, regnum);
1367 if (regnum == tdep->pc_regnum)
1369 val = extract_unsigned_integer (buf, regsize, byte_order);
1370 if (register_size (gdbarch, S390_PSWA_REGNUM) == 4)
1372 regcache_raw_read_unsigned (regcache, S390_PSWA_REGNUM, &psw);
1373 val = (psw & 0x80000000) | (val & 0x7fffffff);
1375 regcache_raw_write_unsigned (regcache, S390_PSWA_REGNUM, val);
1379 if (regnum == tdep->cc_regnum)
1381 val = extract_unsigned_integer (buf, regsize, byte_order);
1382 regcache_raw_read_unsigned (regcache, S390_PSWM_REGNUM, &psw);
1383 if (register_size (gdbarch, S390_PSWA_REGNUM) == 4)
1384 val = (psw & ~((ULONGEST)3 << 12)) | ((val & 3) << 12);
1386 val = (psw & ~((ULONGEST)3 << 44)) | ((val & 3) << 44);
1387 regcache_raw_write_unsigned (regcache, S390_PSWM_REGNUM, val);
1391 if (regnum_is_gpr_full (tdep, regnum))
1393 regnum -= tdep->gpr_full_regnum;
1394 val = extract_unsigned_integer (buf, regsize, byte_order);
1395 regcache_raw_write_unsigned (regcache, S390_R0_REGNUM + regnum,
1397 regcache_raw_write_unsigned (regcache, S390_R0_UPPER_REGNUM + regnum,
1402 if (regnum_is_vxr_full (tdep, regnum))
1404 regnum -= tdep->v0_full_regnum;
1405 regcache_raw_write (regcache, S390_F0_REGNUM + regnum, buf);
1406 regcache_raw_write (regcache, S390_V0_LOWER_REGNUM + regnum, buf + 8);
1410 internal_error (__FILE__, __LINE__, _("invalid regnum"));
1413 /* Register groups. */
1415 /* Implement pseudo_register_reggroup_p tdesc method. */
1418 s390_pseudo_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
1419 struct reggroup *group)
1421 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1423 /* We usually save/restore the whole PSW, which includes PC and CC.
1424 However, some older gdbservers may not support saving/restoring
1425 the whole PSW yet, and will return an XML register description
1426 excluding those from the save/restore register groups. In those
1427 cases, we still need to explicitly save/restore PC and CC in order
1428 to push or pop frames. Since this doesn't hurt anything if we
1429 already save/restore the whole PSW (it's just redundant), we add
1430 PC and CC at this point unconditionally. */
1431 if (group == save_reggroup || group == restore_reggroup)
1432 return regnum == tdep->pc_regnum || regnum == tdep->cc_regnum;
1434 if (group == vector_reggroup)
1435 return regnum_is_vxr_full (tdep, regnum);
1437 if (group == general_reggroup && regnum_is_vxr_full (tdep, regnum))
1440 return default_register_reggroup_p (gdbarch, regnum, group);
1443 /* The "ax_pseudo_register_collect" gdbarch method. */
1446 s390_ax_pseudo_register_collect (struct gdbarch *gdbarch,
1447 struct agent_expr *ax, int regnum)
1449 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1450 if (regnum == tdep->pc_regnum)
1452 ax_reg_mask (ax, S390_PSWA_REGNUM);
1454 else if (regnum == tdep->cc_regnum)
1456 ax_reg_mask (ax, S390_PSWM_REGNUM);
1458 else if (regnum_is_gpr_full (tdep, regnum))
1460 regnum -= tdep->gpr_full_regnum;
1461 ax_reg_mask (ax, S390_R0_REGNUM + regnum);
1462 ax_reg_mask (ax, S390_R0_UPPER_REGNUM + regnum);
1464 else if (regnum_is_vxr_full (tdep, regnum))
1466 regnum -= tdep->v0_full_regnum;
1467 ax_reg_mask (ax, S390_F0_REGNUM + regnum);
1468 ax_reg_mask (ax, S390_V0_LOWER_REGNUM + regnum);
1472 internal_error (__FILE__, __LINE__, _("invalid regnum"));
1477 /* The "ax_pseudo_register_push_stack" gdbarch method. */
1480 s390_ax_pseudo_register_push_stack (struct gdbarch *gdbarch,
1481 struct agent_expr *ax, int regnum)
1483 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1484 if (regnum == tdep->pc_regnum)
1486 ax_reg (ax, S390_PSWA_REGNUM);
1487 if (register_size (gdbarch, S390_PSWA_REGNUM) == 4)
1489 ax_zero_ext (ax, 31);
1492 else if (regnum == tdep->cc_regnum)
1494 ax_reg (ax, S390_PSWM_REGNUM);
1495 if (register_size (gdbarch, S390_PSWA_REGNUM) == 4)
1496 ax_const_l (ax, 12);
1498 ax_const_l (ax, 44);
1499 ax_simple (ax, aop_rsh_unsigned);
1500 ax_zero_ext (ax, 2);
1502 else if (regnum_is_gpr_full (tdep, regnum))
1504 regnum -= tdep->gpr_full_regnum;
1505 ax_reg (ax, S390_R0_REGNUM + regnum);
1506 ax_reg (ax, S390_R0_UPPER_REGNUM + regnum);
1507 ax_const_l (ax, 32);
1508 ax_simple (ax, aop_lsh);
1509 ax_simple (ax, aop_bit_or);
1511 else if (regnum_is_vxr_full (tdep, regnum))
1513 /* Too large to stuff on the stack. */
1518 internal_error (__FILE__, __LINE__, _("invalid regnum"));
1523 /* The "gen_return_address" gdbarch method. Since this is supposed to be
1524 just a best-effort method, and we don't really have the means to run
1525 the full unwinder here, just collect the link register. */
1528 s390_gen_return_address (struct gdbarch *gdbarch,
1529 struct agent_expr *ax, struct axs_value *value,
1532 value->type = register_type (gdbarch, S390_R14_REGNUM);
1533 value->kind = axs_lvalue_register;
1534 value->u.reg = S390_R14_REGNUM;
1537 /* Address handling. */
1539 /* Implement addr_bits_remove gdbarch method.
1540 Only used for ABI_LINUX_S390. */
1543 s390_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr)
1545 return addr & 0x7fffffff;
1548 /* Implement addr_class_type_flags gdbarch method.
1549 Only used for ABI_LINUX_ZSERIES. */
1552 s390_address_class_type_flags (int byte_size, int dwarf2_addr_class)
1555 return TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1;
1560 /* Implement addr_class_type_flags_to_name gdbarch method.
1561 Only used for ABI_LINUX_ZSERIES. */
1564 s390_address_class_type_flags_to_name (struct gdbarch *gdbarch, int type_flags)
1566 if (type_flags & TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1)
1572 /* Implement addr_class_name_to_type_flags gdbarch method.
1573 Only used for ABI_LINUX_ZSERIES. */
1576 s390_address_class_name_to_type_flags (struct gdbarch *gdbarch,
1578 int *type_flags_ptr)
1580 if (strcmp (name, "mode32") == 0)
1582 *type_flags_ptr = TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1;
1589 /* Inferior function calls. */
1591 /* Dummy function calls. */
1593 /* Unwrap any single-field structs in TYPE and return the effective
1594 "inner" type. E.g., yield "float" for all these cases:
1598 struct { struct { float x; } x; };
1599 struct { struct { struct { float x; } x; } x; };
1601 However, if an inner type is smaller than MIN_SIZE, abort the
1604 static struct type *
1605 s390_effective_inner_type (struct type *type, unsigned int min_size)
1607 while (TYPE_CODE (type) == TYPE_CODE_STRUCT
1608 && TYPE_NFIELDS (type) == 1)
1610 struct type *inner = check_typedef (TYPE_FIELD_TYPE (type, 0));
1612 if (TYPE_LENGTH (inner) < min_size)
1620 /* Return non-zero if TYPE should be passed like "float" or
1624 s390_function_arg_float (struct type *type)
1626 /* Note that long double as well as complex types are intentionally
1628 if (TYPE_LENGTH (type) > 8)
1631 /* A struct containing just a float or double is passed like a float
1633 type = s390_effective_inner_type (type, 0);
1635 return (TYPE_CODE (type) == TYPE_CODE_FLT
1636 || TYPE_CODE (type) == TYPE_CODE_DECFLOAT);
1639 /* Return non-zero if TYPE should be passed like a vector. */
1642 s390_function_arg_vector (struct type *type)
1644 if (TYPE_LENGTH (type) > 16)
1647 /* Structs containing just a vector are passed like a vector. */
1648 type = s390_effective_inner_type (type, TYPE_LENGTH (type));
1650 return TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type);
1653 /* Determine whether N is a power of two. */
1656 is_power_of_two (unsigned int n)
1658 return n && ((n & (n - 1)) == 0);
1661 /* For an argument whose type is TYPE and which is not passed like a
1662 float or vector, return non-zero if it should be passed like "int"
1666 s390_function_arg_integer (struct type *type)
1668 enum type_code code = TYPE_CODE (type);
1670 if (TYPE_LENGTH (type) > 8)
1673 if (code == TYPE_CODE_INT
1674 || code == TYPE_CODE_ENUM
1675 || code == TYPE_CODE_RANGE
1676 || code == TYPE_CODE_CHAR
1677 || code == TYPE_CODE_BOOL
1678 || code == TYPE_CODE_PTR
1679 || TYPE_IS_REFERENCE (type))
1682 return ((code == TYPE_CODE_UNION || code == TYPE_CODE_STRUCT)
1683 && is_power_of_two (TYPE_LENGTH (type)));
1686 /* Argument passing state: Internal data structure passed to helper
1687 routines of s390_push_dummy_call. */
1689 struct s390_arg_state
1691 /* Register cache, or NULL, if we are in "preparation mode". */
1692 struct regcache *regcache;
1693 /* Next available general/floating-point/vector register for
1694 argument passing. */
1696 /* Current pointer to copy area (grows downwards). */
1698 /* Current pointer to parameter area (grows upwards). */
1702 /* Prepare one argument ARG for a dummy call and update the argument
1703 passing state AS accordingly. If the regcache field in AS is set,
1704 operate in "write mode" and write ARG into the inferior. Otherwise
1705 run "preparation mode" and skip all updates to the inferior. */
1708 s390_handle_arg (struct s390_arg_state *as, struct value *arg,
1709 struct gdbarch_tdep *tdep, int word_size,
1710 enum bfd_endian byte_order, int is_unnamed)
1712 struct type *type = check_typedef (value_type (arg));
1713 unsigned int length = TYPE_LENGTH (type);
1714 int write_mode = as->regcache != NULL;
1716 if (s390_function_arg_float (type))
1718 /* The GNU/Linux for S/390 ABI uses FPRs 0 and 2 to pass
1719 arguments. The GNU/Linux for zSeries ABI uses 0, 2, 4, and
1721 if (as->fr <= (tdep->abi == ABI_LINUX_S390 ? 2 : 6))
1723 /* When we store a single-precision value in an FP register,
1724 it occupies the leftmost bits. */
1726 regcache_cooked_write_part (as->regcache,
1727 S390_F0_REGNUM + as->fr,
1729 value_contents (arg));
1734 /* When we store a single-precision value in a stack slot,
1735 it occupies the rightmost bits. */
1736 as->argp = align_up (as->argp + length, word_size);
1738 write_memory (as->argp - length, value_contents (arg),
1742 else if (tdep->vector_abi == S390_VECTOR_ABI_128
1743 && s390_function_arg_vector (type))
1745 static const char use_vr[] = {24, 26, 28, 30, 25, 27, 29, 31};
1747 if (!is_unnamed && as->vr < ARRAY_SIZE (use_vr))
1749 int regnum = S390_V24_REGNUM + use_vr[as->vr] - 24;
1752 regcache_cooked_write_part (as->regcache, regnum,
1754 value_contents (arg));
1760 write_memory (as->argp, value_contents (arg), length);
1761 as->argp = align_up (as->argp + length, word_size);
1764 else if (s390_function_arg_integer (type) && length <= word_size)
1766 /* Initialize it just to avoid a GCC false warning. */
1771 /* Place value in least significant bits of the register or
1772 memory word and sign- or zero-extend to full word size.
1773 This also applies to a struct or union. */
1774 val = TYPE_UNSIGNED (type)
1775 ? extract_unsigned_integer (value_contents (arg),
1777 : extract_signed_integer (value_contents (arg),
1778 length, byte_order);
1784 regcache_cooked_write_unsigned (as->regcache,
1785 S390_R0_REGNUM + as->gr,
1792 write_memory_unsigned_integer (as->argp, word_size,
1794 as->argp += word_size;
1797 else if (s390_function_arg_integer (type) && length == 8)
1803 regcache_cooked_write (as->regcache,
1804 S390_R0_REGNUM + as->gr,
1805 value_contents (arg));
1806 regcache_cooked_write (as->regcache,
1807 S390_R0_REGNUM + as->gr + 1,
1808 value_contents (arg) + word_size);
1814 /* If we skipped r6 because we couldn't fit a DOUBLE_ARG
1815 in it, then don't go back and use it again later. */
1819 write_memory (as->argp, value_contents (arg), length);
1825 /* This argument type is never passed in registers. Place the
1826 value in the copy area and pass a pointer to it. Use 8-byte
1827 alignment as a conservative assumption. */
1828 as->copy = align_down (as->copy - length, 8);
1830 write_memory (as->copy, value_contents (arg), length);
1835 regcache_cooked_write_unsigned (as->regcache,
1836 S390_R0_REGNUM + as->gr,
1843 write_memory_unsigned_integer (as->argp, word_size,
1844 byte_order, as->copy);
1845 as->argp += word_size;
1850 /* Put the actual parameter values pointed to by ARGS[0..NARGS-1] in
1851 place to be passed to a function, as specified by the "GNU/Linux
1852 for S/390 ELF Application Binary Interface Supplement".
1854 SP is the current stack pointer. We must put arguments, links,
1855 padding, etc. whereever they belong, and return the new stack
1858 If STRUCT_RETURN is non-zero, then the function we're calling is
1859 going to return a structure by value; STRUCT_ADDR is the address of
1860 a block we've allocated for it on the stack.
1862 Our caller has taken care of any type promotions needed to satisfy
1863 prototypes or the old K&R argument-passing rules. */
1866 s390_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
1867 struct regcache *regcache, CORE_ADDR bp_addr,
1868 int nargs, struct value **args, CORE_ADDR sp,
1869 int struct_return, CORE_ADDR struct_addr)
1871 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1872 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1873 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1875 struct s390_arg_state arg_state, arg_prep;
1876 CORE_ADDR param_area_start, new_sp;
1877 struct type *ftype = check_typedef (value_type (function));
1879 if (TYPE_CODE (ftype) == TYPE_CODE_PTR)
1880 ftype = check_typedef (TYPE_TARGET_TYPE (ftype));
1883 arg_prep.gr = struct_return ? 3 : 2;
1887 arg_prep.regcache = NULL;
1889 /* Initialize arg_state for "preparation mode". */
1890 arg_state = arg_prep;
1892 /* Update arg_state.copy with the start of the reference-to-copy area
1893 and arg_state.argp with the size of the parameter area. */
1894 for (i = 0; i < nargs; i++)
1895 s390_handle_arg (&arg_state, args[i], tdep, word_size, byte_order,
1896 TYPE_VARARGS (ftype) && i >= TYPE_NFIELDS (ftype));
1898 param_area_start = align_down (arg_state.copy - arg_state.argp, 8);
1900 /* Allocate the standard frame areas: the register save area, the
1901 word reserved for the compiler, and the back chain pointer. */
1902 new_sp = param_area_start - (16 * word_size + 32);
1904 /* Now we have the final stack pointer. Make sure we didn't
1905 underflow; on 31-bit, this would result in addresses with the
1906 high bit set, which causes confusion elsewhere. Note that if we
1907 error out here, stack and registers remain untouched. */
1908 if (gdbarch_addr_bits_remove (gdbarch, new_sp) != new_sp)
1909 error (_("Stack overflow"));
1911 /* Pass the structure return address in general register 2. */
1913 regcache_cooked_write_unsigned (regcache, S390_R2_REGNUM, struct_addr);
1915 /* Initialize arg_state for "write mode". */
1916 arg_state = arg_prep;
1917 arg_state.argp = param_area_start;
1918 arg_state.regcache = regcache;
1920 /* Write all parameters. */
1921 for (i = 0; i < nargs; i++)
1922 s390_handle_arg (&arg_state, args[i], tdep, word_size, byte_order,
1923 TYPE_VARARGS (ftype) && i >= TYPE_NFIELDS (ftype));
1925 /* Store return PSWA. In 31-bit mode, keep addressing mode bit. */
1929 regcache_cooked_read_unsigned (regcache, S390_PSWA_REGNUM, &pswa);
1930 bp_addr = (bp_addr & 0x7fffffff) | (pswa & 0x80000000);
1932 regcache_cooked_write_unsigned (regcache, S390_RETADDR_REGNUM, bp_addr);
1934 /* Store updated stack pointer. */
1935 regcache_cooked_write_unsigned (regcache, S390_SP_REGNUM, new_sp);
1937 /* We need to return the 'stack part' of the frame ID,
1938 which is actually the top of the register save area. */
1939 return param_area_start;
1942 /* Assuming THIS_FRAME is a dummy, return the frame ID of that
1943 dummy frame. The frame ID's base needs to match the TOS value
1944 returned by push_dummy_call, and the PC match the dummy frame's
1947 static struct frame_id
1948 s390_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
1950 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1951 CORE_ADDR sp = get_frame_register_unsigned (this_frame, S390_SP_REGNUM);
1952 sp = gdbarch_addr_bits_remove (gdbarch, sp);
1954 return frame_id_build (sp + 16*word_size + 32,
1955 get_frame_pc (this_frame));
1958 /* Implement frame_align gdbarch method. */
1961 s390_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
1963 /* Both the 32- and 64-bit ABI's say that the stack pointer should
1964 always be aligned on an eight-byte boundary. */
1968 /* Helper for s390_return_value: Set or retrieve a function return
1969 value if it resides in a register. */
1972 s390_register_return_value (struct gdbarch *gdbarch, struct type *type,
1973 struct regcache *regcache,
1974 gdb_byte *out, const gdb_byte *in)
1976 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1977 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1978 int length = TYPE_LENGTH (type);
1979 int code = TYPE_CODE (type);
1981 if (code == TYPE_CODE_FLT || code == TYPE_CODE_DECFLOAT)
1983 /* Float-like value: left-aligned in f0. */
1985 regcache_cooked_write_part (regcache, S390_F0_REGNUM,
1988 regcache_cooked_read_part (regcache, S390_F0_REGNUM,
1991 else if (code == TYPE_CODE_ARRAY)
1993 /* Vector: left-aligned in v24. */
1995 regcache_cooked_write_part (regcache, S390_V24_REGNUM,
1998 regcache_cooked_read_part (regcache, S390_V24_REGNUM,
2001 else if (length <= word_size)
2003 /* Integer: zero- or sign-extended in r2. */
2005 regcache_cooked_read_part (regcache, S390_R2_REGNUM,
2006 word_size - length, length, out);
2007 else if (TYPE_UNSIGNED (type))
2008 regcache_cooked_write_unsigned
2009 (regcache, S390_R2_REGNUM,
2010 extract_unsigned_integer (in, length, byte_order));
2012 regcache_cooked_write_signed
2013 (regcache, S390_R2_REGNUM,
2014 extract_signed_integer (in, length, byte_order));
2016 else if (length == 2 * word_size)
2018 /* Double word: in r2 and r3. */
2021 regcache_cooked_write (regcache, S390_R2_REGNUM, in);
2022 regcache_cooked_write (regcache, S390_R3_REGNUM,
2027 regcache_cooked_read (regcache, S390_R2_REGNUM, out);
2028 regcache_cooked_read (regcache, S390_R3_REGNUM,
2033 internal_error (__FILE__, __LINE__, _("invalid return type"));
2036 /* Implement the 'return_value' gdbarch method. */
2038 static enum return_value_convention
2039 s390_return_value (struct gdbarch *gdbarch, struct value *function,
2040 struct type *type, struct regcache *regcache,
2041 gdb_byte *out, const gdb_byte *in)
2043 enum return_value_convention rvc;
2045 type = check_typedef (type);
2047 switch (TYPE_CODE (type))
2049 case TYPE_CODE_STRUCT:
2050 case TYPE_CODE_UNION:
2051 case TYPE_CODE_COMPLEX:
2052 rvc = RETURN_VALUE_STRUCT_CONVENTION;
2054 case TYPE_CODE_ARRAY:
2055 rvc = (gdbarch_tdep (gdbarch)->vector_abi == S390_VECTOR_ABI_128
2056 && TYPE_LENGTH (type) <= 16 && TYPE_VECTOR (type))
2057 ? RETURN_VALUE_REGISTER_CONVENTION
2058 : RETURN_VALUE_STRUCT_CONVENTION;
2061 rvc = TYPE_LENGTH (type) <= 8
2062 ? RETURN_VALUE_REGISTER_CONVENTION
2063 : RETURN_VALUE_STRUCT_CONVENTION;
2066 if (in != NULL || out != NULL)
2068 if (rvc == RETURN_VALUE_REGISTER_CONVENTION)
2069 s390_register_return_value (gdbarch, type, regcache, out, in);
2070 else if (in != NULL)
2071 error (_("Cannot set function return value."));
2073 error (_("Function return value unknown."));
2079 /* Frame unwinding. */
2081 /* Implmement the stack_frame_destroyed_p gdbarch method. */
2084 s390_stack_frame_destroyed_p (struct gdbarch *gdbarch, CORE_ADDR pc)
2086 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
2088 /* In frameless functions, there's no frame to destroy and thus
2089 we don't care about the epilogue.
2091 In functions with frame, the epilogue sequence is a pair of
2092 a LM-type instruction that restores (amongst others) the
2093 return register %r14 and the stack pointer %r15, followed
2094 by a branch 'br %r14' --or equivalent-- that effects the
2097 In that situation, this function needs to return 'true' in
2098 exactly one case: when pc points to that branch instruction.
2100 Thus we try to disassemble the one instructions immediately
2101 preceding pc and check whether it is an LM-type instruction
2102 modifying the stack pointer.
2104 Note that disassembling backwards is not reliable, so there
2105 is a slight chance of false positives here ... */
2108 unsigned int r1, r3, b2;
2112 && !target_read_memory (pc - 4, insn, 4)
2113 && is_rs (insn, op_lm, &r1, &r3, &d2, &b2)
2114 && r3 == S390_SP_REGNUM - S390_R0_REGNUM)
2118 && !target_read_memory (pc - 6, insn, 6)
2119 && is_rsy (insn, op1_lmy, op2_lmy, &r1, &r3, &d2, &b2)
2120 && r3 == S390_SP_REGNUM - S390_R0_REGNUM)
2124 && !target_read_memory (pc - 6, insn, 6)
2125 && is_rsy (insn, op1_lmg, op2_lmg, &r1, &r3, &d2, &b2)
2126 && r3 == S390_SP_REGNUM - S390_R0_REGNUM)
2132 /* Implement unwind_pc gdbarch method. */
2135 s390_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
2137 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2139 pc = frame_unwind_register_unsigned (next_frame, tdep->pc_regnum);
2140 return gdbarch_addr_bits_remove (gdbarch, pc);
2143 /* Implement unwind_sp gdbarch method. */
2146 s390_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
2149 sp = frame_unwind_register_unsigned (next_frame, S390_SP_REGNUM);
2150 return gdbarch_addr_bits_remove (gdbarch, sp);
2153 /* Helper routine to unwind pseudo registers. */
2155 static struct value *
2156 s390_unwind_pseudo_register (struct frame_info *this_frame, int regnum)
2158 struct gdbarch *gdbarch = get_frame_arch (this_frame);
2159 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2160 struct type *type = register_type (gdbarch, regnum);
2162 /* Unwind PC via PSW address. */
2163 if (regnum == tdep->pc_regnum)
2167 val = frame_unwind_register_value (this_frame, S390_PSWA_REGNUM);
2168 if (!value_optimized_out (val))
2170 LONGEST pswa = value_as_long (val);
2172 if (TYPE_LENGTH (type) == 4)
2173 return value_from_pointer (type, pswa & 0x7fffffff);
2175 return value_from_pointer (type, pswa);
2179 /* Unwind CC via PSW mask. */
2180 if (regnum == tdep->cc_regnum)
2184 val = frame_unwind_register_value (this_frame, S390_PSWM_REGNUM);
2185 if (!value_optimized_out (val))
2187 LONGEST pswm = value_as_long (val);
2189 if (TYPE_LENGTH (type) == 4)
2190 return value_from_longest (type, (pswm >> 12) & 3);
2192 return value_from_longest (type, (pswm >> 44) & 3);
2196 /* Unwind full GPRs to show at least the lower halves (as the
2197 upper halves are undefined). */
2198 if (regnum_is_gpr_full (tdep, regnum))
2200 int reg = regnum - tdep->gpr_full_regnum;
2203 val = frame_unwind_register_value (this_frame, S390_R0_REGNUM + reg);
2204 if (!value_optimized_out (val))
2205 return value_cast (type, val);
2208 return allocate_optimized_out_value (type);
2211 /* Translate a .eh_frame register to DWARF register, or adjust a
2212 .debug_frame register. */
2215 s390_adjust_frame_regnum (struct gdbarch *gdbarch, int num, int eh_frame_p)
2217 /* See s390_dwarf_reg_to_regnum for comments. */
2218 return (num >= 0 && num < 16) ? num + s390_dwarf_reg_r0l : num;
2221 /* DWARF-2 frame unwinding. */
2223 /* Function to unwind a pseudo-register in dwarf2_frame unwinder. Used by
2224 s390_dwarf2_frame_init_reg. */
2226 static struct value *
2227 s390_dwarf2_prev_register (struct frame_info *this_frame, void **this_cache,
2230 return s390_unwind_pseudo_register (this_frame, regnum);
2233 /* Implement init_reg dwarf2_frame method. */
2236 s390_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
2237 struct dwarf2_frame_state_reg *reg,
2238 struct frame_info *this_frame)
2240 /* The condition code (and thus PSW mask) is call-clobbered. */
2241 if (regnum == S390_PSWM_REGNUM)
2242 reg->how = DWARF2_FRAME_REG_UNDEFINED;
2244 /* The PSW address unwinds to the return address. */
2245 else if (regnum == S390_PSWA_REGNUM)
2246 reg->how = DWARF2_FRAME_REG_RA;
2248 /* Fixed registers are call-saved or call-clobbered
2249 depending on the ABI in use. */
2250 else if (regnum < S390_NUM_REGS)
2252 if (s390_register_call_saved (gdbarch, regnum))
2253 reg->how = DWARF2_FRAME_REG_SAME_VALUE;
2255 reg->how = DWARF2_FRAME_REG_UNDEFINED;
2258 /* We install a special function to unwind pseudos. */
2261 reg->how = DWARF2_FRAME_REG_FN;
2262 reg->loc.fn = s390_dwarf2_prev_register;
2266 /* Frame unwinding. */
2268 /* Wrapper for trad_frame_get_prev_register to allow for s390 pseudo
2269 register translation. */
2272 s390_trad_frame_prev_register (struct frame_info *this_frame,
2273 struct trad_frame_saved_reg saved_regs[],
2276 if (regnum < S390_NUM_REGS)
2277 return trad_frame_get_prev_register (this_frame, saved_regs, regnum);
2279 return s390_unwind_pseudo_register (this_frame, regnum);
2282 /* Normal stack frames. */
2284 struct s390_unwind_cache {
2287 CORE_ADDR frame_base;
2288 CORE_ADDR local_base;
2290 struct trad_frame_saved_reg *saved_regs;
2293 /* Unwind THIS_FRAME and write the information into unwind cache INFO using
2294 prologue analysis. Helper for s390_frame_unwind_cache. */
2297 s390_prologue_frame_unwind_cache (struct frame_info *this_frame,
2298 struct s390_unwind_cache *info)
2300 struct gdbarch *gdbarch = get_frame_arch (this_frame);
2301 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
2302 struct s390_prologue_data data;
2303 pv_t *fp = &data.gpr[S390_FRAME_REGNUM - S390_R0_REGNUM];
2304 pv_t *sp = &data.gpr[S390_SP_REGNUM - S390_R0_REGNUM];
2313 struct frame_info *next_frame;
2315 /* Try to find the function start address. If we can't find it, we don't
2316 bother searching for it -- with modern compilers this would be mostly
2317 pointless anyway. Trust that we'll either have valid DWARF-2 CFI data
2318 or else a valid backchain ... */
2319 if (!get_frame_func_if_available (this_frame, &info->func))
2326 /* Try to analyze the prologue. */
2327 result = s390_analyze_prologue (gdbarch, func,
2328 get_frame_pc (this_frame), &data);
2332 /* If this was successful, we should have found the instruction that
2333 sets the stack pointer register to the previous value of the stack
2334 pointer minus the frame size. */
2335 if (!pv_is_register (*sp, S390_SP_REGNUM))
2338 /* A frame size of zero at this point can mean either a real
2339 frameless function, or else a failure to find the prologue.
2340 Perform some sanity checks to verify we really have a
2341 frameless function. */
2344 /* If the next frame is a NORMAL_FRAME, this frame *cannot* have frame
2345 size zero. This is only possible if the next frame is a sentinel
2346 frame, a dummy frame, or a signal trampoline frame. */
2347 /* FIXME: cagney/2004-05-01: This sanity check shouldn't be
2348 needed, instead the code should simpliy rely on its
2350 next_frame = get_next_frame (this_frame);
2351 while (next_frame && get_frame_type (next_frame) == INLINE_FRAME)
2352 next_frame = get_next_frame (next_frame);
2354 && get_frame_type (get_next_frame (this_frame)) == NORMAL_FRAME)
2357 /* If we really have a frameless function, %r14 must be valid
2358 -- in particular, it must point to a different function. */
2359 reg = get_frame_register_unsigned (this_frame, S390_RETADDR_REGNUM);
2360 reg = gdbarch_addr_bits_remove (gdbarch, reg) - 1;
2361 if (get_pc_function_start (reg) == func)
2363 /* However, there is one case where it *is* valid for %r14
2364 to point to the same function -- if this is a recursive
2365 call, and we have stopped in the prologue *before* the
2366 stack frame was allocated.
2368 Recognize this case by looking ahead a bit ... */
2370 struct s390_prologue_data data2;
2371 pv_t *sp = &data2.gpr[S390_SP_REGNUM - S390_R0_REGNUM];
2373 if (!(s390_analyze_prologue (gdbarch, func, (CORE_ADDR)-1, &data2)
2374 && pv_is_register (*sp, S390_SP_REGNUM)
2380 /* OK, we've found valid prologue data. */
2383 /* If the frame pointer originally also holds the same value
2384 as the stack pointer, we're probably using it. If it holds
2385 some other value -- even a constant offset -- it is most
2386 likely used as temp register. */
2387 if (pv_is_identical (*sp, *fp))
2388 frame_pointer = S390_FRAME_REGNUM;
2390 frame_pointer = S390_SP_REGNUM;
2392 /* If we've detected a function with stack frame, we'll still have to
2393 treat it as frameless if we're currently within the function epilog
2394 code at a point where the frame pointer has already been restored.
2395 This can only happen in an innermost frame. */
2396 /* FIXME: cagney/2004-05-01: This sanity check shouldn't be needed,
2397 instead the code should simpliy rely on its analysis. */
2398 next_frame = get_next_frame (this_frame);
2399 while (next_frame && get_frame_type (next_frame) == INLINE_FRAME)
2400 next_frame = get_next_frame (next_frame);
2402 && (next_frame == NULL
2403 || get_frame_type (get_next_frame (this_frame)) != NORMAL_FRAME))
2405 /* See the comment in s390_stack_frame_destroyed_p on why this is
2406 not completely reliable ... */
2407 if (s390_stack_frame_destroyed_p (gdbarch, get_frame_pc (this_frame)))
2409 memset (&data, 0, sizeof (data));
2411 frame_pointer = S390_SP_REGNUM;
2415 /* Once we know the frame register and the frame size, we can unwind
2416 the current value of the frame register from the next frame, and
2417 add back the frame size to arrive that the previous frame's
2418 stack pointer value. */
2419 prev_sp = get_frame_register_unsigned (this_frame, frame_pointer) + size;
2420 cfa = prev_sp + 16*word_size + 32;
2422 /* Set up ABI call-saved/call-clobbered registers. */
2423 for (i = 0; i < S390_NUM_REGS; i++)
2424 if (!s390_register_call_saved (gdbarch, i))
2425 trad_frame_set_unknown (info->saved_regs, i);
2427 /* CC is always call-clobbered. */
2428 trad_frame_set_unknown (info->saved_regs, S390_PSWM_REGNUM);
2430 /* Record the addresses of all register spill slots the prologue parser
2431 has recognized. Consider only registers defined as call-saved by the
2432 ABI; for call-clobbered registers the parser may have recognized
2435 for (i = 0; i < 16; i++)
2436 if (s390_register_call_saved (gdbarch, S390_R0_REGNUM + i)
2437 && data.gpr_slot[i] != 0)
2438 info->saved_regs[S390_R0_REGNUM + i].addr = cfa - data.gpr_slot[i];
2440 for (i = 0; i < 16; i++)
2441 if (s390_register_call_saved (gdbarch, S390_F0_REGNUM + i)
2442 && data.fpr_slot[i] != 0)
2443 info->saved_regs[S390_F0_REGNUM + i].addr = cfa - data.fpr_slot[i];
2445 /* Function return will set PC to %r14. */
2446 info->saved_regs[S390_PSWA_REGNUM] = info->saved_regs[S390_RETADDR_REGNUM];
2448 /* In frameless functions, we unwind simply by moving the return
2449 address to the PC. However, if we actually stored to the
2450 save area, use that -- we might only think the function frameless
2451 because we're in the middle of the prologue ... */
2453 && !trad_frame_addr_p (info->saved_regs, S390_PSWA_REGNUM))
2455 info->saved_regs[S390_PSWA_REGNUM].realreg = S390_RETADDR_REGNUM;
2458 /* Another sanity check: unless this is a frameless function,
2459 we should have found spill slots for SP and PC.
2460 If not, we cannot unwind further -- this happens e.g. in
2461 libc's thread_start routine. */
2464 if (!trad_frame_addr_p (info->saved_regs, S390_SP_REGNUM)
2465 || !trad_frame_addr_p (info->saved_regs, S390_PSWA_REGNUM))
2469 /* We use the current value of the frame register as local_base,
2470 and the top of the register save area as frame_base. */
2473 info->frame_base = prev_sp + 16*word_size + 32;
2474 info->local_base = prev_sp - size;
2480 /* Unwind THIS_FRAME and write the information into unwind cache INFO using
2481 back chain unwinding. Helper for s390_frame_unwind_cache. */
2484 s390_backchain_frame_unwind_cache (struct frame_info *this_frame,
2485 struct s390_unwind_cache *info)
2487 struct gdbarch *gdbarch = get_frame_arch (this_frame);
2488 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
2489 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2490 CORE_ADDR backchain;
2495 /* Set up ABI call-saved/call-clobbered registers. */
2496 for (i = 0; i < S390_NUM_REGS; i++)
2497 if (!s390_register_call_saved (gdbarch, i))
2498 trad_frame_set_unknown (info->saved_regs, i);
2500 /* CC is always call-clobbered. */
2501 trad_frame_set_unknown (info->saved_regs, S390_PSWM_REGNUM);
2503 /* Get the backchain. */
2504 reg = get_frame_register_unsigned (this_frame, S390_SP_REGNUM);
2505 if (!safe_read_memory_integer (reg, word_size, byte_order, &tmp))
2507 backchain = (CORE_ADDR) tmp;
2509 /* A zero backchain terminates the frame chain. As additional
2510 sanity check, let's verify that the spill slot for SP in the
2511 save area pointed to by the backchain in fact links back to
2514 && safe_read_memory_integer (backchain + 15*word_size,
2515 word_size, byte_order, &sp)
2516 && (CORE_ADDR)sp == backchain)
2518 /* We don't know which registers were saved, but it will have
2519 to be at least %r14 and %r15. This will allow us to continue
2520 unwinding, but other prev-frame registers may be incorrect ... */
2521 info->saved_regs[S390_SP_REGNUM].addr = backchain + 15*word_size;
2522 info->saved_regs[S390_RETADDR_REGNUM].addr = backchain + 14*word_size;
2524 /* Function return will set PC to %r14. */
2525 info->saved_regs[S390_PSWA_REGNUM]
2526 = info->saved_regs[S390_RETADDR_REGNUM];
2528 /* We use the current value of the frame register as local_base,
2529 and the top of the register save area as frame_base. */
2530 info->frame_base = backchain + 16*word_size + 32;
2531 info->local_base = reg;
2534 info->func = get_frame_pc (this_frame);
2537 /* Unwind THIS_FRAME and return the corresponding unwind cache for
2538 s390_frame_unwind and s390_frame_base. */
2540 static struct s390_unwind_cache *
2541 s390_frame_unwind_cache (struct frame_info *this_frame,
2542 void **this_prologue_cache)
2544 struct s390_unwind_cache *info;
2546 if (*this_prologue_cache)
2547 return (struct s390_unwind_cache *) *this_prologue_cache;
2549 info = FRAME_OBSTACK_ZALLOC (struct s390_unwind_cache);
2550 *this_prologue_cache = info;
2551 info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
2553 info->frame_base = -1;
2554 info->local_base = -1;
2558 /* Try to use prologue analysis to fill the unwind cache.
2559 If this fails, fall back to reading the stack backchain. */
2560 if (!s390_prologue_frame_unwind_cache (this_frame, info))
2561 s390_backchain_frame_unwind_cache (this_frame, info);
2563 CATCH (ex, RETURN_MASK_ERROR)
2565 if (ex.error != NOT_AVAILABLE_ERROR)
2566 throw_exception (ex);
2573 /* Implement this_id frame_unwind method for s390_frame_unwind. */
2576 s390_frame_this_id (struct frame_info *this_frame,
2577 void **this_prologue_cache,
2578 struct frame_id *this_id)
2580 struct s390_unwind_cache *info
2581 = s390_frame_unwind_cache (this_frame, this_prologue_cache);
2583 if (info->frame_base == -1)
2585 if (info->func != -1)
2586 *this_id = frame_id_build_unavailable_stack (info->func);
2590 *this_id = frame_id_build (info->frame_base, info->func);
2593 /* Implement prev_register frame_unwind method for s390_frame_unwind. */
2595 static struct value *
2596 s390_frame_prev_register (struct frame_info *this_frame,
2597 void **this_prologue_cache, int regnum)
2599 struct s390_unwind_cache *info
2600 = s390_frame_unwind_cache (this_frame, this_prologue_cache);
2602 return s390_trad_frame_prev_register (this_frame, info->saved_regs, regnum);
2605 /* Default S390 frame unwinder. */
2607 static const struct frame_unwind s390_frame_unwind = {
2609 default_frame_unwind_stop_reason,
2611 s390_frame_prev_register,
2613 default_frame_sniffer
2616 /* Code stubs and their stack frames. For things like PLTs and NULL
2617 function calls (where there is no true frame and the return address
2618 is in the RETADDR register). */
2620 struct s390_stub_unwind_cache
2622 CORE_ADDR frame_base;
2623 struct trad_frame_saved_reg *saved_regs;
2626 /* Unwind THIS_FRAME and return the corresponding unwind cache for
2627 s390_stub_frame_unwind. */
2629 static struct s390_stub_unwind_cache *
2630 s390_stub_frame_unwind_cache (struct frame_info *this_frame,
2631 void **this_prologue_cache)
2633 struct gdbarch *gdbarch = get_frame_arch (this_frame);
2634 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
2635 struct s390_stub_unwind_cache *info;
2638 if (*this_prologue_cache)
2639 return (struct s390_stub_unwind_cache *) *this_prologue_cache;
2641 info = FRAME_OBSTACK_ZALLOC (struct s390_stub_unwind_cache);
2642 *this_prologue_cache = info;
2643 info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
2645 /* The return address is in register %r14. */
2646 info->saved_regs[S390_PSWA_REGNUM].realreg = S390_RETADDR_REGNUM;
2648 /* Retrieve stack pointer and determine our frame base. */
2649 reg = get_frame_register_unsigned (this_frame, S390_SP_REGNUM);
2650 info->frame_base = reg + 16*word_size + 32;
2655 /* Implement this_id frame_unwind method for s390_stub_frame_unwind. */
2658 s390_stub_frame_this_id (struct frame_info *this_frame,
2659 void **this_prologue_cache,
2660 struct frame_id *this_id)
2662 struct s390_stub_unwind_cache *info
2663 = s390_stub_frame_unwind_cache (this_frame, this_prologue_cache);
2664 *this_id = frame_id_build (info->frame_base, get_frame_pc (this_frame));
2667 /* Implement prev_register frame_unwind method for s390_stub_frame_unwind. */
2669 static struct value *
2670 s390_stub_frame_prev_register (struct frame_info *this_frame,
2671 void **this_prologue_cache, int regnum)
2673 struct s390_stub_unwind_cache *info
2674 = s390_stub_frame_unwind_cache (this_frame, this_prologue_cache);
2675 return s390_trad_frame_prev_register (this_frame, info->saved_regs, regnum);
2678 /* Implement sniffer frame_unwind method for s390_stub_frame_unwind. */
2681 s390_stub_frame_sniffer (const struct frame_unwind *self,
2682 struct frame_info *this_frame,
2683 void **this_prologue_cache)
2685 CORE_ADDR addr_in_block;
2686 bfd_byte insn[S390_MAX_INSTR_SIZE];
2688 /* If the current PC points to non-readable memory, we assume we
2689 have trapped due to an invalid function pointer call. We handle
2690 the non-existing current function like a PLT stub. */
2691 addr_in_block = get_frame_address_in_block (this_frame);
2692 if (in_plt_section (addr_in_block)
2693 || s390_readinstruction (insn, get_frame_pc (this_frame)) < 0)
2698 /* S390 stub frame unwinder. */
2700 static const struct frame_unwind s390_stub_frame_unwind = {
2702 default_frame_unwind_stop_reason,
2703 s390_stub_frame_this_id,
2704 s390_stub_frame_prev_register,
2706 s390_stub_frame_sniffer
2709 /* Frame base handling. */
2712 s390_frame_base_address (struct frame_info *this_frame, void **this_cache)
2714 struct s390_unwind_cache *info
2715 = s390_frame_unwind_cache (this_frame, this_cache);
2716 return info->frame_base;
2720 s390_local_base_address (struct frame_info *this_frame, void **this_cache)
2722 struct s390_unwind_cache *info
2723 = s390_frame_unwind_cache (this_frame, this_cache);
2724 return info->local_base;
2727 static const struct frame_base s390_frame_base = {
2729 s390_frame_base_address,
2730 s390_local_base_address,
2731 s390_local_base_address
2734 /* Process record-replay */
2736 /* Takes the intermediate sum of address calculations and masks off upper
2737 bits according to current addressing mode. */
2740 s390_record_address_mask (struct gdbarch *gdbarch, struct regcache *regcache,
2743 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2744 ULONGEST pswm, pswa;
2746 if (tdep->abi == ABI_LINUX_S390)
2748 regcache_raw_read_unsigned (regcache, S390_PSWA_REGNUM, &pswa);
2749 am = pswa >> 31 & 1;
2753 regcache_raw_read_unsigned (regcache, S390_PSWM_REGNUM, &pswm);
2754 am = pswm >> 31 & 3;
2759 return val & 0xffffff;
2761 return val & 0x7fffffff;
2765 fprintf_unfiltered (gdb_stdlog, "Warning: Addressing mode %d used.", am);
2770 /* Calculates memory address using pre-calculated index, raw instruction word
2771 with b and d/dl fields, and raw instruction byte with dh field. Index and
2772 dh should be set to 0 if unused. */
2775 s390_record_calc_disp_common (struct gdbarch *gdbarch, struct regcache *regcache,
2776 ULONGEST x, uint16_t bd, int8_t dh)
2778 uint8_t rb = bd >> 12 & 0xf;
2779 int32_t d = (bd & 0xfff) | ((int32_t)dh << 12);
2781 CORE_ADDR res = d + x;
2784 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + rb, &b);
2787 return s390_record_address_mask (gdbarch, regcache, res);
2790 /* Calculates memory address using raw x, b + d/dl, dh fields from
2791 instruction. rx and dh should be set to 0 if unused. */
2794 s390_record_calc_disp (struct gdbarch *gdbarch, struct regcache *regcache,
2795 uint8_t rx, uint16_t bd, int8_t dh)
2799 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + rx, &x);
2800 return s390_record_calc_disp_common (gdbarch, regcache, x, bd, dh);
2803 /* Calculates memory address for VSCE[GF] instructions. */
2806 s390_record_calc_disp_vsce (struct gdbarch *gdbarch, struct regcache *regcache,
2807 uint8_t vx, uint8_t el, uint8_t es, uint16_t bd,
2808 int8_t dh, CORE_ADDR *res)
2810 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2811 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2814 if (tdep->v0_full_regnum == -1 || el * es >= 16)
2817 regcache_cooked_read (regcache, tdep->v0_full_regnum + vx, buf);
2819 regcache_raw_read (regcache, S390_V16_REGNUM + vx - 16, buf);
2820 x = extract_unsigned_integer (buf + el * es, es, byte_order);
2821 *res = s390_record_calc_disp_common (gdbarch, regcache, x, bd, dh);
2825 /* Calculates memory address for instructions with relative long addressing. */
2828 s390_record_calc_rl (struct gdbarch *gdbarch, struct regcache *regcache,
2829 CORE_ADDR addr, uint16_t i1, uint16_t i2)
2831 int32_t ri = i1 << 16 | i2;
2832 return s390_record_address_mask (gdbarch, regcache, addr + (LONGEST)ri * 2);
2835 /* Population count helper. */
2837 static int s390_popcnt (unsigned int x) {
2848 /* Record 64-bit register. */
2851 s390_record_gpr_g (struct gdbarch *gdbarch, struct regcache *regcache, int i)
2853 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2854 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + i))
2856 if (tdep->abi == ABI_LINUX_S390)
2857 if (record_full_arch_list_add_reg (regcache, S390_R0_UPPER_REGNUM + i))
2862 /* Record high 32 bits of a register. */
2865 s390_record_gpr_h (struct gdbarch *gdbarch, struct regcache *regcache, int i)
2867 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2868 if (tdep->abi == ABI_LINUX_S390)
2870 if (record_full_arch_list_add_reg (regcache, S390_R0_UPPER_REGNUM + i))
2875 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + i))
2881 /* Record vector register. */
2884 s390_record_vr (struct gdbarch *gdbarch, struct regcache *regcache, int i)
2888 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + i))
2890 if (record_full_arch_list_add_reg (regcache, S390_V0_LOWER_REGNUM + i))
2895 if (record_full_arch_list_add_reg (regcache, S390_V16_REGNUM + i - 16))
2901 /* Implement process_record gdbarch method. */
2904 s390_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
2907 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2908 uint16_t insn[3] = {0};
2909 /* Instruction as bytes. */
2911 /* Instruction as nibbles. */
2913 /* Instruction vector registers. */
2915 CORE_ADDR oaddr, oaddr2, oaddr3;
2918 /* if EX/EXRL instruction used, here's the reg parameter */
2920 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2922 /* Attempting to use EX or EXRL jumps back here */
2925 /* Read instruction. */
2926 insn[0] = read_memory_unsigned_integer (addr, 2, byte_order);
2927 /* If execute was involved, do the adjustment. */
2929 insn[0] |= ex & 0xff;
2930 /* Two highest bits determine instruction size. */
2931 if (insn[0] >= 0x4000)
2932 insn[1] = read_memory_unsigned_integer (addr+2, 2, byte_order);
2934 /* Not necessary, but avoids uninitialized variable warnings. */
2936 if (insn[0] >= 0xc000)
2937 insn[2] = read_memory_unsigned_integer (addr+4, 2, byte_order);
2940 /* Split instruction into bytes and nibbles. */
2941 for (i = 0; i < 3; i++)
2943 ibyte[i*2] = insn[i] >> 8 & 0xff;
2944 ibyte[i*2+1] = insn[i] & 0xff;
2946 for (i = 0; i < 6; i++)
2948 inib[i*2] = ibyte[i] >> 4 & 0xf;
2949 inib[i*2+1] = ibyte[i] & 0xf;
2951 /* Compute vector registers, if applicable. */
2952 ivec[0] = (inib[9] >> 3 & 1) << 4 | inib[2];
2953 ivec[1] = (inib[9] >> 2 & 1) << 4 | inib[3];
2954 ivec[2] = (inib[9] >> 1 & 1) << 4 | inib[4];
2955 ivec[3] = (inib[9] >> 0 & 1) << 4 | inib[8];
2959 /* 0x00 undefined */
2962 /* E-format instruction */
2965 /* 0x00 undefined */
2966 /* 0x01 unsupported: PR - program return */
2967 /* 0x02 unsupported: UPT */
2968 /* 0x03 undefined */
2969 /* 0x04 privileged: PTFF - perform timing facility function */
2970 /* 0x05-0x06 undefined */
2971 /* 0x07 privileged: SCKPF - set clock programmable field */
2972 /* 0x08-0x09 undefined */
2974 case 0x0a: /* PFPO - perform floating point operation */
2975 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM, &tmp);
2976 if (!(tmp & 0x80000000u))
2978 uint8_t ofc = tmp >> 16 & 0xff;
2981 case 0x00: /* HFP32 */
2982 case 0x01: /* HFP64 */
2983 case 0x05: /* BFP32 */
2984 case 0x06: /* BFP64 */
2985 case 0x08: /* DFP32 */
2986 case 0x09: /* DFP64 */
2987 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM))
2990 case 0x02: /* HFP128 */
2991 case 0x07: /* BFP128 */
2992 case 0x0a: /* DFP128 */
2993 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM))
2995 if (record_full_arch_list_add_reg (regcache, S390_F2_REGNUM))
2999 fprintf_unfiltered (gdb_stdlog, "Warning: Unknown PFPO OFC %02x at %s.\n",
3000 ofc, paddress (gdbarch, addr));
3004 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
3007 if (record_full_arch_list_add_reg (regcache, S390_R1_REGNUM))
3009 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3013 case 0x0b: /* TAM - test address mode */
3014 case 0x0c: /* SAM24 - set address mode 24 */
3015 case 0x0d: /* SAM31 - set address mode 31 */
3016 case 0x0e: /* SAM64 - set address mode 64 */
3017 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3021 /* 0x0f-0xfe undefined */
3023 /* 0xff unsupported: TRAP */
3030 /* 0x02 undefined */
3031 /* 0x03 undefined */
3033 case 0x04: /* SPM - set program mask */
3034 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3038 case 0x05: /* BALR - branch and link */
3039 case 0x45: /* BAL - branch and link */
3040 case 0x06: /* BCTR - branch on count */
3041 case 0x46: /* BCT - branch on count */
3042 case 0x0d: /* BASR - branch and save */
3043 case 0x4d: /* BAS - branch and save */
3044 case 0x84: /* BRXH - branch relative on index high */
3045 case 0x85: /* BRXLE - branch relative on index low or equal */
3046 case 0x86: /* BXH - branch on index high */
3047 case 0x87: /* BXLE - branch on index low or equal */
3048 /* BA[SL]* use native-size destination for linkage info, BCT*, BRX*, BX*
3049 use 32-bit destination as counter. */
3050 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
3054 case 0x07: /* BCR - branch on condition */
3055 case 0x47: /* BC - branch on condition */
3056 /* No effect other than PC transfer. */
3059 /* 0x08 undefined */
3060 /* 0x09 undefined */
3063 /* SVC - supervisor call */
3064 if (tdep->s390_syscall_record != NULL)
3066 if (tdep->s390_syscall_record (regcache, ibyte[1]))
3071 printf_unfiltered (_("no syscall record support\n"));
3076 case 0x0b: /* BSM - branch and set mode */
3078 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
3080 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3084 case 0x0c: /* BASSM - branch and save and set mode */
3085 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
3087 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3091 case 0x0e: /* MVCL - move long [interruptible] */
3092 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + inib[2], &tmp);
3093 oaddr = s390_record_address_mask (gdbarch, regcache, tmp);
3094 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + (inib[2] | 1), &tmp);
3096 if (record_full_arch_list_add_mem (oaddr, tmp))
3098 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
3100 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[2] | 1)))
3102 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[3]))
3104 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[3] | 1)))
3106 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3110 case 0x0f: /* CLCL - compare logical long [interruptible] */
3111 case 0xa9: /* CLCLE - compare logical long extended [partial] */
3112 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
3114 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[2] | 1)))
3116 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[3]))
3118 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[3] | 1)))
3120 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3124 case 0x10: /* LPR - load positive */
3125 case 0x11: /* LNR - load negative */
3126 case 0x12: /* LTR - load and test */
3127 case 0x13: /* LCR - load complement */
3128 case 0x14: /* NR - and */
3129 case 0x16: /* OR - or */
3130 case 0x17: /* XR - xor */
3131 case 0x1a: /* AR - add */
3132 case 0x1b: /* SR - subtract */
3133 case 0x1e: /* ALR - add logical */
3134 case 0x1f: /* SLR - subtract logical */
3135 case 0x54: /* N - and */
3136 case 0x56: /* O - or */
3137 case 0x57: /* X - xor */
3138 case 0x5a: /* A - add */
3139 case 0x5b: /* S - subtract */
3140 case 0x5e: /* AL - add logical */
3141 case 0x5f: /* SL - subtract logical */
3142 case 0x4a: /* AH - add halfword */
3143 case 0x4b: /* SH - subtract halfword */
3144 case 0x8a: /* SRA - shift right single */
3145 case 0x8b: /* SLA - shift left single */
3146 case 0xbf: /* ICM - insert characters under mask */
3147 /* 32-bit destination + flags */
3148 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
3150 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3154 case 0x15: /* CLR - compare logical */
3155 case 0x55: /* CL - compare logical */
3156 case 0x19: /* CR - compare */
3157 case 0x29: /* CDR - compare */
3158 case 0x39: /* CER - compare */
3159 case 0x49: /* CH - compare halfword */
3160 case 0x59: /* C - compare */
3161 case 0x69: /* CD - compare */
3162 case 0x79: /* CE - compare */
3163 case 0x91: /* TM - test under mask */
3164 case 0x95: /* CLI - compare logical */
3165 case 0xbd: /* CLM - compare logical under mask */
3166 case 0xd5: /* CLC - compare logical */
3167 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3171 case 0x18: /* LR - load */
3172 case 0x48: /* LH - load halfword */
3173 case 0x58: /* L - load */
3174 case 0x41: /* LA - load address */
3175 case 0x43: /* IC - insert character */
3176 case 0x4c: /* MH - multiply halfword */
3177 case 0x71: /* MS - multiply single */
3178 case 0x88: /* SRL - shift right single logical */
3179 case 0x89: /* SLL - shift left single logical */
3180 /* 32-bit, 8-bit (IC), or native width (LA) destination, no flags */
3181 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
3185 case 0x1c: /* MR - multiply */
3186 case 0x5c: /* M - multiply */
3187 case 0x1d: /* DR - divide */
3188 case 0x5d: /* D - divide */
3189 case 0x8c: /* SRDL - shift right double logical */
3190 case 0x8d: /* SLDL - shift left double logical */
3191 /* 32-bit pair destination, no flags */
3192 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
3194 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[2] | 1)))
3198 case 0x20: /* LPDR - load positive */
3199 case 0x30: /* LPER - load positive */
3200 case 0x21: /* LNDR - load negative */
3201 case 0x31: /* LNER - load negative */
3202 case 0x22: /* LTDR - load and test */
3203 case 0x32: /* LTER - load and test */
3204 case 0x23: /* LCDR - load complement */
3205 case 0x33: /* LCER - load complement */
3206 case 0x2a: /* ADR - add */
3207 case 0x3a: /* AER - add */
3208 case 0x6a: /* AD - add */
3209 case 0x7a: /* AE - add */
3210 case 0x2b: /* SDR - subtract */
3211 case 0x3b: /* SER - subtract */
3212 case 0x6b: /* SD - subtract */
3213 case 0x7b: /* SE - subtract */
3214 case 0x2e: /* AWR - add unnormalized */
3215 case 0x3e: /* AUR - add unnormalized */
3216 case 0x6e: /* AW - add unnormalized */
3217 case 0x7e: /* AU - add unnormalized */
3218 case 0x2f: /* SWR - subtract unnormalized */
3219 case 0x3f: /* SUR - subtract unnormalized */
3220 case 0x6f: /* SW - subtract unnormalized */
3221 case 0x7f: /* SU - subtract unnormalized */
3222 /* float destination + flags */
3223 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[2]))
3225 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3229 case 0x24: /* HDR - halve */
3230 case 0x34: /* HER - halve */
3231 case 0x25: /* LDXR - load rounded */
3232 case 0x35: /* LEDR - load rounded */
3233 case 0x28: /* LDR - load */
3234 case 0x38: /* LER - load */
3235 case 0x68: /* LD - load */
3236 case 0x78: /* LE - load */
3237 case 0x2c: /* MDR - multiply */
3238 case 0x3c: /* MDER - multiply */
3239 case 0x6c: /* MD - multiply */
3240 case 0x7c: /* MDE - multiply */
3241 case 0x2d: /* DDR - divide */
3242 case 0x3d: /* DER - divide */
3243 case 0x6d: /* DD - divide */
3244 case 0x7d: /* DE - divide */
3245 /* float destination, no flags */
3246 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[2]))
3250 case 0x26: /* MXR - multiply */
3251 case 0x27: /* MXDR - multiply */
3252 case 0x67: /* MXD - multiply */
3253 /* float pair destination, no flags */
3254 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[2]))
3256 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + (inib[2] | 2)))
3260 case 0x36: /* AXR - add */
3261 case 0x37: /* SXR - subtract */
3262 /* float pair destination + flags */
3263 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[2]))
3265 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + (inib[2] | 2)))
3267 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3271 case 0x40: /* STH - store halfword */
3272 oaddr = s390_record_calc_disp (gdbarch, regcache, inib[3], insn[1], 0);
3273 if (record_full_arch_list_add_mem (oaddr, 2))
3277 case 0x42: /* STC - store character */
3278 oaddr = s390_record_calc_disp (gdbarch, regcache, inib[3], insn[1], 0);
3279 if (record_full_arch_list_add_mem (oaddr, 1))
3283 case 0x44: /* EX - execute */
3286 fprintf_unfiltered (gdb_stdlog, "Warning: Double execute at %s.\n",
3287 paddress (gdbarch, addr));
3290 addr = s390_record_calc_disp (gdbarch, regcache, inib[3], insn[1], 0);
3293 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + inib[2], &tmp);
3302 case 0x4e: /* CVD - convert to decimal */
3303 case 0x60: /* STD - store */
3304 oaddr = s390_record_calc_disp (gdbarch, regcache, inib[3], insn[1], 0);
3305 if (record_full_arch_list_add_mem (oaddr, 8))
3309 case 0x4f: /* CVB - convert to binary */
3310 /* 32-bit gpr destination + FPC (DXC write) */
3311 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
3313 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
3317 case 0x50: /* ST - store */
3318 case 0x70: /* STE - store */
3319 oaddr = s390_record_calc_disp (gdbarch, regcache, inib[3], insn[1], 0);
3320 if (record_full_arch_list_add_mem (oaddr, 4))
3324 case 0x51: /* LAE - load address extended */
3325 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
3327 if (record_full_arch_list_add_reg (regcache, S390_A0_REGNUM + inib[2]))
3331 /* 0x52 undefined */
3332 /* 0x53 undefined */
3334 /* 0x61-0x66 undefined */
3336 /* 0x72-0x77 undefined */
3338 /* 0x80 privileged: SSM - set system mask */
3339 /* 0x81 undefined */
3340 /* 0x82 privileged: LPSW - load PSW */
3341 /* 0x83 privileged: diagnose */
3343 case 0x8e: /* SRDA - shift right double */
3344 case 0x8f: /* SLDA - shift left double */
3345 /* 32-bit pair destination + flags */
3346 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
3348 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[2] | 1)))
3350 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3354 case 0x90: /* STM - store multiple */
3355 case 0x9b: /* STAM - store access multiple */
3356 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
3357 if (inib[2] <= inib[3])
3358 n = inib[3] - inib[2] + 1;
3360 n = inib[3] + 0x10 - inib[2] + 1;
3361 if (record_full_arch_list_add_mem (oaddr, n * 4))
3365 case 0x92: /* MVI - move */
3366 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
3367 if (record_full_arch_list_add_mem (oaddr, 1))
3371 case 0x93: /* TS - test and set */
3372 case 0x94: /* NI - and */
3373 case 0x96: /* OI - or */
3374 case 0x97: /* XI - xor */
3375 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
3376 if (record_full_arch_list_add_mem (oaddr, 1))
3378 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3382 case 0x98: /* LM - load multiple */
3383 for (i = inib[2]; i != inib[3]; i++, i &= 0xf)
3384 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + i))
3386 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[3]))
3390 /* 0x99 privileged: TRACE */
3392 case 0x9a: /* LAM - load access multiple */
3393 for (i = inib[2]; i != inib[3]; i++, i &= 0xf)
3394 if (record_full_arch_list_add_reg (regcache, S390_A0_REGNUM + i))
3396 if (record_full_arch_list_add_reg (regcache, S390_A0_REGNUM + inib[3]))
3400 /* 0x9c-0x9f privileged and obsolete (old I/O) */
3401 /* 0xa0-0xa4 undefined */
3405 /* RI-format instruction */
3406 switch (ibyte[0] << 4 | inib[3])
3408 case 0xa50: /* IIHH - insert immediate */
3409 case 0xa51: /* IIHL - insert immediate */
3410 /* high 32-bit destination */
3411 if (s390_record_gpr_h (gdbarch, regcache, inib[2]))
3415 case 0xa52: /* IILH - insert immediate */
3416 case 0xa53: /* IILL - insert immediate */
3417 case 0xa75: /* BRAS - branch relative and save */
3418 case 0xa76: /* BRCT - branch relative on count */
3419 case 0xa78: /* LHI - load halfword immediate */
3420 case 0xa7c: /* MHI - multiply halfword immediate */
3421 /* 32-bit or native destination */
3422 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
3426 case 0xa54: /* NIHH - and immediate */
3427 case 0xa55: /* NIHL - and immediate */
3428 case 0xa58: /* OIHH - or immediate */
3429 case 0xa59: /* OIHL - or immediate */
3430 /* high 32-bit destination + flags */
3431 if (s390_record_gpr_h (gdbarch, regcache, inib[2]))
3433 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3437 case 0xa56: /* NILH - and immediate */
3438 case 0xa57: /* NILL - and immediate */
3439 case 0xa5a: /* OILH - or immediate */
3440 case 0xa5b: /* OILL - or immediate */
3441 case 0xa7a: /* AHI - add halfword immediate */
3442 /* 32-bit destination + flags */
3443 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
3445 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3449 case 0xa5c: /* LLIHH - load logical immediate */
3450 case 0xa5d: /* LLIHL - load logical immediate */
3451 case 0xa5e: /* LLILH - load logical immediate */
3452 case 0xa5f: /* LLILL - load logical immediate */
3453 case 0xa77: /* BRCTG - branch relative on count */
3454 case 0xa79: /* LGHI - load halfword immediate */
3455 case 0xa7d: /* MGHI - multiply halfword immediate */
3456 /* 64-bit destination */
3457 if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
3461 case 0xa70: /* TMLH - test under mask */
3462 case 0xa71: /* TMLL - test under mask */
3463 case 0xa72: /* TMHH - test under mask */
3464 case 0xa73: /* TMHL - test under mask */
3465 case 0xa7e: /* CHI - compare halfword immediate */
3466 case 0xa7f: /* CGHI - compare halfword immediate */
3468 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3472 case 0xa74: /* BRC - branch relative on condition */
3473 /* no register change */
3476 case 0xa7b: /* AGHI - add halfword immediate */
3477 /* 64-bit destination + flags */
3478 if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
3480 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3489 /* 0xa6 undefined */
3491 case 0xa8: /* MVCLE - move long extended [partial] */
3492 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + inib[2], &tmp);
3493 oaddr = s390_record_address_mask (gdbarch, regcache, tmp);
3494 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + (inib[2] | 1), &tmp);
3495 if (record_full_arch_list_add_mem (oaddr, tmp))
3497 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
3499 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[2] | 1)))
3501 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[3]))
3503 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[3] | 1)))
3505 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3509 /* 0xaa-0xab undefined */
3510 /* 0xac privileged: STNSM - store then and system mask */
3511 /* 0xad privileged: STOSM - store then or system mask */
3512 /* 0xae privileged: SIGP - signal processor */
3513 /* 0xaf unsupported: MC - monitor call */
3514 /* 0xb0 undefined */
3515 /* 0xb1 privileged: LRA - load real address */
3520 /* S/RRD/RRE/RRF/IE-format instruction */
3523 /* 0xb200-0xb204 undefined or privileged */
3525 case 0xb205: /* STCK - store clock */
3526 case 0xb27c: /* STCKF - store clock fast */
3527 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
3528 if (record_full_arch_list_add_mem (oaddr, 8))
3530 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3534 /* 0xb206-0xb219 undefined, privileged, or unsupported */
3535 /* 0xb21a unsupported: CFC */
3536 /* 0xb21b-0xb221 undefined or privileged */
3538 case 0xb222: /* IPM - insert program mask */
3539 case 0xb24f: /* EAR - extract access */
3540 case 0xb252: /* MSR - multiply single */
3541 case 0xb2ec: /* ETND - extract transaction nesting depth */
3542 case 0xb38c: /* EFPC - extract fpc */
3543 case 0xb91f: /* LRVR - load reversed */
3544 case 0xb926: /* LBR - load byte */
3545 case 0xb927: /* LHR - load halfword */
3546 case 0xb994: /* LLCR - load logical character */
3547 case 0xb995: /* LLHR - load logical halfword */
3548 case 0xb9f2: /* LOCR - load on condition */
3549 /* 32-bit gpr destination */
3550 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
3554 /* 0xb223-0xb22c privileged or unsupported */
3556 case 0xb22d: /* DXR - divide */
3557 case 0xb325: /* LXDR - load lengthened */
3558 case 0xb326: /* LXER - load lengthened */
3559 case 0xb336: /* SQXR - square root */
3560 case 0xb365: /* LXR - load */
3561 case 0xb367: /* FIXR - load fp integer */
3562 case 0xb376: /* LZXR - load zero */
3563 case 0xb3b6: /* CXFR - convert from fixed */
3564 case 0xb3c6: /* CXGR - convert from fixed */
3565 case 0xb3fe: /* IEXTR - insert biased exponent */
3566 /* float pair destination */
3567 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[6]))
3569 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + (inib[6] | 2)))
3573 /* 0xb22e-0xb240 undefined, privileged, or unsupported */
3575 case 0xb241: /* CKSM - checksum [partial] */
3576 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
3578 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[7]))
3580 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[7] | 1)))
3582 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3586 /* 0xb242-0xb243 undefined */
3588 case 0xb244: /* SQDR - square root */
3589 case 0xb245: /* SQER - square root */
3590 case 0xb324: /* LDER - load lengthened */
3591 case 0xb337: /* MEER - multiply */
3592 case 0xb366: /* LEXR - load rounded */
3593 case 0xb370: /* LPDFR - load positive */
3594 case 0xb371: /* LNDFR - load negative */
3595 case 0xb372: /* CSDFR - copy sign */
3596 case 0xb373: /* LCDFR - load complement */
3597 case 0xb374: /* LZER - load zero */
3598 case 0xb375: /* LZDR - load zero */
3599 case 0xb377: /* FIER - load fp integer */
3600 case 0xb37f: /* FIDR - load fp integer */
3601 case 0xb3b4: /* CEFR - convert from fixed */
3602 case 0xb3b5: /* CDFR - convert from fixed */
3603 case 0xb3c1: /* LDGR - load fpr from gr */
3604 case 0xb3c4: /* CEGR - convert from fixed */
3605 case 0xb3c5: /* CDGR - convert from fixed */
3606 case 0xb3f6: /* IEDTR - insert biased exponent */
3607 /* float destination */
3608 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[6]))
3612 /* 0xb246-0xb24c: privileged or unsupported */
3614 case 0xb24d: /* CPYA - copy access */
3615 case 0xb24e: /* SAR - set access */
3616 if (record_full_arch_list_add_reg (regcache, S390_A0_REGNUM + inib[6]))
3620 /* 0xb250-0xb251 undefined or privileged */
3621 /* 0xb253-0xb254 undefined or privileged */
3623 case 0xb255: /* MVST - move string [partial] */
3628 /* Read ending byte. */
3629 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM, &tmp);
3631 /* Get address of second operand. */
3632 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + inib[7], &tmp);
3633 oaddr = s390_record_address_mask (gdbarch, regcache, tmp);
3634 /* Search for ending byte and compute length. */
3637 if (target_read_memory (oaddr, &cur, 1))
3640 } while (cur != end);
3641 /* Get address of first operand and record it. */
3642 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + inib[6], &tmp);
3643 oaddr = s390_record_address_mask (gdbarch, regcache, tmp);
3644 if (record_full_arch_list_add_mem (oaddr, num))
3646 /* Record the registers. */
3647 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
3649 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[7]))
3651 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3656 /* 0xb256 undefined */
3658 case 0xb257: /* CUSE - compare until substring equal [interruptible] */
3659 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
3661 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[6] | 1)))
3663 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[7]))
3665 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[7] | 1)))
3667 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3671 /* 0xb258-0xb25c undefined, privileged, or unsupported */
3673 case 0xb25d: /* CLST - compare logical string [partial] */
3674 case 0xb25e: /* SRST - search string [partial] */
3675 case 0xb9be: /* SRSTU - search string unicode [partial] */
3676 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
3678 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[7]))
3680 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3684 /* 0xb25f-0xb262 undefined */
3686 case 0xb263: /* CMPSC - compression call [interruptible] */
3687 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + inib[6], &tmp);
3688 oaddr = s390_record_address_mask (gdbarch, regcache, tmp);
3689 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + (inib[6] | 1), &tmp);
3690 if (record_full_arch_list_add_mem (oaddr, tmp))
3692 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
3694 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[6] | 1)))
3696 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[7]))
3698 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[7] | 1)))
3700 if (record_full_arch_list_add_reg (regcache, S390_R1_REGNUM))
3702 /* DXC may be written */
3703 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
3705 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3709 /* 0xb264-0xb277 undefined, privileged, or unsupported */
3711 case 0xb278: /* STCKE - store clock extended */
3712 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
3713 if (record_full_arch_list_add_mem (oaddr, 16))
3715 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3719 /* 0xb279-0xb27b undefined or unsupported */
3720 /* 0xb27d-0xb298 undefined or privileged */
3722 case 0xb299: /* SRNM - set rounding mode */
3723 case 0xb2b8: /* SRNMB - set bfp rounding mode */
3724 case 0xb2b9: /* SRNMT - set dfp rounding mode */
3725 case 0xb29d: /* LFPC - load fpc */
3726 case 0xb2bd: /* LFAS - load fpc and signal */
3727 case 0xb384: /* SFPC - set fpc */
3728 case 0xb385: /* SFASR - set fpc and signal */
3729 case 0xb960: /* CGRT - compare and trap */
3730 case 0xb961: /* CLGRT - compare logical and trap */
3731 case 0xb972: /* CRT - compare and trap */
3732 case 0xb973: /* CLRT - compare logical and trap */
3733 /* fpc only - including possible DXC write for trapping insns */
3734 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
3738 /* 0xb29a-0xb29b undefined */
3740 case 0xb29c: /* STFPC - store fpc */
3741 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
3742 if (record_full_arch_list_add_mem (oaddr, 4))
3746 /* 0xb29e-0xb2a4 undefined */
3748 case 0xb2a5: /* TRE - translate extended [partial] */
3749 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + inib[6], &tmp);
3750 oaddr = s390_record_address_mask (gdbarch, regcache, tmp);
3751 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + (inib[6] | 1), &tmp);
3752 if (record_full_arch_list_add_mem (oaddr, tmp))
3754 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
3756 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[6] | 1)))
3758 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3762 case 0xb2a6: /* CU21 - convert UTF-16 to UTF-8 [partial] */
3763 case 0xb2a7: /* CU12 - convert UTF-8 to UTF-16 [partial] */
3764 case 0xb9b0: /* CU14 - convert UTF-8 to UTF-32 [partial] */
3765 case 0xb9b1: /* CU24 - convert UTF-16 to UTF-32 [partial] */
3766 case 0xb9b2: /* CU41 - convert UTF-32 to UTF-8 [partial] */
3767 case 0xb9b3: /* CU42 - convert UTF-32 to UTF-16 [partial] */
3768 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + inib[6], &tmp);
3769 oaddr = s390_record_address_mask (gdbarch, regcache, tmp);
3770 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + (inib[6] | 1), &tmp);
3771 if (record_full_arch_list_add_mem (oaddr, tmp))
3773 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
3775 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[6] | 1)))
3777 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[7]))
3779 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[7] | 1)))
3781 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3785 /* 0xb2a8-0xb2af undefined */
3787 case 0xb2b0: /* STFLE - store facility list extended */
3788 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
3789 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM, &tmp);
3791 if (record_full_arch_list_add_mem (oaddr, 8 * (tmp + 1)))
3793 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM))
3795 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3799 /* 0xb2b1-0xb2b7 undefined or privileged */
3800 /* 0xb2ba-0xb2bc undefined */
3801 /* 0xb2be-0xb2e7 undefined */
3802 /* 0xb2e9-0xb2eb undefined */
3803 /* 0xb2ed-0xb2f7 undefined */
3804 /* 0xb2f8 unsupported: TEND */
3805 /* 0xb2f9 undefined */
3807 case 0xb2e8: /* PPA - perform processor assist */
3808 case 0xb2fa: /* NIAI - next instruction access intent */
3809 /* no visible effects */
3812 /* 0xb2fb undefined */
3813 /* 0xb2fc unsupported: TABORT */
3814 /* 0xb2fd-0xb2fe undefined */
3815 /* 0xb2ff unsupported: TRAP */
3817 case 0xb300: /* LPEBR - load positive */
3818 case 0xb301: /* LNEBR - load negative */
3819 case 0xb303: /* LCEBR - load complement */
3820 case 0xb310: /* LPDBR - load positive */
3821 case 0xb311: /* LNDBR - load negative */
3822 case 0xb313: /* LCDBR - load complement */
3823 case 0xb350: /* TBEDR - convert hfp to bfp */
3824 case 0xb351: /* TBDR - convert hfp to bfp */
3825 case 0xb358: /* THDER - convert bfp to hfp */
3826 case 0xb359: /* THDR - convert bfp to hfp */
3827 /* float destination + flags */
3828 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[6]))
3830 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3834 case 0xb304: /* LDEBR - load lengthened */
3835 case 0xb30c: /* MDEBR - multiply */
3836 case 0xb30d: /* DEBR - divide */
3837 case 0xb314: /* SQEBR - square root */
3838 case 0xb315: /* SQDBR - square root */
3839 case 0xb317: /* MEEBR - multiply */
3840 case 0xb31c: /* MDBR - multiply */
3841 case 0xb31d: /* DDBR - divide */
3842 case 0xb344: /* LEDBRA - load rounded */
3843 case 0xb345: /* LDXBRA - load rounded */
3844 case 0xb346: /* LEXBRA - load rounded */
3845 case 0xb357: /* FIEBRA - load fp integer */
3846 case 0xb35f: /* FIDBRA - load fp integer */
3847 case 0xb390: /* CELFBR - convert from logical */
3848 case 0xb391: /* CDLFBR - convert from logical */
3849 case 0xb394: /* CEFBR - convert from fixed */
3850 case 0xb395: /* CDFBR - convert from fixed */
3851 case 0xb3a0: /* CELGBR - convert from logical */
3852 case 0xb3a1: /* CDLGBR - convert from logical */
3853 case 0xb3a4: /* CEGBR - convert from fixed */
3854 case 0xb3a5: /* CDGBR - convert from fixed */
3855 case 0xb3d0: /* MDTR - multiply */
3856 case 0xb3d1: /* DDTR - divide */
3857 case 0xb3d4: /* LDETR - load lengthened */
3858 case 0xb3d5: /* LEDTR - load lengthened */
3859 case 0xb3d7: /* FIDTR - load fp integer */
3860 case 0xb3dd: /* LDXTR - load lengthened */
3861 case 0xb3f1: /* CDGTR - convert from fixed */
3862 case 0xb3f2: /* CDUTR - convert from unsigned packed */
3863 case 0xb3f3: /* CDSTR - convert from signed packed */
3864 case 0xb3f5: /* QADTR - quantize */
3865 case 0xb3f7: /* RRDTR - reround */
3866 case 0xb951: /* CDFTR - convert from fixed */
3867 case 0xb952: /* CDLGTR - convert from logical */
3868 case 0xb953: /* CDLFTR - convert from logical */
3869 /* float destination + fpc */
3870 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[6]))
3872 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
3876 case 0xb305: /* LXDBR - load lengthened */
3877 case 0xb306: /* LXEBR - load lengthened */
3878 case 0xb307: /* MXDBR - multiply */
3879 case 0xb316: /* SQXBR - square root */
3880 case 0xb34c: /* MXBR - multiply */
3881 case 0xb34d: /* DXBR - divide */
3882 case 0xb347: /* FIXBRA - load fp integer */
3883 case 0xb392: /* CXLFBR - convert from logical */
3884 case 0xb396: /* CXFBR - convert from fixed */
3885 case 0xb3a2: /* CXLGBR - convert from logical */
3886 case 0xb3a6: /* CXGBR - convert from fixed */
3887 case 0xb3d8: /* MXTR - multiply */
3888 case 0xb3d9: /* DXTR - divide */
3889 case 0xb3dc: /* LXDTR - load lengthened */
3890 case 0xb3df: /* FIXTR - load fp integer */
3891 case 0xb3f9: /* CXGTR - convert from fixed */
3892 case 0xb3fa: /* CXUTR - convert from unsigned packed */
3893 case 0xb3fb: /* CXSTR - convert from signed packed */
3894 case 0xb3fd: /* QAXTR - quantize */
3895 case 0xb3ff: /* RRXTR - reround */
3896 case 0xb959: /* CXFTR - convert from fixed */
3897 case 0xb95a: /* CXLGTR - convert from logical */
3898 case 0xb95b: /* CXLFTR - convert from logical */
3899 /* float pair destination + fpc */
3900 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[6]))
3902 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + (inib[6] | 2)))
3904 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
3908 case 0xb308: /* KEBR - compare and signal */
3909 case 0xb309: /* CEBR - compare */
3910 case 0xb318: /* KDBR - compare and signal */
3911 case 0xb319: /* CDBR - compare */
3912 case 0xb348: /* KXBR - compare and signal */
3913 case 0xb349: /* CXBR - compare */
3914 case 0xb3e0: /* KDTR - compare and signal */
3915 case 0xb3e4: /* CDTR - compare */
3916 case 0xb3e8: /* KXTR - compare and signal */
3917 case 0xb3ec: /* CXTR - compare */
3918 /* flags + fpc only */
3919 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3921 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
3925 case 0xb302: /* LTEBR - load and test */
3926 case 0xb312: /* LTDBR - load and test */
3927 case 0xb30a: /* AEBR - add */
3928 case 0xb30b: /* SEBR - subtract */
3929 case 0xb31a: /* ADBR - add */
3930 case 0xb31b: /* SDBR - subtract */
3931 case 0xb3d2: /* ADTR - add */
3932 case 0xb3d3: /* SDTR - subtract */
3933 case 0xb3d6: /* LTDTR - load and test */
3934 /* float destination + flags + fpc */
3935 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[6]))
3937 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3939 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
3943 case 0xb30e: /* MAEBR - multiply and add */
3944 case 0xb30f: /* MSEBR - multiply and subtract */
3945 case 0xb31e: /* MADBR - multiply and add */
3946 case 0xb31f: /* MSDBR - multiply and subtract */
3947 /* float destination [RRD] + fpc */
3948 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[4]))
3950 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
3954 /* 0xb320-0xb323 undefined */
3955 /* 0xb327-0xb32d undefined */
3957 case 0xb32e: /* MAER - multiply and add */
3958 case 0xb32f: /* MSER - multiply and subtract */
3959 case 0xb338: /* MAYLR - multiply and add unnormalized */
3960 case 0xb339: /* MYLR - multiply unnormalized */
3961 case 0xb33c: /* MAYHR - multiply and add unnormalized */
3962 case 0xb33d: /* MYHR - multiply unnormalized */
3963 case 0xb33e: /* MADR - multiply and add */
3964 case 0xb33f: /* MSDR - multiply and subtract */
3965 /* float destination [RRD] */
3966 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[4]))
3970 /* 0xb330-0xb335 undefined */
3972 case 0xb33a: /* MAYR - multiply and add unnormalized */
3973 case 0xb33b: /* MYR - multiply unnormalized */
3974 /* float pair destination [RRD] */
3975 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[4]))
3977 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + (inib[4] | 2)))
3981 case 0xb340: /* LPXBR - load positive */
3982 case 0xb341: /* LNXBR - load negative */
3983 case 0xb343: /* LCXBR - load complement */
3984 case 0xb360: /* LPXR - load positive */
3985 case 0xb361: /* LNXR - load negative */
3986 case 0xb362: /* LTXR - load and test */
3987 case 0xb363: /* LCXR - load complement */
3988 /* float pair destination + flags */
3989 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[6]))
3991 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + (inib[6] | 2)))
3993 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3997 case 0xb342: /* LTXBR - load and test */
3998 case 0xb34a: /* AXBR - add */
3999 case 0xb34b: /* SXBR - subtract */
4000 case 0xb3da: /* AXTR - add */
4001 case 0xb3db: /* SXTR - subtract */
4002 case 0xb3de: /* LTXTR - load and test */
4003 /* float pair destination + flags + fpc */
4004 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[6]))
4006 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + (inib[6] | 2)))
4008 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4010 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
4014 /* 0xb34e-0xb34f undefined */
4015 /* 0xb352 undefined */
4017 case 0xb353: /* DIEBR - divide to integer */
4018 case 0xb35b: /* DIDBR - divide to integer */
4019 /* two float destinations + flags + fpc */
4020 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[4]))
4022 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[6]))
4024 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4026 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
4030 /* 0xb354-0xb356 undefined */
4031 /* 0xb35a undefined */
4033 /* 0xb35c-0xb35e undefined */
4034 /* 0xb364 undefined */
4035 /* 0xb368 undefined */
4037 case 0xb369: /* CXR - compare */
4038 case 0xb3f4: /* CEDTR - compare biased exponent */
4039 case 0xb3fc: /* CEXTR - compare biased exponent */
4040 case 0xb920: /* CGR - compare */
4041 case 0xb921: /* CLGR - compare logical */
4042 case 0xb930: /* CGFR - compare */
4043 case 0xb931: /* CLGFR - compare logical */
4044 case 0xb9cd: /* CHHR - compare high */
4045 case 0xb9cf: /* CLHHR - compare logical high */
4046 case 0xb9dd: /* CHLR - compare high */
4047 case 0xb9df: /* CLHLR - compare logical high */
4049 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4053 /* 0xb36a-0xb36f undefined */
4054 /* 0xb377-0xb37e undefined */
4055 /* 0xb380-0xb383 undefined */
4056 /* 0xb386-0xb38b undefined */
4057 /* 0xb38d-0xb38f undefined */
4058 /* 0xb393 undefined */
4059 /* 0xb397 undefined */
4061 case 0xb398: /* CFEBR - convert to fixed */
4062 case 0xb399: /* CFDBR - convert to fixed */
4063 case 0xb39a: /* CFXBR - convert to fixed */
4064 case 0xb39c: /* CLFEBR - convert to logical */
4065 case 0xb39d: /* CLFDBR - convert to logical */
4066 case 0xb39e: /* CLFXBR - convert to logical */
4067 case 0xb941: /* CFDTR - convert to fixed */
4068 case 0xb949: /* CFXTR - convert to fixed */
4069 case 0xb943: /* CLFDTR - convert to logical */
4070 case 0xb94b: /* CLFXTR - convert to logical */
4071 /* 32-bit gpr destination + flags + fpc */
4072 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
4074 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4076 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
4080 /* 0xb39b undefined */
4081 /* 0xb39f undefined */
4083 /* 0xb3a3 undefined */
4084 /* 0xb3a7 undefined */
4086 case 0xb3a8: /* CGEBR - convert to fixed */
4087 case 0xb3a9: /* CGDBR - convert to fixed */
4088 case 0xb3aa: /* CGXBR - convert to fixed */
4089 case 0xb3ac: /* CLGEBR - convert to logical */
4090 case 0xb3ad: /* CLGDBR - convert to logical */
4091 case 0xb3ae: /* CLGXBR - convert to logical */
4092 case 0xb3e1: /* CGDTR - convert to fixed */
4093 case 0xb3e9: /* CGXTR - convert to fixed */
4094 case 0xb942: /* CLGDTR - convert to logical */
4095 case 0xb94a: /* CLGXTR - convert to logical */
4096 /* 64-bit gpr destination + flags + fpc */
4097 if (s390_record_gpr_g (gdbarch, regcache, inib[6]))
4099 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4101 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
4105 /* 0xb3ab undefined */
4106 /* 0xb3af-0xb3b3 undefined */
4107 /* 0xb3b7 undefined */
4109 case 0xb3b8: /* CFER - convert to fixed */
4110 case 0xb3b9: /* CFDR - convert to fixed */
4111 case 0xb3ba: /* CFXR - convert to fixed */
4112 case 0xb998: /* ALCR - add logical with carry */
4113 case 0xb999: /* SLBR - subtract logical with borrow */
4114 case 0xb9f4: /* NRK - and */
4115 case 0xb9f6: /* ORK - or */
4116 case 0xb9f7: /* XRK - xor */
4117 case 0xb9f8: /* ARK - add */
4118 case 0xb9f9: /* SRK - subtract */
4119 case 0xb9fa: /* ALRK - add logical */
4120 case 0xb9fb: /* SLRK - subtract logical */
4121 /* 32-bit gpr destination + flags */
4122 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
4124 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4128 case 0xb3c8: /* CGER - convert to fixed */
4129 case 0xb3c9: /* CGDR - convert to fixed */
4130 case 0xb3ca: /* CGXR - convert to fixed */
4131 case 0xb900: /* LPGR - load positive */
4132 case 0xb901: /* LNGR - load negative */
4133 case 0xb902: /* LTGR - load and test */
4134 case 0xb903: /* LCGR - load complement */
4135 case 0xb908: /* AGR - add */
4136 case 0xb909: /* SGR - subtract */
4137 case 0xb90a: /* ALGR - add logical */
4138 case 0xb90b: /* SLGR - subtract logical */
4139 case 0xb910: /* LPGFR - load positive */
4140 case 0xb911: /* LNGFR - load negative */
4141 case 0xb912: /* LTGFR - load and test */
4142 case 0xb913: /* LCGFR - load complement */
4143 case 0xb918: /* AGFR - add */
4144 case 0xb919: /* SGFR - subtract */
4145 case 0xb91a: /* ALGFR - add logical */
4146 case 0xb91b: /* SLGFR - subtract logical */
4147 case 0xb980: /* NGR - and */
4148 case 0xb981: /* OGR - or */
4149 case 0xb982: /* XGR - xor */
4150 case 0xb988: /* ALCGR - add logical with carry */
4151 case 0xb989: /* SLBGR - subtract logical with borrow */
4152 case 0xb9e1: /* POPCNT - population count */
4153 case 0xb9e4: /* NGRK - and */
4154 case 0xb9e6: /* OGRK - or */
4155 case 0xb9e7: /* XGRK - xor */
4156 case 0xb9e8: /* AGRK - add */
4157 case 0xb9e9: /* SGRK - subtract */
4158 case 0xb9ea: /* ALGRK - add logical */
4159 case 0xb9eb: /* SLGRK - subtract logical */
4160 case 0xb9ed: /* MSGRKC - multiply single 64x64 -> 64 */
4161 case 0xb9fd: /* MSRKC - multiply single 32x32 -> 32 */
4162 /* 64-bit gpr destination + flags */
4163 if (s390_record_gpr_g (gdbarch, regcache, inib[6]))
4165 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4169 /* 0xb3bb-0xb3c0 undefined */
4170 /* 0xb3c2-0xb3c3 undefined */
4171 /* 0xb3c7 undefined */
4172 /* 0xb3cb-0xb3cc undefined */
4174 case 0xb3cd: /* LGDR - load gr from fpr */
4175 case 0xb3e2: /* CUDTR - convert to unsigned packed */
4176 case 0xb3e3: /* CSDTR - convert to signed packed */
4177 case 0xb3e5: /* EEDTR - extract biased exponent */
4178 case 0xb3e7: /* ESDTR - extract significance */
4179 case 0xb3ed: /* EEXTR - extract biased exponent */
4180 case 0xb3ef: /* ESXTR - extract significance */
4181 case 0xb904: /* LGR - load */
4182 case 0xb906: /* LGBR - load byte */
4183 case 0xb907: /* LGHR - load halfword */
4184 case 0xb90c: /* MSGR - multiply single */
4185 case 0xb90f: /* LRVGR - load reversed */
4186 case 0xb914: /* LGFR - load */
4187 case 0xb916: /* LLGFR - load logical */
4188 case 0xb917: /* LLGTR - load logical thirty one bits */
4189 case 0xb91c: /* MSGFR - multiply single 64<32 */
4190 case 0xb946: /* BCTGR - branch on count */
4191 case 0xb984: /* LLGCR - load logical character */
4192 case 0xb985: /* LLGHR - load logical halfword */
4193 case 0xb9e2: /* LOCGR - load on condition */
4194 /* 64-bit gpr destination */
4195 if (s390_record_gpr_g (gdbarch, regcache, inib[6]))
4199 /* 0xb3ce-0xb3cf undefined */
4200 /* 0xb3e6 undefined */
4202 case 0xb3ea: /* CUXTR - convert to unsigned packed */
4203 case 0xb3eb: /* CSXTR - convert to signed packed */
4204 case 0xb90d: /* DSGR - divide single */
4205 case 0xb91d: /* DSGFR - divide single */
4206 case 0xb986: /* MLGR - multiply logical */
4207 case 0xb987: /* DLGR - divide logical */
4208 case 0xb9ec: /* MGRK - multiply 64x64 -> 128 */
4209 /* 64-bit gpr pair destination */
4210 if (s390_record_gpr_g (gdbarch, regcache, inib[6]))
4212 if (s390_record_gpr_g (gdbarch, regcache, inib[6] | 1))
4216 /* 0xb3ee undefined */
4217 /* 0xb3f0 undefined */
4218 /* 0xb3f8 undefined */
4220 /* 0xb905 privileged */
4222 /* 0xb90e unsupported: EREGG */
4224 /* 0xb915 undefined */
4226 case 0xb91e: /* KMAC - compute message authentication code [partial] */
4227 regcache_raw_read_unsigned (regcache, S390_R1_REGNUM, &tmp);
4228 oaddr = s390_record_address_mask (gdbarch, regcache, tmp);
4229 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM, &tmp);
4233 case 0x00: /* KMAC-Query */
4234 if (record_full_arch_list_add_mem (oaddr, 16))
4238 case 0x01: /* KMAC-DEA */
4239 case 0x02: /* KMAC-TDEA-128 */
4240 case 0x03: /* KMAC-TDEA-192 */
4241 case 0x09: /* KMAC-Encrypted-DEA */
4242 case 0x0a: /* KMAC-Encrypted-TDEA-128 */
4243 case 0x0b: /* KMAC-Encrypted-TDEA-192 */
4244 if (record_full_arch_list_add_mem (oaddr, 8))
4248 case 0x12: /* KMAC-AES-128 */
4249 case 0x13: /* KMAC-AES-192 */
4250 case 0x14: /* KMAC-AES-256 */
4251 case 0x1a: /* KMAC-Encrypted-AES-128 */
4252 case 0x1b: /* KMAC-Encrypted-AES-192 */
4253 case 0x1c: /* KMAC-Encrypted-AES-256 */
4254 if (record_full_arch_list_add_mem (oaddr, 16))
4259 fprintf_unfiltered (gdb_stdlog, "Warning: Unknown KMAC function %02x at %s.\n",
4260 (int)tmp, paddress (gdbarch, addr));
4265 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[7]))
4267 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[7] | 1)))
4270 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4274 /* 0xb922-0xb924 undefined */
4275 /* 0xb925 privileged */
4276 /* 0xb928 privileged */
4278 case 0xb929: /* KMA - cipher message with authentication */
4279 case 0xb92a: /* KMF - cipher message with cipher feedback [partial] */
4280 case 0xb92b: /* KMO - cipher message with output feedback [partial] */
4281 case 0xb92f: /* KMC - cipher message with chaining [partial] */
4282 regcache_raw_read_unsigned (regcache, S390_R1_REGNUM, &tmp);
4283 oaddr = s390_record_address_mask (gdbarch, regcache, tmp);
4284 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM, &tmp);
4288 case 0x00: /* KM*-Query */
4289 if (record_full_arch_list_add_mem (oaddr, 16))
4293 case 0x01: /* KM*-DEA */
4294 case 0x02: /* KM*-TDEA-128 */
4295 case 0x03: /* KM*-TDEA-192 */
4296 case 0x09: /* KM*-Encrypted-DEA */
4297 case 0x0a: /* KM*-Encrypted-TDEA-128 */
4298 case 0x0b: /* KM*-Encrypted-TDEA-192 */
4299 if (record_full_arch_list_add_mem (oaddr, 8))
4303 case 0x12: /* KM*-AES-128 */
4304 case 0x13: /* KM*-AES-192 */
4305 case 0x14: /* KM*-AES-256 */
4306 case 0x1a: /* KM*-Encrypted-AES-128 */
4307 case 0x1b: /* KM*-Encrypted-AES-192 */
4308 case 0x1c: /* KM*-Encrypted-AES-256 */
4309 if (record_full_arch_list_add_mem (oaddr, 16))
4313 case 0x43: /* KMC-PRNG */
4314 /* Only valid for KMC. */
4315 if (insn[0] == 0xb92f)
4317 if (record_full_arch_list_add_mem (oaddr, 8))
4321 /* For other instructions, fallthru. */
4323 fprintf_unfiltered (gdb_stdlog, "Warning: Unknown KM* function %02x at %s.\n",
4324 (int)tmp, paddress (gdbarch, addr));
4329 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + inib[6], &tmp);
4330 oaddr2 = s390_record_address_mask (gdbarch, regcache, tmp);
4331 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + (inib[7] | 1), &tmp);
4332 if (record_full_arch_list_add_mem (oaddr2, tmp))
4334 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
4336 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[7]))
4338 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[7] | 1)))
4341 if (tmp != 0 && insn[0] == 0xb929)
4343 if (record_full_arch_list_add_reg (regcache,
4344 S390_R0_REGNUM + inib[4]))
4346 if (record_full_arch_list_add_reg (regcache,
4347 S390_R0_REGNUM + (inib[4] | 1)))
4350 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4354 case 0xb92c: /* PCC - perform cryptographic computation [partial] */
4355 regcache_raw_read_unsigned (regcache, S390_R1_REGNUM, &tmp);
4356 oaddr = s390_record_address_mask (gdbarch, regcache, tmp);
4357 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM, &tmp);
4361 case 0x00: /* PCC-Query */
4362 if (record_full_arch_list_add_mem (oaddr, 16))
4366 case 0x01: /* PCC-Compute-Last-Block-CMAC-Using-DEA */
4367 case 0x02: /* PCC-Compute-Last-Block-CMAC-Using-TDEA-128 */
4368 case 0x03: /* PCC-Compute-Last-Block-CMAC-Using-TDEA-192 */
4369 case 0x09: /* PCC-Compute-Last-Block-CMAC-Using-Encrypted-DEA */
4370 case 0x0a: /* PCC-Compute-Last-Block-CMAC-Using-Encrypted-TDEA-128 */
4371 case 0x0b: /* PCC-Compute-Last-Block-CMAC-Using-Encrypted-TDEA-192 */
4372 if (record_full_arch_list_add_mem (oaddr + 0x10, 8))
4376 case 0x12: /* PCC-Compute-Last-Block-CMAC-Using-AES-128 */
4377 case 0x13: /* PCC-Compute-Last-Block-CMAC-Using-AES-192 */
4378 case 0x14: /* PCC-Compute-Last-Block-CMAC-Using-AES-256 */
4379 case 0x1a: /* PCC-Compute-Last-Block-CMAC-Using-Encrypted-AES-128 */
4380 case 0x1b: /* PCC-Compute-Last-Block-CMAC-Using-Encrypted-AES-192 */
4381 case 0x1c: /* PCC-Compute-Last-Block-CMAC-Using-Encrypted-AES-256 */
4382 if (record_full_arch_list_add_mem (oaddr + 0x18, 16))
4386 case 0x32: /* PCC-Compute-XTS-Parameter-Using-AES-128 */
4387 if (record_full_arch_list_add_mem (oaddr + 0x30, 32))
4391 case 0x34: /* PCC-Compute-XTS-Parameter-Using-AES-256 */
4392 if (record_full_arch_list_add_mem (oaddr + 0x40, 32))
4396 case 0x3a: /* PCC-Compute-XTS-Parameter-Using-Encrypted-AES-128 */
4397 if (record_full_arch_list_add_mem (oaddr + 0x50, 32))
4401 case 0x3c: /* PCC-Compute-XTS-Parameter-Using-Encrypted-AES-256 */
4402 if (record_full_arch_list_add_mem (oaddr + 0x60, 32))
4407 fprintf_unfiltered (gdb_stdlog, "Warning: Unknown PCC function %02x at %s.\n",
4408 (int)tmp, paddress (gdbarch, addr));
4411 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4415 case 0xb92d: /* KMCTR - cipher message with counter [partial] */
4416 regcache_raw_read_unsigned (regcache, S390_R1_REGNUM, &tmp);
4417 oaddr = s390_record_address_mask (gdbarch, regcache, tmp);
4418 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM, &tmp);
4422 case 0x00: /* KMCTR-Query */
4423 if (record_full_arch_list_add_mem (oaddr, 16))
4427 case 0x01: /* KMCTR-DEA */
4428 case 0x02: /* KMCTR-TDEA-128 */
4429 case 0x03: /* KMCTR-TDEA-192 */
4430 case 0x09: /* KMCTR-Encrypted-DEA */
4431 case 0x0a: /* KMCTR-Encrypted-TDEA-128 */
4432 case 0x0b: /* KMCTR-Encrypted-TDEA-192 */
4433 case 0x12: /* KMCTR-AES-128 */
4434 case 0x13: /* KMCTR-AES-192 */
4435 case 0x14: /* KMCTR-AES-256 */
4436 case 0x1a: /* KMCTR-Encrypted-AES-128 */
4437 case 0x1b: /* KMCTR-Encrypted-AES-192 */
4438 case 0x1c: /* KMCTR-Encrypted-AES-256 */
4442 fprintf_unfiltered (gdb_stdlog, "Warning: Unknown KMCTR function %02x at %s.\n",
4443 (int)tmp, paddress (gdbarch, addr));
4448 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + inib[6], &tmp);
4449 oaddr2 = s390_record_address_mask (gdbarch, regcache, tmp);
4450 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + (inib[7] | 1), &tmp);
4451 if (record_full_arch_list_add_mem (oaddr2, tmp))
4453 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
4455 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[7]))
4457 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[7] | 1)))
4459 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[4]))
4462 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4466 case 0xb92e: /* KM - cipher message [partial] */
4467 regcache_raw_read_unsigned (regcache, S390_R1_REGNUM, &tmp);
4468 oaddr = s390_record_address_mask (gdbarch, regcache, tmp);
4469 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM, &tmp);
4473 case 0x00: /* KM-Query */
4474 if (record_full_arch_list_add_mem (oaddr, 16))
4478 case 0x01: /* KM-DEA */
4479 case 0x02: /* KM-TDEA-128 */
4480 case 0x03: /* KM-TDEA-192 */
4481 case 0x09: /* KM-Encrypted-DEA */
4482 case 0x0a: /* KM-Encrypted-TDEA-128 */
4483 case 0x0b: /* KM-Encrypted-TDEA-192 */
4484 case 0x12: /* KM-AES-128 */
4485 case 0x13: /* KM-AES-192 */
4486 case 0x14: /* KM-AES-256 */
4487 case 0x1a: /* KM-Encrypted-AES-128 */
4488 case 0x1b: /* KM-Encrypted-AES-192 */
4489 case 0x1c: /* KM-Encrypted-AES-256 */
4492 case 0x32: /* KM-XTS-AES-128 */
4493 if (record_full_arch_list_add_mem (oaddr + 0x10, 16))
4497 case 0x34: /* KM-XTS-AES-256 */
4498 if (record_full_arch_list_add_mem (oaddr + 0x20, 16))
4502 case 0x3a: /* KM-XTS-Encrypted-AES-128 */
4503 if (record_full_arch_list_add_mem (oaddr + 0x30, 16))
4507 case 0x3c: /* KM-XTS-Encrypted-AES-256 */
4508 if (record_full_arch_list_add_mem (oaddr + 0x40, 16))
4513 fprintf_unfiltered (gdb_stdlog, "Warning: Unknown KM function %02x at %s.\n",
4514 (int)tmp, paddress (gdbarch, addr));
4519 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + inib[6], &tmp);
4520 oaddr2 = s390_record_address_mask (gdbarch, regcache, tmp);
4521 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + (inib[7] | 1), &tmp);
4522 if (record_full_arch_list_add_mem (oaddr2, tmp))
4524 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
4526 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[7]))
4528 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[7] | 1)))
4531 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4535 /* 0xb932-0xb93b undefined */
4537 case 0xb93c: /* PPNO - perform pseudorandom number operation [partial] */
4538 regcache_raw_read_unsigned (regcache, S390_R1_REGNUM, &tmp);
4539 oaddr = s390_record_address_mask (gdbarch, regcache, tmp);
4540 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM, &tmp);
4544 case 0x00: /* PPNO-Query */
4545 case 0x80: /* PPNO-Query */
4546 if (record_full_arch_list_add_mem (oaddr, 16))
4550 case 0x03: /* PPNO-SHA-512-DRNG - generate */
4551 if (record_full_arch_list_add_mem (oaddr, 240))
4553 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + inib[6], &tmp);
4554 oaddr2 = s390_record_address_mask (gdbarch, regcache, tmp);
4555 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + (inib[6] | 1), &tmp);
4556 if (record_full_arch_list_add_mem (oaddr2, tmp))
4558 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
4560 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[6] | 1)))
4564 case 0x83: /* PPNO-SHA-512-DRNG - seed */
4565 if (record_full_arch_list_add_mem (oaddr, 240))
4567 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[7]))
4569 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[7] | 1)))
4574 fprintf_unfiltered (gdb_stdlog, "Warning: Unknown PPNO function %02x at %s.\n",
4575 (int)tmp, paddress (gdbarch, addr));
4578 /* DXC may be written */
4579 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
4581 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4585 /* 0xb93d undefined */
4587 case 0xb93e: /* KIMD - compute intermediate message digest [partial] */
4588 case 0xb93f: /* KLMD - compute last message digest [partial] */
4589 regcache_raw_read_unsigned (regcache, S390_R1_REGNUM, &tmp);
4590 oaddr = s390_record_address_mask (gdbarch, regcache, tmp);
4591 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM, &tmp);
4595 case 0x00: /* K*MD-Query */
4596 if (record_full_arch_list_add_mem (oaddr, 16))
4600 case 0x01: /* K*MD-SHA-1 */
4601 if (record_full_arch_list_add_mem (oaddr, 20))
4605 case 0x02: /* K*MD-SHA-256 */
4606 if (record_full_arch_list_add_mem (oaddr, 32))
4610 case 0x03: /* K*MD-SHA-512 */
4611 if (record_full_arch_list_add_mem (oaddr, 64))
4615 case 0x41: /* KIMD-GHASH */
4616 /* Only valid for KIMD. */
4617 if (insn[0] == 0xb93e)
4619 if (record_full_arch_list_add_mem (oaddr, 16))
4623 /* For KLMD, fallthru. */
4625 fprintf_unfiltered (gdb_stdlog, "Warning: Unknown KMAC function %02x at %s.\n",
4626 (int)tmp, paddress (gdbarch, addr));
4631 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[7]))
4633 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[7] | 1)))
4636 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4640 /* 0xb940 undefined */
4641 /* 0xb944-0xb945 undefined */
4642 /* 0xb947-0xb948 undefined */
4643 /* 0xb94c-0xb950 undefined */
4644 /* 0xb954-0xb958 undefined */
4645 /* 0xb95c-0xb95f undefined */
4646 /* 0xb962-0xb971 undefined */
4647 /* 0xb974-0xb97f undefined */
4649 case 0xb983: /* FLOGR - find leftmost one */
4650 /* 64-bit gpr pair destination + flags */
4651 if (s390_record_gpr_g (gdbarch, regcache, inib[6]))
4653 if (s390_record_gpr_g (gdbarch, regcache, inib[6] | 1))
4655 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4659 /* 0xb98a privileged */
4660 /* 0xb98b-0xb98c undefined */
4662 case 0xb98d: /* EPSW - extract psw */
4663 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
4666 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[7]))
4670 /* 0xb98e-0xb98f privileged */
4672 case 0xb990: /* TRTT - translate two to two [partial] */
4673 case 0xb991: /* TRTO - translate two to one [partial] */
4674 case 0xb992: /* TROT - translate one to two [partial] */
4675 case 0xb993: /* TROO - translate one to one [partial] */
4676 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + inib[6], &tmp);
4677 oaddr = s390_record_address_mask (gdbarch, regcache, tmp);
4678 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + (inib[6] | 1), &tmp);
4679 /* tmp is source length, we want destination length. Adjust. */
4680 if (insn[0] == 0xb991)
4682 if (insn[0] == 0xb992)
4684 if (record_full_arch_list_add_mem (oaddr, tmp))
4686 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
4688 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[6] | 1)))
4690 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[7]))
4692 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4696 case 0xb996: /* MLR - multiply logical */
4697 case 0xb997: /* DLR - divide logical */
4698 /* 32-bit gpr pair destination */
4699 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
4701 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[6] | 1)))
4705 /* 0xb99a-0xb9af unsupported, privileged, or undefined */
4706 /* 0xb9b4-0xb9bc undefined */
4708 case 0xb9bd: /* TRTRE - translate and test reverse extended [partial] */
4709 case 0xb9bf: /* TRTE - translate and test extended [partial] */
4710 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
4712 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[6] | 1)))
4714 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[7]))
4716 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4720 /* 0xb9c0-0xb9c7 undefined */
4722 case 0xb9c8: /* AHHHR - add high */
4723 case 0xb9c9: /* SHHHR - subtract high */
4724 case 0xb9ca: /* ALHHHR - add logical high */
4725 case 0xb9cb: /* SLHHHR - subtract logical high */
4726 case 0xb9d8: /* AHHLR - add high */
4727 case 0xb9d9: /* SHHLR - subtract high */
4728 case 0xb9da: /* ALHHLR - add logical high */
4729 case 0xb9db: /* SLHHLR - subtract logical high */
4730 /* 32-bit high gpr destination + flags */
4731 if (s390_record_gpr_h (gdbarch, regcache, inib[6]))
4733 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4737 /* 0xb9cc undefined */
4738 /* 0xb9ce undefined */
4739 /* 0xb9d0-0xb9d7 undefined */
4740 /* 0xb9dc undefined */
4741 /* 0xb9de undefined */
4743 case 0xb9e0: /* LOCFHR - load high on condition */
4744 /* 32-bit high gpr destination */
4745 if (s390_record_gpr_h (gdbarch, regcache, inib[6]))
4749 /* 0xb9e3 undefined */
4750 /* 0xb9e5 undefined */
4751 /* 0xb9ee-0xb9f1 undefined */
4752 /* 0xb9f3 undefined */
4753 /* 0xb9f5 undefined */
4754 /* 0xb9fc undefined */
4755 /* 0xb9fe -0xb9ff undefined */
4762 /* 0xb4-0xb5 undefined */
4763 /* 0xb6 privileged: STCTL - store control */
4764 /* 0xb7 privileged: LCTL - load control */
4765 /* 0xb8 undefined */
4767 case 0xba: /* CS - compare and swap */
4768 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
4769 if (record_full_arch_list_add_mem (oaddr, 4))
4771 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
4773 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4777 case 0xbb: /* CDS - compare double and swap */
4778 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
4779 if (record_full_arch_list_add_mem (oaddr, 8))
4781 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
4783 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[2] | 1)))
4785 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4789 /* 0xbc undefined */
4791 case 0xbe: /* STCM - store characters under mask */
4792 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
4793 if (record_full_arch_list_add_mem (oaddr, s390_popcnt (inib[3])))
4802 /* RIL-format instruction */
4803 switch (ibyte[0] << 4 | inib[3])
4805 case 0xc00: /* LARL - load address relative long */
4806 case 0xc05: /* BRASL - branch relative and save long */
4807 case 0xc09: /* IILF - insert immediate */
4808 case 0xc21: /* MSFI - multiply single immediate */
4809 case 0xc42: /* LLHRL - load logical halfword relative long */
4810 case 0xc45: /* LHRL - load halfword relative long */
4811 case 0xc4d: /* LRL - load relative long */
4812 /* 32-bit or native gpr destination */
4813 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
4817 case 0xc01: /* LGFI - load immediate */
4818 case 0xc0e: /* LLIHF - load logical immediate */
4819 case 0xc0f: /* LLILF - load logical immediate */
4820 case 0xc20: /* MSGFI - multiply single immediate */
4821 case 0xc44: /* LGHRL - load halfword relative long */
4822 case 0xc46: /* LLGHRL - load logical halfword relative long */
4823 case 0xc48: /* LGRL - load relative long */
4824 case 0xc4c: /* LGFRL - load relative long */
4825 case 0xc4e: /* LLGFRL - load logical relative long */
4826 /* 64-bit gpr destination */
4827 if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
4831 /* 0xc02-0xc03 undefined */
4833 case 0xc04: /* BRCL - branch relative on condition long */
4834 case 0xc62: /* PFDRL - prefetch data relative long */
4837 case 0xc06: /* XIHF - xor immediate */
4838 case 0xc0a: /* NIHF - and immediate */
4839 case 0xc0c: /* OIHF - or immediate */
4840 case 0xcc8: /* AIH - add immediate high */
4841 case 0xcca: /* ALSIH - add logical with signed immediate high */
4842 /* 32-bit high gpr destination + flags */
4843 if (s390_record_gpr_h (gdbarch, regcache, inib[2]))
4845 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4849 case 0xc07: /* XILF - xor immediate */
4850 case 0xc0b: /* NILF - and immediate */
4851 case 0xc0d: /* OILF - or immediate */
4852 case 0xc25: /* SLFI - subtract logical immediate */
4853 case 0xc29: /* AFI - add immediate */
4854 case 0xc2b: /* ALFI - add logical immediate */
4855 /* 32-bit gpr destination + flags */
4856 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
4858 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4862 case 0xc08: /* IIHF - insert immediate */
4863 case 0xcc6: /* BRCTH - branch relative on count high */
4864 case 0xccb: /* ALSIHN - add logical with signed immediate high */
4865 /* 32-bit high gpr destination */
4866 if (s390_record_gpr_h (gdbarch, regcache, inib[2]))
4870 /* 0xc22-0xc23 undefined */
4872 case 0xc24: /* SLGFI - subtract logical immediate */
4873 case 0xc28: /* AGFI - add immediate */
4874 case 0xc2a: /* ALGFI - add logical immediate */
4875 /* 64-bit gpr destination + flags */
4876 if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
4878 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4882 /* 0xc26-0xc27 undefined */
4884 case 0xc2c: /* CGFI - compare immediate */
4885 case 0xc2d: /* CFI - compare immediate */
4886 case 0xc2e: /* CLGFI - compare logical immediate */
4887 case 0xc2f: /* CLFI - compare logical immediate */
4888 case 0xc64: /* CGHRL - compare halfword relative long */
4889 case 0xc65: /* CHRL - compare halfword relative long */
4890 case 0xc66: /* CLGHRL - compare logical halfword relative long */
4891 case 0xc67: /* CLHRL - compare logical halfword relative long */
4892 case 0xc68: /* CGRL - compare relative long */
4893 case 0xc6a: /* CLGRL - compare logical relative long */
4894 case 0xc6c: /* CGFRL - compare relative long */
4895 case 0xc6d: /* CRL - compare relative long */
4896 case 0xc6e: /* CLGFRL - compare logical relative long */
4897 case 0xc6f: /* CLRL - compare logical relative long */
4898 case 0xccd: /* CIH - compare immediate high */
4899 case 0xccf: /* CLIH - compare logical immediate high */
4901 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4905 /* 0xc40-0xc41 undefined */
4906 /* 0xc43 undefined */
4908 case 0xc47: /* STHRL - store halfword relative long */
4909 oaddr = s390_record_calc_rl (gdbarch, regcache, addr, insn[1], insn[2]);
4910 if (record_full_arch_list_add_mem (oaddr, 2))
4914 /* 0xc49-0xc4a undefined */
4916 case 0xc4b: /* STGRL - store relative long */
4917 oaddr = s390_record_calc_rl (gdbarch, regcache, addr, insn[1], insn[2]);
4918 if (record_full_arch_list_add_mem (oaddr, 8))
4922 case 0xc4f: /* STRL - store relative long */
4923 oaddr = s390_record_calc_rl (gdbarch, regcache, addr, insn[1], insn[2]);
4924 if (record_full_arch_list_add_mem (oaddr, 4))
4928 case 0xc60: /* EXRL - execute relative long */
4931 fprintf_unfiltered (gdb_stdlog, "Warning: Double execute at %s.\n",
4932 paddress (gdbarch, addr));
4935 addr = s390_record_calc_rl (gdbarch, regcache, addr, insn[1], insn[2]);
4938 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + inib[2], &tmp);
4947 /* 0xc61 undefined */
4948 /* 0xc63 undefined */
4949 /* 0xc69 undefined */
4950 /* 0xc6b undefined */
4951 /* 0xcc0-0xcc5 undefined */
4952 /* 0xcc7 undefined */
4953 /* 0xcc9 undefined */
4954 /* 0xccc undefined */
4955 /* 0xcce undefined */
4962 /* 0xc1 undefined */
4963 /* 0xc3 undefined */
4965 case 0xc5: /* BPRP - branch prediction relative preload */
4966 case 0xc7: /* BPP - branch prediction preload */
4967 /* no visible effect */
4971 /* SSF-format instruction */
4972 switch (ibyte[0] << 4 | inib[3])
4974 /* 0xc80 unsupported */
4976 case 0xc81: /* ECTG - extract cpu time */
4977 if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
4979 if (s390_record_gpr_g (gdbarch, regcache, 0))
4981 if (s390_record_gpr_g (gdbarch, regcache, 1))
4985 case 0xc82: /* CSST - compare and swap and store */
4988 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM, &tmp);
4990 sc = tmp >> 8 & 0xff;
4992 /* First and third operands. */
4993 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
4996 case 0x00: /* 32-bit */
4997 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
4999 if (record_full_arch_list_add_mem (oaddr, 4))
5003 case 0x01: /* 64-bit */
5004 if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
5006 if (record_full_arch_list_add_mem (oaddr, 8))
5010 case 0x02: /* 128-bit */
5011 if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
5013 if (s390_record_gpr_g (gdbarch, regcache, inib[2] | 1))
5015 if (record_full_arch_list_add_mem (oaddr, 16))
5020 fprintf_unfiltered (gdb_stdlog, "Warning: Unknown CSST FC %02x at %s.\n",
5021 fc, paddress (gdbarch, addr));
5025 /* Second operand. */
5026 oaddr2 = s390_record_calc_disp (gdbarch, regcache, 0, insn[2], 0);
5029 fprintf_unfiltered (gdb_stdlog, "Warning: Unknown CSST FC %02x at %s.\n",
5030 sc, paddress (gdbarch, addr));
5034 if (record_full_arch_list_add_mem (oaddr2, 1 << sc))
5038 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
5043 /* 0xc83 undefined */
5045 case 0xc84: /* LPD - load pair disjoint */
5046 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
5048 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[2] | 1)))
5050 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
5054 case 0xc85: /* LPDG - load pair disjoint */
5055 if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
5057 if (s390_record_gpr_g (gdbarch, regcache, inib[2] | 1))
5059 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
5063 /* 0xc86-0xc8f undefined */
5070 /* 0xc9-0xcb undefined */
5071 /* 0xcd-0xcf undefined */
5073 case 0xd0: /* TRTR - translate and test reversed */
5074 case 0xdd: /* TRT - translate and test */
5075 if (record_full_arch_list_add_reg (regcache, S390_R1_REGNUM))
5077 if (record_full_arch_list_add_reg (regcache, S390_R2_REGNUM))
5079 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
5083 case 0xd1: /* MVN - move numbers */
5084 case 0xd2: /* MVC - move */
5085 case 0xd3: /* MVZ - move zones */
5086 case 0xdc: /* TR - translate */
5087 case 0xe8: /* MVCIN - move inverse */
5088 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
5089 if (record_full_arch_list_add_mem (oaddr, ibyte[1] + 1))
5093 case 0xd4: /* NC - and */
5094 case 0xd6: /* OC - or*/
5095 case 0xd7: /* XC - xor */
5096 case 0xe2: /* UNPKU - unpack unicode */
5097 case 0xea: /* UNPKA - unpack ASCII */
5098 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
5099 if (record_full_arch_list_add_mem (oaddr, ibyte[1] + 1))
5101 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
5105 case 0xde: /* ED - edit */
5106 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
5107 if (record_full_arch_list_add_mem (oaddr, ibyte[1] + 1))
5109 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
5111 /* DXC may be written */
5112 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
5116 case 0xdf: /* EDMK - edit and mark */
5117 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
5118 if (record_full_arch_list_add_mem (oaddr, ibyte[1] + 1))
5120 if (record_full_arch_list_add_reg (regcache, S390_R1_REGNUM))
5122 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
5124 /* DXC may be written */
5125 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
5129 /* 0xd8 undefined */
5130 /* 0xd9 unsupported: MVCK - move with key */
5131 /* 0xda unsupported: MVCP - move to primary */
5132 /* 0xdb unsupported: MVCS - move to secondary */
5133 /* 0xe0 undefined */
5135 case 0xe1: /* PKU - pack unicode */
5136 case 0xe9: /* PKA - pack ASCII */
5137 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
5138 if (record_full_arch_list_add_mem (oaddr, 16))
5147 /* RXY/RXE/RXF/RSL/RSY/SIY/V*-format instruction */
5148 switch (ibyte[0] << 8 | ibyte[5])
5150 /* 0xe300-0xe301 undefined */
5152 case 0xe302: /* LTG - load and test */
5153 case 0xe308: /* AG - add */
5154 case 0xe309: /* SG - subtract */
5155 case 0xe30a: /* ALG - add logical */
5156 case 0xe30b: /* SLG - subtract logical */
5157 case 0xe318: /* AGF - add */
5158 case 0xe319: /* SGF - subtract */
5159 case 0xe31a: /* ALGF - add logical */
5160 case 0xe31b: /* SLGF - subtract logical */
5161 case 0xe332: /* LTGF - load and test */
5162 case 0xe380: /* NG - and */
5163 case 0xe381: /* OG - or */
5164 case 0xe382: /* XG - xor */
5165 case 0xe388: /* ALCG - add logical with carry */
5166 case 0xe389: /* SLBG - subtract logical with borrow */
5167 case 0xeb0a: /* SRAG - shift right single */
5168 case 0xeb0b: /* SLAG - shift left single */
5169 /* 64-bit gpr destination + flags */
5170 if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
5172 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
5176 /* 0xe303 privileged */
5178 case 0xe304: /* LG - load */
5179 case 0xe30c: /* MSG - multiply single */
5180 case 0xe30f: /* LRVG - load reversed */
5181 case 0xe314: /* LGF - load */
5182 case 0xe315: /* LGH - load halfword */
5183 case 0xe316: /* LLGF - load logical */
5184 case 0xe317: /* LLGT - load logical thirty one bits */
5185 case 0xe31c: /* MSGF - multiply single */
5186 case 0xe32a: /* LZRG - load and zero rightmost byte */
5187 case 0xe33a: /* LLZRGF - load logical and zero rightmost byte */
5188 case 0xe33c: /* MGH - multiply halfword 64x16mem -> 64 */
5189 case 0xe346: /* BCTG - branch on count */
5190 case 0xe377: /* LGB - load byte */
5191 case 0xe390: /* LLGC - load logical character */
5192 case 0xe391: /* LLGH - load logical halfword */
5193 case 0xeb0c: /* SRLG - shift right single logical */
5194 case 0xeb0d: /* SLLG - shift left single logical */
5195 case 0xeb1c: /* RLLG - rotate left single logical */
5196 case 0xeb44: /* BXHG - branch on index high */
5197 case 0xeb45: /* BXLEG - branch on index low or equal */
5198 case 0xeb4c: /* ECAG - extract cpu attribute */
5199 case 0xebe2: /* LOCG - load on condition */
5200 /* 64-bit gpr destination */
5201 if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
5205 /* 0xe305 undefined */
5207 case 0xe306: /* CVBY - convert to binary */
5208 /* 32-bit or native gpr destination + FPC (DXC write) */
5209 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
5211 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
5215 /* 0xe307 undefined */
5217 case 0xe30d: /* DSG - divide single */
5218 case 0xe31d: /* DSGF - divide single */
5219 case 0xe384: /* MG - multiply 64x64mem -> 128 */
5220 case 0xe386: /* MLG - multiply logical */
5221 case 0xe387: /* DLG - divide logical */
5222 case 0xe38f: /* LPQ - load pair from quadword */
5223 /* 64-bit gpr pair destination */
5224 if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
5226 if (s390_record_gpr_g (gdbarch, regcache, inib[2] | 1))
5230 case 0xe30e: /* CVBG - convert to binary */
5231 /* 64-bit gpr destination + FPC (DXC write) */
5232 if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
5234 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
5238 /* 0xe310-0xe311 undefined */
5240 case 0xe312: /* LT - load and test */
5241 case 0xe338: /* AGH - add halfword to 64 bit value */
5242 case 0xe339: /* SGH - subtract halfword from 64 bit value */
5243 case 0xe353: /* MSC - multiply single 32x32mem -> 32 */
5244 case 0xe354: /* NY - and */
5245 case 0xe356: /* OY - or */
5246 case 0xe357: /* XY - xor */
5247 case 0xe35a: /* AY - add */
5248 case 0xe35b: /* SY - subtract */
5249 case 0xe35e: /* ALY - add logical */
5250 case 0xe35f: /* SLY - subtract logical */
5251 case 0xe37a: /* AHY - add halfword */
5252 case 0xe37b: /* SHY - subtract halfword */
5253 case 0xe383: /* MSGC - multiply single 64x64mem -> 64 */
5254 case 0xe398: /* ALC - add logical with carry */
5255 case 0xe399: /* SLB - subtract logical with borrow */
5256 case 0xe727: /* LCBB - load count to block bounduary */
5257 case 0xeb81: /* ICMY - insert characters under mask */
5258 case 0xebdc: /* SRAK - shift left single */
5259 case 0xebdd: /* SLAK - shift left single */
5260 /* 32/64-bit gpr destination + flags */
5261 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
5263 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
5267 /* 0xe313 privileged */
5269 case 0xe31e: /* LRV - load reversed */
5270 case 0xe31f: /* LRVH - load reversed */
5271 case 0xe33b: /* LZRF - load and zero rightmost byte */
5272 case 0xe351: /* MSY - multiply single */
5273 case 0xe358: /* LY - load */
5274 case 0xe371: /* LAY - load address */
5275 case 0xe373: /* ICY - insert character */
5276 case 0xe376: /* LB - load byte */
5277 case 0xe378: /* LHY - load */
5278 case 0xe37c: /* MHY - multiply halfword */
5279 case 0xe394: /* LLC - load logical character */
5280 case 0xe395: /* LLH - load logical halfword */
5281 case 0xeb1d: /* RLL - rotate left single logical */
5282 case 0xebde: /* SRLK - shift left single logical */
5283 case 0xebdf: /* SLLK - shift left single logical */
5284 case 0xebf2: /* LOC - load on condition */
5285 /* 32-bit or native gpr destination */
5286 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
5290 case 0xe320: /* CG - compare */
5291 case 0xe321: /* CLG - compare logical */
5292 case 0xe330: /* CGF - compare */
5293 case 0xe331: /* CLGF - compare logical */
5294 case 0xe334: /* CGH - compare halfword */
5295 case 0xe355: /* CLY - compare logical */
5296 case 0xe359: /* CY - compare */
5297 case 0xe379: /* CHY - compare halfword */
5298 case 0xe3cd: /* CHF - compare high */
5299 case 0xe3cf: /* CLHF - compare logical high */
5300 case 0xeb20: /* CLMH - compare logical under mask high */
5301 case 0xeb21: /* CLMY - compare logical under mask */
5302 case 0xeb51: /* TMY - test under mask */
5303 case 0xeb55: /* CLIY - compare logical */
5304 case 0xebc0: /* TP - test decimal */
5305 case 0xed10: /* TCEB - test data class */
5306 case 0xed11: /* TCDB - test data class */
5307 case 0xed12: /* TCXB - test data class */
5308 case 0xed50: /* TDCET - test data class */
5309 case 0xed51: /* TDGET - test data group */
5310 case 0xed54: /* TDCDT - test data class */
5311 case 0xed55: /* TDGDT - test data group */
5312 case 0xed58: /* TDCXT - test data class */
5313 case 0xed59: /* TDGXT - test data group */
5315 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
5319 /* 0xe322-0xe323 undefined */
5321 case 0xe324: /* STG - store */
5322 case 0xe325: /* NTSTG - nontransactional store */
5323 case 0xe326: /* CVDY - convert to decimal */
5324 case 0xe32f: /* STRVG - store reversed */
5325 case 0xebe3: /* STOCG - store on condition */
5326 case 0xed67: /* STDY - store */
5327 oaddr = s390_record_calc_disp (gdbarch, regcache, inib[3], insn[1], ibyte[4]);
5328 if (record_full_arch_list_add_mem (oaddr, 8))
5332 /* 0xe327-0xe329 undefined */
5333 /* 0xe32b-0xe32d undefined */
5335 case 0xe32e: /* CVDG - convert to decimal */
5336 case 0xe38e: /* STPQ - store pair to quadword */
5337 oaddr = s390_record_calc_disp (gdbarch, regcache, inib[3], insn[1], ibyte[4]);
5338 if (record_full_arch_list_add_mem (oaddr, 16))
5342 /* 0xe333 undefined */
5343 /* 0xe335 undefined */
5345 case 0xe336: /* PFD - prefetch data */
5348 /* 0xe337 undefined */
5349 /* 0xe33c-0xe33d undefined */
5351 case 0xe33e: /* STRV - store reversed */
5352 case 0xe350: /* STY - store */
5353 case 0xe3cb: /* STFH - store high */
5354 case 0xebe1: /* STOCFH - store high on condition */
5355 case 0xebf3: /* STOC - store on condition */
5356 case 0xed66: /* STEY - store */
5357 oaddr = s390_record_calc_disp (gdbarch, regcache, inib[3], insn[1], ibyte[4]);
5358 if (record_full_arch_list_add_mem (oaddr, 4))
5362 case 0xe33f: /* STRVH - store reversed */
5363 case 0xe370: /* STHY - store halfword */
5364 case 0xe3c7: /* STHH - store halfword high */
5365 oaddr = s390_record_calc_disp (gdbarch, regcache, inib[3], insn[1], ibyte[4]);
5366 if (record_full_arch_list_add_mem (oaddr, 2))
5370 /* 0xe340-0xe345 undefined */
5372 case 0xe347: /* BIC - branch indirect on condition */
5375 /* 0xe348-0xe34f undefined */
5376 /* 0xe352 undefined */
5378 case 0xe35c: /* MFY - multiply */
5379 case 0xe396: /* ML - multiply logical */
5380 case 0xe397: /* DL - divide logical */
5381 /* 32-bit gpr pair destination */
5382 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
5384 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[2] | 1)))
5388 /* 0xe35d undefined */
5389 /* 0xe360-0xe36f undefined */
5391 case 0xe372: /* STCY - store character */
5392 case 0xe3c3: /* STCH - store character high */
5393 oaddr = s390_record_calc_disp (gdbarch, regcache, inib[3], insn[1], ibyte[4]);
5394 if (record_full_arch_list_add_mem (oaddr, 1))
5398 /* 0xe374 undefined */
5400 case 0xe375: /* LAEY - load address extended */
5401 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
5403 if (record_full_arch_list_add_reg (regcache, S390_A0_REGNUM + inib[2]))
5407 /* 0xe37d-0xe37f undefined */
5409 case 0xe385: /* LGAT - load and trap */
5410 case 0xe39c: /* LLGTAT - load logical thirty one bits and trap */
5411 case 0xe39d: /* LLGFAT - load logical and trap */
5412 case 0xe650: /* VCVB - vector convert to binary 32 bit*/
5413 case 0xe652: /* VCVBG - vector convert to binary 64 bit*/
5414 case 0xe721: /* VLGV - vector load gr from vr element */
5415 /* 64-bit gpr destination + fpc for possible DXC write */
5416 if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
5418 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
5422 /* 0xe38a-0xe38d undefined */
5423 /* 0xe392-0xe393 undefined */
5424 /* 0xe39a-0xe39b undefined */
5425 /* 0xe39e undefined */
5427 case 0xe39f: /* LAT - load and trap */
5428 /* 32-bit gpr destination + fpc for possible DXC write */
5429 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
5431 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
5435 /* 0xe3a0-0xe3bf undefined */
5437 case 0xe3c0: /* LBH - load byte high */
5438 case 0xe3c2: /* LLCH - load logical character high */
5439 case 0xe3c4: /* LHH - load halfword high */
5440 case 0xe3c6: /* LLHH - load logical halfword high */
5441 case 0xe3ca: /* LFH - load high */
5442 case 0xebe0: /* LOCFH - load high on condition */
5443 /* 32-bit high gpr destination */
5444 if (s390_record_gpr_h (gdbarch, regcache, inib[2]))
5448 /* 0xe3c1 undefined */
5449 /* 0xe3c5 undefined */
5451 case 0xe3c8: /* LFHAT - load high and trap */
5452 /* 32-bit high gpr destination + fpc for possible DXC write */
5453 if (s390_record_gpr_h (gdbarch, regcache, inib[2]))
5455 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
5459 /* 0xe3c9 undefined */
5460 /* 0xe3cc undefined */
5461 /* 0xe3ce undefined */
5462 /* 0xe3d0-0xe3ff undefined */
5464 case 0xe634: /* VPKZ - vector pack zoned */
5465 case 0xe635: /* VLRL - vector load rightmost with immed. length */
5466 case 0xe637: /* VLRLR - vector load rightmost with length */
5467 case 0xe649: /* VLIP - vector load immediate decimal */
5468 case 0xe700: /* VLEB - vector load element */
5469 case 0xe701: /* VLEH - vector load element */
5470 case 0xe702: /* VLEG - vector load element */
5471 case 0xe703: /* VLEF - vector load element */
5472 case 0xe704: /* VLLEZ - vector load logical element and zero */
5473 case 0xe705: /* VLREP - vector load and replicate */
5474 case 0xe706: /* VL - vector load */
5475 case 0xe707: /* VLBB - vector load to block bounduary */
5476 case 0xe712: /* VGEG - vector gather element */
5477 case 0xe713: /* VGEF - vector gather element */
5478 case 0xe722: /* VLVG - vector load vr element from gr */
5479 case 0xe730: /* VESL - vector element shift left */
5480 case 0xe733: /* VERLL - vector element rotate left logical */
5481 case 0xe737: /* VLL - vector load with length */
5482 case 0xe738: /* VESRL - vector element shift right logical */
5483 case 0xe73a: /* VESRA - vector element shift right arithmetic */
5484 case 0xe740: /* VLEIB - vector load element immediate */
5485 case 0xe741: /* VLEIH - vector load element immediate */
5486 case 0xe742: /* VLEIG - vector load element immediate */
5487 case 0xe743: /* VLEIF - vector load element immediate */
5488 case 0xe744: /* VGBM - vector generate byte mask */
5489 case 0xe745: /* VREPI - vector replicate immediate */
5490 case 0xe746: /* VGM - vector generate mask */
5491 case 0xe74d: /* VREP - vector replicate */
5492 case 0xe750: /* VPOPCT - vector population count */
5493 case 0xe752: /* VCTZ - vector count trailing zeros */
5494 case 0xe753: /* VCLZ - vector count leading zeros */
5495 case 0xe756: /* VLR - vector load */
5496 case 0xe75f: /* VSEG -vector sign extend to doubleword */
5497 case 0xe760: /* VMRL - vector merge low */
5498 case 0xe761: /* VMRH - vector merge high */
5499 case 0xe762: /* VLVGP - vector load vr from grs disjoint */
5500 case 0xe764: /* VSUM - vector sum across word */
5501 case 0xe765: /* VSUMG - vector sum across doubleword */
5502 case 0xe766: /* VCKSM - vector checksum */
5503 case 0xe767: /* VSUMQ - vector sum across quadword */
5504 case 0xe768: /* VN - vector and */
5505 case 0xe769: /* VNC - vector and with complement */
5506 case 0xe76a: /* VO - vector or */
5507 case 0xe76b: /* VNO - vector nor */
5508 case 0xe76c: /* VNX - vector not exclusive or */
5509 case 0xe76d: /* VX - vector xor */
5510 case 0xe76e: /* VNN - vector nand */
5511 case 0xe76f: /* VOC - vector or with complement */
5512 case 0xe770: /* VESLV - vector element shift left */
5513 case 0xe772: /* VERIM - vector element rotate and insert under mask */
5514 case 0xe773: /* VERLLV - vector element rotate left logical */
5515 case 0xe774: /* VSL - vector shift left */
5516 case 0xe775: /* VSLB - vector shift left by byte */
5517 case 0xe777: /* VSLDB - vector shift left double by byte */
5518 case 0xe778: /* VESRLV - vector element shift right logical */
5519 case 0xe77a: /* VESRAV - vector element shift right arithmetic */
5520 case 0xe77c: /* VSRL - vector shift right logical */
5521 case 0xe77d: /* VSRLB - vector shift right logical by byte */
5522 case 0xe77e: /* VSRA - vector shift right arithmetic */
5523 case 0xe77f: /* VSRAB - vector shift right arithmetic by byte */
5524 case 0xe784: /* VPDI - vector permute doubleword immediate */
5525 case 0xe785: /* VBPERM - vector bit permute */
5526 case 0xe78c: /* VPERM - vector permute */
5527 case 0xe78d: /* VSEL - vector select */
5528 case 0xe78e: /* VFMS - vector fp multiply and subtract */
5529 case 0xe78f: /* VFMA - vector fp multiply and add */
5530 case 0xe794: /* VPK - vector pack */
5531 case 0xe79e: /* VFNMS - vector fp negative multiply and subtract */
5532 case 0xe79f: /* VFNMA - vector fp negative multiply and add */
5533 case 0xe7a1: /* VMLH - vector multiply logical high */
5534 case 0xe7a2: /* VML - vector multiply low */
5535 case 0xe7a3: /* VMH - vector multiply high */
5536 case 0xe7a4: /* VMLE - vector multiply logical even */
5537 case 0xe7a5: /* VMLO - vector multiply logical odd */
5538 case 0xe7a6: /* VME - vector multiply even */
5539 case 0xe7a7: /* VMO - vector multiply odd */
5540 case 0xe7a9: /* VMALH - vector multiply and add logical high */
5541 case 0xe7aa: /* VMAL - vector multiply and add low */
5542 case 0xe7ab: /* VMAH - vector multiply and add high */
5543 case 0xe7ac: /* VMALE - vector multiply and add logical even */
5544 case 0xe7ad: /* VMALO - vector multiply and add logical odd */
5545 case 0xe7ae: /* VMAE - vector multiply and add even */
5546 case 0xe7af: /* VMAO - vector multiply and add odd */
5547 case 0xe7b4: /* VGFM - vector Galois field multiply sum */
5548 case 0xe7b8: /* VMSL - vector multiply sum logical */
5549 case 0xe7b9: /* VACCC - vector add with carry compute carry */
5550 case 0xe7bb: /* VAC - vector add with carry */
5551 case 0xe7bc: /* VGFMA - vector Galois field multiply sum and accumulate */
5552 case 0xe7bd: /* VSBCBI - vector subtract with borrow compute borrow indication */
5553 case 0xe7bf: /* VSBI - vector subtract with borrow indication */
5554 case 0xe7c0: /* VCLGD - vector convert to logical 64-bit */
5555 case 0xe7c1: /* VCDLG - vector convert from logical 64-bit */
5556 case 0xe7c2: /* VCGD - vector convert to fixed 64-bit */
5557 case 0xe7c3: /* VCDG - vector convert from fixed 64-bit */
5558 case 0xe7c4: /* VLDE/VFLL - vector fp load lengthened */
5559 case 0xe7c5: /* VLED/VFLR - vector fp load rounded */
5560 case 0xe7c7: /* VFI - vector load fp integer */
5561 case 0xe7cc: /* VFPSO - vector fp perform sign operation */
5562 case 0xe7ce: /* VFSQ - vector fp square root */
5563 case 0xe7d4: /* VUPLL - vector unpack logical low */
5564 case 0xe7d6: /* VUPL - vector unpack low */
5565 case 0xe7d5: /* VUPLH - vector unpack logical high */
5566 case 0xe7d7: /* VUPH - vector unpack high */
5567 case 0xe7de: /* VLC - vector load complement */
5568 case 0xe7df: /* VLP - vector load positive */
5569 case 0xe7e2: /* VFA - vector fp subtract */
5570 case 0xe7e3: /* VFA - vector fp add */
5571 case 0xe7e5: /* VFD - vector fp divide */
5572 case 0xe7e7: /* VFM - vector fp multiply */
5573 case 0xe7ee: /* VFMIN - vector fp minimum */
5574 case 0xe7ef: /* VFMAX - vector fp maximum */
5575 case 0xe7f0: /* VAVGL - vector average logical */
5576 case 0xe7f1: /* VACC - vector add and compute carry */
5577 case 0xe7f2: /* VAVG - vector average */
5578 case 0xe7f3: /* VA - vector add */
5579 case 0xe7f5: /* VSCBI - vector subtract compute borrow indication */
5580 case 0xe7f7: /* VS - vector subtract */
5581 case 0xe7fc: /* VMNL - vector minimum logical */
5582 case 0xe7fd: /* VMXL - vector maximum logical */
5583 case 0xe7fe: /* VMN - vector minimum */
5584 case 0xe7ff: /* VMX - vector maximum */
5585 /* vector destination + FPC */
5586 if (s390_record_vr (gdbarch, regcache, ivec[0]))
5588 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
5592 case 0xe63d: /* VSTRL - vector store rightmost with immed. length */
5593 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
5594 if (record_full_arch_list_add_mem (oaddr, inib[3] + 1))
5596 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
5600 case 0xe708: /* VSTEB - vector store element */
5601 oaddr = s390_record_calc_disp (gdbarch, regcache, inib[3], insn[1], 0);
5602 if (record_full_arch_list_add_mem (oaddr, 1))
5604 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
5608 case 0xe709: /* VSTEH - vector store element */
5609 oaddr = s390_record_calc_disp (gdbarch, regcache, inib[3], insn[1], 0);
5610 if (record_full_arch_list_add_mem (oaddr, 2))
5612 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
5616 case 0xe70a: /* VSTEG - vector store element */
5617 oaddr = s390_record_calc_disp (gdbarch, regcache, inib[3], insn[1], 0);
5618 if (record_full_arch_list_add_mem (oaddr, 8))
5620 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
5624 case 0xe70b: /* VSTEF - vector store element */
5625 oaddr = s390_record_calc_disp (gdbarch, regcache, inib[3], insn[1], 0);
5626 if (record_full_arch_list_add_mem (oaddr, 4))
5628 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
5632 /* 0xe70c-0xe70d undefined */
5634 case 0xe70e: /* VST - vector store */
5635 oaddr = s390_record_calc_disp (gdbarch, regcache, inib[3], insn[1], 0);
5636 if (record_full_arch_list_add_mem (oaddr, 16))
5638 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
5642 /* 0xe70f-0xe711 undefined */
5643 /* 0xe714-0xe719 undefined */
5645 case 0xe71a: /* VSCEG - vector scatter element */
5646 if (s390_record_calc_disp_vsce (gdbarch, regcache, ivec[1], inib[8], 8, insn[1], 0, &oaddr))
5648 if (record_full_arch_list_add_mem (oaddr, 8))
5650 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
5654 case 0xe71b: /* VSCEF - vector scatter element */
5655 if (s390_record_calc_disp_vsce (gdbarch, regcache, ivec[1], inib[8], 4, insn[1], 0, &oaddr))
5657 if (record_full_arch_list_add_mem (oaddr, 4))
5659 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
5663 /* 0xe71c-0xe720 undefined */
5664 /* 0xe723-0xe726 undefined */
5665 /* 0xe728-0xe72f undefined */
5666 /* 0xe731-0xe732 undefined */
5667 /* 0xe734-0xe735 undefined */
5669 case 0xe736: /* VLM - vector load multiple */
5670 for (i = ivec[0]; i != ivec[1]; i++, i &= 0x1f)
5671 if (s390_record_vr (gdbarch, regcache, i))
5673 if (s390_record_vr (gdbarch, regcache, ivec[1]))
5675 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
5679 /* 0xe739 undefined */
5680 /* 0xe73b-0xe73d undefined */
5682 case 0xe73e: /* VSTM - vector store multiple */
5683 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
5684 if (ivec[0] <= ivec[1])
5685 n = ivec[1] - ivec[0] + 1;
5687 n = ivec[1] + 0x20 - ivec[0] + 1;
5688 if (record_full_arch_list_add_mem (oaddr, n * 16))
5690 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
5694 case 0xe63c: /* VUPKZ - vector unpack zoned */
5695 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
5696 if (record_full_arch_list_add_mem (oaddr, (ibyte[1] + 1) & 31))
5698 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
5702 case 0xe63f: /* VSTRLR - vector store rightmost with length */
5703 case 0xe73f: /* VSTL - vector store with length */
5704 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
5705 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + inib[3], &tmp);
5709 if (record_full_arch_list_add_mem (oaddr, tmp + 1))
5711 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
5715 /* 0xe747-0xe749 undefined */
5717 case 0xe658: /* VCVD - vector convert to decimal 32 bit */
5718 case 0xe659: /* VSRP - vector shift and round decimal */
5719 case 0xe65a: /* VCVDG - vector convert to decimal 64 bit*/
5720 case 0xe65b: /* VPSOP - vector perform sign operation decimal */
5721 case 0xe671: /* VAP - vector add decimal */
5722 case 0xe673: /* VSP - vector subtract decimal */
5723 case 0xe678: /* VMP - vector multiply decimal */
5724 case 0xe679: /* VMSP - vector multiply decimal */
5725 case 0xe67a: /* VDP - vector divide decimal */
5726 case 0xe67b: /* VRP - vector remainder decimal */
5727 case 0xe67e: /* VSDP - vector shift and divide decimal */
5728 case 0xe74a: /* VFTCI - vector fp test data class immediate */
5729 case 0xe75c: /* VISTR - vector isolate string */
5730 case 0xe780: /* VFEE - vector find element equal */
5731 case 0xe781: /* VFENE - vector find element not equal */
5732 case 0xe782: /* VFA - vector find any element equal */
5733 case 0xe78a: /* VSTRC - vector string range compare */
5734 case 0xe795: /* VPKLS - vector pack logical saturate */
5735 case 0xe797: /* VPKS - vector pack saturate */
5736 case 0xe7e8: /* VFCE - vector fp compare equal */
5737 case 0xe7ea: /* VFCHE - vector fp compare high or equal */
5738 case 0xe7eb: /* VFCH - vector fp compare high */
5739 case 0xe7f8: /* VCEQ - vector compare equal */
5740 case 0xe7f9: /* VCHL - vector compare high logical */
5741 case 0xe7fb: /* VCH - vector compare high */
5742 /* vector destination + flags + FPC */
5743 if (s390_record_vr (gdbarch, regcache, ivec[0]))
5745 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
5747 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
5751 case 0xe65f: /* VTP - vector test decimal */
5753 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
5755 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
5759 /* 0xe74b-0xe74c undefined */
5760 /* 0xe74e-0xe74f undefined */
5761 /* 0xe751 undefined */
5762 /* 0xe754-0xe755 undefined */
5763 /* 0xe757-0xe75b undefined */
5764 /* 0xe75d-0xe75e undefined */
5765 /* 0xe763 undefined */
5766 /* 0xe771 undefined */
5767 /* 0xe776 undefined */
5768 /* 0xe779 undefined */
5769 /* 0xe77b undefined */
5770 /* 0xe783 undefined */
5771 /* 0xe786-0xe789 undefined */
5772 /* 0xe78b undefined */
5773 /* 0xe790-0xe793 undefined */
5774 /* 0xe796 undefined */
5775 /* 0xe798-0xe79d undefined */
5776 /* 0xe7a0 undefined */
5777 /* 0xe7a8 undefined */
5778 /* 0xe7b0-0xe7b3 undefined */
5779 /* 0xe7b5-0xe7b7 undefined */
5780 /* 0xe7ba undefined */
5781 /* 0xe7be undefined */
5782 /* 0xe7c6 undefined */
5783 /* 0xe7c8-0xe7c9 undefined */
5785 case 0xe677: /* VCP - vector compare decimal */
5786 case 0xe7ca: /* WFK - vector fp compare and signal scalar */
5787 case 0xe7cb: /* WFC - vector fp compare scalar */
5788 case 0xe7d8: /* VTM - vector test under mask */
5789 case 0xe7d9: /* VECL - vector element compare logical */
5790 case 0xe7db: /* VEC - vector element compare */
5791 case 0xed08: /* KEB - compare and signal */
5792 case 0xed09: /* CEB - compare */
5793 case 0xed18: /* KDB - compare and signal */
5794 case 0xed19: /* CDB - compare */
5795 /* flags + fpc only */
5796 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
5798 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
5802 /* 0xe7cd undefined */
5803 /* 0xe7cf-0xe7d3 undefined */
5804 /* 0xe7da undefined */
5805 /* 0xe7dc-0xe7dd undefined */
5806 /* 0xe7e0-0xe7e1 undefined */
5807 /* 0xe7e4 undefined */
5808 /* 0xe7e6 undefined */
5809 /* 0xe7e9 undefined */
5810 /* 0xe7ec-0xe7ed undefined */
5811 /* 0xe7f4 undefined */
5812 /* 0xe7f6 undefined */
5813 /* 0xe7fa undefined */
5815 /* 0xeb00-0xeb03 undefined */
5817 case 0xeb04: /* LMG - load multiple */
5818 for (i = inib[2]; i != inib[3]; i++, i &= 0xf)
5819 if (s390_record_gpr_g (gdbarch, regcache, i))
5821 if (s390_record_gpr_g (gdbarch, regcache, inib[3]))
5825 /* 0xeb05-0xeb09 undefined */
5826 /* 0xeb0e undefined */
5827 /* 0xeb0f privileged: TRACG */
5828 /* 0xeb10-0xeb13 undefined */
5830 case 0xeb14: /* CSY - compare and swap */
5831 case 0xebf4: /* LAN - load and and */
5832 case 0xebf6: /* LAO - load and or */
5833 case 0xebf7: /* LAX - load and xor */
5834 case 0xebf8: /* LAA - load and add */
5835 case 0xebfa: /* LAAL - load and add logical */
5836 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], ibyte[4]);
5837 if (record_full_arch_list_add_mem (oaddr, 4))
5839 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
5841 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
5845 /* 0xeb15-0xeb1b undefined */
5846 /* 0xeb1e-0xeb1f undefined */
5847 /* 0xeb22 undefined */
5849 case 0xeb23: /* CLT - compare logical and trap */
5850 case 0xeb2b: /* CLGT - compare logical and trap */
5851 /* fpc only - including possible DXC write for trapping insns */
5852 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
5856 case 0xeb24: /* STMG - store multiple */
5857 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], ibyte[4]);
5858 if (inib[2] <= inib[3])
5859 n = inib[3] - inib[2] + 1;
5861 n = inib[3] + 0x10 - inib[2] + 1;
5862 if (record_full_arch_list_add_mem (oaddr, n * 8))
5866 /* 0xeb25 privileged */
5868 case 0xeb26: /* STMH - store multiple high */
5869 case 0xeb90: /* STMY - store multiple */
5870 case 0xeb9b: /* STAMY - store access multiple */
5871 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], ibyte[4]);
5872 if (inib[2] <= inib[3])
5873 n = inib[3] - inib[2] + 1;
5875 n = inib[3] + 0x10 - inib[2] + 1;
5876 if (record_full_arch_list_add_mem (oaddr, n * 4))
5880 /* 0xeb27-0xeb2a undefined */
5882 case 0xeb2c: /* STCMH - store characters under mask */
5883 case 0xeb2d: /* STCMY - store characters under mask */
5884 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], ibyte[4]);
5885 if (record_full_arch_list_add_mem (oaddr, s390_popcnt (inib[3])))
5889 /* 0xeb2e undefined */
5890 /* 0xeb2f privileged */
5892 case 0xeb30: /* CSG - compare and swap */
5893 case 0xebe4: /* LANG - load and and */
5894 case 0xebe6: /* LAOG - load and or */
5895 case 0xebe7: /* LAXG - load and xor */
5896 case 0xebe8: /* LAAG - load and add */
5897 case 0xebea: /* LAALG - load and add logical */
5898 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], ibyte[4]);
5899 if (record_full_arch_list_add_mem (oaddr, 8))
5901 if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
5903 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
5907 case 0xeb31: /* CDSY - compare double and swap */
5908 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], ibyte[4]);
5909 if (record_full_arch_list_add_mem (oaddr, 8))
5911 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
5913 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[2] | 1)))
5915 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
5919 /* 0xeb32-0xeb3d undefined */
5921 case 0xeb3e: /* CDSG - compare double and swap */
5922 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], ibyte[4]);
5923 if (record_full_arch_list_add_mem (oaddr, 16))
5925 if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
5927 if (s390_record_gpr_g (gdbarch, regcache, inib[2] | 1))
5929 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
5933 /* 0xeb3f-0xeb43 undefined */
5934 /* 0xeb46-0xeb4b undefined */
5935 /* 0xeb4d-0xeb50 undefined */
5937 case 0xeb52: /* MVIY - move */
5938 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], ibyte[4]);
5939 if (record_full_arch_list_add_mem (oaddr, 1))
5943 case 0xeb54: /* NIY - and */
5944 case 0xeb56: /* OIY - or */
5945 case 0xeb57: /* XIY - xor */
5946 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], ibyte[4]);
5947 if (record_full_arch_list_add_mem (oaddr, 1))
5949 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
5953 /* 0xeb53 undefined */
5954 /* 0xeb58-0xeb69 undefined */
5956 case 0xeb6a: /* ASI - add immediate */
5957 case 0xeb6e: /* ALSI - add immediate */
5958 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], ibyte[4]);
5959 if (record_full_arch_list_add_mem (oaddr, 4))
5961 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
5965 /* 0xeb6b-0xeb6d undefined */
5966 /* 0xeb6f-0xeb79 undefined */
5968 case 0xeb7a: /* AGSI - add immediate */
5969 case 0xeb7e: /* ALGSI - add immediate */
5970 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], ibyte[4]);
5971 if (record_full_arch_list_add_mem (oaddr, 8))
5973 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
5977 /* 0xeb7b-0xeb7d undefined */
5978 /* 0xeb7f undefined */
5980 case 0xeb80: /* ICMH - insert characters under mask */
5981 /* 32-bit high gpr destination + flags */
5982 if (s390_record_gpr_h (gdbarch, regcache, inib[2]))
5984 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
5988 /* 0xeb82-0xeb8d undefined */
5990 case 0xeb8e: /* MVCLU - move long unicode [partial] */
5991 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + inib[2], &tmp);
5992 oaddr = s390_record_address_mask (gdbarch, regcache, tmp);
5993 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + (inib[2] | 1), &tmp);
5994 if (record_full_arch_list_add_mem (oaddr, tmp))
5996 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
5998 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[2] | 1)))
6000 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[3]))
6002 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[3] | 1)))
6004 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
6008 case 0xeb8f: /* CLCLU - compare logical long unicode [partial] */
6009 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
6011 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[2] | 1)))
6013 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[3]))
6015 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[3] | 1)))
6017 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
6021 /* 0xeb91-0xeb95 undefined */
6023 case 0xeb96: /* LMH - load multiple high */
6024 for (i = inib[2]; i != inib[3]; i++, i &= 0xf)
6025 if (s390_record_gpr_h (gdbarch, regcache, i))
6027 if (s390_record_gpr_h (gdbarch, regcache, inib[3]))
6031 /* 0xeb97 undefined */
6033 case 0xeb98: /* LMY - load multiple */
6034 for (i = inib[2]; i != inib[3]; i++, i &= 0xf)
6035 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + i))
6037 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[3]))
6041 /* 0xeb99 undefined */
6043 case 0xeb9a: /* LAMY - load access multiple */
6044 for (i = inib[2]; i != inib[3]; i++, i &= 0xf)
6045 if (record_full_arch_list_add_reg (regcache, S390_A0_REGNUM + i))
6047 if (record_full_arch_list_add_reg (regcache, S390_A0_REGNUM + inib[3]))
6051 /* 0xeb9c-0xebbf undefined */
6052 /* 0xebc1-0xebdb undefined */
6053 /* 0xebe5 undefined */
6054 /* 0xebe9 undefined */
6055 /* 0xebeb-0xebf1 undefined */
6056 /* 0xebf5 undefined */
6057 /* 0xebf9 undefined */
6058 /* 0xebfb-0xebff undefined */
6060 /* 0xed00-0xed03 undefined */
6062 case 0xed04: /* LDEB - load lengthened */
6063 case 0xed0c: /* MDEB - multiply */
6064 case 0xed0d: /* DEB - divide */
6065 case 0xed14: /* SQEB - square root */
6066 case 0xed15: /* SQDB - square root */
6067 case 0xed17: /* MEEB - multiply */
6068 case 0xed1c: /* MDB - multiply */
6069 case 0xed1d: /* DDB - divide */
6070 /* float destination + fpc */
6071 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[2]))
6073 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
6077 case 0xed05: /* LXDB - load lengthened */
6078 case 0xed06: /* LXEB - load lengthened */
6079 case 0xed07: /* MXDB - multiply */
6080 /* float pair destination + fpc */
6081 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[2]))
6083 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + (inib[2] | 2)))
6085 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
6089 case 0xed0a: /* AEB - add */
6090 case 0xed0b: /* SEB - subtract */
6091 case 0xed1a: /* ADB - add */
6092 case 0xed1b: /* SDB - subtract */
6093 /* float destination + flags + fpc */
6094 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[2]))
6096 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
6098 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
6102 case 0xed0e: /* MAEB - multiply and add */
6103 case 0xed0f: /* MSEB - multiply and subtract */
6104 case 0xed1e: /* MADB - multiply and add */
6105 case 0xed1f: /* MSDB - multiply and subtract */
6106 case 0xed40: /* SLDT - shift significand left */
6107 case 0xed41: /* SRDT - shift significand right */
6108 case 0xedaa: /* CDZT - convert from zoned */
6109 case 0xedae: /* CDPT - convert from packed */
6110 /* float destination [RXF] + fpc */
6111 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[8]))
6113 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
6117 /* 0xed13 undefined */
6118 /* 0xed16 undefined */
6119 /* 0xed20-0xed23 undefined */
6121 case 0xed24: /* LDE - load lengthened */
6122 case 0xed34: /* SQE - square root */
6123 case 0xed35: /* SQD - square root */
6124 case 0xed37: /* MEE - multiply */
6125 case 0xed64: /* LEY - load */
6126 case 0xed65: /* LDY - load */
6127 /* float destination */
6128 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[2]))
6132 case 0xed25: /* LXD - load lengthened */
6133 case 0xed26: /* LXE - load lengthened */
6134 /* float pair destination */
6135 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[2]))
6137 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + (inib[2] | 2)))
6141 /* 0xed27-0xed2d undefined */
6143 case 0xed2e: /* MAE - multiply and add */
6144 case 0xed2f: /* MSE - multiply and subtract */
6145 case 0xed38: /* MAYL - multiply and add unnormalized */
6146 case 0xed39: /* MYL - multiply unnormalized */
6147 case 0xed3c: /* MAYH - multiply and add unnormalized */
6148 case 0xed3d: /* MYH - multiply unnormalized */
6149 case 0xed3e: /* MAD - multiply and add */
6150 case 0xed3f: /* MSD - multiply and subtract */
6151 /* float destination [RXF] */
6152 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[8]))
6156 /* 0xed30-0xed33 undefined */
6157 /* 0xed36 undefined */
6159 case 0xed3a: /* MAY - multiply and add unnormalized */
6160 case 0xed3b: /* MY - multiply unnormalized */
6161 /* float pair destination [RXF] */
6162 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[8]))
6164 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + (inib[8] | 2)))
6168 /* 0xed42-0xed47 undefind */
6170 case 0xed48: /* SLXT - shift significand left */
6171 case 0xed49: /* SRXT - shift significand right */
6172 case 0xedab: /* CXZT - convert from zoned */
6173 case 0xedaf: /* CXPT - convert from packed */
6174 /* float pair destination [RXF] + fpc */
6175 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[8]))
6177 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + (inib[8] | 2)))
6179 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
6183 /* 0xed4a-0xed4f undefind */
6184 /* 0xed52-0xed53 undefind */
6185 /* 0xed56-0xed57 undefind */
6186 /* 0xed5a-0xed63 undefind */
6187 /* 0xed68-0xeda7 undefined */
6189 case 0xeda8: /* CZDT - convert to zoned */
6190 case 0xeda9: /* CZXT - convert to zoned */
6191 case 0xedac: /* CPDT - convert to packed */
6192 case 0xedad: /* CPXT - convert to packed */
6193 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
6194 if (record_full_arch_list_add_mem (oaddr, ibyte[1] + 1))
6196 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
6200 /* 0xedb0-0xedff undefined */
6207 /* 0xe4 undefined */
6210 /* SSE/SIL-format instruction */
6213 /* 0xe500-0xe543 undefined, privileged, or unsupported */
6215 case 0xe544: /* MVHHI - move */
6216 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
6217 if (record_full_arch_list_add_mem (oaddr, 2))
6221 /* 0xe545-0xe547 undefined */
6223 case 0xe548: /* MVGHI - move */
6224 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
6225 if (record_full_arch_list_add_mem (oaddr, 8))
6229 /* 0xe549-0xe54b undefined */
6231 case 0xe54c: /* MVHI - move */
6232 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
6233 if (record_full_arch_list_add_mem (oaddr, 4))
6237 /* 0xe54d-0xe553 undefined */
6239 case 0xe554: /* CHHSI - compare halfword immediate */
6240 case 0xe555: /* CLHHSI - compare logical immediate */
6241 case 0xe558: /* CGHSI - compare halfword immediate */
6242 case 0xe559: /* CLGHSI - compare logical immediate */
6243 case 0xe55c: /* CHSI - compare halfword immediate */
6244 case 0xe55d: /* CLFHSI - compare logical immediate */
6245 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
6249 /* 0xe556-0xe557 undefined */
6250 /* 0xe55a-0xe55b undefined */
6251 /* 0xe55e-0xe55f undefined */
6253 case 0xe560: /* TBEGIN - transaction begin */
6254 /* The transaction will be immediately aborted after this
6255 instruction, due to single-stepping. This instruction is
6256 only supported so that the program can fail a few times
6257 and go to the non-transactional fallback. */
6260 /* Transaction diagnostic block - user. */
6261 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
6262 if (record_full_arch_list_add_mem (oaddr, 256))
6265 /* Transaction diagnostic block - supervisor. */
6266 if (record_full_arch_list_add_reg (regcache, S390_TDB_DWORD0_REGNUM))
6268 if (record_full_arch_list_add_reg (regcache, S390_TDB_ABORT_CODE_REGNUM))
6270 if (record_full_arch_list_add_reg (regcache, S390_TDB_CONFLICT_TOKEN_REGNUM))
6272 if (record_full_arch_list_add_reg (regcache, S390_TDB_ATIA_REGNUM))
6274 for (i = 0; i < 16; i++)
6275 if (record_full_arch_list_add_reg (regcache, S390_TDB_R0_REGNUM + i))
6278 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
6282 /* 0xe561 unsupported: TBEGINC */
6283 /* 0xe562-0xe5ff undefined */
6291 /* RIE/RIS/RRS-format instruction */
6292 switch (ibyte[0] << 8 | ibyte[5])
6294 /* 0xec00-0xec41 undefined */
6296 case 0xec42: /* LOCHI - load halfword immediate on condition */
6297 case 0xec51: /* RISBLG - rotate then insert selected bits low */
6298 /* 32-bit or native gpr destination */
6299 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
6303 /* 0xec43 undefined */
6305 case 0xec44: /* BRXHG - branch relative on index high */
6306 case 0xec45: /* BRXLG - branch relative on index low or equal */
6307 case 0xec46: /* LOCGHI - load halfword immediate on condition */
6308 case 0xec59: /* RISBGN - rotate then insert selected bits */
6309 /* 64-bit gpr destination */
6310 if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
6314 /* 0xec47-0xec4d undefined */
6316 case 0xec4e: /* LOCHHI - load halfword immediate on condition */
6317 case 0xec5d: /* RISBHG - rotate then insert selected bits high */
6318 /* 32-bit high gpr destination */
6319 if (s390_record_gpr_h (gdbarch, regcache, inib[2]))
6323 /* 0xec4f-0xec50 undefined */
6324 /* 0xec52-0xec53 undefined */
6326 case 0xec54: /* RNSBG - rotate then and selected bits */
6327 case 0xec55: /* RISBG - rotate then insert selected bits */
6328 case 0xec56: /* ROSBG - rotate then or selected bits */
6329 case 0xec57: /* RXSBG - rotate then xor selected bits */
6330 case 0xecd9: /* AGHIK - add immediate */
6331 case 0xecdb: /* ALGHSIK - add logical immediate */
6332 /* 64-bit gpr destination + flags */
6333 if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
6335 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
6339 /* 0xec58 undefined */
6340 /* 0xec5a-0xec5c undefined */
6341 /* 0xec5e-0xec63 undefined */
6343 case 0xec64: /* CGRJ - compare and branch relative */
6344 case 0xec65: /* CLGRJ - compare logical and branch relative */
6345 case 0xec76: /* CRJ - compare and branch relative */
6346 case 0xec77: /* CLRJ - compare logical and branch relative */
6347 case 0xec7c: /* CGIJ - compare immediate and branch relative */
6348 case 0xec7d: /* CLGIJ - compare logical immediate and branch relative */
6349 case 0xec7e: /* CIJ - compare immediate and branch relative */
6350 case 0xec7f: /* CLIJ - compare logical immediate and branch relative */
6351 case 0xece4: /* CGRB - compare and branch */
6352 case 0xece5: /* CLGRB - compare logical and branch */
6353 case 0xecf6: /* CRB - compare and branch */
6354 case 0xecf7: /* CLRB - compare logical and branch */
6355 case 0xecfc: /* CGIB - compare immediate and branch */
6356 case 0xecfd: /* CLGIB - compare logical immediate and branch */
6357 case 0xecfe: /* CIB - compare immediate and branch */
6358 case 0xecff: /* CLIB - compare logical immediate and branch */
6361 /* 0xec66-0xec6f undefined */
6363 case 0xec70: /* CGIT - compare immediate and trap */
6364 case 0xec71: /* CLGIT - compare logical immediate and trap */
6365 case 0xec72: /* CIT - compare immediate and trap */
6366 case 0xec73: /* CLFIT - compare logical immediate and trap */
6367 /* fpc only - including possible DXC write for trapping insns */
6368 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
6372 /* 0xec74-0xec75 undefined */
6373 /* 0xec78-0xec7b undefined */
6375 /* 0xec80-0xecd7 undefined */
6377 case 0xecd8: /* AHIK - add immediate */
6378 case 0xecda: /* ALHSIK - add logical immediate */
6379 /* 32-bit gpr destination + flags */
6380 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
6382 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
6386 /* 0xecdc-0xece3 undefined */
6387 /* 0xece6-0xecf5 undefined */
6388 /* 0xecf8-0xecfb undefined */
6395 case 0xee: /* PLO - perform locked operation */
6396 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM, &tmp);
6397 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
6398 oaddr2 = s390_record_calc_disp (gdbarch, regcache, 0, insn[2], 0);
6401 uint8_t fc = tmp & 0xff;
6407 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
6410 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[3]))
6414 case 0x01: /* CLG */
6416 if (record_full_arch_list_add_mem (oaddr2 + 0x08, 8))
6419 if (record_full_arch_list_add_mem (oaddr2 + 0x28, 8))
6423 case 0x02: /* CLGR */
6425 if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
6428 if (s390_record_gpr_g (gdbarch, regcache, inib[3]))
6432 case 0x03: /* CLX */
6434 if (record_full_arch_list_add_mem (oaddr2 + 0x00, 16))
6437 if (record_full_arch_list_add_mem (oaddr2 + 0x20, 16))
6441 case 0x08: /* DCS */
6443 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[3]))
6446 case 0x0c: /* CSST */
6448 if (record_full_arch_list_add_mem (oaddr2, 4))
6452 case 0x14: /* CSTST */
6454 if (target_read_memory (oaddr2 + 0x88, buf, 8))
6456 oaddr3 = extract_unsigned_integer (buf, 8, byte_order);
6457 oaddr3 = s390_record_address_mask (gdbarch, regcache, oaddr3);
6458 if (record_full_arch_list_add_mem (oaddr3, 4))
6461 case 0x10: /* CSDST */
6463 if (target_read_memory (oaddr2 + 0x68, buf, 8))
6465 oaddr3 = extract_unsigned_integer (buf, 8, byte_order);
6466 oaddr3 = s390_record_address_mask (gdbarch, regcache, oaddr3);
6467 if (record_full_arch_list_add_mem (oaddr3, 4))
6470 if (target_read_memory (oaddr2 + 0x48, buf, 8))
6472 oaddr3 = extract_unsigned_integer (buf, 8, byte_order);
6473 oaddr3 = s390_record_address_mask (gdbarch, regcache, oaddr3);
6474 if (record_full_arch_list_add_mem (oaddr3, 4))
6480 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
6483 if (record_full_arch_list_add_mem (oaddr, 4))
6487 case 0x09: /* DCSG */
6489 if (record_full_arch_list_add_mem (oaddr2 + 0x28, 8))
6493 case 0x15: /* CSTSTG */
6495 if (target_read_memory (oaddr2 + 0x88, buf, 8))
6497 oaddr3 = extract_unsigned_integer (buf, 8, byte_order);
6498 oaddr3 = s390_record_address_mask (gdbarch, regcache, oaddr3);
6499 if (record_full_arch_list_add_mem (oaddr3, 8))
6502 case 0x11: /* CSDSTG */
6504 if (target_read_memory (oaddr2 + 0x68, buf, 8))
6506 oaddr3 = extract_unsigned_integer (buf, 8, byte_order);
6507 oaddr3 = s390_record_address_mask (gdbarch, regcache, oaddr3);
6508 if (record_full_arch_list_add_mem (oaddr3, 8))
6511 case 0x0d: /* CSSTG */
6514 if (target_read_memory (oaddr2 + 0x48, buf, 8))
6516 oaddr3 = extract_unsigned_integer (buf, 8, byte_order);
6517 oaddr3 = s390_record_address_mask (gdbarch, regcache, oaddr3);
6518 if (record_full_arch_list_add_mem (oaddr3, 8))
6521 case 0x05: /* CSG */
6523 if (record_full_arch_list_add_mem (oaddr2 + 0x08, 8))
6526 if (record_full_arch_list_add_mem (oaddr, 8))
6530 case 0x0a: /* DCSGR */
6532 if (s390_record_gpr_g (gdbarch, regcache, inib[3]))
6535 case 0x0e: /* CSSTGR */
6537 if (record_full_arch_list_add_mem (oaddr2, 8))
6541 case 0x16: /* CSTSTGR */
6543 if (target_read_memory (oaddr2 + 0x88, buf, 8))
6545 oaddr3 = extract_unsigned_integer (buf, 8, byte_order);
6546 oaddr3 = s390_record_address_mask (gdbarch, regcache, oaddr3);
6547 if (record_full_arch_list_add_mem (oaddr3, 8))
6550 case 0x12: /* CSDSTGR */
6552 if (target_read_memory (oaddr2 + 0x68, buf, 8))
6554 oaddr3 = extract_unsigned_integer (buf, 8, byte_order);
6555 oaddr3 = s390_record_address_mask (gdbarch, regcache, oaddr3);
6556 if (record_full_arch_list_add_mem (oaddr3, 8))
6559 if (target_read_memory (oaddr2 + 0x48, buf, 8))
6561 oaddr3 = extract_unsigned_integer (buf, 8, byte_order);
6562 oaddr3 = s390_record_address_mask (gdbarch, regcache, oaddr3);
6563 if (record_full_arch_list_add_mem (oaddr3, 8))
6566 case 0x06: /* CSGR */
6569 if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
6572 if (record_full_arch_list_add_mem (oaddr, 8))
6576 case 0x0b: /* DCSX */
6578 if (record_full_arch_list_add_mem (oaddr2 + 0x20, 16))
6582 case 0x17: /* CSTSTX */
6584 if (target_read_memory (oaddr2 + 0x88, buf, 8))
6586 oaddr3 = extract_unsigned_integer (buf, 8, byte_order);
6587 oaddr3 = s390_record_address_mask (gdbarch, regcache, oaddr3);
6588 if (record_full_arch_list_add_mem (oaddr3, 16))
6591 case 0x13: /* CSDSTX */
6593 if (target_read_memory (oaddr2 + 0x68, buf, 8))
6595 oaddr3 = extract_unsigned_integer (buf, 8, byte_order);
6596 oaddr3 = s390_record_address_mask (gdbarch, regcache, oaddr3);
6597 if (record_full_arch_list_add_mem (oaddr3, 16))
6600 case 0x0f: /* CSSTX */
6603 if (target_read_memory (oaddr2 + 0x48, buf, 8))
6605 oaddr3 = extract_unsigned_integer (buf, 8, byte_order);
6606 oaddr3 = s390_record_address_mask (gdbarch, regcache, oaddr3);
6607 if (record_full_arch_list_add_mem (oaddr3, 16))
6610 case 0x07: /* CSX */
6612 if (record_full_arch_list_add_mem (oaddr2 + 0x00, 16))
6615 if (record_full_arch_list_add_mem (oaddr, 16))
6620 fprintf_unfiltered (gdb_stdlog, "Warning: Unknown PLO FC %02x at %s.\n",
6621 fc, paddress (gdbarch, addr));
6625 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
6629 case 0xef: /* LMD - load multiple disjoint */
6630 for (i = inib[2]; i != inib[3]; i++, i &= 0xf)
6631 if (s390_record_gpr_g (gdbarch, regcache, i))
6633 if (s390_record_gpr_g (gdbarch, regcache, inib[3]))
6637 case 0xf0: /* SRP - shift and round decimal */
6638 case 0xf8: /* ZAP - zero and add */
6639 case 0xfa: /* AP - add decimal */
6640 case 0xfb: /* SP - subtract decimal */
6641 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
6642 if (record_full_arch_list_add_mem (oaddr, inib[2] + 1))
6644 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
6646 /* DXC may be written */
6647 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
6651 case 0xf1: /* MVO - move with offset */
6652 case 0xf2: /* PACK - pack */
6653 case 0xf3: /* UNPK - unpack */
6654 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
6655 if (record_full_arch_list_add_mem (oaddr, inib[2] + 1))
6659 /* 0xf4-0xf7 undefined */
6661 case 0xf9: /* CP - compare decimal */
6662 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
6664 /* DXC may be written */
6665 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
6669 case 0xfc: /* MP - multiply decimal */
6670 case 0xfd: /* DP - divide decimal */
6671 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
6672 if (record_full_arch_list_add_mem (oaddr, inib[2] + 1))
6674 /* DXC may be written */
6675 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
6679 /* 0xfe-0xff undefined */
6683 fprintf_unfiltered (gdb_stdlog, "Warning: Don't know how to record %04x "
6684 "at %s.\n", insn[0], paddress (gdbarch, addr));
6688 if (record_full_arch_list_add_reg (regcache, S390_PSWA_REGNUM))
6690 if (record_full_arch_list_add_end ())
6695 /* Miscellaneous. */
6697 /* Implement gdbarch_gcc_target_options. GCC does not know "-m32" or
6698 "-mcmodel=large". */
6701 s390_gcc_target_options (struct gdbarch *gdbarch)
6703 return xstrdup (gdbarch_ptr_bit (gdbarch) == 64 ? "-m64" : "-m31");
6706 /* Implement gdbarch_gnu_triplet_regexp. Target triplets are "s390-*"
6707 for 31-bit and "s390x-*" for 64-bit, while the BFD arch name is
6708 always "s390". Note that an s390x compiler supports "-m31" as
6712 s390_gnu_triplet_regexp (struct gdbarch *gdbarch)
6717 /* Implementation of `gdbarch_stap_is_single_operand', as defined in
6721 s390_stap_is_single_operand (struct gdbarch *gdbarch, const char *s)
6723 return ((isdigit (*s) && s[1] == '(' && s[2] == '%') /* Displacement
6725 || *s == '%' /* Register access. */
6726 || isdigit (*s)); /* Literal number. */
6731 /* Validate the range of registers. NAMES must be known at compile time. */
6733 #define s390_validate_reg_range(feature, tdesc_data, start, names) \
6736 for (int i = 0; i < ARRAY_SIZE (names); i++) \
6737 if (!tdesc_numbered_register (feature, tdesc_data, start + i, names[i])) \
6742 /* Validate the target description. Also numbers registers contained in
6746 s390_tdesc_valid (struct gdbarch_tdep *tdep,
6747 struct tdesc_arch_data *tdesc_data)
6749 static const char *const psw[] = {
6752 static const char *const gprs[] = {
6753 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
6754 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
6756 static const char *const fprs[] = {
6757 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
6758 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15"
6760 static const char *const acrs[] = {
6761 "acr0", "acr1", "acr2", "acr3", "acr4", "acr5", "acr6", "acr7",
6762 "acr8", "acr9", "acr10", "acr11", "acr12", "acr13", "acr14", "acr15"
6764 static const char *const gprs_lower[] = {
6765 "r0l", "r1l", "r2l", "r3l", "r4l", "r5l", "r6l", "r7l",
6766 "r8l", "r9l", "r10l", "r11l", "r12l", "r13l", "r14l", "r15l"
6768 static const char *const gprs_upper[] = {
6769 "r0h", "r1h", "r2h", "r3h", "r4h", "r5h", "r6h", "r7h",
6770 "r8h", "r9h", "r10h", "r11h", "r12h", "r13h", "r14h", "r15h"
6772 static const char *const tdb_regs[] = {
6773 "tdb0", "tac", "tct", "atia",
6774 "tr0", "tr1", "tr2", "tr3", "tr4", "tr5", "tr6", "tr7",
6775 "tr8", "tr9", "tr10", "tr11", "tr12", "tr13", "tr14", "tr15"
6777 static const char *const vxrs_low[] = {
6778 "v0l", "v1l", "v2l", "v3l", "v4l", "v5l", "v6l", "v7l", "v8l",
6779 "v9l", "v10l", "v11l", "v12l", "v13l", "v14l", "v15l",
6781 static const char *const vxrs_high[] = {
6782 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23", "v24",
6783 "v25", "v26", "v27", "v28", "v29", "v30", "v31",
6785 static const char *const gs_cb[] = {
6786 "gsd", "gssm", "gsepla",
6788 static const char *const gs_bc[] = {
6789 "bc_gsd", "bc_gssm", "bc_gsepla",
6792 const struct target_desc *tdesc = tdep->tdesc;
6793 const struct tdesc_feature *feature;
6795 if (!tdesc_has_registers (tdesc))
6798 /* Core registers, i.e. general purpose and PSW. */
6799 feature = tdesc_find_feature (tdesc, "org.gnu.gdb.s390.core");
6800 if (feature == NULL)
6803 s390_validate_reg_range (feature, tdesc_data, S390_PSWM_REGNUM, psw);
6805 if (tdesc_unnumbered_register (feature, "r0"))
6807 s390_validate_reg_range (feature, tdesc_data, S390_R0_REGNUM, gprs);
6811 tdep->have_upper = true;
6812 s390_validate_reg_range (feature, tdesc_data, S390_R0_REGNUM,
6814 s390_validate_reg_range (feature, tdesc_data, S390_R0_UPPER_REGNUM,
6818 /* Floating point registers. */
6819 feature = tdesc_find_feature (tdesc, "org.gnu.gdb.s390.fpr");
6820 if (feature == NULL)
6823 if (!tdesc_numbered_register (feature, tdesc_data, S390_FPC_REGNUM, "fpc"))
6826 s390_validate_reg_range (feature, tdesc_data, S390_F0_REGNUM, fprs);
6828 /* Access control registers. */
6829 feature = tdesc_find_feature (tdesc, "org.gnu.gdb.s390.acr");
6830 if (feature == NULL)
6833 s390_validate_reg_range (feature, tdesc_data, S390_A0_REGNUM, acrs);
6835 /* Optional GNU/Linux-specific "registers". */
6836 feature = tdesc_find_feature (tdesc, "org.gnu.gdb.s390.linux");
6839 tdesc_numbered_register (feature, tdesc_data,
6840 S390_ORIG_R2_REGNUM, "orig_r2");
6842 if (tdesc_numbered_register (feature, tdesc_data,
6843 S390_LAST_BREAK_REGNUM, "last_break"))
6844 tdep->have_linux_v1 = true;
6846 if (tdesc_numbered_register (feature, tdesc_data,
6847 S390_SYSTEM_CALL_REGNUM, "system_call"))
6848 tdep->have_linux_v2 = true;
6850 if (tdep->have_linux_v2 && !tdep->have_linux_v1)
6854 /* Transaction diagnostic block. */
6855 feature = tdesc_find_feature (tdesc, "org.gnu.gdb.s390.tdb");
6858 s390_validate_reg_range (feature, tdesc_data, S390_TDB_DWORD0_REGNUM,
6860 tdep->have_tdb = true;
6863 /* Vector registers. */
6864 feature = tdesc_find_feature (tdesc, "org.gnu.gdb.s390.vx");
6867 s390_validate_reg_range (feature, tdesc_data, S390_V0_LOWER_REGNUM,
6869 s390_validate_reg_range (feature, tdesc_data, S390_V16_REGNUM,
6871 tdep->have_vx = true;
6874 /* Guarded-storage registers. */
6875 feature = tdesc_find_feature (tdesc, "org.gnu.gdb.s390.gs");
6878 s390_validate_reg_range (feature, tdesc_data, S390_GSD_REGNUM, gs_cb);
6879 tdep->have_gs = true;
6882 /* Guarded-storage broadcast control. */
6883 feature = tdesc_find_feature (tdesc, "org.gnu.gdb.s390.gsbc");
6888 s390_validate_reg_range (feature, tdesc_data, S390_BC_GSD_REGNUM,
6895 /* Allocate and initialize new gdbarch_tdep. Caller is responsible to free
6896 memory after use. */
6898 static struct gdbarch_tdep *
6899 s390_gdbarch_tdep_alloc ()
6901 struct gdbarch_tdep *tdep = XCNEW (struct gdbarch_tdep);
6905 tdep->abi = ABI_NONE;
6906 tdep->vector_abi = S390_VECTOR_ABI_NONE;
6908 tdep->gpr_full_regnum = -1;
6909 tdep->v0_full_regnum = -1;
6910 tdep->pc_regnum = -1;
6911 tdep->cc_regnum = -1;
6913 tdep->have_upper = false;
6914 tdep->have_linux_v1 = false;
6915 tdep->have_linux_v2 = false;
6916 tdep->have_tdb = false;
6917 tdep->have_vx = false;
6918 tdep->have_gs = false;
6920 tdep->s390_syscall_record = NULL;
6925 /* Set up gdbarch struct. */
6927 static struct gdbarch *
6928 s390_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
6930 const struct target_desc *tdesc = info.target_desc;
6931 int first_pseudo_reg, last_pseudo_reg;
6932 static const char *const stap_register_prefixes[] = { "%", NULL };
6933 static const char *const stap_register_indirection_prefixes[] = { "(",
6935 static const char *const stap_register_indirection_suffixes[] = { ")",
6938 struct gdbarch_tdep *tdep = s390_gdbarch_tdep_alloc ();
6939 struct gdbarch *gdbarch = gdbarch_alloc (&info, tdep);
6940 struct tdesc_arch_data *tdesc_data = tdesc_data_alloc ();
6941 info.tdesc_data = tdesc_data;
6943 set_gdbarch_believe_pcc_promotion (gdbarch, 0);
6944 set_gdbarch_char_signed (gdbarch, 0);
6946 /* S/390 GNU/Linux uses either 64-bit or 128-bit long doubles.
6947 We can safely let them default to 128-bit, since the debug info
6948 will give the size of type actually used in each case. */
6949 set_gdbarch_long_double_bit (gdbarch, 128);
6950 set_gdbarch_long_double_format (gdbarch, floatformats_ia64_quad);
6953 /* Amount PC must be decremented by after a breakpoint. This is
6954 often the number of bytes returned by gdbarch_breakpoint_from_pc but not
6956 set_gdbarch_decr_pc_after_break (gdbarch, 2);
6957 set_gdbarch_breakpoint_kind_from_pc (gdbarch, s390_breakpoint::kind_from_pc);
6958 set_gdbarch_sw_breakpoint_from_kind (gdbarch, s390_breakpoint::bp_from_kind);
6960 /* Displaced stepping. */
6961 set_gdbarch_displaced_step_copy_insn (gdbarch,
6962 s390_displaced_step_copy_insn);
6963 set_gdbarch_displaced_step_fixup (gdbarch, s390_displaced_step_fixup);
6964 set_gdbarch_displaced_step_location (gdbarch, linux_displaced_step_location);
6965 set_gdbarch_displaced_step_hw_singlestep (gdbarch, s390_displaced_step_hw_singlestep);
6966 set_gdbarch_software_single_step (gdbarch, s390_software_single_step);
6967 set_gdbarch_max_insn_length (gdbarch, S390_MAX_INSTR_SIZE);
6969 /* Prologue analysis. */
6970 set_gdbarch_skip_prologue (gdbarch, s390_skip_prologue);
6972 /* Register handling. */
6973 set_gdbarch_num_regs (gdbarch, S390_NUM_REGS);
6974 set_gdbarch_sp_regnum (gdbarch, S390_SP_REGNUM);
6975 set_gdbarch_fp0_regnum (gdbarch, S390_F0_REGNUM);
6976 set_gdbarch_guess_tracepoint_registers (gdbarch,
6977 s390_guess_tracepoint_registers);
6978 set_gdbarch_stab_reg_to_regnum (gdbarch, s390_dwarf_reg_to_regnum);
6979 set_gdbarch_dwarf2_reg_to_regnum (gdbarch, s390_dwarf_reg_to_regnum);
6980 set_gdbarch_value_from_register (gdbarch, s390_value_from_register);
6982 /* Pseudo registers. */
6983 set_gdbarch_pseudo_register_read (gdbarch, s390_pseudo_register_read);
6984 set_gdbarch_pseudo_register_write (gdbarch, s390_pseudo_register_write);
6985 set_tdesc_pseudo_register_name (gdbarch, s390_pseudo_register_name);
6986 set_tdesc_pseudo_register_type (gdbarch, s390_pseudo_register_type);
6987 set_tdesc_pseudo_register_reggroup_p (gdbarch,
6988 s390_pseudo_register_reggroup_p);
6989 set_gdbarch_ax_pseudo_register_collect (gdbarch,
6990 s390_ax_pseudo_register_collect);
6991 set_gdbarch_ax_pseudo_register_push_stack
6992 (gdbarch, s390_ax_pseudo_register_push_stack);
6993 set_gdbarch_gen_return_address (gdbarch, s390_gen_return_address);
6995 /* Inferior function calls. */
6996 set_gdbarch_push_dummy_call (gdbarch, s390_push_dummy_call);
6997 set_gdbarch_dummy_id (gdbarch, s390_dummy_id);
6998 set_gdbarch_frame_align (gdbarch, s390_frame_align);
6999 set_gdbarch_return_value (gdbarch, s390_return_value);
7001 /* Frame handling. */
7002 /* Stack grows downward. */
7003 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
7004 set_gdbarch_stack_frame_destroyed_p (gdbarch, s390_stack_frame_destroyed_p);
7005 dwarf2_frame_set_init_reg (gdbarch, s390_dwarf2_frame_init_reg);
7006 dwarf2_frame_set_adjust_regnum (gdbarch, s390_adjust_frame_regnum);
7007 dwarf2_append_unwinders (gdbarch);
7008 set_gdbarch_unwind_pc (gdbarch, s390_unwind_pc);
7009 set_gdbarch_unwind_sp (gdbarch, s390_unwind_sp);
7011 switch (info.bfd_arch_info->mach)
7013 case bfd_mach_s390_31:
7014 set_gdbarch_addr_bits_remove (gdbarch, s390_addr_bits_remove);
7017 case bfd_mach_s390_64:
7018 set_gdbarch_long_bit (gdbarch, 64);
7019 set_gdbarch_long_long_bit (gdbarch, 64);
7020 set_gdbarch_ptr_bit (gdbarch, 64);
7021 set_gdbarch_address_class_type_flags (gdbarch,
7022 s390_address_class_type_flags);
7023 set_gdbarch_address_class_type_flags_to_name (gdbarch,
7024 s390_address_class_type_flags_to_name);
7025 set_gdbarch_address_class_name_to_type_flags (gdbarch,
7026 s390_address_class_name_to_type_flags);
7030 /* SystemTap functions. */
7031 set_gdbarch_stap_register_prefixes (gdbarch, stap_register_prefixes);
7032 set_gdbarch_stap_register_indirection_prefixes (gdbarch,
7033 stap_register_indirection_prefixes);
7034 set_gdbarch_stap_register_indirection_suffixes (gdbarch,
7035 stap_register_indirection_suffixes);
7037 set_gdbarch_disassembler_options (gdbarch, &s390_disassembler_options);
7038 set_gdbarch_valid_disassembler_options (gdbarch,
7039 disassembler_options_s390 ());
7041 /* Process record-replay */
7042 set_gdbarch_process_record (gdbarch, s390_process_record);
7044 /* Miscellaneous. */
7045 set_gdbarch_stap_is_single_operand (gdbarch, s390_stap_is_single_operand);
7046 set_gdbarch_gcc_target_options (gdbarch, s390_gcc_target_options);
7047 set_gdbarch_gnu_triplet_regexp (gdbarch, s390_gnu_triplet_regexp);
7049 /* Initialize the OSABI. */
7050 gdbarch_init_osabi (info, gdbarch);
7052 /* Always create a default tdesc. Otherwise commands like 'set osabi'
7053 cause GDB to crash with an internal error when the user tries to set
7054 an unsupported OSABI. */
7055 if (!tdesc_has_registers (tdesc))
7057 if (info.bfd_arch_info->mach == bfd_mach_s390_31)
7058 tdesc = tdesc_s390_linux32;
7060 tdesc = tdesc_s390x_linux64;
7062 tdep->tdesc = tdesc;
7064 /* Check any target description for validity. */
7065 if (!s390_tdesc_valid (tdep, tdesc_data))
7067 tdesc_data_cleanup (tdesc_data);
7069 gdbarch_free (gdbarch);
7073 /* Determine vector ABI. */
7076 && info.abfd != NULL
7077 && info.abfd->format == bfd_object
7078 && bfd_get_flavour (info.abfd) == bfd_target_elf_flavour
7079 && bfd_elf_get_obj_attr_int (info.abfd, OBJ_ATTR_GNU,
7080 Tag_GNU_S390_ABI_Vector) == 2)
7081 tdep->vector_abi = S390_VECTOR_ABI_128;
7084 /* Find a candidate among extant architectures. */
7085 for (arches = gdbarch_list_lookup_by_info (arches, &info);
7087 arches = gdbarch_list_lookup_by_info (arches->next, &info))
7089 struct gdbarch_tdep *tmp = gdbarch_tdep (arches->gdbarch);
7092 /* A program can 'choose' not to use the vector registers when they
7093 are present. Leading to the same tdesc but different tdep and
7094 thereby a different gdbarch. */
7095 if (tmp->vector_abi != tdep->vector_abi)
7098 tdesc_data_cleanup (tdesc_data);
7100 gdbarch_free (gdbarch);
7101 return arches->gdbarch;
7104 tdesc_use_registers (gdbarch, tdep->tdesc, tdesc_data);
7105 set_gdbarch_register_name (gdbarch, s390_register_name);
7107 /* Assign pseudo register numbers. */
7108 first_pseudo_reg = gdbarch_num_regs (gdbarch);
7109 last_pseudo_reg = first_pseudo_reg;
7110 if (tdep->have_upper)
7112 tdep->gpr_full_regnum = last_pseudo_reg;
7113 last_pseudo_reg += 16;
7117 tdep->v0_full_regnum = last_pseudo_reg;
7118 last_pseudo_reg += 16;
7120 tdep->pc_regnum = last_pseudo_reg++;
7121 tdep->cc_regnum = last_pseudo_reg++;
7122 set_gdbarch_pc_regnum (gdbarch, tdep->pc_regnum);
7123 set_gdbarch_num_pseudo_regs (gdbarch, last_pseudo_reg - first_pseudo_reg);
7125 /* Frame handling. */
7126 frame_base_append_sniffer (gdbarch, dwarf2_frame_base_sniffer);
7127 frame_unwind_append_unwinder (gdbarch, &s390_stub_frame_unwind);
7128 frame_unwind_append_unwinder (gdbarch, &s390_frame_unwind);
7129 frame_base_set_default (gdbarch, &s390_frame_base);
7135 _initialize_s390_tdep (void)
7137 /* Hook us into the gdbarch mechanism. */
7138 register_gdbarch_init (bfd_arch_s390, s390_gdbarch_init);
7140 initialize_tdesc_s390_linux32 ();
7141 initialize_tdesc_s390x_linux64 ();