1 /* Target-dependent code for GDB, the GNU debugger.
2 Copyright 2001 Free Software Foundation, Inc.
3 Contributed by D.J. Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
4 for IBM Deutschland Entwicklung GmbH, IBM Corporation.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
23 #define S390_TDEP /* for special macros in tm-s390.h */
25 #include "arch-utils.h"
35 #include "../bfd/bfd.h"
36 #include "floatformat.h"
39 #include "gdb_assert.h"
44 /* Number of bytes of storage in the actual machine representation
47 s390_register_raw_size (int reg_nr
)
49 if (S390_FP0_REGNUM
<= reg_nr
50 && reg_nr
< S390_FP0_REGNUM
+ S390_NUM_FPRS
)
57 s390x_register_raw_size (int reg_nr
)
59 return (reg_nr
== S390_FPC_REGNUM
)
60 || (reg_nr
>= S390_FIRST_ACR
&& reg_nr
<= S390_LAST_ACR
) ? 4 : 8;
64 s390_cannot_fetch_register (int regno
)
66 return (regno
>= S390_FIRST_CR
&& regno
< (S390_FIRST_CR
+ 9)) ||
67 (regno
>= (S390_FIRST_CR
+ 12) && regno
<= S390_LAST_CR
);
71 s390_register_byte (int reg_nr
)
73 if (reg_nr
<= S390_GP_LAST_REGNUM
)
74 return reg_nr
* S390_GPR_SIZE
;
75 if (reg_nr
<= S390_LAST_ACR
)
76 return S390_ACR0_OFFSET
+ (((reg_nr
) - S390_FIRST_ACR
) * S390_ACR_SIZE
);
77 if (reg_nr
<= S390_LAST_CR
)
78 return S390_CR0_OFFSET
+ (((reg_nr
) - S390_FIRST_CR
) * S390_CR_SIZE
);
79 if (reg_nr
== S390_FPC_REGNUM
)
80 return S390_FPC_OFFSET
;
82 return S390_FP0_OFFSET
+ (((reg_nr
) - S390_FP0_REGNUM
) * S390_FPR_SIZE
);
86 #define S390_MAX_INSTR_SIZE (6)
87 #define S390_SYSCALL_OPCODE (0x0a)
88 #define S390_SYSCALL_SIZE (2)
89 #define S390_SIGCONTEXT_SREGS_OFFSET (8)
90 #define S390X_SIGCONTEXT_SREGS_OFFSET (8)
91 #define S390_SIGREGS_FP0_OFFSET (144)
92 #define S390X_SIGREGS_FP0_OFFSET (216)
93 #define S390_UC_MCONTEXT_OFFSET (256)
94 #define S390X_UC_MCONTEXT_OFFSET (344)
95 #define S390_STACK_FRAME_OVERHEAD (GDB_TARGET_IS_ESAME ? 160:96)
96 #define S390_SIGNAL_FRAMESIZE (GDB_TARGET_IS_ESAME ? 160:96)
97 #define s390_NR_sigreturn 119
98 #define s390_NR_rt_sigreturn 173
102 struct frame_extra_info
106 CORE_ADDR function_start
;
107 CORE_ADDR skip_prologue_function_start
;
108 CORE_ADDR saved_pc_valid
;
110 CORE_ADDR sig_fixed_saved_pc_valid
;
111 CORE_ADDR sig_fixed_saved_pc
;
112 CORE_ADDR frame_pointer_saved_pc
; /* frame pointer needed for alloca */
113 CORE_ADDR stack_bought
; /* amount we decrement the stack pointer by */
114 CORE_ADDR sigcontext
;
118 static CORE_ADDR
s390_frame_saved_pc_nofix (struct frame_info
*fi
);
121 s390_readinstruction (bfd_byte instr
[], CORE_ADDR at
,
122 struct disassemble_info
*info
)
126 static int s390_instrlen
[] = {
132 if ((*info
->read_memory_func
) (at
, &instr
[0], 2, info
))
134 instrlen
= s390_instrlen
[instr
[0] >> 6];
137 if ((*info
->read_memory_func
) (at
+ 2, &instr
[2], instrlen
- 2, info
))
144 s390_memset_extra_info (struct frame_extra_info
*fextra_info
)
146 memset (fextra_info
, 0, sizeof (struct frame_extra_info
));
152 s390_register_name (int reg_nr
)
154 static char *register_names
[] = {
156 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
157 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
158 "acr0", "acr1", "acr2", "acr3", "acr4", "acr5", "acr6", "acr7",
159 "acr8", "acr9", "acr10", "acr11", "acr12", "acr13", "acr14", "acr15",
160 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
161 "cr8", "cr9", "cr10", "cr11", "cr12", "cr13", "cr14", "cr15",
163 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
164 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15"
167 if (reg_nr
<= S390_LAST_REGNUM
)
168 return register_names
[reg_nr
];
177 s390_stab_reg_to_regnum (int regno
)
179 return regno
>= 64 ? S390_PSWM_REGNUM
- 64 :
180 regno
>= 48 ? S390_FIRST_ACR
- 48 :
181 regno
>= 32 ? S390_FIRST_CR
- 32 :
182 regno
<= 15 ? (regno
+ 2) :
183 S390_FP0_REGNUM
+ ((regno
- 16) & 8) + (((regno
- 16) & 3) << 1) +
184 (((regno
- 16) & 4) >> 2);
188 /* Return true if REGIDX is the number of a register used to pass
189 arguments, false otherwise. */
191 is_arg_reg (int regidx
)
193 return 2 <= regidx
&& regidx
<= 6;
197 /* s390_get_frame_info based on Hartmuts
198 prologue definition in
199 gcc-2.8.1/config/l390/linux.c
201 It reads one instruction at a time & based on whether
202 it looks like prologue code or not it makes a decision on
203 whether the prologue is over, there are various state machines
204 in the code to determine if the prologue code is possilby valid.
206 This is done to hopefully allow the code survive minor revs of
212 s390_get_frame_info (CORE_ADDR pc
, struct frame_extra_info
*fextra_info
,
213 struct frame_info
*fi
, int init_extra_info
)
215 #define CONST_POOL_REGIDX 13
216 #define GOT_REGIDX 12
217 bfd_byte instr
[S390_MAX_INSTR_SIZE
];
218 CORE_ADDR test_pc
= pc
, test_pc2
;
219 CORE_ADDR orig_sp
= 0, save_reg_addr
= 0, *saved_regs
= NULL
;
220 int valid_prologue
, good_prologue
= 0;
221 int gprs_saved
[S390_NUM_GPRS
];
222 int fprs_saved
[S390_NUM_FPRS
];
223 int regidx
, instrlen
;
224 int const_pool_state
;
226 int loop_cnt
, gdb_gpr_store
, gdb_fpr_store
;
227 int offset
, expected_offset
;
229 disassemble_info info
;
231 /* Have we seen an instruction initializing the frame pointer yet?
232 If we've seen an `lr %r11, %r15', then frame_pointer_found is
233 non-zero, and frame_pointer_regidx == 11. Otherwise,
234 frame_pointer_found is zero and frame_pointer_regidx is 15,
235 indicating that we're using the stack pointer as our frame
237 int frame_pointer_found
= 0;
238 int frame_pointer_regidx
= 0xf;
240 /* What we've seen so far regarding saving the back chain link:
241 0 -- nothing yet; sp still has the same value it had at the entry
242 point. Since not all functions allocate frames, this is a
243 valid state for the prologue to finish in.
244 1 -- We've saved the original sp in some register other than the
245 frame pointer (hard-coded to be %r11, yuck).
246 save_link_regidx is the register we saved it in.
247 2 -- We've seen the initial `bras' instruction of the sequence for
248 reserving more than 32k of stack:
252 where %rX is not the constant pool register.
253 subtract_sp_regidx is %rX, and fextra_info->stack_bought is N.
254 3 -- We've reserved space for a new stack frame. This means we
255 either saw a simple `ahi %r15,-N' in state 1, or the final
256 `s %r15, ...' in state 2.
257 4 -- The frame and link are now fully initialized. We've
258 reserved space for the new stack frame, and stored the old
259 stack pointer captured in the back chain pointer field. */
260 int save_link_state
= 0;
261 int save_link_regidx
, subtract_sp_regidx
;
263 /* What we've seen so far regarding r12 --- the GOT (Global Offset
264 Table) pointer. We expect to see `l %r12, N(%r13)', which loads
265 r12 with the offset from the constant pool to the GOT, and then
266 an `ar %r12, %r13', which adds the constant pool address,
267 yielding the GOT's address. Here's what got_state means:
269 1 -- seen `l %r12, N(%r13)', but no `ar'
270 2 -- seen load and add, so GOT pointer is totally initialized
271 When got_state is 1, then got_load_addr is the address of the
272 load instruction, and got_load_len is the length of that
275 CORE_ADDR got_load_addr
= 0, got_load_len
= 0;
277 const_pool_state
= varargs_state
= 0;
279 memset (gprs_saved
, 0, sizeof (gprs_saved
));
280 memset (fprs_saved
, 0, sizeof (fprs_saved
));
281 info
.read_memory_func
= dis_asm_read_memory
;
283 save_link_regidx
= subtract_sp_regidx
= 0;
289 if (! init_extra_info
&& fextra_info
->initialised
)
290 orig_sp
+= fextra_info
->stack_bought
;
291 saved_regs
= fi
->saved_regs
;
293 if (init_extra_info
|| !fextra_info
->initialised
)
295 s390_memset_extra_info (fextra_info
);
296 fextra_info
->function_start
= pc
;
297 fextra_info
->initialised
= 1;
305 /* add the previous instruction len */
306 instrlen
= s390_readinstruction (instr
, test_pc
, &info
);
313 /* We probably are in a glibc syscall */
314 if (instr
[0] == S390_SYSCALL_OPCODE
&& test_pc
== pc
)
317 if (saved_regs
&& fextra_info
&& fi
->next
&& fi
->next
->extra_info
318 && fi
->next
->extra_info
->sigcontext
)
320 /* We are backtracing from a signal handler */
321 save_reg_addr
= fi
->next
->extra_info
->sigcontext
+
322 REGISTER_BYTE (S390_GP0_REGNUM
);
323 for (regidx
= 0; regidx
< S390_NUM_GPRS
; regidx
++)
325 saved_regs
[S390_GP0_REGNUM
+ regidx
] = save_reg_addr
;
326 save_reg_addr
+= S390_GPR_SIZE
;
328 save_reg_addr
= fi
->next
->extra_info
->sigcontext
+
329 (GDB_TARGET_IS_ESAME
? S390X_SIGREGS_FP0_OFFSET
:
330 S390_SIGREGS_FP0_OFFSET
);
331 for (regidx
= 0; regidx
< S390_NUM_FPRS
; regidx
++)
333 saved_regs
[S390_FP0_REGNUM
+ regidx
] = save_reg_addr
;
334 save_reg_addr
+= S390_FPR_SIZE
;
339 if (save_link_state
== 0)
341 /* check for a stack relative STMG or STM */
342 if (((GDB_TARGET_IS_ESAME
&&
343 ((instr
[0] == 0xeb) && (instr
[5] == 0x24))) ||
344 (instr
[0] == 0x90)) && ((instr
[2] >> 4) == 0xf))
346 regidx
= (instr
[1] >> 4);
349 offset
= ((instr
[2] & 0xf) << 8) + instr
[3];
351 S390_GPR6_STACK_OFFSET
+ (S390_GPR_SIZE
* (regidx
- 6));
352 if (offset
!= expected_offset
)
358 save_reg_addr
= orig_sp
+ offset
;
359 for (; regidx
<= (instr
[1] & 0xf); regidx
++)
361 if (gprs_saved
[regidx
])
367 gprs_saved
[regidx
] = 1;
370 saved_regs
[S390_GP0_REGNUM
+ regidx
] = save_reg_addr
;
371 save_reg_addr
+= S390_GPR_SIZE
;
378 /* check for a stack relative STG or ST */
379 if ((save_link_state
== 0 || save_link_state
== 3) &&
380 ((GDB_TARGET_IS_ESAME
&&
381 ((instr
[0] == 0xe3) && (instr
[5] == 0x24))) ||
382 (instr
[0] == 0x50)) && ((instr
[2] >> 4) == 0xf))
384 regidx
= instr
[1] >> 4;
385 offset
= ((instr
[2] & 0xf) << 8) + instr
[3];
388 if (save_link_state
== 3 && regidx
== save_link_regidx
)
400 S390_GPR6_STACK_OFFSET
+ (S390_GPR_SIZE
* (regidx
- 6));
401 if (offset
!= expected_offset
)
406 if (gprs_saved
[regidx
])
412 gprs_saved
[regidx
] = 1;
415 save_reg_addr
= orig_sp
+ offset
;
416 saved_regs
[S390_GP0_REGNUM
+ regidx
] = save_reg_addr
;
422 /* Check for an fp-relative STG, ST, or STM. This is probably
423 spilling an argument from a register out into a stack slot.
424 This could be a user instruction, but if we haven't included
425 any other suspicious instructions in the prologue, this
426 could only be an initializing store, which isn't too bad to
427 skip. The consequences of not including arg-to-stack spills
428 are more serious, though --- you don't see the proper values
430 if ((save_link_state
== 3 || save_link_state
== 4)
431 && ((instr
[0] == 0x50 /* st %rA, D(%rX,%rB) */
432 && (instr
[1] & 0xf) == 0 /* %rX is zero, no index reg */
433 && is_arg_reg ((instr
[1] >> 4) & 0xf)
434 && ((instr
[2] >> 4) & 0xf) == frame_pointer_regidx
)
435 || (instr
[0] == 0x90 /* stm %rA, %rB, D(%rC) */
436 && is_arg_reg ((instr
[1] >> 4) & 0xf)
437 && is_arg_reg (instr
[1] & 0xf)
438 && ((instr
[2] >> 4) & 0xf) == frame_pointer_regidx
)))
445 if (instr
[0] == 0x60 && (instr
[2] >> 4) == 0xf)
447 regidx
= instr
[1] >> 4;
448 if (regidx
== 0 || regidx
== 2)
450 if (fprs_saved
[regidx
])
455 fprs_saved
[regidx
] = 1;
458 save_reg_addr
= orig_sp
+ (((instr
[2] & 0xf) << 8) + instr
[3]);
459 saved_regs
[S390_FP0_REGNUM
+ regidx
] = save_reg_addr
;
466 if (const_pool_state
== 0)
469 if (GDB_TARGET_IS_ESAME
)
471 /* Check for larl CONST_POOL_REGIDX,offset on ESAME */
472 if ((instr
[0] == 0xc0)
473 && (instr
[1] == (CONST_POOL_REGIDX
<< 4)))
475 const_pool_state
= 2;
482 /* Check for BASR gpr13,gpr0 used to load constant pool pointer to r13 in old compiler */
483 if (instr
[0] == 0xd && (instr
[1] & 0xf) == 0
484 && ((instr
[1] >> 4) == CONST_POOL_REGIDX
))
486 const_pool_state
= 1;
491 /* Check for new fangled bras %r13,newpc to load new constant pool */
492 /* embedded in code, older pre abi compilers also emitted this stuff. */
493 if ((instr
[0] == 0xa7) && ((instr
[1] & 0xf) == 0x5) &&
494 ((instr
[1] >> 4) == CONST_POOL_REGIDX
)
495 && ((instr
[2] & 0x80) == 0))
497 const_pool_state
= 2;
499 (((((instr
[2] & 0xf) << 8) + instr
[3]) << 1) - instrlen
);
504 /* Check for AGHI or AHI CONST_POOL_REGIDX,val */
505 if (const_pool_state
== 1 && (instr
[0] == 0xa7) &&
506 ((GDB_TARGET_IS_ESAME
&&
507 (instr
[1] == ((CONST_POOL_REGIDX
<< 4) | 0xb))) ||
508 (instr
[1] == ((CONST_POOL_REGIDX
<< 4) | 0xa))))
510 const_pool_state
= 2;
514 /* Check for LGR or LR gprx,15 */
515 if ((GDB_TARGET_IS_ESAME
&&
516 instr
[0] == 0xb9 && instr
[1] == 0x04 && (instr
[3] & 0xf) == 0xf) ||
517 (instr
[0] == 0x18 && (instr
[1] & 0xf) == 0xf))
519 if (GDB_TARGET_IS_ESAME
)
520 regidx
= instr
[3] >> 4;
522 regidx
= instr
[1] >> 4;
523 if (save_link_state
== 0 && regidx
!= 0xb)
525 /* Almost defintely code for
526 decrementing the stack pointer
527 ( i.e. a non leaf function
528 or else leaf with locals ) */
529 save_link_regidx
= regidx
;
534 /* We use this frame pointer for alloca
535 unfortunately we need to assume its gpr11
536 otherwise we would need a smarter prologue
538 if (!frame_pointer_found
&& regidx
== 0xb)
540 frame_pointer_regidx
= 0xb;
541 frame_pointer_found
= 1;
543 fextra_info
->frame_pointer_saved_pc
= test_pc
;
548 /* Check for AHI or AGHI gpr15,val */
549 if (save_link_state
== 1 && (instr
[0] == 0xa7) &&
550 ((GDB_TARGET_IS_ESAME
&& (instr
[1] == 0xfb)) || (instr
[1] == 0xfa)))
553 fextra_info
->stack_bought
=
554 -extract_signed_integer (&instr
[2], 2);
559 /* Alternatively check for the complex construction for
560 buying more than 32k of stack
563 s %r15,0(%gprx) gprx currently r1 */
564 if ((save_link_state
== 1) && (instr
[0] == 0xa7)
565 && ((instr
[1] & 0xf) == 0x5) && (instr
[2] == 0)
566 && (instr
[3] == 0x4) && ((instr
[1] >> 4) != CONST_POOL_REGIDX
))
568 subtract_sp_regidx
= instr
[1] >> 4;
571 target_read_memory (test_pc
+ instrlen
,
572 (char *) &fextra_info
->stack_bought
,
573 sizeof (fextra_info
->stack_bought
));
578 if (save_link_state
== 2 && instr
[0] == 0x5b
579 && instr
[1] == 0xf0 &&
580 instr
[2] == (subtract_sp_regidx
<< 4) && instr
[3] == 0)
586 /* check for LA gprx,offset(15) used for varargs */
587 if ((instr
[0] == 0x41) && ((instr
[2] >> 4) == 0xf) &&
588 ((instr
[1] & 0xf) == 0))
590 /* some code uses gpr7 to point to outgoing args */
591 if (((instr
[1] >> 4) == 7) && (save_link_state
== 0) &&
592 ((instr
[2] & 0xf) == 0)
593 && (instr
[3] == S390_STACK_FRAME_OVERHEAD
))
598 if (varargs_state
== 1)
605 /* Check for a GOT load */
607 if (GDB_TARGET_IS_ESAME
)
609 /* Check for larl GOT_REGIDX, on ESAME */
610 if ((got_state
== 0) && (instr
[0] == 0xc0)
611 && (instr
[1] == (GOT_REGIDX
<< 4)))
620 /* check for l GOT_REGIDX,x(CONST_POOL_REGIDX) */
621 if (got_state
== 0 && const_pool_state
== 2 && instr
[0] == 0x58
622 && (instr
[2] == (CONST_POOL_REGIDX
<< 4))
623 && ((instr
[1] >> 4) == GOT_REGIDX
))
626 got_load_addr
= test_pc
;
627 got_load_len
= instrlen
;
631 /* Check for subsequent ar got_regidx,basr_regidx */
632 if (got_state
== 1 && instr
[0] == 0x1a &&
633 instr
[1] == ((GOT_REGIDX
<< 4) | CONST_POOL_REGIDX
))
641 while (valid_prologue
&& good_prologue
);
644 /* If this function doesn't reference the global offset table,
645 then the compiler may use r12 for other things. If the last
646 instruction we saw was a load of r12 from the constant pool,
647 with no subsequent add to make the address PC-relative, then
648 the load was probably a genuine body instruction; don't treat
649 it as part of the prologue. */
651 && got_load_addr
+ got_load_len
== test_pc
)
653 test_pc
= got_load_addr
;
654 instrlen
= got_load_len
;
657 good_prologue
= (((const_pool_state
== 0) || (const_pool_state
== 2)) &&
658 ((save_link_state
== 0) || (save_link_state
== 4)) &&
659 ((varargs_state
== 0) || (varargs_state
== 2)));
663 fextra_info
->good_prologue
= good_prologue
;
664 fextra_info
->skip_prologue_function_start
=
665 (good_prologue
? test_pc
: pc
);
668 /* The SP's element of the saved_regs array holds the old SP,
669 not the address at which it is saved. */
670 saved_regs
[S390_SP_REGNUM
] = orig_sp
;
676 s390_check_function_end (CORE_ADDR pc
)
678 bfd_byte instr
[S390_MAX_INSTR_SIZE
];
679 disassemble_info info
;
680 int regidx
, instrlen
;
682 info
.read_memory_func
= dis_asm_read_memory
;
683 instrlen
= s390_readinstruction (instr
, pc
, &info
);
687 if (instrlen
!= 2 || instr
[0] != 07 || (instr
[1] >> 4) != 0xf)
689 regidx
= instr
[1] & 0xf;
690 /* Check for LMG or LG */
692 s390_readinstruction (instr
, pc
- (GDB_TARGET_IS_ESAME
? 6 : 4), &info
);
695 if (GDB_TARGET_IS_ESAME
)
698 if (instrlen
!= 6 || instr
[0] != 0xeb || instr
[5] != 0x4)
701 else if (instrlen
!= 4 || instr
[0] != 0x98)
705 if ((instr
[2] >> 4) != 0xf)
709 instrlen
= s390_readinstruction (instr
, pc
- (GDB_TARGET_IS_ESAME
? 12 : 8),
713 if (GDB_TARGET_IS_ESAME
)
716 if (instrlen
!= 6 || instr
[0] != 0xe3 || instr
[5] != 0x4)
722 if (instrlen
!= 4 || instr
[0] != 0x58)
725 if (instr
[2] >> 4 != 0xf)
727 if (instr
[1] >> 4 != regidx
)
733 s390_sniff_pc_function_start (CORE_ADDR pc
, struct frame_info
*fi
)
735 CORE_ADDR function_start
, test_function_start
;
736 int loop_cnt
, err
, function_end
;
737 struct frame_extra_info fextra_info
;
738 function_start
= get_pc_function_start (pc
);
740 if (function_start
== 0)
742 test_function_start
= pc
;
743 if (test_function_start
& 1)
744 return 0; /* This has to be bogus */
750 s390_get_frame_info (test_function_start
, &fextra_info
, fi
, 1);
752 test_function_start
-= 2;
753 function_end
= s390_check_function_end (test_function_start
);
755 while (!(function_end
== 1 || err
|| loop_cnt
>= 4096 ||
756 (fextra_info
.good_prologue
)));
757 if (fextra_info
.good_prologue
)
758 function_start
= fextra_info
.function_start
;
759 else if (function_end
== 1)
760 function_start
= test_function_start
;
762 return function_start
;
768 s390_function_start (struct frame_info
*fi
)
770 CORE_ADDR function_start
= 0;
772 if (fi
->extra_info
&& fi
->extra_info
->initialised
)
773 function_start
= fi
->extra_info
->function_start
;
775 function_start
= get_pc_function_start (fi
->pc
);
776 return function_start
;
783 s390_frameless_function_invocation (struct frame_info
*fi
)
785 struct frame_extra_info fextra_info
, *fextra_info_ptr
;
788 if (fi
->next
== NULL
) /* no may be frameless */
791 fextra_info_ptr
= fi
->extra_info
;
794 fextra_info_ptr
= &fextra_info
;
795 s390_get_frame_info (s390_sniff_pc_function_start (fi
->pc
, fi
),
796 fextra_info_ptr
, fi
, 1);
798 frameless
= ((fextra_info_ptr
->stack_bought
== 0));
806 s390_is_sigreturn (CORE_ADDR pc
, struct frame_info
*sighandler_fi
,
807 CORE_ADDR
*sregs
, CORE_ADDR
*sigcaller_pc
)
809 bfd_byte instr
[S390_MAX_INSTR_SIZE
];
810 disassemble_info info
;
815 CORE_ADDR temp_sregs
;
817 scontext
= temp_sregs
= 0;
819 info
.read_memory_func
= dis_asm_read_memory
;
820 instrlen
= s390_readinstruction (instr
, pc
, &info
);
823 if (((instrlen
== S390_SYSCALL_SIZE
) &&
824 (instr
[0] == S390_SYSCALL_OPCODE
)) &&
825 ((instr
[1] == s390_NR_sigreturn
) || (instr
[1] == s390_NR_rt_sigreturn
)))
829 if (s390_frameless_function_invocation (sighandler_fi
))
830 orig_sp
= sighandler_fi
->frame
;
832 orig_sp
= ADDR_BITS_REMOVE ((CORE_ADDR
)
833 read_memory_integer (sighandler_fi
->
836 if (orig_sp
&& sigcaller_pc
)
838 scontext
= orig_sp
+ S390_SIGNAL_FRAMESIZE
;
839 if (pc
== scontext
&& instr
[1] == s390_NR_rt_sigreturn
)
841 /* We got a new style rt_signal */
842 /* get address of read ucontext->uc_mcontext */
843 temp_sregs
= orig_sp
+ (GDB_TARGET_IS_ESAME
?
844 S390X_UC_MCONTEXT_OFFSET
:
845 S390_UC_MCONTEXT_OFFSET
);
849 /* read sigcontext->sregs */
850 temp_sregs
= ADDR_BITS_REMOVE ((CORE_ADDR
)
851 read_memory_integer (scontext
855 S390X_SIGCONTEXT_SREGS_OFFSET
857 S390_SIGCONTEXT_SREGS_OFFSET
),
861 /* read sigregs->psw.addr */
863 ADDR_BITS_REMOVE ((CORE_ADDR
)
864 read_memory_integer (temp_sregs
+
867 S390_PSW_ADDR_SIZE
));
878 We need to do something better here but this will keep us out of trouble
880 For some reason the blockframe.c calls us with fi->next->fromleaf
881 so this seems of little use to us. */
883 s390_init_frame_pc_first (int next_fromleaf
, struct frame_info
*fi
)
885 CORE_ADDR sigcaller_pc
;
890 fi
->pc
= ADDR_BITS_REMOVE (read_register (S390_RETADDR_REGNUM
));
891 /* fix signal handlers */
893 else if (fi
->next
&& fi
->next
->pc
)
894 fi
->pc
= s390_frame_saved_pc_nofix (fi
->next
);
895 if (fi
->pc
&& fi
->next
&& fi
->next
->frame
&&
896 s390_is_sigreturn (fi
->pc
, fi
->next
, NULL
, &sigcaller_pc
))
898 fi
->pc
= sigcaller_pc
;
904 s390_init_extra_frame_info (int fromleaf
, struct frame_info
*fi
)
906 fi
->extra_info
= frame_obstack_alloc (sizeof (struct frame_extra_info
));
908 s390_get_frame_info (s390_sniff_pc_function_start (fi
->pc
, fi
),
909 fi
->extra_info
, fi
, 1);
911 s390_memset_extra_info (fi
->extra_info
);
914 /* If saved registers of frame FI are not known yet, read and cache them.
915 &FEXTRA_INFOP contains struct frame_extra_info; TDATAP can be NULL,
916 in which case the framedata are read. */
919 s390_frame_init_saved_regs (struct frame_info
*fi
)
924 if (fi
->saved_regs
== NULL
)
926 /* zalloc memsets the saved regs */
927 frame_saved_regs_zalloc (fi
);
930 quick
= (fi
->extra_info
&& fi
->extra_info
->initialised
931 && fi
->extra_info
->good_prologue
);
932 s390_get_frame_info (quick
? fi
->extra_info
->function_start
:
933 s390_sniff_pc_function_start (fi
->pc
, fi
),
934 fi
->extra_info
, fi
, !quick
);
942 s390_frame_args_address (struct frame_info
*fi
)
945 /* Apparently gdb already knows gdb_args_offset itself */
951 s390_frame_saved_pc_nofix (struct frame_info
*fi
)
953 if (fi
->extra_info
&& fi
->extra_info
->saved_pc_valid
)
954 return fi
->extra_info
->saved_pc
;
956 if (generic_find_dummy_frame (fi
->pc
, fi
->frame
))
957 return generic_read_register_dummy (fi
->pc
, fi
->frame
, S390_PC_REGNUM
);
959 s390_frame_init_saved_regs (fi
);
962 fi
->extra_info
->saved_pc_valid
= 1;
963 if (fi
->extra_info
->good_prologue
964 && fi
->saved_regs
[S390_RETADDR_REGNUM
])
965 fi
->extra_info
->saved_pc
966 = ADDR_BITS_REMOVE (read_memory_integer
967 (fi
->saved_regs
[S390_RETADDR_REGNUM
],
970 fi
->extra_info
->saved_pc
971 = ADDR_BITS_REMOVE (read_register (S390_RETADDR_REGNUM
));
972 return fi
->extra_info
->saved_pc
;
978 s390_frame_saved_pc (struct frame_info
*fi
)
980 CORE_ADDR saved_pc
= 0, sig_pc
;
982 if (fi
->extra_info
&& fi
->extra_info
->sig_fixed_saved_pc_valid
)
983 return fi
->extra_info
->sig_fixed_saved_pc
;
984 saved_pc
= s390_frame_saved_pc_nofix (fi
);
988 fi
->extra_info
->sig_fixed_saved_pc_valid
= 1;
991 if (s390_is_sigreturn (saved_pc
, fi
, NULL
, &sig_pc
))
994 fi
->extra_info
->sig_fixed_saved_pc
= saved_pc
;
1002 /* We want backtraces out of signal handlers so we don't
1003 set thisframe->signal_handler_caller to 1 */
1006 s390_frame_chain (struct frame_info
*thisframe
)
1008 CORE_ADDR prev_fp
= 0;
1010 if (thisframe
->prev
&& thisframe
->prev
->frame
)
1011 prev_fp
= thisframe
->prev
->frame
;
1012 else if (generic_find_dummy_frame (thisframe
->pc
, thisframe
->frame
))
1013 return generic_read_register_dummy (thisframe
->pc
, thisframe
->frame
,
1018 CORE_ADDR sregs
= 0;
1019 struct frame_extra_info prev_fextra_info
;
1021 memset (&prev_fextra_info
, 0, sizeof (prev_fextra_info
));
1024 CORE_ADDR saved_pc
, sig_pc
;
1026 saved_pc
= s390_frame_saved_pc_nofix (thisframe
);
1030 s390_is_sigreturn (saved_pc
, thisframe
, &sregs
, &sig_pc
)))
1032 s390_get_frame_info (s390_sniff_pc_function_start
1033 (saved_pc
, NULL
), &prev_fextra_info
, NULL
,
1039 /* read sigregs,regs.gprs[11 or 15] */
1040 prev_fp
= read_memory_integer (sregs
+
1041 REGISTER_BYTE (S390_GP0_REGNUM
+
1043 frame_pointer_saved_pc
1046 thisframe
->extra_info
->sigcontext
= sregs
;
1050 if (thisframe
->saved_regs
)
1054 if (prev_fextra_info
.frame_pointer_saved_pc
1055 && thisframe
->saved_regs
[S390_FRAME_REGNUM
])
1056 regno
= S390_FRAME_REGNUM
;
1058 regno
= S390_SP_REGNUM
;
1060 if (thisframe
->saved_regs
[regno
])
1062 /* The SP's entry of `saved_regs' is special. */
1063 if (regno
== S390_SP_REGNUM
)
1064 prev_fp
= thisframe
->saved_regs
[regno
];
1067 read_memory_integer (thisframe
->saved_regs
[regno
],
1073 return ADDR_BITS_REMOVE (prev_fp
);
1077 Whether struct frame_extra_info is actually needed I'll have to figure
1078 out as our frames are similar to rs6000 there is a possibility
1079 i386 dosen't need it. */
1083 /* a given return value in `regbuf' with a type `valtype', extract and copy its
1084 value into `valbuf' */
1086 s390_extract_return_value (struct type
*valtype
, char *regbuf
, char *valbuf
)
1088 /* floats and doubles are returned in fpr0. fpr's have a size of 8 bytes.
1089 We need to truncate the return value into float size (4 byte) if
1091 int len
= TYPE_LENGTH (valtype
);
1093 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
1094 memcpy (valbuf
, ®buf
[REGISTER_BYTE (S390_FP0_REGNUM
)], len
);
1098 /* return value is copied starting from r2. */
1099 if (TYPE_LENGTH (valtype
) < S390_GPR_SIZE
)
1100 offset
= S390_GPR_SIZE
- TYPE_LENGTH (valtype
);
1102 regbuf
+ REGISTER_BYTE (S390_GP0_REGNUM
+ 2) + offset
,
1103 TYPE_LENGTH (valtype
));
1109 s390_promote_integer_argument (struct type
*valtype
, char *valbuf
,
1110 char *reg_buff
, int *arglen
)
1112 char *value
= valbuf
;
1113 int len
= TYPE_LENGTH (valtype
);
1115 if (len
< S390_GPR_SIZE
)
1117 /* We need to upgrade this value to a register to pass it correctly */
1118 int idx
, diff
= S390_GPR_SIZE
- len
, negative
=
1119 (!TYPE_UNSIGNED (valtype
) && value
[0] & 0x80);
1120 for (idx
= 0; idx
< S390_GPR_SIZE
; idx
++)
1122 reg_buff
[idx
] = (idx
< diff
? (negative
? 0xff : 0x0) :
1126 *arglen
= S390_GPR_SIZE
;
1130 if (len
& (S390_GPR_SIZE
- 1))
1132 fprintf_unfiltered (gdb_stderr
,
1133 "s390_promote_integer_argument detected an argument not "
1134 "a multiple of S390_GPR_SIZE & greater than S390_GPR_SIZE "
1135 "we might not deal with this correctly.\n");
1144 s390_store_return_value (struct type
*valtype
, char *valbuf
)
1147 char *reg_buff
= alloca (max (S390_FPR_SIZE
, REGISTER_SIZE
)), *value
;
1149 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
1151 if (TYPE_LENGTH (valtype
) == 4
1152 || TYPE_LENGTH (valtype
) == 8)
1153 write_register_bytes (REGISTER_BYTE (S390_FP0_REGNUM
), valbuf
,
1154 TYPE_LENGTH (valtype
));
1156 error ("GDB is unable to return `long double' values "
1157 "on this architecture.");
1162 s390_promote_integer_argument (valtype
, valbuf
, reg_buff
, &arglen
);
1163 /* Everything else is returned in GPR2 and up. */
1164 write_register_bytes (REGISTER_BYTE (S390_GP0_REGNUM
+ 2), value
,
1169 gdb_print_insn_s390 (bfd_vma memaddr
, disassemble_info
* info
)
1171 bfd_byte instrbuff
[S390_MAX_INSTR_SIZE
];
1174 instrlen
= s390_readinstruction (instrbuff
, (CORE_ADDR
) memaddr
, info
);
1177 (*info
->memory_error_func
) (instrlen
, memaddr
, info
);
1180 for (cnt
= 0; cnt
< instrlen
; cnt
++)
1181 info
->fprintf_func (info
->stream
, "%02X ", instrbuff
[cnt
]);
1182 for (cnt
= instrlen
; cnt
< S390_MAX_INSTR_SIZE
; cnt
++)
1183 info
->fprintf_func (info
->stream
, " ");
1184 instrlen
= print_insn_s390 (memaddr
, info
);
1190 /* Not the most efficent code in the world */
1194 int regno
= S390_SP_REGNUM
;
1195 struct frame_extra_info fextra_info
;
1197 CORE_ADDR pc
= ADDR_BITS_REMOVE (read_register (S390_PC_REGNUM
));
1199 s390_get_frame_info (s390_sniff_pc_function_start (pc
, NULL
), &fextra_info
,
1201 if (fextra_info
.frame_pointer_saved_pc
)
1202 regno
= S390_FRAME_REGNUM
;
1209 return read_register (s390_fp_regnum ());
1214 s390_write_fp (CORE_ADDR val
)
1216 write_register (s390_fp_regnum (), val
);
1221 s390_pop_frame_regular (struct frame_info
*frame
)
1225 write_register (S390_PC_REGNUM
, FRAME_SAVED_PC (frame
));
1227 /* Restore any saved registers. */
1228 if (frame
->saved_regs
)
1230 for (regnum
= 0; regnum
< NUM_REGS
; regnum
++)
1231 if (frame
->saved_regs
[regnum
] != 0)
1235 value
= read_memory_unsigned_integer (frame
->saved_regs
[regnum
],
1236 REGISTER_RAW_SIZE (regnum
));
1237 write_register (regnum
, value
);
1240 /* Actually cut back the stack. Remember that the SP's element of
1241 saved_regs is the old SP itself, not the address at which it is
1243 write_register (S390_SP_REGNUM
, frame
->saved_regs
[S390_SP_REGNUM
]);
1246 /* Throw away any cached frame information. */
1247 flush_cached_frames ();
1251 /* Destroy the innermost (Top-Of-Stack) stack frame, restoring the
1252 machine state that was in effect before the frame was created.
1253 Used in the contexts of the "return" command, and of
1254 target function calls from the debugger. */
1258 /* This function checks for and handles generic dummy frames, and
1259 calls back to our function for ordinary frames. */
1260 generic_pop_current_frame (s390_pop_frame_regular
);
1264 /* Return non-zero if TYPE is an integer-like type, zero otherwise.
1265 "Integer-like" types are those that should be passed the way
1266 integers are: integers, enums, ranges, characters, and booleans. */
1268 is_integer_like (struct type
*type
)
1270 enum type_code code
= TYPE_CODE (type
);
1272 return (code
== TYPE_CODE_INT
1273 || code
== TYPE_CODE_ENUM
1274 || code
== TYPE_CODE_RANGE
1275 || code
== TYPE_CODE_CHAR
1276 || code
== TYPE_CODE_BOOL
);
1280 /* Return non-zero if TYPE is a pointer-like type, zero otherwise.
1281 "Pointer-like" types are those that should be passed the way
1282 pointers are: pointers and references. */
1284 is_pointer_like (struct type
*type
)
1286 enum type_code code
= TYPE_CODE (type
);
1288 return (code
== TYPE_CODE_PTR
1289 || code
== TYPE_CODE_REF
);
1293 /* Return non-zero if TYPE is a `float singleton' or `double
1294 singleton', zero otherwise.
1296 A `T singleton' is a struct type with one member, whose type is
1297 either T or a `T singleton'. So, the following are all float
1301 struct { struct { float x; } x; };
1302 struct { struct { struct { float x; } x; } x; };
1306 WHY THE HECK DO WE CARE ABOUT THIS??? Well, it turns out that GCC
1307 passes all float singletons and double singletons as if they were
1308 simply floats or doubles. This is *not* what the ABI says it
1311 is_float_singleton (struct type
*type
)
1313 return (TYPE_CODE (type
) == TYPE_CODE_STRUCT
1314 && TYPE_NFIELDS (type
) == 1
1315 && (TYPE_CODE (TYPE_FIELD_TYPE (type
, 0)) == TYPE_CODE_FLT
1316 || is_float_singleton (TYPE_FIELD_TYPE (type
, 0))));
1320 /* Return non-zero if TYPE is a struct-like type, zero otherwise.
1321 "Struct-like" types are those that should be passed as structs are:
1324 As an odd quirk, not mentioned in the ABI, GCC passes float and
1325 double singletons as if they were a plain float, double, etc. (The
1326 corresponding union types are handled normally.) So we exclude
1327 those types here. *shrug* */
1329 is_struct_like (struct type
*type
)
1331 enum type_code code
= TYPE_CODE (type
);
1333 return (code
== TYPE_CODE_UNION
1334 || (code
== TYPE_CODE_STRUCT
&& ! is_float_singleton (type
)));
1338 /* Return non-zero if TYPE is a float-like type, zero otherwise.
1339 "Float-like" types are those that should be passed as
1340 floating-point values are.
1342 You'd think this would just be floats, doubles, long doubles, etc.
1343 But as an odd quirk, not mentioned in the ABI, GCC passes float and
1344 double singletons as if they were a plain float, double, etc. (The
1345 corresponding union types are handled normally.) So we exclude
1346 those types here. *shrug* */
1348 is_float_like (struct type
*type
)
1350 return (TYPE_CODE (type
) == TYPE_CODE_FLT
1351 || is_float_singleton (type
));
1355 /* Return non-zero if TYPE is considered a `DOUBLE_OR_FLOAT', as
1356 defined by the parameter passing conventions described in the
1357 "Linux for S/390 ELF Application Binary Interface Supplement".
1358 Otherwise, return zero. */
1360 is_double_or_float (struct type
*type
)
1362 return (is_float_like (type
)
1363 && (TYPE_LENGTH (type
) == 4
1364 || TYPE_LENGTH (type
) == 8));
1368 /* Return non-zero if TYPE is considered a `SIMPLE_ARG', as defined by
1369 the parameter passing conventions described in the "Linux for S/390
1370 ELF Application Binary Interface Supplement". Return zero otherwise. */
1372 is_simple_arg (struct type
*type
)
1374 unsigned length
= TYPE_LENGTH (type
);
1376 /* This is almost a direct translation of the ABI's language, except
1377 that we have to exclude 8-byte structs; those are DOUBLE_ARGs. */
1378 return ((is_integer_like (type
) && length
<= 4)
1379 || is_pointer_like (type
)
1380 || (is_struct_like (type
) && length
!= 8)
1381 || (is_float_like (type
) && length
== 16));
1385 /* Return non-zero if TYPE should be passed as a pointer to a copy,
1386 zero otherwise. TYPE must be a SIMPLE_ARG, as recognized by
1389 pass_by_copy_ref (struct type
*type
)
1391 unsigned length
= TYPE_LENGTH (type
);
1393 return ((is_struct_like (type
) && length
!= 1 && length
!= 2 && length
!= 4)
1394 || (is_float_like (type
) && length
== 16));
1398 /* Return ARG, a `SIMPLE_ARG', sign-extended or zero-extended to a full
1399 word as required for the ABI. */
1401 extend_simple_arg (struct value
*arg
)
1403 struct type
*type
= VALUE_TYPE (arg
);
1405 /* Even structs get passed in the least significant bits of the
1406 register / memory word. It's not really right to extract them as
1407 an integer, but it does take care of the extension. */
1408 if (TYPE_UNSIGNED (type
))
1409 return extract_unsigned_integer (VALUE_CONTENTS (arg
),
1410 TYPE_LENGTH (type
));
1412 return extract_signed_integer (VALUE_CONTENTS (arg
),
1413 TYPE_LENGTH (type
));
1417 /* Return non-zero if TYPE is a `DOUBLE_ARG', as defined by the
1418 parameter passing conventions described in the "Linux for S/390 ELF
1419 Application Binary Interface Supplement". Return zero otherwise. */
1421 is_double_arg (struct type
*type
)
1423 unsigned length
= TYPE_LENGTH (type
);
1425 return ((is_integer_like (type
)
1426 || is_struct_like (type
))
1431 /* Round ADDR up to the next N-byte boundary. N must be a power of
1434 round_up (CORE_ADDR addr
, int n
)
1436 /* Check that N is really a power of two. */
1437 gdb_assert (n
&& (n
& (n
-1)) == 0);
1438 return ((addr
+ n
- 1) & -n
);
1442 /* Round ADDR down to the next N-byte boundary. N must be a power of
1445 round_down (CORE_ADDR addr
, int n
)
1447 /* Check that N is really a power of two. */
1448 gdb_assert (n
&& (n
& (n
-1)) == 0);
1453 /* Return the alignment required by TYPE. */
1455 alignment_of (struct type
*type
)
1459 if (is_integer_like (type
)
1460 || is_pointer_like (type
)
1461 || TYPE_CODE (type
) == TYPE_CODE_FLT
)
1462 alignment
= TYPE_LENGTH (type
);
1463 else if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
1464 || TYPE_CODE (type
) == TYPE_CODE_UNION
)
1469 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1471 int field_alignment
= alignment_of (TYPE_FIELD_TYPE (type
, i
));
1473 if (field_alignment
> alignment
)
1474 alignment
= field_alignment
;
1480 /* Check that everything we ever return is a power of two. Lots of
1481 code doesn't want to deal with aligning things to arbitrary
1483 gdb_assert ((alignment
& (alignment
- 1)) == 0);
1489 /* Put the actual parameter values pointed to by ARGS[0..NARGS-1] in
1490 place to be passed to a function, as specified by the "Linux for
1491 S/390 ELF Application Binary Interface Supplement".
1493 SP is the current stack pointer. We must put arguments, links,
1494 padding, etc. whereever they belong, and return the new stack
1497 If STRUCT_RETURN is non-zero, then the function we're calling is
1498 going to return a structure by value; STRUCT_ADDR is the address of
1499 a block we've allocated for it on the stack.
1501 Our caller has taken care of any type promotions needed to satisfy
1502 prototypes or the old K&R argument-passing rules. */
1504 s390_push_arguments (int nargs
, struct value
**args
, CORE_ADDR sp
,
1505 int struct_return
, CORE_ADDR struct_addr
)
1508 int pointer_size
= (TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
1510 /* The number of arguments passed by reference-to-copy. */
1513 /* If the i'th argument is passed as a reference to a copy, then
1514 copy_addr[i] is the address of the copy we made. */
1515 CORE_ADDR
*copy_addr
= alloca (nargs
* sizeof (CORE_ADDR
));
1517 /* Build the reference-to-copy area. */
1519 for (i
= 0; i
< nargs
; i
++)
1521 struct value
*arg
= args
[i
];
1522 struct type
*type
= VALUE_TYPE (arg
);
1523 unsigned length
= TYPE_LENGTH (type
);
1525 if (is_simple_arg (type
)
1526 && pass_by_copy_ref (type
))
1529 sp
= round_down (sp
, alignment_of (type
));
1530 write_memory (sp
, VALUE_CONTENTS (arg
), length
);
1536 /* Reserve space for the parameter area. As a conservative
1537 simplification, we assume that everything will be passed on the
1542 for (i
= 0; i
< nargs
; i
++)
1544 struct value
*arg
= args
[i
];
1545 struct type
*type
= VALUE_TYPE (arg
);
1546 int length
= TYPE_LENGTH (type
);
1548 sp
= round_down (sp
, alignment_of (type
));
1550 /* SIMPLE_ARG values get extended to 32 bits. Assume every
1552 if (length
< 4) length
= 4;
1557 /* Include space for any reference-to-copy pointers. */
1558 sp
= round_down (sp
, pointer_size
);
1559 sp
-= num_copies
* pointer_size
;
1561 /* After all that, make sure it's still aligned on an eight-byte
1563 sp
= round_down (sp
, 8);
1565 /* Finally, place the actual parameters, working from SP towards
1566 higher addresses. The code above is supposed to reserve enough
1571 CORE_ADDR starg
= sp
;
1573 for (i
= 0; i
< nargs
; i
++)
1575 struct value
*arg
= args
[i
];
1576 struct type
*type
= VALUE_TYPE (arg
);
1578 if (is_double_or_float (type
)
1581 /* When we store a single-precision value in an FP register,
1582 it occupies the leftmost bits. */
1583 write_register_bytes (REGISTER_BYTE (S390_FP0_REGNUM
+ fr
),
1584 VALUE_CONTENTS (arg
),
1585 TYPE_LENGTH (type
));
1588 else if (is_simple_arg (type
)
1591 /* Do we need to pass a pointer to our copy of this
1593 if (pass_by_copy_ref (type
))
1594 write_register (S390_GP0_REGNUM
+ gr
, copy_addr
[i
]);
1596 write_register (S390_GP0_REGNUM
+ gr
, extend_simple_arg (arg
));
1600 else if (is_double_arg (type
)
1603 write_register_gen (S390_GP0_REGNUM
+ gr
,
1604 VALUE_CONTENTS (arg
));
1605 write_register_gen (S390_GP0_REGNUM
+ gr
+ 1,
1606 VALUE_CONTENTS (arg
) + 4);
1611 /* The `OTHER' case. */
1612 enum type_code code
= TYPE_CODE (type
);
1613 unsigned length
= TYPE_LENGTH (type
);
1615 /* If we skipped r6 because we couldn't fit a DOUBLE_ARG
1616 in it, then don't go back and use it again later. */
1617 if (is_double_arg (type
) && gr
== 6)
1620 if (is_simple_arg (type
))
1622 /* Simple args are always either extended to 32 bits,
1624 starg
= round_up (starg
, 4);
1626 /* Do we need to pass a pointer to our copy of this
1628 if (pass_by_copy_ref (type
))
1629 write_memory_signed_integer (starg
, pointer_size
,
1632 /* Simple args are always extended to 32 bits. */
1633 write_memory_signed_integer (starg
, 4,
1634 extend_simple_arg (arg
));
1639 /* You'd think we should say:
1640 starg = round_up (starg, alignment_of (type));
1641 Unfortunately, GCC seems to simply align the stack on
1642 a four-byte boundary, even when passing doubles. */
1643 starg
= round_up (starg
, 4);
1644 write_memory (starg
, VALUE_CONTENTS (arg
), length
);
1651 /* Allocate the standard frame areas: the register save area, the
1652 word reserved for the compiler (which seems kind of meaningless),
1653 and the back chain pointer. */
1656 /* Write the back chain pointer into the first word of the stack
1657 frame. This will help us get backtraces from within functions
1659 write_memory_unsigned_integer (sp
, (TARGET_PTR_BIT
/ TARGET_CHAR_BIT
),
1667 s390_use_struct_convention (int gcc_p
, struct type
*value_type
)
1669 enum type_code code
= TYPE_CODE (value_type
);
1671 return (code
== TYPE_CODE_STRUCT
1672 || code
== TYPE_CODE_UNION
);
1676 /* Return the GDB type object for the "standard" data type
1677 of data in register N. */
1679 s390_register_virtual_type (int regno
)
1681 if (S390_FP0_REGNUM
<= regno
&& regno
< S390_FP0_REGNUM
+ S390_NUM_FPRS
)
1682 return builtin_type_double
;
1684 return builtin_type_int
;
1689 s390x_register_virtual_type (int regno
)
1691 return (regno
== S390_FPC_REGNUM
) ||
1692 (regno
>= S390_FIRST_ACR
&& regno
<= S390_LAST_ACR
) ? builtin_type_int
:
1693 (regno
>= S390_FP0_REGNUM
) ? builtin_type_double
: builtin_type_long
;
1699 s390_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
)
1701 write_register (S390_GP0_REGNUM
+ 2, addr
);
1706 static unsigned char *
1707 s390_breakpoint_from_pc (CORE_ADDR
*pcptr
, int *lenptr
)
1709 static unsigned char breakpoint
[] = { 0x0, 0x1 };
1711 *lenptr
= sizeof (breakpoint
);
1715 /* Advance PC across any function entry prologue instructions to reach some
1718 s390_skip_prologue (CORE_ADDR pc
)
1720 struct frame_extra_info fextra_info
;
1722 s390_get_frame_info (pc
, &fextra_info
, NULL
, 1);
1723 return fextra_info
.skip_prologue_function_start
;
1726 /* Immediately after a function call, return the saved pc.
1727 Can't go through the frames for this because on some machines
1728 the new frame is not set up until the new function executes
1729 some instructions. */
1731 s390_saved_pc_after_call (struct frame_info
*frame
)
1733 return ADDR_BITS_REMOVE (read_register (S390_RETADDR_REGNUM
));
1737 s390_addr_bits_remove (CORE_ADDR addr
)
1739 return (addr
) & 0x7fffffff;
1744 s390_push_return_address (CORE_ADDR pc
, CORE_ADDR sp
)
1746 write_register (S390_RETADDR_REGNUM
, CALL_DUMMY_ADDRESS ());
1751 s390_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1753 static LONGEST s390_call_dummy_words
[] = { 0 };
1754 struct gdbarch
*gdbarch
;
1755 struct gdbarch_tdep
*tdep
;
1758 /* First see if there is already a gdbarch that can satisfy the request. */
1759 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1761 return arches
->gdbarch
;
1763 /* None found: is the request for a s390 architecture? */
1764 if (info
.bfd_arch_info
->arch
!= bfd_arch_s390
)
1765 return NULL
; /* No; then it's not for us. */
1767 /* Yes: create a new gdbarch for the specified machine type. */
1768 gdbarch
= gdbarch_alloc (&info
, NULL
);
1770 set_gdbarch_believe_pcc_promotion (gdbarch
, 0);
1771 set_gdbarch_char_signed (gdbarch
, 0);
1773 set_gdbarch_frame_args_skip (gdbarch
, 0);
1774 set_gdbarch_frame_args_address (gdbarch
, s390_frame_args_address
);
1775 set_gdbarch_frame_chain (gdbarch
, s390_frame_chain
);
1776 set_gdbarch_frame_init_saved_regs (gdbarch
, s390_frame_init_saved_regs
);
1777 set_gdbarch_frame_locals_address (gdbarch
, s390_frame_args_address
);
1778 /* We can't do this */
1779 set_gdbarch_frame_num_args (gdbarch
, frame_num_args_unknown
);
1780 set_gdbarch_store_struct_return (gdbarch
, s390_store_struct_return
);
1781 set_gdbarch_extract_return_value (gdbarch
, s390_extract_return_value
);
1782 set_gdbarch_store_return_value (gdbarch
, s390_store_return_value
);
1783 /* Amount PC must be decremented by after a breakpoint.
1784 This is often the number of bytes in BREAKPOINT
1786 set_gdbarch_decr_pc_after_break (gdbarch
, 2);
1787 set_gdbarch_pop_frame (gdbarch
, s390_pop_frame
);
1788 /* Stack grows downward. */
1789 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1790 /* Offset from address of function to start of its code.
1791 Zero on most machines. */
1792 set_gdbarch_function_start_offset (gdbarch
, 0);
1793 set_gdbarch_max_register_raw_size (gdbarch
, 8);
1794 set_gdbarch_max_register_virtual_size (gdbarch
, 8);
1795 set_gdbarch_breakpoint_from_pc (gdbarch
, s390_breakpoint_from_pc
);
1796 set_gdbarch_skip_prologue (gdbarch
, s390_skip_prologue
);
1797 set_gdbarch_init_extra_frame_info (gdbarch
, s390_init_extra_frame_info
);
1798 set_gdbarch_init_frame_pc_first (gdbarch
, s390_init_frame_pc_first
);
1799 set_gdbarch_read_fp (gdbarch
, s390_read_fp
);
1800 set_gdbarch_write_fp (gdbarch
, s390_write_fp
);
1801 /* This function that tells us whether the function invocation represented
1802 by FI does not have a frame on the stack associated with it. If it
1803 does not, FRAMELESS is set to 1, else 0. */
1804 set_gdbarch_frameless_function_invocation (gdbarch
,
1805 s390_frameless_function_invocation
);
1806 /* Return saved PC from a frame */
1807 set_gdbarch_frame_saved_pc (gdbarch
, s390_frame_saved_pc
);
1808 /* FRAME_CHAIN takes a frame's nominal address
1809 and produces the frame's chain-pointer. */
1810 set_gdbarch_frame_chain (gdbarch
, s390_frame_chain
);
1811 set_gdbarch_saved_pc_after_call (gdbarch
, s390_saved_pc_after_call
);
1812 set_gdbarch_register_byte (gdbarch
, s390_register_byte
);
1813 set_gdbarch_pc_regnum (gdbarch
, S390_PC_REGNUM
);
1814 set_gdbarch_sp_regnum (gdbarch
, S390_SP_REGNUM
);
1815 set_gdbarch_fp_regnum (gdbarch
, S390_FP_REGNUM
);
1816 set_gdbarch_fp0_regnum (gdbarch
, S390_FP0_REGNUM
);
1817 set_gdbarch_num_regs (gdbarch
, S390_NUM_REGS
);
1818 set_gdbarch_cannot_fetch_register (gdbarch
, s390_cannot_fetch_register
);
1819 set_gdbarch_cannot_store_register (gdbarch
, s390_cannot_fetch_register
);
1820 set_gdbarch_get_saved_register (gdbarch
, generic_get_saved_register
);
1821 set_gdbarch_use_struct_convention (gdbarch
, s390_use_struct_convention
);
1822 set_gdbarch_frame_chain_valid (gdbarch
, func_frame_chain_valid
);
1823 set_gdbarch_register_name (gdbarch
, s390_register_name
);
1824 set_gdbarch_stab_reg_to_regnum (gdbarch
, s390_stab_reg_to_regnum
);
1825 set_gdbarch_dwarf_reg_to_regnum (gdbarch
, s390_stab_reg_to_regnum
);
1826 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, s390_stab_reg_to_regnum
);
1827 set_gdbarch_extract_struct_value_address
1828 (gdbarch
, generic_cannot_extract_struct_value_address
);
1830 /* Parameters for inferior function calls. */
1831 set_gdbarch_call_dummy_p (gdbarch
, 1);
1832 set_gdbarch_use_generic_dummy_frames (gdbarch
, 1);
1833 set_gdbarch_call_dummy_length (gdbarch
, 0);
1834 set_gdbarch_call_dummy_location (gdbarch
, AT_ENTRY_POINT
);
1835 set_gdbarch_call_dummy_address (gdbarch
, entry_point_address
);
1836 set_gdbarch_call_dummy_start_offset (gdbarch
, 0);
1837 set_gdbarch_pc_in_call_dummy (gdbarch
, pc_in_call_dummy_at_entry_point
);
1838 set_gdbarch_push_dummy_frame (gdbarch
, generic_push_dummy_frame
);
1839 set_gdbarch_push_arguments (gdbarch
, s390_push_arguments
);
1840 set_gdbarch_save_dummy_frame_tos (gdbarch
, generic_save_dummy_frame_tos
);
1841 set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch
, 1);
1842 set_gdbarch_call_dummy_breakpoint_offset (gdbarch
, 0);
1843 set_gdbarch_call_dummy_stack_adjust_p (gdbarch
, 0);
1844 set_gdbarch_fix_call_dummy (gdbarch
, generic_fix_call_dummy
);
1845 set_gdbarch_push_return_address (gdbarch
, s390_push_return_address
);
1846 set_gdbarch_sizeof_call_dummy_words (gdbarch
,
1847 sizeof (s390_call_dummy_words
));
1848 set_gdbarch_call_dummy_words (gdbarch
, s390_call_dummy_words
);
1849 set_gdbarch_coerce_float_to_double (gdbarch
,
1850 standard_coerce_float_to_double
);
1852 switch (info
.bfd_arch_info
->mach
)
1854 case bfd_mach_s390_esa
:
1855 set_gdbarch_register_size (gdbarch
, 4);
1856 set_gdbarch_register_raw_size (gdbarch
, s390_register_raw_size
);
1857 set_gdbarch_register_virtual_size (gdbarch
, s390_register_raw_size
);
1858 set_gdbarch_register_virtual_type (gdbarch
, s390_register_virtual_type
);
1860 set_gdbarch_addr_bits_remove (gdbarch
, s390_addr_bits_remove
);
1861 set_gdbarch_register_bytes (gdbarch
, S390_REGISTER_BYTES
);
1863 case bfd_mach_s390_esame
:
1864 set_gdbarch_register_size (gdbarch
, 8);
1865 set_gdbarch_register_raw_size (gdbarch
, s390x_register_raw_size
);
1866 set_gdbarch_register_virtual_size (gdbarch
, s390x_register_raw_size
);
1867 set_gdbarch_register_virtual_type (gdbarch
,
1868 s390x_register_virtual_type
);
1870 set_gdbarch_long_bit (gdbarch
, 64);
1871 set_gdbarch_long_long_bit (gdbarch
, 64);
1872 set_gdbarch_ptr_bit (gdbarch
, 64);
1873 set_gdbarch_register_bytes (gdbarch
, S390X_REGISTER_BYTES
);
1883 _initialize_s390_tdep ()
1886 /* Hook us into the gdbarch mechanism. */
1887 register_gdbarch_init (bfd_arch_s390
, s390_gdbarch_init
);
1888 if (!tm_print_insn
) /* Someone may have already set it */
1889 tm_print_insn
= gdb_print_insn_s390
;
1892 #endif /* GDBSERVER */