1 /* Target-dependent code for GDB, the GNU debugger.
3 Copyright (C) 2001-2012 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"
32 #include "floatformat.h"
34 #include "trad-frame.h"
35 #include "frame-base.h"
36 #include "frame-unwind.h"
37 #include "dwarf2-frame.h"
38 #include "reggroups.h"
41 #include "gdb_assert.h"
43 #include "solib-svr4.h"
44 #include "prologue-value.h"
45 #include "linux-tdep.h"
46 #include "s390-tdep.h"
48 #include "stap-probe.h"
51 #include "user-regs.h"
52 #include "cli/cli-utils.h"
55 #include "features/s390-linux32.c"
56 #include "features/s390-linux32v1.c"
57 #include "features/s390-linux32v2.c"
58 #include "features/s390-linux64.c"
59 #include "features/s390-linux64v1.c"
60 #include "features/s390-linux64v2.c"
61 #include "features/s390x-linux64.c"
62 #include "features/s390x-linux64v1.c"
63 #include "features/s390x-linux64v2.c"
65 /* The tdep structure. */
70 enum { ABI_LINUX_S390
, ABI_LINUX_ZSERIES
} abi
;
72 /* Pseudo register numbers. */
77 /* Core file register sets. */
78 const struct regset
*gregset
;
81 const struct regset
*fpregset
;
86 /* ABI call-saved register information. */
89 s390_register_call_saved (struct gdbarch
*gdbarch
, int regnum
)
91 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
96 if ((regnum
>= S390_R6_REGNUM
&& regnum
<= S390_R15_REGNUM
)
97 || regnum
== S390_F4_REGNUM
|| regnum
== S390_F6_REGNUM
98 || regnum
== S390_A0_REGNUM
)
103 case ABI_LINUX_ZSERIES
:
104 if ((regnum
>= S390_R6_REGNUM
&& regnum
<= S390_R15_REGNUM
)
105 || (regnum
>= S390_F8_REGNUM
&& regnum
<= S390_F15_REGNUM
)
106 || (regnum
>= S390_A0_REGNUM
&& regnum
<= S390_A1_REGNUM
))
116 s390_cannot_store_register (struct gdbarch
*gdbarch
, int regnum
)
118 /* The last-break address is read-only. */
119 return regnum
== S390_LAST_BREAK_REGNUM
;
123 s390_write_pc (struct regcache
*regcache
, CORE_ADDR pc
)
125 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
126 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
128 regcache_cooked_write_unsigned (regcache
, tdep
->pc_regnum
, pc
);
130 /* Set special SYSTEM_CALL register to 0 to prevent the kernel from
131 messing with the PC we just installed, if we happen to be within
132 an interrupted system call that the kernel wants to restart.
134 Note that after we return from the dummy call, the SYSTEM_CALL and
135 ORIG_R2 registers will be automatically restored, and the kernel
136 continues to restart the system call at this point. */
137 if (register_size (gdbarch
, S390_SYSTEM_CALL_REGNUM
) > 0)
138 regcache_cooked_write_unsigned (regcache
, S390_SYSTEM_CALL_REGNUM
, 0);
142 /* DWARF Register Mapping. */
144 static int s390_dwarf_regmap
[] =
146 /* General Purpose Registers. */
147 S390_R0_REGNUM
, S390_R1_REGNUM
, S390_R2_REGNUM
, S390_R3_REGNUM
,
148 S390_R4_REGNUM
, S390_R5_REGNUM
, S390_R6_REGNUM
, S390_R7_REGNUM
,
149 S390_R8_REGNUM
, S390_R9_REGNUM
, S390_R10_REGNUM
, S390_R11_REGNUM
,
150 S390_R12_REGNUM
, S390_R13_REGNUM
, S390_R14_REGNUM
, S390_R15_REGNUM
,
152 /* Floating Point Registers. */
153 S390_F0_REGNUM
, S390_F2_REGNUM
, S390_F4_REGNUM
, S390_F6_REGNUM
,
154 S390_F1_REGNUM
, S390_F3_REGNUM
, S390_F5_REGNUM
, S390_F7_REGNUM
,
155 S390_F8_REGNUM
, S390_F10_REGNUM
, S390_F12_REGNUM
, S390_F14_REGNUM
,
156 S390_F9_REGNUM
, S390_F11_REGNUM
, S390_F13_REGNUM
, S390_F15_REGNUM
,
158 /* Control Registers (not mapped). */
159 -1, -1, -1, -1, -1, -1, -1, -1,
160 -1, -1, -1, -1, -1, -1, -1, -1,
162 /* Access Registers. */
163 S390_A0_REGNUM
, S390_A1_REGNUM
, S390_A2_REGNUM
, S390_A3_REGNUM
,
164 S390_A4_REGNUM
, S390_A5_REGNUM
, S390_A6_REGNUM
, S390_A7_REGNUM
,
165 S390_A8_REGNUM
, S390_A9_REGNUM
, S390_A10_REGNUM
, S390_A11_REGNUM
,
166 S390_A12_REGNUM
, S390_A13_REGNUM
, S390_A14_REGNUM
, S390_A15_REGNUM
,
168 /* Program Status Word. */
172 /* GPR Lower Half Access. */
173 S390_R0_REGNUM
, S390_R1_REGNUM
, S390_R2_REGNUM
, S390_R3_REGNUM
,
174 S390_R4_REGNUM
, S390_R5_REGNUM
, S390_R6_REGNUM
, S390_R7_REGNUM
,
175 S390_R8_REGNUM
, S390_R9_REGNUM
, S390_R10_REGNUM
, S390_R11_REGNUM
,
176 S390_R12_REGNUM
, S390_R13_REGNUM
, S390_R14_REGNUM
, S390_R15_REGNUM
,
178 /* GNU/Linux-specific registers (not mapped). */
182 /* Convert DWARF register number REG to the appropriate register
183 number used by GDB. */
185 s390_dwarf_reg_to_regnum (struct gdbarch
*gdbarch
, int reg
)
187 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
189 /* In a 32-on-64 debug scenario, debug info refers to the full 64-bit
190 GPRs. Note that call frame information still refers to the 32-bit
191 lower halves, because s390_adjust_frame_regnum uses register numbers
192 66 .. 81 to access GPRs. */
193 if (tdep
->gpr_full_regnum
!= -1 && reg
>= 0 && reg
< 16)
194 return tdep
->gpr_full_regnum
+ reg
;
196 if (reg
>= 0 && reg
< ARRAY_SIZE (s390_dwarf_regmap
))
197 return s390_dwarf_regmap
[reg
];
199 warning (_("Unmapped DWARF Register #%d encountered."), reg
);
203 /* Translate a .eh_frame register to DWARF register, or adjust a
204 .debug_frame register. */
206 s390_adjust_frame_regnum (struct gdbarch
*gdbarch
, int num
, int eh_frame_p
)
208 /* See s390_dwarf_reg_to_regnum for comments. */
209 return (num
>= 0 && num
< 16)? num
+ 66 : num
;
213 /* Pseudo registers. */
216 s390_pseudo_register_name (struct gdbarch
*gdbarch
, int regnum
)
218 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
220 if (regnum
== tdep
->pc_regnum
)
223 if (regnum
== tdep
->cc_regnum
)
226 if (tdep
->gpr_full_regnum
!= -1
227 && regnum
>= tdep
->gpr_full_regnum
228 && regnum
< tdep
->gpr_full_regnum
+ 16)
230 static const char *full_name
[] = {
231 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
232 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
234 return full_name
[regnum
- tdep
->gpr_full_regnum
];
237 internal_error (__FILE__
, __LINE__
, _("invalid regnum"));
241 s390_pseudo_register_type (struct gdbarch
*gdbarch
, int regnum
)
243 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
245 if (regnum
== tdep
->pc_regnum
)
246 return builtin_type (gdbarch
)->builtin_func_ptr
;
248 if (regnum
== tdep
->cc_regnum
)
249 return builtin_type (gdbarch
)->builtin_int
;
251 if (tdep
->gpr_full_regnum
!= -1
252 && regnum
>= tdep
->gpr_full_regnum
253 && regnum
< tdep
->gpr_full_regnum
+ 16)
254 return builtin_type (gdbarch
)->builtin_uint64
;
256 internal_error (__FILE__
, __LINE__
, _("invalid regnum"));
259 static enum register_status
260 s390_pseudo_register_read (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
261 int regnum
, gdb_byte
*buf
)
263 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
264 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
265 int regsize
= register_size (gdbarch
, regnum
);
268 if (regnum
== tdep
->pc_regnum
)
270 enum register_status status
;
272 status
= regcache_raw_read_unsigned (regcache
, S390_PSWA_REGNUM
, &val
);
273 if (status
== REG_VALID
)
275 if (register_size (gdbarch
, S390_PSWA_REGNUM
) == 4)
277 store_unsigned_integer (buf
, regsize
, byte_order
, val
);
282 if (regnum
== tdep
->cc_regnum
)
284 enum register_status status
;
286 status
= regcache_raw_read_unsigned (regcache
, S390_PSWM_REGNUM
, &val
);
287 if (status
== REG_VALID
)
289 if (register_size (gdbarch
, S390_PSWA_REGNUM
) == 4)
290 val
= (val
>> 12) & 3;
292 val
= (val
>> 44) & 3;
293 store_unsigned_integer (buf
, regsize
, byte_order
, val
);
298 if (tdep
->gpr_full_regnum
!= -1
299 && regnum
>= tdep
->gpr_full_regnum
300 && regnum
< tdep
->gpr_full_regnum
+ 16)
302 enum register_status status
;
305 regnum
-= tdep
->gpr_full_regnum
;
307 status
= regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ regnum
, &val
);
308 if (status
== REG_VALID
)
309 status
= regcache_raw_read_unsigned (regcache
, S390_R0_UPPER_REGNUM
+ regnum
,
311 if (status
== REG_VALID
)
313 val
|= val_upper
<< 32;
314 store_unsigned_integer (buf
, regsize
, byte_order
, val
);
319 internal_error (__FILE__
, __LINE__
, _("invalid regnum"));
323 s390_pseudo_register_write (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
324 int regnum
, const gdb_byte
*buf
)
326 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
327 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
328 int regsize
= register_size (gdbarch
, regnum
);
331 if (regnum
== tdep
->pc_regnum
)
333 val
= extract_unsigned_integer (buf
, regsize
, byte_order
);
334 if (register_size (gdbarch
, S390_PSWA_REGNUM
) == 4)
336 regcache_raw_read_unsigned (regcache
, S390_PSWA_REGNUM
, &psw
);
337 val
= (psw
& 0x80000000) | (val
& 0x7fffffff);
339 regcache_raw_write_unsigned (regcache
, S390_PSWA_REGNUM
, val
);
343 if (regnum
== tdep
->cc_regnum
)
345 val
= extract_unsigned_integer (buf
, regsize
, byte_order
);
346 regcache_raw_read_unsigned (regcache
, S390_PSWM_REGNUM
, &psw
);
347 if (register_size (gdbarch
, S390_PSWA_REGNUM
) == 4)
348 val
= (psw
& ~((ULONGEST
)3 << 12)) | ((val
& 3) << 12);
350 val
= (psw
& ~((ULONGEST
)3 << 44)) | ((val
& 3) << 44);
351 regcache_raw_write_unsigned (regcache
, S390_PSWM_REGNUM
, val
);
355 if (tdep
->gpr_full_regnum
!= -1
356 && regnum
>= tdep
->gpr_full_regnum
357 && regnum
< tdep
->gpr_full_regnum
+ 16)
359 regnum
-= tdep
->gpr_full_regnum
;
360 val
= extract_unsigned_integer (buf
, regsize
, byte_order
);
361 regcache_raw_write_unsigned (regcache
, S390_R0_REGNUM
+ regnum
,
363 regcache_raw_write_unsigned (regcache
, S390_R0_UPPER_REGNUM
+ regnum
,
368 internal_error (__FILE__
, __LINE__
, _("invalid regnum"));
371 /* 'float' values are stored in the upper half of floating-point
372 registers, even though we are otherwise a big-endian platform. */
374 static struct value
*
375 s390_value_from_register (struct type
*type
, int regnum
,
376 struct frame_info
*frame
)
378 struct value
*value
= default_value_from_register (type
, regnum
, frame
);
380 check_typedef (type
);
382 if (regnum
>= S390_F0_REGNUM
&& regnum
<= S390_F15_REGNUM
383 && TYPE_LENGTH (type
) < 8)
384 set_value_offset (value
, 0);
389 /* Register groups. */
392 s390_pseudo_register_reggroup_p (struct gdbarch
*gdbarch
, int regnum
,
393 struct reggroup
*group
)
395 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
397 /* We usually save/restore the whole PSW, which includes PC and CC.
398 However, some older gdbservers may not support saving/restoring
399 the whole PSW yet, and will return an XML register description
400 excluding those from the save/restore register groups. In those
401 cases, we still need to explicitly save/restore PC and CC in order
402 to push or pop frames. Since this doesn't hurt anything if we
403 already save/restore the whole PSW (it's just redundant), we add
404 PC and CC at this point unconditionally. */
405 if (group
== save_reggroup
|| group
== restore_reggroup
)
406 return regnum
== tdep
->pc_regnum
|| regnum
== tdep
->cc_regnum
;
408 return default_register_reggroup_p (gdbarch
, regnum
, group
);
412 /* Core file register sets. */
414 int s390_regmap_gregset
[S390_NUM_REGS
] =
416 /* Program Status Word. */
418 /* General Purpose Registers. */
419 0x08, 0x0c, 0x10, 0x14,
420 0x18, 0x1c, 0x20, 0x24,
421 0x28, 0x2c, 0x30, 0x34,
422 0x38, 0x3c, 0x40, 0x44,
423 /* Access Registers. */
424 0x48, 0x4c, 0x50, 0x54,
425 0x58, 0x5c, 0x60, 0x64,
426 0x68, 0x6c, 0x70, 0x74,
427 0x78, 0x7c, 0x80, 0x84,
428 /* Floating Point Control Word. */
430 /* Floating Point Registers. */
431 -1, -1, -1, -1, -1, -1, -1, -1,
432 -1, -1, -1, -1, -1, -1, -1, -1,
433 /* GPR Uppper Halves. */
434 -1, -1, -1, -1, -1, -1, -1, -1,
435 -1, -1, -1, -1, -1, -1, -1, -1,
436 /* GNU/Linux-specific optional "registers". */
440 int s390x_regmap_gregset
[S390_NUM_REGS
] =
442 /* Program Status Word. */
444 /* General Purpose Registers. */
445 0x10, 0x18, 0x20, 0x28,
446 0x30, 0x38, 0x40, 0x48,
447 0x50, 0x58, 0x60, 0x68,
448 0x70, 0x78, 0x80, 0x88,
449 /* Access Registers. */
450 0x90, 0x94, 0x98, 0x9c,
451 0xa0, 0xa4, 0xa8, 0xac,
452 0xb0, 0xb4, 0xb8, 0xbc,
453 0xc0, 0xc4, 0xc8, 0xcc,
454 /* Floating Point Control Word. */
456 /* Floating Point Registers. */
457 -1, -1, -1, -1, -1, -1, -1, -1,
458 -1, -1, -1, -1, -1, -1, -1, -1,
459 /* GPR Uppper Halves. */
460 0x10, 0x18, 0x20, 0x28,
461 0x30, 0x38, 0x40, 0x48,
462 0x50, 0x58, 0x60, 0x68,
463 0x70, 0x78, 0x80, 0x88,
464 /* GNU/Linux-specific optional "registers". */
468 int s390_regmap_fpregset
[S390_NUM_REGS
] =
470 /* Program Status Word. */
472 /* General Purpose Registers. */
473 -1, -1, -1, -1, -1, -1, -1, -1,
474 -1, -1, -1, -1, -1, -1, -1, -1,
475 /* Access Registers. */
476 -1, -1, -1, -1, -1, -1, -1, -1,
477 -1, -1, -1, -1, -1, -1, -1, -1,
478 /* Floating Point Control Word. */
480 /* Floating Point Registers. */
481 0x08, 0x10, 0x18, 0x20,
482 0x28, 0x30, 0x38, 0x40,
483 0x48, 0x50, 0x58, 0x60,
484 0x68, 0x70, 0x78, 0x80,
485 /* GPR Uppper Halves. */
486 -1, -1, -1, -1, -1, -1, -1, -1,
487 -1, -1, -1, -1, -1, -1, -1, -1,
488 /* GNU/Linux-specific optional "registers". */
492 int s390_regmap_upper
[S390_NUM_REGS
] =
494 /* Program Status Word. */
496 /* General Purpose Registers. */
497 -1, -1, -1, -1, -1, -1, -1, -1,
498 -1, -1, -1, -1, -1, -1, -1, -1,
499 /* Access Registers. */
500 -1, -1, -1, -1, -1, -1, -1, -1,
501 -1, -1, -1, -1, -1, -1, -1, -1,
502 /* Floating Point Control Word. */
504 /* Floating Point Registers. */
505 -1, -1, -1, -1, -1, -1, -1, -1,
506 -1, -1, -1, -1, -1, -1, -1, -1,
507 /* GPR Uppper Halves. */
508 0x00, 0x04, 0x08, 0x0c,
509 0x10, 0x14, 0x18, 0x1c,
510 0x20, 0x24, 0x28, 0x2c,
511 0x30, 0x34, 0x38, 0x3c,
512 /* GNU/Linux-specific optional "registers". */
516 int s390_regmap_last_break
[S390_NUM_REGS
] =
518 /* Program Status Word. */
520 /* General Purpose Registers. */
521 -1, -1, -1, -1, -1, -1, -1, -1,
522 -1, -1, -1, -1, -1, -1, -1, -1,
523 /* Access Registers. */
524 -1, -1, -1, -1, -1, -1, -1, -1,
525 -1, -1, -1, -1, -1, -1, -1, -1,
526 /* Floating Point Control Word. */
528 /* Floating Point Registers. */
529 -1, -1, -1, -1, -1, -1, -1, -1,
530 -1, -1, -1, -1, -1, -1, -1, -1,
531 /* GPR Uppper Halves. */
532 -1, -1, -1, -1, -1, -1, -1, -1,
533 -1, -1, -1, -1, -1, -1, -1, -1,
534 /* GNU/Linux-specific optional "registers". */
538 int s390x_regmap_last_break
[S390_NUM_REGS
] =
540 /* Program Status Word. */
542 /* General Purpose Registers. */
543 -1, -1, -1, -1, -1, -1, -1, -1,
544 -1, -1, -1, -1, -1, -1, -1, -1,
545 /* Access Registers. */
546 -1, -1, -1, -1, -1, -1, -1, -1,
547 -1, -1, -1, -1, -1, -1, -1, -1,
548 /* Floating Point Control Word. */
550 /* Floating Point Registers. */
551 -1, -1, -1, -1, -1, -1, -1, -1,
552 -1, -1, -1, -1, -1, -1, -1, -1,
553 /* GPR Uppper Halves. */
554 -1, -1, -1, -1, -1, -1, -1, -1,
555 -1, -1, -1, -1, -1, -1, -1, -1,
556 /* GNU/Linux-specific optional "registers". */
560 int s390_regmap_system_call
[S390_NUM_REGS
] =
562 /* Program Status Word. */
564 /* General Purpose Registers. */
565 -1, -1, -1, -1, -1, -1, -1, -1,
566 -1, -1, -1, -1, -1, -1, -1, -1,
567 /* Access Registers. */
568 -1, -1, -1, -1, -1, -1, -1, -1,
569 -1, -1, -1, -1, -1, -1, -1, -1,
570 /* Floating Point Control Word. */
572 /* Floating Point Registers. */
573 -1, -1, -1, -1, -1, -1, -1, -1,
574 -1, -1, -1, -1, -1, -1, -1, -1,
575 /* GPR Uppper Halves. */
576 -1, -1, -1, -1, -1, -1, -1, -1,
577 -1, -1, -1, -1, -1, -1, -1, -1,
578 /* GNU/Linux-specific optional "registers". */
582 /* Supply register REGNUM from the register set REGSET to register cache
583 REGCACHE. If REGNUM is -1, do this for all registers in REGSET. */
585 s390_supply_regset (const struct regset
*regset
, struct regcache
*regcache
,
586 int regnum
, const void *regs
, size_t len
)
588 const int *offset
= regset
->descr
;
591 for (i
= 0; i
< S390_NUM_REGS
; i
++)
593 if ((regnum
== i
|| regnum
== -1) && offset
[i
] != -1)
594 regcache_raw_supply (regcache
, i
, (const char *)regs
+ offset
[i
]);
598 /* Collect register REGNUM from the register cache REGCACHE and store
599 it in the buffer specified by REGS and LEN as described by the
600 general-purpose register set REGSET. If REGNUM is -1, do this for
601 all registers in REGSET. */
603 s390_collect_regset (const struct regset
*regset
,
604 const struct regcache
*regcache
,
605 int regnum
, void *regs
, size_t len
)
607 const int *offset
= regset
->descr
;
610 for (i
= 0; i
< S390_NUM_REGS
; i
++)
612 if ((regnum
== i
|| regnum
== -1) && offset
[i
] != -1)
613 regcache_raw_collect (regcache
, i
, (char *)regs
+ offset
[i
]);
617 static const struct regset s390_gregset
= {
623 static const struct regset s390x_gregset
= {
624 s390x_regmap_gregset
,
629 static const struct regset s390_fpregset
= {
630 s390_regmap_fpregset
,
635 static const struct regset s390_upper_regset
= {
641 static const struct regset s390_last_break_regset
= {
642 s390_regmap_last_break
,
647 static const struct regset s390x_last_break_regset
= {
648 s390x_regmap_last_break
,
653 static const struct regset s390_system_call_regset
= {
654 s390_regmap_system_call
,
659 static struct core_regset_section s390_linux32_regset_sections
[] =
661 { ".reg", s390_sizeof_gregset
, "general-purpose" },
662 { ".reg2", s390_sizeof_fpregset
, "floating-point" },
666 static struct core_regset_section s390_linux32v1_regset_sections
[] =
668 { ".reg", s390_sizeof_gregset
, "general-purpose" },
669 { ".reg2", s390_sizeof_fpregset
, "floating-point" },
670 { ".reg-s390-last-break", 8, "s390 last-break address" },
674 static struct core_regset_section s390_linux32v2_regset_sections
[] =
676 { ".reg", s390_sizeof_gregset
, "general-purpose" },
677 { ".reg2", s390_sizeof_fpregset
, "floating-point" },
678 { ".reg-s390-last-break", 8, "s390 last-break address" },
679 { ".reg-s390-system-call", 4, "s390 system-call" },
683 static struct core_regset_section s390_linux64_regset_sections
[] =
685 { ".reg", s390_sizeof_gregset
, "general-purpose" },
686 { ".reg2", s390_sizeof_fpregset
, "floating-point" },
687 { ".reg-s390-high-gprs", 16*4, "s390 GPR upper halves" },
691 static struct core_regset_section s390_linux64v1_regset_sections
[] =
693 { ".reg", s390_sizeof_gregset
, "general-purpose" },
694 { ".reg2", s390_sizeof_fpregset
, "floating-point" },
695 { ".reg-s390-high-gprs", 16*4, "s390 GPR upper halves" },
696 { ".reg-s390-last-break", 8, "s930 last-break address" },
700 static struct core_regset_section s390_linux64v2_regset_sections
[] =
702 { ".reg", s390_sizeof_gregset
, "general-purpose" },
703 { ".reg2", s390_sizeof_fpregset
, "floating-point" },
704 { ".reg-s390-high-gprs", 16*4, "s390 GPR upper halves" },
705 { ".reg-s390-last-break", 8, "s930 last-break address" },
706 { ".reg-s390-system-call", 4, "s390 system-call" },
710 static struct core_regset_section s390x_linux64_regset_sections
[] =
712 { ".reg", s390x_sizeof_gregset
, "general-purpose" },
713 { ".reg2", s390_sizeof_fpregset
, "floating-point" },
717 static struct core_regset_section s390x_linux64v1_regset_sections
[] =
719 { ".reg", s390x_sizeof_gregset
, "general-purpose" },
720 { ".reg2", s390_sizeof_fpregset
, "floating-point" },
721 { ".reg-s390-last-break", 8, "s930 last-break address" },
725 static struct core_regset_section s390x_linux64v2_regset_sections
[] =
727 { ".reg", s390x_sizeof_gregset
, "general-purpose" },
728 { ".reg2", s390_sizeof_fpregset
, "floating-point" },
729 { ".reg-s390-last-break", 8, "s930 last-break address" },
730 { ".reg-s390-system-call", 4, "s390 system-call" },
735 /* Return the appropriate register set for the core section identified
736 by SECT_NAME and SECT_SIZE. */
737 static const struct regset
*
738 s390_regset_from_core_section (struct gdbarch
*gdbarch
,
739 const char *sect_name
, size_t sect_size
)
741 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
743 if (strcmp (sect_name
, ".reg") == 0 && sect_size
>= tdep
->sizeof_gregset
)
744 return tdep
->gregset
;
746 if (strcmp (sect_name
, ".reg2") == 0 && sect_size
>= tdep
->sizeof_fpregset
)
747 return tdep
->fpregset
;
749 if (strcmp (sect_name
, ".reg-s390-high-gprs") == 0 && sect_size
>= 16*4)
750 return &s390_upper_regset
;
752 if (strcmp (sect_name
, ".reg-s390-last-break") == 0 && sect_size
>= 8)
753 return (gdbarch_ptr_bit (gdbarch
) == 32
754 ? &s390_last_break_regset
: &s390x_last_break_regset
);
756 if (strcmp (sect_name
, ".reg-s390-system-call") == 0 && sect_size
>= 4)
757 return &s390_system_call_regset
;
762 static const struct target_desc
*
763 s390_core_read_description (struct gdbarch
*gdbarch
,
764 struct target_ops
*target
, bfd
*abfd
)
766 asection
*high_gprs
= bfd_get_section_by_name (abfd
, ".reg-s390-high-gprs");
767 asection
*v1
= bfd_get_section_by_name (abfd
, ".reg-s390-last-break");
768 asection
*v2
= bfd_get_section_by_name (abfd
, ".reg-s390-system-call");
769 asection
*section
= bfd_get_section_by_name (abfd
, ".reg");
773 switch (bfd_section_size (abfd
, section
))
775 case s390_sizeof_gregset
:
777 return (v2
? tdesc_s390_linux64v2
:
778 v1
? tdesc_s390_linux64v1
: tdesc_s390_linux64
);
780 return (v2
? tdesc_s390_linux32v2
:
781 v1
? tdesc_s390_linux32v1
: tdesc_s390_linux32
);
783 case s390x_sizeof_gregset
:
784 return (v2
? tdesc_s390x_linux64v2
:
785 v1
? tdesc_s390x_linux64v1
: tdesc_s390x_linux64
);
793 /* Decoding S/390 instructions. */
795 /* Named opcode values for the S/390 instructions we recognize. Some
796 instructions have their opcode split across two fields; those are the
797 op1_* and op2_* enums. */
800 op1_lhi
= 0xa7, op2_lhi
= 0x08,
801 op1_lghi
= 0xa7, op2_lghi
= 0x09,
802 op1_lgfi
= 0xc0, op2_lgfi
= 0x01,
806 op1_ly
= 0xe3, op2_ly
= 0x58,
807 op1_lg
= 0xe3, op2_lg
= 0x04,
809 op1_lmy
= 0xeb, op2_lmy
= 0x98,
810 op1_lmg
= 0xeb, op2_lmg
= 0x04,
812 op1_sty
= 0xe3, op2_sty
= 0x50,
813 op1_stg
= 0xe3, op2_stg
= 0x24,
816 op1_stmy
= 0xeb, op2_stmy
= 0x90,
817 op1_stmg
= 0xeb, op2_stmg
= 0x24,
818 op1_aghi
= 0xa7, op2_aghi
= 0x0b,
819 op1_ahi
= 0xa7, op2_ahi
= 0x0a,
820 op1_agfi
= 0xc2, op2_agfi
= 0x08,
821 op1_afi
= 0xc2, op2_afi
= 0x09,
822 op1_algfi
= 0xc2, op2_algfi
= 0x0a,
823 op1_alfi
= 0xc2, op2_alfi
= 0x0b,
827 op1_ay
= 0xe3, op2_ay
= 0x5a,
828 op1_ag
= 0xe3, op2_ag
= 0x08,
829 op1_slgfi
= 0xc2, op2_slgfi
= 0x04,
830 op1_slfi
= 0xc2, op2_slfi
= 0x05,
834 op1_sy
= 0xe3, op2_sy
= 0x5b,
835 op1_sg
= 0xe3, op2_sg
= 0x09,
839 op1_lay
= 0xe3, op2_lay
= 0x71,
840 op1_larl
= 0xc0, op2_larl
= 0x00,
848 op1_bctg
= 0xe3, op2_bctg
= 0x46,
850 op1_bxhg
= 0xeb, op2_bxhg
= 0x44,
852 op1_bxleg
= 0xeb, op2_bxleg
= 0x45,
853 op1_bras
= 0xa7, op2_bras
= 0x05,
854 op1_brasl
= 0xc0, op2_brasl
= 0x05,
855 op1_brc
= 0xa7, op2_brc
= 0x04,
856 op1_brcl
= 0xc0, op2_brcl
= 0x04,
857 op1_brct
= 0xa7, op2_brct
= 0x06,
858 op1_brctg
= 0xa7, op2_brctg
= 0x07,
860 op1_brxhg
= 0xec, op2_brxhg
= 0x44,
862 op1_brxlg
= 0xec, op2_brxlg
= 0x45,
866 /* Read a single instruction from address AT. */
868 #define S390_MAX_INSTR_SIZE 6
870 s390_readinstruction (bfd_byte instr
[], CORE_ADDR at
)
872 static int s390_instrlen
[] = { 2, 4, 4, 6 };
875 if (target_read_memory (at
, &instr
[0], 2))
877 instrlen
= s390_instrlen
[instr
[0] >> 6];
880 if (target_read_memory (at
+ 2, &instr
[2], instrlen
- 2))
887 /* The functions below are for recognizing and decoding S/390
888 instructions of various formats. Each of them checks whether INSN
889 is an instruction of the given format, with the specified opcodes.
890 If it is, it sets the remaining arguments to the values of the
891 instruction's fields, and returns a non-zero value; otherwise, it
894 These functions' arguments appear in the order they appear in the
895 instruction, not in the machine-language form. So, opcodes always
896 come first, even though they're sometimes scattered around the
897 instructions. And displacements appear before base and extension
898 registers, as they do in the assembly syntax, not at the end, as
899 they do in the machine language. */
901 is_ri (bfd_byte
*insn
, int op1
, int op2
, unsigned int *r1
, int *i2
)
903 if (insn
[0] == op1
&& (insn
[1] & 0xf) == op2
)
905 *r1
= (insn
[1] >> 4) & 0xf;
906 /* i2 is a 16-bit signed quantity. */
907 *i2
= (((insn
[2] << 8) | insn
[3]) ^ 0x8000) - 0x8000;
916 is_ril (bfd_byte
*insn
, int op1
, int op2
,
917 unsigned int *r1
, int *i2
)
919 if (insn
[0] == op1
&& (insn
[1] & 0xf) == op2
)
921 *r1
= (insn
[1] >> 4) & 0xf;
922 /* i2 is a signed quantity. If the host 'int' is 32 bits long,
923 no sign extension is necessary, but we don't want to assume
925 *i2
= (((insn
[2] << 24)
928 | (insn
[5])) ^ 0x80000000) - 0x80000000;
937 is_rr (bfd_byte
*insn
, int op
, unsigned int *r1
, unsigned int *r2
)
941 *r1
= (insn
[1] >> 4) & 0xf;
951 is_rre (bfd_byte
*insn
, int op
, unsigned int *r1
, unsigned int *r2
)
953 if (((insn
[0] << 8) | insn
[1]) == op
)
955 /* Yes, insn[3]. insn[2] is unused in RRE format. */
956 *r1
= (insn
[3] >> 4) & 0xf;
966 is_rs (bfd_byte
*insn
, int op
,
967 unsigned int *r1
, unsigned int *r3
, unsigned int *d2
, unsigned int *b2
)
971 *r1
= (insn
[1] >> 4) & 0xf;
973 *b2
= (insn
[2] >> 4) & 0xf;
974 *d2
= ((insn
[2] & 0xf) << 8) | insn
[3];
983 is_rsy (bfd_byte
*insn
, int op1
, int op2
,
984 unsigned int *r1
, unsigned int *r3
, unsigned int *d2
, unsigned int *b2
)
989 *r1
= (insn
[1] >> 4) & 0xf;
991 *b2
= (insn
[2] >> 4) & 0xf;
992 /* The 'long displacement' is a 20-bit signed integer. */
993 *d2
= ((((insn
[2] & 0xf) << 8) | insn
[3] | (insn
[4] << 12))
994 ^ 0x80000) - 0x80000;
1003 is_rsi (bfd_byte
*insn
, int op
,
1004 unsigned int *r1
, unsigned int *r3
, int *i2
)
1008 *r1
= (insn
[1] >> 4) & 0xf;
1009 *r3
= insn
[1] & 0xf;
1010 /* i2 is a 16-bit signed quantity. */
1011 *i2
= (((insn
[2] << 8) | insn
[3]) ^ 0x8000) - 0x8000;
1020 is_rie (bfd_byte
*insn
, int op1
, int op2
,
1021 unsigned int *r1
, unsigned int *r3
, int *i2
)
1026 *r1
= (insn
[1] >> 4) & 0xf;
1027 *r3
= insn
[1] & 0xf;
1028 /* i2 is a 16-bit signed quantity. */
1029 *i2
= (((insn
[2] << 8) | insn
[3]) ^ 0x8000) - 0x8000;
1038 is_rx (bfd_byte
*insn
, int op
,
1039 unsigned int *r1
, unsigned int *d2
, unsigned int *x2
, unsigned int *b2
)
1043 *r1
= (insn
[1] >> 4) & 0xf;
1044 *x2
= insn
[1] & 0xf;
1045 *b2
= (insn
[2] >> 4) & 0xf;
1046 *d2
= ((insn
[2] & 0xf) << 8) | insn
[3];
1055 is_rxy (bfd_byte
*insn
, int op1
, int op2
,
1056 unsigned int *r1
, unsigned int *d2
, unsigned int *x2
, unsigned int *b2
)
1061 *r1
= (insn
[1] >> 4) & 0xf;
1062 *x2
= insn
[1] & 0xf;
1063 *b2
= (insn
[2] >> 4) & 0xf;
1064 /* The 'long displacement' is a 20-bit signed integer. */
1065 *d2
= ((((insn
[2] & 0xf) << 8) | insn
[3] | (insn
[4] << 12))
1066 ^ 0x80000) - 0x80000;
1074 /* Prologue analysis. */
1076 #define S390_NUM_GPRS 16
1077 #define S390_NUM_FPRS 16
1079 struct s390_prologue_data
{
1082 struct pv_area
*stack
;
1084 /* The size and byte-order of a GPR or FPR. */
1087 enum bfd_endian byte_order
;
1089 /* The general-purpose registers. */
1090 pv_t gpr
[S390_NUM_GPRS
];
1092 /* The floating-point registers. */
1093 pv_t fpr
[S390_NUM_FPRS
];
1095 /* The offset relative to the CFA where the incoming GPR N was saved
1096 by the function prologue. 0 if not saved or unknown. */
1097 int gpr_slot
[S390_NUM_GPRS
];
1099 /* Likewise for FPRs. */
1100 int fpr_slot
[S390_NUM_FPRS
];
1102 /* Nonzero if the backchain was saved. This is assumed to be the
1103 case when the incoming SP is saved at the current SP location. */
1104 int back_chain_saved_p
;
1107 /* Return the effective address for an X-style instruction, like:
1111 Here, X2 and B2 are registers, and D2 is a signed 20-bit
1112 constant; the effective address is the sum of all three. If either
1113 X2 or B2 are zero, then it doesn't contribute to the sum --- this
1114 means that r0 can't be used as either X2 or B2. */
1116 s390_addr (struct s390_prologue_data
*data
,
1117 int d2
, unsigned int x2
, unsigned int b2
)
1121 result
= pv_constant (d2
);
1123 result
= pv_add (result
, data
->gpr
[x2
]);
1125 result
= pv_add (result
, data
->gpr
[b2
]);
1130 /* Do a SIZE-byte store of VALUE to D2(X2,B2). */
1132 s390_store (struct s390_prologue_data
*data
,
1133 int d2
, unsigned int x2
, unsigned int b2
, CORE_ADDR size
,
1136 pv_t addr
= s390_addr (data
, d2
, x2
, b2
);
1139 /* Check whether we are storing the backchain. */
1140 offset
= pv_subtract (data
->gpr
[S390_SP_REGNUM
- S390_R0_REGNUM
], addr
);
1142 if (pv_is_constant (offset
) && offset
.k
== 0)
1143 if (size
== data
->gpr_size
1144 && pv_is_register_k (value
, S390_SP_REGNUM
, 0))
1146 data
->back_chain_saved_p
= 1;
1151 /* Check whether we are storing a register into the stack. */
1152 if (!pv_area_store_would_trash (data
->stack
, addr
))
1153 pv_area_store (data
->stack
, addr
, size
, value
);
1156 /* Note: If this is some store we cannot identify, you might think we
1157 should forget our cached values, as any of those might have been hit.
1159 However, we make the assumption that the register save areas are only
1160 ever stored to once in any given function, and we do recognize these
1161 stores. Thus every store we cannot recognize does not hit our data. */
1164 /* Do a SIZE-byte load from D2(X2,B2). */
1166 s390_load (struct s390_prologue_data
*data
,
1167 int d2
, unsigned int x2
, unsigned int b2
, CORE_ADDR size
)
1170 pv_t addr
= s390_addr (data
, d2
, x2
, b2
);
1172 /* If it's a load from an in-line constant pool, then we can
1173 simulate that, under the assumption that the code isn't
1174 going to change between the time the processor actually
1175 executed it creating the current frame, and the time when
1176 we're analyzing the code to unwind past that frame. */
1177 if (pv_is_constant (addr
))
1179 struct target_section
*secp
;
1180 secp
= target_section_by_addr (¤t_target
, addr
.k
);
1182 && (bfd_get_section_flags (secp
->bfd
, secp
->the_bfd_section
)
1184 return pv_constant (read_memory_integer (addr
.k
, size
,
1188 /* Check whether we are accessing one of our save slots. */
1189 return pv_area_fetch (data
->stack
, addr
, size
);
1192 /* Function for finding saved registers in a 'struct pv_area'; we pass
1193 this to pv_area_scan.
1195 If VALUE is a saved register, ADDR says it was saved at a constant
1196 offset from the frame base, and SIZE indicates that the whole
1197 register was saved, record its offset in the reg_offset table in
1198 PROLOGUE_UNTYPED. */
1200 s390_check_for_saved (void *data_untyped
, pv_t addr
,
1201 CORE_ADDR size
, pv_t value
)
1203 struct s390_prologue_data
*data
= data_untyped
;
1206 if (!pv_is_register (addr
, S390_SP_REGNUM
))
1209 offset
= 16 * data
->gpr_size
+ 32 - addr
.k
;
1211 /* If we are storing the original value of a register, we want to
1212 record the CFA offset. If the same register is stored multiple
1213 times, the stack slot with the highest address counts. */
1215 for (i
= 0; i
< S390_NUM_GPRS
; i
++)
1216 if (size
== data
->gpr_size
1217 && pv_is_register_k (value
, S390_R0_REGNUM
+ i
, 0))
1218 if (data
->gpr_slot
[i
] == 0
1219 || data
->gpr_slot
[i
] > offset
)
1221 data
->gpr_slot
[i
] = offset
;
1225 for (i
= 0; i
< S390_NUM_FPRS
; i
++)
1226 if (size
== data
->fpr_size
1227 && pv_is_register_k (value
, S390_F0_REGNUM
+ i
, 0))
1228 if (data
->fpr_slot
[i
] == 0
1229 || data
->fpr_slot
[i
] > offset
)
1231 data
->fpr_slot
[i
] = offset
;
1236 /* Analyze the prologue of the function starting at START_PC,
1237 continuing at most until CURRENT_PC. Initialize DATA to
1238 hold all information we find out about the state of the registers
1239 and stack slots. Return the address of the instruction after
1240 the last one that changed the SP, FP, or back chain; or zero
1243 s390_analyze_prologue (struct gdbarch
*gdbarch
,
1245 CORE_ADDR current_pc
,
1246 struct s390_prologue_data
*data
)
1248 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
1250 /* Our return value:
1251 The address of the instruction after the last one that changed
1252 the SP, FP, or back chain; zero if we got an error trying to
1254 CORE_ADDR result
= start_pc
;
1256 /* The current PC for our abstract interpretation. */
1259 /* The address of the next instruction after that. */
1262 /* Set up everything's initial value. */
1266 data
->stack
= make_pv_area (S390_SP_REGNUM
, gdbarch_addr_bit (gdbarch
));
1268 /* For the purpose of prologue tracking, we consider the GPR size to
1269 be equal to the ABI word size, even if it is actually larger
1270 (i.e. when running a 32-bit binary under a 64-bit kernel). */
1271 data
->gpr_size
= word_size
;
1273 data
->byte_order
= gdbarch_byte_order (gdbarch
);
1275 for (i
= 0; i
< S390_NUM_GPRS
; i
++)
1276 data
->gpr
[i
] = pv_register (S390_R0_REGNUM
+ i
, 0);
1278 for (i
= 0; i
< S390_NUM_FPRS
; i
++)
1279 data
->fpr
[i
] = pv_register (S390_F0_REGNUM
+ i
, 0);
1281 for (i
= 0; i
< S390_NUM_GPRS
; i
++)
1282 data
->gpr_slot
[i
] = 0;
1284 for (i
= 0; i
< S390_NUM_FPRS
; i
++)
1285 data
->fpr_slot
[i
] = 0;
1287 data
->back_chain_saved_p
= 0;
1290 /* Start interpreting instructions, until we hit the frame's
1291 current PC or the first branch instruction. */
1292 for (pc
= start_pc
; pc
> 0 && pc
< current_pc
; pc
= next_pc
)
1294 bfd_byte insn
[S390_MAX_INSTR_SIZE
];
1295 int insn_len
= s390_readinstruction (insn
, pc
);
1297 bfd_byte dummy
[S390_MAX_INSTR_SIZE
] = { 0 };
1298 bfd_byte
*insn32
= word_size
== 4 ? insn
: dummy
;
1299 bfd_byte
*insn64
= word_size
== 8 ? insn
: dummy
;
1301 /* Fields for various kinds of instructions. */
1302 unsigned int b2
, r1
, r2
, x2
, r3
;
1305 /* The values of SP and FP before this instruction,
1306 for detecting instructions that change them. */
1307 pv_t pre_insn_sp
, pre_insn_fp
;
1308 /* Likewise for the flag whether the back chain was saved. */
1309 int pre_insn_back_chain_saved_p
;
1311 /* If we got an error trying to read the instruction, report it. */
1318 next_pc
= pc
+ insn_len
;
1320 pre_insn_sp
= data
->gpr
[S390_SP_REGNUM
- S390_R0_REGNUM
];
1321 pre_insn_fp
= data
->gpr
[S390_FRAME_REGNUM
- S390_R0_REGNUM
];
1322 pre_insn_back_chain_saved_p
= data
->back_chain_saved_p
;
1325 /* LHI r1, i2 --- load halfword immediate. */
1326 /* LGHI r1, i2 --- load halfword immediate (64-bit version). */
1327 /* LGFI r1, i2 --- load fullword immediate. */
1328 if (is_ri (insn32
, op1_lhi
, op2_lhi
, &r1
, &i2
)
1329 || is_ri (insn64
, op1_lghi
, op2_lghi
, &r1
, &i2
)
1330 || is_ril (insn
, op1_lgfi
, op2_lgfi
, &r1
, &i2
))
1331 data
->gpr
[r1
] = pv_constant (i2
);
1333 /* LR r1, r2 --- load from register. */
1334 /* LGR r1, r2 --- load from register (64-bit version). */
1335 else if (is_rr (insn32
, op_lr
, &r1
, &r2
)
1336 || is_rre (insn64
, op_lgr
, &r1
, &r2
))
1337 data
->gpr
[r1
] = data
->gpr
[r2
];
1339 /* L r1, d2(x2, b2) --- load. */
1340 /* LY r1, d2(x2, b2) --- load (long-displacement version). */
1341 /* LG r1, d2(x2, b2) --- load (64-bit version). */
1342 else if (is_rx (insn32
, op_l
, &r1
, &d2
, &x2
, &b2
)
1343 || is_rxy (insn32
, op1_ly
, op2_ly
, &r1
, &d2
, &x2
, &b2
)
1344 || is_rxy (insn64
, op1_lg
, op2_lg
, &r1
, &d2
, &x2
, &b2
))
1345 data
->gpr
[r1
] = s390_load (data
, d2
, x2
, b2
, data
->gpr_size
);
1347 /* ST r1, d2(x2, b2) --- store. */
1348 /* STY r1, d2(x2, b2) --- store (long-displacement version). */
1349 /* STG r1, d2(x2, b2) --- store (64-bit version). */
1350 else if (is_rx (insn32
, op_st
, &r1
, &d2
, &x2
, &b2
)
1351 || is_rxy (insn32
, op1_sty
, op2_sty
, &r1
, &d2
, &x2
, &b2
)
1352 || is_rxy (insn64
, op1_stg
, op2_stg
, &r1
, &d2
, &x2
, &b2
))
1353 s390_store (data
, d2
, x2
, b2
, data
->gpr_size
, data
->gpr
[r1
]);
1355 /* STD r1, d2(x2,b2) --- store floating-point register. */
1356 else if (is_rx (insn
, op_std
, &r1
, &d2
, &x2
, &b2
))
1357 s390_store (data
, d2
, x2
, b2
, data
->fpr_size
, data
->fpr
[r1
]);
1359 /* STM r1, r3, d2(b2) --- store multiple. */
1360 /* STMY r1, r3, d2(b2) --- store multiple (long-displacement
1362 /* STMG r1, r3, d2(b2) --- store multiple (64-bit version). */
1363 else if (is_rs (insn32
, op_stm
, &r1
, &r3
, &d2
, &b2
)
1364 || is_rsy (insn32
, op1_stmy
, op2_stmy
, &r1
, &r3
, &d2
, &b2
)
1365 || is_rsy (insn64
, op1_stmg
, op2_stmg
, &r1
, &r3
, &d2
, &b2
))
1367 for (; r1
<= r3
; r1
++, d2
+= data
->gpr_size
)
1368 s390_store (data
, d2
, 0, b2
, data
->gpr_size
, data
->gpr
[r1
]);
1371 /* AHI r1, i2 --- add halfword immediate. */
1372 /* AGHI r1, i2 --- add halfword immediate (64-bit version). */
1373 /* AFI r1, i2 --- add fullword immediate. */
1374 /* AGFI r1, i2 --- add fullword immediate (64-bit version). */
1375 else if (is_ri (insn32
, op1_ahi
, op2_ahi
, &r1
, &i2
)
1376 || is_ri (insn64
, op1_aghi
, op2_aghi
, &r1
, &i2
)
1377 || is_ril (insn32
, op1_afi
, op2_afi
, &r1
, &i2
)
1378 || is_ril (insn64
, op1_agfi
, op2_agfi
, &r1
, &i2
))
1379 data
->gpr
[r1
] = pv_add_constant (data
->gpr
[r1
], i2
);
1381 /* ALFI r1, i2 --- add logical immediate. */
1382 /* ALGFI r1, i2 --- add logical immediate (64-bit version). */
1383 else if (is_ril (insn32
, op1_alfi
, op2_alfi
, &r1
, &i2
)
1384 || is_ril (insn64
, op1_algfi
, op2_algfi
, &r1
, &i2
))
1385 data
->gpr
[r1
] = pv_add_constant (data
->gpr
[r1
],
1386 (CORE_ADDR
)i2
& 0xffffffff);
1388 /* AR r1, r2 -- add register. */
1389 /* AGR r1, r2 -- add register (64-bit version). */
1390 else if (is_rr (insn32
, op_ar
, &r1
, &r2
)
1391 || is_rre (insn64
, op_agr
, &r1
, &r2
))
1392 data
->gpr
[r1
] = pv_add (data
->gpr
[r1
], data
->gpr
[r2
]);
1394 /* A r1, d2(x2, b2) -- add. */
1395 /* AY r1, d2(x2, b2) -- add (long-displacement version). */
1396 /* AG r1, d2(x2, b2) -- add (64-bit version). */
1397 else if (is_rx (insn32
, op_a
, &r1
, &d2
, &x2
, &b2
)
1398 || is_rxy (insn32
, op1_ay
, op2_ay
, &r1
, &d2
, &x2
, &b2
)
1399 || is_rxy (insn64
, op1_ag
, op2_ag
, &r1
, &d2
, &x2
, &b2
))
1400 data
->gpr
[r1
] = pv_add (data
->gpr
[r1
],
1401 s390_load (data
, d2
, x2
, b2
, data
->gpr_size
));
1403 /* SLFI r1, i2 --- subtract logical immediate. */
1404 /* SLGFI r1, i2 --- subtract logical immediate (64-bit version). */
1405 else if (is_ril (insn32
, op1_slfi
, op2_slfi
, &r1
, &i2
)
1406 || is_ril (insn64
, op1_slgfi
, op2_slgfi
, &r1
, &i2
))
1407 data
->gpr
[r1
] = pv_add_constant (data
->gpr
[r1
],
1408 -((CORE_ADDR
)i2
& 0xffffffff));
1410 /* SR r1, r2 -- subtract register. */
1411 /* SGR r1, r2 -- subtract register (64-bit version). */
1412 else if (is_rr (insn32
, op_sr
, &r1
, &r2
)
1413 || is_rre (insn64
, op_sgr
, &r1
, &r2
))
1414 data
->gpr
[r1
] = pv_subtract (data
->gpr
[r1
], data
->gpr
[r2
]);
1416 /* S r1, d2(x2, b2) -- subtract. */
1417 /* SY r1, d2(x2, b2) -- subtract (long-displacement version). */
1418 /* SG r1, d2(x2, b2) -- subtract (64-bit version). */
1419 else if (is_rx (insn32
, op_s
, &r1
, &d2
, &x2
, &b2
)
1420 || is_rxy (insn32
, op1_sy
, op2_sy
, &r1
, &d2
, &x2
, &b2
)
1421 || is_rxy (insn64
, op1_sg
, op2_sg
, &r1
, &d2
, &x2
, &b2
))
1422 data
->gpr
[r1
] = pv_subtract (data
->gpr
[r1
],
1423 s390_load (data
, d2
, x2
, b2
, data
->gpr_size
));
1425 /* LA r1, d2(x2, b2) --- load address. */
1426 /* LAY r1, d2(x2, b2) --- load address (long-displacement version). */
1427 else if (is_rx (insn
, op_la
, &r1
, &d2
, &x2
, &b2
)
1428 || is_rxy (insn
, op1_lay
, op2_lay
, &r1
, &d2
, &x2
, &b2
))
1429 data
->gpr
[r1
] = s390_addr (data
, d2
, x2
, b2
);
1431 /* LARL r1, i2 --- load address relative long. */
1432 else if (is_ril (insn
, op1_larl
, op2_larl
, &r1
, &i2
))
1433 data
->gpr
[r1
] = pv_constant (pc
+ i2
* 2);
1435 /* BASR r1, 0 --- branch and save.
1436 Since r2 is zero, this saves the PC in r1, but doesn't branch. */
1437 else if (is_rr (insn
, op_basr
, &r1
, &r2
)
1439 data
->gpr
[r1
] = pv_constant (next_pc
);
1441 /* BRAS r1, i2 --- branch relative and save. */
1442 else if (is_ri (insn
, op1_bras
, op2_bras
, &r1
, &i2
))
1444 data
->gpr
[r1
] = pv_constant (next_pc
);
1445 next_pc
= pc
+ i2
* 2;
1447 /* We'd better not interpret any backward branches. We'll
1453 /* Terminate search when hitting any other branch instruction. */
1454 else if (is_rr (insn
, op_basr
, &r1
, &r2
)
1455 || is_rx (insn
, op_bas
, &r1
, &d2
, &x2
, &b2
)
1456 || is_rr (insn
, op_bcr
, &r1
, &r2
)
1457 || is_rx (insn
, op_bc
, &r1
, &d2
, &x2
, &b2
)
1458 || is_ri (insn
, op1_brc
, op2_brc
, &r1
, &i2
)
1459 || is_ril (insn
, op1_brcl
, op2_brcl
, &r1
, &i2
)
1460 || is_ril (insn
, op1_brasl
, op2_brasl
, &r2
, &i2
))
1464 /* An instruction we don't know how to simulate. The only
1465 safe thing to do would be to set every value we're tracking
1466 to 'unknown'. Instead, we'll be optimistic: we assume that
1467 we *can* interpret every instruction that the compiler uses
1468 to manipulate any of the data we're interested in here --
1469 then we can just ignore anything else. */
1472 /* Record the address after the last instruction that changed
1473 the FP, SP, or backlink. Ignore instructions that changed
1474 them back to their original values --- those are probably
1475 restore instructions. (The back chain is never restored,
1478 pv_t sp
= data
->gpr
[S390_SP_REGNUM
- S390_R0_REGNUM
];
1479 pv_t fp
= data
->gpr
[S390_FRAME_REGNUM
- S390_R0_REGNUM
];
1481 if ((! pv_is_identical (pre_insn_sp
, sp
)
1482 && ! pv_is_register_k (sp
, S390_SP_REGNUM
, 0)
1483 && sp
.kind
!= pvk_unknown
)
1484 || (! pv_is_identical (pre_insn_fp
, fp
)
1485 && ! pv_is_register_k (fp
, S390_FRAME_REGNUM
, 0)
1486 && fp
.kind
!= pvk_unknown
)
1487 || pre_insn_back_chain_saved_p
!= data
->back_chain_saved_p
)
1492 /* Record where all the registers were saved. */
1493 pv_area_scan (data
->stack
, s390_check_for_saved
, data
);
1495 free_pv_area (data
->stack
);
1501 /* Advance PC across any function entry prologue instructions to reach
1502 some "real" code. */
1504 s390_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
1506 struct s390_prologue_data data
;
1508 skip_pc
= s390_analyze_prologue (gdbarch
, pc
, (CORE_ADDR
)-1, &data
);
1509 return skip_pc
? skip_pc
: pc
;
1512 /* Return true if we are in the functin's epilogue, i.e. after the
1513 instruction that destroyed the function's stack frame. */
1515 s390_in_function_epilogue_p (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
1517 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
1519 /* In frameless functions, there's not frame to destroy and thus
1520 we don't care about the epilogue.
1522 In functions with frame, the epilogue sequence is a pair of
1523 a LM-type instruction that restores (amongst others) the
1524 return register %r14 and the stack pointer %r15, followed
1525 by a branch 'br %r14' --or equivalent-- that effects the
1528 In that situation, this function needs to return 'true' in
1529 exactly one case: when pc points to that branch instruction.
1531 Thus we try to disassemble the one instructions immediately
1532 preceding pc and check whether it is an LM-type instruction
1533 modifying the stack pointer.
1535 Note that disassembling backwards is not reliable, so there
1536 is a slight chance of false positives here ... */
1539 unsigned int r1
, r3
, b2
;
1543 && !target_read_memory (pc
- 4, insn
, 4)
1544 && is_rs (insn
, op_lm
, &r1
, &r3
, &d2
, &b2
)
1545 && r3
== S390_SP_REGNUM
- S390_R0_REGNUM
)
1549 && !target_read_memory (pc
- 6, insn
, 6)
1550 && is_rsy (insn
, op1_lmy
, op2_lmy
, &r1
, &r3
, &d2
, &b2
)
1551 && r3
== S390_SP_REGNUM
- S390_R0_REGNUM
)
1555 && !target_read_memory (pc
- 6, insn
, 6)
1556 && is_rsy (insn
, op1_lmg
, op2_lmg
, &r1
, &r3
, &d2
, &b2
)
1557 && r3
== S390_SP_REGNUM
- S390_R0_REGNUM
)
1563 /* Displaced stepping. */
1565 /* Fix up the state of registers and memory after having single-stepped
1566 a displaced instruction. */
1568 s390_displaced_step_fixup (struct gdbarch
*gdbarch
,
1569 struct displaced_step_closure
*closure
,
1570 CORE_ADDR from
, CORE_ADDR to
,
1571 struct regcache
*regs
)
1573 /* Since we use simple_displaced_step_copy_insn, our closure is a
1574 copy of the instruction. */
1575 gdb_byte
*insn
= (gdb_byte
*) closure
;
1576 static int s390_instrlen
[] = { 2, 4, 4, 6 };
1577 int insnlen
= s390_instrlen
[insn
[0] >> 6];
1579 /* Fields for various kinds of instructions. */
1580 unsigned int b2
, r1
, r2
, x2
, r3
;
1583 /* Get current PC and addressing mode bit. */
1584 CORE_ADDR pc
= regcache_read_pc (regs
);
1587 if (register_size (gdbarch
, S390_PSWA_REGNUM
) == 4)
1589 regcache_cooked_read_unsigned (regs
, S390_PSWA_REGNUM
, &amode
);
1590 amode
&= 0x80000000;
1593 if (debug_displaced
)
1594 fprintf_unfiltered (gdb_stdlog
,
1595 "displaced: (s390) fixup (%s, %s) pc %s len %d amode 0x%x\n",
1596 paddress (gdbarch
, from
), paddress (gdbarch
, to
),
1597 paddress (gdbarch
, pc
), insnlen
, (int) amode
);
1599 /* Handle absolute branch and save instructions. */
1600 if (is_rr (insn
, op_basr
, &r1
, &r2
)
1601 || is_rx (insn
, op_bas
, &r1
, &d2
, &x2
, &b2
))
1603 /* Recompute saved return address in R1. */
1604 regcache_cooked_write_unsigned (regs
, S390_R0_REGNUM
+ r1
,
1605 amode
| (from
+ insnlen
));
1608 /* Handle absolute branch instructions. */
1609 else if (is_rr (insn
, op_bcr
, &r1
, &r2
)
1610 || is_rx (insn
, op_bc
, &r1
, &d2
, &x2
, &b2
)
1611 || is_rr (insn
, op_bctr
, &r1
, &r2
)
1612 || is_rre (insn
, op_bctgr
, &r1
, &r2
)
1613 || is_rx (insn
, op_bct
, &r1
, &d2
, &x2
, &b2
)
1614 || is_rxy (insn
, op1_bctg
, op2_brctg
, &r1
, &d2
, &x2
, &b2
)
1615 || is_rs (insn
, op_bxh
, &r1
, &r3
, &d2
, &b2
)
1616 || is_rsy (insn
, op1_bxhg
, op2_bxhg
, &r1
, &r3
, &d2
, &b2
)
1617 || is_rs (insn
, op_bxle
, &r1
, &r3
, &d2
, &b2
)
1618 || is_rsy (insn
, op1_bxleg
, op2_bxleg
, &r1
, &r3
, &d2
, &b2
))
1620 /* Update PC iff branch was *not* taken. */
1621 if (pc
== to
+ insnlen
)
1622 regcache_write_pc (regs
, from
+ insnlen
);
1625 /* Handle PC-relative branch and save instructions. */
1626 else if (is_ri (insn
, op1_bras
, op2_bras
, &r1
, &i2
)
1627 || is_ril (insn
, op1_brasl
, op2_brasl
, &r1
, &i2
))
1630 regcache_write_pc (regs
, pc
- to
+ from
);
1631 /* Recompute saved return address in R1. */
1632 regcache_cooked_write_unsigned (regs
, S390_R0_REGNUM
+ r1
,
1633 amode
| (from
+ insnlen
));
1636 /* Handle PC-relative branch instructions. */
1637 else if (is_ri (insn
, op1_brc
, op2_brc
, &r1
, &i2
)
1638 || is_ril (insn
, op1_brcl
, op2_brcl
, &r1
, &i2
)
1639 || is_ri (insn
, op1_brct
, op2_brct
, &r1
, &i2
)
1640 || is_ri (insn
, op1_brctg
, op2_brctg
, &r1
, &i2
)
1641 || is_rsi (insn
, op_brxh
, &r1
, &r3
, &i2
)
1642 || is_rie (insn
, op1_brxhg
, op2_brxhg
, &r1
, &r3
, &i2
)
1643 || is_rsi (insn
, op_brxle
, &r1
, &r3
, &i2
)
1644 || is_rie (insn
, op1_brxlg
, op2_brxlg
, &r1
, &r3
, &i2
))
1647 regcache_write_pc (regs
, pc
- to
+ from
);
1650 /* Handle LOAD ADDRESS RELATIVE LONG. */
1651 else if (is_ril (insn
, op1_larl
, op2_larl
, &r1
, &i2
))
1654 regcache_write_pc (regs
, from
+ insnlen
);
1655 /* Recompute output address in R1. */
1656 regcache_cooked_write_unsigned (regs
, S390_R0_REGNUM
+ r1
,
1657 amode
| (from
+ i2
* 2));
1660 /* If we executed a breakpoint instruction, point PC right back at it. */
1661 else if (insn
[0] == 0x0 && insn
[1] == 0x1)
1662 regcache_write_pc (regs
, from
);
1664 /* For any other insn, PC points right after the original instruction. */
1666 regcache_write_pc (regs
, from
+ insnlen
);
1668 if (debug_displaced
)
1669 fprintf_unfiltered (gdb_stdlog
,
1670 "displaced: (s390) pc is now %s\n",
1671 paddress (gdbarch
, regcache_read_pc (regs
)));
1675 /* Helper routine to unwind pseudo registers. */
1677 static struct value
*
1678 s390_unwind_pseudo_register (struct frame_info
*this_frame
, int regnum
)
1680 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1681 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1682 struct type
*type
= register_type (gdbarch
, regnum
);
1684 /* Unwind PC via PSW address. */
1685 if (regnum
== tdep
->pc_regnum
)
1689 val
= frame_unwind_register_value (this_frame
, S390_PSWA_REGNUM
);
1690 if (!value_optimized_out (val
))
1692 LONGEST pswa
= value_as_long (val
);
1694 if (TYPE_LENGTH (type
) == 4)
1695 return value_from_pointer (type
, pswa
& 0x7fffffff);
1697 return value_from_pointer (type
, pswa
);
1701 /* Unwind CC via PSW mask. */
1702 if (regnum
== tdep
->cc_regnum
)
1706 val
= frame_unwind_register_value (this_frame
, S390_PSWM_REGNUM
);
1707 if (!value_optimized_out (val
))
1709 LONGEST pswm
= value_as_long (val
);
1711 if (TYPE_LENGTH (type
) == 4)
1712 return value_from_longest (type
, (pswm
>> 12) & 3);
1714 return value_from_longest (type
, (pswm
>> 44) & 3);
1718 /* Unwind full GPRs to show at least the lower halves (as the
1719 upper halves are undefined). */
1720 if (tdep
->gpr_full_regnum
!= -1
1721 && regnum
>= tdep
->gpr_full_regnum
1722 && regnum
< tdep
->gpr_full_regnum
+ 16)
1724 int reg
= regnum
- tdep
->gpr_full_regnum
;
1727 val
= frame_unwind_register_value (this_frame
, S390_R0_REGNUM
+ reg
);
1728 if (!value_optimized_out (val
))
1729 return value_cast (type
, val
);
1732 return allocate_optimized_out_value (type
);
1735 static struct value
*
1736 s390_trad_frame_prev_register (struct frame_info
*this_frame
,
1737 struct trad_frame_saved_reg saved_regs
[],
1740 if (regnum
< S390_NUM_REGS
)
1741 return trad_frame_get_prev_register (this_frame
, saved_regs
, regnum
);
1743 return s390_unwind_pseudo_register (this_frame
, regnum
);
1747 /* Normal stack frames. */
1749 struct s390_unwind_cache
{
1752 CORE_ADDR frame_base
;
1753 CORE_ADDR local_base
;
1755 struct trad_frame_saved_reg
*saved_regs
;
1759 s390_prologue_frame_unwind_cache (struct frame_info
*this_frame
,
1760 struct s390_unwind_cache
*info
)
1762 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1763 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
1764 struct s390_prologue_data data
;
1765 pv_t
*fp
= &data
.gpr
[S390_FRAME_REGNUM
- S390_R0_REGNUM
];
1766 pv_t
*sp
= &data
.gpr
[S390_SP_REGNUM
- S390_R0_REGNUM
];
1775 struct frame_info
*next_frame
;
1777 /* Try to find the function start address. If we can't find it, we don't
1778 bother searching for it -- with modern compilers this would be mostly
1779 pointless anyway. Trust that we'll either have valid DWARF-2 CFI data
1780 or else a valid backchain ... */
1781 func
= get_frame_func (this_frame
);
1785 /* Try to analyze the prologue. */
1786 result
= s390_analyze_prologue (gdbarch
, func
,
1787 get_frame_pc (this_frame
), &data
);
1791 /* If this was successful, we should have found the instruction that
1792 sets the stack pointer register to the previous value of the stack
1793 pointer minus the frame size. */
1794 if (!pv_is_register (*sp
, S390_SP_REGNUM
))
1797 /* A frame size of zero at this point can mean either a real
1798 frameless function, or else a failure to find the prologue.
1799 Perform some sanity checks to verify we really have a
1800 frameless function. */
1803 /* If the next frame is a NORMAL_FRAME, this frame *cannot* have frame
1804 size zero. This is only possible if the next frame is a sentinel
1805 frame, a dummy frame, or a signal trampoline frame. */
1806 /* FIXME: cagney/2004-05-01: This sanity check shouldn't be
1807 needed, instead the code should simpliy rely on its
1809 next_frame
= get_next_frame (this_frame
);
1810 while (next_frame
&& get_frame_type (next_frame
) == INLINE_FRAME
)
1811 next_frame
= get_next_frame (next_frame
);
1813 && get_frame_type (get_next_frame (this_frame
)) == NORMAL_FRAME
)
1816 /* If we really have a frameless function, %r14 must be valid
1817 -- in particular, it must point to a different function. */
1818 reg
= get_frame_register_unsigned (this_frame
, S390_RETADDR_REGNUM
);
1819 reg
= gdbarch_addr_bits_remove (gdbarch
, reg
) - 1;
1820 if (get_pc_function_start (reg
) == func
)
1822 /* However, there is one case where it *is* valid for %r14
1823 to point to the same function -- if this is a recursive
1824 call, and we have stopped in the prologue *before* the
1825 stack frame was allocated.
1827 Recognize this case by looking ahead a bit ... */
1829 struct s390_prologue_data data2
;
1830 pv_t
*sp
= &data2
.gpr
[S390_SP_REGNUM
- S390_R0_REGNUM
];
1832 if (!(s390_analyze_prologue (gdbarch
, func
, (CORE_ADDR
)-1, &data2
)
1833 && pv_is_register (*sp
, S390_SP_REGNUM
)
1840 /* OK, we've found valid prologue data. */
1843 /* If the frame pointer originally also holds the same value
1844 as the stack pointer, we're probably using it. If it holds
1845 some other value -- even a constant offset -- it is most
1846 likely used as temp register. */
1847 if (pv_is_identical (*sp
, *fp
))
1848 frame_pointer
= S390_FRAME_REGNUM
;
1850 frame_pointer
= S390_SP_REGNUM
;
1852 /* If we've detected a function with stack frame, we'll still have to
1853 treat it as frameless if we're currently within the function epilog
1854 code at a point where the frame pointer has already been restored.
1855 This can only happen in an innermost frame. */
1856 /* FIXME: cagney/2004-05-01: This sanity check shouldn't be needed,
1857 instead the code should simpliy rely on its analysis. */
1858 next_frame
= get_next_frame (this_frame
);
1859 while (next_frame
&& get_frame_type (next_frame
) == INLINE_FRAME
)
1860 next_frame
= get_next_frame (next_frame
);
1862 && (next_frame
== NULL
1863 || get_frame_type (get_next_frame (this_frame
)) != NORMAL_FRAME
))
1865 /* See the comment in s390_in_function_epilogue_p on why this is
1866 not completely reliable ... */
1867 if (s390_in_function_epilogue_p (gdbarch
, get_frame_pc (this_frame
)))
1869 memset (&data
, 0, sizeof (data
));
1871 frame_pointer
= S390_SP_REGNUM
;
1875 /* Once we know the frame register and the frame size, we can unwind
1876 the current value of the frame register from the next frame, and
1877 add back the frame size to arrive that the previous frame's
1878 stack pointer value. */
1879 prev_sp
= get_frame_register_unsigned (this_frame
, frame_pointer
) + size
;
1880 cfa
= prev_sp
+ 16*word_size
+ 32;
1882 /* Set up ABI call-saved/call-clobbered registers. */
1883 for (i
= 0; i
< S390_NUM_REGS
; i
++)
1884 if (!s390_register_call_saved (gdbarch
, i
))
1885 trad_frame_set_unknown (info
->saved_regs
, i
);
1887 /* CC is always call-clobbered. */
1888 trad_frame_set_unknown (info
->saved_regs
, S390_PSWM_REGNUM
);
1890 /* Record the addresses of all register spill slots the prologue parser
1891 has recognized. Consider only registers defined as call-saved by the
1892 ABI; for call-clobbered registers the parser may have recognized
1895 for (i
= 0; i
< 16; i
++)
1896 if (s390_register_call_saved (gdbarch
, S390_R0_REGNUM
+ i
)
1897 && data
.gpr_slot
[i
] != 0)
1898 info
->saved_regs
[S390_R0_REGNUM
+ i
].addr
= cfa
- data
.gpr_slot
[i
];
1900 for (i
= 0; i
< 16; i
++)
1901 if (s390_register_call_saved (gdbarch
, S390_F0_REGNUM
+ i
)
1902 && data
.fpr_slot
[i
] != 0)
1903 info
->saved_regs
[S390_F0_REGNUM
+ i
].addr
= cfa
- data
.fpr_slot
[i
];
1905 /* Function return will set PC to %r14. */
1906 info
->saved_regs
[S390_PSWA_REGNUM
] = info
->saved_regs
[S390_RETADDR_REGNUM
];
1908 /* In frameless functions, we unwind simply by moving the return
1909 address to the PC. However, if we actually stored to the
1910 save area, use that -- we might only think the function frameless
1911 because we're in the middle of the prologue ... */
1913 && !trad_frame_addr_p (info
->saved_regs
, S390_PSWA_REGNUM
))
1915 info
->saved_regs
[S390_PSWA_REGNUM
].realreg
= S390_RETADDR_REGNUM
;
1918 /* Another sanity check: unless this is a frameless function,
1919 we should have found spill slots for SP and PC.
1920 If not, we cannot unwind further -- this happens e.g. in
1921 libc's thread_start routine. */
1924 if (!trad_frame_addr_p (info
->saved_regs
, S390_SP_REGNUM
)
1925 || !trad_frame_addr_p (info
->saved_regs
, S390_PSWA_REGNUM
))
1929 /* We use the current value of the frame register as local_base,
1930 and the top of the register save area as frame_base. */
1933 info
->frame_base
= prev_sp
+ 16*word_size
+ 32;
1934 info
->local_base
= prev_sp
- size
;
1942 s390_backchain_frame_unwind_cache (struct frame_info
*this_frame
,
1943 struct s390_unwind_cache
*info
)
1945 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1946 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
1947 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1948 CORE_ADDR backchain
;
1953 /* Set up ABI call-saved/call-clobbered registers. */
1954 for (i
= 0; i
< S390_NUM_REGS
; i
++)
1955 if (!s390_register_call_saved (gdbarch
, i
))
1956 trad_frame_set_unknown (info
->saved_regs
, i
);
1958 /* CC is always call-clobbered. */
1959 trad_frame_set_unknown (info
->saved_regs
, S390_PSWM_REGNUM
);
1961 /* Get the backchain. */
1962 reg
= get_frame_register_unsigned (this_frame
, S390_SP_REGNUM
);
1963 backchain
= read_memory_unsigned_integer (reg
, word_size
, byte_order
);
1965 /* A zero backchain terminates the frame chain. As additional
1966 sanity check, let's verify that the spill slot for SP in the
1967 save area pointed to by the backchain in fact links back to
1970 && safe_read_memory_integer (backchain
+ 15*word_size
,
1971 word_size
, byte_order
, &sp
)
1972 && (CORE_ADDR
)sp
== backchain
)
1974 /* We don't know which registers were saved, but it will have
1975 to be at least %r14 and %r15. This will allow us to continue
1976 unwinding, but other prev-frame registers may be incorrect ... */
1977 info
->saved_regs
[S390_SP_REGNUM
].addr
= backchain
+ 15*word_size
;
1978 info
->saved_regs
[S390_RETADDR_REGNUM
].addr
= backchain
+ 14*word_size
;
1980 /* Function return will set PC to %r14. */
1981 info
->saved_regs
[S390_PSWA_REGNUM
]
1982 = info
->saved_regs
[S390_RETADDR_REGNUM
];
1984 /* We use the current value of the frame register as local_base,
1985 and the top of the register save area as frame_base. */
1986 info
->frame_base
= backchain
+ 16*word_size
+ 32;
1987 info
->local_base
= reg
;
1990 info
->func
= get_frame_pc (this_frame
);
1993 static struct s390_unwind_cache
*
1994 s390_frame_unwind_cache (struct frame_info
*this_frame
,
1995 void **this_prologue_cache
)
1997 struct s390_unwind_cache
*info
;
1998 if (*this_prologue_cache
)
1999 return *this_prologue_cache
;
2001 info
= FRAME_OBSTACK_ZALLOC (struct s390_unwind_cache
);
2002 *this_prologue_cache
= info
;
2003 info
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
2005 info
->frame_base
= -1;
2006 info
->local_base
= -1;
2008 /* Try to use prologue analysis to fill the unwind cache.
2009 If this fails, fall back to reading the stack backchain. */
2010 if (!s390_prologue_frame_unwind_cache (this_frame
, info
))
2011 s390_backchain_frame_unwind_cache (this_frame
, info
);
2017 s390_frame_this_id (struct frame_info
*this_frame
,
2018 void **this_prologue_cache
,
2019 struct frame_id
*this_id
)
2021 struct s390_unwind_cache
*info
2022 = s390_frame_unwind_cache (this_frame
, this_prologue_cache
);
2024 if (info
->frame_base
== -1)
2027 *this_id
= frame_id_build (info
->frame_base
, info
->func
);
2030 static struct value
*
2031 s390_frame_prev_register (struct frame_info
*this_frame
,
2032 void **this_prologue_cache
, int regnum
)
2034 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2035 struct s390_unwind_cache
*info
2036 = s390_frame_unwind_cache (this_frame
, this_prologue_cache
);
2038 return s390_trad_frame_prev_register (this_frame
, info
->saved_regs
, regnum
);
2041 static const struct frame_unwind s390_frame_unwind
= {
2043 default_frame_unwind_stop_reason
,
2045 s390_frame_prev_register
,
2047 default_frame_sniffer
2051 /* Code stubs and their stack frames. For things like PLTs and NULL
2052 function calls (where there is no true frame and the return address
2053 is in the RETADDR register). */
2055 struct s390_stub_unwind_cache
2057 CORE_ADDR frame_base
;
2058 struct trad_frame_saved_reg
*saved_regs
;
2061 static struct s390_stub_unwind_cache
*
2062 s390_stub_frame_unwind_cache (struct frame_info
*this_frame
,
2063 void **this_prologue_cache
)
2065 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2066 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
2067 struct s390_stub_unwind_cache
*info
;
2070 if (*this_prologue_cache
)
2071 return *this_prologue_cache
;
2073 info
= FRAME_OBSTACK_ZALLOC (struct s390_stub_unwind_cache
);
2074 *this_prologue_cache
= info
;
2075 info
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
2077 /* The return address is in register %r14. */
2078 info
->saved_regs
[S390_PSWA_REGNUM
].realreg
= S390_RETADDR_REGNUM
;
2080 /* Retrieve stack pointer and determine our frame base. */
2081 reg
= get_frame_register_unsigned (this_frame
, S390_SP_REGNUM
);
2082 info
->frame_base
= reg
+ 16*word_size
+ 32;
2088 s390_stub_frame_this_id (struct frame_info
*this_frame
,
2089 void **this_prologue_cache
,
2090 struct frame_id
*this_id
)
2092 struct s390_stub_unwind_cache
*info
2093 = s390_stub_frame_unwind_cache (this_frame
, this_prologue_cache
);
2094 *this_id
= frame_id_build (info
->frame_base
, get_frame_pc (this_frame
));
2097 static struct value
*
2098 s390_stub_frame_prev_register (struct frame_info
*this_frame
,
2099 void **this_prologue_cache
, int regnum
)
2101 struct s390_stub_unwind_cache
*info
2102 = s390_stub_frame_unwind_cache (this_frame
, this_prologue_cache
);
2103 return s390_trad_frame_prev_register (this_frame
, info
->saved_regs
, regnum
);
2107 s390_stub_frame_sniffer (const struct frame_unwind
*self
,
2108 struct frame_info
*this_frame
,
2109 void **this_prologue_cache
)
2111 CORE_ADDR addr_in_block
;
2112 bfd_byte insn
[S390_MAX_INSTR_SIZE
];
2114 /* If the current PC points to non-readable memory, we assume we
2115 have trapped due to an invalid function pointer call. We handle
2116 the non-existing current function like a PLT stub. */
2117 addr_in_block
= get_frame_address_in_block (this_frame
);
2118 if (in_plt_section (addr_in_block
, NULL
)
2119 || s390_readinstruction (insn
, get_frame_pc (this_frame
)) < 0)
2124 static const struct frame_unwind s390_stub_frame_unwind
= {
2126 default_frame_unwind_stop_reason
,
2127 s390_stub_frame_this_id
,
2128 s390_stub_frame_prev_register
,
2130 s390_stub_frame_sniffer
2134 /* Signal trampoline stack frames. */
2136 struct s390_sigtramp_unwind_cache
{
2137 CORE_ADDR frame_base
;
2138 struct trad_frame_saved_reg
*saved_regs
;
2141 static struct s390_sigtramp_unwind_cache
*
2142 s390_sigtramp_frame_unwind_cache (struct frame_info
*this_frame
,
2143 void **this_prologue_cache
)
2145 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2146 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2147 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
2148 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2149 struct s390_sigtramp_unwind_cache
*info
;
2150 ULONGEST this_sp
, prev_sp
;
2151 CORE_ADDR next_ra
, next_cfa
, sigreg_ptr
, sigreg_high_off
;
2154 if (*this_prologue_cache
)
2155 return *this_prologue_cache
;
2157 info
= FRAME_OBSTACK_ZALLOC (struct s390_sigtramp_unwind_cache
);
2158 *this_prologue_cache
= info
;
2159 info
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
2161 this_sp
= get_frame_register_unsigned (this_frame
, S390_SP_REGNUM
);
2162 next_ra
= get_frame_pc (this_frame
);
2163 next_cfa
= this_sp
+ 16*word_size
+ 32;
2165 /* New-style RT frame:
2166 retcode + alignment (8 bytes)
2168 ucontext (contains sigregs at offset 5 words). */
2169 if (next_ra
== next_cfa
)
2171 sigreg_ptr
= next_cfa
+ 8 + 128 + align_up (5*word_size
, 8);
2172 /* sigregs are followed by uc_sigmask (8 bytes), then by the
2173 upper GPR halves if present. */
2174 sigreg_high_off
= 8;
2177 /* Old-style RT frame and all non-RT frames:
2178 old signal mask (8 bytes)
2179 pointer to sigregs. */
2182 sigreg_ptr
= read_memory_unsigned_integer (next_cfa
+ 8,
2183 word_size
, byte_order
);
2184 /* sigregs are followed by signo (4 bytes), then by the
2185 upper GPR halves if present. */
2186 sigreg_high_off
= 4;
2189 /* The sigregs structure looks like this:
2198 /* PSW mask and address. */
2199 info
->saved_regs
[S390_PSWM_REGNUM
].addr
= sigreg_ptr
;
2200 sigreg_ptr
+= word_size
;
2201 info
->saved_regs
[S390_PSWA_REGNUM
].addr
= sigreg_ptr
;
2202 sigreg_ptr
+= word_size
;
2204 /* Then the GPRs. */
2205 for (i
= 0; i
< 16; i
++)
2207 info
->saved_regs
[S390_R0_REGNUM
+ i
].addr
= sigreg_ptr
;
2208 sigreg_ptr
+= word_size
;
2211 /* Then the ACRs. */
2212 for (i
= 0; i
< 16; i
++)
2214 info
->saved_regs
[S390_A0_REGNUM
+ i
].addr
= sigreg_ptr
;
2218 /* The floating-point control word. */
2219 info
->saved_regs
[S390_FPC_REGNUM
].addr
= sigreg_ptr
;
2222 /* And finally the FPRs. */
2223 for (i
= 0; i
< 16; i
++)
2225 info
->saved_regs
[S390_F0_REGNUM
+ i
].addr
= sigreg_ptr
;
2229 /* If we have them, the GPR upper halves are appended at the end. */
2230 sigreg_ptr
+= sigreg_high_off
;
2231 if (tdep
->gpr_full_regnum
!= -1)
2232 for (i
= 0; i
< 16; i
++)
2234 info
->saved_regs
[S390_R0_UPPER_REGNUM
+ i
].addr
= sigreg_ptr
;
2238 /* Restore the previous frame's SP. */
2239 prev_sp
= read_memory_unsigned_integer (
2240 info
->saved_regs
[S390_SP_REGNUM
].addr
,
2241 word_size
, byte_order
);
2243 /* Determine our frame base. */
2244 info
->frame_base
= prev_sp
+ 16*word_size
+ 32;
2250 s390_sigtramp_frame_this_id (struct frame_info
*this_frame
,
2251 void **this_prologue_cache
,
2252 struct frame_id
*this_id
)
2254 struct s390_sigtramp_unwind_cache
*info
2255 = s390_sigtramp_frame_unwind_cache (this_frame
, this_prologue_cache
);
2256 *this_id
= frame_id_build (info
->frame_base
, get_frame_pc (this_frame
));
2259 static struct value
*
2260 s390_sigtramp_frame_prev_register (struct frame_info
*this_frame
,
2261 void **this_prologue_cache
, int regnum
)
2263 struct s390_sigtramp_unwind_cache
*info
2264 = s390_sigtramp_frame_unwind_cache (this_frame
, this_prologue_cache
);
2265 return s390_trad_frame_prev_register (this_frame
, info
->saved_regs
, regnum
);
2269 s390_sigtramp_frame_sniffer (const struct frame_unwind
*self
,
2270 struct frame_info
*this_frame
,
2271 void **this_prologue_cache
)
2273 CORE_ADDR pc
= get_frame_pc (this_frame
);
2274 bfd_byte sigreturn
[2];
2276 if (target_read_memory (pc
, sigreturn
, 2))
2279 if (sigreturn
[0] != 0x0a /* svc */)
2282 if (sigreturn
[1] != 119 /* sigreturn */
2283 && sigreturn
[1] != 173 /* rt_sigreturn */)
2289 static const struct frame_unwind s390_sigtramp_frame_unwind
= {
2291 default_frame_unwind_stop_reason
,
2292 s390_sigtramp_frame_this_id
,
2293 s390_sigtramp_frame_prev_register
,
2295 s390_sigtramp_frame_sniffer
2299 /* Frame base handling. */
2302 s390_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
2304 struct s390_unwind_cache
*info
2305 = s390_frame_unwind_cache (this_frame
, this_cache
);
2306 return info
->frame_base
;
2310 s390_local_base_address (struct frame_info
*this_frame
, void **this_cache
)
2312 struct s390_unwind_cache
*info
2313 = s390_frame_unwind_cache (this_frame
, this_cache
);
2314 return info
->local_base
;
2317 static const struct frame_base s390_frame_base
= {
2319 s390_frame_base_address
,
2320 s390_local_base_address
,
2321 s390_local_base_address
2325 s390_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2327 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2329 pc
= frame_unwind_register_unsigned (next_frame
, tdep
->pc_regnum
);
2330 return gdbarch_addr_bits_remove (gdbarch
, pc
);
2334 s390_unwind_sp (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2337 sp
= frame_unwind_register_unsigned (next_frame
, S390_SP_REGNUM
);
2338 return gdbarch_addr_bits_remove (gdbarch
, sp
);
2342 /* DWARF-2 frame support. */
2344 static struct value
*
2345 s390_dwarf2_prev_register (struct frame_info
*this_frame
, void **this_cache
,
2348 return s390_unwind_pseudo_register (this_frame
, regnum
);
2352 s390_dwarf2_frame_init_reg (struct gdbarch
*gdbarch
, int regnum
,
2353 struct dwarf2_frame_state_reg
*reg
,
2354 struct frame_info
*this_frame
)
2356 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2358 /* The condition code (and thus PSW mask) is call-clobbered. */
2359 if (regnum
== S390_PSWM_REGNUM
)
2360 reg
->how
= DWARF2_FRAME_REG_UNDEFINED
;
2362 /* The PSW address unwinds to the return address. */
2363 else if (regnum
== S390_PSWA_REGNUM
)
2364 reg
->how
= DWARF2_FRAME_REG_RA
;
2366 /* Fixed registers are call-saved or call-clobbered
2367 depending on the ABI in use. */
2368 else if (regnum
< S390_NUM_REGS
)
2370 if (s390_register_call_saved (gdbarch
, regnum
))
2371 reg
->how
= DWARF2_FRAME_REG_SAME_VALUE
;
2373 reg
->how
= DWARF2_FRAME_REG_UNDEFINED
;
2376 /* We install a special function to unwind pseudos. */
2379 reg
->how
= DWARF2_FRAME_REG_FN
;
2380 reg
->loc
.fn
= s390_dwarf2_prev_register
;
2385 /* Dummy function calls. */
2387 /* Return non-zero if TYPE is an integer-like type, zero otherwise.
2388 "Integer-like" types are those that should be passed the way
2389 integers are: integers, enums, ranges, characters, and booleans. */
2391 is_integer_like (struct type
*type
)
2393 enum type_code code
= TYPE_CODE (type
);
2395 return (code
== TYPE_CODE_INT
2396 || code
== TYPE_CODE_ENUM
2397 || code
== TYPE_CODE_RANGE
2398 || code
== TYPE_CODE_CHAR
2399 || code
== TYPE_CODE_BOOL
);
2402 /* Return non-zero if TYPE is a pointer-like type, zero otherwise.
2403 "Pointer-like" types are those that should be passed the way
2404 pointers are: pointers and references. */
2406 is_pointer_like (struct type
*type
)
2408 enum type_code code
= TYPE_CODE (type
);
2410 return (code
== TYPE_CODE_PTR
2411 || code
== TYPE_CODE_REF
);
2415 /* Return non-zero if TYPE is a `float singleton' or `double
2416 singleton', zero otherwise.
2418 A `T singleton' is a struct type with one member, whose type is
2419 either T or a `T singleton'. So, the following are all float
2423 struct { struct { float x; } x; };
2424 struct { struct { struct { float x; } x; } x; };
2428 All such structures are passed as if they were floats or doubles,
2429 as the (revised) ABI says. */
2431 is_float_singleton (struct type
*type
)
2433 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
&& TYPE_NFIELDS (type
) == 1)
2435 struct type
*singleton_type
= TYPE_FIELD_TYPE (type
, 0);
2436 CHECK_TYPEDEF (singleton_type
);
2438 return (TYPE_CODE (singleton_type
) == TYPE_CODE_FLT
2439 || TYPE_CODE (singleton_type
) == TYPE_CODE_DECFLOAT
2440 || is_float_singleton (singleton_type
));
2447 /* Return non-zero if TYPE is a struct-like type, zero otherwise.
2448 "Struct-like" types are those that should be passed as structs are:
2451 As an odd quirk, not mentioned in the ABI, GCC passes float and
2452 double singletons as if they were a plain float, double, etc. (The
2453 corresponding union types are handled normally.) So we exclude
2454 those types here. *shrug* */
2456 is_struct_like (struct type
*type
)
2458 enum type_code code
= TYPE_CODE (type
);
2460 return (code
== TYPE_CODE_UNION
2461 || (code
== TYPE_CODE_STRUCT
&& ! is_float_singleton (type
)));
2465 /* Return non-zero if TYPE is a float-like type, zero otherwise.
2466 "Float-like" types are those that should be passed as
2467 floating-point values are.
2469 You'd think this would just be floats, doubles, long doubles, etc.
2470 But as an odd quirk, not mentioned in the ABI, GCC passes float and
2471 double singletons as if they were a plain float, double, etc. (The
2472 corresponding union types are handled normally.) So we include
2473 those types here. *shrug* */
2475 is_float_like (struct type
*type
)
2477 return (TYPE_CODE (type
) == TYPE_CODE_FLT
2478 || TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
2479 || is_float_singleton (type
));
2484 is_power_of_two (unsigned int n
)
2486 return ((n
& (n
- 1)) == 0);
2489 /* Return non-zero if TYPE should be passed as a pointer to a copy,
2492 s390_function_arg_pass_by_reference (struct type
*type
)
2494 if (TYPE_LENGTH (type
) > 8)
2497 return (is_struct_like (type
) && !is_power_of_two (TYPE_LENGTH (type
)))
2498 || TYPE_CODE (type
) == TYPE_CODE_COMPLEX
2499 || (TYPE_CODE (type
) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (type
));
2502 /* Return non-zero if TYPE should be passed in a float register
2505 s390_function_arg_float (struct type
*type
)
2507 if (TYPE_LENGTH (type
) > 8)
2510 return is_float_like (type
);
2513 /* Return non-zero if TYPE should be passed in an integer register
2514 (or a pair of integer registers) if possible. */
2516 s390_function_arg_integer (struct type
*type
)
2518 if (TYPE_LENGTH (type
) > 8)
2521 return is_integer_like (type
)
2522 || is_pointer_like (type
)
2523 || (is_struct_like (type
) && is_power_of_two (TYPE_LENGTH (type
)));
2526 /* Return ARG, a `SIMPLE_ARG', sign-extended or zero-extended to a full
2527 word as required for the ABI. */
2529 extend_simple_arg (struct gdbarch
*gdbarch
, struct value
*arg
)
2531 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2532 struct type
*type
= check_typedef (value_type (arg
));
2534 /* Even structs get passed in the least significant bits of the
2535 register / memory word. It's not really right to extract them as
2536 an integer, but it does take care of the extension. */
2537 if (TYPE_UNSIGNED (type
))
2538 return extract_unsigned_integer (value_contents (arg
),
2539 TYPE_LENGTH (type
), byte_order
);
2541 return extract_signed_integer (value_contents (arg
),
2542 TYPE_LENGTH (type
), byte_order
);
2546 /* Return the alignment required by TYPE. */
2548 alignment_of (struct type
*type
)
2552 if (is_integer_like (type
)
2553 || is_pointer_like (type
)
2554 || TYPE_CODE (type
) == TYPE_CODE_FLT
2555 || TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
2556 alignment
= TYPE_LENGTH (type
);
2557 else if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
2558 || TYPE_CODE (type
) == TYPE_CODE_UNION
)
2563 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
2566 = alignment_of (check_typedef (TYPE_FIELD_TYPE (type
, i
)));
2568 if (field_alignment
> alignment
)
2569 alignment
= field_alignment
;
2575 /* Check that everything we ever return is a power of two. Lots of
2576 code doesn't want to deal with aligning things to arbitrary
2578 gdb_assert ((alignment
& (alignment
- 1)) == 0);
2584 /* Put the actual parameter values pointed to by ARGS[0..NARGS-1] in
2585 place to be passed to a function, as specified by the "GNU/Linux
2586 for S/390 ELF Application Binary Interface Supplement".
2588 SP is the current stack pointer. We must put arguments, links,
2589 padding, etc. whereever they belong, and return the new stack
2592 If STRUCT_RETURN is non-zero, then the function we're calling is
2593 going to return a structure by value; STRUCT_ADDR is the address of
2594 a block we've allocated for it on the stack.
2596 Our caller has taken care of any type promotions needed to satisfy
2597 prototypes or the old K&R argument-passing rules. */
2599 s390_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
2600 struct regcache
*regcache
, CORE_ADDR bp_addr
,
2601 int nargs
, struct value
**args
, CORE_ADDR sp
,
2602 int struct_return
, CORE_ADDR struct_addr
)
2604 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2605 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
2606 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2609 /* If the i'th argument is passed as a reference to a copy, then
2610 copy_addr[i] is the address of the copy we made. */
2611 CORE_ADDR
*copy_addr
= alloca (nargs
* sizeof (CORE_ADDR
));
2613 /* Reserve space for the reference-to-copy area. */
2614 for (i
= 0; i
< nargs
; i
++)
2616 struct value
*arg
= args
[i
];
2617 struct type
*type
= check_typedef (value_type (arg
));
2619 if (s390_function_arg_pass_by_reference (type
))
2621 sp
-= TYPE_LENGTH (type
);
2622 sp
= align_down (sp
, alignment_of (type
));
2627 /* Reserve space for the parameter area. As a conservative
2628 simplification, we assume that everything will be passed on the
2629 stack. Since every argument larger than 8 bytes will be
2630 passed by reference, we use this simple upper bound. */
2633 /* After all that, make sure it's still aligned on an eight-byte
2635 sp
= align_down (sp
, 8);
2637 /* Allocate the standard frame areas: the register save area, the
2638 word reserved for the compiler (which seems kind of meaningless),
2639 and the back chain pointer. */
2640 sp
-= 16*word_size
+ 32;
2642 /* Now we have the final SP value. Make sure we didn't underflow;
2643 on 31-bit, this would result in addresses with the high bit set,
2644 which causes confusion elsewhere. Note that if we error out
2645 here, stack and registers remain untouched. */
2646 if (gdbarch_addr_bits_remove (gdbarch
, sp
) != sp
)
2647 error (_("Stack overflow"));
2650 /* Finally, place the actual parameters, working from SP towards
2651 higher addresses. The code above is supposed to reserve enough
2656 CORE_ADDR starg
= sp
+ 16*word_size
+ 32;
2658 /* A struct is returned using general register 2. */
2661 regcache_cooked_write_unsigned (regcache
, S390_R0_REGNUM
+ gr
,
2666 for (i
= 0; i
< nargs
; i
++)
2668 struct value
*arg
= args
[i
];
2669 struct type
*type
= check_typedef (value_type (arg
));
2670 unsigned length
= TYPE_LENGTH (type
);
2672 if (s390_function_arg_pass_by_reference (type
))
2674 /* Actually copy the argument contents to the stack slot
2675 that was reserved above. */
2676 write_memory (copy_addr
[i
], value_contents (arg
), length
);
2680 regcache_cooked_write_unsigned (regcache
, S390_R0_REGNUM
+ gr
,
2686 write_memory_unsigned_integer (starg
, word_size
, byte_order
,
2691 else if (s390_function_arg_float (type
))
2693 /* The GNU/Linux for S/390 ABI uses FPRs 0 and 2 to pass arguments,
2694 the GNU/Linux for zSeries ABI uses 0, 2, 4, and 6. */
2695 if (fr
<= (tdep
->abi
== ABI_LINUX_S390
? 2 : 6))
2697 /* When we store a single-precision value in an FP register,
2698 it occupies the leftmost bits. */
2699 regcache_cooked_write_part (regcache
, S390_F0_REGNUM
+ fr
,
2700 0, length
, value_contents (arg
));
2705 /* When we store a single-precision value in a stack slot,
2706 it occupies the rightmost bits. */
2707 starg
= align_up (starg
+ length
, word_size
);
2708 write_memory (starg
- length
, value_contents (arg
), length
);
2711 else if (s390_function_arg_integer (type
) && length
<= word_size
)
2715 /* Integer arguments are always extended to word size. */
2716 regcache_cooked_write_signed (regcache
, S390_R0_REGNUM
+ gr
,
2717 extend_simple_arg (gdbarch
,
2723 /* Integer arguments are always extended to word size. */
2724 write_memory_signed_integer (starg
, word_size
, byte_order
,
2725 extend_simple_arg (gdbarch
, arg
));
2729 else if (s390_function_arg_integer (type
) && length
== 2*word_size
)
2733 regcache_cooked_write (regcache
, S390_R0_REGNUM
+ gr
,
2734 value_contents (arg
));
2735 regcache_cooked_write (regcache
, S390_R0_REGNUM
+ gr
+ 1,
2736 value_contents (arg
) + word_size
);
2741 /* If we skipped r6 because we couldn't fit a DOUBLE_ARG
2742 in it, then don't go back and use it again later. */
2745 write_memory (starg
, value_contents (arg
), length
);
2750 internal_error (__FILE__
, __LINE__
, _("unknown argument type"));
2754 /* Store return PSWA. In 31-bit mode, keep addressing mode bit. */
2758 regcache_cooked_read_unsigned (regcache
, S390_PSWA_REGNUM
, &pswa
);
2759 bp_addr
= (bp_addr
& 0x7fffffff) | (pswa
& 0x80000000);
2761 regcache_cooked_write_unsigned (regcache
, S390_RETADDR_REGNUM
, bp_addr
);
2763 /* Store updated stack pointer. */
2764 regcache_cooked_write_unsigned (regcache
, S390_SP_REGNUM
, sp
);
2766 /* We need to return the 'stack part' of the frame ID,
2767 which is actually the top of the register save area. */
2768 return sp
+ 16*word_size
+ 32;
2771 /* Assuming THIS_FRAME is a dummy, return the frame ID of that
2772 dummy frame. The frame ID's base needs to match the TOS value
2773 returned by push_dummy_call, and the PC match the dummy frame's
2775 static struct frame_id
2776 s390_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*this_frame
)
2778 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
2779 CORE_ADDR sp
= get_frame_register_unsigned (this_frame
, S390_SP_REGNUM
);
2780 sp
= gdbarch_addr_bits_remove (gdbarch
, sp
);
2782 return frame_id_build (sp
+ 16*word_size
+ 32,
2783 get_frame_pc (this_frame
));
2787 s390_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
2789 /* Both the 32- and 64-bit ABI's say that the stack pointer should
2790 always be aligned on an eight-byte boundary. */
2795 /* Function return value access. */
2797 static enum return_value_convention
2798 s390_return_value_convention (struct gdbarch
*gdbarch
, struct type
*type
)
2800 if (TYPE_LENGTH (type
) > 8)
2801 return RETURN_VALUE_STRUCT_CONVENTION
;
2803 switch (TYPE_CODE (type
))
2805 case TYPE_CODE_STRUCT
:
2806 case TYPE_CODE_UNION
:
2807 case TYPE_CODE_ARRAY
:
2808 case TYPE_CODE_COMPLEX
:
2809 return RETURN_VALUE_STRUCT_CONVENTION
;
2812 return RETURN_VALUE_REGISTER_CONVENTION
;
2816 static enum return_value_convention
2817 s390_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
2818 struct type
*type
, struct regcache
*regcache
,
2819 gdb_byte
*out
, const gdb_byte
*in
)
2821 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2822 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
2823 enum return_value_convention rvc
;
2826 type
= check_typedef (type
);
2827 rvc
= s390_return_value_convention (gdbarch
, type
);
2828 length
= TYPE_LENGTH (type
);
2834 case RETURN_VALUE_REGISTER_CONVENTION
:
2835 if (TYPE_CODE (type
) == TYPE_CODE_FLT
2836 || TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
2838 /* When we store a single-precision value in an FP register,
2839 it occupies the leftmost bits. */
2840 regcache_cooked_write_part (regcache
, S390_F0_REGNUM
,
2843 else if (length
<= word_size
)
2845 /* Integer arguments are always extended to word size. */
2846 if (TYPE_UNSIGNED (type
))
2847 regcache_cooked_write_unsigned (regcache
, S390_R2_REGNUM
,
2848 extract_unsigned_integer (in
, length
, byte_order
));
2850 regcache_cooked_write_signed (regcache
, S390_R2_REGNUM
,
2851 extract_signed_integer (in
, length
, byte_order
));
2853 else if (length
== 2*word_size
)
2855 regcache_cooked_write (regcache
, S390_R2_REGNUM
, in
);
2856 regcache_cooked_write (regcache
, S390_R3_REGNUM
, in
+ word_size
);
2859 internal_error (__FILE__
, __LINE__
, _("invalid return type"));
2862 case RETURN_VALUE_STRUCT_CONVENTION
:
2863 error (_("Cannot set function return value."));
2871 case RETURN_VALUE_REGISTER_CONVENTION
:
2872 if (TYPE_CODE (type
) == TYPE_CODE_FLT
2873 || TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
2875 /* When we store a single-precision value in an FP register,
2876 it occupies the leftmost bits. */
2877 regcache_cooked_read_part (regcache
, S390_F0_REGNUM
,
2880 else if (length
<= word_size
)
2882 /* Integer arguments occupy the rightmost bits. */
2883 regcache_cooked_read_part (regcache
, S390_R2_REGNUM
,
2884 word_size
- length
, length
, out
);
2886 else if (length
== 2*word_size
)
2888 regcache_cooked_read (regcache
, S390_R2_REGNUM
, out
);
2889 regcache_cooked_read (regcache
, S390_R3_REGNUM
, out
+ word_size
);
2892 internal_error (__FILE__
, __LINE__
, _("invalid return type"));
2895 case RETURN_VALUE_STRUCT_CONVENTION
:
2896 error (_("Function return value unknown."));
2907 static const gdb_byte
*
2908 s390_breakpoint_from_pc (struct gdbarch
*gdbarch
,
2909 CORE_ADDR
*pcptr
, int *lenptr
)
2911 static const gdb_byte breakpoint
[] = { 0x0, 0x1 };
2913 *lenptr
= sizeof (breakpoint
);
2918 /* Address handling. */
2921 s390_addr_bits_remove (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
2923 return addr
& 0x7fffffff;
2927 s390_address_class_type_flags (int byte_size
, int dwarf2_addr_class
)
2930 return TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1
;
2936 s390_address_class_type_flags_to_name (struct gdbarch
*gdbarch
, int type_flags
)
2938 if (type_flags
& TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1
)
2945 s390_address_class_name_to_type_flags (struct gdbarch
*gdbarch
,
2947 int *type_flags_ptr
)
2949 if (strcmp (name
, "mode32") == 0)
2951 *type_flags_ptr
= TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1
;
2958 /* Implementation of `gdbarch_stap_is_single_operand', as defined in
2962 s390_stap_is_single_operand (struct gdbarch
*gdbarch
, const char *s
)
2964 return ((isdigit (*s
) && s
[1] == '(' && s
[2] == '%') /* Displacement
2966 || *s
== '%' /* Register access. */
2967 || isdigit (*s
)); /* Literal number. */
2970 /* Set up gdbarch struct. */
2972 static struct gdbarch
*
2973 s390_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
2975 const struct target_desc
*tdesc
= info
.target_desc
;
2976 struct tdesc_arch_data
*tdesc_data
= NULL
;
2977 struct gdbarch
*gdbarch
;
2978 struct gdbarch_tdep
*tdep
;
2981 int have_linux_v1
= 0;
2982 int have_linux_v2
= 0;
2983 int first_pseudo_reg
, last_pseudo_reg
;
2985 /* Default ABI and register size. */
2986 switch (info
.bfd_arch_info
->mach
)
2988 case bfd_mach_s390_31
:
2989 tdep_abi
= ABI_LINUX_S390
;
2992 case bfd_mach_s390_64
:
2993 tdep_abi
= ABI_LINUX_ZSERIES
;
3000 /* Use default target description if none provided by the target. */
3001 if (!tdesc_has_registers (tdesc
))
3003 if (tdep_abi
== ABI_LINUX_S390
)
3004 tdesc
= tdesc_s390_linux32
;
3006 tdesc
= tdesc_s390x_linux64
;
3009 /* Check any target description for validity. */
3010 if (tdesc_has_registers (tdesc
))
3012 static const char *const gprs
[] = {
3013 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
3014 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
3016 static const char *const fprs
[] = {
3017 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
3018 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15"
3020 static const char *const acrs
[] = {
3021 "acr0", "acr1", "acr2", "acr3", "acr4", "acr5", "acr6", "acr7",
3022 "acr8", "acr9", "acr10", "acr11", "acr12", "acr13", "acr14", "acr15"
3024 static const char *const gprs_lower
[] = {
3025 "r0l", "r1l", "r2l", "r3l", "r4l", "r5l", "r6l", "r7l",
3026 "r8l", "r9l", "r10l", "r11l", "r12l", "r13l", "r14l", "r15l"
3028 static const char *const gprs_upper
[] = {
3029 "r0h", "r1h", "r2h", "r3h", "r4h", "r5h", "r6h", "r7h",
3030 "r8h", "r9h", "r10h", "r11h", "r12h", "r13h", "r14h", "r15h"
3032 const struct tdesc_feature
*feature
;
3035 feature
= tdesc_find_feature (tdesc
, "org.gnu.gdb.s390.core");
3036 if (feature
== NULL
)
3039 tdesc_data
= tdesc_data_alloc ();
3041 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
3042 S390_PSWM_REGNUM
, "pswm");
3043 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
3044 S390_PSWA_REGNUM
, "pswa");
3046 if (tdesc_unnumbered_register (feature
, "r0"))
3048 for (i
= 0; i
< 16; i
++)
3049 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
3050 S390_R0_REGNUM
+ i
, gprs
[i
]);
3056 for (i
= 0; i
< 16; i
++)
3057 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
3060 for (i
= 0; i
< 16; i
++)
3061 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
3062 S390_R0_UPPER_REGNUM
+ i
,
3066 feature
= tdesc_find_feature (tdesc
, "org.gnu.gdb.s390.fpr");
3067 if (feature
== NULL
)
3069 tdesc_data_cleanup (tdesc_data
);
3073 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
3074 S390_FPC_REGNUM
, "fpc");
3075 for (i
= 0; i
< 16; i
++)
3076 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
3077 S390_F0_REGNUM
+ i
, fprs
[i
]);
3079 feature
= tdesc_find_feature (tdesc
, "org.gnu.gdb.s390.acr");
3080 if (feature
== NULL
)
3082 tdesc_data_cleanup (tdesc_data
);
3086 for (i
= 0; i
< 16; i
++)
3087 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
3088 S390_A0_REGNUM
+ i
, acrs
[i
]);
3090 /* Optional GNU/Linux-specific "registers". */
3091 feature
= tdesc_find_feature (tdesc
, "org.gnu.gdb.s390.linux");
3094 tdesc_numbered_register (feature
, tdesc_data
,
3095 S390_ORIG_R2_REGNUM
, "orig_r2");
3097 if (tdesc_numbered_register (feature
, tdesc_data
,
3098 S390_LAST_BREAK_REGNUM
, "last_break"))
3101 if (tdesc_numbered_register (feature
, tdesc_data
,
3102 S390_SYSTEM_CALL_REGNUM
, "system_call"))
3105 if (have_linux_v2
> have_linux_v1
)
3111 tdesc_data_cleanup (tdesc_data
);
3116 /* Find a candidate among extant architectures. */
3117 for (arches
= gdbarch_list_lookup_by_info (arches
, &info
);
3119 arches
= gdbarch_list_lookup_by_info (arches
->next
, &info
))
3121 tdep
= gdbarch_tdep (arches
->gdbarch
);
3124 if (tdep
->abi
!= tdep_abi
)
3126 if ((tdep
->gpr_full_regnum
!= -1) != have_upper
)
3128 if (tdesc_data
!= NULL
)
3129 tdesc_data_cleanup (tdesc_data
);
3130 return arches
->gdbarch
;
3133 /* Otherwise create a new gdbarch for the specified machine type. */
3134 tdep
= XCALLOC (1, struct gdbarch_tdep
);
3135 tdep
->abi
= tdep_abi
;
3136 gdbarch
= gdbarch_alloc (&info
, tdep
);
3138 set_gdbarch_believe_pcc_promotion (gdbarch
, 0);
3139 set_gdbarch_char_signed (gdbarch
, 0);
3141 /* S/390 GNU/Linux uses either 64-bit or 128-bit long doubles.
3142 We can safely let them default to 128-bit, since the debug info
3143 will give the size of type actually used in each case. */
3144 set_gdbarch_long_double_bit (gdbarch
, 128);
3145 set_gdbarch_long_double_format (gdbarch
, floatformats_ia64_quad
);
3147 /* Amount PC must be decremented by after a breakpoint. This is
3148 often the number of bytes returned by gdbarch_breakpoint_from_pc but not
3150 set_gdbarch_decr_pc_after_break (gdbarch
, 2);
3151 /* Stack grows downward. */
3152 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
3153 set_gdbarch_breakpoint_from_pc (gdbarch
, s390_breakpoint_from_pc
);
3154 set_gdbarch_skip_prologue (gdbarch
, s390_skip_prologue
);
3155 set_gdbarch_in_function_epilogue_p (gdbarch
, s390_in_function_epilogue_p
);
3157 set_gdbarch_num_regs (gdbarch
, S390_NUM_REGS
);
3158 set_gdbarch_sp_regnum (gdbarch
, S390_SP_REGNUM
);
3159 set_gdbarch_fp0_regnum (gdbarch
, S390_F0_REGNUM
);
3160 set_gdbarch_stab_reg_to_regnum (gdbarch
, s390_dwarf_reg_to_regnum
);
3161 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, s390_dwarf_reg_to_regnum
);
3162 set_gdbarch_value_from_register (gdbarch
, s390_value_from_register
);
3163 set_gdbarch_regset_from_core_section (gdbarch
,
3164 s390_regset_from_core_section
);
3165 set_gdbarch_core_read_description (gdbarch
, s390_core_read_description
);
3166 set_gdbarch_cannot_store_register (gdbarch
, s390_cannot_store_register
);
3167 set_gdbarch_write_pc (gdbarch
, s390_write_pc
);
3168 set_gdbarch_pseudo_register_read (gdbarch
, s390_pseudo_register_read
);
3169 set_gdbarch_pseudo_register_write (gdbarch
, s390_pseudo_register_write
);
3170 set_tdesc_pseudo_register_name (gdbarch
, s390_pseudo_register_name
);
3171 set_tdesc_pseudo_register_type (gdbarch
, s390_pseudo_register_type
);
3172 set_tdesc_pseudo_register_reggroup_p (gdbarch
,
3173 s390_pseudo_register_reggroup_p
);
3174 tdesc_use_registers (gdbarch
, tdesc
, tdesc_data
);
3176 /* Assign pseudo register numbers. */
3177 first_pseudo_reg
= gdbarch_num_regs (gdbarch
);
3178 last_pseudo_reg
= first_pseudo_reg
;
3179 tdep
->gpr_full_regnum
= -1;
3182 tdep
->gpr_full_regnum
= last_pseudo_reg
;
3183 last_pseudo_reg
+= 16;
3185 tdep
->pc_regnum
= last_pseudo_reg
++;
3186 tdep
->cc_regnum
= last_pseudo_reg
++;
3187 set_gdbarch_pc_regnum (gdbarch
, tdep
->pc_regnum
);
3188 set_gdbarch_num_pseudo_regs (gdbarch
, last_pseudo_reg
- first_pseudo_reg
);
3190 /* Inferior function calls. */
3191 set_gdbarch_push_dummy_call (gdbarch
, s390_push_dummy_call
);
3192 set_gdbarch_dummy_id (gdbarch
, s390_dummy_id
);
3193 set_gdbarch_frame_align (gdbarch
, s390_frame_align
);
3194 set_gdbarch_return_value (gdbarch
, s390_return_value
);
3196 /* Frame handling. */
3197 dwarf2_frame_set_init_reg (gdbarch
, s390_dwarf2_frame_init_reg
);
3198 dwarf2_frame_set_adjust_regnum (gdbarch
, s390_adjust_frame_regnum
);
3199 dwarf2_append_unwinders (gdbarch
);
3200 frame_base_append_sniffer (gdbarch
, dwarf2_frame_base_sniffer
);
3201 frame_unwind_append_unwinder (gdbarch
, &s390_stub_frame_unwind
);
3202 frame_unwind_append_unwinder (gdbarch
, &s390_sigtramp_frame_unwind
);
3203 frame_unwind_append_unwinder (gdbarch
, &s390_frame_unwind
);
3204 frame_base_set_default (gdbarch
, &s390_frame_base
);
3205 set_gdbarch_unwind_pc (gdbarch
, s390_unwind_pc
);
3206 set_gdbarch_unwind_sp (gdbarch
, s390_unwind_sp
);
3208 /* Displaced stepping. */
3209 set_gdbarch_displaced_step_copy_insn (gdbarch
,
3210 simple_displaced_step_copy_insn
);
3211 set_gdbarch_displaced_step_fixup (gdbarch
, s390_displaced_step_fixup
);
3212 set_gdbarch_displaced_step_free_closure (gdbarch
,
3213 simple_displaced_step_free_closure
);
3214 set_gdbarch_displaced_step_location (gdbarch
,
3215 displaced_step_at_entry_point
);
3216 set_gdbarch_max_insn_length (gdbarch
, S390_MAX_INSTR_SIZE
);
3218 /* Note that GNU/Linux is the only OS supported on this
3220 linux_init_abi (info
, gdbarch
);
3224 case ABI_LINUX_S390
:
3225 tdep
->gregset
= &s390_gregset
;
3226 tdep
->sizeof_gregset
= s390_sizeof_gregset
;
3227 tdep
->fpregset
= &s390_fpregset
;
3228 tdep
->sizeof_fpregset
= s390_sizeof_fpregset
;
3230 set_gdbarch_addr_bits_remove (gdbarch
, s390_addr_bits_remove
);
3231 set_solib_svr4_fetch_link_map_offsets
3232 (gdbarch
, svr4_ilp32_fetch_link_map_offsets
);
3237 set_gdbarch_core_regset_sections (gdbarch
,
3238 s390_linux64v2_regset_sections
);
3239 else if (have_linux_v1
)
3240 set_gdbarch_core_regset_sections (gdbarch
,
3241 s390_linux64v1_regset_sections
);
3243 set_gdbarch_core_regset_sections (gdbarch
,
3244 s390_linux64_regset_sections
);
3249 set_gdbarch_core_regset_sections (gdbarch
,
3250 s390_linux32v2_regset_sections
);
3251 else if (have_linux_v1
)
3252 set_gdbarch_core_regset_sections (gdbarch
,
3253 s390_linux32v1_regset_sections
);
3255 set_gdbarch_core_regset_sections (gdbarch
,
3256 s390_linux32_regset_sections
);
3260 case ABI_LINUX_ZSERIES
:
3261 tdep
->gregset
= &s390x_gregset
;
3262 tdep
->sizeof_gregset
= s390x_sizeof_gregset
;
3263 tdep
->fpregset
= &s390_fpregset
;
3264 tdep
->sizeof_fpregset
= s390_sizeof_fpregset
;
3266 set_gdbarch_long_bit (gdbarch
, 64);
3267 set_gdbarch_long_long_bit (gdbarch
, 64);
3268 set_gdbarch_ptr_bit (gdbarch
, 64);
3269 set_solib_svr4_fetch_link_map_offsets
3270 (gdbarch
, svr4_lp64_fetch_link_map_offsets
);
3271 set_gdbarch_address_class_type_flags (gdbarch
,
3272 s390_address_class_type_flags
);
3273 set_gdbarch_address_class_type_flags_to_name (gdbarch
,
3274 s390_address_class_type_flags_to_name
);
3275 set_gdbarch_address_class_name_to_type_flags (gdbarch
,
3276 s390_address_class_name_to_type_flags
);
3279 set_gdbarch_core_regset_sections (gdbarch
,
3280 s390x_linux64v2_regset_sections
);
3281 else if (have_linux_v1
)
3282 set_gdbarch_core_regset_sections (gdbarch
,
3283 s390x_linux64v1_regset_sections
);
3285 set_gdbarch_core_regset_sections (gdbarch
,
3286 s390x_linux64_regset_sections
);
3290 set_gdbarch_print_insn (gdbarch
, print_insn_s390
);
3292 set_gdbarch_skip_trampoline_code (gdbarch
, find_solib_trampoline_target
);
3294 /* Enable TLS support. */
3295 set_gdbarch_fetch_tls_load_module_address (gdbarch
,
3296 svr4_fetch_objfile_link_map
);
3298 set_gdbarch_get_siginfo_type (gdbarch
, linux_get_siginfo_type
);
3300 /* SystemTap functions. */
3301 set_gdbarch_stap_register_prefix (gdbarch
, "%");
3302 set_gdbarch_stap_register_indirection_prefix (gdbarch
, "(");
3303 set_gdbarch_stap_register_indirection_suffix (gdbarch
, ")");
3304 set_gdbarch_stap_is_single_operand (gdbarch
, s390_stap_is_single_operand
);
3310 extern initialize_file_ftype _initialize_s390_tdep
; /* -Wmissing-prototypes */
3313 _initialize_s390_tdep (void)
3315 /* Hook us into the gdbarch mechanism. */
3316 register_gdbarch_init (bfd_arch_s390
, s390_gdbarch_init
);
3318 /* Initialize the GNU/Linux target descriptions. */
3319 initialize_tdesc_s390_linux32 ();
3320 initialize_tdesc_s390_linux32v1 ();
3321 initialize_tdesc_s390_linux32v2 ();
3322 initialize_tdesc_s390_linux64 ();
3323 initialize_tdesc_s390_linux64v1 ();
3324 initialize_tdesc_s390_linux64v2 ();
3325 initialize_tdesc_s390x_linux64 ();
3326 initialize_tdesc_s390x_linux64v1 ();
3327 initialize_tdesc_s390x_linux64v2 ();