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 /* Unwrap any single-field structs in TYPE and return the effective
2393 "inner" type. E.g., yield "float" for all these cases:
2397 struct { struct { float x; } x; };
2398 struct { struct { struct { float x; } x; } x; }; */
2400 static struct type
*
2401 s390_effective_inner_type (struct type
*type
)
2403 while (TYPE_CODE (type
) == TYPE_CODE_STRUCT
2404 && TYPE_NFIELDS (type
) == 1)
2405 type
= check_typedef (TYPE_FIELD_TYPE (type
, 0));
2409 /* Return non-zero if TYPE should be passed like "float" or
2413 s390_function_arg_float (struct type
*type
)
2415 /* Note that long double as well as complex types are intentionally
2417 if (TYPE_LENGTH (type
) > 8)
2420 /* A struct containing just a float or double is passed like a float
2422 type
= s390_effective_inner_type (type
);
2424 return (TYPE_CODE (type
) == TYPE_CODE_FLT
2425 || TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
);
2428 /* Determine whether N is a power of two. */
2431 is_power_of_two (unsigned int n
)
2433 return n
&& ((n
& (n
- 1)) == 0);
2436 /* For an argument whose type is TYPE and which is not passed like a
2437 float, return non-zero if it should be passed like "int" or "long
2441 s390_function_arg_integer (struct type
*type
)
2443 enum type_code code
= TYPE_CODE (type
);
2445 if (TYPE_LENGTH (type
) > 8)
2448 if (code
== TYPE_CODE_INT
2449 || code
== TYPE_CODE_ENUM
2450 || code
== TYPE_CODE_RANGE
2451 || code
== TYPE_CODE_CHAR
2452 || code
== TYPE_CODE_BOOL
2453 || code
== TYPE_CODE_PTR
2454 || code
== TYPE_CODE_REF
)
2457 return ((code
== TYPE_CODE_UNION
|| code
== TYPE_CODE_STRUCT
)
2458 && is_power_of_two (TYPE_LENGTH (type
)));
2461 /* Argument passing state: Internal data structure passed to helper
2462 routines of s390_push_dummy_call. */
2464 struct s390_arg_state
2466 /* Register cache, or NULL, if we are in "preparation mode". */
2467 struct regcache
*regcache
;
2468 /* Next available general/floating-point register for argument
2471 /* Current pointer to copy area (grows downwards). */
2473 /* Current pointer to parameter area (grows upwards). */
2477 /* Prepare one argument ARG for a dummy call and update the argument
2478 passing state AS accordingly. If the regcache field in AS is set,
2479 operate in "write mode" and write ARG into the inferior. Otherwise
2480 run "preparation mode" and skip all updates to the inferior. */
2483 s390_handle_arg (struct s390_arg_state
*as
, struct value
*arg
,
2484 struct gdbarch_tdep
*tdep
, int word_size
,
2485 enum bfd_endian byte_order
)
2487 struct type
*type
= check_typedef (value_type (arg
));
2488 unsigned int length
= TYPE_LENGTH (type
);
2489 int write_mode
= as
->regcache
!= NULL
;
2491 if (s390_function_arg_float (type
))
2493 /* The GNU/Linux for S/390 ABI uses FPRs 0 and 2 to pass
2494 arguments. The GNU/Linux for zSeries ABI uses 0, 2, 4, and
2496 if (as
->fr
<= (tdep
->abi
== ABI_LINUX_S390
? 2 : 6))
2498 /* When we store a single-precision value in an FP register,
2499 it occupies the leftmost bits. */
2501 regcache_cooked_write_part (as
->regcache
,
2502 S390_F0_REGNUM
+ as
->fr
,
2504 value_contents (arg
));
2509 /* When we store a single-precision value in a stack slot,
2510 it occupies the rightmost bits. */
2511 as
->argp
= align_up (as
->argp
+ length
, word_size
);
2513 write_memory (as
->argp
- length
, value_contents (arg
),
2517 else if (s390_function_arg_integer (type
) && length
<= word_size
)
2523 /* Place value in least significant bits of the register or
2524 memory word and sign- or zero-extend to full word size.
2525 This also applies to a struct or union. */
2526 val
= TYPE_UNSIGNED (type
)
2527 ? extract_unsigned_integer (value_contents (arg
),
2529 : extract_signed_integer (value_contents (arg
),
2530 length
, byte_order
);
2536 regcache_cooked_write_unsigned (as
->regcache
,
2537 S390_R0_REGNUM
+ as
->gr
,
2544 write_memory_unsigned_integer (as
->argp
, word_size
,
2546 as
->argp
+= word_size
;
2549 else if (s390_function_arg_integer (type
) && length
== 8)
2555 regcache_cooked_write (as
->regcache
,
2556 S390_R0_REGNUM
+ as
->gr
,
2557 value_contents (arg
));
2558 regcache_cooked_write (as
->regcache
,
2559 S390_R0_REGNUM
+ as
->gr
+ 1,
2560 value_contents (arg
) + word_size
);
2566 /* If we skipped r6 because we couldn't fit a DOUBLE_ARG
2567 in it, then don't go back and use it again later. */
2571 write_memory (as
->argp
, value_contents (arg
), length
);
2577 /* This argument type is never passed in registers. Place the
2578 value in the copy area and pass a pointer to it. Use 8-byte
2579 alignment as a conservative assumption. */
2580 as
->copy
= align_down (as
->copy
- length
, 8);
2582 write_memory (as
->copy
, value_contents (arg
), length
);
2587 regcache_cooked_write_unsigned (as
->regcache
,
2588 S390_R0_REGNUM
+ as
->gr
,
2595 write_memory_unsigned_integer (as
->argp
, word_size
,
2596 byte_order
, as
->copy
);
2597 as
->argp
+= word_size
;
2602 /* Put the actual parameter values pointed to by ARGS[0..NARGS-1] in
2603 place to be passed to a function, as specified by the "GNU/Linux
2604 for S/390 ELF Application Binary Interface Supplement".
2606 SP is the current stack pointer. We must put arguments, links,
2607 padding, etc. whereever they belong, and return the new stack
2610 If STRUCT_RETURN is non-zero, then the function we're calling is
2611 going to return a structure by value; STRUCT_ADDR is the address of
2612 a block we've allocated for it on the stack.
2614 Our caller has taken care of any type promotions needed to satisfy
2615 prototypes or the old K&R argument-passing rules. */
2618 s390_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
2619 struct regcache
*regcache
, CORE_ADDR bp_addr
,
2620 int nargs
, struct value
**args
, CORE_ADDR sp
,
2621 int struct_return
, CORE_ADDR struct_addr
)
2623 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2624 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
2625 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2627 struct s390_arg_state arg_state
, arg_prep
;
2628 CORE_ADDR param_area_start
, new_sp
;
2631 arg_prep
.gr
= struct_return
? 3 : 2;
2634 arg_prep
.regcache
= NULL
;
2636 /* Initialize arg_state for "preparation mode". */
2637 arg_state
= arg_prep
;
2639 /* Update arg_state.copy with the start of the reference-to-copy area
2640 and arg_state.argp with the size of the parameter area. */
2641 for (i
= 0; i
< nargs
; i
++)
2642 s390_handle_arg (&arg_state
, args
[i
], tdep
, word_size
, byte_order
);
2644 param_area_start
= align_down (arg_state
.copy
- arg_state
.argp
, 8);
2646 /* Allocate the standard frame areas: the register save area, the
2647 word reserved for the compiler, and the back chain pointer. */
2648 new_sp
= param_area_start
- (16 * word_size
+ 32);
2650 /* Now we have the final stack pointer. Make sure we didn't
2651 underflow; on 31-bit, this would result in addresses with the
2652 high bit set, which causes confusion elsewhere. Note that if we
2653 error out here, stack and registers remain untouched. */
2654 if (gdbarch_addr_bits_remove (gdbarch
, new_sp
) != new_sp
)
2655 error (_("Stack overflow"));
2657 /* Pass the structure return address in general register 2. */
2659 regcache_cooked_write_unsigned (regcache
, S390_R2_REGNUM
, struct_addr
);
2661 /* Initialize arg_state for "write mode". */
2662 arg_state
= arg_prep
;
2663 arg_state
.argp
= param_area_start
;
2664 arg_state
.regcache
= regcache
;
2666 /* Write all parameters. */
2667 for (i
= 0; i
< nargs
; i
++)
2668 s390_handle_arg (&arg_state
, args
[i
], tdep
, word_size
, byte_order
);
2670 /* Store return PSWA. In 31-bit mode, keep addressing mode bit. */
2674 regcache_cooked_read_unsigned (regcache
, S390_PSWA_REGNUM
, &pswa
);
2675 bp_addr
= (bp_addr
& 0x7fffffff) | (pswa
& 0x80000000);
2677 regcache_cooked_write_unsigned (regcache
, S390_RETADDR_REGNUM
, bp_addr
);
2679 /* Store updated stack pointer. */
2680 regcache_cooked_write_unsigned (regcache
, S390_SP_REGNUM
, new_sp
);
2682 /* We need to return the 'stack part' of the frame ID,
2683 which is actually the top of the register save area. */
2684 return param_area_start
;
2687 /* Assuming THIS_FRAME is a dummy, return the frame ID of that
2688 dummy frame. The frame ID's base needs to match the TOS value
2689 returned by push_dummy_call, and the PC match the dummy frame's
2691 static struct frame_id
2692 s390_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*this_frame
)
2694 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
2695 CORE_ADDR sp
= get_frame_register_unsigned (this_frame
, S390_SP_REGNUM
);
2696 sp
= gdbarch_addr_bits_remove (gdbarch
, sp
);
2698 return frame_id_build (sp
+ 16*word_size
+ 32,
2699 get_frame_pc (this_frame
));
2703 s390_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
2705 /* Both the 32- and 64-bit ABI's say that the stack pointer should
2706 always be aligned on an eight-byte boundary. */
2711 /* Function return value access. */
2713 static enum return_value_convention
2714 s390_return_value_convention (struct gdbarch
*gdbarch
, struct type
*type
)
2716 if (TYPE_LENGTH (type
) > 8)
2717 return RETURN_VALUE_STRUCT_CONVENTION
;
2719 switch (TYPE_CODE (type
))
2721 case TYPE_CODE_STRUCT
:
2722 case TYPE_CODE_UNION
:
2723 case TYPE_CODE_ARRAY
:
2724 case TYPE_CODE_COMPLEX
:
2725 return RETURN_VALUE_STRUCT_CONVENTION
;
2728 return RETURN_VALUE_REGISTER_CONVENTION
;
2732 static enum return_value_convention
2733 s390_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
2734 struct type
*type
, struct regcache
*regcache
,
2735 gdb_byte
*out
, const gdb_byte
*in
)
2737 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2738 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
2739 enum return_value_convention rvc
;
2742 type
= check_typedef (type
);
2743 rvc
= s390_return_value_convention (gdbarch
, type
);
2744 length
= TYPE_LENGTH (type
);
2750 case RETURN_VALUE_REGISTER_CONVENTION
:
2751 if (TYPE_CODE (type
) == TYPE_CODE_FLT
2752 || TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
2754 /* When we store a single-precision value in an FP register,
2755 it occupies the leftmost bits. */
2756 regcache_cooked_write_part (regcache
, S390_F0_REGNUM
,
2759 else if (length
<= word_size
)
2761 /* Integer arguments are always extended to word size. */
2762 if (TYPE_UNSIGNED (type
))
2763 regcache_cooked_write_unsigned (regcache
, S390_R2_REGNUM
,
2764 extract_unsigned_integer (in
, length
, byte_order
));
2766 regcache_cooked_write_signed (regcache
, S390_R2_REGNUM
,
2767 extract_signed_integer (in
, length
, byte_order
));
2769 else if (length
== 2*word_size
)
2771 regcache_cooked_write (regcache
, S390_R2_REGNUM
, in
);
2772 regcache_cooked_write (regcache
, S390_R3_REGNUM
, in
+ word_size
);
2775 internal_error (__FILE__
, __LINE__
, _("invalid return type"));
2778 case RETURN_VALUE_STRUCT_CONVENTION
:
2779 error (_("Cannot set function return value."));
2787 case RETURN_VALUE_REGISTER_CONVENTION
:
2788 if (TYPE_CODE (type
) == TYPE_CODE_FLT
2789 || TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
2791 /* When we store a single-precision value in an FP register,
2792 it occupies the leftmost bits. */
2793 regcache_cooked_read_part (regcache
, S390_F0_REGNUM
,
2796 else if (length
<= word_size
)
2798 /* Integer arguments occupy the rightmost bits. */
2799 regcache_cooked_read_part (regcache
, S390_R2_REGNUM
,
2800 word_size
- length
, length
, out
);
2802 else if (length
== 2*word_size
)
2804 regcache_cooked_read (regcache
, S390_R2_REGNUM
, out
);
2805 regcache_cooked_read (regcache
, S390_R3_REGNUM
, out
+ word_size
);
2808 internal_error (__FILE__
, __LINE__
, _("invalid return type"));
2811 case RETURN_VALUE_STRUCT_CONVENTION
:
2812 error (_("Function return value unknown."));
2823 static const gdb_byte
*
2824 s390_breakpoint_from_pc (struct gdbarch
*gdbarch
,
2825 CORE_ADDR
*pcptr
, int *lenptr
)
2827 static const gdb_byte breakpoint
[] = { 0x0, 0x1 };
2829 *lenptr
= sizeof (breakpoint
);
2834 /* Address handling. */
2837 s390_addr_bits_remove (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
2839 return addr
& 0x7fffffff;
2843 s390_address_class_type_flags (int byte_size
, int dwarf2_addr_class
)
2846 return TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1
;
2852 s390_address_class_type_flags_to_name (struct gdbarch
*gdbarch
, int type_flags
)
2854 if (type_flags
& TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1
)
2861 s390_address_class_name_to_type_flags (struct gdbarch
*gdbarch
,
2863 int *type_flags_ptr
)
2865 if (strcmp (name
, "mode32") == 0)
2867 *type_flags_ptr
= TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1
;
2874 /* Implement gdbarch_gcc_target_options. GCC does not know "-m32" or
2875 "-mcmodel=large". */
2878 s390_gcc_target_options (struct gdbarch
*gdbarch
)
2880 return xstrdup (gdbarch_ptr_bit (gdbarch
) == 64 ? "-m64" : "-m31");
2883 /* Implement gdbarch_gnu_triplet_regexp. Target triplets are "s390-*"
2884 for 31-bit and "s390x-*" for 64-bit, while the BFD arch name is
2885 always "s390". Note that an s390x compiler supports "-m31" as
2889 s390_gnu_triplet_regexp (struct gdbarch
*gdbarch
)
2894 /* Implementation of `gdbarch_stap_is_single_operand', as defined in
2898 s390_stap_is_single_operand (struct gdbarch
*gdbarch
, const char *s
)
2900 return ((isdigit (*s
) && s
[1] == '(' && s
[2] == '%') /* Displacement
2902 || *s
== '%' /* Register access. */
2903 || isdigit (*s
)); /* Literal number. */
2906 /* Set up gdbarch struct. */
2908 static struct gdbarch
*
2909 s390_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
2911 const struct target_desc
*tdesc
= info
.target_desc
;
2912 struct tdesc_arch_data
*tdesc_data
= NULL
;
2913 struct gdbarch
*gdbarch
;
2914 struct gdbarch_tdep
*tdep
;
2917 int have_linux_v1
= 0;
2918 int have_linux_v2
= 0;
2921 int first_pseudo_reg
, last_pseudo_reg
;
2922 static const char *const stap_register_prefixes
[] = { "%", NULL
};
2923 static const char *const stap_register_indirection_prefixes
[] = { "(",
2925 static const char *const stap_register_indirection_suffixes
[] = { ")",
2928 /* Default ABI and register size. */
2929 switch (info
.bfd_arch_info
->mach
)
2931 case bfd_mach_s390_31
:
2932 tdep_abi
= ABI_LINUX_S390
;
2935 case bfd_mach_s390_64
:
2936 tdep_abi
= ABI_LINUX_ZSERIES
;
2943 /* Use default target description if none provided by the target. */
2944 if (!tdesc_has_registers (tdesc
))
2946 if (tdep_abi
== ABI_LINUX_S390
)
2947 tdesc
= tdesc_s390_linux32
;
2949 tdesc
= tdesc_s390x_linux64
;
2952 /* Check any target description for validity. */
2953 if (tdesc_has_registers (tdesc
))
2955 static const char *const gprs
[] = {
2956 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2957 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
2959 static const char *const fprs
[] = {
2960 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
2961 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15"
2963 static const char *const acrs
[] = {
2964 "acr0", "acr1", "acr2", "acr3", "acr4", "acr5", "acr6", "acr7",
2965 "acr8", "acr9", "acr10", "acr11", "acr12", "acr13", "acr14", "acr15"
2967 static const char *const gprs_lower
[] = {
2968 "r0l", "r1l", "r2l", "r3l", "r4l", "r5l", "r6l", "r7l",
2969 "r8l", "r9l", "r10l", "r11l", "r12l", "r13l", "r14l", "r15l"
2971 static const char *const gprs_upper
[] = {
2972 "r0h", "r1h", "r2h", "r3h", "r4h", "r5h", "r6h", "r7h",
2973 "r8h", "r9h", "r10h", "r11h", "r12h", "r13h", "r14h", "r15h"
2975 static const char *const tdb_regs
[] = {
2976 "tdb0", "tac", "tct", "atia",
2977 "tr0", "tr1", "tr2", "tr3", "tr4", "tr5", "tr6", "tr7",
2978 "tr8", "tr9", "tr10", "tr11", "tr12", "tr13", "tr14", "tr15"
2980 static const char *const vxrs_low
[] = {
2981 "v0l", "v1l", "v2l", "v3l", "v4l", "v5l", "v6l", "v7l", "v8l",
2982 "v9l", "v10l", "v11l", "v12l", "v13l", "v14l", "v15l",
2984 static const char *const vxrs_high
[] = {
2985 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23", "v24",
2986 "v25", "v26", "v27", "v28", "v29", "v30", "v31",
2988 const struct tdesc_feature
*feature
;
2991 feature
= tdesc_find_feature (tdesc
, "org.gnu.gdb.s390.core");
2992 if (feature
== NULL
)
2995 tdesc_data
= tdesc_data_alloc ();
2997 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
2998 S390_PSWM_REGNUM
, "pswm");
2999 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
3000 S390_PSWA_REGNUM
, "pswa");
3002 if (tdesc_unnumbered_register (feature
, "r0"))
3004 for (i
= 0; i
< 16; i
++)
3005 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
3006 S390_R0_REGNUM
+ i
, gprs
[i
]);
3012 for (i
= 0; i
< 16; i
++)
3013 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
3016 for (i
= 0; i
< 16; i
++)
3017 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
3018 S390_R0_UPPER_REGNUM
+ i
,
3022 feature
= tdesc_find_feature (tdesc
, "org.gnu.gdb.s390.fpr");
3023 if (feature
== NULL
)
3025 tdesc_data_cleanup (tdesc_data
);
3029 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
3030 S390_FPC_REGNUM
, "fpc");
3031 for (i
= 0; i
< 16; i
++)
3032 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
3033 S390_F0_REGNUM
+ i
, fprs
[i
]);
3035 feature
= tdesc_find_feature (tdesc
, "org.gnu.gdb.s390.acr");
3036 if (feature
== NULL
)
3038 tdesc_data_cleanup (tdesc_data
);
3042 for (i
= 0; i
< 16; i
++)
3043 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
3044 S390_A0_REGNUM
+ i
, acrs
[i
]);
3046 /* Optional GNU/Linux-specific "registers". */
3047 feature
= tdesc_find_feature (tdesc
, "org.gnu.gdb.s390.linux");
3050 tdesc_numbered_register (feature
, tdesc_data
,
3051 S390_ORIG_R2_REGNUM
, "orig_r2");
3053 if (tdesc_numbered_register (feature
, tdesc_data
,
3054 S390_LAST_BREAK_REGNUM
, "last_break"))
3057 if (tdesc_numbered_register (feature
, tdesc_data
,
3058 S390_SYSTEM_CALL_REGNUM
, "system_call"))
3061 if (have_linux_v2
> have_linux_v1
)
3065 /* Transaction diagnostic block. */
3066 feature
= tdesc_find_feature (tdesc
, "org.gnu.gdb.s390.tdb");
3069 for (i
= 0; i
< ARRAY_SIZE (tdb_regs
); i
++)
3070 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
3071 S390_TDB_DWORD0_REGNUM
+ i
,
3076 /* Vector registers. */
3077 feature
= tdesc_find_feature (tdesc
, "org.gnu.gdb.s390.vx");
3080 for (i
= 0; i
< 16; i
++)
3081 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
3082 S390_V0_LOWER_REGNUM
+ i
,
3084 for (i
= 0; i
< 16; i
++)
3085 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
3086 S390_V16_REGNUM
+ i
,
3093 tdesc_data_cleanup (tdesc_data
);
3098 /* Find a candidate among extant architectures. */
3099 for (arches
= gdbarch_list_lookup_by_info (arches
, &info
);
3101 arches
= gdbarch_list_lookup_by_info (arches
->next
, &info
))
3103 tdep
= gdbarch_tdep (arches
->gdbarch
);
3106 if (tdep
->abi
!= tdep_abi
)
3108 if ((tdep
->gpr_full_regnum
!= -1) != have_upper
)
3110 if (tdesc_data
!= NULL
)
3111 tdesc_data_cleanup (tdesc_data
);
3112 return arches
->gdbarch
;
3115 /* Otherwise create a new gdbarch for the specified machine type. */
3116 tdep
= XCNEW (struct gdbarch_tdep
);
3117 tdep
->abi
= tdep_abi
;
3118 tdep
->have_linux_v1
= have_linux_v1
;
3119 tdep
->have_linux_v2
= have_linux_v2
;
3120 tdep
->have_tdb
= have_tdb
;
3121 gdbarch
= gdbarch_alloc (&info
, tdep
);
3123 set_gdbarch_believe_pcc_promotion (gdbarch
, 0);
3124 set_gdbarch_char_signed (gdbarch
, 0);
3126 /* S/390 GNU/Linux uses either 64-bit or 128-bit long doubles.
3127 We can safely let them default to 128-bit, since the debug info
3128 will give the size of type actually used in each case. */
3129 set_gdbarch_long_double_bit (gdbarch
, 128);
3130 set_gdbarch_long_double_format (gdbarch
, floatformats_ia64_quad
);
3132 /* Amount PC must be decremented by after a breakpoint. This is
3133 often the number of bytes returned by gdbarch_breakpoint_from_pc but not
3135 set_gdbarch_decr_pc_after_break (gdbarch
, 2);
3136 /* Stack grows downward. */
3137 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
3138 set_gdbarch_breakpoint_from_pc (gdbarch
, s390_breakpoint_from_pc
);
3139 set_gdbarch_skip_prologue (gdbarch
, s390_skip_prologue
);
3140 set_gdbarch_in_function_epilogue_p (gdbarch
, s390_in_function_epilogue_p
);
3142 set_gdbarch_num_regs (gdbarch
, S390_NUM_REGS
);
3143 set_gdbarch_sp_regnum (gdbarch
, S390_SP_REGNUM
);
3144 set_gdbarch_fp0_regnum (gdbarch
, S390_F0_REGNUM
);
3145 set_gdbarch_stab_reg_to_regnum (gdbarch
, s390_dwarf_reg_to_regnum
);
3146 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, s390_dwarf_reg_to_regnum
);
3147 set_gdbarch_value_from_register (gdbarch
, s390_value_from_register
);
3148 set_gdbarch_core_read_description (gdbarch
, s390_core_read_description
);
3149 set_gdbarch_iterate_over_regset_sections (gdbarch
,
3150 s390_iterate_over_regset_sections
);
3151 set_gdbarch_cannot_store_register (gdbarch
, s390_cannot_store_register
);
3152 set_gdbarch_write_pc (gdbarch
, s390_write_pc
);
3153 set_gdbarch_pseudo_register_read (gdbarch
, s390_pseudo_register_read
);
3154 set_gdbarch_pseudo_register_write (gdbarch
, s390_pseudo_register_write
);
3155 set_tdesc_pseudo_register_name (gdbarch
, s390_pseudo_register_name
);
3156 set_tdesc_pseudo_register_type (gdbarch
, s390_pseudo_register_type
);
3157 set_tdesc_pseudo_register_reggroup_p (gdbarch
,
3158 s390_pseudo_register_reggroup_p
);
3159 tdesc_use_registers (gdbarch
, tdesc
, tdesc_data
);
3160 set_gdbarch_register_name (gdbarch
, s390_register_name
);
3162 /* Assign pseudo register numbers. */
3163 first_pseudo_reg
= gdbarch_num_regs (gdbarch
);
3164 last_pseudo_reg
= first_pseudo_reg
;
3165 tdep
->gpr_full_regnum
= -1;
3168 tdep
->gpr_full_regnum
= last_pseudo_reg
;
3169 last_pseudo_reg
+= 16;
3171 tdep
->v0_full_regnum
= -1;
3174 tdep
->v0_full_regnum
= last_pseudo_reg
;
3175 last_pseudo_reg
+= 16;
3177 tdep
->pc_regnum
= last_pseudo_reg
++;
3178 tdep
->cc_regnum
= last_pseudo_reg
++;
3179 set_gdbarch_pc_regnum (gdbarch
, tdep
->pc_regnum
);
3180 set_gdbarch_num_pseudo_regs (gdbarch
, last_pseudo_reg
- first_pseudo_reg
);
3182 /* Inferior function calls. */
3183 set_gdbarch_push_dummy_call (gdbarch
, s390_push_dummy_call
);
3184 set_gdbarch_dummy_id (gdbarch
, s390_dummy_id
);
3185 set_gdbarch_frame_align (gdbarch
, s390_frame_align
);
3186 set_gdbarch_return_value (gdbarch
, s390_return_value
);
3188 /* Syscall handling. */
3189 set_gdbarch_get_syscall_number (gdbarch
, s390_linux_get_syscall_number
);
3191 /* Frame handling. */
3192 dwarf2_frame_set_init_reg (gdbarch
, s390_dwarf2_frame_init_reg
);
3193 dwarf2_frame_set_adjust_regnum (gdbarch
, s390_adjust_frame_regnum
);
3194 dwarf2_append_unwinders (gdbarch
);
3195 frame_base_append_sniffer (gdbarch
, dwarf2_frame_base_sniffer
);
3196 frame_unwind_append_unwinder (gdbarch
, &s390_stub_frame_unwind
);
3197 frame_unwind_append_unwinder (gdbarch
, &s390_sigtramp_frame_unwind
);
3198 frame_unwind_append_unwinder (gdbarch
, &s390_frame_unwind
);
3199 frame_base_set_default (gdbarch
, &s390_frame_base
);
3200 set_gdbarch_unwind_pc (gdbarch
, s390_unwind_pc
);
3201 set_gdbarch_unwind_sp (gdbarch
, s390_unwind_sp
);
3203 /* Displaced stepping. */
3204 set_gdbarch_displaced_step_copy_insn (gdbarch
,
3205 simple_displaced_step_copy_insn
);
3206 set_gdbarch_displaced_step_fixup (gdbarch
, s390_displaced_step_fixup
);
3207 set_gdbarch_displaced_step_free_closure (gdbarch
,
3208 simple_displaced_step_free_closure
);
3209 set_gdbarch_displaced_step_location (gdbarch
, linux_displaced_step_location
);
3210 set_gdbarch_max_insn_length (gdbarch
, S390_MAX_INSTR_SIZE
);
3212 /* Note that GNU/Linux is the only OS supported on this
3214 linux_init_abi (info
, gdbarch
);
3218 case ABI_LINUX_S390
:
3219 set_gdbarch_addr_bits_remove (gdbarch
, s390_addr_bits_remove
);
3220 set_solib_svr4_fetch_link_map_offsets
3221 (gdbarch
, svr4_ilp32_fetch_link_map_offsets
);
3223 set_xml_syscall_file_name (gdbarch
, XML_SYSCALL_FILENAME_S390
);
3226 case ABI_LINUX_ZSERIES
:
3227 set_gdbarch_long_bit (gdbarch
, 64);
3228 set_gdbarch_long_long_bit (gdbarch
, 64);
3229 set_gdbarch_ptr_bit (gdbarch
, 64);
3230 set_solib_svr4_fetch_link_map_offsets
3231 (gdbarch
, svr4_lp64_fetch_link_map_offsets
);
3232 set_gdbarch_address_class_type_flags (gdbarch
,
3233 s390_address_class_type_flags
);
3234 set_gdbarch_address_class_type_flags_to_name (gdbarch
,
3235 s390_address_class_type_flags_to_name
);
3236 set_gdbarch_address_class_name_to_type_flags (gdbarch
,
3237 s390_address_class_name_to_type_flags
);
3238 set_xml_syscall_file_name (gdbarch
, XML_SYSCALL_FILENAME_S390X
);
3242 set_gdbarch_print_insn (gdbarch
, print_insn_s390
);
3244 set_gdbarch_skip_trampoline_code (gdbarch
, find_solib_trampoline_target
);
3246 /* Enable TLS support. */
3247 set_gdbarch_fetch_tls_load_module_address (gdbarch
,
3248 svr4_fetch_objfile_link_map
);
3250 set_gdbarch_get_siginfo_type (gdbarch
, linux_get_siginfo_type
);
3252 /* SystemTap functions. */
3253 set_gdbarch_stap_register_prefixes (gdbarch
, stap_register_prefixes
);
3254 set_gdbarch_stap_register_indirection_prefixes (gdbarch
,
3255 stap_register_indirection_prefixes
);
3256 set_gdbarch_stap_register_indirection_suffixes (gdbarch
,
3257 stap_register_indirection_suffixes
);
3258 set_gdbarch_stap_is_single_operand (gdbarch
, s390_stap_is_single_operand
);
3259 set_gdbarch_gcc_target_options (gdbarch
, s390_gcc_target_options
);
3260 set_gdbarch_gnu_triplet_regexp (gdbarch
, s390_gnu_triplet_regexp
);
3266 extern initialize_file_ftype _initialize_s390_tdep
; /* -Wmissing-prototypes */
3269 _initialize_s390_tdep (void)
3271 /* Hook us into the gdbarch mechanism. */
3272 register_gdbarch_init (bfd_arch_s390
, s390_gdbarch_init
);
3274 /* Initialize the GNU/Linux target descriptions. */
3275 initialize_tdesc_s390_linux32 ();
3276 initialize_tdesc_s390_linux32v1 ();
3277 initialize_tdesc_s390_linux32v2 ();
3278 initialize_tdesc_s390_linux64 ();
3279 initialize_tdesc_s390_linux64v1 ();
3280 initialize_tdesc_s390_linux64v2 ();
3281 initialize_tdesc_s390_te_linux64 ();
3282 initialize_tdesc_s390_vx_linux64 ();
3283 initialize_tdesc_s390_tevx_linux64 ();
3284 initialize_tdesc_s390x_linux64 ();
3285 initialize_tdesc_s390x_linux64v1 ();
3286 initialize_tdesc_s390x_linux64v2 ();
3287 initialize_tdesc_s390x_te_linux64 ();
3288 initialize_tdesc_s390x_vx_linux64 ();
3289 initialize_tdesc_s390x_tevx_linux64 ();