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
);
379 int len
= TYPE_LENGTH (check_typedef (type
));
381 if (regnum
>= S390_F0_REGNUM
&& regnum
<= S390_F15_REGNUM
&& len
< 8)
382 set_value_offset (value
, 0);
387 /* Register groups. */
390 s390_pseudo_register_reggroup_p (struct gdbarch
*gdbarch
, int regnum
,
391 struct reggroup
*group
)
393 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
395 /* We usually save/restore the whole PSW, which includes PC and CC.
396 However, some older gdbservers may not support saving/restoring
397 the whole PSW yet, and will return an XML register description
398 excluding those from the save/restore register groups. In those
399 cases, we still need to explicitly save/restore PC and CC in order
400 to push or pop frames. Since this doesn't hurt anything if we
401 already save/restore the whole PSW (it's just redundant), we add
402 PC and CC at this point unconditionally. */
403 if (group
== save_reggroup
|| group
== restore_reggroup
)
404 return regnum
== tdep
->pc_regnum
|| regnum
== tdep
->cc_regnum
;
406 return default_register_reggroup_p (gdbarch
, regnum
, group
);
410 /* Core file register sets. */
412 int s390_regmap_gregset
[S390_NUM_REGS
] =
414 /* Program Status Word. */
416 /* General Purpose Registers. */
417 0x08, 0x0c, 0x10, 0x14,
418 0x18, 0x1c, 0x20, 0x24,
419 0x28, 0x2c, 0x30, 0x34,
420 0x38, 0x3c, 0x40, 0x44,
421 /* Access Registers. */
422 0x48, 0x4c, 0x50, 0x54,
423 0x58, 0x5c, 0x60, 0x64,
424 0x68, 0x6c, 0x70, 0x74,
425 0x78, 0x7c, 0x80, 0x84,
426 /* Floating Point Control Word. */
428 /* Floating Point Registers. */
429 -1, -1, -1, -1, -1, -1, -1, -1,
430 -1, -1, -1, -1, -1, -1, -1, -1,
431 /* GPR Uppper Halves. */
432 -1, -1, -1, -1, -1, -1, -1, -1,
433 -1, -1, -1, -1, -1, -1, -1, -1,
434 /* GNU/Linux-specific optional "registers". */
438 int s390x_regmap_gregset
[S390_NUM_REGS
] =
440 /* Program Status Word. */
442 /* General Purpose Registers. */
443 0x10, 0x18, 0x20, 0x28,
444 0x30, 0x38, 0x40, 0x48,
445 0x50, 0x58, 0x60, 0x68,
446 0x70, 0x78, 0x80, 0x88,
447 /* Access Registers. */
448 0x90, 0x94, 0x98, 0x9c,
449 0xa0, 0xa4, 0xa8, 0xac,
450 0xb0, 0xb4, 0xb8, 0xbc,
451 0xc0, 0xc4, 0xc8, 0xcc,
452 /* Floating Point Control Word. */
454 /* Floating Point Registers. */
455 -1, -1, -1, -1, -1, -1, -1, -1,
456 -1, -1, -1, -1, -1, -1, -1, -1,
457 /* GPR Uppper Halves. */
458 0x10, 0x18, 0x20, 0x28,
459 0x30, 0x38, 0x40, 0x48,
460 0x50, 0x58, 0x60, 0x68,
461 0x70, 0x78, 0x80, 0x88,
462 /* GNU/Linux-specific optional "registers". */
466 int s390_regmap_fpregset
[S390_NUM_REGS
] =
468 /* Program Status Word. */
470 /* General Purpose Registers. */
471 -1, -1, -1, -1, -1, -1, -1, -1,
472 -1, -1, -1, -1, -1, -1, -1, -1,
473 /* Access Registers. */
474 -1, -1, -1, -1, -1, -1, -1, -1,
475 -1, -1, -1, -1, -1, -1, -1, -1,
476 /* Floating Point Control Word. */
478 /* Floating Point Registers. */
479 0x08, 0x10, 0x18, 0x20,
480 0x28, 0x30, 0x38, 0x40,
481 0x48, 0x50, 0x58, 0x60,
482 0x68, 0x70, 0x78, 0x80,
483 /* GPR Uppper Halves. */
484 -1, -1, -1, -1, -1, -1, -1, -1,
485 -1, -1, -1, -1, -1, -1, -1, -1,
486 /* GNU/Linux-specific optional "registers". */
490 int s390_regmap_upper
[S390_NUM_REGS
] =
492 /* Program Status Word. */
494 /* General Purpose Registers. */
495 -1, -1, -1, -1, -1, -1, -1, -1,
496 -1, -1, -1, -1, -1, -1, -1, -1,
497 /* Access Registers. */
498 -1, -1, -1, -1, -1, -1, -1, -1,
499 -1, -1, -1, -1, -1, -1, -1, -1,
500 /* Floating Point Control Word. */
502 /* Floating Point Registers. */
503 -1, -1, -1, -1, -1, -1, -1, -1,
504 -1, -1, -1, -1, -1, -1, -1, -1,
505 /* GPR Uppper Halves. */
506 0x00, 0x04, 0x08, 0x0c,
507 0x10, 0x14, 0x18, 0x1c,
508 0x20, 0x24, 0x28, 0x2c,
509 0x30, 0x34, 0x38, 0x3c,
510 /* GNU/Linux-specific optional "registers". */
514 int s390_regmap_last_break
[S390_NUM_REGS
] =
516 /* Program Status Word. */
518 /* General Purpose Registers. */
519 -1, -1, -1, -1, -1, -1, -1, -1,
520 -1, -1, -1, -1, -1, -1, -1, -1,
521 /* Access Registers. */
522 -1, -1, -1, -1, -1, -1, -1, -1,
523 -1, -1, -1, -1, -1, -1, -1, -1,
524 /* Floating Point Control Word. */
526 /* Floating Point Registers. */
527 -1, -1, -1, -1, -1, -1, -1, -1,
528 -1, -1, -1, -1, -1, -1, -1, -1,
529 /* GPR Uppper Halves. */
530 -1, -1, -1, -1, -1, -1, -1, -1,
531 -1, -1, -1, -1, -1, -1, -1, -1,
532 /* GNU/Linux-specific optional "registers". */
536 int s390x_regmap_last_break
[S390_NUM_REGS
] =
538 /* Program Status Word. */
540 /* General Purpose Registers. */
541 -1, -1, -1, -1, -1, -1, -1, -1,
542 -1, -1, -1, -1, -1, -1, -1, -1,
543 /* Access Registers. */
544 -1, -1, -1, -1, -1, -1, -1, -1,
545 -1, -1, -1, -1, -1, -1, -1, -1,
546 /* Floating Point Control Word. */
548 /* Floating Point Registers. */
549 -1, -1, -1, -1, -1, -1, -1, -1,
550 -1, -1, -1, -1, -1, -1, -1, -1,
551 /* GPR Uppper Halves. */
552 -1, -1, -1, -1, -1, -1, -1, -1,
553 -1, -1, -1, -1, -1, -1, -1, -1,
554 /* GNU/Linux-specific optional "registers". */
558 int s390_regmap_system_call
[S390_NUM_REGS
] =
560 /* Program Status Word. */
562 /* General Purpose Registers. */
563 -1, -1, -1, -1, -1, -1, -1, -1,
564 -1, -1, -1, -1, -1, -1, -1, -1,
565 /* Access Registers. */
566 -1, -1, -1, -1, -1, -1, -1, -1,
567 -1, -1, -1, -1, -1, -1, -1, -1,
568 /* Floating Point Control Word. */
570 /* Floating Point Registers. */
571 -1, -1, -1, -1, -1, -1, -1, -1,
572 -1, -1, -1, -1, -1, -1, -1, -1,
573 /* GPR Uppper Halves. */
574 -1, -1, -1, -1, -1, -1, -1, -1,
575 -1, -1, -1, -1, -1, -1, -1, -1,
576 /* GNU/Linux-specific optional "registers". */
580 /* Supply register REGNUM from the register set REGSET to register cache
581 REGCACHE. If REGNUM is -1, do this for all registers in REGSET. */
583 s390_supply_regset (const struct regset
*regset
, struct regcache
*regcache
,
584 int regnum
, const void *regs
, size_t len
)
586 const int *offset
= regset
->descr
;
589 for (i
= 0; i
< S390_NUM_REGS
; i
++)
591 if ((regnum
== i
|| regnum
== -1) && offset
[i
] != -1)
592 regcache_raw_supply (regcache
, i
, (const char *)regs
+ offset
[i
]);
596 /* Collect register REGNUM from the register cache REGCACHE and store
597 it in the buffer specified by REGS and LEN as described by the
598 general-purpose register set REGSET. If REGNUM is -1, do this for
599 all registers in REGSET. */
601 s390_collect_regset (const struct regset
*regset
,
602 const struct regcache
*regcache
,
603 int regnum
, void *regs
, size_t len
)
605 const int *offset
= regset
->descr
;
608 for (i
= 0; i
< S390_NUM_REGS
; i
++)
610 if ((regnum
== i
|| regnum
== -1) && offset
[i
] != -1)
611 regcache_raw_collect (regcache
, i
, (char *)regs
+ offset
[i
]);
615 static const struct regset s390_gregset
= {
621 static const struct regset s390x_gregset
= {
622 s390x_regmap_gregset
,
627 static const struct regset s390_fpregset
= {
628 s390_regmap_fpregset
,
633 static const struct regset s390_upper_regset
= {
639 static const struct regset s390_last_break_regset
= {
640 s390_regmap_last_break
,
645 static const struct regset s390x_last_break_regset
= {
646 s390x_regmap_last_break
,
651 static const struct regset s390_system_call_regset
= {
652 s390_regmap_system_call
,
657 static struct core_regset_section s390_linux32_regset_sections
[] =
659 { ".reg", s390_sizeof_gregset
, "general-purpose" },
660 { ".reg2", s390_sizeof_fpregset
, "floating-point" },
664 static struct core_regset_section s390_linux32v1_regset_sections
[] =
666 { ".reg", s390_sizeof_gregset
, "general-purpose" },
667 { ".reg2", s390_sizeof_fpregset
, "floating-point" },
668 { ".reg-s390-last-break", 8, "s390 last-break address" },
672 static struct core_regset_section s390_linux32v2_regset_sections
[] =
674 { ".reg", s390_sizeof_gregset
, "general-purpose" },
675 { ".reg2", s390_sizeof_fpregset
, "floating-point" },
676 { ".reg-s390-last-break", 8, "s390 last-break address" },
677 { ".reg-s390-system-call", 4, "s390 system-call" },
681 static struct core_regset_section s390_linux64_regset_sections
[] =
683 { ".reg", s390_sizeof_gregset
, "general-purpose" },
684 { ".reg2", s390_sizeof_fpregset
, "floating-point" },
685 { ".reg-s390-high-gprs", 16*4, "s390 GPR upper halves" },
689 static struct core_regset_section s390_linux64v1_regset_sections
[] =
691 { ".reg", s390_sizeof_gregset
, "general-purpose" },
692 { ".reg2", s390_sizeof_fpregset
, "floating-point" },
693 { ".reg-s390-high-gprs", 16*4, "s390 GPR upper halves" },
694 { ".reg-s390-last-break", 8, "s930 last-break address" },
698 static struct core_regset_section s390_linux64v2_regset_sections
[] =
700 { ".reg", s390_sizeof_gregset
, "general-purpose" },
701 { ".reg2", s390_sizeof_fpregset
, "floating-point" },
702 { ".reg-s390-high-gprs", 16*4, "s390 GPR upper halves" },
703 { ".reg-s390-last-break", 8, "s930 last-break address" },
704 { ".reg-s390-system-call", 4, "s390 system-call" },
708 static struct core_regset_section s390x_linux64_regset_sections
[] =
710 { ".reg", s390x_sizeof_gregset
, "general-purpose" },
711 { ".reg2", s390_sizeof_fpregset
, "floating-point" },
715 static struct core_regset_section s390x_linux64v1_regset_sections
[] =
717 { ".reg", s390x_sizeof_gregset
, "general-purpose" },
718 { ".reg2", s390_sizeof_fpregset
, "floating-point" },
719 { ".reg-s390-last-break", 8, "s930 last-break address" },
723 static struct core_regset_section s390x_linux64v2_regset_sections
[] =
725 { ".reg", s390x_sizeof_gregset
, "general-purpose" },
726 { ".reg2", s390_sizeof_fpregset
, "floating-point" },
727 { ".reg-s390-last-break", 8, "s930 last-break address" },
728 { ".reg-s390-system-call", 4, "s390 system-call" },
733 /* Return the appropriate register set for the core section identified
734 by SECT_NAME and SECT_SIZE. */
735 static const struct regset
*
736 s390_regset_from_core_section (struct gdbarch
*gdbarch
,
737 const char *sect_name
, size_t sect_size
)
739 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
741 if (strcmp (sect_name
, ".reg") == 0 && sect_size
>= tdep
->sizeof_gregset
)
742 return tdep
->gregset
;
744 if (strcmp (sect_name
, ".reg2") == 0 && sect_size
>= tdep
->sizeof_fpregset
)
745 return tdep
->fpregset
;
747 if (strcmp (sect_name
, ".reg-s390-high-gprs") == 0 && sect_size
>= 16*4)
748 return &s390_upper_regset
;
750 if (strcmp (sect_name
, ".reg-s390-last-break") == 0 && sect_size
>= 8)
751 return (gdbarch_ptr_bit (gdbarch
) == 32
752 ? &s390_last_break_regset
: &s390x_last_break_regset
);
754 if (strcmp (sect_name
, ".reg-s390-system-call") == 0 && sect_size
>= 4)
755 return &s390_system_call_regset
;
760 static const struct target_desc
*
761 s390_core_read_description (struct gdbarch
*gdbarch
,
762 struct target_ops
*target
, bfd
*abfd
)
764 asection
*high_gprs
= bfd_get_section_by_name (abfd
, ".reg-s390-high-gprs");
765 asection
*v1
= bfd_get_section_by_name (abfd
, ".reg-s390-last-break");
766 asection
*v2
= bfd_get_section_by_name (abfd
, ".reg-s390-system-call");
767 asection
*section
= bfd_get_section_by_name (abfd
, ".reg");
771 switch (bfd_section_size (abfd
, section
))
773 case s390_sizeof_gregset
:
775 return (v2
? tdesc_s390_linux64v2
:
776 v1
? tdesc_s390_linux64v1
: tdesc_s390_linux64
);
778 return (v2
? tdesc_s390_linux32v2
:
779 v1
? tdesc_s390_linux32v1
: tdesc_s390_linux32
);
781 case s390x_sizeof_gregset
:
782 return (v2
? tdesc_s390x_linux64v2
:
783 v1
? tdesc_s390x_linux64v1
: tdesc_s390x_linux64
);
791 /* Decoding S/390 instructions. */
793 /* Named opcode values for the S/390 instructions we recognize. Some
794 instructions have their opcode split across two fields; those are the
795 op1_* and op2_* enums. */
798 op1_lhi
= 0xa7, op2_lhi
= 0x08,
799 op1_lghi
= 0xa7, op2_lghi
= 0x09,
800 op1_lgfi
= 0xc0, op2_lgfi
= 0x01,
804 op1_ly
= 0xe3, op2_ly
= 0x58,
805 op1_lg
= 0xe3, op2_lg
= 0x04,
807 op1_lmy
= 0xeb, op2_lmy
= 0x98,
808 op1_lmg
= 0xeb, op2_lmg
= 0x04,
810 op1_sty
= 0xe3, op2_sty
= 0x50,
811 op1_stg
= 0xe3, op2_stg
= 0x24,
814 op1_stmy
= 0xeb, op2_stmy
= 0x90,
815 op1_stmg
= 0xeb, op2_stmg
= 0x24,
816 op1_aghi
= 0xa7, op2_aghi
= 0x0b,
817 op1_ahi
= 0xa7, op2_ahi
= 0x0a,
818 op1_agfi
= 0xc2, op2_agfi
= 0x08,
819 op1_afi
= 0xc2, op2_afi
= 0x09,
820 op1_algfi
= 0xc2, op2_algfi
= 0x0a,
821 op1_alfi
= 0xc2, op2_alfi
= 0x0b,
825 op1_ay
= 0xe3, op2_ay
= 0x5a,
826 op1_ag
= 0xe3, op2_ag
= 0x08,
827 op1_slgfi
= 0xc2, op2_slgfi
= 0x04,
828 op1_slfi
= 0xc2, op2_slfi
= 0x05,
832 op1_sy
= 0xe3, op2_sy
= 0x5b,
833 op1_sg
= 0xe3, op2_sg
= 0x09,
837 op1_lay
= 0xe3, op2_lay
= 0x71,
838 op1_larl
= 0xc0, op2_larl
= 0x00,
846 op1_bctg
= 0xe3, op2_bctg
= 0x46,
848 op1_bxhg
= 0xeb, op2_bxhg
= 0x44,
850 op1_bxleg
= 0xeb, op2_bxleg
= 0x45,
851 op1_bras
= 0xa7, op2_bras
= 0x05,
852 op1_brasl
= 0xc0, op2_brasl
= 0x05,
853 op1_brc
= 0xa7, op2_brc
= 0x04,
854 op1_brcl
= 0xc0, op2_brcl
= 0x04,
855 op1_brct
= 0xa7, op2_brct
= 0x06,
856 op1_brctg
= 0xa7, op2_brctg
= 0x07,
858 op1_brxhg
= 0xec, op2_brxhg
= 0x44,
860 op1_brxlg
= 0xec, op2_brxlg
= 0x45,
864 /* Read a single instruction from address AT. */
866 #define S390_MAX_INSTR_SIZE 6
868 s390_readinstruction (bfd_byte instr
[], CORE_ADDR at
)
870 static int s390_instrlen
[] = { 2, 4, 4, 6 };
873 if (target_read_memory (at
, &instr
[0], 2))
875 instrlen
= s390_instrlen
[instr
[0] >> 6];
878 if (target_read_memory (at
+ 2, &instr
[2], instrlen
- 2))
885 /* The functions below are for recognizing and decoding S/390
886 instructions of various formats. Each of them checks whether INSN
887 is an instruction of the given format, with the specified opcodes.
888 If it is, it sets the remaining arguments to the values of the
889 instruction's fields, and returns a non-zero value; otherwise, it
892 These functions' arguments appear in the order they appear in the
893 instruction, not in the machine-language form. So, opcodes always
894 come first, even though they're sometimes scattered around the
895 instructions. And displacements appear before base and extension
896 registers, as they do in the assembly syntax, not at the end, as
897 they do in the machine language. */
899 is_ri (bfd_byte
*insn
, int op1
, int op2
, unsigned int *r1
, int *i2
)
901 if (insn
[0] == op1
&& (insn
[1] & 0xf) == op2
)
903 *r1
= (insn
[1] >> 4) & 0xf;
904 /* i2 is a 16-bit signed quantity. */
905 *i2
= (((insn
[2] << 8) | insn
[3]) ^ 0x8000) - 0x8000;
914 is_ril (bfd_byte
*insn
, int op1
, int op2
,
915 unsigned int *r1
, int *i2
)
917 if (insn
[0] == op1
&& (insn
[1] & 0xf) == op2
)
919 *r1
= (insn
[1] >> 4) & 0xf;
920 /* i2 is a signed quantity. If the host 'int' is 32 bits long,
921 no sign extension is necessary, but we don't want to assume
923 *i2
= (((insn
[2] << 24)
926 | (insn
[5])) ^ 0x80000000) - 0x80000000;
935 is_rr (bfd_byte
*insn
, int op
, unsigned int *r1
, unsigned int *r2
)
939 *r1
= (insn
[1] >> 4) & 0xf;
949 is_rre (bfd_byte
*insn
, int op
, unsigned int *r1
, unsigned int *r2
)
951 if (((insn
[0] << 8) | insn
[1]) == op
)
953 /* Yes, insn[3]. insn[2] is unused in RRE format. */
954 *r1
= (insn
[3] >> 4) & 0xf;
964 is_rs (bfd_byte
*insn
, int op
,
965 unsigned int *r1
, unsigned int *r3
, unsigned int *d2
, unsigned int *b2
)
969 *r1
= (insn
[1] >> 4) & 0xf;
971 *b2
= (insn
[2] >> 4) & 0xf;
972 *d2
= ((insn
[2] & 0xf) << 8) | insn
[3];
981 is_rsy (bfd_byte
*insn
, int op1
, int op2
,
982 unsigned int *r1
, unsigned int *r3
, unsigned int *d2
, unsigned int *b2
)
987 *r1
= (insn
[1] >> 4) & 0xf;
989 *b2
= (insn
[2] >> 4) & 0xf;
990 /* The 'long displacement' is a 20-bit signed integer. */
991 *d2
= ((((insn
[2] & 0xf) << 8) | insn
[3] | (insn
[4] << 12))
992 ^ 0x80000) - 0x80000;
1001 is_rsi (bfd_byte
*insn
, int op
,
1002 unsigned int *r1
, unsigned int *r3
, int *i2
)
1006 *r1
= (insn
[1] >> 4) & 0xf;
1007 *r3
= insn
[1] & 0xf;
1008 /* i2 is a 16-bit signed quantity. */
1009 *i2
= (((insn
[2] << 8) | insn
[3]) ^ 0x8000) - 0x8000;
1018 is_rie (bfd_byte
*insn
, int op1
, int op2
,
1019 unsigned int *r1
, unsigned int *r3
, int *i2
)
1024 *r1
= (insn
[1] >> 4) & 0xf;
1025 *r3
= insn
[1] & 0xf;
1026 /* i2 is a 16-bit signed quantity. */
1027 *i2
= (((insn
[2] << 8) | insn
[3]) ^ 0x8000) - 0x8000;
1036 is_rx (bfd_byte
*insn
, int op
,
1037 unsigned int *r1
, unsigned int *d2
, unsigned int *x2
, unsigned int *b2
)
1041 *r1
= (insn
[1] >> 4) & 0xf;
1042 *x2
= insn
[1] & 0xf;
1043 *b2
= (insn
[2] >> 4) & 0xf;
1044 *d2
= ((insn
[2] & 0xf) << 8) | insn
[3];
1053 is_rxy (bfd_byte
*insn
, int op1
, int op2
,
1054 unsigned int *r1
, unsigned int *d2
, unsigned int *x2
, unsigned int *b2
)
1059 *r1
= (insn
[1] >> 4) & 0xf;
1060 *x2
= insn
[1] & 0xf;
1061 *b2
= (insn
[2] >> 4) & 0xf;
1062 /* The 'long displacement' is a 20-bit signed integer. */
1063 *d2
= ((((insn
[2] & 0xf) << 8) | insn
[3] | (insn
[4] << 12))
1064 ^ 0x80000) - 0x80000;
1072 /* Prologue analysis. */
1074 #define S390_NUM_GPRS 16
1075 #define S390_NUM_FPRS 16
1077 struct s390_prologue_data
{
1080 struct pv_area
*stack
;
1082 /* The size and byte-order of a GPR or FPR. */
1085 enum bfd_endian byte_order
;
1087 /* The general-purpose registers. */
1088 pv_t gpr
[S390_NUM_GPRS
];
1090 /* The floating-point registers. */
1091 pv_t fpr
[S390_NUM_FPRS
];
1093 /* The offset relative to the CFA where the incoming GPR N was saved
1094 by the function prologue. 0 if not saved or unknown. */
1095 int gpr_slot
[S390_NUM_GPRS
];
1097 /* Likewise for FPRs. */
1098 int fpr_slot
[S390_NUM_FPRS
];
1100 /* Nonzero if the backchain was saved. This is assumed to be the
1101 case when the incoming SP is saved at the current SP location. */
1102 int back_chain_saved_p
;
1105 /* Return the effective address for an X-style instruction, like:
1109 Here, X2 and B2 are registers, and D2 is a signed 20-bit
1110 constant; the effective address is the sum of all three. If either
1111 X2 or B2 are zero, then it doesn't contribute to the sum --- this
1112 means that r0 can't be used as either X2 or B2. */
1114 s390_addr (struct s390_prologue_data
*data
,
1115 int d2
, unsigned int x2
, unsigned int b2
)
1119 result
= pv_constant (d2
);
1121 result
= pv_add (result
, data
->gpr
[x2
]);
1123 result
= pv_add (result
, data
->gpr
[b2
]);
1128 /* Do a SIZE-byte store of VALUE to D2(X2,B2). */
1130 s390_store (struct s390_prologue_data
*data
,
1131 int d2
, unsigned int x2
, unsigned int b2
, CORE_ADDR size
,
1134 pv_t addr
= s390_addr (data
, d2
, x2
, b2
);
1137 /* Check whether we are storing the backchain. */
1138 offset
= pv_subtract (data
->gpr
[S390_SP_REGNUM
- S390_R0_REGNUM
], addr
);
1140 if (pv_is_constant (offset
) && offset
.k
== 0)
1141 if (size
== data
->gpr_size
1142 && pv_is_register_k (value
, S390_SP_REGNUM
, 0))
1144 data
->back_chain_saved_p
= 1;
1149 /* Check whether we are storing a register into the stack. */
1150 if (!pv_area_store_would_trash (data
->stack
, addr
))
1151 pv_area_store (data
->stack
, addr
, size
, value
);
1154 /* Note: If this is some store we cannot identify, you might think we
1155 should forget our cached values, as any of those might have been hit.
1157 However, we make the assumption that the register save areas are only
1158 ever stored to once in any given function, and we do recognize these
1159 stores. Thus every store we cannot recognize does not hit our data. */
1162 /* Do a SIZE-byte load from D2(X2,B2). */
1164 s390_load (struct s390_prologue_data
*data
,
1165 int d2
, unsigned int x2
, unsigned int b2
, CORE_ADDR size
)
1168 pv_t addr
= s390_addr (data
, d2
, x2
, b2
);
1170 /* If it's a load from an in-line constant pool, then we can
1171 simulate that, under the assumption that the code isn't
1172 going to change between the time the processor actually
1173 executed it creating the current frame, and the time when
1174 we're analyzing the code to unwind past that frame. */
1175 if (pv_is_constant (addr
))
1177 struct target_section
*secp
;
1178 secp
= target_section_by_addr (¤t_target
, addr
.k
);
1180 && (bfd_get_section_flags (secp
->bfd
, secp
->the_bfd_section
)
1182 return pv_constant (read_memory_integer (addr
.k
, size
,
1186 /* Check whether we are accessing one of our save slots. */
1187 return pv_area_fetch (data
->stack
, addr
, size
);
1190 /* Function for finding saved registers in a 'struct pv_area'; we pass
1191 this to pv_area_scan.
1193 If VALUE is a saved register, ADDR says it was saved at a constant
1194 offset from the frame base, and SIZE indicates that the whole
1195 register was saved, record its offset in the reg_offset table in
1196 PROLOGUE_UNTYPED. */
1198 s390_check_for_saved (void *data_untyped
, pv_t addr
,
1199 CORE_ADDR size
, pv_t value
)
1201 struct s390_prologue_data
*data
= data_untyped
;
1204 if (!pv_is_register (addr
, S390_SP_REGNUM
))
1207 offset
= 16 * data
->gpr_size
+ 32 - addr
.k
;
1209 /* If we are storing the original value of a register, we want to
1210 record the CFA offset. If the same register is stored multiple
1211 times, the stack slot with the highest address counts. */
1213 for (i
= 0; i
< S390_NUM_GPRS
; i
++)
1214 if (size
== data
->gpr_size
1215 && pv_is_register_k (value
, S390_R0_REGNUM
+ i
, 0))
1216 if (data
->gpr_slot
[i
] == 0
1217 || data
->gpr_slot
[i
] > offset
)
1219 data
->gpr_slot
[i
] = offset
;
1223 for (i
= 0; i
< S390_NUM_FPRS
; i
++)
1224 if (size
== data
->fpr_size
1225 && pv_is_register_k (value
, S390_F0_REGNUM
+ i
, 0))
1226 if (data
->fpr_slot
[i
] == 0
1227 || data
->fpr_slot
[i
] > offset
)
1229 data
->fpr_slot
[i
] = offset
;
1234 /* Analyze the prologue of the function starting at START_PC,
1235 continuing at most until CURRENT_PC. Initialize DATA to
1236 hold all information we find out about the state of the registers
1237 and stack slots. Return the address of the instruction after
1238 the last one that changed the SP, FP, or back chain; or zero
1241 s390_analyze_prologue (struct gdbarch
*gdbarch
,
1243 CORE_ADDR current_pc
,
1244 struct s390_prologue_data
*data
)
1246 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
1248 /* Our return value:
1249 The address of the instruction after the last one that changed
1250 the SP, FP, or back chain; zero if we got an error trying to
1252 CORE_ADDR result
= start_pc
;
1254 /* The current PC for our abstract interpretation. */
1257 /* The address of the next instruction after that. */
1260 /* Set up everything's initial value. */
1264 data
->stack
= make_pv_area (S390_SP_REGNUM
, gdbarch_addr_bit (gdbarch
));
1266 /* For the purpose of prologue tracking, we consider the GPR size to
1267 be equal to the ABI word size, even if it is actually larger
1268 (i.e. when running a 32-bit binary under a 64-bit kernel). */
1269 data
->gpr_size
= word_size
;
1271 data
->byte_order
= gdbarch_byte_order (gdbarch
);
1273 for (i
= 0; i
< S390_NUM_GPRS
; i
++)
1274 data
->gpr
[i
] = pv_register (S390_R0_REGNUM
+ i
, 0);
1276 for (i
= 0; i
< S390_NUM_FPRS
; i
++)
1277 data
->fpr
[i
] = pv_register (S390_F0_REGNUM
+ i
, 0);
1279 for (i
= 0; i
< S390_NUM_GPRS
; i
++)
1280 data
->gpr_slot
[i
] = 0;
1282 for (i
= 0; i
< S390_NUM_FPRS
; i
++)
1283 data
->fpr_slot
[i
] = 0;
1285 data
->back_chain_saved_p
= 0;
1288 /* Start interpreting instructions, until we hit the frame's
1289 current PC or the first branch instruction. */
1290 for (pc
= start_pc
; pc
> 0 && pc
< current_pc
; pc
= next_pc
)
1292 bfd_byte insn
[S390_MAX_INSTR_SIZE
];
1293 int insn_len
= s390_readinstruction (insn
, pc
);
1295 bfd_byte dummy
[S390_MAX_INSTR_SIZE
] = { 0 };
1296 bfd_byte
*insn32
= word_size
== 4 ? insn
: dummy
;
1297 bfd_byte
*insn64
= word_size
== 8 ? insn
: dummy
;
1299 /* Fields for various kinds of instructions. */
1300 unsigned int b2
, r1
, r2
, x2
, r3
;
1303 /* The values of SP and FP before this instruction,
1304 for detecting instructions that change them. */
1305 pv_t pre_insn_sp
, pre_insn_fp
;
1306 /* Likewise for the flag whether the back chain was saved. */
1307 int pre_insn_back_chain_saved_p
;
1309 /* If we got an error trying to read the instruction, report it. */
1316 next_pc
= pc
+ insn_len
;
1318 pre_insn_sp
= data
->gpr
[S390_SP_REGNUM
- S390_R0_REGNUM
];
1319 pre_insn_fp
= data
->gpr
[S390_FRAME_REGNUM
- S390_R0_REGNUM
];
1320 pre_insn_back_chain_saved_p
= data
->back_chain_saved_p
;
1323 /* LHI r1, i2 --- load halfword immediate. */
1324 /* LGHI r1, i2 --- load halfword immediate (64-bit version). */
1325 /* LGFI r1, i2 --- load fullword immediate. */
1326 if (is_ri (insn32
, op1_lhi
, op2_lhi
, &r1
, &i2
)
1327 || is_ri (insn64
, op1_lghi
, op2_lghi
, &r1
, &i2
)
1328 || is_ril (insn
, op1_lgfi
, op2_lgfi
, &r1
, &i2
))
1329 data
->gpr
[r1
] = pv_constant (i2
);
1331 /* LR r1, r2 --- load from register. */
1332 /* LGR r1, r2 --- load from register (64-bit version). */
1333 else if (is_rr (insn32
, op_lr
, &r1
, &r2
)
1334 || is_rre (insn64
, op_lgr
, &r1
, &r2
))
1335 data
->gpr
[r1
] = data
->gpr
[r2
];
1337 /* L r1, d2(x2, b2) --- load. */
1338 /* LY r1, d2(x2, b2) --- load (long-displacement version). */
1339 /* LG r1, d2(x2, b2) --- load (64-bit version). */
1340 else if (is_rx (insn32
, op_l
, &r1
, &d2
, &x2
, &b2
)
1341 || is_rxy (insn32
, op1_ly
, op2_ly
, &r1
, &d2
, &x2
, &b2
)
1342 || is_rxy (insn64
, op1_lg
, op2_lg
, &r1
, &d2
, &x2
, &b2
))
1343 data
->gpr
[r1
] = s390_load (data
, d2
, x2
, b2
, data
->gpr_size
);
1345 /* ST r1, d2(x2, b2) --- store. */
1346 /* STY r1, d2(x2, b2) --- store (long-displacement version). */
1347 /* STG r1, d2(x2, b2) --- store (64-bit version). */
1348 else if (is_rx (insn32
, op_st
, &r1
, &d2
, &x2
, &b2
)
1349 || is_rxy (insn32
, op1_sty
, op2_sty
, &r1
, &d2
, &x2
, &b2
)
1350 || is_rxy (insn64
, op1_stg
, op2_stg
, &r1
, &d2
, &x2
, &b2
))
1351 s390_store (data
, d2
, x2
, b2
, data
->gpr_size
, data
->gpr
[r1
]);
1353 /* STD r1, d2(x2,b2) --- store floating-point register. */
1354 else if (is_rx (insn
, op_std
, &r1
, &d2
, &x2
, &b2
))
1355 s390_store (data
, d2
, x2
, b2
, data
->fpr_size
, data
->fpr
[r1
]);
1357 /* STM r1, r3, d2(b2) --- store multiple. */
1358 /* STMY r1, r3, d2(b2) --- store multiple (long-displacement
1360 /* STMG r1, r3, d2(b2) --- store multiple (64-bit version). */
1361 else if (is_rs (insn32
, op_stm
, &r1
, &r3
, &d2
, &b2
)
1362 || is_rsy (insn32
, op1_stmy
, op2_stmy
, &r1
, &r3
, &d2
, &b2
)
1363 || is_rsy (insn64
, op1_stmg
, op2_stmg
, &r1
, &r3
, &d2
, &b2
))
1365 for (; r1
<= r3
; r1
++, d2
+= data
->gpr_size
)
1366 s390_store (data
, d2
, 0, b2
, data
->gpr_size
, data
->gpr
[r1
]);
1369 /* AHI r1, i2 --- add halfword immediate. */
1370 /* AGHI r1, i2 --- add halfword immediate (64-bit version). */
1371 /* AFI r1, i2 --- add fullword immediate. */
1372 /* AGFI r1, i2 --- add fullword immediate (64-bit version). */
1373 else if (is_ri (insn32
, op1_ahi
, op2_ahi
, &r1
, &i2
)
1374 || is_ri (insn64
, op1_aghi
, op2_aghi
, &r1
, &i2
)
1375 || is_ril (insn32
, op1_afi
, op2_afi
, &r1
, &i2
)
1376 || is_ril (insn64
, op1_agfi
, op2_agfi
, &r1
, &i2
))
1377 data
->gpr
[r1
] = pv_add_constant (data
->gpr
[r1
], i2
);
1379 /* ALFI r1, i2 --- add logical immediate. */
1380 /* ALGFI r1, i2 --- add logical immediate (64-bit version). */
1381 else if (is_ril (insn32
, op1_alfi
, op2_alfi
, &r1
, &i2
)
1382 || is_ril (insn64
, op1_algfi
, op2_algfi
, &r1
, &i2
))
1383 data
->gpr
[r1
] = pv_add_constant (data
->gpr
[r1
],
1384 (CORE_ADDR
)i2
& 0xffffffff);
1386 /* AR r1, r2 -- add register. */
1387 /* AGR r1, r2 -- add register (64-bit version). */
1388 else if (is_rr (insn32
, op_ar
, &r1
, &r2
)
1389 || is_rre (insn64
, op_agr
, &r1
, &r2
))
1390 data
->gpr
[r1
] = pv_add (data
->gpr
[r1
], data
->gpr
[r2
]);
1392 /* A r1, d2(x2, b2) -- add. */
1393 /* AY r1, d2(x2, b2) -- add (long-displacement version). */
1394 /* AG r1, d2(x2, b2) -- add (64-bit version). */
1395 else if (is_rx (insn32
, op_a
, &r1
, &d2
, &x2
, &b2
)
1396 || is_rxy (insn32
, op1_ay
, op2_ay
, &r1
, &d2
, &x2
, &b2
)
1397 || is_rxy (insn64
, op1_ag
, op2_ag
, &r1
, &d2
, &x2
, &b2
))
1398 data
->gpr
[r1
] = pv_add (data
->gpr
[r1
],
1399 s390_load (data
, d2
, x2
, b2
, data
->gpr_size
));
1401 /* SLFI r1, i2 --- subtract logical immediate. */
1402 /* SLGFI r1, i2 --- subtract logical immediate (64-bit version). */
1403 else if (is_ril (insn32
, op1_slfi
, op2_slfi
, &r1
, &i2
)
1404 || is_ril (insn64
, op1_slgfi
, op2_slgfi
, &r1
, &i2
))
1405 data
->gpr
[r1
] = pv_add_constant (data
->gpr
[r1
],
1406 -((CORE_ADDR
)i2
& 0xffffffff));
1408 /* SR r1, r2 -- subtract register. */
1409 /* SGR r1, r2 -- subtract register (64-bit version). */
1410 else if (is_rr (insn32
, op_sr
, &r1
, &r2
)
1411 || is_rre (insn64
, op_sgr
, &r1
, &r2
))
1412 data
->gpr
[r1
] = pv_subtract (data
->gpr
[r1
], data
->gpr
[r2
]);
1414 /* S r1, d2(x2, b2) -- subtract. */
1415 /* SY r1, d2(x2, b2) -- subtract (long-displacement version). */
1416 /* SG r1, d2(x2, b2) -- subtract (64-bit version). */
1417 else if (is_rx (insn32
, op_s
, &r1
, &d2
, &x2
, &b2
)
1418 || is_rxy (insn32
, op1_sy
, op2_sy
, &r1
, &d2
, &x2
, &b2
)
1419 || is_rxy (insn64
, op1_sg
, op2_sg
, &r1
, &d2
, &x2
, &b2
))
1420 data
->gpr
[r1
] = pv_subtract (data
->gpr
[r1
],
1421 s390_load (data
, d2
, x2
, b2
, data
->gpr_size
));
1423 /* LA r1, d2(x2, b2) --- load address. */
1424 /* LAY r1, d2(x2, b2) --- load address (long-displacement version). */
1425 else if (is_rx (insn
, op_la
, &r1
, &d2
, &x2
, &b2
)
1426 || is_rxy (insn
, op1_lay
, op2_lay
, &r1
, &d2
, &x2
, &b2
))
1427 data
->gpr
[r1
] = s390_addr (data
, d2
, x2
, b2
);
1429 /* LARL r1, i2 --- load address relative long. */
1430 else if (is_ril (insn
, op1_larl
, op2_larl
, &r1
, &i2
))
1431 data
->gpr
[r1
] = pv_constant (pc
+ i2
* 2);
1433 /* BASR r1, 0 --- branch and save.
1434 Since r2 is zero, this saves the PC in r1, but doesn't branch. */
1435 else if (is_rr (insn
, op_basr
, &r1
, &r2
)
1437 data
->gpr
[r1
] = pv_constant (next_pc
);
1439 /* BRAS r1, i2 --- branch relative and save. */
1440 else if (is_ri (insn
, op1_bras
, op2_bras
, &r1
, &i2
))
1442 data
->gpr
[r1
] = pv_constant (next_pc
);
1443 next_pc
= pc
+ i2
* 2;
1445 /* We'd better not interpret any backward branches. We'll
1451 /* Terminate search when hitting any other branch instruction. */
1452 else if (is_rr (insn
, op_basr
, &r1
, &r2
)
1453 || is_rx (insn
, op_bas
, &r1
, &d2
, &x2
, &b2
)
1454 || is_rr (insn
, op_bcr
, &r1
, &r2
)
1455 || is_rx (insn
, op_bc
, &r1
, &d2
, &x2
, &b2
)
1456 || is_ri (insn
, op1_brc
, op2_brc
, &r1
, &i2
)
1457 || is_ril (insn
, op1_brcl
, op2_brcl
, &r1
, &i2
)
1458 || is_ril (insn
, op1_brasl
, op2_brasl
, &r2
, &i2
))
1462 /* An instruction we don't know how to simulate. The only
1463 safe thing to do would be to set every value we're tracking
1464 to 'unknown'. Instead, we'll be optimistic: we assume that
1465 we *can* interpret every instruction that the compiler uses
1466 to manipulate any of the data we're interested in here --
1467 then we can just ignore anything else. */
1470 /* Record the address after the last instruction that changed
1471 the FP, SP, or backlink. Ignore instructions that changed
1472 them back to their original values --- those are probably
1473 restore instructions. (The back chain is never restored,
1476 pv_t sp
= data
->gpr
[S390_SP_REGNUM
- S390_R0_REGNUM
];
1477 pv_t fp
= data
->gpr
[S390_FRAME_REGNUM
- S390_R0_REGNUM
];
1479 if ((! pv_is_identical (pre_insn_sp
, sp
)
1480 && ! pv_is_register_k (sp
, S390_SP_REGNUM
, 0)
1481 && sp
.kind
!= pvk_unknown
)
1482 || (! pv_is_identical (pre_insn_fp
, fp
)
1483 && ! pv_is_register_k (fp
, S390_FRAME_REGNUM
, 0)
1484 && fp
.kind
!= pvk_unknown
)
1485 || pre_insn_back_chain_saved_p
!= data
->back_chain_saved_p
)
1490 /* Record where all the registers were saved. */
1491 pv_area_scan (data
->stack
, s390_check_for_saved
, data
);
1493 free_pv_area (data
->stack
);
1499 /* Advance PC across any function entry prologue instructions to reach
1500 some "real" code. */
1502 s390_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
1504 struct s390_prologue_data data
;
1506 skip_pc
= s390_analyze_prologue (gdbarch
, pc
, (CORE_ADDR
)-1, &data
);
1507 return skip_pc
? skip_pc
: pc
;
1510 /* Return true if we are in the functin's epilogue, i.e. after the
1511 instruction that destroyed the function's stack frame. */
1513 s390_in_function_epilogue_p (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
1515 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
1517 /* In frameless functions, there's not frame to destroy and thus
1518 we don't care about the epilogue.
1520 In functions with frame, the epilogue sequence is a pair of
1521 a LM-type instruction that restores (amongst others) the
1522 return register %r14 and the stack pointer %r15, followed
1523 by a branch 'br %r14' --or equivalent-- that effects the
1526 In that situation, this function needs to return 'true' in
1527 exactly one case: when pc points to that branch instruction.
1529 Thus we try to disassemble the one instructions immediately
1530 preceding pc and check whether it is an LM-type instruction
1531 modifying the stack pointer.
1533 Note that disassembling backwards is not reliable, so there
1534 is a slight chance of false positives here ... */
1537 unsigned int r1
, r3
, b2
;
1541 && !target_read_memory (pc
- 4, insn
, 4)
1542 && is_rs (insn
, op_lm
, &r1
, &r3
, &d2
, &b2
)
1543 && r3
== S390_SP_REGNUM
- S390_R0_REGNUM
)
1547 && !target_read_memory (pc
- 6, insn
, 6)
1548 && is_rsy (insn
, op1_lmy
, op2_lmy
, &r1
, &r3
, &d2
, &b2
)
1549 && r3
== S390_SP_REGNUM
- S390_R0_REGNUM
)
1553 && !target_read_memory (pc
- 6, insn
, 6)
1554 && is_rsy (insn
, op1_lmg
, op2_lmg
, &r1
, &r3
, &d2
, &b2
)
1555 && r3
== S390_SP_REGNUM
- S390_R0_REGNUM
)
1561 /* Displaced stepping. */
1563 /* Fix up the state of registers and memory after having single-stepped
1564 a displaced instruction. */
1566 s390_displaced_step_fixup (struct gdbarch
*gdbarch
,
1567 struct displaced_step_closure
*closure
,
1568 CORE_ADDR from
, CORE_ADDR to
,
1569 struct regcache
*regs
)
1571 /* Since we use simple_displaced_step_copy_insn, our closure is a
1572 copy of the instruction. */
1573 gdb_byte
*insn
= (gdb_byte
*) closure
;
1574 static int s390_instrlen
[] = { 2, 4, 4, 6 };
1575 int insnlen
= s390_instrlen
[insn
[0] >> 6];
1577 /* Fields for various kinds of instructions. */
1578 unsigned int b2
, r1
, r2
, x2
, r3
;
1581 /* Get current PC and addressing mode bit. */
1582 CORE_ADDR pc
= regcache_read_pc (regs
);
1585 if (register_size (gdbarch
, S390_PSWA_REGNUM
) == 4)
1587 regcache_cooked_read_unsigned (regs
, S390_PSWA_REGNUM
, &amode
);
1588 amode
&= 0x80000000;
1591 if (debug_displaced
)
1592 fprintf_unfiltered (gdb_stdlog
,
1593 "displaced: (s390) fixup (%s, %s) pc %s len %d amode 0x%x\n",
1594 paddress (gdbarch
, from
), paddress (gdbarch
, to
),
1595 paddress (gdbarch
, pc
), insnlen
, (int) amode
);
1597 /* Handle absolute branch and save instructions. */
1598 if (is_rr (insn
, op_basr
, &r1
, &r2
)
1599 || is_rx (insn
, op_bas
, &r1
, &d2
, &x2
, &b2
))
1601 /* Recompute saved return address in R1. */
1602 regcache_cooked_write_unsigned (regs
, S390_R0_REGNUM
+ r1
,
1603 amode
| (from
+ insnlen
));
1606 /* Handle absolute branch instructions. */
1607 else if (is_rr (insn
, op_bcr
, &r1
, &r2
)
1608 || is_rx (insn
, op_bc
, &r1
, &d2
, &x2
, &b2
)
1609 || is_rr (insn
, op_bctr
, &r1
, &r2
)
1610 || is_rre (insn
, op_bctgr
, &r1
, &r2
)
1611 || is_rx (insn
, op_bct
, &r1
, &d2
, &x2
, &b2
)
1612 || is_rxy (insn
, op1_bctg
, op2_brctg
, &r1
, &d2
, &x2
, &b2
)
1613 || is_rs (insn
, op_bxh
, &r1
, &r3
, &d2
, &b2
)
1614 || is_rsy (insn
, op1_bxhg
, op2_bxhg
, &r1
, &r3
, &d2
, &b2
)
1615 || is_rs (insn
, op_bxle
, &r1
, &r3
, &d2
, &b2
)
1616 || is_rsy (insn
, op1_bxleg
, op2_bxleg
, &r1
, &r3
, &d2
, &b2
))
1618 /* Update PC iff branch was *not* taken. */
1619 if (pc
== to
+ insnlen
)
1620 regcache_write_pc (regs
, from
+ insnlen
);
1623 /* Handle PC-relative branch and save instructions. */
1624 else if (is_ri (insn
, op1_bras
, op2_bras
, &r1
, &i2
)
1625 || is_ril (insn
, op1_brasl
, op2_brasl
, &r1
, &i2
))
1628 regcache_write_pc (regs
, pc
- to
+ from
);
1629 /* Recompute saved return address in R1. */
1630 regcache_cooked_write_unsigned (regs
, S390_R0_REGNUM
+ r1
,
1631 amode
| (from
+ insnlen
));
1634 /* Handle PC-relative branch instructions. */
1635 else if (is_ri (insn
, op1_brc
, op2_brc
, &r1
, &i2
)
1636 || is_ril (insn
, op1_brcl
, op2_brcl
, &r1
, &i2
)
1637 || is_ri (insn
, op1_brct
, op2_brct
, &r1
, &i2
)
1638 || is_ri (insn
, op1_brctg
, op2_brctg
, &r1
, &i2
)
1639 || is_rsi (insn
, op_brxh
, &r1
, &r3
, &i2
)
1640 || is_rie (insn
, op1_brxhg
, op2_brxhg
, &r1
, &r3
, &i2
)
1641 || is_rsi (insn
, op_brxle
, &r1
, &r3
, &i2
)
1642 || is_rie (insn
, op1_brxlg
, op2_brxlg
, &r1
, &r3
, &i2
))
1645 regcache_write_pc (regs
, pc
- to
+ from
);
1648 /* Handle LOAD ADDRESS RELATIVE LONG. */
1649 else if (is_ril (insn
, op1_larl
, op2_larl
, &r1
, &i2
))
1652 regcache_write_pc (regs
, from
+ insnlen
);
1653 /* Recompute output address in R1. */
1654 regcache_cooked_write_unsigned (regs
, S390_R0_REGNUM
+ r1
,
1655 amode
| (from
+ i2
* 2));
1658 /* If we executed a breakpoint instruction, point PC right back at it. */
1659 else if (insn
[0] == 0x0 && insn
[1] == 0x1)
1660 regcache_write_pc (regs
, from
);
1662 /* For any other insn, PC points right after the original instruction. */
1664 regcache_write_pc (regs
, from
+ insnlen
);
1666 if (debug_displaced
)
1667 fprintf_unfiltered (gdb_stdlog
,
1668 "displaced: (s390) pc is now %s\n",
1669 paddress (gdbarch
, regcache_read_pc (regs
)));
1673 /* Helper routine to unwind pseudo registers. */
1675 static struct value
*
1676 s390_unwind_pseudo_register (struct frame_info
*this_frame
, int regnum
)
1678 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1679 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1680 struct type
*type
= register_type (gdbarch
, regnum
);
1682 /* Unwind PC via PSW address. */
1683 if (regnum
== tdep
->pc_regnum
)
1687 val
= frame_unwind_register_value (this_frame
, S390_PSWA_REGNUM
);
1688 if (!value_optimized_out (val
))
1690 LONGEST pswa
= value_as_long (val
);
1692 if (TYPE_LENGTH (type
) == 4)
1693 return value_from_pointer (type
, pswa
& 0x7fffffff);
1695 return value_from_pointer (type
, pswa
);
1699 /* Unwind CC via PSW mask. */
1700 if (regnum
== tdep
->cc_regnum
)
1704 val
= frame_unwind_register_value (this_frame
, S390_PSWM_REGNUM
);
1705 if (!value_optimized_out (val
))
1707 LONGEST pswm
= value_as_long (val
);
1709 if (TYPE_LENGTH (type
) == 4)
1710 return value_from_longest (type
, (pswm
>> 12) & 3);
1712 return value_from_longest (type
, (pswm
>> 44) & 3);
1716 /* Unwind full GPRs to show at least the lower halves (as the
1717 upper halves are undefined). */
1718 if (tdep
->gpr_full_regnum
!= -1
1719 && regnum
>= tdep
->gpr_full_regnum
1720 && regnum
< tdep
->gpr_full_regnum
+ 16)
1722 int reg
= regnum
- tdep
->gpr_full_regnum
;
1725 val
= frame_unwind_register_value (this_frame
, S390_R0_REGNUM
+ reg
);
1726 if (!value_optimized_out (val
))
1727 return value_cast (type
, val
);
1730 return allocate_optimized_out_value (type
);
1733 static struct value
*
1734 s390_trad_frame_prev_register (struct frame_info
*this_frame
,
1735 struct trad_frame_saved_reg saved_regs
[],
1738 if (regnum
< S390_NUM_REGS
)
1739 return trad_frame_get_prev_register (this_frame
, saved_regs
, regnum
);
1741 return s390_unwind_pseudo_register (this_frame
, regnum
);
1745 /* Normal stack frames. */
1747 struct s390_unwind_cache
{
1750 CORE_ADDR frame_base
;
1751 CORE_ADDR local_base
;
1753 struct trad_frame_saved_reg
*saved_regs
;
1757 s390_prologue_frame_unwind_cache (struct frame_info
*this_frame
,
1758 struct s390_unwind_cache
*info
)
1760 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1761 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
1762 struct s390_prologue_data data
;
1763 pv_t
*fp
= &data
.gpr
[S390_FRAME_REGNUM
- S390_R0_REGNUM
];
1764 pv_t
*sp
= &data
.gpr
[S390_SP_REGNUM
- S390_R0_REGNUM
];
1773 struct frame_info
*next_frame
;
1775 /* Try to find the function start address. If we can't find it, we don't
1776 bother searching for it -- with modern compilers this would be mostly
1777 pointless anyway. Trust that we'll either have valid DWARF-2 CFI data
1778 or else a valid backchain ... */
1779 func
= get_frame_func (this_frame
);
1783 /* Try to analyze the prologue. */
1784 result
= s390_analyze_prologue (gdbarch
, func
,
1785 get_frame_pc (this_frame
), &data
);
1789 /* If this was successful, we should have found the instruction that
1790 sets the stack pointer register to the previous value of the stack
1791 pointer minus the frame size. */
1792 if (!pv_is_register (*sp
, S390_SP_REGNUM
))
1795 /* A frame size of zero at this point can mean either a real
1796 frameless function, or else a failure to find the prologue.
1797 Perform some sanity checks to verify we really have a
1798 frameless function. */
1801 /* If the next frame is a NORMAL_FRAME, this frame *cannot* have frame
1802 size zero. This is only possible if the next frame is a sentinel
1803 frame, a dummy frame, or a signal trampoline frame. */
1804 /* FIXME: cagney/2004-05-01: This sanity check shouldn't be
1805 needed, instead the code should simpliy rely on its
1807 next_frame
= get_next_frame (this_frame
);
1808 while (next_frame
&& get_frame_type (next_frame
) == INLINE_FRAME
)
1809 next_frame
= get_next_frame (next_frame
);
1811 && get_frame_type (get_next_frame (this_frame
)) == NORMAL_FRAME
)
1814 /* If we really have a frameless function, %r14 must be valid
1815 -- in particular, it must point to a different function. */
1816 reg
= get_frame_register_unsigned (this_frame
, S390_RETADDR_REGNUM
);
1817 reg
= gdbarch_addr_bits_remove (gdbarch
, reg
) - 1;
1818 if (get_pc_function_start (reg
) == func
)
1820 /* However, there is one case where it *is* valid for %r14
1821 to point to the same function -- if this is a recursive
1822 call, and we have stopped in the prologue *before* the
1823 stack frame was allocated.
1825 Recognize this case by looking ahead a bit ... */
1827 struct s390_prologue_data data2
;
1828 pv_t
*sp
= &data2
.gpr
[S390_SP_REGNUM
- S390_R0_REGNUM
];
1830 if (!(s390_analyze_prologue (gdbarch
, func
, (CORE_ADDR
)-1, &data2
)
1831 && pv_is_register (*sp
, S390_SP_REGNUM
)
1838 /* OK, we've found valid prologue data. */
1841 /* If the frame pointer originally also holds the same value
1842 as the stack pointer, we're probably using it. If it holds
1843 some other value -- even a constant offset -- it is most
1844 likely used as temp register. */
1845 if (pv_is_identical (*sp
, *fp
))
1846 frame_pointer
= S390_FRAME_REGNUM
;
1848 frame_pointer
= S390_SP_REGNUM
;
1850 /* If we've detected a function with stack frame, we'll still have to
1851 treat it as frameless if we're currently within the function epilog
1852 code at a point where the frame pointer has already been restored.
1853 This can only happen in an innermost frame. */
1854 /* FIXME: cagney/2004-05-01: This sanity check shouldn't be needed,
1855 instead the code should simpliy rely on its analysis. */
1856 next_frame
= get_next_frame (this_frame
);
1857 while (next_frame
&& get_frame_type (next_frame
) == INLINE_FRAME
)
1858 next_frame
= get_next_frame (next_frame
);
1860 && (next_frame
== NULL
1861 || get_frame_type (get_next_frame (this_frame
)) != NORMAL_FRAME
))
1863 /* See the comment in s390_in_function_epilogue_p on why this is
1864 not completely reliable ... */
1865 if (s390_in_function_epilogue_p (gdbarch
, get_frame_pc (this_frame
)))
1867 memset (&data
, 0, sizeof (data
));
1869 frame_pointer
= S390_SP_REGNUM
;
1873 /* Once we know the frame register and the frame size, we can unwind
1874 the current value of the frame register from the next frame, and
1875 add back the frame size to arrive that the previous frame's
1876 stack pointer value. */
1877 prev_sp
= get_frame_register_unsigned (this_frame
, frame_pointer
) + size
;
1878 cfa
= prev_sp
+ 16*word_size
+ 32;
1880 /* Set up ABI call-saved/call-clobbered registers. */
1881 for (i
= 0; i
< S390_NUM_REGS
; i
++)
1882 if (!s390_register_call_saved (gdbarch
, i
))
1883 trad_frame_set_unknown (info
->saved_regs
, i
);
1885 /* CC is always call-clobbered. */
1886 trad_frame_set_unknown (info
->saved_regs
, S390_PSWM_REGNUM
);
1888 /* Record the addresses of all register spill slots the prologue parser
1889 has recognized. Consider only registers defined as call-saved by the
1890 ABI; for call-clobbered registers the parser may have recognized
1893 for (i
= 0; i
< 16; i
++)
1894 if (s390_register_call_saved (gdbarch
, S390_R0_REGNUM
+ i
)
1895 && data
.gpr_slot
[i
] != 0)
1896 info
->saved_regs
[S390_R0_REGNUM
+ i
].addr
= cfa
- data
.gpr_slot
[i
];
1898 for (i
= 0; i
< 16; i
++)
1899 if (s390_register_call_saved (gdbarch
, S390_F0_REGNUM
+ i
)
1900 && data
.fpr_slot
[i
] != 0)
1901 info
->saved_regs
[S390_F0_REGNUM
+ i
].addr
= cfa
- data
.fpr_slot
[i
];
1903 /* Function return will set PC to %r14. */
1904 info
->saved_regs
[S390_PSWA_REGNUM
] = info
->saved_regs
[S390_RETADDR_REGNUM
];
1906 /* In frameless functions, we unwind simply by moving the return
1907 address to the PC. However, if we actually stored to the
1908 save area, use that -- we might only think the function frameless
1909 because we're in the middle of the prologue ... */
1911 && !trad_frame_addr_p (info
->saved_regs
, S390_PSWA_REGNUM
))
1913 info
->saved_regs
[S390_PSWA_REGNUM
].realreg
= S390_RETADDR_REGNUM
;
1916 /* Another sanity check: unless this is a frameless function,
1917 we should have found spill slots for SP and PC.
1918 If not, we cannot unwind further -- this happens e.g. in
1919 libc's thread_start routine. */
1922 if (!trad_frame_addr_p (info
->saved_regs
, S390_SP_REGNUM
)
1923 || !trad_frame_addr_p (info
->saved_regs
, S390_PSWA_REGNUM
))
1927 /* We use the current value of the frame register as local_base,
1928 and the top of the register save area as frame_base. */
1931 info
->frame_base
= prev_sp
+ 16*word_size
+ 32;
1932 info
->local_base
= prev_sp
- size
;
1940 s390_backchain_frame_unwind_cache (struct frame_info
*this_frame
,
1941 struct s390_unwind_cache
*info
)
1943 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1944 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
1945 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1946 CORE_ADDR backchain
;
1951 /* Set up ABI call-saved/call-clobbered registers. */
1952 for (i
= 0; i
< S390_NUM_REGS
; i
++)
1953 if (!s390_register_call_saved (gdbarch
, i
))
1954 trad_frame_set_unknown (info
->saved_regs
, i
);
1956 /* CC is always call-clobbered. */
1957 trad_frame_set_unknown (info
->saved_regs
, S390_PSWM_REGNUM
);
1959 /* Get the backchain. */
1960 reg
= get_frame_register_unsigned (this_frame
, S390_SP_REGNUM
);
1961 backchain
= read_memory_unsigned_integer (reg
, word_size
, byte_order
);
1963 /* A zero backchain terminates the frame chain. As additional
1964 sanity check, let's verify that the spill slot for SP in the
1965 save area pointed to by the backchain in fact links back to
1968 && safe_read_memory_integer (backchain
+ 15*word_size
,
1969 word_size
, byte_order
, &sp
)
1970 && (CORE_ADDR
)sp
== backchain
)
1972 /* We don't know which registers were saved, but it will have
1973 to be at least %r14 and %r15. This will allow us to continue
1974 unwinding, but other prev-frame registers may be incorrect ... */
1975 info
->saved_regs
[S390_SP_REGNUM
].addr
= backchain
+ 15*word_size
;
1976 info
->saved_regs
[S390_RETADDR_REGNUM
].addr
= backchain
+ 14*word_size
;
1978 /* Function return will set PC to %r14. */
1979 info
->saved_regs
[S390_PSWA_REGNUM
]
1980 = info
->saved_regs
[S390_RETADDR_REGNUM
];
1982 /* We use the current value of the frame register as local_base,
1983 and the top of the register save area as frame_base. */
1984 info
->frame_base
= backchain
+ 16*word_size
+ 32;
1985 info
->local_base
= reg
;
1988 info
->func
= get_frame_pc (this_frame
);
1991 static struct s390_unwind_cache
*
1992 s390_frame_unwind_cache (struct frame_info
*this_frame
,
1993 void **this_prologue_cache
)
1995 struct s390_unwind_cache
*info
;
1996 if (*this_prologue_cache
)
1997 return *this_prologue_cache
;
1999 info
= FRAME_OBSTACK_ZALLOC (struct s390_unwind_cache
);
2000 *this_prologue_cache
= info
;
2001 info
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
2003 info
->frame_base
= -1;
2004 info
->local_base
= -1;
2006 /* Try to use prologue analysis to fill the unwind cache.
2007 If this fails, fall back to reading the stack backchain. */
2008 if (!s390_prologue_frame_unwind_cache (this_frame
, info
))
2009 s390_backchain_frame_unwind_cache (this_frame
, info
);
2015 s390_frame_this_id (struct frame_info
*this_frame
,
2016 void **this_prologue_cache
,
2017 struct frame_id
*this_id
)
2019 struct s390_unwind_cache
*info
2020 = s390_frame_unwind_cache (this_frame
, this_prologue_cache
);
2022 if (info
->frame_base
== -1)
2025 *this_id
= frame_id_build (info
->frame_base
, info
->func
);
2028 static struct value
*
2029 s390_frame_prev_register (struct frame_info
*this_frame
,
2030 void **this_prologue_cache
, int regnum
)
2032 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2033 struct s390_unwind_cache
*info
2034 = s390_frame_unwind_cache (this_frame
, this_prologue_cache
);
2036 return s390_trad_frame_prev_register (this_frame
, info
->saved_regs
, regnum
);
2039 static const struct frame_unwind s390_frame_unwind
= {
2041 default_frame_unwind_stop_reason
,
2043 s390_frame_prev_register
,
2045 default_frame_sniffer
2049 /* Code stubs and their stack frames. For things like PLTs and NULL
2050 function calls (where there is no true frame and the return address
2051 is in the RETADDR register). */
2053 struct s390_stub_unwind_cache
2055 CORE_ADDR frame_base
;
2056 struct trad_frame_saved_reg
*saved_regs
;
2059 static struct s390_stub_unwind_cache
*
2060 s390_stub_frame_unwind_cache (struct frame_info
*this_frame
,
2061 void **this_prologue_cache
)
2063 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2064 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
2065 struct s390_stub_unwind_cache
*info
;
2068 if (*this_prologue_cache
)
2069 return *this_prologue_cache
;
2071 info
= FRAME_OBSTACK_ZALLOC (struct s390_stub_unwind_cache
);
2072 *this_prologue_cache
= info
;
2073 info
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
2075 /* The return address is in register %r14. */
2076 info
->saved_regs
[S390_PSWA_REGNUM
].realreg
= S390_RETADDR_REGNUM
;
2078 /* Retrieve stack pointer and determine our frame base. */
2079 reg
= get_frame_register_unsigned (this_frame
, S390_SP_REGNUM
);
2080 info
->frame_base
= reg
+ 16*word_size
+ 32;
2086 s390_stub_frame_this_id (struct frame_info
*this_frame
,
2087 void **this_prologue_cache
,
2088 struct frame_id
*this_id
)
2090 struct s390_stub_unwind_cache
*info
2091 = s390_stub_frame_unwind_cache (this_frame
, this_prologue_cache
);
2092 *this_id
= frame_id_build (info
->frame_base
, get_frame_pc (this_frame
));
2095 static struct value
*
2096 s390_stub_frame_prev_register (struct frame_info
*this_frame
,
2097 void **this_prologue_cache
, int regnum
)
2099 struct s390_stub_unwind_cache
*info
2100 = s390_stub_frame_unwind_cache (this_frame
, this_prologue_cache
);
2101 return s390_trad_frame_prev_register (this_frame
, info
->saved_regs
, regnum
);
2105 s390_stub_frame_sniffer (const struct frame_unwind
*self
,
2106 struct frame_info
*this_frame
,
2107 void **this_prologue_cache
)
2109 CORE_ADDR addr_in_block
;
2110 bfd_byte insn
[S390_MAX_INSTR_SIZE
];
2112 /* If the current PC points to non-readable memory, we assume we
2113 have trapped due to an invalid function pointer call. We handle
2114 the non-existing current function like a PLT stub. */
2115 addr_in_block
= get_frame_address_in_block (this_frame
);
2116 if (in_plt_section (addr_in_block
, NULL
)
2117 || s390_readinstruction (insn
, get_frame_pc (this_frame
)) < 0)
2122 static const struct frame_unwind s390_stub_frame_unwind
= {
2124 default_frame_unwind_stop_reason
,
2125 s390_stub_frame_this_id
,
2126 s390_stub_frame_prev_register
,
2128 s390_stub_frame_sniffer
2132 /* Signal trampoline stack frames. */
2134 struct s390_sigtramp_unwind_cache
{
2135 CORE_ADDR frame_base
;
2136 struct trad_frame_saved_reg
*saved_regs
;
2139 static struct s390_sigtramp_unwind_cache
*
2140 s390_sigtramp_frame_unwind_cache (struct frame_info
*this_frame
,
2141 void **this_prologue_cache
)
2143 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2144 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2145 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
2146 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2147 struct s390_sigtramp_unwind_cache
*info
;
2148 ULONGEST this_sp
, prev_sp
;
2149 CORE_ADDR next_ra
, next_cfa
, sigreg_ptr
, sigreg_high_off
;
2152 if (*this_prologue_cache
)
2153 return *this_prologue_cache
;
2155 info
= FRAME_OBSTACK_ZALLOC (struct s390_sigtramp_unwind_cache
);
2156 *this_prologue_cache
= info
;
2157 info
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
2159 this_sp
= get_frame_register_unsigned (this_frame
, S390_SP_REGNUM
);
2160 next_ra
= get_frame_pc (this_frame
);
2161 next_cfa
= this_sp
+ 16*word_size
+ 32;
2163 /* New-style RT frame:
2164 retcode + alignment (8 bytes)
2166 ucontext (contains sigregs at offset 5 words). */
2167 if (next_ra
== next_cfa
)
2169 sigreg_ptr
= next_cfa
+ 8 + 128 + align_up (5*word_size
, 8);
2170 /* sigregs are followed by uc_sigmask (8 bytes), then by the
2171 upper GPR halves if present. */
2172 sigreg_high_off
= 8;
2175 /* Old-style RT frame and all non-RT frames:
2176 old signal mask (8 bytes)
2177 pointer to sigregs. */
2180 sigreg_ptr
= read_memory_unsigned_integer (next_cfa
+ 8,
2181 word_size
, byte_order
);
2182 /* sigregs are followed by signo (4 bytes), then by the
2183 upper GPR halves if present. */
2184 sigreg_high_off
= 4;
2187 /* The sigregs structure looks like this:
2196 /* PSW mask and address. */
2197 info
->saved_regs
[S390_PSWM_REGNUM
].addr
= sigreg_ptr
;
2198 sigreg_ptr
+= word_size
;
2199 info
->saved_regs
[S390_PSWA_REGNUM
].addr
= sigreg_ptr
;
2200 sigreg_ptr
+= word_size
;
2202 /* Then the GPRs. */
2203 for (i
= 0; i
< 16; i
++)
2205 info
->saved_regs
[S390_R0_REGNUM
+ i
].addr
= sigreg_ptr
;
2206 sigreg_ptr
+= word_size
;
2209 /* Then the ACRs. */
2210 for (i
= 0; i
< 16; i
++)
2212 info
->saved_regs
[S390_A0_REGNUM
+ i
].addr
= sigreg_ptr
;
2216 /* The floating-point control word. */
2217 info
->saved_regs
[S390_FPC_REGNUM
].addr
= sigreg_ptr
;
2220 /* And finally the FPRs. */
2221 for (i
= 0; i
< 16; i
++)
2223 info
->saved_regs
[S390_F0_REGNUM
+ i
].addr
= sigreg_ptr
;
2227 /* If we have them, the GPR upper halves are appended at the end. */
2228 sigreg_ptr
+= sigreg_high_off
;
2229 if (tdep
->gpr_full_regnum
!= -1)
2230 for (i
= 0; i
< 16; i
++)
2232 info
->saved_regs
[S390_R0_UPPER_REGNUM
+ i
].addr
= sigreg_ptr
;
2236 /* Restore the previous frame's SP. */
2237 prev_sp
= read_memory_unsigned_integer (
2238 info
->saved_regs
[S390_SP_REGNUM
].addr
,
2239 word_size
, byte_order
);
2241 /* Determine our frame base. */
2242 info
->frame_base
= prev_sp
+ 16*word_size
+ 32;
2248 s390_sigtramp_frame_this_id (struct frame_info
*this_frame
,
2249 void **this_prologue_cache
,
2250 struct frame_id
*this_id
)
2252 struct s390_sigtramp_unwind_cache
*info
2253 = s390_sigtramp_frame_unwind_cache (this_frame
, this_prologue_cache
);
2254 *this_id
= frame_id_build (info
->frame_base
, get_frame_pc (this_frame
));
2257 static struct value
*
2258 s390_sigtramp_frame_prev_register (struct frame_info
*this_frame
,
2259 void **this_prologue_cache
, int regnum
)
2261 struct s390_sigtramp_unwind_cache
*info
2262 = s390_sigtramp_frame_unwind_cache (this_frame
, this_prologue_cache
);
2263 return s390_trad_frame_prev_register (this_frame
, info
->saved_regs
, regnum
);
2267 s390_sigtramp_frame_sniffer (const struct frame_unwind
*self
,
2268 struct frame_info
*this_frame
,
2269 void **this_prologue_cache
)
2271 CORE_ADDR pc
= get_frame_pc (this_frame
);
2272 bfd_byte sigreturn
[2];
2274 if (target_read_memory (pc
, sigreturn
, 2))
2277 if (sigreturn
[0] != 0x0a /* svc */)
2280 if (sigreturn
[1] != 119 /* sigreturn */
2281 && sigreturn
[1] != 173 /* rt_sigreturn */)
2287 static const struct frame_unwind s390_sigtramp_frame_unwind
= {
2289 default_frame_unwind_stop_reason
,
2290 s390_sigtramp_frame_this_id
,
2291 s390_sigtramp_frame_prev_register
,
2293 s390_sigtramp_frame_sniffer
2297 /* Frame base handling. */
2300 s390_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
2302 struct s390_unwind_cache
*info
2303 = s390_frame_unwind_cache (this_frame
, this_cache
);
2304 return info
->frame_base
;
2308 s390_local_base_address (struct frame_info
*this_frame
, void **this_cache
)
2310 struct s390_unwind_cache
*info
2311 = s390_frame_unwind_cache (this_frame
, this_cache
);
2312 return info
->local_base
;
2315 static const struct frame_base s390_frame_base
= {
2317 s390_frame_base_address
,
2318 s390_local_base_address
,
2319 s390_local_base_address
2323 s390_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2325 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2327 pc
= frame_unwind_register_unsigned (next_frame
, tdep
->pc_regnum
);
2328 return gdbarch_addr_bits_remove (gdbarch
, pc
);
2332 s390_unwind_sp (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2335 sp
= frame_unwind_register_unsigned (next_frame
, S390_SP_REGNUM
);
2336 return gdbarch_addr_bits_remove (gdbarch
, sp
);
2340 /* DWARF-2 frame support. */
2342 static struct value
*
2343 s390_dwarf2_prev_register (struct frame_info
*this_frame
, void **this_cache
,
2346 return s390_unwind_pseudo_register (this_frame
, regnum
);
2350 s390_dwarf2_frame_init_reg (struct gdbarch
*gdbarch
, int regnum
,
2351 struct dwarf2_frame_state_reg
*reg
,
2352 struct frame_info
*this_frame
)
2354 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2356 /* The condition code (and thus PSW mask) is call-clobbered. */
2357 if (regnum
== S390_PSWM_REGNUM
)
2358 reg
->how
= DWARF2_FRAME_REG_UNDEFINED
;
2360 /* The PSW address unwinds to the return address. */
2361 else if (regnum
== S390_PSWA_REGNUM
)
2362 reg
->how
= DWARF2_FRAME_REG_RA
;
2364 /* Fixed registers are call-saved or call-clobbered
2365 depending on the ABI in use. */
2366 else if (regnum
< S390_NUM_REGS
)
2368 if (s390_register_call_saved (gdbarch
, regnum
))
2369 reg
->how
= DWARF2_FRAME_REG_SAME_VALUE
;
2371 reg
->how
= DWARF2_FRAME_REG_UNDEFINED
;
2374 /* We install a special function to unwind pseudos. */
2377 reg
->how
= DWARF2_FRAME_REG_FN
;
2378 reg
->loc
.fn
= s390_dwarf2_prev_register
;
2383 /* Dummy function calls. */
2385 /* Return non-zero if TYPE is an integer-like type, zero otherwise.
2386 "Integer-like" types are those that should be passed the way
2387 integers are: integers, enums, ranges, characters, and booleans. */
2389 is_integer_like (struct type
*type
)
2391 enum type_code code
= TYPE_CODE (type
);
2393 return (code
== TYPE_CODE_INT
2394 || code
== TYPE_CODE_ENUM
2395 || code
== TYPE_CODE_RANGE
2396 || code
== TYPE_CODE_CHAR
2397 || code
== TYPE_CODE_BOOL
);
2400 /* Return non-zero if TYPE is a pointer-like type, zero otherwise.
2401 "Pointer-like" types are those that should be passed the way
2402 pointers are: pointers and references. */
2404 is_pointer_like (struct type
*type
)
2406 enum type_code code
= TYPE_CODE (type
);
2408 return (code
== TYPE_CODE_PTR
2409 || code
== TYPE_CODE_REF
);
2413 /* Return non-zero if TYPE is a `float singleton' or `double
2414 singleton', zero otherwise.
2416 A `T singleton' is a struct type with one member, whose type is
2417 either T or a `T singleton'. So, the following are all float
2421 struct { struct { float x; } x; };
2422 struct { struct { struct { float x; } x; } x; };
2426 All such structures are passed as if they were floats or doubles,
2427 as the (revised) ABI says. */
2429 is_float_singleton (struct type
*type
)
2431 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
&& TYPE_NFIELDS (type
) == 1)
2433 struct type
*singleton_type
= TYPE_FIELD_TYPE (type
, 0);
2434 CHECK_TYPEDEF (singleton_type
);
2436 return (TYPE_CODE (singleton_type
) == TYPE_CODE_FLT
2437 || TYPE_CODE (singleton_type
) == TYPE_CODE_DECFLOAT
2438 || is_float_singleton (singleton_type
));
2445 /* Return non-zero if TYPE is a struct-like type, zero otherwise.
2446 "Struct-like" types are those that should be passed as structs are:
2449 As an odd quirk, not mentioned in the ABI, GCC passes float and
2450 double singletons as if they were a plain float, double, etc. (The
2451 corresponding union types are handled normally.) So we exclude
2452 those types here. *shrug* */
2454 is_struct_like (struct type
*type
)
2456 enum type_code code
= TYPE_CODE (type
);
2458 return (code
== TYPE_CODE_UNION
2459 || (code
== TYPE_CODE_STRUCT
&& ! is_float_singleton (type
)));
2463 /* Return non-zero if TYPE is a float-like type, zero otherwise.
2464 "Float-like" types are those that should be passed as
2465 floating-point values are.
2467 You'd think this would just be floats, doubles, long doubles, etc.
2468 But as an odd quirk, not mentioned in the ABI, GCC passes float and
2469 double singletons as if they were a plain float, double, etc. (The
2470 corresponding union types are handled normally.) So we include
2471 those types here. *shrug* */
2473 is_float_like (struct type
*type
)
2475 return (TYPE_CODE (type
) == TYPE_CODE_FLT
2476 || TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
2477 || is_float_singleton (type
));
2482 is_power_of_two (unsigned int n
)
2484 return ((n
& (n
- 1)) == 0);
2487 /* Return non-zero if TYPE should be passed as a pointer to a copy,
2490 s390_function_arg_pass_by_reference (struct type
*type
)
2492 unsigned length
= TYPE_LENGTH (type
);
2496 return (is_struct_like (type
) && !is_power_of_two (TYPE_LENGTH (type
)))
2497 || TYPE_CODE (type
) == TYPE_CODE_COMPLEX
2498 || (TYPE_CODE (type
) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (type
));
2501 /* Return non-zero if TYPE should be passed in a float register
2504 s390_function_arg_float (struct type
*type
)
2506 unsigned length
= TYPE_LENGTH (type
);
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 unsigned length
= TYPE_LENGTH (type
);
2522 return is_integer_like (type
)
2523 || is_pointer_like (type
)
2524 || (is_struct_like (type
) && is_power_of_two (length
));
2527 /* Return ARG, a `SIMPLE_ARG', sign-extended or zero-extended to a full
2528 word as required for the ABI. */
2530 extend_simple_arg (struct gdbarch
*gdbarch
, struct value
*arg
)
2532 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2533 struct type
*type
= check_typedef (value_type (arg
));
2535 /* Even structs get passed in the least significant bits of the
2536 register / memory word. It's not really right to extract them as
2537 an integer, but it does take care of the extension. */
2538 if (TYPE_UNSIGNED (type
))
2539 return extract_unsigned_integer (value_contents (arg
),
2540 TYPE_LENGTH (type
), byte_order
);
2542 return extract_signed_integer (value_contents (arg
),
2543 TYPE_LENGTH (type
), byte_order
);
2547 /* Return the alignment required by TYPE. */
2549 alignment_of (struct type
*type
)
2553 if (is_integer_like (type
)
2554 || is_pointer_like (type
)
2555 || TYPE_CODE (type
) == TYPE_CODE_FLT
2556 || TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
2557 alignment
= TYPE_LENGTH (type
);
2558 else if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
2559 || TYPE_CODE (type
) == TYPE_CODE_UNION
)
2564 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
2567 = alignment_of (check_typedef (TYPE_FIELD_TYPE (type
, i
)));
2569 if (field_alignment
> alignment
)
2570 alignment
= field_alignment
;
2576 /* Check that everything we ever return is a power of two. Lots of
2577 code doesn't want to deal with aligning things to arbitrary
2579 gdb_assert ((alignment
& (alignment
- 1)) == 0);
2585 /* Put the actual parameter values pointed to by ARGS[0..NARGS-1] in
2586 place to be passed to a function, as specified by the "GNU/Linux
2587 for S/390 ELF Application Binary Interface Supplement".
2589 SP is the current stack pointer. We must put arguments, links,
2590 padding, etc. whereever they belong, and return the new stack
2593 If STRUCT_RETURN is non-zero, then the function we're calling is
2594 going to return a structure by value; STRUCT_ADDR is the address of
2595 a block we've allocated for it on the stack.
2597 Our caller has taken care of any type promotions needed to satisfy
2598 prototypes or the old K&R argument-passing rules. */
2600 s390_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
2601 struct regcache
*regcache
, CORE_ADDR bp_addr
,
2602 int nargs
, struct value
**args
, CORE_ADDR sp
,
2603 int struct_return
, CORE_ADDR struct_addr
)
2605 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2606 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
2607 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2610 /* If the i'th argument is passed as a reference to a copy, then
2611 copy_addr[i] is the address of the copy we made. */
2612 CORE_ADDR
*copy_addr
= alloca (nargs
* sizeof (CORE_ADDR
));
2614 /* Reserve space for the reference-to-copy area. */
2615 for (i
= 0; i
< nargs
; i
++)
2617 struct value
*arg
= args
[i
];
2618 struct type
*type
= check_typedef (value_type (arg
));
2619 unsigned length
= TYPE_LENGTH (type
);
2621 if (s390_function_arg_pass_by_reference (type
))
2624 sp
= align_down (sp
, alignment_of (type
));
2629 /* Reserve space for the parameter area. As a conservative
2630 simplification, we assume that everything will be passed on the
2631 stack. Since every argument larger than 8 bytes will be
2632 passed by reference, we use this simple upper bound. */
2635 /* After all that, make sure it's still aligned on an eight-byte
2637 sp
= align_down (sp
, 8);
2639 /* Allocate the standard frame areas: the register save area, the
2640 word reserved for the compiler (which seems kind of meaningless),
2641 and the back chain pointer. */
2642 sp
-= 16*word_size
+ 32;
2644 /* Now we have the final SP value. Make sure we didn't underflow;
2645 on 31-bit, this would result in addresses with the high bit set,
2646 which causes confusion elsewhere. Note that if we error out
2647 here, stack and registers remain untouched. */
2648 if (gdbarch_addr_bits_remove (gdbarch
, sp
) != sp
)
2649 error (_("Stack overflow"));
2652 /* Finally, place the actual parameters, working from SP towards
2653 higher addresses. The code above is supposed to reserve enough
2658 CORE_ADDR starg
= sp
+ 16*word_size
+ 32;
2660 /* A struct is returned using general register 2. */
2663 regcache_cooked_write_unsigned (regcache
, S390_R0_REGNUM
+ gr
,
2668 for (i
= 0; i
< nargs
; i
++)
2670 struct value
*arg
= args
[i
];
2671 struct type
*type
= check_typedef (value_type (arg
));
2672 unsigned length
= TYPE_LENGTH (type
);
2674 if (s390_function_arg_pass_by_reference (type
))
2676 /* Actually copy the argument contents to the stack slot
2677 that was reserved above. */
2678 write_memory (copy_addr
[i
], value_contents (arg
), length
);
2682 regcache_cooked_write_unsigned (regcache
, S390_R0_REGNUM
+ gr
,
2688 write_memory_unsigned_integer (starg
, word_size
, byte_order
,
2693 else if (s390_function_arg_float (type
))
2695 /* The GNU/Linux for S/390 ABI uses FPRs 0 and 2 to pass arguments,
2696 the GNU/Linux for zSeries ABI uses 0, 2, 4, and 6. */
2697 if (fr
<= (tdep
->abi
== ABI_LINUX_S390
? 2 : 6))
2699 /* When we store a single-precision value in an FP register,
2700 it occupies the leftmost bits. */
2701 regcache_cooked_write_part (regcache
, S390_F0_REGNUM
+ fr
,
2702 0, length
, value_contents (arg
));
2707 /* When we store a single-precision value in a stack slot,
2708 it occupies the rightmost bits. */
2709 starg
= align_up (starg
+ length
, word_size
);
2710 write_memory (starg
- length
, value_contents (arg
), length
);
2713 else if (s390_function_arg_integer (type
) && length
<= word_size
)
2717 /* Integer arguments are always extended to word size. */
2718 regcache_cooked_write_signed (regcache
, S390_R0_REGNUM
+ gr
,
2719 extend_simple_arg (gdbarch
,
2725 /* Integer arguments are always extended to word size. */
2726 write_memory_signed_integer (starg
, word_size
, byte_order
,
2727 extend_simple_arg (gdbarch
, arg
));
2731 else if (s390_function_arg_integer (type
) && length
== 2*word_size
)
2735 regcache_cooked_write (regcache
, S390_R0_REGNUM
+ gr
,
2736 value_contents (arg
));
2737 regcache_cooked_write (regcache
, S390_R0_REGNUM
+ gr
+ 1,
2738 value_contents (arg
) + word_size
);
2743 /* If we skipped r6 because we couldn't fit a DOUBLE_ARG
2744 in it, then don't go back and use it again later. */
2747 write_memory (starg
, value_contents (arg
), length
);
2752 internal_error (__FILE__
, __LINE__
, _("unknown argument type"));
2756 /* Store return PSWA. In 31-bit mode, keep addressing mode bit. */
2760 regcache_cooked_read_unsigned (regcache
, S390_PSWA_REGNUM
, &pswa
);
2761 bp_addr
= (bp_addr
& 0x7fffffff) | (pswa
& 0x80000000);
2763 regcache_cooked_write_unsigned (regcache
, S390_RETADDR_REGNUM
, bp_addr
);
2765 /* Store updated stack pointer. */
2766 regcache_cooked_write_unsigned (regcache
, S390_SP_REGNUM
, sp
);
2768 /* We need to return the 'stack part' of the frame ID,
2769 which is actually the top of the register save area. */
2770 return sp
+ 16*word_size
+ 32;
2773 /* Assuming THIS_FRAME is a dummy, return the frame ID of that
2774 dummy frame. The frame ID's base needs to match the TOS value
2775 returned by push_dummy_call, and the PC match the dummy frame's
2777 static struct frame_id
2778 s390_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*this_frame
)
2780 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
2781 CORE_ADDR sp
= get_frame_register_unsigned (this_frame
, S390_SP_REGNUM
);
2782 sp
= gdbarch_addr_bits_remove (gdbarch
, sp
);
2784 return frame_id_build (sp
+ 16*word_size
+ 32,
2785 get_frame_pc (this_frame
));
2789 s390_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
2791 /* Both the 32- and 64-bit ABI's say that the stack pointer should
2792 always be aligned on an eight-byte boundary. */
2797 /* Function return value access. */
2799 static enum return_value_convention
2800 s390_return_value_convention (struct gdbarch
*gdbarch
, struct type
*type
)
2802 int length
= TYPE_LENGTH (type
);
2804 return RETURN_VALUE_STRUCT_CONVENTION
;
2806 switch (TYPE_CODE (type
))
2808 case TYPE_CODE_STRUCT
:
2809 case TYPE_CODE_UNION
:
2810 case TYPE_CODE_ARRAY
:
2811 case TYPE_CODE_COMPLEX
:
2812 return RETURN_VALUE_STRUCT_CONVENTION
;
2815 return RETURN_VALUE_REGISTER_CONVENTION
;
2819 static enum return_value_convention
2820 s390_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
2821 struct type
*type
, struct regcache
*regcache
,
2822 gdb_byte
*out
, const gdb_byte
*in
)
2824 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2825 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
2826 enum return_value_convention rvc
;
2829 type
= check_typedef (type
);
2830 rvc
= s390_return_value_convention (gdbarch
, type
);
2831 length
= TYPE_LENGTH (type
);
2837 case RETURN_VALUE_REGISTER_CONVENTION
:
2838 if (TYPE_CODE (type
) == TYPE_CODE_FLT
2839 || TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
2841 /* When we store a single-precision value in an FP register,
2842 it occupies the leftmost bits. */
2843 regcache_cooked_write_part (regcache
, S390_F0_REGNUM
,
2846 else if (length
<= word_size
)
2848 /* Integer arguments are always extended to word size. */
2849 if (TYPE_UNSIGNED (type
))
2850 regcache_cooked_write_unsigned (regcache
, S390_R2_REGNUM
,
2851 extract_unsigned_integer (in
, length
, byte_order
));
2853 regcache_cooked_write_signed (regcache
, S390_R2_REGNUM
,
2854 extract_signed_integer (in
, length
, byte_order
));
2856 else if (length
== 2*word_size
)
2858 regcache_cooked_write (regcache
, S390_R2_REGNUM
, in
);
2859 regcache_cooked_write (regcache
, S390_R3_REGNUM
, in
+ word_size
);
2862 internal_error (__FILE__
, __LINE__
, _("invalid return type"));
2865 case RETURN_VALUE_STRUCT_CONVENTION
:
2866 error (_("Cannot set function return value."));
2874 case RETURN_VALUE_REGISTER_CONVENTION
:
2875 if (TYPE_CODE (type
) == TYPE_CODE_FLT
2876 || TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
2878 /* When we store a single-precision value in an FP register,
2879 it occupies the leftmost bits. */
2880 regcache_cooked_read_part (regcache
, S390_F0_REGNUM
,
2883 else if (length
<= word_size
)
2885 /* Integer arguments occupy the rightmost bits. */
2886 regcache_cooked_read_part (regcache
, S390_R2_REGNUM
,
2887 word_size
- length
, length
, out
);
2889 else if (length
== 2*word_size
)
2891 regcache_cooked_read (regcache
, S390_R2_REGNUM
, out
);
2892 regcache_cooked_read (regcache
, S390_R3_REGNUM
, out
+ word_size
);
2895 internal_error (__FILE__
, __LINE__
, _("invalid return type"));
2898 case RETURN_VALUE_STRUCT_CONVENTION
:
2899 error (_("Function return value unknown."));
2910 static const gdb_byte
*
2911 s390_breakpoint_from_pc (struct gdbarch
*gdbarch
,
2912 CORE_ADDR
*pcptr
, int *lenptr
)
2914 static const gdb_byte breakpoint
[] = { 0x0, 0x1 };
2916 *lenptr
= sizeof (breakpoint
);
2921 /* Address handling. */
2924 s390_addr_bits_remove (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
2926 return addr
& 0x7fffffff;
2930 s390_address_class_type_flags (int byte_size
, int dwarf2_addr_class
)
2933 return TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1
;
2939 s390_address_class_type_flags_to_name (struct gdbarch
*gdbarch
, int type_flags
)
2941 if (type_flags
& TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1
)
2948 s390_address_class_name_to_type_flags (struct gdbarch
*gdbarch
,
2950 int *type_flags_ptr
)
2952 if (strcmp (name
, "mode32") == 0)
2954 *type_flags_ptr
= TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1
;
2961 /* Implementation of `gdbarch_stap_is_single_operand', as defined in
2965 s390_stap_is_single_operand (struct gdbarch
*gdbarch
, const char *s
)
2967 return ((isdigit (*s
) && s
[1] == '(' && s
[2] == '%') /* Displacement
2969 || *s
== '%' /* Register access. */
2970 || isdigit (*s
)); /* Literal number. */
2973 /* Set up gdbarch struct. */
2975 static struct gdbarch
*
2976 s390_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
2978 const struct target_desc
*tdesc
= info
.target_desc
;
2979 struct tdesc_arch_data
*tdesc_data
= NULL
;
2980 struct gdbarch
*gdbarch
;
2981 struct gdbarch_tdep
*tdep
;
2984 int have_linux_v1
= 0;
2985 int have_linux_v2
= 0;
2986 int first_pseudo_reg
, last_pseudo_reg
;
2988 /* Default ABI and register size. */
2989 switch (info
.bfd_arch_info
->mach
)
2991 case bfd_mach_s390_31
:
2992 tdep_abi
= ABI_LINUX_S390
;
2995 case bfd_mach_s390_64
:
2996 tdep_abi
= ABI_LINUX_ZSERIES
;
3003 /* Use default target description if none provided by the target. */
3004 if (!tdesc_has_registers (tdesc
))
3006 if (tdep_abi
== ABI_LINUX_S390
)
3007 tdesc
= tdesc_s390_linux32
;
3009 tdesc
= tdesc_s390x_linux64
;
3012 /* Check any target description for validity. */
3013 if (tdesc_has_registers (tdesc
))
3015 static const char *const gprs
[] = {
3016 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
3017 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
3019 static const char *const fprs
[] = {
3020 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
3021 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15"
3023 static const char *const acrs
[] = {
3024 "acr0", "acr1", "acr2", "acr3", "acr4", "acr5", "acr6", "acr7",
3025 "acr8", "acr9", "acr10", "acr11", "acr12", "acr13", "acr14", "acr15"
3027 static const char *const gprs_lower
[] = {
3028 "r0l", "r1l", "r2l", "r3l", "r4l", "r5l", "r6l", "r7l",
3029 "r8l", "r9l", "r10l", "r11l", "r12l", "r13l", "r14l", "r15l"
3031 static const char *const gprs_upper
[] = {
3032 "r0h", "r1h", "r2h", "r3h", "r4h", "r5h", "r6h", "r7h",
3033 "r8h", "r9h", "r10h", "r11h", "r12h", "r13h", "r14h", "r15h"
3035 const struct tdesc_feature
*feature
;
3038 feature
= tdesc_find_feature (tdesc
, "org.gnu.gdb.s390.core");
3039 if (feature
== NULL
)
3042 tdesc_data
= tdesc_data_alloc ();
3044 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
3045 S390_PSWM_REGNUM
, "pswm");
3046 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
3047 S390_PSWA_REGNUM
, "pswa");
3049 if (tdesc_unnumbered_register (feature
, "r0"))
3051 for (i
= 0; i
< 16; i
++)
3052 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
3053 S390_R0_REGNUM
+ i
, gprs
[i
]);
3059 for (i
= 0; i
< 16; i
++)
3060 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
3063 for (i
= 0; i
< 16; i
++)
3064 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
3065 S390_R0_UPPER_REGNUM
+ i
,
3069 feature
= tdesc_find_feature (tdesc
, "org.gnu.gdb.s390.fpr");
3070 if (feature
== NULL
)
3072 tdesc_data_cleanup (tdesc_data
);
3076 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
3077 S390_FPC_REGNUM
, "fpc");
3078 for (i
= 0; i
< 16; i
++)
3079 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
3080 S390_F0_REGNUM
+ i
, fprs
[i
]);
3082 feature
= tdesc_find_feature (tdesc
, "org.gnu.gdb.s390.acr");
3083 if (feature
== NULL
)
3085 tdesc_data_cleanup (tdesc_data
);
3089 for (i
= 0; i
< 16; i
++)
3090 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
3091 S390_A0_REGNUM
+ i
, acrs
[i
]);
3093 /* Optional GNU/Linux-specific "registers". */
3094 feature
= tdesc_find_feature (tdesc
, "org.gnu.gdb.s390.linux");
3097 tdesc_numbered_register (feature
, tdesc_data
,
3098 S390_ORIG_R2_REGNUM
, "orig_r2");
3100 if (tdesc_numbered_register (feature
, tdesc_data
,
3101 S390_LAST_BREAK_REGNUM
, "last_break"))
3104 if (tdesc_numbered_register (feature
, tdesc_data
,
3105 S390_SYSTEM_CALL_REGNUM
, "system_call"))
3108 if (have_linux_v2
> have_linux_v1
)
3114 tdesc_data_cleanup (tdesc_data
);
3119 /* Find a candidate among extant architectures. */
3120 for (arches
= gdbarch_list_lookup_by_info (arches
, &info
);
3122 arches
= gdbarch_list_lookup_by_info (arches
->next
, &info
))
3124 tdep
= gdbarch_tdep (arches
->gdbarch
);
3127 if (tdep
->abi
!= tdep_abi
)
3129 if ((tdep
->gpr_full_regnum
!= -1) != have_upper
)
3131 if (tdesc_data
!= NULL
)
3132 tdesc_data_cleanup (tdesc_data
);
3133 return arches
->gdbarch
;
3136 /* Otherwise create a new gdbarch for the specified machine type. */
3137 tdep
= XCALLOC (1, struct gdbarch_tdep
);
3138 tdep
->abi
= tdep_abi
;
3139 gdbarch
= gdbarch_alloc (&info
, tdep
);
3141 set_gdbarch_believe_pcc_promotion (gdbarch
, 0);
3142 set_gdbarch_char_signed (gdbarch
, 0);
3144 /* S/390 GNU/Linux uses either 64-bit or 128-bit long doubles.
3145 We can safely let them default to 128-bit, since the debug info
3146 will give the size of type actually used in each case. */
3147 set_gdbarch_long_double_bit (gdbarch
, 128);
3148 set_gdbarch_long_double_format (gdbarch
, floatformats_ia64_quad
);
3150 /* Amount PC must be decremented by after a breakpoint. This is
3151 often the number of bytes returned by gdbarch_breakpoint_from_pc but not
3153 set_gdbarch_decr_pc_after_break (gdbarch
, 2);
3154 /* Stack grows downward. */
3155 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
3156 set_gdbarch_breakpoint_from_pc (gdbarch
, s390_breakpoint_from_pc
);
3157 set_gdbarch_skip_prologue (gdbarch
, s390_skip_prologue
);
3158 set_gdbarch_in_function_epilogue_p (gdbarch
, s390_in_function_epilogue_p
);
3160 set_gdbarch_num_regs (gdbarch
, S390_NUM_REGS
);
3161 set_gdbarch_sp_regnum (gdbarch
, S390_SP_REGNUM
);
3162 set_gdbarch_fp0_regnum (gdbarch
, S390_F0_REGNUM
);
3163 set_gdbarch_stab_reg_to_regnum (gdbarch
, s390_dwarf_reg_to_regnum
);
3164 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, s390_dwarf_reg_to_regnum
);
3165 set_gdbarch_value_from_register (gdbarch
, s390_value_from_register
);
3166 set_gdbarch_regset_from_core_section (gdbarch
,
3167 s390_regset_from_core_section
);
3168 set_gdbarch_core_read_description (gdbarch
, s390_core_read_description
);
3169 set_gdbarch_cannot_store_register (gdbarch
, s390_cannot_store_register
);
3170 set_gdbarch_write_pc (gdbarch
, s390_write_pc
);
3171 set_gdbarch_pseudo_register_read (gdbarch
, s390_pseudo_register_read
);
3172 set_gdbarch_pseudo_register_write (gdbarch
, s390_pseudo_register_write
);
3173 set_tdesc_pseudo_register_name (gdbarch
, s390_pseudo_register_name
);
3174 set_tdesc_pseudo_register_type (gdbarch
, s390_pseudo_register_type
);
3175 set_tdesc_pseudo_register_reggroup_p (gdbarch
,
3176 s390_pseudo_register_reggroup_p
);
3177 tdesc_use_registers (gdbarch
, tdesc
, tdesc_data
);
3179 /* Assign pseudo register numbers. */
3180 first_pseudo_reg
= gdbarch_num_regs (gdbarch
);
3181 last_pseudo_reg
= first_pseudo_reg
;
3182 tdep
->gpr_full_regnum
= -1;
3185 tdep
->gpr_full_regnum
= last_pseudo_reg
;
3186 last_pseudo_reg
+= 16;
3188 tdep
->pc_regnum
= last_pseudo_reg
++;
3189 tdep
->cc_regnum
= last_pseudo_reg
++;
3190 set_gdbarch_pc_regnum (gdbarch
, tdep
->pc_regnum
);
3191 set_gdbarch_num_pseudo_regs (gdbarch
, last_pseudo_reg
- first_pseudo_reg
);
3193 /* Inferior function calls. */
3194 set_gdbarch_push_dummy_call (gdbarch
, s390_push_dummy_call
);
3195 set_gdbarch_dummy_id (gdbarch
, s390_dummy_id
);
3196 set_gdbarch_frame_align (gdbarch
, s390_frame_align
);
3197 set_gdbarch_return_value (gdbarch
, s390_return_value
);
3199 /* Frame handling. */
3200 dwarf2_frame_set_init_reg (gdbarch
, s390_dwarf2_frame_init_reg
);
3201 dwarf2_frame_set_adjust_regnum (gdbarch
, s390_adjust_frame_regnum
);
3202 dwarf2_append_unwinders (gdbarch
);
3203 frame_base_append_sniffer (gdbarch
, dwarf2_frame_base_sniffer
);
3204 frame_unwind_append_unwinder (gdbarch
, &s390_stub_frame_unwind
);
3205 frame_unwind_append_unwinder (gdbarch
, &s390_sigtramp_frame_unwind
);
3206 frame_unwind_append_unwinder (gdbarch
, &s390_frame_unwind
);
3207 frame_base_set_default (gdbarch
, &s390_frame_base
);
3208 set_gdbarch_unwind_pc (gdbarch
, s390_unwind_pc
);
3209 set_gdbarch_unwind_sp (gdbarch
, s390_unwind_sp
);
3211 /* Displaced stepping. */
3212 set_gdbarch_displaced_step_copy_insn (gdbarch
,
3213 simple_displaced_step_copy_insn
);
3214 set_gdbarch_displaced_step_fixup (gdbarch
, s390_displaced_step_fixup
);
3215 set_gdbarch_displaced_step_free_closure (gdbarch
,
3216 simple_displaced_step_free_closure
);
3217 set_gdbarch_displaced_step_location (gdbarch
,
3218 displaced_step_at_entry_point
);
3219 set_gdbarch_max_insn_length (gdbarch
, S390_MAX_INSTR_SIZE
);
3221 /* Note that GNU/Linux is the only OS supported on this
3223 linux_init_abi (info
, gdbarch
);
3227 case ABI_LINUX_S390
:
3228 tdep
->gregset
= &s390_gregset
;
3229 tdep
->sizeof_gregset
= s390_sizeof_gregset
;
3230 tdep
->fpregset
= &s390_fpregset
;
3231 tdep
->sizeof_fpregset
= s390_sizeof_fpregset
;
3233 set_gdbarch_addr_bits_remove (gdbarch
, s390_addr_bits_remove
);
3234 set_solib_svr4_fetch_link_map_offsets
3235 (gdbarch
, svr4_ilp32_fetch_link_map_offsets
);
3240 set_gdbarch_core_regset_sections (gdbarch
,
3241 s390_linux64v2_regset_sections
);
3242 else if (have_linux_v1
)
3243 set_gdbarch_core_regset_sections (gdbarch
,
3244 s390_linux64v1_regset_sections
);
3246 set_gdbarch_core_regset_sections (gdbarch
,
3247 s390_linux64_regset_sections
);
3252 set_gdbarch_core_regset_sections (gdbarch
,
3253 s390_linux32v2_regset_sections
);
3254 else if (have_linux_v1
)
3255 set_gdbarch_core_regset_sections (gdbarch
,
3256 s390_linux32v1_regset_sections
);
3258 set_gdbarch_core_regset_sections (gdbarch
,
3259 s390_linux32_regset_sections
);
3263 case ABI_LINUX_ZSERIES
:
3264 tdep
->gregset
= &s390x_gregset
;
3265 tdep
->sizeof_gregset
= s390x_sizeof_gregset
;
3266 tdep
->fpregset
= &s390_fpregset
;
3267 tdep
->sizeof_fpregset
= s390_sizeof_fpregset
;
3269 set_gdbarch_long_bit (gdbarch
, 64);
3270 set_gdbarch_long_long_bit (gdbarch
, 64);
3271 set_gdbarch_ptr_bit (gdbarch
, 64);
3272 set_solib_svr4_fetch_link_map_offsets
3273 (gdbarch
, svr4_lp64_fetch_link_map_offsets
);
3274 set_gdbarch_address_class_type_flags (gdbarch
,
3275 s390_address_class_type_flags
);
3276 set_gdbarch_address_class_type_flags_to_name (gdbarch
,
3277 s390_address_class_type_flags_to_name
);
3278 set_gdbarch_address_class_name_to_type_flags (gdbarch
,
3279 s390_address_class_name_to_type_flags
);
3282 set_gdbarch_core_regset_sections (gdbarch
,
3283 s390x_linux64v2_regset_sections
);
3284 else if (have_linux_v1
)
3285 set_gdbarch_core_regset_sections (gdbarch
,
3286 s390x_linux64v1_regset_sections
);
3288 set_gdbarch_core_regset_sections (gdbarch
,
3289 s390x_linux64_regset_sections
);
3293 set_gdbarch_print_insn (gdbarch
, print_insn_s390
);
3295 set_gdbarch_skip_trampoline_code (gdbarch
, find_solib_trampoline_target
);
3297 /* Enable TLS support. */
3298 set_gdbarch_fetch_tls_load_module_address (gdbarch
,
3299 svr4_fetch_objfile_link_map
);
3301 set_gdbarch_get_siginfo_type (gdbarch
, linux_get_siginfo_type
);
3303 /* SystemTap functions. */
3304 set_gdbarch_stap_register_prefix (gdbarch
, "%");
3305 set_gdbarch_stap_register_indirection_prefix (gdbarch
, "(");
3306 set_gdbarch_stap_register_indirection_suffix (gdbarch
, ")");
3307 set_gdbarch_stap_is_single_operand (gdbarch
, s390_stap_is_single_operand
);
3313 extern initialize_file_ftype _initialize_s390_tdep
; /* -Wmissing-prototypes */
3316 _initialize_s390_tdep (void)
3318 /* Hook us into the gdbarch mechanism. */
3319 register_gdbarch_init (bfd_arch_s390
, s390_gdbarch_init
);
3321 /* Initialize the GNU/Linux target descriptions. */
3322 initialize_tdesc_s390_linux32 ();
3323 initialize_tdesc_s390_linux32v1 ();
3324 initialize_tdesc_s390_linux32v2 ();
3325 initialize_tdesc_s390_linux64 ();
3326 initialize_tdesc_s390_linux64v1 ();
3327 initialize_tdesc_s390_linux64v2 ();
3328 initialize_tdesc_s390x_linux64 ();
3329 initialize_tdesc_s390x_linux64v1 ();
3330 initialize_tdesc_s390x_linux64v2 ();