1 /* Target-dependent code for GDB, the GNU debugger.
3 Copyright (C) 2001-2014 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"
73 /* The tdep structure. */
78 enum { ABI_LINUX_S390, ABI_LINUX_ZSERIES } abi;
80 /* Pseudo register numbers. */
91 /* ABI call-saved register information. */
94 s390_register_call_saved (struct gdbarch *gdbarch, int regnum)
96 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
101 if ((regnum >= S390_R6_REGNUM && regnum <= S390_R15_REGNUM)
102 || regnum == S390_F4_REGNUM || regnum == S390_F6_REGNUM
103 || regnum == S390_A0_REGNUM)
108 case ABI_LINUX_ZSERIES:
109 if ((regnum >= S390_R6_REGNUM && regnum <= S390_R15_REGNUM)
110 || (regnum >= S390_F8_REGNUM && regnum <= S390_F15_REGNUM)
111 || (regnum >= S390_A0_REGNUM && regnum <= S390_A1_REGNUM))
121 s390_cannot_store_register (struct gdbarch *gdbarch, int regnum)
123 /* The last-break address is read-only. */
124 return regnum == S390_LAST_BREAK_REGNUM;
128 s390_write_pc (struct regcache *regcache, CORE_ADDR pc)
130 struct gdbarch *gdbarch = get_regcache_arch (regcache);
131 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
133 regcache_cooked_write_unsigned (regcache, tdep->pc_regnum, pc);
135 /* Set special SYSTEM_CALL register to 0 to prevent the kernel from
136 messing with the PC we just installed, if we happen to be within
137 an interrupted system call that the kernel wants to restart.
139 Note that after we return from the dummy call, the SYSTEM_CALL and
140 ORIG_R2 registers will be automatically restored, and the kernel
141 continues to restart the system call at this point. */
142 if (register_size (gdbarch, S390_SYSTEM_CALL_REGNUM) > 0)
143 regcache_cooked_write_unsigned (regcache, S390_SYSTEM_CALL_REGNUM, 0);
147 /* DWARF Register Mapping. */
149 static const short s390_dwarf_regmap[] =
151 /* General Purpose Registers. */
152 S390_R0_REGNUM, S390_R1_REGNUM, S390_R2_REGNUM, S390_R3_REGNUM,
153 S390_R4_REGNUM, S390_R5_REGNUM, S390_R6_REGNUM, S390_R7_REGNUM,
154 S390_R8_REGNUM, S390_R9_REGNUM, S390_R10_REGNUM, S390_R11_REGNUM,
155 S390_R12_REGNUM, S390_R13_REGNUM, S390_R14_REGNUM, S390_R15_REGNUM,
157 /* Floating Point Registers. */
158 S390_F0_REGNUM, S390_F2_REGNUM, S390_F4_REGNUM, S390_F6_REGNUM,
159 S390_F1_REGNUM, S390_F3_REGNUM, S390_F5_REGNUM, S390_F7_REGNUM,
160 S390_F8_REGNUM, S390_F10_REGNUM, S390_F12_REGNUM, S390_F14_REGNUM,
161 S390_F9_REGNUM, S390_F11_REGNUM, S390_F13_REGNUM, S390_F15_REGNUM,
163 /* Control Registers (not mapped). */
164 -1, -1, -1, -1, -1, -1, -1, -1,
165 -1, -1, -1, -1, -1, -1, -1, -1,
167 /* Access Registers. */
168 S390_A0_REGNUM, S390_A1_REGNUM, S390_A2_REGNUM, S390_A3_REGNUM,
169 S390_A4_REGNUM, S390_A5_REGNUM, S390_A6_REGNUM, S390_A7_REGNUM,
170 S390_A8_REGNUM, S390_A9_REGNUM, S390_A10_REGNUM, S390_A11_REGNUM,
171 S390_A12_REGNUM, S390_A13_REGNUM, S390_A14_REGNUM, S390_A15_REGNUM,
173 /* Program Status Word. */
177 /* GPR Lower Half Access. */
178 S390_R0_REGNUM, S390_R1_REGNUM, S390_R2_REGNUM, S390_R3_REGNUM,
179 S390_R4_REGNUM, S390_R5_REGNUM, S390_R6_REGNUM, S390_R7_REGNUM,
180 S390_R8_REGNUM, S390_R9_REGNUM, S390_R10_REGNUM, S390_R11_REGNUM,
181 S390_R12_REGNUM, S390_R13_REGNUM, S390_R14_REGNUM, S390_R15_REGNUM,
183 /* GNU/Linux-specific registers (not mapped). */
187 /* Convert DWARF register number REG to the appropriate register
188 number used by GDB. */
190 s390_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int reg)
192 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
194 /* In a 32-on-64 debug scenario, debug info refers to the full 64-bit
195 GPRs. Note that call frame information still refers to the 32-bit
196 lower halves, because s390_adjust_frame_regnum uses register numbers
197 66 .. 81 to access GPRs. */
198 if (tdep->gpr_full_regnum != -1 && reg >= 0 && reg < 16)
199 return tdep->gpr_full_regnum + reg;
201 if (reg >= 0 && reg < ARRAY_SIZE (s390_dwarf_regmap))
202 return s390_dwarf_regmap[reg];
204 warning (_("Unmapped DWARF Register #%d encountered."), reg);
208 /* Translate a .eh_frame register to DWARF register, or adjust a
209 .debug_frame register. */
211 s390_adjust_frame_regnum (struct gdbarch *gdbarch, int num, int eh_frame_p)
213 /* See s390_dwarf_reg_to_regnum for comments. */
214 return (num >= 0 && num < 16)? num + 66 : num;
218 /* Pseudo registers. */
221 regnum_is_gpr_full (struct gdbarch_tdep *tdep, int regnum)
223 return (tdep->gpr_full_regnum != -1
224 && regnum >= tdep->gpr_full_regnum
225 && regnum <= tdep->gpr_full_regnum + 15);
229 s390_pseudo_register_name (struct gdbarch *gdbarch, int regnum)
231 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
233 if (regnum == tdep->pc_regnum)
236 if (regnum == tdep->cc_regnum)
239 if (regnum_is_gpr_full (tdep, regnum))
241 static const char *full_name[] = {
242 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
243 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
245 return full_name[regnum - tdep->gpr_full_regnum];
248 internal_error (__FILE__, __LINE__, _("invalid regnum"));
252 s390_pseudo_register_type (struct gdbarch *gdbarch, int regnum)
254 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
256 if (regnum == tdep->pc_regnum)
257 return builtin_type (gdbarch)->builtin_func_ptr;
259 if (regnum == tdep->cc_regnum)
260 return builtin_type (gdbarch)->builtin_int;
262 if (regnum_is_gpr_full (tdep, regnum))
263 return builtin_type (gdbarch)->builtin_uint64;
265 internal_error (__FILE__, __LINE__, _("invalid regnum"));
268 static enum register_status
269 s390_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
270 int regnum, gdb_byte *buf)
272 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
273 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
274 int regsize = register_size (gdbarch, regnum);
277 if (regnum == tdep->pc_regnum)
279 enum register_status status;
281 status = regcache_raw_read_unsigned (regcache, S390_PSWA_REGNUM, &val);
282 if (status == REG_VALID)
284 if (register_size (gdbarch, S390_PSWA_REGNUM) == 4)
286 store_unsigned_integer (buf, regsize, byte_order, val);
291 if (regnum == tdep->cc_regnum)
293 enum register_status status;
295 status = regcache_raw_read_unsigned (regcache, S390_PSWM_REGNUM, &val);
296 if (status == REG_VALID)
298 if (register_size (gdbarch, S390_PSWA_REGNUM) == 4)
299 val = (val >> 12) & 3;
301 val = (val >> 44) & 3;
302 store_unsigned_integer (buf, regsize, byte_order, val);
307 if (regnum_is_gpr_full (tdep, regnum))
309 enum register_status status;
312 regnum -= tdep->gpr_full_regnum;
314 status = regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + regnum, &val);
315 if (status == REG_VALID)
316 status = regcache_raw_read_unsigned (regcache, S390_R0_UPPER_REGNUM + regnum,
318 if (status == REG_VALID)
320 val |= val_upper << 32;
321 store_unsigned_integer (buf, regsize, byte_order, val);
326 internal_error (__FILE__, __LINE__, _("invalid regnum"));
330 s390_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
331 int regnum, const gdb_byte *buf)
333 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
334 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
335 int regsize = register_size (gdbarch, regnum);
338 if (regnum == tdep->pc_regnum)
340 val = extract_unsigned_integer (buf, regsize, byte_order);
341 if (register_size (gdbarch, S390_PSWA_REGNUM) == 4)
343 regcache_raw_read_unsigned (regcache, S390_PSWA_REGNUM, &psw);
344 val = (psw & 0x80000000) | (val & 0x7fffffff);
346 regcache_raw_write_unsigned (regcache, S390_PSWA_REGNUM, val);
350 if (regnum == tdep->cc_regnum)
352 val = extract_unsigned_integer (buf, regsize, byte_order);
353 regcache_raw_read_unsigned (regcache, S390_PSWM_REGNUM, &psw);
354 if (register_size (gdbarch, S390_PSWA_REGNUM) == 4)
355 val = (psw & ~((ULONGEST)3 << 12)) | ((val & 3) << 12);
357 val = (psw & ~((ULONGEST)3 << 44)) | ((val & 3) << 44);
358 regcache_raw_write_unsigned (regcache, S390_PSWM_REGNUM, val);
362 if (regnum_is_gpr_full (tdep, regnum))
364 regnum -= tdep->gpr_full_regnum;
365 val = extract_unsigned_integer (buf, regsize, byte_order);
366 regcache_raw_write_unsigned (regcache, S390_R0_REGNUM + regnum,
368 regcache_raw_write_unsigned (regcache, S390_R0_UPPER_REGNUM + regnum,
373 internal_error (__FILE__, __LINE__, _("invalid regnum"));
376 /* 'float' values are stored in the upper half of floating-point
377 registers, even though we are otherwise a big-endian platform. */
379 static struct value *
380 s390_value_from_register (struct gdbarch *gdbarch, struct type *type,
381 int regnum, struct frame_id frame_id)
383 struct value *value = default_value_from_register (gdbarch, type,
385 check_typedef (type);
387 if (regnum >= S390_F0_REGNUM && regnum <= S390_F15_REGNUM
388 && TYPE_LENGTH (type) < 8)
389 set_value_offset (value, 0);
394 /* Register groups. */
397 s390_pseudo_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
398 struct reggroup *group)
400 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
402 /* We usually save/restore the whole PSW, which includes PC and CC.
403 However, some older gdbservers may not support saving/restoring
404 the whole PSW yet, and will return an XML register description
405 excluding those from the save/restore register groups. In those
406 cases, we still need to explicitly save/restore PC and CC in order
407 to push or pop frames. Since this doesn't hurt anything if we
408 already save/restore the whole PSW (it's just redundant), we add
409 PC and CC at this point unconditionally. */
410 if (group == save_reggroup || group == restore_reggroup)
411 return regnum == tdep->pc_regnum || regnum == tdep->cc_regnum;
413 return default_register_reggroup_p (gdbarch, regnum, group);
417 /* Maps for register sets. */
419 static const struct regcache_map_entry s390_gregmap[] =
421 { 1, S390_PSWM_REGNUM },
422 { 1, S390_PSWA_REGNUM },
423 { 16, S390_R0_REGNUM },
424 { 16, S390_A0_REGNUM },
425 { 1, S390_ORIG_R2_REGNUM },
429 static const struct regcache_map_entry s390_fpregmap[] =
431 { 1, S390_FPC_REGNUM, 8 },
432 { 16, S390_F0_REGNUM, 8 },
436 static const struct regcache_map_entry s390_regmap_upper[] =
438 { 16, S390_R0_UPPER_REGNUM, 4 },
442 static const struct regcache_map_entry s390_regmap_last_break[] =
444 { 1, REGCACHE_MAP_SKIP, 4 },
445 { 1, S390_LAST_BREAK_REGNUM, 4 },
449 static const struct regcache_map_entry s390x_regmap_last_break[] =
451 { 1, S390_LAST_BREAK_REGNUM, 8 },
455 static const struct regcache_map_entry s390_regmap_system_call[] =
457 { 1, S390_SYSTEM_CALL_REGNUM, 4 },
461 static const struct regcache_map_entry s390_regmap_tdb[] =
463 { 1, S390_TDB_DWORD0_REGNUM, 8 },
464 { 1, S390_TDB_ABORT_CODE_REGNUM, 8 },
465 { 1, S390_TDB_CONFLICT_TOKEN_REGNUM, 8 },
466 { 1, S390_TDB_ATIA_REGNUM, 8 },
467 { 12, REGCACHE_MAP_SKIP, 8 },
468 { 16, S390_TDB_R0_REGNUM, 8 },
473 /* Supply the TDB regset. Like regcache_supply_regset, but invalidate
474 the TDB registers unless the TDB format field is valid. */
477 s390_supply_tdb_regset (const struct regset *regset, struct regcache *regcache,
478 int regnum, const void *regs, size_t len)
481 enum register_status ret;
484 regcache_supply_regset (regset, regcache, regnum, regs, len);
485 ret = regcache_cooked_read_unsigned (regcache, S390_TDB_DWORD0_REGNUM, &tdw);
486 if (ret != REG_VALID || (tdw >> 56) != 1)
487 regcache_supply_regset (regset, regcache, regnum, NULL, len);
490 const struct regset s390_gregset = {
492 regcache_supply_regset,
493 regcache_collect_regset
496 const struct regset s390_fpregset = {
498 regcache_supply_regset,
499 regcache_collect_regset
502 static const struct regset s390_upper_regset = {
504 regcache_supply_regset,
505 regcache_collect_regset
508 const struct regset s390_last_break_regset = {
509 s390_regmap_last_break,
510 regcache_supply_regset,
511 regcache_collect_regset
514 const struct regset s390x_last_break_regset = {
515 s390x_regmap_last_break,
516 regcache_supply_regset,
517 regcache_collect_regset
520 const struct regset s390_system_call_regset = {
521 s390_regmap_system_call,
522 regcache_supply_regset,
523 regcache_collect_regset
526 const struct regset s390_tdb_regset = {
528 s390_supply_tdb_regset,
529 regcache_collect_regset
532 /* Iterate over supported core file register note sections. */
535 s390_iterate_over_regset_sections (struct gdbarch *gdbarch,
536 iterate_over_regset_sections_cb *cb,
538 const struct regcache *regcache)
540 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
541 const int gregset_size = (tdep->abi == ABI_LINUX_S390 ?
542 s390_sizeof_gregset : s390x_sizeof_gregset);
544 cb (".reg", gregset_size, &s390_gregset, NULL, cb_data);
545 cb (".reg2", s390_sizeof_fpregset, &s390_fpregset, NULL, cb_data);
547 if (tdep->abi == ABI_LINUX_S390 && tdep->gpr_full_regnum != -1)
548 cb (".reg-s390-high-gprs", 16 * 4, &s390_upper_regset,
549 "s390 GPR upper halves", cb_data);
551 if (tdep->have_linux_v1)
552 cb (".reg-s390-last-break", 8,
553 (gdbarch_ptr_bit (gdbarch) == 32
554 ? &s390_last_break_regset : &s390x_last_break_regset),
555 "s930 last-break address", cb_data);
557 if (tdep->have_linux_v2)
558 cb (".reg-s390-system-call", 4, &s390_system_call_regset,
559 "s390 system-call", cb_data);
561 /* If regcache is set, we are in "write" (gcore) mode. In this
562 case, don't iterate over the TDB unless its registers are
566 || REG_VALID == regcache_register_status (regcache,
567 S390_TDB_DWORD0_REGNUM)))
568 cb (".reg-s390-tdb", s390_sizeof_tdbregset, &s390_tdb_regset,
569 "s390 TDB", cb_data);
572 static const struct target_desc *
573 s390_core_read_description (struct gdbarch *gdbarch,
574 struct target_ops *target, bfd *abfd)
576 asection *high_gprs = bfd_get_section_by_name (abfd, ".reg-s390-high-gprs");
577 asection *v1 = bfd_get_section_by_name (abfd, ".reg-s390-last-break");
578 asection *v2 = bfd_get_section_by_name (abfd, ".reg-s390-system-call");
579 asection *section = bfd_get_section_by_name (abfd, ".reg");
582 target_auxv_search (target, AT_HWCAP, &hwcap);
586 switch (bfd_section_size (abfd, section))
588 case s390_sizeof_gregset:
590 return ((hwcap & HWCAP_S390_TE) ? tdesc_s390_te_linux64 :
591 v2? tdesc_s390_linux64v2 :
592 v1? tdesc_s390_linux64v1 : tdesc_s390_linux64);
594 return (v2? tdesc_s390_linux32v2 :
595 v1? tdesc_s390_linux32v1 : tdesc_s390_linux32);
597 case s390x_sizeof_gregset:
598 return ((hwcap & HWCAP_S390_TE) ? tdesc_s390x_te_linux64 :
599 v2? tdesc_s390x_linux64v2 :
600 v1? tdesc_s390x_linux64v1 : tdesc_s390x_linux64);
608 /* Decoding S/390 instructions. */
610 /* Named opcode values for the S/390 instructions we recognize. Some
611 instructions have their opcode split across two fields; those are the
612 op1_* and op2_* enums. */
615 op1_lhi = 0xa7, op2_lhi = 0x08,
616 op1_lghi = 0xa7, op2_lghi = 0x09,
617 op1_lgfi = 0xc0, op2_lgfi = 0x01,
621 op1_ly = 0xe3, op2_ly = 0x58,
622 op1_lg = 0xe3, op2_lg = 0x04,
624 op1_lmy = 0xeb, op2_lmy = 0x98,
625 op1_lmg = 0xeb, op2_lmg = 0x04,
627 op1_sty = 0xe3, op2_sty = 0x50,
628 op1_stg = 0xe3, op2_stg = 0x24,
631 op1_stmy = 0xeb, op2_stmy = 0x90,
632 op1_stmg = 0xeb, op2_stmg = 0x24,
633 op1_aghi = 0xa7, op2_aghi = 0x0b,
634 op1_ahi = 0xa7, op2_ahi = 0x0a,
635 op1_agfi = 0xc2, op2_agfi = 0x08,
636 op1_afi = 0xc2, op2_afi = 0x09,
637 op1_algfi= 0xc2, op2_algfi= 0x0a,
638 op1_alfi = 0xc2, op2_alfi = 0x0b,
642 op1_ay = 0xe3, op2_ay = 0x5a,
643 op1_ag = 0xe3, op2_ag = 0x08,
644 op1_slgfi= 0xc2, op2_slgfi= 0x04,
645 op1_slfi = 0xc2, op2_slfi = 0x05,
649 op1_sy = 0xe3, op2_sy = 0x5b,
650 op1_sg = 0xe3, op2_sg = 0x09,
654 op1_lay = 0xe3, op2_lay = 0x71,
655 op1_larl = 0xc0, op2_larl = 0x00,
663 op1_bctg = 0xe3, op2_bctg = 0x46,
665 op1_bxhg = 0xeb, op2_bxhg = 0x44,
667 op1_bxleg= 0xeb, op2_bxleg= 0x45,
668 op1_bras = 0xa7, op2_bras = 0x05,
669 op1_brasl= 0xc0, op2_brasl= 0x05,
670 op1_brc = 0xa7, op2_brc = 0x04,
671 op1_brcl = 0xc0, op2_brcl = 0x04,
672 op1_brct = 0xa7, op2_brct = 0x06,
673 op1_brctg= 0xa7, op2_brctg= 0x07,
675 op1_brxhg= 0xec, op2_brxhg= 0x44,
677 op1_brxlg= 0xec, op2_brxlg= 0x45,
682 /* Read a single instruction from address AT. */
684 #define S390_MAX_INSTR_SIZE 6
686 s390_readinstruction (bfd_byte instr[], CORE_ADDR at)
688 static int s390_instrlen[] = { 2, 4, 4, 6 };
691 if (target_read_memory (at, &instr[0], 2))
693 instrlen = s390_instrlen[instr[0] >> 6];
696 if (target_read_memory (at + 2, &instr[2], instrlen - 2))
703 /* The functions below are for recognizing and decoding S/390
704 instructions of various formats. Each of them checks whether INSN
705 is an instruction of the given format, with the specified opcodes.
706 If it is, it sets the remaining arguments to the values of the
707 instruction's fields, and returns a non-zero value; otherwise, it
710 These functions' arguments appear in the order they appear in the
711 instruction, not in the machine-language form. So, opcodes always
712 come first, even though they're sometimes scattered around the
713 instructions. And displacements appear before base and extension
714 registers, as they do in the assembly syntax, not at the end, as
715 they do in the machine language. */
717 is_ri (bfd_byte *insn, int op1, int op2, unsigned int *r1, int *i2)
719 if (insn[0] == op1 && (insn[1] & 0xf) == op2)
721 *r1 = (insn[1] >> 4) & 0xf;
722 /* i2 is a 16-bit signed quantity. */
723 *i2 = (((insn[2] << 8) | insn[3]) ^ 0x8000) - 0x8000;
732 is_ril (bfd_byte *insn, int op1, int op2,
733 unsigned int *r1, int *i2)
735 if (insn[0] == op1 && (insn[1] & 0xf) == op2)
737 *r1 = (insn[1] >> 4) & 0xf;
738 /* i2 is a signed quantity. If the host 'int' is 32 bits long,
739 no sign extension is necessary, but we don't want to assume
741 *i2 = (((insn[2] << 24)
744 | (insn[5])) ^ 0x80000000) - 0x80000000;
753 is_rr (bfd_byte *insn, int op, unsigned int *r1, unsigned int *r2)
757 *r1 = (insn[1] >> 4) & 0xf;
767 is_rre (bfd_byte *insn, int op, unsigned int *r1, unsigned int *r2)
769 if (((insn[0] << 8) | insn[1]) == op)
771 /* Yes, insn[3]. insn[2] is unused in RRE format. */
772 *r1 = (insn[3] >> 4) & 0xf;
782 is_rs (bfd_byte *insn, int op,
783 unsigned int *r1, unsigned int *r3, int *d2, unsigned int *b2)
787 *r1 = (insn[1] >> 4) & 0xf;
789 *b2 = (insn[2] >> 4) & 0xf;
790 *d2 = ((insn[2] & 0xf) << 8) | insn[3];
799 is_rsy (bfd_byte *insn, int op1, int op2,
800 unsigned int *r1, unsigned int *r3, int *d2, unsigned int *b2)
805 *r1 = (insn[1] >> 4) & 0xf;
807 *b2 = (insn[2] >> 4) & 0xf;
808 /* The 'long displacement' is a 20-bit signed integer. */
809 *d2 = ((((insn[2] & 0xf) << 8) | insn[3] | (insn[4] << 12))
810 ^ 0x80000) - 0x80000;
819 is_rsi (bfd_byte *insn, int op,
820 unsigned int *r1, unsigned int *r3, int *i2)
824 *r1 = (insn[1] >> 4) & 0xf;
826 /* i2 is a 16-bit signed quantity. */
827 *i2 = (((insn[2] << 8) | insn[3]) ^ 0x8000) - 0x8000;
836 is_rie (bfd_byte *insn, int op1, int op2,
837 unsigned int *r1, unsigned int *r3, int *i2)
842 *r1 = (insn[1] >> 4) & 0xf;
844 /* i2 is a 16-bit signed quantity. */
845 *i2 = (((insn[2] << 8) | insn[3]) ^ 0x8000) - 0x8000;
854 is_rx (bfd_byte *insn, int op,
855 unsigned int *r1, int *d2, unsigned int *x2, unsigned int *b2)
859 *r1 = (insn[1] >> 4) & 0xf;
861 *b2 = (insn[2] >> 4) & 0xf;
862 *d2 = ((insn[2] & 0xf) << 8) | insn[3];
871 is_rxy (bfd_byte *insn, int op1, int op2,
872 unsigned int *r1, int *d2, unsigned int *x2, unsigned int *b2)
877 *r1 = (insn[1] >> 4) & 0xf;
879 *b2 = (insn[2] >> 4) & 0xf;
880 /* The 'long displacement' is a 20-bit signed integer. */
881 *d2 = ((((insn[2] & 0xf) << 8) | insn[3] | (insn[4] << 12))
882 ^ 0x80000) - 0x80000;
890 /* Prologue analysis. */
892 #define S390_NUM_GPRS 16
893 #define S390_NUM_FPRS 16
895 struct s390_prologue_data {
898 struct pv_area *stack;
900 /* The size and byte-order of a GPR or FPR. */
903 enum bfd_endian byte_order;
905 /* The general-purpose registers. */
906 pv_t gpr[S390_NUM_GPRS];
908 /* The floating-point registers. */
909 pv_t fpr[S390_NUM_FPRS];
911 /* The offset relative to the CFA where the incoming GPR N was saved
912 by the function prologue. 0 if not saved or unknown. */
913 int gpr_slot[S390_NUM_GPRS];
915 /* Likewise for FPRs. */
916 int fpr_slot[S390_NUM_FPRS];
918 /* Nonzero if the backchain was saved. This is assumed to be the
919 case when the incoming SP is saved at the current SP location. */
920 int back_chain_saved_p;
923 /* Return the effective address for an X-style instruction, like:
927 Here, X2 and B2 are registers, and D2 is a signed 20-bit
928 constant; the effective address is the sum of all three. If either
929 X2 or B2 are zero, then it doesn't contribute to the sum --- this
930 means that r0 can't be used as either X2 or B2. */
932 s390_addr (struct s390_prologue_data *data,
933 int d2, unsigned int x2, unsigned int b2)
937 result = pv_constant (d2);
939 result = pv_add (result, data->gpr[x2]);
941 result = pv_add (result, data->gpr[b2]);
946 /* Do a SIZE-byte store of VALUE to D2(X2,B2). */
948 s390_store (struct s390_prologue_data *data,
949 int d2, unsigned int x2, unsigned int b2, CORE_ADDR size,
952 pv_t addr = s390_addr (data, d2, x2, b2);
955 /* Check whether we are storing the backchain. */
956 offset = pv_subtract (data->gpr[S390_SP_REGNUM - S390_R0_REGNUM], addr);
958 if (pv_is_constant (offset) && offset.k == 0)
959 if (size == data->gpr_size
960 && pv_is_register_k (value, S390_SP_REGNUM, 0))
962 data->back_chain_saved_p = 1;
967 /* Check whether we are storing a register into the stack. */
968 if (!pv_area_store_would_trash (data->stack, addr))
969 pv_area_store (data->stack, addr, size, value);
972 /* Note: If this is some store we cannot identify, you might think we
973 should forget our cached values, as any of those might have been hit.
975 However, we make the assumption that the register save areas are only
976 ever stored to once in any given function, and we do recognize these
977 stores. Thus every store we cannot recognize does not hit our data. */
980 /* Do a SIZE-byte load from D2(X2,B2). */
982 s390_load (struct s390_prologue_data *data,
983 int d2, unsigned int x2, unsigned int b2, CORE_ADDR size)
986 pv_t addr = s390_addr (data, d2, x2, b2);
988 /* If it's a load from an in-line constant pool, then we can
989 simulate that, under the assumption that the code isn't
990 going to change between the time the processor actually
991 executed it creating the current frame, and the time when
992 we're analyzing the code to unwind past that frame. */
993 if (pv_is_constant (addr))
995 struct target_section *secp;
996 secp = target_section_by_addr (¤t_target, addr.k);
998 && (bfd_get_section_flags (secp->the_bfd_section->owner,
999 secp->the_bfd_section)
1001 return pv_constant (read_memory_integer (addr.k, size,
1005 /* Check whether we are accessing one of our save slots. */
1006 return pv_area_fetch (data->stack, addr, size);
1009 /* Function for finding saved registers in a 'struct pv_area'; we pass
1010 this to pv_area_scan.
1012 If VALUE is a saved register, ADDR says it was saved at a constant
1013 offset from the frame base, and SIZE indicates that the whole
1014 register was saved, record its offset in the reg_offset table in
1015 PROLOGUE_UNTYPED. */
1017 s390_check_for_saved (void *data_untyped, pv_t addr,
1018 CORE_ADDR size, pv_t value)
1020 struct s390_prologue_data *data = data_untyped;
1023 if (!pv_is_register (addr, S390_SP_REGNUM))
1026 offset = 16 * data->gpr_size + 32 - addr.k;
1028 /* If we are storing the original value of a register, we want to
1029 record the CFA offset. If the same register is stored multiple
1030 times, the stack slot with the highest address counts. */
1032 for (i = 0; i < S390_NUM_GPRS; i++)
1033 if (size == data->gpr_size
1034 && pv_is_register_k (value, S390_R0_REGNUM + i, 0))
1035 if (data->gpr_slot[i] == 0
1036 || data->gpr_slot[i] > offset)
1038 data->gpr_slot[i] = offset;
1042 for (i = 0; i < S390_NUM_FPRS; i++)
1043 if (size == data->fpr_size
1044 && pv_is_register_k (value, S390_F0_REGNUM + i, 0))
1045 if (data->fpr_slot[i] == 0
1046 || data->fpr_slot[i] > offset)
1048 data->fpr_slot[i] = offset;
1053 /* Analyze the prologue of the function starting at START_PC,
1054 continuing at most until CURRENT_PC. Initialize DATA to
1055 hold all information we find out about the state of the registers
1056 and stack slots. Return the address of the instruction after
1057 the last one that changed the SP, FP, or back chain; or zero
1060 s390_analyze_prologue (struct gdbarch *gdbarch,
1062 CORE_ADDR current_pc,
1063 struct s390_prologue_data *data)
1065 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1067 /* Our return value:
1068 The address of the instruction after the last one that changed
1069 the SP, FP, or back chain; zero if we got an error trying to
1071 CORE_ADDR result = start_pc;
1073 /* The current PC for our abstract interpretation. */
1076 /* The address of the next instruction after that. */
1079 /* Set up everything's initial value. */
1083 data->stack = make_pv_area (S390_SP_REGNUM, gdbarch_addr_bit (gdbarch));
1085 /* For the purpose of prologue tracking, we consider the GPR size to
1086 be equal to the ABI word size, even if it is actually larger
1087 (i.e. when running a 32-bit binary under a 64-bit kernel). */
1088 data->gpr_size = word_size;
1090 data->byte_order = gdbarch_byte_order (gdbarch);
1092 for (i = 0; i < S390_NUM_GPRS; i++)
1093 data->gpr[i] = pv_register (S390_R0_REGNUM + i, 0);
1095 for (i = 0; i < S390_NUM_FPRS; i++)
1096 data->fpr[i] = pv_register (S390_F0_REGNUM + i, 0);
1098 for (i = 0; i < S390_NUM_GPRS; i++)
1099 data->gpr_slot[i] = 0;
1101 for (i = 0; i < S390_NUM_FPRS; i++)
1102 data->fpr_slot[i] = 0;
1104 data->back_chain_saved_p = 0;
1107 /* Start interpreting instructions, until we hit the frame's
1108 current PC or the first branch instruction. */
1109 for (pc = start_pc; pc > 0 && pc < current_pc; pc = next_pc)
1111 bfd_byte insn[S390_MAX_INSTR_SIZE];
1112 int insn_len = s390_readinstruction (insn, pc);
1114 bfd_byte dummy[S390_MAX_INSTR_SIZE] = { 0 };
1115 bfd_byte *insn32 = word_size == 4 ? insn : dummy;
1116 bfd_byte *insn64 = word_size == 8 ? insn : dummy;
1118 /* Fields for various kinds of instructions. */
1119 unsigned int b2, r1, r2, x2, r3;
1122 /* The values of SP and FP before this instruction,
1123 for detecting instructions that change them. */
1124 pv_t pre_insn_sp, pre_insn_fp;
1125 /* Likewise for the flag whether the back chain was saved. */
1126 int pre_insn_back_chain_saved_p;
1128 /* If we got an error trying to read the instruction, report it. */
1135 next_pc = pc + insn_len;
1137 pre_insn_sp = data->gpr[S390_SP_REGNUM - S390_R0_REGNUM];
1138 pre_insn_fp = data->gpr[S390_FRAME_REGNUM - S390_R0_REGNUM];
1139 pre_insn_back_chain_saved_p = data->back_chain_saved_p;
1142 /* LHI r1, i2 --- load halfword immediate. */
1143 /* LGHI r1, i2 --- load halfword immediate (64-bit version). */
1144 /* LGFI r1, i2 --- load fullword immediate. */
1145 if (is_ri (insn32, op1_lhi, op2_lhi, &r1, &i2)
1146 || is_ri (insn64, op1_lghi, op2_lghi, &r1, &i2)
1147 || is_ril (insn, op1_lgfi, op2_lgfi, &r1, &i2))
1148 data->gpr[r1] = pv_constant (i2);
1150 /* LR r1, r2 --- load from register. */
1151 /* LGR r1, r2 --- load from register (64-bit version). */
1152 else if (is_rr (insn32, op_lr, &r1, &r2)
1153 || is_rre (insn64, op_lgr, &r1, &r2))
1154 data->gpr[r1] = data->gpr[r2];
1156 /* L r1, d2(x2, b2) --- load. */
1157 /* LY r1, d2(x2, b2) --- load (long-displacement version). */
1158 /* LG r1, d2(x2, b2) --- load (64-bit version). */
1159 else if (is_rx (insn32, op_l, &r1, &d2, &x2, &b2)
1160 || is_rxy (insn32, op1_ly, op2_ly, &r1, &d2, &x2, &b2)
1161 || is_rxy (insn64, op1_lg, op2_lg, &r1, &d2, &x2, &b2))
1162 data->gpr[r1] = s390_load (data, d2, x2, b2, data->gpr_size);
1164 /* ST r1, d2(x2, b2) --- store. */
1165 /* STY r1, d2(x2, b2) --- store (long-displacement version). */
1166 /* STG r1, d2(x2, b2) --- store (64-bit version). */
1167 else if (is_rx (insn32, op_st, &r1, &d2, &x2, &b2)
1168 || is_rxy (insn32, op1_sty, op2_sty, &r1, &d2, &x2, &b2)
1169 || is_rxy (insn64, op1_stg, op2_stg, &r1, &d2, &x2, &b2))
1170 s390_store (data, d2, x2, b2, data->gpr_size, data->gpr[r1]);
1172 /* STD r1, d2(x2,b2) --- store floating-point register. */
1173 else if (is_rx (insn, op_std, &r1, &d2, &x2, &b2))
1174 s390_store (data, d2, x2, b2, data->fpr_size, data->fpr[r1]);
1176 /* STM r1, r3, d2(b2) --- store multiple. */
1177 /* STMY r1, r3, d2(b2) --- store multiple (long-displacement
1179 /* STMG r1, r3, d2(b2) --- store multiple (64-bit version). */
1180 else if (is_rs (insn32, op_stm, &r1, &r3, &d2, &b2)
1181 || is_rsy (insn32, op1_stmy, op2_stmy, &r1, &r3, &d2, &b2)
1182 || is_rsy (insn64, op1_stmg, op2_stmg, &r1, &r3, &d2, &b2))
1184 for (; r1 <= r3; r1++, d2 += data->gpr_size)
1185 s390_store (data, d2, 0, b2, data->gpr_size, data->gpr[r1]);
1188 /* AHI r1, i2 --- add halfword immediate. */
1189 /* AGHI r1, i2 --- add halfword immediate (64-bit version). */
1190 /* AFI r1, i2 --- add fullword immediate. */
1191 /* AGFI r1, i2 --- add fullword immediate (64-bit version). */
1192 else if (is_ri (insn32, op1_ahi, op2_ahi, &r1, &i2)
1193 || is_ri (insn64, op1_aghi, op2_aghi, &r1, &i2)
1194 || is_ril (insn32, op1_afi, op2_afi, &r1, &i2)
1195 || is_ril (insn64, op1_agfi, op2_agfi, &r1, &i2))
1196 data->gpr[r1] = pv_add_constant (data->gpr[r1], i2);
1198 /* ALFI r1, i2 --- add logical immediate. */
1199 /* ALGFI r1, i2 --- add logical immediate (64-bit version). */
1200 else if (is_ril (insn32, op1_alfi, op2_alfi, &r1, &i2)
1201 || is_ril (insn64, op1_algfi, op2_algfi, &r1, &i2))
1202 data->gpr[r1] = pv_add_constant (data->gpr[r1],
1203 (CORE_ADDR)i2 & 0xffffffff);
1205 /* AR r1, r2 -- add register. */
1206 /* AGR r1, r2 -- add register (64-bit version). */
1207 else if (is_rr (insn32, op_ar, &r1, &r2)
1208 || is_rre (insn64, op_agr, &r1, &r2))
1209 data->gpr[r1] = pv_add (data->gpr[r1], data->gpr[r2]);
1211 /* A r1, d2(x2, b2) -- add. */
1212 /* AY r1, d2(x2, b2) -- add (long-displacement version). */
1213 /* AG r1, d2(x2, b2) -- add (64-bit version). */
1214 else if (is_rx (insn32, op_a, &r1, &d2, &x2, &b2)
1215 || is_rxy (insn32, op1_ay, op2_ay, &r1, &d2, &x2, &b2)
1216 || is_rxy (insn64, op1_ag, op2_ag, &r1, &d2, &x2, &b2))
1217 data->gpr[r1] = pv_add (data->gpr[r1],
1218 s390_load (data, d2, x2, b2, data->gpr_size));
1220 /* SLFI r1, i2 --- subtract logical immediate. */
1221 /* SLGFI r1, i2 --- subtract logical immediate (64-bit version). */
1222 else if (is_ril (insn32, op1_slfi, op2_slfi, &r1, &i2)
1223 || is_ril (insn64, op1_slgfi, op2_slgfi, &r1, &i2))
1224 data->gpr[r1] = pv_add_constant (data->gpr[r1],
1225 -((CORE_ADDR)i2 & 0xffffffff));
1227 /* SR r1, r2 -- subtract register. */
1228 /* SGR r1, r2 -- subtract register (64-bit version). */
1229 else if (is_rr (insn32, op_sr, &r1, &r2)
1230 || is_rre (insn64, op_sgr, &r1, &r2))
1231 data->gpr[r1] = pv_subtract (data->gpr[r1], data->gpr[r2]);
1233 /* S r1, d2(x2, b2) -- subtract. */
1234 /* SY r1, d2(x2, b2) -- subtract (long-displacement version). */
1235 /* SG r1, d2(x2, b2) -- subtract (64-bit version). */
1236 else if (is_rx (insn32, op_s, &r1, &d2, &x2, &b2)
1237 || is_rxy (insn32, op1_sy, op2_sy, &r1, &d2, &x2, &b2)
1238 || is_rxy (insn64, op1_sg, op2_sg, &r1, &d2, &x2, &b2))
1239 data->gpr[r1] = pv_subtract (data->gpr[r1],
1240 s390_load (data, d2, x2, b2, data->gpr_size));
1242 /* LA r1, d2(x2, b2) --- load address. */
1243 /* LAY r1, d2(x2, b2) --- load address (long-displacement version). */
1244 else if (is_rx (insn, op_la, &r1, &d2, &x2, &b2)
1245 || is_rxy (insn, op1_lay, op2_lay, &r1, &d2, &x2, &b2))
1246 data->gpr[r1] = s390_addr (data, d2, x2, b2);
1248 /* LARL r1, i2 --- load address relative long. */
1249 else if (is_ril (insn, op1_larl, op2_larl, &r1, &i2))
1250 data->gpr[r1] = pv_constant (pc + i2 * 2);
1252 /* BASR r1, 0 --- branch and save.
1253 Since r2 is zero, this saves the PC in r1, but doesn't branch. */
1254 else if (is_rr (insn, op_basr, &r1, &r2)
1256 data->gpr[r1] = pv_constant (next_pc);
1258 /* BRAS r1, i2 --- branch relative and save. */
1259 else if (is_ri (insn, op1_bras, op2_bras, &r1, &i2))
1261 data->gpr[r1] = pv_constant (next_pc);
1262 next_pc = pc + i2 * 2;
1264 /* We'd better not interpret any backward branches. We'll
1270 /* Terminate search when hitting any other branch instruction. */
1271 else if (is_rr (insn, op_basr, &r1, &r2)
1272 || is_rx (insn, op_bas, &r1, &d2, &x2, &b2)
1273 || is_rr (insn, op_bcr, &r1, &r2)
1274 || is_rx (insn, op_bc, &r1, &d2, &x2, &b2)
1275 || is_ri (insn, op1_brc, op2_brc, &r1, &i2)
1276 || is_ril (insn, op1_brcl, op2_brcl, &r1, &i2)
1277 || is_ril (insn, op1_brasl, op2_brasl, &r2, &i2))
1282 /* An instruction we don't know how to simulate. The only
1283 safe thing to do would be to set every value we're tracking
1284 to 'unknown'. Instead, we'll be optimistic: we assume that
1285 we *can* interpret every instruction that the compiler uses
1286 to manipulate any of the data we're interested in here --
1287 then we can just ignore anything else. */
1290 /* Record the address after the last instruction that changed
1291 the FP, SP, or backlink. Ignore instructions that changed
1292 them back to their original values --- those are probably
1293 restore instructions. (The back chain is never restored,
1296 pv_t sp = data->gpr[S390_SP_REGNUM - S390_R0_REGNUM];
1297 pv_t fp = data->gpr[S390_FRAME_REGNUM - S390_R0_REGNUM];
1299 if ((! pv_is_identical (pre_insn_sp, sp)
1300 && ! pv_is_register_k (sp, S390_SP_REGNUM, 0)
1301 && sp.kind != pvk_unknown)
1302 || (! pv_is_identical (pre_insn_fp, fp)
1303 && ! pv_is_register_k (fp, S390_FRAME_REGNUM, 0)
1304 && fp.kind != pvk_unknown)
1305 || pre_insn_back_chain_saved_p != data->back_chain_saved_p)
1310 /* Record where all the registers were saved. */
1311 pv_area_scan (data->stack, s390_check_for_saved, data);
1313 free_pv_area (data->stack);
1319 /* Advance PC across any function entry prologue instructions to reach
1320 some "real" code. */
1322 s390_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
1324 struct s390_prologue_data data;
1326 skip_pc = s390_analyze_prologue (gdbarch, pc, (CORE_ADDR)-1, &data);
1327 return skip_pc ? skip_pc : pc;
1330 /* Return true if we are in the functin's epilogue, i.e. after the
1331 instruction that destroyed the function's stack frame. */
1333 s390_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
1335 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1337 /* In frameless functions, there's not frame to destroy and thus
1338 we don't care about the epilogue.
1340 In functions with frame, the epilogue sequence is a pair of
1341 a LM-type instruction that restores (amongst others) the
1342 return register %r14 and the stack pointer %r15, followed
1343 by a branch 'br %r14' --or equivalent-- that effects the
1346 In that situation, this function needs to return 'true' in
1347 exactly one case: when pc points to that branch instruction.
1349 Thus we try to disassemble the one instructions immediately
1350 preceding pc and check whether it is an LM-type instruction
1351 modifying the stack pointer.
1353 Note that disassembling backwards is not reliable, so there
1354 is a slight chance of false positives here ... */
1357 unsigned int r1, r3, b2;
1361 && !target_read_memory (pc - 4, insn, 4)
1362 && is_rs (insn, op_lm, &r1, &r3, &d2, &b2)
1363 && r3 == S390_SP_REGNUM - S390_R0_REGNUM)
1367 && !target_read_memory (pc - 6, insn, 6)
1368 && is_rsy (insn, op1_lmy, op2_lmy, &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_lmg, op2_lmg, &r1, &r3, &d2, &b2)
1375 && r3 == S390_SP_REGNUM - S390_R0_REGNUM)
1381 /* Displaced stepping. */
1383 /* Fix up the state of registers and memory after having single-stepped
1384 a displaced instruction. */
1386 s390_displaced_step_fixup (struct gdbarch *gdbarch,
1387 struct displaced_step_closure *closure,
1388 CORE_ADDR from, CORE_ADDR to,
1389 struct regcache *regs)
1391 /* Since we use simple_displaced_step_copy_insn, our closure is a
1392 copy of the instruction. */
1393 gdb_byte *insn = (gdb_byte *) closure;
1394 static int s390_instrlen[] = { 2, 4, 4, 6 };
1395 int insnlen = s390_instrlen[insn[0] >> 6];
1397 /* Fields for various kinds of instructions. */
1398 unsigned int b2, r1, r2, x2, r3;
1401 /* Get current PC and addressing mode bit. */
1402 CORE_ADDR pc = regcache_read_pc (regs);
1405 if (register_size (gdbarch, S390_PSWA_REGNUM) == 4)
1407 regcache_cooked_read_unsigned (regs, S390_PSWA_REGNUM, &amode);
1408 amode &= 0x80000000;
1411 if (debug_displaced)
1412 fprintf_unfiltered (gdb_stdlog,
1413 "displaced: (s390) fixup (%s, %s) pc %s len %d amode 0x%x\n",
1414 paddress (gdbarch, from), paddress (gdbarch, to),
1415 paddress (gdbarch, pc), insnlen, (int) amode);
1417 /* Handle absolute branch and save instructions. */
1418 if (is_rr (insn, op_basr, &r1, &r2)
1419 || is_rx (insn, op_bas, &r1, &d2, &x2, &b2))
1421 /* Recompute saved return address in R1. */
1422 regcache_cooked_write_unsigned (regs, S390_R0_REGNUM + r1,
1423 amode | (from + insnlen));
1426 /* Handle absolute branch instructions. */
1427 else if (is_rr (insn, op_bcr, &r1, &r2)
1428 || is_rx (insn, op_bc, &r1, &d2, &x2, &b2)
1429 || is_rr (insn, op_bctr, &r1, &r2)
1430 || is_rre (insn, op_bctgr, &r1, &r2)
1431 || is_rx (insn, op_bct, &r1, &d2, &x2, &b2)
1432 || is_rxy (insn, op1_bctg, op2_brctg, &r1, &d2, &x2, &b2)
1433 || is_rs (insn, op_bxh, &r1, &r3, &d2, &b2)
1434 || is_rsy (insn, op1_bxhg, op2_bxhg, &r1, &r3, &d2, &b2)
1435 || is_rs (insn, op_bxle, &r1, &r3, &d2, &b2)
1436 || is_rsy (insn, op1_bxleg, op2_bxleg, &r1, &r3, &d2, &b2))
1438 /* Update PC iff branch was *not* taken. */
1439 if (pc == to + insnlen)
1440 regcache_write_pc (regs, from + insnlen);
1443 /* Handle PC-relative branch and save instructions. */
1444 else if (is_ri (insn, op1_bras, op2_bras, &r1, &i2)
1445 || is_ril (insn, op1_brasl, op2_brasl, &r1, &i2))
1448 regcache_write_pc (regs, pc - to + from);
1449 /* Recompute saved return address in R1. */
1450 regcache_cooked_write_unsigned (regs, S390_R0_REGNUM + r1,
1451 amode | (from + insnlen));
1454 /* Handle PC-relative branch instructions. */
1455 else if (is_ri (insn, op1_brc, op2_brc, &r1, &i2)
1456 || is_ril (insn, op1_brcl, op2_brcl, &r1, &i2)
1457 || is_ri (insn, op1_brct, op2_brct, &r1, &i2)
1458 || is_ri (insn, op1_brctg, op2_brctg, &r1, &i2)
1459 || is_rsi (insn, op_brxh, &r1, &r3, &i2)
1460 || is_rie (insn, op1_brxhg, op2_brxhg, &r1, &r3, &i2)
1461 || is_rsi (insn, op_brxle, &r1, &r3, &i2)
1462 || is_rie (insn, op1_brxlg, op2_brxlg, &r1, &r3, &i2))
1465 regcache_write_pc (regs, pc - to + from);
1468 /* Handle LOAD ADDRESS RELATIVE LONG. */
1469 else if (is_ril (insn, op1_larl, op2_larl, &r1, &i2))
1472 regcache_write_pc (regs, from + insnlen);
1473 /* Recompute output address in R1. */
1474 regcache_cooked_write_unsigned (regs, S390_R0_REGNUM + r1,
1475 amode | (from + i2 * 2));
1478 /* If we executed a breakpoint instruction, point PC right back at it. */
1479 else if (insn[0] == 0x0 && insn[1] == 0x1)
1480 regcache_write_pc (regs, from);
1482 /* For any other insn, PC points right after the original instruction. */
1484 regcache_write_pc (regs, from + insnlen);
1486 if (debug_displaced)
1487 fprintf_unfiltered (gdb_stdlog,
1488 "displaced: (s390) pc is now %s\n",
1489 paddress (gdbarch, regcache_read_pc (regs)));
1493 /* Helper routine to unwind pseudo registers. */
1495 static struct value *
1496 s390_unwind_pseudo_register (struct frame_info *this_frame, int regnum)
1498 struct gdbarch *gdbarch = get_frame_arch (this_frame);
1499 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1500 struct type *type = register_type (gdbarch, regnum);
1502 /* Unwind PC via PSW address. */
1503 if (regnum == tdep->pc_regnum)
1507 val = frame_unwind_register_value (this_frame, S390_PSWA_REGNUM);
1508 if (!value_optimized_out (val))
1510 LONGEST pswa = value_as_long (val);
1512 if (TYPE_LENGTH (type) == 4)
1513 return value_from_pointer (type, pswa & 0x7fffffff);
1515 return value_from_pointer (type, pswa);
1519 /* Unwind CC via PSW mask. */
1520 if (regnum == tdep->cc_regnum)
1524 val = frame_unwind_register_value (this_frame, S390_PSWM_REGNUM);
1525 if (!value_optimized_out (val))
1527 LONGEST pswm = value_as_long (val);
1529 if (TYPE_LENGTH (type) == 4)
1530 return value_from_longest (type, (pswm >> 12) & 3);
1532 return value_from_longest (type, (pswm >> 44) & 3);
1536 /* Unwind full GPRs to show at least the lower halves (as the
1537 upper halves are undefined). */
1538 if (regnum_is_gpr_full (tdep, regnum))
1540 int reg = regnum - tdep->gpr_full_regnum;
1543 val = frame_unwind_register_value (this_frame, S390_R0_REGNUM + reg);
1544 if (!value_optimized_out (val))
1545 return value_cast (type, val);
1548 return allocate_optimized_out_value (type);
1551 static struct value *
1552 s390_trad_frame_prev_register (struct frame_info *this_frame,
1553 struct trad_frame_saved_reg saved_regs[],
1556 if (regnum < S390_NUM_REGS)
1557 return trad_frame_get_prev_register (this_frame, saved_regs, regnum);
1559 return s390_unwind_pseudo_register (this_frame, regnum);
1563 /* Normal stack frames. */
1565 struct s390_unwind_cache {
1568 CORE_ADDR frame_base;
1569 CORE_ADDR local_base;
1571 struct trad_frame_saved_reg *saved_regs;
1575 s390_prologue_frame_unwind_cache (struct frame_info *this_frame,
1576 struct s390_unwind_cache *info)
1578 struct gdbarch *gdbarch = get_frame_arch (this_frame);
1579 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1580 struct s390_prologue_data data;
1581 pv_t *fp = &data.gpr[S390_FRAME_REGNUM - S390_R0_REGNUM];
1582 pv_t *sp = &data.gpr[S390_SP_REGNUM - S390_R0_REGNUM];
1591 struct frame_info *next_frame;
1593 /* Try to find the function start address. If we can't find it, we don't
1594 bother searching for it -- with modern compilers this would be mostly
1595 pointless anyway. Trust that we'll either have valid DWARF-2 CFI data
1596 or else a valid backchain ... */
1597 func = get_frame_func (this_frame);
1601 /* Try to analyze the prologue. */
1602 result = s390_analyze_prologue (gdbarch, func,
1603 get_frame_pc (this_frame), &data);
1607 /* If this was successful, we should have found the instruction that
1608 sets the stack pointer register to the previous value of the stack
1609 pointer minus the frame size. */
1610 if (!pv_is_register (*sp, S390_SP_REGNUM))
1613 /* A frame size of zero at this point can mean either a real
1614 frameless function, or else a failure to find the prologue.
1615 Perform some sanity checks to verify we really have a
1616 frameless function. */
1619 /* If the next frame is a NORMAL_FRAME, this frame *cannot* have frame
1620 size zero. This is only possible if the next frame is a sentinel
1621 frame, a dummy frame, or a signal trampoline frame. */
1622 /* FIXME: cagney/2004-05-01: This sanity check shouldn't be
1623 needed, instead the code should simpliy rely on its
1625 next_frame = get_next_frame (this_frame);
1626 while (next_frame && get_frame_type (next_frame) == INLINE_FRAME)
1627 next_frame = get_next_frame (next_frame);
1629 && get_frame_type (get_next_frame (this_frame)) == NORMAL_FRAME)
1632 /* If we really have a frameless function, %r14 must be valid
1633 -- in particular, it must point to a different function. */
1634 reg = get_frame_register_unsigned (this_frame, S390_RETADDR_REGNUM);
1635 reg = gdbarch_addr_bits_remove (gdbarch, reg) - 1;
1636 if (get_pc_function_start (reg) == func)
1638 /* However, there is one case where it *is* valid for %r14
1639 to point to the same function -- if this is a recursive
1640 call, and we have stopped in the prologue *before* the
1641 stack frame was allocated.
1643 Recognize this case by looking ahead a bit ... */
1645 struct s390_prologue_data data2;
1646 pv_t *sp = &data2.gpr[S390_SP_REGNUM - S390_R0_REGNUM];
1648 if (!(s390_analyze_prologue (gdbarch, func, (CORE_ADDR)-1, &data2)
1649 && pv_is_register (*sp, S390_SP_REGNUM)
1656 /* OK, we've found valid prologue data. */
1659 /* If the frame pointer originally also holds the same value
1660 as the stack pointer, we're probably using it. If it holds
1661 some other value -- even a constant offset -- it is most
1662 likely used as temp register. */
1663 if (pv_is_identical (*sp, *fp))
1664 frame_pointer = S390_FRAME_REGNUM;
1666 frame_pointer = S390_SP_REGNUM;
1668 /* If we've detected a function with stack frame, we'll still have to
1669 treat it as frameless if we're currently within the function epilog
1670 code at a point where the frame pointer has already been restored.
1671 This can only happen in an innermost frame. */
1672 /* FIXME: cagney/2004-05-01: This sanity check shouldn't be needed,
1673 instead the code should simpliy rely on its analysis. */
1674 next_frame = get_next_frame (this_frame);
1675 while (next_frame && get_frame_type (next_frame) == INLINE_FRAME)
1676 next_frame = get_next_frame (next_frame);
1678 && (next_frame == NULL
1679 || get_frame_type (get_next_frame (this_frame)) != NORMAL_FRAME))
1681 /* See the comment in s390_in_function_epilogue_p on why this is
1682 not completely reliable ... */
1683 if (s390_in_function_epilogue_p (gdbarch, get_frame_pc (this_frame)))
1685 memset (&data, 0, sizeof (data));
1687 frame_pointer = S390_SP_REGNUM;
1691 /* Once we know the frame register and the frame size, we can unwind
1692 the current value of the frame register from the next frame, and
1693 add back the frame size to arrive that the previous frame's
1694 stack pointer value. */
1695 prev_sp = get_frame_register_unsigned (this_frame, frame_pointer) + size;
1696 cfa = prev_sp + 16*word_size + 32;
1698 /* Set up ABI call-saved/call-clobbered registers. */
1699 for (i = 0; i < S390_NUM_REGS; i++)
1700 if (!s390_register_call_saved (gdbarch, i))
1701 trad_frame_set_unknown (info->saved_regs, i);
1703 /* CC is always call-clobbered. */
1704 trad_frame_set_unknown (info->saved_regs, S390_PSWM_REGNUM);
1706 /* Record the addresses of all register spill slots the prologue parser
1707 has recognized. Consider only registers defined as call-saved by the
1708 ABI; for call-clobbered registers the parser may have recognized
1711 for (i = 0; i < 16; i++)
1712 if (s390_register_call_saved (gdbarch, S390_R0_REGNUM + i)
1713 && data.gpr_slot[i] != 0)
1714 info->saved_regs[S390_R0_REGNUM + i].addr = cfa - data.gpr_slot[i];
1716 for (i = 0; i < 16; i++)
1717 if (s390_register_call_saved (gdbarch, S390_F0_REGNUM + i)
1718 && data.fpr_slot[i] != 0)
1719 info->saved_regs[S390_F0_REGNUM + i].addr = cfa - data.fpr_slot[i];
1721 /* Function return will set PC to %r14. */
1722 info->saved_regs[S390_PSWA_REGNUM] = info->saved_regs[S390_RETADDR_REGNUM];
1724 /* In frameless functions, we unwind simply by moving the return
1725 address to the PC. However, if we actually stored to the
1726 save area, use that -- we might only think the function frameless
1727 because we're in the middle of the prologue ... */
1729 && !trad_frame_addr_p (info->saved_regs, S390_PSWA_REGNUM))
1731 info->saved_regs[S390_PSWA_REGNUM].realreg = S390_RETADDR_REGNUM;
1734 /* Another sanity check: unless this is a frameless function,
1735 we should have found spill slots for SP and PC.
1736 If not, we cannot unwind further -- this happens e.g. in
1737 libc's thread_start routine. */
1740 if (!trad_frame_addr_p (info->saved_regs, S390_SP_REGNUM)
1741 || !trad_frame_addr_p (info->saved_regs, S390_PSWA_REGNUM))
1745 /* We use the current value of the frame register as local_base,
1746 and the top of the register save area as frame_base. */
1749 info->frame_base = prev_sp + 16*word_size + 32;
1750 info->local_base = prev_sp - size;
1758 s390_backchain_frame_unwind_cache (struct frame_info *this_frame,
1759 struct s390_unwind_cache *info)
1761 struct gdbarch *gdbarch = get_frame_arch (this_frame);
1762 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1763 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1764 CORE_ADDR backchain;
1769 /* Set up ABI call-saved/call-clobbered registers. */
1770 for (i = 0; i < S390_NUM_REGS; i++)
1771 if (!s390_register_call_saved (gdbarch, i))
1772 trad_frame_set_unknown (info->saved_regs, i);
1774 /* CC is always call-clobbered. */
1775 trad_frame_set_unknown (info->saved_regs, S390_PSWM_REGNUM);
1777 /* Get the backchain. */
1778 reg = get_frame_register_unsigned (this_frame, S390_SP_REGNUM);
1779 backchain = read_memory_unsigned_integer (reg, word_size, byte_order);
1781 /* A zero backchain terminates the frame chain. As additional
1782 sanity check, let's verify that the spill slot for SP in the
1783 save area pointed to by the backchain in fact links back to
1786 && safe_read_memory_integer (backchain + 15*word_size,
1787 word_size, byte_order, &sp)
1788 && (CORE_ADDR)sp == backchain)
1790 /* We don't know which registers were saved, but it will have
1791 to be at least %r14 and %r15. This will allow us to continue
1792 unwinding, but other prev-frame registers may be incorrect ... */
1793 info->saved_regs[S390_SP_REGNUM].addr = backchain + 15*word_size;
1794 info->saved_regs[S390_RETADDR_REGNUM].addr = backchain + 14*word_size;
1796 /* Function return will set PC to %r14. */
1797 info->saved_regs[S390_PSWA_REGNUM]
1798 = info->saved_regs[S390_RETADDR_REGNUM];
1800 /* We use the current value of the frame register as local_base,
1801 and the top of the register save area as frame_base. */
1802 info->frame_base = backchain + 16*word_size + 32;
1803 info->local_base = reg;
1806 info->func = get_frame_pc (this_frame);
1809 static struct s390_unwind_cache *
1810 s390_frame_unwind_cache (struct frame_info *this_frame,
1811 void **this_prologue_cache)
1813 volatile struct gdb_exception ex;
1814 struct s390_unwind_cache *info;
1816 if (*this_prologue_cache)
1817 return *this_prologue_cache;
1819 info = FRAME_OBSTACK_ZALLOC (struct s390_unwind_cache);
1820 *this_prologue_cache = info;
1821 info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
1823 info->frame_base = -1;
1824 info->local_base = -1;
1826 TRY_CATCH (ex, RETURN_MASK_ERROR)
1828 /* Try to use prologue analysis to fill the unwind cache.
1829 If this fails, fall back to reading the stack backchain. */
1830 if (!s390_prologue_frame_unwind_cache (this_frame, info))
1831 s390_backchain_frame_unwind_cache (this_frame, info);
1833 if (ex.reason < 0 && ex.error != NOT_AVAILABLE_ERROR)
1834 throw_exception (ex);
1840 s390_frame_this_id (struct frame_info *this_frame,
1841 void **this_prologue_cache,
1842 struct frame_id *this_id)
1844 struct s390_unwind_cache *info
1845 = s390_frame_unwind_cache (this_frame, this_prologue_cache);
1847 if (info->frame_base == -1)
1850 *this_id = frame_id_build (info->frame_base, info->func);
1853 static struct value *
1854 s390_frame_prev_register (struct frame_info *this_frame,
1855 void **this_prologue_cache, int regnum)
1857 struct gdbarch *gdbarch = get_frame_arch (this_frame);
1858 struct s390_unwind_cache *info
1859 = s390_frame_unwind_cache (this_frame, this_prologue_cache);
1861 return s390_trad_frame_prev_register (this_frame, info->saved_regs, regnum);
1864 static const struct frame_unwind s390_frame_unwind = {
1866 default_frame_unwind_stop_reason,
1868 s390_frame_prev_register,
1870 default_frame_sniffer
1874 /* Code stubs and their stack frames. For things like PLTs and NULL
1875 function calls (where there is no true frame and the return address
1876 is in the RETADDR register). */
1878 struct s390_stub_unwind_cache
1880 CORE_ADDR frame_base;
1881 struct trad_frame_saved_reg *saved_regs;
1884 static struct s390_stub_unwind_cache *
1885 s390_stub_frame_unwind_cache (struct frame_info *this_frame,
1886 void **this_prologue_cache)
1888 struct gdbarch *gdbarch = get_frame_arch (this_frame);
1889 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1890 struct s390_stub_unwind_cache *info;
1893 if (*this_prologue_cache)
1894 return *this_prologue_cache;
1896 info = FRAME_OBSTACK_ZALLOC (struct s390_stub_unwind_cache);
1897 *this_prologue_cache = info;
1898 info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
1900 /* The return address is in register %r14. */
1901 info->saved_regs[S390_PSWA_REGNUM].realreg = S390_RETADDR_REGNUM;
1903 /* Retrieve stack pointer and determine our frame base. */
1904 reg = get_frame_register_unsigned (this_frame, S390_SP_REGNUM);
1905 info->frame_base = reg + 16*word_size + 32;
1911 s390_stub_frame_this_id (struct frame_info *this_frame,
1912 void **this_prologue_cache,
1913 struct frame_id *this_id)
1915 struct s390_stub_unwind_cache *info
1916 = s390_stub_frame_unwind_cache (this_frame, this_prologue_cache);
1917 *this_id = frame_id_build (info->frame_base, get_frame_pc (this_frame));
1920 static struct value *
1921 s390_stub_frame_prev_register (struct frame_info *this_frame,
1922 void **this_prologue_cache, int regnum)
1924 struct s390_stub_unwind_cache *info
1925 = s390_stub_frame_unwind_cache (this_frame, this_prologue_cache);
1926 return s390_trad_frame_prev_register (this_frame, info->saved_regs, regnum);
1930 s390_stub_frame_sniffer (const struct frame_unwind *self,
1931 struct frame_info *this_frame,
1932 void **this_prologue_cache)
1934 CORE_ADDR addr_in_block;
1935 bfd_byte insn[S390_MAX_INSTR_SIZE];
1937 /* If the current PC points to non-readable memory, we assume we
1938 have trapped due to an invalid function pointer call. We handle
1939 the non-existing current function like a PLT stub. */
1940 addr_in_block = get_frame_address_in_block (this_frame);
1941 if (in_plt_section (addr_in_block)
1942 || s390_readinstruction (insn, get_frame_pc (this_frame)) < 0)
1947 static const struct frame_unwind s390_stub_frame_unwind = {
1949 default_frame_unwind_stop_reason,
1950 s390_stub_frame_this_id,
1951 s390_stub_frame_prev_register,
1953 s390_stub_frame_sniffer
1957 /* Signal trampoline stack frames. */
1959 struct s390_sigtramp_unwind_cache {
1960 CORE_ADDR frame_base;
1961 struct trad_frame_saved_reg *saved_regs;
1964 static struct s390_sigtramp_unwind_cache *
1965 s390_sigtramp_frame_unwind_cache (struct frame_info *this_frame,
1966 void **this_prologue_cache)
1968 struct gdbarch *gdbarch = get_frame_arch (this_frame);
1969 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1970 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1971 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1972 struct s390_sigtramp_unwind_cache *info;
1973 ULONGEST this_sp, prev_sp;
1974 CORE_ADDR next_ra, next_cfa, sigreg_ptr, sigreg_high_off;
1977 if (*this_prologue_cache)
1978 return *this_prologue_cache;
1980 info = FRAME_OBSTACK_ZALLOC (struct s390_sigtramp_unwind_cache);
1981 *this_prologue_cache = info;
1982 info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
1984 this_sp = get_frame_register_unsigned (this_frame, S390_SP_REGNUM);
1985 next_ra = get_frame_pc (this_frame);
1986 next_cfa = this_sp + 16*word_size + 32;
1988 /* New-style RT frame:
1989 retcode + alignment (8 bytes)
1991 ucontext (contains sigregs at offset 5 words). */
1992 if (next_ra == next_cfa)
1994 sigreg_ptr = next_cfa + 8 + 128 + align_up (5*word_size, 8);
1995 /* sigregs are followed by uc_sigmask (8 bytes), then by the
1996 upper GPR halves if present. */
1997 sigreg_high_off = 8;
2000 /* Old-style RT frame and all non-RT frames:
2001 old signal mask (8 bytes)
2002 pointer to sigregs. */
2005 sigreg_ptr = read_memory_unsigned_integer (next_cfa + 8,
2006 word_size, byte_order);
2007 /* sigregs are followed by signo (4 bytes), then by the
2008 upper GPR halves if present. */
2009 sigreg_high_off = 4;
2012 /* The sigregs structure looks like this:
2021 /* PSW mask and address. */
2022 info->saved_regs[S390_PSWM_REGNUM].addr = sigreg_ptr;
2023 sigreg_ptr += word_size;
2024 info->saved_regs[S390_PSWA_REGNUM].addr = sigreg_ptr;
2025 sigreg_ptr += word_size;
2027 /* Then the GPRs. */
2028 for (i = 0; i < 16; i++)
2030 info->saved_regs[S390_R0_REGNUM + i].addr = sigreg_ptr;
2031 sigreg_ptr += word_size;
2034 /* Then the ACRs. */
2035 for (i = 0; i < 16; i++)
2037 info->saved_regs[S390_A0_REGNUM + i].addr = sigreg_ptr;
2041 /* The floating-point control word. */
2042 info->saved_regs[S390_FPC_REGNUM].addr = sigreg_ptr;
2045 /* And finally the FPRs. */
2046 for (i = 0; i < 16; i++)
2048 info->saved_regs[S390_F0_REGNUM + i].addr = sigreg_ptr;
2052 /* If we have them, the GPR upper halves are appended at the end. */
2053 sigreg_ptr += sigreg_high_off;
2054 if (tdep->gpr_full_regnum != -1)
2055 for (i = 0; i < 16; i++)
2057 info->saved_regs[S390_R0_UPPER_REGNUM + i].addr = sigreg_ptr;
2061 /* Restore the previous frame's SP. */
2062 prev_sp = read_memory_unsigned_integer (
2063 info->saved_regs[S390_SP_REGNUM].addr,
2064 word_size, byte_order);
2066 /* Determine our frame base. */
2067 info->frame_base = prev_sp + 16*word_size + 32;
2073 s390_sigtramp_frame_this_id (struct frame_info *this_frame,
2074 void **this_prologue_cache,
2075 struct frame_id *this_id)
2077 struct s390_sigtramp_unwind_cache *info
2078 = s390_sigtramp_frame_unwind_cache (this_frame, this_prologue_cache);
2079 *this_id = frame_id_build (info->frame_base, get_frame_pc (this_frame));
2082 static struct value *
2083 s390_sigtramp_frame_prev_register (struct frame_info *this_frame,
2084 void **this_prologue_cache, int regnum)
2086 struct s390_sigtramp_unwind_cache *info
2087 = s390_sigtramp_frame_unwind_cache (this_frame, this_prologue_cache);
2088 return s390_trad_frame_prev_register (this_frame, info->saved_regs, regnum);
2092 s390_sigtramp_frame_sniffer (const struct frame_unwind *self,
2093 struct frame_info *this_frame,
2094 void **this_prologue_cache)
2096 CORE_ADDR pc = get_frame_pc (this_frame);
2097 bfd_byte sigreturn[2];
2099 if (target_read_memory (pc, sigreturn, 2))
2102 if (sigreturn[0] != op_svc)
2105 if (sigreturn[1] != 119 /* sigreturn */
2106 && sigreturn[1] != 173 /* rt_sigreturn */)
2112 static const struct frame_unwind s390_sigtramp_frame_unwind = {
2114 default_frame_unwind_stop_reason,
2115 s390_sigtramp_frame_this_id,
2116 s390_sigtramp_frame_prev_register,
2118 s390_sigtramp_frame_sniffer
2121 /* Retrieve the syscall number at a ptrace syscall-stop. Return -1
2125 s390_linux_get_syscall_number (struct gdbarch *gdbarch,
2128 struct regcache *regs = get_thread_regcache (ptid);
2129 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2130 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2132 ULONGEST svc_number = -1;
2135 /* Assume that the PC points after the 2-byte SVC instruction. We
2136 don't currently support SVC via EXECUTE. */
2137 regcache_cooked_read_unsigned (regs, tdep->pc_regnum, &pc);
2139 opcode = read_memory_unsigned_integer ((CORE_ADDR) pc, 1, byte_order);
2140 if (opcode != op_svc)
2143 svc_number = read_memory_unsigned_integer ((CORE_ADDR) pc + 1, 1,
2145 if (svc_number == 0)
2146 regcache_cooked_read_unsigned (regs, S390_R1_REGNUM, &svc_number);
2152 /* Frame base handling. */
2155 s390_frame_base_address (struct frame_info *this_frame, void **this_cache)
2157 struct s390_unwind_cache *info
2158 = s390_frame_unwind_cache (this_frame, this_cache);
2159 return info->frame_base;
2163 s390_local_base_address (struct frame_info *this_frame, void **this_cache)
2165 struct s390_unwind_cache *info
2166 = s390_frame_unwind_cache (this_frame, this_cache);
2167 return info->local_base;
2170 static const struct frame_base s390_frame_base = {
2172 s390_frame_base_address,
2173 s390_local_base_address,
2174 s390_local_base_address
2178 s390_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
2180 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2182 pc = frame_unwind_register_unsigned (next_frame, tdep->pc_regnum);
2183 return gdbarch_addr_bits_remove (gdbarch, pc);
2187 s390_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
2190 sp = frame_unwind_register_unsigned (next_frame, S390_SP_REGNUM);
2191 return gdbarch_addr_bits_remove (gdbarch, sp);
2195 /* DWARF-2 frame support. */
2197 static struct value *
2198 s390_dwarf2_prev_register (struct frame_info *this_frame, void **this_cache,
2201 return s390_unwind_pseudo_register (this_frame, regnum);
2205 s390_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
2206 struct dwarf2_frame_state_reg *reg,
2207 struct frame_info *this_frame)
2209 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2211 /* The condition code (and thus PSW mask) is call-clobbered. */
2212 if (regnum == S390_PSWM_REGNUM)
2213 reg->how = DWARF2_FRAME_REG_UNDEFINED;
2215 /* The PSW address unwinds to the return address. */
2216 else if (regnum == S390_PSWA_REGNUM)
2217 reg->how = DWARF2_FRAME_REG_RA;
2219 /* Fixed registers are call-saved or call-clobbered
2220 depending on the ABI in use. */
2221 else if (regnum < S390_NUM_REGS)
2223 if (s390_register_call_saved (gdbarch, regnum))
2224 reg->how = DWARF2_FRAME_REG_SAME_VALUE;
2226 reg->how = DWARF2_FRAME_REG_UNDEFINED;
2229 /* We install a special function to unwind pseudos. */
2232 reg->how = DWARF2_FRAME_REG_FN;
2233 reg->loc.fn = s390_dwarf2_prev_register;
2238 /* Dummy function calls. */
2240 /* Return non-zero if TYPE is an integer-like type, zero otherwise.
2241 "Integer-like" types are those that should be passed the way
2242 integers are: integers, enums, ranges, characters, and booleans. */
2244 is_integer_like (struct type *type)
2246 enum type_code code = TYPE_CODE (type);
2248 return (code == TYPE_CODE_INT
2249 || code == TYPE_CODE_ENUM
2250 || code == TYPE_CODE_RANGE
2251 || code == TYPE_CODE_CHAR
2252 || code == TYPE_CODE_BOOL);
2255 /* Return non-zero if TYPE is a pointer-like type, zero otherwise.
2256 "Pointer-like" types are those that should be passed the way
2257 pointers are: pointers and references. */
2259 is_pointer_like (struct type *type)
2261 enum type_code code = TYPE_CODE (type);
2263 return (code == TYPE_CODE_PTR
2264 || code == TYPE_CODE_REF);
2268 /* Return non-zero if TYPE is a `float singleton' or `double
2269 singleton', zero otherwise.
2271 A `T singleton' is a struct type with one member, whose type is
2272 either T or a `T singleton'. So, the following are all float
2276 struct { struct { float x; } x; };
2277 struct { struct { struct { float x; } x; } x; };
2281 All such structures are passed as if they were floats or doubles,
2282 as the (revised) ABI says. */
2284 is_float_singleton (struct type *type)
2286 if (TYPE_CODE (type) == TYPE_CODE_STRUCT && TYPE_NFIELDS (type) == 1)
2288 struct type *singleton_type = TYPE_FIELD_TYPE (type, 0);
2289 CHECK_TYPEDEF (singleton_type);
2291 return (TYPE_CODE (singleton_type) == TYPE_CODE_FLT
2292 || TYPE_CODE (singleton_type) == TYPE_CODE_DECFLOAT
2293 || is_float_singleton (singleton_type));
2300 /* Return non-zero if TYPE is a struct-like type, zero otherwise.
2301 "Struct-like" types are those that should be passed as structs are:
2304 As an odd quirk, not mentioned in the ABI, GCC passes float and
2305 double singletons as if they were a plain float, double, etc. (The
2306 corresponding union types are handled normally.) So we exclude
2307 those types here. *shrug* */
2309 is_struct_like (struct type *type)
2311 enum type_code code = TYPE_CODE (type);
2313 return (code == TYPE_CODE_UNION
2314 || (code == TYPE_CODE_STRUCT && ! is_float_singleton (type)));
2318 /* Return non-zero if TYPE is a float-like type, zero otherwise.
2319 "Float-like" types are those that should be passed as
2320 floating-point values are.
2322 You'd think this would just be floats, doubles, long doubles, etc.
2323 But as an odd quirk, not mentioned in the ABI, GCC passes float and
2324 double singletons as if they were a plain float, double, etc. (The
2325 corresponding union types are handled normally.) So we include
2326 those types here. *shrug* */
2328 is_float_like (struct type *type)
2330 return (TYPE_CODE (type) == TYPE_CODE_FLT
2331 || TYPE_CODE (type) == TYPE_CODE_DECFLOAT
2332 || is_float_singleton (type));
2337 is_power_of_two (unsigned int n)
2339 return ((n & (n - 1)) == 0);
2342 /* Return non-zero if TYPE should be passed as a pointer to a copy,
2345 s390_function_arg_pass_by_reference (struct type *type)
2347 if (TYPE_LENGTH (type) > 8)
2350 return (is_struct_like (type) && !is_power_of_two (TYPE_LENGTH (type)))
2351 || TYPE_CODE (type) == TYPE_CODE_COMPLEX
2352 || (TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type));
2355 /* Return non-zero if TYPE should be passed in a float register
2358 s390_function_arg_float (struct type *type)
2360 if (TYPE_LENGTH (type) > 8)
2363 return is_float_like (type);
2366 /* Return non-zero if TYPE should be passed in an integer register
2367 (or a pair of integer registers) if possible. */
2369 s390_function_arg_integer (struct type *type)
2371 if (TYPE_LENGTH (type) > 8)
2374 return is_integer_like (type)
2375 || is_pointer_like (type)
2376 || (is_struct_like (type) && is_power_of_two (TYPE_LENGTH (type)));
2379 /* Return ARG, a `SIMPLE_ARG', sign-extended or zero-extended to a full
2380 word as required for the ABI. */
2382 extend_simple_arg (struct gdbarch *gdbarch, struct value *arg)
2384 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2385 struct type *type = check_typedef (value_type (arg));
2387 /* Even structs get passed in the least significant bits of the
2388 register / memory word. It's not really right to extract them as
2389 an integer, but it does take care of the extension. */
2390 if (TYPE_UNSIGNED (type))
2391 return extract_unsigned_integer (value_contents (arg),
2392 TYPE_LENGTH (type), byte_order);
2394 return extract_signed_integer (value_contents (arg),
2395 TYPE_LENGTH (type), byte_order);
2399 /* Return the alignment required by TYPE. */
2401 alignment_of (struct type *type)
2405 if (is_integer_like (type)
2406 || is_pointer_like (type)
2407 || TYPE_CODE (type) == TYPE_CODE_FLT
2408 || TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
2409 alignment = TYPE_LENGTH (type);
2410 else if (TYPE_CODE (type) == TYPE_CODE_STRUCT
2411 || TYPE_CODE (type) == TYPE_CODE_UNION)
2416 for (i = 0; i < TYPE_NFIELDS (type); i++)
2419 = alignment_of (check_typedef (TYPE_FIELD_TYPE (type, i)));
2421 if (field_alignment > alignment)
2422 alignment = field_alignment;
2428 /* Check that everything we ever return is a power of two. Lots of
2429 code doesn't want to deal with aligning things to arbitrary
2431 gdb_assert ((alignment & (alignment - 1)) == 0);
2437 /* Put the actual parameter values pointed to by ARGS[0..NARGS-1] in
2438 place to be passed to a function, as specified by the "GNU/Linux
2439 for S/390 ELF Application Binary Interface Supplement".
2441 SP is the current stack pointer. We must put arguments, links,
2442 padding, etc. whereever they belong, and return the new stack
2445 If STRUCT_RETURN is non-zero, then the function we're calling is
2446 going to return a structure by value; STRUCT_ADDR is the address of
2447 a block we've allocated for it on the stack.
2449 Our caller has taken care of any type promotions needed to satisfy
2450 prototypes or the old K&R argument-passing rules. */
2452 s390_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
2453 struct regcache *regcache, CORE_ADDR bp_addr,
2454 int nargs, struct value **args, CORE_ADDR sp,
2455 int struct_return, CORE_ADDR struct_addr)
2457 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2458 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
2459 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2462 /* If the i'th argument is passed as a reference to a copy, then
2463 copy_addr[i] is the address of the copy we made. */
2464 CORE_ADDR *copy_addr = alloca (nargs * sizeof (CORE_ADDR));
2466 /* Reserve space for the reference-to-copy area. */
2467 for (i = 0; i < nargs; i++)
2469 struct value *arg = args[i];
2470 struct type *type = check_typedef (value_type (arg));
2472 if (s390_function_arg_pass_by_reference (type))
2474 sp -= TYPE_LENGTH (type);
2475 sp = align_down (sp, alignment_of (type));
2480 /* Reserve space for the parameter area. As a conservative
2481 simplification, we assume that everything will be passed on the
2482 stack. Since every argument larger than 8 bytes will be
2483 passed by reference, we use this simple upper bound. */
2486 /* After all that, make sure it's still aligned on an eight-byte
2488 sp = align_down (sp, 8);
2490 /* Allocate the standard frame areas: the register save area, the
2491 word reserved for the compiler (which seems kind of meaningless),
2492 and the back chain pointer. */
2493 sp -= 16*word_size + 32;
2495 /* Now we have the final SP value. Make sure we didn't underflow;
2496 on 31-bit, this would result in addresses with the high bit set,
2497 which causes confusion elsewhere. Note that if we error out
2498 here, stack and registers remain untouched. */
2499 if (gdbarch_addr_bits_remove (gdbarch, sp) != sp)
2500 error (_("Stack overflow"));
2503 /* Finally, place the actual parameters, working from SP towards
2504 higher addresses. The code above is supposed to reserve enough
2509 CORE_ADDR starg = sp + 16*word_size + 32;
2511 /* A struct is returned using general register 2. */
2514 regcache_cooked_write_unsigned (regcache, S390_R0_REGNUM + gr,
2519 for (i = 0; i < nargs; i++)
2521 struct value *arg = args[i];
2522 struct type *type = check_typedef (value_type (arg));
2523 unsigned length = TYPE_LENGTH (type);
2525 if (s390_function_arg_pass_by_reference (type))
2527 /* Actually copy the argument contents to the stack slot
2528 that was reserved above. */
2529 write_memory (copy_addr[i], value_contents (arg), length);
2533 regcache_cooked_write_unsigned (regcache, S390_R0_REGNUM + gr,
2539 write_memory_unsigned_integer (starg, word_size, byte_order,
2544 else if (s390_function_arg_float (type))
2546 /* The GNU/Linux for S/390 ABI uses FPRs 0 and 2 to pass arguments,
2547 the GNU/Linux for zSeries ABI uses 0, 2, 4, and 6. */
2548 if (fr <= (tdep->abi == ABI_LINUX_S390 ? 2 : 6))
2550 /* When we store a single-precision value in an FP register,
2551 it occupies the leftmost bits. */
2552 regcache_cooked_write_part (regcache, S390_F0_REGNUM + fr,
2553 0, length, value_contents (arg));
2558 /* When we store a single-precision value in a stack slot,
2559 it occupies the rightmost bits. */
2560 starg = align_up (starg + length, word_size);
2561 write_memory (starg - length, value_contents (arg), length);
2564 else if (s390_function_arg_integer (type) && length <= word_size)
2568 /* Integer arguments are always extended to word size. */
2569 regcache_cooked_write_signed (regcache, S390_R0_REGNUM + gr,
2570 extend_simple_arg (gdbarch,
2576 /* Integer arguments are always extended to word size. */
2577 write_memory_signed_integer (starg, word_size, byte_order,
2578 extend_simple_arg (gdbarch, arg));
2582 else if (s390_function_arg_integer (type) && length == 2*word_size)
2586 regcache_cooked_write (regcache, S390_R0_REGNUM + gr,
2587 value_contents (arg));
2588 regcache_cooked_write (regcache, S390_R0_REGNUM + gr + 1,
2589 value_contents (arg) + word_size);
2594 /* If we skipped r6 because we couldn't fit a DOUBLE_ARG
2595 in it, then don't go back and use it again later. */
2598 write_memory (starg, value_contents (arg), length);
2603 internal_error (__FILE__, __LINE__, _("unknown argument type"));
2607 /* Store return PSWA. In 31-bit mode, keep addressing mode bit. */
2611 regcache_cooked_read_unsigned (regcache, S390_PSWA_REGNUM, &pswa);
2612 bp_addr = (bp_addr & 0x7fffffff) | (pswa & 0x80000000);
2614 regcache_cooked_write_unsigned (regcache, S390_RETADDR_REGNUM, bp_addr);
2616 /* Store updated stack pointer. */
2617 regcache_cooked_write_unsigned (regcache, S390_SP_REGNUM, sp);
2619 /* We need to return the 'stack part' of the frame ID,
2620 which is actually the top of the register save area. */
2621 return sp + 16*word_size + 32;
2624 /* Assuming THIS_FRAME is a dummy, return the frame ID of that
2625 dummy frame. The frame ID's base needs to match the TOS value
2626 returned by push_dummy_call, and the PC match the dummy frame's
2628 static struct frame_id
2629 s390_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
2631 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
2632 CORE_ADDR sp = get_frame_register_unsigned (this_frame, S390_SP_REGNUM);
2633 sp = gdbarch_addr_bits_remove (gdbarch, sp);
2635 return frame_id_build (sp + 16*word_size + 32,
2636 get_frame_pc (this_frame));
2640 s390_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
2642 /* Both the 32- and 64-bit ABI's say that the stack pointer should
2643 always be aligned on an eight-byte boundary. */
2648 /* Function return value access. */
2650 static enum return_value_convention
2651 s390_return_value_convention (struct gdbarch *gdbarch, struct type *type)
2653 if (TYPE_LENGTH (type) > 8)
2654 return RETURN_VALUE_STRUCT_CONVENTION;
2656 switch (TYPE_CODE (type))
2658 case TYPE_CODE_STRUCT:
2659 case TYPE_CODE_UNION:
2660 case TYPE_CODE_ARRAY:
2661 case TYPE_CODE_COMPLEX:
2662 return RETURN_VALUE_STRUCT_CONVENTION;
2665 return RETURN_VALUE_REGISTER_CONVENTION;
2669 static enum return_value_convention
2670 s390_return_value (struct gdbarch *gdbarch, struct value *function,
2671 struct type *type, struct regcache *regcache,
2672 gdb_byte *out, const gdb_byte *in)
2674 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2675 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
2676 enum return_value_convention rvc;
2679 type = check_typedef (type);
2680 rvc = s390_return_value_convention (gdbarch, type);
2681 length = TYPE_LENGTH (type);
2687 case RETURN_VALUE_REGISTER_CONVENTION:
2688 if (TYPE_CODE (type) == TYPE_CODE_FLT
2689 || TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
2691 /* When we store a single-precision value in an FP register,
2692 it occupies the leftmost bits. */
2693 regcache_cooked_write_part (regcache, S390_F0_REGNUM,
2696 else if (length <= word_size)
2698 /* Integer arguments are always extended to word size. */
2699 if (TYPE_UNSIGNED (type))
2700 regcache_cooked_write_unsigned (regcache, S390_R2_REGNUM,
2701 extract_unsigned_integer (in, length, byte_order));
2703 regcache_cooked_write_signed (regcache, S390_R2_REGNUM,
2704 extract_signed_integer (in, length, byte_order));
2706 else if (length == 2*word_size)
2708 regcache_cooked_write (regcache, S390_R2_REGNUM, in);
2709 regcache_cooked_write (regcache, S390_R3_REGNUM, in + word_size);
2712 internal_error (__FILE__, __LINE__, _("invalid return type"));
2715 case RETURN_VALUE_STRUCT_CONVENTION:
2716 error (_("Cannot set function return value."));
2724 case RETURN_VALUE_REGISTER_CONVENTION:
2725 if (TYPE_CODE (type) == TYPE_CODE_FLT
2726 || TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
2728 /* When we store a single-precision value in an FP register,
2729 it occupies the leftmost bits. */
2730 regcache_cooked_read_part (regcache, S390_F0_REGNUM,
2733 else if (length <= word_size)
2735 /* Integer arguments occupy the rightmost bits. */
2736 regcache_cooked_read_part (regcache, S390_R2_REGNUM,
2737 word_size - length, length, out);
2739 else if (length == 2*word_size)
2741 regcache_cooked_read (regcache, S390_R2_REGNUM, out);
2742 regcache_cooked_read (regcache, S390_R3_REGNUM, out + word_size);
2745 internal_error (__FILE__, __LINE__, _("invalid return type"));
2748 case RETURN_VALUE_STRUCT_CONVENTION:
2749 error (_("Function return value unknown."));
2760 static const gdb_byte *
2761 s390_breakpoint_from_pc (struct gdbarch *gdbarch,
2762 CORE_ADDR *pcptr, int *lenptr)
2764 static const gdb_byte breakpoint[] = { 0x0, 0x1 };
2766 *lenptr = sizeof (breakpoint);
2771 /* Address handling. */
2774 s390_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr)
2776 return addr & 0x7fffffff;
2780 s390_address_class_type_flags (int byte_size, int dwarf2_addr_class)
2783 return TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1;
2789 s390_address_class_type_flags_to_name (struct gdbarch *gdbarch, int type_flags)
2791 if (type_flags & TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1)
2798 s390_address_class_name_to_type_flags (struct gdbarch *gdbarch,
2800 int *type_flags_ptr)
2802 if (strcmp (name, "mode32") == 0)
2804 *type_flags_ptr = TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1;
2811 /* Implementation of `gdbarch_stap_is_single_operand', as defined in
2815 s390_stap_is_single_operand (struct gdbarch *gdbarch, const char *s)
2817 return ((isdigit (*s) && s[1] == '(' && s[2] == '%') /* Displacement
2819 || *s == '%' /* Register access. */
2820 || isdigit (*s)); /* Literal number. */
2823 /* Set up gdbarch struct. */
2825 static struct gdbarch *
2826 s390_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
2828 const struct target_desc *tdesc = info.target_desc;
2829 struct tdesc_arch_data *tdesc_data = NULL;
2830 struct gdbarch *gdbarch;
2831 struct gdbarch_tdep *tdep;
2834 int have_linux_v1 = 0;
2835 int have_linux_v2 = 0;
2837 int first_pseudo_reg, last_pseudo_reg;
2838 static const char *const stap_register_prefixes[] = { "%", NULL };
2839 static const char *const stap_register_indirection_prefixes[] = { "(",
2841 static const char *const stap_register_indirection_suffixes[] = { ")",
2844 /* Default ABI and register size. */
2845 switch (info.bfd_arch_info->mach)
2847 case bfd_mach_s390_31:
2848 tdep_abi = ABI_LINUX_S390;
2851 case bfd_mach_s390_64:
2852 tdep_abi = ABI_LINUX_ZSERIES;
2859 /* Use default target description if none provided by the target. */
2860 if (!tdesc_has_registers (tdesc))
2862 if (tdep_abi == ABI_LINUX_S390)
2863 tdesc = tdesc_s390_linux32;
2865 tdesc = tdesc_s390x_linux64;
2868 /* Check any target description for validity. */
2869 if (tdesc_has_registers (tdesc))
2871 static const char *const gprs[] = {
2872 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2873 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
2875 static const char *const fprs[] = {
2876 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
2877 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15"
2879 static const char *const acrs[] = {
2880 "acr0", "acr1", "acr2", "acr3", "acr4", "acr5", "acr6", "acr7",
2881 "acr8", "acr9", "acr10", "acr11", "acr12", "acr13", "acr14", "acr15"
2883 static const char *const gprs_lower[] = {
2884 "r0l", "r1l", "r2l", "r3l", "r4l", "r5l", "r6l", "r7l",
2885 "r8l", "r9l", "r10l", "r11l", "r12l", "r13l", "r14l", "r15l"
2887 static const char *const gprs_upper[] = {
2888 "r0h", "r1h", "r2h", "r3h", "r4h", "r5h", "r6h", "r7h",
2889 "r8h", "r9h", "r10h", "r11h", "r12h", "r13h", "r14h", "r15h"
2891 static const char *const tdb_regs[] = {
2892 "tdb0", "tac", "tct", "atia",
2893 "tr0", "tr1", "tr2", "tr3", "tr4", "tr5", "tr6", "tr7",
2894 "tr8", "tr9", "tr10", "tr11", "tr12", "tr13", "tr14", "tr15"
2896 const struct tdesc_feature *feature;
2899 feature = tdesc_find_feature (tdesc, "org.gnu.gdb.s390.core");
2900 if (feature == NULL)
2903 tdesc_data = tdesc_data_alloc ();
2905 valid_p &= tdesc_numbered_register (feature, tdesc_data,
2906 S390_PSWM_REGNUM, "pswm");
2907 valid_p &= tdesc_numbered_register (feature, tdesc_data,
2908 S390_PSWA_REGNUM, "pswa");
2910 if (tdesc_unnumbered_register (feature, "r0"))
2912 for (i = 0; i < 16; i++)
2913 valid_p &= tdesc_numbered_register (feature, tdesc_data,
2914 S390_R0_REGNUM + i, gprs[i]);
2920 for (i = 0; i < 16; i++)
2921 valid_p &= tdesc_numbered_register (feature, tdesc_data,
2924 for (i = 0; i < 16; i++)
2925 valid_p &= tdesc_numbered_register (feature, tdesc_data,
2926 S390_R0_UPPER_REGNUM + i,
2930 feature = tdesc_find_feature (tdesc, "org.gnu.gdb.s390.fpr");
2931 if (feature == NULL)
2933 tdesc_data_cleanup (tdesc_data);
2937 valid_p &= tdesc_numbered_register (feature, tdesc_data,
2938 S390_FPC_REGNUM, "fpc");
2939 for (i = 0; i < 16; i++)
2940 valid_p &= tdesc_numbered_register (feature, tdesc_data,
2941 S390_F0_REGNUM + i, fprs[i]);
2943 feature = tdesc_find_feature (tdesc, "org.gnu.gdb.s390.acr");
2944 if (feature == NULL)
2946 tdesc_data_cleanup (tdesc_data);
2950 for (i = 0; i < 16; i++)
2951 valid_p &= tdesc_numbered_register (feature, tdesc_data,
2952 S390_A0_REGNUM + i, acrs[i]);
2954 /* Optional GNU/Linux-specific "registers". */
2955 feature = tdesc_find_feature (tdesc, "org.gnu.gdb.s390.linux");
2958 tdesc_numbered_register (feature, tdesc_data,
2959 S390_ORIG_R2_REGNUM, "orig_r2");
2961 if (tdesc_numbered_register (feature, tdesc_data,
2962 S390_LAST_BREAK_REGNUM, "last_break"))
2965 if (tdesc_numbered_register (feature, tdesc_data,
2966 S390_SYSTEM_CALL_REGNUM, "system_call"))
2969 if (have_linux_v2 > have_linux_v1)
2973 /* Transaction diagnostic block. */
2974 feature = tdesc_find_feature (tdesc, "org.gnu.gdb.s390.tdb");
2977 for (i = 0; i < ARRAY_SIZE (tdb_regs); i++)
2978 valid_p &= tdesc_numbered_register (feature, tdesc_data,
2979 S390_TDB_DWORD0_REGNUM + i,
2986 tdesc_data_cleanup (tdesc_data);
2991 /* Find a candidate among extant architectures. */
2992 for (arches = gdbarch_list_lookup_by_info (arches, &info);
2994 arches = gdbarch_list_lookup_by_info (arches->next, &info))
2996 tdep = gdbarch_tdep (arches->gdbarch);
2999 if (tdep->abi != tdep_abi)
3001 if ((tdep->gpr_full_regnum != -1) != have_upper)
3003 if (tdesc_data != NULL)
3004 tdesc_data_cleanup (tdesc_data);
3005 return arches->gdbarch;
3008 /* Otherwise create a new gdbarch for the specified machine type. */
3009 tdep = XCNEW (struct gdbarch_tdep);
3010 tdep->abi = tdep_abi;
3011 tdep->have_linux_v1 = have_linux_v1;
3012 tdep->have_linux_v2 = have_linux_v2;
3013 tdep->have_tdb = have_tdb;
3014 gdbarch = gdbarch_alloc (&info, tdep);
3016 set_gdbarch_believe_pcc_promotion (gdbarch, 0);
3017 set_gdbarch_char_signed (gdbarch, 0);
3019 /* S/390 GNU/Linux uses either 64-bit or 128-bit long doubles.
3020 We can safely let them default to 128-bit, since the debug info
3021 will give the size of type actually used in each case. */
3022 set_gdbarch_long_double_bit (gdbarch, 128);
3023 set_gdbarch_long_double_format (gdbarch, floatformats_ia64_quad);
3025 /* Amount PC must be decremented by after a breakpoint. This is
3026 often the number of bytes returned by gdbarch_breakpoint_from_pc but not
3028 set_gdbarch_decr_pc_after_break (gdbarch, 2);
3029 /* Stack grows downward. */
3030 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
3031 set_gdbarch_breakpoint_from_pc (gdbarch, s390_breakpoint_from_pc);
3032 set_gdbarch_skip_prologue (gdbarch, s390_skip_prologue);
3033 set_gdbarch_in_function_epilogue_p (gdbarch, s390_in_function_epilogue_p);
3035 set_gdbarch_num_regs (gdbarch, S390_NUM_REGS);
3036 set_gdbarch_sp_regnum (gdbarch, S390_SP_REGNUM);
3037 set_gdbarch_fp0_regnum (gdbarch, S390_F0_REGNUM);
3038 set_gdbarch_stab_reg_to_regnum (gdbarch, s390_dwarf_reg_to_regnum);
3039 set_gdbarch_dwarf2_reg_to_regnum (gdbarch, s390_dwarf_reg_to_regnum);
3040 set_gdbarch_value_from_register (gdbarch, s390_value_from_register);
3041 set_gdbarch_core_read_description (gdbarch, s390_core_read_description);
3042 set_gdbarch_iterate_over_regset_sections (gdbarch,
3043 s390_iterate_over_regset_sections);
3044 set_gdbarch_cannot_store_register (gdbarch, s390_cannot_store_register);
3045 set_gdbarch_write_pc (gdbarch, s390_write_pc);
3046 set_gdbarch_pseudo_register_read (gdbarch, s390_pseudo_register_read);
3047 set_gdbarch_pseudo_register_write (gdbarch, s390_pseudo_register_write);
3048 set_tdesc_pseudo_register_name (gdbarch, s390_pseudo_register_name);
3049 set_tdesc_pseudo_register_type (gdbarch, s390_pseudo_register_type);
3050 set_tdesc_pseudo_register_reggroup_p (gdbarch,
3051 s390_pseudo_register_reggroup_p);
3052 tdesc_use_registers (gdbarch, tdesc, tdesc_data);
3054 /* Assign pseudo register numbers. */
3055 first_pseudo_reg = gdbarch_num_regs (gdbarch);
3056 last_pseudo_reg = first_pseudo_reg;
3057 tdep->gpr_full_regnum = -1;
3060 tdep->gpr_full_regnum = last_pseudo_reg;
3061 last_pseudo_reg += 16;
3063 tdep->pc_regnum = last_pseudo_reg++;
3064 tdep->cc_regnum = last_pseudo_reg++;
3065 set_gdbarch_pc_regnum (gdbarch, tdep->pc_regnum);
3066 set_gdbarch_num_pseudo_regs (gdbarch, last_pseudo_reg - first_pseudo_reg);
3068 /* Inferior function calls. */
3069 set_gdbarch_push_dummy_call (gdbarch, s390_push_dummy_call);
3070 set_gdbarch_dummy_id (gdbarch, s390_dummy_id);
3071 set_gdbarch_frame_align (gdbarch, s390_frame_align);
3072 set_gdbarch_return_value (gdbarch, s390_return_value);
3074 /* Syscall handling. */
3075 set_gdbarch_get_syscall_number (gdbarch, s390_linux_get_syscall_number);
3077 /* Frame handling. */
3078 dwarf2_frame_set_init_reg (gdbarch, s390_dwarf2_frame_init_reg);
3079 dwarf2_frame_set_adjust_regnum (gdbarch, s390_adjust_frame_regnum);
3080 dwarf2_append_unwinders (gdbarch);
3081 frame_base_append_sniffer (gdbarch, dwarf2_frame_base_sniffer);
3082 frame_unwind_append_unwinder (gdbarch, &s390_stub_frame_unwind);
3083 frame_unwind_append_unwinder (gdbarch, &s390_sigtramp_frame_unwind);
3084 frame_unwind_append_unwinder (gdbarch, &s390_frame_unwind);
3085 frame_base_set_default (gdbarch, &s390_frame_base);
3086 set_gdbarch_unwind_pc (gdbarch, s390_unwind_pc);
3087 set_gdbarch_unwind_sp (gdbarch, s390_unwind_sp);
3089 /* Displaced stepping. */
3090 set_gdbarch_displaced_step_copy_insn (gdbarch,
3091 simple_displaced_step_copy_insn);
3092 set_gdbarch_displaced_step_fixup (gdbarch, s390_displaced_step_fixup);
3093 set_gdbarch_displaced_step_free_closure (gdbarch,
3094 simple_displaced_step_free_closure);
3095 set_gdbarch_displaced_step_location (gdbarch,
3096 displaced_step_at_entry_point);
3097 set_gdbarch_max_insn_length (gdbarch, S390_MAX_INSTR_SIZE);
3099 /* Note that GNU/Linux is the only OS supported on this
3101 linux_init_abi (info, gdbarch);
3105 case ABI_LINUX_S390:
3106 set_gdbarch_addr_bits_remove (gdbarch, s390_addr_bits_remove);
3107 set_solib_svr4_fetch_link_map_offsets
3108 (gdbarch, svr4_ilp32_fetch_link_map_offsets);
3110 set_xml_syscall_file_name (XML_SYSCALL_FILENAME_S390);
3113 case ABI_LINUX_ZSERIES:
3114 set_gdbarch_long_bit (gdbarch, 64);
3115 set_gdbarch_long_long_bit (gdbarch, 64);
3116 set_gdbarch_ptr_bit (gdbarch, 64);
3117 set_solib_svr4_fetch_link_map_offsets
3118 (gdbarch, svr4_lp64_fetch_link_map_offsets);
3119 set_gdbarch_address_class_type_flags (gdbarch,
3120 s390_address_class_type_flags);
3121 set_gdbarch_address_class_type_flags_to_name (gdbarch,
3122 s390_address_class_type_flags_to_name);
3123 set_gdbarch_address_class_name_to_type_flags (gdbarch,
3124 s390_address_class_name_to_type_flags);
3125 set_xml_syscall_file_name (XML_SYSCALL_FILENAME_S390);
3129 set_gdbarch_print_insn (gdbarch, print_insn_s390);
3131 set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
3133 /* Enable TLS support. */
3134 set_gdbarch_fetch_tls_load_module_address (gdbarch,
3135 svr4_fetch_objfile_link_map);
3137 set_gdbarch_get_siginfo_type (gdbarch, linux_get_siginfo_type);
3139 /* SystemTap functions. */
3140 set_gdbarch_stap_register_prefixes (gdbarch, stap_register_prefixes);
3141 set_gdbarch_stap_register_indirection_prefixes (gdbarch,
3142 stap_register_indirection_prefixes);
3143 set_gdbarch_stap_register_indirection_suffixes (gdbarch,
3144 stap_register_indirection_suffixes);
3145 set_gdbarch_stap_is_single_operand (gdbarch, s390_stap_is_single_operand);
3151 extern initialize_file_ftype _initialize_s390_tdep; /* -Wmissing-prototypes */
3154 _initialize_s390_tdep (void)
3156 /* Hook us into the gdbarch mechanism. */
3157 register_gdbarch_init (bfd_arch_s390, s390_gdbarch_init);
3159 /* Initialize the GNU/Linux target descriptions. */
3160 initialize_tdesc_s390_linux32 ();
3161 initialize_tdesc_s390_linux32v1 ();
3162 initialize_tdesc_s390_linux32v2 ();
3163 initialize_tdesc_s390_linux64 ();
3164 initialize_tdesc_s390_linux64v1 ();
3165 initialize_tdesc_s390_linux64v2 ();
3166 initialize_tdesc_s390_te_linux64 ();
3167 initialize_tdesc_s390x_linux64 ();
3168 initialize_tdesc_s390x_linux64v1 ();
3169 initialize_tdesc_s390x_linux64v2 ();
3170 initialize_tdesc_s390x_te_linux64 ();