1 /* Target-dependent code for GDB, the GNU debugger.
3 Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
4 Free Software Foundation, Inc.
6 Contributed by D.J. Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
7 for IBM Deutschland Entwicklung GmbH, IBM Corporation.
9 This file is part of GDB.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program. If not, see <http://www.gnu.org/licenses/>. */
25 #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"
42 #include "gdb_assert.h"
44 #include "solib-svr4.h"
45 #include "prologue-value.h"
47 #include "s390-tdep.h"
50 /* The tdep structure. */
55 enum { ABI_LINUX_S390
, ABI_LINUX_ZSERIES
} abi
;
57 /* Core file register sets. */
58 const struct regset
*gregset
;
61 const struct regset
*fpregset
;
66 /* Return the name of register REGNUM. */
68 s390_register_name (struct gdbarch
*gdbarch
, int regnum
)
70 static const char *register_names
[S390_NUM_TOTAL_REGS
] =
72 /* Program Status Word. */
74 /* General Purpose Registers. */
75 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
76 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
77 /* Access Registers. */
78 "acr0", "acr1", "acr2", "acr3", "acr4", "acr5", "acr6", "acr7",
79 "acr8", "acr9", "acr10", "acr11", "acr12", "acr13", "acr14", "acr15",
80 /* Floating Point Control Word. */
82 /* Floating Point Registers. */
83 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
84 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
85 /* Pseudo registers. */
89 gdb_assert (regnum
>= 0 && regnum
< S390_NUM_TOTAL_REGS
);
90 return register_names
[regnum
];
93 /* Return the GDB type object for the "standard" data type of data in
96 s390_register_type (struct gdbarch
*gdbarch
, int regnum
)
98 if (regnum
== S390_PSWM_REGNUM
|| regnum
== S390_PSWA_REGNUM
)
99 return builtin_type (gdbarch
)->builtin_long
;
100 if (regnum
>= S390_R0_REGNUM
&& regnum
<= S390_R15_REGNUM
)
101 return builtin_type (gdbarch
)->builtin_long
;
102 if (regnum
>= S390_A0_REGNUM
&& regnum
<= S390_A15_REGNUM
)
103 return builtin_type (gdbarch
)->builtin_int
;
104 if (regnum
== S390_FPC_REGNUM
)
105 return builtin_type (gdbarch
)->builtin_int
;
106 if (regnum
>= S390_F0_REGNUM
&& regnum
<= S390_F15_REGNUM
)
107 return builtin_type (gdbarch
)->builtin_double
;
108 if (regnum
== S390_PC_REGNUM
)
109 return builtin_type (gdbarch
)->builtin_func_ptr
;
110 if (regnum
== S390_CC_REGNUM
)
111 return builtin_type (gdbarch
)->builtin_int
;
113 internal_error (__FILE__
, __LINE__
, _("invalid regnum"));
116 /* DWARF Register Mapping. */
118 static int s390_dwarf_regmap
[] =
120 /* General Purpose Registers. */
121 S390_R0_REGNUM
, S390_R1_REGNUM
, S390_R2_REGNUM
, S390_R3_REGNUM
,
122 S390_R4_REGNUM
, S390_R5_REGNUM
, S390_R6_REGNUM
, S390_R7_REGNUM
,
123 S390_R8_REGNUM
, S390_R9_REGNUM
, S390_R10_REGNUM
, S390_R11_REGNUM
,
124 S390_R12_REGNUM
, S390_R13_REGNUM
, S390_R14_REGNUM
, S390_R15_REGNUM
,
126 /* Floating Point Registers. */
127 S390_F0_REGNUM
, S390_F2_REGNUM
, S390_F4_REGNUM
, S390_F6_REGNUM
,
128 S390_F1_REGNUM
, S390_F3_REGNUM
, S390_F5_REGNUM
, S390_F7_REGNUM
,
129 S390_F8_REGNUM
, S390_F10_REGNUM
, S390_F12_REGNUM
, S390_F14_REGNUM
,
130 S390_F9_REGNUM
, S390_F11_REGNUM
, S390_F13_REGNUM
, S390_F15_REGNUM
,
132 /* Control Registers (not mapped). */
133 -1, -1, -1, -1, -1, -1, -1, -1,
134 -1, -1, -1, -1, -1, -1, -1, -1,
136 /* Access Registers. */
137 S390_A0_REGNUM
, S390_A1_REGNUM
, S390_A2_REGNUM
, S390_A3_REGNUM
,
138 S390_A4_REGNUM
, S390_A5_REGNUM
, S390_A6_REGNUM
, S390_A7_REGNUM
,
139 S390_A8_REGNUM
, S390_A9_REGNUM
, S390_A10_REGNUM
, S390_A11_REGNUM
,
140 S390_A12_REGNUM
, S390_A13_REGNUM
, S390_A14_REGNUM
, S390_A15_REGNUM
,
142 /* Program Status Word. */
147 /* Convert DWARF register number REG to the appropriate register
148 number used by GDB. */
150 s390_dwarf_reg_to_regnum (struct gdbarch
*gdbarch
, int reg
)
154 if (reg
>= 0 && reg
< ARRAY_SIZE (s390_dwarf_regmap
))
155 regnum
= s390_dwarf_regmap
[reg
];
158 warning (_("Unmapped DWARF Register #%d encountered."), reg
);
163 /* Pseudo registers - PC and condition code. */
166 s390_pseudo_register_read (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
167 int regnum
, gdb_byte
*buf
)
169 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
175 regcache_raw_read_unsigned (regcache
, S390_PSWA_REGNUM
, &val
);
176 store_unsigned_integer (buf
, 4, byte_order
, val
& 0x7fffffff);
180 regcache_raw_read_unsigned (regcache
, S390_PSWM_REGNUM
, &val
);
181 store_unsigned_integer (buf
, 4, byte_order
, (val
>> 12) & 3);
185 internal_error (__FILE__
, __LINE__
, _("invalid regnum"));
190 s390_pseudo_register_write (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
191 int regnum
, const gdb_byte
*buf
)
193 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
199 val
= extract_unsigned_integer (buf
, 4, byte_order
);
200 regcache_raw_read_unsigned (regcache
, S390_PSWA_REGNUM
, &psw
);
201 psw
= (psw
& 0x80000000) | (val
& 0x7fffffff);
202 regcache_raw_write_unsigned (regcache
, S390_PSWA_REGNUM
, psw
);
206 val
= extract_unsigned_integer (buf
, 4, byte_order
);
207 regcache_raw_read_unsigned (regcache
, S390_PSWM_REGNUM
, &psw
);
208 psw
= (psw
& ~((ULONGEST
)3 << 12)) | ((val
& 3) << 12);
209 regcache_raw_write_unsigned (regcache
, S390_PSWM_REGNUM
, psw
);
213 internal_error (__FILE__
, __LINE__
, _("invalid regnum"));
218 s390x_pseudo_register_read (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
219 int regnum
, gdb_byte
*buf
)
221 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
227 regcache_raw_read (regcache
, S390_PSWA_REGNUM
, buf
);
231 regcache_raw_read_unsigned (regcache
, S390_PSWM_REGNUM
, &val
);
232 store_unsigned_integer (buf
, 4, byte_order
, (val
>> 44) & 3);
236 internal_error (__FILE__
, __LINE__
, _("invalid regnum"));
241 s390x_pseudo_register_write (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
242 int regnum
, const gdb_byte
*buf
)
244 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
250 regcache_raw_write (regcache
, S390_PSWA_REGNUM
, buf
);
254 val
= extract_unsigned_integer (buf
, 4, byte_order
);
255 regcache_raw_read_unsigned (regcache
, S390_PSWM_REGNUM
, &psw
);
256 psw
= (psw
& ~((ULONGEST
)3 << 44)) | ((val
& 3) << 44);
257 regcache_raw_write_unsigned (regcache
, S390_PSWM_REGNUM
, psw
);
261 internal_error (__FILE__
, __LINE__
, _("invalid regnum"));
265 /* 'float' values are stored in the upper half of floating-point
266 registers, even though we are otherwise a big-endian platform. */
268 static struct value
*
269 s390_value_from_register (struct type
*type
, int regnum
,
270 struct frame_info
*frame
)
272 struct value
*value
= default_value_from_register (type
, regnum
, frame
);
273 int len
= TYPE_LENGTH (type
);
275 if (regnum
>= S390_F0_REGNUM
&& regnum
<= S390_F15_REGNUM
&& len
< 8)
276 set_value_offset (value
, 0);
281 /* Register groups. */
284 s390_register_reggroup_p (struct gdbarch
*gdbarch
, int regnum
,
285 struct reggroup
*group
)
287 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
289 /* Registers displayed via 'info regs'. */
290 if (group
== general_reggroup
)
291 return (regnum
>= S390_R0_REGNUM
&& regnum
<= S390_R15_REGNUM
)
292 || regnum
== S390_PC_REGNUM
293 || regnum
== S390_CC_REGNUM
;
295 /* Registers displayed via 'info float'. */
296 if (group
== float_reggroup
)
297 return (regnum
>= S390_F0_REGNUM
&& regnum
<= S390_F15_REGNUM
)
298 || regnum
== S390_FPC_REGNUM
;
300 /* Registers that need to be saved/restored in order to
301 push or pop frames. */
302 if (group
== save_reggroup
|| group
== restore_reggroup
)
303 return regnum
!= S390_PSWM_REGNUM
&& regnum
!= S390_PSWA_REGNUM
;
305 return default_register_reggroup_p (gdbarch
, regnum
, group
);
309 /* Core file register sets. */
311 int s390_regmap_gregset
[S390_NUM_REGS
] =
313 /* Program Status Word. */
315 /* General Purpose Registers. */
316 0x08, 0x0c, 0x10, 0x14,
317 0x18, 0x1c, 0x20, 0x24,
318 0x28, 0x2c, 0x30, 0x34,
319 0x38, 0x3c, 0x40, 0x44,
320 /* Access Registers. */
321 0x48, 0x4c, 0x50, 0x54,
322 0x58, 0x5c, 0x60, 0x64,
323 0x68, 0x6c, 0x70, 0x74,
324 0x78, 0x7c, 0x80, 0x84,
325 /* Floating Point Control Word. */
327 /* Floating Point Registers. */
328 -1, -1, -1, -1, -1, -1, -1, -1,
329 -1, -1, -1, -1, -1, -1, -1, -1,
332 int s390x_regmap_gregset
[S390_NUM_REGS
] =
335 /* General Purpose Registers. */
336 0x10, 0x18, 0x20, 0x28,
337 0x30, 0x38, 0x40, 0x48,
338 0x50, 0x58, 0x60, 0x68,
339 0x70, 0x78, 0x80, 0x88,
340 /* Access Registers. */
341 0x90, 0x94, 0x98, 0x9c,
342 0xa0, 0xa4, 0xa8, 0xac,
343 0xb0, 0xb4, 0xb8, 0xbc,
344 0xc0, 0xc4, 0xc8, 0xcc,
345 /* Floating Point Control Word. */
347 /* Floating Point Registers. */
348 -1, -1, -1, -1, -1, -1, -1, -1,
349 -1, -1, -1, -1, -1, -1, -1, -1,
352 int s390_regmap_fpregset
[S390_NUM_REGS
] =
354 /* Program Status Word. */
356 /* General Purpose Registers. */
357 -1, -1, -1, -1, -1, -1, -1, -1,
358 -1, -1, -1, -1, -1, -1, -1, -1,
359 /* Access Registers. */
360 -1, -1, -1, -1, -1, -1, -1, -1,
361 -1, -1, -1, -1, -1, -1, -1, -1,
362 /* Floating Point Control Word. */
364 /* Floating Point Registers. */
365 0x08, 0x10, 0x18, 0x20,
366 0x28, 0x30, 0x38, 0x40,
367 0x48, 0x50, 0x58, 0x60,
368 0x68, 0x70, 0x78, 0x80,
371 /* Supply register REGNUM from the register set REGSET to register cache
372 REGCACHE. If REGNUM is -1, do this for all registers in REGSET. */
374 s390_supply_regset (const struct regset
*regset
, struct regcache
*regcache
,
375 int regnum
, const void *regs
, size_t len
)
377 const int *offset
= regset
->descr
;
380 for (i
= 0; i
< S390_NUM_REGS
; i
++)
382 if ((regnum
== i
|| regnum
== -1) && offset
[i
] != -1)
383 regcache_raw_supply (regcache
, i
, (const char *)regs
+ offset
[i
]);
387 /* Collect register REGNUM from the register cache REGCACHE and store
388 it in the buffer specified by REGS and LEN as described by the
389 general-purpose register set REGSET. If REGNUM is -1, do this for
390 all registers in REGSET. */
392 s390_collect_regset (const struct regset
*regset
,
393 const struct regcache
*regcache
,
394 int regnum
, void *regs
, size_t len
)
396 const int *offset
= regset
->descr
;
399 for (i
= 0; i
< S390_NUM_REGS
; i
++)
401 if ((regnum
== i
|| regnum
== -1) && offset
[i
] != -1)
402 regcache_raw_collect (regcache
, i
, (char *)regs
+ offset
[i
]);
406 static const struct regset s390_gregset
= {
412 static const struct regset s390x_gregset
= {
413 s390x_regmap_gregset
,
418 static const struct regset s390_fpregset
= {
419 s390_regmap_fpregset
,
424 /* Return the appropriate register set for the core section identified
425 by SECT_NAME and SECT_SIZE. */
426 static const struct regset
*
427 s390_regset_from_core_section (struct gdbarch
*gdbarch
,
428 const char *sect_name
, size_t sect_size
)
430 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
432 if (strcmp (sect_name
, ".reg") == 0 && sect_size
>= tdep
->sizeof_gregset
)
433 return tdep
->gregset
;
435 if (strcmp (sect_name
, ".reg2") == 0 && sect_size
>= tdep
->sizeof_fpregset
)
436 return tdep
->fpregset
;
442 /* Decoding S/390 instructions. */
444 /* Named opcode values for the S/390 instructions we recognize. Some
445 instructions have their opcode split across two fields; those are the
446 op1_* and op2_* enums. */
449 op1_lhi
= 0xa7, op2_lhi
= 0x08,
450 op1_lghi
= 0xa7, op2_lghi
= 0x09,
451 op1_lgfi
= 0xc0, op2_lgfi
= 0x01,
455 op1_ly
= 0xe3, op2_ly
= 0x58,
456 op1_lg
= 0xe3, op2_lg
= 0x04,
458 op1_lmy
= 0xeb, op2_lmy
= 0x98,
459 op1_lmg
= 0xeb, op2_lmg
= 0x04,
461 op1_sty
= 0xe3, op2_sty
= 0x50,
462 op1_stg
= 0xe3, op2_stg
= 0x24,
465 op1_stmy
= 0xeb, op2_stmy
= 0x90,
466 op1_stmg
= 0xeb, op2_stmg
= 0x24,
467 op1_aghi
= 0xa7, op2_aghi
= 0x0b,
468 op1_ahi
= 0xa7, op2_ahi
= 0x0a,
469 op1_agfi
= 0xc2, op2_agfi
= 0x08,
470 op1_afi
= 0xc2, op2_afi
= 0x09,
471 op1_algfi
= 0xc2, op2_algfi
= 0x0a,
472 op1_alfi
= 0xc2, op2_alfi
= 0x0b,
476 op1_ay
= 0xe3, op2_ay
= 0x5a,
477 op1_ag
= 0xe3, op2_ag
= 0x08,
478 op1_slgfi
= 0xc2, op2_slgfi
= 0x04,
479 op1_slfi
= 0xc2, op2_slfi
= 0x05,
483 op1_sy
= 0xe3, op2_sy
= 0x5b,
484 op1_sg
= 0xe3, op2_sg
= 0x09,
488 op1_lay
= 0xe3, op2_lay
= 0x71,
489 op1_larl
= 0xc0, op2_larl
= 0x00,
494 op1_bras
= 0xa7, op2_bras
= 0x05,
495 op1_brasl
= 0xc0, op2_brasl
= 0x05,
496 op1_brc
= 0xa7, op2_brc
= 0x04,
497 op1_brcl
= 0xc0, op2_brcl
= 0x04,
501 /* Read a single instruction from address AT. */
503 #define S390_MAX_INSTR_SIZE 6
505 s390_readinstruction (bfd_byte instr
[], CORE_ADDR at
)
507 static int s390_instrlen
[] = { 2, 4, 4, 6 };
510 if (target_read_memory (at
, &instr
[0], 2))
512 instrlen
= s390_instrlen
[instr
[0] >> 6];
515 if (target_read_memory (at
+ 2, &instr
[2], instrlen
- 2))
522 /* The functions below are for recognizing and decoding S/390
523 instructions of various formats. Each of them checks whether INSN
524 is an instruction of the given format, with the specified opcodes.
525 If it is, it sets the remaining arguments to the values of the
526 instruction's fields, and returns a non-zero value; otherwise, it
529 These functions' arguments appear in the order they appear in the
530 instruction, not in the machine-language form. So, opcodes always
531 come first, even though they're sometimes scattered around the
532 instructions. And displacements appear before base and extension
533 registers, as they do in the assembly syntax, not at the end, as
534 they do in the machine language. */
536 is_ri (bfd_byte
*insn
, int op1
, int op2
, unsigned int *r1
, int *i2
)
538 if (insn
[0] == op1
&& (insn
[1] & 0xf) == op2
)
540 *r1
= (insn
[1] >> 4) & 0xf;
541 /* i2 is a 16-bit signed quantity. */
542 *i2
= (((insn
[2] << 8) | insn
[3]) ^ 0x8000) - 0x8000;
551 is_ril (bfd_byte
*insn
, int op1
, int op2
,
552 unsigned int *r1
, int *i2
)
554 if (insn
[0] == op1
&& (insn
[1] & 0xf) == op2
)
556 *r1
= (insn
[1] >> 4) & 0xf;
557 /* i2 is a signed quantity. If the host 'int' is 32 bits long,
558 no sign extension is necessary, but we don't want to assume
560 *i2
= (((insn
[2] << 24)
563 | (insn
[5])) ^ 0x80000000) - 0x80000000;
572 is_rr (bfd_byte
*insn
, int op
, unsigned int *r1
, unsigned int *r2
)
576 *r1
= (insn
[1] >> 4) & 0xf;
586 is_rre (bfd_byte
*insn
, int op
, unsigned int *r1
, unsigned int *r2
)
588 if (((insn
[0] << 8) | insn
[1]) == op
)
590 /* Yes, insn[3]. insn[2] is unused in RRE format. */
591 *r1
= (insn
[3] >> 4) & 0xf;
601 is_rs (bfd_byte
*insn
, int op
,
602 unsigned int *r1
, unsigned int *r3
, unsigned int *d2
, unsigned int *b2
)
606 *r1
= (insn
[1] >> 4) & 0xf;
608 *b2
= (insn
[2] >> 4) & 0xf;
609 *d2
= ((insn
[2] & 0xf) << 8) | insn
[3];
618 is_rsy (bfd_byte
*insn
, int op1
, int op2
,
619 unsigned int *r1
, unsigned int *r3
, unsigned int *d2
, unsigned int *b2
)
624 *r1
= (insn
[1] >> 4) & 0xf;
626 *b2
= (insn
[2] >> 4) & 0xf;
627 /* The 'long displacement' is a 20-bit signed integer. */
628 *d2
= ((((insn
[2] & 0xf) << 8) | insn
[3] | (insn
[4] << 12))
629 ^ 0x80000) - 0x80000;
638 is_rx (bfd_byte
*insn
, int op
,
639 unsigned int *r1
, unsigned int *d2
, unsigned int *x2
, unsigned int *b2
)
643 *r1
= (insn
[1] >> 4) & 0xf;
645 *b2
= (insn
[2] >> 4) & 0xf;
646 *d2
= ((insn
[2] & 0xf) << 8) | insn
[3];
655 is_rxy (bfd_byte
*insn
, int op1
, int op2
,
656 unsigned int *r1
, unsigned int *d2
, unsigned int *x2
, unsigned int *b2
)
661 *r1
= (insn
[1] >> 4) & 0xf;
663 *b2
= (insn
[2] >> 4) & 0xf;
664 /* The 'long displacement' is a 20-bit signed integer. */
665 *d2
= ((((insn
[2] & 0xf) << 8) | insn
[3] | (insn
[4] << 12))
666 ^ 0x80000) - 0x80000;
674 /* Prologue analysis. */
676 #define S390_NUM_GPRS 16
677 #define S390_NUM_FPRS 16
679 struct s390_prologue_data
{
682 struct pv_area
*stack
;
684 /* The size and byte-order of a GPR or FPR. */
687 enum bfd_endian byte_order
;
689 /* The general-purpose registers. */
690 pv_t gpr
[S390_NUM_GPRS
];
692 /* The floating-point registers. */
693 pv_t fpr
[S390_NUM_FPRS
];
695 /* The offset relative to the CFA where the incoming GPR N was saved
696 by the function prologue. 0 if not saved or unknown. */
697 int gpr_slot
[S390_NUM_GPRS
];
699 /* Likewise for FPRs. */
700 int fpr_slot
[S390_NUM_FPRS
];
702 /* Nonzero if the backchain was saved. This is assumed to be the
703 case when the incoming SP is saved at the current SP location. */
704 int back_chain_saved_p
;
707 /* Return the effective address for an X-style instruction, like:
711 Here, X2 and B2 are registers, and D2 is a signed 20-bit
712 constant; the effective address is the sum of all three. If either
713 X2 or B2 are zero, then it doesn't contribute to the sum --- this
714 means that r0 can't be used as either X2 or B2. */
716 s390_addr (struct s390_prologue_data
*data
,
717 int d2
, unsigned int x2
, unsigned int b2
)
721 result
= pv_constant (d2
);
723 result
= pv_add (result
, data
->gpr
[x2
]);
725 result
= pv_add (result
, data
->gpr
[b2
]);
730 /* Do a SIZE-byte store of VALUE to D2(X2,B2). */
732 s390_store (struct s390_prologue_data
*data
,
733 int d2
, unsigned int x2
, unsigned int b2
, CORE_ADDR size
,
736 pv_t addr
= s390_addr (data
, d2
, x2
, b2
);
739 /* Check whether we are storing the backchain. */
740 offset
= pv_subtract (data
->gpr
[S390_SP_REGNUM
- S390_R0_REGNUM
], addr
);
742 if (pv_is_constant (offset
) && offset
.k
== 0)
743 if (size
== data
->gpr_size
744 && pv_is_register_k (value
, S390_SP_REGNUM
, 0))
746 data
->back_chain_saved_p
= 1;
751 /* Check whether we are storing a register into the stack. */
752 if (!pv_area_store_would_trash (data
->stack
, addr
))
753 pv_area_store (data
->stack
, addr
, size
, value
);
756 /* Note: If this is some store we cannot identify, you might think we
757 should forget our cached values, as any of those might have been hit.
759 However, we make the assumption that the register save areas are only
760 ever stored to once in any given function, and we do recognize these
761 stores. Thus every store we cannot recognize does not hit our data. */
764 /* Do a SIZE-byte load from D2(X2,B2). */
766 s390_load (struct s390_prologue_data
*data
,
767 int d2
, unsigned int x2
, unsigned int b2
, CORE_ADDR size
)
770 pv_t addr
= s390_addr (data
, d2
, x2
, b2
);
773 /* If it's a load from an in-line constant pool, then we can
774 simulate that, under the assumption that the code isn't
775 going to change between the time the processor actually
776 executed it creating the current frame, and the time when
777 we're analyzing the code to unwind past that frame. */
778 if (pv_is_constant (addr
))
780 struct target_section
*secp
;
781 secp
= target_section_by_addr (¤t_target
, addr
.k
);
783 && (bfd_get_section_flags (secp
->bfd
, secp
->the_bfd_section
)
785 return pv_constant (read_memory_integer (addr
.k
, size
,
789 /* Check whether we are accessing one of our save slots. */
790 return pv_area_fetch (data
->stack
, addr
, size
);
793 /* Function for finding saved registers in a 'struct pv_area'; we pass
794 this to pv_area_scan.
796 If VALUE is a saved register, ADDR says it was saved at a constant
797 offset from the frame base, and SIZE indicates that the whole
798 register was saved, record its offset in the reg_offset table in
801 s390_check_for_saved (void *data_untyped
, pv_t addr
, CORE_ADDR size
, pv_t value
)
803 struct s390_prologue_data
*data
= data_untyped
;
806 if (!pv_is_register (addr
, S390_SP_REGNUM
))
809 offset
= 16 * data
->gpr_size
+ 32 - addr
.k
;
811 /* If we are storing the original value of a register, we want to
812 record the CFA offset. If the same register is stored multiple
813 times, the stack slot with the highest address counts. */
815 for (i
= 0; i
< S390_NUM_GPRS
; i
++)
816 if (size
== data
->gpr_size
817 && pv_is_register_k (value
, S390_R0_REGNUM
+ i
, 0))
818 if (data
->gpr_slot
[i
] == 0
819 || data
->gpr_slot
[i
] > offset
)
821 data
->gpr_slot
[i
] = offset
;
825 for (i
= 0; i
< S390_NUM_FPRS
; i
++)
826 if (size
== data
->fpr_size
827 && pv_is_register_k (value
, S390_F0_REGNUM
+ i
, 0))
828 if (data
->fpr_slot
[i
] == 0
829 || data
->fpr_slot
[i
] > offset
)
831 data
->fpr_slot
[i
] = offset
;
836 /* Analyze the prologue of the function starting at START_PC,
837 continuing at most until CURRENT_PC. Initialize DATA to
838 hold all information we find out about the state of the registers
839 and stack slots. Return the address of the instruction after
840 the last one that changed the SP, FP, or back chain; or zero
843 s390_analyze_prologue (struct gdbarch
*gdbarch
,
845 CORE_ADDR current_pc
,
846 struct s390_prologue_data
*data
)
848 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
851 The address of the instruction after the last one that changed
852 the SP, FP, or back chain; zero if we got an error trying to
854 CORE_ADDR result
= start_pc
;
856 /* The current PC for our abstract interpretation. */
859 /* The address of the next instruction after that. */
862 /* Set up everything's initial value. */
866 data
->stack
= make_pv_area (S390_SP_REGNUM
, gdbarch_addr_bit (gdbarch
));
868 /* For the purpose of prologue tracking, we consider the GPR size to
869 be equal to the ABI word size, even if it is actually larger
870 (i.e. when running a 32-bit binary under a 64-bit kernel). */
871 data
->gpr_size
= word_size
;
873 data
->byte_order
= gdbarch_byte_order (gdbarch
);
875 for (i
= 0; i
< S390_NUM_GPRS
; i
++)
876 data
->gpr
[i
] = pv_register (S390_R0_REGNUM
+ i
, 0);
878 for (i
= 0; i
< S390_NUM_FPRS
; i
++)
879 data
->fpr
[i
] = pv_register (S390_F0_REGNUM
+ i
, 0);
881 for (i
= 0; i
< S390_NUM_GPRS
; i
++)
882 data
->gpr_slot
[i
] = 0;
884 for (i
= 0; i
< S390_NUM_FPRS
; i
++)
885 data
->fpr_slot
[i
] = 0;
887 data
->back_chain_saved_p
= 0;
890 /* Start interpreting instructions, until we hit the frame's
891 current PC or the first branch instruction. */
892 for (pc
= start_pc
; pc
> 0 && pc
< current_pc
; pc
= next_pc
)
894 bfd_byte insn
[S390_MAX_INSTR_SIZE
];
895 int insn_len
= s390_readinstruction (insn
, pc
);
897 bfd_byte dummy
[S390_MAX_INSTR_SIZE
] = { 0 };
898 bfd_byte
*insn32
= word_size
== 4 ? insn
: dummy
;
899 bfd_byte
*insn64
= word_size
== 8 ? insn
: dummy
;
901 /* Fields for various kinds of instructions. */
902 unsigned int b2
, r1
, r2
, x2
, r3
;
905 /* The values of SP and FP before this instruction,
906 for detecting instructions that change them. */
907 pv_t pre_insn_sp
, pre_insn_fp
;
908 /* Likewise for the flag whether the back chain was saved. */
909 int pre_insn_back_chain_saved_p
;
911 /* If we got an error trying to read the instruction, report it. */
918 next_pc
= pc
+ insn_len
;
920 pre_insn_sp
= data
->gpr
[S390_SP_REGNUM
- S390_R0_REGNUM
];
921 pre_insn_fp
= data
->gpr
[S390_FRAME_REGNUM
- S390_R0_REGNUM
];
922 pre_insn_back_chain_saved_p
= data
->back_chain_saved_p
;
925 /* LHI r1, i2 --- load halfword immediate. */
926 /* LGHI r1, i2 --- load halfword immediate (64-bit version). */
927 /* LGFI r1, i2 --- load fullword immediate. */
928 if (is_ri (insn32
, op1_lhi
, op2_lhi
, &r1
, &i2
)
929 || is_ri (insn64
, op1_lghi
, op2_lghi
, &r1
, &i2
)
930 || is_ril (insn
, op1_lgfi
, op2_lgfi
, &r1
, &i2
))
931 data
->gpr
[r1
] = pv_constant (i2
);
933 /* LR r1, r2 --- load from register. */
934 /* LGR r1, r2 --- load from register (64-bit version). */
935 else if (is_rr (insn32
, op_lr
, &r1
, &r2
)
936 || is_rre (insn64
, op_lgr
, &r1
, &r2
))
937 data
->gpr
[r1
] = data
->gpr
[r2
];
939 /* L r1, d2(x2, b2) --- load. */
940 /* LY r1, d2(x2, b2) --- load (long-displacement version). */
941 /* LG r1, d2(x2, b2) --- load (64-bit version). */
942 else if (is_rx (insn32
, op_l
, &r1
, &d2
, &x2
, &b2
)
943 || is_rxy (insn32
, op1_ly
, op2_ly
, &r1
, &d2
, &x2
, &b2
)
944 || is_rxy (insn64
, op1_lg
, op2_lg
, &r1
, &d2
, &x2
, &b2
))
945 data
->gpr
[r1
] = s390_load (data
, d2
, x2
, b2
, data
->gpr_size
);
947 /* ST r1, d2(x2, b2) --- store. */
948 /* STY r1, d2(x2, b2) --- store (long-displacement version). */
949 /* STG r1, d2(x2, b2) --- store (64-bit version). */
950 else if (is_rx (insn32
, op_st
, &r1
, &d2
, &x2
, &b2
)
951 || is_rxy (insn32
, op1_sty
, op2_sty
, &r1
, &d2
, &x2
, &b2
)
952 || is_rxy (insn64
, op1_stg
, op2_stg
, &r1
, &d2
, &x2
, &b2
))
953 s390_store (data
, d2
, x2
, b2
, data
->gpr_size
, data
->gpr
[r1
]);
955 /* STD r1, d2(x2,b2) --- store floating-point register. */
956 else if (is_rx (insn
, op_std
, &r1
, &d2
, &x2
, &b2
))
957 s390_store (data
, d2
, x2
, b2
, data
->fpr_size
, data
->fpr
[r1
]);
959 /* STM r1, r3, d2(b2) --- store multiple. */
960 /* STMY r1, r3, d2(b2) --- store multiple (long-displacement version). */
961 /* STMG r1, r3, d2(b2) --- store multiple (64-bit version). */
962 else if (is_rs (insn32
, op_stm
, &r1
, &r3
, &d2
, &b2
)
963 || is_rsy (insn32
, op1_stmy
, op2_stmy
, &r1
, &r3
, &d2
, &b2
)
964 || is_rsy (insn64
, op1_stmg
, op2_stmg
, &r1
, &r3
, &d2
, &b2
))
966 for (; r1
<= r3
; r1
++, d2
+= data
->gpr_size
)
967 s390_store (data
, d2
, 0, b2
, data
->gpr_size
, data
->gpr
[r1
]);
970 /* AHI r1, i2 --- add halfword immediate. */
971 /* AGHI r1, i2 --- add halfword immediate (64-bit version). */
972 /* AFI r1, i2 --- add fullword immediate. */
973 /* AGFI r1, i2 --- add fullword immediate (64-bit version). */
974 else if (is_ri (insn32
, op1_ahi
, op2_ahi
, &r1
, &i2
)
975 || is_ri (insn64
, op1_aghi
, op2_aghi
, &r1
, &i2
)
976 || is_ril (insn32
, op1_afi
, op2_afi
, &r1
, &i2
)
977 || is_ril (insn64
, op1_agfi
, op2_agfi
, &r1
, &i2
))
978 data
->gpr
[r1
] = pv_add_constant (data
->gpr
[r1
], i2
);
980 /* ALFI r1, i2 --- add logical immediate. */
981 /* ALGFI r1, i2 --- add logical immediate (64-bit version). */
982 else if (is_ril (insn32
, op1_alfi
, op2_alfi
, &r1
, &i2
)
983 || is_ril (insn64
, op1_algfi
, op2_algfi
, &r1
, &i2
))
984 data
->gpr
[r1
] = pv_add_constant (data
->gpr
[r1
],
985 (CORE_ADDR
)i2
& 0xffffffff);
987 /* AR r1, r2 -- add register. */
988 /* AGR r1, r2 -- add register (64-bit version). */
989 else if (is_rr (insn32
, op_ar
, &r1
, &r2
)
990 || is_rre (insn64
, op_agr
, &r1
, &r2
))
991 data
->gpr
[r1
] = pv_add (data
->gpr
[r1
], data
->gpr
[r2
]);
993 /* A r1, d2(x2, b2) -- add. */
994 /* AY r1, d2(x2, b2) -- add (long-displacement version). */
995 /* AG r1, d2(x2, b2) -- add (64-bit version). */
996 else if (is_rx (insn32
, op_a
, &r1
, &d2
, &x2
, &b2
)
997 || is_rxy (insn32
, op1_ay
, op2_ay
, &r1
, &d2
, &x2
, &b2
)
998 || is_rxy (insn64
, op1_ag
, op2_ag
, &r1
, &d2
, &x2
, &b2
))
999 data
->gpr
[r1
] = pv_add (data
->gpr
[r1
],
1000 s390_load (data
, d2
, x2
, b2
, data
->gpr_size
));
1002 /* SLFI r1, i2 --- subtract logical immediate. */
1003 /* SLGFI r1, i2 --- subtract logical immediate (64-bit version). */
1004 else if (is_ril (insn32
, op1_slfi
, op2_slfi
, &r1
, &i2
)
1005 || is_ril (insn64
, op1_slgfi
, op2_slgfi
, &r1
, &i2
))
1006 data
->gpr
[r1
] = pv_add_constant (data
->gpr
[r1
],
1007 -((CORE_ADDR
)i2
& 0xffffffff));
1009 /* SR r1, r2 -- subtract register. */
1010 /* SGR r1, r2 -- subtract register (64-bit version). */
1011 else if (is_rr (insn32
, op_sr
, &r1
, &r2
)
1012 || is_rre (insn64
, op_sgr
, &r1
, &r2
))
1013 data
->gpr
[r1
] = pv_subtract (data
->gpr
[r1
], data
->gpr
[r2
]);
1015 /* S r1, d2(x2, b2) -- subtract. */
1016 /* SY r1, d2(x2, b2) -- subtract (long-displacement version). */
1017 /* SG r1, d2(x2, b2) -- subtract (64-bit version). */
1018 else if (is_rx (insn32
, op_s
, &r1
, &d2
, &x2
, &b2
)
1019 || is_rxy (insn32
, op1_sy
, op2_sy
, &r1
, &d2
, &x2
, &b2
)
1020 || is_rxy (insn64
, op1_sg
, op2_sg
, &r1
, &d2
, &x2
, &b2
))
1021 data
->gpr
[r1
] = pv_subtract (data
->gpr
[r1
],
1022 s390_load (data
, d2
, x2
, b2
, data
->gpr_size
));
1024 /* LA r1, d2(x2, b2) --- load address. */
1025 /* LAY r1, d2(x2, b2) --- load address (long-displacement version). */
1026 else if (is_rx (insn
, op_la
, &r1
, &d2
, &x2
, &b2
)
1027 || is_rxy (insn
, op1_lay
, op2_lay
, &r1
, &d2
, &x2
, &b2
))
1028 data
->gpr
[r1
] = s390_addr (data
, d2
, x2
, b2
);
1030 /* LARL r1, i2 --- load address relative long. */
1031 else if (is_ril (insn
, op1_larl
, op2_larl
, &r1
, &i2
))
1032 data
->gpr
[r1
] = pv_constant (pc
+ i2
* 2);
1034 /* BASR r1, 0 --- branch and save.
1035 Since r2 is zero, this saves the PC in r1, but doesn't branch. */
1036 else if (is_rr (insn
, op_basr
, &r1
, &r2
)
1038 data
->gpr
[r1
] = pv_constant (next_pc
);
1040 /* BRAS r1, i2 --- branch relative and save. */
1041 else if (is_ri (insn
, op1_bras
, op2_bras
, &r1
, &i2
))
1043 data
->gpr
[r1
] = pv_constant (next_pc
);
1044 next_pc
= pc
+ i2
* 2;
1046 /* We'd better not interpret any backward branches. We'll
1052 /* Terminate search when hitting any other branch instruction. */
1053 else if (is_rr (insn
, op_basr
, &r1
, &r2
)
1054 || is_rx (insn
, op_bas
, &r1
, &d2
, &x2
, &b2
)
1055 || is_rr (insn
, op_bcr
, &r1
, &r2
)
1056 || is_rx (insn
, op_bc
, &r1
, &d2
, &x2
, &b2
)
1057 || is_ri (insn
, op1_brc
, op2_brc
, &r1
, &i2
)
1058 || is_ril (insn
, op1_brcl
, op2_brcl
, &r1
, &i2
)
1059 || is_ril (insn
, op1_brasl
, op2_brasl
, &r2
, &i2
))
1063 /* An instruction we don't know how to simulate. The only
1064 safe thing to do would be to set every value we're tracking
1065 to 'unknown'. Instead, we'll be optimistic: we assume that
1066 we *can* interpret every instruction that the compiler uses
1067 to manipulate any of the data we're interested in here --
1068 then we can just ignore anything else. */
1071 /* Record the address after the last instruction that changed
1072 the FP, SP, or backlink. Ignore instructions that changed
1073 them back to their original values --- those are probably
1074 restore instructions. (The back chain is never restored,
1077 pv_t sp
= data
->gpr
[S390_SP_REGNUM
- S390_R0_REGNUM
];
1078 pv_t fp
= data
->gpr
[S390_FRAME_REGNUM
- S390_R0_REGNUM
];
1080 if ((! pv_is_identical (pre_insn_sp
, sp
)
1081 && ! pv_is_register_k (sp
, S390_SP_REGNUM
, 0)
1082 && sp
.kind
!= pvk_unknown
)
1083 || (! pv_is_identical (pre_insn_fp
, fp
)
1084 && ! pv_is_register_k (fp
, S390_FRAME_REGNUM
, 0)
1085 && fp
.kind
!= pvk_unknown
)
1086 || pre_insn_back_chain_saved_p
!= data
->back_chain_saved_p
)
1091 /* Record where all the registers were saved. */
1092 pv_area_scan (data
->stack
, s390_check_for_saved
, data
);
1094 free_pv_area (data
->stack
);
1100 /* Advance PC across any function entry prologue instructions to reach
1101 some "real" code. */
1103 s390_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
1105 struct s390_prologue_data data
;
1107 skip_pc
= s390_analyze_prologue (gdbarch
, pc
, (CORE_ADDR
)-1, &data
);
1108 return skip_pc
? skip_pc
: pc
;
1111 /* Return true if we are in the functin's epilogue, i.e. after the
1112 instruction that destroyed the function's stack frame. */
1114 s390_in_function_epilogue_p (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
1116 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
1118 /* In frameless functions, there's not frame to destroy and thus
1119 we don't care about the epilogue.
1121 In functions with frame, the epilogue sequence is a pair of
1122 a LM-type instruction that restores (amongst others) the
1123 return register %r14 and the stack pointer %r15, followed
1124 by a branch 'br %r14' --or equivalent-- that effects the
1127 In that situation, this function needs to return 'true' in
1128 exactly one case: when pc points to that branch instruction.
1130 Thus we try to disassemble the one instructions immediately
1131 preceeding pc and check whether it is an LM-type instruction
1132 modifying the stack pointer.
1134 Note that disassembling backwards is not reliable, so there
1135 is a slight chance of false positives here ... */
1138 unsigned int r1
, r3
, b2
;
1142 && !target_read_memory (pc
- 4, insn
, 4)
1143 && is_rs (insn
, op_lm
, &r1
, &r3
, &d2
, &b2
)
1144 && r3
== S390_SP_REGNUM
- S390_R0_REGNUM
)
1148 && !target_read_memory (pc
- 6, insn
, 6)
1149 && is_rsy (insn
, op1_lmy
, op2_lmy
, &r1
, &r3
, &d2
, &b2
)
1150 && r3
== S390_SP_REGNUM
- S390_R0_REGNUM
)
1154 && !target_read_memory (pc
- 6, insn
, 6)
1155 && is_rsy (insn
, op1_lmg
, op2_lmg
, &r1
, &r3
, &d2
, &b2
)
1156 && r3
== S390_SP_REGNUM
- S390_R0_REGNUM
)
1163 /* Normal stack frames. */
1165 struct s390_unwind_cache
{
1168 CORE_ADDR frame_base
;
1169 CORE_ADDR local_base
;
1171 struct trad_frame_saved_reg
*saved_regs
;
1175 s390_prologue_frame_unwind_cache (struct frame_info
*this_frame
,
1176 struct s390_unwind_cache
*info
)
1178 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1179 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1180 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
1181 struct s390_prologue_data data
;
1182 pv_t
*fp
= &data
.gpr
[S390_FRAME_REGNUM
- S390_R0_REGNUM
];
1183 pv_t
*sp
= &data
.gpr
[S390_SP_REGNUM
- S390_R0_REGNUM
];
1192 struct frame_info
*next_frame
;
1194 /* Try to find the function start address. If we can't find it, we don't
1195 bother searching for it -- with modern compilers this would be mostly
1196 pointless anyway. Trust that we'll either have valid DWARF-2 CFI data
1197 or else a valid backchain ... */
1198 func
= get_frame_func (this_frame
);
1202 /* Try to analyze the prologue. */
1203 result
= s390_analyze_prologue (gdbarch
, func
,
1204 get_frame_pc (this_frame
), &data
);
1208 /* If this was successful, we should have found the instruction that
1209 sets the stack pointer register to the previous value of the stack
1210 pointer minus the frame size. */
1211 if (!pv_is_register (*sp
, S390_SP_REGNUM
))
1214 /* A frame size of zero at this point can mean either a real
1215 frameless function, or else a failure to find the prologue.
1216 Perform some sanity checks to verify we really have a
1217 frameless function. */
1220 /* If the next frame is a NORMAL_FRAME, this frame *cannot* have frame
1221 size zero. This is only possible if the next frame is a sentinel
1222 frame, a dummy frame, or a signal trampoline frame. */
1223 /* FIXME: cagney/2004-05-01: This sanity check shouldn't be
1224 needed, instead the code should simpliy rely on its
1226 next_frame
= get_next_frame (this_frame
);
1227 while (next_frame
&& get_frame_type (next_frame
) == INLINE_FRAME
)
1228 next_frame
= get_next_frame (next_frame
);
1230 && get_frame_type (get_next_frame (this_frame
)) == NORMAL_FRAME
)
1233 /* If we really have a frameless function, %r14 must be valid
1234 -- in particular, it must point to a different function. */
1235 reg
= get_frame_register_unsigned (this_frame
, S390_RETADDR_REGNUM
);
1236 reg
= gdbarch_addr_bits_remove (gdbarch
, reg
) - 1;
1237 if (get_pc_function_start (reg
) == func
)
1239 /* However, there is one case where it *is* valid for %r14
1240 to point to the same function -- if this is a recursive
1241 call, and we have stopped in the prologue *before* the
1242 stack frame was allocated.
1244 Recognize this case by looking ahead a bit ... */
1246 struct s390_prologue_data data2
;
1247 pv_t
*sp
= &data2
.gpr
[S390_SP_REGNUM
- S390_R0_REGNUM
];
1249 if (!(s390_analyze_prologue (gdbarch
, func
, (CORE_ADDR
)-1, &data2
)
1250 && pv_is_register (*sp
, S390_SP_REGNUM
)
1257 /* OK, we've found valid prologue data. */
1260 /* If the frame pointer originally also holds the same value
1261 as the stack pointer, we're probably using it. If it holds
1262 some other value -- even a constant offset -- it is most
1263 likely used as temp register. */
1264 if (pv_is_identical (*sp
, *fp
))
1265 frame_pointer
= S390_FRAME_REGNUM
;
1267 frame_pointer
= S390_SP_REGNUM
;
1269 /* If we've detected a function with stack frame, we'll still have to
1270 treat it as frameless if we're currently within the function epilog
1271 code at a point where the frame pointer has already been restored.
1272 This can only happen in an innermost frame. */
1273 /* FIXME: cagney/2004-05-01: This sanity check shouldn't be needed,
1274 instead the code should simpliy rely on its analysis. */
1275 next_frame
= get_next_frame (this_frame
);
1276 while (next_frame
&& get_frame_type (next_frame
) == INLINE_FRAME
)
1277 next_frame
= get_next_frame (next_frame
);
1279 && (next_frame
== NULL
1280 || get_frame_type (get_next_frame (this_frame
)) != NORMAL_FRAME
))
1282 /* See the comment in s390_in_function_epilogue_p on why this is
1283 not completely reliable ... */
1284 if (s390_in_function_epilogue_p (gdbarch
, get_frame_pc (this_frame
)))
1286 memset (&data
, 0, sizeof (data
));
1288 frame_pointer
= S390_SP_REGNUM
;
1292 /* Once we know the frame register and the frame size, we can unwind
1293 the current value of the frame register from the next frame, and
1294 add back the frame size to arrive that the previous frame's
1295 stack pointer value. */
1296 prev_sp
= get_frame_register_unsigned (this_frame
, frame_pointer
) + size
;
1297 cfa
= prev_sp
+ 16*word_size
+ 32;
1299 /* Record the addresses of all register spill slots the prologue parser
1300 has recognized. Consider only registers defined as call-saved by the
1301 ABI; for call-clobbered registers the parser may have recognized
1304 for (i
= 6; i
<= 15; i
++)
1305 if (data
.gpr_slot
[i
] != 0)
1306 info
->saved_regs
[S390_R0_REGNUM
+ i
].addr
= cfa
- data
.gpr_slot
[i
];
1310 case ABI_LINUX_S390
:
1311 if (data
.fpr_slot
[4] != 0)
1312 info
->saved_regs
[S390_F4_REGNUM
].addr
= cfa
- data
.fpr_slot
[4];
1313 if (data
.fpr_slot
[6] != 0)
1314 info
->saved_regs
[S390_F6_REGNUM
].addr
= cfa
- data
.fpr_slot
[6];
1317 case ABI_LINUX_ZSERIES
:
1318 for (i
= 8; i
<= 15; i
++)
1319 if (data
.fpr_slot
[i
] != 0)
1320 info
->saved_regs
[S390_F0_REGNUM
+ i
].addr
= cfa
- data
.fpr_slot
[i
];
1324 /* Function return will set PC to %r14. */
1325 info
->saved_regs
[S390_PC_REGNUM
] = info
->saved_regs
[S390_RETADDR_REGNUM
];
1327 /* In frameless functions, we unwind simply by moving the return
1328 address to the PC. However, if we actually stored to the
1329 save area, use that -- we might only think the function frameless
1330 because we're in the middle of the prologue ... */
1332 && !trad_frame_addr_p (info
->saved_regs
, S390_PC_REGNUM
))
1334 info
->saved_regs
[S390_PC_REGNUM
].realreg
= S390_RETADDR_REGNUM
;
1337 /* Another sanity check: unless this is a frameless function,
1338 we should have found spill slots for SP and PC.
1339 If not, we cannot unwind further -- this happens e.g. in
1340 libc's thread_start routine. */
1343 if (!trad_frame_addr_p (info
->saved_regs
, S390_SP_REGNUM
)
1344 || !trad_frame_addr_p (info
->saved_regs
, S390_PC_REGNUM
))
1348 /* We use the current value of the frame register as local_base,
1349 and the top of the register save area as frame_base. */
1352 info
->frame_base
= prev_sp
+ 16*word_size
+ 32;
1353 info
->local_base
= prev_sp
- size
;
1361 s390_backchain_frame_unwind_cache (struct frame_info
*this_frame
,
1362 struct s390_unwind_cache
*info
)
1364 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1365 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
1366 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1367 CORE_ADDR backchain
;
1371 /* Get the backchain. */
1372 reg
= get_frame_register_unsigned (this_frame
, S390_SP_REGNUM
);
1373 backchain
= read_memory_unsigned_integer (reg
, word_size
, byte_order
);
1375 /* A zero backchain terminates the frame chain. As additional
1376 sanity check, let's verify that the spill slot for SP in the
1377 save area pointed to by the backchain in fact links back to
1380 && safe_read_memory_integer (backchain
+ 15*word_size
,
1381 word_size
, byte_order
, &sp
)
1382 && (CORE_ADDR
)sp
== backchain
)
1384 /* We don't know which registers were saved, but it will have
1385 to be at least %r14 and %r15. This will allow us to continue
1386 unwinding, but other prev-frame registers may be incorrect ... */
1387 info
->saved_regs
[S390_SP_REGNUM
].addr
= backchain
+ 15*word_size
;
1388 info
->saved_regs
[S390_RETADDR_REGNUM
].addr
= backchain
+ 14*word_size
;
1390 /* Function return will set PC to %r14. */
1391 info
->saved_regs
[S390_PC_REGNUM
] = info
->saved_regs
[S390_RETADDR_REGNUM
];
1393 /* We use the current value of the frame register as local_base,
1394 and the top of the register save area as frame_base. */
1395 info
->frame_base
= backchain
+ 16*word_size
+ 32;
1396 info
->local_base
= reg
;
1399 info
->func
= get_frame_pc (this_frame
);
1402 static struct s390_unwind_cache
*
1403 s390_frame_unwind_cache (struct frame_info
*this_frame
,
1404 void **this_prologue_cache
)
1406 struct s390_unwind_cache
*info
;
1407 if (*this_prologue_cache
)
1408 return *this_prologue_cache
;
1410 info
= FRAME_OBSTACK_ZALLOC (struct s390_unwind_cache
);
1411 *this_prologue_cache
= info
;
1412 info
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
1414 info
->frame_base
= -1;
1415 info
->local_base
= -1;
1417 /* Try to use prologue analysis to fill the unwind cache.
1418 If this fails, fall back to reading the stack backchain. */
1419 if (!s390_prologue_frame_unwind_cache (this_frame
, info
))
1420 s390_backchain_frame_unwind_cache (this_frame
, info
);
1426 s390_frame_this_id (struct frame_info
*this_frame
,
1427 void **this_prologue_cache
,
1428 struct frame_id
*this_id
)
1430 struct s390_unwind_cache
*info
1431 = s390_frame_unwind_cache (this_frame
, this_prologue_cache
);
1433 if (info
->frame_base
== -1)
1436 *this_id
= frame_id_build (info
->frame_base
, info
->func
);
1439 static struct value
*
1440 s390_frame_prev_register (struct frame_info
*this_frame
,
1441 void **this_prologue_cache
, int regnum
)
1443 struct s390_unwind_cache
*info
1444 = s390_frame_unwind_cache (this_frame
, this_prologue_cache
);
1445 return trad_frame_get_prev_register (this_frame
, info
->saved_regs
, regnum
);
1448 static const struct frame_unwind s390_frame_unwind
= {
1451 s390_frame_prev_register
,
1453 default_frame_sniffer
1457 /* Code stubs and their stack frames. For things like PLTs and NULL
1458 function calls (where there is no true frame and the return address
1459 is in the RETADDR register). */
1461 struct s390_stub_unwind_cache
1463 CORE_ADDR frame_base
;
1464 struct trad_frame_saved_reg
*saved_regs
;
1467 static struct s390_stub_unwind_cache
*
1468 s390_stub_frame_unwind_cache (struct frame_info
*this_frame
,
1469 void **this_prologue_cache
)
1471 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1472 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
1473 struct s390_stub_unwind_cache
*info
;
1476 if (*this_prologue_cache
)
1477 return *this_prologue_cache
;
1479 info
= FRAME_OBSTACK_ZALLOC (struct s390_stub_unwind_cache
);
1480 *this_prologue_cache
= info
;
1481 info
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
1483 /* The return address is in register %r14. */
1484 info
->saved_regs
[S390_PC_REGNUM
].realreg
= S390_RETADDR_REGNUM
;
1486 /* Retrieve stack pointer and determine our frame base. */
1487 reg
= get_frame_register_unsigned (this_frame
, S390_SP_REGNUM
);
1488 info
->frame_base
= reg
+ 16*word_size
+ 32;
1494 s390_stub_frame_this_id (struct frame_info
*this_frame
,
1495 void **this_prologue_cache
,
1496 struct frame_id
*this_id
)
1498 struct s390_stub_unwind_cache
*info
1499 = s390_stub_frame_unwind_cache (this_frame
, this_prologue_cache
);
1500 *this_id
= frame_id_build (info
->frame_base
, get_frame_pc (this_frame
));
1503 static struct value
*
1504 s390_stub_frame_prev_register (struct frame_info
*this_frame
,
1505 void **this_prologue_cache
, int regnum
)
1507 struct s390_stub_unwind_cache
*info
1508 = s390_stub_frame_unwind_cache (this_frame
, this_prologue_cache
);
1509 return trad_frame_get_prev_register (this_frame
, info
->saved_regs
, regnum
);
1513 s390_stub_frame_sniffer (const struct frame_unwind
*self
,
1514 struct frame_info
*this_frame
,
1515 void **this_prologue_cache
)
1517 CORE_ADDR addr_in_block
;
1518 bfd_byte insn
[S390_MAX_INSTR_SIZE
];
1520 /* If the current PC points to non-readable memory, we assume we
1521 have trapped due to an invalid function pointer call. We handle
1522 the non-existing current function like a PLT stub. */
1523 addr_in_block
= get_frame_address_in_block (this_frame
);
1524 if (in_plt_section (addr_in_block
, NULL
)
1525 || s390_readinstruction (insn
, get_frame_pc (this_frame
)) < 0)
1530 static const struct frame_unwind s390_stub_frame_unwind
= {
1532 s390_stub_frame_this_id
,
1533 s390_stub_frame_prev_register
,
1535 s390_stub_frame_sniffer
1539 /* Signal trampoline stack frames. */
1541 struct s390_sigtramp_unwind_cache
{
1542 CORE_ADDR frame_base
;
1543 struct trad_frame_saved_reg
*saved_regs
;
1546 static struct s390_sigtramp_unwind_cache
*
1547 s390_sigtramp_frame_unwind_cache (struct frame_info
*this_frame
,
1548 void **this_prologue_cache
)
1550 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1551 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
1552 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1553 struct s390_sigtramp_unwind_cache
*info
;
1554 ULONGEST this_sp
, prev_sp
;
1555 CORE_ADDR next_ra
, next_cfa
, sigreg_ptr
;
1558 if (*this_prologue_cache
)
1559 return *this_prologue_cache
;
1561 info
= FRAME_OBSTACK_ZALLOC (struct s390_sigtramp_unwind_cache
);
1562 *this_prologue_cache
= info
;
1563 info
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
1565 this_sp
= get_frame_register_unsigned (this_frame
, S390_SP_REGNUM
);
1566 next_ra
= get_frame_pc (this_frame
);
1567 next_cfa
= this_sp
+ 16*word_size
+ 32;
1569 /* New-style RT frame:
1570 retcode + alignment (8 bytes)
1572 ucontext (contains sigregs at offset 5 words) */
1573 if (next_ra
== next_cfa
)
1575 sigreg_ptr
= next_cfa
+ 8 + 128 + align_up (5*word_size
, 8);
1578 /* Old-style RT frame and all non-RT frames:
1579 old signal mask (8 bytes)
1580 pointer to sigregs */
1583 sigreg_ptr
= read_memory_unsigned_integer (next_cfa
+ 8,
1584 word_size
, byte_order
);
1587 /* The sigregs structure looks like this:
1596 /* Let's ignore the PSW mask, it will not be restored anyway. */
1597 sigreg_ptr
+= word_size
;
1599 /* Next comes the PSW address. */
1600 info
->saved_regs
[S390_PC_REGNUM
].addr
= sigreg_ptr
;
1601 sigreg_ptr
+= word_size
;
1603 /* Then the GPRs. */
1604 for (i
= 0; i
< 16; i
++)
1606 info
->saved_regs
[S390_R0_REGNUM
+ i
].addr
= sigreg_ptr
;
1607 sigreg_ptr
+= word_size
;
1610 /* Then the ACRs. */
1611 for (i
= 0; i
< 16; i
++)
1613 info
->saved_regs
[S390_A0_REGNUM
+ i
].addr
= sigreg_ptr
;
1617 /* The floating-point control word. */
1618 info
->saved_regs
[S390_FPC_REGNUM
].addr
= sigreg_ptr
;
1621 /* And finally the FPRs. */
1622 for (i
= 0; i
< 16; i
++)
1624 info
->saved_regs
[S390_F0_REGNUM
+ i
].addr
= sigreg_ptr
;
1628 /* Restore the previous frame's SP. */
1629 prev_sp
= read_memory_unsigned_integer (
1630 info
->saved_regs
[S390_SP_REGNUM
].addr
,
1631 word_size
, byte_order
);
1633 /* Determine our frame base. */
1634 info
->frame_base
= prev_sp
+ 16*word_size
+ 32;
1640 s390_sigtramp_frame_this_id (struct frame_info
*this_frame
,
1641 void **this_prologue_cache
,
1642 struct frame_id
*this_id
)
1644 struct s390_sigtramp_unwind_cache
*info
1645 = s390_sigtramp_frame_unwind_cache (this_frame
, this_prologue_cache
);
1646 *this_id
= frame_id_build (info
->frame_base
, get_frame_pc (this_frame
));
1649 static struct value
*
1650 s390_sigtramp_frame_prev_register (struct frame_info
*this_frame
,
1651 void **this_prologue_cache
, int regnum
)
1653 struct s390_sigtramp_unwind_cache
*info
1654 = s390_sigtramp_frame_unwind_cache (this_frame
, this_prologue_cache
);
1655 return trad_frame_get_prev_register (this_frame
, info
->saved_regs
, regnum
);
1659 s390_sigtramp_frame_sniffer (const struct frame_unwind
*self
,
1660 struct frame_info
*this_frame
,
1661 void **this_prologue_cache
)
1663 CORE_ADDR pc
= get_frame_pc (this_frame
);
1664 bfd_byte sigreturn
[2];
1666 if (target_read_memory (pc
, sigreturn
, 2))
1669 if (sigreturn
[0] != 0x0a /* svc */)
1672 if (sigreturn
[1] != 119 /* sigreturn */
1673 && sigreturn
[1] != 173 /* rt_sigreturn */)
1679 static const struct frame_unwind s390_sigtramp_frame_unwind
= {
1681 s390_sigtramp_frame_this_id
,
1682 s390_sigtramp_frame_prev_register
,
1684 s390_sigtramp_frame_sniffer
1688 /* Frame base handling. */
1691 s390_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
1693 struct s390_unwind_cache
*info
1694 = s390_frame_unwind_cache (this_frame
, this_cache
);
1695 return info
->frame_base
;
1699 s390_local_base_address (struct frame_info
*this_frame
, void **this_cache
)
1701 struct s390_unwind_cache
*info
1702 = s390_frame_unwind_cache (this_frame
, this_cache
);
1703 return info
->local_base
;
1706 static const struct frame_base s390_frame_base
= {
1708 s390_frame_base_address
,
1709 s390_local_base_address
,
1710 s390_local_base_address
1714 s390_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1717 pc
= frame_unwind_register_unsigned (next_frame
, S390_PC_REGNUM
);
1718 return gdbarch_addr_bits_remove (gdbarch
, pc
);
1722 s390_unwind_sp (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1725 sp
= frame_unwind_register_unsigned (next_frame
, S390_SP_REGNUM
);
1726 return gdbarch_addr_bits_remove (gdbarch
, sp
);
1730 /* DWARF-2 frame support. */
1733 s390_dwarf2_frame_init_reg (struct gdbarch
*gdbarch
, int regnum
,
1734 struct dwarf2_frame_state_reg
*reg
,
1735 struct frame_info
*this_frame
)
1737 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1741 case ABI_LINUX_S390
:
1742 /* Call-saved registers. */
1743 if ((regnum
>= S390_R6_REGNUM
&& regnum
<= S390_R15_REGNUM
)
1744 || regnum
== S390_F4_REGNUM
1745 || regnum
== S390_F6_REGNUM
)
1746 reg
->how
= DWARF2_FRAME_REG_SAME_VALUE
;
1748 /* Call-clobbered registers. */
1749 else if ((regnum
>= S390_R0_REGNUM
&& regnum
<= S390_R5_REGNUM
)
1750 || (regnum
>= S390_F0_REGNUM
&& regnum
<= S390_F15_REGNUM
1751 && regnum
!= S390_F4_REGNUM
&& regnum
!= S390_F6_REGNUM
))
1752 reg
->how
= DWARF2_FRAME_REG_UNDEFINED
;
1754 /* The return address column. */
1755 else if (regnum
== S390_PC_REGNUM
)
1756 reg
->how
= DWARF2_FRAME_REG_RA
;
1759 case ABI_LINUX_ZSERIES
:
1760 /* Call-saved registers. */
1761 if ((regnum
>= S390_R6_REGNUM
&& regnum
<= S390_R15_REGNUM
)
1762 || (regnum
>= S390_F8_REGNUM
&& regnum
<= S390_F15_REGNUM
))
1763 reg
->how
= DWARF2_FRAME_REG_SAME_VALUE
;
1765 /* Call-clobbered registers. */
1766 else if ((regnum
>= S390_R0_REGNUM
&& regnum
<= S390_R5_REGNUM
)
1767 || (regnum
>= S390_F0_REGNUM
&& regnum
<= S390_F7_REGNUM
))
1768 reg
->how
= DWARF2_FRAME_REG_UNDEFINED
;
1770 /* The return address column. */
1771 else if (regnum
== S390_PC_REGNUM
)
1772 reg
->how
= DWARF2_FRAME_REG_RA
;
1778 /* Dummy function calls. */
1780 /* Return non-zero if TYPE is an integer-like type, zero otherwise.
1781 "Integer-like" types are those that should be passed the way
1782 integers are: integers, enums, ranges, characters, and booleans. */
1784 is_integer_like (struct type
*type
)
1786 enum type_code code
= TYPE_CODE (type
);
1788 return (code
== TYPE_CODE_INT
1789 || code
== TYPE_CODE_ENUM
1790 || code
== TYPE_CODE_RANGE
1791 || code
== TYPE_CODE_CHAR
1792 || code
== TYPE_CODE_BOOL
);
1795 /* Return non-zero if TYPE is a pointer-like type, zero otherwise.
1796 "Pointer-like" types are those that should be passed the way
1797 pointers are: pointers and references. */
1799 is_pointer_like (struct type
*type
)
1801 enum type_code code
= TYPE_CODE (type
);
1803 return (code
== TYPE_CODE_PTR
1804 || code
== TYPE_CODE_REF
);
1808 /* Return non-zero if TYPE is a `float singleton' or `double
1809 singleton', zero otherwise.
1811 A `T singleton' is a struct type with one member, whose type is
1812 either T or a `T singleton'. So, the following are all float
1816 struct { struct { float x; } x; };
1817 struct { struct { struct { float x; } x; } x; };
1821 All such structures are passed as if they were floats or doubles,
1822 as the (revised) ABI says. */
1824 is_float_singleton (struct type
*type
)
1826 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
&& TYPE_NFIELDS (type
) == 1)
1828 struct type
*singleton_type
= TYPE_FIELD_TYPE (type
, 0);
1829 CHECK_TYPEDEF (singleton_type
);
1831 return (TYPE_CODE (singleton_type
) == TYPE_CODE_FLT
1832 || TYPE_CODE (singleton_type
) == TYPE_CODE_DECFLOAT
1833 || is_float_singleton (singleton_type
));
1840 /* Return non-zero if TYPE is a struct-like type, zero otherwise.
1841 "Struct-like" types are those that should be passed as structs are:
1844 As an odd quirk, not mentioned in the ABI, GCC passes float and
1845 double singletons as if they were a plain float, double, etc. (The
1846 corresponding union types are handled normally.) So we exclude
1847 those types here. *shrug* */
1849 is_struct_like (struct type
*type
)
1851 enum type_code code
= TYPE_CODE (type
);
1853 return (code
== TYPE_CODE_UNION
1854 || (code
== TYPE_CODE_STRUCT
&& ! is_float_singleton (type
)));
1858 /* Return non-zero if TYPE is a float-like type, zero otherwise.
1859 "Float-like" types are those that should be passed as
1860 floating-point values are.
1862 You'd think this would just be floats, doubles, long doubles, etc.
1863 But as an odd quirk, not mentioned in the ABI, GCC passes float and
1864 double singletons as if they were a plain float, double, etc. (The
1865 corresponding union types are handled normally.) So we include
1866 those types here. *shrug* */
1868 is_float_like (struct type
*type
)
1870 return (TYPE_CODE (type
) == TYPE_CODE_FLT
1871 || TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
1872 || is_float_singleton (type
));
1877 is_power_of_two (unsigned int n
)
1879 return ((n
& (n
- 1)) == 0);
1882 /* Return non-zero if TYPE should be passed as a pointer to a copy,
1885 s390_function_arg_pass_by_reference (struct type
*type
)
1887 unsigned length
= TYPE_LENGTH (type
);
1891 /* FIXME: All complex and vector types are also returned by reference. */
1892 return is_struct_like (type
) && !is_power_of_two (length
);
1895 /* Return non-zero if TYPE should be passed in a float register
1898 s390_function_arg_float (struct type
*type
)
1900 unsigned length
= TYPE_LENGTH (type
);
1904 return is_float_like (type
);
1907 /* Return non-zero if TYPE should be passed in an integer register
1908 (or a pair of integer registers) if possible. */
1910 s390_function_arg_integer (struct type
*type
)
1912 unsigned length
= TYPE_LENGTH (type
);
1916 return is_integer_like (type
)
1917 || is_pointer_like (type
)
1918 || (is_struct_like (type
) && is_power_of_two (length
));
1921 /* Return ARG, a `SIMPLE_ARG', sign-extended or zero-extended to a full
1922 word as required for the ABI. */
1924 extend_simple_arg (struct gdbarch
*gdbarch
, struct value
*arg
)
1926 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1927 struct type
*type
= value_type (arg
);
1929 /* Even structs get passed in the least significant bits of the
1930 register / memory word. It's not really right to extract them as
1931 an integer, but it does take care of the extension. */
1932 if (TYPE_UNSIGNED (type
))
1933 return extract_unsigned_integer (value_contents (arg
),
1934 TYPE_LENGTH (type
), byte_order
);
1936 return extract_signed_integer (value_contents (arg
),
1937 TYPE_LENGTH (type
), byte_order
);
1941 /* Return the alignment required by TYPE. */
1943 alignment_of (struct type
*type
)
1947 if (is_integer_like (type
)
1948 || is_pointer_like (type
)
1949 || TYPE_CODE (type
) == TYPE_CODE_FLT
1950 || TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
1951 alignment
= TYPE_LENGTH (type
);
1952 else if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
1953 || TYPE_CODE (type
) == TYPE_CODE_UNION
)
1958 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1960 int field_alignment
= alignment_of (TYPE_FIELD_TYPE (type
, i
));
1962 if (field_alignment
> alignment
)
1963 alignment
= field_alignment
;
1969 /* Check that everything we ever return is a power of two. Lots of
1970 code doesn't want to deal with aligning things to arbitrary
1972 gdb_assert ((alignment
& (alignment
- 1)) == 0);
1978 /* Put the actual parameter values pointed to by ARGS[0..NARGS-1] in
1979 place to be passed to a function, as specified by the "GNU/Linux
1980 for S/390 ELF Application Binary Interface Supplement".
1982 SP is the current stack pointer. We must put arguments, links,
1983 padding, etc. whereever they belong, and return the new stack
1986 If STRUCT_RETURN is non-zero, then the function we're calling is
1987 going to return a structure by value; STRUCT_ADDR is the address of
1988 a block we've allocated for it on the stack.
1990 Our caller has taken care of any type promotions needed to satisfy
1991 prototypes or the old K&R argument-passing rules. */
1993 s390_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
1994 struct regcache
*regcache
, CORE_ADDR bp_addr
,
1995 int nargs
, struct value
**args
, CORE_ADDR sp
,
1996 int struct_return
, CORE_ADDR struct_addr
)
1998 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1999 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
2000 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2004 /* If the i'th argument is passed as a reference to a copy, then
2005 copy_addr[i] is the address of the copy we made. */
2006 CORE_ADDR
*copy_addr
= alloca (nargs
* sizeof (CORE_ADDR
));
2008 /* Build the reference-to-copy area. */
2009 for (i
= 0; i
< nargs
; i
++)
2011 struct value
*arg
= args
[i
];
2012 struct type
*type
= value_type (arg
);
2013 unsigned length
= TYPE_LENGTH (type
);
2015 if (s390_function_arg_pass_by_reference (type
))
2018 sp
= align_down (sp
, alignment_of (type
));
2019 write_memory (sp
, value_contents (arg
), length
);
2024 /* Reserve space for the parameter area. As a conservative
2025 simplification, we assume that everything will be passed on the
2026 stack. Since every argument larger than 8 bytes will be
2027 passed by reference, we use this simple upper bound. */
2030 /* After all that, make sure it's still aligned on an eight-byte
2032 sp
= align_down (sp
, 8);
2034 /* Finally, place the actual parameters, working from SP towards
2035 higher addresses. The code above is supposed to reserve enough
2040 CORE_ADDR starg
= sp
;
2042 /* A struct is returned using general register 2. */
2045 regcache_cooked_write_unsigned (regcache
, S390_R0_REGNUM
+ gr
,
2050 for (i
= 0; i
< nargs
; i
++)
2052 struct value
*arg
= args
[i
];
2053 struct type
*type
= value_type (arg
);
2054 unsigned length
= TYPE_LENGTH (type
);
2056 if (s390_function_arg_pass_by_reference (type
))
2060 regcache_cooked_write_unsigned (regcache
, S390_R0_REGNUM
+ gr
,
2066 write_memory_unsigned_integer (starg
, word_size
, byte_order
,
2071 else if (s390_function_arg_float (type
))
2073 /* The GNU/Linux for S/390 ABI uses FPRs 0 and 2 to pass arguments,
2074 the GNU/Linux for zSeries ABI uses 0, 2, 4, and 6. */
2075 if (fr
<= (tdep
->abi
== ABI_LINUX_S390
? 2 : 6))
2077 /* When we store a single-precision value in an FP register,
2078 it occupies the leftmost bits. */
2079 regcache_cooked_write_part (regcache
, S390_F0_REGNUM
+ fr
,
2080 0, length
, value_contents (arg
));
2085 /* When we store a single-precision value in a stack slot,
2086 it occupies the rightmost bits. */
2087 starg
= align_up (starg
+ length
, word_size
);
2088 write_memory (starg
- length
, value_contents (arg
), length
);
2091 else if (s390_function_arg_integer (type
) && length
<= word_size
)
2095 /* Integer arguments are always extended to word size. */
2096 regcache_cooked_write_signed (regcache
, S390_R0_REGNUM
+ gr
,
2097 extend_simple_arg (gdbarch
, arg
));
2102 /* Integer arguments are always extended to word size. */
2103 write_memory_signed_integer (starg
, word_size
, byte_order
,
2104 extend_simple_arg (gdbarch
, arg
));
2108 else if (s390_function_arg_integer (type
) && length
== 2*word_size
)
2112 regcache_cooked_write (regcache
, S390_R0_REGNUM
+ gr
,
2113 value_contents (arg
));
2114 regcache_cooked_write (regcache
, S390_R0_REGNUM
+ gr
+ 1,
2115 value_contents (arg
) + word_size
);
2120 /* If we skipped r6 because we couldn't fit a DOUBLE_ARG
2121 in it, then don't go back and use it again later. */
2124 write_memory (starg
, value_contents (arg
), length
);
2129 internal_error (__FILE__
, __LINE__
, _("unknown argument type"));
2133 /* Allocate the standard frame areas: the register save area, the
2134 word reserved for the compiler (which seems kind of meaningless),
2135 and the back chain pointer. */
2136 sp
-= 16*word_size
+ 32;
2138 /* Store return address. */
2139 regcache_cooked_write_unsigned (regcache
, S390_RETADDR_REGNUM
, bp_addr
);
2141 /* Store updated stack pointer. */
2142 regcache_cooked_write_unsigned (regcache
, S390_SP_REGNUM
, sp
);
2144 /* We need to return the 'stack part' of the frame ID,
2145 which is actually the top of the register save area. */
2146 return sp
+ 16*word_size
+ 32;
2149 /* Assuming THIS_FRAME is a dummy, return the frame ID of that
2150 dummy frame. The frame ID's base needs to match the TOS value
2151 returned by push_dummy_call, and the PC match the dummy frame's
2153 static struct frame_id
2154 s390_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*this_frame
)
2156 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
2157 CORE_ADDR sp
= get_frame_register_unsigned (this_frame
, S390_SP_REGNUM
);
2158 sp
= gdbarch_addr_bits_remove (gdbarch
, sp
);
2160 return frame_id_build (sp
+ 16*word_size
+ 32,
2161 get_frame_pc (this_frame
));
2165 s390_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
2167 /* Both the 32- and 64-bit ABI's say that the stack pointer should
2168 always be aligned on an eight-byte boundary. */
2173 /* Function return value access. */
2175 static enum return_value_convention
2176 s390_return_value_convention (struct gdbarch
*gdbarch
, struct type
*type
)
2178 int length
= TYPE_LENGTH (type
);
2180 return RETURN_VALUE_STRUCT_CONVENTION
;
2182 switch (TYPE_CODE (type
))
2184 case TYPE_CODE_STRUCT
:
2185 case TYPE_CODE_UNION
:
2186 case TYPE_CODE_ARRAY
:
2187 return RETURN_VALUE_STRUCT_CONVENTION
;
2190 return RETURN_VALUE_REGISTER_CONVENTION
;
2194 static enum return_value_convention
2195 s390_return_value (struct gdbarch
*gdbarch
, struct type
*func_type
,
2196 struct type
*type
, struct regcache
*regcache
,
2197 gdb_byte
*out
, const gdb_byte
*in
)
2199 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2200 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
2201 int length
= TYPE_LENGTH (type
);
2202 enum return_value_convention rvc
=
2203 s390_return_value_convention (gdbarch
, type
);
2208 case RETURN_VALUE_REGISTER_CONVENTION
:
2209 if (TYPE_CODE (type
) == TYPE_CODE_FLT
2210 || TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
2212 /* When we store a single-precision value in an FP register,
2213 it occupies the leftmost bits. */
2214 regcache_cooked_write_part (regcache
, S390_F0_REGNUM
,
2217 else if (length
<= word_size
)
2219 /* Integer arguments are always extended to word size. */
2220 if (TYPE_UNSIGNED (type
))
2221 regcache_cooked_write_unsigned (regcache
, S390_R2_REGNUM
,
2222 extract_unsigned_integer (in
, length
, byte_order
));
2224 regcache_cooked_write_signed (regcache
, S390_R2_REGNUM
,
2225 extract_signed_integer (in
, length
, byte_order
));
2227 else if (length
== 2*word_size
)
2229 regcache_cooked_write (regcache
, S390_R2_REGNUM
, in
);
2230 regcache_cooked_write (regcache
, S390_R3_REGNUM
, in
+ word_size
);
2233 internal_error (__FILE__
, __LINE__
, _("invalid return type"));
2236 case RETURN_VALUE_STRUCT_CONVENTION
:
2237 error (_("Cannot set function return value."));
2245 case RETURN_VALUE_REGISTER_CONVENTION
:
2246 if (TYPE_CODE (type
) == TYPE_CODE_FLT
2247 || TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
2249 /* When we store a single-precision value in an FP register,
2250 it occupies the leftmost bits. */
2251 regcache_cooked_read_part (regcache
, S390_F0_REGNUM
,
2254 else if (length
<= word_size
)
2256 /* Integer arguments occupy the rightmost bits. */
2257 regcache_cooked_read_part (regcache
, S390_R2_REGNUM
,
2258 word_size
- length
, length
, out
);
2260 else if (length
== 2*word_size
)
2262 regcache_cooked_read (regcache
, S390_R2_REGNUM
, out
);
2263 regcache_cooked_read (regcache
, S390_R3_REGNUM
, out
+ word_size
);
2266 internal_error (__FILE__
, __LINE__
, _("invalid return type"));
2269 case RETURN_VALUE_STRUCT_CONVENTION
:
2270 error (_("Function return value unknown."));
2281 static const gdb_byte
*
2282 s390_breakpoint_from_pc (struct gdbarch
*gdbarch
, CORE_ADDR
*pcptr
, int *lenptr
)
2284 static const gdb_byte breakpoint
[] = { 0x0, 0x1 };
2286 *lenptr
= sizeof (breakpoint
);
2291 /* Address handling. */
2294 s390_addr_bits_remove (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
2296 return addr
& 0x7fffffff;
2300 s390_address_class_type_flags (int byte_size
, int dwarf2_addr_class
)
2303 return TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1
;
2309 s390_address_class_type_flags_to_name (struct gdbarch
*gdbarch
, int type_flags
)
2311 if (type_flags
& TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1
)
2318 s390_address_class_name_to_type_flags (struct gdbarch
*gdbarch
, const char *name
,
2319 int *type_flags_ptr
)
2321 if (strcmp (name
, "mode32") == 0)
2323 *type_flags_ptr
= TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1
;
2330 /* Set up gdbarch struct. */
2332 static struct gdbarch
*
2333 s390_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
2335 struct gdbarch
*gdbarch
;
2336 struct gdbarch_tdep
*tdep
;
2338 /* First see if there is already a gdbarch that can satisfy the request. */
2339 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
2341 return arches
->gdbarch
;
2343 /* None found: is the request for a s390 architecture? */
2344 if (info
.bfd_arch_info
->arch
!= bfd_arch_s390
)
2345 return NULL
; /* No; then it's not for us. */
2347 /* Yes: create a new gdbarch for the specified machine type. */
2348 tdep
= XCALLOC (1, struct gdbarch_tdep
);
2349 gdbarch
= gdbarch_alloc (&info
, tdep
);
2351 set_gdbarch_believe_pcc_promotion (gdbarch
, 0);
2352 set_gdbarch_char_signed (gdbarch
, 0);
2354 /* S/390 GNU/Linux uses either 64-bit or 128-bit long doubles.
2355 We can safely let them default to 128-bit, since the debug info
2356 will give the size of type actually used in each case. */
2357 set_gdbarch_long_double_bit (gdbarch
, 128);
2358 set_gdbarch_long_double_format (gdbarch
, floatformats_ia64_quad
);
2360 /* Amount PC must be decremented by after a breakpoint. This is
2361 often the number of bytes returned by gdbarch_breakpoint_from_pc but not
2363 set_gdbarch_decr_pc_after_break (gdbarch
, 2);
2364 /* Stack grows downward. */
2365 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
2366 set_gdbarch_breakpoint_from_pc (gdbarch
, s390_breakpoint_from_pc
);
2367 set_gdbarch_skip_prologue (gdbarch
, s390_skip_prologue
);
2368 set_gdbarch_in_function_epilogue_p (gdbarch
, s390_in_function_epilogue_p
);
2370 set_gdbarch_pc_regnum (gdbarch
, S390_PC_REGNUM
);
2371 set_gdbarch_sp_regnum (gdbarch
, S390_SP_REGNUM
);
2372 set_gdbarch_fp0_regnum (gdbarch
, S390_F0_REGNUM
);
2373 set_gdbarch_num_regs (gdbarch
, S390_NUM_REGS
);
2374 set_gdbarch_num_pseudo_regs (gdbarch
, S390_NUM_PSEUDO_REGS
);
2375 set_gdbarch_register_name (gdbarch
, s390_register_name
);
2376 set_gdbarch_register_type (gdbarch
, s390_register_type
);
2377 set_gdbarch_stab_reg_to_regnum (gdbarch
, s390_dwarf_reg_to_regnum
);
2378 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, s390_dwarf_reg_to_regnum
);
2379 set_gdbarch_value_from_register (gdbarch
, s390_value_from_register
);
2380 set_gdbarch_register_reggroup_p (gdbarch
, s390_register_reggroup_p
);
2381 set_gdbarch_regset_from_core_section (gdbarch
,
2382 s390_regset_from_core_section
);
2384 /* Inferior function calls. */
2385 set_gdbarch_push_dummy_call (gdbarch
, s390_push_dummy_call
);
2386 set_gdbarch_dummy_id (gdbarch
, s390_dummy_id
);
2387 set_gdbarch_frame_align (gdbarch
, s390_frame_align
);
2388 set_gdbarch_return_value (gdbarch
, s390_return_value
);
2390 /* Frame handling. */
2391 dwarf2_frame_set_init_reg (gdbarch
, s390_dwarf2_frame_init_reg
);
2392 dwarf2_append_unwinders (gdbarch
);
2393 frame_base_append_sniffer (gdbarch
, dwarf2_frame_base_sniffer
);
2394 frame_unwind_append_unwinder (gdbarch
, &s390_stub_frame_unwind
);
2395 frame_unwind_append_unwinder (gdbarch
, &s390_sigtramp_frame_unwind
);
2396 frame_unwind_append_unwinder (gdbarch
, &s390_frame_unwind
);
2397 frame_base_set_default (gdbarch
, &s390_frame_base
);
2398 set_gdbarch_unwind_pc (gdbarch
, s390_unwind_pc
);
2399 set_gdbarch_unwind_sp (gdbarch
, s390_unwind_sp
);
2401 switch (info
.bfd_arch_info
->mach
)
2403 case bfd_mach_s390_31
:
2404 tdep
->abi
= ABI_LINUX_S390
;
2406 tdep
->gregset
= &s390_gregset
;
2407 tdep
->sizeof_gregset
= s390_sizeof_gregset
;
2408 tdep
->fpregset
= &s390_fpregset
;
2409 tdep
->sizeof_fpregset
= s390_sizeof_fpregset
;
2411 set_gdbarch_addr_bits_remove (gdbarch
, s390_addr_bits_remove
);
2412 set_gdbarch_pseudo_register_read (gdbarch
, s390_pseudo_register_read
);
2413 set_gdbarch_pseudo_register_write (gdbarch
, s390_pseudo_register_write
);
2414 set_solib_svr4_fetch_link_map_offsets
2415 (gdbarch
, svr4_ilp32_fetch_link_map_offsets
);
2418 case bfd_mach_s390_64
:
2419 tdep
->abi
= ABI_LINUX_ZSERIES
;
2421 tdep
->gregset
= &s390x_gregset
;
2422 tdep
->sizeof_gregset
= s390x_sizeof_gregset
;
2423 tdep
->fpregset
= &s390_fpregset
;
2424 tdep
->sizeof_fpregset
= s390_sizeof_fpregset
;
2426 set_gdbarch_long_bit (gdbarch
, 64);
2427 set_gdbarch_long_long_bit (gdbarch
, 64);
2428 set_gdbarch_ptr_bit (gdbarch
, 64);
2429 set_gdbarch_pseudo_register_read (gdbarch
, s390x_pseudo_register_read
);
2430 set_gdbarch_pseudo_register_write (gdbarch
, s390x_pseudo_register_write
);
2431 set_solib_svr4_fetch_link_map_offsets
2432 (gdbarch
, svr4_lp64_fetch_link_map_offsets
);
2433 set_gdbarch_address_class_type_flags (gdbarch
,
2434 s390_address_class_type_flags
);
2435 set_gdbarch_address_class_type_flags_to_name (gdbarch
,
2436 s390_address_class_type_flags_to_name
);
2437 set_gdbarch_address_class_name_to_type_flags (gdbarch
,
2438 s390_address_class_name_to_type_flags
);
2442 set_gdbarch_print_insn (gdbarch
, print_insn_s390
);
2444 set_gdbarch_skip_trampoline_code (gdbarch
, find_solib_trampoline_target
);
2446 /* Enable TLS support. */
2447 set_gdbarch_fetch_tls_load_module_address (gdbarch
,
2448 svr4_fetch_objfile_link_map
);
2455 extern initialize_file_ftype _initialize_s390_tdep
; /* -Wmissing-prototypes */
2458 _initialize_s390_tdep (void)
2461 /* Hook us into the gdbarch mechanism. */
2462 register_gdbarch_init (bfd_arch_s390
, s390_gdbarch_init
);