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
46 Note that the unsigned cast here forces the result of the
47 subtraction to very high positive values if N < S390_FP0_REGNUM */
49 s390_register_raw_size (int reg_nr
)
51 return ((unsigned) reg_nr
- S390_FP0_REGNUM
) <
52 S390_NUM_FPRS
? S390_FPR_SIZE
: 4;
56 s390x_register_raw_size (int reg_nr
)
58 return (reg_nr
== S390_FPC_REGNUM
)
59 || (reg_nr
>= S390_FIRST_ACR
&& reg_nr
<= S390_LAST_ACR
) ? 4 : 8;
63 s390_cannot_fetch_register (int regno
)
65 return (regno
>= S390_FIRST_CR
&& regno
< (S390_FIRST_CR
+ 9)) ||
66 (regno
>= (S390_FIRST_CR
+ 12) && regno
<= S390_LAST_CR
);
70 s390_register_byte (int reg_nr
)
72 if (reg_nr
<= S390_GP_LAST_REGNUM
)
73 return reg_nr
* S390_GPR_SIZE
;
74 if (reg_nr
<= S390_LAST_ACR
)
75 return S390_ACR0_OFFSET
+ (((reg_nr
) - S390_FIRST_ACR
) * S390_ACR_SIZE
);
76 if (reg_nr
<= S390_LAST_CR
)
77 return S390_CR0_OFFSET
+ (((reg_nr
) - S390_FIRST_CR
) * S390_CR_SIZE
);
78 if (reg_nr
== S390_FPC_REGNUM
)
79 return S390_FPC_OFFSET
;
81 return S390_FP0_OFFSET
+ (((reg_nr
) - S390_FP0_REGNUM
) * S390_FPR_SIZE
);
85 #define S390_MAX_INSTR_SIZE (6)
86 #define S390_SYSCALL_OPCODE (0x0a)
87 #define S390_SYSCALL_SIZE (2)
88 #define S390_SIGCONTEXT_SREGS_OFFSET (8)
89 #define S390X_SIGCONTEXT_SREGS_OFFSET (8)
90 #define S390_SIGREGS_FP0_OFFSET (144)
91 #define S390X_SIGREGS_FP0_OFFSET (216)
92 #define S390_UC_MCONTEXT_OFFSET (256)
93 #define S390X_UC_MCONTEXT_OFFSET (344)
94 #define S390_STACK_FRAME_OVERHEAD (GDB_TARGET_IS_ESAME ? 160:96)
95 #define S390_SIGNAL_FRAMESIZE (GDB_TARGET_IS_ESAME ? 160:96)
96 #define s390_NR_sigreturn 119
97 #define s390_NR_rt_sigreturn 173
101 struct frame_extra_info
105 CORE_ADDR function_start
;
106 CORE_ADDR skip_prologue_function_start
;
107 CORE_ADDR saved_pc_valid
;
109 CORE_ADDR sig_fixed_saved_pc_valid
;
110 CORE_ADDR sig_fixed_saved_pc
;
111 CORE_ADDR frame_pointer_saved_pc
; /* frame pointer needed for alloca */
112 CORE_ADDR stack_bought
; /* amount we decrement the stack pointer by */
113 CORE_ADDR sigcontext
;
117 static CORE_ADDR
s390_frame_saved_pc_nofix (struct frame_info
*fi
);
120 s390_readinstruction (bfd_byte instr
[], CORE_ADDR at
,
121 struct disassemble_info
*info
)
125 static int s390_instrlen
[] = {
131 if ((*info
->read_memory_func
) (at
, &instr
[0], 2, info
))
133 instrlen
= s390_instrlen
[instr
[0] >> 6];
134 if ((*info
->read_memory_func
) (at
+ 2, &instr
[2], instrlen
- 2, info
))
140 s390_memset_extra_info (struct frame_extra_info
*fextra_info
)
142 memset (fextra_info
, 0, sizeof (struct frame_extra_info
));
148 s390_register_name (int reg_nr
)
150 static char *register_names
[] = {
152 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
153 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
154 "acr0", "acr1", "acr2", "acr3", "acr4", "acr5", "acr6", "acr7",
155 "acr8", "acr9", "acr10", "acr11", "acr12", "acr13", "acr14", "acr15",
156 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
157 "cr8", "cr9", "cr10", "cr11", "cr12", "cr13", "cr14", "cr15",
159 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
160 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15"
163 if (reg_nr
>= S390_LAST_REGNUM
)
165 return register_names
[reg_nr
];
172 s390_stab_reg_to_regnum (int regno
)
174 return regno
>= 64 ? S390_PSWM_REGNUM
- 64 :
175 regno
>= 48 ? S390_FIRST_ACR
- 48 :
176 regno
>= 32 ? S390_FIRST_CR
- 32 :
177 regno
<= 15 ? (regno
+ 2) :
178 S390_FP0_REGNUM
+ ((regno
- 16) & 8) + (((regno
- 16) & 3) << 1) +
179 (((regno
- 16) & 4) >> 2);
184 /* s390_get_frame_info based on Hartmuts
185 prologue definition in
186 gcc-2.8.1/config/l390/linux.c
188 It reads one instruction at a time & based on whether
189 it looks like prologue code or not it makes a decision on
190 whether the prologue is over, there are various state machines
191 in the code to determine if the prologue code is possilby valid.
193 This is done to hopefully allow the code survive minor revs of
199 s390_get_frame_info (CORE_ADDR pc
, struct frame_extra_info
*fextra_info
,
200 struct frame_info
*fi
, int init_extra_info
)
202 #define CONST_POOL_REGIDX 13
203 #define GOT_REGIDX 12
204 bfd_byte instr
[S390_MAX_INSTR_SIZE
];
205 CORE_ADDR test_pc
= pc
, test_pc2
;
206 CORE_ADDR orig_sp
= 0, save_reg_addr
= 0, *saved_regs
= NULL
;
207 int valid_prologue
, good_prologue
= 0;
208 int gprs_saved
[S390_NUM_GPRS
];
209 int fprs_saved
[S390_NUM_FPRS
];
210 int regidx
, instrlen
;
211 int save_link_regidx
, subtract_sp_regidx
;
212 int const_pool_state
, save_link_state
;
213 int frame_pointer_found
, varargs_state
;
214 int loop_cnt
, gdb_gpr_store
, gdb_fpr_store
;
215 int frame_pointer_regidx
= 0xf;
216 int offset
, expected_offset
;
218 disassemble_info info
;
220 /* What we've seen so far regarding r12 --- the GOT (Global Offset
221 Table) pointer. We expect to see `l %r12, N(%r13)', which loads
222 r12 with the offset from the constant pool to the GOT, and then
223 an `ar %r12, %r13', which adds the constant pool address,
224 yielding the GOT's address. Here's what got_state means:
226 1 -- seen `l %r12, N(%r13)', but no `ar'
227 2 -- seen load and add, so GOT pointer is totally initialized
228 When got_state is 1, then got_load_addr is the address of the
229 load instruction, and got_load_len is the length of that
232 CORE_ADDR got_load_addr
= 0, got_load_len
= 0;
234 const_pool_state
= save_link_state
= got_state
= varargs_state
= 0;
235 frame_pointer_found
= 0;
236 memset (gprs_saved
, 0, sizeof (gprs_saved
));
237 memset (fprs_saved
, 0, sizeof (fprs_saved
));
238 info
.read_memory_func
= dis_asm_read_memory
;
240 save_link_regidx
= subtract_sp_regidx
= 0;
245 orig_sp
= fi
->frame
+ fextra_info
->stack_bought
;
246 saved_regs
= fi
->saved_regs
;
248 if (init_extra_info
|| !fextra_info
->initialised
)
250 s390_memset_extra_info (fextra_info
);
251 fextra_info
->function_start
= pc
;
252 fextra_info
->initialised
= 1;
260 /* add the previous instruction len */
261 instrlen
= s390_readinstruction (instr
, test_pc
, &info
);
268 /* We probably are in a glibc syscall */
269 if (instr
[0] == S390_SYSCALL_OPCODE
&& test_pc
== pc
)
272 if (saved_regs
&& fextra_info
&& fi
->next
&& fi
->next
->extra_info
273 && fi
->next
->extra_info
->sigcontext
)
275 /* We are backtracing from a signal handler */
276 save_reg_addr
= fi
->next
->extra_info
->sigcontext
+
277 REGISTER_BYTE (S390_GP0_REGNUM
);
278 for (regidx
= 0; regidx
< S390_NUM_GPRS
; regidx
++)
280 saved_regs
[S390_GP0_REGNUM
+ regidx
] = save_reg_addr
;
281 save_reg_addr
+= S390_GPR_SIZE
;
283 save_reg_addr
= fi
->next
->extra_info
->sigcontext
+
284 (GDB_TARGET_IS_ESAME
? S390X_SIGREGS_FP0_OFFSET
:
285 S390_SIGREGS_FP0_OFFSET
);
286 for (regidx
= 0; regidx
< S390_NUM_FPRS
; regidx
++)
288 saved_regs
[S390_FP0_REGNUM
+ regidx
] = save_reg_addr
;
289 save_reg_addr
+= S390_FPR_SIZE
;
294 if (save_link_state
== 0)
296 /* check for a stack relative STMG or STM */
297 if (((GDB_TARGET_IS_ESAME
&&
298 ((instr
[0] == 0xeb) && (instr
[5] == 0x24))) ||
299 (instr
[0] == 0x90)) && ((instr
[2] >> 4) == 0xf))
301 regidx
= (instr
[1] >> 4);
304 offset
= ((instr
[2] & 0xf) << 8) + instr
[3];
306 S390_GPR6_STACK_OFFSET
+ (S390_GPR_SIZE
* (regidx
- 6));
307 if (offset
!= expected_offset
)
313 save_reg_addr
= orig_sp
+ offset
;
314 for (; regidx
<= (instr
[1] & 0xf); regidx
++)
316 if (gprs_saved
[regidx
])
322 gprs_saved
[regidx
] = 1;
325 saved_regs
[S390_GP0_REGNUM
+ regidx
] = save_reg_addr
;
326 save_reg_addr
+= S390_GPR_SIZE
;
333 /* check for a stack relative STG or ST */
334 if ((save_link_state
== 0 || save_link_state
== 3) &&
335 ((GDB_TARGET_IS_ESAME
&&
336 ((instr
[0] == 0xe3) && (instr
[5] == 0x24))) ||
337 (instr
[0] == 0x50)) && ((instr
[2] >> 4) == 0xf))
339 regidx
= instr
[1] >> 4;
340 offset
= ((instr
[2] & 0xf) << 8) + instr
[3];
343 if (save_link_state
== 3 && regidx
== save_link_regidx
)
355 S390_GPR6_STACK_OFFSET
+ (S390_GPR_SIZE
* (regidx
- 6));
356 if (offset
!= expected_offset
)
361 if (gprs_saved
[regidx
])
367 gprs_saved
[regidx
] = 1;
370 save_reg_addr
= orig_sp
+ offset
;
371 saved_regs
[S390_GP0_REGNUM
+ regidx
] = save_reg_addr
;
378 if (instr
[0] == 0x60 && (instr
[2] >> 4) == 0xf)
380 regidx
= instr
[1] >> 4;
381 if (regidx
== 0 || regidx
== 2)
383 if (fprs_saved
[regidx
])
388 fprs_saved
[regidx
] = 1;
391 save_reg_addr
= orig_sp
+ (((instr
[2] & 0xf) << 8) + instr
[3]);
392 saved_regs
[S390_FP0_REGNUM
+ regidx
] = save_reg_addr
;
399 if (const_pool_state
== 0)
402 if (GDB_TARGET_IS_ESAME
)
404 /* Check for larl CONST_POOL_REGIDX,offset on ESAME */
405 if ((instr
[0] == 0xc0)
406 && (instr
[1] == (CONST_POOL_REGIDX
<< 4)))
408 const_pool_state
= 2;
415 /* Check for BASR gpr13,gpr0 used to load constant pool pointer to r13 in old compiler */
416 if (instr
[0] == 0xd && (instr
[1] & 0xf) == 0
417 && ((instr
[1] >> 4) == CONST_POOL_REGIDX
))
419 const_pool_state
= 1;
424 /* Check for new fangled bras %r13,newpc to load new constant pool */
425 /* embedded in code, older pre abi compilers also emitted this stuff. */
426 if ((instr
[0] == 0xa7) && ((instr
[1] & 0xf) == 0x5) &&
427 ((instr
[1] >> 4) == CONST_POOL_REGIDX
)
428 && ((instr
[2] & 0x80) == 0))
430 const_pool_state
= 2;
432 (((((instr
[2] & 0xf) << 8) + instr
[3]) << 1) - instrlen
);
437 /* Check for AGHI or AHI CONST_POOL_REGIDX,val */
438 if (const_pool_state
== 1 && (instr
[0] == 0xa7) &&
439 ((GDB_TARGET_IS_ESAME
&&
440 (instr
[1] == ((CONST_POOL_REGIDX
<< 4) | 0xb))) ||
441 (instr
[1] == ((CONST_POOL_REGIDX
<< 4) | 0xa))))
443 const_pool_state
= 2;
447 /* Check for LGR or LR gprx,15 */
448 if ((GDB_TARGET_IS_ESAME
&&
449 instr
[0] == 0xb9 && instr
[1] == 0x04 && (instr
[3] & 0xf) == 0xf) ||
450 (instr
[0] == 0x18 && (instr
[1] & 0xf) == 0xf))
452 if (GDB_TARGET_IS_ESAME
)
453 regidx
= instr
[3] >> 4;
455 regidx
= instr
[1] >> 4;
456 if (save_link_state
== 0 && regidx
!= 0xb)
458 /* Almost defintely code for
459 decrementing the stack pointer
460 ( i.e. a non leaf function
461 or else leaf with locals ) */
462 save_link_regidx
= regidx
;
467 /* We use this frame pointer for alloca
468 unfortunately we need to assume its gpr11
469 otherwise we would need a smarter prologue
471 if (!frame_pointer_found
&& regidx
== 0xb)
473 frame_pointer_regidx
= 0xb;
474 frame_pointer_found
= 1;
476 fextra_info
->frame_pointer_saved_pc
= test_pc
;
481 /* Check for AHI or AGHI gpr15,val */
482 if (save_link_state
== 1 && (instr
[0] == 0xa7) &&
483 ((GDB_TARGET_IS_ESAME
&& (instr
[1] == 0xfb)) || (instr
[1] == 0xfa)))
486 fextra_info
->stack_bought
=
487 -extract_signed_integer (&instr
[2], 2);
492 /* Alternatively check for the complex construction for
493 buying more than 32k of stack
495 long vals %r15,0(%gprx) gprx currently r1 */
496 if ((save_link_state
== 1) && (instr
[0] == 0xa7)
497 && ((instr
[1] & 0xf) == 0x5) && (instr
[2] == 0)
498 && (instr
[3] == 0x4) && ((instr
[1] >> 4) != CONST_POOL_REGIDX
))
500 subtract_sp_regidx
= instr
[1] >> 4;
503 target_read_memory (test_pc
+ instrlen
,
504 (char *) &fextra_info
->stack_bought
,
505 sizeof (fextra_info
->stack_bought
));
510 if (save_link_state
== 2 && instr
[0] == 0x5b
511 && instr
[1] == 0xf0 &&
512 instr
[2] == (subtract_sp_regidx
<< 4) && instr
[3] == 0)
518 /* check for LA gprx,offset(15) used for varargs */
519 if ((instr
[0] == 0x41) && ((instr
[2] >> 4) == 0xf) &&
520 ((instr
[1] & 0xf) == 0))
522 /* some code uses gpr7 to point to outgoing args */
523 if (((instr
[1] >> 4) == 7) && (save_link_state
== 0) &&
524 ((instr
[2] & 0xf) == 0)
525 && (instr
[3] == S390_STACK_FRAME_OVERHEAD
))
530 if (varargs_state
== 1)
537 /* Check for a GOT load */
539 if (GDB_TARGET_IS_ESAME
)
541 /* Check for larl GOT_REGIDX, on ESAME */
542 if ((got_state
== 0) && (instr
[0] == 0xc0)
543 && (instr
[1] == (GOT_REGIDX
<< 4)))
552 /* check for l GOT_REGIDX,x(CONST_POOL_REGIDX) */
553 if (got_state
== 0 && const_pool_state
== 2 && instr
[0] == 0x58
554 && (instr
[2] == (CONST_POOL_REGIDX
<< 4))
555 && ((instr
[1] >> 4) == GOT_REGIDX
))
558 got_load_addr
= test_pc
;
559 got_load_len
= instrlen
;
563 /* Check for subsequent ar got_regidx,basr_regidx */
564 if (got_state
== 1 && instr
[0] == 0x1a &&
565 instr
[1] == ((GOT_REGIDX
<< 4) | CONST_POOL_REGIDX
))
573 while (valid_prologue
&& good_prologue
);
576 /* If this function doesn't reference the global offset table,
577 then the compiler may use r12 for other things. If the last
578 instruction we saw was a load of r12 from the constant pool,
579 with no subsequent add to make the address PC-relative, then
580 the load was probably a genuine body instruction; don't treat
581 it as part of the prologue. */
583 && got_load_addr
+ got_load_len
== test_pc
)
585 test_pc
= got_load_addr
;
586 instrlen
= got_load_len
;
589 good_prologue
= (((const_pool_state
== 0) || (const_pool_state
== 2)) &&
590 ((save_link_state
== 0) || (save_link_state
== 4)) &&
591 ((varargs_state
== 0) || (varargs_state
== 2)));
595 fextra_info
->good_prologue
= good_prologue
;
596 fextra_info
->skip_prologue_function_start
=
597 (good_prologue
? test_pc
: pc
);
600 /* The SP's element of the saved_regs array holds the old SP,
601 not the address at which it is saved. */
602 saved_regs
[S390_SP_REGNUM
] = orig_sp
;
608 s390_check_function_end (CORE_ADDR pc
)
610 bfd_byte instr
[S390_MAX_INSTR_SIZE
];
611 disassemble_info info
;
612 int regidx
, instrlen
;
614 info
.read_memory_func
= dis_asm_read_memory
;
615 instrlen
= s390_readinstruction (instr
, pc
, &info
);
619 if (instrlen
!= 2 || instr
[0] != 07 || (instr
[1] >> 4) != 0xf)
621 regidx
= instr
[1] & 0xf;
622 /* Check for LMG or LG */
624 s390_readinstruction (instr
, pc
- (GDB_TARGET_IS_ESAME
? 6 : 4), &info
);
627 if (GDB_TARGET_IS_ESAME
)
630 if (instrlen
!= 6 || instr
[0] != 0xeb || instr
[5] != 0x4)
633 else if (instrlen
!= 4 || instr
[0] != 0x98)
637 if ((instr
[2] >> 4) != 0xf)
641 instrlen
= s390_readinstruction (instr
, pc
- (GDB_TARGET_IS_ESAME
? 12 : 8),
645 if (GDB_TARGET_IS_ESAME
)
648 if (instrlen
!= 6 || instr
[0] != 0xe3 || instr
[5] != 0x4)
654 if (instrlen
!= 4 || instr
[0] != 0x58)
657 if (instr
[2] >> 4 != 0xf)
659 if (instr
[1] >> 4 != regidx
)
665 s390_sniff_pc_function_start (CORE_ADDR pc
, struct frame_info
*fi
)
667 CORE_ADDR function_start
, test_function_start
;
668 int loop_cnt
, err
, function_end
;
669 struct frame_extra_info fextra_info
;
670 function_start
= get_pc_function_start (pc
);
672 if (function_start
== 0)
674 test_function_start
= pc
;
675 if (test_function_start
& 1)
676 return 0; /* This has to be bogus */
682 s390_get_frame_info (test_function_start
, &fextra_info
, fi
, 1);
684 test_function_start
-= 2;
685 function_end
= s390_check_function_end (test_function_start
);
687 while (!(function_end
== 1 || err
|| loop_cnt
>= 4096 ||
688 (fextra_info
.good_prologue
)));
689 if (fextra_info
.good_prologue
)
690 function_start
= fextra_info
.function_start
;
691 else if (function_end
== 1)
692 function_start
= test_function_start
;
694 return function_start
;
700 s390_function_start (struct frame_info
*fi
)
702 CORE_ADDR function_start
= 0;
704 if (fi
->extra_info
&& fi
->extra_info
->initialised
)
705 function_start
= fi
->extra_info
->function_start
;
707 function_start
= get_pc_function_start (fi
->pc
);
708 return function_start
;
715 s390_frameless_function_invocation (struct frame_info
*fi
)
717 struct frame_extra_info fextra_info
, *fextra_info_ptr
;
720 if (fi
->next
== NULL
) /* no may be frameless */
723 fextra_info_ptr
= fi
->extra_info
;
726 fextra_info_ptr
= &fextra_info
;
727 s390_get_frame_info (s390_sniff_pc_function_start (fi
->pc
, fi
),
728 fextra_info_ptr
, fi
, 1);
730 frameless
= ((fextra_info_ptr
->stack_bought
== 0));
738 s390_is_sigreturn (CORE_ADDR pc
, struct frame_info
*sighandler_fi
,
739 CORE_ADDR
*sregs
, CORE_ADDR
*sigcaller_pc
)
741 bfd_byte instr
[S390_MAX_INSTR_SIZE
];
742 disassemble_info info
;
747 CORE_ADDR temp_sregs
;
749 scontext
= temp_sregs
= 0;
751 info
.read_memory_func
= dis_asm_read_memory
;
752 instrlen
= s390_readinstruction (instr
, pc
, &info
);
755 if (((instrlen
== S390_SYSCALL_SIZE
) &&
756 (instr
[0] == S390_SYSCALL_OPCODE
)) &&
757 ((instr
[1] == s390_NR_sigreturn
) || (instr
[1] == s390_NR_rt_sigreturn
)))
761 if (s390_frameless_function_invocation (sighandler_fi
))
762 orig_sp
= sighandler_fi
->frame
;
764 orig_sp
= ADDR_BITS_REMOVE ((CORE_ADDR
)
765 read_memory_integer (sighandler_fi
->
768 if (orig_sp
&& sigcaller_pc
)
770 scontext
= orig_sp
+ S390_SIGNAL_FRAMESIZE
;
771 if (pc
== scontext
&& instr
[1] == s390_NR_rt_sigreturn
)
773 /* We got a new style rt_signal */
774 /* get address of read ucontext->uc_mcontext */
775 temp_sregs
= orig_sp
+ (GDB_TARGET_IS_ESAME
?
776 S390X_UC_MCONTEXT_OFFSET
:
777 S390_UC_MCONTEXT_OFFSET
);
781 /* read sigcontext->sregs */
782 temp_sregs
= ADDR_BITS_REMOVE ((CORE_ADDR
)
783 read_memory_integer (scontext
787 S390X_SIGCONTEXT_SREGS_OFFSET
789 S390_SIGCONTEXT_SREGS_OFFSET
),
793 /* read sigregs->psw.addr */
795 ADDR_BITS_REMOVE ((CORE_ADDR
)
796 read_memory_integer (temp_sregs
+
799 S390_PSW_ADDR_SIZE
));
810 We need to do something better here but this will keep us out of trouble
812 For some reason the blockframe.c calls us with fi->next->fromleaf
813 so this seems of little use to us. */
815 s390_init_frame_pc_first (int next_fromleaf
, struct frame_info
*fi
)
817 CORE_ADDR sigcaller_pc
;
822 fi
->pc
= ADDR_BITS_REMOVE (read_register (S390_RETADDR_REGNUM
));
823 /* fix signal handlers */
825 else if (fi
->next
&& fi
->next
->pc
)
826 fi
->pc
= s390_frame_saved_pc_nofix (fi
->next
);
827 if (fi
->pc
&& fi
->next
&& fi
->next
->frame
&&
828 s390_is_sigreturn (fi
->pc
, fi
->next
, NULL
, &sigcaller_pc
))
830 fi
->pc
= sigcaller_pc
;
836 s390_init_extra_frame_info (int fromleaf
, struct frame_info
*fi
)
838 fi
->extra_info
= frame_obstack_alloc (sizeof (struct frame_extra_info
));
840 s390_get_frame_info (s390_sniff_pc_function_start (fi
->pc
, fi
),
841 fi
->extra_info
, fi
, 1);
843 s390_memset_extra_info (fi
->extra_info
);
846 /* If saved registers of frame FI are not known yet, read and cache them.
847 &FEXTRA_INFOP contains struct frame_extra_info; TDATAP can be NULL,
848 in which case the framedata are read. */
851 s390_frame_init_saved_regs (struct frame_info
*fi
)
856 if (fi
->saved_regs
== NULL
)
858 /* zalloc memsets the saved regs */
859 frame_saved_regs_zalloc (fi
);
862 quick
= (fi
->extra_info
&& fi
->extra_info
->initialised
863 && fi
->extra_info
->good_prologue
);
864 s390_get_frame_info (quick
? fi
->extra_info
->function_start
:
865 s390_sniff_pc_function_start (fi
->pc
, fi
),
866 fi
->extra_info
, fi
, !quick
);
874 s390_frame_args_address (struct frame_info
*fi
)
877 /* Apparently gdb already knows gdb_args_offset itself */
883 s390_frame_saved_pc_nofix (struct frame_info
*fi
)
885 if (fi
->extra_info
&& fi
->extra_info
->saved_pc_valid
)
886 return fi
->extra_info
->saved_pc
;
888 if (generic_find_dummy_frame (fi
->pc
, fi
->frame
))
889 return generic_read_register_dummy (fi
->pc
, fi
->frame
, S390_PC_REGNUM
);
891 s390_frame_init_saved_regs (fi
);
894 fi
->extra_info
->saved_pc_valid
= 1;
895 if (fi
->extra_info
->good_prologue
)
897 if (fi
->saved_regs
[S390_RETADDR_REGNUM
])
899 return (fi
->extra_info
->saved_pc
=
900 ADDR_BITS_REMOVE (read_memory_integer
901 (fi
->saved_regs
[S390_RETADDR_REGNUM
],
910 s390_frame_saved_pc (struct frame_info
*fi
)
912 CORE_ADDR saved_pc
= 0, sig_pc
;
914 if (fi
->extra_info
&& fi
->extra_info
->sig_fixed_saved_pc_valid
)
915 return fi
->extra_info
->sig_fixed_saved_pc
;
916 saved_pc
= s390_frame_saved_pc_nofix (fi
);
920 fi
->extra_info
->sig_fixed_saved_pc_valid
= 1;
923 if (s390_is_sigreturn (saved_pc
, fi
, NULL
, &sig_pc
))
926 fi
->extra_info
->sig_fixed_saved_pc
= saved_pc
;
934 /* We want backtraces out of signal handlers so we don't
935 set thisframe->signal_handler_caller to 1 */
938 s390_frame_chain (struct frame_info
*thisframe
)
940 CORE_ADDR prev_fp
= 0;
942 if (thisframe
->prev
&& thisframe
->prev
->frame
)
943 prev_fp
= thisframe
->prev
->frame
;
944 else if (generic_find_dummy_frame (thisframe
->pc
, thisframe
->frame
))
945 return generic_read_register_dummy (thisframe
->pc
, thisframe
->frame
,
951 struct frame_extra_info prev_fextra_info
;
953 memset (&prev_fextra_info
, 0, sizeof (prev_fextra_info
));
956 CORE_ADDR saved_pc
, sig_pc
;
958 saved_pc
= s390_frame_saved_pc_nofix (thisframe
);
962 s390_is_sigreturn (saved_pc
, thisframe
, &sregs
, &sig_pc
)))
964 s390_get_frame_info (s390_sniff_pc_function_start
965 (saved_pc
, NULL
), &prev_fextra_info
, NULL
,
971 /* read sigregs,regs.gprs[11 or 15] */
972 prev_fp
= read_memory_integer (sregs
+
973 REGISTER_BYTE (S390_GP0_REGNUM
+
975 frame_pointer_saved_pc
978 thisframe
->extra_info
->sigcontext
= sregs
;
982 if (thisframe
->saved_regs
)
986 if (prev_fextra_info
.frame_pointer_saved_pc
987 && thisframe
->saved_regs
[S390_FRAME_REGNUM
])
988 regno
= S390_FRAME_REGNUM
;
990 regno
= S390_SP_REGNUM
;
992 if (thisframe
->saved_regs
[regno
])
994 /* The SP's entry of `saved_regs' is special. */
995 if (regno
== S390_SP_REGNUM
)
996 prev_fp
= thisframe
->saved_regs
[regno
];
999 read_memory_integer (thisframe
->saved_regs
[regno
],
1005 return ADDR_BITS_REMOVE (prev_fp
);
1009 Whether struct frame_extra_info is actually needed I'll have to figure
1010 out as our frames are similar to rs6000 there is a possibility
1011 i386 dosen't need it. */
1015 /* a given return value in `regbuf' with a type `valtype', extract and copy its
1016 value into `valbuf' */
1018 s390_extract_return_value (struct type
*valtype
, char *regbuf
, char *valbuf
)
1020 /* floats and doubles are returned in fpr0. fpr's have a size of 8 bytes.
1021 We need to truncate the return value into float size (4 byte) if
1023 int len
= TYPE_LENGTH (valtype
);
1025 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
1026 memcpy (valbuf
, ®buf
[REGISTER_BYTE (S390_FP0_REGNUM
)], len
);
1030 /* return value is copied starting from r2. */
1031 if (TYPE_LENGTH (valtype
) < S390_GPR_SIZE
)
1032 offset
= S390_GPR_SIZE
- TYPE_LENGTH (valtype
);
1034 regbuf
+ REGISTER_BYTE (S390_GP0_REGNUM
+ 2) + offset
,
1035 TYPE_LENGTH (valtype
));
1041 s390_promote_integer_argument (struct type
*valtype
, char *valbuf
,
1042 char *reg_buff
, int *arglen
)
1044 char *value
= valbuf
;
1045 int len
= TYPE_LENGTH (valtype
);
1047 if (len
< S390_GPR_SIZE
)
1049 /* We need to upgrade this value to a register to pass it correctly */
1050 int idx
, diff
= S390_GPR_SIZE
- len
, negative
=
1051 (!TYPE_UNSIGNED (valtype
) && value
[0] & 0x80);
1052 for (idx
= 0; idx
< S390_GPR_SIZE
; idx
++)
1054 reg_buff
[idx
] = (idx
< diff
? (negative
? 0xff : 0x0) :
1058 *arglen
= S390_GPR_SIZE
;
1062 if (len
& (S390_GPR_SIZE
- 1))
1064 fprintf_unfiltered (gdb_stderr
,
1065 "s390_promote_integer_argument detected an argument not "
1066 "a multiple of S390_GPR_SIZE & greater than S390_GPR_SIZE "
1067 "we might not deal with this correctly.\n");
1076 s390_store_return_value (struct type
*valtype
, char *valbuf
)
1079 char *reg_buff
= alloca (max (S390_FPR_SIZE
, REGISTER_SIZE
)), *value
;
1081 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
1083 DOUBLEST tempfloat
= extract_floating (valbuf
, TYPE_LENGTH (valtype
));
1085 floatformat_from_doublest (&floatformat_ieee_double_big
, &tempfloat
,
1087 write_register_bytes (REGISTER_BYTE (S390_FP0_REGNUM
), reg_buff
,
1093 s390_promote_integer_argument (valtype
, valbuf
, reg_buff
, &arglen
);
1094 /* Everything else is returned in GPR2 and up. */
1095 write_register_bytes (REGISTER_BYTE (S390_GP0_REGNUM
+ 2), value
,
1100 gdb_print_insn_s390 (bfd_vma memaddr
, disassemble_info
* info
)
1102 bfd_byte instrbuff
[S390_MAX_INSTR_SIZE
];
1105 instrlen
= s390_readinstruction (instrbuff
, (CORE_ADDR
) memaddr
, info
);
1108 (*info
->memory_error_func
) (instrlen
, memaddr
, info
);
1111 for (cnt
= 0; cnt
< instrlen
; cnt
++)
1112 info
->fprintf_func (info
->stream
, "%02X ", instrbuff
[cnt
]);
1113 for (cnt
= instrlen
; cnt
< S390_MAX_INSTR_SIZE
; cnt
++)
1114 info
->fprintf_func (info
->stream
, " ");
1115 instrlen
= print_insn_s390 (memaddr
, info
);
1121 /* Not the most efficent code in the world */
1125 int regno
= S390_SP_REGNUM
;
1126 struct frame_extra_info fextra_info
;
1128 CORE_ADDR pc
= ADDR_BITS_REMOVE (read_register (S390_PC_REGNUM
));
1130 s390_get_frame_info (s390_sniff_pc_function_start (pc
, NULL
), &fextra_info
,
1132 if (fextra_info
.frame_pointer_saved_pc
)
1133 regno
= S390_FRAME_REGNUM
;
1140 return read_register (s390_fp_regnum ());
1145 s390_write_fp (CORE_ADDR val
)
1147 write_register (s390_fp_regnum (), val
);
1152 s390_pop_frame_regular (struct frame_info
*frame
)
1156 write_register (S390_PC_REGNUM
, FRAME_SAVED_PC (frame
));
1158 /* Restore any saved registers. */
1159 for (regnum
= 0; regnum
< NUM_REGS
; regnum
++)
1160 if (frame
->saved_regs
[regnum
] != 0)
1164 value
= read_memory_unsigned_integer (frame
->saved_regs
[regnum
],
1165 REGISTER_RAW_SIZE (regnum
));
1166 write_register (regnum
, value
);
1169 /* Actually cut back the stack. Remember that the SP's element of
1170 saved_regs is the old SP itself, not the address at which it is
1172 write_register (S390_SP_REGNUM
, frame
->saved_regs
[S390_SP_REGNUM
]);
1174 /* Throw away any cached frame information. */
1175 flush_cached_frames ();
1179 /* Destroy the innermost (Top-Of-Stack) stack frame, restoring the
1180 machine state that was in effect before the frame was created.
1181 Used in the contexts of the "return" command, and of
1182 target function calls from the debugger. */
1186 /* This function checks for and handles generic dummy frames, and
1187 calls back to our function for ordinary frames. */
1188 generic_pop_current_frame (s390_pop_frame_regular
);
1192 /* Return non-zero if TYPE is an integer-like type, zero otherwise.
1193 "Integer-like" types are those that should be passed the way
1194 integers are: integers, enums, ranges, characters, and booleans. */
1196 is_integer_like (struct type
*type
)
1198 enum type_code code
= TYPE_CODE (type
);
1200 return (code
== TYPE_CODE_INT
1201 || code
== TYPE_CODE_ENUM
1202 || code
== TYPE_CODE_RANGE
1203 || code
== TYPE_CODE_CHAR
1204 || code
== TYPE_CODE_BOOL
);
1208 /* Return non-zero if TYPE is a pointer-like type, zero otherwise.
1209 "Pointer-like" types are those that should be passed the way
1210 pointers are: pointers and references. */
1212 is_pointer_like (struct type
*type
)
1214 enum type_code code
= TYPE_CODE (type
);
1216 return (code
== TYPE_CODE_PTR
1217 || code
== TYPE_CODE_REF
);
1221 /* Return non-zero if TYPE is a `float singleton' or `double
1222 singleton', zero otherwise.
1224 A `T singleton' is a struct type with one member, whose type is
1225 either T or a `T singleton'. So, the following are all float
1229 struct { struct { float x; } x; };
1230 struct { struct { struct { float x; } x; } x; };
1234 WHY THE HECK DO WE CARE ABOUT THIS??? Well, it turns out that GCC
1235 passes all float singletons and double singletons as if they were
1236 simply floats or doubles. This is *not* what the ABI says it
1239 is_float_singleton (struct type
*type
)
1241 return (TYPE_CODE (type
) == TYPE_CODE_STRUCT
1242 && TYPE_NFIELDS (type
) == 1
1243 && (TYPE_CODE (TYPE_FIELD_TYPE (type
, 0)) == TYPE_CODE_FLT
1244 || is_float_singleton (TYPE_FIELD_TYPE (type
, 0))));
1248 /* Return non-zero if TYPE is a struct-like type, zero otherwise.
1249 "Struct-like" types are those that should be passed as structs are:
1252 As an odd quirk, not mentioned in the ABI, GCC passes float and
1253 double singletons as if they were a plain float, double, etc. (The
1254 corresponding union types are handled normally.) So we exclude
1255 those types here. *shrug* */
1257 is_struct_like (struct type
*type
)
1259 enum type_code code
= TYPE_CODE (type
);
1261 return (code
== TYPE_CODE_UNION
1262 || (code
== TYPE_CODE_STRUCT
&& ! is_float_singleton (type
)));
1266 /* Return non-zero if TYPE is a float-like type, zero otherwise.
1267 "Float-like" types are those that should be passed as
1268 floating-point values are.
1270 You'd think this would just be floats, doubles, long doubles, etc.
1271 But as an odd quirk, not mentioned in the ABI, GCC passes float and
1272 double singletons as if they were a plain float, double, etc. (The
1273 corresponding union types are handled normally.) So we exclude
1274 those types here. *shrug* */
1276 is_float_like (struct type
*type
)
1278 return (TYPE_CODE (type
) == TYPE_CODE_FLT
1279 || is_float_singleton (type
));
1283 /* Return non-zero if TYPE is considered a `DOUBLE_OR_FLOAT', as
1284 defined by the parameter passing conventions described in the
1285 "Linux for S/390 ELF Application Binary Interface Supplement".
1286 Otherwise, return zero. */
1288 is_double_or_float (struct type
*type
)
1290 return (is_float_like (type
)
1291 && (TYPE_LENGTH (type
) == 4
1292 || TYPE_LENGTH (type
) == 8));
1296 /* Return non-zero if TYPE is considered a `SIMPLE_ARG', as defined by
1297 the parameter passing conventions described in the "Linux for S/390
1298 ELF Application Binary Interface Supplement". Return zero otherwise. */
1300 is_simple_arg (struct type
*type
)
1302 unsigned length
= TYPE_LENGTH (type
);
1304 /* This is almost a direct translation of the ABI's language, except
1305 that we have to exclude 8-byte structs; those are DOUBLE_ARGs. */
1306 return ((is_integer_like (type
) && length
<= 4)
1307 || is_pointer_like (type
)
1308 || (is_struct_like (type
) && length
!= 8)
1309 || (is_float_like (type
) && length
== 16));
1313 /* Return non-zero if TYPE should be passed as a pointer to a copy,
1314 zero otherwise. TYPE must be a SIMPLE_ARG, as recognized by
1317 pass_by_copy_ref (struct type
*type
)
1319 unsigned length
= TYPE_LENGTH (type
);
1321 return ((is_struct_like (type
) && length
!= 1 && length
!= 2 && length
!= 4)
1322 || (is_float_like (type
) && length
== 16));
1326 /* Return ARG, a `SIMPLE_ARG', sign-extended or zero-extended to a full
1327 word as required for the ABI. */
1329 extend_simple_arg (struct value
*arg
)
1331 struct type
*type
= VALUE_TYPE (arg
);
1333 /* Even structs get passed in the least significant bits of the
1334 register / memory word. It's not really right to extract them as
1335 an integer, but it does take care of the extension. */
1336 if (TYPE_UNSIGNED (type
))
1337 return extract_unsigned_integer (VALUE_CONTENTS (arg
),
1338 TYPE_LENGTH (type
));
1340 return extract_signed_integer (VALUE_CONTENTS (arg
),
1341 TYPE_LENGTH (type
));
1345 /* Return non-zero if TYPE is a `DOUBLE_ARG', as defined by the
1346 parameter passing conventions described in the "Linux for S/390 ELF
1347 Application Binary Interface Supplement". Return zero otherwise. */
1349 is_double_arg (struct type
*type
)
1351 unsigned length
= TYPE_LENGTH (type
);
1353 return ((is_integer_like (type
)
1354 || is_struct_like (type
))
1359 /* Round ADDR up to the next N-byte boundary. N must be a power of
1362 round_up (CORE_ADDR addr
, int n
)
1364 /* Check that N is really a power of two. */
1365 gdb_assert (n
&& (n
& (n
-1)) == 0);
1366 return ((addr
+ n
- 1) & -n
);
1370 /* Round ADDR down to the next N-byte boundary. N must be a power of
1373 round_down (CORE_ADDR addr
, int n
)
1375 /* Check that N is really a power of two. */
1376 gdb_assert (n
&& (n
& (n
-1)) == 0);
1381 /* Return the alignment required by TYPE. */
1383 alignment_of (struct type
*type
)
1387 if (is_integer_like (type
)
1388 || is_pointer_like (type
)
1389 || TYPE_CODE (type
) == TYPE_CODE_FLT
)
1390 alignment
= TYPE_LENGTH (type
);
1391 else if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
1392 || TYPE_CODE (type
) == TYPE_CODE_UNION
)
1397 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1399 int field_alignment
= alignment_of (TYPE_FIELD_TYPE (type
, i
));
1401 if (field_alignment
> alignment
)
1402 alignment
= field_alignment
;
1408 /* Check that everything we ever return is a power of two. Lots of
1409 code doesn't want to deal with aligning things to arbitrary
1411 gdb_assert ((alignment
& (alignment
- 1)) == 0);
1417 /* Put the actual parameter values pointed to by ARGS[0..NARGS-1] in
1418 place to be passed to a function, as specified by the "Linux for
1419 S/390 ELF Application Binary Interface Supplement".
1421 SP is the current stack pointer. We must put arguments, links,
1422 padding, etc. whereever they belong, and return the new stack
1425 If STRUCT_RETURN is non-zero, then the function we're calling is
1426 going to return a structure by value; STRUCT_ADDR is the address of
1427 a block we've allocated for it on the stack.
1429 Our caller has taken care of any type promotions needed to satisfy
1430 prototypes or the old K&R argument-passing rules. */
1432 s390_push_arguments (int nargs
, struct value
**args
, CORE_ADDR sp
,
1433 int struct_return
, CORE_ADDR struct_addr
)
1436 int pointer_size
= (TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
1438 /* The number of arguments passed by reference-to-copy. */
1441 /* If the i'th argument is passed as a reference to a copy, then
1442 copy_addr[i] is the address of the copy we made. */
1443 CORE_ADDR
*copy_addr
= alloca (nargs
* sizeof (CORE_ADDR
));
1445 /* Build the reference-to-copy area. */
1447 for (i
= 0; i
< nargs
; i
++)
1449 struct value
*arg
= args
[i
];
1450 struct type
*type
= VALUE_TYPE (arg
);
1451 unsigned length
= TYPE_LENGTH (type
);
1453 if (is_simple_arg (type
)
1454 && pass_by_copy_ref (type
))
1457 sp
= round_down (sp
, alignment_of (type
));
1458 write_memory (sp
, VALUE_CONTENTS (arg
), length
);
1464 /* Reserve space for the parameter area. As a conservative
1465 simplification, we assume that everything will be passed on the
1470 for (i
= 0; i
< nargs
; i
++)
1472 struct value
*arg
= args
[i
];
1473 struct type
*type
= VALUE_TYPE (arg
);
1474 int length
= TYPE_LENGTH (type
);
1476 sp
= round_down (sp
, alignment_of (type
));
1478 /* SIMPLE_ARG values get extended to 32 bits. Assume every
1480 if (length
< 4) length
= 4;
1485 /* Include space for any reference-to-copy pointers. */
1486 sp
= round_down (sp
, pointer_size
);
1487 sp
-= num_copies
* pointer_size
;
1489 /* After all that, make sure it's still aligned on an eight-byte
1491 sp
= round_down (sp
, 8);
1493 /* Finally, place the actual parameters, working from SP towards
1494 higher addresses. The code above is supposed to reserve enough
1499 CORE_ADDR starg
= sp
;
1501 for (i
= 0; i
< nargs
; i
++)
1503 struct value
*arg
= args
[i
];
1504 struct type
*type
= VALUE_TYPE (arg
);
1506 if (is_double_or_float (type
)
1509 /* When we store a single-precision value in an FP register,
1510 it occupies the leftmost bits. */
1511 write_register_bytes (REGISTER_BYTE (S390_FP0_REGNUM
+ fr
),
1512 VALUE_CONTENTS (arg
),
1513 TYPE_LENGTH (type
));
1516 else if (is_simple_arg (type
)
1519 /* Do we need to pass a pointer to our copy of this
1521 if (pass_by_copy_ref (type
))
1522 write_register (S390_GP0_REGNUM
+ gr
, copy_addr
[i
]);
1524 write_register (S390_GP0_REGNUM
+ gr
, extend_simple_arg (arg
));
1528 else if (is_double_arg (type
)
1531 write_register_gen (S390_GP0_REGNUM
+ gr
,
1532 VALUE_CONTENTS (arg
));
1533 write_register_gen (S390_GP0_REGNUM
+ gr
+ 1,
1534 VALUE_CONTENTS (arg
) + 4);
1539 /* The `OTHER' case. */
1540 enum type_code code
= TYPE_CODE (type
);
1541 unsigned length
= TYPE_LENGTH (type
);
1543 /* If we skipped r6 because we couldn't fit a DOUBLE_ARG
1544 in it, then don't go back and use it again later. */
1545 if (is_double_arg (type
) && gr
== 6)
1548 if (is_simple_arg (type
))
1550 /* Simple args are always either extended to 32 bits,
1552 starg
= round_up (starg
, 4);
1554 /* Do we need to pass a pointer to our copy of this
1556 if (pass_by_copy_ref (type
))
1557 write_memory_signed_integer (starg
, pointer_size
,
1560 /* Simple args are always extended to 32 bits. */
1561 write_memory_signed_integer (starg
, 4,
1562 extend_simple_arg (arg
));
1567 /* You'd think we should say:
1568 starg = round_up (starg, alignment_of (type));
1569 Unfortunately, GCC seems to simply align the stack on
1570 a four-byte boundary, even when passing doubles. */
1571 starg
= round_up (starg
, 4);
1572 write_memory (starg
, VALUE_CONTENTS (arg
), length
);
1579 /* Allocate the standard frame areas: the register save area, the
1580 word reserved for the compiler (which seems kind of meaningless),
1581 and the back chain pointer. */
1584 /* Write the back chain pointer into the first word of the stack
1585 frame. This will help us get backtraces from within functions
1587 write_memory_unsigned_integer (sp
, (TARGET_PTR_BIT
/ TARGET_CHAR_BIT
),
1593 /* Return the GDB type object for the "standard" data type
1594 of data in register N. */
1596 s390_register_virtual_type (int regno
)
1598 return ((unsigned) regno
- S390_FPC_REGNUM
) <
1599 S390_NUM_FPRS
? builtin_type_double
: builtin_type_int
;
1604 s390x_register_virtual_type (int regno
)
1606 return (regno
== S390_FPC_REGNUM
) ||
1607 (regno
>= S390_FIRST_ACR
&& regno
<= S390_LAST_ACR
) ? builtin_type_int
:
1608 (regno
>= S390_FP0_REGNUM
) ? builtin_type_double
: builtin_type_long
;
1614 s390_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
)
1616 write_register (S390_GP0_REGNUM
+ 2, addr
);
1621 static unsigned char *
1622 s390_breakpoint_from_pc (CORE_ADDR
*pcptr
, int *lenptr
)
1624 static unsigned char breakpoint
[] = { 0x0, 0x1 };
1626 *lenptr
= sizeof (breakpoint
);
1630 /* Advance PC across any function entry prologue instructions to reach some
1633 s390_skip_prologue (CORE_ADDR pc
)
1635 struct frame_extra_info fextra_info
;
1637 s390_get_frame_info (pc
, &fextra_info
, NULL
, 1);
1638 return fextra_info
.skip_prologue_function_start
;
1641 /* Immediately after a function call, return the saved pc.
1642 Can't go through the frames for this because on some machines
1643 the new frame is not set up until the new function executes
1644 some instructions. */
1646 s390_saved_pc_after_call (struct frame_info
*frame
)
1648 return ADDR_BITS_REMOVE (read_register (S390_RETADDR_REGNUM
));
1652 s390_addr_bits_remove (CORE_ADDR addr
)
1654 return (addr
) & 0x7fffffff;
1659 s390_push_return_address (CORE_ADDR pc
, CORE_ADDR sp
)
1661 write_register (S390_RETADDR_REGNUM
, CALL_DUMMY_ADDRESS ());
1666 s390_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1668 static LONGEST s390_call_dummy_words
[] = { 0 };
1669 struct gdbarch
*gdbarch
;
1670 struct gdbarch_tdep
*tdep
;
1673 /* First see if there is already a gdbarch that can satisfy the request. */
1674 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1676 return arches
->gdbarch
;
1678 /* None found: is the request for a s390 architecture? */
1679 if (info
.bfd_arch_info
->arch
!= bfd_arch_s390
)
1680 return NULL
; /* No; then it's not for us. */
1682 /* Yes: create a new gdbarch for the specified machine type. */
1683 gdbarch
= gdbarch_alloc (&info
, NULL
);
1685 set_gdbarch_believe_pcc_promotion (gdbarch
, 0);
1687 set_gdbarch_frame_args_skip (gdbarch
, 0);
1688 set_gdbarch_frame_args_address (gdbarch
, s390_frame_args_address
);
1689 set_gdbarch_frame_chain (gdbarch
, s390_frame_chain
);
1690 set_gdbarch_frame_init_saved_regs (gdbarch
, s390_frame_init_saved_regs
);
1691 set_gdbarch_frame_locals_address (gdbarch
, s390_frame_args_address
);
1692 /* We can't do this */
1693 set_gdbarch_frame_num_args (gdbarch
, frame_num_args_unknown
);
1694 set_gdbarch_store_struct_return (gdbarch
, s390_store_struct_return
);
1695 set_gdbarch_extract_return_value (gdbarch
, s390_extract_return_value
);
1696 set_gdbarch_store_return_value (gdbarch
, s390_store_return_value
);
1697 /* Amount PC must be decremented by after a breakpoint.
1698 This is often the number of bytes in BREAKPOINT
1700 set_gdbarch_decr_pc_after_break (gdbarch
, 2);
1701 set_gdbarch_pop_frame (gdbarch
, s390_pop_frame
);
1702 set_gdbarch_ieee_float (gdbarch
, 1);
1703 /* Stack grows downward. */
1704 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1705 /* Offset from address of function to start of its code.
1706 Zero on most machines. */
1707 set_gdbarch_function_start_offset (gdbarch
, 0);
1708 set_gdbarch_max_register_raw_size (gdbarch
, 8);
1709 set_gdbarch_max_register_virtual_size (gdbarch
, 8);
1710 set_gdbarch_breakpoint_from_pc (gdbarch
, s390_breakpoint_from_pc
);
1711 set_gdbarch_skip_prologue (gdbarch
, s390_skip_prologue
);
1712 set_gdbarch_init_extra_frame_info (gdbarch
, s390_init_extra_frame_info
);
1713 set_gdbarch_init_frame_pc_first (gdbarch
, s390_init_frame_pc_first
);
1714 set_gdbarch_read_fp (gdbarch
, s390_read_fp
);
1715 set_gdbarch_write_fp (gdbarch
, s390_write_fp
);
1716 /* This function that tells us whether the function invocation represented
1717 by FI does not have a frame on the stack associated with it. If it
1718 does not, FRAMELESS is set to 1, else 0. */
1719 set_gdbarch_frameless_function_invocation (gdbarch
,
1720 s390_frameless_function_invocation
);
1721 /* Return saved PC from a frame */
1722 set_gdbarch_frame_saved_pc (gdbarch
, s390_frame_saved_pc
);
1723 /* FRAME_CHAIN takes a frame's nominal address
1724 and produces the frame's chain-pointer. */
1725 set_gdbarch_frame_chain (gdbarch
, s390_frame_chain
);
1726 set_gdbarch_saved_pc_after_call (gdbarch
, s390_saved_pc_after_call
);
1727 set_gdbarch_register_byte (gdbarch
, s390_register_byte
);
1728 set_gdbarch_pc_regnum (gdbarch
, S390_PC_REGNUM
);
1729 set_gdbarch_sp_regnum (gdbarch
, S390_SP_REGNUM
);
1730 set_gdbarch_fp_regnum (gdbarch
, S390_FP_REGNUM
);
1731 set_gdbarch_fp0_regnum (gdbarch
, S390_FP0_REGNUM
);
1732 set_gdbarch_num_regs (gdbarch
, S390_NUM_REGS
);
1733 set_gdbarch_cannot_fetch_register (gdbarch
, s390_cannot_fetch_register
);
1734 set_gdbarch_cannot_store_register (gdbarch
, s390_cannot_fetch_register
);
1735 set_gdbarch_get_saved_register (gdbarch
, generic_get_saved_register
);
1736 set_gdbarch_use_struct_convention (gdbarch
, generic_use_struct_convention
);
1737 set_gdbarch_frame_chain_valid (gdbarch
, func_frame_chain_valid
);
1738 set_gdbarch_register_name (gdbarch
, s390_register_name
);
1739 set_gdbarch_stab_reg_to_regnum (gdbarch
, s390_stab_reg_to_regnum
);
1740 set_gdbarch_dwarf_reg_to_regnum (gdbarch
, s390_stab_reg_to_regnum
);
1741 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, s390_stab_reg_to_regnum
);
1743 /* Parameters for inferior function calls. */
1744 set_gdbarch_call_dummy_p (gdbarch
, 1);
1745 set_gdbarch_use_generic_dummy_frames (gdbarch
, 1);
1746 set_gdbarch_call_dummy_length (gdbarch
, 0);
1747 set_gdbarch_call_dummy_location (gdbarch
, AT_ENTRY_POINT
);
1748 set_gdbarch_call_dummy_address (gdbarch
, entry_point_address
);
1749 set_gdbarch_call_dummy_start_offset (gdbarch
, 0);
1750 set_gdbarch_pc_in_call_dummy (gdbarch
, pc_in_call_dummy_at_entry_point
);
1751 set_gdbarch_push_dummy_frame (gdbarch
, generic_push_dummy_frame
);
1752 set_gdbarch_push_arguments (gdbarch
, s390_push_arguments
);
1753 set_gdbarch_save_dummy_frame_tos (gdbarch
, generic_save_dummy_frame_tos
);
1754 set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch
, 1);
1755 set_gdbarch_call_dummy_breakpoint_offset (gdbarch
, 0);
1756 set_gdbarch_call_dummy_stack_adjust_p (gdbarch
, 0);
1757 set_gdbarch_extract_struct_value_address (gdbarch
, 0);
1758 set_gdbarch_fix_call_dummy (gdbarch
, generic_fix_call_dummy
);
1759 set_gdbarch_push_return_address (gdbarch
, s390_push_return_address
);
1760 set_gdbarch_sizeof_call_dummy_words (gdbarch
,
1761 sizeof (s390_call_dummy_words
));
1762 set_gdbarch_call_dummy_words (gdbarch
, s390_call_dummy_words
);
1763 set_gdbarch_coerce_float_to_double (gdbarch
,
1764 standard_coerce_float_to_double
);
1766 switch (info
.bfd_arch_info
->mach
)
1768 case bfd_mach_s390_esa
:
1769 set_gdbarch_register_size (gdbarch
, 4);
1770 set_gdbarch_register_raw_size (gdbarch
, s390_register_raw_size
);
1771 set_gdbarch_register_virtual_size (gdbarch
, s390_register_raw_size
);
1772 set_gdbarch_register_virtual_type (gdbarch
, s390_register_virtual_type
);
1774 set_gdbarch_addr_bits_remove (gdbarch
, s390_addr_bits_remove
);
1775 set_gdbarch_register_bytes (gdbarch
, S390_REGISTER_BYTES
);
1777 case bfd_mach_s390_esame
:
1778 set_gdbarch_register_size (gdbarch
, 8);
1779 set_gdbarch_register_raw_size (gdbarch
, s390x_register_raw_size
);
1780 set_gdbarch_register_virtual_size (gdbarch
, s390x_register_raw_size
);
1781 set_gdbarch_register_virtual_type (gdbarch
,
1782 s390x_register_virtual_type
);
1784 set_gdbarch_long_bit (gdbarch
, 64);
1785 set_gdbarch_long_long_bit (gdbarch
, 64);
1786 set_gdbarch_ptr_bit (gdbarch
, 64);
1787 set_gdbarch_register_bytes (gdbarch
, S390X_REGISTER_BYTES
);
1797 _initialize_s390_tdep ()
1800 /* Hook us into the gdbarch mechanism. */
1801 register_gdbarch_init (bfd_arch_s390
, s390_gdbarch_init
);
1802 if (!tm_print_insn
) /* Someone may have already set it */
1803 tm_print_insn
= gdb_print_insn_s390
;
1806 #endif /* GDBSERVER */