1 /* Target-dependent code for GDB, the GNU debugger.
3 Copyright 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
5 Contributed by D.J. Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
6 for IBM Deutschland Entwicklung GmbH, IBM Corporation.
8 This file is part of GDB.
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.
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.
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
25 #define S390_TDEP /* for special macros in tm-s390.h */
27 #include "arch-utils.h"
36 #include "../bfd/bfd.h"
37 #include "floatformat.h"
40 #include "gdb_assert.h"
45 /* Number of bytes of storage in the actual machine representation
48 s390_register_raw_size (int reg_nr
)
50 if (S390_FP0_REGNUM
<= reg_nr
51 && reg_nr
< S390_FP0_REGNUM
+ S390_NUM_FPRS
)
58 s390x_register_raw_size (int reg_nr
)
60 return (reg_nr
== S390_FPC_REGNUM
)
61 || (reg_nr
>= S390_FIRST_ACR
&& reg_nr
<= S390_LAST_ACR
) ? 4 : 8;
65 s390_cannot_fetch_register (int regno
)
67 return (regno
>= S390_FIRST_CR
&& regno
< (S390_FIRST_CR
+ 9)) ||
68 (regno
>= (S390_FIRST_CR
+ 12) && regno
<= S390_LAST_CR
);
72 s390_register_byte (int reg_nr
)
74 if (reg_nr
<= S390_GP_LAST_REGNUM
)
75 return reg_nr
* S390_GPR_SIZE
;
76 if (reg_nr
<= S390_LAST_ACR
)
77 return S390_ACR0_OFFSET
+ (((reg_nr
) - S390_FIRST_ACR
) * S390_ACR_SIZE
);
78 if (reg_nr
<= S390_LAST_CR
)
79 return S390_CR0_OFFSET
+ (((reg_nr
) - S390_FIRST_CR
) * S390_CR_SIZE
);
80 if (reg_nr
== S390_FPC_REGNUM
)
81 return S390_FPC_OFFSET
;
83 return S390_FP0_OFFSET
+ (((reg_nr
) - S390_FP0_REGNUM
) * S390_FPR_SIZE
);
86 #define S390_MAX_INSTR_SIZE (6)
87 #define S390_SYSCALL_OPCODE (0x0a)
88 #define S390_SYSCALL_SIZE (2)
89 #define S390_SIGCONTEXT_SREGS_OFFSET (8)
90 #define S390X_SIGCONTEXT_SREGS_OFFSET (8)
91 #define S390_SIGREGS_FP0_OFFSET (144)
92 #define S390X_SIGREGS_FP0_OFFSET (216)
93 #define S390_UC_MCONTEXT_OFFSET (256)
94 #define S390X_UC_MCONTEXT_OFFSET (344)
95 #define S390_STACK_FRAME_OVERHEAD 16*DEPRECATED_REGISTER_SIZE+32
96 #define S390_STACK_PARAMETER_ALIGNMENT DEPRECATED_REGISTER_SIZE
97 #define S390_NUM_FP_PARAMETER_REGISTERS (GDB_TARGET_IS_ESAME ? 4:2)
98 #define S390_SIGNAL_FRAMESIZE (GDB_TARGET_IS_ESAME ? 160:96)
99 #define s390_NR_sigreturn 119
100 #define s390_NR_rt_sigreturn 173
104 struct frame_extra_info
108 CORE_ADDR function_start
;
109 CORE_ADDR skip_prologue_function_start
;
110 CORE_ADDR saved_pc_valid
;
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_valid
;
116 CORE_ADDR stack_bought
; /* amount we decrement the stack pointer by */
117 CORE_ADDR sigcontext
;
121 static CORE_ADDR
s390_frame_saved_pc_nofix (struct frame_info
*fi
);
124 s390_readinstruction (bfd_byte instr
[], CORE_ADDR at
)
128 static int s390_instrlen
[] = {
134 if (target_read_memory (at
, &instr
[0], 2))
136 instrlen
= s390_instrlen
[instr
[0] >> 6];
139 if (target_read_memory (at
+ 2, &instr
[2], instrlen
- 2))
146 s390_memset_extra_info (struct frame_extra_info
*fextra_info
)
148 memset (fextra_info
, 0, sizeof (struct frame_extra_info
));
154 s390_register_name (int reg_nr
)
156 static char *register_names
[] = {
158 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
159 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
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",
165 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
166 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15"
169 if (reg_nr
<= S390_LAST_REGNUM
)
170 return register_names
[reg_nr
];
179 s390_stab_reg_to_regnum (int regno
)
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);
190 /* Prologue analysis. */
192 /* When we analyze a prologue, we're really doing 'abstract
193 interpretation' or 'pseudo-evaluation': running the function's code
194 in simulation, but using conservative approximations of the values
195 it would have when it actually runs. For example, if our function
196 starts with the instruction:
198 ahi r1, 42 # add halfword immediate 42 to r1
200 we don't know exactly what value will be in r1 after executing this
201 instruction, but we do know it'll be 42 greater than its original
204 If we then see an instruction like:
206 ahi r1, 22 # add halfword immediate 22 to r1
208 we still don't know what r1's value is, but again, we can say it is
209 now 64 greater than its original value.
211 If the next instruction were:
213 lr r2, r1 # set r2 to r1's value
215 then we can say that r2's value is now the original value of r1
218 Of course, this can only go so far before it gets unreasonable. If
219 we wanted to be able to say anything about the value of r1 after
222 xr r1, r3 # exclusive-or r1 and r3, place result in r1
224 then things would get pretty complex. But remember, we're just
225 doing a conservative approximation; if exclusive-or instructions
226 aren't relevant to prologues, we can just say r1's value is now
227 'unknown'. We can ignore things that are too complex, if that loss
228 of information is acceptable for our application.
230 Once you've reached an instruction that you don't know how to
231 simulate, you stop. Now you examine the state of the registers and
232 stack slots you've kept track of. For example:
234 - To see how large your stack frame is, just check the value of sp;
235 if it's the original value of sp minus a constant, then that
236 constant is the stack frame's size. If the sp's value has been
237 marked as 'unknown', then that means the prologue has done
238 something too complex for us to track, and we don't know the
241 - To see whether we've saved the SP in the current frame's back
242 chain slot, we just check whether the current value of the back
243 chain stack slot is the original value of the sp.
245 Sure, this takes some work. But prologue analyzers aren't
246 quick-and-simple pattern patching to recognize a few fixed prologue
247 forms any more; they're big, hairy functions. Along with inferior
248 function calls, prologue analysis accounts for a substantial
249 portion of the time needed to stabilize a GDB port. So I think
250 it's worthwhile to look for an approach that will be easier to
251 understand and maintain. In the approach used here:
253 - It's easier to see that the analyzer is correct: you just see
254 whether the analyzer properly (albiet conservatively) simulates
255 the effect of each instruction.
257 - It's easier to extend the analyzer: you can add support for new
258 instructions, and know that you haven't broken anything that
259 wasn't already broken before.
261 - It's orthogonal: to gather new information, you don't need to
262 complicate the code for each instruction. As long as your domain
263 of conservative values is already detailed enough to tell you
264 what you need, then all the existing instruction simulations are
265 already gathering the right data for you.
267 A 'struct prologue_value' is a conservative approximation of the
268 real value the register or stack slot will have. */
270 struct prologue_value
{
272 /* What sort of value is this? This determines the interpretation
273 of subsequent fields. */
276 /* We don't know anything about the value. This is also used for
277 values we could have kept track of, when doing so would have
278 been too complex and we don't want to bother. The bottom of
282 /* A known constant. K is its value. */
285 /* The value that register REG originally had *UPON ENTRY TO THE
286 FUNCTION*, plus K. If K is zero, this means, obviously, just
287 the value REG had upon entry to the function. REG is a GDB
288 register number. Before we start interpreting, we initialize
289 every register R to { pv_register, R, 0 }. */
294 /* The meanings of the following fields depend on 'kind'; see the
295 comments for the specific 'kind' values. */
301 /* Set V to be unknown. */
303 pv_set_to_unknown (struct prologue_value
*v
)
305 v
->kind
= pv_unknown
;
309 /* Set V to the constant K. */
311 pv_set_to_constant (struct prologue_value
*v
, CORE_ADDR k
)
313 v
->kind
= pv_constant
;
318 /* Set V to the original value of register REG, plus K. */
320 pv_set_to_register (struct prologue_value
*v
, int reg
, CORE_ADDR k
)
322 v
->kind
= pv_register
;
328 /* If one of *A and *B is a constant, and the other isn't, swap the
329 pointers as necessary to ensure that *B points to the constant.
330 This can reduce the number of cases we need to analyze in the
333 pv_constant_last (struct prologue_value
**a
,
334 struct prologue_value
**b
)
336 if ((*a
)->kind
== pv_constant
337 && (*b
)->kind
!= pv_constant
)
339 struct prologue_value
*temp
= *a
;
346 /* Set SUM to the sum of A and B. SUM, A, and B may point to the same
347 'struct prologue_value' object. */
349 pv_add (struct prologue_value
*sum
,
350 struct prologue_value
*a
,
351 struct prologue_value
*b
)
353 pv_constant_last (&a
, &b
);
355 /* We can handle adding constants to registers, and other constants. */
356 if (b
->kind
== pv_constant
357 && (a
->kind
== pv_register
358 || a
->kind
== pv_constant
))
361 sum
->reg
= a
->reg
; /* not meaningful if a is pv_constant, but
363 sum
->k
= a
->k
+ b
->k
;
366 /* Anything else we don't know how to add. We don't have a
367 representation for, say, the sum of two registers, or a multiple
368 of a register's value (adding a register to itself). */
370 sum
->kind
= pv_unknown
;
374 /* Add the constant K to V. */
376 pv_add_constant (struct prologue_value
*v
, CORE_ADDR k
)
378 struct prologue_value pv_k
;
380 /* Rather than thinking of all the cases we can and can't handle,
381 we'll just let pv_add take care of that for us. */
382 pv_set_to_constant (&pv_k
, k
);
383 pv_add (v
, v
, &pv_k
);
387 /* Subtract B from A, and put the result in DIFF.
389 This isn't quite the same as negating B and adding it to A, since
390 we don't have a representation for the negation of anything but a
391 constant. For example, we can't negate { pv_register, R1, 10 },
392 but we do know that { pv_register, R1, 10 } minus { pv_register,
393 R1, 5 } is { pv_constant, <ignored>, 5 }.
395 This means, for example, that we can subtract two stack addresses;
396 they're both relative to the original SP. Since the frame pointer
397 is set based on the SP, its value will be the original SP plus some
398 constant (probably zero), so we can use its value just fine. */
400 pv_subtract (struct prologue_value
*diff
,
401 struct prologue_value
*a
,
402 struct prologue_value
*b
)
404 pv_constant_last (&a
, &b
);
406 /* We can subtract a constant from another constant, or from a
408 if (b
->kind
== pv_constant
409 && (a
->kind
== pv_register
410 || a
->kind
== pv_constant
))
412 diff
->kind
= a
->kind
;
413 diff
->reg
= a
->reg
; /* not always meaningful, but harmless */
414 diff
->k
= a
->k
- b
->k
;
417 /* We can subtract a register from itself, yielding a constant. */
418 else if (a
->kind
== pv_register
419 && b
->kind
== pv_register
422 diff
->kind
= pv_constant
;
423 diff
->k
= a
->k
- b
->k
;
426 /* We don't know how to subtract anything else. */
428 diff
->kind
= pv_unknown
;
432 /* Set AND to the logical and of A and B. */
434 pv_logical_and (struct prologue_value
*and,
435 struct prologue_value
*a
,
436 struct prologue_value
*b
)
438 pv_constant_last (&a
, &b
);
440 /* We can 'and' two constants. */
441 if (a
->kind
== pv_constant
442 && b
->kind
== pv_constant
)
444 and->kind
= pv_constant
;
445 and->k
= a
->k
& b
->k
;
448 /* We can 'and' anything with the constant zero. */
449 else if (b
->kind
== pv_constant
452 and->kind
= pv_constant
;
456 /* We can 'and' anything with ~0. */
457 else if (b
->kind
== pv_constant
458 && b
->k
== ~ (CORE_ADDR
) 0)
461 /* We can 'and' a register with itself. */
462 else if (a
->kind
== pv_register
463 && b
->kind
== pv_register
468 /* Otherwise, we don't know. */
470 pv_set_to_unknown (and);
474 /* Return non-zero iff A and B are identical expressions.
476 This is not the same as asking if the two values are equal; the
477 result of such a comparison would have to be a pv_boolean, and
478 asking whether two 'unknown' values were equal would give you
479 pv_maybe. Same for comparing, say, { pv_register, R1, 0 } and {
480 pv_register, R2, 0}. Instead, this is asking whether the two
481 representations are the same. */
483 pv_is_identical (struct prologue_value
*a
,
484 struct prologue_value
*b
)
486 if (a
->kind
!= b
->kind
)
494 return (a
->k
== b
->k
);
496 return (a
->reg
== b
->reg
&& a
->k
== b
->k
);
503 /* Return non-zero if A is the original value of register number R
504 plus K, zero otherwise. */
506 pv_is_register (struct prologue_value
*a
, int r
, CORE_ADDR k
)
508 return (a
->kind
== pv_register
514 /* A prologue-value-esque boolean type, including "maybe", when we
515 can't figure out whether something is true or not. */
523 /* Decide whether a reference to SIZE bytes at ADDR refers exactly to
524 an element of an array. The array starts at ARRAY_ADDR, and has
525 ARRAY_LEN values of ELT_SIZE bytes each. If ADDR definitely does
526 refer to an array element, set *I to the index of the referenced
527 element in the array, and return pv_definite_yes. If it definitely
528 doesn't, return pv_definite_no. If we can't tell, return pv_maybe.
530 If the reference does touch the array, but doesn't fall exactly on
531 an element boundary, or doesn't refer to the whole element, return
533 static enum pv_boolean
534 pv_is_array_ref (struct prologue_value
*addr
,
536 struct prologue_value
*array_addr
,
541 struct prologue_value offset
;
543 /* Note that, since ->k is a CORE_ADDR, and CORE_ADDR is unsigned,
544 if addr is *before* the start of the array, then this isn't going
546 pv_subtract (&offset
, addr
, array_addr
);
548 if (offset
.kind
== pv_constant
)
550 /* This is a rather odd test. We want to know if the SIZE bytes
551 at ADDR don't overlap the array at all, so you'd expect it to
552 be an || expression: "if we're completely before || we're
553 completely after". But with unsigned arithmetic, things are
554 different: since it's a number circle, not a number line, the
555 right values for offset.k are actually one contiguous range. */
556 if (offset
.k
<= -size
557 && offset
.k
>= array_len
* elt_size
)
558 return pv_definite_no
;
559 else if (offset
.k
% elt_size
!= 0
564 *i
= offset
.k
/ elt_size
;
565 return pv_definite_yes
;
574 /* Decoding S/390 instructions. */
576 /* Named opcode values for the S/390 instructions we recognize. Some
577 instructions have their opcode split across two fields; those are the
578 op1_* and op2_* enums. */
581 op1_aghi
= 0xa7, op2_aghi
= 0xb,
582 op1_ahi
= 0xa7, op2_ahi
= 0xa,
585 op1_bras
= 0xa7, op2_bras
= 0x5,
588 op1_larl
= 0xc0, op2_larl
= 0x0,
590 op1_lghi
= 0xa7, op2_lghi
= 0x9,
591 op1_lhi
= 0xa7, op2_lhi
= 0x8,
598 op1_stg
= 0xe3, op2_stg
= 0x24,
600 op1_stmg
= 0xeb, op2_stmg
= 0x24,
605 /* The functions below are for recognizing and decoding S/390
606 instructions of various formats. Each of them checks whether INSN
607 is an instruction of the given format, with the specified opcodes.
608 If it is, it sets the remaining arguments to the values of the
609 instruction's fields, and returns a non-zero value; otherwise, it
612 These functions' arguments appear in the order they appear in the
613 instruction, not in the machine-language form. So, opcodes always
614 come first, even though they're sometimes scattered around the
615 instructions. And displacements appear before base and extension
616 registers, as they do in the assembly syntax, not at the end, as
617 they do in the machine language. */
619 is_ri (bfd_byte
*insn
, int op1
, int op2
, unsigned int *r1
, int *i2
)
621 if (insn
[0] == op1
&& (insn
[1] & 0xf) == op2
)
623 *r1
= (insn
[1] >> 4) & 0xf;
624 /* i2 is a 16-bit signed quantity. */
625 *i2
= (((insn
[2] << 8) | insn
[3]) ^ 0x8000) - 0x8000;
634 is_ril (bfd_byte
*insn
, int op1
, int op2
,
635 unsigned int *r1
, int *i2
)
637 if (insn
[0] == op1
&& (insn
[1] & 0xf) == op2
)
639 *r1
= (insn
[1] >> 4) & 0xf;
640 /* i2 is a signed quantity. If the host 'int' is 32 bits long,
641 no sign extension is necessary, but we don't want to assume
643 *i2
= (((insn
[2] << 24)
646 | (insn
[5])) ^ 0x80000000) - 0x80000000;
655 is_rr (bfd_byte
*insn
, int op
, unsigned int *r1
, unsigned int *r2
)
659 *r1
= (insn
[1] >> 4) & 0xf;
669 is_rre (bfd_byte
*insn
, int op
, unsigned int *r1
, unsigned int *r2
)
671 if (((insn
[0] << 8) | insn
[1]) == op
)
673 /* Yes, insn[3]. insn[2] is unused in RRE format. */
674 *r1
= (insn
[3] >> 4) & 0xf;
684 is_rs (bfd_byte
*insn
, int op
,
685 unsigned int *r1
, unsigned int *r3
, unsigned int *d2
, unsigned int *b2
)
689 *r1
= (insn
[1] >> 4) & 0xf;
691 *b2
= (insn
[2] >> 4) & 0xf;
692 *d2
= ((insn
[2] & 0xf) << 8) | insn
[3];
701 is_rse (bfd_byte
*insn
, int op1
, int op2
,
702 unsigned int *r1
, unsigned int *r3
, unsigned int *d2
, unsigned int *b2
)
705 /* Yes, insn[5]. insn[4] is unused. */
708 *r1
= (insn
[1] >> 4) & 0xf;
710 *b2
= (insn
[2] >> 4) & 0xf;
711 *d2
= ((insn
[2] & 0xf) << 8) | insn
[3];
720 is_rx (bfd_byte
*insn
, int op
,
721 unsigned int *r1
, unsigned int *d2
, unsigned int *x2
, unsigned int *b2
)
725 *r1
= (insn
[1] >> 4) & 0xf;
727 *b2
= (insn
[2] >> 4) & 0xf;
728 *d2
= ((insn
[2] & 0xf) << 8) | insn
[3];
737 is_rxe (bfd_byte
*insn
, int op1
, int op2
,
738 unsigned int *r1
, unsigned int *d2
, unsigned int *x2
, unsigned int *b2
)
741 /* Yes, insn[5]. insn[4] is unused. */
744 *r1
= (insn
[1] >> 4) & 0xf;
746 *b2
= (insn
[2] >> 4) & 0xf;
747 *d2
= ((insn
[2] & 0xf) << 8) | insn
[3];
755 /* Set ADDR to the effective address for an X-style instruction, like:
759 Here, X2 and B2 are registers, and D2 is an unsigned 12-bit
760 constant; the effective address is the sum of all three. If either
761 X2 or B2 are zero, then it doesn't contribute to the sum --- this
762 means that r0 can't be used as either X2 or B2.
764 GPR is an array of general register values, indexed by GPR number,
765 not GDB register number. */
767 compute_x_addr (struct prologue_value
*addr
,
768 struct prologue_value
*gpr
,
769 unsigned int d2
, unsigned int x2
, unsigned int b2
)
771 /* We can't just add stuff directly in addr; it might alias some of
772 the registers we need to read. */
773 struct prologue_value result
;
775 pv_set_to_constant (&result
, d2
);
777 pv_add (&result
, &result
, &gpr
[x2
]);
779 pv_add (&result
, &result
, &gpr
[b2
]);
785 /* The number of GPR and FPR spill slots in an S/390 stack frame. We
786 track general-purpose registers r2 -- r15, and floating-point
787 registers f0, f2, f4, and f6. */
788 #define S390_NUM_SPILL_SLOTS (14 + 4)
791 /* If the SIZE bytes at ADDR are a stack slot we're actually tracking,
792 return pv_definite_yes and set *STACK to point to the slot. If
793 we're sure that they are not any of our stack slots, then return
794 pv_definite_no. Otherwise, return pv_maybe.
795 - GPR is an array indexed by GPR number giving the current values
796 of the general-purpose registers.
797 - SPILL is an array tracking the spill area of the caller's frame;
798 SPILL[i] is the i'th spill slot. The spill slots are designated
799 for r2 -- r15, and then f0, f2, f4, and f6.
800 - BACK_CHAIN is the value of the back chain slot; it's only valid
801 when the current frame actually has some space for a back chain
802 slot --- that is, when the current value of the stack pointer
803 (according to GPR) is at least S390_STACK_FRAME_OVERHEAD bytes
804 less than its original value. */
805 static enum pv_boolean
806 s390_on_stack (struct prologue_value
*addr
,
808 struct prologue_value
*gpr
,
809 struct prologue_value
*spill
,
810 struct prologue_value
*back_chain
,
811 struct prologue_value
**stack
)
813 struct prologue_value gpr_spill_addr
;
814 struct prologue_value fpr_spill_addr
;
815 struct prologue_value back_chain_addr
;
819 /* Construct the addresses of the spill arrays and the back chain. */
820 pv_set_to_register (&gpr_spill_addr
, S390_SP_REGNUM
, 2 * S390_GPR_SIZE
);
821 pv_set_to_register (&fpr_spill_addr
, S390_SP_REGNUM
, 16 * S390_GPR_SIZE
);
822 back_chain_addr
= gpr
[S390_SP_REGNUM
- S390_GP0_REGNUM
];
824 /* We have to check for GPR and FPR references using two separate
825 calls to pv_is_array_ref, since the GPR and FPR spill slots are
826 different sizes. (SPILL is an array, but the thing it tracks
827 isn't really an array.) */
829 /* Was it a reference to the GPR spill array? */
830 b
= pv_is_array_ref (addr
, size
, &gpr_spill_addr
, 14, S390_GPR_SIZE
, &i
);
831 if (b
== pv_definite_yes
)
834 return pv_definite_yes
;
839 /* Was it a reference to the FPR spill array? */
840 b
= pv_is_array_ref (addr
, size
, &fpr_spill_addr
, 4, S390_FPR_SIZE
, &i
);
841 if (b
== pv_definite_yes
)
843 *stack
= &spill
[14 + i
];
844 return pv_definite_yes
;
849 /* Was it a reference to the back chain?
850 This isn't quite right. We ought to check whether we have
851 actually allocated any new frame at all. */
852 b
= pv_is_array_ref (addr
, size
, &back_chain_addr
, 1, S390_GPR_SIZE
, &i
);
853 if (b
== pv_definite_yes
)
856 return pv_definite_yes
;
861 /* All the above queries returned definite 'no's. */
862 return pv_definite_no
;
866 /* Do a SIZE-byte store of VALUE to ADDR. GPR, SPILL, and BACK_CHAIN,
867 and the return value are as described for s390_on_stack, above.
868 Note that, when this returns pv_maybe, we have to assume that all
869 of our memory now contains unknown values. */
870 static enum pv_boolean
871 s390_store (struct prologue_value
*addr
,
873 struct prologue_value
*value
,
874 struct prologue_value
*gpr
,
875 struct prologue_value
*spill
,
876 struct prologue_value
*back_chain
)
878 struct prologue_value
*stack
;
879 enum pv_boolean on_stack
880 = s390_on_stack (addr
, size
, gpr
, spill
, back_chain
, &stack
);
882 if (on_stack
== pv_definite_yes
)
889 /* The current frame looks like a signal delivery frame: the first
890 instruction is an 'svc' opcode. If the next frame is a signal
891 handler's frame, set FI's saved register map to point into the
892 signal context structure. */
894 s390_get_signal_frame_info (struct frame_info
*fi
)
896 struct frame_info
*next_frame
= get_next_frame (fi
);
899 && get_frame_extra_info (next_frame
)
900 && get_frame_extra_info (next_frame
)->sigcontext
)
902 /* We're definitely backtracing from a signal handler. */
903 CORE_ADDR
*saved_regs
= deprecated_get_frame_saved_regs (fi
);
904 CORE_ADDR save_reg_addr
= (get_frame_extra_info (next_frame
)->sigcontext
905 + DEPRECATED_REGISTER_BYTE (S390_GP0_REGNUM
));
908 for (reg
= 0; reg
< S390_NUM_GPRS
; reg
++)
910 saved_regs
[S390_GP0_REGNUM
+ reg
] = save_reg_addr
;
911 save_reg_addr
+= S390_GPR_SIZE
;
914 save_reg_addr
= (get_frame_extra_info (next_frame
)->sigcontext
915 + (GDB_TARGET_IS_ESAME
? S390X_SIGREGS_FP0_OFFSET
:
916 S390_SIGREGS_FP0_OFFSET
));
917 for (reg
= 0; reg
< S390_NUM_FPRS
; reg
++)
919 saved_regs
[S390_FP0_REGNUM
+ reg
] = save_reg_addr
;
920 save_reg_addr
+= S390_FPR_SIZE
;
927 s390_get_frame_info (CORE_ADDR start_pc
,
928 struct frame_extra_info
*fextra_info
,
929 struct frame_info
*fi
,
933 zero if we were able to read all the instructions we wanted, or
934 -1 if we got an error trying to read memory. */
937 /* The current PC for our abstract interpretation. */
940 /* The address of the next instruction after that. */
943 /* The general-purpose registers. */
944 struct prologue_value gpr
[S390_NUM_GPRS
];
946 /* The floating-point registers. */
947 struct prologue_value fpr
[S390_NUM_FPRS
];
949 /* The register spill stack slots in the caller's frame ---
950 general-purpose registers r2 through r15, and floating-point
951 registers. spill[i] is where gpr i+2 gets spilled;
952 spill[(14, 15, 16, 17)] is where (f0, f2, f4, f6) get spilled. */
953 struct prologue_value spill
[S390_NUM_SPILL_SLOTS
];
955 /* The value of the back chain slot. This is only valid if the stack
956 pointer is known to be less than its original value --- that is,
957 if we have indeed allocated space on the stack. */
958 struct prologue_value back_chain
;
960 /* The address of the instruction after the last one that changed
961 the SP, FP, or back chain. */
962 CORE_ADDR after_last_frame_setup_insn
= start_pc
;
964 /* Set up everything's initial value. */
968 for (i
= 0; i
< S390_NUM_GPRS
; i
++)
969 pv_set_to_register (&gpr
[i
], S390_GP0_REGNUM
+ i
, 0);
971 for (i
= 0; i
< S390_NUM_FPRS
; i
++)
972 pv_set_to_register (&fpr
[i
], S390_FP0_REGNUM
+ i
, 0);
974 for (i
= 0; i
< S390_NUM_SPILL_SLOTS
; i
++)
975 pv_set_to_unknown (&spill
[i
]);
977 pv_set_to_unknown (&back_chain
);
980 /* Start interpreting instructions, until we hit something we don't
981 know how to interpret. (Ideally, we should stop at the frame's
982 real current PC, but at the moment, our callers don't give us
984 for (pc
= start_pc
; ; pc
= next_pc
)
986 bfd_byte insn
[S390_MAX_INSTR_SIZE
];
987 int insn_len
= s390_readinstruction (insn
, pc
);
989 /* Fields for various kinds of instructions. */
990 unsigned int b2
, r1
, r2
, d2
, x2
, r3
;
993 /* The values of SP, FP, and back chain before this instruction,
994 for detecting instructions that change them. */
995 struct prologue_value pre_insn_sp
, pre_insn_fp
, pre_insn_back_chain
;
997 /* If we got an error trying to read the instruction, report it. */
1004 next_pc
= pc
+ insn_len
;
1006 pre_insn_sp
= gpr
[S390_SP_REGNUM
- S390_GP0_REGNUM
];
1007 pre_insn_fp
= gpr
[S390_FRAME_REGNUM
- S390_GP0_REGNUM
];
1008 pre_insn_back_chain
= back_chain
;
1010 /* A special case, first --- only recognized as the very first
1011 instruction of the function, for signal delivery frames:
1012 SVC i --- system call */
1014 && is_rr (insn
, op_svc
, &r1
, &r2
))
1017 s390_get_signal_frame_info (fi
);
1021 /* AHI r1, i2 --- add halfword immediate */
1022 else if (is_ri (insn
, op1_ahi
, op2_ahi
, &r1
, &i2
))
1023 pv_add_constant (&gpr
[r1
], i2
);
1026 /* AGHI r1, i2 --- add halfword immediate (64-bit version) */
1027 else if (GDB_TARGET_IS_ESAME
1028 && is_ri (insn
, op1_aghi
, op2_aghi
, &r1
, &i2
))
1029 pv_add_constant (&gpr
[r1
], i2
);
1031 /* AR r1, r2 -- add register */
1032 else if (is_rr (insn
, op_ar
, &r1
, &r2
))
1033 pv_add (&gpr
[r1
], &gpr
[r1
], &gpr
[r2
]);
1035 /* BASR r1, 0 --- branch and save
1036 Since r2 is zero, this saves the PC in r1, but doesn't branch. */
1037 else if (is_rr (insn
, op_basr
, &r1
, &r2
)
1039 pv_set_to_constant (&gpr
[r1
], next_pc
);
1041 /* BRAS r1, i2 --- branch relative and save */
1042 else if (is_ri (insn
, op1_bras
, op2_bras
, &r1
, &i2
))
1044 pv_set_to_constant (&gpr
[r1
], next_pc
);
1045 next_pc
= pc
+ i2
* 2;
1047 /* We'd better not interpret any backward branches. We'll
1053 /* L r1, d2(x2, b2) --- load */
1054 else if (is_rx (insn
, op_l
, &r1
, &d2
, &x2
, &b2
))
1056 struct prologue_value addr
;
1057 struct prologue_value
*stack
;
1059 compute_x_addr (&addr
, gpr
, d2
, x2
, b2
);
1061 /* If it's a load from an in-line constant pool, then we can
1062 simulate that, under the assumption that the code isn't
1063 going to change between the time the processor actually
1064 executed it creating the current frame, and the time when
1065 we're analyzing the code to unwind past that frame. */
1066 if (addr
.kind
== pv_constant
1067 && start_pc
<= addr
.k
1068 && addr
.k
< next_pc
)
1069 pv_set_to_constant (&gpr
[r1
],
1070 read_memory_integer (addr
.k
, 4));
1072 /* If it's definitely a reference to something on the stack,
1074 else if (s390_on_stack (&addr
, 4, gpr
, spill
, &back_chain
, &stack
)
1078 /* Otherwise, we don't know the value. */
1080 pv_set_to_unknown (&gpr
[r1
]);
1083 /* LA r1, d2(x2, b2) --- load address */
1084 else if (is_rx (insn
, op_la
, &r1
, &d2
, &x2
, &b2
))
1085 compute_x_addr (&gpr
[r1
], gpr
, d2
, x2
, b2
);
1087 /* LARL r1, i2 --- load address relative long */
1088 else if (GDB_TARGET_IS_ESAME
1089 && is_ril (insn
, op1_larl
, op2_larl
, &r1
, &i2
))
1090 pv_set_to_constant (&gpr
[r1
], pc
+ i2
* 2);
1092 /* LGR r1, r2 --- load from register */
1093 else if (GDB_TARGET_IS_ESAME
1094 && is_rre (insn
, op_lgr
, &r1
, &r2
))
1097 /* LHI r1, i2 --- load halfword immediate */
1098 else if (is_ri (insn
, op1_lhi
, op2_lhi
, &r1
, &i2
))
1099 pv_set_to_constant (&gpr
[r1
], i2
);
1101 /* LGHI r1, i2 --- load halfword immediate --- 64-bit version */
1102 else if (is_ri (insn
, op1_lghi
, op2_lghi
, &r1
, &i2
))
1103 pv_set_to_constant (&gpr
[r1
], i2
);
1105 /* LR r1, r2 --- load from register */
1106 else if (is_rr (insn
, op_lr
, &r1
, &r2
))
1109 /* NGR r1, r2 --- logical and --- 64-bit version */
1110 else if (GDB_TARGET_IS_ESAME
1111 && is_rre (insn
, op_ngr
, &r1
, &r2
))
1112 pv_logical_and (&gpr
[r1
], &gpr
[r1
], &gpr
[r2
]);
1114 /* NR r1, r2 --- logical and */
1115 else if (is_rr (insn
, op_nr
, &r1
, &r2
))
1116 pv_logical_and (&gpr
[r1
], &gpr
[r1
], &gpr
[r2
]);
1118 /* NGR r1, r2 --- logical and --- 64-bit version */
1119 else if (GDB_TARGET_IS_ESAME
1120 && is_rre (insn
, op_ngr
, &r1
, &r2
))
1121 pv_logical_and (&gpr
[r1
], &gpr
[r1
], &gpr
[r2
]);
1123 /* NR r1, r2 --- logical and */
1124 else if (is_rr (insn
, op_nr
, &r1
, &r2
))
1125 pv_logical_and (&gpr
[r1
], &gpr
[r1
], &gpr
[r2
]);
1127 /* S r1, d2(x2, b2) --- subtract from memory */
1128 else if (is_rx (insn
, op_s
, &r1
, &d2
, &x2
, &b2
))
1130 struct prologue_value addr
;
1131 struct prologue_value value
;
1132 struct prologue_value
*stack
;
1134 compute_x_addr (&addr
, gpr
, d2
, x2
, b2
);
1136 /* If it's a load from an in-line constant pool, then we can
1137 simulate that, under the assumption that the code isn't
1138 going to change between the time the processor actually
1139 executed it and the time when we're analyzing it. */
1140 if (addr
.kind
== pv_constant
1141 && start_pc
<= addr
.k
1143 pv_set_to_constant (&value
, read_memory_integer (addr
.k
, 4));
1145 /* If it's definitely a reference to something on the stack,
1146 we could do that. */
1147 else if (s390_on_stack (&addr
, 4, gpr
, spill
, &back_chain
, &stack
)
1151 /* Otherwise, we don't know the value. */
1153 pv_set_to_unknown (&value
);
1155 pv_subtract (&gpr
[r1
], &gpr
[r1
], &value
);
1158 /* ST r1, d2(x2, b2) --- store */
1159 else if (is_rx (insn
, op_st
, &r1
, &d2
, &x2
, &b2
))
1161 struct prologue_value addr
;
1163 compute_x_addr (&addr
, gpr
, d2
, x2
, b2
);
1165 /* The below really should be '4', not 'S390_GPR_SIZE'; this
1166 instruction always stores 32 bits, regardless of the full
1168 if (s390_store (&addr
, 4, &gpr
[r1
], gpr
, spill
, &back_chain
)
1170 /* If we can't be sure that it's *not* a store to
1171 something we're tracing, then we would have to mark all
1172 our memory as unknown --- after all, it *could* be a
1173 store to any of them --- so we might as well just stop
1178 /* STD r1, d2(x2,b2) --- store floating-point register */
1179 else if (is_rx (insn
, op_std
, &r1
, &d2
, &x2
, &b2
))
1181 struct prologue_value addr
;
1183 compute_x_addr (&addr
, gpr
, d2
, x2
, b2
);
1185 if (s390_store (&addr
, 8, &fpr
[r1
], gpr
, spill
, &back_chain
)
1187 /* If we can't be sure that it's *not* a store to
1188 something we're tracing, then we would have to mark all
1189 our memory as unknown --- after all, it *could* be a
1190 store to any of them --- so we might as well just stop
1195 /* STG r1, d2(x2, b2) --- 64-bit store */
1196 else if (GDB_TARGET_IS_ESAME
1197 && is_rxe (insn
, op1_stg
, op2_stg
, &r1
, &d2
, &x2
, &b2
))
1199 struct prologue_value addr
;
1201 compute_x_addr (&addr
, gpr
, d2
, x2
, b2
);
1203 /* The below really should be '8', not 'S390_GPR_SIZE'; this
1204 instruction always stores 64 bits, regardless of the full
1206 if (s390_store (&addr
, 8, &gpr
[r1
], gpr
, spill
, &back_chain
)
1208 /* If we can't be sure that it's *not* a store to
1209 something we're tracing, then we would have to mark all
1210 our memory as unknown --- after all, it *could* be a
1211 store to any of them --- so we might as well just stop
1216 /* STM r1, r3, d2(b2) --- store multiple */
1217 else if (is_rs (insn
, op_stm
, &r1
, &r3
, &d2
, &b2
))
1221 struct prologue_value addr
;
1223 for (regnum
= r1
, offset
= 0;
1225 regnum
++, offset
+= 4)
1227 compute_x_addr (&addr
, gpr
, d2
+ offset
, 0, b2
);
1229 if (s390_store (&addr
, 4, &gpr
[regnum
], gpr
, spill
, &back_chain
)
1231 /* If we can't be sure that it's *not* a store to
1232 something we're tracing, then we would have to mark all
1233 our memory as unknown --- after all, it *could* be a
1234 store to any of them --- so we might as well just stop
1239 /* If we left the loop early, we should stop interpreting
1245 /* STMG r1, r3, d2(b2) --- store multiple, 64-bit */
1246 else if (GDB_TARGET_IS_ESAME
1247 && is_rse (insn
, op1_stmg
, op2_stmg
, &r1
, &r3
, &d2
, &b2
))
1251 struct prologue_value addr
;
1253 for (regnum
= r1
, offset
= 0;
1255 regnum
++, offset
+= 8)
1257 compute_x_addr (&addr
, gpr
, d2
+ offset
, 0, b2
);
1259 if (s390_store (&addr
, 8, &gpr
[regnum
], gpr
, spill
, &back_chain
)
1261 /* If we can't be sure that it's *not* a store to
1262 something we're tracing, then we would have to mark all
1263 our memory as unknown --- after all, it *could* be a
1264 store to any of them --- so we might as well just stop
1269 /* If we left the loop early, we should stop interpreting
1276 /* An instruction we don't know how to simulate. The only
1277 safe thing to do would be to set every value we're tracking
1278 to 'unknown'. Instead, we'll be optimistic: we just stop
1279 interpreting, and assume that the machine state we've got
1280 now is good enough for unwinding the stack. */
1283 /* Record the address after the last instruction that changed
1284 the FP, SP, or backlink. Ignore instructions that changed
1285 them back to their original values --- those are probably
1286 restore instructions. (The back chain is never restored,
1289 struct prologue_value
*sp
= &gpr
[S390_SP_REGNUM
- S390_GP0_REGNUM
];
1290 struct prologue_value
*fp
= &gpr
[S390_FRAME_REGNUM
- S390_GP0_REGNUM
];
1292 if ((! pv_is_identical (&pre_insn_sp
, sp
)
1293 && ! pv_is_register (sp
, S390_SP_REGNUM
, 0))
1294 || (! pv_is_identical (&pre_insn_fp
, fp
)
1295 && ! pv_is_register (fp
, S390_FRAME_REGNUM
, 0))
1296 || ! pv_is_identical (&pre_insn_back_chain
, &back_chain
))
1297 after_last_frame_setup_insn
= next_pc
;
1301 /* Okay, now gpr[], fpr[], spill[], and back_chain reflect the state
1302 of the machine as of the first instruction we couldn't interpret
1303 (hopefully the first non-prologue instruction). */
1305 /* The size of the frame, or (CORE_ADDR) -1 if we couldn't figure
1307 CORE_ADDR frame_size
= -1;
1309 /* The value the SP had upon entry to the function, or
1310 (CORE_ADDR) -1 if we can't figure that out. */
1311 CORE_ADDR original_sp
= -1;
1313 /* Are we using S390_FRAME_REGNUM as a frame pointer register? */
1314 int using_frame_pointer
= 0;
1316 /* If S390_FRAME_REGNUM is some constant offset from the SP, then
1317 that strongly suggests that we're going to use that as our
1318 frame pointer register, not the SP. */
1320 struct prologue_value
*fp
= &gpr
[S390_FRAME_REGNUM
- S390_GP0_REGNUM
];
1322 if (fp
->kind
== pv_register
1323 && fp
->reg
== S390_SP_REGNUM
)
1324 using_frame_pointer
= 1;
1327 /* If we were given a frame_info structure, we may be able to use
1328 the frame's base address to figure out the actual value of the
1330 if (fi
&& get_frame_base (fi
))
1332 int frame_base_regno
;
1333 struct prologue_value
*frame_base
;
1335 /* The meaning of the frame base depends on whether the
1336 function uses a frame pointer register other than the SP or
1337 not (see s390_read_fp):
1338 - If the function does use a frame pointer register other
1339 than the SP, then the frame base is that register's
1341 - If the function doesn't use a frame pointer, then the
1342 frame base is the SP itself.
1343 We're duplicating some of the logic of s390_fp_regnum here,
1344 but we don't want to call that, because it would just do
1345 exactly the same analysis we've already done above. */
1346 if (using_frame_pointer
)
1347 frame_base_regno
= S390_FRAME_REGNUM
;
1349 frame_base_regno
= S390_SP_REGNUM
;
1351 frame_base
= &gpr
[frame_base_regno
- S390_GP0_REGNUM
];
1353 /* We know the frame base address; if the value of whatever
1354 register it came from is a constant offset from the
1355 original SP, then we can reconstruct the original SP just
1356 by subtracting off that constant. */
1357 if (frame_base
->kind
== pv_register
1358 && frame_base
->reg
== S390_SP_REGNUM
)
1359 original_sp
= get_frame_base (fi
) - frame_base
->k
;
1362 /* If the analysis said that the current SP value is the original
1363 value less some constant, then that constant is the frame size. */
1365 struct prologue_value
*sp
= &gpr
[S390_SP_REGNUM
- S390_GP0_REGNUM
];
1367 if (sp
->kind
== pv_register
1368 && sp
->reg
== S390_SP_REGNUM
)
1369 frame_size
= -sp
->k
;
1372 /* If we knew other registers' current values, we could check if
1373 the analysis said any of those were related to the original SP
1374 value, too. But for now, we'll just punt. */
1376 /* If the caller passed in an 'extra info' structure, fill in the
1380 if (init_extra_info
|| ! fextra_info
->initialised
)
1382 s390_memset_extra_info (fextra_info
);
1383 fextra_info
->function_start
= start_pc
;
1384 fextra_info
->initialised
= 1;
1387 if (frame_size
!= -1)
1389 fextra_info
->stack_bought_valid
= 1;
1390 fextra_info
->stack_bought
= frame_size
;
1393 /* Assume everything was okay, and indicate otherwise when we
1394 find something amiss. */
1395 fextra_info
->good_prologue
= 1;
1397 if (using_frame_pointer
)
1398 /* Actually, nobody cares about the exact PC, so any
1399 non-zero value will do here. */
1400 fextra_info
->frame_pointer_saved_pc
= 1;
1402 /* If we weren't able to find the size of the frame, or find
1403 the original sp based on actual current register values,
1404 then we're not going to be able to unwind this frame.
1406 (If we're just doing prologue analysis to set a breakpoint,
1407 then frame_size might be known, but original_sp unknown; if
1408 we're analyzing a real frame which uses alloca, then
1409 original_sp might be known (from the frame pointer
1410 register), but the frame size might be unknown.) */
1411 if (original_sp
== -1 && frame_size
== -1)
1412 fextra_info
->good_prologue
= 0;
1414 if (fextra_info
->good_prologue
)
1415 fextra_info
->skip_prologue_function_start
1416 = after_last_frame_setup_insn
;
1418 /* If the prologue was too complex for us to make sense of,
1419 then perhaps it's better to just not skip anything at
1421 fextra_info
->skip_prologue_function_start
= start_pc
;
1424 /* Indicate where registers were saved on the stack, if:
1425 - the caller seems to want to know,
1426 - the caller provided an actual SP, and
1427 - the analysis gave us enough information to actually figure it
1430 && deprecated_get_frame_saved_regs (fi
)
1431 && original_sp
!= -1)
1434 CORE_ADDR slot_addr
;
1435 CORE_ADDR
*saved_regs
= deprecated_get_frame_saved_regs (fi
);
1437 /* Scan the spill array; if a spill slot says it holds the
1438 original value of some register, then record that slot's
1439 address as the place that register was saved.
1441 Just for kicks, note that, even if registers aren't saved
1442 in their officially-sanctioned slots, this will still work
1443 --- we know what really got put where. */
1445 /* First, the slots for r2 -- r15. */
1446 for (slot_num
= 0, slot_addr
= original_sp
+ 2 * S390_GPR_SIZE
;
1448 slot_num
++, slot_addr
+= S390_GPR_SIZE
)
1450 struct prologue_value
*slot
= &spill
[slot_num
];
1452 if (slot
->kind
== pv_register
1454 saved_regs
[slot
->reg
] = slot_addr
;
1457 /* Then, the slots for f0, f2, f4, and f6. They're a
1459 for (slot_num
= 14, slot_addr
= original_sp
+ 16 * S390_GPR_SIZE
;
1460 slot_num
< S390_NUM_SPILL_SLOTS
;
1461 slot_num
++, slot_addr
+= S390_FPR_SIZE
)
1463 struct prologue_value
*slot
= &spill
[slot_num
];
1465 if (slot
->kind
== pv_register
1467 saved_regs
[slot
->reg
] = slot_addr
;
1470 /* The stack pointer's element of saved_regs[] is special. */
1471 saved_regs
[S390_SP_REGNUM
] = original_sp
;
1480 s390_check_function_end (CORE_ADDR pc
)
1482 bfd_byte instr
[S390_MAX_INSTR_SIZE
];
1483 int regidx
, instrlen
;
1485 instrlen
= s390_readinstruction (instr
, pc
);
1489 if (instrlen
!= 2 || instr
[0] != 07 || (instr
[1] >> 4) != 0xf)
1491 regidx
= instr
[1] & 0xf;
1492 /* Check for LMG or LG */
1494 s390_readinstruction (instr
, pc
- (GDB_TARGET_IS_ESAME
? 6 : 4));
1497 if (GDB_TARGET_IS_ESAME
)
1500 if (instrlen
!= 6 || instr
[0] != 0xeb || instr
[5] != 0x4)
1503 else if (instrlen
!= 4 || instr
[0] != 0x98)
1507 if ((instr
[2] >> 4) != 0xf)
1511 instrlen
= s390_readinstruction (instr
, pc
- (GDB_TARGET_IS_ESAME
? 12 : 8));
1514 if (GDB_TARGET_IS_ESAME
)
1517 if (instrlen
!= 6 || instr
[0] != 0xe3 || instr
[5] != 0x4)
1523 if (instrlen
!= 4 || instr
[0] != 0x58)
1526 if (instr
[2] >> 4 != 0xf)
1528 if (instr
[1] >> 4 != regidx
)
1534 s390_sniff_pc_function_start (CORE_ADDR pc
, struct frame_info
*fi
)
1536 CORE_ADDR function_start
, test_function_start
;
1537 int loop_cnt
, err
, function_end
;
1538 struct frame_extra_info fextra_info
;
1539 function_start
= get_pc_function_start (pc
);
1541 if (function_start
== 0)
1543 test_function_start
= pc
;
1544 if (test_function_start
& 1)
1545 return 0; /* This has to be bogus */
1551 s390_get_frame_info (test_function_start
, &fextra_info
, fi
, 1);
1553 test_function_start
-= 2;
1554 function_end
= s390_check_function_end (test_function_start
);
1556 while (!(function_end
== 1 || err
|| loop_cnt
>= 4096 ||
1557 (fextra_info
.good_prologue
)));
1558 if (fextra_info
.good_prologue
)
1559 function_start
= fextra_info
.function_start
;
1560 else if (function_end
== 1)
1561 function_start
= test_function_start
;
1563 return function_start
;
1568 s390_frameless_function_invocation (struct frame_info
*fi
)
1570 struct frame_extra_info fextra_info
, *fextra_info_ptr
;
1573 if (get_next_frame (fi
) == NULL
) /* no may be frameless */
1575 if (get_frame_extra_info (fi
))
1576 fextra_info_ptr
= get_frame_extra_info (fi
);
1579 fextra_info_ptr
= &fextra_info
;
1580 s390_get_frame_info (s390_sniff_pc_function_start (get_frame_pc (fi
), fi
),
1581 fextra_info_ptr
, fi
, 1);
1583 frameless
= (fextra_info_ptr
->stack_bought_valid
1584 && fextra_info_ptr
->stack_bought
== 0);
1592 s390_is_sigreturn (CORE_ADDR pc
, struct frame_info
*sighandler_fi
,
1593 CORE_ADDR
*sregs
, CORE_ADDR
*sigcaller_pc
)
1595 bfd_byte instr
[S390_MAX_INSTR_SIZE
];
1600 CORE_ADDR temp_sregs
;
1602 scontext
= temp_sregs
= 0;
1604 instrlen
= s390_readinstruction (instr
, pc
);
1607 if (((instrlen
== S390_SYSCALL_SIZE
) &&
1608 (instr
[0] == S390_SYSCALL_OPCODE
)) &&
1609 ((instr
[1] == s390_NR_sigreturn
) || (instr
[1] == s390_NR_rt_sigreturn
)))
1613 if (s390_frameless_function_invocation (sighandler_fi
))
1614 orig_sp
= get_frame_base (sighandler_fi
);
1616 orig_sp
= ADDR_BITS_REMOVE ((CORE_ADDR
)
1617 read_memory_integer (get_frame_base (sighandler_fi
),
1619 if (orig_sp
&& sigcaller_pc
)
1621 scontext
= orig_sp
+ S390_SIGNAL_FRAMESIZE
;
1622 if (pc
== scontext
&& instr
[1] == s390_NR_rt_sigreturn
)
1624 /* We got a new style rt_signal */
1625 /* get address of read ucontext->uc_mcontext */
1626 temp_sregs
= orig_sp
+ (GDB_TARGET_IS_ESAME
?
1627 S390X_UC_MCONTEXT_OFFSET
:
1628 S390_UC_MCONTEXT_OFFSET
);
1632 /* read sigcontext->sregs */
1633 temp_sregs
= ADDR_BITS_REMOVE ((CORE_ADDR
)
1634 read_memory_integer (scontext
1636 (GDB_TARGET_IS_ESAME
1638 S390X_SIGCONTEXT_SREGS_OFFSET
1640 S390_SIGCONTEXT_SREGS_OFFSET
),
1644 /* read sigregs->psw.addr */
1646 ADDR_BITS_REMOVE ((CORE_ADDR
)
1647 read_memory_integer (temp_sregs
+
1648 DEPRECATED_REGISTER_BYTE (S390_PC_REGNUM
),
1649 S390_PSW_ADDR_SIZE
));
1655 *sregs
= temp_sregs
;
1660 We need to do something better here but this will keep us out of trouble
1662 For some reason the blockframe.c calls us with fi->next->fromleaf
1663 so this seems of little use to us. */
1665 s390_init_frame_pc_first (int next_fromleaf
, struct frame_info
*fi
)
1667 CORE_ADDR sigcaller_pc
;
1671 pc
= ADDR_BITS_REMOVE (read_register (S390_RETADDR_REGNUM
));
1672 /* fix signal handlers */
1674 else if (get_next_frame (fi
) && get_frame_pc (get_next_frame (fi
)))
1675 pc
= s390_frame_saved_pc_nofix (get_next_frame (fi
));
1676 if (pc
&& get_next_frame (fi
) && get_frame_base (get_next_frame (fi
))
1677 && s390_is_sigreturn (pc
, get_next_frame (fi
), NULL
, &sigcaller_pc
))
1685 s390_init_extra_frame_info (int fromleaf
, struct frame_info
*fi
)
1687 frame_extra_info_zalloc (fi
, sizeof (struct frame_extra_info
));
1688 if (get_frame_pc (fi
))
1689 s390_get_frame_info (s390_sniff_pc_function_start (get_frame_pc (fi
), fi
),
1690 get_frame_extra_info (fi
), fi
, 1);
1692 s390_memset_extra_info (get_frame_extra_info (fi
));
1695 /* If saved registers of frame FI are not known yet, read and cache them.
1696 &FEXTRA_INFOP contains struct frame_extra_info; TDATAP can be NULL,
1697 in which case the framedata are read. */
1700 s390_frame_init_saved_regs (struct frame_info
*fi
)
1705 if (deprecated_get_frame_saved_regs (fi
) == NULL
)
1707 /* zalloc memsets the saved regs */
1708 frame_saved_regs_zalloc (fi
);
1709 if (get_frame_pc (fi
))
1711 quick
= (get_frame_extra_info (fi
)
1712 && get_frame_extra_info (fi
)->initialised
1713 && get_frame_extra_info (fi
)->good_prologue
);
1714 s390_get_frame_info (quick
1715 ? get_frame_extra_info (fi
)->function_start
1716 : s390_sniff_pc_function_start (get_frame_pc (fi
), fi
),
1717 get_frame_extra_info (fi
), fi
, !quick
);
1725 s390_frame_saved_pc_nofix (struct frame_info
*fi
)
1727 if (get_frame_extra_info (fi
) && get_frame_extra_info (fi
)->saved_pc_valid
)
1728 return get_frame_extra_info (fi
)->saved_pc
;
1730 if (deprecated_generic_find_dummy_frame (get_frame_pc (fi
),
1731 get_frame_base (fi
)))
1732 return deprecated_read_register_dummy (get_frame_pc (fi
),
1733 get_frame_base (fi
), S390_PC_REGNUM
);
1735 s390_frame_init_saved_regs (fi
);
1736 if (get_frame_extra_info (fi
))
1738 get_frame_extra_info (fi
)->saved_pc_valid
= 1;
1739 if (get_frame_extra_info (fi
)->good_prologue
1740 && deprecated_get_frame_saved_regs (fi
)[S390_RETADDR_REGNUM
])
1741 get_frame_extra_info (fi
)->saved_pc
1742 = ADDR_BITS_REMOVE (read_memory_integer
1743 (deprecated_get_frame_saved_regs (fi
)[S390_RETADDR_REGNUM
],
1746 get_frame_extra_info (fi
)->saved_pc
1747 = ADDR_BITS_REMOVE (read_register (S390_RETADDR_REGNUM
));
1748 return get_frame_extra_info (fi
)->saved_pc
;
1754 s390_frame_saved_pc (struct frame_info
*fi
)
1756 CORE_ADDR saved_pc
= 0, sig_pc
;
1758 if (get_frame_extra_info (fi
)
1759 && get_frame_extra_info (fi
)->sig_fixed_saved_pc_valid
)
1760 return get_frame_extra_info (fi
)->sig_fixed_saved_pc
;
1761 saved_pc
= s390_frame_saved_pc_nofix (fi
);
1763 if (get_frame_extra_info (fi
))
1765 get_frame_extra_info (fi
)->sig_fixed_saved_pc_valid
= 1;
1768 if (s390_is_sigreturn (saved_pc
, fi
, NULL
, &sig_pc
))
1771 get_frame_extra_info (fi
)->sig_fixed_saved_pc
= saved_pc
;
1779 /* We want backtraces out of signal handlers so we don't set
1780 (get_frame_type (thisframe) == SIGTRAMP_FRAME) to 1 */
1783 s390_frame_chain (struct frame_info
*thisframe
)
1785 CORE_ADDR prev_fp
= 0;
1787 if (deprecated_generic_find_dummy_frame (get_frame_pc (thisframe
),
1788 get_frame_base (thisframe
)))
1789 return deprecated_read_register_dummy (get_frame_pc (thisframe
),
1790 get_frame_base (thisframe
),
1795 CORE_ADDR sregs
= 0;
1796 struct frame_extra_info prev_fextra_info
;
1798 memset (&prev_fextra_info
, 0, sizeof (prev_fextra_info
));
1799 if (get_frame_pc (thisframe
))
1801 CORE_ADDR saved_pc
, sig_pc
;
1803 saved_pc
= s390_frame_saved_pc_nofix (thisframe
);
1807 s390_is_sigreturn (saved_pc
, thisframe
, &sregs
, &sig_pc
)))
1809 s390_get_frame_info (s390_sniff_pc_function_start
1810 (saved_pc
, NULL
), &prev_fextra_info
, NULL
,
1816 /* read sigregs,regs.gprs[11 or 15] */
1817 prev_fp
= read_memory_integer (sregs
+
1818 DEPRECATED_REGISTER_BYTE (S390_GP0_REGNUM
+
1820 frame_pointer_saved_pc
1823 get_frame_extra_info (thisframe
)->sigcontext
= sregs
;
1827 if (deprecated_get_frame_saved_regs (thisframe
))
1831 if (prev_fextra_info
.frame_pointer_saved_pc
1832 && deprecated_get_frame_saved_regs (thisframe
)[S390_FRAME_REGNUM
])
1833 regno
= S390_FRAME_REGNUM
;
1835 regno
= S390_SP_REGNUM
;
1837 if (deprecated_get_frame_saved_regs (thisframe
)[regno
])
1839 /* The SP's entry of `saved_regs' is special. */
1840 if (regno
== S390_SP_REGNUM
)
1841 prev_fp
= deprecated_get_frame_saved_regs (thisframe
)[regno
];
1844 read_memory_integer (deprecated_get_frame_saved_regs (thisframe
)[regno
],
1850 return ADDR_BITS_REMOVE (prev_fp
);
1854 Whether struct frame_extra_info is actually needed I'll have to figure
1855 out as our frames are similar to rs6000 there is a possibility
1856 i386 dosen't need it. */
1860 /* NOTE: cagney/2003-10-31: "return_value" makes
1861 "extract_struct_value_address", "extract_return_value", and
1862 "use_struct_convention" redundant. */
1864 s390_cannot_extract_struct_value_address (struct regcache
*regcache
)
1869 /* a given return value in `regbuf' with a type `valtype', extract and copy its
1870 value into `valbuf' */
1872 s390_extract_return_value (struct type
*valtype
, char *regbuf
, char *valbuf
)
1874 /* floats and doubles are returned in fpr0. fpr's have a size of 8 bytes.
1875 We need to truncate the return value into float size (4 byte) if
1877 int len
= TYPE_LENGTH (valtype
);
1879 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
1880 memcpy (valbuf
, ®buf
[DEPRECATED_REGISTER_BYTE (S390_FP0_REGNUM
)], len
);
1884 /* return value is copied starting from r2. */
1885 if (TYPE_LENGTH (valtype
) < S390_GPR_SIZE
)
1886 offset
= S390_GPR_SIZE
- TYPE_LENGTH (valtype
);
1888 regbuf
+ DEPRECATED_REGISTER_BYTE (S390_GP0_REGNUM
+ 2) + offset
,
1889 TYPE_LENGTH (valtype
));
1895 s390_promote_integer_argument (struct type
*valtype
, char *valbuf
,
1896 char *reg_buff
, int *arglen
)
1898 char *value
= valbuf
;
1899 int len
= TYPE_LENGTH (valtype
);
1901 if (len
< S390_GPR_SIZE
)
1903 /* We need to upgrade this value to a register to pass it correctly */
1904 int idx
, diff
= S390_GPR_SIZE
- len
, negative
=
1905 (!TYPE_UNSIGNED (valtype
) && value
[0] & 0x80);
1906 for (idx
= 0; idx
< S390_GPR_SIZE
; idx
++)
1908 reg_buff
[idx
] = (idx
< diff
? (negative
? 0xff : 0x0) :
1912 *arglen
= S390_GPR_SIZE
;
1916 if (len
& (S390_GPR_SIZE
- 1))
1918 fprintf_unfiltered (gdb_stderr
,
1919 "s390_promote_integer_argument detected an argument not "
1920 "a multiple of S390_GPR_SIZE & greater than S390_GPR_SIZE "
1921 "we might not deal with this correctly.\n");
1930 s390_store_return_value (struct type
*valtype
, char *valbuf
)
1933 char *reg_buff
= alloca (max (S390_FPR_SIZE
, DEPRECATED_REGISTER_SIZE
)), *value
;
1935 if (TYPE_CODE (valtype
) == TYPE_CODE_FLT
)
1937 if (TYPE_LENGTH (valtype
) == 4
1938 || TYPE_LENGTH (valtype
) == 8)
1939 deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (S390_FP0_REGNUM
),
1940 valbuf
, TYPE_LENGTH (valtype
));
1942 error ("GDB is unable to return `long double' values "
1943 "on this architecture.");
1948 s390_promote_integer_argument (valtype
, valbuf
, reg_buff
, &arglen
);
1949 /* Everything else is returned in GPR2 and up. */
1950 deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (S390_GP0_REGNUM
+ 2),
1956 /* Not the most efficent code in the world */
1958 s390_fp_regnum (void)
1960 int regno
= S390_SP_REGNUM
;
1961 struct frame_extra_info fextra_info
;
1963 CORE_ADDR pc
= ADDR_BITS_REMOVE (read_register (S390_PC_REGNUM
));
1965 s390_get_frame_info (s390_sniff_pc_function_start (pc
, NULL
), &fextra_info
,
1967 if (fextra_info
.frame_pointer_saved_pc
)
1968 regno
= S390_FRAME_REGNUM
;
1975 return read_register (s390_fp_regnum ());
1980 s390_pop_frame_regular (struct frame_info
*frame
)
1984 write_register (S390_PC_REGNUM
, DEPRECATED_FRAME_SAVED_PC (frame
));
1986 /* Restore any saved registers. */
1987 if (deprecated_get_frame_saved_regs (frame
))
1989 for (regnum
= 0; regnum
< NUM_REGS
; regnum
++)
1990 if (deprecated_get_frame_saved_regs (frame
)[regnum
] != 0)
1994 value
= read_memory_unsigned_integer (deprecated_get_frame_saved_regs (frame
)[regnum
],
1995 DEPRECATED_REGISTER_RAW_SIZE (regnum
));
1996 write_register (regnum
, value
);
1999 /* Actually cut back the stack. Remember that the SP's element of
2000 saved_regs is the old SP itself, not the address at which it is
2002 write_register (S390_SP_REGNUM
, deprecated_get_frame_saved_regs (frame
)[S390_SP_REGNUM
]);
2005 /* Throw away any cached frame information. */
2006 flush_cached_frames ();
2010 /* Destroy the innermost (Top-Of-Stack) stack frame, restoring the
2011 machine state that was in effect before the frame was created.
2012 Used in the contexts of the "return" command, and of
2013 target function calls from the debugger. */
2015 s390_pop_frame (void)
2017 /* This function checks for and handles generic dummy frames, and
2018 calls back to our function for ordinary frames. */
2019 generic_pop_current_frame (s390_pop_frame_regular
);
2023 /* Return non-zero if TYPE is an integer-like type, zero otherwise.
2024 "Integer-like" types are those that should be passed the way
2025 integers are: integers, enums, ranges, characters, and booleans. */
2027 is_integer_like (struct type
*type
)
2029 enum type_code code
= TYPE_CODE (type
);
2031 return (code
== TYPE_CODE_INT
2032 || code
== TYPE_CODE_ENUM
2033 || code
== TYPE_CODE_RANGE
2034 || code
== TYPE_CODE_CHAR
2035 || code
== TYPE_CODE_BOOL
);
2039 /* Return non-zero if TYPE is a pointer-like type, zero otherwise.
2040 "Pointer-like" types are those that should be passed the way
2041 pointers are: pointers and references. */
2043 is_pointer_like (struct type
*type
)
2045 enum type_code code
= TYPE_CODE (type
);
2047 return (code
== TYPE_CODE_PTR
2048 || code
== TYPE_CODE_REF
);
2052 /* Return non-zero if TYPE is a `float singleton' or `double
2053 singleton', zero otherwise.
2055 A `T singleton' is a struct type with one member, whose type is
2056 either T or a `T singleton'. So, the following are all float
2060 struct { struct { float x; } x; };
2061 struct { struct { struct { float x; } x; } x; };
2065 WHY THE HECK DO WE CARE ABOUT THIS??? Well, it turns out that GCC
2066 passes all float singletons and double singletons as if they were
2067 simply floats or doubles. This is *not* what the ABI says it
2070 is_float_singleton (struct type
*type
)
2072 return (TYPE_CODE (type
) == TYPE_CODE_STRUCT
2073 && TYPE_NFIELDS (type
) == 1
2074 && (TYPE_CODE (TYPE_FIELD_TYPE (type
, 0)) == TYPE_CODE_FLT
2075 || is_float_singleton (TYPE_FIELD_TYPE (type
, 0))));
2079 /* Return non-zero if TYPE is a struct-like type, zero otherwise.
2080 "Struct-like" types are those that should be passed as structs are:
2083 As an odd quirk, not mentioned in the ABI, GCC passes float and
2084 double singletons as if they were a plain float, double, etc. (The
2085 corresponding union types are handled normally.) So we exclude
2086 those types here. *shrug* */
2088 is_struct_like (struct type
*type
)
2090 enum type_code code
= TYPE_CODE (type
);
2092 return (code
== TYPE_CODE_UNION
2093 || (code
== TYPE_CODE_STRUCT
&& ! is_float_singleton (type
)));
2097 /* Return non-zero if TYPE is a float-like type, zero otherwise.
2098 "Float-like" types are those that should be passed as
2099 floating-point values are.
2101 You'd think this would just be floats, doubles, long doubles, etc.
2102 But as an odd quirk, not mentioned in the ABI, GCC passes float and
2103 double singletons as if they were a plain float, double, etc. (The
2104 corresponding union types are handled normally.) So we include
2105 those types here. *shrug* */
2107 is_float_like (struct type
*type
)
2109 return (TYPE_CODE (type
) == TYPE_CODE_FLT
2110 || is_float_singleton (type
));
2114 /* Return non-zero if TYPE is considered a `DOUBLE_OR_FLOAT', as
2115 defined by the parameter passing conventions described in the
2116 "GNU/Linux for S/390 ELF Application Binary Interface Supplement".
2117 Otherwise, return zero. */
2119 is_double_or_float (struct type
*type
)
2121 return (is_float_like (type
)
2122 && (TYPE_LENGTH (type
) == 4
2123 || TYPE_LENGTH (type
) == 8));
2127 /* Return non-zero if TYPE is a `DOUBLE_ARG', as defined by the
2128 parameter passing conventions described in the "GNU/Linux for S/390
2129 ELF Application Binary Interface Supplement". Return zero
2132 is_double_arg (struct type
*type
)
2134 unsigned length
= TYPE_LENGTH (type
);
2136 /* The s390x ABI doesn't handle DOUBLE_ARGS specially. */
2137 if (GDB_TARGET_IS_ESAME
)
2140 return ((is_integer_like (type
)
2141 || is_struct_like (type
))
2146 /* Return non-zero if TYPE is considered a `SIMPLE_ARG', as defined by
2147 the parameter passing conventions described in the "GNU/Linux for
2148 S/390 ELF Application Binary Interface Supplement". Return zero
2151 is_simple_arg (struct type
*type
)
2153 unsigned length
= TYPE_LENGTH (type
);
2155 /* This is almost a direct translation of the ABI's language, except
2156 that we have to exclude 8-byte structs; those are DOUBLE_ARGs. */
2157 return ((is_integer_like (type
) && length
<= DEPRECATED_REGISTER_SIZE
)
2158 || is_pointer_like (type
)
2159 || (is_struct_like (type
) && !is_double_arg (type
)));
2164 is_power_of_two (unsigned int n
)
2166 return ((n
& (n
- 1)) == 0);
2169 /* Return non-zero if TYPE should be passed as a pointer to a copy,
2170 zero otherwise. TYPE must be a SIMPLE_ARG, as recognized by
2173 pass_by_copy_ref (struct type
*type
)
2175 unsigned length
= TYPE_LENGTH (type
);
2177 return (is_struct_like (type
)
2178 && !(is_power_of_two (length
) && length
<= DEPRECATED_REGISTER_SIZE
));
2182 /* Return ARG, a `SIMPLE_ARG', sign-extended or zero-extended to a full
2183 word as required for the ABI. */
2185 extend_simple_arg (struct value
*arg
)
2187 struct type
*type
= VALUE_TYPE (arg
);
2189 /* Even structs get passed in the least significant bits of the
2190 register / memory word. It's not really right to extract them as
2191 an integer, but it does take care of the extension. */
2192 if (TYPE_UNSIGNED (type
))
2193 return extract_unsigned_integer (VALUE_CONTENTS (arg
),
2194 TYPE_LENGTH (type
));
2196 return extract_signed_integer (VALUE_CONTENTS (arg
),
2197 TYPE_LENGTH (type
));
2201 /* Return the alignment required by TYPE. */
2203 alignment_of (struct type
*type
)
2207 if (is_integer_like (type
)
2208 || is_pointer_like (type
)
2209 || TYPE_CODE (type
) == TYPE_CODE_FLT
)
2210 alignment
= TYPE_LENGTH (type
);
2211 else if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
2212 || TYPE_CODE (type
) == TYPE_CODE_UNION
)
2217 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
2219 int field_alignment
= alignment_of (TYPE_FIELD_TYPE (type
, i
));
2221 if (field_alignment
> alignment
)
2222 alignment
= field_alignment
;
2228 /* Check that everything we ever return is a power of two. Lots of
2229 code doesn't want to deal with aligning things to arbitrary
2231 gdb_assert ((alignment
& (alignment
- 1)) == 0);
2237 /* Put the actual parameter values pointed to by ARGS[0..NARGS-1] in
2238 place to be passed to a function, as specified by the "GNU/Linux
2239 for S/390 ELF Application Binary Interface Supplement".
2241 SP is the current stack pointer. We must put arguments, links,
2242 padding, etc. whereever they belong, and return the new stack
2245 If STRUCT_RETURN is non-zero, then the function we're calling is
2246 going to return a structure by value; STRUCT_ADDR is the address of
2247 a block we've allocated for it on the stack.
2249 Our caller has taken care of any type promotions needed to satisfy
2250 prototypes or the old K&R argument-passing rules. */
2252 s390_push_arguments (int nargs
, struct value
**args
, CORE_ADDR sp
,
2253 int struct_return
, CORE_ADDR struct_addr
)
2256 int pointer_size
= (TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
2258 /* The number of arguments passed by reference-to-copy. */
2261 /* If the i'th argument is passed as a reference to a copy, then
2262 copy_addr[i] is the address of the copy we made. */
2263 CORE_ADDR
*copy_addr
= alloca (nargs
* sizeof (CORE_ADDR
));
2265 /* Build the reference-to-copy area. */
2267 for (i
= 0; i
< nargs
; i
++)
2269 struct value
*arg
= args
[i
];
2270 struct type
*type
= VALUE_TYPE (arg
);
2271 unsigned length
= TYPE_LENGTH (type
);
2273 if (is_simple_arg (type
)
2274 && pass_by_copy_ref (type
))
2277 sp
= align_down (sp
, alignment_of (type
));
2278 write_memory (sp
, VALUE_CONTENTS (arg
), length
);
2284 /* Reserve space for the parameter area. As a conservative
2285 simplification, we assume that everything will be passed on the
2290 for (i
= 0; i
< nargs
; i
++)
2292 struct value
*arg
= args
[i
];
2293 struct type
*type
= VALUE_TYPE (arg
);
2294 int length
= TYPE_LENGTH (type
);
2296 sp
= align_down (sp
, alignment_of (type
));
2298 /* SIMPLE_ARG values get extended to DEPRECATED_REGISTER_SIZE bytes.
2299 Assume every argument is. */
2300 if (length
< DEPRECATED_REGISTER_SIZE
) length
= DEPRECATED_REGISTER_SIZE
;
2305 /* Include space for any reference-to-copy pointers. */
2306 sp
= align_down (sp
, pointer_size
);
2307 sp
-= num_copies
* pointer_size
;
2309 /* After all that, make sure it's still aligned on an eight-byte
2311 sp
= align_down (sp
, 8);
2313 /* Finally, place the actual parameters, working from SP towards
2314 higher addresses. The code above is supposed to reserve enough
2319 CORE_ADDR starg
= sp
;
2321 /* A struct is returned using general register 2 */
2325 for (i
= 0; i
< nargs
; i
++)
2327 struct value
*arg
= args
[i
];
2328 struct type
*type
= VALUE_TYPE (arg
);
2330 if (is_double_or_float (type
)
2331 && fr
<= S390_NUM_FP_PARAMETER_REGISTERS
* 2 - 2)
2333 /* When we store a single-precision value in an FP register,
2334 it occupies the leftmost bits. */
2335 deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (S390_FP0_REGNUM
+ fr
),
2336 VALUE_CONTENTS (arg
),
2337 TYPE_LENGTH (type
));
2340 else if (is_simple_arg (type
)
2343 /* Do we need to pass a pointer to our copy of this
2345 if (pass_by_copy_ref (type
))
2346 write_register (S390_GP0_REGNUM
+ gr
, copy_addr
[i
]);
2348 write_register (S390_GP0_REGNUM
+ gr
, extend_simple_arg (arg
));
2352 else if (is_double_arg (type
)
2355 deprecated_write_register_gen (S390_GP0_REGNUM
+ gr
,
2356 VALUE_CONTENTS (arg
));
2357 deprecated_write_register_gen (S390_GP0_REGNUM
+ gr
+ 1,
2358 VALUE_CONTENTS (arg
) + DEPRECATED_REGISTER_SIZE
);
2363 /* The `OTHER' case. */
2364 enum type_code code
= TYPE_CODE (type
);
2365 unsigned length
= TYPE_LENGTH (type
);
2367 /* If we skipped r6 because we couldn't fit a DOUBLE_ARG
2368 in it, then don't go back and use it again later. */
2369 if (is_double_arg (type
) && gr
== 6)
2372 if (is_simple_arg (type
))
2374 /* Simple args are always extended to
2375 DEPRECATED_REGISTER_SIZE bytes. */
2376 starg
= align_up (starg
, DEPRECATED_REGISTER_SIZE
);
2378 /* Do we need to pass a pointer to our copy of this
2380 if (pass_by_copy_ref (type
))
2381 write_memory_signed_integer (starg
, pointer_size
,
2384 /* Simple args are always extended to
2385 DEPRECATED_REGISTER_SIZE bytes. */
2386 write_memory_signed_integer (starg
, DEPRECATED_REGISTER_SIZE
,
2387 extend_simple_arg (arg
));
2388 starg
+= DEPRECATED_REGISTER_SIZE
;
2392 /* You'd think we should say:
2393 starg = align_up (starg, alignment_of (type));
2394 Unfortunately, GCC seems to simply align the stack on
2395 a four/eight-byte boundary, even when passing doubles. */
2396 starg
= align_up (starg
, S390_STACK_PARAMETER_ALIGNMENT
);
2397 write_memory (starg
, VALUE_CONTENTS (arg
), length
);
2404 /* Allocate the standard frame areas: the register save area, the
2405 word reserved for the compiler (which seems kind of meaningless),
2406 and the back chain pointer. */
2407 sp
-= S390_STACK_FRAME_OVERHEAD
;
2409 /* Write the back chain pointer into the first word of the stack
2410 frame. This will help us get backtraces from within functions
2412 write_memory_unsigned_integer (sp
, (TARGET_PTR_BIT
/ TARGET_CHAR_BIT
),
2413 deprecated_read_fp ());
2420 s390_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
2422 /* Both the 32- and 64-bit ABI's say that the stack pointer should
2423 always be aligned on an eight-byte boundary. */
2429 s390_use_struct_convention (int gcc_p
, struct type
*value_type
)
2431 enum type_code code
= TYPE_CODE (value_type
);
2433 return (code
== TYPE_CODE_STRUCT
2434 || code
== TYPE_CODE_UNION
);
2438 /* Return the GDB type object for the "standard" data type
2439 of data in register N. */
2440 static struct type
*
2441 s390_register_virtual_type (int regno
)
2443 if (S390_FP0_REGNUM
<= regno
&& regno
< S390_FP0_REGNUM
+ S390_NUM_FPRS
)
2444 return builtin_type_double
;
2446 return builtin_type_int
;
2450 static struct type
*
2451 s390x_register_virtual_type (int regno
)
2453 return (regno
== S390_FPC_REGNUM
) ||
2454 (regno
>= S390_FIRST_ACR
&& regno
<= S390_LAST_ACR
) ? builtin_type_int
:
2455 (regno
>= S390_FP0_REGNUM
) ? builtin_type_double
: builtin_type_long
;
2461 s390_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
)
2463 write_register (S390_GP0_REGNUM
+ 2, addr
);
2468 static const unsigned char *
2469 s390_breakpoint_from_pc (CORE_ADDR
*pcptr
, int *lenptr
)
2471 static unsigned char breakpoint
[] = { 0x0, 0x1 };
2473 *lenptr
= sizeof (breakpoint
);
2477 /* Advance PC across any function entry prologue instructions to reach some
2480 s390_skip_prologue (CORE_ADDR pc
)
2482 struct frame_extra_info fextra_info
;
2484 s390_get_frame_info (pc
, &fextra_info
, NULL
, 1);
2485 return fextra_info
.skip_prologue_function_start
;
2488 /* Immediately after a function call, return the saved pc.
2489 Can't go through the frames for this because on some machines
2490 the new frame is not set up until the new function executes
2491 some instructions. */
2493 s390_saved_pc_after_call (struct frame_info
*frame
)
2495 return ADDR_BITS_REMOVE (read_register (S390_RETADDR_REGNUM
));
2499 s390_addr_bits_remove (CORE_ADDR addr
)
2501 return (addr
) & 0x7fffffff;
2506 s390_push_return_address (CORE_ADDR pc
, CORE_ADDR sp
)
2508 write_register (S390_RETADDR_REGNUM
, entry_point_address ());
2513 s390_address_class_type_flags (int byte_size
, int dwarf2_addr_class
)
2516 return TYPE_FLAG_ADDRESS_CLASS_1
;
2522 s390_address_class_type_flags_to_name (struct gdbarch
*gdbarch
, int type_flags
)
2524 if (type_flags
& TYPE_FLAG_ADDRESS_CLASS_1
)
2531 s390_address_class_name_to_type_flags (struct gdbarch
*gdbarch
, const char *name
,
2532 int *type_flags_ptr
)
2534 if (strcmp (name
, "mode32") == 0)
2536 *type_flags_ptr
= TYPE_FLAG_ADDRESS_CLASS_1
;
2543 static struct gdbarch
*
2544 s390_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
2546 static LONGEST s390_call_dummy_words
[] = { 0 };
2547 struct gdbarch
*gdbarch
;
2548 struct gdbarch_tdep
*tdep
;
2551 /* First see if there is already a gdbarch that can satisfy the request. */
2552 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
2554 return arches
->gdbarch
;
2556 /* None found: is the request for a s390 architecture? */
2557 if (info
.bfd_arch_info
->arch
!= bfd_arch_s390
)
2558 return NULL
; /* No; then it's not for us. */
2560 /* Yes: create a new gdbarch for the specified machine type. */
2561 gdbarch
= gdbarch_alloc (&info
, NULL
);
2563 /* NOTE: cagney/2002-12-06: This can be deleted when this arch is
2564 ready to unwind the PC first (see frame.c:get_prev_frame()). */
2565 set_gdbarch_deprecated_init_frame_pc (gdbarch
, deprecated_init_frame_pc_default
);
2567 set_gdbarch_believe_pcc_promotion (gdbarch
, 0);
2568 set_gdbarch_char_signed (gdbarch
, 0);
2570 set_gdbarch_deprecated_frame_chain (gdbarch
, s390_frame_chain
);
2571 set_gdbarch_deprecated_frame_init_saved_regs (gdbarch
, s390_frame_init_saved_regs
);
2572 set_gdbarch_deprecated_store_struct_return (gdbarch
, s390_store_struct_return
);
2573 set_gdbarch_deprecated_extract_return_value (gdbarch
, s390_extract_return_value
);
2574 set_gdbarch_deprecated_store_return_value (gdbarch
, s390_store_return_value
);
2575 /* Amount PC must be decremented by after a breakpoint. This is
2576 often the number of bytes returned by BREAKPOINT_FROM_PC but not
2578 set_gdbarch_decr_pc_after_break (gdbarch
, 2);
2579 set_gdbarch_deprecated_pop_frame (gdbarch
, s390_pop_frame
);
2580 /* Stack grows downward. */
2581 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
2582 set_gdbarch_deprecated_max_register_raw_size (gdbarch
, 8);
2583 set_gdbarch_deprecated_max_register_virtual_size (gdbarch
, 8);
2584 set_gdbarch_breakpoint_from_pc (gdbarch
, s390_breakpoint_from_pc
);
2585 set_gdbarch_skip_prologue (gdbarch
, s390_skip_prologue
);
2586 set_gdbarch_deprecated_init_extra_frame_info (gdbarch
, s390_init_extra_frame_info
);
2587 set_gdbarch_deprecated_init_frame_pc_first (gdbarch
, s390_init_frame_pc_first
);
2588 set_gdbarch_deprecated_target_read_fp (gdbarch
, s390_read_fp
);
2589 /* This function that tells us whether the function invocation represented
2590 by FI does not have a frame on the stack associated with it. If it
2591 does not, FRAMELESS is set to 1, else 0. */
2592 set_gdbarch_deprecated_frameless_function_invocation (gdbarch
, s390_frameless_function_invocation
);
2593 /* Return saved PC from a frame */
2594 set_gdbarch_deprecated_frame_saved_pc (gdbarch
, s390_frame_saved_pc
);
2595 /* DEPRECATED_FRAME_CHAIN takes a frame's nominal address and
2596 produces the frame's chain-pointer. */
2597 set_gdbarch_deprecated_frame_chain (gdbarch
, s390_frame_chain
);
2598 set_gdbarch_deprecated_saved_pc_after_call (gdbarch
, s390_saved_pc_after_call
);
2599 set_gdbarch_deprecated_register_byte (gdbarch
, s390_register_byte
);
2600 set_gdbarch_pc_regnum (gdbarch
, S390_PC_REGNUM
);
2601 set_gdbarch_sp_regnum (gdbarch
, S390_SP_REGNUM
);
2602 set_gdbarch_deprecated_fp_regnum (gdbarch
, S390_FP_REGNUM
);
2603 set_gdbarch_fp0_regnum (gdbarch
, S390_FP0_REGNUM
);
2604 set_gdbarch_num_regs (gdbarch
, S390_NUM_REGS
);
2605 set_gdbarch_cannot_fetch_register (gdbarch
, s390_cannot_fetch_register
);
2606 set_gdbarch_cannot_store_register (gdbarch
, s390_cannot_fetch_register
);
2607 set_gdbarch_use_struct_convention (gdbarch
, s390_use_struct_convention
);
2608 set_gdbarch_register_name (gdbarch
, s390_register_name
);
2609 set_gdbarch_stab_reg_to_regnum (gdbarch
, s390_stab_reg_to_regnum
);
2610 set_gdbarch_dwarf_reg_to_regnum (gdbarch
, s390_stab_reg_to_regnum
);
2611 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, s390_stab_reg_to_regnum
);
2612 set_gdbarch_deprecated_extract_struct_value_address (gdbarch
, s390_cannot_extract_struct_value_address
);
2614 /* Parameters for inferior function calls. */
2615 set_gdbarch_deprecated_pc_in_call_dummy (gdbarch
, deprecated_pc_in_call_dummy_at_entry_point
);
2616 set_gdbarch_frame_align (gdbarch
, s390_frame_align
);
2617 set_gdbarch_deprecated_push_arguments (gdbarch
, s390_push_arguments
);
2618 set_gdbarch_deprecated_save_dummy_frame_tos (gdbarch
, generic_save_dummy_frame_tos
);
2619 set_gdbarch_deprecated_push_return_address (gdbarch
,
2620 s390_push_return_address
);
2621 set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch
, sizeof (s390_call_dummy_words
));
2622 set_gdbarch_deprecated_call_dummy_words (gdbarch
, s390_call_dummy_words
);
2624 switch (info
.bfd_arch_info
->mach
)
2626 case bfd_mach_s390_31
:
2627 set_gdbarch_deprecated_register_size (gdbarch
, 4);
2628 set_gdbarch_deprecated_register_raw_size (gdbarch
, s390_register_raw_size
);
2629 set_gdbarch_deprecated_register_virtual_size (gdbarch
, s390_register_raw_size
);
2630 set_gdbarch_deprecated_register_virtual_type (gdbarch
, s390_register_virtual_type
);
2632 set_gdbarch_addr_bits_remove (gdbarch
, s390_addr_bits_remove
);
2633 set_gdbarch_deprecated_register_bytes (gdbarch
, S390_REGISTER_BYTES
);
2635 case bfd_mach_s390_64
:
2636 set_gdbarch_deprecated_register_size (gdbarch
, 8);
2637 set_gdbarch_deprecated_register_raw_size (gdbarch
, s390x_register_raw_size
);
2638 set_gdbarch_deprecated_register_virtual_size (gdbarch
, s390x_register_raw_size
);
2639 set_gdbarch_deprecated_register_virtual_type (gdbarch
, s390x_register_virtual_type
);
2641 set_gdbarch_long_bit (gdbarch
, 64);
2642 set_gdbarch_long_long_bit (gdbarch
, 64);
2643 set_gdbarch_ptr_bit (gdbarch
, 64);
2644 set_gdbarch_deprecated_register_bytes (gdbarch
, S390X_REGISTER_BYTES
);
2645 set_gdbarch_address_class_type_flags (gdbarch
,
2646 s390_address_class_type_flags
);
2647 set_gdbarch_address_class_type_flags_to_name (gdbarch
,
2648 s390_address_class_type_flags_to_name
);
2649 set_gdbarch_address_class_name_to_type_flags (gdbarch
,
2650 s390_address_class_name_to_type_flags
);
2654 /* Should be using push_dummy_call. */
2655 set_gdbarch_deprecated_dummy_write_sp (gdbarch
, deprecated_write_sp
);
2657 set_gdbarch_print_insn (gdbarch
, print_insn_s390
);
2664 extern initialize_file_ftype _initialize_s390_tdep
; /* -Wmissing-prototypes */
2667 _initialize_s390_tdep (void)
2670 /* Hook us into the gdbarch mechanism. */
2671 register_gdbarch_init (bfd_arch_s390
, s390_gdbarch_init
);