1 /* Target-dependent code for GDB, the GNU debugger.
3 Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
4 2011 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"
46 #include "linux-tdep.h"
47 #include "s390-tdep.h"
49 #include "features/s390-linux32.c"
50 #include "features/s390-linux64.c"
51 #include "features/s390x-linux64.c"
54 /* The tdep structure. */
59 enum { ABI_LINUX_S390, ABI_LINUX_ZSERIES } abi;
61 /* Pseudo register numbers. */
66 /* Core file register sets. */
67 const struct regset *gregset;
70 const struct regset *fpregset;
75 /* ABI call-saved register information. */
78 s390_register_call_saved (struct gdbarch *gdbarch, int regnum)
80 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
85 if ((regnum >= S390_R6_REGNUM && regnum <= S390_R15_REGNUM)
86 || regnum == S390_F4_REGNUM || regnum == S390_F6_REGNUM
87 || regnum == S390_A0_REGNUM)
92 case ABI_LINUX_ZSERIES:
93 if ((regnum >= S390_R6_REGNUM && regnum <= S390_R15_REGNUM)
94 || (regnum >= S390_F8_REGNUM && regnum <= S390_F15_REGNUM)
95 || (regnum >= S390_A0_REGNUM && regnum <= S390_A1_REGNUM))
105 /* DWARF Register Mapping. */
107 static int s390_dwarf_regmap[] =
109 /* General Purpose Registers. */
110 S390_R0_REGNUM, S390_R1_REGNUM, S390_R2_REGNUM, S390_R3_REGNUM,
111 S390_R4_REGNUM, S390_R5_REGNUM, S390_R6_REGNUM, S390_R7_REGNUM,
112 S390_R8_REGNUM, S390_R9_REGNUM, S390_R10_REGNUM, S390_R11_REGNUM,
113 S390_R12_REGNUM, S390_R13_REGNUM, S390_R14_REGNUM, S390_R15_REGNUM,
115 /* Floating Point Registers. */
116 S390_F0_REGNUM, S390_F2_REGNUM, S390_F4_REGNUM, S390_F6_REGNUM,
117 S390_F1_REGNUM, S390_F3_REGNUM, S390_F5_REGNUM, S390_F7_REGNUM,
118 S390_F8_REGNUM, S390_F10_REGNUM, S390_F12_REGNUM, S390_F14_REGNUM,
119 S390_F9_REGNUM, S390_F11_REGNUM, S390_F13_REGNUM, S390_F15_REGNUM,
121 /* Control Registers (not mapped). */
122 -1, -1, -1, -1, -1, -1, -1, -1,
123 -1, -1, -1, -1, -1, -1, -1, -1,
125 /* Access Registers. */
126 S390_A0_REGNUM, S390_A1_REGNUM, S390_A2_REGNUM, S390_A3_REGNUM,
127 S390_A4_REGNUM, S390_A5_REGNUM, S390_A6_REGNUM, S390_A7_REGNUM,
128 S390_A8_REGNUM, S390_A9_REGNUM, S390_A10_REGNUM, S390_A11_REGNUM,
129 S390_A12_REGNUM, S390_A13_REGNUM, S390_A14_REGNUM, S390_A15_REGNUM,
131 /* Program Status Word. */
135 /* GPR Lower Half Access. */
136 S390_R0_REGNUM, S390_R1_REGNUM, S390_R2_REGNUM, S390_R3_REGNUM,
137 S390_R4_REGNUM, S390_R5_REGNUM, S390_R6_REGNUM, S390_R7_REGNUM,
138 S390_R8_REGNUM, S390_R9_REGNUM, S390_R10_REGNUM, S390_R11_REGNUM,
139 S390_R12_REGNUM, S390_R13_REGNUM, S390_R14_REGNUM, S390_R15_REGNUM,
142 /* Convert DWARF register number REG to the appropriate register
143 number used by GDB. */
145 s390_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int reg)
147 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
149 /* In a 32-on-64 debug scenario, debug info refers to the full 64-bit
150 GPRs. Note that call frame information still refers to the 32-bit
151 lower halves, because s390_adjust_frame_regnum uses register numbers
152 66 .. 81 to access GPRs. */
153 if (tdep->gpr_full_regnum != -1 && reg >= 0 && reg < 16)
154 return tdep->gpr_full_regnum + reg;
156 if (reg >= 0 && reg < ARRAY_SIZE (s390_dwarf_regmap))
157 return s390_dwarf_regmap[reg];
159 warning (_("Unmapped DWARF Register #%d encountered."), reg);
163 /* Translate a .eh_frame register to DWARF register, or adjust a
164 .debug_frame register. */
166 s390_adjust_frame_regnum (struct gdbarch *gdbarch, int num, int eh_frame_p)
168 /* See s390_dwarf_reg_to_regnum for comments. */
169 return (num >= 0 && num < 16)? num + 66 : num;
173 /* Pseudo registers. */
176 s390_pseudo_register_name (struct gdbarch *gdbarch, int regnum)
178 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
180 if (regnum == tdep->pc_regnum)
183 if (regnum == tdep->cc_regnum)
186 if (tdep->gpr_full_regnum != -1
187 && regnum >= tdep->gpr_full_regnum
188 && regnum < tdep->gpr_full_regnum + 16)
190 static const char *full_name[] = {
191 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
192 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
194 return full_name[regnum - tdep->gpr_full_regnum];
197 internal_error (__FILE__, __LINE__, _("invalid regnum"));
201 s390_pseudo_register_type (struct gdbarch *gdbarch, int regnum)
203 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
205 if (regnum == tdep->pc_regnum)
206 return builtin_type (gdbarch)->builtin_func_ptr;
208 if (regnum == tdep->cc_regnum)
209 return builtin_type (gdbarch)->builtin_int;
211 if (tdep->gpr_full_regnum != -1
212 && regnum >= tdep->gpr_full_regnum
213 && regnum < tdep->gpr_full_regnum + 16)
214 return builtin_type (gdbarch)->builtin_uint64;
216 internal_error (__FILE__, __LINE__, _("invalid regnum"));
219 static enum register_status
220 s390_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
221 int regnum, gdb_byte *buf)
223 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
224 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
225 int regsize = register_size (gdbarch, regnum);
228 if (regnum == tdep->pc_regnum)
230 enum register_status status;
232 status = regcache_raw_read_unsigned (regcache, S390_PSWA_REGNUM, &val);
233 if (status == REG_VALID)
235 if (register_size (gdbarch, S390_PSWA_REGNUM) == 4)
237 store_unsigned_integer (buf, regsize, byte_order, val);
242 if (regnum == tdep->cc_regnum)
244 enum register_status status;
246 status = regcache_raw_read_unsigned (regcache, S390_PSWM_REGNUM, &val);
247 if (status == REG_VALID)
249 if (register_size (gdbarch, S390_PSWA_REGNUM) == 4)
250 val = (val >> 12) & 3;
252 val = (val >> 44) & 3;
253 store_unsigned_integer (buf, regsize, byte_order, val);
258 if (tdep->gpr_full_regnum != -1
259 && regnum >= tdep->gpr_full_regnum
260 && regnum < tdep->gpr_full_regnum + 16)
262 enum register_status status;
265 regnum -= tdep->gpr_full_regnum;
267 status = regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + regnum, &val);
268 if (status == REG_VALID)
269 status = regcache_raw_read_unsigned (regcache, S390_R0_UPPER_REGNUM + regnum,
271 if (status == REG_VALID)
273 val |= val_upper << 32;
274 store_unsigned_integer (buf, regsize, byte_order, val);
279 internal_error (__FILE__, __LINE__, _("invalid regnum"));
283 s390_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
284 int regnum, const gdb_byte *buf)
286 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
287 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
288 int regsize = register_size (gdbarch, regnum);
291 if (regnum == tdep->pc_regnum)
293 val = extract_unsigned_integer (buf, regsize, byte_order);
294 if (register_size (gdbarch, S390_PSWA_REGNUM) == 4)
296 regcache_raw_read_unsigned (regcache, S390_PSWA_REGNUM, &psw);
297 val = (psw & 0x80000000) | (val & 0x7fffffff);
299 regcache_raw_write_unsigned (regcache, S390_PSWA_REGNUM, val);
303 if (regnum == tdep->cc_regnum)
305 val = extract_unsigned_integer (buf, regsize, byte_order);
306 regcache_raw_read_unsigned (regcache, S390_PSWM_REGNUM, &psw);
307 if (register_size (gdbarch, S390_PSWA_REGNUM) == 4)
308 val = (psw & ~((ULONGEST)3 << 12)) | ((val & 3) << 12);
310 val = (psw & ~((ULONGEST)3 << 44)) | ((val & 3) << 44);
311 regcache_raw_write_unsigned (regcache, S390_PSWM_REGNUM, val);
315 if (tdep->gpr_full_regnum != -1
316 && regnum >= tdep->gpr_full_regnum
317 && regnum < tdep->gpr_full_regnum + 16)
319 regnum -= tdep->gpr_full_regnum;
320 val = extract_unsigned_integer (buf, regsize, byte_order);
321 regcache_raw_write_unsigned (regcache, S390_R0_REGNUM + regnum,
323 regcache_raw_write_unsigned (regcache, S390_R0_UPPER_REGNUM + regnum,
328 internal_error (__FILE__, __LINE__, _("invalid regnum"));
331 /* 'float' values are stored in the upper half of floating-point
332 registers, even though we are otherwise a big-endian platform. */
334 static struct value *
335 s390_value_from_register (struct type *type, int regnum,
336 struct frame_info *frame)
338 struct value *value = default_value_from_register (type, regnum, frame);
339 int len = TYPE_LENGTH (check_typedef (type));
341 if (regnum >= S390_F0_REGNUM && regnum <= S390_F15_REGNUM && len < 8)
342 set_value_offset (value, 0);
347 /* Register groups. */
350 s390_pseudo_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
351 struct reggroup *group)
353 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
355 /* PC and CC pseudo registers need to be saved/restored in order to
356 push or pop frames. */
357 if (group == save_reggroup || group == restore_reggroup)
358 return regnum == tdep->pc_regnum || regnum == tdep->cc_regnum;
360 return default_register_reggroup_p (gdbarch, regnum, group);
364 /* Core file register sets. */
366 int s390_regmap_gregset[S390_NUM_REGS] =
368 /* Program Status Word. */
370 /* General Purpose Registers. */
371 0x08, 0x0c, 0x10, 0x14,
372 0x18, 0x1c, 0x20, 0x24,
373 0x28, 0x2c, 0x30, 0x34,
374 0x38, 0x3c, 0x40, 0x44,
375 /* Access Registers. */
376 0x48, 0x4c, 0x50, 0x54,
377 0x58, 0x5c, 0x60, 0x64,
378 0x68, 0x6c, 0x70, 0x74,
379 0x78, 0x7c, 0x80, 0x84,
380 /* Floating Point Control Word. */
382 /* Floating Point Registers. */
383 -1, -1, -1, -1, -1, -1, -1, -1,
384 -1, -1, -1, -1, -1, -1, -1, -1,
385 /* GPR Uppper Halves. */
386 -1, -1, -1, -1, -1, -1, -1, -1,
387 -1, -1, -1, -1, -1, -1, -1, -1,
390 int s390x_regmap_gregset[S390_NUM_REGS] =
392 /* Program Status Word. */
394 /* General Purpose Registers. */
395 0x10, 0x18, 0x20, 0x28,
396 0x30, 0x38, 0x40, 0x48,
397 0x50, 0x58, 0x60, 0x68,
398 0x70, 0x78, 0x80, 0x88,
399 /* Access Registers. */
400 0x90, 0x94, 0x98, 0x9c,
401 0xa0, 0xa4, 0xa8, 0xac,
402 0xb0, 0xb4, 0xb8, 0xbc,
403 0xc0, 0xc4, 0xc8, 0xcc,
404 /* Floating Point Control Word. */
406 /* Floating Point Registers. */
407 -1, -1, -1, -1, -1, -1, -1, -1,
408 -1, -1, -1, -1, -1, -1, -1, -1,
409 /* GPR Uppper Halves. */
410 0x10, 0x18, 0x20, 0x28,
411 0x30, 0x38, 0x40, 0x48,
412 0x50, 0x58, 0x60, 0x68,
413 0x70, 0x78, 0x80, 0x88,
416 int s390_regmap_fpregset[S390_NUM_REGS] =
418 /* Program Status Word. */
420 /* General Purpose Registers. */
421 -1, -1, -1, -1, -1, -1, -1, -1,
422 -1, -1, -1, -1, -1, -1, -1, -1,
423 /* Access Registers. */
424 -1, -1, -1, -1, -1, -1, -1, -1,
425 -1, -1, -1, -1, -1, -1, -1, -1,
426 /* Floating Point Control Word. */
428 /* Floating Point Registers. */
429 0x08, 0x10, 0x18, 0x20,
430 0x28, 0x30, 0x38, 0x40,
431 0x48, 0x50, 0x58, 0x60,
432 0x68, 0x70, 0x78, 0x80,
433 /* GPR Uppper Halves. */
434 -1, -1, -1, -1, -1, -1, -1, -1,
435 -1, -1, -1, -1, -1, -1, -1, -1,
438 int s390_regmap_upper[S390_NUM_REGS] =
440 /* Program Status Word. */
442 /* General Purpose Registers. */
443 -1, -1, -1, -1, -1, -1, -1, -1,
444 -1, -1, -1, -1, -1, -1, -1, -1,
445 /* Access Registers. */
446 -1, -1, -1, -1, -1, -1, -1, -1,
447 -1, -1, -1, -1, -1, -1, -1, -1,
448 /* Floating Point Control Word. */
450 /* Floating Point Registers. */
451 -1, -1, -1, -1, -1, -1, -1, -1,
452 -1, -1, -1, -1, -1, -1, -1, -1,
453 /* GPR Uppper Halves. */
454 0x00, 0x04, 0x08, 0x0c,
455 0x10, 0x14, 0x18, 0x1c,
456 0x20, 0x24, 0x28, 0x2c,
457 0x30, 0x34, 0x38, 0x3c,
460 /* Supply register REGNUM from the register set REGSET to register cache
461 REGCACHE. If REGNUM is -1, do this for all registers in REGSET. */
463 s390_supply_regset (const struct regset *regset, struct regcache *regcache,
464 int regnum, const void *regs, size_t len)
466 const int *offset = regset->descr;
469 for (i = 0; i < S390_NUM_REGS; i++)
471 if ((regnum == i || regnum == -1) && offset[i] != -1)
472 regcache_raw_supply (regcache, i, (const char *)regs + offset[i]);
476 /* Collect register REGNUM from the register cache REGCACHE and store
477 it in the buffer specified by REGS and LEN as described by the
478 general-purpose register set REGSET. If REGNUM is -1, do this for
479 all registers in REGSET. */
481 s390_collect_regset (const struct regset *regset,
482 const struct regcache *regcache,
483 int regnum, void *regs, size_t len)
485 const int *offset = regset->descr;
488 for (i = 0; i < S390_NUM_REGS; i++)
490 if ((regnum == i || regnum == -1) && offset[i] != -1)
491 regcache_raw_collect (regcache, i, (char *)regs + offset[i]);
495 static const struct regset s390_gregset = {
501 static const struct regset s390x_gregset = {
502 s390x_regmap_gregset,
507 static const struct regset s390_fpregset = {
508 s390_regmap_fpregset,
513 static const struct regset s390_upper_regset = {
519 static struct core_regset_section s390_upper_regset_sections[] =
521 { ".reg", s390_sizeof_gregset, "general-purpose" },
522 { ".reg2", s390_sizeof_fpregset, "floating-point" },
523 { ".reg-s390-high-gprs", 16*4, "s390 GPR upper halves" },
527 /* Return the appropriate register set for the core section identified
528 by SECT_NAME and SECT_SIZE. */
529 static const struct regset *
530 s390_regset_from_core_section (struct gdbarch *gdbarch,
531 const char *sect_name, size_t sect_size)
533 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
535 if (strcmp (sect_name, ".reg") == 0 && sect_size >= tdep->sizeof_gregset)
536 return tdep->gregset;
538 if (strcmp (sect_name, ".reg2") == 0 && sect_size >= tdep->sizeof_fpregset)
539 return tdep->fpregset;
541 if (strcmp (sect_name, ".reg-s390-high-gprs") == 0 && sect_size >= 16*4)
542 return &s390_upper_regset;
547 static const struct target_desc *
548 s390_core_read_description (struct gdbarch *gdbarch,
549 struct target_ops *target, bfd *abfd)
551 asection *high_gprs = bfd_get_section_by_name (abfd, ".reg-s390-high-gprs");
552 asection *section = bfd_get_section_by_name (abfd, ".reg");
556 switch (bfd_section_size (abfd, section))
558 case s390_sizeof_gregset:
559 return high_gprs? tdesc_s390_linux64 : tdesc_s390_linux32;
561 case s390x_sizeof_gregset:
562 return tdesc_s390x_linux64;
570 /* Decoding S/390 instructions. */
572 /* Named opcode values for the S/390 instructions we recognize. Some
573 instructions have their opcode split across two fields; those are the
574 op1_* and op2_* enums. */
577 op1_lhi = 0xa7, op2_lhi = 0x08,
578 op1_lghi = 0xa7, op2_lghi = 0x09,
579 op1_lgfi = 0xc0, op2_lgfi = 0x01,
583 op1_ly = 0xe3, op2_ly = 0x58,
584 op1_lg = 0xe3, op2_lg = 0x04,
586 op1_lmy = 0xeb, op2_lmy = 0x98,
587 op1_lmg = 0xeb, op2_lmg = 0x04,
589 op1_sty = 0xe3, op2_sty = 0x50,
590 op1_stg = 0xe3, op2_stg = 0x24,
593 op1_stmy = 0xeb, op2_stmy = 0x90,
594 op1_stmg = 0xeb, op2_stmg = 0x24,
595 op1_aghi = 0xa7, op2_aghi = 0x0b,
596 op1_ahi = 0xa7, op2_ahi = 0x0a,
597 op1_agfi = 0xc2, op2_agfi = 0x08,
598 op1_afi = 0xc2, op2_afi = 0x09,
599 op1_algfi= 0xc2, op2_algfi= 0x0a,
600 op1_alfi = 0xc2, op2_alfi = 0x0b,
604 op1_ay = 0xe3, op2_ay = 0x5a,
605 op1_ag = 0xe3, op2_ag = 0x08,
606 op1_slgfi= 0xc2, op2_slgfi= 0x04,
607 op1_slfi = 0xc2, op2_slfi = 0x05,
611 op1_sy = 0xe3, op2_sy = 0x5b,
612 op1_sg = 0xe3, op2_sg = 0x09,
616 op1_lay = 0xe3, op2_lay = 0x71,
617 op1_larl = 0xc0, op2_larl = 0x00,
625 op1_bctg = 0xe3, op2_bctg = 0x46,
627 op1_bxhg = 0xeb, op2_bxhg = 0x44,
629 op1_bxleg= 0xeb, op2_bxleg= 0x45,
630 op1_bras = 0xa7, op2_bras = 0x05,
631 op1_brasl= 0xc0, op2_brasl= 0x05,
632 op1_brc = 0xa7, op2_brc = 0x04,
633 op1_brcl = 0xc0, op2_brcl = 0x04,
634 op1_brct = 0xa7, op2_brct = 0x06,
635 op1_brctg= 0xa7, op2_brctg= 0x07,
637 op1_brxhg= 0xec, op2_brxhg= 0x44,
639 op1_brxlg= 0xec, op2_brxlg= 0x45,
643 /* Read a single instruction from address AT. */
645 #define S390_MAX_INSTR_SIZE 6
647 s390_readinstruction (bfd_byte instr[], CORE_ADDR at)
649 static int s390_instrlen[] = { 2, 4, 4, 6 };
652 if (target_read_memory (at, &instr[0], 2))
654 instrlen = s390_instrlen[instr[0] >> 6];
657 if (target_read_memory (at + 2, &instr[2], instrlen - 2))
664 /* The functions below are for recognizing and decoding S/390
665 instructions of various formats. Each of them checks whether INSN
666 is an instruction of the given format, with the specified opcodes.
667 If it is, it sets the remaining arguments to the values of the
668 instruction's fields, and returns a non-zero value; otherwise, it
671 These functions' arguments appear in the order they appear in the
672 instruction, not in the machine-language form. So, opcodes always
673 come first, even though they're sometimes scattered around the
674 instructions. And displacements appear before base and extension
675 registers, as they do in the assembly syntax, not at the end, as
676 they do in the machine language. */
678 is_ri (bfd_byte *insn, int op1, int op2, unsigned int *r1, int *i2)
680 if (insn[0] == op1 && (insn[1] & 0xf) == op2)
682 *r1 = (insn[1] >> 4) & 0xf;
683 /* i2 is a 16-bit signed quantity. */
684 *i2 = (((insn[2] << 8) | insn[3]) ^ 0x8000) - 0x8000;
693 is_ril (bfd_byte *insn, int op1, int op2,
694 unsigned int *r1, int *i2)
696 if (insn[0] == op1 && (insn[1] & 0xf) == op2)
698 *r1 = (insn[1] >> 4) & 0xf;
699 /* i2 is a signed quantity. If the host 'int' is 32 bits long,
700 no sign extension is necessary, but we don't want to assume
702 *i2 = (((insn[2] << 24)
705 | (insn[5])) ^ 0x80000000) - 0x80000000;
714 is_rr (bfd_byte *insn, int op, unsigned int *r1, unsigned int *r2)
718 *r1 = (insn[1] >> 4) & 0xf;
728 is_rre (bfd_byte *insn, int op, unsigned int *r1, unsigned int *r2)
730 if (((insn[0] << 8) | insn[1]) == op)
732 /* Yes, insn[3]. insn[2] is unused in RRE format. */
733 *r1 = (insn[3] >> 4) & 0xf;
743 is_rs (bfd_byte *insn, int op,
744 unsigned int *r1, unsigned int *r3, unsigned int *d2, unsigned int *b2)
748 *r1 = (insn[1] >> 4) & 0xf;
750 *b2 = (insn[2] >> 4) & 0xf;
751 *d2 = ((insn[2] & 0xf) << 8) | insn[3];
760 is_rsy (bfd_byte *insn, int op1, int op2,
761 unsigned int *r1, unsigned int *r3, unsigned int *d2, unsigned int *b2)
766 *r1 = (insn[1] >> 4) & 0xf;
768 *b2 = (insn[2] >> 4) & 0xf;
769 /* The 'long displacement' is a 20-bit signed integer. */
770 *d2 = ((((insn[2] & 0xf) << 8) | insn[3] | (insn[4] << 12))
771 ^ 0x80000) - 0x80000;
780 is_rsi (bfd_byte *insn, int op,
781 unsigned int *r1, unsigned int *r3, int *i2)
785 *r1 = (insn[1] >> 4) & 0xf;
787 /* i2 is a 16-bit signed quantity. */
788 *i2 = (((insn[2] << 8) | insn[3]) ^ 0x8000) - 0x8000;
797 is_rie (bfd_byte *insn, int op1, int op2,
798 unsigned int *r1, unsigned int *r3, int *i2)
803 *r1 = (insn[1] >> 4) & 0xf;
805 /* i2 is a 16-bit signed quantity. */
806 *i2 = (((insn[2] << 8) | insn[3]) ^ 0x8000) - 0x8000;
815 is_rx (bfd_byte *insn, int op,
816 unsigned int *r1, unsigned int *d2, unsigned int *x2, unsigned int *b2)
820 *r1 = (insn[1] >> 4) & 0xf;
822 *b2 = (insn[2] >> 4) & 0xf;
823 *d2 = ((insn[2] & 0xf) << 8) | insn[3];
832 is_rxy (bfd_byte *insn, int op1, int op2,
833 unsigned int *r1, unsigned int *d2, unsigned int *x2, unsigned int *b2)
838 *r1 = (insn[1] >> 4) & 0xf;
840 *b2 = (insn[2] >> 4) & 0xf;
841 /* The 'long displacement' is a 20-bit signed integer. */
842 *d2 = ((((insn[2] & 0xf) << 8) | insn[3] | (insn[4] << 12))
843 ^ 0x80000) - 0x80000;
851 /* Prologue analysis. */
853 #define S390_NUM_GPRS 16
854 #define S390_NUM_FPRS 16
856 struct s390_prologue_data {
859 struct pv_area *stack;
861 /* The size and byte-order of a GPR or FPR. */
864 enum bfd_endian byte_order;
866 /* The general-purpose registers. */
867 pv_t gpr[S390_NUM_GPRS];
869 /* The floating-point registers. */
870 pv_t fpr[S390_NUM_FPRS];
872 /* The offset relative to the CFA where the incoming GPR N was saved
873 by the function prologue. 0 if not saved or unknown. */
874 int gpr_slot[S390_NUM_GPRS];
876 /* Likewise for FPRs. */
877 int fpr_slot[S390_NUM_FPRS];
879 /* Nonzero if the backchain was saved. This is assumed to be the
880 case when the incoming SP is saved at the current SP location. */
881 int back_chain_saved_p;
884 /* Return the effective address for an X-style instruction, like:
888 Here, X2 and B2 are registers, and D2 is a signed 20-bit
889 constant; the effective address is the sum of all three. If either
890 X2 or B2 are zero, then it doesn't contribute to the sum --- this
891 means that r0 can't be used as either X2 or B2. */
893 s390_addr (struct s390_prologue_data *data,
894 int d2, unsigned int x2, unsigned int b2)
898 result = pv_constant (d2);
900 result = pv_add (result, data->gpr[x2]);
902 result = pv_add (result, data->gpr[b2]);
907 /* Do a SIZE-byte store of VALUE to D2(X2,B2). */
909 s390_store (struct s390_prologue_data *data,
910 int d2, unsigned int x2, unsigned int b2, CORE_ADDR size,
913 pv_t addr = s390_addr (data, d2, x2, b2);
916 /* Check whether we are storing the backchain. */
917 offset = pv_subtract (data->gpr[S390_SP_REGNUM - S390_R0_REGNUM], addr);
919 if (pv_is_constant (offset) && offset.k == 0)
920 if (size == data->gpr_size
921 && pv_is_register_k (value, S390_SP_REGNUM, 0))
923 data->back_chain_saved_p = 1;
928 /* Check whether we are storing a register into the stack. */
929 if (!pv_area_store_would_trash (data->stack, addr))
930 pv_area_store (data->stack, addr, size, value);
933 /* Note: If this is some store we cannot identify, you might think we
934 should forget our cached values, as any of those might have been hit.
936 However, we make the assumption that the register save areas are only
937 ever stored to once in any given function, and we do recognize these
938 stores. Thus every store we cannot recognize does not hit our data. */
941 /* Do a SIZE-byte load from D2(X2,B2). */
943 s390_load (struct s390_prologue_data *data,
944 int d2, unsigned int x2, unsigned int b2, CORE_ADDR size)
947 pv_t addr = s390_addr (data, d2, x2, b2);
950 /* If it's a load from an in-line constant pool, then we can
951 simulate that, under the assumption that the code isn't
952 going to change between the time the processor actually
953 executed it creating the current frame, and the time when
954 we're analyzing the code to unwind past that frame. */
955 if (pv_is_constant (addr))
957 struct target_section *secp;
958 secp = target_section_by_addr (¤t_target, addr.k);
960 && (bfd_get_section_flags (secp->bfd, secp->the_bfd_section)
962 return pv_constant (read_memory_integer (addr.k, size,
966 /* Check whether we are accessing one of our save slots. */
967 return pv_area_fetch (data->stack, addr, size);
970 /* Function for finding saved registers in a 'struct pv_area'; we pass
971 this to pv_area_scan.
973 If VALUE is a saved register, ADDR says it was saved at a constant
974 offset from the frame base, and SIZE indicates that the whole
975 register was saved, record its offset in the reg_offset table in
978 s390_check_for_saved (void *data_untyped, pv_t addr,
979 CORE_ADDR size, pv_t value)
981 struct s390_prologue_data *data = data_untyped;
984 if (!pv_is_register (addr, S390_SP_REGNUM))
987 offset = 16 * data->gpr_size + 32 - addr.k;
989 /* If we are storing the original value of a register, we want to
990 record the CFA offset. If the same register is stored multiple
991 times, the stack slot with the highest address counts. */
993 for (i = 0; i < S390_NUM_GPRS; i++)
994 if (size == data->gpr_size
995 && pv_is_register_k (value, S390_R0_REGNUM + i, 0))
996 if (data->gpr_slot[i] == 0
997 || data->gpr_slot[i] > offset)
999 data->gpr_slot[i] = offset;
1003 for (i = 0; i < S390_NUM_FPRS; i++)
1004 if (size == data->fpr_size
1005 && pv_is_register_k (value, S390_F0_REGNUM + i, 0))
1006 if (data->fpr_slot[i] == 0
1007 || data->fpr_slot[i] > offset)
1009 data->fpr_slot[i] = offset;
1014 /* Analyze the prologue of the function starting at START_PC,
1015 continuing at most until CURRENT_PC. Initialize DATA to
1016 hold all information we find out about the state of the registers
1017 and stack slots. Return the address of the instruction after
1018 the last one that changed the SP, FP, or back chain; or zero
1021 s390_analyze_prologue (struct gdbarch *gdbarch,
1023 CORE_ADDR current_pc,
1024 struct s390_prologue_data *data)
1026 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1028 /* Our return value:
1029 The address of the instruction after the last one that changed
1030 the SP, FP, or back chain; zero if we got an error trying to
1032 CORE_ADDR result = start_pc;
1034 /* The current PC for our abstract interpretation. */
1037 /* The address of the next instruction after that. */
1040 /* Set up everything's initial value. */
1044 data->stack = make_pv_area (S390_SP_REGNUM, gdbarch_addr_bit (gdbarch));
1046 /* For the purpose of prologue tracking, we consider the GPR size to
1047 be equal to the ABI word size, even if it is actually larger
1048 (i.e. when running a 32-bit binary under a 64-bit kernel). */
1049 data->gpr_size = word_size;
1051 data->byte_order = gdbarch_byte_order (gdbarch);
1053 for (i = 0; i < S390_NUM_GPRS; i++)
1054 data->gpr[i] = pv_register (S390_R0_REGNUM + i, 0);
1056 for (i = 0; i < S390_NUM_FPRS; i++)
1057 data->fpr[i] = pv_register (S390_F0_REGNUM + i, 0);
1059 for (i = 0; i < S390_NUM_GPRS; i++)
1060 data->gpr_slot[i] = 0;
1062 for (i = 0; i < S390_NUM_FPRS; i++)
1063 data->fpr_slot[i] = 0;
1065 data->back_chain_saved_p = 0;
1068 /* Start interpreting instructions, until we hit the frame's
1069 current PC or the first branch instruction. */
1070 for (pc = start_pc; pc > 0 && pc < current_pc; pc = next_pc)
1072 bfd_byte insn[S390_MAX_INSTR_SIZE];
1073 int insn_len = s390_readinstruction (insn, pc);
1075 bfd_byte dummy[S390_MAX_INSTR_SIZE] = { 0 };
1076 bfd_byte *insn32 = word_size == 4 ? insn : dummy;
1077 bfd_byte *insn64 = word_size == 8 ? insn : dummy;
1079 /* Fields for various kinds of instructions. */
1080 unsigned int b2, r1, r2, x2, r3;
1083 /* The values of SP and FP before this instruction,
1084 for detecting instructions that change them. */
1085 pv_t pre_insn_sp, pre_insn_fp;
1086 /* Likewise for the flag whether the back chain was saved. */
1087 int pre_insn_back_chain_saved_p;
1089 /* If we got an error trying to read the instruction, report it. */
1096 next_pc = pc + insn_len;
1098 pre_insn_sp = data->gpr[S390_SP_REGNUM - S390_R0_REGNUM];
1099 pre_insn_fp = data->gpr[S390_FRAME_REGNUM - S390_R0_REGNUM];
1100 pre_insn_back_chain_saved_p = data->back_chain_saved_p;
1103 /* LHI r1, i2 --- load halfword immediate. */
1104 /* LGHI r1, i2 --- load halfword immediate (64-bit version). */
1105 /* LGFI r1, i2 --- load fullword immediate. */
1106 if (is_ri (insn32, op1_lhi, op2_lhi, &r1, &i2)
1107 || is_ri (insn64, op1_lghi, op2_lghi, &r1, &i2)
1108 || is_ril (insn, op1_lgfi, op2_lgfi, &r1, &i2))
1109 data->gpr[r1] = pv_constant (i2);
1111 /* LR r1, r2 --- load from register. */
1112 /* LGR r1, r2 --- load from register (64-bit version). */
1113 else if (is_rr (insn32, op_lr, &r1, &r2)
1114 || is_rre (insn64, op_lgr, &r1, &r2))
1115 data->gpr[r1] = data->gpr[r2];
1117 /* L r1, d2(x2, b2) --- load. */
1118 /* LY r1, d2(x2, b2) --- load (long-displacement version). */
1119 /* LG r1, d2(x2, b2) --- load (64-bit version). */
1120 else if (is_rx (insn32, op_l, &r1, &d2, &x2, &b2)
1121 || is_rxy (insn32, op1_ly, op2_ly, &r1, &d2, &x2, &b2)
1122 || is_rxy (insn64, op1_lg, op2_lg, &r1, &d2, &x2, &b2))
1123 data->gpr[r1] = s390_load (data, d2, x2, b2, data->gpr_size);
1125 /* ST r1, d2(x2, b2) --- store. */
1126 /* STY r1, d2(x2, b2) --- store (long-displacement version). */
1127 /* STG r1, d2(x2, b2) --- store (64-bit version). */
1128 else if (is_rx (insn32, op_st, &r1, &d2, &x2, &b2)
1129 || is_rxy (insn32, op1_sty, op2_sty, &r1, &d2, &x2, &b2)
1130 || is_rxy (insn64, op1_stg, op2_stg, &r1, &d2, &x2, &b2))
1131 s390_store (data, d2, x2, b2, data->gpr_size, data->gpr[r1]);
1133 /* STD r1, d2(x2,b2) --- store floating-point register. */
1134 else if (is_rx (insn, op_std, &r1, &d2, &x2, &b2))
1135 s390_store (data, d2, x2, b2, data->fpr_size, data->fpr[r1]);
1137 /* STM r1, r3, d2(b2) --- store multiple. */
1138 /* STMY r1, r3, d2(b2) --- store multiple (long-displacement
1140 /* STMG r1, r3, d2(b2) --- store multiple (64-bit version). */
1141 else if (is_rs (insn32, op_stm, &r1, &r3, &d2, &b2)
1142 || is_rsy (insn32, op1_stmy, op2_stmy, &r1, &r3, &d2, &b2)
1143 || is_rsy (insn64, op1_stmg, op2_stmg, &r1, &r3, &d2, &b2))
1145 for (; r1 <= r3; r1++, d2 += data->gpr_size)
1146 s390_store (data, d2, 0, b2, data->gpr_size, data->gpr[r1]);
1149 /* AHI r1, i2 --- add halfword immediate. */
1150 /* AGHI r1, i2 --- add halfword immediate (64-bit version). */
1151 /* AFI r1, i2 --- add fullword immediate. */
1152 /* AGFI r1, i2 --- add fullword immediate (64-bit version). */
1153 else if (is_ri (insn32, op1_ahi, op2_ahi, &r1, &i2)
1154 || is_ri (insn64, op1_aghi, op2_aghi, &r1, &i2)
1155 || is_ril (insn32, op1_afi, op2_afi, &r1, &i2)
1156 || is_ril (insn64, op1_agfi, op2_agfi, &r1, &i2))
1157 data->gpr[r1] = pv_add_constant (data->gpr[r1], i2);
1159 /* ALFI r1, i2 --- add logical immediate. */
1160 /* ALGFI r1, i2 --- add logical immediate (64-bit version). */
1161 else if (is_ril (insn32, op1_alfi, op2_alfi, &r1, &i2)
1162 || is_ril (insn64, op1_algfi, op2_algfi, &r1, &i2))
1163 data->gpr[r1] = pv_add_constant (data->gpr[r1],
1164 (CORE_ADDR)i2 & 0xffffffff);
1166 /* AR r1, r2 -- add register. */
1167 /* AGR r1, r2 -- add register (64-bit version). */
1168 else if (is_rr (insn32, op_ar, &r1, &r2)
1169 || is_rre (insn64, op_agr, &r1, &r2))
1170 data->gpr[r1] = pv_add (data->gpr[r1], data->gpr[r2]);
1172 /* A r1, d2(x2, b2) -- add. */
1173 /* AY r1, d2(x2, b2) -- add (long-displacement version). */
1174 /* AG r1, d2(x2, b2) -- add (64-bit version). */
1175 else if (is_rx (insn32, op_a, &r1, &d2, &x2, &b2)
1176 || is_rxy (insn32, op1_ay, op2_ay, &r1, &d2, &x2, &b2)
1177 || is_rxy (insn64, op1_ag, op2_ag, &r1, &d2, &x2, &b2))
1178 data->gpr[r1] = pv_add (data->gpr[r1],
1179 s390_load (data, d2, x2, b2, data->gpr_size));
1181 /* SLFI r1, i2 --- subtract logical immediate. */
1182 /* SLGFI r1, i2 --- subtract logical immediate (64-bit version). */
1183 else if (is_ril (insn32, op1_slfi, op2_slfi, &r1, &i2)
1184 || is_ril (insn64, op1_slgfi, op2_slgfi, &r1, &i2))
1185 data->gpr[r1] = pv_add_constant (data->gpr[r1],
1186 -((CORE_ADDR)i2 & 0xffffffff));
1188 /* SR r1, r2 -- subtract register. */
1189 /* SGR r1, r2 -- subtract register (64-bit version). */
1190 else if (is_rr (insn32, op_sr, &r1, &r2)
1191 || is_rre (insn64, op_sgr, &r1, &r2))
1192 data->gpr[r1] = pv_subtract (data->gpr[r1], data->gpr[r2]);
1194 /* S r1, d2(x2, b2) -- subtract. */
1195 /* SY r1, d2(x2, b2) -- subtract (long-displacement version). */
1196 /* SG r1, d2(x2, b2) -- subtract (64-bit version). */
1197 else if (is_rx (insn32, op_s, &r1, &d2, &x2, &b2)
1198 || is_rxy (insn32, op1_sy, op2_sy, &r1, &d2, &x2, &b2)
1199 || is_rxy (insn64, op1_sg, op2_sg, &r1, &d2, &x2, &b2))
1200 data->gpr[r1] = pv_subtract (data->gpr[r1],
1201 s390_load (data, d2, x2, b2, data->gpr_size));
1203 /* LA r1, d2(x2, b2) --- load address. */
1204 /* LAY r1, d2(x2, b2) --- load address (long-displacement version). */
1205 else if (is_rx (insn, op_la, &r1, &d2, &x2, &b2)
1206 || is_rxy (insn, op1_lay, op2_lay, &r1, &d2, &x2, &b2))
1207 data->gpr[r1] = s390_addr (data, d2, x2, b2);
1209 /* LARL r1, i2 --- load address relative long. */
1210 else if (is_ril (insn, op1_larl, op2_larl, &r1, &i2))
1211 data->gpr[r1] = pv_constant (pc + i2 * 2);
1213 /* BASR r1, 0 --- branch and save.
1214 Since r2 is zero, this saves the PC in r1, but doesn't branch. */
1215 else if (is_rr (insn, op_basr, &r1, &r2)
1217 data->gpr[r1] = pv_constant (next_pc);
1219 /* BRAS r1, i2 --- branch relative and save. */
1220 else if (is_ri (insn, op1_bras, op2_bras, &r1, &i2))
1222 data->gpr[r1] = pv_constant (next_pc);
1223 next_pc = pc + i2 * 2;
1225 /* We'd better not interpret any backward branches. We'll
1231 /* Terminate search when hitting any other branch instruction. */
1232 else if (is_rr (insn, op_basr, &r1, &r2)
1233 || is_rx (insn, op_bas, &r1, &d2, &x2, &b2)
1234 || is_rr (insn, op_bcr, &r1, &r2)
1235 || is_rx (insn, op_bc, &r1, &d2, &x2, &b2)
1236 || is_ri (insn, op1_brc, op2_brc, &r1, &i2)
1237 || is_ril (insn, op1_brcl, op2_brcl, &r1, &i2)
1238 || is_ril (insn, op1_brasl, op2_brasl, &r2, &i2))
1242 /* An instruction we don't know how to simulate. The only
1243 safe thing to do would be to set every value we're tracking
1244 to 'unknown'. Instead, we'll be optimistic: we assume that
1245 we *can* interpret every instruction that the compiler uses
1246 to manipulate any of the data we're interested in here --
1247 then we can just ignore anything else. */
1250 /* Record the address after the last instruction that changed
1251 the FP, SP, or backlink. Ignore instructions that changed
1252 them back to their original values --- those are probably
1253 restore instructions. (The back chain is never restored,
1256 pv_t sp = data->gpr[S390_SP_REGNUM - S390_R0_REGNUM];
1257 pv_t fp = data->gpr[S390_FRAME_REGNUM - S390_R0_REGNUM];
1259 if ((! pv_is_identical (pre_insn_sp, sp)
1260 && ! pv_is_register_k (sp, S390_SP_REGNUM, 0)
1261 && sp.kind != pvk_unknown)
1262 || (! pv_is_identical (pre_insn_fp, fp)
1263 && ! pv_is_register_k (fp, S390_FRAME_REGNUM, 0)
1264 && fp.kind != pvk_unknown)
1265 || pre_insn_back_chain_saved_p != data->back_chain_saved_p)
1270 /* Record where all the registers were saved. */
1271 pv_area_scan (data->stack, s390_check_for_saved, data);
1273 free_pv_area (data->stack);
1279 /* Advance PC across any function entry prologue instructions to reach
1280 some "real" code. */
1282 s390_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
1284 struct s390_prologue_data data;
1286 skip_pc = s390_analyze_prologue (gdbarch, pc, (CORE_ADDR)-1, &data);
1287 return skip_pc ? skip_pc : pc;
1290 /* Return true if we are in the functin's epilogue, i.e. after the
1291 instruction that destroyed the function's stack frame. */
1293 s390_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
1295 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1297 /* In frameless functions, there's not frame to destroy and thus
1298 we don't care about the epilogue.
1300 In functions with frame, the epilogue sequence is a pair of
1301 a LM-type instruction that restores (amongst others) the
1302 return register %r14 and the stack pointer %r15, followed
1303 by a branch 'br %r14' --or equivalent-- that effects the
1306 In that situation, this function needs to return 'true' in
1307 exactly one case: when pc points to that branch instruction.
1309 Thus we try to disassemble the one instructions immediately
1310 preceding pc and check whether it is an LM-type instruction
1311 modifying the stack pointer.
1313 Note that disassembling backwards is not reliable, so there
1314 is a slight chance of false positives here ... */
1317 unsigned int r1, r3, b2;
1321 && !target_read_memory (pc - 4, insn, 4)
1322 && is_rs (insn, op_lm, &r1, &r3, &d2, &b2)
1323 && r3 == S390_SP_REGNUM - S390_R0_REGNUM)
1327 && !target_read_memory (pc - 6, insn, 6)
1328 && is_rsy (insn, op1_lmy, op2_lmy, &r1, &r3, &d2, &b2)
1329 && r3 == S390_SP_REGNUM - S390_R0_REGNUM)
1333 && !target_read_memory (pc - 6, insn, 6)
1334 && is_rsy (insn, op1_lmg, op2_lmg, &r1, &r3, &d2, &b2)
1335 && r3 == S390_SP_REGNUM - S390_R0_REGNUM)
1341 /* Displaced stepping. */
1343 /* Fix up the state of registers and memory after having single-stepped
1344 a displaced instruction. */
1346 s390_displaced_step_fixup (struct gdbarch *gdbarch,
1347 struct displaced_step_closure *closure,
1348 CORE_ADDR from, CORE_ADDR to,
1349 struct regcache *regs)
1351 /* Since we use simple_displaced_step_copy_insn, our closure is a
1352 copy of the instruction. */
1353 gdb_byte *insn = (gdb_byte *) closure;
1354 static int s390_instrlen[] = { 2, 4, 4, 6 };
1355 int insnlen = s390_instrlen[insn[0] >> 6];
1357 /* Fields for various kinds of instructions. */
1358 unsigned int b2, r1, r2, x2, r3;
1361 /* Get current PC and addressing mode bit. */
1362 CORE_ADDR pc = regcache_read_pc (regs);
1365 if (register_size (gdbarch, S390_PSWA_REGNUM) == 4)
1367 regcache_cooked_read_unsigned (regs, S390_PSWA_REGNUM, &amode);
1368 amode &= 0x80000000;
1371 if (debug_displaced)
1372 fprintf_unfiltered (gdb_stdlog,
1373 "displaced: (s390) fixup (%s, %s) pc %s len %d amode 0x%x\n",
1374 paddress (gdbarch, from), paddress (gdbarch, to),
1375 paddress (gdbarch, pc), insnlen, (int) amode);
1377 /* Handle absolute branch and save instructions. */
1378 if (is_rr (insn, op_basr, &r1, &r2)
1379 || is_rx (insn, op_bas, &r1, &d2, &x2, &b2))
1381 /* Recompute saved return address in R1. */
1382 regcache_cooked_write_unsigned (regs, S390_R0_REGNUM + r1,
1383 amode | (from + insnlen));
1386 /* Handle absolute branch instructions. */
1387 else if (is_rr (insn, op_bcr, &r1, &r2)
1388 || is_rx (insn, op_bc, &r1, &d2, &x2, &b2)
1389 || is_rr (insn, op_bctr, &r1, &r2)
1390 || is_rre (insn, op_bctgr, &r1, &r2)
1391 || is_rx (insn, op_bct, &r1, &d2, &x2, &b2)
1392 || is_rxy (insn, op1_bctg, op2_brctg, &r1, &d2, &x2, &b2)
1393 || is_rs (insn, op_bxh, &r1, &r3, &d2, &b2)
1394 || is_rsy (insn, op1_bxhg, op2_bxhg, &r1, &r3, &d2, &b2)
1395 || is_rs (insn, op_bxle, &r1, &r3, &d2, &b2)
1396 || is_rsy (insn, op1_bxleg, op2_bxleg, &r1, &r3, &d2, &b2))
1398 /* Update PC iff branch was *not* taken. */
1399 if (pc == to + insnlen)
1400 regcache_write_pc (regs, from + insnlen);
1403 /* Handle PC-relative branch and save instructions. */
1404 else if (is_ri (insn, op1_bras, op2_bras, &r1, &i2)
1405 || is_ril (insn, op1_brasl, op2_brasl, &r1, &i2))
1408 regcache_write_pc (regs, pc - to + from);
1409 /* Recompute saved return address in R1. */
1410 regcache_cooked_write_unsigned (regs, S390_R0_REGNUM + r1,
1411 amode | (from + insnlen));
1414 /* Handle PC-relative branch instructions. */
1415 else if (is_ri (insn, op1_brc, op2_brc, &r1, &i2)
1416 || is_ril (insn, op1_brcl, op2_brcl, &r1, &i2)
1417 || is_ri (insn, op1_brct, op2_brct, &r1, &i2)
1418 || is_ri (insn, op1_brctg, op2_brctg, &r1, &i2)
1419 || is_rsi (insn, op_brxh, &r1, &r3, &i2)
1420 || is_rie (insn, op1_brxhg, op2_brxhg, &r1, &r3, &i2)
1421 || is_rsi (insn, op_brxle, &r1, &r3, &i2)
1422 || is_rie (insn, op1_brxlg, op2_brxlg, &r1, &r3, &i2))
1425 regcache_write_pc (regs, pc - to + from);
1428 /* Handle LOAD ADDRESS RELATIVE LONG. */
1429 else if (is_ril (insn, op1_larl, op2_larl, &r1, &i2))
1432 regcache_write_pc (regs, from + insnlen);
1433 /* Recompute output address in R1. */
1434 regcache_cooked_write_unsigned (regs, S390_R0_REGNUM + r1,
1435 amode | (from + i2 * 2));
1438 /* If we executed a breakpoint instruction, point PC right back at it. */
1439 else if (insn[0] == 0x0 && insn[1] == 0x1)
1440 regcache_write_pc (regs, from);
1442 /* For any other insn, PC points right after the original instruction. */
1444 regcache_write_pc (regs, from + insnlen);
1446 if (debug_displaced)
1447 fprintf_unfiltered (gdb_stdlog,
1448 "displaced: (s390) pc is now %s\n",
1449 paddress (gdbarch, regcache_read_pc (regs)));
1452 /* Normal stack frames. */
1454 struct s390_unwind_cache {
1457 CORE_ADDR frame_base;
1458 CORE_ADDR local_base;
1460 struct trad_frame_saved_reg *saved_regs;
1464 s390_prologue_frame_unwind_cache (struct frame_info *this_frame,
1465 struct s390_unwind_cache *info)
1467 struct gdbarch *gdbarch = get_frame_arch (this_frame);
1468 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1469 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1470 struct s390_prologue_data data;
1471 pv_t *fp = &data.gpr[S390_FRAME_REGNUM - S390_R0_REGNUM];
1472 pv_t *sp = &data.gpr[S390_SP_REGNUM - S390_R0_REGNUM];
1481 struct frame_info *next_frame;
1483 /* Try to find the function start address. If we can't find it, we don't
1484 bother searching for it -- with modern compilers this would be mostly
1485 pointless anyway. Trust that we'll either have valid DWARF-2 CFI data
1486 or else a valid backchain ... */
1487 func = get_frame_func (this_frame);
1491 /* Try to analyze the prologue. */
1492 result = s390_analyze_prologue (gdbarch, func,
1493 get_frame_pc (this_frame), &data);
1497 /* If this was successful, we should have found the instruction that
1498 sets the stack pointer register to the previous value of the stack
1499 pointer minus the frame size. */
1500 if (!pv_is_register (*sp, S390_SP_REGNUM))
1503 /* A frame size of zero at this point can mean either a real
1504 frameless function, or else a failure to find the prologue.
1505 Perform some sanity checks to verify we really have a
1506 frameless function. */
1509 /* If the next frame is a NORMAL_FRAME, this frame *cannot* have frame
1510 size zero. This is only possible if the next frame is a sentinel
1511 frame, a dummy frame, or a signal trampoline frame. */
1512 /* FIXME: cagney/2004-05-01: This sanity check shouldn't be
1513 needed, instead the code should simpliy rely on its
1515 next_frame = get_next_frame (this_frame);
1516 while (next_frame && get_frame_type (next_frame) == INLINE_FRAME)
1517 next_frame = get_next_frame (next_frame);
1519 && get_frame_type (get_next_frame (this_frame)) == NORMAL_FRAME)
1522 /* If we really have a frameless function, %r14 must be valid
1523 -- in particular, it must point to a different function. */
1524 reg = get_frame_register_unsigned (this_frame, S390_RETADDR_REGNUM);
1525 reg = gdbarch_addr_bits_remove (gdbarch, reg) - 1;
1526 if (get_pc_function_start (reg) == func)
1528 /* However, there is one case where it *is* valid for %r14
1529 to point to the same function -- if this is a recursive
1530 call, and we have stopped in the prologue *before* the
1531 stack frame was allocated.
1533 Recognize this case by looking ahead a bit ... */
1535 struct s390_prologue_data data2;
1536 pv_t *sp = &data2.gpr[S390_SP_REGNUM - S390_R0_REGNUM];
1538 if (!(s390_analyze_prologue (gdbarch, func, (CORE_ADDR)-1, &data2)
1539 && pv_is_register (*sp, S390_SP_REGNUM)
1546 /* OK, we've found valid prologue data. */
1549 /* If the frame pointer originally also holds the same value
1550 as the stack pointer, we're probably using it. If it holds
1551 some other value -- even a constant offset -- it is most
1552 likely used as temp register. */
1553 if (pv_is_identical (*sp, *fp))
1554 frame_pointer = S390_FRAME_REGNUM;
1556 frame_pointer = S390_SP_REGNUM;
1558 /* If we've detected a function with stack frame, we'll still have to
1559 treat it as frameless if we're currently within the function epilog
1560 code at a point where the frame pointer has already been restored.
1561 This can only happen in an innermost frame. */
1562 /* FIXME: cagney/2004-05-01: This sanity check shouldn't be needed,
1563 instead the code should simpliy rely on its analysis. */
1564 next_frame = get_next_frame (this_frame);
1565 while (next_frame && get_frame_type (next_frame) == INLINE_FRAME)
1566 next_frame = get_next_frame (next_frame);
1568 && (next_frame == NULL
1569 || get_frame_type (get_next_frame (this_frame)) != NORMAL_FRAME))
1571 /* See the comment in s390_in_function_epilogue_p on why this is
1572 not completely reliable ... */
1573 if (s390_in_function_epilogue_p (gdbarch, get_frame_pc (this_frame)))
1575 memset (&data, 0, sizeof (data));
1577 frame_pointer = S390_SP_REGNUM;
1581 /* Once we know the frame register and the frame size, we can unwind
1582 the current value of the frame register from the next frame, and
1583 add back the frame size to arrive that the previous frame's
1584 stack pointer value. */
1585 prev_sp = get_frame_register_unsigned (this_frame, frame_pointer) + size;
1586 cfa = prev_sp + 16*word_size + 32;
1588 /* Set up ABI call-saved/call-clobbered registers. */
1589 for (i = 0; i < S390_NUM_REGS; i++)
1590 if (!s390_register_call_saved (gdbarch, i))
1591 trad_frame_set_unknown (info->saved_regs, i);
1593 /* CC is always call-clobbered. */
1594 trad_frame_set_unknown (info->saved_regs, tdep->cc_regnum);
1596 /* Record the addresses of all register spill slots the prologue parser
1597 has recognized. Consider only registers defined as call-saved by the
1598 ABI; for call-clobbered registers the parser may have recognized
1601 for (i = 0; i < 16; i++)
1602 if (s390_register_call_saved (gdbarch, S390_R0_REGNUM + i)
1603 && data.gpr_slot[i] != 0)
1604 info->saved_regs[S390_R0_REGNUM + i].addr = cfa - data.gpr_slot[i];
1606 for (i = 0; i < 16; i++)
1607 if (s390_register_call_saved (gdbarch, S390_F0_REGNUM + i)
1608 && data.fpr_slot[i] != 0)
1609 info->saved_regs[S390_F0_REGNUM + i].addr = cfa - data.fpr_slot[i];
1611 /* Function return will set PC to %r14. */
1612 info->saved_regs[tdep->pc_regnum] = info->saved_regs[S390_RETADDR_REGNUM];
1614 /* In frameless functions, we unwind simply by moving the return
1615 address to the PC. However, if we actually stored to the
1616 save area, use that -- we might only think the function frameless
1617 because we're in the middle of the prologue ... */
1619 && !trad_frame_addr_p (info->saved_regs, tdep->pc_regnum))
1621 info->saved_regs[tdep->pc_regnum].realreg = S390_RETADDR_REGNUM;
1624 /* Another sanity check: unless this is a frameless function,
1625 we should have found spill slots for SP and PC.
1626 If not, we cannot unwind further -- this happens e.g. in
1627 libc's thread_start routine. */
1630 if (!trad_frame_addr_p (info->saved_regs, S390_SP_REGNUM)
1631 || !trad_frame_addr_p (info->saved_regs, tdep->pc_regnum))
1635 /* We use the current value of the frame register as local_base,
1636 and the top of the register save area as frame_base. */
1639 info->frame_base = prev_sp + 16*word_size + 32;
1640 info->local_base = prev_sp - size;
1648 s390_backchain_frame_unwind_cache (struct frame_info *this_frame,
1649 struct s390_unwind_cache *info)
1651 struct gdbarch *gdbarch = get_frame_arch (this_frame);
1652 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1653 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1654 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1655 CORE_ADDR backchain;
1660 /* Set up ABI call-saved/call-clobbered registers. */
1661 for (i = 0; i < S390_NUM_REGS; i++)
1662 if (!s390_register_call_saved (gdbarch, i))
1663 trad_frame_set_unknown (info->saved_regs, i);
1665 /* CC is always call-clobbered. */
1666 trad_frame_set_unknown (info->saved_regs, tdep->cc_regnum);
1668 /* Get the backchain. */
1669 reg = get_frame_register_unsigned (this_frame, S390_SP_REGNUM);
1670 backchain = read_memory_unsigned_integer (reg, word_size, byte_order);
1672 /* A zero backchain terminates the frame chain. As additional
1673 sanity check, let's verify that the spill slot for SP in the
1674 save area pointed to by the backchain in fact links back to
1677 && safe_read_memory_integer (backchain + 15*word_size,
1678 word_size, byte_order, &sp)
1679 && (CORE_ADDR)sp == backchain)
1681 /* We don't know which registers were saved, but it will have
1682 to be at least %r14 and %r15. This will allow us to continue
1683 unwinding, but other prev-frame registers may be incorrect ... */
1684 info->saved_regs[S390_SP_REGNUM].addr = backchain + 15*word_size;
1685 info->saved_regs[S390_RETADDR_REGNUM].addr = backchain + 14*word_size;
1687 /* Function return will set PC to %r14. */
1688 info->saved_regs[tdep->pc_regnum]
1689 = info->saved_regs[S390_RETADDR_REGNUM];
1691 /* We use the current value of the frame register as local_base,
1692 and the top of the register save area as frame_base. */
1693 info->frame_base = backchain + 16*word_size + 32;
1694 info->local_base = reg;
1697 info->func = get_frame_pc (this_frame);
1700 static struct s390_unwind_cache *
1701 s390_frame_unwind_cache (struct frame_info *this_frame,
1702 void **this_prologue_cache)
1704 struct s390_unwind_cache *info;
1705 if (*this_prologue_cache)
1706 return *this_prologue_cache;
1708 info = FRAME_OBSTACK_ZALLOC (struct s390_unwind_cache);
1709 *this_prologue_cache = info;
1710 info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
1712 info->frame_base = -1;
1713 info->local_base = -1;
1715 /* Try to use prologue analysis to fill the unwind cache.
1716 If this fails, fall back to reading the stack backchain. */
1717 if (!s390_prologue_frame_unwind_cache (this_frame, info))
1718 s390_backchain_frame_unwind_cache (this_frame, info);
1724 s390_frame_this_id (struct frame_info *this_frame,
1725 void **this_prologue_cache,
1726 struct frame_id *this_id)
1728 struct s390_unwind_cache *info
1729 = s390_frame_unwind_cache (this_frame, this_prologue_cache);
1731 if (info->frame_base == -1)
1734 *this_id = frame_id_build (info->frame_base, info->func);
1737 static struct value *
1738 s390_frame_prev_register (struct frame_info *this_frame,
1739 void **this_prologue_cache, int regnum)
1741 struct gdbarch *gdbarch = get_frame_arch (this_frame);
1742 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1743 struct s390_unwind_cache *info
1744 = s390_frame_unwind_cache (this_frame, this_prologue_cache);
1746 /* Unwind full GPRs to show at least the lower halves (as the
1747 upper halves are undefined). */
1748 if (tdep->gpr_full_regnum != -1
1749 && regnum >= tdep->gpr_full_regnum
1750 && regnum < tdep->gpr_full_regnum + 16)
1752 int reg = regnum - tdep->gpr_full_regnum + S390_R0_REGNUM;
1753 struct value *val, *newval;
1755 val = trad_frame_get_prev_register (this_frame, info->saved_regs, reg);
1756 newval = value_cast (register_type (gdbarch, regnum), val);
1757 if (value_optimized_out (val))
1758 set_value_optimized_out (newval, 1);
1763 return trad_frame_get_prev_register (this_frame, info->saved_regs, regnum);
1766 static const struct frame_unwind s390_frame_unwind = {
1768 default_frame_unwind_stop_reason,
1770 s390_frame_prev_register,
1772 default_frame_sniffer
1776 /* Code stubs and their stack frames. For things like PLTs and NULL
1777 function calls (where there is no true frame and the return address
1778 is in the RETADDR register). */
1780 struct s390_stub_unwind_cache
1782 CORE_ADDR frame_base;
1783 struct trad_frame_saved_reg *saved_regs;
1786 static struct s390_stub_unwind_cache *
1787 s390_stub_frame_unwind_cache (struct frame_info *this_frame,
1788 void **this_prologue_cache)
1790 struct gdbarch *gdbarch = get_frame_arch (this_frame);
1791 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1792 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1793 struct s390_stub_unwind_cache *info;
1796 if (*this_prologue_cache)
1797 return *this_prologue_cache;
1799 info = FRAME_OBSTACK_ZALLOC (struct s390_stub_unwind_cache);
1800 *this_prologue_cache = info;
1801 info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
1803 /* The return address is in register %r14. */
1804 info->saved_regs[tdep->pc_regnum].realreg = S390_RETADDR_REGNUM;
1806 /* Retrieve stack pointer and determine our frame base. */
1807 reg = get_frame_register_unsigned (this_frame, S390_SP_REGNUM);
1808 info->frame_base = reg + 16*word_size + 32;
1814 s390_stub_frame_this_id (struct frame_info *this_frame,
1815 void **this_prologue_cache,
1816 struct frame_id *this_id)
1818 struct s390_stub_unwind_cache *info
1819 = s390_stub_frame_unwind_cache (this_frame, this_prologue_cache);
1820 *this_id = frame_id_build (info->frame_base, get_frame_pc (this_frame));
1823 static struct value *
1824 s390_stub_frame_prev_register (struct frame_info *this_frame,
1825 void **this_prologue_cache, int regnum)
1827 struct s390_stub_unwind_cache *info
1828 = s390_stub_frame_unwind_cache (this_frame, this_prologue_cache);
1829 return trad_frame_get_prev_register (this_frame, info->saved_regs, regnum);
1833 s390_stub_frame_sniffer (const struct frame_unwind *self,
1834 struct frame_info *this_frame,
1835 void **this_prologue_cache)
1837 CORE_ADDR addr_in_block;
1838 bfd_byte insn[S390_MAX_INSTR_SIZE];
1840 /* If the current PC points to non-readable memory, we assume we
1841 have trapped due to an invalid function pointer call. We handle
1842 the non-existing current function like a PLT stub. */
1843 addr_in_block = get_frame_address_in_block (this_frame);
1844 if (in_plt_section (addr_in_block, NULL)
1845 || s390_readinstruction (insn, get_frame_pc (this_frame)) < 0)
1850 static const struct frame_unwind s390_stub_frame_unwind = {
1852 default_frame_unwind_stop_reason,
1853 s390_stub_frame_this_id,
1854 s390_stub_frame_prev_register,
1856 s390_stub_frame_sniffer
1860 /* Signal trampoline stack frames. */
1862 struct s390_sigtramp_unwind_cache {
1863 CORE_ADDR frame_base;
1864 struct trad_frame_saved_reg *saved_regs;
1867 static struct s390_sigtramp_unwind_cache *
1868 s390_sigtramp_frame_unwind_cache (struct frame_info *this_frame,
1869 void **this_prologue_cache)
1871 struct gdbarch *gdbarch = get_frame_arch (this_frame);
1872 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1873 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1874 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1875 struct s390_sigtramp_unwind_cache *info;
1876 ULONGEST this_sp, prev_sp;
1877 CORE_ADDR next_ra, next_cfa, sigreg_ptr, sigreg_high_off;
1881 if (*this_prologue_cache)
1882 return *this_prologue_cache;
1884 info = FRAME_OBSTACK_ZALLOC (struct s390_sigtramp_unwind_cache);
1885 *this_prologue_cache = info;
1886 info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
1888 this_sp = get_frame_register_unsigned (this_frame, S390_SP_REGNUM);
1889 next_ra = get_frame_pc (this_frame);
1890 next_cfa = this_sp + 16*word_size + 32;
1892 /* New-style RT frame:
1893 retcode + alignment (8 bytes)
1895 ucontext (contains sigregs at offset 5 words). */
1896 if (next_ra == next_cfa)
1898 sigreg_ptr = next_cfa + 8 + 128 + align_up (5*word_size, 8);
1899 /* sigregs are followed by uc_sigmask (8 bytes), then by the
1900 upper GPR halves if present. */
1901 sigreg_high_off = 8;
1904 /* Old-style RT frame and all non-RT frames:
1905 old signal mask (8 bytes)
1906 pointer to sigregs. */
1909 sigreg_ptr = read_memory_unsigned_integer (next_cfa + 8,
1910 word_size, byte_order);
1911 /* sigregs are followed by signo (4 bytes), then by the
1912 upper GPR halves if present. */
1913 sigreg_high_off = 4;
1916 /* The sigregs structure looks like this:
1925 /* PSW mask and address. */
1926 info->saved_regs[S390_PSWM_REGNUM].addr = sigreg_ptr;
1927 sigreg_ptr += word_size;
1928 info->saved_regs[S390_PSWA_REGNUM].addr = sigreg_ptr;
1929 sigreg_ptr += word_size;
1931 /* Point PC to PSWA as well. */
1932 info->saved_regs[tdep->pc_regnum] = info->saved_regs[S390_PSWA_REGNUM];
1934 /* Extract CC from PSWM. */
1935 pswm = read_memory_unsigned_integer (
1936 info->saved_regs[S390_PSWM_REGNUM].addr,
1937 word_size, byte_order);
1938 trad_frame_set_value (info->saved_regs, tdep->cc_regnum,
1939 (pswm >> (8 * word_size - 20)) & 3);
1941 /* Then the GPRs. */
1942 for (i = 0; i < 16; i++)
1944 info->saved_regs[S390_R0_REGNUM + i].addr = sigreg_ptr;
1945 sigreg_ptr += word_size;
1948 /* Then the ACRs. */
1949 for (i = 0; i < 16; i++)
1951 info->saved_regs[S390_A0_REGNUM + i].addr = sigreg_ptr;
1955 /* The floating-point control word. */
1956 info->saved_regs[S390_FPC_REGNUM].addr = sigreg_ptr;
1959 /* And finally the FPRs. */
1960 for (i = 0; i < 16; i++)
1962 info->saved_regs[S390_F0_REGNUM + i].addr = sigreg_ptr;
1966 /* If we have them, the GPR upper halves are appended at the end. */
1967 sigreg_ptr += sigreg_high_off;
1968 if (tdep->gpr_full_regnum != -1)
1969 for (i = 0; i < 16; i++)
1971 info->saved_regs[S390_R0_UPPER_REGNUM + i].addr = sigreg_ptr;
1975 /* Provide read-only copies of the full registers. */
1976 if (tdep->gpr_full_regnum != -1)
1977 for (i = 0; i < 16; i++)
1980 low = read_memory_unsigned_integer (
1981 info->saved_regs[S390_R0_REGNUM + i].addr,
1983 high = read_memory_unsigned_integer (
1984 info->saved_regs[S390_R0_UPPER_REGNUM + i].addr,
1987 trad_frame_set_value (info->saved_regs, tdep->gpr_full_regnum + i,
1988 (high << 32) | low);
1991 /* Restore the previous frame's SP. */
1992 prev_sp = read_memory_unsigned_integer (
1993 info->saved_regs[S390_SP_REGNUM].addr,
1994 word_size, byte_order);
1996 /* Determine our frame base. */
1997 info->frame_base = prev_sp + 16*word_size + 32;
2003 s390_sigtramp_frame_this_id (struct frame_info *this_frame,
2004 void **this_prologue_cache,
2005 struct frame_id *this_id)
2007 struct s390_sigtramp_unwind_cache *info
2008 = s390_sigtramp_frame_unwind_cache (this_frame, this_prologue_cache);
2009 *this_id = frame_id_build (info->frame_base, get_frame_pc (this_frame));
2012 static struct value *
2013 s390_sigtramp_frame_prev_register (struct frame_info *this_frame,
2014 void **this_prologue_cache, int regnum)
2016 struct s390_sigtramp_unwind_cache *info
2017 = s390_sigtramp_frame_unwind_cache (this_frame, this_prologue_cache);
2018 return trad_frame_get_prev_register (this_frame, info->saved_regs, regnum);
2022 s390_sigtramp_frame_sniffer (const struct frame_unwind *self,
2023 struct frame_info *this_frame,
2024 void **this_prologue_cache)
2026 CORE_ADDR pc = get_frame_pc (this_frame);
2027 bfd_byte sigreturn[2];
2029 if (target_read_memory (pc, sigreturn, 2))
2032 if (sigreturn[0] != 0x0a /* svc */)
2035 if (sigreturn[1] != 119 /* sigreturn */
2036 && sigreturn[1] != 173 /* rt_sigreturn */)
2042 static const struct frame_unwind s390_sigtramp_frame_unwind = {
2044 default_frame_unwind_stop_reason,
2045 s390_sigtramp_frame_this_id,
2046 s390_sigtramp_frame_prev_register,
2048 s390_sigtramp_frame_sniffer
2052 /* Frame base handling. */
2055 s390_frame_base_address (struct frame_info *this_frame, void **this_cache)
2057 struct s390_unwind_cache *info
2058 = s390_frame_unwind_cache (this_frame, this_cache);
2059 return info->frame_base;
2063 s390_local_base_address (struct frame_info *this_frame, void **this_cache)
2065 struct s390_unwind_cache *info
2066 = s390_frame_unwind_cache (this_frame, this_cache);
2067 return info->local_base;
2070 static const struct frame_base s390_frame_base = {
2072 s390_frame_base_address,
2073 s390_local_base_address,
2074 s390_local_base_address
2078 s390_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
2080 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2082 pc = frame_unwind_register_unsigned (next_frame, tdep->pc_regnum);
2083 return gdbarch_addr_bits_remove (gdbarch, pc);
2087 s390_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
2090 sp = frame_unwind_register_unsigned (next_frame, S390_SP_REGNUM);
2091 return gdbarch_addr_bits_remove (gdbarch, sp);
2095 /* DWARF-2 frame support. */
2097 static struct value *
2098 s390_dwarf2_prev_register (struct frame_info *this_frame, void **this_cache,
2101 struct gdbarch *gdbarch = get_frame_arch (this_frame);
2102 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2103 int reg = regnum - tdep->gpr_full_regnum;
2104 struct value *val, *newval;
2106 val = frame_unwind_register_value (this_frame, S390_R0_REGNUM + reg);
2107 newval = value_cast (register_type (gdbarch, regnum), val);
2108 if (value_optimized_out (val))
2109 set_value_optimized_out (newval, 1);
2115 s390_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
2116 struct dwarf2_frame_state_reg *reg,
2117 struct frame_info *this_frame)
2119 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2121 /* Fixed registers are call-saved or call-clobbered
2122 depending on the ABI in use. */
2123 if (regnum >= 0 && regnum < S390_NUM_REGS)
2125 if (s390_register_call_saved (gdbarch, regnum))
2126 reg->how = DWARF2_FRAME_REG_SAME_VALUE;
2128 reg->how = DWARF2_FRAME_REG_UNDEFINED;
2131 /* The CC pseudo register is call-clobbered. */
2132 else if (regnum == tdep->cc_regnum)
2133 reg->how = DWARF2_FRAME_REG_UNDEFINED;
2135 /* The PC register unwinds to the return address. */
2136 else if (regnum == tdep->pc_regnum)
2137 reg->how = DWARF2_FRAME_REG_RA;
2139 /* We install a special function to unwind full GPRs to show at
2140 least the lower halves (as the upper halves are undefined). */
2141 else if (tdep->gpr_full_regnum != -1
2142 && regnum >= tdep->gpr_full_regnum
2143 && regnum < tdep->gpr_full_regnum + 16)
2145 reg->how = DWARF2_FRAME_REG_FN;
2146 reg->loc.fn = s390_dwarf2_prev_register;
2151 /* Dummy function calls. */
2153 /* Return non-zero if TYPE is an integer-like type, zero otherwise.
2154 "Integer-like" types are those that should be passed the way
2155 integers are: integers, enums, ranges, characters, and booleans. */
2157 is_integer_like (struct type *type)
2159 enum type_code code = TYPE_CODE (type);
2161 return (code == TYPE_CODE_INT
2162 || code == TYPE_CODE_ENUM
2163 || code == TYPE_CODE_RANGE
2164 || code == TYPE_CODE_CHAR
2165 || code == TYPE_CODE_BOOL);
2168 /* Return non-zero if TYPE is a pointer-like type, zero otherwise.
2169 "Pointer-like" types are those that should be passed the way
2170 pointers are: pointers and references. */
2172 is_pointer_like (struct type *type)
2174 enum type_code code = TYPE_CODE (type);
2176 return (code == TYPE_CODE_PTR
2177 || code == TYPE_CODE_REF);
2181 /* Return non-zero if TYPE is a `float singleton' or `double
2182 singleton', zero otherwise.
2184 A `T singleton' is a struct type with one member, whose type is
2185 either T or a `T singleton'. So, the following are all float
2189 struct { struct { float x; } x; };
2190 struct { struct { struct { float x; } x; } x; };
2194 All such structures are passed as if they were floats or doubles,
2195 as the (revised) ABI says. */
2197 is_float_singleton (struct type *type)
2199 if (TYPE_CODE (type) == TYPE_CODE_STRUCT && TYPE_NFIELDS (type) == 1)
2201 struct type *singleton_type = TYPE_FIELD_TYPE (type, 0);
2202 CHECK_TYPEDEF (singleton_type);
2204 return (TYPE_CODE (singleton_type) == TYPE_CODE_FLT
2205 || TYPE_CODE (singleton_type) == TYPE_CODE_DECFLOAT
2206 || is_float_singleton (singleton_type));
2213 /* Return non-zero if TYPE is a struct-like type, zero otherwise.
2214 "Struct-like" types are those that should be passed as structs are:
2217 As an odd quirk, not mentioned in the ABI, GCC passes float and
2218 double singletons as if they were a plain float, double, etc. (The
2219 corresponding union types are handled normally.) So we exclude
2220 those types here. *shrug* */
2222 is_struct_like (struct type *type)
2224 enum type_code code = TYPE_CODE (type);
2226 return (code == TYPE_CODE_UNION
2227 || (code == TYPE_CODE_STRUCT && ! is_float_singleton (type)));
2231 /* Return non-zero if TYPE is a float-like type, zero otherwise.
2232 "Float-like" types are those that should be passed as
2233 floating-point values are.
2235 You'd think this would just be floats, doubles, long doubles, etc.
2236 But as an odd quirk, not mentioned in the ABI, GCC passes float and
2237 double singletons as if they were a plain float, double, etc. (The
2238 corresponding union types are handled normally.) So we include
2239 those types here. *shrug* */
2241 is_float_like (struct type *type)
2243 return (TYPE_CODE (type) == TYPE_CODE_FLT
2244 || TYPE_CODE (type) == TYPE_CODE_DECFLOAT
2245 || is_float_singleton (type));
2250 is_power_of_two (unsigned int n)
2252 return ((n & (n - 1)) == 0);
2255 /* Return non-zero if TYPE should be passed as a pointer to a copy,
2258 s390_function_arg_pass_by_reference (struct type *type)
2260 unsigned length = TYPE_LENGTH (type);
2264 return (is_struct_like (type) && !is_power_of_two (TYPE_LENGTH (type)))
2265 || TYPE_CODE (type) == TYPE_CODE_COMPLEX
2266 || (TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type));
2269 /* Return non-zero if TYPE should be passed in a float register
2272 s390_function_arg_float (struct type *type)
2274 unsigned length = TYPE_LENGTH (type);
2278 return is_float_like (type);
2281 /* Return non-zero if TYPE should be passed in an integer register
2282 (or a pair of integer registers) if possible. */
2284 s390_function_arg_integer (struct type *type)
2286 unsigned length = TYPE_LENGTH (type);
2290 return is_integer_like (type)
2291 || is_pointer_like (type)
2292 || (is_struct_like (type) && is_power_of_two (length));
2295 /* Return ARG, a `SIMPLE_ARG', sign-extended or zero-extended to a full
2296 word as required for the ABI. */
2298 extend_simple_arg (struct gdbarch *gdbarch, struct value *arg)
2300 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2301 struct type *type = check_typedef (value_type (arg));
2303 /* Even structs get passed in the least significant bits of the
2304 register / memory word. It's not really right to extract them as
2305 an integer, but it does take care of the extension. */
2306 if (TYPE_UNSIGNED (type))
2307 return extract_unsigned_integer (value_contents (arg),
2308 TYPE_LENGTH (type), byte_order);
2310 return extract_signed_integer (value_contents (arg),
2311 TYPE_LENGTH (type), byte_order);
2315 /* Return the alignment required by TYPE. */
2317 alignment_of (struct type *type)
2321 if (is_integer_like (type)
2322 || is_pointer_like (type)
2323 || TYPE_CODE (type) == TYPE_CODE_FLT
2324 || TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
2325 alignment = TYPE_LENGTH (type);
2326 else if (TYPE_CODE (type) == TYPE_CODE_STRUCT
2327 || TYPE_CODE (type) == TYPE_CODE_UNION)
2332 for (i = 0; i < TYPE_NFIELDS (type); i++)
2335 = alignment_of (check_typedef (TYPE_FIELD_TYPE (type, i)));
2337 if (field_alignment > alignment)
2338 alignment = field_alignment;
2344 /* Check that everything we ever return is a power of two. Lots of
2345 code doesn't want to deal with aligning things to arbitrary
2347 gdb_assert ((alignment & (alignment - 1)) == 0);
2353 /* Put the actual parameter values pointed to by ARGS[0..NARGS-1] in
2354 place to be passed to a function, as specified by the "GNU/Linux
2355 for S/390 ELF Application Binary Interface Supplement".
2357 SP is the current stack pointer. We must put arguments, links,
2358 padding, etc. whereever they belong, and return the new stack
2361 If STRUCT_RETURN is non-zero, then the function we're calling is
2362 going to return a structure by value; STRUCT_ADDR is the address of
2363 a block we've allocated for it on the stack.
2365 Our caller has taken care of any type promotions needed to satisfy
2366 prototypes or the old K&R argument-passing rules. */
2368 s390_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
2369 struct regcache *regcache, CORE_ADDR bp_addr,
2370 int nargs, struct value **args, CORE_ADDR sp,
2371 int struct_return, CORE_ADDR struct_addr)
2373 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2374 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
2375 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2378 /* If the i'th argument is passed as a reference to a copy, then
2379 copy_addr[i] is the address of the copy we made. */
2380 CORE_ADDR *copy_addr = alloca (nargs * sizeof (CORE_ADDR));
2382 /* Reserve space for the reference-to-copy area. */
2383 for (i = 0; i < nargs; i++)
2385 struct value *arg = args[i];
2386 struct type *type = check_typedef (value_type (arg));
2387 unsigned length = TYPE_LENGTH (type);
2389 if (s390_function_arg_pass_by_reference (type))
2392 sp = align_down (sp, alignment_of (type));
2397 /* Reserve space for the parameter area. As a conservative
2398 simplification, we assume that everything will be passed on the
2399 stack. Since every argument larger than 8 bytes will be
2400 passed by reference, we use this simple upper bound. */
2403 /* After all that, make sure it's still aligned on an eight-byte
2405 sp = align_down (sp, 8);
2407 /* Allocate the standard frame areas: the register save area, the
2408 word reserved for the compiler (which seems kind of meaningless),
2409 and the back chain pointer. */
2410 sp -= 16*word_size + 32;
2412 /* Now we have the final SP value. Make sure we didn't underflow;
2413 on 31-bit, this would result in addresses with the high bit set,
2414 which causes confusion elsewhere. Note that if we error out
2415 here, stack and registers remain untouched. */
2416 if (gdbarch_addr_bits_remove (gdbarch, sp) != sp)
2417 error (_("Stack overflow"));
2420 /* Finally, place the actual parameters, working from SP towards
2421 higher addresses. The code above is supposed to reserve enough
2426 CORE_ADDR starg = sp + 16*word_size + 32;
2428 /* A struct is returned using general register 2. */
2431 regcache_cooked_write_unsigned (regcache, S390_R0_REGNUM + gr,
2436 for (i = 0; i < nargs; i++)
2438 struct value *arg = args[i];
2439 struct type *type = check_typedef (value_type (arg));
2440 unsigned length = TYPE_LENGTH (type);
2442 if (s390_function_arg_pass_by_reference (type))
2444 /* Actually copy the argument contents to the stack slot
2445 that was reserved above. */
2446 write_memory (copy_addr[i], value_contents (arg), length);
2450 regcache_cooked_write_unsigned (regcache, S390_R0_REGNUM + gr,
2456 write_memory_unsigned_integer (starg, word_size, byte_order,
2461 else if (s390_function_arg_float (type))
2463 /* The GNU/Linux for S/390 ABI uses FPRs 0 and 2 to pass arguments,
2464 the GNU/Linux for zSeries ABI uses 0, 2, 4, and 6. */
2465 if (fr <= (tdep->abi == ABI_LINUX_S390 ? 2 : 6))
2467 /* When we store a single-precision value in an FP register,
2468 it occupies the leftmost bits. */
2469 regcache_cooked_write_part (regcache, S390_F0_REGNUM + fr,
2470 0, length, value_contents (arg));
2475 /* When we store a single-precision value in a stack slot,
2476 it occupies the rightmost bits. */
2477 starg = align_up (starg + length, word_size);
2478 write_memory (starg - length, value_contents (arg), length);
2481 else if (s390_function_arg_integer (type) && length <= word_size)
2485 /* Integer arguments are always extended to word size. */
2486 regcache_cooked_write_signed (regcache, S390_R0_REGNUM + gr,
2487 extend_simple_arg (gdbarch,
2493 /* Integer arguments are always extended to word size. */
2494 write_memory_signed_integer (starg, word_size, byte_order,
2495 extend_simple_arg (gdbarch, arg));
2499 else if (s390_function_arg_integer (type) && length == 2*word_size)
2503 regcache_cooked_write (regcache, S390_R0_REGNUM + gr,
2504 value_contents (arg));
2505 regcache_cooked_write (regcache, S390_R0_REGNUM + gr + 1,
2506 value_contents (arg) + word_size);
2511 /* If we skipped r6 because we couldn't fit a DOUBLE_ARG
2512 in it, then don't go back and use it again later. */
2515 write_memory (starg, value_contents (arg), length);
2520 internal_error (__FILE__, __LINE__, _("unknown argument type"));
2524 /* Store return address. */
2525 regcache_cooked_write_unsigned (regcache, S390_RETADDR_REGNUM, bp_addr);
2527 /* Store updated stack pointer. */
2528 regcache_cooked_write_unsigned (regcache, S390_SP_REGNUM, sp);
2530 /* We need to return the 'stack part' of the frame ID,
2531 which is actually the top of the register save area. */
2532 return sp + 16*word_size + 32;
2535 /* Assuming THIS_FRAME is a dummy, return the frame ID of that
2536 dummy frame. The frame ID's base needs to match the TOS value
2537 returned by push_dummy_call, and the PC match the dummy frame's
2539 static struct frame_id
2540 s390_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
2542 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
2543 CORE_ADDR sp = get_frame_register_unsigned (this_frame, S390_SP_REGNUM);
2544 sp = gdbarch_addr_bits_remove (gdbarch, sp);
2546 return frame_id_build (sp + 16*word_size + 32,
2547 get_frame_pc (this_frame));
2551 s390_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
2553 /* Both the 32- and 64-bit ABI's say that the stack pointer should
2554 always be aligned on an eight-byte boundary. */
2559 /* Function return value access. */
2561 static enum return_value_convention
2562 s390_return_value_convention (struct gdbarch *gdbarch, struct type *type)
2564 int length = TYPE_LENGTH (type);
2566 return RETURN_VALUE_STRUCT_CONVENTION;
2568 switch (TYPE_CODE (type))
2570 case TYPE_CODE_STRUCT:
2571 case TYPE_CODE_UNION:
2572 case TYPE_CODE_ARRAY:
2573 case TYPE_CODE_COMPLEX:
2574 return RETURN_VALUE_STRUCT_CONVENTION;
2577 return RETURN_VALUE_REGISTER_CONVENTION;
2581 static enum return_value_convention
2582 s390_return_value (struct gdbarch *gdbarch, struct type *func_type,
2583 struct type *type, struct regcache *regcache,
2584 gdb_byte *out, const gdb_byte *in)
2586 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2587 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
2588 enum return_value_convention rvc;
2591 type = check_typedef (type);
2592 rvc = s390_return_value_convention (gdbarch, type);
2593 length = TYPE_LENGTH (type);
2599 case RETURN_VALUE_REGISTER_CONVENTION:
2600 if (TYPE_CODE (type) == TYPE_CODE_FLT
2601 || TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
2603 /* When we store a single-precision value in an FP register,
2604 it occupies the leftmost bits. */
2605 regcache_cooked_write_part (regcache, S390_F0_REGNUM,
2608 else if (length <= word_size)
2610 /* Integer arguments are always extended to word size. */
2611 if (TYPE_UNSIGNED (type))
2612 regcache_cooked_write_unsigned (regcache, S390_R2_REGNUM,
2613 extract_unsigned_integer (in, length, byte_order));
2615 regcache_cooked_write_signed (regcache, S390_R2_REGNUM,
2616 extract_signed_integer (in, length, byte_order));
2618 else if (length == 2*word_size)
2620 regcache_cooked_write (regcache, S390_R2_REGNUM, in);
2621 regcache_cooked_write (regcache, S390_R3_REGNUM, in + word_size);
2624 internal_error (__FILE__, __LINE__, _("invalid return type"));
2627 case RETURN_VALUE_STRUCT_CONVENTION:
2628 error (_("Cannot set function return value."));
2636 case RETURN_VALUE_REGISTER_CONVENTION:
2637 if (TYPE_CODE (type) == TYPE_CODE_FLT
2638 || TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
2640 /* When we store a single-precision value in an FP register,
2641 it occupies the leftmost bits. */
2642 regcache_cooked_read_part (regcache, S390_F0_REGNUM,
2645 else if (length <= word_size)
2647 /* Integer arguments occupy the rightmost bits. */
2648 regcache_cooked_read_part (regcache, S390_R2_REGNUM,
2649 word_size - length, length, out);
2651 else if (length == 2*word_size)
2653 regcache_cooked_read (regcache, S390_R2_REGNUM, out);
2654 regcache_cooked_read (regcache, S390_R3_REGNUM, out + word_size);
2657 internal_error (__FILE__, __LINE__, _("invalid return type"));
2660 case RETURN_VALUE_STRUCT_CONVENTION:
2661 error (_("Function return value unknown."));
2672 static const gdb_byte *
2673 s390_breakpoint_from_pc (struct gdbarch *gdbarch,
2674 CORE_ADDR *pcptr, int *lenptr)
2676 static const gdb_byte breakpoint[] = { 0x0, 0x1 };
2678 *lenptr = sizeof (breakpoint);
2683 /* Address handling. */
2686 s390_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr)
2688 return addr & 0x7fffffff;
2692 s390_address_class_type_flags (int byte_size, int dwarf2_addr_class)
2695 return TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1;
2701 s390_address_class_type_flags_to_name (struct gdbarch *gdbarch, int type_flags)
2703 if (type_flags & TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1)
2710 s390_address_class_name_to_type_flags (struct gdbarch *gdbarch,
2712 int *type_flags_ptr)
2714 if (strcmp (name, "mode32") == 0)
2716 *type_flags_ptr = TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1;
2723 /* Set up gdbarch struct. */
2725 static struct gdbarch *
2726 s390_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
2728 const struct target_desc *tdesc = info.target_desc;
2729 struct tdesc_arch_data *tdesc_data = NULL;
2730 struct gdbarch *gdbarch;
2731 struct gdbarch_tdep *tdep;
2734 int first_pseudo_reg, last_pseudo_reg;
2736 /* Default ABI and register size. */
2737 switch (info.bfd_arch_info->mach)
2739 case bfd_mach_s390_31:
2740 tdep_abi = ABI_LINUX_S390;
2743 case bfd_mach_s390_64:
2744 tdep_abi = ABI_LINUX_ZSERIES;
2751 /* Use default target description if none provided by the target. */
2752 if (!tdesc_has_registers (tdesc))
2754 if (tdep_abi == ABI_LINUX_S390)
2755 tdesc = tdesc_s390_linux32;
2757 tdesc = tdesc_s390x_linux64;
2760 /* Check any target description for validity. */
2761 if (tdesc_has_registers (tdesc))
2763 static const char *const gprs[] = {
2764 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2765 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
2767 static const char *const fprs[] = {
2768 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
2769 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15"
2771 static const char *const acrs[] = {
2772 "acr0", "acr1", "acr2", "acr3", "acr4", "acr5", "acr6", "acr7",
2773 "acr8", "acr9", "acr10", "acr11", "acr12", "acr13", "acr14", "acr15"
2775 static const char *const gprs_lower[] = {
2776 "r0l", "r1l", "r2l", "r3l", "r4l", "r5l", "r6l", "r7l",
2777 "r8l", "r9l", "r10l", "r11l", "r12l", "r13l", "r14l", "r15l"
2779 static const char *const gprs_upper[] = {
2780 "r0h", "r1h", "r2h", "r3h", "r4h", "r5h", "r6h", "r7h",
2781 "r8h", "r9h", "r10h", "r11h", "r12h", "r13h", "r14h", "r15h"
2783 const struct tdesc_feature *feature;
2786 feature = tdesc_find_feature (tdesc, "org.gnu.gdb.s390.core");
2787 if (feature == NULL)
2790 tdesc_data = tdesc_data_alloc ();
2792 valid_p &= tdesc_numbered_register (feature, tdesc_data,
2793 S390_PSWM_REGNUM, "pswm");
2794 valid_p &= tdesc_numbered_register (feature, tdesc_data,
2795 S390_PSWA_REGNUM, "pswa");
2797 if (tdesc_unnumbered_register (feature, "r0"))
2799 for (i = 0; i < 16; i++)
2800 valid_p &= tdesc_numbered_register (feature, tdesc_data,
2801 S390_R0_REGNUM + i, gprs[i]);
2807 for (i = 0; i < 16; i++)
2808 valid_p &= tdesc_numbered_register (feature, tdesc_data,
2811 for (i = 0; i < 16; i++)
2812 valid_p &= tdesc_numbered_register (feature, tdesc_data,
2813 S390_R0_UPPER_REGNUM + i,
2817 feature = tdesc_find_feature (tdesc, "org.gnu.gdb.s390.fpr");
2818 if (feature == NULL)
2820 tdesc_data_cleanup (tdesc_data);
2824 valid_p &= tdesc_numbered_register (feature, tdesc_data,
2825 S390_FPC_REGNUM, "fpc");
2826 for (i = 0; i < 16; i++)
2827 valid_p &= tdesc_numbered_register (feature, tdesc_data,
2828 S390_F0_REGNUM + i, fprs[i]);
2830 feature = tdesc_find_feature (tdesc, "org.gnu.gdb.s390.acr");
2831 if (feature == NULL)
2833 tdesc_data_cleanup (tdesc_data);
2837 for (i = 0; i < 16; i++)
2838 valid_p &= tdesc_numbered_register (feature, tdesc_data,
2839 S390_A0_REGNUM + i, acrs[i]);
2843 tdesc_data_cleanup (tdesc_data);
2848 /* Find a candidate among extant architectures. */
2849 for (arches = gdbarch_list_lookup_by_info (arches, &info);
2851 arches = gdbarch_list_lookup_by_info (arches->next, &info))
2853 tdep = gdbarch_tdep (arches->gdbarch);
2856 if (tdep->abi != tdep_abi)
2858 if ((tdep->gpr_full_regnum != -1) != have_upper)
2860 if (tdesc_data != NULL)
2861 tdesc_data_cleanup (tdesc_data);
2862 return arches->gdbarch;
2865 /* Otherwise create a new gdbarch for the specified machine type. */
2866 tdep = XCALLOC (1, struct gdbarch_tdep);
2867 tdep->abi = tdep_abi;
2868 gdbarch = gdbarch_alloc (&info, tdep);
2870 set_gdbarch_believe_pcc_promotion (gdbarch, 0);
2871 set_gdbarch_char_signed (gdbarch, 0);
2873 /* S/390 GNU/Linux uses either 64-bit or 128-bit long doubles.
2874 We can safely let them default to 128-bit, since the debug info
2875 will give the size of type actually used in each case. */
2876 set_gdbarch_long_double_bit (gdbarch, 128);
2877 set_gdbarch_long_double_format (gdbarch, floatformats_ia64_quad);
2879 /* Amount PC must be decremented by after a breakpoint. This is
2880 often the number of bytes returned by gdbarch_breakpoint_from_pc but not
2882 set_gdbarch_decr_pc_after_break (gdbarch, 2);
2883 /* Stack grows downward. */
2884 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
2885 set_gdbarch_breakpoint_from_pc (gdbarch, s390_breakpoint_from_pc);
2886 set_gdbarch_skip_prologue (gdbarch, s390_skip_prologue);
2887 set_gdbarch_in_function_epilogue_p (gdbarch, s390_in_function_epilogue_p);
2889 set_gdbarch_num_regs (gdbarch, S390_NUM_REGS);
2890 set_gdbarch_sp_regnum (gdbarch, S390_SP_REGNUM);
2891 set_gdbarch_fp0_regnum (gdbarch, S390_F0_REGNUM);
2892 set_gdbarch_stab_reg_to_regnum (gdbarch, s390_dwarf_reg_to_regnum);
2893 set_gdbarch_dwarf2_reg_to_regnum (gdbarch, s390_dwarf_reg_to_regnum);
2894 set_gdbarch_value_from_register (gdbarch, s390_value_from_register);
2895 set_gdbarch_regset_from_core_section (gdbarch,
2896 s390_regset_from_core_section);
2897 set_gdbarch_core_read_description (gdbarch, s390_core_read_description);
2899 set_gdbarch_core_regset_sections (gdbarch, s390_upper_regset_sections);
2900 set_gdbarch_pseudo_register_read (gdbarch, s390_pseudo_register_read);
2901 set_gdbarch_pseudo_register_write (gdbarch, s390_pseudo_register_write);
2902 set_tdesc_pseudo_register_name (gdbarch, s390_pseudo_register_name);
2903 set_tdesc_pseudo_register_type (gdbarch, s390_pseudo_register_type);
2904 set_tdesc_pseudo_register_reggroup_p (gdbarch,
2905 s390_pseudo_register_reggroup_p);
2906 tdesc_use_registers (gdbarch, tdesc, tdesc_data);
2908 /* Assign pseudo register numbers. */
2909 first_pseudo_reg = gdbarch_num_regs (gdbarch);
2910 last_pseudo_reg = first_pseudo_reg;
2911 tdep->gpr_full_regnum = -1;
2914 tdep->gpr_full_regnum = last_pseudo_reg;
2915 last_pseudo_reg += 16;
2917 tdep->pc_regnum = last_pseudo_reg++;
2918 tdep->cc_regnum = last_pseudo_reg++;
2919 set_gdbarch_pc_regnum (gdbarch, tdep->pc_regnum);
2920 set_gdbarch_num_pseudo_regs (gdbarch, last_pseudo_reg - first_pseudo_reg);
2922 /* Inferior function calls. */
2923 set_gdbarch_push_dummy_call (gdbarch, s390_push_dummy_call);
2924 set_gdbarch_dummy_id (gdbarch, s390_dummy_id);
2925 set_gdbarch_frame_align (gdbarch, s390_frame_align);
2926 set_gdbarch_return_value (gdbarch, s390_return_value);
2928 /* Frame handling. */
2929 dwarf2_frame_set_init_reg (gdbarch, s390_dwarf2_frame_init_reg);
2930 dwarf2_frame_set_adjust_regnum (gdbarch, s390_adjust_frame_regnum);
2931 dwarf2_append_unwinders (gdbarch);
2932 frame_base_append_sniffer (gdbarch, dwarf2_frame_base_sniffer);
2933 frame_unwind_append_unwinder (gdbarch, &s390_stub_frame_unwind);
2934 frame_unwind_append_unwinder (gdbarch, &s390_sigtramp_frame_unwind);
2935 frame_unwind_append_unwinder (gdbarch, &s390_frame_unwind);
2936 frame_base_set_default (gdbarch, &s390_frame_base);
2937 set_gdbarch_unwind_pc (gdbarch, s390_unwind_pc);
2938 set_gdbarch_unwind_sp (gdbarch, s390_unwind_sp);
2940 /* Displaced stepping. */
2941 set_gdbarch_displaced_step_copy_insn (gdbarch,
2942 simple_displaced_step_copy_insn);
2943 set_gdbarch_displaced_step_fixup (gdbarch, s390_displaced_step_fixup);
2944 set_gdbarch_displaced_step_free_closure (gdbarch,
2945 simple_displaced_step_free_closure);
2946 set_gdbarch_displaced_step_location (gdbarch,
2947 displaced_step_at_entry_point);
2948 set_gdbarch_max_insn_length (gdbarch, S390_MAX_INSTR_SIZE);
2950 /* Note that GNU/Linux is the only OS supported on this
2952 linux_init_abi (info, gdbarch);
2956 case ABI_LINUX_S390:
2957 tdep->gregset = &s390_gregset;
2958 tdep->sizeof_gregset = s390_sizeof_gregset;
2959 tdep->fpregset = &s390_fpregset;
2960 tdep->sizeof_fpregset = s390_sizeof_fpregset;
2962 set_gdbarch_addr_bits_remove (gdbarch, s390_addr_bits_remove);
2963 set_solib_svr4_fetch_link_map_offsets
2964 (gdbarch, svr4_ilp32_fetch_link_map_offsets);
2967 case ABI_LINUX_ZSERIES:
2968 tdep->gregset = &s390x_gregset;
2969 tdep->sizeof_gregset = s390x_sizeof_gregset;
2970 tdep->fpregset = &s390_fpregset;
2971 tdep->sizeof_fpregset = s390_sizeof_fpregset;
2973 set_gdbarch_long_bit (gdbarch, 64);
2974 set_gdbarch_long_long_bit (gdbarch, 64);
2975 set_gdbarch_ptr_bit (gdbarch, 64);
2976 set_solib_svr4_fetch_link_map_offsets
2977 (gdbarch, svr4_lp64_fetch_link_map_offsets);
2978 set_gdbarch_address_class_type_flags (gdbarch,
2979 s390_address_class_type_flags);
2980 set_gdbarch_address_class_type_flags_to_name (gdbarch,
2981 s390_address_class_type_flags_to_name);
2982 set_gdbarch_address_class_name_to_type_flags (gdbarch,
2983 s390_address_class_name_to_type_flags);
2987 set_gdbarch_print_insn (gdbarch, print_insn_s390);
2989 set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
2991 /* Enable TLS support. */
2992 set_gdbarch_fetch_tls_load_module_address (gdbarch,
2993 svr4_fetch_objfile_link_map);
2999 extern initialize_file_ftype _initialize_s390_tdep; /* -Wmissing-prototypes */
3002 _initialize_s390_tdep (void)
3004 /* Hook us into the gdbarch mechanism. */
3005 register_gdbarch_init (bfd_arch_s390, s390_gdbarch_init);
3007 /* Initialize the Linux target descriptions. */
3008 initialize_tdesc_s390_linux32 ();
3009 initialize_tdesc_s390_linux64 ();
3010 initialize_tdesc_s390x_linux64 ();