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"
43 /* Number of bytes of storage in the actual machine representation
45 Note that the unsigned cast here forces the result of the
46 subtraction to very high positive values if N < S390_FP0_REGNUM */
48 s390_register_raw_size (int reg_nr
)
50 return ((unsigned) reg_nr
- S390_FP0_REGNUM
) <
51 S390_NUM_FPRS
? S390_FPR_SIZE
: 4;
55 s390x_register_raw_size (int reg_nr
)
57 return (reg_nr
== S390_FPC_REGNUM
)
58 || (reg_nr
>= S390_FIRST_ACR
&& reg_nr
<= S390_LAST_ACR
) ? 4 : 8;
62 s390_cannot_fetch_register (int regno
)
64 return (regno
>= S390_FIRST_CR
&& regno
< (S390_FIRST_CR
+ 9)) ||
65 (regno
>= (S390_FIRST_CR
+ 12) && regno
<= S390_LAST_CR
);
69 s390_register_byte (int reg_nr
)
71 if (reg_nr
<= S390_GP_LAST_REGNUM
)
72 return reg_nr
* S390_GPR_SIZE
;
73 if (reg_nr
<= S390_LAST_ACR
)
74 return S390_ACR0_OFFSET
+ (((reg_nr
) - S390_FIRST_ACR
) * S390_ACR_SIZE
);
75 if (reg_nr
<= S390_LAST_CR
)
76 return S390_CR0_OFFSET
+ (((reg_nr
) - S390_FIRST_CR
) * S390_CR_SIZE
);
77 if (reg_nr
== S390_FPC_REGNUM
)
78 return S390_FPC_OFFSET
;
80 return S390_FP0_OFFSET
+ (((reg_nr
) - S390_FP0_REGNUM
) * S390_FPR_SIZE
);
84 #define S390_MAX_INSTR_SIZE (6)
85 #define S390_SYSCALL_OPCODE (0x0a)
86 #define S390_SYSCALL_SIZE (2)
87 #define S390_SIGCONTEXT_SREGS_OFFSET (8)
88 #define S390X_SIGCONTEXT_SREGS_OFFSET (8)
89 #define S390_SIGREGS_FP0_OFFSET (144)
90 #define S390X_SIGREGS_FP0_OFFSET (216)
91 #define S390_UC_MCONTEXT_OFFSET (256)
92 #define S390X_UC_MCONTEXT_OFFSET (344)
93 #define S390_STACK_FRAME_OVERHEAD (GDB_TARGET_IS_ESAME ? 160:96)
94 #define S390_SIGNAL_FRAMESIZE (GDB_TARGET_IS_ESAME ? 160:96)
95 #define s390_NR_sigreturn 119
96 #define s390_NR_rt_sigreturn 173
100 struct frame_extra_info
104 CORE_ADDR function_start
;
105 CORE_ADDR skip_prologue_function_start
;
106 CORE_ADDR saved_pc_valid
;
108 CORE_ADDR sig_fixed_saved_pc_valid
;
109 CORE_ADDR sig_fixed_saved_pc
;
110 CORE_ADDR frame_pointer_saved_pc
; /* frame pointer needed for alloca */
111 CORE_ADDR stack_bought
; /* amount we decrement the stack pointer by */
112 CORE_ADDR sigcontext
;
116 static CORE_ADDR
s390_frame_saved_pc_nofix (struct frame_info
*fi
);
119 s390_readinstruction (bfd_byte instr
[], CORE_ADDR at
,
120 struct disassemble_info
*info
)
124 static int s390_instrlen
[] = {
130 if ((*info
->read_memory_func
) (at
, &instr
[0], 2, info
))
132 instrlen
= s390_instrlen
[instr
[0] >> 6];
133 if ((*info
->read_memory_func
) (at
+ 2, &instr
[2], instrlen
- 2, info
))
139 s390_memset_extra_info (struct frame_extra_info
*fextra_info
)
141 memset (fextra_info
, 0, sizeof (struct frame_extra_info
));
147 s390_register_name (int reg_nr
)
149 static char *register_names
[] = {
151 "gpr0", "gpr1", "gpr2", "gpr3", "gpr4", "gpr5", "gpr6", "gpr7",
152 "gpr8", "gpr9", "gpr10", "gpr11", "gpr12", "gpr13", "gpr14", "gpr15",
153 "acr0", "acr1", "acr2", "acr3", "acr4", "acr5", "acr6", "acr7",
154 "acr8", "acr9", "acr10", "acr11", "acr12", "acr13", "acr14", "acr15",
155 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
156 "cr8", "cr9", "cr10", "cr11", "cr12", "cr13", "cr14", "cr15",
158 "fpr0", "fpr1", "fpr2", "fpr3", "fpr4", "fpr5", "fpr6", "fpr7",
159 "fpr8", "fpr9", "fpr10", "fpr11", "fpr12", "fpr13", "fpr14", "fpr15"
162 if (reg_nr
>= S390_LAST_REGNUM
)
164 return register_names
[reg_nr
];
171 s390_stab_reg_to_regnum (int regno
)
173 return regno
>= 64 ? S390_PSWM_REGNUM
- 64 :
174 regno
>= 48 ? S390_FIRST_ACR
- 48 :
175 regno
>= 32 ? S390_FIRST_CR
- 32 :
176 regno
<= 15 ? (regno
+ 2) :
177 S390_FP0_REGNUM
+ ((regno
- 16) & 8) + (((regno
- 16) & 3) << 1) +
178 (((regno
- 16) & 4) >> 2);
183 /* s390_get_frame_info based on Hartmuts
184 prologue definition in
185 gcc-2.8.1/config/l390/linux.c
187 It reads one instruction at a time & based on whether
188 it looks like prologue code or not it makes a decision on
189 whether the prologue is over, there are various state machines
190 in the code to determine if the prologue code is possilby valid.
192 This is done to hopefully allow the code survive minor revs of
198 s390_get_frame_info (CORE_ADDR pc
, struct frame_extra_info
*fextra_info
,
199 struct frame_info
*fi
, int init_extra_info
)
201 #define CONST_POOL_REGIDX 13
202 #define GOT_REGIDX 12
203 bfd_byte instr
[S390_MAX_INSTR_SIZE
];
204 CORE_ADDR test_pc
= pc
, test_pc2
;
205 CORE_ADDR orig_sp
= 0, save_reg_addr
= 0, *saved_regs
= NULL
;
206 int valid_prologue
, good_prologue
= 0;
207 int gprs_saved
[S390_NUM_GPRS
];
208 int fprs_saved
[S390_NUM_FPRS
];
209 int regidx
, instrlen
;
210 int save_link_regidx
, subtract_sp_regidx
;
211 int const_pool_state
, save_link_state
, got_state
;
212 int frame_pointer_found
, varargs_state
;
213 int loop_cnt
, gdb_gpr_store
, gdb_fpr_store
;
214 int frame_pointer_regidx
= 0xf;
215 int offset
, expected_offset
;
217 disassemble_info info
;
218 const_pool_state
= save_link_state
= got_state
= varargs_state
= 0;
219 frame_pointer_found
= 0;
220 memset (gprs_saved
, 0, sizeof (gprs_saved
));
221 memset (fprs_saved
, 0, sizeof (fprs_saved
));
222 info
.read_memory_func
= dis_asm_read_memory
;
224 save_link_regidx
= subtract_sp_regidx
= 0;
229 orig_sp
= fi
->frame
+ fextra_info
->stack_bought
;
230 saved_regs
= fi
->saved_regs
;
232 if (init_extra_info
|| !fextra_info
->initialised
)
234 s390_memset_extra_info (fextra_info
);
235 fextra_info
->function_start
= pc
;
236 fextra_info
->initialised
= 1;
244 /* add the previous instruction len */
245 instrlen
= s390_readinstruction (instr
, test_pc
, &info
);
252 /* We probably are in a glibc syscall */
253 if (instr
[0] == S390_SYSCALL_OPCODE
&& test_pc
== pc
)
256 if (saved_regs
&& fextra_info
&& fi
->next
&& fi
->next
->extra_info
257 && fi
->next
->extra_info
->sigcontext
)
259 /* We are backtracing from a signal handler */
260 save_reg_addr
= fi
->next
->extra_info
->sigcontext
+
261 REGISTER_BYTE (S390_GP0_REGNUM
);
262 for (regidx
= 0; regidx
< S390_NUM_GPRS
; regidx
++)
264 saved_regs
[S390_GP0_REGNUM
+ regidx
] = save_reg_addr
;
265 save_reg_addr
+= S390_GPR_SIZE
;
267 save_reg_addr
= fi
->next
->extra_info
->sigcontext
+
268 (GDB_TARGET_IS_ESAME
? S390X_SIGREGS_FP0_OFFSET
:
269 S390_SIGREGS_FP0_OFFSET
);
270 for (regidx
= 0; regidx
< S390_NUM_FPRS
; regidx
++)
272 saved_regs
[S390_FP0_REGNUM
+ regidx
] = save_reg_addr
;
273 save_reg_addr
+= S390_FPR_SIZE
;
278 if (save_link_state
== 0)
280 /* check for a stack relative STMG or STM */
281 if (((GDB_TARGET_IS_ESAME
&&
282 ((instr
[0] == 0xeb) && (instr
[5] == 0x24))) ||
283 (instr
[0] == 0x90)) && ((instr
[2] >> 4) == 0xf))
285 regidx
= (instr
[1] >> 4);
288 offset
= ((instr
[2] & 0xf) << 8) + instr
[3];
290 S390_GPR6_STACK_OFFSET
+ (S390_GPR_SIZE
* (regidx
- 6));
291 if (offset
!= expected_offset
)
297 save_reg_addr
= orig_sp
+ offset
;
298 for (; regidx
<= (instr
[1] & 0xf); regidx
++)
300 if (gprs_saved
[regidx
])
306 gprs_saved
[regidx
] = 1;
309 saved_regs
[S390_GP0_REGNUM
+ regidx
] = save_reg_addr
;
310 save_reg_addr
+= S390_GPR_SIZE
;
317 /* check for a stack relative STG or ST */
318 if ((save_link_state
== 0 || save_link_state
== 3) &&
319 ((GDB_TARGET_IS_ESAME
&&
320 ((instr
[0] == 0xe3) && (instr
[5] == 0x24))) ||
321 (instr
[0] == 0x50)) && ((instr
[2] >> 4) == 0xf))
323 regidx
= instr
[1] >> 4;
324 offset
= ((instr
[2] & 0xf) << 8) + instr
[3];
327 if (save_link_state
== 3 && regidx
== save_link_regidx
)
339 S390_GPR6_STACK_OFFSET
+ (S390_GPR_SIZE
* (regidx
- 6));
340 if (offset
!= expected_offset
)
345 if (gprs_saved
[regidx
])
351 gprs_saved
[regidx
] = 1;
354 save_reg_addr
= orig_sp
+ offset
;
355 saved_regs
[S390_GP0_REGNUM
+ regidx
] = save_reg_addr
;
362 if (instr
[0] == 0x60 && (instr
[2] >> 4) == 0xf)
364 regidx
= instr
[1] >> 4;
365 if (regidx
== 0 || regidx
== 2)
367 if (fprs_saved
[regidx
])
372 fprs_saved
[regidx
] = 1;
375 save_reg_addr
= orig_sp
+ (((instr
[2] & 0xf) << 8) + instr
[3]);
376 saved_regs
[S390_FP0_REGNUM
+ regidx
] = save_reg_addr
;
383 if (const_pool_state
== 0)
386 if (GDB_TARGET_IS_ESAME
)
388 /* Check for larl CONST_POOL_REGIDX,offset on ESAME */
389 if ((instr
[0] == 0xc0)
390 && (instr
[1] == (CONST_POOL_REGIDX
<< 4)))
392 const_pool_state
= 2;
399 /* Check for BASR gpr13,gpr0 used to load constant pool pointer to r13 in old compiler */
400 if (instr
[0] == 0xd && (instr
[1] & 0xf) == 0
401 && ((instr
[1] >> 4) == CONST_POOL_REGIDX
))
403 const_pool_state
= 1;
408 /* Check for new fangled bras %r13,newpc to load new constant pool */
409 /* embedded in code, older pre abi compilers also emitted this stuff. */
410 if ((instr
[0] == 0xa7) && ((instr
[1] & 0xf) == 0x5) &&
411 ((instr
[1] >> 4) == CONST_POOL_REGIDX
)
412 && ((instr
[2] & 0x80) == 0))
414 const_pool_state
= 2;
416 (((((instr
[2] & 0xf) << 8) + instr
[3]) << 1) - instrlen
);
421 /* Check for AGHI or AHI CONST_POOL_REGIDX,val */
422 if (const_pool_state
== 1 && (instr
[0] == 0xa7) &&
423 ((GDB_TARGET_IS_ESAME
&&
424 (instr
[1] == ((CONST_POOL_REGIDX
<< 4) | 0xb))) ||
425 (instr
[1] == ((CONST_POOL_REGIDX
<< 4) | 0xa))))
427 const_pool_state
= 2;
431 /* Check for LGR or LR gprx,15 */
432 if ((GDB_TARGET_IS_ESAME
&&
433 instr
[0] == 0xb9 && instr
[1] == 0x04 && (instr
[3] & 0xf) == 0xf) ||
434 (instr
[0] == 0x18 && (instr
[1] & 0xf) == 0xf))
436 if (GDB_TARGET_IS_ESAME
)
437 regidx
= instr
[3] >> 4;
439 regidx
= instr
[1] >> 4;
440 if (save_link_state
== 0 && regidx
!= 0xb)
442 /* Almost defintely code for
443 decrementing the stack pointer
444 ( i.e. a non leaf function
445 or else leaf with locals ) */
446 save_link_regidx
= regidx
;
451 /* We use this frame pointer for alloca
452 unfortunately we need to assume its gpr11
453 otherwise we would need a smarter prologue
455 if (!frame_pointer_found
&& regidx
== 0xb)
457 frame_pointer_regidx
= 0xb;
458 frame_pointer_found
= 1;
460 fextra_info
->frame_pointer_saved_pc
= test_pc
;
465 /* Check for AHI or AGHI gpr15,val */
466 if (save_link_state
== 1 && (instr
[0] == 0xa7) &&
467 ((GDB_TARGET_IS_ESAME
&& (instr
[1] == 0xfb)) || (instr
[1] == 0xfa)))
470 fextra_info
->stack_bought
=
471 -extract_signed_integer (&instr
[2], 2);
476 /* Alternatively check for the complex construction for
477 buying more than 32k of stack
479 long vals %r15,0(%gprx) gprx currently r1 */
480 if ((save_link_state
== 1) && (instr
[0] == 0xa7)
481 && ((instr
[1] & 0xf) == 0x5) && (instr
[2] == 0)
482 && (instr
[3] == 0x4) && ((instr
[1] >> 4) != CONST_POOL_REGIDX
))
484 subtract_sp_regidx
= instr
[1] >> 4;
487 target_read_memory (test_pc
+ instrlen
,
488 (char *) &fextra_info
->stack_bought
,
489 sizeof (fextra_info
->stack_bought
));
494 if (save_link_state
== 2 && instr
[0] == 0x5b
495 && instr
[1] == 0xf0 &&
496 instr
[2] == (subtract_sp_regidx
<< 4) && instr
[3] == 0)
502 /* check for LA gprx,offset(15) used for varargs */
503 if ((instr
[0] == 0x41) && ((instr
[2] >> 4) == 0xf) &&
504 ((instr
[1] & 0xf) == 0))
506 /* some code uses gpr7 to point to outgoing args */
507 if (((instr
[1] >> 4) == 7) && (save_link_state
== 0) &&
508 ((instr
[2] & 0xf) == 0)
509 && (instr
[3] == S390_STACK_FRAME_OVERHEAD
))
514 if (varargs_state
== 1)
521 /* Check for a GOT load */
523 if (GDB_TARGET_IS_ESAME
)
525 /* Check for larl GOT_REGIDX, on ESAME */
526 if ((got_state
== 0) && (instr
[0] == 0xc0)
527 && (instr
[1] == (GOT_REGIDX
<< 4)))
536 /* check for l GOT_REGIDX,x(CONST_POOL_REGIDX) */
537 if (got_state
== 0 && const_pool_state
== 2 && instr
[0] == 0x58
538 && (instr
[2] == (CONST_POOL_REGIDX
<< 4))
539 && ((instr
[1] >> 4) == GOT_REGIDX
))
545 /* Check for subsequent ar got_regidx,basr_regidx */
546 if (got_state
== 1 && instr
[0] == 0x1a &&
547 instr
[1] == ((GOT_REGIDX
<< 4) | CONST_POOL_REGIDX
))
555 while (valid_prologue
&& good_prologue
);
558 good_prologue
= (((got_state
== 0) || (got_state
== 2)) &&
559 ((const_pool_state
== 0) || (const_pool_state
== 2)) &&
560 ((save_link_state
== 0) || (save_link_state
== 4)) &&
561 ((varargs_state
== 0) || (varargs_state
== 2)));
565 fextra_info
->good_prologue
= good_prologue
;
566 fextra_info
->skip_prologue_function_start
=
567 (good_prologue
? test_pc
: pc
);
574 s390_check_function_end (CORE_ADDR pc
)
576 bfd_byte instr
[S390_MAX_INSTR_SIZE
];
577 disassemble_info info
;
578 int regidx
, instrlen
;
580 info
.read_memory_func
= dis_asm_read_memory
;
581 instrlen
= s390_readinstruction (instr
, pc
, &info
);
585 if (instrlen
!= 2 || instr
[0] != 07 || (instr
[1] >> 4) != 0xf)
587 regidx
= instr
[1] & 0xf;
588 /* Check for LMG or LG */
590 s390_readinstruction (instr
, pc
- (GDB_TARGET_IS_ESAME
? 6 : 4), &info
);
593 if (GDB_TARGET_IS_ESAME
)
596 if (instrlen
!= 6 || instr
[0] != 0xeb || instr
[5] != 0x4)
599 else if (instrlen
!= 4 || instr
[0] != 0x98)
603 if ((instr
[2] >> 4) != 0xf)
607 instrlen
= s390_readinstruction (instr
, pc
- (GDB_TARGET_IS_ESAME
? 12 : 8),
611 if (GDB_TARGET_IS_ESAME
)
614 if (instrlen
!= 6 || instr
[0] != 0xe3 || instr
[5] != 0x4)
620 if (instrlen
!= 4 || instr
[0] != 0x58)
623 if (instr
[2] >> 4 != 0xf)
625 if (instr
[1] >> 4 != regidx
)
631 s390_sniff_pc_function_start (CORE_ADDR pc
, struct frame_info
*fi
)
633 CORE_ADDR function_start
, test_function_start
;
634 int loop_cnt
, err
, function_end
;
635 struct frame_extra_info fextra_info
;
636 function_start
= get_pc_function_start (pc
);
638 if (function_start
== 0)
640 test_function_start
= pc
;
641 if (test_function_start
& 1)
642 return 0; /* This has to be bogus */
648 s390_get_frame_info (test_function_start
, &fextra_info
, fi
, 1);
650 test_function_start
-= 2;
651 function_end
= s390_check_function_end (test_function_start
);
653 while (!(function_end
== 1 || err
|| loop_cnt
>= 4096 ||
654 (fextra_info
.good_prologue
)));
655 if (fextra_info
.good_prologue
)
656 function_start
= fextra_info
.function_start
;
657 else if (function_end
== 1)
658 function_start
= test_function_start
;
660 return function_start
;
666 s390_function_start (struct frame_info
*fi
)
668 CORE_ADDR function_start
= 0;
670 if (fi
->extra_info
&& fi
->extra_info
->initialised
)
671 function_start
= fi
->extra_info
->function_start
;
673 function_start
= get_pc_function_start (fi
->pc
);
674 return function_start
;
681 s390_frameless_function_invocation (struct frame_info
*fi
)
683 struct frame_extra_info fextra_info
, *fextra_info_ptr
;
686 if (fi
->next
== NULL
) /* no may be frameless */
689 fextra_info_ptr
= fi
->extra_info
;
692 fextra_info_ptr
= &fextra_info
;
693 s390_get_frame_info (s390_sniff_pc_function_start (fi
->pc
, fi
),
694 fextra_info_ptr
, fi
, 1);
696 frameless
= ((fextra_info_ptr
->stack_bought
== 0));
704 s390_is_sigreturn (CORE_ADDR pc
, struct frame_info
*sighandler_fi
,
705 CORE_ADDR
*sregs
, CORE_ADDR
*sigcaller_pc
)
707 bfd_byte instr
[S390_MAX_INSTR_SIZE
];
708 disassemble_info info
;
713 CORE_ADDR temp_sregs
;
715 scontext
= temp_sregs
= 0;
717 info
.read_memory_func
= dis_asm_read_memory
;
718 instrlen
= s390_readinstruction (instr
, pc
, &info
);
721 if (((instrlen
== S390_SYSCALL_SIZE
) &&
722 (instr
[0] == S390_SYSCALL_OPCODE
)) &&
723 ((instr
[1] == s390_NR_sigreturn
) || (instr
[1] == s390_NR_rt_sigreturn
)))
727 if (s390_frameless_function_invocation (sighandler_fi
))
728 orig_sp
= sighandler_fi
->frame
;
730 orig_sp
= ADDR_BITS_REMOVE ((CORE_ADDR
)
731 read_memory_integer (sighandler_fi
->
734 if (orig_sp
&& sigcaller_pc
)
736 scontext
= orig_sp
+ S390_SIGNAL_FRAMESIZE
;
737 if (pc
== scontext
&& instr
[1] == s390_NR_rt_sigreturn
)
739 /* We got a new style rt_signal */
740 /* get address of read ucontext->uc_mcontext */
741 temp_sregs
= orig_sp
+ (GDB_TARGET_IS_ESAME
?
742 S390X_UC_MCONTEXT_OFFSET
:
743 S390_UC_MCONTEXT_OFFSET
);
747 /* read sigcontext->sregs */
748 temp_sregs
= ADDR_BITS_REMOVE ((CORE_ADDR
)
749 read_memory_integer (scontext
753 S390X_SIGCONTEXT_SREGS_OFFSET
755 S390_SIGCONTEXT_SREGS_OFFSET
),
759 /* read sigregs->psw.addr */
761 ADDR_BITS_REMOVE ((CORE_ADDR
)
762 read_memory_integer (temp_sregs
+
765 S390_PSW_ADDR_SIZE
));
776 We need to do something better here but this will keep us out of trouble
778 For some reason the blockframe.c calls us with fi->next->fromleaf
779 so this seems of little use to us. */
781 s390_init_frame_pc_first (int next_fromleaf
, struct frame_info
*fi
)
783 CORE_ADDR sigcaller_pc
;
788 fi
->pc
= ADDR_BITS_REMOVE (read_register (S390_RETADDR_REGNUM
));
789 /* fix signal handlers */
791 else if (fi
->next
&& fi
->next
->pc
)
792 fi
->pc
= s390_frame_saved_pc_nofix (fi
->next
);
793 if (fi
->pc
&& fi
->next
&& fi
->next
->frame
&&
794 s390_is_sigreturn (fi
->pc
, fi
->next
, NULL
, &sigcaller_pc
))
796 fi
->pc
= sigcaller_pc
;
802 s390_init_extra_frame_info (int fromleaf
, struct frame_info
*fi
)
804 fi
->extra_info
= frame_obstack_alloc (sizeof (struct frame_extra_info
));
806 s390_get_frame_info (s390_sniff_pc_function_start (fi
->pc
, fi
),
807 fi
->extra_info
, fi
, 1);
809 s390_memset_extra_info (fi
->extra_info
);
812 /* If saved registers of frame FI are not known yet, read and cache them.
813 &FEXTRA_INFOP contains struct frame_extra_info; TDATAP can be NULL,
814 in which case the framedata are read. */
817 s390_frame_init_saved_regs (struct frame_info
*fi
)
822 if (fi
->saved_regs
== NULL
)
824 /* zalloc memsets the saved regs */
825 frame_saved_regs_zalloc (fi
);
828 quick
= (fi
->extra_info
&& fi
->extra_info
->initialised
829 && fi
->extra_info
->good_prologue
);
830 s390_get_frame_info (quick
? fi
->extra_info
->function_start
:
831 s390_sniff_pc_function_start (fi
->pc
, fi
),
832 fi
->extra_info
, fi
, !quick
);
840 s390_frame_args_address (struct frame_info
*fi
)
843 /* Apparently gdb already knows gdb_args_offset itself */
849 s390_frame_saved_pc_nofix (struct frame_info
*fi
)
851 if (fi
->extra_info
&& fi
->extra_info
->saved_pc_valid
)
852 return fi
->extra_info
->saved_pc
;
853 s390_frame_init_saved_regs (fi
);
856 fi
->extra_info
->saved_pc_valid
= 1;
857 if (fi
->extra_info
->good_prologue
)
859 if (fi
->saved_regs
[S390_RETADDR_REGNUM
])
861 return (fi
->extra_info
->saved_pc
=
862 ADDR_BITS_REMOVE (read_memory_integer
863 (fi
->saved_regs
[S390_RETADDR_REGNUM
],
872 s390_frame_saved_pc (struct frame_info
*fi
)
874 CORE_ADDR saved_pc
= 0, sig_pc
;
876 if (fi
->extra_info
&& fi
->extra_info
->sig_fixed_saved_pc_valid
)
877 return fi
->extra_info
->sig_fixed_saved_pc
;
878 saved_pc
= s390_frame_saved_pc_nofix (fi
);
882 fi
->extra_info
->sig_fixed_saved_pc_valid
= 1;
885 if (s390_is_sigreturn (saved_pc
, fi
, NULL
, &sig_pc
))
888 fi
->extra_info
->sig_fixed_saved_pc
= saved_pc
;
896 /* We want backtraces out of signal handlers so we don't
897 set thisframe->signal_handler_caller to 1 */
900 s390_frame_chain (struct frame_info
*thisframe
)
902 CORE_ADDR prev_fp
= 0;
904 if (thisframe
->prev
&& thisframe
->prev
->frame
)
905 prev_fp
= thisframe
->prev
->frame
;
910 struct frame_extra_info prev_fextra_info
;
912 memset (&prev_fextra_info
, 0, sizeof (prev_fextra_info
));
915 CORE_ADDR saved_pc
, sig_pc
;
917 saved_pc
= s390_frame_saved_pc_nofix (thisframe
);
921 s390_is_sigreturn (saved_pc
, thisframe
, &sregs
, &sig_pc
)))
923 s390_get_frame_info (s390_sniff_pc_function_start
924 (saved_pc
, NULL
), &prev_fextra_info
, NULL
,
930 /* read sigregs,regs.gprs[11 or 15] */
931 prev_fp
= read_memory_integer (sregs
+
932 REGISTER_BYTE (S390_GP0_REGNUM
+
934 frame_pointer_saved_pc
937 thisframe
->extra_info
->sigcontext
= sregs
;
941 if (thisframe
->saved_regs
)
947 ((prev_fextra_info
.frame_pointer_saved_pc
949 saved_regs
[S390_FRAME_REGNUM
]) ? S390_FRAME_REGNUM
:
951 if (thisframe
->saved_regs
[regno
])
953 read_memory_integer (thisframe
->saved_regs
[regno
],
958 return ADDR_BITS_REMOVE (prev_fp
);
962 Whether struct frame_extra_info is actually needed I'll have to figure
963 out as our frames are similar to rs6000 there is a possibility
964 i386 dosen't need it. */
968 /* a given return value in `regbuf' with a type `valtype', extract and copy its
969 value into `valbuf' */
971 s390_extract_return_value (struct type
*valtype
, char *regbuf
, char *valbuf
)
973 /* floats and doubles are returned in fpr0. fpr's have a size of 8 bytes.
974 We need to truncate the return value into float size (4 byte) if
976 int len
= TYPE_LENGTH (valtype
);
978 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
980 if (len
> (TARGET_FLOAT_BIT
>> 3))
981 memcpy (valbuf
, ®buf
[REGISTER_BYTE (S390_FP0_REGNUM
)], len
);
987 floatformat_to_doublest (&floatformat_ieee_double_big
,
988 ®buf
[REGISTER_BYTE (S390_FP0_REGNUM
)],
990 store_floating (valbuf
, len
, val
);
996 /* return value is copied starting from r2. */
997 if (TYPE_LENGTH (valtype
) < S390_GPR_SIZE
)
998 offset
= S390_GPR_SIZE
- TYPE_LENGTH (valtype
);
1000 regbuf
+ REGISTER_BYTE (S390_GP0_REGNUM
+ 2) + offset
,
1001 TYPE_LENGTH (valtype
));
1007 s390_promote_integer_argument (struct type
*valtype
, char *valbuf
,
1008 char *reg_buff
, int *arglen
)
1010 char *value
= valbuf
;
1011 int len
= TYPE_LENGTH (valtype
);
1013 if (len
< S390_GPR_SIZE
)
1015 /* We need to upgrade this value to a register to pass it correctly */
1016 int idx
, diff
= S390_GPR_SIZE
- len
, negative
=
1017 (!TYPE_UNSIGNED (valtype
) && value
[0] & 0x80);
1018 for (idx
= 0; idx
< S390_GPR_SIZE
; idx
++)
1020 reg_buff
[idx
] = (idx
< diff
? (negative
? 0xff : 0x0) :
1024 *arglen
= S390_GPR_SIZE
;
1028 if (len
& (S390_GPR_SIZE
- 1))
1030 fprintf_unfiltered (gdb_stderr
,
1031 "s390_promote_integer_argument detected an argument not "
1032 "a multiple of S390_GPR_SIZE & greater than S390_GPR_SIZE "
1033 "we might not deal with this correctly.\n");
1042 s390_store_return_value (struct type
*valtype
, char *valbuf
)
1045 char *reg_buff
= alloca (max (S390_FPR_SIZE
, REGISTER_SIZE
)), *value
;
1047 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
1049 DOUBLEST tempfloat
= extract_floating (valbuf
, TYPE_LENGTH (valtype
));
1051 floatformat_from_doublest (&floatformat_ieee_double_big
, &tempfloat
,
1053 write_register_bytes (REGISTER_BYTE (S390_FP0_REGNUM
), reg_buff
,
1059 s390_promote_integer_argument (valtype
, valbuf
, reg_buff
, &arglen
);
1060 /* Everything else is returned in GPR2 and up. */
1061 write_register_bytes (REGISTER_BYTE (S390_GP0_REGNUM
+ 2), value
,
1066 gdb_print_insn_s390 (bfd_vma memaddr
, disassemble_info
* info
)
1068 bfd_byte instrbuff
[S390_MAX_INSTR_SIZE
];
1071 instrlen
= s390_readinstruction (instrbuff
, (CORE_ADDR
) memaddr
, info
);
1074 (*info
->memory_error_func
) (instrlen
, memaddr
, info
);
1077 for (cnt
= 0; cnt
< instrlen
; cnt
++)
1078 info
->fprintf_func (info
->stream
, "%02X ", instrbuff
[cnt
]);
1079 for (cnt
= instrlen
; cnt
< S390_MAX_INSTR_SIZE
; cnt
++)
1080 info
->fprintf_func (info
->stream
, " ");
1081 instrlen
= print_insn_s390 (memaddr
, info
);
1087 /* Not the most efficent code in the world */
1091 int regno
= S390_SP_REGNUM
;
1092 struct frame_extra_info fextra_info
;
1094 CORE_ADDR pc
= ADDR_BITS_REMOVE (read_register (S390_PC_REGNUM
));
1096 s390_get_frame_info (s390_sniff_pc_function_start (pc
, NULL
), &fextra_info
,
1098 if (fextra_info
.frame_pointer_saved_pc
)
1099 regno
= S390_FRAME_REGNUM
;
1106 return read_register (s390_fp_regnum ());
1111 s390_write_fp (CORE_ADDR val
)
1113 write_register (s390_fp_regnum (), val
);
1118 s390_push_dummy_frame ()
1120 CORE_ADDR orig_sp
= read_register (S390_SP_REGNUM
), new_sp
;
1121 void *saved_regs
= alloca (REGISTER_BYTES
);
1123 new_sp
= (orig_sp
- (REGISTER_BYTES
+ S390_GPR_SIZE
));
1124 read_register_bytes (0, (char *) saved_regs
, REGISTER_BYTES
);
1125 /* Use saved copy instead of orig_sp as this will have the correct endianness */
1126 write_memory (new_sp
, (char *) saved_regs
+ REGISTER_BYTE (S390_SP_REGNUM
),
1128 write_memory (new_sp
+ S390_GPR_SIZE
, (char *) &saved_regs
, REGISTER_BYTES
);
1129 write_register (S390_SP_REGNUM
, new_sp
);
1132 /* pop the innermost frame, go back to the caller.
1133 Used in `call_function_by_hand' to remove an artificial stack
1138 CORE_ADDR new_sp
= read_register (S390_SP_REGNUM
), orig_sp
;
1139 void *saved_regs
= alloca (REGISTER_BYTES
);
1142 read_memory (new_sp
+ S390_GPR_SIZE
, (char *) saved_regs
, REGISTER_BYTES
);
1143 write_register_bytes (0, (char *) &saved_regs
, REGISTER_BYTES
);
1146 /* used by call function by hand
1147 struct_return indicates that this function returns a structure &
1148 therefore gpr2 stores a pointer to the structure to be returned as
1149 opposed to the first argument.
1150 Currently I haven't seen a TYPE_CODE_INT whose size wasn't 2^n or less
1151 than S390_GPR_SIZE this is good because I don't seem to have to worry
1152 about sign extending pushed arguments (i.e. a signed char currently
1153 comes into this code with a size of 4 ). */
1156 s390_push_arguments (int nargs
, value_ptr
*args
, CORE_ADDR sp
,
1157 int struct_return
, CORE_ADDR struct_addr
)
1159 int num_float_args
, num_gpr_args
, orig_num_gpr_args
, argno
;
1160 int second_pass
, len
, arglen
, gprs_required
;
1161 CORE_ADDR outgoing_args_ptr
, outgoing_args_space
;
1164 int max_num_gpr_args
= 5 - (struct_return
? 1 : 0);
1165 int arg0_regnum
= S390_GP0_REGNUM
+ 2 + (struct_return
? 1 : 0);
1166 char *reg_buff
= alloca (max (S390_FPR_SIZE
, REGISTER_SIZE
)), *value
;
1168 for (second_pass
= 0; second_pass
<= 1; second_pass
++)
1171 outgoing_args_ptr
= sp
+ S390_STACK_FRAME_OVERHEAD
;
1173 outgoing_args_ptr
= 0;
1176 for (argno
= 0; argno
< nargs
; argno
++)
1179 type
= check_typedef (VALUE_TYPE (arg
));
1180 len
= TYPE_LENGTH (type
);
1181 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
1183 int all_float_registers_used
=
1184 num_float_args
> (GDB_TARGET_IS_ESAME
? 3 : 1);
1188 DOUBLEST tempfloat
=
1189 extract_floating (VALUE_CONTENTS (arg
), len
);
1192 floatformat_from_doublest (all_float_registers_used
&&
1193 len
== (TARGET_FLOAT_BIT
>> 3)
1194 ? &floatformat_ieee_single_big
1195 : &floatformat_ieee_double_big
,
1196 &tempfloat
, reg_buff
);
1197 if (all_float_registers_used
)
1198 write_memory (outgoing_args_ptr
, reg_buff
, len
);
1200 write_register_bytes (REGISTER_BYTE ((S390_FP0_REGNUM
)
1204 reg_buff
, S390_FPR_SIZE
);
1206 if (all_float_registers_used
)
1207 outgoing_args_ptr
+= len
;
1212 gprs_required
= ((len
+ (S390_GPR_SIZE
- 1)) / S390_GPR_SIZE
);
1215 s390_promote_integer_argument (type
, VALUE_CONTENTS (arg
),
1218 orig_num_gpr_args
= num_gpr_args
;
1219 num_gpr_args
+= gprs_required
;
1220 if (num_gpr_args
> max_num_gpr_args
)
1223 write_memory (outgoing_args_ptr
, value
, arglen
);
1224 outgoing_args_ptr
+= arglen
;
1229 write_register_bytes (REGISTER_BYTE (arg0_regnum
)
1231 (orig_num_gpr_args
* S390_GPR_SIZE
),
1238 outgoing_args_space
= outgoing_args_ptr
;
1239 /* Align to 16 bytes because because I like alignment &
1240 some of the kernel code requires 8 byte stack alignment at least. */
1241 sp
= (sp
- (S390_STACK_FRAME_OVERHEAD
+ outgoing_args_ptr
)) & (-16);
1250 s390_fix_call_dummy (char *dummy
, CORE_ADDR pc
, CORE_ADDR fun
, int nargs
,
1251 struct value
**args
, struct type
*value_type
,
1254 store_unsigned_integer (dummy
+ 4, REGISTER_SIZE
, fun
);
1258 /* Return the GDB type object for the "standard" data type
1259 of data in register N. */
1261 s390_register_virtual_type (int regno
)
1263 return ((unsigned) regno
- S390_FPC_REGNUM
) <
1264 S390_NUM_FPRS
? builtin_type_double
: builtin_type_int
;
1269 s390x_register_virtual_type (int regno
)
1271 return (regno
== S390_FPC_REGNUM
) ||
1272 (regno
>= S390_FIRST_ACR
&& regno
<= S390_LAST_ACR
) ? builtin_type_int
:
1273 (regno
>= S390_FP0_REGNUM
) ? builtin_type_double
: builtin_type_long
;
1279 s390_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
)
1281 write_register (S390_GP0_REGNUM
+ 2, addr
);
1286 static unsigned char *
1287 s390_breakpoint_from_pc (CORE_ADDR
*pcptr
, int *lenptr
)
1289 static unsigned char breakpoint
[] = { 0x0, 0x1 };
1291 *lenptr
= sizeof (breakpoint
);
1295 /* Advance PC across any function entry prologue instructions to reach some
1298 s390_skip_prologue (CORE_ADDR pc
)
1300 struct frame_extra_info fextra_info
;
1302 s390_get_frame_info (pc
, &fextra_info
, NULL
, 1);
1303 return fextra_info
.skip_prologue_function_start
;
1306 /* pc_in_call_dummy_on stack may work for us must test this */
1308 s390_pc_in_call_dummy (CORE_ADDR pc
, CORE_ADDR sp
, CORE_ADDR frame_address
)
1310 return pc
> sp
&& pc
< (sp
+ 4096);
1313 /* Immediately after a function call, return the saved pc.
1314 Can't go through the frames for this because on some machines
1315 the new frame is not set up until the new function executes
1316 some instructions. */
1318 s390_saved_pc_after_call (struct frame_info
*frame
)
1320 return ADDR_BITS_REMOVE (read_register (S390_RETADDR_REGNUM
));
1324 s390_addr_bits_remove (CORE_ADDR addr
)
1326 return (addr
) & 0x7fffffff;
1331 s390_push_return_address (CORE_ADDR pc
, CORE_ADDR sp
)
1337 s390_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1340 /* instruction sequence for s390 call dummy is as follows
1341 bras %r1,.+8 ; 0xA7150004
1342 long basraddr ; 0x00000000
1343 l %r1,0(%r1) ; 0x58101000
1344 basr %r14,%r1 ; 0x0DE1
1345 breakpoint ; 0x0001 */
1346 static LONGEST s390_call_dummy_words
[] = { 0xA7150004, 0x00000000,
1347 0x58101000, 0x0DE10001
1349 /* instruction sequence for esame call dummy is as follows
1350 bras %r1,.+12 ; 0xA7150006
1351 long basraddr ; 0x0000000000000000
1352 lg %r1,0(%r1) ; 0xE31010000004
1353 basr %r14,%r1 ; 0x0DE1
1354 breakpoint ; 0x0001 */
1355 static LONGEST s390x_call_dummy_words
[] = { 0xA715000600000000,
1359 struct gdbarch
*gdbarch
;
1360 struct gdbarch_tdep
*tdep
;
1363 /* First see if there is already a gdbarch that can satisfy the request. */
1364 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1366 return arches
->gdbarch
;
1368 /* None found: is the request for a s390 architecture? */
1369 if (info
.bfd_arch_info
->arch
!= bfd_arch_s390
)
1370 return NULL
; /* No; then it's not for us. */
1372 /* Yes: create a new gdbarch for the specified machine type. */
1373 gdbarch
= gdbarch_alloc (&info
, NULL
);
1375 set_gdbarch_believe_pcc_promotion (gdbarch
, 0);
1377 /* We don't define set_gdbarch_call_dummy_breakpoint_offset
1378 as we already have a breakpoint inserted. */
1379 set_gdbarch_use_generic_dummy_frames (gdbarch
, 0);
1381 set_gdbarch_call_dummy_location (gdbarch
, ON_STACK
);
1382 set_gdbarch_call_dummy_start_offset (gdbarch
, 0);
1383 set_gdbarch_pc_in_call_dummy (gdbarch
, s390_pc_in_call_dummy
);
1384 set_gdbarch_frame_args_skip (gdbarch
, 0);
1385 set_gdbarch_frame_args_address (gdbarch
, s390_frame_args_address
);
1386 set_gdbarch_frame_chain (gdbarch
, s390_frame_chain
);
1387 set_gdbarch_frame_init_saved_regs (gdbarch
, s390_frame_init_saved_regs
);
1388 set_gdbarch_frame_locals_address (gdbarch
, s390_frame_args_address
);
1389 /* We can't do this */
1390 set_gdbarch_frame_num_args (gdbarch
, frame_num_args_unknown
);
1391 set_gdbarch_store_struct_return (gdbarch
, s390_store_struct_return
);
1392 set_gdbarch_extract_return_value (gdbarch
, s390_extract_return_value
);
1393 set_gdbarch_store_return_value (gdbarch
, s390_store_return_value
);
1394 /* Amount PC must be decremented by after a breakpoint.
1395 This is often the number of bytes in BREAKPOINT
1397 set_gdbarch_decr_pc_after_break (gdbarch
, 2);
1398 set_gdbarch_pop_frame (gdbarch
, s390_pop_frame
);
1399 set_gdbarch_push_dummy_frame (gdbarch
, s390_push_dummy_frame
);
1400 set_gdbarch_push_arguments (gdbarch
, s390_push_arguments
);
1401 set_gdbarch_ieee_float (gdbarch
, 1);
1402 /* Stack grows downward. */
1403 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1404 /* Offset from address of function to start of its code.
1405 Zero on most machines. */
1406 set_gdbarch_function_start_offset (gdbarch
, 0);
1407 set_gdbarch_max_register_raw_size (gdbarch
, 8);
1408 set_gdbarch_max_register_virtual_size (gdbarch
, 8);
1409 set_gdbarch_breakpoint_from_pc (gdbarch
, s390_breakpoint_from_pc
);
1410 set_gdbarch_skip_prologue (gdbarch
, s390_skip_prologue
);
1411 set_gdbarch_init_extra_frame_info (gdbarch
, s390_init_extra_frame_info
);
1412 set_gdbarch_init_frame_pc_first (gdbarch
, s390_init_frame_pc_first
);
1413 set_gdbarch_read_fp (gdbarch
, s390_read_fp
);
1414 set_gdbarch_write_fp (gdbarch
, s390_write_fp
);
1415 /* This function that tells us whether the function invocation represented
1416 by FI does not have a frame on the stack associated with it. If it
1417 does not, FRAMELESS is set to 1, else 0. */
1418 set_gdbarch_frameless_function_invocation (gdbarch
,
1419 s390_frameless_function_invocation
);
1420 /* Return saved PC from a frame */
1421 set_gdbarch_frame_saved_pc (gdbarch
, s390_frame_saved_pc
);
1422 /* FRAME_CHAIN takes a frame's nominal address
1423 and produces the frame's chain-pointer. */
1424 set_gdbarch_frame_chain (gdbarch
, s390_frame_chain
);
1425 set_gdbarch_saved_pc_after_call (gdbarch
, s390_saved_pc_after_call
);
1426 set_gdbarch_register_byte (gdbarch
, s390_register_byte
);
1427 set_gdbarch_pc_regnum (gdbarch
, S390_PC_REGNUM
);
1428 set_gdbarch_sp_regnum (gdbarch
, S390_SP_REGNUM
);
1429 set_gdbarch_fp_regnum (gdbarch
, S390_FP_REGNUM
);
1430 set_gdbarch_fp0_regnum (gdbarch
, S390_FP0_REGNUM
);
1431 set_gdbarch_num_regs (gdbarch
, S390_NUM_REGS
);
1432 set_gdbarch_cannot_fetch_register (gdbarch
, s390_cannot_fetch_register
);
1433 set_gdbarch_cannot_store_register (gdbarch
, s390_cannot_fetch_register
);
1434 set_gdbarch_get_saved_register (gdbarch
, generic_get_saved_register
);
1435 set_gdbarch_use_struct_convention (gdbarch
, generic_use_struct_convention
);
1436 set_gdbarch_frame_chain_valid (gdbarch
, file_frame_chain_valid
);
1437 set_gdbarch_register_name (gdbarch
, s390_register_name
);
1438 set_gdbarch_stab_reg_to_regnum (gdbarch
, s390_stab_reg_to_regnum
);
1439 set_gdbarch_dwarf_reg_to_regnum (gdbarch
, s390_stab_reg_to_regnum
);
1440 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, s390_stab_reg_to_regnum
);
1441 set_gdbarch_skip_trampoline_code (gdbarch
, find_solib_trampoline_target
);
1443 /* Stuff below here wouldn't be required if gdbarch.sh was a little */
1444 /* more intelligent */
1445 set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch
, 0);
1446 set_gdbarch_call_dummy_p (gdbarch
, 1);
1447 set_gdbarch_call_dummy_stack_adjust_p (gdbarch
, 0);
1448 set_gdbarch_extract_struct_value_address (gdbarch
, 0);
1449 set_gdbarch_fix_call_dummy (gdbarch
, s390_fix_call_dummy
);
1451 set_gdbarch_prepare_to_proceed (gdbarch
, linuxthreads_prepare_to_proceed
);
1453 set_gdbarch_push_return_address (gdbarch
, s390_push_return_address
);
1455 switch (info
.bfd_arch_info
->mach
)
1457 case bfd_mach_s390_esa
:
1458 set_gdbarch_register_size (gdbarch
, 4);
1459 set_gdbarch_call_dummy_length (gdbarch
, 16);
1460 set_gdbarch_register_raw_size (gdbarch
, s390_register_raw_size
);
1461 set_gdbarch_register_virtual_size (gdbarch
, s390_register_raw_size
);
1462 set_gdbarch_register_virtual_type (gdbarch
, s390_register_virtual_type
);
1464 set_gdbarch_addr_bits_remove (gdbarch
, s390_addr_bits_remove
);
1466 set_gdbarch_sizeof_call_dummy_words (gdbarch
,
1467 sizeof (s390_call_dummy_words
));
1468 set_gdbarch_call_dummy_words (gdbarch
, s390_call_dummy_words
);
1469 set_gdbarch_register_bytes (gdbarch
, S390_REGISTER_BYTES
);
1471 case bfd_mach_s390_esame
:
1472 set_gdbarch_register_size (gdbarch
, 8);
1473 set_gdbarch_call_dummy_length (gdbarch
, 22);
1474 set_gdbarch_register_raw_size (gdbarch
, s390x_register_raw_size
);
1475 set_gdbarch_register_virtual_size (gdbarch
, s390x_register_raw_size
);
1476 set_gdbarch_register_virtual_type (gdbarch
,
1477 s390x_register_virtual_type
);
1479 set_gdbarch_long_bit (gdbarch
, 64);
1480 set_gdbarch_long_long_bit (gdbarch
, 64);
1481 set_gdbarch_ptr_bit (gdbarch
, 64);
1482 set_gdbarch_sizeof_call_dummy_words (gdbarch
,
1483 sizeof (s390x_call_dummy_words
));
1484 set_gdbarch_call_dummy_words (gdbarch
, s390x_call_dummy_words
);
1485 set_gdbarch_register_bytes (gdbarch
, S390X_REGISTER_BYTES
);
1495 _initialize_s390_tdep ()
1498 /* Hook us into the gdbarch mechanism. */
1499 register_gdbarch_init (bfd_arch_s390
, s390_gdbarch_init
);
1500 if (!tm_print_insn
) /* Someone may have already set it */
1501 tm_print_insn
= gdb_print_insn_s390
;
1504 #endif /* GDBSERVER */