1 /* Target-dependent code for GDB, the GNU debugger.
3 Copyright (C) 2001-2015 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"
48 #include "xml-syscall.h"
50 #include "stap-probe.h"
53 #include "user-regs.h"
54 #include "cli/cli-utils.h"
56 #include "elf/common.h"
58 #include "features/s390-linux32.c"
59 #include "features/s390-linux32v1.c"
60 #include "features/s390-linux32v2.c"
61 #include "features/s390-linux64.c"
62 #include "features/s390-linux64v1.c"
63 #include "features/s390-linux64v2.c"
64 #include "features/s390-te-linux64.c"
65 #include "features/s390-vx-linux64.c"
66 #include "features/s390-tevx-linux64.c"
67 #include "features/s390x-linux64.c"
68 #include "features/s390x-linux64v1.c"
69 #include "features/s390x-linux64v2.c"
70 #include "features/s390x-te-linux64.c"
71 #include "features/s390x-vx-linux64.c"
72 #include "features/s390x-tevx-linux64.c"
74 #define XML_SYSCALL_FILENAME_S390 "syscalls/s390-linux.xml"
75 #define XML_SYSCALL_FILENAME_S390X "syscalls/s390x-linux.xml"
83 /* The tdep structure. */
88 enum s390_abi_kind abi;
90 /* Pseudo register numbers. */
102 /* ABI call-saved register information. */
105 s390_register_call_saved (struct gdbarch *gdbarch, int regnum)
107 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
112 if ((regnum >= S390_R6_REGNUM && regnum <= S390_R15_REGNUM)
113 || regnum == S390_F4_REGNUM || regnum == S390_F6_REGNUM
114 || regnum == S390_A0_REGNUM)
119 case ABI_LINUX_ZSERIES:
120 if ((regnum >= S390_R6_REGNUM && regnum <= S390_R15_REGNUM)
121 || (regnum >= S390_F8_REGNUM && regnum <= S390_F15_REGNUM)
122 || (regnum >= S390_A0_REGNUM && regnum <= S390_A1_REGNUM))
132 s390_cannot_store_register (struct gdbarch *gdbarch, int regnum)
134 /* The last-break address is read-only. */
135 return regnum == S390_LAST_BREAK_REGNUM;
139 s390_write_pc (struct regcache *regcache, CORE_ADDR pc)
141 struct gdbarch *gdbarch = get_regcache_arch (regcache);
142 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
144 regcache_cooked_write_unsigned (regcache, tdep->pc_regnum, pc);
146 /* Set special SYSTEM_CALL register to 0 to prevent the kernel from
147 messing with the PC we just installed, if we happen to be within
148 an interrupted system call that the kernel wants to restart.
150 Note that after we return from the dummy call, the SYSTEM_CALL and
151 ORIG_R2 registers will be automatically restored, and the kernel
152 continues to restart the system call at this point. */
153 if (register_size (gdbarch, S390_SYSTEM_CALL_REGNUM) > 0)
154 regcache_cooked_write_unsigned (regcache, S390_SYSTEM_CALL_REGNUM, 0);
158 /* DWARF Register Mapping. */
160 static const short s390_dwarf_regmap[] =
162 /* 0-15: General Purpose Registers. */
163 S390_R0_REGNUM, S390_R1_REGNUM, S390_R2_REGNUM, S390_R3_REGNUM,
164 S390_R4_REGNUM, S390_R5_REGNUM, S390_R6_REGNUM, S390_R7_REGNUM,
165 S390_R8_REGNUM, S390_R9_REGNUM, S390_R10_REGNUM, S390_R11_REGNUM,
166 S390_R12_REGNUM, S390_R13_REGNUM, S390_R14_REGNUM, S390_R15_REGNUM,
168 /* 16-31: Floating Point Registers / Vector Registers 0-15. */
169 S390_F0_REGNUM, S390_F2_REGNUM, S390_F4_REGNUM, S390_F6_REGNUM,
170 S390_F1_REGNUM, S390_F3_REGNUM, S390_F5_REGNUM, S390_F7_REGNUM,
171 S390_F8_REGNUM, S390_F10_REGNUM, S390_F12_REGNUM, S390_F14_REGNUM,
172 S390_F9_REGNUM, S390_F11_REGNUM, S390_F13_REGNUM, S390_F15_REGNUM,
174 /* 32-47: Control Registers (not mapped). */
175 -1, -1, -1, -1, -1, -1, -1, -1,
176 -1, -1, -1, -1, -1, -1, -1, -1,
178 /* 48-63: Access Registers. */
179 S390_A0_REGNUM, S390_A1_REGNUM, S390_A2_REGNUM, S390_A3_REGNUM,
180 S390_A4_REGNUM, S390_A5_REGNUM, S390_A6_REGNUM, S390_A7_REGNUM,
181 S390_A8_REGNUM, S390_A9_REGNUM, S390_A10_REGNUM, S390_A11_REGNUM,
182 S390_A12_REGNUM, S390_A13_REGNUM, S390_A14_REGNUM, S390_A15_REGNUM,
184 /* 64-65: Program Status Word. */
188 /* 66-67: Reserved. */
191 /* 68-83: Vector Registers 16-31. */
192 S390_V16_REGNUM, S390_V18_REGNUM, S390_V20_REGNUM, S390_V22_REGNUM,
193 S390_V17_REGNUM, S390_V19_REGNUM, S390_V21_REGNUM, S390_V23_REGNUM,
194 S390_V24_REGNUM, S390_V26_REGNUM, S390_V28_REGNUM, S390_V30_REGNUM,
195 S390_V25_REGNUM, S390_V27_REGNUM, S390_V29_REGNUM, S390_V31_REGNUM,
197 /* End of "official" DWARF registers. The remainder of the map is
198 for GDB internal use only. */
200 /* GPR Lower Half Access. */
201 S390_R0_REGNUM, S390_R1_REGNUM, S390_R2_REGNUM, S390_R3_REGNUM,
202 S390_R4_REGNUM, S390_R5_REGNUM, S390_R6_REGNUM, S390_R7_REGNUM,
203 S390_R8_REGNUM, S390_R9_REGNUM, S390_R10_REGNUM, S390_R11_REGNUM,
204 S390_R12_REGNUM, S390_R13_REGNUM, S390_R14_REGNUM, S390_R15_REGNUM,
207 enum { s390_dwarf_reg_r0l = ARRAY_SIZE (s390_dwarf_regmap) - 16 };
209 /* Convert DWARF register number REG to the appropriate register
210 number used by GDB. */
212 s390_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int reg)
214 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
217 /* In a 32-on-64 debug scenario, debug info refers to the full
218 64-bit GPRs. Note that call frame information still refers to
219 the 32-bit lower halves, because s390_adjust_frame_regnum uses
220 special register numbers to access GPRs. */
221 if (tdep->gpr_full_regnum != -1 && reg >= 0 && reg < 16)
222 return tdep->gpr_full_regnum + reg;
224 if (reg >= 0 && reg < ARRAY_SIZE (s390_dwarf_regmap))
225 gdb_reg = s390_dwarf_regmap[reg];
227 if (tdep->v0_full_regnum == -1)
229 if (gdb_reg >= S390_V16_REGNUM && gdb_reg <= S390_V31_REGNUM)
234 if (gdb_reg >= S390_F0_REGNUM && gdb_reg <= S390_F15_REGNUM)
235 gdb_reg = gdb_reg - S390_F0_REGNUM + tdep->v0_full_regnum;
241 /* Translate a .eh_frame register to DWARF register, or adjust a
242 .debug_frame register. */
244 s390_adjust_frame_regnum (struct gdbarch *gdbarch, int num, int eh_frame_p)
246 /* See s390_dwarf_reg_to_regnum for comments. */
247 return (num >= 0 && num < 16) ? num + s390_dwarf_reg_r0l : num;
251 /* Pseudo registers. */
254 regnum_is_gpr_full (struct gdbarch_tdep *tdep, int regnum)
256 return (tdep->gpr_full_regnum != -1
257 && regnum >= tdep->gpr_full_regnum
258 && regnum <= tdep->gpr_full_regnum + 15);
261 /* Check whether REGNUM indicates a full vector register (v0-v15).
262 These pseudo-registers are composed of f0-f15 and v0l-v15l. */
265 regnum_is_vxr_full (struct gdbarch_tdep *tdep, int regnum)
267 return (tdep->v0_full_regnum != -1
268 && regnum >= tdep->v0_full_regnum
269 && regnum <= tdep->v0_full_regnum + 15);
272 /* Return the name of register REGNO. Return NULL for registers that
273 shouldn't be visible. */
276 s390_register_name (struct gdbarch *gdbarch, int regnum)
278 if (regnum >= S390_V0_LOWER_REGNUM
279 && regnum <= S390_V15_LOWER_REGNUM)
281 return tdesc_register_name (gdbarch, regnum);
285 s390_pseudo_register_name (struct gdbarch *gdbarch, int regnum)
287 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
289 if (regnum == tdep->pc_regnum)
292 if (regnum == tdep->cc_regnum)
295 if (regnum_is_gpr_full (tdep, regnum))
297 static const char *full_name[] = {
298 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
299 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
301 return full_name[regnum - tdep->gpr_full_regnum];
304 if (regnum_is_vxr_full (tdep, regnum))
306 static const char *full_name[] = {
307 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
308 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15"
310 return full_name[regnum - tdep->v0_full_regnum];
313 internal_error (__FILE__, __LINE__, _("invalid regnum"));
317 s390_pseudo_register_type (struct gdbarch *gdbarch, int regnum)
319 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
321 if (regnum == tdep->pc_regnum)
322 return builtin_type (gdbarch)->builtin_func_ptr;
324 if (regnum == tdep->cc_regnum)
325 return builtin_type (gdbarch)->builtin_int;
327 if (regnum_is_gpr_full (tdep, regnum))
328 return builtin_type (gdbarch)->builtin_uint64;
330 if (regnum_is_vxr_full (tdep, regnum))
331 return tdesc_find_type (gdbarch, "vec128");
333 internal_error (__FILE__, __LINE__, _("invalid regnum"));
336 static enum register_status
337 s390_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
338 int regnum, gdb_byte *buf)
340 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
341 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
342 int regsize = register_size (gdbarch, regnum);
345 if (regnum == tdep->pc_regnum)
347 enum register_status status;
349 status = regcache_raw_read_unsigned (regcache, S390_PSWA_REGNUM, &val);
350 if (status == REG_VALID)
352 if (register_size (gdbarch, S390_PSWA_REGNUM) == 4)
354 store_unsigned_integer (buf, regsize, byte_order, val);
359 if (regnum == tdep->cc_regnum)
361 enum register_status status;
363 status = regcache_raw_read_unsigned (regcache, S390_PSWM_REGNUM, &val);
364 if (status == REG_VALID)
366 if (register_size (gdbarch, S390_PSWA_REGNUM) == 4)
367 val = (val >> 12) & 3;
369 val = (val >> 44) & 3;
370 store_unsigned_integer (buf, regsize, byte_order, val);
375 if (regnum_is_gpr_full (tdep, regnum))
377 enum register_status status;
380 regnum -= tdep->gpr_full_regnum;
382 status = regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + regnum, &val);
383 if (status == REG_VALID)
384 status = regcache_raw_read_unsigned (regcache, S390_R0_UPPER_REGNUM + regnum,
386 if (status == REG_VALID)
388 val |= val_upper << 32;
389 store_unsigned_integer (buf, regsize, byte_order, val);
394 if (regnum_is_vxr_full (tdep, regnum))
396 enum register_status status;
398 regnum -= tdep->v0_full_regnum;
400 status = regcache_raw_read (regcache, S390_F0_REGNUM + regnum, buf);
401 if (status == REG_VALID)
402 status = regcache_raw_read (regcache,
403 S390_V0_LOWER_REGNUM + regnum, buf + 8);
407 internal_error (__FILE__, __LINE__, _("invalid regnum"));
411 s390_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
412 int regnum, const gdb_byte *buf)
414 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
415 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
416 int regsize = register_size (gdbarch, regnum);
419 if (regnum == tdep->pc_regnum)
421 val = extract_unsigned_integer (buf, regsize, byte_order);
422 if (register_size (gdbarch, S390_PSWA_REGNUM) == 4)
424 regcache_raw_read_unsigned (regcache, S390_PSWA_REGNUM, &psw);
425 val = (psw & 0x80000000) | (val & 0x7fffffff);
427 regcache_raw_write_unsigned (regcache, S390_PSWA_REGNUM, val);
431 if (regnum == tdep->cc_regnum)
433 val = extract_unsigned_integer (buf, regsize, byte_order);
434 regcache_raw_read_unsigned (regcache, S390_PSWM_REGNUM, &psw);
435 if (register_size (gdbarch, S390_PSWA_REGNUM) == 4)
436 val = (psw & ~((ULONGEST)3 << 12)) | ((val & 3) << 12);
438 val = (psw & ~((ULONGEST)3 << 44)) | ((val & 3) << 44);
439 regcache_raw_write_unsigned (regcache, S390_PSWM_REGNUM, val);
443 if (regnum_is_gpr_full (tdep, regnum))
445 regnum -= tdep->gpr_full_regnum;
446 val = extract_unsigned_integer (buf, regsize, byte_order);
447 regcache_raw_write_unsigned (regcache, S390_R0_REGNUM + regnum,
449 regcache_raw_write_unsigned (regcache, S390_R0_UPPER_REGNUM + regnum,
454 if (regnum_is_vxr_full (tdep, regnum))
456 regnum -= tdep->v0_full_regnum;
457 regcache_raw_write (regcache, S390_F0_REGNUM + regnum, buf);
458 regcache_raw_write (regcache, S390_V0_LOWER_REGNUM + regnum, buf + 8);
462 internal_error (__FILE__, __LINE__, _("invalid regnum"));
465 /* 'float' values are stored in the upper half of floating-point
466 registers, even though we are otherwise a big-endian platform. The
467 same applies to a 'float' value within a vector. */
469 static struct value *
470 s390_value_from_register (struct gdbarch *gdbarch, struct type *type,
471 int regnum, struct frame_id frame_id)
473 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
474 struct value *value = default_value_from_register (gdbarch, type,
476 check_typedef (type);
478 if ((regnum >= S390_F0_REGNUM && regnum <= S390_F15_REGNUM
479 && TYPE_LENGTH (type) < 8)
480 || regnum_is_vxr_full (tdep, regnum)
481 || (regnum >= S390_V16_REGNUM && regnum <= S390_V31_REGNUM))
482 set_value_offset (value, 0);
487 /* Register groups. */
490 s390_pseudo_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
491 struct reggroup *group)
493 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
495 /* We usually save/restore the whole PSW, which includes PC and CC.
496 However, some older gdbservers may not support saving/restoring
497 the whole PSW yet, and will return an XML register description
498 excluding those from the save/restore register groups. In those
499 cases, we still need to explicitly save/restore PC and CC in order
500 to push or pop frames. Since this doesn't hurt anything if we
501 already save/restore the whole PSW (it's just redundant), we add
502 PC and CC at this point unconditionally. */
503 if (group == save_reggroup || group == restore_reggroup)
504 return regnum == tdep->pc_regnum || regnum == tdep->cc_regnum;
506 if (group == vector_reggroup)
507 return regnum_is_vxr_full (tdep, regnum);
509 if (group == general_reggroup && regnum_is_vxr_full (tdep, regnum))
512 return default_register_reggroup_p (gdbarch, regnum, group);
516 /* Maps for register sets. */
518 static const struct regcache_map_entry s390_gregmap[] =
520 { 1, S390_PSWM_REGNUM },
521 { 1, S390_PSWA_REGNUM },
522 { 16, S390_R0_REGNUM },
523 { 16, S390_A0_REGNUM },
524 { 1, S390_ORIG_R2_REGNUM },
528 static const struct regcache_map_entry s390_fpregmap[] =
530 { 1, S390_FPC_REGNUM, 8 },
531 { 16, S390_F0_REGNUM, 8 },
535 static const struct regcache_map_entry s390_regmap_upper[] =
537 { 16, S390_R0_UPPER_REGNUM, 4 },
541 static const struct regcache_map_entry s390_regmap_last_break[] =
543 { 1, REGCACHE_MAP_SKIP, 4 },
544 { 1, S390_LAST_BREAK_REGNUM, 4 },
548 static const struct regcache_map_entry s390x_regmap_last_break[] =
550 { 1, S390_LAST_BREAK_REGNUM, 8 },
554 static const struct regcache_map_entry s390_regmap_system_call[] =
556 { 1, S390_SYSTEM_CALL_REGNUM, 4 },
560 static const struct regcache_map_entry s390_regmap_tdb[] =
562 { 1, S390_TDB_DWORD0_REGNUM, 8 },
563 { 1, S390_TDB_ABORT_CODE_REGNUM, 8 },
564 { 1, S390_TDB_CONFLICT_TOKEN_REGNUM, 8 },
565 { 1, S390_TDB_ATIA_REGNUM, 8 },
566 { 12, REGCACHE_MAP_SKIP, 8 },
567 { 16, S390_TDB_R0_REGNUM, 8 },
571 static const struct regcache_map_entry s390_regmap_vxrs_low[] =
573 { 16, S390_V0_LOWER_REGNUM, 8 },
577 static const struct regcache_map_entry s390_regmap_vxrs_high[] =
579 { 16, S390_V16_REGNUM, 16 },
584 /* Supply the TDB regset. Like regcache_supply_regset, but invalidate
585 the TDB registers unless the TDB format field is valid. */
588 s390_supply_tdb_regset (const struct regset *regset, struct regcache *regcache,
589 int regnum, const void *regs, size_t len)
592 enum register_status ret;
595 regcache_supply_regset (regset, regcache, regnum, regs, len);
596 ret = regcache_cooked_read_unsigned (regcache, S390_TDB_DWORD0_REGNUM, &tdw);
597 if (ret != REG_VALID || (tdw >> 56) != 1)
598 regcache_supply_regset (regset, regcache, regnum, NULL, len);
601 const struct regset s390_gregset = {
603 regcache_supply_regset,
604 regcache_collect_regset
607 const struct regset s390_fpregset = {
609 regcache_supply_regset,
610 regcache_collect_regset
613 static const struct regset s390_upper_regset = {
615 regcache_supply_regset,
616 regcache_collect_regset
619 const struct regset s390_last_break_regset = {
620 s390_regmap_last_break,
621 regcache_supply_regset,
622 regcache_collect_regset
625 const struct regset s390x_last_break_regset = {
626 s390x_regmap_last_break,
627 regcache_supply_regset,
628 regcache_collect_regset
631 const struct regset s390_system_call_regset = {
632 s390_regmap_system_call,
633 regcache_supply_regset,
634 regcache_collect_regset
637 const struct regset s390_tdb_regset = {
639 s390_supply_tdb_regset,
640 regcache_collect_regset
643 const struct regset s390_vxrs_low_regset = {
644 s390_regmap_vxrs_low,
645 regcache_supply_regset,
646 regcache_collect_regset
649 const struct regset s390_vxrs_high_regset = {
650 s390_regmap_vxrs_high,
651 regcache_supply_regset,
652 regcache_collect_regset
655 /* Iterate over supported core file register note sections. */
658 s390_iterate_over_regset_sections (struct gdbarch *gdbarch,
659 iterate_over_regset_sections_cb *cb,
661 const struct regcache *regcache)
663 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
664 const int gregset_size = (tdep->abi == ABI_LINUX_S390 ?
665 s390_sizeof_gregset : s390x_sizeof_gregset);
667 cb (".reg", gregset_size, &s390_gregset, NULL, cb_data);
668 cb (".reg2", s390_sizeof_fpregset, &s390_fpregset, NULL, cb_data);
670 if (tdep->abi == ABI_LINUX_S390 && tdep->gpr_full_regnum != -1)
671 cb (".reg-s390-high-gprs", 16 * 4, &s390_upper_regset,
672 "s390 GPR upper halves", cb_data);
674 if (tdep->have_linux_v1)
675 cb (".reg-s390-last-break", 8,
676 (gdbarch_ptr_bit (gdbarch) == 32
677 ? &s390_last_break_regset : &s390x_last_break_regset),
678 "s930 last-break address", cb_data);
680 if (tdep->have_linux_v2)
681 cb (".reg-s390-system-call", 4, &s390_system_call_regset,
682 "s390 system-call", cb_data);
684 /* If regcache is set, we are in "write" (gcore) mode. In this
685 case, don't iterate over the TDB unless its registers are
689 || REG_VALID == regcache_register_status (regcache,
690 S390_TDB_DWORD0_REGNUM)))
691 cb (".reg-s390-tdb", s390_sizeof_tdbregset, &s390_tdb_regset,
692 "s390 TDB", cb_data);
694 if (tdep->v0_full_regnum != -1)
696 cb (".reg-s390-vxrs-low", 16 * 8, &s390_vxrs_low_regset,
697 "s390 vector registers 0-15 lower half", cb_data);
698 cb (".reg-s390-vxrs-high", 16 * 16, &s390_vxrs_high_regset,
699 "s390 vector registers 16-31", cb_data);
703 static const struct target_desc *
704 s390_core_read_description (struct gdbarch *gdbarch,
705 struct target_ops *target, bfd *abfd)
707 asection *section = bfd_get_section_by_name (abfd, ".reg");
709 int high_gprs, v1, v2, te, vx;
711 target_auxv_search (target, AT_HWCAP, &hwcap);
715 high_gprs = (bfd_get_section_by_name (abfd, ".reg-s390-high-gprs")
717 v1 = (bfd_get_section_by_name (abfd, ".reg-s390-last-break") != NULL);
718 v2 = (bfd_get_section_by_name (abfd, ".reg-s390-system-call") != NULL);
719 vx = (hwcap & HWCAP_S390_VX);
720 te = (hwcap & HWCAP_S390_TE);
722 switch (bfd_section_size (abfd, section))
724 case s390_sizeof_gregset:
726 return (te && vx ? tdesc_s390_tevx_linux64 :
727 vx ? tdesc_s390_vx_linux64 :
728 te ? tdesc_s390_te_linux64 :
729 v2 ? tdesc_s390_linux64v2 :
730 v1 ? tdesc_s390_linux64v1 : tdesc_s390_linux64);
732 return (v2 ? tdesc_s390_linux32v2 :
733 v1 ? tdesc_s390_linux32v1 : tdesc_s390_linux32);
735 case s390x_sizeof_gregset:
736 return (te && vx ? tdesc_s390x_tevx_linux64 :
737 vx ? tdesc_s390x_vx_linux64 :
738 te ? tdesc_s390x_te_linux64 :
739 v2 ? tdesc_s390x_linux64v2 :
740 v1 ? tdesc_s390x_linux64v1 : tdesc_s390x_linux64);
748 /* Decoding S/390 instructions. */
750 /* Named opcode values for the S/390 instructions we recognize. Some
751 instructions have their opcode split across two fields; those are the
752 op1_* and op2_* enums. */
755 op1_lhi = 0xa7, op2_lhi = 0x08,
756 op1_lghi = 0xa7, op2_lghi = 0x09,
757 op1_lgfi = 0xc0, op2_lgfi = 0x01,
761 op1_ly = 0xe3, op2_ly = 0x58,
762 op1_lg = 0xe3, op2_lg = 0x04,
764 op1_lmy = 0xeb, op2_lmy = 0x98,
765 op1_lmg = 0xeb, op2_lmg = 0x04,
767 op1_sty = 0xe3, op2_sty = 0x50,
768 op1_stg = 0xe3, op2_stg = 0x24,
771 op1_stmy = 0xeb, op2_stmy = 0x90,
772 op1_stmg = 0xeb, op2_stmg = 0x24,
773 op1_aghi = 0xa7, op2_aghi = 0x0b,
774 op1_ahi = 0xa7, op2_ahi = 0x0a,
775 op1_agfi = 0xc2, op2_agfi = 0x08,
776 op1_afi = 0xc2, op2_afi = 0x09,
777 op1_algfi= 0xc2, op2_algfi= 0x0a,
778 op1_alfi = 0xc2, op2_alfi = 0x0b,
782 op1_ay = 0xe3, op2_ay = 0x5a,
783 op1_ag = 0xe3, op2_ag = 0x08,
784 op1_slgfi= 0xc2, op2_slgfi= 0x04,
785 op1_slfi = 0xc2, op2_slfi = 0x05,
789 op1_sy = 0xe3, op2_sy = 0x5b,
790 op1_sg = 0xe3, op2_sg = 0x09,
794 op1_lay = 0xe3, op2_lay = 0x71,
795 op1_larl = 0xc0, op2_larl = 0x00,
803 op1_bctg = 0xe3, op2_bctg = 0x46,
805 op1_bxhg = 0xeb, op2_bxhg = 0x44,
807 op1_bxleg= 0xeb, op2_bxleg= 0x45,
808 op1_bras = 0xa7, op2_bras = 0x05,
809 op1_brasl= 0xc0, op2_brasl= 0x05,
810 op1_brc = 0xa7, op2_brc = 0x04,
811 op1_brcl = 0xc0, op2_brcl = 0x04,
812 op1_brct = 0xa7, op2_brct = 0x06,
813 op1_brctg= 0xa7, op2_brctg= 0x07,
815 op1_brxhg= 0xec, op2_brxhg= 0x44,
817 op1_brxlg= 0xec, op2_brxlg= 0x45,
822 /* Read a single instruction from address AT. */
824 #define S390_MAX_INSTR_SIZE 6
826 s390_readinstruction (bfd_byte instr[], CORE_ADDR at)
828 static int s390_instrlen[] = { 2, 4, 4, 6 };
831 if (target_read_memory (at, &instr[0], 2))
833 instrlen = s390_instrlen[instr[0] >> 6];
836 if (target_read_memory (at + 2, &instr[2], instrlen - 2))
843 /* The functions below are for recognizing and decoding S/390
844 instructions of various formats. Each of them checks whether INSN
845 is an instruction of the given format, with the specified opcodes.
846 If it is, it sets the remaining arguments to the values of the
847 instruction's fields, and returns a non-zero value; otherwise, it
850 These functions' arguments appear in the order they appear in the
851 instruction, not in the machine-language form. So, opcodes always
852 come first, even though they're sometimes scattered around the
853 instructions. And displacements appear before base and extension
854 registers, as they do in the assembly syntax, not at the end, as
855 they do in the machine language. */
857 is_ri (bfd_byte *insn, int op1, int op2, unsigned int *r1, int *i2)
859 if (insn[0] == op1 && (insn[1] & 0xf) == op2)
861 *r1 = (insn[1] >> 4) & 0xf;
862 /* i2 is a 16-bit signed quantity. */
863 *i2 = (((insn[2] << 8) | insn[3]) ^ 0x8000) - 0x8000;
872 is_ril (bfd_byte *insn, int op1, int op2,
873 unsigned int *r1, int *i2)
875 if (insn[0] == op1 && (insn[1] & 0xf) == op2)
877 *r1 = (insn[1] >> 4) & 0xf;
878 /* i2 is a signed quantity. If the host 'int' is 32 bits long,
879 no sign extension is necessary, but we don't want to assume
881 *i2 = (((insn[2] << 24)
884 | (insn[5])) ^ 0x80000000) - 0x80000000;
893 is_rr (bfd_byte *insn, int op, unsigned int *r1, unsigned int *r2)
897 *r1 = (insn[1] >> 4) & 0xf;
907 is_rre (bfd_byte *insn, int op, unsigned int *r1, unsigned int *r2)
909 if (((insn[0] << 8) | insn[1]) == op)
911 /* Yes, insn[3]. insn[2] is unused in RRE format. */
912 *r1 = (insn[3] >> 4) & 0xf;
922 is_rs (bfd_byte *insn, int op,
923 unsigned int *r1, unsigned int *r3, int *d2, unsigned int *b2)
927 *r1 = (insn[1] >> 4) & 0xf;
929 *b2 = (insn[2] >> 4) & 0xf;
930 *d2 = ((insn[2] & 0xf) << 8) | insn[3];
939 is_rsy (bfd_byte *insn, int op1, int op2,
940 unsigned int *r1, unsigned int *r3, int *d2, unsigned int *b2)
945 *r1 = (insn[1] >> 4) & 0xf;
947 *b2 = (insn[2] >> 4) & 0xf;
948 /* The 'long displacement' is a 20-bit signed integer. */
949 *d2 = ((((insn[2] & 0xf) << 8) | insn[3] | (insn[4] << 12))
950 ^ 0x80000) - 0x80000;
959 is_rsi (bfd_byte *insn, int op,
960 unsigned int *r1, unsigned int *r3, int *i2)
964 *r1 = (insn[1] >> 4) & 0xf;
966 /* i2 is a 16-bit signed quantity. */
967 *i2 = (((insn[2] << 8) | insn[3]) ^ 0x8000) - 0x8000;
976 is_rie (bfd_byte *insn, int op1, int op2,
977 unsigned int *r1, unsigned int *r3, int *i2)
982 *r1 = (insn[1] >> 4) & 0xf;
984 /* i2 is a 16-bit signed quantity. */
985 *i2 = (((insn[2] << 8) | insn[3]) ^ 0x8000) - 0x8000;
994 is_rx (bfd_byte *insn, int op,
995 unsigned int *r1, int *d2, unsigned int *x2, unsigned int *b2)
999 *r1 = (insn[1] >> 4) & 0xf;
1000 *x2 = insn[1] & 0xf;
1001 *b2 = (insn[2] >> 4) & 0xf;
1002 *d2 = ((insn[2] & 0xf) << 8) | insn[3];
1011 is_rxy (bfd_byte *insn, int op1, int op2,
1012 unsigned int *r1, int *d2, unsigned int *x2, unsigned int *b2)
1017 *r1 = (insn[1] >> 4) & 0xf;
1018 *x2 = insn[1] & 0xf;
1019 *b2 = (insn[2] >> 4) & 0xf;
1020 /* The 'long displacement' is a 20-bit signed integer. */
1021 *d2 = ((((insn[2] & 0xf) << 8) | insn[3] | (insn[4] << 12))
1022 ^ 0x80000) - 0x80000;
1030 /* Prologue analysis. */
1032 #define S390_NUM_GPRS 16
1033 #define S390_NUM_FPRS 16
1035 struct s390_prologue_data {
1038 struct pv_area *stack;
1040 /* The size and byte-order of a GPR or FPR. */
1043 enum bfd_endian byte_order;
1045 /* The general-purpose registers. */
1046 pv_t gpr[S390_NUM_GPRS];
1048 /* The floating-point registers. */
1049 pv_t fpr[S390_NUM_FPRS];
1051 /* The offset relative to the CFA where the incoming GPR N was saved
1052 by the function prologue. 0 if not saved or unknown. */
1053 int gpr_slot[S390_NUM_GPRS];
1055 /* Likewise for FPRs. */
1056 int fpr_slot[S390_NUM_FPRS];
1058 /* Nonzero if the backchain was saved. This is assumed to be the
1059 case when the incoming SP is saved at the current SP location. */
1060 int back_chain_saved_p;
1063 /* Return the effective address for an X-style instruction, like:
1067 Here, X2 and B2 are registers, and D2 is a signed 20-bit
1068 constant; the effective address is the sum of all three. If either
1069 X2 or B2 are zero, then it doesn't contribute to the sum --- this
1070 means that r0 can't be used as either X2 or B2. */
1072 s390_addr (struct s390_prologue_data *data,
1073 int d2, unsigned int x2, unsigned int b2)
1077 result = pv_constant (d2);
1079 result = pv_add (result, data->gpr[x2]);
1081 result = pv_add (result, data->gpr[b2]);
1086 /* Do a SIZE-byte store of VALUE to D2(X2,B2). */
1088 s390_store (struct s390_prologue_data *data,
1089 int d2, unsigned int x2, unsigned int b2, CORE_ADDR size,
1092 pv_t addr = s390_addr (data, d2, x2, b2);
1095 /* Check whether we are storing the backchain. */
1096 offset = pv_subtract (data->gpr[S390_SP_REGNUM - S390_R0_REGNUM], addr);
1098 if (pv_is_constant (offset) && offset.k == 0)
1099 if (size == data->gpr_size
1100 && pv_is_register_k (value, S390_SP_REGNUM, 0))
1102 data->back_chain_saved_p = 1;
1107 /* Check whether we are storing a register into the stack. */
1108 if (!pv_area_store_would_trash (data->stack, addr))
1109 pv_area_store (data->stack, addr, size, value);
1112 /* Note: If this is some store we cannot identify, you might think we
1113 should forget our cached values, as any of those might have been hit.
1115 However, we make the assumption that the register save areas are only
1116 ever stored to once in any given function, and we do recognize these
1117 stores. Thus every store we cannot recognize does not hit our data. */
1120 /* Do a SIZE-byte load from D2(X2,B2). */
1122 s390_load (struct s390_prologue_data *data,
1123 int d2, unsigned int x2, unsigned int b2, CORE_ADDR size)
1126 pv_t addr = s390_addr (data, d2, x2, b2);
1128 /* If it's a load from an in-line constant pool, then we can
1129 simulate that, under the assumption that the code isn't
1130 going to change between the time the processor actually
1131 executed it creating the current frame, and the time when
1132 we're analyzing the code to unwind past that frame. */
1133 if (pv_is_constant (addr))
1135 struct target_section *secp;
1136 secp = target_section_by_addr (¤t_target, addr.k);
1138 && (bfd_get_section_flags (secp->the_bfd_section->owner,
1139 secp->the_bfd_section)
1141 return pv_constant (read_memory_integer (addr.k, size,
1145 /* Check whether we are accessing one of our save slots. */
1146 return pv_area_fetch (data->stack, addr, size);
1149 /* Function for finding saved registers in a 'struct pv_area'; we pass
1150 this to pv_area_scan.
1152 If VALUE is a saved register, ADDR says it was saved at a constant
1153 offset from the frame base, and SIZE indicates that the whole
1154 register was saved, record its offset in the reg_offset table in
1155 PROLOGUE_UNTYPED. */
1157 s390_check_for_saved (void *data_untyped, pv_t addr,
1158 CORE_ADDR size, pv_t value)
1160 struct s390_prologue_data *data = data_untyped;
1163 if (!pv_is_register (addr, S390_SP_REGNUM))
1166 offset = 16 * data->gpr_size + 32 - addr.k;
1168 /* If we are storing the original value of a register, we want to
1169 record the CFA offset. If the same register is stored multiple
1170 times, the stack slot with the highest address counts. */
1172 for (i = 0; i < S390_NUM_GPRS; i++)
1173 if (size == data->gpr_size
1174 && pv_is_register_k (value, S390_R0_REGNUM + i, 0))
1175 if (data->gpr_slot[i] == 0
1176 || data->gpr_slot[i] > offset)
1178 data->gpr_slot[i] = offset;
1182 for (i = 0; i < S390_NUM_FPRS; i++)
1183 if (size == data->fpr_size
1184 && pv_is_register_k (value, S390_F0_REGNUM + i, 0))
1185 if (data->fpr_slot[i] == 0
1186 || data->fpr_slot[i] > offset)
1188 data->fpr_slot[i] = offset;
1193 /* Analyze the prologue of the function starting at START_PC,
1194 continuing at most until CURRENT_PC. Initialize DATA to
1195 hold all information we find out about the state of the registers
1196 and stack slots. Return the address of the instruction after
1197 the last one that changed the SP, FP, or back chain; or zero
1200 s390_analyze_prologue (struct gdbarch *gdbarch,
1202 CORE_ADDR current_pc,
1203 struct s390_prologue_data *data)
1205 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1207 /* Our return value:
1208 The address of the instruction after the last one that changed
1209 the SP, FP, or back chain; zero if we got an error trying to
1211 CORE_ADDR result = start_pc;
1213 /* The current PC for our abstract interpretation. */
1216 /* The address of the next instruction after that. */
1219 /* Set up everything's initial value. */
1223 data->stack = make_pv_area (S390_SP_REGNUM, gdbarch_addr_bit (gdbarch));
1225 /* For the purpose of prologue tracking, we consider the GPR size to
1226 be equal to the ABI word size, even if it is actually larger
1227 (i.e. when running a 32-bit binary under a 64-bit kernel). */
1228 data->gpr_size = word_size;
1230 data->byte_order = gdbarch_byte_order (gdbarch);
1232 for (i = 0; i < S390_NUM_GPRS; i++)
1233 data->gpr[i] = pv_register (S390_R0_REGNUM + i, 0);
1235 for (i = 0; i < S390_NUM_FPRS; i++)
1236 data->fpr[i] = pv_register (S390_F0_REGNUM + i, 0);
1238 for (i = 0; i < S390_NUM_GPRS; i++)
1239 data->gpr_slot[i] = 0;
1241 for (i = 0; i < S390_NUM_FPRS; i++)
1242 data->fpr_slot[i] = 0;
1244 data->back_chain_saved_p = 0;
1247 /* Start interpreting instructions, until we hit the frame's
1248 current PC or the first branch instruction. */
1249 for (pc = start_pc; pc > 0 && pc < current_pc; pc = next_pc)
1251 bfd_byte insn[S390_MAX_INSTR_SIZE];
1252 int insn_len = s390_readinstruction (insn, pc);
1254 bfd_byte dummy[S390_MAX_INSTR_SIZE] = { 0 };
1255 bfd_byte *insn32 = word_size == 4 ? insn : dummy;
1256 bfd_byte *insn64 = word_size == 8 ? insn : dummy;
1258 /* Fields for various kinds of instructions. */
1259 unsigned int b2, r1, r2, x2, r3;
1262 /* The values of SP and FP before this instruction,
1263 for detecting instructions that change them. */
1264 pv_t pre_insn_sp, pre_insn_fp;
1265 /* Likewise for the flag whether the back chain was saved. */
1266 int pre_insn_back_chain_saved_p;
1268 /* If we got an error trying to read the instruction, report it. */
1275 next_pc = pc + insn_len;
1277 pre_insn_sp = data->gpr[S390_SP_REGNUM - S390_R0_REGNUM];
1278 pre_insn_fp = data->gpr[S390_FRAME_REGNUM - S390_R0_REGNUM];
1279 pre_insn_back_chain_saved_p = data->back_chain_saved_p;
1282 /* LHI r1, i2 --- load halfword immediate. */
1283 /* LGHI r1, i2 --- load halfword immediate (64-bit version). */
1284 /* LGFI r1, i2 --- load fullword immediate. */
1285 if (is_ri (insn32, op1_lhi, op2_lhi, &r1, &i2)
1286 || is_ri (insn64, op1_lghi, op2_lghi, &r1, &i2)
1287 || is_ril (insn, op1_lgfi, op2_lgfi, &r1, &i2))
1288 data->gpr[r1] = pv_constant (i2);
1290 /* LR r1, r2 --- load from register. */
1291 /* LGR r1, r2 --- load from register (64-bit version). */
1292 else if (is_rr (insn32, op_lr, &r1, &r2)
1293 || is_rre (insn64, op_lgr, &r1, &r2))
1294 data->gpr[r1] = data->gpr[r2];
1296 /* L r1, d2(x2, b2) --- load. */
1297 /* LY r1, d2(x2, b2) --- load (long-displacement version). */
1298 /* LG r1, d2(x2, b2) --- load (64-bit version). */
1299 else if (is_rx (insn32, op_l, &r1, &d2, &x2, &b2)
1300 || is_rxy (insn32, op1_ly, op2_ly, &r1, &d2, &x2, &b2)
1301 || is_rxy (insn64, op1_lg, op2_lg, &r1, &d2, &x2, &b2))
1302 data->gpr[r1] = s390_load (data, d2, x2, b2, data->gpr_size);
1304 /* ST r1, d2(x2, b2) --- store. */
1305 /* STY r1, d2(x2, b2) --- store (long-displacement version). */
1306 /* STG r1, d2(x2, b2) --- store (64-bit version). */
1307 else if (is_rx (insn32, op_st, &r1, &d2, &x2, &b2)
1308 || is_rxy (insn32, op1_sty, op2_sty, &r1, &d2, &x2, &b2)
1309 || is_rxy (insn64, op1_stg, op2_stg, &r1, &d2, &x2, &b2))
1310 s390_store (data, d2, x2, b2, data->gpr_size, data->gpr[r1]);
1312 /* STD r1, d2(x2,b2) --- store floating-point register. */
1313 else if (is_rx (insn, op_std, &r1, &d2, &x2, &b2))
1314 s390_store (data, d2, x2, b2, data->fpr_size, data->fpr[r1]);
1316 /* STM r1, r3, d2(b2) --- store multiple. */
1317 /* STMY r1, r3, d2(b2) --- store multiple (long-displacement
1319 /* STMG r1, r3, d2(b2) --- store multiple (64-bit version). */
1320 else if (is_rs (insn32, op_stm, &r1, &r3, &d2, &b2)
1321 || is_rsy (insn32, op1_stmy, op2_stmy, &r1, &r3, &d2, &b2)
1322 || is_rsy (insn64, op1_stmg, op2_stmg, &r1, &r3, &d2, &b2))
1324 for (; r1 <= r3; r1++, d2 += data->gpr_size)
1325 s390_store (data, d2, 0, b2, data->gpr_size, data->gpr[r1]);
1328 /* AHI r1, i2 --- add halfword immediate. */
1329 /* AGHI r1, i2 --- add halfword immediate (64-bit version). */
1330 /* AFI r1, i2 --- add fullword immediate. */
1331 /* AGFI r1, i2 --- add fullword immediate (64-bit version). */
1332 else if (is_ri (insn32, op1_ahi, op2_ahi, &r1, &i2)
1333 || is_ri (insn64, op1_aghi, op2_aghi, &r1, &i2)
1334 || is_ril (insn32, op1_afi, op2_afi, &r1, &i2)
1335 || is_ril (insn64, op1_agfi, op2_agfi, &r1, &i2))
1336 data->gpr[r1] = pv_add_constant (data->gpr[r1], i2);
1338 /* ALFI r1, i2 --- add logical immediate. */
1339 /* ALGFI r1, i2 --- add logical immediate (64-bit version). */
1340 else if (is_ril (insn32, op1_alfi, op2_alfi, &r1, &i2)
1341 || is_ril (insn64, op1_algfi, op2_algfi, &r1, &i2))
1342 data->gpr[r1] = pv_add_constant (data->gpr[r1],
1343 (CORE_ADDR)i2 & 0xffffffff);
1345 /* AR r1, r2 -- add register. */
1346 /* AGR r1, r2 -- add register (64-bit version). */
1347 else if (is_rr (insn32, op_ar, &r1, &r2)
1348 || is_rre (insn64, op_agr, &r1, &r2))
1349 data->gpr[r1] = pv_add (data->gpr[r1], data->gpr[r2]);
1351 /* A r1, d2(x2, b2) -- add. */
1352 /* AY r1, d2(x2, b2) -- add (long-displacement version). */
1353 /* AG r1, d2(x2, b2) -- add (64-bit version). */
1354 else if (is_rx (insn32, op_a, &r1, &d2, &x2, &b2)
1355 || is_rxy (insn32, op1_ay, op2_ay, &r1, &d2, &x2, &b2)
1356 || is_rxy (insn64, op1_ag, op2_ag, &r1, &d2, &x2, &b2))
1357 data->gpr[r1] = pv_add (data->gpr[r1],
1358 s390_load (data, d2, x2, b2, data->gpr_size));
1360 /* SLFI r1, i2 --- subtract logical immediate. */
1361 /* SLGFI r1, i2 --- subtract logical immediate (64-bit version). */
1362 else if (is_ril (insn32, op1_slfi, op2_slfi, &r1, &i2)
1363 || is_ril (insn64, op1_slgfi, op2_slgfi, &r1, &i2))
1364 data->gpr[r1] = pv_add_constant (data->gpr[r1],
1365 -((CORE_ADDR)i2 & 0xffffffff));
1367 /* SR r1, r2 -- subtract register. */
1368 /* SGR r1, r2 -- subtract register (64-bit version). */
1369 else if (is_rr (insn32, op_sr, &r1, &r2)
1370 || is_rre (insn64, op_sgr, &r1, &r2))
1371 data->gpr[r1] = pv_subtract (data->gpr[r1], data->gpr[r2]);
1373 /* S r1, d2(x2, b2) -- subtract. */
1374 /* SY r1, d2(x2, b2) -- subtract (long-displacement version). */
1375 /* SG r1, d2(x2, b2) -- subtract (64-bit version). */
1376 else if (is_rx (insn32, op_s, &r1, &d2, &x2, &b2)
1377 || is_rxy (insn32, op1_sy, op2_sy, &r1, &d2, &x2, &b2)
1378 || is_rxy (insn64, op1_sg, op2_sg, &r1, &d2, &x2, &b2))
1379 data->gpr[r1] = pv_subtract (data->gpr[r1],
1380 s390_load (data, d2, x2, b2, data->gpr_size));
1382 /* LA r1, d2(x2, b2) --- load address. */
1383 /* LAY r1, d2(x2, b2) --- load address (long-displacement version). */
1384 else if (is_rx (insn, op_la, &r1, &d2, &x2, &b2)
1385 || is_rxy (insn, op1_lay, op2_lay, &r1, &d2, &x2, &b2))
1386 data->gpr[r1] = s390_addr (data, d2, x2, b2);
1388 /* LARL r1, i2 --- load address relative long. */
1389 else if (is_ril (insn, op1_larl, op2_larl, &r1, &i2))
1390 data->gpr[r1] = pv_constant (pc + i2 * 2);
1392 /* BASR r1, 0 --- branch and save.
1393 Since r2 is zero, this saves the PC in r1, but doesn't branch. */
1394 else if (is_rr (insn, op_basr, &r1, &r2)
1396 data->gpr[r1] = pv_constant (next_pc);
1398 /* BRAS r1, i2 --- branch relative and save. */
1399 else if (is_ri (insn, op1_bras, op2_bras, &r1, &i2))
1401 data->gpr[r1] = pv_constant (next_pc);
1402 next_pc = pc + i2 * 2;
1404 /* We'd better not interpret any backward branches. We'll
1410 /* Terminate search when hitting any other branch instruction. */
1411 else if (is_rr (insn, op_basr, &r1, &r2)
1412 || is_rx (insn, op_bas, &r1, &d2, &x2, &b2)
1413 || is_rr (insn, op_bcr, &r1, &r2)
1414 || is_rx (insn, op_bc, &r1, &d2, &x2, &b2)
1415 || is_ri (insn, op1_brc, op2_brc, &r1, &i2)
1416 || is_ril (insn, op1_brcl, op2_brcl, &r1, &i2)
1417 || is_ril (insn, op1_brasl, op2_brasl, &r2, &i2))
1422 /* An instruction we don't know how to simulate. The only
1423 safe thing to do would be to set every value we're tracking
1424 to 'unknown'. Instead, we'll be optimistic: we assume that
1425 we *can* interpret every instruction that the compiler uses
1426 to manipulate any of the data we're interested in here --
1427 then we can just ignore anything else. */
1430 /* Record the address after the last instruction that changed
1431 the FP, SP, or backlink. Ignore instructions that changed
1432 them back to their original values --- those are probably
1433 restore instructions. (The back chain is never restored,
1436 pv_t sp = data->gpr[S390_SP_REGNUM - S390_R0_REGNUM];
1437 pv_t fp = data->gpr[S390_FRAME_REGNUM - S390_R0_REGNUM];
1439 if ((! pv_is_identical (pre_insn_sp, sp)
1440 && ! pv_is_register_k (sp, S390_SP_REGNUM, 0)
1441 && sp.kind != pvk_unknown)
1442 || (! pv_is_identical (pre_insn_fp, fp)
1443 && ! pv_is_register_k (fp, S390_FRAME_REGNUM, 0)
1444 && fp.kind != pvk_unknown)
1445 || pre_insn_back_chain_saved_p != data->back_chain_saved_p)
1450 /* Record where all the registers were saved. */
1451 pv_area_scan (data->stack, s390_check_for_saved, data);
1453 free_pv_area (data->stack);
1459 /* Advance PC across any function entry prologue instructions to reach
1460 some "real" code. */
1462 s390_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
1464 struct s390_prologue_data data;
1466 skip_pc = s390_analyze_prologue (gdbarch, pc, (CORE_ADDR)-1, &data);
1467 return skip_pc ? skip_pc : pc;
1470 /* Return true if we are in the functin's epilogue, i.e. after the
1471 instruction that destroyed the function's stack frame. */
1473 s390_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
1475 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1477 /* In frameless functions, there's not frame to destroy and thus
1478 we don't care about the epilogue.
1480 In functions with frame, the epilogue sequence is a pair of
1481 a LM-type instruction that restores (amongst others) the
1482 return register %r14 and the stack pointer %r15, followed
1483 by a branch 'br %r14' --or equivalent-- that effects the
1486 In that situation, this function needs to return 'true' in
1487 exactly one case: when pc points to that branch instruction.
1489 Thus we try to disassemble the one instructions immediately
1490 preceding pc and check whether it is an LM-type instruction
1491 modifying the stack pointer.
1493 Note that disassembling backwards is not reliable, so there
1494 is a slight chance of false positives here ... */
1497 unsigned int r1, r3, b2;
1501 && !target_read_memory (pc - 4, insn, 4)
1502 && is_rs (insn, op_lm, &r1, &r3, &d2, &b2)
1503 && r3 == S390_SP_REGNUM - S390_R0_REGNUM)
1507 && !target_read_memory (pc - 6, insn, 6)
1508 && is_rsy (insn, op1_lmy, op2_lmy, &r1, &r3, &d2, &b2)
1509 && r3 == S390_SP_REGNUM - S390_R0_REGNUM)
1513 && !target_read_memory (pc - 6, insn, 6)
1514 && is_rsy (insn, op1_lmg, op2_lmg, &r1, &r3, &d2, &b2)
1515 && r3 == S390_SP_REGNUM - S390_R0_REGNUM)
1521 /* Displaced stepping. */
1523 /* Fix up the state of registers and memory after having single-stepped
1524 a displaced instruction. */
1526 s390_displaced_step_fixup (struct gdbarch *gdbarch,
1527 struct displaced_step_closure *closure,
1528 CORE_ADDR from, CORE_ADDR to,
1529 struct regcache *regs)
1531 /* Since we use simple_displaced_step_copy_insn, our closure is a
1532 copy of the instruction. */
1533 gdb_byte *insn = (gdb_byte *) closure;
1534 static int s390_instrlen[] = { 2, 4, 4, 6 };
1535 int insnlen = s390_instrlen[insn[0] >> 6];
1537 /* Fields for various kinds of instructions. */
1538 unsigned int b2, r1, r2, x2, r3;
1541 /* Get current PC and addressing mode bit. */
1542 CORE_ADDR pc = regcache_read_pc (regs);
1545 if (register_size (gdbarch, S390_PSWA_REGNUM) == 4)
1547 regcache_cooked_read_unsigned (regs, S390_PSWA_REGNUM, &amode);
1548 amode &= 0x80000000;
1551 if (debug_displaced)
1552 fprintf_unfiltered (gdb_stdlog,
1553 "displaced: (s390) fixup (%s, %s) pc %s len %d amode 0x%x\n",
1554 paddress (gdbarch, from), paddress (gdbarch, to),
1555 paddress (gdbarch, pc), insnlen, (int) amode);
1557 /* Handle absolute branch and save instructions. */
1558 if (is_rr (insn, op_basr, &r1, &r2)
1559 || is_rx (insn, op_bas, &r1, &d2, &x2, &b2))
1561 /* Recompute saved return address in R1. */
1562 regcache_cooked_write_unsigned (regs, S390_R0_REGNUM + r1,
1563 amode | (from + insnlen));
1566 /* Handle absolute branch instructions. */
1567 else if (is_rr (insn, op_bcr, &r1, &r2)
1568 || is_rx (insn, op_bc, &r1, &d2, &x2, &b2)
1569 || is_rr (insn, op_bctr, &r1, &r2)
1570 || is_rre (insn, op_bctgr, &r1, &r2)
1571 || is_rx (insn, op_bct, &r1, &d2, &x2, &b2)
1572 || is_rxy (insn, op1_bctg, op2_brctg, &r1, &d2, &x2, &b2)
1573 || is_rs (insn, op_bxh, &r1, &r3, &d2, &b2)
1574 || is_rsy (insn, op1_bxhg, op2_bxhg, &r1, &r3, &d2, &b2)
1575 || is_rs (insn, op_bxle, &r1, &r3, &d2, &b2)
1576 || is_rsy (insn, op1_bxleg, op2_bxleg, &r1, &r3, &d2, &b2))
1578 /* Update PC iff branch was *not* taken. */
1579 if (pc == to + insnlen)
1580 regcache_write_pc (regs, from + insnlen);
1583 /* Handle PC-relative branch and save instructions. */
1584 else if (is_ri (insn, op1_bras, op2_bras, &r1, &i2)
1585 || is_ril (insn, op1_brasl, op2_brasl, &r1, &i2))
1588 regcache_write_pc (regs, pc - to + from);
1589 /* Recompute saved return address in R1. */
1590 regcache_cooked_write_unsigned (regs, S390_R0_REGNUM + r1,
1591 amode | (from + insnlen));
1594 /* Handle PC-relative branch instructions. */
1595 else if (is_ri (insn, op1_brc, op2_brc, &r1, &i2)
1596 || is_ril (insn, op1_brcl, op2_brcl, &r1, &i2)
1597 || is_ri (insn, op1_brct, op2_brct, &r1, &i2)
1598 || is_ri (insn, op1_brctg, op2_brctg, &r1, &i2)
1599 || is_rsi (insn, op_brxh, &r1, &r3, &i2)
1600 || is_rie (insn, op1_brxhg, op2_brxhg, &r1, &r3, &i2)
1601 || is_rsi (insn, op_brxle, &r1, &r3, &i2)
1602 || is_rie (insn, op1_brxlg, op2_brxlg, &r1, &r3, &i2))
1605 regcache_write_pc (regs, pc - to + from);
1608 /* Handle LOAD ADDRESS RELATIVE LONG. */
1609 else if (is_ril (insn, op1_larl, op2_larl, &r1, &i2))
1612 regcache_write_pc (regs, from + insnlen);
1613 /* Recompute output address in R1. */
1614 regcache_cooked_write_unsigned (regs, S390_R0_REGNUM + r1,
1615 amode | (from + i2 * 2));
1618 /* If we executed a breakpoint instruction, point PC right back at it. */
1619 else if (insn[0] == 0x0 && insn[1] == 0x1)
1620 regcache_write_pc (regs, from);
1622 /* For any other insn, PC points right after the original instruction. */
1624 regcache_write_pc (regs, from + insnlen);
1626 if (debug_displaced)
1627 fprintf_unfiltered (gdb_stdlog,
1628 "displaced: (s390) pc is now %s\n",
1629 paddress (gdbarch, regcache_read_pc (regs)));
1633 /* Helper routine to unwind pseudo registers. */
1635 static struct value *
1636 s390_unwind_pseudo_register (struct frame_info *this_frame, int regnum)
1638 struct gdbarch *gdbarch = get_frame_arch (this_frame);
1639 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1640 struct type *type = register_type (gdbarch, regnum);
1642 /* Unwind PC via PSW address. */
1643 if (regnum == tdep->pc_regnum)
1647 val = frame_unwind_register_value (this_frame, S390_PSWA_REGNUM);
1648 if (!value_optimized_out (val))
1650 LONGEST pswa = value_as_long (val);
1652 if (TYPE_LENGTH (type) == 4)
1653 return value_from_pointer (type, pswa & 0x7fffffff);
1655 return value_from_pointer (type, pswa);
1659 /* Unwind CC via PSW mask. */
1660 if (regnum == tdep->cc_regnum)
1664 val = frame_unwind_register_value (this_frame, S390_PSWM_REGNUM);
1665 if (!value_optimized_out (val))
1667 LONGEST pswm = value_as_long (val);
1669 if (TYPE_LENGTH (type) == 4)
1670 return value_from_longest (type, (pswm >> 12) & 3);
1672 return value_from_longest (type, (pswm >> 44) & 3);
1676 /* Unwind full GPRs to show at least the lower halves (as the
1677 upper halves are undefined). */
1678 if (regnum_is_gpr_full (tdep, regnum))
1680 int reg = regnum - tdep->gpr_full_regnum;
1683 val = frame_unwind_register_value (this_frame, S390_R0_REGNUM + reg);
1684 if (!value_optimized_out (val))
1685 return value_cast (type, val);
1688 return allocate_optimized_out_value (type);
1691 static struct value *
1692 s390_trad_frame_prev_register (struct frame_info *this_frame,
1693 struct trad_frame_saved_reg saved_regs[],
1696 if (regnum < S390_NUM_REGS)
1697 return trad_frame_get_prev_register (this_frame, saved_regs, regnum);
1699 return s390_unwind_pseudo_register (this_frame, regnum);
1703 /* Normal stack frames. */
1705 struct s390_unwind_cache {
1708 CORE_ADDR frame_base;
1709 CORE_ADDR local_base;
1711 struct trad_frame_saved_reg *saved_regs;
1715 s390_prologue_frame_unwind_cache (struct frame_info *this_frame,
1716 struct s390_unwind_cache *info)
1718 struct gdbarch *gdbarch = get_frame_arch (this_frame);
1719 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1720 struct s390_prologue_data data;
1721 pv_t *fp = &data.gpr[S390_FRAME_REGNUM - S390_R0_REGNUM];
1722 pv_t *sp = &data.gpr[S390_SP_REGNUM - S390_R0_REGNUM];
1731 struct frame_info *next_frame;
1733 /* Try to find the function start address. If we can't find it, we don't
1734 bother searching for it -- with modern compilers this would be mostly
1735 pointless anyway. Trust that we'll either have valid DWARF-2 CFI data
1736 or else a valid backchain ... */
1737 func = get_frame_func (this_frame);
1741 /* Try to analyze the prologue. */
1742 result = s390_analyze_prologue (gdbarch, func,
1743 get_frame_pc (this_frame), &data);
1747 /* If this was successful, we should have found the instruction that
1748 sets the stack pointer register to the previous value of the stack
1749 pointer minus the frame size. */
1750 if (!pv_is_register (*sp, S390_SP_REGNUM))
1753 /* A frame size of zero at this point can mean either a real
1754 frameless function, or else a failure to find the prologue.
1755 Perform some sanity checks to verify we really have a
1756 frameless function. */
1759 /* If the next frame is a NORMAL_FRAME, this frame *cannot* have frame
1760 size zero. This is only possible if the next frame is a sentinel
1761 frame, a dummy frame, or a signal trampoline frame. */
1762 /* FIXME: cagney/2004-05-01: This sanity check shouldn't be
1763 needed, instead the code should simpliy rely on its
1765 next_frame = get_next_frame (this_frame);
1766 while (next_frame && get_frame_type (next_frame) == INLINE_FRAME)
1767 next_frame = get_next_frame (next_frame);
1769 && get_frame_type (get_next_frame (this_frame)) == NORMAL_FRAME)
1772 /* If we really have a frameless function, %r14 must be valid
1773 -- in particular, it must point to a different function. */
1774 reg = get_frame_register_unsigned (this_frame, S390_RETADDR_REGNUM);
1775 reg = gdbarch_addr_bits_remove (gdbarch, reg) - 1;
1776 if (get_pc_function_start (reg) == func)
1778 /* However, there is one case where it *is* valid for %r14
1779 to point to the same function -- if this is a recursive
1780 call, and we have stopped in the prologue *before* the
1781 stack frame was allocated.
1783 Recognize this case by looking ahead a bit ... */
1785 struct s390_prologue_data data2;
1786 pv_t *sp = &data2.gpr[S390_SP_REGNUM - S390_R0_REGNUM];
1788 if (!(s390_analyze_prologue (gdbarch, func, (CORE_ADDR)-1, &data2)
1789 && pv_is_register (*sp, S390_SP_REGNUM)
1796 /* OK, we've found valid prologue data. */
1799 /* If the frame pointer originally also holds the same value
1800 as the stack pointer, we're probably using it. If it holds
1801 some other value -- even a constant offset -- it is most
1802 likely used as temp register. */
1803 if (pv_is_identical (*sp, *fp))
1804 frame_pointer = S390_FRAME_REGNUM;
1806 frame_pointer = S390_SP_REGNUM;
1808 /* If we've detected a function with stack frame, we'll still have to
1809 treat it as frameless if we're currently within the function epilog
1810 code at a point where the frame pointer has already been restored.
1811 This can only happen in an innermost frame. */
1812 /* FIXME: cagney/2004-05-01: This sanity check shouldn't be needed,
1813 instead the code should simpliy rely on its analysis. */
1814 next_frame = get_next_frame (this_frame);
1815 while (next_frame && get_frame_type (next_frame) == INLINE_FRAME)
1816 next_frame = get_next_frame (next_frame);
1818 && (next_frame == NULL
1819 || get_frame_type (get_next_frame (this_frame)) != NORMAL_FRAME))
1821 /* See the comment in s390_in_function_epilogue_p on why this is
1822 not completely reliable ... */
1823 if (s390_in_function_epilogue_p (gdbarch, get_frame_pc (this_frame)))
1825 memset (&data, 0, sizeof (data));
1827 frame_pointer = S390_SP_REGNUM;
1831 /* Once we know the frame register and the frame size, we can unwind
1832 the current value of the frame register from the next frame, and
1833 add back the frame size to arrive that the previous frame's
1834 stack pointer value. */
1835 prev_sp = get_frame_register_unsigned (this_frame, frame_pointer) + size;
1836 cfa = prev_sp + 16*word_size + 32;
1838 /* Set up ABI call-saved/call-clobbered registers. */
1839 for (i = 0; i < S390_NUM_REGS; i++)
1840 if (!s390_register_call_saved (gdbarch, i))
1841 trad_frame_set_unknown (info->saved_regs, i);
1843 /* CC is always call-clobbered. */
1844 trad_frame_set_unknown (info->saved_regs, S390_PSWM_REGNUM);
1846 /* Record the addresses of all register spill slots the prologue parser
1847 has recognized. Consider only registers defined as call-saved by the
1848 ABI; for call-clobbered registers the parser may have recognized
1851 for (i = 0; i < 16; i++)
1852 if (s390_register_call_saved (gdbarch, S390_R0_REGNUM + i)
1853 && data.gpr_slot[i] != 0)
1854 info->saved_regs[S390_R0_REGNUM + i].addr = cfa - data.gpr_slot[i];
1856 for (i = 0; i < 16; i++)
1857 if (s390_register_call_saved (gdbarch, S390_F0_REGNUM + i)
1858 && data.fpr_slot[i] != 0)
1859 info->saved_regs[S390_F0_REGNUM + i].addr = cfa - data.fpr_slot[i];
1861 /* Function return will set PC to %r14. */
1862 info->saved_regs[S390_PSWA_REGNUM] = info->saved_regs[S390_RETADDR_REGNUM];
1864 /* In frameless functions, we unwind simply by moving the return
1865 address to the PC. However, if we actually stored to the
1866 save area, use that -- we might only think the function frameless
1867 because we're in the middle of the prologue ... */
1869 && !trad_frame_addr_p (info->saved_regs, S390_PSWA_REGNUM))
1871 info->saved_regs[S390_PSWA_REGNUM].realreg = S390_RETADDR_REGNUM;
1874 /* Another sanity check: unless this is a frameless function,
1875 we should have found spill slots for SP and PC.
1876 If not, we cannot unwind further -- this happens e.g. in
1877 libc's thread_start routine. */
1880 if (!trad_frame_addr_p (info->saved_regs, S390_SP_REGNUM)
1881 || !trad_frame_addr_p (info->saved_regs, S390_PSWA_REGNUM))
1885 /* We use the current value of the frame register as local_base,
1886 and the top of the register save area as frame_base. */
1889 info->frame_base = prev_sp + 16*word_size + 32;
1890 info->local_base = prev_sp - size;
1898 s390_backchain_frame_unwind_cache (struct frame_info *this_frame,
1899 struct s390_unwind_cache *info)
1901 struct gdbarch *gdbarch = get_frame_arch (this_frame);
1902 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1903 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1904 CORE_ADDR backchain;
1909 /* Set up ABI call-saved/call-clobbered registers. */
1910 for (i = 0; i < S390_NUM_REGS; i++)
1911 if (!s390_register_call_saved (gdbarch, i))
1912 trad_frame_set_unknown (info->saved_regs, i);
1914 /* CC is always call-clobbered. */
1915 trad_frame_set_unknown (info->saved_regs, S390_PSWM_REGNUM);
1917 /* Get the backchain. */
1918 reg = get_frame_register_unsigned (this_frame, S390_SP_REGNUM);
1919 backchain = read_memory_unsigned_integer (reg, word_size, byte_order);
1921 /* A zero backchain terminates the frame chain. As additional
1922 sanity check, let's verify that the spill slot for SP in the
1923 save area pointed to by the backchain in fact links back to
1926 && safe_read_memory_integer (backchain + 15*word_size,
1927 word_size, byte_order, &sp)
1928 && (CORE_ADDR)sp == backchain)
1930 /* We don't know which registers were saved, but it will have
1931 to be at least %r14 and %r15. This will allow us to continue
1932 unwinding, but other prev-frame registers may be incorrect ... */
1933 info->saved_regs[S390_SP_REGNUM].addr = backchain + 15*word_size;
1934 info->saved_regs[S390_RETADDR_REGNUM].addr = backchain + 14*word_size;
1936 /* Function return will set PC to %r14. */
1937 info->saved_regs[S390_PSWA_REGNUM]
1938 = info->saved_regs[S390_RETADDR_REGNUM];
1940 /* We use the current value of the frame register as local_base,
1941 and the top of the register save area as frame_base. */
1942 info->frame_base = backchain + 16*word_size + 32;
1943 info->local_base = reg;
1946 info->func = get_frame_pc (this_frame);
1949 static struct s390_unwind_cache *
1950 s390_frame_unwind_cache (struct frame_info *this_frame,
1951 void **this_prologue_cache)
1953 volatile struct gdb_exception ex;
1954 struct s390_unwind_cache *info;
1956 if (*this_prologue_cache)
1957 return *this_prologue_cache;
1959 info = FRAME_OBSTACK_ZALLOC (struct s390_unwind_cache);
1960 *this_prologue_cache = info;
1961 info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
1963 info->frame_base = -1;
1964 info->local_base = -1;
1966 TRY_CATCH (ex, RETURN_MASK_ERROR)
1968 /* Try to use prologue analysis to fill the unwind cache.
1969 If this fails, fall back to reading the stack backchain. */
1970 if (!s390_prologue_frame_unwind_cache (this_frame, info))
1971 s390_backchain_frame_unwind_cache (this_frame, info);
1973 if (ex.reason < 0 && ex.error != NOT_AVAILABLE_ERROR)
1974 throw_exception (ex);
1980 s390_frame_this_id (struct frame_info *this_frame,
1981 void **this_prologue_cache,
1982 struct frame_id *this_id)
1984 struct s390_unwind_cache *info
1985 = s390_frame_unwind_cache (this_frame, this_prologue_cache);
1987 if (info->frame_base == -1)
1990 *this_id = frame_id_build (info->frame_base, info->func);
1993 static struct value *
1994 s390_frame_prev_register (struct frame_info *this_frame,
1995 void **this_prologue_cache, int regnum)
1997 struct gdbarch *gdbarch = get_frame_arch (this_frame);
1998 struct s390_unwind_cache *info
1999 = s390_frame_unwind_cache (this_frame, this_prologue_cache);
2001 return s390_trad_frame_prev_register (this_frame, info->saved_regs, regnum);
2004 static const struct frame_unwind s390_frame_unwind = {
2006 default_frame_unwind_stop_reason,
2008 s390_frame_prev_register,
2010 default_frame_sniffer
2014 /* Code stubs and their stack frames. For things like PLTs and NULL
2015 function calls (where there is no true frame and the return address
2016 is in the RETADDR register). */
2018 struct s390_stub_unwind_cache
2020 CORE_ADDR frame_base;
2021 struct trad_frame_saved_reg *saved_regs;
2024 static struct s390_stub_unwind_cache *
2025 s390_stub_frame_unwind_cache (struct frame_info *this_frame,
2026 void **this_prologue_cache)
2028 struct gdbarch *gdbarch = get_frame_arch (this_frame);
2029 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
2030 struct s390_stub_unwind_cache *info;
2033 if (*this_prologue_cache)
2034 return *this_prologue_cache;
2036 info = FRAME_OBSTACK_ZALLOC (struct s390_stub_unwind_cache);
2037 *this_prologue_cache = info;
2038 info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
2040 /* The return address is in register %r14. */
2041 info->saved_regs[S390_PSWA_REGNUM].realreg = S390_RETADDR_REGNUM;
2043 /* Retrieve stack pointer and determine our frame base. */
2044 reg = get_frame_register_unsigned (this_frame, S390_SP_REGNUM);
2045 info->frame_base = reg + 16*word_size + 32;
2051 s390_stub_frame_this_id (struct frame_info *this_frame,
2052 void **this_prologue_cache,
2053 struct frame_id *this_id)
2055 struct s390_stub_unwind_cache *info
2056 = s390_stub_frame_unwind_cache (this_frame, this_prologue_cache);
2057 *this_id = frame_id_build (info->frame_base, get_frame_pc (this_frame));
2060 static struct value *
2061 s390_stub_frame_prev_register (struct frame_info *this_frame,
2062 void **this_prologue_cache, int regnum)
2064 struct s390_stub_unwind_cache *info
2065 = s390_stub_frame_unwind_cache (this_frame, this_prologue_cache);
2066 return s390_trad_frame_prev_register (this_frame, info->saved_regs, regnum);
2070 s390_stub_frame_sniffer (const struct frame_unwind *self,
2071 struct frame_info *this_frame,
2072 void **this_prologue_cache)
2074 CORE_ADDR addr_in_block;
2075 bfd_byte insn[S390_MAX_INSTR_SIZE];
2077 /* If the current PC points to non-readable memory, we assume we
2078 have trapped due to an invalid function pointer call. We handle
2079 the non-existing current function like a PLT stub. */
2080 addr_in_block = get_frame_address_in_block (this_frame);
2081 if (in_plt_section (addr_in_block)
2082 || s390_readinstruction (insn, get_frame_pc (this_frame)) < 0)
2087 static const struct frame_unwind s390_stub_frame_unwind = {
2089 default_frame_unwind_stop_reason,
2090 s390_stub_frame_this_id,
2091 s390_stub_frame_prev_register,
2093 s390_stub_frame_sniffer
2097 /* Signal trampoline stack frames. */
2099 struct s390_sigtramp_unwind_cache {
2100 CORE_ADDR frame_base;
2101 struct trad_frame_saved_reg *saved_regs;
2104 static struct s390_sigtramp_unwind_cache *
2105 s390_sigtramp_frame_unwind_cache (struct frame_info *this_frame,
2106 void **this_prologue_cache)
2108 struct gdbarch *gdbarch = get_frame_arch (this_frame);
2109 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2110 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
2111 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2112 struct s390_sigtramp_unwind_cache *info;
2113 ULONGEST this_sp, prev_sp;
2114 CORE_ADDR next_ra, next_cfa, sigreg_ptr, sigreg_high_off;
2117 if (*this_prologue_cache)
2118 return *this_prologue_cache;
2120 info = FRAME_OBSTACK_ZALLOC (struct s390_sigtramp_unwind_cache);
2121 *this_prologue_cache = info;
2122 info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
2124 this_sp = get_frame_register_unsigned (this_frame, S390_SP_REGNUM);
2125 next_ra = get_frame_pc (this_frame);
2126 next_cfa = this_sp + 16*word_size + 32;
2128 /* New-style RT frame:
2129 retcode + alignment (8 bytes)
2131 ucontext (contains sigregs at offset 5 words). */
2132 if (next_ra == next_cfa)
2134 sigreg_ptr = next_cfa + 8 + 128 + align_up (5*word_size, 8);
2135 /* sigregs are followed by uc_sigmask (8 bytes), then by the
2136 upper GPR halves if present. */
2137 sigreg_high_off = 8;
2140 /* Old-style RT frame and all non-RT frames:
2141 old signal mask (8 bytes)
2142 pointer to sigregs. */
2145 sigreg_ptr = read_memory_unsigned_integer (next_cfa + 8,
2146 word_size, byte_order);
2147 /* sigregs are followed by signo (4 bytes), then by the
2148 upper GPR halves if present. */
2149 sigreg_high_off = 4;
2152 /* The sigregs structure looks like this:
2161 /* PSW mask and address. */
2162 info->saved_regs[S390_PSWM_REGNUM].addr = sigreg_ptr;
2163 sigreg_ptr += word_size;
2164 info->saved_regs[S390_PSWA_REGNUM].addr = sigreg_ptr;
2165 sigreg_ptr += word_size;
2167 /* Then the GPRs. */
2168 for (i = 0; i < 16; i++)
2170 info->saved_regs[S390_R0_REGNUM + i].addr = sigreg_ptr;
2171 sigreg_ptr += word_size;
2174 /* Then the ACRs. */
2175 for (i = 0; i < 16; i++)
2177 info->saved_regs[S390_A0_REGNUM + i].addr = sigreg_ptr;
2181 /* The floating-point control word. */
2182 info->saved_regs[S390_FPC_REGNUM].addr = sigreg_ptr;
2185 /* And finally the FPRs. */
2186 for (i = 0; i < 16; i++)
2188 info->saved_regs[S390_F0_REGNUM + i].addr = sigreg_ptr;
2192 /* If we have them, the GPR upper halves are appended at the end. */
2193 sigreg_ptr += sigreg_high_off;
2194 if (tdep->gpr_full_regnum != -1)
2195 for (i = 0; i < 16; i++)
2197 info->saved_regs[S390_R0_UPPER_REGNUM + i].addr = sigreg_ptr;
2201 /* Restore the previous frame's SP. */
2202 prev_sp = read_memory_unsigned_integer (
2203 info->saved_regs[S390_SP_REGNUM].addr,
2204 word_size, byte_order);
2206 /* Determine our frame base. */
2207 info->frame_base = prev_sp + 16*word_size + 32;
2213 s390_sigtramp_frame_this_id (struct frame_info *this_frame,
2214 void **this_prologue_cache,
2215 struct frame_id *this_id)
2217 struct s390_sigtramp_unwind_cache *info
2218 = s390_sigtramp_frame_unwind_cache (this_frame, this_prologue_cache);
2219 *this_id = frame_id_build (info->frame_base, get_frame_pc (this_frame));
2222 static struct value *
2223 s390_sigtramp_frame_prev_register (struct frame_info *this_frame,
2224 void **this_prologue_cache, int regnum)
2226 struct s390_sigtramp_unwind_cache *info
2227 = s390_sigtramp_frame_unwind_cache (this_frame, this_prologue_cache);
2228 return s390_trad_frame_prev_register (this_frame, info->saved_regs, regnum);
2232 s390_sigtramp_frame_sniffer (const struct frame_unwind *self,
2233 struct frame_info *this_frame,
2234 void **this_prologue_cache)
2236 CORE_ADDR pc = get_frame_pc (this_frame);
2237 bfd_byte sigreturn[2];
2239 if (target_read_memory (pc, sigreturn, 2))
2242 if (sigreturn[0] != op_svc)
2245 if (sigreturn[1] != 119 /* sigreturn */
2246 && sigreturn[1] != 173 /* rt_sigreturn */)
2252 static const struct frame_unwind s390_sigtramp_frame_unwind = {
2254 default_frame_unwind_stop_reason,
2255 s390_sigtramp_frame_this_id,
2256 s390_sigtramp_frame_prev_register,
2258 s390_sigtramp_frame_sniffer
2261 /* Retrieve the syscall number at a ptrace syscall-stop. Return -1
2265 s390_linux_get_syscall_number (struct gdbarch *gdbarch,
2268 struct regcache *regs = get_thread_regcache (ptid);
2269 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2270 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2272 ULONGEST svc_number = -1;
2275 /* Assume that the PC points after the 2-byte SVC instruction. We
2276 don't currently support SVC via EXECUTE. */
2277 regcache_cooked_read_unsigned (regs, tdep->pc_regnum, &pc);
2279 opcode = read_memory_unsigned_integer ((CORE_ADDR) pc, 1, byte_order);
2280 if (opcode != op_svc)
2283 svc_number = read_memory_unsigned_integer ((CORE_ADDR) pc + 1, 1,
2285 if (svc_number == 0)
2286 regcache_cooked_read_unsigned (regs, S390_R1_REGNUM, &svc_number);
2292 /* Frame base handling. */
2295 s390_frame_base_address (struct frame_info *this_frame, void **this_cache)
2297 struct s390_unwind_cache *info
2298 = s390_frame_unwind_cache (this_frame, this_cache);
2299 return info->frame_base;
2303 s390_local_base_address (struct frame_info *this_frame, void **this_cache)
2305 struct s390_unwind_cache *info
2306 = s390_frame_unwind_cache (this_frame, this_cache);
2307 return info->local_base;
2310 static const struct frame_base s390_frame_base = {
2312 s390_frame_base_address,
2313 s390_local_base_address,
2314 s390_local_base_address
2318 s390_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
2320 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2322 pc = frame_unwind_register_unsigned (next_frame, tdep->pc_regnum);
2323 return gdbarch_addr_bits_remove (gdbarch, pc);
2327 s390_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
2330 sp = frame_unwind_register_unsigned (next_frame, S390_SP_REGNUM);
2331 return gdbarch_addr_bits_remove (gdbarch, sp);
2335 /* DWARF-2 frame support. */
2337 static struct value *
2338 s390_dwarf2_prev_register (struct frame_info *this_frame, void **this_cache,
2341 return s390_unwind_pseudo_register (this_frame, regnum);
2345 s390_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
2346 struct dwarf2_frame_state_reg *reg,
2347 struct frame_info *this_frame)
2349 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2351 /* The condition code (and thus PSW mask) is call-clobbered. */
2352 if (regnum == S390_PSWM_REGNUM)
2353 reg->how = DWARF2_FRAME_REG_UNDEFINED;
2355 /* The PSW address unwinds to the return address. */
2356 else if (regnum == S390_PSWA_REGNUM)
2357 reg->how = DWARF2_FRAME_REG_RA;
2359 /* Fixed registers are call-saved or call-clobbered
2360 depending on the ABI in use. */
2361 else if (regnum < S390_NUM_REGS)
2363 if (s390_register_call_saved (gdbarch, regnum))
2364 reg->how = DWARF2_FRAME_REG_SAME_VALUE;
2366 reg->how = DWARF2_FRAME_REG_UNDEFINED;
2369 /* We install a special function to unwind pseudos. */
2372 reg->how = DWARF2_FRAME_REG_FN;
2373 reg->loc.fn = s390_dwarf2_prev_register;
2378 /* Dummy function calls. */
2380 /* Return non-zero if TYPE is an integer-like type, zero otherwise.
2381 "Integer-like" types are those that should be passed the way
2382 integers are: integers, enums, ranges, characters, and booleans. */
2384 is_integer_like (struct type *type)
2386 enum type_code code = TYPE_CODE (type);
2388 return (code == TYPE_CODE_INT
2389 || code == TYPE_CODE_ENUM
2390 || code == TYPE_CODE_RANGE
2391 || code == TYPE_CODE_CHAR
2392 || code == TYPE_CODE_BOOL);
2395 /* Return non-zero if TYPE is a pointer-like type, zero otherwise.
2396 "Pointer-like" types are those that should be passed the way
2397 pointers are: pointers and references. */
2399 is_pointer_like (struct type *type)
2401 enum type_code code = TYPE_CODE (type);
2403 return (code == TYPE_CODE_PTR
2404 || code == TYPE_CODE_REF);
2408 /* Return non-zero if TYPE is a `float singleton' or `double
2409 singleton', zero otherwise.
2411 A `T singleton' is a struct type with one member, whose type is
2412 either T or a `T singleton'. So, the following are all float
2416 struct { struct { float x; } x; };
2417 struct { struct { struct { float x; } x; } x; };
2421 All such structures are passed as if they were floats or doubles,
2422 as the (revised) ABI says. */
2424 is_float_singleton (struct type *type)
2426 if (TYPE_CODE (type) == TYPE_CODE_STRUCT && TYPE_NFIELDS (type) == 1)
2428 struct type *singleton_type = TYPE_FIELD_TYPE (type, 0);
2429 CHECK_TYPEDEF (singleton_type);
2431 return (TYPE_CODE (singleton_type) == TYPE_CODE_FLT
2432 || TYPE_CODE (singleton_type) == TYPE_CODE_DECFLOAT
2433 || is_float_singleton (singleton_type));
2440 /* Return non-zero if TYPE is a struct-like type, zero otherwise.
2441 "Struct-like" types are those that should be passed as structs are:
2444 As an odd quirk, not mentioned in the ABI, GCC passes float and
2445 double singletons as if they were a plain float, double, etc. (The
2446 corresponding union types are handled normally.) So we exclude
2447 those types here. *shrug* */
2449 is_struct_like (struct type *type)
2451 enum type_code code = TYPE_CODE (type);
2453 return (code == TYPE_CODE_UNION
2454 || (code == TYPE_CODE_STRUCT && ! is_float_singleton (type)));
2458 /* Return non-zero if TYPE is a float-like type, zero otherwise.
2459 "Float-like" types are those that should be passed as
2460 floating-point values are.
2462 You'd think this would just be floats, doubles, long doubles, etc.
2463 But as an odd quirk, not mentioned in the ABI, GCC passes float and
2464 double singletons as if they were a plain float, double, etc. (The
2465 corresponding union types are handled normally.) So we include
2466 those types here. *shrug* */
2468 is_float_like (struct type *type)
2470 return (TYPE_CODE (type) == TYPE_CODE_FLT
2471 || TYPE_CODE (type) == TYPE_CODE_DECFLOAT
2472 || is_float_singleton (type));
2477 is_power_of_two (unsigned int n)
2479 return ((n & (n - 1)) == 0);
2482 /* Return non-zero if TYPE should be passed as a pointer to a copy,
2485 s390_function_arg_pass_by_reference (struct type *type)
2487 if (TYPE_LENGTH (type) > 8)
2490 return (is_struct_like (type) && !is_power_of_two (TYPE_LENGTH (type)))
2491 || TYPE_CODE (type) == TYPE_CODE_COMPLEX
2492 || (TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type));
2495 /* Return non-zero if TYPE should be passed in a float register
2498 s390_function_arg_float (struct type *type)
2500 if (TYPE_LENGTH (type) > 8)
2503 return is_float_like (type);
2506 /* Return non-zero if TYPE should be passed in an integer register
2507 (or a pair of integer registers) if possible. */
2509 s390_function_arg_integer (struct type *type)
2511 if (TYPE_LENGTH (type) > 8)
2514 return is_integer_like (type)
2515 || is_pointer_like (type)
2516 || (is_struct_like (type) && is_power_of_two (TYPE_LENGTH (type)));
2519 /* Return ARG, a `SIMPLE_ARG', sign-extended or zero-extended to a full
2520 word as required for the ABI. */
2522 extend_simple_arg (struct gdbarch *gdbarch, struct value *arg)
2524 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2525 struct type *type = check_typedef (value_type (arg));
2527 /* Even structs get passed in the least significant bits of the
2528 register / memory word. It's not really right to extract them as
2529 an integer, but it does take care of the extension. */
2530 if (TYPE_UNSIGNED (type))
2531 return extract_unsigned_integer (value_contents (arg),
2532 TYPE_LENGTH (type), byte_order);
2534 return extract_signed_integer (value_contents (arg),
2535 TYPE_LENGTH (type), byte_order);
2539 /* Return the alignment required by TYPE. */
2541 alignment_of (struct type *type)
2545 if (is_integer_like (type)
2546 || is_pointer_like (type)
2547 || TYPE_CODE (type) == TYPE_CODE_FLT
2548 || TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
2549 alignment = TYPE_LENGTH (type);
2550 else if (TYPE_CODE (type) == TYPE_CODE_STRUCT
2551 || TYPE_CODE (type) == TYPE_CODE_UNION)
2556 for (i = 0; i < TYPE_NFIELDS (type); i++)
2559 = alignment_of (check_typedef (TYPE_FIELD_TYPE (type, i)));
2561 if (field_alignment > alignment)
2562 alignment = field_alignment;
2568 /* Check that everything we ever return is a power of two. Lots of
2569 code doesn't want to deal with aligning things to arbitrary
2571 gdb_assert ((alignment & (alignment - 1)) == 0);
2577 /* Put the actual parameter values pointed to by ARGS[0..NARGS-1] in
2578 place to be passed to a function, as specified by the "GNU/Linux
2579 for S/390 ELF Application Binary Interface Supplement".
2581 SP is the current stack pointer. We must put arguments, links,
2582 padding, etc. whereever they belong, and return the new stack
2585 If STRUCT_RETURN is non-zero, then the function we're calling is
2586 going to return a structure by value; STRUCT_ADDR is the address of
2587 a block we've allocated for it on the stack.
2589 Our caller has taken care of any type promotions needed to satisfy
2590 prototypes or the old K&R argument-passing rules. */
2592 s390_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
2593 struct regcache *regcache, CORE_ADDR bp_addr,
2594 int nargs, struct value **args, CORE_ADDR sp,
2595 int struct_return, CORE_ADDR struct_addr)
2597 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2598 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
2599 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2602 /* If the i'th argument is passed as a reference to a copy, then
2603 copy_addr[i] is the address of the copy we made. */
2604 CORE_ADDR *copy_addr = alloca (nargs * sizeof (CORE_ADDR));
2606 /* Reserve space for the reference-to-copy area. */
2607 for (i = 0; i < nargs; i++)
2609 struct value *arg = args[i];
2610 struct type *type = check_typedef (value_type (arg));
2612 if (s390_function_arg_pass_by_reference (type))
2614 sp -= TYPE_LENGTH (type);
2615 sp = align_down (sp, alignment_of (type));
2620 /* Reserve space for the parameter area. As a conservative
2621 simplification, we assume that everything will be passed on the
2622 stack. Since every argument larger than 8 bytes will be
2623 passed by reference, we use this simple upper bound. */
2626 /* After all that, make sure it's still aligned on an eight-byte
2628 sp = align_down (sp, 8);
2630 /* Allocate the standard frame areas: the register save area, the
2631 word reserved for the compiler (which seems kind of meaningless),
2632 and the back chain pointer. */
2633 sp -= 16*word_size + 32;
2635 /* Now we have the final SP value. Make sure we didn't underflow;
2636 on 31-bit, this would result in addresses with the high bit set,
2637 which causes confusion elsewhere. Note that if we error out
2638 here, stack and registers remain untouched. */
2639 if (gdbarch_addr_bits_remove (gdbarch, sp) != sp)
2640 error (_("Stack overflow"));
2643 /* Finally, place the actual parameters, working from SP towards
2644 higher addresses. The code above is supposed to reserve enough
2649 CORE_ADDR starg = sp + 16*word_size + 32;
2651 /* A struct is returned using general register 2. */
2654 regcache_cooked_write_unsigned (regcache, S390_R0_REGNUM + gr,
2659 for (i = 0; i < nargs; i++)
2661 struct value *arg = args[i];
2662 struct type *type = check_typedef (value_type (arg));
2663 unsigned length = TYPE_LENGTH (type);
2665 if (s390_function_arg_pass_by_reference (type))
2667 /* Actually copy the argument contents to the stack slot
2668 that was reserved above. */
2669 write_memory (copy_addr[i], value_contents (arg), length);
2673 regcache_cooked_write_unsigned (regcache, S390_R0_REGNUM + gr,
2679 write_memory_unsigned_integer (starg, word_size, byte_order,
2684 else if (s390_function_arg_float (type))
2686 /* The GNU/Linux for S/390 ABI uses FPRs 0 and 2 to pass arguments,
2687 the GNU/Linux for zSeries ABI uses 0, 2, 4, and 6. */
2688 if (fr <= (tdep->abi == ABI_LINUX_S390 ? 2 : 6))
2690 /* When we store a single-precision value in an FP register,
2691 it occupies the leftmost bits. */
2692 regcache_cooked_write_part (regcache, S390_F0_REGNUM + fr,
2693 0, length, value_contents (arg));
2698 /* When we store a single-precision value in a stack slot,
2699 it occupies the rightmost bits. */
2700 starg = align_up (starg + length, word_size);
2701 write_memory (starg - length, value_contents (arg), length);
2704 else if (s390_function_arg_integer (type) && length <= word_size)
2708 /* Integer arguments are always extended to word size. */
2709 regcache_cooked_write_signed (regcache, S390_R0_REGNUM + gr,
2710 extend_simple_arg (gdbarch,
2716 /* Integer arguments are always extended to word size. */
2717 write_memory_signed_integer (starg, word_size, byte_order,
2718 extend_simple_arg (gdbarch, arg));
2722 else if (s390_function_arg_integer (type) && length == 2*word_size)
2726 regcache_cooked_write (regcache, S390_R0_REGNUM + gr,
2727 value_contents (arg));
2728 regcache_cooked_write (regcache, S390_R0_REGNUM + gr + 1,
2729 value_contents (arg) + word_size);
2734 /* If we skipped r6 because we couldn't fit a DOUBLE_ARG
2735 in it, then don't go back and use it again later. */
2738 write_memory (starg, value_contents (arg), length);
2743 internal_error (__FILE__, __LINE__, _("unknown argument type"));
2747 /* Store return PSWA. In 31-bit mode, keep addressing mode bit. */
2751 regcache_cooked_read_unsigned (regcache, S390_PSWA_REGNUM, &pswa);
2752 bp_addr = (bp_addr & 0x7fffffff) | (pswa & 0x80000000);
2754 regcache_cooked_write_unsigned (regcache, S390_RETADDR_REGNUM, bp_addr);
2756 /* Store updated stack pointer. */
2757 regcache_cooked_write_unsigned (regcache, S390_SP_REGNUM, sp);
2759 /* We need to return the 'stack part' of the frame ID,
2760 which is actually the top of the register save area. */
2761 return sp + 16*word_size + 32;
2764 /* Assuming THIS_FRAME is a dummy, return the frame ID of that
2765 dummy frame. The frame ID's base needs to match the TOS value
2766 returned by push_dummy_call, and the PC match the dummy frame's
2768 static struct frame_id
2769 s390_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
2771 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
2772 CORE_ADDR sp = get_frame_register_unsigned (this_frame, S390_SP_REGNUM);
2773 sp = gdbarch_addr_bits_remove (gdbarch, sp);
2775 return frame_id_build (sp + 16*word_size + 32,
2776 get_frame_pc (this_frame));
2780 s390_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
2782 /* Both the 32- and 64-bit ABI's say that the stack pointer should
2783 always be aligned on an eight-byte boundary. */
2788 /* Function return value access. */
2790 static enum return_value_convention
2791 s390_return_value_convention (struct gdbarch *gdbarch, struct type *type)
2793 if (TYPE_LENGTH (type) > 8)
2794 return RETURN_VALUE_STRUCT_CONVENTION;
2796 switch (TYPE_CODE (type))
2798 case TYPE_CODE_STRUCT:
2799 case TYPE_CODE_UNION:
2800 case TYPE_CODE_ARRAY:
2801 case TYPE_CODE_COMPLEX:
2802 return RETURN_VALUE_STRUCT_CONVENTION;
2805 return RETURN_VALUE_REGISTER_CONVENTION;
2809 static enum return_value_convention
2810 s390_return_value (struct gdbarch *gdbarch, struct value *function,
2811 struct type *type, struct regcache *regcache,
2812 gdb_byte *out, const gdb_byte *in)
2814 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2815 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
2816 enum return_value_convention rvc;
2819 type = check_typedef (type);
2820 rvc = s390_return_value_convention (gdbarch, type);
2821 length = TYPE_LENGTH (type);
2827 case RETURN_VALUE_REGISTER_CONVENTION:
2828 if (TYPE_CODE (type) == TYPE_CODE_FLT
2829 || TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
2831 /* When we store a single-precision value in an FP register,
2832 it occupies the leftmost bits. */
2833 regcache_cooked_write_part (regcache, S390_F0_REGNUM,
2836 else if (length <= word_size)
2838 /* Integer arguments are always extended to word size. */
2839 if (TYPE_UNSIGNED (type))
2840 regcache_cooked_write_unsigned (regcache, S390_R2_REGNUM,
2841 extract_unsigned_integer (in, length, byte_order));
2843 regcache_cooked_write_signed (regcache, S390_R2_REGNUM,
2844 extract_signed_integer (in, length, byte_order));
2846 else if (length == 2*word_size)
2848 regcache_cooked_write (regcache, S390_R2_REGNUM, in);
2849 regcache_cooked_write (regcache, S390_R3_REGNUM, in + word_size);
2852 internal_error (__FILE__, __LINE__, _("invalid return type"));
2855 case RETURN_VALUE_STRUCT_CONVENTION:
2856 error (_("Cannot set function return value."));
2864 case RETURN_VALUE_REGISTER_CONVENTION:
2865 if (TYPE_CODE (type) == TYPE_CODE_FLT
2866 || TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
2868 /* When we store a single-precision value in an FP register,
2869 it occupies the leftmost bits. */
2870 regcache_cooked_read_part (regcache, S390_F0_REGNUM,
2873 else if (length <= word_size)
2875 /* Integer arguments occupy the rightmost bits. */
2876 regcache_cooked_read_part (regcache, S390_R2_REGNUM,
2877 word_size - length, length, out);
2879 else if (length == 2*word_size)
2881 regcache_cooked_read (regcache, S390_R2_REGNUM, out);
2882 regcache_cooked_read (regcache, S390_R3_REGNUM, out + word_size);
2885 internal_error (__FILE__, __LINE__, _("invalid return type"));
2888 case RETURN_VALUE_STRUCT_CONVENTION:
2889 error (_("Function return value unknown."));
2900 static const gdb_byte *
2901 s390_breakpoint_from_pc (struct gdbarch *gdbarch,
2902 CORE_ADDR *pcptr, int *lenptr)
2904 static const gdb_byte breakpoint[] = { 0x0, 0x1 };
2906 *lenptr = sizeof (breakpoint);
2911 /* Address handling. */
2914 s390_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr)
2916 return addr & 0x7fffffff;
2920 s390_address_class_type_flags (int byte_size, int dwarf2_addr_class)
2923 return TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1;
2929 s390_address_class_type_flags_to_name (struct gdbarch *gdbarch, int type_flags)
2931 if (type_flags & TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1)
2938 s390_address_class_name_to_type_flags (struct gdbarch *gdbarch,
2940 int *type_flags_ptr)
2942 if (strcmp (name, "mode32") == 0)
2944 *type_flags_ptr = TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1;
2951 /* Implement gdbarch_gcc_target_options. GCC does not know "-m32" or
2952 "-mcmodel=large". */
2955 s390_gcc_target_options (struct gdbarch *gdbarch)
2957 return xstrdup (gdbarch_ptr_bit (gdbarch) == 64 ? "-m64" : "-m31");
2960 /* Implement gdbarch_gnu_triplet_regexp. Target triplets are "s390-*"
2961 for 31-bit and "s390x-*" for 64-bit, while the BFD arch name is
2962 always "s390". Note that an s390x compiler supports "-m31" as
2966 s390_gnu_triplet_regexp (struct gdbarch *gdbarch)
2971 /* Implementation of `gdbarch_stap_is_single_operand', as defined in
2975 s390_stap_is_single_operand (struct gdbarch *gdbarch, const char *s)
2977 return ((isdigit (*s) && s[1] == '(' && s[2] == '%') /* Displacement
2979 || *s == '%' /* Register access. */
2980 || isdigit (*s)); /* Literal number. */
2983 /* Set up gdbarch struct. */
2985 static struct gdbarch *
2986 s390_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
2988 const struct target_desc *tdesc = info.target_desc;
2989 struct tdesc_arch_data *tdesc_data = NULL;
2990 struct gdbarch *gdbarch;
2991 struct gdbarch_tdep *tdep;
2994 int have_linux_v1 = 0;
2995 int have_linux_v2 = 0;
2998 int first_pseudo_reg, last_pseudo_reg;
2999 static const char *const stap_register_prefixes[] = { "%", NULL };
3000 static const char *const stap_register_indirection_prefixes[] = { "(",
3002 static const char *const stap_register_indirection_suffixes[] = { ")",
3005 /* Default ABI and register size. */
3006 switch (info.bfd_arch_info->mach)
3008 case bfd_mach_s390_31:
3009 tdep_abi = ABI_LINUX_S390;
3012 case bfd_mach_s390_64:
3013 tdep_abi = ABI_LINUX_ZSERIES;
3020 /* Use default target description if none provided by the target. */
3021 if (!tdesc_has_registers (tdesc))
3023 if (tdep_abi == ABI_LINUX_S390)
3024 tdesc = tdesc_s390_linux32;
3026 tdesc = tdesc_s390x_linux64;
3029 /* Check any target description for validity. */
3030 if (tdesc_has_registers (tdesc))
3032 static const char *const gprs[] = {
3033 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
3034 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
3036 static const char *const fprs[] = {
3037 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
3038 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15"
3040 static const char *const acrs[] = {
3041 "acr0", "acr1", "acr2", "acr3", "acr4", "acr5", "acr6", "acr7",
3042 "acr8", "acr9", "acr10", "acr11", "acr12", "acr13", "acr14", "acr15"
3044 static const char *const gprs_lower[] = {
3045 "r0l", "r1l", "r2l", "r3l", "r4l", "r5l", "r6l", "r7l",
3046 "r8l", "r9l", "r10l", "r11l", "r12l", "r13l", "r14l", "r15l"
3048 static const char *const gprs_upper[] = {
3049 "r0h", "r1h", "r2h", "r3h", "r4h", "r5h", "r6h", "r7h",
3050 "r8h", "r9h", "r10h", "r11h", "r12h", "r13h", "r14h", "r15h"
3052 static const char *const tdb_regs[] = {
3053 "tdb0", "tac", "tct", "atia",
3054 "tr0", "tr1", "tr2", "tr3", "tr4", "tr5", "tr6", "tr7",
3055 "tr8", "tr9", "tr10", "tr11", "tr12", "tr13", "tr14", "tr15"
3057 static const char *const vxrs_low[] = {
3058 "v0l", "v1l", "v2l", "v3l", "v4l", "v5l", "v6l", "v7l", "v8l",
3059 "v9l", "v10l", "v11l", "v12l", "v13l", "v14l", "v15l",
3061 static const char *const vxrs_high[] = {
3062 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23", "v24",
3063 "v25", "v26", "v27", "v28", "v29", "v30", "v31",
3065 const struct tdesc_feature *feature;
3068 feature = tdesc_find_feature (tdesc, "org.gnu.gdb.s390.core");
3069 if (feature == NULL)
3072 tdesc_data = tdesc_data_alloc ();
3074 valid_p &= tdesc_numbered_register (feature, tdesc_data,
3075 S390_PSWM_REGNUM, "pswm");
3076 valid_p &= tdesc_numbered_register (feature, tdesc_data,
3077 S390_PSWA_REGNUM, "pswa");
3079 if (tdesc_unnumbered_register (feature, "r0"))
3081 for (i = 0; i < 16; i++)
3082 valid_p &= tdesc_numbered_register (feature, tdesc_data,
3083 S390_R0_REGNUM + i, gprs[i]);
3089 for (i = 0; i < 16; i++)
3090 valid_p &= tdesc_numbered_register (feature, tdesc_data,
3093 for (i = 0; i < 16; i++)
3094 valid_p &= tdesc_numbered_register (feature, tdesc_data,
3095 S390_R0_UPPER_REGNUM + i,
3099 feature = tdesc_find_feature (tdesc, "org.gnu.gdb.s390.fpr");
3100 if (feature == NULL)
3102 tdesc_data_cleanup (tdesc_data);
3106 valid_p &= tdesc_numbered_register (feature, tdesc_data,
3107 S390_FPC_REGNUM, "fpc");
3108 for (i = 0; i < 16; i++)
3109 valid_p &= tdesc_numbered_register (feature, tdesc_data,
3110 S390_F0_REGNUM + i, fprs[i]);
3112 feature = tdesc_find_feature (tdesc, "org.gnu.gdb.s390.acr");
3113 if (feature == NULL)
3115 tdesc_data_cleanup (tdesc_data);
3119 for (i = 0; i < 16; i++)
3120 valid_p &= tdesc_numbered_register (feature, tdesc_data,
3121 S390_A0_REGNUM + i, acrs[i]);
3123 /* Optional GNU/Linux-specific "registers". */
3124 feature = tdesc_find_feature (tdesc, "org.gnu.gdb.s390.linux");
3127 tdesc_numbered_register (feature, tdesc_data,
3128 S390_ORIG_R2_REGNUM, "orig_r2");
3130 if (tdesc_numbered_register (feature, tdesc_data,
3131 S390_LAST_BREAK_REGNUM, "last_break"))
3134 if (tdesc_numbered_register (feature, tdesc_data,
3135 S390_SYSTEM_CALL_REGNUM, "system_call"))
3138 if (have_linux_v2 > have_linux_v1)
3142 /* Transaction diagnostic block. */
3143 feature = tdesc_find_feature (tdesc, "org.gnu.gdb.s390.tdb");
3146 for (i = 0; i < ARRAY_SIZE (tdb_regs); i++)
3147 valid_p &= tdesc_numbered_register (feature, tdesc_data,
3148 S390_TDB_DWORD0_REGNUM + i,
3153 /* Vector registers. */
3154 feature = tdesc_find_feature (tdesc, "org.gnu.gdb.s390.vx");
3157 for (i = 0; i < 16; i++)
3158 valid_p &= tdesc_numbered_register (feature, tdesc_data,
3159 S390_V0_LOWER_REGNUM + i,
3161 for (i = 0; i < 16; i++)
3162 valid_p &= tdesc_numbered_register (feature, tdesc_data,
3163 S390_V16_REGNUM + i,
3170 tdesc_data_cleanup (tdesc_data);
3175 /* Find a candidate among extant architectures. */
3176 for (arches = gdbarch_list_lookup_by_info (arches, &info);
3178 arches = gdbarch_list_lookup_by_info (arches->next, &info))
3180 tdep = gdbarch_tdep (arches->gdbarch);
3183 if (tdep->abi != tdep_abi)
3185 if ((tdep->gpr_full_regnum != -1) != have_upper)
3187 if (tdesc_data != NULL)
3188 tdesc_data_cleanup (tdesc_data);
3189 return arches->gdbarch;
3192 /* Otherwise create a new gdbarch for the specified machine type. */
3193 tdep = XCNEW (struct gdbarch_tdep);
3194 tdep->abi = tdep_abi;
3195 tdep->have_linux_v1 = have_linux_v1;
3196 tdep->have_linux_v2 = have_linux_v2;
3197 tdep->have_tdb = have_tdb;
3198 gdbarch = gdbarch_alloc (&info, tdep);
3200 set_gdbarch_believe_pcc_promotion (gdbarch, 0);
3201 set_gdbarch_char_signed (gdbarch, 0);
3203 /* S/390 GNU/Linux uses either 64-bit or 128-bit long doubles.
3204 We can safely let them default to 128-bit, since the debug info
3205 will give the size of type actually used in each case. */
3206 set_gdbarch_long_double_bit (gdbarch, 128);
3207 set_gdbarch_long_double_format (gdbarch, floatformats_ia64_quad);
3209 /* Amount PC must be decremented by after a breakpoint. This is
3210 often the number of bytes returned by gdbarch_breakpoint_from_pc but not
3212 set_gdbarch_decr_pc_after_break (gdbarch, 2);
3213 /* Stack grows downward. */
3214 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
3215 set_gdbarch_breakpoint_from_pc (gdbarch, s390_breakpoint_from_pc);
3216 set_gdbarch_skip_prologue (gdbarch, s390_skip_prologue);
3217 set_gdbarch_in_function_epilogue_p (gdbarch, s390_in_function_epilogue_p);
3219 set_gdbarch_num_regs (gdbarch, S390_NUM_REGS);
3220 set_gdbarch_sp_regnum (gdbarch, S390_SP_REGNUM);
3221 set_gdbarch_fp0_regnum (gdbarch, S390_F0_REGNUM);
3222 set_gdbarch_stab_reg_to_regnum (gdbarch, s390_dwarf_reg_to_regnum);
3223 set_gdbarch_dwarf2_reg_to_regnum (gdbarch, s390_dwarf_reg_to_regnum);
3224 set_gdbarch_value_from_register (gdbarch, s390_value_from_register);
3225 set_gdbarch_core_read_description (gdbarch, s390_core_read_description);
3226 set_gdbarch_iterate_over_regset_sections (gdbarch,
3227 s390_iterate_over_regset_sections);
3228 set_gdbarch_cannot_store_register (gdbarch, s390_cannot_store_register);
3229 set_gdbarch_write_pc (gdbarch, s390_write_pc);
3230 set_gdbarch_pseudo_register_read (gdbarch, s390_pseudo_register_read);
3231 set_gdbarch_pseudo_register_write (gdbarch, s390_pseudo_register_write);
3232 set_tdesc_pseudo_register_name (gdbarch, s390_pseudo_register_name);
3233 set_tdesc_pseudo_register_type (gdbarch, s390_pseudo_register_type);
3234 set_tdesc_pseudo_register_reggroup_p (gdbarch,
3235 s390_pseudo_register_reggroup_p);
3236 tdesc_use_registers (gdbarch, tdesc, tdesc_data);
3237 set_gdbarch_register_name (gdbarch, s390_register_name);
3239 /* Assign pseudo register numbers. */
3240 first_pseudo_reg = gdbarch_num_regs (gdbarch);
3241 last_pseudo_reg = first_pseudo_reg;
3242 tdep->gpr_full_regnum = -1;
3245 tdep->gpr_full_regnum = last_pseudo_reg;
3246 last_pseudo_reg += 16;
3248 tdep->v0_full_regnum = -1;
3251 tdep->v0_full_regnum = last_pseudo_reg;
3252 last_pseudo_reg += 16;
3254 tdep->pc_regnum = last_pseudo_reg++;
3255 tdep->cc_regnum = last_pseudo_reg++;
3256 set_gdbarch_pc_regnum (gdbarch, tdep->pc_regnum);
3257 set_gdbarch_num_pseudo_regs (gdbarch, last_pseudo_reg - first_pseudo_reg);
3259 /* Inferior function calls. */
3260 set_gdbarch_push_dummy_call (gdbarch, s390_push_dummy_call);
3261 set_gdbarch_dummy_id (gdbarch, s390_dummy_id);
3262 set_gdbarch_frame_align (gdbarch, s390_frame_align);
3263 set_gdbarch_return_value (gdbarch, s390_return_value);
3265 /* Syscall handling. */
3266 set_gdbarch_get_syscall_number (gdbarch, s390_linux_get_syscall_number);
3268 /* Frame handling. */
3269 dwarf2_frame_set_init_reg (gdbarch, s390_dwarf2_frame_init_reg);
3270 dwarf2_frame_set_adjust_regnum (gdbarch, s390_adjust_frame_regnum);
3271 dwarf2_append_unwinders (gdbarch);
3272 frame_base_append_sniffer (gdbarch, dwarf2_frame_base_sniffer);
3273 frame_unwind_append_unwinder (gdbarch, &s390_stub_frame_unwind);
3274 frame_unwind_append_unwinder (gdbarch, &s390_sigtramp_frame_unwind);
3275 frame_unwind_append_unwinder (gdbarch, &s390_frame_unwind);
3276 frame_base_set_default (gdbarch, &s390_frame_base);
3277 set_gdbarch_unwind_pc (gdbarch, s390_unwind_pc);
3278 set_gdbarch_unwind_sp (gdbarch, s390_unwind_sp);
3280 /* Displaced stepping. */
3281 set_gdbarch_displaced_step_copy_insn (gdbarch,
3282 simple_displaced_step_copy_insn);
3283 set_gdbarch_displaced_step_fixup (gdbarch, s390_displaced_step_fixup);
3284 set_gdbarch_displaced_step_free_closure (gdbarch,
3285 simple_displaced_step_free_closure);
3286 set_gdbarch_displaced_step_location (gdbarch,
3287 displaced_step_at_entry_point);
3288 set_gdbarch_max_insn_length (gdbarch, S390_MAX_INSTR_SIZE);
3290 /* Note that GNU/Linux is the only OS supported on this
3292 linux_init_abi (info, gdbarch);
3296 case ABI_LINUX_S390:
3297 set_gdbarch_addr_bits_remove (gdbarch, s390_addr_bits_remove);
3298 set_solib_svr4_fetch_link_map_offsets
3299 (gdbarch, svr4_ilp32_fetch_link_map_offsets);
3301 set_xml_syscall_file_name (gdbarch, XML_SYSCALL_FILENAME_S390);
3304 case ABI_LINUX_ZSERIES:
3305 set_gdbarch_long_bit (gdbarch, 64);
3306 set_gdbarch_long_long_bit (gdbarch, 64);
3307 set_gdbarch_ptr_bit (gdbarch, 64);
3308 set_solib_svr4_fetch_link_map_offsets
3309 (gdbarch, svr4_lp64_fetch_link_map_offsets);
3310 set_gdbarch_address_class_type_flags (gdbarch,
3311 s390_address_class_type_flags);
3312 set_gdbarch_address_class_type_flags_to_name (gdbarch,
3313 s390_address_class_type_flags_to_name);
3314 set_gdbarch_address_class_name_to_type_flags (gdbarch,
3315 s390_address_class_name_to_type_flags);
3316 set_xml_syscall_file_name (gdbarch, XML_SYSCALL_FILENAME_S390X);
3320 set_gdbarch_print_insn (gdbarch, print_insn_s390);
3322 set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
3324 /* Enable TLS support. */
3325 set_gdbarch_fetch_tls_load_module_address (gdbarch,
3326 svr4_fetch_objfile_link_map);
3328 set_gdbarch_get_siginfo_type (gdbarch, linux_get_siginfo_type);
3330 /* SystemTap functions. */
3331 set_gdbarch_stap_register_prefixes (gdbarch, stap_register_prefixes);
3332 set_gdbarch_stap_register_indirection_prefixes (gdbarch,
3333 stap_register_indirection_prefixes);
3334 set_gdbarch_stap_register_indirection_suffixes (gdbarch,
3335 stap_register_indirection_suffixes);
3336 set_gdbarch_stap_is_single_operand (gdbarch, s390_stap_is_single_operand);
3337 set_gdbarch_gcc_target_options (gdbarch, s390_gcc_target_options);
3338 set_gdbarch_gnu_triplet_regexp (gdbarch, s390_gnu_triplet_regexp);
3344 extern initialize_file_ftype _initialize_s390_tdep; /* -Wmissing-prototypes */
3347 _initialize_s390_tdep (void)
3349 /* Hook us into the gdbarch mechanism. */
3350 register_gdbarch_init (bfd_arch_s390, s390_gdbarch_init);
3352 /* Initialize the GNU/Linux target descriptions. */
3353 initialize_tdesc_s390_linux32 ();
3354 initialize_tdesc_s390_linux32v1 ();
3355 initialize_tdesc_s390_linux32v2 ();
3356 initialize_tdesc_s390_linux64 ();
3357 initialize_tdesc_s390_linux64v1 ();
3358 initialize_tdesc_s390_linux64v2 ();
3359 initialize_tdesc_s390_te_linux64 ();
3360 initialize_tdesc_s390_vx_linux64 ();
3361 initialize_tdesc_s390_tevx_linux64 ();
3362 initialize_tdesc_s390x_linux64 ();
3363 initialize_tdesc_s390x_linux64v1 ();
3364 initialize_tdesc_s390x_linux64v2 ();
3365 initialize_tdesc_s390x_te_linux64 ();
3366 initialize_tdesc_s390x_vx_linux64 ();
3367 initialize_tdesc_s390x_tevx_linux64 ();