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 "features/s390-linux32.c"
49 #include "features/s390-linux32v1.c"
50 #include "features/s390-linux32v2.c"
51 #include "features/s390-linux64.c"
52 #include "features/s390-linux64v1.c"
53 #include "features/s390-linux64v2.c"
54 #include "features/s390x-linux64.c"
55 #include "features/s390x-linux64v1.c"
56 #include "features/s390x-linux64v2.c"
59 /* The tdep structure. */
64 enum { ABI_LINUX_S390
, ABI_LINUX_ZSERIES
} abi
;
66 /* Pseudo register numbers. */
71 /* Core file register sets. */
72 const struct regset
*gregset
;
75 const struct regset
*fpregset
;
80 /* ABI call-saved register information. */
83 s390_register_call_saved (struct gdbarch
*gdbarch
, int regnum
)
85 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
90 if ((regnum
>= S390_R6_REGNUM
&& regnum
<= S390_R15_REGNUM
)
91 || regnum
== S390_F4_REGNUM
|| regnum
== S390_F6_REGNUM
92 || regnum
== S390_A0_REGNUM
)
97 case ABI_LINUX_ZSERIES
:
98 if ((regnum
>= S390_R6_REGNUM
&& regnum
<= S390_R15_REGNUM
)
99 || (regnum
>= S390_F8_REGNUM
&& regnum
<= S390_F15_REGNUM
)
100 || (regnum
>= S390_A0_REGNUM
&& regnum
<= S390_A1_REGNUM
))
110 s390_cannot_store_register (struct gdbarch
*gdbarch
, int regnum
)
112 /* The last-break address is read-only. */
113 return regnum
== S390_LAST_BREAK_REGNUM
;
117 s390_write_pc (struct regcache
*regcache
, CORE_ADDR pc
)
119 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
120 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
122 regcache_cooked_write_unsigned (regcache
, tdep
->pc_regnum
, pc
);
124 /* Set special SYSTEM_CALL register to 0 to prevent the kernel from
125 messing with the PC we just installed, if we happen to be within
126 an interrupted system call that the kernel wants to restart.
128 Note that after we return from the dummy call, the SYSTEM_CALL and
129 ORIG_R2 registers will be automatically restored, and the kernel
130 continues to restart the system call at this point. */
131 if (register_size (gdbarch
, S390_SYSTEM_CALL_REGNUM
) > 0)
132 regcache_cooked_write_unsigned (regcache
, S390_SYSTEM_CALL_REGNUM
, 0);
136 /* DWARF Register Mapping. */
138 static int s390_dwarf_regmap
[] =
140 /* General Purpose Registers. */
141 S390_R0_REGNUM
, S390_R1_REGNUM
, S390_R2_REGNUM
, S390_R3_REGNUM
,
142 S390_R4_REGNUM
, S390_R5_REGNUM
, S390_R6_REGNUM
, S390_R7_REGNUM
,
143 S390_R8_REGNUM
, S390_R9_REGNUM
, S390_R10_REGNUM
, S390_R11_REGNUM
,
144 S390_R12_REGNUM
, S390_R13_REGNUM
, S390_R14_REGNUM
, S390_R15_REGNUM
,
146 /* Floating Point Registers. */
147 S390_F0_REGNUM
, S390_F2_REGNUM
, S390_F4_REGNUM
, S390_F6_REGNUM
,
148 S390_F1_REGNUM
, S390_F3_REGNUM
, S390_F5_REGNUM
, S390_F7_REGNUM
,
149 S390_F8_REGNUM
, S390_F10_REGNUM
, S390_F12_REGNUM
, S390_F14_REGNUM
,
150 S390_F9_REGNUM
, S390_F11_REGNUM
, S390_F13_REGNUM
, S390_F15_REGNUM
,
152 /* Control Registers (not mapped). */
153 -1, -1, -1, -1, -1, -1, -1, -1,
154 -1, -1, -1, -1, -1, -1, -1, -1,
156 /* Access Registers. */
157 S390_A0_REGNUM
, S390_A1_REGNUM
, S390_A2_REGNUM
, S390_A3_REGNUM
,
158 S390_A4_REGNUM
, S390_A5_REGNUM
, S390_A6_REGNUM
, S390_A7_REGNUM
,
159 S390_A8_REGNUM
, S390_A9_REGNUM
, S390_A10_REGNUM
, S390_A11_REGNUM
,
160 S390_A12_REGNUM
, S390_A13_REGNUM
, S390_A14_REGNUM
, S390_A15_REGNUM
,
162 /* Program Status Word. */
166 /* GPR Lower Half Access. */
167 S390_R0_REGNUM
, S390_R1_REGNUM
, S390_R2_REGNUM
, S390_R3_REGNUM
,
168 S390_R4_REGNUM
, S390_R5_REGNUM
, S390_R6_REGNUM
, S390_R7_REGNUM
,
169 S390_R8_REGNUM
, S390_R9_REGNUM
, S390_R10_REGNUM
, S390_R11_REGNUM
,
170 S390_R12_REGNUM
, S390_R13_REGNUM
, S390_R14_REGNUM
, S390_R15_REGNUM
,
172 /* GNU/Linux-specific registers (not mapped). */
176 /* Convert DWARF register number REG to the appropriate register
177 number used by GDB. */
179 s390_dwarf_reg_to_regnum (struct gdbarch
*gdbarch
, int reg
)
181 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
183 /* In a 32-on-64 debug scenario, debug info refers to the full 64-bit
184 GPRs. Note that call frame information still refers to the 32-bit
185 lower halves, because s390_adjust_frame_regnum uses register numbers
186 66 .. 81 to access GPRs. */
187 if (tdep
->gpr_full_regnum
!= -1 && reg
>= 0 && reg
< 16)
188 return tdep
->gpr_full_regnum
+ reg
;
190 if (reg
>= 0 && reg
< ARRAY_SIZE (s390_dwarf_regmap
))
191 return s390_dwarf_regmap
[reg
];
193 warning (_("Unmapped DWARF Register #%d encountered."), reg
);
197 /* Translate a .eh_frame register to DWARF register, or adjust a
198 .debug_frame register. */
200 s390_adjust_frame_regnum (struct gdbarch
*gdbarch
, int num
, int eh_frame_p
)
202 /* See s390_dwarf_reg_to_regnum for comments. */
203 return (num
>= 0 && num
< 16)? num
+ 66 : num
;
207 /* Pseudo registers. */
210 s390_pseudo_register_name (struct gdbarch
*gdbarch
, int regnum
)
212 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
214 if (regnum
== tdep
->pc_regnum
)
217 if (regnum
== tdep
->cc_regnum
)
220 if (tdep
->gpr_full_regnum
!= -1
221 && regnum
>= tdep
->gpr_full_regnum
222 && regnum
< tdep
->gpr_full_regnum
+ 16)
224 static const char *full_name
[] = {
225 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
226 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
228 return full_name
[regnum
- tdep
->gpr_full_regnum
];
231 internal_error (__FILE__
, __LINE__
, _("invalid regnum"));
235 s390_pseudo_register_type (struct gdbarch
*gdbarch
, int regnum
)
237 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
239 if (regnum
== tdep
->pc_regnum
)
240 return builtin_type (gdbarch
)->builtin_func_ptr
;
242 if (regnum
== tdep
->cc_regnum
)
243 return builtin_type (gdbarch
)->builtin_int
;
245 if (tdep
->gpr_full_regnum
!= -1
246 && regnum
>= tdep
->gpr_full_regnum
247 && regnum
< tdep
->gpr_full_regnum
+ 16)
248 return builtin_type (gdbarch
)->builtin_uint64
;
250 internal_error (__FILE__
, __LINE__
, _("invalid regnum"));
253 static enum register_status
254 s390_pseudo_register_read (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
255 int regnum
, gdb_byte
*buf
)
257 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
258 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
259 int regsize
= register_size (gdbarch
, regnum
);
262 if (regnum
== tdep
->pc_regnum
)
264 enum register_status status
;
266 status
= regcache_raw_read_unsigned (regcache
, S390_PSWA_REGNUM
, &val
);
267 if (status
== REG_VALID
)
269 if (register_size (gdbarch
, S390_PSWA_REGNUM
) == 4)
271 store_unsigned_integer (buf
, regsize
, byte_order
, val
);
276 if (regnum
== tdep
->cc_regnum
)
278 enum register_status status
;
280 status
= regcache_raw_read_unsigned (regcache
, S390_PSWM_REGNUM
, &val
);
281 if (status
== REG_VALID
)
283 if (register_size (gdbarch
, S390_PSWA_REGNUM
) == 4)
284 val
= (val
>> 12) & 3;
286 val
= (val
>> 44) & 3;
287 store_unsigned_integer (buf
, regsize
, byte_order
, val
);
292 if (tdep
->gpr_full_regnum
!= -1
293 && regnum
>= tdep
->gpr_full_regnum
294 && regnum
< tdep
->gpr_full_regnum
+ 16)
296 enum register_status status
;
299 regnum
-= tdep
->gpr_full_regnum
;
301 status
= regcache_raw_read_unsigned (regcache
, S390_R0_REGNUM
+ regnum
, &val
);
302 if (status
== REG_VALID
)
303 status
= regcache_raw_read_unsigned (regcache
, S390_R0_UPPER_REGNUM
+ regnum
,
305 if (status
== REG_VALID
)
307 val
|= val_upper
<< 32;
308 store_unsigned_integer (buf
, regsize
, byte_order
, val
);
313 internal_error (__FILE__
, __LINE__
, _("invalid regnum"));
317 s390_pseudo_register_write (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
318 int regnum
, const gdb_byte
*buf
)
320 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
321 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
322 int regsize
= register_size (gdbarch
, regnum
);
325 if (regnum
== tdep
->pc_regnum
)
327 val
= extract_unsigned_integer (buf
, regsize
, byte_order
);
328 if (register_size (gdbarch
, S390_PSWA_REGNUM
) == 4)
330 regcache_raw_read_unsigned (regcache
, S390_PSWA_REGNUM
, &psw
);
331 val
= (psw
& 0x80000000) | (val
& 0x7fffffff);
333 regcache_raw_write_unsigned (regcache
, S390_PSWA_REGNUM
, val
);
337 if (regnum
== tdep
->cc_regnum
)
339 val
= extract_unsigned_integer (buf
, regsize
, byte_order
);
340 regcache_raw_read_unsigned (regcache
, S390_PSWM_REGNUM
, &psw
);
341 if (register_size (gdbarch
, S390_PSWA_REGNUM
) == 4)
342 val
= (psw
& ~((ULONGEST
)3 << 12)) | ((val
& 3) << 12);
344 val
= (psw
& ~((ULONGEST
)3 << 44)) | ((val
& 3) << 44);
345 regcache_raw_write_unsigned (regcache
, S390_PSWM_REGNUM
, val
);
349 if (tdep
->gpr_full_regnum
!= -1
350 && regnum
>= tdep
->gpr_full_regnum
351 && regnum
< tdep
->gpr_full_regnum
+ 16)
353 regnum
-= tdep
->gpr_full_regnum
;
354 val
= extract_unsigned_integer (buf
, regsize
, byte_order
);
355 regcache_raw_write_unsigned (regcache
, S390_R0_REGNUM
+ regnum
,
357 regcache_raw_write_unsigned (regcache
, S390_R0_UPPER_REGNUM
+ regnum
,
362 internal_error (__FILE__
, __LINE__
, _("invalid regnum"));
365 /* 'float' values are stored in the upper half of floating-point
366 registers, even though we are otherwise a big-endian platform. */
368 static struct value
*
369 s390_value_from_register (struct type
*type
, int regnum
,
370 struct frame_info
*frame
)
372 struct value
*value
= default_value_from_register (type
, regnum
, frame
);
373 int len
= TYPE_LENGTH (check_typedef (type
));
375 if (regnum
>= S390_F0_REGNUM
&& regnum
<= S390_F15_REGNUM
&& len
< 8)
376 set_value_offset (value
, 0);
381 /* Register groups. */
384 s390_pseudo_register_reggroup_p (struct gdbarch
*gdbarch
, int regnum
,
385 struct reggroup
*group
)
387 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
389 /* We usually save/restore the whole PSW, which includes PC and CC.
390 However, some older gdbservers may not support saving/restoring
391 the whole PSW yet, and will return an XML register description
392 excluding those from the save/restore register groups. In those
393 cases, we still need to explicitly save/restore PC and CC in order
394 to push or pop frames. Since this doesn't hurt anything if we
395 already save/restore the whole PSW (it's just redundant), we add
396 PC and CC at this point unconditionally. */
397 if (group
== save_reggroup
|| group
== restore_reggroup
)
398 return regnum
== tdep
->pc_regnum
|| regnum
== tdep
->cc_regnum
;
400 return default_register_reggroup_p (gdbarch
, regnum
, group
);
404 /* Core file register sets. */
406 int s390_regmap_gregset
[S390_NUM_REGS
] =
408 /* Program Status Word. */
410 /* General Purpose Registers. */
411 0x08, 0x0c, 0x10, 0x14,
412 0x18, 0x1c, 0x20, 0x24,
413 0x28, 0x2c, 0x30, 0x34,
414 0x38, 0x3c, 0x40, 0x44,
415 /* Access Registers. */
416 0x48, 0x4c, 0x50, 0x54,
417 0x58, 0x5c, 0x60, 0x64,
418 0x68, 0x6c, 0x70, 0x74,
419 0x78, 0x7c, 0x80, 0x84,
420 /* Floating Point Control Word. */
422 /* Floating Point Registers. */
423 -1, -1, -1, -1, -1, -1, -1, -1,
424 -1, -1, -1, -1, -1, -1, -1, -1,
425 /* GPR Uppper Halves. */
426 -1, -1, -1, -1, -1, -1, -1, -1,
427 -1, -1, -1, -1, -1, -1, -1, -1,
428 /* GNU/Linux-specific optional "registers". */
432 int s390x_regmap_gregset
[S390_NUM_REGS
] =
434 /* Program Status Word. */
436 /* General Purpose Registers. */
437 0x10, 0x18, 0x20, 0x28,
438 0x30, 0x38, 0x40, 0x48,
439 0x50, 0x58, 0x60, 0x68,
440 0x70, 0x78, 0x80, 0x88,
441 /* Access Registers. */
442 0x90, 0x94, 0x98, 0x9c,
443 0xa0, 0xa4, 0xa8, 0xac,
444 0xb0, 0xb4, 0xb8, 0xbc,
445 0xc0, 0xc4, 0xc8, 0xcc,
446 /* Floating Point Control Word. */
448 /* Floating Point Registers. */
449 -1, -1, -1, -1, -1, -1, -1, -1,
450 -1, -1, -1, -1, -1, -1, -1, -1,
451 /* GPR Uppper Halves. */
452 0x10, 0x18, 0x20, 0x28,
453 0x30, 0x38, 0x40, 0x48,
454 0x50, 0x58, 0x60, 0x68,
455 0x70, 0x78, 0x80, 0x88,
456 /* GNU/Linux-specific optional "registers". */
460 int s390_regmap_fpregset
[S390_NUM_REGS
] =
462 /* Program Status Word. */
464 /* General Purpose Registers. */
465 -1, -1, -1, -1, -1, -1, -1, -1,
466 -1, -1, -1, -1, -1, -1, -1, -1,
467 /* Access Registers. */
468 -1, -1, -1, -1, -1, -1, -1, -1,
469 -1, -1, -1, -1, -1, -1, -1, -1,
470 /* Floating Point Control Word. */
472 /* Floating Point Registers. */
473 0x08, 0x10, 0x18, 0x20,
474 0x28, 0x30, 0x38, 0x40,
475 0x48, 0x50, 0x58, 0x60,
476 0x68, 0x70, 0x78, 0x80,
477 /* GPR Uppper Halves. */
478 -1, -1, -1, -1, -1, -1, -1, -1,
479 -1, -1, -1, -1, -1, -1, -1, -1,
480 /* GNU/Linux-specific optional "registers". */
484 int s390_regmap_upper
[S390_NUM_REGS
] =
486 /* Program Status Word. */
488 /* General Purpose Registers. */
489 -1, -1, -1, -1, -1, -1, -1, -1,
490 -1, -1, -1, -1, -1, -1, -1, -1,
491 /* Access Registers. */
492 -1, -1, -1, -1, -1, -1, -1, -1,
493 -1, -1, -1, -1, -1, -1, -1, -1,
494 /* Floating Point Control Word. */
496 /* Floating Point Registers. */
497 -1, -1, -1, -1, -1, -1, -1, -1,
498 -1, -1, -1, -1, -1, -1, -1, -1,
499 /* GPR Uppper Halves. */
500 0x00, 0x04, 0x08, 0x0c,
501 0x10, 0x14, 0x18, 0x1c,
502 0x20, 0x24, 0x28, 0x2c,
503 0x30, 0x34, 0x38, 0x3c,
504 /* GNU/Linux-specific optional "registers". */
508 int s390_regmap_last_break
[S390_NUM_REGS
] =
510 /* Program Status Word. */
512 /* General Purpose Registers. */
513 -1, -1, -1, -1, -1, -1, -1, -1,
514 -1, -1, -1, -1, -1, -1, -1, -1,
515 /* Access Registers. */
516 -1, -1, -1, -1, -1, -1, -1, -1,
517 -1, -1, -1, -1, -1, -1, -1, -1,
518 /* Floating Point Control Word. */
520 /* Floating Point Registers. */
521 -1, -1, -1, -1, -1, -1, -1, -1,
522 -1, -1, -1, -1, -1, -1, -1, -1,
523 /* GPR Uppper Halves. */
524 -1, -1, -1, -1, -1, -1, -1, -1,
525 -1, -1, -1, -1, -1, -1, -1, -1,
526 /* GNU/Linux-specific optional "registers". */
530 int s390x_regmap_last_break
[S390_NUM_REGS
] =
532 /* Program Status Word. */
534 /* General Purpose Registers. */
535 -1, -1, -1, -1, -1, -1, -1, -1,
536 -1, -1, -1, -1, -1, -1, -1, -1,
537 /* Access Registers. */
538 -1, -1, -1, -1, -1, -1, -1, -1,
539 -1, -1, -1, -1, -1, -1, -1, -1,
540 /* Floating Point Control Word. */
542 /* Floating Point Registers. */
543 -1, -1, -1, -1, -1, -1, -1, -1,
544 -1, -1, -1, -1, -1, -1, -1, -1,
545 /* GPR Uppper Halves. */
546 -1, -1, -1, -1, -1, -1, -1, -1,
547 -1, -1, -1, -1, -1, -1, -1, -1,
548 /* GNU/Linux-specific optional "registers". */
552 int s390_regmap_system_call
[S390_NUM_REGS
] =
554 /* Program Status Word. */
556 /* General Purpose Registers. */
557 -1, -1, -1, -1, -1, -1, -1, -1,
558 -1, -1, -1, -1, -1, -1, -1, -1,
559 /* Access Registers. */
560 -1, -1, -1, -1, -1, -1, -1, -1,
561 -1, -1, -1, -1, -1, -1, -1, -1,
562 /* Floating Point Control Word. */
564 /* Floating Point Registers. */
565 -1, -1, -1, -1, -1, -1, -1, -1,
566 -1, -1, -1, -1, -1, -1, -1, -1,
567 /* GPR Uppper Halves. */
568 -1, -1, -1, -1, -1, -1, -1, -1,
569 -1, -1, -1, -1, -1, -1, -1, -1,
570 /* GNU/Linux-specific optional "registers". */
574 /* Supply register REGNUM from the register set REGSET to register cache
575 REGCACHE. If REGNUM is -1, do this for all registers in REGSET. */
577 s390_supply_regset (const struct regset
*regset
, struct regcache
*regcache
,
578 int regnum
, const void *regs
, size_t len
)
580 const int *offset
= regset
->descr
;
583 for (i
= 0; i
< S390_NUM_REGS
; i
++)
585 if ((regnum
== i
|| regnum
== -1) && offset
[i
] != -1)
586 regcache_raw_supply (regcache
, i
, (const char *)regs
+ offset
[i
]);
590 /* Collect register REGNUM from the register cache REGCACHE and store
591 it in the buffer specified by REGS and LEN as described by the
592 general-purpose register set REGSET. If REGNUM is -1, do this for
593 all registers in REGSET. */
595 s390_collect_regset (const struct regset
*regset
,
596 const struct regcache
*regcache
,
597 int regnum
, void *regs
, size_t len
)
599 const int *offset
= regset
->descr
;
602 for (i
= 0; i
< S390_NUM_REGS
; i
++)
604 if ((regnum
== i
|| regnum
== -1) && offset
[i
] != -1)
605 regcache_raw_collect (regcache
, i
, (char *)regs
+ offset
[i
]);
609 static const struct regset s390_gregset
= {
615 static const struct regset s390x_gregset
= {
616 s390x_regmap_gregset
,
621 static const struct regset s390_fpregset
= {
622 s390_regmap_fpregset
,
627 static const struct regset s390_upper_regset
= {
633 static const struct regset s390_last_break_regset
= {
634 s390_regmap_last_break
,
639 static const struct regset s390x_last_break_regset
= {
640 s390x_regmap_last_break
,
645 static const struct regset s390_system_call_regset
= {
646 s390_regmap_system_call
,
651 static struct core_regset_section s390_linux32_regset_sections
[] =
653 { ".reg", s390_sizeof_gregset
, "general-purpose" },
654 { ".reg2", s390_sizeof_fpregset
, "floating-point" },
658 static struct core_regset_section s390_linux32v1_regset_sections
[] =
660 { ".reg", s390_sizeof_gregset
, "general-purpose" },
661 { ".reg2", s390_sizeof_fpregset
, "floating-point" },
662 { ".reg-s390-last-break", 8, "s390 last-break address" },
666 static struct core_regset_section s390_linux32v2_regset_sections
[] =
668 { ".reg", s390_sizeof_gregset
, "general-purpose" },
669 { ".reg2", s390_sizeof_fpregset
, "floating-point" },
670 { ".reg-s390-last-break", 8, "s390 last-break address" },
671 { ".reg-s390-system-call", 4, "s390 system-call" },
675 static struct core_regset_section s390_linux64_regset_sections
[] =
677 { ".reg", s390_sizeof_gregset
, "general-purpose" },
678 { ".reg2", s390_sizeof_fpregset
, "floating-point" },
679 { ".reg-s390-high-gprs", 16*4, "s390 GPR upper halves" },
683 static struct core_regset_section s390_linux64v1_regset_sections
[] =
685 { ".reg", s390_sizeof_gregset
, "general-purpose" },
686 { ".reg2", s390_sizeof_fpregset
, "floating-point" },
687 { ".reg-s390-high-gprs", 16*4, "s390 GPR upper halves" },
688 { ".reg-s390-last-break", 8, "s930 last-break address" },
692 static struct core_regset_section s390_linux64v2_regset_sections
[] =
694 { ".reg", s390_sizeof_gregset
, "general-purpose" },
695 { ".reg2", s390_sizeof_fpregset
, "floating-point" },
696 { ".reg-s390-high-gprs", 16*4, "s390 GPR upper halves" },
697 { ".reg-s390-last-break", 8, "s930 last-break address" },
698 { ".reg-s390-system-call", 4, "s390 system-call" },
702 static struct core_regset_section s390x_linux64_regset_sections
[] =
704 { ".reg", s390x_sizeof_gregset
, "general-purpose" },
705 { ".reg2", s390_sizeof_fpregset
, "floating-point" },
709 static struct core_regset_section s390x_linux64v1_regset_sections
[] =
711 { ".reg", s390x_sizeof_gregset
, "general-purpose" },
712 { ".reg2", s390_sizeof_fpregset
, "floating-point" },
713 { ".reg-s390-last-break", 8, "s930 last-break address" },
717 static struct core_regset_section s390x_linux64v2_regset_sections
[] =
719 { ".reg", s390x_sizeof_gregset
, "general-purpose" },
720 { ".reg2", s390_sizeof_fpregset
, "floating-point" },
721 { ".reg-s390-last-break", 8, "s930 last-break address" },
722 { ".reg-s390-system-call", 4, "s390 system-call" },
727 /* Return the appropriate register set for the core section identified
728 by SECT_NAME and SECT_SIZE. */
729 static const struct regset
*
730 s390_regset_from_core_section (struct gdbarch
*gdbarch
,
731 const char *sect_name
, size_t sect_size
)
733 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
735 if (strcmp (sect_name
, ".reg") == 0 && sect_size
>= tdep
->sizeof_gregset
)
736 return tdep
->gregset
;
738 if (strcmp (sect_name
, ".reg2") == 0 && sect_size
>= tdep
->sizeof_fpregset
)
739 return tdep
->fpregset
;
741 if (strcmp (sect_name
, ".reg-s390-high-gprs") == 0 && sect_size
>= 16*4)
742 return &s390_upper_regset
;
744 if (strcmp (sect_name
, ".reg-s390-last-break") == 0 && sect_size
>= 8)
745 return (gdbarch_ptr_bit (gdbarch
) == 32
746 ? &s390_last_break_regset
: &s390x_last_break_regset
);
748 if (strcmp (sect_name
, ".reg-s390-system-call") == 0 && sect_size
>= 4)
749 return &s390_system_call_regset
;
754 static const struct target_desc
*
755 s390_core_read_description (struct gdbarch
*gdbarch
,
756 struct target_ops
*target
, bfd
*abfd
)
758 asection
*high_gprs
= bfd_get_section_by_name (abfd
, ".reg-s390-high-gprs");
759 asection
*v1
= bfd_get_section_by_name (abfd
, ".reg-s390-last-break");
760 asection
*v2
= bfd_get_section_by_name (abfd
, ".reg-s390-system-call");
761 asection
*section
= bfd_get_section_by_name (abfd
, ".reg");
765 switch (bfd_section_size (abfd
, section
))
767 case s390_sizeof_gregset
:
769 return (v2
? tdesc_s390_linux64v2
:
770 v1
? tdesc_s390_linux64v1
: tdesc_s390_linux64
);
772 return (v2
? tdesc_s390_linux32v2
:
773 v1
? tdesc_s390_linux32v1
: tdesc_s390_linux32
);
775 case s390x_sizeof_gregset
:
776 return (v2
? tdesc_s390x_linux64v2
:
777 v1
? tdesc_s390x_linux64v1
: tdesc_s390x_linux64
);
785 /* Decoding S/390 instructions. */
787 /* Named opcode values for the S/390 instructions we recognize. Some
788 instructions have their opcode split across two fields; those are the
789 op1_* and op2_* enums. */
792 op1_lhi
= 0xa7, op2_lhi
= 0x08,
793 op1_lghi
= 0xa7, op2_lghi
= 0x09,
794 op1_lgfi
= 0xc0, op2_lgfi
= 0x01,
798 op1_ly
= 0xe3, op2_ly
= 0x58,
799 op1_lg
= 0xe3, op2_lg
= 0x04,
801 op1_lmy
= 0xeb, op2_lmy
= 0x98,
802 op1_lmg
= 0xeb, op2_lmg
= 0x04,
804 op1_sty
= 0xe3, op2_sty
= 0x50,
805 op1_stg
= 0xe3, op2_stg
= 0x24,
808 op1_stmy
= 0xeb, op2_stmy
= 0x90,
809 op1_stmg
= 0xeb, op2_stmg
= 0x24,
810 op1_aghi
= 0xa7, op2_aghi
= 0x0b,
811 op1_ahi
= 0xa7, op2_ahi
= 0x0a,
812 op1_agfi
= 0xc2, op2_agfi
= 0x08,
813 op1_afi
= 0xc2, op2_afi
= 0x09,
814 op1_algfi
= 0xc2, op2_algfi
= 0x0a,
815 op1_alfi
= 0xc2, op2_alfi
= 0x0b,
819 op1_ay
= 0xe3, op2_ay
= 0x5a,
820 op1_ag
= 0xe3, op2_ag
= 0x08,
821 op1_slgfi
= 0xc2, op2_slgfi
= 0x04,
822 op1_slfi
= 0xc2, op2_slfi
= 0x05,
826 op1_sy
= 0xe3, op2_sy
= 0x5b,
827 op1_sg
= 0xe3, op2_sg
= 0x09,
831 op1_lay
= 0xe3, op2_lay
= 0x71,
832 op1_larl
= 0xc0, op2_larl
= 0x00,
840 op1_bctg
= 0xe3, op2_bctg
= 0x46,
842 op1_bxhg
= 0xeb, op2_bxhg
= 0x44,
844 op1_bxleg
= 0xeb, op2_bxleg
= 0x45,
845 op1_bras
= 0xa7, op2_bras
= 0x05,
846 op1_brasl
= 0xc0, op2_brasl
= 0x05,
847 op1_brc
= 0xa7, op2_brc
= 0x04,
848 op1_brcl
= 0xc0, op2_brcl
= 0x04,
849 op1_brct
= 0xa7, op2_brct
= 0x06,
850 op1_brctg
= 0xa7, op2_brctg
= 0x07,
852 op1_brxhg
= 0xec, op2_brxhg
= 0x44,
854 op1_brxlg
= 0xec, op2_brxlg
= 0x45,
858 /* Read a single instruction from address AT. */
860 #define S390_MAX_INSTR_SIZE 6
862 s390_readinstruction (bfd_byte instr
[], CORE_ADDR at
)
864 static int s390_instrlen
[] = { 2, 4, 4, 6 };
867 if (target_read_memory (at
, &instr
[0], 2))
869 instrlen
= s390_instrlen
[instr
[0] >> 6];
872 if (target_read_memory (at
+ 2, &instr
[2], instrlen
- 2))
879 /* The functions below are for recognizing and decoding S/390
880 instructions of various formats. Each of them checks whether INSN
881 is an instruction of the given format, with the specified opcodes.
882 If it is, it sets the remaining arguments to the values of the
883 instruction's fields, and returns a non-zero value; otherwise, it
886 These functions' arguments appear in the order they appear in the
887 instruction, not in the machine-language form. So, opcodes always
888 come first, even though they're sometimes scattered around the
889 instructions. And displacements appear before base and extension
890 registers, as they do in the assembly syntax, not at the end, as
891 they do in the machine language. */
893 is_ri (bfd_byte
*insn
, int op1
, int op2
, unsigned int *r1
, int *i2
)
895 if (insn
[0] == op1
&& (insn
[1] & 0xf) == op2
)
897 *r1
= (insn
[1] >> 4) & 0xf;
898 /* i2 is a 16-bit signed quantity. */
899 *i2
= (((insn
[2] << 8) | insn
[3]) ^ 0x8000) - 0x8000;
908 is_ril (bfd_byte
*insn
, int op1
, int op2
,
909 unsigned int *r1
, int *i2
)
911 if (insn
[0] == op1
&& (insn
[1] & 0xf) == op2
)
913 *r1
= (insn
[1] >> 4) & 0xf;
914 /* i2 is a signed quantity. If the host 'int' is 32 bits long,
915 no sign extension is necessary, but we don't want to assume
917 *i2
= (((insn
[2] << 24)
920 | (insn
[5])) ^ 0x80000000) - 0x80000000;
929 is_rr (bfd_byte
*insn
, int op
, unsigned int *r1
, unsigned int *r2
)
933 *r1
= (insn
[1] >> 4) & 0xf;
943 is_rre (bfd_byte
*insn
, int op
, unsigned int *r1
, unsigned int *r2
)
945 if (((insn
[0] << 8) | insn
[1]) == op
)
947 /* Yes, insn[3]. insn[2] is unused in RRE format. */
948 *r1
= (insn
[3] >> 4) & 0xf;
958 is_rs (bfd_byte
*insn
, int op
,
959 unsigned int *r1
, unsigned int *r3
, unsigned int *d2
, unsigned int *b2
)
963 *r1
= (insn
[1] >> 4) & 0xf;
965 *b2
= (insn
[2] >> 4) & 0xf;
966 *d2
= ((insn
[2] & 0xf) << 8) | insn
[3];
975 is_rsy (bfd_byte
*insn
, int op1
, int op2
,
976 unsigned int *r1
, unsigned int *r3
, unsigned int *d2
, unsigned int *b2
)
981 *r1
= (insn
[1] >> 4) & 0xf;
983 *b2
= (insn
[2] >> 4) & 0xf;
984 /* The 'long displacement' is a 20-bit signed integer. */
985 *d2
= ((((insn
[2] & 0xf) << 8) | insn
[3] | (insn
[4] << 12))
986 ^ 0x80000) - 0x80000;
995 is_rsi (bfd_byte
*insn
, int op
,
996 unsigned int *r1
, unsigned int *r3
, int *i2
)
1000 *r1
= (insn
[1] >> 4) & 0xf;
1001 *r3
= insn
[1] & 0xf;
1002 /* i2 is a 16-bit signed quantity. */
1003 *i2
= (((insn
[2] << 8) | insn
[3]) ^ 0x8000) - 0x8000;
1012 is_rie (bfd_byte
*insn
, int op1
, int op2
,
1013 unsigned int *r1
, unsigned int *r3
, int *i2
)
1018 *r1
= (insn
[1] >> 4) & 0xf;
1019 *r3
= insn
[1] & 0xf;
1020 /* i2 is a 16-bit signed quantity. */
1021 *i2
= (((insn
[2] << 8) | insn
[3]) ^ 0x8000) - 0x8000;
1030 is_rx (bfd_byte
*insn
, int op
,
1031 unsigned int *r1
, unsigned int *d2
, unsigned int *x2
, unsigned int *b2
)
1035 *r1
= (insn
[1] >> 4) & 0xf;
1036 *x2
= insn
[1] & 0xf;
1037 *b2
= (insn
[2] >> 4) & 0xf;
1038 *d2
= ((insn
[2] & 0xf) << 8) | insn
[3];
1047 is_rxy (bfd_byte
*insn
, int op1
, int op2
,
1048 unsigned int *r1
, unsigned int *d2
, unsigned int *x2
, unsigned int *b2
)
1053 *r1
= (insn
[1] >> 4) & 0xf;
1054 *x2
= insn
[1] & 0xf;
1055 *b2
= (insn
[2] >> 4) & 0xf;
1056 /* The 'long displacement' is a 20-bit signed integer. */
1057 *d2
= ((((insn
[2] & 0xf) << 8) | insn
[3] | (insn
[4] << 12))
1058 ^ 0x80000) - 0x80000;
1066 /* Prologue analysis. */
1068 #define S390_NUM_GPRS 16
1069 #define S390_NUM_FPRS 16
1071 struct s390_prologue_data
{
1074 struct pv_area
*stack
;
1076 /* The size and byte-order of a GPR or FPR. */
1079 enum bfd_endian byte_order
;
1081 /* The general-purpose registers. */
1082 pv_t gpr
[S390_NUM_GPRS
];
1084 /* The floating-point registers. */
1085 pv_t fpr
[S390_NUM_FPRS
];
1087 /* The offset relative to the CFA where the incoming GPR N was saved
1088 by the function prologue. 0 if not saved or unknown. */
1089 int gpr_slot
[S390_NUM_GPRS
];
1091 /* Likewise for FPRs. */
1092 int fpr_slot
[S390_NUM_FPRS
];
1094 /* Nonzero if the backchain was saved. This is assumed to be the
1095 case when the incoming SP is saved at the current SP location. */
1096 int back_chain_saved_p
;
1099 /* Return the effective address for an X-style instruction, like:
1103 Here, X2 and B2 are registers, and D2 is a signed 20-bit
1104 constant; the effective address is the sum of all three. If either
1105 X2 or B2 are zero, then it doesn't contribute to the sum --- this
1106 means that r0 can't be used as either X2 or B2. */
1108 s390_addr (struct s390_prologue_data
*data
,
1109 int d2
, unsigned int x2
, unsigned int b2
)
1113 result
= pv_constant (d2
);
1115 result
= pv_add (result
, data
->gpr
[x2
]);
1117 result
= pv_add (result
, data
->gpr
[b2
]);
1122 /* Do a SIZE-byte store of VALUE to D2(X2,B2). */
1124 s390_store (struct s390_prologue_data
*data
,
1125 int d2
, unsigned int x2
, unsigned int b2
, CORE_ADDR size
,
1128 pv_t addr
= s390_addr (data
, d2
, x2
, b2
);
1131 /* Check whether we are storing the backchain. */
1132 offset
= pv_subtract (data
->gpr
[S390_SP_REGNUM
- S390_R0_REGNUM
], addr
);
1134 if (pv_is_constant (offset
) && offset
.k
== 0)
1135 if (size
== data
->gpr_size
1136 && pv_is_register_k (value
, S390_SP_REGNUM
, 0))
1138 data
->back_chain_saved_p
= 1;
1143 /* Check whether we are storing a register into the stack. */
1144 if (!pv_area_store_would_trash (data
->stack
, addr
))
1145 pv_area_store (data
->stack
, addr
, size
, value
);
1148 /* Note: If this is some store we cannot identify, you might think we
1149 should forget our cached values, as any of those might have been hit.
1151 However, we make the assumption that the register save areas are only
1152 ever stored to once in any given function, and we do recognize these
1153 stores. Thus every store we cannot recognize does not hit our data. */
1156 /* Do a SIZE-byte load from D2(X2,B2). */
1158 s390_load (struct s390_prologue_data
*data
,
1159 int d2
, unsigned int x2
, unsigned int b2
, CORE_ADDR size
)
1162 pv_t addr
= s390_addr (data
, d2
, x2
, b2
);
1165 /* If it's a load from an in-line constant pool, then we can
1166 simulate that, under the assumption that the code isn't
1167 going to change between the time the processor actually
1168 executed it creating the current frame, and the time when
1169 we're analyzing the code to unwind past that frame. */
1170 if (pv_is_constant (addr
))
1172 struct target_section
*secp
;
1173 secp
= target_section_by_addr (¤t_target
, addr
.k
);
1175 && (bfd_get_section_flags (secp
->bfd
, secp
->the_bfd_section
)
1177 return pv_constant (read_memory_integer (addr
.k
, size
,
1181 /* Check whether we are accessing one of our save slots. */
1182 return pv_area_fetch (data
->stack
, addr
, size
);
1185 /* Function for finding saved registers in a 'struct pv_area'; we pass
1186 this to pv_area_scan.
1188 If VALUE is a saved register, ADDR says it was saved at a constant
1189 offset from the frame base, and SIZE indicates that the whole
1190 register was saved, record its offset in the reg_offset table in
1191 PROLOGUE_UNTYPED. */
1193 s390_check_for_saved (void *data_untyped
, pv_t addr
,
1194 CORE_ADDR size
, pv_t value
)
1196 struct s390_prologue_data
*data
= data_untyped
;
1199 if (!pv_is_register (addr
, S390_SP_REGNUM
))
1202 offset
= 16 * data
->gpr_size
+ 32 - addr
.k
;
1204 /* If we are storing the original value of a register, we want to
1205 record the CFA offset. If the same register is stored multiple
1206 times, the stack slot with the highest address counts. */
1208 for (i
= 0; i
< S390_NUM_GPRS
; i
++)
1209 if (size
== data
->gpr_size
1210 && pv_is_register_k (value
, S390_R0_REGNUM
+ i
, 0))
1211 if (data
->gpr_slot
[i
] == 0
1212 || data
->gpr_slot
[i
] > offset
)
1214 data
->gpr_slot
[i
] = offset
;
1218 for (i
= 0; i
< S390_NUM_FPRS
; i
++)
1219 if (size
== data
->fpr_size
1220 && pv_is_register_k (value
, S390_F0_REGNUM
+ i
, 0))
1221 if (data
->fpr_slot
[i
] == 0
1222 || data
->fpr_slot
[i
] > offset
)
1224 data
->fpr_slot
[i
] = offset
;
1229 /* Analyze the prologue of the function starting at START_PC,
1230 continuing at most until CURRENT_PC. Initialize DATA to
1231 hold all information we find out about the state of the registers
1232 and stack slots. Return the address of the instruction after
1233 the last one that changed the SP, FP, or back chain; or zero
1236 s390_analyze_prologue (struct gdbarch
*gdbarch
,
1238 CORE_ADDR current_pc
,
1239 struct s390_prologue_data
*data
)
1241 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
1243 /* Our return value:
1244 The address of the instruction after the last one that changed
1245 the SP, FP, or back chain; zero if we got an error trying to
1247 CORE_ADDR result
= start_pc
;
1249 /* The current PC for our abstract interpretation. */
1252 /* The address of the next instruction after that. */
1255 /* Set up everything's initial value. */
1259 data
->stack
= make_pv_area (S390_SP_REGNUM
, gdbarch_addr_bit (gdbarch
));
1261 /* For the purpose of prologue tracking, we consider the GPR size to
1262 be equal to the ABI word size, even if it is actually larger
1263 (i.e. when running a 32-bit binary under a 64-bit kernel). */
1264 data
->gpr_size
= word_size
;
1266 data
->byte_order
= gdbarch_byte_order (gdbarch
);
1268 for (i
= 0; i
< S390_NUM_GPRS
; i
++)
1269 data
->gpr
[i
] = pv_register (S390_R0_REGNUM
+ i
, 0);
1271 for (i
= 0; i
< S390_NUM_FPRS
; i
++)
1272 data
->fpr
[i
] = pv_register (S390_F0_REGNUM
+ i
, 0);
1274 for (i
= 0; i
< S390_NUM_GPRS
; i
++)
1275 data
->gpr_slot
[i
] = 0;
1277 for (i
= 0; i
< S390_NUM_FPRS
; i
++)
1278 data
->fpr_slot
[i
] = 0;
1280 data
->back_chain_saved_p
= 0;
1283 /* Start interpreting instructions, until we hit the frame's
1284 current PC or the first branch instruction. */
1285 for (pc
= start_pc
; pc
> 0 && pc
< current_pc
; pc
= next_pc
)
1287 bfd_byte insn
[S390_MAX_INSTR_SIZE
];
1288 int insn_len
= s390_readinstruction (insn
, pc
);
1290 bfd_byte dummy
[S390_MAX_INSTR_SIZE
] = { 0 };
1291 bfd_byte
*insn32
= word_size
== 4 ? insn
: dummy
;
1292 bfd_byte
*insn64
= word_size
== 8 ? insn
: dummy
;
1294 /* Fields for various kinds of instructions. */
1295 unsigned int b2
, r1
, r2
, x2
, r3
;
1298 /* The values of SP and FP before this instruction,
1299 for detecting instructions that change them. */
1300 pv_t pre_insn_sp
, pre_insn_fp
;
1301 /* Likewise for the flag whether the back chain was saved. */
1302 int pre_insn_back_chain_saved_p
;
1304 /* If we got an error trying to read the instruction, report it. */
1311 next_pc
= pc
+ insn_len
;
1313 pre_insn_sp
= data
->gpr
[S390_SP_REGNUM
- S390_R0_REGNUM
];
1314 pre_insn_fp
= data
->gpr
[S390_FRAME_REGNUM
- S390_R0_REGNUM
];
1315 pre_insn_back_chain_saved_p
= data
->back_chain_saved_p
;
1318 /* LHI r1, i2 --- load halfword immediate. */
1319 /* LGHI r1, i2 --- load halfword immediate (64-bit version). */
1320 /* LGFI r1, i2 --- load fullword immediate. */
1321 if (is_ri (insn32
, op1_lhi
, op2_lhi
, &r1
, &i2
)
1322 || is_ri (insn64
, op1_lghi
, op2_lghi
, &r1
, &i2
)
1323 || is_ril (insn
, op1_lgfi
, op2_lgfi
, &r1
, &i2
))
1324 data
->gpr
[r1
] = pv_constant (i2
);
1326 /* LR r1, r2 --- load from register. */
1327 /* LGR r1, r2 --- load from register (64-bit version). */
1328 else if (is_rr (insn32
, op_lr
, &r1
, &r2
)
1329 || is_rre (insn64
, op_lgr
, &r1
, &r2
))
1330 data
->gpr
[r1
] = data
->gpr
[r2
];
1332 /* L r1, d2(x2, b2) --- load. */
1333 /* LY r1, d2(x2, b2) --- load (long-displacement version). */
1334 /* LG r1, d2(x2, b2) --- load (64-bit version). */
1335 else if (is_rx (insn32
, op_l
, &r1
, &d2
, &x2
, &b2
)
1336 || is_rxy (insn32
, op1_ly
, op2_ly
, &r1
, &d2
, &x2
, &b2
)
1337 || is_rxy (insn64
, op1_lg
, op2_lg
, &r1
, &d2
, &x2
, &b2
))
1338 data
->gpr
[r1
] = s390_load (data
, d2
, x2
, b2
, data
->gpr_size
);
1340 /* ST r1, d2(x2, b2) --- store. */
1341 /* STY r1, d2(x2, b2) --- store (long-displacement version). */
1342 /* STG r1, d2(x2, b2) --- store (64-bit version). */
1343 else if (is_rx (insn32
, op_st
, &r1
, &d2
, &x2
, &b2
)
1344 || is_rxy (insn32
, op1_sty
, op2_sty
, &r1
, &d2
, &x2
, &b2
)
1345 || is_rxy (insn64
, op1_stg
, op2_stg
, &r1
, &d2
, &x2
, &b2
))
1346 s390_store (data
, d2
, x2
, b2
, data
->gpr_size
, data
->gpr
[r1
]);
1348 /* STD r1, d2(x2,b2) --- store floating-point register. */
1349 else if (is_rx (insn
, op_std
, &r1
, &d2
, &x2
, &b2
))
1350 s390_store (data
, d2
, x2
, b2
, data
->fpr_size
, data
->fpr
[r1
]);
1352 /* STM r1, r3, d2(b2) --- store multiple. */
1353 /* STMY r1, r3, d2(b2) --- store multiple (long-displacement
1355 /* STMG r1, r3, d2(b2) --- store multiple (64-bit version). */
1356 else if (is_rs (insn32
, op_stm
, &r1
, &r3
, &d2
, &b2
)
1357 || is_rsy (insn32
, op1_stmy
, op2_stmy
, &r1
, &r3
, &d2
, &b2
)
1358 || is_rsy (insn64
, op1_stmg
, op2_stmg
, &r1
, &r3
, &d2
, &b2
))
1360 for (; r1
<= r3
; r1
++, d2
+= data
->gpr_size
)
1361 s390_store (data
, d2
, 0, b2
, data
->gpr_size
, data
->gpr
[r1
]);
1364 /* AHI r1, i2 --- add halfword immediate. */
1365 /* AGHI r1, i2 --- add halfword immediate (64-bit version). */
1366 /* AFI r1, i2 --- add fullword immediate. */
1367 /* AGFI r1, i2 --- add fullword immediate (64-bit version). */
1368 else if (is_ri (insn32
, op1_ahi
, op2_ahi
, &r1
, &i2
)
1369 || is_ri (insn64
, op1_aghi
, op2_aghi
, &r1
, &i2
)
1370 || is_ril (insn32
, op1_afi
, op2_afi
, &r1
, &i2
)
1371 || is_ril (insn64
, op1_agfi
, op2_agfi
, &r1
, &i2
))
1372 data
->gpr
[r1
] = pv_add_constant (data
->gpr
[r1
], i2
);
1374 /* ALFI r1, i2 --- add logical immediate. */
1375 /* ALGFI r1, i2 --- add logical immediate (64-bit version). */
1376 else if (is_ril (insn32
, op1_alfi
, op2_alfi
, &r1
, &i2
)
1377 || is_ril (insn64
, op1_algfi
, op2_algfi
, &r1
, &i2
))
1378 data
->gpr
[r1
] = pv_add_constant (data
->gpr
[r1
],
1379 (CORE_ADDR
)i2
& 0xffffffff);
1381 /* AR r1, r2 -- add register. */
1382 /* AGR r1, r2 -- add register (64-bit version). */
1383 else if (is_rr (insn32
, op_ar
, &r1
, &r2
)
1384 || is_rre (insn64
, op_agr
, &r1
, &r2
))
1385 data
->gpr
[r1
] = pv_add (data
->gpr
[r1
], data
->gpr
[r2
]);
1387 /* A r1, d2(x2, b2) -- add. */
1388 /* AY r1, d2(x2, b2) -- add (long-displacement version). */
1389 /* AG r1, d2(x2, b2) -- add (64-bit version). */
1390 else if (is_rx (insn32
, op_a
, &r1
, &d2
, &x2
, &b2
)
1391 || is_rxy (insn32
, op1_ay
, op2_ay
, &r1
, &d2
, &x2
, &b2
)
1392 || is_rxy (insn64
, op1_ag
, op2_ag
, &r1
, &d2
, &x2
, &b2
))
1393 data
->gpr
[r1
] = pv_add (data
->gpr
[r1
],
1394 s390_load (data
, d2
, x2
, b2
, data
->gpr_size
));
1396 /* SLFI r1, i2 --- subtract logical immediate. */
1397 /* SLGFI r1, i2 --- subtract logical immediate (64-bit version). */
1398 else if (is_ril (insn32
, op1_slfi
, op2_slfi
, &r1
, &i2
)
1399 || is_ril (insn64
, op1_slgfi
, op2_slgfi
, &r1
, &i2
))
1400 data
->gpr
[r1
] = pv_add_constant (data
->gpr
[r1
],
1401 -((CORE_ADDR
)i2
& 0xffffffff));
1403 /* SR r1, r2 -- subtract register. */
1404 /* SGR r1, r2 -- subtract register (64-bit version). */
1405 else if (is_rr (insn32
, op_sr
, &r1
, &r2
)
1406 || is_rre (insn64
, op_sgr
, &r1
, &r2
))
1407 data
->gpr
[r1
] = pv_subtract (data
->gpr
[r1
], data
->gpr
[r2
]);
1409 /* S r1, d2(x2, b2) -- subtract. */
1410 /* SY r1, d2(x2, b2) -- subtract (long-displacement version). */
1411 /* SG r1, d2(x2, b2) -- subtract (64-bit version). */
1412 else if (is_rx (insn32
, op_s
, &r1
, &d2
, &x2
, &b2
)
1413 || is_rxy (insn32
, op1_sy
, op2_sy
, &r1
, &d2
, &x2
, &b2
)
1414 || is_rxy (insn64
, op1_sg
, op2_sg
, &r1
, &d2
, &x2
, &b2
))
1415 data
->gpr
[r1
] = pv_subtract (data
->gpr
[r1
],
1416 s390_load (data
, d2
, x2
, b2
, data
->gpr_size
));
1418 /* LA r1, d2(x2, b2) --- load address. */
1419 /* LAY r1, d2(x2, b2) --- load address (long-displacement version). */
1420 else if (is_rx (insn
, op_la
, &r1
, &d2
, &x2
, &b2
)
1421 || is_rxy (insn
, op1_lay
, op2_lay
, &r1
, &d2
, &x2
, &b2
))
1422 data
->gpr
[r1
] = s390_addr (data
, d2
, x2
, b2
);
1424 /* LARL r1, i2 --- load address relative long. */
1425 else if (is_ril (insn
, op1_larl
, op2_larl
, &r1
, &i2
))
1426 data
->gpr
[r1
] = pv_constant (pc
+ i2
* 2);
1428 /* BASR r1, 0 --- branch and save.
1429 Since r2 is zero, this saves the PC in r1, but doesn't branch. */
1430 else if (is_rr (insn
, op_basr
, &r1
, &r2
)
1432 data
->gpr
[r1
] = pv_constant (next_pc
);
1434 /* BRAS r1, i2 --- branch relative and save. */
1435 else if (is_ri (insn
, op1_bras
, op2_bras
, &r1
, &i2
))
1437 data
->gpr
[r1
] = pv_constant (next_pc
);
1438 next_pc
= pc
+ i2
* 2;
1440 /* We'd better not interpret any backward branches. We'll
1446 /* Terminate search when hitting any other branch instruction. */
1447 else if (is_rr (insn
, op_basr
, &r1
, &r2
)
1448 || is_rx (insn
, op_bas
, &r1
, &d2
, &x2
, &b2
)
1449 || is_rr (insn
, op_bcr
, &r1
, &r2
)
1450 || is_rx (insn
, op_bc
, &r1
, &d2
, &x2
, &b2
)
1451 || is_ri (insn
, op1_brc
, op2_brc
, &r1
, &i2
)
1452 || is_ril (insn
, op1_brcl
, op2_brcl
, &r1
, &i2
)
1453 || is_ril (insn
, op1_brasl
, op2_brasl
, &r2
, &i2
))
1457 /* An instruction we don't know how to simulate. The only
1458 safe thing to do would be to set every value we're tracking
1459 to 'unknown'. Instead, we'll be optimistic: we assume that
1460 we *can* interpret every instruction that the compiler uses
1461 to manipulate any of the data we're interested in here --
1462 then we can just ignore anything else. */
1465 /* Record the address after the last instruction that changed
1466 the FP, SP, or backlink. Ignore instructions that changed
1467 them back to their original values --- those are probably
1468 restore instructions. (The back chain is never restored,
1471 pv_t sp
= data
->gpr
[S390_SP_REGNUM
- S390_R0_REGNUM
];
1472 pv_t fp
= data
->gpr
[S390_FRAME_REGNUM
- S390_R0_REGNUM
];
1474 if ((! pv_is_identical (pre_insn_sp
, sp
)
1475 && ! pv_is_register_k (sp
, S390_SP_REGNUM
, 0)
1476 && sp
.kind
!= pvk_unknown
)
1477 || (! pv_is_identical (pre_insn_fp
, fp
)
1478 && ! pv_is_register_k (fp
, S390_FRAME_REGNUM
, 0)
1479 && fp
.kind
!= pvk_unknown
)
1480 || pre_insn_back_chain_saved_p
!= data
->back_chain_saved_p
)
1485 /* Record where all the registers were saved. */
1486 pv_area_scan (data
->stack
, s390_check_for_saved
, data
);
1488 free_pv_area (data
->stack
);
1494 /* Advance PC across any function entry prologue instructions to reach
1495 some "real" code. */
1497 s390_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
1499 struct s390_prologue_data data
;
1501 skip_pc
= s390_analyze_prologue (gdbarch
, pc
, (CORE_ADDR
)-1, &data
);
1502 return skip_pc
? skip_pc
: pc
;
1505 /* Return true if we are in the functin's epilogue, i.e. after the
1506 instruction that destroyed the function's stack frame. */
1508 s390_in_function_epilogue_p (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
1510 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
1512 /* In frameless functions, there's not frame to destroy and thus
1513 we don't care about the epilogue.
1515 In functions with frame, the epilogue sequence is a pair of
1516 a LM-type instruction that restores (amongst others) the
1517 return register %r14 and the stack pointer %r15, followed
1518 by a branch 'br %r14' --or equivalent-- that effects the
1521 In that situation, this function needs to return 'true' in
1522 exactly one case: when pc points to that branch instruction.
1524 Thus we try to disassemble the one instructions immediately
1525 preceding pc and check whether it is an LM-type instruction
1526 modifying the stack pointer.
1528 Note that disassembling backwards is not reliable, so there
1529 is a slight chance of false positives here ... */
1532 unsigned int r1
, r3
, b2
;
1536 && !target_read_memory (pc
- 4, insn
, 4)
1537 && is_rs (insn
, op_lm
, &r1
, &r3
, &d2
, &b2
)
1538 && r3
== S390_SP_REGNUM
- S390_R0_REGNUM
)
1542 && !target_read_memory (pc
- 6, insn
, 6)
1543 && is_rsy (insn
, op1_lmy
, op2_lmy
, &r1
, &r3
, &d2
, &b2
)
1544 && r3
== S390_SP_REGNUM
- S390_R0_REGNUM
)
1548 && !target_read_memory (pc
- 6, insn
, 6)
1549 && is_rsy (insn
, op1_lmg
, op2_lmg
, &r1
, &r3
, &d2
, &b2
)
1550 && r3
== S390_SP_REGNUM
- S390_R0_REGNUM
)
1556 /* Displaced stepping. */
1558 /* Fix up the state of registers and memory after having single-stepped
1559 a displaced instruction. */
1561 s390_displaced_step_fixup (struct gdbarch
*gdbarch
,
1562 struct displaced_step_closure
*closure
,
1563 CORE_ADDR from
, CORE_ADDR to
,
1564 struct regcache
*regs
)
1566 /* Since we use simple_displaced_step_copy_insn, our closure is a
1567 copy of the instruction. */
1568 gdb_byte
*insn
= (gdb_byte
*) closure
;
1569 static int s390_instrlen
[] = { 2, 4, 4, 6 };
1570 int insnlen
= s390_instrlen
[insn
[0] >> 6];
1572 /* Fields for various kinds of instructions. */
1573 unsigned int b2
, r1
, r2
, x2
, r3
;
1576 /* Get current PC and addressing mode bit. */
1577 CORE_ADDR pc
= regcache_read_pc (regs
);
1580 if (register_size (gdbarch
, S390_PSWA_REGNUM
) == 4)
1582 regcache_cooked_read_unsigned (regs
, S390_PSWA_REGNUM
, &amode
);
1583 amode
&= 0x80000000;
1586 if (debug_displaced
)
1587 fprintf_unfiltered (gdb_stdlog
,
1588 "displaced: (s390) fixup (%s, %s) pc %s len %d amode 0x%x\n",
1589 paddress (gdbarch
, from
), paddress (gdbarch
, to
),
1590 paddress (gdbarch
, pc
), insnlen
, (int) amode
);
1592 /* Handle absolute branch and save instructions. */
1593 if (is_rr (insn
, op_basr
, &r1
, &r2
)
1594 || is_rx (insn
, op_bas
, &r1
, &d2
, &x2
, &b2
))
1596 /* Recompute saved return address in R1. */
1597 regcache_cooked_write_unsigned (regs
, S390_R0_REGNUM
+ r1
,
1598 amode
| (from
+ insnlen
));
1601 /* Handle absolute branch instructions. */
1602 else if (is_rr (insn
, op_bcr
, &r1
, &r2
)
1603 || is_rx (insn
, op_bc
, &r1
, &d2
, &x2
, &b2
)
1604 || is_rr (insn
, op_bctr
, &r1
, &r2
)
1605 || is_rre (insn
, op_bctgr
, &r1
, &r2
)
1606 || is_rx (insn
, op_bct
, &r1
, &d2
, &x2
, &b2
)
1607 || is_rxy (insn
, op1_bctg
, op2_brctg
, &r1
, &d2
, &x2
, &b2
)
1608 || is_rs (insn
, op_bxh
, &r1
, &r3
, &d2
, &b2
)
1609 || is_rsy (insn
, op1_bxhg
, op2_bxhg
, &r1
, &r3
, &d2
, &b2
)
1610 || is_rs (insn
, op_bxle
, &r1
, &r3
, &d2
, &b2
)
1611 || is_rsy (insn
, op1_bxleg
, op2_bxleg
, &r1
, &r3
, &d2
, &b2
))
1613 /* Update PC iff branch was *not* taken. */
1614 if (pc
== to
+ insnlen
)
1615 regcache_write_pc (regs
, from
+ insnlen
);
1618 /* Handle PC-relative branch and save instructions. */
1619 else if (is_ri (insn
, op1_bras
, op2_bras
, &r1
, &i2
)
1620 || is_ril (insn
, op1_brasl
, op2_brasl
, &r1
, &i2
))
1623 regcache_write_pc (regs
, pc
- to
+ from
);
1624 /* Recompute saved return address in R1. */
1625 regcache_cooked_write_unsigned (regs
, S390_R0_REGNUM
+ r1
,
1626 amode
| (from
+ insnlen
));
1629 /* Handle PC-relative branch instructions. */
1630 else if (is_ri (insn
, op1_brc
, op2_brc
, &r1
, &i2
)
1631 || is_ril (insn
, op1_brcl
, op2_brcl
, &r1
, &i2
)
1632 || is_ri (insn
, op1_brct
, op2_brct
, &r1
, &i2
)
1633 || is_ri (insn
, op1_brctg
, op2_brctg
, &r1
, &i2
)
1634 || is_rsi (insn
, op_brxh
, &r1
, &r3
, &i2
)
1635 || is_rie (insn
, op1_brxhg
, op2_brxhg
, &r1
, &r3
, &i2
)
1636 || is_rsi (insn
, op_brxle
, &r1
, &r3
, &i2
)
1637 || is_rie (insn
, op1_brxlg
, op2_brxlg
, &r1
, &r3
, &i2
))
1640 regcache_write_pc (regs
, pc
- to
+ from
);
1643 /* Handle LOAD ADDRESS RELATIVE LONG. */
1644 else if (is_ril (insn
, op1_larl
, op2_larl
, &r1
, &i2
))
1647 regcache_write_pc (regs
, from
+ insnlen
);
1648 /* Recompute output address in R1. */
1649 regcache_cooked_write_unsigned (regs
, S390_R0_REGNUM
+ r1
,
1650 amode
| (from
+ i2
* 2));
1653 /* If we executed a breakpoint instruction, point PC right back at it. */
1654 else if (insn
[0] == 0x0 && insn
[1] == 0x1)
1655 regcache_write_pc (regs
, from
);
1657 /* For any other insn, PC points right after the original instruction. */
1659 regcache_write_pc (regs
, from
+ insnlen
);
1661 if (debug_displaced
)
1662 fprintf_unfiltered (gdb_stdlog
,
1663 "displaced: (s390) pc is now %s\n",
1664 paddress (gdbarch
, regcache_read_pc (regs
)));
1668 /* Helper routine to unwind pseudo registers. */
1670 static struct value
*
1671 s390_unwind_pseudo_register (struct frame_info
*this_frame
, int regnum
)
1673 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1674 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1675 struct type
*type
= register_type (gdbarch
, regnum
);
1677 /* Unwind PC via PSW address. */
1678 if (regnum
== tdep
->pc_regnum
)
1682 val
= frame_unwind_register_value (this_frame
, S390_PSWA_REGNUM
);
1683 if (!value_optimized_out (val
))
1685 LONGEST pswa
= value_as_long (val
);
1687 if (TYPE_LENGTH (type
) == 4)
1688 return value_from_pointer (type
, pswa
& 0x7fffffff);
1690 return value_from_pointer (type
, pswa
);
1694 /* Unwind CC via PSW mask. */
1695 if (regnum
== tdep
->cc_regnum
)
1699 val
= frame_unwind_register_value (this_frame
, S390_PSWM_REGNUM
);
1700 if (!value_optimized_out (val
))
1702 LONGEST pswm
= value_as_long (val
);
1704 if (TYPE_LENGTH (type
) == 4)
1705 return value_from_longest (type
, (pswm
>> 12) & 3);
1707 return value_from_longest (type
, (pswm
>> 44) & 3);
1711 /* Unwind full GPRs to show at least the lower halves (as the
1712 upper halves are undefined). */
1713 if (tdep
->gpr_full_regnum
!= -1
1714 && regnum
>= tdep
->gpr_full_regnum
1715 && regnum
< tdep
->gpr_full_regnum
+ 16)
1717 int reg
= regnum
- tdep
->gpr_full_regnum
;
1720 val
= frame_unwind_register_value (this_frame
, S390_R0_REGNUM
+ reg
);
1721 if (!value_optimized_out (val
))
1722 return value_cast (type
, val
);
1725 return allocate_optimized_out_value (type
);
1728 static struct value
*
1729 s390_trad_frame_prev_register (struct frame_info
*this_frame
,
1730 struct trad_frame_saved_reg saved_regs
[],
1733 if (regnum
< S390_NUM_REGS
)
1734 return trad_frame_get_prev_register (this_frame
, saved_regs
, regnum
);
1736 return s390_unwind_pseudo_register (this_frame
, regnum
);
1740 /* Normal stack frames. */
1742 struct s390_unwind_cache
{
1745 CORE_ADDR frame_base
;
1746 CORE_ADDR local_base
;
1748 struct trad_frame_saved_reg
*saved_regs
;
1752 s390_prologue_frame_unwind_cache (struct frame_info
*this_frame
,
1753 struct s390_unwind_cache
*info
)
1755 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1756 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
1757 struct s390_prologue_data data
;
1758 pv_t
*fp
= &data
.gpr
[S390_FRAME_REGNUM
- S390_R0_REGNUM
];
1759 pv_t
*sp
= &data
.gpr
[S390_SP_REGNUM
- S390_R0_REGNUM
];
1768 struct frame_info
*next_frame
;
1770 /* Try to find the function start address. If we can't find it, we don't
1771 bother searching for it -- with modern compilers this would be mostly
1772 pointless anyway. Trust that we'll either have valid DWARF-2 CFI data
1773 or else a valid backchain ... */
1774 func
= get_frame_func (this_frame
);
1778 /* Try to analyze the prologue. */
1779 result
= s390_analyze_prologue (gdbarch
, func
,
1780 get_frame_pc (this_frame
), &data
);
1784 /* If this was successful, we should have found the instruction that
1785 sets the stack pointer register to the previous value of the stack
1786 pointer minus the frame size. */
1787 if (!pv_is_register (*sp
, S390_SP_REGNUM
))
1790 /* A frame size of zero at this point can mean either a real
1791 frameless function, or else a failure to find the prologue.
1792 Perform some sanity checks to verify we really have a
1793 frameless function. */
1796 /* If the next frame is a NORMAL_FRAME, this frame *cannot* have frame
1797 size zero. This is only possible if the next frame is a sentinel
1798 frame, a dummy frame, or a signal trampoline frame. */
1799 /* FIXME: cagney/2004-05-01: This sanity check shouldn't be
1800 needed, instead the code should simpliy rely on its
1802 next_frame
= get_next_frame (this_frame
);
1803 while (next_frame
&& get_frame_type (next_frame
) == INLINE_FRAME
)
1804 next_frame
= get_next_frame (next_frame
);
1806 && get_frame_type (get_next_frame (this_frame
)) == NORMAL_FRAME
)
1809 /* If we really have a frameless function, %r14 must be valid
1810 -- in particular, it must point to a different function. */
1811 reg
= get_frame_register_unsigned (this_frame
, S390_RETADDR_REGNUM
);
1812 reg
= gdbarch_addr_bits_remove (gdbarch
, reg
) - 1;
1813 if (get_pc_function_start (reg
) == func
)
1815 /* However, there is one case where it *is* valid for %r14
1816 to point to the same function -- if this is a recursive
1817 call, and we have stopped in the prologue *before* the
1818 stack frame was allocated.
1820 Recognize this case by looking ahead a bit ... */
1822 struct s390_prologue_data data2
;
1823 pv_t
*sp
= &data2
.gpr
[S390_SP_REGNUM
- S390_R0_REGNUM
];
1825 if (!(s390_analyze_prologue (gdbarch
, func
, (CORE_ADDR
)-1, &data2
)
1826 && pv_is_register (*sp
, S390_SP_REGNUM
)
1833 /* OK, we've found valid prologue data. */
1836 /* If the frame pointer originally also holds the same value
1837 as the stack pointer, we're probably using it. If it holds
1838 some other value -- even a constant offset -- it is most
1839 likely used as temp register. */
1840 if (pv_is_identical (*sp
, *fp
))
1841 frame_pointer
= S390_FRAME_REGNUM
;
1843 frame_pointer
= S390_SP_REGNUM
;
1845 /* If we've detected a function with stack frame, we'll still have to
1846 treat it as frameless if we're currently within the function epilog
1847 code at a point where the frame pointer has already been restored.
1848 This can only happen in an innermost frame. */
1849 /* FIXME: cagney/2004-05-01: This sanity check shouldn't be needed,
1850 instead the code should simpliy rely on its analysis. */
1851 next_frame
= get_next_frame (this_frame
);
1852 while (next_frame
&& get_frame_type (next_frame
) == INLINE_FRAME
)
1853 next_frame
= get_next_frame (next_frame
);
1855 && (next_frame
== NULL
1856 || get_frame_type (get_next_frame (this_frame
)) != NORMAL_FRAME
))
1858 /* See the comment in s390_in_function_epilogue_p on why this is
1859 not completely reliable ... */
1860 if (s390_in_function_epilogue_p (gdbarch
, get_frame_pc (this_frame
)))
1862 memset (&data
, 0, sizeof (data
));
1864 frame_pointer
= S390_SP_REGNUM
;
1868 /* Once we know the frame register and the frame size, we can unwind
1869 the current value of the frame register from the next frame, and
1870 add back the frame size to arrive that the previous frame's
1871 stack pointer value. */
1872 prev_sp
= get_frame_register_unsigned (this_frame
, frame_pointer
) + size
;
1873 cfa
= prev_sp
+ 16*word_size
+ 32;
1875 /* Set up ABI call-saved/call-clobbered registers. */
1876 for (i
= 0; i
< S390_NUM_REGS
; i
++)
1877 if (!s390_register_call_saved (gdbarch
, i
))
1878 trad_frame_set_unknown (info
->saved_regs
, i
);
1880 /* CC is always call-clobbered. */
1881 trad_frame_set_unknown (info
->saved_regs
, S390_PSWM_REGNUM
);
1883 /* Record the addresses of all register spill slots the prologue parser
1884 has recognized. Consider only registers defined as call-saved by the
1885 ABI; for call-clobbered registers the parser may have recognized
1888 for (i
= 0; i
< 16; i
++)
1889 if (s390_register_call_saved (gdbarch
, S390_R0_REGNUM
+ i
)
1890 && data
.gpr_slot
[i
] != 0)
1891 info
->saved_regs
[S390_R0_REGNUM
+ i
].addr
= cfa
- data
.gpr_slot
[i
];
1893 for (i
= 0; i
< 16; i
++)
1894 if (s390_register_call_saved (gdbarch
, S390_F0_REGNUM
+ i
)
1895 && data
.fpr_slot
[i
] != 0)
1896 info
->saved_regs
[S390_F0_REGNUM
+ i
].addr
= cfa
- data
.fpr_slot
[i
];
1898 /* Function return will set PC to %r14. */
1899 info
->saved_regs
[S390_PSWA_REGNUM
] = info
->saved_regs
[S390_RETADDR_REGNUM
];
1901 /* In frameless functions, we unwind simply by moving the return
1902 address to the PC. However, if we actually stored to the
1903 save area, use that -- we might only think the function frameless
1904 because we're in the middle of the prologue ... */
1906 && !trad_frame_addr_p (info
->saved_regs
, S390_PSWA_REGNUM
))
1908 info
->saved_regs
[S390_PSWA_REGNUM
].realreg
= S390_RETADDR_REGNUM
;
1911 /* Another sanity check: unless this is a frameless function,
1912 we should have found spill slots for SP and PC.
1913 If not, we cannot unwind further -- this happens e.g. in
1914 libc's thread_start routine. */
1917 if (!trad_frame_addr_p (info
->saved_regs
, S390_SP_REGNUM
)
1918 || !trad_frame_addr_p (info
->saved_regs
, S390_PSWA_REGNUM
))
1922 /* We use the current value of the frame register as local_base,
1923 and the top of the register save area as frame_base. */
1926 info
->frame_base
= prev_sp
+ 16*word_size
+ 32;
1927 info
->local_base
= prev_sp
- size
;
1935 s390_backchain_frame_unwind_cache (struct frame_info
*this_frame
,
1936 struct s390_unwind_cache
*info
)
1938 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1939 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
1940 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1941 CORE_ADDR backchain
;
1946 /* Set up ABI call-saved/call-clobbered registers. */
1947 for (i
= 0; i
< S390_NUM_REGS
; i
++)
1948 if (!s390_register_call_saved (gdbarch
, i
))
1949 trad_frame_set_unknown (info
->saved_regs
, i
);
1951 /* CC is always call-clobbered. */
1952 trad_frame_set_unknown (info
->saved_regs
, S390_PSWM_REGNUM
);
1954 /* Get the backchain. */
1955 reg
= get_frame_register_unsigned (this_frame
, S390_SP_REGNUM
);
1956 backchain
= read_memory_unsigned_integer (reg
, word_size
, byte_order
);
1958 /* A zero backchain terminates the frame chain. As additional
1959 sanity check, let's verify that the spill slot for SP in the
1960 save area pointed to by the backchain in fact links back to
1963 && safe_read_memory_integer (backchain
+ 15*word_size
,
1964 word_size
, byte_order
, &sp
)
1965 && (CORE_ADDR
)sp
== backchain
)
1967 /* We don't know which registers were saved, but it will have
1968 to be at least %r14 and %r15. This will allow us to continue
1969 unwinding, but other prev-frame registers may be incorrect ... */
1970 info
->saved_regs
[S390_SP_REGNUM
].addr
= backchain
+ 15*word_size
;
1971 info
->saved_regs
[S390_RETADDR_REGNUM
].addr
= backchain
+ 14*word_size
;
1973 /* Function return will set PC to %r14. */
1974 info
->saved_regs
[S390_PSWA_REGNUM
]
1975 = info
->saved_regs
[S390_RETADDR_REGNUM
];
1977 /* We use the current value of the frame register as local_base,
1978 and the top of the register save area as frame_base. */
1979 info
->frame_base
= backchain
+ 16*word_size
+ 32;
1980 info
->local_base
= reg
;
1983 info
->func
= get_frame_pc (this_frame
);
1986 static struct s390_unwind_cache
*
1987 s390_frame_unwind_cache (struct frame_info
*this_frame
,
1988 void **this_prologue_cache
)
1990 struct s390_unwind_cache
*info
;
1991 if (*this_prologue_cache
)
1992 return *this_prologue_cache
;
1994 info
= FRAME_OBSTACK_ZALLOC (struct s390_unwind_cache
);
1995 *this_prologue_cache
= info
;
1996 info
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
1998 info
->frame_base
= -1;
1999 info
->local_base
= -1;
2001 /* Try to use prologue analysis to fill the unwind cache.
2002 If this fails, fall back to reading the stack backchain. */
2003 if (!s390_prologue_frame_unwind_cache (this_frame
, info
))
2004 s390_backchain_frame_unwind_cache (this_frame
, info
);
2010 s390_frame_this_id (struct frame_info
*this_frame
,
2011 void **this_prologue_cache
,
2012 struct frame_id
*this_id
)
2014 struct s390_unwind_cache
*info
2015 = s390_frame_unwind_cache (this_frame
, this_prologue_cache
);
2017 if (info
->frame_base
== -1)
2020 *this_id
= frame_id_build (info
->frame_base
, info
->func
);
2023 static struct value
*
2024 s390_frame_prev_register (struct frame_info
*this_frame
,
2025 void **this_prologue_cache
, int regnum
)
2027 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2028 struct s390_unwind_cache
*info
2029 = s390_frame_unwind_cache (this_frame
, this_prologue_cache
);
2031 return s390_trad_frame_prev_register (this_frame
, info
->saved_regs
, regnum
);
2034 static const struct frame_unwind s390_frame_unwind
= {
2036 default_frame_unwind_stop_reason
,
2038 s390_frame_prev_register
,
2040 default_frame_sniffer
2044 /* Code stubs and their stack frames. For things like PLTs and NULL
2045 function calls (where there is no true frame and the return address
2046 is in the RETADDR register). */
2048 struct s390_stub_unwind_cache
2050 CORE_ADDR frame_base
;
2051 struct trad_frame_saved_reg
*saved_regs
;
2054 static struct s390_stub_unwind_cache
*
2055 s390_stub_frame_unwind_cache (struct frame_info
*this_frame
,
2056 void **this_prologue_cache
)
2058 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2059 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
2060 struct s390_stub_unwind_cache
*info
;
2063 if (*this_prologue_cache
)
2064 return *this_prologue_cache
;
2066 info
= FRAME_OBSTACK_ZALLOC (struct s390_stub_unwind_cache
);
2067 *this_prologue_cache
= info
;
2068 info
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
2070 /* The return address is in register %r14. */
2071 info
->saved_regs
[S390_PSWA_REGNUM
].realreg
= S390_RETADDR_REGNUM
;
2073 /* Retrieve stack pointer and determine our frame base. */
2074 reg
= get_frame_register_unsigned (this_frame
, S390_SP_REGNUM
);
2075 info
->frame_base
= reg
+ 16*word_size
+ 32;
2081 s390_stub_frame_this_id (struct frame_info
*this_frame
,
2082 void **this_prologue_cache
,
2083 struct frame_id
*this_id
)
2085 struct s390_stub_unwind_cache
*info
2086 = s390_stub_frame_unwind_cache (this_frame
, this_prologue_cache
);
2087 *this_id
= frame_id_build (info
->frame_base
, get_frame_pc (this_frame
));
2090 static struct value
*
2091 s390_stub_frame_prev_register (struct frame_info
*this_frame
,
2092 void **this_prologue_cache
, int regnum
)
2094 struct s390_stub_unwind_cache
*info
2095 = s390_stub_frame_unwind_cache (this_frame
, this_prologue_cache
);
2096 return s390_trad_frame_prev_register (this_frame
, info
->saved_regs
, regnum
);
2100 s390_stub_frame_sniffer (const struct frame_unwind
*self
,
2101 struct frame_info
*this_frame
,
2102 void **this_prologue_cache
)
2104 CORE_ADDR addr_in_block
;
2105 bfd_byte insn
[S390_MAX_INSTR_SIZE
];
2107 /* If the current PC points to non-readable memory, we assume we
2108 have trapped due to an invalid function pointer call. We handle
2109 the non-existing current function like a PLT stub. */
2110 addr_in_block
= get_frame_address_in_block (this_frame
);
2111 if (in_plt_section (addr_in_block
, NULL
)
2112 || s390_readinstruction (insn
, get_frame_pc (this_frame
)) < 0)
2117 static const struct frame_unwind s390_stub_frame_unwind
= {
2119 default_frame_unwind_stop_reason
,
2120 s390_stub_frame_this_id
,
2121 s390_stub_frame_prev_register
,
2123 s390_stub_frame_sniffer
2127 /* Signal trampoline stack frames. */
2129 struct s390_sigtramp_unwind_cache
{
2130 CORE_ADDR frame_base
;
2131 struct trad_frame_saved_reg
*saved_regs
;
2134 static struct s390_sigtramp_unwind_cache
*
2135 s390_sigtramp_frame_unwind_cache (struct frame_info
*this_frame
,
2136 void **this_prologue_cache
)
2138 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2139 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2140 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
2141 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2142 struct s390_sigtramp_unwind_cache
*info
;
2143 ULONGEST this_sp
, prev_sp
;
2144 CORE_ADDR next_ra
, next_cfa
, sigreg_ptr
, sigreg_high_off
;
2147 if (*this_prologue_cache
)
2148 return *this_prologue_cache
;
2150 info
= FRAME_OBSTACK_ZALLOC (struct s390_sigtramp_unwind_cache
);
2151 *this_prologue_cache
= info
;
2152 info
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
2154 this_sp
= get_frame_register_unsigned (this_frame
, S390_SP_REGNUM
);
2155 next_ra
= get_frame_pc (this_frame
);
2156 next_cfa
= this_sp
+ 16*word_size
+ 32;
2158 /* New-style RT frame:
2159 retcode + alignment (8 bytes)
2161 ucontext (contains sigregs at offset 5 words). */
2162 if (next_ra
== next_cfa
)
2164 sigreg_ptr
= next_cfa
+ 8 + 128 + align_up (5*word_size
, 8);
2165 /* sigregs are followed by uc_sigmask (8 bytes), then by the
2166 upper GPR halves if present. */
2167 sigreg_high_off
= 8;
2170 /* Old-style RT frame and all non-RT frames:
2171 old signal mask (8 bytes)
2172 pointer to sigregs. */
2175 sigreg_ptr
= read_memory_unsigned_integer (next_cfa
+ 8,
2176 word_size
, byte_order
);
2177 /* sigregs are followed by signo (4 bytes), then by the
2178 upper GPR halves if present. */
2179 sigreg_high_off
= 4;
2182 /* The sigregs structure looks like this:
2191 /* PSW mask and address. */
2192 info
->saved_regs
[S390_PSWM_REGNUM
].addr
= sigreg_ptr
;
2193 sigreg_ptr
+= word_size
;
2194 info
->saved_regs
[S390_PSWA_REGNUM
].addr
= sigreg_ptr
;
2195 sigreg_ptr
+= word_size
;
2197 /* Then the GPRs. */
2198 for (i
= 0; i
< 16; i
++)
2200 info
->saved_regs
[S390_R0_REGNUM
+ i
].addr
= sigreg_ptr
;
2201 sigreg_ptr
+= word_size
;
2204 /* Then the ACRs. */
2205 for (i
= 0; i
< 16; i
++)
2207 info
->saved_regs
[S390_A0_REGNUM
+ i
].addr
= sigreg_ptr
;
2211 /* The floating-point control word. */
2212 info
->saved_regs
[S390_FPC_REGNUM
].addr
= sigreg_ptr
;
2215 /* And finally the FPRs. */
2216 for (i
= 0; i
< 16; i
++)
2218 info
->saved_regs
[S390_F0_REGNUM
+ i
].addr
= sigreg_ptr
;
2222 /* If we have them, the GPR upper halves are appended at the end. */
2223 sigreg_ptr
+= sigreg_high_off
;
2224 if (tdep
->gpr_full_regnum
!= -1)
2225 for (i
= 0; i
< 16; i
++)
2227 info
->saved_regs
[S390_R0_UPPER_REGNUM
+ i
].addr
= sigreg_ptr
;
2231 /* Restore the previous frame's SP. */
2232 prev_sp
= read_memory_unsigned_integer (
2233 info
->saved_regs
[S390_SP_REGNUM
].addr
,
2234 word_size
, byte_order
);
2236 /* Determine our frame base. */
2237 info
->frame_base
= prev_sp
+ 16*word_size
+ 32;
2243 s390_sigtramp_frame_this_id (struct frame_info
*this_frame
,
2244 void **this_prologue_cache
,
2245 struct frame_id
*this_id
)
2247 struct s390_sigtramp_unwind_cache
*info
2248 = s390_sigtramp_frame_unwind_cache (this_frame
, this_prologue_cache
);
2249 *this_id
= frame_id_build (info
->frame_base
, get_frame_pc (this_frame
));
2252 static struct value
*
2253 s390_sigtramp_frame_prev_register (struct frame_info
*this_frame
,
2254 void **this_prologue_cache
, int regnum
)
2256 struct s390_sigtramp_unwind_cache
*info
2257 = s390_sigtramp_frame_unwind_cache (this_frame
, this_prologue_cache
);
2258 return s390_trad_frame_prev_register (this_frame
, info
->saved_regs
, regnum
);
2262 s390_sigtramp_frame_sniffer (const struct frame_unwind
*self
,
2263 struct frame_info
*this_frame
,
2264 void **this_prologue_cache
)
2266 CORE_ADDR pc
= get_frame_pc (this_frame
);
2267 bfd_byte sigreturn
[2];
2269 if (target_read_memory (pc
, sigreturn
, 2))
2272 if (sigreturn
[0] != 0x0a /* svc */)
2275 if (sigreturn
[1] != 119 /* sigreturn */
2276 && sigreturn
[1] != 173 /* rt_sigreturn */)
2282 static const struct frame_unwind s390_sigtramp_frame_unwind
= {
2284 default_frame_unwind_stop_reason
,
2285 s390_sigtramp_frame_this_id
,
2286 s390_sigtramp_frame_prev_register
,
2288 s390_sigtramp_frame_sniffer
2292 /* Frame base handling. */
2295 s390_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
2297 struct s390_unwind_cache
*info
2298 = s390_frame_unwind_cache (this_frame
, this_cache
);
2299 return info
->frame_base
;
2303 s390_local_base_address (struct frame_info
*this_frame
, void **this_cache
)
2305 struct s390_unwind_cache
*info
2306 = s390_frame_unwind_cache (this_frame
, this_cache
);
2307 return info
->local_base
;
2310 static const struct frame_base s390_frame_base
= {
2312 s390_frame_base_address
,
2313 s390_local_base_address
,
2314 s390_local_base_address
2318 s390_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2320 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2322 pc
= frame_unwind_register_unsigned (next_frame
, tdep
->pc_regnum
);
2323 return gdbarch_addr_bits_remove (gdbarch
, pc
);
2327 s390_unwind_sp (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2330 sp
= frame_unwind_register_unsigned (next_frame
, S390_SP_REGNUM
);
2331 return gdbarch_addr_bits_remove (gdbarch
, sp
);
2335 /* DWARF-2 frame support. */
2337 static struct value
*
2338 s390_dwarf2_prev_register (struct frame_info
*this_frame
, void **this_cache
,
2341 return s390_unwind_pseudo_register (this_frame
, regnum
);
2345 s390_dwarf2_frame_init_reg (struct gdbarch
*gdbarch
, int regnum
,
2346 struct dwarf2_frame_state_reg
*reg
,
2347 struct frame_info
*this_frame
)
2349 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2351 /* The condition code (and thus PSW mask) is call-clobbered. */
2352 if (regnum
== S390_PSWM_REGNUM
)
2353 reg
->how
= DWARF2_FRAME_REG_UNDEFINED
;
2355 /* The PSW address unwinds to the return address. */
2356 else if (regnum
== S390_PSWA_REGNUM
)
2357 reg
->how
= DWARF2_FRAME_REG_RA
;
2359 /* Fixed registers are call-saved or call-clobbered
2360 depending on the ABI in use. */
2361 else if (regnum
< S390_NUM_REGS
)
2363 if (s390_register_call_saved (gdbarch
, regnum
))
2364 reg
->how
= DWARF2_FRAME_REG_SAME_VALUE
;
2366 reg
->how
= DWARF2_FRAME_REG_UNDEFINED
;
2369 /* We install a special function to unwind pseudos. */
2372 reg
->how
= DWARF2_FRAME_REG_FN
;
2373 reg
->loc
.fn
= s390_dwarf2_prev_register
;
2378 /* Dummy function calls. */
2380 /* Return non-zero if TYPE is an integer-like type, zero otherwise.
2381 "Integer-like" types are those that should be passed the way
2382 integers are: integers, enums, ranges, characters, and booleans. */
2384 is_integer_like (struct type
*type
)
2386 enum type_code code
= TYPE_CODE (type
);
2388 return (code
== TYPE_CODE_INT
2389 || code
== TYPE_CODE_ENUM
2390 || code
== TYPE_CODE_RANGE
2391 || code
== TYPE_CODE_CHAR
2392 || code
== TYPE_CODE_BOOL
);
2395 /* Return non-zero if TYPE is a pointer-like type, zero otherwise.
2396 "Pointer-like" types are those that should be passed the way
2397 pointers are: pointers and references. */
2399 is_pointer_like (struct type
*type
)
2401 enum type_code code
= TYPE_CODE (type
);
2403 return (code
== TYPE_CODE_PTR
2404 || code
== TYPE_CODE_REF
);
2408 /* Return non-zero if TYPE is a `float singleton' or `double
2409 singleton', zero otherwise.
2411 A `T singleton' is a struct type with one member, whose type is
2412 either T or a `T singleton'. So, the following are all float
2416 struct { struct { float x; } x; };
2417 struct { struct { struct { float x; } x; } x; };
2421 All such structures are passed as if they were floats or doubles,
2422 as the (revised) ABI says. */
2424 is_float_singleton (struct type
*type
)
2426 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
&& TYPE_NFIELDS (type
) == 1)
2428 struct type
*singleton_type
= TYPE_FIELD_TYPE (type
, 0);
2429 CHECK_TYPEDEF (singleton_type
);
2431 return (TYPE_CODE (singleton_type
) == TYPE_CODE_FLT
2432 || TYPE_CODE (singleton_type
) == TYPE_CODE_DECFLOAT
2433 || is_float_singleton (singleton_type
));
2440 /* Return non-zero if TYPE is a struct-like type, zero otherwise.
2441 "Struct-like" types are those that should be passed as structs are:
2444 As an odd quirk, not mentioned in the ABI, GCC passes float and
2445 double singletons as if they were a plain float, double, etc. (The
2446 corresponding union types are handled normally.) So we exclude
2447 those types here. *shrug* */
2449 is_struct_like (struct type
*type
)
2451 enum type_code code
= TYPE_CODE (type
);
2453 return (code
== TYPE_CODE_UNION
2454 || (code
== TYPE_CODE_STRUCT
&& ! is_float_singleton (type
)));
2458 /* Return non-zero if TYPE is a float-like type, zero otherwise.
2459 "Float-like" types are those that should be passed as
2460 floating-point values are.
2462 You'd think this would just be floats, doubles, long doubles, etc.
2463 But as an odd quirk, not mentioned in the ABI, GCC passes float and
2464 double singletons as if they were a plain float, double, etc. (The
2465 corresponding union types are handled normally.) So we include
2466 those types here. *shrug* */
2468 is_float_like (struct type
*type
)
2470 return (TYPE_CODE (type
) == TYPE_CODE_FLT
2471 || TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
2472 || is_float_singleton (type
));
2477 is_power_of_two (unsigned int n
)
2479 return ((n
& (n
- 1)) == 0);
2482 /* Return non-zero if TYPE should be passed as a pointer to a copy,
2485 s390_function_arg_pass_by_reference (struct type
*type
)
2487 unsigned length
= TYPE_LENGTH (type
);
2491 return (is_struct_like (type
) && !is_power_of_two (TYPE_LENGTH (type
)))
2492 || TYPE_CODE (type
) == TYPE_CODE_COMPLEX
2493 || (TYPE_CODE (type
) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (type
));
2496 /* Return non-zero if TYPE should be passed in a float register
2499 s390_function_arg_float (struct type
*type
)
2501 unsigned length
= TYPE_LENGTH (type
);
2505 return is_float_like (type
);
2508 /* Return non-zero if TYPE should be passed in an integer register
2509 (or a pair of integer registers) if possible. */
2511 s390_function_arg_integer (struct type
*type
)
2513 unsigned length
= TYPE_LENGTH (type
);
2517 return is_integer_like (type
)
2518 || is_pointer_like (type
)
2519 || (is_struct_like (type
) && is_power_of_two (length
));
2522 /* Return ARG, a `SIMPLE_ARG', sign-extended or zero-extended to a full
2523 word as required for the ABI. */
2525 extend_simple_arg (struct gdbarch
*gdbarch
, struct value
*arg
)
2527 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2528 struct type
*type
= check_typedef (value_type (arg
));
2530 /* Even structs get passed in the least significant bits of the
2531 register / memory word. It's not really right to extract them as
2532 an integer, but it does take care of the extension. */
2533 if (TYPE_UNSIGNED (type
))
2534 return extract_unsigned_integer (value_contents (arg
),
2535 TYPE_LENGTH (type
), byte_order
);
2537 return extract_signed_integer (value_contents (arg
),
2538 TYPE_LENGTH (type
), byte_order
);
2542 /* Return the alignment required by TYPE. */
2544 alignment_of (struct type
*type
)
2548 if (is_integer_like (type
)
2549 || is_pointer_like (type
)
2550 || TYPE_CODE (type
) == TYPE_CODE_FLT
2551 || TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
2552 alignment
= TYPE_LENGTH (type
);
2553 else if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
2554 || TYPE_CODE (type
) == TYPE_CODE_UNION
)
2559 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
2562 = alignment_of (check_typedef (TYPE_FIELD_TYPE (type
, i
)));
2564 if (field_alignment
> alignment
)
2565 alignment
= field_alignment
;
2571 /* Check that everything we ever return is a power of two. Lots of
2572 code doesn't want to deal with aligning things to arbitrary
2574 gdb_assert ((alignment
& (alignment
- 1)) == 0);
2580 /* Put the actual parameter values pointed to by ARGS[0..NARGS-1] in
2581 place to be passed to a function, as specified by the "GNU/Linux
2582 for S/390 ELF Application Binary Interface Supplement".
2584 SP is the current stack pointer. We must put arguments, links,
2585 padding, etc. whereever they belong, and return the new stack
2588 If STRUCT_RETURN is non-zero, then the function we're calling is
2589 going to return a structure by value; STRUCT_ADDR is the address of
2590 a block we've allocated for it on the stack.
2592 Our caller has taken care of any type promotions needed to satisfy
2593 prototypes or the old K&R argument-passing rules. */
2595 s390_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
2596 struct regcache
*regcache
, CORE_ADDR bp_addr
,
2597 int nargs
, struct value
**args
, CORE_ADDR sp
,
2598 int struct_return
, CORE_ADDR struct_addr
)
2600 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2601 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
2602 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2605 /* If the i'th argument is passed as a reference to a copy, then
2606 copy_addr[i] is the address of the copy we made. */
2607 CORE_ADDR
*copy_addr
= alloca (nargs
* sizeof (CORE_ADDR
));
2609 /* Reserve space for the reference-to-copy area. */
2610 for (i
= 0; i
< nargs
; i
++)
2612 struct value
*arg
= args
[i
];
2613 struct type
*type
= check_typedef (value_type (arg
));
2614 unsigned length
= TYPE_LENGTH (type
);
2616 if (s390_function_arg_pass_by_reference (type
))
2619 sp
= align_down (sp
, alignment_of (type
));
2624 /* Reserve space for the parameter area. As a conservative
2625 simplification, we assume that everything will be passed on the
2626 stack. Since every argument larger than 8 bytes will be
2627 passed by reference, we use this simple upper bound. */
2630 /* After all that, make sure it's still aligned on an eight-byte
2632 sp
= align_down (sp
, 8);
2634 /* Allocate the standard frame areas: the register save area, the
2635 word reserved for the compiler (which seems kind of meaningless),
2636 and the back chain pointer. */
2637 sp
-= 16*word_size
+ 32;
2639 /* Now we have the final SP value. Make sure we didn't underflow;
2640 on 31-bit, this would result in addresses with the high bit set,
2641 which causes confusion elsewhere. Note that if we error out
2642 here, stack and registers remain untouched. */
2643 if (gdbarch_addr_bits_remove (gdbarch
, sp
) != sp
)
2644 error (_("Stack overflow"));
2647 /* Finally, place the actual parameters, working from SP towards
2648 higher addresses. The code above is supposed to reserve enough
2653 CORE_ADDR starg
= sp
+ 16*word_size
+ 32;
2655 /* A struct is returned using general register 2. */
2658 regcache_cooked_write_unsigned (regcache
, S390_R0_REGNUM
+ gr
,
2663 for (i
= 0; i
< nargs
; i
++)
2665 struct value
*arg
= args
[i
];
2666 struct type
*type
= check_typedef (value_type (arg
));
2667 unsigned length
= TYPE_LENGTH (type
);
2669 if (s390_function_arg_pass_by_reference (type
))
2671 /* Actually copy the argument contents to the stack slot
2672 that was reserved above. */
2673 write_memory (copy_addr
[i
], value_contents (arg
), length
);
2677 regcache_cooked_write_unsigned (regcache
, S390_R0_REGNUM
+ gr
,
2683 write_memory_unsigned_integer (starg
, word_size
, byte_order
,
2688 else if (s390_function_arg_float (type
))
2690 /* The GNU/Linux for S/390 ABI uses FPRs 0 and 2 to pass arguments,
2691 the GNU/Linux for zSeries ABI uses 0, 2, 4, and 6. */
2692 if (fr
<= (tdep
->abi
== ABI_LINUX_S390
? 2 : 6))
2694 /* When we store a single-precision value in an FP register,
2695 it occupies the leftmost bits. */
2696 regcache_cooked_write_part (regcache
, S390_F0_REGNUM
+ fr
,
2697 0, length
, value_contents (arg
));
2702 /* When we store a single-precision value in a stack slot,
2703 it occupies the rightmost bits. */
2704 starg
= align_up (starg
+ length
, word_size
);
2705 write_memory (starg
- length
, value_contents (arg
), length
);
2708 else if (s390_function_arg_integer (type
) && length
<= word_size
)
2712 /* Integer arguments are always extended to word size. */
2713 regcache_cooked_write_signed (regcache
, S390_R0_REGNUM
+ gr
,
2714 extend_simple_arg (gdbarch
,
2720 /* Integer arguments are always extended to word size. */
2721 write_memory_signed_integer (starg
, word_size
, byte_order
,
2722 extend_simple_arg (gdbarch
, arg
));
2726 else if (s390_function_arg_integer (type
) && length
== 2*word_size
)
2730 regcache_cooked_write (regcache
, S390_R0_REGNUM
+ gr
,
2731 value_contents (arg
));
2732 regcache_cooked_write (regcache
, S390_R0_REGNUM
+ gr
+ 1,
2733 value_contents (arg
) + word_size
);
2738 /* If we skipped r6 because we couldn't fit a DOUBLE_ARG
2739 in it, then don't go back and use it again later. */
2742 write_memory (starg
, value_contents (arg
), length
);
2747 internal_error (__FILE__
, __LINE__
, _("unknown argument type"));
2751 /* Store return PSWA. In 31-bit mode, keep addressing mode bit. */
2755 regcache_cooked_read_unsigned (regcache
, S390_PSWA_REGNUM
, &pswa
);
2756 bp_addr
= (bp_addr
& 0x7fffffff) | (pswa
& 0x80000000);
2758 regcache_cooked_write_unsigned (regcache
, S390_RETADDR_REGNUM
, bp_addr
);
2760 /* Store updated stack pointer. */
2761 regcache_cooked_write_unsigned (regcache
, S390_SP_REGNUM
, sp
);
2763 /* We need to return the 'stack part' of the frame ID,
2764 which is actually the top of the register save area. */
2765 return sp
+ 16*word_size
+ 32;
2768 /* Assuming THIS_FRAME is a dummy, return the frame ID of that
2769 dummy frame. The frame ID's base needs to match the TOS value
2770 returned by push_dummy_call, and the PC match the dummy frame's
2772 static struct frame_id
2773 s390_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*this_frame
)
2775 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
2776 CORE_ADDR sp
= get_frame_register_unsigned (this_frame
, S390_SP_REGNUM
);
2777 sp
= gdbarch_addr_bits_remove (gdbarch
, sp
);
2779 return frame_id_build (sp
+ 16*word_size
+ 32,
2780 get_frame_pc (this_frame
));
2784 s390_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
2786 /* Both the 32- and 64-bit ABI's say that the stack pointer should
2787 always be aligned on an eight-byte boundary. */
2792 /* Function return value access. */
2794 static enum return_value_convention
2795 s390_return_value_convention (struct gdbarch
*gdbarch
, struct type
*type
)
2797 int length
= TYPE_LENGTH (type
);
2799 return RETURN_VALUE_STRUCT_CONVENTION
;
2801 switch (TYPE_CODE (type
))
2803 case TYPE_CODE_STRUCT
:
2804 case TYPE_CODE_UNION
:
2805 case TYPE_CODE_ARRAY
:
2806 case TYPE_CODE_COMPLEX
:
2807 return RETURN_VALUE_STRUCT_CONVENTION
;
2810 return RETURN_VALUE_REGISTER_CONVENTION
;
2814 static enum return_value_convention
2815 s390_return_value (struct gdbarch
*gdbarch
, struct type
*func_type
,
2816 struct type
*type
, struct regcache
*regcache
,
2817 gdb_byte
*out
, const gdb_byte
*in
)
2819 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2820 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
2821 enum return_value_convention rvc
;
2824 type
= check_typedef (type
);
2825 rvc
= s390_return_value_convention (gdbarch
, type
);
2826 length
= TYPE_LENGTH (type
);
2832 case RETURN_VALUE_REGISTER_CONVENTION
:
2833 if (TYPE_CODE (type
) == TYPE_CODE_FLT
2834 || TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
2836 /* When we store a single-precision value in an FP register,
2837 it occupies the leftmost bits. */
2838 regcache_cooked_write_part (regcache
, S390_F0_REGNUM
,
2841 else if (length
<= word_size
)
2843 /* Integer arguments are always extended to word size. */
2844 if (TYPE_UNSIGNED (type
))
2845 regcache_cooked_write_unsigned (regcache
, S390_R2_REGNUM
,
2846 extract_unsigned_integer (in
, length
, byte_order
));
2848 regcache_cooked_write_signed (regcache
, S390_R2_REGNUM
,
2849 extract_signed_integer (in
, length
, byte_order
));
2851 else if (length
== 2*word_size
)
2853 regcache_cooked_write (regcache
, S390_R2_REGNUM
, in
);
2854 regcache_cooked_write (regcache
, S390_R3_REGNUM
, in
+ word_size
);
2857 internal_error (__FILE__
, __LINE__
, _("invalid return type"));
2860 case RETURN_VALUE_STRUCT_CONVENTION
:
2861 error (_("Cannot set function return value."));
2869 case RETURN_VALUE_REGISTER_CONVENTION
:
2870 if (TYPE_CODE (type
) == TYPE_CODE_FLT
2871 || TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
2873 /* When we store a single-precision value in an FP register,
2874 it occupies the leftmost bits. */
2875 regcache_cooked_read_part (regcache
, S390_F0_REGNUM
,
2878 else if (length
<= word_size
)
2880 /* Integer arguments occupy the rightmost bits. */
2881 regcache_cooked_read_part (regcache
, S390_R2_REGNUM
,
2882 word_size
- length
, length
, out
);
2884 else if (length
== 2*word_size
)
2886 regcache_cooked_read (regcache
, S390_R2_REGNUM
, out
);
2887 regcache_cooked_read (regcache
, S390_R3_REGNUM
, out
+ word_size
);
2890 internal_error (__FILE__
, __LINE__
, _("invalid return type"));
2893 case RETURN_VALUE_STRUCT_CONVENTION
:
2894 error (_("Function return value unknown."));
2905 static const gdb_byte
*
2906 s390_breakpoint_from_pc (struct gdbarch
*gdbarch
,
2907 CORE_ADDR
*pcptr
, int *lenptr
)
2909 static const gdb_byte breakpoint
[] = { 0x0, 0x1 };
2911 *lenptr
= sizeof (breakpoint
);
2916 /* Address handling. */
2919 s390_addr_bits_remove (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
2921 return addr
& 0x7fffffff;
2925 s390_address_class_type_flags (int byte_size
, int dwarf2_addr_class
)
2928 return TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1
;
2934 s390_address_class_type_flags_to_name (struct gdbarch
*gdbarch
, int type_flags
)
2936 if (type_flags
& TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1
)
2943 s390_address_class_name_to_type_flags (struct gdbarch
*gdbarch
,
2945 int *type_flags_ptr
)
2947 if (strcmp (name
, "mode32") == 0)
2949 *type_flags_ptr
= TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1
;
2956 /* Set up gdbarch struct. */
2958 static struct gdbarch
*
2959 s390_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
2961 const struct target_desc
*tdesc
= info
.target_desc
;
2962 struct tdesc_arch_data
*tdesc_data
= NULL
;
2963 struct gdbarch
*gdbarch
;
2964 struct gdbarch_tdep
*tdep
;
2967 int have_linux_v1
= 0;
2968 int have_linux_v2
= 0;
2969 int first_pseudo_reg
, last_pseudo_reg
;
2971 /* Default ABI and register size. */
2972 switch (info
.bfd_arch_info
->mach
)
2974 case bfd_mach_s390_31
:
2975 tdep_abi
= ABI_LINUX_S390
;
2978 case bfd_mach_s390_64
:
2979 tdep_abi
= ABI_LINUX_ZSERIES
;
2986 /* Use default target description if none provided by the target. */
2987 if (!tdesc_has_registers (tdesc
))
2989 if (tdep_abi
== ABI_LINUX_S390
)
2990 tdesc
= tdesc_s390_linux32
;
2992 tdesc
= tdesc_s390x_linux64
;
2995 /* Check any target description for validity. */
2996 if (tdesc_has_registers (tdesc
))
2998 static const char *const gprs
[] = {
2999 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
3000 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
3002 static const char *const fprs
[] = {
3003 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
3004 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15"
3006 static const char *const acrs
[] = {
3007 "acr0", "acr1", "acr2", "acr3", "acr4", "acr5", "acr6", "acr7",
3008 "acr8", "acr9", "acr10", "acr11", "acr12", "acr13", "acr14", "acr15"
3010 static const char *const gprs_lower
[] = {
3011 "r0l", "r1l", "r2l", "r3l", "r4l", "r5l", "r6l", "r7l",
3012 "r8l", "r9l", "r10l", "r11l", "r12l", "r13l", "r14l", "r15l"
3014 static const char *const gprs_upper
[] = {
3015 "r0h", "r1h", "r2h", "r3h", "r4h", "r5h", "r6h", "r7h",
3016 "r8h", "r9h", "r10h", "r11h", "r12h", "r13h", "r14h", "r15h"
3018 const struct tdesc_feature
*feature
;
3021 feature
= tdesc_find_feature (tdesc
, "org.gnu.gdb.s390.core");
3022 if (feature
== NULL
)
3025 tdesc_data
= tdesc_data_alloc ();
3027 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
3028 S390_PSWM_REGNUM
, "pswm");
3029 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
3030 S390_PSWA_REGNUM
, "pswa");
3032 if (tdesc_unnumbered_register (feature
, "r0"))
3034 for (i
= 0; i
< 16; i
++)
3035 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
3036 S390_R0_REGNUM
+ i
, gprs
[i
]);
3042 for (i
= 0; i
< 16; i
++)
3043 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
3046 for (i
= 0; i
< 16; i
++)
3047 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
3048 S390_R0_UPPER_REGNUM
+ i
,
3052 feature
= tdesc_find_feature (tdesc
, "org.gnu.gdb.s390.fpr");
3053 if (feature
== NULL
)
3055 tdesc_data_cleanup (tdesc_data
);
3059 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
3060 S390_FPC_REGNUM
, "fpc");
3061 for (i
= 0; i
< 16; i
++)
3062 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
3063 S390_F0_REGNUM
+ i
, fprs
[i
]);
3065 feature
= tdesc_find_feature (tdesc
, "org.gnu.gdb.s390.acr");
3066 if (feature
== NULL
)
3068 tdesc_data_cleanup (tdesc_data
);
3072 for (i
= 0; i
< 16; i
++)
3073 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
,
3074 S390_A0_REGNUM
+ i
, acrs
[i
]);
3076 /* Optional GNU/Linux-specific "registers". */
3077 feature
= tdesc_find_feature (tdesc
, "org.gnu.gdb.s390.linux");
3080 tdesc_numbered_register (feature
, tdesc_data
,
3081 S390_ORIG_R2_REGNUM
, "orig_r2");
3083 if (tdesc_numbered_register (feature
, tdesc_data
,
3084 S390_LAST_BREAK_REGNUM
, "last_break"))
3087 if (tdesc_numbered_register (feature
, tdesc_data
,
3088 S390_SYSTEM_CALL_REGNUM
, "system_call"))
3091 if (have_linux_v2
> have_linux_v1
)
3097 tdesc_data_cleanup (tdesc_data
);
3102 /* Find a candidate among extant architectures. */
3103 for (arches
= gdbarch_list_lookup_by_info (arches
, &info
);
3105 arches
= gdbarch_list_lookup_by_info (arches
->next
, &info
))
3107 tdep
= gdbarch_tdep (arches
->gdbarch
);
3110 if (tdep
->abi
!= tdep_abi
)
3112 if ((tdep
->gpr_full_regnum
!= -1) != have_upper
)
3114 if (tdesc_data
!= NULL
)
3115 tdesc_data_cleanup (tdesc_data
);
3116 return arches
->gdbarch
;
3119 /* Otherwise create a new gdbarch for the specified machine type. */
3120 tdep
= XCALLOC (1, struct gdbarch_tdep
);
3121 tdep
->abi
= tdep_abi
;
3122 gdbarch
= gdbarch_alloc (&info
, tdep
);
3124 set_gdbarch_believe_pcc_promotion (gdbarch
, 0);
3125 set_gdbarch_char_signed (gdbarch
, 0);
3127 /* S/390 GNU/Linux uses either 64-bit or 128-bit long doubles.
3128 We can safely let them default to 128-bit, since the debug info
3129 will give the size of type actually used in each case. */
3130 set_gdbarch_long_double_bit (gdbarch
, 128);
3131 set_gdbarch_long_double_format (gdbarch
, floatformats_ia64_quad
);
3133 /* Amount PC must be decremented by after a breakpoint. This is
3134 often the number of bytes returned by gdbarch_breakpoint_from_pc but not
3136 set_gdbarch_decr_pc_after_break (gdbarch
, 2);
3137 /* Stack grows downward. */
3138 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
3139 set_gdbarch_breakpoint_from_pc (gdbarch
, s390_breakpoint_from_pc
);
3140 set_gdbarch_skip_prologue (gdbarch
, s390_skip_prologue
);
3141 set_gdbarch_in_function_epilogue_p (gdbarch
, s390_in_function_epilogue_p
);
3143 set_gdbarch_num_regs (gdbarch
, S390_NUM_REGS
);
3144 set_gdbarch_sp_regnum (gdbarch
, S390_SP_REGNUM
);
3145 set_gdbarch_fp0_regnum (gdbarch
, S390_F0_REGNUM
);
3146 set_gdbarch_stab_reg_to_regnum (gdbarch
, s390_dwarf_reg_to_regnum
);
3147 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, s390_dwarf_reg_to_regnum
);
3148 set_gdbarch_value_from_register (gdbarch
, s390_value_from_register
);
3149 set_gdbarch_regset_from_core_section (gdbarch
,
3150 s390_regset_from_core_section
);
3151 set_gdbarch_core_read_description (gdbarch
, s390_core_read_description
);
3152 set_gdbarch_cannot_store_register (gdbarch
, s390_cannot_store_register
);
3153 set_gdbarch_write_pc (gdbarch
, s390_write_pc
);
3154 set_gdbarch_pseudo_register_read (gdbarch
, s390_pseudo_register_read
);
3155 set_gdbarch_pseudo_register_write (gdbarch
, s390_pseudo_register_write
);
3156 set_tdesc_pseudo_register_name (gdbarch
, s390_pseudo_register_name
);
3157 set_tdesc_pseudo_register_type (gdbarch
, s390_pseudo_register_type
);
3158 set_tdesc_pseudo_register_reggroup_p (gdbarch
,
3159 s390_pseudo_register_reggroup_p
);
3160 tdesc_use_registers (gdbarch
, tdesc
, tdesc_data
);
3162 /* Assign pseudo register numbers. */
3163 first_pseudo_reg
= gdbarch_num_regs (gdbarch
);
3164 last_pseudo_reg
= first_pseudo_reg
;
3165 tdep
->gpr_full_regnum
= -1;
3168 tdep
->gpr_full_regnum
= last_pseudo_reg
;
3169 last_pseudo_reg
+= 16;
3171 tdep
->pc_regnum
= last_pseudo_reg
++;
3172 tdep
->cc_regnum
= last_pseudo_reg
++;
3173 set_gdbarch_pc_regnum (gdbarch
, tdep
->pc_regnum
);
3174 set_gdbarch_num_pseudo_regs (gdbarch
, last_pseudo_reg
- first_pseudo_reg
);
3176 /* Inferior function calls. */
3177 set_gdbarch_push_dummy_call (gdbarch
, s390_push_dummy_call
);
3178 set_gdbarch_dummy_id (gdbarch
, s390_dummy_id
);
3179 set_gdbarch_frame_align (gdbarch
, s390_frame_align
);
3180 set_gdbarch_return_value (gdbarch
, s390_return_value
);
3182 /* Frame handling. */
3183 dwarf2_frame_set_init_reg (gdbarch
, s390_dwarf2_frame_init_reg
);
3184 dwarf2_frame_set_adjust_regnum (gdbarch
, s390_adjust_frame_regnum
);
3185 dwarf2_append_unwinders (gdbarch
);
3186 frame_base_append_sniffer (gdbarch
, dwarf2_frame_base_sniffer
);
3187 frame_unwind_append_unwinder (gdbarch
, &s390_stub_frame_unwind
);
3188 frame_unwind_append_unwinder (gdbarch
, &s390_sigtramp_frame_unwind
);
3189 frame_unwind_append_unwinder (gdbarch
, &s390_frame_unwind
);
3190 frame_base_set_default (gdbarch
, &s390_frame_base
);
3191 set_gdbarch_unwind_pc (gdbarch
, s390_unwind_pc
);
3192 set_gdbarch_unwind_sp (gdbarch
, s390_unwind_sp
);
3194 /* Displaced stepping. */
3195 set_gdbarch_displaced_step_copy_insn (gdbarch
,
3196 simple_displaced_step_copy_insn
);
3197 set_gdbarch_displaced_step_fixup (gdbarch
, s390_displaced_step_fixup
);
3198 set_gdbarch_displaced_step_free_closure (gdbarch
,
3199 simple_displaced_step_free_closure
);
3200 set_gdbarch_displaced_step_location (gdbarch
,
3201 displaced_step_at_entry_point
);
3202 set_gdbarch_max_insn_length (gdbarch
, S390_MAX_INSTR_SIZE
);
3204 /* Note that GNU/Linux is the only OS supported on this
3206 linux_init_abi (info
, gdbarch
);
3210 case ABI_LINUX_S390
:
3211 tdep
->gregset
= &s390_gregset
;
3212 tdep
->sizeof_gregset
= s390_sizeof_gregset
;
3213 tdep
->fpregset
= &s390_fpregset
;
3214 tdep
->sizeof_fpregset
= s390_sizeof_fpregset
;
3216 set_gdbarch_addr_bits_remove (gdbarch
, s390_addr_bits_remove
);
3217 set_solib_svr4_fetch_link_map_offsets
3218 (gdbarch
, svr4_ilp32_fetch_link_map_offsets
);
3223 set_gdbarch_core_regset_sections (gdbarch
,
3224 s390_linux64v2_regset_sections
);
3225 else if (have_linux_v1
)
3226 set_gdbarch_core_regset_sections (gdbarch
,
3227 s390_linux64v1_regset_sections
);
3229 set_gdbarch_core_regset_sections (gdbarch
,
3230 s390_linux64_regset_sections
);
3235 set_gdbarch_core_regset_sections (gdbarch
,
3236 s390_linux32v2_regset_sections
);
3237 else if (have_linux_v1
)
3238 set_gdbarch_core_regset_sections (gdbarch
,
3239 s390_linux32v1_regset_sections
);
3241 set_gdbarch_core_regset_sections (gdbarch
,
3242 s390_linux32_regset_sections
);
3246 case ABI_LINUX_ZSERIES
:
3247 tdep
->gregset
= &s390x_gregset
;
3248 tdep
->sizeof_gregset
= s390x_sizeof_gregset
;
3249 tdep
->fpregset
= &s390_fpregset
;
3250 tdep
->sizeof_fpregset
= s390_sizeof_fpregset
;
3252 set_gdbarch_long_bit (gdbarch
, 64);
3253 set_gdbarch_long_long_bit (gdbarch
, 64);
3254 set_gdbarch_ptr_bit (gdbarch
, 64);
3255 set_solib_svr4_fetch_link_map_offsets
3256 (gdbarch
, svr4_lp64_fetch_link_map_offsets
);
3257 set_gdbarch_address_class_type_flags (gdbarch
,
3258 s390_address_class_type_flags
);
3259 set_gdbarch_address_class_type_flags_to_name (gdbarch
,
3260 s390_address_class_type_flags_to_name
);
3261 set_gdbarch_address_class_name_to_type_flags (gdbarch
,
3262 s390_address_class_name_to_type_flags
);
3265 set_gdbarch_core_regset_sections (gdbarch
,
3266 s390x_linux64v2_regset_sections
);
3267 else if (have_linux_v1
)
3268 set_gdbarch_core_regset_sections (gdbarch
,
3269 s390x_linux64v1_regset_sections
);
3271 set_gdbarch_core_regset_sections (gdbarch
,
3272 s390x_linux64_regset_sections
);
3276 set_gdbarch_print_insn (gdbarch
, print_insn_s390
);
3278 set_gdbarch_skip_trampoline_code (gdbarch
, find_solib_trampoline_target
);
3280 /* Enable TLS support. */
3281 set_gdbarch_fetch_tls_load_module_address (gdbarch
,
3282 svr4_fetch_objfile_link_map
);
3284 set_gdbarch_get_siginfo_type (gdbarch
, linux_get_siginfo_type
);
3290 extern initialize_file_ftype _initialize_s390_tdep
; /* -Wmissing-prototypes */
3293 _initialize_s390_tdep (void)
3295 /* Hook us into the gdbarch mechanism. */
3296 register_gdbarch_init (bfd_arch_s390
, s390_gdbarch_init
);
3298 /* Initialize the GNU/Linux target descriptions. */
3299 initialize_tdesc_s390_linux32 ();
3300 initialize_tdesc_s390_linux32v1 ();
3301 initialize_tdesc_s390_linux32v2 ();
3302 initialize_tdesc_s390_linux64 ();
3303 initialize_tdesc_s390_linux64v1 ();
3304 initialize_tdesc_s390_linux64v2 ();
3305 initialize_tdesc_s390x_linux64 ();
3306 initialize_tdesc_s390x_linux64v1 ();
3307 initialize_tdesc_s390x_linux64v2 ();