1 /* Target-dependent code for GDB, the GNU debugger.
3 Copyright (C) 2001-2016 Free Software Foundation, Inc.
5 Contributed by D.J. Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
6 for IBM Deutschland Entwicklung GmbH, IBM Corporation.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "arch-utils.h"
33 #include "floatformat.h"
35 #include "trad-frame.h"
36 #include "frame-base.h"
37 #include "frame-unwind.h"
38 #include "dwarf2-frame.h"
39 #include "reggroups.h"
43 #include "solib-svr4.h"
44 #include "prologue-value.h"
45 #include "linux-tdep.h"
46 #include "s390-linux-tdep.h"
47 #include "linux-record.h"
48 #include "record-full.h"
50 #include "xml-syscall.h"
52 #include "stap-probe.h"
55 #include "user-regs.h"
56 #include "cli/cli-utils.h"
58 #include "elf/common.h"
62 #include "features/s390-linux32.c"
63 #include "features/s390-linux32v1.c"
64 #include "features/s390-linux32v2.c"
65 #include "features/s390-linux64.c"
66 #include "features/s390-linux64v1.c"
67 #include "features/s390-linux64v2.c"
68 #include "features/s390-te-linux64.c"
69 #include "features/s390-vx-linux64.c"
70 #include "features/s390-tevx-linux64.c"
71 #include "features/s390x-linux64.c"
72 #include "features/s390x-linux64v1.c"
73 #include "features/s390x-linux64v2.c"
74 #include "features/s390x-te-linux64.c"
75 #include "features/s390x-vx-linux64.c"
76 #include "features/s390x-tevx-linux64.c"
78 #define XML_SYSCALL_FILENAME_S390 "syscalls/s390-linux.xml"
79 #define XML_SYSCALL_FILENAME_S390X "syscalls/s390x-linux.xml"
87 enum s390_vector_abi_kind
93 /* The tdep structure. */
98 enum s390_abi_kind abi
;
101 enum s390_vector_abi_kind vector_abi
;
103 /* Pseudo register numbers. */
115 /* ABI call-saved register information. */
118 s390_register_call_saved (struct gdbarch
*gdbarch
, int regnum
)
120 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
125 if ((regnum
>= S390_R6_REGNUM
&& regnum
<= S390_R15_REGNUM
)
126 || regnum
== S390_F4_REGNUM
|| regnum
== S390_F6_REGNUM
127 || regnum
== S390_A0_REGNUM
)
132 case ABI_LINUX_ZSERIES
:
133 if ((regnum
>= S390_R6_REGNUM
&& regnum
<= S390_R15_REGNUM
)
134 || (regnum
>= S390_F8_REGNUM
&& regnum
<= S390_F15_REGNUM
)
135 || (regnum
>= S390_A0_REGNUM
&& regnum
<= S390_A1_REGNUM
))
145 s390_cannot_store_register (struct gdbarch
*gdbarch
, int regnum
)
147 /* The last-break address is read-only. */
148 return regnum
== S390_LAST_BREAK_REGNUM
;
152 s390_write_pc (struct regcache
*regcache
, CORE_ADDR pc
)
154 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
155 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
157 regcache_cooked_write_unsigned (regcache
, tdep
->pc_regnum
, pc
);
159 /* Set special SYSTEM_CALL register to 0 to prevent the kernel from
160 messing with the PC we just installed, if we happen to be within
161 an interrupted system call that the kernel wants to restart.
163 Note that after we return from the dummy call, the SYSTEM_CALL and
164 ORIG_R2 registers will be automatically restored, and the kernel
165 continues to restart the system call at this point. */
166 if (register_size (gdbarch
, S390_SYSTEM_CALL_REGNUM
) > 0)
167 regcache_cooked_write_unsigned (regcache
, S390_SYSTEM_CALL_REGNUM
, 0);
170 /* The "guess_tracepoint_registers" gdbarch method. */
173 s390_guess_tracepoint_registers (struct gdbarch
*gdbarch
,
174 struct regcache
*regcache
,
177 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
178 int sz
= register_size (gdbarch
, S390_PSWA_REGNUM
);
179 gdb_byte
*reg
= (gdb_byte
*) alloca (sz
);
182 /* Set PSWA from the location and a default PSWM (the only part we're
183 unlikely to get right is the CC). */
184 if (tdep
->abi
== ABI_LINUX_S390
)
186 /* 31-bit PSWA needs high bit set (it's very unlikely the target
187 was in 24-bit mode). */
188 pswa
= addr
| 0x80000000UL
;
194 pswm
= 0x0705000180000000ULL
;
197 store_unsigned_integer (reg
, sz
, gdbarch_byte_order (gdbarch
), pswa
);
198 regcache_raw_supply (regcache
, S390_PSWA_REGNUM
, reg
);
200 store_unsigned_integer (reg
, sz
, gdbarch_byte_order (gdbarch
), pswm
);
201 regcache_raw_supply (regcache
, S390_PSWM_REGNUM
, reg
);
205 /* DWARF Register Mapping. */
207 static const short s390_dwarf_regmap
[] =
209 /* 0-15: General Purpose Registers. */
210 S390_R0_REGNUM
, S390_R1_REGNUM
, S390_R2_REGNUM
, S390_R3_REGNUM
,
211 S390_R4_REGNUM
, S390_R5_REGNUM
, S390_R6_REGNUM
, S390_R7_REGNUM
,
212 S390_R8_REGNUM
, S390_R9_REGNUM
, S390_R10_REGNUM
, S390_R11_REGNUM
,
213 S390_R12_REGNUM
, S390_R13_REGNUM
, S390_R14_REGNUM
, S390_R15_REGNUM
,
215 /* 16-31: Floating Point Registers / Vector Registers 0-15. */
216 S390_F0_REGNUM
, S390_F2_REGNUM
, S390_F4_REGNUM
, S390_F6_REGNUM
,
217 S390_F1_REGNUM
, S390_F3_REGNUM
, S390_F5_REGNUM
, S390_F7_REGNUM
,
218 S390_F8_REGNUM
, S390_F10_REGNUM
, S390_F12_REGNUM
, S390_F14_REGNUM
,
219 S390_F9_REGNUM
, S390_F11_REGNUM
, S390_F13_REGNUM
, S390_F15_REGNUM
,
221 /* 32-47: Control Registers (not mapped). */
222 -1, -1, -1, -1, -1, -1, -1, -1,
223 -1, -1, -1, -1, -1, -1, -1, -1,
225 /* 48-63: Access Registers. */
226 S390_A0_REGNUM
, S390_A1_REGNUM
, S390_A2_REGNUM
, S390_A3_REGNUM
,
227 S390_A4_REGNUM
, S390_A5_REGNUM
, S390_A6_REGNUM
, S390_A7_REGNUM
,
228 S390_A8_REGNUM
, S390_A9_REGNUM
, S390_A10_REGNUM
, S390_A11_REGNUM
,
229 S390_A12_REGNUM
, S390_A13_REGNUM
, S390_A14_REGNUM
, S390_A15_REGNUM
,
231 /* 64-65: Program Status Word. */
235 /* 66-67: Reserved. */
238 /* 68-83: Vector Registers 16-31. */
239 S390_V16_REGNUM
, S390_V18_REGNUM
, S390_V20_REGNUM
, S390_V22_REGNUM
,
240 S390_V17_REGNUM
, S390_V19_REGNUM
, S390_V21_REGNUM
, S390_V23_REGNUM
,
241 S390_V24_REGNUM
, S390_V26_REGNUM
, S390_V28_REGNUM
, S390_V30_REGNUM
,
242 S390_V25_REGNUM
, S390_V27_REGNUM
, S390_V29_REGNUM
, S390_V31_REGNUM
,
244 /* End of "official" DWARF registers. The remainder of the map is
245 for GDB internal use only. */
247 /* GPR Lower Half Access. */
248 S390_R0_REGNUM
, S390_R1_REGNUM
, S390_R2_REGNUM
, S390_R3_REGNUM
,
249 S390_R4_REGNUM
, S390_R5_REGNUM
, S390_R6_REGNUM
, S390_R7_REGNUM
,
250 S390_R8_REGNUM
, S390_R9_REGNUM
, S390_R10_REGNUM
, S390_R11_REGNUM
,
251 S390_R12_REGNUM
, S390_R13_REGNUM
, S390_R14_REGNUM
, S390_R15_REGNUM
,
254 enum { s390_dwarf_reg_r0l
= ARRAY_SIZE (s390_dwarf_regmap
) - 16 };
256 /* Convert DWARF register number REG to the appropriate register
257 number used by GDB. */
259 s390_dwarf_reg_to_regnum (struct gdbarch
*gdbarch
, int reg
)
261 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
264 /* In a 32-on-64 debug scenario, debug info refers to the full
265 64-bit GPRs. Note that call frame information still refers to
266 the 32-bit lower halves, because s390_adjust_frame_regnum uses
267 special register numbers to access GPRs. */
268 if (tdep
->gpr_full_regnum
!= -1 && reg
>= 0 && reg
< 16)
269 return tdep
->gpr_full_regnum
+ reg
;
271 if (reg
>= 0 && reg
< ARRAY_SIZE (s390_dwarf_regmap
))
272 gdb_reg
= s390_dwarf_regmap
[reg
];
274 if (tdep
->v0_full_regnum
== -1)
276 if (gdb_reg
>= S390_V16_REGNUM
&& gdb_reg
<= S390_V31_REGNUM
)
281 if (gdb_reg
>= S390_F0_REGNUM
&& gdb_reg
<= S390_F15_REGNUM
)
282 gdb_reg
= gdb_reg
- S390_F0_REGNUM
+ tdep
->v0_full_regnum
;
288 /* Translate a .eh_frame register to DWARF register, or adjust a
289 .debug_frame register. */
291 s390_adjust_frame_regnum (struct gdbarch
*gdbarch
, int num
, int eh_frame_p
)
293 /* See s390_dwarf_reg_to_regnum for comments. */
294 return (num
>= 0 && num
< 16) ? num
+ s390_dwarf_reg_r0l
: num
;
298 /* Pseudo registers. */
301 regnum_is_gpr_full (struct gdbarch_tdep
*tdep
, int regnum
)
303 return (tdep
->gpr_full_regnum
!= -1
304 && regnum
>= tdep
->gpr_full_regnum
305 && regnum
<= tdep
->gpr_full_regnum
+ 15);
308 /* Check whether REGNUM indicates a full vector register (v0-v15).
309 These pseudo-registers are composed of f0-f15 and v0l-v15l. */
312 regnum_is_vxr_full (struct gdbarch_tdep
*tdep
, int regnum
)
314 return (tdep
->v0_full_regnum
!= -1
315 && regnum
>= tdep
->v0_full_regnum
316 && regnum
<= tdep
->v0_full_regnum
+ 15);
319 /* Return the name of register REGNO. Return the empty string for
320 registers that shouldn't be visible. */
323 s390_register_name (struct gdbarch
*gdbarch
, int regnum
)
325 if (regnum
>= S390_V0_LOWER_REGNUM
326 && regnum
<= S390_V15_LOWER_REGNUM
)
328 return tdesc_register_name (gdbarch
, regnum
);
332 s390_pseudo_register_name (struct gdbarch
*gdbarch
, int regnum
)
334 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
336 if (regnum
== tdep
->pc_regnum
)
339 if (regnum
== tdep
->cc_regnum
)
342 if (regnum_is_gpr_full (tdep
, regnum
))
344 static const char *full_name
[] = {
345 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
346 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
348 return full_name
[regnum
- tdep
->gpr_full_regnum
];
351 if (regnum_is_vxr_full (tdep
, regnum
))
353 static const char *full_name
[] = {
354 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
355 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15"
357 return full_name
[regnum
- tdep
->v0_full_regnum
];
360 internal_error (__FILE__
, __LINE__
, _("invalid regnum"));
364 s390_pseudo_register_type (struct gdbarch
*gdbarch
, int regnum
)
366 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
368 if (regnum
== tdep
->pc_regnum
)
369 return builtin_type (gdbarch
)->builtin_func_ptr
;
371 if (regnum
== tdep
->cc_regnum
)
372 return builtin_type (gdbarch
)->builtin_int
;
374 if (regnum_is_gpr_full (tdep
, regnum
))
375 return builtin_type (gdbarch
)->builtin_uint64
;
377 if (regnum_is_vxr_full (tdep
, regnum
))
378 return tdesc_find_type (gdbarch
, "vec128");
380 internal_error (__FILE__
, __LINE__
, _("invalid regnum"));
383 static enum register_status
384 s390_pseudo_register_read (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
385 int regnum
, gdb_byte
*buf
)
387 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
388 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
389 int regsize
= register_size (gdbarch
, regnum
);
392 if (regnum
== tdep
->pc_regnum
)
394 enum register_status status
;
396 status
= regcache_raw_read_unsigned (regcache
, S390_PSWA_REGNUM
, &val
);
397 if (status
== REG_VALID
)
399 if (register_size (gdbarch
, S390_PSWA_REGNUM
) == 4)
401 store_unsigned_integer (buf
, regsize
, byte_order
, val
);
406 if (regnum
== tdep
->cc_regnum
)
408 enum register_status status
;
410 status
= regcache_raw_read_unsigned (regcache
, S390_PSWM_REGNUM
, &val
);
411 if (status
== REG_VALID
)
413 if (register_size (gdbarch
, S390_PSWA_REGNUM
) == 4)
414 val
= (val
>> 12) & 3;
416 val
= (val
>> 44) & 3;
417 store_unsigned_integer (buf
, regsize
, byte_order
, val
);
422 if (regnum_is_gpr_full (tdep
, regnum
))
424 enum register_status status
;
427 regnum
-= tdep
->gpr_full_regnum
;
429 status
= regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ regnum
, &val
);
430 if (status
== REG_VALID
)
431 status
= regcache_raw_read_unsigned (regcache
, S390_R0_UPPER_REGNUM
+ regnum
,
433 if (status
== REG_VALID
)
435 val
|= val_upper
<< 32;
436 store_unsigned_integer (buf
, regsize
, byte_order
, val
);
441 if (regnum_is_vxr_full (tdep
, regnum
))
443 enum register_status status
;
445 regnum
-= tdep
->v0_full_regnum
;
447 status
= regcache_raw_read (regcache
, S390_F0_REGNUM
+ regnum
, buf
);
448 if (status
== REG_VALID
)
449 status
= regcache_raw_read (regcache
,
450 S390_V0_LOWER_REGNUM
+ regnum
, buf
+ 8);
454 internal_error (__FILE__
, __LINE__
, _("invalid regnum"));
458 s390_pseudo_register_write (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
459 int regnum
, const gdb_byte
*buf
)
461 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
462 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
463 int regsize
= register_size (gdbarch
, regnum
);
466 if (regnum
== tdep
->pc_regnum
)
468 val
= extract_unsigned_integer (buf
, regsize
, byte_order
);
469 if (register_size (gdbarch
, S390_PSWA_REGNUM
) == 4)
471 regcache_raw_read_unsigned (regcache
, S390_PSWA_REGNUM
, &psw
);
472 val
= (psw
& 0x80000000) | (val
& 0x7fffffff);
474 regcache_raw_write_unsigned (regcache
, S390_PSWA_REGNUM
, val
);
478 if (regnum
== tdep
->cc_regnum
)
480 val
= extract_unsigned_integer (buf
, regsize
, byte_order
);
481 regcache_raw_read_unsigned (regcache
, S390_PSWM_REGNUM
, &psw
);
482 if (register_size (gdbarch
, S390_PSWA_REGNUM
) == 4)
483 val
= (psw
& ~((ULONGEST
)3 << 12)) | ((val
& 3) << 12);
485 val
= (psw
& ~((ULONGEST
)3 << 44)) | ((val
& 3) << 44);
486 regcache_raw_write_unsigned (regcache
, S390_PSWM_REGNUM
, val
);
490 if (regnum_is_gpr_full (tdep
, regnum
))
492 regnum
-= tdep
->gpr_full_regnum
;
493 val
= extract_unsigned_integer (buf
, regsize
, byte_order
);
494 regcache_raw_write_unsigned (regcache
, S390_R0_REGNUM
+ regnum
,
496 regcache_raw_write_unsigned (regcache
, S390_R0_UPPER_REGNUM
+ regnum
,
501 if (regnum_is_vxr_full (tdep
, regnum
))
503 regnum
-= tdep
->v0_full_regnum
;
504 regcache_raw_write (regcache
, S390_F0_REGNUM
+ regnum
, buf
);
505 regcache_raw_write (regcache
, S390_V0_LOWER_REGNUM
+ regnum
, buf
+ 8);
509 internal_error (__FILE__
, __LINE__
, _("invalid regnum"));
512 /* 'float' values are stored in the upper half of floating-point
513 registers, even though we are otherwise a big-endian platform. The
514 same applies to a 'float' value within a vector. */
516 static struct value
*
517 s390_value_from_register (struct gdbarch
*gdbarch
, struct type
*type
,
518 int regnum
, struct frame_id frame_id
)
520 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
521 struct value
*value
= default_value_from_register (gdbarch
, type
,
523 check_typedef (type
);
525 if ((regnum
>= S390_F0_REGNUM
&& regnum
<= S390_F15_REGNUM
526 && TYPE_LENGTH (type
) < 8)
527 || regnum_is_vxr_full (tdep
, regnum
)
528 || (regnum
>= S390_V16_REGNUM
&& regnum
<= S390_V31_REGNUM
))
529 set_value_offset (value
, 0);
534 /* Register groups. */
537 s390_pseudo_register_reggroup_p (struct gdbarch
*gdbarch
, int regnum
,
538 struct reggroup
*group
)
540 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
542 /* We usually save/restore the whole PSW, which includes PC and CC.
543 However, some older gdbservers may not support saving/restoring
544 the whole PSW yet, and will return an XML register description
545 excluding those from the save/restore register groups. In those
546 cases, we still need to explicitly save/restore PC and CC in order
547 to push or pop frames. Since this doesn't hurt anything if we
548 already save/restore the whole PSW (it's just redundant), we add
549 PC and CC at this point unconditionally. */
550 if (group
== save_reggroup
|| group
== restore_reggroup
)
551 return regnum
== tdep
->pc_regnum
|| regnum
== tdep
->cc_regnum
;
553 if (group
== vector_reggroup
)
554 return regnum_is_vxr_full (tdep
, regnum
);
556 if (group
== general_reggroup
&& regnum_is_vxr_full (tdep
, regnum
))
559 return default_register_reggroup_p (gdbarch
, regnum
, group
);
563 /* A helper for s390_software_single_step, decides if an instruction
564 is a partial-execution instruction that needs to be executed until
565 completion when in record mode. If it is, returns 1 and writes
566 instruction length to a pointer. */
569 s390_is_partial_instruction (struct gdbarch
*gdbarch
, CORE_ADDR loc
, int *len
)
571 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
574 insn
= read_memory_integer (loc
, 2, byte_order
);
578 case 0xa8: /* MVCLE */
584 insn
= read_memory_integer (loc
+ 4, 2, byte_order
);
585 if ((insn
& 0xff) == 0x8e)
597 case 0xb255: /* MVST */
598 case 0xb263: /* CMPSC */
599 case 0xb2a5: /* TRE */
600 case 0xb2a6: /* CU21 */
601 case 0xb2a7: /* CU12 */
602 case 0xb9b0: /* CU14 */
603 case 0xb9b1: /* CU24 */
604 case 0xb9b2: /* CU41 */
605 case 0xb9b3: /* CU42 */
606 case 0xb92a: /* KMF */
607 case 0xb92b: /* KMO */
608 case 0xb92f: /* KMC */
609 case 0xb92d: /* KMCTR */
610 case 0xb92e: /* KM */
611 case 0xb93c: /* PPNO */
612 case 0xb990: /* TRTT */
613 case 0xb991: /* TRTO */
614 case 0xb992: /* TROT */
615 case 0xb993: /* TROO */
623 /* Implement the "software_single_step" gdbarch method, needed to single step
624 through instructions like MVCLE in record mode, to make sure they are
625 executed to completion. Without that, record will save the full length
626 of destination buffer on every iteration, even though the CPU will only
627 process about 4kiB of it each time, leading to O(n**2) memory and time
631 s390_software_single_step (struct frame_info
*frame
)
633 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
634 struct address_space
*aspace
= get_frame_address_space (frame
);
635 CORE_ADDR loc
= get_frame_pc (frame
);
636 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
640 /* Special handling only if recording. */
641 if (!record_full_is_used ())
644 /* First, match a partial instruction. */
645 if (!s390_is_partial_instruction (gdbarch
, loc
, &len
))
650 /* Second, look for a branch back to it. */
651 insn
= read_memory_integer (loc
, 2, byte_order
);
652 if (insn
!= 0xa714) /* BRC with mask 1 */
655 insn
= read_memory_integer (loc
+ 2, 2, byte_order
);
656 if (insn
!= (uint16_t) -(len
/ 2))
661 /* Found it, step past the whole thing. */
663 insert_single_step_breakpoint (gdbarch
, aspace
, loc
);
669 s390_displaced_step_hw_singlestep (struct gdbarch
*gdbarch
,
670 struct displaced_step_closure
*closure
)
676 /* Maps for register sets. */
678 static const struct regcache_map_entry s390_gregmap
[] =
680 { 1, S390_PSWM_REGNUM
},
681 { 1, S390_PSWA_REGNUM
},
682 { 16, S390_R0_REGNUM
},
683 { 16, S390_A0_REGNUM
},
684 { 1, S390_ORIG_R2_REGNUM
},
688 static const struct regcache_map_entry s390_fpregmap
[] =
690 { 1, S390_FPC_REGNUM
, 8 },
691 { 16, S390_F0_REGNUM
, 8 },
695 static const struct regcache_map_entry s390_regmap_upper
[] =
697 { 16, S390_R0_UPPER_REGNUM
, 4 },
701 static const struct regcache_map_entry s390_regmap_last_break
[] =
703 { 1, REGCACHE_MAP_SKIP
, 4 },
704 { 1, S390_LAST_BREAK_REGNUM
, 4 },
708 static const struct regcache_map_entry s390x_regmap_last_break
[] =
710 { 1, S390_LAST_BREAK_REGNUM
, 8 },
714 static const struct regcache_map_entry s390_regmap_system_call
[] =
716 { 1, S390_SYSTEM_CALL_REGNUM
, 4 },
720 static const struct regcache_map_entry s390_regmap_tdb
[] =
722 { 1, S390_TDB_DWORD0_REGNUM
, 8 },
723 { 1, S390_TDB_ABORT_CODE_REGNUM
, 8 },
724 { 1, S390_TDB_CONFLICT_TOKEN_REGNUM
, 8 },
725 { 1, S390_TDB_ATIA_REGNUM
, 8 },
726 { 12, REGCACHE_MAP_SKIP
, 8 },
727 { 16, S390_TDB_R0_REGNUM
, 8 },
731 static const struct regcache_map_entry s390_regmap_vxrs_low
[] =
733 { 16, S390_V0_LOWER_REGNUM
, 8 },
737 static const struct regcache_map_entry s390_regmap_vxrs_high
[] =
739 { 16, S390_V16_REGNUM
, 16 },
744 /* Supply the TDB regset. Like regcache_supply_regset, but invalidate
745 the TDB registers unless the TDB format field is valid. */
748 s390_supply_tdb_regset (const struct regset
*regset
, struct regcache
*regcache
,
749 int regnum
, const void *regs
, size_t len
)
752 enum register_status ret
;
755 regcache_supply_regset (regset
, regcache
, regnum
, regs
, len
);
756 ret
= regcache_cooked_read_unsigned (regcache
, S390_TDB_DWORD0_REGNUM
, &tdw
);
757 if (ret
!= REG_VALID
|| (tdw
>> 56) != 1)
758 regcache_supply_regset (regset
, regcache
, regnum
, NULL
, len
);
761 const struct regset s390_gregset
= {
763 regcache_supply_regset
,
764 regcache_collect_regset
767 const struct regset s390_fpregset
= {
769 regcache_supply_regset
,
770 regcache_collect_regset
773 static const struct regset s390_upper_regset
= {
775 regcache_supply_regset
,
776 regcache_collect_regset
779 const struct regset s390_last_break_regset
= {
780 s390_regmap_last_break
,
781 regcache_supply_regset
,
782 regcache_collect_regset
785 const struct regset s390x_last_break_regset
= {
786 s390x_regmap_last_break
,
787 regcache_supply_regset
,
788 regcache_collect_regset
791 const struct regset s390_system_call_regset
= {
792 s390_regmap_system_call
,
793 regcache_supply_regset
,
794 regcache_collect_regset
797 const struct regset s390_tdb_regset
= {
799 s390_supply_tdb_regset
,
800 regcache_collect_regset
803 const struct regset s390_vxrs_low_regset
= {
804 s390_regmap_vxrs_low
,
805 regcache_supply_regset
,
806 regcache_collect_regset
809 const struct regset s390_vxrs_high_regset
= {
810 s390_regmap_vxrs_high
,
811 regcache_supply_regset
,
812 regcache_collect_regset
815 /* Iterate over supported core file register note sections. */
818 s390_iterate_over_regset_sections (struct gdbarch
*gdbarch
,
819 iterate_over_regset_sections_cb
*cb
,
821 const struct regcache
*regcache
)
823 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
824 const int gregset_size
= (tdep
->abi
== ABI_LINUX_S390
?
825 s390_sizeof_gregset
: s390x_sizeof_gregset
);
827 cb (".reg", gregset_size
, &s390_gregset
, NULL
, cb_data
);
828 cb (".reg2", s390_sizeof_fpregset
, &s390_fpregset
, NULL
, cb_data
);
830 if (tdep
->abi
== ABI_LINUX_S390
&& tdep
->gpr_full_regnum
!= -1)
831 cb (".reg-s390-high-gprs", 16 * 4, &s390_upper_regset
,
832 "s390 GPR upper halves", cb_data
);
834 if (tdep
->have_linux_v1
)
835 cb (".reg-s390-last-break", 8,
836 (gdbarch_ptr_bit (gdbarch
) == 32
837 ? &s390_last_break_regset
: &s390x_last_break_regset
),
838 "s930 last-break address", cb_data
);
840 if (tdep
->have_linux_v2
)
841 cb (".reg-s390-system-call", 4, &s390_system_call_regset
,
842 "s390 system-call", cb_data
);
844 /* If regcache is set, we are in "write" (gcore) mode. In this
845 case, don't iterate over the TDB unless its registers are
849 || REG_VALID
== regcache_register_status (regcache
,
850 S390_TDB_DWORD0_REGNUM
)))
851 cb (".reg-s390-tdb", s390_sizeof_tdbregset
, &s390_tdb_regset
,
852 "s390 TDB", cb_data
);
854 if (tdep
->v0_full_regnum
!= -1)
856 cb (".reg-s390-vxrs-low", 16 * 8, &s390_vxrs_low_regset
,
857 "s390 vector registers 0-15 lower half", cb_data
);
858 cb (".reg-s390-vxrs-high", 16 * 16, &s390_vxrs_high_regset
,
859 "s390 vector registers 16-31", cb_data
);
863 static const struct target_desc
*
864 s390_core_read_description (struct gdbarch
*gdbarch
,
865 struct target_ops
*target
, bfd
*abfd
)
867 asection
*section
= bfd_get_section_by_name (abfd
, ".reg");
869 int high_gprs
, v1
, v2
, te
, vx
;
871 target_auxv_search (target
, AT_HWCAP
, &hwcap
);
875 high_gprs
= (bfd_get_section_by_name (abfd
, ".reg-s390-high-gprs")
877 v1
= (bfd_get_section_by_name (abfd
, ".reg-s390-last-break") != NULL
);
878 v2
= (bfd_get_section_by_name (abfd
, ".reg-s390-system-call") != NULL
);
879 vx
= (hwcap
& HWCAP_S390_VX
);
880 te
= (hwcap
& HWCAP_S390_TE
);
882 switch (bfd_section_size (abfd
, section
))
884 case s390_sizeof_gregset
:
886 return (te
&& vx
? tdesc_s390_tevx_linux64
:
887 vx
? tdesc_s390_vx_linux64
:
888 te
? tdesc_s390_te_linux64
:
889 v2
? tdesc_s390_linux64v2
:
890 v1
? tdesc_s390_linux64v1
: tdesc_s390_linux64
);
892 return (v2
? tdesc_s390_linux32v2
:
893 v1
? tdesc_s390_linux32v1
: tdesc_s390_linux32
);
895 case s390x_sizeof_gregset
:
896 return (te
&& vx
? tdesc_s390x_tevx_linux64
:
897 vx
? tdesc_s390x_vx_linux64
:
898 te
? tdesc_s390x_te_linux64
:
899 v2
? tdesc_s390x_linux64v2
:
900 v1
? tdesc_s390x_linux64v1
: tdesc_s390x_linux64
);
908 /* Decoding S/390 instructions. */
910 /* Named opcode values for the S/390 instructions we recognize. Some
911 instructions have their opcode split across two fields; those are the
912 op1_* and op2_* enums. */
915 op1_lhi
= 0xa7, op2_lhi
= 0x08,
916 op1_lghi
= 0xa7, op2_lghi
= 0x09,
917 op1_lgfi
= 0xc0, op2_lgfi
= 0x01,
921 op1_ly
= 0xe3, op2_ly
= 0x58,
922 op1_lg
= 0xe3, op2_lg
= 0x04,
924 op1_lmy
= 0xeb, op2_lmy
= 0x98,
925 op1_lmg
= 0xeb, op2_lmg
= 0x04,
927 op1_sty
= 0xe3, op2_sty
= 0x50,
928 op1_stg
= 0xe3, op2_stg
= 0x24,
931 op1_stmy
= 0xeb, op2_stmy
= 0x90,
932 op1_stmg
= 0xeb, op2_stmg
= 0x24,
933 op1_aghi
= 0xa7, op2_aghi
= 0x0b,
934 op1_ahi
= 0xa7, op2_ahi
= 0x0a,
935 op1_agfi
= 0xc2, op2_agfi
= 0x08,
936 op1_afi
= 0xc2, op2_afi
= 0x09,
937 op1_algfi
= 0xc2, op2_algfi
= 0x0a,
938 op1_alfi
= 0xc2, op2_alfi
= 0x0b,
942 op1_ay
= 0xe3, op2_ay
= 0x5a,
943 op1_ag
= 0xe3, op2_ag
= 0x08,
944 op1_slgfi
= 0xc2, op2_slgfi
= 0x04,
945 op1_slfi
= 0xc2, op2_slfi
= 0x05,
949 op1_sy
= 0xe3, op2_sy
= 0x5b,
950 op1_sg
= 0xe3, op2_sg
= 0x09,
954 op1_lay
= 0xe3, op2_lay
= 0x71,
955 op1_larl
= 0xc0, op2_larl
= 0x00,
963 op1_bctg
= 0xe3, op2_bctg
= 0x46,
965 op1_bxhg
= 0xeb, op2_bxhg
= 0x44,
967 op1_bxleg
= 0xeb, op2_bxleg
= 0x45,
968 op1_bras
= 0xa7, op2_bras
= 0x05,
969 op1_brasl
= 0xc0, op2_brasl
= 0x05,
970 op1_brc
= 0xa7, op2_brc
= 0x04,
971 op1_brcl
= 0xc0, op2_brcl
= 0x04,
972 op1_brct
= 0xa7, op2_brct
= 0x06,
973 op1_brctg
= 0xa7, op2_brctg
= 0x07,
975 op1_brxhg
= 0xec, op2_brxhg
= 0x44,
977 op1_brxlg
= 0xec, op2_brxlg
= 0x45,
982 /* Read a single instruction from address AT. */
984 #define S390_MAX_INSTR_SIZE 6
986 s390_readinstruction (bfd_byte instr
[], CORE_ADDR at
)
988 static int s390_instrlen
[] = { 2, 4, 4, 6 };
991 if (target_read_memory (at
, &instr
[0], 2))
993 instrlen
= s390_instrlen
[instr
[0] >> 6];
996 if (target_read_memory (at
+ 2, &instr
[2], instrlen
- 2))
1003 /* The functions below are for recognizing and decoding S/390
1004 instructions of various formats. Each of them checks whether INSN
1005 is an instruction of the given format, with the specified opcodes.
1006 If it is, it sets the remaining arguments to the values of the
1007 instruction's fields, and returns a non-zero value; otherwise, it
1010 These functions' arguments appear in the order they appear in the
1011 instruction, not in the machine-language form. So, opcodes always
1012 come first, even though they're sometimes scattered around the
1013 instructions. And displacements appear before base and extension
1014 registers, as they do in the assembly syntax, not at the end, as
1015 they do in the machine language. */
1017 is_ri (bfd_byte
*insn
, int op1
, int op2
, unsigned int *r1
, int *i2
)
1019 if (insn
[0] == op1
&& (insn
[1] & 0xf) == op2
)
1021 *r1
= (insn
[1] >> 4) & 0xf;
1022 /* i2 is a 16-bit signed quantity. */
1023 *i2
= (((insn
[2] << 8) | insn
[3]) ^ 0x8000) - 0x8000;
1032 is_ril (bfd_byte
*insn
, int op1
, int op2
,
1033 unsigned int *r1
, int *i2
)
1035 if (insn
[0] == op1
&& (insn
[1] & 0xf) == op2
)
1037 *r1
= (insn
[1] >> 4) & 0xf;
1038 /* i2 is a signed quantity. If the host 'int' is 32 bits long,
1039 no sign extension is necessary, but we don't want to assume
1041 *i2
= (((insn
[2] << 24)
1044 | (insn
[5])) ^ 0x80000000) - 0x80000000;
1053 is_rr (bfd_byte
*insn
, int op
, unsigned int *r1
, unsigned int *r2
)
1057 *r1
= (insn
[1] >> 4) & 0xf;
1058 *r2
= insn
[1] & 0xf;
1067 is_rre (bfd_byte
*insn
, int op
, unsigned int *r1
, unsigned int *r2
)
1069 if (((insn
[0] << 8) | insn
[1]) == op
)
1071 /* Yes, insn[3]. insn[2] is unused in RRE format. */
1072 *r1
= (insn
[3] >> 4) & 0xf;
1073 *r2
= insn
[3] & 0xf;
1082 is_rs (bfd_byte
*insn
, int op
,
1083 unsigned int *r1
, unsigned int *r3
, int *d2
, unsigned int *b2
)
1087 *r1
= (insn
[1] >> 4) & 0xf;
1088 *r3
= insn
[1] & 0xf;
1089 *b2
= (insn
[2] >> 4) & 0xf;
1090 *d2
= ((insn
[2] & 0xf) << 8) | insn
[3];
1099 is_rsy (bfd_byte
*insn
, int op1
, int op2
,
1100 unsigned int *r1
, unsigned int *r3
, int *d2
, unsigned int *b2
)
1105 *r1
= (insn
[1] >> 4) & 0xf;
1106 *r3
= insn
[1] & 0xf;
1107 *b2
= (insn
[2] >> 4) & 0xf;
1108 /* The 'long displacement' is a 20-bit signed integer. */
1109 *d2
= ((((insn
[2] & 0xf) << 8) | insn
[3] | (insn
[4] << 12))
1110 ^ 0x80000) - 0x80000;
1119 is_rsi (bfd_byte
*insn
, int op
,
1120 unsigned int *r1
, unsigned int *r3
, int *i2
)
1124 *r1
= (insn
[1] >> 4) & 0xf;
1125 *r3
= insn
[1] & 0xf;
1126 /* i2 is a 16-bit signed quantity. */
1127 *i2
= (((insn
[2] << 8) | insn
[3]) ^ 0x8000) - 0x8000;
1136 is_rie (bfd_byte
*insn
, int op1
, int op2
,
1137 unsigned int *r1
, unsigned int *r3
, int *i2
)
1142 *r1
= (insn
[1] >> 4) & 0xf;
1143 *r3
= insn
[1] & 0xf;
1144 /* i2 is a 16-bit signed quantity. */
1145 *i2
= (((insn
[2] << 8) | insn
[3]) ^ 0x8000) - 0x8000;
1154 is_rx (bfd_byte
*insn
, int op
,
1155 unsigned int *r1
, int *d2
, unsigned int *x2
, unsigned int *b2
)
1159 *r1
= (insn
[1] >> 4) & 0xf;
1160 *x2
= insn
[1] & 0xf;
1161 *b2
= (insn
[2] >> 4) & 0xf;
1162 *d2
= ((insn
[2] & 0xf) << 8) | insn
[3];
1171 is_rxy (bfd_byte
*insn
, int op1
, int op2
,
1172 unsigned int *r1
, int *d2
, unsigned int *x2
, unsigned int *b2
)
1177 *r1
= (insn
[1] >> 4) & 0xf;
1178 *x2
= insn
[1] & 0xf;
1179 *b2
= (insn
[2] >> 4) & 0xf;
1180 /* The 'long displacement' is a 20-bit signed integer. */
1181 *d2
= ((((insn
[2] & 0xf) << 8) | insn
[3] | (insn
[4] << 12))
1182 ^ 0x80000) - 0x80000;
1190 /* Prologue analysis. */
1192 #define S390_NUM_GPRS 16
1193 #define S390_NUM_FPRS 16
1195 struct s390_prologue_data
{
1198 struct pv_area
*stack
;
1200 /* The size and byte-order of a GPR or FPR. */
1203 enum bfd_endian byte_order
;
1205 /* The general-purpose registers. */
1206 pv_t gpr
[S390_NUM_GPRS
];
1208 /* The floating-point registers. */
1209 pv_t fpr
[S390_NUM_FPRS
];
1211 /* The offset relative to the CFA where the incoming GPR N was saved
1212 by the function prologue. 0 if not saved or unknown. */
1213 int gpr_slot
[S390_NUM_GPRS
];
1215 /* Likewise for FPRs. */
1216 int fpr_slot
[S390_NUM_FPRS
];
1218 /* Nonzero if the backchain was saved. This is assumed to be the
1219 case when the incoming SP is saved at the current SP location. */
1220 int back_chain_saved_p
;
1223 /* Return the effective address for an X-style instruction, like:
1227 Here, X2 and B2 are registers, and D2 is a signed 20-bit
1228 constant; the effective address is the sum of all three. If either
1229 X2 or B2 are zero, then it doesn't contribute to the sum --- this
1230 means that r0 can't be used as either X2 or B2. */
1232 s390_addr (struct s390_prologue_data
*data
,
1233 int d2
, unsigned int x2
, unsigned int b2
)
1237 result
= pv_constant (d2
);
1239 result
= pv_add (result
, data
->gpr
[x2
]);
1241 result
= pv_add (result
, data
->gpr
[b2
]);
1246 /* Do a SIZE-byte store of VALUE to D2(X2,B2). */
1248 s390_store (struct s390_prologue_data
*data
,
1249 int d2
, unsigned int x2
, unsigned int b2
, CORE_ADDR size
,
1252 pv_t addr
= s390_addr (data
, d2
, x2
, b2
);
1255 /* Check whether we are storing the backchain. */
1256 offset
= pv_subtract (data
->gpr
[S390_SP_REGNUM
- S390_R0_REGNUM
], addr
);
1258 if (pv_is_constant (offset
) && offset
.k
== 0)
1259 if (size
== data
->gpr_size
1260 && pv_is_register_k (value
, S390_SP_REGNUM
, 0))
1262 data
->back_chain_saved_p
= 1;
1267 /* Check whether we are storing a register into the stack. */
1268 if (!pv_area_store_would_trash (data
->stack
, addr
))
1269 pv_area_store (data
->stack
, addr
, size
, value
);
1272 /* Note: If this is some store we cannot identify, you might think we
1273 should forget our cached values, as any of those might have been hit.
1275 However, we make the assumption that the register save areas are only
1276 ever stored to once in any given function, and we do recognize these
1277 stores. Thus every store we cannot recognize does not hit our data. */
1280 /* Do a SIZE-byte load from D2(X2,B2). */
1282 s390_load (struct s390_prologue_data
*data
,
1283 int d2
, unsigned int x2
, unsigned int b2
, CORE_ADDR size
)
1286 pv_t addr
= s390_addr (data
, d2
, x2
, b2
);
1288 /* If it's a load from an in-line constant pool, then we can
1289 simulate that, under the assumption that the code isn't
1290 going to change between the time the processor actually
1291 executed it creating the current frame, and the time when
1292 we're analyzing the code to unwind past that frame. */
1293 if (pv_is_constant (addr
))
1295 struct target_section
*secp
;
1296 secp
= target_section_by_addr (¤t_target
, addr
.k
);
1298 && (bfd_get_section_flags (secp
->the_bfd_section
->owner
,
1299 secp
->the_bfd_section
)
1301 return pv_constant (read_memory_integer (addr
.k
, size
,
1305 /* Check whether we are accessing one of our save slots. */
1306 return pv_area_fetch (data
->stack
, addr
, size
);
1309 /* Function for finding saved registers in a 'struct pv_area'; we pass
1310 this to pv_area_scan.
1312 If VALUE is a saved register, ADDR says it was saved at a constant
1313 offset from the frame base, and SIZE indicates that the whole
1314 register was saved, record its offset in the reg_offset table in
1315 PROLOGUE_UNTYPED. */
1317 s390_check_for_saved (void *data_untyped
, pv_t addr
,
1318 CORE_ADDR size
, pv_t value
)
1320 struct s390_prologue_data
*data
= (struct s390_prologue_data
*) data_untyped
;
1323 if (!pv_is_register (addr
, S390_SP_REGNUM
))
1326 offset
= 16 * data
->gpr_size
+ 32 - addr
.k
;
1328 /* If we are storing the original value of a register, we want to
1329 record the CFA offset. If the same register is stored multiple
1330 times, the stack slot with the highest address counts. */
1332 for (i
= 0; i
< S390_NUM_GPRS
; i
++)
1333 if (size
== data
->gpr_size
1334 && pv_is_register_k (value
, S390_R0_REGNUM
+ i
, 0))
1335 if (data
->gpr_slot
[i
] == 0
1336 || data
->gpr_slot
[i
] > offset
)
1338 data
->gpr_slot
[i
] = offset
;
1342 for (i
= 0; i
< S390_NUM_FPRS
; i
++)
1343 if (size
== data
->fpr_size
1344 && pv_is_register_k (value
, S390_F0_REGNUM
+ i
, 0))
1345 if (data
->fpr_slot
[i
] == 0
1346 || data
->fpr_slot
[i
] > offset
)
1348 data
->fpr_slot
[i
] = offset
;
1353 /* Analyze the prologue of the function starting at START_PC,
1354 continuing at most until CURRENT_PC. Initialize DATA to
1355 hold all information we find out about the state of the registers
1356 and stack slots. Return the address of the instruction after
1357 the last one that changed the SP, FP, or back chain; or zero
1360 s390_analyze_prologue (struct gdbarch
*gdbarch
,
1362 CORE_ADDR current_pc
,
1363 struct s390_prologue_data
*data
)
1365 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
1367 /* Our return value:
1368 The address of the instruction after the last one that changed
1369 the SP, FP, or back chain; zero if we got an error trying to
1371 CORE_ADDR result
= start_pc
;
1373 /* The current PC for our abstract interpretation. */
1376 /* The address of the next instruction after that. */
1379 /* Set up everything's initial value. */
1383 data
->stack
= make_pv_area (S390_SP_REGNUM
, gdbarch_addr_bit (gdbarch
));
1385 /* For the purpose of prologue tracking, we consider the GPR size to
1386 be equal to the ABI word size, even if it is actually larger
1387 (i.e. when running a 32-bit binary under a 64-bit kernel). */
1388 data
->gpr_size
= word_size
;
1390 data
->byte_order
= gdbarch_byte_order (gdbarch
);
1392 for (i
= 0; i
< S390_NUM_GPRS
; i
++)
1393 data
->gpr
[i
] = pv_register (S390_R0_REGNUM
+ i
, 0);
1395 for (i
= 0; i
< S390_NUM_FPRS
; i
++)
1396 data
->fpr
[i
] = pv_register (S390_F0_REGNUM
+ i
, 0);
1398 for (i
= 0; i
< S390_NUM_GPRS
; i
++)
1399 data
->gpr_slot
[i
] = 0;
1401 for (i
= 0; i
< S390_NUM_FPRS
; i
++)
1402 data
->fpr_slot
[i
] = 0;
1404 data
->back_chain_saved_p
= 0;
1407 /* Start interpreting instructions, until we hit the frame's
1408 current PC or the first branch instruction. */
1409 for (pc
= start_pc
; pc
> 0 && pc
< current_pc
; pc
= next_pc
)
1411 bfd_byte insn
[S390_MAX_INSTR_SIZE
];
1412 int insn_len
= s390_readinstruction (insn
, pc
);
1414 bfd_byte dummy
[S390_MAX_INSTR_SIZE
] = { 0 };
1415 bfd_byte
*insn32
= word_size
== 4 ? insn
: dummy
;
1416 bfd_byte
*insn64
= word_size
== 8 ? insn
: dummy
;
1418 /* Fields for various kinds of instructions. */
1419 unsigned int b2
, r1
, r2
, x2
, r3
;
1422 /* The values of SP and FP before this instruction,
1423 for detecting instructions that change them. */
1424 pv_t pre_insn_sp
, pre_insn_fp
;
1425 /* Likewise for the flag whether the back chain was saved. */
1426 int pre_insn_back_chain_saved_p
;
1428 /* If we got an error trying to read the instruction, report it. */
1435 next_pc
= pc
+ insn_len
;
1437 pre_insn_sp
= data
->gpr
[S390_SP_REGNUM
- S390_R0_REGNUM
];
1438 pre_insn_fp
= data
->gpr
[S390_FRAME_REGNUM
- S390_R0_REGNUM
];
1439 pre_insn_back_chain_saved_p
= data
->back_chain_saved_p
;
1442 /* LHI r1, i2 --- load halfword immediate. */
1443 /* LGHI r1, i2 --- load halfword immediate (64-bit version). */
1444 /* LGFI r1, i2 --- load fullword immediate. */
1445 if (is_ri (insn32
, op1_lhi
, op2_lhi
, &r1
, &i2
)
1446 || is_ri (insn64
, op1_lghi
, op2_lghi
, &r1
, &i2
)
1447 || is_ril (insn
, op1_lgfi
, op2_lgfi
, &r1
, &i2
))
1448 data
->gpr
[r1
] = pv_constant (i2
);
1450 /* LR r1, r2 --- load from register. */
1451 /* LGR r1, r2 --- load from register (64-bit version). */
1452 else if (is_rr (insn32
, op_lr
, &r1
, &r2
)
1453 || is_rre (insn64
, op_lgr
, &r1
, &r2
))
1454 data
->gpr
[r1
] = data
->gpr
[r2
];
1456 /* L r1, d2(x2, b2) --- load. */
1457 /* LY r1, d2(x2, b2) --- load (long-displacement version). */
1458 /* LG r1, d2(x2, b2) --- load (64-bit version). */
1459 else if (is_rx (insn32
, op_l
, &r1
, &d2
, &x2
, &b2
)
1460 || is_rxy (insn32
, op1_ly
, op2_ly
, &r1
, &d2
, &x2
, &b2
)
1461 || is_rxy (insn64
, op1_lg
, op2_lg
, &r1
, &d2
, &x2
, &b2
))
1462 data
->gpr
[r1
] = s390_load (data
, d2
, x2
, b2
, data
->gpr_size
);
1464 /* ST r1, d2(x2, b2) --- store. */
1465 /* STY r1, d2(x2, b2) --- store (long-displacement version). */
1466 /* STG r1, d2(x2, b2) --- store (64-bit version). */
1467 else if (is_rx (insn32
, op_st
, &r1
, &d2
, &x2
, &b2
)
1468 || is_rxy (insn32
, op1_sty
, op2_sty
, &r1
, &d2
, &x2
, &b2
)
1469 || is_rxy (insn64
, op1_stg
, op2_stg
, &r1
, &d2
, &x2
, &b2
))
1470 s390_store (data
, d2
, x2
, b2
, data
->gpr_size
, data
->gpr
[r1
]);
1472 /* STD r1, d2(x2,b2) --- store floating-point register. */
1473 else if (is_rx (insn
, op_std
, &r1
, &d2
, &x2
, &b2
))
1474 s390_store (data
, d2
, x2
, b2
, data
->fpr_size
, data
->fpr
[r1
]);
1476 /* STM r1, r3, d2(b2) --- store multiple. */
1477 /* STMY r1, r3, d2(b2) --- store multiple (long-displacement
1479 /* STMG r1, r3, d2(b2) --- store multiple (64-bit version). */
1480 else if (is_rs (insn32
, op_stm
, &r1
, &r3
, &d2
, &b2
)
1481 || is_rsy (insn32
, op1_stmy
, op2_stmy
, &r1
, &r3
, &d2
, &b2
)
1482 || is_rsy (insn64
, op1_stmg
, op2_stmg
, &r1
, &r3
, &d2
, &b2
))
1484 for (; r1
<= r3
; r1
++, d2
+= data
->gpr_size
)
1485 s390_store (data
, d2
, 0, b2
, data
->gpr_size
, data
->gpr
[r1
]);
1488 /* AHI r1, i2 --- add halfword immediate. */
1489 /* AGHI r1, i2 --- add halfword immediate (64-bit version). */
1490 /* AFI r1, i2 --- add fullword immediate. */
1491 /* AGFI r1, i2 --- add fullword immediate (64-bit version). */
1492 else if (is_ri (insn32
, op1_ahi
, op2_ahi
, &r1
, &i2
)
1493 || is_ri (insn64
, op1_aghi
, op2_aghi
, &r1
, &i2
)
1494 || is_ril (insn32
, op1_afi
, op2_afi
, &r1
, &i2
)
1495 || is_ril (insn64
, op1_agfi
, op2_agfi
, &r1
, &i2
))
1496 data
->gpr
[r1
] = pv_add_constant (data
->gpr
[r1
], i2
);
1498 /* ALFI r1, i2 --- add logical immediate. */
1499 /* ALGFI r1, i2 --- add logical immediate (64-bit version). */
1500 else if (is_ril (insn32
, op1_alfi
, op2_alfi
, &r1
, &i2
)
1501 || is_ril (insn64
, op1_algfi
, op2_algfi
, &r1
, &i2
))
1502 data
->gpr
[r1
] = pv_add_constant (data
->gpr
[r1
],
1503 (CORE_ADDR
)i2
& 0xffffffff);
1505 /* AR r1, r2 -- add register. */
1506 /* AGR r1, r2 -- add register (64-bit version). */
1507 else if (is_rr (insn32
, op_ar
, &r1
, &r2
)
1508 || is_rre (insn64
, op_agr
, &r1
, &r2
))
1509 data
->gpr
[r1
] = pv_add (data
->gpr
[r1
], data
->gpr
[r2
]);
1511 /* A r1, d2(x2, b2) -- add. */
1512 /* AY r1, d2(x2, b2) -- add (long-displacement version). */
1513 /* AG r1, d2(x2, b2) -- add (64-bit version). */
1514 else if (is_rx (insn32
, op_a
, &r1
, &d2
, &x2
, &b2
)
1515 || is_rxy (insn32
, op1_ay
, op2_ay
, &r1
, &d2
, &x2
, &b2
)
1516 || is_rxy (insn64
, op1_ag
, op2_ag
, &r1
, &d2
, &x2
, &b2
))
1517 data
->gpr
[r1
] = pv_add (data
->gpr
[r1
],
1518 s390_load (data
, d2
, x2
, b2
, data
->gpr_size
));
1520 /* SLFI r1, i2 --- subtract logical immediate. */
1521 /* SLGFI r1, i2 --- subtract logical immediate (64-bit version). */
1522 else if (is_ril (insn32
, op1_slfi
, op2_slfi
, &r1
, &i2
)
1523 || is_ril (insn64
, op1_slgfi
, op2_slgfi
, &r1
, &i2
))
1524 data
->gpr
[r1
] = pv_add_constant (data
->gpr
[r1
],
1525 -((CORE_ADDR
)i2
& 0xffffffff));
1527 /* SR r1, r2 -- subtract register. */
1528 /* SGR r1, r2 -- subtract register (64-bit version). */
1529 else if (is_rr (insn32
, op_sr
, &r1
, &r2
)
1530 || is_rre (insn64
, op_sgr
, &r1
, &r2
))
1531 data
->gpr
[r1
] = pv_subtract (data
->gpr
[r1
], data
->gpr
[r2
]);
1533 /* S r1, d2(x2, b2) -- subtract. */
1534 /* SY r1, d2(x2, b2) -- subtract (long-displacement version). */
1535 /* SG r1, d2(x2, b2) -- subtract (64-bit version). */
1536 else if (is_rx (insn32
, op_s
, &r1
, &d2
, &x2
, &b2
)
1537 || is_rxy (insn32
, op1_sy
, op2_sy
, &r1
, &d2
, &x2
, &b2
)
1538 || is_rxy (insn64
, op1_sg
, op2_sg
, &r1
, &d2
, &x2
, &b2
))
1539 data
->gpr
[r1
] = pv_subtract (data
->gpr
[r1
],
1540 s390_load (data
, d2
, x2
, b2
, data
->gpr_size
));
1542 /* LA r1, d2(x2, b2) --- load address. */
1543 /* LAY r1, d2(x2, b2) --- load address (long-displacement version). */
1544 else if (is_rx (insn
, op_la
, &r1
, &d2
, &x2
, &b2
)
1545 || is_rxy (insn
, op1_lay
, op2_lay
, &r1
, &d2
, &x2
, &b2
))
1546 data
->gpr
[r1
] = s390_addr (data
, d2
, x2
, b2
);
1548 /* LARL r1, i2 --- load address relative long. */
1549 else if (is_ril (insn
, op1_larl
, op2_larl
, &r1
, &i2
))
1550 data
->gpr
[r1
] = pv_constant (pc
+ i2
* 2);
1552 /* BASR r1, 0 --- branch and save.
1553 Since r2 is zero, this saves the PC in r1, but doesn't branch. */
1554 else if (is_rr (insn
, op_basr
, &r1
, &r2
)
1556 data
->gpr
[r1
] = pv_constant (next_pc
);
1558 /* BRAS r1, i2 --- branch relative and save. */
1559 else if (is_ri (insn
, op1_bras
, op2_bras
, &r1
, &i2
))
1561 data
->gpr
[r1
] = pv_constant (next_pc
);
1562 next_pc
= pc
+ i2
* 2;
1564 /* We'd better not interpret any backward branches. We'll
1570 /* BRC/BRCL -- branch relative on condition. Ignore "branch
1571 never", branch to following instruction, and "conditional
1572 trap" (BRC +2). Otherwise terminate search. */
1573 else if (is_ri (insn
, op1_brc
, op2_brc
, &r1
, &i2
))
1575 if (r1
!= 0 && i2
!= 1 && i2
!= 2)
1578 else if (is_ril (insn
, op1_brcl
, op2_brcl
, &r1
, &i2
))
1580 if (r1
!= 0 && i2
!= 3)
1584 /* Terminate search when hitting any other branch instruction. */
1585 else if (is_rr (insn
, op_basr
, &r1
, &r2
)
1586 || is_rx (insn
, op_bas
, &r1
, &d2
, &x2
, &b2
)
1587 || is_rr (insn
, op_bcr
, &r1
, &r2
)
1588 || is_rx (insn
, op_bc
, &r1
, &d2
, &x2
, &b2
)
1589 || is_ril (insn
, op1_brasl
, op2_brasl
, &r2
, &i2
))
1594 /* An instruction we don't know how to simulate. The only
1595 safe thing to do would be to set every value we're tracking
1596 to 'unknown'. Instead, we'll be optimistic: we assume that
1597 we *can* interpret every instruction that the compiler uses
1598 to manipulate any of the data we're interested in here --
1599 then we can just ignore anything else. */
1602 /* Record the address after the last instruction that changed
1603 the FP, SP, or backlink. Ignore instructions that changed
1604 them back to their original values --- those are probably
1605 restore instructions. (The back chain is never restored,
1608 pv_t sp
= data
->gpr
[S390_SP_REGNUM
- S390_R0_REGNUM
];
1609 pv_t fp
= data
->gpr
[S390_FRAME_REGNUM
- S390_R0_REGNUM
];
1611 if ((! pv_is_identical (pre_insn_sp
, sp
)
1612 && ! pv_is_register_k (sp
, S390_SP_REGNUM
, 0)
1613 && sp
.kind
!= pvk_unknown
)
1614 || (! pv_is_identical (pre_insn_fp
, fp
)
1615 && ! pv_is_register_k (fp
, S390_FRAME_REGNUM
, 0)
1616 && fp
.kind
!= pvk_unknown
)
1617 || pre_insn_back_chain_saved_p
!= data
->back_chain_saved_p
)
1622 /* Record where all the registers were saved. */
1623 pv_area_scan (data
->stack
, s390_check_for_saved
, data
);
1625 free_pv_area (data
->stack
);
1631 /* Advance PC across any function entry prologue instructions to reach
1632 some "real" code. */
1634 s390_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
1636 struct s390_prologue_data data
;
1637 CORE_ADDR skip_pc
, func_addr
;
1639 if (find_pc_partial_function (pc
, NULL
, &func_addr
, NULL
))
1641 CORE_ADDR post_prologue_pc
1642 = skip_prologue_using_sal (gdbarch
, func_addr
);
1643 if (post_prologue_pc
!= 0)
1644 return max (pc
, post_prologue_pc
);
1647 skip_pc
= s390_analyze_prologue (gdbarch
, pc
, (CORE_ADDR
)-1, &data
);
1648 return skip_pc
? skip_pc
: pc
;
1651 /* Implmement the stack_frame_destroyed_p gdbarch method. */
1653 s390_stack_frame_destroyed_p (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
1655 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
1657 /* In frameless functions, there's not frame to destroy and thus
1658 we don't care about the epilogue.
1660 In functions with frame, the epilogue sequence is a pair of
1661 a LM-type instruction that restores (amongst others) the
1662 return register %r14 and the stack pointer %r15, followed
1663 by a branch 'br %r14' --or equivalent-- that effects the
1666 In that situation, this function needs to return 'true' in
1667 exactly one case: when pc points to that branch instruction.
1669 Thus we try to disassemble the one instructions immediately
1670 preceding pc and check whether it is an LM-type instruction
1671 modifying the stack pointer.
1673 Note that disassembling backwards is not reliable, so there
1674 is a slight chance of false positives here ... */
1677 unsigned int r1
, r3
, b2
;
1681 && !target_read_memory (pc
- 4, insn
, 4)
1682 && is_rs (insn
, op_lm
, &r1
, &r3
, &d2
, &b2
)
1683 && r3
== S390_SP_REGNUM
- S390_R0_REGNUM
)
1687 && !target_read_memory (pc
- 6, insn
, 6)
1688 && is_rsy (insn
, op1_lmy
, op2_lmy
, &r1
, &r3
, &d2
, &b2
)
1689 && r3
== S390_SP_REGNUM
- S390_R0_REGNUM
)
1693 && !target_read_memory (pc
- 6, insn
, 6)
1694 && is_rsy (insn
, op1_lmg
, op2_lmg
, &r1
, &r3
, &d2
, &b2
)
1695 && r3
== S390_SP_REGNUM
- S390_R0_REGNUM
)
1701 /* Displaced stepping. */
1703 /* Return true if INSN is a non-branch RIL-b or RIL-c format
1707 is_non_branch_ril (gdb_byte
*insn
)
1709 gdb_byte op1
= insn
[0];
1713 gdb_byte op2
= insn
[1] & 0x0f;
1717 case 0x02: /* llhrl */
1718 case 0x04: /* lghrl */
1719 case 0x05: /* lhrl */
1720 case 0x06: /* llghrl */
1721 case 0x07: /* sthrl */
1722 case 0x08: /* lgrl */
1723 case 0x0b: /* stgrl */
1724 case 0x0c: /* lgfrl */
1725 case 0x0d: /* lrl */
1726 case 0x0e: /* llgfrl */
1727 case 0x0f: /* strl */
1731 else if (op1
== 0xc6)
1733 gdb_byte op2
= insn
[1] & 0x0f;
1737 case 0x00: /* exrl */
1738 case 0x02: /* pfdrl */
1739 case 0x04: /* cghrl */
1740 case 0x05: /* chrl */
1741 case 0x06: /* clghrl */
1742 case 0x07: /* clhrl */
1743 case 0x08: /* cgrl */
1744 case 0x0a: /* clgrl */
1745 case 0x0c: /* cgfrl */
1746 case 0x0d: /* crl */
1747 case 0x0e: /* clgfrl */
1748 case 0x0f: /* clrl */
1756 /* Implementation of gdbarch_displaced_step_copy_insn. */
1758 static struct displaced_step_closure
*
1759 s390_displaced_step_copy_insn (struct gdbarch
*gdbarch
,
1760 CORE_ADDR from
, CORE_ADDR to
,
1761 struct regcache
*regs
)
1763 size_t len
= gdbarch_max_insn_length (gdbarch
);
1764 gdb_byte
*buf
= (gdb_byte
*) xmalloc (len
);
1765 struct cleanup
*old_chain
= make_cleanup (xfree
, buf
);
1767 read_memory (from
, buf
, len
);
1769 /* Adjust the displacement field of PC-relative RIL instructions,
1770 except branches. The latter are handled in the fixup hook. */
1771 if (is_non_branch_ril (buf
))
1775 offset
= extract_signed_integer (buf
+ 2, 4, BFD_ENDIAN_BIG
);
1776 offset
= (from
- to
+ offset
* 2) / 2;
1778 /* If the instruction is too far from the jump pad, punt. This
1779 will usually happen with instructions in shared libraries.
1780 We could probably support these by rewriting them to be
1781 absolute or fully emulating them. */
1782 if (offset
< INT32_MIN
|| offset
> INT32_MAX
)
1784 /* Let the core fall back to stepping over the breakpoint
1786 if (debug_displaced
)
1788 fprintf_unfiltered (gdb_stdlog
,
1789 "displaced: can't displaced step "
1790 "RIL instruction: offset %s out of range\n",
1793 do_cleanups (old_chain
);
1797 store_signed_integer (buf
+ 2, 4, BFD_ENDIAN_BIG
, offset
);
1800 write_memory (to
, buf
, len
);
1802 if (debug_displaced
)
1804 fprintf_unfiltered (gdb_stdlog
, "displaced: copy %s->%s: ",
1805 paddress (gdbarch
, from
), paddress (gdbarch
, to
));
1806 displaced_step_dump_bytes (gdb_stdlog
, buf
, len
);
1809 discard_cleanups (old_chain
);
1810 return (struct displaced_step_closure
*) buf
;
1813 /* Fix up the state of registers and memory after having single-stepped
1814 a displaced instruction. */
1816 s390_displaced_step_fixup (struct gdbarch
*gdbarch
,
1817 struct displaced_step_closure
*closure
,
1818 CORE_ADDR from
, CORE_ADDR to
,
1819 struct regcache
*regs
)
1821 /* Our closure is a copy of the instruction. */
1822 gdb_byte
*insn
= (gdb_byte
*) closure
;
1823 static int s390_instrlen
[] = { 2, 4, 4, 6 };
1824 int insnlen
= s390_instrlen
[insn
[0] >> 6];
1826 /* Fields for various kinds of instructions. */
1827 unsigned int b2
, r1
, r2
, x2
, r3
;
1830 /* Get current PC and addressing mode bit. */
1831 CORE_ADDR pc
= regcache_read_pc (regs
);
1834 if (register_size (gdbarch
, S390_PSWA_REGNUM
) == 4)
1836 regcache_cooked_read_unsigned (regs
, S390_PSWA_REGNUM
, &amode
);
1837 amode
&= 0x80000000;
1840 if (debug_displaced
)
1841 fprintf_unfiltered (gdb_stdlog
,
1842 "displaced: (s390) fixup (%s, %s) pc %s len %d amode 0x%x\n",
1843 paddress (gdbarch
, from
), paddress (gdbarch
, to
),
1844 paddress (gdbarch
, pc
), insnlen
, (int) amode
);
1846 /* Handle absolute branch and save instructions. */
1847 if (is_rr (insn
, op_basr
, &r1
, &r2
)
1848 || is_rx (insn
, op_bas
, &r1
, &d2
, &x2
, &b2
))
1850 /* Recompute saved return address in R1. */
1851 regcache_cooked_write_unsigned (regs
, S390_R0_REGNUM
+ r1
,
1852 amode
| (from
+ insnlen
));
1855 /* Handle absolute branch instructions. */
1856 else if (is_rr (insn
, op_bcr
, &r1
, &r2
)
1857 || is_rx (insn
, op_bc
, &r1
, &d2
, &x2
, &b2
)
1858 || is_rr (insn
, op_bctr
, &r1
, &r2
)
1859 || is_rre (insn
, op_bctgr
, &r1
, &r2
)
1860 || is_rx (insn
, op_bct
, &r1
, &d2
, &x2
, &b2
)
1861 || is_rxy (insn
, op1_bctg
, op2_brctg
, &r1
, &d2
, &x2
, &b2
)
1862 || is_rs (insn
, op_bxh
, &r1
, &r3
, &d2
, &b2
)
1863 || is_rsy (insn
, op1_bxhg
, op2_bxhg
, &r1
, &r3
, &d2
, &b2
)
1864 || is_rs (insn
, op_bxle
, &r1
, &r3
, &d2
, &b2
)
1865 || is_rsy (insn
, op1_bxleg
, op2_bxleg
, &r1
, &r3
, &d2
, &b2
))
1867 /* Update PC iff branch was *not* taken. */
1868 if (pc
== to
+ insnlen
)
1869 regcache_write_pc (regs
, from
+ insnlen
);
1872 /* Handle PC-relative branch and save instructions. */
1873 else if (is_ri (insn
, op1_bras
, op2_bras
, &r1
, &i2
)
1874 || is_ril (insn
, op1_brasl
, op2_brasl
, &r1
, &i2
))
1877 regcache_write_pc (regs
, pc
- to
+ from
);
1878 /* Recompute saved return address in R1. */
1879 regcache_cooked_write_unsigned (regs
, S390_R0_REGNUM
+ r1
,
1880 amode
| (from
+ insnlen
));
1883 /* Handle PC-relative branch instructions. */
1884 else if (is_ri (insn
, op1_brc
, op2_brc
, &r1
, &i2
)
1885 || is_ril (insn
, op1_brcl
, op2_brcl
, &r1
, &i2
)
1886 || is_ri (insn
, op1_brct
, op2_brct
, &r1
, &i2
)
1887 || is_ri (insn
, op1_brctg
, op2_brctg
, &r1
, &i2
)
1888 || is_rsi (insn
, op_brxh
, &r1
, &r3
, &i2
)
1889 || is_rie (insn
, op1_brxhg
, op2_brxhg
, &r1
, &r3
, &i2
)
1890 || is_rsi (insn
, op_brxle
, &r1
, &r3
, &i2
)
1891 || is_rie (insn
, op1_brxlg
, op2_brxlg
, &r1
, &r3
, &i2
))
1894 regcache_write_pc (regs
, pc
- to
+ from
);
1897 /* Handle LOAD ADDRESS RELATIVE LONG. */
1898 else if (is_ril (insn
, op1_larl
, op2_larl
, &r1
, &i2
))
1901 regcache_write_pc (regs
, from
+ insnlen
);
1902 /* Recompute output address in R1. */
1903 regcache_cooked_write_unsigned (regs
, S390_R0_REGNUM
+ r1
,
1904 amode
| (from
+ i2
* 2));
1907 /* If we executed a breakpoint instruction, point PC right back at it. */
1908 else if (insn
[0] == 0x0 && insn
[1] == 0x1)
1909 regcache_write_pc (regs
, from
);
1911 /* For any other insn, PC points right after the original instruction. */
1913 regcache_write_pc (regs
, from
+ insnlen
);
1915 if (debug_displaced
)
1916 fprintf_unfiltered (gdb_stdlog
,
1917 "displaced: (s390) pc is now %s\n",
1918 paddress (gdbarch
, regcache_read_pc (regs
)));
1922 /* Helper routine to unwind pseudo registers. */
1924 static struct value
*
1925 s390_unwind_pseudo_register (struct frame_info
*this_frame
, int regnum
)
1927 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1928 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1929 struct type
*type
= register_type (gdbarch
, regnum
);
1931 /* Unwind PC via PSW address. */
1932 if (regnum
== tdep
->pc_regnum
)
1936 val
= frame_unwind_register_value (this_frame
, S390_PSWA_REGNUM
);
1937 if (!value_optimized_out (val
))
1939 LONGEST pswa
= value_as_long (val
);
1941 if (TYPE_LENGTH (type
) == 4)
1942 return value_from_pointer (type
, pswa
& 0x7fffffff);
1944 return value_from_pointer (type
, pswa
);
1948 /* Unwind CC via PSW mask. */
1949 if (regnum
== tdep
->cc_regnum
)
1953 val
= frame_unwind_register_value (this_frame
, S390_PSWM_REGNUM
);
1954 if (!value_optimized_out (val
))
1956 LONGEST pswm
= value_as_long (val
);
1958 if (TYPE_LENGTH (type
) == 4)
1959 return value_from_longest (type
, (pswm
>> 12) & 3);
1961 return value_from_longest (type
, (pswm
>> 44) & 3);
1965 /* Unwind full GPRs to show at least the lower halves (as the
1966 upper halves are undefined). */
1967 if (regnum_is_gpr_full (tdep
, regnum
))
1969 int reg
= regnum
- tdep
->gpr_full_regnum
;
1972 val
= frame_unwind_register_value (this_frame
, S390_R0_REGNUM
+ reg
);
1973 if (!value_optimized_out (val
))
1974 return value_cast (type
, val
);
1977 return allocate_optimized_out_value (type
);
1980 static struct value
*
1981 s390_trad_frame_prev_register (struct frame_info
*this_frame
,
1982 struct trad_frame_saved_reg saved_regs
[],
1985 if (regnum
< S390_NUM_REGS
)
1986 return trad_frame_get_prev_register (this_frame
, saved_regs
, regnum
);
1988 return s390_unwind_pseudo_register (this_frame
, regnum
);
1992 /* Normal stack frames. */
1994 struct s390_unwind_cache
{
1997 CORE_ADDR frame_base
;
1998 CORE_ADDR local_base
;
2000 struct trad_frame_saved_reg
*saved_regs
;
2004 s390_prologue_frame_unwind_cache (struct frame_info
*this_frame
,
2005 struct s390_unwind_cache
*info
)
2007 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2008 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
2009 struct s390_prologue_data data
;
2010 pv_t
*fp
= &data
.gpr
[S390_FRAME_REGNUM
- S390_R0_REGNUM
];
2011 pv_t
*sp
= &data
.gpr
[S390_SP_REGNUM
- S390_R0_REGNUM
];
2020 struct frame_info
*next_frame
;
2022 /* Try to find the function start address. If we can't find it, we don't
2023 bother searching for it -- with modern compilers this would be mostly
2024 pointless anyway. Trust that we'll either have valid DWARF-2 CFI data
2025 or else a valid backchain ... */
2026 if (!get_frame_func_if_available (this_frame
, &info
->func
))
2033 /* Try to analyze the prologue. */
2034 result
= s390_analyze_prologue (gdbarch
, func
,
2035 get_frame_pc (this_frame
), &data
);
2039 /* If this was successful, we should have found the instruction that
2040 sets the stack pointer register to the previous value of the stack
2041 pointer minus the frame size. */
2042 if (!pv_is_register (*sp
, S390_SP_REGNUM
))
2045 /* A frame size of zero at this point can mean either a real
2046 frameless function, or else a failure to find the prologue.
2047 Perform some sanity checks to verify we really have a
2048 frameless function. */
2051 /* If the next frame is a NORMAL_FRAME, this frame *cannot* have frame
2052 size zero. This is only possible if the next frame is a sentinel
2053 frame, a dummy frame, or a signal trampoline frame. */
2054 /* FIXME: cagney/2004-05-01: This sanity check shouldn't be
2055 needed, instead the code should simpliy rely on its
2057 next_frame
= get_next_frame (this_frame
);
2058 while (next_frame
&& get_frame_type (next_frame
) == INLINE_FRAME
)
2059 next_frame
= get_next_frame (next_frame
);
2061 && get_frame_type (get_next_frame (this_frame
)) == NORMAL_FRAME
)
2064 /* If we really have a frameless function, %r14 must be valid
2065 -- in particular, it must point to a different function. */
2066 reg
= get_frame_register_unsigned (this_frame
, S390_RETADDR_REGNUM
);
2067 reg
= gdbarch_addr_bits_remove (gdbarch
, reg
) - 1;
2068 if (get_pc_function_start (reg
) == func
)
2070 /* However, there is one case where it *is* valid for %r14
2071 to point to the same function -- if this is a recursive
2072 call, and we have stopped in the prologue *before* the
2073 stack frame was allocated.
2075 Recognize this case by looking ahead a bit ... */
2077 struct s390_prologue_data data2
;
2078 pv_t
*sp
= &data2
.gpr
[S390_SP_REGNUM
- S390_R0_REGNUM
];
2080 if (!(s390_analyze_prologue (gdbarch
, func
, (CORE_ADDR
)-1, &data2
)
2081 && pv_is_register (*sp
, S390_SP_REGNUM
)
2088 /* OK, we've found valid prologue data. */
2091 /* If the frame pointer originally also holds the same value
2092 as the stack pointer, we're probably using it. If it holds
2093 some other value -- even a constant offset -- it is most
2094 likely used as temp register. */
2095 if (pv_is_identical (*sp
, *fp
))
2096 frame_pointer
= S390_FRAME_REGNUM
;
2098 frame_pointer
= S390_SP_REGNUM
;
2100 /* If we've detected a function with stack frame, we'll still have to
2101 treat it as frameless if we're currently within the function epilog
2102 code at a point where the frame pointer has already been restored.
2103 This can only happen in an innermost frame. */
2104 /* FIXME: cagney/2004-05-01: This sanity check shouldn't be needed,
2105 instead the code should simpliy rely on its analysis. */
2106 next_frame
= get_next_frame (this_frame
);
2107 while (next_frame
&& get_frame_type (next_frame
) == INLINE_FRAME
)
2108 next_frame
= get_next_frame (next_frame
);
2110 && (next_frame
== NULL
2111 || get_frame_type (get_next_frame (this_frame
)) != NORMAL_FRAME
))
2113 /* See the comment in s390_stack_frame_destroyed_p on why this is
2114 not completely reliable ... */
2115 if (s390_stack_frame_destroyed_p (gdbarch
, get_frame_pc (this_frame
)))
2117 memset (&data
, 0, sizeof (data
));
2119 frame_pointer
= S390_SP_REGNUM
;
2123 /* Once we know the frame register and the frame size, we can unwind
2124 the current value of the frame register from the next frame, and
2125 add back the frame size to arrive that the previous frame's
2126 stack pointer value. */
2127 prev_sp
= get_frame_register_unsigned (this_frame
, frame_pointer
) + size
;
2128 cfa
= prev_sp
+ 16*word_size
+ 32;
2130 /* Set up ABI call-saved/call-clobbered registers. */
2131 for (i
= 0; i
< S390_NUM_REGS
; i
++)
2132 if (!s390_register_call_saved (gdbarch
, i
))
2133 trad_frame_set_unknown (info
->saved_regs
, i
);
2135 /* CC is always call-clobbered. */
2136 trad_frame_set_unknown (info
->saved_regs
, S390_PSWM_REGNUM
);
2138 /* Record the addresses of all register spill slots the prologue parser
2139 has recognized. Consider only registers defined as call-saved by the
2140 ABI; for call-clobbered registers the parser may have recognized
2143 for (i
= 0; i
< 16; i
++)
2144 if (s390_register_call_saved (gdbarch
, S390_R0_REGNUM
+ i
)
2145 && data
.gpr_slot
[i
] != 0)
2146 info
->saved_regs
[S390_R0_REGNUM
+ i
].addr
= cfa
- data
.gpr_slot
[i
];
2148 for (i
= 0; i
< 16; i
++)
2149 if (s390_register_call_saved (gdbarch
, S390_F0_REGNUM
+ i
)
2150 && data
.fpr_slot
[i
] != 0)
2151 info
->saved_regs
[S390_F0_REGNUM
+ i
].addr
= cfa
- data
.fpr_slot
[i
];
2153 /* Function return will set PC to %r14. */
2154 info
->saved_regs
[S390_PSWA_REGNUM
] = info
->saved_regs
[S390_RETADDR_REGNUM
];
2156 /* In frameless functions, we unwind simply by moving the return
2157 address to the PC. However, if we actually stored to the
2158 save area, use that -- we might only think the function frameless
2159 because we're in the middle of the prologue ... */
2161 && !trad_frame_addr_p (info
->saved_regs
, S390_PSWA_REGNUM
))
2163 info
->saved_regs
[S390_PSWA_REGNUM
].realreg
= S390_RETADDR_REGNUM
;
2166 /* Another sanity check: unless this is a frameless function,
2167 we should have found spill slots for SP and PC.
2168 If not, we cannot unwind further -- this happens e.g. in
2169 libc's thread_start routine. */
2172 if (!trad_frame_addr_p (info
->saved_regs
, S390_SP_REGNUM
)
2173 || !trad_frame_addr_p (info
->saved_regs
, S390_PSWA_REGNUM
))
2177 /* We use the current value of the frame register as local_base,
2178 and the top of the register save area as frame_base. */
2181 info
->frame_base
= prev_sp
+ 16*word_size
+ 32;
2182 info
->local_base
= prev_sp
- size
;
2189 s390_backchain_frame_unwind_cache (struct frame_info
*this_frame
,
2190 struct s390_unwind_cache
*info
)
2192 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2193 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
2194 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2195 CORE_ADDR backchain
;
2200 /* Set up ABI call-saved/call-clobbered registers. */
2201 for (i
= 0; i
< S390_NUM_REGS
; i
++)
2202 if (!s390_register_call_saved (gdbarch
, i
))
2203 trad_frame_set_unknown (info
->saved_regs
, i
);
2205 /* CC is always call-clobbered. */
2206 trad_frame_set_unknown (info
->saved_regs
, S390_PSWM_REGNUM
);
2208 /* Get the backchain. */
2209 reg
= get_frame_register_unsigned (this_frame
, S390_SP_REGNUM
);
2210 if (!safe_read_memory_integer (reg
, word_size
, byte_order
, &tmp
))
2212 backchain
= (CORE_ADDR
) tmp
;
2214 /* A zero backchain terminates the frame chain. As additional
2215 sanity check, let's verify that the spill slot for SP in the
2216 save area pointed to by the backchain in fact links back to
2219 && safe_read_memory_integer (backchain
+ 15*word_size
,
2220 word_size
, byte_order
, &sp
)
2221 && (CORE_ADDR
)sp
== backchain
)
2223 /* We don't know which registers were saved, but it will have
2224 to be at least %r14 and %r15. This will allow us to continue
2225 unwinding, but other prev-frame registers may be incorrect ... */
2226 info
->saved_regs
[S390_SP_REGNUM
].addr
= backchain
+ 15*word_size
;
2227 info
->saved_regs
[S390_RETADDR_REGNUM
].addr
= backchain
+ 14*word_size
;
2229 /* Function return will set PC to %r14. */
2230 info
->saved_regs
[S390_PSWA_REGNUM
]
2231 = info
->saved_regs
[S390_RETADDR_REGNUM
];
2233 /* We use the current value of the frame register as local_base,
2234 and the top of the register save area as frame_base. */
2235 info
->frame_base
= backchain
+ 16*word_size
+ 32;
2236 info
->local_base
= reg
;
2239 info
->func
= get_frame_pc (this_frame
);
2242 static struct s390_unwind_cache
*
2243 s390_frame_unwind_cache (struct frame_info
*this_frame
,
2244 void **this_prologue_cache
)
2246 struct s390_unwind_cache
*info
;
2248 if (*this_prologue_cache
)
2249 return (struct s390_unwind_cache
*) *this_prologue_cache
;
2251 info
= FRAME_OBSTACK_ZALLOC (struct s390_unwind_cache
);
2252 *this_prologue_cache
= info
;
2253 info
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
2255 info
->frame_base
= -1;
2256 info
->local_base
= -1;
2260 /* Try to use prologue analysis to fill the unwind cache.
2261 If this fails, fall back to reading the stack backchain. */
2262 if (!s390_prologue_frame_unwind_cache (this_frame
, info
))
2263 s390_backchain_frame_unwind_cache (this_frame
, info
);
2265 CATCH (ex
, RETURN_MASK_ERROR
)
2267 if (ex
.error
!= NOT_AVAILABLE_ERROR
)
2268 throw_exception (ex
);
2276 s390_frame_this_id (struct frame_info
*this_frame
,
2277 void **this_prologue_cache
,
2278 struct frame_id
*this_id
)
2280 struct s390_unwind_cache
*info
2281 = s390_frame_unwind_cache (this_frame
, this_prologue_cache
);
2283 if (info
->frame_base
== -1)
2285 if (info
->func
!= -1)
2286 *this_id
= frame_id_build_unavailable_stack (info
->func
);
2290 *this_id
= frame_id_build (info
->frame_base
, info
->func
);
2293 static struct value
*
2294 s390_frame_prev_register (struct frame_info
*this_frame
,
2295 void **this_prologue_cache
, int regnum
)
2297 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2298 struct s390_unwind_cache
*info
2299 = s390_frame_unwind_cache (this_frame
, this_prologue_cache
);
2301 return s390_trad_frame_prev_register (this_frame
, info
->saved_regs
, regnum
);
2304 static const struct frame_unwind s390_frame_unwind
= {
2306 default_frame_unwind_stop_reason
,
2308 s390_frame_prev_register
,
2310 default_frame_sniffer
2314 /* Code stubs and their stack frames. For things like PLTs and NULL
2315 function calls (where there is no true frame and the return address
2316 is in the RETADDR register). */
2318 struct s390_stub_unwind_cache
2320 CORE_ADDR frame_base
;
2321 struct trad_frame_saved_reg
*saved_regs
;
2324 static struct s390_stub_unwind_cache
*
2325 s390_stub_frame_unwind_cache (struct frame_info
*this_frame
,
2326 void **this_prologue_cache
)
2328 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2329 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
2330 struct s390_stub_unwind_cache
*info
;
2333 if (*this_prologue_cache
)
2334 return (struct s390_stub_unwind_cache
*) *this_prologue_cache
;
2336 info
= FRAME_OBSTACK_ZALLOC (struct s390_stub_unwind_cache
);
2337 *this_prologue_cache
= info
;
2338 info
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
2340 /* The return address is in register %r14. */
2341 info
->saved_regs
[S390_PSWA_REGNUM
].realreg
= S390_RETADDR_REGNUM
;
2343 /* Retrieve stack pointer and determine our frame base. */
2344 reg
= get_frame_register_unsigned (this_frame
, S390_SP_REGNUM
);
2345 info
->frame_base
= reg
+ 16*word_size
+ 32;
2351 s390_stub_frame_this_id (struct frame_info
*this_frame
,
2352 void **this_prologue_cache
,
2353 struct frame_id
*this_id
)
2355 struct s390_stub_unwind_cache
*info
2356 = s390_stub_frame_unwind_cache (this_frame
, this_prologue_cache
);
2357 *this_id
= frame_id_build (info
->frame_base
, get_frame_pc (this_frame
));
2360 static struct value
*
2361 s390_stub_frame_prev_register (struct frame_info
*this_frame
,
2362 void **this_prologue_cache
, int regnum
)
2364 struct s390_stub_unwind_cache
*info
2365 = s390_stub_frame_unwind_cache (this_frame
, this_prologue_cache
);
2366 return s390_trad_frame_prev_register (this_frame
, info
->saved_regs
, regnum
);
2370 s390_stub_frame_sniffer (const struct frame_unwind
*self
,
2371 struct frame_info
*this_frame
,
2372 void **this_prologue_cache
)
2374 CORE_ADDR addr_in_block
;
2375 bfd_byte insn
[S390_MAX_INSTR_SIZE
];
2377 /* If the current PC points to non-readable memory, we assume we
2378 have trapped due to an invalid function pointer call. We handle
2379 the non-existing current function like a PLT stub. */
2380 addr_in_block
= get_frame_address_in_block (this_frame
);
2381 if (in_plt_section (addr_in_block
)
2382 || s390_readinstruction (insn
, get_frame_pc (this_frame
)) < 0)
2387 static const struct frame_unwind s390_stub_frame_unwind
= {
2389 default_frame_unwind_stop_reason
,
2390 s390_stub_frame_this_id
,
2391 s390_stub_frame_prev_register
,
2393 s390_stub_frame_sniffer
2397 /* Signal trampoline stack frames. */
2399 struct s390_sigtramp_unwind_cache
{
2400 CORE_ADDR frame_base
;
2401 struct trad_frame_saved_reg
*saved_regs
;
2404 static struct s390_sigtramp_unwind_cache
*
2405 s390_sigtramp_frame_unwind_cache (struct frame_info
*this_frame
,
2406 void **this_prologue_cache
)
2408 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2409 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2410 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
2411 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2412 struct s390_sigtramp_unwind_cache
*info
;
2413 ULONGEST this_sp
, prev_sp
;
2414 CORE_ADDR next_ra
, next_cfa
, sigreg_ptr
, sigreg_high_off
;
2417 if (*this_prologue_cache
)
2418 return (struct s390_sigtramp_unwind_cache
*) *this_prologue_cache
;
2420 info
= FRAME_OBSTACK_ZALLOC (struct s390_sigtramp_unwind_cache
);
2421 *this_prologue_cache
= info
;
2422 info
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
2424 this_sp
= get_frame_register_unsigned (this_frame
, S390_SP_REGNUM
);
2425 next_ra
= get_frame_pc (this_frame
);
2426 next_cfa
= this_sp
+ 16*word_size
+ 32;
2428 /* New-style RT frame:
2429 retcode + alignment (8 bytes)
2431 ucontext (contains sigregs at offset 5 words). */
2432 if (next_ra
== next_cfa
)
2434 sigreg_ptr
= next_cfa
+ 8 + 128 + align_up (5*word_size
, 8);
2435 /* sigregs are followed by uc_sigmask (8 bytes), then by the
2436 upper GPR halves if present. */
2437 sigreg_high_off
= 8;
2440 /* Old-style RT frame and all non-RT frames:
2441 old signal mask (8 bytes)
2442 pointer to sigregs. */
2445 sigreg_ptr
= read_memory_unsigned_integer (next_cfa
+ 8,
2446 word_size
, byte_order
);
2447 /* sigregs are followed by signo (4 bytes), then by the
2448 upper GPR halves if present. */
2449 sigreg_high_off
= 4;
2452 /* The sigregs structure looks like this:
2461 /* PSW mask and address. */
2462 info
->saved_regs
[S390_PSWM_REGNUM
].addr
= sigreg_ptr
;
2463 sigreg_ptr
+= word_size
;
2464 info
->saved_regs
[S390_PSWA_REGNUM
].addr
= sigreg_ptr
;
2465 sigreg_ptr
+= word_size
;
2467 /* Then the GPRs. */
2468 for (i
= 0; i
< 16; i
++)
2470 info
->saved_regs
[S390_R0_REGNUM
+ i
].addr
= sigreg_ptr
;
2471 sigreg_ptr
+= word_size
;
2474 /* Then the ACRs. */
2475 for (i
= 0; i
< 16; i
++)
2477 info
->saved_regs
[S390_A0_REGNUM
+ i
].addr
= sigreg_ptr
;
2481 /* The floating-point control word. */
2482 info
->saved_regs
[S390_FPC_REGNUM
].addr
= sigreg_ptr
;
2485 /* And finally the FPRs. */
2486 for (i
= 0; i
< 16; i
++)
2488 info
->saved_regs
[S390_F0_REGNUM
+ i
].addr
= sigreg_ptr
;
2492 /* If we have them, the GPR upper halves are appended at the end. */
2493 sigreg_ptr
+= sigreg_high_off
;
2494 if (tdep
->gpr_full_regnum
!= -1)
2495 for (i
= 0; i
< 16; i
++)
2497 info
->saved_regs
[S390_R0_UPPER_REGNUM
+ i
].addr
= sigreg_ptr
;
2501 /* Restore the previous frame's SP. */
2502 prev_sp
= read_memory_unsigned_integer (
2503 info
->saved_regs
[S390_SP_REGNUM
].addr
,
2504 word_size
, byte_order
);
2506 /* Determine our frame base. */
2507 info
->frame_base
= prev_sp
+ 16*word_size
+ 32;
2513 s390_sigtramp_frame_this_id (struct frame_info
*this_frame
,
2514 void **this_prologue_cache
,
2515 struct frame_id
*this_id
)
2517 struct s390_sigtramp_unwind_cache
*info
2518 = s390_sigtramp_frame_unwind_cache (this_frame
, this_prologue_cache
);
2519 *this_id
= frame_id_build (info
->frame_base
, get_frame_pc (this_frame
));
2522 static struct value
*
2523 s390_sigtramp_frame_prev_register (struct frame_info
*this_frame
,
2524 void **this_prologue_cache
, int regnum
)
2526 struct s390_sigtramp_unwind_cache
*info
2527 = s390_sigtramp_frame_unwind_cache (this_frame
, this_prologue_cache
);
2528 return s390_trad_frame_prev_register (this_frame
, info
->saved_regs
, regnum
);
2532 s390_sigtramp_frame_sniffer (const struct frame_unwind
*self
,
2533 struct frame_info
*this_frame
,
2534 void **this_prologue_cache
)
2536 CORE_ADDR pc
= get_frame_pc (this_frame
);
2537 bfd_byte sigreturn
[2];
2539 if (target_read_memory (pc
, sigreturn
, 2))
2542 if (sigreturn
[0] != op_svc
)
2545 if (sigreturn
[1] != 119 /* sigreturn */
2546 && sigreturn
[1] != 173 /* rt_sigreturn */)
2552 static const struct frame_unwind s390_sigtramp_frame_unwind
= {
2554 default_frame_unwind_stop_reason
,
2555 s390_sigtramp_frame_this_id
,
2556 s390_sigtramp_frame_prev_register
,
2558 s390_sigtramp_frame_sniffer
2561 /* Retrieve the syscall number at a ptrace syscall-stop. Return -1
2565 s390_linux_get_syscall_number (struct gdbarch
*gdbarch
,
2568 struct regcache
*regs
= get_thread_regcache (ptid
);
2569 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2570 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2572 ULONGEST svc_number
= -1;
2575 /* Assume that the PC points after the 2-byte SVC instruction. We
2576 don't currently support SVC via EXECUTE. */
2577 regcache_cooked_read_unsigned (regs
, tdep
->pc_regnum
, &pc
);
2579 opcode
= read_memory_unsigned_integer ((CORE_ADDR
) pc
, 1, byte_order
);
2580 if (opcode
!= op_svc
)
2583 svc_number
= read_memory_unsigned_integer ((CORE_ADDR
) pc
+ 1, 1,
2585 if (svc_number
== 0)
2586 regcache_cooked_read_unsigned (regs
, S390_R1_REGNUM
, &svc_number
);
2591 /* Process record-replay */
2593 static struct linux_record_tdep s390_linux_record_tdep
;
2594 static struct linux_record_tdep s390x_linux_record_tdep
;
2596 /* Record all registers but PC register for process-record. */
2599 s390_all_but_pc_registers_record (struct regcache
*regcache
)
2601 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
2602 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2605 for (i
= 0; i
< 16; i
++)
2607 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ i
))
2609 if (record_full_arch_list_add_reg (regcache
, S390_A0_REGNUM
+ i
))
2611 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ i
))
2613 if (tdep
->gpr_full_regnum
!= -1)
2614 if (record_full_arch_list_add_reg (regcache
, S390_R0_UPPER_REGNUM
+ i
))
2616 if (tdep
->v0_full_regnum
!= -1)
2618 if (record_full_arch_list_add_reg (regcache
, S390_V0_LOWER_REGNUM
+ i
))
2620 if (record_full_arch_list_add_reg (regcache
, S390_V16_REGNUM
+ i
))
2624 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
2626 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
2632 static enum gdb_syscall
2633 s390_canonicalize_syscall (int syscall
, enum s390_abi_kind abi
)
2637 /* s390 syscall numbers < 222 are mostly the same as x86, so just list
2640 return gdb_sys_no_syscall
;
2642 return gdb_sys_restart_syscall
;
2643 /* These syscalls work only on 31-bit. */
2645 case 16: /* lchown[16] */
2646 case 23: /* setuid[16] */
2647 case 24: /* getuid[16] */
2648 case 25: /* stime */
2649 case 46: /* setgid[16] */
2650 case 47: /* getgid[16] */
2651 case 49: /* seteuid[16] */
2652 case 50: /* getegid[16] */
2653 case 70: /* setreuid[16] */
2654 case 71: /* setregid[16] */
2655 case 76: /* [old_]getrlimit */
2656 case 80: /* getgroups[16] */
2657 case 81: /* setgroups[16] */
2658 case 95: /* fchown[16] */
2659 case 101: /* ioperm */
2660 case 138: /* setfsuid[16] */
2661 case 139: /* setfsgid[16] */
2662 case 140: /* _llseek */
2663 case 164: /* setresuid[16] */
2664 case 165: /* getresuid[16] */
2665 case 170: /* setresgid[16] */
2666 case 171: /* getresgid[16] */
2667 case 182: /* chown[16] */
2668 case 192: /* mmap2 */
2669 case 193: /* truncate64 */
2670 case 194: /* ftruncate64 */
2671 case 195: /* stat64 */
2672 case 196: /* lstat64 */
2673 case 197: /* fstat64 */
2674 case 221: /* fcntl64 */
2675 if (abi
== ABI_LINUX_S390
)
2676 return (enum gdb_syscall
) syscall
;
2677 return gdb_sys_no_syscall
;
2678 /* These syscalls don't exist on s390. */
2679 case 17: /* break */
2680 case 18: /* oldstat */
2681 case 28: /* oldfstat */
2684 case 35: /* ftime */
2688 case 58: /* ulimit */
2689 case 59: /* oldolduname */
2690 case 68: /* sgetmask */
2691 case 69: /* ssetmask */
2692 case 82: /* [old_]select */
2693 case 84: /* oldlstat */
2694 case 98: /* profil */
2695 case 109: /* olduname */
2696 case 113: /* vm86old */
2697 case 123: /* modify_ldt */
2698 case 166: /* vm86 */
2699 return gdb_sys_no_syscall
;
2701 return gdb_sys_lookup_dcookie
;
2702 /* Here come the differences. */
2704 return gdb_sys_readahead
;
2706 if (abi
== ABI_LINUX_S390
)
2707 return gdb_sys_sendfile64
;
2708 return gdb_sys_no_syscall
;
2709 /* 224-235 handled below */
2711 return gdb_sys_gettid
;
2713 return gdb_sys_tkill
;
2715 return gdb_sys_futex
;
2717 return gdb_sys_sched_setaffinity
;
2719 return gdb_sys_sched_getaffinity
;
2721 return gdb_sys_tgkill
;
2724 return gdb_sys_io_setup
;
2726 return gdb_sys_io_destroy
;
2728 return gdb_sys_io_getevents
;
2730 return gdb_sys_io_submit
;
2732 return gdb_sys_io_cancel
;
2734 return gdb_sys_exit_group
;
2736 return gdb_sys_epoll_create
;
2738 return gdb_sys_epoll_ctl
;
2740 return gdb_sys_epoll_wait
;
2742 return gdb_sys_set_tid_address
;
2744 return gdb_sys_fadvise64
;
2745 /* 254-262 handled below */
2748 if (abi
== ABI_LINUX_S390
)
2749 return gdb_sys_fadvise64_64
;
2750 return gdb_sys_no_syscall
;
2752 return gdb_sys_statfs64
;
2754 return gdb_sys_fstatfs64
;
2756 return gdb_sys_remap_file_pages
;
2757 /* 268-270 reserved */
2758 /* 271-277 handled below */
2760 return gdb_sys_add_key
;
2762 return gdb_sys_request_key
;
2764 return gdb_sys_keyctl
;
2766 return gdb_sys_waitid
;
2767 /* 282-312 handled below */
2769 if (abi
== ABI_LINUX_S390
)
2770 return gdb_sys_fstatat64
;
2771 return gdb_sys_newfstatat
;
2772 /* 313+ not yet supported */
2777 /* Most "old" syscalls copied from i386. */
2780 /* xattr syscalls. */
2781 else if (syscall
>= 224 && syscall
<= 235)
2783 /* timer syscalls. */
2784 else if (syscall
>= 254 && syscall
<= 262)
2786 /* mq_* and kexec_load */
2787 else if (syscall
>= 271 && syscall
<= 277)
2789 /* ioprio_set .. epoll_pwait */
2790 else if (syscall
>= 282 && syscall
<= 312)
2793 ret
= gdb_sys_no_syscall
;
2795 return (enum gdb_syscall
) ret
;
2801 s390_linux_syscall_record (struct regcache
*regcache
, LONGEST syscall_native
)
2803 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
2804 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2806 enum gdb_syscall syscall_gdb
;
2808 /* On s390, syscall number can be passed either as immediate field of svc
2809 instruction, or in %r1 (with svc 0). */
2810 if (syscall_native
== 0)
2811 regcache_raw_read_signed (regcache
, S390_R1_REGNUM
, &syscall_native
);
2813 syscall_gdb
= s390_canonicalize_syscall (syscall_native
, tdep
->abi
);
2815 if (syscall_gdb
< 0)
2817 printf_unfiltered (_("Process record and replay target doesn't "
2818 "support syscall number %s\n"),
2819 plongest (syscall_native
));
2823 if (syscall_gdb
== gdb_sys_sigreturn
2824 || syscall_gdb
== gdb_sys_rt_sigreturn
)
2826 if (s390_all_but_pc_registers_record (regcache
))
2831 if (tdep
->abi
== ABI_LINUX_ZSERIES
)
2832 ret
= record_linux_system_call (syscall_gdb
, regcache
,
2833 &s390x_linux_record_tdep
);
2835 ret
= record_linux_system_call (syscall_gdb
, regcache
,
2836 &s390_linux_record_tdep
);
2841 /* Record the return value of the system call. */
2842 if (record_full_arch_list_add_reg (regcache
, S390_R2_REGNUM
))
2849 s390_linux_record_signal (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
2850 enum gdb_signal signal
)
2852 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2853 /* There are two kinds of signal frames on s390. rt_sigframe is always
2854 the larger one, so don't even bother with sigframe. */
2855 const int sizeof_rt_sigframe
= (tdep
->abi
== ABI_LINUX_ZSERIES
?
2856 160 + 8 + 128 + 1024 : 96 + 8 + 128 + 1000);
2860 for (i
= 0; i
< 16; i
++)
2862 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ i
))
2864 if (tdep
->gpr_full_regnum
!= -1)
2865 if (record_full_arch_list_add_reg (regcache
, S390_R0_UPPER_REGNUM
+ i
))
2868 if (record_full_arch_list_add_reg (regcache
, S390_PSWA_REGNUM
))
2870 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
2873 /* Record the change in the stack.
2874 frame-size = sizeof (struct rt_sigframe) + SIGNAL_FRAMESIZE */
2875 regcache_raw_read_unsigned (regcache
, S390_SP_REGNUM
, &sp
);
2876 sp
-= sizeof_rt_sigframe
;
2878 if (record_full_arch_list_add_mem (sp
, sizeof_rt_sigframe
))
2881 if (record_full_arch_list_add_end ())
2887 /* Frame base handling. */
2890 s390_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
2892 struct s390_unwind_cache
*info
2893 = s390_frame_unwind_cache (this_frame
, this_cache
);
2894 return info
->frame_base
;
2898 s390_local_base_address (struct frame_info
*this_frame
, void **this_cache
)
2900 struct s390_unwind_cache
*info
2901 = s390_frame_unwind_cache (this_frame
, this_cache
);
2902 return info
->local_base
;
2905 static const struct frame_base s390_frame_base
= {
2907 s390_frame_base_address
,
2908 s390_local_base_address
,
2909 s390_local_base_address
2913 s390_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2915 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2917 pc
= frame_unwind_register_unsigned (next_frame
, tdep
->pc_regnum
);
2918 return gdbarch_addr_bits_remove (gdbarch
, pc
);
2922 s390_unwind_sp (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2925 sp
= frame_unwind_register_unsigned (next_frame
, S390_SP_REGNUM
);
2926 return gdbarch_addr_bits_remove (gdbarch
, sp
);
2930 /* DWARF-2 frame support. */
2932 static struct value
*
2933 s390_dwarf2_prev_register (struct frame_info
*this_frame
, void **this_cache
,
2936 return s390_unwind_pseudo_register (this_frame
, regnum
);
2940 s390_dwarf2_frame_init_reg (struct gdbarch
*gdbarch
, int regnum
,
2941 struct dwarf2_frame_state_reg
*reg
,
2942 struct frame_info
*this_frame
)
2944 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2946 /* The condition code (and thus PSW mask) is call-clobbered. */
2947 if (regnum
== S390_PSWM_REGNUM
)
2948 reg
->how
= DWARF2_FRAME_REG_UNDEFINED
;
2950 /* The PSW address unwinds to the return address. */
2951 else if (regnum
== S390_PSWA_REGNUM
)
2952 reg
->how
= DWARF2_FRAME_REG_RA
;
2954 /* Fixed registers are call-saved or call-clobbered
2955 depending on the ABI in use. */
2956 else if (regnum
< S390_NUM_REGS
)
2958 if (s390_register_call_saved (gdbarch
, regnum
))
2959 reg
->how
= DWARF2_FRAME_REG_SAME_VALUE
;
2961 reg
->how
= DWARF2_FRAME_REG_UNDEFINED
;
2964 /* We install a special function to unwind pseudos. */
2967 reg
->how
= DWARF2_FRAME_REG_FN
;
2968 reg
->loc
.fn
= s390_dwarf2_prev_register
;
2973 /* Dummy function calls. */
2975 /* Unwrap any single-field structs in TYPE and return the effective
2976 "inner" type. E.g., yield "float" for all these cases:
2980 struct { struct { float x; } x; };
2981 struct { struct { struct { float x; } x; } x; };
2983 However, if an inner type is smaller than MIN_SIZE, abort the
2986 static struct type
*
2987 s390_effective_inner_type (struct type
*type
, unsigned int min_size
)
2989 while (TYPE_CODE (type
) == TYPE_CODE_STRUCT
2990 && TYPE_NFIELDS (type
) == 1)
2992 struct type
*inner
= check_typedef (TYPE_FIELD_TYPE (type
, 0));
2994 if (TYPE_LENGTH (inner
) < min_size
)
3002 /* Return non-zero if TYPE should be passed like "float" or
3006 s390_function_arg_float (struct type
*type
)
3008 /* Note that long double as well as complex types are intentionally
3010 if (TYPE_LENGTH (type
) > 8)
3013 /* A struct containing just a float or double is passed like a float
3015 type
= s390_effective_inner_type (type
, 0);
3017 return (TYPE_CODE (type
) == TYPE_CODE_FLT
3018 || TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
);
3021 /* Return non-zero if TYPE should be passed like a vector. */
3024 s390_function_arg_vector (struct type
*type
)
3026 if (TYPE_LENGTH (type
) > 16)
3029 /* Structs containing just a vector are passed like a vector. */
3030 type
= s390_effective_inner_type (type
, TYPE_LENGTH (type
));
3032 return TYPE_CODE (type
) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (type
);
3035 /* Determine whether N is a power of two. */
3038 is_power_of_two (unsigned int n
)
3040 return n
&& ((n
& (n
- 1)) == 0);
3043 /* For an argument whose type is TYPE and which is not passed like a
3044 float or vector, return non-zero if it should be passed like "int"
3048 s390_function_arg_integer (struct type
*type
)
3050 enum type_code code
= TYPE_CODE (type
);
3052 if (TYPE_LENGTH (type
) > 8)
3055 if (code
== TYPE_CODE_INT
3056 || code
== TYPE_CODE_ENUM
3057 || code
== TYPE_CODE_RANGE
3058 || code
== TYPE_CODE_CHAR
3059 || code
== TYPE_CODE_BOOL
3060 || code
== TYPE_CODE_PTR
3061 || code
== TYPE_CODE_REF
)
3064 return ((code
== TYPE_CODE_UNION
|| code
== TYPE_CODE_STRUCT
)
3065 && is_power_of_two (TYPE_LENGTH (type
)));
3068 /* Argument passing state: Internal data structure passed to helper
3069 routines of s390_push_dummy_call. */
3071 struct s390_arg_state
3073 /* Register cache, or NULL, if we are in "preparation mode". */
3074 struct regcache
*regcache
;
3075 /* Next available general/floating-point/vector register for
3076 argument passing. */
3078 /* Current pointer to copy area (grows downwards). */
3080 /* Current pointer to parameter area (grows upwards). */
3084 /* Prepare one argument ARG for a dummy call and update the argument
3085 passing state AS accordingly. If the regcache field in AS is set,
3086 operate in "write mode" and write ARG into the inferior. Otherwise
3087 run "preparation mode" and skip all updates to the inferior. */
3090 s390_handle_arg (struct s390_arg_state
*as
, struct value
*arg
,
3091 struct gdbarch_tdep
*tdep
, int word_size
,
3092 enum bfd_endian byte_order
, int is_unnamed
)
3094 struct type
*type
= check_typedef (value_type (arg
));
3095 unsigned int length
= TYPE_LENGTH (type
);
3096 int write_mode
= as
->regcache
!= NULL
;
3098 if (s390_function_arg_float (type
))
3100 /* The GNU/Linux for S/390 ABI uses FPRs 0 and 2 to pass
3101 arguments. The GNU/Linux for zSeries ABI uses 0, 2, 4, and
3103 if (as
->fr
<= (tdep
->abi
== ABI_LINUX_S390
? 2 : 6))
3105 /* When we store a single-precision value in an FP register,
3106 it occupies the leftmost bits. */
3108 regcache_cooked_write_part (as
->regcache
,
3109 S390_F0_REGNUM
+ as
->fr
,
3111 value_contents (arg
));
3116 /* When we store a single-precision value in a stack slot,
3117 it occupies the rightmost bits. */
3118 as
->argp
= align_up (as
->argp
+ length
, word_size
);
3120 write_memory (as
->argp
- length
, value_contents (arg
),
3124 else if (tdep
->vector_abi
== S390_VECTOR_ABI_128
3125 && s390_function_arg_vector (type
))
3127 static const char use_vr
[] = {24, 26, 28, 30, 25, 27, 29, 31};
3129 if (!is_unnamed
&& as
->vr
< ARRAY_SIZE (use_vr
))
3131 int regnum
= S390_V24_REGNUM
+ use_vr
[as
->vr
] - 24;
3134 regcache_cooked_write_part (as
->regcache
, regnum
,
3136 value_contents (arg
));
3142 write_memory (as
->argp
, value_contents (arg
), length
);
3143 as
->argp
= align_up (as
->argp
+ length
, word_size
);
3146 else if (s390_function_arg_integer (type
) && length
<= word_size
)
3148 /* Initialize it just to avoid a GCC false warning. */
3153 /* Place value in least significant bits of the register or
3154 memory word and sign- or zero-extend to full word size.
3155 This also applies to a struct or union. */
3156 val
= TYPE_UNSIGNED (type
)
3157 ? extract_unsigned_integer (value_contents (arg
),
3159 : extract_signed_integer (value_contents (arg
),
3160 length
, byte_order
);
3166 regcache_cooked_write_unsigned (as
->regcache
,
3167 S390_R0_REGNUM
+ as
->gr
,
3174 write_memory_unsigned_integer (as
->argp
, word_size
,
3176 as
->argp
+= word_size
;
3179 else if (s390_function_arg_integer (type
) && length
== 8)
3185 regcache_cooked_write (as
->regcache
,
3186 S390_R0_REGNUM
+ as
->gr
,
3187 value_contents (arg
));
3188 regcache_cooked_write (as
->regcache
,
3189 S390_R0_REGNUM
+ as
->gr
+ 1,
3190 value_contents (arg
) + word_size
);
3196 /* If we skipped r6 because we couldn't fit a DOUBLE_ARG
3197 in it, then don't go back and use it again later. */
3201 write_memory (as
->argp
, value_contents (arg
), length
);
3207 /* This argument type is never passed in registers. Place the
3208 value in the copy area and pass a pointer to it. Use 8-byte
3209 alignment as a conservative assumption. */
3210 as
->copy
= align_down (as
->copy
- length
, 8);
3212 write_memory (as
->copy
, value_contents (arg
), length
);
3217 regcache_cooked_write_unsigned (as
->regcache
,
3218 S390_R0_REGNUM
+ as
->gr
,
3225 write_memory_unsigned_integer (as
->argp
, word_size
,
3226 byte_order
, as
->copy
);
3227 as
->argp
+= word_size
;
3232 /* Put the actual parameter values pointed to by ARGS[0..NARGS-1] in
3233 place to be passed to a function, as specified by the "GNU/Linux
3234 for S/390 ELF Application Binary Interface Supplement".
3236 SP is the current stack pointer. We must put arguments, links,
3237 padding, etc. whereever they belong, and return the new stack
3240 If STRUCT_RETURN is non-zero, then the function we're calling is
3241 going to return a structure by value; STRUCT_ADDR is the address of
3242 a block we've allocated for it on the stack.
3244 Our caller has taken care of any type promotions needed to satisfy
3245 prototypes or the old K&R argument-passing rules. */
3248 s390_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
3249 struct regcache
*regcache
, CORE_ADDR bp_addr
,
3250 int nargs
, struct value
**args
, CORE_ADDR sp
,
3251 int struct_return
, CORE_ADDR struct_addr
)
3253 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
3254 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
3255 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
3257 struct s390_arg_state arg_state
, arg_prep
;
3258 CORE_ADDR param_area_start
, new_sp
;
3259 struct type
*ftype
= check_typedef (value_type (function
));
3261 if (TYPE_CODE (ftype
) == TYPE_CODE_PTR
)
3262 ftype
= check_typedef (TYPE_TARGET_TYPE (ftype
));
3265 arg_prep
.gr
= struct_return
? 3 : 2;
3269 arg_prep
.regcache
= NULL
;
3271 /* Initialize arg_state for "preparation mode". */
3272 arg_state
= arg_prep
;
3274 /* Update arg_state.copy with the start of the reference-to-copy area
3275 and arg_state.argp with the size of the parameter area. */
3276 for (i
= 0; i
< nargs
; i
++)
3277 s390_handle_arg (&arg_state
, args
[i
], tdep
, word_size
, byte_order
,
3278 TYPE_VARARGS (ftype
) && i
>= TYPE_NFIELDS (ftype
));
3280 param_area_start
= align_down (arg_state
.copy
- arg_state
.argp
, 8);
3282 /* Allocate the standard frame areas: the register save area, the
3283 word reserved for the compiler, and the back chain pointer. */
3284 new_sp
= param_area_start
- (16 * word_size
+ 32);
3286 /* Now we have the final stack pointer. Make sure we didn't
3287 underflow; on 31-bit, this would result in addresses with the
3288 high bit set, which causes confusion elsewhere. Note that if we
3289 error out here, stack and registers remain untouched. */
3290 if (gdbarch_addr_bits_remove (gdbarch
, new_sp
) != new_sp
)
3291 error (_("Stack overflow"));
3293 /* Pass the structure return address in general register 2. */
3295 regcache_cooked_write_unsigned (regcache
, S390_R2_REGNUM
, struct_addr
);
3297 /* Initialize arg_state for "write mode". */
3298 arg_state
= arg_prep
;
3299 arg_state
.argp
= param_area_start
;
3300 arg_state
.regcache
= regcache
;
3302 /* Write all parameters. */
3303 for (i
= 0; i
< nargs
; i
++)
3304 s390_handle_arg (&arg_state
, args
[i
], tdep
, word_size
, byte_order
,
3305 TYPE_VARARGS (ftype
) && i
>= TYPE_NFIELDS (ftype
));
3307 /* Store return PSWA. In 31-bit mode, keep addressing mode bit. */
3311 regcache_cooked_read_unsigned (regcache
, S390_PSWA_REGNUM
, &pswa
);
3312 bp_addr
= (bp_addr
& 0x7fffffff) | (pswa
& 0x80000000);
3314 regcache_cooked_write_unsigned (regcache
, S390_RETADDR_REGNUM
, bp_addr
);
3316 /* Store updated stack pointer. */
3317 regcache_cooked_write_unsigned (regcache
, S390_SP_REGNUM
, new_sp
);
3319 /* We need to return the 'stack part' of the frame ID,
3320 which is actually the top of the register save area. */
3321 return param_area_start
;
3324 /* Assuming THIS_FRAME is a dummy, return the frame ID of that
3325 dummy frame. The frame ID's base needs to match the TOS value
3326 returned by push_dummy_call, and the PC match the dummy frame's
3328 static struct frame_id
3329 s390_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*this_frame
)
3331 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
3332 CORE_ADDR sp
= get_frame_register_unsigned (this_frame
, S390_SP_REGNUM
);
3333 sp
= gdbarch_addr_bits_remove (gdbarch
, sp
);
3335 return frame_id_build (sp
+ 16*word_size
+ 32,
3336 get_frame_pc (this_frame
));
3340 s390_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
3342 /* Both the 32- and 64-bit ABI's say that the stack pointer should
3343 always be aligned on an eight-byte boundary. */
3348 /* Helper for s390_return_value: Set or retrieve a function return
3349 value if it resides in a register. */
3352 s390_register_return_value (struct gdbarch
*gdbarch
, struct type
*type
,
3353 struct regcache
*regcache
,
3354 gdb_byte
*out
, const gdb_byte
*in
)
3356 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
3357 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
3358 int length
= TYPE_LENGTH (type
);
3359 int code
= TYPE_CODE (type
);
3361 if (code
== TYPE_CODE_FLT
|| code
== TYPE_CODE_DECFLOAT
)
3363 /* Float-like value: left-aligned in f0. */
3365 regcache_cooked_write_part (regcache
, S390_F0_REGNUM
,
3368 regcache_cooked_read_part (regcache
, S390_F0_REGNUM
,
3371 else if (code
== TYPE_CODE_ARRAY
)
3373 /* Vector: left-aligned in v24. */
3375 regcache_cooked_write_part (regcache
, S390_V24_REGNUM
,
3378 regcache_cooked_read_part (regcache
, S390_V24_REGNUM
,
3381 else if (length
<= word_size
)
3383 /* Integer: zero- or sign-extended in r2. */
3385 regcache_cooked_read_part (regcache
, S390_R2_REGNUM
,
3386 word_size
- length
, length
, out
);
3387 else if (TYPE_UNSIGNED (type
))
3388 regcache_cooked_write_unsigned
3389 (regcache
, S390_R2_REGNUM
,
3390 extract_unsigned_integer (in
, length
, byte_order
));
3392 regcache_cooked_write_signed
3393 (regcache
, S390_R2_REGNUM
,
3394 extract_signed_integer (in
, length
, byte_order
));
3396 else if (length
== 2 * word_size
)
3398 /* Double word: in r2 and r3. */
3401 regcache_cooked_write (regcache
, S390_R2_REGNUM
, in
);
3402 regcache_cooked_write (regcache
, S390_R3_REGNUM
,
3407 regcache_cooked_read (regcache
, S390_R2_REGNUM
, out
);
3408 regcache_cooked_read (regcache
, S390_R3_REGNUM
,
3413 internal_error (__FILE__
, __LINE__
, _("invalid return type"));
3417 /* Implement the 'return_value' gdbarch method. */
3419 static enum return_value_convention
3420 s390_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
3421 struct type
*type
, struct regcache
*regcache
,
3422 gdb_byte
*out
, const gdb_byte
*in
)
3424 enum return_value_convention rvc
;
3426 type
= check_typedef (type
);
3428 switch (TYPE_CODE (type
))
3430 case TYPE_CODE_STRUCT
:
3431 case TYPE_CODE_UNION
:
3432 case TYPE_CODE_COMPLEX
:
3433 rvc
= RETURN_VALUE_STRUCT_CONVENTION
;
3435 case TYPE_CODE_ARRAY
:
3436 rvc
= (gdbarch_tdep (gdbarch
)->vector_abi
== S390_VECTOR_ABI_128
3437 && TYPE_LENGTH (type
) <= 16 && TYPE_VECTOR (type
))
3438 ? RETURN_VALUE_REGISTER_CONVENTION
3439 : RETURN_VALUE_STRUCT_CONVENTION
;
3442 rvc
= TYPE_LENGTH (type
) <= 8
3443 ? RETURN_VALUE_REGISTER_CONVENTION
3444 : RETURN_VALUE_STRUCT_CONVENTION
;
3447 if (in
!= NULL
|| out
!= NULL
)
3449 if (rvc
== RETURN_VALUE_REGISTER_CONVENTION
)
3450 s390_register_return_value (gdbarch
, type
, regcache
, out
, in
);
3451 else if (in
!= NULL
)
3452 error (_("Cannot set function return value."));
3454 error (_("Function return value unknown."));
3463 static const gdb_byte
*
3464 s390_breakpoint_from_pc (struct gdbarch
*gdbarch
,
3465 CORE_ADDR
*pcptr
, int *lenptr
)
3467 static const gdb_byte breakpoint
[] = { 0x0, 0x1 };
3469 *lenptr
= sizeof (breakpoint
);
3474 /* Address handling. */
3477 s390_addr_bits_remove (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
3479 return addr
& 0x7fffffff;
3483 s390_address_class_type_flags (int byte_size
, int dwarf2_addr_class
)
3486 return TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1
;
3492 s390_address_class_type_flags_to_name (struct gdbarch
*gdbarch
, int type_flags
)
3494 if (type_flags
& TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1
)
3501 s390_address_class_name_to_type_flags (struct gdbarch
*gdbarch
,
3503 int *type_flags_ptr
)
3505 if (strcmp (name
, "mode32") == 0)
3507 *type_flags_ptr
= TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1
;
3514 /* Implement gdbarch_gcc_target_options. GCC does not know "-m32" or
3515 "-mcmodel=large". */
3518 s390_gcc_target_options (struct gdbarch
*gdbarch
)
3520 return xstrdup (gdbarch_ptr_bit (gdbarch
) == 64 ? "-m64" : "-m31");
3523 /* Implement gdbarch_gnu_triplet_regexp. Target triplets are "s390-*"
3524 for 31-bit and "s390x-*" for 64-bit, while the BFD arch name is
3525 always "s390". Note that an s390x compiler supports "-m31" as
3529 s390_gnu_triplet_regexp (struct gdbarch
*gdbarch
)
3534 /* Implementation of `gdbarch_stap_is_single_operand', as defined in
3538 s390_stap_is_single_operand (struct gdbarch
*gdbarch
, const char *s
)
3540 return ((isdigit (*s
) && s
[1] == '(' && s
[2] == '%') /* Displacement
3542 || *s
== '%' /* Register access. */
3543 || isdigit (*s
)); /* Literal number. */
3546 /* Process record and replay helpers. */
3548 /* Takes the intermediate sum of address calculations and masks off upper
3549 bits according to current addressing mode. */
3552 s390_record_address_mask (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
3554 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
3555 ULONGEST pswm
, pswa
;
3557 if (tdep
->abi
== ABI_LINUX_S390
)
3559 regcache_raw_read_unsigned (regcache
, S390_PSWA_REGNUM
, &pswa
);
3560 am
= pswa
>> 31 & 1;
3564 regcache_raw_read_unsigned (regcache
, S390_PSWM_REGNUM
, &pswm
);
3565 am
= pswm
>> 31 & 3;
3570 return val
& 0xffffff;
3572 return val
& 0x7fffffff;
3576 fprintf_unfiltered (gdb_stdlog
, "Warning: Addressing mode %d used.", am
);
3581 /* Calculates memory address using pre-calculated index, raw instruction word
3582 with b and d/dl fields, and raw instruction byte with dh field. Index and
3583 dh should be set to 0 if unused. */
3586 s390_record_calc_disp_common (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
3587 ULONGEST x
, uint16_t bd
, int8_t dh
)
3589 uint8_t rb
= bd
>> 12 & 0xf;
3590 int32_t d
= (bd
& 0xfff) | ((int32_t)dh
<< 12);
3592 CORE_ADDR res
= d
+ x
;
3595 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ rb
, &b
);
3598 return s390_record_address_mask (gdbarch
, regcache
, res
);
3601 /* Calculates memory address using raw x, b + d/dl, dh fields from
3602 instruction. rx and dh should be set to 0 if unused. */
3605 s390_record_calc_disp (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
3606 uint8_t rx
, uint16_t bd
, int8_t dh
)
3610 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ rx
, &x
);
3611 return s390_record_calc_disp_common (gdbarch
, regcache
, x
, bd
, dh
);
3614 /* Calculates memory address for VSCE[GF] instructions. */
3617 s390_record_calc_disp_vsce (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
3618 uint8_t vx
, uint8_t el
, uint8_t es
, uint16_t bd
,
3619 int8_t dh
, CORE_ADDR
*res
)
3621 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
3622 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
3625 if (tdep
->v0_full_regnum
== -1 || el
* es
>= 16)
3628 regcache_cooked_read (regcache
, tdep
->v0_full_regnum
+ vx
, buf
);
3630 regcache_raw_read (regcache
, S390_V16_REGNUM
+ vx
- 16, buf
);
3631 x
= extract_unsigned_integer (buf
+ el
* es
, es
, byte_order
);
3632 *res
= s390_record_calc_disp_common (gdbarch
, regcache
, x
, bd
, dh
);
3636 /* Calculates memory address for instructions with relative long addressing. */
3639 s390_record_calc_rl (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
3640 CORE_ADDR addr
, uint16_t i1
, uint16_t i2
)
3642 int32_t ri
= i1
<< 16 | i2
;
3643 return s390_record_address_mask (gdbarch
, regcache
, addr
+ (LONGEST
)ri
* 2);
3646 /* Population count helper. */
3648 static int s390_popcnt (unsigned int x
) {
3659 /* Record 64-bit register. */
3662 s390_record_gpr_g (struct gdbarch
*gdbarch
, struct regcache
*regcache
, int i
)
3664 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
3665 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ i
))
3667 if (tdep
->abi
== ABI_LINUX_S390
)
3668 if (record_full_arch_list_add_reg (regcache
, S390_R0_UPPER_REGNUM
+ i
))
3673 /* Record high 32 bits of a register. */
3676 s390_record_gpr_h (struct gdbarch
*gdbarch
, struct regcache
*regcache
, int i
)
3678 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
3679 if (tdep
->abi
== ABI_LINUX_S390
)
3681 if (record_full_arch_list_add_reg (regcache
, S390_R0_UPPER_REGNUM
+ i
))
3686 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ i
))
3692 /* Record vector register. */
3695 s390_record_vr (struct gdbarch
*gdbarch
, struct regcache
*regcache
, int i
)
3697 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
3700 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ i
))
3702 if (record_full_arch_list_add_reg (regcache
, S390_V0_LOWER_REGNUM
+ i
))
3707 if (record_full_arch_list_add_reg (regcache
, S390_V16_REGNUM
+ i
- 16))
3714 s390_process_record (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
3717 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
3718 uint16_t insn
[3] = {0};
3719 /* Instruction as bytes. */
3721 /* Instruction as nibbles. */
3723 /* Instruction vector registers. */
3725 CORE_ADDR oaddr
, oaddr2
, oaddr3
;
3728 /* if EX/EXRL instruction used, here's the reg parameter */
3730 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
3732 /* Attempting to use EX or EXRL jumps back here */
3735 /* Read instruction. */
3736 insn
[0] = read_memory_unsigned_integer (addr
, 2, byte_order
);
3737 /* If execute was involved, do the adjustment. */
3739 insn
[0] |= ex
& 0xff;
3740 /* Two highest bits determine instruction size. */
3741 if (insn
[0] >= 0x4000)
3742 insn
[1] = read_memory_unsigned_integer (addr
+2, 2, byte_order
);
3744 /* Not necessary, but avoids uninitialized variable warnings. */
3746 if (insn
[0] >= 0xc000)
3747 insn
[2] = read_memory_unsigned_integer (addr
+4, 2, byte_order
);
3750 /* Split instruction into bytes and nibbles. */
3751 for (i
= 0; i
< 3; i
++)
3753 ibyte
[i
*2] = insn
[i
] >> 8 & 0xff;
3754 ibyte
[i
*2+1] = insn
[i
] & 0xff;
3756 for (i
= 0; i
< 6; i
++)
3758 inib
[i
*2] = ibyte
[i
] >> 4 & 0xf;
3759 inib
[i
*2+1] = ibyte
[i
] & 0xf;
3761 /* Compute vector registers, if applicable. */
3762 ivec
[0] = (inib
[9] >> 3 & 1) << 4 | inib
[2];
3763 ivec
[1] = (inib
[9] >> 2 & 1) << 4 | inib
[3];
3764 ivec
[2] = (inib
[9] >> 1 & 1) << 4 | inib
[4];
3765 ivec
[3] = (inib
[9] >> 0 & 1) << 4 | inib
[8];
3769 /* 0x00 undefined */
3772 /* E-format instruction */
3775 /* 0x00 undefined */
3776 /* 0x01 unsupported: PR - program return */
3777 /* 0x02 unsupported: UPT */
3778 /* 0x03 undefined */
3779 /* 0x04 privileged: PTFF - perform timing facility function */
3780 /* 0x05-0x06 undefined */
3781 /* 0x07 privileged: SCKPF - set clock programmable field */
3782 /* 0x08-0x09 undefined */
3784 case 0x0a: /* PFPO - perform floating point operation */
3785 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
, &tmp
);
3786 if (!(tmp
& 0x80000000u
))
3788 uint8_t ofc
= tmp
>> 16 & 0xff;
3791 case 0x00: /* HFP32 */
3792 case 0x01: /* HFP64 */
3793 case 0x05: /* BFP32 */
3794 case 0x06: /* BFP64 */
3795 case 0x08: /* DFP32 */
3796 case 0x09: /* DFP64 */
3797 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
))
3800 case 0x02: /* HFP128 */
3801 case 0x07: /* BFP128 */
3802 case 0x0a: /* DFP128 */
3803 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
))
3805 if (record_full_arch_list_add_reg (regcache
, S390_F2_REGNUM
))
3809 fprintf_unfiltered (gdb_stdlog
, "Warning: Unknown PFPO OFC %02x at %s.\n",
3810 ofc
, paddress (gdbarch
, addr
));
3814 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
3817 if (record_full_arch_list_add_reg (regcache
, S390_R1_REGNUM
))
3819 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3823 case 0x0b: /* TAM - test address mode */
3824 case 0x0c: /* SAM24 - set address mode 24 */
3825 case 0x0d: /* SAM31 - set address mode 31 */
3826 case 0x0e: /* SAM64 - set address mode 64 */
3827 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3831 /* 0x0f-0xfe undefined */
3833 /* 0xff unsupported: TRAP */
3840 /* 0x02 undefined */
3841 /* 0x03 undefined */
3843 case 0x04: /* SPM - set program mask */
3844 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3848 case 0x05: /* BALR - branch and link */
3849 case 0x45: /* BAL - branch and link */
3850 case 0x06: /* BCTR - branch on count */
3851 case 0x46: /* BCT - branch on count */
3852 case 0x0d: /* BASR - branch and save */
3853 case 0x4d: /* BAS - branch and save */
3854 case 0x84: /* BRXH - branch relative on index high */
3855 case 0x85: /* BRXLE - branch relative on index low or equal */
3856 case 0x86: /* BXH - branch on index high */
3857 case 0x87: /* BXLE - branch on index low or equal */
3858 /* BA[SL]* use native-size destination for linkage info, BCT*, BRX*, BX*
3859 use 32-bit destination as counter. */
3860 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
3864 case 0x07: /* BCR - branch on condition */
3865 case 0x47: /* BC - branch on condition */
3866 /* No effect other than PC transfer. */
3869 /* 0x08 undefined */
3870 /* 0x09 undefined */
3873 /* SVC - supervisor call */
3874 if (s390_linux_syscall_record (regcache
, ibyte
[1]))
3878 case 0x0b: /* BSM - branch and set mode */
3880 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
3882 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3886 case 0x0c: /* BASSM - branch and save and set mode */
3887 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
3889 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3893 case 0x0e: /* MVCL - move long [interruptible] */
3894 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ inib
[2], &tmp
);
3895 oaddr
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
3896 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ (inib
[2] | 1), &tmp
);
3898 if (record_full_arch_list_add_mem (oaddr
, tmp
))
3900 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
3902 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[2] | 1)))
3904 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[3]))
3906 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[3] | 1)))
3908 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3912 case 0x0f: /* CLCL - compare logical long [interruptible] */
3913 case 0xa9: /* CLCLE - compare logical long extended [partial] */
3914 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
3916 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[2] | 1)))
3918 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[3]))
3920 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[3] | 1)))
3922 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3926 case 0x10: /* LPR - load positive */
3927 case 0x11: /* LNR - load negative */
3928 case 0x12: /* LTR - load and test */
3929 case 0x13: /* LCR - load complement */
3930 case 0x14: /* NR - and */
3931 case 0x16: /* OR - or */
3932 case 0x17: /* XR - xor */
3933 case 0x1a: /* AR - add */
3934 case 0x1b: /* SR - subtract */
3935 case 0x1e: /* ALR - add logical */
3936 case 0x1f: /* SLR - subtract logical */
3937 case 0x54: /* N - and */
3938 case 0x56: /* O - or */
3939 case 0x57: /* X - xor */
3940 case 0x5a: /* A - add */
3941 case 0x5b: /* S - subtract */
3942 case 0x5e: /* AL - add logical */
3943 case 0x5f: /* SL - subtract logical */
3944 case 0x4a: /* AH - add halfword */
3945 case 0x4b: /* SH - subtract halfword */
3946 case 0x8a: /* SRA - shift right single */
3947 case 0x8b: /* SLA - shift left single */
3948 case 0xbf: /* ICM - insert characters under mask */
3949 /* 32-bit destination + flags */
3950 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
3952 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3956 case 0x15: /* CLR - compare logical */
3957 case 0x55: /* CL - compare logical */
3958 case 0x19: /* CR - compare */
3959 case 0x29: /* CDR - compare */
3960 case 0x39: /* CER - compare */
3961 case 0x49: /* CH - compare halfword */
3962 case 0x59: /* C - compare */
3963 case 0x69: /* CD - compare */
3964 case 0x79: /* CE - compare */
3965 case 0x91: /* TM - test under mask */
3966 case 0x95: /* CLI - compare logical */
3967 case 0xbd: /* CLM - compare logical under mask */
3968 case 0xd5: /* CLC - compare logical */
3969 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
3973 case 0x18: /* LR - load */
3974 case 0x48: /* LH - load halfword */
3975 case 0x58: /* L - load */
3976 case 0x41: /* LA - load address */
3977 case 0x43: /* IC - insert character */
3978 case 0x4c: /* MH - multiply halfword */
3979 case 0x71: /* MS - multiply single */
3980 case 0x88: /* SRL - shift right single logical */
3981 case 0x89: /* SLL - shift left single logical */
3982 /* 32-bit, 8-bit (IC), or native width (LA) destination, no flags */
3983 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
3987 case 0x1c: /* MR - multiply */
3988 case 0x5c: /* M - multiply */
3989 case 0x1d: /* DR - divide */
3990 case 0x5d: /* D - divide */
3991 case 0x8c: /* SRDL - shift right double logical */
3992 case 0x8d: /* SLDL - shift left double logical */
3993 /* 32-bit pair destination, no flags */
3994 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
3996 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[2] | 1)))
4000 case 0x20: /* LPDR - load positive */
4001 case 0x30: /* LPER - load positive */
4002 case 0x21: /* LNDR - load negative */
4003 case 0x31: /* LNER - load negative */
4004 case 0x22: /* LTDR - load and test */
4005 case 0x32: /* LTER - load and test */
4006 case 0x23: /* LCDR - load complement */
4007 case 0x33: /* LCER - load complement */
4008 case 0x2a: /* ADR - add */
4009 case 0x3a: /* AER - add */
4010 case 0x6a: /* AD - add */
4011 case 0x7a: /* AE - add */
4012 case 0x2b: /* SDR - subtract */
4013 case 0x3b: /* SER - subtract */
4014 case 0x6b: /* SD - subtract */
4015 case 0x7b: /* SE - subtract */
4016 case 0x2e: /* AWR - add unnormalized */
4017 case 0x3e: /* AUR - add unnormalized */
4018 case 0x6e: /* AW - add unnormalized */
4019 case 0x7e: /* AU - add unnormalized */
4020 case 0x2f: /* SWR - subtract unnormalized */
4021 case 0x3f: /* SUR - subtract unnormalized */
4022 case 0x6f: /* SW - subtract unnormalized */
4023 case 0x7f: /* SU - subtract unnormalized */
4024 /* float destination + flags */
4025 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[2]))
4027 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4031 case 0x24: /* HDR - halve */
4032 case 0x34: /* HER - halve */
4033 case 0x25: /* LDXR - load rounded */
4034 case 0x35: /* LEDR - load rounded */
4035 case 0x28: /* LDR - load */
4036 case 0x38: /* LER - load */
4037 case 0x68: /* LD - load */
4038 case 0x78: /* LE - load */
4039 case 0x2c: /* MDR - multiply */
4040 case 0x3c: /* MDER - multiply */
4041 case 0x6c: /* MD - multiply */
4042 case 0x7c: /* MDE - multiply */
4043 case 0x2d: /* DDR - divide */
4044 case 0x3d: /* DER - divide */
4045 case 0x6d: /* DD - divide */
4046 case 0x7d: /* DE - divide */
4047 /* float destination, no flags */
4048 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[2]))
4052 case 0x26: /* MXR - multiply */
4053 case 0x27: /* MXDR - multiply */
4054 case 0x67: /* MXD - multiply */
4055 /* float pair destination, no flags */
4056 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[2]))
4058 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ (inib
[2] | 2)))
4062 case 0x36: /* AXR - add */
4063 case 0x37: /* SXR - subtract */
4064 /* float pair destination + flags */
4065 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[2]))
4067 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ (inib
[2] | 2)))
4069 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4073 case 0x40: /* STH - store halfword */
4074 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, inib
[3], insn
[1], 0);
4075 if (record_full_arch_list_add_mem (oaddr
, 2))
4079 case 0x42: /* STC - store character */
4080 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, inib
[3], insn
[1], 0);
4081 if (record_full_arch_list_add_mem (oaddr
, 1))
4085 case 0x44: /* EX - execute */
4088 fprintf_unfiltered (gdb_stdlog
, "Warning: Double execute at %s.\n",
4089 paddress (gdbarch
, addr
));
4092 addr
= s390_record_calc_disp (gdbarch
, regcache
, inib
[3], insn
[1], 0);
4095 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ inib
[2], &tmp
);
4104 case 0x4e: /* CVD - convert to decimal */
4105 case 0x60: /* STD - store */
4106 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, inib
[3], insn
[1], 0);
4107 if (record_full_arch_list_add_mem (oaddr
, 8))
4111 case 0x4f: /* CVB - convert to binary */
4112 /* 32-bit gpr destination + FPC (DXC write) */
4113 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
4115 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
4119 case 0x50: /* ST - store */
4120 case 0x70: /* STE - store */
4121 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, inib
[3], insn
[1], 0);
4122 if (record_full_arch_list_add_mem (oaddr
, 4))
4126 case 0x51: /* LAE - load address extended */
4127 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
4129 if (record_full_arch_list_add_reg (regcache
, S390_A0_REGNUM
+ inib
[2]))
4133 /* 0x52 undefined */
4134 /* 0x53 undefined */
4136 /* 0x61-0x66 undefined */
4138 /* 0x72-0x77 undefined */
4140 /* 0x80 privileged: SSM - set system mask */
4141 /* 0x81 undefined */
4142 /* 0x82 privileged: LPSW - load PSW */
4143 /* 0x83 privileged: diagnose */
4145 case 0x8e: /* SRDA - shift right double */
4146 case 0x8f: /* SLDA - shift left double */
4147 /* 32-bit pair destination + flags */
4148 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
4150 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[2] | 1)))
4152 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4156 case 0x90: /* STM - store multiple */
4157 case 0x9b: /* STAM - store access multiple */
4158 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
4159 if (inib
[2] <= inib
[3])
4160 n
= inib
[3] - inib
[2] + 1;
4162 n
= inib
[3] + 0x10 - inib
[2] + 1;
4163 if (record_full_arch_list_add_mem (oaddr
, n
* 4))
4167 case 0x92: /* MVI - move */
4168 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
4169 if (record_full_arch_list_add_mem (oaddr
, 1))
4173 case 0x93: /* TS - test and set */
4174 case 0x94: /* NI - and */
4175 case 0x96: /* OI - or */
4176 case 0x97: /* XI - xor */
4177 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
4178 if (record_full_arch_list_add_mem (oaddr
, 1))
4180 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4184 case 0x98: /* LM - load multiple */
4185 for (i
= inib
[2]; i
!= inib
[3]; i
++, i
&= 0xf)
4186 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ i
))
4188 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[3]))
4192 /* 0x99 privileged: TRACE */
4194 case 0x9a: /* LAM - load access multiple */
4195 for (i
= inib
[2]; i
!= inib
[3]; i
++, i
&= 0xf)
4196 if (record_full_arch_list_add_reg (regcache
, S390_A0_REGNUM
+ i
))
4198 if (record_full_arch_list_add_reg (regcache
, S390_A0_REGNUM
+ inib
[3]))
4202 /* 0x9c-0x9f privileged and obsolete (old I/O) */
4203 /* 0xa0-0xa4 undefined */
4207 /* RI-format instruction */
4208 switch (ibyte
[0] << 4 | inib
[3])
4210 case 0xa50: /* IIHH - insert immediate */
4211 case 0xa51: /* IIHL - insert immediate */
4212 /* high 32-bit destination */
4213 if (s390_record_gpr_h (gdbarch
, regcache
, inib
[2]))
4217 case 0xa52: /* IILH - insert immediate */
4218 case 0xa53: /* IILL - insert immediate */
4219 case 0xa75: /* BRAS - branch relative and save */
4220 case 0xa76: /* BRCT - branch relative on count */
4221 case 0xa78: /* LHI - load halfword immediate */
4222 case 0xa7c: /* MHI - multiply halfword immediate */
4223 /* 32-bit or native destination */
4224 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
4228 case 0xa54: /* NIHH - and immediate */
4229 case 0xa55: /* NIHL - and immediate */
4230 case 0xa58: /* OIHH - or immediate */
4231 case 0xa59: /* OIHL - or immediate */
4232 /* high 32-bit destination + flags */
4233 if (s390_record_gpr_h (gdbarch
, regcache
, inib
[2]))
4235 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4239 case 0xa56: /* NILH - and immediate */
4240 case 0xa57: /* NILL - and immediate */
4241 case 0xa5a: /* OILH - or immediate */
4242 case 0xa5b: /* OILL - or immediate */
4243 case 0xa7a: /* AHI - add halfword immediate */
4244 /* 32-bit destination + flags */
4245 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
4247 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4251 case 0xa5c: /* LLIHH - load logical immediate */
4252 case 0xa5d: /* LLIHL - load logical immediate */
4253 case 0xa5e: /* LLILH - load logical immediate */
4254 case 0xa5f: /* LLILL - load logical immediate */
4255 case 0xa77: /* BRCTG - branch relative on count */
4256 case 0xa79: /* LGHI - load halfword immediate */
4257 case 0xa7d: /* MGHI - multiply halfword immediate */
4258 /* 64-bit destination */
4259 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
4263 case 0xa70: /* TMLH - test under mask */
4264 case 0xa71: /* TMLL - test under mask */
4265 case 0xa72: /* TMHH - test under mask */
4266 case 0xa73: /* TMHL - test under mask */
4267 case 0xa7e: /* CHI - compare halfword immediate */
4268 case 0xa7f: /* CGHI - compare halfword immediate */
4270 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4274 case 0xa74: /* BRC - branch relative on condition */
4275 /* no register change */
4278 case 0xa7b: /* AGHI - add halfword immediate */
4279 /* 64-bit destination + flags */
4280 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
4282 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4291 /* 0xa6 undefined */
4293 case 0xa8: /* MVCLE - move long extended [partial] */
4294 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ inib
[2], &tmp
);
4295 oaddr
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
4296 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ (inib
[2] | 1), &tmp
);
4297 if (record_full_arch_list_add_mem (oaddr
, tmp
))
4299 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
4301 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[2] | 1)))
4303 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[3]))
4305 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[3] | 1)))
4307 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4311 /* 0xaa-0xab undefined */
4312 /* 0xac privileged: STNSM - store then and system mask */
4313 /* 0xad privileged: STOSM - store then or system mask */
4314 /* 0xae privileged: SIGP - signal processor */
4315 /* 0xaf unsupported: MC - monitor call */
4316 /* 0xb0 undefined */
4317 /* 0xb1 privileged: LRA - load real address */
4322 /* S/RRD/RRE/RRF/IE-format instruction */
4325 /* 0xb200-0xb204 undefined or privileged */
4327 case 0xb205: /* STCK - store clock */
4328 case 0xb27c: /* STCKF - store clock fast */
4329 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
4330 if (record_full_arch_list_add_mem (oaddr
, 8))
4332 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4336 /* 0xb206-0xb219 undefined, privileged, or unsupported */
4337 /* 0xb21a unsupported: CFC */
4338 /* 0xb21b-0xb221 undefined or privileged */
4340 case 0xb222: /* IPM - insert program mask */
4341 case 0xb24f: /* EAR - extract access */
4342 case 0xb252: /* MSR - multiply single */
4343 case 0xb2ec: /* ETND - extract transaction nesting depth */
4344 case 0xb38c: /* EFPC - extract fpc */
4345 case 0xb91f: /* LRVR - load reversed */
4346 case 0xb926: /* LBR - load byte */
4347 case 0xb927: /* LHR - load halfword */
4348 case 0xb994: /* LLCR - load logical character */
4349 case 0xb995: /* LLHR - load logical halfword */
4350 case 0xb9f2: /* LOCR - load on condition */
4351 /* 32-bit gpr destination */
4352 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
4356 /* 0xb223-0xb22c privileged or unsupported */
4358 case 0xb22d: /* DXR - divide */
4359 case 0xb325: /* LXDR - load lengthened */
4360 case 0xb326: /* LXER - load lengthened */
4361 case 0xb336: /* SQXR - square root */
4362 case 0xb365: /* LXR - load */
4363 case 0xb367: /* FIXR - load fp integer */
4364 case 0xb376: /* LZXR - load zero */
4365 case 0xb3b6: /* CXFR - convert from fixed */
4366 case 0xb3c6: /* CXGR - convert from fixed */
4367 case 0xb3fe: /* IEXTR - insert biased exponent */
4368 /* float pair destination */
4369 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[6]))
4371 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ (inib
[6] | 2)))
4375 /* 0xb22e-0xb240 undefined, privileged, or unsupported */
4377 case 0xb241: /* CKSM - checksum [partial] */
4378 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
4380 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[7]))
4382 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[7] | 1)))
4384 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4388 /* 0xb242-0xb243 undefined */
4390 case 0xb244: /* SQDR - square root */
4391 case 0xb245: /* SQER - square root */
4392 case 0xb324: /* LDER - load lengthened */
4393 case 0xb337: /* MEER - multiply */
4394 case 0xb366: /* LEXR - load rounded */
4395 case 0xb370: /* LPDFR - load positive */
4396 case 0xb371: /* LNDFR - load negative */
4397 case 0xb372: /* CSDFR - copy sign */
4398 case 0xb373: /* LCDFR - load complement */
4399 case 0xb374: /* LZER - load zero */
4400 case 0xb375: /* LZDR - load zero */
4401 case 0xb377: /* FIER - load fp integer */
4402 case 0xb37f: /* FIDR - load fp integer */
4403 case 0xb3b4: /* CEFR - convert from fixed */
4404 case 0xb3b5: /* CDFR - convert from fixed */
4405 case 0xb3c1: /* LDGR - load fpr from gr */
4406 case 0xb3c4: /* CEGR - convert from fixed */
4407 case 0xb3c5: /* CDGR - convert from fixed */
4408 case 0xb3f6: /* IEDTR - insert biased exponent */
4409 /* float destination */
4410 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[6]))
4414 /* 0xb246-0xb24c: privileged or unsupported */
4416 case 0xb24d: /* CPYA - copy access */
4417 case 0xb24e: /* SAR - set access */
4418 if (record_full_arch_list_add_reg (regcache
, S390_A0_REGNUM
+ inib
[6]))
4422 /* 0xb250-0xb251 undefined or privileged */
4423 /* 0xb253-0xb254 undefined or privileged */
4425 case 0xb255: /* MVST - move string [partial] */
4430 /* Read ending byte. */
4431 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
, &tmp
);
4433 /* Get address of second operand. */
4434 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ inib
[7], &tmp
);
4435 oaddr
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
4436 /* Search for ending byte and compute length. */
4439 if (target_read_memory (oaddr
, &cur
, 1))
4442 } while (cur
!= end
);
4443 /* Get address of first operand and record it. */
4444 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ inib
[6], &tmp
);
4445 oaddr
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
4446 if (record_full_arch_list_add_mem (oaddr
, num
))
4448 /* Record the registers. */
4449 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
4451 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[7]))
4453 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4458 /* 0xb256 undefined */
4460 case 0xb257: /* CUSE - compare until substring equal [interruptible] */
4461 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
4463 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[6] | 1)))
4465 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[7]))
4467 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[7] | 1)))
4469 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4473 /* 0xb258-0xb25c undefined, privileged, or unsupported */
4475 case 0xb25d: /* CLST - compare logical string [partial] */
4476 case 0xb25e: /* SRST - search string [partial] */
4477 case 0xb9be: /* SRSTU - search string unicode [partial] */
4478 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
4480 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[7]))
4482 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4486 /* 0xb25f-0xb262 undefined */
4488 case 0xb263: /* CMPSC - compression call [interruptible] */
4489 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ inib
[6], &tmp
);
4490 oaddr
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
4491 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ (inib
[6] | 1), &tmp
);
4492 if (record_full_arch_list_add_mem (oaddr
, tmp
))
4494 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
4496 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[6] | 1)))
4498 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[7]))
4500 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[7] | 1)))
4502 if (record_full_arch_list_add_reg (regcache
, S390_R1_REGNUM
))
4504 /* DXC may be written */
4505 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
4507 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4511 /* 0xb264-0xb277 undefined, privileged, or unsupported */
4513 case 0xb278: /* STCKE - store clock extended */
4514 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
4515 if (record_full_arch_list_add_mem (oaddr
, 16))
4517 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4521 /* 0xb279-0xb27b undefined or unsupported */
4522 /* 0xb27d-0xb298 undefined or privileged */
4524 case 0xb299: /* SRNM - set rounding mode */
4525 case 0xb2b8: /* SRNMB - set bfp rounding mode */
4526 case 0xb2b9: /* SRNMT - set dfp rounding mode */
4527 case 0xb29d: /* LFPC - load fpc */
4528 case 0xb2bd: /* LFAS - load fpc and signal */
4529 case 0xb384: /* SFPC - set fpc */
4530 case 0xb385: /* SFASR - set fpc and signal */
4531 case 0xb960: /* CGRT - compare and trap */
4532 case 0xb961: /* CLGRT - compare logical and trap */
4533 case 0xb972: /* CRT - compare and trap */
4534 case 0xb973: /* CLRT - compare logical and trap */
4535 /* fpc only - including possible DXC write for trapping insns */
4536 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
4540 /* 0xb29a-0xb29b undefined */
4542 case 0xb29c: /* STFPC - store fpc */
4543 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
4544 if (record_full_arch_list_add_mem (oaddr
, 4))
4548 /* 0xb29e-0xb2a4 undefined */
4550 case 0xb2a5: /* TRE - translate extended [partial] */
4551 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ inib
[6], &tmp
);
4552 oaddr
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
4553 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ (inib
[6] | 1), &tmp
);
4554 if (record_full_arch_list_add_mem (oaddr
, tmp
))
4556 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
4558 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[6] | 1)))
4560 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4564 case 0xb2a6: /* CU21 - convert UTF-16 to UTF-8 [partial] */
4565 case 0xb2a7: /* CU12 - convert UTF-8 to UTF-16 [partial] */
4566 case 0xb9b0: /* CU14 - convert UTF-8 to UTF-32 [partial] */
4567 case 0xb9b1: /* CU24 - convert UTF-16 to UTF-32 [partial] */
4568 case 0xb9b2: /* CU41 - convert UTF-32 to UTF-8 [partial] */
4569 case 0xb9b3: /* CU42 - convert UTF-32 to UTF-16 [partial] */
4570 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ inib
[6], &tmp
);
4571 oaddr
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
4572 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ (inib
[6] | 1), &tmp
);
4573 if (record_full_arch_list_add_mem (oaddr
, tmp
))
4575 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
4577 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[6] | 1)))
4579 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[7]))
4581 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[7] | 1)))
4583 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4587 /* 0xb2a8-0xb2af undefined */
4589 case 0xb2b0: /* STFLE - store facility list extended */
4590 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
4591 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
, &tmp
);
4593 if (record_full_arch_list_add_mem (oaddr
, 8 * (tmp
+ 1)))
4595 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
))
4597 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4601 /* 0xb2b1-0xb2b7 undefined or privileged */
4602 /* 0xb2ba-0xb2bc undefined */
4603 /* 0xb2be-0xb2e7 undefined */
4604 /* 0xb2e9-0xb2eb undefined */
4605 /* 0xb2ed-0xb2f7 undefined */
4606 /* 0xb2f8 unsupported: TEND */
4607 /* 0xb2f9 undefined */
4609 case 0xb2e8: /* PPA - perform processor assist */
4610 case 0xb2fa: /* NIAI - next instruction access intent */
4611 /* no visible effects */
4614 /* 0xb2fb undefined */
4615 /* 0xb2fc unsupported: TABORT */
4616 /* 0xb2fd-0xb2fe undefined */
4617 /* 0xb2ff unsupported: TRAP */
4619 case 0xb300: /* LPEBR - load positive */
4620 case 0xb301: /* LNEBR - load negative */
4621 case 0xb303: /* LCEBR - load complement */
4622 case 0xb310: /* LPDBR - load positive */
4623 case 0xb311: /* LNDBR - load negative */
4624 case 0xb313: /* LCDBR - load complement */
4625 case 0xb350: /* TBEDR - convert hfp to bfp */
4626 case 0xb351: /* TBDR - convert hfp to bfp */
4627 case 0xb358: /* THDER - convert bfp to hfp */
4628 case 0xb359: /* THDR - convert bfp to hfp */
4629 /* float destination + flags */
4630 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[6]))
4632 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4636 case 0xb304: /* LDEBR - load lengthened */
4637 case 0xb30c: /* MDEBR - multiply */
4638 case 0xb30d: /* DEBR - divide */
4639 case 0xb314: /* SQEBR - square root */
4640 case 0xb315: /* SQDBR - square root */
4641 case 0xb317: /* MEEBR - multiply */
4642 case 0xb31c: /* MDBR - multiply */
4643 case 0xb31d: /* DDBR - divide */
4644 case 0xb344: /* LEDBRA - load rounded */
4645 case 0xb345: /* LDXBRA - load rounded */
4646 case 0xb346: /* LEXBRA - load rounded */
4647 case 0xb357: /* FIEBRA - load fp integer */
4648 case 0xb35f: /* FIDBRA - load fp integer */
4649 case 0xb390: /* CELFBR - convert from logical */
4650 case 0xb391: /* CDLFBR - convert from logical */
4651 case 0xb394: /* CEFBR - convert from fixed */
4652 case 0xb395: /* CDFBR - convert from fixed */
4653 case 0xb3a0: /* CELGBR - convert from logical */
4654 case 0xb3a1: /* CDLGBR - convert from logical */
4655 case 0xb3a4: /* CEGBR - convert from fixed */
4656 case 0xb3a5: /* CDGBR - convert from fixed */
4657 case 0xb3d0: /* MDTR - multiply */
4658 case 0xb3d1: /* DDTR - divide */
4659 case 0xb3d4: /* LDETR - load lengthened */
4660 case 0xb3d5: /* LEDTR - load lengthened */
4661 case 0xb3d7: /* FIDTR - load fp integer */
4662 case 0xb3dd: /* LDXTR - load lengthened */
4663 case 0xb3f1: /* CDGTR - convert from fixed */
4664 case 0xb3f2: /* CDUTR - convert from unsigned packed */
4665 case 0xb3f3: /* CDSTR - convert from signed packed */
4666 case 0xb3f5: /* QADTR - quantize */
4667 case 0xb3f7: /* RRDTR - reround */
4668 case 0xb951: /* CDFTR - convert from fixed */
4669 case 0xb952: /* CDLGTR - convert from logical */
4670 case 0xb953: /* CDLFTR - convert from logical */
4671 /* float destination + fpc */
4672 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[6]))
4674 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
4678 case 0xb305: /* LXDBR - load lengthened */
4679 case 0xb306: /* LXEBR - load lengthened */
4680 case 0xb307: /* MXDBR - multiply */
4681 case 0xb316: /* SQXBR - square root */
4682 case 0xb34c: /* MXBR - multiply */
4683 case 0xb34d: /* DXBR - divide */
4684 case 0xb347: /* FIXBRA - load fp integer */
4685 case 0xb392: /* CXLFBR - convert from logical */
4686 case 0xb396: /* CXFBR - convert from fixed */
4687 case 0xb3a2: /* CXLGBR - convert from logical */
4688 case 0xb3a6: /* CXGBR - convert from fixed */
4689 case 0xb3d8: /* MXTR - multiply */
4690 case 0xb3d9: /* DXTR - divide */
4691 case 0xb3dc: /* LXDTR - load lengthened */
4692 case 0xb3df: /* FIXTR - load fp integer */
4693 case 0xb3f9: /* CXGTR - convert from fixed */
4694 case 0xb3fa: /* CXUTR - convert from unsigned packed */
4695 case 0xb3fb: /* CXSTR - convert from signed packed */
4696 case 0xb3fd: /* QAXTR - quantize */
4697 case 0xb3ff: /* RRXTR - reround */
4698 case 0xb959: /* CXFTR - convert from fixed */
4699 case 0xb95a: /* CXLGTR - convert from logical */
4700 case 0xb95b: /* CXLFTR - convert from logical */
4701 /* float pair destination + fpc */
4702 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[6]))
4704 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ (inib
[6] | 2)))
4706 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
4710 case 0xb308: /* KEBR - compare and signal */
4711 case 0xb309: /* CEBR - compare */
4712 case 0xb318: /* KDBR - compare and signal */
4713 case 0xb319: /* CDBR - compare */
4714 case 0xb348: /* KXBR - compare and signal */
4715 case 0xb349: /* CXBR - compare */
4716 case 0xb3e0: /* KDTR - compare and signal */
4717 case 0xb3e4: /* CDTR - compare */
4718 case 0xb3e8: /* KXTR - compare and signal */
4719 case 0xb3ec: /* CXTR - compare */
4720 /* flags + fpc only */
4721 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4723 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
4727 case 0xb302: /* LTEBR - load and test */
4728 case 0xb312: /* LTDBR - load and test */
4729 case 0xb30a: /* AEBR - add */
4730 case 0xb30b: /* SEBR - subtract */
4731 case 0xb31a: /* ADBR - add */
4732 case 0xb31b: /* SDBR - subtract */
4733 case 0xb3d2: /* ADTR - add */
4734 case 0xb3d3: /* SDTR - subtract */
4735 case 0xb3d6: /* LTDTR - load and test */
4736 /* float destination + flags + fpc */
4737 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[6]))
4739 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4741 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
4745 case 0xb30e: /* MAEBR - multiply and add */
4746 case 0xb30f: /* MSEBR - multiply and subtract */
4747 case 0xb31e: /* MADBR - multiply and add */
4748 case 0xb31f: /* MSDBR - multiply and subtract */
4749 /* float destination [RRD] + fpc */
4750 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[4]))
4752 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
4756 /* 0xb320-0xb323 undefined */
4757 /* 0xb327-0xb32d undefined */
4759 case 0xb32e: /* MAER - multiply and add */
4760 case 0xb32f: /* MSER - multiply and subtract */
4761 case 0xb338: /* MAYLR - multiply and add unnormalized */
4762 case 0xb339: /* MYLR - multiply unnormalized */
4763 case 0xb33c: /* MAYHR - multiply and add unnormalized */
4764 case 0xb33d: /* MYHR - multiply unnormalized */
4765 case 0xb33e: /* MADR - multiply and add */
4766 case 0xb33f: /* MSDR - multiply and subtract */
4767 /* float destination [RRD] */
4768 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[4]))
4772 /* 0xb330-0xb335 undefined */
4774 case 0xb33a: /* MAYR - multiply and add unnormalized */
4775 case 0xb33b: /* MYR - multiply unnormalized */
4776 /* float pair destination [RRD] */
4777 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[4]))
4779 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ (inib
[4] | 2)))
4783 case 0xb340: /* LPXBR - load positive */
4784 case 0xb341: /* LNXBR - load negative */
4785 case 0xb343: /* LCXBR - load complement */
4786 case 0xb360: /* LPXR - load positive */
4787 case 0xb361: /* LNXR - load negative */
4788 case 0xb362: /* LTXR - load and test */
4789 case 0xb363: /* LCXR - load complement */
4790 /* float pair destination + flags */
4791 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[6]))
4793 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ (inib
[6] | 2)))
4795 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4799 case 0xb342: /* LTXBR - load and test */
4800 case 0xb34a: /* AXBR - add */
4801 case 0xb34b: /* SXBR - subtract */
4802 case 0xb3da: /* AXTR - add */
4803 case 0xb3db: /* SXTR - subtract */
4804 case 0xb3de: /* LTXTR - load and test */
4805 /* float pair destination + flags + fpc */
4806 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[6]))
4808 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ (inib
[6] | 2)))
4810 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4812 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
4816 /* 0xb34e-0xb34f undefined */
4817 /* 0xb352 undefined */
4819 case 0xb353: /* DIEBR - divide to integer */
4820 case 0xb35b: /* DIDBR - divide to integer */
4821 /* two float destinations + flags + fpc */
4822 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[4]))
4824 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[6]))
4826 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4828 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
4832 /* 0xb354-0xb356 undefined */
4833 /* 0xb35a undefined */
4835 /* 0xb35c-0xb35e undefined */
4836 /* 0xb364 undefined */
4837 /* 0xb368 undefined */
4839 case 0xb369: /* CXR - compare */
4840 case 0xb3f4: /* CEDTR - compare biased exponent */
4841 case 0xb3fc: /* CEXTR - compare biased exponent */
4842 case 0xb920: /* CGR - compare */
4843 case 0xb921: /* CLGR - compare logical */
4844 case 0xb930: /* CGFR - compare */
4845 case 0xb931: /* CLGFR - compare logical */
4846 case 0xb9cd: /* CHHR - compare high */
4847 case 0xb9cf: /* CLHHR - compare logical high */
4848 case 0xb9dd: /* CHLR - compare high */
4849 case 0xb9df: /* CLHLR - compare logical high */
4851 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4855 /* 0xb36a-0xb36f undefined */
4856 /* 0xb377-0xb37e undefined */
4857 /* 0xb380-0xb383 undefined */
4858 /* 0xb386-0xb38b undefined */
4859 /* 0xb38d-0xb38f undefined */
4860 /* 0xb393 undefined */
4861 /* 0xb397 undefined */
4863 case 0xb398: /* CFEBR - convert to fixed */
4864 case 0xb399: /* CFDBR - convert to fixed */
4865 case 0xb39a: /* CFXBR - convert to fixed */
4866 case 0xb39c: /* CLFEBR - convert to logical */
4867 case 0xb39d: /* CLFDBR - convert to logical */
4868 case 0xb39e: /* CLFXBR - convert to logical */
4869 case 0xb941: /* CFDTR - convert to fixed */
4870 case 0xb949: /* CFXTR - convert to fixed */
4871 case 0xb943: /* CLFDTR - convert to logical */
4872 case 0xb94b: /* CLFXTR - convert to logical */
4873 /* 32-bit gpr destination + flags + fpc */
4874 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
4876 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4878 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
4882 /* 0xb39b undefined */
4883 /* 0xb39f undefined */
4885 /* 0xb3a3 undefined */
4886 /* 0xb3a7 undefined */
4888 case 0xb3a8: /* CGEBR - convert to fixed */
4889 case 0xb3a9: /* CGDBR - convert to fixed */
4890 case 0xb3aa: /* CGXBR - convert to fixed */
4891 case 0xb3ac: /* CLGEBR - convert to logical */
4892 case 0xb3ad: /* CLGDBR - convert to logical */
4893 case 0xb3ae: /* CLGXBR - convert to logical */
4894 case 0xb3e1: /* CGDTR - convert to fixed */
4895 case 0xb3e9: /* CGXTR - convert to fixed */
4896 case 0xb942: /* CLGDTR - convert to logical */
4897 case 0xb94a: /* CLGXTR - convert to logical */
4898 /* 64-bit gpr destination + flags + fpc */
4899 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[6]))
4901 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4903 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
4907 /* 0xb3ab undefined */
4908 /* 0xb3af-0xb3b3 undefined */
4909 /* 0xb3b7 undefined */
4911 case 0xb3b8: /* CFER - convert to fixed */
4912 case 0xb3b9: /* CFDR - convert to fixed */
4913 case 0xb3ba: /* CFXR - convert to fixed */
4914 case 0xb998: /* ALCR - add logical with carry */
4915 case 0xb999: /* SLBR - subtract logical with borrow */
4916 case 0xb9f4: /* NRK - and */
4917 case 0xb9f6: /* ORK - or */
4918 case 0xb9f7: /* XRK - xor */
4919 case 0xb9f8: /* ARK - add */
4920 case 0xb9f9: /* SRK - subtract */
4921 case 0xb9fa: /* ALRK - add logical */
4922 case 0xb9fb: /* SLRK - subtract logical */
4923 /* 32-bit gpr destination + flags */
4924 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
4926 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4930 case 0xb3c8: /* CGER - convert to fixed */
4931 case 0xb3c9: /* CGDR - convert to fixed */
4932 case 0xb3ca: /* CGXR - convert to fixed */
4933 case 0xb900: /* LPGR - load positive */
4934 case 0xb901: /* LNGR - load negative */
4935 case 0xb902: /* LTGR - load and test */
4936 case 0xb903: /* LCGR - load complement */
4937 case 0xb908: /* AGR - add */
4938 case 0xb909: /* SGR - subtract */
4939 case 0xb90a: /* ALGR - add logical */
4940 case 0xb90b: /* SLGR - subtract logical */
4941 case 0xb910: /* LPGFR - load positive */
4942 case 0xb911: /* LNGFR - load negative */
4943 case 0xb912: /* LTGFR - load and test */
4944 case 0xb913: /* LCGFR - load complement */
4945 case 0xb918: /* AGFR - add */
4946 case 0xb919: /* SGFR - subtract */
4947 case 0xb91a: /* ALGFR - add logical */
4948 case 0xb91b: /* SLGFR - subtract logical */
4949 case 0xb980: /* NGR - and */
4950 case 0xb981: /* OGR - or */
4951 case 0xb982: /* XGR - xor */
4952 case 0xb988: /* ALCGR - add logical with carry */
4953 case 0xb989: /* SLBGR - subtract logical with borrow */
4954 case 0xb9e1: /* POPCNT - population count */
4955 case 0xb9e4: /* NGRK - and */
4956 case 0xb9e6: /* OGRK - or */
4957 case 0xb9e7: /* XGRK - xor */
4958 case 0xb9e8: /* AGRK - add */
4959 case 0xb9e9: /* SGRK - subtract */
4960 case 0xb9ea: /* ALGRK - add logical */
4961 case 0xb9eb: /* SLGRK - subtract logical */
4962 /* 64-bit gpr destination + flags */
4963 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[6]))
4965 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
4969 /* 0xb3bb-0xb3c0 undefined */
4970 /* 0xb3c2-0xb3c3 undefined */
4971 /* 0xb3c7 undefined */
4972 /* 0xb3cb-0xb3cc undefined */
4974 case 0xb3cd: /* LGDR - load gr from fpr */
4975 case 0xb3e2: /* CUDTR - convert to unsigned packed */
4976 case 0xb3e3: /* CSDTR - convert to signed packed */
4977 case 0xb3e5: /* EEDTR - extract biased exponent */
4978 case 0xb3e7: /* ESDTR - extract significance */
4979 case 0xb3ed: /* EEXTR - extract biased exponent */
4980 case 0xb3ef: /* ESXTR - extract significance */
4981 case 0xb904: /* LGR - load */
4982 case 0xb906: /* LGBR - load byte */
4983 case 0xb907: /* LGHR - load halfword */
4984 case 0xb90c: /* MSGR - multiply single */
4985 case 0xb90f: /* LRVGR - load reversed */
4986 case 0xb914: /* LGFR - load */
4987 case 0xb916: /* LLGFR - load logical */
4988 case 0xb917: /* LLGTR - load logical thirty one bits */
4989 case 0xb91c: /* MSGFR - load */
4990 case 0xb946: /* BCTGR - branch on count */
4991 case 0xb984: /* LLGCR - load logical character */
4992 case 0xb985: /* LLGHR - load logical halfword */
4993 case 0xb9e2: /* LOCGR - load on condition */
4994 /* 64-bit gpr destination */
4995 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[6]))
4999 /* 0xb3ce-0xb3cf undefined */
5000 /* 0xb3e6 undefined */
5002 case 0xb3ea: /* CUXTR - convert to unsigned packed */
5003 case 0xb3eb: /* CSXTR - convert to signed packed */
5004 case 0xb90d: /* DSGR - divide single */
5005 case 0xb91d: /* DSGFR - divide single */
5006 case 0xb986: /* MLGR - multiply logical */
5007 case 0xb987: /* DLGR - divide logical */
5008 /* 64-bit gpr pair destination */
5009 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[6]))
5011 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[6] | 1))
5015 /* 0xb3ee undefined */
5016 /* 0xb3f0 undefined */
5017 /* 0xb3f8 undefined */
5019 /* 0xb905 privileged */
5021 /* 0xb90e unsupported: EREGG */
5023 /* 0xb915 undefined */
5025 case 0xb91e: /* KMAC - compute message authentication code [partial] */
5026 regcache_raw_read_unsigned (regcache
, S390_R1_REGNUM
, &tmp
);
5027 oaddr
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
5028 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
, &tmp
);
5032 case 0x00: /* KMAC-Query */
5033 if (record_full_arch_list_add_mem (oaddr
, 16))
5037 case 0x01: /* KMAC-DEA */
5038 case 0x02: /* KMAC-TDEA-128 */
5039 case 0x03: /* KMAC-TDEA-192 */
5040 case 0x09: /* KMAC-Encrypted-DEA */
5041 case 0x0a: /* KMAC-Encrypted-TDEA-128 */
5042 case 0x0b: /* KMAC-Encrypted-TDEA-192 */
5043 if (record_full_arch_list_add_mem (oaddr
, 8))
5047 case 0x12: /* KMAC-AES-128 */
5048 case 0x13: /* KMAC-AES-192 */
5049 case 0x14: /* KMAC-AES-256 */
5050 case 0x1a: /* KMAC-Encrypted-AES-128 */
5051 case 0x1b: /* KMAC-Encrypted-AES-192 */
5052 case 0x1c: /* KMAC-Encrypted-AES-256 */
5053 if (record_full_arch_list_add_mem (oaddr
, 16))
5058 fprintf_unfiltered (gdb_stdlog
, "Warning: Unknown KMAC function %02x at %s.\n",
5059 (int)tmp
, paddress (gdbarch
, addr
));
5064 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[7]))
5066 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[7] | 1)))
5069 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5073 /* 0xb922-0xb924 undefined */
5074 /* 0xb925 privileged */
5075 /* 0xb928 privileged */
5076 /* 0xb929 undefined */
5078 case 0xb92a: /* KMF - cipher message with cipher feedback [partial] */
5079 case 0xb92b: /* KMO - cipher message with output feedback [partial] */
5080 case 0xb92f: /* KMC - cipher message with chaining [partial] */
5081 regcache_raw_read_unsigned (regcache
, S390_R1_REGNUM
, &tmp
);
5082 oaddr
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
5083 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
, &tmp
);
5087 case 0x00: /* KM*-Query */
5088 if (record_full_arch_list_add_mem (oaddr
, 16))
5092 case 0x01: /* KM*-DEA */
5093 case 0x02: /* KM*-TDEA-128 */
5094 case 0x03: /* KM*-TDEA-192 */
5095 case 0x09: /* KM*-Encrypted-DEA */
5096 case 0x0a: /* KM*-Encrypted-TDEA-128 */
5097 case 0x0b: /* KM*-Encrypted-TDEA-192 */
5098 if (record_full_arch_list_add_mem (oaddr
, 8))
5102 case 0x12: /* KM*-AES-128 */
5103 case 0x13: /* KM*-AES-192 */
5104 case 0x14: /* KM*-AES-256 */
5105 case 0x1a: /* KM*-Encrypted-AES-128 */
5106 case 0x1b: /* KM*-Encrypted-AES-192 */
5107 case 0x1c: /* KM*-Encrypted-AES-256 */
5108 if (record_full_arch_list_add_mem (oaddr
, 16))
5112 case 0x43: /* KMC-PRNG */
5113 /* Only valid for KMC. */
5114 if (insn
[0] == 0xb92f)
5116 if (record_full_arch_list_add_mem (oaddr
, 8))
5120 /* For other instructions, fallthru. */
5122 fprintf_unfiltered (gdb_stdlog
, "Warning: Unknown KM* function %02x at %s.\n",
5123 (int)tmp
, paddress (gdbarch
, addr
));
5128 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ inib
[6], &tmp
);
5129 oaddr2
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
5130 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ (inib
[7] | 1), &tmp
);
5131 if (record_full_arch_list_add_mem (oaddr2
, tmp
))
5133 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
5135 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[7]))
5137 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[7] | 1)))
5140 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5144 case 0xb92c: /* PCC - perform cryptographic computation [partial] */
5145 regcache_raw_read_unsigned (regcache
, S390_R1_REGNUM
, &tmp
);
5146 oaddr
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
5147 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
, &tmp
);
5151 case 0x00: /* PCC-Query */
5152 if (record_full_arch_list_add_mem (oaddr
, 16))
5156 case 0x01: /* PCC-Compute-Last-Block-CMAC-Using-DEA */
5157 case 0x02: /* PCC-Compute-Last-Block-CMAC-Using-TDEA-128 */
5158 case 0x03: /* PCC-Compute-Last-Block-CMAC-Using-TDEA-192 */
5159 case 0x09: /* PCC-Compute-Last-Block-CMAC-Using-Encrypted-DEA */
5160 case 0x0a: /* PCC-Compute-Last-Block-CMAC-Using-Encrypted-TDEA-128 */
5161 case 0x0b: /* PCC-Compute-Last-Block-CMAC-Using-Encrypted-TDEA-192 */
5162 if (record_full_arch_list_add_mem (oaddr
+ 0x10, 8))
5166 case 0x12: /* PCC-Compute-Last-Block-CMAC-Using-AES-128 */
5167 case 0x13: /* PCC-Compute-Last-Block-CMAC-Using-AES-192 */
5168 case 0x14: /* PCC-Compute-Last-Block-CMAC-Using-AES-256 */
5169 case 0x1a: /* PCC-Compute-Last-Block-CMAC-Using-Encrypted-AES-128 */
5170 case 0x1b: /* PCC-Compute-Last-Block-CMAC-Using-Encrypted-AES-192 */
5171 case 0x1c: /* PCC-Compute-Last-Block-CMAC-Using-Encrypted-AES-256 */
5172 if (record_full_arch_list_add_mem (oaddr
+ 0x18, 16))
5176 case 0x32: /* PCC-Compute-XTS-Parameter-Using-AES-128 */
5177 if (record_full_arch_list_add_mem (oaddr
+ 0x30, 32))
5181 case 0x34: /* PCC-Compute-XTS-Parameter-Using-AES-256 */
5182 if (record_full_arch_list_add_mem (oaddr
+ 0x40, 32))
5186 case 0x3a: /* PCC-Compute-XTS-Parameter-Using-Encrypted-AES-128 */
5187 if (record_full_arch_list_add_mem (oaddr
+ 0x50, 32))
5191 case 0x3c: /* PCC-Compute-XTS-Parameter-Using-Encrypted-AES-256 */
5192 if (record_full_arch_list_add_mem (oaddr
+ 0x60, 32))
5197 fprintf_unfiltered (gdb_stdlog
, "Warning: Unknown PCC function %02x at %s.\n",
5198 (int)tmp
, paddress (gdbarch
, addr
));
5201 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5205 case 0xb92d: /* KMCTR - cipher message with counter [partial] */
5206 regcache_raw_read_unsigned (regcache
, S390_R1_REGNUM
, &tmp
);
5207 oaddr
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
5208 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
, &tmp
);
5212 case 0x00: /* KMCTR-Query */
5213 if (record_full_arch_list_add_mem (oaddr
, 16))
5217 case 0x01: /* KMCTR-DEA */
5218 case 0x02: /* KMCTR-TDEA-128 */
5219 case 0x03: /* KMCTR-TDEA-192 */
5220 case 0x09: /* KMCTR-Encrypted-DEA */
5221 case 0x0a: /* KMCTR-Encrypted-TDEA-128 */
5222 case 0x0b: /* KMCTR-Encrypted-TDEA-192 */
5223 case 0x12: /* KMCTR-AES-128 */
5224 case 0x13: /* KMCTR-AES-192 */
5225 case 0x14: /* KMCTR-AES-256 */
5226 case 0x1a: /* KMCTR-Encrypted-AES-128 */
5227 case 0x1b: /* KMCTR-Encrypted-AES-192 */
5228 case 0x1c: /* KMCTR-Encrypted-AES-256 */
5232 fprintf_unfiltered (gdb_stdlog
, "Warning: Unknown KMCTR function %02x at %s.\n",
5233 (int)tmp
, paddress (gdbarch
, addr
));
5238 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ inib
[6], &tmp
);
5239 oaddr2
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
5240 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ (inib
[7] | 1), &tmp
);
5241 if (record_full_arch_list_add_mem (oaddr2
, tmp
))
5243 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
5245 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[7]))
5247 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[7] | 1)))
5249 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[4]))
5252 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5256 case 0xb92e: /* KM - cipher message [partial] */
5257 regcache_raw_read_unsigned (regcache
, S390_R1_REGNUM
, &tmp
);
5258 oaddr
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
5259 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
, &tmp
);
5263 case 0x00: /* KM-Query */
5264 if (record_full_arch_list_add_mem (oaddr
, 16))
5268 case 0x01: /* KM-DEA */
5269 case 0x02: /* KM-TDEA-128 */
5270 case 0x03: /* KM-TDEA-192 */
5271 case 0x09: /* KM-Encrypted-DEA */
5272 case 0x0a: /* KM-Encrypted-TDEA-128 */
5273 case 0x0b: /* KM-Encrypted-TDEA-192 */
5274 case 0x12: /* KM-AES-128 */
5275 case 0x13: /* KM-AES-192 */
5276 case 0x14: /* KM-AES-256 */
5277 case 0x1a: /* KM-Encrypted-AES-128 */
5278 case 0x1b: /* KM-Encrypted-AES-192 */
5279 case 0x1c: /* KM-Encrypted-AES-256 */
5282 case 0x32: /* KM-XTS-AES-128 */
5283 if (record_full_arch_list_add_mem (oaddr
+ 0x10, 16))
5287 case 0x34: /* KM-XTS-AES-256 */
5288 if (record_full_arch_list_add_mem (oaddr
+ 0x20, 16))
5292 case 0x3a: /* KM-XTS-Encrypted-AES-128 */
5293 if (record_full_arch_list_add_mem (oaddr
+ 0x30, 16))
5297 case 0x3c: /* KM-XTS-Encrypted-AES-256 */
5298 if (record_full_arch_list_add_mem (oaddr
+ 0x40, 16))
5303 fprintf_unfiltered (gdb_stdlog
, "Warning: Unknown KM function %02x at %s.\n",
5304 (int)tmp
, paddress (gdbarch
, addr
));
5309 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ inib
[6], &tmp
);
5310 oaddr2
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
5311 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ (inib
[7] | 1), &tmp
);
5312 if (record_full_arch_list_add_mem (oaddr2
, tmp
))
5314 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
5316 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[7]))
5318 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[7] | 1)))
5321 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5325 /* 0xb932-0xb93b undefined */
5327 case 0xb93c: /* PPNO - perform pseudorandom number operation [partial] */
5328 regcache_raw_read_unsigned (regcache
, S390_R1_REGNUM
, &tmp
);
5329 oaddr
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
5330 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
, &tmp
);
5334 case 0x00: /* PPNO-Query */
5335 case 0x80: /* PPNO-Query */
5336 if (record_full_arch_list_add_mem (oaddr
, 16))
5340 case 0x03: /* PPNO-SHA-512-DRNG - generate */
5341 if (record_full_arch_list_add_mem (oaddr
, 240))
5343 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ inib
[6], &tmp
);
5344 oaddr2
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
5345 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ (inib
[6] | 1), &tmp
);
5346 if (record_full_arch_list_add_mem (oaddr2
, tmp
))
5348 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
5350 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[6] | 1)))
5354 case 0x83: /* PPNO-SHA-512-DRNG - seed */
5355 if (record_full_arch_list_add_mem (oaddr
, 240))
5357 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[7]))
5359 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[7] | 1)))
5364 fprintf_unfiltered (gdb_stdlog
, "Warning: Unknown PPNO function %02x at %s.\n",
5365 (int)tmp
, paddress (gdbarch
, addr
));
5368 /* DXC may be written */
5369 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
5371 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5375 /* 0xb93d undefined */
5377 case 0xb93e: /* KIMD - compute intermediate message digest [partial] */
5378 case 0xb93f: /* KLMD - compute last message digest [partial] */
5379 regcache_raw_read_unsigned (regcache
, S390_R1_REGNUM
, &tmp
);
5380 oaddr
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
5381 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
, &tmp
);
5385 case 0x00: /* K*MD-Query */
5386 if (record_full_arch_list_add_mem (oaddr
, 16))
5390 case 0x01: /* K*MD-SHA-1 */
5391 if (record_full_arch_list_add_mem (oaddr
, 20))
5395 case 0x02: /* K*MD-SHA-256 */
5396 if (record_full_arch_list_add_mem (oaddr
, 32))
5400 case 0x03: /* K*MD-SHA-512 */
5401 if (record_full_arch_list_add_mem (oaddr
, 64))
5405 case 0x41: /* KIMD-GHASH */
5406 /* Only valid for KIMD. */
5407 if (insn
[0] == 0xb93e)
5409 if (record_full_arch_list_add_mem (oaddr
, 16))
5413 /* For KLMD, fallthru. */
5415 fprintf_unfiltered (gdb_stdlog
, "Warning: Unknown KMAC function %02x at %s.\n",
5416 (int)tmp
, paddress (gdbarch
, addr
));
5421 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[7]))
5423 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[7] | 1)))
5426 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5430 /* 0xb940 undefined */
5431 /* 0xb944-0xb945 undefined */
5432 /* 0xb947-0xb948 undefined */
5433 /* 0xb94c-0xb950 undefined */
5434 /* 0xb954-0xb958 undefined */
5435 /* 0xb95c-0xb95f undefined */
5436 /* 0xb962-0xb971 undefined */
5437 /* 0xb974-0xb97f undefined */
5439 case 0xb983: /* FLOGR - find leftmost one */
5440 /* 64-bit gpr pair destination + flags */
5441 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[6]))
5443 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[6] | 1))
5445 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5449 /* 0xb98a privileged */
5450 /* 0xb98b-0xb98c undefined */
5452 case 0xb98d: /* EPSW - extract psw */
5453 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
5456 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[7]))
5460 /* 0xb98e-0xb98f privileged */
5462 case 0xb990: /* TRTT - translate two to two [partial] */
5463 case 0xb991: /* TRTO - translate two to one [partial] */
5464 case 0xb992: /* TROT - translate one to two [partial] */
5465 case 0xb993: /* TROO - translate one to one [partial] */
5466 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ inib
[6], &tmp
);
5467 oaddr
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
5468 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ (inib
[6] | 1), &tmp
);
5469 /* tmp is source length, we want destination length. Adjust. */
5470 if (insn
[0] == 0xb991)
5472 if (insn
[0] == 0xb992)
5474 if (record_full_arch_list_add_mem (oaddr
, tmp
))
5476 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
5478 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[6] | 1)))
5480 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[7]))
5482 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5486 case 0xb996: /* MLR - multiply logical */
5487 case 0xb997: /* DLR - divide logical */
5488 /* 32-bit gpr pair destination */
5489 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
5491 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[6] | 1)))
5495 /* 0xb99a-0xb9af unsupported, privileged, or undefined */
5496 /* 0xb9b4-0xb9bc undefined */
5498 case 0xb9bd: /* TRTRE - translate and test reverse extended [partial] */
5499 case 0xb9bf: /* TRTE - translate and test extended [partial] */
5500 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[6]))
5502 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[6] | 1)))
5504 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[7]))
5506 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5510 /* 0xb9c0-0xb9c7 undefined */
5512 case 0xb9c8: /* AHHHR - add high */
5513 case 0xb9c9: /* SHHHR - subtract high */
5514 case 0xb9ca: /* ALHHHR - add logical high */
5515 case 0xb9cb: /* SLHHHR - subtract logical high */
5516 case 0xb9d8: /* AHHLR - add high */
5517 case 0xb9d9: /* SHHLR - subtract high */
5518 case 0xb9da: /* ALHHLR - add logical high */
5519 case 0xb9db: /* SLHHLR - subtract logical high */
5520 /* 32-bit high gpr destination + flags */
5521 if (s390_record_gpr_h (gdbarch
, regcache
, inib
[6]))
5523 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5527 /* 0xb9cc undefined */
5528 /* 0xb9ce undefined */
5529 /* 0xb9d0-0xb9d7 undefined */
5530 /* 0xb9dc undefined */
5531 /* 0xb9de undefined */
5533 case 0xb9e0: /* LOCFHR - load high on condition */
5534 /* 32-bit high gpr destination */
5535 if (s390_record_gpr_h (gdbarch
, regcache
, inib
[6]))
5539 /* 0xb9e3 undefined */
5540 /* 0xb9e5 undefined */
5541 /* 0xb9ec-0xb9f1 undefined */
5542 /* 0xb9f3 undefined */
5543 /* 0xb9f5 undefined */
5544 /* 0xb9fc-0xb9ff undefined */
5551 /* 0xb4-0xb5 undefined */
5552 /* 0xb6 privileged: STCTL - store control */
5553 /* 0xb7 privileged: LCTL - load control */
5554 /* 0xb8 undefined */
5556 case 0xba: /* CS - compare and swap */
5557 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
5558 if (record_full_arch_list_add_mem (oaddr
, 4))
5560 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
5562 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5566 case 0xbb: /* CDS - compare double and swap */
5567 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
5568 if (record_full_arch_list_add_mem (oaddr
, 8))
5570 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
5572 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[2] | 1)))
5574 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5578 /* 0xbc undefined */
5580 case 0xbe: /* STCM - store characters under mask */
5581 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
5582 if (record_full_arch_list_add_mem (oaddr
, s390_popcnt (inib
[3])))
5591 /* RIL-format instruction */
5592 switch (ibyte
[0] << 4 | inib
[3])
5594 case 0xc00: /* LARL - load address relative long */
5595 case 0xc05: /* BRASL - branch relative and save long */
5596 case 0xc09: /* IILF - insert immediate */
5597 case 0xc21: /* MSFI - multiply single immediate */
5598 case 0xc42: /* LLHRL - load logical halfword relative long */
5599 case 0xc45: /* LHRL - load halfword relative long */
5600 case 0xc4d: /* LRL - load relative long */
5601 /* 32-bit or native gpr destination */
5602 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
5606 case 0xc01: /* LGFI - load immediate */
5607 case 0xc0e: /* LLIHF - load logical immediate */
5608 case 0xc0f: /* LLILF - load logical immediate */
5609 case 0xc20: /* MSGFI - multiply single immediate */
5610 case 0xc44: /* LGHRL - load halfword relative long */
5611 case 0xc46: /* LLGHRL - load logical halfword relative long */
5612 case 0xc48: /* LGRL - load relative long */
5613 case 0xc4c: /* LGFRL - load relative long */
5614 case 0xc4e: /* LLGFRL - load logical relative long */
5615 /* 64-bit gpr destination */
5616 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
5620 /* 0xc02-0xc03 undefined */
5622 case 0xc04: /* BRCL - branch relative on condition long */
5623 case 0xc62: /* PFDRL - prefetch data relative long */
5626 case 0xc06: /* XIHF - xor immediate */
5627 case 0xc0a: /* NIHF - and immediate */
5628 case 0xc0c: /* OIHF - or immediate */
5629 case 0xcc8: /* AIH - add immediate high */
5630 case 0xcca: /* ALSIH - add logical with signed immediate high */
5631 /* 32-bit high gpr destination + flags */
5632 if (s390_record_gpr_h (gdbarch
, regcache
, inib
[2]))
5634 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5638 case 0xc07: /* XILF - xor immediate */
5639 case 0xc0b: /* NILF - and immediate */
5640 case 0xc0d: /* OILF - or immediate */
5641 case 0xc25: /* SLFI - subtract logical immediate */
5642 case 0xc29: /* AFI - add immediate */
5643 case 0xc2b: /* ALFI - add logical immediate */
5644 /* 32-bit gpr destination + flags */
5645 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
5647 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5651 case 0xc08: /* IIHF - insert immediate */
5652 case 0xcc6: /* BRCTH - branch relative on count high */
5653 case 0xccb: /* ALSIHN - add logical with signed immediate high */
5654 /* 32-bit high gpr destination */
5655 if (s390_record_gpr_h (gdbarch
, regcache
, inib
[2]))
5659 /* 0xc22-0xc23 undefined */
5661 case 0xc24: /* SLGFI - subtract logical immediate */
5662 case 0xc28: /* AGFI - add immediate */
5663 case 0xc2a: /* ALGFI - add logical immediate */
5664 /* 64-bit gpr destination + flags */
5665 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
5667 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5671 /* 0xc26-0xc27 undefined */
5673 case 0xc2c: /* CGFI - compare immediate */
5674 case 0xc2d: /* CFI - compare immediate */
5675 case 0xc2e: /* CLGFI - compare logical immediate */
5676 case 0xc2f: /* CLFI - compare logical immediate */
5677 case 0xc64: /* CGHRL - compare halfword relative long */
5678 case 0xc65: /* CHRL - compare halfword relative long */
5679 case 0xc66: /* CLGHRL - compare logical halfword relative long */
5680 case 0xc67: /* CLHRL - compare logical halfword relative long */
5681 case 0xc68: /* CGRL - compare relative long */
5682 case 0xc6a: /* CLGRL - compare logical relative long */
5683 case 0xc6c: /* CGFRL - compare relative long */
5684 case 0xc6d: /* CRL - compare relative long */
5685 case 0xc6e: /* CLGFRL - compare logical relative long */
5686 case 0xc6f: /* CLRL - compare logical relative long */
5687 case 0xccd: /* CIH - compare immediate high */
5688 case 0xccf: /* CLIH - compare logical immediate high */
5690 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5694 /* 0xc40-0xc41 undefined */
5695 /* 0xc43 undefined */
5697 case 0xc47: /* STHRL - store halfword relative long */
5698 oaddr
= s390_record_calc_rl (gdbarch
, regcache
, addr
, insn
[1], insn
[2]);
5699 if (record_full_arch_list_add_mem (oaddr
, 2))
5703 /* 0xc49-0xc4a undefined */
5705 case 0xc4b: /* STGRL - store relative long */
5706 oaddr
= s390_record_calc_rl (gdbarch
, regcache
, addr
, insn
[1], insn
[2]);
5707 if (record_full_arch_list_add_mem (oaddr
, 8))
5711 case 0xc4f: /* STRL - store relative long */
5712 oaddr
= s390_record_calc_rl (gdbarch
, regcache
, addr
, insn
[1], insn
[2]);
5713 if (record_full_arch_list_add_mem (oaddr
, 4))
5717 case 0xc60: /* EXRL - execute relative long */
5720 fprintf_unfiltered (gdb_stdlog
, "Warning: Double execute at %s.\n",
5721 paddress (gdbarch
, addr
));
5724 addr
= s390_record_calc_rl (gdbarch
, regcache
, addr
, insn
[1], insn
[2]);
5727 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ inib
[2], &tmp
);
5736 /* 0xc61 undefined */
5737 /* 0xc63 undefined */
5738 /* 0xc69 undefined */
5739 /* 0xc6b undefined */
5740 /* 0xcc0-0xcc5 undefined */
5741 /* 0xcc7 undefined */
5742 /* 0xcc9 undefined */
5743 /* 0xccc undefined */
5744 /* 0xcce undefined */
5751 /* 0xc1 undefined */
5752 /* 0xc3 undefined */
5754 case 0xc5: /* BPRP - branch prediction relative preload */
5755 case 0xc7: /* BPP - branch prediction preload */
5756 /* no visible effect */
5760 /* SSF-format instruction */
5761 switch (ibyte
[0] << 4 | inib
[3])
5763 /* 0xc80 unsupported */
5765 case 0xc81: /* ECTG - extract cpu time */
5766 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
5768 if (s390_record_gpr_g (gdbarch
, regcache
, 0))
5770 if (s390_record_gpr_g (gdbarch
, regcache
, 1))
5774 case 0xc82: /* CSST - compare and swap and store */
5777 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
, &tmp
);
5779 sc
= tmp
>> 8 & 0xff;
5781 /* First and third operands. */
5782 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
5785 case 0x00: /* 32-bit */
5786 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
5788 if (record_full_arch_list_add_mem (oaddr
, 4))
5792 case 0x01: /* 64-bit */
5793 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
5795 if (record_full_arch_list_add_mem (oaddr
, 8))
5799 case 0x02: /* 128-bit */
5800 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
5802 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2] | 1))
5804 if (record_full_arch_list_add_mem (oaddr
, 16))
5809 fprintf_unfiltered (gdb_stdlog
, "Warning: Unknown CSST FC %02x at %s.\n",
5810 fc
, paddress (gdbarch
, addr
));
5814 /* Second operand. */
5815 oaddr2
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[2], 0);
5818 fprintf_unfiltered (gdb_stdlog
, "Warning: Unknown CSST FC %02x at %s.\n",
5819 sc
, paddress (gdbarch
, addr
));
5823 if (record_full_arch_list_add_mem (oaddr2
, 1 << sc
))
5827 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5832 /* 0xc83 undefined */
5834 case 0xc84: /* LPD - load pair disjoint */
5835 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
5837 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[2] | 1)))
5839 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5843 case 0xc85: /* LPDG - load pair disjoint */
5844 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
5846 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2] | 1))
5848 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5852 /* 0xc86-0xc8f undefined */
5859 /* 0xc9-0xcb undefined */
5860 /* 0xcd-0xcf undefined */
5862 case 0xd0: /* TRTR - translate and test reversed */
5863 case 0xdd: /* TRT - translate and test */
5864 if (record_full_arch_list_add_reg (regcache
, S390_R1_REGNUM
))
5866 if (record_full_arch_list_add_reg (regcache
, S390_R2_REGNUM
))
5868 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5872 case 0xd1: /* MVN - move numbers */
5873 case 0xd2: /* MVC - move */
5874 case 0xd3: /* MVZ - move zones */
5875 case 0xdc: /* TR - translate */
5876 case 0xe8: /* MVCIN - move inverse */
5877 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
5878 if (record_full_arch_list_add_mem (oaddr
, ibyte
[1] + 1))
5882 case 0xd4: /* NC - and */
5883 case 0xd6: /* OC - or*/
5884 case 0xd7: /* XC - xor */
5885 case 0xe2: /* UNPKU - unpack unicode */
5886 case 0xea: /* UNPKA - unpack ASCII */
5887 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
5888 if (record_full_arch_list_add_mem (oaddr
, ibyte
[1] + 1))
5890 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5894 case 0xde: /* ED - edit */
5895 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
5896 if (record_full_arch_list_add_mem (oaddr
, ibyte
[1] + 1))
5898 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5900 /* DXC may be written */
5901 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
5905 case 0xdf: /* EDMK - edit and mark */
5906 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
5907 if (record_full_arch_list_add_mem (oaddr
, ibyte
[1] + 1))
5909 if (record_full_arch_list_add_reg (regcache
, S390_R1_REGNUM
))
5911 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5913 /* DXC may be written */
5914 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
5918 /* 0xd8 undefined */
5919 /* 0xd9 unsupported: MVCK - move with key */
5920 /* 0xda unsupported: MVCP - move to primary */
5921 /* 0xdb unsupported: MVCS - move to secondary */
5922 /* 0xe0 undefined */
5924 case 0xe1: /* PKU - pack unicode */
5925 case 0xe9: /* PKA - pack ASCII */
5926 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
5927 if (record_full_arch_list_add_mem (oaddr
, 16))
5935 /* RXY/RXE/RXF/RSL/RSY/SIY/V*-format instruction */
5936 switch (ibyte
[0] << 8 | ibyte
[5])
5938 /* 0xe300-0xe301 undefined */
5940 case 0xe302: /* LTG - load and test */
5941 case 0xe308: /* AG - add */
5942 case 0xe309: /* SG - subtract */
5943 case 0xe30a: /* ALG - add logical */
5944 case 0xe30b: /* SLG - subtract logical */
5945 case 0xe318: /* AGF - add */
5946 case 0xe319: /* SGF - subtract */
5947 case 0xe31a: /* ALGF - add logical */
5948 case 0xe31b: /* SLGF - subtract logical */
5949 case 0xe332: /* LTGF - load and test */
5950 case 0xe380: /* NG - and */
5951 case 0xe381: /* OG - or */
5952 case 0xe382: /* XG - xor */
5953 case 0xe388: /* ALCG - add logical with carry */
5954 case 0xe389: /* SLBG - subtract logical with borrow */
5955 case 0xeb0a: /* SRAG - shift right single */
5956 case 0xeb0b: /* SLAG - shift left single */
5957 /* 64-bit gpr destination + flags */
5958 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
5960 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
5964 /* 0xe303 privileged */
5966 case 0xe304: /* LG - load */
5967 case 0xe30c: /* MSG - multiply single */
5968 case 0xe30f: /* LRVG - load reversed */
5969 case 0xe314: /* LGF - load */
5970 case 0xe315: /* LGH - load halfword */
5971 case 0xe316: /* LLGF - load logical */
5972 case 0xe317: /* LLGT - load logical thirty one bits */
5973 case 0xe31c: /* MSGF - multiply single */
5974 case 0xe32a: /* LZRG - load and zero rightmost byte */
5975 case 0xe33a: /* LLZRGF - load logical and zero rightmost byte */
5976 case 0xe346: /* BCTG - branch on count */
5977 case 0xe377: /* LGB - load byte */
5978 case 0xe390: /* LLGC - load logical character */
5979 case 0xe391: /* LLGH - load logical halfword */
5980 case 0xeb0c: /* SRLG - shift right single logical */
5981 case 0xeb0d: /* SLLG - shift left single logical */
5982 case 0xeb1c: /* RLLG - rotate left single logical */
5983 case 0xeb44: /* BXHG - branch on index high */
5984 case 0xeb45: /* BXLEG - branch on index low or equal */
5985 case 0xeb4c: /* ECAG - extract cpu attribute */
5986 case 0xebe2: /* LOCG - load on condition */
5987 /* 64-bit gpr destination */
5988 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
5992 /* 0xe305 undefined */
5994 case 0xe306: /* CVBY - convert to binary */
5995 /* 32-bit or native gpr destination + FPC (DXC write) */
5996 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
5998 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
6002 /* 0xe307 undefined */
6004 case 0xe30d: /* DSG - divide single */
6005 case 0xe31d: /* DSGF - divide single */
6006 case 0xe386: /* MLG - multiply logical */
6007 case 0xe387: /* DLG - divide logical */
6008 case 0xe38f: /* LPQ - load pair from quadword */
6009 /* 64-bit gpr pair destination */
6010 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
6012 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2] | 1))
6016 case 0xe30e: /* CVBG - convert to binary */
6017 /* 64-bit gpr destination + FPC (DXC write) */
6018 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
6020 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
6024 /* 0xe310-0xe311 undefined */
6026 case 0xe312: /* LT - load and test */
6027 case 0xe354: /* NY - and */
6028 case 0xe356: /* OY - or */
6029 case 0xe357: /* XY - xor */
6030 case 0xe35a: /* AY - add */
6031 case 0xe35b: /* SY - subtract */
6032 case 0xe35e: /* ALY - add logical */
6033 case 0xe35f: /* SLY - subtract logical */
6034 case 0xe37a: /* AHY - add halfword */
6035 case 0xe37b: /* SHY - subtract halfword */
6036 case 0xe398: /* ALC - add logical with carry */
6037 case 0xe399: /* SLB - subtract logical with borrow */
6038 case 0xe727: /* LCBB - load count to block bounduary */
6039 case 0xeb81: /* ICMY - insert characters under mask */
6040 case 0xebdc: /* SRAK - shift left single */
6041 case 0xebdd: /* SLAK - shift left single */
6042 /* 32-bit gpr destination + flags */
6043 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
6045 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
6049 /* 0xe313 privileged */
6051 case 0xe31e: /* LRV - load reversed */
6052 case 0xe31f: /* LRVH - load reversed */
6053 case 0xe33b: /* LZRF - load and zero rightmost byte */
6054 case 0xe351: /* MSY - multiply single */
6055 case 0xe358: /* LY - load */
6056 case 0xe371: /* LAY - load address */
6057 case 0xe373: /* ICY - insert character */
6058 case 0xe376: /* LB - load byte */
6059 case 0xe378: /* LHY - load */
6060 case 0xe37c: /* MHY - multiply halfword */
6061 case 0xe394: /* LLC - load logical character */
6062 case 0xe395: /* LLH - load logical halfword */
6063 case 0xeb1d: /* RLL - rotate left single logical */
6064 case 0xebde: /* SRLK - shift left single logical */
6065 case 0xebdf: /* SLLK - shift left single logical */
6066 case 0xebf2: /* LOC - load on condition */
6067 /* 32-bit or native gpr destination */
6068 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
6072 case 0xe320: /* CG - compare */
6073 case 0xe321: /* CLG - compare logical */
6074 case 0xe330: /* CGF - compare */
6075 case 0xe331: /* CLGF - compare logical */
6076 case 0xe334: /* CGH - compare halfword */
6077 case 0xe355: /* CLY - compare logical */
6078 case 0xe359: /* CY - compare */
6079 case 0xe379: /* CHY - compare halfword */
6080 case 0xe3cd: /* CHF - compare high */
6081 case 0xe3cf: /* CLHF - compare logical high */
6082 case 0xeb20: /* CLMH - compare logical under mask high */
6083 case 0xeb21: /* CLMY - compare logical under mask */
6084 case 0xeb51: /* TMY - test under mask */
6085 case 0xeb55: /* CLIY - compare logical */
6086 case 0xebc0: /* TP - test decimal */
6087 case 0xed10: /* TCEB - test data class */
6088 case 0xed11: /* TCDB - test data class */
6089 case 0xed12: /* TCXB - test data class */
6090 case 0xed50: /* TDCET - test data class */
6091 case 0xed51: /* TDGET - test data group */
6092 case 0xed54: /* TDCDT - test data class */
6093 case 0xed55: /* TDGDT - test data group */
6094 case 0xed58: /* TDCXT - test data class */
6095 case 0xed59: /* TDGXT - test data group */
6097 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
6101 /* 0xe322-0xe323 undefined */
6103 case 0xe324: /* STG - store */
6104 case 0xe325: /* NTSTG - nontransactional store */
6105 case 0xe326: /* CVDY - convert to decimal */
6106 case 0xe32f: /* STRVG - store reversed */
6107 case 0xebe3: /* STOCG - store on condition */
6108 case 0xed67: /* STDY - store */
6109 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, inib
[3], insn
[1], ibyte
[4]);
6110 if (record_full_arch_list_add_mem (oaddr
, 8))
6114 /* 0xe327-0xe329 undefined */
6115 /* 0xe32b-0xe32d undefined */
6117 case 0xe32e: /* CVDG - convert to decimal */
6118 case 0xe38e: /* STPQ - store pair to quadword */
6119 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, inib
[3], insn
[1], ibyte
[4]);
6120 if (record_full_arch_list_add_mem (oaddr
, 16))
6124 /* 0xe333 undefined */
6125 /* 0xe335 undefined */
6127 case 0xe336: /* PFD - prefetch data */
6130 /* 0xe337-0xe339 undefined */
6131 /* 0xe33c-0xe33d undefined */
6133 case 0xe33e: /* STRV - store reversed */
6134 case 0xe350: /* STY - store */
6135 case 0xe3cb: /* STFH - store high */
6136 case 0xebe1: /* STOCFH - store high on condition */
6137 case 0xebf3: /* STOC - store on condition */
6138 case 0xed66: /* STEY - store */
6139 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, inib
[3], insn
[1], ibyte
[4]);
6140 if (record_full_arch_list_add_mem (oaddr
, 4))
6144 case 0xe33f: /* STRVH - store reversed */
6145 case 0xe370: /* STHY - store halfword */
6146 case 0xe3c7: /* STHH - store halfword high */
6147 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, inib
[3], insn
[1], ibyte
[4]);
6148 if (record_full_arch_list_add_mem (oaddr
, 2))
6152 /* 0xe340-0xe345 undefined */
6153 /* 0xe347-0xe34f undefined */
6154 /* 0xe352-0xe353 undefined */
6156 case 0xe35c: /* MFY - multiply */
6157 case 0xe396: /* ML - multiply logical */
6158 case 0xe397: /* DL - divide logical */
6159 /* 32-bit gpr pair destination */
6160 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
6162 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[2] | 1)))
6166 /* 0xe35d undefined */
6167 /* 0xe360-0xe36f undefined */
6169 case 0xe372: /* STCY - store character */
6170 case 0xe3c3: /* STCH - store character high */
6171 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, inib
[3], insn
[1], ibyte
[4]);
6172 if (record_full_arch_list_add_mem (oaddr
, 1))
6176 /* 0xe374 undefined */
6178 case 0xe375: /* LAEY - load address extended */
6179 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
6181 if (record_full_arch_list_add_reg (regcache
, S390_A0_REGNUM
+ inib
[2]))
6185 /* 0xe37d-0xe37f undefined */
6186 /* 0xe383-0xe384 undefined */
6188 case 0xe385: /* LGAT - load and trap */
6189 case 0xe39c: /* LLGTAT - load logical thirty one bits and trap */
6190 case 0xe39d: /* LLGFAT - load logical and trap */
6191 case 0xe721: /* VLGV - vector load gr from vr element */
6192 /* 64-bit gpr destination + fpc for possible DXC write */
6193 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
6195 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
6199 /* 0xe38a-0xe38d undefined */
6200 /* 0xe392-0xe393 undefined */
6201 /* 0xe39a-0xe39b undefined */
6202 /* 0xe39e undefined */
6204 case 0xe39f: /* LAT - load and trap */
6205 /* 32-bit gpr destination + fpc for possible DXC write */
6206 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
6208 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
6212 /* 0xe3a0-0xe3bf undefined */
6214 case 0xe3c0: /* LBH - load byte high */
6215 case 0xe3c2: /* LLCH - load logical character high */
6216 case 0xe3c4: /* LHH - load halfword high */
6217 case 0xe3c6: /* LLHH - load logical halfword high */
6218 case 0xe3ca: /* LFH - load high */
6219 case 0xebe0: /* LOCFH - load high on condition */
6220 /* 32-bit high gpr destination */
6221 if (s390_record_gpr_h (gdbarch
, regcache
, inib
[2]))
6225 /* 0xe3c1 undefined */
6226 /* 0xe3c5 undefined */
6228 case 0xe3c8: /* LFHAT - load high and trap */
6229 /* 32-bit high gpr destination + fpc for possible DXC write */
6230 if (s390_record_gpr_h (gdbarch
, regcache
, inib
[2]))
6232 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
6236 /* 0xe3c9 undefined */
6237 /* 0xe3cc undefined */
6238 /* 0xe3ce undefined */
6239 /* 0xe3d0-0xe3ff undefined */
6241 case 0xe700: /* VLEB - vector load element */
6242 case 0xe701: /* VLEH - vector load element */
6243 case 0xe702: /* VLEG - vector load element */
6244 case 0xe703: /* VLEF - vector load element */
6245 case 0xe704: /* VLLEZ - vector load logical element and zero */
6246 case 0xe705: /* VLREP - vector load and replicate */
6247 case 0xe706: /* VL - vector load */
6248 case 0xe707: /* VLBB - vector load to block bounduary */
6249 case 0xe712: /* VGEG - vector gather element */
6250 case 0xe713: /* VGEF - vector gather element */
6251 case 0xe722: /* VLVG - vector load vr element from gr */
6252 case 0xe730: /* VESL - vector element shift left */
6253 case 0xe733: /* VERLL - vector element rotate left logical */
6254 case 0xe737: /* VLL - vector load with length */
6255 case 0xe738: /* VESRL - vector element shift right logical */
6256 case 0xe73a: /* VESRA - vector element shift right arithmetic */
6257 case 0xe740: /* VLEIB - vector load element immediate */
6258 case 0xe741: /* VLEIH - vector load element immediate */
6259 case 0xe742: /* VLEIG - vector load element immediate */
6260 case 0xe743: /* VLEIF - vector load element immediate */
6261 case 0xe744: /* VGBM - vector generate byte mask */
6262 case 0xe745: /* VREPI - vector replicate immediate */
6263 case 0xe746: /* VGM - vector generate mask */
6264 case 0xe74d: /* VREP - vector replicate */
6265 case 0xe750: /* VPOPCT - vector population count */
6266 case 0xe752: /* VCTZ - vector count trailing zeros */
6267 case 0xe753: /* VCLZ - vector count leading zeros */
6268 case 0xe756: /* VLR - vector load */
6269 case 0xe75f: /* VSEG -vector sign extend to doubleword */
6270 case 0xe760: /* VMRL - vector merge low */
6271 case 0xe761: /* VMRH - vector merge high */
6272 case 0xe762: /* VLVGP - vector load vr from grs disjoint */
6273 case 0xe764: /* VSUM - vector sum across word */
6274 case 0xe765: /* VSUMG - vector sum across doubleword */
6275 case 0xe766: /* VCKSM - vector checksum */
6276 case 0xe767: /* VSUMQ - vector sum across quadword */
6277 case 0xe768: /* VN - vector and */
6278 case 0xe769: /* VNC - vector and with complement */
6279 case 0xe76a: /* VO - vector or */
6280 case 0xe76b: /* VNO - vector nor */
6281 case 0xe76d: /* VX - vector xor */
6282 case 0xe770: /* VESLV - vector element shift left */
6283 case 0xe772: /* VERIM - vector element rotate and insert under mask */
6284 case 0xe773: /* VERLLV - vector element rotate left logical */
6285 case 0xe774: /* VSL - vector shift left */
6286 case 0xe775: /* VSLB - vector shift left by byte */
6287 case 0xe777: /* VSLDB - vector shift left double by byte */
6288 case 0xe778: /* VESRLV - vector element shift right logical */
6289 case 0xe77a: /* VESRAV - vector element shift right arithmetic */
6290 case 0xe77c: /* VSRL - vector shift right logical */
6291 case 0xe77d: /* VSRLB - vector shift right logical by byte */
6292 case 0xe77e: /* VSRA - vector shift right arithmetic */
6293 case 0xe77f: /* VSRAB - vector shift right arithmetic by byte */
6294 case 0xe784: /* VPDI - vector permute doubleword immediate */
6295 case 0xe78c: /* VPERM - vector permute */
6296 case 0xe78d: /* VSEL - vector select */
6297 case 0xe78e: /* VFMS - vector fp multiply and subtract */
6298 case 0xe78f: /* VFMA - vector fp multiply and add */
6299 case 0xe794: /* VPK - vector pack */
6300 case 0xe7a1: /* VMLH - vector multiply logical high */
6301 case 0xe7a2: /* VML - vector multiply low */
6302 case 0xe7a3: /* VMH - vector multiply high */
6303 case 0xe7a4: /* VMLE - vector multiply logical even */
6304 case 0xe7a5: /* VMLO - vector multiply logical odd */
6305 case 0xe7a6: /* VME - vector multiply even */
6306 case 0xe7a7: /* VMO - vector multiply odd */
6307 case 0xe7a9: /* VMALH - vector multiply and add logical high */
6308 case 0xe7aa: /* VMAL - vector multiply and add low */
6309 case 0xe7ab: /* VMAH - vector multiply and add high */
6310 case 0xe7ac: /* VMALE - vector multiply and add logical even */
6311 case 0xe7ad: /* VMALO - vector multiply and add logical odd */
6312 case 0xe7ae: /* VMAE - vector multiply and add even */
6313 case 0xe7af: /* VMAO - vector multiply and add odd */
6314 case 0xe7b4: /* VGFM - vector Galois field multiply sum */
6315 case 0xe7b9: /* VACCC - vector add with carry compute carry */
6316 case 0xe7bb: /* VAC - vector add with carry */
6317 case 0xe7bc: /* VGFMA - vector Galois field multiply sum and accumulate */
6318 case 0xe7bd: /* VSBCBI - vector subtract with borrow compute borrow indication */
6319 case 0xe7bf: /* VSBI - vector subtract with borrow indication */
6320 case 0xe7c0: /* VCLGD - vector convert to logical 64-bit */
6321 case 0xe7c1: /* VCDLG - vector convert from logical 64-bit */
6322 case 0xe7c2: /* VCGD - vector convert to fixed 64-bit */
6323 case 0xe7c3: /* VCDG - vector convert from fixed 64-bit */
6324 case 0xe7c4: /* VLDE - vector fp load lengthened */
6325 case 0xe7c5: /* VLED - vector fp load rounded */
6326 case 0xe7c7: /* VFI - vector load fp integer */
6327 case 0xe7cc: /* VFPSO - vector fp perform sign operation */
6328 case 0xe7ce: /* VFSQ - vector fp square root */
6329 case 0xe7d4: /* VUPLL - vector unpack logical low */
6330 case 0xe7d6: /* VUPL - vector unpack low */
6331 case 0xe7d5: /* VUPLH - vector unpack logical high */
6332 case 0xe7d7: /* VUPH - vector unpack high */
6333 case 0xe7de: /* VLC - vector load complement */
6334 case 0xe7df: /* VLP - vector load positive */
6335 case 0xe7e2: /* VFA - vector fp subtract */
6336 case 0xe7e3: /* VFA - vector fp add */
6337 case 0xe7e5: /* VFD - vector fp divide */
6338 case 0xe7e7: /* VFM - vector fp multiply */
6339 case 0xe7f0: /* VAVGL - vector average logical */
6340 case 0xe7f1: /* VACC - vector add and compute carry */
6341 case 0xe7f2: /* VAVG - vector average */
6342 case 0xe7f3: /* VA - vector add */
6343 case 0xe7f5: /* VSCBI - vector subtract compute borrow indication */
6344 case 0xe7f7: /* VS - vector subtract */
6345 case 0xe7fc: /* VMNL - vector minimum logical */
6346 case 0xe7fd: /* VMXL - vector maximum logical */
6347 case 0xe7fe: /* VMN - vector minimum */
6348 case 0xe7ff: /* VMX - vector maximum */
6349 /* vector destination + FPC */
6350 if (s390_record_vr (gdbarch
, regcache
, ivec
[0]))
6352 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
6356 case 0xe708: /* VSTEB - vector store element */
6357 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, inib
[3], insn
[1], 0);
6358 if (record_full_arch_list_add_mem (oaddr
, 1))
6360 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
6364 case 0xe709: /* VSTEH - vector store element */
6365 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, inib
[3], insn
[1], 0);
6366 if (record_full_arch_list_add_mem (oaddr
, 2))
6368 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
6372 case 0xe70a: /* VSTEG - vector store element */
6373 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, inib
[3], insn
[1], 0);
6374 if (record_full_arch_list_add_mem (oaddr
, 8))
6376 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
6380 case 0xe70b: /* VSTEF - vector store element */
6381 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, inib
[3], insn
[1], 0);
6382 if (record_full_arch_list_add_mem (oaddr
, 4))
6384 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
6388 /* 0xe70c-0xe70d undefined */
6390 case 0xe70e: /* VST - vector store */
6391 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, inib
[3], insn
[1], 0);
6392 if (record_full_arch_list_add_mem (oaddr
, 16))
6394 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
6398 /* 0xe70f-0xe711 undefined */
6399 /* 0xe714-0xe719 undefined */
6401 case 0xe71a: /* VSCEG - vector scatter element */
6402 if (s390_record_calc_disp_vsce (gdbarch
, regcache
, ivec
[1], inib
[8], 8, insn
[1], 0, &oaddr
))
6404 if (record_full_arch_list_add_mem (oaddr
, 8))
6406 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
6410 case 0xe71b: /* VSCEF - vector scatter element */
6411 if (s390_record_calc_disp_vsce (gdbarch
, regcache
, ivec
[1], inib
[8], 4, insn
[1], 0, &oaddr
))
6413 if (record_full_arch_list_add_mem (oaddr
, 4))
6415 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
6419 /* 0xe71c-0xe720 undefined */
6420 /* 0xe723-0xe726 undefined */
6421 /* 0xe728-0xe72f undefined */
6422 /* 0xe731-0xe732 undefined */
6423 /* 0xe734-0xe735 undefined */
6425 case 0xe736: /* VLM - vector load multiple */
6426 for (i
= ivec
[0]; i
!= ivec
[1]; i
++, i
&= 0x1f)
6427 if (s390_record_vr (gdbarch
, regcache
, i
))
6429 if (s390_record_vr (gdbarch
, regcache
, ivec
[1]))
6431 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
6435 /* 0xe739 undefined */
6436 /* 0xe73b-0xe73d undefined */
6438 case 0xe73e: /* VSTM - vector store multiple */
6439 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
6440 if (ivec
[0] <= ivec
[1])
6441 n
= ivec
[1] - ivec
[0] + 1;
6443 n
= ivec
[1] + 0x20 - ivec
[0] + 1;
6444 if (record_full_arch_list_add_mem (oaddr
, n
* 16))
6446 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
6450 case 0xe73f: /* VSTL - vector store with length */
6451 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
6452 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ inib
[3], &tmp
);
6456 if (record_full_arch_list_add_mem (oaddr
, tmp
))
6458 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
6462 /* 0xe747-0xe749 undefined */
6464 case 0xe74a: /* VFTCI - vector fp test data class immediate */
6465 case 0xe75c: /* VISTR - vector isolate string */
6466 case 0xe780: /* VFEE - vector find element equal */
6467 case 0xe781: /* VFENE - vector find element not equal */
6468 case 0xe782: /* VFA - vector find any element equal */
6469 case 0xe78a: /* VSTRC - vector string range compare */
6470 case 0xe795: /* VPKLS - vector pack logical saturate */
6471 case 0xe797: /* VPKS - vector pack saturate */
6472 case 0xe7e8: /* VFCE - vector fp compare equal */
6473 case 0xe7ea: /* VFCHE - vector fp compare high or equal */
6474 case 0xe7eb: /* VFCE - vector fp compare high */
6475 case 0xe7f8: /* VCEQ - vector compare equal */
6476 case 0xe7f9: /* VCHL - vector compare high logical */
6477 case 0xe7fb: /* VCH - vector compare high */
6478 /* vector destination + flags + FPC */
6479 if (s390_record_vr (gdbarch
, regcache
, ivec
[0]))
6481 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
6483 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
6487 /* 0xe74b-0xe74c undefined */
6488 /* 0xe74e-0xe74f undefined */
6489 /* 0xe751 undefined */
6490 /* 0xe754-0xe755 undefined */
6491 /* 0xe757-0xe75b undefined */
6492 /* 0xe75d-0xe75e undefined */
6493 /* 0xe763 undefined */
6494 /* 0xe76c undefined */
6495 /* 0xe76e-0xe76f undefined */
6496 /* 0xe771 undefined */
6497 /* 0xe776 undefined */
6498 /* 0xe779 undefined */
6499 /* 0xe77b undefined */
6500 /* 0xe783 undefined */
6501 /* 0xe785-0xe789 undefined */
6502 /* 0xe78b undefined */
6503 /* 0xe790-0xe793 undefined */
6504 /* 0xe796 undefined */
6505 /* 0xe798-0xe7a0 undefined */
6506 /* 0xe7a8 undefined */
6507 /* 0xe7b0-0xe7b3 undefined */
6508 /* 0xe7b5-0xe7b8 undefined */
6509 /* 0xe7ba undefined */
6510 /* 0xe7be undefined */
6511 /* 0xe7c6 undefined */
6512 /* 0xe7c8-0xe7c9 undefined */
6514 case 0xe7ca: /* WFK - vector fp compare and signal scalar */
6515 case 0xe7cb: /* WFC - vector fp compare scalar */
6516 case 0xe7d8: /* VTM - vector test under mask */
6517 case 0xe7d9: /* VECL - vector element compare logical */
6518 case 0xe7db: /* VEC - vector element compare */
6519 case 0xed08: /* KEB - compare and signal */
6520 case 0xed09: /* CEB - compare */
6521 case 0xed18: /* KDB - compare and signal */
6522 case 0xed19: /* CDB - compare */
6523 /* flags + fpc only */
6524 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
6526 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
6530 /* 0xe7cd undefined */
6531 /* 0xe7cf-0xe7d3 undefined */
6532 /* 0xe7da undefined */
6533 /* 0xe7dc-0xe7dd undefined */
6534 /* 0xe7e0-0xe7e1 undefined */
6535 /* 0xe7e4 undefined */
6536 /* 0xe7e6 undefined */
6537 /* 0xe7e9 undefined */
6538 /* 0xe7ec-0xe7ef undefined */
6539 /* 0xe7f4 undefined */
6540 /* 0xe7f6 undefined */
6541 /* 0xe7fa undefined */
6543 /* 0xeb00-0xeb03 undefined */
6545 case 0xeb04: /* LMG - load multiple */
6546 for (i
= inib
[2]; i
!= inib
[3]; i
++, i
&= 0xf)
6547 if (s390_record_gpr_g (gdbarch
, regcache
, i
))
6549 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[3]))
6553 /* 0xeb05-0xeb09 undefined */
6554 /* 0xeb0e undefined */
6555 /* 0xeb0f privileged: TRACG */
6556 /* 0xeb10-0xeb13 undefined */
6558 case 0xeb14: /* CSY - compare and swap */
6559 case 0xebf4: /* LAN - load and and */
6560 case 0xebf6: /* LAO - load and or */
6561 case 0xebf7: /* LAX - load and xor */
6562 case 0xebf8: /* LAA - load and add */
6563 case 0xebfa: /* LAAL - load and add logical */
6564 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], ibyte
[4]);
6565 if (record_full_arch_list_add_mem (oaddr
, 4))
6567 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
6569 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
6573 /* 0xeb15-0xeb1b undefined */
6574 /* 0xeb1e-0xeb1f undefined */
6575 /* 0xeb22 undefined */
6577 case 0xeb23: /* CLT - compare logical and trap */
6578 case 0xeb2b: /* CLGT - compare logical and trap */
6579 /* fpc only - including possible DXC write for trapping insns */
6580 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
6584 case 0xeb24: /* STMG - store multiple */
6585 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], ibyte
[4]);
6586 if (inib
[2] <= inib
[3])
6587 n
= inib
[3] - inib
[2] + 1;
6589 n
= inib
[3] + 0x10 - inib
[2] + 1;
6590 if (record_full_arch_list_add_mem (oaddr
, n
* 8))
6594 /* 0xeb25 privileged */
6596 case 0xeb26: /* STMH - store multiple high */
6597 case 0xeb90: /* STMY - store multiple */
6598 case 0xeb9b: /* STAMY - store access multiple */
6599 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], ibyte
[4]);
6600 if (inib
[2] <= inib
[3])
6601 n
= inib
[3] - inib
[2] + 1;
6603 n
= inib
[3] + 0x10 - inib
[2] + 1;
6604 if (record_full_arch_list_add_mem (oaddr
, n
* 4))
6608 /* 0xeb27-0xeb2a undefined */
6610 case 0xeb2c: /* STCMH - store characters under mask */
6611 case 0xeb2d: /* STCMY - store characters under mask */
6612 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], ibyte
[4]);
6613 if (record_full_arch_list_add_mem (oaddr
, s390_popcnt (inib
[3])))
6617 /* 0xeb2e undefined */
6618 /* 0xeb2f privileged */
6620 case 0xeb30: /* CSG - compare and swap */
6621 case 0xebe4: /* LANG - load and and */
6622 case 0xebe6: /* LAOG - load and or */
6623 case 0xebe7: /* LAXG - load and xor */
6624 case 0xebe8: /* LAAG - load and add */
6625 case 0xebea: /* LAALG - load and add logical */
6626 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], ibyte
[4]);
6627 if (record_full_arch_list_add_mem (oaddr
, 8))
6629 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
6631 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
6635 case 0xeb31: /* CDSY - compare double and swap */
6636 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], ibyte
[4]);
6637 if (record_full_arch_list_add_mem (oaddr
, 8))
6639 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
6641 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[2] | 1)))
6643 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
6647 /* 0xeb32-0xeb3d undefined */
6649 case 0xeb3e: /* CDSG - compare double and swap */
6650 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], ibyte
[4]);
6651 if (record_full_arch_list_add_mem (oaddr
, 16))
6653 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
6655 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2] | 1))
6657 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
6661 /* 0xeb3f-0xeb43 undefined */
6662 /* 0xeb46-0xeb4b undefined */
6663 /* 0xeb4d-0xeb50 undefined */
6665 case 0xeb52: /* MVIY - move */
6666 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], ibyte
[4]);
6667 if (record_full_arch_list_add_mem (oaddr
, 1))
6671 case 0xeb54: /* NIY - and */
6672 case 0xeb56: /* OIY - or */
6673 case 0xeb57: /* XIY - xor */
6674 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], ibyte
[4]);
6675 if (record_full_arch_list_add_mem (oaddr
, 1))
6677 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
6681 /* 0xeb53 undefined */
6682 /* 0xeb58-0xeb69 undefined */
6684 case 0xeb6a: /* ASI - add immediate */
6685 case 0xeb6e: /* ALSI - add immediate */
6686 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], ibyte
[4]);
6687 if (record_full_arch_list_add_mem (oaddr
, 4))
6689 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
6693 /* 0xeb6b-0xeb6d undefined */
6694 /* 0xeb6f-0xeb79 undefined */
6696 case 0xeb7a: /* AGSI - add immediate */
6697 case 0xeb7e: /* ALGSI - add immediate */
6698 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], ibyte
[4]);
6699 if (record_full_arch_list_add_mem (oaddr
, 8))
6701 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
6705 /* 0xeb7b-0xeb7d undefined */
6706 /* 0xeb7f undefined */
6708 case 0xeb80: /* ICMH - insert characters under mask */
6709 /* 32-bit high gpr destination + flags */
6710 if (s390_record_gpr_h (gdbarch
, regcache
, inib
[2]))
6712 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
6716 /* 0xeb82-0xeb8d undefined */
6718 case 0xeb8e: /* MVCLU - move long unicode [partial] */
6719 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ inib
[2], &tmp
);
6720 oaddr
= s390_record_address_mask (gdbarch
, regcache
, tmp
);
6721 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ (inib
[2] | 1), &tmp
);
6722 if (record_full_arch_list_add_mem (oaddr
, tmp
))
6724 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
6726 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[2] | 1)))
6728 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[3]))
6730 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[3] | 1)))
6732 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
6736 case 0xeb8f: /* CLCLU - compare logical long unicode [partial] */
6737 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
6739 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[2] | 1)))
6741 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[3]))
6743 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ (inib
[3] | 1)))
6745 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
6749 /* 0xeb91-0xeb95 undefined */
6751 case 0xeb96: /* LMH - load multiple high */
6752 for (i
= inib
[2]; i
!= inib
[3]; i
++, i
&= 0xf)
6753 if (s390_record_gpr_h (gdbarch
, regcache
, i
))
6755 if (s390_record_gpr_h (gdbarch
, regcache
, inib
[3]))
6759 /* 0xeb97 undefined */
6761 case 0xeb98: /* LMY - load multiple */
6762 for (i
= inib
[2]; i
!= inib
[3]; i
++, i
&= 0xf)
6763 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ i
))
6765 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[3]))
6769 /* 0xeb99 undefined */
6771 case 0xeb9a: /* LAMY - load access multiple */
6772 for (i
= inib
[2]; i
!= inib
[3]; i
++, i
&= 0xf)
6773 if (record_full_arch_list_add_reg (regcache
, S390_A0_REGNUM
+ i
))
6775 if (record_full_arch_list_add_reg (regcache
, S390_A0_REGNUM
+ inib
[3]))
6779 /* 0xeb9c-0xebbf undefined */
6780 /* 0xebc1-0xebdb undefined */
6781 /* 0xebe5 undefined */
6782 /* 0xebe9 undefined */
6783 /* 0xebeb-0xebf1 undefined */
6784 /* 0xebf5 undefined */
6785 /* 0xebf9 undefined */
6786 /* 0xebfb-0xebff undefined */
6788 /* 0xed00-0xed03 undefined */
6790 case 0xed04: /* LDEB - load lengthened */
6791 case 0xed0c: /* MDEB - multiply */
6792 case 0xed0d: /* DEB - divide */
6793 case 0xed14: /* SQEB - square root */
6794 case 0xed15: /* SQDB - square root */
6795 case 0xed17: /* MEEB - multiply */
6796 case 0xed1c: /* MDB - multiply */
6797 case 0xed1d: /* DDB - divide */
6798 /* float destination + fpc */
6799 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[2]))
6801 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
6805 case 0xed05: /* LXDB - load lengthened */
6806 case 0xed06: /* LXEB - load lengthened */
6807 case 0xed07: /* MXDB - multiply */
6808 /* float pair destination + fpc */
6809 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[2]))
6811 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ (inib
[2] | 2)))
6813 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
6817 case 0xed0a: /* AEB - add */
6818 case 0xed0b: /* SEB - subtract */
6819 case 0xed1a: /* ADB - add */
6820 case 0xed1b: /* SDB - subtract */
6821 /* float destination + flags + fpc */
6822 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[2]))
6824 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
6826 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
6830 case 0xed0e: /* MAEB - multiply and add */
6831 case 0xed0f: /* MSEB - multiply and subtract */
6832 case 0xed1e: /* MADB - multiply and add */
6833 case 0xed1f: /* MSDB - multiply and subtract */
6834 case 0xed40: /* SLDT - shift significand left */
6835 case 0xed41: /* SRDT - shift significand right */
6836 case 0xedaa: /* CDZT - convert from zoned */
6837 case 0xedae: /* CDPT - convert from packed */
6838 /* float destination [RXF] + fpc */
6839 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[8]))
6841 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
6845 /* 0xed13 undefined */
6846 /* 0xed16 undefined */
6847 /* 0xed20-0xed23 undefined */
6849 case 0xed24: /* LDE - load lengthened */
6850 case 0xed34: /* SQE - square root */
6851 case 0xed35: /* SQD - square root */
6852 case 0xed37: /* MEE - multiply */
6853 case 0xed64: /* LEY - load */
6854 case 0xed65: /* LDY - load */
6855 /* float destination */
6856 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[2]))
6860 case 0xed25: /* LXD - load lengthened */
6861 case 0xed26: /* LXE - load lengthened */
6862 /* float pair destination */
6863 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[2]))
6865 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ (inib
[2] | 2)))
6869 /* 0xed27-0xed2d undefined */
6871 case 0xed2e: /* MAE - multiply and add */
6872 case 0xed2f: /* MSE - multiply and subtract */
6873 case 0xed38: /* MAYL - multiply and add unnormalized */
6874 case 0xed39: /* MYL - multiply unnormalized */
6875 case 0xed3c: /* MAYH - multiply and add unnormalized */
6876 case 0xed3d: /* MYH - multiply unnormalized */
6877 case 0xed3e: /* MAD - multiply and add */
6878 case 0xed3f: /* MSD - multiply and subtract */
6879 /* float destination [RXF] */
6880 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[8]))
6884 /* 0xed30-0xed33 undefined */
6885 /* 0xed36 undefined */
6887 case 0xed3a: /* MAY - multiply and add unnormalized */
6888 case 0xed3b: /* MY - multiply unnormalized */
6889 /* float pair destination [RXF] */
6890 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[8]))
6892 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ (inib
[8] | 2)))
6896 /* 0xed42-0xed47 undefind */
6898 case 0xed48: /* SLXT - shift significand left */
6899 case 0xed49: /* SRXT - shift significand right */
6900 case 0xedab: /* CXZT - convert from zoned */
6901 case 0xedaf: /* CXPT - convert from packed */
6902 /* float pair destination [RXF] + fpc */
6903 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ inib
[8]))
6905 if (record_full_arch_list_add_reg (regcache
, S390_F0_REGNUM
+ (inib
[8] | 2)))
6907 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
6911 /* 0xed4a-0xed4f undefind */
6912 /* 0xed52-0xed53 undefind */
6913 /* 0xed56-0xed57 undefind */
6914 /* 0xed5a-0xed63 undefind */
6915 /* 0xed68-0xeda7 undefined */
6917 case 0xeda8: /* CZDT - convert to zoned */
6918 case 0xeda9: /* CZXT - convert to zoned */
6919 case 0xedac: /* CPDT - convert to packed */
6920 case 0xedad: /* CPXT - convert to packed */
6921 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
6922 if (record_full_arch_list_add_mem (oaddr
, ibyte
[1] + 1))
6924 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
6928 /* 0xedb0-0xedff undefined */
6935 /* 0xe4 undefined */
6938 /* SSE/SIL-format instruction */
6941 /* 0xe500-0xe543 undefined, privileged, or unsupported */
6943 case 0xe544: /* MVHHI - move */
6944 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
6945 if (record_full_arch_list_add_mem (oaddr
, 2))
6949 /* 0xe545-0xe547 undefined */
6951 case 0xe548: /* MVGHI - move */
6952 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
6953 if (record_full_arch_list_add_mem (oaddr
, 8))
6957 /* 0xe549-0xe54b undefined */
6959 case 0xe54c: /* MVHI - move */
6960 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
6961 if (record_full_arch_list_add_mem (oaddr
, 4))
6965 /* 0xe54d-0xe553 undefined */
6967 case 0xe554: /* CHHSI - compare halfword immediate */
6968 case 0xe555: /* CLHHSI - compare logical immediate */
6969 case 0xe558: /* CGHSI - compare halfword immediate */
6970 case 0xe559: /* CLGHSI - compare logical immediate */
6971 case 0xe55c: /* CHSI - compare halfword immediate */
6972 case 0xe55d: /* CLFHSI - compare logical immediate */
6973 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
6977 /* 0xe556-0xe557 undefined */
6978 /* 0xe55a-0xe55b undefined */
6979 /* 0xe55e-0xe55f undefined */
6981 case 0xe560: /* TBEGIN - transaction begin */
6982 /* The transaction will be immediately aborted after this
6983 instruction, due to single-stepping. This instruction is
6984 only supported so that the program can fail a few times
6985 and go to the non-transactional fallback. */
6988 /* Transaction diagnostic block - user. */
6989 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
6990 if (record_full_arch_list_add_mem (oaddr
, 256))
6993 /* Transaction diagnostic block - supervisor. */
6994 if (record_full_arch_list_add_reg (regcache
, S390_TDB_DWORD0_REGNUM
))
6996 if (record_full_arch_list_add_reg (regcache
, S390_TDB_ABORT_CODE_REGNUM
))
6998 if (record_full_arch_list_add_reg (regcache
, S390_TDB_CONFLICT_TOKEN_REGNUM
))
7000 if (record_full_arch_list_add_reg (regcache
, S390_TDB_ATIA_REGNUM
))
7002 for (i
= 0; i
< 16; i
++)
7003 if (record_full_arch_list_add_reg (regcache
, S390_TDB_R0_REGNUM
+ i
))
7006 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
7010 /* 0xe561 unsupported: TBEGINC */
7011 /* 0xe562-0xe5ff undefined */
7018 /* 0xe6 undefined */
7021 /* RIE/RIS/RRS-format instruction */
7022 switch (ibyte
[0] << 8 | ibyte
[5])
7024 /* 0xec00-0xec41 undefined */
7026 case 0xec42: /* LOCHI - load halfword immediate on condition */
7027 case 0xec51: /* RISBLG - rotate then insert selected bits low */
7028 /* 32-bit or native gpr destination */
7029 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
7033 /* 0xec43 undefined */
7035 case 0xec44: /* BRXHG - branch relative on index high */
7036 case 0xec45: /* BRXLG - branch relative on index low or equal */
7037 case 0xec46: /* LOCGHI - load halfword immediate on condition */
7038 case 0xec59: /* RISBGN - rotate then insert selected bits */
7039 /* 64-bit gpr destination */
7040 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
7044 /* 0xec47-0xec4d undefined */
7046 case 0xec4e: /* LOCHHI - load halfword immediate on condition */
7047 case 0xec5d: /* RISBHG - rotate then insert selected bits high */
7048 /* 32-bit high gpr destination */
7049 if (s390_record_gpr_h (gdbarch
, regcache
, inib
[2]))
7053 /* 0xec4f-0xec50 undefined */
7054 /* 0xec52-0xec53 undefined */
7056 case 0xec54: /* RNSBG - rotate then and selected bits */
7057 case 0xec55: /* RISBG - rotate then insert selected bits */
7058 case 0xec56: /* ROSBG - rotate then or selected bits */
7059 case 0xec57: /* RXSBG - rotate then xor selected bits */
7060 case 0xecd9: /* AGHIK - add immediate */
7061 case 0xecdb: /* ALGHSIK - add logical immediate */
7062 /* 64-bit gpr destination + flags */
7063 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
7065 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
7069 /* 0xec58 undefined */
7070 /* 0xec5a-0xec5c undefined */
7071 /* 0xec5e-0xec63 undefined */
7073 case 0xec64: /* CGRJ - compare and branch relative */
7074 case 0xec65: /* CLGRJ - compare logical and branch relative */
7075 case 0xec76: /* CRJ - compare and branch relative */
7076 case 0xec77: /* CLRJ - compare logical and branch relative */
7077 case 0xec7c: /* CGIJ - compare immediate and branch relative */
7078 case 0xec7d: /* CLGIJ - compare logical immediate and branch relative */
7079 case 0xec7e: /* CIJ - compare immediate and branch relative */
7080 case 0xec7f: /* CLIJ - compare logical immediate and branch relative */
7081 case 0xece4: /* CGRB - compare and branch */
7082 case 0xece5: /* CLGRB - compare logical and branch */
7083 case 0xecf6: /* CRB - compare and branch */
7084 case 0xecf7: /* CLRB - compare logical and branch */
7085 case 0xecfc: /* CGIB - compare immediate and branch */
7086 case 0xecfd: /* CLGIB - compare logical immediate and branch */
7087 case 0xecfe: /* CIB - compare immediate and branch */
7088 case 0xecff: /* CLIB - compare logical immediate and branch */
7091 /* 0xec66-0xec6f undefined */
7093 case 0xec70: /* CGIT - compare immediate and trap */
7094 case 0xec71: /* CLGIT - compare logical immediate and trap */
7095 case 0xec72: /* CIT - compare immediate and trap */
7096 case 0xec73: /* CLFIT - compare logical immediate and trap */
7097 /* fpc only - including possible DXC write for trapping insns */
7098 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
7102 /* 0xec74-0xec75 undefined */
7103 /* 0xec78-0xec7b undefined */
7105 /* 0xec80-0xecd7 undefined */
7107 case 0xecd8: /* AHIK - add immediate */
7108 case 0xecda: /* ALHSIK - add logical immediate */
7109 /* 32-bit gpr destination + flags */
7110 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
7112 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
7116 /* 0xecdc-0xece3 undefined */
7117 /* 0xece6-0xecf5 undefined */
7118 /* 0xecf8-0xecfb undefined */
7125 case 0xee: /* PLO - perform locked operation */
7126 regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
, &tmp
);
7127 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
7128 oaddr2
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[2], 0);
7131 uint8_t fc
= tmp
& 0xff;
7137 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
7140 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[3]))
7144 case 0x01: /* CLG */
7146 if (record_full_arch_list_add_mem (oaddr2
+ 0x08, 8))
7149 if (record_full_arch_list_add_mem (oaddr2
+ 0x28, 8))
7153 case 0x02: /* CLGR */
7155 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
7158 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[3]))
7162 case 0x03: /* CLX */
7164 if (record_full_arch_list_add_mem (oaddr2
+ 0x00, 16))
7167 if (record_full_arch_list_add_mem (oaddr2
+ 0x20, 16))
7171 case 0x08: /* DCS */
7173 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[3]))
7176 case 0x0c: /* CSST */
7178 if (record_full_arch_list_add_mem (oaddr2
, 4))
7182 case 0x14: /* CSTST */
7184 if (target_read_memory (oaddr2
+ 0x88, buf
, 8))
7186 oaddr3
= extract_unsigned_integer (buf
, 8, byte_order
);
7187 oaddr3
= s390_record_address_mask (gdbarch
, regcache
, oaddr3
);
7188 if (record_full_arch_list_add_mem (oaddr3
, 4))
7191 case 0x10: /* CSDST */
7193 if (target_read_memory (oaddr2
+ 0x68, buf
, 8))
7195 oaddr3
= extract_unsigned_integer (buf
, 8, byte_order
);
7196 oaddr3
= s390_record_address_mask (gdbarch
, regcache
, oaddr3
);
7197 if (record_full_arch_list_add_mem (oaddr3
, 4))
7200 if (target_read_memory (oaddr2
+ 0x48, buf
, 8))
7202 oaddr3
= extract_unsigned_integer (buf
, 8, byte_order
);
7203 oaddr3
= s390_record_address_mask (gdbarch
, regcache
, oaddr3
);
7204 if (record_full_arch_list_add_mem (oaddr3
, 4))
7210 if (record_full_arch_list_add_reg (regcache
, S390_R0_REGNUM
+ inib
[2]))
7213 if (record_full_arch_list_add_mem (oaddr
, 4))
7217 case 0x09: /* DCSG */
7219 if (record_full_arch_list_add_mem (oaddr2
+ 0x28, 8))
7223 case 0x15: /* CSTSTG */
7225 if (target_read_memory (oaddr2
+ 0x88, buf
, 8))
7227 oaddr3
= extract_unsigned_integer (buf
, 8, byte_order
);
7228 oaddr3
= s390_record_address_mask (gdbarch
, regcache
, oaddr3
);
7229 if (record_full_arch_list_add_mem (oaddr3
, 8))
7232 case 0x11: /* CSDSTG */
7234 if (target_read_memory (oaddr2
+ 0x68, buf
, 8))
7236 oaddr3
= extract_unsigned_integer (buf
, 8, byte_order
);
7237 oaddr3
= s390_record_address_mask (gdbarch
, regcache
, oaddr3
);
7238 if (record_full_arch_list_add_mem (oaddr3
, 8))
7241 case 0x0d: /* CSSTG */
7244 if (target_read_memory (oaddr2
+ 0x48, buf
, 8))
7246 oaddr3
= extract_unsigned_integer (buf
, 8, byte_order
);
7247 oaddr3
= s390_record_address_mask (gdbarch
, regcache
, oaddr3
);
7248 if (record_full_arch_list_add_mem (oaddr3
, 8))
7251 case 0x05: /* CSG */
7253 if (record_full_arch_list_add_mem (oaddr2
+ 0x08, 8))
7256 if (record_full_arch_list_add_mem (oaddr
, 8))
7260 case 0x0a: /* DCSGR */
7262 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[3]))
7265 case 0x0e: /* CSSTGR */
7267 if (record_full_arch_list_add_mem (oaddr2
, 8))
7271 case 0x16: /* CSTSTGR */
7273 if (target_read_memory (oaddr2
+ 0x88, buf
, 8))
7275 oaddr3
= extract_unsigned_integer (buf
, 8, byte_order
);
7276 oaddr3
= s390_record_address_mask (gdbarch
, regcache
, oaddr3
);
7277 if (record_full_arch_list_add_mem (oaddr3
, 8))
7280 case 0x12: /* CSDSTGR */
7282 if (target_read_memory (oaddr2
+ 0x68, buf
, 8))
7284 oaddr3
= extract_unsigned_integer (buf
, 8, byte_order
);
7285 oaddr3
= s390_record_address_mask (gdbarch
, regcache
, oaddr3
);
7286 if (record_full_arch_list_add_mem (oaddr3
, 8))
7289 if (target_read_memory (oaddr2
+ 0x48, buf
, 8))
7291 oaddr3
= extract_unsigned_integer (buf
, 8, byte_order
);
7292 oaddr3
= s390_record_address_mask (gdbarch
, regcache
, oaddr3
);
7293 if (record_full_arch_list_add_mem (oaddr3
, 8))
7296 case 0x06: /* CSGR */
7299 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[2]))
7302 if (record_full_arch_list_add_mem (oaddr
, 8))
7306 case 0x0b: /* DCSX */
7308 if (record_full_arch_list_add_mem (oaddr2
+ 0x20, 16))
7312 case 0x17: /* CSTSTX */
7314 if (target_read_memory (oaddr2
+ 0x88, buf
, 8))
7316 oaddr3
= extract_unsigned_integer (buf
, 8, byte_order
);
7317 oaddr3
= s390_record_address_mask (gdbarch
, regcache
, oaddr3
);
7318 if (record_full_arch_list_add_mem (oaddr3
, 16))
7321 case 0x13: /* CSDSTX */
7323 if (target_read_memory (oaddr2
+ 0x68, buf
, 8))
7325 oaddr3
= extract_unsigned_integer (buf
, 8, byte_order
);
7326 oaddr3
= s390_record_address_mask (gdbarch
, regcache
, oaddr3
);
7327 if (record_full_arch_list_add_mem (oaddr3
, 16))
7330 case 0x0f: /* CSSTX */
7333 if (target_read_memory (oaddr2
+ 0x48, buf
, 8))
7335 oaddr3
= extract_unsigned_integer (buf
, 8, byte_order
);
7336 oaddr3
= s390_record_address_mask (gdbarch
, regcache
, oaddr3
);
7337 if (record_full_arch_list_add_mem (oaddr3
, 16))
7340 case 0x07: /* CSX */
7342 if (record_full_arch_list_add_mem (oaddr2
+ 0x00, 16))
7345 if (record_full_arch_list_add_mem (oaddr
, 16))
7350 fprintf_unfiltered (gdb_stdlog
, "Warning: Unknown PLO FC %02x at %s.\n",
7351 fc
, paddress (gdbarch
, addr
));
7355 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
7359 case 0xef: /* LMD - load multiple disjoint */
7360 for (i
= inib
[2]; i
!= inib
[3]; i
++, i
&= 0xf)
7361 if (s390_record_gpr_g (gdbarch
, regcache
, i
))
7363 if (s390_record_gpr_g (gdbarch
, regcache
, inib
[3]))
7367 case 0xf0: /* SRP - shift and round decimal */
7368 case 0xf8: /* ZAP - zero and add */
7369 case 0xfa: /* AP - add decimal */
7370 case 0xfb: /* SP - subtract decimal */
7371 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
7372 if (record_full_arch_list_add_mem (oaddr
, inib
[2] + 1))
7374 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
7376 /* DXC may be written */
7377 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
7381 case 0xf1: /* MVO - move with offset */
7382 case 0xf2: /* PACK - pack */
7383 case 0xf3: /* UNPK - unpack */
7384 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
7385 if (record_full_arch_list_add_mem (oaddr
, inib
[2] + 1))
7389 /* 0xf4-0xf7 undefined */
7391 case 0xf9: /* CP - compare decimal */
7392 if (record_full_arch_list_add_reg (regcache
, S390_PSWM_REGNUM
))
7394 /* DXC may be written */
7395 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
7399 case 0xfc: /* MP - multiply decimal */
7400 case 0xfd: /* DP - divide decimal */
7401 oaddr
= s390_record_calc_disp (gdbarch
, regcache
, 0, insn
[1], 0);
7402 if (record_full_arch_list_add_mem (oaddr
, inib
[2] + 1))
7404 /* DXC may be written */
7405 if (record_full_arch_list_add_reg (regcache
, S390_FPC_REGNUM
))
7409 /* 0xfe-0xff undefined */
7413 fprintf_unfiltered (gdb_stdlog
, "Warning: Don't know how to record %04x "
7414 "at %s.\n", insn
[0], paddress (gdbarch
, addr
));
7418 if (record_full_arch_list_add_reg (regcache
, S390_PSWA_REGNUM
))
7420 if (record_full_arch_list_add_end ())
7425 /* Initialize linux_record_tdep if not initialized yet. */
7428 s390_init_linux_record_tdep (struct linux_record_tdep
*record_tdep
,
7429 enum s390_abi_kind abi
)
7431 /* These values are the size of the type that will be used in a system
7432 call. They are obtained from Linux Kernel source. */
7434 if (abi
== ABI_LINUX_ZSERIES
)
7436 record_tdep
->size_pointer
= 8;
7437 /* no _old_kernel_stat */
7438 record_tdep
->size_tms
= 32;
7439 record_tdep
->size_loff_t
= 8;
7440 record_tdep
->size_flock
= 32;
7441 record_tdep
->size_ustat
= 32;
7442 record_tdep
->size_old_sigaction
= 32;
7443 record_tdep
->size_old_sigset_t
= 8;
7444 record_tdep
->size_rlimit
= 16;
7445 record_tdep
->size_rusage
= 144;
7446 record_tdep
->size_timeval
= 16;
7447 record_tdep
->size_timezone
= 8;
7448 /* old_[ug]id_t never used */
7449 record_tdep
->size_fd_set
= 128;
7450 record_tdep
->size_old_dirent
= 280;
7451 record_tdep
->size_statfs
= 88;
7452 record_tdep
->size_statfs64
= 88;
7453 record_tdep
->size_sockaddr
= 16;
7454 record_tdep
->size_int
= 4;
7455 record_tdep
->size_long
= 8;
7456 record_tdep
->size_ulong
= 8;
7457 record_tdep
->size_msghdr
= 56;
7458 record_tdep
->size_itimerval
= 32;
7459 record_tdep
->size_stat
= 144;
7460 /* old_utsname unused */
7461 record_tdep
->size_sysinfo
= 112;
7462 record_tdep
->size_msqid_ds
= 120;
7463 record_tdep
->size_shmid_ds
= 112;
7464 record_tdep
->size_new_utsname
= 390;
7465 record_tdep
->size_timex
= 208;
7466 record_tdep
->size_mem_dqinfo
= 24;
7467 record_tdep
->size_if_dqblk
= 72;
7468 record_tdep
->size_fs_quota_stat
= 80;
7469 record_tdep
->size_timespec
= 16;
7470 record_tdep
->size_pollfd
= 8;
7471 record_tdep
->size_NFS_FHSIZE
= 32;
7472 record_tdep
->size_knfsd_fh
= 132;
7473 record_tdep
->size_TASK_COMM_LEN
= 16;
7474 record_tdep
->size_sigaction
= 32;
7475 record_tdep
->size_sigset_t
= 8;
7476 record_tdep
->size_siginfo_t
= 128;
7477 record_tdep
->size_cap_user_data_t
= 12;
7478 record_tdep
->size_stack_t
= 24;
7479 record_tdep
->size_off_t
= 8;
7481 record_tdep
->size_gid_t
= 4;
7482 record_tdep
->size_uid_t
= 4;
7483 record_tdep
->size_PAGE_SIZE
= 0x1000; /* 4KB */
7484 record_tdep
->size_flock64
= 32;
7485 record_tdep
->size_io_event
= 32;
7486 record_tdep
->size_iocb
= 64;
7487 record_tdep
->size_epoll_event
= 16;
7488 record_tdep
->size_itimerspec
= 32;
7489 record_tdep
->size_mq_attr
= 64;
7490 record_tdep
->size_termios
= 36;
7491 record_tdep
->size_termios2
= 44;
7492 record_tdep
->size_pid_t
= 4;
7493 record_tdep
->size_winsize
= 8;
7494 record_tdep
->size_serial_struct
= 72;
7495 record_tdep
->size_serial_icounter_struct
= 80;
7496 record_tdep
->size_size_t
= 8;
7497 record_tdep
->size_iovec
= 16;
7498 record_tdep
->size_time_t
= 8;
7500 else if (abi
== ABI_LINUX_S390
)
7502 record_tdep
->size_pointer
= 4;
7503 record_tdep
->size__old_kernel_stat
= 32;
7504 record_tdep
->size_tms
= 16;
7505 record_tdep
->size_loff_t
= 8;
7506 record_tdep
->size_flock
= 16;
7507 record_tdep
->size_ustat
= 20;
7508 record_tdep
->size_old_sigaction
= 16;
7509 record_tdep
->size_old_sigset_t
= 4;
7510 record_tdep
->size_rlimit
= 8;
7511 record_tdep
->size_rusage
= 72;
7512 record_tdep
->size_timeval
= 8;
7513 record_tdep
->size_timezone
= 8;
7514 record_tdep
->size_old_gid_t
= 2;
7515 record_tdep
->size_old_uid_t
= 2;
7516 record_tdep
->size_fd_set
= 128;
7517 record_tdep
->size_old_dirent
= 268;
7518 record_tdep
->size_statfs
= 64;
7519 record_tdep
->size_statfs64
= 88;
7520 record_tdep
->size_sockaddr
= 16;
7521 record_tdep
->size_int
= 4;
7522 record_tdep
->size_long
= 4;
7523 record_tdep
->size_ulong
= 4;
7524 record_tdep
->size_msghdr
= 28;
7525 record_tdep
->size_itimerval
= 16;
7526 record_tdep
->size_stat
= 64;
7527 /* old_utsname unused */
7528 record_tdep
->size_sysinfo
= 64;
7529 record_tdep
->size_msqid_ds
= 88;
7530 record_tdep
->size_shmid_ds
= 84;
7531 record_tdep
->size_new_utsname
= 390;
7532 record_tdep
->size_timex
= 128;
7533 record_tdep
->size_mem_dqinfo
= 24;
7534 record_tdep
->size_if_dqblk
= 72;
7535 record_tdep
->size_fs_quota_stat
= 80;
7536 record_tdep
->size_timespec
= 8;
7537 record_tdep
->size_pollfd
= 8;
7538 record_tdep
->size_NFS_FHSIZE
= 32;
7539 record_tdep
->size_knfsd_fh
= 132;
7540 record_tdep
->size_TASK_COMM_LEN
= 16;
7541 record_tdep
->size_sigaction
= 20;
7542 record_tdep
->size_sigset_t
= 8;
7543 record_tdep
->size_siginfo_t
= 128;
7544 record_tdep
->size_cap_user_data_t
= 12;
7545 record_tdep
->size_stack_t
= 12;
7546 record_tdep
->size_off_t
= 4;
7547 record_tdep
->size_stat64
= 104;
7548 record_tdep
->size_gid_t
= 4;
7549 record_tdep
->size_uid_t
= 4;
7550 record_tdep
->size_PAGE_SIZE
= 0x1000; /* 4KB */
7551 record_tdep
->size_flock64
= 32;
7552 record_tdep
->size_io_event
= 32;
7553 record_tdep
->size_iocb
= 64;
7554 record_tdep
->size_epoll_event
= 16;
7555 record_tdep
->size_itimerspec
= 16;
7556 record_tdep
->size_mq_attr
= 32;
7557 record_tdep
->size_termios
= 36;
7558 record_tdep
->size_termios2
= 44;
7559 record_tdep
->size_pid_t
= 4;
7560 record_tdep
->size_winsize
= 8;
7561 record_tdep
->size_serial_struct
= 60;
7562 record_tdep
->size_serial_icounter_struct
= 80;
7563 record_tdep
->size_size_t
= 4;
7564 record_tdep
->size_iovec
= 8;
7565 record_tdep
->size_time_t
= 4;
7568 /* These values are the second argument of system call "sys_fcntl"
7569 and "sys_fcntl64". They are obtained from Linux Kernel source. */
7570 record_tdep
->fcntl_F_GETLK
= 5;
7571 record_tdep
->fcntl_F_GETLK64
= 12;
7572 record_tdep
->fcntl_F_SETLK64
= 13;
7573 record_tdep
->fcntl_F_SETLKW64
= 14;
7575 record_tdep
->arg1
= S390_R2_REGNUM
;
7576 record_tdep
->arg2
= S390_R3_REGNUM
;
7577 record_tdep
->arg3
= S390_R4_REGNUM
;
7578 record_tdep
->arg4
= S390_R5_REGNUM
;
7579 record_tdep
->arg5
= S390_R6_REGNUM
;
7581 /* These values are the second argument of system call "sys_ioctl".
7582 They are obtained from Linux Kernel source.
7583 See arch/s390/include/uapi/asm/ioctls.h. */
7585 record_tdep
->ioctl_TCGETS
= 0x5401;
7586 record_tdep
->ioctl_TCSETS
= 0x5402;
7587 record_tdep
->ioctl_TCSETSW
= 0x5403;
7588 record_tdep
->ioctl_TCSETSF
= 0x5404;
7589 record_tdep
->ioctl_TCGETA
= 0x5405;
7590 record_tdep
->ioctl_TCSETA
= 0x5406;
7591 record_tdep
->ioctl_TCSETAW
= 0x5407;
7592 record_tdep
->ioctl_TCSETAF
= 0x5408;
7593 record_tdep
->ioctl_TCSBRK
= 0x5409;
7594 record_tdep
->ioctl_TCXONC
= 0x540a;
7595 record_tdep
->ioctl_TCFLSH
= 0x540b;
7596 record_tdep
->ioctl_TIOCEXCL
= 0x540c;
7597 record_tdep
->ioctl_TIOCNXCL
= 0x540d;
7598 record_tdep
->ioctl_TIOCSCTTY
= 0x540e;
7599 record_tdep
->ioctl_TIOCGPGRP
= 0x540f;
7600 record_tdep
->ioctl_TIOCSPGRP
= 0x5410;
7601 record_tdep
->ioctl_TIOCOUTQ
= 0x5411;
7602 record_tdep
->ioctl_TIOCSTI
= 0x5412;
7603 record_tdep
->ioctl_TIOCGWINSZ
= 0x5413;
7604 record_tdep
->ioctl_TIOCSWINSZ
= 0x5414;
7605 record_tdep
->ioctl_TIOCMGET
= 0x5415;
7606 record_tdep
->ioctl_TIOCMBIS
= 0x5416;
7607 record_tdep
->ioctl_TIOCMBIC
= 0x5417;
7608 record_tdep
->ioctl_TIOCMSET
= 0x5418;
7609 record_tdep
->ioctl_TIOCGSOFTCAR
= 0x5419;
7610 record_tdep
->ioctl_TIOCSSOFTCAR
= 0x541a;
7611 record_tdep
->ioctl_FIONREAD
= 0x541b;
7612 record_tdep
->ioctl_TIOCINQ
= 0x541b; /* alias */
7613 record_tdep
->ioctl_TIOCLINUX
= 0x541c;
7614 record_tdep
->ioctl_TIOCCONS
= 0x541d;
7615 record_tdep
->ioctl_TIOCGSERIAL
= 0x541e;
7616 record_tdep
->ioctl_TIOCSSERIAL
= 0x541f;
7617 record_tdep
->ioctl_TIOCPKT
= 0x5420;
7618 record_tdep
->ioctl_FIONBIO
= 0x5421;
7619 record_tdep
->ioctl_TIOCNOTTY
= 0x5422;
7620 record_tdep
->ioctl_TIOCSETD
= 0x5423;
7621 record_tdep
->ioctl_TIOCGETD
= 0x5424;
7622 record_tdep
->ioctl_TCSBRKP
= 0x5425;
7623 record_tdep
->ioctl_TIOCSBRK
= 0x5427;
7624 record_tdep
->ioctl_TIOCCBRK
= 0x5428;
7625 record_tdep
->ioctl_TIOCGSID
= 0x5429;
7626 record_tdep
->ioctl_TCGETS2
= 0x802c542a;
7627 record_tdep
->ioctl_TCSETS2
= 0x402c542b;
7628 record_tdep
->ioctl_TCSETSW2
= 0x402c542c;
7629 record_tdep
->ioctl_TCSETSF2
= 0x402c542d;
7630 record_tdep
->ioctl_TIOCGPTN
= 0x80045430;
7631 record_tdep
->ioctl_TIOCSPTLCK
= 0x40045431;
7632 record_tdep
->ioctl_FIONCLEX
= 0x5450;
7633 record_tdep
->ioctl_FIOCLEX
= 0x5451;
7634 record_tdep
->ioctl_FIOASYNC
= 0x5452;
7635 record_tdep
->ioctl_TIOCSERCONFIG
= 0x5453;
7636 record_tdep
->ioctl_TIOCSERGWILD
= 0x5454;
7637 record_tdep
->ioctl_TIOCSERSWILD
= 0x5455;
7638 record_tdep
->ioctl_TIOCGLCKTRMIOS
= 0x5456;
7639 record_tdep
->ioctl_TIOCSLCKTRMIOS
= 0x5457;
7640 record_tdep
->ioctl_TIOCSERGSTRUCT
= 0x5458;
7641 record_tdep
->ioctl_TIOCSERGETLSR
= 0x5459;
7642 record_tdep
->ioctl_TIOCSERGETMULTI
= 0x545a;
7643 record_tdep
->ioctl_TIOCSERSETMULTI
= 0x545b;
7644 record_tdep
->ioctl_TIOCMIWAIT
= 0x545c;
7645 record_tdep
->ioctl_TIOCGICOUNT
= 0x545d;
7646 record_tdep
->ioctl_FIOQSIZE
= 0x545e;
7649 /* Set up gdbarch struct. */
7651 static struct gdbarch
*
7652 s390_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
7654 const struct target_desc
*tdesc
= info
.target_desc
;
7655 struct tdesc_arch_data
*tdesc_data
= NULL
;
7656 struct gdbarch
*gdbarch
;
7657 struct gdbarch_tdep
*tdep
;
7658 enum s390_abi_kind tdep_abi
;
7659 enum s390_vector_abi_kind vector_abi
;
7661 int have_linux_v1
= 0;
7662 int have_linux_v2
= 0;
7665 int first_pseudo_reg
, last_pseudo_reg
;
7666 static const char *const stap_register_prefixes
[] = { "%", NULL
};
7667 static const char *const stap_register_indirection_prefixes
[] = { "(",
7669 static const char *const stap_register_indirection_suffixes
[] = { ")",
7672 /* Default ABI and register size. */
7673 switch (info
.bfd_arch_info
->mach
)
7675 case bfd_mach_s390_31
:
7676 tdep_abi
= ABI_LINUX_S390
;
7679 case bfd_mach_s390_64
:
7680 tdep_abi
= ABI_LINUX_ZSERIES
;
7687 /* Use default target description if none provided by the target. */
7688 if (!tdesc_has_registers (tdesc
))
7690 if (tdep_abi
== ABI_LINUX_S390
)
7691 tdesc
= tdesc_s390_linux32
;
7693 tdesc
= tdesc_s390x_linux64
;
7696 /* Check any target description for validity. */
7697 if (tdesc_has_registers (tdesc
))
7699 static const char *const gprs
[] = {
7700 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
7701 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
7703 static const char *const fprs
[] = {
7704 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
7705 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15"
7707 static const char *const acrs
[] = {
7708 "acr0", "acr1", "acr2", "acr3", "acr4", "acr5", "acr6", "acr7",
7709 "acr8", "acr9", "acr10", "acr11", "acr12", "acr13", "acr14", "acr15"
7711 static const char *const gprs_lower
[] = {
7712 "r0l", "r1l", "r2l", "r3l", "r4l", "r5l", "r6l", "r7l",
7713 "r8l", "r9l", "r10l", "r11l", "r12l", "r13l", "r14l", "r15l"
7715 static const char *const gprs_upper
[] = {
7716 "r0h", "r1h", "r2h", "r3h", "r4h", "r5h", "r6h", "r7h",
7717 "r8h", "r9h", "r10h", "r11h", "r12h", "r13h", "r14h", "r15h"
7719 static const char *const tdb_regs
[] = {
7720 "tdb0", "tac", "tct", "atia",
7721 "tr0", "tr1", "tr2", "tr3", "tr4", "tr5", "tr6", "tr7",
7722 "tr8", "tr9", "tr10", "tr11", "tr12", "tr13", "tr14", "tr15"
7724 static const char *const vxrs_low
[] = {
7725 "v0l", "v1l", "v2l", "v3l", "v4l", "v5l", "v6l", "v7l", "v8l",
7726 "v9l", "v10l", "v11l", "v12l", "v13l", "v14l", "v15l",
7728 static const char *const vxrs_high
[] = {
7729 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23", "v24",
7730 "v25", "v26", "v27", "v28", "v29", "v30", "v31",
7732 const struct tdesc_feature
*feature
;
7735 feature
= tdesc_find_feature (tdesc
, "org.gnu.gdb.s390.core");
7736 if (feature
== NULL
)
7739 tdesc_data
= tdesc_data_alloc ();
7741 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
7742 S390_PSWM_REGNUM
, "pswm");
7743 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
7744 S390_PSWA_REGNUM
, "pswa");
7746 if (tdesc_unnumbered_register (feature
, "r0"))
7748 for (i
= 0; i
< 16; i
++)
7749 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
7750 S390_R0_REGNUM
+ i
, gprs
[i
]);
7756 for (i
= 0; i
< 16; i
++)
7757 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
7760 for (i
= 0; i
< 16; i
++)
7761 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
7762 S390_R0_UPPER_REGNUM
+ i
,
7766 feature
= tdesc_find_feature (tdesc
, "org.gnu.gdb.s390.fpr");
7767 if (feature
== NULL
)
7769 tdesc_data_cleanup (tdesc_data
);
7773 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
7774 S390_FPC_REGNUM
, "fpc");
7775 for (i
= 0; i
< 16; i
++)
7776 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
7777 S390_F0_REGNUM
+ i
, fprs
[i
]);
7779 feature
= tdesc_find_feature (tdesc
, "org.gnu.gdb.s390.acr");
7780 if (feature
== NULL
)
7782 tdesc_data_cleanup (tdesc_data
);
7786 for (i
= 0; i
< 16; i
++)
7787 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
7788 S390_A0_REGNUM
+ i
, acrs
[i
]);
7790 /* Optional GNU/Linux-specific "registers". */
7791 feature
= tdesc_find_feature (tdesc
, "org.gnu.gdb.s390.linux");
7794 tdesc_numbered_register (feature
, tdesc_data
,
7795 S390_ORIG_R2_REGNUM
, "orig_r2");
7797 if (tdesc_numbered_register (feature
, tdesc_data
,
7798 S390_LAST_BREAK_REGNUM
, "last_break"))
7801 if (tdesc_numbered_register (feature
, tdesc_data
,
7802 S390_SYSTEM_CALL_REGNUM
, "system_call"))
7805 if (have_linux_v2
> have_linux_v1
)
7809 /* Transaction diagnostic block. */
7810 feature
= tdesc_find_feature (tdesc
, "org.gnu.gdb.s390.tdb");
7813 for (i
= 0; i
< ARRAY_SIZE (tdb_regs
); i
++)
7814 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
7815 S390_TDB_DWORD0_REGNUM
+ i
,
7820 /* Vector registers. */
7821 feature
= tdesc_find_feature (tdesc
, "org.gnu.gdb.s390.vx");
7824 for (i
= 0; i
< 16; i
++)
7825 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
7826 S390_V0_LOWER_REGNUM
+ i
,
7828 for (i
= 0; i
< 16; i
++)
7829 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
7830 S390_V16_REGNUM
+ i
,
7837 tdesc_data_cleanup (tdesc_data
);
7842 /* Determine vector ABI. */
7843 vector_abi
= S390_VECTOR_ABI_NONE
;
7846 && info
.abfd
!= NULL
7847 && info
.abfd
->format
== bfd_object
7848 && bfd_get_flavour (info
.abfd
) == bfd_target_elf_flavour
7849 && bfd_elf_get_obj_attr_int (info
.abfd
, OBJ_ATTR_GNU
,
7850 Tag_GNU_S390_ABI_Vector
) == 2)
7851 vector_abi
= S390_VECTOR_ABI_128
;
7854 /* Find a candidate among extant architectures. */
7855 for (arches
= gdbarch_list_lookup_by_info (arches
, &info
);
7857 arches
= gdbarch_list_lookup_by_info (arches
->next
, &info
))
7859 tdep
= gdbarch_tdep (arches
->gdbarch
);
7862 if (tdep
->abi
!= tdep_abi
)
7864 if (tdep
->vector_abi
!= vector_abi
)
7866 if ((tdep
->gpr_full_regnum
!= -1) != have_upper
)
7868 if (tdesc_data
!= NULL
)
7869 tdesc_data_cleanup (tdesc_data
);
7870 return arches
->gdbarch
;
7873 /* Otherwise create a new gdbarch for the specified machine type. */
7874 tdep
= XCNEW (struct gdbarch_tdep
);
7875 tdep
->abi
= tdep_abi
;
7876 tdep
->vector_abi
= vector_abi
;
7877 tdep
->have_linux_v1
= have_linux_v1
;
7878 tdep
->have_linux_v2
= have_linux_v2
;
7879 tdep
->have_tdb
= have_tdb
;
7880 gdbarch
= gdbarch_alloc (&info
, tdep
);
7882 set_gdbarch_believe_pcc_promotion (gdbarch
, 0);
7883 set_gdbarch_char_signed (gdbarch
, 0);
7885 /* S/390 GNU/Linux uses either 64-bit or 128-bit long doubles.
7886 We can safely let them default to 128-bit, since the debug info
7887 will give the size of type actually used in each case. */
7888 set_gdbarch_long_double_bit (gdbarch
, 128);
7889 set_gdbarch_long_double_format (gdbarch
, floatformats_ia64_quad
);
7891 /* Amount PC must be decremented by after a breakpoint. This is
7892 often the number of bytes returned by gdbarch_breakpoint_from_pc but not
7894 set_gdbarch_decr_pc_after_break (gdbarch
, 2);
7895 /* Stack grows downward. */
7896 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
7897 set_gdbarch_breakpoint_from_pc (gdbarch
, s390_breakpoint_from_pc
);
7898 set_gdbarch_software_single_step (gdbarch
, s390_software_single_step
);
7899 set_gdbarch_displaced_step_hw_singlestep (gdbarch
, s390_displaced_step_hw_singlestep
);
7900 set_gdbarch_skip_prologue (gdbarch
, s390_skip_prologue
);
7901 set_gdbarch_stack_frame_destroyed_p (gdbarch
, s390_stack_frame_destroyed_p
);
7903 set_gdbarch_num_regs (gdbarch
, S390_NUM_REGS
);
7904 set_gdbarch_sp_regnum (gdbarch
, S390_SP_REGNUM
);
7905 set_gdbarch_fp0_regnum (gdbarch
, S390_F0_REGNUM
);
7906 set_gdbarch_stab_reg_to_regnum (gdbarch
, s390_dwarf_reg_to_regnum
);
7907 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, s390_dwarf_reg_to_regnum
);
7908 set_gdbarch_value_from_register (gdbarch
, s390_value_from_register
);
7909 set_gdbarch_core_read_description (gdbarch
, s390_core_read_description
);
7910 set_gdbarch_iterate_over_regset_sections (gdbarch
,
7911 s390_iterate_over_regset_sections
);
7912 set_gdbarch_cannot_store_register (gdbarch
, s390_cannot_store_register
);
7913 set_gdbarch_write_pc (gdbarch
, s390_write_pc
);
7914 set_gdbarch_guess_tracepoint_registers (gdbarch
, s390_guess_tracepoint_registers
);
7915 set_gdbarch_pseudo_register_read (gdbarch
, s390_pseudo_register_read
);
7916 set_gdbarch_pseudo_register_write (gdbarch
, s390_pseudo_register_write
);
7917 set_tdesc_pseudo_register_name (gdbarch
, s390_pseudo_register_name
);
7918 set_tdesc_pseudo_register_type (gdbarch
, s390_pseudo_register_type
);
7919 set_tdesc_pseudo_register_reggroup_p (gdbarch
,
7920 s390_pseudo_register_reggroup_p
);
7921 tdesc_use_registers (gdbarch
, tdesc
, tdesc_data
);
7922 set_gdbarch_register_name (gdbarch
, s390_register_name
);
7924 /* Assign pseudo register numbers. */
7925 first_pseudo_reg
= gdbarch_num_regs (gdbarch
);
7926 last_pseudo_reg
= first_pseudo_reg
;
7927 tdep
->gpr_full_regnum
= -1;
7930 tdep
->gpr_full_regnum
= last_pseudo_reg
;
7931 last_pseudo_reg
+= 16;
7933 tdep
->v0_full_regnum
= -1;
7936 tdep
->v0_full_regnum
= last_pseudo_reg
;
7937 last_pseudo_reg
+= 16;
7939 tdep
->pc_regnum
= last_pseudo_reg
++;
7940 tdep
->cc_regnum
= last_pseudo_reg
++;
7941 set_gdbarch_pc_regnum (gdbarch
, tdep
->pc_regnum
);
7942 set_gdbarch_num_pseudo_regs (gdbarch
, last_pseudo_reg
- first_pseudo_reg
);
7944 /* Inferior function calls. */
7945 set_gdbarch_push_dummy_call (gdbarch
, s390_push_dummy_call
);
7946 set_gdbarch_dummy_id (gdbarch
, s390_dummy_id
);
7947 set_gdbarch_frame_align (gdbarch
, s390_frame_align
);
7948 set_gdbarch_return_value (gdbarch
, s390_return_value
);
7950 /* Syscall handling. */
7951 set_gdbarch_get_syscall_number (gdbarch
, s390_linux_get_syscall_number
);
7953 /* Frame handling. */
7954 dwarf2_frame_set_init_reg (gdbarch
, s390_dwarf2_frame_init_reg
);
7955 dwarf2_frame_set_adjust_regnum (gdbarch
, s390_adjust_frame_regnum
);
7956 dwarf2_append_unwinders (gdbarch
);
7957 frame_base_append_sniffer (gdbarch
, dwarf2_frame_base_sniffer
);
7958 frame_unwind_append_unwinder (gdbarch
, &s390_stub_frame_unwind
);
7959 frame_unwind_append_unwinder (gdbarch
, &s390_sigtramp_frame_unwind
);
7960 frame_unwind_append_unwinder (gdbarch
, &s390_frame_unwind
);
7961 frame_base_set_default (gdbarch
, &s390_frame_base
);
7962 set_gdbarch_unwind_pc (gdbarch
, s390_unwind_pc
);
7963 set_gdbarch_unwind_sp (gdbarch
, s390_unwind_sp
);
7965 /* Displaced stepping. */
7966 set_gdbarch_displaced_step_copy_insn (gdbarch
,
7967 s390_displaced_step_copy_insn
);
7968 set_gdbarch_displaced_step_fixup (gdbarch
, s390_displaced_step_fixup
);
7969 set_gdbarch_displaced_step_free_closure (gdbarch
,
7970 simple_displaced_step_free_closure
);
7971 set_gdbarch_displaced_step_location (gdbarch
, linux_displaced_step_location
);
7972 set_gdbarch_max_insn_length (gdbarch
, S390_MAX_INSTR_SIZE
);
7974 /* Note that GNU/Linux is the only OS supported on this
7976 linux_init_abi (info
, gdbarch
);
7980 case ABI_LINUX_S390
:
7981 set_gdbarch_addr_bits_remove (gdbarch
, s390_addr_bits_remove
);
7982 set_solib_svr4_fetch_link_map_offsets
7983 (gdbarch
, svr4_ilp32_fetch_link_map_offsets
);
7985 set_xml_syscall_file_name (gdbarch
, XML_SYSCALL_FILENAME_S390
);
7988 case ABI_LINUX_ZSERIES
:
7989 set_gdbarch_long_bit (gdbarch
, 64);
7990 set_gdbarch_long_long_bit (gdbarch
, 64);
7991 set_gdbarch_ptr_bit (gdbarch
, 64);
7992 set_solib_svr4_fetch_link_map_offsets
7993 (gdbarch
, svr4_lp64_fetch_link_map_offsets
);
7994 set_gdbarch_address_class_type_flags (gdbarch
,
7995 s390_address_class_type_flags
);
7996 set_gdbarch_address_class_type_flags_to_name (gdbarch
,
7997 s390_address_class_type_flags_to_name
);
7998 set_gdbarch_address_class_name_to_type_flags (gdbarch
,
7999 s390_address_class_name_to_type_flags
);
8000 set_xml_syscall_file_name (gdbarch
, XML_SYSCALL_FILENAME_S390X
);
8004 set_gdbarch_print_insn (gdbarch
, print_insn_s390
);
8006 set_gdbarch_skip_trampoline_code (gdbarch
, find_solib_trampoline_target
);
8008 /* Enable TLS support. */
8009 set_gdbarch_fetch_tls_load_module_address (gdbarch
,
8010 svr4_fetch_objfile_link_map
);
8012 /* SystemTap functions. */
8013 set_gdbarch_stap_register_prefixes (gdbarch
, stap_register_prefixes
);
8014 set_gdbarch_stap_register_indirection_prefixes (gdbarch
,
8015 stap_register_indirection_prefixes
);
8016 set_gdbarch_stap_register_indirection_suffixes (gdbarch
,
8017 stap_register_indirection_suffixes
);
8018 set_gdbarch_stap_is_single_operand (gdbarch
, s390_stap_is_single_operand
);
8019 set_gdbarch_gcc_target_options (gdbarch
, s390_gcc_target_options
);
8020 set_gdbarch_gnu_triplet_regexp (gdbarch
, s390_gnu_triplet_regexp
);
8022 /* Support reverse debugging. */
8024 set_gdbarch_process_record (gdbarch
, s390_process_record
);
8025 set_gdbarch_process_record_signal (gdbarch
, s390_linux_record_signal
);
8027 s390_init_linux_record_tdep (&s390_linux_record_tdep
, ABI_LINUX_S390
);
8028 s390_init_linux_record_tdep (&s390x_linux_record_tdep
, ABI_LINUX_ZSERIES
);
8034 extern initialize_file_ftype _initialize_s390_tdep
; /* -Wmissing-prototypes */
8037 _initialize_s390_tdep (void)
8039 /* Hook us into the gdbarch mechanism. */
8040 register_gdbarch_init (bfd_arch_s390
, s390_gdbarch_init
);
8042 /* Initialize the GNU/Linux target descriptions. */
8043 initialize_tdesc_s390_linux32 ();
8044 initialize_tdesc_s390_linux32v1 ();
8045 initialize_tdesc_s390_linux32v2 ();
8046 initialize_tdesc_s390_linux64 ();
8047 initialize_tdesc_s390_linux64v1 ();
8048 initialize_tdesc_s390_linux64v2 ();
8049 initialize_tdesc_s390_te_linux64 ();
8050 initialize_tdesc_s390_vx_linux64 ();
8051 initialize_tdesc_s390_tevx_linux64 ();
8052 initialize_tdesc_s390x_linux64 ();
8053 initialize_tdesc_s390x_linux64v1 ();
8054 initialize_tdesc_s390x_linux64v2 ();
8055 initialize_tdesc_s390x_te_linux64 ();
8056 initialize_tdesc_s390x_vx_linux64 ();
8057 initialize_tdesc_s390x_tevx_linux64 ();