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
, got_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
;
219 const_pool_state
= save_link_state
= got_state
= varargs_state
= 0;
220 frame_pointer_found
= 0;
221 memset (gprs_saved
, 0, sizeof (gprs_saved
));
222 memset (fprs_saved
, 0, sizeof (fprs_saved
));
223 info
.read_memory_func
= dis_asm_read_memory
;
225 save_link_regidx
= subtract_sp_regidx
= 0;
230 orig_sp
= fi
->frame
+ fextra_info
->stack_bought
;
231 saved_regs
= fi
->saved_regs
;
233 if (init_extra_info
|| !fextra_info
->initialised
)
235 s390_memset_extra_info (fextra_info
);
236 fextra_info
->function_start
= pc
;
237 fextra_info
->initialised
= 1;
245 /* add the previous instruction len */
246 instrlen
= s390_readinstruction (instr
, test_pc
, &info
);
253 /* We probably are in a glibc syscall */
254 if (instr
[0] == S390_SYSCALL_OPCODE
&& test_pc
== pc
)
257 if (saved_regs
&& fextra_info
&& fi
->next
&& fi
->next
->extra_info
258 && fi
->next
->extra_info
->sigcontext
)
260 /* We are backtracing from a signal handler */
261 save_reg_addr
= fi
->next
->extra_info
->sigcontext
+
262 REGISTER_BYTE (S390_GP0_REGNUM
);
263 for (regidx
= 0; regidx
< S390_NUM_GPRS
; regidx
++)
265 saved_regs
[S390_GP0_REGNUM
+ regidx
] = save_reg_addr
;
266 save_reg_addr
+= S390_GPR_SIZE
;
268 save_reg_addr
= fi
->next
->extra_info
->sigcontext
+
269 (GDB_TARGET_IS_ESAME
? S390X_SIGREGS_FP0_OFFSET
:
270 S390_SIGREGS_FP0_OFFSET
);
271 for (regidx
= 0; regidx
< S390_NUM_FPRS
; regidx
++)
273 saved_regs
[S390_FP0_REGNUM
+ regidx
] = save_reg_addr
;
274 save_reg_addr
+= S390_FPR_SIZE
;
279 if (save_link_state
== 0)
281 /* check for a stack relative STMG or STM */
282 if (((GDB_TARGET_IS_ESAME
&&
283 ((instr
[0] == 0xeb) && (instr
[5] == 0x24))) ||
284 (instr
[0] == 0x90)) && ((instr
[2] >> 4) == 0xf))
286 regidx
= (instr
[1] >> 4);
289 offset
= ((instr
[2] & 0xf) << 8) + instr
[3];
291 S390_GPR6_STACK_OFFSET
+ (S390_GPR_SIZE
* (regidx
- 6));
292 if (offset
!= expected_offset
)
298 save_reg_addr
= orig_sp
+ offset
;
299 for (; regidx
<= (instr
[1] & 0xf); regidx
++)
301 if (gprs_saved
[regidx
])
307 gprs_saved
[regidx
] = 1;
310 saved_regs
[S390_GP0_REGNUM
+ regidx
] = save_reg_addr
;
311 save_reg_addr
+= S390_GPR_SIZE
;
318 /* check for a stack relative STG or ST */
319 if ((save_link_state
== 0 || save_link_state
== 3) &&
320 ((GDB_TARGET_IS_ESAME
&&
321 ((instr
[0] == 0xe3) && (instr
[5] == 0x24))) ||
322 (instr
[0] == 0x50)) && ((instr
[2] >> 4) == 0xf))
324 regidx
= instr
[1] >> 4;
325 offset
= ((instr
[2] & 0xf) << 8) + instr
[3];
328 if (save_link_state
== 3 && regidx
== save_link_regidx
)
340 S390_GPR6_STACK_OFFSET
+ (S390_GPR_SIZE
* (regidx
- 6));
341 if (offset
!= expected_offset
)
346 if (gprs_saved
[regidx
])
352 gprs_saved
[regidx
] = 1;
355 save_reg_addr
= orig_sp
+ offset
;
356 saved_regs
[S390_GP0_REGNUM
+ regidx
] = save_reg_addr
;
363 if (instr
[0] == 0x60 && (instr
[2] >> 4) == 0xf)
365 regidx
= instr
[1] >> 4;
366 if (regidx
== 0 || regidx
== 2)
368 if (fprs_saved
[regidx
])
373 fprs_saved
[regidx
] = 1;
376 save_reg_addr
= orig_sp
+ (((instr
[2] & 0xf) << 8) + instr
[3]);
377 saved_regs
[S390_FP0_REGNUM
+ regidx
] = save_reg_addr
;
384 if (const_pool_state
== 0)
387 if (GDB_TARGET_IS_ESAME
)
389 /* Check for larl CONST_POOL_REGIDX,offset on ESAME */
390 if ((instr
[0] == 0xc0)
391 && (instr
[1] == (CONST_POOL_REGIDX
<< 4)))
393 const_pool_state
= 2;
400 /* Check for BASR gpr13,gpr0 used to load constant pool pointer to r13 in old compiler */
401 if (instr
[0] == 0xd && (instr
[1] & 0xf) == 0
402 && ((instr
[1] >> 4) == CONST_POOL_REGIDX
))
404 const_pool_state
= 1;
409 /* Check for new fangled bras %r13,newpc to load new constant pool */
410 /* embedded in code, older pre abi compilers also emitted this stuff. */
411 if ((instr
[0] == 0xa7) && ((instr
[1] & 0xf) == 0x5) &&
412 ((instr
[1] >> 4) == CONST_POOL_REGIDX
)
413 && ((instr
[2] & 0x80) == 0))
415 const_pool_state
= 2;
417 (((((instr
[2] & 0xf) << 8) + instr
[3]) << 1) - instrlen
);
422 /* Check for AGHI or AHI CONST_POOL_REGIDX,val */
423 if (const_pool_state
== 1 && (instr
[0] == 0xa7) &&
424 ((GDB_TARGET_IS_ESAME
&&
425 (instr
[1] == ((CONST_POOL_REGIDX
<< 4) | 0xb))) ||
426 (instr
[1] == ((CONST_POOL_REGIDX
<< 4) | 0xa))))
428 const_pool_state
= 2;
432 /* Check for LGR or LR gprx,15 */
433 if ((GDB_TARGET_IS_ESAME
&&
434 instr
[0] == 0xb9 && instr
[1] == 0x04 && (instr
[3] & 0xf) == 0xf) ||
435 (instr
[0] == 0x18 && (instr
[1] & 0xf) == 0xf))
437 if (GDB_TARGET_IS_ESAME
)
438 regidx
= instr
[3] >> 4;
440 regidx
= instr
[1] >> 4;
441 if (save_link_state
== 0 && regidx
!= 0xb)
443 /* Almost defintely code for
444 decrementing the stack pointer
445 ( i.e. a non leaf function
446 or else leaf with locals ) */
447 save_link_regidx
= regidx
;
452 /* We use this frame pointer for alloca
453 unfortunately we need to assume its gpr11
454 otherwise we would need a smarter prologue
456 if (!frame_pointer_found
&& regidx
== 0xb)
458 frame_pointer_regidx
= 0xb;
459 frame_pointer_found
= 1;
461 fextra_info
->frame_pointer_saved_pc
= test_pc
;
466 /* Check for AHI or AGHI gpr15,val */
467 if (save_link_state
== 1 && (instr
[0] == 0xa7) &&
468 ((GDB_TARGET_IS_ESAME
&& (instr
[1] == 0xfb)) || (instr
[1] == 0xfa)))
471 fextra_info
->stack_bought
=
472 -extract_signed_integer (&instr
[2], 2);
477 /* Alternatively check for the complex construction for
478 buying more than 32k of stack
480 long vals %r15,0(%gprx) gprx currently r1 */
481 if ((save_link_state
== 1) && (instr
[0] == 0xa7)
482 && ((instr
[1] & 0xf) == 0x5) && (instr
[2] == 0)
483 && (instr
[3] == 0x4) && ((instr
[1] >> 4) != CONST_POOL_REGIDX
))
485 subtract_sp_regidx
= instr
[1] >> 4;
488 target_read_memory (test_pc
+ instrlen
,
489 (char *) &fextra_info
->stack_bought
,
490 sizeof (fextra_info
->stack_bought
));
495 if (save_link_state
== 2 && instr
[0] == 0x5b
496 && instr
[1] == 0xf0 &&
497 instr
[2] == (subtract_sp_regidx
<< 4) && instr
[3] == 0)
503 /* check for LA gprx,offset(15) used for varargs */
504 if ((instr
[0] == 0x41) && ((instr
[2] >> 4) == 0xf) &&
505 ((instr
[1] & 0xf) == 0))
507 /* some code uses gpr7 to point to outgoing args */
508 if (((instr
[1] >> 4) == 7) && (save_link_state
== 0) &&
509 ((instr
[2] & 0xf) == 0)
510 && (instr
[3] == S390_STACK_FRAME_OVERHEAD
))
515 if (varargs_state
== 1)
522 /* Check for a GOT load */
524 if (GDB_TARGET_IS_ESAME
)
526 /* Check for larl GOT_REGIDX, on ESAME */
527 if ((got_state
== 0) && (instr
[0] == 0xc0)
528 && (instr
[1] == (GOT_REGIDX
<< 4)))
537 /* check for l GOT_REGIDX,x(CONST_POOL_REGIDX) */
538 if (got_state
== 0 && const_pool_state
== 2 && instr
[0] == 0x58
539 && (instr
[2] == (CONST_POOL_REGIDX
<< 4))
540 && ((instr
[1] >> 4) == GOT_REGIDX
))
546 /* Check for subsequent ar got_regidx,basr_regidx */
547 if (got_state
== 1 && instr
[0] == 0x1a &&
548 instr
[1] == ((GOT_REGIDX
<< 4) | CONST_POOL_REGIDX
))
556 while (valid_prologue
&& good_prologue
);
559 good_prologue
= (((got_state
== 0) || (got_state
== 2)) &&
560 ((const_pool_state
== 0) || (const_pool_state
== 2)) &&
561 ((save_link_state
== 0) || (save_link_state
== 4)) &&
562 ((varargs_state
== 0) || (varargs_state
== 2)));
566 fextra_info
->good_prologue
= good_prologue
;
567 fextra_info
->skip_prologue_function_start
=
568 (good_prologue
? test_pc
: pc
);
575 s390_check_function_end (CORE_ADDR pc
)
577 bfd_byte instr
[S390_MAX_INSTR_SIZE
];
578 disassemble_info info
;
579 int regidx
, instrlen
;
581 info
.read_memory_func
= dis_asm_read_memory
;
582 instrlen
= s390_readinstruction (instr
, pc
, &info
);
586 if (instrlen
!= 2 || instr
[0] != 07 || (instr
[1] >> 4) != 0xf)
588 regidx
= instr
[1] & 0xf;
589 /* Check for LMG or LG */
591 s390_readinstruction (instr
, pc
- (GDB_TARGET_IS_ESAME
? 6 : 4), &info
);
594 if (GDB_TARGET_IS_ESAME
)
597 if (instrlen
!= 6 || instr
[0] != 0xeb || instr
[5] != 0x4)
600 else if (instrlen
!= 4 || instr
[0] != 0x98)
604 if ((instr
[2] >> 4) != 0xf)
608 instrlen
= s390_readinstruction (instr
, pc
- (GDB_TARGET_IS_ESAME
? 12 : 8),
612 if (GDB_TARGET_IS_ESAME
)
615 if (instrlen
!= 6 || instr
[0] != 0xe3 || instr
[5] != 0x4)
621 if (instrlen
!= 4 || instr
[0] != 0x58)
624 if (instr
[2] >> 4 != 0xf)
626 if (instr
[1] >> 4 != regidx
)
632 s390_sniff_pc_function_start (CORE_ADDR pc
, struct frame_info
*fi
)
634 CORE_ADDR function_start
, test_function_start
;
635 int loop_cnt
, err
, function_end
;
636 struct frame_extra_info fextra_info
;
637 function_start
= get_pc_function_start (pc
);
639 if (function_start
== 0)
641 test_function_start
= pc
;
642 if (test_function_start
& 1)
643 return 0; /* This has to be bogus */
649 s390_get_frame_info (test_function_start
, &fextra_info
, fi
, 1);
651 test_function_start
-= 2;
652 function_end
= s390_check_function_end (test_function_start
);
654 while (!(function_end
== 1 || err
|| loop_cnt
>= 4096 ||
655 (fextra_info
.good_prologue
)));
656 if (fextra_info
.good_prologue
)
657 function_start
= fextra_info
.function_start
;
658 else if (function_end
== 1)
659 function_start
= test_function_start
;
661 return function_start
;
667 s390_function_start (struct frame_info
*fi
)
669 CORE_ADDR function_start
= 0;
671 if (fi
->extra_info
&& fi
->extra_info
->initialised
)
672 function_start
= fi
->extra_info
->function_start
;
674 function_start
= get_pc_function_start (fi
->pc
);
675 return function_start
;
682 s390_frameless_function_invocation (struct frame_info
*fi
)
684 struct frame_extra_info fextra_info
, *fextra_info_ptr
;
687 if (fi
->next
== NULL
) /* no may be frameless */
690 fextra_info_ptr
= fi
->extra_info
;
693 fextra_info_ptr
= &fextra_info
;
694 s390_get_frame_info (s390_sniff_pc_function_start (fi
->pc
, fi
),
695 fextra_info_ptr
, fi
, 1);
697 frameless
= ((fextra_info_ptr
->stack_bought
== 0));
705 s390_is_sigreturn (CORE_ADDR pc
, struct frame_info
*sighandler_fi
,
706 CORE_ADDR
*sregs
, CORE_ADDR
*sigcaller_pc
)
708 bfd_byte instr
[S390_MAX_INSTR_SIZE
];
709 disassemble_info info
;
714 CORE_ADDR temp_sregs
;
716 scontext
= temp_sregs
= 0;
718 info
.read_memory_func
= dis_asm_read_memory
;
719 instrlen
= s390_readinstruction (instr
, pc
, &info
);
722 if (((instrlen
== S390_SYSCALL_SIZE
) &&
723 (instr
[0] == S390_SYSCALL_OPCODE
)) &&
724 ((instr
[1] == s390_NR_sigreturn
) || (instr
[1] == s390_NR_rt_sigreturn
)))
728 if (s390_frameless_function_invocation (sighandler_fi
))
729 orig_sp
= sighandler_fi
->frame
;
731 orig_sp
= ADDR_BITS_REMOVE ((CORE_ADDR
)
732 read_memory_integer (sighandler_fi
->
735 if (orig_sp
&& sigcaller_pc
)
737 scontext
= orig_sp
+ S390_SIGNAL_FRAMESIZE
;
738 if (pc
== scontext
&& instr
[1] == s390_NR_rt_sigreturn
)
740 /* We got a new style rt_signal */
741 /* get address of read ucontext->uc_mcontext */
742 temp_sregs
= orig_sp
+ (GDB_TARGET_IS_ESAME
?
743 S390X_UC_MCONTEXT_OFFSET
:
744 S390_UC_MCONTEXT_OFFSET
);
748 /* read sigcontext->sregs */
749 temp_sregs
= ADDR_BITS_REMOVE ((CORE_ADDR
)
750 read_memory_integer (scontext
754 S390X_SIGCONTEXT_SREGS_OFFSET
756 S390_SIGCONTEXT_SREGS_OFFSET
),
760 /* read sigregs->psw.addr */
762 ADDR_BITS_REMOVE ((CORE_ADDR
)
763 read_memory_integer (temp_sregs
+
766 S390_PSW_ADDR_SIZE
));
777 We need to do something better here but this will keep us out of trouble
779 For some reason the blockframe.c calls us with fi->next->fromleaf
780 so this seems of little use to us. */
782 s390_init_frame_pc_first (int next_fromleaf
, struct frame_info
*fi
)
784 CORE_ADDR sigcaller_pc
;
789 fi
->pc
= ADDR_BITS_REMOVE (read_register (S390_RETADDR_REGNUM
));
790 /* fix signal handlers */
792 else if (fi
->next
&& fi
->next
->pc
)
793 fi
->pc
= s390_frame_saved_pc_nofix (fi
->next
);
794 if (fi
->pc
&& fi
->next
&& fi
->next
->frame
&&
795 s390_is_sigreturn (fi
->pc
, fi
->next
, NULL
, &sigcaller_pc
))
797 fi
->pc
= sigcaller_pc
;
803 s390_init_extra_frame_info (int fromleaf
, struct frame_info
*fi
)
805 fi
->extra_info
= frame_obstack_alloc (sizeof (struct frame_extra_info
));
807 s390_get_frame_info (s390_sniff_pc_function_start (fi
->pc
, fi
),
808 fi
->extra_info
, fi
, 1);
810 s390_memset_extra_info (fi
->extra_info
);
813 /* If saved registers of frame FI are not known yet, read and cache them.
814 &FEXTRA_INFOP contains struct frame_extra_info; TDATAP can be NULL,
815 in which case the framedata are read. */
818 s390_frame_init_saved_regs (struct frame_info
*fi
)
823 if (fi
->saved_regs
== NULL
)
825 /* zalloc memsets the saved regs */
826 frame_saved_regs_zalloc (fi
);
829 quick
= (fi
->extra_info
&& fi
->extra_info
->initialised
830 && fi
->extra_info
->good_prologue
);
831 s390_get_frame_info (quick
? fi
->extra_info
->function_start
:
832 s390_sniff_pc_function_start (fi
->pc
, fi
),
833 fi
->extra_info
, fi
, !quick
);
841 s390_frame_args_address (struct frame_info
*fi
)
844 /* Apparently gdb already knows gdb_args_offset itself */
850 s390_frame_saved_pc_nofix (struct frame_info
*fi
)
852 if (fi
->extra_info
&& fi
->extra_info
->saved_pc_valid
)
853 return fi
->extra_info
->saved_pc
;
854 s390_frame_init_saved_regs (fi
);
857 fi
->extra_info
->saved_pc_valid
= 1;
858 if (fi
->extra_info
->good_prologue
)
860 if (fi
->saved_regs
[S390_RETADDR_REGNUM
])
862 return (fi
->extra_info
->saved_pc
=
863 ADDR_BITS_REMOVE (read_memory_integer
864 (fi
->saved_regs
[S390_RETADDR_REGNUM
],
873 s390_frame_saved_pc (struct frame_info
*fi
)
875 CORE_ADDR saved_pc
= 0, sig_pc
;
877 if (fi
->extra_info
&& fi
->extra_info
->sig_fixed_saved_pc_valid
)
878 return fi
->extra_info
->sig_fixed_saved_pc
;
879 saved_pc
= s390_frame_saved_pc_nofix (fi
);
883 fi
->extra_info
->sig_fixed_saved_pc_valid
= 1;
886 if (s390_is_sigreturn (saved_pc
, fi
, NULL
, &sig_pc
))
889 fi
->extra_info
->sig_fixed_saved_pc
= saved_pc
;
897 /* We want backtraces out of signal handlers so we don't
898 set thisframe->signal_handler_caller to 1 */
901 s390_frame_chain (struct frame_info
*thisframe
)
903 CORE_ADDR prev_fp
= 0;
905 if (thisframe
->prev
&& thisframe
->prev
->frame
)
906 prev_fp
= thisframe
->prev
->frame
;
911 struct frame_extra_info prev_fextra_info
;
913 memset (&prev_fextra_info
, 0, sizeof (prev_fextra_info
));
916 CORE_ADDR saved_pc
, sig_pc
;
918 saved_pc
= s390_frame_saved_pc_nofix (thisframe
);
922 s390_is_sigreturn (saved_pc
, thisframe
, &sregs
, &sig_pc
)))
924 s390_get_frame_info (s390_sniff_pc_function_start
925 (saved_pc
, NULL
), &prev_fextra_info
, NULL
,
931 /* read sigregs,regs.gprs[11 or 15] */
932 prev_fp
= read_memory_integer (sregs
+
933 REGISTER_BYTE (S390_GP0_REGNUM
+
935 frame_pointer_saved_pc
938 thisframe
->extra_info
->sigcontext
= sregs
;
942 if (thisframe
->saved_regs
)
948 ((prev_fextra_info
.frame_pointer_saved_pc
950 saved_regs
[S390_FRAME_REGNUM
]) ? S390_FRAME_REGNUM
:
952 if (thisframe
->saved_regs
[regno
])
954 read_memory_integer (thisframe
->saved_regs
[regno
],
959 return ADDR_BITS_REMOVE (prev_fp
);
963 Whether struct frame_extra_info is actually needed I'll have to figure
964 out as our frames are similar to rs6000 there is a possibility
965 i386 dosen't need it. */
969 /* a given return value in `regbuf' with a type `valtype', extract and copy its
970 value into `valbuf' */
972 s390_extract_return_value (struct type
*valtype
, char *regbuf
, char *valbuf
)
974 /* floats and doubles are returned in fpr0. fpr's have a size of 8 bytes.
975 We need to truncate the return value into float size (4 byte) if
977 int len
= TYPE_LENGTH (valtype
);
979 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
981 if (len
> (TARGET_FLOAT_BIT
>> 3))
982 memcpy (valbuf
, ®buf
[REGISTER_BYTE (S390_FP0_REGNUM
)], len
);
988 floatformat_to_doublest (&floatformat_ieee_double_big
,
989 ®buf
[REGISTER_BYTE (S390_FP0_REGNUM
)],
991 store_floating (valbuf
, len
, val
);
997 /* return value is copied starting from r2. */
998 if (TYPE_LENGTH (valtype
) < S390_GPR_SIZE
)
999 offset
= S390_GPR_SIZE
- TYPE_LENGTH (valtype
);
1001 regbuf
+ REGISTER_BYTE (S390_GP0_REGNUM
+ 2) + offset
,
1002 TYPE_LENGTH (valtype
));
1008 s390_promote_integer_argument (struct type
*valtype
, char *valbuf
,
1009 char *reg_buff
, int *arglen
)
1011 char *value
= valbuf
;
1012 int len
= TYPE_LENGTH (valtype
);
1014 if (len
< S390_GPR_SIZE
)
1016 /* We need to upgrade this value to a register to pass it correctly */
1017 int idx
, diff
= S390_GPR_SIZE
- len
, negative
=
1018 (!TYPE_UNSIGNED (valtype
) && value
[0] & 0x80);
1019 for (idx
= 0; idx
< S390_GPR_SIZE
; idx
++)
1021 reg_buff
[idx
] = (idx
< diff
? (negative
? 0xff : 0x0) :
1025 *arglen
= S390_GPR_SIZE
;
1029 if (len
& (S390_GPR_SIZE
- 1))
1031 fprintf_unfiltered (gdb_stderr
,
1032 "s390_promote_integer_argument detected an argument not "
1033 "a multiple of S390_GPR_SIZE & greater than S390_GPR_SIZE "
1034 "we might not deal with this correctly.\n");
1043 s390_store_return_value (struct type
*valtype
, char *valbuf
)
1046 char *reg_buff
= alloca (max (S390_FPR_SIZE
, REGISTER_SIZE
)), *value
;
1048 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
1050 DOUBLEST tempfloat
= extract_floating (valbuf
, TYPE_LENGTH (valtype
));
1052 floatformat_from_doublest (&floatformat_ieee_double_big
, &tempfloat
,
1054 write_register_bytes (REGISTER_BYTE (S390_FP0_REGNUM
), reg_buff
,
1060 s390_promote_integer_argument (valtype
, valbuf
, reg_buff
, &arglen
);
1061 /* Everything else is returned in GPR2 and up. */
1062 write_register_bytes (REGISTER_BYTE (S390_GP0_REGNUM
+ 2), value
,
1067 gdb_print_insn_s390 (bfd_vma memaddr
, disassemble_info
* info
)
1069 bfd_byte instrbuff
[S390_MAX_INSTR_SIZE
];
1072 instrlen
= s390_readinstruction (instrbuff
, (CORE_ADDR
) memaddr
, info
);
1075 (*info
->memory_error_func
) (instrlen
, memaddr
, info
);
1078 for (cnt
= 0; cnt
< instrlen
; cnt
++)
1079 info
->fprintf_func (info
->stream
, "%02X ", instrbuff
[cnt
]);
1080 for (cnt
= instrlen
; cnt
< S390_MAX_INSTR_SIZE
; cnt
++)
1081 info
->fprintf_func (info
->stream
, " ");
1082 instrlen
= print_insn_s390 (memaddr
, info
);
1088 /* Not the most efficent code in the world */
1092 int regno
= S390_SP_REGNUM
;
1093 struct frame_extra_info fextra_info
;
1095 CORE_ADDR pc
= ADDR_BITS_REMOVE (read_register (S390_PC_REGNUM
));
1097 s390_get_frame_info (s390_sniff_pc_function_start (pc
, NULL
), &fextra_info
,
1099 if (fextra_info
.frame_pointer_saved_pc
)
1100 regno
= S390_FRAME_REGNUM
;
1107 return read_register (s390_fp_regnum ());
1112 s390_write_fp (CORE_ADDR val
)
1114 write_register (s390_fp_regnum (), val
);
1119 s390_push_dummy_frame ()
1121 CORE_ADDR orig_sp
= read_register (S390_SP_REGNUM
), new_sp
;
1122 void *saved_regs
= alloca (REGISTER_BYTES
);
1124 new_sp
= (orig_sp
- (REGISTER_BYTES
+ S390_GPR_SIZE
));
1125 read_register_bytes (0, (char *) saved_regs
, REGISTER_BYTES
);
1126 /* Use saved copy instead of orig_sp as this will have the correct endianness */
1127 write_memory (new_sp
, (char *) saved_regs
+ REGISTER_BYTE (S390_SP_REGNUM
),
1129 write_memory (new_sp
+ S390_GPR_SIZE
, (char *) &saved_regs
, REGISTER_BYTES
);
1130 write_register (S390_SP_REGNUM
, new_sp
);
1133 /* pop the innermost frame, go back to the caller.
1134 Used in `call_function_by_hand' to remove an artificial stack
1139 CORE_ADDR new_sp
= read_register (S390_SP_REGNUM
), orig_sp
;
1140 void *saved_regs
= alloca (REGISTER_BYTES
);
1143 read_memory (new_sp
+ S390_GPR_SIZE
, (char *) saved_regs
, REGISTER_BYTES
);
1144 write_register_bytes (0, (char *) &saved_regs
, REGISTER_BYTES
);
1147 /* used by call function by hand
1148 struct_return indicates that this function returns a structure &
1149 therefore gpr2 stores a pointer to the structure to be returned as
1150 opposed to the first argument.
1151 Currently I haven't seen a TYPE_CODE_INT whose size wasn't 2^n or less
1152 than S390_GPR_SIZE this is good because I don't seem to have to worry
1153 about sign extending pushed arguments (i.e. a signed char currently
1154 comes into this code with a size of 4 ). */
1157 s390_push_arguments (int nargs
, struct value
**args
, CORE_ADDR sp
,
1158 int struct_return
, CORE_ADDR struct_addr
)
1160 int num_float_args
, num_gpr_args
, orig_num_gpr_args
, argno
;
1161 int second_pass
, len
, arglen
, gprs_required
;
1162 CORE_ADDR outgoing_args_ptr
, outgoing_args_space
;
1165 int max_num_gpr_args
= 5 - (struct_return
? 1 : 0);
1166 int arg0_regnum
= S390_GP0_REGNUM
+ 2 + (struct_return
? 1 : 0);
1167 char *reg_buff
= alloca (max (S390_FPR_SIZE
, REGISTER_SIZE
)), *value
;
1169 for (second_pass
= 0; second_pass
<= 1; second_pass
++)
1172 outgoing_args_ptr
= sp
+ S390_STACK_FRAME_OVERHEAD
;
1174 outgoing_args_ptr
= 0;
1177 for (argno
= 0; argno
< nargs
; argno
++)
1180 type
= check_typedef (VALUE_TYPE (arg
));
1181 len
= TYPE_LENGTH (type
);
1182 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
1184 int all_float_registers_used
=
1185 num_float_args
> (GDB_TARGET_IS_ESAME
? 3 : 1);
1189 DOUBLEST tempfloat
=
1190 extract_floating (VALUE_CONTENTS (arg
), len
);
1193 floatformat_from_doublest (all_float_registers_used
&&
1194 len
== (TARGET_FLOAT_BIT
>> 3)
1195 ? &floatformat_ieee_single_big
1196 : &floatformat_ieee_double_big
,
1197 &tempfloat
, reg_buff
);
1198 if (all_float_registers_used
)
1199 write_memory (outgoing_args_ptr
, reg_buff
, len
);
1201 write_register_bytes (REGISTER_BYTE ((S390_FP0_REGNUM
)
1205 reg_buff
, S390_FPR_SIZE
);
1207 if (all_float_registers_used
)
1208 outgoing_args_ptr
+= len
;
1213 gprs_required
= ((len
+ (S390_GPR_SIZE
- 1)) / S390_GPR_SIZE
);
1216 s390_promote_integer_argument (type
, VALUE_CONTENTS (arg
),
1219 orig_num_gpr_args
= num_gpr_args
;
1220 num_gpr_args
+= gprs_required
;
1221 if (num_gpr_args
> max_num_gpr_args
)
1224 write_memory (outgoing_args_ptr
, value
, arglen
);
1225 outgoing_args_ptr
+= arglen
;
1230 write_register_bytes (REGISTER_BYTE (arg0_regnum
)
1232 (orig_num_gpr_args
* S390_GPR_SIZE
),
1239 outgoing_args_space
= outgoing_args_ptr
;
1240 /* Align to 16 bytes because because I like alignment &
1241 some of the kernel code requires 8 byte stack alignment at least. */
1242 sp
= (sp
- (S390_STACK_FRAME_OVERHEAD
+ outgoing_args_ptr
)) & (-16);
1251 s390_fix_call_dummy (char *dummy
, CORE_ADDR pc
, CORE_ADDR fun
, int nargs
,
1252 struct value
**args
, struct type
*value_type
,
1255 store_unsigned_integer (dummy
+ 4, REGISTER_SIZE
, fun
);
1259 /* Return the GDB type object for the "standard" data type
1260 of data in register N. */
1262 s390_register_virtual_type (int regno
)
1264 return ((unsigned) regno
- S390_FPC_REGNUM
) <
1265 S390_NUM_FPRS
? builtin_type_double
: builtin_type_int
;
1270 s390x_register_virtual_type (int regno
)
1272 return (regno
== S390_FPC_REGNUM
) ||
1273 (regno
>= S390_FIRST_ACR
&& regno
<= S390_LAST_ACR
) ? builtin_type_int
:
1274 (regno
>= S390_FP0_REGNUM
) ? builtin_type_double
: builtin_type_long
;
1280 s390_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
)
1282 write_register (S390_GP0_REGNUM
+ 2, addr
);
1287 static unsigned char *
1288 s390_breakpoint_from_pc (CORE_ADDR
*pcptr
, int *lenptr
)
1290 static unsigned char breakpoint
[] = { 0x0, 0x1 };
1292 *lenptr
= sizeof (breakpoint
);
1296 /* Advance PC across any function entry prologue instructions to reach some
1299 s390_skip_prologue (CORE_ADDR pc
)
1301 struct frame_extra_info fextra_info
;
1303 s390_get_frame_info (pc
, &fextra_info
, NULL
, 1);
1304 return fextra_info
.skip_prologue_function_start
;
1307 /* pc_in_call_dummy_on stack may work for us must test this */
1309 s390_pc_in_call_dummy (CORE_ADDR pc
, CORE_ADDR sp
, CORE_ADDR frame_address
)
1311 return pc
> sp
&& pc
< (sp
+ 4096);
1314 /* Immediately after a function call, return the saved pc.
1315 Can't go through the frames for this because on some machines
1316 the new frame is not set up until the new function executes
1317 some instructions. */
1319 s390_saved_pc_after_call (struct frame_info
*frame
)
1321 return ADDR_BITS_REMOVE (read_register (S390_RETADDR_REGNUM
));
1325 s390_addr_bits_remove (CORE_ADDR addr
)
1327 return (addr
) & 0x7fffffff;
1332 s390_push_return_address (CORE_ADDR pc
, CORE_ADDR sp
)
1338 s390_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1341 /* instruction sequence for s390 call dummy is as follows
1342 bras %r1,.+8 ; 0xA7150004
1343 long basraddr ; 0x00000000
1344 l %r1,0(%r1) ; 0x58101000
1345 basr %r14,%r1 ; 0x0DE1
1346 breakpoint ; 0x0001 */
1347 static LONGEST s390_call_dummy_words
[] = { 0xA7150004, 0x00000000,
1348 0x58101000, 0x0DE10001
1350 /* instruction sequence for esame call dummy is as follows
1351 bras %r1,.+12 ; 0xA7150006
1352 long basraddr ; 0x0000000000000000
1353 lg %r1,0(%r1) ; 0xE31010000004
1354 basr %r14,%r1 ; 0x0DE1
1355 breakpoint ; 0x0001 */
1356 static LONGEST s390x_call_dummy_words
[] = { 0xA715000600000000,
1360 struct gdbarch
*gdbarch
;
1361 struct gdbarch_tdep
*tdep
;
1364 /* First see if there is already a gdbarch that can satisfy the request. */
1365 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1367 return arches
->gdbarch
;
1369 /* None found: is the request for a s390 architecture? */
1370 if (info
.bfd_arch_info
->arch
!= bfd_arch_s390
)
1371 return NULL
; /* No; then it's not for us. */
1373 /* Yes: create a new gdbarch for the specified machine type. */
1374 gdbarch
= gdbarch_alloc (&info
, NULL
);
1376 set_gdbarch_believe_pcc_promotion (gdbarch
, 0);
1378 /* We don't define set_gdbarch_call_dummy_breakpoint_offset
1379 as we already have a breakpoint inserted. */
1380 set_gdbarch_use_generic_dummy_frames (gdbarch
, 0);
1382 set_gdbarch_call_dummy_location (gdbarch
, ON_STACK
);
1383 set_gdbarch_call_dummy_start_offset (gdbarch
, 0);
1384 set_gdbarch_pc_in_call_dummy (gdbarch
, s390_pc_in_call_dummy
);
1385 set_gdbarch_frame_args_skip (gdbarch
, 0);
1386 set_gdbarch_frame_args_address (gdbarch
, s390_frame_args_address
);
1387 set_gdbarch_frame_chain (gdbarch
, s390_frame_chain
);
1388 set_gdbarch_frame_init_saved_regs (gdbarch
, s390_frame_init_saved_regs
);
1389 set_gdbarch_frame_locals_address (gdbarch
, s390_frame_args_address
);
1390 /* We can't do this */
1391 set_gdbarch_frame_num_args (gdbarch
, frame_num_args_unknown
);
1392 set_gdbarch_store_struct_return (gdbarch
, s390_store_struct_return
);
1393 set_gdbarch_extract_return_value (gdbarch
, s390_extract_return_value
);
1394 set_gdbarch_store_return_value (gdbarch
, s390_store_return_value
);
1395 /* Amount PC must be decremented by after a breakpoint.
1396 This is often the number of bytes in BREAKPOINT
1398 set_gdbarch_decr_pc_after_break (gdbarch
, 2);
1399 set_gdbarch_pop_frame (gdbarch
, s390_pop_frame
);
1400 set_gdbarch_push_dummy_frame (gdbarch
, s390_push_dummy_frame
);
1401 set_gdbarch_push_arguments (gdbarch
, s390_push_arguments
);
1402 set_gdbarch_ieee_float (gdbarch
, 1);
1403 /* Stack grows downward. */
1404 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1405 /* Offset from address of function to start of its code.
1406 Zero on most machines. */
1407 set_gdbarch_function_start_offset (gdbarch
, 0);
1408 set_gdbarch_max_register_raw_size (gdbarch
, 8);
1409 set_gdbarch_max_register_virtual_size (gdbarch
, 8);
1410 set_gdbarch_breakpoint_from_pc (gdbarch
, s390_breakpoint_from_pc
);
1411 set_gdbarch_skip_prologue (gdbarch
, s390_skip_prologue
);
1412 set_gdbarch_init_extra_frame_info (gdbarch
, s390_init_extra_frame_info
);
1413 set_gdbarch_init_frame_pc_first (gdbarch
, s390_init_frame_pc_first
);
1414 set_gdbarch_read_fp (gdbarch
, s390_read_fp
);
1415 set_gdbarch_write_fp (gdbarch
, s390_write_fp
);
1416 /* This function that tells us whether the function invocation represented
1417 by FI does not have a frame on the stack associated with it. If it
1418 does not, FRAMELESS is set to 1, else 0. */
1419 set_gdbarch_frameless_function_invocation (gdbarch
,
1420 s390_frameless_function_invocation
);
1421 /* Return saved PC from a frame */
1422 set_gdbarch_frame_saved_pc (gdbarch
, s390_frame_saved_pc
);
1423 /* FRAME_CHAIN takes a frame's nominal address
1424 and produces the frame's chain-pointer. */
1425 set_gdbarch_frame_chain (gdbarch
, s390_frame_chain
);
1426 set_gdbarch_saved_pc_after_call (gdbarch
, s390_saved_pc_after_call
);
1427 set_gdbarch_register_byte (gdbarch
, s390_register_byte
);
1428 set_gdbarch_pc_regnum (gdbarch
, S390_PC_REGNUM
);
1429 set_gdbarch_sp_regnum (gdbarch
, S390_SP_REGNUM
);
1430 set_gdbarch_fp_regnum (gdbarch
, S390_FP_REGNUM
);
1431 set_gdbarch_fp0_regnum (gdbarch
, S390_FP0_REGNUM
);
1432 set_gdbarch_num_regs (gdbarch
, S390_NUM_REGS
);
1433 set_gdbarch_cannot_fetch_register (gdbarch
, s390_cannot_fetch_register
);
1434 set_gdbarch_cannot_store_register (gdbarch
, s390_cannot_fetch_register
);
1435 set_gdbarch_get_saved_register (gdbarch
, generic_get_saved_register
);
1436 set_gdbarch_use_struct_convention (gdbarch
, generic_use_struct_convention
);
1437 set_gdbarch_frame_chain_valid (gdbarch
, file_frame_chain_valid
);
1438 set_gdbarch_register_name (gdbarch
, s390_register_name
);
1439 set_gdbarch_stab_reg_to_regnum (gdbarch
, s390_stab_reg_to_regnum
);
1440 set_gdbarch_dwarf_reg_to_regnum (gdbarch
, s390_stab_reg_to_regnum
);
1441 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, s390_stab_reg_to_regnum
);
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 */