[PATCH 30/57][Arm][GAS] Add support for MVE instructions: vqmovnt, vqmovnb, vqmovunt...
[binutils-gdb.git] / gdb / s390-tdep.c
blob4b931017a8dd933a537a7bd60720f1f400c5aa9e
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/>. */
20 #include "defs.h"
22 #include "arch-utils.h"
23 #include "ax-gdb.h"
24 #include "dwarf2-frame.h"
25 #include "elf/s390.h"
26 #include "elf-bfd.h"
27 #include "frame-base.h"
28 #include "frame-unwind.h"
29 #include "gdbarch.h"
30 #include "gdbcore.h"
31 #include "infrun.h"
32 #include "linux-tdep.h"
33 #include "objfiles.h"
34 #include "osabi.h"
35 #include "record-full.h"
36 #include "regcache.h"
37 #include "reggroups.h"
38 #include "s390-tdep.h"
39 #include "target-descriptions.h"
40 #include "trad-frame.h"
41 #include "value.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;
49 /* Breakpoints. */
51 constexpr gdb_byte s390_break_insn[] = { 0x0, 0x1 };
53 typedef BP_MANIPULATION (s390_break_insn) s390_breakpoint;
55 /* Decoding S/390 instructions. */
57 /* Read a single instruction from address AT. */
59 static int
60 s390_readinstruction (bfd_byte instr[], CORE_ADDR at)
62 static int s390_instrlen[] = { 2, 4, 4, 6 };
63 int instrlen;
65 if (target_read_memory (at, &instr[0], 2))
66 return -1;
67 instrlen = s390_instrlen[instr[0] >> 6];
68 if (instrlen > 2)
70 if (target_read_memory (at + 2, &instr[2], instrlen - 2))
71 return -1;
73 return instrlen;
76 /* The functions below are for recognizing and decoding S/390
77 instructions of various formats. Each of them checks whether INSN
78 is an instruction of the given format, with the specified opcodes.
79 If it is, it sets the remaining arguments to the values of the
80 instruction's fields, and returns a non-zero value; otherwise, it
81 returns zero.
83 These functions' arguments appear in the order they appear in the
84 instruction, not in the machine-language form. So, opcodes always
85 come first, even though they're sometimes scattered around the
86 instructions. And displacements appear before base and extension
87 registers, as they do in the assembly syntax, not at the end, as
88 they do in the machine language.
90 Test for RI instruction format. */
92 static int
93 is_ri (bfd_byte *insn, int op1, int op2, unsigned int *r1, int *i2)
95 if (insn[0] == op1 && (insn[1] & 0xf) == op2)
97 *r1 = (insn[1] >> 4) & 0xf;
98 /* i2 is a 16-bit signed quantity. */
99 *i2 = (((insn[2] << 8) | insn[3]) ^ 0x8000) - 0x8000;
100 return 1;
102 else
103 return 0;
106 /* Test for RIL instruction format. See comment on is_ri for details. */
108 static int
109 is_ril (bfd_byte *insn, int op1, int op2,
110 unsigned int *r1, int *i2)
112 if (insn[0] == op1 && (insn[1] & 0xf) == op2)
114 *r1 = (insn[1] >> 4) & 0xf;
115 /* i2 is a signed quantity. If the host 'int' is 32 bits long,
116 no sign extension is necessary, but we don't want to assume
117 that. */
118 *i2 = (((insn[2] << 24)
119 | (insn[3] << 16)
120 | (insn[4] << 8)
121 | (insn[5])) ^ 0x80000000) - 0x80000000;
122 return 1;
124 else
125 return 0;
128 /* Test for RR instruction format. See comment on is_ri for details. */
130 static int
131 is_rr (bfd_byte *insn, int op, unsigned int *r1, unsigned int *r2)
133 if (insn[0] == op)
135 *r1 = (insn[1] >> 4) & 0xf;
136 *r2 = insn[1] & 0xf;
137 return 1;
139 else
140 return 0;
143 /* Test for RRE instruction format. See comment on is_ri for details. */
145 static int
146 is_rre (bfd_byte *insn, int op, unsigned int *r1, unsigned int *r2)
148 if (((insn[0] << 8) | insn[1]) == op)
150 /* Yes, insn[3]. insn[2] is unused in RRE format. */
151 *r1 = (insn[3] >> 4) & 0xf;
152 *r2 = insn[3] & 0xf;
153 return 1;
155 else
156 return 0;
159 /* Test for RS instruction format. See comment on is_ri for details. */
161 static int
162 is_rs (bfd_byte *insn, int op,
163 unsigned int *r1, unsigned int *r3, int *d2, unsigned int *b2)
165 if (insn[0] == op)
167 *r1 = (insn[1] >> 4) & 0xf;
168 *r3 = insn[1] & 0xf;
169 *b2 = (insn[2] >> 4) & 0xf;
170 *d2 = ((insn[2] & 0xf) << 8) | insn[3];
171 return 1;
173 else
174 return 0;
177 /* Test for RSY instruction format. See comment on is_ri for details. */
179 static int
180 is_rsy (bfd_byte *insn, int op1, int op2,
181 unsigned int *r1, unsigned int *r3, int *d2, unsigned int *b2)
183 if (insn[0] == op1
184 && insn[5] == op2)
186 *r1 = (insn[1] >> 4) & 0xf;
187 *r3 = insn[1] & 0xf;
188 *b2 = (insn[2] >> 4) & 0xf;
189 /* The 'long displacement' is a 20-bit signed integer. */
190 *d2 = ((((insn[2] & 0xf) << 8) | insn[3] | (insn[4] << 12))
191 ^ 0x80000) - 0x80000;
192 return 1;
194 else
195 return 0;
198 /* Test for RX instruction format. See comment on is_ri for details. */
200 static int
201 is_rx (bfd_byte *insn, int op,
202 unsigned int *r1, int *d2, unsigned int *x2, unsigned int *b2)
204 if (insn[0] == op)
206 *r1 = (insn[1] >> 4) & 0xf;
207 *x2 = insn[1] & 0xf;
208 *b2 = (insn[2] >> 4) & 0xf;
209 *d2 = ((insn[2] & 0xf) << 8) | insn[3];
210 return 1;
212 else
213 return 0;
216 /* Test for RXY instruction format. See comment on is_ri for details. */
218 static int
219 is_rxy (bfd_byte *insn, int op1, int op2,
220 unsigned int *r1, int *d2, unsigned int *x2, unsigned int *b2)
222 if (insn[0] == op1
223 && insn[5] == op2)
225 *r1 = (insn[1] >> 4) & 0xf;
226 *x2 = insn[1] & 0xf;
227 *b2 = (insn[2] >> 4) & 0xf;
228 /* The 'long displacement' is a 20-bit signed integer. */
229 *d2 = ((((insn[2] & 0xf) << 8) | insn[3] | (insn[4] << 12))
230 ^ 0x80000) - 0x80000;
231 return 1;
233 else
234 return 0;
237 /* A helper for s390_software_single_step, decides if an instruction
238 is a partial-execution instruction that needs to be executed until
239 completion when in record mode. If it is, returns 1 and writes
240 instruction length to a pointer. */
242 static int
243 s390_is_partial_instruction (struct gdbarch *gdbarch, CORE_ADDR loc, int *len)
245 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
246 uint16_t insn;
248 insn = read_memory_integer (loc, 2, byte_order);
250 switch (insn >> 8)
252 case 0xa8: /* MVCLE */
253 *len = 4;
254 return 1;
256 case 0xeb:
258 insn = read_memory_integer (loc + 4, 2, byte_order);
259 if ((insn & 0xff) == 0x8e)
261 /* MVCLU */
262 *len = 6;
263 return 1;
266 break;
269 switch (insn)
271 case 0xb255: /* MVST */
272 case 0xb263: /* CMPSC */
273 case 0xb2a5: /* TRE */
274 case 0xb2a6: /* CU21 */
275 case 0xb2a7: /* CU12 */
276 case 0xb9b0: /* CU14 */
277 case 0xb9b1: /* CU24 */
278 case 0xb9b2: /* CU41 */
279 case 0xb9b3: /* CU42 */
280 case 0xb92a: /* KMF */
281 case 0xb92b: /* KMO */
282 case 0xb92f: /* KMC */
283 case 0xb92d: /* KMCTR */
284 case 0xb92e: /* KM */
285 case 0xb93c: /* PPNO */
286 case 0xb990: /* TRTT */
287 case 0xb991: /* TRTO */
288 case 0xb992: /* TROT */
289 case 0xb993: /* TROO */
290 *len = 4;
291 return 1;
294 return 0;
297 /* Implement the "software_single_step" gdbarch method, needed to single step
298 through instructions like MVCLE in record mode, to make sure they are
299 executed to completion. Without that, record will save the full length
300 of destination buffer on every iteration, even though the CPU will only
301 process about 4kiB of it each time, leading to O(n**2) memory and time
302 complexity. */
304 static std::vector<CORE_ADDR>
305 s390_software_single_step (struct regcache *regcache)
307 struct gdbarch *gdbarch = regcache->arch ();
308 CORE_ADDR loc = regcache_read_pc (regcache);
309 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
310 int len;
311 uint16_t insn;
313 /* Special handling only if recording. */
314 if (!record_full_is_used ())
315 return {};
317 /* First, match a partial instruction. */
318 if (!s390_is_partial_instruction (gdbarch, loc, &len))
319 return {};
321 loc += len;
323 /* Second, look for a branch back to it. */
324 insn = read_memory_integer (loc, 2, byte_order);
325 if (insn != 0xa714) /* BRC with mask 1 */
326 return {};
328 insn = read_memory_integer (loc + 2, 2, byte_order);
329 if (insn != (uint16_t) -(len / 2))
330 return {};
332 loc += 4;
334 /* Found it, step past the whole thing. */
335 return {loc};
338 /* Displaced stepping. */
340 /* Return true if INSN is a non-branch RIL-b or RIL-c format
341 instruction. */
343 static int
344 is_non_branch_ril (gdb_byte *insn)
346 gdb_byte op1 = insn[0];
348 if (op1 == 0xc4)
350 gdb_byte op2 = insn[1] & 0x0f;
352 switch (op2)
354 case 0x02: /* llhrl */
355 case 0x04: /* lghrl */
356 case 0x05: /* lhrl */
357 case 0x06: /* llghrl */
358 case 0x07: /* sthrl */
359 case 0x08: /* lgrl */
360 case 0x0b: /* stgrl */
361 case 0x0c: /* lgfrl */
362 case 0x0d: /* lrl */
363 case 0x0e: /* llgfrl */
364 case 0x0f: /* strl */
365 return 1;
368 else if (op1 == 0xc6)
370 gdb_byte op2 = insn[1] & 0x0f;
372 switch (op2)
374 case 0x00: /* exrl */
375 case 0x02: /* pfdrl */
376 case 0x04: /* cghrl */
377 case 0x05: /* chrl */
378 case 0x06: /* clghrl */
379 case 0x07: /* clhrl */
380 case 0x08: /* cgrl */
381 case 0x0a: /* clgrl */
382 case 0x0c: /* cgfrl */
383 case 0x0d: /* crl */
384 case 0x0e: /* clgfrl */
385 case 0x0f: /* clrl */
386 return 1;
390 return 0;
393 typedef buf_displaced_step_closure s390_displaced_step_closure;
395 /* Implementation of gdbarch_displaced_step_copy_insn. */
397 static struct displaced_step_closure *
398 s390_displaced_step_copy_insn (struct gdbarch *gdbarch,
399 CORE_ADDR from, CORE_ADDR to,
400 struct regcache *regs)
402 size_t len = gdbarch_max_insn_length (gdbarch);
403 std::unique_ptr<s390_displaced_step_closure> closure
404 (new s390_displaced_step_closure (len));
405 gdb_byte *buf = closure->buf.data ();
407 read_memory (from, buf, len);
409 /* Adjust the displacement field of PC-relative RIL instructions,
410 except branches. The latter are handled in the fixup hook. */
411 if (is_non_branch_ril (buf))
413 LONGEST offset;
415 offset = extract_signed_integer (buf + 2, 4, BFD_ENDIAN_BIG);
416 offset = (from - to + offset * 2) / 2;
418 /* If the instruction is too far from the jump pad, punt. This
419 will usually happen with instructions in shared libraries.
420 We could probably support these by rewriting them to be
421 absolute or fully emulating them. */
422 if (offset < INT32_MIN || offset > INT32_MAX)
424 /* Let the core fall back to stepping over the breakpoint
425 in-line. */
426 if (debug_displaced)
428 fprintf_unfiltered (gdb_stdlog,
429 "displaced: can't displaced step "
430 "RIL instruction: offset %s out of range\n",
431 plongest (offset));
434 return NULL;
437 store_signed_integer (buf + 2, 4, BFD_ENDIAN_BIG, offset);
440 write_memory (to, buf, len);
442 if (debug_displaced)
444 fprintf_unfiltered (gdb_stdlog, "displaced: copy %s->%s: ",
445 paddress (gdbarch, from), paddress (gdbarch, to));
446 displaced_step_dump_bytes (gdb_stdlog, buf, len);
449 return closure.release ();
452 /* Fix up the state of registers and memory after having single-stepped
453 a displaced instruction. */
455 static void
456 s390_displaced_step_fixup (struct gdbarch *gdbarch,
457 struct displaced_step_closure *closure_,
458 CORE_ADDR from, CORE_ADDR to,
459 struct regcache *regs)
461 /* Our closure is a copy of the instruction. */
462 s390_displaced_step_closure *closure
463 = (s390_displaced_step_closure *) closure_;
464 gdb_byte *insn = closure->buf.data ();
465 static int s390_instrlen[] = { 2, 4, 4, 6 };
466 int insnlen = s390_instrlen[insn[0] >> 6];
468 /* Fields for various kinds of instructions. */
469 unsigned int b2, r1, r2, x2, r3;
470 int i2, d2;
472 /* Get current PC and addressing mode bit. */
473 CORE_ADDR pc = regcache_read_pc (regs);
474 ULONGEST amode = 0;
476 if (register_size (gdbarch, S390_PSWA_REGNUM) == 4)
478 regcache_cooked_read_unsigned (regs, S390_PSWA_REGNUM, &amode);
479 amode &= 0x80000000;
482 if (debug_displaced)
483 fprintf_unfiltered (gdb_stdlog,
484 "displaced: (s390) fixup (%s, %s) pc %s len %d amode 0x%x\n",
485 paddress (gdbarch, from), paddress (gdbarch, to),
486 paddress (gdbarch, pc), insnlen, (int) amode);
488 /* Handle absolute branch and save instructions. */
489 if (is_rr (insn, op_basr, &r1, &r2)
490 || is_rx (insn, op_bas, &r1, &d2, &x2, &b2))
492 /* Recompute saved return address in R1. */
493 regcache_cooked_write_unsigned (regs, S390_R0_REGNUM + r1,
494 amode | (from + insnlen));
495 /* Update PC iff the instruction doesn't actually branch. */
496 if (insn[0] == op_basr && r2 == 0)
497 regcache_write_pc (regs, from + insnlen);
500 /* Handle absolute branch instructions. */
501 else if (is_rr (insn, op_bcr, &r1, &r2)
502 || is_rx (insn, op_bc, &r1, &d2, &x2, &b2)
503 || is_rr (insn, op_bctr, &r1, &r2)
504 || is_rre (insn, op_bctgr, &r1, &r2)
505 || is_rx (insn, op_bct, &r1, &d2, &x2, &b2)
506 || is_rxy (insn, op1_bctg, op2_brctg, &r1, &d2, &x2, &b2)
507 || is_rs (insn, op_bxh, &r1, &r3, &d2, &b2)
508 || is_rsy (insn, op1_bxhg, op2_bxhg, &r1, &r3, &d2, &b2)
509 || is_rs (insn, op_bxle, &r1, &r3, &d2, &b2)
510 || is_rsy (insn, op1_bxleg, op2_bxleg, &r1, &r3, &d2, &b2))
512 /* Update PC iff branch was *not* taken. */
513 if (pc == to + insnlen)
514 regcache_write_pc (regs, from + insnlen);
517 /* Handle PC-relative branch and save instructions. */
518 else if (is_ri (insn, op1_bras, op2_bras, &r1, &i2)
519 || is_ril (insn, op1_brasl, op2_brasl, &r1, &i2))
521 /* Update PC. */
522 regcache_write_pc (regs, pc - to + from);
523 /* Recompute saved return address in R1. */
524 regcache_cooked_write_unsigned (regs, S390_R0_REGNUM + r1,
525 amode | (from + insnlen));
528 /* Handle LOAD ADDRESS RELATIVE LONG. */
529 else if (is_ril (insn, op1_larl, op2_larl, &r1, &i2))
531 /* Update PC. */
532 regcache_write_pc (regs, from + insnlen);
533 /* Recompute output address in R1. */
534 regcache_cooked_write_unsigned (regs, S390_R0_REGNUM + r1,
535 amode | (from + i2 * 2));
538 /* If we executed a breakpoint instruction, point PC right back at it. */
539 else if (insn[0] == 0x0 && insn[1] == 0x1)
540 regcache_write_pc (regs, from);
542 /* For any other insn, adjust PC by negated displacement. PC then
543 points right after the original instruction, except for PC-relative
544 branches, where it points to the adjusted branch target. */
545 else
546 regcache_write_pc (regs, pc - to + from);
548 if (debug_displaced)
549 fprintf_unfiltered (gdb_stdlog,
550 "displaced: (s390) pc is now %s\n",
551 paddress (gdbarch, regcache_read_pc (regs)));
554 /* Implement displaced_step_hw_singlestep gdbarch method. */
556 static int
557 s390_displaced_step_hw_singlestep (struct gdbarch *gdbarch,
558 struct displaced_step_closure *closure)
560 return 1;
563 /* Prologue analysis. */
565 struct s390_prologue_data {
567 /* The stack. */
568 struct pv_area *stack;
570 /* The size and byte-order of a GPR or FPR. */
571 int gpr_size;
572 int fpr_size;
573 enum bfd_endian byte_order;
575 /* The general-purpose registers. */
576 pv_t gpr[S390_NUM_GPRS];
578 /* The floating-point registers. */
579 pv_t fpr[S390_NUM_FPRS];
581 /* The offset relative to the CFA where the incoming GPR N was saved
582 by the function prologue. 0 if not saved or unknown. */
583 int gpr_slot[S390_NUM_GPRS];
585 /* Likewise for FPRs. */
586 int fpr_slot[S390_NUM_FPRS];
588 /* Nonzero if the backchain was saved. This is assumed to be the
589 case when the incoming SP is saved at the current SP location. */
590 int back_chain_saved_p;
593 /* Return the effective address for an X-style instruction, like:
595 L R1, D2(X2, B2)
597 Here, X2 and B2 are registers, and D2 is a signed 20-bit
598 constant; the effective address is the sum of all three. If either
599 X2 or B2 are zero, then it doesn't contribute to the sum --- this
600 means that r0 can't be used as either X2 or B2. */
602 static pv_t
603 s390_addr (struct s390_prologue_data *data,
604 int d2, unsigned int x2, unsigned int b2)
606 pv_t result;
608 result = pv_constant (d2);
609 if (x2)
610 result = pv_add (result, data->gpr[x2]);
611 if (b2)
612 result = pv_add (result, data->gpr[b2]);
614 return result;
617 /* Do a SIZE-byte store of VALUE to D2(X2,B2). */
619 static void
620 s390_store (struct s390_prologue_data *data,
621 int d2, unsigned int x2, unsigned int b2, CORE_ADDR size,
622 pv_t value)
624 pv_t addr = s390_addr (data, d2, x2, b2);
625 pv_t offset;
627 /* Check whether we are storing the backchain. */
628 offset = pv_subtract (data->gpr[S390_SP_REGNUM - S390_R0_REGNUM], addr);
630 if (pv_is_constant (offset) && offset.k == 0)
631 if (size == data->gpr_size
632 && pv_is_register_k (value, S390_SP_REGNUM, 0))
634 data->back_chain_saved_p = 1;
635 return;
638 /* Check whether we are storing a register into the stack. */
639 if (!data->stack->store_would_trash (addr))
640 data->stack->store (addr, size, value);
642 /* Note: If this is some store we cannot identify, you might think we
643 should forget our cached values, as any of those might have been hit.
645 However, we make the assumption that the register save areas are only
646 ever stored to once in any given function, and we do recognize these
647 stores. Thus every store we cannot recognize does not hit our data. */
650 /* Do a SIZE-byte load from D2(X2,B2). */
652 static pv_t
653 s390_load (struct s390_prologue_data *data,
654 int d2, unsigned int x2, unsigned int b2, CORE_ADDR size)
657 pv_t addr = s390_addr (data, d2, x2, b2);
659 /* If it's a load from an in-line constant pool, then we can
660 simulate that, under the assumption that the code isn't
661 going to change between the time the processor actually
662 executed it creating the current frame, and the time when
663 we're analyzing the code to unwind past that frame. */
664 if (pv_is_constant (addr))
666 struct target_section *secp;
667 secp = target_section_by_addr (current_top_target (), addr.k);
668 if (secp != NULL
669 && (bfd_get_section_flags (secp->the_bfd_section->owner,
670 secp->the_bfd_section)
671 & SEC_READONLY))
672 return pv_constant (read_memory_integer (addr.k, size,
673 data->byte_order));
676 /* Check whether we are accessing one of our save slots. */
677 return data->stack->fetch (addr, size);
680 /* Function for finding saved registers in a 'struct pv_area'; we pass
681 this to pv_area::scan.
683 If VALUE is a saved register, ADDR says it was saved at a constant
684 offset from the frame base, and SIZE indicates that the whole
685 register was saved, record its offset in the reg_offset table in
686 PROLOGUE_UNTYPED. */
688 static void
689 s390_check_for_saved (void *data_untyped, pv_t addr,
690 CORE_ADDR size, pv_t value)
692 struct s390_prologue_data *data = (struct s390_prologue_data *) data_untyped;
693 int i, offset;
695 if (!pv_is_register (addr, S390_SP_REGNUM))
696 return;
698 offset = 16 * data->gpr_size + 32 - addr.k;
700 /* If we are storing the original value of a register, we want to
701 record the CFA offset. If the same register is stored multiple
702 times, the stack slot with the highest address counts. */
704 for (i = 0; i < S390_NUM_GPRS; i++)
705 if (size == data->gpr_size
706 && pv_is_register_k (value, S390_R0_REGNUM + i, 0))
707 if (data->gpr_slot[i] == 0
708 || data->gpr_slot[i] > offset)
710 data->gpr_slot[i] = offset;
711 return;
714 for (i = 0; i < S390_NUM_FPRS; i++)
715 if (size == data->fpr_size
716 && pv_is_register_k (value, S390_F0_REGNUM + i, 0))
717 if (data->fpr_slot[i] == 0
718 || data->fpr_slot[i] > offset)
720 data->fpr_slot[i] = offset;
721 return;
725 /* Analyze the prologue of the function starting at START_PC, continuing at
726 most until CURRENT_PC. Initialize DATA to hold all information we find
727 out about the state of the registers and stack slots. Return the address
728 of the instruction after the last one that changed the SP, FP, or back
729 chain; or zero on error. */
731 static CORE_ADDR
732 s390_analyze_prologue (struct gdbarch *gdbarch,
733 CORE_ADDR start_pc,
734 CORE_ADDR current_pc,
735 struct s390_prologue_data *data)
737 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
739 /* Our return value:
740 The address of the instruction after the last one that changed
741 the SP, FP, or back chain; zero if we got an error trying to
742 read memory. */
743 CORE_ADDR result = start_pc;
745 /* The current PC for our abstract interpretation. */
746 CORE_ADDR pc;
748 /* The address of the next instruction after that. */
749 CORE_ADDR next_pc;
751 pv_area stack (S390_SP_REGNUM, gdbarch_addr_bit (gdbarch));
752 scoped_restore restore_stack = make_scoped_restore (&data->stack, &stack);
754 /* Set up everything's initial value. */
756 int i;
758 /* For the purpose of prologue tracking, we consider the GPR size to
759 be equal to the ABI word size, even if it is actually larger
760 (i.e. when running a 32-bit binary under a 64-bit kernel). */
761 data->gpr_size = word_size;
762 data->fpr_size = 8;
763 data->byte_order = gdbarch_byte_order (gdbarch);
765 for (i = 0; i < S390_NUM_GPRS; i++)
766 data->gpr[i] = pv_register (S390_R0_REGNUM + i, 0);
768 for (i = 0; i < S390_NUM_FPRS; i++)
769 data->fpr[i] = pv_register (S390_F0_REGNUM + i, 0);
771 for (i = 0; i < S390_NUM_GPRS; i++)
772 data->gpr_slot[i] = 0;
774 for (i = 0; i < S390_NUM_FPRS; i++)
775 data->fpr_slot[i] = 0;
777 data->back_chain_saved_p = 0;
780 /* Start interpreting instructions, until we hit the frame's
781 current PC or the first branch instruction. */
782 for (pc = start_pc; pc > 0 && pc < current_pc; pc = next_pc)
784 bfd_byte insn[S390_MAX_INSTR_SIZE];
785 int insn_len = s390_readinstruction (insn, pc);
787 bfd_byte dummy[S390_MAX_INSTR_SIZE] = { 0 };
788 bfd_byte *insn32 = word_size == 4 ? insn : dummy;
789 bfd_byte *insn64 = word_size == 8 ? insn : dummy;
791 /* Fields for various kinds of instructions. */
792 unsigned int b2, r1, r2, x2, r3;
793 int i2, d2;
795 /* The values of SP and FP before this instruction,
796 for detecting instructions that change them. */
797 pv_t pre_insn_sp, pre_insn_fp;
798 /* Likewise for the flag whether the back chain was saved. */
799 int pre_insn_back_chain_saved_p;
801 /* If we got an error trying to read the instruction, report it. */
802 if (insn_len < 0)
804 result = 0;
805 break;
808 next_pc = pc + insn_len;
810 pre_insn_sp = data->gpr[S390_SP_REGNUM - S390_R0_REGNUM];
811 pre_insn_fp = data->gpr[S390_FRAME_REGNUM - S390_R0_REGNUM];
812 pre_insn_back_chain_saved_p = data->back_chain_saved_p;
814 /* LHI r1, i2 --- load halfword immediate. */
815 /* LGHI r1, i2 --- load halfword immediate (64-bit version). */
816 /* LGFI r1, i2 --- load fullword immediate. */
817 if (is_ri (insn32, op1_lhi, op2_lhi, &r1, &i2)
818 || is_ri (insn64, op1_lghi, op2_lghi, &r1, &i2)
819 || is_ril (insn, op1_lgfi, op2_lgfi, &r1, &i2))
820 data->gpr[r1] = pv_constant (i2);
822 /* LR r1, r2 --- load from register. */
823 /* LGR r1, r2 --- load from register (64-bit version). */
824 else if (is_rr (insn32, op_lr, &r1, &r2)
825 || is_rre (insn64, op_lgr, &r1, &r2))
826 data->gpr[r1] = data->gpr[r2];
828 /* L r1, d2(x2, b2) --- load. */
829 /* LY r1, d2(x2, b2) --- load (long-displacement version). */
830 /* LG r1, d2(x2, b2) --- load (64-bit version). */
831 else if (is_rx (insn32, op_l, &r1, &d2, &x2, &b2)
832 || is_rxy (insn32, op1_ly, op2_ly, &r1, &d2, &x2, &b2)
833 || is_rxy (insn64, op1_lg, op2_lg, &r1, &d2, &x2, &b2))
834 data->gpr[r1] = s390_load (data, d2, x2, b2, data->gpr_size);
836 /* ST r1, d2(x2, b2) --- store. */
837 /* STY r1, d2(x2, b2) --- store (long-displacement version). */
838 /* STG r1, d2(x2, b2) --- store (64-bit version). */
839 else if (is_rx (insn32, op_st, &r1, &d2, &x2, &b2)
840 || is_rxy (insn32, op1_sty, op2_sty, &r1, &d2, &x2, &b2)
841 || is_rxy (insn64, op1_stg, op2_stg, &r1, &d2, &x2, &b2))
842 s390_store (data, d2, x2, b2, data->gpr_size, data->gpr[r1]);
844 /* STD r1, d2(x2,b2) --- store floating-point register. */
845 else if (is_rx (insn, op_std, &r1, &d2, &x2, &b2))
846 s390_store (data, d2, x2, b2, data->fpr_size, data->fpr[r1]);
848 /* STM r1, r3, d2(b2) --- store multiple. */
849 /* STMY r1, r3, d2(b2) --- store multiple (long-displacement
850 version). */
851 /* STMG r1, r3, d2(b2) --- store multiple (64-bit version). */
852 else if (is_rs (insn32, op_stm, &r1, &r3, &d2, &b2)
853 || is_rsy (insn32, op1_stmy, op2_stmy, &r1, &r3, &d2, &b2)
854 || is_rsy (insn64, op1_stmg, op2_stmg, &r1, &r3, &d2, &b2))
856 for (; r1 <= r3; r1++, d2 += data->gpr_size)
857 s390_store (data, d2, 0, b2, data->gpr_size, data->gpr[r1]);
860 /* AHI r1, i2 --- add halfword immediate. */
861 /* AGHI r1, i2 --- add halfword immediate (64-bit version). */
862 /* AFI r1, i2 --- add fullword immediate. */
863 /* AGFI r1, i2 --- add fullword immediate (64-bit version). */
864 else if (is_ri (insn32, op1_ahi, op2_ahi, &r1, &i2)
865 || is_ri (insn64, op1_aghi, op2_aghi, &r1, &i2)
866 || is_ril (insn32, op1_afi, op2_afi, &r1, &i2)
867 || is_ril (insn64, op1_agfi, op2_agfi, &r1, &i2))
868 data->gpr[r1] = pv_add_constant (data->gpr[r1], i2);
870 /* ALFI r1, i2 --- add logical immediate. */
871 /* ALGFI r1, i2 --- add logical immediate (64-bit version). */
872 else if (is_ril (insn32, op1_alfi, op2_alfi, &r1, &i2)
873 || is_ril (insn64, op1_algfi, op2_algfi, &r1, &i2))
874 data->gpr[r1] = pv_add_constant (data->gpr[r1],
875 (CORE_ADDR)i2 & 0xffffffff);
877 /* AR r1, r2 -- add register. */
878 /* AGR r1, r2 -- add register (64-bit version). */
879 else if (is_rr (insn32, op_ar, &r1, &r2)
880 || is_rre (insn64, op_agr, &r1, &r2))
881 data->gpr[r1] = pv_add (data->gpr[r1], data->gpr[r2]);
883 /* A r1, d2(x2, b2) -- add. */
884 /* AY r1, d2(x2, b2) -- add (long-displacement version). */
885 /* AG r1, d2(x2, b2) -- add (64-bit version). */
886 else if (is_rx (insn32, op_a, &r1, &d2, &x2, &b2)
887 || is_rxy (insn32, op1_ay, op2_ay, &r1, &d2, &x2, &b2)
888 || is_rxy (insn64, op1_ag, op2_ag, &r1, &d2, &x2, &b2))
889 data->gpr[r1] = pv_add (data->gpr[r1],
890 s390_load (data, d2, x2, b2, data->gpr_size));
892 /* SLFI r1, i2 --- subtract logical immediate. */
893 /* SLGFI r1, i2 --- subtract logical immediate (64-bit version). */
894 else if (is_ril (insn32, op1_slfi, op2_slfi, &r1, &i2)
895 || is_ril (insn64, op1_slgfi, op2_slgfi, &r1, &i2))
896 data->gpr[r1] = pv_add_constant (data->gpr[r1],
897 -((CORE_ADDR)i2 & 0xffffffff));
899 /* SR r1, r2 -- subtract register. */
900 /* SGR r1, r2 -- subtract register (64-bit version). */
901 else if (is_rr (insn32, op_sr, &r1, &r2)
902 || is_rre (insn64, op_sgr, &r1, &r2))
903 data->gpr[r1] = pv_subtract (data->gpr[r1], data->gpr[r2]);
905 /* S r1, d2(x2, b2) -- subtract. */
906 /* SY r1, d2(x2, b2) -- subtract (long-displacement version). */
907 /* SG r1, d2(x2, b2) -- subtract (64-bit version). */
908 else if (is_rx (insn32, op_s, &r1, &d2, &x2, &b2)
909 || is_rxy (insn32, op1_sy, op2_sy, &r1, &d2, &x2, &b2)
910 || is_rxy (insn64, op1_sg, op2_sg, &r1, &d2, &x2, &b2))
911 data->gpr[r1] = pv_subtract (data->gpr[r1],
912 s390_load (data, d2, x2, b2, data->gpr_size));
914 /* LA r1, d2(x2, b2) --- load address. */
915 /* LAY r1, d2(x2, b2) --- load address (long-displacement version). */
916 else if (is_rx (insn, op_la, &r1, &d2, &x2, &b2)
917 || is_rxy (insn, op1_lay, op2_lay, &r1, &d2, &x2, &b2))
918 data->gpr[r1] = s390_addr (data, d2, x2, b2);
920 /* LARL r1, i2 --- load address relative long. */
921 else if (is_ril (insn, op1_larl, op2_larl, &r1, &i2))
922 data->gpr[r1] = pv_constant (pc + i2 * 2);
924 /* BASR r1, 0 --- branch and save.
925 Since r2 is zero, this saves the PC in r1, but doesn't branch. */
926 else if (is_rr (insn, op_basr, &r1, &r2)
927 && r2 == 0)
928 data->gpr[r1] = pv_constant (next_pc);
930 /* BRAS r1, i2 --- branch relative and save. */
931 else if (is_ri (insn, op1_bras, op2_bras, &r1, &i2))
933 data->gpr[r1] = pv_constant (next_pc);
934 next_pc = pc + i2 * 2;
936 /* We'd better not interpret any backward branches. We'll
937 never terminate. */
938 if (next_pc <= pc)
939 break;
942 /* BRC/BRCL -- branch relative on condition. Ignore "branch
943 never", branch to following instruction, and "conditional
944 trap" (BRC +2). Otherwise terminate search. */
945 else if (is_ri (insn, op1_brc, op2_brc, &r1, &i2))
947 if (r1 != 0 && i2 != 1 && i2 != 2)
948 break;
950 else if (is_ril (insn, op1_brcl, op2_brcl, &r1, &i2))
952 if (r1 != 0 && i2 != 3)
953 break;
956 /* Terminate search when hitting any other branch instruction. */
957 else if (is_rr (insn, op_basr, &r1, &r2)
958 || is_rx (insn, op_bas, &r1, &d2, &x2, &b2)
959 || is_rr (insn, op_bcr, &r1, &r2)
960 || is_rx (insn, op_bc, &r1, &d2, &x2, &b2)
961 || is_ril (insn, op1_brasl, op2_brasl, &r2, &i2))
962 break;
964 else
966 /* An instruction we don't know how to simulate. The only
967 safe thing to do would be to set every value we're tracking
968 to 'unknown'. Instead, we'll be optimistic: we assume that
969 we *can* interpret every instruction that the compiler uses
970 to manipulate any of the data we're interested in here --
971 then we can just ignore anything else. */
974 /* Record the address after the last instruction that changed
975 the FP, SP, or backlink. Ignore instructions that changed
976 them back to their original values --- those are probably
977 restore instructions. (The back chain is never restored,
978 just popped.) */
980 pv_t sp = data->gpr[S390_SP_REGNUM - S390_R0_REGNUM];
981 pv_t fp = data->gpr[S390_FRAME_REGNUM - S390_R0_REGNUM];
983 if ((! pv_is_identical (pre_insn_sp, sp)
984 && ! pv_is_register_k (sp, S390_SP_REGNUM, 0)
985 && sp.kind != pvk_unknown)
986 || (! pv_is_identical (pre_insn_fp, fp)
987 && ! pv_is_register_k (fp, S390_FRAME_REGNUM, 0)
988 && fp.kind != pvk_unknown)
989 || pre_insn_back_chain_saved_p != data->back_chain_saved_p)
990 result = next_pc;
994 /* Record where all the registers were saved. */
995 data->stack->scan (s390_check_for_saved, data);
997 return result;
1000 /* Advance PC across any function entry prologue instructions to reach
1001 some "real" code. */
1003 static CORE_ADDR
1004 s390_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
1006 struct s390_prologue_data data;
1007 CORE_ADDR skip_pc, func_addr;
1009 if (find_pc_partial_function (pc, NULL, &func_addr, NULL))
1011 CORE_ADDR post_prologue_pc
1012 = skip_prologue_using_sal (gdbarch, func_addr);
1013 if (post_prologue_pc != 0)
1014 return std::max (pc, post_prologue_pc);
1017 skip_pc = s390_analyze_prologue (gdbarch, pc, (CORE_ADDR)-1, &data);
1018 return skip_pc ? skip_pc : pc;
1021 /* Register handling. */
1023 /* ABI call-saved register information. */
1025 static int
1026 s390_register_call_saved (struct gdbarch *gdbarch, int regnum)
1028 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1030 switch (tdep->abi)
1032 case ABI_LINUX_S390:
1033 if ((regnum >= S390_R6_REGNUM && regnum <= S390_R15_REGNUM)
1034 || regnum == S390_F4_REGNUM || regnum == S390_F6_REGNUM
1035 || regnum == S390_A0_REGNUM)
1036 return 1;
1038 break;
1040 case ABI_LINUX_ZSERIES:
1041 if ((regnum >= S390_R6_REGNUM && regnum <= S390_R15_REGNUM)
1042 || (regnum >= S390_F8_REGNUM && regnum <= S390_F15_REGNUM)
1043 || (regnum >= S390_A0_REGNUM && regnum <= S390_A1_REGNUM))
1044 return 1;
1046 break;
1049 return 0;
1052 /* The "guess_tracepoint_registers" gdbarch method. */
1054 static void
1055 s390_guess_tracepoint_registers (struct gdbarch *gdbarch,
1056 struct regcache *regcache,
1057 CORE_ADDR addr)
1059 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1060 int sz = register_size (gdbarch, S390_PSWA_REGNUM);
1061 gdb_byte *reg = (gdb_byte *) alloca (sz);
1062 ULONGEST pswm, pswa;
1064 /* Set PSWA from the location and a default PSWM (the only part we're
1065 unlikely to get right is the CC). */
1066 if (tdep->abi == ABI_LINUX_S390)
1068 /* 31-bit PSWA needs high bit set (it's very unlikely the target
1069 was in 24-bit mode). */
1070 pswa = addr | 0x80000000UL;
1071 pswm = 0x070d0000UL;
1073 else
1075 pswa = addr;
1076 pswm = 0x0705000180000000ULL;
1079 store_unsigned_integer (reg, sz, gdbarch_byte_order (gdbarch), pswa);
1080 regcache->raw_supply (S390_PSWA_REGNUM, reg);
1082 store_unsigned_integer (reg, sz, gdbarch_byte_order (gdbarch), pswm);
1083 regcache->raw_supply (S390_PSWM_REGNUM, reg);
1086 /* Return the name of register REGNO. Return the empty string for
1087 registers that shouldn't be visible. */
1089 static const char *
1090 s390_register_name (struct gdbarch *gdbarch, int regnum)
1092 if (regnum >= S390_V0_LOWER_REGNUM
1093 && regnum <= S390_V15_LOWER_REGNUM)
1094 return "";
1095 return tdesc_register_name (gdbarch, regnum);
1098 /* DWARF Register Mapping. */
1100 static const short s390_dwarf_regmap[] =
1102 /* 0-15: General Purpose Registers. */
1103 S390_R0_REGNUM, S390_R1_REGNUM, S390_R2_REGNUM, S390_R3_REGNUM,
1104 S390_R4_REGNUM, S390_R5_REGNUM, S390_R6_REGNUM, S390_R7_REGNUM,
1105 S390_R8_REGNUM, S390_R9_REGNUM, S390_R10_REGNUM, S390_R11_REGNUM,
1106 S390_R12_REGNUM, S390_R13_REGNUM, S390_R14_REGNUM, S390_R15_REGNUM,
1108 /* 16-31: Floating Point Registers / Vector Registers 0-15. */
1109 S390_F0_REGNUM, S390_F2_REGNUM, S390_F4_REGNUM, S390_F6_REGNUM,
1110 S390_F1_REGNUM, S390_F3_REGNUM, S390_F5_REGNUM, S390_F7_REGNUM,
1111 S390_F8_REGNUM, S390_F10_REGNUM, S390_F12_REGNUM, S390_F14_REGNUM,
1112 S390_F9_REGNUM, S390_F11_REGNUM, S390_F13_REGNUM, S390_F15_REGNUM,
1114 /* 32-47: Control Registers (not mapped). */
1115 -1, -1, -1, -1, -1, -1, -1, -1,
1116 -1, -1, -1, -1, -1, -1, -1, -1,
1118 /* 48-63: Access Registers. */
1119 S390_A0_REGNUM, S390_A1_REGNUM, S390_A2_REGNUM, S390_A3_REGNUM,
1120 S390_A4_REGNUM, S390_A5_REGNUM, S390_A6_REGNUM, S390_A7_REGNUM,
1121 S390_A8_REGNUM, S390_A9_REGNUM, S390_A10_REGNUM, S390_A11_REGNUM,
1122 S390_A12_REGNUM, S390_A13_REGNUM, S390_A14_REGNUM, S390_A15_REGNUM,
1124 /* 64-65: Program Status Word. */
1125 S390_PSWM_REGNUM,
1126 S390_PSWA_REGNUM,
1128 /* 66-67: Reserved. */
1129 -1, -1,
1131 /* 68-83: Vector Registers 16-31. */
1132 S390_V16_REGNUM, S390_V18_REGNUM, S390_V20_REGNUM, S390_V22_REGNUM,
1133 S390_V17_REGNUM, S390_V19_REGNUM, S390_V21_REGNUM, S390_V23_REGNUM,
1134 S390_V24_REGNUM, S390_V26_REGNUM, S390_V28_REGNUM, S390_V30_REGNUM,
1135 S390_V25_REGNUM, S390_V27_REGNUM, S390_V29_REGNUM, S390_V31_REGNUM,
1137 /* End of "official" DWARF registers. The remainder of the map is
1138 for GDB internal use only. */
1140 /* GPR Lower Half Access. */
1141 S390_R0_REGNUM, S390_R1_REGNUM, S390_R2_REGNUM, S390_R3_REGNUM,
1142 S390_R4_REGNUM, S390_R5_REGNUM, S390_R6_REGNUM, S390_R7_REGNUM,
1143 S390_R8_REGNUM, S390_R9_REGNUM, S390_R10_REGNUM, S390_R11_REGNUM,
1144 S390_R12_REGNUM, S390_R13_REGNUM, S390_R14_REGNUM, S390_R15_REGNUM,
1147 enum { s390_dwarf_reg_r0l = ARRAY_SIZE (s390_dwarf_regmap) - 16 };
1149 /* Convert DWARF register number REG to the appropriate register
1150 number used by GDB. */
1152 static int
1153 s390_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int reg)
1155 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1156 int gdb_reg = -1;
1158 /* In a 32-on-64 debug scenario, debug info refers to the full
1159 64-bit GPRs. Note that call frame information still refers to
1160 the 32-bit lower halves, because s390_adjust_frame_regnum uses
1161 special register numbers to access GPRs. */
1162 if (tdep->gpr_full_regnum != -1 && reg >= 0 && reg < 16)
1163 return tdep->gpr_full_regnum + reg;
1165 if (reg >= 0 && reg < ARRAY_SIZE (s390_dwarf_regmap))
1166 gdb_reg = s390_dwarf_regmap[reg];
1168 if (tdep->v0_full_regnum == -1)
1170 if (gdb_reg >= S390_V16_REGNUM && gdb_reg <= S390_V31_REGNUM)
1171 gdb_reg = -1;
1173 else
1175 if (gdb_reg >= S390_F0_REGNUM && gdb_reg <= S390_F15_REGNUM)
1176 gdb_reg = gdb_reg - S390_F0_REGNUM + tdep->v0_full_regnum;
1179 return gdb_reg;
1182 /* Pseudo registers. */
1184 /* Check whether REGNUM indicates a coupled general purpose register.
1185 These pseudo-registers are composed of two adjacent gprs. */
1187 static int
1188 regnum_is_gpr_full (struct gdbarch_tdep *tdep, int regnum)
1190 return (tdep->gpr_full_regnum != -1
1191 && regnum >= tdep->gpr_full_regnum
1192 && regnum <= tdep->gpr_full_regnum + 15);
1195 /* Check whether REGNUM indicates a full vector register (v0-v15).
1196 These pseudo-registers are composed of f0-f15 and v0l-v15l. */
1198 static int
1199 regnum_is_vxr_full (struct gdbarch_tdep *tdep, int regnum)
1201 return (tdep->v0_full_regnum != -1
1202 && regnum >= tdep->v0_full_regnum
1203 && regnum <= tdep->v0_full_regnum + 15);
1206 /* 'float' values are stored in the upper half of floating-point
1207 registers, even though we are otherwise a big-endian platform. The
1208 same applies to a 'float' value within a vector. */
1210 static struct value *
1211 s390_value_from_register (struct gdbarch *gdbarch, struct type *type,
1212 int regnum, struct frame_id frame_id)
1214 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1215 struct value *value = default_value_from_register (gdbarch, type,
1216 regnum, frame_id);
1217 check_typedef (type);
1219 if ((regnum >= S390_F0_REGNUM && regnum <= S390_F15_REGNUM
1220 && TYPE_LENGTH (type) < 8)
1221 || regnum_is_vxr_full (tdep, regnum)
1222 || (regnum >= S390_V16_REGNUM && regnum <= S390_V31_REGNUM))
1223 set_value_offset (value, 0);
1225 return value;
1228 /* Implement pseudo_register_name tdesc method. */
1230 static const char *
1231 s390_pseudo_register_name (struct gdbarch *gdbarch, int regnum)
1233 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1235 if (regnum == tdep->pc_regnum)
1236 return "pc";
1238 if (regnum == tdep->cc_regnum)
1239 return "cc";
1241 if (regnum_is_gpr_full (tdep, regnum))
1243 static const char *full_name[] = {
1244 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1245 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
1247 return full_name[regnum - tdep->gpr_full_regnum];
1250 if (regnum_is_vxr_full (tdep, regnum))
1252 static const char *full_name[] = {
1253 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
1254 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15"
1256 return full_name[regnum - tdep->v0_full_regnum];
1259 internal_error (__FILE__, __LINE__, _("invalid regnum"));
1262 /* Implement pseudo_register_type tdesc method. */
1264 static struct type *
1265 s390_pseudo_register_type (struct gdbarch *gdbarch, int regnum)
1267 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1269 if (regnum == tdep->pc_regnum)
1270 return builtin_type (gdbarch)->builtin_func_ptr;
1272 if (regnum == tdep->cc_regnum)
1273 return builtin_type (gdbarch)->builtin_int;
1275 if (regnum_is_gpr_full (tdep, regnum))
1276 return builtin_type (gdbarch)->builtin_uint64;
1278 /* For the "concatenated" vector registers use the same type as v16. */
1279 if (regnum_is_vxr_full (tdep, regnum))
1280 return tdesc_register_type (gdbarch, S390_V16_REGNUM);
1282 internal_error (__FILE__, __LINE__, _("invalid regnum"));
1285 /* Implement pseudo_register_read gdbarch method. */
1287 static enum register_status
1288 s390_pseudo_register_read (struct gdbarch *gdbarch, readable_regcache *regcache,
1289 int regnum, gdb_byte *buf)
1291 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1292 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1293 int regsize = register_size (gdbarch, regnum);
1294 ULONGEST val;
1296 if (regnum == tdep->pc_regnum)
1298 enum register_status status;
1300 status = regcache->raw_read (S390_PSWA_REGNUM, &val);
1301 if (status == REG_VALID)
1303 if (register_size (gdbarch, S390_PSWA_REGNUM) == 4)
1304 val &= 0x7fffffff;
1305 store_unsigned_integer (buf, regsize, byte_order, val);
1307 return status;
1310 if (regnum == tdep->cc_regnum)
1312 enum register_status status;
1314 status = regcache->raw_read (S390_PSWM_REGNUM, &val);
1315 if (status == REG_VALID)
1317 if (register_size (gdbarch, S390_PSWA_REGNUM) == 4)
1318 val = (val >> 12) & 3;
1319 else
1320 val = (val >> 44) & 3;
1321 store_unsigned_integer (buf, regsize, byte_order, val);
1323 return status;
1326 if (regnum_is_gpr_full (tdep, regnum))
1328 enum register_status status;
1329 ULONGEST val_upper;
1331 regnum -= tdep->gpr_full_regnum;
1333 status = regcache->raw_read (S390_R0_REGNUM + regnum, &val);
1334 if (status == REG_VALID)
1335 status = regcache->raw_read (S390_R0_UPPER_REGNUM + regnum,
1336 &val_upper);
1337 if (status == REG_VALID)
1339 val |= val_upper << 32;
1340 store_unsigned_integer (buf, regsize, byte_order, val);
1342 return status;
1345 if (regnum_is_vxr_full (tdep, regnum))
1347 enum register_status status;
1349 regnum -= tdep->v0_full_regnum;
1351 status = regcache->raw_read (S390_F0_REGNUM + regnum, buf);
1352 if (status == REG_VALID)
1353 status = regcache->raw_read (S390_V0_LOWER_REGNUM + regnum, buf + 8);
1354 return status;
1357 internal_error (__FILE__, __LINE__, _("invalid regnum"));
1360 /* Implement pseudo_register_write gdbarch method. */
1362 static void
1363 s390_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
1364 int regnum, const gdb_byte *buf)
1366 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1367 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1368 int regsize = register_size (gdbarch, regnum);
1369 ULONGEST val, psw;
1371 if (regnum == tdep->pc_regnum)
1373 val = extract_unsigned_integer (buf, regsize, byte_order);
1374 if (register_size (gdbarch, S390_PSWA_REGNUM) == 4)
1376 regcache_raw_read_unsigned (regcache, S390_PSWA_REGNUM, &psw);
1377 val = (psw & 0x80000000) | (val & 0x7fffffff);
1379 regcache_raw_write_unsigned (regcache, S390_PSWA_REGNUM, val);
1380 return;
1383 if (regnum == tdep->cc_regnum)
1385 val = extract_unsigned_integer (buf, regsize, byte_order);
1386 regcache_raw_read_unsigned (regcache, S390_PSWM_REGNUM, &psw);
1387 if (register_size (gdbarch, S390_PSWA_REGNUM) == 4)
1388 val = (psw & ~((ULONGEST)3 << 12)) | ((val & 3) << 12);
1389 else
1390 val = (psw & ~((ULONGEST)3 << 44)) | ((val & 3) << 44);
1391 regcache_raw_write_unsigned (regcache, S390_PSWM_REGNUM, val);
1392 return;
1395 if (regnum_is_gpr_full (tdep, regnum))
1397 regnum -= tdep->gpr_full_regnum;
1398 val = extract_unsigned_integer (buf, regsize, byte_order);
1399 regcache_raw_write_unsigned (regcache, S390_R0_REGNUM + regnum,
1400 val & 0xffffffff);
1401 regcache_raw_write_unsigned (regcache, S390_R0_UPPER_REGNUM + regnum,
1402 val >> 32);
1403 return;
1406 if (regnum_is_vxr_full (tdep, regnum))
1408 regnum -= tdep->v0_full_regnum;
1409 regcache->raw_write (S390_F0_REGNUM + regnum, buf);
1410 regcache->raw_write (S390_V0_LOWER_REGNUM + regnum, buf + 8);
1411 return;
1414 internal_error (__FILE__, __LINE__, _("invalid regnum"));
1417 /* Register groups. */
1419 /* Implement pseudo_register_reggroup_p tdesc method. */
1421 static int
1422 s390_pseudo_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
1423 struct reggroup *group)
1425 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1427 /* We usually save/restore the whole PSW, which includes PC and CC.
1428 However, some older gdbservers may not support saving/restoring
1429 the whole PSW yet, and will return an XML register description
1430 excluding those from the save/restore register groups. In those
1431 cases, we still need to explicitly save/restore PC and CC in order
1432 to push or pop frames. Since this doesn't hurt anything if we
1433 already save/restore the whole PSW (it's just redundant), we add
1434 PC and CC at this point unconditionally. */
1435 if (group == save_reggroup || group == restore_reggroup)
1436 return regnum == tdep->pc_regnum || regnum == tdep->cc_regnum;
1438 if (group == vector_reggroup)
1439 return regnum_is_vxr_full (tdep, regnum);
1441 if (group == general_reggroup && regnum_is_vxr_full (tdep, regnum))
1442 return 0;
1444 return default_register_reggroup_p (gdbarch, regnum, group);
1447 /* The "ax_pseudo_register_collect" gdbarch method. */
1449 static int
1450 s390_ax_pseudo_register_collect (struct gdbarch *gdbarch,
1451 struct agent_expr *ax, int regnum)
1453 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1454 if (regnum == tdep->pc_regnum)
1456 ax_reg_mask (ax, S390_PSWA_REGNUM);
1458 else if (regnum == tdep->cc_regnum)
1460 ax_reg_mask (ax, S390_PSWM_REGNUM);
1462 else if (regnum_is_gpr_full (tdep, regnum))
1464 regnum -= tdep->gpr_full_regnum;
1465 ax_reg_mask (ax, S390_R0_REGNUM + regnum);
1466 ax_reg_mask (ax, S390_R0_UPPER_REGNUM + regnum);
1468 else if (regnum_is_vxr_full (tdep, regnum))
1470 regnum -= tdep->v0_full_regnum;
1471 ax_reg_mask (ax, S390_F0_REGNUM + regnum);
1472 ax_reg_mask (ax, S390_V0_LOWER_REGNUM + regnum);
1474 else
1476 internal_error (__FILE__, __LINE__, _("invalid regnum"));
1478 return 0;
1481 /* The "ax_pseudo_register_push_stack" gdbarch method. */
1483 static int
1484 s390_ax_pseudo_register_push_stack (struct gdbarch *gdbarch,
1485 struct agent_expr *ax, int regnum)
1487 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1488 if (regnum == tdep->pc_regnum)
1490 ax_reg (ax, S390_PSWA_REGNUM);
1491 if (register_size (gdbarch, S390_PSWA_REGNUM) == 4)
1493 ax_zero_ext (ax, 31);
1496 else if (regnum == tdep->cc_regnum)
1498 ax_reg (ax, S390_PSWM_REGNUM);
1499 if (register_size (gdbarch, S390_PSWA_REGNUM) == 4)
1500 ax_const_l (ax, 12);
1501 else
1502 ax_const_l (ax, 44);
1503 ax_simple (ax, aop_rsh_unsigned);
1504 ax_zero_ext (ax, 2);
1506 else if (regnum_is_gpr_full (tdep, regnum))
1508 regnum -= tdep->gpr_full_regnum;
1509 ax_reg (ax, S390_R0_REGNUM + regnum);
1510 ax_reg (ax, S390_R0_UPPER_REGNUM + regnum);
1511 ax_const_l (ax, 32);
1512 ax_simple (ax, aop_lsh);
1513 ax_simple (ax, aop_bit_or);
1515 else if (regnum_is_vxr_full (tdep, regnum))
1517 /* Too large to stuff on the stack. */
1518 return 1;
1520 else
1522 internal_error (__FILE__, __LINE__, _("invalid regnum"));
1524 return 0;
1527 /* The "gen_return_address" gdbarch method. Since this is supposed to be
1528 just a best-effort method, and we don't really have the means to run
1529 the full unwinder here, just collect the link register. */
1531 static void
1532 s390_gen_return_address (struct gdbarch *gdbarch,
1533 struct agent_expr *ax, struct axs_value *value,
1534 CORE_ADDR scope)
1536 value->type = register_type (gdbarch, S390_R14_REGNUM);
1537 value->kind = axs_lvalue_register;
1538 value->u.reg = S390_R14_REGNUM;
1541 /* Address handling. */
1543 /* Implement addr_bits_remove gdbarch method.
1544 Only used for ABI_LINUX_S390. */
1546 static CORE_ADDR
1547 s390_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr)
1549 return addr & 0x7fffffff;
1552 /* Implement addr_class_type_flags gdbarch method.
1553 Only used for ABI_LINUX_ZSERIES. */
1555 static int
1556 s390_address_class_type_flags (int byte_size, int dwarf2_addr_class)
1558 if (byte_size == 4)
1559 return TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1;
1560 else
1561 return 0;
1564 /* Implement addr_class_type_flags_to_name gdbarch method.
1565 Only used for ABI_LINUX_ZSERIES. */
1567 static const char *
1568 s390_address_class_type_flags_to_name (struct gdbarch *gdbarch, int type_flags)
1570 if (type_flags & TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1)
1571 return "mode32";
1572 else
1573 return NULL;
1576 /* Implement addr_class_name_to_type_flags gdbarch method.
1577 Only used for ABI_LINUX_ZSERIES. */
1579 static int
1580 s390_address_class_name_to_type_flags (struct gdbarch *gdbarch,
1581 const char *name,
1582 int *type_flags_ptr)
1584 if (strcmp (name, "mode32") == 0)
1586 *type_flags_ptr = TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1;
1587 return 1;
1589 else
1590 return 0;
1593 /* Inferior function calls. */
1595 /* Dummy function calls. */
1597 /* Unwrap any single-field structs in TYPE and return the effective
1598 "inner" type. E.g., yield "float" for all these cases:
1600 float x;
1601 struct { float x };
1602 struct { struct { float x; } x; };
1603 struct { struct { struct { float x; } x; } x; };
1605 However, if an inner type is smaller than MIN_SIZE, abort the
1606 unwrapping. */
1608 static struct type *
1609 s390_effective_inner_type (struct type *type, unsigned int min_size)
1611 while (TYPE_CODE (type) == TYPE_CODE_STRUCT
1612 && TYPE_NFIELDS (type) == 1)
1614 struct type *inner = check_typedef (TYPE_FIELD_TYPE (type, 0));
1616 if (TYPE_LENGTH (inner) < min_size)
1617 break;
1618 type = inner;
1621 return type;
1624 /* Return non-zero if TYPE should be passed like "float" or
1625 "double". */
1627 static int
1628 s390_function_arg_float (struct type *type)
1630 /* Note that long double as well as complex types are intentionally
1631 excluded. */
1632 if (TYPE_LENGTH (type) > 8)
1633 return 0;
1635 /* A struct containing just a float or double is passed like a float
1636 or double. */
1637 type = s390_effective_inner_type (type, 0);
1639 return (TYPE_CODE (type) == TYPE_CODE_FLT
1640 || TYPE_CODE (type) == TYPE_CODE_DECFLOAT);
1643 /* Return non-zero if TYPE should be passed like a vector. */
1645 static int
1646 s390_function_arg_vector (struct type *type)
1648 if (TYPE_LENGTH (type) > 16)
1649 return 0;
1651 /* Structs containing just a vector are passed like a vector. */
1652 type = s390_effective_inner_type (type, TYPE_LENGTH (type));
1654 return TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type);
1657 /* Determine whether N is a power of two. */
1659 static int
1660 is_power_of_two (unsigned int n)
1662 return n && ((n & (n - 1)) == 0);
1665 /* For an argument whose type is TYPE and which is not passed like a
1666 float or vector, return non-zero if it should be passed like "int"
1667 or "long long". */
1669 static int
1670 s390_function_arg_integer (struct type *type)
1672 enum type_code code = TYPE_CODE (type);
1674 if (TYPE_LENGTH (type) > 8)
1675 return 0;
1677 if (code == TYPE_CODE_INT
1678 || code == TYPE_CODE_ENUM
1679 || code == TYPE_CODE_RANGE
1680 || code == TYPE_CODE_CHAR
1681 || code == TYPE_CODE_BOOL
1682 || code == TYPE_CODE_PTR
1683 || TYPE_IS_REFERENCE (type))
1684 return 1;
1686 return ((code == TYPE_CODE_UNION || code == TYPE_CODE_STRUCT)
1687 && is_power_of_two (TYPE_LENGTH (type)));
1690 /* Argument passing state: Internal data structure passed to helper
1691 routines of s390_push_dummy_call. */
1693 struct s390_arg_state
1695 /* Register cache, or NULL, if we are in "preparation mode". */
1696 struct regcache *regcache;
1697 /* Next available general/floating-point/vector register for
1698 argument passing. */
1699 int gr, fr, vr;
1700 /* Current pointer to copy area (grows downwards). */
1701 CORE_ADDR copy;
1702 /* Current pointer to parameter area (grows upwards). */
1703 CORE_ADDR argp;
1706 /* Prepare one argument ARG for a dummy call and update the argument
1707 passing state AS accordingly. If the regcache field in AS is set,
1708 operate in "write mode" and write ARG into the inferior. Otherwise
1709 run "preparation mode" and skip all updates to the inferior. */
1711 static void
1712 s390_handle_arg (struct s390_arg_state *as, struct value *arg,
1713 struct gdbarch_tdep *tdep, int word_size,
1714 enum bfd_endian byte_order, int is_unnamed)
1716 struct type *type = check_typedef (value_type (arg));
1717 unsigned int length = TYPE_LENGTH (type);
1718 int write_mode = as->regcache != NULL;
1720 if (s390_function_arg_float (type))
1722 /* The GNU/Linux for S/390 ABI uses FPRs 0 and 2 to pass
1723 arguments. The GNU/Linux for zSeries ABI uses 0, 2, 4, and
1724 6. */
1725 if (as->fr <= (tdep->abi == ABI_LINUX_S390 ? 2 : 6))
1727 /* When we store a single-precision value in an FP register,
1728 it occupies the leftmost bits. */
1729 if (write_mode)
1730 as->regcache->cooked_write_part (S390_F0_REGNUM + as->fr, 0, length,
1731 value_contents (arg));
1732 as->fr += 2;
1734 else
1736 /* When we store a single-precision value in a stack slot,
1737 it occupies the rightmost bits. */
1738 as->argp = align_up (as->argp + length, word_size);
1739 if (write_mode)
1740 write_memory (as->argp - length, value_contents (arg),
1741 length);
1744 else if (tdep->vector_abi == S390_VECTOR_ABI_128
1745 && s390_function_arg_vector (type))
1747 static const char use_vr[] = {24, 26, 28, 30, 25, 27, 29, 31};
1749 if (!is_unnamed && as->vr < ARRAY_SIZE (use_vr))
1751 int regnum = S390_V24_REGNUM + use_vr[as->vr] - 24;
1753 if (write_mode)
1754 as->regcache->cooked_write_part (regnum, 0, length,
1755 value_contents (arg));
1756 as->vr++;
1758 else
1760 if (write_mode)
1761 write_memory (as->argp, value_contents (arg), length);
1762 as->argp = align_up (as->argp + length, word_size);
1765 else if (s390_function_arg_integer (type) && length <= word_size)
1767 /* Initialize it just to avoid a GCC false warning. */
1768 ULONGEST val = 0;
1770 if (write_mode)
1772 /* Place value in least significant bits of the register or
1773 memory word and sign- or zero-extend to full word size.
1774 This also applies to a struct or union. */
1775 val = TYPE_UNSIGNED (type)
1776 ? extract_unsigned_integer (value_contents (arg),
1777 length, byte_order)
1778 : extract_signed_integer (value_contents (arg),
1779 length, byte_order);
1782 if (as->gr <= 6)
1784 if (write_mode)
1785 regcache_cooked_write_unsigned (as->regcache,
1786 S390_R0_REGNUM + as->gr,
1787 val);
1788 as->gr++;
1790 else
1792 if (write_mode)
1793 write_memory_unsigned_integer (as->argp, word_size,
1794 byte_order, val);
1795 as->argp += word_size;
1798 else if (s390_function_arg_integer (type) && length == 8)
1800 if (as->gr <= 5)
1802 if (write_mode)
1804 as->regcache->cooked_write (S390_R0_REGNUM + as->gr,
1805 value_contents (arg));
1806 as->regcache->cooked_write (S390_R0_REGNUM + as->gr + 1,
1807 value_contents (arg) + word_size);
1809 as->gr += 2;
1811 else
1813 /* If we skipped r6 because we couldn't fit a DOUBLE_ARG
1814 in it, then don't go back and use it again later. */
1815 as->gr = 7;
1817 if (write_mode)
1818 write_memory (as->argp, value_contents (arg), length);
1819 as->argp += length;
1822 else
1824 /* This argument type is never passed in registers. Place the
1825 value in the copy area and pass a pointer to it. Use 8-byte
1826 alignment as a conservative assumption. */
1827 as->copy = align_down (as->copy - length, 8);
1828 if (write_mode)
1829 write_memory (as->copy, value_contents (arg), length);
1831 if (as->gr <= 6)
1833 if (write_mode)
1834 regcache_cooked_write_unsigned (as->regcache,
1835 S390_R0_REGNUM + as->gr,
1836 as->copy);
1837 as->gr++;
1839 else
1841 if (write_mode)
1842 write_memory_unsigned_integer (as->argp, word_size,
1843 byte_order, as->copy);
1844 as->argp += word_size;
1849 /* Put the actual parameter values pointed to by ARGS[0..NARGS-1] in
1850 place to be passed to a function, as specified by the "GNU/Linux
1851 for S/390 ELF Application Binary Interface Supplement".
1853 SP is the current stack pointer. We must put arguments, links,
1854 padding, etc. whereever they belong, and return the new stack
1855 pointer value.
1857 If STRUCT_RETURN is non-zero, then the function we're calling is
1858 going to return a structure by value; STRUCT_ADDR is the address of
1859 a block we've allocated for it on the stack.
1861 Our caller has taken care of any type promotions needed to satisfy
1862 prototypes or the old K&R argument-passing rules. */
1864 static CORE_ADDR
1865 s390_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
1866 struct regcache *regcache, CORE_ADDR bp_addr,
1867 int nargs, struct value **args, CORE_ADDR sp,
1868 function_call_return_method return_method,
1869 CORE_ADDR struct_addr)
1871 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1872 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1873 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1874 int i;
1875 struct s390_arg_state arg_state, arg_prep;
1876 CORE_ADDR param_area_start, new_sp;
1877 struct type *ftype = check_typedef (value_type (function));
1879 if (TYPE_CODE (ftype) == TYPE_CODE_PTR)
1880 ftype = check_typedef (TYPE_TARGET_TYPE (ftype));
1882 arg_prep.copy = sp;
1883 arg_prep.gr = (return_method == return_method_struct) ? 3 : 2;
1884 arg_prep.fr = 0;
1885 arg_prep.vr = 0;
1886 arg_prep.argp = 0;
1887 arg_prep.regcache = NULL;
1889 /* Initialize arg_state for "preparation mode". */
1890 arg_state = arg_prep;
1892 /* Update arg_state.copy with the start of the reference-to-copy area
1893 and arg_state.argp with the size of the parameter area. */
1894 for (i = 0; i < nargs; i++)
1895 s390_handle_arg (&arg_state, args[i], tdep, word_size, byte_order,
1896 TYPE_VARARGS (ftype) && i >= TYPE_NFIELDS (ftype));
1898 param_area_start = align_down (arg_state.copy - arg_state.argp, 8);
1900 /* Allocate the standard frame areas: the register save area, the
1901 word reserved for the compiler, and the back chain pointer. */
1902 new_sp = param_area_start - (16 * word_size + 32);
1904 /* Now we have the final stack pointer. Make sure we didn't
1905 underflow; on 31-bit, this would result in addresses with the
1906 high bit set, which causes confusion elsewhere. Note that if we
1907 error out here, stack and registers remain untouched. */
1908 if (gdbarch_addr_bits_remove (gdbarch, new_sp) != new_sp)
1909 error (_("Stack overflow"));
1911 /* Pass the structure return address in general register 2. */
1912 if (return_method == return_method_struct)
1913 regcache_cooked_write_unsigned (regcache, S390_R2_REGNUM, struct_addr);
1915 /* Initialize arg_state for "write mode". */
1916 arg_state = arg_prep;
1917 arg_state.argp = param_area_start;
1918 arg_state.regcache = regcache;
1920 /* Write all parameters. */
1921 for (i = 0; i < nargs; i++)
1922 s390_handle_arg (&arg_state, args[i], tdep, word_size, byte_order,
1923 TYPE_VARARGS (ftype) && i >= TYPE_NFIELDS (ftype));
1925 /* Store return PSWA. In 31-bit mode, keep addressing mode bit. */
1926 if (word_size == 4)
1928 ULONGEST pswa;
1929 regcache_cooked_read_unsigned (regcache, S390_PSWA_REGNUM, &pswa);
1930 bp_addr = (bp_addr & 0x7fffffff) | (pswa & 0x80000000);
1932 regcache_cooked_write_unsigned (regcache, S390_RETADDR_REGNUM, bp_addr);
1934 /* Store updated stack pointer. */
1935 regcache_cooked_write_unsigned (regcache, S390_SP_REGNUM, new_sp);
1937 /* We need to return the 'stack part' of the frame ID,
1938 which is actually the top of the register save area. */
1939 return param_area_start;
1942 /* Assuming THIS_FRAME is a dummy, return the frame ID of that
1943 dummy frame. The frame ID's base needs to match the TOS value
1944 returned by push_dummy_call, and the PC match the dummy frame's
1945 breakpoint. */
1947 static struct frame_id
1948 s390_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
1950 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1951 CORE_ADDR sp = get_frame_register_unsigned (this_frame, S390_SP_REGNUM);
1952 sp = gdbarch_addr_bits_remove (gdbarch, sp);
1954 return frame_id_build (sp + 16*word_size + 32,
1955 get_frame_pc (this_frame));
1958 /* Implement frame_align gdbarch method. */
1960 static CORE_ADDR
1961 s390_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
1963 /* Both the 32- and 64-bit ABI's say that the stack pointer should
1964 always be aligned on an eight-byte boundary. */
1965 return (addr & -8);
1968 /* Helper for s390_return_value: Set or retrieve a function return
1969 value if it resides in a register. */
1971 static void
1972 s390_register_return_value (struct gdbarch *gdbarch, struct type *type,
1973 struct regcache *regcache,
1974 gdb_byte *out, const gdb_byte *in)
1976 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1977 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1978 int length = TYPE_LENGTH (type);
1979 int code = TYPE_CODE (type);
1981 if (code == TYPE_CODE_FLT || code == TYPE_CODE_DECFLOAT)
1983 /* Float-like value: left-aligned in f0. */
1984 if (in != NULL)
1985 regcache->cooked_write_part (S390_F0_REGNUM, 0, length, in);
1986 else
1987 regcache->cooked_read_part (S390_F0_REGNUM, 0, length, out);
1989 else if (code == TYPE_CODE_ARRAY)
1991 /* Vector: left-aligned in v24. */
1992 if (in != NULL)
1993 regcache->cooked_write_part (S390_V24_REGNUM, 0, length, in);
1994 else
1995 regcache->cooked_read_part (S390_V24_REGNUM, 0, length, out);
1997 else if (length <= word_size)
1999 /* Integer: zero- or sign-extended in r2. */
2000 if (out != NULL)
2001 regcache->cooked_read_part (S390_R2_REGNUM, word_size - length, length,
2002 out);
2003 else if (TYPE_UNSIGNED (type))
2004 regcache_cooked_write_unsigned
2005 (regcache, S390_R2_REGNUM,
2006 extract_unsigned_integer (in, length, byte_order));
2007 else
2008 regcache_cooked_write_signed
2009 (regcache, S390_R2_REGNUM,
2010 extract_signed_integer (in, length, byte_order));
2012 else if (length == 2 * word_size)
2014 /* Double word: in r2 and r3. */
2015 if (in != NULL)
2017 regcache->cooked_write (S390_R2_REGNUM, in);
2018 regcache->cooked_write (S390_R3_REGNUM, in + word_size);
2020 else
2022 regcache->cooked_read (S390_R2_REGNUM, out);
2023 regcache->cooked_read (S390_R3_REGNUM, out + word_size);
2026 else
2027 internal_error (__FILE__, __LINE__, _("invalid return type"));
2030 /* Implement the 'return_value' gdbarch method. */
2032 static enum return_value_convention
2033 s390_return_value (struct gdbarch *gdbarch, struct value *function,
2034 struct type *type, struct regcache *regcache,
2035 gdb_byte *out, const gdb_byte *in)
2037 enum return_value_convention rvc;
2039 type = check_typedef (type);
2041 switch (TYPE_CODE (type))
2043 case TYPE_CODE_STRUCT:
2044 case TYPE_CODE_UNION:
2045 case TYPE_CODE_COMPLEX:
2046 rvc = RETURN_VALUE_STRUCT_CONVENTION;
2047 break;
2048 case TYPE_CODE_ARRAY:
2049 rvc = (gdbarch_tdep (gdbarch)->vector_abi == S390_VECTOR_ABI_128
2050 && TYPE_LENGTH (type) <= 16 && TYPE_VECTOR (type))
2051 ? RETURN_VALUE_REGISTER_CONVENTION
2052 : RETURN_VALUE_STRUCT_CONVENTION;
2053 break;
2054 default:
2055 rvc = TYPE_LENGTH (type) <= 8
2056 ? RETURN_VALUE_REGISTER_CONVENTION
2057 : RETURN_VALUE_STRUCT_CONVENTION;
2060 if (in != NULL || out != NULL)
2062 if (rvc == RETURN_VALUE_REGISTER_CONVENTION)
2063 s390_register_return_value (gdbarch, type, regcache, out, in);
2064 else if (in != NULL)
2065 error (_("Cannot set function return value."));
2066 else
2067 error (_("Function return value unknown."));
2070 return rvc;
2073 /* Frame unwinding. */
2075 /* Implmement the stack_frame_destroyed_p gdbarch method. */
2077 static int
2078 s390_stack_frame_destroyed_p (struct gdbarch *gdbarch, CORE_ADDR pc)
2080 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
2082 /* In frameless functions, there's no frame to destroy and thus
2083 we don't care about the epilogue.
2085 In functions with frame, the epilogue sequence is a pair of
2086 a LM-type instruction that restores (amongst others) the
2087 return register %r14 and the stack pointer %r15, followed
2088 by a branch 'br %r14' --or equivalent-- that effects the
2089 actual return.
2091 In that situation, this function needs to return 'true' in
2092 exactly one case: when pc points to that branch instruction.
2094 Thus we try to disassemble the one instructions immediately
2095 preceding pc and check whether it is an LM-type instruction
2096 modifying the stack pointer.
2098 Note that disassembling backwards is not reliable, so there
2099 is a slight chance of false positives here ... */
2101 bfd_byte insn[6];
2102 unsigned int r1, r3, b2;
2103 int d2;
2105 if (word_size == 4
2106 && !target_read_memory (pc - 4, insn, 4)
2107 && is_rs (insn, op_lm, &r1, &r3, &d2, &b2)
2108 && r3 == S390_SP_REGNUM - S390_R0_REGNUM)
2109 return 1;
2111 if (word_size == 4
2112 && !target_read_memory (pc - 6, insn, 6)
2113 && is_rsy (insn, op1_lmy, op2_lmy, &r1, &r3, &d2, &b2)
2114 && r3 == S390_SP_REGNUM - S390_R0_REGNUM)
2115 return 1;
2117 if (word_size == 8
2118 && !target_read_memory (pc - 6, insn, 6)
2119 && is_rsy (insn, op1_lmg, op2_lmg, &r1, &r3, &d2, &b2)
2120 && r3 == S390_SP_REGNUM - S390_R0_REGNUM)
2121 return 1;
2123 return 0;
2126 /* Implement unwind_pc gdbarch method. */
2128 static CORE_ADDR
2129 s390_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
2131 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2132 ULONGEST pc;
2133 pc = frame_unwind_register_unsigned (next_frame, tdep->pc_regnum);
2134 return gdbarch_addr_bits_remove (gdbarch, pc);
2137 /* Implement unwind_sp gdbarch method. */
2139 static CORE_ADDR
2140 s390_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
2142 ULONGEST sp;
2143 sp = frame_unwind_register_unsigned (next_frame, S390_SP_REGNUM);
2144 return gdbarch_addr_bits_remove (gdbarch, sp);
2147 /* Helper routine to unwind pseudo registers. */
2149 static struct value *
2150 s390_unwind_pseudo_register (struct frame_info *this_frame, int regnum)
2152 struct gdbarch *gdbarch = get_frame_arch (this_frame);
2153 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2154 struct type *type = register_type (gdbarch, regnum);
2156 /* Unwind PC via PSW address. */
2157 if (regnum == tdep->pc_regnum)
2159 struct value *val;
2161 val = frame_unwind_register_value (this_frame, S390_PSWA_REGNUM);
2162 if (!value_optimized_out (val))
2164 LONGEST pswa = value_as_long (val);
2166 if (TYPE_LENGTH (type) == 4)
2167 return value_from_pointer (type, pswa & 0x7fffffff);
2168 else
2169 return value_from_pointer (type, pswa);
2173 /* Unwind CC via PSW mask. */
2174 if (regnum == tdep->cc_regnum)
2176 struct value *val;
2178 val = frame_unwind_register_value (this_frame, S390_PSWM_REGNUM);
2179 if (!value_optimized_out (val))
2181 LONGEST pswm = value_as_long (val);
2183 if (TYPE_LENGTH (type) == 4)
2184 return value_from_longest (type, (pswm >> 12) & 3);
2185 else
2186 return value_from_longest (type, (pswm >> 44) & 3);
2190 /* Unwind full GPRs to show at least the lower halves (as the
2191 upper halves are undefined). */
2192 if (regnum_is_gpr_full (tdep, regnum))
2194 int reg = regnum - tdep->gpr_full_regnum;
2195 struct value *val;
2197 val = frame_unwind_register_value (this_frame, S390_R0_REGNUM + reg);
2198 if (!value_optimized_out (val))
2199 return value_cast (type, val);
2202 return allocate_optimized_out_value (type);
2205 /* Translate a .eh_frame register to DWARF register, or adjust a
2206 .debug_frame register. */
2208 static int
2209 s390_adjust_frame_regnum (struct gdbarch *gdbarch, int num, int eh_frame_p)
2211 /* See s390_dwarf_reg_to_regnum for comments. */
2212 return (num >= 0 && num < 16) ? num + s390_dwarf_reg_r0l : num;
2215 /* DWARF-2 frame unwinding. */
2217 /* Function to unwind a pseudo-register in dwarf2_frame unwinder. Used by
2218 s390_dwarf2_frame_init_reg. */
2220 static struct value *
2221 s390_dwarf2_prev_register (struct frame_info *this_frame, void **this_cache,
2222 int regnum)
2224 return s390_unwind_pseudo_register (this_frame, regnum);
2227 /* Implement init_reg dwarf2_frame method. */
2229 static void
2230 s390_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
2231 struct dwarf2_frame_state_reg *reg,
2232 struct frame_info *this_frame)
2234 /* The condition code (and thus PSW mask) is call-clobbered. */
2235 if (regnum == S390_PSWM_REGNUM)
2236 reg->how = DWARF2_FRAME_REG_UNDEFINED;
2238 /* The PSW address unwinds to the return address. */
2239 else if (regnum == S390_PSWA_REGNUM)
2240 reg->how = DWARF2_FRAME_REG_RA;
2242 /* Fixed registers are call-saved or call-clobbered
2243 depending on the ABI in use. */
2244 else if (regnum < S390_NUM_REGS)
2246 if (s390_register_call_saved (gdbarch, regnum))
2247 reg->how = DWARF2_FRAME_REG_SAME_VALUE;
2248 else
2249 reg->how = DWARF2_FRAME_REG_UNDEFINED;
2252 /* We install a special function to unwind pseudos. */
2253 else
2255 reg->how = DWARF2_FRAME_REG_FN;
2256 reg->loc.fn = s390_dwarf2_prev_register;
2260 /* Frame unwinding. */
2262 /* Wrapper for trad_frame_get_prev_register to allow for s390 pseudo
2263 register translation. */
2265 struct value *
2266 s390_trad_frame_prev_register (struct frame_info *this_frame,
2267 struct trad_frame_saved_reg saved_regs[],
2268 int regnum)
2270 if (regnum < S390_NUM_REGS)
2271 return trad_frame_get_prev_register (this_frame, saved_regs, regnum);
2272 else
2273 return s390_unwind_pseudo_register (this_frame, regnum);
2276 /* Normal stack frames. */
2278 struct s390_unwind_cache {
2280 CORE_ADDR func;
2281 CORE_ADDR frame_base;
2282 CORE_ADDR local_base;
2284 struct trad_frame_saved_reg *saved_regs;
2287 /* Unwind THIS_FRAME and write the information into unwind cache INFO using
2288 prologue analysis. Helper for s390_frame_unwind_cache. */
2290 static int
2291 s390_prologue_frame_unwind_cache (struct frame_info *this_frame,
2292 struct s390_unwind_cache *info)
2294 struct gdbarch *gdbarch = get_frame_arch (this_frame);
2295 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
2296 struct s390_prologue_data data;
2297 pv_t *fp = &data.gpr[S390_FRAME_REGNUM - S390_R0_REGNUM];
2298 pv_t *sp = &data.gpr[S390_SP_REGNUM - S390_R0_REGNUM];
2299 int i;
2300 CORE_ADDR cfa;
2301 CORE_ADDR func;
2302 CORE_ADDR result;
2303 ULONGEST reg;
2304 CORE_ADDR prev_sp;
2305 int frame_pointer;
2306 int size;
2307 struct frame_info *next_frame;
2309 /* Try to find the function start address. If we can't find it, we don't
2310 bother searching for it -- with modern compilers this would be mostly
2311 pointless anyway. Trust that we'll either have valid DWARF-2 CFI data
2312 or else a valid backchain ... */
2313 if (!get_frame_func_if_available (this_frame, &info->func))
2315 info->func = -1;
2316 return 0;
2318 func = info->func;
2320 /* Try to analyze the prologue. */
2321 result = s390_analyze_prologue (gdbarch, func,
2322 get_frame_pc (this_frame), &data);
2323 if (!result)
2324 return 0;
2326 /* If this was successful, we should have found the instruction that
2327 sets the stack pointer register to the previous value of the stack
2328 pointer minus the frame size. */
2329 if (!pv_is_register (*sp, S390_SP_REGNUM))
2330 return 0;
2332 /* A frame size of zero at this point can mean either a real
2333 frameless function, or else a failure to find the prologue.
2334 Perform some sanity checks to verify we really have a
2335 frameless function. */
2336 if (sp->k == 0)
2338 /* If the next frame is a NORMAL_FRAME, this frame *cannot* have frame
2339 size zero. This is only possible if the next frame is a sentinel
2340 frame, a dummy frame, or a signal trampoline frame. */
2341 /* FIXME: cagney/2004-05-01: This sanity check shouldn't be
2342 needed, instead the code should simpliy rely on its
2343 analysis. */
2344 next_frame = get_next_frame (this_frame);
2345 while (next_frame && get_frame_type (next_frame) == INLINE_FRAME)
2346 next_frame = get_next_frame (next_frame);
2347 if (next_frame
2348 && get_frame_type (get_next_frame (this_frame)) == NORMAL_FRAME)
2349 return 0;
2351 /* If we really have a frameless function, %r14 must be valid
2352 -- in particular, it must point to a different function. */
2353 reg = get_frame_register_unsigned (this_frame, S390_RETADDR_REGNUM);
2354 reg = gdbarch_addr_bits_remove (gdbarch, reg) - 1;
2355 if (get_pc_function_start (reg) == func)
2357 /* However, there is one case where it *is* valid for %r14
2358 to point to the same function -- if this is a recursive
2359 call, and we have stopped in the prologue *before* the
2360 stack frame was allocated.
2362 Recognize this case by looking ahead a bit ... */
2364 struct s390_prologue_data data2;
2365 pv_t *sp2 = &data2.gpr[S390_SP_REGNUM - S390_R0_REGNUM];
2367 if (!(s390_analyze_prologue (gdbarch, func, (CORE_ADDR)-1, &data2)
2368 && pv_is_register (*sp2, S390_SP_REGNUM)
2369 && sp2->k != 0))
2370 return 0;
2374 /* OK, we've found valid prologue data. */
2375 size = -sp->k;
2377 /* If the frame pointer originally also holds the same value
2378 as the stack pointer, we're probably using it. If it holds
2379 some other value -- even a constant offset -- it is most
2380 likely used as temp register. */
2381 if (pv_is_identical (*sp, *fp))
2382 frame_pointer = S390_FRAME_REGNUM;
2383 else
2384 frame_pointer = S390_SP_REGNUM;
2386 /* If we've detected a function with stack frame, we'll still have to
2387 treat it as frameless if we're currently within the function epilog
2388 code at a point where the frame pointer has already been restored.
2389 This can only happen in an innermost frame. */
2390 /* FIXME: cagney/2004-05-01: This sanity check shouldn't be needed,
2391 instead the code should simpliy rely on its analysis. */
2392 next_frame = get_next_frame (this_frame);
2393 while (next_frame && get_frame_type (next_frame) == INLINE_FRAME)
2394 next_frame = get_next_frame (next_frame);
2395 if (size > 0
2396 && (next_frame == NULL
2397 || get_frame_type (get_next_frame (this_frame)) != NORMAL_FRAME))
2399 /* See the comment in s390_stack_frame_destroyed_p on why this is
2400 not completely reliable ... */
2401 if (s390_stack_frame_destroyed_p (gdbarch, get_frame_pc (this_frame)))
2403 memset (&data, 0, sizeof (data));
2404 size = 0;
2405 frame_pointer = S390_SP_REGNUM;
2409 /* Once we know the frame register and the frame size, we can unwind
2410 the current value of the frame register from the next frame, and
2411 add back the frame size to arrive that the previous frame's
2412 stack pointer value. */
2413 prev_sp = get_frame_register_unsigned (this_frame, frame_pointer) + size;
2414 cfa = prev_sp + 16*word_size + 32;
2416 /* Set up ABI call-saved/call-clobbered registers. */
2417 for (i = 0; i < S390_NUM_REGS; i++)
2418 if (!s390_register_call_saved (gdbarch, i))
2419 trad_frame_set_unknown (info->saved_regs, i);
2421 /* CC is always call-clobbered. */
2422 trad_frame_set_unknown (info->saved_regs, S390_PSWM_REGNUM);
2424 /* Record the addresses of all register spill slots the prologue parser
2425 has recognized. Consider only registers defined as call-saved by the
2426 ABI; for call-clobbered registers the parser may have recognized
2427 spurious stores. */
2429 for (i = 0; i < 16; i++)
2430 if (s390_register_call_saved (gdbarch, S390_R0_REGNUM + i)
2431 && data.gpr_slot[i] != 0)
2432 info->saved_regs[S390_R0_REGNUM + i].addr = cfa - data.gpr_slot[i];
2434 for (i = 0; i < 16; i++)
2435 if (s390_register_call_saved (gdbarch, S390_F0_REGNUM + i)
2436 && data.fpr_slot[i] != 0)
2437 info->saved_regs[S390_F0_REGNUM + i].addr = cfa - data.fpr_slot[i];
2439 /* Function return will set PC to %r14. */
2440 info->saved_regs[S390_PSWA_REGNUM] = info->saved_regs[S390_RETADDR_REGNUM];
2442 /* In frameless functions, we unwind simply by moving the return
2443 address to the PC. However, if we actually stored to the
2444 save area, use that -- we might only think the function frameless
2445 because we're in the middle of the prologue ... */
2446 if (size == 0
2447 && !trad_frame_addr_p (info->saved_regs, S390_PSWA_REGNUM))
2449 info->saved_regs[S390_PSWA_REGNUM].realreg = S390_RETADDR_REGNUM;
2452 /* Another sanity check: unless this is a frameless function,
2453 we should have found spill slots for SP and PC.
2454 If not, we cannot unwind further -- this happens e.g. in
2455 libc's thread_start routine. */
2456 if (size > 0)
2458 if (!trad_frame_addr_p (info->saved_regs, S390_SP_REGNUM)
2459 || !trad_frame_addr_p (info->saved_regs, S390_PSWA_REGNUM))
2460 prev_sp = -1;
2463 /* We use the current value of the frame register as local_base,
2464 and the top of the register save area as frame_base. */
2465 if (prev_sp != -1)
2467 info->frame_base = prev_sp + 16*word_size + 32;
2468 info->local_base = prev_sp - size;
2471 return 1;
2474 /* Unwind THIS_FRAME and write the information into unwind cache INFO using
2475 back chain unwinding. Helper for s390_frame_unwind_cache. */
2477 static void
2478 s390_backchain_frame_unwind_cache (struct frame_info *this_frame,
2479 struct s390_unwind_cache *info)
2481 struct gdbarch *gdbarch = get_frame_arch (this_frame);
2482 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
2483 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2484 CORE_ADDR backchain;
2485 ULONGEST reg;
2486 LONGEST sp, tmp;
2487 int i;
2489 /* Set up ABI call-saved/call-clobbered registers. */
2490 for (i = 0; i < S390_NUM_REGS; i++)
2491 if (!s390_register_call_saved (gdbarch, i))
2492 trad_frame_set_unknown (info->saved_regs, i);
2494 /* CC is always call-clobbered. */
2495 trad_frame_set_unknown (info->saved_regs, S390_PSWM_REGNUM);
2497 /* Get the backchain. */
2498 reg = get_frame_register_unsigned (this_frame, S390_SP_REGNUM);
2499 if (!safe_read_memory_integer (reg, word_size, byte_order, &tmp))
2500 tmp = 0;
2501 backchain = (CORE_ADDR) tmp;
2503 /* A zero backchain terminates the frame chain. As additional
2504 sanity check, let's verify that the spill slot for SP in the
2505 save area pointed to by the backchain in fact links back to
2506 the save area. */
2507 if (backchain != 0
2508 && safe_read_memory_integer (backchain + 15*word_size,
2509 word_size, byte_order, &sp)
2510 && (CORE_ADDR)sp == backchain)
2512 /* We don't know which registers were saved, but it will have
2513 to be at least %r14 and %r15. This will allow us to continue
2514 unwinding, but other prev-frame registers may be incorrect ... */
2515 info->saved_regs[S390_SP_REGNUM].addr = backchain + 15*word_size;
2516 info->saved_regs[S390_RETADDR_REGNUM].addr = backchain + 14*word_size;
2518 /* Function return will set PC to %r14. */
2519 info->saved_regs[S390_PSWA_REGNUM]
2520 = info->saved_regs[S390_RETADDR_REGNUM];
2522 /* We use the current value of the frame register as local_base,
2523 and the top of the register save area as frame_base. */
2524 info->frame_base = backchain + 16*word_size + 32;
2525 info->local_base = reg;
2528 info->func = get_frame_pc (this_frame);
2531 /* Unwind THIS_FRAME and return the corresponding unwind cache for
2532 s390_frame_unwind and s390_frame_base. */
2534 static struct s390_unwind_cache *
2535 s390_frame_unwind_cache (struct frame_info *this_frame,
2536 void **this_prologue_cache)
2538 struct s390_unwind_cache *info;
2540 if (*this_prologue_cache)
2541 return (struct s390_unwind_cache *) *this_prologue_cache;
2543 info = FRAME_OBSTACK_ZALLOC (struct s390_unwind_cache);
2544 *this_prologue_cache = info;
2545 info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
2546 info->func = -1;
2547 info->frame_base = -1;
2548 info->local_base = -1;
2552 /* Try to use prologue analysis to fill the unwind cache.
2553 If this fails, fall back to reading the stack backchain. */
2554 if (!s390_prologue_frame_unwind_cache (this_frame, info))
2555 s390_backchain_frame_unwind_cache (this_frame, info);
2557 catch (const gdb_exception_error &ex)
2559 if (ex.error != NOT_AVAILABLE_ERROR)
2560 throw;
2563 return info;
2566 /* Implement this_id frame_unwind method for s390_frame_unwind. */
2568 static void
2569 s390_frame_this_id (struct frame_info *this_frame,
2570 void **this_prologue_cache,
2571 struct frame_id *this_id)
2573 struct s390_unwind_cache *info
2574 = s390_frame_unwind_cache (this_frame, this_prologue_cache);
2576 if (info->frame_base == -1)
2578 if (info->func != -1)
2579 *this_id = frame_id_build_unavailable_stack (info->func);
2580 return;
2583 *this_id = frame_id_build (info->frame_base, info->func);
2586 /* Implement prev_register frame_unwind method for s390_frame_unwind. */
2588 static struct value *
2589 s390_frame_prev_register (struct frame_info *this_frame,
2590 void **this_prologue_cache, int regnum)
2592 struct s390_unwind_cache *info
2593 = s390_frame_unwind_cache (this_frame, this_prologue_cache);
2595 return s390_trad_frame_prev_register (this_frame, info->saved_regs, regnum);
2598 /* Default S390 frame unwinder. */
2600 static const struct frame_unwind s390_frame_unwind = {
2601 NORMAL_FRAME,
2602 default_frame_unwind_stop_reason,
2603 s390_frame_this_id,
2604 s390_frame_prev_register,
2605 NULL,
2606 default_frame_sniffer
2609 /* Code stubs and their stack frames. For things like PLTs and NULL
2610 function calls (where there is no true frame and the return address
2611 is in the RETADDR register). */
2613 struct s390_stub_unwind_cache
2615 CORE_ADDR frame_base;
2616 struct trad_frame_saved_reg *saved_regs;
2619 /* Unwind THIS_FRAME and return the corresponding unwind cache for
2620 s390_stub_frame_unwind. */
2622 static struct s390_stub_unwind_cache *
2623 s390_stub_frame_unwind_cache (struct frame_info *this_frame,
2624 void **this_prologue_cache)
2626 struct gdbarch *gdbarch = get_frame_arch (this_frame);
2627 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
2628 struct s390_stub_unwind_cache *info;
2629 ULONGEST reg;
2631 if (*this_prologue_cache)
2632 return (struct s390_stub_unwind_cache *) *this_prologue_cache;
2634 info = FRAME_OBSTACK_ZALLOC (struct s390_stub_unwind_cache);
2635 *this_prologue_cache = info;
2636 info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
2638 /* The return address is in register %r14. */
2639 info->saved_regs[S390_PSWA_REGNUM].realreg = S390_RETADDR_REGNUM;
2641 /* Retrieve stack pointer and determine our frame base. */
2642 reg = get_frame_register_unsigned (this_frame, S390_SP_REGNUM);
2643 info->frame_base = reg + 16*word_size + 32;
2645 return info;
2648 /* Implement this_id frame_unwind method for s390_stub_frame_unwind. */
2650 static void
2651 s390_stub_frame_this_id (struct frame_info *this_frame,
2652 void **this_prologue_cache,
2653 struct frame_id *this_id)
2655 struct s390_stub_unwind_cache *info
2656 = s390_stub_frame_unwind_cache (this_frame, this_prologue_cache);
2657 *this_id = frame_id_build (info->frame_base, get_frame_pc (this_frame));
2660 /* Implement prev_register frame_unwind method for s390_stub_frame_unwind. */
2662 static struct value *
2663 s390_stub_frame_prev_register (struct frame_info *this_frame,
2664 void **this_prologue_cache, int regnum)
2666 struct s390_stub_unwind_cache *info
2667 = s390_stub_frame_unwind_cache (this_frame, this_prologue_cache);
2668 return s390_trad_frame_prev_register (this_frame, info->saved_regs, regnum);
2671 /* Implement sniffer frame_unwind method for s390_stub_frame_unwind. */
2673 static int
2674 s390_stub_frame_sniffer (const struct frame_unwind *self,
2675 struct frame_info *this_frame,
2676 void **this_prologue_cache)
2678 CORE_ADDR addr_in_block;
2679 bfd_byte insn[S390_MAX_INSTR_SIZE];
2681 /* If the current PC points to non-readable memory, we assume we
2682 have trapped due to an invalid function pointer call. We handle
2683 the non-existing current function like a PLT stub. */
2684 addr_in_block = get_frame_address_in_block (this_frame);
2685 if (in_plt_section (addr_in_block)
2686 || s390_readinstruction (insn, get_frame_pc (this_frame)) < 0)
2687 return 1;
2688 return 0;
2691 /* S390 stub frame unwinder. */
2693 static const struct frame_unwind s390_stub_frame_unwind = {
2694 NORMAL_FRAME,
2695 default_frame_unwind_stop_reason,
2696 s390_stub_frame_this_id,
2697 s390_stub_frame_prev_register,
2698 NULL,
2699 s390_stub_frame_sniffer
2702 /* Frame base handling. */
2704 static CORE_ADDR
2705 s390_frame_base_address (struct frame_info *this_frame, void **this_cache)
2707 struct s390_unwind_cache *info
2708 = s390_frame_unwind_cache (this_frame, this_cache);
2709 return info->frame_base;
2712 static CORE_ADDR
2713 s390_local_base_address (struct frame_info *this_frame, void **this_cache)
2715 struct s390_unwind_cache *info
2716 = s390_frame_unwind_cache (this_frame, this_cache);
2717 return info->local_base;
2720 static const struct frame_base s390_frame_base = {
2721 &s390_frame_unwind,
2722 s390_frame_base_address,
2723 s390_local_base_address,
2724 s390_local_base_address
2727 /* Process record-replay */
2729 /* Takes the intermediate sum of address calculations and masks off upper
2730 bits according to current addressing mode. */
2732 static CORE_ADDR
2733 s390_record_address_mask (struct gdbarch *gdbarch, struct regcache *regcache,
2734 CORE_ADDR val)
2736 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2737 ULONGEST pswm, pswa;
2738 int am;
2739 if (tdep->abi == ABI_LINUX_S390)
2741 regcache_raw_read_unsigned (regcache, S390_PSWA_REGNUM, &pswa);
2742 am = pswa >> 31 & 1;
2744 else
2746 regcache_raw_read_unsigned (regcache, S390_PSWM_REGNUM, &pswm);
2747 am = pswm >> 31 & 3;
2749 switch (am)
2751 case 0:
2752 return val & 0xffffff;
2753 case 1:
2754 return val & 0x7fffffff;
2755 case 3:
2756 return val;
2757 default:
2758 fprintf_unfiltered (gdb_stdlog, "Warning: Addressing mode %d used.", am);
2759 return 0;
2763 /* Calculates memory address using pre-calculated index, raw instruction word
2764 with b and d/dl fields, and raw instruction byte with dh field. Index and
2765 dh should be set to 0 if unused. */
2767 static CORE_ADDR
2768 s390_record_calc_disp_common (struct gdbarch *gdbarch, struct regcache *regcache,
2769 ULONGEST x, uint16_t bd, int8_t dh)
2771 uint8_t rb = bd >> 12 & 0xf;
2772 int32_t d = (bd & 0xfff) | ((int32_t)dh << 12);
2773 ULONGEST b;
2774 CORE_ADDR res = d + x;
2775 if (rb)
2777 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + rb, &b);
2778 res += b;
2780 return s390_record_address_mask (gdbarch, regcache, res);
2783 /* Calculates memory address using raw x, b + d/dl, dh fields from
2784 instruction. rx and dh should be set to 0 if unused. */
2786 static CORE_ADDR
2787 s390_record_calc_disp (struct gdbarch *gdbarch, struct regcache *regcache,
2788 uint8_t rx, uint16_t bd, int8_t dh)
2790 ULONGEST x = 0;
2791 if (rx)
2792 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + rx, &x);
2793 return s390_record_calc_disp_common (gdbarch, regcache, x, bd, dh);
2796 /* Calculates memory address for VSCE[GF] instructions. */
2798 static int
2799 s390_record_calc_disp_vsce (struct gdbarch *gdbarch, struct regcache *regcache,
2800 uint8_t vx, uint8_t el, uint8_t es, uint16_t bd,
2801 int8_t dh, CORE_ADDR *res)
2803 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2804 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2805 ULONGEST x;
2806 gdb_byte buf[16];
2807 if (tdep->v0_full_regnum == -1 || el * es >= 16)
2808 return -1;
2809 if (vx < 16)
2810 regcache->cooked_read (tdep->v0_full_regnum + vx, buf);
2811 else
2812 regcache->raw_read (S390_V16_REGNUM + vx - 16, buf);
2813 x = extract_unsigned_integer (buf + el * es, es, byte_order);
2814 *res = s390_record_calc_disp_common (gdbarch, regcache, x, bd, dh);
2815 return 0;
2818 /* Calculates memory address for instructions with relative long addressing. */
2820 static CORE_ADDR
2821 s390_record_calc_rl (struct gdbarch *gdbarch, struct regcache *regcache,
2822 CORE_ADDR addr, uint16_t i1, uint16_t i2)
2824 int32_t ri = i1 << 16 | i2;
2825 return s390_record_address_mask (gdbarch, regcache, addr + (LONGEST)ri * 2);
2828 /* Population count helper. */
2830 static int s390_popcnt (unsigned int x) {
2831 int res = 0;
2832 while (x)
2834 if (x & 1)
2835 res++;
2836 x >>= 1;
2838 return res;
2841 /* Record 64-bit register. */
2843 static int
2844 s390_record_gpr_g (struct gdbarch *gdbarch, struct regcache *regcache, int i)
2846 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2847 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + i))
2848 return -1;
2849 if (tdep->abi == ABI_LINUX_S390)
2850 if (record_full_arch_list_add_reg (regcache, S390_R0_UPPER_REGNUM + i))
2851 return -1;
2852 return 0;
2855 /* Record high 32 bits of a register. */
2857 static int
2858 s390_record_gpr_h (struct gdbarch *gdbarch, struct regcache *regcache, int i)
2860 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2861 if (tdep->abi == ABI_LINUX_S390)
2863 if (record_full_arch_list_add_reg (regcache, S390_R0_UPPER_REGNUM + i))
2864 return -1;
2866 else
2868 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + i))
2869 return -1;
2871 return 0;
2874 /* Record vector register. */
2876 static int
2877 s390_record_vr (struct gdbarch *gdbarch, struct regcache *regcache, int i)
2879 if (i < 16)
2881 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + i))
2882 return -1;
2883 if (record_full_arch_list_add_reg (regcache, S390_V0_LOWER_REGNUM + i))
2884 return -1;
2886 else
2888 if (record_full_arch_list_add_reg (regcache, S390_V16_REGNUM + i - 16))
2889 return -1;
2891 return 0;
2894 /* Implement process_record gdbarch method. */
2896 static int
2897 s390_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
2898 CORE_ADDR addr)
2900 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2901 uint16_t insn[3] = {0};
2902 /* Instruction as bytes. */
2903 uint8_t ibyte[6];
2904 /* Instruction as nibbles. */
2905 uint8_t inib[12];
2906 /* Instruction vector registers. */
2907 uint8_t ivec[4];
2908 CORE_ADDR oaddr, oaddr2, oaddr3;
2909 ULONGEST tmp;
2910 int i, n;
2911 /* if EX/EXRL instruction used, here's the reg parameter */
2912 int ex = -1;
2913 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2915 /* Attempting to use EX or EXRL jumps back here */
2918 /* Read instruction. */
2919 insn[0] = read_memory_unsigned_integer (addr, 2, byte_order);
2920 /* If execute was involved, do the adjustment. */
2921 if (ex != -1)
2922 insn[0] |= ex & 0xff;
2923 /* Two highest bits determine instruction size. */
2924 if (insn[0] >= 0x4000)
2925 insn[1] = read_memory_unsigned_integer (addr+2, 2, byte_order);
2926 else
2927 /* Not necessary, but avoids uninitialized variable warnings. */
2928 insn[1] = 0;
2929 if (insn[0] >= 0xc000)
2930 insn[2] = read_memory_unsigned_integer (addr+4, 2, byte_order);
2931 else
2932 insn[2] = 0;
2933 /* Split instruction into bytes and nibbles. */
2934 for (i = 0; i < 3; i++)
2936 ibyte[i*2] = insn[i] >> 8 & 0xff;
2937 ibyte[i*2+1] = insn[i] & 0xff;
2939 for (i = 0; i < 6; i++)
2941 inib[i*2] = ibyte[i] >> 4 & 0xf;
2942 inib[i*2+1] = ibyte[i] & 0xf;
2944 /* Compute vector registers, if applicable. */
2945 ivec[0] = (inib[9] >> 3 & 1) << 4 | inib[2];
2946 ivec[1] = (inib[9] >> 2 & 1) << 4 | inib[3];
2947 ivec[2] = (inib[9] >> 1 & 1) << 4 | inib[4];
2948 ivec[3] = (inib[9] >> 0 & 1) << 4 | inib[8];
2950 switch (ibyte[0])
2952 /* 0x00 undefined */
2954 case 0x01:
2955 /* E-format instruction */
2956 switch (ibyte[1])
2958 /* 0x00 undefined */
2959 /* 0x01 unsupported: PR - program return */
2960 /* 0x02 unsupported: UPT */
2961 /* 0x03 undefined */
2962 /* 0x04 privileged: PTFF - perform timing facility function */
2963 /* 0x05-0x06 undefined */
2964 /* 0x07 privileged: SCKPF - set clock programmable field */
2965 /* 0x08-0x09 undefined */
2967 case 0x0a: /* PFPO - perform floating point operation */
2968 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM, &tmp);
2969 if (!(tmp & 0x80000000u))
2971 uint8_t ofc = tmp >> 16 & 0xff;
2972 switch (ofc)
2974 case 0x00: /* HFP32 */
2975 case 0x01: /* HFP64 */
2976 case 0x05: /* BFP32 */
2977 case 0x06: /* BFP64 */
2978 case 0x08: /* DFP32 */
2979 case 0x09: /* DFP64 */
2980 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM))
2981 return -1;
2982 break;
2983 case 0x02: /* HFP128 */
2984 case 0x07: /* BFP128 */
2985 case 0x0a: /* DFP128 */
2986 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM))
2987 return -1;
2988 if (record_full_arch_list_add_reg (regcache, S390_F2_REGNUM))
2989 return -1;
2990 break;
2991 default:
2992 fprintf_unfiltered (gdb_stdlog, "Warning: Unknown PFPO OFC %02x at %s.\n",
2993 ofc, paddress (gdbarch, addr));
2994 return -1;
2997 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
2998 return -1;
3000 if (record_full_arch_list_add_reg (regcache, S390_R1_REGNUM))
3001 return -1;
3002 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3003 return -1;
3004 break;
3006 case 0x0b: /* TAM - test address mode */
3007 case 0x0c: /* SAM24 - set address mode 24 */
3008 case 0x0d: /* SAM31 - set address mode 31 */
3009 case 0x0e: /* SAM64 - set address mode 64 */
3010 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3011 return -1;
3012 break;
3014 /* 0x0f-0xfe undefined */
3016 /* 0xff unsupported: TRAP */
3018 default:
3019 goto UNKNOWN_OP;
3021 break;
3023 /* 0x02 undefined */
3024 /* 0x03 undefined */
3026 case 0x04: /* SPM - set program mask */
3027 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3028 return -1;
3029 break;
3031 case 0x05: /* BALR - branch and link */
3032 case 0x45: /* BAL - branch and link */
3033 case 0x06: /* BCTR - branch on count */
3034 case 0x46: /* BCT - branch on count */
3035 case 0x0d: /* BASR - branch and save */
3036 case 0x4d: /* BAS - branch and save */
3037 case 0x84: /* BRXH - branch relative on index high */
3038 case 0x85: /* BRXLE - branch relative on index low or equal */
3039 case 0x86: /* BXH - branch on index high */
3040 case 0x87: /* BXLE - branch on index low or equal */
3041 /* BA[SL]* use native-size destination for linkage info, BCT*, BRX*, BX*
3042 use 32-bit destination as counter. */
3043 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
3044 return -1;
3045 break;
3047 case 0x07: /* BCR - branch on condition */
3048 case 0x47: /* BC - branch on condition */
3049 /* No effect other than PC transfer. */
3050 break;
3052 /* 0x08 undefined */
3053 /* 0x09 undefined */
3055 case 0x0a:
3056 /* SVC - supervisor call */
3057 if (tdep->s390_syscall_record != NULL)
3059 if (tdep->s390_syscall_record (regcache, ibyte[1]))
3060 return -1;
3062 else
3064 printf_unfiltered (_("no syscall record support\n"));
3065 return -1;
3067 break;
3069 case 0x0b: /* BSM - branch and set mode */
3070 if (inib[2])
3071 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
3072 return -1;
3073 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3074 return -1;
3075 break;
3077 case 0x0c: /* BASSM - branch and save and set mode */
3078 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
3079 return -1;
3080 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3081 return -1;
3082 break;
3084 case 0x0e: /* MVCL - move long [interruptible] */
3085 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + inib[2], &tmp);
3086 oaddr = s390_record_address_mask (gdbarch, regcache, tmp);
3087 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + (inib[2] | 1), &tmp);
3088 tmp &= 0xffffff;
3089 if (record_full_arch_list_add_mem (oaddr, tmp))
3090 return -1;
3091 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
3092 return -1;
3093 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[2] | 1)))
3094 return -1;
3095 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[3]))
3096 return -1;
3097 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[3] | 1)))
3098 return -1;
3099 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3100 return -1;
3101 break;
3103 case 0x0f: /* CLCL - compare logical long [interruptible] */
3104 case 0xa9: /* CLCLE - compare logical long extended [partial] */
3105 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
3106 return -1;
3107 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[2] | 1)))
3108 return -1;
3109 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[3]))
3110 return -1;
3111 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[3] | 1)))
3112 return -1;
3113 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3114 return -1;
3115 break;
3117 case 0x10: /* LPR - load positive */
3118 case 0x11: /* LNR - load negative */
3119 case 0x12: /* LTR - load and test */
3120 case 0x13: /* LCR - load complement */
3121 case 0x14: /* NR - and */
3122 case 0x16: /* OR - or */
3123 case 0x17: /* XR - xor */
3124 case 0x1a: /* AR - add */
3125 case 0x1b: /* SR - subtract */
3126 case 0x1e: /* ALR - add logical */
3127 case 0x1f: /* SLR - subtract logical */
3128 case 0x54: /* N - and */
3129 case 0x56: /* O - or */
3130 case 0x57: /* X - xor */
3131 case 0x5a: /* A - add */
3132 case 0x5b: /* S - subtract */
3133 case 0x5e: /* AL - add logical */
3134 case 0x5f: /* SL - subtract logical */
3135 case 0x4a: /* AH - add halfword */
3136 case 0x4b: /* SH - subtract halfword */
3137 case 0x8a: /* SRA - shift right single */
3138 case 0x8b: /* SLA - shift left single */
3139 case 0xbf: /* ICM - insert characters under mask */
3140 /* 32-bit destination + flags */
3141 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
3142 return -1;
3143 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3144 return -1;
3145 break;
3147 case 0x15: /* CLR - compare logical */
3148 case 0x55: /* CL - compare logical */
3149 case 0x19: /* CR - compare */
3150 case 0x29: /* CDR - compare */
3151 case 0x39: /* CER - compare */
3152 case 0x49: /* CH - compare halfword */
3153 case 0x59: /* C - compare */
3154 case 0x69: /* CD - compare */
3155 case 0x79: /* CE - compare */
3156 case 0x91: /* TM - test under mask */
3157 case 0x95: /* CLI - compare logical */
3158 case 0xbd: /* CLM - compare logical under mask */
3159 case 0xd5: /* CLC - compare logical */
3160 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3161 return -1;
3162 break;
3164 case 0x18: /* LR - load */
3165 case 0x48: /* LH - load halfword */
3166 case 0x58: /* L - load */
3167 case 0x41: /* LA - load address */
3168 case 0x43: /* IC - insert character */
3169 case 0x4c: /* MH - multiply halfword */
3170 case 0x71: /* MS - multiply single */
3171 case 0x88: /* SRL - shift right single logical */
3172 case 0x89: /* SLL - shift left single logical */
3173 /* 32-bit, 8-bit (IC), or native width (LA) destination, no flags */
3174 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
3175 return -1;
3176 break;
3178 case 0x1c: /* MR - multiply */
3179 case 0x5c: /* M - multiply */
3180 case 0x1d: /* DR - divide */
3181 case 0x5d: /* D - divide */
3182 case 0x8c: /* SRDL - shift right double logical */
3183 case 0x8d: /* SLDL - shift left double logical */
3184 /* 32-bit pair destination, no flags */
3185 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
3186 return -1;
3187 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[2] | 1)))
3188 return -1;
3189 break;
3191 case 0x20: /* LPDR - load positive */
3192 case 0x30: /* LPER - load positive */
3193 case 0x21: /* LNDR - load negative */
3194 case 0x31: /* LNER - load negative */
3195 case 0x22: /* LTDR - load and test */
3196 case 0x32: /* LTER - load and test */
3197 case 0x23: /* LCDR - load complement */
3198 case 0x33: /* LCER - load complement */
3199 case 0x2a: /* ADR - add */
3200 case 0x3a: /* AER - add */
3201 case 0x6a: /* AD - add */
3202 case 0x7a: /* AE - add */
3203 case 0x2b: /* SDR - subtract */
3204 case 0x3b: /* SER - subtract */
3205 case 0x6b: /* SD - subtract */
3206 case 0x7b: /* SE - subtract */
3207 case 0x2e: /* AWR - add unnormalized */
3208 case 0x3e: /* AUR - add unnormalized */
3209 case 0x6e: /* AW - add unnormalized */
3210 case 0x7e: /* AU - add unnormalized */
3211 case 0x2f: /* SWR - subtract unnormalized */
3212 case 0x3f: /* SUR - subtract unnormalized */
3213 case 0x6f: /* SW - subtract unnormalized */
3214 case 0x7f: /* SU - subtract unnormalized */
3215 /* float destination + flags */
3216 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[2]))
3217 return -1;
3218 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3219 return -1;
3220 break;
3222 case 0x24: /* HDR - halve */
3223 case 0x34: /* HER - halve */
3224 case 0x25: /* LDXR - load rounded */
3225 case 0x35: /* LEDR - load rounded */
3226 case 0x28: /* LDR - load */
3227 case 0x38: /* LER - load */
3228 case 0x68: /* LD - load */
3229 case 0x78: /* LE - load */
3230 case 0x2c: /* MDR - multiply */
3231 case 0x3c: /* MDER - multiply */
3232 case 0x6c: /* MD - multiply */
3233 case 0x7c: /* MDE - multiply */
3234 case 0x2d: /* DDR - divide */
3235 case 0x3d: /* DER - divide */
3236 case 0x6d: /* DD - divide */
3237 case 0x7d: /* DE - divide */
3238 /* float destination, no flags */
3239 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[2]))
3240 return -1;
3241 break;
3243 case 0x26: /* MXR - multiply */
3244 case 0x27: /* MXDR - multiply */
3245 case 0x67: /* MXD - multiply */
3246 /* float pair destination, no flags */
3247 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[2]))
3248 return -1;
3249 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + (inib[2] | 2)))
3250 return -1;
3251 break;
3253 case 0x36: /* AXR - add */
3254 case 0x37: /* SXR - subtract */
3255 /* float pair destination + flags */
3256 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[2]))
3257 return -1;
3258 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + (inib[2] | 2)))
3259 return -1;
3260 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3261 return -1;
3262 break;
3264 case 0x40: /* STH - store halfword */
3265 oaddr = s390_record_calc_disp (gdbarch, regcache, inib[3], insn[1], 0);
3266 if (record_full_arch_list_add_mem (oaddr, 2))
3267 return -1;
3268 break;
3270 case 0x42: /* STC - store character */
3271 oaddr = s390_record_calc_disp (gdbarch, regcache, inib[3], insn[1], 0);
3272 if (record_full_arch_list_add_mem (oaddr, 1))
3273 return -1;
3274 break;
3276 case 0x44: /* EX - execute */
3277 if (ex != -1)
3279 fprintf_unfiltered (gdb_stdlog, "Warning: Double execute at %s.\n",
3280 paddress (gdbarch, addr));
3281 return -1;
3283 addr = s390_record_calc_disp (gdbarch, regcache, inib[3], insn[1], 0);
3284 if (inib[2])
3286 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + inib[2], &tmp);
3287 ex = tmp & 0xff;
3289 else
3291 ex = 0;
3293 goto ex;
3295 case 0x4e: /* CVD - convert to decimal */
3296 case 0x60: /* STD - store */
3297 oaddr = s390_record_calc_disp (gdbarch, regcache, inib[3], insn[1], 0);
3298 if (record_full_arch_list_add_mem (oaddr, 8))
3299 return -1;
3300 break;
3302 case 0x4f: /* CVB - convert to binary */
3303 /* 32-bit gpr destination + FPC (DXC write) */
3304 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
3305 return -1;
3306 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
3307 return -1;
3308 break;
3310 case 0x50: /* ST - store */
3311 case 0x70: /* STE - store */
3312 oaddr = s390_record_calc_disp (gdbarch, regcache, inib[3], insn[1], 0);
3313 if (record_full_arch_list_add_mem (oaddr, 4))
3314 return -1;
3315 break;
3317 case 0x51: /* LAE - load address extended */
3318 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
3319 return -1;
3320 if (record_full_arch_list_add_reg (regcache, S390_A0_REGNUM + inib[2]))
3321 return -1;
3322 break;
3324 /* 0x52 undefined */
3325 /* 0x53 undefined */
3327 /* 0x61-0x66 undefined */
3329 /* 0x72-0x77 undefined */
3331 /* 0x80 privileged: SSM - set system mask */
3332 /* 0x81 undefined */
3333 /* 0x82 privileged: LPSW - load PSW */
3334 /* 0x83 privileged: diagnose */
3336 case 0x8e: /* SRDA - shift right double */
3337 case 0x8f: /* SLDA - shift left double */
3338 /* 32-bit pair destination + flags */
3339 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
3340 return -1;
3341 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[2] | 1)))
3342 return -1;
3343 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3344 return -1;
3345 break;
3347 case 0x90: /* STM - store multiple */
3348 case 0x9b: /* STAM - store access multiple */
3349 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
3350 if (inib[2] <= inib[3])
3351 n = inib[3] - inib[2] + 1;
3352 else
3353 n = inib[3] + 0x10 - inib[2] + 1;
3354 if (record_full_arch_list_add_mem (oaddr, n * 4))
3355 return -1;
3356 break;
3358 case 0x92: /* MVI - move */
3359 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
3360 if (record_full_arch_list_add_mem (oaddr, 1))
3361 return -1;
3362 break;
3364 case 0x93: /* TS - test and set */
3365 case 0x94: /* NI - and */
3366 case 0x96: /* OI - or */
3367 case 0x97: /* XI - xor */
3368 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
3369 if (record_full_arch_list_add_mem (oaddr, 1))
3370 return -1;
3371 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3372 return -1;
3373 break;
3375 case 0x98: /* LM - load multiple */
3376 for (i = inib[2]; i != inib[3]; i++, i &= 0xf)
3377 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + i))
3378 return -1;
3379 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[3]))
3380 return -1;
3381 break;
3383 /* 0x99 privileged: TRACE */
3385 case 0x9a: /* LAM - load access multiple */
3386 for (i = inib[2]; i != inib[3]; i++, i &= 0xf)
3387 if (record_full_arch_list_add_reg (regcache, S390_A0_REGNUM + i))
3388 return -1;
3389 if (record_full_arch_list_add_reg (regcache, S390_A0_REGNUM + inib[3]))
3390 return -1;
3391 break;
3393 /* 0x9c-0x9f privileged and obsolete (old I/O) */
3394 /* 0xa0-0xa4 undefined */
3396 case 0xa5:
3397 case 0xa7:
3398 /* RI-format instruction */
3399 switch (ibyte[0] << 4 | inib[3])
3401 case 0xa50: /* IIHH - insert immediate */
3402 case 0xa51: /* IIHL - insert immediate */
3403 /* high 32-bit destination */
3404 if (s390_record_gpr_h (gdbarch, regcache, inib[2]))
3405 return -1;
3406 break;
3408 case 0xa52: /* IILH - insert immediate */
3409 case 0xa53: /* IILL - insert immediate */
3410 case 0xa75: /* BRAS - branch relative and save */
3411 case 0xa76: /* BRCT - branch relative on count */
3412 case 0xa78: /* LHI - load halfword immediate */
3413 case 0xa7c: /* MHI - multiply halfword immediate */
3414 /* 32-bit or native destination */
3415 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
3416 return -1;
3417 break;
3419 case 0xa54: /* NIHH - and immediate */
3420 case 0xa55: /* NIHL - and immediate */
3421 case 0xa58: /* OIHH - or immediate */
3422 case 0xa59: /* OIHL - or immediate */
3423 /* high 32-bit destination + flags */
3424 if (s390_record_gpr_h (gdbarch, regcache, inib[2]))
3425 return -1;
3426 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3427 return -1;
3428 break;
3430 case 0xa56: /* NILH - and immediate */
3431 case 0xa57: /* NILL - and immediate */
3432 case 0xa5a: /* OILH - or immediate */
3433 case 0xa5b: /* OILL - or immediate */
3434 case 0xa7a: /* AHI - add halfword immediate */
3435 /* 32-bit destination + flags */
3436 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
3437 return -1;
3438 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3439 return -1;
3440 break;
3442 case 0xa5c: /* LLIHH - load logical immediate */
3443 case 0xa5d: /* LLIHL - load logical immediate */
3444 case 0xa5e: /* LLILH - load logical immediate */
3445 case 0xa5f: /* LLILL - load logical immediate */
3446 case 0xa77: /* BRCTG - branch relative on count */
3447 case 0xa79: /* LGHI - load halfword immediate */
3448 case 0xa7d: /* MGHI - multiply halfword immediate */
3449 /* 64-bit destination */
3450 if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
3451 return -1;
3452 break;
3454 case 0xa70: /* TMLH - test under mask */
3455 case 0xa71: /* TMLL - test under mask */
3456 case 0xa72: /* TMHH - test under mask */
3457 case 0xa73: /* TMHL - test under mask */
3458 case 0xa7e: /* CHI - compare halfword immediate */
3459 case 0xa7f: /* CGHI - compare halfword immediate */
3460 /* flags only */
3461 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3462 return -1;
3463 break;
3465 case 0xa74: /* BRC - branch relative on condition */
3466 /* no register change */
3467 break;
3469 case 0xa7b: /* AGHI - add halfword immediate */
3470 /* 64-bit destination + flags */
3471 if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
3472 return -1;
3473 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3474 return -1;
3475 break;
3477 default:
3478 goto UNKNOWN_OP;
3480 break;
3482 /* 0xa6 undefined */
3484 case 0xa8: /* MVCLE - move long extended [partial] */
3485 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + inib[2], &tmp);
3486 oaddr = s390_record_address_mask (gdbarch, regcache, tmp);
3487 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + (inib[2] | 1), &tmp);
3488 if (record_full_arch_list_add_mem (oaddr, tmp))
3489 return -1;
3490 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
3491 return -1;
3492 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[2] | 1)))
3493 return -1;
3494 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[3]))
3495 return -1;
3496 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[3] | 1)))
3497 return -1;
3498 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3499 return -1;
3500 break;
3502 /* 0xaa-0xab undefined */
3503 /* 0xac privileged: STNSM - store then and system mask */
3504 /* 0xad privileged: STOSM - store then or system mask */
3505 /* 0xae privileged: SIGP - signal processor */
3506 /* 0xaf unsupported: MC - monitor call */
3507 /* 0xb0 undefined */
3508 /* 0xb1 privileged: LRA - load real address */
3510 case 0xb2:
3511 case 0xb3:
3512 case 0xb9:
3513 /* S/RRD/RRE/RRF/IE-format instruction */
3514 switch (insn[0])
3516 /* 0xb200-0xb204 undefined or privileged */
3518 case 0xb205: /* STCK - store clock */
3519 case 0xb27c: /* STCKF - store clock fast */
3520 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
3521 if (record_full_arch_list_add_mem (oaddr, 8))
3522 return -1;
3523 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3524 return -1;
3525 break;
3527 /* 0xb206-0xb219 undefined, privileged, or unsupported */
3528 /* 0xb21a unsupported: CFC */
3529 /* 0xb21b-0xb221 undefined or privileged */
3531 case 0xb222: /* IPM - insert program mask */
3532 case 0xb24f: /* EAR - extract access */
3533 case 0xb252: /* MSR - multiply single */
3534 case 0xb2ec: /* ETND - extract transaction nesting depth */
3535 case 0xb38c: /* EFPC - extract fpc */
3536 case 0xb91f: /* LRVR - load reversed */
3537 case 0xb926: /* LBR - load byte */
3538 case 0xb927: /* LHR - load halfword */
3539 case 0xb994: /* LLCR - load logical character */
3540 case 0xb995: /* LLHR - load logical halfword */
3541 case 0xb9f2: /* LOCR - load on condition */
3542 /* 32-bit gpr destination */
3543 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
3544 return -1;
3545 break;
3547 /* 0xb223-0xb22c privileged or unsupported */
3549 case 0xb22d: /* DXR - divide */
3550 case 0xb325: /* LXDR - load lengthened */
3551 case 0xb326: /* LXER - load lengthened */
3552 case 0xb336: /* SQXR - square root */
3553 case 0xb365: /* LXR - load */
3554 case 0xb367: /* FIXR - load fp integer */
3555 case 0xb376: /* LZXR - load zero */
3556 case 0xb3b6: /* CXFR - convert from fixed */
3557 case 0xb3c6: /* CXGR - convert from fixed */
3558 case 0xb3fe: /* IEXTR - insert biased exponent */
3559 /* float pair destination */
3560 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[6]))
3561 return -1;
3562 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + (inib[6] | 2)))
3563 return -1;
3564 break;
3566 /* 0xb22e-0xb240 undefined, privileged, or unsupported */
3568 case 0xb241: /* CKSM - checksum [partial] */
3569 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
3570 return -1;
3571 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[7]))
3572 return -1;
3573 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[7] | 1)))
3574 return -1;
3575 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3576 return -1;
3577 break;
3579 /* 0xb242-0xb243 undefined */
3581 case 0xb244: /* SQDR - square root */
3582 case 0xb245: /* SQER - square root */
3583 case 0xb324: /* LDER - load lengthened */
3584 case 0xb337: /* MEER - multiply */
3585 case 0xb366: /* LEXR - load rounded */
3586 case 0xb370: /* LPDFR - load positive */
3587 case 0xb371: /* LNDFR - load negative */
3588 case 0xb372: /* CSDFR - copy sign */
3589 case 0xb373: /* LCDFR - load complement */
3590 case 0xb374: /* LZER - load zero */
3591 case 0xb375: /* LZDR - load zero */
3592 case 0xb377: /* FIER - load fp integer */
3593 case 0xb37f: /* FIDR - load fp integer */
3594 case 0xb3b4: /* CEFR - convert from fixed */
3595 case 0xb3b5: /* CDFR - convert from fixed */
3596 case 0xb3c1: /* LDGR - load fpr from gr */
3597 case 0xb3c4: /* CEGR - convert from fixed */
3598 case 0xb3c5: /* CDGR - convert from fixed */
3599 case 0xb3f6: /* IEDTR - insert biased exponent */
3600 /* float destination */
3601 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[6]))
3602 return -1;
3603 break;
3605 /* 0xb246-0xb24c: privileged or unsupported */
3607 case 0xb24d: /* CPYA - copy access */
3608 case 0xb24e: /* SAR - set access */
3609 if (record_full_arch_list_add_reg (regcache, S390_A0_REGNUM + inib[6]))
3610 return -1;
3611 break;
3613 /* 0xb250-0xb251 undefined or privileged */
3614 /* 0xb253-0xb254 undefined or privileged */
3616 case 0xb255: /* MVST - move string [partial] */
3618 uint8_t end;
3619 gdb_byte cur;
3620 ULONGEST num = 0;
3621 /* Read ending byte. */
3622 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM, &tmp);
3623 end = tmp & 0xff;
3624 /* Get address of second operand. */
3625 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + inib[7], &tmp);
3626 oaddr = s390_record_address_mask (gdbarch, regcache, tmp);
3627 /* Search for ending byte and compute length. */
3628 do {
3629 num++;
3630 if (target_read_memory (oaddr, &cur, 1))
3631 return -1;
3632 oaddr++;
3633 } while (cur != end);
3634 /* Get address of first operand and record it. */
3635 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + inib[6], &tmp);
3636 oaddr = s390_record_address_mask (gdbarch, regcache, tmp);
3637 if (record_full_arch_list_add_mem (oaddr, num))
3638 return -1;
3639 /* Record the registers. */
3640 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
3641 return -1;
3642 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[7]))
3643 return -1;
3644 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3645 return -1;
3647 break;
3649 /* 0xb256 undefined */
3651 case 0xb257: /* CUSE - compare until substring equal [interruptible] */
3652 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
3653 return -1;
3654 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[6] | 1)))
3655 return -1;
3656 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[7]))
3657 return -1;
3658 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[7] | 1)))
3659 return -1;
3660 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3661 return -1;
3662 break;
3664 /* 0xb258-0xb25c undefined, privileged, or unsupported */
3666 case 0xb25d: /* CLST - compare logical string [partial] */
3667 case 0xb25e: /* SRST - search string [partial] */
3668 case 0xb9be: /* SRSTU - search string unicode [partial] */
3669 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
3670 return -1;
3671 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[7]))
3672 return -1;
3673 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3674 return -1;
3675 break;
3677 /* 0xb25f-0xb262 undefined */
3679 case 0xb263: /* CMPSC - compression call [interruptible] */
3680 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + inib[6], &tmp);
3681 oaddr = s390_record_address_mask (gdbarch, regcache, tmp);
3682 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + (inib[6] | 1), &tmp);
3683 if (record_full_arch_list_add_mem (oaddr, tmp))
3684 return -1;
3685 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
3686 return -1;
3687 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[6] | 1)))
3688 return -1;
3689 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[7]))
3690 return -1;
3691 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[7] | 1)))
3692 return -1;
3693 if (record_full_arch_list_add_reg (regcache, S390_R1_REGNUM))
3694 return -1;
3695 /* DXC may be written */
3696 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
3697 return -1;
3698 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3699 return -1;
3700 break;
3702 /* 0xb264-0xb277 undefined, privileged, or unsupported */
3704 case 0xb278: /* STCKE - store clock extended */
3705 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
3706 if (record_full_arch_list_add_mem (oaddr, 16))
3707 return -1;
3708 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3709 return -1;
3710 break;
3712 /* 0xb279-0xb27b undefined or unsupported */
3713 /* 0xb27d-0xb298 undefined or privileged */
3715 case 0xb299: /* SRNM - set rounding mode */
3716 case 0xb2b8: /* SRNMB - set bfp rounding mode */
3717 case 0xb2b9: /* SRNMT - set dfp rounding mode */
3718 case 0xb29d: /* LFPC - load fpc */
3719 case 0xb2bd: /* LFAS - load fpc and signal */
3720 case 0xb384: /* SFPC - set fpc */
3721 case 0xb385: /* SFASR - set fpc and signal */
3722 case 0xb960: /* CGRT - compare and trap */
3723 case 0xb961: /* CLGRT - compare logical and trap */
3724 case 0xb972: /* CRT - compare and trap */
3725 case 0xb973: /* CLRT - compare logical and trap */
3726 /* fpc only - including possible DXC write for trapping insns */
3727 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
3728 return -1;
3729 break;
3731 /* 0xb29a-0xb29b undefined */
3733 case 0xb29c: /* STFPC - store fpc */
3734 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
3735 if (record_full_arch_list_add_mem (oaddr, 4))
3736 return -1;
3737 break;
3739 /* 0xb29e-0xb2a4 undefined */
3741 case 0xb2a5: /* TRE - translate extended [partial] */
3742 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + inib[6], &tmp);
3743 oaddr = s390_record_address_mask (gdbarch, regcache, tmp);
3744 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + (inib[6] | 1), &tmp);
3745 if (record_full_arch_list_add_mem (oaddr, tmp))
3746 return -1;
3747 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
3748 return -1;
3749 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[6] | 1)))
3750 return -1;
3751 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3752 return -1;
3753 break;
3755 case 0xb2a6: /* CU21 - convert UTF-16 to UTF-8 [partial] */
3756 case 0xb2a7: /* CU12 - convert UTF-8 to UTF-16 [partial] */
3757 case 0xb9b0: /* CU14 - convert UTF-8 to UTF-32 [partial] */
3758 case 0xb9b1: /* CU24 - convert UTF-16 to UTF-32 [partial] */
3759 case 0xb9b2: /* CU41 - convert UTF-32 to UTF-8 [partial] */
3760 case 0xb9b3: /* CU42 - convert UTF-32 to UTF-16 [partial] */
3761 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + inib[6], &tmp);
3762 oaddr = s390_record_address_mask (gdbarch, regcache, tmp);
3763 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + (inib[6] | 1), &tmp);
3764 if (record_full_arch_list_add_mem (oaddr, tmp))
3765 return -1;
3766 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
3767 return -1;
3768 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[6] | 1)))
3769 return -1;
3770 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[7]))
3771 return -1;
3772 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[7] | 1)))
3773 return -1;
3774 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3775 return -1;
3776 break;
3778 /* 0xb2a8-0xb2af undefined */
3780 case 0xb2b0: /* STFLE - store facility list extended */
3781 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
3782 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM, &tmp);
3783 tmp &= 0xff;
3784 if (record_full_arch_list_add_mem (oaddr, 8 * (tmp + 1)))
3785 return -1;
3786 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM))
3787 return -1;
3788 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3789 return -1;
3790 break;
3792 /* 0xb2b1-0xb2b7 undefined or privileged */
3793 /* 0xb2ba-0xb2bc undefined */
3794 /* 0xb2be-0xb2e7 undefined */
3795 /* 0xb2e9-0xb2eb undefined */
3796 /* 0xb2ed-0xb2f7 undefined */
3797 /* 0xb2f8 unsupported: TEND */
3798 /* 0xb2f9 undefined */
3800 case 0xb2e8: /* PPA - perform processor assist */
3801 case 0xb2fa: /* NIAI - next instruction access intent */
3802 /* no visible effects */
3803 break;
3805 /* 0xb2fb undefined */
3806 /* 0xb2fc unsupported: TABORT */
3807 /* 0xb2fd-0xb2fe undefined */
3808 /* 0xb2ff unsupported: TRAP */
3810 case 0xb300: /* LPEBR - load positive */
3811 case 0xb301: /* LNEBR - load negative */
3812 case 0xb303: /* LCEBR - load complement */
3813 case 0xb310: /* LPDBR - load positive */
3814 case 0xb311: /* LNDBR - load negative */
3815 case 0xb313: /* LCDBR - load complement */
3816 case 0xb350: /* TBEDR - convert hfp to bfp */
3817 case 0xb351: /* TBDR - convert hfp to bfp */
3818 case 0xb358: /* THDER - convert bfp to hfp */
3819 case 0xb359: /* THDR - convert bfp to hfp */
3820 /* float destination + flags */
3821 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[6]))
3822 return -1;
3823 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3824 return -1;
3825 break;
3827 case 0xb304: /* LDEBR - load lengthened */
3828 case 0xb30c: /* MDEBR - multiply */
3829 case 0xb30d: /* DEBR - divide */
3830 case 0xb314: /* SQEBR - square root */
3831 case 0xb315: /* SQDBR - square root */
3832 case 0xb317: /* MEEBR - multiply */
3833 case 0xb31c: /* MDBR - multiply */
3834 case 0xb31d: /* DDBR - divide */
3835 case 0xb344: /* LEDBRA - load rounded */
3836 case 0xb345: /* LDXBRA - load rounded */
3837 case 0xb346: /* LEXBRA - load rounded */
3838 case 0xb357: /* FIEBRA - load fp integer */
3839 case 0xb35f: /* FIDBRA - load fp integer */
3840 case 0xb390: /* CELFBR - convert from logical */
3841 case 0xb391: /* CDLFBR - convert from logical */
3842 case 0xb394: /* CEFBR - convert from fixed */
3843 case 0xb395: /* CDFBR - convert from fixed */
3844 case 0xb3a0: /* CELGBR - convert from logical */
3845 case 0xb3a1: /* CDLGBR - convert from logical */
3846 case 0xb3a4: /* CEGBR - convert from fixed */
3847 case 0xb3a5: /* CDGBR - convert from fixed */
3848 case 0xb3d0: /* MDTR - multiply */
3849 case 0xb3d1: /* DDTR - divide */
3850 case 0xb3d4: /* LDETR - load lengthened */
3851 case 0xb3d5: /* LEDTR - load lengthened */
3852 case 0xb3d7: /* FIDTR - load fp integer */
3853 case 0xb3dd: /* LDXTR - load lengthened */
3854 case 0xb3f1: /* CDGTR - convert from fixed */
3855 case 0xb3f2: /* CDUTR - convert from unsigned packed */
3856 case 0xb3f3: /* CDSTR - convert from signed packed */
3857 case 0xb3f5: /* QADTR - quantize */
3858 case 0xb3f7: /* RRDTR - reround */
3859 case 0xb951: /* CDFTR - convert from fixed */
3860 case 0xb952: /* CDLGTR - convert from logical */
3861 case 0xb953: /* CDLFTR - convert from logical */
3862 /* float destination + fpc */
3863 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[6]))
3864 return -1;
3865 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
3866 return -1;
3867 break;
3869 case 0xb305: /* LXDBR - load lengthened */
3870 case 0xb306: /* LXEBR - load lengthened */
3871 case 0xb307: /* MXDBR - multiply */
3872 case 0xb316: /* SQXBR - square root */
3873 case 0xb34c: /* MXBR - multiply */
3874 case 0xb34d: /* DXBR - divide */
3875 case 0xb347: /* FIXBRA - load fp integer */
3876 case 0xb392: /* CXLFBR - convert from logical */
3877 case 0xb396: /* CXFBR - convert from fixed */
3878 case 0xb3a2: /* CXLGBR - convert from logical */
3879 case 0xb3a6: /* CXGBR - convert from fixed */
3880 case 0xb3d8: /* MXTR - multiply */
3881 case 0xb3d9: /* DXTR - divide */
3882 case 0xb3dc: /* LXDTR - load lengthened */
3883 case 0xb3df: /* FIXTR - load fp integer */
3884 case 0xb3f9: /* CXGTR - convert from fixed */
3885 case 0xb3fa: /* CXUTR - convert from unsigned packed */
3886 case 0xb3fb: /* CXSTR - convert from signed packed */
3887 case 0xb3fd: /* QAXTR - quantize */
3888 case 0xb3ff: /* RRXTR - reround */
3889 case 0xb959: /* CXFTR - convert from fixed */
3890 case 0xb95a: /* CXLGTR - convert from logical */
3891 case 0xb95b: /* CXLFTR - convert from logical */
3892 /* float pair destination + fpc */
3893 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[6]))
3894 return -1;
3895 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + (inib[6] | 2)))
3896 return -1;
3897 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
3898 return -1;
3899 break;
3901 case 0xb308: /* KEBR - compare and signal */
3902 case 0xb309: /* CEBR - compare */
3903 case 0xb318: /* KDBR - compare and signal */
3904 case 0xb319: /* CDBR - compare */
3905 case 0xb348: /* KXBR - compare and signal */
3906 case 0xb349: /* CXBR - compare */
3907 case 0xb3e0: /* KDTR - compare and signal */
3908 case 0xb3e4: /* CDTR - compare */
3909 case 0xb3e8: /* KXTR - compare and signal */
3910 case 0xb3ec: /* CXTR - compare */
3911 /* flags + fpc only */
3912 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3913 return -1;
3914 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
3915 return -1;
3916 break;
3918 case 0xb302: /* LTEBR - load and test */
3919 case 0xb312: /* LTDBR - load and test */
3920 case 0xb30a: /* AEBR - add */
3921 case 0xb30b: /* SEBR - subtract */
3922 case 0xb31a: /* ADBR - add */
3923 case 0xb31b: /* SDBR - subtract */
3924 case 0xb3d2: /* ADTR - add */
3925 case 0xb3d3: /* SDTR - subtract */
3926 case 0xb3d6: /* LTDTR - load and test */
3927 /* float destination + flags + fpc */
3928 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[6]))
3929 return -1;
3930 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3931 return -1;
3932 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
3933 return -1;
3934 break;
3936 case 0xb30e: /* MAEBR - multiply and add */
3937 case 0xb30f: /* MSEBR - multiply and subtract */
3938 case 0xb31e: /* MADBR - multiply and add */
3939 case 0xb31f: /* MSDBR - multiply and subtract */
3940 /* float destination [RRD] + fpc */
3941 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[4]))
3942 return -1;
3943 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
3944 return -1;
3945 break;
3947 /* 0xb320-0xb323 undefined */
3948 /* 0xb327-0xb32d undefined */
3950 case 0xb32e: /* MAER - multiply and add */
3951 case 0xb32f: /* MSER - multiply and subtract */
3952 case 0xb338: /* MAYLR - multiply and add unnormalized */
3953 case 0xb339: /* MYLR - multiply unnormalized */
3954 case 0xb33c: /* MAYHR - multiply and add unnormalized */
3955 case 0xb33d: /* MYHR - multiply unnormalized */
3956 case 0xb33e: /* MADR - multiply and add */
3957 case 0xb33f: /* MSDR - multiply and subtract */
3958 /* float destination [RRD] */
3959 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[4]))
3960 return -1;
3961 break;
3963 /* 0xb330-0xb335 undefined */
3965 case 0xb33a: /* MAYR - multiply and add unnormalized */
3966 case 0xb33b: /* MYR - multiply unnormalized */
3967 /* float pair destination [RRD] */
3968 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[4]))
3969 return -1;
3970 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + (inib[4] | 2)))
3971 return -1;
3972 break;
3974 case 0xb340: /* LPXBR - load positive */
3975 case 0xb341: /* LNXBR - load negative */
3976 case 0xb343: /* LCXBR - load complement */
3977 case 0xb360: /* LPXR - load positive */
3978 case 0xb361: /* LNXR - load negative */
3979 case 0xb362: /* LTXR - load and test */
3980 case 0xb363: /* LCXR - load complement */
3981 /* float pair destination + flags */
3982 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[6]))
3983 return -1;
3984 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + (inib[6] | 2)))
3985 return -1;
3986 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3987 return -1;
3988 break;
3990 case 0xb342: /* LTXBR - load and test */
3991 case 0xb34a: /* AXBR - add */
3992 case 0xb34b: /* SXBR - subtract */
3993 case 0xb3da: /* AXTR - add */
3994 case 0xb3db: /* SXTR - subtract */
3995 case 0xb3de: /* LTXTR - load and test */
3996 /* float pair destination + flags + fpc */
3997 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[6]))
3998 return -1;
3999 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + (inib[6] | 2)))
4000 return -1;
4001 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4002 return -1;
4003 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
4004 return -1;
4005 break;
4007 /* 0xb34e-0xb34f undefined */
4008 /* 0xb352 undefined */
4010 case 0xb353: /* DIEBR - divide to integer */
4011 case 0xb35b: /* DIDBR - divide to integer */
4012 /* two float destinations + flags + fpc */
4013 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[4]))
4014 return -1;
4015 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[6]))
4016 return -1;
4017 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4018 return -1;
4019 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
4020 return -1;
4021 break;
4023 /* 0xb354-0xb356 undefined */
4024 /* 0xb35a undefined */
4026 /* 0xb35c-0xb35e undefined */
4027 /* 0xb364 undefined */
4028 /* 0xb368 undefined */
4030 case 0xb369: /* CXR - compare */
4031 case 0xb3f4: /* CEDTR - compare biased exponent */
4032 case 0xb3fc: /* CEXTR - compare biased exponent */
4033 case 0xb920: /* CGR - compare */
4034 case 0xb921: /* CLGR - compare logical */
4035 case 0xb930: /* CGFR - compare */
4036 case 0xb931: /* CLGFR - compare logical */
4037 case 0xb9cd: /* CHHR - compare high */
4038 case 0xb9cf: /* CLHHR - compare logical high */
4039 case 0xb9dd: /* CHLR - compare high */
4040 case 0xb9df: /* CLHLR - compare logical high */
4041 /* flags only */
4042 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4043 return -1;
4044 break;
4046 /* 0xb36a-0xb36f undefined */
4047 /* 0xb377-0xb37e undefined */
4048 /* 0xb380-0xb383 undefined */
4049 /* 0xb386-0xb38b undefined */
4050 /* 0xb38d-0xb38f undefined */
4051 /* 0xb393 undefined */
4052 /* 0xb397 undefined */
4054 case 0xb398: /* CFEBR - convert to fixed */
4055 case 0xb399: /* CFDBR - convert to fixed */
4056 case 0xb39a: /* CFXBR - convert to fixed */
4057 case 0xb39c: /* CLFEBR - convert to logical */
4058 case 0xb39d: /* CLFDBR - convert to logical */
4059 case 0xb39e: /* CLFXBR - convert to logical */
4060 case 0xb941: /* CFDTR - convert to fixed */
4061 case 0xb949: /* CFXTR - convert to fixed */
4062 case 0xb943: /* CLFDTR - convert to logical */
4063 case 0xb94b: /* CLFXTR - convert to logical */
4064 /* 32-bit gpr destination + flags + fpc */
4065 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
4066 return -1;
4067 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4068 return -1;
4069 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
4070 return -1;
4071 break;
4073 /* 0xb39b undefined */
4074 /* 0xb39f undefined */
4076 /* 0xb3a3 undefined */
4077 /* 0xb3a7 undefined */
4079 case 0xb3a8: /* CGEBR - convert to fixed */
4080 case 0xb3a9: /* CGDBR - convert to fixed */
4081 case 0xb3aa: /* CGXBR - convert to fixed */
4082 case 0xb3ac: /* CLGEBR - convert to logical */
4083 case 0xb3ad: /* CLGDBR - convert to logical */
4084 case 0xb3ae: /* CLGXBR - convert to logical */
4085 case 0xb3e1: /* CGDTR - convert to fixed */
4086 case 0xb3e9: /* CGXTR - convert to fixed */
4087 case 0xb942: /* CLGDTR - convert to logical */
4088 case 0xb94a: /* CLGXTR - convert to logical */
4089 /* 64-bit gpr destination + flags + fpc */
4090 if (s390_record_gpr_g (gdbarch, regcache, inib[6]))
4091 return -1;
4092 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4093 return -1;
4094 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
4095 return -1;
4096 break;
4098 /* 0xb3ab undefined */
4099 /* 0xb3af-0xb3b3 undefined */
4100 /* 0xb3b7 undefined */
4102 case 0xb3b8: /* CFER - convert to fixed */
4103 case 0xb3b9: /* CFDR - convert to fixed */
4104 case 0xb3ba: /* CFXR - convert to fixed */
4105 case 0xb998: /* ALCR - add logical with carry */
4106 case 0xb999: /* SLBR - subtract logical with borrow */
4107 case 0xb9f4: /* NRK - and */
4108 case 0xb9f6: /* ORK - or */
4109 case 0xb9f7: /* XRK - xor */
4110 case 0xb9f8: /* ARK - add */
4111 case 0xb9f9: /* SRK - subtract */
4112 case 0xb9fa: /* ALRK - add logical */
4113 case 0xb9fb: /* SLRK - subtract logical */
4114 /* 32-bit gpr destination + flags */
4115 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
4116 return -1;
4117 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4118 return -1;
4119 break;
4121 case 0xb3c8: /* CGER - convert to fixed */
4122 case 0xb3c9: /* CGDR - convert to fixed */
4123 case 0xb3ca: /* CGXR - convert to fixed */
4124 case 0xb900: /* LPGR - load positive */
4125 case 0xb901: /* LNGR - load negative */
4126 case 0xb902: /* LTGR - load and test */
4127 case 0xb903: /* LCGR - load complement */
4128 case 0xb908: /* AGR - add */
4129 case 0xb909: /* SGR - subtract */
4130 case 0xb90a: /* ALGR - add logical */
4131 case 0xb90b: /* SLGR - subtract logical */
4132 case 0xb910: /* LPGFR - load positive */
4133 case 0xb911: /* LNGFR - load negative */
4134 case 0xb912: /* LTGFR - load and test */
4135 case 0xb913: /* LCGFR - load complement */
4136 case 0xb918: /* AGFR - add */
4137 case 0xb919: /* SGFR - subtract */
4138 case 0xb91a: /* ALGFR - add logical */
4139 case 0xb91b: /* SLGFR - subtract logical */
4140 case 0xb980: /* NGR - and */
4141 case 0xb981: /* OGR - or */
4142 case 0xb982: /* XGR - xor */
4143 case 0xb988: /* ALCGR - add logical with carry */
4144 case 0xb989: /* SLBGR - subtract logical with borrow */
4145 case 0xb9e1: /* POPCNT - population count */
4146 case 0xb9e4: /* NGRK - and */
4147 case 0xb9e6: /* OGRK - or */
4148 case 0xb9e7: /* XGRK - xor */
4149 case 0xb9e8: /* AGRK - add */
4150 case 0xb9e9: /* SGRK - subtract */
4151 case 0xb9ea: /* ALGRK - add logical */
4152 case 0xb9eb: /* SLGRK - subtract logical */
4153 case 0xb9ed: /* MSGRKC - multiply single 64x64 -> 64 */
4154 case 0xb9fd: /* MSRKC - multiply single 32x32 -> 32 */
4155 /* 64-bit gpr destination + flags */
4156 if (s390_record_gpr_g (gdbarch, regcache, inib[6]))
4157 return -1;
4158 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4159 return -1;
4160 break;
4162 /* 0xb3bb-0xb3c0 undefined */
4163 /* 0xb3c2-0xb3c3 undefined */
4164 /* 0xb3c7 undefined */
4165 /* 0xb3cb-0xb3cc undefined */
4167 case 0xb3cd: /* LGDR - load gr from fpr */
4168 case 0xb3e2: /* CUDTR - convert to unsigned packed */
4169 case 0xb3e3: /* CSDTR - convert to signed packed */
4170 case 0xb3e5: /* EEDTR - extract biased exponent */
4171 case 0xb3e7: /* ESDTR - extract significance */
4172 case 0xb3ed: /* EEXTR - extract biased exponent */
4173 case 0xb3ef: /* ESXTR - extract significance */
4174 case 0xb904: /* LGR - load */
4175 case 0xb906: /* LGBR - load byte */
4176 case 0xb907: /* LGHR - load halfword */
4177 case 0xb90c: /* MSGR - multiply single */
4178 case 0xb90f: /* LRVGR - load reversed */
4179 case 0xb914: /* LGFR - load */
4180 case 0xb916: /* LLGFR - load logical */
4181 case 0xb917: /* LLGTR - load logical thirty one bits */
4182 case 0xb91c: /* MSGFR - multiply single 64<32 */
4183 case 0xb946: /* BCTGR - branch on count */
4184 case 0xb984: /* LLGCR - load logical character */
4185 case 0xb985: /* LLGHR - load logical halfword */
4186 case 0xb9e2: /* LOCGR - load on condition */
4187 /* 64-bit gpr destination */
4188 if (s390_record_gpr_g (gdbarch, regcache, inib[6]))
4189 return -1;
4190 break;
4192 /* 0xb3ce-0xb3cf undefined */
4193 /* 0xb3e6 undefined */
4195 case 0xb3ea: /* CUXTR - convert to unsigned packed */
4196 case 0xb3eb: /* CSXTR - convert to signed packed */
4197 case 0xb90d: /* DSGR - divide single */
4198 case 0xb91d: /* DSGFR - divide single */
4199 case 0xb986: /* MLGR - multiply logical */
4200 case 0xb987: /* DLGR - divide logical */
4201 case 0xb9ec: /* MGRK - multiply 64x64 -> 128 */
4202 /* 64-bit gpr pair destination */
4203 if (s390_record_gpr_g (gdbarch, regcache, inib[6]))
4204 return -1;
4205 if (s390_record_gpr_g (gdbarch, regcache, inib[6] | 1))
4206 return -1;
4207 break;
4209 /* 0xb3ee undefined */
4210 /* 0xb3f0 undefined */
4211 /* 0xb3f8 undefined */
4213 /* 0xb905 privileged */
4215 /* 0xb90e unsupported: EREGG */
4217 /* 0xb915 undefined */
4219 case 0xb91e: /* KMAC - compute message authentication code [partial] */
4220 regcache_raw_read_unsigned (regcache, S390_R1_REGNUM, &tmp);
4221 oaddr = s390_record_address_mask (gdbarch, regcache, tmp);
4222 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM, &tmp);
4223 tmp &= 0xff;
4224 switch (tmp)
4226 case 0x00: /* KMAC-Query */
4227 if (record_full_arch_list_add_mem (oaddr, 16))
4228 return -1;
4229 break;
4231 case 0x01: /* KMAC-DEA */
4232 case 0x02: /* KMAC-TDEA-128 */
4233 case 0x03: /* KMAC-TDEA-192 */
4234 case 0x09: /* KMAC-Encrypted-DEA */
4235 case 0x0a: /* KMAC-Encrypted-TDEA-128 */
4236 case 0x0b: /* KMAC-Encrypted-TDEA-192 */
4237 if (record_full_arch_list_add_mem (oaddr, 8))
4238 return -1;
4239 break;
4241 case 0x12: /* KMAC-AES-128 */
4242 case 0x13: /* KMAC-AES-192 */
4243 case 0x14: /* KMAC-AES-256 */
4244 case 0x1a: /* KMAC-Encrypted-AES-128 */
4245 case 0x1b: /* KMAC-Encrypted-AES-192 */
4246 case 0x1c: /* KMAC-Encrypted-AES-256 */
4247 if (record_full_arch_list_add_mem (oaddr, 16))
4248 return -1;
4249 break;
4251 default:
4252 fprintf_unfiltered (gdb_stdlog, "Warning: Unknown KMAC function %02x at %s.\n",
4253 (int)tmp, paddress (gdbarch, addr));
4254 return -1;
4256 if (tmp != 0)
4258 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[7]))
4259 return -1;
4260 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[7] | 1)))
4261 return -1;
4263 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4264 return -1;
4265 break;
4267 /* 0xb922-0xb924 undefined */
4268 /* 0xb925 privileged */
4269 /* 0xb928 privileged */
4271 case 0xb929: /* KMA - cipher message with authentication */
4272 case 0xb92a: /* KMF - cipher message with cipher feedback [partial] */
4273 case 0xb92b: /* KMO - cipher message with output feedback [partial] */
4274 case 0xb92f: /* KMC - cipher message with chaining [partial] */
4275 regcache_raw_read_unsigned (regcache, S390_R1_REGNUM, &tmp);
4276 oaddr = s390_record_address_mask (gdbarch, regcache, tmp);
4277 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM, &tmp);
4278 tmp &= 0x7f;
4279 switch (tmp)
4281 case 0x00: /* KM*-Query */
4282 if (record_full_arch_list_add_mem (oaddr, 16))
4283 return -1;
4284 break;
4286 case 0x01: /* KM*-DEA */
4287 case 0x02: /* KM*-TDEA-128 */
4288 case 0x03: /* KM*-TDEA-192 */
4289 case 0x09: /* KM*-Encrypted-DEA */
4290 case 0x0a: /* KM*-Encrypted-TDEA-128 */
4291 case 0x0b: /* KM*-Encrypted-TDEA-192 */
4292 if (record_full_arch_list_add_mem (oaddr, 8))
4293 return -1;
4294 break;
4296 case 0x12: /* KM*-AES-128 */
4297 case 0x13: /* KM*-AES-192 */
4298 case 0x14: /* KM*-AES-256 */
4299 case 0x1a: /* KM*-Encrypted-AES-128 */
4300 case 0x1b: /* KM*-Encrypted-AES-192 */
4301 case 0x1c: /* KM*-Encrypted-AES-256 */
4302 if (record_full_arch_list_add_mem (oaddr, 16))
4303 return -1;
4304 break;
4306 case 0x43: /* KMC-PRNG */
4307 /* Only valid for KMC. */
4308 if (insn[0] == 0xb92f)
4310 if (record_full_arch_list_add_mem (oaddr, 8))
4311 return -1;
4312 break;
4314 /* For other instructions... */
4315 /* Fall through. */
4316 default:
4317 fprintf_unfiltered (gdb_stdlog, "Warning: Unknown KM* function %02x at %s.\n",
4318 (int)tmp, paddress (gdbarch, addr));
4319 return -1;
4321 if (tmp != 0)
4323 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + inib[6], &tmp);
4324 oaddr2 = s390_record_address_mask (gdbarch, regcache, tmp);
4325 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + (inib[7] | 1), &tmp);
4326 if (record_full_arch_list_add_mem (oaddr2, tmp))
4327 return -1;
4328 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
4329 return -1;
4330 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[7]))
4331 return -1;
4332 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[7] | 1)))
4333 return -1;
4335 if (tmp != 0 && insn[0] == 0xb929)
4337 if (record_full_arch_list_add_reg (regcache,
4338 S390_R0_REGNUM + inib[4]))
4339 return -1;
4340 if (record_full_arch_list_add_reg (regcache,
4341 S390_R0_REGNUM + (inib[4] | 1)))
4342 return -1;
4344 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4345 return -1;
4346 break;
4348 case 0xb92c: /* PCC - perform cryptographic computation [partial] */
4349 regcache_raw_read_unsigned (regcache, S390_R1_REGNUM, &tmp);
4350 oaddr = s390_record_address_mask (gdbarch, regcache, tmp);
4351 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM, &tmp);
4352 tmp &= 0x7f;
4353 switch (tmp)
4355 case 0x00: /* PCC-Query */
4356 if (record_full_arch_list_add_mem (oaddr, 16))
4357 return -1;
4358 break;
4360 case 0x01: /* PCC-Compute-Last-Block-CMAC-Using-DEA */
4361 case 0x02: /* PCC-Compute-Last-Block-CMAC-Using-TDEA-128 */
4362 case 0x03: /* PCC-Compute-Last-Block-CMAC-Using-TDEA-192 */
4363 case 0x09: /* PCC-Compute-Last-Block-CMAC-Using-Encrypted-DEA */
4364 case 0x0a: /* PCC-Compute-Last-Block-CMAC-Using-Encrypted-TDEA-128 */
4365 case 0x0b: /* PCC-Compute-Last-Block-CMAC-Using-Encrypted-TDEA-192 */
4366 if (record_full_arch_list_add_mem (oaddr + 0x10, 8))
4367 return -1;
4368 break;
4370 case 0x12: /* PCC-Compute-Last-Block-CMAC-Using-AES-128 */
4371 case 0x13: /* PCC-Compute-Last-Block-CMAC-Using-AES-192 */
4372 case 0x14: /* PCC-Compute-Last-Block-CMAC-Using-AES-256 */
4373 case 0x1a: /* PCC-Compute-Last-Block-CMAC-Using-Encrypted-AES-128 */
4374 case 0x1b: /* PCC-Compute-Last-Block-CMAC-Using-Encrypted-AES-192 */
4375 case 0x1c: /* PCC-Compute-Last-Block-CMAC-Using-Encrypted-AES-256 */
4376 if (record_full_arch_list_add_mem (oaddr + 0x18, 16))
4377 return -1;
4378 break;
4380 case 0x32: /* PCC-Compute-XTS-Parameter-Using-AES-128 */
4381 if (record_full_arch_list_add_mem (oaddr + 0x30, 32))
4382 return -1;
4383 break;
4385 case 0x34: /* PCC-Compute-XTS-Parameter-Using-AES-256 */
4386 if (record_full_arch_list_add_mem (oaddr + 0x40, 32))
4387 return -1;
4388 break;
4390 case 0x3a: /* PCC-Compute-XTS-Parameter-Using-Encrypted-AES-128 */
4391 if (record_full_arch_list_add_mem (oaddr + 0x50, 32))
4392 return -1;
4393 break;
4395 case 0x3c: /* PCC-Compute-XTS-Parameter-Using-Encrypted-AES-256 */
4396 if (record_full_arch_list_add_mem (oaddr + 0x60, 32))
4397 return -1;
4398 break;
4400 default:
4401 fprintf_unfiltered (gdb_stdlog, "Warning: Unknown PCC function %02x at %s.\n",
4402 (int)tmp, paddress (gdbarch, addr));
4403 return -1;
4405 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4406 return -1;
4407 break;
4409 case 0xb92d: /* KMCTR - cipher message with counter [partial] */
4410 regcache_raw_read_unsigned (regcache, S390_R1_REGNUM, &tmp);
4411 oaddr = s390_record_address_mask (gdbarch, regcache, tmp);
4412 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM, &tmp);
4413 tmp &= 0x7f;
4414 switch (tmp)
4416 case 0x00: /* KMCTR-Query */
4417 if (record_full_arch_list_add_mem (oaddr, 16))
4418 return -1;
4419 break;
4421 case 0x01: /* KMCTR-DEA */
4422 case 0x02: /* KMCTR-TDEA-128 */
4423 case 0x03: /* KMCTR-TDEA-192 */
4424 case 0x09: /* KMCTR-Encrypted-DEA */
4425 case 0x0a: /* KMCTR-Encrypted-TDEA-128 */
4426 case 0x0b: /* KMCTR-Encrypted-TDEA-192 */
4427 case 0x12: /* KMCTR-AES-128 */
4428 case 0x13: /* KMCTR-AES-192 */
4429 case 0x14: /* KMCTR-AES-256 */
4430 case 0x1a: /* KMCTR-Encrypted-AES-128 */
4431 case 0x1b: /* KMCTR-Encrypted-AES-192 */
4432 case 0x1c: /* KMCTR-Encrypted-AES-256 */
4433 break;
4435 default:
4436 fprintf_unfiltered (gdb_stdlog, "Warning: Unknown KMCTR function %02x at %s.\n",
4437 (int)tmp, paddress (gdbarch, addr));
4438 return -1;
4440 if (tmp != 0)
4442 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + inib[6], &tmp);
4443 oaddr2 = s390_record_address_mask (gdbarch, regcache, tmp);
4444 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + (inib[7] | 1), &tmp);
4445 if (record_full_arch_list_add_mem (oaddr2, tmp))
4446 return -1;
4447 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
4448 return -1;
4449 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[7]))
4450 return -1;
4451 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[7] | 1)))
4452 return -1;
4453 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[4]))
4454 return -1;
4456 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4457 return -1;
4458 break;
4460 case 0xb92e: /* KM - cipher message [partial] */
4461 regcache_raw_read_unsigned (regcache, S390_R1_REGNUM, &tmp);
4462 oaddr = s390_record_address_mask (gdbarch, regcache, tmp);
4463 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM, &tmp);
4464 tmp &= 0x7f;
4465 switch (tmp)
4467 case 0x00: /* KM-Query */
4468 if (record_full_arch_list_add_mem (oaddr, 16))
4469 return -1;
4470 break;
4472 case 0x01: /* KM-DEA */
4473 case 0x02: /* KM-TDEA-128 */
4474 case 0x03: /* KM-TDEA-192 */
4475 case 0x09: /* KM-Encrypted-DEA */
4476 case 0x0a: /* KM-Encrypted-TDEA-128 */
4477 case 0x0b: /* KM-Encrypted-TDEA-192 */
4478 case 0x12: /* KM-AES-128 */
4479 case 0x13: /* KM-AES-192 */
4480 case 0x14: /* KM-AES-256 */
4481 case 0x1a: /* KM-Encrypted-AES-128 */
4482 case 0x1b: /* KM-Encrypted-AES-192 */
4483 case 0x1c: /* KM-Encrypted-AES-256 */
4484 break;
4486 case 0x32: /* KM-XTS-AES-128 */
4487 if (record_full_arch_list_add_mem (oaddr + 0x10, 16))
4488 return -1;
4489 break;
4491 case 0x34: /* KM-XTS-AES-256 */
4492 if (record_full_arch_list_add_mem (oaddr + 0x20, 16))
4493 return -1;
4494 break;
4496 case 0x3a: /* KM-XTS-Encrypted-AES-128 */
4497 if (record_full_arch_list_add_mem (oaddr + 0x30, 16))
4498 return -1;
4499 break;
4501 case 0x3c: /* KM-XTS-Encrypted-AES-256 */
4502 if (record_full_arch_list_add_mem (oaddr + 0x40, 16))
4503 return -1;
4504 break;
4506 default:
4507 fprintf_unfiltered (gdb_stdlog, "Warning: Unknown KM function %02x at %s.\n",
4508 (int)tmp, paddress (gdbarch, addr));
4509 return -1;
4511 if (tmp != 0)
4513 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + inib[6], &tmp);
4514 oaddr2 = s390_record_address_mask (gdbarch, regcache, tmp);
4515 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + (inib[7] | 1), &tmp);
4516 if (record_full_arch_list_add_mem (oaddr2, tmp))
4517 return -1;
4518 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
4519 return -1;
4520 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[7]))
4521 return -1;
4522 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[7] | 1)))
4523 return -1;
4525 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4526 return -1;
4527 break;
4529 /* 0xb932-0xb93b undefined */
4531 case 0xb93c: /* PPNO - perform pseudorandom number operation [partial] */
4532 regcache_raw_read_unsigned (regcache, S390_R1_REGNUM, &tmp);
4533 oaddr = s390_record_address_mask (gdbarch, regcache, tmp);
4534 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM, &tmp);
4535 tmp &= 0xff;
4536 switch (tmp)
4538 case 0x00: /* PPNO-Query */
4539 case 0x80: /* PPNO-Query */
4540 if (record_full_arch_list_add_mem (oaddr, 16))
4541 return -1;
4542 break;
4544 case 0x03: /* PPNO-SHA-512-DRNG - generate */
4545 if (record_full_arch_list_add_mem (oaddr, 240))
4546 return -1;
4547 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + inib[6], &tmp);
4548 oaddr2 = s390_record_address_mask (gdbarch, regcache, tmp);
4549 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + (inib[6] | 1), &tmp);
4550 if (record_full_arch_list_add_mem (oaddr2, tmp))
4551 return -1;
4552 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
4553 return -1;
4554 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[6] | 1)))
4555 return -1;
4556 break;
4558 case 0x83: /* PPNO-SHA-512-DRNG - seed */
4559 if (record_full_arch_list_add_mem (oaddr, 240))
4560 return -1;
4561 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[7]))
4562 return -1;
4563 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[7] | 1)))
4564 return -1;
4565 break;
4567 default:
4568 fprintf_unfiltered (gdb_stdlog, "Warning: Unknown PPNO function %02x at %s.\n",
4569 (int)tmp, paddress (gdbarch, addr));
4570 return -1;
4572 /* DXC may be written */
4573 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
4574 return -1;
4575 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4576 return -1;
4577 break;
4579 /* 0xb93d undefined */
4581 case 0xb93e: /* KIMD - compute intermediate message digest [partial] */
4582 case 0xb93f: /* KLMD - compute last message digest [partial] */
4583 regcache_raw_read_unsigned (regcache, S390_R1_REGNUM, &tmp);
4584 oaddr = s390_record_address_mask (gdbarch, regcache, tmp);
4585 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM, &tmp);
4586 tmp &= 0xff;
4587 switch (tmp)
4589 case 0x00: /* K*MD-Query */
4590 if (record_full_arch_list_add_mem (oaddr, 16))
4591 return -1;
4592 break;
4594 case 0x01: /* K*MD-SHA-1 */
4595 if (record_full_arch_list_add_mem (oaddr, 20))
4596 return -1;
4597 break;
4599 case 0x02: /* K*MD-SHA-256 */
4600 if (record_full_arch_list_add_mem (oaddr, 32))
4601 return -1;
4602 break;
4604 case 0x03: /* K*MD-SHA-512 */
4605 if (record_full_arch_list_add_mem (oaddr, 64))
4606 return -1;
4607 break;
4609 case 0x41: /* KIMD-GHASH */
4610 /* Only valid for KIMD. */
4611 if (insn[0] == 0xb93e)
4613 if (record_full_arch_list_add_mem (oaddr, 16))
4614 return -1;
4615 break;
4617 /* For KLMD... */
4618 /* Fall through. */
4619 default:
4620 fprintf_unfiltered (gdb_stdlog, "Warning: Unknown KMAC function %02x at %s.\n",
4621 (int)tmp, paddress (gdbarch, addr));
4622 return -1;
4624 if (tmp != 0)
4626 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[7]))
4627 return -1;
4628 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[7] | 1)))
4629 return -1;
4631 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4632 return -1;
4633 break;
4635 /* 0xb940 undefined */
4636 /* 0xb944-0xb945 undefined */
4637 /* 0xb947-0xb948 undefined */
4638 /* 0xb94c-0xb950 undefined */
4639 /* 0xb954-0xb958 undefined */
4640 /* 0xb95c-0xb95f undefined */
4641 /* 0xb962-0xb971 undefined */
4642 /* 0xb974-0xb97f undefined */
4644 case 0xb983: /* FLOGR - find leftmost one */
4645 /* 64-bit gpr pair destination + flags */
4646 if (s390_record_gpr_g (gdbarch, regcache, inib[6]))
4647 return -1;
4648 if (s390_record_gpr_g (gdbarch, regcache, inib[6] | 1))
4649 return -1;
4650 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4651 return -1;
4652 break;
4654 /* 0xb98a privileged */
4655 /* 0xb98b-0xb98c undefined */
4657 case 0xb98d: /* EPSW - extract psw */
4658 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
4659 return -1;
4660 if (inib[7])
4661 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[7]))
4662 return -1;
4663 break;
4665 /* 0xb98e-0xb98f privileged */
4667 case 0xb990: /* TRTT - translate two to two [partial] */
4668 case 0xb991: /* TRTO - translate two to one [partial] */
4669 case 0xb992: /* TROT - translate one to two [partial] */
4670 case 0xb993: /* TROO - translate one to one [partial] */
4671 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + inib[6], &tmp);
4672 oaddr = s390_record_address_mask (gdbarch, regcache, tmp);
4673 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + (inib[6] | 1), &tmp);
4674 /* tmp is source length, we want destination length. Adjust. */
4675 if (insn[0] == 0xb991)
4676 tmp >>= 1;
4677 if (insn[0] == 0xb992)
4678 tmp <<= 1;
4679 if (record_full_arch_list_add_mem (oaddr, tmp))
4680 return -1;
4681 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
4682 return -1;
4683 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[6] | 1)))
4684 return -1;
4685 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[7]))
4686 return -1;
4687 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4688 return -1;
4689 break;
4691 case 0xb996: /* MLR - multiply logical */
4692 case 0xb997: /* DLR - divide logical */
4693 /* 32-bit gpr pair destination */
4694 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
4695 return -1;
4696 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[6] | 1)))
4697 return -1;
4698 break;
4700 /* 0xb99a-0xb9af unsupported, privileged, or undefined */
4701 /* 0xb9b4-0xb9bc undefined */
4703 case 0xb9bd: /* TRTRE - translate and test reverse extended [partial] */
4704 case 0xb9bf: /* TRTE - translate and test extended [partial] */
4705 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
4706 return -1;
4707 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[6] | 1)))
4708 return -1;
4709 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[7]))
4710 return -1;
4711 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4712 return -1;
4713 break;
4715 /* 0xb9c0-0xb9c7 undefined */
4717 case 0xb9c8: /* AHHHR - add high */
4718 case 0xb9c9: /* SHHHR - subtract high */
4719 case 0xb9ca: /* ALHHHR - add logical high */
4720 case 0xb9cb: /* SLHHHR - subtract logical high */
4721 case 0xb9d8: /* AHHLR - add high */
4722 case 0xb9d9: /* SHHLR - subtract high */
4723 case 0xb9da: /* ALHHLR - add logical high */
4724 case 0xb9db: /* SLHHLR - subtract logical high */
4725 /* 32-bit high gpr destination + flags */
4726 if (s390_record_gpr_h (gdbarch, regcache, inib[6]))
4727 return -1;
4728 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4729 return -1;
4730 break;
4732 /* 0xb9cc undefined */
4733 /* 0xb9ce undefined */
4734 /* 0xb9d0-0xb9d7 undefined */
4735 /* 0xb9dc undefined */
4736 /* 0xb9de undefined */
4738 case 0xb9e0: /* LOCFHR - load high on condition */
4739 /* 32-bit high gpr destination */
4740 if (s390_record_gpr_h (gdbarch, regcache, inib[6]))
4741 return -1;
4742 break;
4744 /* 0xb9e3 undefined */
4745 /* 0xb9e5 undefined */
4746 /* 0xb9ee-0xb9f1 undefined */
4747 /* 0xb9f3 undefined */
4748 /* 0xb9f5 undefined */
4749 /* 0xb9fc undefined */
4750 /* 0xb9fe -0xb9ff undefined */
4752 default:
4753 goto UNKNOWN_OP;
4755 break;
4757 /* 0xb4-0xb5 undefined */
4758 /* 0xb6 privileged: STCTL - store control */
4759 /* 0xb7 privileged: LCTL - load control */
4760 /* 0xb8 undefined */
4762 case 0xba: /* CS - compare and swap */
4763 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
4764 if (record_full_arch_list_add_mem (oaddr, 4))
4765 return -1;
4766 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
4767 return -1;
4768 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4769 return -1;
4770 break;
4772 case 0xbb: /* CDS - compare double and swap */
4773 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
4774 if (record_full_arch_list_add_mem (oaddr, 8))
4775 return -1;
4776 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
4777 return -1;
4778 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[2] | 1)))
4779 return -1;
4780 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4781 return -1;
4782 break;
4784 /* 0xbc undefined */
4786 case 0xbe: /* STCM - store characters under mask */
4787 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
4788 if (record_full_arch_list_add_mem (oaddr, s390_popcnt (inib[3])))
4789 return -1;
4790 break;
4792 case 0xc0:
4793 case 0xc2:
4794 case 0xc4:
4795 case 0xc6:
4796 case 0xcc:
4797 /* RIL-format instruction */
4798 switch (ibyte[0] << 4 | inib[3])
4800 case 0xc00: /* LARL - load address relative long */
4801 case 0xc05: /* BRASL - branch relative and save long */
4802 case 0xc09: /* IILF - insert immediate */
4803 case 0xc21: /* MSFI - multiply single immediate */
4804 case 0xc42: /* LLHRL - load logical halfword relative long */
4805 case 0xc45: /* LHRL - load halfword relative long */
4806 case 0xc4d: /* LRL - load relative long */
4807 /* 32-bit or native gpr destination */
4808 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
4809 return -1;
4810 break;
4812 case 0xc01: /* LGFI - load immediate */
4813 case 0xc0e: /* LLIHF - load logical immediate */
4814 case 0xc0f: /* LLILF - load logical immediate */
4815 case 0xc20: /* MSGFI - multiply single immediate */
4816 case 0xc44: /* LGHRL - load halfword relative long */
4817 case 0xc46: /* LLGHRL - load logical halfword relative long */
4818 case 0xc48: /* LGRL - load relative long */
4819 case 0xc4c: /* LGFRL - load relative long */
4820 case 0xc4e: /* LLGFRL - load logical relative long */
4821 /* 64-bit gpr destination */
4822 if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
4823 return -1;
4824 break;
4826 /* 0xc02-0xc03 undefined */
4828 case 0xc04: /* BRCL - branch relative on condition long */
4829 case 0xc62: /* PFDRL - prefetch data relative long */
4830 break;
4832 case 0xc06: /* XIHF - xor immediate */
4833 case 0xc0a: /* NIHF - and immediate */
4834 case 0xc0c: /* OIHF - or immediate */
4835 case 0xcc8: /* AIH - add immediate high */
4836 case 0xcca: /* ALSIH - add logical with signed immediate high */
4837 /* 32-bit high gpr destination + flags */
4838 if (s390_record_gpr_h (gdbarch, regcache, inib[2]))
4839 return -1;
4840 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4841 return -1;
4842 break;
4844 case 0xc07: /* XILF - xor immediate */
4845 case 0xc0b: /* NILF - and immediate */
4846 case 0xc0d: /* OILF - or immediate */
4847 case 0xc25: /* SLFI - subtract logical immediate */
4848 case 0xc29: /* AFI - add immediate */
4849 case 0xc2b: /* ALFI - add logical immediate */
4850 /* 32-bit gpr destination + flags */
4851 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
4852 return -1;
4853 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4854 return -1;
4855 break;
4857 case 0xc08: /* IIHF - insert immediate */
4858 case 0xcc6: /* BRCTH - branch relative on count high */
4859 case 0xccb: /* ALSIHN - add logical with signed immediate high */
4860 /* 32-bit high gpr destination */
4861 if (s390_record_gpr_h (gdbarch, regcache, inib[2]))
4862 return -1;
4863 break;
4865 /* 0xc22-0xc23 undefined */
4867 case 0xc24: /* SLGFI - subtract logical immediate */
4868 case 0xc28: /* AGFI - add immediate */
4869 case 0xc2a: /* ALGFI - add logical immediate */
4870 /* 64-bit gpr destination + flags */
4871 if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
4872 return -1;
4873 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4874 return -1;
4875 break;
4877 /* 0xc26-0xc27 undefined */
4879 case 0xc2c: /* CGFI - compare immediate */
4880 case 0xc2d: /* CFI - compare immediate */
4881 case 0xc2e: /* CLGFI - compare logical immediate */
4882 case 0xc2f: /* CLFI - compare logical immediate */
4883 case 0xc64: /* CGHRL - compare halfword relative long */
4884 case 0xc65: /* CHRL - compare halfword relative long */
4885 case 0xc66: /* CLGHRL - compare logical halfword relative long */
4886 case 0xc67: /* CLHRL - compare logical halfword relative long */
4887 case 0xc68: /* CGRL - compare relative long */
4888 case 0xc6a: /* CLGRL - compare logical relative long */
4889 case 0xc6c: /* CGFRL - compare relative long */
4890 case 0xc6d: /* CRL - compare relative long */
4891 case 0xc6e: /* CLGFRL - compare logical relative long */
4892 case 0xc6f: /* CLRL - compare logical relative long */
4893 case 0xccd: /* CIH - compare immediate high */
4894 case 0xccf: /* CLIH - compare logical immediate high */
4895 /* flags only */
4896 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4897 return -1;
4898 break;
4900 /* 0xc40-0xc41 undefined */
4901 /* 0xc43 undefined */
4903 case 0xc47: /* STHRL - store halfword relative long */
4904 oaddr = s390_record_calc_rl (gdbarch, regcache, addr, insn[1], insn[2]);
4905 if (record_full_arch_list_add_mem (oaddr, 2))
4906 return -1;
4907 break;
4909 /* 0xc49-0xc4a undefined */
4911 case 0xc4b: /* STGRL - store relative long */
4912 oaddr = s390_record_calc_rl (gdbarch, regcache, addr, insn[1], insn[2]);
4913 if (record_full_arch_list_add_mem (oaddr, 8))
4914 return -1;
4915 break;
4917 case 0xc4f: /* STRL - store relative long */
4918 oaddr = s390_record_calc_rl (gdbarch, regcache, addr, insn[1], insn[2]);
4919 if (record_full_arch_list_add_mem (oaddr, 4))
4920 return -1;
4921 break;
4923 case 0xc60: /* EXRL - execute relative long */
4924 if (ex != -1)
4926 fprintf_unfiltered (gdb_stdlog, "Warning: Double execute at %s.\n",
4927 paddress (gdbarch, addr));
4928 return -1;
4930 addr = s390_record_calc_rl (gdbarch, regcache, addr, insn[1], insn[2]);
4931 if (inib[2])
4933 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + inib[2], &tmp);
4934 ex = tmp & 0xff;
4936 else
4938 ex = 0;
4940 goto ex;
4942 /* 0xc61 undefined */
4943 /* 0xc63 undefined */
4944 /* 0xc69 undefined */
4945 /* 0xc6b undefined */
4946 /* 0xcc0-0xcc5 undefined */
4947 /* 0xcc7 undefined */
4948 /* 0xcc9 undefined */
4949 /* 0xccc undefined */
4950 /* 0xcce undefined */
4952 default:
4953 goto UNKNOWN_OP;
4955 break;
4957 /* 0xc1 undefined */
4958 /* 0xc3 undefined */
4960 case 0xc5: /* BPRP - branch prediction relative preload */
4961 case 0xc7: /* BPP - branch prediction preload */
4962 /* no visible effect */
4963 break;
4965 case 0xc8:
4966 /* SSF-format instruction */
4967 switch (ibyte[0] << 4 | inib[3])
4969 /* 0xc80 unsupported */
4971 case 0xc81: /* ECTG - extract cpu time */
4972 if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
4973 return -1;
4974 if (s390_record_gpr_g (gdbarch, regcache, 0))
4975 return -1;
4976 if (s390_record_gpr_g (gdbarch, regcache, 1))
4977 return -1;
4978 break;
4980 case 0xc82: /* CSST - compare and swap and store */
4982 uint8_t fc, sc;
4983 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM, &tmp);
4984 fc = tmp & 0xff;
4985 sc = tmp >> 8 & 0xff;
4987 /* First and third operands. */
4988 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
4989 switch (fc)
4991 case 0x00: /* 32-bit */
4992 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
4993 return -1;
4994 if (record_full_arch_list_add_mem (oaddr, 4))
4995 return -1;
4996 break;
4998 case 0x01: /* 64-bit */
4999 if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
5000 return -1;
5001 if (record_full_arch_list_add_mem (oaddr, 8))
5002 return -1;
5003 break;
5005 case 0x02: /* 128-bit */
5006 if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
5007 return -1;
5008 if (s390_record_gpr_g (gdbarch, regcache, inib[2] | 1))
5009 return -1;
5010 if (record_full_arch_list_add_mem (oaddr, 16))
5011 return -1;
5012 break;
5014 default:
5015 fprintf_unfiltered (gdb_stdlog, "Warning: Unknown CSST FC %02x at %s.\n",
5016 fc, paddress (gdbarch, addr));
5017 return -1;
5020 /* Second operand. */
5021 oaddr2 = s390_record_calc_disp (gdbarch, regcache, 0, insn[2], 0);
5022 if (sc > 4)
5024 fprintf_unfiltered (gdb_stdlog, "Warning: Unknown CSST FC %02x at %s.\n",
5025 sc, paddress (gdbarch, addr));
5026 return -1;
5029 if (record_full_arch_list_add_mem (oaddr2, 1 << sc))
5030 return -1;
5032 /* Flags. */
5033 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
5034 return -1;
5036 break;
5038 /* 0xc83 undefined */
5040 case 0xc84: /* LPD - load pair disjoint */
5041 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
5042 return -1;
5043 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[2] | 1)))
5044 return -1;
5045 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
5046 return -1;
5047 break;
5049 case 0xc85: /* LPDG - load pair disjoint */
5050 if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
5051 return -1;
5052 if (s390_record_gpr_g (gdbarch, regcache, inib[2] | 1))
5053 return -1;
5054 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
5055 return -1;
5056 break;
5058 /* 0xc86-0xc8f undefined */
5060 default:
5061 goto UNKNOWN_OP;
5063 break;
5065 /* 0xc9-0xcb undefined */
5066 /* 0xcd-0xcf undefined */
5068 case 0xd0: /* TRTR - translate and test reversed */
5069 case 0xdd: /* TRT - translate and test */
5070 if (record_full_arch_list_add_reg (regcache, S390_R1_REGNUM))
5071 return -1;
5072 if (record_full_arch_list_add_reg (regcache, S390_R2_REGNUM))
5073 return -1;
5074 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
5075 return -1;
5076 break;
5078 case 0xd1: /* MVN - move numbers */
5079 case 0xd2: /* MVC - move */
5080 case 0xd3: /* MVZ - move zones */
5081 case 0xdc: /* TR - translate */
5082 case 0xe8: /* MVCIN - move inverse */
5083 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
5084 if (record_full_arch_list_add_mem (oaddr, ibyte[1] + 1))
5085 return -1;
5086 break;
5088 case 0xd4: /* NC - and */
5089 case 0xd6: /* OC - or*/
5090 case 0xd7: /* XC - xor */
5091 case 0xe2: /* UNPKU - unpack unicode */
5092 case 0xea: /* UNPKA - unpack ASCII */
5093 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
5094 if (record_full_arch_list_add_mem (oaddr, ibyte[1] + 1))
5095 return -1;
5096 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
5097 return -1;
5098 break;
5100 case 0xde: /* ED - edit */
5101 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
5102 if (record_full_arch_list_add_mem (oaddr, ibyte[1] + 1))
5103 return -1;
5104 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
5105 return -1;
5106 /* DXC may be written */
5107 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
5108 return -1;
5109 break;
5111 case 0xdf: /* EDMK - edit and mark */
5112 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
5113 if (record_full_arch_list_add_mem (oaddr, ibyte[1] + 1))
5114 return -1;
5115 if (record_full_arch_list_add_reg (regcache, S390_R1_REGNUM))
5116 return -1;
5117 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
5118 return -1;
5119 /* DXC may be written */
5120 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
5121 return -1;
5122 break;
5124 /* 0xd8 undefined */
5125 /* 0xd9 unsupported: MVCK - move with key */
5126 /* 0xda unsupported: MVCP - move to primary */
5127 /* 0xdb unsupported: MVCS - move to secondary */
5128 /* 0xe0 undefined */
5130 case 0xe1: /* PKU - pack unicode */
5131 case 0xe9: /* PKA - pack ASCII */
5132 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
5133 if (record_full_arch_list_add_mem (oaddr, 16))
5134 return -1;
5135 break;
5137 case 0xe3:
5138 case 0xe6:
5139 case 0xe7:
5140 case 0xeb:
5141 case 0xed:
5142 /* RXY/RXE/RXF/RSL/RSY/SIY/V*-format instruction */
5143 switch (ibyte[0] << 8 | ibyte[5])
5145 /* 0xe300-0xe301 undefined */
5147 case 0xe302: /* LTG - load and test */
5148 case 0xe308: /* AG - add */
5149 case 0xe309: /* SG - subtract */
5150 case 0xe30a: /* ALG - add logical */
5151 case 0xe30b: /* SLG - subtract logical */
5152 case 0xe318: /* AGF - add */
5153 case 0xe319: /* SGF - subtract */
5154 case 0xe31a: /* ALGF - add logical */
5155 case 0xe31b: /* SLGF - subtract logical */
5156 case 0xe332: /* LTGF - load and test */
5157 case 0xe380: /* NG - and */
5158 case 0xe381: /* OG - or */
5159 case 0xe382: /* XG - xor */
5160 case 0xe388: /* ALCG - add logical with carry */
5161 case 0xe389: /* SLBG - subtract logical with borrow */
5162 case 0xeb0a: /* SRAG - shift right single */
5163 case 0xeb0b: /* SLAG - shift left single */
5164 /* 64-bit gpr destination + flags */
5165 if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
5166 return -1;
5167 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
5168 return -1;
5169 break;
5171 /* 0xe303 privileged */
5173 case 0xe304: /* LG - load */
5174 case 0xe30c: /* MSG - multiply single */
5175 case 0xe30f: /* LRVG - load reversed */
5176 case 0xe314: /* LGF - load */
5177 case 0xe315: /* LGH - load halfword */
5178 case 0xe316: /* LLGF - load logical */
5179 case 0xe317: /* LLGT - load logical thirty one bits */
5180 case 0xe31c: /* MSGF - multiply single */
5181 case 0xe32a: /* LZRG - load and zero rightmost byte */
5182 case 0xe33a: /* LLZRGF - load logical and zero rightmost byte */
5183 case 0xe33c: /* MGH - multiply halfword 64x16mem -> 64 */
5184 case 0xe346: /* BCTG - branch on count */
5185 case 0xe377: /* LGB - load byte */
5186 case 0xe390: /* LLGC - load logical character */
5187 case 0xe391: /* LLGH - load logical halfword */
5188 case 0xeb0c: /* SRLG - shift right single logical */
5189 case 0xeb0d: /* SLLG - shift left single logical */
5190 case 0xeb1c: /* RLLG - rotate left single logical */
5191 case 0xeb44: /* BXHG - branch on index high */
5192 case 0xeb45: /* BXLEG - branch on index low or equal */
5193 case 0xeb4c: /* ECAG - extract cpu attribute */
5194 case 0xebe2: /* LOCG - load on condition */
5195 /* 64-bit gpr destination */
5196 if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
5197 return -1;
5198 break;
5200 /* 0xe305 undefined */
5202 case 0xe306: /* CVBY - convert to binary */
5203 /* 32-bit or native gpr destination + FPC (DXC write) */
5204 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
5205 return -1;
5206 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
5207 return -1;
5208 break;
5210 /* 0xe307 undefined */
5212 case 0xe30d: /* DSG - divide single */
5213 case 0xe31d: /* DSGF - divide single */
5214 case 0xe384: /* MG - multiply 64x64mem -> 128 */
5215 case 0xe386: /* MLG - multiply logical */
5216 case 0xe387: /* DLG - divide logical */
5217 case 0xe38f: /* LPQ - load pair from quadword */
5218 /* 64-bit gpr pair destination */
5219 if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
5220 return -1;
5221 if (s390_record_gpr_g (gdbarch, regcache, inib[2] | 1))
5222 return -1;
5223 break;
5225 case 0xe30e: /* CVBG - convert to binary */
5226 /* 64-bit gpr destination + FPC (DXC write) */
5227 if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
5228 return -1;
5229 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
5230 return -1;
5231 break;
5233 /* 0xe310-0xe311 undefined */
5235 case 0xe312: /* LT - load and test */
5236 case 0xe338: /* AGH - add halfword to 64 bit value */
5237 case 0xe339: /* SGH - subtract halfword from 64 bit value */
5238 case 0xe353: /* MSC - multiply single 32x32mem -> 32 */
5239 case 0xe354: /* NY - and */
5240 case 0xe356: /* OY - or */
5241 case 0xe357: /* XY - xor */
5242 case 0xe35a: /* AY - add */
5243 case 0xe35b: /* SY - subtract */
5244 case 0xe35e: /* ALY - add logical */
5245 case 0xe35f: /* SLY - subtract logical */
5246 case 0xe37a: /* AHY - add halfword */
5247 case 0xe37b: /* SHY - subtract halfword */
5248 case 0xe383: /* MSGC - multiply single 64x64mem -> 64 */
5249 case 0xe398: /* ALC - add logical with carry */
5250 case 0xe399: /* SLB - subtract logical with borrow */
5251 case 0xe727: /* LCBB - load count to block bounduary */
5252 case 0xeb81: /* ICMY - insert characters under mask */
5253 case 0xebdc: /* SRAK - shift left single */
5254 case 0xebdd: /* SLAK - shift left single */
5255 /* 32/64-bit gpr destination + flags */
5256 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
5257 return -1;
5258 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
5259 return -1;
5260 break;
5262 /* 0xe313 privileged */
5264 case 0xe31e: /* LRV - load reversed */
5265 case 0xe31f: /* LRVH - load reversed */
5266 case 0xe33b: /* LZRF - load and zero rightmost byte */
5267 case 0xe351: /* MSY - multiply single */
5268 case 0xe358: /* LY - load */
5269 case 0xe371: /* LAY - load address */
5270 case 0xe373: /* ICY - insert character */
5271 case 0xe376: /* LB - load byte */
5272 case 0xe378: /* LHY - load */
5273 case 0xe37c: /* MHY - multiply halfword */
5274 case 0xe394: /* LLC - load logical character */
5275 case 0xe395: /* LLH - load logical halfword */
5276 case 0xeb1d: /* RLL - rotate left single logical */
5277 case 0xebde: /* SRLK - shift left single logical */
5278 case 0xebdf: /* SLLK - shift left single logical */
5279 case 0xebf2: /* LOC - load on condition */
5280 /* 32-bit or native gpr destination */
5281 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
5282 return -1;
5283 break;
5285 case 0xe320: /* CG - compare */
5286 case 0xe321: /* CLG - compare logical */
5287 case 0xe330: /* CGF - compare */
5288 case 0xe331: /* CLGF - compare logical */
5289 case 0xe334: /* CGH - compare halfword */
5290 case 0xe355: /* CLY - compare logical */
5291 case 0xe359: /* CY - compare */
5292 case 0xe379: /* CHY - compare halfword */
5293 case 0xe3cd: /* CHF - compare high */
5294 case 0xe3cf: /* CLHF - compare logical high */
5295 case 0xeb20: /* CLMH - compare logical under mask high */
5296 case 0xeb21: /* CLMY - compare logical under mask */
5297 case 0xeb51: /* TMY - test under mask */
5298 case 0xeb55: /* CLIY - compare logical */
5299 case 0xebc0: /* TP - test decimal */
5300 case 0xed10: /* TCEB - test data class */
5301 case 0xed11: /* TCDB - test data class */
5302 case 0xed12: /* TCXB - test data class */
5303 case 0xed50: /* TDCET - test data class */
5304 case 0xed51: /* TDGET - test data group */
5305 case 0xed54: /* TDCDT - test data class */
5306 case 0xed55: /* TDGDT - test data group */
5307 case 0xed58: /* TDCXT - test data class */
5308 case 0xed59: /* TDGXT - test data group */
5309 /* flags only */
5310 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
5311 return -1;
5312 break;
5314 /* 0xe322-0xe323 undefined */
5316 case 0xe324: /* STG - store */
5317 case 0xe325: /* NTSTG - nontransactional store */
5318 case 0xe326: /* CVDY - convert to decimal */
5319 case 0xe32f: /* STRVG - store reversed */
5320 case 0xebe3: /* STOCG - store on condition */
5321 case 0xed67: /* STDY - store */
5322 oaddr = s390_record_calc_disp (gdbarch, regcache, inib[3], insn[1], ibyte[4]);
5323 if (record_full_arch_list_add_mem (oaddr, 8))
5324 return -1;
5325 break;
5327 /* 0xe327-0xe329 undefined */
5328 /* 0xe32b-0xe32d undefined */
5330 case 0xe32e: /* CVDG - convert to decimal */
5331 case 0xe38e: /* STPQ - store pair to quadword */
5332 oaddr = s390_record_calc_disp (gdbarch, regcache, inib[3], insn[1], ibyte[4]);
5333 if (record_full_arch_list_add_mem (oaddr, 16))
5334 return -1;
5335 break;
5337 /* 0xe333 undefined */
5338 /* 0xe335 undefined */
5340 case 0xe336: /* PFD - prefetch data */
5341 break;
5343 /* 0xe337 undefined */
5344 /* 0xe33c-0xe33d undefined */
5346 case 0xe33e: /* STRV - store reversed */
5347 case 0xe350: /* STY - store */
5348 case 0xe3cb: /* STFH - store high */
5349 case 0xebe1: /* STOCFH - store high on condition */
5350 case 0xebf3: /* STOC - store on condition */
5351 case 0xed66: /* STEY - store */
5352 oaddr = s390_record_calc_disp (gdbarch, regcache, inib[3], insn[1], ibyte[4]);
5353 if (record_full_arch_list_add_mem (oaddr, 4))
5354 return -1;
5355 break;
5357 case 0xe33f: /* STRVH - store reversed */
5358 case 0xe370: /* STHY - store halfword */
5359 case 0xe3c7: /* STHH - store halfword high */
5360 oaddr = s390_record_calc_disp (gdbarch, regcache, inib[3], insn[1], ibyte[4]);
5361 if (record_full_arch_list_add_mem (oaddr, 2))
5362 return -1;
5363 break;
5365 /* 0xe340-0xe345 undefined */
5367 case 0xe347: /* BIC - branch indirect on condition */
5368 break;
5370 /* 0xe348-0xe34f undefined */
5371 /* 0xe352 undefined */
5373 case 0xe35c: /* MFY - multiply */
5374 case 0xe396: /* ML - multiply logical */
5375 case 0xe397: /* DL - divide logical */
5376 /* 32-bit gpr pair destination */
5377 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
5378 return -1;
5379 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[2] | 1)))
5380 return -1;
5381 break;
5383 /* 0xe35d undefined */
5384 /* 0xe360-0xe36f undefined */
5386 case 0xe372: /* STCY - store character */
5387 case 0xe3c3: /* STCH - store character high */
5388 oaddr = s390_record_calc_disp (gdbarch, regcache, inib[3], insn[1], ibyte[4]);
5389 if (record_full_arch_list_add_mem (oaddr, 1))
5390 return -1;
5391 break;
5393 /* 0xe374 undefined */
5395 case 0xe375: /* LAEY - load address extended */
5396 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
5397 return -1;
5398 if (record_full_arch_list_add_reg (regcache, S390_A0_REGNUM + inib[2]))
5399 return -1;
5400 break;
5402 /* 0xe37d-0xe37f undefined */
5404 case 0xe385: /* LGAT - load and trap */
5405 case 0xe39c: /* LLGTAT - load logical thirty one bits and trap */
5406 case 0xe39d: /* LLGFAT - load logical and trap */
5407 case 0xe650: /* VCVB - vector convert to binary 32 bit*/
5408 case 0xe652: /* VCVBG - vector convert to binary 64 bit*/
5409 case 0xe721: /* VLGV - vector load gr from vr element */
5410 /* 64-bit gpr destination + fpc for possible DXC write */
5411 if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
5412 return -1;
5413 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
5414 return -1;
5415 break;
5417 /* 0xe38a-0xe38d undefined */
5418 /* 0xe392-0xe393 undefined */
5419 /* 0xe39a-0xe39b undefined */
5420 /* 0xe39e undefined */
5422 case 0xe39f: /* LAT - load and trap */
5423 /* 32-bit gpr destination + fpc for possible DXC write */
5424 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
5425 return -1;
5426 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
5427 return -1;
5428 break;
5430 /* 0xe3a0-0xe3bf undefined */
5432 case 0xe3c0: /* LBH - load byte high */
5433 case 0xe3c2: /* LLCH - load logical character high */
5434 case 0xe3c4: /* LHH - load halfword high */
5435 case 0xe3c6: /* LLHH - load logical halfword high */
5436 case 0xe3ca: /* LFH - load high */
5437 case 0xebe0: /* LOCFH - load high on condition */
5438 /* 32-bit high gpr destination */
5439 if (s390_record_gpr_h (gdbarch, regcache, inib[2]))
5440 return -1;
5441 break;
5443 /* 0xe3c1 undefined */
5444 /* 0xe3c5 undefined */
5446 case 0xe3c8: /* LFHAT - load high and trap */
5447 /* 32-bit high gpr destination + fpc for possible DXC write */
5448 if (s390_record_gpr_h (gdbarch, regcache, inib[2]))
5449 return -1;
5450 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
5451 return -1;
5452 break;
5454 /* 0xe3c9 undefined */
5455 /* 0xe3cc undefined */
5456 /* 0xe3ce undefined */
5457 /* 0xe3d0-0xe3ff undefined */
5459 case 0xe634: /* VPKZ - vector pack zoned */
5460 case 0xe635: /* VLRL - vector load rightmost with immed. length */
5461 case 0xe637: /* VLRLR - vector load rightmost with length */
5462 case 0xe649: /* VLIP - vector load immediate decimal */
5463 case 0xe700: /* VLEB - vector load element */
5464 case 0xe701: /* VLEH - vector load element */
5465 case 0xe702: /* VLEG - vector load element */
5466 case 0xe703: /* VLEF - vector load element */
5467 case 0xe704: /* VLLEZ - vector load logical element and zero */
5468 case 0xe705: /* VLREP - vector load and replicate */
5469 case 0xe706: /* VL - vector load */
5470 case 0xe707: /* VLBB - vector load to block bounduary */
5471 case 0xe712: /* VGEG - vector gather element */
5472 case 0xe713: /* VGEF - vector gather element */
5473 case 0xe722: /* VLVG - vector load vr element from gr */
5474 case 0xe730: /* VESL - vector element shift left */
5475 case 0xe733: /* VERLL - vector element rotate left logical */
5476 case 0xe737: /* VLL - vector load with length */
5477 case 0xe738: /* VESRL - vector element shift right logical */
5478 case 0xe73a: /* VESRA - vector element shift right arithmetic */
5479 case 0xe740: /* VLEIB - vector load element immediate */
5480 case 0xe741: /* VLEIH - vector load element immediate */
5481 case 0xe742: /* VLEIG - vector load element immediate */
5482 case 0xe743: /* VLEIF - vector load element immediate */
5483 case 0xe744: /* VGBM - vector generate byte mask */
5484 case 0xe745: /* VREPI - vector replicate immediate */
5485 case 0xe746: /* VGM - vector generate mask */
5486 case 0xe74d: /* VREP - vector replicate */
5487 case 0xe750: /* VPOPCT - vector population count */
5488 case 0xe752: /* VCTZ - vector count trailing zeros */
5489 case 0xe753: /* VCLZ - vector count leading zeros */
5490 case 0xe756: /* VLR - vector load */
5491 case 0xe75f: /* VSEG -vector sign extend to doubleword */
5492 case 0xe760: /* VMRL - vector merge low */
5493 case 0xe761: /* VMRH - vector merge high */
5494 case 0xe762: /* VLVGP - vector load vr from grs disjoint */
5495 case 0xe764: /* VSUM - vector sum across word */
5496 case 0xe765: /* VSUMG - vector sum across doubleword */
5497 case 0xe766: /* VCKSM - vector checksum */
5498 case 0xe767: /* VSUMQ - vector sum across quadword */
5499 case 0xe768: /* VN - vector and */
5500 case 0xe769: /* VNC - vector and with complement */
5501 case 0xe76a: /* VO - vector or */
5502 case 0xe76b: /* VNO - vector nor */
5503 case 0xe76c: /* VNX - vector not exclusive or */
5504 case 0xe76d: /* VX - vector xor */
5505 case 0xe76e: /* VNN - vector nand */
5506 case 0xe76f: /* VOC - vector or with complement */
5507 case 0xe770: /* VESLV - vector element shift left */
5508 case 0xe772: /* VERIM - vector element rotate and insert under mask */
5509 case 0xe773: /* VERLLV - vector element rotate left logical */
5510 case 0xe774: /* VSL - vector shift left */
5511 case 0xe775: /* VSLB - vector shift left by byte */
5512 case 0xe777: /* VSLDB - vector shift left double by byte */
5513 case 0xe778: /* VESRLV - vector element shift right logical */
5514 case 0xe77a: /* VESRAV - vector element shift right arithmetic */
5515 case 0xe77c: /* VSRL - vector shift right logical */
5516 case 0xe77d: /* VSRLB - vector shift right logical by byte */
5517 case 0xe77e: /* VSRA - vector shift right arithmetic */
5518 case 0xe77f: /* VSRAB - vector shift right arithmetic by byte */
5519 case 0xe784: /* VPDI - vector permute doubleword immediate */
5520 case 0xe785: /* VBPERM - vector bit permute */
5521 case 0xe78c: /* VPERM - vector permute */
5522 case 0xe78d: /* VSEL - vector select */
5523 case 0xe78e: /* VFMS - vector fp multiply and subtract */
5524 case 0xe78f: /* VFMA - vector fp multiply and add */
5525 case 0xe794: /* VPK - vector pack */
5526 case 0xe79e: /* VFNMS - vector fp negative multiply and subtract */
5527 case 0xe79f: /* VFNMA - vector fp negative multiply and add */
5528 case 0xe7a1: /* VMLH - vector multiply logical high */
5529 case 0xe7a2: /* VML - vector multiply low */
5530 case 0xe7a3: /* VMH - vector multiply high */
5531 case 0xe7a4: /* VMLE - vector multiply logical even */
5532 case 0xe7a5: /* VMLO - vector multiply logical odd */
5533 case 0xe7a6: /* VME - vector multiply even */
5534 case 0xe7a7: /* VMO - vector multiply odd */
5535 case 0xe7a9: /* VMALH - vector multiply and add logical high */
5536 case 0xe7aa: /* VMAL - vector multiply and add low */
5537 case 0xe7ab: /* VMAH - vector multiply and add high */
5538 case 0xe7ac: /* VMALE - vector multiply and add logical even */
5539 case 0xe7ad: /* VMALO - vector multiply and add logical odd */
5540 case 0xe7ae: /* VMAE - vector multiply and add even */
5541 case 0xe7af: /* VMAO - vector multiply and add odd */
5542 case 0xe7b4: /* VGFM - vector Galois field multiply sum */
5543 case 0xe7b8: /* VMSL - vector multiply sum logical */
5544 case 0xe7b9: /* VACCC - vector add with carry compute carry */
5545 case 0xe7bb: /* VAC - vector add with carry */
5546 case 0xe7bc: /* VGFMA - vector Galois field multiply sum and accumulate */
5547 case 0xe7bd: /* VSBCBI - vector subtract with borrow compute borrow indication */
5548 case 0xe7bf: /* VSBI - vector subtract with borrow indication */
5549 case 0xe7c0: /* VCLGD - vector convert to logical 64-bit */
5550 case 0xe7c1: /* VCDLG - vector convert from logical 64-bit */
5551 case 0xe7c2: /* VCGD - vector convert to fixed 64-bit */
5552 case 0xe7c3: /* VCDG - vector convert from fixed 64-bit */
5553 case 0xe7c4: /* VLDE/VFLL - vector fp load lengthened */
5554 case 0xe7c5: /* VLED/VFLR - vector fp load rounded */
5555 case 0xe7c7: /* VFI - vector load fp integer */
5556 case 0xe7cc: /* VFPSO - vector fp perform sign operation */
5557 case 0xe7ce: /* VFSQ - vector fp square root */
5558 case 0xe7d4: /* VUPLL - vector unpack logical low */
5559 case 0xe7d6: /* VUPL - vector unpack low */
5560 case 0xe7d5: /* VUPLH - vector unpack logical high */
5561 case 0xe7d7: /* VUPH - vector unpack high */
5562 case 0xe7de: /* VLC - vector load complement */
5563 case 0xe7df: /* VLP - vector load positive */
5564 case 0xe7e2: /* VFA - vector fp subtract */
5565 case 0xe7e3: /* VFA - vector fp add */
5566 case 0xe7e5: /* VFD - vector fp divide */
5567 case 0xe7e7: /* VFM - vector fp multiply */
5568 case 0xe7ee: /* VFMIN - vector fp minimum */
5569 case 0xe7ef: /* VFMAX - vector fp maximum */
5570 case 0xe7f0: /* VAVGL - vector average logical */
5571 case 0xe7f1: /* VACC - vector add and compute carry */
5572 case 0xe7f2: /* VAVG - vector average */
5573 case 0xe7f3: /* VA - vector add */
5574 case 0xe7f5: /* VSCBI - vector subtract compute borrow indication */
5575 case 0xe7f7: /* VS - vector subtract */
5576 case 0xe7fc: /* VMNL - vector minimum logical */
5577 case 0xe7fd: /* VMXL - vector maximum logical */
5578 case 0xe7fe: /* VMN - vector minimum */
5579 case 0xe7ff: /* VMX - vector maximum */
5580 /* vector destination + FPC */
5581 if (s390_record_vr (gdbarch, regcache, ivec[0]))
5582 return -1;
5583 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
5584 return -1;
5585 break;
5587 case 0xe63d: /* VSTRL - vector store rightmost with immed. length */
5588 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
5589 if (record_full_arch_list_add_mem (oaddr, inib[3] + 1))
5590 return -1;
5591 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
5592 return -1;
5593 break;
5595 case 0xe708: /* VSTEB - vector store element */
5596 oaddr = s390_record_calc_disp (gdbarch, regcache, inib[3], insn[1], 0);
5597 if (record_full_arch_list_add_mem (oaddr, 1))
5598 return -1;
5599 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
5600 return -1;
5601 break;
5603 case 0xe709: /* VSTEH - vector store element */
5604 oaddr = s390_record_calc_disp (gdbarch, regcache, inib[3], insn[1], 0);
5605 if (record_full_arch_list_add_mem (oaddr, 2))
5606 return -1;
5607 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
5608 return -1;
5609 break;
5611 case 0xe70a: /* VSTEG - vector store element */
5612 oaddr = s390_record_calc_disp (gdbarch, regcache, inib[3], insn[1], 0);
5613 if (record_full_arch_list_add_mem (oaddr, 8))
5614 return -1;
5615 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
5616 return -1;
5617 break;
5619 case 0xe70b: /* VSTEF - vector store element */
5620 oaddr = s390_record_calc_disp (gdbarch, regcache, inib[3], insn[1], 0);
5621 if (record_full_arch_list_add_mem (oaddr, 4))
5622 return -1;
5623 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
5624 return -1;
5625 break;
5627 /* 0xe70c-0xe70d undefined */
5629 case 0xe70e: /* VST - vector store */
5630 oaddr = s390_record_calc_disp (gdbarch, regcache, inib[3], insn[1], 0);
5631 if (record_full_arch_list_add_mem (oaddr, 16))
5632 return -1;
5633 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
5634 return -1;
5635 break;
5637 /* 0xe70f-0xe711 undefined */
5638 /* 0xe714-0xe719 undefined */
5640 case 0xe71a: /* VSCEG - vector scatter element */
5641 if (s390_record_calc_disp_vsce (gdbarch, regcache, ivec[1], inib[8], 8, insn[1], 0, &oaddr))
5642 return -1;
5643 if (record_full_arch_list_add_mem (oaddr, 8))
5644 return -1;
5645 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
5646 return -1;
5647 break;
5649 case 0xe71b: /* VSCEF - vector scatter element */
5650 if (s390_record_calc_disp_vsce (gdbarch, regcache, ivec[1], inib[8], 4, insn[1], 0, &oaddr))
5651 return -1;
5652 if (record_full_arch_list_add_mem (oaddr, 4))
5653 return -1;
5654 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
5655 return -1;
5656 break;
5658 /* 0xe71c-0xe720 undefined */
5659 /* 0xe723-0xe726 undefined */
5660 /* 0xe728-0xe72f undefined */
5661 /* 0xe731-0xe732 undefined */
5662 /* 0xe734-0xe735 undefined */
5664 case 0xe736: /* VLM - vector load multiple */
5665 for (i = ivec[0]; i != ivec[1]; i++, i &= 0x1f)
5666 if (s390_record_vr (gdbarch, regcache, i))
5667 return -1;
5668 if (s390_record_vr (gdbarch, regcache, ivec[1]))
5669 return -1;
5670 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
5671 return -1;
5672 break;
5674 /* 0xe739 undefined */
5675 /* 0xe73b-0xe73d undefined */
5677 case 0xe73e: /* VSTM - vector store multiple */
5678 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
5679 if (ivec[0] <= ivec[1])
5680 n = ivec[1] - ivec[0] + 1;
5681 else
5682 n = ivec[1] + 0x20 - ivec[0] + 1;
5683 if (record_full_arch_list_add_mem (oaddr, n * 16))
5684 return -1;
5685 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
5686 return -1;
5687 break;
5689 case 0xe63c: /* VUPKZ - vector unpack zoned */
5690 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
5691 if (record_full_arch_list_add_mem (oaddr, (ibyte[1] + 1) & 31))
5692 return -1;
5693 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
5694 return -1;
5695 break;
5697 case 0xe63f: /* VSTRLR - vector store rightmost with length */
5698 case 0xe73f: /* VSTL - vector store with length */
5699 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
5700 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + inib[3], &tmp);
5701 tmp &= 0xffffffffu;
5702 if (tmp > 15)
5703 tmp = 15;
5704 if (record_full_arch_list_add_mem (oaddr, tmp + 1))
5705 return -1;
5706 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
5707 return -1;
5708 break;
5710 /* 0xe747-0xe749 undefined */
5712 case 0xe658: /* VCVD - vector convert to decimal 32 bit */
5713 case 0xe659: /* VSRP - vector shift and round decimal */
5714 case 0xe65a: /* VCVDG - vector convert to decimal 64 bit*/
5715 case 0xe65b: /* VPSOP - vector perform sign operation decimal */
5716 case 0xe671: /* VAP - vector add decimal */
5717 case 0xe673: /* VSP - vector subtract decimal */
5718 case 0xe678: /* VMP - vector multiply decimal */
5719 case 0xe679: /* VMSP - vector multiply decimal */
5720 case 0xe67a: /* VDP - vector divide decimal */
5721 case 0xe67b: /* VRP - vector remainder decimal */
5722 case 0xe67e: /* VSDP - vector shift and divide decimal */
5723 case 0xe74a: /* VFTCI - vector fp test data class immediate */
5724 case 0xe75c: /* VISTR - vector isolate string */
5725 case 0xe780: /* VFEE - vector find element equal */
5726 case 0xe781: /* VFENE - vector find element not equal */
5727 case 0xe782: /* VFA - vector find any element equal */
5728 case 0xe78a: /* VSTRC - vector string range compare */
5729 case 0xe795: /* VPKLS - vector pack logical saturate */
5730 case 0xe797: /* VPKS - vector pack saturate */
5731 case 0xe7e8: /* VFCE - vector fp compare equal */
5732 case 0xe7ea: /* VFCHE - vector fp compare high or equal */
5733 case 0xe7eb: /* VFCH - vector fp compare high */
5734 case 0xe7f8: /* VCEQ - vector compare equal */
5735 case 0xe7f9: /* VCHL - vector compare high logical */
5736 case 0xe7fb: /* VCH - vector compare high */
5737 /* vector destination + flags + FPC */
5738 if (s390_record_vr (gdbarch, regcache, ivec[0]))
5739 return -1;
5740 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
5741 return -1;
5742 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
5743 return -1;
5744 break;
5746 case 0xe65f: /* VTP - vector test decimal */
5747 /* flags + FPC */
5748 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
5749 return -1;
5750 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
5751 return -1;
5752 break;
5754 /* 0xe74b-0xe74c undefined */
5755 /* 0xe74e-0xe74f undefined */
5756 /* 0xe751 undefined */
5757 /* 0xe754-0xe755 undefined */
5758 /* 0xe757-0xe75b undefined */
5759 /* 0xe75d-0xe75e undefined */
5760 /* 0xe763 undefined */
5761 /* 0xe771 undefined */
5762 /* 0xe776 undefined */
5763 /* 0xe779 undefined */
5764 /* 0xe77b undefined */
5765 /* 0xe783 undefined */
5766 /* 0xe786-0xe789 undefined */
5767 /* 0xe78b undefined */
5768 /* 0xe790-0xe793 undefined */
5769 /* 0xe796 undefined */
5770 /* 0xe798-0xe79d undefined */
5771 /* 0xe7a0 undefined */
5772 /* 0xe7a8 undefined */
5773 /* 0xe7b0-0xe7b3 undefined */
5774 /* 0xe7b5-0xe7b7 undefined */
5775 /* 0xe7ba undefined */
5776 /* 0xe7be undefined */
5777 /* 0xe7c6 undefined */
5778 /* 0xe7c8-0xe7c9 undefined */
5780 case 0xe677: /* VCP - vector compare decimal */
5781 case 0xe7ca: /* WFK - vector fp compare and signal scalar */
5782 case 0xe7cb: /* WFC - vector fp compare scalar */
5783 case 0xe7d8: /* VTM - vector test under mask */
5784 case 0xe7d9: /* VECL - vector element compare logical */
5785 case 0xe7db: /* VEC - vector element compare */
5786 case 0xed08: /* KEB - compare and signal */
5787 case 0xed09: /* CEB - compare */
5788 case 0xed18: /* KDB - compare and signal */
5789 case 0xed19: /* CDB - compare */
5790 /* flags + fpc only */
5791 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
5792 return -1;
5793 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
5794 return -1;
5795 break;
5797 /* 0xe7cd undefined */
5798 /* 0xe7cf-0xe7d3 undefined */
5799 /* 0xe7da undefined */
5800 /* 0xe7dc-0xe7dd undefined */
5801 /* 0xe7e0-0xe7e1 undefined */
5802 /* 0xe7e4 undefined */
5803 /* 0xe7e6 undefined */
5804 /* 0xe7e9 undefined */
5805 /* 0xe7ec-0xe7ed undefined */
5806 /* 0xe7f4 undefined */
5807 /* 0xe7f6 undefined */
5808 /* 0xe7fa undefined */
5810 /* 0xeb00-0xeb03 undefined */
5812 case 0xeb04: /* LMG - load multiple */
5813 for (i = inib[2]; i != inib[3]; i++, i &= 0xf)
5814 if (s390_record_gpr_g (gdbarch, regcache, i))
5815 return -1;
5816 if (s390_record_gpr_g (gdbarch, regcache, inib[3]))
5817 return -1;
5818 break;
5820 /* 0xeb05-0xeb09 undefined */
5821 /* 0xeb0e undefined */
5822 /* 0xeb0f privileged: TRACG */
5823 /* 0xeb10-0xeb13 undefined */
5825 case 0xeb14: /* CSY - compare and swap */
5826 case 0xebf4: /* LAN - load and and */
5827 case 0xebf6: /* LAO - load and or */
5828 case 0xebf7: /* LAX - load and xor */
5829 case 0xebf8: /* LAA - load and add */
5830 case 0xebfa: /* LAAL - load and add logical */
5831 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], ibyte[4]);
5832 if (record_full_arch_list_add_mem (oaddr, 4))
5833 return -1;
5834 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
5835 return -1;
5836 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
5837 return -1;
5838 break;
5840 /* 0xeb15-0xeb1b undefined */
5841 /* 0xeb1e-0xeb1f undefined */
5842 /* 0xeb22 undefined */
5844 case 0xeb23: /* CLT - compare logical and trap */
5845 case 0xeb2b: /* CLGT - compare logical and trap */
5846 /* fpc only - including possible DXC write for trapping insns */
5847 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
5848 return -1;
5849 break;
5851 case 0xeb24: /* STMG - store multiple */
5852 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], ibyte[4]);
5853 if (inib[2] <= inib[3])
5854 n = inib[3] - inib[2] + 1;
5855 else
5856 n = inib[3] + 0x10 - inib[2] + 1;
5857 if (record_full_arch_list_add_mem (oaddr, n * 8))
5858 return -1;
5859 break;
5861 /* 0xeb25 privileged */
5863 case 0xeb26: /* STMH - store multiple high */
5864 case 0xeb90: /* STMY - store multiple */
5865 case 0xeb9b: /* STAMY - store access multiple */
5866 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], ibyte[4]);
5867 if (inib[2] <= inib[3])
5868 n = inib[3] - inib[2] + 1;
5869 else
5870 n = inib[3] + 0x10 - inib[2] + 1;
5871 if (record_full_arch_list_add_mem (oaddr, n * 4))
5872 return -1;
5873 break;
5875 /* 0xeb27-0xeb2a undefined */
5877 case 0xeb2c: /* STCMH - store characters under mask */
5878 case 0xeb2d: /* STCMY - store characters under mask */
5879 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], ibyte[4]);
5880 if (record_full_arch_list_add_mem (oaddr, s390_popcnt (inib[3])))
5881 return -1;
5882 break;
5884 /* 0xeb2e undefined */
5885 /* 0xeb2f privileged */
5887 case 0xeb30: /* CSG - compare and swap */
5888 case 0xebe4: /* LANG - load and and */
5889 case 0xebe6: /* LAOG - load and or */
5890 case 0xebe7: /* LAXG - load and xor */
5891 case 0xebe8: /* LAAG - load and add */
5892 case 0xebea: /* LAALG - load and add logical */
5893 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], ibyte[4]);
5894 if (record_full_arch_list_add_mem (oaddr, 8))
5895 return -1;
5896 if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
5897 return -1;
5898 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
5899 return -1;
5900 break;
5902 case 0xeb31: /* CDSY - compare double and swap */
5903 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], ibyte[4]);
5904 if (record_full_arch_list_add_mem (oaddr, 8))
5905 return -1;
5906 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
5907 return -1;
5908 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[2] | 1)))
5909 return -1;
5910 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
5911 return -1;
5912 break;
5914 /* 0xeb32-0xeb3d undefined */
5916 case 0xeb3e: /* CDSG - compare double and swap */
5917 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], ibyte[4]);
5918 if (record_full_arch_list_add_mem (oaddr, 16))
5919 return -1;
5920 if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
5921 return -1;
5922 if (s390_record_gpr_g (gdbarch, regcache, inib[2] | 1))
5923 return -1;
5924 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
5925 return -1;
5926 break;
5928 /* 0xeb3f-0xeb43 undefined */
5929 /* 0xeb46-0xeb4b undefined */
5930 /* 0xeb4d-0xeb50 undefined */
5932 case 0xeb52: /* MVIY - move */
5933 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], ibyte[4]);
5934 if (record_full_arch_list_add_mem (oaddr, 1))
5935 return -1;
5936 break;
5938 case 0xeb54: /* NIY - and */
5939 case 0xeb56: /* OIY - or */
5940 case 0xeb57: /* XIY - xor */
5941 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], ibyte[4]);
5942 if (record_full_arch_list_add_mem (oaddr, 1))
5943 return -1;
5944 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
5945 return -1;
5946 break;
5948 /* 0xeb53 undefined */
5949 /* 0xeb58-0xeb69 undefined */
5951 case 0xeb6a: /* ASI - add immediate */
5952 case 0xeb6e: /* ALSI - add immediate */
5953 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], ibyte[4]);
5954 if (record_full_arch_list_add_mem (oaddr, 4))
5955 return -1;
5956 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
5957 return -1;
5958 break;
5960 /* 0xeb6b-0xeb6d undefined */
5961 /* 0xeb6f-0xeb79 undefined */
5963 case 0xeb7a: /* AGSI - add immediate */
5964 case 0xeb7e: /* ALGSI - add immediate */
5965 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], ibyte[4]);
5966 if (record_full_arch_list_add_mem (oaddr, 8))
5967 return -1;
5968 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
5969 return -1;
5970 break;
5972 /* 0xeb7b-0xeb7d undefined */
5973 /* 0xeb7f undefined */
5975 case 0xeb80: /* ICMH - insert characters under mask */
5976 /* 32-bit high gpr destination + flags */
5977 if (s390_record_gpr_h (gdbarch, regcache, inib[2]))
5978 return -1;
5979 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
5980 return -1;
5981 break;
5983 /* 0xeb82-0xeb8d undefined */
5985 case 0xeb8e: /* MVCLU - move long unicode [partial] */
5986 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + inib[2], &tmp);
5987 oaddr = s390_record_address_mask (gdbarch, regcache, tmp);
5988 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + (inib[2] | 1), &tmp);
5989 if (record_full_arch_list_add_mem (oaddr, tmp))
5990 return -1;
5991 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
5992 return -1;
5993 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[2] | 1)))
5994 return -1;
5995 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[3]))
5996 return -1;
5997 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[3] | 1)))
5998 return -1;
5999 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
6000 return -1;
6001 break;
6003 case 0xeb8f: /* CLCLU - compare logical long unicode [partial] */
6004 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
6005 return -1;
6006 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[2] | 1)))
6007 return -1;
6008 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[3]))
6009 return -1;
6010 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[3] | 1)))
6011 return -1;
6012 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
6013 return -1;
6014 break;
6016 /* 0xeb91-0xeb95 undefined */
6018 case 0xeb96: /* LMH - load multiple high */
6019 for (i = inib[2]; i != inib[3]; i++, i &= 0xf)
6020 if (s390_record_gpr_h (gdbarch, regcache, i))
6021 return -1;
6022 if (s390_record_gpr_h (gdbarch, regcache, inib[3]))
6023 return -1;
6024 break;
6026 /* 0xeb97 undefined */
6028 case 0xeb98: /* LMY - load multiple */
6029 for (i = inib[2]; i != inib[3]; i++, i &= 0xf)
6030 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + i))
6031 return -1;
6032 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[3]))
6033 return -1;
6034 break;
6036 /* 0xeb99 undefined */
6038 case 0xeb9a: /* LAMY - load access multiple */
6039 for (i = inib[2]; i != inib[3]; i++, i &= 0xf)
6040 if (record_full_arch_list_add_reg (regcache, S390_A0_REGNUM + i))
6041 return -1;
6042 if (record_full_arch_list_add_reg (regcache, S390_A0_REGNUM + inib[3]))
6043 return -1;
6044 break;
6046 /* 0xeb9c-0xebbf undefined */
6047 /* 0xebc1-0xebdb undefined */
6048 /* 0xebe5 undefined */
6049 /* 0xebe9 undefined */
6050 /* 0xebeb-0xebf1 undefined */
6051 /* 0xebf5 undefined */
6052 /* 0xebf9 undefined */
6053 /* 0xebfb-0xebff undefined */
6055 /* 0xed00-0xed03 undefined */
6057 case 0xed04: /* LDEB - load lengthened */
6058 case 0xed0c: /* MDEB - multiply */
6059 case 0xed0d: /* DEB - divide */
6060 case 0xed14: /* SQEB - square root */
6061 case 0xed15: /* SQDB - square root */
6062 case 0xed17: /* MEEB - multiply */
6063 case 0xed1c: /* MDB - multiply */
6064 case 0xed1d: /* DDB - divide */
6065 /* float destination + fpc */
6066 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[2]))
6067 return -1;
6068 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
6069 return -1;
6070 break;
6072 case 0xed05: /* LXDB - load lengthened */
6073 case 0xed06: /* LXEB - load lengthened */
6074 case 0xed07: /* MXDB - multiply */
6075 /* float pair destination + fpc */
6076 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[2]))
6077 return -1;
6078 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + (inib[2] | 2)))
6079 return -1;
6080 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
6081 return -1;
6082 break;
6084 case 0xed0a: /* AEB - add */
6085 case 0xed0b: /* SEB - subtract */
6086 case 0xed1a: /* ADB - add */
6087 case 0xed1b: /* SDB - subtract */
6088 /* float destination + flags + fpc */
6089 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[2]))
6090 return -1;
6091 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
6092 return -1;
6093 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
6094 return -1;
6095 break;
6097 case 0xed0e: /* MAEB - multiply and add */
6098 case 0xed0f: /* MSEB - multiply and subtract */
6099 case 0xed1e: /* MADB - multiply and add */
6100 case 0xed1f: /* MSDB - multiply and subtract */
6101 case 0xed40: /* SLDT - shift significand left */
6102 case 0xed41: /* SRDT - shift significand right */
6103 case 0xedaa: /* CDZT - convert from zoned */
6104 case 0xedae: /* CDPT - convert from packed */
6105 /* float destination [RXF] + fpc */
6106 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[8]))
6107 return -1;
6108 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
6109 return -1;
6110 break;
6112 /* 0xed13 undefined */
6113 /* 0xed16 undefined */
6114 /* 0xed20-0xed23 undefined */
6116 case 0xed24: /* LDE - load lengthened */
6117 case 0xed34: /* SQE - square root */
6118 case 0xed35: /* SQD - square root */
6119 case 0xed37: /* MEE - multiply */
6120 case 0xed64: /* LEY - load */
6121 case 0xed65: /* LDY - load */
6122 /* float destination */
6123 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[2]))
6124 return -1;
6125 break;
6127 case 0xed25: /* LXD - load lengthened */
6128 case 0xed26: /* LXE - load lengthened */
6129 /* float pair destination */
6130 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[2]))
6131 return -1;
6132 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + (inib[2] | 2)))
6133 return -1;
6134 break;
6136 /* 0xed27-0xed2d undefined */
6138 case 0xed2e: /* MAE - multiply and add */
6139 case 0xed2f: /* MSE - multiply and subtract */
6140 case 0xed38: /* MAYL - multiply and add unnormalized */
6141 case 0xed39: /* MYL - multiply unnormalized */
6142 case 0xed3c: /* MAYH - multiply and add unnormalized */
6143 case 0xed3d: /* MYH - multiply unnormalized */
6144 case 0xed3e: /* MAD - multiply and add */
6145 case 0xed3f: /* MSD - multiply and subtract */
6146 /* float destination [RXF] */
6147 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[8]))
6148 return -1;
6149 break;
6151 /* 0xed30-0xed33 undefined */
6152 /* 0xed36 undefined */
6154 case 0xed3a: /* MAY - multiply and add unnormalized */
6155 case 0xed3b: /* MY - multiply unnormalized */
6156 /* float pair destination [RXF] */
6157 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[8]))
6158 return -1;
6159 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + (inib[8] | 2)))
6160 return -1;
6161 break;
6163 /* 0xed42-0xed47 undefind */
6165 case 0xed48: /* SLXT - shift significand left */
6166 case 0xed49: /* SRXT - shift significand right */
6167 case 0xedab: /* CXZT - convert from zoned */
6168 case 0xedaf: /* CXPT - convert from packed */
6169 /* float pair destination [RXF] + fpc */
6170 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[8]))
6171 return -1;
6172 if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + (inib[8] | 2)))
6173 return -1;
6174 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
6175 return -1;
6176 break;
6178 /* 0xed4a-0xed4f undefind */
6179 /* 0xed52-0xed53 undefind */
6180 /* 0xed56-0xed57 undefind */
6181 /* 0xed5a-0xed63 undefind */
6182 /* 0xed68-0xeda7 undefined */
6184 case 0xeda8: /* CZDT - convert to zoned */
6185 case 0xeda9: /* CZXT - convert to zoned */
6186 case 0xedac: /* CPDT - convert to packed */
6187 case 0xedad: /* CPXT - convert to packed */
6188 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
6189 if (record_full_arch_list_add_mem (oaddr, ibyte[1] + 1))
6190 return -1;
6191 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
6192 return -1;
6193 break;
6195 /* 0xedb0-0xedff undefined */
6197 default:
6198 goto UNKNOWN_OP;
6200 break;
6202 /* 0xe4 undefined */
6204 case 0xe5:
6205 /* SSE/SIL-format instruction */
6206 switch (insn[0])
6208 /* 0xe500-0xe543 undefined, privileged, or unsupported */
6210 case 0xe544: /* MVHHI - move */
6211 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
6212 if (record_full_arch_list_add_mem (oaddr, 2))
6213 return -1;
6214 break;
6216 /* 0xe545-0xe547 undefined */
6218 case 0xe548: /* MVGHI - move */
6219 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
6220 if (record_full_arch_list_add_mem (oaddr, 8))
6221 return -1;
6222 break;
6224 /* 0xe549-0xe54b undefined */
6226 case 0xe54c: /* MVHI - move */
6227 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
6228 if (record_full_arch_list_add_mem (oaddr, 4))
6229 return -1;
6230 break;
6232 /* 0xe54d-0xe553 undefined */
6234 case 0xe554: /* CHHSI - compare halfword immediate */
6235 case 0xe555: /* CLHHSI - compare logical immediate */
6236 case 0xe558: /* CGHSI - compare halfword immediate */
6237 case 0xe559: /* CLGHSI - compare logical immediate */
6238 case 0xe55c: /* CHSI - compare halfword immediate */
6239 case 0xe55d: /* CLFHSI - compare logical immediate */
6240 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
6241 return -1;
6242 break;
6244 /* 0xe556-0xe557 undefined */
6245 /* 0xe55a-0xe55b undefined */
6246 /* 0xe55e-0xe55f undefined */
6248 case 0xe560: /* TBEGIN - transaction begin */
6249 /* The transaction will be immediately aborted after this
6250 instruction, due to single-stepping. This instruction is
6251 only supported so that the program can fail a few times
6252 and go to the non-transactional fallback. */
6253 if (inib[4])
6255 /* Transaction diagnostic block - user. */
6256 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
6257 if (record_full_arch_list_add_mem (oaddr, 256))
6258 return -1;
6260 /* Transaction diagnostic block - supervisor. */
6261 if (record_full_arch_list_add_reg (regcache, S390_TDB_DWORD0_REGNUM))
6262 return -1;
6263 if (record_full_arch_list_add_reg (regcache, S390_TDB_ABORT_CODE_REGNUM))
6264 return -1;
6265 if (record_full_arch_list_add_reg (regcache, S390_TDB_CONFLICT_TOKEN_REGNUM))
6266 return -1;
6267 if (record_full_arch_list_add_reg (regcache, S390_TDB_ATIA_REGNUM))
6268 return -1;
6269 for (i = 0; i < 16; i++)
6270 if (record_full_arch_list_add_reg (regcache, S390_TDB_R0_REGNUM + i))
6271 return -1;
6272 /* And flags. */
6273 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
6274 return -1;
6275 break;
6277 /* 0xe561 unsupported: TBEGINC */
6278 /* 0xe562-0xe5ff undefined */
6280 default:
6281 goto UNKNOWN_OP;
6283 break;
6285 case 0xec:
6286 /* RIE/RIS/RRS-format instruction */
6287 switch (ibyte[0] << 8 | ibyte[5])
6289 /* 0xec00-0xec41 undefined */
6291 case 0xec42: /* LOCHI - load halfword immediate on condition */
6292 case 0xec51: /* RISBLG - rotate then insert selected bits low */
6293 /* 32-bit or native gpr destination */
6294 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
6295 return -1;
6296 break;
6298 /* 0xec43 undefined */
6300 case 0xec44: /* BRXHG - branch relative on index high */
6301 case 0xec45: /* BRXLG - branch relative on index low or equal */
6302 case 0xec46: /* LOCGHI - load halfword immediate on condition */
6303 case 0xec59: /* RISBGN - rotate then insert selected bits */
6304 /* 64-bit gpr destination */
6305 if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
6306 return -1;
6307 break;
6309 /* 0xec47-0xec4d undefined */
6311 case 0xec4e: /* LOCHHI - load halfword immediate on condition */
6312 case 0xec5d: /* RISBHG - rotate then insert selected bits high */
6313 /* 32-bit high gpr destination */
6314 if (s390_record_gpr_h (gdbarch, regcache, inib[2]))
6315 return -1;
6316 break;
6318 /* 0xec4f-0xec50 undefined */
6319 /* 0xec52-0xec53 undefined */
6321 case 0xec54: /* RNSBG - rotate then and selected bits */
6322 case 0xec55: /* RISBG - rotate then insert selected bits */
6323 case 0xec56: /* ROSBG - rotate then or selected bits */
6324 case 0xec57: /* RXSBG - rotate then xor selected bits */
6325 case 0xecd9: /* AGHIK - add immediate */
6326 case 0xecdb: /* ALGHSIK - add logical immediate */
6327 /* 64-bit gpr destination + flags */
6328 if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
6329 return -1;
6330 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
6331 return -1;
6332 break;
6334 /* 0xec58 undefined */
6335 /* 0xec5a-0xec5c undefined */
6336 /* 0xec5e-0xec63 undefined */
6338 case 0xec64: /* CGRJ - compare and branch relative */
6339 case 0xec65: /* CLGRJ - compare logical and branch relative */
6340 case 0xec76: /* CRJ - compare and branch relative */
6341 case 0xec77: /* CLRJ - compare logical and branch relative */
6342 case 0xec7c: /* CGIJ - compare immediate and branch relative */
6343 case 0xec7d: /* CLGIJ - compare logical immediate and branch relative */
6344 case 0xec7e: /* CIJ - compare immediate and branch relative */
6345 case 0xec7f: /* CLIJ - compare logical immediate and branch relative */
6346 case 0xece4: /* CGRB - compare and branch */
6347 case 0xece5: /* CLGRB - compare logical and branch */
6348 case 0xecf6: /* CRB - compare and branch */
6349 case 0xecf7: /* CLRB - compare logical and branch */
6350 case 0xecfc: /* CGIB - compare immediate and branch */
6351 case 0xecfd: /* CLGIB - compare logical immediate and branch */
6352 case 0xecfe: /* CIB - compare immediate and branch */
6353 case 0xecff: /* CLIB - compare logical immediate and branch */
6354 break;
6356 /* 0xec66-0xec6f undefined */
6358 case 0xec70: /* CGIT - compare immediate and trap */
6359 case 0xec71: /* CLGIT - compare logical immediate and trap */
6360 case 0xec72: /* CIT - compare immediate and trap */
6361 case 0xec73: /* CLFIT - compare logical immediate and trap */
6362 /* fpc only - including possible DXC write for trapping insns */
6363 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
6364 return -1;
6365 break;
6367 /* 0xec74-0xec75 undefined */
6368 /* 0xec78-0xec7b undefined */
6370 /* 0xec80-0xecd7 undefined */
6372 case 0xecd8: /* AHIK - add immediate */
6373 case 0xecda: /* ALHSIK - add logical immediate */
6374 /* 32-bit gpr destination + flags */
6375 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
6376 return -1;
6377 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
6378 return -1;
6379 break;
6381 /* 0xecdc-0xece3 undefined */
6382 /* 0xece6-0xecf5 undefined */
6383 /* 0xecf8-0xecfb undefined */
6385 default:
6386 goto UNKNOWN_OP;
6388 break;
6390 case 0xee: /* PLO - perform locked operation */
6391 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM, &tmp);
6392 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
6393 oaddr2 = s390_record_calc_disp (gdbarch, regcache, 0, insn[2], 0);
6394 if (!(tmp & 0x100))
6396 uint8_t fc = tmp & 0xff;
6397 gdb_byte buf[8];
6398 switch (fc)
6400 case 0x00: /* CL */
6401 /* op1c */
6402 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
6403 return -1;
6404 /* op3 */
6405 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[3]))
6406 return -1;
6407 break;
6409 case 0x01: /* CLG */
6410 /* op1c */
6411 if (record_full_arch_list_add_mem (oaddr2 + 0x08, 8))
6412 return -1;
6413 /* op3 */
6414 if (record_full_arch_list_add_mem (oaddr2 + 0x28, 8))
6415 return -1;
6416 break;
6418 case 0x02: /* CLGR */
6419 /* op1c */
6420 if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
6421 return -1;
6422 /* op3 */
6423 if (s390_record_gpr_g (gdbarch, regcache, inib[3]))
6424 return -1;
6425 break;
6427 case 0x03: /* CLX */
6428 /* op1c */
6429 if (record_full_arch_list_add_mem (oaddr2 + 0x00, 16))
6430 return -1;
6431 /* op3 */
6432 if (record_full_arch_list_add_mem (oaddr2 + 0x20, 16))
6433 return -1;
6434 break;
6436 case 0x08: /* DCS */
6437 /* op3c */
6438 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[3]))
6439 return -1;
6440 /* fallthru */
6441 case 0x0c: /* CSST */
6442 /* op4 */
6443 if (record_full_arch_list_add_mem (oaddr2, 4))
6444 return -1;
6445 goto CS;
6447 case 0x14: /* CSTST */
6448 /* op8 */
6449 if (target_read_memory (oaddr2 + 0x88, buf, 8))
6450 return -1;
6451 oaddr3 = extract_unsigned_integer (buf, 8, byte_order);
6452 oaddr3 = s390_record_address_mask (gdbarch, regcache, oaddr3);
6453 if (record_full_arch_list_add_mem (oaddr3, 4))
6454 return -1;
6455 /* fallthru */
6456 case 0x10: /* CSDST */
6457 /* op6 */
6458 if (target_read_memory (oaddr2 + 0x68, buf, 8))
6459 return -1;
6460 oaddr3 = extract_unsigned_integer (buf, 8, byte_order);
6461 oaddr3 = s390_record_address_mask (gdbarch, regcache, oaddr3);
6462 if (record_full_arch_list_add_mem (oaddr3, 4))
6463 return -1;
6464 /* op4 */
6465 if (target_read_memory (oaddr2 + 0x48, buf, 8))
6466 return -1;
6467 oaddr3 = extract_unsigned_integer (buf, 8, byte_order);
6468 oaddr3 = s390_record_address_mask (gdbarch, regcache, oaddr3);
6469 if (record_full_arch_list_add_mem (oaddr3, 4))
6470 return -1;
6471 /* fallthru */
6472 case 0x04: /* CS */
6474 /* op1c */
6475 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
6476 return -1;
6477 /* op2 */
6478 if (record_full_arch_list_add_mem (oaddr, 4))
6479 return -1;
6480 break;
6482 case 0x09: /* DCSG */
6483 /* op3c */
6484 if (record_full_arch_list_add_mem (oaddr2 + 0x28, 8))
6485 return -1;
6486 goto CSSTG;
6488 case 0x15: /* CSTSTG */
6489 /* op8 */
6490 if (target_read_memory (oaddr2 + 0x88, buf, 8))
6491 return -1;
6492 oaddr3 = extract_unsigned_integer (buf, 8, byte_order);
6493 oaddr3 = s390_record_address_mask (gdbarch, regcache, oaddr3);
6494 if (record_full_arch_list_add_mem (oaddr3, 8))
6495 return -1;
6496 /* fallthru */
6497 case 0x11: /* CSDSTG */
6498 /* op6 */
6499 if (target_read_memory (oaddr2 + 0x68, buf, 8))
6500 return -1;
6501 oaddr3 = extract_unsigned_integer (buf, 8, byte_order);
6502 oaddr3 = s390_record_address_mask (gdbarch, regcache, oaddr3);
6503 if (record_full_arch_list_add_mem (oaddr3, 8))
6504 return -1;
6505 /* fallthru */
6506 case 0x0d: /* CSSTG */
6507 CSSTG:
6508 /* op4 */
6509 if (target_read_memory (oaddr2 + 0x48, buf, 8))
6510 return -1;
6511 oaddr3 = extract_unsigned_integer (buf, 8, byte_order);
6512 oaddr3 = s390_record_address_mask (gdbarch, regcache, oaddr3);
6513 if (record_full_arch_list_add_mem (oaddr3, 8))
6514 return -1;
6515 /* fallthru */
6516 case 0x05: /* CSG */
6517 /* op1c */
6518 if (record_full_arch_list_add_mem (oaddr2 + 0x08, 8))
6519 return -1;
6520 /* op2 */
6521 if (record_full_arch_list_add_mem (oaddr, 8))
6522 return -1;
6523 break;
6525 case 0x0a: /* DCSGR */
6526 /* op3c */
6527 if (s390_record_gpr_g (gdbarch, regcache, inib[3]))
6528 return -1;
6529 /* fallthru */
6530 case 0x0e: /* CSSTGR */
6531 /* op4 */
6532 if (record_full_arch_list_add_mem (oaddr2, 8))
6533 return -1;
6534 goto CSGR;
6536 case 0x16: /* CSTSTGR */
6537 /* op8 */
6538 if (target_read_memory (oaddr2 + 0x88, buf, 8))
6539 return -1;
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))
6543 return -1;
6544 /* fallthru */
6545 case 0x12: /* CSDSTGR */
6546 /* op6 */
6547 if (target_read_memory (oaddr2 + 0x68, buf, 8))
6548 return -1;
6549 oaddr3 = extract_unsigned_integer (buf, 8, byte_order);
6550 oaddr3 = s390_record_address_mask (gdbarch, regcache, oaddr3);
6551 if (record_full_arch_list_add_mem (oaddr3, 8))
6552 return -1;
6553 /* op4 */
6554 if (target_read_memory (oaddr2 + 0x48, buf, 8))
6555 return -1;
6556 oaddr3 = extract_unsigned_integer (buf, 8, byte_order);
6557 oaddr3 = s390_record_address_mask (gdbarch, regcache, oaddr3);
6558 if (record_full_arch_list_add_mem (oaddr3, 8))
6559 return -1;
6560 /* fallthru */
6561 case 0x06: /* CSGR */
6562 CSGR:
6563 /* op1c */
6564 if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
6565 return -1;
6566 /* op2 */
6567 if (record_full_arch_list_add_mem (oaddr, 8))
6568 return -1;
6569 break;
6571 case 0x0b: /* DCSX */
6572 /* op3c */
6573 if (record_full_arch_list_add_mem (oaddr2 + 0x20, 16))
6574 return -1;
6575 goto CSSTX;
6577 case 0x17: /* CSTSTX */
6578 /* op8 */
6579 if (target_read_memory (oaddr2 + 0x88, buf, 8))
6580 return -1;
6581 oaddr3 = extract_unsigned_integer (buf, 8, byte_order);
6582 oaddr3 = s390_record_address_mask (gdbarch, regcache, oaddr3);
6583 if (record_full_arch_list_add_mem (oaddr3, 16))
6584 return -1;
6585 /* fallthru */
6586 case 0x13: /* CSDSTX */
6587 /* op6 */
6588 if (target_read_memory (oaddr2 + 0x68, buf, 8))
6589 return -1;
6590 oaddr3 = extract_unsigned_integer (buf, 8, byte_order);
6591 oaddr3 = s390_record_address_mask (gdbarch, regcache, oaddr3);
6592 if (record_full_arch_list_add_mem (oaddr3, 16))
6593 return -1;
6594 /* fallthru */
6595 case 0x0f: /* CSSTX */
6596 CSSTX:
6597 /* op4 */
6598 if (target_read_memory (oaddr2 + 0x48, buf, 8))
6599 return -1;
6600 oaddr3 = extract_unsigned_integer (buf, 8, byte_order);
6601 oaddr3 = s390_record_address_mask (gdbarch, regcache, oaddr3);
6602 if (record_full_arch_list_add_mem (oaddr3, 16))
6603 return -1;
6604 /* fallthru */
6605 case 0x07: /* CSX */
6606 /* op1c */
6607 if (record_full_arch_list_add_mem (oaddr2 + 0x00, 16))
6608 return -1;
6609 /* op2 */
6610 if (record_full_arch_list_add_mem (oaddr, 16))
6611 return -1;
6612 break;
6614 default:
6615 fprintf_unfiltered (gdb_stdlog, "Warning: Unknown PLO FC %02x at %s.\n",
6616 fc, paddress (gdbarch, addr));
6617 return -1;
6620 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
6621 return -1;
6622 break;
6624 case 0xef: /* LMD - load multiple disjoint */
6625 for (i = inib[2]; i != inib[3]; i++, i &= 0xf)
6626 if (s390_record_gpr_g (gdbarch, regcache, i))
6627 return -1;
6628 if (s390_record_gpr_g (gdbarch, regcache, inib[3]))
6629 return -1;
6630 break;
6632 case 0xf0: /* SRP - shift and round decimal */
6633 case 0xf8: /* ZAP - zero and add */
6634 case 0xfa: /* AP - add decimal */
6635 case 0xfb: /* SP - subtract decimal */
6636 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
6637 if (record_full_arch_list_add_mem (oaddr, inib[2] + 1))
6638 return -1;
6639 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
6640 return -1;
6641 /* DXC may be written */
6642 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
6643 return -1;
6644 break;
6646 case 0xf1: /* MVO - move with offset */
6647 case 0xf2: /* PACK - pack */
6648 case 0xf3: /* UNPK - unpack */
6649 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
6650 if (record_full_arch_list_add_mem (oaddr, inib[2] + 1))
6651 return -1;
6652 break;
6654 /* 0xf4-0xf7 undefined */
6656 case 0xf9: /* CP - compare decimal */
6657 if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
6658 return -1;
6659 /* DXC may be written */
6660 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
6661 return -1;
6662 break;
6664 case 0xfc: /* MP - multiply decimal */
6665 case 0xfd: /* DP - divide decimal */
6666 oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
6667 if (record_full_arch_list_add_mem (oaddr, inib[2] + 1))
6668 return -1;
6669 /* DXC may be written */
6670 if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
6671 return -1;
6672 break;
6674 /* 0xfe-0xff undefined */
6676 default:
6677 UNKNOWN_OP:
6678 fprintf_unfiltered (gdb_stdlog, "Warning: Don't know how to record %04x "
6679 "at %s.\n", insn[0], paddress (gdbarch, addr));
6680 return -1;
6683 if (record_full_arch_list_add_reg (regcache, S390_PSWA_REGNUM))
6684 return -1;
6685 if (record_full_arch_list_add_end ())
6686 return -1;
6687 return 0;
6690 /* Miscellaneous. */
6692 /* Implement gdbarch_gcc_target_options. GCC does not know "-m32" or
6693 "-mcmodel=large". */
6695 static char *
6696 s390_gcc_target_options (struct gdbarch *gdbarch)
6698 return xstrdup (gdbarch_ptr_bit (gdbarch) == 64 ? "-m64" : "-m31");
6701 /* Implement gdbarch_gnu_triplet_regexp. Target triplets are "s390-*"
6702 for 31-bit and "s390x-*" for 64-bit, while the BFD arch name is
6703 always "s390". Note that an s390x compiler supports "-m31" as
6704 well. */
6706 static const char *
6707 s390_gnu_triplet_regexp (struct gdbarch *gdbarch)
6709 return "s390x?";
6712 /* Implementation of `gdbarch_stap_is_single_operand', as defined in
6713 gdbarch.h. */
6715 static int
6716 s390_stap_is_single_operand (struct gdbarch *gdbarch, const char *s)
6718 return ((isdigit (*s) && s[1] == '(' && s[2] == '%') /* Displacement
6719 or indirection. */
6720 || *s == '%' /* Register access. */
6721 || isdigit (*s)); /* Literal number. */
6724 /* gdbarch init. */
6726 /* Validate the range of registers. NAMES must be known at compile time. */
6728 #define s390_validate_reg_range(feature, tdesc_data, start, names) \
6729 do \
6731 for (int i = 0; i < ARRAY_SIZE (names); i++) \
6732 if (!tdesc_numbered_register (feature, tdesc_data, start + i, names[i])) \
6733 return false; \
6735 while (0)
6737 /* Validate the target description. Also numbers registers contained in
6738 tdesc. */
6740 static bool
6741 s390_tdesc_valid (struct gdbarch_tdep *tdep,
6742 struct tdesc_arch_data *tdesc_data)
6744 static const char *const psw[] = {
6745 "pswm", "pswa"
6747 static const char *const gprs[] = {
6748 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
6749 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
6751 static const char *const fprs[] = {
6752 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
6753 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15"
6755 static const char *const acrs[] = {
6756 "acr0", "acr1", "acr2", "acr3", "acr4", "acr5", "acr6", "acr7",
6757 "acr8", "acr9", "acr10", "acr11", "acr12", "acr13", "acr14", "acr15"
6759 static const char *const gprs_lower[] = {
6760 "r0l", "r1l", "r2l", "r3l", "r4l", "r5l", "r6l", "r7l",
6761 "r8l", "r9l", "r10l", "r11l", "r12l", "r13l", "r14l", "r15l"
6763 static const char *const gprs_upper[] = {
6764 "r0h", "r1h", "r2h", "r3h", "r4h", "r5h", "r6h", "r7h",
6765 "r8h", "r9h", "r10h", "r11h", "r12h", "r13h", "r14h", "r15h"
6767 static const char *const tdb_regs[] = {
6768 "tdb0", "tac", "tct", "atia",
6769 "tr0", "tr1", "tr2", "tr3", "tr4", "tr5", "tr6", "tr7",
6770 "tr8", "tr9", "tr10", "tr11", "tr12", "tr13", "tr14", "tr15"
6772 static const char *const vxrs_low[] = {
6773 "v0l", "v1l", "v2l", "v3l", "v4l", "v5l", "v6l", "v7l", "v8l",
6774 "v9l", "v10l", "v11l", "v12l", "v13l", "v14l", "v15l",
6776 static const char *const vxrs_high[] = {
6777 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23", "v24",
6778 "v25", "v26", "v27", "v28", "v29", "v30", "v31",
6780 static const char *const gs_cb[] = {
6781 "gsd", "gssm", "gsepla",
6783 static const char *const gs_bc[] = {
6784 "bc_gsd", "bc_gssm", "bc_gsepla",
6787 const struct target_desc *tdesc = tdep->tdesc;
6788 const struct tdesc_feature *feature;
6790 if (!tdesc_has_registers (tdesc))
6791 return false;
6793 /* Core registers, i.e. general purpose and PSW. */
6794 feature = tdesc_find_feature (tdesc, "org.gnu.gdb.s390.core");
6795 if (feature == NULL)
6796 return false;
6798 s390_validate_reg_range (feature, tdesc_data, S390_PSWM_REGNUM, psw);
6800 if (tdesc_unnumbered_register (feature, "r0"))
6802 s390_validate_reg_range (feature, tdesc_data, S390_R0_REGNUM, gprs);
6804 else
6806 tdep->have_upper = true;
6807 s390_validate_reg_range (feature, tdesc_data, S390_R0_REGNUM,
6808 gprs_lower);
6809 s390_validate_reg_range (feature, tdesc_data, S390_R0_UPPER_REGNUM,
6810 gprs_upper);
6813 /* Floating point registers. */
6814 feature = tdesc_find_feature (tdesc, "org.gnu.gdb.s390.fpr");
6815 if (feature == NULL)
6816 return false;
6818 if (!tdesc_numbered_register (feature, tdesc_data, S390_FPC_REGNUM, "fpc"))
6819 return false;
6821 s390_validate_reg_range (feature, tdesc_data, S390_F0_REGNUM, fprs);
6823 /* Access control registers. */
6824 feature = tdesc_find_feature (tdesc, "org.gnu.gdb.s390.acr");
6825 if (feature == NULL)
6826 return false;
6828 s390_validate_reg_range (feature, tdesc_data, S390_A0_REGNUM, acrs);
6830 /* Optional GNU/Linux-specific "registers". */
6831 feature = tdesc_find_feature (tdesc, "org.gnu.gdb.s390.linux");
6832 if (feature)
6834 tdesc_numbered_register (feature, tdesc_data,
6835 S390_ORIG_R2_REGNUM, "orig_r2");
6837 if (tdesc_numbered_register (feature, tdesc_data,
6838 S390_LAST_BREAK_REGNUM, "last_break"))
6839 tdep->have_linux_v1 = true;
6841 if (tdesc_numbered_register (feature, tdesc_data,
6842 S390_SYSTEM_CALL_REGNUM, "system_call"))
6843 tdep->have_linux_v2 = true;
6845 if (tdep->have_linux_v2 && !tdep->have_linux_v1)
6846 return false;
6849 /* Transaction diagnostic block. */
6850 feature = tdesc_find_feature (tdesc, "org.gnu.gdb.s390.tdb");
6851 if (feature)
6853 s390_validate_reg_range (feature, tdesc_data, S390_TDB_DWORD0_REGNUM,
6854 tdb_regs);
6855 tdep->have_tdb = true;
6858 /* Vector registers. */
6859 feature = tdesc_find_feature (tdesc, "org.gnu.gdb.s390.vx");
6860 if (feature)
6862 s390_validate_reg_range (feature, tdesc_data, S390_V0_LOWER_REGNUM,
6863 vxrs_low);
6864 s390_validate_reg_range (feature, tdesc_data, S390_V16_REGNUM,
6865 vxrs_high);
6866 tdep->have_vx = true;
6869 /* Guarded-storage registers. */
6870 feature = tdesc_find_feature (tdesc, "org.gnu.gdb.s390.gs");
6871 if (feature)
6873 s390_validate_reg_range (feature, tdesc_data, S390_GSD_REGNUM, gs_cb);
6874 tdep->have_gs = true;
6877 /* Guarded-storage broadcast control. */
6878 feature = tdesc_find_feature (tdesc, "org.gnu.gdb.s390.gsbc");
6879 if (feature)
6881 if (!tdep->have_gs)
6882 return false;
6883 s390_validate_reg_range (feature, tdesc_data, S390_BC_GSD_REGNUM,
6884 gs_bc);
6887 return true;
6890 /* Allocate and initialize new gdbarch_tdep. Caller is responsible to free
6891 memory after use. */
6893 static struct gdbarch_tdep *
6894 s390_gdbarch_tdep_alloc ()
6896 struct gdbarch_tdep *tdep = XCNEW (struct gdbarch_tdep);
6898 tdep->tdesc = NULL;
6900 tdep->abi = ABI_NONE;
6901 tdep->vector_abi = S390_VECTOR_ABI_NONE;
6903 tdep->gpr_full_regnum = -1;
6904 tdep->v0_full_regnum = -1;
6905 tdep->pc_regnum = -1;
6906 tdep->cc_regnum = -1;
6908 tdep->have_upper = false;
6909 tdep->have_linux_v1 = false;
6910 tdep->have_linux_v2 = false;
6911 tdep->have_tdb = false;
6912 tdep->have_vx = false;
6913 tdep->have_gs = false;
6915 tdep->s390_syscall_record = NULL;
6917 return tdep;
6920 /* Set up gdbarch struct. */
6922 static struct gdbarch *
6923 s390_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
6925 const struct target_desc *tdesc = info.target_desc;
6926 int first_pseudo_reg, last_pseudo_reg;
6927 static const char *const stap_register_prefixes[] = { "%", NULL };
6928 static const char *const stap_register_indirection_prefixes[] = { "(",
6929 NULL };
6930 static const char *const stap_register_indirection_suffixes[] = { ")",
6931 NULL };
6933 struct gdbarch_tdep *tdep = s390_gdbarch_tdep_alloc ();
6934 struct gdbarch *gdbarch = gdbarch_alloc (&info, tdep);
6935 struct tdesc_arch_data *tdesc_data = tdesc_data_alloc ();
6936 info.tdesc_data = tdesc_data;
6938 set_gdbarch_believe_pcc_promotion (gdbarch, 0);
6939 set_gdbarch_char_signed (gdbarch, 0);
6941 /* S/390 GNU/Linux uses either 64-bit or 128-bit long doubles.
6942 We can safely let them default to 128-bit, since the debug info
6943 will give the size of type actually used in each case. */
6944 set_gdbarch_long_double_bit (gdbarch, 128);
6945 set_gdbarch_long_double_format (gdbarch, floatformats_ia64_quad);
6947 /* Breakpoints. */
6948 /* Amount PC must be decremented by after a breakpoint. This is
6949 often the number of bytes returned by gdbarch_breakpoint_from_pc but not
6950 always. */
6951 set_gdbarch_decr_pc_after_break (gdbarch, 2);
6952 set_gdbarch_breakpoint_kind_from_pc (gdbarch, s390_breakpoint::kind_from_pc);
6953 set_gdbarch_sw_breakpoint_from_kind (gdbarch, s390_breakpoint::bp_from_kind);
6955 /* Displaced stepping. */
6956 set_gdbarch_displaced_step_copy_insn (gdbarch,
6957 s390_displaced_step_copy_insn);
6958 set_gdbarch_displaced_step_fixup (gdbarch, s390_displaced_step_fixup);
6959 set_gdbarch_displaced_step_location (gdbarch, linux_displaced_step_location);
6960 set_gdbarch_displaced_step_hw_singlestep (gdbarch, s390_displaced_step_hw_singlestep);
6961 set_gdbarch_software_single_step (gdbarch, s390_software_single_step);
6962 set_gdbarch_max_insn_length (gdbarch, S390_MAX_INSTR_SIZE);
6964 /* Prologue analysis. */
6965 set_gdbarch_skip_prologue (gdbarch, s390_skip_prologue);
6967 /* Register handling. */
6968 set_gdbarch_num_regs (gdbarch, S390_NUM_REGS);
6969 set_gdbarch_sp_regnum (gdbarch, S390_SP_REGNUM);
6970 set_gdbarch_fp0_regnum (gdbarch, S390_F0_REGNUM);
6971 set_gdbarch_guess_tracepoint_registers (gdbarch,
6972 s390_guess_tracepoint_registers);
6973 set_gdbarch_stab_reg_to_regnum (gdbarch, s390_dwarf_reg_to_regnum);
6974 set_gdbarch_dwarf2_reg_to_regnum (gdbarch, s390_dwarf_reg_to_regnum);
6975 set_gdbarch_value_from_register (gdbarch, s390_value_from_register);
6977 /* Pseudo registers. */
6978 set_gdbarch_pseudo_register_read (gdbarch, s390_pseudo_register_read);
6979 set_gdbarch_pseudo_register_write (gdbarch, s390_pseudo_register_write);
6980 set_tdesc_pseudo_register_name (gdbarch, s390_pseudo_register_name);
6981 set_tdesc_pseudo_register_type (gdbarch, s390_pseudo_register_type);
6982 set_tdesc_pseudo_register_reggroup_p (gdbarch,
6983 s390_pseudo_register_reggroup_p);
6984 set_gdbarch_ax_pseudo_register_collect (gdbarch,
6985 s390_ax_pseudo_register_collect);
6986 set_gdbarch_ax_pseudo_register_push_stack
6987 (gdbarch, s390_ax_pseudo_register_push_stack);
6988 set_gdbarch_gen_return_address (gdbarch, s390_gen_return_address);
6990 /* Inferior function calls. */
6991 set_gdbarch_push_dummy_call (gdbarch, s390_push_dummy_call);
6992 set_gdbarch_dummy_id (gdbarch, s390_dummy_id);
6993 set_gdbarch_frame_align (gdbarch, s390_frame_align);
6994 set_gdbarch_return_value (gdbarch, s390_return_value);
6996 /* Frame handling. */
6997 /* Stack grows downward. */
6998 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
6999 set_gdbarch_stack_frame_destroyed_p (gdbarch, s390_stack_frame_destroyed_p);
7000 dwarf2_frame_set_init_reg (gdbarch, s390_dwarf2_frame_init_reg);
7001 dwarf2_frame_set_adjust_regnum (gdbarch, s390_adjust_frame_regnum);
7002 dwarf2_append_unwinders (gdbarch);
7003 set_gdbarch_unwind_pc (gdbarch, s390_unwind_pc);
7004 set_gdbarch_unwind_sp (gdbarch, s390_unwind_sp);
7006 switch (info.bfd_arch_info->mach)
7008 case bfd_mach_s390_31:
7009 set_gdbarch_addr_bits_remove (gdbarch, s390_addr_bits_remove);
7010 break;
7012 case bfd_mach_s390_64:
7013 set_gdbarch_long_bit (gdbarch, 64);
7014 set_gdbarch_long_long_bit (gdbarch, 64);
7015 set_gdbarch_ptr_bit (gdbarch, 64);
7016 set_gdbarch_address_class_type_flags (gdbarch,
7017 s390_address_class_type_flags);
7018 set_gdbarch_address_class_type_flags_to_name (gdbarch,
7019 s390_address_class_type_flags_to_name);
7020 set_gdbarch_address_class_name_to_type_flags (gdbarch,
7021 s390_address_class_name_to_type_flags);
7022 break;
7025 /* SystemTap functions. */
7026 set_gdbarch_stap_register_prefixes (gdbarch, stap_register_prefixes);
7027 set_gdbarch_stap_register_indirection_prefixes (gdbarch,
7028 stap_register_indirection_prefixes);
7029 set_gdbarch_stap_register_indirection_suffixes (gdbarch,
7030 stap_register_indirection_suffixes);
7032 set_gdbarch_disassembler_options (gdbarch, &s390_disassembler_options);
7033 set_gdbarch_valid_disassembler_options (gdbarch,
7034 disassembler_options_s390 ());
7036 /* Process record-replay */
7037 set_gdbarch_process_record (gdbarch, s390_process_record);
7039 /* Miscellaneous. */
7040 set_gdbarch_stap_is_single_operand (gdbarch, s390_stap_is_single_operand);
7041 set_gdbarch_gcc_target_options (gdbarch, s390_gcc_target_options);
7042 set_gdbarch_gnu_triplet_regexp (gdbarch, s390_gnu_triplet_regexp);
7044 /* Initialize the OSABI. */
7045 gdbarch_init_osabi (info, gdbarch);
7047 /* Always create a default tdesc. Otherwise commands like 'set osabi'
7048 cause GDB to crash with an internal error when the user tries to set
7049 an unsupported OSABI. */
7050 if (!tdesc_has_registers (tdesc))
7052 if (info.bfd_arch_info->mach == bfd_mach_s390_31)
7053 tdesc = tdesc_s390_linux32;
7054 else
7055 tdesc = tdesc_s390x_linux64;
7057 tdep->tdesc = tdesc;
7059 /* Check any target description for validity. */
7060 if (!s390_tdesc_valid (tdep, tdesc_data))
7062 tdesc_data_cleanup (tdesc_data);
7063 xfree (tdep);
7064 gdbarch_free (gdbarch);
7065 return NULL;
7068 /* Determine vector ABI. */
7069 #ifdef HAVE_ELF
7070 if (tdep->have_vx
7071 && info.abfd != NULL
7072 && info.abfd->format == bfd_object
7073 && bfd_get_flavour (info.abfd) == bfd_target_elf_flavour
7074 && bfd_elf_get_obj_attr_int (info.abfd, OBJ_ATTR_GNU,
7075 Tag_GNU_S390_ABI_Vector) == 2)
7076 tdep->vector_abi = S390_VECTOR_ABI_128;
7077 #endif
7079 /* Find a candidate among extant architectures. */
7080 for (arches = gdbarch_list_lookup_by_info (arches, &info);
7081 arches != NULL;
7082 arches = gdbarch_list_lookup_by_info (arches->next, &info))
7084 struct gdbarch_tdep *tmp = gdbarch_tdep (arches->gdbarch);
7085 if (!tmp)
7086 continue;
7087 /* A program can 'choose' not to use the vector registers when they
7088 are present. Leading to the same tdesc but different tdep and
7089 thereby a different gdbarch. */
7090 if (tmp->vector_abi != tdep->vector_abi)
7091 continue;
7093 tdesc_data_cleanup (tdesc_data);
7094 xfree (tdep);
7095 gdbarch_free (gdbarch);
7096 return arches->gdbarch;
7099 tdesc_use_registers (gdbarch, tdep->tdesc, tdesc_data);
7100 set_gdbarch_register_name (gdbarch, s390_register_name);
7102 /* Assign pseudo register numbers. */
7103 first_pseudo_reg = gdbarch_num_regs (gdbarch);
7104 last_pseudo_reg = first_pseudo_reg;
7105 if (tdep->have_upper)
7107 tdep->gpr_full_regnum = last_pseudo_reg;
7108 last_pseudo_reg += 16;
7110 if (tdep->have_vx)
7112 tdep->v0_full_regnum = last_pseudo_reg;
7113 last_pseudo_reg += 16;
7115 tdep->pc_regnum = last_pseudo_reg++;
7116 tdep->cc_regnum = last_pseudo_reg++;
7117 set_gdbarch_pc_regnum (gdbarch, tdep->pc_regnum);
7118 set_gdbarch_num_pseudo_regs (gdbarch, last_pseudo_reg - first_pseudo_reg);
7120 /* Frame handling. */
7121 frame_base_append_sniffer (gdbarch, dwarf2_frame_base_sniffer);
7122 frame_unwind_append_unwinder (gdbarch, &s390_stub_frame_unwind);
7123 frame_unwind_append_unwinder (gdbarch, &s390_frame_unwind);
7124 frame_base_set_default (gdbarch, &s390_frame_base);
7126 return gdbarch;
7129 void
7130 _initialize_s390_tdep (void)
7132 /* Hook us into the gdbarch mechanism. */
7133 register_gdbarch_init (bfd_arch_s390, s390_gdbarch_init);
7135 initialize_tdesc_s390_linux32 ();
7136 initialize_tdesc_s390x_linux64 ();