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/s390x-linux64.c"
66 #include "features/s390x-linux64v1.c"
67 #include "features/s390x-linux64v2.c"
68 #include "features/s390x-te-linux64.c"
70 #define XML_SYSCALL_FILENAME_S390 "syscalls/s390-linux.xml"
71 #define XML_SYSCALL_FILENAME_S390X "syscalls/s390x-linux.xml"
79 /* The tdep structure. */
84 enum s390_abi_kind abi
;
86 /* Pseudo register numbers. */
97 /* ABI call-saved register information. */
100 s390_register_call_saved (struct gdbarch
*gdbarch
, int regnum
)
102 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
107 if ((regnum
>= S390_R6_REGNUM
&& regnum
<= S390_R15_REGNUM
)
108 || regnum
== S390_F4_REGNUM
|| regnum
== S390_F6_REGNUM
109 || regnum
== S390_A0_REGNUM
)
114 case ABI_LINUX_ZSERIES
:
115 if ((regnum
>= S390_R6_REGNUM
&& regnum
<= S390_R15_REGNUM
)
116 || (regnum
>= S390_F8_REGNUM
&& regnum
<= S390_F15_REGNUM
)
117 || (regnum
>= S390_A0_REGNUM
&& regnum
<= S390_A1_REGNUM
))
127 s390_cannot_store_register (struct gdbarch
*gdbarch
, int regnum
)
129 /* The last-break address is read-only. */
130 return regnum
== S390_LAST_BREAK_REGNUM
;
134 s390_write_pc (struct regcache
*regcache
, CORE_ADDR pc
)
136 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
137 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
139 regcache_cooked_write_unsigned (regcache
, tdep
->pc_regnum
, pc
);
141 /* Set special SYSTEM_CALL register to 0 to prevent the kernel from
142 messing with the PC we just installed, if we happen to be within
143 an interrupted system call that the kernel wants to restart.
145 Note that after we return from the dummy call, the SYSTEM_CALL and
146 ORIG_R2 registers will be automatically restored, and the kernel
147 continues to restart the system call at this point. */
148 if (register_size (gdbarch
, S390_SYSTEM_CALL_REGNUM
) > 0)
149 regcache_cooked_write_unsigned (regcache
, S390_SYSTEM_CALL_REGNUM
, 0);
153 /* DWARF Register Mapping. */
155 static const short s390_dwarf_regmap
[] =
157 /* General Purpose Registers. */
158 S390_R0_REGNUM
, S390_R1_REGNUM
, S390_R2_REGNUM
, S390_R3_REGNUM
,
159 S390_R4_REGNUM
, S390_R5_REGNUM
, S390_R6_REGNUM
, S390_R7_REGNUM
,
160 S390_R8_REGNUM
, S390_R9_REGNUM
, S390_R10_REGNUM
, S390_R11_REGNUM
,
161 S390_R12_REGNUM
, S390_R13_REGNUM
, S390_R14_REGNUM
, S390_R15_REGNUM
,
163 /* Floating Point Registers. */
164 S390_F0_REGNUM
, S390_F2_REGNUM
, S390_F4_REGNUM
, S390_F6_REGNUM
,
165 S390_F1_REGNUM
, S390_F3_REGNUM
, S390_F5_REGNUM
, S390_F7_REGNUM
,
166 S390_F8_REGNUM
, S390_F10_REGNUM
, S390_F12_REGNUM
, S390_F14_REGNUM
,
167 S390_F9_REGNUM
, S390_F11_REGNUM
, S390_F13_REGNUM
, S390_F15_REGNUM
,
169 /* Control Registers (not mapped). */
170 -1, -1, -1, -1, -1, -1, -1, -1,
171 -1, -1, -1, -1, -1, -1, -1, -1,
173 /* Access Registers. */
174 S390_A0_REGNUM
, S390_A1_REGNUM
, S390_A2_REGNUM
, S390_A3_REGNUM
,
175 S390_A4_REGNUM
, S390_A5_REGNUM
, S390_A6_REGNUM
, S390_A7_REGNUM
,
176 S390_A8_REGNUM
, S390_A9_REGNUM
, S390_A10_REGNUM
, S390_A11_REGNUM
,
177 S390_A12_REGNUM
, S390_A13_REGNUM
, S390_A14_REGNUM
, S390_A15_REGNUM
,
179 /* Program Status Word. */
183 /* GPR Lower Half Access. */
184 S390_R0_REGNUM
, S390_R1_REGNUM
, S390_R2_REGNUM
, S390_R3_REGNUM
,
185 S390_R4_REGNUM
, S390_R5_REGNUM
, S390_R6_REGNUM
, S390_R7_REGNUM
,
186 S390_R8_REGNUM
, S390_R9_REGNUM
, S390_R10_REGNUM
, S390_R11_REGNUM
,
187 S390_R12_REGNUM
, S390_R13_REGNUM
, S390_R14_REGNUM
, S390_R15_REGNUM
,
189 /* GNU/Linux-specific registers (not mapped). */
193 /* Convert DWARF register number REG to the appropriate register
194 number used by GDB. */
196 s390_dwarf_reg_to_regnum (struct gdbarch
*gdbarch
, int reg
)
198 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
200 /* In a 32-on-64 debug scenario, debug info refers to the full 64-bit
201 GPRs. Note that call frame information still refers to the 32-bit
202 lower halves, because s390_adjust_frame_regnum uses register numbers
203 66 .. 81 to access GPRs. */
204 if (tdep
->gpr_full_regnum
!= -1 && reg
>= 0 && reg
< 16)
205 return tdep
->gpr_full_regnum
+ reg
;
207 if (reg
>= 0 && reg
< ARRAY_SIZE (s390_dwarf_regmap
))
208 return s390_dwarf_regmap
[reg
];
210 warning (_("Unmapped DWARF Register #%d encountered."), reg
);
214 /* Translate a .eh_frame register to DWARF register, or adjust a
215 .debug_frame register. */
217 s390_adjust_frame_regnum (struct gdbarch
*gdbarch
, int num
, int eh_frame_p
)
219 /* See s390_dwarf_reg_to_regnum for comments. */
220 return (num
>= 0 && num
< 16)? num
+ 66 : num
;
224 /* Pseudo registers. */
227 regnum_is_gpr_full (struct gdbarch_tdep
*tdep
, int regnum
)
229 return (tdep
->gpr_full_regnum
!= -1
230 && regnum
>= tdep
->gpr_full_regnum
231 && regnum
<= tdep
->gpr_full_regnum
+ 15);
235 s390_pseudo_register_name (struct gdbarch
*gdbarch
, int regnum
)
237 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
239 if (regnum
== tdep
->pc_regnum
)
242 if (regnum
== tdep
->cc_regnum
)
245 if (regnum_is_gpr_full (tdep
, regnum
))
247 static const char *full_name
[] = {
248 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
249 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
251 return full_name
[regnum
- tdep
->gpr_full_regnum
];
254 internal_error (__FILE__
, __LINE__
, _("invalid regnum"));
258 s390_pseudo_register_type (struct gdbarch
*gdbarch
, int regnum
)
260 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
262 if (regnum
== tdep
->pc_regnum
)
263 return builtin_type (gdbarch
)->builtin_func_ptr
;
265 if (regnum
== tdep
->cc_regnum
)
266 return builtin_type (gdbarch
)->builtin_int
;
268 if (regnum_is_gpr_full (tdep
, regnum
))
269 return builtin_type (gdbarch
)->builtin_uint64
;
271 internal_error (__FILE__
, __LINE__
, _("invalid regnum"));
274 static enum register_status
275 s390_pseudo_register_read (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
276 int regnum
, gdb_byte
*buf
)
278 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
279 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
280 int regsize
= register_size (gdbarch
, regnum
);
283 if (regnum
== tdep
->pc_regnum
)
285 enum register_status status
;
287 status
= regcache_raw_read_unsigned (regcache
, S390_PSWA_REGNUM
, &val
);
288 if (status
== REG_VALID
)
290 if (register_size (gdbarch
, S390_PSWA_REGNUM
) == 4)
292 store_unsigned_integer (buf
, regsize
, byte_order
, val
);
297 if (regnum
== tdep
->cc_regnum
)
299 enum register_status status
;
301 status
= regcache_raw_read_unsigned (regcache
, S390_PSWM_REGNUM
, &val
);
302 if (status
== REG_VALID
)
304 if (register_size (gdbarch
, S390_PSWA_REGNUM
) == 4)
305 val
= (val
>> 12) & 3;
307 val
= (val
>> 44) & 3;
308 store_unsigned_integer (buf
, regsize
, byte_order
, val
);
313 if (regnum_is_gpr_full (tdep
, regnum
))
315 enum register_status status
;
318 regnum
-= tdep
->gpr_full_regnum
;
320 status
= regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ regnum
, &val
);
321 if (status
== REG_VALID
)
322 status
= regcache_raw_read_unsigned (regcache
, S390_R0_UPPER_REGNUM
+ regnum
,
324 if (status
== REG_VALID
)
326 val
|= val_upper
<< 32;
327 store_unsigned_integer (buf
, regsize
, byte_order
, val
);
332 internal_error (__FILE__
, __LINE__
, _("invalid regnum"));
336 s390_pseudo_register_write (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
337 int regnum
, const gdb_byte
*buf
)
339 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
340 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
341 int regsize
= register_size (gdbarch
, regnum
);
344 if (regnum
== tdep
->pc_regnum
)
346 val
= extract_unsigned_integer (buf
, regsize
, byte_order
);
347 if (register_size (gdbarch
, S390_PSWA_REGNUM
) == 4)
349 regcache_raw_read_unsigned (regcache
, S390_PSWA_REGNUM
, &psw
);
350 val
= (psw
& 0x80000000) | (val
& 0x7fffffff);
352 regcache_raw_write_unsigned (regcache
, S390_PSWA_REGNUM
, val
);
356 if (regnum
== tdep
->cc_regnum
)
358 val
= extract_unsigned_integer (buf
, regsize
, byte_order
);
359 regcache_raw_read_unsigned (regcache
, S390_PSWM_REGNUM
, &psw
);
360 if (register_size (gdbarch
, S390_PSWA_REGNUM
) == 4)
361 val
= (psw
& ~((ULONGEST
)3 << 12)) | ((val
& 3) << 12);
363 val
= (psw
& ~((ULONGEST
)3 << 44)) | ((val
& 3) << 44);
364 regcache_raw_write_unsigned (regcache
, S390_PSWM_REGNUM
, val
);
368 if (regnum_is_gpr_full (tdep
, regnum
))
370 regnum
-= tdep
->gpr_full_regnum
;
371 val
= extract_unsigned_integer (buf
, regsize
, byte_order
);
372 regcache_raw_write_unsigned (regcache
, S390_R0_REGNUM
+ regnum
,
374 regcache_raw_write_unsigned (regcache
, S390_R0_UPPER_REGNUM
+ regnum
,
379 internal_error (__FILE__
, __LINE__
, _("invalid regnum"));
382 /* 'float' values are stored in the upper half of floating-point
383 registers, even though we are otherwise a big-endian platform. */
385 static struct value
*
386 s390_value_from_register (struct gdbarch
*gdbarch
, struct type
*type
,
387 int regnum
, struct frame_id frame_id
)
389 struct value
*value
= default_value_from_register (gdbarch
, type
,
391 check_typedef (type
);
393 if (regnum
>= S390_F0_REGNUM
&& regnum
<= S390_F15_REGNUM
394 && TYPE_LENGTH (type
) < 8)
395 set_value_offset (value
, 0);
400 /* Register groups. */
403 s390_pseudo_register_reggroup_p (struct gdbarch
*gdbarch
, int regnum
,
404 struct reggroup
*group
)
406 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
408 /* We usually save/restore the whole PSW, which includes PC and CC.
409 However, some older gdbservers may not support saving/restoring
410 the whole PSW yet, and will return an XML register description
411 excluding those from the save/restore register groups. In those
412 cases, we still need to explicitly save/restore PC and CC in order
413 to push or pop frames. Since this doesn't hurt anything if we
414 already save/restore the whole PSW (it's just redundant), we add
415 PC and CC at this point unconditionally. */
416 if (group
== save_reggroup
|| group
== restore_reggroup
)
417 return regnum
== tdep
->pc_regnum
|| regnum
== tdep
->cc_regnum
;
419 return default_register_reggroup_p (gdbarch
, regnum
, group
);
423 /* Maps for register sets. */
425 static const struct regcache_map_entry s390_gregmap
[] =
427 { 1, S390_PSWM_REGNUM
},
428 { 1, S390_PSWA_REGNUM
},
429 { 16, S390_R0_REGNUM
},
430 { 16, S390_A0_REGNUM
},
431 { 1, S390_ORIG_R2_REGNUM
},
435 static const struct regcache_map_entry s390_fpregmap
[] =
437 { 1, S390_FPC_REGNUM
, 8 },
438 { 16, S390_F0_REGNUM
, 8 },
442 static const struct regcache_map_entry s390_regmap_upper
[] =
444 { 16, S390_R0_UPPER_REGNUM
, 4 },
448 static const struct regcache_map_entry s390_regmap_last_break
[] =
450 { 1, REGCACHE_MAP_SKIP
, 4 },
451 { 1, S390_LAST_BREAK_REGNUM
, 4 },
455 static const struct regcache_map_entry s390x_regmap_last_break
[] =
457 { 1, S390_LAST_BREAK_REGNUM
, 8 },
461 static const struct regcache_map_entry s390_regmap_system_call
[] =
463 { 1, S390_SYSTEM_CALL_REGNUM
, 4 },
467 static const struct regcache_map_entry s390_regmap_tdb
[] =
469 { 1, S390_TDB_DWORD0_REGNUM
, 8 },
470 { 1, S390_TDB_ABORT_CODE_REGNUM
, 8 },
471 { 1, S390_TDB_CONFLICT_TOKEN_REGNUM
, 8 },
472 { 1, S390_TDB_ATIA_REGNUM
, 8 },
473 { 12, REGCACHE_MAP_SKIP
, 8 },
474 { 16, S390_TDB_R0_REGNUM
, 8 },
479 /* Supply the TDB regset. Like regcache_supply_regset, but invalidate
480 the TDB registers unless the TDB format field is valid. */
483 s390_supply_tdb_regset (const struct regset
*regset
, struct regcache
*regcache
,
484 int regnum
, const void *regs
, size_t len
)
487 enum register_status ret
;
490 regcache_supply_regset (regset
, regcache
, regnum
, regs
, len
);
491 ret
= regcache_cooked_read_unsigned (regcache
, S390_TDB_DWORD0_REGNUM
, &tdw
);
492 if (ret
!= REG_VALID
|| (tdw
>> 56) != 1)
493 regcache_supply_regset (regset
, regcache
, regnum
, NULL
, len
);
496 const struct regset s390_gregset
= {
498 regcache_supply_regset
,
499 regcache_collect_regset
502 const struct regset s390_fpregset
= {
504 regcache_supply_regset
,
505 regcache_collect_regset
508 static const struct regset s390_upper_regset
= {
510 regcache_supply_regset
,
511 regcache_collect_regset
514 const struct regset s390_last_break_regset
= {
515 s390_regmap_last_break
,
516 regcache_supply_regset
,
517 regcache_collect_regset
520 const struct regset s390x_last_break_regset
= {
521 s390x_regmap_last_break
,
522 regcache_supply_regset
,
523 regcache_collect_regset
526 const struct regset s390_system_call_regset
= {
527 s390_regmap_system_call
,
528 regcache_supply_regset
,
529 regcache_collect_regset
532 const struct regset s390_tdb_regset
= {
534 s390_supply_tdb_regset
,
535 regcache_collect_regset
538 /* Iterate over supported core file register note sections. */
541 s390_iterate_over_regset_sections (struct gdbarch
*gdbarch
,
542 iterate_over_regset_sections_cb
*cb
,
544 const struct regcache
*regcache
)
546 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
547 const int gregset_size
= (tdep
->abi
== ABI_LINUX_S390
?
548 s390_sizeof_gregset
: s390x_sizeof_gregset
);
550 cb (".reg", gregset_size
, &s390_gregset
, NULL
, cb_data
);
551 cb (".reg2", s390_sizeof_fpregset
, &s390_fpregset
, NULL
, cb_data
);
553 if (tdep
->abi
== ABI_LINUX_S390
&& tdep
->gpr_full_regnum
!= -1)
554 cb (".reg-s390-high-gprs", 16 * 4, &s390_upper_regset
,
555 "s390 GPR upper halves", cb_data
);
557 if (tdep
->have_linux_v1
)
558 cb (".reg-s390-last-break", 8,
559 (gdbarch_ptr_bit (gdbarch
) == 32
560 ? &s390_last_break_regset
: &s390x_last_break_regset
),
561 "s930 last-break address", cb_data
);
563 if (tdep
->have_linux_v2
)
564 cb (".reg-s390-system-call", 4, &s390_system_call_regset
,
565 "s390 system-call", cb_data
);
567 /* If regcache is set, we are in "write" (gcore) mode. In this
568 case, don't iterate over the TDB unless its registers are
572 || REG_VALID
== regcache_register_status (regcache
,
573 S390_TDB_DWORD0_REGNUM
)))
574 cb (".reg-s390-tdb", s390_sizeof_tdbregset
, &s390_tdb_regset
,
575 "s390 TDB", cb_data
);
578 static const struct target_desc
*
579 s390_core_read_description (struct gdbarch
*gdbarch
,
580 struct target_ops
*target
, bfd
*abfd
)
582 asection
*high_gprs
= bfd_get_section_by_name (abfd
, ".reg-s390-high-gprs");
583 asection
*v1
= bfd_get_section_by_name (abfd
, ".reg-s390-last-break");
584 asection
*v2
= bfd_get_section_by_name (abfd
, ".reg-s390-system-call");
585 asection
*section
= bfd_get_section_by_name (abfd
, ".reg");
588 target_auxv_search (target
, AT_HWCAP
, &hwcap
);
592 switch (bfd_section_size (abfd
, section
))
594 case s390_sizeof_gregset
:
596 return ((hwcap
& HWCAP_S390_TE
) ? tdesc_s390_te_linux64
:
597 v2
? tdesc_s390_linux64v2
:
598 v1
? tdesc_s390_linux64v1
: tdesc_s390_linux64
);
600 return (v2
? tdesc_s390_linux32v2
:
601 v1
? tdesc_s390_linux32v1
: tdesc_s390_linux32
);
603 case s390x_sizeof_gregset
:
604 return ((hwcap
& HWCAP_S390_TE
) ? tdesc_s390x_te_linux64
:
605 v2
? tdesc_s390x_linux64v2
:
606 v1
? tdesc_s390x_linux64v1
: tdesc_s390x_linux64
);
614 /* Decoding S/390 instructions. */
616 /* Named opcode values for the S/390 instructions we recognize. Some
617 instructions have their opcode split across two fields; those are the
618 op1_* and op2_* enums. */
621 op1_lhi
= 0xa7, op2_lhi
= 0x08,
622 op1_lghi
= 0xa7, op2_lghi
= 0x09,
623 op1_lgfi
= 0xc0, op2_lgfi
= 0x01,
627 op1_ly
= 0xe3, op2_ly
= 0x58,
628 op1_lg
= 0xe3, op2_lg
= 0x04,
630 op1_lmy
= 0xeb, op2_lmy
= 0x98,
631 op1_lmg
= 0xeb, op2_lmg
= 0x04,
633 op1_sty
= 0xe3, op2_sty
= 0x50,
634 op1_stg
= 0xe3, op2_stg
= 0x24,
637 op1_stmy
= 0xeb, op2_stmy
= 0x90,
638 op1_stmg
= 0xeb, op2_stmg
= 0x24,
639 op1_aghi
= 0xa7, op2_aghi
= 0x0b,
640 op1_ahi
= 0xa7, op2_ahi
= 0x0a,
641 op1_agfi
= 0xc2, op2_agfi
= 0x08,
642 op1_afi
= 0xc2, op2_afi
= 0x09,
643 op1_algfi
= 0xc2, op2_algfi
= 0x0a,
644 op1_alfi
= 0xc2, op2_alfi
= 0x0b,
648 op1_ay
= 0xe3, op2_ay
= 0x5a,
649 op1_ag
= 0xe3, op2_ag
= 0x08,
650 op1_slgfi
= 0xc2, op2_slgfi
= 0x04,
651 op1_slfi
= 0xc2, op2_slfi
= 0x05,
655 op1_sy
= 0xe3, op2_sy
= 0x5b,
656 op1_sg
= 0xe3, op2_sg
= 0x09,
660 op1_lay
= 0xe3, op2_lay
= 0x71,
661 op1_larl
= 0xc0, op2_larl
= 0x00,
669 op1_bctg
= 0xe3, op2_bctg
= 0x46,
671 op1_bxhg
= 0xeb, op2_bxhg
= 0x44,
673 op1_bxleg
= 0xeb, op2_bxleg
= 0x45,
674 op1_bras
= 0xa7, op2_bras
= 0x05,
675 op1_brasl
= 0xc0, op2_brasl
= 0x05,
676 op1_brc
= 0xa7, op2_brc
= 0x04,
677 op1_brcl
= 0xc0, op2_brcl
= 0x04,
678 op1_brct
= 0xa7, op2_brct
= 0x06,
679 op1_brctg
= 0xa7, op2_brctg
= 0x07,
681 op1_brxhg
= 0xec, op2_brxhg
= 0x44,
683 op1_brxlg
= 0xec, op2_brxlg
= 0x45,
688 /* Read a single instruction from address AT. */
690 #define S390_MAX_INSTR_SIZE 6
692 s390_readinstruction (bfd_byte instr
[], CORE_ADDR at
)
694 static int s390_instrlen
[] = { 2, 4, 4, 6 };
697 if (target_read_memory (at
, &instr
[0], 2))
699 instrlen
= s390_instrlen
[instr
[0] >> 6];
702 if (target_read_memory (at
+ 2, &instr
[2], instrlen
- 2))
709 /* The functions below are for recognizing and decoding S/390
710 instructions of various formats. Each of them checks whether INSN
711 is an instruction of the given format, with the specified opcodes.
712 If it is, it sets the remaining arguments to the values of the
713 instruction's fields, and returns a non-zero value; otherwise, it
716 These functions' arguments appear in the order they appear in the
717 instruction, not in the machine-language form. So, opcodes always
718 come first, even though they're sometimes scattered around the
719 instructions. And displacements appear before base and extension
720 registers, as they do in the assembly syntax, not at the end, as
721 they do in the machine language. */
723 is_ri (bfd_byte
*insn
, int op1
, int op2
, unsigned int *r1
, int *i2
)
725 if (insn
[0] == op1
&& (insn
[1] & 0xf) == op2
)
727 *r1
= (insn
[1] >> 4) & 0xf;
728 /* i2 is a 16-bit signed quantity. */
729 *i2
= (((insn
[2] << 8) | insn
[3]) ^ 0x8000) - 0x8000;
738 is_ril (bfd_byte
*insn
, int op1
, int op2
,
739 unsigned int *r1
, int *i2
)
741 if (insn
[0] == op1
&& (insn
[1] & 0xf) == op2
)
743 *r1
= (insn
[1] >> 4) & 0xf;
744 /* i2 is a signed quantity. If the host 'int' is 32 bits long,
745 no sign extension is necessary, but we don't want to assume
747 *i2
= (((insn
[2] << 24)
750 | (insn
[5])) ^ 0x80000000) - 0x80000000;
759 is_rr (bfd_byte
*insn
, int op
, unsigned int *r1
, unsigned int *r2
)
763 *r1
= (insn
[1] >> 4) & 0xf;
773 is_rre (bfd_byte
*insn
, int op
, unsigned int *r1
, unsigned int *r2
)
775 if (((insn
[0] << 8) | insn
[1]) == op
)
777 /* Yes, insn[3]. insn[2] is unused in RRE format. */
778 *r1
= (insn
[3] >> 4) & 0xf;
788 is_rs (bfd_byte
*insn
, int op
,
789 unsigned int *r1
, unsigned int *r3
, int *d2
, unsigned int *b2
)
793 *r1
= (insn
[1] >> 4) & 0xf;
795 *b2
= (insn
[2] >> 4) & 0xf;
796 *d2
= ((insn
[2] & 0xf) << 8) | insn
[3];
805 is_rsy (bfd_byte
*insn
, int op1
, int op2
,
806 unsigned int *r1
, unsigned int *r3
, int *d2
, unsigned int *b2
)
811 *r1
= (insn
[1] >> 4) & 0xf;
813 *b2
= (insn
[2] >> 4) & 0xf;
814 /* The 'long displacement' is a 20-bit signed integer. */
815 *d2
= ((((insn
[2] & 0xf) << 8) | insn
[3] | (insn
[4] << 12))
816 ^ 0x80000) - 0x80000;
825 is_rsi (bfd_byte
*insn
, int op
,
826 unsigned int *r1
, unsigned int *r3
, int *i2
)
830 *r1
= (insn
[1] >> 4) & 0xf;
832 /* i2 is a 16-bit signed quantity. */
833 *i2
= (((insn
[2] << 8) | insn
[3]) ^ 0x8000) - 0x8000;
842 is_rie (bfd_byte
*insn
, int op1
, int op2
,
843 unsigned int *r1
, unsigned int *r3
, int *i2
)
848 *r1
= (insn
[1] >> 4) & 0xf;
850 /* i2 is a 16-bit signed quantity. */
851 *i2
= (((insn
[2] << 8) | insn
[3]) ^ 0x8000) - 0x8000;
860 is_rx (bfd_byte
*insn
, int op
,
861 unsigned int *r1
, int *d2
, unsigned int *x2
, unsigned int *b2
)
865 *r1
= (insn
[1] >> 4) & 0xf;
867 *b2
= (insn
[2] >> 4) & 0xf;
868 *d2
= ((insn
[2] & 0xf) << 8) | insn
[3];
877 is_rxy (bfd_byte
*insn
, int op1
, int op2
,
878 unsigned int *r1
, int *d2
, unsigned int *x2
, unsigned int *b2
)
883 *r1
= (insn
[1] >> 4) & 0xf;
885 *b2
= (insn
[2] >> 4) & 0xf;
886 /* The 'long displacement' is a 20-bit signed integer. */
887 *d2
= ((((insn
[2] & 0xf) << 8) | insn
[3] | (insn
[4] << 12))
888 ^ 0x80000) - 0x80000;
896 /* Prologue analysis. */
898 #define S390_NUM_GPRS 16
899 #define S390_NUM_FPRS 16
901 struct s390_prologue_data
{
904 struct pv_area
*stack
;
906 /* The size and byte-order of a GPR or FPR. */
909 enum bfd_endian byte_order
;
911 /* The general-purpose registers. */
912 pv_t gpr
[S390_NUM_GPRS
];
914 /* The floating-point registers. */
915 pv_t fpr
[S390_NUM_FPRS
];
917 /* The offset relative to the CFA where the incoming GPR N was saved
918 by the function prologue. 0 if not saved or unknown. */
919 int gpr_slot
[S390_NUM_GPRS
];
921 /* Likewise for FPRs. */
922 int fpr_slot
[S390_NUM_FPRS
];
924 /* Nonzero if the backchain was saved. This is assumed to be the
925 case when the incoming SP is saved at the current SP location. */
926 int back_chain_saved_p
;
929 /* Return the effective address for an X-style instruction, like:
933 Here, X2 and B2 are registers, and D2 is a signed 20-bit
934 constant; the effective address is the sum of all three. If either
935 X2 or B2 are zero, then it doesn't contribute to the sum --- this
936 means that r0 can't be used as either X2 or B2. */
938 s390_addr (struct s390_prologue_data
*data
,
939 int d2
, unsigned int x2
, unsigned int b2
)
943 result
= pv_constant (d2
);
945 result
= pv_add (result
, data
->gpr
[x2
]);
947 result
= pv_add (result
, data
->gpr
[b2
]);
952 /* Do a SIZE-byte store of VALUE to D2(X2,B2). */
954 s390_store (struct s390_prologue_data
*data
,
955 int d2
, unsigned int x2
, unsigned int b2
, CORE_ADDR size
,
958 pv_t addr
= s390_addr (data
, d2
, x2
, b2
);
961 /* Check whether we are storing the backchain. */
962 offset
= pv_subtract (data
->gpr
[S390_SP_REGNUM
- S390_R0_REGNUM
], addr
);
964 if (pv_is_constant (offset
) && offset
.k
== 0)
965 if (size
== data
->gpr_size
966 && pv_is_register_k (value
, S390_SP_REGNUM
, 0))
968 data
->back_chain_saved_p
= 1;
973 /* Check whether we are storing a register into the stack. */
974 if (!pv_area_store_would_trash (data
->stack
, addr
))
975 pv_area_store (data
->stack
, addr
, size
, value
);
978 /* Note: If this is some store we cannot identify, you might think we
979 should forget our cached values, as any of those might have been hit.
981 However, we make the assumption that the register save areas are only
982 ever stored to once in any given function, and we do recognize these
983 stores. Thus every store we cannot recognize does not hit our data. */
986 /* Do a SIZE-byte load from D2(X2,B2). */
988 s390_load (struct s390_prologue_data
*data
,
989 int d2
, unsigned int x2
, unsigned int b2
, CORE_ADDR size
)
992 pv_t addr
= s390_addr (data
, d2
, x2
, b2
);
994 /* If it's a load from an in-line constant pool, then we can
995 simulate that, under the assumption that the code isn't
996 going to change between the time the processor actually
997 executed it creating the current frame, and the time when
998 we're analyzing the code to unwind past that frame. */
999 if (pv_is_constant (addr
))
1001 struct target_section
*secp
;
1002 secp
= target_section_by_addr (¤t_target
, addr
.k
);
1004 && (bfd_get_section_flags (secp
->the_bfd_section
->owner
,
1005 secp
->the_bfd_section
)
1007 return pv_constant (read_memory_integer (addr
.k
, size
,
1011 /* Check whether we are accessing one of our save slots. */
1012 return pv_area_fetch (data
->stack
, addr
, size
);
1015 /* Function for finding saved registers in a 'struct pv_area'; we pass
1016 this to pv_area_scan.
1018 If VALUE is a saved register, ADDR says it was saved at a constant
1019 offset from the frame base, and SIZE indicates that the whole
1020 register was saved, record its offset in the reg_offset table in
1021 PROLOGUE_UNTYPED. */
1023 s390_check_for_saved (void *data_untyped
, pv_t addr
,
1024 CORE_ADDR size
, pv_t value
)
1026 struct s390_prologue_data
*data
= data_untyped
;
1029 if (!pv_is_register (addr
, S390_SP_REGNUM
))
1032 offset
= 16 * data
->gpr_size
+ 32 - addr
.k
;
1034 /* If we are storing the original value of a register, we want to
1035 record the CFA offset. If the same register is stored multiple
1036 times, the stack slot with the highest address counts. */
1038 for (i
= 0; i
< S390_NUM_GPRS
; i
++)
1039 if (size
== data
->gpr_size
1040 && pv_is_register_k (value
, S390_R0_REGNUM
+ i
, 0))
1041 if (data
->gpr_slot
[i
] == 0
1042 || data
->gpr_slot
[i
] > offset
)
1044 data
->gpr_slot
[i
] = offset
;
1048 for (i
= 0; i
< S390_NUM_FPRS
; i
++)
1049 if (size
== data
->fpr_size
1050 && pv_is_register_k (value
, S390_F0_REGNUM
+ i
, 0))
1051 if (data
->fpr_slot
[i
] == 0
1052 || data
->fpr_slot
[i
] > offset
)
1054 data
->fpr_slot
[i
] = offset
;
1059 /* Analyze the prologue of the function starting at START_PC,
1060 continuing at most until CURRENT_PC. Initialize DATA to
1061 hold all information we find out about the state of the registers
1062 and stack slots. Return the address of the instruction after
1063 the last one that changed the SP, FP, or back chain; or zero
1066 s390_analyze_prologue (struct gdbarch
*gdbarch
,
1068 CORE_ADDR current_pc
,
1069 struct s390_prologue_data
*data
)
1071 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
1073 /* Our return value:
1074 The address of the instruction after the last one that changed
1075 the SP, FP, or back chain; zero if we got an error trying to
1077 CORE_ADDR result
= start_pc
;
1079 /* The current PC for our abstract interpretation. */
1082 /* The address of the next instruction after that. */
1085 /* Set up everything's initial value. */
1089 data
->stack
= make_pv_area (S390_SP_REGNUM
, gdbarch_addr_bit (gdbarch
));
1091 /* For the purpose of prologue tracking, we consider the GPR size to
1092 be equal to the ABI word size, even if it is actually larger
1093 (i.e. when running a 32-bit binary under a 64-bit kernel). */
1094 data
->gpr_size
= word_size
;
1096 data
->byte_order
= gdbarch_byte_order (gdbarch
);
1098 for (i
= 0; i
< S390_NUM_GPRS
; i
++)
1099 data
->gpr
[i
] = pv_register (S390_R0_REGNUM
+ i
, 0);
1101 for (i
= 0; i
< S390_NUM_FPRS
; i
++)
1102 data
->fpr
[i
] = pv_register (S390_F0_REGNUM
+ i
, 0);
1104 for (i
= 0; i
< S390_NUM_GPRS
; i
++)
1105 data
->gpr_slot
[i
] = 0;
1107 for (i
= 0; i
< S390_NUM_FPRS
; i
++)
1108 data
->fpr_slot
[i
] = 0;
1110 data
->back_chain_saved_p
= 0;
1113 /* Start interpreting instructions, until we hit the frame's
1114 current PC or the first branch instruction. */
1115 for (pc
= start_pc
; pc
> 0 && pc
< current_pc
; pc
= next_pc
)
1117 bfd_byte insn
[S390_MAX_INSTR_SIZE
];
1118 int insn_len
= s390_readinstruction (insn
, pc
);
1120 bfd_byte dummy
[S390_MAX_INSTR_SIZE
] = { 0 };
1121 bfd_byte
*insn32
= word_size
== 4 ? insn
: dummy
;
1122 bfd_byte
*insn64
= word_size
== 8 ? insn
: dummy
;
1124 /* Fields for various kinds of instructions. */
1125 unsigned int b2
, r1
, r2
, x2
, r3
;
1128 /* The values of SP and FP before this instruction,
1129 for detecting instructions that change them. */
1130 pv_t pre_insn_sp
, pre_insn_fp
;
1131 /* Likewise for the flag whether the back chain was saved. */
1132 int pre_insn_back_chain_saved_p
;
1134 /* If we got an error trying to read the instruction, report it. */
1141 next_pc
= pc
+ insn_len
;
1143 pre_insn_sp
= data
->gpr
[S390_SP_REGNUM
- S390_R0_REGNUM
];
1144 pre_insn_fp
= data
->gpr
[S390_FRAME_REGNUM
- S390_R0_REGNUM
];
1145 pre_insn_back_chain_saved_p
= data
->back_chain_saved_p
;
1148 /* LHI r1, i2 --- load halfword immediate. */
1149 /* LGHI r1, i2 --- load halfword immediate (64-bit version). */
1150 /* LGFI r1, i2 --- load fullword immediate. */
1151 if (is_ri (insn32
, op1_lhi
, op2_lhi
, &r1
, &i2
)
1152 || is_ri (insn64
, op1_lghi
, op2_lghi
, &r1
, &i2
)
1153 || is_ril (insn
, op1_lgfi
, op2_lgfi
, &r1
, &i2
))
1154 data
->gpr
[r1
] = pv_constant (i2
);
1156 /* LR r1, r2 --- load from register. */
1157 /* LGR r1, r2 --- load from register (64-bit version). */
1158 else if (is_rr (insn32
, op_lr
, &r1
, &r2
)
1159 || is_rre (insn64
, op_lgr
, &r1
, &r2
))
1160 data
->gpr
[r1
] = data
->gpr
[r2
];
1162 /* L r1, d2(x2, b2) --- load. */
1163 /* LY r1, d2(x2, b2) --- load (long-displacement version). */
1164 /* LG r1, d2(x2, b2) --- load (64-bit version). */
1165 else if (is_rx (insn32
, op_l
, &r1
, &d2
, &x2
, &b2
)
1166 || is_rxy (insn32
, op1_ly
, op2_ly
, &r1
, &d2
, &x2
, &b2
)
1167 || is_rxy (insn64
, op1_lg
, op2_lg
, &r1
, &d2
, &x2
, &b2
))
1168 data
->gpr
[r1
] = s390_load (data
, d2
, x2
, b2
, data
->gpr_size
);
1170 /* ST r1, d2(x2, b2) --- store. */
1171 /* STY r1, d2(x2, b2) --- store (long-displacement version). */
1172 /* STG r1, d2(x2, b2) --- store (64-bit version). */
1173 else if (is_rx (insn32
, op_st
, &r1
, &d2
, &x2
, &b2
)
1174 || is_rxy (insn32
, op1_sty
, op2_sty
, &r1
, &d2
, &x2
, &b2
)
1175 || is_rxy (insn64
, op1_stg
, op2_stg
, &r1
, &d2
, &x2
, &b2
))
1176 s390_store (data
, d2
, x2
, b2
, data
->gpr_size
, data
->gpr
[r1
]);
1178 /* STD r1, d2(x2,b2) --- store floating-point register. */
1179 else if (is_rx (insn
, op_std
, &r1
, &d2
, &x2
, &b2
))
1180 s390_store (data
, d2
, x2
, b2
, data
->fpr_size
, data
->fpr
[r1
]);
1182 /* STM r1, r3, d2(b2) --- store multiple. */
1183 /* STMY r1, r3, d2(b2) --- store multiple (long-displacement
1185 /* STMG r1, r3, d2(b2) --- store multiple (64-bit version). */
1186 else if (is_rs (insn32
, op_stm
, &r1
, &r3
, &d2
, &b2
)
1187 || is_rsy (insn32
, op1_stmy
, op2_stmy
, &r1
, &r3
, &d2
, &b2
)
1188 || is_rsy (insn64
, op1_stmg
, op2_stmg
, &r1
, &r3
, &d2
, &b2
))
1190 for (; r1
<= r3
; r1
++, d2
+= data
->gpr_size
)
1191 s390_store (data
, d2
, 0, b2
, data
->gpr_size
, data
->gpr
[r1
]);
1194 /* AHI r1, i2 --- add halfword immediate. */
1195 /* AGHI r1, i2 --- add halfword immediate (64-bit version). */
1196 /* AFI r1, i2 --- add fullword immediate. */
1197 /* AGFI r1, i2 --- add fullword immediate (64-bit version). */
1198 else if (is_ri (insn32
, op1_ahi
, op2_ahi
, &r1
, &i2
)
1199 || is_ri (insn64
, op1_aghi
, op2_aghi
, &r1
, &i2
)
1200 || is_ril (insn32
, op1_afi
, op2_afi
, &r1
, &i2
)
1201 || is_ril (insn64
, op1_agfi
, op2_agfi
, &r1
, &i2
))
1202 data
->gpr
[r1
] = pv_add_constant (data
->gpr
[r1
], i2
);
1204 /* ALFI r1, i2 --- add logical immediate. */
1205 /* ALGFI r1, i2 --- add logical immediate (64-bit version). */
1206 else if (is_ril (insn32
, op1_alfi
, op2_alfi
, &r1
, &i2
)
1207 || is_ril (insn64
, op1_algfi
, op2_algfi
, &r1
, &i2
))
1208 data
->gpr
[r1
] = pv_add_constant (data
->gpr
[r1
],
1209 (CORE_ADDR
)i2
& 0xffffffff);
1211 /* AR r1, r2 -- add register. */
1212 /* AGR r1, r2 -- add register (64-bit version). */
1213 else if (is_rr (insn32
, op_ar
, &r1
, &r2
)
1214 || is_rre (insn64
, op_agr
, &r1
, &r2
))
1215 data
->gpr
[r1
] = pv_add (data
->gpr
[r1
], data
->gpr
[r2
]);
1217 /* A r1, d2(x2, b2) -- add. */
1218 /* AY r1, d2(x2, b2) -- add (long-displacement version). */
1219 /* AG r1, d2(x2, b2) -- add (64-bit version). */
1220 else if (is_rx (insn32
, op_a
, &r1
, &d2
, &x2
, &b2
)
1221 || is_rxy (insn32
, op1_ay
, op2_ay
, &r1
, &d2
, &x2
, &b2
)
1222 || is_rxy (insn64
, op1_ag
, op2_ag
, &r1
, &d2
, &x2
, &b2
))
1223 data
->gpr
[r1
] = pv_add (data
->gpr
[r1
],
1224 s390_load (data
, d2
, x2
, b2
, data
->gpr_size
));
1226 /* SLFI r1, i2 --- subtract logical immediate. */
1227 /* SLGFI r1, i2 --- subtract logical immediate (64-bit version). */
1228 else if (is_ril (insn32
, op1_slfi
, op2_slfi
, &r1
, &i2
)
1229 || is_ril (insn64
, op1_slgfi
, op2_slgfi
, &r1
, &i2
))
1230 data
->gpr
[r1
] = pv_add_constant (data
->gpr
[r1
],
1231 -((CORE_ADDR
)i2
& 0xffffffff));
1233 /* SR r1, r2 -- subtract register. */
1234 /* SGR r1, r2 -- subtract register (64-bit version). */
1235 else if (is_rr (insn32
, op_sr
, &r1
, &r2
)
1236 || is_rre (insn64
, op_sgr
, &r1
, &r2
))
1237 data
->gpr
[r1
] = pv_subtract (data
->gpr
[r1
], data
->gpr
[r2
]);
1239 /* S r1, d2(x2, b2) -- subtract. */
1240 /* SY r1, d2(x2, b2) -- subtract (long-displacement version). */
1241 /* SG r1, d2(x2, b2) -- subtract (64-bit version). */
1242 else if (is_rx (insn32
, op_s
, &r1
, &d2
, &x2
, &b2
)
1243 || is_rxy (insn32
, op1_sy
, op2_sy
, &r1
, &d2
, &x2
, &b2
)
1244 || is_rxy (insn64
, op1_sg
, op2_sg
, &r1
, &d2
, &x2
, &b2
))
1245 data
->gpr
[r1
] = pv_subtract (data
->gpr
[r1
],
1246 s390_load (data
, d2
, x2
, b2
, data
->gpr_size
));
1248 /* LA r1, d2(x2, b2) --- load address. */
1249 /* LAY r1, d2(x2, b2) --- load address (long-displacement version). */
1250 else if (is_rx (insn
, op_la
, &r1
, &d2
, &x2
, &b2
)
1251 || is_rxy (insn
, op1_lay
, op2_lay
, &r1
, &d2
, &x2
, &b2
))
1252 data
->gpr
[r1
] = s390_addr (data
, d2
, x2
, b2
);
1254 /* LARL r1, i2 --- load address relative long. */
1255 else if (is_ril (insn
, op1_larl
, op2_larl
, &r1
, &i2
))
1256 data
->gpr
[r1
] = pv_constant (pc
+ i2
* 2);
1258 /* BASR r1, 0 --- branch and save.
1259 Since r2 is zero, this saves the PC in r1, but doesn't branch. */
1260 else if (is_rr (insn
, op_basr
, &r1
, &r2
)
1262 data
->gpr
[r1
] = pv_constant (next_pc
);
1264 /* BRAS r1, i2 --- branch relative and save. */
1265 else if (is_ri (insn
, op1_bras
, op2_bras
, &r1
, &i2
))
1267 data
->gpr
[r1
] = pv_constant (next_pc
);
1268 next_pc
= pc
+ i2
* 2;
1270 /* We'd better not interpret any backward branches. We'll
1276 /* Terminate search when hitting any other branch instruction. */
1277 else if (is_rr (insn
, op_basr
, &r1
, &r2
)
1278 || is_rx (insn
, op_bas
, &r1
, &d2
, &x2
, &b2
)
1279 || is_rr (insn
, op_bcr
, &r1
, &r2
)
1280 || is_rx (insn
, op_bc
, &r1
, &d2
, &x2
, &b2
)
1281 || is_ri (insn
, op1_brc
, op2_brc
, &r1
, &i2
)
1282 || is_ril (insn
, op1_brcl
, op2_brcl
, &r1
, &i2
)
1283 || is_ril (insn
, op1_brasl
, op2_brasl
, &r2
, &i2
))
1288 /* An instruction we don't know how to simulate. The only
1289 safe thing to do would be to set every value we're tracking
1290 to 'unknown'. Instead, we'll be optimistic: we assume that
1291 we *can* interpret every instruction that the compiler uses
1292 to manipulate any of the data we're interested in here --
1293 then we can just ignore anything else. */
1296 /* Record the address after the last instruction that changed
1297 the FP, SP, or backlink. Ignore instructions that changed
1298 them back to their original values --- those are probably
1299 restore instructions. (The back chain is never restored,
1302 pv_t sp
= data
->gpr
[S390_SP_REGNUM
- S390_R0_REGNUM
];
1303 pv_t fp
= data
->gpr
[S390_FRAME_REGNUM
- S390_R0_REGNUM
];
1305 if ((! pv_is_identical (pre_insn_sp
, sp
)
1306 && ! pv_is_register_k (sp
, S390_SP_REGNUM
, 0)
1307 && sp
.kind
!= pvk_unknown
)
1308 || (! pv_is_identical (pre_insn_fp
, fp
)
1309 && ! pv_is_register_k (fp
, S390_FRAME_REGNUM
, 0)
1310 && fp
.kind
!= pvk_unknown
)
1311 || pre_insn_back_chain_saved_p
!= data
->back_chain_saved_p
)
1316 /* Record where all the registers were saved. */
1317 pv_area_scan (data
->stack
, s390_check_for_saved
, data
);
1319 free_pv_area (data
->stack
);
1325 /* Advance PC across any function entry prologue instructions to reach
1326 some "real" code. */
1328 s390_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
1330 struct s390_prologue_data data
;
1332 skip_pc
= s390_analyze_prologue (gdbarch
, pc
, (CORE_ADDR
)-1, &data
);
1333 return skip_pc
? skip_pc
: pc
;
1336 /* Return true if we are in the functin's epilogue, i.e. after the
1337 instruction that destroyed the function's stack frame. */
1339 s390_in_function_epilogue_p (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
1341 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
1343 /* In frameless functions, there's not frame to destroy and thus
1344 we don't care about the epilogue.
1346 In functions with frame, the epilogue sequence is a pair of
1347 a LM-type instruction that restores (amongst others) the
1348 return register %r14 and the stack pointer %r15, followed
1349 by a branch 'br %r14' --or equivalent-- that effects the
1352 In that situation, this function needs to return 'true' in
1353 exactly one case: when pc points to that branch instruction.
1355 Thus we try to disassemble the one instructions immediately
1356 preceding pc and check whether it is an LM-type instruction
1357 modifying the stack pointer.
1359 Note that disassembling backwards is not reliable, so there
1360 is a slight chance of false positives here ... */
1363 unsigned int r1
, r3
, b2
;
1367 && !target_read_memory (pc
- 4, insn
, 4)
1368 && is_rs (insn
, op_lm
, &r1
, &r3
, &d2
, &b2
)
1369 && r3
== S390_SP_REGNUM
- S390_R0_REGNUM
)
1373 && !target_read_memory (pc
- 6, insn
, 6)
1374 && is_rsy (insn
, op1_lmy
, op2_lmy
, &r1
, &r3
, &d2
, &b2
)
1375 && r3
== S390_SP_REGNUM
- S390_R0_REGNUM
)
1379 && !target_read_memory (pc
- 6, insn
, 6)
1380 && is_rsy (insn
, op1_lmg
, op2_lmg
, &r1
, &r3
, &d2
, &b2
)
1381 && r3
== S390_SP_REGNUM
- S390_R0_REGNUM
)
1387 /* Displaced stepping. */
1389 /* Fix up the state of registers and memory after having single-stepped
1390 a displaced instruction. */
1392 s390_displaced_step_fixup (struct gdbarch
*gdbarch
,
1393 struct displaced_step_closure
*closure
,
1394 CORE_ADDR from
, CORE_ADDR to
,
1395 struct regcache
*regs
)
1397 /* Since we use simple_displaced_step_copy_insn, our closure is a
1398 copy of the instruction. */
1399 gdb_byte
*insn
= (gdb_byte
*) closure
;
1400 static int s390_instrlen
[] = { 2, 4, 4, 6 };
1401 int insnlen
= s390_instrlen
[insn
[0] >> 6];
1403 /* Fields for various kinds of instructions. */
1404 unsigned int b2
, r1
, r2
, x2
, r3
;
1407 /* Get current PC and addressing mode bit. */
1408 CORE_ADDR pc
= regcache_read_pc (regs
);
1411 if (register_size (gdbarch
, S390_PSWA_REGNUM
) == 4)
1413 regcache_cooked_read_unsigned (regs
, S390_PSWA_REGNUM
, &amode
);
1414 amode
&= 0x80000000;
1417 if (debug_displaced
)
1418 fprintf_unfiltered (gdb_stdlog
,
1419 "displaced: (s390) fixup (%s, %s) pc %s len %d amode 0x%x\n",
1420 paddress (gdbarch
, from
), paddress (gdbarch
, to
),
1421 paddress (gdbarch
, pc
), insnlen
, (int) amode
);
1423 /* Handle absolute branch and save instructions. */
1424 if (is_rr (insn
, op_basr
, &r1
, &r2
)
1425 || is_rx (insn
, op_bas
, &r1
, &d2
, &x2
, &b2
))
1427 /* Recompute saved return address in R1. */
1428 regcache_cooked_write_unsigned (regs
, S390_R0_REGNUM
+ r1
,
1429 amode
| (from
+ insnlen
));
1432 /* Handle absolute branch instructions. */
1433 else if (is_rr (insn
, op_bcr
, &r1
, &r2
)
1434 || is_rx (insn
, op_bc
, &r1
, &d2
, &x2
, &b2
)
1435 || is_rr (insn
, op_bctr
, &r1
, &r2
)
1436 || is_rre (insn
, op_bctgr
, &r1
, &r2
)
1437 || is_rx (insn
, op_bct
, &r1
, &d2
, &x2
, &b2
)
1438 || is_rxy (insn
, op1_bctg
, op2_brctg
, &r1
, &d2
, &x2
, &b2
)
1439 || is_rs (insn
, op_bxh
, &r1
, &r3
, &d2
, &b2
)
1440 || is_rsy (insn
, op1_bxhg
, op2_bxhg
, &r1
, &r3
, &d2
, &b2
)
1441 || is_rs (insn
, op_bxle
, &r1
, &r3
, &d2
, &b2
)
1442 || is_rsy (insn
, op1_bxleg
, op2_bxleg
, &r1
, &r3
, &d2
, &b2
))
1444 /* Update PC iff branch was *not* taken. */
1445 if (pc
== to
+ insnlen
)
1446 regcache_write_pc (regs
, from
+ insnlen
);
1449 /* Handle PC-relative branch and save instructions. */
1450 else if (is_ri (insn
, op1_bras
, op2_bras
, &r1
, &i2
)
1451 || is_ril (insn
, op1_brasl
, op2_brasl
, &r1
, &i2
))
1454 regcache_write_pc (regs
, pc
- to
+ from
);
1455 /* Recompute saved return address in R1. */
1456 regcache_cooked_write_unsigned (regs
, S390_R0_REGNUM
+ r1
,
1457 amode
| (from
+ insnlen
));
1460 /* Handle PC-relative branch instructions. */
1461 else if (is_ri (insn
, op1_brc
, op2_brc
, &r1
, &i2
)
1462 || is_ril (insn
, op1_brcl
, op2_brcl
, &r1
, &i2
)
1463 || is_ri (insn
, op1_brct
, op2_brct
, &r1
, &i2
)
1464 || is_ri (insn
, op1_brctg
, op2_brctg
, &r1
, &i2
)
1465 || is_rsi (insn
, op_brxh
, &r1
, &r3
, &i2
)
1466 || is_rie (insn
, op1_brxhg
, op2_brxhg
, &r1
, &r3
, &i2
)
1467 || is_rsi (insn
, op_brxle
, &r1
, &r3
, &i2
)
1468 || is_rie (insn
, op1_brxlg
, op2_brxlg
, &r1
, &r3
, &i2
))
1471 regcache_write_pc (regs
, pc
- to
+ from
);
1474 /* Handle LOAD ADDRESS RELATIVE LONG. */
1475 else if (is_ril (insn
, op1_larl
, op2_larl
, &r1
, &i2
))
1478 regcache_write_pc (regs
, from
+ insnlen
);
1479 /* Recompute output address in R1. */
1480 regcache_cooked_write_unsigned (regs
, S390_R0_REGNUM
+ r1
,
1481 amode
| (from
+ i2
* 2));
1484 /* If we executed a breakpoint instruction, point PC right back at it. */
1485 else if (insn
[0] == 0x0 && insn
[1] == 0x1)
1486 regcache_write_pc (regs
, from
);
1488 /* For any other insn, PC points right after the original instruction. */
1490 regcache_write_pc (regs
, from
+ insnlen
);
1492 if (debug_displaced
)
1493 fprintf_unfiltered (gdb_stdlog
,
1494 "displaced: (s390) pc is now %s\n",
1495 paddress (gdbarch
, regcache_read_pc (regs
)));
1499 /* Helper routine to unwind pseudo registers. */
1501 static struct value
*
1502 s390_unwind_pseudo_register (struct frame_info
*this_frame
, int regnum
)
1504 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1505 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1506 struct type
*type
= register_type (gdbarch
, regnum
);
1508 /* Unwind PC via PSW address. */
1509 if (regnum
== tdep
->pc_regnum
)
1513 val
= frame_unwind_register_value (this_frame
, S390_PSWA_REGNUM
);
1514 if (!value_optimized_out (val
))
1516 LONGEST pswa
= value_as_long (val
);
1518 if (TYPE_LENGTH (type
) == 4)
1519 return value_from_pointer (type
, pswa
& 0x7fffffff);
1521 return value_from_pointer (type
, pswa
);
1525 /* Unwind CC via PSW mask. */
1526 if (regnum
== tdep
->cc_regnum
)
1530 val
= frame_unwind_register_value (this_frame
, S390_PSWM_REGNUM
);
1531 if (!value_optimized_out (val
))
1533 LONGEST pswm
= value_as_long (val
);
1535 if (TYPE_LENGTH (type
) == 4)
1536 return value_from_longest (type
, (pswm
>> 12) & 3);
1538 return value_from_longest (type
, (pswm
>> 44) & 3);
1542 /* Unwind full GPRs to show at least the lower halves (as the
1543 upper halves are undefined). */
1544 if (regnum_is_gpr_full (tdep
, regnum
))
1546 int reg
= regnum
- tdep
->gpr_full_regnum
;
1549 val
= frame_unwind_register_value (this_frame
, S390_R0_REGNUM
+ reg
);
1550 if (!value_optimized_out (val
))
1551 return value_cast (type
, val
);
1554 return allocate_optimized_out_value (type
);
1557 static struct value
*
1558 s390_trad_frame_prev_register (struct frame_info
*this_frame
,
1559 struct trad_frame_saved_reg saved_regs
[],
1562 if (regnum
< S390_NUM_REGS
)
1563 return trad_frame_get_prev_register (this_frame
, saved_regs
, regnum
);
1565 return s390_unwind_pseudo_register (this_frame
, regnum
);
1569 /* Normal stack frames. */
1571 struct s390_unwind_cache
{
1574 CORE_ADDR frame_base
;
1575 CORE_ADDR local_base
;
1577 struct trad_frame_saved_reg
*saved_regs
;
1581 s390_prologue_frame_unwind_cache (struct frame_info
*this_frame
,
1582 struct s390_unwind_cache
*info
)
1584 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1585 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
1586 struct s390_prologue_data data
;
1587 pv_t
*fp
= &data
.gpr
[S390_FRAME_REGNUM
- S390_R0_REGNUM
];
1588 pv_t
*sp
= &data
.gpr
[S390_SP_REGNUM
- S390_R0_REGNUM
];
1597 struct frame_info
*next_frame
;
1599 /* Try to find the function start address. If we can't find it, we don't
1600 bother searching for it -- with modern compilers this would be mostly
1601 pointless anyway. Trust that we'll either have valid DWARF-2 CFI data
1602 or else a valid backchain ... */
1603 func
= get_frame_func (this_frame
);
1607 /* Try to analyze the prologue. */
1608 result
= s390_analyze_prologue (gdbarch
, func
,
1609 get_frame_pc (this_frame
), &data
);
1613 /* If this was successful, we should have found the instruction that
1614 sets the stack pointer register to the previous value of the stack
1615 pointer minus the frame size. */
1616 if (!pv_is_register (*sp
, S390_SP_REGNUM
))
1619 /* A frame size of zero at this point can mean either a real
1620 frameless function, or else a failure to find the prologue.
1621 Perform some sanity checks to verify we really have a
1622 frameless function. */
1625 /* If the next frame is a NORMAL_FRAME, this frame *cannot* have frame
1626 size zero. This is only possible if the next frame is a sentinel
1627 frame, a dummy frame, or a signal trampoline frame. */
1628 /* FIXME: cagney/2004-05-01: This sanity check shouldn't be
1629 needed, instead the code should simpliy rely on its
1631 next_frame
= get_next_frame (this_frame
);
1632 while (next_frame
&& get_frame_type (next_frame
) == INLINE_FRAME
)
1633 next_frame
= get_next_frame (next_frame
);
1635 && get_frame_type (get_next_frame (this_frame
)) == NORMAL_FRAME
)
1638 /* If we really have a frameless function, %r14 must be valid
1639 -- in particular, it must point to a different function. */
1640 reg
= get_frame_register_unsigned (this_frame
, S390_RETADDR_REGNUM
);
1641 reg
= gdbarch_addr_bits_remove (gdbarch
, reg
) - 1;
1642 if (get_pc_function_start (reg
) == func
)
1644 /* However, there is one case where it *is* valid for %r14
1645 to point to the same function -- if this is a recursive
1646 call, and we have stopped in the prologue *before* the
1647 stack frame was allocated.
1649 Recognize this case by looking ahead a bit ... */
1651 struct s390_prologue_data data2
;
1652 pv_t
*sp
= &data2
.gpr
[S390_SP_REGNUM
- S390_R0_REGNUM
];
1654 if (!(s390_analyze_prologue (gdbarch
, func
, (CORE_ADDR
)-1, &data2
)
1655 && pv_is_register (*sp
, S390_SP_REGNUM
)
1662 /* OK, we've found valid prologue data. */
1665 /* If the frame pointer originally also holds the same value
1666 as the stack pointer, we're probably using it. If it holds
1667 some other value -- even a constant offset -- it is most
1668 likely used as temp register. */
1669 if (pv_is_identical (*sp
, *fp
))
1670 frame_pointer
= S390_FRAME_REGNUM
;
1672 frame_pointer
= S390_SP_REGNUM
;
1674 /* If we've detected a function with stack frame, we'll still have to
1675 treat it as frameless if we're currently within the function epilog
1676 code at a point where the frame pointer has already been restored.
1677 This can only happen in an innermost frame. */
1678 /* FIXME: cagney/2004-05-01: This sanity check shouldn't be needed,
1679 instead the code should simpliy rely on its analysis. */
1680 next_frame
= get_next_frame (this_frame
);
1681 while (next_frame
&& get_frame_type (next_frame
) == INLINE_FRAME
)
1682 next_frame
= get_next_frame (next_frame
);
1684 && (next_frame
== NULL
1685 || get_frame_type (get_next_frame (this_frame
)) != NORMAL_FRAME
))
1687 /* See the comment in s390_in_function_epilogue_p on why this is
1688 not completely reliable ... */
1689 if (s390_in_function_epilogue_p (gdbarch
, get_frame_pc (this_frame
)))
1691 memset (&data
, 0, sizeof (data
));
1693 frame_pointer
= S390_SP_REGNUM
;
1697 /* Once we know the frame register and the frame size, we can unwind
1698 the current value of the frame register from the next frame, and
1699 add back the frame size to arrive that the previous frame's
1700 stack pointer value. */
1701 prev_sp
= get_frame_register_unsigned (this_frame
, frame_pointer
) + size
;
1702 cfa
= prev_sp
+ 16*word_size
+ 32;
1704 /* Set up ABI call-saved/call-clobbered registers. */
1705 for (i
= 0; i
< S390_NUM_REGS
; i
++)
1706 if (!s390_register_call_saved (gdbarch
, i
))
1707 trad_frame_set_unknown (info
->saved_regs
, i
);
1709 /* CC is always call-clobbered. */
1710 trad_frame_set_unknown (info
->saved_regs
, S390_PSWM_REGNUM
);
1712 /* Record the addresses of all register spill slots the prologue parser
1713 has recognized. Consider only registers defined as call-saved by the
1714 ABI; for call-clobbered registers the parser may have recognized
1717 for (i
= 0; i
< 16; i
++)
1718 if (s390_register_call_saved (gdbarch
, S390_R0_REGNUM
+ i
)
1719 && data
.gpr_slot
[i
] != 0)
1720 info
->saved_regs
[S390_R0_REGNUM
+ i
].addr
= cfa
- data
.gpr_slot
[i
];
1722 for (i
= 0; i
< 16; i
++)
1723 if (s390_register_call_saved (gdbarch
, S390_F0_REGNUM
+ i
)
1724 && data
.fpr_slot
[i
] != 0)
1725 info
->saved_regs
[S390_F0_REGNUM
+ i
].addr
= cfa
- data
.fpr_slot
[i
];
1727 /* Function return will set PC to %r14. */
1728 info
->saved_regs
[S390_PSWA_REGNUM
] = info
->saved_regs
[S390_RETADDR_REGNUM
];
1730 /* In frameless functions, we unwind simply by moving the return
1731 address to the PC. However, if we actually stored to the
1732 save area, use that -- we might only think the function frameless
1733 because we're in the middle of the prologue ... */
1735 && !trad_frame_addr_p (info
->saved_regs
, S390_PSWA_REGNUM
))
1737 info
->saved_regs
[S390_PSWA_REGNUM
].realreg
= S390_RETADDR_REGNUM
;
1740 /* Another sanity check: unless this is a frameless function,
1741 we should have found spill slots for SP and PC.
1742 If not, we cannot unwind further -- this happens e.g. in
1743 libc's thread_start routine. */
1746 if (!trad_frame_addr_p (info
->saved_regs
, S390_SP_REGNUM
)
1747 || !trad_frame_addr_p (info
->saved_regs
, S390_PSWA_REGNUM
))
1751 /* We use the current value of the frame register as local_base,
1752 and the top of the register save area as frame_base. */
1755 info
->frame_base
= prev_sp
+ 16*word_size
+ 32;
1756 info
->local_base
= prev_sp
- size
;
1764 s390_backchain_frame_unwind_cache (struct frame_info
*this_frame
,
1765 struct s390_unwind_cache
*info
)
1767 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1768 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
1769 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1770 CORE_ADDR backchain
;
1775 /* Set up ABI call-saved/call-clobbered registers. */
1776 for (i
= 0; i
< S390_NUM_REGS
; i
++)
1777 if (!s390_register_call_saved (gdbarch
, i
))
1778 trad_frame_set_unknown (info
->saved_regs
, i
);
1780 /* CC is always call-clobbered. */
1781 trad_frame_set_unknown (info
->saved_regs
, S390_PSWM_REGNUM
);
1783 /* Get the backchain. */
1784 reg
= get_frame_register_unsigned (this_frame
, S390_SP_REGNUM
);
1785 backchain
= read_memory_unsigned_integer (reg
, word_size
, byte_order
);
1787 /* A zero backchain terminates the frame chain. As additional
1788 sanity check, let's verify that the spill slot for SP in the
1789 save area pointed to by the backchain in fact links back to
1792 && safe_read_memory_integer (backchain
+ 15*word_size
,
1793 word_size
, byte_order
, &sp
)
1794 && (CORE_ADDR
)sp
== backchain
)
1796 /* We don't know which registers were saved, but it will have
1797 to be at least %r14 and %r15. This will allow us to continue
1798 unwinding, but other prev-frame registers may be incorrect ... */
1799 info
->saved_regs
[S390_SP_REGNUM
].addr
= backchain
+ 15*word_size
;
1800 info
->saved_regs
[S390_RETADDR_REGNUM
].addr
= backchain
+ 14*word_size
;
1802 /* Function return will set PC to %r14. */
1803 info
->saved_regs
[S390_PSWA_REGNUM
]
1804 = info
->saved_regs
[S390_RETADDR_REGNUM
];
1806 /* We use the current value of the frame register as local_base,
1807 and the top of the register save area as frame_base. */
1808 info
->frame_base
= backchain
+ 16*word_size
+ 32;
1809 info
->local_base
= reg
;
1812 info
->func
= get_frame_pc (this_frame
);
1815 static struct s390_unwind_cache
*
1816 s390_frame_unwind_cache (struct frame_info
*this_frame
,
1817 void **this_prologue_cache
)
1819 volatile struct gdb_exception ex
;
1820 struct s390_unwind_cache
*info
;
1822 if (*this_prologue_cache
)
1823 return *this_prologue_cache
;
1825 info
= FRAME_OBSTACK_ZALLOC (struct s390_unwind_cache
);
1826 *this_prologue_cache
= info
;
1827 info
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
1829 info
->frame_base
= -1;
1830 info
->local_base
= -1;
1832 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
1834 /* Try to use prologue analysis to fill the unwind cache.
1835 If this fails, fall back to reading the stack backchain. */
1836 if (!s390_prologue_frame_unwind_cache (this_frame
, info
))
1837 s390_backchain_frame_unwind_cache (this_frame
, info
);
1839 if (ex
.reason
< 0 && ex
.error
!= NOT_AVAILABLE_ERROR
)
1840 throw_exception (ex
);
1846 s390_frame_this_id (struct frame_info
*this_frame
,
1847 void **this_prologue_cache
,
1848 struct frame_id
*this_id
)
1850 struct s390_unwind_cache
*info
1851 = s390_frame_unwind_cache (this_frame
, this_prologue_cache
);
1853 if (info
->frame_base
== -1)
1856 *this_id
= frame_id_build (info
->frame_base
, info
->func
);
1859 static struct value
*
1860 s390_frame_prev_register (struct frame_info
*this_frame
,
1861 void **this_prologue_cache
, int regnum
)
1863 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1864 struct s390_unwind_cache
*info
1865 = s390_frame_unwind_cache (this_frame
, this_prologue_cache
);
1867 return s390_trad_frame_prev_register (this_frame
, info
->saved_regs
, regnum
);
1870 static const struct frame_unwind s390_frame_unwind
= {
1872 default_frame_unwind_stop_reason
,
1874 s390_frame_prev_register
,
1876 default_frame_sniffer
1880 /* Code stubs and their stack frames. For things like PLTs and NULL
1881 function calls (where there is no true frame and the return address
1882 is in the RETADDR register). */
1884 struct s390_stub_unwind_cache
1886 CORE_ADDR frame_base
;
1887 struct trad_frame_saved_reg
*saved_regs
;
1890 static struct s390_stub_unwind_cache
*
1891 s390_stub_frame_unwind_cache (struct frame_info
*this_frame
,
1892 void **this_prologue_cache
)
1894 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1895 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
1896 struct s390_stub_unwind_cache
*info
;
1899 if (*this_prologue_cache
)
1900 return *this_prologue_cache
;
1902 info
= FRAME_OBSTACK_ZALLOC (struct s390_stub_unwind_cache
);
1903 *this_prologue_cache
= info
;
1904 info
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
1906 /* The return address is in register %r14. */
1907 info
->saved_regs
[S390_PSWA_REGNUM
].realreg
= S390_RETADDR_REGNUM
;
1909 /* Retrieve stack pointer and determine our frame base. */
1910 reg
= get_frame_register_unsigned (this_frame
, S390_SP_REGNUM
);
1911 info
->frame_base
= reg
+ 16*word_size
+ 32;
1917 s390_stub_frame_this_id (struct frame_info
*this_frame
,
1918 void **this_prologue_cache
,
1919 struct frame_id
*this_id
)
1921 struct s390_stub_unwind_cache
*info
1922 = s390_stub_frame_unwind_cache (this_frame
, this_prologue_cache
);
1923 *this_id
= frame_id_build (info
->frame_base
, get_frame_pc (this_frame
));
1926 static struct value
*
1927 s390_stub_frame_prev_register (struct frame_info
*this_frame
,
1928 void **this_prologue_cache
, int regnum
)
1930 struct s390_stub_unwind_cache
*info
1931 = s390_stub_frame_unwind_cache (this_frame
, this_prologue_cache
);
1932 return s390_trad_frame_prev_register (this_frame
, info
->saved_regs
, regnum
);
1936 s390_stub_frame_sniffer (const struct frame_unwind
*self
,
1937 struct frame_info
*this_frame
,
1938 void **this_prologue_cache
)
1940 CORE_ADDR addr_in_block
;
1941 bfd_byte insn
[S390_MAX_INSTR_SIZE
];
1943 /* If the current PC points to non-readable memory, we assume we
1944 have trapped due to an invalid function pointer call. We handle
1945 the non-existing current function like a PLT stub. */
1946 addr_in_block
= get_frame_address_in_block (this_frame
);
1947 if (in_plt_section (addr_in_block
)
1948 || s390_readinstruction (insn
, get_frame_pc (this_frame
)) < 0)
1953 static const struct frame_unwind s390_stub_frame_unwind
= {
1955 default_frame_unwind_stop_reason
,
1956 s390_stub_frame_this_id
,
1957 s390_stub_frame_prev_register
,
1959 s390_stub_frame_sniffer
1963 /* Signal trampoline stack frames. */
1965 struct s390_sigtramp_unwind_cache
{
1966 CORE_ADDR frame_base
;
1967 struct trad_frame_saved_reg
*saved_regs
;
1970 static struct s390_sigtramp_unwind_cache
*
1971 s390_sigtramp_frame_unwind_cache (struct frame_info
*this_frame
,
1972 void **this_prologue_cache
)
1974 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1975 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1976 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
1977 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1978 struct s390_sigtramp_unwind_cache
*info
;
1979 ULONGEST this_sp
, prev_sp
;
1980 CORE_ADDR next_ra
, next_cfa
, sigreg_ptr
, sigreg_high_off
;
1983 if (*this_prologue_cache
)
1984 return *this_prologue_cache
;
1986 info
= FRAME_OBSTACK_ZALLOC (struct s390_sigtramp_unwind_cache
);
1987 *this_prologue_cache
= info
;
1988 info
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
1990 this_sp
= get_frame_register_unsigned (this_frame
, S390_SP_REGNUM
);
1991 next_ra
= get_frame_pc (this_frame
);
1992 next_cfa
= this_sp
+ 16*word_size
+ 32;
1994 /* New-style RT frame:
1995 retcode + alignment (8 bytes)
1997 ucontext (contains sigregs at offset 5 words). */
1998 if (next_ra
== next_cfa
)
2000 sigreg_ptr
= next_cfa
+ 8 + 128 + align_up (5*word_size
, 8);
2001 /* sigregs are followed by uc_sigmask (8 bytes), then by the
2002 upper GPR halves if present. */
2003 sigreg_high_off
= 8;
2006 /* Old-style RT frame and all non-RT frames:
2007 old signal mask (8 bytes)
2008 pointer to sigregs. */
2011 sigreg_ptr
= read_memory_unsigned_integer (next_cfa
+ 8,
2012 word_size
, byte_order
);
2013 /* sigregs are followed by signo (4 bytes), then by the
2014 upper GPR halves if present. */
2015 sigreg_high_off
= 4;
2018 /* The sigregs structure looks like this:
2027 /* PSW mask and address. */
2028 info
->saved_regs
[S390_PSWM_REGNUM
].addr
= sigreg_ptr
;
2029 sigreg_ptr
+= word_size
;
2030 info
->saved_regs
[S390_PSWA_REGNUM
].addr
= sigreg_ptr
;
2031 sigreg_ptr
+= word_size
;
2033 /* Then the GPRs. */
2034 for (i
= 0; i
< 16; i
++)
2036 info
->saved_regs
[S390_R0_REGNUM
+ i
].addr
= sigreg_ptr
;
2037 sigreg_ptr
+= word_size
;
2040 /* Then the ACRs. */
2041 for (i
= 0; i
< 16; i
++)
2043 info
->saved_regs
[S390_A0_REGNUM
+ i
].addr
= sigreg_ptr
;
2047 /* The floating-point control word. */
2048 info
->saved_regs
[S390_FPC_REGNUM
].addr
= sigreg_ptr
;
2051 /* And finally the FPRs. */
2052 for (i
= 0; i
< 16; i
++)
2054 info
->saved_regs
[S390_F0_REGNUM
+ i
].addr
= sigreg_ptr
;
2058 /* If we have them, the GPR upper halves are appended at the end. */
2059 sigreg_ptr
+= sigreg_high_off
;
2060 if (tdep
->gpr_full_regnum
!= -1)
2061 for (i
= 0; i
< 16; i
++)
2063 info
->saved_regs
[S390_R0_UPPER_REGNUM
+ i
].addr
= sigreg_ptr
;
2067 /* Restore the previous frame's SP. */
2068 prev_sp
= read_memory_unsigned_integer (
2069 info
->saved_regs
[S390_SP_REGNUM
].addr
,
2070 word_size
, byte_order
);
2072 /* Determine our frame base. */
2073 info
->frame_base
= prev_sp
+ 16*word_size
+ 32;
2079 s390_sigtramp_frame_this_id (struct frame_info
*this_frame
,
2080 void **this_prologue_cache
,
2081 struct frame_id
*this_id
)
2083 struct s390_sigtramp_unwind_cache
*info
2084 = s390_sigtramp_frame_unwind_cache (this_frame
, this_prologue_cache
);
2085 *this_id
= frame_id_build (info
->frame_base
, get_frame_pc (this_frame
));
2088 static struct value
*
2089 s390_sigtramp_frame_prev_register (struct frame_info
*this_frame
,
2090 void **this_prologue_cache
, int regnum
)
2092 struct s390_sigtramp_unwind_cache
*info
2093 = s390_sigtramp_frame_unwind_cache (this_frame
, this_prologue_cache
);
2094 return s390_trad_frame_prev_register (this_frame
, info
->saved_regs
, regnum
);
2098 s390_sigtramp_frame_sniffer (const struct frame_unwind
*self
,
2099 struct frame_info
*this_frame
,
2100 void **this_prologue_cache
)
2102 CORE_ADDR pc
= get_frame_pc (this_frame
);
2103 bfd_byte sigreturn
[2];
2105 if (target_read_memory (pc
, sigreturn
, 2))
2108 if (sigreturn
[0] != op_svc
)
2111 if (sigreturn
[1] != 119 /* sigreturn */
2112 && sigreturn
[1] != 173 /* rt_sigreturn */)
2118 static const struct frame_unwind s390_sigtramp_frame_unwind
= {
2120 default_frame_unwind_stop_reason
,
2121 s390_sigtramp_frame_this_id
,
2122 s390_sigtramp_frame_prev_register
,
2124 s390_sigtramp_frame_sniffer
2127 /* Retrieve the syscall number at a ptrace syscall-stop. Return -1
2131 s390_linux_get_syscall_number (struct gdbarch
*gdbarch
,
2134 struct regcache
*regs
= get_thread_regcache (ptid
);
2135 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2136 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2138 ULONGEST svc_number
= -1;
2141 /* Assume that the PC points after the 2-byte SVC instruction. We
2142 don't currently support SVC via EXECUTE. */
2143 regcache_cooked_read_unsigned (regs
, tdep
->pc_regnum
, &pc
);
2145 opcode
= read_memory_unsigned_integer ((CORE_ADDR
) pc
, 1, byte_order
);
2146 if (opcode
!= op_svc
)
2149 svc_number
= read_memory_unsigned_integer ((CORE_ADDR
) pc
+ 1, 1,
2151 if (svc_number
== 0)
2152 regcache_cooked_read_unsigned (regs
, S390_R1_REGNUM
, &svc_number
);
2158 /* Frame base handling. */
2161 s390_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
2163 struct s390_unwind_cache
*info
2164 = s390_frame_unwind_cache (this_frame
, this_cache
);
2165 return info
->frame_base
;
2169 s390_local_base_address (struct frame_info
*this_frame
, void **this_cache
)
2171 struct s390_unwind_cache
*info
2172 = s390_frame_unwind_cache (this_frame
, this_cache
);
2173 return info
->local_base
;
2176 static const struct frame_base s390_frame_base
= {
2178 s390_frame_base_address
,
2179 s390_local_base_address
,
2180 s390_local_base_address
2184 s390_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2186 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2188 pc
= frame_unwind_register_unsigned (next_frame
, tdep
->pc_regnum
);
2189 return gdbarch_addr_bits_remove (gdbarch
, pc
);
2193 s390_unwind_sp (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2196 sp
= frame_unwind_register_unsigned (next_frame
, S390_SP_REGNUM
);
2197 return gdbarch_addr_bits_remove (gdbarch
, sp
);
2201 /* DWARF-2 frame support. */
2203 static struct value
*
2204 s390_dwarf2_prev_register (struct frame_info
*this_frame
, void **this_cache
,
2207 return s390_unwind_pseudo_register (this_frame
, regnum
);
2211 s390_dwarf2_frame_init_reg (struct gdbarch
*gdbarch
, int regnum
,
2212 struct dwarf2_frame_state_reg
*reg
,
2213 struct frame_info
*this_frame
)
2215 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2217 /* The condition code (and thus PSW mask) is call-clobbered. */
2218 if (regnum
== S390_PSWM_REGNUM
)
2219 reg
->how
= DWARF2_FRAME_REG_UNDEFINED
;
2221 /* The PSW address unwinds to the return address. */
2222 else if (regnum
== S390_PSWA_REGNUM
)
2223 reg
->how
= DWARF2_FRAME_REG_RA
;
2225 /* Fixed registers are call-saved or call-clobbered
2226 depending on the ABI in use. */
2227 else if (regnum
< S390_NUM_REGS
)
2229 if (s390_register_call_saved (gdbarch
, regnum
))
2230 reg
->how
= DWARF2_FRAME_REG_SAME_VALUE
;
2232 reg
->how
= DWARF2_FRAME_REG_UNDEFINED
;
2235 /* We install a special function to unwind pseudos. */
2238 reg
->how
= DWARF2_FRAME_REG_FN
;
2239 reg
->loc
.fn
= s390_dwarf2_prev_register
;
2244 /* Dummy function calls. */
2246 /* Return non-zero if TYPE is an integer-like type, zero otherwise.
2247 "Integer-like" types are those that should be passed the way
2248 integers are: integers, enums, ranges, characters, and booleans. */
2250 is_integer_like (struct type
*type
)
2252 enum type_code code
= TYPE_CODE (type
);
2254 return (code
== TYPE_CODE_INT
2255 || code
== TYPE_CODE_ENUM
2256 || code
== TYPE_CODE_RANGE
2257 || code
== TYPE_CODE_CHAR
2258 || code
== TYPE_CODE_BOOL
);
2261 /* Return non-zero if TYPE is a pointer-like type, zero otherwise.
2262 "Pointer-like" types are those that should be passed the way
2263 pointers are: pointers and references. */
2265 is_pointer_like (struct type
*type
)
2267 enum type_code code
= TYPE_CODE (type
);
2269 return (code
== TYPE_CODE_PTR
2270 || code
== TYPE_CODE_REF
);
2274 /* Return non-zero if TYPE is a `float singleton' or `double
2275 singleton', zero otherwise.
2277 A `T singleton' is a struct type with one member, whose type is
2278 either T or a `T singleton'. So, the following are all float
2282 struct { struct { float x; } x; };
2283 struct { struct { struct { float x; } x; } x; };
2287 All such structures are passed as if they were floats or doubles,
2288 as the (revised) ABI says. */
2290 is_float_singleton (struct type
*type
)
2292 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
&& TYPE_NFIELDS (type
) == 1)
2294 struct type
*singleton_type
= TYPE_FIELD_TYPE (type
, 0);
2295 CHECK_TYPEDEF (singleton_type
);
2297 return (TYPE_CODE (singleton_type
) == TYPE_CODE_FLT
2298 || TYPE_CODE (singleton_type
) == TYPE_CODE_DECFLOAT
2299 || is_float_singleton (singleton_type
));
2306 /* Return non-zero if TYPE is a struct-like type, zero otherwise.
2307 "Struct-like" types are those that should be passed as structs are:
2310 As an odd quirk, not mentioned in the ABI, GCC passes float and
2311 double singletons as if they were a plain float, double, etc. (The
2312 corresponding union types are handled normally.) So we exclude
2313 those types here. *shrug* */
2315 is_struct_like (struct type
*type
)
2317 enum type_code code
= TYPE_CODE (type
);
2319 return (code
== TYPE_CODE_UNION
2320 || (code
== TYPE_CODE_STRUCT
&& ! is_float_singleton (type
)));
2324 /* Return non-zero if TYPE is a float-like type, zero otherwise.
2325 "Float-like" types are those that should be passed as
2326 floating-point values are.
2328 You'd think this would just be floats, doubles, long doubles, etc.
2329 But as an odd quirk, not mentioned in the ABI, GCC passes float and
2330 double singletons as if they were a plain float, double, etc. (The
2331 corresponding union types are handled normally.) So we include
2332 those types here. *shrug* */
2334 is_float_like (struct type
*type
)
2336 return (TYPE_CODE (type
) == TYPE_CODE_FLT
2337 || TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
2338 || is_float_singleton (type
));
2343 is_power_of_two (unsigned int n
)
2345 return ((n
& (n
- 1)) == 0);
2348 /* Return non-zero if TYPE should be passed as a pointer to a copy,
2351 s390_function_arg_pass_by_reference (struct type
*type
)
2353 if (TYPE_LENGTH (type
) > 8)
2356 return (is_struct_like (type
) && !is_power_of_two (TYPE_LENGTH (type
)))
2357 || TYPE_CODE (type
) == TYPE_CODE_COMPLEX
2358 || (TYPE_CODE (type
) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (type
));
2361 /* Return non-zero if TYPE should be passed in a float register
2364 s390_function_arg_float (struct type
*type
)
2366 if (TYPE_LENGTH (type
) > 8)
2369 return is_float_like (type
);
2372 /* Return non-zero if TYPE should be passed in an integer register
2373 (or a pair of integer registers) if possible. */
2375 s390_function_arg_integer (struct type
*type
)
2377 if (TYPE_LENGTH (type
) > 8)
2380 return is_integer_like (type
)
2381 || is_pointer_like (type
)
2382 || (is_struct_like (type
) && is_power_of_two (TYPE_LENGTH (type
)));
2385 /* Return ARG, a `SIMPLE_ARG', sign-extended or zero-extended to a full
2386 word as required for the ABI. */
2388 extend_simple_arg (struct gdbarch
*gdbarch
, struct value
*arg
)
2390 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2391 struct type
*type
= check_typedef (value_type (arg
));
2393 /* Even structs get passed in the least significant bits of the
2394 register / memory word. It's not really right to extract them as
2395 an integer, but it does take care of the extension. */
2396 if (TYPE_UNSIGNED (type
))
2397 return extract_unsigned_integer (value_contents (arg
),
2398 TYPE_LENGTH (type
), byte_order
);
2400 return extract_signed_integer (value_contents (arg
),
2401 TYPE_LENGTH (type
), byte_order
);
2405 /* Return the alignment required by TYPE. */
2407 alignment_of (struct type
*type
)
2411 if (is_integer_like (type
)
2412 || is_pointer_like (type
)
2413 || TYPE_CODE (type
) == TYPE_CODE_FLT
2414 || TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
2415 alignment
= TYPE_LENGTH (type
);
2416 else if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
2417 || TYPE_CODE (type
) == TYPE_CODE_UNION
)
2422 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
2425 = alignment_of (check_typedef (TYPE_FIELD_TYPE (type
, i
)));
2427 if (field_alignment
> alignment
)
2428 alignment
= field_alignment
;
2434 /* Check that everything we ever return is a power of two. Lots of
2435 code doesn't want to deal with aligning things to arbitrary
2437 gdb_assert ((alignment
& (alignment
- 1)) == 0);
2443 /* Put the actual parameter values pointed to by ARGS[0..NARGS-1] in
2444 place to be passed to a function, as specified by the "GNU/Linux
2445 for S/390 ELF Application Binary Interface Supplement".
2447 SP is the current stack pointer. We must put arguments, links,
2448 padding, etc. whereever they belong, and return the new stack
2451 If STRUCT_RETURN is non-zero, then the function we're calling is
2452 going to return a structure by value; STRUCT_ADDR is the address of
2453 a block we've allocated for it on the stack.
2455 Our caller has taken care of any type promotions needed to satisfy
2456 prototypes or the old K&R argument-passing rules. */
2458 s390_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
2459 struct regcache
*regcache
, CORE_ADDR bp_addr
,
2460 int nargs
, struct value
**args
, CORE_ADDR sp
,
2461 int struct_return
, CORE_ADDR struct_addr
)
2463 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2464 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
2465 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2468 /* If the i'th argument is passed as a reference to a copy, then
2469 copy_addr[i] is the address of the copy we made. */
2470 CORE_ADDR
*copy_addr
= alloca (nargs
* sizeof (CORE_ADDR
));
2472 /* Reserve space for the reference-to-copy area. */
2473 for (i
= 0; i
< nargs
; i
++)
2475 struct value
*arg
= args
[i
];
2476 struct type
*type
= check_typedef (value_type (arg
));
2478 if (s390_function_arg_pass_by_reference (type
))
2480 sp
-= TYPE_LENGTH (type
);
2481 sp
= align_down (sp
, alignment_of (type
));
2486 /* Reserve space for the parameter area. As a conservative
2487 simplification, we assume that everything will be passed on the
2488 stack. Since every argument larger than 8 bytes will be
2489 passed by reference, we use this simple upper bound. */
2492 /* After all that, make sure it's still aligned on an eight-byte
2494 sp
= align_down (sp
, 8);
2496 /* Allocate the standard frame areas: the register save area, the
2497 word reserved for the compiler (which seems kind of meaningless),
2498 and the back chain pointer. */
2499 sp
-= 16*word_size
+ 32;
2501 /* Now we have the final SP value. Make sure we didn't underflow;
2502 on 31-bit, this would result in addresses with the high bit set,
2503 which causes confusion elsewhere. Note that if we error out
2504 here, stack and registers remain untouched. */
2505 if (gdbarch_addr_bits_remove (gdbarch
, sp
) != sp
)
2506 error (_("Stack overflow"));
2509 /* Finally, place the actual parameters, working from SP towards
2510 higher addresses. The code above is supposed to reserve enough
2515 CORE_ADDR starg
= sp
+ 16*word_size
+ 32;
2517 /* A struct is returned using general register 2. */
2520 regcache_cooked_write_unsigned (regcache
, S390_R0_REGNUM
+ gr
,
2525 for (i
= 0; i
< nargs
; i
++)
2527 struct value
*arg
= args
[i
];
2528 struct type
*type
= check_typedef (value_type (arg
));
2529 unsigned length
= TYPE_LENGTH (type
);
2531 if (s390_function_arg_pass_by_reference (type
))
2533 /* Actually copy the argument contents to the stack slot
2534 that was reserved above. */
2535 write_memory (copy_addr
[i
], value_contents (arg
), length
);
2539 regcache_cooked_write_unsigned (regcache
, S390_R0_REGNUM
+ gr
,
2545 write_memory_unsigned_integer (starg
, word_size
, byte_order
,
2550 else if (s390_function_arg_float (type
))
2552 /* The GNU/Linux for S/390 ABI uses FPRs 0 and 2 to pass arguments,
2553 the GNU/Linux for zSeries ABI uses 0, 2, 4, and 6. */
2554 if (fr
<= (tdep
->abi
== ABI_LINUX_S390
? 2 : 6))
2556 /* When we store a single-precision value in an FP register,
2557 it occupies the leftmost bits. */
2558 regcache_cooked_write_part (regcache
, S390_F0_REGNUM
+ fr
,
2559 0, length
, value_contents (arg
));
2564 /* When we store a single-precision value in a stack slot,
2565 it occupies the rightmost bits. */
2566 starg
= align_up (starg
+ length
, word_size
);
2567 write_memory (starg
- length
, value_contents (arg
), length
);
2570 else if (s390_function_arg_integer (type
) && length
<= word_size
)
2574 /* Integer arguments are always extended to word size. */
2575 regcache_cooked_write_signed (regcache
, S390_R0_REGNUM
+ gr
,
2576 extend_simple_arg (gdbarch
,
2582 /* Integer arguments are always extended to word size. */
2583 write_memory_signed_integer (starg
, word_size
, byte_order
,
2584 extend_simple_arg (gdbarch
, arg
));
2588 else if (s390_function_arg_integer (type
) && length
== 2*word_size
)
2592 regcache_cooked_write (regcache
, S390_R0_REGNUM
+ gr
,
2593 value_contents (arg
));
2594 regcache_cooked_write (regcache
, S390_R0_REGNUM
+ gr
+ 1,
2595 value_contents (arg
) + word_size
);
2600 /* If we skipped r6 because we couldn't fit a DOUBLE_ARG
2601 in it, then don't go back and use it again later. */
2604 write_memory (starg
, value_contents (arg
), length
);
2609 internal_error (__FILE__
, __LINE__
, _("unknown argument type"));
2613 /* Store return PSWA. In 31-bit mode, keep addressing mode bit. */
2617 regcache_cooked_read_unsigned (regcache
, S390_PSWA_REGNUM
, &pswa
);
2618 bp_addr
= (bp_addr
& 0x7fffffff) | (pswa
& 0x80000000);
2620 regcache_cooked_write_unsigned (regcache
, S390_RETADDR_REGNUM
, bp_addr
);
2622 /* Store updated stack pointer. */
2623 regcache_cooked_write_unsigned (regcache
, S390_SP_REGNUM
, sp
);
2625 /* We need to return the 'stack part' of the frame ID,
2626 which is actually the top of the register save area. */
2627 return sp
+ 16*word_size
+ 32;
2630 /* Assuming THIS_FRAME is a dummy, return the frame ID of that
2631 dummy frame. The frame ID's base needs to match the TOS value
2632 returned by push_dummy_call, and the PC match the dummy frame's
2634 static struct frame_id
2635 s390_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*this_frame
)
2637 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
2638 CORE_ADDR sp
= get_frame_register_unsigned (this_frame
, S390_SP_REGNUM
);
2639 sp
= gdbarch_addr_bits_remove (gdbarch
, sp
);
2641 return frame_id_build (sp
+ 16*word_size
+ 32,
2642 get_frame_pc (this_frame
));
2646 s390_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
2648 /* Both the 32- and 64-bit ABI's say that the stack pointer should
2649 always be aligned on an eight-byte boundary. */
2654 /* Function return value access. */
2656 static enum return_value_convention
2657 s390_return_value_convention (struct gdbarch
*gdbarch
, struct type
*type
)
2659 if (TYPE_LENGTH (type
) > 8)
2660 return RETURN_VALUE_STRUCT_CONVENTION
;
2662 switch (TYPE_CODE (type
))
2664 case TYPE_CODE_STRUCT
:
2665 case TYPE_CODE_UNION
:
2666 case TYPE_CODE_ARRAY
:
2667 case TYPE_CODE_COMPLEX
:
2668 return RETURN_VALUE_STRUCT_CONVENTION
;
2671 return RETURN_VALUE_REGISTER_CONVENTION
;
2675 static enum return_value_convention
2676 s390_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
2677 struct type
*type
, struct regcache
*regcache
,
2678 gdb_byte
*out
, const gdb_byte
*in
)
2680 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2681 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
2682 enum return_value_convention rvc
;
2685 type
= check_typedef (type
);
2686 rvc
= s390_return_value_convention (gdbarch
, type
);
2687 length
= TYPE_LENGTH (type
);
2693 case RETURN_VALUE_REGISTER_CONVENTION
:
2694 if (TYPE_CODE (type
) == TYPE_CODE_FLT
2695 || TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
2697 /* When we store a single-precision value in an FP register,
2698 it occupies the leftmost bits. */
2699 regcache_cooked_write_part (regcache
, S390_F0_REGNUM
,
2702 else if (length
<= word_size
)
2704 /* Integer arguments are always extended to word size. */
2705 if (TYPE_UNSIGNED (type
))
2706 regcache_cooked_write_unsigned (regcache
, S390_R2_REGNUM
,
2707 extract_unsigned_integer (in
, length
, byte_order
));
2709 regcache_cooked_write_signed (regcache
, S390_R2_REGNUM
,
2710 extract_signed_integer (in
, length
, byte_order
));
2712 else if (length
== 2*word_size
)
2714 regcache_cooked_write (regcache
, S390_R2_REGNUM
, in
);
2715 regcache_cooked_write (regcache
, S390_R3_REGNUM
, in
+ word_size
);
2718 internal_error (__FILE__
, __LINE__
, _("invalid return type"));
2721 case RETURN_VALUE_STRUCT_CONVENTION
:
2722 error (_("Cannot set function return value."));
2730 case RETURN_VALUE_REGISTER_CONVENTION
:
2731 if (TYPE_CODE (type
) == TYPE_CODE_FLT
2732 || TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
2734 /* When we store a single-precision value in an FP register,
2735 it occupies the leftmost bits. */
2736 regcache_cooked_read_part (regcache
, S390_F0_REGNUM
,
2739 else if (length
<= word_size
)
2741 /* Integer arguments occupy the rightmost bits. */
2742 regcache_cooked_read_part (regcache
, S390_R2_REGNUM
,
2743 word_size
- length
, length
, out
);
2745 else if (length
== 2*word_size
)
2747 regcache_cooked_read (regcache
, S390_R2_REGNUM
, out
);
2748 regcache_cooked_read (regcache
, S390_R3_REGNUM
, out
+ word_size
);
2751 internal_error (__FILE__
, __LINE__
, _("invalid return type"));
2754 case RETURN_VALUE_STRUCT_CONVENTION
:
2755 error (_("Function return value unknown."));
2766 static const gdb_byte
*
2767 s390_breakpoint_from_pc (struct gdbarch
*gdbarch
,
2768 CORE_ADDR
*pcptr
, int *lenptr
)
2770 static const gdb_byte breakpoint
[] = { 0x0, 0x1 };
2772 *lenptr
= sizeof (breakpoint
);
2777 /* Address handling. */
2780 s390_addr_bits_remove (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
2782 return addr
& 0x7fffffff;
2786 s390_address_class_type_flags (int byte_size
, int dwarf2_addr_class
)
2789 return TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1
;
2795 s390_address_class_type_flags_to_name (struct gdbarch
*gdbarch
, int type_flags
)
2797 if (type_flags
& TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1
)
2804 s390_address_class_name_to_type_flags (struct gdbarch
*gdbarch
,
2806 int *type_flags_ptr
)
2808 if (strcmp (name
, "mode32") == 0)
2810 *type_flags_ptr
= TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1
;
2817 /* Implement gdbarch_gcc_target_options. GCC does not know "-m32" or
2818 "-mcmodel=large". */
2821 s390_gcc_target_options (struct gdbarch
*gdbarch
)
2823 return xstrdup (gdbarch_ptr_bit (gdbarch
) == 64 ? "-m64" : "-m31");
2826 /* Implement gdbarch_gnu_triplet_regexp. Target triplets are "s390-*"
2827 for 31-bit and "s390x-*" for 64-bit, while the BFD arch name is
2828 always "s390". Note that an s390x compiler supports "-m31" as
2832 s390_gnu_triplet_regexp (struct gdbarch
*gdbarch
)
2837 /* Implementation of `gdbarch_stap_is_single_operand', as defined in
2841 s390_stap_is_single_operand (struct gdbarch
*gdbarch
, const char *s
)
2843 return ((isdigit (*s
) && s
[1] == '(' && s
[2] == '%') /* Displacement
2845 || *s
== '%' /* Register access. */
2846 || isdigit (*s
)); /* Literal number. */
2849 /* Set up gdbarch struct. */
2851 static struct gdbarch
*
2852 s390_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
2854 const struct target_desc
*tdesc
= info
.target_desc
;
2855 struct tdesc_arch_data
*tdesc_data
= NULL
;
2856 struct gdbarch
*gdbarch
;
2857 struct gdbarch_tdep
*tdep
;
2860 int have_linux_v1
= 0;
2861 int have_linux_v2
= 0;
2863 int first_pseudo_reg
, last_pseudo_reg
;
2864 static const char *const stap_register_prefixes
[] = { "%", NULL
};
2865 static const char *const stap_register_indirection_prefixes
[] = { "(",
2867 static const char *const stap_register_indirection_suffixes
[] = { ")",
2870 /* Default ABI and register size. */
2871 switch (info
.bfd_arch_info
->mach
)
2873 case bfd_mach_s390_31
:
2874 tdep_abi
= ABI_LINUX_S390
;
2877 case bfd_mach_s390_64
:
2878 tdep_abi
= ABI_LINUX_ZSERIES
;
2885 /* Use default target description if none provided by the target. */
2886 if (!tdesc_has_registers (tdesc
))
2888 if (tdep_abi
== ABI_LINUX_S390
)
2889 tdesc
= tdesc_s390_linux32
;
2891 tdesc
= tdesc_s390x_linux64
;
2894 /* Check any target description for validity. */
2895 if (tdesc_has_registers (tdesc
))
2897 static const char *const gprs
[] = {
2898 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2899 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
2901 static const char *const fprs
[] = {
2902 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
2903 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15"
2905 static const char *const acrs
[] = {
2906 "acr0", "acr1", "acr2", "acr3", "acr4", "acr5", "acr6", "acr7",
2907 "acr8", "acr9", "acr10", "acr11", "acr12", "acr13", "acr14", "acr15"
2909 static const char *const gprs_lower
[] = {
2910 "r0l", "r1l", "r2l", "r3l", "r4l", "r5l", "r6l", "r7l",
2911 "r8l", "r9l", "r10l", "r11l", "r12l", "r13l", "r14l", "r15l"
2913 static const char *const gprs_upper
[] = {
2914 "r0h", "r1h", "r2h", "r3h", "r4h", "r5h", "r6h", "r7h",
2915 "r8h", "r9h", "r10h", "r11h", "r12h", "r13h", "r14h", "r15h"
2917 static const char *const tdb_regs
[] = {
2918 "tdb0", "tac", "tct", "atia",
2919 "tr0", "tr1", "tr2", "tr3", "tr4", "tr5", "tr6", "tr7",
2920 "tr8", "tr9", "tr10", "tr11", "tr12", "tr13", "tr14", "tr15"
2922 const struct tdesc_feature
*feature
;
2925 feature
= tdesc_find_feature (tdesc
, "org.gnu.gdb.s390.core");
2926 if (feature
== NULL
)
2929 tdesc_data
= tdesc_data_alloc ();
2931 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
2932 S390_PSWM_REGNUM
, "pswm");
2933 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
2934 S390_PSWA_REGNUM
, "pswa");
2936 if (tdesc_unnumbered_register (feature
, "r0"))
2938 for (i
= 0; i
< 16; i
++)
2939 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
2940 S390_R0_REGNUM
+ i
, gprs
[i
]);
2946 for (i
= 0; i
< 16; i
++)
2947 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
2950 for (i
= 0; i
< 16; i
++)
2951 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
2952 S390_R0_UPPER_REGNUM
+ i
,
2956 feature
= tdesc_find_feature (tdesc
, "org.gnu.gdb.s390.fpr");
2957 if (feature
== NULL
)
2959 tdesc_data_cleanup (tdesc_data
);
2963 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
2964 S390_FPC_REGNUM
, "fpc");
2965 for (i
= 0; i
< 16; i
++)
2966 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
2967 S390_F0_REGNUM
+ i
, fprs
[i
]);
2969 feature
= tdesc_find_feature (tdesc
, "org.gnu.gdb.s390.acr");
2970 if (feature
== NULL
)
2972 tdesc_data_cleanup (tdesc_data
);
2976 for (i
= 0; i
< 16; i
++)
2977 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
2978 S390_A0_REGNUM
+ i
, acrs
[i
]);
2980 /* Optional GNU/Linux-specific "registers". */
2981 feature
= tdesc_find_feature (tdesc
, "org.gnu.gdb.s390.linux");
2984 tdesc_numbered_register (feature
, tdesc_data
,
2985 S390_ORIG_R2_REGNUM
, "orig_r2");
2987 if (tdesc_numbered_register (feature
, tdesc_data
,
2988 S390_LAST_BREAK_REGNUM
, "last_break"))
2991 if (tdesc_numbered_register (feature
, tdesc_data
,
2992 S390_SYSTEM_CALL_REGNUM
, "system_call"))
2995 if (have_linux_v2
> have_linux_v1
)
2999 /* Transaction diagnostic block. */
3000 feature
= tdesc_find_feature (tdesc
, "org.gnu.gdb.s390.tdb");
3003 for (i
= 0; i
< ARRAY_SIZE (tdb_regs
); i
++)
3004 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
3005 S390_TDB_DWORD0_REGNUM
+ i
,
3012 tdesc_data_cleanup (tdesc_data
);
3017 /* Find a candidate among extant architectures. */
3018 for (arches
= gdbarch_list_lookup_by_info (arches
, &info
);
3020 arches
= gdbarch_list_lookup_by_info (arches
->next
, &info
))
3022 tdep
= gdbarch_tdep (arches
->gdbarch
);
3025 if (tdep
->abi
!= tdep_abi
)
3027 if ((tdep
->gpr_full_regnum
!= -1) != have_upper
)
3029 if (tdesc_data
!= NULL
)
3030 tdesc_data_cleanup (tdesc_data
);
3031 return arches
->gdbarch
;
3034 /* Otherwise create a new gdbarch for the specified machine type. */
3035 tdep
= XCNEW (struct gdbarch_tdep
);
3036 tdep
->abi
= tdep_abi
;
3037 tdep
->have_linux_v1
= have_linux_v1
;
3038 tdep
->have_linux_v2
= have_linux_v2
;
3039 tdep
->have_tdb
= have_tdb
;
3040 gdbarch
= gdbarch_alloc (&info
, tdep
);
3042 set_gdbarch_believe_pcc_promotion (gdbarch
, 0);
3043 set_gdbarch_char_signed (gdbarch
, 0);
3045 /* S/390 GNU/Linux uses either 64-bit or 128-bit long doubles.
3046 We can safely let them default to 128-bit, since the debug info
3047 will give the size of type actually used in each case. */
3048 set_gdbarch_long_double_bit (gdbarch
, 128);
3049 set_gdbarch_long_double_format (gdbarch
, floatformats_ia64_quad
);
3051 /* Amount PC must be decremented by after a breakpoint. This is
3052 often the number of bytes returned by gdbarch_breakpoint_from_pc but not
3054 set_gdbarch_decr_pc_after_break (gdbarch
, 2);
3055 /* Stack grows downward. */
3056 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
3057 set_gdbarch_breakpoint_from_pc (gdbarch
, s390_breakpoint_from_pc
);
3058 set_gdbarch_skip_prologue (gdbarch
, s390_skip_prologue
);
3059 set_gdbarch_in_function_epilogue_p (gdbarch
, s390_in_function_epilogue_p
);
3061 set_gdbarch_num_regs (gdbarch
, S390_NUM_REGS
);
3062 set_gdbarch_sp_regnum (gdbarch
, S390_SP_REGNUM
);
3063 set_gdbarch_fp0_regnum (gdbarch
, S390_F0_REGNUM
);
3064 set_gdbarch_stab_reg_to_regnum (gdbarch
, s390_dwarf_reg_to_regnum
);
3065 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, s390_dwarf_reg_to_regnum
);
3066 set_gdbarch_value_from_register (gdbarch
, s390_value_from_register
);
3067 set_gdbarch_core_read_description (gdbarch
, s390_core_read_description
);
3068 set_gdbarch_iterate_over_regset_sections (gdbarch
,
3069 s390_iterate_over_regset_sections
);
3070 set_gdbarch_cannot_store_register (gdbarch
, s390_cannot_store_register
);
3071 set_gdbarch_write_pc (gdbarch
, s390_write_pc
);
3072 set_gdbarch_pseudo_register_read (gdbarch
, s390_pseudo_register_read
);
3073 set_gdbarch_pseudo_register_write (gdbarch
, s390_pseudo_register_write
);
3074 set_tdesc_pseudo_register_name (gdbarch
, s390_pseudo_register_name
);
3075 set_tdesc_pseudo_register_type (gdbarch
, s390_pseudo_register_type
);
3076 set_tdesc_pseudo_register_reggroup_p (gdbarch
,
3077 s390_pseudo_register_reggroup_p
);
3078 tdesc_use_registers (gdbarch
, tdesc
, tdesc_data
);
3080 /* Assign pseudo register numbers. */
3081 first_pseudo_reg
= gdbarch_num_regs (gdbarch
);
3082 last_pseudo_reg
= first_pseudo_reg
;
3083 tdep
->gpr_full_regnum
= -1;
3086 tdep
->gpr_full_regnum
= last_pseudo_reg
;
3087 last_pseudo_reg
+= 16;
3089 tdep
->pc_regnum
= last_pseudo_reg
++;
3090 tdep
->cc_regnum
= last_pseudo_reg
++;
3091 set_gdbarch_pc_regnum (gdbarch
, tdep
->pc_regnum
);
3092 set_gdbarch_num_pseudo_regs (gdbarch
, last_pseudo_reg
- first_pseudo_reg
);
3094 /* Inferior function calls. */
3095 set_gdbarch_push_dummy_call (gdbarch
, s390_push_dummy_call
);
3096 set_gdbarch_dummy_id (gdbarch
, s390_dummy_id
);
3097 set_gdbarch_frame_align (gdbarch
, s390_frame_align
);
3098 set_gdbarch_return_value (gdbarch
, s390_return_value
);
3100 /* Syscall handling. */
3101 set_gdbarch_get_syscall_number (gdbarch
, s390_linux_get_syscall_number
);
3103 /* Frame handling. */
3104 dwarf2_frame_set_init_reg (gdbarch
, s390_dwarf2_frame_init_reg
);
3105 dwarf2_frame_set_adjust_regnum (gdbarch
, s390_adjust_frame_regnum
);
3106 dwarf2_append_unwinders (gdbarch
);
3107 frame_base_append_sniffer (gdbarch
, dwarf2_frame_base_sniffer
);
3108 frame_unwind_append_unwinder (gdbarch
, &s390_stub_frame_unwind
);
3109 frame_unwind_append_unwinder (gdbarch
, &s390_sigtramp_frame_unwind
);
3110 frame_unwind_append_unwinder (gdbarch
, &s390_frame_unwind
);
3111 frame_base_set_default (gdbarch
, &s390_frame_base
);
3112 set_gdbarch_unwind_pc (gdbarch
, s390_unwind_pc
);
3113 set_gdbarch_unwind_sp (gdbarch
, s390_unwind_sp
);
3115 /* Displaced stepping. */
3116 set_gdbarch_displaced_step_copy_insn (gdbarch
,
3117 simple_displaced_step_copy_insn
);
3118 set_gdbarch_displaced_step_fixup (gdbarch
, s390_displaced_step_fixup
);
3119 set_gdbarch_displaced_step_free_closure (gdbarch
,
3120 simple_displaced_step_free_closure
);
3121 set_gdbarch_displaced_step_location (gdbarch
,
3122 displaced_step_at_entry_point
);
3123 set_gdbarch_max_insn_length (gdbarch
, S390_MAX_INSTR_SIZE
);
3125 /* Note that GNU/Linux is the only OS supported on this
3127 linux_init_abi (info
, gdbarch
);
3131 case ABI_LINUX_S390
:
3132 set_gdbarch_addr_bits_remove (gdbarch
, s390_addr_bits_remove
);
3133 set_solib_svr4_fetch_link_map_offsets
3134 (gdbarch
, svr4_ilp32_fetch_link_map_offsets
);
3136 set_xml_syscall_file_name (gdbarch
, XML_SYSCALL_FILENAME_S390
);
3139 case ABI_LINUX_ZSERIES
:
3140 set_gdbarch_long_bit (gdbarch
, 64);
3141 set_gdbarch_long_long_bit (gdbarch
, 64);
3142 set_gdbarch_ptr_bit (gdbarch
, 64);
3143 set_solib_svr4_fetch_link_map_offsets
3144 (gdbarch
, svr4_lp64_fetch_link_map_offsets
);
3145 set_gdbarch_address_class_type_flags (gdbarch
,
3146 s390_address_class_type_flags
);
3147 set_gdbarch_address_class_type_flags_to_name (gdbarch
,
3148 s390_address_class_type_flags_to_name
);
3149 set_gdbarch_address_class_name_to_type_flags (gdbarch
,
3150 s390_address_class_name_to_type_flags
);
3151 set_xml_syscall_file_name (gdbarch
, XML_SYSCALL_FILENAME_S390
);
3155 set_gdbarch_print_insn (gdbarch
, print_insn_s390
);
3157 set_gdbarch_skip_trampoline_code (gdbarch
, find_solib_trampoline_target
);
3159 /* Enable TLS support. */
3160 set_gdbarch_fetch_tls_load_module_address (gdbarch
,
3161 svr4_fetch_objfile_link_map
);
3163 set_gdbarch_get_siginfo_type (gdbarch
, linux_get_siginfo_type
);
3165 /* SystemTap functions. */
3166 set_gdbarch_stap_register_prefixes (gdbarch
, stap_register_prefixes
);
3167 set_gdbarch_stap_register_indirection_prefixes (gdbarch
,
3168 stap_register_indirection_prefixes
);
3169 set_gdbarch_stap_register_indirection_suffixes (gdbarch
,
3170 stap_register_indirection_suffixes
);
3171 set_gdbarch_stap_is_single_operand (gdbarch
, s390_stap_is_single_operand
);
3172 set_gdbarch_gcc_target_options (gdbarch
, s390_gcc_target_options
);
3173 set_gdbarch_gnu_triplet_regexp (gdbarch
, s390_gnu_triplet_regexp
);
3179 extern initialize_file_ftype _initialize_s390_tdep
; /* -Wmissing-prototypes */
3182 _initialize_s390_tdep (void)
3184 /* Hook us into the gdbarch mechanism. */
3185 register_gdbarch_init (bfd_arch_s390
, s390_gdbarch_init
);
3187 /* Initialize the GNU/Linux target descriptions. */
3188 initialize_tdesc_s390_linux32 ();
3189 initialize_tdesc_s390_linux32v1 ();
3190 initialize_tdesc_s390_linux32v2 ();
3191 initialize_tdesc_s390_linux64 ();
3192 initialize_tdesc_s390_linux64v1 ();
3193 initialize_tdesc_s390_linux64v2 ();
3194 initialize_tdesc_s390_te_linux64 ();
3195 initialize_tdesc_s390x_linux64 ();
3196 initialize_tdesc_s390x_linux64v1 ();
3197 initialize_tdesc_s390x_linux64v2 ();
3198 initialize_tdesc_s390x_te_linux64 ();