1 /* Target-dependent code for GDB, the GNU debugger.
3 Copyright (C) 2001-2014 Free Software Foundation, Inc.
5 Contributed by D.J. Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
6 for IBM Deutschland Entwicklung GmbH, IBM Corporation.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "arch-utils.h"
33 #include "floatformat.h"
35 #include "trad-frame.h"
36 #include "frame-base.h"
37 #include "frame-unwind.h"
38 #include "dwarf2-frame.h"
39 #include "reggroups.h"
42 #include "gdb_assert.h"
44 #include "solib-svr4.h"
45 #include "prologue-value.h"
46 #include "linux-tdep.h"
47 #include "s390-linux-tdep.h"
49 #include "xml-syscall.h"
51 #include "stap-probe.h"
54 #include "user-regs.h"
55 #include "cli/cli-utils.h"
57 #include "elf/common.h"
59 #include "features/s390-linux32.c"
60 #include "features/s390-linux32v1.c"
61 #include "features/s390-linux32v2.c"
62 #include "features/s390-linux64.c"
63 #include "features/s390-linux64v1.c"
64 #include "features/s390-linux64v2.c"
65 #include "features/s390-te-linux64.c"
66 #include "features/s390x-linux64.c"
67 #include "features/s390x-linux64v1.c"
68 #include "features/s390x-linux64v2.c"
69 #include "features/s390x-te-linux64.c"
71 #define XML_SYSCALL_FILENAME_S390 "syscalls/s390-linux.xml"
72 #define XML_SYSCALL_FILENAME_S390X "syscalls/s390x-linux.xml"
74 /* The tdep structure. */
79 enum { ABI_LINUX_S390
, ABI_LINUX_ZSERIES
} abi
;
81 /* Pseudo register numbers. */
86 /* Core file register sets. */
87 const struct regset
*gregset
;
90 const struct regset
*fpregset
;
95 /* ABI call-saved register information. */
98 s390_register_call_saved (struct gdbarch
*gdbarch
, int regnum
)
100 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
105 if ((regnum
>= S390_R6_REGNUM
&& regnum
<= S390_R15_REGNUM
)
106 || regnum
== S390_F4_REGNUM
|| regnum
== S390_F6_REGNUM
107 || regnum
== S390_A0_REGNUM
)
112 case ABI_LINUX_ZSERIES
:
113 if ((regnum
>= S390_R6_REGNUM
&& regnum
<= S390_R15_REGNUM
)
114 || (regnum
>= S390_F8_REGNUM
&& regnum
<= S390_F15_REGNUM
)
115 || (regnum
>= S390_A0_REGNUM
&& regnum
<= S390_A1_REGNUM
))
125 s390_cannot_store_register (struct gdbarch
*gdbarch
, int regnum
)
127 /* The last-break address is read-only. */
128 return regnum
== S390_LAST_BREAK_REGNUM
;
132 s390_write_pc (struct regcache
*regcache
, CORE_ADDR pc
)
134 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
135 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
137 regcache_cooked_write_unsigned (regcache
, tdep
->pc_regnum
, pc
);
139 /* Set special SYSTEM_CALL register to 0 to prevent the kernel from
140 messing with the PC we just installed, if we happen to be within
141 an interrupted system call that the kernel wants to restart.
143 Note that after we return from the dummy call, the SYSTEM_CALL and
144 ORIG_R2 registers will be automatically restored, and the kernel
145 continues to restart the system call at this point. */
146 if (register_size (gdbarch
, S390_SYSTEM_CALL_REGNUM
) > 0)
147 regcache_cooked_write_unsigned (regcache
, S390_SYSTEM_CALL_REGNUM
, 0);
151 /* DWARF Register Mapping. */
153 static const short s390_dwarf_regmap
[] =
155 /* General Purpose Registers. */
156 S390_R0_REGNUM
, S390_R1_REGNUM
, S390_R2_REGNUM
, S390_R3_REGNUM
,
157 S390_R4_REGNUM
, S390_R5_REGNUM
, S390_R6_REGNUM
, S390_R7_REGNUM
,
158 S390_R8_REGNUM
, S390_R9_REGNUM
, S390_R10_REGNUM
, S390_R11_REGNUM
,
159 S390_R12_REGNUM
, S390_R13_REGNUM
, S390_R14_REGNUM
, S390_R15_REGNUM
,
161 /* Floating Point Registers. */
162 S390_F0_REGNUM
, S390_F2_REGNUM
, S390_F4_REGNUM
, S390_F6_REGNUM
,
163 S390_F1_REGNUM
, S390_F3_REGNUM
, S390_F5_REGNUM
, S390_F7_REGNUM
,
164 S390_F8_REGNUM
, S390_F10_REGNUM
, S390_F12_REGNUM
, S390_F14_REGNUM
,
165 S390_F9_REGNUM
, S390_F11_REGNUM
, S390_F13_REGNUM
, S390_F15_REGNUM
,
167 /* Control Registers (not mapped). */
168 -1, -1, -1, -1, -1, -1, -1, -1,
169 -1, -1, -1, -1, -1, -1, -1, -1,
171 /* Access Registers. */
172 S390_A0_REGNUM
, S390_A1_REGNUM
, S390_A2_REGNUM
, S390_A3_REGNUM
,
173 S390_A4_REGNUM
, S390_A5_REGNUM
, S390_A6_REGNUM
, S390_A7_REGNUM
,
174 S390_A8_REGNUM
, S390_A9_REGNUM
, S390_A10_REGNUM
, S390_A11_REGNUM
,
175 S390_A12_REGNUM
, S390_A13_REGNUM
, S390_A14_REGNUM
, S390_A15_REGNUM
,
177 /* Program Status Word. */
181 /* GPR Lower Half Access. */
182 S390_R0_REGNUM
, S390_R1_REGNUM
, S390_R2_REGNUM
, S390_R3_REGNUM
,
183 S390_R4_REGNUM
, S390_R5_REGNUM
, S390_R6_REGNUM
, S390_R7_REGNUM
,
184 S390_R8_REGNUM
, S390_R9_REGNUM
, S390_R10_REGNUM
, S390_R11_REGNUM
,
185 S390_R12_REGNUM
, S390_R13_REGNUM
, S390_R14_REGNUM
, S390_R15_REGNUM
,
187 /* GNU/Linux-specific registers (not mapped). */
191 /* Convert DWARF register number REG to the appropriate register
192 number used by GDB. */
194 s390_dwarf_reg_to_regnum (struct gdbarch
*gdbarch
, int reg
)
196 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
198 /* In a 32-on-64 debug scenario, debug info refers to the full 64-bit
199 GPRs. Note that call frame information still refers to the 32-bit
200 lower halves, because s390_adjust_frame_regnum uses register numbers
201 66 .. 81 to access GPRs. */
202 if (tdep
->gpr_full_regnum
!= -1 && reg
>= 0 && reg
< 16)
203 return tdep
->gpr_full_regnum
+ reg
;
205 if (reg
>= 0 && reg
< ARRAY_SIZE (s390_dwarf_regmap
))
206 return s390_dwarf_regmap
[reg
];
208 warning (_("Unmapped DWARF Register #%d encountered."), reg
);
212 /* Translate a .eh_frame register to DWARF register, or adjust a
213 .debug_frame register. */
215 s390_adjust_frame_regnum (struct gdbarch
*gdbarch
, int num
, int eh_frame_p
)
217 /* See s390_dwarf_reg_to_regnum for comments. */
218 return (num
>= 0 && num
< 16)? num
+ 66 : num
;
222 /* Pseudo registers. */
225 regnum_is_gpr_full (struct gdbarch_tdep
*tdep
, int regnum
)
227 return (tdep
->gpr_full_regnum
!= -1
228 && regnum
>= tdep
->gpr_full_regnum
229 && regnum
<= tdep
->gpr_full_regnum
+ 15);
233 s390_pseudo_register_name (struct gdbarch
*gdbarch
, int regnum
)
235 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
237 if (regnum
== tdep
->pc_regnum
)
240 if (regnum
== tdep
->cc_regnum
)
243 if (regnum_is_gpr_full (tdep
, regnum
))
245 static const char *full_name
[] = {
246 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
247 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
249 return full_name
[regnum
- tdep
->gpr_full_regnum
];
252 internal_error (__FILE__
, __LINE__
, _("invalid regnum"));
256 s390_pseudo_register_type (struct gdbarch
*gdbarch
, int regnum
)
258 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
260 if (regnum
== tdep
->pc_regnum
)
261 return builtin_type (gdbarch
)->builtin_func_ptr
;
263 if (regnum
== tdep
->cc_regnum
)
264 return builtin_type (gdbarch
)->builtin_int
;
266 if (regnum_is_gpr_full (tdep
, regnum
))
267 return builtin_type (gdbarch
)->builtin_uint64
;
269 internal_error (__FILE__
, __LINE__
, _("invalid regnum"));
272 static enum register_status
273 s390_pseudo_register_read (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
274 int regnum
, gdb_byte
*buf
)
276 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
277 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
278 int regsize
= register_size (gdbarch
, regnum
);
281 if (regnum
== tdep
->pc_regnum
)
283 enum register_status status
;
285 status
= regcache_raw_read_unsigned (regcache
, S390_PSWA_REGNUM
, &val
);
286 if (status
== REG_VALID
)
288 if (register_size (gdbarch
, S390_PSWA_REGNUM
) == 4)
290 store_unsigned_integer (buf
, regsize
, byte_order
, val
);
295 if (regnum
== tdep
->cc_regnum
)
297 enum register_status status
;
299 status
= regcache_raw_read_unsigned (regcache
, S390_PSWM_REGNUM
, &val
);
300 if (status
== REG_VALID
)
302 if (register_size (gdbarch
, S390_PSWA_REGNUM
) == 4)
303 val
= (val
>> 12) & 3;
305 val
= (val
>> 44) & 3;
306 store_unsigned_integer (buf
, regsize
, byte_order
, val
);
311 if (regnum_is_gpr_full (tdep
, regnum
))
313 enum register_status status
;
316 regnum
-= tdep
->gpr_full_regnum
;
318 status
= regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ regnum
, &val
);
319 if (status
== REG_VALID
)
320 status
= regcache_raw_read_unsigned (regcache
, S390_R0_UPPER_REGNUM
+ regnum
,
322 if (status
== REG_VALID
)
324 val
|= val_upper
<< 32;
325 store_unsigned_integer (buf
, regsize
, byte_order
, val
);
330 internal_error (__FILE__
, __LINE__
, _("invalid regnum"));
334 s390_pseudo_register_write (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
335 int regnum
, const gdb_byte
*buf
)
337 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
338 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
339 int regsize
= register_size (gdbarch
, regnum
);
342 if (regnum
== tdep
->pc_regnum
)
344 val
= extract_unsigned_integer (buf
, regsize
, byte_order
);
345 if (register_size (gdbarch
, S390_PSWA_REGNUM
) == 4)
347 regcache_raw_read_unsigned (regcache
, S390_PSWA_REGNUM
, &psw
);
348 val
= (psw
& 0x80000000) | (val
& 0x7fffffff);
350 regcache_raw_write_unsigned (regcache
, S390_PSWA_REGNUM
, val
);
354 if (regnum
== tdep
->cc_regnum
)
356 val
= extract_unsigned_integer (buf
, regsize
, byte_order
);
357 regcache_raw_read_unsigned (regcache
, S390_PSWM_REGNUM
, &psw
);
358 if (register_size (gdbarch
, S390_PSWA_REGNUM
) == 4)
359 val
= (psw
& ~((ULONGEST
)3 << 12)) | ((val
& 3) << 12);
361 val
= (psw
& ~((ULONGEST
)3 << 44)) | ((val
& 3) << 44);
362 regcache_raw_write_unsigned (regcache
, S390_PSWM_REGNUM
, val
);
366 if (regnum_is_gpr_full (tdep
, regnum
))
368 regnum
-= tdep
->gpr_full_regnum
;
369 val
= extract_unsigned_integer (buf
, regsize
, byte_order
);
370 regcache_raw_write_unsigned (regcache
, S390_R0_REGNUM
+ regnum
,
372 regcache_raw_write_unsigned (regcache
, S390_R0_UPPER_REGNUM
+ regnum
,
377 internal_error (__FILE__
, __LINE__
, _("invalid regnum"));
380 /* 'float' values are stored in the upper half of floating-point
381 registers, even though we are otherwise a big-endian platform. */
383 static struct value
*
384 s390_value_from_register (struct gdbarch
*gdbarch
, struct type
*type
,
385 int regnum
, struct frame_id frame_id
)
387 struct value
*value
= default_value_from_register (gdbarch
, type
,
389 check_typedef (type
);
391 if (regnum
>= S390_F0_REGNUM
&& regnum
<= S390_F15_REGNUM
392 && TYPE_LENGTH (type
) < 8)
393 set_value_offset (value
, 0);
398 /* Register groups. */
401 s390_pseudo_register_reggroup_p (struct gdbarch
*gdbarch
, int regnum
,
402 struct reggroup
*group
)
404 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
406 /* We usually save/restore the whole PSW, which includes PC and CC.
407 However, some older gdbservers may not support saving/restoring
408 the whole PSW yet, and will return an XML register description
409 excluding those from the save/restore register groups. In those
410 cases, we still need to explicitly save/restore PC and CC in order
411 to push or pop frames. Since this doesn't hurt anything if we
412 already save/restore the whole PSW (it's just redundant), we add
413 PC and CC at this point unconditionally. */
414 if (group
== save_reggroup
|| group
== restore_reggroup
)
415 return regnum
== tdep
->pc_regnum
|| regnum
== tdep
->cc_regnum
;
417 return default_register_reggroup_p (gdbarch
, regnum
, group
);
421 /* Maps for register sets. */
423 const short s390_regmap_gregset
[] =
425 0x00, S390_PSWM_REGNUM
,
426 0x04, S390_PSWA_REGNUM
,
427 0x08, S390_R0_REGNUM
,
428 0x0c, S390_R1_REGNUM
,
429 0x10, S390_R2_REGNUM
,
430 0x14, S390_R3_REGNUM
,
431 0x18, S390_R4_REGNUM
,
432 0x1c, S390_R5_REGNUM
,
433 0x20, S390_R6_REGNUM
,
434 0x24, S390_R7_REGNUM
,
435 0x28, S390_R8_REGNUM
,
436 0x2c, S390_R9_REGNUM
,
437 0x30, S390_R10_REGNUM
,
438 0x34, S390_R11_REGNUM
,
439 0x38, S390_R12_REGNUM
,
440 0x3c, S390_R13_REGNUM
,
441 0x40, S390_R14_REGNUM
,
442 0x44, S390_R15_REGNUM
,
443 0x48, S390_A0_REGNUM
,
444 0x4c, S390_A1_REGNUM
,
445 0x50, S390_A2_REGNUM
,
446 0x54, S390_A3_REGNUM
,
447 0x58, S390_A4_REGNUM
,
448 0x5c, S390_A5_REGNUM
,
449 0x60, S390_A6_REGNUM
,
450 0x64, S390_A7_REGNUM
,
451 0x68, S390_A8_REGNUM
,
452 0x6c, S390_A9_REGNUM
,
453 0x70, S390_A10_REGNUM
,
454 0x74, S390_A11_REGNUM
,
455 0x78, S390_A12_REGNUM
,
456 0x7c, S390_A13_REGNUM
,
457 0x80, S390_A14_REGNUM
,
458 0x84, S390_A15_REGNUM
,
459 0x88, S390_ORIG_R2_REGNUM
,
463 const short s390x_regmap_gregset
[] =
465 0x00, S390_PSWM_REGNUM
,
466 0x08, S390_PSWA_REGNUM
,
467 0x10, S390_R0_REGNUM
,
468 0x18, S390_R1_REGNUM
,
469 0x20, S390_R2_REGNUM
,
470 0x28, S390_R3_REGNUM
,
471 0x30, S390_R4_REGNUM
,
472 0x38, S390_R5_REGNUM
,
473 0x40, S390_R6_REGNUM
,
474 0x48, S390_R7_REGNUM
,
475 0x50, S390_R8_REGNUM
,
476 0x58, S390_R9_REGNUM
,
477 0x60, S390_R10_REGNUM
,
478 0x68, S390_R11_REGNUM
,
479 0x70, S390_R12_REGNUM
,
480 0x78, S390_R13_REGNUM
,
481 0x80, S390_R14_REGNUM
,
482 0x88, S390_R15_REGNUM
,
483 0x90, S390_A0_REGNUM
,
484 0x94, S390_A1_REGNUM
,
485 0x98, S390_A2_REGNUM
,
486 0x9c, S390_A3_REGNUM
,
487 0xa0, S390_A4_REGNUM
,
488 0xa4, S390_A5_REGNUM
,
489 0xa8, S390_A6_REGNUM
,
490 0xac, S390_A7_REGNUM
,
491 0xb0, S390_A8_REGNUM
,
492 0xb4, S390_A9_REGNUM
,
493 0xb8, S390_A10_REGNUM
,
494 0xbc, S390_A11_REGNUM
,
495 0xc0, S390_A12_REGNUM
,
496 0xc4, S390_A13_REGNUM
,
497 0xc8, S390_A14_REGNUM
,
498 0xcc, S390_A15_REGNUM
,
499 0x10, S390_R0_UPPER_REGNUM
,
500 0x18, S390_R1_UPPER_REGNUM
,
501 0x20, S390_R2_UPPER_REGNUM
,
502 0x28, S390_R3_UPPER_REGNUM
,
503 0x30, S390_R4_UPPER_REGNUM
,
504 0x38, S390_R5_UPPER_REGNUM
,
505 0x40, S390_R6_UPPER_REGNUM
,
506 0x48, S390_R7_UPPER_REGNUM
,
507 0x50, S390_R8_UPPER_REGNUM
,
508 0x58, S390_R9_UPPER_REGNUM
,
509 0x60, S390_R10_UPPER_REGNUM
,
510 0x68, S390_R11_UPPER_REGNUM
,
511 0x70, S390_R12_UPPER_REGNUM
,
512 0x78, S390_R13_UPPER_REGNUM
,
513 0x80, S390_R14_UPPER_REGNUM
,
514 0x88, S390_R15_UPPER_REGNUM
,
515 0xd0, S390_ORIG_R2_REGNUM
,
519 const short s390_regmap_fpregset
[] =
521 0x00, S390_FPC_REGNUM
,
522 0x08, S390_F0_REGNUM
,
523 0x10, S390_F1_REGNUM
,
524 0x18, S390_F2_REGNUM
,
525 0x20, S390_F3_REGNUM
,
526 0x28, S390_F4_REGNUM
,
527 0x30, S390_F5_REGNUM
,
528 0x38, S390_F6_REGNUM
,
529 0x40, S390_F7_REGNUM
,
530 0x48, S390_F8_REGNUM
,
531 0x50, S390_F9_REGNUM
,
532 0x58, S390_F10_REGNUM
,
533 0x60, S390_F11_REGNUM
,
534 0x68, S390_F12_REGNUM
,
535 0x70, S390_F13_REGNUM
,
536 0x78, S390_F14_REGNUM
,
537 0x80, S390_F15_REGNUM
,
541 const short s390_regmap_upper
[] =
543 0x00, S390_R0_UPPER_REGNUM
,
544 0x04, S390_R1_UPPER_REGNUM
,
545 0x08, S390_R2_UPPER_REGNUM
,
546 0x0c, S390_R3_UPPER_REGNUM
,
547 0x10, S390_R4_UPPER_REGNUM
,
548 0x14, S390_R5_UPPER_REGNUM
,
549 0x18, S390_R6_UPPER_REGNUM
,
550 0x1c, S390_R7_UPPER_REGNUM
,
551 0x20, S390_R8_UPPER_REGNUM
,
552 0x24, S390_R9_UPPER_REGNUM
,
553 0x28, S390_R10_UPPER_REGNUM
,
554 0x2c, S390_R11_UPPER_REGNUM
,
555 0x30, S390_R12_UPPER_REGNUM
,
556 0x34, S390_R13_UPPER_REGNUM
,
557 0x38, S390_R14_UPPER_REGNUM
,
558 0x3c, S390_R15_UPPER_REGNUM
,
562 const short s390_regmap_last_break
[] =
564 0x04, S390_LAST_BREAK_REGNUM
,
568 const short s390x_regmap_last_break
[] =
570 0x00, S390_LAST_BREAK_REGNUM
,
574 const short s390_regmap_system_call
[] =
576 0x00, S390_SYSTEM_CALL_REGNUM
,
580 const short s390_regmap_tdb
[] =
582 0x00, S390_TDB_DWORD0_REGNUM
,
583 0x08, S390_TDB_ABORT_CODE_REGNUM
,
584 0x10, S390_TDB_CONFLICT_TOKEN_REGNUM
,
585 0x18, S390_TDB_ATIA_REGNUM
,
586 0x80, S390_TDB_R0_REGNUM
,
587 0x88, S390_TDB_R1_REGNUM
,
588 0x90, S390_TDB_R2_REGNUM
,
589 0x98, S390_TDB_R3_REGNUM
,
590 0xa0, S390_TDB_R4_REGNUM
,
591 0xa8, S390_TDB_R5_REGNUM
,
592 0xb0, S390_TDB_R6_REGNUM
,
593 0xb8, S390_TDB_R7_REGNUM
,
594 0xc0, S390_TDB_R8_REGNUM
,
595 0xc8, S390_TDB_R9_REGNUM
,
596 0xd0, S390_TDB_R10_REGNUM
,
597 0xd8, S390_TDB_R11_REGNUM
,
598 0xe0, S390_TDB_R12_REGNUM
,
599 0xe8, S390_TDB_R13_REGNUM
,
600 0xf0, S390_TDB_R14_REGNUM
,
601 0xf8, S390_TDB_R15_REGNUM
,
606 /* Supply register REGNUM from the register set REGSET to register cache
607 REGCACHE. If REGNUM is -1, do this for all registers in REGSET. */
609 s390_supply_regset (const struct regset
*regset
, struct regcache
*regcache
,
610 int regnum
, const void *regs
, size_t len
)
613 for (map
= regset
->descr
; map
[0] >= 0; map
+= 2)
614 if (regnum
== -1 || regnum
== map
[1])
615 regcache_raw_supply (regcache
, map
[1],
616 regs
? (const char *)regs
+ map
[0] : NULL
);
619 /* Supply the TDB regset. Like s390_supply_regset, but invalidate the
620 TDB registers unless the TDB format field is valid. */
623 s390_supply_tdb_regset (const struct regset
*regset
, struct regcache
*regcache
,
624 int regnum
, const void *regs
, size_t len
)
627 enum register_status ret
;
630 s390_supply_regset (regset
, regcache
, regnum
, regs
, len
);
631 ret
= regcache_cooked_read_unsigned (regcache
, S390_TDB_DWORD0_REGNUM
, &tdw
);
632 if (ret
!= REG_VALID
|| (tdw
>> 56) != 1)
633 s390_supply_regset (regset
, regcache
, regnum
, NULL
, len
);
636 /* Collect register REGNUM from the register cache REGCACHE and store
637 it in the buffer specified by REGS and LEN as described by the
638 general-purpose register set REGSET. If REGNUM is -1, do this for
639 all registers in REGSET. */
641 s390_collect_regset (const struct regset
*regset
,
642 const struct regcache
*regcache
,
643 int regnum
, void *regs
, size_t len
)
646 for (map
= regset
->descr
; map
[0] >= 0; map
+= 2)
647 if (regnum
== -1 || regnum
== map
[1])
648 regcache_raw_collect (regcache
, map
[1], (char *)regs
+ map
[0]);
651 static const struct regset s390_gregset
= {
657 static const struct regset s390x_gregset
= {
658 s390x_regmap_gregset
,
663 static const struct regset s390_fpregset
= {
664 s390_regmap_fpregset
,
669 static const struct regset s390_upper_regset
= {
675 static const struct regset s390_last_break_regset
= {
676 s390_regmap_last_break
,
681 static const struct regset s390x_last_break_regset
= {
682 s390x_regmap_last_break
,
687 static const struct regset s390_system_call_regset
= {
688 s390_regmap_system_call
,
693 static const struct regset s390_tdb_regset
= {
695 s390_supply_tdb_regset
,
699 static struct core_regset_section s390_linux32_regset_sections
[] =
701 { ".reg", s390_sizeof_gregset
, "general-purpose" },
702 { ".reg2", s390_sizeof_fpregset
, "floating-point" },
706 static struct core_regset_section s390_linux32v1_regset_sections
[] =
708 { ".reg", s390_sizeof_gregset
, "general-purpose" },
709 { ".reg2", s390_sizeof_fpregset
, "floating-point" },
710 { ".reg-s390-last-break", 8, "s390 last-break address" },
714 static struct core_regset_section s390_linux32v2_regset_sections
[] =
716 { ".reg", s390_sizeof_gregset
, "general-purpose" },
717 { ".reg2", s390_sizeof_fpregset
, "floating-point" },
718 { ".reg-s390-last-break", 8, "s390 last-break address" },
719 { ".reg-s390-system-call", 4, "s390 system-call" },
723 static struct core_regset_section s390_linux64_regset_sections
[] =
725 { ".reg", s390_sizeof_gregset
, "general-purpose" },
726 { ".reg2", s390_sizeof_fpregset
, "floating-point" },
727 { ".reg-s390-high-gprs", 16*4, "s390 GPR upper halves" },
731 static struct core_regset_section s390_linux64v1_regset_sections
[] =
733 { ".reg", s390_sizeof_gregset
, "general-purpose" },
734 { ".reg2", s390_sizeof_fpregset
, "floating-point" },
735 { ".reg-s390-high-gprs", 16*4, "s390 GPR upper halves" },
736 { ".reg-s390-last-break", 8, "s930 last-break address" },
740 static struct core_regset_section s390_linux64v2_regset_sections
[] =
742 { ".reg", s390_sizeof_gregset
, "general-purpose" },
743 { ".reg2", s390_sizeof_fpregset
, "floating-point" },
744 { ".reg-s390-high-gprs", 16*4, "s390 GPR upper halves" },
745 { ".reg-s390-last-break", 8, "s930 last-break address" },
746 { ".reg-s390-system-call", 4, "s390 system-call" },
747 { ".reg-s390-tdb", s390_sizeof_tdbregset
, "s390 TDB" },
751 static struct core_regset_section s390x_linux64_regset_sections
[] =
753 { ".reg", s390x_sizeof_gregset
, "general-purpose" },
754 { ".reg2", s390_sizeof_fpregset
, "floating-point" },
758 static struct core_regset_section s390x_linux64v1_regset_sections
[] =
760 { ".reg", s390x_sizeof_gregset
, "general-purpose" },
761 { ".reg2", s390_sizeof_fpregset
, "floating-point" },
762 { ".reg-s390-last-break", 8, "s930 last-break address" },
766 static struct core_regset_section s390x_linux64v2_regset_sections
[] =
768 { ".reg", s390x_sizeof_gregset
, "general-purpose" },
769 { ".reg2", s390_sizeof_fpregset
, "floating-point" },
770 { ".reg-s390-last-break", 8, "s930 last-break address" },
771 { ".reg-s390-system-call", 4, "s390 system-call" },
772 { ".reg-s390-tdb", s390_sizeof_tdbregset
, "s390 TDB" },
777 /* Return the appropriate register set for the core section identified
778 by SECT_NAME and SECT_SIZE. */
779 static const struct regset
*
780 s390_regset_from_core_section (struct gdbarch
*gdbarch
,
781 const char *sect_name
, size_t sect_size
)
783 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
785 if (strcmp (sect_name
, ".reg") == 0 && sect_size
>= tdep
->sizeof_gregset
)
786 return tdep
->gregset
;
788 if (strcmp (sect_name
, ".reg2") == 0 && sect_size
>= tdep
->sizeof_fpregset
)
789 return tdep
->fpregset
;
791 if (strcmp (sect_name
, ".reg-s390-high-gprs") == 0 && sect_size
>= 16*4)
792 return &s390_upper_regset
;
794 if (strcmp (sect_name
, ".reg-s390-last-break") == 0 && sect_size
>= 8)
795 return (gdbarch_ptr_bit (gdbarch
) == 32
796 ? &s390_last_break_regset
: &s390x_last_break_regset
);
798 if (strcmp (sect_name
, ".reg-s390-system-call") == 0 && sect_size
>= 4)
799 return &s390_system_call_regset
;
801 if (strcmp (sect_name
, ".reg-s390-tdb") == 0 && sect_size
>= 256)
802 return &s390_tdb_regset
;
807 static const struct target_desc
*
808 s390_core_read_description (struct gdbarch
*gdbarch
,
809 struct target_ops
*target
, bfd
*abfd
)
811 asection
*high_gprs
= bfd_get_section_by_name (abfd
, ".reg-s390-high-gprs");
812 asection
*v1
= bfd_get_section_by_name (abfd
, ".reg-s390-last-break");
813 asection
*v2
= bfd_get_section_by_name (abfd
, ".reg-s390-system-call");
814 asection
*section
= bfd_get_section_by_name (abfd
, ".reg");
817 target_auxv_search (target
, AT_HWCAP
, &hwcap
);
821 switch (bfd_section_size (abfd
, section
))
823 case s390_sizeof_gregset
:
825 return ((hwcap
& HWCAP_S390_TE
) ? tdesc_s390_te_linux64
:
826 v2
? tdesc_s390_linux64v2
:
827 v1
? tdesc_s390_linux64v1
: tdesc_s390_linux64
);
829 return (v2
? tdesc_s390_linux32v2
:
830 v1
? tdesc_s390_linux32v1
: tdesc_s390_linux32
);
832 case s390x_sizeof_gregset
:
833 return ((hwcap
& HWCAP_S390_TE
) ? tdesc_s390x_te_linux64
:
834 v2
? tdesc_s390x_linux64v2
:
835 v1
? tdesc_s390x_linux64v1
: tdesc_s390x_linux64
);
843 /* Decoding S/390 instructions. */
845 /* Named opcode values for the S/390 instructions we recognize. Some
846 instructions have their opcode split across two fields; those are the
847 op1_* and op2_* enums. */
850 op1_lhi
= 0xa7, op2_lhi
= 0x08,
851 op1_lghi
= 0xa7, op2_lghi
= 0x09,
852 op1_lgfi
= 0xc0, op2_lgfi
= 0x01,
856 op1_ly
= 0xe3, op2_ly
= 0x58,
857 op1_lg
= 0xe3, op2_lg
= 0x04,
859 op1_lmy
= 0xeb, op2_lmy
= 0x98,
860 op1_lmg
= 0xeb, op2_lmg
= 0x04,
862 op1_sty
= 0xe3, op2_sty
= 0x50,
863 op1_stg
= 0xe3, op2_stg
= 0x24,
866 op1_stmy
= 0xeb, op2_stmy
= 0x90,
867 op1_stmg
= 0xeb, op2_stmg
= 0x24,
868 op1_aghi
= 0xa7, op2_aghi
= 0x0b,
869 op1_ahi
= 0xa7, op2_ahi
= 0x0a,
870 op1_agfi
= 0xc2, op2_agfi
= 0x08,
871 op1_afi
= 0xc2, op2_afi
= 0x09,
872 op1_algfi
= 0xc2, op2_algfi
= 0x0a,
873 op1_alfi
= 0xc2, op2_alfi
= 0x0b,
877 op1_ay
= 0xe3, op2_ay
= 0x5a,
878 op1_ag
= 0xe3, op2_ag
= 0x08,
879 op1_slgfi
= 0xc2, op2_slgfi
= 0x04,
880 op1_slfi
= 0xc2, op2_slfi
= 0x05,
884 op1_sy
= 0xe3, op2_sy
= 0x5b,
885 op1_sg
= 0xe3, op2_sg
= 0x09,
889 op1_lay
= 0xe3, op2_lay
= 0x71,
890 op1_larl
= 0xc0, op2_larl
= 0x00,
898 op1_bctg
= 0xe3, op2_bctg
= 0x46,
900 op1_bxhg
= 0xeb, op2_bxhg
= 0x44,
902 op1_bxleg
= 0xeb, op2_bxleg
= 0x45,
903 op1_bras
= 0xa7, op2_bras
= 0x05,
904 op1_brasl
= 0xc0, op2_brasl
= 0x05,
905 op1_brc
= 0xa7, op2_brc
= 0x04,
906 op1_brcl
= 0xc0, op2_brcl
= 0x04,
907 op1_brct
= 0xa7, op2_brct
= 0x06,
908 op1_brctg
= 0xa7, op2_brctg
= 0x07,
910 op1_brxhg
= 0xec, op2_brxhg
= 0x44,
912 op1_brxlg
= 0xec, op2_brxlg
= 0x45,
917 /* Read a single instruction from address AT. */
919 #define S390_MAX_INSTR_SIZE 6
921 s390_readinstruction (bfd_byte instr
[], CORE_ADDR at
)
923 static int s390_instrlen
[] = { 2, 4, 4, 6 };
926 if (target_read_memory (at
, &instr
[0], 2))
928 instrlen
= s390_instrlen
[instr
[0] >> 6];
931 if (target_read_memory (at
+ 2, &instr
[2], instrlen
- 2))
938 /* The functions below are for recognizing and decoding S/390
939 instructions of various formats. Each of them checks whether INSN
940 is an instruction of the given format, with the specified opcodes.
941 If it is, it sets the remaining arguments to the values of the
942 instruction's fields, and returns a non-zero value; otherwise, it
945 These functions' arguments appear in the order they appear in the
946 instruction, not in the machine-language form. So, opcodes always
947 come first, even though they're sometimes scattered around the
948 instructions. And displacements appear before base and extension
949 registers, as they do in the assembly syntax, not at the end, as
950 they do in the machine language. */
952 is_ri (bfd_byte
*insn
, int op1
, int op2
, unsigned int *r1
, int *i2
)
954 if (insn
[0] == op1
&& (insn
[1] & 0xf) == op2
)
956 *r1
= (insn
[1] >> 4) & 0xf;
957 /* i2 is a 16-bit signed quantity. */
958 *i2
= (((insn
[2] << 8) | insn
[3]) ^ 0x8000) - 0x8000;
967 is_ril (bfd_byte
*insn
, int op1
, int op2
,
968 unsigned int *r1
, int *i2
)
970 if (insn
[0] == op1
&& (insn
[1] & 0xf) == op2
)
972 *r1
= (insn
[1] >> 4) & 0xf;
973 /* i2 is a signed quantity. If the host 'int' is 32 bits long,
974 no sign extension is necessary, but we don't want to assume
976 *i2
= (((insn
[2] << 24)
979 | (insn
[5])) ^ 0x80000000) - 0x80000000;
988 is_rr (bfd_byte
*insn
, int op
, unsigned int *r1
, unsigned int *r2
)
992 *r1
= (insn
[1] >> 4) & 0xf;
1002 is_rre (bfd_byte
*insn
, int op
, unsigned int *r1
, unsigned int *r2
)
1004 if (((insn
[0] << 8) | insn
[1]) == op
)
1006 /* Yes, insn[3]. insn[2] is unused in RRE format. */
1007 *r1
= (insn
[3] >> 4) & 0xf;
1008 *r2
= insn
[3] & 0xf;
1017 is_rs (bfd_byte
*insn
, int op
,
1018 unsigned int *r1
, unsigned int *r3
, int *d2
, unsigned int *b2
)
1022 *r1
= (insn
[1] >> 4) & 0xf;
1023 *r3
= insn
[1] & 0xf;
1024 *b2
= (insn
[2] >> 4) & 0xf;
1025 *d2
= ((insn
[2] & 0xf) << 8) | insn
[3];
1034 is_rsy (bfd_byte
*insn
, int op1
, int op2
,
1035 unsigned int *r1
, unsigned int *r3
, int *d2
, unsigned int *b2
)
1040 *r1
= (insn
[1] >> 4) & 0xf;
1041 *r3
= insn
[1] & 0xf;
1042 *b2
= (insn
[2] >> 4) & 0xf;
1043 /* The 'long displacement' is a 20-bit signed integer. */
1044 *d2
= ((((insn
[2] & 0xf) << 8) | insn
[3] | (insn
[4] << 12))
1045 ^ 0x80000) - 0x80000;
1054 is_rsi (bfd_byte
*insn
, int op
,
1055 unsigned int *r1
, unsigned int *r3
, int *i2
)
1059 *r1
= (insn
[1] >> 4) & 0xf;
1060 *r3
= insn
[1] & 0xf;
1061 /* i2 is a 16-bit signed quantity. */
1062 *i2
= (((insn
[2] << 8) | insn
[3]) ^ 0x8000) - 0x8000;
1071 is_rie (bfd_byte
*insn
, int op1
, int op2
,
1072 unsigned int *r1
, unsigned int *r3
, int *i2
)
1077 *r1
= (insn
[1] >> 4) & 0xf;
1078 *r3
= insn
[1] & 0xf;
1079 /* i2 is a 16-bit signed quantity. */
1080 *i2
= (((insn
[2] << 8) | insn
[3]) ^ 0x8000) - 0x8000;
1089 is_rx (bfd_byte
*insn
, int op
,
1090 unsigned int *r1
, int *d2
, unsigned int *x2
, unsigned int *b2
)
1094 *r1
= (insn
[1] >> 4) & 0xf;
1095 *x2
= insn
[1] & 0xf;
1096 *b2
= (insn
[2] >> 4) & 0xf;
1097 *d2
= ((insn
[2] & 0xf) << 8) | insn
[3];
1106 is_rxy (bfd_byte
*insn
, int op1
, int op2
,
1107 unsigned int *r1
, int *d2
, unsigned int *x2
, unsigned int *b2
)
1112 *r1
= (insn
[1] >> 4) & 0xf;
1113 *x2
= insn
[1] & 0xf;
1114 *b2
= (insn
[2] >> 4) & 0xf;
1115 /* The 'long displacement' is a 20-bit signed integer. */
1116 *d2
= ((((insn
[2] & 0xf) << 8) | insn
[3] | (insn
[4] << 12))
1117 ^ 0x80000) - 0x80000;
1125 /* Prologue analysis. */
1127 #define S390_NUM_GPRS 16
1128 #define S390_NUM_FPRS 16
1130 struct s390_prologue_data
{
1133 struct pv_area
*stack
;
1135 /* The size and byte-order of a GPR or FPR. */
1138 enum bfd_endian byte_order
;
1140 /* The general-purpose registers. */
1141 pv_t gpr
[S390_NUM_GPRS
];
1143 /* The floating-point registers. */
1144 pv_t fpr
[S390_NUM_FPRS
];
1146 /* The offset relative to the CFA where the incoming GPR N was saved
1147 by the function prologue. 0 if not saved or unknown. */
1148 int gpr_slot
[S390_NUM_GPRS
];
1150 /* Likewise for FPRs. */
1151 int fpr_slot
[S390_NUM_FPRS
];
1153 /* Nonzero if the backchain was saved. This is assumed to be the
1154 case when the incoming SP is saved at the current SP location. */
1155 int back_chain_saved_p
;
1158 /* Return the effective address for an X-style instruction, like:
1162 Here, X2 and B2 are registers, and D2 is a signed 20-bit
1163 constant; the effective address is the sum of all three. If either
1164 X2 or B2 are zero, then it doesn't contribute to the sum --- this
1165 means that r0 can't be used as either X2 or B2. */
1167 s390_addr (struct s390_prologue_data
*data
,
1168 int d2
, unsigned int x2
, unsigned int b2
)
1172 result
= pv_constant (d2
);
1174 result
= pv_add (result
, data
->gpr
[x2
]);
1176 result
= pv_add (result
, data
->gpr
[b2
]);
1181 /* Do a SIZE-byte store of VALUE to D2(X2,B2). */
1183 s390_store (struct s390_prologue_data
*data
,
1184 int d2
, unsigned int x2
, unsigned int b2
, CORE_ADDR size
,
1187 pv_t addr
= s390_addr (data
, d2
, x2
, b2
);
1190 /* Check whether we are storing the backchain. */
1191 offset
= pv_subtract (data
->gpr
[S390_SP_REGNUM
- S390_R0_REGNUM
], addr
);
1193 if (pv_is_constant (offset
) && offset
.k
== 0)
1194 if (size
== data
->gpr_size
1195 && pv_is_register_k (value
, S390_SP_REGNUM
, 0))
1197 data
->back_chain_saved_p
= 1;
1202 /* Check whether we are storing a register into the stack. */
1203 if (!pv_area_store_would_trash (data
->stack
, addr
))
1204 pv_area_store (data
->stack
, addr
, size
, value
);
1207 /* Note: If this is some store we cannot identify, you might think we
1208 should forget our cached values, as any of those might have been hit.
1210 However, we make the assumption that the register save areas are only
1211 ever stored to once in any given function, and we do recognize these
1212 stores. Thus every store we cannot recognize does not hit our data. */
1215 /* Do a SIZE-byte load from D2(X2,B2). */
1217 s390_load (struct s390_prologue_data
*data
,
1218 int d2
, unsigned int x2
, unsigned int b2
, CORE_ADDR size
)
1221 pv_t addr
= s390_addr (data
, d2
, x2
, b2
);
1223 /* If it's a load from an in-line constant pool, then we can
1224 simulate that, under the assumption that the code isn't
1225 going to change between the time the processor actually
1226 executed it creating the current frame, and the time when
1227 we're analyzing the code to unwind past that frame. */
1228 if (pv_is_constant (addr
))
1230 struct target_section
*secp
;
1231 secp
= target_section_by_addr (¤t_target
, addr
.k
);
1233 && (bfd_get_section_flags (secp
->the_bfd_section
->owner
,
1234 secp
->the_bfd_section
)
1236 return pv_constant (read_memory_integer (addr
.k
, size
,
1240 /* Check whether we are accessing one of our save slots. */
1241 return pv_area_fetch (data
->stack
, addr
, size
);
1244 /* Function for finding saved registers in a 'struct pv_area'; we pass
1245 this to pv_area_scan.
1247 If VALUE is a saved register, ADDR says it was saved at a constant
1248 offset from the frame base, and SIZE indicates that the whole
1249 register was saved, record its offset in the reg_offset table in
1250 PROLOGUE_UNTYPED. */
1252 s390_check_for_saved (void *data_untyped
, pv_t addr
,
1253 CORE_ADDR size
, pv_t value
)
1255 struct s390_prologue_data
*data
= data_untyped
;
1258 if (!pv_is_register (addr
, S390_SP_REGNUM
))
1261 offset
= 16 * data
->gpr_size
+ 32 - addr
.k
;
1263 /* If we are storing the original value of a register, we want to
1264 record the CFA offset. If the same register is stored multiple
1265 times, the stack slot with the highest address counts. */
1267 for (i
= 0; i
< S390_NUM_GPRS
; i
++)
1268 if (size
== data
->gpr_size
1269 && pv_is_register_k (value
, S390_R0_REGNUM
+ i
, 0))
1270 if (data
->gpr_slot
[i
] == 0
1271 || data
->gpr_slot
[i
] > offset
)
1273 data
->gpr_slot
[i
] = offset
;
1277 for (i
= 0; i
< S390_NUM_FPRS
; i
++)
1278 if (size
== data
->fpr_size
1279 && pv_is_register_k (value
, S390_F0_REGNUM
+ i
, 0))
1280 if (data
->fpr_slot
[i
] == 0
1281 || data
->fpr_slot
[i
] > offset
)
1283 data
->fpr_slot
[i
] = offset
;
1288 /* Analyze the prologue of the function starting at START_PC,
1289 continuing at most until CURRENT_PC. Initialize DATA to
1290 hold all information we find out about the state of the registers
1291 and stack slots. Return the address of the instruction after
1292 the last one that changed the SP, FP, or back chain; or zero
1295 s390_analyze_prologue (struct gdbarch
*gdbarch
,
1297 CORE_ADDR current_pc
,
1298 struct s390_prologue_data
*data
)
1300 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
1302 /* Our return value:
1303 The address of the instruction after the last one that changed
1304 the SP, FP, or back chain; zero if we got an error trying to
1306 CORE_ADDR result
= start_pc
;
1308 /* The current PC for our abstract interpretation. */
1311 /* The address of the next instruction after that. */
1314 /* Set up everything's initial value. */
1318 data
->stack
= make_pv_area (S390_SP_REGNUM
, gdbarch_addr_bit (gdbarch
));
1320 /* For the purpose of prologue tracking, we consider the GPR size to
1321 be equal to the ABI word size, even if it is actually larger
1322 (i.e. when running a 32-bit binary under a 64-bit kernel). */
1323 data
->gpr_size
= word_size
;
1325 data
->byte_order
= gdbarch_byte_order (gdbarch
);
1327 for (i
= 0; i
< S390_NUM_GPRS
; i
++)
1328 data
->gpr
[i
] = pv_register (S390_R0_REGNUM
+ i
, 0);
1330 for (i
= 0; i
< S390_NUM_FPRS
; i
++)
1331 data
->fpr
[i
] = pv_register (S390_F0_REGNUM
+ i
, 0);
1333 for (i
= 0; i
< S390_NUM_GPRS
; i
++)
1334 data
->gpr_slot
[i
] = 0;
1336 for (i
= 0; i
< S390_NUM_FPRS
; i
++)
1337 data
->fpr_slot
[i
] = 0;
1339 data
->back_chain_saved_p
= 0;
1342 /* Start interpreting instructions, until we hit the frame's
1343 current PC or the first branch instruction. */
1344 for (pc
= start_pc
; pc
> 0 && pc
< current_pc
; pc
= next_pc
)
1346 bfd_byte insn
[S390_MAX_INSTR_SIZE
];
1347 int insn_len
= s390_readinstruction (insn
, pc
);
1349 bfd_byte dummy
[S390_MAX_INSTR_SIZE
] = { 0 };
1350 bfd_byte
*insn32
= word_size
== 4 ? insn
: dummy
;
1351 bfd_byte
*insn64
= word_size
== 8 ? insn
: dummy
;
1353 /* Fields for various kinds of instructions. */
1354 unsigned int b2
, r1
, r2
, x2
, r3
;
1357 /* The values of SP and FP before this instruction,
1358 for detecting instructions that change them. */
1359 pv_t pre_insn_sp
, pre_insn_fp
;
1360 /* Likewise for the flag whether the back chain was saved. */
1361 int pre_insn_back_chain_saved_p
;
1363 /* If we got an error trying to read the instruction, report it. */
1370 next_pc
= pc
+ insn_len
;
1372 pre_insn_sp
= data
->gpr
[S390_SP_REGNUM
- S390_R0_REGNUM
];
1373 pre_insn_fp
= data
->gpr
[S390_FRAME_REGNUM
- S390_R0_REGNUM
];
1374 pre_insn_back_chain_saved_p
= data
->back_chain_saved_p
;
1377 /* LHI r1, i2 --- load halfword immediate. */
1378 /* LGHI r1, i2 --- load halfword immediate (64-bit version). */
1379 /* LGFI r1, i2 --- load fullword immediate. */
1380 if (is_ri (insn32
, op1_lhi
, op2_lhi
, &r1
, &i2
)
1381 || is_ri (insn64
, op1_lghi
, op2_lghi
, &r1
, &i2
)
1382 || is_ril (insn
, op1_lgfi
, op2_lgfi
, &r1
, &i2
))
1383 data
->gpr
[r1
] = pv_constant (i2
);
1385 /* LR r1, r2 --- load from register. */
1386 /* LGR r1, r2 --- load from register (64-bit version). */
1387 else if (is_rr (insn32
, op_lr
, &r1
, &r2
)
1388 || is_rre (insn64
, op_lgr
, &r1
, &r2
))
1389 data
->gpr
[r1
] = data
->gpr
[r2
];
1391 /* L r1, d2(x2, b2) --- load. */
1392 /* LY r1, d2(x2, b2) --- load (long-displacement version). */
1393 /* LG r1, d2(x2, b2) --- load (64-bit version). */
1394 else if (is_rx (insn32
, op_l
, &r1
, &d2
, &x2
, &b2
)
1395 || is_rxy (insn32
, op1_ly
, op2_ly
, &r1
, &d2
, &x2
, &b2
)
1396 || is_rxy (insn64
, op1_lg
, op2_lg
, &r1
, &d2
, &x2
, &b2
))
1397 data
->gpr
[r1
] = s390_load (data
, d2
, x2
, b2
, data
->gpr_size
);
1399 /* ST r1, d2(x2, b2) --- store. */
1400 /* STY r1, d2(x2, b2) --- store (long-displacement version). */
1401 /* STG r1, d2(x2, b2) --- store (64-bit version). */
1402 else if (is_rx (insn32
, op_st
, &r1
, &d2
, &x2
, &b2
)
1403 || is_rxy (insn32
, op1_sty
, op2_sty
, &r1
, &d2
, &x2
, &b2
)
1404 || is_rxy (insn64
, op1_stg
, op2_stg
, &r1
, &d2
, &x2
, &b2
))
1405 s390_store (data
, d2
, x2
, b2
, data
->gpr_size
, data
->gpr
[r1
]);
1407 /* STD r1, d2(x2,b2) --- store floating-point register. */
1408 else if (is_rx (insn
, op_std
, &r1
, &d2
, &x2
, &b2
))
1409 s390_store (data
, d2
, x2
, b2
, data
->fpr_size
, data
->fpr
[r1
]);
1411 /* STM r1, r3, d2(b2) --- store multiple. */
1412 /* STMY r1, r3, d2(b2) --- store multiple (long-displacement
1414 /* STMG r1, r3, d2(b2) --- store multiple (64-bit version). */
1415 else if (is_rs (insn32
, op_stm
, &r1
, &r3
, &d2
, &b2
)
1416 || is_rsy (insn32
, op1_stmy
, op2_stmy
, &r1
, &r3
, &d2
, &b2
)
1417 || is_rsy (insn64
, op1_stmg
, op2_stmg
, &r1
, &r3
, &d2
, &b2
))
1419 for (; r1
<= r3
; r1
++, d2
+= data
->gpr_size
)
1420 s390_store (data
, d2
, 0, b2
, data
->gpr_size
, data
->gpr
[r1
]);
1423 /* AHI r1, i2 --- add halfword immediate. */
1424 /* AGHI r1, i2 --- add halfword immediate (64-bit version). */
1425 /* AFI r1, i2 --- add fullword immediate. */
1426 /* AGFI r1, i2 --- add fullword immediate (64-bit version). */
1427 else if (is_ri (insn32
, op1_ahi
, op2_ahi
, &r1
, &i2
)
1428 || is_ri (insn64
, op1_aghi
, op2_aghi
, &r1
, &i2
)
1429 || is_ril (insn32
, op1_afi
, op2_afi
, &r1
, &i2
)
1430 || is_ril (insn64
, op1_agfi
, op2_agfi
, &r1
, &i2
))
1431 data
->gpr
[r1
] = pv_add_constant (data
->gpr
[r1
], i2
);
1433 /* ALFI r1, i2 --- add logical immediate. */
1434 /* ALGFI r1, i2 --- add logical immediate (64-bit version). */
1435 else if (is_ril (insn32
, op1_alfi
, op2_alfi
, &r1
, &i2
)
1436 || is_ril (insn64
, op1_algfi
, op2_algfi
, &r1
, &i2
))
1437 data
->gpr
[r1
] = pv_add_constant (data
->gpr
[r1
],
1438 (CORE_ADDR
)i2
& 0xffffffff);
1440 /* AR r1, r2 -- add register. */
1441 /* AGR r1, r2 -- add register (64-bit version). */
1442 else if (is_rr (insn32
, op_ar
, &r1
, &r2
)
1443 || is_rre (insn64
, op_agr
, &r1
, &r2
))
1444 data
->gpr
[r1
] = pv_add (data
->gpr
[r1
], data
->gpr
[r2
]);
1446 /* A r1, d2(x2, b2) -- add. */
1447 /* AY r1, d2(x2, b2) -- add (long-displacement version). */
1448 /* AG r1, d2(x2, b2) -- add (64-bit version). */
1449 else if (is_rx (insn32
, op_a
, &r1
, &d2
, &x2
, &b2
)
1450 || is_rxy (insn32
, op1_ay
, op2_ay
, &r1
, &d2
, &x2
, &b2
)
1451 || is_rxy (insn64
, op1_ag
, op2_ag
, &r1
, &d2
, &x2
, &b2
))
1452 data
->gpr
[r1
] = pv_add (data
->gpr
[r1
],
1453 s390_load (data
, d2
, x2
, b2
, data
->gpr_size
));
1455 /* SLFI r1, i2 --- subtract logical immediate. */
1456 /* SLGFI r1, i2 --- subtract logical immediate (64-bit version). */
1457 else if (is_ril (insn32
, op1_slfi
, op2_slfi
, &r1
, &i2
)
1458 || is_ril (insn64
, op1_slgfi
, op2_slgfi
, &r1
, &i2
))
1459 data
->gpr
[r1
] = pv_add_constant (data
->gpr
[r1
],
1460 -((CORE_ADDR
)i2
& 0xffffffff));
1462 /* SR r1, r2 -- subtract register. */
1463 /* SGR r1, r2 -- subtract register (64-bit version). */
1464 else if (is_rr (insn32
, op_sr
, &r1
, &r2
)
1465 || is_rre (insn64
, op_sgr
, &r1
, &r2
))
1466 data
->gpr
[r1
] = pv_subtract (data
->gpr
[r1
], data
->gpr
[r2
]);
1468 /* S r1, d2(x2, b2) -- subtract. */
1469 /* SY r1, d2(x2, b2) -- subtract (long-displacement version). */
1470 /* SG r1, d2(x2, b2) -- subtract (64-bit version). */
1471 else if (is_rx (insn32
, op_s
, &r1
, &d2
, &x2
, &b2
)
1472 || is_rxy (insn32
, op1_sy
, op2_sy
, &r1
, &d2
, &x2
, &b2
)
1473 || is_rxy (insn64
, op1_sg
, op2_sg
, &r1
, &d2
, &x2
, &b2
))
1474 data
->gpr
[r1
] = pv_subtract (data
->gpr
[r1
],
1475 s390_load (data
, d2
, x2
, b2
, data
->gpr_size
));
1477 /* LA r1, d2(x2, b2) --- load address. */
1478 /* LAY r1, d2(x2, b2) --- load address (long-displacement version). */
1479 else if (is_rx (insn
, op_la
, &r1
, &d2
, &x2
, &b2
)
1480 || is_rxy (insn
, op1_lay
, op2_lay
, &r1
, &d2
, &x2
, &b2
))
1481 data
->gpr
[r1
] = s390_addr (data
, d2
, x2
, b2
);
1483 /* LARL r1, i2 --- load address relative long. */
1484 else if (is_ril (insn
, op1_larl
, op2_larl
, &r1
, &i2
))
1485 data
->gpr
[r1
] = pv_constant (pc
+ i2
* 2);
1487 /* BASR r1, 0 --- branch and save.
1488 Since r2 is zero, this saves the PC in r1, but doesn't branch. */
1489 else if (is_rr (insn
, op_basr
, &r1
, &r2
)
1491 data
->gpr
[r1
] = pv_constant (next_pc
);
1493 /* BRAS r1, i2 --- branch relative and save. */
1494 else if (is_ri (insn
, op1_bras
, op2_bras
, &r1
, &i2
))
1496 data
->gpr
[r1
] = pv_constant (next_pc
);
1497 next_pc
= pc
+ i2
* 2;
1499 /* We'd better not interpret any backward branches. We'll
1505 /* Terminate search when hitting any other branch instruction. */
1506 else if (is_rr (insn
, op_basr
, &r1
, &r2
)
1507 || is_rx (insn
, op_bas
, &r1
, &d2
, &x2
, &b2
)
1508 || is_rr (insn
, op_bcr
, &r1
, &r2
)
1509 || is_rx (insn
, op_bc
, &r1
, &d2
, &x2
, &b2
)
1510 || is_ri (insn
, op1_brc
, op2_brc
, &r1
, &i2
)
1511 || is_ril (insn
, op1_brcl
, op2_brcl
, &r1
, &i2
)
1512 || is_ril (insn
, op1_brasl
, op2_brasl
, &r2
, &i2
))
1517 /* An instruction we don't know how to simulate. The only
1518 safe thing to do would be to set every value we're tracking
1519 to 'unknown'. Instead, we'll be optimistic: we assume that
1520 we *can* interpret every instruction that the compiler uses
1521 to manipulate any of the data we're interested in here --
1522 then we can just ignore anything else. */
1525 /* Record the address after the last instruction that changed
1526 the FP, SP, or backlink. Ignore instructions that changed
1527 them back to their original values --- those are probably
1528 restore instructions. (The back chain is never restored,
1531 pv_t sp
= data
->gpr
[S390_SP_REGNUM
- S390_R0_REGNUM
];
1532 pv_t fp
= data
->gpr
[S390_FRAME_REGNUM
- S390_R0_REGNUM
];
1534 if ((! pv_is_identical (pre_insn_sp
, sp
)
1535 && ! pv_is_register_k (sp
, S390_SP_REGNUM
, 0)
1536 && sp
.kind
!= pvk_unknown
)
1537 || (! pv_is_identical (pre_insn_fp
, fp
)
1538 && ! pv_is_register_k (fp
, S390_FRAME_REGNUM
, 0)
1539 && fp
.kind
!= pvk_unknown
)
1540 || pre_insn_back_chain_saved_p
!= data
->back_chain_saved_p
)
1545 /* Record where all the registers were saved. */
1546 pv_area_scan (data
->stack
, s390_check_for_saved
, data
);
1548 free_pv_area (data
->stack
);
1554 /* Advance PC across any function entry prologue instructions to reach
1555 some "real" code. */
1557 s390_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
1559 struct s390_prologue_data data
;
1561 skip_pc
= s390_analyze_prologue (gdbarch
, pc
, (CORE_ADDR
)-1, &data
);
1562 return skip_pc
? skip_pc
: pc
;
1565 /* Return true if we are in the functin's epilogue, i.e. after the
1566 instruction that destroyed the function's stack frame. */
1568 s390_in_function_epilogue_p (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
1570 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
1572 /* In frameless functions, there's not frame to destroy and thus
1573 we don't care about the epilogue.
1575 In functions with frame, the epilogue sequence is a pair of
1576 a LM-type instruction that restores (amongst others) the
1577 return register %r14 and the stack pointer %r15, followed
1578 by a branch 'br %r14' --or equivalent-- that effects the
1581 In that situation, this function needs to return 'true' in
1582 exactly one case: when pc points to that branch instruction.
1584 Thus we try to disassemble the one instructions immediately
1585 preceding pc and check whether it is an LM-type instruction
1586 modifying the stack pointer.
1588 Note that disassembling backwards is not reliable, so there
1589 is a slight chance of false positives here ... */
1592 unsigned int r1
, r3
, b2
;
1596 && !target_read_memory (pc
- 4, insn
, 4)
1597 && is_rs (insn
, op_lm
, &r1
, &r3
, &d2
, &b2
)
1598 && r3
== S390_SP_REGNUM
- S390_R0_REGNUM
)
1602 && !target_read_memory (pc
- 6, insn
, 6)
1603 && is_rsy (insn
, op1_lmy
, op2_lmy
, &r1
, &r3
, &d2
, &b2
)
1604 && r3
== S390_SP_REGNUM
- S390_R0_REGNUM
)
1608 && !target_read_memory (pc
- 6, insn
, 6)
1609 && is_rsy (insn
, op1_lmg
, op2_lmg
, &r1
, &r3
, &d2
, &b2
)
1610 && r3
== S390_SP_REGNUM
- S390_R0_REGNUM
)
1616 /* Displaced stepping. */
1618 /* Fix up the state of registers and memory after having single-stepped
1619 a displaced instruction. */
1621 s390_displaced_step_fixup (struct gdbarch
*gdbarch
,
1622 struct displaced_step_closure
*closure
,
1623 CORE_ADDR from
, CORE_ADDR to
,
1624 struct regcache
*regs
)
1626 /* Since we use simple_displaced_step_copy_insn, our closure is a
1627 copy of the instruction. */
1628 gdb_byte
*insn
= (gdb_byte
*) closure
;
1629 static int s390_instrlen
[] = { 2, 4, 4, 6 };
1630 int insnlen
= s390_instrlen
[insn
[0] >> 6];
1632 /* Fields for various kinds of instructions. */
1633 unsigned int b2
, r1
, r2
, x2
, r3
;
1636 /* Get current PC and addressing mode bit. */
1637 CORE_ADDR pc
= regcache_read_pc (regs
);
1640 if (register_size (gdbarch
, S390_PSWA_REGNUM
) == 4)
1642 regcache_cooked_read_unsigned (regs
, S390_PSWA_REGNUM
, &amode
);
1643 amode
&= 0x80000000;
1646 if (debug_displaced
)
1647 fprintf_unfiltered (gdb_stdlog
,
1648 "displaced: (s390) fixup (%s, %s) pc %s len %d amode 0x%x\n",
1649 paddress (gdbarch
, from
), paddress (gdbarch
, to
),
1650 paddress (gdbarch
, pc
), insnlen
, (int) amode
);
1652 /* Handle absolute branch and save instructions. */
1653 if (is_rr (insn
, op_basr
, &r1
, &r2
)
1654 || is_rx (insn
, op_bas
, &r1
, &d2
, &x2
, &b2
))
1656 /* Recompute saved return address in R1. */
1657 regcache_cooked_write_unsigned (regs
, S390_R0_REGNUM
+ r1
,
1658 amode
| (from
+ insnlen
));
1661 /* Handle absolute branch instructions. */
1662 else if (is_rr (insn
, op_bcr
, &r1
, &r2
)
1663 || is_rx (insn
, op_bc
, &r1
, &d2
, &x2
, &b2
)
1664 || is_rr (insn
, op_bctr
, &r1
, &r2
)
1665 || is_rre (insn
, op_bctgr
, &r1
, &r2
)
1666 || is_rx (insn
, op_bct
, &r1
, &d2
, &x2
, &b2
)
1667 || is_rxy (insn
, op1_bctg
, op2_brctg
, &r1
, &d2
, &x2
, &b2
)
1668 || is_rs (insn
, op_bxh
, &r1
, &r3
, &d2
, &b2
)
1669 || is_rsy (insn
, op1_bxhg
, op2_bxhg
, &r1
, &r3
, &d2
, &b2
)
1670 || is_rs (insn
, op_bxle
, &r1
, &r3
, &d2
, &b2
)
1671 || is_rsy (insn
, op1_bxleg
, op2_bxleg
, &r1
, &r3
, &d2
, &b2
))
1673 /* Update PC iff branch was *not* taken. */
1674 if (pc
== to
+ insnlen
)
1675 regcache_write_pc (regs
, from
+ insnlen
);
1678 /* Handle PC-relative branch and save instructions. */
1679 else if (is_ri (insn
, op1_bras
, op2_bras
, &r1
, &i2
)
1680 || is_ril (insn
, op1_brasl
, op2_brasl
, &r1
, &i2
))
1683 regcache_write_pc (regs
, pc
- to
+ from
);
1684 /* Recompute saved return address in R1. */
1685 regcache_cooked_write_unsigned (regs
, S390_R0_REGNUM
+ r1
,
1686 amode
| (from
+ insnlen
));
1689 /* Handle PC-relative branch instructions. */
1690 else if (is_ri (insn
, op1_brc
, op2_brc
, &r1
, &i2
)
1691 || is_ril (insn
, op1_brcl
, op2_brcl
, &r1
, &i2
)
1692 || is_ri (insn
, op1_brct
, op2_brct
, &r1
, &i2
)
1693 || is_ri (insn
, op1_brctg
, op2_brctg
, &r1
, &i2
)
1694 || is_rsi (insn
, op_brxh
, &r1
, &r3
, &i2
)
1695 || is_rie (insn
, op1_brxhg
, op2_brxhg
, &r1
, &r3
, &i2
)
1696 || is_rsi (insn
, op_brxle
, &r1
, &r3
, &i2
)
1697 || is_rie (insn
, op1_brxlg
, op2_brxlg
, &r1
, &r3
, &i2
))
1700 regcache_write_pc (regs
, pc
- to
+ from
);
1703 /* Handle LOAD ADDRESS RELATIVE LONG. */
1704 else if (is_ril (insn
, op1_larl
, op2_larl
, &r1
, &i2
))
1707 regcache_write_pc (regs
, from
+ insnlen
);
1708 /* Recompute output address in R1. */
1709 regcache_cooked_write_unsigned (regs
, S390_R0_REGNUM
+ r1
,
1710 amode
| (from
+ i2
* 2));
1713 /* If we executed a breakpoint instruction, point PC right back at it. */
1714 else if (insn
[0] == 0x0 && insn
[1] == 0x1)
1715 regcache_write_pc (regs
, from
);
1717 /* For any other insn, PC points right after the original instruction. */
1719 regcache_write_pc (regs
, from
+ insnlen
);
1721 if (debug_displaced
)
1722 fprintf_unfiltered (gdb_stdlog
,
1723 "displaced: (s390) pc is now %s\n",
1724 paddress (gdbarch
, regcache_read_pc (regs
)));
1728 /* Helper routine to unwind pseudo registers. */
1730 static struct value
*
1731 s390_unwind_pseudo_register (struct frame_info
*this_frame
, int regnum
)
1733 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1734 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1735 struct type
*type
= register_type (gdbarch
, regnum
);
1737 /* Unwind PC via PSW address. */
1738 if (regnum
== tdep
->pc_regnum
)
1742 val
= frame_unwind_register_value (this_frame
, S390_PSWA_REGNUM
);
1743 if (!value_optimized_out (val
))
1745 LONGEST pswa
= value_as_long (val
);
1747 if (TYPE_LENGTH (type
) == 4)
1748 return value_from_pointer (type
, pswa
& 0x7fffffff);
1750 return value_from_pointer (type
, pswa
);
1754 /* Unwind CC via PSW mask. */
1755 if (regnum
== tdep
->cc_regnum
)
1759 val
= frame_unwind_register_value (this_frame
, S390_PSWM_REGNUM
);
1760 if (!value_optimized_out (val
))
1762 LONGEST pswm
= value_as_long (val
);
1764 if (TYPE_LENGTH (type
) == 4)
1765 return value_from_longest (type
, (pswm
>> 12) & 3);
1767 return value_from_longest (type
, (pswm
>> 44) & 3);
1771 /* Unwind full GPRs to show at least the lower halves (as the
1772 upper halves are undefined). */
1773 if (regnum_is_gpr_full (tdep
, regnum
))
1775 int reg
= regnum
- tdep
->gpr_full_regnum
;
1778 val
= frame_unwind_register_value (this_frame
, S390_R0_REGNUM
+ reg
);
1779 if (!value_optimized_out (val
))
1780 return value_cast (type
, val
);
1783 return allocate_optimized_out_value (type
);
1786 static struct value
*
1787 s390_trad_frame_prev_register (struct frame_info
*this_frame
,
1788 struct trad_frame_saved_reg saved_regs
[],
1791 if (regnum
< S390_NUM_REGS
)
1792 return trad_frame_get_prev_register (this_frame
, saved_regs
, regnum
);
1794 return s390_unwind_pseudo_register (this_frame
, regnum
);
1798 /* Normal stack frames. */
1800 struct s390_unwind_cache
{
1803 CORE_ADDR frame_base
;
1804 CORE_ADDR local_base
;
1806 struct trad_frame_saved_reg
*saved_regs
;
1810 s390_prologue_frame_unwind_cache (struct frame_info
*this_frame
,
1811 struct s390_unwind_cache
*info
)
1813 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1814 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
1815 struct s390_prologue_data data
;
1816 pv_t
*fp
= &data
.gpr
[S390_FRAME_REGNUM
- S390_R0_REGNUM
];
1817 pv_t
*sp
= &data
.gpr
[S390_SP_REGNUM
- S390_R0_REGNUM
];
1826 struct frame_info
*next_frame
;
1828 /* Try to find the function start address. If we can't find it, we don't
1829 bother searching for it -- with modern compilers this would be mostly
1830 pointless anyway. Trust that we'll either have valid DWARF-2 CFI data
1831 or else a valid backchain ... */
1832 func
= get_frame_func (this_frame
);
1836 /* Try to analyze the prologue. */
1837 result
= s390_analyze_prologue (gdbarch
, func
,
1838 get_frame_pc (this_frame
), &data
);
1842 /* If this was successful, we should have found the instruction that
1843 sets the stack pointer register to the previous value of the stack
1844 pointer minus the frame size. */
1845 if (!pv_is_register (*sp
, S390_SP_REGNUM
))
1848 /* A frame size of zero at this point can mean either a real
1849 frameless function, or else a failure to find the prologue.
1850 Perform some sanity checks to verify we really have a
1851 frameless function. */
1854 /* If the next frame is a NORMAL_FRAME, this frame *cannot* have frame
1855 size zero. This is only possible if the next frame is a sentinel
1856 frame, a dummy frame, or a signal trampoline frame. */
1857 /* FIXME: cagney/2004-05-01: This sanity check shouldn't be
1858 needed, instead the code should simpliy rely on its
1860 next_frame
= get_next_frame (this_frame
);
1861 while (next_frame
&& get_frame_type (next_frame
) == INLINE_FRAME
)
1862 next_frame
= get_next_frame (next_frame
);
1864 && get_frame_type (get_next_frame (this_frame
)) == NORMAL_FRAME
)
1867 /* If we really have a frameless function, %r14 must be valid
1868 -- in particular, it must point to a different function. */
1869 reg
= get_frame_register_unsigned (this_frame
, S390_RETADDR_REGNUM
);
1870 reg
= gdbarch_addr_bits_remove (gdbarch
, reg
) - 1;
1871 if (get_pc_function_start (reg
) == func
)
1873 /* However, there is one case where it *is* valid for %r14
1874 to point to the same function -- if this is a recursive
1875 call, and we have stopped in the prologue *before* the
1876 stack frame was allocated.
1878 Recognize this case by looking ahead a bit ... */
1880 struct s390_prologue_data data2
;
1881 pv_t
*sp
= &data2
.gpr
[S390_SP_REGNUM
- S390_R0_REGNUM
];
1883 if (!(s390_analyze_prologue (gdbarch
, func
, (CORE_ADDR
)-1, &data2
)
1884 && pv_is_register (*sp
, S390_SP_REGNUM
)
1891 /* OK, we've found valid prologue data. */
1894 /* If the frame pointer originally also holds the same value
1895 as the stack pointer, we're probably using it. If it holds
1896 some other value -- even a constant offset -- it is most
1897 likely used as temp register. */
1898 if (pv_is_identical (*sp
, *fp
))
1899 frame_pointer
= S390_FRAME_REGNUM
;
1901 frame_pointer
= S390_SP_REGNUM
;
1903 /* If we've detected a function with stack frame, we'll still have to
1904 treat it as frameless if we're currently within the function epilog
1905 code at a point where the frame pointer has already been restored.
1906 This can only happen in an innermost frame. */
1907 /* FIXME: cagney/2004-05-01: This sanity check shouldn't be needed,
1908 instead the code should simpliy rely on its analysis. */
1909 next_frame
= get_next_frame (this_frame
);
1910 while (next_frame
&& get_frame_type (next_frame
) == INLINE_FRAME
)
1911 next_frame
= get_next_frame (next_frame
);
1913 && (next_frame
== NULL
1914 || get_frame_type (get_next_frame (this_frame
)) != NORMAL_FRAME
))
1916 /* See the comment in s390_in_function_epilogue_p on why this is
1917 not completely reliable ... */
1918 if (s390_in_function_epilogue_p (gdbarch
, get_frame_pc (this_frame
)))
1920 memset (&data
, 0, sizeof (data
));
1922 frame_pointer
= S390_SP_REGNUM
;
1926 /* Once we know the frame register and the frame size, we can unwind
1927 the current value of the frame register from the next frame, and
1928 add back the frame size to arrive that the previous frame's
1929 stack pointer value. */
1930 prev_sp
= get_frame_register_unsigned (this_frame
, frame_pointer
) + size
;
1931 cfa
= prev_sp
+ 16*word_size
+ 32;
1933 /* Set up ABI call-saved/call-clobbered registers. */
1934 for (i
= 0; i
< S390_NUM_REGS
; i
++)
1935 if (!s390_register_call_saved (gdbarch
, i
))
1936 trad_frame_set_unknown (info
->saved_regs
, i
);
1938 /* CC is always call-clobbered. */
1939 trad_frame_set_unknown (info
->saved_regs
, S390_PSWM_REGNUM
);
1941 /* Record the addresses of all register spill slots the prologue parser
1942 has recognized. Consider only registers defined as call-saved by the
1943 ABI; for call-clobbered registers the parser may have recognized
1946 for (i
= 0; i
< 16; i
++)
1947 if (s390_register_call_saved (gdbarch
, S390_R0_REGNUM
+ i
)
1948 && data
.gpr_slot
[i
] != 0)
1949 info
->saved_regs
[S390_R0_REGNUM
+ i
].addr
= cfa
- data
.gpr_slot
[i
];
1951 for (i
= 0; i
< 16; i
++)
1952 if (s390_register_call_saved (gdbarch
, S390_F0_REGNUM
+ i
)
1953 && data
.fpr_slot
[i
] != 0)
1954 info
->saved_regs
[S390_F0_REGNUM
+ i
].addr
= cfa
- data
.fpr_slot
[i
];
1956 /* Function return will set PC to %r14. */
1957 info
->saved_regs
[S390_PSWA_REGNUM
] = info
->saved_regs
[S390_RETADDR_REGNUM
];
1959 /* In frameless functions, we unwind simply by moving the return
1960 address to the PC. However, if we actually stored to the
1961 save area, use that -- we might only think the function frameless
1962 because we're in the middle of the prologue ... */
1964 && !trad_frame_addr_p (info
->saved_regs
, S390_PSWA_REGNUM
))
1966 info
->saved_regs
[S390_PSWA_REGNUM
].realreg
= S390_RETADDR_REGNUM
;
1969 /* Another sanity check: unless this is a frameless function,
1970 we should have found spill slots for SP and PC.
1971 If not, we cannot unwind further -- this happens e.g. in
1972 libc's thread_start routine. */
1975 if (!trad_frame_addr_p (info
->saved_regs
, S390_SP_REGNUM
)
1976 || !trad_frame_addr_p (info
->saved_regs
, S390_PSWA_REGNUM
))
1980 /* We use the current value of the frame register as local_base,
1981 and the top of the register save area as frame_base. */
1984 info
->frame_base
= prev_sp
+ 16*word_size
+ 32;
1985 info
->local_base
= prev_sp
- size
;
1993 s390_backchain_frame_unwind_cache (struct frame_info
*this_frame
,
1994 struct s390_unwind_cache
*info
)
1996 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1997 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
1998 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1999 CORE_ADDR backchain
;
2004 /* Set up ABI call-saved/call-clobbered registers. */
2005 for (i
= 0; i
< S390_NUM_REGS
; i
++)
2006 if (!s390_register_call_saved (gdbarch
, i
))
2007 trad_frame_set_unknown (info
->saved_regs
, i
);
2009 /* CC is always call-clobbered. */
2010 trad_frame_set_unknown (info
->saved_regs
, S390_PSWM_REGNUM
);
2012 /* Get the backchain. */
2013 reg
= get_frame_register_unsigned (this_frame
, S390_SP_REGNUM
);
2014 backchain
= read_memory_unsigned_integer (reg
, word_size
, byte_order
);
2016 /* A zero backchain terminates the frame chain. As additional
2017 sanity check, let's verify that the spill slot for SP in the
2018 save area pointed to by the backchain in fact links back to
2021 && safe_read_memory_integer (backchain
+ 15*word_size
,
2022 word_size
, byte_order
, &sp
)
2023 && (CORE_ADDR
)sp
== backchain
)
2025 /* We don't know which registers were saved, but it will have
2026 to be at least %r14 and %r15. This will allow us to continue
2027 unwinding, but other prev-frame registers may be incorrect ... */
2028 info
->saved_regs
[S390_SP_REGNUM
].addr
= backchain
+ 15*word_size
;
2029 info
->saved_regs
[S390_RETADDR_REGNUM
].addr
= backchain
+ 14*word_size
;
2031 /* Function return will set PC to %r14. */
2032 info
->saved_regs
[S390_PSWA_REGNUM
]
2033 = info
->saved_regs
[S390_RETADDR_REGNUM
];
2035 /* We use the current value of the frame register as local_base,
2036 and the top of the register save area as frame_base. */
2037 info
->frame_base
= backchain
+ 16*word_size
+ 32;
2038 info
->local_base
= reg
;
2041 info
->func
= get_frame_pc (this_frame
);
2044 static struct s390_unwind_cache
*
2045 s390_frame_unwind_cache (struct frame_info
*this_frame
,
2046 void **this_prologue_cache
)
2048 volatile struct gdb_exception ex
;
2049 struct s390_unwind_cache
*info
;
2051 if (*this_prologue_cache
)
2052 return *this_prologue_cache
;
2054 info
= FRAME_OBSTACK_ZALLOC (struct s390_unwind_cache
);
2055 *this_prologue_cache
= info
;
2056 info
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
2058 info
->frame_base
= -1;
2059 info
->local_base
= -1;
2061 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
2063 /* Try to use prologue analysis to fill the unwind cache.
2064 If this fails, fall back to reading the stack backchain. */
2065 if (!s390_prologue_frame_unwind_cache (this_frame
, info
))
2066 s390_backchain_frame_unwind_cache (this_frame
, info
);
2068 if (ex
.reason
< 0 && ex
.error
!= NOT_AVAILABLE_ERROR
)
2069 throw_exception (ex
);
2075 s390_frame_this_id (struct frame_info
*this_frame
,
2076 void **this_prologue_cache
,
2077 struct frame_id
*this_id
)
2079 struct s390_unwind_cache
*info
2080 = s390_frame_unwind_cache (this_frame
, this_prologue_cache
);
2082 if (info
->frame_base
== -1)
2085 *this_id
= frame_id_build (info
->frame_base
, info
->func
);
2088 static struct value
*
2089 s390_frame_prev_register (struct frame_info
*this_frame
,
2090 void **this_prologue_cache
, int regnum
)
2092 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2093 struct s390_unwind_cache
*info
2094 = s390_frame_unwind_cache (this_frame
, this_prologue_cache
);
2096 return s390_trad_frame_prev_register (this_frame
, info
->saved_regs
, regnum
);
2099 static const struct frame_unwind s390_frame_unwind
= {
2101 default_frame_unwind_stop_reason
,
2103 s390_frame_prev_register
,
2105 default_frame_sniffer
2109 /* Code stubs and their stack frames. For things like PLTs and NULL
2110 function calls (where there is no true frame and the return address
2111 is in the RETADDR register). */
2113 struct s390_stub_unwind_cache
2115 CORE_ADDR frame_base
;
2116 struct trad_frame_saved_reg
*saved_regs
;
2119 static struct s390_stub_unwind_cache
*
2120 s390_stub_frame_unwind_cache (struct frame_info
*this_frame
,
2121 void **this_prologue_cache
)
2123 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2124 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
2125 struct s390_stub_unwind_cache
*info
;
2128 if (*this_prologue_cache
)
2129 return *this_prologue_cache
;
2131 info
= FRAME_OBSTACK_ZALLOC (struct s390_stub_unwind_cache
);
2132 *this_prologue_cache
= info
;
2133 info
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
2135 /* The return address is in register %r14. */
2136 info
->saved_regs
[S390_PSWA_REGNUM
].realreg
= S390_RETADDR_REGNUM
;
2138 /* Retrieve stack pointer and determine our frame base. */
2139 reg
= get_frame_register_unsigned (this_frame
, S390_SP_REGNUM
);
2140 info
->frame_base
= reg
+ 16*word_size
+ 32;
2146 s390_stub_frame_this_id (struct frame_info
*this_frame
,
2147 void **this_prologue_cache
,
2148 struct frame_id
*this_id
)
2150 struct s390_stub_unwind_cache
*info
2151 = s390_stub_frame_unwind_cache (this_frame
, this_prologue_cache
);
2152 *this_id
= frame_id_build (info
->frame_base
, get_frame_pc (this_frame
));
2155 static struct value
*
2156 s390_stub_frame_prev_register (struct frame_info
*this_frame
,
2157 void **this_prologue_cache
, int regnum
)
2159 struct s390_stub_unwind_cache
*info
2160 = s390_stub_frame_unwind_cache (this_frame
, this_prologue_cache
);
2161 return s390_trad_frame_prev_register (this_frame
, info
->saved_regs
, regnum
);
2165 s390_stub_frame_sniffer (const struct frame_unwind
*self
,
2166 struct frame_info
*this_frame
,
2167 void **this_prologue_cache
)
2169 CORE_ADDR addr_in_block
;
2170 bfd_byte insn
[S390_MAX_INSTR_SIZE
];
2172 /* If the current PC points to non-readable memory, we assume we
2173 have trapped due to an invalid function pointer call. We handle
2174 the non-existing current function like a PLT stub. */
2175 addr_in_block
= get_frame_address_in_block (this_frame
);
2176 if (in_plt_section (addr_in_block
)
2177 || s390_readinstruction (insn
, get_frame_pc (this_frame
)) < 0)
2182 static const struct frame_unwind s390_stub_frame_unwind
= {
2184 default_frame_unwind_stop_reason
,
2185 s390_stub_frame_this_id
,
2186 s390_stub_frame_prev_register
,
2188 s390_stub_frame_sniffer
2192 /* Signal trampoline stack frames. */
2194 struct s390_sigtramp_unwind_cache
{
2195 CORE_ADDR frame_base
;
2196 struct trad_frame_saved_reg
*saved_regs
;
2199 static struct s390_sigtramp_unwind_cache
*
2200 s390_sigtramp_frame_unwind_cache (struct frame_info
*this_frame
,
2201 void **this_prologue_cache
)
2203 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2204 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2205 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
2206 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2207 struct s390_sigtramp_unwind_cache
*info
;
2208 ULONGEST this_sp
, prev_sp
;
2209 CORE_ADDR next_ra
, next_cfa
, sigreg_ptr
, sigreg_high_off
;
2212 if (*this_prologue_cache
)
2213 return *this_prologue_cache
;
2215 info
= FRAME_OBSTACK_ZALLOC (struct s390_sigtramp_unwind_cache
);
2216 *this_prologue_cache
= info
;
2217 info
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
2219 this_sp
= get_frame_register_unsigned (this_frame
, S390_SP_REGNUM
);
2220 next_ra
= get_frame_pc (this_frame
);
2221 next_cfa
= this_sp
+ 16*word_size
+ 32;
2223 /* New-style RT frame:
2224 retcode + alignment (8 bytes)
2226 ucontext (contains sigregs at offset 5 words). */
2227 if (next_ra
== next_cfa
)
2229 sigreg_ptr
= next_cfa
+ 8 + 128 + align_up (5*word_size
, 8);
2230 /* sigregs are followed by uc_sigmask (8 bytes), then by the
2231 upper GPR halves if present. */
2232 sigreg_high_off
= 8;
2235 /* Old-style RT frame and all non-RT frames:
2236 old signal mask (8 bytes)
2237 pointer to sigregs. */
2240 sigreg_ptr
= read_memory_unsigned_integer (next_cfa
+ 8,
2241 word_size
, byte_order
);
2242 /* sigregs are followed by signo (4 bytes), then by the
2243 upper GPR halves if present. */
2244 sigreg_high_off
= 4;
2247 /* The sigregs structure looks like this:
2256 /* PSW mask and address. */
2257 info
->saved_regs
[S390_PSWM_REGNUM
].addr
= sigreg_ptr
;
2258 sigreg_ptr
+= word_size
;
2259 info
->saved_regs
[S390_PSWA_REGNUM
].addr
= sigreg_ptr
;
2260 sigreg_ptr
+= word_size
;
2262 /* Then the GPRs. */
2263 for (i
= 0; i
< 16; i
++)
2265 info
->saved_regs
[S390_R0_REGNUM
+ i
].addr
= sigreg_ptr
;
2266 sigreg_ptr
+= word_size
;
2269 /* Then the ACRs. */
2270 for (i
= 0; i
< 16; i
++)
2272 info
->saved_regs
[S390_A0_REGNUM
+ i
].addr
= sigreg_ptr
;
2276 /* The floating-point control word. */
2277 info
->saved_regs
[S390_FPC_REGNUM
].addr
= sigreg_ptr
;
2280 /* And finally the FPRs. */
2281 for (i
= 0; i
< 16; i
++)
2283 info
->saved_regs
[S390_F0_REGNUM
+ i
].addr
= sigreg_ptr
;
2287 /* If we have them, the GPR upper halves are appended at the end. */
2288 sigreg_ptr
+= sigreg_high_off
;
2289 if (tdep
->gpr_full_regnum
!= -1)
2290 for (i
= 0; i
< 16; i
++)
2292 info
->saved_regs
[S390_R0_UPPER_REGNUM
+ i
].addr
= sigreg_ptr
;
2296 /* Restore the previous frame's SP. */
2297 prev_sp
= read_memory_unsigned_integer (
2298 info
->saved_regs
[S390_SP_REGNUM
].addr
,
2299 word_size
, byte_order
);
2301 /* Determine our frame base. */
2302 info
->frame_base
= prev_sp
+ 16*word_size
+ 32;
2308 s390_sigtramp_frame_this_id (struct frame_info
*this_frame
,
2309 void **this_prologue_cache
,
2310 struct frame_id
*this_id
)
2312 struct s390_sigtramp_unwind_cache
*info
2313 = s390_sigtramp_frame_unwind_cache (this_frame
, this_prologue_cache
);
2314 *this_id
= frame_id_build (info
->frame_base
, get_frame_pc (this_frame
));
2317 static struct value
*
2318 s390_sigtramp_frame_prev_register (struct frame_info
*this_frame
,
2319 void **this_prologue_cache
, int regnum
)
2321 struct s390_sigtramp_unwind_cache
*info
2322 = s390_sigtramp_frame_unwind_cache (this_frame
, this_prologue_cache
);
2323 return s390_trad_frame_prev_register (this_frame
, info
->saved_regs
, regnum
);
2327 s390_sigtramp_frame_sniffer (const struct frame_unwind
*self
,
2328 struct frame_info
*this_frame
,
2329 void **this_prologue_cache
)
2331 CORE_ADDR pc
= get_frame_pc (this_frame
);
2332 bfd_byte sigreturn
[2];
2334 if (target_read_memory (pc
, sigreturn
, 2))
2337 if (sigreturn
[0] != op_svc
)
2340 if (sigreturn
[1] != 119 /* sigreturn */
2341 && sigreturn
[1] != 173 /* rt_sigreturn */)
2347 static const struct frame_unwind s390_sigtramp_frame_unwind
= {
2349 default_frame_unwind_stop_reason
,
2350 s390_sigtramp_frame_this_id
,
2351 s390_sigtramp_frame_prev_register
,
2353 s390_sigtramp_frame_sniffer
2356 /* Retrieve the syscall number at a ptrace syscall-stop. Return -1
2360 s390_linux_get_syscall_number (struct gdbarch
*gdbarch
,
2363 struct regcache
*regs
= get_thread_regcache (ptid
);
2364 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2365 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2367 ULONGEST svc_number
= -1;
2370 /* Assume that the PC points after the 2-byte SVC instruction. We
2371 don't currently support SVC via EXECUTE. */
2372 regcache_cooked_read_unsigned (regs
, tdep
->pc_regnum
, &pc
);
2374 opcode
= read_memory_unsigned_integer ((CORE_ADDR
) pc
, 1, byte_order
);
2375 if (opcode
!= op_svc
)
2378 svc_number
= read_memory_unsigned_integer ((CORE_ADDR
) pc
+ 1, 1,
2380 if (svc_number
== 0)
2381 regcache_cooked_read_unsigned (regs
, S390_R1_REGNUM
, &svc_number
);
2387 /* Frame base handling. */
2390 s390_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
2392 struct s390_unwind_cache
*info
2393 = s390_frame_unwind_cache (this_frame
, this_cache
);
2394 return info
->frame_base
;
2398 s390_local_base_address (struct frame_info
*this_frame
, void **this_cache
)
2400 struct s390_unwind_cache
*info
2401 = s390_frame_unwind_cache (this_frame
, this_cache
);
2402 return info
->local_base
;
2405 static const struct frame_base s390_frame_base
= {
2407 s390_frame_base_address
,
2408 s390_local_base_address
,
2409 s390_local_base_address
2413 s390_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2415 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2417 pc
= frame_unwind_register_unsigned (next_frame
, tdep
->pc_regnum
);
2418 return gdbarch_addr_bits_remove (gdbarch
, pc
);
2422 s390_unwind_sp (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2425 sp
= frame_unwind_register_unsigned (next_frame
, S390_SP_REGNUM
);
2426 return gdbarch_addr_bits_remove (gdbarch
, sp
);
2430 /* DWARF-2 frame support. */
2432 static struct value
*
2433 s390_dwarf2_prev_register (struct frame_info
*this_frame
, void **this_cache
,
2436 return s390_unwind_pseudo_register (this_frame
, regnum
);
2440 s390_dwarf2_frame_init_reg (struct gdbarch
*gdbarch
, int regnum
,
2441 struct dwarf2_frame_state_reg
*reg
,
2442 struct frame_info
*this_frame
)
2444 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2446 /* The condition code (and thus PSW mask) is call-clobbered. */
2447 if (regnum
== S390_PSWM_REGNUM
)
2448 reg
->how
= DWARF2_FRAME_REG_UNDEFINED
;
2450 /* The PSW address unwinds to the return address. */
2451 else if (regnum
== S390_PSWA_REGNUM
)
2452 reg
->how
= DWARF2_FRAME_REG_RA
;
2454 /* Fixed registers are call-saved or call-clobbered
2455 depending on the ABI in use. */
2456 else if (regnum
< S390_NUM_REGS
)
2458 if (s390_register_call_saved (gdbarch
, regnum
))
2459 reg
->how
= DWARF2_FRAME_REG_SAME_VALUE
;
2461 reg
->how
= DWARF2_FRAME_REG_UNDEFINED
;
2464 /* We install a special function to unwind pseudos. */
2467 reg
->how
= DWARF2_FRAME_REG_FN
;
2468 reg
->loc
.fn
= s390_dwarf2_prev_register
;
2473 /* Dummy function calls. */
2475 /* Return non-zero if TYPE is an integer-like type, zero otherwise.
2476 "Integer-like" types are those that should be passed the way
2477 integers are: integers, enums, ranges, characters, and booleans. */
2479 is_integer_like (struct type
*type
)
2481 enum type_code code
= TYPE_CODE (type
);
2483 return (code
== TYPE_CODE_INT
2484 || code
== TYPE_CODE_ENUM
2485 || code
== TYPE_CODE_RANGE
2486 || code
== TYPE_CODE_CHAR
2487 || code
== TYPE_CODE_BOOL
);
2490 /* Return non-zero if TYPE is a pointer-like type, zero otherwise.
2491 "Pointer-like" types are those that should be passed the way
2492 pointers are: pointers and references. */
2494 is_pointer_like (struct type
*type
)
2496 enum type_code code
= TYPE_CODE (type
);
2498 return (code
== TYPE_CODE_PTR
2499 || code
== TYPE_CODE_REF
);
2503 /* Return non-zero if TYPE is a `float singleton' or `double
2504 singleton', zero otherwise.
2506 A `T singleton' is a struct type with one member, whose type is
2507 either T or a `T singleton'. So, the following are all float
2511 struct { struct { float x; } x; };
2512 struct { struct { struct { float x; } x; } x; };
2516 All such structures are passed as if they were floats or doubles,
2517 as the (revised) ABI says. */
2519 is_float_singleton (struct type
*type
)
2521 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
&& TYPE_NFIELDS (type
) == 1)
2523 struct type
*singleton_type
= TYPE_FIELD_TYPE (type
, 0);
2524 CHECK_TYPEDEF (singleton_type
);
2526 return (TYPE_CODE (singleton_type
) == TYPE_CODE_FLT
2527 || TYPE_CODE (singleton_type
) == TYPE_CODE_DECFLOAT
2528 || is_float_singleton (singleton_type
));
2535 /* Return non-zero if TYPE is a struct-like type, zero otherwise.
2536 "Struct-like" types are those that should be passed as structs are:
2539 As an odd quirk, not mentioned in the ABI, GCC passes float and
2540 double singletons as if they were a plain float, double, etc. (The
2541 corresponding union types are handled normally.) So we exclude
2542 those types here. *shrug* */
2544 is_struct_like (struct type
*type
)
2546 enum type_code code
= TYPE_CODE (type
);
2548 return (code
== TYPE_CODE_UNION
2549 || (code
== TYPE_CODE_STRUCT
&& ! is_float_singleton (type
)));
2553 /* Return non-zero if TYPE is a float-like type, zero otherwise.
2554 "Float-like" types are those that should be passed as
2555 floating-point values are.
2557 You'd think this would just be floats, doubles, long doubles, etc.
2558 But as an odd quirk, not mentioned in the ABI, GCC passes float and
2559 double singletons as if they were a plain float, double, etc. (The
2560 corresponding union types are handled normally.) So we include
2561 those types here. *shrug* */
2563 is_float_like (struct type
*type
)
2565 return (TYPE_CODE (type
) == TYPE_CODE_FLT
2566 || TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
2567 || is_float_singleton (type
));
2572 is_power_of_two (unsigned int n
)
2574 return ((n
& (n
- 1)) == 0);
2577 /* Return non-zero if TYPE should be passed as a pointer to a copy,
2580 s390_function_arg_pass_by_reference (struct type
*type
)
2582 if (TYPE_LENGTH (type
) > 8)
2585 return (is_struct_like (type
) && !is_power_of_two (TYPE_LENGTH (type
)))
2586 || TYPE_CODE (type
) == TYPE_CODE_COMPLEX
2587 || (TYPE_CODE (type
) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (type
));
2590 /* Return non-zero if TYPE should be passed in a float register
2593 s390_function_arg_float (struct type
*type
)
2595 if (TYPE_LENGTH (type
) > 8)
2598 return is_float_like (type
);
2601 /* Return non-zero if TYPE should be passed in an integer register
2602 (or a pair of integer registers) if possible. */
2604 s390_function_arg_integer (struct type
*type
)
2606 if (TYPE_LENGTH (type
) > 8)
2609 return is_integer_like (type
)
2610 || is_pointer_like (type
)
2611 || (is_struct_like (type
) && is_power_of_two (TYPE_LENGTH (type
)));
2614 /* Return ARG, a `SIMPLE_ARG', sign-extended or zero-extended to a full
2615 word as required for the ABI. */
2617 extend_simple_arg (struct gdbarch
*gdbarch
, struct value
*arg
)
2619 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2620 struct type
*type
= check_typedef (value_type (arg
));
2622 /* Even structs get passed in the least significant bits of the
2623 register / memory word. It's not really right to extract them as
2624 an integer, but it does take care of the extension. */
2625 if (TYPE_UNSIGNED (type
))
2626 return extract_unsigned_integer (value_contents (arg
),
2627 TYPE_LENGTH (type
), byte_order
);
2629 return extract_signed_integer (value_contents (arg
),
2630 TYPE_LENGTH (type
), byte_order
);
2634 /* Return the alignment required by TYPE. */
2636 alignment_of (struct type
*type
)
2640 if (is_integer_like (type
)
2641 || is_pointer_like (type
)
2642 || TYPE_CODE (type
) == TYPE_CODE_FLT
2643 || TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
2644 alignment
= TYPE_LENGTH (type
);
2645 else if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
2646 || TYPE_CODE (type
) == TYPE_CODE_UNION
)
2651 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
2654 = alignment_of (check_typedef (TYPE_FIELD_TYPE (type
, i
)));
2656 if (field_alignment
> alignment
)
2657 alignment
= field_alignment
;
2663 /* Check that everything we ever return is a power of two. Lots of
2664 code doesn't want to deal with aligning things to arbitrary
2666 gdb_assert ((alignment
& (alignment
- 1)) == 0);
2672 /* Put the actual parameter values pointed to by ARGS[0..NARGS-1] in
2673 place to be passed to a function, as specified by the "GNU/Linux
2674 for S/390 ELF Application Binary Interface Supplement".
2676 SP is the current stack pointer. We must put arguments, links,
2677 padding, etc. whereever they belong, and return the new stack
2680 If STRUCT_RETURN is non-zero, then the function we're calling is
2681 going to return a structure by value; STRUCT_ADDR is the address of
2682 a block we've allocated for it on the stack.
2684 Our caller has taken care of any type promotions needed to satisfy
2685 prototypes or the old K&R argument-passing rules. */
2687 s390_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
2688 struct regcache
*regcache
, CORE_ADDR bp_addr
,
2689 int nargs
, struct value
**args
, CORE_ADDR sp
,
2690 int struct_return
, CORE_ADDR struct_addr
)
2692 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2693 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
2694 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2697 /* If the i'th argument is passed as a reference to a copy, then
2698 copy_addr[i] is the address of the copy we made. */
2699 CORE_ADDR
*copy_addr
= alloca (nargs
* sizeof (CORE_ADDR
));
2701 /* Reserve space for the reference-to-copy area. */
2702 for (i
= 0; i
< nargs
; i
++)
2704 struct value
*arg
= args
[i
];
2705 struct type
*type
= check_typedef (value_type (arg
));
2707 if (s390_function_arg_pass_by_reference (type
))
2709 sp
-= TYPE_LENGTH (type
);
2710 sp
= align_down (sp
, alignment_of (type
));
2715 /* Reserve space for the parameter area. As a conservative
2716 simplification, we assume that everything will be passed on the
2717 stack. Since every argument larger than 8 bytes will be
2718 passed by reference, we use this simple upper bound. */
2721 /* After all that, make sure it's still aligned on an eight-byte
2723 sp
= align_down (sp
, 8);
2725 /* Allocate the standard frame areas: the register save area, the
2726 word reserved for the compiler (which seems kind of meaningless),
2727 and the back chain pointer. */
2728 sp
-= 16*word_size
+ 32;
2730 /* Now we have the final SP value. Make sure we didn't underflow;
2731 on 31-bit, this would result in addresses with the high bit set,
2732 which causes confusion elsewhere. Note that if we error out
2733 here, stack and registers remain untouched. */
2734 if (gdbarch_addr_bits_remove (gdbarch
, sp
) != sp
)
2735 error (_("Stack overflow"));
2738 /* Finally, place the actual parameters, working from SP towards
2739 higher addresses. The code above is supposed to reserve enough
2744 CORE_ADDR starg
= sp
+ 16*word_size
+ 32;
2746 /* A struct is returned using general register 2. */
2749 regcache_cooked_write_unsigned (regcache
, S390_R0_REGNUM
+ gr
,
2754 for (i
= 0; i
< nargs
; i
++)
2756 struct value
*arg
= args
[i
];
2757 struct type
*type
= check_typedef (value_type (arg
));
2758 unsigned length
= TYPE_LENGTH (type
);
2760 if (s390_function_arg_pass_by_reference (type
))
2762 /* Actually copy the argument contents to the stack slot
2763 that was reserved above. */
2764 write_memory (copy_addr
[i
], value_contents (arg
), length
);
2768 regcache_cooked_write_unsigned (regcache
, S390_R0_REGNUM
+ gr
,
2774 write_memory_unsigned_integer (starg
, word_size
, byte_order
,
2779 else if (s390_function_arg_float (type
))
2781 /* The GNU/Linux for S/390 ABI uses FPRs 0 and 2 to pass arguments,
2782 the GNU/Linux for zSeries ABI uses 0, 2, 4, and 6. */
2783 if (fr
<= (tdep
->abi
== ABI_LINUX_S390
? 2 : 6))
2785 /* When we store a single-precision value in an FP register,
2786 it occupies the leftmost bits. */
2787 regcache_cooked_write_part (regcache
, S390_F0_REGNUM
+ fr
,
2788 0, length
, value_contents (arg
));
2793 /* When we store a single-precision value in a stack slot,
2794 it occupies the rightmost bits. */
2795 starg
= align_up (starg
+ length
, word_size
);
2796 write_memory (starg
- length
, value_contents (arg
), length
);
2799 else if (s390_function_arg_integer (type
) && length
<= word_size
)
2803 /* Integer arguments are always extended to word size. */
2804 regcache_cooked_write_signed (regcache
, S390_R0_REGNUM
+ gr
,
2805 extend_simple_arg (gdbarch
,
2811 /* Integer arguments are always extended to word size. */
2812 write_memory_signed_integer (starg
, word_size
, byte_order
,
2813 extend_simple_arg (gdbarch
, arg
));
2817 else if (s390_function_arg_integer (type
) && length
== 2*word_size
)
2821 regcache_cooked_write (regcache
, S390_R0_REGNUM
+ gr
,
2822 value_contents (arg
));
2823 regcache_cooked_write (regcache
, S390_R0_REGNUM
+ gr
+ 1,
2824 value_contents (arg
) + word_size
);
2829 /* If we skipped r6 because we couldn't fit a DOUBLE_ARG
2830 in it, then don't go back and use it again later. */
2833 write_memory (starg
, value_contents (arg
), length
);
2838 internal_error (__FILE__
, __LINE__
, _("unknown argument type"));
2842 /* Store return PSWA. In 31-bit mode, keep addressing mode bit. */
2846 regcache_cooked_read_unsigned (regcache
, S390_PSWA_REGNUM
, &pswa
);
2847 bp_addr
= (bp_addr
& 0x7fffffff) | (pswa
& 0x80000000);
2849 regcache_cooked_write_unsigned (regcache
, S390_RETADDR_REGNUM
, bp_addr
);
2851 /* Store updated stack pointer. */
2852 regcache_cooked_write_unsigned (regcache
, S390_SP_REGNUM
, sp
);
2854 /* We need to return the 'stack part' of the frame ID,
2855 which is actually the top of the register save area. */
2856 return sp
+ 16*word_size
+ 32;
2859 /* Assuming THIS_FRAME is a dummy, return the frame ID of that
2860 dummy frame. The frame ID's base needs to match the TOS value
2861 returned by push_dummy_call, and the PC match the dummy frame's
2863 static struct frame_id
2864 s390_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*this_frame
)
2866 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
2867 CORE_ADDR sp
= get_frame_register_unsigned (this_frame
, S390_SP_REGNUM
);
2868 sp
= gdbarch_addr_bits_remove (gdbarch
, sp
);
2870 return frame_id_build (sp
+ 16*word_size
+ 32,
2871 get_frame_pc (this_frame
));
2875 s390_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
2877 /* Both the 32- and 64-bit ABI's say that the stack pointer should
2878 always be aligned on an eight-byte boundary. */
2883 /* Function return value access. */
2885 static enum return_value_convention
2886 s390_return_value_convention (struct gdbarch
*gdbarch
, struct type
*type
)
2888 if (TYPE_LENGTH (type
) > 8)
2889 return RETURN_VALUE_STRUCT_CONVENTION
;
2891 switch (TYPE_CODE (type
))
2893 case TYPE_CODE_STRUCT
:
2894 case TYPE_CODE_UNION
:
2895 case TYPE_CODE_ARRAY
:
2896 case TYPE_CODE_COMPLEX
:
2897 return RETURN_VALUE_STRUCT_CONVENTION
;
2900 return RETURN_VALUE_REGISTER_CONVENTION
;
2904 static enum return_value_convention
2905 s390_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
2906 struct type
*type
, struct regcache
*regcache
,
2907 gdb_byte
*out
, const gdb_byte
*in
)
2909 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2910 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
2911 enum return_value_convention rvc
;
2914 type
= check_typedef (type
);
2915 rvc
= s390_return_value_convention (gdbarch
, type
);
2916 length
= TYPE_LENGTH (type
);
2922 case RETURN_VALUE_REGISTER_CONVENTION
:
2923 if (TYPE_CODE (type
) == TYPE_CODE_FLT
2924 || TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
2926 /* When we store a single-precision value in an FP register,
2927 it occupies the leftmost bits. */
2928 regcache_cooked_write_part (regcache
, S390_F0_REGNUM
,
2931 else if (length
<= word_size
)
2933 /* Integer arguments are always extended to word size. */
2934 if (TYPE_UNSIGNED (type
))
2935 regcache_cooked_write_unsigned (regcache
, S390_R2_REGNUM
,
2936 extract_unsigned_integer (in
, length
, byte_order
));
2938 regcache_cooked_write_signed (regcache
, S390_R2_REGNUM
,
2939 extract_signed_integer (in
, length
, byte_order
));
2941 else if (length
== 2*word_size
)
2943 regcache_cooked_write (regcache
, S390_R2_REGNUM
, in
);
2944 regcache_cooked_write (regcache
, S390_R3_REGNUM
, in
+ word_size
);
2947 internal_error (__FILE__
, __LINE__
, _("invalid return type"));
2950 case RETURN_VALUE_STRUCT_CONVENTION
:
2951 error (_("Cannot set function return value."));
2959 case RETURN_VALUE_REGISTER_CONVENTION
:
2960 if (TYPE_CODE (type
) == TYPE_CODE_FLT
2961 || TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
2963 /* When we store a single-precision value in an FP register,
2964 it occupies the leftmost bits. */
2965 regcache_cooked_read_part (regcache
, S390_F0_REGNUM
,
2968 else if (length
<= word_size
)
2970 /* Integer arguments occupy the rightmost bits. */
2971 regcache_cooked_read_part (regcache
, S390_R2_REGNUM
,
2972 word_size
- length
, length
, out
);
2974 else if (length
== 2*word_size
)
2976 regcache_cooked_read (regcache
, S390_R2_REGNUM
, out
);
2977 regcache_cooked_read (regcache
, S390_R3_REGNUM
, out
+ word_size
);
2980 internal_error (__FILE__
, __LINE__
, _("invalid return type"));
2983 case RETURN_VALUE_STRUCT_CONVENTION
:
2984 error (_("Function return value unknown."));
2995 static const gdb_byte
*
2996 s390_breakpoint_from_pc (struct gdbarch
*gdbarch
,
2997 CORE_ADDR
*pcptr
, int *lenptr
)
2999 static const gdb_byte breakpoint
[] = { 0x0, 0x1 };
3001 *lenptr
= sizeof (breakpoint
);
3006 /* Address handling. */
3009 s390_addr_bits_remove (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
3011 return addr
& 0x7fffffff;
3015 s390_address_class_type_flags (int byte_size
, int dwarf2_addr_class
)
3018 return TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1
;
3024 s390_address_class_type_flags_to_name (struct gdbarch
*gdbarch
, int type_flags
)
3026 if (type_flags
& TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1
)
3033 s390_address_class_name_to_type_flags (struct gdbarch
*gdbarch
,
3035 int *type_flags_ptr
)
3037 if (strcmp (name
, "mode32") == 0)
3039 *type_flags_ptr
= TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1
;
3046 /* Implementation of `gdbarch_stap_is_single_operand', as defined in
3050 s390_stap_is_single_operand (struct gdbarch
*gdbarch
, const char *s
)
3052 return ((isdigit (*s
) && s
[1] == '(' && s
[2] == '%') /* Displacement
3054 || *s
== '%' /* Register access. */
3055 || isdigit (*s
)); /* Literal number. */
3058 /* Set up gdbarch struct. */
3060 static struct gdbarch
*
3061 s390_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
3063 const struct target_desc
*tdesc
= info
.target_desc
;
3064 struct tdesc_arch_data
*tdesc_data
= NULL
;
3065 struct gdbarch
*gdbarch
;
3066 struct gdbarch_tdep
*tdep
;
3069 int have_linux_v1
= 0;
3070 int have_linux_v2
= 0;
3071 int first_pseudo_reg
, last_pseudo_reg
;
3072 static const char *const stap_register_prefixes
[] = { "%", NULL
};
3073 static const char *const stap_register_indirection_prefixes
[] = { "(",
3075 static const char *const stap_register_indirection_suffixes
[] = { ")",
3078 /* Default ABI and register size. */
3079 switch (info
.bfd_arch_info
->mach
)
3081 case bfd_mach_s390_31
:
3082 tdep_abi
= ABI_LINUX_S390
;
3085 case bfd_mach_s390_64
:
3086 tdep_abi
= ABI_LINUX_ZSERIES
;
3093 /* Use default target description if none provided by the target. */
3094 if (!tdesc_has_registers (tdesc
))
3096 if (tdep_abi
== ABI_LINUX_S390
)
3097 tdesc
= tdesc_s390_linux32
;
3099 tdesc
= tdesc_s390x_linux64
;
3102 /* Check any target description for validity. */
3103 if (tdesc_has_registers (tdesc
))
3105 static const char *const gprs
[] = {
3106 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
3107 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
3109 static const char *const fprs
[] = {
3110 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
3111 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15"
3113 static const char *const acrs
[] = {
3114 "acr0", "acr1", "acr2", "acr3", "acr4", "acr5", "acr6", "acr7",
3115 "acr8", "acr9", "acr10", "acr11", "acr12", "acr13", "acr14", "acr15"
3117 static const char *const gprs_lower
[] = {
3118 "r0l", "r1l", "r2l", "r3l", "r4l", "r5l", "r6l", "r7l",
3119 "r8l", "r9l", "r10l", "r11l", "r12l", "r13l", "r14l", "r15l"
3121 static const char *const gprs_upper
[] = {
3122 "r0h", "r1h", "r2h", "r3h", "r4h", "r5h", "r6h", "r7h",
3123 "r8h", "r9h", "r10h", "r11h", "r12h", "r13h", "r14h", "r15h"
3125 static const char *const tdb_regs
[] = {
3126 "tdb0", "tac", "tct", "atia",
3127 "tr0", "tr1", "tr2", "tr3", "tr4", "tr5", "tr6", "tr7",
3128 "tr8", "tr9", "tr10", "tr11", "tr12", "tr13", "tr14", "tr15"
3130 const struct tdesc_feature
*feature
;
3133 feature
= tdesc_find_feature (tdesc
, "org.gnu.gdb.s390.core");
3134 if (feature
== NULL
)
3137 tdesc_data
= tdesc_data_alloc ();
3139 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
3140 S390_PSWM_REGNUM
, "pswm");
3141 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
3142 S390_PSWA_REGNUM
, "pswa");
3144 if (tdesc_unnumbered_register (feature
, "r0"))
3146 for (i
= 0; i
< 16; i
++)
3147 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
3148 S390_R0_REGNUM
+ i
, gprs
[i
]);
3154 for (i
= 0; i
< 16; i
++)
3155 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
3158 for (i
= 0; i
< 16; i
++)
3159 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
3160 S390_R0_UPPER_REGNUM
+ i
,
3164 feature
= tdesc_find_feature (tdesc
, "org.gnu.gdb.s390.fpr");
3165 if (feature
== NULL
)
3167 tdesc_data_cleanup (tdesc_data
);
3171 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
3172 S390_FPC_REGNUM
, "fpc");
3173 for (i
= 0; i
< 16; i
++)
3174 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
3175 S390_F0_REGNUM
+ i
, fprs
[i
]);
3177 feature
= tdesc_find_feature (tdesc
, "org.gnu.gdb.s390.acr");
3178 if (feature
== NULL
)
3180 tdesc_data_cleanup (tdesc_data
);
3184 for (i
= 0; i
< 16; i
++)
3185 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
3186 S390_A0_REGNUM
+ i
, acrs
[i
]);
3188 /* Optional GNU/Linux-specific "registers". */
3189 feature
= tdesc_find_feature (tdesc
, "org.gnu.gdb.s390.linux");
3192 tdesc_numbered_register (feature
, tdesc_data
,
3193 S390_ORIG_R2_REGNUM
, "orig_r2");
3195 if (tdesc_numbered_register (feature
, tdesc_data
,
3196 S390_LAST_BREAK_REGNUM
, "last_break"))
3199 if (tdesc_numbered_register (feature
, tdesc_data
,
3200 S390_SYSTEM_CALL_REGNUM
, "system_call"))
3203 if (have_linux_v2
> have_linux_v1
)
3207 /* Transaction diagnostic block. */
3208 feature
= tdesc_find_feature (tdesc
, "org.gnu.gdb.s390.tdb");
3211 for (i
= 0; i
< ARRAY_SIZE (tdb_regs
); i
++)
3212 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
3213 S390_TDB_DWORD0_REGNUM
+ i
,
3219 tdesc_data_cleanup (tdesc_data
);
3224 /* Find a candidate among extant architectures. */
3225 for (arches
= gdbarch_list_lookup_by_info (arches
, &info
);
3227 arches
= gdbarch_list_lookup_by_info (arches
->next
, &info
))
3229 tdep
= gdbarch_tdep (arches
->gdbarch
);
3232 if (tdep
->abi
!= tdep_abi
)
3234 if ((tdep
->gpr_full_regnum
!= -1) != have_upper
)
3236 if (tdesc_data
!= NULL
)
3237 tdesc_data_cleanup (tdesc_data
);
3238 return arches
->gdbarch
;
3241 /* Otherwise create a new gdbarch for the specified machine type. */
3242 tdep
= XCNEW (struct gdbarch_tdep
);
3243 tdep
->abi
= tdep_abi
;
3244 gdbarch
= gdbarch_alloc (&info
, tdep
);
3246 set_gdbarch_believe_pcc_promotion (gdbarch
, 0);
3247 set_gdbarch_char_signed (gdbarch
, 0);
3249 /* S/390 GNU/Linux uses either 64-bit or 128-bit long doubles.
3250 We can safely let them default to 128-bit, since the debug info
3251 will give the size of type actually used in each case. */
3252 set_gdbarch_long_double_bit (gdbarch
, 128);
3253 set_gdbarch_long_double_format (gdbarch
, floatformats_ia64_quad
);
3255 /* Amount PC must be decremented by after a breakpoint. This is
3256 often the number of bytes returned by gdbarch_breakpoint_from_pc but not
3258 set_gdbarch_decr_pc_after_break (gdbarch
, 2);
3259 /* Stack grows downward. */
3260 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
3261 set_gdbarch_breakpoint_from_pc (gdbarch
, s390_breakpoint_from_pc
);
3262 set_gdbarch_skip_prologue (gdbarch
, s390_skip_prologue
);
3263 set_gdbarch_in_function_epilogue_p (gdbarch
, s390_in_function_epilogue_p
);
3265 set_gdbarch_num_regs (gdbarch
, S390_NUM_REGS
);
3266 set_gdbarch_sp_regnum (gdbarch
, S390_SP_REGNUM
);
3267 set_gdbarch_fp0_regnum (gdbarch
, S390_F0_REGNUM
);
3268 set_gdbarch_stab_reg_to_regnum (gdbarch
, s390_dwarf_reg_to_regnum
);
3269 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, s390_dwarf_reg_to_regnum
);
3270 set_gdbarch_value_from_register (gdbarch
, s390_value_from_register
);
3271 set_gdbarch_regset_from_core_section (gdbarch
,
3272 s390_regset_from_core_section
);
3273 set_gdbarch_core_read_description (gdbarch
, s390_core_read_description
);
3274 set_gdbarch_cannot_store_register (gdbarch
, s390_cannot_store_register
);
3275 set_gdbarch_write_pc (gdbarch
, s390_write_pc
);
3276 set_gdbarch_pseudo_register_read (gdbarch
, s390_pseudo_register_read
);
3277 set_gdbarch_pseudo_register_write (gdbarch
, s390_pseudo_register_write
);
3278 set_tdesc_pseudo_register_name (gdbarch
, s390_pseudo_register_name
);
3279 set_tdesc_pseudo_register_type (gdbarch
, s390_pseudo_register_type
);
3280 set_tdesc_pseudo_register_reggroup_p (gdbarch
,
3281 s390_pseudo_register_reggroup_p
);
3282 tdesc_use_registers (gdbarch
, tdesc
, tdesc_data
);
3284 /* Assign pseudo register numbers. */
3285 first_pseudo_reg
= gdbarch_num_regs (gdbarch
);
3286 last_pseudo_reg
= first_pseudo_reg
;
3287 tdep
->gpr_full_regnum
= -1;
3290 tdep
->gpr_full_regnum
= last_pseudo_reg
;
3291 last_pseudo_reg
+= 16;
3293 tdep
->pc_regnum
= last_pseudo_reg
++;
3294 tdep
->cc_regnum
= last_pseudo_reg
++;
3295 set_gdbarch_pc_regnum (gdbarch
, tdep
->pc_regnum
);
3296 set_gdbarch_num_pseudo_regs (gdbarch
, last_pseudo_reg
- first_pseudo_reg
);
3298 /* Inferior function calls. */
3299 set_gdbarch_push_dummy_call (gdbarch
, s390_push_dummy_call
);
3300 set_gdbarch_dummy_id (gdbarch
, s390_dummy_id
);
3301 set_gdbarch_frame_align (gdbarch
, s390_frame_align
);
3302 set_gdbarch_return_value (gdbarch
, s390_return_value
);
3304 /* Syscall handling. */
3305 set_gdbarch_get_syscall_number (gdbarch
, s390_linux_get_syscall_number
);
3307 /* Frame handling. */
3308 dwarf2_frame_set_init_reg (gdbarch
, s390_dwarf2_frame_init_reg
);
3309 dwarf2_frame_set_adjust_regnum (gdbarch
, s390_adjust_frame_regnum
);
3310 dwarf2_append_unwinders (gdbarch
);
3311 frame_base_append_sniffer (gdbarch
, dwarf2_frame_base_sniffer
);
3312 frame_unwind_append_unwinder (gdbarch
, &s390_stub_frame_unwind
);
3313 frame_unwind_append_unwinder (gdbarch
, &s390_sigtramp_frame_unwind
);
3314 frame_unwind_append_unwinder (gdbarch
, &s390_frame_unwind
);
3315 frame_base_set_default (gdbarch
, &s390_frame_base
);
3316 set_gdbarch_unwind_pc (gdbarch
, s390_unwind_pc
);
3317 set_gdbarch_unwind_sp (gdbarch
, s390_unwind_sp
);
3319 /* Displaced stepping. */
3320 set_gdbarch_displaced_step_copy_insn (gdbarch
,
3321 simple_displaced_step_copy_insn
);
3322 set_gdbarch_displaced_step_fixup (gdbarch
, s390_displaced_step_fixup
);
3323 set_gdbarch_displaced_step_free_closure (gdbarch
,
3324 simple_displaced_step_free_closure
);
3325 set_gdbarch_displaced_step_location (gdbarch
,
3326 displaced_step_at_entry_point
);
3327 set_gdbarch_max_insn_length (gdbarch
, S390_MAX_INSTR_SIZE
);
3329 /* Note that GNU/Linux is the only OS supported on this
3331 linux_init_abi (info
, gdbarch
);
3335 case ABI_LINUX_S390
:
3336 tdep
->gregset
= &s390_gregset
;
3337 tdep
->sizeof_gregset
= s390_sizeof_gregset
;
3338 tdep
->fpregset
= &s390_fpregset
;
3339 tdep
->sizeof_fpregset
= s390_sizeof_fpregset
;
3341 set_gdbarch_addr_bits_remove (gdbarch
, s390_addr_bits_remove
);
3342 set_solib_svr4_fetch_link_map_offsets
3343 (gdbarch
, svr4_ilp32_fetch_link_map_offsets
);
3345 set_xml_syscall_file_name (XML_SYSCALL_FILENAME_S390
);
3350 set_gdbarch_core_regset_sections (gdbarch
,
3351 s390_linux64v2_regset_sections
);
3352 else if (have_linux_v1
)
3353 set_gdbarch_core_regset_sections (gdbarch
,
3354 s390_linux64v1_regset_sections
);
3356 set_gdbarch_core_regset_sections (gdbarch
,
3357 s390_linux64_regset_sections
);
3362 set_gdbarch_core_regset_sections (gdbarch
,
3363 s390_linux32v2_regset_sections
);
3364 else if (have_linux_v1
)
3365 set_gdbarch_core_regset_sections (gdbarch
,
3366 s390_linux32v1_regset_sections
);
3368 set_gdbarch_core_regset_sections (gdbarch
,
3369 s390_linux32_regset_sections
);
3373 case ABI_LINUX_ZSERIES
:
3374 tdep
->gregset
= &s390x_gregset
;
3375 tdep
->sizeof_gregset
= s390x_sizeof_gregset
;
3376 tdep
->fpregset
= &s390_fpregset
;
3377 tdep
->sizeof_fpregset
= s390_sizeof_fpregset
;
3379 set_gdbarch_long_bit (gdbarch
, 64);
3380 set_gdbarch_long_long_bit (gdbarch
, 64);
3381 set_gdbarch_ptr_bit (gdbarch
, 64);
3382 set_solib_svr4_fetch_link_map_offsets
3383 (gdbarch
, svr4_lp64_fetch_link_map_offsets
);
3384 set_gdbarch_address_class_type_flags (gdbarch
,
3385 s390_address_class_type_flags
);
3386 set_gdbarch_address_class_type_flags_to_name (gdbarch
,
3387 s390_address_class_type_flags_to_name
);
3388 set_gdbarch_address_class_name_to_type_flags (gdbarch
,
3389 s390_address_class_name_to_type_flags
);
3391 set_xml_syscall_file_name (XML_SYSCALL_FILENAME_S390
);
3394 set_gdbarch_core_regset_sections (gdbarch
,
3395 s390x_linux64v2_regset_sections
);
3396 else if (have_linux_v1
)
3397 set_gdbarch_core_regset_sections (gdbarch
,
3398 s390x_linux64v1_regset_sections
);
3400 set_gdbarch_core_regset_sections (gdbarch
,
3401 s390x_linux64_regset_sections
);
3405 set_gdbarch_print_insn (gdbarch
, print_insn_s390
);
3407 set_gdbarch_skip_trampoline_code (gdbarch
, find_solib_trampoline_target
);
3409 /* Enable TLS support. */
3410 set_gdbarch_fetch_tls_load_module_address (gdbarch
,
3411 svr4_fetch_objfile_link_map
);
3413 set_gdbarch_get_siginfo_type (gdbarch
, linux_get_siginfo_type
);
3415 /* SystemTap functions. */
3416 set_gdbarch_stap_register_prefixes (gdbarch
, stap_register_prefixes
);
3417 set_gdbarch_stap_register_indirection_prefixes (gdbarch
,
3418 stap_register_indirection_prefixes
);
3419 set_gdbarch_stap_register_indirection_suffixes (gdbarch
,
3420 stap_register_indirection_suffixes
);
3421 set_gdbarch_stap_is_single_operand (gdbarch
, s390_stap_is_single_operand
);
3427 extern initialize_file_ftype _initialize_s390_tdep
; /* -Wmissing-prototypes */
3430 _initialize_s390_tdep (void)
3432 /* Hook us into the gdbarch mechanism. */
3433 register_gdbarch_init (bfd_arch_s390
, s390_gdbarch_init
);
3435 /* Initialize the GNU/Linux target descriptions. */
3436 initialize_tdesc_s390_linux32 ();
3437 initialize_tdesc_s390_linux32v1 ();
3438 initialize_tdesc_s390_linux32v2 ();
3439 initialize_tdesc_s390_linux64 ();
3440 initialize_tdesc_s390_linux64v1 ();
3441 initialize_tdesc_s390_linux64v2 ();
3442 initialize_tdesc_s390_te_linux64 ();
3443 initialize_tdesc_s390x_linux64 ();
3444 initialize_tdesc_s390x_linux64v1 ();
3445 initialize_tdesc_s390x_linux64v2 ();
3446 initialize_tdesc_s390x_te_linux64 ();