1 /* Target-dependent code for GDB, the GNU debugger.
3 Copyright 2001, 2002, 2003 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"
37 #include "../bfd/bfd.h"
38 #include "floatformat.h"
41 #include "gdb_assert.h"
46 /* Number of bytes of storage in the actual machine representation
49 s390_register_raw_size (int reg_nr)
51 if (S390_FP0_REGNUM <= reg_nr
52 && reg_nr < S390_FP0_REGNUM + S390_NUM_FPRS)
59 s390x_register_raw_size (int reg_nr)
61 return (reg_nr == S390_FPC_REGNUM)
62 || (reg_nr >= S390_FIRST_ACR && reg_nr <= S390_LAST_ACR) ? 4 : 8;
66 s390_cannot_fetch_register (int regno)
68 return (regno >= S390_FIRST_CR && regno < (S390_FIRST_CR + 9)) ||
69 (regno >= (S390_FIRST_CR + 12) && regno <= S390_LAST_CR);
73 s390_register_byte (int reg_nr)
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;
84 return S390_FP0_OFFSET + (((reg_nr) - S390_FP0_REGNUM) * S390_FPR_SIZE);
87 #define S390_MAX_INSTR_SIZE (6)
88 #define S390_SYSCALL_OPCODE (0x0a)
89 #define S390_SYSCALL_SIZE (2)
90 #define S390_SIGCONTEXT_SREGS_OFFSET (8)
91 #define S390X_SIGCONTEXT_SREGS_OFFSET (8)
92 #define S390_SIGREGS_FP0_OFFSET (144)
93 #define S390X_SIGREGS_FP0_OFFSET (216)
94 #define S390_UC_MCONTEXT_OFFSET (256)
95 #define S390X_UC_MCONTEXT_OFFSET (344)
96 #define S390_STACK_FRAME_OVERHEAD 16*DEPRECATED_REGISTER_SIZE+32
97 #define S390_STACK_PARAMETER_ALIGNMENT DEPRECATED_REGISTER_SIZE
98 #define S390_NUM_FP_PARAMETER_REGISTERS (GDB_TARGET_IS_ESAME ? 4:2)
99 #define S390_SIGNAL_FRAMESIZE (GDB_TARGET_IS_ESAME ? 160:96)
100 #define s390_NR_sigreturn 119
101 #define s390_NR_rt_sigreturn 173
105 struct frame_extra_info
109 CORE_ADDR function_start;
110 CORE_ADDR skip_prologue_function_start;
111 CORE_ADDR saved_pc_valid;
113 CORE_ADDR sig_fixed_saved_pc_valid;
114 CORE_ADDR sig_fixed_saved_pc;
115 CORE_ADDR frame_pointer_saved_pc; /* frame pointer needed for alloca */
116 CORE_ADDR stack_bought_valid;
117 CORE_ADDR stack_bought; /* amount we decrement the stack pointer by */
118 CORE_ADDR sigcontext;
122 static CORE_ADDR s390_frame_saved_pc_nofix (struct frame_info *fi);
125 s390_readinstruction (bfd_byte instr[], CORE_ADDR at,
126 struct disassemble_info *info)
130 static int s390_instrlen[] = {
136 if ((*info->read_memory_func) (at, &instr[0], 2, info))
138 instrlen = s390_instrlen[instr[0] >> 6];
141 if ((*info->read_memory_func) (at + 2, &instr[2], instrlen - 2, info))
148 s390_memset_extra_info (struct frame_extra_info *fextra_info)
150 memset (fextra_info, 0, sizeof (struct frame_extra_info));
156 s390_register_name (int reg_nr)
158 static char *register_names[] = {
160 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
161 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
162 "acr0", "acr1", "acr2", "acr3", "acr4", "acr5", "acr6", "acr7",
163 "acr8", "acr9", "acr10", "acr11", "acr12", "acr13", "acr14", "acr15",
164 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
165 "cr8", "cr9", "cr10", "cr11", "cr12", "cr13", "cr14", "cr15",
167 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
168 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15"
171 if (reg_nr <= S390_LAST_REGNUM)
172 return register_names[reg_nr];
181 s390_stab_reg_to_regnum (int regno)
183 return regno >= 64 ? S390_PSWM_REGNUM - 64 :
184 regno >= 48 ? S390_FIRST_ACR - 48 :
185 regno >= 32 ? S390_FIRST_CR - 32 :
186 regno <= 15 ? (regno + 2) :
187 S390_FP0_REGNUM + ((regno - 16) & 8) + (((regno - 16) & 3) << 1) +
188 (((regno - 16) & 4) >> 2);
192 /* Prologue analysis. */
194 /* When we analyze a prologue, we're really doing 'abstract
195 interpretation' or 'pseudo-evaluation': running the function's code
196 in simulation, but using conservative approximations of the values
197 it would have when it actually runs. For example, if our function
198 starts with the instruction:
200 ahi r1, 42 # add halfword immediate 42 to r1
202 we don't know exactly what value will be in r1 after executing this
203 instruction, but we do know it'll be 42 greater than its original
206 If we then see an instruction like:
208 ahi r1, 22 # add halfword immediate 22 to r1
210 we still don't know what r1's value is, but again, we can say it is
211 now 64 greater than its original value.
213 If the next instruction were:
215 lr r2, r1 # set r2 to r1's value
217 then we can say that r2's value is now the original value of r1
220 Of course, this can only go so far before it gets unreasonable. If
221 we wanted to be able to say anything about the value of r1 after
224 xr r1, r3 # exclusive-or r1 and r3, place result in r1
226 then things would get pretty complex. But remember, we're just
227 doing a conservative approximation; if exclusive-or instructions
228 aren't relevant to prologues, we can just say r1's value is now
229 'unknown'. We can ignore things that are too complex, if that loss
230 of information is acceptable for our application.
232 Once you've reached an instruction that you don't know how to
233 simulate, you stop. Now you examine the state of the registers and
234 stack slots you've kept track of. For example:
236 - To see how large your stack frame is, just check the value of sp;
237 if it's the original value of sp minus a constant, then that
238 constant is the stack frame's size. If the sp's value has been
239 marked as 'unknown', then that means the prologue has done
240 something too complex for us to track, and we don't know the
243 - To see whether we've saved the SP in the current frame's back
244 chain slot, we just check whether the current value of the back
245 chain stack slot is the original value of the sp.
247 Sure, this takes some work. But prologue analyzers aren't
248 quick-and-simple pattern patching to recognize a few fixed prologue
249 forms any more; they're big, hairy functions. Along with inferior
250 function calls, prologue analysis accounts for a substantial
251 portion of the time needed to stabilize a GDB port. So I think
252 it's worthwhile to look for an approach that will be easier to
253 understand and maintain. In the approach used here:
255 - It's easier to see that the analyzer is correct: you just see
256 whether the analyzer properly (albiet conservatively) simulates
257 the effect of each instruction.
259 - It's easier to extend the analyzer: you can add support for new
260 instructions, and know that you haven't broken anything that
261 wasn't already broken before.
263 - It's orthogonal: to gather new information, you don't need to
264 complicate the code for each instruction. As long as your domain
265 of conservative values is already detailed enough to tell you
266 what you need, then all the existing instruction simulations are
267 already gathering the right data for you.
269 A 'struct prologue_value' is a conservative approximation of the
270 real value the register or stack slot will have. */
272 struct prologue_value {
274 /* What sort of value is this? This determines the interpretation
275 of subsequent fields. */
278 /* We don't know anything about the value. This is also used for
279 values we could have kept track of, when doing so would have
280 been too complex and we don't want to bother. The bottom of
284 /* A known constant. K is its value. */
287 /* The value that register REG originally had *UPON ENTRY TO THE
288 FUNCTION*, plus K. If K is zero, this means, obviously, just
289 the value REG had upon entry to the function. REG is a GDB
290 register number. Before we start interpreting, we initialize
291 every register R to { pv_register, R, 0 }. */
296 /* The meanings of the following fields depend on 'kind'; see the
297 comments for the specific 'kind' values. */
303 /* Set V to be unknown. */
305 pv_set_to_unknown (struct prologue_value *v)
307 v->kind = pv_unknown;
311 /* Set V to the constant K. */
313 pv_set_to_constant (struct prologue_value *v, CORE_ADDR k)
315 v->kind = pv_constant;
320 /* Set V to the original value of register REG, plus K. */
322 pv_set_to_register (struct prologue_value *v, int reg, CORE_ADDR k)
324 v->kind = pv_register;
330 /* If one of *A and *B is a constant, and the other isn't, swap the
331 pointers as necessary to ensure that *B points to the constant.
332 This can reduce the number of cases we need to analyze in the
335 pv_constant_last (struct prologue_value **a,
336 struct prologue_value **b)
338 if ((*a)->kind == pv_constant
339 && (*b)->kind != pv_constant)
341 struct prologue_value *temp = *a;
348 /* Set SUM to the sum of A and B. SUM, A, and B may point to the same
349 'struct prologue_value' object. */
351 pv_add (struct prologue_value *sum,
352 struct prologue_value *a,
353 struct prologue_value *b)
355 pv_constant_last (&a, &b);
357 /* We can handle adding constants to registers, and other constants. */
358 if (b->kind == pv_constant
359 && (a->kind == pv_register
360 || a->kind == pv_constant))
363 sum->reg = a->reg; /* not meaningful if a is pv_constant, but
365 sum->k = a->k + b->k;
368 /* Anything else we don't know how to add. We don't have a
369 representation for, say, the sum of two registers, or a multiple
370 of a register's value (adding a register to itself). */
372 sum->kind = pv_unknown;
376 /* Add the constant K to V. */
378 pv_add_constant (struct prologue_value *v, CORE_ADDR k)
380 struct prologue_value pv_k;
382 /* Rather than thinking of all the cases we can and can't handle,
383 we'll just let pv_add take care of that for us. */
384 pv_set_to_constant (&pv_k, k);
385 pv_add (v, v, &pv_k);
389 /* Subtract B from A, and put the result in DIFF.
391 This isn't quite the same as negating B and adding it to A, since
392 we don't have a representation for the negation of anything but a
393 constant. For example, we can't negate { pv_register, R1, 10 },
394 but we do know that { pv_register, R1, 10 } minus { pv_register,
395 R1, 5 } is { pv_constant, <ignored>, 5 }.
397 This means, for example, that we can subtract two stack addresses;
398 they're both relative to the original SP. Since the frame pointer
399 is set based on the SP, its value will be the original SP plus some
400 constant (probably zero), so we can use its value just fine. */
402 pv_subtract (struct prologue_value *diff,
403 struct prologue_value *a,
404 struct prologue_value *b)
406 pv_constant_last (&a, &b);
408 /* We can subtract a constant from another constant, or from a
410 if (b->kind == pv_constant
411 && (a->kind == pv_register
412 || a->kind == pv_constant))
414 diff->kind = a->kind;
415 diff->reg = a->reg; /* not always meaningful, but harmless */
416 diff->k = a->k - b->k;
419 /* We can subtract a register from itself, yielding a constant. */
420 else if (a->kind == pv_register
421 && b->kind == pv_register
424 diff->kind = pv_constant;
425 diff->k = a->k - b->k;
428 /* We don't know how to subtract anything else. */
430 diff->kind = pv_unknown;
434 /* Set AND to the logical and of A and B. */
436 pv_logical_and (struct prologue_value *and,
437 struct prologue_value *a,
438 struct prologue_value *b)
440 pv_constant_last (&a, &b);
442 /* We can 'and' two constants. */
443 if (a->kind == pv_constant
444 && b->kind == pv_constant)
446 and->kind = pv_constant;
447 and->k = a->k & b->k;
450 /* We can 'and' anything with the constant zero. */
451 else if (b->kind == pv_constant
454 and->kind = pv_constant;
458 /* We can 'and' anything with ~0. */
459 else if (b->kind == pv_constant
460 && b->k == ~ (CORE_ADDR) 0)
463 /* We can 'and' a register with itself. */
464 else if (a->kind == pv_register
465 && b->kind == pv_register
470 /* Otherwise, we don't know. */
472 pv_set_to_unknown (and);
476 /* Return non-zero iff A and B are identical expressions.
478 This is not the same as asking if the two values are equal; the
479 result of such a comparison would have to be a pv_boolean, and
480 asking whether two 'unknown' values were equal would give you
481 pv_maybe. Same for comparing, say, { pv_register, R1, 0 } and {
482 pv_register, R2, 0}. Instead, this is asking whether the two
483 representations are the same. */
485 pv_is_identical (struct prologue_value *a,
486 struct prologue_value *b)
488 if (a->kind != b->kind)
496 return (a->k == b->k);
498 return (a->reg == b->reg && a->k == b->k);
505 /* Return non-zero if A is the original value of register number R
506 plus K, zero otherwise. */
508 pv_is_register (struct prologue_value *a, int r, CORE_ADDR k)
510 return (a->kind == pv_register
516 /* A prologue-value-esque boolean type, including "maybe", when we
517 can't figure out whether something is true or not. */
525 /* Decide whether a reference to SIZE bytes at ADDR refers exactly to
526 an element of an array. The array starts at ARRAY_ADDR, and has
527 ARRAY_LEN values of ELT_SIZE bytes each. If ADDR definitely does
528 refer to an array element, set *I to the index of the referenced
529 element in the array, and return pv_definite_yes. If it definitely
530 doesn't, return pv_definite_no. If we can't tell, return pv_maybe.
532 If the reference does touch the array, but doesn't fall exactly on
533 an element boundary, or doesn't refer to the whole element, return
535 static enum pv_boolean
536 pv_is_array_ref (struct prologue_value *addr,
538 struct prologue_value *array_addr,
543 struct prologue_value offset;
545 /* Note that, since ->k is a CORE_ADDR, and CORE_ADDR is unsigned,
546 if addr is *before* the start of the array, then this isn't going
548 pv_subtract (&offset, addr, array_addr);
550 if (offset.kind == pv_constant)
552 /* This is a rather odd test. We want to know if the SIZE bytes
553 at ADDR don't overlap the array at all, so you'd expect it to
554 be an || expression: "if we're completely before || we're
555 completely after". But with unsigned arithmetic, things are
556 different: since it's a number circle, not a number line, the
557 right values for offset.k are actually one contiguous range. */
558 if (offset.k <= -size
559 && offset.k >= array_len * elt_size)
560 return pv_definite_no;
561 else if (offset.k % elt_size != 0
566 *i = offset.k / elt_size;
567 return pv_definite_yes;
576 /* Decoding S/390 instructions. */
578 /* Named opcode values for the S/390 instructions we recognize. Some
579 instructions have their opcode split across two fields; those are the
580 op1_* and op2_* enums. */
583 op1_aghi = 0xa7, op2_aghi = 0xb,
584 op1_ahi = 0xa7, op2_ahi = 0xa,
587 op1_bras = 0xa7, op2_bras = 0x5,
590 op1_larl = 0xc0, op2_larl = 0x0,
592 op1_lghi = 0xa7, op2_lghi = 0x9,
593 op1_lhi = 0xa7, op2_lhi = 0x8,
600 op1_stg = 0xe3, op2_stg = 0x24,
602 op1_stmg = 0xeb, op2_stmg = 0x24,
607 /* The functions below are for recognizing and decoding S/390
608 instructions of various formats. Each of them checks whether INSN
609 is an instruction of the given format, with the specified opcodes.
610 If it is, it sets the remaining arguments to the values of the
611 instruction's fields, and returns a non-zero value; otherwise, it
614 These functions' arguments appear in the order they appear in the
615 instruction, not in the machine-language form. So, opcodes always
616 come first, even though they're sometimes scattered around the
617 instructions. And displacements appear before base and extension
618 registers, as they do in the assembly syntax, not at the end, as
619 they do in the machine language. */
621 is_ri (bfd_byte *insn, int op1, int op2, unsigned int *r1, int *i2)
623 if (insn[0] == op1 && (insn[1] & 0xf) == op2)
625 *r1 = (insn[1] >> 4) & 0xf;
626 /* i2 is a 16-bit signed quantity. */
627 *i2 = (((insn[2] << 8) | insn[3]) ^ 0x8000) - 0x8000;
636 is_ril (bfd_byte *insn, int op1, int op2,
637 unsigned int *r1, int *i2)
639 if (insn[0] == op1 && (insn[1] & 0xf) == op2)
641 *r1 = (insn[1] >> 4) & 0xf;
642 /* i2 is a signed quantity. If the host 'int' is 32 bits long,
643 no sign extension is necessary, but we don't want to assume
645 *i2 = (((insn[2] << 24)
648 | (insn[5])) ^ 0x80000000) - 0x80000000;
657 is_rr (bfd_byte *insn, int op, unsigned int *r1, unsigned int *r2)
661 *r1 = (insn[1] >> 4) & 0xf;
671 is_rre (bfd_byte *insn, int op, unsigned int *r1, unsigned int *r2)
673 if (((insn[0] << 8) | insn[1]) == op)
675 /* Yes, insn[3]. insn[2] is unused in RRE format. */
676 *r1 = (insn[3] >> 4) & 0xf;
686 is_rs (bfd_byte *insn, int op,
687 unsigned int *r1, unsigned int *r3, unsigned int *d2, unsigned int *b2)
691 *r1 = (insn[1] >> 4) & 0xf;
693 *b2 = (insn[2] >> 4) & 0xf;
694 *d2 = ((insn[2] & 0xf) << 8) | insn[3];
703 is_rse (bfd_byte *insn, int op1, int op2,
704 unsigned int *r1, unsigned int *r3, unsigned int *d2, unsigned int *b2)
707 /* Yes, insn[5]. insn[4] is unused. */
710 *r1 = (insn[1] >> 4) & 0xf;
712 *b2 = (insn[2] >> 4) & 0xf;
713 *d2 = ((insn[2] & 0xf) << 8) | insn[3];
722 is_rx (bfd_byte *insn, int op,
723 unsigned int *r1, unsigned int *d2, unsigned int *x2, unsigned int *b2)
727 *r1 = (insn[1] >> 4) & 0xf;
729 *b2 = (insn[2] >> 4) & 0xf;
730 *d2 = ((insn[2] & 0xf) << 8) | insn[3];
739 is_rxe (bfd_byte *insn, int op1, int op2,
740 unsigned int *r1, unsigned int *d2, unsigned int *x2, unsigned int *b2)
743 /* Yes, insn[5]. insn[4] is unused. */
746 *r1 = (insn[1] >> 4) & 0xf;
748 *b2 = (insn[2] >> 4) & 0xf;
749 *d2 = ((insn[2] & 0xf) << 8) | insn[3];
757 /* Set ADDR to the effective address for an X-style instruction, like:
761 Here, X2 and B2 are registers, and D2 is an unsigned 12-bit
762 constant; the effective address is the sum of all three. If either
763 X2 or B2 are zero, then it doesn't contribute to the sum --- this
764 means that r0 can't be used as either X2 or B2.
766 GPR is an array of general register values, indexed by GPR number,
767 not GDB register number. */
769 compute_x_addr (struct prologue_value *addr,
770 struct prologue_value *gpr,
771 unsigned int d2, unsigned int x2, unsigned int b2)
773 /* We can't just add stuff directly in addr; it might alias some of
774 the registers we need to read. */
775 struct prologue_value result;
777 pv_set_to_constant (&result, d2);
779 pv_add (&result, &result, &gpr[x2]);
781 pv_add (&result, &result, &gpr[b2]);
787 /* The number of GPR and FPR spill slots in an S/390 stack frame. We
788 track general-purpose registers r2 -- r15, and floating-point
789 registers f0, f2, f4, and f6. */
790 #define S390_NUM_SPILL_SLOTS (14 + 4)
793 /* If the SIZE bytes at ADDR are a stack slot we're actually tracking,
794 return pv_definite_yes and set *STACK to point to the slot. If
795 we're sure that they are not any of our stack slots, then return
796 pv_definite_no. Otherwise, return pv_maybe.
797 - GPR is an array indexed by GPR number giving the current values
798 of the general-purpose registers.
799 - SPILL is an array tracking the spill area of the caller's frame;
800 SPILL[i] is the i'th spill slot. The spill slots are designated
801 for r2 -- r15, and then f0, f2, f4, and f6.
802 - BACK_CHAIN is the value of the back chain slot; it's only valid
803 when the current frame actually has some space for a back chain
804 slot --- that is, when the current value of the stack pointer
805 (according to GPR) is at least S390_STACK_FRAME_OVERHEAD bytes
806 less than its original value. */
807 static enum pv_boolean
808 s390_on_stack (struct prologue_value *addr,
810 struct prologue_value *gpr,
811 struct prologue_value *spill,
812 struct prologue_value *back_chain,
813 struct prologue_value **stack)
815 struct prologue_value gpr_spill_addr;
816 struct prologue_value fpr_spill_addr;
817 struct prologue_value back_chain_addr;
821 /* Construct the addresses of the spill arrays and the back chain. */
822 pv_set_to_register (&gpr_spill_addr, S390_SP_REGNUM, 2 * S390_GPR_SIZE);
823 pv_set_to_register (&fpr_spill_addr, S390_SP_REGNUM, 16 * S390_GPR_SIZE);
824 back_chain_addr = gpr[S390_SP_REGNUM - S390_GP0_REGNUM];
826 /* We have to check for GPR and FPR references using two separate
827 calls to pv_is_array_ref, since the GPR and FPR spill slots are
828 different sizes. (SPILL is an array, but the thing it tracks
829 isn't really an array.) */
831 /* Was it a reference to the GPR spill array? */
832 b = pv_is_array_ref (addr, size, &gpr_spill_addr, 14, S390_GPR_SIZE, &i);
833 if (b == pv_definite_yes)
836 return pv_definite_yes;
841 /* Was it a reference to the FPR spill array? */
842 b = pv_is_array_ref (addr, size, &fpr_spill_addr, 4, S390_FPR_SIZE, &i);
843 if (b == pv_definite_yes)
845 *stack = &spill[14 + i];
846 return pv_definite_yes;
851 /* Was it a reference to the back chain?
852 This isn't quite right. We ought to check whether we have
853 actually allocated any new frame at all. */
854 b = pv_is_array_ref (addr, size, &back_chain_addr, 1, S390_GPR_SIZE, &i);
855 if (b == pv_definite_yes)
858 return pv_definite_yes;
863 /* All the above queries returned definite 'no's. */
864 return pv_definite_no;
868 /* Do a SIZE-byte store of VALUE to ADDR. GPR, SPILL, and BACK_CHAIN,
869 and the return value are as described for s390_on_stack, above.
870 Note that, when this returns pv_maybe, we have to assume that all
871 of our memory now contains unknown values. */
872 static enum pv_boolean
873 s390_store (struct prologue_value *addr,
875 struct prologue_value *value,
876 struct prologue_value *gpr,
877 struct prologue_value *spill,
878 struct prologue_value *back_chain)
880 struct prologue_value *stack;
881 enum pv_boolean on_stack
882 = s390_on_stack (addr, size, gpr, spill, back_chain, &stack);
884 if (on_stack == pv_definite_yes)
891 /* The current frame looks like a signal delivery frame: the first
892 instruction is an 'svc' opcode. If the next frame is a signal
893 handler's frame, set FI's saved register map to point into the
894 signal context structure. */
896 s390_get_signal_frame_info (struct frame_info *fi)
898 struct frame_info *next_frame = get_next_frame (fi);
901 && get_frame_extra_info (next_frame)
902 && get_frame_extra_info (next_frame)->sigcontext)
904 /* We're definitely backtracing from a signal handler. */
905 CORE_ADDR *saved_regs = get_frame_saved_regs (fi);
906 CORE_ADDR save_reg_addr = (get_frame_extra_info (next_frame)->sigcontext
907 + REGISTER_BYTE (S390_GP0_REGNUM));
910 for (reg = 0; reg < S390_NUM_GPRS; reg++)
912 saved_regs[S390_GP0_REGNUM + reg] = save_reg_addr;
913 save_reg_addr += S390_GPR_SIZE;
916 save_reg_addr = (get_frame_extra_info (next_frame)->sigcontext
917 + (GDB_TARGET_IS_ESAME ? S390X_SIGREGS_FP0_OFFSET :
918 S390_SIGREGS_FP0_OFFSET));
919 for (reg = 0; reg < S390_NUM_FPRS; reg++)
921 saved_regs[S390_FP0_REGNUM + reg] = save_reg_addr;
922 save_reg_addr += S390_FPR_SIZE;
929 s390_get_frame_info (CORE_ADDR start_pc,
930 struct frame_extra_info *fextra_info,
931 struct frame_info *fi,
935 zero if we were able to read all the instructions we wanted, or
936 -1 if we got an error trying to read memory. */
939 /* We just use this for reading instructions. */
940 disassemble_info info;
942 /* The current PC for our abstract interpretation. */
945 /* The address of the next instruction after that. */
948 /* The general-purpose registers. */
949 struct prologue_value gpr[S390_NUM_GPRS];
951 /* The floating-point registers. */
952 struct prologue_value fpr[S390_NUM_FPRS];
954 /* The register spill stack slots in the caller's frame ---
955 general-purpose registers r2 through r15, and floating-point
956 registers. spill[i] is where gpr i+2 gets spilled;
957 spill[(14, 15, 16, 17)] is where (f0, f2, f4, f6) get spilled. */
958 struct prologue_value spill[S390_NUM_SPILL_SLOTS];
960 /* The value of the back chain slot. This is only valid if the stack
961 pointer is known to be less than its original value --- that is,
962 if we have indeed allocated space on the stack. */
963 struct prologue_value back_chain;
965 /* The address of the instruction after the last one that changed
966 the SP, FP, or back chain. */
967 CORE_ADDR after_last_frame_setup_insn = start_pc;
969 info.read_memory_func = deprecated_tm_print_insn_info.read_memory_func;
971 /* Set up everything's initial value. */
975 for (i = 0; i < S390_NUM_GPRS; i++)
976 pv_set_to_register (&gpr[i], S390_GP0_REGNUM + i, 0);
978 for (i = 0; i < S390_NUM_FPRS; i++)
979 pv_set_to_register (&fpr[i], S390_FP0_REGNUM + i, 0);
981 for (i = 0; i < S390_NUM_SPILL_SLOTS; i++)
982 pv_set_to_unknown (&spill[i]);
984 pv_set_to_unknown (&back_chain);
987 /* Start interpreting instructions, until we hit something we don't
988 know how to interpret. (Ideally, we should stop at the frame's
989 real current PC, but at the moment, our callers don't give us
991 for (pc = start_pc; ; pc = next_pc)
993 bfd_byte insn[S390_MAX_INSTR_SIZE];
994 int insn_len = s390_readinstruction (insn, pc, &info);
996 /* Fields for various kinds of instructions. */
997 unsigned int b2, r1, r2, d2, x2, r3;
1000 /* The values of SP, FP, and back chain before this instruction,
1001 for detecting instructions that change them. */
1002 struct prologue_value pre_insn_sp, pre_insn_fp, pre_insn_back_chain;
1004 /* If we got an error trying to read the instruction, report it. */
1011 next_pc = pc + insn_len;
1013 pre_insn_sp = gpr[S390_SP_REGNUM - S390_GP0_REGNUM];
1014 pre_insn_fp = gpr[S390_FRAME_REGNUM - S390_GP0_REGNUM];
1015 pre_insn_back_chain = back_chain;
1017 /* A special case, first --- only recognized as the very first
1018 instruction of the function, for signal delivery frames:
1019 SVC i --- system call */
1021 && is_rr (insn, op_svc, &r1, &r2))
1024 s390_get_signal_frame_info (fi);
1028 /* AHI r1, i2 --- add halfword immediate */
1029 else if (is_ri (insn, op1_ahi, op2_ahi, &r1, &i2))
1030 pv_add_constant (&gpr[r1], i2);
1033 /* AGHI r1, i2 --- add halfword immediate (64-bit version) */
1034 else if (GDB_TARGET_IS_ESAME
1035 && is_ri (insn, op1_aghi, op2_aghi, &r1, &i2))
1036 pv_add_constant (&gpr[r1], i2);
1038 /* AR r1, r2 -- add register */
1039 else if (is_rr (insn, op_ar, &r1, &r2))
1040 pv_add (&gpr[r1], &gpr[r1], &gpr[r2]);
1042 /* BASR r1, 0 --- branch and save
1043 Since r2 is zero, this saves the PC in r1, but doesn't branch. */
1044 else if (is_rr (insn, op_basr, &r1, &r2)
1046 pv_set_to_constant (&gpr[r1], next_pc);
1048 /* BRAS r1, i2 --- branch relative and save */
1049 else if (is_ri (insn, op1_bras, op2_bras, &r1, &i2))
1051 pv_set_to_constant (&gpr[r1], next_pc);
1052 next_pc = pc + i2 * 2;
1054 /* We'd better not interpret any backward branches. We'll
1060 /* L r1, d2(x2, b2) --- load */
1061 else if (is_rx (insn, op_l, &r1, &d2, &x2, &b2))
1063 struct prologue_value addr;
1064 struct prologue_value *stack;
1066 compute_x_addr (&addr, gpr, d2, x2, b2);
1068 /* If it's a load from an in-line constant pool, then we can
1069 simulate that, under the assumption that the code isn't
1070 going to change between the time the processor actually
1071 executed it creating the current frame, and the time when
1072 we're analyzing the code to unwind past that frame. */
1073 if (addr.kind == pv_constant
1074 && start_pc <= addr.k
1075 && addr.k < next_pc)
1076 pv_set_to_constant (&gpr[r1],
1077 read_memory_integer (addr.k, 4));
1079 /* If it's definitely a reference to something on the stack,
1081 else if (s390_on_stack (&addr, 4, gpr, spill, &back_chain, &stack)
1085 /* Otherwise, we don't know the value. */
1087 pv_set_to_unknown (&gpr[r1]);
1090 /* LA r1, d2(x2, b2) --- load address */
1091 else if (is_rx (insn, op_la, &r1, &d2, &x2, &b2))
1092 compute_x_addr (&gpr[r1], gpr, d2, x2, b2);
1094 /* LARL r1, i2 --- load address relative long */
1095 else if (GDB_TARGET_IS_ESAME
1096 && is_ril (insn, op1_larl, op2_larl, &r1, &i2))
1097 pv_set_to_constant (&gpr[r1], pc + i2 * 2);
1099 /* LGR r1, r2 --- load from register */
1100 else if (GDB_TARGET_IS_ESAME
1101 && is_rre (insn, op_lgr, &r1, &r2))
1104 /* LHI r1, i2 --- load halfword immediate */
1105 else if (is_ri (insn, op1_lhi, op2_lhi, &r1, &i2))
1106 pv_set_to_constant (&gpr[r1], i2);
1108 /* LGHI r1, i2 --- load halfword immediate --- 64-bit version */
1109 else if (is_ri (insn, op1_lghi, op2_lghi, &r1, &i2))
1110 pv_set_to_constant (&gpr[r1], i2);
1112 /* LR r1, r2 --- load from register */
1113 else if (is_rr (insn, op_lr, &r1, &r2))
1116 /* NGR r1, r2 --- logical and --- 64-bit version */
1117 else if (GDB_TARGET_IS_ESAME
1118 && is_rre (insn, op_ngr, &r1, &r2))
1119 pv_logical_and (&gpr[r1], &gpr[r1], &gpr[r2]);
1121 /* NR r1, r2 --- logical and */
1122 else if (is_rr (insn, op_nr, &r1, &r2))
1123 pv_logical_and (&gpr[r1], &gpr[r1], &gpr[r2]);
1125 /* NGR r1, r2 --- logical and --- 64-bit version */
1126 else if (GDB_TARGET_IS_ESAME
1127 && is_rre (insn, op_ngr, &r1, &r2))
1128 pv_logical_and (&gpr[r1], &gpr[r1], &gpr[r2]);
1130 /* NR r1, r2 --- logical and */
1131 else if (is_rr (insn, op_nr, &r1, &r2))
1132 pv_logical_and (&gpr[r1], &gpr[r1], &gpr[r2]);
1134 /* S r1, d2(x2, b2) --- subtract from memory */
1135 else if (is_rx (insn, op_s, &r1, &d2, &x2, &b2))
1137 struct prologue_value addr;
1138 struct prologue_value value;
1139 struct prologue_value *stack;
1141 compute_x_addr (&addr, gpr, d2, x2, b2);
1143 /* If it's a load from an in-line constant pool, then we can
1144 simulate that, under the assumption that the code isn't
1145 going to change between the time the processor actually
1146 executed it and the time when we're analyzing it. */
1147 if (addr.kind == pv_constant
1148 && start_pc <= addr.k
1150 pv_set_to_constant (&value, read_memory_integer (addr.k, 4));
1152 /* If it's definitely a reference to something on the stack,
1153 we could do that. */
1154 else if (s390_on_stack (&addr, 4, gpr, spill, &back_chain, &stack)
1158 /* Otherwise, we don't know the value. */
1160 pv_set_to_unknown (&value);
1162 pv_subtract (&gpr[r1], &gpr[r1], &value);
1165 /* ST r1, d2(x2, b2) --- store */
1166 else if (is_rx (insn, op_st, &r1, &d2, &x2, &b2))
1168 struct prologue_value addr;
1170 compute_x_addr (&addr, gpr, d2, x2, b2);
1172 /* The below really should be '4', not 'S390_GPR_SIZE'; this
1173 instruction always stores 32 bits, regardless of the full
1175 if (s390_store (&addr, 4, &gpr[r1], gpr, spill, &back_chain)
1177 /* If we can't be sure that it's *not* a store to
1178 something we're tracing, then we would have to mark all
1179 our memory as unknown --- after all, it *could* be a
1180 store to any of them --- so we might as well just stop
1185 /* STD r1, d2(x2,b2) --- store floating-point register */
1186 else if (is_rx (insn, op_std, &r1, &d2, &x2, &b2))
1188 struct prologue_value addr;
1190 compute_x_addr (&addr, gpr, d2, x2, b2);
1192 if (s390_store (&addr, 8, &fpr[r1], gpr, spill, &back_chain)
1194 /* If we can't be sure that it's *not* a store to
1195 something we're tracing, then we would have to mark all
1196 our memory as unknown --- after all, it *could* be a
1197 store to any of them --- so we might as well just stop
1202 /* STG r1, d2(x2, b2) --- 64-bit store */
1203 else if (GDB_TARGET_IS_ESAME
1204 && is_rxe (insn, op1_stg, op2_stg, &r1, &d2, &x2, &b2))
1206 struct prologue_value addr;
1208 compute_x_addr (&addr, gpr, d2, x2, b2);
1210 /* The below really should be '8', not 'S390_GPR_SIZE'; this
1211 instruction always stores 64 bits, regardless of the full
1213 if (s390_store (&addr, 8, &gpr[r1], gpr, spill, &back_chain)
1215 /* If we can't be sure that it's *not* a store to
1216 something we're tracing, then we would have to mark all
1217 our memory as unknown --- after all, it *could* be a
1218 store to any of them --- so we might as well just stop
1223 /* STM r1, r3, d2(b2) --- store multiple */
1224 else if (is_rs (insn, op_stm, &r1, &r3, &d2, &b2))
1228 struct prologue_value addr;
1230 for (regnum = r1, offset = 0;
1232 regnum++, offset += 4)
1234 compute_x_addr (&addr, gpr, d2 + offset, 0, b2);
1236 if (s390_store (&addr, 4, &gpr[regnum], gpr, spill, &back_chain)
1238 /* If we can't be sure that it's *not* a store to
1239 something we're tracing, then we would have to mark all
1240 our memory as unknown --- after all, it *could* be a
1241 store to any of them --- so we might as well just stop
1246 /* If we left the loop early, we should stop interpreting
1252 /* STMG r1, r3, d2(b2) --- store multiple, 64-bit */
1253 else if (GDB_TARGET_IS_ESAME
1254 && is_rse (insn, op1_stmg, op2_stmg, &r1, &r3, &d2, &b2))
1258 struct prologue_value addr;
1260 for (regnum = r1, offset = 0;
1262 regnum++, offset += 8)
1264 compute_x_addr (&addr, gpr, d2 + offset, 0, b2);
1266 if (s390_store (&addr, 8, &gpr[regnum], gpr, spill, &back_chain)
1268 /* If we can't be sure that it's *not* a store to
1269 something we're tracing, then we would have to mark all
1270 our memory as unknown --- after all, it *could* be a
1271 store to any of them --- so we might as well just stop
1276 /* If we left the loop early, we should stop interpreting
1283 /* An instruction we don't know how to simulate. The only
1284 safe thing to do would be to set every value we're tracking
1285 to 'unknown'. Instead, we'll be optimistic: we just stop
1286 interpreting, and assume that the machine state we've got
1287 now is good enough for unwinding the stack. */
1290 /* Record the address after the last instruction that changed
1291 the FP, SP, or backlink. Ignore instructions that changed
1292 them back to their original values --- those are probably
1293 restore instructions. (The back chain is never restored,
1296 struct prologue_value *sp = &gpr[S390_SP_REGNUM - S390_GP0_REGNUM];
1297 struct prologue_value *fp = &gpr[S390_FRAME_REGNUM - S390_GP0_REGNUM];
1299 if ((! pv_is_identical (&pre_insn_sp, sp)
1300 && ! pv_is_register (sp, S390_SP_REGNUM, 0))
1301 || (! pv_is_identical (&pre_insn_fp, fp)
1302 && ! pv_is_register (fp, S390_FRAME_REGNUM, 0))
1303 || ! pv_is_identical (&pre_insn_back_chain, &back_chain))
1304 after_last_frame_setup_insn = next_pc;
1308 /* Okay, now gpr[], fpr[], spill[], and back_chain reflect the state
1309 of the machine as of the first instruction we couldn't interpret
1310 (hopefully the first non-prologue instruction). */
1312 /* The size of the frame, or (CORE_ADDR) -1 if we couldn't figure
1314 CORE_ADDR frame_size = -1;
1316 /* The value the SP had upon entry to the function, or
1317 (CORE_ADDR) -1 if we can't figure that out. */
1318 CORE_ADDR original_sp = -1;
1320 /* Are we using S390_FRAME_REGNUM as a frame pointer register? */
1321 int using_frame_pointer = 0;
1323 /* If S390_FRAME_REGNUM is some constant offset from the SP, then
1324 that strongly suggests that we're going to use that as our
1325 frame pointer register, not the SP. */
1327 struct prologue_value *fp = &gpr[S390_FRAME_REGNUM - S390_GP0_REGNUM];
1329 if (fp->kind == pv_register
1330 && fp->reg == S390_SP_REGNUM)
1331 using_frame_pointer = 1;
1334 /* If we were given a frame_info structure, we may be able to use
1335 the frame's base address to figure out the actual value of the
1337 if (fi && get_frame_base (fi))
1339 int frame_base_regno;
1340 struct prologue_value *frame_base;
1342 /* The meaning of the frame base depends on whether the
1343 function uses a frame pointer register other than the SP or
1344 not (see s390_read_fp):
1345 - If the function does use a frame pointer register other
1346 than the SP, then the frame base is that register's
1348 - If the function doesn't use a frame pointer, then the
1349 frame base is the SP itself.
1350 We're duplicating some of the logic of s390_fp_regnum here,
1351 but we don't want to call that, because it would just do
1352 exactly the same analysis we've already done above. */
1353 if (using_frame_pointer)
1354 frame_base_regno = S390_FRAME_REGNUM;
1356 frame_base_regno = S390_SP_REGNUM;
1358 frame_base = &gpr[frame_base_regno - S390_GP0_REGNUM];
1360 /* We know the frame base address; if the value of whatever
1361 register it came from is a constant offset from the
1362 original SP, then we can reconstruct the original SP just
1363 by subtracting off that constant. */
1364 if (frame_base->kind == pv_register
1365 && frame_base->reg == S390_SP_REGNUM)
1366 original_sp = get_frame_base (fi) - frame_base->k;
1369 /* If the analysis said that the current SP value is the original
1370 value less some constant, then that constant is the frame size. */
1372 struct prologue_value *sp = &gpr[S390_SP_REGNUM - S390_GP0_REGNUM];
1374 if (sp->kind == pv_register
1375 && sp->reg == S390_SP_REGNUM)
1376 frame_size = -sp->k;
1379 /* If we knew other registers' current values, we could check if
1380 the analysis said any of those were related to the original SP
1381 value, too. But for now, we'll just punt. */
1383 /* If the caller passed in an 'extra info' structure, fill in the
1387 if (init_extra_info || ! fextra_info->initialised)
1389 s390_memset_extra_info (fextra_info);
1390 fextra_info->function_start = start_pc;
1391 fextra_info->initialised = 1;
1394 if (frame_size != -1)
1396 fextra_info->stack_bought_valid = 1;
1397 fextra_info->stack_bought = frame_size;
1400 /* Assume everything was okay, and indicate otherwise when we
1401 find something amiss. */
1402 fextra_info->good_prologue = 1;
1404 if (using_frame_pointer)
1405 /* Actually, nobody cares about the exact PC, so any
1406 non-zero value will do here. */
1407 fextra_info->frame_pointer_saved_pc = 1;
1409 /* If we weren't able to find the size of the frame, or find
1410 the original sp based on actual current register values,
1411 then we're not going to be able to unwind this frame.
1413 (If we're just doing prologue analysis to set a breakpoint,
1414 then frame_size might be known, but original_sp unknown; if
1415 we're analyzing a real frame which uses alloca, then
1416 original_sp might be known (from the frame pointer
1417 register), but the frame size might be unknown.) */
1418 if (original_sp == -1 && frame_size == -1)
1419 fextra_info->good_prologue = 0;
1421 if (fextra_info->good_prologue)
1422 fextra_info->skip_prologue_function_start
1423 = after_last_frame_setup_insn;
1425 /* If the prologue was too complex for us to make sense of,
1426 then perhaps it's better to just not skip anything at
1428 fextra_info->skip_prologue_function_start = start_pc;
1431 /* Indicate where registers were saved on the stack, if:
1432 - the caller seems to want to know,
1433 - the caller provided an actual SP, and
1434 - the analysis gave us enough information to actually figure it
1437 && get_frame_saved_regs (fi)
1438 && original_sp != -1)
1441 CORE_ADDR slot_addr;
1442 CORE_ADDR *saved_regs = get_frame_saved_regs (fi);
1444 /* Scan the spill array; if a spill slot says it holds the
1445 original value of some register, then record that slot's
1446 address as the place that register was saved.
1448 Just for kicks, note that, even if registers aren't saved
1449 in their officially-sanctioned slots, this will still work
1450 --- we know what really got put where. */
1452 /* First, the slots for r2 -- r15. */
1453 for (slot_num = 0, slot_addr = original_sp + 2 * S390_GPR_SIZE;
1455 slot_num++, slot_addr += S390_GPR_SIZE)
1457 struct prologue_value *slot = &spill[slot_num];
1459 if (slot->kind == pv_register
1461 saved_regs[slot->reg] = slot_addr;
1464 /* Then, the slots for f0, f2, f4, and f6. They're a
1466 for (slot_num = 14, slot_addr = original_sp + 16 * S390_GPR_SIZE;
1467 slot_num < S390_NUM_SPILL_SLOTS;
1468 slot_num++, slot_addr += S390_FPR_SIZE)
1470 struct prologue_value *slot = &spill[slot_num];
1472 if (slot->kind == pv_register
1474 saved_regs[slot->reg] = slot_addr;
1477 /* The stack pointer's element of saved_regs[] is special. */
1478 saved_regs[S390_SP_REGNUM] = original_sp;
1487 s390_check_function_end (CORE_ADDR pc)
1489 bfd_byte instr[S390_MAX_INSTR_SIZE];
1490 disassemble_info info;
1491 int regidx, instrlen;
1493 info.read_memory_func = deprecated_tm_print_insn_info.read_memory_func;
1494 instrlen = s390_readinstruction (instr, pc, &info);
1498 if (instrlen != 2 || instr[0] != 07 || (instr[1] >> 4) != 0xf)
1500 regidx = instr[1] & 0xf;
1501 /* Check for LMG or LG */
1503 s390_readinstruction (instr, pc - (GDB_TARGET_IS_ESAME ? 6 : 4), &info);
1506 if (GDB_TARGET_IS_ESAME)
1509 if (instrlen != 6 || instr[0] != 0xeb || instr[5] != 0x4)
1512 else if (instrlen != 4 || instr[0] != 0x98)
1516 if ((instr[2] >> 4) != 0xf)
1520 instrlen = s390_readinstruction (instr, pc - (GDB_TARGET_IS_ESAME ? 12 : 8),
1524 if (GDB_TARGET_IS_ESAME)
1527 if (instrlen != 6 || instr[0] != 0xe3 || instr[5] != 0x4)
1533 if (instrlen != 4 || instr[0] != 0x58)
1536 if (instr[2] >> 4 != 0xf)
1538 if (instr[1] >> 4 != regidx)
1544 s390_sniff_pc_function_start (CORE_ADDR pc, struct frame_info *fi)
1546 CORE_ADDR function_start, test_function_start;
1547 int loop_cnt, err, function_end;
1548 struct frame_extra_info fextra_info;
1549 function_start = get_pc_function_start (pc);
1551 if (function_start == 0)
1553 test_function_start = pc;
1554 if (test_function_start & 1)
1555 return 0; /* This has to be bogus */
1561 s390_get_frame_info (test_function_start, &fextra_info, fi, 1);
1563 test_function_start -= 2;
1564 function_end = s390_check_function_end (test_function_start);
1566 while (!(function_end == 1 || err || loop_cnt >= 4096 ||
1567 (fextra_info.good_prologue)));
1568 if (fextra_info.good_prologue)
1569 function_start = fextra_info.function_start;
1570 else if (function_end == 1)
1571 function_start = test_function_start;
1573 return function_start;
1579 s390_function_start (struct frame_info *fi)
1581 CORE_ADDR function_start = 0;
1583 if (get_frame_extra_info (fi) && get_frame_extra_info (fi)->initialised)
1584 function_start = get_frame_extra_info (fi)->function_start;
1585 else if (get_frame_pc (fi))
1586 function_start = get_frame_func (fi);
1587 return function_start;
1594 s390_frameless_function_invocation (struct frame_info *fi)
1596 struct frame_extra_info fextra_info, *fextra_info_ptr;
1599 if (get_next_frame (fi) == NULL) /* no may be frameless */
1601 if (get_frame_extra_info (fi))
1602 fextra_info_ptr = get_frame_extra_info (fi);
1605 fextra_info_ptr = &fextra_info;
1606 s390_get_frame_info (s390_sniff_pc_function_start (get_frame_pc (fi), fi),
1607 fextra_info_ptr, fi, 1);
1609 frameless = (fextra_info_ptr->stack_bought_valid
1610 && fextra_info_ptr->stack_bought == 0);
1618 s390_is_sigreturn (CORE_ADDR pc, struct frame_info *sighandler_fi,
1619 CORE_ADDR *sregs, CORE_ADDR *sigcaller_pc)
1621 bfd_byte instr[S390_MAX_INSTR_SIZE];
1622 disassemble_info info;
1627 CORE_ADDR temp_sregs;
1629 scontext = temp_sregs = 0;
1631 info.read_memory_func = deprecated_tm_print_insn_info.read_memory_func;
1632 instrlen = s390_readinstruction (instr, pc, &info);
1635 if (((instrlen == S390_SYSCALL_SIZE) &&
1636 (instr[0] == S390_SYSCALL_OPCODE)) &&
1637 ((instr[1] == s390_NR_sigreturn) || (instr[1] == s390_NR_rt_sigreturn)))
1641 if (s390_frameless_function_invocation (sighandler_fi))
1642 orig_sp = get_frame_base (sighandler_fi);
1644 orig_sp = ADDR_BITS_REMOVE ((CORE_ADDR)
1645 read_memory_integer (get_frame_base (sighandler_fi),
1647 if (orig_sp && sigcaller_pc)
1649 scontext = orig_sp + S390_SIGNAL_FRAMESIZE;
1650 if (pc == scontext && instr[1] == s390_NR_rt_sigreturn)
1652 /* We got a new style rt_signal */
1653 /* get address of read ucontext->uc_mcontext */
1654 temp_sregs = orig_sp + (GDB_TARGET_IS_ESAME ?
1655 S390X_UC_MCONTEXT_OFFSET :
1656 S390_UC_MCONTEXT_OFFSET);
1660 /* read sigcontext->sregs */
1661 temp_sregs = ADDR_BITS_REMOVE ((CORE_ADDR)
1662 read_memory_integer (scontext
1664 (GDB_TARGET_IS_ESAME
1666 S390X_SIGCONTEXT_SREGS_OFFSET
1668 S390_SIGCONTEXT_SREGS_OFFSET),
1672 /* read sigregs->psw.addr */
1674 ADDR_BITS_REMOVE ((CORE_ADDR)
1675 read_memory_integer (temp_sregs +
1678 S390_PSW_ADDR_SIZE));
1684 *sregs = temp_sregs;
1689 We need to do something better here but this will keep us out of trouble
1691 For some reason the blockframe.c calls us with fi->next->fromleaf
1692 so this seems of little use to us. */
1694 s390_init_frame_pc_first (int next_fromleaf, struct frame_info *fi)
1696 CORE_ADDR sigcaller_pc;
1700 pc = ADDR_BITS_REMOVE (read_register (S390_RETADDR_REGNUM));
1701 /* fix signal handlers */
1703 else if (get_next_frame (fi) && get_frame_pc (get_next_frame (fi)))
1704 pc = s390_frame_saved_pc_nofix (get_next_frame (fi));
1705 if (pc && get_next_frame (fi) && get_frame_base (get_next_frame (fi))
1706 && s390_is_sigreturn (pc, get_next_frame (fi), NULL, &sigcaller_pc))
1714 s390_init_extra_frame_info (int fromleaf, struct frame_info *fi)
1716 frame_extra_info_zalloc (fi, sizeof (struct frame_extra_info));
1717 if (get_frame_pc (fi))
1718 s390_get_frame_info (s390_sniff_pc_function_start (get_frame_pc (fi), fi),
1719 get_frame_extra_info (fi), fi, 1);
1721 s390_memset_extra_info (get_frame_extra_info (fi));
1724 /* If saved registers of frame FI are not known yet, read and cache them.
1725 &FEXTRA_INFOP contains struct frame_extra_info; TDATAP can be NULL,
1726 in which case the framedata are read. */
1729 s390_frame_init_saved_regs (struct frame_info *fi)
1734 if (get_frame_saved_regs (fi) == NULL)
1736 /* zalloc memsets the saved regs */
1737 frame_saved_regs_zalloc (fi);
1738 if (get_frame_pc (fi))
1740 quick = (get_frame_extra_info (fi)
1741 && get_frame_extra_info (fi)->initialised
1742 && get_frame_extra_info (fi)->good_prologue);
1743 s390_get_frame_info (quick
1744 ? get_frame_extra_info (fi)->function_start
1745 : s390_sniff_pc_function_start (get_frame_pc (fi), fi),
1746 get_frame_extra_info (fi), fi, !quick);
1754 s390_frame_saved_pc_nofix (struct frame_info *fi)
1756 if (get_frame_extra_info (fi) && get_frame_extra_info (fi)->saved_pc_valid)
1757 return get_frame_extra_info (fi)->saved_pc;
1759 if (deprecated_generic_find_dummy_frame (get_frame_pc (fi),
1760 get_frame_base (fi)))
1761 return deprecated_read_register_dummy (get_frame_pc (fi),
1762 get_frame_base (fi), S390_PC_REGNUM);
1764 s390_frame_init_saved_regs (fi);
1765 if (get_frame_extra_info (fi))
1767 get_frame_extra_info (fi)->saved_pc_valid = 1;
1768 if (get_frame_extra_info (fi)->good_prologue
1769 && get_frame_saved_regs (fi)[S390_RETADDR_REGNUM])
1770 get_frame_extra_info (fi)->saved_pc
1771 = ADDR_BITS_REMOVE (read_memory_integer
1772 (get_frame_saved_regs (fi)[S390_RETADDR_REGNUM],
1775 get_frame_extra_info (fi)->saved_pc
1776 = ADDR_BITS_REMOVE (read_register (S390_RETADDR_REGNUM));
1777 return get_frame_extra_info (fi)->saved_pc;
1783 s390_frame_saved_pc (struct frame_info *fi)
1785 CORE_ADDR saved_pc = 0, sig_pc;
1787 if (get_frame_extra_info (fi)
1788 && get_frame_extra_info (fi)->sig_fixed_saved_pc_valid)
1789 return get_frame_extra_info (fi)->sig_fixed_saved_pc;
1790 saved_pc = s390_frame_saved_pc_nofix (fi);
1792 if (get_frame_extra_info (fi))
1794 get_frame_extra_info (fi)->sig_fixed_saved_pc_valid = 1;
1797 if (s390_is_sigreturn (saved_pc, fi, NULL, &sig_pc))
1800 get_frame_extra_info (fi)->sig_fixed_saved_pc = saved_pc;
1808 /* We want backtraces out of signal handlers so we don't set
1809 (get_frame_type (thisframe) == SIGTRAMP_FRAME) to 1 */
1812 s390_frame_chain (struct frame_info *thisframe)
1814 CORE_ADDR prev_fp = 0;
1816 if (deprecated_generic_find_dummy_frame (get_frame_pc (thisframe),
1817 get_frame_base (thisframe)))
1818 return deprecated_read_register_dummy (get_frame_pc (thisframe),
1819 get_frame_base (thisframe),
1824 CORE_ADDR sregs = 0;
1825 struct frame_extra_info prev_fextra_info;
1827 memset (&prev_fextra_info, 0, sizeof (prev_fextra_info));
1828 if (get_frame_pc (thisframe))
1830 CORE_ADDR saved_pc, sig_pc;
1832 saved_pc = s390_frame_saved_pc_nofix (thisframe);
1836 s390_is_sigreturn (saved_pc, thisframe, &sregs, &sig_pc)))
1838 s390_get_frame_info (s390_sniff_pc_function_start
1839 (saved_pc, NULL), &prev_fextra_info, NULL,
1845 /* read sigregs,regs.gprs[11 or 15] */
1846 prev_fp = read_memory_integer (sregs +
1847 REGISTER_BYTE (S390_GP0_REGNUM +
1849 frame_pointer_saved_pc
1852 get_frame_extra_info (thisframe)->sigcontext = sregs;
1856 if (get_frame_saved_regs (thisframe))
1860 if (prev_fextra_info.frame_pointer_saved_pc
1861 && get_frame_saved_regs (thisframe)[S390_FRAME_REGNUM])
1862 regno = S390_FRAME_REGNUM;
1864 regno = S390_SP_REGNUM;
1866 if (get_frame_saved_regs (thisframe)[regno])
1868 /* The SP's entry of `saved_regs' is special. */
1869 if (regno == S390_SP_REGNUM)
1870 prev_fp = get_frame_saved_regs (thisframe)[regno];
1873 read_memory_integer (get_frame_saved_regs (thisframe)[regno],
1879 return ADDR_BITS_REMOVE (prev_fp);
1883 Whether struct frame_extra_info is actually needed I'll have to figure
1884 out as our frames are similar to rs6000 there is a possibility
1885 i386 dosen't need it. */
1889 /* a given return value in `regbuf' with a type `valtype', extract and copy its
1890 value into `valbuf' */
1892 s390_extract_return_value (struct type *valtype, char *regbuf, char *valbuf)
1894 /* floats and doubles are returned in fpr0. fpr's have a size of 8 bytes.
1895 We need to truncate the return value into float size (4 byte) if
1897 int len = TYPE_LENGTH (valtype);
1899 if (TYPE_CODE (valtype) == TYPE_CODE_FLT)
1900 memcpy (valbuf, ®buf[REGISTER_BYTE (S390_FP0_REGNUM)], len);
1904 /* return value is copied starting from r2. */
1905 if (TYPE_LENGTH (valtype) < S390_GPR_SIZE)
1906 offset = S390_GPR_SIZE - TYPE_LENGTH (valtype);
1908 regbuf + REGISTER_BYTE (S390_GP0_REGNUM + 2) + offset,
1909 TYPE_LENGTH (valtype));
1915 s390_promote_integer_argument (struct type *valtype, char *valbuf,
1916 char *reg_buff, int *arglen)
1918 char *value = valbuf;
1919 int len = TYPE_LENGTH (valtype);
1921 if (len < S390_GPR_SIZE)
1923 /* We need to upgrade this value to a register to pass it correctly */
1924 int idx, diff = S390_GPR_SIZE - len, negative =
1925 (!TYPE_UNSIGNED (valtype) && value[0] & 0x80);
1926 for (idx = 0; idx < S390_GPR_SIZE; idx++)
1928 reg_buff[idx] = (idx < diff ? (negative ? 0xff : 0x0) :
1932 *arglen = S390_GPR_SIZE;
1936 if (len & (S390_GPR_SIZE - 1))
1938 fprintf_unfiltered (gdb_stderr,
1939 "s390_promote_integer_argument detected an argument not "
1940 "a multiple of S390_GPR_SIZE & greater than S390_GPR_SIZE "
1941 "we might not deal with this correctly.\n");
1950 s390_store_return_value (struct type *valtype, char *valbuf)
1953 char *reg_buff = alloca (max (S390_FPR_SIZE, DEPRECATED_REGISTER_SIZE)), *value;
1955 if (TYPE_CODE (valtype) == TYPE_CODE_FLT)
1957 if (TYPE_LENGTH (valtype) == 4
1958 || TYPE_LENGTH (valtype) == 8)
1959 deprecated_write_register_bytes (REGISTER_BYTE (S390_FP0_REGNUM),
1960 valbuf, TYPE_LENGTH (valtype));
1962 error ("GDB is unable to return `long double' values "
1963 "on this architecture.");
1968 s390_promote_integer_argument (valtype, valbuf, reg_buff, &arglen);
1969 /* Everything else is returned in GPR2 and up. */
1970 deprecated_write_register_bytes (REGISTER_BYTE (S390_GP0_REGNUM + 2),
1975 gdb_print_insn_s390 (bfd_vma memaddr, disassemble_info * info)
1977 bfd_byte instrbuff[S390_MAX_INSTR_SIZE];
1980 instrlen = s390_readinstruction (instrbuff, (CORE_ADDR) memaddr, info);
1983 (*info->memory_error_func) (instrlen, memaddr, info);
1986 for (cnt = 0; cnt < instrlen; cnt++)
1987 info->fprintf_func (info->stream, "%02X ", instrbuff[cnt]);
1988 for (cnt = instrlen; cnt < S390_MAX_INSTR_SIZE; cnt++)
1989 info->fprintf_func (info->stream, " ");
1990 instrlen = print_insn_s390 (memaddr, info);
1996 /* Not the most efficent code in the world */
1998 s390_fp_regnum (void)
2000 int regno = S390_SP_REGNUM;
2001 struct frame_extra_info fextra_info;
2003 CORE_ADDR pc = ADDR_BITS_REMOVE (read_register (S390_PC_REGNUM));
2005 s390_get_frame_info (s390_sniff_pc_function_start (pc, NULL), &fextra_info,
2007 if (fextra_info.frame_pointer_saved_pc)
2008 regno = S390_FRAME_REGNUM;
2015 return read_register (s390_fp_regnum ());
2020 s390_pop_frame_regular (struct frame_info *frame)
2024 write_register (S390_PC_REGNUM, DEPRECATED_FRAME_SAVED_PC (frame));
2026 /* Restore any saved registers. */
2027 if (get_frame_saved_regs (frame))
2029 for (regnum = 0; regnum < NUM_REGS; regnum++)
2030 if (get_frame_saved_regs (frame)[regnum] != 0)
2034 value = read_memory_unsigned_integer (get_frame_saved_regs (frame)[regnum],
2035 REGISTER_RAW_SIZE (regnum));
2036 write_register (regnum, value);
2039 /* Actually cut back the stack. Remember that the SP's element of
2040 saved_regs is the old SP itself, not the address at which it is
2042 write_register (S390_SP_REGNUM, get_frame_saved_regs (frame)[S390_SP_REGNUM]);
2045 /* Throw away any cached frame information. */
2046 flush_cached_frames ();
2050 /* Destroy the innermost (Top-Of-Stack) stack frame, restoring the
2051 machine state that was in effect before the frame was created.
2052 Used in the contexts of the "return" command, and of
2053 target function calls from the debugger. */
2055 s390_pop_frame (void)
2057 /* This function checks for and handles generic dummy frames, and
2058 calls back to our function for ordinary frames. */
2059 generic_pop_current_frame (s390_pop_frame_regular);
2063 /* Return non-zero if TYPE is an integer-like type, zero otherwise.
2064 "Integer-like" types are those that should be passed the way
2065 integers are: integers, enums, ranges, characters, and booleans. */
2067 is_integer_like (struct type *type)
2069 enum type_code code = TYPE_CODE (type);
2071 return (code == TYPE_CODE_INT
2072 || code == TYPE_CODE_ENUM
2073 || code == TYPE_CODE_RANGE
2074 || code == TYPE_CODE_CHAR
2075 || code == TYPE_CODE_BOOL);
2079 /* Return non-zero if TYPE is a pointer-like type, zero otherwise.
2080 "Pointer-like" types are those that should be passed the way
2081 pointers are: pointers and references. */
2083 is_pointer_like (struct type *type)
2085 enum type_code code = TYPE_CODE (type);
2087 return (code == TYPE_CODE_PTR
2088 || code == TYPE_CODE_REF);
2092 /* Return non-zero if TYPE is a `float singleton' or `double
2093 singleton', zero otherwise.
2095 A `T singleton' is a struct type with one member, whose type is
2096 either T or a `T singleton'. So, the following are all float
2100 struct { struct { float x; } x; };
2101 struct { struct { struct { float x; } x; } x; };
2105 WHY THE HECK DO WE CARE ABOUT THIS??? Well, it turns out that GCC
2106 passes all float singletons and double singletons as if they were
2107 simply floats or doubles. This is *not* what the ABI says it
2110 is_float_singleton (struct type *type)
2112 return (TYPE_CODE (type) == TYPE_CODE_STRUCT
2113 && TYPE_NFIELDS (type) == 1
2114 && (TYPE_CODE (TYPE_FIELD_TYPE (type, 0)) == TYPE_CODE_FLT
2115 || is_float_singleton (TYPE_FIELD_TYPE (type, 0))));
2119 /* Return non-zero if TYPE is a struct-like type, zero otherwise.
2120 "Struct-like" types are those that should be passed as structs are:
2123 As an odd quirk, not mentioned in the ABI, GCC passes float and
2124 double singletons as if they were a plain float, double, etc. (The
2125 corresponding union types are handled normally.) So we exclude
2126 those types here. *shrug* */
2128 is_struct_like (struct type *type)
2130 enum type_code code = TYPE_CODE (type);
2132 return (code == TYPE_CODE_UNION
2133 || (code == TYPE_CODE_STRUCT && ! is_float_singleton (type)));
2137 /* Return non-zero if TYPE is a float-like type, zero otherwise.
2138 "Float-like" types are those that should be passed as
2139 floating-point values are.
2141 You'd think this would just be floats, doubles, long doubles, etc.
2142 But as an odd quirk, not mentioned in the ABI, GCC passes float and
2143 double singletons as if they were a plain float, double, etc. (The
2144 corresponding union types are handled normally.) So we include
2145 those types here. *shrug* */
2147 is_float_like (struct type *type)
2149 return (TYPE_CODE (type) == TYPE_CODE_FLT
2150 || is_float_singleton (type));
2154 /* Return non-zero if TYPE is considered a `DOUBLE_OR_FLOAT', as
2155 defined by the parameter passing conventions described in the
2156 "GNU/Linux for S/390 ELF Application Binary Interface Supplement".
2157 Otherwise, return zero. */
2159 is_double_or_float (struct type *type)
2161 return (is_float_like (type)
2162 && (TYPE_LENGTH (type) == 4
2163 || TYPE_LENGTH (type) == 8));
2167 /* Return non-zero if TYPE is a `DOUBLE_ARG', as defined by the
2168 parameter passing conventions described in the "GNU/Linux for S/390
2169 ELF Application Binary Interface Supplement". Return zero
2172 is_double_arg (struct type *type)
2174 unsigned length = TYPE_LENGTH (type);
2176 /* The s390x ABI doesn't handle DOUBLE_ARGS specially. */
2177 if (GDB_TARGET_IS_ESAME)
2180 return ((is_integer_like (type)
2181 || is_struct_like (type))
2186 /* Return non-zero if TYPE is considered a `SIMPLE_ARG', as defined by
2187 the parameter passing conventions described in the "GNU/Linux for
2188 S/390 ELF Application Binary Interface Supplement". Return zero
2191 is_simple_arg (struct type *type)
2193 unsigned length = TYPE_LENGTH (type);
2195 /* This is almost a direct translation of the ABI's language, except
2196 that we have to exclude 8-byte structs; those are DOUBLE_ARGs. */
2197 return ((is_integer_like (type) && length <= DEPRECATED_REGISTER_SIZE)
2198 || is_pointer_like (type)
2199 || (is_struct_like (type) && !is_double_arg (type)));
2204 is_power_of_two (unsigned int n)
2206 return ((n & (n - 1)) == 0);
2209 /* Return non-zero if TYPE should be passed as a pointer to a copy,
2210 zero otherwise. TYPE must be a SIMPLE_ARG, as recognized by
2213 pass_by_copy_ref (struct type *type)
2215 unsigned length = TYPE_LENGTH (type);
2217 return (is_struct_like (type)
2218 && !(is_power_of_two (length) && length <= DEPRECATED_REGISTER_SIZE));
2222 /* Return ARG, a `SIMPLE_ARG', sign-extended or zero-extended to a full
2223 word as required for the ABI. */
2225 extend_simple_arg (struct value *arg)
2227 struct type *type = VALUE_TYPE (arg);
2229 /* Even structs get passed in the least significant bits of the
2230 register / memory word. It's not really right to extract them as
2231 an integer, but it does take care of the extension. */
2232 if (TYPE_UNSIGNED (type))
2233 return extract_unsigned_integer (VALUE_CONTENTS (arg),
2234 TYPE_LENGTH (type));
2236 return extract_signed_integer (VALUE_CONTENTS (arg),
2237 TYPE_LENGTH (type));
2241 /* Round ADDR up to the next N-byte boundary. N must be a power of
2244 round_up (CORE_ADDR addr, int n)
2246 /* Check that N is really a power of two. */
2247 gdb_assert (n && (n & (n-1)) == 0);
2248 return ((addr + n - 1) & -n);
2252 /* Round ADDR down to the next N-byte boundary. N must be a power of
2255 round_down (CORE_ADDR addr, int n)
2257 /* Check that N is really a power of two. */
2258 gdb_assert (n && (n & (n-1)) == 0);
2263 /* Return the alignment required by TYPE. */
2265 alignment_of (struct type *type)
2269 if (is_integer_like (type)
2270 || is_pointer_like (type)
2271 || TYPE_CODE (type) == TYPE_CODE_FLT)
2272 alignment = TYPE_LENGTH (type);
2273 else if (TYPE_CODE (type) == TYPE_CODE_STRUCT
2274 || TYPE_CODE (type) == TYPE_CODE_UNION)
2279 for (i = 0; i < TYPE_NFIELDS (type); i++)
2281 int field_alignment = alignment_of (TYPE_FIELD_TYPE (type, i));
2283 if (field_alignment > alignment)
2284 alignment = field_alignment;
2290 /* Check that everything we ever return is a power of two. Lots of
2291 code doesn't want to deal with aligning things to arbitrary
2293 gdb_assert ((alignment & (alignment - 1)) == 0);
2299 /* Put the actual parameter values pointed to by ARGS[0..NARGS-1] in
2300 place to be passed to a function, as specified by the "GNU/Linux
2301 for S/390 ELF Application Binary Interface Supplement".
2303 SP is the current stack pointer. We must put arguments, links,
2304 padding, etc. whereever they belong, and return the new stack
2307 If STRUCT_RETURN is non-zero, then the function we're calling is
2308 going to return a structure by value; STRUCT_ADDR is the address of
2309 a block we've allocated for it on the stack.
2311 Our caller has taken care of any type promotions needed to satisfy
2312 prototypes or the old K&R argument-passing rules. */
2314 s390_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
2315 int struct_return, CORE_ADDR struct_addr)
2318 int pointer_size = (TARGET_PTR_BIT / TARGET_CHAR_BIT);
2320 /* The number of arguments passed by reference-to-copy. */
2323 /* If the i'th argument is passed as a reference to a copy, then
2324 copy_addr[i] is the address of the copy we made. */
2325 CORE_ADDR *copy_addr = alloca (nargs * sizeof (CORE_ADDR));
2327 /* Build the reference-to-copy area. */
2329 for (i = 0; i < nargs; i++)
2331 struct value *arg = args[i];
2332 struct type *type = VALUE_TYPE (arg);
2333 unsigned length = TYPE_LENGTH (type);
2335 if (is_simple_arg (type)
2336 && pass_by_copy_ref (type))
2339 sp = round_down (sp, alignment_of (type));
2340 write_memory (sp, VALUE_CONTENTS (arg), length);
2346 /* Reserve space for the parameter area. As a conservative
2347 simplification, we assume that everything will be passed on the
2352 for (i = 0; i < nargs; i++)
2354 struct value *arg = args[i];
2355 struct type *type = VALUE_TYPE (arg);
2356 int length = TYPE_LENGTH (type);
2358 sp = round_down (sp, alignment_of (type));
2360 /* SIMPLE_ARG values get extended to DEPRECATED_REGISTER_SIZE bytes.
2361 Assume every argument is. */
2362 if (length < DEPRECATED_REGISTER_SIZE) length = DEPRECATED_REGISTER_SIZE;
2367 /* Include space for any reference-to-copy pointers. */
2368 sp = round_down (sp, pointer_size);
2369 sp -= num_copies * pointer_size;
2371 /* After all that, make sure it's still aligned on an eight-byte
2373 sp = round_down (sp, 8);
2375 /* Finally, place the actual parameters, working from SP towards
2376 higher addresses. The code above is supposed to reserve enough
2381 CORE_ADDR starg = sp;
2383 /* A struct is returned using general register 2 */
2387 for (i = 0; i < nargs; i++)
2389 struct value *arg = args[i];
2390 struct type *type = VALUE_TYPE (arg);
2392 if (is_double_or_float (type)
2393 && fr <= S390_NUM_FP_PARAMETER_REGISTERS * 2 - 2)
2395 /* When we store a single-precision value in an FP register,
2396 it occupies the leftmost bits. */
2397 deprecated_write_register_bytes (REGISTER_BYTE (S390_FP0_REGNUM + fr),
2398 VALUE_CONTENTS (arg),
2399 TYPE_LENGTH (type));
2402 else if (is_simple_arg (type)
2405 /* Do we need to pass a pointer to our copy of this
2407 if (pass_by_copy_ref (type))
2408 write_register (S390_GP0_REGNUM + gr, copy_addr[i]);
2410 write_register (S390_GP0_REGNUM + gr, extend_simple_arg (arg));
2414 else if (is_double_arg (type)
2417 deprecated_write_register_gen (S390_GP0_REGNUM + gr,
2418 VALUE_CONTENTS (arg));
2419 deprecated_write_register_gen (S390_GP0_REGNUM + gr + 1,
2420 VALUE_CONTENTS (arg) + DEPRECATED_REGISTER_SIZE);
2425 /* The `OTHER' case. */
2426 enum type_code code = TYPE_CODE (type);
2427 unsigned length = TYPE_LENGTH (type);
2429 /* If we skipped r6 because we couldn't fit a DOUBLE_ARG
2430 in it, then don't go back and use it again later. */
2431 if (is_double_arg (type) && gr == 6)
2434 if (is_simple_arg (type))
2436 /* Simple args are always extended to
2437 DEPRECATED_REGISTER_SIZE bytes. */
2438 starg = round_up (starg, DEPRECATED_REGISTER_SIZE);
2440 /* Do we need to pass a pointer to our copy of this
2442 if (pass_by_copy_ref (type))
2443 write_memory_signed_integer (starg, pointer_size,
2446 /* Simple args are always extended to
2447 DEPRECATED_REGISTER_SIZE bytes. */
2448 write_memory_signed_integer (starg, DEPRECATED_REGISTER_SIZE,
2449 extend_simple_arg (arg));
2450 starg += DEPRECATED_REGISTER_SIZE;
2454 /* You'd think we should say:
2455 starg = round_up (starg, alignment_of (type));
2456 Unfortunately, GCC seems to simply align the stack on
2457 a four/eight-byte boundary, even when passing doubles. */
2458 starg = round_up (starg, S390_STACK_PARAMETER_ALIGNMENT);
2459 write_memory (starg, VALUE_CONTENTS (arg), length);
2466 /* Allocate the standard frame areas: the register save area, the
2467 word reserved for the compiler (which seems kind of meaningless),
2468 and the back chain pointer. */
2469 sp -= S390_STACK_FRAME_OVERHEAD;
2471 /* Write the back chain pointer into the first word of the stack
2472 frame. This will help us get backtraces from within functions
2474 write_memory_unsigned_integer (sp, (TARGET_PTR_BIT / TARGET_CHAR_BIT),
2475 deprecated_read_fp ());
2482 s390_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
2484 /* Both the 32- and 64-bit ABI's say that the stack pointer should
2485 always be aligned on an eight-byte boundary. */
2491 s390_use_struct_convention (int gcc_p, struct type *value_type)
2493 enum type_code code = TYPE_CODE (value_type);
2495 return (code == TYPE_CODE_STRUCT
2496 || code == TYPE_CODE_UNION);
2500 /* Return the GDB type object for the "standard" data type
2501 of data in register N. */
2502 static struct type *
2503 s390_register_virtual_type (int regno)
2505 if (S390_FP0_REGNUM <= regno && regno < S390_FP0_REGNUM + S390_NUM_FPRS)
2506 return builtin_type_double;
2508 return builtin_type_int;
2512 static struct type *
2513 s390x_register_virtual_type (int regno)
2515 return (regno == S390_FPC_REGNUM) ||
2516 (regno >= S390_FIRST_ACR && regno <= S390_LAST_ACR) ? builtin_type_int :
2517 (regno >= S390_FP0_REGNUM) ? builtin_type_double : builtin_type_long;
2523 s390_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
2525 write_register (S390_GP0_REGNUM + 2, addr);
2530 static const unsigned char *
2531 s390_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
2533 static unsigned char breakpoint[] = { 0x0, 0x1 };
2535 *lenptr = sizeof (breakpoint);
2539 /* Advance PC across any function entry prologue instructions to reach some
2542 s390_skip_prologue (CORE_ADDR pc)
2544 struct frame_extra_info fextra_info;
2546 s390_get_frame_info (pc, &fextra_info, NULL, 1);
2547 return fextra_info.skip_prologue_function_start;
2550 /* Immediately after a function call, return the saved pc.
2551 Can't go through the frames for this because on some machines
2552 the new frame is not set up until the new function executes
2553 some instructions. */
2555 s390_saved_pc_after_call (struct frame_info *frame)
2557 return ADDR_BITS_REMOVE (read_register (S390_RETADDR_REGNUM));
2561 s390_addr_bits_remove (CORE_ADDR addr)
2563 return (addr) & 0x7fffffff;
2568 s390_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
2570 write_register (S390_RETADDR_REGNUM, CALL_DUMMY_ADDRESS ());
2575 s390_address_class_type_flags (int byte_size, int dwarf2_addr_class)
2578 return TYPE_FLAG_ADDRESS_CLASS_1;
2584 s390_address_class_type_flags_to_name (struct gdbarch *gdbarch, int type_flags)
2586 if (type_flags & TYPE_FLAG_ADDRESS_CLASS_1)
2593 s390_address_class_name_to_type_flags (struct gdbarch *gdbarch, const char *name,
2594 int *type_flags_ptr)
2596 if (strcmp (name, "mode32") == 0)
2598 *type_flags_ptr = TYPE_FLAG_ADDRESS_CLASS_1;
2605 static struct gdbarch *
2606 s390_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
2608 static LONGEST s390_call_dummy_words[] = { 0 };
2609 struct gdbarch *gdbarch;
2610 struct gdbarch_tdep *tdep;
2613 /* First see if there is already a gdbarch that can satisfy the request. */
2614 arches = gdbarch_list_lookup_by_info (arches, &info);
2616 return arches->gdbarch;
2618 /* None found: is the request for a s390 architecture? */
2619 if (info.bfd_arch_info->arch != bfd_arch_s390)
2620 return NULL; /* No; then it's not for us. */
2622 /* Yes: create a new gdbarch for the specified machine type. */
2623 gdbarch = gdbarch_alloc (&info, NULL);
2625 /* NOTE: cagney/2002-12-06: This can be deleted when this arch is
2626 ready to unwind the PC first (see frame.c:get_prev_frame()). */
2627 set_gdbarch_deprecated_init_frame_pc (gdbarch, init_frame_pc_default);
2629 set_gdbarch_believe_pcc_promotion (gdbarch, 0);
2630 set_gdbarch_char_signed (gdbarch, 0);
2632 set_gdbarch_frame_args_skip (gdbarch, 0);
2633 set_gdbarch_deprecated_frame_chain (gdbarch, s390_frame_chain);
2634 set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, s390_frame_init_saved_regs);
2635 set_gdbarch_deprecated_store_struct_return (gdbarch, s390_store_struct_return);
2636 set_gdbarch_deprecated_extract_return_value (gdbarch, s390_extract_return_value);
2637 set_gdbarch_deprecated_store_return_value (gdbarch, s390_store_return_value);
2638 /* Amount PC must be decremented by after a breakpoint. This is
2639 often the number of bytes returned by BREAKPOINT_FROM_PC but not
2641 set_gdbarch_decr_pc_after_break (gdbarch, 2);
2642 set_gdbarch_deprecated_pop_frame (gdbarch, s390_pop_frame);
2643 /* Stack grows downward. */
2644 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
2645 /* Offset from address of function to start of its code.
2646 Zero on most machines. */
2647 set_gdbarch_function_start_offset (gdbarch, 0);
2648 set_gdbarch_deprecated_max_register_raw_size (gdbarch, 8);
2649 set_gdbarch_deprecated_max_register_virtual_size (gdbarch, 8);
2650 set_gdbarch_breakpoint_from_pc (gdbarch, s390_breakpoint_from_pc);
2651 set_gdbarch_skip_prologue (gdbarch, s390_skip_prologue);
2652 set_gdbarch_deprecated_init_extra_frame_info (gdbarch, s390_init_extra_frame_info);
2653 set_gdbarch_deprecated_init_frame_pc_first (gdbarch, s390_init_frame_pc_first);
2654 set_gdbarch_deprecated_target_read_fp (gdbarch, s390_read_fp);
2655 /* This function that tells us whether the function invocation represented
2656 by FI does not have a frame on the stack associated with it. If it
2657 does not, FRAMELESS is set to 1, else 0. */
2658 set_gdbarch_frameless_function_invocation (gdbarch,
2659 s390_frameless_function_invocation);
2660 /* Return saved PC from a frame */
2661 set_gdbarch_deprecated_frame_saved_pc (gdbarch, s390_frame_saved_pc);
2662 /* DEPRECATED_FRAME_CHAIN takes a frame's nominal address and
2663 produces the frame's chain-pointer. */
2664 set_gdbarch_deprecated_frame_chain (gdbarch, s390_frame_chain);
2665 set_gdbarch_deprecated_saved_pc_after_call (gdbarch, s390_saved_pc_after_call);
2666 set_gdbarch_deprecated_register_byte (gdbarch, s390_register_byte);
2667 set_gdbarch_pc_regnum (gdbarch, S390_PC_REGNUM);
2668 set_gdbarch_sp_regnum (gdbarch, S390_SP_REGNUM);
2669 set_gdbarch_deprecated_fp_regnum (gdbarch, S390_FP_REGNUM);
2670 set_gdbarch_fp0_regnum (gdbarch, S390_FP0_REGNUM);
2671 set_gdbarch_num_regs (gdbarch, S390_NUM_REGS);
2672 set_gdbarch_cannot_fetch_register (gdbarch, s390_cannot_fetch_register);
2673 set_gdbarch_cannot_store_register (gdbarch, s390_cannot_fetch_register);
2674 set_gdbarch_use_struct_convention (gdbarch, s390_use_struct_convention);
2675 set_gdbarch_register_name (gdbarch, s390_register_name);
2676 set_gdbarch_stab_reg_to_regnum (gdbarch, s390_stab_reg_to_regnum);
2677 set_gdbarch_dwarf_reg_to_regnum (gdbarch, s390_stab_reg_to_regnum);
2678 set_gdbarch_dwarf2_reg_to_regnum (gdbarch, s390_stab_reg_to_regnum);
2679 set_gdbarch_deprecated_extract_struct_value_address
2680 (gdbarch, generic_cannot_extract_struct_value_address);
2682 /* Parameters for inferior function calls. */
2683 set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_at_entry_point);
2684 set_gdbarch_frame_align (gdbarch, s390_frame_align);
2685 set_gdbarch_deprecated_push_arguments (gdbarch, s390_push_arguments);
2686 set_gdbarch_deprecated_save_dummy_frame_tos (gdbarch, generic_save_dummy_frame_tos);
2687 set_gdbarch_deprecated_push_return_address (gdbarch,
2688 s390_push_return_address);
2689 set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof (s390_call_dummy_words));
2690 set_gdbarch_deprecated_call_dummy_words (gdbarch, s390_call_dummy_words);
2692 switch (info.bfd_arch_info->mach)
2694 case bfd_mach_s390_31:
2695 set_gdbarch_deprecated_register_size (gdbarch, 4);
2696 set_gdbarch_deprecated_register_raw_size (gdbarch, s390_register_raw_size);
2697 set_gdbarch_deprecated_register_virtual_size (gdbarch, s390_register_raw_size);
2698 set_gdbarch_deprecated_register_virtual_type (gdbarch, s390_register_virtual_type);
2700 set_gdbarch_addr_bits_remove (gdbarch, s390_addr_bits_remove);
2701 set_gdbarch_deprecated_register_bytes (gdbarch, S390_REGISTER_BYTES);
2703 case bfd_mach_s390_64:
2704 set_gdbarch_deprecated_register_size (gdbarch, 8);
2705 set_gdbarch_deprecated_register_raw_size (gdbarch, s390x_register_raw_size);
2706 set_gdbarch_deprecated_register_virtual_size (gdbarch, s390x_register_raw_size);
2707 set_gdbarch_deprecated_register_virtual_type (gdbarch, s390x_register_virtual_type);
2709 set_gdbarch_long_bit (gdbarch, 64);
2710 set_gdbarch_long_long_bit (gdbarch, 64);
2711 set_gdbarch_ptr_bit (gdbarch, 64);
2712 set_gdbarch_deprecated_register_bytes (gdbarch, S390X_REGISTER_BYTES);
2713 set_gdbarch_address_class_type_flags (gdbarch,
2714 s390_address_class_type_flags);
2715 set_gdbarch_address_class_type_flags_to_name (gdbarch,
2716 s390_address_class_type_flags_to_name);
2717 set_gdbarch_address_class_name_to_type_flags (gdbarch,
2718 s390_address_class_name_to_type_flags);
2722 /* Should be using push_dummy_call. */
2723 set_gdbarch_deprecated_dummy_write_sp (gdbarch, deprecated_write_sp);
2730 extern initialize_file_ftype _initialize_s390_tdep; /* -Wmissing-prototypes */
2733 _initialize_s390_tdep (void)
2736 /* Hook us into the gdbarch mechanism. */
2737 register_gdbarch_init (bfd_arch_s390, s390_gdbarch_init);
2738 if (!deprecated_tm_print_insn) /* Someone may have already set it */
2739 deprecated_tm_print_insn = gdb_print_insn_s390;