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"
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 "gpr0", "gpr1", "gpr2", "gpr3", "gpr4", "gpr5", "gpr6", "gpr7",
153 "gpr8", "gpr9", "gpr10", "gpr11", "gpr12", "gpr13", "gpr14", "gpr15",
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 "fpr0", "fpr1", "fpr2", "fpr3", "fpr4", "fpr5", "fpr6", "fpr7",
160 "fpr8", "fpr9", "fpr10", "fpr11", "fpr12", "fpr13", "fpr14", "fpr15"
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
);
604 s390_check_function_end (CORE_ADDR pc
)
606 bfd_byte instr
[S390_MAX_INSTR_SIZE
];
607 disassemble_info info
;
608 int regidx
, instrlen
;
610 info
.read_memory_func
= dis_asm_read_memory
;
611 instrlen
= s390_readinstruction (instr
, pc
, &info
);
615 if (instrlen
!= 2 || instr
[0] != 07 || (instr
[1] >> 4) != 0xf)
617 regidx
= instr
[1] & 0xf;
618 /* Check for LMG or LG */
620 s390_readinstruction (instr
, pc
- (GDB_TARGET_IS_ESAME
? 6 : 4), &info
);
623 if (GDB_TARGET_IS_ESAME
)
626 if (instrlen
!= 6 || instr
[0] != 0xeb || instr
[5] != 0x4)
629 else if (instrlen
!= 4 || instr
[0] != 0x98)
633 if ((instr
[2] >> 4) != 0xf)
637 instrlen
= s390_readinstruction (instr
, pc
- (GDB_TARGET_IS_ESAME
? 12 : 8),
641 if (GDB_TARGET_IS_ESAME
)
644 if (instrlen
!= 6 || instr
[0] != 0xe3 || instr
[5] != 0x4)
650 if (instrlen
!= 4 || instr
[0] != 0x58)
653 if (instr
[2] >> 4 != 0xf)
655 if (instr
[1] >> 4 != regidx
)
661 s390_sniff_pc_function_start (CORE_ADDR pc
, struct frame_info
*fi
)
663 CORE_ADDR function_start
, test_function_start
;
664 int loop_cnt
, err
, function_end
;
665 struct frame_extra_info fextra_info
;
666 function_start
= get_pc_function_start (pc
);
668 if (function_start
== 0)
670 test_function_start
= pc
;
671 if (test_function_start
& 1)
672 return 0; /* This has to be bogus */
678 s390_get_frame_info (test_function_start
, &fextra_info
, fi
, 1);
680 test_function_start
-= 2;
681 function_end
= s390_check_function_end (test_function_start
);
683 while (!(function_end
== 1 || err
|| loop_cnt
>= 4096 ||
684 (fextra_info
.good_prologue
)));
685 if (fextra_info
.good_prologue
)
686 function_start
= fextra_info
.function_start
;
687 else if (function_end
== 1)
688 function_start
= test_function_start
;
690 return function_start
;
696 s390_function_start (struct frame_info
*fi
)
698 CORE_ADDR function_start
= 0;
700 if (fi
->extra_info
&& fi
->extra_info
->initialised
)
701 function_start
= fi
->extra_info
->function_start
;
703 function_start
= get_pc_function_start (fi
->pc
);
704 return function_start
;
711 s390_frameless_function_invocation (struct frame_info
*fi
)
713 struct frame_extra_info fextra_info
, *fextra_info_ptr
;
716 if (fi
->next
== NULL
) /* no may be frameless */
719 fextra_info_ptr
= fi
->extra_info
;
722 fextra_info_ptr
= &fextra_info
;
723 s390_get_frame_info (s390_sniff_pc_function_start (fi
->pc
, fi
),
724 fextra_info_ptr
, fi
, 1);
726 frameless
= ((fextra_info_ptr
->stack_bought
== 0));
734 s390_is_sigreturn (CORE_ADDR pc
, struct frame_info
*sighandler_fi
,
735 CORE_ADDR
*sregs
, CORE_ADDR
*sigcaller_pc
)
737 bfd_byte instr
[S390_MAX_INSTR_SIZE
];
738 disassemble_info info
;
743 CORE_ADDR temp_sregs
;
745 scontext
= temp_sregs
= 0;
747 info
.read_memory_func
= dis_asm_read_memory
;
748 instrlen
= s390_readinstruction (instr
, pc
, &info
);
751 if (((instrlen
== S390_SYSCALL_SIZE
) &&
752 (instr
[0] == S390_SYSCALL_OPCODE
)) &&
753 ((instr
[1] == s390_NR_sigreturn
) || (instr
[1] == s390_NR_rt_sigreturn
)))
757 if (s390_frameless_function_invocation (sighandler_fi
))
758 orig_sp
= sighandler_fi
->frame
;
760 orig_sp
= ADDR_BITS_REMOVE ((CORE_ADDR
)
761 read_memory_integer (sighandler_fi
->
764 if (orig_sp
&& sigcaller_pc
)
766 scontext
= orig_sp
+ S390_SIGNAL_FRAMESIZE
;
767 if (pc
== scontext
&& instr
[1] == s390_NR_rt_sigreturn
)
769 /* We got a new style rt_signal */
770 /* get address of read ucontext->uc_mcontext */
771 temp_sregs
= orig_sp
+ (GDB_TARGET_IS_ESAME
?
772 S390X_UC_MCONTEXT_OFFSET
:
773 S390_UC_MCONTEXT_OFFSET
);
777 /* read sigcontext->sregs */
778 temp_sregs
= ADDR_BITS_REMOVE ((CORE_ADDR
)
779 read_memory_integer (scontext
783 S390X_SIGCONTEXT_SREGS_OFFSET
785 S390_SIGCONTEXT_SREGS_OFFSET
),
789 /* read sigregs->psw.addr */
791 ADDR_BITS_REMOVE ((CORE_ADDR
)
792 read_memory_integer (temp_sregs
+
795 S390_PSW_ADDR_SIZE
));
806 We need to do something better here but this will keep us out of trouble
808 For some reason the blockframe.c calls us with fi->next->fromleaf
809 so this seems of little use to us. */
811 s390_init_frame_pc_first (int next_fromleaf
, struct frame_info
*fi
)
813 CORE_ADDR sigcaller_pc
;
818 fi
->pc
= ADDR_BITS_REMOVE (read_register (S390_RETADDR_REGNUM
));
819 /* fix signal handlers */
821 else if (fi
->next
&& fi
->next
->pc
)
822 fi
->pc
= s390_frame_saved_pc_nofix (fi
->next
);
823 if (fi
->pc
&& fi
->next
&& fi
->next
->frame
&&
824 s390_is_sigreturn (fi
->pc
, fi
->next
, NULL
, &sigcaller_pc
))
826 fi
->pc
= sigcaller_pc
;
832 s390_init_extra_frame_info (int fromleaf
, struct frame_info
*fi
)
834 fi
->extra_info
= frame_obstack_alloc (sizeof (struct frame_extra_info
));
836 s390_get_frame_info (s390_sniff_pc_function_start (fi
->pc
, fi
),
837 fi
->extra_info
, fi
, 1);
839 s390_memset_extra_info (fi
->extra_info
);
842 /* If saved registers of frame FI are not known yet, read and cache them.
843 &FEXTRA_INFOP contains struct frame_extra_info; TDATAP can be NULL,
844 in which case the framedata are read. */
847 s390_frame_init_saved_regs (struct frame_info
*fi
)
852 if (fi
->saved_regs
== NULL
)
854 /* zalloc memsets the saved regs */
855 frame_saved_regs_zalloc (fi
);
858 quick
= (fi
->extra_info
&& fi
->extra_info
->initialised
859 && fi
->extra_info
->good_prologue
);
860 s390_get_frame_info (quick
? fi
->extra_info
->function_start
:
861 s390_sniff_pc_function_start (fi
->pc
, fi
),
862 fi
->extra_info
, fi
, !quick
);
870 s390_frame_args_address (struct frame_info
*fi
)
873 /* Apparently gdb already knows gdb_args_offset itself */
879 s390_frame_saved_pc_nofix (struct frame_info
*fi
)
881 if (fi
->extra_info
&& fi
->extra_info
->saved_pc_valid
)
882 return fi
->extra_info
->saved_pc
;
883 s390_frame_init_saved_regs (fi
);
886 fi
->extra_info
->saved_pc_valid
= 1;
887 if (fi
->extra_info
->good_prologue
)
889 if (fi
->saved_regs
[S390_RETADDR_REGNUM
])
891 return (fi
->extra_info
->saved_pc
=
892 ADDR_BITS_REMOVE (read_memory_integer
893 (fi
->saved_regs
[S390_RETADDR_REGNUM
],
902 s390_frame_saved_pc (struct frame_info
*fi
)
904 CORE_ADDR saved_pc
= 0, sig_pc
;
906 if (fi
->extra_info
&& fi
->extra_info
->sig_fixed_saved_pc_valid
)
907 return fi
->extra_info
->sig_fixed_saved_pc
;
908 saved_pc
= s390_frame_saved_pc_nofix (fi
);
912 fi
->extra_info
->sig_fixed_saved_pc_valid
= 1;
915 if (s390_is_sigreturn (saved_pc
, fi
, NULL
, &sig_pc
))
918 fi
->extra_info
->sig_fixed_saved_pc
= saved_pc
;
926 /* We want backtraces out of signal handlers so we don't
927 set thisframe->signal_handler_caller to 1 */
930 s390_frame_chain (struct frame_info
*thisframe
)
932 CORE_ADDR prev_fp
= 0;
934 if (thisframe
->prev
&& thisframe
->prev
->frame
)
935 prev_fp
= thisframe
->prev
->frame
;
940 struct frame_extra_info prev_fextra_info
;
942 memset (&prev_fextra_info
, 0, sizeof (prev_fextra_info
));
945 CORE_ADDR saved_pc
, sig_pc
;
947 saved_pc
= s390_frame_saved_pc_nofix (thisframe
);
951 s390_is_sigreturn (saved_pc
, thisframe
, &sregs
, &sig_pc
)))
953 s390_get_frame_info (s390_sniff_pc_function_start
954 (saved_pc
, NULL
), &prev_fextra_info
, NULL
,
960 /* read sigregs,regs.gprs[11 or 15] */
961 prev_fp
= read_memory_integer (sregs
+
962 REGISTER_BYTE (S390_GP0_REGNUM
+
964 frame_pointer_saved_pc
967 thisframe
->extra_info
->sigcontext
= sregs
;
971 if (thisframe
->saved_regs
)
977 ((prev_fextra_info
.frame_pointer_saved_pc
979 saved_regs
[S390_FRAME_REGNUM
]) ? S390_FRAME_REGNUM
:
981 if (thisframe
->saved_regs
[regno
])
983 read_memory_integer (thisframe
->saved_regs
[regno
],
988 return ADDR_BITS_REMOVE (prev_fp
);
992 Whether struct frame_extra_info is actually needed I'll have to figure
993 out as our frames are similar to rs6000 there is a possibility
994 i386 dosen't need it. */
998 /* a given return value in `regbuf' with a type `valtype', extract and copy its
999 value into `valbuf' */
1001 s390_extract_return_value (struct type
*valtype
, char *regbuf
, char *valbuf
)
1003 /* floats and doubles are returned in fpr0. fpr's have a size of 8 bytes.
1004 We need to truncate the return value into float size (4 byte) if
1006 int len
= TYPE_LENGTH (valtype
);
1008 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
1010 if (len
> (TARGET_FLOAT_BIT
>> 3))
1011 memcpy (valbuf
, ®buf
[REGISTER_BYTE (S390_FP0_REGNUM
)], len
);
1017 floatformat_to_doublest (&floatformat_ieee_double_big
,
1018 ®buf
[REGISTER_BYTE (S390_FP0_REGNUM
)],
1020 store_floating (valbuf
, len
, val
);
1026 /* return value is copied starting from r2. */
1027 if (TYPE_LENGTH (valtype
) < S390_GPR_SIZE
)
1028 offset
= S390_GPR_SIZE
- TYPE_LENGTH (valtype
);
1030 regbuf
+ REGISTER_BYTE (S390_GP0_REGNUM
+ 2) + offset
,
1031 TYPE_LENGTH (valtype
));
1037 s390_promote_integer_argument (struct type
*valtype
, char *valbuf
,
1038 char *reg_buff
, int *arglen
)
1040 char *value
= valbuf
;
1041 int len
= TYPE_LENGTH (valtype
);
1043 if (len
< S390_GPR_SIZE
)
1045 /* We need to upgrade this value to a register to pass it correctly */
1046 int idx
, diff
= S390_GPR_SIZE
- len
, negative
=
1047 (!TYPE_UNSIGNED (valtype
) && value
[0] & 0x80);
1048 for (idx
= 0; idx
< S390_GPR_SIZE
; idx
++)
1050 reg_buff
[idx
] = (idx
< diff
? (negative
? 0xff : 0x0) :
1054 *arglen
= S390_GPR_SIZE
;
1058 if (len
& (S390_GPR_SIZE
- 1))
1060 fprintf_unfiltered (gdb_stderr
,
1061 "s390_promote_integer_argument detected an argument not "
1062 "a multiple of S390_GPR_SIZE & greater than S390_GPR_SIZE "
1063 "we might not deal with this correctly.\n");
1072 s390_store_return_value (struct type
*valtype
, char *valbuf
)
1075 char *reg_buff
= alloca (max (S390_FPR_SIZE
, REGISTER_SIZE
)), *value
;
1077 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
1079 DOUBLEST tempfloat
= extract_floating (valbuf
, TYPE_LENGTH (valtype
));
1081 floatformat_from_doublest (&floatformat_ieee_double_big
, &tempfloat
,
1083 write_register_bytes (REGISTER_BYTE (S390_FP0_REGNUM
), reg_buff
,
1089 s390_promote_integer_argument (valtype
, valbuf
, reg_buff
, &arglen
);
1090 /* Everything else is returned in GPR2 and up. */
1091 write_register_bytes (REGISTER_BYTE (S390_GP0_REGNUM
+ 2), value
,
1096 gdb_print_insn_s390 (bfd_vma memaddr
, disassemble_info
* info
)
1098 bfd_byte instrbuff
[S390_MAX_INSTR_SIZE
];
1101 instrlen
= s390_readinstruction (instrbuff
, (CORE_ADDR
) memaddr
, info
);
1104 (*info
->memory_error_func
) (instrlen
, memaddr
, info
);
1107 for (cnt
= 0; cnt
< instrlen
; cnt
++)
1108 info
->fprintf_func (info
->stream
, "%02X ", instrbuff
[cnt
]);
1109 for (cnt
= instrlen
; cnt
< S390_MAX_INSTR_SIZE
; cnt
++)
1110 info
->fprintf_func (info
->stream
, " ");
1111 instrlen
= print_insn_s390 (memaddr
, info
);
1117 /* Not the most efficent code in the world */
1121 int regno
= S390_SP_REGNUM
;
1122 struct frame_extra_info fextra_info
;
1124 CORE_ADDR pc
= ADDR_BITS_REMOVE (read_register (S390_PC_REGNUM
));
1126 s390_get_frame_info (s390_sniff_pc_function_start (pc
, NULL
), &fextra_info
,
1128 if (fextra_info
.frame_pointer_saved_pc
)
1129 regno
= S390_FRAME_REGNUM
;
1136 return read_register (s390_fp_regnum ());
1141 s390_write_fp (CORE_ADDR val
)
1143 write_register (s390_fp_regnum (), val
);
1148 s390_push_dummy_frame ()
1150 CORE_ADDR orig_sp
= read_register (S390_SP_REGNUM
), new_sp
;
1151 void *saved_regs
= alloca (REGISTER_BYTES
);
1153 new_sp
= (orig_sp
- (REGISTER_BYTES
+ S390_GPR_SIZE
));
1154 read_register_bytes (0, (char *) saved_regs
, REGISTER_BYTES
);
1155 /* Use saved copy instead of orig_sp as this will have the correct endianness */
1156 write_memory (new_sp
, (char *) saved_regs
+ REGISTER_BYTE (S390_SP_REGNUM
),
1158 write_memory (new_sp
+ S390_GPR_SIZE
, (char *) &saved_regs
, REGISTER_BYTES
);
1159 write_register (S390_SP_REGNUM
, new_sp
);
1162 /* pop the innermost frame, go back to the caller.
1163 Used in `call_function_by_hand' to remove an artificial stack
1168 CORE_ADDR new_sp
= read_register (S390_SP_REGNUM
), orig_sp
;
1169 void *saved_regs
= alloca (REGISTER_BYTES
);
1172 read_memory (new_sp
+ S390_GPR_SIZE
, (char *) saved_regs
, REGISTER_BYTES
);
1173 write_register_bytes (0, (char *) &saved_regs
, REGISTER_BYTES
);
1176 /* used by call function by hand
1177 struct_return indicates that this function returns a structure &
1178 therefore gpr2 stores a pointer to the structure to be returned as
1179 opposed to the first argument.
1180 Currently I haven't seen a TYPE_CODE_INT whose size wasn't 2^n or less
1181 than S390_GPR_SIZE this is good because I don't seem to have to worry
1182 about sign extending pushed arguments (i.e. a signed char currently
1183 comes into this code with a size of 4 ). */
1186 s390_push_arguments (int nargs
, struct value
**args
, CORE_ADDR sp
,
1187 int struct_return
, CORE_ADDR struct_addr
)
1189 int num_float_args
, num_gpr_args
, orig_num_gpr_args
, argno
;
1190 int second_pass
, len
, arglen
, gprs_required
;
1191 CORE_ADDR outgoing_args_ptr
, outgoing_args_space
;
1194 int max_num_gpr_args
= 5 - (struct_return
? 1 : 0);
1195 int arg0_regnum
= S390_GP0_REGNUM
+ 2 + (struct_return
? 1 : 0);
1196 char *reg_buff
= alloca (max (S390_FPR_SIZE
, REGISTER_SIZE
)), *value
;
1198 for (second_pass
= 0; second_pass
<= 1; second_pass
++)
1201 outgoing_args_ptr
= sp
+ S390_STACK_FRAME_OVERHEAD
;
1203 outgoing_args_ptr
= 0;
1206 for (argno
= 0; argno
< nargs
; argno
++)
1209 type
= check_typedef (VALUE_TYPE (arg
));
1210 len
= TYPE_LENGTH (type
);
1211 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
1213 int all_float_registers_used
=
1214 num_float_args
> (GDB_TARGET_IS_ESAME
? 3 : 1);
1218 DOUBLEST tempfloat
=
1219 extract_floating (VALUE_CONTENTS (arg
), len
);
1222 floatformat_from_doublest (all_float_registers_used
&&
1223 len
== (TARGET_FLOAT_BIT
>> 3)
1224 ? &floatformat_ieee_single_big
1225 : &floatformat_ieee_double_big
,
1226 &tempfloat
, reg_buff
);
1227 if (all_float_registers_used
)
1228 write_memory (outgoing_args_ptr
, reg_buff
, len
);
1230 write_register_bytes (REGISTER_BYTE ((S390_FP0_REGNUM
)
1234 reg_buff
, S390_FPR_SIZE
);
1236 if (all_float_registers_used
)
1237 outgoing_args_ptr
+= len
;
1242 gprs_required
= ((len
+ (S390_GPR_SIZE
- 1)) / S390_GPR_SIZE
);
1245 s390_promote_integer_argument (type
, VALUE_CONTENTS (arg
),
1248 orig_num_gpr_args
= num_gpr_args
;
1249 num_gpr_args
+= gprs_required
;
1250 if (num_gpr_args
> max_num_gpr_args
)
1253 write_memory (outgoing_args_ptr
, value
, arglen
);
1254 outgoing_args_ptr
+= arglen
;
1259 write_register_bytes (REGISTER_BYTE (arg0_regnum
)
1261 (orig_num_gpr_args
* S390_GPR_SIZE
),
1268 /* Write the back chain pointer into the first word of the
1269 stack frame. This will help us get backtraces from
1270 within functions called from GDB. */
1271 write_memory_unsigned_integer (sp
,
1272 (TARGET_PTR_BIT
/ TARGET_CHAR_BIT
),
1277 outgoing_args_space
= outgoing_args_ptr
;
1278 /* Align to 16 bytes because because I like alignment &
1279 some of the kernel code requires 8 byte stack alignment at least. */
1280 sp
= (sp
- (S390_STACK_FRAME_OVERHEAD
+ outgoing_args_ptr
)) & (-16);
1289 s390_fix_call_dummy (char *dummy
, CORE_ADDR pc
, CORE_ADDR fun
, int nargs
,
1290 struct value
**args
, struct type
*value_type
,
1293 store_unsigned_integer (dummy
+ 4, REGISTER_SIZE
, fun
);
1297 /* Return the GDB type object for the "standard" data type
1298 of data in register N. */
1300 s390_register_virtual_type (int regno
)
1302 return ((unsigned) regno
- S390_FPC_REGNUM
) <
1303 S390_NUM_FPRS
? builtin_type_double
: builtin_type_int
;
1308 s390x_register_virtual_type (int regno
)
1310 return (regno
== S390_FPC_REGNUM
) ||
1311 (regno
>= S390_FIRST_ACR
&& regno
<= S390_LAST_ACR
) ? builtin_type_int
:
1312 (regno
>= S390_FP0_REGNUM
) ? builtin_type_double
: builtin_type_long
;
1318 s390_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
)
1320 write_register (S390_GP0_REGNUM
+ 2, addr
);
1325 static unsigned char *
1326 s390_breakpoint_from_pc (CORE_ADDR
*pcptr
, int *lenptr
)
1328 static unsigned char breakpoint
[] = { 0x0, 0x1 };
1330 *lenptr
= sizeof (breakpoint
);
1334 /* Advance PC across any function entry prologue instructions to reach some
1337 s390_skip_prologue (CORE_ADDR pc
)
1339 struct frame_extra_info fextra_info
;
1341 s390_get_frame_info (pc
, &fextra_info
, NULL
, 1);
1342 return fextra_info
.skip_prologue_function_start
;
1345 /* pc_in_call_dummy_on stack may work for us must test this */
1347 s390_pc_in_call_dummy (CORE_ADDR pc
, CORE_ADDR sp
, CORE_ADDR frame_address
)
1349 return pc
> sp
&& pc
< (sp
+ 4096);
1352 /* Immediately after a function call, return the saved pc.
1353 Can't go through the frames for this because on some machines
1354 the new frame is not set up until the new function executes
1355 some instructions. */
1357 s390_saved_pc_after_call (struct frame_info
*frame
)
1359 return ADDR_BITS_REMOVE (read_register (S390_RETADDR_REGNUM
));
1363 s390_addr_bits_remove (CORE_ADDR addr
)
1365 return (addr
) & 0x7fffffff;
1370 s390_push_return_address (CORE_ADDR pc
, CORE_ADDR sp
)
1376 s390_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1379 /* instruction sequence for s390 call dummy is as follows
1380 bras %r1,.+8 ; 0xA7150004
1381 long basraddr ; 0x00000000
1382 l %r1,0(%r1) ; 0x58101000
1383 basr %r14,%r1 ; 0x0DE1
1384 breakpoint ; 0x0001 */
1385 static LONGEST s390_call_dummy_words
[] = { 0xA7150004, 0x00000000,
1386 0x58101000, 0x0DE10001
1388 /* instruction sequence for esame call dummy is as follows
1389 bras %r1,.+12 ; 0xA7150006
1390 long basraddr ; 0x0000000000000000
1391 lg %r1,0(%r1) ; 0xE31010000004
1392 basr %r14,%r1 ; 0x0DE1
1393 breakpoint ; 0x0001 */
1394 static LONGEST s390x_call_dummy_words
[] = { 0xA715000600000000,
1398 struct gdbarch
*gdbarch
;
1399 struct gdbarch_tdep
*tdep
;
1402 /* First see if there is already a gdbarch that can satisfy the request. */
1403 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1405 return arches
->gdbarch
;
1407 /* None found: is the request for a s390 architecture? */
1408 if (info
.bfd_arch_info
->arch
!= bfd_arch_s390
)
1409 return NULL
; /* No; then it's not for us. */
1411 /* Yes: create a new gdbarch for the specified machine type. */
1412 gdbarch
= gdbarch_alloc (&info
, NULL
);
1414 set_gdbarch_believe_pcc_promotion (gdbarch
, 0);
1416 /* We don't define set_gdbarch_call_dummy_breakpoint_offset
1417 as we already have a breakpoint inserted. */
1418 set_gdbarch_use_generic_dummy_frames (gdbarch
, 0);
1420 set_gdbarch_call_dummy_location (gdbarch
, ON_STACK
);
1421 set_gdbarch_call_dummy_start_offset (gdbarch
, 0);
1422 set_gdbarch_pc_in_call_dummy (gdbarch
, s390_pc_in_call_dummy
);
1423 set_gdbarch_frame_args_skip (gdbarch
, 0);
1424 set_gdbarch_frame_args_address (gdbarch
, s390_frame_args_address
);
1425 set_gdbarch_frame_chain (gdbarch
, s390_frame_chain
);
1426 set_gdbarch_frame_init_saved_regs (gdbarch
, s390_frame_init_saved_regs
);
1427 set_gdbarch_frame_locals_address (gdbarch
, s390_frame_args_address
);
1428 /* We can't do this */
1429 set_gdbarch_frame_num_args (gdbarch
, frame_num_args_unknown
);
1430 set_gdbarch_store_struct_return (gdbarch
, s390_store_struct_return
);
1431 set_gdbarch_extract_return_value (gdbarch
, s390_extract_return_value
);
1432 set_gdbarch_store_return_value (gdbarch
, s390_store_return_value
);
1433 /* Amount PC must be decremented by after a breakpoint.
1434 This is often the number of bytes in BREAKPOINT
1436 set_gdbarch_decr_pc_after_break (gdbarch
, 2);
1437 set_gdbarch_pop_frame (gdbarch
, s390_pop_frame
);
1438 set_gdbarch_push_dummy_frame (gdbarch
, s390_push_dummy_frame
);
1439 set_gdbarch_push_arguments (gdbarch
, s390_push_arguments
);
1440 set_gdbarch_ieee_float (gdbarch
, 1);
1441 /* Stack grows downward. */
1442 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1443 /* Offset from address of function to start of its code.
1444 Zero on most machines. */
1445 set_gdbarch_function_start_offset (gdbarch
, 0);
1446 set_gdbarch_max_register_raw_size (gdbarch
, 8);
1447 set_gdbarch_max_register_virtual_size (gdbarch
, 8);
1448 set_gdbarch_breakpoint_from_pc (gdbarch
, s390_breakpoint_from_pc
);
1449 set_gdbarch_skip_prologue (gdbarch
, s390_skip_prologue
);
1450 set_gdbarch_init_extra_frame_info (gdbarch
, s390_init_extra_frame_info
);
1451 set_gdbarch_init_frame_pc_first (gdbarch
, s390_init_frame_pc_first
);
1452 set_gdbarch_read_fp (gdbarch
, s390_read_fp
);
1453 set_gdbarch_write_fp (gdbarch
, s390_write_fp
);
1454 /* This function that tells us whether the function invocation represented
1455 by FI does not have a frame on the stack associated with it. If it
1456 does not, FRAMELESS is set to 1, else 0. */
1457 set_gdbarch_frameless_function_invocation (gdbarch
,
1458 s390_frameless_function_invocation
);
1459 /* Return saved PC from a frame */
1460 set_gdbarch_frame_saved_pc (gdbarch
, s390_frame_saved_pc
);
1461 /* FRAME_CHAIN takes a frame's nominal address
1462 and produces the frame's chain-pointer. */
1463 set_gdbarch_frame_chain (gdbarch
, s390_frame_chain
);
1464 set_gdbarch_saved_pc_after_call (gdbarch
, s390_saved_pc_after_call
);
1465 set_gdbarch_register_byte (gdbarch
, s390_register_byte
);
1466 set_gdbarch_pc_regnum (gdbarch
, S390_PC_REGNUM
);
1467 set_gdbarch_sp_regnum (gdbarch
, S390_SP_REGNUM
);
1468 set_gdbarch_fp_regnum (gdbarch
, S390_FP_REGNUM
);
1469 set_gdbarch_fp0_regnum (gdbarch
, S390_FP0_REGNUM
);
1470 set_gdbarch_num_regs (gdbarch
, S390_NUM_REGS
);
1471 set_gdbarch_cannot_fetch_register (gdbarch
, s390_cannot_fetch_register
);
1472 set_gdbarch_cannot_store_register (gdbarch
, s390_cannot_fetch_register
);
1473 set_gdbarch_get_saved_register (gdbarch
, generic_get_saved_register
);
1474 set_gdbarch_use_struct_convention (gdbarch
, generic_use_struct_convention
);
1475 set_gdbarch_frame_chain_valid (gdbarch
, func_frame_chain_valid
);
1476 set_gdbarch_register_name (gdbarch
, s390_register_name
);
1477 set_gdbarch_stab_reg_to_regnum (gdbarch
, s390_stab_reg_to_regnum
);
1478 set_gdbarch_dwarf_reg_to_regnum (gdbarch
, s390_stab_reg_to_regnum
);
1479 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, s390_stab_reg_to_regnum
);
1481 /* Stuff below here wouldn't be required if gdbarch.sh was a little */
1482 /* more intelligent */
1483 set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch
, 0);
1484 set_gdbarch_call_dummy_p (gdbarch
, 1);
1485 set_gdbarch_call_dummy_stack_adjust_p (gdbarch
, 0);
1486 set_gdbarch_extract_struct_value_address (gdbarch
, 0);
1487 set_gdbarch_fix_call_dummy (gdbarch
, s390_fix_call_dummy
);
1488 set_gdbarch_push_return_address (gdbarch
, s390_push_return_address
);
1490 switch (info
.bfd_arch_info
->mach
)
1492 case bfd_mach_s390_esa
:
1493 set_gdbarch_register_size (gdbarch
, 4);
1494 set_gdbarch_call_dummy_length (gdbarch
, 16);
1495 set_gdbarch_register_raw_size (gdbarch
, s390_register_raw_size
);
1496 set_gdbarch_register_virtual_size (gdbarch
, s390_register_raw_size
);
1497 set_gdbarch_register_virtual_type (gdbarch
, s390_register_virtual_type
);
1499 set_gdbarch_addr_bits_remove (gdbarch
, s390_addr_bits_remove
);
1501 set_gdbarch_sizeof_call_dummy_words (gdbarch
,
1502 sizeof (s390_call_dummy_words
));
1503 set_gdbarch_call_dummy_words (gdbarch
, s390_call_dummy_words
);
1504 set_gdbarch_register_bytes (gdbarch
, S390_REGISTER_BYTES
);
1506 case bfd_mach_s390_esame
:
1507 set_gdbarch_register_size (gdbarch
, 8);
1508 set_gdbarch_call_dummy_length (gdbarch
, 22);
1509 set_gdbarch_register_raw_size (gdbarch
, s390x_register_raw_size
);
1510 set_gdbarch_register_virtual_size (gdbarch
, s390x_register_raw_size
);
1511 set_gdbarch_register_virtual_type (gdbarch
,
1512 s390x_register_virtual_type
);
1514 set_gdbarch_long_bit (gdbarch
, 64);
1515 set_gdbarch_long_long_bit (gdbarch
, 64);
1516 set_gdbarch_ptr_bit (gdbarch
, 64);
1517 set_gdbarch_sizeof_call_dummy_words (gdbarch
,
1518 sizeof (s390x_call_dummy_words
));
1519 set_gdbarch_call_dummy_words (gdbarch
, s390x_call_dummy_words
);
1520 set_gdbarch_register_bytes (gdbarch
, S390X_REGISTER_BYTES
);
1530 _initialize_s390_tdep ()
1533 /* Hook us into the gdbarch mechanism. */
1534 register_gdbarch_init (bfd_arch_s390
, s390_gdbarch_init
);
1535 if (!tm_print_insn
) /* Someone may have already set it */
1536 tm_print_insn
= gdb_print_insn_s390
;
1539 #endif /* GDBSERVER */