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 the empty string for
273 registers that 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;
1465 CORE_ADDR skip_pc, func_addr;
1467 if (find_pc_partial_function (pc, NULL, &func_addr, NULL))
1469 CORE_ADDR post_prologue_pc
1470 = skip_prologue_using_sal (gdbarch, func_addr);
1471 if (post_prologue_pc != 0)
1472 return max (pc, post_prologue_pc);
1475 skip_pc = s390_analyze_prologue (gdbarch, pc, (CORE_ADDR)-1, &data);
1476 return skip_pc ? skip_pc : pc;
1479 /* Return true if we are in the functin's epilogue, i.e. after the
1480 instruction that destroyed the function's stack frame. */
1482 s390_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
1484 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1486 /* In frameless functions, there's not frame to destroy and thus
1487 we don't care about the epilogue.
1489 In functions with frame, the epilogue sequence is a pair of
1490 a LM-type instruction that restores (amongst others) the
1491 return register %r14 and the stack pointer %r15, followed
1492 by a branch 'br %r14' --or equivalent-- that effects the
1495 In that situation, this function needs to return 'true' in
1496 exactly one case: when pc points to that branch instruction.
1498 Thus we try to disassemble the one instructions immediately
1499 preceding pc and check whether it is an LM-type instruction
1500 modifying the stack pointer.
1502 Note that disassembling backwards is not reliable, so there
1503 is a slight chance of false positives here ... */
1506 unsigned int r1, r3, b2;
1510 && !target_read_memory (pc - 4, insn, 4)
1511 && is_rs (insn, op_lm, &r1, &r3, &d2, &b2)
1512 && r3 == S390_SP_REGNUM - S390_R0_REGNUM)
1516 && !target_read_memory (pc - 6, insn, 6)
1517 && is_rsy (insn, op1_lmy, op2_lmy, &r1, &r3, &d2, &b2)
1518 && r3 == S390_SP_REGNUM - S390_R0_REGNUM)
1522 && !target_read_memory (pc - 6, insn, 6)
1523 && is_rsy (insn, op1_lmg, op2_lmg, &r1, &r3, &d2, &b2)
1524 && r3 == S390_SP_REGNUM - S390_R0_REGNUM)
1530 /* Displaced stepping. */
1532 /* Fix up the state of registers and memory after having single-stepped
1533 a displaced instruction. */
1535 s390_displaced_step_fixup (struct gdbarch *gdbarch,
1536 struct displaced_step_closure *closure,
1537 CORE_ADDR from, CORE_ADDR to,
1538 struct regcache *regs)
1540 /* Since we use simple_displaced_step_copy_insn, our closure is a
1541 copy of the instruction. */
1542 gdb_byte *insn = (gdb_byte *) closure;
1543 static int s390_instrlen[] = { 2, 4, 4, 6 };
1544 int insnlen = s390_instrlen[insn[0] >> 6];
1546 /* Fields for various kinds of instructions. */
1547 unsigned int b2, r1, r2, x2, r3;
1550 /* Get current PC and addressing mode bit. */
1551 CORE_ADDR pc = regcache_read_pc (regs);
1554 if (register_size (gdbarch, S390_PSWA_REGNUM) == 4)
1556 regcache_cooked_read_unsigned (regs, S390_PSWA_REGNUM, &amode);
1557 amode &= 0x80000000;
1560 if (debug_displaced)
1561 fprintf_unfiltered (gdb_stdlog,
1562 "displaced: (s390) fixup (%s, %s) pc %s len %d amode 0x%x\n",
1563 paddress (gdbarch, from), paddress (gdbarch, to),
1564 paddress (gdbarch, pc), insnlen, (int) amode);
1566 /* Handle absolute branch and save instructions. */
1567 if (is_rr (insn, op_basr, &r1, &r2)
1568 || is_rx (insn, op_bas, &r1, &d2, &x2, &b2))
1570 /* Recompute saved return address in R1. */
1571 regcache_cooked_write_unsigned (regs, S390_R0_REGNUM + r1,
1572 amode | (from + insnlen));
1575 /* Handle absolute branch instructions. */
1576 else if (is_rr (insn, op_bcr, &r1, &r2)
1577 || is_rx (insn, op_bc, &r1, &d2, &x2, &b2)
1578 || is_rr (insn, op_bctr, &r1, &r2)
1579 || is_rre (insn, op_bctgr, &r1, &r2)
1580 || is_rx (insn, op_bct, &r1, &d2, &x2, &b2)
1581 || is_rxy (insn, op1_bctg, op2_brctg, &r1, &d2, &x2, &b2)
1582 || is_rs (insn, op_bxh, &r1, &r3, &d2, &b2)
1583 || is_rsy (insn, op1_bxhg, op2_bxhg, &r1, &r3, &d2, &b2)
1584 || is_rs (insn, op_bxle, &r1, &r3, &d2, &b2)
1585 || is_rsy (insn, op1_bxleg, op2_bxleg, &r1, &r3, &d2, &b2))
1587 /* Update PC iff branch was *not* taken. */
1588 if (pc == to + insnlen)
1589 regcache_write_pc (regs, from + insnlen);
1592 /* Handle PC-relative branch and save instructions. */
1593 else if (is_ri (insn, op1_bras, op2_bras, &r1, &i2)
1594 || is_ril (insn, op1_brasl, op2_brasl, &r1, &i2))
1597 regcache_write_pc (regs, pc - to + from);
1598 /* Recompute saved return address in R1. */
1599 regcache_cooked_write_unsigned (regs, S390_R0_REGNUM + r1,
1600 amode | (from + insnlen));
1603 /* Handle PC-relative branch instructions. */
1604 else if (is_ri (insn, op1_brc, op2_brc, &r1, &i2)
1605 || is_ril (insn, op1_brcl, op2_brcl, &r1, &i2)
1606 || is_ri (insn, op1_brct, op2_brct, &r1, &i2)
1607 || is_ri (insn, op1_brctg, op2_brctg, &r1, &i2)
1608 || is_rsi (insn, op_brxh, &r1, &r3, &i2)
1609 || is_rie (insn, op1_brxhg, op2_brxhg, &r1, &r3, &i2)
1610 || is_rsi (insn, op_brxle, &r1, &r3, &i2)
1611 || is_rie (insn, op1_brxlg, op2_brxlg, &r1, &r3, &i2))
1614 regcache_write_pc (regs, pc - to + from);
1617 /* Handle LOAD ADDRESS RELATIVE LONG. */
1618 else if (is_ril (insn, op1_larl, op2_larl, &r1, &i2))
1621 regcache_write_pc (regs, from + insnlen);
1622 /* Recompute output address in R1. */
1623 regcache_cooked_write_unsigned (regs, S390_R0_REGNUM + r1,
1624 amode | (from + i2 * 2));
1627 /* If we executed a breakpoint instruction, point PC right back at it. */
1628 else if (insn[0] == 0x0 && insn[1] == 0x1)
1629 regcache_write_pc (regs, from);
1631 /* For any other insn, PC points right after the original instruction. */
1633 regcache_write_pc (regs, from + insnlen);
1635 if (debug_displaced)
1636 fprintf_unfiltered (gdb_stdlog,
1637 "displaced: (s390) pc is now %s\n",
1638 paddress (gdbarch, regcache_read_pc (regs)));
1642 /* Helper routine to unwind pseudo registers. */
1644 static struct value *
1645 s390_unwind_pseudo_register (struct frame_info *this_frame, int regnum)
1647 struct gdbarch *gdbarch = get_frame_arch (this_frame);
1648 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1649 struct type *type = register_type (gdbarch, regnum);
1651 /* Unwind PC via PSW address. */
1652 if (regnum == tdep->pc_regnum)
1656 val = frame_unwind_register_value (this_frame, S390_PSWA_REGNUM);
1657 if (!value_optimized_out (val))
1659 LONGEST pswa = value_as_long (val);
1661 if (TYPE_LENGTH (type) == 4)
1662 return value_from_pointer (type, pswa & 0x7fffffff);
1664 return value_from_pointer (type, pswa);
1668 /* Unwind CC via PSW mask. */
1669 if (regnum == tdep->cc_regnum)
1673 val = frame_unwind_register_value (this_frame, S390_PSWM_REGNUM);
1674 if (!value_optimized_out (val))
1676 LONGEST pswm = value_as_long (val);
1678 if (TYPE_LENGTH (type) == 4)
1679 return value_from_longest (type, (pswm >> 12) & 3);
1681 return value_from_longest (type, (pswm >> 44) & 3);
1685 /* Unwind full GPRs to show at least the lower halves (as the
1686 upper halves are undefined). */
1687 if (regnum_is_gpr_full (tdep, regnum))
1689 int reg = regnum - tdep->gpr_full_regnum;
1692 val = frame_unwind_register_value (this_frame, S390_R0_REGNUM + reg);
1693 if (!value_optimized_out (val))
1694 return value_cast (type, val);
1697 return allocate_optimized_out_value (type);
1700 static struct value *
1701 s390_trad_frame_prev_register (struct frame_info *this_frame,
1702 struct trad_frame_saved_reg saved_regs[],
1705 if (regnum < S390_NUM_REGS)
1706 return trad_frame_get_prev_register (this_frame, saved_regs, regnum);
1708 return s390_unwind_pseudo_register (this_frame, regnum);
1712 /* Normal stack frames. */
1714 struct s390_unwind_cache {
1717 CORE_ADDR frame_base;
1718 CORE_ADDR local_base;
1720 struct trad_frame_saved_reg *saved_regs;
1724 s390_prologue_frame_unwind_cache (struct frame_info *this_frame,
1725 struct s390_unwind_cache *info)
1727 struct gdbarch *gdbarch = get_frame_arch (this_frame);
1728 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1729 struct s390_prologue_data data;
1730 pv_t *fp = &data.gpr[S390_FRAME_REGNUM - S390_R0_REGNUM];
1731 pv_t *sp = &data.gpr[S390_SP_REGNUM - S390_R0_REGNUM];
1740 struct frame_info *next_frame;
1742 /* Try to find the function start address. If we can't find it, we don't
1743 bother searching for it -- with modern compilers this would be mostly
1744 pointless anyway. Trust that we'll either have valid DWARF-2 CFI data
1745 or else a valid backchain ... */
1746 func = get_frame_func (this_frame);
1750 /* Try to analyze the prologue. */
1751 result = s390_analyze_prologue (gdbarch, func,
1752 get_frame_pc (this_frame), &data);
1756 /* If this was successful, we should have found the instruction that
1757 sets the stack pointer register to the previous value of the stack
1758 pointer minus the frame size. */
1759 if (!pv_is_register (*sp, S390_SP_REGNUM))
1762 /* A frame size of zero at this point can mean either a real
1763 frameless function, or else a failure to find the prologue.
1764 Perform some sanity checks to verify we really have a
1765 frameless function. */
1768 /* If the next frame is a NORMAL_FRAME, this frame *cannot* have frame
1769 size zero. This is only possible if the next frame is a sentinel
1770 frame, a dummy frame, or a signal trampoline frame. */
1771 /* FIXME: cagney/2004-05-01: This sanity check shouldn't be
1772 needed, instead the code should simpliy rely on its
1774 next_frame = get_next_frame (this_frame);
1775 while (next_frame && get_frame_type (next_frame) == INLINE_FRAME)
1776 next_frame = get_next_frame (next_frame);
1778 && get_frame_type (get_next_frame (this_frame)) == NORMAL_FRAME)
1781 /* If we really have a frameless function, %r14 must be valid
1782 -- in particular, it must point to a different function. */
1783 reg = get_frame_register_unsigned (this_frame, S390_RETADDR_REGNUM);
1784 reg = gdbarch_addr_bits_remove (gdbarch, reg) - 1;
1785 if (get_pc_function_start (reg) == func)
1787 /* However, there is one case where it *is* valid for %r14
1788 to point to the same function -- if this is a recursive
1789 call, and we have stopped in the prologue *before* the
1790 stack frame was allocated.
1792 Recognize this case by looking ahead a bit ... */
1794 struct s390_prologue_data data2;
1795 pv_t *sp = &data2.gpr[S390_SP_REGNUM - S390_R0_REGNUM];
1797 if (!(s390_analyze_prologue (gdbarch, func, (CORE_ADDR)-1, &data2)
1798 && pv_is_register (*sp, S390_SP_REGNUM)
1805 /* OK, we've found valid prologue data. */
1808 /* If the frame pointer originally also holds the same value
1809 as the stack pointer, we're probably using it. If it holds
1810 some other value -- even a constant offset -- it is most
1811 likely used as temp register. */
1812 if (pv_is_identical (*sp, *fp))
1813 frame_pointer = S390_FRAME_REGNUM;
1815 frame_pointer = S390_SP_REGNUM;
1817 /* If we've detected a function with stack frame, we'll still have to
1818 treat it as frameless if we're currently within the function epilog
1819 code at a point where the frame pointer has already been restored.
1820 This can only happen in an innermost frame. */
1821 /* FIXME: cagney/2004-05-01: This sanity check shouldn't be needed,
1822 instead the code should simpliy rely on its analysis. */
1823 next_frame = get_next_frame (this_frame);
1824 while (next_frame && get_frame_type (next_frame) == INLINE_FRAME)
1825 next_frame = get_next_frame (next_frame);
1827 && (next_frame == NULL
1828 || get_frame_type (get_next_frame (this_frame)) != NORMAL_FRAME))
1830 /* See the comment in s390_in_function_epilogue_p on why this is
1831 not completely reliable ... */
1832 if (s390_in_function_epilogue_p (gdbarch, get_frame_pc (this_frame)))
1834 memset (&data, 0, sizeof (data));
1836 frame_pointer = S390_SP_REGNUM;
1840 /* Once we know the frame register and the frame size, we can unwind
1841 the current value of the frame register from the next frame, and
1842 add back the frame size to arrive that the previous frame's
1843 stack pointer value. */
1844 prev_sp = get_frame_register_unsigned (this_frame, frame_pointer) + size;
1845 cfa = prev_sp + 16*word_size + 32;
1847 /* Set up ABI call-saved/call-clobbered registers. */
1848 for (i = 0; i < S390_NUM_REGS; i++)
1849 if (!s390_register_call_saved (gdbarch, i))
1850 trad_frame_set_unknown (info->saved_regs, i);
1852 /* CC is always call-clobbered. */
1853 trad_frame_set_unknown (info->saved_regs, S390_PSWM_REGNUM);
1855 /* Record the addresses of all register spill slots the prologue parser
1856 has recognized. Consider only registers defined as call-saved by the
1857 ABI; for call-clobbered registers the parser may have recognized
1860 for (i = 0; i < 16; i++)
1861 if (s390_register_call_saved (gdbarch, S390_R0_REGNUM + i)
1862 && data.gpr_slot[i] != 0)
1863 info->saved_regs[S390_R0_REGNUM + i].addr = cfa - data.gpr_slot[i];
1865 for (i = 0; i < 16; i++)
1866 if (s390_register_call_saved (gdbarch, S390_F0_REGNUM + i)
1867 && data.fpr_slot[i] != 0)
1868 info->saved_regs[S390_F0_REGNUM + i].addr = cfa - data.fpr_slot[i];
1870 /* Function return will set PC to %r14. */
1871 info->saved_regs[S390_PSWA_REGNUM] = info->saved_regs[S390_RETADDR_REGNUM];
1873 /* In frameless functions, we unwind simply by moving the return
1874 address to the PC. However, if we actually stored to the
1875 save area, use that -- we might only think the function frameless
1876 because we're in the middle of the prologue ... */
1878 && !trad_frame_addr_p (info->saved_regs, S390_PSWA_REGNUM))
1880 info->saved_regs[S390_PSWA_REGNUM].realreg = S390_RETADDR_REGNUM;
1883 /* Another sanity check: unless this is a frameless function,
1884 we should have found spill slots for SP and PC.
1885 If not, we cannot unwind further -- this happens e.g. in
1886 libc's thread_start routine. */
1889 if (!trad_frame_addr_p (info->saved_regs, S390_SP_REGNUM)
1890 || !trad_frame_addr_p (info->saved_regs, S390_PSWA_REGNUM))
1894 /* We use the current value of the frame register as local_base,
1895 and the top of the register save area as frame_base. */
1898 info->frame_base = prev_sp + 16*word_size + 32;
1899 info->local_base = prev_sp - size;
1907 s390_backchain_frame_unwind_cache (struct frame_info *this_frame,
1908 struct s390_unwind_cache *info)
1910 struct gdbarch *gdbarch = get_frame_arch (this_frame);
1911 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1912 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1913 CORE_ADDR backchain;
1918 /* Set up ABI call-saved/call-clobbered registers. */
1919 for (i = 0; i < S390_NUM_REGS; i++)
1920 if (!s390_register_call_saved (gdbarch, i))
1921 trad_frame_set_unknown (info->saved_regs, i);
1923 /* CC is always call-clobbered. */
1924 trad_frame_set_unknown (info->saved_regs, S390_PSWM_REGNUM);
1926 /* Get the backchain. */
1927 reg = get_frame_register_unsigned (this_frame, S390_SP_REGNUM);
1928 backchain = read_memory_unsigned_integer (reg, word_size, byte_order);
1930 /* A zero backchain terminates the frame chain. As additional
1931 sanity check, let's verify that the spill slot for SP in the
1932 save area pointed to by the backchain in fact links back to
1935 && safe_read_memory_integer (backchain + 15*word_size,
1936 word_size, byte_order, &sp)
1937 && (CORE_ADDR)sp == backchain)
1939 /* We don't know which registers were saved, but it will have
1940 to be at least %r14 and %r15. This will allow us to continue
1941 unwinding, but other prev-frame registers may be incorrect ... */
1942 info->saved_regs[S390_SP_REGNUM].addr = backchain + 15*word_size;
1943 info->saved_regs[S390_RETADDR_REGNUM].addr = backchain + 14*word_size;
1945 /* Function return will set PC to %r14. */
1946 info->saved_regs[S390_PSWA_REGNUM]
1947 = info->saved_regs[S390_RETADDR_REGNUM];
1949 /* We use the current value of the frame register as local_base,
1950 and the top of the register save area as frame_base. */
1951 info->frame_base = backchain + 16*word_size + 32;
1952 info->local_base = reg;
1955 info->func = get_frame_pc (this_frame);
1958 static struct s390_unwind_cache *
1959 s390_frame_unwind_cache (struct frame_info *this_frame,
1960 void **this_prologue_cache)
1962 struct s390_unwind_cache *info;
1964 if (*this_prologue_cache)
1965 return *this_prologue_cache;
1967 info = FRAME_OBSTACK_ZALLOC (struct s390_unwind_cache);
1968 *this_prologue_cache = info;
1969 info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
1971 info->frame_base = -1;
1972 info->local_base = -1;
1976 /* Try to use prologue analysis to fill the unwind cache.
1977 If this fails, fall back to reading the stack backchain. */
1978 if (!s390_prologue_frame_unwind_cache (this_frame, info))
1979 s390_backchain_frame_unwind_cache (this_frame, info);
1981 CATCH (ex, RETURN_MASK_ERROR)
1983 if (ex.error != NOT_AVAILABLE_ERROR)
1984 throw_exception (ex);
1992 s390_frame_this_id (struct frame_info *this_frame,
1993 void **this_prologue_cache,
1994 struct frame_id *this_id)
1996 struct s390_unwind_cache *info
1997 = s390_frame_unwind_cache (this_frame, this_prologue_cache);
1999 if (info->frame_base == -1)
2002 *this_id = frame_id_build (info->frame_base, info->func);
2005 static struct value *
2006 s390_frame_prev_register (struct frame_info *this_frame,
2007 void **this_prologue_cache, int regnum)
2009 struct gdbarch *gdbarch = get_frame_arch (this_frame);
2010 struct s390_unwind_cache *info
2011 = s390_frame_unwind_cache (this_frame, this_prologue_cache);
2013 return s390_trad_frame_prev_register (this_frame, info->saved_regs, regnum);
2016 static const struct frame_unwind s390_frame_unwind = {
2018 default_frame_unwind_stop_reason,
2020 s390_frame_prev_register,
2022 default_frame_sniffer
2026 /* Code stubs and their stack frames. For things like PLTs and NULL
2027 function calls (where there is no true frame and the return address
2028 is in the RETADDR register). */
2030 struct s390_stub_unwind_cache
2032 CORE_ADDR frame_base;
2033 struct trad_frame_saved_reg *saved_regs;
2036 static struct s390_stub_unwind_cache *
2037 s390_stub_frame_unwind_cache (struct frame_info *this_frame,
2038 void **this_prologue_cache)
2040 struct gdbarch *gdbarch = get_frame_arch (this_frame);
2041 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
2042 struct s390_stub_unwind_cache *info;
2045 if (*this_prologue_cache)
2046 return *this_prologue_cache;
2048 info = FRAME_OBSTACK_ZALLOC (struct s390_stub_unwind_cache);
2049 *this_prologue_cache = info;
2050 info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
2052 /* The return address is in register %r14. */
2053 info->saved_regs[S390_PSWA_REGNUM].realreg = S390_RETADDR_REGNUM;
2055 /* Retrieve stack pointer and determine our frame base. */
2056 reg = get_frame_register_unsigned (this_frame, S390_SP_REGNUM);
2057 info->frame_base = reg + 16*word_size + 32;
2063 s390_stub_frame_this_id (struct frame_info *this_frame,
2064 void **this_prologue_cache,
2065 struct frame_id *this_id)
2067 struct s390_stub_unwind_cache *info
2068 = s390_stub_frame_unwind_cache (this_frame, this_prologue_cache);
2069 *this_id = frame_id_build (info->frame_base, get_frame_pc (this_frame));
2072 static struct value *
2073 s390_stub_frame_prev_register (struct frame_info *this_frame,
2074 void **this_prologue_cache, int regnum)
2076 struct s390_stub_unwind_cache *info
2077 = s390_stub_frame_unwind_cache (this_frame, this_prologue_cache);
2078 return s390_trad_frame_prev_register (this_frame, info->saved_regs, regnum);
2082 s390_stub_frame_sniffer (const struct frame_unwind *self,
2083 struct frame_info *this_frame,
2084 void **this_prologue_cache)
2086 CORE_ADDR addr_in_block;
2087 bfd_byte insn[S390_MAX_INSTR_SIZE];
2089 /* If the current PC points to non-readable memory, we assume we
2090 have trapped due to an invalid function pointer call. We handle
2091 the non-existing current function like a PLT stub. */
2092 addr_in_block = get_frame_address_in_block (this_frame);
2093 if (in_plt_section (addr_in_block)
2094 || s390_readinstruction (insn, get_frame_pc (this_frame)) < 0)
2099 static const struct frame_unwind s390_stub_frame_unwind = {
2101 default_frame_unwind_stop_reason,
2102 s390_stub_frame_this_id,
2103 s390_stub_frame_prev_register,
2105 s390_stub_frame_sniffer
2109 /* Signal trampoline stack frames. */
2111 struct s390_sigtramp_unwind_cache {
2112 CORE_ADDR frame_base;
2113 struct trad_frame_saved_reg *saved_regs;
2116 static struct s390_sigtramp_unwind_cache *
2117 s390_sigtramp_frame_unwind_cache (struct frame_info *this_frame,
2118 void **this_prologue_cache)
2120 struct gdbarch *gdbarch = get_frame_arch (this_frame);
2121 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2122 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
2123 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2124 struct s390_sigtramp_unwind_cache *info;
2125 ULONGEST this_sp, prev_sp;
2126 CORE_ADDR next_ra, next_cfa, sigreg_ptr, sigreg_high_off;
2129 if (*this_prologue_cache)
2130 return *this_prologue_cache;
2132 info = FRAME_OBSTACK_ZALLOC (struct s390_sigtramp_unwind_cache);
2133 *this_prologue_cache = info;
2134 info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
2136 this_sp = get_frame_register_unsigned (this_frame, S390_SP_REGNUM);
2137 next_ra = get_frame_pc (this_frame);
2138 next_cfa = this_sp + 16*word_size + 32;
2140 /* New-style RT frame:
2141 retcode + alignment (8 bytes)
2143 ucontext (contains sigregs at offset 5 words). */
2144 if (next_ra == next_cfa)
2146 sigreg_ptr = next_cfa + 8 + 128 + align_up (5*word_size, 8);
2147 /* sigregs are followed by uc_sigmask (8 bytes), then by the
2148 upper GPR halves if present. */
2149 sigreg_high_off = 8;
2152 /* Old-style RT frame and all non-RT frames:
2153 old signal mask (8 bytes)
2154 pointer to sigregs. */
2157 sigreg_ptr = read_memory_unsigned_integer (next_cfa + 8,
2158 word_size, byte_order);
2159 /* sigregs are followed by signo (4 bytes), then by the
2160 upper GPR halves if present. */
2161 sigreg_high_off = 4;
2164 /* The sigregs structure looks like this:
2173 /* PSW mask and address. */
2174 info->saved_regs[S390_PSWM_REGNUM].addr = sigreg_ptr;
2175 sigreg_ptr += word_size;
2176 info->saved_regs[S390_PSWA_REGNUM].addr = sigreg_ptr;
2177 sigreg_ptr += word_size;
2179 /* Then the GPRs. */
2180 for (i = 0; i < 16; i++)
2182 info->saved_regs[S390_R0_REGNUM + i].addr = sigreg_ptr;
2183 sigreg_ptr += word_size;
2186 /* Then the ACRs. */
2187 for (i = 0; i < 16; i++)
2189 info->saved_regs[S390_A0_REGNUM + i].addr = sigreg_ptr;
2193 /* The floating-point control word. */
2194 info->saved_regs[S390_FPC_REGNUM].addr = sigreg_ptr;
2197 /* And finally the FPRs. */
2198 for (i = 0; i < 16; i++)
2200 info->saved_regs[S390_F0_REGNUM + i].addr = sigreg_ptr;
2204 /* If we have them, the GPR upper halves are appended at the end. */
2205 sigreg_ptr += sigreg_high_off;
2206 if (tdep->gpr_full_regnum != -1)
2207 for (i = 0; i < 16; i++)
2209 info->saved_regs[S390_R0_UPPER_REGNUM + i].addr = sigreg_ptr;
2213 /* Restore the previous frame's SP. */
2214 prev_sp = read_memory_unsigned_integer (
2215 info->saved_regs[S390_SP_REGNUM].addr,
2216 word_size, byte_order);
2218 /* Determine our frame base. */
2219 info->frame_base = prev_sp + 16*word_size + 32;
2225 s390_sigtramp_frame_this_id (struct frame_info *this_frame,
2226 void **this_prologue_cache,
2227 struct frame_id *this_id)
2229 struct s390_sigtramp_unwind_cache *info
2230 = s390_sigtramp_frame_unwind_cache (this_frame, this_prologue_cache);
2231 *this_id = frame_id_build (info->frame_base, get_frame_pc (this_frame));
2234 static struct value *
2235 s390_sigtramp_frame_prev_register (struct frame_info *this_frame,
2236 void **this_prologue_cache, int regnum)
2238 struct s390_sigtramp_unwind_cache *info
2239 = s390_sigtramp_frame_unwind_cache (this_frame, this_prologue_cache);
2240 return s390_trad_frame_prev_register (this_frame, info->saved_regs, regnum);
2244 s390_sigtramp_frame_sniffer (const struct frame_unwind *self,
2245 struct frame_info *this_frame,
2246 void **this_prologue_cache)
2248 CORE_ADDR pc = get_frame_pc (this_frame);
2249 bfd_byte sigreturn[2];
2251 if (target_read_memory (pc, sigreturn, 2))
2254 if (sigreturn[0] != op_svc)
2257 if (sigreturn[1] != 119 /* sigreturn */
2258 && sigreturn[1] != 173 /* rt_sigreturn */)
2264 static const struct frame_unwind s390_sigtramp_frame_unwind = {
2266 default_frame_unwind_stop_reason,
2267 s390_sigtramp_frame_this_id,
2268 s390_sigtramp_frame_prev_register,
2270 s390_sigtramp_frame_sniffer
2273 /* Retrieve the syscall number at a ptrace syscall-stop. Return -1
2277 s390_linux_get_syscall_number (struct gdbarch *gdbarch,
2280 struct regcache *regs = get_thread_regcache (ptid);
2281 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2282 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2284 ULONGEST svc_number = -1;
2287 /* Assume that the PC points after the 2-byte SVC instruction. We
2288 don't currently support SVC via EXECUTE. */
2289 regcache_cooked_read_unsigned (regs, tdep->pc_regnum, &pc);
2291 opcode = read_memory_unsigned_integer ((CORE_ADDR) pc, 1, byte_order);
2292 if (opcode != op_svc)
2295 svc_number = read_memory_unsigned_integer ((CORE_ADDR) pc + 1, 1,
2297 if (svc_number == 0)
2298 regcache_cooked_read_unsigned (regs, S390_R1_REGNUM, &svc_number);
2304 /* Frame base handling. */
2307 s390_frame_base_address (struct frame_info *this_frame, void **this_cache)
2309 struct s390_unwind_cache *info
2310 = s390_frame_unwind_cache (this_frame, this_cache);
2311 return info->frame_base;
2315 s390_local_base_address (struct frame_info *this_frame, void **this_cache)
2317 struct s390_unwind_cache *info
2318 = s390_frame_unwind_cache (this_frame, this_cache);
2319 return info->local_base;
2322 static const struct frame_base s390_frame_base = {
2324 s390_frame_base_address,
2325 s390_local_base_address,
2326 s390_local_base_address
2330 s390_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
2332 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2334 pc = frame_unwind_register_unsigned (next_frame, tdep->pc_regnum);
2335 return gdbarch_addr_bits_remove (gdbarch, pc);
2339 s390_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
2342 sp = frame_unwind_register_unsigned (next_frame, S390_SP_REGNUM);
2343 return gdbarch_addr_bits_remove (gdbarch, sp);
2347 /* DWARF-2 frame support. */
2349 static struct value *
2350 s390_dwarf2_prev_register (struct frame_info *this_frame, void **this_cache,
2353 return s390_unwind_pseudo_register (this_frame, regnum);
2357 s390_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
2358 struct dwarf2_frame_state_reg *reg,
2359 struct frame_info *this_frame)
2361 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2363 /* The condition code (and thus PSW mask) is call-clobbered. */
2364 if (regnum == S390_PSWM_REGNUM)
2365 reg->how = DWARF2_FRAME_REG_UNDEFINED;
2367 /* The PSW address unwinds to the return address. */
2368 else if (regnum == S390_PSWA_REGNUM)
2369 reg->how = DWARF2_FRAME_REG_RA;
2371 /* Fixed registers are call-saved or call-clobbered
2372 depending on the ABI in use. */
2373 else if (regnum < S390_NUM_REGS)
2375 if (s390_register_call_saved (gdbarch, regnum))
2376 reg->how = DWARF2_FRAME_REG_SAME_VALUE;
2378 reg->how = DWARF2_FRAME_REG_UNDEFINED;
2381 /* We install a special function to unwind pseudos. */
2384 reg->how = DWARF2_FRAME_REG_FN;
2385 reg->loc.fn = s390_dwarf2_prev_register;
2390 /* Dummy function calls. */
2392 /* Return non-zero if TYPE is an integer-like type, zero otherwise.
2393 "Integer-like" types are those that should be passed the way
2394 integers are: integers, enums, ranges, characters, and booleans. */
2396 is_integer_like (struct type *type)
2398 enum type_code code = TYPE_CODE (type);
2400 return (code == TYPE_CODE_INT
2401 || code == TYPE_CODE_ENUM
2402 || code == TYPE_CODE_RANGE
2403 || code == TYPE_CODE_CHAR
2404 || code == TYPE_CODE_BOOL);
2407 /* Return non-zero if TYPE is a pointer-like type, zero otherwise.
2408 "Pointer-like" types are those that should be passed the way
2409 pointers are: pointers and references. */
2411 is_pointer_like (struct type *type)
2413 enum type_code code = TYPE_CODE (type);
2415 return (code == TYPE_CODE_PTR
2416 || code == TYPE_CODE_REF);
2420 /* Return non-zero if TYPE is a `float singleton' or `double
2421 singleton', zero otherwise.
2423 A `T singleton' is a struct type with one member, whose type is
2424 either T or a `T singleton'. So, the following are all float
2428 struct { struct { float x; } x; };
2429 struct { struct { struct { float x; } x; } x; };
2433 All such structures are passed as if they were floats or doubles,
2434 as the (revised) ABI says. */
2436 is_float_singleton (struct type *type)
2438 if (TYPE_CODE (type) == TYPE_CODE_STRUCT && TYPE_NFIELDS (type) == 1)
2440 struct type *singleton_type = TYPE_FIELD_TYPE (type, 0);
2441 CHECK_TYPEDEF (singleton_type);
2443 return (TYPE_CODE (singleton_type) == TYPE_CODE_FLT
2444 || TYPE_CODE (singleton_type) == TYPE_CODE_DECFLOAT
2445 || is_float_singleton (singleton_type));
2452 /* Return non-zero if TYPE is a struct-like type, zero otherwise.
2453 "Struct-like" types are those that should be passed as structs are:
2456 As an odd quirk, not mentioned in the ABI, GCC passes float and
2457 double singletons as if they were a plain float, double, etc. (The
2458 corresponding union types are handled normally.) So we exclude
2459 those types here. *shrug* */
2461 is_struct_like (struct type *type)
2463 enum type_code code = TYPE_CODE (type);
2465 return (code == TYPE_CODE_UNION
2466 || (code == TYPE_CODE_STRUCT && ! is_float_singleton (type)));
2470 /* Return non-zero if TYPE is a float-like type, zero otherwise.
2471 "Float-like" types are those that should be passed as
2472 floating-point values are.
2474 You'd think this would just be floats, doubles, long doubles, etc.
2475 But as an odd quirk, not mentioned in the ABI, GCC passes float and
2476 double singletons as if they were a plain float, double, etc. (The
2477 corresponding union types are handled normally.) So we include
2478 those types here. *shrug* */
2480 is_float_like (struct type *type)
2482 return (TYPE_CODE (type) == TYPE_CODE_FLT
2483 || TYPE_CODE (type) == TYPE_CODE_DECFLOAT
2484 || is_float_singleton (type));
2487 /* Determine whether N is a power of two. */
2490 is_power_of_two (unsigned int n)
2492 return n && ((n & (n - 1)) == 0);
2495 /* Return non-zero if TYPE should be passed as a pointer to a copy,
2498 s390_function_arg_pass_by_reference (struct type *type)
2500 if (TYPE_LENGTH (type) > 8)
2503 return (is_struct_like (type) && !is_power_of_two (TYPE_LENGTH (type)))
2504 || TYPE_CODE (type) == TYPE_CODE_COMPLEX
2505 || (TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type));
2508 /* Return non-zero if TYPE should be passed in a float register
2511 s390_function_arg_float (struct type *type)
2513 if (TYPE_LENGTH (type) > 8)
2516 return is_float_like (type);
2519 /* Return non-zero if TYPE should be passed in an integer register
2520 (or a pair of integer registers) if possible. */
2522 s390_function_arg_integer (struct type *type)
2524 if (TYPE_LENGTH (type) > 8)
2527 return is_integer_like (type)
2528 || is_pointer_like (type)
2529 || (is_struct_like (type) && is_power_of_two (TYPE_LENGTH (type)));
2532 /* Return ARG, a `SIMPLE_ARG', sign-extended or zero-extended to a full
2533 word as required for the ABI. */
2535 extend_simple_arg (struct gdbarch *gdbarch, struct value *arg)
2537 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2538 struct type *type = check_typedef (value_type (arg));
2540 /* Even structs get passed in the least significant bits of the
2541 register / memory word. It's not really right to extract them as
2542 an integer, but it does take care of the extension. */
2543 if (TYPE_UNSIGNED (type))
2544 return extract_unsigned_integer (value_contents (arg),
2545 TYPE_LENGTH (type), byte_order);
2547 return extract_signed_integer (value_contents (arg),
2548 TYPE_LENGTH (type), byte_order);
2552 /* Return the alignment required by TYPE. */
2554 alignment_of (struct type *type)
2558 if (is_integer_like (type)
2559 || is_pointer_like (type)
2560 || TYPE_CODE (type) == TYPE_CODE_FLT
2561 || TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
2562 alignment = TYPE_LENGTH (type);
2563 else if (TYPE_CODE (type) == TYPE_CODE_STRUCT
2564 || TYPE_CODE (type) == TYPE_CODE_UNION)
2569 for (i = 0; i < TYPE_NFIELDS (type); i++)
2572 = alignment_of (check_typedef (TYPE_FIELD_TYPE (type, i)));
2574 if (field_alignment > alignment)
2575 alignment = field_alignment;
2581 /* Check that everything we ever return is a power of two. Lots of
2582 code doesn't want to deal with aligning things to arbitrary
2584 gdb_assert ((alignment & (alignment - 1)) == 0);
2590 /* Put the actual parameter values pointed to by ARGS[0..NARGS-1] in
2591 place to be passed to a function, as specified by the "GNU/Linux
2592 for S/390 ELF Application Binary Interface Supplement".
2594 SP is the current stack pointer. We must put arguments, links,
2595 padding, etc. whereever they belong, and return the new stack
2598 If STRUCT_RETURN is non-zero, then the function we're calling is
2599 going to return a structure by value; STRUCT_ADDR is the address of
2600 a block we've allocated for it on the stack.
2602 Our caller has taken care of any type promotions needed to satisfy
2603 prototypes or the old K&R argument-passing rules. */
2605 s390_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
2606 struct regcache *regcache, CORE_ADDR bp_addr,
2607 int nargs, struct value **args, CORE_ADDR sp,
2608 int struct_return, CORE_ADDR struct_addr)
2610 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2611 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
2612 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2615 /* If the i'th argument is passed as a reference to a copy, then
2616 copy_addr[i] is the address of the copy we made. */
2617 CORE_ADDR *copy_addr = alloca (nargs * sizeof (CORE_ADDR));
2619 /* Reserve space for the reference-to-copy area. */
2620 for (i = 0; i < nargs; i++)
2622 struct value *arg = args[i];
2623 struct type *type = check_typedef (value_type (arg));
2625 if (s390_function_arg_pass_by_reference (type))
2627 sp -= TYPE_LENGTH (type);
2628 sp = align_down (sp, alignment_of (type));
2633 /* Reserve space for the parameter area. As a conservative
2634 simplification, we assume that everything will be passed on the
2635 stack. Since every argument larger than 8 bytes will be
2636 passed by reference, we use this simple upper bound. */
2639 /* After all that, make sure it's still aligned on an eight-byte
2641 sp = align_down (sp, 8);
2643 /* Allocate the standard frame areas: the register save area, the
2644 word reserved for the compiler (which seems kind of meaningless),
2645 and the back chain pointer. */
2646 sp -= 16*word_size + 32;
2648 /* Now we have the final SP value. Make sure we didn't underflow;
2649 on 31-bit, this would result in addresses with the high bit set,
2650 which causes confusion elsewhere. Note that if we error out
2651 here, stack and registers remain untouched. */
2652 if (gdbarch_addr_bits_remove (gdbarch, sp) != sp)
2653 error (_("Stack overflow"));
2656 /* Finally, place the actual parameters, working from SP towards
2657 higher addresses. The code above is supposed to reserve enough
2662 CORE_ADDR starg = sp + 16*word_size + 32;
2664 /* A struct is returned using general register 2. */
2667 regcache_cooked_write_unsigned (regcache, S390_R0_REGNUM + gr,
2672 for (i = 0; i < nargs; i++)
2674 struct value *arg = args[i];
2675 struct type *type = check_typedef (value_type (arg));
2676 unsigned length = TYPE_LENGTH (type);
2678 if (s390_function_arg_pass_by_reference (type))
2680 /* Actually copy the argument contents to the stack slot
2681 that was reserved above. */
2682 write_memory (copy_addr[i], value_contents (arg), length);
2686 regcache_cooked_write_unsigned (regcache, S390_R0_REGNUM + gr,
2692 write_memory_unsigned_integer (starg, word_size, byte_order,
2697 else if (s390_function_arg_float (type))
2699 /* The GNU/Linux for S/390 ABI uses FPRs 0 and 2 to pass arguments,
2700 the GNU/Linux for zSeries ABI uses 0, 2, 4, and 6. */
2701 if (fr <= (tdep->abi == ABI_LINUX_S390 ? 2 : 6))
2703 /* When we store a single-precision value in an FP register,
2704 it occupies the leftmost bits. */
2705 regcache_cooked_write_part (regcache, S390_F0_REGNUM + fr,
2706 0, length, value_contents (arg));
2711 /* When we store a single-precision value in a stack slot,
2712 it occupies the rightmost bits. */
2713 starg = align_up (starg + length, word_size);
2714 write_memory (starg - length, value_contents (arg), length);
2717 else if (s390_function_arg_integer (type) && length <= word_size)
2721 /* Integer arguments are always extended to word size. */
2722 regcache_cooked_write_signed (regcache, S390_R0_REGNUM + gr,
2723 extend_simple_arg (gdbarch,
2729 /* Integer arguments are always extended to word size. */
2730 write_memory_signed_integer (starg, word_size, byte_order,
2731 extend_simple_arg (gdbarch, arg));
2735 else if (s390_function_arg_integer (type) && length == 2*word_size)
2739 regcache_cooked_write (regcache, S390_R0_REGNUM + gr,
2740 value_contents (arg));
2741 regcache_cooked_write (regcache, S390_R0_REGNUM + gr + 1,
2742 value_contents (arg) + word_size);
2747 /* If we skipped r6 because we couldn't fit a DOUBLE_ARG
2748 in it, then don't go back and use it again later. */
2751 write_memory (starg, value_contents (arg), length);
2756 internal_error (__FILE__, __LINE__, _("unknown argument type"));
2760 /* Store return PSWA. In 31-bit mode, keep addressing mode bit. */
2764 regcache_cooked_read_unsigned (regcache, S390_PSWA_REGNUM, &pswa);
2765 bp_addr = (bp_addr & 0x7fffffff) | (pswa & 0x80000000);
2767 regcache_cooked_write_unsigned (regcache, S390_RETADDR_REGNUM, bp_addr);
2769 /* Store updated stack pointer. */
2770 regcache_cooked_write_unsigned (regcache, S390_SP_REGNUM, sp);
2772 /* We need to return the 'stack part' of the frame ID,
2773 which is actually the top of the register save area. */
2774 return sp + 16*word_size + 32;
2777 /* Assuming THIS_FRAME is a dummy, return the frame ID of that
2778 dummy frame. The frame ID's base needs to match the TOS value
2779 returned by push_dummy_call, and the PC match the dummy frame's
2781 static struct frame_id
2782 s390_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
2784 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
2785 CORE_ADDR sp = get_frame_register_unsigned (this_frame, S390_SP_REGNUM);
2786 sp = gdbarch_addr_bits_remove (gdbarch, sp);
2788 return frame_id_build (sp + 16*word_size + 32,
2789 get_frame_pc (this_frame));
2793 s390_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
2795 /* Both the 32- and 64-bit ABI's say that the stack pointer should
2796 always be aligned on an eight-byte boundary. */
2801 /* Function return value access. */
2803 static enum return_value_convention
2804 s390_return_value_convention (struct gdbarch *gdbarch, struct type *type)
2806 if (TYPE_LENGTH (type) > 8)
2807 return RETURN_VALUE_STRUCT_CONVENTION;
2809 switch (TYPE_CODE (type))
2811 case TYPE_CODE_STRUCT:
2812 case TYPE_CODE_UNION:
2813 case TYPE_CODE_ARRAY:
2814 case TYPE_CODE_COMPLEX:
2815 return RETURN_VALUE_STRUCT_CONVENTION;
2818 return RETURN_VALUE_REGISTER_CONVENTION;
2822 static enum return_value_convention
2823 s390_return_value (struct gdbarch *gdbarch, struct value *function,
2824 struct type *type, struct regcache *regcache,
2825 gdb_byte *out, const gdb_byte *in)
2827 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2828 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
2829 enum return_value_convention rvc;
2832 type = check_typedef (type);
2833 rvc = s390_return_value_convention (gdbarch, type);
2834 length = TYPE_LENGTH (type);
2840 case RETURN_VALUE_REGISTER_CONVENTION:
2841 if (TYPE_CODE (type) == TYPE_CODE_FLT
2842 || TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
2844 /* When we store a single-precision value in an FP register,
2845 it occupies the leftmost bits. */
2846 regcache_cooked_write_part (regcache, S390_F0_REGNUM,
2849 else if (length <= word_size)
2851 /* Integer arguments are always extended to word size. */
2852 if (TYPE_UNSIGNED (type))
2853 regcache_cooked_write_unsigned (regcache, S390_R2_REGNUM,
2854 extract_unsigned_integer (in, length, byte_order));
2856 regcache_cooked_write_signed (regcache, S390_R2_REGNUM,
2857 extract_signed_integer (in, length, byte_order));
2859 else if (length == 2*word_size)
2861 regcache_cooked_write (regcache, S390_R2_REGNUM, in);
2862 regcache_cooked_write (regcache, S390_R3_REGNUM, in + word_size);
2865 internal_error (__FILE__, __LINE__, _("invalid return type"));
2868 case RETURN_VALUE_STRUCT_CONVENTION:
2869 error (_("Cannot set function return value."));
2877 case RETURN_VALUE_REGISTER_CONVENTION:
2878 if (TYPE_CODE (type) == TYPE_CODE_FLT
2879 || TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
2881 /* When we store a single-precision value in an FP register,
2882 it occupies the leftmost bits. */
2883 regcache_cooked_read_part (regcache, S390_F0_REGNUM,
2886 else if (length <= word_size)
2888 /* Integer arguments occupy the rightmost bits. */
2889 regcache_cooked_read_part (regcache, S390_R2_REGNUM,
2890 word_size - length, length, out);
2892 else if (length == 2*word_size)
2894 regcache_cooked_read (regcache, S390_R2_REGNUM, out);
2895 regcache_cooked_read (regcache, S390_R3_REGNUM, out + word_size);
2898 internal_error (__FILE__, __LINE__, _("invalid return type"));
2901 case RETURN_VALUE_STRUCT_CONVENTION:
2902 error (_("Function return value unknown."));
2913 static const gdb_byte *
2914 s390_breakpoint_from_pc (struct gdbarch *gdbarch,
2915 CORE_ADDR *pcptr, int *lenptr)
2917 static const gdb_byte breakpoint[] = { 0x0, 0x1 };
2919 *lenptr = sizeof (breakpoint);
2924 /* Address handling. */
2927 s390_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr)
2929 return addr & 0x7fffffff;
2933 s390_address_class_type_flags (int byte_size, int dwarf2_addr_class)
2936 return TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1;
2942 s390_address_class_type_flags_to_name (struct gdbarch *gdbarch, int type_flags)
2944 if (type_flags & TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1)
2951 s390_address_class_name_to_type_flags (struct gdbarch *gdbarch,
2953 int *type_flags_ptr)
2955 if (strcmp (name, "mode32") == 0)
2957 *type_flags_ptr = TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1;
2964 /* Implement gdbarch_gcc_target_options. GCC does not know "-m32" or
2965 "-mcmodel=large". */
2968 s390_gcc_target_options (struct gdbarch *gdbarch)
2970 return xstrdup (gdbarch_ptr_bit (gdbarch) == 64 ? "-m64" : "-m31");
2973 /* Implement gdbarch_gnu_triplet_regexp. Target triplets are "s390-*"
2974 for 31-bit and "s390x-*" for 64-bit, while the BFD arch name is
2975 always "s390". Note that an s390x compiler supports "-m31" as
2979 s390_gnu_triplet_regexp (struct gdbarch *gdbarch)
2984 /* Implementation of `gdbarch_stap_is_single_operand', as defined in
2988 s390_stap_is_single_operand (struct gdbarch *gdbarch, const char *s)
2990 return ((isdigit (*s) && s[1] == '(' && s[2] == '%') /* Displacement
2992 || *s == '%' /* Register access. */
2993 || isdigit (*s)); /* Literal number. */
2996 /* Set up gdbarch struct. */
2998 static struct gdbarch *
2999 s390_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
3001 const struct target_desc *tdesc = info.target_desc;
3002 struct tdesc_arch_data *tdesc_data = NULL;
3003 struct gdbarch *gdbarch;
3004 struct gdbarch_tdep *tdep;
3007 int have_linux_v1 = 0;
3008 int have_linux_v2 = 0;
3011 int first_pseudo_reg, last_pseudo_reg;
3012 static const char *const stap_register_prefixes[] = { "%", NULL };
3013 static const char *const stap_register_indirection_prefixes[] = { "(",
3015 static const char *const stap_register_indirection_suffixes[] = { ")",
3018 /* Default ABI and register size. */
3019 switch (info.bfd_arch_info->mach)
3021 case bfd_mach_s390_31:
3022 tdep_abi = ABI_LINUX_S390;
3025 case bfd_mach_s390_64:
3026 tdep_abi = ABI_LINUX_ZSERIES;
3033 /* Use default target description if none provided by the target. */
3034 if (!tdesc_has_registers (tdesc))
3036 if (tdep_abi == ABI_LINUX_S390)
3037 tdesc = tdesc_s390_linux32;
3039 tdesc = tdesc_s390x_linux64;
3042 /* Check any target description for validity. */
3043 if (tdesc_has_registers (tdesc))
3045 static const char *const gprs[] = {
3046 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
3047 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
3049 static const char *const fprs[] = {
3050 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
3051 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15"
3053 static const char *const acrs[] = {
3054 "acr0", "acr1", "acr2", "acr3", "acr4", "acr5", "acr6", "acr7",
3055 "acr8", "acr9", "acr10", "acr11", "acr12", "acr13", "acr14", "acr15"
3057 static const char *const gprs_lower[] = {
3058 "r0l", "r1l", "r2l", "r3l", "r4l", "r5l", "r6l", "r7l",
3059 "r8l", "r9l", "r10l", "r11l", "r12l", "r13l", "r14l", "r15l"
3061 static const char *const gprs_upper[] = {
3062 "r0h", "r1h", "r2h", "r3h", "r4h", "r5h", "r6h", "r7h",
3063 "r8h", "r9h", "r10h", "r11h", "r12h", "r13h", "r14h", "r15h"
3065 static const char *const tdb_regs[] = {
3066 "tdb0", "tac", "tct", "atia",
3067 "tr0", "tr1", "tr2", "tr3", "tr4", "tr5", "tr6", "tr7",
3068 "tr8", "tr9", "tr10", "tr11", "tr12", "tr13", "tr14", "tr15"
3070 static const char *const vxrs_low[] = {
3071 "v0l", "v1l", "v2l", "v3l", "v4l", "v5l", "v6l", "v7l", "v8l",
3072 "v9l", "v10l", "v11l", "v12l", "v13l", "v14l", "v15l",
3074 static const char *const vxrs_high[] = {
3075 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23", "v24",
3076 "v25", "v26", "v27", "v28", "v29", "v30", "v31",
3078 const struct tdesc_feature *feature;
3081 feature = tdesc_find_feature (tdesc, "org.gnu.gdb.s390.core");
3082 if (feature == NULL)
3085 tdesc_data = tdesc_data_alloc ();
3087 valid_p &= tdesc_numbered_register (feature, tdesc_data,
3088 S390_PSWM_REGNUM, "pswm");
3089 valid_p &= tdesc_numbered_register (feature, tdesc_data,
3090 S390_PSWA_REGNUM, "pswa");
3092 if (tdesc_unnumbered_register (feature, "r0"))
3094 for (i = 0; i < 16; i++)
3095 valid_p &= tdesc_numbered_register (feature, tdesc_data,
3096 S390_R0_REGNUM + i, gprs[i]);
3102 for (i = 0; i < 16; i++)
3103 valid_p &= tdesc_numbered_register (feature, tdesc_data,
3106 for (i = 0; i < 16; i++)
3107 valid_p &= tdesc_numbered_register (feature, tdesc_data,
3108 S390_R0_UPPER_REGNUM + i,
3112 feature = tdesc_find_feature (tdesc, "org.gnu.gdb.s390.fpr");
3113 if (feature == NULL)
3115 tdesc_data_cleanup (tdesc_data);
3119 valid_p &= tdesc_numbered_register (feature, tdesc_data,
3120 S390_FPC_REGNUM, "fpc");
3121 for (i = 0; i < 16; i++)
3122 valid_p &= tdesc_numbered_register (feature, tdesc_data,
3123 S390_F0_REGNUM + i, fprs[i]);
3125 feature = tdesc_find_feature (tdesc, "org.gnu.gdb.s390.acr");
3126 if (feature == NULL)
3128 tdesc_data_cleanup (tdesc_data);
3132 for (i = 0; i < 16; i++)
3133 valid_p &= tdesc_numbered_register (feature, tdesc_data,
3134 S390_A0_REGNUM + i, acrs[i]);
3136 /* Optional GNU/Linux-specific "registers". */
3137 feature = tdesc_find_feature (tdesc, "org.gnu.gdb.s390.linux");
3140 tdesc_numbered_register (feature, tdesc_data,
3141 S390_ORIG_R2_REGNUM, "orig_r2");
3143 if (tdesc_numbered_register (feature, tdesc_data,
3144 S390_LAST_BREAK_REGNUM, "last_break"))
3147 if (tdesc_numbered_register (feature, tdesc_data,
3148 S390_SYSTEM_CALL_REGNUM, "system_call"))
3151 if (have_linux_v2 > have_linux_v1)
3155 /* Transaction diagnostic block. */
3156 feature = tdesc_find_feature (tdesc, "org.gnu.gdb.s390.tdb");
3159 for (i = 0; i < ARRAY_SIZE (tdb_regs); i++)
3160 valid_p &= tdesc_numbered_register (feature, tdesc_data,
3161 S390_TDB_DWORD0_REGNUM + i,
3166 /* Vector registers. */
3167 feature = tdesc_find_feature (tdesc, "org.gnu.gdb.s390.vx");
3170 for (i = 0; i < 16; i++)
3171 valid_p &= tdesc_numbered_register (feature, tdesc_data,
3172 S390_V0_LOWER_REGNUM + i,
3174 for (i = 0; i < 16; i++)
3175 valid_p &= tdesc_numbered_register (feature, tdesc_data,
3176 S390_V16_REGNUM + i,
3183 tdesc_data_cleanup (tdesc_data);
3188 /* Find a candidate among extant architectures. */
3189 for (arches = gdbarch_list_lookup_by_info (arches, &info);
3191 arches = gdbarch_list_lookup_by_info (arches->next, &info))
3193 tdep = gdbarch_tdep (arches->gdbarch);
3196 if (tdep->abi != tdep_abi)
3198 if ((tdep->gpr_full_regnum != -1) != have_upper)
3200 if (tdesc_data != NULL)
3201 tdesc_data_cleanup (tdesc_data);
3202 return arches->gdbarch;
3205 /* Otherwise create a new gdbarch for the specified machine type. */
3206 tdep = XCNEW (struct gdbarch_tdep);
3207 tdep->abi = tdep_abi;
3208 tdep->have_linux_v1 = have_linux_v1;
3209 tdep->have_linux_v2 = have_linux_v2;
3210 tdep->have_tdb = have_tdb;
3211 gdbarch = gdbarch_alloc (&info, tdep);
3213 set_gdbarch_believe_pcc_promotion (gdbarch, 0);
3214 set_gdbarch_char_signed (gdbarch, 0);
3216 /* S/390 GNU/Linux uses either 64-bit or 128-bit long doubles.
3217 We can safely let them default to 128-bit, since the debug info
3218 will give the size of type actually used in each case. */
3219 set_gdbarch_long_double_bit (gdbarch, 128);
3220 set_gdbarch_long_double_format (gdbarch, floatformats_ia64_quad);
3222 /* Amount PC must be decremented by after a breakpoint. This is
3223 often the number of bytes returned by gdbarch_breakpoint_from_pc but not
3225 set_gdbarch_decr_pc_after_break (gdbarch, 2);
3226 /* Stack grows downward. */
3227 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
3228 set_gdbarch_breakpoint_from_pc (gdbarch, s390_breakpoint_from_pc);
3229 set_gdbarch_skip_prologue (gdbarch, s390_skip_prologue);
3230 set_gdbarch_in_function_epilogue_p (gdbarch, s390_in_function_epilogue_p);
3232 set_gdbarch_num_regs (gdbarch, S390_NUM_REGS);
3233 set_gdbarch_sp_regnum (gdbarch, S390_SP_REGNUM);
3234 set_gdbarch_fp0_regnum (gdbarch, S390_F0_REGNUM);
3235 set_gdbarch_stab_reg_to_regnum (gdbarch, s390_dwarf_reg_to_regnum);
3236 set_gdbarch_dwarf2_reg_to_regnum (gdbarch, s390_dwarf_reg_to_regnum);
3237 set_gdbarch_value_from_register (gdbarch, s390_value_from_register);
3238 set_gdbarch_core_read_description (gdbarch, s390_core_read_description);
3239 set_gdbarch_iterate_over_regset_sections (gdbarch,
3240 s390_iterate_over_regset_sections);
3241 set_gdbarch_cannot_store_register (gdbarch, s390_cannot_store_register);
3242 set_gdbarch_write_pc (gdbarch, s390_write_pc);
3243 set_gdbarch_pseudo_register_read (gdbarch, s390_pseudo_register_read);
3244 set_gdbarch_pseudo_register_write (gdbarch, s390_pseudo_register_write);
3245 set_tdesc_pseudo_register_name (gdbarch, s390_pseudo_register_name);
3246 set_tdesc_pseudo_register_type (gdbarch, s390_pseudo_register_type);
3247 set_tdesc_pseudo_register_reggroup_p (gdbarch,
3248 s390_pseudo_register_reggroup_p);
3249 tdesc_use_registers (gdbarch, tdesc, tdesc_data);
3250 set_gdbarch_register_name (gdbarch, s390_register_name);
3252 /* Assign pseudo register numbers. */
3253 first_pseudo_reg = gdbarch_num_regs (gdbarch);
3254 last_pseudo_reg = first_pseudo_reg;
3255 tdep->gpr_full_regnum = -1;
3258 tdep->gpr_full_regnum = last_pseudo_reg;
3259 last_pseudo_reg += 16;
3261 tdep->v0_full_regnum = -1;
3264 tdep->v0_full_regnum = last_pseudo_reg;
3265 last_pseudo_reg += 16;
3267 tdep->pc_regnum = last_pseudo_reg++;
3268 tdep->cc_regnum = last_pseudo_reg++;
3269 set_gdbarch_pc_regnum (gdbarch, tdep->pc_regnum);
3270 set_gdbarch_num_pseudo_regs (gdbarch, last_pseudo_reg - first_pseudo_reg);
3272 /* Inferior function calls. */
3273 set_gdbarch_push_dummy_call (gdbarch, s390_push_dummy_call);
3274 set_gdbarch_dummy_id (gdbarch, s390_dummy_id);
3275 set_gdbarch_frame_align (gdbarch, s390_frame_align);
3276 set_gdbarch_return_value (gdbarch, s390_return_value);
3278 /* Syscall handling. */
3279 set_gdbarch_get_syscall_number (gdbarch, s390_linux_get_syscall_number);
3281 /* Frame handling. */
3282 dwarf2_frame_set_init_reg (gdbarch, s390_dwarf2_frame_init_reg);
3283 dwarf2_frame_set_adjust_regnum (gdbarch, s390_adjust_frame_regnum);
3284 dwarf2_append_unwinders (gdbarch);
3285 frame_base_append_sniffer (gdbarch, dwarf2_frame_base_sniffer);
3286 frame_unwind_append_unwinder (gdbarch, &s390_stub_frame_unwind);
3287 frame_unwind_append_unwinder (gdbarch, &s390_sigtramp_frame_unwind);
3288 frame_unwind_append_unwinder (gdbarch, &s390_frame_unwind);
3289 frame_base_set_default (gdbarch, &s390_frame_base);
3290 set_gdbarch_unwind_pc (gdbarch, s390_unwind_pc);
3291 set_gdbarch_unwind_sp (gdbarch, s390_unwind_sp);
3293 /* Displaced stepping. */
3294 set_gdbarch_displaced_step_copy_insn (gdbarch,
3295 simple_displaced_step_copy_insn);
3296 set_gdbarch_displaced_step_fixup (gdbarch, s390_displaced_step_fixup);
3297 set_gdbarch_displaced_step_free_closure (gdbarch,
3298 simple_displaced_step_free_closure);
3299 set_gdbarch_displaced_step_location (gdbarch, linux_displaced_step_location);
3300 set_gdbarch_max_insn_length (gdbarch, S390_MAX_INSTR_SIZE);
3302 /* Note that GNU/Linux is the only OS supported on this
3304 linux_init_abi (info, gdbarch);
3308 case ABI_LINUX_S390:
3309 set_gdbarch_addr_bits_remove (gdbarch, s390_addr_bits_remove);
3310 set_solib_svr4_fetch_link_map_offsets
3311 (gdbarch, svr4_ilp32_fetch_link_map_offsets);
3313 set_xml_syscall_file_name (gdbarch, XML_SYSCALL_FILENAME_S390);
3316 case ABI_LINUX_ZSERIES:
3317 set_gdbarch_long_bit (gdbarch, 64);
3318 set_gdbarch_long_long_bit (gdbarch, 64);
3319 set_gdbarch_ptr_bit (gdbarch, 64);
3320 set_solib_svr4_fetch_link_map_offsets
3321 (gdbarch, svr4_lp64_fetch_link_map_offsets);
3322 set_gdbarch_address_class_type_flags (gdbarch,
3323 s390_address_class_type_flags);
3324 set_gdbarch_address_class_type_flags_to_name (gdbarch,
3325 s390_address_class_type_flags_to_name);
3326 set_gdbarch_address_class_name_to_type_flags (gdbarch,
3327 s390_address_class_name_to_type_flags);
3328 set_xml_syscall_file_name (gdbarch, XML_SYSCALL_FILENAME_S390X);
3332 set_gdbarch_print_insn (gdbarch, print_insn_s390);
3334 set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
3336 /* Enable TLS support. */
3337 set_gdbarch_fetch_tls_load_module_address (gdbarch,
3338 svr4_fetch_objfile_link_map);
3340 set_gdbarch_get_siginfo_type (gdbarch, linux_get_siginfo_type);
3342 /* SystemTap functions. */
3343 set_gdbarch_stap_register_prefixes (gdbarch, stap_register_prefixes);
3344 set_gdbarch_stap_register_indirection_prefixes (gdbarch,
3345 stap_register_indirection_prefixes);
3346 set_gdbarch_stap_register_indirection_suffixes (gdbarch,
3347 stap_register_indirection_suffixes);
3348 set_gdbarch_stap_is_single_operand (gdbarch, s390_stap_is_single_operand);
3349 set_gdbarch_gcc_target_options (gdbarch, s390_gcc_target_options);
3350 set_gdbarch_gnu_triplet_regexp (gdbarch, s390_gnu_triplet_regexp);
3356 extern initialize_file_ftype _initialize_s390_tdep; /* -Wmissing-prototypes */
3359 _initialize_s390_tdep (void)
3361 /* Hook us into the gdbarch mechanism. */
3362 register_gdbarch_init (bfd_arch_s390, s390_gdbarch_init);
3364 /* Initialize the GNU/Linux target descriptions. */
3365 initialize_tdesc_s390_linux32 ();
3366 initialize_tdesc_s390_linux32v1 ();
3367 initialize_tdesc_s390_linux32v2 ();
3368 initialize_tdesc_s390_linux64 ();
3369 initialize_tdesc_s390_linux64v1 ();
3370 initialize_tdesc_s390_linux64v2 ();
3371 initialize_tdesc_s390_te_linux64 ();
3372 initialize_tdesc_s390_vx_linux64 ();
3373 initialize_tdesc_s390_tevx_linux64 ();
3374 initialize_tdesc_s390x_linux64 ();
3375 initialize_tdesc_s390x_linux64v1 ();
3376 initialize_tdesc_s390x_linux64v2 ();
3377 initialize_tdesc_s390x_te_linux64 ();
3378 initialize_tdesc_s390x_vx_linux64 ();
3379 initialize_tdesc_s390x_tevx_linux64 ();