1 /* Target-dependent code for s390.
3 Copyright (C) 2001-2019 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "arch-utils.h"
24 #include "dwarf2-frame.h"
27 #include "frame-base.h"
28 #include "frame-unwind.h"
32 #include "linux-tdep.h"
35 #include "record-full.h"
37 #include "reggroups.h"
38 #include "s390-tdep.h"
39 #include "target-descriptions.h"
40 #include "trad-frame.h"
43 #include "features/s390-linux32.c"
44 #include "features/s390x-linux64.c"
46 /* Holds the current set of options to be passed to the disassembler. */
47 static char *s390_disassembler_options
;
51 constexpr gdb_byte s390_break_insn
[] = { 0x0, 0x1 };
53 typedef BP_MANIPULATION (s390_break_insn
) s390_breakpoint
;
57 /* Implement the gdbarch type alignment method. */
60 s390_type_align (gdbarch
*gdbarch
, struct type
*t
)
62 t
= check_typedef (t
);
64 if (TYPE_LENGTH (t
) > 8)
66 switch (TYPE_CODE (t
))
74 case TYPE_CODE_DECFLOAT
:
86 /* Decoding S/390 instructions. */
88 /* Read a single instruction from address AT. */
91 s390_readinstruction (bfd_byte instr
[], CORE_ADDR at
)
93 static int s390_instrlen
[] = { 2, 4, 4, 6 };
96 if (target_read_memory (at
, &instr
[0], 2))
98 instrlen
= s390_instrlen
[instr
[0] >> 6];
101 if (target_read_memory (at
+ 2, &instr
[2], instrlen
- 2))
107 /* The functions below are for recognizing and decoding S/390
108 instructions of various formats. Each of them checks whether INSN
109 is an instruction of the given format, with the specified opcodes.
110 If it is, it sets the remaining arguments to the values of the
111 instruction's fields, and returns a non-zero value; otherwise, it
114 These functions' arguments appear in the order they appear in the
115 instruction, not in the machine-language form. So, opcodes always
116 come first, even though they're sometimes scattered around the
117 instructions. And displacements appear before base and extension
118 registers, as they do in the assembly syntax, not at the end, as
119 they do in the machine language.
121 Test for RI instruction format. */
124 is_ri (bfd_byte
*insn
, int op1
, int op2
, unsigned int *r1
, int *i2
)
126 if (insn
[0] == op1
&& (insn
[1] & 0xf) == op2
)
128 *r1
= (insn
[1] >> 4) & 0xf;
129 /* i2 is a 16-bit signed quantity. */
130 *i2
= (((insn
[2] << 8) | insn
[3]) ^ 0x8000) - 0x8000;
137 /* Test for RIL instruction format. See comment on is_ri for details. */
140 is_ril (bfd_byte
*insn
, int op1
, int op2
,
141 unsigned int *r1
, int *i2
)
143 if (insn
[0] == op1
&& (insn
[1] & 0xf) == op2
)
145 *r1
= (insn
[1] >> 4) & 0xf;
146 /* i2 is a signed quantity. If the host 'int' is 32 bits long,
147 no sign extension is necessary, but we don't want to assume
149 *i2
= (((insn
[2] << 24)
152 | (insn
[5])) ^ 0x80000000) - 0x80000000;
159 /* Test for RR instruction format. See comment on is_ri for details. */
162 is_rr (bfd_byte
*insn
, int op
, unsigned int *r1
, unsigned int *r2
)
166 *r1
= (insn
[1] >> 4) & 0xf;
174 /* Test for RRE instruction format. See comment on is_ri for details. */
177 is_rre (bfd_byte
*insn
, int op
, unsigned int *r1
, unsigned int *r2
)
179 if (((insn
[0] << 8) | insn
[1]) == op
)
181 /* Yes, insn[3]. insn[2] is unused in RRE format. */
182 *r1
= (insn
[3] >> 4) & 0xf;
190 /* Test for RS instruction format. See comment on is_ri for details. */
193 is_rs (bfd_byte
*insn
, int op
,
194 unsigned int *r1
, unsigned int *r3
, int *d2
, unsigned int *b2
)
198 *r1
= (insn
[1] >> 4) & 0xf;
200 *b2
= (insn
[2] >> 4) & 0xf;
201 *d2
= ((insn
[2] & 0xf) << 8) | insn
[3];
208 /* Test for RSY instruction format. See comment on is_ri for details. */
211 is_rsy (bfd_byte
*insn
, int op1
, int op2
,
212 unsigned int *r1
, unsigned int *r3
, int *d2
, unsigned int *b2
)
217 *r1
= (insn
[1] >> 4) & 0xf;
219 *b2
= (insn
[2] >> 4) & 0xf;
220 /* The 'long displacement' is a 20-bit signed integer. */
221 *d2
= ((((insn
[2] & 0xf) << 8) | insn
[3] | (insn
[4] << 12))
222 ^ 0x80000) - 0x80000;
229 /* Test for RX instruction format. See comment on is_ri for details. */
232 is_rx (bfd_byte
*insn
, int op
,
233 unsigned int *r1
, int *d2
, unsigned int *x2
, unsigned int *b2
)
237 *r1
= (insn
[1] >> 4) & 0xf;
239 *b2
= (insn
[2] >> 4) & 0xf;
240 *d2
= ((insn
[2] & 0xf) << 8) | insn
[3];
247 /* Test for RXY instruction format. See comment on is_ri for details. */
250 is_rxy (bfd_byte
*insn
, int op1
, int op2
,
251 unsigned int *r1
, int *d2
, unsigned int *x2
, unsigned int *b2
)
256 *r1
= (insn
[1] >> 4) & 0xf;
258 *b2
= (insn
[2] >> 4) & 0xf;
259 /* The 'long displacement' is a 20-bit signed integer. */
260 *d2
= ((((insn
[2] & 0xf) << 8) | insn
[3] | (insn
[4] << 12))
261 ^ 0x80000) - 0x80000;
268 /* A helper for s390_software_single_step, decides if an instruction
269 is a partial-execution instruction that needs to be executed until
270 completion when in record mode. If it is, returns 1 and writes
271 instruction length to a pointer. */
274 s390_is_partial_instruction (struct gdbarch
*gdbarch
, CORE_ADDR loc
, int *len
)
276 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
279 insn
= read_memory_integer (loc
, 2, byte_order
);
283 case 0xa8: /* MVCLE */
289 insn
= read_memory_integer (loc
+ 4, 2, byte_order
);
290 if ((insn
& 0xff) == 0x8e)
302 case 0xb255: /* MVST */
303 case 0xb263: /* CMPSC */
304 case 0xb2a5: /* TRE */
305 case 0xb2a6: /* CU21 */
306 case 0xb2a7: /* CU12 */
307 case 0xb9b0: /* CU14 */
308 case 0xb9b1: /* CU24 */
309 case 0xb9b2: /* CU41 */
310 case 0xb9b3: /* CU42 */
311 case 0xb92a: /* KMF */
312 case 0xb92b: /* KMO */
313 case 0xb92f: /* KMC */
314 case 0xb92d: /* KMCTR */
315 case 0xb92e: /* KM */
316 case 0xb93c: /* PPNO */
317 case 0xb990: /* TRTT */
318 case 0xb991: /* TRTO */
319 case 0xb992: /* TROT */
320 case 0xb993: /* TROO */
328 /* Implement the "software_single_step" gdbarch method, needed to single step
329 through instructions like MVCLE in record mode, to make sure they are
330 executed to completion. Without that, record will save the full length
331 of destination buffer on every iteration, even though the CPU will only
332 process about 4kiB of it each time, leading to O(n**2) memory and time
335 static std::vector
<CORE_ADDR
>
336 s390_software_single_step (struct regcache
*regcache
)
338 struct gdbarch
*gdbarch
= regcache
->arch ();
339 CORE_ADDR loc
= regcache_read_pc (regcache
);
340 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
344 /* Special handling only if recording. */
345 if (!record_full_is_used ())
348 /* First, match a partial instruction. */
349 if (!s390_is_partial_instruction (gdbarch
, loc
, &len
))
354 /* Second, look for a branch back to it. */
355 insn
= read_memory_integer (loc
, 2, byte_order
);
356 if (insn
!= 0xa714) /* BRC with mask 1 */
359 insn
= read_memory_integer (loc
+ 2, 2, byte_order
);
360 if (insn
!= (uint16_t) -(len
/ 2))
365 /* Found it, step past the whole thing. */
369 /* Displaced stepping. */
371 /* Return true if INSN is a non-branch RIL-b or RIL-c format
375 is_non_branch_ril (gdb_byte
*insn
)
377 gdb_byte op1
= insn
[0];
381 gdb_byte op2
= insn
[1] & 0x0f;
385 case 0x02: /* llhrl */
386 case 0x04: /* lghrl */
387 case 0x05: /* lhrl */
388 case 0x06: /* llghrl */
389 case 0x07: /* sthrl */
390 case 0x08: /* lgrl */
391 case 0x0b: /* stgrl */
392 case 0x0c: /* lgfrl */
394 case 0x0e: /* llgfrl */
395 case 0x0f: /* strl */
399 else if (op1
== 0xc6)
401 gdb_byte op2
= insn
[1] & 0x0f;
405 case 0x00: /* exrl */
406 case 0x02: /* pfdrl */
407 case 0x04: /* cghrl */
408 case 0x05: /* chrl */
409 case 0x06: /* clghrl */
410 case 0x07: /* clhrl */
411 case 0x08: /* cgrl */
412 case 0x0a: /* clgrl */
413 case 0x0c: /* cgfrl */
415 case 0x0e: /* clgfrl */
416 case 0x0f: /* clrl */
424 typedef buf_displaced_step_closure s390_displaced_step_closure
;
426 /* Implementation of gdbarch_displaced_step_copy_insn. */
428 static struct displaced_step_closure
*
429 s390_displaced_step_copy_insn (struct gdbarch
*gdbarch
,
430 CORE_ADDR from
, CORE_ADDR to
,
431 struct regcache
*regs
)
433 size_t len
= gdbarch_max_insn_length (gdbarch
);
434 std::unique_ptr
<s390_displaced_step_closure
> closure
435 (new s390_displaced_step_closure (len
));
436 gdb_byte
*buf
= closure
->buf
.data ();
438 read_memory (from
, buf
, len
);
440 /* Adjust the displacement field of PC-relative RIL instructions,
441 except branches. The latter are handled in the fixup hook. */
442 if (is_non_branch_ril (buf
))
446 offset
= extract_signed_integer (buf
+ 2, 4, BFD_ENDIAN_BIG
);
447 offset
= (from
- to
+ offset
* 2) / 2;
449 /* If the instruction is too far from the jump pad, punt. This
450 will usually happen with instructions in shared libraries.
451 We could probably support these by rewriting them to be
452 absolute or fully emulating them. */
453 if (offset
< INT32_MIN
|| offset
> INT32_MAX
)
455 /* Let the core fall back to stepping over the breakpoint
459 fprintf_unfiltered (gdb_stdlog
,
460 "displaced: can't displaced step "
461 "RIL instruction: offset %s out of range\n",
468 store_signed_integer (buf
+ 2, 4, BFD_ENDIAN_BIG
, offset
);
471 write_memory (to
, buf
, len
);
475 fprintf_unfiltered (gdb_stdlog
, "displaced: copy %s->%s: ",
476 paddress (gdbarch
, from
), paddress (gdbarch
, to
));
477 displaced_step_dump_bytes (gdb_stdlog
, buf
, len
);
480 return closure
.release ();
483 /* Fix up the state of registers and memory after having single-stepped
484 a displaced instruction. */
487 s390_displaced_step_fixup (struct gdbarch
*gdbarch
,
488 struct displaced_step_closure
*closure_
,
489 CORE_ADDR from
, CORE_ADDR to
,
490 struct regcache
*regs
)
492 /* Our closure is a copy of the instruction. */
493 s390_displaced_step_closure
*closure
494 = (s390_displaced_step_closure
*) closure_
;
495 gdb_byte
*insn
= closure
->buf
.data ();
496 static int s390_instrlen
[] = { 2, 4, 4, 6 };
497 int insnlen
= s390_instrlen
[insn
[0] >> 6];
499 /* Fields for various kinds of instructions. */
500 unsigned int b2
, r1
, r2
, x2
, r3
;
503 /* Get current PC and addressing mode bit. */
504 CORE_ADDR pc
= regcache_read_pc (regs
);
507 if (register_size (gdbarch
, S390_PSWA_REGNUM
) == 4)
509 regcache_cooked_read_unsigned (regs
, S390_PSWA_REGNUM
, &amode
);
514 fprintf_unfiltered (gdb_stdlog
,
515 "displaced: (s390) fixup (%s, %s) pc %s len %d amode 0x%x\n",
516 paddress (gdbarch
, from
), paddress (gdbarch
, to
),
517 paddress (gdbarch
, pc
), insnlen
, (int) amode
);
519 /* Handle absolute branch and save instructions. */
520 if (is_rr (insn
, op_basr
, &r1
, &r2
)
521 || is_rx (insn
, op_bas
, &r1
, &d2
, &x2
, &b2
))
523 /* Recompute saved return address in R1. */
524 regcache_cooked_write_unsigned (regs
, S390_R0_REGNUM
+ r1
,
525 amode
| (from
+ insnlen
));
526 /* Update PC iff the instruction doesn't actually branch. */
527 if (insn
[0] == op_basr
&& r2
== 0)
528 regcache_write_pc (regs
, from
+ insnlen
);
531 /* Handle absolute branch instructions. */
532 else if (is_rr (insn
, op_bcr
, &r1
, &r2
)
533 || is_rx (insn
, op_bc
, &r1
, &d2
, &x2
, &b2
)
534 || is_rr (insn
, op_bctr
, &r1
, &r2
)
535 || is_rre (insn
, op_bctgr
, &r1
, &r2
)
536 || is_rx (insn
, op_bct
, &r1
, &d2
, &x2
, &b2
)
537 || is_rxy (insn
, op1_bctg
, op2_brctg
, &r1
, &d2
, &x2
, &b2
)
538 || is_rs (insn
, op_bxh
, &r1
, &r3
, &d2
, &b2
)
539 || is_rsy (insn
, op1_bxhg
, op2_bxhg
, &r1
, &r3
, &d2
, &b2
)
540 || is_rs (insn
, op_bxle
, &r1
, &r3
, &d2
, &b2
)
541 || is_rsy (insn
, op1_bxleg
, op2_bxleg
, &r1
, &r3
, &d2
, &b2
))
543 /* Update PC iff branch was *not* taken. */
544 if (pc
== to
+ insnlen
)
545 regcache_write_pc (regs
, from
+ insnlen
);
548 /* Handle PC-relative branch and save instructions. */
549 else if (is_ri (insn
, op1_bras
, op2_bras
, &r1
, &i2
)
550 || is_ril (insn
, op1_brasl
, op2_brasl
, &r1
, &i2
))
553 regcache_write_pc (regs
, pc
- to
+ from
);
554 /* Recompute saved return address in R1. */
555 regcache_cooked_write_unsigned (regs
, S390_R0_REGNUM
+ r1
,
556 amode
| (from
+ insnlen
));
559 /* Handle LOAD ADDRESS RELATIVE LONG. */
560 else if (is_ril (insn
, op1_larl
, op2_larl
, &r1
, &i2
))
563 regcache_write_pc (regs
, from
+ insnlen
);
564 /* Recompute output address in R1. */
565 regcache_cooked_write_unsigned (regs
, S390_R0_REGNUM
+ r1
,
566 amode
| (from
+ i2
* 2));
569 /* If we executed a breakpoint instruction, point PC right back at it. */
570 else if (insn
[0] == 0x0 && insn
[1] == 0x1)
571 regcache_write_pc (regs
, from
);
573 /* For any other insn, adjust PC by negated displacement. PC then
574 points right after the original instruction, except for PC-relative
575 branches, where it points to the adjusted branch target. */
577 regcache_write_pc (regs
, pc
- to
+ from
);
580 fprintf_unfiltered (gdb_stdlog
,
581 "displaced: (s390) pc is now %s\n",
582 paddress (gdbarch
, regcache_read_pc (regs
)));
585 /* Implement displaced_step_hw_singlestep gdbarch method. */
588 s390_displaced_step_hw_singlestep (struct gdbarch
*gdbarch
,
589 struct displaced_step_closure
*closure
)
594 /* Prologue analysis. */
596 struct s390_prologue_data
{
599 struct pv_area
*stack
;
601 /* The size and byte-order of a GPR or FPR. */
604 enum bfd_endian byte_order
;
606 /* The general-purpose registers. */
607 pv_t gpr
[S390_NUM_GPRS
];
609 /* The floating-point registers. */
610 pv_t fpr
[S390_NUM_FPRS
];
612 /* The offset relative to the CFA where the incoming GPR N was saved
613 by the function prologue. 0 if not saved or unknown. */
614 int gpr_slot
[S390_NUM_GPRS
];
616 /* Likewise for FPRs. */
617 int fpr_slot
[S390_NUM_FPRS
];
619 /* Nonzero if the backchain was saved. This is assumed to be the
620 case when the incoming SP is saved at the current SP location. */
621 int back_chain_saved_p
;
624 /* Return the effective address for an X-style instruction, like:
628 Here, X2 and B2 are registers, and D2 is a signed 20-bit
629 constant; the effective address is the sum of all three. If either
630 X2 or B2 are zero, then it doesn't contribute to the sum --- this
631 means that r0 can't be used as either X2 or B2. */
634 s390_addr (struct s390_prologue_data
*data
,
635 int d2
, unsigned int x2
, unsigned int b2
)
639 result
= pv_constant (d2
);
641 result
= pv_add (result
, data
->gpr
[x2
]);
643 result
= pv_add (result
, data
->gpr
[b2
]);
648 /* Do a SIZE-byte store of VALUE to D2(X2,B2). */
651 s390_store (struct s390_prologue_data
*data
,
652 int d2
, unsigned int x2
, unsigned int b2
, CORE_ADDR size
,
655 pv_t addr
= s390_addr (data
, d2
, x2
, b2
);
658 /* Check whether we are storing the backchain. */
659 offset
= pv_subtract (data
->gpr
[S390_SP_REGNUM
- S390_R0_REGNUM
], addr
);
661 if (pv_is_constant (offset
) && offset
.k
== 0)
662 if (size
== data
->gpr_size
663 && pv_is_register_k (value
, S390_SP_REGNUM
, 0))
665 data
->back_chain_saved_p
= 1;
669 /* Check whether we are storing a register into the stack. */
670 if (!data
->stack
->store_would_trash (addr
))
671 data
->stack
->store (addr
, size
, value
);
673 /* Note: If this is some store we cannot identify, you might think we
674 should forget our cached values, as any of those might have been hit.
676 However, we make the assumption that the register save areas are only
677 ever stored to once in any given function, and we do recognize these
678 stores. Thus every store we cannot recognize does not hit our data. */
681 /* Do a SIZE-byte load from D2(X2,B2). */
684 s390_load (struct s390_prologue_data
*data
,
685 int d2
, unsigned int x2
, unsigned int b2
, CORE_ADDR size
)
688 pv_t addr
= s390_addr (data
, d2
, x2
, b2
);
690 /* If it's a load from an in-line constant pool, then we can
691 simulate that, under the assumption that the code isn't
692 going to change between the time the processor actually
693 executed it creating the current frame, and the time when
694 we're analyzing the code to unwind past that frame. */
695 if (pv_is_constant (addr
))
697 struct target_section
*secp
;
698 secp
= target_section_by_addr (current_top_target (), addr
.k
);
700 && (bfd_section_flags (secp
->the_bfd_section
) & SEC_READONLY
))
701 return pv_constant (read_memory_integer (addr
.k
, size
,
705 /* Check whether we are accessing one of our save slots. */
706 return data
->stack
->fetch (addr
, size
);
709 /* Function for finding saved registers in a 'struct pv_area'; we pass
710 this to pv_area::scan.
712 If VALUE is a saved register, ADDR says it was saved at a constant
713 offset from the frame base, and SIZE indicates that the whole
714 register was saved, record its offset in the reg_offset table in
718 s390_check_for_saved (void *data_untyped
, pv_t addr
,
719 CORE_ADDR size
, pv_t value
)
721 struct s390_prologue_data
*data
= (struct s390_prologue_data
*) data_untyped
;
724 if (!pv_is_register (addr
, S390_SP_REGNUM
))
727 offset
= 16 * data
->gpr_size
+ 32 - addr
.k
;
729 /* If we are storing the original value of a register, we want to
730 record the CFA offset. If the same register is stored multiple
731 times, the stack slot with the highest address counts. */
733 for (i
= 0; i
< S390_NUM_GPRS
; i
++)
734 if (size
== data
->gpr_size
735 && pv_is_register_k (value
, S390_R0_REGNUM
+ i
, 0))
736 if (data
->gpr_slot
[i
] == 0
737 || data
->gpr_slot
[i
] > offset
)
739 data
->gpr_slot
[i
] = offset
;
743 for (i
= 0; i
< S390_NUM_FPRS
; i
++)
744 if (size
== data
->fpr_size
745 && pv_is_register_k (value
, S390_F0_REGNUM
+ i
, 0))
746 if (data
->fpr_slot
[i
] == 0
747 || data
->fpr_slot
[i
] > offset
)
749 data
->fpr_slot
[i
] = offset
;
754 /* Analyze the prologue of the function starting at START_PC, continuing at
755 most until CURRENT_PC. Initialize DATA to hold all information we find
756 out about the state of the registers and stack slots. Return the address
757 of the instruction after the last one that changed the SP, FP, or back
758 chain; or zero on error. */
761 s390_analyze_prologue (struct gdbarch
*gdbarch
,
763 CORE_ADDR current_pc
,
764 struct s390_prologue_data
*data
)
766 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
769 The address of the instruction after the last one that changed
770 the SP, FP, or back chain; zero if we got an error trying to
772 CORE_ADDR result
= start_pc
;
774 /* The current PC for our abstract interpretation. */
777 /* The address of the next instruction after that. */
780 pv_area
stack (S390_SP_REGNUM
, gdbarch_addr_bit (gdbarch
));
781 scoped_restore restore_stack
= make_scoped_restore (&data
->stack
, &stack
);
783 /* Set up everything's initial value. */
787 /* For the purpose of prologue tracking, we consider the GPR size to
788 be equal to the ABI word size, even if it is actually larger
789 (i.e. when running a 32-bit binary under a 64-bit kernel). */
790 data
->gpr_size
= word_size
;
792 data
->byte_order
= gdbarch_byte_order (gdbarch
);
794 for (i
= 0; i
< S390_NUM_GPRS
; i
++)
795 data
->gpr
[i
] = pv_register (S390_R0_REGNUM
+ i
, 0);
797 for (i
= 0; i
< S390_NUM_FPRS
; i
++)
798 data
->fpr
[i
] = pv_register (S390_F0_REGNUM
+ i
, 0);
800 for (i
= 0; i
< S390_NUM_GPRS
; i
++)
801 data
->gpr_slot
[i
] = 0;
803 for (i
= 0; i
< S390_NUM_FPRS
; i
++)
804 data
->fpr_slot
[i
] = 0;
806 data
->back_chain_saved_p
= 0;
809 /* Start interpreting instructions, until we hit the frame's
810 current PC or the first branch instruction. */
811 for (pc
= start_pc
; pc
> 0 && pc
< current_pc
; pc
= next_pc
)
813 bfd_byte insn
[S390_MAX_INSTR_SIZE
];
814 int insn_len
= s390_readinstruction (insn
, pc
);
816 bfd_byte dummy
[S390_MAX_INSTR_SIZE
] = { 0 };
817 bfd_byte
*insn32
= word_size
== 4 ? insn
: dummy
;
818 bfd_byte
*insn64
= word_size
== 8 ? insn
: dummy
;
820 /* Fields for various kinds of instructions. */
821 unsigned int b2
, r1
, r2
, x2
, r3
;
824 /* The values of SP and FP before this instruction,
825 for detecting instructions that change them. */
826 pv_t pre_insn_sp
, pre_insn_fp
;
827 /* Likewise for the flag whether the back chain was saved. */
828 int pre_insn_back_chain_saved_p
;
830 /* If we got an error trying to read the instruction, report it. */
837 next_pc
= pc
+ insn_len
;
839 pre_insn_sp
= data
->gpr
[S390_SP_REGNUM
- S390_R0_REGNUM
];
840 pre_insn_fp
= data
->gpr
[S390_FRAME_REGNUM
- S390_R0_REGNUM
];
841 pre_insn_back_chain_saved_p
= data
->back_chain_saved_p
;
843 /* LHI r1, i2 --- load halfword immediate. */
844 /* LGHI r1, i2 --- load halfword immediate (64-bit version). */
845 /* LGFI r1, i2 --- load fullword immediate. */
846 if (is_ri (insn32
, op1_lhi
, op2_lhi
, &r1
, &i2
)
847 || is_ri (insn64
, op1_lghi
, op2_lghi
, &r1
, &i2
)
848 || is_ril (insn
, op1_lgfi
, op2_lgfi
, &r1
, &i2
))
849 data
->gpr
[r1
] = pv_constant (i2
);
851 /* LR r1, r2 --- load from register. */
852 /* LGR r1, r2 --- load from register (64-bit version). */
853 else if (is_rr (insn32
, op_lr
, &r1
, &r2
)
854 || is_rre (insn64
, op_lgr
, &r1
, &r2
))
855 data
->gpr
[r1
] = data
->gpr
[r2
];
857 /* L r1, d2(x2, b2) --- load. */
858 /* LY r1, d2(x2, b2) --- load (long-displacement version). */
859 /* LG r1, d2(x2, b2) --- load (64-bit version). */
860 else if (is_rx (insn32
, op_l
, &r1
, &d2
, &x2
, &b2
)
861 || is_rxy (insn32
, op1_ly
, op2_ly
, &r1
, &d2
, &x2
, &b2
)
862 || is_rxy (insn64
, op1_lg
, op2_lg
, &r1
, &d2
, &x2
, &b2
))
863 data
->gpr
[r1
] = s390_load (data
, d2
, x2
, b2
, data
->gpr_size
);
865 /* ST r1, d2(x2, b2) --- store. */
866 /* STY r1, d2(x2, b2) --- store (long-displacement version). */
867 /* STG r1, d2(x2, b2) --- store (64-bit version). */
868 else if (is_rx (insn32
, op_st
, &r1
, &d2
, &x2
, &b2
)
869 || is_rxy (insn32
, op1_sty
, op2_sty
, &r1
, &d2
, &x2
, &b2
)
870 || is_rxy (insn64
, op1_stg
, op2_stg
, &r1
, &d2
, &x2
, &b2
))
871 s390_store (data
, d2
, x2
, b2
, data
->gpr_size
, data
->gpr
[r1
]);
873 /* STD r1, d2(x2,b2) --- store floating-point register. */
874 else if (is_rx (insn
, op_std
, &r1
, &d2
, &x2
, &b2
))
875 s390_store (data
, d2
, x2
, b2
, data
->fpr_size
, data
->fpr
[r1
]);
877 /* STM r1, r3, d2(b2) --- store multiple. */
878 /* STMY r1, r3, d2(b2) --- store multiple (long-displacement
880 /* STMG r1, r3, d2(b2) --- store multiple (64-bit version). */
881 else if (is_rs (insn32
, op_stm
, &r1
, &r3
, &d2
, &b2
)
882 || is_rsy (insn32
, op1_stmy
, op2_stmy
, &r1
, &r3
, &d2
, &b2
)
883 || is_rsy (insn64
, op1_stmg
, op2_stmg
, &r1
, &r3
, &d2
, &b2
))
885 for (; r1
<= r3
; r1
++, d2
+= data
->gpr_size
)
886 s390_store (data
, d2
, 0, b2
, data
->gpr_size
, data
->gpr
[r1
]);
889 /* AHI r1, i2 --- add halfword immediate. */
890 /* AGHI r1, i2 --- add halfword immediate (64-bit version). */
891 /* AFI r1, i2 --- add fullword immediate. */
892 /* AGFI r1, i2 --- add fullword immediate (64-bit version). */
893 else if (is_ri (insn32
, op1_ahi
, op2_ahi
, &r1
, &i2
)
894 || is_ri (insn64
, op1_aghi
, op2_aghi
, &r1
, &i2
)
895 || is_ril (insn32
, op1_afi
, op2_afi
, &r1
, &i2
)
896 || is_ril (insn64
, op1_agfi
, op2_agfi
, &r1
, &i2
))
897 data
->gpr
[r1
] = pv_add_constant (data
->gpr
[r1
], i2
);
899 /* ALFI r1, i2 --- add logical immediate. */
900 /* ALGFI r1, i2 --- add logical immediate (64-bit version). */
901 else if (is_ril (insn32
, op1_alfi
, op2_alfi
, &r1
, &i2
)
902 || is_ril (insn64
, op1_algfi
, op2_algfi
, &r1
, &i2
))
903 data
->gpr
[r1
] = pv_add_constant (data
->gpr
[r1
],
904 (CORE_ADDR
)i2
& 0xffffffff);
906 /* AR r1, r2 -- add register. */
907 /* AGR r1, r2 -- add register (64-bit version). */
908 else if (is_rr (insn32
, op_ar
, &r1
, &r2
)
909 || is_rre (insn64
, op_agr
, &r1
, &r2
))
910 data
->gpr
[r1
] = pv_add (data
->gpr
[r1
], data
->gpr
[r2
]);
912 /* A r1, d2(x2, b2) -- add. */
913 /* AY r1, d2(x2, b2) -- add (long-displacement version). */
914 /* AG r1, d2(x2, b2) -- add (64-bit version). */
915 else if (is_rx (insn32
, op_a
, &r1
, &d2
, &x2
, &b2
)
916 || is_rxy (insn32
, op1_ay
, op2_ay
, &r1
, &d2
, &x2
, &b2
)
917 || is_rxy (insn64
, op1_ag
, op2_ag
, &r1
, &d2
, &x2
, &b2
))
918 data
->gpr
[r1
] = pv_add (data
->gpr
[r1
],
919 s390_load (data
, d2
, x2
, b2
, data
->gpr_size
));
921 /* SLFI r1, i2 --- subtract logical immediate. */
922 /* SLGFI r1, i2 --- subtract logical immediate (64-bit version). */
923 else if (is_ril (insn32
, op1_slfi
, op2_slfi
, &r1
, &i2
)
924 || is_ril (insn64
, op1_slgfi
, op2_slgfi
, &r1
, &i2
))
925 data
->gpr
[r1
] = pv_add_constant (data
->gpr
[r1
],
926 -((CORE_ADDR
)i2
& 0xffffffff));
928 /* SR r1, r2 -- subtract register. */
929 /* SGR r1, r2 -- subtract register (64-bit version). */
930 else if (is_rr (insn32
, op_sr
, &r1
, &r2
)
931 || is_rre (insn64
, op_sgr
, &r1
, &r2
))
932 data
->gpr
[r1
] = pv_subtract (data
->gpr
[r1
], data
->gpr
[r2
]);
934 /* S r1, d2(x2, b2) -- subtract. */
935 /* SY r1, d2(x2, b2) -- subtract (long-displacement version). */
936 /* SG r1, d2(x2, b2) -- subtract (64-bit version). */
937 else if (is_rx (insn32
, op_s
, &r1
, &d2
, &x2
, &b2
)
938 || is_rxy (insn32
, op1_sy
, op2_sy
, &r1
, &d2
, &x2
, &b2
)
939 || is_rxy (insn64
, op1_sg
, op2_sg
, &r1
, &d2
, &x2
, &b2
))
940 data
->gpr
[r1
] = pv_subtract (data
->gpr
[r1
],
941 s390_load (data
, d2
, x2
, b2
, data
->gpr_size
));
943 /* LA r1, d2(x2, b2) --- load address. */
944 /* LAY r1, d2(x2, b2) --- load address (long-displacement version). */
945 else if (is_rx (insn
, op_la
, &r1
, &d2
, &x2
, &b2
)
946 || is_rxy (insn
, op1_lay
, op2_lay
, &r1
, &d2
, &x2
, &b2
))
947 data
->gpr
[r1
] = s390_addr (data
, d2
, x2
, b2
);
949 /* LARL r1, i2 --- load address relative long. */
950 else if (is_ril (insn
, op1_larl
, op2_larl
, &r1
, &i2
))
951 data
->gpr
[r1
] = pv_constant (pc
+ i2
* 2);
953 /* BASR r1, 0 --- branch and save.
954 Since r2 is zero, this saves the PC in r1, but doesn't branch. */
955 else if (is_rr (insn
, op_basr
, &r1
, &r2
)
957 data
->gpr
[r1
] = pv_constant (next_pc
);
959 /* BRAS r1, i2 --- branch relative and save. */
960 else if (is_ri (insn
, op1_bras
, op2_bras
, &r1
, &i2
))
962 data
->gpr
[r1
] = pv_constant (next_pc
);
963 next_pc
= pc
+ i2
* 2;
965 /* We'd better not interpret any backward branches. We'll
971 /* BRC/BRCL -- branch relative on condition. Ignore "branch
972 never", branch to following instruction, and "conditional
973 trap" (BRC +2). Otherwise terminate search. */
974 else if (is_ri (insn
, op1_brc
, op2_brc
, &r1
, &i2
))
976 if (r1
!= 0 && i2
!= 1 && i2
!= 2)
979 else if (is_ril (insn
, op1_brcl
, op2_brcl
, &r1
, &i2
))
981 if (r1
!= 0 && i2
!= 3)
985 /* Terminate search when hitting any other branch instruction. */
986 else if (is_rr (insn
, op_basr
, &r1
, &r2
)
987 || is_rx (insn
, op_bas
, &r1
, &d2
, &x2
, &b2
)
988 || is_rr (insn
, op_bcr
, &r1
, &r2
)
989 || is_rx (insn
, op_bc
, &r1
, &d2
, &x2
, &b2
)
990 || is_ril (insn
, op1_brasl
, op2_brasl
, &r2
, &i2
))
995 /* An instruction we don't know how to simulate. The only
996 safe thing to do would be to set every value we're tracking
997 to 'unknown'. Instead, we'll be optimistic: we assume that
998 we *can* interpret every instruction that the compiler uses
999 to manipulate any of the data we're interested in here --
1000 then we can just ignore anything else. */
1003 /* Record the address after the last instruction that changed
1004 the FP, SP, or backlink. Ignore instructions that changed
1005 them back to their original values --- those are probably
1006 restore instructions. (The back chain is never restored,
1009 pv_t sp
= data
->gpr
[S390_SP_REGNUM
- S390_R0_REGNUM
];
1010 pv_t fp
= data
->gpr
[S390_FRAME_REGNUM
- S390_R0_REGNUM
];
1012 if ((! pv_is_identical (pre_insn_sp
, sp
)
1013 && ! pv_is_register_k (sp
, S390_SP_REGNUM
, 0)
1014 && sp
.kind
!= pvk_unknown
)
1015 || (! pv_is_identical (pre_insn_fp
, fp
)
1016 && ! pv_is_register_k (fp
, S390_FRAME_REGNUM
, 0)
1017 && fp
.kind
!= pvk_unknown
)
1018 || pre_insn_back_chain_saved_p
!= data
->back_chain_saved_p
)
1023 /* Record where all the registers were saved. */
1024 data
->stack
->scan (s390_check_for_saved
, data
);
1029 /* Advance PC across any function entry prologue instructions to reach
1030 some "real" code. */
1033 s390_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
1035 struct s390_prologue_data data
;
1036 CORE_ADDR skip_pc
, func_addr
;
1038 if (find_pc_partial_function (pc
, NULL
, &func_addr
, NULL
))
1040 CORE_ADDR post_prologue_pc
1041 = skip_prologue_using_sal (gdbarch
, func_addr
);
1042 if (post_prologue_pc
!= 0)
1043 return std::max (pc
, post_prologue_pc
);
1046 skip_pc
= s390_analyze_prologue (gdbarch
, pc
, (CORE_ADDR
)-1, &data
);
1047 return skip_pc
? skip_pc
: pc
;
1050 /* Register handling. */
1052 /* ABI call-saved register information. */
1055 s390_register_call_saved (struct gdbarch
*gdbarch
, int regnum
)
1057 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1061 case ABI_LINUX_S390
:
1062 if ((regnum
>= S390_R6_REGNUM
&& regnum
<= S390_R15_REGNUM
)
1063 || regnum
== S390_F4_REGNUM
|| regnum
== S390_F6_REGNUM
1064 || regnum
== S390_A0_REGNUM
)
1069 case ABI_LINUX_ZSERIES
:
1070 if ((regnum
>= S390_R6_REGNUM
&& regnum
<= S390_R15_REGNUM
)
1071 || (regnum
>= S390_F8_REGNUM
&& regnum
<= S390_F15_REGNUM
)
1072 || (regnum
>= S390_A0_REGNUM
&& regnum
<= S390_A1_REGNUM
))
1081 /* The "guess_tracepoint_registers" gdbarch method. */
1084 s390_guess_tracepoint_registers (struct gdbarch
*gdbarch
,
1085 struct regcache
*regcache
,
1088 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1089 int sz
= register_size (gdbarch
, S390_PSWA_REGNUM
);
1090 gdb_byte
*reg
= (gdb_byte
*) alloca (sz
);
1091 ULONGEST pswm
, pswa
;
1093 /* Set PSWA from the location and a default PSWM (the only part we're
1094 unlikely to get right is the CC). */
1095 if (tdep
->abi
== ABI_LINUX_S390
)
1097 /* 31-bit PSWA needs high bit set (it's very unlikely the target
1098 was in 24-bit mode). */
1099 pswa
= addr
| 0x80000000UL
;
1100 pswm
= 0x070d0000UL
;
1105 pswm
= 0x0705000180000000ULL
;
1108 store_unsigned_integer (reg
, sz
, gdbarch_byte_order (gdbarch
), pswa
);
1109 regcache
->raw_supply (S390_PSWA_REGNUM
, reg
);
1111 store_unsigned_integer (reg
, sz
, gdbarch_byte_order (gdbarch
), pswm
);
1112 regcache
->raw_supply (S390_PSWM_REGNUM
, reg
);
1115 /* Return the name of register REGNO. Return the empty string for
1116 registers that shouldn't be visible. */
1119 s390_register_name (struct gdbarch
*gdbarch
, int regnum
)
1121 if (regnum
>= S390_V0_LOWER_REGNUM
1122 && regnum
<= S390_V15_LOWER_REGNUM
)
1124 return tdesc_register_name (gdbarch
, regnum
);
1127 /* DWARF Register Mapping. */
1129 static const short s390_dwarf_regmap
[] =
1131 /* 0-15: General Purpose Registers. */
1132 S390_R0_REGNUM
, S390_R1_REGNUM
, S390_R2_REGNUM
, S390_R3_REGNUM
,
1133 S390_R4_REGNUM
, S390_R5_REGNUM
, S390_R6_REGNUM
, S390_R7_REGNUM
,
1134 S390_R8_REGNUM
, S390_R9_REGNUM
, S390_R10_REGNUM
, S390_R11_REGNUM
,
1135 S390_R12_REGNUM
, S390_R13_REGNUM
, S390_R14_REGNUM
, S390_R15_REGNUM
,
1137 /* 16-31: Floating Point Registers / Vector Registers 0-15. */
1138 S390_F0_REGNUM
, S390_F2_REGNUM
, S390_F4_REGNUM
, S390_F6_REGNUM
,
1139 S390_F1_REGNUM
, S390_F3_REGNUM
, S390_F5_REGNUM
, S390_F7_REGNUM
,
1140 S390_F8_REGNUM
, S390_F10_REGNUM
, S390_F12_REGNUM
, S390_F14_REGNUM
,
1141 S390_F9_REGNUM
, S390_F11_REGNUM
, S390_F13_REGNUM
, S390_F15_REGNUM
,
1143 /* 32-47: Control Registers (not mapped). */
1144 -1, -1, -1, -1, -1, -1, -1, -1,
1145 -1, -1, -1, -1, -1, -1, -1, -1,
1147 /* 48-63: Access Registers. */
1148 S390_A0_REGNUM
, S390_A1_REGNUM
, S390_A2_REGNUM
, S390_A3_REGNUM
,
1149 S390_A4_REGNUM
, S390_A5_REGNUM
, S390_A6_REGNUM
, S390_A7_REGNUM
,
1150 S390_A8_REGNUM
, S390_A9_REGNUM
, S390_A10_REGNUM
, S390_A11_REGNUM
,
1151 S390_A12_REGNUM
, S390_A13_REGNUM
, S390_A14_REGNUM
, S390_A15_REGNUM
,
1153 /* 64-65: Program Status Word. */
1157 /* 66-67: Reserved. */
1160 /* 68-83: Vector Registers 16-31. */
1161 S390_V16_REGNUM
, S390_V18_REGNUM
, S390_V20_REGNUM
, S390_V22_REGNUM
,
1162 S390_V17_REGNUM
, S390_V19_REGNUM
, S390_V21_REGNUM
, S390_V23_REGNUM
,
1163 S390_V24_REGNUM
, S390_V26_REGNUM
, S390_V28_REGNUM
, S390_V30_REGNUM
,
1164 S390_V25_REGNUM
, S390_V27_REGNUM
, S390_V29_REGNUM
, S390_V31_REGNUM
,
1166 /* End of "official" DWARF registers. The remainder of the map is
1167 for GDB internal use only. */
1169 /* GPR Lower Half Access. */
1170 S390_R0_REGNUM
, S390_R1_REGNUM
, S390_R2_REGNUM
, S390_R3_REGNUM
,
1171 S390_R4_REGNUM
, S390_R5_REGNUM
, S390_R6_REGNUM
, S390_R7_REGNUM
,
1172 S390_R8_REGNUM
, S390_R9_REGNUM
, S390_R10_REGNUM
, S390_R11_REGNUM
,
1173 S390_R12_REGNUM
, S390_R13_REGNUM
, S390_R14_REGNUM
, S390_R15_REGNUM
,
1176 enum { s390_dwarf_reg_r0l
= ARRAY_SIZE (s390_dwarf_regmap
) - 16 };
1178 /* Convert DWARF register number REG to the appropriate register
1179 number used by GDB. */
1182 s390_dwarf_reg_to_regnum (struct gdbarch
*gdbarch
, int reg
)
1184 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1187 /* In a 32-on-64 debug scenario, debug info refers to the full
1188 64-bit GPRs. Note that call frame information still refers to
1189 the 32-bit lower halves, because s390_adjust_frame_regnum uses
1190 special register numbers to access GPRs. */
1191 if (tdep
->gpr_full_regnum
!= -1 && reg
>= 0 && reg
< 16)
1192 return tdep
->gpr_full_regnum
+ reg
;
1194 if (reg
>= 0 && reg
< ARRAY_SIZE (s390_dwarf_regmap
))
1195 gdb_reg
= s390_dwarf_regmap
[reg
];
1197 if (tdep
->v0_full_regnum
== -1)
1199 if (gdb_reg
>= S390_V16_REGNUM
&& gdb_reg
<= S390_V31_REGNUM
)
1204 if (gdb_reg
>= S390_F0_REGNUM
&& gdb_reg
<= S390_F15_REGNUM
)
1205 gdb_reg
= gdb_reg
- S390_F0_REGNUM
+ tdep
->v0_full_regnum
;
1211 /* Pseudo registers. */
1213 /* Check whether REGNUM indicates a coupled general purpose register.
1214 These pseudo-registers are composed of two adjacent gprs. */
1217 regnum_is_gpr_full (struct gdbarch_tdep
*tdep
, int regnum
)
1219 return (tdep
->gpr_full_regnum
!= -1
1220 && regnum
>= tdep
->gpr_full_regnum
1221 && regnum
<= tdep
->gpr_full_regnum
+ 15);
1224 /* Check whether REGNUM indicates a full vector register (v0-v15).
1225 These pseudo-registers are composed of f0-f15 and v0l-v15l. */
1228 regnum_is_vxr_full (struct gdbarch_tdep
*tdep
, int regnum
)
1230 return (tdep
->v0_full_regnum
!= -1
1231 && regnum
>= tdep
->v0_full_regnum
1232 && regnum
<= tdep
->v0_full_regnum
+ 15);
1235 /* 'float' values are stored in the upper half of floating-point
1236 registers, even though we are otherwise a big-endian platform. The
1237 same applies to a 'float' value within a vector. */
1239 static struct value
*
1240 s390_value_from_register (struct gdbarch
*gdbarch
, struct type
*type
,
1241 int regnum
, struct frame_id frame_id
)
1243 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1244 struct value
*value
= default_value_from_register (gdbarch
, type
,
1246 check_typedef (type
);
1248 if ((regnum
>= S390_F0_REGNUM
&& regnum
<= S390_F15_REGNUM
1249 && TYPE_LENGTH (type
) < 8)
1250 || regnum_is_vxr_full (tdep
, regnum
)
1251 || (regnum
>= S390_V16_REGNUM
&& regnum
<= S390_V31_REGNUM
))
1252 set_value_offset (value
, 0);
1257 /* Implement pseudo_register_name tdesc method. */
1260 s390_pseudo_register_name (struct gdbarch
*gdbarch
, int regnum
)
1262 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1264 if (regnum
== tdep
->pc_regnum
)
1267 if (regnum
== tdep
->cc_regnum
)
1270 if (regnum_is_gpr_full (tdep
, regnum
))
1272 static const char *full_name
[] = {
1273 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1274 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
1276 return full_name
[regnum
- tdep
->gpr_full_regnum
];
1279 if (regnum_is_vxr_full (tdep
, regnum
))
1281 static const char *full_name
[] = {
1282 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
1283 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15"
1285 return full_name
[regnum
- tdep
->v0_full_regnum
];
1288 internal_error (__FILE__
, __LINE__
, _("invalid regnum"));
1291 /* Implement pseudo_register_type tdesc method. */
1293 static struct type
*
1294 s390_pseudo_register_type (struct gdbarch
*gdbarch
, int regnum
)
1296 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1298 if (regnum
== tdep
->pc_regnum
)
1299 return builtin_type (gdbarch
)->builtin_func_ptr
;
1301 if (regnum
== tdep
->cc_regnum
)
1302 return builtin_type (gdbarch
)->builtin_int
;
1304 if (regnum_is_gpr_full (tdep
, regnum
))
1305 return builtin_type (gdbarch
)->builtin_uint64
;
1307 /* For the "concatenated" vector registers use the same type as v16. */
1308 if (regnum_is_vxr_full (tdep
, regnum
))
1309 return tdesc_register_type (gdbarch
, S390_V16_REGNUM
);
1311 internal_error (__FILE__
, __LINE__
, _("invalid regnum"));
1314 /* Implement pseudo_register_read gdbarch method. */
1316 static enum register_status
1317 s390_pseudo_register_read (struct gdbarch
*gdbarch
, readable_regcache
*regcache
,
1318 int regnum
, gdb_byte
*buf
)
1320 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1321 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1322 int regsize
= register_size (gdbarch
, regnum
);
1325 if (regnum
== tdep
->pc_regnum
)
1327 enum register_status status
;
1329 status
= regcache
->raw_read (S390_PSWA_REGNUM
, &val
);
1330 if (status
== REG_VALID
)
1332 if (register_size (gdbarch
, S390_PSWA_REGNUM
) == 4)
1334 store_unsigned_integer (buf
, regsize
, byte_order
, val
);
1339 if (regnum
== tdep
->cc_regnum
)
1341 enum register_status status
;
1343 status
= regcache
->raw_read (S390_PSWM_REGNUM
, &val
);
1344 if (status
== REG_VALID
)
1346 if (register_size (gdbarch
, S390_PSWA_REGNUM
) == 4)
1347 val
= (val
>> 12) & 3;
1349 val
= (val
>> 44) & 3;
1350 store_unsigned_integer (buf
, regsize
, byte_order
, val
);
1355 if (regnum_is_gpr_full (tdep
, regnum
))
1357 enum register_status status
;
1360 regnum
-= tdep
->gpr_full_regnum
;
1362 status
= regcache
->raw_read (S390_R0_REGNUM
+ regnum
, &val
);
1363 if (status
== REG_VALID
)
1364 status
= regcache
->raw_read (S390_R0_UPPER_REGNUM
+ regnum
,
1366 if (status
== REG_VALID
)
1368 val
|= val_upper
<< 32;
1369 store_unsigned_integer (buf
, regsize
, byte_order
, val
);
1374 if (regnum_is_vxr_full (tdep
, regnum
))
1376 enum register_status status
;
1378 regnum
-= tdep
->v0_full_regnum
;
1380 status
= regcache
->raw_read (S390_F0_REGNUM
+ regnum
, buf
);
1381 if (status
== REG_VALID
)
1382 status
= regcache
->raw_read (S390_V0_LOWER_REGNUM
+ regnum
, buf
+ 8);
1386 internal_error (__FILE__
, __LINE__
, _("invalid regnum"));
1389 /* Implement pseudo_register_write gdbarch method. */
1392 s390_pseudo_register_write (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
1393 int regnum
, const gdb_byte
*buf
)
1395 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1396 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1397 int regsize
= register_size (gdbarch
, regnum
);
1400 if (regnum
== tdep
->pc_regnum
)
1402 val
= extract_unsigned_integer (buf
, regsize
, byte_order
);
1403 if (register_size (gdbarch
, S390_PSWA_REGNUM
) == 4)
1405 regcache_raw_read_unsigned (regcache
, S390_PSWA_REGNUM
, &psw
);
1406 val
= (psw
& 0x80000000) | (val
& 0x7fffffff);
1408 regcache_raw_write_unsigned (regcache
, S390_PSWA_REGNUM
, val
);
1412 if (regnum
== tdep
->cc_regnum
)
1414 val
= extract_unsigned_integer (buf
, regsize
, byte_order
);
1415 regcache_raw_read_unsigned (regcache
, S390_PSWM_REGNUM
, &psw
);
1416 if (register_size (gdbarch
, S390_PSWA_REGNUM
) == 4)
1417 val
= (psw
& ~((ULONGEST
)3 << 12)) | ((val
& 3) << 12);
1419 val
= (psw
& ~((ULONGEST
)3 << 44)) | ((val
& 3) << 44);
1420 regcache_raw_write_unsigned (regcache
, S390_PSWM_REGNUM
, val
);
1424 if (regnum_is_gpr_full (tdep
, regnum
))
1426 regnum
-= tdep
->gpr_full_regnum
;
1427 val
= extract_unsigned_integer (buf
, regsize
, byte_order
);
1428 regcache_raw_write_unsigned (regcache
, S390_R0_REGNUM
+ regnum
,
1430 regcache_raw_write_unsigned (regcache
, S390_R0_UPPER_REGNUM
+ regnum
,
1435 if (regnum_is_vxr_full (tdep
, regnum
))
1437 regnum
-= tdep
->v0_full_regnum
;
1438 regcache
->raw_write (S390_F0_REGNUM
+ regnum
, buf
);
1439 regcache
->raw_write (S390_V0_LOWER_REGNUM
+ regnum
, buf
+ 8);
1443 internal_error (__FILE__
, __LINE__
, _("invalid regnum"));
1446 /* Register groups. */
1448 /* Implement pseudo_register_reggroup_p tdesc method. */
1451 s390_pseudo_register_reggroup_p (struct gdbarch
*gdbarch
, int regnum
,
1452 struct reggroup
*group
)
1454 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1456 /* We usually save/restore the whole PSW, which includes PC and CC.
1457 However, some older gdbservers may not support saving/restoring
1458 the whole PSW yet, and will return an XML register description
1459 excluding those from the save/restore register groups. In those
1460 cases, we still need to explicitly save/restore PC and CC in order
1461 to push or pop frames. Since this doesn't hurt anything if we
1462 already save/restore the whole PSW (it's just redundant), we add
1463 PC and CC at this point unconditionally. */
1464 if (group
== save_reggroup
|| group
== restore_reggroup
)
1465 return regnum
== tdep
->pc_regnum
|| regnum
== tdep
->cc_regnum
;
1467 if (group
== vector_reggroup
)
1468 return regnum_is_vxr_full (tdep
, regnum
);
1470 if (group
== general_reggroup
&& regnum_is_vxr_full (tdep
, regnum
))
1473 return default_register_reggroup_p (gdbarch
, regnum
, group
);
1476 /* The "ax_pseudo_register_collect" gdbarch method. */
1479 s390_ax_pseudo_register_collect (struct gdbarch
*gdbarch
,
1480 struct agent_expr
*ax
, int regnum
)
1482 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1483 if (regnum
== tdep
->pc_regnum
)
1485 ax_reg_mask (ax
, S390_PSWA_REGNUM
);
1487 else if (regnum
== tdep
->cc_regnum
)
1489 ax_reg_mask (ax
, S390_PSWM_REGNUM
);
1491 else if (regnum_is_gpr_full (tdep
, regnum
))
1493 regnum
-= tdep
->gpr_full_regnum
;
1494 ax_reg_mask (ax
, S390_R0_REGNUM
+ regnum
);
1495 ax_reg_mask (ax
, S390_R0_UPPER_REGNUM
+ regnum
);
1497 else if (regnum_is_vxr_full (tdep
, regnum
))
1499 regnum
-= tdep
->v0_full_regnum
;
1500 ax_reg_mask (ax
, S390_F0_REGNUM
+ regnum
);
1501 ax_reg_mask (ax
, S390_V0_LOWER_REGNUM
+ regnum
);
1505 internal_error (__FILE__
, __LINE__
, _("invalid regnum"));
1510 /* The "ax_pseudo_register_push_stack" gdbarch method. */
1513 s390_ax_pseudo_register_push_stack (struct gdbarch
*gdbarch
,
1514 struct agent_expr
*ax
, int regnum
)
1516 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1517 if (regnum
== tdep
->pc_regnum
)
1519 ax_reg (ax
, S390_PSWA_REGNUM
);
1520 if (register_size (gdbarch
, S390_PSWA_REGNUM
) == 4)
1522 ax_zero_ext (ax
, 31);
1525 else if (regnum
== tdep
->cc_regnum
)
1527 ax_reg (ax
, S390_PSWM_REGNUM
);
1528 if (register_size (gdbarch
, S390_PSWA_REGNUM
) == 4)
1529 ax_const_l (ax
, 12);
1531 ax_const_l (ax
, 44);
1532 ax_simple (ax
, aop_rsh_unsigned
);
1533 ax_zero_ext (ax
, 2);
1535 else if (regnum_is_gpr_full (tdep
, regnum
))
1537 regnum
-= tdep
->gpr_full_regnum
;
1538 ax_reg (ax
, S390_R0_REGNUM
+ regnum
);
1539 ax_reg (ax
, S390_R0_UPPER_REGNUM
+ regnum
);
1540 ax_const_l (ax
, 32);
1541 ax_simple (ax
, aop_lsh
);
1542 ax_simple (ax
, aop_bit_or
);
1544 else if (regnum_is_vxr_full (tdep
, regnum
))
1546 /* Too large to stuff on the stack. */
1551 internal_error (__FILE__
, __LINE__
, _("invalid regnum"));
1556 /* The "gen_return_address" gdbarch method. Since this is supposed to be
1557 just a best-effort method, and we don't really have the means to run
1558 the full unwinder here, just collect the link register. */
1561 s390_gen_return_address (struct gdbarch
*gdbarch
,
1562 struct agent_expr
*ax
, struct axs_value
*value
,
1565 value
->type
= register_type (gdbarch
, S390_R14_REGNUM
);
1566 value
->kind
= axs_lvalue_register
;
1567 value
->u
.reg
= S390_R14_REGNUM
;
1570 /* Address handling. */
1572 /* Implement addr_bits_remove gdbarch method.
1573 Only used for ABI_LINUX_S390. */
1576 s390_addr_bits_remove (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1578 return addr
& 0x7fffffff;
1581 /* Implement addr_class_type_flags gdbarch method.
1582 Only used for ABI_LINUX_ZSERIES. */
1585 s390_address_class_type_flags (int byte_size
, int dwarf2_addr_class
)
1588 return TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1
;
1593 /* Implement addr_class_type_flags_to_name gdbarch method.
1594 Only used for ABI_LINUX_ZSERIES. */
1597 s390_address_class_type_flags_to_name (struct gdbarch
*gdbarch
, int type_flags
)
1599 if (type_flags
& TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1
)
1605 /* Implement addr_class_name_to_type_flags gdbarch method.
1606 Only used for ABI_LINUX_ZSERIES. */
1609 s390_address_class_name_to_type_flags (struct gdbarch
*gdbarch
,
1611 int *type_flags_ptr
)
1613 if (strcmp (name
, "mode32") == 0)
1615 *type_flags_ptr
= TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1
;
1622 /* Inferior function calls. */
1624 /* Dummy function calls. */
1626 /* Unwrap any single-field structs in TYPE and return the effective
1627 "inner" type. E.g., yield "float" for all these cases:
1631 struct { struct { float x; } x; };
1632 struct { struct { struct { float x; } x; } x; };
1634 However, if an inner type is smaller than MIN_SIZE, abort the
1637 static struct type
*
1638 s390_effective_inner_type (struct type
*type
, unsigned int min_size
)
1640 while (TYPE_CODE (type
) == TYPE_CODE_STRUCT
1641 && TYPE_NFIELDS (type
) == 1)
1643 struct type
*inner
= check_typedef (TYPE_FIELD_TYPE (type
, 0));
1645 if (TYPE_LENGTH (inner
) < min_size
)
1653 /* Return non-zero if TYPE should be passed like "float" or
1657 s390_function_arg_float (struct type
*type
)
1659 /* Note that long double as well as complex types are intentionally
1661 if (TYPE_LENGTH (type
) > 8)
1664 /* A struct containing just a float or double is passed like a float
1666 type
= s390_effective_inner_type (type
, 0);
1668 return (TYPE_CODE (type
) == TYPE_CODE_FLT
1669 || TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
);
1672 /* Return non-zero if TYPE should be passed like a vector. */
1675 s390_function_arg_vector (struct type
*type
)
1677 if (TYPE_LENGTH (type
) > 16)
1680 /* Structs containing just a vector are passed like a vector. */
1681 type
= s390_effective_inner_type (type
, TYPE_LENGTH (type
));
1683 return TYPE_CODE (type
) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (type
);
1686 /* Determine whether N is a power of two. */
1689 is_power_of_two (unsigned int n
)
1691 return n
&& ((n
& (n
- 1)) == 0);
1694 /* For an argument whose type is TYPE and which is not passed like a
1695 float or vector, return non-zero if it should be passed like "int"
1699 s390_function_arg_integer (struct type
*type
)
1701 enum type_code code
= TYPE_CODE (type
);
1703 if (TYPE_LENGTH (type
) > 8)
1706 if (code
== TYPE_CODE_INT
1707 || code
== TYPE_CODE_ENUM
1708 || code
== TYPE_CODE_RANGE
1709 || code
== TYPE_CODE_CHAR
1710 || code
== TYPE_CODE_BOOL
1711 || code
== TYPE_CODE_PTR
1712 || TYPE_IS_REFERENCE (type
))
1715 return ((code
== TYPE_CODE_UNION
|| code
== TYPE_CODE_STRUCT
)
1716 && is_power_of_two (TYPE_LENGTH (type
)));
1719 /* Argument passing state: Internal data structure passed to helper
1720 routines of s390_push_dummy_call. */
1722 struct s390_arg_state
1724 /* Register cache, or NULL, if we are in "preparation mode". */
1725 struct regcache
*regcache
;
1726 /* Next available general/floating-point/vector register for
1727 argument passing. */
1729 /* Current pointer to copy area (grows downwards). */
1731 /* Current pointer to parameter area (grows upwards). */
1735 /* Prepare one argument ARG for a dummy call and update the argument
1736 passing state AS accordingly. If the regcache field in AS is set,
1737 operate in "write mode" and write ARG into the inferior. Otherwise
1738 run "preparation mode" and skip all updates to the inferior. */
1741 s390_handle_arg (struct s390_arg_state
*as
, struct value
*arg
,
1742 struct gdbarch_tdep
*tdep
, int word_size
,
1743 enum bfd_endian byte_order
, int is_unnamed
)
1745 struct type
*type
= check_typedef (value_type (arg
));
1746 unsigned int length
= TYPE_LENGTH (type
);
1747 int write_mode
= as
->regcache
!= NULL
;
1749 if (s390_function_arg_float (type
))
1751 /* The GNU/Linux for S/390 ABI uses FPRs 0 and 2 to pass
1752 arguments. The GNU/Linux for zSeries ABI uses 0, 2, 4, and
1754 if (as
->fr
<= (tdep
->abi
== ABI_LINUX_S390
? 2 : 6))
1756 /* When we store a single-precision value in an FP register,
1757 it occupies the leftmost bits. */
1759 as
->regcache
->cooked_write_part (S390_F0_REGNUM
+ as
->fr
, 0, length
,
1760 value_contents (arg
));
1765 /* When we store a single-precision value in a stack slot,
1766 it occupies the rightmost bits. */
1767 as
->argp
= align_up (as
->argp
+ length
, word_size
);
1769 write_memory (as
->argp
- length
, value_contents (arg
),
1773 else if (tdep
->vector_abi
== S390_VECTOR_ABI_128
1774 && s390_function_arg_vector (type
))
1776 static const char use_vr
[] = {24, 26, 28, 30, 25, 27, 29, 31};
1778 if (!is_unnamed
&& as
->vr
< ARRAY_SIZE (use_vr
))
1780 int regnum
= S390_V24_REGNUM
+ use_vr
[as
->vr
] - 24;
1783 as
->regcache
->cooked_write_part (regnum
, 0, length
,
1784 value_contents (arg
));
1790 write_memory (as
->argp
, value_contents (arg
), length
);
1791 as
->argp
= align_up (as
->argp
+ length
, word_size
);
1794 else if (s390_function_arg_integer (type
) && length
<= word_size
)
1796 /* Initialize it just to avoid a GCC false warning. */
1801 /* Place value in least significant bits of the register or
1802 memory word and sign- or zero-extend to full word size.
1803 This also applies to a struct or union. */
1804 val
= TYPE_UNSIGNED (type
)
1805 ? extract_unsigned_integer (value_contents (arg
),
1807 : extract_signed_integer (value_contents (arg
),
1808 length
, byte_order
);
1814 regcache_cooked_write_unsigned (as
->regcache
,
1815 S390_R0_REGNUM
+ as
->gr
,
1822 write_memory_unsigned_integer (as
->argp
, word_size
,
1824 as
->argp
+= word_size
;
1827 else if (s390_function_arg_integer (type
) && length
== 8)
1833 as
->regcache
->cooked_write (S390_R0_REGNUM
+ as
->gr
,
1834 value_contents (arg
));
1835 as
->regcache
->cooked_write (S390_R0_REGNUM
+ as
->gr
+ 1,
1836 value_contents (arg
) + word_size
);
1842 /* If we skipped r6 because we couldn't fit a DOUBLE_ARG
1843 in it, then don't go back and use it again later. */
1847 write_memory (as
->argp
, value_contents (arg
), length
);
1853 /* This argument type is never passed in registers. Place the
1854 value in the copy area and pass a pointer to it. Use 8-byte
1855 alignment as a conservative assumption. */
1856 as
->copy
= align_down (as
->copy
- length
, 8);
1858 write_memory (as
->copy
, value_contents (arg
), length
);
1863 regcache_cooked_write_unsigned (as
->regcache
,
1864 S390_R0_REGNUM
+ as
->gr
,
1871 write_memory_unsigned_integer (as
->argp
, word_size
,
1872 byte_order
, as
->copy
);
1873 as
->argp
+= word_size
;
1878 /* Put the actual parameter values pointed to by ARGS[0..NARGS-1] in
1879 place to be passed to a function, as specified by the "GNU/Linux
1880 for S/390 ELF Application Binary Interface Supplement".
1882 SP is the current stack pointer. We must put arguments, links,
1883 padding, etc. whereever they belong, and return the new stack
1886 If STRUCT_RETURN is non-zero, then the function we're calling is
1887 going to return a structure by value; STRUCT_ADDR is the address of
1888 a block we've allocated for it on the stack.
1890 Our caller has taken care of any type promotions needed to satisfy
1891 prototypes or the old K&R argument-passing rules. */
1894 s390_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
1895 struct regcache
*regcache
, CORE_ADDR bp_addr
,
1896 int nargs
, struct value
**args
, CORE_ADDR sp
,
1897 function_call_return_method return_method
,
1898 CORE_ADDR struct_addr
)
1900 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1901 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
1902 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1904 struct s390_arg_state arg_state
, arg_prep
;
1905 CORE_ADDR param_area_start
, new_sp
;
1906 struct type
*ftype
= check_typedef (value_type (function
));
1908 if (TYPE_CODE (ftype
) == TYPE_CODE_PTR
)
1909 ftype
= check_typedef (TYPE_TARGET_TYPE (ftype
));
1912 arg_prep
.gr
= (return_method
== return_method_struct
) ? 3 : 2;
1916 arg_prep
.regcache
= NULL
;
1918 /* Initialize arg_state for "preparation mode". */
1919 arg_state
= arg_prep
;
1921 /* Update arg_state.copy with the start of the reference-to-copy area
1922 and arg_state.argp with the size of the parameter area. */
1923 for (i
= 0; i
< nargs
; i
++)
1924 s390_handle_arg (&arg_state
, args
[i
], tdep
, word_size
, byte_order
,
1925 TYPE_VARARGS (ftype
) && i
>= TYPE_NFIELDS (ftype
));
1927 param_area_start
= align_down (arg_state
.copy
- arg_state
.argp
, 8);
1929 /* Allocate the standard frame areas: the register save area, the
1930 word reserved for the compiler, and the back chain pointer. */
1931 new_sp
= param_area_start
- (16 * word_size
+ 32);
1933 /* Now we have the final stack pointer. Make sure we didn't
1934 underflow; on 31-bit, this would result in addresses with the
1935 high bit set, which causes confusion elsewhere. Note that if we
1936 error out here, stack and registers remain untouched. */
1937 if (gdbarch_addr_bits_remove (gdbarch
, new_sp
) != new_sp
)
1938 error (_("Stack overflow"));
1940 /* Pass the structure return address in general register 2. */
1941 if (return_method
== return_method_struct
)
1942 regcache_cooked_write_unsigned (regcache
, S390_R2_REGNUM
, struct_addr
);
1944 /* Initialize arg_state for "write mode". */
1945 arg_state
= arg_prep
;
1946 arg_state
.argp
= param_area_start
;
1947 arg_state
.regcache
= regcache
;
1949 /* Write all parameters. */
1950 for (i
= 0; i
< nargs
; i
++)
1951 s390_handle_arg (&arg_state
, args
[i
], tdep
, word_size
, byte_order
,
1952 TYPE_VARARGS (ftype
) && i
>= TYPE_NFIELDS (ftype
));
1954 /* Store return PSWA. In 31-bit mode, keep addressing mode bit. */
1958 regcache_cooked_read_unsigned (regcache
, S390_PSWA_REGNUM
, &pswa
);
1959 bp_addr
= (bp_addr
& 0x7fffffff) | (pswa
& 0x80000000);
1961 regcache_cooked_write_unsigned (regcache
, S390_RETADDR_REGNUM
, bp_addr
);
1963 /* Store updated stack pointer. */
1964 regcache_cooked_write_unsigned (regcache
, S390_SP_REGNUM
, new_sp
);
1966 /* We need to return the 'stack part' of the frame ID,
1967 which is actually the top of the register save area. */
1968 return param_area_start
;
1971 /* Assuming THIS_FRAME is a dummy, return the frame ID of that
1972 dummy frame. The frame ID's base needs to match the TOS value
1973 returned by push_dummy_call, and the PC match the dummy frame's
1976 static struct frame_id
1977 s390_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*this_frame
)
1979 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
1980 CORE_ADDR sp
= get_frame_register_unsigned (this_frame
, S390_SP_REGNUM
);
1981 sp
= gdbarch_addr_bits_remove (gdbarch
, sp
);
1983 return frame_id_build (sp
+ 16*word_size
+ 32,
1984 get_frame_pc (this_frame
));
1987 /* Implement frame_align gdbarch method. */
1990 s390_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1992 /* Both the 32- and 64-bit ABI's say that the stack pointer should
1993 always be aligned on an eight-byte boundary. */
1997 /* Helper for s390_return_value: Set or retrieve a function return
1998 value if it resides in a register. */
2001 s390_register_return_value (struct gdbarch
*gdbarch
, struct type
*type
,
2002 struct regcache
*regcache
,
2003 gdb_byte
*out
, const gdb_byte
*in
)
2005 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2006 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
2007 int length
= TYPE_LENGTH (type
);
2008 int code
= TYPE_CODE (type
);
2010 if (code
== TYPE_CODE_FLT
|| code
== TYPE_CODE_DECFLOAT
)
2012 /* Float-like value: left-aligned in f0. */
2014 regcache
->cooked_write_part (S390_F0_REGNUM
, 0, length
, in
);
2016 regcache
->cooked_read_part (S390_F0_REGNUM
, 0, length
, out
);
2018 else if (code
== TYPE_CODE_ARRAY
)
2020 /* Vector: left-aligned in v24. */
2022 regcache
->cooked_write_part (S390_V24_REGNUM
, 0, length
, in
);
2024 regcache
->cooked_read_part (S390_V24_REGNUM
, 0, length
, out
);
2026 else if (length
<= word_size
)
2028 /* Integer: zero- or sign-extended in r2. */
2030 regcache
->cooked_read_part (S390_R2_REGNUM
, word_size
- length
, length
,
2032 else if (TYPE_UNSIGNED (type
))
2033 regcache_cooked_write_unsigned
2034 (regcache
, S390_R2_REGNUM
,
2035 extract_unsigned_integer (in
, length
, byte_order
));
2037 regcache_cooked_write_signed
2038 (regcache
, S390_R2_REGNUM
,
2039 extract_signed_integer (in
, length
, byte_order
));
2041 else if (length
== 2 * word_size
)
2043 /* Double word: in r2 and r3. */
2046 regcache
->cooked_write (S390_R2_REGNUM
, in
);
2047 regcache
->cooked_write (S390_R3_REGNUM
, in
+ word_size
);
2051 regcache
->cooked_read (S390_R2_REGNUM
, out
);
2052 regcache
->cooked_read (S390_R3_REGNUM
, out
+ word_size
);
2056 internal_error (__FILE__
, __LINE__
, _("invalid return type"));
2059 /* Implement the 'return_value' gdbarch method. */
2061 static enum return_value_convention
2062 s390_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
2063 struct type
*type
, struct regcache
*regcache
,
2064 gdb_byte
*out
, const gdb_byte
*in
)
2066 enum return_value_convention rvc
;
2068 type
= check_typedef (type
);
2070 switch (TYPE_CODE (type
))
2072 case TYPE_CODE_STRUCT
:
2073 case TYPE_CODE_UNION
:
2074 case TYPE_CODE_COMPLEX
:
2075 rvc
= RETURN_VALUE_STRUCT_CONVENTION
;
2077 case TYPE_CODE_ARRAY
:
2078 rvc
= (gdbarch_tdep (gdbarch
)->vector_abi
== S390_VECTOR_ABI_128
2079 && TYPE_LENGTH (type
) <= 16 && TYPE_VECTOR (type
))
2080 ? RETURN_VALUE_REGISTER_CONVENTION
2081 : RETURN_VALUE_STRUCT_CONVENTION
;
2084 rvc
= TYPE_LENGTH (type
) <= 8
2085 ? RETURN_VALUE_REGISTER_CONVENTION
2086 : RETURN_VALUE_STRUCT_CONVENTION
;
2089 if (in
!= NULL
|| out
!= NULL
)
2091 if (rvc
== RETURN_VALUE_REGISTER_CONVENTION
)
2092 s390_register_return_value (gdbarch
, type
, regcache
, out
, in
);
2093 else if (in
!= NULL
)
2094 error (_("Cannot set function return value."));
2096 error (_("Function return value unknown."));
2102 /* Frame unwinding. */
2104 /* Implmement the stack_frame_destroyed_p gdbarch method. */
2107 s390_stack_frame_destroyed_p (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
2109 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
2111 /* In frameless functions, there's no frame to destroy and thus
2112 we don't care about the epilogue.
2114 In functions with frame, the epilogue sequence is a pair of
2115 a LM-type instruction that restores (amongst others) the
2116 return register %r14 and the stack pointer %r15, followed
2117 by a branch 'br %r14' --or equivalent-- that effects the
2120 In that situation, this function needs to return 'true' in
2121 exactly one case: when pc points to that branch instruction.
2123 Thus we try to disassemble the one instructions immediately
2124 preceding pc and check whether it is an LM-type instruction
2125 modifying the stack pointer.
2127 Note that disassembling backwards is not reliable, so there
2128 is a slight chance of false positives here ... */
2131 unsigned int r1
, r3
, b2
;
2135 && !target_read_memory (pc
- 4, insn
, 4)
2136 && is_rs (insn
, op_lm
, &r1
, &r3
, &d2
, &b2
)
2137 && r3
== S390_SP_REGNUM
- S390_R0_REGNUM
)
2141 && !target_read_memory (pc
- 6, insn
, 6)
2142 && is_rsy (insn
, op1_lmy
, op2_lmy
, &r1
, &r3
, &d2
, &b2
)
2143 && r3
== S390_SP_REGNUM
- S390_R0_REGNUM
)
2147 && !target_read_memory (pc
- 6, insn
, 6)
2148 && is_rsy (insn
, op1_lmg
, op2_lmg
, &r1
, &r3
, &d2
, &b2
)
2149 && r3
== S390_SP_REGNUM
- S390_R0_REGNUM
)
2155 /* Implement unwind_pc gdbarch method. */
2158 s390_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2160 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2162 pc
= frame_unwind_register_unsigned (next_frame
, tdep
->pc_regnum
);
2163 return gdbarch_addr_bits_remove (gdbarch
, pc
);
2166 /* Implement unwind_sp gdbarch method. */
2169 s390_unwind_sp (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2172 sp
= frame_unwind_register_unsigned (next_frame
, S390_SP_REGNUM
);
2173 return gdbarch_addr_bits_remove (gdbarch
, sp
);
2176 /* Helper routine to unwind pseudo registers. */
2178 static struct value
*
2179 s390_unwind_pseudo_register (struct frame_info
*this_frame
, int regnum
)
2181 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2182 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2183 struct type
*type
= register_type (gdbarch
, regnum
);
2185 /* Unwind PC via PSW address. */
2186 if (regnum
== tdep
->pc_regnum
)
2190 val
= frame_unwind_register_value (this_frame
, S390_PSWA_REGNUM
);
2191 if (!value_optimized_out (val
))
2193 LONGEST pswa
= value_as_long (val
);
2195 if (TYPE_LENGTH (type
) == 4)
2196 return value_from_pointer (type
, pswa
& 0x7fffffff);
2198 return value_from_pointer (type
, pswa
);
2202 /* Unwind CC via PSW mask. */
2203 if (regnum
== tdep
->cc_regnum
)
2207 val
= frame_unwind_register_value (this_frame
, S390_PSWM_REGNUM
);
2208 if (!value_optimized_out (val
))
2210 LONGEST pswm
= value_as_long (val
);
2212 if (TYPE_LENGTH (type
) == 4)
2213 return value_from_longest (type
, (pswm
>> 12) & 3);
2215 return value_from_longest (type
, (pswm
>> 44) & 3);
2219 /* Unwind full GPRs to show at least the lower halves (as the
2220 upper halves are undefined). */
2221 if (regnum_is_gpr_full (tdep
, regnum
))
2223 int reg
= regnum
- tdep
->gpr_full_regnum
;
2226 val
= frame_unwind_register_value (this_frame
, S390_R0_REGNUM
+ reg
);
2227 if (!value_optimized_out (val
))
2228 return value_cast (type
, val
);
2231 return allocate_optimized_out_value (type
);
2234 /* Translate a .eh_frame register to DWARF register, or adjust a
2235 .debug_frame register. */
2238 s390_adjust_frame_regnum (struct gdbarch
*gdbarch
, int num
, int eh_frame_p
)
2240 /* See s390_dwarf_reg_to_regnum for comments. */
2241 return (num
>= 0 && num
< 16) ? num
+ s390_dwarf_reg_r0l
: num
;
2244 /* DWARF-2 frame unwinding. */
2246 /* Function to unwind a pseudo-register in dwarf2_frame unwinder. Used by
2247 s390_dwarf2_frame_init_reg. */
2249 static struct value
*
2250 s390_dwarf2_prev_register (struct frame_info
*this_frame
, void **this_cache
,
2253 return s390_unwind_pseudo_register (this_frame
, regnum
);
2256 /* Implement init_reg dwarf2_frame method. */
2259 s390_dwarf2_frame_init_reg (struct gdbarch
*gdbarch
, int regnum
,
2260 struct dwarf2_frame_state_reg
*reg
,
2261 struct frame_info
*this_frame
)
2263 /* The condition code (and thus PSW mask) is call-clobbered. */
2264 if (regnum
== S390_PSWM_REGNUM
)
2265 reg
->how
= DWARF2_FRAME_REG_UNDEFINED
;
2267 /* The PSW address unwinds to the return address. */
2268 else if (regnum
== S390_PSWA_REGNUM
)
2269 reg
->how
= DWARF2_FRAME_REG_RA
;
2271 /* Fixed registers are call-saved or call-clobbered
2272 depending on the ABI in use. */
2273 else if (regnum
< S390_NUM_REGS
)
2275 if (s390_register_call_saved (gdbarch
, regnum
))
2276 reg
->how
= DWARF2_FRAME_REG_SAME_VALUE
;
2278 reg
->how
= DWARF2_FRAME_REG_UNDEFINED
;
2281 /* We install a special function to unwind pseudos. */
2284 reg
->how
= DWARF2_FRAME_REG_FN
;
2285 reg
->loc
.fn
= s390_dwarf2_prev_register
;
2289 /* Frame unwinding. */
2291 /* Wrapper for trad_frame_get_prev_register to allow for s390 pseudo
2292 register translation. */
2295 s390_trad_frame_prev_register (struct frame_info
*this_frame
,
2296 struct trad_frame_saved_reg saved_regs
[],
2299 if (regnum
< S390_NUM_REGS
)
2300 return trad_frame_get_prev_register (this_frame
, saved_regs
, regnum
);
2302 return s390_unwind_pseudo_register (this_frame
, regnum
);
2305 /* Normal stack frames. */
2307 struct s390_unwind_cache
{
2310 CORE_ADDR frame_base
;
2311 CORE_ADDR local_base
;
2313 struct trad_frame_saved_reg
*saved_regs
;
2316 /* Unwind THIS_FRAME and write the information into unwind cache INFO using
2317 prologue analysis. Helper for s390_frame_unwind_cache. */
2320 s390_prologue_frame_unwind_cache (struct frame_info
*this_frame
,
2321 struct s390_unwind_cache
*info
)
2323 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2324 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
2325 struct s390_prologue_data data
;
2326 pv_t
*fp
= &data
.gpr
[S390_FRAME_REGNUM
- S390_R0_REGNUM
];
2327 pv_t
*sp
= &data
.gpr
[S390_SP_REGNUM
- S390_R0_REGNUM
];
2336 struct frame_info
*next_frame
;
2338 /* Try to find the function start address. If we can't find it, we don't
2339 bother searching for it -- with modern compilers this would be mostly
2340 pointless anyway. Trust that we'll either have valid DWARF-2 CFI data
2341 or else a valid backchain ... */
2342 if (!get_frame_func_if_available (this_frame
, &info
->func
))
2349 /* Try to analyze the prologue. */
2350 result
= s390_analyze_prologue (gdbarch
, func
,
2351 get_frame_pc (this_frame
), &data
);
2355 /* If this was successful, we should have found the instruction that
2356 sets the stack pointer register to the previous value of the stack
2357 pointer minus the frame size. */
2358 if (!pv_is_register (*sp
, S390_SP_REGNUM
))
2361 /* A frame size of zero at this point can mean either a real
2362 frameless function, or else a failure to find the prologue.
2363 Perform some sanity checks to verify we really have a
2364 frameless function. */
2367 /* If the next frame is a NORMAL_FRAME, this frame *cannot* have frame
2368 size zero. This is only possible if the next frame is a sentinel
2369 frame, a dummy frame, or a signal trampoline frame. */
2370 /* FIXME: cagney/2004-05-01: This sanity check shouldn't be
2371 needed, instead the code should simpliy rely on its
2373 next_frame
= get_next_frame (this_frame
);
2374 while (next_frame
&& get_frame_type (next_frame
) == INLINE_FRAME
)
2375 next_frame
= get_next_frame (next_frame
);
2377 && get_frame_type (get_next_frame (this_frame
)) == NORMAL_FRAME
)
2380 /* If we really have a frameless function, %r14 must be valid
2381 -- in particular, it must point to a different function. */
2382 reg
= get_frame_register_unsigned (this_frame
, S390_RETADDR_REGNUM
);
2383 reg
= gdbarch_addr_bits_remove (gdbarch
, reg
) - 1;
2384 if (get_pc_function_start (reg
) == func
)
2386 /* However, there is one case where it *is* valid for %r14
2387 to point to the same function -- if this is a recursive
2388 call, and we have stopped in the prologue *before* the
2389 stack frame was allocated.
2391 Recognize this case by looking ahead a bit ... */
2393 struct s390_prologue_data data2
;
2394 pv_t
*sp2
= &data2
.gpr
[S390_SP_REGNUM
- S390_R0_REGNUM
];
2396 if (!(s390_analyze_prologue (gdbarch
, func
, (CORE_ADDR
)-1, &data2
)
2397 && pv_is_register (*sp2
, S390_SP_REGNUM
)
2403 /* OK, we've found valid prologue data. */
2406 /* If the frame pointer originally also holds the same value
2407 as the stack pointer, we're probably using it. If it holds
2408 some other value -- even a constant offset -- it is most
2409 likely used as temp register. */
2410 if (pv_is_identical (*sp
, *fp
))
2411 frame_pointer
= S390_FRAME_REGNUM
;
2413 frame_pointer
= S390_SP_REGNUM
;
2415 /* If we've detected a function with stack frame, we'll still have to
2416 treat it as frameless if we're currently within the function epilog
2417 code at a point where the frame pointer has already been restored.
2418 This can only happen in an innermost frame. */
2419 /* FIXME: cagney/2004-05-01: This sanity check shouldn't be needed,
2420 instead the code should simpliy rely on its analysis. */
2421 next_frame
= get_next_frame (this_frame
);
2422 while (next_frame
&& get_frame_type (next_frame
) == INLINE_FRAME
)
2423 next_frame
= get_next_frame (next_frame
);
2425 && (next_frame
== NULL
2426 || get_frame_type (get_next_frame (this_frame
)) != NORMAL_FRAME
))
2428 /* See the comment in s390_stack_frame_destroyed_p on why this is
2429 not completely reliable ... */
2430 if (s390_stack_frame_destroyed_p (gdbarch
, get_frame_pc (this_frame
)))
2432 memset (&data
, 0, sizeof (data
));
2434 frame_pointer
= S390_SP_REGNUM
;
2438 /* Once we know the frame register and the frame size, we can unwind
2439 the current value of the frame register from the next frame, and
2440 add back the frame size to arrive that the previous frame's
2441 stack pointer value. */
2442 prev_sp
= get_frame_register_unsigned (this_frame
, frame_pointer
) + size
;
2443 cfa
= prev_sp
+ 16*word_size
+ 32;
2445 /* Set up ABI call-saved/call-clobbered registers. */
2446 for (i
= 0; i
< S390_NUM_REGS
; i
++)
2447 if (!s390_register_call_saved (gdbarch
, i
))
2448 trad_frame_set_unknown (info
->saved_regs
, i
);
2450 /* CC is always call-clobbered. */
2451 trad_frame_set_unknown (info
->saved_regs
, S390_PSWM_REGNUM
);
2453 /* Record the addresses of all register spill slots the prologue parser
2454 has recognized. Consider only registers defined as call-saved by the
2455 ABI; for call-clobbered registers the parser may have recognized
2458 for (i
= 0; i
< 16; i
++)
2459 if (s390_register_call_saved (gdbarch
, S390_R0_REGNUM
+ i
)
2460 && data
.gpr_slot
[i
] != 0)
2461 info
->saved_regs
[S390_R0_REGNUM
+ i
].addr
= cfa
- data
.gpr_slot
[i
];
2463 for (i
= 0; i
< 16; i
++)
2464 if (s390_register_call_saved (gdbarch
, S390_F0_REGNUM
+ i
)
2465 && data
.fpr_slot
[i
] != 0)
2466 info
->saved_regs
[S390_F0_REGNUM
+ i
].addr
= cfa
- data
.fpr_slot
[i
];
2468 /* Function return will set PC to %r14. */
2469 info
->saved_regs
[S390_PSWA_REGNUM
] = info
->saved_regs
[S390_RETADDR_REGNUM
];
2471 /* In frameless functions, we unwind simply by moving the return
2472 address to the PC. However, if we actually stored to the
2473 save area, use that -- we might only think the function frameless
2474 because we're in the middle of the prologue ... */
2476 && !trad_frame_addr_p (info
->saved_regs
, S390_PSWA_REGNUM
))
2478 info
->saved_regs
[S390_PSWA_REGNUM
].realreg
= S390_RETADDR_REGNUM
;
2481 /* Another sanity check: unless this is a frameless function,
2482 we should have found spill slots for SP and PC.
2483 If not, we cannot unwind further -- this happens e.g. in
2484 libc's thread_start routine. */
2487 if (!trad_frame_addr_p (info
->saved_regs
, S390_SP_REGNUM
)
2488 || !trad_frame_addr_p (info
->saved_regs
, S390_PSWA_REGNUM
))
2492 /* We use the current value of the frame register as local_base,
2493 and the top of the register save area as frame_base. */
2496 info
->frame_base
= prev_sp
+ 16*word_size
+ 32;
2497 info
->local_base
= prev_sp
- size
;
2503 /* Unwind THIS_FRAME and write the information into unwind cache INFO using
2504 back chain unwinding. Helper for s390_frame_unwind_cache. */
2507 s390_backchain_frame_unwind_cache (struct frame_info
*this_frame
,
2508 struct s390_unwind_cache
*info
)
2510 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2511 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
2512 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2513 CORE_ADDR backchain
;
2518 /* Set up ABI call-saved/call-clobbered registers. */
2519 for (i
= 0; i
< S390_NUM_REGS
; i
++)
2520 if (!s390_register_call_saved (gdbarch
, i
))
2521 trad_frame_set_unknown (info
->saved_regs
, i
);
2523 /* CC is always call-clobbered. */
2524 trad_frame_set_unknown (info
->saved_regs
, S390_PSWM_REGNUM
);
2526 /* Get the backchain. */
2527 reg
= get_frame_register_unsigned (this_frame
, S390_SP_REGNUM
);
2528 if (!safe_read_memory_integer (reg
, word_size
, byte_order
, &tmp
))
2530 backchain
= (CORE_ADDR
) tmp
;
2532 /* A zero backchain terminates the frame chain. As additional
2533 sanity check, let's verify that the spill slot for SP in the
2534 save area pointed to by the backchain in fact links back to
2537 && safe_read_memory_integer (backchain
+ 15*word_size
,
2538 word_size
, byte_order
, &sp
)
2539 && (CORE_ADDR
)sp
== backchain
)
2541 /* We don't know which registers were saved, but it will have
2542 to be at least %r14 and %r15. This will allow us to continue
2543 unwinding, but other prev-frame registers may be incorrect ... */
2544 info
->saved_regs
[S390_SP_REGNUM
].addr
= backchain
+ 15*word_size
;
2545 info
->saved_regs
[S390_RETADDR_REGNUM
].addr
= backchain
+ 14*word_size
;
2547 /* Function return will set PC to %r14. */
2548 info
->saved_regs
[S390_PSWA_REGNUM
]
2549 = info
->saved_regs
[S390_RETADDR_REGNUM
];
2551 /* We use the current value of the frame register as local_base,
2552 and the top of the register save area as frame_base. */
2553 info
->frame_base
= backchain
+ 16*word_size
+ 32;
2554 info
->local_base
= reg
;
2557 info
->func
= get_frame_pc (this_frame
);
2560 /* Unwind THIS_FRAME and return the corresponding unwind cache for
2561 s390_frame_unwind and s390_frame_base. */
2563 static struct s390_unwind_cache
*
2564 s390_frame_unwind_cache (struct frame_info
*this_frame
,
2565 void **this_prologue_cache
)
2567 struct s390_unwind_cache
*info
;
2569 if (*this_prologue_cache
)
2570 return (struct s390_unwind_cache
*) *this_prologue_cache
;
2572 info
= FRAME_OBSTACK_ZALLOC (struct s390_unwind_cache
);
2573 *this_prologue_cache
= info
;
2574 info
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
2576 info
->frame_base
= -1;
2577 info
->local_base
= -1;
2581 /* Try to use prologue analysis to fill the unwind cache.
2582 If this fails, fall back to reading the stack backchain. */
2583 if (!s390_prologue_frame_unwind_cache (this_frame
, info
))
2584 s390_backchain_frame_unwind_cache (this_frame
, info
);
2586 catch (const gdb_exception_error
&ex
)
2588 if (ex
.error
!= NOT_AVAILABLE_ERROR
)
2595 /* Implement this_id frame_unwind method for s390_frame_unwind. */
2598 s390_frame_this_id (struct frame_info
*this_frame
,
2599 void **this_prologue_cache
,
2600 struct frame_id
*this_id
)
2602 struct s390_unwind_cache
*info
2603 = s390_frame_unwind_cache (this_frame
, this_prologue_cache
);
2605 if (info
->frame_base
== -1)
2607 if (info
->func
!= -1)
2608 *this_id
= frame_id_build_unavailable_stack (info
->func
);
2612 *this_id
= frame_id_build (info
->frame_base
, info
->func
);
2615 /* Implement prev_register frame_unwind method for s390_frame_unwind. */
2617 static struct value
*
2618 s390_frame_prev_register (struct frame_info
*this_frame
,
2619 void **this_prologue_cache
, int regnum
)
2621 struct s390_unwind_cache
*info
2622 = s390_frame_unwind_cache (this_frame
, this_prologue_cache
);
2624 return s390_trad_frame_prev_register (this_frame
, info
->saved_regs
, regnum
);
2627 /* Default S390 frame unwinder. */
2629 static const struct frame_unwind s390_frame_unwind
= {
2631 default_frame_unwind_stop_reason
,
2633 s390_frame_prev_register
,
2635 default_frame_sniffer
2638 /* Code stubs and their stack frames. For things like PLTs and NULL
2639 function calls (where there is no true frame and the return address
2640 is in the RETADDR register). */
2642 struct s390_stub_unwind_cache
2644 CORE_ADDR frame_base
;
2645 struct trad_frame_saved_reg
*saved_regs
;
2648 /* Unwind THIS_FRAME and return the corresponding unwind cache for
2649 s390_stub_frame_unwind. */
2651 static struct s390_stub_unwind_cache
*
2652 s390_stub_frame_unwind_cache (struct frame_info
*this_frame
,
2653 void **this_prologue_cache
)
2655 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2656 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
2657 struct s390_stub_unwind_cache
*info
;
2660 if (*this_prologue_cache
)
2661 return (struct s390_stub_unwind_cache
*) *this_prologue_cache
;
2663 info
= FRAME_OBSTACK_ZALLOC (struct s390_stub_unwind_cache
);
2664 *this_prologue_cache
= info
;
2665 info
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
2667 /* The return address is in register %r14. */
2668 info
->saved_regs
[S390_PSWA_REGNUM
].realreg
= S390_RETADDR_REGNUM
;
2670 /* Retrieve stack pointer and determine our frame base. */
2671 reg
= get_frame_register_unsigned (this_frame
, S390_SP_REGNUM
);
2672 info
->frame_base
= reg
+ 16*word_size
+ 32;
2677 /* Implement this_id frame_unwind method for s390_stub_frame_unwind. */
2680 s390_stub_frame_this_id (struct frame_info
*this_frame
,
2681 void **this_prologue_cache
,
2682 struct frame_id
*this_id
)
2684 struct s390_stub_unwind_cache
*info
2685 = s390_stub_frame_unwind_cache (this_frame
, this_prologue_cache
);
2686 *this_id
= frame_id_build (info
->frame_base
, get_frame_pc (this_frame
));
2689 /* Implement prev_register frame_unwind method for s390_stub_frame_unwind. */
2691 static struct value
*
2692 s390_stub_frame_prev_register (struct frame_info
*this_frame
,
2693 void **this_prologue_cache
, int regnum
)
2695 struct s390_stub_unwind_cache
*info
2696 = s390_stub_frame_unwind_cache (this_frame
, this_prologue_cache
);
2697 return s390_trad_frame_prev_register (this_frame
, info
->saved_regs
, regnum
);
2700 /* Implement sniffer frame_unwind method for s390_stub_frame_unwind. */
2703 s390_stub_frame_sniffer (const struct frame_unwind
*self
,
2704 struct frame_info
*this_frame
,
2705 void **this_prologue_cache
)
2707 CORE_ADDR addr_in_block
;
2708 bfd_byte insn
[S390_MAX_INSTR_SIZE
];
2710 /* If the current PC points to non-readable memory, we assume we
2711 have trapped due to an invalid function pointer call. We handle
2712 the non-existing current function like a PLT stub. */
2713 addr_in_block
= get_frame_address_in_block (this_frame
);
2714 if (in_plt_section (addr_in_block
)
2715 || s390_readinstruction (insn
, get_frame_pc (this_frame
)) < 0)
2720 /* S390 stub frame unwinder. */
2722 static const struct frame_unwind s390_stub_frame_unwind
= {
2724 default_frame_unwind_stop_reason
,
2725 s390_stub_frame_this_id
,
2726 s390_stub_frame_prev_register
,
2728 s390_stub_frame_sniffer
2731 /* Frame base handling. */
2734 s390_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
2736 struct s390_unwind_cache
*info
2737 = s390_frame_unwind_cache (this_frame
, this_cache
);
2738 return info
->frame_base
;
2742 s390_local_base_address (struct frame_info
*this_frame
, void **this_cache
)
2744 struct s390_unwind_cache
*info
2745 = s390_frame_unwind_cache (this_frame
, this_cache
);
2746 return info
->local_base
;
2749 static const struct frame_base s390_frame_base
= {
2751 s390_frame_base_address
,
2752 s390_local_base_address
,
2753 s390_local_base_address
2756 /* Process record-replay */
2758 /* Takes the intermediate sum of address calculations and masks off upper
2759 bits according to current addressing mode. */
2762 s390_record_address_mask (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
2765 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2766 ULONGEST pswm
, pswa
;
2768 if (tdep
->abi
== ABI_LINUX_S390
)
2770 regcache_raw_read_unsigned (regcache
, S390_PSWA_REGNUM
, &pswa
);
2771 am
= pswa
>> 31 & 1;
2775 regcache_raw_read_unsigned (regcache
, S390_PSWM_REGNUM
, &pswm
);
2776 am
= pswm
>> 31 & 3;
2781 return val
& 0xffffff;
2783 return val
& 0x7fffffff;
2787 fprintf_unfiltered (gdb_stdlog
, "Warning: Addressing mode %d used.", am
);
2792 /* Calculates memory address using pre-calculated index, raw instruction word
2793 with b and d/dl fields, and raw instruction byte with dh field. Index and
2794 dh should be set to 0 if unused. */
2797 s390_record_calc_disp_common (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
2798 ULONGEST x
, uint16_t bd
, int8_t dh
)
2800 uint8_t rb
= bd
>> 12 & 0xf;
2801 int32_t d
= (bd
& 0xfff) | ((int32_t)dh
<< 12);
2803 CORE_ADDR res
= d
+ x
;
2806 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ rb
, &b
);
2809 return s390_record_address_mask (gdbarch
, regcache
, res
);
2812 /* Calculates memory address using raw x, b + d/dl, dh fields from
2813 instruction. rx and dh should be set to 0 if unused. */
2816 s390_record_calc_disp (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
2817 uint8_t rx
, uint16_t bd
, int8_t dh
)
2821 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ rx
, &x
);
2822 return s390_record_calc_disp_common (gdbarch
, regcache
, x
, bd
, dh
);
2825 /* Calculates memory address for VSCE[GF] instructions. */
2828 s390_record_calc_disp_vsce (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
2829 uint8_t vx
, uint8_t el
, uint8_t es
, uint16_t bd
,
2830 int8_t dh
, CORE_ADDR
*res
)
2832 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2833 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2836 if (tdep
->v0_full_regnum
== -1 || el
* es
>= 16)
2839 regcache
->cooked_read (tdep
->v0_full_regnum
+ vx
, buf
);
2841 regcache
->raw_read (S390_V16_REGNUM
+ vx
- 16, buf
);
2842 x
= extract_unsigned_integer (buf
+ el
* es
, es
, byte_order
);
2843 *res
= s390_record_calc_disp_common (gdbarch
, regcache
, x
, bd
, dh
);
2847 /* Calculates memory address for instructions with relative long addressing. */
2850 s390_record_calc_rl (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
2851 CORE_ADDR addr
, uint16_t i1
, uint16_t i2
)
2853 int32_t ri
= i1
<< 16 | i2
;
2854 return s390_record_address_mask (gdbarch
, regcache
, addr
+ (LONGEST
)ri
* 2);
2857 /* Population count helper. */
2859 static int s390_popcnt (unsigned int x
) {
2870 /* Record 64-bit register. */
2873 s390_record_gpr_g (struct gdbarch
*gdbarch
, struct regcache
*regcache
, int i
)
2875 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2876 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ i
))
2878 if (tdep
->abi
== ABI_LINUX_S390
)
2879 if (record_full_arch_list_add_reg (regcache
, S390_R0_UPPER_REGNUM
+ i
))
2884 /* Record high 32 bits of a register. */
2887 s390_record_gpr_h (struct gdbarch
*gdbarch
, struct regcache
*regcache
, int i
)
2889 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2890 if (tdep
->abi
== ABI_LINUX_S390
)
2892 if (record_full_arch_list_add_reg (regcache
, S390_R0_UPPER_REGNUM
+ i
))
2897 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ i
))
2903 /* Record vector register. */
2906 s390_record_vr (struct gdbarch
*gdbarch
, struct regcache
*regcache
, int i
)
2910 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ i
))
2912 if (record_full_arch_list_add_reg (regcache
, S390_V0_LOWER_REGNUM
+ i
))
2917 if (record_full_arch_list_add_reg (regcache
, S390_V16_REGNUM
+ i
- 16))
2923 /* Implement process_record gdbarch method. */
2926 s390_process_record (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
2929 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2930 uint16_t insn
[3] = {0};
2931 /* Instruction as bytes. */
2933 /* Instruction as nibbles. */
2935 /* Instruction vector registers. */
2937 CORE_ADDR oaddr
, oaddr2
, oaddr3
;
2940 /* if EX/EXRL instruction used, here's the reg parameter */
2942 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2944 /* Attempting to use EX or EXRL jumps back here */
2947 /* Read instruction. */
2948 insn
[0] = read_memory_unsigned_integer (addr
, 2, byte_order
);
2949 /* If execute was involved, do the adjustment. */
2951 insn
[0] |= ex
& 0xff;
2952 /* Two highest bits determine instruction size. */
2953 if (insn
[0] >= 0x4000)
2954 insn
[1] = read_memory_unsigned_integer (addr
+2, 2, byte_order
);
2956 /* Not necessary, but avoids uninitialized variable warnings. */
2958 if (insn
[0] >= 0xc000)
2959 insn
[2] = read_memory_unsigned_integer (addr
+4, 2, byte_order
);
2962 /* Split instruction into bytes and nibbles. */
2963 for (i
= 0; i
< 3; i
++)
2965 ibyte
[i
*2] = insn
[i
] >> 8 & 0xff;
2966 ibyte
[i
*2+1] = insn
[i
] & 0xff;
2968 for (i
= 0; i
< 6; i
++)
2970 inib
[i
*2] = ibyte
[i
] >> 4 & 0xf;
2971 inib
[i
*2+1] = ibyte
[i
] & 0xf;
2973 /* Compute vector registers, if applicable. */
2974 ivec
[0] = (inib
[9] >> 3 & 1) << 4 | inib
[2];
2975 ivec
[1] = (inib
[9] >> 2 & 1) << 4 | inib
[3];
2976 ivec
[2] = (inib
[9] >> 1 & 1) << 4 | inib
[4];
2977 ivec
[3] = (inib
[9] >> 0 & 1) << 4 | inib
[8];
2981 /* 0x00 undefined */
2984 /* E-format instruction */
2987 /* 0x00 undefined */
2988 /* 0x01 unsupported: PR - program return */
2989 /* 0x02 unsupported: UPT */
2990 /* 0x03 undefined */
2991 /* 0x04 privileged: PTFF - perform timing facility function */
2992 /* 0x05-0x06 undefined */
2993 /* 0x07 privileged: SCKPF - set clock programmable field */
2994 /* 0x08-0x09 undefined */
2996 case 0x0a: /* PFPO - perform floating point operation */
2997 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
, &tmp
);
2998 if (!(tmp
& 0x80000000u
))
3000 uint8_t ofc
= tmp
>> 16 & 0xff;
3003 case 0x00: /* HFP32 */
3004 case 0x01: /* HFP64 */
3005 case 0x05: /* BFP32 */
3006 case 0x06: /* BFP64 */
3007 case 0x08: /* DFP32 */
3008 case 0x09: /* DFP64 */
3009 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
))
3012 case 0x02: /* HFP128 */
3013 case 0x07: /* BFP128 */
3014 case 0x0a: /* DFP128 */
3015 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
))
3017 if (record_full_arch_list_add_reg (regcache
, S390_F2_REGNUM
))
3021 fprintf_unfiltered (gdb_stdlog
, "Warning: Unknown PFPO OFC %02x at %s.\n",
3022 ofc
, paddress (gdbarch
, addr
));
3026 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
3029 if (record_full_arch_list_add_reg (regcache
, S390_R1_REGNUM
))
3031 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3035 case 0x0b: /* TAM - test address mode */
3036 case 0x0c: /* SAM24 - set address mode 24 */
3037 case 0x0d: /* SAM31 - set address mode 31 */
3038 case 0x0e: /* SAM64 - set address mode 64 */
3039 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3043 /* 0x0f-0xfe undefined */
3045 /* 0xff unsupported: TRAP */
3052 /* 0x02 undefined */
3053 /* 0x03 undefined */
3055 case 0x04: /* SPM - set program mask */
3056 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3060 case 0x05: /* BALR - branch and link */
3061 case 0x45: /* BAL - branch and link */
3062 case 0x06: /* BCTR - branch on count */
3063 case 0x46: /* BCT - branch on count */
3064 case 0x0d: /* BASR - branch and save */
3065 case 0x4d: /* BAS - branch and save */
3066 case 0x84: /* BRXH - branch relative on index high */
3067 case 0x85: /* BRXLE - branch relative on index low or equal */
3068 case 0x86: /* BXH - branch on index high */
3069 case 0x87: /* BXLE - branch on index low or equal */
3070 /* BA[SL]* use native-size destination for linkage info, BCT*, BRX*, BX*
3071 use 32-bit destination as counter. */
3072 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
3076 case 0x07: /* BCR - branch on condition */
3077 case 0x47: /* BC - branch on condition */
3078 /* No effect other than PC transfer. */
3081 /* 0x08 undefined */
3082 /* 0x09 undefined */
3085 /* SVC - supervisor call */
3086 if (tdep
->s390_syscall_record
!= NULL
)
3088 if (tdep
->s390_syscall_record (regcache
, ibyte
[1]))
3093 printf_unfiltered (_("no syscall record support\n"));
3098 case 0x0b: /* BSM - branch and set mode */
3100 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
3102 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3106 case 0x0c: /* BASSM - branch and save 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 0x0e: /* MVCL - move long [interruptible] */
3114 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ inib
[2], &tmp
);
3115 oaddr
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
3116 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ (inib
[2] | 1), &tmp
);
3118 if (record_full_arch_list_add_mem (oaddr
, tmp
))
3120 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
3122 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[2] | 1)))
3124 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[3]))
3126 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[3] | 1)))
3128 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3132 case 0x0f: /* CLCL - compare logical long [interruptible] */
3133 case 0xa9: /* CLCLE - compare logical long extended [partial] */
3134 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
3136 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[2] | 1)))
3138 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[3]))
3140 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[3] | 1)))
3142 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3146 case 0x10: /* LPR - load positive */
3147 case 0x11: /* LNR - load negative */
3148 case 0x12: /* LTR - load and test */
3149 case 0x13: /* LCR - load complement */
3150 case 0x14: /* NR - and */
3151 case 0x16: /* OR - or */
3152 case 0x17: /* XR - xor */
3153 case 0x1a: /* AR - add */
3154 case 0x1b: /* SR - subtract */
3155 case 0x1e: /* ALR - add logical */
3156 case 0x1f: /* SLR - subtract logical */
3157 case 0x54: /* N - and */
3158 case 0x56: /* O - or */
3159 case 0x57: /* X - xor */
3160 case 0x5a: /* A - add */
3161 case 0x5b: /* S - subtract */
3162 case 0x5e: /* AL - add logical */
3163 case 0x5f: /* SL - subtract logical */
3164 case 0x4a: /* AH - add halfword */
3165 case 0x4b: /* SH - subtract halfword */
3166 case 0x8a: /* SRA - shift right single */
3167 case 0x8b: /* SLA - shift left single */
3168 case 0xbf: /* ICM - insert characters under mask */
3169 /* 32-bit destination + flags */
3170 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
3172 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3176 case 0x15: /* CLR - compare logical */
3177 case 0x55: /* CL - compare logical */
3178 case 0x19: /* CR - compare */
3179 case 0x29: /* CDR - compare */
3180 case 0x39: /* CER - compare */
3181 case 0x49: /* CH - compare halfword */
3182 case 0x59: /* C - compare */
3183 case 0x69: /* CD - compare */
3184 case 0x79: /* CE - compare */
3185 case 0x91: /* TM - test under mask */
3186 case 0x95: /* CLI - compare logical */
3187 case 0xbd: /* CLM - compare logical under mask */
3188 case 0xd5: /* CLC - compare logical */
3189 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3193 case 0x18: /* LR - load */
3194 case 0x48: /* LH - load halfword */
3195 case 0x58: /* L - load */
3196 case 0x41: /* LA - load address */
3197 case 0x43: /* IC - insert character */
3198 case 0x4c: /* MH - multiply halfword */
3199 case 0x71: /* MS - multiply single */
3200 case 0x88: /* SRL - shift right single logical */
3201 case 0x89: /* SLL - shift left single logical */
3202 /* 32-bit, 8-bit (IC), or native width (LA) destination, no flags */
3203 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
3207 case 0x1c: /* MR - multiply */
3208 case 0x5c: /* M - multiply */
3209 case 0x1d: /* DR - divide */
3210 case 0x5d: /* D - divide */
3211 case 0x8c: /* SRDL - shift right double logical */
3212 case 0x8d: /* SLDL - shift left double logical */
3213 /* 32-bit pair destination, no flags */
3214 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
3216 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[2] | 1)))
3220 case 0x20: /* LPDR - load positive */
3221 case 0x30: /* LPER - load positive */
3222 case 0x21: /* LNDR - load negative */
3223 case 0x31: /* LNER - load negative */
3224 case 0x22: /* LTDR - load and test */
3225 case 0x32: /* LTER - load and test */
3226 case 0x23: /* LCDR - load complement */
3227 case 0x33: /* LCER - load complement */
3228 case 0x2a: /* ADR - add */
3229 case 0x3a: /* AER - add */
3230 case 0x6a: /* AD - add */
3231 case 0x7a: /* AE - add */
3232 case 0x2b: /* SDR - subtract */
3233 case 0x3b: /* SER - subtract */
3234 case 0x6b: /* SD - subtract */
3235 case 0x7b: /* SE - subtract */
3236 case 0x2e: /* AWR - add unnormalized */
3237 case 0x3e: /* AUR - add unnormalized */
3238 case 0x6e: /* AW - add unnormalized */
3239 case 0x7e: /* AU - add unnormalized */
3240 case 0x2f: /* SWR - subtract unnormalized */
3241 case 0x3f: /* SUR - subtract unnormalized */
3242 case 0x6f: /* SW - subtract unnormalized */
3243 case 0x7f: /* SU - subtract unnormalized */
3244 /* float destination + flags */
3245 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[2]))
3247 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3251 case 0x24: /* HDR - halve */
3252 case 0x34: /* HER - halve */
3253 case 0x25: /* LDXR - load rounded */
3254 case 0x35: /* LEDR - load rounded */
3255 case 0x28: /* LDR - load */
3256 case 0x38: /* LER - load */
3257 case 0x68: /* LD - load */
3258 case 0x78: /* LE - load */
3259 case 0x2c: /* MDR - multiply */
3260 case 0x3c: /* MDER - multiply */
3261 case 0x6c: /* MD - multiply */
3262 case 0x7c: /* MDE - multiply */
3263 case 0x2d: /* DDR - divide */
3264 case 0x3d: /* DER - divide */
3265 case 0x6d: /* DD - divide */
3266 case 0x7d: /* DE - divide */
3267 /* float destination, no flags */
3268 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[2]))
3272 case 0x26: /* MXR - multiply */
3273 case 0x27: /* MXDR - multiply */
3274 case 0x67: /* MXD - multiply */
3275 /* float pair destination, no flags */
3276 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[2]))
3278 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ (inib
[2] | 2)))
3282 case 0x36: /* AXR - add */
3283 case 0x37: /* SXR - subtract */
3284 /* float pair destination + flags */
3285 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[2]))
3287 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ (inib
[2] | 2)))
3289 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3293 case 0x40: /* STH - store halfword */
3294 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, inib
[3], insn
[1], 0);
3295 if (record_full_arch_list_add_mem (oaddr
, 2))
3299 case 0x42: /* STC - store character */
3300 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, inib
[3], insn
[1], 0);
3301 if (record_full_arch_list_add_mem (oaddr
, 1))
3305 case 0x44: /* EX - execute */
3308 fprintf_unfiltered (gdb_stdlog
, "Warning: Double execute at %s.\n",
3309 paddress (gdbarch
, addr
));
3312 addr
= s390_record_calc_disp (gdbarch
, regcache
, inib
[3], insn
[1], 0);
3315 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ inib
[2], &tmp
);
3324 case 0x4e: /* CVD - convert to decimal */
3325 case 0x60: /* STD - store */
3326 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, inib
[3], insn
[1], 0);
3327 if (record_full_arch_list_add_mem (oaddr
, 8))
3331 case 0x4f: /* CVB - convert to binary */
3332 /* 32-bit gpr destination + FPC (DXC write) */
3333 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
3335 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
3339 case 0x50: /* ST - store */
3340 case 0x70: /* STE - store */
3341 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, inib
[3], insn
[1], 0);
3342 if (record_full_arch_list_add_mem (oaddr
, 4))
3346 case 0x51: /* LAE - load address extended */
3347 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
3349 if (record_full_arch_list_add_reg (regcache
, S390_A0_REGNUM
+ inib
[2]))
3353 /* 0x52 undefined */
3354 /* 0x53 undefined */
3356 /* 0x61-0x66 undefined */
3358 /* 0x72-0x77 undefined */
3360 /* 0x80 privileged: SSM - set system mask */
3361 /* 0x81 undefined */
3362 /* 0x82 privileged: LPSW - load PSW */
3363 /* 0x83 privileged: diagnose */
3365 case 0x8e: /* SRDA - shift right double */
3366 case 0x8f: /* SLDA - shift left double */
3367 /* 32-bit pair destination + flags */
3368 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
3370 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[2] | 1)))
3372 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3376 case 0x90: /* STM - store multiple */
3377 case 0x9b: /* STAM - store access multiple */
3378 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
3379 if (inib
[2] <= inib
[3])
3380 n
= inib
[3] - inib
[2] + 1;
3382 n
= inib
[3] + 0x10 - inib
[2] + 1;
3383 if (record_full_arch_list_add_mem (oaddr
, n
* 4))
3387 case 0x92: /* MVI - move */
3388 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
3389 if (record_full_arch_list_add_mem (oaddr
, 1))
3393 case 0x93: /* TS - test and set */
3394 case 0x94: /* NI - and */
3395 case 0x96: /* OI - or */
3396 case 0x97: /* XI - xor */
3397 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
3398 if (record_full_arch_list_add_mem (oaddr
, 1))
3400 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3404 case 0x98: /* LM - load multiple */
3405 for (i
= inib
[2]; i
!= inib
[3]; i
++, i
&= 0xf)
3406 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ i
))
3408 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[3]))
3412 /* 0x99 privileged: TRACE */
3414 case 0x9a: /* LAM - load access multiple */
3415 for (i
= inib
[2]; i
!= inib
[3]; i
++, i
&= 0xf)
3416 if (record_full_arch_list_add_reg (regcache
, S390_A0_REGNUM
+ i
))
3418 if (record_full_arch_list_add_reg (regcache
, S390_A0_REGNUM
+ inib
[3]))
3422 /* 0x9c-0x9f privileged and obsolete (old I/O) */
3423 /* 0xa0-0xa4 undefined */
3427 /* RI-format instruction */
3428 switch (ibyte
[0] << 4 | inib
[3])
3430 case 0xa50: /* IIHH - insert immediate */
3431 case 0xa51: /* IIHL - insert immediate */
3432 /* high 32-bit destination */
3433 if (s390_record_gpr_h (gdbarch
, regcache
, inib
[2]))
3437 case 0xa52: /* IILH - insert immediate */
3438 case 0xa53: /* IILL - insert immediate */
3439 case 0xa75: /* BRAS - branch relative and save */
3440 case 0xa76: /* BRCT - branch relative on count */
3441 case 0xa78: /* LHI - load halfword immediate */
3442 case 0xa7c: /* MHI - multiply halfword immediate */
3443 /* 32-bit or native destination */
3444 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
3448 case 0xa54: /* NIHH - and immediate */
3449 case 0xa55: /* NIHL - and immediate */
3450 case 0xa58: /* OIHH - or immediate */
3451 case 0xa59: /* OIHL - or immediate */
3452 /* high 32-bit destination + flags */
3453 if (s390_record_gpr_h (gdbarch
, regcache
, inib
[2]))
3455 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3459 case 0xa56: /* NILH - and immediate */
3460 case 0xa57: /* NILL - and immediate */
3461 case 0xa5a: /* OILH - or immediate */
3462 case 0xa5b: /* OILL - or immediate */
3463 case 0xa7a: /* AHI - add halfword immediate */
3464 /* 32-bit destination + flags */
3465 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
3467 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3471 case 0xa5c: /* LLIHH - load logical immediate */
3472 case 0xa5d: /* LLIHL - load logical immediate */
3473 case 0xa5e: /* LLILH - load logical immediate */
3474 case 0xa5f: /* LLILL - load logical immediate */
3475 case 0xa77: /* BRCTG - branch relative on count */
3476 case 0xa79: /* LGHI - load halfword immediate */
3477 case 0xa7d: /* MGHI - multiply halfword immediate */
3478 /* 64-bit destination */
3479 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
3483 case 0xa70: /* TMLH - test under mask */
3484 case 0xa71: /* TMLL - test under mask */
3485 case 0xa72: /* TMHH - test under mask */
3486 case 0xa73: /* TMHL - test under mask */
3487 case 0xa7e: /* CHI - compare halfword immediate */
3488 case 0xa7f: /* CGHI - compare halfword immediate */
3490 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3494 case 0xa74: /* BRC - branch relative on condition */
3495 /* no register change */
3498 case 0xa7b: /* AGHI - add halfword immediate */
3499 /* 64-bit destination + flags */
3500 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
3502 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3511 /* 0xa6 undefined */
3513 case 0xa8: /* MVCLE - move long extended [partial] */
3514 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ inib
[2], &tmp
);
3515 oaddr
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
3516 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ (inib
[2] | 1), &tmp
);
3517 if (record_full_arch_list_add_mem (oaddr
, tmp
))
3519 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
3521 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[2] | 1)))
3523 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[3]))
3525 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[3] | 1)))
3527 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3531 /* 0xaa-0xab undefined */
3532 /* 0xac privileged: STNSM - store then and system mask */
3533 /* 0xad privileged: STOSM - store then or system mask */
3534 /* 0xae privileged: SIGP - signal processor */
3535 /* 0xaf unsupported: MC - monitor call */
3536 /* 0xb0 undefined */
3537 /* 0xb1 privileged: LRA - load real address */
3542 /* S/RRD/RRE/RRF/IE-format instruction */
3545 /* 0xb200-0xb204 undefined or privileged */
3547 case 0xb205: /* STCK - store clock */
3548 case 0xb27c: /* STCKF - store clock fast */
3549 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
3550 if (record_full_arch_list_add_mem (oaddr
, 8))
3552 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3556 /* 0xb206-0xb219 undefined, privileged, or unsupported */
3557 /* 0xb21a unsupported: CFC */
3558 /* 0xb21b-0xb221 undefined or privileged */
3560 case 0xb222: /* IPM - insert program mask */
3561 case 0xb24f: /* EAR - extract access */
3562 case 0xb252: /* MSR - multiply single */
3563 case 0xb2ec: /* ETND - extract transaction nesting depth */
3564 case 0xb38c: /* EFPC - extract fpc */
3565 case 0xb91f: /* LRVR - load reversed */
3566 case 0xb926: /* LBR - load byte */
3567 case 0xb927: /* LHR - load halfword */
3568 case 0xb994: /* LLCR - load logical character */
3569 case 0xb995: /* LLHR - load logical halfword */
3570 case 0xb9f2: /* LOCR - load on condition */
3571 /* 32-bit gpr destination */
3572 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
3576 /* 0xb223-0xb22c privileged or unsupported */
3578 case 0xb22d: /* DXR - divide */
3579 case 0xb325: /* LXDR - load lengthened */
3580 case 0xb326: /* LXER - load lengthened */
3581 case 0xb336: /* SQXR - square root */
3582 case 0xb365: /* LXR - load */
3583 case 0xb367: /* FIXR - load fp integer */
3584 case 0xb376: /* LZXR - load zero */
3585 case 0xb3b6: /* CXFR - convert from fixed */
3586 case 0xb3c6: /* CXGR - convert from fixed */
3587 case 0xb3fe: /* IEXTR - insert biased exponent */
3588 /* float pair destination */
3589 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[6]))
3591 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ (inib
[6] | 2)))
3595 /* 0xb22e-0xb240 undefined, privileged, or unsupported */
3597 case 0xb241: /* CKSM - checksum [partial] */
3598 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
3600 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[7]))
3602 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[7] | 1)))
3604 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3608 /* 0xb242-0xb243 undefined */
3610 case 0xb244: /* SQDR - square root */
3611 case 0xb245: /* SQER - square root */
3612 case 0xb324: /* LDER - load lengthened */
3613 case 0xb337: /* MEER - multiply */
3614 case 0xb366: /* LEXR - load rounded */
3615 case 0xb370: /* LPDFR - load positive */
3616 case 0xb371: /* LNDFR - load negative */
3617 case 0xb372: /* CSDFR - copy sign */
3618 case 0xb373: /* LCDFR - load complement */
3619 case 0xb374: /* LZER - load zero */
3620 case 0xb375: /* LZDR - load zero */
3621 case 0xb377: /* FIER - load fp integer */
3622 case 0xb37f: /* FIDR - load fp integer */
3623 case 0xb3b4: /* CEFR - convert from fixed */
3624 case 0xb3b5: /* CDFR - convert from fixed */
3625 case 0xb3c1: /* LDGR - load fpr from gr */
3626 case 0xb3c4: /* CEGR - convert from fixed */
3627 case 0xb3c5: /* CDGR - convert from fixed */
3628 case 0xb3f6: /* IEDTR - insert biased exponent */
3629 /* float destination */
3630 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[6]))
3634 /* 0xb246-0xb24c: privileged or unsupported */
3636 case 0xb24d: /* CPYA - copy access */
3637 case 0xb24e: /* SAR - set access */
3638 if (record_full_arch_list_add_reg (regcache
, S390_A0_REGNUM
+ inib
[6]))
3642 /* 0xb250-0xb251 undefined or privileged */
3643 /* 0xb253-0xb254 undefined or privileged */
3645 case 0xb255: /* MVST - move string [partial] */
3650 /* Read ending byte. */
3651 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
, &tmp
);
3653 /* Get address of second operand. */
3654 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ inib
[7], &tmp
);
3655 oaddr
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
3656 /* Search for ending byte and compute length. */
3659 if (target_read_memory (oaddr
, &cur
, 1))
3662 } while (cur
!= end
);
3663 /* Get address of first operand and record it. */
3664 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ inib
[6], &tmp
);
3665 oaddr
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
3666 if (record_full_arch_list_add_mem (oaddr
, num
))
3668 /* Record the registers. */
3669 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
3671 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[7]))
3673 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3678 /* 0xb256 undefined */
3680 case 0xb257: /* CUSE - compare until substring equal [interruptible] */
3681 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
3683 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[6] | 1)))
3685 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[7]))
3687 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[7] | 1)))
3689 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3693 /* 0xb258-0xb25c undefined, privileged, or unsupported */
3695 case 0xb25d: /* CLST - compare logical string [partial] */
3696 case 0xb25e: /* SRST - search string [partial] */
3697 case 0xb9be: /* SRSTU - search string unicode [partial] */
3698 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
3700 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[7]))
3702 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3706 /* 0xb25f-0xb262 undefined */
3708 case 0xb263: /* CMPSC - compression call [interruptible] */
3709 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ inib
[6], &tmp
);
3710 oaddr
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
3711 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ (inib
[6] | 1), &tmp
);
3712 if (record_full_arch_list_add_mem (oaddr
, tmp
))
3714 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
3716 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[6] | 1)))
3718 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[7]))
3720 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[7] | 1)))
3722 if (record_full_arch_list_add_reg (regcache
, S390_R1_REGNUM
))
3724 /* DXC may be written */
3725 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
3727 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3731 /* 0xb264-0xb277 undefined, privileged, or unsupported */
3733 case 0xb278: /* STCKE - store clock extended */
3734 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
3735 if (record_full_arch_list_add_mem (oaddr
, 16))
3737 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3741 /* 0xb279-0xb27b undefined or unsupported */
3742 /* 0xb27d-0xb298 undefined or privileged */
3744 case 0xb299: /* SRNM - set rounding mode */
3745 case 0xb2b8: /* SRNMB - set bfp rounding mode */
3746 case 0xb2b9: /* SRNMT - set dfp rounding mode */
3747 case 0xb29d: /* LFPC - load fpc */
3748 case 0xb2bd: /* LFAS - load fpc and signal */
3749 case 0xb384: /* SFPC - set fpc */
3750 case 0xb385: /* SFASR - set fpc and signal */
3751 case 0xb960: /* CGRT - compare and trap */
3752 case 0xb961: /* CLGRT - compare logical and trap */
3753 case 0xb972: /* CRT - compare and trap */
3754 case 0xb973: /* CLRT - compare logical and trap */
3755 /* fpc only - including possible DXC write for trapping insns */
3756 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
3760 /* 0xb29a-0xb29b undefined */
3762 case 0xb29c: /* STFPC - store fpc */
3763 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
3764 if (record_full_arch_list_add_mem (oaddr
, 4))
3768 /* 0xb29e-0xb2a4 undefined */
3770 case 0xb2a5: /* TRE - translate extended [partial] */
3771 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ inib
[6], &tmp
);
3772 oaddr
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
3773 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ (inib
[6] | 1), &tmp
);
3774 if (record_full_arch_list_add_mem (oaddr
, tmp
))
3776 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
3778 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[6] | 1)))
3780 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3784 case 0xb2a6: /* CU21 - convert UTF-16 to UTF-8 [partial] */
3785 case 0xb2a7: /* CU12 - convert UTF-8 to UTF-16 [partial] */
3786 case 0xb9b0: /* CU14 - convert UTF-8 to UTF-32 [partial] */
3787 case 0xb9b1: /* CU24 - convert UTF-16 to UTF-32 [partial] */
3788 case 0xb9b2: /* CU41 - convert UTF-32 to UTF-8 [partial] */
3789 case 0xb9b3: /* CU42 - convert UTF-32 to UTF-16 [partial] */
3790 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ inib
[6], &tmp
);
3791 oaddr
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
3792 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ (inib
[6] | 1), &tmp
);
3793 if (record_full_arch_list_add_mem (oaddr
, tmp
))
3795 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
3797 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[6] | 1)))
3799 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[7]))
3801 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[7] | 1)))
3803 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3807 /* 0xb2a8-0xb2af undefined */
3809 case 0xb2b0: /* STFLE - store facility list extended */
3810 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
3811 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
, &tmp
);
3813 if (record_full_arch_list_add_mem (oaddr
, 8 * (tmp
+ 1)))
3815 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
))
3817 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3821 /* 0xb2b1-0xb2b7 undefined or privileged */
3822 /* 0xb2ba-0xb2bc undefined */
3823 /* 0xb2be-0xb2e7 undefined */
3824 /* 0xb2e9-0xb2eb undefined */
3825 /* 0xb2ed-0xb2f7 undefined */
3826 /* 0xb2f8 unsupported: TEND */
3827 /* 0xb2f9 undefined */
3829 case 0xb2e8: /* PPA - perform processor assist */
3830 case 0xb2fa: /* NIAI - next instruction access intent */
3831 /* no visible effects */
3834 /* 0xb2fb undefined */
3835 /* 0xb2fc unsupported: TABORT */
3836 /* 0xb2fd-0xb2fe undefined */
3837 /* 0xb2ff unsupported: TRAP */
3839 case 0xb300: /* LPEBR - load positive */
3840 case 0xb301: /* LNEBR - load negative */
3841 case 0xb303: /* LCEBR - load complement */
3842 case 0xb310: /* LPDBR - load positive */
3843 case 0xb311: /* LNDBR - load negative */
3844 case 0xb313: /* LCDBR - load complement */
3845 case 0xb350: /* TBEDR - convert hfp to bfp */
3846 case 0xb351: /* TBDR - convert hfp to bfp */
3847 case 0xb358: /* THDER - convert bfp to hfp */
3848 case 0xb359: /* THDR - convert bfp to hfp */
3849 /* float destination + flags */
3850 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[6]))
3852 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3856 case 0xb304: /* LDEBR - load lengthened */
3857 case 0xb30c: /* MDEBR - multiply */
3858 case 0xb30d: /* DEBR - divide */
3859 case 0xb314: /* SQEBR - square root */
3860 case 0xb315: /* SQDBR - square root */
3861 case 0xb317: /* MEEBR - multiply */
3862 case 0xb31c: /* MDBR - multiply */
3863 case 0xb31d: /* DDBR - divide */
3864 case 0xb344: /* LEDBRA - load rounded */
3865 case 0xb345: /* LDXBRA - load rounded */
3866 case 0xb346: /* LEXBRA - load rounded */
3867 case 0xb357: /* FIEBRA - load fp integer */
3868 case 0xb35f: /* FIDBRA - load fp integer */
3869 case 0xb390: /* CELFBR - convert from logical */
3870 case 0xb391: /* CDLFBR - convert from logical */
3871 case 0xb394: /* CEFBR - convert from fixed */
3872 case 0xb395: /* CDFBR - convert from fixed */
3873 case 0xb3a0: /* CELGBR - convert from logical */
3874 case 0xb3a1: /* CDLGBR - convert from logical */
3875 case 0xb3a4: /* CEGBR - convert from fixed */
3876 case 0xb3a5: /* CDGBR - convert from fixed */
3877 case 0xb3d0: /* MDTR - multiply */
3878 case 0xb3d1: /* DDTR - divide */
3879 case 0xb3d4: /* LDETR - load lengthened */
3880 case 0xb3d5: /* LEDTR - load lengthened */
3881 case 0xb3d7: /* FIDTR - load fp integer */
3882 case 0xb3dd: /* LDXTR - load lengthened */
3883 case 0xb3f1: /* CDGTR - convert from fixed */
3884 case 0xb3f2: /* CDUTR - convert from unsigned packed */
3885 case 0xb3f3: /* CDSTR - convert from signed packed */
3886 case 0xb3f5: /* QADTR - quantize */
3887 case 0xb3f7: /* RRDTR - reround */
3888 case 0xb951: /* CDFTR - convert from fixed */
3889 case 0xb952: /* CDLGTR - convert from logical */
3890 case 0xb953: /* CDLFTR - convert from logical */
3891 /* float destination + fpc */
3892 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[6]))
3894 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
3898 case 0xb305: /* LXDBR - load lengthened */
3899 case 0xb306: /* LXEBR - load lengthened */
3900 case 0xb307: /* MXDBR - multiply */
3901 case 0xb316: /* SQXBR - square root */
3902 case 0xb34c: /* MXBR - multiply */
3903 case 0xb34d: /* DXBR - divide */
3904 case 0xb347: /* FIXBRA - load fp integer */
3905 case 0xb392: /* CXLFBR - convert from logical */
3906 case 0xb396: /* CXFBR - convert from fixed */
3907 case 0xb3a2: /* CXLGBR - convert from logical */
3908 case 0xb3a6: /* CXGBR - convert from fixed */
3909 case 0xb3d8: /* MXTR - multiply */
3910 case 0xb3d9: /* DXTR - divide */
3911 case 0xb3dc: /* LXDTR - load lengthened */
3912 case 0xb3df: /* FIXTR - load fp integer */
3913 case 0xb3f9: /* CXGTR - convert from fixed */
3914 case 0xb3fa: /* CXUTR - convert from unsigned packed */
3915 case 0xb3fb: /* CXSTR - convert from signed packed */
3916 case 0xb3fd: /* QAXTR - quantize */
3917 case 0xb3ff: /* RRXTR - reround */
3918 case 0xb959: /* CXFTR - convert from fixed */
3919 case 0xb95a: /* CXLGTR - convert from logical */
3920 case 0xb95b: /* CXLFTR - convert from logical */
3921 /* float pair destination + fpc */
3922 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[6]))
3924 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ (inib
[6] | 2)))
3926 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
3930 case 0xb308: /* KEBR - compare and signal */
3931 case 0xb309: /* CEBR - compare */
3932 case 0xb318: /* KDBR - compare and signal */
3933 case 0xb319: /* CDBR - compare */
3934 case 0xb348: /* KXBR - compare and signal */
3935 case 0xb349: /* CXBR - compare */
3936 case 0xb3e0: /* KDTR - compare and signal */
3937 case 0xb3e4: /* CDTR - compare */
3938 case 0xb3e8: /* KXTR - compare and signal */
3939 case 0xb3ec: /* CXTR - compare */
3940 /* flags + fpc only */
3941 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3943 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
3947 case 0xb302: /* LTEBR - load and test */
3948 case 0xb312: /* LTDBR - load and test */
3949 case 0xb30a: /* AEBR - add */
3950 case 0xb30b: /* SEBR - subtract */
3951 case 0xb31a: /* ADBR - add */
3952 case 0xb31b: /* SDBR - subtract */
3953 case 0xb3d2: /* ADTR - add */
3954 case 0xb3d3: /* SDTR - subtract */
3955 case 0xb3d6: /* LTDTR - load and test */
3956 /* float destination + flags + fpc */
3957 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[6]))
3959 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3961 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
3965 case 0xb30e: /* MAEBR - multiply and add */
3966 case 0xb30f: /* MSEBR - multiply and subtract */
3967 case 0xb31e: /* MADBR - multiply and add */
3968 case 0xb31f: /* MSDBR - multiply and subtract */
3969 /* float destination [RRD] + fpc */
3970 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[4]))
3972 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
3976 /* 0xb320-0xb323 undefined */
3977 /* 0xb327-0xb32d undefined */
3979 case 0xb32e: /* MAER - multiply and add */
3980 case 0xb32f: /* MSER - multiply and subtract */
3981 case 0xb338: /* MAYLR - multiply and add unnormalized */
3982 case 0xb339: /* MYLR - multiply unnormalized */
3983 case 0xb33c: /* MAYHR - multiply and add unnormalized */
3984 case 0xb33d: /* MYHR - multiply unnormalized */
3985 case 0xb33e: /* MADR - multiply and add */
3986 case 0xb33f: /* MSDR - multiply and subtract */
3987 /* float destination [RRD] */
3988 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[4]))
3992 /* 0xb330-0xb335 undefined */
3994 case 0xb33a: /* MAYR - multiply and add unnormalized */
3995 case 0xb33b: /* MYR - multiply unnormalized */
3996 /* float pair destination [RRD] */
3997 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[4]))
3999 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ (inib
[4] | 2)))
4003 case 0xb340: /* LPXBR - load positive */
4004 case 0xb341: /* LNXBR - load negative */
4005 case 0xb343: /* LCXBR - load complement */
4006 case 0xb360: /* LPXR - load positive */
4007 case 0xb361: /* LNXR - load negative */
4008 case 0xb362: /* LTXR - load and test */
4009 case 0xb363: /* LCXR - load complement */
4010 /* float pair destination + flags */
4011 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[6]))
4013 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ (inib
[6] | 2)))
4015 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4019 case 0xb342: /* LTXBR - load and test */
4020 case 0xb34a: /* AXBR - add */
4021 case 0xb34b: /* SXBR - subtract */
4022 case 0xb3da: /* AXTR - add */
4023 case 0xb3db: /* SXTR - subtract */
4024 case 0xb3de: /* LTXTR - load and test */
4025 /* float pair destination + flags + fpc */
4026 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[6]))
4028 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ (inib
[6] | 2)))
4030 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4032 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
4036 /* 0xb34e-0xb34f undefined */
4037 /* 0xb352 undefined */
4039 case 0xb353: /* DIEBR - divide to integer */
4040 case 0xb35b: /* DIDBR - divide to integer */
4041 /* two float destinations + flags + fpc */
4042 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[4]))
4044 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[6]))
4046 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4048 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
4052 /* 0xb354-0xb356 undefined */
4053 /* 0xb35a undefined */
4055 /* 0xb35c-0xb35e undefined */
4056 /* 0xb364 undefined */
4057 /* 0xb368 undefined */
4059 case 0xb369: /* CXR - compare */
4060 case 0xb3f4: /* CEDTR - compare biased exponent */
4061 case 0xb3fc: /* CEXTR - compare biased exponent */
4062 case 0xb920: /* CGR - compare */
4063 case 0xb921: /* CLGR - compare logical */
4064 case 0xb930: /* CGFR - compare */
4065 case 0xb931: /* CLGFR - compare logical */
4066 case 0xb9cd: /* CHHR - compare high */
4067 case 0xb9cf: /* CLHHR - compare logical high */
4068 case 0xb9dd: /* CHLR - compare high */
4069 case 0xb9df: /* CLHLR - compare logical high */
4071 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4075 /* 0xb36a-0xb36f undefined */
4076 /* 0xb377-0xb37e undefined */
4077 /* 0xb380-0xb383 undefined */
4078 /* 0xb386-0xb38b undefined */
4079 /* 0xb38d-0xb38f undefined */
4080 /* 0xb393 undefined */
4081 /* 0xb397 undefined */
4083 case 0xb398: /* CFEBR - convert to fixed */
4084 case 0xb399: /* CFDBR - convert to fixed */
4085 case 0xb39a: /* CFXBR - convert to fixed */
4086 case 0xb39c: /* CLFEBR - convert to logical */
4087 case 0xb39d: /* CLFDBR - convert to logical */
4088 case 0xb39e: /* CLFXBR - convert to logical */
4089 case 0xb941: /* CFDTR - convert to fixed */
4090 case 0xb949: /* CFXTR - convert to fixed */
4091 case 0xb943: /* CLFDTR - convert to logical */
4092 case 0xb94b: /* CLFXTR - convert to logical */
4093 /* 32-bit gpr destination + flags + fpc */
4094 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
4096 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4098 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
4102 /* 0xb39b undefined */
4103 /* 0xb39f undefined */
4105 /* 0xb3a3 undefined */
4106 /* 0xb3a7 undefined */
4108 case 0xb3a8: /* CGEBR - convert to fixed */
4109 case 0xb3a9: /* CGDBR - convert to fixed */
4110 case 0xb3aa: /* CGXBR - convert to fixed */
4111 case 0xb3ac: /* CLGEBR - convert to logical */
4112 case 0xb3ad: /* CLGDBR - convert to logical */
4113 case 0xb3ae: /* CLGXBR - convert to logical */
4114 case 0xb3e1: /* CGDTR - convert to fixed */
4115 case 0xb3e9: /* CGXTR - convert to fixed */
4116 case 0xb942: /* CLGDTR - convert to logical */
4117 case 0xb94a: /* CLGXTR - convert to logical */
4118 /* 64-bit gpr destination + flags + fpc */
4119 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[6]))
4121 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4123 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
4127 /* 0xb3ab undefined */
4128 /* 0xb3af-0xb3b3 undefined */
4129 /* 0xb3b7 undefined */
4131 case 0xb3b8: /* CFER - convert to fixed */
4132 case 0xb3b9: /* CFDR - convert to fixed */
4133 case 0xb3ba: /* CFXR - convert to fixed */
4134 case 0xb998: /* ALCR - add logical with carry */
4135 case 0xb999: /* SLBR - subtract logical with borrow */
4136 case 0xb9f4: /* NRK - and */
4137 case 0xb9f6: /* ORK - or */
4138 case 0xb9f7: /* XRK - xor */
4139 case 0xb9f8: /* ARK - add */
4140 case 0xb9f9: /* SRK - subtract */
4141 case 0xb9fa: /* ALRK - add logical */
4142 case 0xb9fb: /* SLRK - subtract logical */
4143 /* 32-bit gpr destination + flags */
4144 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
4146 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4150 case 0xb3c8: /* CGER - convert to fixed */
4151 case 0xb3c9: /* CGDR - convert to fixed */
4152 case 0xb3ca: /* CGXR - convert to fixed */
4153 case 0xb900: /* LPGR - load positive */
4154 case 0xb901: /* LNGR - load negative */
4155 case 0xb902: /* LTGR - load and test */
4156 case 0xb903: /* LCGR - load complement */
4157 case 0xb908: /* AGR - add */
4158 case 0xb909: /* SGR - subtract */
4159 case 0xb90a: /* ALGR - add logical */
4160 case 0xb90b: /* SLGR - subtract logical */
4161 case 0xb910: /* LPGFR - load positive */
4162 case 0xb911: /* LNGFR - load negative */
4163 case 0xb912: /* LTGFR - load and test */
4164 case 0xb913: /* LCGFR - load complement */
4165 case 0xb918: /* AGFR - add */
4166 case 0xb919: /* SGFR - subtract */
4167 case 0xb91a: /* ALGFR - add logical */
4168 case 0xb91b: /* SLGFR - subtract logical */
4169 case 0xb980: /* NGR - and */
4170 case 0xb981: /* OGR - or */
4171 case 0xb982: /* XGR - xor */
4172 case 0xb988: /* ALCGR - add logical with carry */
4173 case 0xb989: /* SLBGR - subtract logical with borrow */
4174 case 0xb9e1: /* POPCNT - population count */
4175 case 0xb9e4: /* NGRK - and */
4176 case 0xb9e6: /* OGRK - or */
4177 case 0xb9e7: /* XGRK - xor */
4178 case 0xb9e8: /* AGRK - add */
4179 case 0xb9e9: /* SGRK - subtract */
4180 case 0xb9ea: /* ALGRK - add logical */
4181 case 0xb9eb: /* SLGRK - subtract logical */
4182 case 0xb9ed: /* MSGRKC - multiply single 64x64 -> 64 */
4183 case 0xb9fd: /* MSRKC - multiply single 32x32 -> 32 */
4184 /* 64-bit gpr destination + flags */
4185 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[6]))
4187 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4191 /* 0xb3bb-0xb3c0 undefined */
4192 /* 0xb3c2-0xb3c3 undefined */
4193 /* 0xb3c7 undefined */
4194 /* 0xb3cb-0xb3cc undefined */
4196 case 0xb3cd: /* LGDR - load gr from fpr */
4197 case 0xb3e2: /* CUDTR - convert to unsigned packed */
4198 case 0xb3e3: /* CSDTR - convert to signed packed */
4199 case 0xb3e5: /* EEDTR - extract biased exponent */
4200 case 0xb3e7: /* ESDTR - extract significance */
4201 case 0xb3ed: /* EEXTR - extract biased exponent */
4202 case 0xb3ef: /* ESXTR - extract significance */
4203 case 0xb904: /* LGR - load */
4204 case 0xb906: /* LGBR - load byte */
4205 case 0xb907: /* LGHR - load halfword */
4206 case 0xb90c: /* MSGR - multiply single */
4207 case 0xb90f: /* LRVGR - load reversed */
4208 case 0xb914: /* LGFR - load */
4209 case 0xb916: /* LLGFR - load logical */
4210 case 0xb917: /* LLGTR - load logical thirty one bits */
4211 case 0xb91c: /* MSGFR - multiply single 64<32 */
4212 case 0xb946: /* BCTGR - branch on count */
4213 case 0xb984: /* LLGCR - load logical character */
4214 case 0xb985: /* LLGHR - load logical halfword */
4215 case 0xb9e2: /* LOCGR - load on condition */
4216 /* 64-bit gpr destination */
4217 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[6]))
4221 /* 0xb3ce-0xb3cf undefined */
4222 /* 0xb3e6 undefined */
4224 case 0xb3ea: /* CUXTR - convert to unsigned packed */
4225 case 0xb3eb: /* CSXTR - convert to signed packed */
4226 case 0xb90d: /* DSGR - divide single */
4227 case 0xb91d: /* DSGFR - divide single */
4228 case 0xb986: /* MLGR - multiply logical */
4229 case 0xb987: /* DLGR - divide logical */
4230 case 0xb9ec: /* MGRK - multiply 64x64 -> 128 */
4231 /* 64-bit gpr pair destination */
4232 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[6]))
4234 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[6] | 1))
4238 /* 0xb3ee undefined */
4239 /* 0xb3f0 undefined */
4240 /* 0xb3f8 undefined */
4242 /* 0xb905 privileged */
4244 /* 0xb90e unsupported: EREGG */
4246 /* 0xb915 undefined */
4248 case 0xb91e: /* KMAC - compute message authentication code [partial] */
4249 regcache_raw_read_unsigned (regcache
, S390_R1_REGNUM
, &tmp
);
4250 oaddr
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
4251 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
, &tmp
);
4255 case 0x00: /* KMAC-Query */
4256 if (record_full_arch_list_add_mem (oaddr
, 16))
4260 case 0x01: /* KMAC-DEA */
4261 case 0x02: /* KMAC-TDEA-128 */
4262 case 0x03: /* KMAC-TDEA-192 */
4263 case 0x09: /* KMAC-Encrypted-DEA */
4264 case 0x0a: /* KMAC-Encrypted-TDEA-128 */
4265 case 0x0b: /* KMAC-Encrypted-TDEA-192 */
4266 if (record_full_arch_list_add_mem (oaddr
, 8))
4270 case 0x12: /* KMAC-AES-128 */
4271 case 0x13: /* KMAC-AES-192 */
4272 case 0x14: /* KMAC-AES-256 */
4273 case 0x1a: /* KMAC-Encrypted-AES-128 */
4274 case 0x1b: /* KMAC-Encrypted-AES-192 */
4275 case 0x1c: /* KMAC-Encrypted-AES-256 */
4276 if (record_full_arch_list_add_mem (oaddr
, 16))
4281 fprintf_unfiltered (gdb_stdlog
, "Warning: Unknown KMAC function %02x at %s.\n",
4282 (int)tmp
, paddress (gdbarch
, addr
));
4287 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[7]))
4289 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[7] | 1)))
4292 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4296 /* 0xb922-0xb924 undefined */
4297 /* 0xb925 privileged */
4298 /* 0xb928 privileged */
4300 case 0xb929: /* KMA - cipher message with authentication */
4301 case 0xb92a: /* KMF - cipher message with cipher feedback [partial] */
4302 case 0xb92b: /* KMO - cipher message with output feedback [partial] */
4303 case 0xb92f: /* KMC - cipher message with chaining [partial] */
4304 regcache_raw_read_unsigned (regcache
, S390_R1_REGNUM
, &tmp
);
4305 oaddr
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
4306 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
, &tmp
);
4310 case 0x00: /* KM*-Query */
4311 if (record_full_arch_list_add_mem (oaddr
, 16))
4315 case 0x01: /* KM*-DEA */
4316 case 0x02: /* KM*-TDEA-128 */
4317 case 0x03: /* KM*-TDEA-192 */
4318 case 0x09: /* KM*-Encrypted-DEA */
4319 case 0x0a: /* KM*-Encrypted-TDEA-128 */
4320 case 0x0b: /* KM*-Encrypted-TDEA-192 */
4321 if (record_full_arch_list_add_mem (oaddr
, 8))
4325 case 0x12: /* KM*-AES-128 */
4326 case 0x13: /* KM*-AES-192 */
4327 case 0x14: /* KM*-AES-256 */
4328 case 0x1a: /* KM*-Encrypted-AES-128 */
4329 case 0x1b: /* KM*-Encrypted-AES-192 */
4330 case 0x1c: /* KM*-Encrypted-AES-256 */
4331 if (record_full_arch_list_add_mem (oaddr
, 16))
4335 case 0x43: /* KMC-PRNG */
4336 /* Only valid for KMC. */
4337 if (insn
[0] == 0xb92f)
4339 if (record_full_arch_list_add_mem (oaddr
, 8))
4343 /* For other instructions... */
4346 fprintf_unfiltered (gdb_stdlog
, "Warning: Unknown KM* function %02x at %s.\n",
4347 (int)tmp
, paddress (gdbarch
, addr
));
4352 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ inib
[6], &tmp
);
4353 oaddr2
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
4354 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ (inib
[7] | 1), &tmp
);
4355 if (record_full_arch_list_add_mem (oaddr2
, tmp
))
4357 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
4359 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[7]))
4361 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[7] | 1)))
4364 if (tmp
!= 0 && insn
[0] == 0xb929)
4366 if (record_full_arch_list_add_reg (regcache
,
4367 S390_R0_REGNUM
+ inib
[4]))
4369 if (record_full_arch_list_add_reg (regcache
,
4370 S390_R0_REGNUM
+ (inib
[4] | 1)))
4373 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4377 case 0xb92c: /* PCC - perform cryptographic computation [partial] */
4378 regcache_raw_read_unsigned (regcache
, S390_R1_REGNUM
, &tmp
);
4379 oaddr
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
4380 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
, &tmp
);
4384 case 0x00: /* PCC-Query */
4385 if (record_full_arch_list_add_mem (oaddr
, 16))
4389 case 0x01: /* PCC-Compute-Last-Block-CMAC-Using-DEA */
4390 case 0x02: /* PCC-Compute-Last-Block-CMAC-Using-TDEA-128 */
4391 case 0x03: /* PCC-Compute-Last-Block-CMAC-Using-TDEA-192 */
4392 case 0x09: /* PCC-Compute-Last-Block-CMAC-Using-Encrypted-DEA */
4393 case 0x0a: /* PCC-Compute-Last-Block-CMAC-Using-Encrypted-TDEA-128 */
4394 case 0x0b: /* PCC-Compute-Last-Block-CMAC-Using-Encrypted-TDEA-192 */
4395 if (record_full_arch_list_add_mem (oaddr
+ 0x10, 8))
4399 case 0x12: /* PCC-Compute-Last-Block-CMAC-Using-AES-128 */
4400 case 0x13: /* PCC-Compute-Last-Block-CMAC-Using-AES-192 */
4401 case 0x14: /* PCC-Compute-Last-Block-CMAC-Using-AES-256 */
4402 case 0x1a: /* PCC-Compute-Last-Block-CMAC-Using-Encrypted-AES-128 */
4403 case 0x1b: /* PCC-Compute-Last-Block-CMAC-Using-Encrypted-AES-192 */
4404 case 0x1c: /* PCC-Compute-Last-Block-CMAC-Using-Encrypted-AES-256 */
4405 if (record_full_arch_list_add_mem (oaddr
+ 0x18, 16))
4409 case 0x32: /* PCC-Compute-XTS-Parameter-Using-AES-128 */
4410 if (record_full_arch_list_add_mem (oaddr
+ 0x30, 32))
4414 case 0x34: /* PCC-Compute-XTS-Parameter-Using-AES-256 */
4415 if (record_full_arch_list_add_mem (oaddr
+ 0x40, 32))
4419 case 0x3a: /* PCC-Compute-XTS-Parameter-Using-Encrypted-AES-128 */
4420 if (record_full_arch_list_add_mem (oaddr
+ 0x50, 32))
4424 case 0x3c: /* PCC-Compute-XTS-Parameter-Using-Encrypted-AES-256 */
4425 if (record_full_arch_list_add_mem (oaddr
+ 0x60, 32))
4430 fprintf_unfiltered (gdb_stdlog
, "Warning: Unknown PCC function %02x at %s.\n",
4431 (int)tmp
, paddress (gdbarch
, addr
));
4434 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4438 case 0xb92d: /* KMCTR - cipher message with counter [partial] */
4439 regcache_raw_read_unsigned (regcache
, S390_R1_REGNUM
, &tmp
);
4440 oaddr
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
4441 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
, &tmp
);
4445 case 0x00: /* KMCTR-Query */
4446 if (record_full_arch_list_add_mem (oaddr
, 16))
4450 case 0x01: /* KMCTR-DEA */
4451 case 0x02: /* KMCTR-TDEA-128 */
4452 case 0x03: /* KMCTR-TDEA-192 */
4453 case 0x09: /* KMCTR-Encrypted-DEA */
4454 case 0x0a: /* KMCTR-Encrypted-TDEA-128 */
4455 case 0x0b: /* KMCTR-Encrypted-TDEA-192 */
4456 case 0x12: /* KMCTR-AES-128 */
4457 case 0x13: /* KMCTR-AES-192 */
4458 case 0x14: /* KMCTR-AES-256 */
4459 case 0x1a: /* KMCTR-Encrypted-AES-128 */
4460 case 0x1b: /* KMCTR-Encrypted-AES-192 */
4461 case 0x1c: /* KMCTR-Encrypted-AES-256 */
4465 fprintf_unfiltered (gdb_stdlog
, "Warning: Unknown KMCTR function %02x at %s.\n",
4466 (int)tmp
, paddress (gdbarch
, addr
));
4471 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ inib
[6], &tmp
);
4472 oaddr2
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
4473 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ (inib
[7] | 1), &tmp
);
4474 if (record_full_arch_list_add_mem (oaddr2
, tmp
))
4476 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
4478 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[7]))
4480 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[7] | 1)))
4482 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[4]))
4485 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4489 case 0xb92e: /* KM - cipher message [partial] */
4490 regcache_raw_read_unsigned (regcache
, S390_R1_REGNUM
, &tmp
);
4491 oaddr
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
4492 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
, &tmp
);
4496 case 0x00: /* KM-Query */
4497 if (record_full_arch_list_add_mem (oaddr
, 16))
4501 case 0x01: /* KM-DEA */
4502 case 0x02: /* KM-TDEA-128 */
4503 case 0x03: /* KM-TDEA-192 */
4504 case 0x09: /* KM-Encrypted-DEA */
4505 case 0x0a: /* KM-Encrypted-TDEA-128 */
4506 case 0x0b: /* KM-Encrypted-TDEA-192 */
4507 case 0x12: /* KM-AES-128 */
4508 case 0x13: /* KM-AES-192 */
4509 case 0x14: /* KM-AES-256 */
4510 case 0x1a: /* KM-Encrypted-AES-128 */
4511 case 0x1b: /* KM-Encrypted-AES-192 */
4512 case 0x1c: /* KM-Encrypted-AES-256 */
4515 case 0x32: /* KM-XTS-AES-128 */
4516 if (record_full_arch_list_add_mem (oaddr
+ 0x10, 16))
4520 case 0x34: /* KM-XTS-AES-256 */
4521 if (record_full_arch_list_add_mem (oaddr
+ 0x20, 16))
4525 case 0x3a: /* KM-XTS-Encrypted-AES-128 */
4526 if (record_full_arch_list_add_mem (oaddr
+ 0x30, 16))
4530 case 0x3c: /* KM-XTS-Encrypted-AES-256 */
4531 if (record_full_arch_list_add_mem (oaddr
+ 0x40, 16))
4536 fprintf_unfiltered (gdb_stdlog
, "Warning: Unknown KM function %02x at %s.\n",
4537 (int)tmp
, paddress (gdbarch
, addr
));
4542 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ inib
[6], &tmp
);
4543 oaddr2
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
4544 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ (inib
[7] | 1), &tmp
);
4545 if (record_full_arch_list_add_mem (oaddr2
, tmp
))
4547 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
4549 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[7]))
4551 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[7] | 1)))
4554 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4558 /* 0xb932-0xb93b undefined */
4560 case 0xb93c: /* PPNO - perform pseudorandom number operation [partial] */
4561 regcache_raw_read_unsigned (regcache
, S390_R1_REGNUM
, &tmp
);
4562 oaddr
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
4563 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
, &tmp
);
4567 case 0x00: /* PPNO-Query */
4568 case 0x80: /* PPNO-Query */
4569 if (record_full_arch_list_add_mem (oaddr
, 16))
4573 case 0x03: /* PPNO-SHA-512-DRNG - generate */
4574 if (record_full_arch_list_add_mem (oaddr
, 240))
4576 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ inib
[6], &tmp
);
4577 oaddr2
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
4578 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ (inib
[6] | 1), &tmp
);
4579 if (record_full_arch_list_add_mem (oaddr2
, tmp
))
4581 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
4583 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[6] | 1)))
4587 case 0x83: /* PPNO-SHA-512-DRNG - seed */
4588 if (record_full_arch_list_add_mem (oaddr
, 240))
4590 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[7]))
4592 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[7] | 1)))
4597 fprintf_unfiltered (gdb_stdlog
, "Warning: Unknown PPNO function %02x at %s.\n",
4598 (int)tmp
, paddress (gdbarch
, addr
));
4601 /* DXC may be written */
4602 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
4604 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4608 /* 0xb93d undefined */
4610 case 0xb93e: /* KIMD - compute intermediate message digest [partial] */
4611 case 0xb93f: /* KLMD - compute last message digest [partial] */
4612 regcache_raw_read_unsigned (regcache
, S390_R1_REGNUM
, &tmp
);
4613 oaddr
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
4614 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
, &tmp
);
4618 case 0x00: /* K*MD-Query */
4619 if (record_full_arch_list_add_mem (oaddr
, 16))
4623 case 0x01: /* K*MD-SHA-1 */
4624 if (record_full_arch_list_add_mem (oaddr
, 20))
4628 case 0x02: /* K*MD-SHA-256 */
4629 if (record_full_arch_list_add_mem (oaddr
, 32))
4633 case 0x03: /* K*MD-SHA-512 */
4634 if (record_full_arch_list_add_mem (oaddr
, 64))
4638 case 0x41: /* KIMD-GHASH */
4639 /* Only valid for KIMD. */
4640 if (insn
[0] == 0xb93e)
4642 if (record_full_arch_list_add_mem (oaddr
, 16))
4649 fprintf_unfiltered (gdb_stdlog
, "Warning: Unknown KMAC function %02x at %s.\n",
4650 (int)tmp
, paddress (gdbarch
, addr
));
4655 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[7]))
4657 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[7] | 1)))
4660 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4664 /* 0xb940 undefined */
4665 /* 0xb944-0xb945 undefined */
4666 /* 0xb947-0xb948 undefined */
4667 /* 0xb94c-0xb950 undefined */
4668 /* 0xb954-0xb958 undefined */
4669 /* 0xb95c-0xb95f undefined */
4670 /* 0xb962-0xb971 undefined */
4671 /* 0xb974-0xb97f undefined */
4673 case 0xb983: /* FLOGR - find leftmost one */
4674 /* 64-bit gpr pair destination + flags */
4675 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[6]))
4677 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[6] | 1))
4679 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4683 /* 0xb98a privileged */
4684 /* 0xb98b-0xb98c undefined */
4686 case 0xb98d: /* EPSW - extract psw */
4687 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
4690 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[7]))
4694 /* 0xb98e-0xb98f privileged */
4696 case 0xb990: /* TRTT - translate two to two [partial] */
4697 case 0xb991: /* TRTO - translate two to one [partial] */
4698 case 0xb992: /* TROT - translate one to two [partial] */
4699 case 0xb993: /* TROO - translate one to one [partial] */
4700 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ inib
[6], &tmp
);
4701 oaddr
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
4702 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ (inib
[6] | 1), &tmp
);
4703 /* tmp is source length, we want destination length. Adjust. */
4704 if (insn
[0] == 0xb991)
4706 if (insn
[0] == 0xb992)
4708 if (record_full_arch_list_add_mem (oaddr
, tmp
))
4710 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
4712 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[6] | 1)))
4714 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[7]))
4716 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4720 case 0xb996: /* MLR - multiply logical */
4721 case 0xb997: /* DLR - divide logical */
4722 /* 32-bit gpr pair destination */
4723 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
4725 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[6] | 1)))
4729 /* 0xb99a-0xb9af unsupported, privileged, or undefined */
4730 /* 0xb9b4-0xb9bc undefined */
4732 case 0xb9bd: /* TRTRE - translate and test reverse extended [partial] */
4733 case 0xb9bf: /* TRTE - translate and test extended [partial] */
4734 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
4736 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[6] | 1)))
4738 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[7]))
4740 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4744 /* 0xb9c0-0xb9c7 undefined */
4746 case 0xb9c8: /* AHHHR - add high */
4747 case 0xb9c9: /* SHHHR - subtract high */
4748 case 0xb9ca: /* ALHHHR - add logical high */
4749 case 0xb9cb: /* SLHHHR - subtract logical high */
4750 case 0xb9d8: /* AHHLR - add high */
4751 case 0xb9d9: /* SHHLR - subtract high */
4752 case 0xb9da: /* ALHHLR - add logical high */
4753 case 0xb9db: /* SLHHLR - subtract logical high */
4754 /* 32-bit high gpr destination + flags */
4755 if (s390_record_gpr_h (gdbarch
, regcache
, inib
[6]))
4757 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4761 /* 0xb9cc undefined */
4762 /* 0xb9ce undefined */
4763 /* 0xb9d0-0xb9d7 undefined */
4764 /* 0xb9dc undefined */
4765 /* 0xb9de undefined */
4767 case 0xb9e0: /* LOCFHR - load high on condition */
4768 /* 32-bit high gpr destination */
4769 if (s390_record_gpr_h (gdbarch
, regcache
, inib
[6]))
4773 /* 0xb9e3 undefined */
4774 /* 0xb9e5 undefined */
4775 /* 0xb9ee-0xb9f1 undefined */
4776 /* 0xb9f3 undefined */
4777 /* 0xb9f5 undefined */
4778 /* 0xb9fc undefined */
4779 /* 0xb9fe -0xb9ff undefined */
4786 /* 0xb4-0xb5 undefined */
4787 /* 0xb6 privileged: STCTL - store control */
4788 /* 0xb7 privileged: LCTL - load control */
4789 /* 0xb8 undefined */
4791 case 0xba: /* CS - compare and swap */
4792 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
4793 if (record_full_arch_list_add_mem (oaddr
, 4))
4795 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
4797 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4801 case 0xbb: /* CDS - compare double and swap */
4802 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
4803 if (record_full_arch_list_add_mem (oaddr
, 8))
4805 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
4807 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[2] | 1)))
4809 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4813 /* 0xbc undefined */
4815 case 0xbe: /* STCM - store characters under mask */
4816 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
4817 if (record_full_arch_list_add_mem (oaddr
, s390_popcnt (inib
[3])))
4826 /* RIL-format instruction */
4827 switch (ibyte
[0] << 4 | inib
[3])
4829 case 0xc00: /* LARL - load address relative long */
4830 case 0xc05: /* BRASL - branch relative and save long */
4831 case 0xc09: /* IILF - insert immediate */
4832 case 0xc21: /* MSFI - multiply single immediate */
4833 case 0xc42: /* LLHRL - load logical halfword relative long */
4834 case 0xc45: /* LHRL - load halfword relative long */
4835 case 0xc4d: /* LRL - load relative long */
4836 /* 32-bit or native gpr destination */
4837 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
4841 case 0xc01: /* LGFI - load immediate */
4842 case 0xc0e: /* LLIHF - load logical immediate */
4843 case 0xc0f: /* LLILF - load logical immediate */
4844 case 0xc20: /* MSGFI - multiply single immediate */
4845 case 0xc44: /* LGHRL - load halfword relative long */
4846 case 0xc46: /* LLGHRL - load logical halfword relative long */
4847 case 0xc48: /* LGRL - load relative long */
4848 case 0xc4c: /* LGFRL - load relative long */
4849 case 0xc4e: /* LLGFRL - load logical relative long */
4850 /* 64-bit gpr destination */
4851 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
4855 /* 0xc02-0xc03 undefined */
4857 case 0xc04: /* BRCL - branch relative on condition long */
4858 case 0xc62: /* PFDRL - prefetch data relative long */
4861 case 0xc06: /* XIHF - xor immediate */
4862 case 0xc0a: /* NIHF - and immediate */
4863 case 0xc0c: /* OIHF - or immediate */
4864 case 0xcc8: /* AIH - add immediate high */
4865 case 0xcca: /* ALSIH - add logical with signed immediate high */
4866 /* 32-bit high gpr destination + flags */
4867 if (s390_record_gpr_h (gdbarch
, regcache
, inib
[2]))
4869 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4873 case 0xc07: /* XILF - xor immediate */
4874 case 0xc0b: /* NILF - and immediate */
4875 case 0xc0d: /* OILF - or immediate */
4876 case 0xc25: /* SLFI - subtract logical immediate */
4877 case 0xc29: /* AFI - add immediate */
4878 case 0xc2b: /* ALFI - add logical immediate */
4879 /* 32-bit gpr destination + flags */
4880 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
4882 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4886 case 0xc08: /* IIHF - insert immediate */
4887 case 0xcc6: /* BRCTH - branch relative on count high */
4888 case 0xccb: /* ALSIHN - add logical with signed immediate high */
4889 /* 32-bit high gpr destination */
4890 if (s390_record_gpr_h (gdbarch
, regcache
, inib
[2]))
4894 /* 0xc22-0xc23 undefined */
4896 case 0xc24: /* SLGFI - subtract logical immediate */
4897 case 0xc28: /* AGFI - add immediate */
4898 case 0xc2a: /* ALGFI - add logical immediate */
4899 /* 64-bit gpr destination + flags */
4900 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
4902 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4906 /* 0xc26-0xc27 undefined */
4908 case 0xc2c: /* CGFI - compare immediate */
4909 case 0xc2d: /* CFI - compare immediate */
4910 case 0xc2e: /* CLGFI - compare logical immediate */
4911 case 0xc2f: /* CLFI - compare logical immediate */
4912 case 0xc64: /* CGHRL - compare halfword relative long */
4913 case 0xc65: /* CHRL - compare halfword relative long */
4914 case 0xc66: /* CLGHRL - compare logical halfword relative long */
4915 case 0xc67: /* CLHRL - compare logical halfword relative long */
4916 case 0xc68: /* CGRL - compare relative long */
4917 case 0xc6a: /* CLGRL - compare logical relative long */
4918 case 0xc6c: /* CGFRL - compare relative long */
4919 case 0xc6d: /* CRL - compare relative long */
4920 case 0xc6e: /* CLGFRL - compare logical relative long */
4921 case 0xc6f: /* CLRL - compare logical relative long */
4922 case 0xccd: /* CIH - compare immediate high */
4923 case 0xccf: /* CLIH - compare logical immediate high */
4925 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4929 /* 0xc40-0xc41 undefined */
4930 /* 0xc43 undefined */
4932 case 0xc47: /* STHRL - store halfword relative long */
4933 oaddr
= s390_record_calc_rl (gdbarch
, regcache
, addr
, insn
[1], insn
[2]);
4934 if (record_full_arch_list_add_mem (oaddr
, 2))
4938 /* 0xc49-0xc4a undefined */
4940 case 0xc4b: /* STGRL - store relative long */
4941 oaddr
= s390_record_calc_rl (gdbarch
, regcache
, addr
, insn
[1], insn
[2]);
4942 if (record_full_arch_list_add_mem (oaddr
, 8))
4946 case 0xc4f: /* STRL - store relative long */
4947 oaddr
= s390_record_calc_rl (gdbarch
, regcache
, addr
, insn
[1], insn
[2]);
4948 if (record_full_arch_list_add_mem (oaddr
, 4))
4952 case 0xc60: /* EXRL - execute relative long */
4955 fprintf_unfiltered (gdb_stdlog
, "Warning: Double execute at %s.\n",
4956 paddress (gdbarch
, addr
));
4959 addr
= s390_record_calc_rl (gdbarch
, regcache
, addr
, insn
[1], insn
[2]);
4962 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ inib
[2], &tmp
);
4971 /* 0xc61 undefined */
4972 /* 0xc63 undefined */
4973 /* 0xc69 undefined */
4974 /* 0xc6b undefined */
4975 /* 0xcc0-0xcc5 undefined */
4976 /* 0xcc7 undefined */
4977 /* 0xcc9 undefined */
4978 /* 0xccc undefined */
4979 /* 0xcce undefined */
4986 /* 0xc1 undefined */
4987 /* 0xc3 undefined */
4989 case 0xc5: /* BPRP - branch prediction relative preload */
4990 case 0xc7: /* BPP - branch prediction preload */
4991 /* no visible effect */
4995 /* SSF-format instruction */
4996 switch (ibyte
[0] << 4 | inib
[3])
4998 /* 0xc80 unsupported */
5000 case 0xc81: /* ECTG - extract cpu time */
5001 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
5003 if (s390_record_gpr_g (gdbarch
, regcache
, 0))
5005 if (s390_record_gpr_g (gdbarch
, regcache
, 1))
5009 case 0xc82: /* CSST - compare and swap and store */
5012 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
, &tmp
);
5014 sc
= tmp
>> 8 & 0xff;
5016 /* First and third operands. */
5017 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
5020 case 0x00: /* 32-bit */
5021 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
5023 if (record_full_arch_list_add_mem (oaddr
, 4))
5027 case 0x01: /* 64-bit */
5028 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
5030 if (record_full_arch_list_add_mem (oaddr
, 8))
5034 case 0x02: /* 128-bit */
5035 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
5037 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2] | 1))
5039 if (record_full_arch_list_add_mem (oaddr
, 16))
5044 fprintf_unfiltered (gdb_stdlog
, "Warning: Unknown CSST FC %02x at %s.\n",
5045 fc
, paddress (gdbarch
, addr
));
5049 /* Second operand. */
5050 oaddr2
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[2], 0);
5053 fprintf_unfiltered (gdb_stdlog
, "Warning: Unknown CSST FC %02x at %s.\n",
5054 sc
, paddress (gdbarch
, addr
));
5058 if (record_full_arch_list_add_mem (oaddr2
, 1 << sc
))
5062 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5067 /* 0xc83 undefined */
5069 case 0xc84: /* LPD - load pair disjoint */
5070 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
5072 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[2] | 1)))
5074 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5078 case 0xc85: /* LPDG - load pair disjoint */
5079 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
5081 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2] | 1))
5083 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5087 /* 0xc86-0xc8f undefined */
5094 /* 0xc9-0xcb undefined */
5095 /* 0xcd-0xcf undefined */
5097 case 0xd0: /* TRTR - translate and test reversed */
5098 case 0xdd: /* TRT - translate and test */
5099 if (record_full_arch_list_add_reg (regcache
, S390_R1_REGNUM
))
5101 if (record_full_arch_list_add_reg (regcache
, S390_R2_REGNUM
))
5103 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5107 case 0xd1: /* MVN - move numbers */
5108 case 0xd2: /* MVC - move */
5109 case 0xd3: /* MVZ - move zones */
5110 case 0xdc: /* TR - translate */
5111 case 0xe8: /* MVCIN - move inverse */
5112 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
5113 if (record_full_arch_list_add_mem (oaddr
, ibyte
[1] + 1))
5117 case 0xd4: /* NC - and */
5118 case 0xd6: /* OC - or*/
5119 case 0xd7: /* XC - xor */
5120 case 0xe2: /* UNPKU - unpack unicode */
5121 case 0xea: /* UNPKA - unpack ASCII */
5122 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
5123 if (record_full_arch_list_add_mem (oaddr
, ibyte
[1] + 1))
5125 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5129 case 0xde: /* ED - edit */
5130 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
5131 if (record_full_arch_list_add_mem (oaddr
, ibyte
[1] + 1))
5133 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5135 /* DXC may be written */
5136 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
5140 case 0xdf: /* EDMK - edit and mark */
5141 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
5142 if (record_full_arch_list_add_mem (oaddr
, ibyte
[1] + 1))
5144 if (record_full_arch_list_add_reg (regcache
, S390_R1_REGNUM
))
5146 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5148 /* DXC may be written */
5149 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
5153 /* 0xd8 undefined */
5154 /* 0xd9 unsupported: MVCK - move with key */
5155 /* 0xda unsupported: MVCP - move to primary */
5156 /* 0xdb unsupported: MVCS - move to secondary */
5157 /* 0xe0 undefined */
5159 case 0xe1: /* PKU - pack unicode */
5160 case 0xe9: /* PKA - pack ASCII */
5161 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
5162 if (record_full_arch_list_add_mem (oaddr
, 16))
5171 /* RXY/RXE/RXF/RSL/RSY/SIY/V*-format instruction */
5172 switch (ibyte
[0] << 8 | ibyte
[5])
5174 /* 0xe300-0xe301 undefined */
5176 case 0xe302: /* LTG - load and test */
5177 case 0xe308: /* AG - add */
5178 case 0xe309: /* SG - subtract */
5179 case 0xe30a: /* ALG - add logical */
5180 case 0xe30b: /* SLG - subtract logical */
5181 case 0xe318: /* AGF - add */
5182 case 0xe319: /* SGF - subtract */
5183 case 0xe31a: /* ALGF - add logical */
5184 case 0xe31b: /* SLGF - subtract logical */
5185 case 0xe332: /* LTGF - load and test */
5186 case 0xe380: /* NG - and */
5187 case 0xe381: /* OG - or */
5188 case 0xe382: /* XG - xor */
5189 case 0xe388: /* ALCG - add logical with carry */
5190 case 0xe389: /* SLBG - subtract logical with borrow */
5191 case 0xeb0a: /* SRAG - shift right single */
5192 case 0xeb0b: /* SLAG - shift left single */
5193 /* 64-bit gpr destination + flags */
5194 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
5196 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5200 /* 0xe303 privileged */
5202 case 0xe304: /* LG - load */
5203 case 0xe30c: /* MSG - multiply single */
5204 case 0xe30f: /* LRVG - load reversed */
5205 case 0xe314: /* LGF - load */
5206 case 0xe315: /* LGH - load halfword */
5207 case 0xe316: /* LLGF - load logical */
5208 case 0xe317: /* LLGT - load logical thirty one bits */
5209 case 0xe31c: /* MSGF - multiply single */
5210 case 0xe32a: /* LZRG - load and zero rightmost byte */
5211 case 0xe33a: /* LLZRGF - load logical and zero rightmost byte */
5212 case 0xe33c: /* MGH - multiply halfword 64x16mem -> 64 */
5213 case 0xe346: /* BCTG - branch on count */
5214 case 0xe377: /* LGB - load byte */
5215 case 0xe390: /* LLGC - load logical character */
5216 case 0xe391: /* LLGH - load logical halfword */
5217 case 0xeb0c: /* SRLG - shift right single logical */
5218 case 0xeb0d: /* SLLG - shift left single logical */
5219 case 0xeb1c: /* RLLG - rotate left single logical */
5220 case 0xeb44: /* BXHG - branch on index high */
5221 case 0xeb45: /* BXLEG - branch on index low or equal */
5222 case 0xeb4c: /* ECAG - extract cpu attribute */
5223 case 0xebe2: /* LOCG - load on condition */
5224 /* 64-bit gpr destination */
5225 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
5229 /* 0xe305 undefined */
5231 case 0xe306: /* CVBY - convert to binary */
5232 /* 32-bit or native gpr destination + FPC (DXC write) */
5233 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
5235 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
5239 /* 0xe307 undefined */
5241 case 0xe30d: /* DSG - divide single */
5242 case 0xe31d: /* DSGF - divide single */
5243 case 0xe384: /* MG - multiply 64x64mem -> 128 */
5244 case 0xe386: /* MLG - multiply logical */
5245 case 0xe387: /* DLG - divide logical */
5246 case 0xe38f: /* LPQ - load pair from quadword */
5247 /* 64-bit gpr pair destination */
5248 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
5250 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2] | 1))
5254 case 0xe30e: /* CVBG - convert to binary */
5255 /* 64-bit gpr destination + FPC (DXC write) */
5256 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
5258 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
5262 /* 0xe310-0xe311 undefined */
5264 case 0xe312: /* LT - load and test */
5265 case 0xe338: /* AGH - add halfword to 64 bit value */
5266 case 0xe339: /* SGH - subtract halfword from 64 bit value */
5267 case 0xe353: /* MSC - multiply single 32x32mem -> 32 */
5268 case 0xe354: /* NY - and */
5269 case 0xe356: /* OY - or */
5270 case 0xe357: /* XY - xor */
5271 case 0xe35a: /* AY - add */
5272 case 0xe35b: /* SY - subtract */
5273 case 0xe35e: /* ALY - add logical */
5274 case 0xe35f: /* SLY - subtract logical */
5275 case 0xe37a: /* AHY - add halfword */
5276 case 0xe37b: /* SHY - subtract halfword */
5277 case 0xe383: /* MSGC - multiply single 64x64mem -> 64 */
5278 case 0xe398: /* ALC - add logical with carry */
5279 case 0xe399: /* SLB - subtract logical with borrow */
5280 case 0xe727: /* LCBB - load count to block bounduary */
5281 case 0xeb81: /* ICMY - insert characters under mask */
5282 case 0xebdc: /* SRAK - shift left single */
5283 case 0xebdd: /* SLAK - shift left single */
5284 /* 32/64-bit gpr destination + flags */
5285 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
5287 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5291 /* 0xe313 privileged */
5293 case 0xe31e: /* LRV - load reversed */
5294 case 0xe31f: /* LRVH - load reversed */
5295 case 0xe33b: /* LZRF - load and zero rightmost byte */
5296 case 0xe351: /* MSY - multiply single */
5297 case 0xe358: /* LY - load */
5298 case 0xe371: /* LAY - load address */
5299 case 0xe373: /* ICY - insert character */
5300 case 0xe376: /* LB - load byte */
5301 case 0xe378: /* LHY - load */
5302 case 0xe37c: /* MHY - multiply halfword */
5303 case 0xe394: /* LLC - load logical character */
5304 case 0xe395: /* LLH - load logical halfword */
5305 case 0xeb1d: /* RLL - rotate left single logical */
5306 case 0xebde: /* SRLK - shift left single logical */
5307 case 0xebdf: /* SLLK - shift left single logical */
5308 case 0xebf2: /* LOC - load on condition */
5309 /* 32-bit or native gpr destination */
5310 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
5314 case 0xe320: /* CG - compare */
5315 case 0xe321: /* CLG - compare logical */
5316 case 0xe330: /* CGF - compare */
5317 case 0xe331: /* CLGF - compare logical */
5318 case 0xe334: /* CGH - compare halfword */
5319 case 0xe355: /* CLY - compare logical */
5320 case 0xe359: /* CY - compare */
5321 case 0xe379: /* CHY - compare halfword */
5322 case 0xe3cd: /* CHF - compare high */
5323 case 0xe3cf: /* CLHF - compare logical high */
5324 case 0xeb20: /* CLMH - compare logical under mask high */
5325 case 0xeb21: /* CLMY - compare logical under mask */
5326 case 0xeb51: /* TMY - test under mask */
5327 case 0xeb55: /* CLIY - compare logical */
5328 case 0xebc0: /* TP - test decimal */
5329 case 0xed10: /* TCEB - test data class */
5330 case 0xed11: /* TCDB - test data class */
5331 case 0xed12: /* TCXB - test data class */
5332 case 0xed50: /* TDCET - test data class */
5333 case 0xed51: /* TDGET - test data group */
5334 case 0xed54: /* TDCDT - test data class */
5335 case 0xed55: /* TDGDT - test data group */
5336 case 0xed58: /* TDCXT - test data class */
5337 case 0xed59: /* TDGXT - test data group */
5339 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5343 /* 0xe322-0xe323 undefined */
5345 case 0xe324: /* STG - store */
5346 case 0xe325: /* NTSTG - nontransactional store */
5347 case 0xe326: /* CVDY - convert to decimal */
5348 case 0xe32f: /* STRVG - store reversed */
5349 case 0xebe3: /* STOCG - store on condition */
5350 case 0xed67: /* STDY - store */
5351 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, inib
[3], insn
[1], ibyte
[4]);
5352 if (record_full_arch_list_add_mem (oaddr
, 8))
5356 /* 0xe327-0xe329 undefined */
5357 /* 0xe32b-0xe32d undefined */
5359 case 0xe32e: /* CVDG - convert to decimal */
5360 case 0xe38e: /* STPQ - store pair to quadword */
5361 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, inib
[3], insn
[1], ibyte
[4]);
5362 if (record_full_arch_list_add_mem (oaddr
, 16))
5366 /* 0xe333 undefined */
5367 /* 0xe335 undefined */
5369 case 0xe336: /* PFD - prefetch data */
5372 /* 0xe337 undefined */
5373 /* 0xe33c-0xe33d undefined */
5375 case 0xe33e: /* STRV - store reversed */
5376 case 0xe350: /* STY - store */
5377 case 0xe3cb: /* STFH - store high */
5378 case 0xebe1: /* STOCFH - store high on condition */
5379 case 0xebf3: /* STOC - store on condition */
5380 case 0xed66: /* STEY - store */
5381 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, inib
[3], insn
[1], ibyte
[4]);
5382 if (record_full_arch_list_add_mem (oaddr
, 4))
5386 case 0xe33f: /* STRVH - store reversed */
5387 case 0xe370: /* STHY - store halfword */
5388 case 0xe3c7: /* STHH - store halfword high */
5389 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, inib
[3], insn
[1], ibyte
[4]);
5390 if (record_full_arch_list_add_mem (oaddr
, 2))
5394 /* 0xe340-0xe345 undefined */
5396 case 0xe347: /* BIC - branch indirect on condition */
5399 /* 0xe348-0xe34f undefined */
5400 /* 0xe352 undefined */
5402 case 0xe35c: /* MFY - multiply */
5403 case 0xe396: /* ML - multiply logical */
5404 case 0xe397: /* DL - divide logical */
5405 /* 32-bit gpr pair destination */
5406 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
5408 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[2] | 1)))
5412 /* 0xe35d undefined */
5413 /* 0xe360-0xe36f undefined */
5415 case 0xe372: /* STCY - store character */
5416 case 0xe3c3: /* STCH - store character high */
5417 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, inib
[3], insn
[1], ibyte
[4]);
5418 if (record_full_arch_list_add_mem (oaddr
, 1))
5422 /* 0xe374 undefined */
5424 case 0xe375: /* LAEY - load address extended */
5425 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
5427 if (record_full_arch_list_add_reg (regcache
, S390_A0_REGNUM
+ inib
[2]))
5431 /* 0xe37d-0xe37f undefined */
5433 case 0xe385: /* LGAT - load and trap */
5434 case 0xe39c: /* LLGTAT - load logical thirty one bits and trap */
5435 case 0xe39d: /* LLGFAT - load logical and trap */
5436 case 0xe650: /* VCVB - vector convert to binary 32 bit*/
5437 case 0xe652: /* VCVBG - vector convert to binary 64 bit*/
5438 case 0xe721: /* VLGV - vector load gr from vr element */
5439 /* 64-bit gpr destination + fpc for possible DXC write */
5440 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
5442 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
5446 /* 0xe38a-0xe38d undefined */
5447 /* 0xe392-0xe393 undefined */
5448 /* 0xe39a-0xe39b undefined */
5449 /* 0xe39e undefined */
5451 case 0xe39f: /* LAT - load and trap */
5452 /* 32-bit gpr destination + fpc for possible DXC write */
5453 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
5455 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
5459 /* 0xe3a0-0xe3bf undefined */
5461 case 0xe3c0: /* LBH - load byte high */
5462 case 0xe3c2: /* LLCH - load logical character high */
5463 case 0xe3c4: /* LHH - load halfword high */
5464 case 0xe3c6: /* LLHH - load logical halfword high */
5465 case 0xe3ca: /* LFH - load high */
5466 case 0xebe0: /* LOCFH - load high on condition */
5467 /* 32-bit high gpr destination */
5468 if (s390_record_gpr_h (gdbarch
, regcache
, inib
[2]))
5472 /* 0xe3c1 undefined */
5473 /* 0xe3c5 undefined */
5475 case 0xe3c8: /* LFHAT - load high and trap */
5476 /* 32-bit high gpr destination + fpc for possible DXC write */
5477 if (s390_record_gpr_h (gdbarch
, regcache
, inib
[2]))
5479 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
5483 /* 0xe3c9 undefined */
5484 /* 0xe3cc undefined */
5485 /* 0xe3ce undefined */
5486 /* 0xe3d0-0xe3ff undefined */
5488 case 0xe634: /* VPKZ - vector pack zoned */
5489 case 0xe635: /* VLRL - vector load rightmost with immed. length */
5490 case 0xe637: /* VLRLR - vector load rightmost with length */
5491 case 0xe649: /* VLIP - vector load immediate decimal */
5492 case 0xe700: /* VLEB - vector load element */
5493 case 0xe701: /* VLEH - vector load element */
5494 case 0xe702: /* VLEG - vector load element */
5495 case 0xe703: /* VLEF - vector load element */
5496 case 0xe704: /* VLLEZ - vector load logical element and zero */
5497 case 0xe705: /* VLREP - vector load and replicate */
5498 case 0xe706: /* VL - vector load */
5499 case 0xe707: /* VLBB - vector load to block bounduary */
5500 case 0xe712: /* VGEG - vector gather element */
5501 case 0xe713: /* VGEF - vector gather element */
5502 case 0xe722: /* VLVG - vector load vr element from gr */
5503 case 0xe730: /* VESL - vector element shift left */
5504 case 0xe733: /* VERLL - vector element rotate left logical */
5505 case 0xe737: /* VLL - vector load with length */
5506 case 0xe738: /* VESRL - vector element shift right logical */
5507 case 0xe73a: /* VESRA - vector element shift right arithmetic */
5508 case 0xe740: /* VLEIB - vector load element immediate */
5509 case 0xe741: /* VLEIH - vector load element immediate */
5510 case 0xe742: /* VLEIG - vector load element immediate */
5511 case 0xe743: /* VLEIF - vector load element immediate */
5512 case 0xe744: /* VGBM - vector generate byte mask */
5513 case 0xe745: /* VREPI - vector replicate immediate */
5514 case 0xe746: /* VGM - vector generate mask */
5515 case 0xe74d: /* VREP - vector replicate */
5516 case 0xe750: /* VPOPCT - vector population count */
5517 case 0xe752: /* VCTZ - vector count trailing zeros */
5518 case 0xe753: /* VCLZ - vector count leading zeros */
5519 case 0xe756: /* VLR - vector load */
5520 case 0xe75f: /* VSEG -vector sign extend to doubleword */
5521 case 0xe760: /* VMRL - vector merge low */
5522 case 0xe761: /* VMRH - vector merge high */
5523 case 0xe762: /* VLVGP - vector load vr from grs disjoint */
5524 case 0xe764: /* VSUM - vector sum across word */
5525 case 0xe765: /* VSUMG - vector sum across doubleword */
5526 case 0xe766: /* VCKSM - vector checksum */
5527 case 0xe767: /* VSUMQ - vector sum across quadword */
5528 case 0xe768: /* VN - vector and */
5529 case 0xe769: /* VNC - vector and with complement */
5530 case 0xe76a: /* VO - vector or */
5531 case 0xe76b: /* VNO - vector nor */
5532 case 0xe76c: /* VNX - vector not exclusive or */
5533 case 0xe76d: /* VX - vector xor */
5534 case 0xe76e: /* VNN - vector nand */
5535 case 0xe76f: /* VOC - vector or with complement */
5536 case 0xe770: /* VESLV - vector element shift left */
5537 case 0xe772: /* VERIM - vector element rotate and insert under mask */
5538 case 0xe773: /* VERLLV - vector element rotate left logical */
5539 case 0xe774: /* VSL - vector shift left */
5540 case 0xe775: /* VSLB - vector shift left by byte */
5541 case 0xe777: /* VSLDB - vector shift left double by byte */
5542 case 0xe778: /* VESRLV - vector element shift right logical */
5543 case 0xe77a: /* VESRAV - vector element shift right arithmetic */
5544 case 0xe77c: /* VSRL - vector shift right logical */
5545 case 0xe77d: /* VSRLB - vector shift right logical by byte */
5546 case 0xe77e: /* VSRA - vector shift right arithmetic */
5547 case 0xe77f: /* VSRAB - vector shift right arithmetic by byte */
5548 case 0xe784: /* VPDI - vector permute doubleword immediate */
5549 case 0xe785: /* VBPERM - vector bit permute */
5550 case 0xe78c: /* VPERM - vector permute */
5551 case 0xe78d: /* VSEL - vector select */
5552 case 0xe78e: /* VFMS - vector fp multiply and subtract */
5553 case 0xe78f: /* VFMA - vector fp multiply and add */
5554 case 0xe794: /* VPK - vector pack */
5555 case 0xe79e: /* VFNMS - vector fp negative multiply and subtract */
5556 case 0xe79f: /* VFNMA - vector fp negative multiply and add */
5557 case 0xe7a1: /* VMLH - vector multiply logical high */
5558 case 0xe7a2: /* VML - vector multiply low */
5559 case 0xe7a3: /* VMH - vector multiply high */
5560 case 0xe7a4: /* VMLE - vector multiply logical even */
5561 case 0xe7a5: /* VMLO - vector multiply logical odd */
5562 case 0xe7a6: /* VME - vector multiply even */
5563 case 0xe7a7: /* VMO - vector multiply odd */
5564 case 0xe7a9: /* VMALH - vector multiply and add logical high */
5565 case 0xe7aa: /* VMAL - vector multiply and add low */
5566 case 0xe7ab: /* VMAH - vector multiply and add high */
5567 case 0xe7ac: /* VMALE - vector multiply and add logical even */
5568 case 0xe7ad: /* VMALO - vector multiply and add logical odd */
5569 case 0xe7ae: /* VMAE - vector multiply and add even */
5570 case 0xe7af: /* VMAO - vector multiply and add odd */
5571 case 0xe7b4: /* VGFM - vector Galois field multiply sum */
5572 case 0xe7b8: /* VMSL - vector multiply sum logical */
5573 case 0xe7b9: /* VACCC - vector add with carry compute carry */
5574 case 0xe7bb: /* VAC - vector add with carry */
5575 case 0xe7bc: /* VGFMA - vector Galois field multiply sum and accumulate */
5576 case 0xe7bd: /* VSBCBI - vector subtract with borrow compute borrow indication */
5577 case 0xe7bf: /* VSBI - vector subtract with borrow indication */
5578 case 0xe7c0: /* VCLGD - vector convert to logical 64-bit */
5579 case 0xe7c1: /* VCDLG - vector convert from logical 64-bit */
5580 case 0xe7c2: /* VCGD - vector convert to fixed 64-bit */
5581 case 0xe7c3: /* VCDG - vector convert from fixed 64-bit */
5582 case 0xe7c4: /* VLDE/VFLL - vector fp load lengthened */
5583 case 0xe7c5: /* VLED/VFLR - vector fp load rounded */
5584 case 0xe7c7: /* VFI - vector load fp integer */
5585 case 0xe7cc: /* VFPSO - vector fp perform sign operation */
5586 case 0xe7ce: /* VFSQ - vector fp square root */
5587 case 0xe7d4: /* VUPLL - vector unpack logical low */
5588 case 0xe7d6: /* VUPL - vector unpack low */
5589 case 0xe7d5: /* VUPLH - vector unpack logical high */
5590 case 0xe7d7: /* VUPH - vector unpack high */
5591 case 0xe7de: /* VLC - vector load complement */
5592 case 0xe7df: /* VLP - vector load positive */
5593 case 0xe7e2: /* VFA - vector fp subtract */
5594 case 0xe7e3: /* VFA - vector fp add */
5595 case 0xe7e5: /* VFD - vector fp divide */
5596 case 0xe7e7: /* VFM - vector fp multiply */
5597 case 0xe7ee: /* VFMIN - vector fp minimum */
5598 case 0xe7ef: /* VFMAX - vector fp maximum */
5599 case 0xe7f0: /* VAVGL - vector average logical */
5600 case 0xe7f1: /* VACC - vector add and compute carry */
5601 case 0xe7f2: /* VAVG - vector average */
5602 case 0xe7f3: /* VA - vector add */
5603 case 0xe7f5: /* VSCBI - vector subtract compute borrow indication */
5604 case 0xe7f7: /* VS - vector subtract */
5605 case 0xe7fc: /* VMNL - vector minimum logical */
5606 case 0xe7fd: /* VMXL - vector maximum logical */
5607 case 0xe7fe: /* VMN - vector minimum */
5608 case 0xe7ff: /* VMX - vector maximum */
5609 /* vector destination + FPC */
5610 if (s390_record_vr (gdbarch
, regcache
, ivec
[0]))
5612 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
5616 case 0xe63d: /* VSTRL - vector store rightmost with immed. length */
5617 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
5618 if (record_full_arch_list_add_mem (oaddr
, inib
[3] + 1))
5620 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
5624 case 0xe708: /* VSTEB - vector store element */
5625 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, inib
[3], insn
[1], 0);
5626 if (record_full_arch_list_add_mem (oaddr
, 1))
5628 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
5632 case 0xe709: /* VSTEH - vector store element */
5633 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, inib
[3], insn
[1], 0);
5634 if (record_full_arch_list_add_mem (oaddr
, 2))
5636 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
5640 case 0xe70a: /* VSTEG - vector store element */
5641 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, inib
[3], insn
[1], 0);
5642 if (record_full_arch_list_add_mem (oaddr
, 8))
5644 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
5648 case 0xe70b: /* VSTEF - vector store element */
5649 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, inib
[3], insn
[1], 0);
5650 if (record_full_arch_list_add_mem (oaddr
, 4))
5652 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
5656 /* 0xe70c-0xe70d undefined */
5658 case 0xe70e: /* VST - vector store */
5659 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, inib
[3], insn
[1], 0);
5660 if (record_full_arch_list_add_mem (oaddr
, 16))
5662 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
5666 /* 0xe70f-0xe711 undefined */
5667 /* 0xe714-0xe719 undefined */
5669 case 0xe71a: /* VSCEG - vector scatter element */
5670 if (s390_record_calc_disp_vsce (gdbarch
, regcache
, ivec
[1], inib
[8], 8, insn
[1], 0, &oaddr
))
5672 if (record_full_arch_list_add_mem (oaddr
, 8))
5674 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
5678 case 0xe71b: /* VSCEF - vector scatter element */
5679 if (s390_record_calc_disp_vsce (gdbarch
, regcache
, ivec
[1], inib
[8], 4, insn
[1], 0, &oaddr
))
5681 if (record_full_arch_list_add_mem (oaddr
, 4))
5683 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
5687 /* 0xe71c-0xe720 undefined */
5688 /* 0xe723-0xe726 undefined */
5689 /* 0xe728-0xe72f undefined */
5690 /* 0xe731-0xe732 undefined */
5691 /* 0xe734-0xe735 undefined */
5693 case 0xe736: /* VLM - vector load multiple */
5694 for (i
= ivec
[0]; i
!= ivec
[1]; i
++, i
&= 0x1f)
5695 if (s390_record_vr (gdbarch
, regcache
, i
))
5697 if (s390_record_vr (gdbarch
, regcache
, ivec
[1]))
5699 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
5703 /* 0xe739 undefined */
5704 /* 0xe73b-0xe73d undefined */
5706 case 0xe73e: /* VSTM - vector store multiple */
5707 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
5708 if (ivec
[0] <= ivec
[1])
5709 n
= ivec
[1] - ivec
[0] + 1;
5711 n
= ivec
[1] + 0x20 - ivec
[0] + 1;
5712 if (record_full_arch_list_add_mem (oaddr
, n
* 16))
5714 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
5718 case 0xe63c: /* VUPKZ - vector unpack zoned */
5719 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
5720 if (record_full_arch_list_add_mem (oaddr
, (ibyte
[1] + 1) & 31))
5722 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5726 case 0xe63f: /* VSTRLR - vector store rightmost with length */
5727 case 0xe73f: /* VSTL - vector store with length */
5728 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
5729 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ inib
[3], &tmp
);
5733 if (record_full_arch_list_add_mem (oaddr
, tmp
+ 1))
5735 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
5739 /* 0xe747-0xe749 undefined */
5741 case 0xe658: /* VCVD - vector convert to decimal 32 bit */
5742 case 0xe659: /* VSRP - vector shift and round decimal */
5743 case 0xe65a: /* VCVDG - vector convert to decimal 64 bit*/
5744 case 0xe65b: /* VPSOP - vector perform sign operation decimal */
5745 case 0xe671: /* VAP - vector add decimal */
5746 case 0xe673: /* VSP - vector subtract decimal */
5747 case 0xe678: /* VMP - vector multiply decimal */
5748 case 0xe679: /* VMSP - vector multiply decimal */
5749 case 0xe67a: /* VDP - vector divide decimal */
5750 case 0xe67b: /* VRP - vector remainder decimal */
5751 case 0xe67e: /* VSDP - vector shift and divide decimal */
5752 case 0xe74a: /* VFTCI - vector fp test data class immediate */
5753 case 0xe75c: /* VISTR - vector isolate string */
5754 case 0xe780: /* VFEE - vector find element equal */
5755 case 0xe781: /* VFENE - vector find element not equal */
5756 case 0xe782: /* VFA - vector find any element equal */
5757 case 0xe78a: /* VSTRC - vector string range compare */
5758 case 0xe795: /* VPKLS - vector pack logical saturate */
5759 case 0xe797: /* VPKS - vector pack saturate */
5760 case 0xe7e8: /* VFCE - vector fp compare equal */
5761 case 0xe7ea: /* VFCHE - vector fp compare high or equal */
5762 case 0xe7eb: /* VFCH - vector fp compare high */
5763 case 0xe7f8: /* VCEQ - vector compare equal */
5764 case 0xe7f9: /* VCHL - vector compare high logical */
5765 case 0xe7fb: /* VCH - vector compare high */
5766 /* vector destination + flags + FPC */
5767 if (s390_record_vr (gdbarch
, regcache
, ivec
[0]))
5769 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5771 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
5775 case 0xe65f: /* VTP - vector test decimal */
5777 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5779 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
5783 /* 0xe74b-0xe74c undefined */
5784 /* 0xe74e-0xe74f undefined */
5785 /* 0xe751 undefined */
5786 /* 0xe754-0xe755 undefined */
5787 /* 0xe757-0xe75b undefined */
5788 /* 0xe75d-0xe75e undefined */
5789 /* 0xe763 undefined */
5790 /* 0xe771 undefined */
5791 /* 0xe776 undefined */
5792 /* 0xe779 undefined */
5793 /* 0xe77b undefined */
5794 /* 0xe783 undefined */
5795 /* 0xe786-0xe789 undefined */
5796 /* 0xe78b undefined */
5797 /* 0xe790-0xe793 undefined */
5798 /* 0xe796 undefined */
5799 /* 0xe798-0xe79d undefined */
5800 /* 0xe7a0 undefined */
5801 /* 0xe7a8 undefined */
5802 /* 0xe7b0-0xe7b3 undefined */
5803 /* 0xe7b5-0xe7b7 undefined */
5804 /* 0xe7ba undefined */
5805 /* 0xe7be undefined */
5806 /* 0xe7c6 undefined */
5807 /* 0xe7c8-0xe7c9 undefined */
5809 case 0xe677: /* VCP - vector compare decimal */
5810 case 0xe7ca: /* WFK - vector fp compare and signal scalar */
5811 case 0xe7cb: /* WFC - vector fp compare scalar */
5812 case 0xe7d8: /* VTM - vector test under mask */
5813 case 0xe7d9: /* VECL - vector element compare logical */
5814 case 0xe7db: /* VEC - vector element compare */
5815 case 0xed08: /* KEB - compare and signal */
5816 case 0xed09: /* CEB - compare */
5817 case 0xed18: /* KDB - compare and signal */
5818 case 0xed19: /* CDB - compare */
5819 /* flags + fpc only */
5820 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5822 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
5826 /* 0xe7cd undefined */
5827 /* 0xe7cf-0xe7d3 undefined */
5828 /* 0xe7da undefined */
5829 /* 0xe7dc-0xe7dd undefined */
5830 /* 0xe7e0-0xe7e1 undefined */
5831 /* 0xe7e4 undefined */
5832 /* 0xe7e6 undefined */
5833 /* 0xe7e9 undefined */
5834 /* 0xe7ec-0xe7ed undefined */
5835 /* 0xe7f4 undefined */
5836 /* 0xe7f6 undefined */
5837 /* 0xe7fa undefined */
5839 /* 0xeb00-0xeb03 undefined */
5841 case 0xeb04: /* LMG - load multiple */
5842 for (i
= inib
[2]; i
!= inib
[3]; i
++, i
&= 0xf)
5843 if (s390_record_gpr_g (gdbarch
, regcache
, i
))
5845 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[3]))
5849 /* 0xeb05-0xeb09 undefined */
5850 /* 0xeb0e undefined */
5851 /* 0xeb0f privileged: TRACG */
5852 /* 0xeb10-0xeb13 undefined */
5854 case 0xeb14: /* CSY - compare and swap */
5855 case 0xebf4: /* LAN - load and and */
5856 case 0xebf6: /* LAO - load and or */
5857 case 0xebf7: /* LAX - load and xor */
5858 case 0xebf8: /* LAA - load and add */
5859 case 0xebfa: /* LAAL - load and add logical */
5860 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], ibyte
[4]);
5861 if (record_full_arch_list_add_mem (oaddr
, 4))
5863 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
5865 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5869 /* 0xeb15-0xeb1b undefined */
5870 /* 0xeb1e-0xeb1f undefined */
5871 /* 0xeb22 undefined */
5873 case 0xeb23: /* CLT - compare logical and trap */
5874 case 0xeb2b: /* CLGT - compare logical and trap */
5875 /* fpc only - including possible DXC write for trapping insns */
5876 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
5880 case 0xeb24: /* STMG - store multiple */
5881 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], ibyte
[4]);
5882 if (inib
[2] <= inib
[3])
5883 n
= inib
[3] - inib
[2] + 1;
5885 n
= inib
[3] + 0x10 - inib
[2] + 1;
5886 if (record_full_arch_list_add_mem (oaddr
, n
* 8))
5890 /* 0xeb25 privileged */
5892 case 0xeb26: /* STMH - store multiple high */
5893 case 0xeb90: /* STMY - store multiple */
5894 case 0xeb9b: /* STAMY - store access multiple */
5895 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], ibyte
[4]);
5896 if (inib
[2] <= inib
[3])
5897 n
= inib
[3] - inib
[2] + 1;
5899 n
= inib
[3] + 0x10 - inib
[2] + 1;
5900 if (record_full_arch_list_add_mem (oaddr
, n
* 4))
5904 /* 0xeb27-0xeb2a undefined */
5906 case 0xeb2c: /* STCMH - store characters under mask */
5907 case 0xeb2d: /* STCMY - store characters under mask */
5908 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], ibyte
[4]);
5909 if (record_full_arch_list_add_mem (oaddr
, s390_popcnt (inib
[3])))
5913 /* 0xeb2e undefined */
5914 /* 0xeb2f privileged */
5916 case 0xeb30: /* CSG - compare and swap */
5917 case 0xebe4: /* LANG - load and and */
5918 case 0xebe6: /* LAOG - load and or */
5919 case 0xebe7: /* LAXG - load and xor */
5920 case 0xebe8: /* LAAG - load and add */
5921 case 0xebea: /* LAALG - load and add logical */
5922 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], ibyte
[4]);
5923 if (record_full_arch_list_add_mem (oaddr
, 8))
5925 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
5927 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5931 case 0xeb31: /* CDSY - compare double and swap */
5932 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], ibyte
[4]);
5933 if (record_full_arch_list_add_mem (oaddr
, 8))
5935 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
5937 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[2] | 1)))
5939 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5943 /* 0xeb32-0xeb3d undefined */
5945 case 0xeb3e: /* CDSG - compare double and swap */
5946 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], ibyte
[4]);
5947 if (record_full_arch_list_add_mem (oaddr
, 16))
5949 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
5951 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2] | 1))
5953 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5957 /* 0xeb3f-0xeb43 undefined */
5958 /* 0xeb46-0xeb4b undefined */
5959 /* 0xeb4d-0xeb50 undefined */
5961 case 0xeb52: /* MVIY - move */
5962 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], ibyte
[4]);
5963 if (record_full_arch_list_add_mem (oaddr
, 1))
5967 case 0xeb54: /* NIY - and */
5968 case 0xeb56: /* OIY - or */
5969 case 0xeb57: /* XIY - xor */
5970 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], ibyte
[4]);
5971 if (record_full_arch_list_add_mem (oaddr
, 1))
5973 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5977 /* 0xeb53 undefined */
5978 /* 0xeb58-0xeb69 undefined */
5980 case 0xeb6a: /* ASI - add immediate */
5981 case 0xeb6e: /* ALSI - add immediate */
5982 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], ibyte
[4]);
5983 if (record_full_arch_list_add_mem (oaddr
, 4))
5985 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5989 /* 0xeb6b-0xeb6d undefined */
5990 /* 0xeb6f-0xeb79 undefined */
5992 case 0xeb7a: /* AGSI - add immediate */
5993 case 0xeb7e: /* ALGSI - add immediate */
5994 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], ibyte
[4]);
5995 if (record_full_arch_list_add_mem (oaddr
, 8))
5997 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
6001 /* 0xeb7b-0xeb7d undefined */
6002 /* 0xeb7f undefined */
6004 case 0xeb80: /* ICMH - insert characters under mask */
6005 /* 32-bit high gpr destination + flags */
6006 if (s390_record_gpr_h (gdbarch
, regcache
, inib
[2]))
6008 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
6012 /* 0xeb82-0xeb8d undefined */
6014 case 0xeb8e: /* MVCLU - move long unicode [partial] */
6015 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ inib
[2], &tmp
);
6016 oaddr
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
6017 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ (inib
[2] | 1), &tmp
);
6018 if (record_full_arch_list_add_mem (oaddr
, tmp
))
6020 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
6022 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[2] | 1)))
6024 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[3]))
6026 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[3] | 1)))
6028 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
6032 case 0xeb8f: /* CLCLU - compare logical long unicode [partial] */
6033 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
6035 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[2] | 1)))
6037 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[3]))
6039 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[3] | 1)))
6041 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
6045 /* 0xeb91-0xeb95 undefined */
6047 case 0xeb96: /* LMH - load multiple high */
6048 for (i
= inib
[2]; i
!= inib
[3]; i
++, i
&= 0xf)
6049 if (s390_record_gpr_h (gdbarch
, regcache
, i
))
6051 if (s390_record_gpr_h (gdbarch
, regcache
, inib
[3]))
6055 /* 0xeb97 undefined */
6057 case 0xeb98: /* LMY - load multiple */
6058 for (i
= inib
[2]; i
!= inib
[3]; i
++, i
&= 0xf)
6059 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ i
))
6061 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[3]))
6065 /* 0xeb99 undefined */
6067 case 0xeb9a: /* LAMY - load access multiple */
6068 for (i
= inib
[2]; i
!= inib
[3]; i
++, i
&= 0xf)
6069 if (record_full_arch_list_add_reg (regcache
, S390_A0_REGNUM
+ i
))
6071 if (record_full_arch_list_add_reg (regcache
, S390_A0_REGNUM
+ inib
[3]))
6075 /* 0xeb9c-0xebbf undefined */
6076 /* 0xebc1-0xebdb undefined */
6077 /* 0xebe5 undefined */
6078 /* 0xebe9 undefined */
6079 /* 0xebeb-0xebf1 undefined */
6080 /* 0xebf5 undefined */
6081 /* 0xebf9 undefined */
6082 /* 0xebfb-0xebff undefined */
6084 /* 0xed00-0xed03 undefined */
6086 case 0xed04: /* LDEB - load lengthened */
6087 case 0xed0c: /* MDEB - multiply */
6088 case 0xed0d: /* DEB - divide */
6089 case 0xed14: /* SQEB - square root */
6090 case 0xed15: /* SQDB - square root */
6091 case 0xed17: /* MEEB - multiply */
6092 case 0xed1c: /* MDB - multiply */
6093 case 0xed1d: /* DDB - divide */
6094 /* float destination + fpc */
6095 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[2]))
6097 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
6101 case 0xed05: /* LXDB - load lengthened */
6102 case 0xed06: /* LXEB - load lengthened */
6103 case 0xed07: /* MXDB - multiply */
6104 /* float pair destination + fpc */
6105 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[2]))
6107 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ (inib
[2] | 2)))
6109 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
6113 case 0xed0a: /* AEB - add */
6114 case 0xed0b: /* SEB - subtract */
6115 case 0xed1a: /* ADB - add */
6116 case 0xed1b: /* SDB - subtract */
6117 /* float destination + flags + fpc */
6118 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[2]))
6120 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
6122 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
6126 case 0xed0e: /* MAEB - multiply and add */
6127 case 0xed0f: /* MSEB - multiply and subtract */
6128 case 0xed1e: /* MADB - multiply and add */
6129 case 0xed1f: /* MSDB - multiply and subtract */
6130 case 0xed40: /* SLDT - shift significand left */
6131 case 0xed41: /* SRDT - shift significand right */
6132 case 0xedaa: /* CDZT - convert from zoned */
6133 case 0xedae: /* CDPT - convert from packed */
6134 /* float destination [RXF] + fpc */
6135 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[8]))
6137 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
6141 /* 0xed13 undefined */
6142 /* 0xed16 undefined */
6143 /* 0xed20-0xed23 undefined */
6145 case 0xed24: /* LDE - load lengthened */
6146 case 0xed34: /* SQE - square root */
6147 case 0xed35: /* SQD - square root */
6148 case 0xed37: /* MEE - multiply */
6149 case 0xed64: /* LEY - load */
6150 case 0xed65: /* LDY - load */
6151 /* float destination */
6152 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[2]))
6156 case 0xed25: /* LXD - load lengthened */
6157 case 0xed26: /* LXE - load lengthened */
6158 /* float pair destination */
6159 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[2]))
6161 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ (inib
[2] | 2)))
6165 /* 0xed27-0xed2d undefined */
6167 case 0xed2e: /* MAE - multiply and add */
6168 case 0xed2f: /* MSE - multiply and subtract */
6169 case 0xed38: /* MAYL - multiply and add unnormalized */
6170 case 0xed39: /* MYL - multiply unnormalized */
6171 case 0xed3c: /* MAYH - multiply and add unnormalized */
6172 case 0xed3d: /* MYH - multiply unnormalized */
6173 case 0xed3e: /* MAD - multiply and add */
6174 case 0xed3f: /* MSD - multiply and subtract */
6175 /* float destination [RXF] */
6176 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[8]))
6180 /* 0xed30-0xed33 undefined */
6181 /* 0xed36 undefined */
6183 case 0xed3a: /* MAY - multiply and add unnormalized */
6184 case 0xed3b: /* MY - multiply unnormalized */
6185 /* float pair destination [RXF] */
6186 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[8]))
6188 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ (inib
[8] | 2)))
6192 /* 0xed42-0xed47 undefind */
6194 case 0xed48: /* SLXT - shift significand left */
6195 case 0xed49: /* SRXT - shift significand right */
6196 case 0xedab: /* CXZT - convert from zoned */
6197 case 0xedaf: /* CXPT - convert from packed */
6198 /* float pair destination [RXF] + fpc */
6199 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[8]))
6201 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ (inib
[8] | 2)))
6203 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
6207 /* 0xed4a-0xed4f undefind */
6208 /* 0xed52-0xed53 undefind */
6209 /* 0xed56-0xed57 undefind */
6210 /* 0xed5a-0xed63 undefind */
6211 /* 0xed68-0xeda7 undefined */
6213 case 0xeda8: /* CZDT - convert to zoned */
6214 case 0xeda9: /* CZXT - convert to zoned */
6215 case 0xedac: /* CPDT - convert to packed */
6216 case 0xedad: /* CPXT - convert to packed */
6217 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
6218 if (record_full_arch_list_add_mem (oaddr
, ibyte
[1] + 1))
6220 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
6224 /* 0xedb0-0xedff undefined */
6231 /* 0xe4 undefined */
6234 /* SSE/SIL-format instruction */
6237 /* 0xe500-0xe543 undefined, privileged, or unsupported */
6239 case 0xe544: /* MVHHI - move */
6240 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
6241 if (record_full_arch_list_add_mem (oaddr
, 2))
6245 /* 0xe545-0xe547 undefined */
6247 case 0xe548: /* MVGHI - move */
6248 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
6249 if (record_full_arch_list_add_mem (oaddr
, 8))
6253 /* 0xe549-0xe54b undefined */
6255 case 0xe54c: /* MVHI - move */
6256 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
6257 if (record_full_arch_list_add_mem (oaddr
, 4))
6261 /* 0xe54d-0xe553 undefined */
6263 case 0xe554: /* CHHSI - compare halfword immediate */
6264 case 0xe555: /* CLHHSI - compare logical immediate */
6265 case 0xe558: /* CGHSI - compare halfword immediate */
6266 case 0xe559: /* CLGHSI - compare logical immediate */
6267 case 0xe55c: /* CHSI - compare halfword immediate */
6268 case 0xe55d: /* CLFHSI - compare logical immediate */
6269 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
6273 /* 0xe556-0xe557 undefined */
6274 /* 0xe55a-0xe55b undefined */
6275 /* 0xe55e-0xe55f undefined */
6277 case 0xe560: /* TBEGIN - transaction begin */
6278 /* The transaction will be immediately aborted after this
6279 instruction, due to single-stepping. This instruction is
6280 only supported so that the program can fail a few times
6281 and go to the non-transactional fallback. */
6284 /* Transaction diagnostic block - user. */
6285 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
6286 if (record_full_arch_list_add_mem (oaddr
, 256))
6289 /* Transaction diagnostic block - supervisor. */
6290 if (record_full_arch_list_add_reg (regcache
, S390_TDB_DWORD0_REGNUM
))
6292 if (record_full_arch_list_add_reg (regcache
, S390_TDB_ABORT_CODE_REGNUM
))
6294 if (record_full_arch_list_add_reg (regcache
, S390_TDB_CONFLICT_TOKEN_REGNUM
))
6296 if (record_full_arch_list_add_reg (regcache
, S390_TDB_ATIA_REGNUM
))
6298 for (i
= 0; i
< 16; i
++)
6299 if (record_full_arch_list_add_reg (regcache
, S390_TDB_R0_REGNUM
+ i
))
6302 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
6306 /* 0xe561 unsupported: TBEGINC */
6307 /* 0xe562-0xe5ff undefined */
6315 /* RIE/RIS/RRS-format instruction */
6316 switch (ibyte
[0] << 8 | ibyte
[5])
6318 /* 0xec00-0xec41 undefined */
6320 case 0xec42: /* LOCHI - load halfword immediate on condition */
6321 case 0xec51: /* RISBLG - rotate then insert selected bits low */
6322 /* 32-bit or native gpr destination */
6323 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
6327 /* 0xec43 undefined */
6329 case 0xec44: /* BRXHG - branch relative on index high */
6330 case 0xec45: /* BRXLG - branch relative on index low or equal */
6331 case 0xec46: /* LOCGHI - load halfword immediate on condition */
6332 case 0xec59: /* RISBGN - rotate then insert selected bits */
6333 /* 64-bit gpr destination */
6334 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
6338 /* 0xec47-0xec4d undefined */
6340 case 0xec4e: /* LOCHHI - load halfword immediate on condition */
6341 case 0xec5d: /* RISBHG - rotate then insert selected bits high */
6342 /* 32-bit high gpr destination */
6343 if (s390_record_gpr_h (gdbarch
, regcache
, inib
[2]))
6347 /* 0xec4f-0xec50 undefined */
6348 /* 0xec52-0xec53 undefined */
6350 case 0xec54: /* RNSBG - rotate then and selected bits */
6351 case 0xec55: /* RISBG - rotate then insert selected bits */
6352 case 0xec56: /* ROSBG - rotate then or selected bits */
6353 case 0xec57: /* RXSBG - rotate then xor selected bits */
6354 case 0xecd9: /* AGHIK - add immediate */
6355 case 0xecdb: /* ALGHSIK - add logical immediate */
6356 /* 64-bit gpr destination + flags */
6357 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
6359 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
6363 /* 0xec58 undefined */
6364 /* 0xec5a-0xec5c undefined */
6365 /* 0xec5e-0xec63 undefined */
6367 case 0xec64: /* CGRJ - compare and branch relative */
6368 case 0xec65: /* CLGRJ - compare logical and branch relative */
6369 case 0xec76: /* CRJ - compare and branch relative */
6370 case 0xec77: /* CLRJ - compare logical and branch relative */
6371 case 0xec7c: /* CGIJ - compare immediate and branch relative */
6372 case 0xec7d: /* CLGIJ - compare logical immediate and branch relative */
6373 case 0xec7e: /* CIJ - compare immediate and branch relative */
6374 case 0xec7f: /* CLIJ - compare logical immediate and branch relative */
6375 case 0xece4: /* CGRB - compare and branch */
6376 case 0xece5: /* CLGRB - compare logical and branch */
6377 case 0xecf6: /* CRB - compare and branch */
6378 case 0xecf7: /* CLRB - compare logical and branch */
6379 case 0xecfc: /* CGIB - compare immediate and branch */
6380 case 0xecfd: /* CLGIB - compare logical immediate and branch */
6381 case 0xecfe: /* CIB - compare immediate and branch */
6382 case 0xecff: /* CLIB - compare logical immediate and branch */
6385 /* 0xec66-0xec6f undefined */
6387 case 0xec70: /* CGIT - compare immediate and trap */
6388 case 0xec71: /* CLGIT - compare logical immediate and trap */
6389 case 0xec72: /* CIT - compare immediate and trap */
6390 case 0xec73: /* CLFIT - compare logical immediate and trap */
6391 /* fpc only - including possible DXC write for trapping insns */
6392 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
6396 /* 0xec74-0xec75 undefined */
6397 /* 0xec78-0xec7b undefined */
6399 /* 0xec80-0xecd7 undefined */
6401 case 0xecd8: /* AHIK - add immediate */
6402 case 0xecda: /* ALHSIK - add logical immediate */
6403 /* 32-bit gpr destination + flags */
6404 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
6406 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
6410 /* 0xecdc-0xece3 undefined */
6411 /* 0xece6-0xecf5 undefined */
6412 /* 0xecf8-0xecfb undefined */
6419 case 0xee: /* PLO - perform locked operation */
6420 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
, &tmp
);
6421 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
6422 oaddr2
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[2], 0);
6425 uint8_t fc
= tmp
& 0xff;
6431 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
6434 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[3]))
6438 case 0x01: /* CLG */
6440 if (record_full_arch_list_add_mem (oaddr2
+ 0x08, 8))
6443 if (record_full_arch_list_add_mem (oaddr2
+ 0x28, 8))
6447 case 0x02: /* CLGR */
6449 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
6452 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[3]))
6456 case 0x03: /* CLX */
6458 if (record_full_arch_list_add_mem (oaddr2
+ 0x00, 16))
6461 if (record_full_arch_list_add_mem (oaddr2
+ 0x20, 16))
6465 case 0x08: /* DCS */
6467 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[3]))
6470 case 0x0c: /* CSST */
6472 if (record_full_arch_list_add_mem (oaddr2
, 4))
6476 case 0x14: /* CSTST */
6478 if (target_read_memory (oaddr2
+ 0x88, buf
, 8))
6480 oaddr3
= extract_unsigned_integer (buf
, 8, byte_order
);
6481 oaddr3
= s390_record_address_mask (gdbarch
, regcache
, oaddr3
);
6482 if (record_full_arch_list_add_mem (oaddr3
, 4))
6485 case 0x10: /* CSDST */
6487 if (target_read_memory (oaddr2
+ 0x68, buf
, 8))
6489 oaddr3
= extract_unsigned_integer (buf
, 8, byte_order
);
6490 oaddr3
= s390_record_address_mask (gdbarch
, regcache
, oaddr3
);
6491 if (record_full_arch_list_add_mem (oaddr3
, 4))
6494 if (target_read_memory (oaddr2
+ 0x48, buf
, 8))
6496 oaddr3
= extract_unsigned_integer (buf
, 8, byte_order
);
6497 oaddr3
= s390_record_address_mask (gdbarch
, regcache
, oaddr3
);
6498 if (record_full_arch_list_add_mem (oaddr3
, 4))
6504 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
6507 if (record_full_arch_list_add_mem (oaddr
, 4))
6511 case 0x09: /* DCSG */
6513 if (record_full_arch_list_add_mem (oaddr2
+ 0x28, 8))
6517 case 0x15: /* CSTSTG */
6519 if (target_read_memory (oaddr2
+ 0x88, buf
, 8))
6521 oaddr3
= extract_unsigned_integer (buf
, 8, byte_order
);
6522 oaddr3
= s390_record_address_mask (gdbarch
, regcache
, oaddr3
);
6523 if (record_full_arch_list_add_mem (oaddr3
, 8))
6526 case 0x11: /* CSDSTG */
6528 if (target_read_memory (oaddr2
+ 0x68, buf
, 8))
6530 oaddr3
= extract_unsigned_integer (buf
, 8, byte_order
);
6531 oaddr3
= s390_record_address_mask (gdbarch
, regcache
, oaddr3
);
6532 if (record_full_arch_list_add_mem (oaddr3
, 8))
6535 case 0x0d: /* CSSTG */
6538 if (target_read_memory (oaddr2
+ 0x48, buf
, 8))
6540 oaddr3
= extract_unsigned_integer (buf
, 8, byte_order
);
6541 oaddr3
= s390_record_address_mask (gdbarch
, regcache
, oaddr3
);
6542 if (record_full_arch_list_add_mem (oaddr3
, 8))
6545 case 0x05: /* CSG */
6547 if (record_full_arch_list_add_mem (oaddr2
+ 0x08, 8))
6550 if (record_full_arch_list_add_mem (oaddr
, 8))
6554 case 0x0a: /* DCSGR */
6556 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[3]))
6559 case 0x0e: /* CSSTGR */
6561 if (record_full_arch_list_add_mem (oaddr2
, 8))
6565 case 0x16: /* CSTSTGR */
6567 if (target_read_memory (oaddr2
+ 0x88, buf
, 8))
6569 oaddr3
= extract_unsigned_integer (buf
, 8, byte_order
);
6570 oaddr3
= s390_record_address_mask (gdbarch
, regcache
, oaddr3
);
6571 if (record_full_arch_list_add_mem (oaddr3
, 8))
6574 case 0x12: /* CSDSTGR */
6576 if (target_read_memory (oaddr2
+ 0x68, buf
, 8))
6578 oaddr3
= extract_unsigned_integer (buf
, 8, byte_order
);
6579 oaddr3
= s390_record_address_mask (gdbarch
, regcache
, oaddr3
);
6580 if (record_full_arch_list_add_mem (oaddr3
, 8))
6583 if (target_read_memory (oaddr2
+ 0x48, buf
, 8))
6585 oaddr3
= extract_unsigned_integer (buf
, 8, byte_order
);
6586 oaddr3
= s390_record_address_mask (gdbarch
, regcache
, oaddr3
);
6587 if (record_full_arch_list_add_mem (oaddr3
, 8))
6590 case 0x06: /* CSGR */
6593 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
6596 if (record_full_arch_list_add_mem (oaddr
, 8))
6600 case 0x0b: /* DCSX */
6602 if (record_full_arch_list_add_mem (oaddr2
+ 0x20, 16))
6606 case 0x17: /* CSTSTX */
6608 if (target_read_memory (oaddr2
+ 0x88, buf
, 8))
6610 oaddr3
= extract_unsigned_integer (buf
, 8, byte_order
);
6611 oaddr3
= s390_record_address_mask (gdbarch
, regcache
, oaddr3
);
6612 if (record_full_arch_list_add_mem (oaddr3
, 16))
6615 case 0x13: /* CSDSTX */
6617 if (target_read_memory (oaddr2
+ 0x68, buf
, 8))
6619 oaddr3
= extract_unsigned_integer (buf
, 8, byte_order
);
6620 oaddr3
= s390_record_address_mask (gdbarch
, regcache
, oaddr3
);
6621 if (record_full_arch_list_add_mem (oaddr3
, 16))
6624 case 0x0f: /* CSSTX */
6627 if (target_read_memory (oaddr2
+ 0x48, buf
, 8))
6629 oaddr3
= extract_unsigned_integer (buf
, 8, byte_order
);
6630 oaddr3
= s390_record_address_mask (gdbarch
, regcache
, oaddr3
);
6631 if (record_full_arch_list_add_mem (oaddr3
, 16))
6634 case 0x07: /* CSX */
6636 if (record_full_arch_list_add_mem (oaddr2
+ 0x00, 16))
6639 if (record_full_arch_list_add_mem (oaddr
, 16))
6644 fprintf_unfiltered (gdb_stdlog
, "Warning: Unknown PLO FC %02x at %s.\n",
6645 fc
, paddress (gdbarch
, addr
));
6649 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
6653 case 0xef: /* LMD - load multiple disjoint */
6654 for (i
= inib
[2]; i
!= inib
[3]; i
++, i
&= 0xf)
6655 if (s390_record_gpr_g (gdbarch
, regcache
, i
))
6657 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[3]))
6661 case 0xf0: /* SRP - shift and round decimal */
6662 case 0xf8: /* ZAP - zero and add */
6663 case 0xfa: /* AP - add decimal */
6664 case 0xfb: /* SP - subtract decimal */
6665 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
6666 if (record_full_arch_list_add_mem (oaddr
, inib
[2] + 1))
6668 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
6670 /* DXC may be written */
6671 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
6675 case 0xf1: /* MVO - move with offset */
6676 case 0xf2: /* PACK - pack */
6677 case 0xf3: /* UNPK - unpack */
6678 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
6679 if (record_full_arch_list_add_mem (oaddr
, inib
[2] + 1))
6683 /* 0xf4-0xf7 undefined */
6685 case 0xf9: /* CP - compare decimal */
6686 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
6688 /* DXC may be written */
6689 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
6693 case 0xfc: /* MP - multiply decimal */
6694 case 0xfd: /* DP - divide decimal */
6695 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
6696 if (record_full_arch_list_add_mem (oaddr
, inib
[2] + 1))
6698 /* DXC may be written */
6699 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
6703 /* 0xfe-0xff undefined */
6707 fprintf_unfiltered (gdb_stdlog
, "Warning: Don't know how to record %04x "
6708 "at %s.\n", insn
[0], paddress (gdbarch
, addr
));
6712 if (record_full_arch_list_add_reg (regcache
, S390_PSWA_REGNUM
))
6714 if (record_full_arch_list_add_end ())
6719 /* Miscellaneous. */
6721 /* Implement gdbarch_gcc_target_options. GCC does not know "-m32" or
6722 "-mcmodel=large". */
6725 s390_gcc_target_options (struct gdbarch
*gdbarch
)
6727 return xstrdup (gdbarch_ptr_bit (gdbarch
) == 64 ? "-m64" : "-m31");
6730 /* Implement gdbarch_gnu_triplet_regexp. Target triplets are "s390-*"
6731 for 31-bit and "s390x-*" for 64-bit, while the BFD arch name is
6732 always "s390". Note that an s390x compiler supports "-m31" as
6736 s390_gnu_triplet_regexp (struct gdbarch
*gdbarch
)
6741 /* Implementation of `gdbarch_stap_is_single_operand', as defined in
6745 s390_stap_is_single_operand (struct gdbarch
*gdbarch
, const char *s
)
6747 return ((isdigit (*s
) && s
[1] == '(' && s
[2] == '%') /* Displacement
6749 || *s
== '%' /* Register access. */
6750 || isdigit (*s
)); /* Literal number. */
6755 /* Validate the range of registers. NAMES must be known at compile time. */
6757 #define s390_validate_reg_range(feature, tdesc_data, start, names) \
6760 for (int i = 0; i < ARRAY_SIZE (names); i++) \
6761 if (!tdesc_numbered_register (feature, tdesc_data, start + i, names[i])) \
6766 /* Validate the target description. Also numbers registers contained in
6770 s390_tdesc_valid (struct gdbarch_tdep
*tdep
,
6771 struct tdesc_arch_data
*tdesc_data
)
6773 static const char *const psw
[] = {
6776 static const char *const gprs
[] = {
6777 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
6778 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
6780 static const char *const fprs
[] = {
6781 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
6782 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15"
6784 static const char *const acrs
[] = {
6785 "acr0", "acr1", "acr2", "acr3", "acr4", "acr5", "acr6", "acr7",
6786 "acr8", "acr9", "acr10", "acr11", "acr12", "acr13", "acr14", "acr15"
6788 static const char *const gprs_lower
[] = {
6789 "r0l", "r1l", "r2l", "r3l", "r4l", "r5l", "r6l", "r7l",
6790 "r8l", "r9l", "r10l", "r11l", "r12l", "r13l", "r14l", "r15l"
6792 static const char *const gprs_upper
[] = {
6793 "r0h", "r1h", "r2h", "r3h", "r4h", "r5h", "r6h", "r7h",
6794 "r8h", "r9h", "r10h", "r11h", "r12h", "r13h", "r14h", "r15h"
6796 static const char *const tdb_regs
[] = {
6797 "tdb0", "tac", "tct", "atia",
6798 "tr0", "tr1", "tr2", "tr3", "tr4", "tr5", "tr6", "tr7",
6799 "tr8", "tr9", "tr10", "tr11", "tr12", "tr13", "tr14", "tr15"
6801 static const char *const vxrs_low
[] = {
6802 "v0l", "v1l", "v2l", "v3l", "v4l", "v5l", "v6l", "v7l", "v8l",
6803 "v9l", "v10l", "v11l", "v12l", "v13l", "v14l", "v15l",
6805 static const char *const vxrs_high
[] = {
6806 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23", "v24",
6807 "v25", "v26", "v27", "v28", "v29", "v30", "v31",
6809 static const char *const gs_cb
[] = {
6810 "gsd", "gssm", "gsepla",
6812 static const char *const gs_bc
[] = {
6813 "bc_gsd", "bc_gssm", "bc_gsepla",
6816 const struct target_desc
*tdesc
= tdep
->tdesc
;
6817 const struct tdesc_feature
*feature
;
6819 if (!tdesc_has_registers (tdesc
))
6822 /* Core registers, i.e. general purpose and PSW. */
6823 feature
= tdesc_find_feature (tdesc
, "org.gnu.gdb.s390.core");
6824 if (feature
== NULL
)
6827 s390_validate_reg_range (feature
, tdesc_data
, S390_PSWM_REGNUM
, psw
);
6829 if (tdesc_unnumbered_register (feature
, "r0"))
6831 s390_validate_reg_range (feature
, tdesc_data
, S390_R0_REGNUM
, gprs
);
6835 tdep
->have_upper
= true;
6836 s390_validate_reg_range (feature
, tdesc_data
, S390_R0_REGNUM
,
6838 s390_validate_reg_range (feature
, tdesc_data
, S390_R0_UPPER_REGNUM
,
6842 /* Floating point registers. */
6843 feature
= tdesc_find_feature (tdesc
, "org.gnu.gdb.s390.fpr");
6844 if (feature
== NULL
)
6847 if (!tdesc_numbered_register (feature
, tdesc_data
, S390_FPC_REGNUM
, "fpc"))
6850 s390_validate_reg_range (feature
, tdesc_data
, S390_F0_REGNUM
, fprs
);
6852 /* Access control registers. */
6853 feature
= tdesc_find_feature (tdesc
, "org.gnu.gdb.s390.acr");
6854 if (feature
== NULL
)
6857 s390_validate_reg_range (feature
, tdesc_data
, S390_A0_REGNUM
, acrs
);
6859 /* Optional GNU/Linux-specific "registers". */
6860 feature
= tdesc_find_feature (tdesc
, "org.gnu.gdb.s390.linux");
6863 tdesc_numbered_register (feature
, tdesc_data
,
6864 S390_ORIG_R2_REGNUM
, "orig_r2");
6866 if (tdesc_numbered_register (feature
, tdesc_data
,
6867 S390_LAST_BREAK_REGNUM
, "last_break"))
6868 tdep
->have_linux_v1
= true;
6870 if (tdesc_numbered_register (feature
, tdesc_data
,
6871 S390_SYSTEM_CALL_REGNUM
, "system_call"))
6872 tdep
->have_linux_v2
= true;
6874 if (tdep
->have_linux_v2
&& !tdep
->have_linux_v1
)
6878 /* Transaction diagnostic block. */
6879 feature
= tdesc_find_feature (tdesc
, "org.gnu.gdb.s390.tdb");
6882 s390_validate_reg_range (feature
, tdesc_data
, S390_TDB_DWORD0_REGNUM
,
6884 tdep
->have_tdb
= true;
6887 /* Vector registers. */
6888 feature
= tdesc_find_feature (tdesc
, "org.gnu.gdb.s390.vx");
6891 s390_validate_reg_range (feature
, tdesc_data
, S390_V0_LOWER_REGNUM
,
6893 s390_validate_reg_range (feature
, tdesc_data
, S390_V16_REGNUM
,
6895 tdep
->have_vx
= true;
6898 /* Guarded-storage registers. */
6899 feature
= tdesc_find_feature (tdesc
, "org.gnu.gdb.s390.gs");
6902 s390_validate_reg_range (feature
, tdesc_data
, S390_GSD_REGNUM
, gs_cb
);
6903 tdep
->have_gs
= true;
6906 /* Guarded-storage broadcast control. */
6907 feature
= tdesc_find_feature (tdesc
, "org.gnu.gdb.s390.gsbc");
6912 s390_validate_reg_range (feature
, tdesc_data
, S390_BC_GSD_REGNUM
,
6919 /* Allocate and initialize new gdbarch_tdep. Caller is responsible to free
6920 memory after use. */
6922 static struct gdbarch_tdep
*
6923 s390_gdbarch_tdep_alloc ()
6925 struct gdbarch_tdep
*tdep
= XCNEW (struct gdbarch_tdep
);
6929 tdep
->abi
= ABI_NONE
;
6930 tdep
->vector_abi
= S390_VECTOR_ABI_NONE
;
6932 tdep
->gpr_full_regnum
= -1;
6933 tdep
->v0_full_regnum
= -1;
6934 tdep
->pc_regnum
= -1;
6935 tdep
->cc_regnum
= -1;
6937 tdep
->have_upper
= false;
6938 tdep
->have_linux_v1
= false;
6939 tdep
->have_linux_v2
= false;
6940 tdep
->have_tdb
= false;
6941 tdep
->have_vx
= false;
6942 tdep
->have_gs
= false;
6944 tdep
->s390_syscall_record
= NULL
;
6949 /* Set up gdbarch struct. */
6951 static struct gdbarch
*
6952 s390_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
6954 const struct target_desc
*tdesc
= info
.target_desc
;
6955 int first_pseudo_reg
, last_pseudo_reg
;
6956 static const char *const stap_register_prefixes
[] = { "%", NULL
};
6957 static const char *const stap_register_indirection_prefixes
[] = { "(",
6959 static const char *const stap_register_indirection_suffixes
[] = { ")",
6962 struct gdbarch_tdep
*tdep
= s390_gdbarch_tdep_alloc ();
6963 struct gdbarch
*gdbarch
= gdbarch_alloc (&info
, tdep
);
6964 struct tdesc_arch_data
*tdesc_data
= tdesc_data_alloc ();
6965 info
.tdesc_data
= tdesc_data
;
6967 set_gdbarch_believe_pcc_promotion (gdbarch
, 0);
6968 set_gdbarch_char_signed (gdbarch
, 0);
6970 /* S/390 GNU/Linux uses either 64-bit or 128-bit long doubles.
6971 We can safely let them default to 128-bit, since the debug info
6972 will give the size of type actually used in each case. */
6973 set_gdbarch_long_double_bit (gdbarch
, 128);
6974 set_gdbarch_long_double_format (gdbarch
, floatformats_ia64_quad
);
6976 set_gdbarch_type_align (gdbarch
, s390_type_align
);
6979 /* Amount PC must be decremented by after a breakpoint. This is
6980 often the number of bytes returned by gdbarch_breakpoint_from_pc but not
6982 set_gdbarch_decr_pc_after_break (gdbarch
, 2);
6983 set_gdbarch_breakpoint_kind_from_pc (gdbarch
, s390_breakpoint::kind_from_pc
);
6984 set_gdbarch_sw_breakpoint_from_kind (gdbarch
, s390_breakpoint::bp_from_kind
);
6986 /* Displaced stepping. */
6987 set_gdbarch_displaced_step_copy_insn (gdbarch
,
6988 s390_displaced_step_copy_insn
);
6989 set_gdbarch_displaced_step_fixup (gdbarch
, s390_displaced_step_fixup
);
6990 set_gdbarch_displaced_step_location (gdbarch
, linux_displaced_step_location
);
6991 set_gdbarch_displaced_step_hw_singlestep (gdbarch
, s390_displaced_step_hw_singlestep
);
6992 set_gdbarch_software_single_step (gdbarch
, s390_software_single_step
);
6993 set_gdbarch_max_insn_length (gdbarch
, S390_MAX_INSTR_SIZE
);
6995 /* Prologue analysis. */
6996 set_gdbarch_skip_prologue (gdbarch
, s390_skip_prologue
);
6998 /* Register handling. */
6999 set_gdbarch_num_regs (gdbarch
, S390_NUM_REGS
);
7000 set_gdbarch_sp_regnum (gdbarch
, S390_SP_REGNUM
);
7001 set_gdbarch_fp0_regnum (gdbarch
, S390_F0_REGNUM
);
7002 set_gdbarch_guess_tracepoint_registers (gdbarch
,
7003 s390_guess_tracepoint_registers
);
7004 set_gdbarch_stab_reg_to_regnum (gdbarch
, s390_dwarf_reg_to_regnum
);
7005 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, s390_dwarf_reg_to_regnum
);
7006 set_gdbarch_value_from_register (gdbarch
, s390_value_from_register
);
7008 /* Pseudo registers. */
7009 set_gdbarch_pseudo_register_read (gdbarch
, s390_pseudo_register_read
);
7010 set_gdbarch_pseudo_register_write (gdbarch
, s390_pseudo_register_write
);
7011 set_tdesc_pseudo_register_name (gdbarch
, s390_pseudo_register_name
);
7012 set_tdesc_pseudo_register_type (gdbarch
, s390_pseudo_register_type
);
7013 set_tdesc_pseudo_register_reggroup_p (gdbarch
,
7014 s390_pseudo_register_reggroup_p
);
7015 set_gdbarch_ax_pseudo_register_collect (gdbarch
,
7016 s390_ax_pseudo_register_collect
);
7017 set_gdbarch_ax_pseudo_register_push_stack
7018 (gdbarch
, s390_ax_pseudo_register_push_stack
);
7019 set_gdbarch_gen_return_address (gdbarch
, s390_gen_return_address
);
7021 /* Inferior function calls. */
7022 set_gdbarch_push_dummy_call (gdbarch
, s390_push_dummy_call
);
7023 set_gdbarch_dummy_id (gdbarch
, s390_dummy_id
);
7024 set_gdbarch_frame_align (gdbarch
, s390_frame_align
);
7025 set_gdbarch_return_value (gdbarch
, s390_return_value
);
7027 /* Frame handling. */
7028 /* Stack grows downward. */
7029 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
7030 set_gdbarch_stack_frame_destroyed_p (gdbarch
, s390_stack_frame_destroyed_p
);
7031 dwarf2_frame_set_init_reg (gdbarch
, s390_dwarf2_frame_init_reg
);
7032 dwarf2_frame_set_adjust_regnum (gdbarch
, s390_adjust_frame_regnum
);
7033 dwarf2_append_unwinders (gdbarch
);
7034 set_gdbarch_unwind_pc (gdbarch
, s390_unwind_pc
);
7035 set_gdbarch_unwind_sp (gdbarch
, s390_unwind_sp
);
7037 switch (info
.bfd_arch_info
->mach
)
7039 case bfd_mach_s390_31
:
7040 set_gdbarch_addr_bits_remove (gdbarch
, s390_addr_bits_remove
);
7043 case bfd_mach_s390_64
:
7044 set_gdbarch_long_bit (gdbarch
, 64);
7045 set_gdbarch_long_long_bit (gdbarch
, 64);
7046 set_gdbarch_ptr_bit (gdbarch
, 64);
7047 set_gdbarch_address_class_type_flags (gdbarch
,
7048 s390_address_class_type_flags
);
7049 set_gdbarch_address_class_type_flags_to_name (gdbarch
,
7050 s390_address_class_type_flags_to_name
);
7051 set_gdbarch_address_class_name_to_type_flags (gdbarch
,
7052 s390_address_class_name_to_type_flags
);
7056 /* SystemTap functions. */
7057 set_gdbarch_stap_register_prefixes (gdbarch
, stap_register_prefixes
);
7058 set_gdbarch_stap_register_indirection_prefixes (gdbarch
,
7059 stap_register_indirection_prefixes
);
7060 set_gdbarch_stap_register_indirection_suffixes (gdbarch
,
7061 stap_register_indirection_suffixes
);
7063 set_gdbarch_disassembler_options (gdbarch
, &s390_disassembler_options
);
7064 set_gdbarch_valid_disassembler_options (gdbarch
,
7065 disassembler_options_s390 ());
7067 /* Process record-replay */
7068 set_gdbarch_process_record (gdbarch
, s390_process_record
);
7070 /* Miscellaneous. */
7071 set_gdbarch_stap_is_single_operand (gdbarch
, s390_stap_is_single_operand
);
7072 set_gdbarch_gcc_target_options (gdbarch
, s390_gcc_target_options
);
7073 set_gdbarch_gnu_triplet_regexp (gdbarch
, s390_gnu_triplet_regexp
);
7075 /* Initialize the OSABI. */
7076 gdbarch_init_osabi (info
, gdbarch
);
7078 /* Always create a default tdesc. Otherwise commands like 'set osabi'
7079 cause GDB to crash with an internal error when the user tries to set
7080 an unsupported OSABI. */
7081 if (!tdesc_has_registers (tdesc
))
7083 if (info
.bfd_arch_info
->mach
== bfd_mach_s390_31
)
7084 tdesc
= tdesc_s390_linux32
;
7086 tdesc
= tdesc_s390x_linux64
;
7088 tdep
->tdesc
= tdesc
;
7090 /* Check any target description for validity. */
7091 if (!s390_tdesc_valid (tdep
, tdesc_data
))
7093 tdesc_data_cleanup (tdesc_data
);
7095 gdbarch_free (gdbarch
);
7099 /* Determine vector ABI. */
7102 && info
.abfd
!= NULL
7103 && info
.abfd
->format
== bfd_object
7104 && bfd_get_flavour (info
.abfd
) == bfd_target_elf_flavour
7105 && bfd_elf_get_obj_attr_int (info
.abfd
, OBJ_ATTR_GNU
,
7106 Tag_GNU_S390_ABI_Vector
) == 2)
7107 tdep
->vector_abi
= S390_VECTOR_ABI_128
;
7110 /* Find a candidate among extant architectures. */
7111 for (arches
= gdbarch_list_lookup_by_info (arches
, &info
);
7113 arches
= gdbarch_list_lookup_by_info (arches
->next
, &info
))
7115 struct gdbarch_tdep
*tmp
= gdbarch_tdep (arches
->gdbarch
);
7118 /* A program can 'choose' not to use the vector registers when they
7119 are present. Leading to the same tdesc but different tdep and
7120 thereby a different gdbarch. */
7121 if (tmp
->vector_abi
!= tdep
->vector_abi
)
7124 tdesc_data_cleanup (tdesc_data
);
7126 gdbarch_free (gdbarch
);
7127 return arches
->gdbarch
;
7130 tdesc_use_registers (gdbarch
, tdep
->tdesc
, tdesc_data
);
7131 set_gdbarch_register_name (gdbarch
, s390_register_name
);
7133 /* Assign pseudo register numbers. */
7134 first_pseudo_reg
= gdbarch_num_regs (gdbarch
);
7135 last_pseudo_reg
= first_pseudo_reg
;
7136 if (tdep
->have_upper
)
7138 tdep
->gpr_full_regnum
= last_pseudo_reg
;
7139 last_pseudo_reg
+= 16;
7143 tdep
->v0_full_regnum
= last_pseudo_reg
;
7144 last_pseudo_reg
+= 16;
7146 tdep
->pc_regnum
= last_pseudo_reg
++;
7147 tdep
->cc_regnum
= last_pseudo_reg
++;
7148 set_gdbarch_pc_regnum (gdbarch
, tdep
->pc_regnum
);
7149 set_gdbarch_num_pseudo_regs (gdbarch
, last_pseudo_reg
- first_pseudo_reg
);
7151 /* Frame handling. */
7152 frame_base_append_sniffer (gdbarch
, dwarf2_frame_base_sniffer
);
7153 frame_unwind_append_unwinder (gdbarch
, &s390_stub_frame_unwind
);
7154 frame_unwind_append_unwinder (gdbarch
, &s390_frame_unwind
);
7155 frame_base_set_default (gdbarch
, &s390_frame_base
);
7161 _initialize_s390_tdep (void)
7163 /* Hook us into the gdbarch mechanism. */
7164 register_gdbarch_init (bfd_arch_s390
, s390_gdbarch_init
);
7166 initialize_tdesc_s390_linux32 ();
7167 initialize_tdesc_s390x_linux64 ();