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