projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* run.c (usage): Fix typos.
[deliverable/binutils-gdb.git] / gdb / s390-tdep.c
CommitLineData
5769d3cd 1/* Target-dependent code for GDB, the GNU debugger.
ca557f44 2
1e698235 3 Copyright 2001, 2002, 2003 Free Software Foundation, Inc.
ca557f44 4
5769d3cd
AC		 5 Contributed by D.J. Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
6 for IBM Deutschland Entwicklung GmbH, IBM Corporation.
7
8 This file is part of GDB.
9
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
14
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
23 02111-1307, USA. */
24
25#define S390_TDEP /* for special macros in tm-s390.h */
26#include <defs.h>
27#include "arch-utils.h"
28#include "frame.h"
29#include "inferior.h"
30#include "symtab.h"
31#include "target.h"
32#include "gdbcore.h"
33#include "gdbcmd.h"
34#include "symfile.h"
35#include "objfiles.h"
36#include "tm.h"
37#include "../bfd/bfd.h"
38#include "floatformat.h"
39#include "regcache.h"
fd0407d6 40#include "value.h"
78f8b424 41#include "gdb_assert.h"
5769d3cd
AC		 42
43
44
60e6cc42 45
5769d3cd 46/* Number of bytes of storage in the actual machine representation
23b7362f 47 for register N. */
5769d3cd
AC		 48int
49s390_register_raw_size (int reg_nr)
50{
23b7362f
JB		 51 if (S390_FP0_REGNUM <= reg_nr
52 && reg_nr < S390_FP0_REGNUM + S390_NUM_FPRS)
53 return S390_FPR_SIZE;
54 else
55 return 4;
5769d3cd
AC		 56}
57
58int
59s390x_register_raw_size (int reg_nr)
60{
61 return (reg_nr == S390_FPC_REGNUM)
62 || (reg_nr >= S390_FIRST_ACR && reg_nr <= S390_LAST_ACR) ? 4 : 8;
63}
64
65int
66s390_cannot_fetch_register (int regno)
67{
68 return (regno >= S390_FIRST_CR && regno < (S390_FIRST_CR + 9)) ||
69 (regno >= (S390_FIRST_CR + 12) && regno <= S390_LAST_CR);
70}
71
72int
73s390_register_byte (int reg_nr)
74{
75 if (reg_nr <= S390_GP_LAST_REGNUM)
76 return reg_nr * S390_GPR_SIZE;
77 if (reg_nr <= S390_LAST_ACR)
78 return S390_ACR0_OFFSET + (((reg_nr) - S390_FIRST_ACR) * S390_ACR_SIZE);
79 if (reg_nr <= S390_LAST_CR)
80 return S390_CR0_OFFSET + (((reg_nr) - S390_FIRST_CR) * S390_CR_SIZE);
81 if (reg_nr == S390_FPC_REGNUM)
82 return S390_FPC_OFFSET;
83 else
84 return S390_FP0_OFFSET + (((reg_nr) - S390_FP0_REGNUM) * S390_FPR_SIZE);
85}
86
87#ifndef GDBSERVER
88#define S390_MAX_INSTR_SIZE (6)
89#define S390_SYSCALL_OPCODE (0x0a)
90#define S390_SYSCALL_SIZE (2)
91#define S390_SIGCONTEXT_SREGS_OFFSET (8)
92#define S390X_SIGCONTEXT_SREGS_OFFSET (8)
93#define S390_SIGREGS_FP0_OFFSET (144)
94#define S390X_SIGREGS_FP0_OFFSET (216)
95#define S390_UC_MCONTEXT_OFFSET (256)
96#define S390X_UC_MCONTEXT_OFFSET (344)
97#define S390_STACK_FRAME_OVERHEAD (GDB_TARGET_IS_ESAME ? 160:96)
98#define S390_SIGNAL_FRAMESIZE (GDB_TARGET_IS_ESAME ? 160:96)
99#define s390_NR_sigreturn 119
100#define s390_NR_rt_sigreturn 173
101
102
103
104struct frame_extra_info
105{
106 int initialised;
107 int good_prologue;
108 CORE_ADDR function_start;
109 CORE_ADDR skip_prologue_function_start;
110 CORE_ADDR saved_pc_valid;
111 CORE_ADDR saved_pc;
112 CORE_ADDR sig_fixed_saved_pc_valid;
113 CORE_ADDR sig_fixed_saved_pc;
114 CORE_ADDR frame_pointer_saved_pc; /* frame pointer needed for alloca */
115 CORE_ADDR stack_bought; /* amount we decrement the stack pointer by */
116 CORE_ADDR sigcontext;
117};
118
119
120static CORE_ADDR s390_frame_saved_pc_nofix (struct frame_info *fi);
121
122int
123s390_readinstruction (bfd_byte instr[], CORE_ADDR at,
124 struct disassemble_info *info)
125{
126 int instrlen;
127
128 static int s390_instrlen[] = {
129 2,
130 4,
131 4,
132 6
133 };
134 if ((*info->read_memory_func) (at, &instr[0], 2, info))
135 return -1;
136 instrlen = s390_instrlen[instr[0] >> 6];
c5e243bb
JB		 137 if (instrlen > 2)
138 {
139 if ((*info->read_memory_func) (at + 2, &instr[2], instrlen - 2, info))
140 return -1;
141 }
5769d3cd
AC		 142 return instrlen;
143}
144
145static void
146s390_memset_extra_info (struct frame_extra_info *fextra_info)
147{
148 memset (fextra_info, 0, sizeof (struct frame_extra_info));
149}
150
151
152
fa88f677 153const char *
5769d3cd
AC		 154s390_register_name (int reg_nr)
155{
156 static char *register_names[] = {
157 "pswm", "pswa",
4ed90530
JB		 158 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
159 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
5769d3cd
AC		 160 "acr0", "acr1", "acr2", "acr3", "acr4", "acr5", "acr6", "acr7",
161 "acr8", "acr9", "acr10", "acr11", "acr12", "acr13", "acr14", "acr15",
162 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
163 "cr8", "cr9", "cr10", "cr11", "cr12", "cr13", "cr14", "cr15",
164 "fpc",
4ed90530
JB		 165 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
166 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15"
5769d3cd
AC		 167 };
168
b09677dc
JB		 169 if (reg_nr <= S390_LAST_REGNUM)
170 return register_names[reg_nr];
171 else
5769d3cd 172 return NULL;
5769d3cd
AC		 173}
174
175
176
177
178int
179s390_stab_reg_to_regnum (int regno)
180{
181 return regno >= 64 ? S390_PSWM_REGNUM - 64 :
182 regno >= 48 ? S390_FIRST_ACR - 48 :
183 regno >= 32 ? S390_FIRST_CR - 32 :
184 regno <= 15 ? (regno + 2) :
185 S390_FP0_REGNUM + ((regno - 16) & 8) + (((regno - 16) & 3) << 1) +
186 (((regno - 16) & 4) >> 2);
187}
188
189
12bffad7
JB		 190/* Return true if REGIDX is the number of a register used to pass
191 arguments, false otherwise. */
192static int
193is_arg_reg (int regidx)
194{
195 return 2 <= regidx && regidx <= 6;
196}
197
5769d3cd
AC		 198
199/* s390_get_frame_info based on Hartmuts
200 prologue definition in
201 gcc-2.8.1/config/l390/linux.c
202
203 It reads one instruction at a time & based on whether
204 it looks like prologue code or not it makes a decision on
205 whether the prologue is over, there are various state machines
206 in the code to determine if the prologue code is possilby valid.
207
208 This is done to hopefully allow the code survive minor revs of
209 calling conventions.
210
211 */
212
213int
214s390_get_frame_info (CORE_ADDR pc, struct frame_extra_info *fextra_info,
215 struct frame_info *fi, int init_extra_info)
216{
217#define CONST_POOL_REGIDX 13
218#define GOT_REGIDX 12
219 bfd_byte instr[S390_MAX_INSTR_SIZE];
220 CORE_ADDR test_pc = pc, test_pc2;
221 CORE_ADDR orig_sp = 0, save_reg_addr = 0, *saved_regs = NULL;
222 int valid_prologue, good_prologue = 0;
223 int gprs_saved[S390_NUM_GPRS];
224 int fprs_saved[S390_NUM_FPRS];
225 int regidx, instrlen;
6df29de2 226 int const_pool_state;
7286245e 227 int varargs_state;
5769d3cd 228 int loop_cnt, gdb_gpr_store, gdb_fpr_store;
5769d3cd
AC		 229 int offset, expected_offset;
230 int err = 0;
231 disassemble_info info;
8ac0e65a 232
7286245e
JB		 233 /* Have we seen an instruction initializing the frame pointer yet?
234 If we've seen an `lr %r11, %r15', then frame_pointer_found is
235 non-zero, and frame_pointer_regidx == 11. Otherwise,
236 frame_pointer_found is zero and frame_pointer_regidx is 15,
237 indicating that we're using the stack pointer as our frame
238 pointer. */
239 int frame_pointer_found = 0;
240 int frame_pointer_regidx = 0xf;
241
6df29de2
JB		 242 /* What we've seen so far regarding saving the back chain link:
243 0 -- nothing yet; sp still has the same value it had at the entry
244 point. Since not all functions allocate frames, this is a
245 valid state for the prologue to finish in.
246 1 -- We've saved the original sp in some register other than the
247 frame pointer (hard-coded to be %r11, yuck).
248 save_link_regidx is the register we saved it in.
249 2 -- We've seen the initial `bras' instruction of the sequence for
250 reserving more than 32k of stack:
251 bras %rX, .+8
252 .long N
253 s %r15, 0(%rX)
254 where %rX is not the constant pool register.
255 subtract_sp_regidx is %rX, and fextra_info->stack_bought is N.
256 3 -- We've reserved space for a new stack frame. This means we
257 either saw a simple `ahi %r15,-N' in state 1, or the final
258 `s %r15, ...' in state 2.
259 4 -- The frame and link are now fully initialized. We've
260 reserved space for the new stack frame, and stored the old
261 stack pointer captured in the back chain pointer field. */
7286245e 262 int save_link_state = 0;
6df29de2
JB		 263 int save_link_regidx, subtract_sp_regidx;
264
8ac0e65a
JB		 265 /* What we've seen so far regarding r12 --- the GOT (Global Offset
266 Table) pointer. We expect to see `l %r12, N(%r13)', which loads
267 r12 with the offset from the constant pool to the GOT, and then
268 an `ar %r12, %r13', which adds the constant pool address,
269 yielding the GOT's address. Here's what got_state means:
270 0 -- seen nothing
271 1 -- seen `l %r12, N(%r13)', but no `ar'
272 2 -- seen load and add, so GOT pointer is totally initialized
273 When got_state is 1, then got_load_addr is the address of the
274 load instruction, and got_load_len is the length of that
275 instruction. */
7286245e 276 int got_state= 0;
64f9bb98 277 CORE_ADDR got_load_addr = 0, got_load_len = 0;
8ac0e65a 278
7286245e
JB		 279 const_pool_state = varargs_state = 0;
280
5769d3cd
AC		 281 memset (gprs_saved, 0, sizeof (gprs_saved));
282 memset (fprs_saved, 0, sizeof (fprs_saved));
283 info.read_memory_func = dis_asm_read_memory;
284
285 save_link_regidx = subtract_sp_regidx = 0;
286 if (fextra_info)
287 {
1e2330ba 288 if (fi && get_frame_base (fi))
5769d3cd 289 {
1e2330ba 290 orig_sp = get_frame_base (fi);
386e4208 291 if (! init_extra_info && fextra_info->initialised)
76cc2cf0 292 orig_sp += fextra_info->stack_bought;
b2fb4676 293 saved_regs = get_frame_saved_regs (fi);
5769d3cd
AC		 294 }
295 if (init_extra_info || !fextra_info->initialised)
296 {
297 s390_memset_extra_info (fextra_info);
298 fextra_info->function_start = pc;
299 fextra_info->initialised = 1;
300 }
301 }
302 instrlen = 0;
303 do
304 {
305 valid_prologue = 0;
306 test_pc += instrlen;
307 /* add the previous instruction len */
308 instrlen = s390_readinstruction (instr, test_pc, &info);
309 if (instrlen < 0)
310 {
311 good_prologue = 0;
312 err = -1;
313 break;
314 }
315 /* We probably are in a glibc syscall */
316 if (instr[0] == S390_SYSCALL_OPCODE && test_pc == pc)
317 {
318 good_prologue = 1;
11c02a10
AC		 319 if (saved_regs && fextra_info && get_next_frame (fi)
320 && get_next_frame (fi)->extra_info
321 && get_next_frame (fi)->extra_info->sigcontext)
5769d3cd
AC		 322 {
323 /* We are backtracing from a signal handler */
11c02a10 324 save_reg_addr = get_next_frame (fi)->extra_info->sigcontext +
5769d3cd
AC		 325 REGISTER_BYTE (S390_GP0_REGNUM);
326 for (regidx = 0; regidx < S390_NUM_GPRS; regidx++)
327 {
328 saved_regs[S390_GP0_REGNUM + regidx] = save_reg_addr;
329 save_reg_addr += S390_GPR_SIZE;
330 }
11c02a10 331 save_reg_addr = get_next_frame (fi)->extra_info->sigcontext +
5769d3cd
AC		 332 (GDB_TARGET_IS_ESAME ? S390X_SIGREGS_FP0_OFFSET :
333 S390_SIGREGS_FP0_OFFSET);
334 for (regidx = 0; regidx < S390_NUM_FPRS; regidx++)
335 {
336 saved_regs[S390_FP0_REGNUM + regidx] = save_reg_addr;
337 save_reg_addr += S390_FPR_SIZE;
338 }
339 }
340 break;
341 }
342 if (save_link_state == 0)
343 {
344 /* check for a stack relative STMG or STM */
345 if (((GDB_TARGET_IS_ESAME &&
346 ((instr[0] == 0xeb) && (instr[5] == 0x24))) ||
347 (instr[0] == 0x90)) && ((instr[2] >> 4) == 0xf))
348 {
349 regidx = (instr[1] >> 4);
350 if (regidx < 6)
351 varargs_state = 1;
352 offset = ((instr[2] & 0xf) << 8) + instr[3];
353 expected_offset =
354 S390_GPR6_STACK_OFFSET + (S390_GPR_SIZE * (regidx - 6));
355 if (offset != expected_offset)
356 {
357 good_prologue = 0;
358 break;
359 }
360 if (saved_regs)
361 save_reg_addr = orig_sp + offset;
362 for (; regidx <= (instr[1] & 0xf); regidx++)
363 {
364 if (gprs_saved[regidx])
365 {
366 good_prologue = 0;
367 break;
368 }
369 good_prologue = 1;
370 gprs_saved[regidx] = 1;
371 if (saved_regs)
372 {
373 saved_regs[S390_GP0_REGNUM + regidx] = save_reg_addr;
374 save_reg_addr += S390_GPR_SIZE;
375 }
376 }
377 valid_prologue = 1;
378 continue;
379 }
380 }
381 /* check for a stack relative STG or ST */
382 if ((save_link_state == 0 || save_link_state == 3) &&
383 ((GDB_TARGET_IS_ESAME &&
384 ((instr[0] == 0xe3) && (instr[5] == 0x24))) ||
385 (instr[0] == 0x50)) && ((instr[2] >> 4) == 0xf))
386 {
387 regidx = instr[1] >> 4;
388 offset = ((instr[2] & 0xf) << 8) + instr[3];
389 if (offset == 0)
390 {
391 if (save_link_state == 3 && regidx == save_link_regidx)
392 {
393 save_link_state = 4;
394 valid_prologue = 1;
395 continue;
396 }
397 else
398 break;
399 }
400 if (regidx < 6)
401 varargs_state = 1;
402 expected_offset =
403 S390_GPR6_STACK_OFFSET + (S390_GPR_SIZE * (regidx - 6));
404 if (offset != expected_offset)
405 {
406 good_prologue = 0;
407 break;
408 }
409 if (gprs_saved[regidx])
410 {
411 good_prologue = 0;
412 break;
413 }
414 good_prologue = 1;
415 gprs_saved[regidx] = 1;
416 if (saved_regs)
417 {
418 save_reg_addr = orig_sp + offset;
419 saved_regs[S390_GP0_REGNUM + regidx] = save_reg_addr;
420 }
421 valid_prologue = 1;
422 continue;
423 }
424
12bffad7 425 /* Check for an fp-relative STG, ST, or STM. This is probably
7666f43c
JB		 426 spilling an argument from a register out into a stack slot.
427 This could be a user instruction, but if we haven't included
428 any other suspicious instructions in the prologue, this
429 could only be an initializing store, which isn't too bad to
430 skip. The consequences of not including arg-to-stack spills
431 are more serious, though --- you don't see the proper values
432 of the arguments. */
433 if ((save_link_state == 3 || save_link_state == 4)
12bffad7
JB		 434 && ((instr[0] == 0x50 /* st %rA, D(%rX,%rB) */
435 && (instr[1] & 0xf) == 0 /* %rX is zero, no index reg */
436 && is_arg_reg ((instr[1] >> 4) & 0xf)
437 && ((instr[2] >> 4) & 0xf) == frame_pointer_regidx)
438 || (instr[0] == 0x90 /* stm %rA, %rB, D(%rC) */
439 && is_arg_reg ((instr[1] >> 4) & 0xf)
440 && is_arg_reg (instr[1] & 0xf)
441 && ((instr[2] >> 4) & 0xf) == frame_pointer_regidx)))
7666f43c
JB		 442 {
443 valid_prologue = 1;
444 continue;
445 }
446
5769d3cd
AC		 447 /* check for STD */
448 if (instr[0] == 0x60 && (instr[2] >> 4) == 0xf)
449 {
450 regidx = instr[1] >> 4;
451 if (regidx == 0 || regidx == 2)
452 varargs_state = 1;
453 if (fprs_saved[regidx])
454 {
455 good_prologue = 0;
456 break;
457 }
458 fprs_saved[regidx] = 1;
459 if (saved_regs)
460 {
461 save_reg_addr = orig_sp + (((instr[2] & 0xf) << 8) + instr[3]);
462 saved_regs[S390_FP0_REGNUM + regidx] = save_reg_addr;
463 }
464 valid_prologue = 1;
465 continue;
466 }
467
468
469 if (const_pool_state == 0)
470 {
471
472 if (GDB_TARGET_IS_ESAME)
473 {
474 /* Check for larl CONST_POOL_REGIDX,offset on ESAME */
475 if ((instr[0] == 0xc0)
476 && (instr[1] == (CONST_POOL_REGIDX << 4)))
477 {
478 const_pool_state = 2;
479 valid_prologue = 1;
480 continue;
481 }
482 }
483 else
484 {
485 /* Check for BASR gpr13,gpr0 used to load constant pool pointer to r13 in old compiler */
486 if (instr[0] == 0xd && (instr[1] & 0xf) == 0
487 && ((instr[1] >> 4) == CONST_POOL_REGIDX))
488 {
489 const_pool_state = 1;
490 valid_prologue = 1;
491 continue;
492 }
493 }
494 /* Check for new fangled bras %r13,newpc to load new constant pool */
495 /* embedded in code, older pre abi compilers also emitted this stuff. */
496 if ((instr[0] == 0xa7) && ((instr[1] & 0xf) == 0x5) &&
497 ((instr[1] >> 4) == CONST_POOL_REGIDX)
498 && ((instr[2] & 0x80) == 0))
499 {
500 const_pool_state = 2;
501 test_pc +=
502 (((((instr[2] & 0xf) << 8) + instr[3]) << 1) - instrlen);
503 valid_prologue = 1;
504 continue;
505 }
506 }
507 /* Check for AGHI or AHI CONST_POOL_REGIDX,val */
508 if (const_pool_state == 1 && (instr[0] == 0xa7) &&
509 ((GDB_TARGET_IS_ESAME &&
510 (instr[1] == ((CONST_POOL_REGIDX << 4) | 0xb))) ||
511 (instr[1] == ((CONST_POOL_REGIDX << 4) | 0xa))))
512 {
513 const_pool_state = 2;
514 valid_prologue = 1;
515 continue;
516 }
517 /* Check for LGR or LR gprx,15 */
518 if ((GDB_TARGET_IS_ESAME &&
519 instr[0] == 0xb9 && instr[1] == 0x04 && (instr[3] & 0xf) == 0xf) ||
520 (instr[0] == 0x18 && (instr[1] & 0xf) == 0xf))
521 {
522 if (GDB_TARGET_IS_ESAME)
523 regidx = instr[3] >> 4;
524 else
525 regidx = instr[1] >> 4;
526 if (save_link_state == 0 && regidx != 0xb)
527 {
528 /* Almost defintely code for
529 decrementing the stack pointer
530 ( i.e. a non leaf function
531 or else leaf with locals ) */
532 save_link_regidx = regidx;
533 save_link_state = 1;
534 valid_prologue = 1;
535 continue;
536 }
537 /* We use this frame pointer for alloca
538 unfortunately we need to assume its gpr11
539 otherwise we would need a smarter prologue
540 walker. */
541 if (!frame_pointer_found && regidx == 0xb)
542 {
543 frame_pointer_regidx = 0xb;
544 frame_pointer_found = 1;
545 if (fextra_info)
546 fextra_info->frame_pointer_saved_pc = test_pc;
547 valid_prologue = 1;
548 continue;
549 }
550 }
551 /* Check for AHI or AGHI gpr15,val */
552 if (save_link_state == 1 && (instr[0] == 0xa7) &&
553 ((GDB_TARGET_IS_ESAME && (instr[1] == 0xfb)) || (instr[1] == 0xfa)))
554 {
555 if (fextra_info)
556 fextra_info->stack_bought =
557 -extract_signed_integer (&instr[2], 2);
558 save_link_state = 3;
559 valid_prologue = 1;
560 continue;
561 }
562 /* Alternatively check for the complex construction for
563 buying more than 32k of stack
564 BRAS gprx,.+8
6df29de2
JB		 565 long val
566 s %r15,0(%gprx) gprx currently r1 */
5769d3cd
AC		 567 if ((save_link_state == 1) && (instr[0] == 0xa7)
568 && ((instr[1] & 0xf) == 0x5) && (instr[2] == 0)
569 && (instr[3] == 0x4) && ((instr[1] >> 4) != CONST_POOL_REGIDX))
570 {
571 subtract_sp_regidx = instr[1] >> 4;
572 save_link_state = 2;
573 if (fextra_info)
574 target_read_memory (test_pc + instrlen,
575 (char *) &fextra_info->stack_bought,
576 sizeof (fextra_info->stack_bought));
577 test_pc += 4;
578 valid_prologue = 1;
579 continue;
580 }
581 if (save_link_state == 2 && instr[0] == 0x5b
582 && instr[1] == 0xf0 &&
583 instr[2] == (subtract_sp_regidx << 4) && instr[3] == 0)
584 {
585 save_link_state = 3;
586 valid_prologue = 1;
587 continue;
588 }
589 /* check for LA gprx,offset(15) used for varargs */
590 if ((instr[0] == 0x41) && ((instr[2] >> 4) == 0xf) &&
591 ((instr[1] & 0xf) == 0))
592 {
593 /* some code uses gpr7 to point to outgoing args */
594 if (((instr[1] >> 4) == 7) && (save_link_state == 0) &&
595 ((instr[2] & 0xf) == 0)
596 && (instr[3] == S390_STACK_FRAME_OVERHEAD))
597 {
598 valid_prologue = 1;
599 continue;
600 }
601 if (varargs_state == 1)
602 {
603 varargs_state = 2;
604 valid_prologue = 1;
605 continue;
606 }
607 }
608 /* Check for a GOT load */
609
610 if (GDB_TARGET_IS_ESAME)
611 {
612 /* Check for larl GOT_REGIDX, on ESAME */
613 if ((got_state == 0) && (instr[0] == 0xc0)
614 && (instr[1] == (GOT_REGIDX << 4)))
615 {
616 got_state = 2;
617 valid_prologue = 1;
618 continue;
619 }
620 }
621 else
622 {
623 /* check for l GOT_REGIDX,x(CONST_POOL_REGIDX) */
624 if (got_state == 0 && const_pool_state == 2 && instr[0] == 0x58
625 && (instr[2] == (CONST_POOL_REGIDX << 4))
626 && ((instr[1] >> 4) == GOT_REGIDX))
627 {
8ac0e65a
JB		 628 got_state = 1;
629 got_load_addr = test_pc;
630 got_load_len = instrlen;
5769d3cd
AC		 631 valid_prologue = 1;
632 continue;
633 }
634 /* Check for subsequent ar got_regidx,basr_regidx */
635 if (got_state == 1 && instr[0] == 0x1a &&
636 instr[1] == ((GOT_REGIDX << 4) | CONST_POOL_REGIDX))
637 {
638 got_state = 2;
639 valid_prologue = 1;
640 continue;
641 }
642 }
643 }
644 while (valid_prologue && good_prologue);
645 if (good_prologue)
646 {
8ac0e65a
JB		 647 /* If this function doesn't reference the global offset table,
648 then the compiler may use r12 for other things. If the last
649 instruction we saw was a load of r12 from the constant pool,
650 with no subsequent add to make the address PC-relative, then
651 the load was probably a genuine body instruction; don't treat
652 it as part of the prologue. */
653 if (got_state == 1
654 && got_load_addr + got_load_len == test_pc)
655 {
656 test_pc = got_load_addr;
657 instrlen = got_load_len;
658 }
659
660 good_prologue = (((const_pool_state == 0) || (const_pool_state == 2)) &&
5769d3cd
AC		 661 ((save_link_state == 0) || (save_link_state == 4)) &&
662 ((varargs_state == 0) || (varargs_state == 2)));
663 }
664 if (fextra_info)
665 {
666 fextra_info->good_prologue = good_prologue;
667 fextra_info->skip_prologue_function_start =
668 (good_prologue ? test_pc : pc);
669 }
09025237
JB		 670 if (saved_regs)
671 /* The SP's element of the saved_regs array holds the old SP,
672 not the address at which it is saved. */
673 saved_regs[S390_SP_REGNUM] = orig_sp;
5769d3cd
AC		 674 return err;
675}
676
677
678int
679s390_check_function_end (CORE_ADDR pc)
680{
681 bfd_byte instr[S390_MAX_INSTR_SIZE];
682 disassemble_info info;
683 int regidx, instrlen;
684
685 info.read_memory_func = dis_asm_read_memory;
686 instrlen = s390_readinstruction (instr, pc, &info);
687 if (instrlen < 0)
688 return -1;
689 /* check for BR */
690 if (instrlen != 2 || instr[0] != 07 || (instr[1] >> 4) != 0xf)
691 return 0;
692 regidx = instr[1] & 0xf;
693 /* Check for LMG or LG */
694 instrlen =
695 s390_readinstruction (instr, pc - (GDB_TARGET_IS_ESAME ? 6 : 4), &info);
696 if (instrlen < 0)
697 return -1;
698 if (GDB_TARGET_IS_ESAME)
699 {
700
701 if (instrlen != 6 || instr[0] != 0xeb || instr[5] != 0x4)
702 return 0;
703 }
704 else if (instrlen != 4 || instr[0] != 0x98)
705 {
706 return 0;
707 }
708 if ((instr[2] >> 4) != 0xf)
709 return 0;
710 if (regidx == 14)
711 return 1;
712 instrlen = s390_readinstruction (instr, pc - (GDB_TARGET_IS_ESAME ? 12 : 8),
713 &info);
714 if (instrlen < 0)
715 return -1;
716 if (GDB_TARGET_IS_ESAME)
717 {
718 /* Check for LG */
719 if (instrlen != 6 || instr[0] != 0xe3 || instr[5] != 0x4)
720 return 0;
721 }
722 else
723 {
724 /* Check for L */
725 if (instrlen != 4 || instr[0] != 0x58)
726 return 0;
727 }
728 if (instr[2] >> 4 != 0xf)
729 return 0;
730 if (instr[1] >> 4 != regidx)
731 return 0;
732 return 1;
733}
734
735static CORE_ADDR
736s390_sniff_pc_function_start (CORE_ADDR pc, struct frame_info *fi)
737{
738 CORE_ADDR function_start, test_function_start;
739 int loop_cnt, err, function_end;
740 struct frame_extra_info fextra_info;
741 function_start = get_pc_function_start (pc);
742
743 if (function_start == 0)
744 {
745 test_function_start = pc;
746 if (test_function_start & 1)
747 return 0; /* This has to be bogus */
748 loop_cnt = 0;
749 do
750 {
751
752 err =
753 s390_get_frame_info (test_function_start, &fextra_info, fi, 1);
754 loop_cnt++;
755 test_function_start -= 2;
756 function_end = s390_check_function_end (test_function_start);
757 }
758 while (!(function_end == 1 || err || loop_cnt >= 4096 ||
759 (fextra_info.good_prologue)));
760 if (fextra_info.good_prologue)
761 function_start = fextra_info.function_start;
762 else if (function_end == 1)
763 function_start = test_function_start;
764 }
765 return function_start;
766}
767
768
769
770CORE_ADDR
771s390_function_start (struct frame_info *fi)
772{
773 CORE_ADDR function_start = 0;
774
775 if (fi->extra_info && fi->extra_info->initialised)
776 function_start = fi->extra_info->function_start;
50abf9e5
AC		 777 else if (get_frame_pc (fi))
778 function_start = get_pc_function_start (get_frame_pc (fi));
5769d3cd
AC		 779 return function_start;
780}
781
782
783
784
785int
786s390_frameless_function_invocation (struct frame_info *fi)
787{
788 struct frame_extra_info fextra_info, *fextra_info_ptr;
789 int frameless = 0;
790
11c02a10 791 if (get_next_frame (fi) == NULL) /* no may be frameless */
5769d3cd
AC		 792 {
793 if (fi->extra_info)
794 fextra_info_ptr = fi->extra_info;
795 else
796 {
797 fextra_info_ptr = &fextra_info;
50abf9e5 798 s390_get_frame_info (s390_sniff_pc_function_start (get_frame_pc (fi), fi),
5769d3cd
AC		 799 fextra_info_ptr, fi, 1);
800 }
801 frameless = ((fextra_info_ptr->stack_bought == 0));
802 }
803 return frameless;
804
805}
806
807
808static int
809s390_is_sigreturn (CORE_ADDR pc, struct frame_info *sighandler_fi,
810 CORE_ADDR *sregs, CORE_ADDR *sigcaller_pc)
811{
812 bfd_byte instr[S390_MAX_INSTR_SIZE];
813 disassemble_info info;
814 int instrlen;
815 CORE_ADDR scontext;
816 int retval = 0;
817 CORE_ADDR orig_sp;
818 CORE_ADDR temp_sregs;
819
820 scontext = temp_sregs = 0;
821
822 info.read_memory_func = dis_asm_read_memory;
823 instrlen = s390_readinstruction (instr, pc, &info);
824 if (sigcaller_pc)
825 *sigcaller_pc = 0;
826 if (((instrlen == S390_SYSCALL_SIZE) &&
827 (instr[0] == S390_SYSCALL_OPCODE)) &&
828 ((instr[1] == s390_NR_sigreturn) || (instr[1] == s390_NR_rt_sigreturn)))
829 {
830 if (sighandler_fi)
831 {
832 if (s390_frameless_function_invocation (sighandler_fi))
1e2330ba 833 orig_sp = get_frame_base (sighandler_fi);
5769d3cd
AC		 834 else
835 orig_sp = ADDR_BITS_REMOVE ((CORE_ADDR)
1e2330ba 836 read_memory_integer (get_frame_base (sighandler_fi),
5769d3cd
AC		 837 S390_GPR_SIZE));
838 if (orig_sp && sigcaller_pc)
839 {
840 scontext = orig_sp + S390_SIGNAL_FRAMESIZE;
841 if (pc == scontext && instr[1] == s390_NR_rt_sigreturn)
842 {
843 /* We got a new style rt_signal */
844 /* get address of read ucontext->uc_mcontext */
845 temp_sregs = orig_sp + (GDB_TARGET_IS_ESAME ?
846 S390X_UC_MCONTEXT_OFFSET :
847 S390_UC_MCONTEXT_OFFSET);
848 }
849 else
850 {
851 /* read sigcontext->sregs */
852 temp_sregs = ADDR_BITS_REMOVE ((CORE_ADDR)
853 read_memory_integer (scontext
854 +
855 (GDB_TARGET_IS_ESAME
856 ?
857 S390X_SIGCONTEXT_SREGS_OFFSET
858 :
859 S390_SIGCONTEXT_SREGS_OFFSET),
860 S390_GPR_SIZE));
861
862 }
863 /* read sigregs->psw.addr */
864 *sigcaller_pc =
865 ADDR_BITS_REMOVE ((CORE_ADDR)
866 read_memory_integer (temp_sregs +
867 REGISTER_BYTE
868 (S390_PC_REGNUM),
869 S390_PSW_ADDR_SIZE));
870 }
871 }
872 retval = 1;
873 }
874 if (sregs)
875 *sregs = temp_sregs;
876 return retval;
877}
878
879/*
880 We need to do something better here but this will keep us out of trouble
881 for the moment.
882 For some reason the blockframe.c calls us with fi->next->fromleaf
883 so this seems of little use to us. */
97f46953 884CORE_ADDR
5769d3cd
AC		 885s390_init_frame_pc_first (int next_fromleaf, struct frame_info *fi)
886{
887 CORE_ADDR sigcaller_pc;
97f46953 888 CORE_ADDR pc = 0;
5769d3cd
AC		 889 if (next_fromleaf)
890 {
97f46953 891 pc = ADDR_BITS_REMOVE (read_register (S390_RETADDR_REGNUM));
5769d3cd
AC		 892 /* fix signal handlers */
893 }
97f46953
AC		 894 else if (get_next_frame (fi) && get_frame_pc (get_next_frame (fi)))
895 pc = s390_frame_saved_pc_nofix (get_next_frame (fi));
896 if (pc && get_next_frame (fi) && get_frame_base (get_next_frame (fi))
897 && s390_is_sigreturn (pc, get_next_frame (fi), NULL, &sigcaller_pc))
5769d3cd 898 {
97f46953 899 pc = sigcaller_pc;
5769d3cd 900 }
97f46953 901 return pc;
5769d3cd
AC		 902}
903
904void
905s390_init_extra_frame_info (int fromleaf, struct frame_info *fi)
906{
a00a19e9 907 frame_extra_info_zalloc (fi, sizeof (struct frame_extra_info));
50abf9e5
AC		 908 if (get_frame_pc (fi))
909 s390_get_frame_info (s390_sniff_pc_function_start (get_frame_pc (fi), fi),
5769d3cd
AC		 910 fi->extra_info, fi, 1);
911 else
912 s390_memset_extra_info (fi->extra_info);
913}
914
915/* If saved registers of frame FI are not known yet, read and cache them.
916 &FEXTRA_INFOP contains struct frame_extra_info; TDATAP can be NULL,
917 in which case the framedata are read. */
918
919void
920s390_frame_init_saved_regs (struct frame_info *fi)
921{
922
923 int quick;
924
b2fb4676 925 if (get_frame_saved_regs (fi) == NULL)
5769d3cd
AC		 926 {
927 /* zalloc memsets the saved regs */
928 frame_saved_regs_zalloc (fi);
50abf9e5 929 if (get_frame_pc (fi))
5769d3cd
AC		 930 {
931 quick = (fi->extra_info && fi->extra_info->initialised
932 && fi->extra_info->good_prologue);
933 s390_get_frame_info (quick ? fi->extra_info->function_start :
50abf9e5 934 s390_sniff_pc_function_start (get_frame_pc (fi), fi),
5769d3cd
AC		 935 fi->extra_info, fi, !quick);
936 }
937 }
938}
939
940
941
942CORE_ADDR
943s390_frame_args_address (struct frame_info *fi)
944{
945
946 /* Apparently gdb already knows gdb_args_offset itself */
1e2330ba 947 return get_frame_base (fi);
5769d3cd
AC		 948}
949
950
951static CORE_ADDR
952s390_frame_saved_pc_nofix (struct frame_info *fi)
953{
954 if (fi->extra_info && fi->extra_info->saved_pc_valid)
955 return fi->extra_info->saved_pc;
5c3cf190 956
1e2330ba
AC		 957 if (deprecated_generic_find_dummy_frame (get_frame_pc (fi),
958 get_frame_base (fi)))
959 return deprecated_read_register_dummy (get_frame_pc (fi),
960 get_frame_base (fi), S390_PC_REGNUM);
5c3cf190 961
5769d3cd
AC		 962 s390_frame_init_saved_regs (fi);
963 if (fi->extra_info)
964 {
965 fi->extra_info->saved_pc_valid = 1;
529765f4 966 if (fi->extra_info->good_prologue
b2fb4676 967 && get_frame_saved_regs (fi)[S390_RETADDR_REGNUM])
529765f4
JB		 968 fi->extra_info->saved_pc
969 = ADDR_BITS_REMOVE (read_memory_integer
b2fb4676 970 (get_frame_saved_regs (fi)[S390_RETADDR_REGNUM],
529765f4
JB		 971 S390_GPR_SIZE));
972 else
973 fi->extra_info->saved_pc
974 = ADDR_BITS_REMOVE (read_register (S390_RETADDR_REGNUM));
975 return fi->extra_info->saved_pc;
5769d3cd
AC		 976 }
977 return 0;
978}
979
980CORE_ADDR
981s390_frame_saved_pc (struct frame_info *fi)
982{
983 CORE_ADDR saved_pc = 0, sig_pc;
984
985 if (fi->extra_info && fi->extra_info->sig_fixed_saved_pc_valid)
986 return fi->extra_info->sig_fixed_saved_pc;
987 saved_pc = s390_frame_saved_pc_nofix (fi);
988
989 if (fi->extra_info)
990 {
991 fi->extra_info->sig_fixed_saved_pc_valid = 1;
992 if (saved_pc)
993 {
994 if (s390_is_sigreturn (saved_pc, fi, NULL, &sig_pc))
995 saved_pc = sig_pc;
996 }
997 fi->extra_info->sig_fixed_saved_pc = saved_pc;
998 }
999 return saved_pc;
1000}
1001
1002
1003
1004
5a203e44
AC		 1005/* We want backtraces out of signal handlers so we don't set
1006 (get_frame_type (thisframe) == SIGTRAMP_FRAME) to 1 */
5769d3cd
AC		 1007
1008CORE_ADDR
1009s390_frame_chain (struct frame_info *thisframe)
1010{
1011 CORE_ADDR prev_fp = 0;
1012
1e2330ba
AC		 1013 if (deprecated_generic_find_dummy_frame (get_frame_pc (thisframe),
1014 get_frame_base (thisframe)))
1015 return deprecated_read_register_dummy (get_frame_pc (thisframe),
1016 get_frame_base (thisframe),
135c175f 1017 S390_SP_REGNUM);
5769d3cd
AC		 1018 else
1019 {
1020 int sigreturn = 0;
1021 CORE_ADDR sregs = 0;
1022 struct frame_extra_info prev_fextra_info;
1023
1024 memset (&prev_fextra_info, 0, sizeof (prev_fextra_info));
50abf9e5 1025 if (get_frame_pc (thisframe))
5769d3cd
AC		 1026 {
1027 CORE_ADDR saved_pc, sig_pc;
1028
1029 saved_pc = s390_frame_saved_pc_nofix (thisframe);
1030 if (saved_pc)
1031 {
1032 if ((sigreturn =
1033 s390_is_sigreturn (saved_pc, thisframe, &sregs, &sig_pc)))
1034 saved_pc = sig_pc;
1035 s390_get_frame_info (s390_sniff_pc_function_start
1036 (saved_pc, NULL), &prev_fextra_info, NULL,
1037 1);
1038 }
1039 }
1040 if (sigreturn)
1041 {
1042 /* read sigregs,regs.gprs[11 or 15] */
1043 prev_fp = read_memory_integer (sregs +
1044 REGISTER_BYTE (S390_GP0_REGNUM +
1045 (prev_fextra_info.
1046 frame_pointer_saved_pc
1047 ? 11 : 15)),
1048 S390_GPR_SIZE);
1049 thisframe->extra_info->sigcontext = sregs;
1050 }
1051 else
1052 {
b2fb4676 1053 if (get_frame_saved_regs (thisframe))
5769d3cd 1054 {
5769d3cd
AC		 1055 int regno;
1056
31c4d430 1057 if (prev_fextra_info.frame_pointer_saved_pc
b2fb4676 1058 && get_frame_saved_regs (thisframe)[S390_FRAME_REGNUM])
31c4d430
JB		 1059 regno = S390_FRAME_REGNUM;
1060 else
1061 regno = S390_SP_REGNUM;
1062
b2fb4676 1063 if (get_frame_saved_regs (thisframe)[regno])
31c4d430
JB		 1064 {
1065 /* The SP's entry of `saved_regs' is special. */
1066 if (regno == S390_SP_REGNUM)
b2fb4676 1067 prev_fp = get_frame_saved_regs (thisframe)[regno];
31c4d430
JB		 1068 else
1069 prev_fp =
b2fb4676 1070 read_memory_integer (get_frame_saved_regs (thisframe)[regno],
31c4d430
JB		 1071 S390_GPR_SIZE);
1072 }
5769d3cd
AC		 1073 }
1074 }
1075 }
1076 return ADDR_BITS_REMOVE (prev_fp);
1077}
1078
1079/*
1080 Whether struct frame_extra_info is actually needed I'll have to figure
1081 out as our frames are similar to rs6000 there is a possibility
1082 i386 dosen't need it. */
1083
1084
1085
1086/* a given return value in `regbuf' with a type `valtype', extract and copy its
1087 value into `valbuf' */
1088void
1089s390_extract_return_value (struct type *valtype, char *regbuf, char *valbuf)
1090{
1091 /* floats and doubles are returned in fpr0. fpr's have a size of 8 bytes.
1092 We need to truncate the return value into float size (4 byte) if
1093 necessary. */
1094 int len = TYPE_LENGTH (valtype);
1095
1096 if (TYPE_CODE (valtype) == TYPE_CODE_FLT)
f2c6cfba 1097 memcpy (valbuf, &regbuf[REGISTER_BYTE (S390_FP0_REGNUM)], len);
5769d3cd
AC		 1098 else
1099 {
1100 int offset = 0;
1101 /* return value is copied starting from r2. */
1102 if (TYPE_LENGTH (valtype) < S390_GPR_SIZE)
1103 offset = S390_GPR_SIZE - TYPE_LENGTH (valtype);
1104 memcpy (valbuf,
1105 regbuf + REGISTER_BYTE (S390_GP0_REGNUM + 2) + offset,
1106 TYPE_LENGTH (valtype));
1107 }
1108}
1109
1110
1111static char *
1112s390_promote_integer_argument (struct type *valtype, char *valbuf,
1113 char *reg_buff, int *arglen)
1114{
1115 char *value = valbuf;
1116 int len = TYPE_LENGTH (valtype);
1117
1118 if (len < S390_GPR_SIZE)
1119 {
1120 /* We need to upgrade this value to a register to pass it correctly */
1121 int idx, diff = S390_GPR_SIZE - len, negative =
1122 (!TYPE_UNSIGNED (valtype) && value[0] & 0x80);
1123 for (idx = 0; idx < S390_GPR_SIZE; idx++)
1124 {
1125 reg_buff[idx] = (idx < diff ? (negative ? 0xff : 0x0) :
1126 value[idx - diff]);
1127 }
1128 value = reg_buff;
1129 *arglen = S390_GPR_SIZE;
1130 }
1131 else
1132 {
1133 if (len & (S390_GPR_SIZE - 1))
1134 {
1135 fprintf_unfiltered (gdb_stderr,
1136 "s390_promote_integer_argument detected an argument not "
1137 "a multiple of S390_GPR_SIZE & greater than S390_GPR_SIZE "
1138 "we might not deal with this correctly.\n");
1139 }
1140 *arglen = len;
1141 }
1142
1143 return (value);
1144}
1145
1146void
1147s390_store_return_value (struct type *valtype, char *valbuf)
1148{
1149 int arglen;
1150 char *reg_buff = alloca (max (S390_FPR_SIZE, REGISTER_SIZE)), *value;
1151
1152 if (TYPE_CODE (valtype) == TYPE_CODE_FLT)
1153 {
03a013f4
JB		 1154 if (TYPE_LENGTH (valtype) == 4
1155 || TYPE_LENGTH (valtype) == 8)
73937e03
AC		 1156 deprecated_write_register_bytes (REGISTER_BYTE (S390_FP0_REGNUM),
1157 valbuf, TYPE_LENGTH (valtype));
03a013f4
JB		 1158 else
1159 error ("GDB is unable to return `long double' values "
1160 "on this architecture.");
5769d3cd
AC		 1161 }
1162 else
1163 {
1164 value =
1165 s390_promote_integer_argument (valtype, valbuf, reg_buff, &arglen);
1166 /* Everything else is returned in GPR2 and up. */
73937e03
AC		 1167 deprecated_write_register_bytes (REGISTER_BYTE (S390_GP0_REGNUM + 2),
1168 value, arglen);
5769d3cd
AC		 1169 }
1170}
1171static int
1172gdb_print_insn_s390 (bfd_vma memaddr, disassemble_info * info)
1173{
1174 bfd_byte instrbuff[S390_MAX_INSTR_SIZE];
1175 int instrlen, cnt;
1176
1177 instrlen = s390_readinstruction (instrbuff, (CORE_ADDR) memaddr, info);
1178 if (instrlen < 0)
1179 {
1180 (*info->memory_error_func) (instrlen, memaddr, info);
1181 return -1;
1182 }
1183 for (cnt = 0; cnt < instrlen; cnt++)
1184 info->fprintf_func (info->stream, "%02X ", instrbuff[cnt]);
1185 for (cnt = instrlen; cnt < S390_MAX_INSTR_SIZE; cnt++)
1186 info->fprintf_func (info->stream, " ");
1187 instrlen = print_insn_s390 (memaddr, info);
1188 return instrlen;
1189}
1190
1191
1192
1193/* Not the most efficent code in the world */
1194int
5ae5f592 1195s390_fp_regnum (void)
5769d3cd
AC		 1196{
1197 int regno = S390_SP_REGNUM;
1198 struct frame_extra_info fextra_info;
1199
1200 CORE_ADDR pc = ADDR_BITS_REMOVE (read_register (S390_PC_REGNUM));
1201
1202 s390_get_frame_info (s390_sniff_pc_function_start (pc, NULL), &fextra_info,
1203 NULL, 1);
1204 if (fextra_info.frame_pointer_saved_pc)
1205 regno = S390_FRAME_REGNUM;
1206 return regno;
1207}
1208
1209CORE_ADDR
5ae5f592 1210s390_read_fp (void)
5769d3cd
AC		 1211{
1212 return read_register (s390_fp_regnum ());
1213}
1214
1215
4c8287ac
JB		 1216static void
1217s390_pop_frame_regular (struct frame_info *frame)
5769d3cd 1218{
4c8287ac
JB		 1219 int regnum;
1220
1221 write_register (S390_PC_REGNUM, FRAME_SAVED_PC (frame));
1222
1223 /* Restore any saved registers. */
b2fb4676 1224 if (get_frame_saved_regs (frame))
1a889ea5
JB		 1225 {
1226 for (regnum = 0; regnum < NUM_REGS; regnum++)
b2fb4676 1227 if (get_frame_saved_regs (frame)[regnum] != 0)
1a889ea5
JB		 1228 {
1229 ULONGEST value;
1230
b2fb4676 1231 value = read_memory_unsigned_integer (get_frame_saved_regs (frame)[regnum],
1a889ea5
JB		 1232 REGISTER_RAW_SIZE (regnum));
1233 write_register (regnum, value);
1234 }
1235
1236 /* Actually cut back the stack. Remember that the SP's element of
1237 saved_regs is the old SP itself, not the address at which it is
1238 saved. */
b2fb4676 1239 write_register (S390_SP_REGNUM, get_frame_saved_regs (frame)[S390_SP_REGNUM]);
1a889ea5 1240 }
5769d3cd 1241
4c8287ac
JB		 1242 /* Throw away any cached frame information. */
1243 flush_cached_frames ();
5769d3cd
AC		 1244}
1245
4c8287ac
JB		 1246
1247/* Destroy the innermost (Top-Of-Stack) stack frame, restoring the
1248 machine state that was in effect before the frame was created.
1249 Used in the contexts of the "return" command, and of
1250 target function calls from the debugger. */
1251void
5ae5f592 1252s390_pop_frame (void)
4c8287ac
JB		 1253{
1254 /* This function checks for and handles generic dummy frames, and
1255 calls back to our function for ordinary frames. */
1256 generic_pop_current_frame (s390_pop_frame_regular);
1257}
1258
1259
78f8b424
JB		 1260/* Return non-zero if TYPE is an integer-like type, zero otherwise.
1261 "Integer-like" types are those that should be passed the way
1262 integers are: integers, enums, ranges, characters, and booleans. */
1263static int
1264is_integer_like (struct type *type)
1265{
1266 enum type_code code = TYPE_CODE (type);
1267
1268 return (code == TYPE_CODE_INT
1269 || code == TYPE_CODE_ENUM
1270 || code == TYPE_CODE_RANGE
1271 || code == TYPE_CODE_CHAR
1272 || code == TYPE_CODE_BOOL);
1273}
1274
1275
1276/* Return non-zero if TYPE is a pointer-like type, zero otherwise.
1277 "Pointer-like" types are those that should be passed the way
1278 pointers are: pointers and references. */
1279static int
1280is_pointer_like (struct type *type)
1281{
1282 enum type_code code = TYPE_CODE (type);
1283
1284 return (code == TYPE_CODE_PTR
1285 || code == TYPE_CODE_REF);
1286}
1287
1288
20a940cc
JB		 1289/* Return non-zero if TYPE is a `float singleton' or `double
1290 singleton', zero otherwise.
1291
1292 A `T singleton' is a struct type with one member, whose type is
1293 either T or a `T singleton'. So, the following are all float
1294 singletons:
1295
1296 struct { float x };
1297 struct { struct { float x; } x; };
1298 struct { struct { struct { float x; } x; } x; };
1299
1300 ... and so on.
1301
1302 WHY THE HECK DO WE CARE ABOUT THIS??? Well, it turns out that GCC
1303 passes all float singletons and double singletons as if they were
1304 simply floats or doubles. This is *not* what the ABI says it
1305 should do. */
1306static int
1307is_float_singleton (struct type *type)
1308{
1309 return (TYPE_CODE (type) == TYPE_CODE_STRUCT
1310 && TYPE_NFIELDS (type) == 1
1311 && (TYPE_CODE (TYPE_FIELD_TYPE (type, 0)) == TYPE_CODE_FLT
1312 || is_float_singleton (TYPE_FIELD_TYPE (type, 0))));
1313}
1314
1315
1316/* Return non-zero if TYPE is a struct-like type, zero otherwise.
1317 "Struct-like" types are those that should be passed as structs are:
1318 structs and unions.
1319
1320 As an odd quirk, not mentioned in the ABI, GCC passes float and
1321 double singletons as if they were a plain float, double, etc. (The
1322 corresponding union types are handled normally.) So we exclude
1323 those types here. *shrug* */
1324static int
1325is_struct_like (struct type *type)
1326{
1327 enum type_code code = TYPE_CODE (type);
1328
1329 return (code == TYPE_CODE_UNION
1330 || (code == TYPE_CODE_STRUCT && ! is_float_singleton (type)));
1331}
1332
1333
1334/* Return non-zero if TYPE is a float-like type, zero otherwise.
1335 "Float-like" types are those that should be passed as
1336 floating-point values are.
1337
1338 You'd think this would just be floats, doubles, long doubles, etc.
1339 But as an odd quirk, not mentioned in the ABI, GCC passes float and
1340 double singletons as if they were a plain float, double, etc. (The
1341 corresponding union types are handled normally.) So we exclude
1342 those types here. *shrug* */
1343static int
1344is_float_like (struct type *type)
1345{
1346 return (TYPE_CODE (type) == TYPE_CODE_FLT
1347 || is_float_singleton (type));
1348}
1349
1350
78f8b424
JB		 1351/* Return non-zero if TYPE is considered a `DOUBLE_OR_FLOAT', as
1352 defined by the parameter passing conventions described in the
ca557f44 1353 "GNU/Linux for S/390 ELF Application Binary Interface Supplement".
78f8b424
JB		 1354 Otherwise, return zero. */
1355static int
1356is_double_or_float (struct type *type)
1357{
20a940cc 1358 return (is_float_like (type)
78f8b424
JB		 1359 && (TYPE_LENGTH (type) == 4
1360 || TYPE_LENGTH (type) == 8));
1361}
1362
5769d3cd 1363
78f8b424 1364/* Return non-zero if TYPE is considered a `SIMPLE_ARG', as defined by
ca557f44
AC		 1365 the parameter passing conventions described in the "GNU/Linux for
1366 S/390 ELF Application Binary Interface Supplement". Return zero
1367 otherwise. */
78f8b424
JB		 1368static int
1369is_simple_arg (struct type *type)
1370{
78f8b424
JB		 1371 unsigned length = TYPE_LENGTH (type);
1372
a1677dfb
JB		 1373 /* This is almost a direct translation of the ABI's language, except
1374 that we have to exclude 8-byte structs; those are DOUBLE_ARGs. */
78f8b424
JB		 1375 return ((is_integer_like (type) && length <= 4)
1376 || is_pointer_like (type)
20a940cc
JB		 1377 || (is_struct_like (type) && length != 8)
1378 || (is_float_like (type) && length == 16));
78f8b424
JB		 1379}
1380
1381
1382/* Return non-zero if TYPE should be passed as a pointer to a copy,
1383 zero otherwise. TYPE must be a SIMPLE_ARG, as recognized by
1384 `is_simple_arg'. */
1385static int
1386pass_by_copy_ref (struct type *type)
1387{
78f8b424
JB		 1388 unsigned length = TYPE_LENGTH (type);
1389
20a940cc
JB		 1390 return ((is_struct_like (type) && length != 1 && length != 2 && length != 4)
1391 || (is_float_like (type) && length == 16));
78f8b424
JB		 1392}
1393
1394
1395/* Return ARG, a `SIMPLE_ARG', sign-extended or zero-extended to a full
1396 word as required for the ABI. */
1397static LONGEST
1398extend_simple_arg (struct value *arg)
1399{
1400 struct type *type = VALUE_TYPE (arg);
1401
1402 /* Even structs get passed in the least significant bits of the
1403 register / memory word. It's not really right to extract them as
1404 an integer, but it does take care of the extension. */
1405 if (TYPE_UNSIGNED (type))
1406 return extract_unsigned_integer (VALUE_CONTENTS (arg),
1407 TYPE_LENGTH (type));
1408 else
1409 return extract_signed_integer (VALUE_CONTENTS (arg),
1410 TYPE_LENGTH (type));
1411}
1412
1413
1414/* Return non-zero if TYPE is a `DOUBLE_ARG', as defined by the
ca557f44
AC		 1415 parameter passing conventions described in the "GNU/Linux for S/390
1416 ELF Application Binary Interface Supplement". Return zero
1417 otherwise. */
78f8b424
JB		 1418static int
1419is_double_arg (struct type *type)
1420{
78f8b424
JB		 1421 unsigned length = TYPE_LENGTH (type);
1422
1423 return ((is_integer_like (type)
20a940cc 1424 || is_struct_like (type))
78f8b424
JB		 1425 && length == 8);
1426}
1427
1428
1429/* Round ADDR up to the next N-byte boundary. N must be a power of
1430 two. */
1431static CORE_ADDR
1432round_up (CORE_ADDR addr, int n)
1433{
1434 /* Check that N is really a power of two. */
1435 gdb_assert (n && (n & (n-1)) == 0);
1436 return ((addr + n - 1) & -n);
1437}
1438
1439
1440/* Round ADDR down to the next N-byte boundary. N must be a power of
1441 two. */
1442static CORE_ADDR
1443round_down (CORE_ADDR addr, int n)
1444{
1445 /* Check that N is really a power of two. */
1446 gdb_assert (n && (n & (n-1)) == 0);
1447 return (addr & -n);
1448}
1449
1450
1451/* Return the alignment required by TYPE. */
1452static int
1453alignment_of (struct type *type)
1454{
1455 int alignment;
1456
1457 if (is_integer_like (type)
1458 || is_pointer_like (type)
1459 || TYPE_CODE (type) == TYPE_CODE_FLT)
1460 alignment = TYPE_LENGTH (type);
1461 else if (TYPE_CODE (type) == TYPE_CODE_STRUCT
1462 || TYPE_CODE (type) == TYPE_CODE_UNION)
1463 {
1464 int i;
1465
1466 alignment = 1;
1467 for (i = 0; i < TYPE_NFIELDS (type); i++)
1468 {
1469 int field_alignment = alignment_of (TYPE_FIELD_TYPE (type, i));
1470
1471 if (field_alignment > alignment)
1472 alignment = field_alignment;
1473 }
1474 }
1475 else
1476 alignment = 1;
1477
1478 /* Check that everything we ever return is a power of two. Lots of
1479 code doesn't want to deal with aligning things to arbitrary
1480 boundaries. */
1481 gdb_assert ((alignment & (alignment - 1)) == 0);
1482
1483 return alignment;
1484}
1485
1486
1487/* Put the actual parameter values pointed to by ARGS[0..NARGS-1] in
ca557f44
AC		 1488 place to be passed to a function, as specified by the "GNU/Linux
1489 for S/390 ELF Application Binary Interface Supplement".
78f8b424
JB		 1490
1491 SP is the current stack pointer. We must put arguments, links,
1492 padding, etc. whereever they belong, and return the new stack
1493 pointer value.
1494
1495 If STRUCT_RETURN is non-zero, then the function we're calling is
1496 going to return a structure by value; STRUCT_ADDR is the address of
1497 a block we've allocated for it on the stack.
1498
1499 Our caller has taken care of any type promotions needed to satisfy
1500 prototypes or the old K&R argument-passing rules. */
5769d3cd 1501CORE_ADDR
d45fc520 1502s390_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
5769d3cd
AC		 1503 int struct_return, CORE_ADDR struct_addr)
1504{
78f8b424
JB		 1505 int i;
1506 int pointer_size = (TARGET_PTR_BIT / TARGET_CHAR_BIT);
5769d3cd 1507
78f8b424
JB		 1508 /* The number of arguments passed by reference-to-copy. */
1509 int num_copies;
5769d3cd 1510
78f8b424
JB		 1511 /* If the i'th argument is passed as a reference to a copy, then
1512 copy_addr[i] is the address of the copy we made. */
1513 CORE_ADDR *copy_addr = alloca (nargs * sizeof (CORE_ADDR));
5769d3cd 1514
78f8b424
JB		 1515 /* Build the reference-to-copy area. */
1516 num_copies = 0;
1517 for (i = 0; i < nargs; i++)
1518 {
1519 struct value *arg = args[i];
1520 struct type *type = VALUE_TYPE (arg);
1521 unsigned length = TYPE_LENGTH (type);
5769d3cd 1522
78f8b424
JB		 1523 if (is_simple_arg (type)
1524 && pass_by_copy_ref (type))
01c464e9 1525 {
78f8b424
JB		 1526 sp -= length;
1527 sp = round_down (sp, alignment_of (type));
1528 write_memory (sp, VALUE_CONTENTS (arg), length);
1529 copy_addr[i] = sp;
1530 num_copies++;
01c464e9 1531 }
5769d3cd 1532 }
5769d3cd 1533
78f8b424
JB		 1534 /* Reserve space for the parameter area. As a conservative
1535 simplification, we assume that everything will be passed on the
1536 stack. */
1537 {
1538 int i;
1539
1540 for (i = 0; i < nargs; i++)
1541 {
1542 struct value *arg = args[i];
1543 struct type *type = VALUE_TYPE (arg);
1544 int length = TYPE_LENGTH (type);
1545
1546 sp = round_down (sp, alignment_of (type));
1547
1548 /* SIMPLE_ARG values get extended to 32 bits. Assume every
1549 argument is. */
1550 if (length < 4) length = 4;
1551 sp -= length;
1552 }
1553 }
1554
1555 /* Include space for any reference-to-copy pointers. */
1556 sp = round_down (sp, pointer_size);
1557 sp -= num_copies * pointer_size;
1558
1559 /* After all that, make sure it's still aligned on an eight-byte
1560 boundary. */
1561 sp = round_down (sp, 8);
1562
1563 /* Finally, place the actual parameters, working from SP towards
1564 higher addresses. The code above is supposed to reserve enough
1565 space for this. */
1566 {
1567 int fr = 0;
1568 int gr = 2;
1569 CORE_ADDR starg = sp;
1570
1571 for (i = 0; i < nargs; i++)
1572 {
1573 struct value *arg = args[i];
1574 struct type *type = VALUE_TYPE (arg);
1575
1576 if (is_double_or_float (type)
1577 && fr <= 2)
1578 {
1579 /* When we store a single-precision value in an FP register,
1580 it occupies the leftmost bits. */
73937e03
AC		 1581 deprecated_write_register_bytes (REGISTER_BYTE (S390_FP0_REGNUM + fr),
1582 VALUE_CONTENTS (arg),
1583 TYPE_LENGTH (type));
78f8b424
JB		 1584 fr += 2;
1585 }
1586 else if (is_simple_arg (type)
1587 && gr <= 6)
1588 {
1589 /* Do we need to pass a pointer to our copy of this
1590 argument? */
1591 if (pass_by_copy_ref (type))
1592 write_register (S390_GP0_REGNUM + gr, copy_addr[i]);
1593 else
1594 write_register (S390_GP0_REGNUM + gr, extend_simple_arg (arg));
1595
1596 gr++;
1597 }
1598 else if (is_double_arg (type)
1599 && gr <= 5)
1600 {
4caf0990
AC		 1601 deprecated_write_register_gen (S390_GP0_REGNUM + gr,
1602 VALUE_CONTENTS (arg));
1603 deprecated_write_register_gen (S390_GP0_REGNUM + gr + 1,
1604 VALUE_CONTENTS (arg) + 4);
78f8b424
JB		 1605 gr += 2;
1606 }
1607 else
1608 {
1609 /* The `OTHER' case. */
1610 enum type_code code = TYPE_CODE (type);
1611 unsigned length = TYPE_LENGTH (type);
1612
1613 /* If we skipped r6 because we couldn't fit a DOUBLE_ARG
1614 in it, then don't go back and use it again later. */
1615 if (is_double_arg (type) && gr == 6)
1616 gr = 7;
1617
1618 if (is_simple_arg (type))
1619 {
1620 /* Simple args are always either extended to 32 bits,
1621 or pointers. */
1622 starg = round_up (starg, 4);
1623
1624 /* Do we need to pass a pointer to our copy of this
1625 argument? */
1626 if (pass_by_copy_ref (type))
1627 write_memory_signed_integer (starg, pointer_size,
1628 copy_addr[i]);
1629 else
1630 /* Simple args are always extended to 32 bits. */
1631 write_memory_signed_integer (starg, 4,
1632 extend_simple_arg (arg));
1633 starg += 4;
1634 }
1635 else
1636 {
20a940cc
JB		 1637 /* You'd think we should say:
1638 starg = round_up (starg, alignment_of (type));
1639 Unfortunately, GCC seems to simply align the stack on
1640 a four-byte boundary, even when passing doubles. */
1641 starg = round_up (starg, 4);
78f8b424
JB		 1642 write_memory (starg, VALUE_CONTENTS (arg), length);
1643 starg += length;
1644 }
1645 }
1646 }
1647 }
1648
1649 /* Allocate the standard frame areas: the register save area, the
1650 word reserved for the compiler (which seems kind of meaningless),
1651 and the back chain pointer. */
1652 sp -= 96;
1653
1654 /* Write the back chain pointer into the first word of the stack
1655 frame. This will help us get backtraces from within functions
1656 called from GDB. */
1657 write_memory_unsigned_integer (sp, (TARGET_PTR_BIT / TARGET_CHAR_BIT),
1658 read_fp ());
1659
1660 return sp;
5769d3cd
AC		 1661}
1662
c8f9d51c
JB		 1663
1664static int
1665s390_use_struct_convention (int gcc_p, struct type *value_type)
1666{
1667 enum type_code code = TYPE_CODE (value_type);
1668
1669 return (code == TYPE_CODE_STRUCT
1670 || code == TYPE_CODE_UNION);
1671}
1672
1673
5769d3cd
AC		 1674/* Return the GDB type object for the "standard" data type
1675 of data in register N. */
1676struct type *
1677s390_register_virtual_type (int regno)
1678{
b09677dc
JB		 1679 if (S390_FP0_REGNUM <= regno && regno < S390_FP0_REGNUM + S390_NUM_FPRS)
1680 return builtin_type_double;
1681 else
1682 return builtin_type_int;
5769d3cd
AC		 1683}
1684
1685
1686struct type *
1687s390x_register_virtual_type (int regno)
1688{
1689 return (regno == S390_FPC_REGNUM) ||
1690 (regno >= S390_FIRST_ACR && regno <= S390_LAST_ACR) ? builtin_type_int :
1691 (regno >= S390_FP0_REGNUM) ? builtin_type_double : builtin_type_long;
1692}
1693
1694
1695
1696void
1697s390_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
1698{
1699 write_register (S390_GP0_REGNUM + 2, addr);
1700}
1701
1702
1703
f4f9705a 1704const static unsigned char *
5769d3cd
AC		 1705s390_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
1706{
1707 static unsigned char breakpoint[] = { 0x0, 0x1 };
1708
1709 *lenptr = sizeof (breakpoint);
1710 return breakpoint;
1711}
1712
1713/* Advance PC across any function entry prologue instructions to reach some
1714 "real" code. */
1715CORE_ADDR
1716s390_skip_prologue (CORE_ADDR pc)
1717{
1718 struct frame_extra_info fextra_info;
1719
1720 s390_get_frame_info (pc, &fextra_info, NULL, 1);
1721 return fextra_info.skip_prologue_function_start;
1722}
1723
5769d3cd
AC		 1724/* Immediately after a function call, return the saved pc.
1725 Can't go through the frames for this because on some machines
1726 the new frame is not set up until the new function executes
1727 some instructions. */
1728CORE_ADDR
1729s390_saved_pc_after_call (struct frame_info *frame)
1730{
1731 return ADDR_BITS_REMOVE (read_register (S390_RETADDR_REGNUM));
1732}
1733
1734static CORE_ADDR
1735s390_addr_bits_remove (CORE_ADDR addr)
1736{
1737 return (addr) & 0x7fffffff;
1738}
1739
1740
1741static CORE_ADDR
1742s390_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
1743{
d4d0c21e 1744 write_register (S390_RETADDR_REGNUM, CALL_DUMMY_ADDRESS ());
5769d3cd
AC		 1745 return sp;
1746}
1747
1748struct gdbarch *
1749s390_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1750{
d4d0c21e 1751 static LONGEST s390_call_dummy_words[] = { 0 };
5769d3cd
AC		 1752 struct gdbarch *gdbarch;
1753 struct gdbarch_tdep *tdep;
1754 int elf_flags;
1755
1756 /* First see if there is already a gdbarch that can satisfy the request. */
1757 arches = gdbarch_list_lookup_by_info (arches, &info);
1758 if (arches != NULL)
1759 return arches->gdbarch;
1760
1761 /* None found: is the request for a s390 architecture? */
1762 if (info.bfd_arch_info->arch != bfd_arch_s390)
1763 return NULL; /* No; then it's not for us. */
1764
1765 /* Yes: create a new gdbarch for the specified machine type. */
1766 gdbarch = gdbarch_alloc (&info, NULL);
1767
a5afb99f
AC		 1768 /* NOTE: cagney/2002-12-06: This can be deleted when this arch is
1769 ready to unwind the PC first (see frame.c:get_prev_frame()). */
1770 set_gdbarch_deprecated_init_frame_pc (gdbarch, init_frame_pc_default);
1771
5769d3cd 1772 set_gdbarch_believe_pcc_promotion (gdbarch, 0);
4e409299 1773 set_gdbarch_char_signed (gdbarch, 0);
5769d3cd 1774
5769d3cd
AC		 1775 set_gdbarch_frame_args_skip (gdbarch, 0);
1776 set_gdbarch_frame_args_address (gdbarch, s390_frame_args_address);
1777 set_gdbarch_frame_chain (gdbarch, s390_frame_chain);
1778 set_gdbarch_frame_init_saved_regs (gdbarch, s390_frame_init_saved_regs);
1779 set_gdbarch_frame_locals_address (gdbarch, s390_frame_args_address);
1780 /* We can't do this */
1781 set_gdbarch_frame_num_args (gdbarch, frame_num_args_unknown);
1782 set_gdbarch_store_struct_return (gdbarch, s390_store_struct_return);
26e9b323 1783 set_gdbarch_deprecated_extract_return_value (gdbarch, s390_extract_return_value);
ebba8386 1784 set_gdbarch_deprecated_store_return_value (gdbarch, s390_store_return_value);
5769d3cd
AC		 1785 /* Amount PC must be decremented by after a breakpoint.
1786 This is often the number of bytes in BREAKPOINT
1787 but not always. */
1788 set_gdbarch_decr_pc_after_break (gdbarch, 2);
1789 set_gdbarch_pop_frame (gdbarch, s390_pop_frame);
5769d3cd
AC		 1790 /* Stack grows downward. */
1791 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1792 /* Offset from address of function to start of its code.
1793 Zero on most machines. */
1794 set_gdbarch_function_start_offset (gdbarch, 0);
1795 set_gdbarch_max_register_raw_size (gdbarch, 8);
1796 set_gdbarch_max_register_virtual_size (gdbarch, 8);
1797 set_gdbarch_breakpoint_from_pc (gdbarch, s390_breakpoint_from_pc);
1798 set_gdbarch_skip_prologue (gdbarch, s390_skip_prologue);
1799 set_gdbarch_init_extra_frame_info (gdbarch, s390_init_extra_frame_info);
2ca6c561 1800 set_gdbarch_deprecated_init_frame_pc_first (gdbarch, s390_init_frame_pc_first);
5769d3cd 1801 set_gdbarch_read_fp (gdbarch, s390_read_fp);
5769d3cd
AC		 1802 /* This function that tells us whether the function invocation represented
1803 by FI does not have a frame on the stack associated with it. If it
1804 does not, FRAMELESS is set to 1, else 0. */
1805 set_gdbarch_frameless_function_invocation (gdbarch,
1806 s390_frameless_function_invocation);
1807 /* Return saved PC from a frame */
1808 set_gdbarch_frame_saved_pc (gdbarch, s390_frame_saved_pc);
1809 /* FRAME_CHAIN takes a frame's nominal address
1810 and produces the frame's chain-pointer. */
1811 set_gdbarch_frame_chain (gdbarch, s390_frame_chain);
1812 set_gdbarch_saved_pc_after_call (gdbarch, s390_saved_pc_after_call);
1813 set_gdbarch_register_byte (gdbarch, s390_register_byte);
1814 set_gdbarch_pc_regnum (gdbarch, S390_PC_REGNUM);
1815 set_gdbarch_sp_regnum (gdbarch, S390_SP_REGNUM);
1816 set_gdbarch_fp_regnum (gdbarch, S390_FP_REGNUM);
1817 set_gdbarch_fp0_regnum (gdbarch, S390_FP0_REGNUM);
1818 set_gdbarch_num_regs (gdbarch, S390_NUM_REGS);
1819 set_gdbarch_cannot_fetch_register (gdbarch, s390_cannot_fetch_register);
1820 set_gdbarch_cannot_store_register (gdbarch, s390_cannot_fetch_register);
c8f9d51c 1821 set_gdbarch_use_struct_convention (gdbarch, s390_use_struct_convention);
5769d3cd
AC		 1822 set_gdbarch_register_name (gdbarch, s390_register_name);
1823 set_gdbarch_stab_reg_to_regnum (gdbarch, s390_stab_reg_to_regnum);
1824 set_gdbarch_dwarf_reg_to_regnum (gdbarch, s390_stab_reg_to_regnum);
1825 set_gdbarch_dwarf2_reg_to_regnum (gdbarch, s390_stab_reg_to_regnum);
26e9b323 1826 set_gdbarch_deprecated_extract_struct_value_address
c8f9d51c 1827 (gdbarch, generic_cannot_extract_struct_value_address);
5769d3cd 1828
d4d0c21e 1829 /* Parameters for inferior function calls. */
5769d3cd 1830 set_gdbarch_call_dummy_p (gdbarch, 1);
d4d0c21e 1831 set_gdbarch_call_dummy_length (gdbarch, 0);
d4d0c21e
JB		 1832 set_gdbarch_call_dummy_address (gdbarch, entry_point_address);
1833 set_gdbarch_call_dummy_start_offset (gdbarch, 0);
ae45cd16 1834 set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_at_entry_point);
d4d0c21e
JB		 1835 set_gdbarch_push_dummy_frame (gdbarch, generic_push_dummy_frame);
1836 set_gdbarch_push_arguments (gdbarch, s390_push_arguments);
5c3cf190 1837 set_gdbarch_save_dummy_frame_tos (gdbarch, generic_save_dummy_frame_tos);
d4d0c21e
JB		 1838 set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 1);
1839 set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 0);
5769d3cd 1840 set_gdbarch_call_dummy_stack_adjust_p (gdbarch, 0);
d4d0c21e 1841 set_gdbarch_fix_call_dummy (gdbarch, generic_fix_call_dummy);
5769d3cd 1842 set_gdbarch_push_return_address (gdbarch, s390_push_return_address);
d4d0c21e
JB		 1843 set_gdbarch_sizeof_call_dummy_words (gdbarch,
1844 sizeof (s390_call_dummy_words));
1845 set_gdbarch_call_dummy_words (gdbarch, s390_call_dummy_words);
5769d3cd
AC		 1846
1847 switch (info.bfd_arch_info->mach)
1848 {
b8b8b047 1849 case bfd_mach_s390_31:
5769d3cd 1850 set_gdbarch_register_size (gdbarch, 4);
5769d3cd
AC		 1851 set_gdbarch_register_raw_size (gdbarch, s390_register_raw_size);
1852 set_gdbarch_register_virtual_size (gdbarch, s390_register_raw_size);
1853 set_gdbarch_register_virtual_type (gdbarch, s390_register_virtual_type);
1854
1855 set_gdbarch_addr_bits_remove (gdbarch, s390_addr_bits_remove);
5769d3cd
AC		 1856 set_gdbarch_register_bytes (gdbarch, S390_REGISTER_BYTES);
1857 break;
b8b8b047 1858 case bfd_mach_s390_64:
5769d3cd 1859 set_gdbarch_register_size (gdbarch, 8);
5769d3cd
AC		 1860 set_gdbarch_register_raw_size (gdbarch, s390x_register_raw_size);
1861 set_gdbarch_register_virtual_size (gdbarch, s390x_register_raw_size);
1862 set_gdbarch_register_virtual_type (gdbarch,
1863 s390x_register_virtual_type);
1864
1865 set_gdbarch_long_bit (gdbarch, 64);
1866 set_gdbarch_long_long_bit (gdbarch, 64);
1867 set_gdbarch_ptr_bit (gdbarch, 64);
5769d3cd
AC		 1868 set_gdbarch_register_bytes (gdbarch, S390X_REGISTER_BYTES);
1869 break;
1870 }
1871
1872 return gdbarch;
1873}
1874
1875
1876
1877void
5ae5f592 1878_initialize_s390_tdep (void)
5769d3cd
AC		 1879{
1880
1881 /* Hook us into the gdbarch mechanism. */
1882 register_gdbarch_init (bfd_arch_s390, s390_gdbarch_init);
1883 if (!tm_print_insn) /* Someone may have already set it */
1884 tm_print_insn = gdb_print_insn_s390;
1885}
1886
1887#endif /* GDBSERVER */
GDB Binutils - Deliverables
This page took 0.257467 seconds and 4 git commands to generate.