1 /* Target-dependent code for s390.
3 Copyright (C) 2001-2021 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"
44 #include "features/s390-linux32.c"
45 #include "features/s390x-linux64.c"
47 /* Holds the current set of options to be passed to the disassembler. */
48 static char *s390_disassembler_options
;
52 constexpr gdb_byte s390_break_insn
[] = { 0x0, 0x1 };
54 typedef BP_MANIPULATION (s390_break_insn
) s390_breakpoint
;
58 /* Implement the gdbarch type alignment method. */
61 s390_type_align (gdbarch
*gdbarch
, struct type
*t
)
63 t
= check_typedef (t
);
65 if (TYPE_LENGTH (t
) > 8)
75 case TYPE_CODE_DECFLOAT
:
87 /* Decoding S/390 instructions. */
89 /* Read a single instruction from address AT. */
92 s390_readinstruction (bfd_byte instr
[], CORE_ADDR at
)
94 static int s390_instrlen
[] = { 2, 4, 4, 6 };
97 if (target_read_memory (at
, &instr
[0], 2))
99 instrlen
= s390_instrlen
[instr
[0] >> 6];
102 if (target_read_memory (at
+ 2, &instr
[2], instrlen
- 2))
108 /* The functions below are for recognizing and decoding S/390
109 instructions of various formats. Each of them checks whether INSN
110 is an instruction of the given format, with the specified opcodes.
111 If it is, it sets the remaining arguments to the values of the
112 instruction's fields, and returns a non-zero value; otherwise, it
115 These functions' arguments appear in the order they appear in the
116 instruction, not in the machine-language form. So, opcodes always
117 come first, even though they're sometimes scattered around the
118 instructions. And displacements appear before base and extension
119 registers, as they do in the assembly syntax, not at the end, as
120 they do in the machine language.
122 Test for RI instruction format. */
125 is_ri (bfd_byte
*insn
, int op1
, int op2
, unsigned int *r1
, int *i2
)
127 if (insn
[0] == op1
&& (insn
[1] & 0xf) == op2
)
129 *r1
= (insn
[1] >> 4) & 0xf;
130 /* i2 is a 16-bit signed quantity. */
131 *i2
= (((insn
[2] << 8) | insn
[3]) ^ 0x8000) - 0x8000;
138 /* Test for RIL instruction format. See comment on is_ri for details. */
141 is_ril (bfd_byte
*insn
, int op1
, int op2
,
142 unsigned int *r1
, int *i2
)
144 if (insn
[0] == op1
&& (insn
[1] & 0xf) == op2
)
146 *r1
= (insn
[1] >> 4) & 0xf;
147 /* i2 is a signed quantity. If the host 'int' is 32 bits long,
148 no sign extension is necessary, but we don't want to assume
150 *i2
= (((insn
[2] << 24)
153 | (insn
[5])) ^ 0x80000000) - 0x80000000;
160 /* Test for RR instruction format. See comment on is_ri for details. */
163 is_rr (bfd_byte
*insn
, int op
, unsigned int *r1
, unsigned int *r2
)
167 *r1
= (insn
[1] >> 4) & 0xf;
175 /* Test for RRE instruction format. See comment on is_ri for details. */
178 is_rre (bfd_byte
*insn
, int op
, unsigned int *r1
, unsigned int *r2
)
180 if (((insn
[0] << 8) | insn
[1]) == op
)
182 /* Yes, insn[3]. insn[2] is unused in RRE format. */
183 *r1
= (insn
[3] >> 4) & 0xf;
191 /* Test for RS instruction format. See comment on is_ri for details. */
194 is_rs (bfd_byte
*insn
, int op
,
195 unsigned int *r1
, unsigned int *r3
, int *d2
, unsigned int *b2
)
199 *r1
= (insn
[1] >> 4) & 0xf;
201 *b2
= (insn
[2] >> 4) & 0xf;
202 *d2
= ((insn
[2] & 0xf) << 8) | insn
[3];
209 /* Test for RSY instruction format. See comment on is_ri for details. */
212 is_rsy (bfd_byte
*insn
, int op1
, int op2
,
213 unsigned int *r1
, unsigned int *r3
, int *d2
, unsigned int *b2
)
218 *r1
= (insn
[1] >> 4) & 0xf;
220 *b2
= (insn
[2] >> 4) & 0xf;
221 /* The 'long displacement' is a 20-bit signed integer. */
222 *d2
= ((((insn
[2] & 0xf) << 8) | insn
[3] | (insn
[4] << 12))
223 ^ 0x80000) - 0x80000;
230 /* Test for RX instruction format. See comment on is_ri for details. */
233 is_rx (bfd_byte
*insn
, int op
,
234 unsigned int *r1
, int *d2
, unsigned int *x2
, unsigned int *b2
)
238 *r1
= (insn
[1] >> 4) & 0xf;
240 *b2
= (insn
[2] >> 4) & 0xf;
241 *d2
= ((insn
[2] & 0xf) << 8) | insn
[3];
248 /* Test for RXY instruction format. See comment on is_ri for details. */
251 is_rxy (bfd_byte
*insn
, int op1
, int op2
,
252 unsigned int *r1
, int *d2
, unsigned int *x2
, unsigned int *b2
)
257 *r1
= (insn
[1] >> 4) & 0xf;
259 *b2
= (insn
[2] >> 4) & 0xf;
260 /* The 'long displacement' is a 20-bit signed integer. */
261 *d2
= ((((insn
[2] & 0xf) << 8) | insn
[3] | (insn
[4] << 12))
262 ^ 0x80000) - 0x80000;
269 /* A helper for s390_software_single_step, decides if an instruction
270 is a partial-execution instruction that needs to be executed until
271 completion when in record mode. If it is, returns 1 and writes
272 instruction length to a pointer. */
275 s390_is_partial_instruction (struct gdbarch
*gdbarch
, CORE_ADDR loc
, int *len
)
277 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
280 insn
= read_memory_integer (loc
, 2, byte_order
);
284 case 0xa8: /* MVCLE */
290 insn
= read_memory_integer (loc
+ 4, 2, byte_order
);
291 if ((insn
& 0xff) == 0x8e)
303 case 0xb255: /* MVST */
304 case 0xb263: /* CMPSC */
305 case 0xb2a5: /* TRE */
306 case 0xb2a6: /* CU21 */
307 case 0xb2a7: /* CU12 */
308 case 0xb9b0: /* CU14 */
309 case 0xb9b1: /* CU24 */
310 case 0xb9b2: /* CU41 */
311 case 0xb9b3: /* CU42 */
312 case 0xb92a: /* KMF */
313 case 0xb92b: /* KMO */
314 case 0xb92f: /* KMC */
315 case 0xb92d: /* KMCTR */
316 case 0xb92e: /* KM */
317 case 0xb93c: /* PPNO */
318 case 0xb990: /* TRTT */
319 case 0xb991: /* TRTO */
320 case 0xb992: /* TROT */
321 case 0xb993: /* TROO */
329 /* Implement the "software_single_step" gdbarch method, needed to single step
330 through instructions like MVCLE in record mode, to make sure they are
331 executed to completion. Without that, record will save the full length
332 of destination buffer on every iteration, even though the CPU will only
333 process about 4kiB of it each time, leading to O(n**2) memory and time
336 static std::vector
<CORE_ADDR
>
337 s390_software_single_step (struct regcache
*regcache
)
339 struct gdbarch
*gdbarch
= regcache
->arch ();
340 CORE_ADDR loc
= regcache_read_pc (regcache
);
341 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
345 /* Special handling only if recording. */
346 if (!record_full_is_used ())
349 /* First, match a partial instruction. */
350 if (!s390_is_partial_instruction (gdbarch
, loc
, &len
))
355 /* Second, look for a branch back to it. */
356 insn
= read_memory_integer (loc
, 2, byte_order
);
357 if (insn
!= 0xa714) /* BRC with mask 1 */
360 insn
= read_memory_integer (loc
+ 2, 2, byte_order
);
361 if (insn
!= (uint16_t) -(len
/ 2))
366 /* Found it, step past the whole thing. */
370 /* Displaced stepping. */
372 /* Return true if INSN is a non-branch RIL-b or RIL-c format
376 is_non_branch_ril (gdb_byte
*insn
)
378 gdb_byte op1
= insn
[0];
382 gdb_byte op2
= insn
[1] & 0x0f;
386 case 0x02: /* llhrl */
387 case 0x04: /* lghrl */
388 case 0x05: /* lhrl */
389 case 0x06: /* llghrl */
390 case 0x07: /* sthrl */
391 case 0x08: /* lgrl */
392 case 0x0b: /* stgrl */
393 case 0x0c: /* lgfrl */
395 case 0x0e: /* llgfrl */
396 case 0x0f: /* strl */
400 else if (op1
== 0xc6)
402 gdb_byte op2
= insn
[1] & 0x0f;
406 case 0x00: /* exrl */
407 case 0x02: /* pfdrl */
408 case 0x04: /* cghrl */
409 case 0x05: /* chrl */
410 case 0x06: /* clghrl */
411 case 0x07: /* clhrl */
412 case 0x08: /* cgrl */
413 case 0x0a: /* clgrl */
414 case 0x0c: /* cgfrl */
416 case 0x0e: /* clgfrl */
417 case 0x0f: /* clrl */
425 typedef buf_displaced_step_copy_insn_closure
426 s390_displaced_step_copy_insn_closure
;
428 /* Implementation of gdbarch_displaced_step_copy_insn. */
430 static displaced_step_copy_insn_closure_up
431 s390_displaced_step_copy_insn (struct gdbarch
*gdbarch
,
432 CORE_ADDR from
, CORE_ADDR to
,
433 struct regcache
*regs
)
435 size_t len
= gdbarch_max_insn_length (gdbarch
);
436 std::unique_ptr
<s390_displaced_step_copy_insn_closure
> closure
437 (new s390_displaced_step_copy_insn_closure (len
));
438 gdb_byte
*buf
= closure
->buf
.data ();
440 read_memory (from
, buf
, len
);
442 /* Adjust the displacement field of PC-relative RIL instructions,
443 except branches. The latter are handled in the fixup hook. */
444 if (is_non_branch_ril (buf
))
448 offset
= extract_signed_integer (buf
+ 2, 4, BFD_ENDIAN_BIG
);
449 offset
= (from
- to
+ offset
* 2) / 2;
451 /* If the instruction is too far from the jump pad, punt. This
452 will usually happen with instructions in shared libraries.
453 We could probably support these by rewriting them to be
454 absolute or fully emulating them. */
455 if (offset
< INT32_MIN
|| offset
> INT32_MAX
)
457 /* Let the core fall back to stepping over the breakpoint
459 displaced_debug_printf ("can't displaced step RIL instruction: offset "
460 "%s out of range", plongest (offset
));
465 store_signed_integer (buf
+ 2, 4, BFD_ENDIAN_BIG
, offset
);
468 write_memory (to
, buf
, len
);
470 displaced_debug_printf ("copy %s->%s: %s",
471 paddress (gdbarch
, from
), paddress (gdbarch
, to
),
472 displaced_step_dump_bytes (buf
, len
).c_str ());
474 /* This is a work around for a problem with g++ 4.8. */
475 return displaced_step_copy_insn_closure_up (closure
.release ());
478 /* Fix up the state of registers and memory after having single-stepped
479 a displaced instruction. */
482 s390_displaced_step_fixup (struct gdbarch
*gdbarch
,
483 displaced_step_copy_insn_closure
*closure_
,
484 CORE_ADDR from
, CORE_ADDR to
,
485 struct regcache
*regs
)
487 /* Our closure is a copy of the instruction. */
488 s390_displaced_step_copy_insn_closure
*closure
489 = (s390_displaced_step_copy_insn_closure
*) closure_
;
490 gdb_byte
*insn
= closure
->buf
.data ();
491 static int s390_instrlen
[] = { 2, 4, 4, 6 };
492 int insnlen
= s390_instrlen
[insn
[0] >> 6];
494 /* Fields for various kinds of instructions. */
495 unsigned int b2
, r1
, r2
, x2
, r3
;
498 /* Get current PC and addressing mode bit. */
499 CORE_ADDR pc
= regcache_read_pc (regs
);
502 if (register_size (gdbarch
, S390_PSWA_REGNUM
) == 4)
504 regcache_cooked_read_unsigned (regs
, S390_PSWA_REGNUM
, &amode
);
508 displaced_debug_printf ("(s390) fixup (%s, %s) pc %s len %d amode 0x%x",
509 paddress (gdbarch
, from
), paddress (gdbarch
, to
),
510 paddress (gdbarch
, pc
), insnlen
, (int) amode
);
512 /* Handle absolute branch and save instructions. */
513 int op_basr_p
= is_rr (insn
, op_basr
, &r1
, &r2
);
515 || is_rx (insn
, op_bas
, &r1
, &d2
, &x2
, &b2
))
517 /* Recompute saved return address in R1. */
518 regcache_cooked_write_unsigned (regs
, S390_R0_REGNUM
+ r1
,
519 amode
| (from
+ insnlen
));
520 /* Update PC iff the instruction doesn't actually branch. */
521 if (op_basr_p
&& r2
== 0)
522 regcache_write_pc (regs
, from
+ insnlen
);
525 /* Handle absolute branch instructions. */
526 else if (is_rr (insn
, op_bcr
, &r1
, &r2
)
527 || is_rx (insn
, op_bc
, &r1
, &d2
, &x2
, &b2
)
528 || is_rr (insn
, op_bctr
, &r1
, &r2
)
529 || is_rre (insn
, op_bctgr
, &r1
, &r2
)
530 || is_rx (insn
, op_bct
, &r1
, &d2
, &x2
, &b2
)
531 || is_rxy (insn
, op1_bctg
, op2_brctg
, &r1
, &d2
, &x2
, &b2
)
532 || is_rs (insn
, op_bxh
, &r1
, &r3
, &d2
, &b2
)
533 || is_rsy (insn
, op1_bxhg
, op2_bxhg
, &r1
, &r3
, &d2
, &b2
)
534 || is_rs (insn
, op_bxle
, &r1
, &r3
, &d2
, &b2
)
535 || is_rsy (insn
, op1_bxleg
, op2_bxleg
, &r1
, &r3
, &d2
, &b2
))
537 /* Update PC iff branch was *not* taken. */
538 if (pc
== to
+ insnlen
)
539 regcache_write_pc (regs
, from
+ insnlen
);
542 /* Handle PC-relative branch and save instructions. */
543 else if (is_ri (insn
, op1_bras
, op2_bras
, &r1
, &i2
)
544 || is_ril (insn
, op1_brasl
, op2_brasl
, &r1
, &i2
))
547 regcache_write_pc (regs
, pc
- to
+ from
);
548 /* Recompute saved return address in R1. */
549 regcache_cooked_write_unsigned (regs
, S390_R0_REGNUM
+ r1
,
550 amode
| (from
+ insnlen
));
553 /* Handle LOAD ADDRESS RELATIVE LONG. */
554 else if (is_ril (insn
, op1_larl
, op2_larl
, &r1
, &i2
))
557 regcache_write_pc (regs
, from
+ insnlen
);
558 /* Recompute output address in R1. */
559 regcache_cooked_write_unsigned (regs
, S390_R0_REGNUM
+ r1
,
560 amode
| (from
+ i2
* 2));
563 /* If we executed a breakpoint instruction, point PC right back at it. */
564 else if (insn
[0] == 0x0 && insn
[1] == 0x1)
565 regcache_write_pc (regs
, from
);
567 /* For any other insn, adjust PC by negated displacement. PC then
568 points right after the original instruction, except for PC-relative
569 branches, where it points to the adjusted branch target. */
571 regcache_write_pc (regs
, pc
- to
+ from
);
573 displaced_debug_printf ("(s390) pc is now %s",
574 paddress (gdbarch
, regcache_read_pc (regs
)));
577 /* Implement displaced_step_hw_singlestep gdbarch method. */
580 s390_displaced_step_hw_singlestep (struct gdbarch
*gdbarch
)
585 /* Prologue analysis. */
587 struct s390_prologue_data
{
590 struct pv_area
*stack
;
592 /* The size and byte-order of a GPR or FPR. */
595 enum bfd_endian byte_order
;
597 /* The general-purpose registers. */
598 pv_t gpr
[S390_NUM_GPRS
];
600 /* The floating-point registers. */
601 pv_t fpr
[S390_NUM_FPRS
];
603 /* The offset relative to the CFA where the incoming GPR N was saved
604 by the function prologue. 0 if not saved or unknown. */
605 int gpr_slot
[S390_NUM_GPRS
];
607 /* Likewise for FPRs. */
608 int fpr_slot
[S390_NUM_FPRS
];
610 /* Nonzero if the backchain was saved. This is assumed to be the
611 case when the incoming SP is saved at the current SP location. */
612 int back_chain_saved_p
;
615 /* Return the effective address for an X-style instruction, like:
619 Here, X2 and B2 are registers, and D2 is a signed 20-bit
620 constant; the effective address is the sum of all three. If either
621 X2 or B2 are zero, then it doesn't contribute to the sum --- this
622 means that r0 can't be used as either X2 or B2. */
625 s390_addr (struct s390_prologue_data
*data
,
626 int d2
, unsigned int x2
, unsigned int b2
)
630 result
= pv_constant (d2
);
632 result
= pv_add (result
, data
->gpr
[x2
]);
634 result
= pv_add (result
, data
->gpr
[b2
]);
639 /* Do a SIZE-byte store of VALUE to D2(X2,B2). */
642 s390_store (struct s390_prologue_data
*data
,
643 int d2
, unsigned int x2
, unsigned int b2
, CORE_ADDR size
,
646 pv_t addr
= s390_addr (data
, d2
, x2
, b2
);
649 /* Check whether we are storing the backchain. */
650 offset
= pv_subtract (data
->gpr
[S390_SP_REGNUM
- S390_R0_REGNUM
], addr
);
652 if (pv_is_constant (offset
) && offset
.k
== 0)
653 if (size
== data
->gpr_size
654 && pv_is_register_k (value
, S390_SP_REGNUM
, 0))
656 data
->back_chain_saved_p
= 1;
660 /* Check whether we are storing a register into the stack. */
661 if (!data
->stack
->store_would_trash (addr
))
662 data
->stack
->store (addr
, size
, value
);
664 /* Note: If this is some store we cannot identify, you might think we
665 should forget our cached values, as any of those might have been hit.
667 However, we make the assumption that the register save areas are only
668 ever stored to once in any given function, and we do recognize these
669 stores. Thus every store we cannot recognize does not hit our data. */
672 /* Do a SIZE-byte load from D2(X2,B2). */
675 s390_load (struct s390_prologue_data
*data
,
676 int d2
, unsigned int x2
, unsigned int b2
, CORE_ADDR size
)
679 pv_t addr
= s390_addr (data
, d2
, x2
, b2
);
681 /* If it's a load from an in-line constant pool, then we can
682 simulate that, under the assumption that the code isn't
683 going to change between the time the processor actually
684 executed it creating the current frame, and the time when
685 we're analyzing the code to unwind past that frame. */
686 if (pv_is_constant (addr
))
688 const struct target_section
*secp
689 = target_section_by_addr (current_inferior ()->top_target (), addr
.k
);
691 && (bfd_section_flags (secp
->the_bfd_section
) & SEC_READONLY
))
692 return pv_constant (read_memory_integer (addr
.k
, size
,
696 /* Check whether we are accessing one of our save slots. */
697 return data
->stack
->fetch (addr
, size
);
700 /* Function for finding saved registers in a 'struct pv_area'; we pass
701 this to pv_area::scan.
703 If VALUE is a saved register, ADDR says it was saved at a constant
704 offset from the frame base, and SIZE indicates that the whole
705 register was saved, record its offset in the reg_offset table in
709 s390_check_for_saved (void *data_untyped
, pv_t addr
,
710 CORE_ADDR size
, pv_t value
)
712 struct s390_prologue_data
*data
= (struct s390_prologue_data
*) data_untyped
;
715 if (!pv_is_register (addr
, S390_SP_REGNUM
))
718 offset
= 16 * data
->gpr_size
+ 32 - addr
.k
;
720 /* If we are storing the original value of a register, we want to
721 record the CFA offset. If the same register is stored multiple
722 times, the stack slot with the highest address counts. */
724 for (i
= 0; i
< S390_NUM_GPRS
; i
++)
725 if (size
== data
->gpr_size
726 && pv_is_register_k (value
, S390_R0_REGNUM
+ i
, 0))
727 if (data
->gpr_slot
[i
] == 0
728 || data
->gpr_slot
[i
] > offset
)
730 data
->gpr_slot
[i
] = offset
;
734 for (i
= 0; i
< S390_NUM_FPRS
; i
++)
735 if (size
== data
->fpr_size
736 && pv_is_register_k (value
, S390_F0_REGNUM
+ i
, 0))
737 if (data
->fpr_slot
[i
] == 0
738 || data
->fpr_slot
[i
] > offset
)
740 data
->fpr_slot
[i
] = offset
;
745 /* Analyze the prologue of the function starting at START_PC, continuing at
746 most until CURRENT_PC. Initialize DATA to hold all information we find
747 out about the state of the registers and stack slots. Return the address
748 of the instruction after the last one that changed the SP, FP, or back
749 chain; or zero on error. */
752 s390_analyze_prologue (struct gdbarch
*gdbarch
,
754 CORE_ADDR current_pc
,
755 struct s390_prologue_data
*data
)
757 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
760 The address of the instruction after the last one that changed
761 the SP, FP, or back chain; zero if we got an error trying to
763 CORE_ADDR result
= start_pc
;
765 /* The current PC for our abstract interpretation. */
768 /* The address of the next instruction after that. */
771 pv_area
stack (S390_SP_REGNUM
, gdbarch_addr_bit (gdbarch
));
772 scoped_restore restore_stack
= make_scoped_restore (&data
->stack
, &stack
);
774 /* Set up everything's initial value. */
778 /* For the purpose of prologue tracking, we consider the GPR size to
779 be equal to the ABI word size, even if it is actually larger
780 (i.e. when running a 32-bit binary under a 64-bit kernel). */
781 data
->gpr_size
= word_size
;
783 data
->byte_order
= gdbarch_byte_order (gdbarch
);
785 for (i
= 0; i
< S390_NUM_GPRS
; i
++)
786 data
->gpr
[i
] = pv_register (S390_R0_REGNUM
+ i
, 0);
788 for (i
= 0; i
< S390_NUM_FPRS
; i
++)
789 data
->fpr
[i
] = pv_register (S390_F0_REGNUM
+ i
, 0);
791 for (i
= 0; i
< S390_NUM_GPRS
; i
++)
792 data
->gpr_slot
[i
] = 0;
794 for (i
= 0; i
< S390_NUM_FPRS
; i
++)
795 data
->fpr_slot
[i
] = 0;
797 data
->back_chain_saved_p
= 0;
800 /* Start interpreting instructions, until we hit the frame's
801 current PC or the first branch instruction. */
802 for (pc
= start_pc
; pc
> 0 && pc
< current_pc
; pc
= next_pc
)
804 bfd_byte insn
[S390_MAX_INSTR_SIZE
];
805 int insn_len
= s390_readinstruction (insn
, pc
);
807 bfd_byte dummy
[S390_MAX_INSTR_SIZE
] = { 0 };
808 bfd_byte
*insn32
= word_size
== 4 ? insn
: dummy
;
809 bfd_byte
*insn64
= word_size
== 8 ? insn
: dummy
;
811 /* Fields for various kinds of instructions. */
812 unsigned int b2
, r1
, r2
, x2
, r3
;
815 /* The values of SP and FP before this instruction,
816 for detecting instructions that change them. */
817 pv_t pre_insn_sp
, pre_insn_fp
;
818 /* Likewise for the flag whether the back chain was saved. */
819 int pre_insn_back_chain_saved_p
;
821 /* If we got an error trying to read the instruction, report it. */
828 next_pc
= pc
+ insn_len
;
830 pre_insn_sp
= data
->gpr
[S390_SP_REGNUM
- S390_R0_REGNUM
];
831 pre_insn_fp
= data
->gpr
[S390_FRAME_REGNUM
- S390_R0_REGNUM
];
832 pre_insn_back_chain_saved_p
= data
->back_chain_saved_p
;
834 /* LHI r1, i2 --- load halfword immediate. */
835 /* LGHI r1, i2 --- load halfword immediate (64-bit version). */
836 /* LGFI r1, i2 --- load fullword immediate. */
837 if (is_ri (insn32
, op1_lhi
, op2_lhi
, &r1
, &i2
)
838 || is_ri (insn64
, op1_lghi
, op2_lghi
, &r1
, &i2
)
839 || is_ril (insn
, op1_lgfi
, op2_lgfi
, &r1
, &i2
))
840 data
->gpr
[r1
] = pv_constant (i2
);
842 /* LR r1, r2 --- load from register. */
843 /* LGR r1, r2 --- load from register (64-bit version). */
844 else if (is_rr (insn32
, op_lr
, &r1
, &r2
)
845 || is_rre (insn64
, op_lgr
, &r1
, &r2
))
846 data
->gpr
[r1
] = data
->gpr
[r2
];
848 /* L r1, d2(x2, b2) --- load. */
849 /* LY r1, d2(x2, b2) --- load (long-displacement version). */
850 /* LG r1, d2(x2, b2) --- load (64-bit version). */
851 else if (is_rx (insn32
, op_l
, &r1
, &d2
, &x2
, &b2
)
852 || is_rxy (insn32
, op1_ly
, op2_ly
, &r1
, &d2
, &x2
, &b2
)
853 || is_rxy (insn64
, op1_lg
, op2_lg
, &r1
, &d2
, &x2
, &b2
))
854 data
->gpr
[r1
] = s390_load (data
, d2
, x2
, b2
, data
->gpr_size
);
856 /* ST r1, d2(x2, b2) --- store. */
857 /* STY r1, d2(x2, b2) --- store (long-displacement version). */
858 /* STG r1, d2(x2, b2) --- store (64-bit version). */
859 else if (is_rx (insn32
, op_st
, &r1
, &d2
, &x2
, &b2
)
860 || is_rxy (insn32
, op1_sty
, op2_sty
, &r1
, &d2
, &x2
, &b2
)
861 || is_rxy (insn64
, op1_stg
, op2_stg
, &r1
, &d2
, &x2
, &b2
))
862 s390_store (data
, d2
, x2
, b2
, data
->gpr_size
, data
->gpr
[r1
]);
864 /* STD r1, d2(x2,b2) --- store floating-point register. */
865 else if (is_rx (insn
, op_std
, &r1
, &d2
, &x2
, &b2
))
866 s390_store (data
, d2
, x2
, b2
, data
->fpr_size
, data
->fpr
[r1
]);
868 /* STM r1, r3, d2(b2) --- store multiple. */
869 /* STMY r1, r3, d2(b2) --- store multiple (long-displacement
871 /* STMG r1, r3, d2(b2) --- store multiple (64-bit version). */
872 else if (is_rs (insn32
, op_stm
, &r1
, &r3
, &d2
, &b2
)
873 || is_rsy (insn32
, op1_stmy
, op2_stmy
, &r1
, &r3
, &d2
, &b2
)
874 || is_rsy (insn64
, op1_stmg
, op2_stmg
, &r1
, &r3
, &d2
, &b2
))
876 for (; r1
<= r3
; r1
++, d2
+= data
->gpr_size
)
877 s390_store (data
, d2
, 0, b2
, data
->gpr_size
, data
->gpr
[r1
]);
880 /* AHI r1, i2 --- add halfword immediate. */
881 /* AGHI r1, i2 --- add halfword immediate (64-bit version). */
882 /* AFI r1, i2 --- add fullword immediate. */
883 /* AGFI r1, i2 --- add fullword immediate (64-bit version). */
884 else if (is_ri (insn32
, op1_ahi
, op2_ahi
, &r1
, &i2
)
885 || is_ri (insn64
, op1_aghi
, op2_aghi
, &r1
, &i2
)
886 || is_ril (insn32
, op1_afi
, op2_afi
, &r1
, &i2
)
887 || is_ril (insn64
, op1_agfi
, op2_agfi
, &r1
, &i2
))
888 data
->gpr
[r1
] = pv_add_constant (data
->gpr
[r1
], i2
);
890 /* ALFI r1, i2 --- add logical immediate. */
891 /* ALGFI r1, i2 --- add logical immediate (64-bit version). */
892 else if (is_ril (insn32
, op1_alfi
, op2_alfi
, &r1
, &i2
)
893 || is_ril (insn64
, op1_algfi
, op2_algfi
, &r1
, &i2
))
894 data
->gpr
[r1
] = pv_add_constant (data
->gpr
[r1
],
895 (CORE_ADDR
)i2
& 0xffffffff);
897 /* AR r1, r2 -- add register. */
898 /* AGR r1, r2 -- add register (64-bit version). */
899 else if (is_rr (insn32
, op_ar
, &r1
, &r2
)
900 || is_rre (insn64
, op_agr
, &r1
, &r2
))
901 data
->gpr
[r1
] = pv_add (data
->gpr
[r1
], data
->gpr
[r2
]);
903 /* A r1, d2(x2, b2) -- add. */
904 /* AY r1, d2(x2, b2) -- add (long-displacement version). */
905 /* AG r1, d2(x2, b2) -- add (64-bit version). */
906 else if (is_rx (insn32
, op_a
, &r1
, &d2
, &x2
, &b2
)
907 || is_rxy (insn32
, op1_ay
, op2_ay
, &r1
, &d2
, &x2
, &b2
)
908 || is_rxy (insn64
, op1_ag
, op2_ag
, &r1
, &d2
, &x2
, &b2
))
909 data
->gpr
[r1
] = pv_add (data
->gpr
[r1
],
910 s390_load (data
, d2
, x2
, b2
, data
->gpr_size
));
912 /* SLFI r1, i2 --- subtract logical immediate. */
913 /* SLGFI r1, i2 --- subtract logical immediate (64-bit version). */
914 else if (is_ril (insn32
, op1_slfi
, op2_slfi
, &r1
, &i2
)
915 || is_ril (insn64
, op1_slgfi
, op2_slgfi
, &r1
, &i2
))
916 data
->gpr
[r1
] = pv_add_constant (data
->gpr
[r1
],
917 -((CORE_ADDR
)i2
& 0xffffffff));
919 /* SR r1, r2 -- subtract register. */
920 /* SGR r1, r2 -- subtract register (64-bit version). */
921 else if (is_rr (insn32
, op_sr
, &r1
, &r2
)
922 || is_rre (insn64
, op_sgr
, &r1
, &r2
))
923 data
->gpr
[r1
] = pv_subtract (data
->gpr
[r1
], data
->gpr
[r2
]);
925 /* S r1, d2(x2, b2) -- subtract. */
926 /* SY r1, d2(x2, b2) -- subtract (long-displacement version). */
927 /* SG r1, d2(x2, b2) -- subtract (64-bit version). */
928 else if (is_rx (insn32
, op_s
, &r1
, &d2
, &x2
, &b2
)
929 || is_rxy (insn32
, op1_sy
, op2_sy
, &r1
, &d2
, &x2
, &b2
)
930 || is_rxy (insn64
, op1_sg
, op2_sg
, &r1
, &d2
, &x2
, &b2
))
931 data
->gpr
[r1
] = pv_subtract (data
->gpr
[r1
],
932 s390_load (data
, d2
, x2
, b2
, data
->gpr_size
));
934 /* LA r1, d2(x2, b2) --- load address. */
935 /* LAY r1, d2(x2, b2) --- load address (long-displacement version). */
936 else if (is_rx (insn
, op_la
, &r1
, &d2
, &x2
, &b2
)
937 || is_rxy (insn
, op1_lay
, op2_lay
, &r1
, &d2
, &x2
, &b2
))
938 data
->gpr
[r1
] = s390_addr (data
, d2
, x2
, b2
);
940 /* LARL r1, i2 --- load address relative long. */
941 else if (is_ril (insn
, op1_larl
, op2_larl
, &r1
, &i2
))
942 data
->gpr
[r1
] = pv_constant (pc
+ i2
* 2);
944 /* BASR r1, 0 --- branch and save.
945 Since r2 is zero, this saves the PC in r1, but doesn't branch. */
946 else if (is_rr (insn
, op_basr
, &r1
, &r2
)
948 data
->gpr
[r1
] = pv_constant (next_pc
);
950 /* BRAS r1, i2 --- branch relative and save. */
951 else if (is_ri (insn
, op1_bras
, op2_bras
, &r1
, &i2
))
953 data
->gpr
[r1
] = pv_constant (next_pc
);
954 next_pc
= pc
+ i2
* 2;
956 /* We'd better not interpret any backward branches. We'll
962 /* BRC/BRCL -- branch relative on condition. Ignore "branch
963 never", branch to following instruction, and "conditional
964 trap" (BRC +2). Otherwise terminate search. */
965 else if (is_ri (insn
, op1_brc
, op2_brc
, &r1
, &i2
))
967 if (r1
!= 0 && i2
!= 1 && i2
!= 2)
970 else if (is_ril (insn
, op1_brcl
, op2_brcl
, &r1
, &i2
))
972 if (r1
!= 0 && i2
!= 3)
976 /* Terminate search when hitting any other branch instruction. */
977 else if (is_rr (insn
, op_basr
, &r1
, &r2
)
978 || is_rx (insn
, op_bas
, &r1
, &d2
, &x2
, &b2
)
979 || is_rr (insn
, op_bcr
, &r1
, &r2
)
980 || is_rx (insn
, op_bc
, &r1
, &d2
, &x2
, &b2
)
981 || is_ril (insn
, op1_brasl
, op2_brasl
, &r2
, &i2
))
986 /* An instruction we don't know how to simulate. The only
987 safe thing to do would be to set every value we're tracking
988 to 'unknown'. Instead, we'll be optimistic: we assume that
989 we *can* interpret every instruction that the compiler uses
990 to manipulate any of the data we're interested in here --
991 then we can just ignore anything else. */
994 /* Record the address after the last instruction that changed
995 the FP, SP, or backlink. Ignore instructions that changed
996 them back to their original values --- those are probably
997 restore instructions. (The back chain is never restored,
1000 pv_t sp
= data
->gpr
[S390_SP_REGNUM
- S390_R0_REGNUM
];
1001 pv_t fp
= data
->gpr
[S390_FRAME_REGNUM
- S390_R0_REGNUM
];
1003 if ((! pv_is_identical (pre_insn_sp
, sp
)
1004 && ! pv_is_register_k (sp
, S390_SP_REGNUM
, 0)
1005 && sp
.kind
!= pvk_unknown
)
1006 || (! pv_is_identical (pre_insn_fp
, fp
)
1007 && ! pv_is_register_k (fp
, S390_FRAME_REGNUM
, 0)
1008 && fp
.kind
!= pvk_unknown
)
1009 || pre_insn_back_chain_saved_p
!= data
->back_chain_saved_p
)
1014 /* Record where all the registers were saved. */
1015 data
->stack
->scan (s390_check_for_saved
, data
);
1020 /* Advance PC across any function entry prologue instructions to reach
1021 some "real" code. */
1024 s390_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
1026 struct s390_prologue_data data
;
1027 CORE_ADDR skip_pc
, func_addr
;
1029 if (find_pc_partial_function (pc
, NULL
, &func_addr
, NULL
))
1031 CORE_ADDR post_prologue_pc
1032 = skip_prologue_using_sal (gdbarch
, func_addr
);
1033 if (post_prologue_pc
!= 0)
1034 return std::max (pc
, post_prologue_pc
);
1037 skip_pc
= s390_analyze_prologue (gdbarch
, pc
, (CORE_ADDR
)-1, &data
);
1038 return skip_pc
? skip_pc
: pc
;
1041 /* Register handling. */
1043 /* ABI call-saved register information. */
1046 s390_register_call_saved (struct gdbarch
*gdbarch
, int regnum
)
1048 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1052 case ABI_LINUX_S390
:
1053 if ((regnum
>= S390_R6_REGNUM
&& regnum
<= S390_R15_REGNUM
)
1054 || regnum
== S390_F4_REGNUM
|| regnum
== S390_F6_REGNUM
1055 || regnum
== S390_A0_REGNUM
)
1060 case ABI_LINUX_ZSERIES
:
1061 if ((regnum
>= S390_R6_REGNUM
&& regnum
<= S390_R15_REGNUM
)
1062 || (regnum
>= S390_F8_REGNUM
&& regnum
<= S390_F15_REGNUM
)
1063 || (regnum
>= S390_A0_REGNUM
&& regnum
<= S390_A1_REGNUM
))
1072 /* The "guess_tracepoint_registers" gdbarch method. */
1075 s390_guess_tracepoint_registers (struct gdbarch
*gdbarch
,
1076 struct regcache
*regcache
,
1079 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1080 int sz
= register_size (gdbarch
, S390_PSWA_REGNUM
);
1081 gdb_byte
*reg
= (gdb_byte
*) alloca (sz
);
1082 ULONGEST pswm
, pswa
;
1084 /* Set PSWA from the location and a default PSWM (the only part we're
1085 unlikely to get right is the CC). */
1086 if (tdep
->abi
== ABI_LINUX_S390
)
1088 /* 31-bit PSWA needs high bit set (it's very unlikely the target
1089 was in 24-bit mode). */
1090 pswa
= addr
| 0x80000000UL
;
1091 pswm
= 0x070d0000UL
;
1096 pswm
= 0x0705000180000000ULL
;
1099 store_unsigned_integer (reg
, sz
, gdbarch_byte_order (gdbarch
), pswa
);
1100 regcache
->raw_supply (S390_PSWA_REGNUM
, reg
);
1102 store_unsigned_integer (reg
, sz
, gdbarch_byte_order (gdbarch
), pswm
);
1103 regcache
->raw_supply (S390_PSWM_REGNUM
, reg
);
1106 /* Return the name of register REGNO. Return the empty string for
1107 registers that shouldn't be visible. */
1110 s390_register_name (struct gdbarch
*gdbarch
, int regnum
)
1112 if (regnum
>= S390_V0_LOWER_REGNUM
1113 && regnum
<= S390_V15_LOWER_REGNUM
)
1115 return tdesc_register_name (gdbarch
, regnum
);
1118 /* DWARF Register Mapping. */
1120 static const short s390_dwarf_regmap
[] =
1122 /* 0-15: General Purpose Registers. */
1123 S390_R0_REGNUM
, S390_R1_REGNUM
, S390_R2_REGNUM
, S390_R3_REGNUM
,
1124 S390_R4_REGNUM
, S390_R5_REGNUM
, S390_R6_REGNUM
, S390_R7_REGNUM
,
1125 S390_R8_REGNUM
, S390_R9_REGNUM
, S390_R10_REGNUM
, S390_R11_REGNUM
,
1126 S390_R12_REGNUM
, S390_R13_REGNUM
, S390_R14_REGNUM
, S390_R15_REGNUM
,
1128 /* 16-31: Floating Point Registers / Vector Registers 0-15. */
1129 S390_F0_REGNUM
, S390_F2_REGNUM
, S390_F4_REGNUM
, S390_F6_REGNUM
,
1130 S390_F1_REGNUM
, S390_F3_REGNUM
, S390_F5_REGNUM
, S390_F7_REGNUM
,
1131 S390_F8_REGNUM
, S390_F10_REGNUM
, S390_F12_REGNUM
, S390_F14_REGNUM
,
1132 S390_F9_REGNUM
, S390_F11_REGNUM
, S390_F13_REGNUM
, S390_F15_REGNUM
,
1134 /* 32-47: Control Registers (not mapped). */
1135 -1, -1, -1, -1, -1, -1, -1, -1,
1136 -1, -1, -1, -1, -1, -1, -1, -1,
1138 /* 48-63: Access Registers. */
1139 S390_A0_REGNUM
, S390_A1_REGNUM
, S390_A2_REGNUM
, S390_A3_REGNUM
,
1140 S390_A4_REGNUM
, S390_A5_REGNUM
, S390_A6_REGNUM
, S390_A7_REGNUM
,
1141 S390_A8_REGNUM
, S390_A9_REGNUM
, S390_A10_REGNUM
, S390_A11_REGNUM
,
1142 S390_A12_REGNUM
, S390_A13_REGNUM
, S390_A14_REGNUM
, S390_A15_REGNUM
,
1144 /* 64-65: Program Status Word. */
1148 /* 66-67: Reserved. */
1151 /* 68-83: Vector Registers 16-31. */
1152 S390_V16_REGNUM
, S390_V18_REGNUM
, S390_V20_REGNUM
, S390_V22_REGNUM
,
1153 S390_V17_REGNUM
, S390_V19_REGNUM
, S390_V21_REGNUM
, S390_V23_REGNUM
,
1154 S390_V24_REGNUM
, S390_V26_REGNUM
, S390_V28_REGNUM
, S390_V30_REGNUM
,
1155 S390_V25_REGNUM
, S390_V27_REGNUM
, S390_V29_REGNUM
, S390_V31_REGNUM
,
1157 /* End of "official" DWARF registers. The remainder of the map is
1158 for GDB internal use only. */
1160 /* GPR Lower Half Access. */
1161 S390_R0_REGNUM
, S390_R1_REGNUM
, S390_R2_REGNUM
, S390_R3_REGNUM
,
1162 S390_R4_REGNUM
, S390_R5_REGNUM
, S390_R6_REGNUM
, S390_R7_REGNUM
,
1163 S390_R8_REGNUM
, S390_R9_REGNUM
, S390_R10_REGNUM
, S390_R11_REGNUM
,
1164 S390_R12_REGNUM
, S390_R13_REGNUM
, S390_R14_REGNUM
, S390_R15_REGNUM
,
1167 enum { s390_dwarf_reg_r0l
= ARRAY_SIZE (s390_dwarf_regmap
) - 16 };
1169 /* Convert DWARF register number REG to the appropriate register
1170 number used by GDB. */
1173 s390_dwarf_reg_to_regnum (struct gdbarch
*gdbarch
, int reg
)
1175 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1178 /* In a 32-on-64 debug scenario, debug info refers to the full
1179 64-bit GPRs. Note that call frame information still refers to
1180 the 32-bit lower halves, because s390_adjust_frame_regnum uses
1181 special register numbers to access GPRs. */
1182 if (tdep
->gpr_full_regnum
!= -1 && reg
>= 0 && reg
< 16)
1183 return tdep
->gpr_full_regnum
+ reg
;
1185 if (reg
>= 0 && reg
< ARRAY_SIZE (s390_dwarf_regmap
))
1186 gdb_reg
= s390_dwarf_regmap
[reg
];
1188 if (tdep
->v0_full_regnum
== -1)
1190 if (gdb_reg
>= S390_V16_REGNUM
&& gdb_reg
<= S390_V31_REGNUM
)
1195 if (gdb_reg
>= S390_F0_REGNUM
&& gdb_reg
<= S390_F15_REGNUM
)
1196 gdb_reg
= gdb_reg
- S390_F0_REGNUM
+ tdep
->v0_full_regnum
;
1202 /* Pseudo registers. */
1204 /* Check whether REGNUM indicates a coupled general purpose register.
1205 These pseudo-registers are composed of two adjacent gprs. */
1208 regnum_is_gpr_full (struct gdbarch_tdep
*tdep
, int regnum
)
1210 return (tdep
->gpr_full_regnum
!= -1
1211 && regnum
>= tdep
->gpr_full_regnum
1212 && regnum
<= tdep
->gpr_full_regnum
+ 15);
1215 /* Check whether REGNUM indicates a full vector register (v0-v15).
1216 These pseudo-registers are composed of f0-f15 and v0l-v15l. */
1219 regnum_is_vxr_full (struct gdbarch_tdep
*tdep
, int regnum
)
1221 return (tdep
->v0_full_regnum
!= -1
1222 && regnum
>= tdep
->v0_full_regnum
1223 && regnum
<= tdep
->v0_full_regnum
+ 15);
1226 /* 'float' values are stored in the upper half of floating-point
1227 registers, even though we are otherwise a big-endian platform. The
1228 same applies to a 'float' value within a vector. */
1230 static struct value
*
1231 s390_value_from_register (struct gdbarch
*gdbarch
, struct type
*type
,
1232 int regnum
, struct frame_id frame_id
)
1234 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1235 struct value
*value
= default_value_from_register (gdbarch
, type
,
1237 check_typedef (type
);
1239 if ((regnum
>= S390_F0_REGNUM
&& regnum
<= S390_F15_REGNUM
1240 && TYPE_LENGTH (type
) < 8)
1241 || regnum_is_vxr_full (tdep
, regnum
)
1242 || (regnum
>= S390_V16_REGNUM
&& regnum
<= S390_V31_REGNUM
))
1243 set_value_offset (value
, 0);
1248 /* Implement pseudo_register_name tdesc method. */
1251 s390_pseudo_register_name (struct gdbarch
*gdbarch
, int regnum
)
1253 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1255 if (regnum
== tdep
->pc_regnum
)
1258 if (regnum
== tdep
->cc_regnum
)
1261 if (regnum_is_gpr_full (tdep
, regnum
))
1263 static const char *full_name
[] = {
1264 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1265 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
1267 return full_name
[regnum
- tdep
->gpr_full_regnum
];
1270 if (regnum_is_vxr_full (tdep
, regnum
))
1272 static const char *full_name
[] = {
1273 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
1274 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15"
1276 return full_name
[regnum
- tdep
->v0_full_regnum
];
1279 internal_error (__FILE__
, __LINE__
, _("invalid regnum"));
1282 /* Implement pseudo_register_type tdesc method. */
1284 static struct type
*
1285 s390_pseudo_register_type (struct gdbarch
*gdbarch
, int regnum
)
1287 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1289 if (regnum
== tdep
->pc_regnum
)
1290 return builtin_type (gdbarch
)->builtin_func_ptr
;
1292 if (regnum
== tdep
->cc_regnum
)
1293 return builtin_type (gdbarch
)->builtin_int
;
1295 if (regnum_is_gpr_full (tdep
, regnum
))
1296 return builtin_type (gdbarch
)->builtin_uint64
;
1298 /* For the "concatenated" vector registers use the same type as v16. */
1299 if (regnum_is_vxr_full (tdep
, regnum
))
1300 return tdesc_register_type (gdbarch
, S390_V16_REGNUM
);
1302 internal_error (__FILE__
, __LINE__
, _("invalid regnum"));
1305 /* Implement pseudo_register_read gdbarch method. */
1307 static enum register_status
1308 s390_pseudo_register_read (struct gdbarch
*gdbarch
, readable_regcache
*regcache
,
1309 int regnum
, gdb_byte
*buf
)
1311 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1312 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1313 int regsize
= register_size (gdbarch
, regnum
);
1316 if (regnum
== tdep
->pc_regnum
)
1318 enum register_status status
;
1320 status
= regcache
->raw_read (S390_PSWA_REGNUM
, &val
);
1321 if (status
== REG_VALID
)
1323 if (register_size (gdbarch
, S390_PSWA_REGNUM
) == 4)
1325 store_unsigned_integer (buf
, regsize
, byte_order
, val
);
1330 if (regnum
== tdep
->cc_regnum
)
1332 enum register_status status
;
1334 status
= regcache
->raw_read (S390_PSWM_REGNUM
, &val
);
1335 if (status
== REG_VALID
)
1337 if (register_size (gdbarch
, S390_PSWA_REGNUM
) == 4)
1338 val
= (val
>> 12) & 3;
1340 val
= (val
>> 44) & 3;
1341 store_unsigned_integer (buf
, regsize
, byte_order
, val
);
1346 if (regnum_is_gpr_full (tdep
, regnum
))
1348 enum register_status status
;
1351 regnum
-= tdep
->gpr_full_regnum
;
1353 status
= regcache
->raw_read (S390_R0_REGNUM
+ regnum
, &val
);
1354 if (status
== REG_VALID
)
1355 status
= regcache
->raw_read (S390_R0_UPPER_REGNUM
+ regnum
,
1357 if (status
== REG_VALID
)
1359 val
|= val_upper
<< 32;
1360 store_unsigned_integer (buf
, regsize
, byte_order
, val
);
1365 if (regnum_is_vxr_full (tdep
, regnum
))
1367 enum register_status status
;
1369 regnum
-= tdep
->v0_full_regnum
;
1371 status
= regcache
->raw_read (S390_F0_REGNUM
+ regnum
, buf
);
1372 if (status
== REG_VALID
)
1373 status
= regcache
->raw_read (S390_V0_LOWER_REGNUM
+ regnum
, buf
+ 8);
1377 internal_error (__FILE__
, __LINE__
, _("invalid regnum"));
1380 /* Implement pseudo_register_write gdbarch method. */
1383 s390_pseudo_register_write (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
1384 int regnum
, const gdb_byte
*buf
)
1386 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1387 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1388 int regsize
= register_size (gdbarch
, regnum
);
1391 if (regnum
== tdep
->pc_regnum
)
1393 val
= extract_unsigned_integer (buf
, regsize
, byte_order
);
1394 if (register_size (gdbarch
, S390_PSWA_REGNUM
) == 4)
1396 regcache_raw_read_unsigned (regcache
, S390_PSWA_REGNUM
, &psw
);
1397 val
= (psw
& 0x80000000) | (val
& 0x7fffffff);
1399 regcache_raw_write_unsigned (regcache
, S390_PSWA_REGNUM
, val
);
1403 if (regnum
== tdep
->cc_regnum
)
1405 val
= extract_unsigned_integer (buf
, regsize
, byte_order
);
1406 regcache_raw_read_unsigned (regcache
, S390_PSWM_REGNUM
, &psw
);
1407 if (register_size (gdbarch
, S390_PSWA_REGNUM
) == 4)
1408 val
= (psw
& ~((ULONGEST
)3 << 12)) | ((val
& 3) << 12);
1410 val
= (psw
& ~((ULONGEST
)3 << 44)) | ((val
& 3) << 44);
1411 regcache_raw_write_unsigned (regcache
, S390_PSWM_REGNUM
, val
);
1415 if (regnum_is_gpr_full (tdep
, regnum
))
1417 regnum
-= tdep
->gpr_full_regnum
;
1418 val
= extract_unsigned_integer (buf
, regsize
, byte_order
);
1419 regcache_raw_write_unsigned (regcache
, S390_R0_REGNUM
+ regnum
,
1421 regcache_raw_write_unsigned (regcache
, S390_R0_UPPER_REGNUM
+ regnum
,
1426 if (regnum_is_vxr_full (tdep
, regnum
))
1428 regnum
-= tdep
->v0_full_regnum
;
1429 regcache
->raw_write (S390_F0_REGNUM
+ regnum
, buf
);
1430 regcache
->raw_write (S390_V0_LOWER_REGNUM
+ regnum
, buf
+ 8);
1434 internal_error (__FILE__
, __LINE__
, _("invalid regnum"));
1437 /* Register groups. */
1439 /* Implement pseudo_register_reggroup_p tdesc method. */
1442 s390_pseudo_register_reggroup_p (struct gdbarch
*gdbarch
, int regnum
,
1443 struct reggroup
*group
)
1445 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1447 /* We usually save/restore the whole PSW, which includes PC and CC.
1448 However, some older gdbservers may not support saving/restoring
1449 the whole PSW yet, and will return an XML register description
1450 excluding those from the save/restore register groups. In those
1451 cases, we still need to explicitly save/restore PC and CC in order
1452 to push or pop frames. Since this doesn't hurt anything if we
1453 already save/restore the whole PSW (it's just redundant), we add
1454 PC and CC at this point unconditionally. */
1455 if (group
== save_reggroup
|| group
== restore_reggroup
)
1456 return regnum
== tdep
->pc_regnum
|| regnum
== tdep
->cc_regnum
;
1458 if (group
== vector_reggroup
)
1459 return regnum_is_vxr_full (tdep
, regnum
);
1461 if (group
== general_reggroup
&& regnum_is_vxr_full (tdep
, regnum
))
1464 return default_register_reggroup_p (gdbarch
, regnum
, group
);
1467 /* The "ax_pseudo_register_collect" gdbarch method. */
1470 s390_ax_pseudo_register_collect (struct gdbarch
*gdbarch
,
1471 struct agent_expr
*ax
, int regnum
)
1473 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1474 if (regnum
== tdep
->pc_regnum
)
1476 ax_reg_mask (ax
, S390_PSWA_REGNUM
);
1478 else if (regnum
== tdep
->cc_regnum
)
1480 ax_reg_mask (ax
, S390_PSWM_REGNUM
);
1482 else if (regnum_is_gpr_full (tdep
, regnum
))
1484 regnum
-= tdep
->gpr_full_regnum
;
1485 ax_reg_mask (ax
, S390_R0_REGNUM
+ regnum
);
1486 ax_reg_mask (ax
, S390_R0_UPPER_REGNUM
+ regnum
);
1488 else if (regnum_is_vxr_full (tdep
, regnum
))
1490 regnum
-= tdep
->v0_full_regnum
;
1491 ax_reg_mask (ax
, S390_F0_REGNUM
+ regnum
);
1492 ax_reg_mask (ax
, S390_V0_LOWER_REGNUM
+ regnum
);
1496 internal_error (__FILE__
, __LINE__
, _("invalid regnum"));
1501 /* The "ax_pseudo_register_push_stack" gdbarch method. */
1504 s390_ax_pseudo_register_push_stack (struct gdbarch
*gdbarch
,
1505 struct agent_expr
*ax
, int regnum
)
1507 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1508 if (regnum
== tdep
->pc_regnum
)
1510 ax_reg (ax
, S390_PSWA_REGNUM
);
1511 if (register_size (gdbarch
, S390_PSWA_REGNUM
) == 4)
1513 ax_zero_ext (ax
, 31);
1516 else if (regnum
== tdep
->cc_regnum
)
1518 ax_reg (ax
, S390_PSWM_REGNUM
);
1519 if (register_size (gdbarch
, S390_PSWA_REGNUM
) == 4)
1520 ax_const_l (ax
, 12);
1522 ax_const_l (ax
, 44);
1523 ax_simple (ax
, aop_rsh_unsigned
);
1524 ax_zero_ext (ax
, 2);
1526 else if (regnum_is_gpr_full (tdep
, regnum
))
1528 regnum
-= tdep
->gpr_full_regnum
;
1529 ax_reg (ax
, S390_R0_REGNUM
+ regnum
);
1530 ax_reg (ax
, S390_R0_UPPER_REGNUM
+ regnum
);
1531 ax_const_l (ax
, 32);
1532 ax_simple (ax
, aop_lsh
);
1533 ax_simple (ax
, aop_bit_or
);
1535 else if (regnum_is_vxr_full (tdep
, regnum
))
1537 /* Too large to stuff on the stack. */
1542 internal_error (__FILE__
, __LINE__
, _("invalid regnum"));
1547 /* The "gen_return_address" gdbarch method. Since this is supposed to be
1548 just a best-effort method, and we don't really have the means to run
1549 the full unwinder here, just collect the link register. */
1552 s390_gen_return_address (struct gdbarch
*gdbarch
,
1553 struct agent_expr
*ax
, struct axs_value
*value
,
1556 value
->type
= register_type (gdbarch
, S390_R14_REGNUM
);
1557 value
->kind
= axs_lvalue_register
;
1558 value
->u
.reg
= S390_R14_REGNUM
;
1561 /* Address handling. */
1563 /* Implement addr_bits_remove gdbarch method.
1564 Only used for ABI_LINUX_S390. */
1567 s390_addr_bits_remove (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1569 return addr
& 0x7fffffff;
1572 /* Implement addr_class_type_flags gdbarch method.
1573 Only used for ABI_LINUX_ZSERIES. */
1575 static type_instance_flags
1576 s390_address_class_type_flags (int byte_size
, int dwarf2_addr_class
)
1579 return TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1
;
1584 /* Implement addr_class_type_flags_to_name gdbarch method.
1585 Only used for ABI_LINUX_ZSERIES. */
1588 s390_address_class_type_flags_to_name (struct gdbarch
*gdbarch
,
1589 type_instance_flags type_flags
)
1591 if (type_flags
& TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1
)
1597 /* Implement addr_class_name_to_type_flags gdbarch method.
1598 Only used for ABI_LINUX_ZSERIES. */
1601 s390_address_class_name_to_type_flags (struct gdbarch
*gdbarch
,
1603 type_instance_flags
*type_flags_ptr
)
1605 if (strcmp (name
, "mode32") == 0)
1607 *type_flags_ptr
= TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1
;
1614 /* Inferior function calls. */
1616 /* Dummy function calls. */
1618 /* Unwrap any single-field structs in TYPE and return the effective
1619 "inner" type. E.g., yield "float" for all these cases:
1623 struct { struct { float x; } x; };
1624 struct { struct { struct { float x; } x; } x; };
1626 However, if an inner type is smaller than MIN_SIZE, abort the
1629 static struct type
*
1630 s390_effective_inner_type (struct type
*type
, unsigned int min_size
)
1632 while (type
->code () == TYPE_CODE_STRUCT
)
1634 struct type
*inner
= NULL
;
1636 /* Find a non-static field, if any. Unless there's exactly one,
1637 abort the unwrapping. */
1638 for (int i
= 0; i
< type
->num_fields (); i
++)
1640 struct field f
= type
->field (i
);
1642 if (field_is_static (&f
))
1651 inner
= check_typedef (inner
);
1652 if (TYPE_LENGTH (inner
) < min_size
)
1660 /* Return non-zero if TYPE should be passed like "float" or
1664 s390_function_arg_float (struct type
*type
)
1666 /* Note that long double as well as complex types are intentionally
1668 if (TYPE_LENGTH (type
) > 8)
1671 /* A struct containing just a float or double is passed like a float
1673 type
= s390_effective_inner_type (type
, 0);
1675 return (type
->code () == TYPE_CODE_FLT
1676 || type
->code () == TYPE_CODE_DECFLOAT
);
1679 /* Return non-zero if TYPE should be passed like a vector. */
1682 s390_function_arg_vector (struct type
*type
)
1684 if (TYPE_LENGTH (type
) > 16)
1687 /* Structs containing just a vector are passed like a vector. */
1688 type
= s390_effective_inner_type (type
, TYPE_LENGTH (type
));
1690 return type
->code () == TYPE_CODE_ARRAY
&& type
->is_vector ();
1693 /* Determine whether N is a power of two. */
1696 is_power_of_two (unsigned int n
)
1698 return n
&& ((n
& (n
- 1)) == 0);
1701 /* For an argument whose type is TYPE and which is not passed like a
1702 float or vector, return non-zero if it should be passed like "int"
1706 s390_function_arg_integer (struct type
*type
)
1708 enum type_code code
= type
->code ();
1710 if (TYPE_LENGTH (type
) > 8)
1713 if (code
== TYPE_CODE_INT
1714 || code
== TYPE_CODE_ENUM
1715 || code
== TYPE_CODE_RANGE
1716 || code
== TYPE_CODE_CHAR
1717 || code
== TYPE_CODE_BOOL
1718 || code
== TYPE_CODE_PTR
1719 || TYPE_IS_REFERENCE (type
))
1722 return ((code
== TYPE_CODE_UNION
|| code
== TYPE_CODE_STRUCT
)
1723 && is_power_of_two (TYPE_LENGTH (type
)));
1726 /* Argument passing state: Internal data structure passed to helper
1727 routines of s390_push_dummy_call. */
1729 struct s390_arg_state
1731 /* Register cache, or NULL, if we are in "preparation mode". */
1732 struct regcache
*regcache
;
1733 /* Next available general/floating-point/vector register for
1734 argument passing. */
1736 /* Current pointer to copy area (grows downwards). */
1738 /* Current pointer to parameter area (grows upwards). */
1742 /* Prepare one argument ARG for a dummy call and update the argument
1743 passing state AS accordingly. If the regcache field in AS is set,
1744 operate in "write mode" and write ARG into the inferior. Otherwise
1745 run "preparation mode" and skip all updates to the inferior. */
1748 s390_handle_arg (struct s390_arg_state
*as
, struct value
*arg
,
1749 struct gdbarch_tdep
*tdep
, int word_size
,
1750 enum bfd_endian byte_order
, int is_unnamed
)
1752 struct type
*type
= check_typedef (value_type (arg
));
1753 unsigned int length
= TYPE_LENGTH (type
);
1754 int write_mode
= as
->regcache
!= NULL
;
1756 if (s390_function_arg_float (type
))
1758 /* The GNU/Linux for S/390 ABI uses FPRs 0 and 2 to pass
1759 arguments. The GNU/Linux for zSeries ABI uses 0, 2, 4, and
1761 if (as
->fr
<= (tdep
->abi
== ABI_LINUX_S390
? 2 : 6))
1763 /* When we store a single-precision value in an FP register,
1764 it occupies the leftmost bits. */
1766 as
->regcache
->cooked_write_part (S390_F0_REGNUM
+ as
->fr
, 0, length
,
1767 value_contents (arg
));
1772 /* When we store a single-precision value in a stack slot,
1773 it occupies the rightmost bits. */
1774 as
->argp
= align_up (as
->argp
+ length
, word_size
);
1776 write_memory (as
->argp
- length
, value_contents (arg
),
1780 else if (tdep
->vector_abi
== S390_VECTOR_ABI_128
1781 && s390_function_arg_vector (type
))
1783 static const char use_vr
[] = {24, 26, 28, 30, 25, 27, 29, 31};
1785 if (!is_unnamed
&& as
->vr
< ARRAY_SIZE (use_vr
))
1787 int regnum
= S390_V24_REGNUM
+ use_vr
[as
->vr
] - 24;
1790 as
->regcache
->cooked_write_part (regnum
, 0, length
,
1791 value_contents (arg
));
1797 write_memory (as
->argp
, value_contents (arg
), length
);
1798 as
->argp
= align_up (as
->argp
+ length
, word_size
);
1801 else if (s390_function_arg_integer (type
) && length
<= word_size
)
1803 /* Initialize it just to avoid a GCC false warning. */
1808 /* Place value in least significant bits of the register or
1809 memory word and sign- or zero-extend to full word size.
1810 This also applies to a struct or union. */
1811 val
= type
->is_unsigned ()
1812 ? extract_unsigned_integer (value_contents (arg
),
1814 : extract_signed_integer (value_contents (arg
),
1815 length
, byte_order
);
1821 regcache_cooked_write_unsigned (as
->regcache
,
1822 S390_R0_REGNUM
+ as
->gr
,
1829 write_memory_unsigned_integer (as
->argp
, word_size
,
1831 as
->argp
+= word_size
;
1834 else if (s390_function_arg_integer (type
) && length
== 8)
1840 as
->regcache
->cooked_write (S390_R0_REGNUM
+ as
->gr
,
1841 value_contents (arg
));
1842 as
->regcache
->cooked_write (S390_R0_REGNUM
+ as
->gr
+ 1,
1843 value_contents (arg
) + word_size
);
1849 /* If we skipped r6 because we couldn't fit a DOUBLE_ARG
1850 in it, then don't go back and use it again later. */
1854 write_memory (as
->argp
, value_contents (arg
), length
);
1860 /* This argument type is never passed in registers. Place the
1861 value in the copy area and pass a pointer to it. Use 8-byte
1862 alignment as a conservative assumption. */
1863 as
->copy
= align_down (as
->copy
- length
, 8);
1865 write_memory (as
->copy
, value_contents (arg
), length
);
1870 regcache_cooked_write_unsigned (as
->regcache
,
1871 S390_R0_REGNUM
+ as
->gr
,
1878 write_memory_unsigned_integer (as
->argp
, word_size
,
1879 byte_order
, as
->copy
);
1880 as
->argp
+= word_size
;
1885 /* Put the actual parameter values pointed to by ARGS[0..NARGS-1] in
1886 place to be passed to a function, as specified by the "GNU/Linux
1887 for S/390 ELF Application Binary Interface Supplement".
1889 SP is the current stack pointer. We must put arguments, links,
1890 padding, etc. whereever they belong, and return the new stack
1893 If STRUCT_RETURN is non-zero, then the function we're calling is
1894 going to return a structure by value; STRUCT_ADDR is the address of
1895 a block we've allocated for it on the stack.
1897 Our caller has taken care of any type promotions needed to satisfy
1898 prototypes or the old K&R argument-passing rules. */
1901 s390_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
1902 struct regcache
*regcache
, CORE_ADDR bp_addr
,
1903 int nargs
, struct value
**args
, CORE_ADDR sp
,
1904 function_call_return_method return_method
,
1905 CORE_ADDR struct_addr
)
1907 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1908 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
1909 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1911 struct s390_arg_state arg_state
, arg_prep
;
1912 CORE_ADDR param_area_start
, new_sp
;
1913 struct type
*ftype
= check_typedef (value_type (function
));
1915 if (ftype
->code () == TYPE_CODE_PTR
)
1916 ftype
= check_typedef (TYPE_TARGET_TYPE (ftype
));
1919 arg_prep
.gr
= (return_method
== return_method_struct
) ? 3 : 2;
1923 arg_prep
.regcache
= NULL
;
1925 /* Initialize arg_state for "preparation mode". */
1926 arg_state
= arg_prep
;
1928 /* Update arg_state.copy with the start of the reference-to-copy area
1929 and arg_state.argp with the size of the parameter area. */
1930 for (i
= 0; i
< nargs
; i
++)
1931 s390_handle_arg (&arg_state
, args
[i
], tdep
, word_size
, byte_order
,
1932 ftype
->has_varargs () && i
>= ftype
->num_fields ());
1934 param_area_start
= align_down (arg_state
.copy
- arg_state
.argp
, 8);
1936 /* Allocate the standard frame areas: the register save area, the
1937 word reserved for the compiler, and the back chain pointer. */
1938 new_sp
= param_area_start
- (16 * word_size
+ 32);
1940 /* Now we have the final stack pointer. Make sure we didn't
1941 underflow; on 31-bit, this would result in addresses with the
1942 high bit set, which causes confusion elsewhere. Note that if we
1943 error out here, stack and registers remain untouched. */
1944 if (gdbarch_addr_bits_remove (gdbarch
, new_sp
) != new_sp
)
1945 error (_("Stack overflow"));
1947 /* Pass the structure return address in general register 2. */
1948 if (return_method
== return_method_struct
)
1949 regcache_cooked_write_unsigned (regcache
, S390_R2_REGNUM
, struct_addr
);
1951 /* Initialize arg_state for "write mode". */
1952 arg_state
= arg_prep
;
1953 arg_state
.argp
= param_area_start
;
1954 arg_state
.regcache
= regcache
;
1956 /* Write all parameters. */
1957 for (i
= 0; i
< nargs
; i
++)
1958 s390_handle_arg (&arg_state
, args
[i
], tdep
, word_size
, byte_order
,
1959 ftype
->has_varargs () && i
>= ftype
->num_fields ());
1961 /* Store return PSWA. In 31-bit mode, keep addressing mode bit. */
1965 regcache_cooked_read_unsigned (regcache
, S390_PSWA_REGNUM
, &pswa
);
1966 bp_addr
= (bp_addr
& 0x7fffffff) | (pswa
& 0x80000000);
1968 regcache_cooked_write_unsigned (regcache
, S390_RETADDR_REGNUM
, bp_addr
);
1970 /* Store updated stack pointer. */
1971 regcache_cooked_write_unsigned (regcache
, S390_SP_REGNUM
, new_sp
);
1973 /* We need to return the 'stack part' of the frame ID,
1974 which is actually the top of the register save area. */
1975 return param_area_start
;
1978 /* Assuming THIS_FRAME is a dummy, return the frame ID of that
1979 dummy frame. The frame ID's base needs to match the TOS value
1980 returned by push_dummy_call, and the PC match the dummy frame's
1983 static struct frame_id
1984 s390_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*this_frame
)
1986 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
1987 CORE_ADDR sp
= get_frame_register_unsigned (this_frame
, S390_SP_REGNUM
);
1988 sp
= gdbarch_addr_bits_remove (gdbarch
, sp
);
1990 return frame_id_build (sp
+ 16*word_size
+ 32,
1991 get_frame_pc (this_frame
));
1994 /* Implement frame_align gdbarch method. */
1997 s390_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1999 /* Both the 32- and 64-bit ABI's say that the stack pointer should
2000 always be aligned on an eight-byte boundary. */
2004 /* Helper for s390_return_value: Set or retrieve a function return
2005 value if it resides in a register. */
2008 s390_register_return_value (struct gdbarch
*gdbarch
, struct type
*type
,
2009 struct regcache
*regcache
,
2010 gdb_byte
*out
, const gdb_byte
*in
)
2012 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2013 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
2014 int length
= TYPE_LENGTH (type
);
2015 int code
= type
->code ();
2017 if (code
== TYPE_CODE_FLT
|| code
== TYPE_CODE_DECFLOAT
)
2019 /* Float-like value: left-aligned in f0. */
2021 regcache
->cooked_write_part (S390_F0_REGNUM
, 0, length
, in
);
2023 regcache
->cooked_read_part (S390_F0_REGNUM
, 0, length
, out
);
2025 else if (code
== TYPE_CODE_ARRAY
)
2027 /* Vector: left-aligned in v24. */
2029 regcache
->cooked_write_part (S390_V24_REGNUM
, 0, length
, in
);
2031 regcache
->cooked_read_part (S390_V24_REGNUM
, 0, length
, out
);
2033 else if (length
<= word_size
)
2035 /* Integer: zero- or sign-extended in r2. */
2037 regcache
->cooked_read_part (S390_R2_REGNUM
, word_size
- length
, length
,
2039 else if (type
->is_unsigned ())
2040 regcache_cooked_write_unsigned
2041 (regcache
, S390_R2_REGNUM
,
2042 extract_unsigned_integer (in
, length
, byte_order
));
2044 regcache_cooked_write_signed
2045 (regcache
, S390_R2_REGNUM
,
2046 extract_signed_integer (in
, length
, byte_order
));
2048 else if (length
== 2 * word_size
)
2050 /* Double word: in r2 and r3. */
2053 regcache
->cooked_write (S390_R2_REGNUM
, in
);
2054 regcache
->cooked_write (S390_R3_REGNUM
, in
+ word_size
);
2058 regcache
->cooked_read (S390_R2_REGNUM
, out
);
2059 regcache
->cooked_read (S390_R3_REGNUM
, out
+ word_size
);
2063 internal_error (__FILE__
, __LINE__
, _("invalid return type"));
2066 /* Implement the 'return_value' gdbarch method. */
2068 static enum return_value_convention
2069 s390_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
2070 struct type
*type
, struct regcache
*regcache
,
2071 gdb_byte
*out
, const gdb_byte
*in
)
2073 enum return_value_convention rvc
;
2075 type
= check_typedef (type
);
2077 switch (type
->code ())
2079 case TYPE_CODE_STRUCT
:
2080 case TYPE_CODE_UNION
:
2081 case TYPE_CODE_COMPLEX
:
2082 rvc
= RETURN_VALUE_STRUCT_CONVENTION
;
2084 case TYPE_CODE_ARRAY
:
2085 rvc
= (gdbarch_tdep (gdbarch
)->vector_abi
== S390_VECTOR_ABI_128
2086 && TYPE_LENGTH (type
) <= 16 && type
->is_vector ())
2087 ? RETURN_VALUE_REGISTER_CONVENTION
2088 : RETURN_VALUE_STRUCT_CONVENTION
;
2091 rvc
= TYPE_LENGTH (type
) <= 8
2092 ? RETURN_VALUE_REGISTER_CONVENTION
2093 : RETURN_VALUE_STRUCT_CONVENTION
;
2096 if (in
!= NULL
|| out
!= NULL
)
2098 if (rvc
== RETURN_VALUE_REGISTER_CONVENTION
)
2099 s390_register_return_value (gdbarch
, type
, regcache
, out
, in
);
2100 else if (in
!= NULL
)
2101 error (_("Cannot set function return value."));
2103 error (_("Function return value unknown."));
2109 /* Frame unwinding. */
2111 /* Implement the stack_frame_destroyed_p gdbarch method. */
2114 s390_stack_frame_destroyed_p (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
2116 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
2118 /* In frameless functions, there's no frame to destroy and thus
2119 we don't care about the epilogue.
2121 In functions with frame, the epilogue sequence is a pair of
2122 a LM-type instruction that restores (amongst others) the
2123 return register %r14 and the stack pointer %r15, followed
2124 by a branch 'br %r14' --or equivalent-- that effects the
2127 In that situation, this function needs to return 'true' in
2128 exactly one case: when pc points to that branch instruction.
2130 Thus we try to disassemble the one instructions immediately
2131 preceding pc and check whether it is an LM-type instruction
2132 modifying the stack pointer.
2134 Note that disassembling backwards is not reliable, so there
2135 is a slight chance of false positives here ... */
2138 unsigned int r1
, r3
, b2
;
2142 && !target_read_memory (pc
- 4, insn
, 4)
2143 && is_rs (insn
, op_lm
, &r1
, &r3
, &d2
, &b2
)
2144 && r3
== S390_SP_REGNUM
- S390_R0_REGNUM
)
2148 && !target_read_memory (pc
- 6, insn
, 6)
2149 && is_rsy (insn
, op1_lmy
, op2_lmy
, &r1
, &r3
, &d2
, &b2
)
2150 && r3
== S390_SP_REGNUM
- S390_R0_REGNUM
)
2154 && !target_read_memory (pc
- 6, insn
, 6)
2155 && is_rsy (insn
, op1_lmg
, op2_lmg
, &r1
, &r3
, &d2
, &b2
)
2156 && r3
== S390_SP_REGNUM
- S390_R0_REGNUM
)
2162 /* Implement unwind_pc gdbarch method. */
2165 s390_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2167 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2169 pc
= frame_unwind_register_unsigned (next_frame
, tdep
->pc_regnum
);
2170 return gdbarch_addr_bits_remove (gdbarch
, pc
);
2173 /* Implement unwind_sp gdbarch method. */
2176 s390_unwind_sp (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2179 sp
= frame_unwind_register_unsigned (next_frame
, S390_SP_REGNUM
);
2180 return gdbarch_addr_bits_remove (gdbarch
, sp
);
2183 /* Helper routine to unwind pseudo registers. */
2185 static struct value
*
2186 s390_unwind_pseudo_register (struct frame_info
*this_frame
, int regnum
)
2188 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2189 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2190 struct type
*type
= register_type (gdbarch
, regnum
);
2192 /* Unwind PC via PSW address. */
2193 if (regnum
== tdep
->pc_regnum
)
2197 val
= frame_unwind_register_value (this_frame
, S390_PSWA_REGNUM
);
2198 if (!value_optimized_out (val
))
2200 LONGEST pswa
= value_as_long (val
);
2202 if (TYPE_LENGTH (type
) == 4)
2203 return value_from_pointer (type
, pswa
& 0x7fffffff);
2205 return value_from_pointer (type
, pswa
);
2209 /* Unwind CC via PSW mask. */
2210 if (regnum
== tdep
->cc_regnum
)
2214 val
= frame_unwind_register_value (this_frame
, S390_PSWM_REGNUM
);
2215 if (!value_optimized_out (val
))
2217 LONGEST pswm
= value_as_long (val
);
2219 if (TYPE_LENGTH (type
) == 4)
2220 return value_from_longest (type
, (pswm
>> 12) & 3);
2222 return value_from_longest (type
, (pswm
>> 44) & 3);
2226 /* Unwind full GPRs to show at least the lower halves (as the
2227 upper halves are undefined). */
2228 if (regnum_is_gpr_full (tdep
, regnum
))
2230 int reg
= regnum
- tdep
->gpr_full_regnum
;
2233 val
= frame_unwind_register_value (this_frame
, S390_R0_REGNUM
+ reg
);
2234 if (!value_optimized_out (val
))
2235 return value_cast (type
, val
);
2238 return allocate_optimized_out_value (type
);
2241 /* Translate a .eh_frame register to DWARF register, or adjust a
2242 .debug_frame register. */
2245 s390_adjust_frame_regnum (struct gdbarch
*gdbarch
, int num
, int eh_frame_p
)
2247 /* See s390_dwarf_reg_to_regnum for comments. */
2248 return (num
>= 0 && num
< 16) ? num
+ s390_dwarf_reg_r0l
: num
;
2251 /* DWARF-2 frame unwinding. */
2253 /* Function to unwind a pseudo-register in dwarf2_frame unwinder. Used by
2254 s390_dwarf2_frame_init_reg. */
2256 static struct value
*
2257 s390_dwarf2_prev_register (struct frame_info
*this_frame
, void **this_cache
,
2260 return s390_unwind_pseudo_register (this_frame
, regnum
);
2263 /* Implement init_reg dwarf2_frame method. */
2266 s390_dwarf2_frame_init_reg (struct gdbarch
*gdbarch
, int regnum
,
2267 struct dwarf2_frame_state_reg
*reg
,
2268 struct frame_info
*this_frame
)
2270 /* The condition code (and thus PSW mask) is call-clobbered. */
2271 if (regnum
== S390_PSWM_REGNUM
)
2272 reg
->how
= DWARF2_FRAME_REG_UNDEFINED
;
2274 /* The PSW address unwinds to the return address. */
2275 else if (regnum
== S390_PSWA_REGNUM
)
2276 reg
->how
= DWARF2_FRAME_REG_RA
;
2278 /* Fixed registers are call-saved or call-clobbered
2279 depending on the ABI in use. */
2280 else if (regnum
< S390_NUM_REGS
)
2282 if (s390_register_call_saved (gdbarch
, regnum
))
2283 reg
->how
= DWARF2_FRAME_REG_SAME_VALUE
;
2285 reg
->how
= DWARF2_FRAME_REG_UNDEFINED
;
2288 /* We install a special function to unwind pseudos. */
2291 reg
->how
= DWARF2_FRAME_REG_FN
;
2292 reg
->loc
.fn
= s390_dwarf2_prev_register
;
2296 /* Frame unwinding. */
2298 /* Wrapper for trad_frame_get_prev_register to allow for s390 pseudo
2299 register translation. */
2302 s390_trad_frame_prev_register (struct frame_info
*this_frame
,
2303 trad_frame_saved_reg saved_regs
[],
2306 if (regnum
< S390_NUM_REGS
)
2307 return trad_frame_get_prev_register (this_frame
, saved_regs
, regnum
);
2309 return s390_unwind_pseudo_register (this_frame
, regnum
);
2312 /* Normal stack frames. */
2314 struct s390_unwind_cache
{
2317 CORE_ADDR frame_base
;
2318 CORE_ADDR local_base
;
2320 trad_frame_saved_reg
*saved_regs
;
2323 /* Unwind THIS_FRAME and write the information into unwind cache INFO using
2324 prologue analysis. Helper for s390_frame_unwind_cache. */
2327 s390_prologue_frame_unwind_cache (struct frame_info
*this_frame
,
2328 struct s390_unwind_cache
*info
)
2330 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2331 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
2332 struct s390_prologue_data data
;
2333 pv_t
*fp
= &data
.gpr
[S390_FRAME_REGNUM
- S390_R0_REGNUM
];
2334 pv_t
*sp
= &data
.gpr
[S390_SP_REGNUM
- S390_R0_REGNUM
];
2343 struct frame_info
*next_frame
;
2345 /* Try to find the function start address. If we can't find it, we don't
2346 bother searching for it -- with modern compilers this would be mostly
2347 pointless anyway. Trust that we'll either have valid DWARF-2 CFI data
2348 or else a valid backchain ... */
2349 if (!get_frame_func_if_available (this_frame
, &info
->func
))
2356 /* Try to analyze the prologue. */
2357 result
= s390_analyze_prologue (gdbarch
, func
,
2358 get_frame_pc (this_frame
), &data
);
2362 /* If this was successful, we should have found the instruction that
2363 sets the stack pointer register to the previous value of the stack
2364 pointer minus the frame size. */
2365 if (!pv_is_register (*sp
, S390_SP_REGNUM
))
2368 /* A frame size of zero at this point can mean either a real
2369 frameless function, or else a failure to find the prologue.
2370 Perform some sanity checks to verify we really have a
2371 frameless function. */
2374 /* If the next frame is a NORMAL_FRAME, this frame *cannot* have frame
2375 size zero. This is only possible if the next frame is a sentinel
2376 frame, a dummy frame, or a signal trampoline frame. */
2377 /* FIXME: cagney/2004-05-01: This sanity check shouldn't be
2378 needed, instead the code should simpliy rely on its
2380 next_frame
= get_next_frame (this_frame
);
2381 while (next_frame
&& get_frame_type (next_frame
) == INLINE_FRAME
)
2382 next_frame
= get_next_frame (next_frame
);
2384 && get_frame_type (get_next_frame (this_frame
)) == NORMAL_FRAME
)
2387 /* If we really have a frameless function, %r14 must be valid
2388 -- in particular, it must point to a different function. */
2389 reg
= get_frame_register_unsigned (this_frame
, S390_RETADDR_REGNUM
);
2390 reg
= gdbarch_addr_bits_remove (gdbarch
, reg
) - 1;
2391 if (get_pc_function_start (reg
) == func
)
2393 /* However, there is one case where it *is* valid for %r14
2394 to point to the same function -- if this is a recursive
2395 call, and we have stopped in the prologue *before* the
2396 stack frame was allocated.
2398 Recognize this case by looking ahead a bit ... */
2400 struct s390_prologue_data data2
;
2401 pv_t
*sp2
= &data2
.gpr
[S390_SP_REGNUM
- S390_R0_REGNUM
];
2403 if (!(s390_analyze_prologue (gdbarch
, func
, (CORE_ADDR
)-1, &data2
)
2404 && pv_is_register (*sp2
, S390_SP_REGNUM
)
2410 /* OK, we've found valid prologue data. */
2413 /* If the frame pointer originally also holds the same value
2414 as the stack pointer, we're probably using it. If it holds
2415 some other value -- even a constant offset -- it is most
2416 likely used as temp register. */
2417 if (pv_is_identical (*sp
, *fp
))
2418 frame_pointer
= S390_FRAME_REGNUM
;
2420 frame_pointer
= S390_SP_REGNUM
;
2422 /* If we've detected a function with stack frame, we'll still have to
2423 treat it as frameless if we're currently within the function epilog
2424 code at a point where the frame pointer has already been restored.
2425 This can only happen in an innermost frame. */
2426 /* FIXME: cagney/2004-05-01: This sanity check shouldn't be needed,
2427 instead the code should simpliy rely on its analysis. */
2428 next_frame
= get_next_frame (this_frame
);
2429 while (next_frame
&& get_frame_type (next_frame
) == INLINE_FRAME
)
2430 next_frame
= get_next_frame (next_frame
);
2432 && (next_frame
== NULL
2433 || get_frame_type (get_next_frame (this_frame
)) != NORMAL_FRAME
))
2435 /* See the comment in s390_stack_frame_destroyed_p on why this is
2436 not completely reliable ... */
2437 if (s390_stack_frame_destroyed_p (gdbarch
, get_frame_pc (this_frame
)))
2439 memset (&data
, 0, sizeof (data
));
2441 frame_pointer
= S390_SP_REGNUM
;
2445 /* Once we know the frame register and the frame size, we can unwind
2446 the current value of the frame register from the next frame, and
2447 add back the frame size to arrive that the previous frame's
2448 stack pointer value. */
2449 prev_sp
= get_frame_register_unsigned (this_frame
, frame_pointer
) + size
;
2450 cfa
= prev_sp
+ 16*word_size
+ 32;
2452 /* Set up ABI call-saved/call-clobbered registers. */
2453 for (i
= 0; i
< S390_NUM_REGS
; i
++)
2454 if (!s390_register_call_saved (gdbarch
, i
))
2455 info
->saved_regs
[i
].set_unknown ();
2457 /* CC is always call-clobbered. */
2458 info
->saved_regs
[S390_PSWM_REGNUM
].set_unknown ();
2460 /* Record the addresses of all register spill slots the prologue parser
2461 has recognized. Consider only registers defined as call-saved by the
2462 ABI; for call-clobbered registers the parser may have recognized
2465 for (i
= 0; i
< 16; i
++)
2466 if (s390_register_call_saved (gdbarch
, S390_R0_REGNUM
+ i
)
2467 && data
.gpr_slot
[i
] != 0)
2468 info
->saved_regs
[S390_R0_REGNUM
+ i
].set_addr (cfa
- data
.gpr_slot
[i
]);
2470 for (i
= 0; i
< 16; i
++)
2471 if (s390_register_call_saved (gdbarch
, S390_F0_REGNUM
+ i
)
2472 && data
.fpr_slot
[i
] != 0)
2473 info
->saved_regs
[S390_F0_REGNUM
+ i
].set_addr (cfa
- data
.fpr_slot
[i
]);
2475 /* Function return will set PC to %r14. */
2476 info
->saved_regs
[S390_PSWA_REGNUM
] = info
->saved_regs
[S390_RETADDR_REGNUM
];
2478 /* In frameless functions, we unwind simply by moving the return
2479 address to the PC. However, if we actually stored to the
2480 save area, use that -- we might only think the function frameless
2481 because we're in the middle of the prologue ... */
2483 && !info
->saved_regs
[S390_PSWA_REGNUM
].is_addr ())
2485 info
->saved_regs
[S390_PSWA_REGNUM
].set_realreg (S390_RETADDR_REGNUM
);
2488 /* Another sanity check: unless this is a frameless function,
2489 we should have found spill slots for SP and PC.
2490 If not, we cannot unwind further -- this happens e.g. in
2491 libc's thread_start routine. */
2494 if (!info
->saved_regs
[S390_SP_REGNUM
].is_addr ()
2495 || !info
->saved_regs
[S390_PSWA_REGNUM
].is_addr ())
2499 /* We use the current value of the frame register as local_base,
2500 and the top of the register save area as frame_base. */
2503 info
->frame_base
= prev_sp
+ 16*word_size
+ 32;
2504 info
->local_base
= prev_sp
- size
;
2510 /* Unwind THIS_FRAME and write the information into unwind cache INFO using
2511 back chain unwinding. Helper for s390_frame_unwind_cache. */
2514 s390_backchain_frame_unwind_cache (struct frame_info
*this_frame
,
2515 struct s390_unwind_cache
*info
)
2517 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2518 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
2519 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2520 CORE_ADDR backchain
;
2525 /* Set up ABI call-saved/call-clobbered registers. */
2526 for (i
= 0; i
< S390_NUM_REGS
; i
++)
2527 if (!s390_register_call_saved (gdbarch
, i
))
2528 info
->saved_regs
[i
].set_unknown ();
2530 /* CC is always call-clobbered. */
2531 info
->saved_regs
[S390_PSWM_REGNUM
].set_unknown ();
2533 /* Get the backchain. */
2534 reg
= get_frame_register_unsigned (this_frame
, S390_SP_REGNUM
);
2535 if (!safe_read_memory_integer (reg
, word_size
, byte_order
, &tmp
))
2537 backchain
= (CORE_ADDR
) tmp
;
2539 /* A zero backchain terminates the frame chain. As additional
2540 sanity check, let's verify that the spill slot for SP in the
2541 save area pointed to by the backchain in fact links back to
2544 && safe_read_memory_integer (backchain
+ 15*word_size
,
2545 word_size
, byte_order
, &sp
)
2546 && (CORE_ADDR
)sp
== backchain
)
2548 /* We don't know which registers were saved, but it will have
2549 to be at least %r14 and %r15. This will allow us to continue
2550 unwinding, but other prev-frame registers may be incorrect ... */
2551 info
->saved_regs
[S390_SP_REGNUM
].set_addr (backchain
+ 15*word_size
);
2552 info
->saved_regs
[S390_RETADDR_REGNUM
].set_addr (backchain
+ 14*word_size
);
2554 /* Function return will set PC to %r14. */
2555 info
->saved_regs
[S390_PSWA_REGNUM
]
2556 = info
->saved_regs
[S390_RETADDR_REGNUM
];
2558 /* We use the current value of the frame register as local_base,
2559 and the top of the register save area as frame_base. */
2560 info
->frame_base
= backchain
+ 16*word_size
+ 32;
2561 info
->local_base
= reg
;
2564 info
->func
= get_frame_pc (this_frame
);
2567 /* Unwind THIS_FRAME and return the corresponding unwind cache for
2568 s390_frame_unwind and s390_frame_base. */
2570 static struct s390_unwind_cache
*
2571 s390_frame_unwind_cache (struct frame_info
*this_frame
,
2572 void **this_prologue_cache
)
2574 struct s390_unwind_cache
*info
;
2576 if (*this_prologue_cache
)
2577 return (struct s390_unwind_cache
*) *this_prologue_cache
;
2579 info
= FRAME_OBSTACK_ZALLOC (struct s390_unwind_cache
);
2580 *this_prologue_cache
= info
;
2581 info
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
2583 info
->frame_base
= -1;
2584 info
->local_base
= -1;
2588 /* Try to use prologue analysis to fill the unwind cache.
2589 If this fails, fall back to reading the stack backchain. */
2590 if (!s390_prologue_frame_unwind_cache (this_frame
, info
))
2591 s390_backchain_frame_unwind_cache (this_frame
, info
);
2593 catch (const gdb_exception_error
&ex
)
2595 if (ex
.error
!= NOT_AVAILABLE_ERROR
)
2602 /* Implement this_id frame_unwind method for s390_frame_unwind. */
2605 s390_frame_this_id (struct frame_info
*this_frame
,
2606 void **this_prologue_cache
,
2607 struct frame_id
*this_id
)
2609 struct s390_unwind_cache
*info
2610 = s390_frame_unwind_cache (this_frame
, this_prologue_cache
);
2612 if (info
->frame_base
== -1)
2614 if (info
->func
!= -1)
2615 *this_id
= frame_id_build_unavailable_stack (info
->func
);
2619 *this_id
= frame_id_build (info
->frame_base
, info
->func
);
2622 /* Implement prev_register frame_unwind method for s390_frame_unwind. */
2624 static struct value
*
2625 s390_frame_prev_register (struct frame_info
*this_frame
,
2626 void **this_prologue_cache
, int regnum
)
2628 struct s390_unwind_cache
*info
2629 = s390_frame_unwind_cache (this_frame
, this_prologue_cache
);
2631 return s390_trad_frame_prev_register (this_frame
, info
->saved_regs
, regnum
);
2634 /* Default S390 frame unwinder. */
2636 static const struct frame_unwind s390_frame_unwind
= {
2638 default_frame_unwind_stop_reason
,
2640 s390_frame_prev_register
,
2642 default_frame_sniffer
2645 /* Code stubs and their stack frames. For things like PLTs and NULL
2646 function calls (where there is no true frame and the return address
2647 is in the RETADDR register). */
2649 struct s390_stub_unwind_cache
2651 CORE_ADDR frame_base
;
2652 trad_frame_saved_reg
*saved_regs
;
2655 /* Unwind THIS_FRAME and return the corresponding unwind cache for
2656 s390_stub_frame_unwind. */
2658 static struct s390_stub_unwind_cache
*
2659 s390_stub_frame_unwind_cache (struct frame_info
*this_frame
,
2660 void **this_prologue_cache
)
2662 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2663 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
2664 struct s390_stub_unwind_cache
*info
;
2667 if (*this_prologue_cache
)
2668 return (struct s390_stub_unwind_cache
*) *this_prologue_cache
;
2670 info
= FRAME_OBSTACK_ZALLOC (struct s390_stub_unwind_cache
);
2671 *this_prologue_cache
= info
;
2672 info
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
2674 /* The return address is in register %r14. */
2675 info
->saved_regs
[S390_PSWA_REGNUM
].set_realreg (S390_RETADDR_REGNUM
);
2677 /* Retrieve stack pointer and determine our frame base. */
2678 reg
= get_frame_register_unsigned (this_frame
, S390_SP_REGNUM
);
2679 info
->frame_base
= reg
+ 16*word_size
+ 32;
2684 /* Implement this_id frame_unwind method for s390_stub_frame_unwind. */
2687 s390_stub_frame_this_id (struct frame_info
*this_frame
,
2688 void **this_prologue_cache
,
2689 struct frame_id
*this_id
)
2691 struct s390_stub_unwind_cache
*info
2692 = s390_stub_frame_unwind_cache (this_frame
, this_prologue_cache
);
2693 *this_id
= frame_id_build (info
->frame_base
, get_frame_pc (this_frame
));
2696 /* Implement prev_register frame_unwind method for s390_stub_frame_unwind. */
2698 static struct value
*
2699 s390_stub_frame_prev_register (struct frame_info
*this_frame
,
2700 void **this_prologue_cache
, int regnum
)
2702 struct s390_stub_unwind_cache
*info
2703 = s390_stub_frame_unwind_cache (this_frame
, this_prologue_cache
);
2704 return s390_trad_frame_prev_register (this_frame
, info
->saved_regs
, regnum
);
2707 /* Implement sniffer frame_unwind method for s390_stub_frame_unwind. */
2710 s390_stub_frame_sniffer (const struct frame_unwind
*self
,
2711 struct frame_info
*this_frame
,
2712 void **this_prologue_cache
)
2714 CORE_ADDR addr_in_block
;
2715 bfd_byte insn
[S390_MAX_INSTR_SIZE
];
2717 /* If the current PC points to non-readable memory, we assume we
2718 have trapped due to an invalid function pointer call. We handle
2719 the non-existing current function like a PLT stub. */
2720 addr_in_block
= get_frame_address_in_block (this_frame
);
2721 if (in_plt_section (addr_in_block
)
2722 || s390_readinstruction (insn
, get_frame_pc (this_frame
)) < 0)
2727 /* S390 stub frame unwinder. */
2729 static const struct frame_unwind s390_stub_frame_unwind
= {
2731 default_frame_unwind_stop_reason
,
2732 s390_stub_frame_this_id
,
2733 s390_stub_frame_prev_register
,
2735 s390_stub_frame_sniffer
2738 /* Frame base handling. */
2741 s390_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
2743 struct s390_unwind_cache
*info
2744 = s390_frame_unwind_cache (this_frame
, this_cache
);
2745 return info
->frame_base
;
2749 s390_local_base_address (struct frame_info
*this_frame
, void **this_cache
)
2751 struct s390_unwind_cache
*info
2752 = s390_frame_unwind_cache (this_frame
, this_cache
);
2753 return info
->local_base
;
2756 static const struct frame_base s390_frame_base
= {
2758 s390_frame_base_address
,
2759 s390_local_base_address
,
2760 s390_local_base_address
2763 /* Process record-replay */
2765 /* Takes the intermediate sum of address calculations and masks off upper
2766 bits according to current addressing mode. */
2769 s390_record_address_mask (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
2772 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2773 ULONGEST pswm
, pswa
;
2775 if (tdep
->abi
== ABI_LINUX_S390
)
2777 regcache_raw_read_unsigned (regcache
, S390_PSWA_REGNUM
, &pswa
);
2778 am
= pswa
>> 31 & 1;
2782 regcache_raw_read_unsigned (regcache
, S390_PSWM_REGNUM
, &pswm
);
2783 am
= pswm
>> 31 & 3;
2788 return val
& 0xffffff;
2790 return val
& 0x7fffffff;
2794 fprintf_unfiltered (gdb_stdlog
, "Warning: Addressing mode %d used.", am
);
2799 /* Calculates memory address using pre-calculated index, raw instruction word
2800 with b and d/dl fields, and raw instruction byte with dh field. Index and
2801 dh should be set to 0 if unused. */
2804 s390_record_calc_disp_common (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
2805 ULONGEST x
, uint16_t bd
, int8_t dh
)
2807 uint8_t rb
= bd
>> 12 & 0xf;
2808 int32_t d
= (bd
& 0xfff) | ((int32_t)dh
<< 12);
2810 CORE_ADDR res
= d
+ x
;
2813 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ rb
, &b
);
2816 return s390_record_address_mask (gdbarch
, regcache
, res
);
2819 /* Calculates memory address using raw x, b + d/dl, dh fields from
2820 instruction. rx and dh should be set to 0 if unused. */
2823 s390_record_calc_disp (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
2824 uint8_t rx
, uint16_t bd
, int8_t dh
)
2828 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ rx
, &x
);
2829 return s390_record_calc_disp_common (gdbarch
, regcache
, x
, bd
, dh
);
2832 /* Calculates memory address for VSCE[GF] instructions. */
2835 s390_record_calc_disp_vsce (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
2836 uint8_t vx
, uint8_t el
, uint8_t es
, uint16_t bd
,
2837 int8_t dh
, CORE_ADDR
*res
)
2839 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2840 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2843 if (tdep
->v0_full_regnum
== -1 || el
* es
>= 16)
2846 regcache
->cooked_read (tdep
->v0_full_regnum
+ vx
, buf
);
2848 regcache
->raw_read (S390_V16_REGNUM
+ vx
- 16, buf
);
2849 x
= extract_unsigned_integer (buf
+ el
* es
, es
, byte_order
);
2850 *res
= s390_record_calc_disp_common (gdbarch
, regcache
, x
, bd
, dh
);
2854 /* Calculates memory address for instructions with relative long addressing. */
2857 s390_record_calc_rl (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
2858 CORE_ADDR addr
, uint16_t i1
, uint16_t i2
)
2860 int32_t ri
= i1
<< 16 | i2
;
2861 return s390_record_address_mask (gdbarch
, regcache
, addr
+ (LONGEST
)ri
* 2);
2864 /* Population count helper. */
2866 static int s390_popcnt (unsigned int x
) {
2877 /* Record 64-bit register. */
2880 s390_record_gpr_g (struct gdbarch
*gdbarch
, struct regcache
*regcache
, int i
)
2882 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2883 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ i
))
2885 if (tdep
->abi
== ABI_LINUX_S390
)
2886 if (record_full_arch_list_add_reg (regcache
, S390_R0_UPPER_REGNUM
+ i
))
2891 /* Record high 32 bits of a register. */
2894 s390_record_gpr_h (struct gdbarch
*gdbarch
, struct regcache
*regcache
, int i
)
2896 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2897 if (tdep
->abi
== ABI_LINUX_S390
)
2899 if (record_full_arch_list_add_reg (regcache
, S390_R0_UPPER_REGNUM
+ i
))
2904 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ i
))
2910 /* Record vector register. */
2913 s390_record_vr (struct gdbarch
*gdbarch
, struct regcache
*regcache
, int i
)
2917 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ i
))
2919 if (record_full_arch_list_add_reg (regcache
, S390_V0_LOWER_REGNUM
+ i
))
2924 if (record_full_arch_list_add_reg (regcache
, S390_V16_REGNUM
+ i
- 16))
2930 /* Implement process_record gdbarch method. */
2933 s390_process_record (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
2936 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2937 uint16_t insn
[3] = {0};
2938 /* Instruction as bytes. */
2940 /* Instruction as nibbles. */
2942 /* Instruction vector registers. */
2944 CORE_ADDR oaddr
, oaddr2
, oaddr3
;
2947 /* if EX/EXRL instruction used, here's the reg parameter */
2949 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2951 /* Attempting to use EX or EXRL jumps back here */
2954 /* Read instruction. */
2955 insn
[0] = read_memory_unsigned_integer (addr
, 2, byte_order
);
2956 /* If execute was involved, do the adjustment. */
2958 insn
[0] |= ex
& 0xff;
2959 /* Two highest bits determine instruction size. */
2960 if (insn
[0] >= 0x4000)
2961 insn
[1] = read_memory_unsigned_integer (addr
+2, 2, byte_order
);
2963 /* Not necessary, but avoids uninitialized variable warnings. */
2965 if (insn
[0] >= 0xc000)
2966 insn
[2] = read_memory_unsigned_integer (addr
+4, 2, byte_order
);
2969 /* Split instruction into bytes and nibbles. */
2970 for (i
= 0; i
< 3; i
++)
2972 ibyte
[i
*2] = insn
[i
] >> 8 & 0xff;
2973 ibyte
[i
*2+1] = insn
[i
] & 0xff;
2975 for (i
= 0; i
< 6; i
++)
2977 inib
[i
*2] = ibyte
[i
] >> 4 & 0xf;
2978 inib
[i
*2+1] = ibyte
[i
] & 0xf;
2980 /* Compute vector registers, if applicable. */
2981 ivec
[0] = (inib
[9] >> 3 & 1) << 4 | inib
[2];
2982 ivec
[1] = (inib
[9] >> 2 & 1) << 4 | inib
[3];
2983 ivec
[2] = (inib
[9] >> 1 & 1) << 4 | inib
[4];
2984 ivec
[3] = (inib
[9] >> 0 & 1) << 4 | inib
[8];
2988 /* 0x00 undefined */
2991 /* E-format instruction */
2994 /* 0x00 undefined */
2995 /* 0x01 unsupported: PR - program return */
2996 /* 0x02 unsupported: UPT */
2997 /* 0x03 undefined */
2998 /* 0x04 privileged: PTFF - perform timing facility function */
2999 /* 0x05-0x06 undefined */
3000 /* 0x07 privileged: SCKPF - set clock programmable field */
3001 /* 0x08-0x09 undefined */
3003 case 0x0a: /* PFPO - perform floating point operation */
3004 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
, &tmp
);
3005 if (!(tmp
& 0x80000000u
))
3007 uint8_t ofc
= tmp
>> 16 & 0xff;
3010 case 0x00: /* HFP32 */
3011 case 0x01: /* HFP64 */
3012 case 0x05: /* BFP32 */
3013 case 0x06: /* BFP64 */
3014 case 0x08: /* DFP32 */
3015 case 0x09: /* DFP64 */
3016 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
))
3019 case 0x02: /* HFP128 */
3020 case 0x07: /* BFP128 */
3021 case 0x0a: /* DFP128 */
3022 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
))
3024 if (record_full_arch_list_add_reg (regcache
, S390_F2_REGNUM
))
3028 fprintf_unfiltered (gdb_stdlog
, "Warning: Unknown PFPO OFC %02x at %s.\n",
3029 ofc
, paddress (gdbarch
, addr
));
3033 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
3036 if (record_full_arch_list_add_reg (regcache
, S390_R1_REGNUM
))
3038 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3042 case 0x0b: /* TAM - test address mode */
3043 case 0x0c: /* SAM24 - set address mode 24 */
3044 case 0x0d: /* SAM31 - set address mode 31 */
3045 case 0x0e: /* SAM64 - set address mode 64 */
3046 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3050 /* 0x0f-0xfe undefined */
3052 /* 0xff unsupported: TRAP */
3059 /* 0x02 undefined */
3060 /* 0x03 undefined */
3062 case 0x04: /* SPM - set program mask */
3063 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3067 case 0x05: /* BALR - branch and link */
3068 case 0x45: /* BAL - branch and link */
3069 case 0x06: /* BCTR - branch on count */
3070 case 0x46: /* BCT - branch on count */
3071 case 0x0d: /* BASR - branch and save */
3072 case 0x4d: /* BAS - branch and save */
3073 case 0x84: /* BRXH - branch relative on index high */
3074 case 0x85: /* BRXLE - branch relative on index low or equal */
3075 case 0x86: /* BXH - branch on index high */
3076 case 0x87: /* BXLE - branch on index low or equal */
3077 /* BA[SL]* use native-size destination for linkage info, BCT*, BRX*, BX*
3078 use 32-bit destination as counter. */
3079 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
3083 case 0x07: /* BCR - branch on condition */
3084 case 0x47: /* BC - branch on condition */
3085 /* No effect other than PC transfer. */
3088 /* 0x08 undefined */
3089 /* 0x09 undefined */
3092 /* SVC - supervisor call */
3093 if (tdep
->s390_syscall_record
!= NULL
)
3095 if (tdep
->s390_syscall_record (regcache
, ibyte
[1]))
3100 printf_unfiltered (_("no syscall record support\n"));
3105 case 0x0b: /* BSM - branch and set mode */
3107 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
3109 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3113 case 0x0c: /* BASSM - branch and save and set mode */
3114 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
3116 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3120 case 0x0e: /* MVCL - move long [interruptible] */
3121 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ inib
[2], &tmp
);
3122 oaddr
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
3123 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ (inib
[2] | 1), &tmp
);
3125 if (record_full_arch_list_add_mem (oaddr
, tmp
))
3127 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
3129 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[2] | 1)))
3131 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[3]))
3133 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[3] | 1)))
3135 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3139 case 0x0f: /* CLCL - compare logical long [interruptible] */
3140 case 0xa9: /* CLCLE - compare logical long extended [partial] */
3141 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
3143 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[2] | 1)))
3145 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[3]))
3147 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[3] | 1)))
3149 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3153 case 0x10: /* LPR - load positive */
3154 case 0x11: /* LNR - load negative */
3155 case 0x12: /* LTR - load and test */
3156 case 0x13: /* LCR - load complement */
3157 case 0x14: /* NR - and */
3158 case 0x16: /* OR - or */
3159 case 0x17: /* XR - xor */
3160 case 0x1a: /* AR - add */
3161 case 0x1b: /* SR - subtract */
3162 case 0x1e: /* ALR - add logical */
3163 case 0x1f: /* SLR - subtract logical */
3164 case 0x54: /* N - and */
3165 case 0x56: /* O - or */
3166 case 0x57: /* X - xor */
3167 case 0x5a: /* A - add */
3168 case 0x5b: /* S - subtract */
3169 case 0x5e: /* AL - add logical */
3170 case 0x5f: /* SL - subtract logical */
3171 case 0x4a: /* AH - add halfword */
3172 case 0x4b: /* SH - subtract halfword */
3173 case 0x8a: /* SRA - shift right single */
3174 case 0x8b: /* SLA - shift left single */
3175 case 0xbf: /* ICM - insert characters under mask */
3176 /* 32-bit destination + flags */
3177 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
3179 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3183 case 0x15: /* CLR - compare logical */
3184 case 0x55: /* CL - compare logical */
3185 case 0x19: /* CR - compare */
3186 case 0x29: /* CDR - compare */
3187 case 0x39: /* CER - compare */
3188 case 0x49: /* CH - compare halfword */
3189 case 0x59: /* C - compare */
3190 case 0x69: /* CD - compare */
3191 case 0x79: /* CE - compare */
3192 case 0x91: /* TM - test under mask */
3193 case 0x95: /* CLI - compare logical */
3194 case 0xbd: /* CLM - compare logical under mask */
3195 case 0xd5: /* CLC - compare logical */
3196 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3200 case 0x18: /* LR - load */
3201 case 0x48: /* LH - load halfword */
3202 case 0x58: /* L - load */
3203 case 0x41: /* LA - load address */
3204 case 0x43: /* IC - insert character */
3205 case 0x4c: /* MH - multiply halfword */
3206 case 0x71: /* MS - multiply single */
3207 case 0x88: /* SRL - shift right single logical */
3208 case 0x89: /* SLL - shift left single logical */
3209 /* 32-bit, 8-bit (IC), or native width (LA) destination, no flags */
3210 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
3214 case 0x1c: /* MR - multiply */
3215 case 0x5c: /* M - multiply */
3216 case 0x1d: /* DR - divide */
3217 case 0x5d: /* D - divide */
3218 case 0x8c: /* SRDL - shift right double logical */
3219 case 0x8d: /* SLDL - shift left double logical */
3220 /* 32-bit pair destination, no flags */
3221 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
3223 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[2] | 1)))
3227 case 0x20: /* LPDR - load positive */
3228 case 0x30: /* LPER - load positive */
3229 case 0x21: /* LNDR - load negative */
3230 case 0x31: /* LNER - load negative */
3231 case 0x22: /* LTDR - load and test */
3232 case 0x32: /* LTER - load and test */
3233 case 0x23: /* LCDR - load complement */
3234 case 0x33: /* LCER - load complement */
3235 case 0x2a: /* ADR - add */
3236 case 0x3a: /* AER - add */
3237 case 0x6a: /* AD - add */
3238 case 0x7a: /* AE - add */
3239 case 0x2b: /* SDR - subtract */
3240 case 0x3b: /* SER - subtract */
3241 case 0x6b: /* SD - subtract */
3242 case 0x7b: /* SE - subtract */
3243 case 0x2e: /* AWR - add unnormalized */
3244 case 0x3e: /* AUR - add unnormalized */
3245 case 0x6e: /* AW - add unnormalized */
3246 case 0x7e: /* AU - add unnormalized */
3247 case 0x2f: /* SWR - subtract unnormalized */
3248 case 0x3f: /* SUR - subtract unnormalized */
3249 case 0x6f: /* SW - subtract unnormalized */
3250 case 0x7f: /* SU - subtract unnormalized */
3251 /* float destination + flags */
3252 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[2]))
3254 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3258 case 0x24: /* HDR - halve */
3259 case 0x34: /* HER - halve */
3260 case 0x25: /* LDXR - load rounded */
3261 case 0x35: /* LEDR - load rounded */
3262 case 0x28: /* LDR - load */
3263 case 0x38: /* LER - load */
3264 case 0x68: /* LD - load */
3265 case 0x78: /* LE - load */
3266 case 0x2c: /* MDR - multiply */
3267 case 0x3c: /* MDER - multiply */
3268 case 0x6c: /* MD - multiply */
3269 case 0x7c: /* MDE - multiply */
3270 case 0x2d: /* DDR - divide */
3271 case 0x3d: /* DER - divide */
3272 case 0x6d: /* DD - divide */
3273 case 0x7d: /* DE - divide */
3274 /* float destination, no flags */
3275 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[2]))
3279 case 0x26: /* MXR - multiply */
3280 case 0x27: /* MXDR - multiply */
3281 case 0x67: /* MXD - multiply */
3282 /* float pair destination, no flags */
3283 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[2]))
3285 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ (inib
[2] | 2)))
3289 case 0x36: /* AXR - add */
3290 case 0x37: /* SXR - subtract */
3291 /* float pair destination + flags */
3292 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[2]))
3294 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ (inib
[2] | 2)))
3296 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3300 case 0x40: /* STH - store halfword */
3301 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, inib
[3], insn
[1], 0);
3302 if (record_full_arch_list_add_mem (oaddr
, 2))
3306 case 0x42: /* STC - store character */
3307 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, inib
[3], insn
[1], 0);
3308 if (record_full_arch_list_add_mem (oaddr
, 1))
3312 case 0x44: /* EX - execute */
3315 fprintf_unfiltered (gdb_stdlog
, "Warning: Double execute at %s.\n",
3316 paddress (gdbarch
, addr
));
3319 addr
= s390_record_calc_disp (gdbarch
, regcache
, inib
[3], insn
[1], 0);
3322 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ inib
[2], &tmp
);
3331 case 0x4e: /* CVD - convert to decimal */
3332 case 0x60: /* STD - store */
3333 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, inib
[3], insn
[1], 0);
3334 if (record_full_arch_list_add_mem (oaddr
, 8))
3338 case 0x4f: /* CVB - convert to binary */
3339 /* 32-bit gpr destination + FPC (DXC write) */
3340 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
3342 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
3346 case 0x50: /* ST - store */
3347 case 0x70: /* STE - store */
3348 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, inib
[3], insn
[1], 0);
3349 if (record_full_arch_list_add_mem (oaddr
, 4))
3353 case 0x51: /* LAE - load address extended */
3354 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
3356 if (record_full_arch_list_add_reg (regcache
, S390_A0_REGNUM
+ inib
[2]))
3360 /* 0x52 undefined */
3361 /* 0x53 undefined */
3363 /* 0x61-0x66 undefined */
3365 /* 0x72-0x77 undefined */
3367 /* 0x80 privileged: SSM - set system mask */
3368 /* 0x81 undefined */
3369 /* 0x82 privileged: LPSW - load PSW */
3370 /* 0x83 privileged: diagnose */
3372 case 0x8e: /* SRDA - shift right double */
3373 case 0x8f: /* SLDA - shift left double */
3374 /* 32-bit pair destination + flags */
3375 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
3377 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[2] | 1)))
3379 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3383 case 0x90: /* STM - store multiple */
3384 case 0x9b: /* STAM - store access multiple */
3385 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
3386 if (inib
[2] <= inib
[3])
3387 n
= inib
[3] - inib
[2] + 1;
3389 n
= inib
[3] + 0x10 - inib
[2] + 1;
3390 if (record_full_arch_list_add_mem (oaddr
, n
* 4))
3394 case 0x92: /* MVI - move */
3395 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
3396 if (record_full_arch_list_add_mem (oaddr
, 1))
3400 case 0x93: /* TS - test and set */
3401 case 0x94: /* NI - and */
3402 case 0x96: /* OI - or */
3403 case 0x97: /* XI - xor */
3404 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
3405 if (record_full_arch_list_add_mem (oaddr
, 1))
3407 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3411 case 0x98: /* LM - load multiple */
3412 for (i
= inib
[2]; i
!= inib
[3]; i
++, i
&= 0xf)
3413 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ i
))
3415 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[3]))
3419 /* 0x99 privileged: TRACE */
3421 case 0x9a: /* LAM - load access multiple */
3422 for (i
= inib
[2]; i
!= inib
[3]; i
++, i
&= 0xf)
3423 if (record_full_arch_list_add_reg (regcache
, S390_A0_REGNUM
+ i
))
3425 if (record_full_arch_list_add_reg (regcache
, S390_A0_REGNUM
+ inib
[3]))
3429 /* 0x9c-0x9f privileged and obsolete (old I/O) */
3430 /* 0xa0-0xa4 undefined */
3434 /* RI-format instruction */
3435 switch (ibyte
[0] << 4 | inib
[3])
3437 case 0xa50: /* IIHH - insert immediate */
3438 case 0xa51: /* IIHL - insert immediate */
3439 /* high 32-bit destination */
3440 if (s390_record_gpr_h (gdbarch
, regcache
, inib
[2]))
3444 case 0xa52: /* IILH - insert immediate */
3445 case 0xa53: /* IILL - insert immediate */
3446 case 0xa75: /* BRAS - branch relative and save */
3447 case 0xa76: /* BRCT - branch relative on count */
3448 case 0xa78: /* LHI - load halfword immediate */
3449 case 0xa7c: /* MHI - multiply halfword immediate */
3450 /* 32-bit or native destination */
3451 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
3455 case 0xa54: /* NIHH - and immediate */
3456 case 0xa55: /* NIHL - and immediate */
3457 case 0xa58: /* OIHH - or immediate */
3458 case 0xa59: /* OIHL - or immediate */
3459 /* high 32-bit destination + flags */
3460 if (s390_record_gpr_h (gdbarch
, regcache
, inib
[2]))
3462 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3466 case 0xa56: /* NILH - and immediate */
3467 case 0xa57: /* NILL - and immediate */
3468 case 0xa5a: /* OILH - or immediate */
3469 case 0xa5b: /* OILL - or immediate */
3470 case 0xa7a: /* AHI - add halfword immediate */
3471 /* 32-bit destination + flags */
3472 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
3474 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3478 case 0xa5c: /* LLIHH - load logical immediate */
3479 case 0xa5d: /* LLIHL - load logical immediate */
3480 case 0xa5e: /* LLILH - load logical immediate */
3481 case 0xa5f: /* LLILL - load logical immediate */
3482 case 0xa77: /* BRCTG - branch relative on count */
3483 case 0xa79: /* LGHI - load halfword immediate */
3484 case 0xa7d: /* MGHI - multiply halfword immediate */
3485 /* 64-bit destination */
3486 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
3490 case 0xa70: /* TMLH - test under mask */
3491 case 0xa71: /* TMLL - test under mask */
3492 case 0xa72: /* TMHH - test under mask */
3493 case 0xa73: /* TMHL - test under mask */
3494 case 0xa7e: /* CHI - compare halfword immediate */
3495 case 0xa7f: /* CGHI - compare halfword immediate */
3497 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3501 case 0xa74: /* BRC - branch relative on condition */
3502 /* no register change */
3505 case 0xa7b: /* AGHI - add halfword immediate */
3506 /* 64-bit destination + flags */
3507 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
3509 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3518 /* 0xa6 undefined */
3520 case 0xa8: /* MVCLE - move long extended [partial] */
3521 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ inib
[2], &tmp
);
3522 oaddr
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
3523 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ (inib
[2] | 1), &tmp
);
3524 if (record_full_arch_list_add_mem (oaddr
, tmp
))
3526 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
3528 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[2] | 1)))
3530 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[3]))
3532 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[3] | 1)))
3534 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3538 /* 0xaa-0xab undefined */
3539 /* 0xac privileged: STNSM - store then and system mask */
3540 /* 0xad privileged: STOSM - store then or system mask */
3541 /* 0xae privileged: SIGP - signal processor */
3542 /* 0xaf unsupported: MC - monitor call */
3543 /* 0xb0 undefined */
3544 /* 0xb1 privileged: LRA - load real address */
3549 /* S/RRD/RRE/RRF/IE-format instruction */
3552 /* 0xb200-0xb204 undefined or privileged */
3554 case 0xb205: /* STCK - store clock */
3555 case 0xb27c: /* STCKF - store clock fast */
3556 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
3557 if (record_full_arch_list_add_mem (oaddr
, 8))
3559 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3563 /* 0xb206-0xb219 undefined, privileged, or unsupported */
3564 /* 0xb21a unsupported: CFC */
3565 /* 0xb21b-0xb221 undefined or privileged */
3567 case 0xb222: /* IPM - insert program mask */
3568 case 0xb24f: /* EAR - extract access */
3569 case 0xb252: /* MSR - multiply single */
3570 case 0xb2ec: /* ETND - extract transaction nesting depth */
3571 case 0xb38c: /* EFPC - extract fpc */
3572 case 0xb91f: /* LRVR - load reversed */
3573 case 0xb926: /* LBR - load byte */
3574 case 0xb927: /* LHR - load halfword */
3575 case 0xb994: /* LLCR - load logical character */
3576 case 0xb995: /* LLHR - load logical halfword */
3577 case 0xb9f2: /* LOCR - load on condition */
3578 /* 32-bit gpr destination */
3579 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
3583 /* 0xb223-0xb22c privileged or unsupported */
3585 case 0xb22d: /* DXR - divide */
3586 case 0xb325: /* LXDR - load lengthened */
3587 case 0xb326: /* LXER - load lengthened */
3588 case 0xb336: /* SQXR - square root */
3589 case 0xb365: /* LXR - load */
3590 case 0xb367: /* FIXR - load fp integer */
3591 case 0xb376: /* LZXR - load zero */
3592 case 0xb3b6: /* CXFR - convert from fixed */
3593 case 0xb3c6: /* CXGR - convert from fixed */
3594 case 0xb3fe: /* IEXTR - insert biased exponent */
3595 /* float pair destination */
3596 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[6]))
3598 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ (inib
[6] | 2)))
3602 /* 0xb22e-0xb240 undefined, privileged, or unsupported */
3604 case 0xb241: /* CKSM - checksum [partial] */
3605 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
3607 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[7]))
3609 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[7] | 1)))
3611 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3615 /* 0xb242-0xb243 undefined */
3617 case 0xb244: /* SQDR - square root */
3618 case 0xb245: /* SQER - square root */
3619 case 0xb324: /* LDER - load lengthened */
3620 case 0xb337: /* MEER - multiply */
3621 case 0xb366: /* LEXR - load rounded */
3622 case 0xb370: /* LPDFR - load positive */
3623 case 0xb371: /* LNDFR - load negative */
3624 case 0xb372: /* CSDFR - copy sign */
3625 case 0xb373: /* LCDFR - load complement */
3626 case 0xb374: /* LZER - load zero */
3627 case 0xb375: /* LZDR - load zero */
3628 case 0xb377: /* FIER - load fp integer */
3629 case 0xb37f: /* FIDR - load fp integer */
3630 case 0xb3b4: /* CEFR - convert from fixed */
3631 case 0xb3b5: /* CDFR - convert from fixed */
3632 case 0xb3c1: /* LDGR - load fpr from gr */
3633 case 0xb3c4: /* CEGR - convert from fixed */
3634 case 0xb3c5: /* CDGR - convert from fixed */
3635 case 0xb3f6: /* IEDTR - insert biased exponent */
3636 /* float destination */
3637 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[6]))
3641 /* 0xb246-0xb24c: privileged or unsupported */
3643 case 0xb24d: /* CPYA - copy access */
3644 case 0xb24e: /* SAR - set access */
3645 if (record_full_arch_list_add_reg (regcache
, S390_A0_REGNUM
+ inib
[6]))
3649 /* 0xb250-0xb251 undefined or privileged */
3650 /* 0xb253-0xb254 undefined or privileged */
3652 case 0xb255: /* MVST - move string [partial] */
3657 /* Read ending byte. */
3658 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
, &tmp
);
3660 /* Get address of second operand. */
3661 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ inib
[7], &tmp
);
3662 oaddr
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
3663 /* Search for ending byte and compute length. */
3666 if (target_read_memory (oaddr
, &cur
, 1))
3669 } while (cur
!= end
);
3670 /* Get address of first operand and record it. */
3671 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ inib
[6], &tmp
);
3672 oaddr
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
3673 if (record_full_arch_list_add_mem (oaddr
, num
))
3675 /* Record the registers. */
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
))
3685 /* 0xb256 undefined */
3687 case 0xb257: /* CUSE - compare until substring equal [interruptible] */
3688 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
3690 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[6] | 1)))
3692 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[7]))
3694 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[7] | 1)))
3696 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3700 /* 0xb258-0xb25c undefined, privileged, or unsupported */
3702 case 0xb25d: /* CLST - compare logical string [partial] */
3703 case 0xb25e: /* SRST - search string [partial] */
3704 case 0xb9be: /* SRSTU - search string unicode [partial] */
3705 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
3707 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[7]))
3709 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3713 /* 0xb25f-0xb262 undefined */
3715 case 0xb263: /* CMPSC - compression call [interruptible] */
3716 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ inib
[6], &tmp
);
3717 oaddr
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
3718 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ (inib
[6] | 1), &tmp
);
3719 if (record_full_arch_list_add_mem (oaddr
, tmp
))
3721 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
3723 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[6] | 1)))
3725 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[7]))
3727 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[7] | 1)))
3729 if (record_full_arch_list_add_reg (regcache
, S390_R1_REGNUM
))
3731 /* DXC may be written */
3732 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
3734 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3738 /* 0xb264-0xb277 undefined, privileged, or unsupported */
3740 case 0xb278: /* STCKE - store clock extended */
3741 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
3742 if (record_full_arch_list_add_mem (oaddr
, 16))
3744 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3748 /* 0xb279-0xb27b undefined or unsupported */
3749 /* 0xb27d-0xb298 undefined or privileged */
3751 case 0xb299: /* SRNM - set rounding mode */
3752 case 0xb2b8: /* SRNMB - set bfp rounding mode */
3753 case 0xb2b9: /* SRNMT - set dfp rounding mode */
3754 case 0xb29d: /* LFPC - load fpc */
3755 case 0xb2bd: /* LFAS - load fpc and signal */
3756 case 0xb384: /* SFPC - set fpc */
3757 case 0xb385: /* SFASR - set fpc and signal */
3758 case 0xb960: /* CGRT - compare and trap */
3759 case 0xb961: /* CLGRT - compare logical and trap */
3760 case 0xb972: /* CRT - compare and trap */
3761 case 0xb973: /* CLRT - compare logical and trap */
3762 /* fpc only - including possible DXC write for trapping insns */
3763 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
3767 /* 0xb29a-0xb29b undefined */
3769 case 0xb29c: /* STFPC - store fpc */
3770 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
3771 if (record_full_arch_list_add_mem (oaddr
, 4))
3775 /* 0xb29e-0xb2a4 undefined */
3777 case 0xb2a5: /* TRE - translate extended [partial] */
3778 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ inib
[6], &tmp
);
3779 oaddr
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
3780 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ (inib
[6] | 1), &tmp
);
3781 if (record_full_arch_list_add_mem (oaddr
, tmp
))
3783 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
3785 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[6] | 1)))
3787 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3791 case 0xb2a6: /* CU21 - convert UTF-16 to UTF-8 [partial] */
3792 case 0xb2a7: /* CU12 - convert UTF-8 to UTF-16 [partial] */
3793 case 0xb9b0: /* CU14 - convert UTF-8 to UTF-32 [partial] */
3794 case 0xb9b1: /* CU24 - convert UTF-16 to UTF-32 [partial] */
3795 case 0xb9b2: /* CU41 - convert UTF-32 to UTF-8 [partial] */
3796 case 0xb9b3: /* CU42 - convert UTF-32 to UTF-16 [partial] */
3797 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ inib
[6], &tmp
);
3798 oaddr
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
3799 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ (inib
[6] | 1), &tmp
);
3800 if (record_full_arch_list_add_mem (oaddr
, tmp
))
3802 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
3804 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[6] | 1)))
3806 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[7]))
3808 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[7] | 1)))
3810 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3814 /* 0xb2a8-0xb2af undefined */
3816 case 0xb2b0: /* STFLE - store facility list extended */
3817 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
3818 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
, &tmp
);
3820 if (record_full_arch_list_add_mem (oaddr
, 8 * (tmp
+ 1)))
3822 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
))
3824 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3828 /* 0xb2b1-0xb2b7 undefined or privileged */
3829 /* 0xb2ba-0xb2bc undefined */
3830 /* 0xb2be-0xb2e7 undefined */
3831 /* 0xb2e9-0xb2eb undefined */
3832 /* 0xb2ed-0xb2f7 undefined */
3833 /* 0xb2f8 unsupported: TEND */
3834 /* 0xb2f9 undefined */
3836 case 0xb2e8: /* PPA - perform processor assist */
3837 case 0xb2fa: /* NIAI - next instruction access intent */
3838 /* no visible effects */
3841 /* 0xb2fb undefined */
3842 /* 0xb2fc unsupported: TABORT */
3843 /* 0xb2fd-0xb2fe undefined */
3844 /* 0xb2ff unsupported: TRAP */
3846 case 0xb300: /* LPEBR - load positive */
3847 case 0xb301: /* LNEBR - load negative */
3848 case 0xb303: /* LCEBR - load complement */
3849 case 0xb310: /* LPDBR - load positive */
3850 case 0xb311: /* LNDBR - load negative */
3851 case 0xb313: /* LCDBR - load complement */
3852 case 0xb350: /* TBEDR - convert hfp to bfp */
3853 case 0xb351: /* TBDR - convert hfp to bfp */
3854 case 0xb358: /* THDER - convert bfp to hfp */
3855 case 0xb359: /* THDR - convert bfp to hfp */
3856 /* float destination + flags */
3857 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[6]))
3859 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3863 case 0xb304: /* LDEBR - load lengthened */
3864 case 0xb30c: /* MDEBR - multiply */
3865 case 0xb30d: /* DEBR - divide */
3866 case 0xb314: /* SQEBR - square root */
3867 case 0xb315: /* SQDBR - square root */
3868 case 0xb317: /* MEEBR - multiply */
3869 case 0xb31c: /* MDBR - multiply */
3870 case 0xb31d: /* DDBR - divide */
3871 case 0xb344: /* LEDBRA - load rounded */
3872 case 0xb345: /* LDXBRA - load rounded */
3873 case 0xb346: /* LEXBRA - load rounded */
3874 case 0xb357: /* FIEBRA - load fp integer */
3875 case 0xb35f: /* FIDBRA - load fp integer */
3876 case 0xb390: /* CELFBR - convert from logical */
3877 case 0xb391: /* CDLFBR - convert from logical */
3878 case 0xb394: /* CEFBR - convert from fixed */
3879 case 0xb395: /* CDFBR - convert from fixed */
3880 case 0xb3a0: /* CELGBR - convert from logical */
3881 case 0xb3a1: /* CDLGBR - convert from logical */
3882 case 0xb3a4: /* CEGBR - convert from fixed */
3883 case 0xb3a5: /* CDGBR - convert from fixed */
3884 case 0xb3d0: /* MDTR - multiply */
3885 case 0xb3d1: /* DDTR - divide */
3886 case 0xb3d4: /* LDETR - load lengthened */
3887 case 0xb3d5: /* LEDTR - load lengthened */
3888 case 0xb3d7: /* FIDTR - load fp integer */
3889 case 0xb3dd: /* LDXTR - load lengthened */
3890 case 0xb3f1: /* CDGTR - convert from fixed */
3891 case 0xb3f2: /* CDUTR - convert from unsigned packed */
3892 case 0xb3f3: /* CDSTR - convert from signed packed */
3893 case 0xb3f5: /* QADTR - quantize */
3894 case 0xb3f7: /* RRDTR - reround */
3895 case 0xb951: /* CDFTR - convert from fixed */
3896 case 0xb952: /* CDLGTR - convert from logical */
3897 case 0xb953: /* CDLFTR - convert from logical */
3898 /* float destination + fpc */
3899 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[6]))
3901 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
3905 case 0xb305: /* LXDBR - load lengthened */
3906 case 0xb306: /* LXEBR - load lengthened */
3907 case 0xb307: /* MXDBR - multiply */
3908 case 0xb316: /* SQXBR - square root */
3909 case 0xb34c: /* MXBR - multiply */
3910 case 0xb34d: /* DXBR - divide */
3911 case 0xb347: /* FIXBRA - load fp integer */
3912 case 0xb392: /* CXLFBR - convert from logical */
3913 case 0xb396: /* CXFBR - convert from fixed */
3914 case 0xb3a2: /* CXLGBR - convert from logical */
3915 case 0xb3a6: /* CXGBR - convert from fixed */
3916 case 0xb3d8: /* MXTR - multiply */
3917 case 0xb3d9: /* DXTR - divide */
3918 case 0xb3dc: /* LXDTR - load lengthened */
3919 case 0xb3df: /* FIXTR - load fp integer */
3920 case 0xb3f9: /* CXGTR - convert from fixed */
3921 case 0xb3fa: /* CXUTR - convert from unsigned packed */
3922 case 0xb3fb: /* CXSTR - convert from signed packed */
3923 case 0xb3fd: /* QAXTR - quantize */
3924 case 0xb3ff: /* RRXTR - reround */
3925 case 0xb959: /* CXFTR - convert from fixed */
3926 case 0xb95a: /* CXLGTR - convert from logical */
3927 case 0xb95b: /* CXLFTR - convert from logical */
3928 /* float pair destination + fpc */
3929 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[6]))
3931 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ (inib
[6] | 2)))
3933 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
3937 case 0xb308: /* KEBR - compare and signal */
3938 case 0xb309: /* CEBR - compare */
3939 case 0xb318: /* KDBR - compare and signal */
3940 case 0xb319: /* CDBR - compare */
3941 case 0xb348: /* KXBR - compare and signal */
3942 case 0xb349: /* CXBR - compare */
3943 case 0xb3e0: /* KDTR - compare and signal */
3944 case 0xb3e4: /* CDTR - compare */
3945 case 0xb3e8: /* KXTR - compare and signal */
3946 case 0xb3ec: /* CXTR - compare */
3947 /* flags + fpc only */
3948 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3950 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
3954 case 0xb302: /* LTEBR - load and test */
3955 case 0xb312: /* LTDBR - load and test */
3956 case 0xb30a: /* AEBR - add */
3957 case 0xb30b: /* SEBR - subtract */
3958 case 0xb31a: /* ADBR - add */
3959 case 0xb31b: /* SDBR - subtract */
3960 case 0xb3d2: /* ADTR - add */
3961 case 0xb3d3: /* SDTR - subtract */
3962 case 0xb3d6: /* LTDTR - load and test */
3963 /* float destination + flags + fpc */
3964 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[6]))
3966 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3968 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
3972 case 0xb30e: /* MAEBR - multiply and add */
3973 case 0xb30f: /* MSEBR - multiply and subtract */
3974 case 0xb31e: /* MADBR - multiply and add */
3975 case 0xb31f: /* MSDBR - multiply and subtract */
3976 /* float destination [RRD] + fpc */
3977 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[4]))
3979 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
3983 /* 0xb320-0xb323 undefined */
3984 /* 0xb327-0xb32d undefined */
3986 case 0xb32e: /* MAER - multiply and add */
3987 case 0xb32f: /* MSER - multiply and subtract */
3988 case 0xb338: /* MAYLR - multiply and add unnormalized */
3989 case 0xb339: /* MYLR - multiply unnormalized */
3990 case 0xb33c: /* MAYHR - multiply and add unnormalized */
3991 case 0xb33d: /* MYHR - multiply unnormalized */
3992 case 0xb33e: /* MADR - multiply and add */
3993 case 0xb33f: /* MSDR - multiply and subtract */
3994 /* float destination [RRD] */
3995 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[4]))
3999 /* 0xb330-0xb335 undefined */
4001 case 0xb33a: /* MAYR - multiply and add unnormalized */
4002 case 0xb33b: /* MYR - multiply unnormalized */
4003 /* float pair destination [RRD] */
4004 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[4]))
4006 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ (inib
[4] | 2)))
4010 case 0xb340: /* LPXBR - load positive */
4011 case 0xb341: /* LNXBR - load negative */
4012 case 0xb343: /* LCXBR - load complement */
4013 case 0xb360: /* LPXR - load positive */
4014 case 0xb361: /* LNXR - load negative */
4015 case 0xb362: /* LTXR - load and test */
4016 case 0xb363: /* LCXR - load complement */
4017 /* float pair destination + flags */
4018 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[6]))
4020 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ (inib
[6] | 2)))
4022 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4026 case 0xb342: /* LTXBR - load and test */
4027 case 0xb34a: /* AXBR - add */
4028 case 0xb34b: /* SXBR - subtract */
4029 case 0xb3da: /* AXTR - add */
4030 case 0xb3db: /* SXTR - subtract */
4031 case 0xb3de: /* LTXTR - load and test */
4032 /* float pair destination + flags + fpc */
4033 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[6]))
4035 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ (inib
[6] | 2)))
4037 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4039 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
4043 /* 0xb34e-0xb34f undefined */
4044 /* 0xb352 undefined */
4046 case 0xb353: /* DIEBR - divide to integer */
4047 case 0xb35b: /* DIDBR - divide to integer */
4048 /* two float destinations + flags + fpc */
4049 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[4]))
4051 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[6]))
4053 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4055 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
4059 /* 0xb354-0xb356 undefined */
4060 /* 0xb35a undefined */
4062 /* 0xb35c-0xb35e undefined */
4063 /* 0xb364 undefined */
4064 /* 0xb368 undefined */
4066 case 0xb369: /* CXR - compare */
4067 case 0xb3f4: /* CEDTR - compare biased exponent */
4068 case 0xb3fc: /* CEXTR - compare biased exponent */
4069 case 0xb920: /* CGR - compare */
4070 case 0xb921: /* CLGR - compare logical */
4071 case 0xb930: /* CGFR - compare */
4072 case 0xb931: /* CLGFR - compare logical */
4073 case 0xb9cd: /* CHHR - compare high */
4074 case 0xb9cf: /* CLHHR - compare logical high */
4075 case 0xb9dd: /* CHLR - compare high */
4076 case 0xb9df: /* CLHLR - compare logical high */
4078 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4082 /* 0xb36a-0xb36f undefined */
4083 /* 0xb377-0xb37e undefined */
4084 /* 0xb380-0xb383 undefined */
4085 /* 0xb386-0xb38b undefined */
4086 /* 0xb38d-0xb38f undefined */
4087 /* 0xb393 undefined */
4088 /* 0xb397 undefined */
4090 case 0xb398: /* CFEBR - convert to fixed */
4091 case 0xb399: /* CFDBR - convert to fixed */
4092 case 0xb39a: /* CFXBR - convert to fixed */
4093 case 0xb39c: /* CLFEBR - convert to logical */
4094 case 0xb39d: /* CLFDBR - convert to logical */
4095 case 0xb39e: /* CLFXBR - convert to logical */
4096 case 0xb941: /* CFDTR - convert to fixed */
4097 case 0xb949: /* CFXTR - convert to fixed */
4098 case 0xb943: /* CLFDTR - convert to logical */
4099 case 0xb94b: /* CLFXTR - convert to logical */
4100 /* 32-bit gpr destination + flags + fpc */
4101 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
4103 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4105 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
4109 /* 0xb39b undefined */
4110 /* 0xb39f undefined */
4112 /* 0xb3a3 undefined */
4113 /* 0xb3a7 undefined */
4115 case 0xb3a8: /* CGEBR - convert to fixed */
4116 case 0xb3a9: /* CGDBR - convert to fixed */
4117 case 0xb3aa: /* CGXBR - convert to fixed */
4118 case 0xb3ac: /* CLGEBR - convert to logical */
4119 case 0xb3ad: /* CLGDBR - convert to logical */
4120 case 0xb3ae: /* CLGXBR - convert to logical */
4121 case 0xb3e1: /* CGDTR - convert to fixed */
4122 case 0xb3e9: /* CGXTR - convert to fixed */
4123 case 0xb942: /* CLGDTR - convert to logical */
4124 case 0xb94a: /* CLGXTR - convert to logical */
4125 /* 64-bit gpr destination + flags + fpc */
4126 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[6]))
4128 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4130 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
4134 /* 0xb3ab undefined */
4135 /* 0xb3af-0xb3b3 undefined */
4136 /* 0xb3b7 undefined */
4138 case 0xb3b8: /* CFER - convert to fixed */
4139 case 0xb3b9: /* CFDR - convert to fixed */
4140 case 0xb3ba: /* CFXR - convert to fixed */
4141 case 0xb998: /* ALCR - add logical with carry */
4142 case 0xb999: /* SLBR - subtract logical with borrow */
4143 case 0xb9f4: /* NRK - and */
4144 case 0xb9f5: /* NCRK - and with complement */
4145 case 0xb9f6: /* ORK - or */
4146 case 0xb9f7: /* XRK - xor */
4147 case 0xb9f8: /* ARK - add */
4148 case 0xb9f9: /* SRK - subtract */
4149 case 0xb9fa: /* ALRK - add logical */
4150 case 0xb9fb: /* SLRK - subtract logical */
4151 /* 32-bit gpr destination + flags */
4152 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
4154 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4158 case 0xb3c8: /* CGER - convert to fixed */
4159 case 0xb3c9: /* CGDR - convert to fixed */
4160 case 0xb3ca: /* CGXR - convert to fixed */
4161 case 0xb900: /* LPGR - load positive */
4162 case 0xb901: /* LNGR - load negative */
4163 case 0xb902: /* LTGR - load and test */
4164 case 0xb903: /* LCGR - load complement */
4165 case 0xb908: /* AGR - add */
4166 case 0xb909: /* SGR - subtract */
4167 case 0xb90a: /* ALGR - add logical */
4168 case 0xb90b: /* SLGR - subtract logical */
4169 case 0xb910: /* LPGFR - load positive */
4170 case 0xb911: /* LNGFR - load negative */
4171 case 0xb912: /* LTGFR - load and test */
4172 case 0xb913: /* LCGFR - load complement */
4173 case 0xb918: /* AGFR - add */
4174 case 0xb919: /* SGFR - subtract */
4175 case 0xb91a: /* ALGFR - add logical */
4176 case 0xb91b: /* SLGFR - subtract logical */
4177 case 0xb964: /* NNGRK - and 64 bit */
4178 case 0xb965: /* OCGRK - or with complement 64 bit */
4179 case 0xb966: /* NOGRK - or 64 bit */
4180 case 0xb967: /* NXGRK - not exclusive or 64 bit */
4181 case 0xb974: /* NNRK - and 32 bit */
4182 case 0xb975: /* OCRK - or with complement 32 bit */
4183 case 0xb976: /* NORK - or 32 bit */
4184 case 0xb977: /* NXRK - not exclusive or 32 bit */
4185 case 0xb980: /* NGR - and */
4186 case 0xb981: /* OGR - or */
4187 case 0xb982: /* XGR - xor */
4188 case 0xb988: /* ALCGR - add logical with carry */
4189 case 0xb989: /* SLBGR - subtract logical with borrow */
4190 case 0xb9c0: /* SELFHR - select high */
4191 case 0xb9e1: /* POPCNT - population count */
4192 case 0xb9e4: /* NGRK - and */
4193 case 0xb9e5: /* NCGRK - and with complement */
4194 case 0xb9e6: /* OGRK - or */
4195 case 0xb9e7: /* XGRK - xor */
4196 case 0xb9e8: /* AGRK - add */
4197 case 0xb9e9: /* SGRK - subtract */
4198 case 0xb9ea: /* ALGRK - add logical */
4199 case 0xb9e3: /* SELGR - select 64 bit */
4200 case 0xb9eb: /* SLGRK - subtract logical */
4201 case 0xb9ed: /* MSGRKC - multiply single 64x64 -> 64 */
4202 case 0xb9f0: /* SELR - select 32 bit */
4203 case 0xb9fd: /* MSRKC - multiply single 32x32 -> 32 */
4204 /* 64-bit gpr destination + flags */
4205 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[6]))
4207 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4211 /* 0xb3bb-0xb3c0 undefined */
4212 /* 0xb3c2-0xb3c3 undefined */
4213 /* 0xb3c7 undefined */
4214 /* 0xb3cb-0xb3cc undefined */
4216 case 0xb3cd: /* LGDR - load gr from fpr */
4217 case 0xb3e2: /* CUDTR - convert to unsigned packed */
4218 case 0xb3e3: /* CSDTR - convert to signed packed */
4219 case 0xb3e5: /* EEDTR - extract biased exponent */
4220 case 0xb3e7: /* ESDTR - extract significance */
4221 case 0xb3ed: /* EEXTR - extract biased exponent */
4222 case 0xb3ef: /* ESXTR - extract significance */
4223 case 0xb904: /* LGR - load */
4224 case 0xb906: /* LGBR - load byte */
4225 case 0xb907: /* LGHR - load halfword */
4226 case 0xb90c: /* MSGR - multiply single */
4227 case 0xb90f: /* LRVGR - load reversed */
4228 case 0xb914: /* LGFR - load */
4229 case 0xb916: /* LLGFR - load logical */
4230 case 0xb917: /* LLGTR - load logical thirty one bits */
4231 case 0xb91c: /* MSGFR - multiply single 64<32 */
4232 case 0xb946: /* BCTGR - branch on count */
4233 case 0xb984: /* LLGCR - load logical character */
4234 case 0xb985: /* LLGHR - load logical halfword */
4235 case 0xb9e2: /* LOCGR - load on condition */
4236 /* 64-bit gpr destination */
4237 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[6]))
4241 /* 0xb3ce-0xb3cf undefined */
4242 /* 0xb3e6 undefined */
4244 case 0xb3ea: /* CUXTR - convert to unsigned packed */
4245 case 0xb3eb: /* CSXTR - convert to signed packed */
4246 case 0xb90d: /* DSGR - divide single */
4247 case 0xb91d: /* DSGFR - divide single */
4248 case 0xb986: /* MLGR - multiply logical */
4249 case 0xb987: /* DLGR - divide logical */
4250 case 0xb9ec: /* MGRK - multiply 64x64 -> 128 */
4251 /* 64-bit gpr pair destination */
4252 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[6]))
4254 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[6] | 1))
4258 /* 0xb3ee undefined */
4259 /* 0xb3f0 undefined */
4260 /* 0xb3f8 undefined */
4262 /* 0xb905 privileged */
4264 /* 0xb90e unsupported: EREGG */
4266 /* 0xb915 undefined */
4268 case 0xb91e: /* KMAC - compute message authentication code [partial] */
4269 regcache_raw_read_unsigned (regcache
, S390_R1_REGNUM
, &tmp
);
4270 oaddr
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
4271 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
, &tmp
);
4275 case 0x00: /* KMAC-Query */
4276 if (record_full_arch_list_add_mem (oaddr
, 16))
4280 case 0x01: /* KMAC-DEA */
4281 case 0x02: /* KMAC-TDEA-128 */
4282 case 0x03: /* KMAC-TDEA-192 */
4283 case 0x09: /* KMAC-Encrypted-DEA */
4284 case 0x0a: /* KMAC-Encrypted-TDEA-128 */
4285 case 0x0b: /* KMAC-Encrypted-TDEA-192 */
4286 if (record_full_arch_list_add_mem (oaddr
, 8))
4290 case 0x12: /* KMAC-AES-128 */
4291 case 0x13: /* KMAC-AES-192 */
4292 case 0x14: /* KMAC-AES-256 */
4293 case 0x1a: /* KMAC-Encrypted-AES-128 */
4294 case 0x1b: /* KMAC-Encrypted-AES-192 */
4295 case 0x1c: /* KMAC-Encrypted-AES-256 */
4296 if (record_full_arch_list_add_mem (oaddr
, 16))
4301 fprintf_unfiltered (gdb_stdlog
, "Warning: Unknown KMAC function %02x at %s.\n",
4302 (int)tmp
, paddress (gdbarch
, addr
));
4307 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[7]))
4309 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[7] | 1)))
4312 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4316 /* 0xb922-0xb924 undefined */
4317 /* 0xb925 privileged */
4318 /* 0xb928 privileged */
4320 case 0xb929: /* KMA - cipher message with authentication */
4321 case 0xb92a: /* KMF - cipher message with cipher feedback [partial] */
4322 case 0xb92b: /* KMO - cipher message with output feedback [partial] */
4323 case 0xb92f: /* KMC - cipher message with chaining [partial] */
4324 regcache_raw_read_unsigned (regcache
, S390_R1_REGNUM
, &tmp
);
4325 oaddr
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
4326 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
, &tmp
);
4330 case 0x00: /* KM*-Query */
4331 if (record_full_arch_list_add_mem (oaddr
, 16))
4335 case 0x01: /* KM*-DEA */
4336 case 0x02: /* KM*-TDEA-128 */
4337 case 0x03: /* KM*-TDEA-192 */
4338 case 0x09: /* KM*-Encrypted-DEA */
4339 case 0x0a: /* KM*-Encrypted-TDEA-128 */
4340 case 0x0b: /* KM*-Encrypted-TDEA-192 */
4341 if (record_full_arch_list_add_mem (oaddr
, 8))
4345 case 0x12: /* KM*-AES-128 */
4346 case 0x13: /* KM*-AES-192 */
4347 case 0x14: /* KM*-AES-256 */
4348 case 0x1a: /* KM*-Encrypted-AES-128 */
4349 case 0x1b: /* KM*-Encrypted-AES-192 */
4350 case 0x1c: /* KM*-Encrypted-AES-256 */
4351 if (record_full_arch_list_add_mem (oaddr
, 16))
4355 case 0x43: /* KMC-PRNG */
4356 /* Only valid for KMC. */
4357 if (insn
[0] == 0xb92f)
4359 if (record_full_arch_list_add_mem (oaddr
, 8))
4363 /* For other instructions... */
4366 fprintf_unfiltered (gdb_stdlog
, "Warning: Unknown KM* function %02x at %s.\n",
4367 (int)tmp
, paddress (gdbarch
, addr
));
4372 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ inib
[6], &tmp
);
4373 oaddr2
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
4374 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ (inib
[7] | 1), &tmp
);
4375 if (record_full_arch_list_add_mem (oaddr2
, tmp
))
4377 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
4379 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[7]))
4381 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[7] | 1)))
4384 if (tmp
!= 0 && insn
[0] == 0xb929)
4386 if (record_full_arch_list_add_reg (regcache
,
4387 S390_R0_REGNUM
+ inib
[4]))
4389 if (record_full_arch_list_add_reg (regcache
,
4390 S390_R0_REGNUM
+ (inib
[4] | 1)))
4393 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4397 case 0xb92c: /* PCC - perform cryptographic computation [partial] */
4398 regcache_raw_read_unsigned (regcache
, S390_R1_REGNUM
, &tmp
);
4399 oaddr
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
4400 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
, &tmp
);
4404 case 0x00: /* PCC-Query */
4405 if (record_full_arch_list_add_mem (oaddr
, 16))
4409 case 0x01: /* PCC-Compute-Last-Block-CMAC-Using-DEA */
4410 case 0x02: /* PCC-Compute-Last-Block-CMAC-Using-TDEA-128 */
4411 case 0x03: /* PCC-Compute-Last-Block-CMAC-Using-TDEA-192 */
4412 case 0x09: /* PCC-Compute-Last-Block-CMAC-Using-Encrypted-DEA */
4413 case 0x0a: /* PCC-Compute-Last-Block-CMAC-Using-Encrypted-TDEA-128 */
4414 case 0x0b: /* PCC-Compute-Last-Block-CMAC-Using-Encrypted-TDEA-192 */
4415 if (record_full_arch_list_add_mem (oaddr
+ 0x10, 8))
4419 case 0x12: /* PCC-Compute-Last-Block-CMAC-Using-AES-128 */
4420 case 0x13: /* PCC-Compute-Last-Block-CMAC-Using-AES-192 */
4421 case 0x14: /* PCC-Compute-Last-Block-CMAC-Using-AES-256 */
4422 case 0x1a: /* PCC-Compute-Last-Block-CMAC-Using-Encrypted-AES-128 */
4423 case 0x1b: /* PCC-Compute-Last-Block-CMAC-Using-Encrypted-AES-192 */
4424 case 0x1c: /* PCC-Compute-Last-Block-CMAC-Using-Encrypted-AES-256 */
4425 if (record_full_arch_list_add_mem (oaddr
+ 0x18, 16))
4429 case 0x32: /* PCC-Compute-XTS-Parameter-Using-AES-128 */
4430 if (record_full_arch_list_add_mem (oaddr
+ 0x30, 32))
4434 case 0x34: /* PCC-Compute-XTS-Parameter-Using-AES-256 */
4435 if (record_full_arch_list_add_mem (oaddr
+ 0x40, 32))
4439 case 0x3a: /* PCC-Compute-XTS-Parameter-Using-Encrypted-AES-128 */
4440 if (record_full_arch_list_add_mem (oaddr
+ 0x50, 32))
4444 case 0x3c: /* PCC-Compute-XTS-Parameter-Using-Encrypted-AES-256 */
4445 if (record_full_arch_list_add_mem (oaddr
+ 0x60, 32))
4450 fprintf_unfiltered (gdb_stdlog
, "Warning: Unknown PCC function %02x at %s.\n",
4451 (int)tmp
, paddress (gdbarch
, addr
));
4454 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4458 case 0xb92d: /* KMCTR - cipher message with counter [partial] */
4459 regcache_raw_read_unsigned (regcache
, S390_R1_REGNUM
, &tmp
);
4460 oaddr
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
4461 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
, &tmp
);
4465 case 0x00: /* KMCTR-Query */
4466 if (record_full_arch_list_add_mem (oaddr
, 16))
4470 case 0x01: /* KMCTR-DEA */
4471 case 0x02: /* KMCTR-TDEA-128 */
4472 case 0x03: /* KMCTR-TDEA-192 */
4473 case 0x09: /* KMCTR-Encrypted-DEA */
4474 case 0x0a: /* KMCTR-Encrypted-TDEA-128 */
4475 case 0x0b: /* KMCTR-Encrypted-TDEA-192 */
4476 case 0x12: /* KMCTR-AES-128 */
4477 case 0x13: /* KMCTR-AES-192 */
4478 case 0x14: /* KMCTR-AES-256 */
4479 case 0x1a: /* KMCTR-Encrypted-AES-128 */
4480 case 0x1b: /* KMCTR-Encrypted-AES-192 */
4481 case 0x1c: /* KMCTR-Encrypted-AES-256 */
4485 fprintf_unfiltered (gdb_stdlog
, "Warning: Unknown KMCTR function %02x at %s.\n",
4486 (int)tmp
, paddress (gdbarch
, addr
));
4491 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ inib
[6], &tmp
);
4492 oaddr2
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
4493 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ (inib
[7] | 1), &tmp
);
4494 if (record_full_arch_list_add_mem (oaddr2
, tmp
))
4496 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
4498 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[7]))
4500 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[7] | 1)))
4502 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[4]))
4505 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4509 case 0xb92e: /* KM - cipher message [partial] */
4510 regcache_raw_read_unsigned (regcache
, S390_R1_REGNUM
, &tmp
);
4511 oaddr
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
4512 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
, &tmp
);
4516 case 0x00: /* KM-Query */
4517 if (record_full_arch_list_add_mem (oaddr
, 16))
4521 case 0x01: /* KM-DEA */
4522 case 0x02: /* KM-TDEA-128 */
4523 case 0x03: /* KM-TDEA-192 */
4524 case 0x09: /* KM-Encrypted-DEA */
4525 case 0x0a: /* KM-Encrypted-TDEA-128 */
4526 case 0x0b: /* KM-Encrypted-TDEA-192 */
4527 case 0x12: /* KM-AES-128 */
4528 case 0x13: /* KM-AES-192 */
4529 case 0x14: /* KM-AES-256 */
4530 case 0x1a: /* KM-Encrypted-AES-128 */
4531 case 0x1b: /* KM-Encrypted-AES-192 */
4532 case 0x1c: /* KM-Encrypted-AES-256 */
4535 case 0x32: /* KM-XTS-AES-128 */
4536 if (record_full_arch_list_add_mem (oaddr
+ 0x10, 16))
4540 case 0x34: /* KM-XTS-AES-256 */
4541 if (record_full_arch_list_add_mem (oaddr
+ 0x20, 16))
4545 case 0x3a: /* KM-XTS-Encrypted-AES-128 */
4546 if (record_full_arch_list_add_mem (oaddr
+ 0x30, 16))
4550 case 0x3c: /* KM-XTS-Encrypted-AES-256 */
4551 if (record_full_arch_list_add_mem (oaddr
+ 0x40, 16))
4556 fprintf_unfiltered (gdb_stdlog
, "Warning: Unknown KM function %02x at %s.\n",
4557 (int)tmp
, paddress (gdbarch
, addr
));
4562 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ inib
[6], &tmp
);
4563 oaddr2
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
4564 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ (inib
[7] | 1), &tmp
);
4565 if (record_full_arch_list_add_mem (oaddr2
, tmp
))
4567 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
4569 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[7]))
4571 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[7] | 1)))
4574 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4578 /* 0xb932-0xb937 undefined */
4580 /* 0xb938 unsupported: SORTL - sort lists */
4581 /* 0xb939 unsupported: DFLTCC - deflate conversion call */
4582 /* 0xb93a unsupported: KDSA - compute dig. signature auth. */
4584 /* 0xb93b undefined */
4586 case 0xb93c: /* PPNO - perform pseudorandom number operation [partial] */
4587 regcache_raw_read_unsigned (regcache
, S390_R1_REGNUM
, &tmp
);
4588 oaddr
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
4589 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
, &tmp
);
4593 case 0x00: /* PPNO-Query */
4594 case 0x80: /* PPNO-Query */
4595 if (record_full_arch_list_add_mem (oaddr
, 16))
4599 case 0x03: /* PPNO-SHA-512-DRNG - generate */
4600 if (record_full_arch_list_add_mem (oaddr
, 240))
4602 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ inib
[6], &tmp
);
4603 oaddr2
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
4604 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ (inib
[6] | 1), &tmp
);
4605 if (record_full_arch_list_add_mem (oaddr2
, tmp
))
4607 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
4609 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[6] | 1)))
4613 case 0x83: /* PPNO-SHA-512-DRNG - seed */
4614 if (record_full_arch_list_add_mem (oaddr
, 240))
4616 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[7]))
4618 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[7] | 1)))
4623 fprintf_unfiltered (gdb_stdlog
, "Warning: Unknown PPNO function %02x at %s.\n",
4624 (int)tmp
, paddress (gdbarch
, addr
));
4627 /* DXC may be written */
4628 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
4630 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4634 /* 0xb93d undefined */
4636 case 0xb93e: /* KIMD - compute intermediate message digest [partial] */
4637 case 0xb93f: /* KLMD - compute last message digest [partial] */
4638 regcache_raw_read_unsigned (regcache
, S390_R1_REGNUM
, &tmp
);
4639 oaddr
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
4640 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
, &tmp
);
4644 case 0x00: /* K*MD-Query */
4645 if (record_full_arch_list_add_mem (oaddr
, 16))
4649 case 0x01: /* K*MD-SHA-1 */
4650 if (record_full_arch_list_add_mem (oaddr
, 20))
4654 case 0x02: /* K*MD-SHA-256 */
4655 if (record_full_arch_list_add_mem (oaddr
, 32))
4659 case 0x03: /* K*MD-SHA-512 */
4660 if (record_full_arch_list_add_mem (oaddr
, 64))
4664 case 0x41: /* KIMD-GHASH */
4665 /* Only valid for KIMD. */
4666 if (insn
[0] == 0xb93e)
4668 if (record_full_arch_list_add_mem (oaddr
, 16))
4675 fprintf_unfiltered (gdb_stdlog
, "Warning: Unknown KMAC function %02x at %s.\n",
4676 (int)tmp
, paddress (gdbarch
, addr
));
4681 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[7]))
4683 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[7] | 1)))
4686 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4690 /* 0xb940 undefined */
4691 /* 0xb944-0xb945 undefined */
4692 /* 0xb947-0xb948 undefined */
4693 /* 0xb94c-0xb950 undefined */
4694 /* 0xb954-0xb958 undefined */
4695 /* 0xb95c-0xb95f undefined */
4696 /* 0xb962-0xb971 undefined */
4697 /* 0xb974-0xb97f undefined */
4699 case 0xb983: /* FLOGR - find leftmost one */
4700 /* 64-bit gpr pair destination + flags */
4701 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[6]))
4703 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[6] | 1))
4705 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4709 /* 0xb98a privileged */
4710 /* 0xb98b-0xb98c undefined */
4712 case 0xb98d: /* EPSW - extract psw */
4713 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
4716 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[7]))
4720 /* 0xb98e-0xb98f privileged */
4722 case 0xb990: /* TRTT - translate two to two [partial] */
4723 case 0xb991: /* TRTO - translate two to one [partial] */
4724 case 0xb992: /* TROT - translate one to two [partial] */
4725 case 0xb993: /* TROO - translate one to one [partial] */
4726 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ inib
[6], &tmp
);
4727 oaddr
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
4728 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ (inib
[6] | 1), &tmp
);
4729 /* tmp is source length, we want destination length. Adjust. */
4730 if (insn
[0] == 0xb991)
4732 if (insn
[0] == 0xb992)
4734 if (record_full_arch_list_add_mem (oaddr
, tmp
))
4736 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
4738 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[6] | 1)))
4740 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[7]))
4742 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4746 case 0xb996: /* MLR - multiply logical */
4747 case 0xb997: /* DLR - divide logical */
4748 /* 32-bit gpr pair destination */
4749 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
4751 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[6] | 1)))
4755 /* 0xb99a-0xb9af unsupported, privileged, or undefined */
4756 /* 0xb9b4-0xb9bc undefined */
4758 case 0xb9bd: /* TRTRE - translate and test reverse extended [partial] */
4759 case 0xb9bf: /* TRTE - translate and test extended [partial] */
4760 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
4762 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[6] | 1)))
4764 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[7]))
4766 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4770 /* 0xb9c0-0xb9c7 undefined */
4772 case 0xb9c8: /* AHHHR - add high */
4773 case 0xb9c9: /* SHHHR - subtract high */
4774 case 0xb9ca: /* ALHHHR - add logical high */
4775 case 0xb9cb: /* SLHHHR - subtract logical high */
4776 case 0xb9d8: /* AHHLR - add high */
4777 case 0xb9d9: /* SHHLR - subtract high */
4778 case 0xb9da: /* ALHHLR - add logical high */
4779 case 0xb9db: /* SLHHLR - subtract logical high */
4780 /* 32-bit high gpr destination + flags */
4781 if (s390_record_gpr_h (gdbarch
, regcache
, inib
[6]))
4783 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4787 /* 0xb9cc undefined */
4788 /* 0xb9ce undefined */
4789 /* 0xb9d0-0xb9d7 undefined */
4790 /* 0xb9dc undefined */
4791 /* 0xb9de undefined */
4793 case 0xb9e0: /* LOCFHR - load high on condition */
4794 /* 32-bit high gpr destination */
4795 if (s390_record_gpr_h (gdbarch
, regcache
, inib
[6]))
4799 /* 0xb9e3 undefined */
4800 /* 0xb9e5 undefined */
4801 /* 0xb9ee-0xb9f1 undefined */
4802 /* 0xb9f3 undefined */
4803 /* 0xb9f5 undefined */
4804 /* 0xb9fc undefined */
4805 /* 0xb9fe -0xb9ff undefined */
4812 /* 0xb4-0xb5 undefined */
4813 /* 0xb6 privileged: STCTL - store control */
4814 /* 0xb7 privileged: LCTL - load control */
4815 /* 0xb8 undefined */
4817 case 0xba: /* CS - compare and swap */
4818 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
4819 if (record_full_arch_list_add_mem (oaddr
, 4))
4821 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
4823 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4827 case 0xbb: /* CDS - compare double and swap */
4828 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
4829 if (record_full_arch_list_add_mem (oaddr
, 8))
4831 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
4833 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[2] | 1)))
4835 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4839 /* 0xbc undefined */
4841 case 0xbe: /* STCM - store characters under mask */
4842 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
4843 if (record_full_arch_list_add_mem (oaddr
, s390_popcnt (inib
[3])))
4852 /* RIL-format instruction */
4853 switch (ibyte
[0] << 4 | inib
[3])
4855 case 0xc00: /* LARL - load address relative long */
4856 case 0xc05: /* BRASL - branch relative and save long */
4857 case 0xc09: /* IILF - insert immediate */
4858 case 0xc21: /* MSFI - multiply single immediate */
4859 case 0xc42: /* LLHRL - load logical halfword relative long */
4860 case 0xc45: /* LHRL - load halfword relative long */
4861 case 0xc4d: /* LRL - load relative long */
4862 /* 32-bit or native gpr destination */
4863 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
4867 case 0xc01: /* LGFI - load immediate */
4868 case 0xc0e: /* LLIHF - load logical immediate */
4869 case 0xc0f: /* LLILF - load logical immediate */
4870 case 0xc20: /* MSGFI - multiply single immediate */
4871 case 0xc44: /* LGHRL - load halfword relative long */
4872 case 0xc46: /* LLGHRL - load logical halfword relative long */
4873 case 0xc48: /* LGRL - load relative long */
4874 case 0xc4c: /* LGFRL - load relative long */
4875 case 0xc4e: /* LLGFRL - load logical relative long */
4876 /* 64-bit gpr destination */
4877 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
4881 /* 0xc02-0xc03 undefined */
4883 case 0xc04: /* BRCL - branch relative on condition long */
4884 case 0xc62: /* PFDRL - prefetch data relative long */
4887 case 0xc06: /* XIHF - xor immediate */
4888 case 0xc0a: /* NIHF - and immediate */
4889 case 0xc0c: /* OIHF - or immediate */
4890 case 0xcc8: /* AIH - add immediate high */
4891 case 0xcca: /* ALSIH - add logical with signed immediate high */
4892 /* 32-bit high gpr destination + flags */
4893 if (s390_record_gpr_h (gdbarch
, regcache
, inib
[2]))
4895 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4899 case 0xc07: /* XILF - xor immediate */
4900 case 0xc0b: /* NILF - and immediate */
4901 case 0xc0d: /* OILF - or immediate */
4902 case 0xc25: /* SLFI - subtract logical immediate */
4903 case 0xc29: /* AFI - add immediate */
4904 case 0xc2b: /* ALFI - add logical immediate */
4905 /* 32-bit gpr destination + flags */
4906 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
4908 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4912 case 0xc08: /* IIHF - insert immediate */
4913 case 0xcc6: /* BRCTH - branch relative on count high */
4914 case 0xccb: /* ALSIHN - add logical with signed immediate high */
4915 /* 32-bit high gpr destination */
4916 if (s390_record_gpr_h (gdbarch
, regcache
, inib
[2]))
4920 /* 0xc22-0xc23 undefined */
4922 case 0xc24: /* SLGFI - subtract logical immediate */
4923 case 0xc28: /* AGFI - add immediate */
4924 case 0xc2a: /* ALGFI - add logical immediate */
4925 /* 64-bit gpr destination + flags */
4926 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
4928 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4932 /* 0xc26-0xc27 undefined */
4934 case 0xc2c: /* CGFI - compare immediate */
4935 case 0xc2d: /* CFI - compare immediate */
4936 case 0xc2e: /* CLGFI - compare logical immediate */
4937 case 0xc2f: /* CLFI - compare logical immediate */
4938 case 0xc64: /* CGHRL - compare halfword relative long */
4939 case 0xc65: /* CHRL - compare halfword relative long */
4940 case 0xc66: /* CLGHRL - compare logical halfword relative long */
4941 case 0xc67: /* CLHRL - compare logical halfword relative long */
4942 case 0xc68: /* CGRL - compare relative long */
4943 case 0xc6a: /* CLGRL - compare logical relative long */
4944 case 0xc6c: /* CGFRL - compare relative long */
4945 case 0xc6d: /* CRL - compare relative long */
4946 case 0xc6e: /* CLGFRL - compare logical relative long */
4947 case 0xc6f: /* CLRL - compare logical relative long */
4948 case 0xccd: /* CIH - compare immediate high */
4949 case 0xccf: /* CLIH - compare logical immediate high */
4951 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4955 /* 0xc40-0xc41 undefined */
4956 /* 0xc43 undefined */
4958 case 0xc47: /* STHRL - store halfword relative long */
4959 oaddr
= s390_record_calc_rl (gdbarch
, regcache
, addr
, insn
[1], insn
[2]);
4960 if (record_full_arch_list_add_mem (oaddr
, 2))
4964 /* 0xc49-0xc4a undefined */
4966 case 0xc4b: /* STGRL - store relative long */
4967 oaddr
= s390_record_calc_rl (gdbarch
, regcache
, addr
, insn
[1], insn
[2]);
4968 if (record_full_arch_list_add_mem (oaddr
, 8))
4972 case 0xc4f: /* STRL - store relative long */
4973 oaddr
= s390_record_calc_rl (gdbarch
, regcache
, addr
, insn
[1], insn
[2]);
4974 if (record_full_arch_list_add_mem (oaddr
, 4))
4978 case 0xc60: /* EXRL - execute relative long */
4981 fprintf_unfiltered (gdb_stdlog
, "Warning: Double execute at %s.\n",
4982 paddress (gdbarch
, addr
));
4985 addr
= s390_record_calc_rl (gdbarch
, regcache
, addr
, insn
[1], insn
[2]);
4988 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ inib
[2], &tmp
);
4997 /* 0xc61 undefined */
4998 /* 0xc63 undefined */
4999 /* 0xc69 undefined */
5000 /* 0xc6b undefined */
5001 /* 0xcc0-0xcc5 undefined */
5002 /* 0xcc7 undefined */
5003 /* 0xcc9 undefined */
5004 /* 0xccc undefined */
5005 /* 0xcce undefined */
5012 /* 0xc1 undefined */
5013 /* 0xc3 undefined */
5015 case 0xc5: /* BPRP - branch prediction relative preload */
5016 case 0xc7: /* BPP - branch prediction preload */
5017 /* no visible effect */
5021 /* SSF-format instruction */
5022 switch (ibyte
[0] << 4 | inib
[3])
5024 /* 0xc80 unsupported */
5026 case 0xc81: /* ECTG - extract cpu time */
5027 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
5029 if (s390_record_gpr_g (gdbarch
, regcache
, 0))
5031 if (s390_record_gpr_g (gdbarch
, regcache
, 1))
5035 case 0xc82: /* CSST - compare and swap and store */
5038 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
, &tmp
);
5040 sc
= tmp
>> 8 & 0xff;
5042 /* First and third operands. */
5043 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
5046 case 0x00: /* 32-bit */
5047 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
5049 if (record_full_arch_list_add_mem (oaddr
, 4))
5053 case 0x01: /* 64-bit */
5054 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
5056 if (record_full_arch_list_add_mem (oaddr
, 8))
5060 case 0x02: /* 128-bit */
5061 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
5063 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2] | 1))
5065 if (record_full_arch_list_add_mem (oaddr
, 16))
5070 fprintf_unfiltered (gdb_stdlog
, "Warning: Unknown CSST FC %02x at %s.\n",
5071 fc
, paddress (gdbarch
, addr
));
5075 /* Second operand. */
5076 oaddr2
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[2], 0);
5079 fprintf_unfiltered (gdb_stdlog
, "Warning: Unknown CSST FC %02x at %s.\n",
5080 sc
, paddress (gdbarch
, addr
));
5084 if (record_full_arch_list_add_mem (oaddr2
, 1 << sc
))
5088 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5093 /* 0xc83 undefined */
5095 case 0xc84: /* LPD - load pair disjoint */
5096 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
5098 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[2] | 1)))
5100 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5104 case 0xc85: /* LPDG - load pair disjoint */
5105 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
5107 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2] | 1))
5109 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5113 /* 0xc86-0xc8f undefined */
5120 /* 0xc9-0xcb undefined */
5121 /* 0xcd-0xcf undefined */
5123 case 0xd0: /* TRTR - translate and test reversed */
5124 case 0xdd: /* TRT - translate and test */
5125 if (record_full_arch_list_add_reg (regcache
, S390_R1_REGNUM
))
5127 if (record_full_arch_list_add_reg (regcache
, S390_R2_REGNUM
))
5129 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5133 case 0xd1: /* MVN - move numbers */
5134 case 0xd2: /* MVC - move */
5135 case 0xd3: /* MVZ - move zones */
5136 case 0xdc: /* TR - translate */
5137 case 0xe8: /* MVCIN - move inverse */
5138 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
5139 if (record_full_arch_list_add_mem (oaddr
, ibyte
[1] + 1))
5143 case 0xd4: /* NC - and */
5144 case 0xd6: /* OC - or*/
5145 case 0xd7: /* XC - xor */
5146 case 0xe2: /* UNPKU - unpack unicode */
5147 case 0xea: /* UNPKA - unpack ASCII */
5148 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
5149 if (record_full_arch_list_add_mem (oaddr
, ibyte
[1] + 1))
5151 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5155 case 0xde: /* ED - edit */
5156 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
5157 if (record_full_arch_list_add_mem (oaddr
, ibyte
[1] + 1))
5159 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5161 /* DXC may be written */
5162 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
5166 case 0xdf: /* EDMK - edit and mark */
5167 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
5168 if (record_full_arch_list_add_mem (oaddr
, ibyte
[1] + 1))
5170 if (record_full_arch_list_add_reg (regcache
, S390_R1_REGNUM
))
5172 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5174 /* DXC may be written */
5175 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
5179 /* 0xd8 undefined */
5180 /* 0xd9 unsupported: MVCK - move with key */
5181 /* 0xda unsupported: MVCP - move to primary */
5182 /* 0xdb unsupported: MVCS - move to secondary */
5183 /* 0xe0 undefined */
5185 case 0xe1: /* PKU - pack unicode */
5186 case 0xe9: /* PKA - pack ASCII */
5187 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
5188 if (record_full_arch_list_add_mem (oaddr
, 16))
5197 /* RXY/RXE/RXF/RSL/RSY/SIY/V*-format instruction */
5198 switch (ibyte
[0] << 8 | ibyte
[5])
5200 /* 0xe300-0xe301 undefined */
5202 case 0xe302: /* LTG - load and test */
5203 case 0xe308: /* AG - add */
5204 case 0xe309: /* SG - subtract */
5205 case 0xe30a: /* ALG - add logical */
5206 case 0xe30b: /* SLG - subtract logical */
5207 case 0xe318: /* AGF - add */
5208 case 0xe319: /* SGF - subtract */
5209 case 0xe31a: /* ALGF - add logical */
5210 case 0xe31b: /* SLGF - subtract logical */
5211 case 0xe332: /* LTGF - load and test */
5212 case 0xe380: /* NG - and */
5213 case 0xe381: /* OG - or */
5214 case 0xe382: /* XG - xor */
5215 case 0xe388: /* ALCG - add logical with carry */
5216 case 0xe389: /* SLBG - subtract logical with borrow */
5217 case 0xeb0a: /* SRAG - shift right single */
5218 case 0xeb0b: /* SLAG - shift left single */
5219 /* 64-bit gpr destination + flags */
5220 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
5222 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5226 /* 0xe303 privileged */
5228 case 0xe304: /* LG - load */
5229 case 0xe30c: /* MSG - multiply single */
5230 case 0xe30f: /* LRVG - load reversed */
5231 case 0xe314: /* LGF - load */
5232 case 0xe315: /* LGH - load halfword */
5233 case 0xe316: /* LLGF - load logical */
5234 case 0xe317: /* LLGT - load logical thirty one bits */
5235 case 0xe31c: /* MSGF - multiply single */
5236 case 0xe32a: /* LZRG - load and zero rightmost byte */
5237 case 0xe33a: /* LLZRGF - load logical and zero rightmost byte */
5238 case 0xe33c: /* MGH - multiply halfword 64x16mem -> 64 */
5239 case 0xe346: /* BCTG - branch on count */
5240 case 0xe377: /* LGB - load byte */
5241 case 0xe390: /* LLGC - load logical character */
5242 case 0xe391: /* LLGH - load logical halfword */
5243 case 0xeb0c: /* SRLG - shift right single logical */
5244 case 0xeb0d: /* SLLG - shift left single logical */
5245 case 0xeb1c: /* RLLG - rotate left single logical */
5246 case 0xeb44: /* BXHG - branch on index high */
5247 case 0xeb45: /* BXLEG - branch on index low or equal */
5248 case 0xeb4c: /* ECAG - extract cpu attribute */
5249 case 0xebe2: /* LOCG - load on condition */
5250 /* 64-bit gpr destination */
5251 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
5255 /* 0xe305 undefined */
5257 case 0xe306: /* CVBY - convert to binary */
5258 /* 32-bit or native gpr destination + FPC (DXC write) */
5259 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
5261 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
5265 /* 0xe307 undefined */
5267 case 0xe30d: /* DSG - divide single */
5268 case 0xe31d: /* DSGF - divide single */
5269 case 0xe384: /* MG - multiply 64x64mem -> 128 */
5270 case 0xe386: /* MLG - multiply logical */
5271 case 0xe387: /* DLG - divide logical */
5272 case 0xe38f: /* LPQ - load pair from quadword */
5273 /* 64-bit gpr pair destination */
5274 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
5276 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2] | 1))
5280 case 0xe30e: /* CVBG - convert to binary */
5281 /* 64-bit gpr destination + FPC (DXC write) */
5282 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
5284 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
5288 /* 0xe310-0xe311 undefined */
5290 case 0xe312: /* LT - load and test */
5291 case 0xe338: /* AGH - add halfword to 64 bit value */
5292 case 0xe339: /* SGH - subtract halfword from 64 bit value */
5293 case 0xe353: /* MSC - multiply single 32x32mem -> 32 */
5294 case 0xe354: /* NY - and */
5295 case 0xe356: /* OY - or */
5296 case 0xe357: /* XY - xor */
5297 case 0xe35a: /* AY - add */
5298 case 0xe35b: /* SY - subtract */
5299 case 0xe35e: /* ALY - add logical */
5300 case 0xe35f: /* SLY - subtract logical */
5301 case 0xe37a: /* AHY - add halfword */
5302 case 0xe37b: /* SHY - subtract halfword */
5303 case 0xe383: /* MSGC - multiply single 64x64mem -> 64 */
5304 case 0xe398: /* ALC - add logical with carry */
5305 case 0xe399: /* SLB - subtract logical with borrow */
5306 case 0xe727: /* LCBB - load count to block boundary */
5307 case 0xeb81: /* ICMY - insert characters under mask */
5308 case 0xebdc: /* SRAK - shift left single */
5309 case 0xebdd: /* SLAK - shift left single */
5310 /* 32/64-bit gpr destination + flags */
5311 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
5313 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5317 /* 0xe313 privileged */
5319 case 0xe31e: /* LRV - load reversed */
5320 case 0xe31f: /* LRVH - load reversed */
5321 case 0xe33b: /* LZRF - load and zero rightmost byte */
5322 case 0xe351: /* MSY - multiply single */
5323 case 0xe358: /* LY - load */
5324 case 0xe371: /* LAY - load address */
5325 case 0xe373: /* ICY - insert character */
5326 case 0xe376: /* LB - load byte */
5327 case 0xe378: /* LHY - load */
5328 case 0xe37c: /* MHY - multiply halfword */
5329 case 0xe394: /* LLC - load logical character */
5330 case 0xe395: /* LLH - load logical halfword */
5331 case 0xeb1d: /* RLL - rotate left single logical */
5332 case 0xebde: /* SRLK - shift left single logical */
5333 case 0xebdf: /* SLLK - shift left single logical */
5334 case 0xebf2: /* LOC - load on condition */
5335 /* 32-bit or native gpr destination */
5336 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
5340 case 0xe320: /* CG - compare */
5341 case 0xe321: /* CLG - compare logical */
5342 case 0xe330: /* CGF - compare */
5343 case 0xe331: /* CLGF - compare logical */
5344 case 0xe334: /* CGH - compare halfword */
5345 case 0xe355: /* CLY - compare logical */
5346 case 0xe359: /* CY - compare */
5347 case 0xe379: /* CHY - compare halfword */
5348 case 0xe3cd: /* CHF - compare high */
5349 case 0xe3cf: /* CLHF - compare logical high */
5350 case 0xeb20: /* CLMH - compare logical under mask high */
5351 case 0xeb21: /* CLMY - compare logical under mask */
5352 case 0xeb51: /* TMY - test under mask */
5353 case 0xeb55: /* CLIY - compare logical */
5354 case 0xebc0: /* TP - test decimal */
5355 case 0xed10: /* TCEB - test data class */
5356 case 0xed11: /* TCDB - test data class */
5357 case 0xed12: /* TCXB - test data class */
5358 case 0xed50: /* TDCET - test data class */
5359 case 0xed51: /* TDGET - test data group */
5360 case 0xed54: /* TDCDT - test data class */
5361 case 0xed55: /* TDGDT - test data group */
5362 case 0xed58: /* TDCXT - test data class */
5363 case 0xed59: /* TDGXT - test data group */
5365 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5369 /* 0xe322-0xe323 undefined */
5371 case 0xe324: /* STG - store */
5372 case 0xe325: /* NTSTG - nontransactional store */
5373 case 0xe326: /* CVDY - convert to decimal */
5374 case 0xe32f: /* STRVG - store reversed */
5375 case 0xed67: /* STDY - store */
5376 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, inib
[3], insn
[1], ibyte
[4]);
5377 if (record_full_arch_list_add_mem (oaddr
, 8))
5381 /* 0xe327-0xe329 undefined */
5382 /* 0xe32b-0xe32d undefined */
5384 case 0xe32e: /* CVDG - convert to decimal */
5385 case 0xe38e: /* STPQ - store pair to quadword */
5386 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, inib
[3], insn
[1], ibyte
[4]);
5387 if (record_full_arch_list_add_mem (oaddr
, 16))
5391 /* 0xe333 undefined */
5392 /* 0xe335 undefined */
5394 case 0xe336: /* PFD - prefetch data */
5397 /* 0xe337 undefined */
5398 /* 0xe33c-0xe33d undefined */
5400 case 0xe33e: /* STRV - store reversed */
5401 case 0xe350: /* STY - store */
5402 case 0xe3cb: /* STFH - store high */
5403 case 0xed66: /* STEY - store */
5404 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, inib
[3], insn
[1], ibyte
[4]);
5405 if (record_full_arch_list_add_mem (oaddr
, 4))
5409 case 0xe33f: /* STRVH - store reversed */
5410 case 0xe370: /* STHY - store halfword */
5411 case 0xe3c7: /* STHH - store halfword high */
5412 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, inib
[3], insn
[1], ibyte
[4]);
5413 if (record_full_arch_list_add_mem (oaddr
, 2))
5417 /* 0xe340-0xe345 undefined */
5419 case 0xe347: /* BIC - branch indirect on condition */
5422 /* 0xe348-0xe34f undefined */
5423 /* 0xe352 undefined */
5425 case 0xe35c: /* MFY - multiply */
5426 case 0xe396: /* ML - multiply logical */
5427 case 0xe397: /* DL - divide logical */
5428 /* 32-bit gpr pair destination */
5429 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
5431 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[2] | 1)))
5435 /* 0xe35d undefined */
5436 /* 0xe360-0xe36f undefined */
5438 case 0xe372: /* STCY - store character */
5439 case 0xe3c3: /* STCH - store character high */
5440 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, inib
[3], insn
[1], ibyte
[4]);
5441 if (record_full_arch_list_add_mem (oaddr
, 1))
5445 /* 0xe374 undefined */
5447 case 0xe375: /* LAEY - load address extended */
5448 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
5450 if (record_full_arch_list_add_reg (regcache
, S390_A0_REGNUM
+ inib
[2]))
5454 /* 0xe37d-0xe37f undefined */
5456 case 0xe385: /* LGAT - load and trap */
5457 case 0xe39c: /* LLGTAT - load logical thirty one bits and trap */
5458 case 0xe39d: /* LLGFAT - load logical and trap */
5459 case 0xe650: /* VCVB - vector convert to binary 32 bit*/
5460 case 0xe652: /* VCVBG - vector convert to binary 64 bit*/
5461 case 0xe721: /* VLGV - vector load gr from vr element */
5462 /* 64-bit gpr destination + fpc for possible DXC write */
5463 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
5465 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
5469 /* 0xe38a-0xe38d undefined */
5470 /* 0xe392-0xe393 undefined */
5471 /* 0xe39a-0xe39b undefined */
5472 /* 0xe39e undefined */
5474 case 0xe39f: /* LAT - load and trap */
5475 /* 32-bit gpr destination + fpc for possible DXC write */
5476 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
5478 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
5482 /* 0xe3a0-0xe3bf undefined */
5484 case 0xe3c0: /* LBH - load byte high */
5485 case 0xe3c2: /* LLCH - load logical character high */
5486 case 0xe3c4: /* LHH - load halfword high */
5487 case 0xe3c6: /* LLHH - load logical halfword high */
5488 case 0xe3ca: /* LFH - load high */
5489 case 0xebe0: /* LOCFH - load high on condition */
5490 /* 32-bit high gpr destination */
5491 if (s390_record_gpr_h (gdbarch
, regcache
, inib
[2]))
5495 /* 0xe3c1 undefined */
5496 /* 0xe3c5 undefined */
5498 case 0xe3c8: /* LFHAT - load high and trap */
5499 /* 32-bit high gpr destination + fpc for possible DXC write */
5500 if (s390_record_gpr_h (gdbarch
, regcache
, inib
[2]))
5502 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
5506 /* 0xe3c9 undefined */
5507 /* 0xe3cc undefined */
5508 /* 0xe3ce undefined */
5509 /* 0xe3d0-0xe3ff undefined */
5511 case 0xe601: /* VLEBRH - vector load byte reversed element */
5512 case 0xe602: /* VLEBRG - vector load byte reversed element */
5513 case 0xe603: /* VLEBRF - vector load byte reversed element */
5514 case 0xe604: /* VLLEBRZ - vector load byte rev. el. and zero */
5515 case 0xe605: /* VLBRREP - vector load byte rev. el. and replicate */
5516 case 0xe606: /* VLBR - vector load byte reversed elements */
5517 case 0xe607: /* VLER - vector load elements reversed */
5518 case 0xe634: /* VPKZ - vector pack zoned */
5519 case 0xe635: /* VLRL - vector load rightmost with immed. length */
5520 case 0xe637: /* VLRLR - vector load rightmost with length */
5521 case 0xe649: /* VLIP - vector load immediate decimal */
5522 case 0xe700: /* VLEB - vector load element */
5523 case 0xe701: /* VLEH - vector load element */
5524 case 0xe702: /* VLEG - vector load element */
5525 case 0xe703: /* VLEF - vector load element */
5526 case 0xe704: /* VLLEZ - vector load logical element and zero */
5527 case 0xe705: /* VLREP - vector load and replicate */
5528 case 0xe706: /* VL - vector load */
5529 case 0xe707: /* VLBB - vector load to block boundary */
5530 case 0xe712: /* VGEG - vector gather element */
5531 case 0xe713: /* VGEF - vector gather element */
5532 case 0xe722: /* VLVG - vector load vr element from gr */
5533 case 0xe730: /* VESL - vector element shift left */
5534 case 0xe733: /* VERLL - vector element rotate left logical */
5535 case 0xe737: /* VLL - vector load with length */
5536 case 0xe738: /* VESRL - vector element shift right logical */
5537 case 0xe73a: /* VESRA - vector element shift right arithmetic */
5538 case 0xe740: /* VLEIB - vector load element immediate */
5539 case 0xe741: /* VLEIH - vector load element immediate */
5540 case 0xe742: /* VLEIG - vector load element immediate */
5541 case 0xe743: /* VLEIF - vector load element immediate */
5542 case 0xe744: /* VGBM - vector generate byte mask */
5543 case 0xe745: /* VREPI - vector replicate immediate */
5544 case 0xe746: /* VGM - vector generate mask */
5545 case 0xe74d: /* VREP - vector replicate */
5546 case 0xe750: /* VPOPCT - vector population count */
5547 case 0xe752: /* VCTZ - vector count trailing zeros */
5548 case 0xe753: /* VCLZ - vector count leading zeros */
5549 case 0xe756: /* VLR - vector load */
5550 case 0xe75f: /* VSEG -vector sign extend to doubleword */
5551 case 0xe760: /* VMRL - vector merge low */
5552 case 0xe761: /* VMRH - vector merge high */
5553 case 0xe762: /* VLVGP - vector load vr from grs disjoint */
5554 case 0xe764: /* VSUM - vector sum across word */
5555 case 0xe765: /* VSUMG - vector sum across doubleword */
5556 case 0xe766: /* VCKSM - vector checksum */
5557 case 0xe767: /* VSUMQ - vector sum across quadword */
5558 case 0xe768: /* VN - vector and */
5559 case 0xe769: /* VNC - vector and with complement */
5560 case 0xe76a: /* VO - vector or */
5561 case 0xe76b: /* VNO - vector nor */
5562 case 0xe76c: /* VNX - vector not exclusive or */
5563 case 0xe76d: /* VX - vector xor */
5564 case 0xe76e: /* VNN - vector nand */
5565 case 0xe76f: /* VOC - vector or with complement */
5566 case 0xe770: /* VESLV - vector element shift left */
5567 case 0xe772: /* VERIM - vector element rotate and insert under mask */
5568 case 0xe773: /* VERLLV - vector element rotate left logical */
5569 case 0xe774: /* VSL - vector shift left */
5570 case 0xe775: /* VSLB - vector shift left by byte */
5571 case 0xe777: /* VSLDB - vector shift left double by byte */
5572 case 0xe778: /* VESRLV - vector element shift right logical */
5573 case 0xe77a: /* VESRAV - vector element shift right arithmetic */
5574 case 0xe77c: /* VSRL - vector shift right logical */
5575 case 0xe77d: /* VSRLB - vector shift right logical by byte */
5576 case 0xe77e: /* VSRA - vector shift right arithmetic */
5577 case 0xe77f: /* VSRAB - vector shift right arithmetic by byte */
5578 case 0xe784: /* VPDI - vector permute doubleword immediate */
5579 case 0xe785: /* VBPERM - vector bit permute */
5580 case 0xe786: /* VSLD - vector shift left double by bit */
5581 case 0xe787: /* VSRD - vector shift right double by bit */
5582 case 0xe78b: /* VSTRS - vector string search */
5583 case 0xe78c: /* VPERM - vector permute */
5584 case 0xe78d: /* VSEL - vector select */
5585 case 0xe78e: /* VFMS - vector fp multiply and subtract */
5586 case 0xe78f: /* VFMA - vector fp multiply and add */
5587 case 0xe794: /* VPK - vector pack */
5588 case 0xe79e: /* VFNMS - vector fp negative multiply and subtract */
5589 case 0xe79f: /* VFNMA - vector fp negative multiply and add */
5590 case 0xe7a1: /* VMLH - vector multiply logical high */
5591 case 0xe7a2: /* VML - vector multiply low */
5592 case 0xe7a3: /* VMH - vector multiply high */
5593 case 0xe7a4: /* VMLE - vector multiply logical even */
5594 case 0xe7a5: /* VMLO - vector multiply logical odd */
5595 case 0xe7a6: /* VME - vector multiply even */
5596 case 0xe7a7: /* VMO - vector multiply odd */
5597 case 0xe7a9: /* VMALH - vector multiply and add logical high */
5598 case 0xe7aa: /* VMAL - vector multiply and add low */
5599 case 0xe7ab: /* VMAH - vector multiply and add high */
5600 case 0xe7ac: /* VMALE - vector multiply and add logical even */
5601 case 0xe7ad: /* VMALO - vector multiply and add logical odd */
5602 case 0xe7ae: /* VMAE - vector multiply and add even */
5603 case 0xe7af: /* VMAO - vector multiply and add odd */
5604 case 0xe7b4: /* VGFM - vector Galois field multiply sum */
5605 case 0xe7b8: /* VMSL - vector multiply sum logical */
5606 case 0xe7b9: /* VACCC - vector add with carry compute carry */
5607 case 0xe7bb: /* VAC - vector add with carry */
5608 case 0xe7bc: /* VGFMA - vector Galois field multiply sum and accumulate */
5609 case 0xe7bd: /* VSBCBI - vector subtract with borrow compute borrow indication */
5610 case 0xe7bf: /* VSBI - vector subtract with borrow indication */
5611 case 0xe7c0: /* VCLFP - vector fp convert to logical */
5612 case 0xe7c1: /* VCFPL - vector fp convert from logical */
5613 case 0xe7c2: /* VCSFP - vector fp convert to fixed */
5614 case 0xe7c3: /* VCFPS - vector fp convert from fixed */
5615 case 0xe7c4: /* VLDE/VFLL - vector fp load lengthened */
5616 case 0xe7c5: /* VLED/VFLR - vector fp load rounded */
5617 case 0xe7c7: /* VFI - vector load fp integer */
5618 case 0xe7cc: /* VFPSO - vector fp perform sign operation */
5619 case 0xe7ce: /* VFSQ - vector fp square root */
5620 case 0xe7d4: /* VUPLL - vector unpack logical low */
5621 case 0xe7d6: /* VUPL - vector unpack low */
5622 case 0xe7d5: /* VUPLH - vector unpack logical high */
5623 case 0xe7d7: /* VUPH - vector unpack high */
5624 case 0xe7de: /* VLC - vector load complement */
5625 case 0xe7df: /* VLP - vector load positive */
5626 case 0xe7e2: /* VFA - vector fp subtract */
5627 case 0xe7e3: /* VFA - vector fp add */
5628 case 0xe7e5: /* VFD - vector fp divide */
5629 case 0xe7e7: /* VFM - vector fp multiply */
5630 case 0xe7ee: /* VFMIN - vector fp minimum */
5631 case 0xe7ef: /* VFMAX - vector fp maximum */
5632 case 0xe7f0: /* VAVGL - vector average logical */
5633 case 0xe7f1: /* VACC - vector add and compute carry */
5634 case 0xe7f2: /* VAVG - vector average */
5635 case 0xe7f3: /* VA - vector add */
5636 case 0xe7f5: /* VSCBI - vector subtract compute borrow indication */
5637 case 0xe7f7: /* VS - vector subtract */
5638 case 0xe7fc: /* VMNL - vector minimum logical */
5639 case 0xe7fd: /* VMXL - vector maximum logical */
5640 case 0xe7fe: /* VMN - vector minimum */
5641 case 0xe7ff: /* VMX - vector maximum */
5642 /* vector destination + FPC */
5643 if (s390_record_vr (gdbarch
, regcache
, ivec
[0]))
5645 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
5649 case 0xe63d: /* VSTRL - vector store rightmost with immed. length */
5650 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
5651 if (record_full_arch_list_add_mem (oaddr
, inib
[3] + 1))
5653 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
5657 case 0xe708: /* VSTEB - vector store element */
5658 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, inib
[3], insn
[1], 0);
5659 if (record_full_arch_list_add_mem (oaddr
, 1))
5661 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
5665 case 0xe609: /* VSTEBRH - vector store byte reversed element */
5666 case 0xe709: /* VSTEH - vector store element */
5667 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, inib
[3], insn
[1], 0);
5668 if (record_full_arch_list_add_mem (oaddr
, 2))
5670 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
5674 case 0xe60a: /* VSTEBRG - vector store byte reversed element */
5675 case 0xe70a: /* VSTEG - vector store element */
5676 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, inib
[3], insn
[1], 0);
5677 if (record_full_arch_list_add_mem (oaddr
, 8))
5679 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
5683 case 0xe60b: /* VSTEBRF - vector store byte reversed element */
5684 case 0xe70b: /* VSTEF - vector store element */
5685 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, inib
[3], insn
[1], 0);
5686 if (record_full_arch_list_add_mem (oaddr
, 4))
5688 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
5692 /* 0xe70c-0xe70d undefined */
5694 case 0xe60e: /* VSTBR - vector store byte reversed elements */
5695 case 0xe60f: /* VSTER - vector store elements reversed */
5696 case 0xe70e: /* VST - vector store */
5697 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, inib
[3], insn
[1], 0);
5698 if (record_full_arch_list_add_mem (oaddr
, 16))
5700 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
5704 /* 0xe70f-0xe711 undefined */
5705 /* 0xe714-0xe719 undefined */
5707 case 0xe71a: /* VSCEG - vector scatter element */
5708 if (s390_record_calc_disp_vsce (gdbarch
, regcache
, ivec
[1], inib
[8], 8, insn
[1], 0, &oaddr
))
5710 if (record_full_arch_list_add_mem (oaddr
, 8))
5712 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
5716 case 0xe71b: /* VSCEF - vector scatter element */
5717 if (s390_record_calc_disp_vsce (gdbarch
, regcache
, ivec
[1], inib
[8], 4, insn
[1], 0, &oaddr
))
5719 if (record_full_arch_list_add_mem (oaddr
, 4))
5721 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
5725 /* 0xe71c-0xe720 undefined */
5726 /* 0xe723-0xe726 undefined */
5727 /* 0xe728-0xe72f undefined */
5728 /* 0xe731-0xe732 undefined */
5729 /* 0xe734-0xe735 undefined */
5731 case 0xe736: /* VLM - vector load multiple */
5732 for (i
= ivec
[0]; i
!= ivec
[1]; i
++, i
&= 0x1f)
5733 if (s390_record_vr (gdbarch
, regcache
, i
))
5735 if (s390_record_vr (gdbarch
, regcache
, ivec
[1]))
5737 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
5741 /* 0xe739 undefined */
5742 /* 0xe73b-0xe73d undefined */
5744 case 0xe73e: /* VSTM - vector store multiple */
5745 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
5746 if (ivec
[0] <= ivec
[1])
5747 n
= ivec
[1] - ivec
[0] + 1;
5749 n
= ivec
[1] + 0x20 - ivec
[0] + 1;
5750 if (record_full_arch_list_add_mem (oaddr
, n
* 16))
5752 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
5756 case 0xe63c: /* VUPKZ - vector unpack zoned */
5757 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
5758 if (record_full_arch_list_add_mem (oaddr
, (ibyte
[1] + 1) & 31))
5760 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5764 case 0xe63f: /* VSTRLR - vector store rightmost with length */
5765 case 0xe73f: /* VSTL - vector store with length */
5766 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
5767 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ inib
[3], &tmp
);
5771 if (record_full_arch_list_add_mem (oaddr
, tmp
+ 1))
5773 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
5777 /* 0xe747-0xe749 undefined */
5779 case 0xe658: /* VCVD - vector convert to decimal 32 bit */
5780 case 0xe659: /* VSRP - vector shift and round decimal */
5781 case 0xe65a: /* VCVDG - vector convert to decimal 64 bit*/
5782 case 0xe65b: /* VPSOP - vector perform sign operation decimal */
5783 case 0xe671: /* VAP - vector add decimal */
5784 case 0xe673: /* VSP - vector subtract decimal */
5785 case 0xe678: /* VMP - vector multiply decimal */
5786 case 0xe679: /* VMSP - vector multiply decimal */
5787 case 0xe67a: /* VDP - vector divide decimal */
5788 case 0xe67b: /* VRP - vector remainder decimal */
5789 case 0xe67e: /* VSDP - vector shift and divide decimal */
5790 case 0xe74a: /* VFTCI - vector fp test data class immediate */
5791 case 0xe75c: /* VISTR - vector isolate string */
5792 case 0xe780: /* VFEE - vector find element equal */
5793 case 0xe781: /* VFENE - vector find element not equal */
5794 case 0xe782: /* VFA - vector find any element equal */
5795 case 0xe78a: /* VSTRC - vector string range compare */
5796 case 0xe795: /* VPKLS - vector pack logical saturate */
5797 case 0xe797: /* VPKS - vector pack saturate */
5798 case 0xe7e8: /* VFCE - vector fp compare equal */
5799 case 0xe7ea: /* VFCHE - vector fp compare high or equal */
5800 case 0xe7eb: /* VFCH - vector fp compare high */
5801 case 0xe7f8: /* VCEQ - vector compare equal */
5802 case 0xe7f9: /* VCHL - vector compare high logical */
5803 case 0xe7fb: /* VCH - vector compare high */
5804 /* vector destination + flags + FPC */
5805 if (s390_record_vr (gdbarch
, regcache
, ivec
[0]))
5807 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5809 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
5813 case 0xe65f: /* VTP - vector test decimal */
5815 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5817 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
5821 /* 0xe74b-0xe74c undefined */
5822 /* 0xe74e-0xe74f undefined */
5823 /* 0xe751 undefined */
5824 /* 0xe754-0xe755 undefined */
5825 /* 0xe757-0xe75b undefined */
5826 /* 0xe75d-0xe75e undefined */
5827 /* 0xe763 undefined */
5828 /* 0xe771 undefined */
5829 /* 0xe776 undefined */
5830 /* 0xe779 undefined */
5831 /* 0xe77b undefined */
5832 /* 0xe783 undefined */
5833 /* 0xe786-0xe789 undefined */
5834 /* 0xe78b undefined */
5835 /* 0xe790-0xe793 undefined */
5836 /* 0xe796 undefined */
5837 /* 0xe798-0xe79d undefined */
5838 /* 0xe7a0 undefined */
5839 /* 0xe7a8 undefined */
5840 /* 0xe7b0-0xe7b3 undefined */
5841 /* 0xe7b5-0xe7b7 undefined */
5842 /* 0xe7ba undefined */
5843 /* 0xe7be undefined */
5844 /* 0xe7c6 undefined */
5845 /* 0xe7c8-0xe7c9 undefined */
5847 case 0xe677: /* VCP - vector compare decimal */
5848 case 0xe7ca: /* WFK - vector fp compare and signal scalar */
5849 case 0xe7cb: /* WFC - vector fp compare scalar */
5850 case 0xe7d8: /* VTM - vector test under mask */
5851 case 0xe7d9: /* VECL - vector element compare logical */
5852 case 0xe7db: /* VEC - vector element compare */
5853 case 0xed08: /* KEB - compare and signal */
5854 case 0xed09: /* CEB - compare */
5855 case 0xed18: /* KDB - compare and signal */
5856 case 0xed19: /* CDB - compare */
5857 /* flags + fpc only */
5858 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5860 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
5864 /* 0xe7cd undefined */
5865 /* 0xe7cf-0xe7d3 undefined */
5866 /* 0xe7da undefined */
5867 /* 0xe7dc-0xe7dd undefined */
5868 /* 0xe7e0-0xe7e1 undefined */
5869 /* 0xe7e4 undefined */
5870 /* 0xe7e6 undefined */
5871 /* 0xe7e9 undefined */
5872 /* 0xe7ec-0xe7ed undefined */
5873 /* 0xe7f4 undefined */
5874 /* 0xe7f6 undefined */
5875 /* 0xe7fa undefined */
5877 /* 0xeb00-0xeb03 undefined */
5879 case 0xeb04: /* LMG - load multiple */
5880 for (i
= inib
[2]; i
!= inib
[3]; i
++, i
&= 0xf)
5881 if (s390_record_gpr_g (gdbarch
, regcache
, i
))
5883 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[3]))
5887 /* 0xeb05-0xeb09 undefined */
5888 /* 0xeb0e undefined */
5889 /* 0xeb0f privileged: TRACG */
5890 /* 0xeb10-0xeb13 undefined */
5892 case 0xeb14: /* CSY - compare and swap */
5893 case 0xebf4: /* LAN - load and and */
5894 case 0xebf6: /* LAO - load and or */
5895 case 0xebf7: /* LAX - load and xor */
5896 case 0xebf8: /* LAA - load and add */
5897 case 0xebfa: /* LAAL - 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
, 4))
5901 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
5903 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5907 /* 0xeb15-0xeb1b undefined */
5908 /* 0xeb1e-0xeb1f undefined */
5909 /* 0xeb22 undefined */
5911 case 0xeb23: /* CLT - compare logical and trap */
5912 case 0xeb2b: /* CLGT - compare logical and trap */
5913 /* fpc only - including possible DXC write for trapping insns */
5914 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
5918 case 0xeb24: /* STMG - store multiple */
5919 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], ibyte
[4]);
5920 if (inib
[2] <= inib
[3])
5921 n
= inib
[3] - inib
[2] + 1;
5923 n
= inib
[3] + 0x10 - inib
[2] + 1;
5924 if (record_full_arch_list_add_mem (oaddr
, n
* 8))
5928 /* 0xeb25 privileged */
5930 case 0xeb26: /* STMH - store multiple high */
5931 case 0xeb90: /* STMY - store multiple */
5932 case 0xeb9b: /* STAMY - store access multiple */
5933 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], ibyte
[4]);
5934 if (inib
[2] <= inib
[3])
5935 n
= inib
[3] - inib
[2] + 1;
5937 n
= inib
[3] + 0x10 - inib
[2] + 1;
5938 if (record_full_arch_list_add_mem (oaddr
, n
* 4))
5942 /* 0xeb27-0xeb2a undefined */
5944 case 0xeb2c: /* STCMH - store characters under mask */
5945 case 0xeb2d: /* STCMY - store characters under mask */
5946 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], ibyte
[4]);
5947 if (record_full_arch_list_add_mem (oaddr
, s390_popcnt (inib
[3])))
5951 /* 0xeb2e undefined */
5952 /* 0xeb2f privileged */
5954 case 0xeb30: /* CSG - compare and swap */
5955 case 0xebe4: /* LANG - load and and */
5956 case 0xebe6: /* LAOG - load and or */
5957 case 0xebe7: /* LAXG - load and xor */
5958 case 0xebe8: /* LAAG - load and add */
5959 case 0xebea: /* LAALG - load and add logical */
5960 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], ibyte
[4]);
5961 if (record_full_arch_list_add_mem (oaddr
, 8))
5963 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
5965 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5969 case 0xeb31: /* CDSY - compare double and swap */
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_R0_REGNUM
+ inib
[2]))
5975 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[2] | 1)))
5977 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5981 /* 0xeb32-0xeb3d undefined */
5983 case 0xeb3e: /* CDSG - compare double and swap */
5984 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], ibyte
[4]);
5985 if (record_full_arch_list_add_mem (oaddr
, 16))
5987 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
5989 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2] | 1))
5991 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5995 /* 0xeb3f-0xeb43 undefined */
5996 /* 0xeb46-0xeb4b undefined */
5997 /* 0xeb4d-0xeb50 undefined */
5999 case 0xeb52: /* MVIY - move */
6000 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], ibyte
[4]);
6001 if (record_full_arch_list_add_mem (oaddr
, 1))
6005 case 0xeb54: /* NIY - and */
6006 case 0xeb56: /* OIY - or */
6007 case 0xeb57: /* XIY - xor */
6008 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], ibyte
[4]);
6009 if (record_full_arch_list_add_mem (oaddr
, 1))
6011 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
6015 /* 0xeb53 undefined */
6016 /* 0xeb58-0xeb69 undefined */
6018 case 0xeb6a: /* ASI - add immediate */
6019 case 0xeb6e: /* ALSI - add immediate */
6020 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], ibyte
[4]);
6021 if (record_full_arch_list_add_mem (oaddr
, 4))
6023 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
6027 /* 0xeb6b-0xeb6d undefined */
6028 /* 0xeb6f-0xeb79 undefined */
6030 case 0xeb7a: /* AGSI - add immediate */
6031 case 0xeb7e: /* ALGSI - add immediate */
6032 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], ibyte
[4]);
6033 if (record_full_arch_list_add_mem (oaddr
, 8))
6035 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
6039 /* 0xeb7b-0xeb7d undefined */
6040 /* 0xeb7f undefined */
6042 case 0xeb80: /* ICMH - insert characters under mask */
6043 /* 32-bit high gpr destination + flags */
6044 if (s390_record_gpr_h (gdbarch
, regcache
, inib
[2]))
6046 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
6050 /* 0xeb82-0xeb8d undefined */
6052 case 0xeb8e: /* MVCLU - move long unicode [partial] */
6053 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ inib
[2], &tmp
);
6054 oaddr
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
6055 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ (inib
[2] | 1), &tmp
);
6056 if (record_full_arch_list_add_mem (oaddr
, tmp
))
6058 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
6060 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[2] | 1)))
6062 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[3]))
6064 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[3] | 1)))
6066 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
6070 case 0xeb8f: /* CLCLU - compare logical long unicode [partial] */
6071 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
6073 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[2] | 1)))
6075 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[3]))
6077 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[3] | 1)))
6079 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
6083 /* 0xeb91-0xeb95 undefined */
6085 case 0xeb96: /* LMH - load multiple high */
6086 for (i
= inib
[2]; i
!= inib
[3]; i
++, i
&= 0xf)
6087 if (s390_record_gpr_h (gdbarch
, regcache
, i
))
6089 if (s390_record_gpr_h (gdbarch
, regcache
, inib
[3]))
6093 /* 0xeb97 undefined */
6095 case 0xeb98: /* LMY - load multiple */
6096 for (i
= inib
[2]; i
!= inib
[3]; i
++, i
&= 0xf)
6097 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ i
))
6099 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[3]))
6103 /* 0xeb99 undefined */
6105 case 0xeb9a: /* LAMY - load access multiple */
6106 for (i
= inib
[2]; i
!= inib
[3]; i
++, i
&= 0xf)
6107 if (record_full_arch_list_add_reg (regcache
, S390_A0_REGNUM
+ i
))
6109 if (record_full_arch_list_add_reg (regcache
, S390_A0_REGNUM
+ inib
[3]))
6113 /* 0xeb9c-0xebbf undefined */
6114 /* 0xebc1-0xebdb undefined */
6116 case 0xebe1: /* STOCFH - store high on condition */
6117 case 0xebf3: /* STOC - store on condition */
6118 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], ibyte
[4]);
6119 if (record_full_arch_list_add_mem (oaddr
, 4))
6123 case 0xebe3: /* STOCG - store on condition */
6124 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], ibyte
[4]);
6125 if (record_full_arch_list_add_mem (oaddr
, 8))
6129 /* 0xebe5 undefined */
6130 /* 0xebe9 undefined */
6131 /* 0xebeb-0xebf1 undefined */
6132 /* 0xebf5 undefined */
6133 /* 0xebf9 undefined */
6134 /* 0xebfb-0xebff undefined */
6136 /* 0xed00-0xed03 undefined */
6138 case 0xed04: /* LDEB - load lengthened */
6139 case 0xed0c: /* MDEB - multiply */
6140 case 0xed0d: /* DEB - divide */
6141 case 0xed14: /* SQEB - square root */
6142 case 0xed15: /* SQDB - square root */
6143 case 0xed17: /* MEEB - multiply */
6144 case 0xed1c: /* MDB - multiply */
6145 case 0xed1d: /* DDB - divide */
6146 /* float destination + fpc */
6147 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[2]))
6149 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
6153 case 0xed05: /* LXDB - load lengthened */
6154 case 0xed06: /* LXEB - load lengthened */
6155 case 0xed07: /* MXDB - multiply */
6156 /* float pair destination + fpc */
6157 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[2]))
6159 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ (inib
[2] | 2)))
6161 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
6165 case 0xed0a: /* AEB - add */
6166 case 0xed0b: /* SEB - subtract */
6167 case 0xed1a: /* ADB - add */
6168 case 0xed1b: /* SDB - subtract */
6169 /* float destination + flags + fpc */
6170 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[2]))
6172 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
6174 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
6178 case 0xed0e: /* MAEB - multiply and add */
6179 case 0xed0f: /* MSEB - multiply and subtract */
6180 case 0xed1e: /* MADB - multiply and add */
6181 case 0xed1f: /* MSDB - multiply and subtract */
6182 case 0xed40: /* SLDT - shift significand left */
6183 case 0xed41: /* SRDT - shift significand right */
6184 case 0xedaa: /* CDZT - convert from zoned */
6185 case 0xedae: /* CDPT - convert from packed */
6186 /* float destination [RXF] + fpc */
6187 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[8]))
6189 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
6193 /* 0xed13 undefined */
6194 /* 0xed16 undefined */
6195 /* 0xed20-0xed23 undefined */
6197 case 0xed24: /* LDE - load lengthened */
6198 case 0xed34: /* SQE - square root */
6199 case 0xed35: /* SQD - square root */
6200 case 0xed37: /* MEE - multiply */
6201 case 0xed64: /* LEY - load */
6202 case 0xed65: /* LDY - load */
6203 /* float destination */
6204 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[2]))
6208 case 0xed25: /* LXD - load lengthened */
6209 case 0xed26: /* LXE - load lengthened */
6210 /* float pair destination */
6211 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[2]))
6213 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ (inib
[2] | 2)))
6217 /* 0xed27-0xed2d undefined */
6219 case 0xed2e: /* MAE - multiply and add */
6220 case 0xed2f: /* MSE - multiply and subtract */
6221 case 0xed38: /* MAYL - multiply and add unnormalized */
6222 case 0xed39: /* MYL - multiply unnormalized */
6223 case 0xed3c: /* MAYH - multiply and add unnormalized */
6224 case 0xed3d: /* MYH - multiply unnormalized */
6225 case 0xed3e: /* MAD - multiply and add */
6226 case 0xed3f: /* MSD - multiply and subtract */
6227 /* float destination [RXF] */
6228 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[8]))
6232 /* 0xed30-0xed33 undefined */
6233 /* 0xed36 undefined */
6235 case 0xed3a: /* MAY - multiply and add unnormalized */
6236 case 0xed3b: /* MY - multiply unnormalized */
6237 /* float pair destination [RXF] */
6238 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[8]))
6240 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ (inib
[8] | 2)))
6244 /* 0xed42-0xed47 undefined */
6246 case 0xed48: /* SLXT - shift significand left */
6247 case 0xed49: /* SRXT - shift significand right */
6248 case 0xedab: /* CXZT - convert from zoned */
6249 case 0xedaf: /* CXPT - convert from packed */
6250 /* float pair destination [RXF] + fpc */
6251 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[8]))
6253 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ (inib
[8] | 2)))
6255 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
6259 /* 0xed4a-0xed4f undefined */
6260 /* 0xed52-0xed53 undefined */
6261 /* 0xed56-0xed57 undefined */
6262 /* 0xed5a-0xed63 undefined */
6263 /* 0xed68-0xeda7 undefined */
6265 case 0xeda8: /* CZDT - convert to zoned */
6266 case 0xeda9: /* CZXT - convert to zoned */
6267 case 0xedac: /* CPDT - convert to packed */
6268 case 0xedad: /* CPXT - convert to packed */
6269 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
6270 if (record_full_arch_list_add_mem (oaddr
, ibyte
[1] + 1))
6272 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
6276 /* 0xedb0-0xedff undefined */
6283 /* 0xe4 undefined */
6286 /* SSE/SIL-format instruction */
6289 /* 0xe500-0xe509 undefined, privileged, or unsupported */
6291 case 0xe50a: /* MVCRL - move right to left */
6292 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
, &tmp
);
6293 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
6294 if (record_full_arch_list_add_mem (oaddr
, (tmp
& 0xff) + 1))
6298 /* 0xe50b-0xe543 undefined, privileged, or unsupported */
6300 case 0xe544: /* MVHHI - move */
6301 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
6302 if (record_full_arch_list_add_mem (oaddr
, 2))
6306 /* 0xe545-0xe547 undefined */
6308 case 0xe548: /* MVGHI - move */
6309 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
6310 if (record_full_arch_list_add_mem (oaddr
, 8))
6314 /* 0xe549-0xe54b undefined */
6316 case 0xe54c: /* MVHI - move */
6317 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
6318 if (record_full_arch_list_add_mem (oaddr
, 4))
6322 /* 0xe54d-0xe553 undefined */
6324 case 0xe554: /* CHHSI - compare halfword immediate */
6325 case 0xe555: /* CLHHSI - compare logical immediate */
6326 case 0xe558: /* CGHSI - compare halfword immediate */
6327 case 0xe559: /* CLGHSI - compare logical immediate */
6328 case 0xe55c: /* CHSI - compare halfword immediate */
6329 case 0xe55d: /* CLFHSI - compare logical immediate */
6330 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
6334 /* 0xe556-0xe557 undefined */
6335 /* 0xe55a-0xe55b undefined */
6336 /* 0xe55e-0xe55f undefined */
6338 case 0xe560: /* TBEGIN - transaction begin */
6339 /* The transaction will be immediately aborted after this
6340 instruction, due to single-stepping. This instruction is
6341 only supported so that the program can fail a few times
6342 and go to the non-transactional fallback. */
6345 /* Transaction diagnostic block - user. */
6346 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
6347 if (record_full_arch_list_add_mem (oaddr
, 256))
6350 /* Transaction diagnostic block - supervisor. */
6351 if (record_full_arch_list_add_reg (regcache
, S390_TDB_DWORD0_REGNUM
))
6353 if (record_full_arch_list_add_reg (regcache
, S390_TDB_ABORT_CODE_REGNUM
))
6355 if (record_full_arch_list_add_reg (regcache
, S390_TDB_CONFLICT_TOKEN_REGNUM
))
6357 if (record_full_arch_list_add_reg (regcache
, S390_TDB_ATIA_REGNUM
))
6359 for (i
= 0; i
< 16; i
++)
6360 if (record_full_arch_list_add_reg (regcache
, S390_TDB_R0_REGNUM
+ i
))
6363 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
6367 /* 0xe561 unsupported: TBEGINC */
6368 /* 0xe562-0xe5ff undefined */
6376 /* RIE/RIS/RRS-format instruction */
6377 switch (ibyte
[0] << 8 | ibyte
[5])
6379 /* 0xec00-0xec41 undefined */
6381 case 0xec42: /* LOCHI - load halfword immediate on condition */
6382 case 0xec51: /* RISBLG - rotate then insert selected bits low */
6383 /* 32-bit or native gpr destination */
6384 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
6388 /* 0xec43 undefined */
6390 case 0xec44: /* BRXHG - branch relative on index high */
6391 case 0xec45: /* BRXLG - branch relative on index low or equal */
6392 case 0xec46: /* LOCGHI - load halfword immediate on condition */
6393 case 0xec59: /* RISBGN - rotate then insert selected bits */
6394 /* 64-bit gpr destination */
6395 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
6399 /* 0xec47-0xec4d undefined */
6401 case 0xec4e: /* LOCHHI - load halfword immediate on condition */
6402 case 0xec5d: /* RISBHG - rotate then insert selected bits high */
6403 /* 32-bit high gpr destination */
6404 if (s390_record_gpr_h (gdbarch
, regcache
, inib
[2]))
6408 /* 0xec4f-0xec50 undefined */
6409 /* 0xec52-0xec53 undefined */
6411 case 0xec54: /* RNSBG - rotate then and selected bits */
6412 case 0xec55: /* RISBG - rotate then insert selected bits */
6413 case 0xec56: /* ROSBG - rotate then or selected bits */
6414 case 0xec57: /* RXSBG - rotate then xor selected bits */
6415 case 0xecd9: /* AGHIK - add immediate */
6416 case 0xecdb: /* ALGHSIK - add logical immediate */
6417 /* 64-bit gpr destination + flags */
6418 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
6420 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
6424 /* 0xec58 undefined */
6425 /* 0xec5a-0xec5c undefined */
6426 /* 0xec5e-0xec63 undefined */
6428 case 0xec64: /* CGRJ - compare and branch relative */
6429 case 0xec65: /* CLGRJ - compare logical and branch relative */
6430 case 0xec76: /* CRJ - compare and branch relative */
6431 case 0xec77: /* CLRJ - compare logical and branch relative */
6432 case 0xec7c: /* CGIJ - compare immediate and branch relative */
6433 case 0xec7d: /* CLGIJ - compare logical immediate and branch relative */
6434 case 0xec7e: /* CIJ - compare immediate and branch relative */
6435 case 0xec7f: /* CLIJ - compare logical immediate and branch relative */
6436 case 0xece4: /* CGRB - compare and branch */
6437 case 0xece5: /* CLGRB - compare logical and branch */
6438 case 0xecf6: /* CRB - compare and branch */
6439 case 0xecf7: /* CLRB - compare logical and branch */
6440 case 0xecfc: /* CGIB - compare immediate and branch */
6441 case 0xecfd: /* CLGIB - compare logical immediate and branch */
6442 case 0xecfe: /* CIB - compare immediate and branch */
6443 case 0xecff: /* CLIB - compare logical immediate and branch */
6446 /* 0xec66-0xec6f undefined */
6448 case 0xec70: /* CGIT - compare immediate and trap */
6449 case 0xec71: /* CLGIT - compare logical immediate and trap */
6450 case 0xec72: /* CIT - compare immediate and trap */
6451 case 0xec73: /* CLFIT - compare logical immediate and trap */
6452 /* fpc only - including possible DXC write for trapping insns */
6453 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
6457 /* 0xec74-0xec75 undefined */
6458 /* 0xec78-0xec7b undefined */
6460 /* 0xec80-0xecd7 undefined */
6462 case 0xecd8: /* AHIK - add immediate */
6463 case 0xecda: /* ALHSIK - add logical immediate */
6464 /* 32-bit gpr destination + flags */
6465 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
6467 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
6471 /* 0xecdc-0xece3 undefined */
6472 /* 0xece6-0xecf5 undefined */
6473 /* 0xecf8-0xecfb undefined */
6480 case 0xee: /* PLO - perform locked operation */
6481 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
, &tmp
);
6482 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
6483 oaddr2
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[2], 0);
6486 uint8_t fc
= tmp
& 0xff;
6492 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
6495 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[3]))
6499 case 0x01: /* CLG */
6501 if (record_full_arch_list_add_mem (oaddr2
+ 0x08, 8))
6504 if (record_full_arch_list_add_mem (oaddr2
+ 0x28, 8))
6508 case 0x02: /* CLGR */
6510 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
6513 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[3]))
6517 case 0x03: /* CLX */
6519 if (record_full_arch_list_add_mem (oaddr2
+ 0x00, 16))
6522 if (record_full_arch_list_add_mem (oaddr2
+ 0x20, 16))
6526 case 0x08: /* DCS */
6528 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[3]))
6531 case 0x0c: /* CSST */
6533 if (record_full_arch_list_add_mem (oaddr2
, 4))
6537 case 0x14: /* CSTST */
6539 if (target_read_memory (oaddr2
+ 0x88, buf
, 8))
6541 oaddr3
= extract_unsigned_integer (buf
, 8, byte_order
);
6542 oaddr3
= s390_record_address_mask (gdbarch
, regcache
, oaddr3
);
6543 if (record_full_arch_list_add_mem (oaddr3
, 4))
6546 case 0x10: /* CSDST */
6548 if (target_read_memory (oaddr2
+ 0x68, buf
, 8))
6550 oaddr3
= extract_unsigned_integer (buf
, 8, byte_order
);
6551 oaddr3
= s390_record_address_mask (gdbarch
, regcache
, oaddr3
);
6552 if (record_full_arch_list_add_mem (oaddr3
, 4))
6555 if (target_read_memory (oaddr2
+ 0x48, buf
, 8))
6557 oaddr3
= extract_unsigned_integer (buf
, 8, byte_order
);
6558 oaddr3
= s390_record_address_mask (gdbarch
, regcache
, oaddr3
);
6559 if (record_full_arch_list_add_mem (oaddr3
, 4))
6565 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
6568 if (record_full_arch_list_add_mem (oaddr
, 4))
6572 case 0x09: /* DCSG */
6574 if (record_full_arch_list_add_mem (oaddr2
+ 0x28, 8))
6578 case 0x15: /* CSTSTG */
6580 if (target_read_memory (oaddr2
+ 0x88, buf
, 8))
6582 oaddr3
= extract_unsigned_integer (buf
, 8, byte_order
);
6583 oaddr3
= s390_record_address_mask (gdbarch
, regcache
, oaddr3
);
6584 if (record_full_arch_list_add_mem (oaddr3
, 8))
6587 case 0x11: /* CSDSTG */
6589 if (target_read_memory (oaddr2
+ 0x68, buf
, 8))
6591 oaddr3
= extract_unsigned_integer (buf
, 8, byte_order
);
6592 oaddr3
= s390_record_address_mask (gdbarch
, regcache
, oaddr3
);
6593 if (record_full_arch_list_add_mem (oaddr3
, 8))
6596 case 0x0d: /* CSSTG */
6599 if (target_read_memory (oaddr2
+ 0x48, buf
, 8))
6601 oaddr3
= extract_unsigned_integer (buf
, 8, byte_order
);
6602 oaddr3
= s390_record_address_mask (gdbarch
, regcache
, oaddr3
);
6603 if (record_full_arch_list_add_mem (oaddr3
, 8))
6606 case 0x05: /* CSG */
6608 if (record_full_arch_list_add_mem (oaddr2
+ 0x08, 8))
6611 if (record_full_arch_list_add_mem (oaddr
, 8))
6615 case 0x0a: /* DCSGR */
6617 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[3]))
6620 case 0x0e: /* CSSTGR */
6622 if (record_full_arch_list_add_mem (oaddr2
, 8))
6626 case 0x16: /* CSTSTGR */
6628 if (target_read_memory (oaddr2
+ 0x88, buf
, 8))
6630 oaddr3
= extract_unsigned_integer (buf
, 8, byte_order
);
6631 oaddr3
= s390_record_address_mask (gdbarch
, regcache
, oaddr3
);
6632 if (record_full_arch_list_add_mem (oaddr3
, 8))
6635 case 0x12: /* CSDSTGR */
6637 if (target_read_memory (oaddr2
+ 0x68, buf
, 8))
6639 oaddr3
= extract_unsigned_integer (buf
, 8, byte_order
);
6640 oaddr3
= s390_record_address_mask (gdbarch
, regcache
, oaddr3
);
6641 if (record_full_arch_list_add_mem (oaddr3
, 8))
6644 if (target_read_memory (oaddr2
+ 0x48, buf
, 8))
6646 oaddr3
= extract_unsigned_integer (buf
, 8, byte_order
);
6647 oaddr3
= s390_record_address_mask (gdbarch
, regcache
, oaddr3
);
6648 if (record_full_arch_list_add_mem (oaddr3
, 8))
6651 case 0x06: /* CSGR */
6654 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
6657 if (record_full_arch_list_add_mem (oaddr
, 8))
6661 case 0x0b: /* DCSX */
6663 if (record_full_arch_list_add_mem (oaddr2
+ 0x20, 16))
6667 case 0x17: /* CSTSTX */
6669 if (target_read_memory (oaddr2
+ 0x88, buf
, 8))
6671 oaddr3
= extract_unsigned_integer (buf
, 8, byte_order
);
6672 oaddr3
= s390_record_address_mask (gdbarch
, regcache
, oaddr3
);
6673 if (record_full_arch_list_add_mem (oaddr3
, 16))
6676 case 0x13: /* CSDSTX */
6678 if (target_read_memory (oaddr2
+ 0x68, buf
, 8))
6680 oaddr3
= extract_unsigned_integer (buf
, 8, byte_order
);
6681 oaddr3
= s390_record_address_mask (gdbarch
, regcache
, oaddr3
);
6682 if (record_full_arch_list_add_mem (oaddr3
, 16))
6685 case 0x0f: /* CSSTX */
6688 if (target_read_memory (oaddr2
+ 0x48, buf
, 8))
6690 oaddr3
= extract_unsigned_integer (buf
, 8, byte_order
);
6691 oaddr3
= s390_record_address_mask (gdbarch
, regcache
, oaddr3
);
6692 if (record_full_arch_list_add_mem (oaddr3
, 16))
6695 case 0x07: /* CSX */
6697 if (record_full_arch_list_add_mem (oaddr2
+ 0x00, 16))
6700 if (record_full_arch_list_add_mem (oaddr
, 16))
6705 fprintf_unfiltered (gdb_stdlog
, "Warning: Unknown PLO FC %02x at %s.\n",
6706 fc
, paddress (gdbarch
, addr
));
6710 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
6714 case 0xef: /* LMD - load multiple disjoint */
6715 for (i
= inib
[2]; i
!= inib
[3]; i
++, i
&= 0xf)
6716 if (s390_record_gpr_g (gdbarch
, regcache
, i
))
6718 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[3]))
6722 case 0xf0: /* SRP - shift and round decimal */
6723 case 0xf8: /* ZAP - zero and add */
6724 case 0xfa: /* AP - add decimal */
6725 case 0xfb: /* SP - subtract decimal */
6726 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
6727 if (record_full_arch_list_add_mem (oaddr
, inib
[2] + 1))
6729 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
6731 /* DXC may be written */
6732 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
6736 case 0xf1: /* MVO - move with offset */
6737 case 0xf2: /* PACK - pack */
6738 case 0xf3: /* UNPK - unpack */
6739 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
6740 if (record_full_arch_list_add_mem (oaddr
, inib
[2] + 1))
6744 /* 0xf4-0xf7 undefined */
6746 case 0xf9: /* CP - compare decimal */
6747 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
6749 /* DXC may be written */
6750 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
6754 case 0xfc: /* MP - multiply decimal */
6755 case 0xfd: /* DP - divide decimal */
6756 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
6757 if (record_full_arch_list_add_mem (oaddr
, inib
[2] + 1))
6759 /* DXC may be written */
6760 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
6764 /* 0xfe-0xff undefined */
6768 fprintf_unfiltered (gdb_stdlog
, "Warning: Don't know how to record %04x "
6769 "at %s.\n", insn
[0], paddress (gdbarch
, addr
));
6773 if (record_full_arch_list_add_reg (regcache
, S390_PSWA_REGNUM
))
6775 if (record_full_arch_list_add_end ())
6780 /* Miscellaneous. */
6782 /* Implement gdbarch_gcc_target_options. GCC does not know "-m32" or
6783 "-mcmodel=large". */
6786 s390_gcc_target_options (struct gdbarch
*gdbarch
)
6788 return gdbarch_ptr_bit (gdbarch
) == 64 ? "-m64" : "-m31";
6791 /* Implement gdbarch_gnu_triplet_regexp. Target triplets are "s390-*"
6792 for 31-bit and "s390x-*" for 64-bit, while the BFD arch name is
6793 always "s390". Note that an s390x compiler supports "-m31" as
6797 s390_gnu_triplet_regexp (struct gdbarch
*gdbarch
)
6802 /* Implementation of `gdbarch_stap_is_single_operand', as defined in
6806 s390_stap_is_single_operand (struct gdbarch
*gdbarch
, const char *s
)
6808 return ((isdigit (*s
) && s
[1] == '(' && s
[2] == '%') /* Displacement
6810 || *s
== '%' /* Register access. */
6811 || isdigit (*s
)); /* Literal number. */
6816 /* Validate the range of registers. NAMES must be known at compile time. */
6818 #define s390_validate_reg_range(feature, tdesc_data, start, names) \
6821 for (int i = 0; i < ARRAY_SIZE (names); i++) \
6822 if (!tdesc_numbered_register (feature, tdesc_data, start + i, names[i])) \
6827 /* Validate the target description. Also numbers registers contained in
6831 s390_tdesc_valid (struct gdbarch_tdep
*tdep
,
6832 struct tdesc_arch_data
*tdesc_data
)
6834 static const char *const psw
[] = {
6837 static const char *const gprs
[] = {
6838 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
6839 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
6841 static const char *const fprs
[] = {
6842 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
6843 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15"
6845 static const char *const acrs
[] = {
6846 "acr0", "acr1", "acr2", "acr3", "acr4", "acr5", "acr6", "acr7",
6847 "acr8", "acr9", "acr10", "acr11", "acr12", "acr13", "acr14", "acr15"
6849 static const char *const gprs_lower
[] = {
6850 "r0l", "r1l", "r2l", "r3l", "r4l", "r5l", "r6l", "r7l",
6851 "r8l", "r9l", "r10l", "r11l", "r12l", "r13l", "r14l", "r15l"
6853 static const char *const gprs_upper
[] = {
6854 "r0h", "r1h", "r2h", "r3h", "r4h", "r5h", "r6h", "r7h",
6855 "r8h", "r9h", "r10h", "r11h", "r12h", "r13h", "r14h", "r15h"
6857 static const char *const tdb_regs
[] = {
6858 "tdb0", "tac", "tct", "atia",
6859 "tr0", "tr1", "tr2", "tr3", "tr4", "tr5", "tr6", "tr7",
6860 "tr8", "tr9", "tr10", "tr11", "tr12", "tr13", "tr14", "tr15"
6862 static const char *const vxrs_low
[] = {
6863 "v0l", "v1l", "v2l", "v3l", "v4l", "v5l", "v6l", "v7l", "v8l",
6864 "v9l", "v10l", "v11l", "v12l", "v13l", "v14l", "v15l",
6866 static const char *const vxrs_high
[] = {
6867 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23", "v24",
6868 "v25", "v26", "v27", "v28", "v29", "v30", "v31",
6870 static const char *const gs_cb
[] = {
6871 "gsd", "gssm", "gsepla",
6873 static const char *const gs_bc
[] = {
6874 "bc_gsd", "bc_gssm", "bc_gsepla",
6877 const struct target_desc
*tdesc
= tdep
->tdesc
;
6878 const struct tdesc_feature
*feature
;
6880 if (!tdesc_has_registers (tdesc
))
6883 /* Core registers, i.e. general purpose and PSW. */
6884 feature
= tdesc_find_feature (tdesc
, "org.gnu.gdb.s390.core");
6885 if (feature
== NULL
)
6888 s390_validate_reg_range (feature
, tdesc_data
, S390_PSWM_REGNUM
, psw
);
6890 if (tdesc_unnumbered_register (feature
, "r0"))
6892 s390_validate_reg_range (feature
, tdesc_data
, S390_R0_REGNUM
, gprs
);
6896 tdep
->have_upper
= true;
6897 s390_validate_reg_range (feature
, tdesc_data
, S390_R0_REGNUM
,
6899 s390_validate_reg_range (feature
, tdesc_data
, S390_R0_UPPER_REGNUM
,
6903 /* Floating point registers. */
6904 feature
= tdesc_find_feature (tdesc
, "org.gnu.gdb.s390.fpr");
6905 if (feature
== NULL
)
6908 if (!tdesc_numbered_register (feature
, tdesc_data
, S390_FPC_REGNUM
, "fpc"))
6911 s390_validate_reg_range (feature
, tdesc_data
, S390_F0_REGNUM
, fprs
);
6913 /* Access control registers. */
6914 feature
= tdesc_find_feature (tdesc
, "org.gnu.gdb.s390.acr");
6915 if (feature
== NULL
)
6918 s390_validate_reg_range (feature
, tdesc_data
, S390_A0_REGNUM
, acrs
);
6920 /* Optional GNU/Linux-specific "registers". */
6921 feature
= tdesc_find_feature (tdesc
, "org.gnu.gdb.s390.linux");
6924 tdesc_numbered_register (feature
, tdesc_data
,
6925 S390_ORIG_R2_REGNUM
, "orig_r2");
6927 if (tdesc_numbered_register (feature
, tdesc_data
,
6928 S390_LAST_BREAK_REGNUM
, "last_break"))
6929 tdep
->have_linux_v1
= true;
6931 if (tdesc_numbered_register (feature
, tdesc_data
,
6932 S390_SYSTEM_CALL_REGNUM
, "system_call"))
6933 tdep
->have_linux_v2
= true;
6935 if (tdep
->have_linux_v2
&& !tdep
->have_linux_v1
)
6939 /* Transaction diagnostic block. */
6940 feature
= tdesc_find_feature (tdesc
, "org.gnu.gdb.s390.tdb");
6943 s390_validate_reg_range (feature
, tdesc_data
, S390_TDB_DWORD0_REGNUM
,
6945 tdep
->have_tdb
= true;
6948 /* Vector registers. */
6949 feature
= tdesc_find_feature (tdesc
, "org.gnu.gdb.s390.vx");
6952 s390_validate_reg_range (feature
, tdesc_data
, S390_V0_LOWER_REGNUM
,
6954 s390_validate_reg_range (feature
, tdesc_data
, S390_V16_REGNUM
,
6956 tdep
->have_vx
= true;
6959 /* Guarded-storage registers. */
6960 feature
= tdesc_find_feature (tdesc
, "org.gnu.gdb.s390.gs");
6963 s390_validate_reg_range (feature
, tdesc_data
, S390_GSD_REGNUM
, gs_cb
);
6964 tdep
->have_gs
= true;
6967 /* Guarded-storage broadcast control. */
6968 feature
= tdesc_find_feature (tdesc
, "org.gnu.gdb.s390.gsbc");
6973 s390_validate_reg_range (feature
, tdesc_data
, S390_BC_GSD_REGNUM
,
6980 /* Allocate and initialize new gdbarch_tdep. Caller is responsible to free
6981 memory after use. */
6983 static struct gdbarch_tdep
*
6984 s390_gdbarch_tdep_alloc ()
6986 struct gdbarch_tdep
*tdep
= XCNEW (struct gdbarch_tdep
);
6990 tdep
->abi
= ABI_NONE
;
6991 tdep
->vector_abi
= S390_VECTOR_ABI_NONE
;
6993 tdep
->gpr_full_regnum
= -1;
6994 tdep
->v0_full_regnum
= -1;
6995 tdep
->pc_regnum
= -1;
6996 tdep
->cc_regnum
= -1;
6998 tdep
->have_upper
= false;
6999 tdep
->have_linux_v1
= false;
7000 tdep
->have_linux_v2
= false;
7001 tdep
->have_tdb
= false;
7002 tdep
->have_vx
= false;
7003 tdep
->have_gs
= false;
7005 tdep
->s390_syscall_record
= NULL
;
7010 /* Set up gdbarch struct. */
7012 static struct gdbarch
*
7013 s390_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
7015 const struct target_desc
*tdesc
= info
.target_desc
;
7016 int first_pseudo_reg
, last_pseudo_reg
;
7017 static const char *const stap_register_prefixes
[] = { "%", NULL
};
7018 static const char *const stap_register_indirection_prefixes
[] = { "(",
7020 static const char *const stap_register_indirection_suffixes
[] = { ")",
7023 struct gdbarch_tdep
*tdep
= s390_gdbarch_tdep_alloc ();
7024 struct gdbarch
*gdbarch
= gdbarch_alloc (&info
, tdep
);
7025 tdesc_arch_data_up tdesc_data
= tdesc_data_alloc ();
7026 info
.tdesc_data
= tdesc_data
.get ();
7028 set_gdbarch_believe_pcc_promotion (gdbarch
, 0);
7029 set_gdbarch_char_signed (gdbarch
, 0);
7031 /* S/390 GNU/Linux uses either 64-bit or 128-bit long doubles.
7032 We can safely let them default to 128-bit, since the debug info
7033 will give the size of type actually used in each case. */
7034 set_gdbarch_long_double_bit (gdbarch
, 128);
7035 set_gdbarch_long_double_format (gdbarch
, floatformats_ia64_quad
);
7037 set_gdbarch_type_align (gdbarch
, s390_type_align
);
7040 /* Amount PC must be decremented by after a breakpoint. This is
7041 often the number of bytes returned by gdbarch_breakpoint_from_pc but not
7043 set_gdbarch_decr_pc_after_break (gdbarch
, 2);
7044 set_gdbarch_breakpoint_kind_from_pc (gdbarch
, s390_breakpoint::kind_from_pc
);
7045 set_gdbarch_sw_breakpoint_from_kind (gdbarch
, s390_breakpoint::bp_from_kind
);
7047 /* Displaced stepping. */
7048 set_gdbarch_displaced_step_copy_insn (gdbarch
,
7049 s390_displaced_step_copy_insn
);
7050 set_gdbarch_displaced_step_fixup (gdbarch
, s390_displaced_step_fixup
);
7051 set_gdbarch_displaced_step_prepare (gdbarch
, linux_displaced_step_prepare
);
7052 set_gdbarch_displaced_step_finish (gdbarch
, linux_displaced_step_finish
);
7053 set_gdbarch_displaced_step_restore_all_in_ptid
7054 (gdbarch
, linux_displaced_step_restore_all_in_ptid
);
7055 set_gdbarch_displaced_step_hw_singlestep (gdbarch
, s390_displaced_step_hw_singlestep
);
7056 set_gdbarch_software_single_step (gdbarch
, s390_software_single_step
);
7057 set_gdbarch_max_insn_length (gdbarch
, S390_MAX_INSTR_SIZE
);
7059 /* Prologue analysis. */
7060 set_gdbarch_skip_prologue (gdbarch
, s390_skip_prologue
);
7062 /* Register handling. */
7063 set_gdbarch_num_regs (gdbarch
, S390_NUM_REGS
);
7064 set_gdbarch_sp_regnum (gdbarch
, S390_SP_REGNUM
);
7065 set_gdbarch_fp0_regnum (gdbarch
, S390_F0_REGNUM
);
7066 set_gdbarch_guess_tracepoint_registers (gdbarch
,
7067 s390_guess_tracepoint_registers
);
7068 set_gdbarch_stab_reg_to_regnum (gdbarch
, s390_dwarf_reg_to_regnum
);
7069 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, s390_dwarf_reg_to_regnum
);
7070 set_gdbarch_value_from_register (gdbarch
, s390_value_from_register
);
7072 /* Pseudo registers. */
7073 set_gdbarch_pseudo_register_read (gdbarch
, s390_pseudo_register_read
);
7074 set_gdbarch_pseudo_register_write (gdbarch
, s390_pseudo_register_write
);
7075 set_tdesc_pseudo_register_name (gdbarch
, s390_pseudo_register_name
);
7076 set_tdesc_pseudo_register_type (gdbarch
, s390_pseudo_register_type
);
7077 set_tdesc_pseudo_register_reggroup_p (gdbarch
,
7078 s390_pseudo_register_reggroup_p
);
7079 set_gdbarch_ax_pseudo_register_collect (gdbarch
,
7080 s390_ax_pseudo_register_collect
);
7081 set_gdbarch_ax_pseudo_register_push_stack
7082 (gdbarch
, s390_ax_pseudo_register_push_stack
);
7083 set_gdbarch_gen_return_address (gdbarch
, s390_gen_return_address
);
7085 /* Inferior function calls. */
7086 set_gdbarch_push_dummy_call (gdbarch
, s390_push_dummy_call
);
7087 set_gdbarch_dummy_id (gdbarch
, s390_dummy_id
);
7088 set_gdbarch_frame_align (gdbarch
, s390_frame_align
);
7089 set_gdbarch_return_value (gdbarch
, s390_return_value
);
7091 /* Frame handling. */
7092 /* Stack grows downward. */
7093 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
7094 set_gdbarch_stack_frame_destroyed_p (gdbarch
, s390_stack_frame_destroyed_p
);
7095 dwarf2_frame_set_init_reg (gdbarch
, s390_dwarf2_frame_init_reg
);
7096 dwarf2_frame_set_adjust_regnum (gdbarch
, s390_adjust_frame_regnum
);
7097 dwarf2_append_unwinders (gdbarch
);
7098 set_gdbarch_unwind_pc (gdbarch
, s390_unwind_pc
);
7099 set_gdbarch_unwind_sp (gdbarch
, s390_unwind_sp
);
7101 switch (info
.bfd_arch_info
->mach
)
7103 case bfd_mach_s390_31
:
7104 set_gdbarch_addr_bits_remove (gdbarch
, s390_addr_bits_remove
);
7107 case bfd_mach_s390_64
:
7108 set_gdbarch_long_bit (gdbarch
, 64);
7109 set_gdbarch_long_long_bit (gdbarch
, 64);
7110 set_gdbarch_ptr_bit (gdbarch
, 64);
7111 set_gdbarch_address_class_type_flags (gdbarch
,
7112 s390_address_class_type_flags
);
7113 set_gdbarch_address_class_type_flags_to_name (gdbarch
,
7114 s390_address_class_type_flags_to_name
);
7115 set_gdbarch_address_class_name_to_type_flags (gdbarch
,
7116 s390_address_class_name_to_type_flags
);
7120 /* SystemTap functions. */
7121 set_gdbarch_stap_register_prefixes (gdbarch
, stap_register_prefixes
);
7122 set_gdbarch_stap_register_indirection_prefixes (gdbarch
,
7123 stap_register_indirection_prefixes
);
7124 set_gdbarch_stap_register_indirection_suffixes (gdbarch
,
7125 stap_register_indirection_suffixes
);
7127 set_gdbarch_disassembler_options (gdbarch
, &s390_disassembler_options
);
7128 set_gdbarch_valid_disassembler_options (gdbarch
,
7129 disassembler_options_s390 ());
7131 /* Process record-replay */
7132 set_gdbarch_process_record (gdbarch
, s390_process_record
);
7134 /* Miscellaneous. */
7135 set_gdbarch_stap_is_single_operand (gdbarch
, s390_stap_is_single_operand
);
7136 set_gdbarch_gcc_target_options (gdbarch
, s390_gcc_target_options
);
7137 set_gdbarch_gnu_triplet_regexp (gdbarch
, s390_gnu_triplet_regexp
);
7139 /* Initialize the OSABI. */
7140 gdbarch_init_osabi (info
, gdbarch
);
7142 /* Always create a default tdesc. Otherwise commands like 'set osabi'
7143 cause GDB to crash with an internal error when the user tries to set
7144 an unsupported OSABI. */
7145 if (!tdesc_has_registers (tdesc
))
7147 if (info
.bfd_arch_info
->mach
== bfd_mach_s390_31
)
7148 tdesc
= tdesc_s390_linux32
;
7150 tdesc
= tdesc_s390x_linux64
;
7152 tdep
->tdesc
= tdesc
;
7154 /* Check any target description for validity. */
7155 if (!s390_tdesc_valid (tdep
, tdesc_data
.get ()))
7158 gdbarch_free (gdbarch
);
7162 /* Determine vector ABI. */
7165 && info
.abfd
!= NULL
7166 && info
.abfd
->format
== bfd_object
7167 && bfd_get_flavour (info
.abfd
) == bfd_target_elf_flavour
7168 && bfd_elf_get_obj_attr_int (info
.abfd
, OBJ_ATTR_GNU
,
7169 Tag_GNU_S390_ABI_Vector
) == 2)
7170 tdep
->vector_abi
= S390_VECTOR_ABI_128
;
7173 /* Find a candidate among extant architectures. */
7174 for (arches
= gdbarch_list_lookup_by_info (arches
, &info
);
7176 arches
= gdbarch_list_lookup_by_info (arches
->next
, &info
))
7178 struct gdbarch_tdep
*tmp
= gdbarch_tdep (arches
->gdbarch
);
7181 /* A program can 'choose' not to use the vector registers when they
7182 are present. Leading to the same tdesc but different tdep and
7183 thereby a different gdbarch. */
7184 if (tmp
->vector_abi
!= tdep
->vector_abi
)
7188 gdbarch_free (gdbarch
);
7189 return arches
->gdbarch
;
7192 tdesc_use_registers (gdbarch
, tdep
->tdesc
, std::move (tdesc_data
));
7193 set_gdbarch_register_name (gdbarch
, s390_register_name
);
7195 /* Assign pseudo register numbers. */
7196 first_pseudo_reg
= gdbarch_num_regs (gdbarch
);
7197 last_pseudo_reg
= first_pseudo_reg
;
7198 if (tdep
->have_upper
)
7200 tdep
->gpr_full_regnum
= last_pseudo_reg
;
7201 last_pseudo_reg
+= 16;
7205 tdep
->v0_full_regnum
= last_pseudo_reg
;
7206 last_pseudo_reg
+= 16;
7208 tdep
->pc_regnum
= last_pseudo_reg
++;
7209 tdep
->cc_regnum
= last_pseudo_reg
++;
7210 set_gdbarch_pc_regnum (gdbarch
, tdep
->pc_regnum
);
7211 set_gdbarch_num_pseudo_regs (gdbarch
, last_pseudo_reg
- first_pseudo_reg
);
7213 /* Frame handling. */
7214 frame_base_append_sniffer (gdbarch
, dwarf2_frame_base_sniffer
);
7215 frame_unwind_append_unwinder (gdbarch
, &s390_stub_frame_unwind
);
7216 frame_unwind_append_unwinder (gdbarch
, &s390_frame_unwind
);
7217 frame_base_set_default (gdbarch
, &s390_frame_base
);
7222 void _initialize_s390_tdep ();
7224 _initialize_s390_tdep ()
7226 /* Hook us into the gdbarch mechanism. */
7227 register_gdbarch_init (bfd_arch_s390
, s390_gdbarch_init
);
7229 initialize_tdesc_s390_linux32 ();
7230 initialize_tdesc_s390x_linux64 ();