1 /* Target-dependent code for GDB, the GNU debugger.
3 Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007
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_long;
100 if (regnum >= S390_R0_REGNUM && regnum <= S390_R15_REGNUM)
101 return builtin_type_long;
102 if (regnum >= S390_A0_REGNUM && regnum <= S390_A15_REGNUM)
103 return builtin_type_int;
104 if (regnum == S390_FPC_REGNUM)
105 return builtin_type_int;
106 if (regnum >= S390_F0_REGNUM && regnum <= S390_F15_REGNUM)
107 return builtin_type_double;
108 if (regnum == S390_PC_REGNUM)
109 return builtin_type_void_func_ptr;
110 if (regnum == S390_CC_REGNUM)
111 return builtin_type_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 (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)
174 regcache_raw_read_unsigned (regcache, S390_PSWA_REGNUM, &val);
175 store_unsigned_integer (buf, 4, val & 0x7fffffff);
179 regcache_raw_read_unsigned (regcache, S390_PSWM_REGNUM, &val);
180 store_unsigned_integer (buf, 4, (val >> 12) & 3);
184 internal_error (__FILE__, __LINE__, _("invalid regnum"));
189 s390_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
190 int regnum, const gdb_byte *buf)
197 val = extract_unsigned_integer (buf, 4);
198 regcache_raw_read_unsigned (regcache, S390_PSWA_REGNUM, &psw);
199 psw = (psw & 0x80000000) | (val & 0x7fffffff);
200 regcache_raw_write_unsigned (regcache, S390_PSWA_REGNUM, psw);
204 val = extract_unsigned_integer (buf, 4);
205 regcache_raw_read_unsigned (regcache, S390_PSWM_REGNUM, &psw);
206 psw = (psw & ~((ULONGEST)3 << 12)) | ((val & 3) << 12);
207 regcache_raw_write_unsigned (regcache, S390_PSWM_REGNUM, psw);
211 internal_error (__FILE__, __LINE__, _("invalid regnum"));
216 s390x_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
217 int regnum, gdb_byte *buf)
224 regcache_raw_read (regcache, S390_PSWA_REGNUM, buf);
228 regcache_raw_read_unsigned (regcache, S390_PSWM_REGNUM, &val);
229 store_unsigned_integer (buf, 4, (val >> 44) & 3);
233 internal_error (__FILE__, __LINE__, _("invalid regnum"));
238 s390x_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
239 int regnum, const gdb_byte *buf)
246 regcache_raw_write (regcache, S390_PSWA_REGNUM, buf);
250 val = extract_unsigned_integer (buf, 4);
251 regcache_raw_read_unsigned (regcache, S390_PSWM_REGNUM, &psw);
252 psw = (psw & ~((ULONGEST)3 << 44)) | ((val & 3) << 44);
253 regcache_raw_write_unsigned (regcache, S390_PSWM_REGNUM, psw);
257 internal_error (__FILE__, __LINE__, _("invalid regnum"));
261 /* 'float' values are stored in the upper half of floating-point
262 registers, even though we are otherwise a big-endian platform. */
264 static struct value *
265 s390_value_from_register (struct type *type, int regnum,
266 struct frame_info *frame)
268 struct value *value = default_value_from_register (type, regnum, frame);
269 int len = TYPE_LENGTH (type);
271 if (regnum >= S390_F0_REGNUM && regnum <= S390_F15_REGNUM && len < 8)
272 set_value_offset (value, 0);
277 /* Register groups. */
280 s390_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
281 struct reggroup *group)
283 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
285 /* Registers displayed via 'info regs'. */
286 if (group == general_reggroup)
287 return (regnum >= S390_R0_REGNUM && regnum <= S390_R15_REGNUM)
288 || regnum == S390_PC_REGNUM
289 || regnum == S390_CC_REGNUM;
291 /* Registers displayed via 'info float'. */
292 if (group == float_reggroup)
293 return (regnum >= S390_F0_REGNUM && regnum <= S390_F15_REGNUM)
294 || regnum == S390_FPC_REGNUM;
296 /* Registers that need to be saved/restored in order to
297 push or pop frames. */
298 if (group == save_reggroup || group == restore_reggroup)
299 return regnum != S390_PSWM_REGNUM && regnum != S390_PSWA_REGNUM;
301 return default_register_reggroup_p (gdbarch, regnum, group);
305 /* Core file register sets. */
307 int s390_regmap_gregset[S390_NUM_REGS] =
309 /* Program Status Word. */
311 /* General Purpose Registers. */
312 0x08, 0x0c, 0x10, 0x14,
313 0x18, 0x1c, 0x20, 0x24,
314 0x28, 0x2c, 0x30, 0x34,
315 0x38, 0x3c, 0x40, 0x44,
316 /* Access Registers. */
317 0x48, 0x4c, 0x50, 0x54,
318 0x58, 0x5c, 0x60, 0x64,
319 0x68, 0x6c, 0x70, 0x74,
320 0x78, 0x7c, 0x80, 0x84,
321 /* Floating Point Control Word. */
323 /* Floating Point Registers. */
324 -1, -1, -1, -1, -1, -1, -1, -1,
325 -1, -1, -1, -1, -1, -1, -1, -1,
328 int s390x_regmap_gregset[S390_NUM_REGS] =
331 /* General Purpose Registers. */
332 0x10, 0x18, 0x20, 0x28,
333 0x30, 0x38, 0x40, 0x48,
334 0x50, 0x58, 0x60, 0x68,
335 0x70, 0x78, 0x80, 0x88,
336 /* Access Registers. */
337 0x90, 0x94, 0x98, 0x9c,
338 0xa0, 0xa4, 0xa8, 0xac,
339 0xb0, 0xb4, 0xb8, 0xbc,
340 0xc0, 0xc4, 0xc8, 0xcc,
341 /* Floating Point Control Word. */
343 /* Floating Point Registers. */
344 -1, -1, -1, -1, -1, -1, -1, -1,
345 -1, -1, -1, -1, -1, -1, -1, -1,
348 int s390_regmap_fpregset[S390_NUM_REGS] =
350 /* Program Status Word. */
352 /* General Purpose Registers. */
353 -1, -1, -1, -1, -1, -1, -1, -1,
354 -1, -1, -1, -1, -1, -1, -1, -1,
355 /* Access Registers. */
356 -1, -1, -1, -1, -1, -1, -1, -1,
357 -1, -1, -1, -1, -1, -1, -1, -1,
358 /* Floating Point Control Word. */
360 /* Floating Point Registers. */
361 0x08, 0x10, 0x18, 0x20,
362 0x28, 0x30, 0x38, 0x40,
363 0x48, 0x50, 0x58, 0x60,
364 0x68, 0x70, 0x78, 0x80,
367 /* Supply register REGNUM from the register set REGSET to register cache
368 REGCACHE. If REGNUM is -1, do this for all registers in REGSET. */
370 s390_supply_regset (const struct regset *regset, struct regcache *regcache,
371 int regnum, const void *regs, size_t len)
373 const int *offset = regset->descr;
376 for (i = 0; i < S390_NUM_REGS; i++)
378 if ((regnum == i || regnum == -1) && offset[i] != -1)
379 regcache_raw_supply (regcache, i, (const char *)regs + offset[i]);
383 /* Collect register REGNUM from the register cache REGCACHE and store
384 it in the buffer specified by REGS and LEN as described by the
385 general-purpose register set REGSET. If REGNUM is -1, do this for
386 all registers in REGSET. */
388 s390_collect_regset (const struct regset *regset,
389 const struct regcache *regcache,
390 int regnum, void *regs, size_t len)
392 const int *offset = regset->descr;
395 for (i = 0; i < S390_NUM_REGS; i++)
397 if ((regnum == i || regnum == -1) && offset[i] != -1)
398 regcache_raw_collect (regcache, i, (char *)regs + offset[i]);
402 static const struct regset s390_gregset = {
408 static const struct regset s390x_gregset = {
409 s390x_regmap_gregset,
414 static const struct regset s390_fpregset = {
415 s390_regmap_fpregset,
420 /* Return the appropriate register set for the core section identified
421 by SECT_NAME and SECT_SIZE. */
422 const struct regset *
423 s390_regset_from_core_section (struct gdbarch *gdbarch,
424 const char *sect_name, size_t sect_size)
426 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
428 if (strcmp (sect_name, ".reg") == 0 && sect_size >= tdep->sizeof_gregset)
429 return tdep->gregset;
431 if (strcmp (sect_name, ".reg2") == 0 && sect_size >= tdep->sizeof_fpregset)
432 return tdep->fpregset;
438 /* Decoding S/390 instructions. */
440 /* Named opcode values for the S/390 instructions we recognize. Some
441 instructions have their opcode split across two fields; those are the
442 op1_* and op2_* enums. */
445 op1_lhi = 0xa7, op2_lhi = 0x08,
446 op1_lghi = 0xa7, op2_lghi = 0x09,
447 op1_lgfi = 0xc0, op2_lgfi = 0x01,
451 op1_ly = 0xe3, op2_ly = 0x58,
452 op1_lg = 0xe3, op2_lg = 0x04,
454 op1_lmy = 0xeb, op2_lmy = 0x98,
455 op1_lmg = 0xeb, op2_lmg = 0x04,
457 op1_sty = 0xe3, op2_sty = 0x50,
458 op1_stg = 0xe3, op2_stg = 0x24,
461 op1_stmy = 0xeb, op2_stmy = 0x90,
462 op1_stmg = 0xeb, op2_stmg = 0x24,
463 op1_aghi = 0xa7, op2_aghi = 0x0b,
464 op1_ahi = 0xa7, op2_ahi = 0x0a,
465 op1_agfi = 0xc2, op2_agfi = 0x08,
466 op1_afi = 0xc2, op2_afi = 0x09,
467 op1_algfi= 0xc2, op2_algfi= 0x0a,
468 op1_alfi = 0xc2, op2_alfi = 0x0b,
472 op1_ay = 0xe3, op2_ay = 0x5a,
473 op1_ag = 0xe3, op2_ag = 0x08,
474 op1_slgfi= 0xc2, op2_slgfi= 0x04,
475 op1_slfi = 0xc2, op2_slfi = 0x05,
479 op1_sy = 0xe3, op2_sy = 0x5b,
480 op1_sg = 0xe3, op2_sg = 0x09,
484 op1_lay = 0xe3, op2_lay = 0x71,
485 op1_larl = 0xc0, op2_larl = 0x00,
490 op1_bras = 0xa7, op2_bras = 0x05,
491 op1_brasl= 0xc0, op2_brasl= 0x05,
492 op1_brc = 0xa7, op2_brc = 0x04,
493 op1_brcl = 0xc0, op2_brcl = 0x04,
497 /* Read a single instruction from address AT. */
499 #define S390_MAX_INSTR_SIZE 6
501 s390_readinstruction (bfd_byte instr[], CORE_ADDR at)
503 static int s390_instrlen[] = { 2, 4, 4, 6 };
506 if (read_memory_nobpt (at, &instr[0], 2))
508 instrlen = s390_instrlen[instr[0] >> 6];
511 if (read_memory_nobpt (at + 2, &instr[2], instrlen - 2))
518 /* The functions below are for recognizing and decoding S/390
519 instructions of various formats. Each of them checks whether INSN
520 is an instruction of the given format, with the specified opcodes.
521 If it is, it sets the remaining arguments to the values of the
522 instruction's fields, and returns a non-zero value; otherwise, it
525 These functions' arguments appear in the order they appear in the
526 instruction, not in the machine-language form. So, opcodes always
527 come first, even though they're sometimes scattered around the
528 instructions. And displacements appear before base and extension
529 registers, as they do in the assembly syntax, not at the end, as
530 they do in the machine language. */
532 is_ri (bfd_byte *insn, int op1, int op2, unsigned int *r1, int *i2)
534 if (insn[0] == op1 && (insn[1] & 0xf) == op2)
536 *r1 = (insn[1] >> 4) & 0xf;
537 /* i2 is a 16-bit signed quantity. */
538 *i2 = (((insn[2] << 8) | insn[3]) ^ 0x8000) - 0x8000;
547 is_ril (bfd_byte *insn, int op1, int op2,
548 unsigned int *r1, int *i2)
550 if (insn[0] == op1 && (insn[1] & 0xf) == op2)
552 *r1 = (insn[1] >> 4) & 0xf;
553 /* i2 is a signed quantity. If the host 'int' is 32 bits long,
554 no sign extension is necessary, but we don't want to assume
556 *i2 = (((insn[2] << 24)
559 | (insn[5])) ^ 0x80000000) - 0x80000000;
568 is_rr (bfd_byte *insn, int op, unsigned int *r1, unsigned int *r2)
572 *r1 = (insn[1] >> 4) & 0xf;
582 is_rre (bfd_byte *insn, int op, unsigned int *r1, unsigned int *r2)
584 if (((insn[0] << 8) | insn[1]) == op)
586 /* Yes, insn[3]. insn[2] is unused in RRE format. */
587 *r1 = (insn[3] >> 4) & 0xf;
597 is_rs (bfd_byte *insn, int op,
598 unsigned int *r1, unsigned int *r3, unsigned int *d2, unsigned int *b2)
602 *r1 = (insn[1] >> 4) & 0xf;
604 *b2 = (insn[2] >> 4) & 0xf;
605 *d2 = ((insn[2] & 0xf) << 8) | insn[3];
614 is_rsy (bfd_byte *insn, int op1, int op2,
615 unsigned int *r1, unsigned int *r3, unsigned int *d2, unsigned int *b2)
620 *r1 = (insn[1] >> 4) & 0xf;
622 *b2 = (insn[2] >> 4) & 0xf;
623 /* The 'long displacement' is a 20-bit signed integer. */
624 *d2 = ((((insn[2] & 0xf) << 8) | insn[3] | (insn[4] << 12))
625 ^ 0x80000) - 0x80000;
634 is_rx (bfd_byte *insn, int op,
635 unsigned int *r1, unsigned int *d2, unsigned int *x2, unsigned int *b2)
639 *r1 = (insn[1] >> 4) & 0xf;
641 *b2 = (insn[2] >> 4) & 0xf;
642 *d2 = ((insn[2] & 0xf) << 8) | insn[3];
651 is_rxy (bfd_byte *insn, int op1, int op2,
652 unsigned int *r1, unsigned int *d2, unsigned int *x2, unsigned int *b2)
657 *r1 = (insn[1] >> 4) & 0xf;
659 *b2 = (insn[2] >> 4) & 0xf;
660 /* The 'long displacement' is a 20-bit signed integer. */
661 *d2 = ((((insn[2] & 0xf) << 8) | insn[3] | (insn[4] << 12))
662 ^ 0x80000) - 0x80000;
670 /* Prologue analysis. */
672 #define S390_NUM_GPRS 16
673 #define S390_NUM_FPRS 16
675 struct s390_prologue_data {
678 struct pv_area *stack;
680 /* The size of a GPR or FPR. */
684 /* The general-purpose registers. */
685 pv_t gpr[S390_NUM_GPRS];
687 /* The floating-point registers. */
688 pv_t fpr[S390_NUM_FPRS];
690 /* The offset relative to the CFA where the incoming GPR N was saved
691 by the function prologue. 0 if not saved or unknown. */
692 int gpr_slot[S390_NUM_GPRS];
694 /* Likewise for FPRs. */
695 int fpr_slot[S390_NUM_FPRS];
697 /* Nonzero if the backchain was saved. This is assumed to be the
698 case when the incoming SP is saved at the current SP location. */
699 int back_chain_saved_p;
702 /* Return the effective address for an X-style instruction, like:
706 Here, X2 and B2 are registers, and D2 is a signed 20-bit
707 constant; the effective address is the sum of all three. If either
708 X2 or B2 are zero, then it doesn't contribute to the sum --- this
709 means that r0 can't be used as either X2 or B2. */
711 s390_addr (struct s390_prologue_data *data,
712 int d2, unsigned int x2, unsigned int b2)
716 result = pv_constant (d2);
718 result = pv_add (result, data->gpr[x2]);
720 result = pv_add (result, data->gpr[b2]);
725 /* Do a SIZE-byte store of VALUE to D2(X2,B2). */
727 s390_store (struct s390_prologue_data *data,
728 int d2, unsigned int x2, unsigned int b2, CORE_ADDR size,
731 pv_t addr = s390_addr (data, d2, x2, b2);
734 /* Check whether we are storing the backchain. */
735 offset = pv_subtract (data->gpr[S390_SP_REGNUM - S390_R0_REGNUM], addr);
737 if (pv_is_constant (offset) && offset.k == 0)
738 if (size == data->gpr_size
739 && pv_is_register_k (value, S390_SP_REGNUM, 0))
741 data->back_chain_saved_p = 1;
746 /* Check whether we are storing a register into the stack. */
747 if (!pv_area_store_would_trash (data->stack, addr))
748 pv_area_store (data->stack, addr, size, value);
751 /* Note: If this is some store we cannot identify, you might think we
752 should forget our cached values, as any of those might have been hit.
754 However, we make the assumption that the register save areas are only
755 ever stored to once in any given function, and we do recognize these
756 stores. Thus every store we cannot recognize does not hit our data. */
759 /* Do a SIZE-byte load from D2(X2,B2). */
761 s390_load (struct s390_prologue_data *data,
762 int d2, unsigned int x2, unsigned int b2, CORE_ADDR size)
765 pv_t addr = s390_addr (data, d2, x2, b2);
768 /* If it's a load from an in-line constant pool, then we can
769 simulate that, under the assumption that the code isn't
770 going to change between the time the processor actually
771 executed it creating the current frame, and the time when
772 we're analyzing the code to unwind past that frame. */
773 if (pv_is_constant (addr))
775 struct section_table *secp;
776 secp = target_section_by_addr (¤t_target, addr.k);
778 && (bfd_get_section_flags (secp->bfd, secp->the_bfd_section)
780 return pv_constant (read_memory_integer (addr.k, size));
783 /* Check whether we are accessing one of our save slots. */
784 return pv_area_fetch (data->stack, addr, size);
787 /* Function for finding saved registers in a 'struct pv_area'; we pass
788 this to pv_area_scan.
790 If VALUE is a saved register, ADDR says it was saved at a constant
791 offset from the frame base, and SIZE indicates that the whole
792 register was saved, record its offset in the reg_offset table in
795 s390_check_for_saved (void *data_untyped, pv_t addr, CORE_ADDR size, pv_t value)
797 struct s390_prologue_data *data = data_untyped;
800 if (!pv_is_register (addr, S390_SP_REGNUM))
803 offset = 16 * data->gpr_size + 32 - addr.k;
805 /* If we are storing the original value of a register, we want to
806 record the CFA offset. If the same register is stored multiple
807 times, the stack slot with the highest address counts. */
809 for (i = 0; i < S390_NUM_GPRS; i++)
810 if (size == data->gpr_size
811 && pv_is_register_k (value, S390_R0_REGNUM + i, 0))
812 if (data->gpr_slot[i] == 0
813 || data->gpr_slot[i] > offset)
815 data->gpr_slot[i] = offset;
819 for (i = 0; i < S390_NUM_FPRS; i++)
820 if (size == data->fpr_size
821 && pv_is_register_k (value, S390_F0_REGNUM + i, 0))
822 if (data->fpr_slot[i] == 0
823 || data->fpr_slot[i] > offset)
825 data->fpr_slot[i] = offset;
830 /* Analyze the prologue of the function starting at START_PC,
831 continuing at most until CURRENT_PC. Initialize DATA to
832 hold all information we find out about the state of the registers
833 and stack slots. Return the address of the instruction after
834 the last one that changed the SP, FP, or back chain; or zero
837 s390_analyze_prologue (struct gdbarch *gdbarch,
839 CORE_ADDR current_pc,
840 struct s390_prologue_data *data)
842 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
845 The address of the instruction after the last one that changed
846 the SP, FP, or back chain; zero if we got an error trying to
848 CORE_ADDR result = start_pc;
850 /* The current PC for our abstract interpretation. */
853 /* The address of the next instruction after that. */
856 /* Set up everything's initial value. */
860 data->stack = make_pv_area (S390_SP_REGNUM);
862 /* For the purpose of prologue tracking, we consider the GPR size to
863 be equal to the ABI word size, even if it is actually larger
864 (i.e. when running a 32-bit binary under a 64-bit kernel). */
865 data->gpr_size = word_size;
868 for (i = 0; i < S390_NUM_GPRS; i++)
869 data->gpr[i] = pv_register (S390_R0_REGNUM + i, 0);
871 for (i = 0; i < S390_NUM_FPRS; i++)
872 data->fpr[i] = pv_register (S390_F0_REGNUM + i, 0);
874 for (i = 0; i < S390_NUM_GPRS; i++)
875 data->gpr_slot[i] = 0;
877 for (i = 0; i < S390_NUM_FPRS; i++)
878 data->fpr_slot[i] = 0;
880 data->back_chain_saved_p = 0;
883 /* Start interpreting instructions, until we hit the frame's
884 current PC or the first branch instruction. */
885 for (pc = start_pc; pc > 0 && pc < current_pc; pc = next_pc)
887 bfd_byte insn[S390_MAX_INSTR_SIZE];
888 int insn_len = s390_readinstruction (insn, pc);
890 bfd_byte dummy[S390_MAX_INSTR_SIZE] = { 0 };
891 bfd_byte *insn32 = word_size == 4 ? insn : dummy;
892 bfd_byte *insn64 = word_size == 8 ? insn : dummy;
894 /* Fields for various kinds of instructions. */
895 unsigned int b2, r1, r2, x2, r3;
898 /* The values of SP and FP before this instruction,
899 for detecting instructions that change them. */
900 pv_t pre_insn_sp, pre_insn_fp;
901 /* Likewise for the flag whether the back chain was saved. */
902 int pre_insn_back_chain_saved_p;
904 /* If we got an error trying to read the instruction, report it. */
911 next_pc = pc + insn_len;
913 pre_insn_sp = data->gpr[S390_SP_REGNUM - S390_R0_REGNUM];
914 pre_insn_fp = data->gpr[S390_FRAME_REGNUM - S390_R0_REGNUM];
915 pre_insn_back_chain_saved_p = data->back_chain_saved_p;
918 /* LHI r1, i2 --- load halfword immediate. */
919 /* LGHI r1, i2 --- load halfword immediate (64-bit version). */
920 /* LGFI r1, i2 --- load fullword immediate. */
921 if (is_ri (insn32, op1_lhi, op2_lhi, &r1, &i2)
922 || is_ri (insn64, op1_lghi, op2_lghi, &r1, &i2)
923 || is_ril (insn, op1_lgfi, op2_lgfi, &r1, &i2))
924 data->gpr[r1] = pv_constant (i2);
926 /* LR r1, r2 --- load from register. */
927 /* LGR r1, r2 --- load from register (64-bit version). */
928 else if (is_rr (insn32, op_lr, &r1, &r2)
929 || is_rre (insn64, op_lgr, &r1, &r2))
930 data->gpr[r1] = data->gpr[r2];
932 /* L r1, d2(x2, b2) --- load. */
933 /* LY r1, d2(x2, b2) --- load (long-displacement version). */
934 /* LG r1, d2(x2, b2) --- load (64-bit version). */
935 else if (is_rx (insn32, op_l, &r1, &d2, &x2, &b2)
936 || is_rxy (insn32, op1_ly, op2_ly, &r1, &d2, &x2, &b2)
937 || is_rxy (insn64, op1_lg, op2_lg, &r1, &d2, &x2, &b2))
938 data->gpr[r1] = s390_load (data, d2, x2, b2, data->gpr_size);
940 /* ST r1, d2(x2, b2) --- store. */
941 /* STY r1, d2(x2, b2) --- store (long-displacement version). */
942 /* STG r1, d2(x2, b2) --- store (64-bit version). */
943 else if (is_rx (insn32, op_st, &r1, &d2, &x2, &b2)
944 || is_rxy (insn32, op1_sty, op2_sty, &r1, &d2, &x2, &b2)
945 || is_rxy (insn64, op1_stg, op2_stg, &r1, &d2, &x2, &b2))
946 s390_store (data, d2, x2, b2, data->gpr_size, data->gpr[r1]);
948 /* STD r1, d2(x2,b2) --- store floating-point register. */
949 else if (is_rx (insn, op_std, &r1, &d2, &x2, &b2))
950 s390_store (data, d2, x2, b2, data->fpr_size, data->fpr[r1]);
952 /* STM r1, r3, d2(b2) --- store multiple. */
953 /* STMY r1, r3, d2(b2) --- store multiple (long-displacement version). */
954 /* STMG r1, r3, d2(b2) --- store multiple (64-bit version). */
955 else if (is_rs (insn32, op_stm, &r1, &r3, &d2, &b2)
956 || is_rsy (insn32, op1_stmy, op2_stmy, &r1, &r3, &d2, &b2)
957 || is_rsy (insn64, op1_stmg, op2_stmg, &r1, &r3, &d2, &b2))
959 for (; r1 <= r3; r1++, d2 += data->gpr_size)
960 s390_store (data, d2, 0, b2, data->gpr_size, data->gpr[r1]);
963 /* AHI r1, i2 --- add halfword immediate. */
964 /* AGHI r1, i2 --- add halfword immediate (64-bit version). */
965 /* AFI r1, i2 --- add fullword immediate. */
966 /* AGFI r1, i2 --- add fullword immediate (64-bit version). */
967 else if (is_ri (insn32, op1_ahi, op2_ahi, &r1, &i2)
968 || is_ri (insn64, op1_aghi, op2_aghi, &r1, &i2)
969 || is_ril (insn32, op1_afi, op2_afi, &r1, &i2)
970 || is_ril (insn64, op1_agfi, op2_agfi, &r1, &i2))
971 data->gpr[r1] = pv_add_constant (data->gpr[r1], i2);
973 /* ALFI r1, i2 --- add logical immediate. */
974 /* ALGFI r1, i2 --- add logical immediate (64-bit version). */
975 else if (is_ril (insn32, op1_alfi, op2_alfi, &r1, &i2)
976 || is_ril (insn64, op1_algfi, op2_algfi, &r1, &i2))
977 data->gpr[r1] = pv_add_constant (data->gpr[r1],
978 (CORE_ADDR)i2 & 0xffffffff);
980 /* AR r1, r2 -- add register. */
981 /* AGR r1, r2 -- add register (64-bit version). */
982 else if (is_rr (insn32, op_ar, &r1, &r2)
983 || is_rre (insn64, op_agr, &r1, &r2))
984 data->gpr[r1] = pv_add (data->gpr[r1], data->gpr[r2]);
986 /* A r1, d2(x2, b2) -- add. */
987 /* AY r1, d2(x2, b2) -- add (long-displacement version). */
988 /* AG r1, d2(x2, b2) -- add (64-bit version). */
989 else if (is_rx (insn32, op_a, &r1, &d2, &x2, &b2)
990 || is_rxy (insn32, op1_ay, op2_ay, &r1, &d2, &x2, &b2)
991 || is_rxy (insn64, op1_ag, op2_ag, &r1, &d2, &x2, &b2))
992 data->gpr[r1] = pv_add (data->gpr[r1],
993 s390_load (data, d2, x2, b2, data->gpr_size));
995 /* SLFI r1, i2 --- subtract logical immediate. */
996 /* SLGFI r1, i2 --- subtract logical immediate (64-bit version). */
997 else if (is_ril (insn32, op1_slfi, op2_slfi, &r1, &i2)
998 || is_ril (insn64, op1_slgfi, op2_slgfi, &r1, &i2))
999 data->gpr[r1] = pv_add_constant (data->gpr[r1],
1000 -((CORE_ADDR)i2 & 0xffffffff));
1002 /* SR r1, r2 -- subtract register. */
1003 /* SGR r1, r2 -- subtract register (64-bit version). */
1004 else if (is_rr (insn32, op_sr, &r1, &r2)
1005 || is_rre (insn64, op_sgr, &r1, &r2))
1006 data->gpr[r1] = pv_subtract (data->gpr[r1], data->gpr[r2]);
1008 /* S r1, d2(x2, b2) -- subtract. */
1009 /* SY r1, d2(x2, b2) -- subtract (long-displacement version). */
1010 /* SG r1, d2(x2, b2) -- subtract (64-bit version). */
1011 else if (is_rx (insn32, op_s, &r1, &d2, &x2, &b2)
1012 || is_rxy (insn32, op1_sy, op2_sy, &r1, &d2, &x2, &b2)
1013 || is_rxy (insn64, op1_sg, op2_sg, &r1, &d2, &x2, &b2))
1014 data->gpr[r1] = pv_subtract (data->gpr[r1],
1015 s390_load (data, d2, x2, b2, data->gpr_size));
1017 /* LA r1, d2(x2, b2) --- load address. */
1018 /* LAY r1, d2(x2, b2) --- load address (long-displacement version). */
1019 else if (is_rx (insn, op_la, &r1, &d2, &x2, &b2)
1020 || is_rxy (insn, op1_lay, op2_lay, &r1, &d2, &x2, &b2))
1021 data->gpr[r1] = s390_addr (data, d2, x2, b2);
1023 /* LARL r1, i2 --- load address relative long. */
1024 else if (is_ril (insn, op1_larl, op2_larl, &r1, &i2))
1025 data->gpr[r1] = pv_constant (pc + i2 * 2);
1027 /* BASR r1, 0 --- branch and save.
1028 Since r2 is zero, this saves the PC in r1, but doesn't branch. */
1029 else if (is_rr (insn, op_basr, &r1, &r2)
1031 data->gpr[r1] = pv_constant (next_pc);
1033 /* BRAS r1, i2 --- branch relative and save. */
1034 else if (is_ri (insn, op1_bras, op2_bras, &r1, &i2))
1036 data->gpr[r1] = pv_constant (next_pc);
1037 next_pc = pc + i2 * 2;
1039 /* We'd better not interpret any backward branches. We'll
1045 /* Terminate search when hitting any other branch instruction. */
1046 else if (is_rr (insn, op_basr, &r1, &r2)
1047 || is_rx (insn, op_bas, &r1, &d2, &x2, &b2)
1048 || is_rr (insn, op_bcr, &r1, &r2)
1049 || is_rx (insn, op_bc, &r1, &d2, &x2, &b2)
1050 || is_ri (insn, op1_brc, op2_brc, &r1, &i2)
1051 || is_ril (insn, op1_brcl, op2_brcl, &r1, &i2)
1052 || is_ril (insn, op1_brasl, op2_brasl, &r2, &i2))
1056 /* An instruction we don't know how to simulate. The only
1057 safe thing to do would be to set every value we're tracking
1058 to 'unknown'. Instead, we'll be optimistic: we assume that
1059 we *can* interpret every instruction that the compiler uses
1060 to manipulate any of the data we're interested in here --
1061 then we can just ignore anything else. */
1064 /* Record the address after the last instruction that changed
1065 the FP, SP, or backlink. Ignore instructions that changed
1066 them back to their original values --- those are probably
1067 restore instructions. (The back chain is never restored,
1070 pv_t sp = data->gpr[S390_SP_REGNUM - S390_R0_REGNUM];
1071 pv_t fp = data->gpr[S390_FRAME_REGNUM - S390_R0_REGNUM];
1073 if ((! pv_is_identical (pre_insn_sp, sp)
1074 && ! pv_is_register_k (sp, S390_SP_REGNUM, 0)
1075 && sp.kind != pvk_unknown)
1076 || (! pv_is_identical (pre_insn_fp, fp)
1077 && ! pv_is_register_k (fp, S390_FRAME_REGNUM, 0)
1078 && fp.kind != pvk_unknown)
1079 || pre_insn_back_chain_saved_p != data->back_chain_saved_p)
1084 /* Record where all the registers were saved. */
1085 pv_area_scan (data->stack, s390_check_for_saved, data);
1087 free_pv_area (data->stack);
1093 /* Advance PC across any function entry prologue instructions to reach
1094 some "real" code. */
1096 s390_skip_prologue (CORE_ADDR pc)
1098 struct s390_prologue_data data;
1100 skip_pc = s390_analyze_prologue (current_gdbarch, pc, (CORE_ADDR)-1, &data);
1101 return skip_pc ? skip_pc : pc;
1104 /* Return true if we are in the functin's epilogue, i.e. after the
1105 instruction that destroyed the function's stack frame. */
1107 s390_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
1109 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1111 /* In frameless functions, there's not frame to destroy and thus
1112 we don't care about the epilogue.
1114 In functions with frame, the epilogue sequence is a pair of
1115 a LM-type instruction that restores (amongst others) the
1116 return register %r14 and the stack pointer %r15, followed
1117 by a branch 'br %r14' --or equivalent-- that effects the
1120 In that situation, this function needs to return 'true' in
1121 exactly one case: when pc points to that branch instruction.
1123 Thus we try to disassemble the one instructions immediately
1124 preceeding pc and check whether it is an LM-type instruction
1125 modifying the stack pointer.
1127 Note that disassembling backwards is not reliable, so there
1128 is a slight chance of false positives here ... */
1131 unsigned int r1, r3, b2;
1135 && !read_memory_nobpt (pc - 4, insn, 4)
1136 && is_rs (insn, op_lm, &r1, &r3, &d2, &b2)
1137 && r3 == S390_SP_REGNUM - S390_R0_REGNUM)
1141 && !read_memory_nobpt (pc - 6, insn, 6)
1142 && is_rsy (insn, op1_lmy, op2_lmy, &r1, &r3, &d2, &b2)
1143 && r3 == S390_SP_REGNUM - S390_R0_REGNUM)
1147 && !read_memory_nobpt (pc - 6, insn, 6)
1148 && is_rsy (insn, op1_lmg, op2_lmg, &r1, &r3, &d2, &b2)
1149 && r3 == S390_SP_REGNUM - S390_R0_REGNUM)
1156 /* Normal stack frames. */
1158 struct s390_unwind_cache {
1161 CORE_ADDR frame_base;
1162 CORE_ADDR local_base;
1164 struct trad_frame_saved_reg *saved_regs;
1168 s390_prologue_frame_unwind_cache (struct frame_info *next_frame,
1169 struct s390_unwind_cache *info)
1171 struct gdbarch *gdbarch = get_frame_arch (next_frame);
1172 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1173 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1174 struct s390_prologue_data data;
1175 pv_t *fp = &data.gpr[S390_FRAME_REGNUM - S390_R0_REGNUM];
1176 pv_t *sp = &data.gpr[S390_SP_REGNUM - S390_R0_REGNUM];
1186 /* Try to find the function start address. If we can't find it, we don't
1187 bother searching for it -- with modern compilers this would be mostly
1188 pointless anyway. Trust that we'll either have valid DWARF-2 CFI data
1189 or else a valid backchain ... */
1190 func = frame_func_unwind (next_frame, NORMAL_FRAME);
1194 /* Try to analyze the prologue. */
1195 result = s390_analyze_prologue (gdbarch, func,
1196 frame_pc_unwind (next_frame), &data);
1200 /* If this was successful, we should have found the instruction that
1201 sets the stack pointer register to the previous value of the stack
1202 pointer minus the frame size. */
1203 if (!pv_is_register (*sp, S390_SP_REGNUM))
1206 /* A frame size of zero at this point can mean either a real
1207 frameless function, or else a failure to find the prologue.
1208 Perform some sanity checks to verify we really have a
1209 frameless function. */
1212 /* If the next frame is a NORMAL_FRAME, this frame *cannot* have frame
1213 size zero. This is only possible if the next frame is a sentinel
1214 frame, a dummy frame, or a signal trampoline frame. */
1215 /* FIXME: cagney/2004-05-01: This sanity check shouldn't be
1216 needed, instead the code should simpliy rely on its
1218 if (get_frame_type (next_frame) == NORMAL_FRAME)
1221 /* If we really have a frameless function, %r14 must be valid
1222 -- in particular, it must point to a different function. */
1223 reg = frame_unwind_register_unsigned (next_frame, S390_RETADDR_REGNUM);
1224 reg = gdbarch_addr_bits_remove (gdbarch, reg) - 1;
1225 if (get_pc_function_start (reg) == func)
1227 /* However, there is one case where it *is* valid for %r14
1228 to point to the same function -- if this is a recursive
1229 call, and we have stopped in the prologue *before* the
1230 stack frame was allocated.
1232 Recognize this case by looking ahead a bit ... */
1234 struct s390_prologue_data data2;
1235 pv_t *sp = &data2.gpr[S390_SP_REGNUM - S390_R0_REGNUM];
1237 if (!(s390_analyze_prologue (gdbarch, func, (CORE_ADDR)-1, &data2)
1238 && pv_is_register (*sp, S390_SP_REGNUM)
1245 /* OK, we've found valid prologue data. */
1248 /* If the frame pointer originally also holds the same value
1249 as the stack pointer, we're probably using it. If it holds
1250 some other value -- even a constant offset -- it is most
1251 likely used as temp register. */
1252 if (pv_is_identical (*sp, *fp))
1253 frame_pointer = S390_FRAME_REGNUM;
1255 frame_pointer = S390_SP_REGNUM;
1257 /* If we've detected a function with stack frame, we'll still have to
1258 treat it as frameless if we're currently within the function epilog
1259 code at a point where the frame pointer has already been restored.
1260 This can only happen in an innermost frame. */
1261 /* FIXME: cagney/2004-05-01: This sanity check shouldn't be needed,
1262 instead the code should simpliy rely on its analysis. */
1263 if (size > 0 && get_frame_type (next_frame) != NORMAL_FRAME)
1265 /* See the comment in s390_in_function_epilogue_p on why this is
1266 not completely reliable ... */
1267 if (s390_in_function_epilogue_p (gdbarch, frame_pc_unwind (next_frame)))
1269 memset (&data, 0, sizeof (data));
1271 frame_pointer = S390_SP_REGNUM;
1275 /* Once we know the frame register and the frame size, we can unwind
1276 the current value of the frame register from the next frame, and
1277 add back the frame size to arrive that the previous frame's
1278 stack pointer value. */
1279 prev_sp = frame_unwind_register_unsigned (next_frame, frame_pointer) + size;
1280 cfa = prev_sp + 16*word_size + 32;
1282 /* Record the addresses of all register spill slots the prologue parser
1283 has recognized. Consider only registers defined as call-saved by the
1284 ABI; for call-clobbered registers the parser may have recognized
1287 for (i = 6; i <= 15; i++)
1288 if (data.gpr_slot[i] != 0)
1289 info->saved_regs[S390_R0_REGNUM + i].addr = cfa - data.gpr_slot[i];
1293 case ABI_LINUX_S390:
1294 if (data.fpr_slot[4] != 0)
1295 info->saved_regs[S390_F4_REGNUM].addr = cfa - data.fpr_slot[4];
1296 if (data.fpr_slot[6] != 0)
1297 info->saved_regs[S390_F6_REGNUM].addr = cfa - data.fpr_slot[6];
1300 case ABI_LINUX_ZSERIES:
1301 for (i = 8; i <= 15; i++)
1302 if (data.fpr_slot[i] != 0)
1303 info->saved_regs[S390_F0_REGNUM + i].addr = cfa - data.fpr_slot[i];
1307 /* Function return will set PC to %r14. */
1308 info->saved_regs[S390_PC_REGNUM] = info->saved_regs[S390_RETADDR_REGNUM];
1310 /* In frameless functions, we unwind simply by moving the return
1311 address to the PC. However, if we actually stored to the
1312 save area, use that -- we might only think the function frameless
1313 because we're in the middle of the prologue ... */
1315 && !trad_frame_addr_p (info->saved_regs, S390_PC_REGNUM))
1317 info->saved_regs[S390_PC_REGNUM].realreg = S390_RETADDR_REGNUM;
1320 /* Another sanity check: unless this is a frameless function,
1321 we should have found spill slots for SP and PC.
1322 If not, we cannot unwind further -- this happens e.g. in
1323 libc's thread_start routine. */
1326 if (!trad_frame_addr_p (info->saved_regs, S390_SP_REGNUM)
1327 || !trad_frame_addr_p (info->saved_regs, S390_PC_REGNUM))
1331 /* We use the current value of the frame register as local_base,
1332 and the top of the register save area as frame_base. */
1335 info->frame_base = prev_sp + 16*word_size + 32;
1336 info->local_base = prev_sp - size;
1344 s390_backchain_frame_unwind_cache (struct frame_info *next_frame,
1345 struct s390_unwind_cache *info)
1347 struct gdbarch *gdbarch = get_frame_arch (next_frame);
1348 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1349 CORE_ADDR backchain;
1353 /* Get the backchain. */
1354 reg = frame_unwind_register_unsigned (next_frame, S390_SP_REGNUM);
1355 backchain = read_memory_unsigned_integer (reg, word_size);
1357 /* A zero backchain terminates the frame chain. As additional
1358 sanity check, let's verify that the spill slot for SP in the
1359 save area pointed to by the backchain in fact links back to
1362 && safe_read_memory_integer (backchain + 15*word_size, word_size, &sp)
1363 && (CORE_ADDR)sp == backchain)
1365 /* We don't know which registers were saved, but it will have
1366 to be at least %r14 and %r15. This will allow us to continue
1367 unwinding, but other prev-frame registers may be incorrect ... */
1368 info->saved_regs[S390_SP_REGNUM].addr = backchain + 15*word_size;
1369 info->saved_regs[S390_RETADDR_REGNUM].addr = backchain + 14*word_size;
1371 /* Function return will set PC to %r14. */
1372 info->saved_regs[S390_PC_REGNUM] = info->saved_regs[S390_RETADDR_REGNUM];
1374 /* We use the current value of the frame register as local_base,
1375 and the top of the register save area as frame_base. */
1376 info->frame_base = backchain + 16*word_size + 32;
1377 info->local_base = reg;
1380 info->func = frame_pc_unwind (next_frame);
1383 static struct s390_unwind_cache *
1384 s390_frame_unwind_cache (struct frame_info *next_frame,
1385 void **this_prologue_cache)
1387 struct s390_unwind_cache *info;
1388 if (*this_prologue_cache)
1389 return *this_prologue_cache;
1391 info = FRAME_OBSTACK_ZALLOC (struct s390_unwind_cache);
1392 *this_prologue_cache = info;
1393 info->saved_regs = trad_frame_alloc_saved_regs (next_frame);
1395 info->frame_base = -1;
1396 info->local_base = -1;
1398 /* Try to use prologue analysis to fill the unwind cache.
1399 If this fails, fall back to reading the stack backchain. */
1400 if (!s390_prologue_frame_unwind_cache (next_frame, info))
1401 s390_backchain_frame_unwind_cache (next_frame, info);
1407 s390_frame_this_id (struct frame_info *next_frame,
1408 void **this_prologue_cache,
1409 struct frame_id *this_id)
1411 struct s390_unwind_cache *info
1412 = s390_frame_unwind_cache (next_frame, this_prologue_cache);
1414 if (info->frame_base == -1)
1417 *this_id = frame_id_build (info->frame_base, info->func);
1421 s390_frame_prev_register (struct frame_info *next_frame,
1422 void **this_prologue_cache,
1423 int regnum, int *optimizedp,
1424 enum lval_type *lvalp, CORE_ADDR *addrp,
1425 int *realnump, gdb_byte *bufferp)
1427 struct s390_unwind_cache *info
1428 = s390_frame_unwind_cache (next_frame, this_prologue_cache);
1429 trad_frame_get_prev_register (next_frame, info->saved_regs, regnum,
1430 optimizedp, lvalp, addrp, realnump, bufferp);
1433 static const struct frame_unwind s390_frame_unwind = {
1436 s390_frame_prev_register
1439 static const struct frame_unwind *
1440 s390_frame_sniffer (struct frame_info *next_frame)
1442 return &s390_frame_unwind;
1446 /* Code stubs and their stack frames. For things like PLTs and NULL
1447 function calls (where there is no true frame and the return address
1448 is in the RETADDR register). */
1450 struct s390_stub_unwind_cache
1452 CORE_ADDR frame_base;
1453 struct trad_frame_saved_reg *saved_regs;
1456 static struct s390_stub_unwind_cache *
1457 s390_stub_frame_unwind_cache (struct frame_info *next_frame,
1458 void **this_prologue_cache)
1460 struct gdbarch *gdbarch = get_frame_arch (next_frame);
1461 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1462 struct s390_stub_unwind_cache *info;
1465 if (*this_prologue_cache)
1466 return *this_prologue_cache;
1468 info = FRAME_OBSTACK_ZALLOC (struct s390_stub_unwind_cache);
1469 *this_prologue_cache = info;
1470 info->saved_regs = trad_frame_alloc_saved_regs (next_frame);
1472 /* The return address is in register %r14. */
1473 info->saved_regs[S390_PC_REGNUM].realreg = S390_RETADDR_REGNUM;
1475 /* Retrieve stack pointer and determine our frame base. */
1476 reg = frame_unwind_register_unsigned (next_frame, S390_SP_REGNUM);
1477 info->frame_base = reg + 16*word_size + 32;
1483 s390_stub_frame_this_id (struct frame_info *next_frame,
1484 void **this_prologue_cache,
1485 struct frame_id *this_id)
1487 struct s390_stub_unwind_cache *info
1488 = s390_stub_frame_unwind_cache (next_frame, this_prologue_cache);
1489 *this_id = frame_id_build (info->frame_base, frame_pc_unwind (next_frame));
1493 s390_stub_frame_prev_register (struct frame_info *next_frame,
1494 void **this_prologue_cache,
1495 int regnum, int *optimizedp,
1496 enum lval_type *lvalp, CORE_ADDR *addrp,
1497 int *realnump, gdb_byte *bufferp)
1499 struct s390_stub_unwind_cache *info
1500 = s390_stub_frame_unwind_cache (next_frame, this_prologue_cache);
1501 trad_frame_get_prev_register (next_frame, info->saved_regs, regnum,
1502 optimizedp, lvalp, addrp, realnump, bufferp);
1505 static const struct frame_unwind s390_stub_frame_unwind = {
1507 s390_stub_frame_this_id,
1508 s390_stub_frame_prev_register
1511 static const struct frame_unwind *
1512 s390_stub_frame_sniffer (struct frame_info *next_frame)
1514 CORE_ADDR addr_in_block;
1515 bfd_byte insn[S390_MAX_INSTR_SIZE];
1517 /* If the current PC points to non-readable memory, we assume we
1518 have trapped due to an invalid function pointer call. We handle
1519 the non-existing current function like a PLT stub. */
1520 addr_in_block = frame_unwind_address_in_block (next_frame, NORMAL_FRAME);
1521 if (in_plt_section (addr_in_block, NULL)
1522 || s390_readinstruction (insn, frame_pc_unwind (next_frame)) < 0)
1523 return &s390_stub_frame_unwind;
1528 /* Signal trampoline stack frames. */
1530 struct s390_sigtramp_unwind_cache {
1531 CORE_ADDR frame_base;
1532 struct trad_frame_saved_reg *saved_regs;
1535 static struct s390_sigtramp_unwind_cache *
1536 s390_sigtramp_frame_unwind_cache (struct frame_info *next_frame,
1537 void **this_prologue_cache)
1539 struct gdbarch *gdbarch = get_frame_arch (next_frame);
1540 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1541 struct s390_sigtramp_unwind_cache *info;
1542 ULONGEST this_sp, prev_sp;
1543 CORE_ADDR next_ra, next_cfa, sigreg_ptr;
1546 if (*this_prologue_cache)
1547 return *this_prologue_cache;
1549 info = FRAME_OBSTACK_ZALLOC (struct s390_sigtramp_unwind_cache);
1550 *this_prologue_cache = info;
1551 info->saved_regs = trad_frame_alloc_saved_regs (next_frame);
1553 this_sp = frame_unwind_register_unsigned (next_frame, S390_SP_REGNUM);
1554 next_ra = frame_pc_unwind (next_frame);
1555 next_cfa = this_sp + 16*word_size + 32;
1557 /* New-style RT frame:
1558 retcode + alignment (8 bytes)
1560 ucontext (contains sigregs at offset 5 words) */
1561 if (next_ra == next_cfa)
1563 sigreg_ptr = next_cfa + 8 + 128 + align_up (5*word_size, 8);
1566 /* Old-style RT frame and all non-RT frames:
1567 old signal mask (8 bytes)
1568 pointer to sigregs */
1571 sigreg_ptr = read_memory_unsigned_integer (next_cfa + 8, word_size);
1574 /* The sigregs structure looks like this:
1583 /* Let's ignore the PSW mask, it will not be restored anyway. */
1584 sigreg_ptr += word_size;
1586 /* Next comes the PSW address. */
1587 info->saved_regs[S390_PC_REGNUM].addr = sigreg_ptr;
1588 sigreg_ptr += word_size;
1590 /* Then the GPRs. */
1591 for (i = 0; i < 16; i++)
1593 info->saved_regs[S390_R0_REGNUM + i].addr = sigreg_ptr;
1594 sigreg_ptr += word_size;
1597 /* Then the ACRs. */
1598 for (i = 0; i < 16; i++)
1600 info->saved_regs[S390_A0_REGNUM + i].addr = sigreg_ptr;
1604 /* The floating-point control word. */
1605 info->saved_regs[S390_FPC_REGNUM].addr = sigreg_ptr;
1608 /* And finally the FPRs. */
1609 for (i = 0; i < 16; i++)
1611 info->saved_regs[S390_F0_REGNUM + i].addr = sigreg_ptr;
1615 /* Restore the previous frame's SP. */
1616 prev_sp = read_memory_unsigned_integer (
1617 info->saved_regs[S390_SP_REGNUM].addr,
1620 /* Determine our frame base. */
1621 info->frame_base = prev_sp + 16*word_size + 32;
1627 s390_sigtramp_frame_this_id (struct frame_info *next_frame,
1628 void **this_prologue_cache,
1629 struct frame_id *this_id)
1631 struct s390_sigtramp_unwind_cache *info
1632 = s390_sigtramp_frame_unwind_cache (next_frame, this_prologue_cache);
1633 *this_id = frame_id_build (info->frame_base, frame_pc_unwind (next_frame));
1637 s390_sigtramp_frame_prev_register (struct frame_info *next_frame,
1638 void **this_prologue_cache,
1639 int regnum, int *optimizedp,
1640 enum lval_type *lvalp, CORE_ADDR *addrp,
1641 int *realnump, gdb_byte *bufferp)
1643 struct s390_sigtramp_unwind_cache *info
1644 = s390_sigtramp_frame_unwind_cache (next_frame, this_prologue_cache);
1645 trad_frame_get_prev_register (next_frame, info->saved_regs, regnum,
1646 optimizedp, lvalp, addrp, realnump, bufferp);
1649 static const struct frame_unwind s390_sigtramp_frame_unwind = {
1651 s390_sigtramp_frame_this_id,
1652 s390_sigtramp_frame_prev_register
1655 static const struct frame_unwind *
1656 s390_sigtramp_frame_sniffer (struct frame_info *next_frame)
1658 CORE_ADDR pc = frame_pc_unwind (next_frame);
1659 bfd_byte sigreturn[2];
1661 if (read_memory_nobpt (pc, sigreturn, 2))
1664 if (sigreturn[0] != 0x0a /* svc */)
1667 if (sigreturn[1] != 119 /* sigreturn */
1668 && sigreturn[1] != 173 /* rt_sigreturn */)
1671 return &s390_sigtramp_frame_unwind;
1675 /* Frame base handling. */
1678 s390_frame_base_address (struct frame_info *next_frame, void **this_cache)
1680 struct s390_unwind_cache *info
1681 = s390_frame_unwind_cache (next_frame, this_cache);
1682 return info->frame_base;
1686 s390_local_base_address (struct frame_info *next_frame, void **this_cache)
1688 struct s390_unwind_cache *info
1689 = s390_frame_unwind_cache (next_frame, this_cache);
1690 return info->local_base;
1693 static const struct frame_base s390_frame_base = {
1695 s390_frame_base_address,
1696 s390_local_base_address,
1697 s390_local_base_address
1701 s390_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
1704 pc = frame_unwind_register_unsigned (next_frame, S390_PC_REGNUM);
1705 return gdbarch_addr_bits_remove (gdbarch, pc);
1709 s390_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
1712 sp = frame_unwind_register_unsigned (next_frame, S390_SP_REGNUM);
1713 return gdbarch_addr_bits_remove (gdbarch, sp);
1717 /* DWARF-2 frame support. */
1720 s390_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
1721 struct dwarf2_frame_state_reg *reg,
1722 struct frame_info *next_frame)
1724 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1728 case ABI_LINUX_S390:
1729 /* Call-saved registers. */
1730 if ((regnum >= S390_R6_REGNUM && regnum <= S390_R15_REGNUM)
1731 || regnum == S390_F4_REGNUM
1732 || regnum == S390_F6_REGNUM)
1733 reg->how = DWARF2_FRAME_REG_SAME_VALUE;
1735 /* Call-clobbered registers. */
1736 else if ((regnum >= S390_R0_REGNUM && regnum <= S390_R5_REGNUM)
1737 || (regnum >= S390_F0_REGNUM && regnum <= S390_F15_REGNUM
1738 && regnum != S390_F4_REGNUM && regnum != S390_F6_REGNUM))
1739 reg->how = DWARF2_FRAME_REG_UNDEFINED;
1741 /* The return address column. */
1742 else if (regnum == S390_PC_REGNUM)
1743 reg->how = DWARF2_FRAME_REG_RA;
1746 case ABI_LINUX_ZSERIES:
1747 /* Call-saved registers. */
1748 if ((regnum >= S390_R6_REGNUM && regnum <= S390_R15_REGNUM)
1749 || (regnum >= S390_F8_REGNUM && regnum <= S390_F15_REGNUM))
1750 reg->how = DWARF2_FRAME_REG_SAME_VALUE;
1752 /* Call-clobbered registers. */
1753 else if ((regnum >= S390_R0_REGNUM && regnum <= S390_R5_REGNUM)
1754 || (regnum >= S390_F0_REGNUM && regnum <= S390_F7_REGNUM))
1755 reg->how = DWARF2_FRAME_REG_UNDEFINED;
1757 /* The return address column. */
1758 else if (regnum == S390_PC_REGNUM)
1759 reg->how = DWARF2_FRAME_REG_RA;
1765 /* Dummy function calls. */
1767 /* Return non-zero if TYPE is an integer-like type, zero otherwise.
1768 "Integer-like" types are those that should be passed the way
1769 integers are: integers, enums, ranges, characters, and booleans. */
1771 is_integer_like (struct type *type)
1773 enum type_code code = TYPE_CODE (type);
1775 return (code == TYPE_CODE_INT
1776 || code == TYPE_CODE_ENUM
1777 || code == TYPE_CODE_RANGE
1778 || code == TYPE_CODE_CHAR
1779 || code == TYPE_CODE_BOOL);
1782 /* Return non-zero if TYPE is a pointer-like type, zero otherwise.
1783 "Pointer-like" types are those that should be passed the way
1784 pointers are: pointers and references. */
1786 is_pointer_like (struct type *type)
1788 enum type_code code = TYPE_CODE (type);
1790 return (code == TYPE_CODE_PTR
1791 || code == TYPE_CODE_REF);
1795 /* Return non-zero if TYPE is a `float singleton' or `double
1796 singleton', zero otherwise.
1798 A `T singleton' is a struct type with one member, whose type is
1799 either T or a `T singleton'. So, the following are all float
1803 struct { struct { float x; } x; };
1804 struct { struct { struct { float x; } x; } x; };
1808 All such structures are passed as if they were floats or doubles,
1809 as the (revised) ABI says. */
1811 is_float_singleton (struct type *type)
1813 if (TYPE_CODE (type) == TYPE_CODE_STRUCT && TYPE_NFIELDS (type) == 1)
1815 struct type *singleton_type = TYPE_FIELD_TYPE (type, 0);
1816 CHECK_TYPEDEF (singleton_type);
1818 return (TYPE_CODE (singleton_type) == TYPE_CODE_FLT
1819 || is_float_singleton (singleton_type));
1826 /* Return non-zero if TYPE is a struct-like type, zero otherwise.
1827 "Struct-like" types are those that should be passed as structs are:
1830 As an odd quirk, not mentioned in the ABI, GCC passes float and
1831 double singletons as if they were a plain float, double, etc. (The
1832 corresponding union types are handled normally.) So we exclude
1833 those types here. *shrug* */
1835 is_struct_like (struct type *type)
1837 enum type_code code = TYPE_CODE (type);
1839 return (code == TYPE_CODE_UNION
1840 || (code == TYPE_CODE_STRUCT && ! is_float_singleton (type)));
1844 /* Return non-zero if TYPE is a float-like type, zero otherwise.
1845 "Float-like" types are those that should be passed as
1846 floating-point values are.
1848 You'd think this would just be floats, doubles, long doubles, etc.
1849 But as an odd quirk, not mentioned in the ABI, GCC passes float and
1850 double singletons as if they were a plain float, double, etc. (The
1851 corresponding union types are handled normally.) So we include
1852 those types here. *shrug* */
1854 is_float_like (struct type *type)
1856 return (TYPE_CODE (type) == TYPE_CODE_FLT
1857 || is_float_singleton (type));
1862 is_power_of_two (unsigned int n)
1864 return ((n & (n - 1)) == 0);
1867 /* Return non-zero if TYPE should be passed as a pointer to a copy,
1870 s390_function_arg_pass_by_reference (struct type *type)
1872 unsigned length = TYPE_LENGTH (type);
1876 /* FIXME: All complex and vector types are also returned by reference. */
1877 return is_struct_like (type) && !is_power_of_two (length);
1880 /* Return non-zero if TYPE should be passed in a float register
1883 s390_function_arg_float (struct type *type)
1885 unsigned length = TYPE_LENGTH (type);
1889 return is_float_like (type);
1892 /* Return non-zero if TYPE should be passed in an integer register
1893 (or a pair of integer registers) if possible. */
1895 s390_function_arg_integer (struct type *type)
1897 unsigned length = TYPE_LENGTH (type);
1901 return is_integer_like (type)
1902 || is_pointer_like (type)
1903 || (is_struct_like (type) && is_power_of_two (length));
1906 /* Return ARG, a `SIMPLE_ARG', sign-extended or zero-extended to a full
1907 word as required for the ABI. */
1909 extend_simple_arg (struct value *arg)
1911 struct type *type = value_type (arg);
1913 /* Even structs get passed in the least significant bits of the
1914 register / memory word. It's not really right to extract them as
1915 an integer, but it does take care of the extension. */
1916 if (TYPE_UNSIGNED (type))
1917 return extract_unsigned_integer (value_contents (arg),
1918 TYPE_LENGTH (type));
1920 return extract_signed_integer (value_contents (arg),
1921 TYPE_LENGTH (type));
1925 /* Return the alignment required by TYPE. */
1927 alignment_of (struct type *type)
1931 if (is_integer_like (type)
1932 || is_pointer_like (type)
1933 || TYPE_CODE (type) == TYPE_CODE_FLT)
1934 alignment = TYPE_LENGTH (type);
1935 else if (TYPE_CODE (type) == TYPE_CODE_STRUCT
1936 || TYPE_CODE (type) == TYPE_CODE_UNION)
1941 for (i = 0; i < TYPE_NFIELDS (type); i++)
1943 int field_alignment = alignment_of (TYPE_FIELD_TYPE (type, i));
1945 if (field_alignment > alignment)
1946 alignment = field_alignment;
1952 /* Check that everything we ever return is a power of two. Lots of
1953 code doesn't want to deal with aligning things to arbitrary
1955 gdb_assert ((alignment & (alignment - 1)) == 0);
1961 /* Put the actual parameter values pointed to by ARGS[0..NARGS-1] in
1962 place to be passed to a function, as specified by the "GNU/Linux
1963 for S/390 ELF Application Binary Interface Supplement".
1965 SP is the current stack pointer. We must put arguments, links,
1966 padding, etc. whereever they belong, and return the new stack
1969 If STRUCT_RETURN is non-zero, then the function we're calling is
1970 going to return a structure by value; STRUCT_ADDR is the address of
1971 a block we've allocated for it on the stack.
1973 Our caller has taken care of any type promotions needed to satisfy
1974 prototypes or the old K&R argument-passing rules. */
1976 s390_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
1977 struct regcache *regcache, CORE_ADDR bp_addr,
1978 int nargs, struct value **args, CORE_ADDR sp,
1979 int struct_return, CORE_ADDR struct_addr)
1981 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1982 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1986 /* If the i'th argument is passed as a reference to a copy, then
1987 copy_addr[i] is the address of the copy we made. */
1988 CORE_ADDR *copy_addr = alloca (nargs * sizeof (CORE_ADDR));
1990 /* Build the reference-to-copy area. */
1991 for (i = 0; i < nargs; i++)
1993 struct value *arg = args[i];
1994 struct type *type = value_type (arg);
1995 unsigned length = TYPE_LENGTH (type);
1997 if (s390_function_arg_pass_by_reference (type))
2000 sp = align_down (sp, alignment_of (type));
2001 write_memory (sp, value_contents (arg), length);
2006 /* Reserve space for the parameter area. As a conservative
2007 simplification, we assume that everything will be passed on the
2008 stack. Since every argument larger than 8 bytes will be
2009 passed by reference, we use this simple upper bound. */
2012 /* After all that, make sure it's still aligned on an eight-byte
2014 sp = align_down (sp, 8);
2016 /* Finally, place the actual parameters, working from SP towards
2017 higher addresses. The code above is supposed to reserve enough
2022 CORE_ADDR starg = sp;
2024 /* A struct is returned using general register 2. */
2027 regcache_cooked_write_unsigned (regcache, S390_R0_REGNUM + gr,
2032 for (i = 0; i < nargs; i++)
2034 struct value *arg = args[i];
2035 struct type *type = value_type (arg);
2036 unsigned length = TYPE_LENGTH (type);
2038 if (s390_function_arg_pass_by_reference (type))
2042 regcache_cooked_write_unsigned (regcache, S390_R0_REGNUM + gr,
2048 write_memory_unsigned_integer (starg, word_size, copy_addr[i]);
2052 else if (s390_function_arg_float (type))
2054 /* The GNU/Linux for S/390 ABI uses FPRs 0 and 2 to pass arguments,
2055 the GNU/Linux for zSeries ABI uses 0, 2, 4, and 6. */
2056 if (fr <= (tdep->abi == ABI_LINUX_S390 ? 2 : 6))
2058 /* When we store a single-precision value in an FP register,
2059 it occupies the leftmost bits. */
2060 regcache_cooked_write_part (regcache, S390_F0_REGNUM + fr,
2061 0, length, value_contents (arg));
2066 /* When we store a single-precision value in a stack slot,
2067 it occupies the rightmost bits. */
2068 starg = align_up (starg + length, word_size);
2069 write_memory (starg - length, value_contents (arg), length);
2072 else if (s390_function_arg_integer (type) && length <= word_size)
2076 /* Integer arguments are always extended to word size. */
2077 regcache_cooked_write_signed (regcache, S390_R0_REGNUM + gr,
2078 extend_simple_arg (arg));
2083 /* Integer arguments are always extended to word size. */
2084 write_memory_signed_integer (starg, word_size,
2085 extend_simple_arg (arg));
2089 else if (s390_function_arg_integer (type) && length == 2*word_size)
2093 regcache_cooked_write (regcache, S390_R0_REGNUM + gr,
2094 value_contents (arg));
2095 regcache_cooked_write (regcache, S390_R0_REGNUM + gr + 1,
2096 value_contents (arg) + word_size);
2101 /* If we skipped r6 because we couldn't fit a DOUBLE_ARG
2102 in it, then don't go back and use it again later. */
2105 write_memory (starg, value_contents (arg), length);
2110 internal_error (__FILE__, __LINE__, _("unknown argument type"));
2114 /* Allocate the standard frame areas: the register save area, the
2115 word reserved for the compiler (which seems kind of meaningless),
2116 and the back chain pointer. */
2117 sp -= 16*word_size + 32;
2119 /* Store return address. */
2120 regcache_cooked_write_unsigned (regcache, S390_RETADDR_REGNUM, bp_addr);
2122 /* Store updated stack pointer. */
2123 regcache_cooked_write_unsigned (regcache, S390_SP_REGNUM, sp);
2125 /* We need to return the 'stack part' of the frame ID,
2126 which is actually the top of the register save area. */
2127 return sp + 16*word_size + 32;
2130 /* Assuming NEXT_FRAME->prev is a dummy, return the frame ID of that
2131 dummy frame. The frame ID's base needs to match the TOS value
2132 returned by push_dummy_call, and the PC match the dummy frame's
2134 static struct frame_id
2135 s390_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
2137 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
2138 CORE_ADDR sp = s390_unwind_sp (gdbarch, next_frame);
2140 return frame_id_build (sp + 16*word_size + 32,
2141 frame_pc_unwind (next_frame));
2145 s390_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
2147 /* Both the 32- and 64-bit ABI's say that the stack pointer should
2148 always be aligned on an eight-byte boundary. */
2153 /* Function return value access. */
2155 static enum return_value_convention
2156 s390_return_value_convention (struct gdbarch *gdbarch, struct type *type)
2158 int length = TYPE_LENGTH (type);
2160 return RETURN_VALUE_STRUCT_CONVENTION;
2162 switch (TYPE_CODE (type))
2164 case TYPE_CODE_STRUCT:
2165 case TYPE_CODE_UNION:
2166 case TYPE_CODE_ARRAY:
2167 return RETURN_VALUE_STRUCT_CONVENTION;
2170 return RETURN_VALUE_REGISTER_CONVENTION;
2174 static enum return_value_convention
2175 s390_return_value (struct gdbarch *gdbarch, struct type *type,
2176 struct regcache *regcache, gdb_byte *out,
2179 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
2180 int length = TYPE_LENGTH (type);
2181 enum return_value_convention rvc =
2182 s390_return_value_convention (gdbarch, type);
2187 case RETURN_VALUE_REGISTER_CONVENTION:
2188 if (TYPE_CODE (type) == TYPE_CODE_FLT)
2190 /* When we store a single-precision value in an FP register,
2191 it occupies the leftmost bits. */
2192 regcache_cooked_write_part (regcache, S390_F0_REGNUM,
2195 else if (length <= word_size)
2197 /* Integer arguments are always extended to word size. */
2198 if (TYPE_UNSIGNED (type))
2199 regcache_cooked_write_unsigned (regcache, S390_R2_REGNUM,
2200 extract_unsigned_integer (in, length));
2202 regcache_cooked_write_signed (regcache, S390_R2_REGNUM,
2203 extract_signed_integer (in, length));
2205 else if (length == 2*word_size)
2207 regcache_cooked_write (regcache, S390_R2_REGNUM, in);
2208 regcache_cooked_write (regcache, S390_R3_REGNUM, in + word_size);
2211 internal_error (__FILE__, __LINE__, _("invalid return type"));
2214 case RETURN_VALUE_STRUCT_CONVENTION:
2215 error (_("Cannot set function return value."));
2223 case RETURN_VALUE_REGISTER_CONVENTION:
2224 if (TYPE_CODE (type) == TYPE_CODE_FLT)
2226 /* When we store a single-precision value in an FP register,
2227 it occupies the leftmost bits. */
2228 regcache_cooked_read_part (regcache, S390_F0_REGNUM,
2231 else if (length <= word_size)
2233 /* Integer arguments occupy the rightmost bits. */
2234 regcache_cooked_read_part (regcache, S390_R2_REGNUM,
2235 word_size - length, length, out);
2237 else if (length == 2*word_size)
2239 regcache_cooked_read (regcache, S390_R2_REGNUM, out);
2240 regcache_cooked_read (regcache, S390_R3_REGNUM, out + word_size);
2243 internal_error (__FILE__, __LINE__, _("invalid return type"));
2246 case RETURN_VALUE_STRUCT_CONVENTION:
2247 error (_("Function return value unknown."));
2258 static const gdb_byte *
2259 s390_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
2261 static const gdb_byte breakpoint[] = { 0x0, 0x1 };
2263 *lenptr = sizeof (breakpoint);
2268 /* Address handling. */
2271 s390_addr_bits_remove (CORE_ADDR addr)
2273 return addr & 0x7fffffff;
2277 s390_address_class_type_flags (int byte_size, int dwarf2_addr_class)
2280 return TYPE_FLAG_ADDRESS_CLASS_1;
2286 s390_address_class_type_flags_to_name (struct gdbarch *gdbarch, int type_flags)
2288 if (type_flags & TYPE_FLAG_ADDRESS_CLASS_1)
2295 s390_address_class_name_to_type_flags (struct gdbarch *gdbarch, const char *name,
2296 int *type_flags_ptr)
2298 if (strcmp (name, "mode32") == 0)
2300 *type_flags_ptr = TYPE_FLAG_ADDRESS_CLASS_1;
2307 /* Set up gdbarch struct. */
2309 static struct gdbarch *
2310 s390_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
2312 struct gdbarch *gdbarch;
2313 struct gdbarch_tdep *tdep;
2315 /* First see if there is already a gdbarch that can satisfy the request. */
2316 arches = gdbarch_list_lookup_by_info (arches, &info);
2318 return arches->gdbarch;
2320 /* None found: is the request for a s390 architecture? */
2321 if (info.bfd_arch_info->arch != bfd_arch_s390)
2322 return NULL; /* No; then it's not for us. */
2324 /* Yes: create a new gdbarch for the specified machine type. */
2325 tdep = XCALLOC (1, struct gdbarch_tdep);
2326 gdbarch = gdbarch_alloc (&info, tdep);
2328 set_gdbarch_believe_pcc_promotion (gdbarch, 0);
2329 set_gdbarch_char_signed (gdbarch, 0);
2331 /* Amount PC must be decremented by after a breakpoint. This is
2332 often the number of bytes returned by gdbarch_breakpoint_from_pc but not
2334 set_gdbarch_decr_pc_after_break (gdbarch, 2);
2335 /* Stack grows downward. */
2336 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
2337 set_gdbarch_breakpoint_from_pc (gdbarch, s390_breakpoint_from_pc);
2338 set_gdbarch_skip_prologue (gdbarch, s390_skip_prologue);
2339 set_gdbarch_in_function_epilogue_p (gdbarch, s390_in_function_epilogue_p);
2341 set_gdbarch_pc_regnum (gdbarch, S390_PC_REGNUM);
2342 set_gdbarch_sp_regnum (gdbarch, S390_SP_REGNUM);
2343 set_gdbarch_fp0_regnum (gdbarch, S390_F0_REGNUM);
2344 set_gdbarch_num_regs (gdbarch, S390_NUM_REGS);
2345 set_gdbarch_num_pseudo_regs (gdbarch, S390_NUM_PSEUDO_REGS);
2346 set_gdbarch_register_name (gdbarch, s390_register_name);
2347 set_gdbarch_register_type (gdbarch, s390_register_type);
2348 set_gdbarch_stab_reg_to_regnum (gdbarch, s390_dwarf_reg_to_regnum);
2349 set_gdbarch_dwarf_reg_to_regnum (gdbarch, s390_dwarf_reg_to_regnum);
2350 set_gdbarch_dwarf2_reg_to_regnum (gdbarch, s390_dwarf_reg_to_regnum);
2351 set_gdbarch_value_from_register (gdbarch, s390_value_from_register);
2352 set_gdbarch_register_reggroup_p (gdbarch, s390_register_reggroup_p);
2353 set_gdbarch_regset_from_core_section (gdbarch,
2354 s390_regset_from_core_section);
2356 /* Inferior function calls. */
2357 set_gdbarch_push_dummy_call (gdbarch, s390_push_dummy_call);
2358 set_gdbarch_unwind_dummy_id (gdbarch, s390_unwind_dummy_id);
2359 set_gdbarch_frame_align (gdbarch, s390_frame_align);
2360 set_gdbarch_return_value (gdbarch, s390_return_value);
2362 /* Frame handling. */
2363 dwarf2_frame_set_init_reg (gdbarch, s390_dwarf2_frame_init_reg);
2364 frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer);
2365 frame_base_append_sniffer (gdbarch, dwarf2_frame_base_sniffer);
2366 frame_unwind_append_sniffer (gdbarch, s390_stub_frame_sniffer);
2367 frame_unwind_append_sniffer (gdbarch, s390_sigtramp_frame_sniffer);
2368 frame_unwind_append_sniffer (gdbarch, s390_frame_sniffer);
2369 frame_base_set_default (gdbarch, &s390_frame_base);
2370 set_gdbarch_unwind_pc (gdbarch, s390_unwind_pc);
2371 set_gdbarch_unwind_sp (gdbarch, s390_unwind_sp);
2373 switch (info.bfd_arch_info->mach)
2375 case bfd_mach_s390_31:
2376 tdep->abi = ABI_LINUX_S390;
2378 tdep->gregset = &s390_gregset;
2379 tdep->sizeof_gregset = s390_sizeof_gregset;
2380 tdep->fpregset = &s390_fpregset;
2381 tdep->sizeof_fpregset = s390_sizeof_fpregset;
2383 set_gdbarch_addr_bits_remove (gdbarch, s390_addr_bits_remove);
2384 set_gdbarch_pseudo_register_read (gdbarch, s390_pseudo_register_read);
2385 set_gdbarch_pseudo_register_write (gdbarch, s390_pseudo_register_write);
2386 set_solib_svr4_fetch_link_map_offsets
2387 (gdbarch, svr4_ilp32_fetch_link_map_offsets);
2390 case bfd_mach_s390_64:
2391 tdep->abi = ABI_LINUX_ZSERIES;
2393 tdep->gregset = &s390x_gregset;
2394 tdep->sizeof_gregset = s390x_sizeof_gregset;
2395 tdep->fpregset = &s390_fpregset;
2396 tdep->sizeof_fpregset = s390_sizeof_fpregset;
2398 set_gdbarch_long_bit (gdbarch, 64);
2399 set_gdbarch_long_long_bit (gdbarch, 64);
2400 set_gdbarch_ptr_bit (gdbarch, 64);
2401 set_gdbarch_pseudo_register_read (gdbarch, s390x_pseudo_register_read);
2402 set_gdbarch_pseudo_register_write (gdbarch, s390x_pseudo_register_write);
2403 set_solib_svr4_fetch_link_map_offsets
2404 (gdbarch, svr4_lp64_fetch_link_map_offsets);
2405 set_gdbarch_address_class_type_flags (gdbarch,
2406 s390_address_class_type_flags);
2407 set_gdbarch_address_class_type_flags_to_name (gdbarch,
2408 s390_address_class_type_flags_to_name);
2409 set_gdbarch_address_class_name_to_type_flags (gdbarch,
2410 s390_address_class_name_to_type_flags);
2414 set_gdbarch_print_insn (gdbarch, print_insn_s390);
2416 set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
2418 /* Enable TLS support. */
2419 set_gdbarch_fetch_tls_load_module_address (gdbarch,
2420 svr4_fetch_objfile_link_map);
2427 extern initialize_file_ftype _initialize_s390_tdep; /* -Wmissing-prototypes */
2430 _initialize_s390_tdep (void)
2433 /* Hook us into the gdbarch mechanism. */
2434 register_gdbarch_init (bfd_arch_s390, s390_gdbarch_init);