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 for (regnum
= 0; regnum
< NUM_REGS
; regnum
++)
1229 if (frame
->saved_regs
[regnum
] != 0)
1233 value
= read_memory_unsigned_integer (frame
->saved_regs
[regnum
],
1234 REGISTER_RAW_SIZE (regnum
));
1235 write_register (regnum
, value
);
1238 /* Actually cut back the stack. Remember that the SP's element of
1239 saved_regs is the old SP itself, not the address at which it is
1241 write_register (S390_SP_REGNUM
, frame
->saved_regs
[S390_SP_REGNUM
]);
1243 /* Throw away any cached frame information. */
1244 flush_cached_frames ();
1248 /* Destroy the innermost (Top-Of-Stack) stack frame, restoring the
1249 machine state that was in effect before the frame was created.
1250 Used in the contexts of the "return" command, and of
1251 target function calls from the debugger. */
1255 /* This function checks for and handles generic dummy frames, and
1256 calls back to our function for ordinary frames. */
1257 generic_pop_current_frame (s390_pop_frame_regular
);
1261 /* Return non-zero if TYPE is an integer-like type, zero otherwise.
1262 "Integer-like" types are those that should be passed the way
1263 integers are: integers, enums, ranges, characters, and booleans. */
1265 is_integer_like (struct type
*type
)
1267 enum type_code code
= TYPE_CODE (type
);
1269 return (code
== TYPE_CODE_INT
1270 || code
== TYPE_CODE_ENUM
1271 || code
== TYPE_CODE_RANGE
1272 || code
== TYPE_CODE_CHAR
1273 || code
== TYPE_CODE_BOOL
);
1277 /* Return non-zero if TYPE is a pointer-like type, zero otherwise.
1278 "Pointer-like" types are those that should be passed the way
1279 pointers are: pointers and references. */
1281 is_pointer_like (struct type
*type
)
1283 enum type_code code
= TYPE_CODE (type
);
1285 return (code
== TYPE_CODE_PTR
1286 || code
== TYPE_CODE_REF
);
1290 /* Return non-zero if TYPE is a `float singleton' or `double
1291 singleton', zero otherwise.
1293 A `T singleton' is a struct type with one member, whose type is
1294 either T or a `T singleton'. So, the following are all float
1298 struct { struct { float x; } x; };
1299 struct { struct { struct { float x; } x; } x; };
1303 WHY THE HECK DO WE CARE ABOUT THIS??? Well, it turns out that GCC
1304 passes all float singletons and double singletons as if they were
1305 simply floats or doubles. This is *not* what the ABI says it
1308 is_float_singleton (struct type
*type
)
1310 return (TYPE_CODE (type
) == TYPE_CODE_STRUCT
1311 && TYPE_NFIELDS (type
) == 1
1312 && (TYPE_CODE (TYPE_FIELD_TYPE (type
, 0)) == TYPE_CODE_FLT
1313 || is_float_singleton (TYPE_FIELD_TYPE (type
, 0))));
1317 /* Return non-zero if TYPE is a struct-like type, zero otherwise.
1318 "Struct-like" types are those that should be passed as structs are:
1321 As an odd quirk, not mentioned in the ABI, GCC passes float and
1322 double singletons as if they were a plain float, double, etc. (The
1323 corresponding union types are handled normally.) So we exclude
1324 those types here. *shrug* */
1326 is_struct_like (struct type
*type
)
1328 enum type_code code
= TYPE_CODE (type
);
1330 return (code
== TYPE_CODE_UNION
1331 || (code
== TYPE_CODE_STRUCT
&& ! is_float_singleton (type
)));
1335 /* Return non-zero if TYPE is a float-like type, zero otherwise.
1336 "Float-like" types are those that should be passed as
1337 floating-point values are.
1339 You'd think this would just be floats, doubles, long doubles, etc.
1340 But as an odd quirk, not mentioned in the ABI, GCC passes float and
1341 double singletons as if they were a plain float, double, etc. (The
1342 corresponding union types are handled normally.) So we exclude
1343 those types here. *shrug* */
1345 is_float_like (struct type
*type
)
1347 return (TYPE_CODE (type
) == TYPE_CODE_FLT
1348 || is_float_singleton (type
));
1352 /* Return non-zero if TYPE is considered a `DOUBLE_OR_FLOAT', as
1353 defined by the parameter passing conventions described in the
1354 "Linux for S/390 ELF Application Binary Interface Supplement".
1355 Otherwise, return zero. */
1357 is_double_or_float (struct type
*type
)
1359 return (is_float_like (type
)
1360 && (TYPE_LENGTH (type
) == 4
1361 || TYPE_LENGTH (type
) == 8));
1365 /* Return non-zero if TYPE is considered a `SIMPLE_ARG', as defined by
1366 the parameter passing conventions described in the "Linux for S/390
1367 ELF Application Binary Interface Supplement". Return zero otherwise. */
1369 is_simple_arg (struct type
*type
)
1371 unsigned length
= TYPE_LENGTH (type
);
1373 /* This is almost a direct translation of the ABI's language, except
1374 that we have to exclude 8-byte structs; those are DOUBLE_ARGs. */
1375 return ((is_integer_like (type
) && length
<= 4)
1376 || is_pointer_like (type
)
1377 || (is_struct_like (type
) && length
!= 8)
1378 || (is_float_like (type
) && length
== 16));
1382 /* Return non-zero if TYPE should be passed as a pointer to a copy,
1383 zero otherwise. TYPE must be a SIMPLE_ARG, as recognized by
1386 pass_by_copy_ref (struct type
*type
)
1388 unsigned length
= TYPE_LENGTH (type
);
1390 return ((is_struct_like (type
) && length
!= 1 && length
!= 2 && length
!= 4)
1391 || (is_float_like (type
) && length
== 16));
1395 /* Return ARG, a `SIMPLE_ARG', sign-extended or zero-extended to a full
1396 word as required for the ABI. */
1398 extend_simple_arg (struct value
*arg
)
1400 struct type
*type
= VALUE_TYPE (arg
);
1402 /* Even structs get passed in the least significant bits of the
1403 register / memory word. It's not really right to extract them as
1404 an integer, but it does take care of the extension. */
1405 if (TYPE_UNSIGNED (type
))
1406 return extract_unsigned_integer (VALUE_CONTENTS (arg
),
1407 TYPE_LENGTH (type
));
1409 return extract_signed_integer (VALUE_CONTENTS (arg
),
1410 TYPE_LENGTH (type
));
1414 /* Return non-zero if TYPE is a `DOUBLE_ARG', as defined by the
1415 parameter passing conventions described in the "Linux for S/390 ELF
1416 Application Binary Interface Supplement". Return zero otherwise. */
1418 is_double_arg (struct type
*type
)
1420 unsigned length
= TYPE_LENGTH (type
);
1422 return ((is_integer_like (type
)
1423 || is_struct_like (type
))
1428 /* Round ADDR up to the next N-byte boundary. N must be a power of
1431 round_up (CORE_ADDR addr
, int n
)
1433 /* Check that N is really a power of two. */
1434 gdb_assert (n
&& (n
& (n
-1)) == 0);
1435 return ((addr
+ n
- 1) & -n
);
1439 /* Round ADDR down to the next N-byte boundary. N must be a power of
1442 round_down (CORE_ADDR addr
, int n
)
1444 /* Check that N is really a power of two. */
1445 gdb_assert (n
&& (n
& (n
-1)) == 0);
1450 /* Return the alignment required by TYPE. */
1452 alignment_of (struct type
*type
)
1456 if (is_integer_like (type
)
1457 || is_pointer_like (type
)
1458 || TYPE_CODE (type
) == TYPE_CODE_FLT
)
1459 alignment
= TYPE_LENGTH (type
);
1460 else if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
1461 || TYPE_CODE (type
) == TYPE_CODE_UNION
)
1466 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1468 int field_alignment
= alignment_of (TYPE_FIELD_TYPE (type
, i
));
1470 if (field_alignment
> alignment
)
1471 alignment
= field_alignment
;
1477 /* Check that everything we ever return is a power of two. Lots of
1478 code doesn't want to deal with aligning things to arbitrary
1480 gdb_assert ((alignment
& (alignment
- 1)) == 0);
1486 /* Put the actual parameter values pointed to by ARGS[0..NARGS-1] in
1487 place to be passed to a function, as specified by the "Linux for
1488 S/390 ELF Application Binary Interface Supplement".
1490 SP is the current stack pointer. We must put arguments, links,
1491 padding, etc. whereever they belong, and return the new stack
1494 If STRUCT_RETURN is non-zero, then the function we're calling is
1495 going to return a structure by value; STRUCT_ADDR is the address of
1496 a block we've allocated for it on the stack.
1498 Our caller has taken care of any type promotions needed to satisfy
1499 prototypes or the old K&R argument-passing rules. */
1501 s390_push_arguments (int nargs
, struct value
**args
, CORE_ADDR sp
,
1502 int struct_return
, CORE_ADDR struct_addr
)
1505 int pointer_size
= (TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
1507 /* The number of arguments passed by reference-to-copy. */
1510 /* If the i'th argument is passed as a reference to a copy, then
1511 copy_addr[i] is the address of the copy we made. */
1512 CORE_ADDR
*copy_addr
= alloca (nargs
* sizeof (CORE_ADDR
));
1514 /* Build the reference-to-copy area. */
1516 for (i
= 0; i
< nargs
; i
++)
1518 struct value
*arg
= args
[i
];
1519 struct type
*type
= VALUE_TYPE (arg
);
1520 unsigned length
= TYPE_LENGTH (type
);
1522 if (is_simple_arg (type
)
1523 && pass_by_copy_ref (type
))
1526 sp
= round_down (sp
, alignment_of (type
));
1527 write_memory (sp
, VALUE_CONTENTS (arg
), length
);
1533 /* Reserve space for the parameter area. As a conservative
1534 simplification, we assume that everything will be passed on the
1539 for (i
= 0; i
< nargs
; i
++)
1541 struct value
*arg
= args
[i
];
1542 struct type
*type
= VALUE_TYPE (arg
);
1543 int length
= TYPE_LENGTH (type
);
1545 sp
= round_down (sp
, alignment_of (type
));
1547 /* SIMPLE_ARG values get extended to 32 bits. Assume every
1549 if (length
< 4) length
= 4;
1554 /* Include space for any reference-to-copy pointers. */
1555 sp
= round_down (sp
, pointer_size
);
1556 sp
-= num_copies
* pointer_size
;
1558 /* After all that, make sure it's still aligned on an eight-byte
1560 sp
= round_down (sp
, 8);
1562 /* Finally, place the actual parameters, working from SP towards
1563 higher addresses. The code above is supposed to reserve enough
1568 CORE_ADDR starg
= sp
;
1570 for (i
= 0; i
< nargs
; i
++)
1572 struct value
*arg
= args
[i
];
1573 struct type
*type
= VALUE_TYPE (arg
);
1575 if (is_double_or_float (type
)
1578 /* When we store a single-precision value in an FP register,
1579 it occupies the leftmost bits. */
1580 write_register_bytes (REGISTER_BYTE (S390_FP0_REGNUM
+ fr
),
1581 VALUE_CONTENTS (arg
),
1582 TYPE_LENGTH (type
));
1585 else if (is_simple_arg (type
)
1588 /* Do we need to pass a pointer to our copy of this
1590 if (pass_by_copy_ref (type
))
1591 write_register (S390_GP0_REGNUM
+ gr
, copy_addr
[i
]);
1593 write_register (S390_GP0_REGNUM
+ gr
, extend_simple_arg (arg
));
1597 else if (is_double_arg (type
)
1600 write_register_gen (S390_GP0_REGNUM
+ gr
,
1601 VALUE_CONTENTS (arg
));
1602 write_register_gen (S390_GP0_REGNUM
+ gr
+ 1,
1603 VALUE_CONTENTS (arg
) + 4);
1608 /* The `OTHER' case. */
1609 enum type_code code
= TYPE_CODE (type
);
1610 unsigned length
= TYPE_LENGTH (type
);
1612 /* If we skipped r6 because we couldn't fit a DOUBLE_ARG
1613 in it, then don't go back and use it again later. */
1614 if (is_double_arg (type
) && gr
== 6)
1617 if (is_simple_arg (type
))
1619 /* Simple args are always either extended to 32 bits,
1621 starg
= round_up (starg
, 4);
1623 /* Do we need to pass a pointer to our copy of this
1625 if (pass_by_copy_ref (type
))
1626 write_memory_signed_integer (starg
, pointer_size
,
1629 /* Simple args are always extended to 32 bits. */
1630 write_memory_signed_integer (starg
, 4,
1631 extend_simple_arg (arg
));
1636 /* You'd think we should say:
1637 starg = round_up (starg, alignment_of (type));
1638 Unfortunately, GCC seems to simply align the stack on
1639 a four-byte boundary, even when passing doubles. */
1640 starg
= round_up (starg
, 4);
1641 write_memory (starg
, VALUE_CONTENTS (arg
), length
);
1648 /* Allocate the standard frame areas: the register save area, the
1649 word reserved for the compiler (which seems kind of meaningless),
1650 and the back chain pointer. */
1653 /* Write the back chain pointer into the first word of the stack
1654 frame. This will help us get backtraces from within functions
1656 write_memory_unsigned_integer (sp
, (TARGET_PTR_BIT
/ TARGET_CHAR_BIT
),
1664 s390_use_struct_convention (int gcc_p
, struct type
*value_type
)
1666 enum type_code code
= TYPE_CODE (value_type
);
1668 return (code
== TYPE_CODE_STRUCT
1669 || code
== TYPE_CODE_UNION
);
1673 /* Return the GDB type object for the "standard" data type
1674 of data in register N. */
1676 s390_register_virtual_type (int regno
)
1678 if (S390_FP0_REGNUM
<= regno
&& regno
< S390_FP0_REGNUM
+ S390_NUM_FPRS
)
1679 return builtin_type_double
;
1681 return builtin_type_int
;
1686 s390x_register_virtual_type (int regno
)
1688 return (regno
== S390_FPC_REGNUM
) ||
1689 (regno
>= S390_FIRST_ACR
&& regno
<= S390_LAST_ACR
) ? builtin_type_int
:
1690 (regno
>= S390_FP0_REGNUM
) ? builtin_type_double
: builtin_type_long
;
1696 s390_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
)
1698 write_register (S390_GP0_REGNUM
+ 2, addr
);
1703 static unsigned char *
1704 s390_breakpoint_from_pc (CORE_ADDR
*pcptr
, int *lenptr
)
1706 static unsigned char breakpoint
[] = { 0x0, 0x1 };
1708 *lenptr
= sizeof (breakpoint
);
1712 /* Advance PC across any function entry prologue instructions to reach some
1715 s390_skip_prologue (CORE_ADDR pc
)
1717 struct frame_extra_info fextra_info
;
1719 s390_get_frame_info (pc
, &fextra_info
, NULL
, 1);
1720 return fextra_info
.skip_prologue_function_start
;
1723 /* Immediately after a function call, return the saved pc.
1724 Can't go through the frames for this because on some machines
1725 the new frame is not set up until the new function executes
1726 some instructions. */
1728 s390_saved_pc_after_call (struct frame_info
*frame
)
1730 return ADDR_BITS_REMOVE (read_register (S390_RETADDR_REGNUM
));
1734 s390_addr_bits_remove (CORE_ADDR addr
)
1736 return (addr
) & 0x7fffffff;
1741 s390_push_return_address (CORE_ADDR pc
, CORE_ADDR sp
)
1743 write_register (S390_RETADDR_REGNUM
, CALL_DUMMY_ADDRESS ());
1748 s390_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1750 static LONGEST s390_call_dummy_words
[] = { 0 };
1751 struct gdbarch
*gdbarch
;
1752 struct gdbarch_tdep
*tdep
;
1755 /* First see if there is already a gdbarch that can satisfy the request. */
1756 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1758 return arches
->gdbarch
;
1760 /* None found: is the request for a s390 architecture? */
1761 if (info
.bfd_arch_info
->arch
!= bfd_arch_s390
)
1762 return NULL
; /* No; then it's not for us. */
1764 /* Yes: create a new gdbarch for the specified machine type. */
1765 gdbarch
= gdbarch_alloc (&info
, NULL
);
1767 set_gdbarch_believe_pcc_promotion (gdbarch
, 0);
1768 set_gdbarch_char_signed (gdbarch
, 0);
1770 set_gdbarch_frame_args_skip (gdbarch
, 0);
1771 set_gdbarch_frame_args_address (gdbarch
, s390_frame_args_address
);
1772 set_gdbarch_frame_chain (gdbarch
, s390_frame_chain
);
1773 set_gdbarch_frame_init_saved_regs (gdbarch
, s390_frame_init_saved_regs
);
1774 set_gdbarch_frame_locals_address (gdbarch
, s390_frame_args_address
);
1775 /* We can't do this */
1776 set_gdbarch_frame_num_args (gdbarch
, frame_num_args_unknown
);
1777 set_gdbarch_store_struct_return (gdbarch
, s390_store_struct_return
);
1778 set_gdbarch_extract_return_value (gdbarch
, s390_extract_return_value
);
1779 set_gdbarch_store_return_value (gdbarch
, s390_store_return_value
);
1780 /* Amount PC must be decremented by after a breakpoint.
1781 This is often the number of bytes in BREAKPOINT
1783 set_gdbarch_decr_pc_after_break (gdbarch
, 2);
1784 set_gdbarch_pop_frame (gdbarch
, s390_pop_frame
);
1785 set_gdbarch_ieee_float (gdbarch
, 1);
1786 /* Stack grows downward. */
1787 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1788 /* Offset from address of function to start of its code.
1789 Zero on most machines. */
1790 set_gdbarch_function_start_offset (gdbarch
, 0);
1791 set_gdbarch_max_register_raw_size (gdbarch
, 8);
1792 set_gdbarch_max_register_virtual_size (gdbarch
, 8);
1793 set_gdbarch_breakpoint_from_pc (gdbarch
, s390_breakpoint_from_pc
);
1794 set_gdbarch_skip_prologue (gdbarch
, s390_skip_prologue
);
1795 set_gdbarch_init_extra_frame_info (gdbarch
, s390_init_extra_frame_info
);
1796 set_gdbarch_init_frame_pc_first (gdbarch
, s390_init_frame_pc_first
);
1797 set_gdbarch_read_fp (gdbarch
, s390_read_fp
);
1798 set_gdbarch_write_fp (gdbarch
, s390_write_fp
);
1799 /* This function that tells us whether the function invocation represented
1800 by FI does not have a frame on the stack associated with it. If it
1801 does not, FRAMELESS is set to 1, else 0. */
1802 set_gdbarch_frameless_function_invocation (gdbarch
,
1803 s390_frameless_function_invocation
);
1804 /* Return saved PC from a frame */
1805 set_gdbarch_frame_saved_pc (gdbarch
, s390_frame_saved_pc
);
1806 /* FRAME_CHAIN takes a frame's nominal address
1807 and produces the frame's chain-pointer. */
1808 set_gdbarch_frame_chain (gdbarch
, s390_frame_chain
);
1809 set_gdbarch_saved_pc_after_call (gdbarch
, s390_saved_pc_after_call
);
1810 set_gdbarch_register_byte (gdbarch
, s390_register_byte
);
1811 set_gdbarch_pc_regnum (gdbarch
, S390_PC_REGNUM
);
1812 set_gdbarch_sp_regnum (gdbarch
, S390_SP_REGNUM
);
1813 set_gdbarch_fp_regnum (gdbarch
, S390_FP_REGNUM
);
1814 set_gdbarch_fp0_regnum (gdbarch
, S390_FP0_REGNUM
);
1815 set_gdbarch_num_regs (gdbarch
, S390_NUM_REGS
);
1816 set_gdbarch_cannot_fetch_register (gdbarch
, s390_cannot_fetch_register
);
1817 set_gdbarch_cannot_store_register (gdbarch
, s390_cannot_fetch_register
);
1818 set_gdbarch_get_saved_register (gdbarch
, generic_get_saved_register
);
1819 set_gdbarch_use_struct_convention (gdbarch
, s390_use_struct_convention
);
1820 set_gdbarch_frame_chain_valid (gdbarch
, func_frame_chain_valid
);
1821 set_gdbarch_register_name (gdbarch
, s390_register_name
);
1822 set_gdbarch_stab_reg_to_regnum (gdbarch
, s390_stab_reg_to_regnum
);
1823 set_gdbarch_dwarf_reg_to_regnum (gdbarch
, s390_stab_reg_to_regnum
);
1824 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, s390_stab_reg_to_regnum
);
1825 set_gdbarch_extract_struct_value_address
1826 (gdbarch
, generic_cannot_extract_struct_value_address
);
1828 /* Parameters for inferior function calls. */
1829 set_gdbarch_call_dummy_p (gdbarch
, 1);
1830 set_gdbarch_use_generic_dummy_frames (gdbarch
, 1);
1831 set_gdbarch_call_dummy_length (gdbarch
, 0);
1832 set_gdbarch_call_dummy_location (gdbarch
, AT_ENTRY_POINT
);
1833 set_gdbarch_call_dummy_address (gdbarch
, entry_point_address
);
1834 set_gdbarch_call_dummy_start_offset (gdbarch
, 0);
1835 set_gdbarch_pc_in_call_dummy (gdbarch
, pc_in_call_dummy_at_entry_point
);
1836 set_gdbarch_push_dummy_frame (gdbarch
, generic_push_dummy_frame
);
1837 set_gdbarch_push_arguments (gdbarch
, s390_push_arguments
);
1838 set_gdbarch_save_dummy_frame_tos (gdbarch
, generic_save_dummy_frame_tos
);
1839 set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch
, 1);
1840 set_gdbarch_call_dummy_breakpoint_offset (gdbarch
, 0);
1841 set_gdbarch_call_dummy_stack_adjust_p (gdbarch
, 0);
1842 set_gdbarch_fix_call_dummy (gdbarch
, generic_fix_call_dummy
);
1843 set_gdbarch_push_return_address (gdbarch
, s390_push_return_address
);
1844 set_gdbarch_sizeof_call_dummy_words (gdbarch
,
1845 sizeof (s390_call_dummy_words
));
1846 set_gdbarch_call_dummy_words (gdbarch
, s390_call_dummy_words
);
1847 set_gdbarch_coerce_float_to_double (gdbarch
,
1848 standard_coerce_float_to_double
);
1850 switch (info
.bfd_arch_info
->mach
)
1852 case bfd_mach_s390_esa
:
1853 set_gdbarch_register_size (gdbarch
, 4);
1854 set_gdbarch_register_raw_size (gdbarch
, s390_register_raw_size
);
1855 set_gdbarch_register_virtual_size (gdbarch
, s390_register_raw_size
);
1856 set_gdbarch_register_virtual_type (gdbarch
, s390_register_virtual_type
);
1858 set_gdbarch_addr_bits_remove (gdbarch
, s390_addr_bits_remove
);
1859 set_gdbarch_register_bytes (gdbarch
, S390_REGISTER_BYTES
);
1861 case bfd_mach_s390_esame
:
1862 set_gdbarch_register_size (gdbarch
, 8);
1863 set_gdbarch_register_raw_size (gdbarch
, s390x_register_raw_size
);
1864 set_gdbarch_register_virtual_size (gdbarch
, s390x_register_raw_size
);
1865 set_gdbarch_register_virtual_type (gdbarch
,
1866 s390x_register_virtual_type
);
1868 set_gdbarch_long_bit (gdbarch
, 64);
1869 set_gdbarch_long_long_bit (gdbarch
, 64);
1870 set_gdbarch_ptr_bit (gdbarch
, 64);
1871 set_gdbarch_register_bytes (gdbarch
, S390X_REGISTER_BYTES
);
1881 _initialize_s390_tdep ()
1884 /* Hook us into the gdbarch mechanism. */
1885 register_gdbarch_init (bfd_arch_s390
, s390_gdbarch_init
);
1886 if (!tm_print_insn
) /* Someone may have already set it */
1887 tm_print_insn
= gdb_print_insn_s390
;
1890 #endif /* GDBSERVER */