* alpha-tdep.c (alpha_register_type): Use builtin_type (gdbarch)
[external/binutils.git] / gdb / s390-tdep.c
1 /* Target-dependent code for GDB, the GNU debugger.
2
3    Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
4    Free Software Foundation, Inc.
5
6    Contributed by D.J. Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
7    for IBM Deutschland Entwicklung GmbH, IBM Corporation.
8
9    This file is part of GDB.
10
11    This program is free software; you can redistribute it and/or modify
12    it under the terms of the GNU General Public License as published by
13    the Free Software Foundation; either version 3 of the License, or
14    (at your option) any later version.
15
16    This program is distributed in the hope that it will be useful,
17    but WITHOUT ANY WARRANTY; without even the implied warranty of
18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19    GNU General Public License for more details.
20
21    You should have received a copy of the GNU General Public License
22    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
23
24 #include "defs.h"
25 #include "arch-utils.h"
26 #include "frame.h"
27 #include "inferior.h"
28 #include "symtab.h"
29 #include "target.h"
30 #include "gdbcore.h"
31 #include "gdbcmd.h"
32 #include "objfiles.h"
33 #include "floatformat.h"
34 #include "regcache.h"
35 #include "trad-frame.h"
36 #include "frame-base.h"
37 #include "frame-unwind.h"
38 #include "dwarf2-frame.h"
39 #include "reggroups.h"
40 #include "regset.h"
41 #include "value.h"
42 #include "gdb_assert.h"
43 #include "dis-asm.h"
44 #include "solib-svr4.h"
45 #include "prologue-value.h"
46
47 #include "s390-tdep.h"
48
49
50 /* The tdep structure.  */
51
52 struct gdbarch_tdep
53 {
54   /* ABI version.  */
55   enum { ABI_LINUX_S390, ABI_LINUX_ZSERIES } abi;
56
57   /* Core file register sets.  */
58   const struct regset *gregset;
59   int sizeof_gregset;
60
61   const struct regset *fpregset;
62   int sizeof_fpregset;
63 };
64
65
66 /* Return the name of register REGNUM.  */
67 static const char *
68 s390_register_name (struct gdbarch *gdbarch, int regnum)
69 {
70   static const char *register_names[S390_NUM_TOTAL_REGS] =
71     {
72       /* Program Status Word.  */
73       "pswm", "pswa",
74       /* General Purpose Registers.  */
75       "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
76       "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
77       /* Access Registers.  */
78       "acr0", "acr1", "acr2", "acr3", "acr4", "acr5", "acr6", "acr7",
79       "acr8", "acr9", "acr10", "acr11", "acr12", "acr13", "acr14", "acr15",
80       /* Floating Point Control Word.  */
81       "fpc",
82       /* Floating Point Registers.  */
83       "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
84       "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
85       /* Pseudo registers.  */
86       "pc", "cc",
87     };
88
89   gdb_assert (regnum >= 0 && regnum < S390_NUM_TOTAL_REGS);
90   return register_names[regnum];
91 }
92
93 /* Return the GDB type object for the "standard" data type of data in
94    register REGNUM.  */
95 static struct type *
96 s390_register_type (struct gdbarch *gdbarch, int regnum)
97 {
98   if (regnum == S390_PSWM_REGNUM || regnum == S390_PSWA_REGNUM)
99     return builtin_type (gdbarch)->builtin_long;
100   if (regnum >= S390_R0_REGNUM && regnum <= S390_R15_REGNUM)
101     return builtin_type (gdbarch)->builtin_long;
102   if (regnum >= S390_A0_REGNUM && regnum <= S390_A15_REGNUM)
103     return builtin_type (gdbarch)->builtin_int;
104   if (regnum == S390_FPC_REGNUM)
105     return builtin_type (gdbarch)->builtin_int;
106   if (regnum >= S390_F0_REGNUM && regnum <= S390_F15_REGNUM)
107     return builtin_type (gdbarch)->builtin_double;
108   if (regnum == S390_PC_REGNUM)
109     return builtin_type (gdbarch)->builtin_func_ptr;
110   if (regnum == S390_CC_REGNUM)
111     return builtin_type (gdbarch)->builtin_int;
112
113   internal_error (__FILE__, __LINE__, _("invalid regnum"));
114 }
115
116 /* DWARF Register Mapping.  */
117
118 static int s390_dwarf_regmap[] =
119 {
120   /* General Purpose Registers.  */
121   S390_R0_REGNUM, S390_R1_REGNUM, S390_R2_REGNUM, S390_R3_REGNUM,
122   S390_R4_REGNUM, S390_R5_REGNUM, S390_R6_REGNUM, S390_R7_REGNUM,
123   S390_R8_REGNUM, S390_R9_REGNUM, S390_R10_REGNUM, S390_R11_REGNUM,
124   S390_R12_REGNUM, S390_R13_REGNUM, S390_R14_REGNUM, S390_R15_REGNUM,
125
126   /* Floating Point Registers.  */
127   S390_F0_REGNUM, S390_F2_REGNUM, S390_F4_REGNUM, S390_F6_REGNUM,
128   S390_F1_REGNUM, S390_F3_REGNUM, S390_F5_REGNUM, S390_F7_REGNUM,
129   S390_F8_REGNUM, S390_F10_REGNUM, S390_F12_REGNUM, S390_F14_REGNUM,
130   S390_F9_REGNUM, S390_F11_REGNUM, S390_F13_REGNUM, S390_F15_REGNUM,
131
132   /* Control Registers (not mapped).  */
133   -1, -1, -1, -1, -1, -1, -1, -1, 
134   -1, -1, -1, -1, -1, -1, -1, -1, 
135
136   /* Access Registers.  */
137   S390_A0_REGNUM, S390_A1_REGNUM, S390_A2_REGNUM, S390_A3_REGNUM,
138   S390_A4_REGNUM, S390_A5_REGNUM, S390_A6_REGNUM, S390_A7_REGNUM,
139   S390_A8_REGNUM, S390_A9_REGNUM, S390_A10_REGNUM, S390_A11_REGNUM,
140   S390_A12_REGNUM, S390_A13_REGNUM, S390_A14_REGNUM, S390_A15_REGNUM,
141
142   /* Program Status Word.  */
143   S390_PSWM_REGNUM,
144   S390_PSWA_REGNUM
145 };
146
147 /* Convert DWARF register number REG to the appropriate register
148    number used by GDB.  */
149 static int
150 s390_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int reg)
151 {
152   int regnum = -1;
153
154   if (reg >= 0 && reg < ARRAY_SIZE (s390_dwarf_regmap))
155     regnum = s390_dwarf_regmap[reg];
156
157   if (regnum == -1)
158     warning (_("Unmapped DWARF Register #%d encountered."), reg);
159
160   return regnum;
161 }
162
163 /* Pseudo registers - PC and condition code.  */
164
165 static void
166 s390_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
167                            int regnum, gdb_byte *buf)
168 {
169   ULONGEST val;
170
171   switch (regnum)
172     {
173     case S390_PC_REGNUM:
174       regcache_raw_read_unsigned (regcache, S390_PSWA_REGNUM, &val);
175       store_unsigned_integer (buf, 4, val & 0x7fffffff);
176       break;
177
178     case S390_CC_REGNUM:
179       regcache_raw_read_unsigned (regcache, S390_PSWM_REGNUM, &val);
180       store_unsigned_integer (buf, 4, (val >> 12) & 3);
181       break;
182
183     default:
184       internal_error (__FILE__, __LINE__, _("invalid regnum"));
185     }
186 }
187
188 static void
189 s390_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
190                             int regnum, const gdb_byte *buf)
191 {
192   ULONGEST val, psw;
193
194   switch (regnum)
195     {
196     case S390_PC_REGNUM:
197       val = extract_unsigned_integer (buf, 4);
198       regcache_raw_read_unsigned (regcache, S390_PSWA_REGNUM, &psw);
199       psw = (psw & 0x80000000) | (val & 0x7fffffff);
200       regcache_raw_write_unsigned (regcache, S390_PSWA_REGNUM, psw);
201       break;
202
203     case S390_CC_REGNUM:
204       val = extract_unsigned_integer (buf, 4);
205       regcache_raw_read_unsigned (regcache, S390_PSWM_REGNUM, &psw);
206       psw = (psw & ~((ULONGEST)3 << 12)) | ((val & 3) << 12);
207       regcache_raw_write_unsigned (regcache, S390_PSWM_REGNUM, psw);
208       break;
209
210     default:
211       internal_error (__FILE__, __LINE__, _("invalid regnum"));
212     }
213 }
214
215 static void
216 s390x_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
217                             int regnum, gdb_byte *buf)
218 {
219   ULONGEST val;
220
221   switch (regnum)
222     {
223     case S390_PC_REGNUM:
224       regcache_raw_read (regcache, S390_PSWA_REGNUM, buf);
225       break;
226
227     case S390_CC_REGNUM:
228       regcache_raw_read_unsigned (regcache, S390_PSWM_REGNUM, &val);
229       store_unsigned_integer (buf, 4, (val >> 44) & 3);
230       break;
231
232     default:
233       internal_error (__FILE__, __LINE__, _("invalid regnum"));
234     }
235 }
236
237 static void
238 s390x_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
239                              int regnum, const gdb_byte *buf)
240 {
241   ULONGEST val, psw;
242
243   switch (regnum)
244     {
245     case S390_PC_REGNUM:
246       regcache_raw_write (regcache, S390_PSWA_REGNUM, buf);
247       break;
248
249     case S390_CC_REGNUM:
250       val = extract_unsigned_integer (buf, 4);
251       regcache_raw_read_unsigned (regcache, S390_PSWM_REGNUM, &psw);
252       psw = (psw & ~((ULONGEST)3 << 44)) | ((val & 3) << 44);
253       regcache_raw_write_unsigned (regcache, S390_PSWM_REGNUM, psw);
254       break;
255
256     default:
257       internal_error (__FILE__, __LINE__, _("invalid regnum"));
258     }
259 }
260
261 /* 'float' values are stored in the upper half of floating-point
262    registers, even though we are otherwise a big-endian platform.  */
263
264 static struct value *
265 s390_value_from_register (struct type *type, int regnum,
266                           struct frame_info *frame)
267 {
268   struct value *value = default_value_from_register (type, regnum, frame);
269   int len = TYPE_LENGTH (type);
270
271   if (regnum >= S390_F0_REGNUM && regnum <= S390_F15_REGNUM && len < 8)
272     set_value_offset (value, 0);
273
274   return value;
275 }
276
277 /* Register groups.  */
278
279 static int
280 s390_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
281                           struct reggroup *group)
282 {
283   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
284
285   /* Registers displayed via 'info regs'.  */
286   if (group == general_reggroup)
287     return (regnum >= S390_R0_REGNUM && regnum <= S390_R15_REGNUM)
288            || regnum == S390_PC_REGNUM
289            || regnum == S390_CC_REGNUM;
290
291   /* Registers displayed via 'info float'.  */
292   if (group == float_reggroup)
293     return (regnum >= S390_F0_REGNUM && regnum <= S390_F15_REGNUM)
294            || regnum == S390_FPC_REGNUM;
295
296   /* Registers that need to be saved/restored in order to
297      push or pop frames.  */
298   if (group == save_reggroup || group == restore_reggroup)
299     return regnum != S390_PSWM_REGNUM && regnum != S390_PSWA_REGNUM;
300
301   return default_register_reggroup_p (gdbarch, regnum, group);
302 }
303
304
305 /* Core file register sets.  */
306
307 int s390_regmap_gregset[S390_NUM_REGS] =
308 {
309   /* Program Status Word.  */
310   0x00, 0x04,
311   /* General Purpose Registers.  */
312   0x08, 0x0c, 0x10, 0x14,
313   0x18, 0x1c, 0x20, 0x24,
314   0x28, 0x2c, 0x30, 0x34,
315   0x38, 0x3c, 0x40, 0x44,
316   /* Access Registers.  */
317   0x48, 0x4c, 0x50, 0x54,
318   0x58, 0x5c, 0x60, 0x64,
319   0x68, 0x6c, 0x70, 0x74,
320   0x78, 0x7c, 0x80, 0x84,
321   /* Floating Point Control Word.  */
322   -1,
323   /* Floating Point Registers.  */
324   -1, -1, -1, -1, -1, -1, -1, -1,
325   -1, -1, -1, -1, -1, -1, -1, -1,
326 };
327
328 int s390x_regmap_gregset[S390_NUM_REGS] =
329 {
330   0x00, 0x08,
331   /* General Purpose Registers.  */
332   0x10, 0x18, 0x20, 0x28,
333   0x30, 0x38, 0x40, 0x48,
334   0x50, 0x58, 0x60, 0x68,
335   0x70, 0x78, 0x80, 0x88,
336   /* Access Registers.  */
337   0x90, 0x94, 0x98, 0x9c,
338   0xa0, 0xa4, 0xa8, 0xac,
339   0xb0, 0xb4, 0xb8, 0xbc,
340   0xc0, 0xc4, 0xc8, 0xcc,
341   /* Floating Point Control Word.  */
342   -1,
343   /* Floating Point Registers.  */
344   -1, -1, -1, -1, -1, -1, -1, -1,
345   -1, -1, -1, -1, -1, -1, -1, -1,
346 };
347
348 int s390_regmap_fpregset[S390_NUM_REGS] =
349 {
350   /* Program Status Word.  */
351   -1, -1,
352   /* General Purpose Registers.  */
353   -1, -1, -1, -1, -1, -1, -1, -1,
354   -1, -1, -1, -1, -1, -1, -1, -1,
355   /* Access Registers.  */
356   -1, -1, -1, -1, -1, -1, -1, -1,
357   -1, -1, -1, -1, -1, -1, -1, -1,
358   /* Floating Point Control Word.  */
359   0x00,
360   /* Floating Point Registers.  */
361   0x08, 0x10, 0x18, 0x20,
362   0x28, 0x30, 0x38, 0x40,
363   0x48, 0x50, 0x58, 0x60,
364   0x68, 0x70, 0x78, 0x80,
365 };
366
367 /* Supply register REGNUM from the register set REGSET to register cache 
368    REGCACHE.  If REGNUM is -1, do this for all registers in REGSET.  */
369 static void
370 s390_supply_regset (const struct regset *regset, struct regcache *regcache,
371                     int regnum, const void *regs, size_t len)
372 {
373   const int *offset = regset->descr;
374   int i;
375
376   for (i = 0; i < S390_NUM_REGS; i++)
377     {
378       if ((regnum == i || regnum == -1) && offset[i] != -1)
379         regcache_raw_supply (regcache, i, (const char *)regs + offset[i]);
380     }
381 }
382
383 /* Collect register REGNUM from the register cache REGCACHE and store
384    it in the buffer specified by REGS and LEN as described by the
385    general-purpose register set REGSET.  If REGNUM is -1, do this for
386    all registers in REGSET.  */
387 static void
388 s390_collect_regset (const struct regset *regset,
389                      const struct regcache *regcache,
390                      int regnum, void *regs, size_t len)
391 {
392   const int *offset = regset->descr;
393   int i;
394
395   for (i = 0; i < S390_NUM_REGS; i++)
396     {
397       if ((regnum == i || regnum == -1) && offset[i] != -1)
398         regcache_raw_collect (regcache, i, (char *)regs + offset[i]);
399     }
400 }
401
402 static const struct regset s390_gregset = {
403   s390_regmap_gregset, 
404   s390_supply_regset,
405   s390_collect_regset
406 };
407
408 static const struct regset s390x_gregset = {
409   s390x_regmap_gregset, 
410   s390_supply_regset,
411   s390_collect_regset
412 };
413
414 static const struct regset s390_fpregset = {
415   s390_regmap_fpregset, 
416   s390_supply_regset,
417   s390_collect_regset
418 };
419
420 /* Return the appropriate register set for the core section identified
421    by SECT_NAME and SECT_SIZE.  */
422 const struct regset *
423 s390_regset_from_core_section (struct gdbarch *gdbarch,
424                                const char *sect_name, size_t sect_size)
425 {
426   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
427
428   if (strcmp (sect_name, ".reg") == 0 && sect_size >= tdep->sizeof_gregset)
429     return tdep->gregset;
430
431   if (strcmp (sect_name, ".reg2") == 0 && sect_size >= tdep->sizeof_fpregset)
432     return tdep->fpregset;
433
434   return NULL;
435 }
436
437
438 /* Decoding S/390 instructions.  */
439
440 /* Named opcode values for the S/390 instructions we recognize.  Some
441    instructions have their opcode split across two fields; those are the
442    op1_* and op2_* enums.  */
443 enum
444   {
445     op1_lhi  = 0xa7,   op2_lhi  = 0x08,
446     op1_lghi = 0xa7,   op2_lghi = 0x09,
447     op1_lgfi = 0xc0,   op2_lgfi = 0x01,
448     op_lr    = 0x18,
449     op_lgr   = 0xb904,
450     op_l     = 0x58,
451     op1_ly   = 0xe3,   op2_ly   = 0x58,
452     op1_lg   = 0xe3,   op2_lg   = 0x04,
453     op_lm    = 0x98,
454     op1_lmy  = 0xeb,   op2_lmy  = 0x98,
455     op1_lmg  = 0xeb,   op2_lmg  = 0x04,
456     op_st    = 0x50,
457     op1_sty  = 0xe3,   op2_sty  = 0x50,
458     op1_stg  = 0xe3,   op2_stg  = 0x24,
459     op_std   = 0x60,
460     op_stm   = 0x90,
461     op1_stmy = 0xeb,   op2_stmy = 0x90,
462     op1_stmg = 0xeb,   op2_stmg = 0x24,
463     op1_aghi = 0xa7,   op2_aghi = 0x0b,
464     op1_ahi  = 0xa7,   op2_ahi  = 0x0a,
465     op1_agfi = 0xc2,   op2_agfi = 0x08,
466     op1_afi  = 0xc2,   op2_afi  = 0x09,
467     op1_algfi= 0xc2,   op2_algfi= 0x0a,
468     op1_alfi = 0xc2,   op2_alfi = 0x0b,
469     op_ar    = 0x1a,
470     op_agr   = 0xb908,
471     op_a     = 0x5a,
472     op1_ay   = 0xe3,   op2_ay   = 0x5a,
473     op1_ag   = 0xe3,   op2_ag   = 0x08,
474     op1_slgfi= 0xc2,   op2_slgfi= 0x04,
475     op1_slfi = 0xc2,   op2_slfi = 0x05,
476     op_sr    = 0x1b,
477     op_sgr   = 0xb909,
478     op_s     = 0x5b,
479     op1_sy   = 0xe3,   op2_sy   = 0x5b,
480     op1_sg   = 0xe3,   op2_sg   = 0x09,
481     op_nr    = 0x14,
482     op_ngr   = 0xb980,
483     op_la    = 0x41,
484     op1_lay  = 0xe3,   op2_lay  = 0x71,
485     op1_larl = 0xc0,   op2_larl = 0x00,
486     op_basr  = 0x0d,
487     op_bas   = 0x4d,
488     op_bcr   = 0x07,
489     op_bc    = 0x0d,
490     op1_bras = 0xa7,   op2_bras = 0x05,
491     op1_brasl= 0xc0,   op2_brasl= 0x05,
492     op1_brc  = 0xa7,   op2_brc  = 0x04,
493     op1_brcl = 0xc0,   op2_brcl = 0x04,
494   };
495
496
497 /* Read a single instruction from address AT.  */
498
499 #define S390_MAX_INSTR_SIZE 6
500 static int
501 s390_readinstruction (bfd_byte instr[], CORE_ADDR at)
502 {
503   static int s390_instrlen[] = { 2, 4, 4, 6 };
504   int instrlen;
505
506   if (target_read_memory (at, &instr[0], 2))
507     return -1;
508   instrlen = s390_instrlen[instr[0] >> 6];
509   if (instrlen > 2)
510     {
511       if (target_read_memory (at + 2, &instr[2], instrlen - 2))
512         return -1;
513     }
514   return instrlen;
515 }
516
517
518 /* The functions below are for recognizing and decoding S/390
519    instructions of various formats.  Each of them checks whether INSN
520    is an instruction of the given format, with the specified opcodes.
521    If it is, it sets the remaining arguments to the values of the
522    instruction's fields, and returns a non-zero value; otherwise, it
523    returns zero.
524
525    These functions' arguments appear in the order they appear in the
526    instruction, not in the machine-language form.  So, opcodes always
527    come first, even though they're sometimes scattered around the
528    instructions.  And displacements appear before base and extension
529    registers, as they do in the assembly syntax, not at the end, as
530    they do in the machine language.  */
531 static int
532 is_ri (bfd_byte *insn, int op1, int op2, unsigned int *r1, int *i2)
533 {
534   if (insn[0] == op1 && (insn[1] & 0xf) == op2)
535     {
536       *r1 = (insn[1] >> 4) & 0xf;
537       /* i2 is a 16-bit signed quantity.  */
538       *i2 = (((insn[2] << 8) | insn[3]) ^ 0x8000) - 0x8000;
539       return 1;
540     }
541   else
542     return 0;
543 }
544
545
546 static int
547 is_ril (bfd_byte *insn, int op1, int op2,
548         unsigned int *r1, int *i2)
549 {
550   if (insn[0] == op1 && (insn[1] & 0xf) == op2)
551     {
552       *r1 = (insn[1] >> 4) & 0xf;
553       /* i2 is a signed quantity.  If the host 'int' is 32 bits long,
554          no sign extension is necessary, but we don't want to assume
555          that.  */
556       *i2 = (((insn[2] << 24)
557               | (insn[3] << 16)
558               | (insn[4] << 8)
559               | (insn[5])) ^ 0x80000000) - 0x80000000;
560       return 1;
561     }
562   else
563     return 0;
564 }
565
566
567 static int
568 is_rr (bfd_byte *insn, int op, unsigned int *r1, unsigned int *r2)
569 {
570   if (insn[0] == op)
571     {
572       *r1 = (insn[1] >> 4) & 0xf;
573       *r2 = insn[1] & 0xf;
574       return 1;
575     }
576   else
577     return 0;
578 }
579
580
581 static int
582 is_rre (bfd_byte *insn, int op, unsigned int *r1, unsigned int *r2)
583 {
584   if (((insn[0] << 8) | insn[1]) == op)
585     {
586       /* Yes, insn[3].  insn[2] is unused in RRE format.  */
587       *r1 = (insn[3] >> 4) & 0xf;
588       *r2 = insn[3] & 0xf;
589       return 1;
590     }
591   else
592     return 0;
593 }
594
595
596 static int
597 is_rs (bfd_byte *insn, int op,
598        unsigned int *r1, unsigned int *r3, unsigned int *d2, unsigned int *b2)
599 {
600   if (insn[0] == op)
601     {
602       *r1 = (insn[1] >> 4) & 0xf;
603       *r3 = insn[1] & 0xf;
604       *b2 = (insn[2] >> 4) & 0xf;
605       *d2 = ((insn[2] & 0xf) << 8) | insn[3];
606       return 1;
607     }
608   else
609     return 0;
610 }
611
612
613 static int
614 is_rsy (bfd_byte *insn, int op1, int op2,
615         unsigned int *r1, unsigned int *r3, unsigned int *d2, unsigned int *b2)
616 {
617   if (insn[0] == op1
618       && insn[5] == op2)
619     {
620       *r1 = (insn[1] >> 4) & 0xf;
621       *r3 = insn[1] & 0xf;
622       *b2 = (insn[2] >> 4) & 0xf;
623       /* The 'long displacement' is a 20-bit signed integer.  */
624       *d2 = ((((insn[2] & 0xf) << 8) | insn[3] | (insn[4] << 12)) 
625                 ^ 0x80000) - 0x80000;
626       return 1;
627     }
628   else
629     return 0;
630 }
631
632
633 static int
634 is_rx (bfd_byte *insn, int op,
635        unsigned int *r1, unsigned int *d2, unsigned int *x2, unsigned int *b2)
636 {
637   if (insn[0] == op)
638     {
639       *r1 = (insn[1] >> 4) & 0xf;
640       *x2 = insn[1] & 0xf;
641       *b2 = (insn[2] >> 4) & 0xf;
642       *d2 = ((insn[2] & 0xf) << 8) | insn[3];
643       return 1;
644     }
645   else
646     return 0;
647 }
648
649
650 static int
651 is_rxy (bfd_byte *insn, int op1, int op2,
652         unsigned int *r1, unsigned int *d2, unsigned int *x2, unsigned int *b2)
653 {
654   if (insn[0] == op1
655       && insn[5] == op2)
656     {
657       *r1 = (insn[1] >> 4) & 0xf;
658       *x2 = insn[1] & 0xf;
659       *b2 = (insn[2] >> 4) & 0xf;
660       /* The 'long displacement' is a 20-bit signed integer.  */
661       *d2 = ((((insn[2] & 0xf) << 8) | insn[3] | (insn[4] << 12)) 
662                 ^ 0x80000) - 0x80000;
663       return 1;
664     }
665   else
666     return 0;
667 }
668
669
670 /* Prologue analysis.  */
671
672 #define S390_NUM_GPRS 16
673 #define S390_NUM_FPRS 16
674
675 struct s390_prologue_data {
676
677   /* The stack.  */
678   struct pv_area *stack;
679
680   /* The size of a GPR or FPR.  */
681   int gpr_size;
682   int fpr_size;
683
684   /* The general-purpose registers.  */
685   pv_t gpr[S390_NUM_GPRS];
686
687   /* The floating-point registers.  */
688   pv_t fpr[S390_NUM_FPRS];
689
690   /* The offset relative to the CFA where the incoming GPR N was saved
691      by the function prologue.  0 if not saved or unknown.  */
692   int gpr_slot[S390_NUM_GPRS];
693
694   /* Likewise for FPRs.  */
695   int fpr_slot[S390_NUM_FPRS];
696
697   /* Nonzero if the backchain was saved.  This is assumed to be the
698      case when the incoming SP is saved at the current SP location.  */
699   int back_chain_saved_p;
700 };
701
702 /* Return the effective address for an X-style instruction, like:
703
704         L R1, D2(X2, B2)
705
706    Here, X2 and B2 are registers, and D2 is a signed 20-bit
707    constant; the effective address is the sum of all three.  If either
708    X2 or B2 are zero, then it doesn't contribute to the sum --- this
709    means that r0 can't be used as either X2 or B2.  */
710 static pv_t
711 s390_addr (struct s390_prologue_data *data,
712            int d2, unsigned int x2, unsigned int b2)
713 {
714   pv_t result;
715
716   result = pv_constant (d2);
717   if (x2)
718     result = pv_add (result, data->gpr[x2]);
719   if (b2)
720     result = pv_add (result, data->gpr[b2]);
721
722   return result;
723 }
724
725 /* Do a SIZE-byte store of VALUE to D2(X2,B2).  */
726 static void
727 s390_store (struct s390_prologue_data *data,
728             int d2, unsigned int x2, unsigned int b2, CORE_ADDR size,
729             pv_t value)
730 {
731   pv_t addr = s390_addr (data, d2, x2, b2);
732   pv_t offset;
733
734   /* Check whether we are storing the backchain.  */
735   offset = pv_subtract (data->gpr[S390_SP_REGNUM - S390_R0_REGNUM], addr);
736
737   if (pv_is_constant (offset) && offset.k == 0)
738     if (size == data->gpr_size
739         && pv_is_register_k (value, S390_SP_REGNUM, 0))
740       {
741         data->back_chain_saved_p = 1;
742         return;
743       }
744
745
746   /* Check whether we are storing a register into the stack.  */
747   if (!pv_area_store_would_trash (data->stack, addr))
748     pv_area_store (data->stack, addr, size, value);
749
750
751   /* Note: If this is some store we cannot identify, you might think we
752      should forget our cached values, as any of those might have been hit.
753
754      However, we make the assumption that the register save areas are only
755      ever stored to once in any given function, and we do recognize these
756      stores.  Thus every store we cannot recognize does not hit our data.  */
757 }
758
759 /* Do a SIZE-byte load from D2(X2,B2).  */
760 static pv_t
761 s390_load (struct s390_prologue_data *data,
762            int d2, unsigned int x2, unsigned int b2, CORE_ADDR size)
763            
764 {
765   pv_t addr = s390_addr (data, d2, x2, b2);
766   pv_t offset;
767
768   /* If it's a load from an in-line constant pool, then we can
769      simulate that, under the assumption that the code isn't
770      going to change between the time the processor actually
771      executed it creating the current frame, and the time when
772      we're analyzing the code to unwind past that frame.  */
773   if (pv_is_constant (addr))
774     {
775       struct section_table *secp;
776       secp = target_section_by_addr (&current_target, addr.k);
777       if (secp != NULL
778           && (bfd_get_section_flags (secp->bfd, secp->the_bfd_section)
779               & SEC_READONLY))
780         return pv_constant (read_memory_integer (addr.k, size));
781     }
782
783   /* Check whether we are accessing one of our save slots.  */
784   return pv_area_fetch (data->stack, addr, size);
785 }
786
787 /* Function for finding saved registers in a 'struct pv_area'; we pass
788    this to pv_area_scan.
789
790    If VALUE is a saved register, ADDR says it was saved at a constant
791    offset from the frame base, and SIZE indicates that the whole
792    register was saved, record its offset in the reg_offset table in
793    PROLOGUE_UNTYPED.  */
794 static void
795 s390_check_for_saved (void *data_untyped, pv_t addr, CORE_ADDR size, pv_t value)
796 {
797   struct s390_prologue_data *data = data_untyped;
798   int i, offset;
799
800   if (!pv_is_register (addr, S390_SP_REGNUM))
801     return;
802
803   offset = 16 * data->gpr_size + 32 - addr.k;
804
805   /* If we are storing the original value of a register, we want to
806      record the CFA offset.  If the same register is stored multiple
807      times, the stack slot with the highest address counts.  */
808  
809   for (i = 0; i < S390_NUM_GPRS; i++)
810     if (size == data->gpr_size
811         && pv_is_register_k (value, S390_R0_REGNUM + i, 0))
812       if (data->gpr_slot[i] == 0
813           || data->gpr_slot[i] > offset)
814         {
815           data->gpr_slot[i] = offset;
816           return;
817         }
818
819   for (i = 0; i < S390_NUM_FPRS; i++)
820     if (size == data->fpr_size
821         && pv_is_register_k (value, S390_F0_REGNUM + i, 0))
822       if (data->fpr_slot[i] == 0
823           || data->fpr_slot[i] > offset)
824         {
825           data->fpr_slot[i] = offset;
826           return;
827         }
828 }
829
830 /* Analyze the prologue of the function starting at START_PC,
831    continuing at most until CURRENT_PC.  Initialize DATA to
832    hold all information we find out about the state of the registers
833    and stack slots.  Return the address of the instruction after
834    the last one that changed the SP, FP, or back chain; or zero
835    on error.  */
836 static CORE_ADDR
837 s390_analyze_prologue (struct gdbarch *gdbarch,
838                        CORE_ADDR start_pc,
839                        CORE_ADDR current_pc,
840                        struct s390_prologue_data *data)
841 {
842   int word_size = gdbarch_ptr_bit (gdbarch) / 8;
843
844   /* Our return value:
845      The address of the instruction after the last one that changed
846      the SP, FP, or back chain;  zero if we got an error trying to 
847      read memory.  */
848   CORE_ADDR result = start_pc;
849
850   /* The current PC for our abstract interpretation.  */
851   CORE_ADDR pc;
852
853   /* The address of the next instruction after that.  */
854   CORE_ADDR next_pc;
855   
856   /* Set up everything's initial value.  */
857   {
858     int i;
859
860     data->stack = make_pv_area (S390_SP_REGNUM);
861
862     /* For the purpose of prologue tracking, we consider the GPR size to
863        be equal to the ABI word size, even if it is actually larger
864        (i.e. when running a 32-bit binary under a 64-bit kernel).  */
865     data->gpr_size = word_size;
866     data->fpr_size = 8;
867
868     for (i = 0; i < S390_NUM_GPRS; i++)
869       data->gpr[i] = pv_register (S390_R0_REGNUM + i, 0);
870
871     for (i = 0; i < S390_NUM_FPRS; i++)
872       data->fpr[i] = pv_register (S390_F0_REGNUM + i, 0);
873
874     for (i = 0; i < S390_NUM_GPRS; i++)
875       data->gpr_slot[i]  = 0;
876
877     for (i = 0; i < S390_NUM_FPRS; i++)
878       data->fpr_slot[i]  = 0;
879
880     data->back_chain_saved_p = 0;
881   }
882
883   /* Start interpreting instructions, until we hit the frame's
884      current PC or the first branch instruction.  */
885   for (pc = start_pc; pc > 0 && pc < current_pc; pc = next_pc)
886     {
887       bfd_byte insn[S390_MAX_INSTR_SIZE];
888       int insn_len = s390_readinstruction (insn, pc);
889
890       bfd_byte dummy[S390_MAX_INSTR_SIZE] = { 0 };
891       bfd_byte *insn32 = word_size == 4 ? insn : dummy;
892       bfd_byte *insn64 = word_size == 8 ? insn : dummy;
893
894       /* Fields for various kinds of instructions.  */
895       unsigned int b2, r1, r2, x2, r3;
896       int i2, d2;
897
898       /* The values of SP and FP before this instruction,
899          for detecting instructions that change them.  */
900       pv_t pre_insn_sp, pre_insn_fp;
901       /* Likewise for the flag whether the back chain was saved.  */
902       int pre_insn_back_chain_saved_p;
903
904       /* If we got an error trying to read the instruction, report it.  */
905       if (insn_len < 0)
906         {
907           result = 0;
908           break;
909         }
910
911       next_pc = pc + insn_len;
912
913       pre_insn_sp = data->gpr[S390_SP_REGNUM - S390_R0_REGNUM];
914       pre_insn_fp = data->gpr[S390_FRAME_REGNUM - S390_R0_REGNUM];
915       pre_insn_back_chain_saved_p = data->back_chain_saved_p;
916
917
918       /* LHI r1, i2 --- load halfword immediate.  */
919       /* LGHI r1, i2 --- load halfword immediate (64-bit version).  */
920       /* LGFI r1, i2 --- load fullword immediate.  */
921       if (is_ri (insn32, op1_lhi, op2_lhi, &r1, &i2)
922           || is_ri (insn64, op1_lghi, op2_lghi, &r1, &i2)
923           || is_ril (insn, op1_lgfi, op2_lgfi, &r1, &i2))
924         data->gpr[r1] = pv_constant (i2);
925
926       /* LR r1, r2 --- load from register.  */
927       /* LGR r1, r2 --- load from register (64-bit version).  */
928       else if (is_rr (insn32, op_lr, &r1, &r2)
929                || is_rre (insn64, op_lgr, &r1, &r2))
930         data->gpr[r1] = data->gpr[r2];
931
932       /* L r1, d2(x2, b2) --- load.  */
933       /* LY r1, d2(x2, b2) --- load (long-displacement version).  */
934       /* LG r1, d2(x2, b2) --- load (64-bit version).  */
935       else if (is_rx (insn32, op_l, &r1, &d2, &x2, &b2)
936                || is_rxy (insn32, op1_ly, op2_ly, &r1, &d2, &x2, &b2)
937                || is_rxy (insn64, op1_lg, op2_lg, &r1, &d2, &x2, &b2))
938         data->gpr[r1] = s390_load (data, d2, x2, b2, data->gpr_size);
939
940       /* ST r1, d2(x2, b2) --- store.  */
941       /* STY r1, d2(x2, b2) --- store (long-displacement version).  */
942       /* STG r1, d2(x2, b2) --- store (64-bit version).  */
943       else if (is_rx (insn32, op_st, &r1, &d2, &x2, &b2)
944                || is_rxy (insn32, op1_sty, op2_sty, &r1, &d2, &x2, &b2)
945                || is_rxy (insn64, op1_stg, op2_stg, &r1, &d2, &x2, &b2))
946         s390_store (data, d2, x2, b2, data->gpr_size, data->gpr[r1]);
947
948       /* STD r1, d2(x2,b2) --- store floating-point register.  */
949       else if (is_rx (insn, op_std, &r1, &d2, &x2, &b2))
950         s390_store (data, d2, x2, b2, data->fpr_size, data->fpr[r1]);
951
952       /* STM r1, r3, d2(b2) --- store multiple.  */
953       /* STMY r1, r3, d2(b2) --- store multiple (long-displacement version).  */
954       /* STMG r1, r3, d2(b2) --- store multiple (64-bit version).  */
955       else if (is_rs (insn32, op_stm, &r1, &r3, &d2, &b2)
956                || is_rsy (insn32, op1_stmy, op2_stmy, &r1, &r3, &d2, &b2)
957                || is_rsy (insn64, op1_stmg, op2_stmg, &r1, &r3, &d2, &b2))
958         {
959           for (; r1 <= r3; r1++, d2 += data->gpr_size)
960             s390_store (data, d2, 0, b2, data->gpr_size, data->gpr[r1]);
961         }
962
963       /* AHI r1, i2 --- add halfword immediate.  */
964       /* AGHI r1, i2 --- add halfword immediate (64-bit version).  */
965       /* AFI r1, i2 --- add fullword immediate.  */
966       /* AGFI r1, i2 --- add fullword immediate (64-bit version).  */
967       else if (is_ri (insn32, op1_ahi, op2_ahi, &r1, &i2)
968                || is_ri (insn64, op1_aghi, op2_aghi, &r1, &i2)
969                || is_ril (insn32, op1_afi, op2_afi, &r1, &i2)
970                || is_ril (insn64, op1_agfi, op2_agfi, &r1, &i2))
971         data->gpr[r1] = pv_add_constant (data->gpr[r1], i2);
972
973       /* ALFI r1, i2 --- add logical immediate.  */
974       /* ALGFI r1, i2 --- add logical immediate (64-bit version).  */
975       else if (is_ril (insn32, op1_alfi, op2_alfi, &r1, &i2)
976                || is_ril (insn64, op1_algfi, op2_algfi, &r1, &i2))
977         data->gpr[r1] = pv_add_constant (data->gpr[r1],
978                                          (CORE_ADDR)i2 & 0xffffffff);
979
980       /* AR r1, r2 -- add register.  */
981       /* AGR r1, r2 -- add register (64-bit version).  */
982       else if (is_rr (insn32, op_ar, &r1, &r2)
983                || is_rre (insn64, op_agr, &r1, &r2))
984         data->gpr[r1] = pv_add (data->gpr[r1], data->gpr[r2]);
985
986       /* A r1, d2(x2, b2) -- add.  */
987       /* AY r1, d2(x2, b2) -- add (long-displacement version).  */
988       /* AG r1, d2(x2, b2) -- add (64-bit version).  */
989       else if (is_rx (insn32, op_a, &r1, &d2, &x2, &b2)
990                || is_rxy (insn32, op1_ay, op2_ay, &r1, &d2, &x2, &b2)
991                || is_rxy (insn64, op1_ag, op2_ag, &r1, &d2, &x2, &b2))
992         data->gpr[r1] = pv_add (data->gpr[r1],
993                                 s390_load (data, d2, x2, b2, data->gpr_size));
994
995       /* SLFI r1, i2 --- subtract logical immediate.  */
996       /* SLGFI r1, i2 --- subtract logical immediate (64-bit version).  */
997       else if (is_ril (insn32, op1_slfi, op2_slfi, &r1, &i2)
998                || is_ril (insn64, op1_slgfi, op2_slgfi, &r1, &i2))
999         data->gpr[r1] = pv_add_constant (data->gpr[r1],
1000                                          -((CORE_ADDR)i2 & 0xffffffff));
1001
1002       /* SR r1, r2 -- subtract register.  */
1003       /* SGR r1, r2 -- subtract register (64-bit version).  */
1004       else if (is_rr (insn32, op_sr, &r1, &r2)
1005                || is_rre (insn64, op_sgr, &r1, &r2))
1006         data->gpr[r1] = pv_subtract (data->gpr[r1], data->gpr[r2]);
1007
1008       /* S r1, d2(x2, b2) -- subtract.  */
1009       /* SY r1, d2(x2, b2) -- subtract (long-displacement version).  */
1010       /* SG r1, d2(x2, b2) -- subtract (64-bit version).  */
1011       else if (is_rx (insn32, op_s, &r1, &d2, &x2, &b2)
1012                || is_rxy (insn32, op1_sy, op2_sy, &r1, &d2, &x2, &b2)
1013                || is_rxy (insn64, op1_sg, op2_sg, &r1, &d2, &x2, &b2))
1014         data->gpr[r1] = pv_subtract (data->gpr[r1],
1015                                 s390_load (data, d2, x2, b2, data->gpr_size));
1016
1017       /* LA r1, d2(x2, b2) --- load address.  */
1018       /* LAY r1, d2(x2, b2) --- load address (long-displacement version).  */
1019       else if (is_rx (insn, op_la, &r1, &d2, &x2, &b2)
1020                || is_rxy (insn, op1_lay, op2_lay, &r1, &d2, &x2, &b2))
1021         data->gpr[r1] = s390_addr (data, d2, x2, b2);
1022
1023       /* LARL r1, i2 --- load address relative long.  */
1024       else if (is_ril (insn, op1_larl, op2_larl, &r1, &i2))
1025         data->gpr[r1] = pv_constant (pc + i2 * 2);
1026
1027       /* BASR r1, 0 --- branch and save.
1028          Since r2 is zero, this saves the PC in r1, but doesn't branch.  */
1029       else if (is_rr (insn, op_basr, &r1, &r2)
1030                && r2 == 0)
1031         data->gpr[r1] = pv_constant (next_pc);
1032
1033       /* BRAS r1, i2 --- branch relative and save.  */
1034       else if (is_ri (insn, op1_bras, op2_bras, &r1, &i2))
1035         {
1036           data->gpr[r1] = pv_constant (next_pc);
1037           next_pc = pc + i2 * 2;
1038
1039           /* We'd better not interpret any backward branches.  We'll
1040              never terminate.  */
1041           if (next_pc <= pc)
1042             break;
1043         }
1044
1045       /* Terminate search when hitting any other branch instruction.  */
1046       else if (is_rr (insn, op_basr, &r1, &r2)
1047                || is_rx (insn, op_bas, &r1, &d2, &x2, &b2)
1048                || is_rr (insn, op_bcr, &r1, &r2)
1049                || is_rx (insn, op_bc, &r1, &d2, &x2, &b2)
1050                || is_ri (insn, op1_brc, op2_brc, &r1, &i2)
1051                || is_ril (insn, op1_brcl, op2_brcl, &r1, &i2)
1052                || is_ril (insn, op1_brasl, op2_brasl, &r2, &i2))
1053         break;
1054
1055       else
1056         /* An instruction we don't know how to simulate.  The only
1057            safe thing to do would be to set every value we're tracking
1058            to 'unknown'.  Instead, we'll be optimistic: we assume that
1059            we *can* interpret every instruction that the compiler uses
1060            to manipulate any of the data we're interested in here --
1061            then we can just ignore anything else.  */
1062         ;
1063
1064       /* Record the address after the last instruction that changed
1065          the FP, SP, or backlink.  Ignore instructions that changed
1066          them back to their original values --- those are probably
1067          restore instructions.  (The back chain is never restored,
1068          just popped.)  */
1069       {
1070         pv_t sp = data->gpr[S390_SP_REGNUM - S390_R0_REGNUM];
1071         pv_t fp = data->gpr[S390_FRAME_REGNUM - S390_R0_REGNUM];
1072         
1073         if ((! pv_is_identical (pre_insn_sp, sp)
1074              && ! pv_is_register_k (sp, S390_SP_REGNUM, 0)
1075              && sp.kind != pvk_unknown)
1076             || (! pv_is_identical (pre_insn_fp, fp)
1077                 && ! pv_is_register_k (fp, S390_FRAME_REGNUM, 0)
1078                 && fp.kind != pvk_unknown)
1079             || pre_insn_back_chain_saved_p != data->back_chain_saved_p)
1080           result = next_pc;
1081       }
1082     }
1083
1084   /* Record where all the registers were saved.  */
1085   pv_area_scan (data->stack, s390_check_for_saved, data);
1086
1087   free_pv_area (data->stack);
1088   data->stack = NULL;
1089
1090   return result;
1091 }
1092
1093 /* Advance PC across any function entry prologue instructions to reach 
1094    some "real" code.  */
1095 static CORE_ADDR
1096 s390_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
1097 {
1098   struct s390_prologue_data data;
1099   CORE_ADDR skip_pc;
1100   skip_pc = s390_analyze_prologue (gdbarch, pc, (CORE_ADDR)-1, &data);
1101   return skip_pc ? skip_pc : pc;
1102 }
1103
1104 /* Return true if we are in the functin's epilogue, i.e. after the
1105    instruction that destroyed the function's stack frame.  */
1106 static int
1107 s390_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
1108 {
1109   int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1110
1111   /* In frameless functions, there's not frame to destroy and thus
1112      we don't care about the epilogue.
1113
1114      In functions with frame, the epilogue sequence is a pair of
1115      a LM-type instruction that restores (amongst others) the
1116      return register %r14 and the stack pointer %r15, followed
1117      by a branch 'br %r14' --or equivalent-- that effects the
1118      actual return.
1119
1120      In that situation, this function needs to return 'true' in
1121      exactly one case: when pc points to that branch instruction.
1122
1123      Thus we try to disassemble the one instructions immediately
1124      preceeding pc and check whether it is an LM-type instruction
1125      modifying the stack pointer.
1126
1127      Note that disassembling backwards is not reliable, so there
1128      is a slight chance of false positives here ...  */
1129
1130   bfd_byte insn[6];
1131   unsigned int r1, r3, b2;
1132   int d2;
1133
1134   if (word_size == 4
1135       && !target_read_memory (pc - 4, insn, 4)
1136       && is_rs (insn, op_lm, &r1, &r3, &d2, &b2)
1137       && r3 == S390_SP_REGNUM - S390_R0_REGNUM)
1138     return 1;
1139
1140   if (word_size == 4
1141       && !target_read_memory (pc - 6, insn, 6)
1142       && is_rsy (insn, op1_lmy, op2_lmy, &r1, &r3, &d2, &b2)
1143       && r3 == S390_SP_REGNUM - S390_R0_REGNUM)
1144     return 1;
1145
1146   if (word_size == 8
1147       && !target_read_memory (pc - 6, insn, 6)
1148       && is_rsy (insn, op1_lmg, op2_lmg, &r1, &r3, &d2, &b2)
1149       && r3 == S390_SP_REGNUM - S390_R0_REGNUM)
1150     return 1;
1151
1152   return 0;
1153 }
1154
1155
1156 /* Normal stack frames.  */
1157
1158 struct s390_unwind_cache {
1159
1160   CORE_ADDR func;
1161   CORE_ADDR frame_base;
1162   CORE_ADDR local_base;
1163
1164   struct trad_frame_saved_reg *saved_regs;
1165 };
1166
1167 static int
1168 s390_prologue_frame_unwind_cache (struct frame_info *this_frame,
1169                                   struct s390_unwind_cache *info)
1170 {
1171   struct gdbarch *gdbarch = get_frame_arch (this_frame);
1172   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1173   int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1174   struct s390_prologue_data data;
1175   pv_t *fp = &data.gpr[S390_FRAME_REGNUM - S390_R0_REGNUM];
1176   pv_t *sp = &data.gpr[S390_SP_REGNUM - S390_R0_REGNUM];
1177   int i;
1178   CORE_ADDR cfa;
1179   CORE_ADDR func;
1180   CORE_ADDR result;
1181   ULONGEST reg;
1182   CORE_ADDR prev_sp;
1183   int frame_pointer;
1184   int size;
1185
1186   /* Try to find the function start address.  If we can't find it, we don't
1187      bother searching for it -- with modern compilers this would be mostly
1188      pointless anyway.  Trust that we'll either have valid DWARF-2 CFI data
1189      or else a valid backchain ...  */
1190   func = get_frame_func (this_frame);
1191   if (!func)
1192     return 0;
1193
1194   /* Try to analyze the prologue.  */
1195   result = s390_analyze_prologue (gdbarch, func,
1196                                   get_frame_pc (this_frame), &data);
1197   if (!result)
1198     return 0;
1199
1200   /* If this was successful, we should have found the instruction that
1201      sets the stack pointer register to the previous value of the stack 
1202      pointer minus the frame size.  */
1203   if (!pv_is_register (*sp, S390_SP_REGNUM))
1204     return 0;
1205
1206   /* A frame size of zero at this point can mean either a real 
1207      frameless function, or else a failure to find the prologue.
1208      Perform some sanity checks to verify we really have a 
1209      frameless function.  */
1210   if (sp->k == 0)
1211     {
1212       /* If the next frame is a NORMAL_FRAME, this frame *cannot* have frame 
1213          size zero.  This is only possible if the next frame is a sentinel 
1214          frame, a dummy frame, or a signal trampoline frame.  */
1215       /* FIXME: cagney/2004-05-01: This sanity check shouldn't be
1216          needed, instead the code should simpliy rely on its
1217          analysis.  */
1218       if (get_next_frame (this_frame)
1219           && get_frame_type (get_next_frame (this_frame)) == NORMAL_FRAME)
1220         return 0;
1221
1222       /* If we really have a frameless function, %r14 must be valid
1223          -- in particular, it must point to a different function.  */
1224       reg = get_frame_register_unsigned (this_frame, S390_RETADDR_REGNUM);
1225       reg = gdbarch_addr_bits_remove (gdbarch, reg) - 1;
1226       if (get_pc_function_start (reg) == func)
1227         {
1228           /* However, there is one case where it *is* valid for %r14
1229              to point to the same function -- if this is a recursive
1230              call, and we have stopped in the prologue *before* the
1231              stack frame was allocated.
1232
1233              Recognize this case by looking ahead a bit ...  */
1234
1235           struct s390_prologue_data data2;
1236           pv_t *sp = &data2.gpr[S390_SP_REGNUM - S390_R0_REGNUM];
1237
1238           if (!(s390_analyze_prologue (gdbarch, func, (CORE_ADDR)-1, &data2)
1239                 && pv_is_register (*sp, S390_SP_REGNUM)
1240                 && sp->k != 0))
1241             return 0;
1242         }
1243     }
1244
1245
1246   /* OK, we've found valid prologue data.  */
1247   size = -sp->k;
1248
1249   /* If the frame pointer originally also holds the same value
1250      as the stack pointer, we're probably using it.  If it holds
1251      some other value -- even a constant offset -- it is most
1252      likely used as temp register.  */
1253   if (pv_is_identical (*sp, *fp))
1254     frame_pointer = S390_FRAME_REGNUM;
1255   else
1256     frame_pointer = S390_SP_REGNUM;
1257
1258   /* If we've detected a function with stack frame, we'll still have to 
1259      treat it as frameless if we're currently within the function epilog 
1260      code at a point where the frame pointer has already been restored.  
1261      This can only happen in an innermost frame.  */
1262   /* FIXME: cagney/2004-05-01: This sanity check shouldn't be needed,
1263      instead the code should simpliy rely on its analysis.  */
1264   if (size > 0
1265       && (!get_next_frame (this_frame)
1266           || get_frame_type (get_next_frame (this_frame)) != NORMAL_FRAME))
1267     {
1268       /* See the comment in s390_in_function_epilogue_p on why this is
1269          not completely reliable ...  */
1270       if (s390_in_function_epilogue_p (gdbarch, get_frame_pc (this_frame)))
1271         {
1272           memset (&data, 0, sizeof (data));
1273           size = 0;
1274           frame_pointer = S390_SP_REGNUM;
1275         }
1276     }
1277
1278   /* Once we know the frame register and the frame size, we can unwind
1279      the current value of the frame register from the next frame, and
1280      add back the frame size to arrive that the previous frame's 
1281      stack pointer value.  */
1282   prev_sp = get_frame_register_unsigned (this_frame, frame_pointer) + size;
1283   cfa = prev_sp + 16*word_size + 32;
1284
1285   /* Record the addresses of all register spill slots the prologue parser
1286      has recognized.  Consider only registers defined as call-saved by the
1287      ABI; for call-clobbered registers the parser may have recognized
1288      spurious stores.  */
1289
1290   for (i = 6; i <= 15; i++)
1291     if (data.gpr_slot[i] != 0)
1292       info->saved_regs[S390_R0_REGNUM + i].addr = cfa - data.gpr_slot[i];
1293
1294   switch (tdep->abi)
1295     {
1296     case ABI_LINUX_S390:
1297       if (data.fpr_slot[4] != 0)
1298         info->saved_regs[S390_F4_REGNUM].addr = cfa - data.fpr_slot[4];
1299       if (data.fpr_slot[6] != 0)
1300         info->saved_regs[S390_F6_REGNUM].addr = cfa - data.fpr_slot[6];
1301       break;
1302
1303     case ABI_LINUX_ZSERIES:
1304       for (i = 8; i <= 15; i++)
1305         if (data.fpr_slot[i] != 0)
1306           info->saved_regs[S390_F0_REGNUM + i].addr = cfa - data.fpr_slot[i];
1307       break;
1308     }
1309
1310   /* Function return will set PC to %r14.  */
1311   info->saved_regs[S390_PC_REGNUM] = info->saved_regs[S390_RETADDR_REGNUM];
1312
1313   /* In frameless functions, we unwind simply by moving the return
1314      address to the PC.  However, if we actually stored to the
1315      save area, use that -- we might only think the function frameless
1316      because we're in the middle of the prologue ...  */
1317   if (size == 0
1318       && !trad_frame_addr_p (info->saved_regs, S390_PC_REGNUM))
1319     {
1320       info->saved_regs[S390_PC_REGNUM].realreg = S390_RETADDR_REGNUM;
1321     }
1322
1323   /* Another sanity check: unless this is a frameless function,
1324      we should have found spill slots for SP and PC.
1325      If not, we cannot unwind further -- this happens e.g. in
1326      libc's thread_start routine.  */
1327   if (size > 0)
1328     {
1329       if (!trad_frame_addr_p (info->saved_regs, S390_SP_REGNUM)
1330           || !trad_frame_addr_p (info->saved_regs, S390_PC_REGNUM))
1331         prev_sp = -1;
1332     }
1333
1334   /* We use the current value of the frame register as local_base,
1335      and the top of the register save area as frame_base.  */
1336   if (prev_sp != -1)
1337     {
1338       info->frame_base = prev_sp + 16*word_size + 32;
1339       info->local_base = prev_sp - size;
1340     }
1341
1342   info->func = func;
1343   return 1;
1344 }
1345
1346 static void
1347 s390_backchain_frame_unwind_cache (struct frame_info *this_frame,
1348                                    struct s390_unwind_cache *info)
1349 {
1350   struct gdbarch *gdbarch = get_frame_arch (this_frame);
1351   int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1352   CORE_ADDR backchain;
1353   ULONGEST reg;
1354   LONGEST sp;
1355
1356   /* Get the backchain.  */
1357   reg = get_frame_register_unsigned (this_frame, S390_SP_REGNUM);
1358   backchain = read_memory_unsigned_integer (reg, word_size);
1359
1360   /* A zero backchain terminates the frame chain.  As additional
1361      sanity check, let's verify that the spill slot for SP in the
1362      save area pointed to by the backchain in fact links back to
1363      the save area.  */
1364   if (backchain != 0
1365       && safe_read_memory_integer (backchain + 15*word_size, word_size, &sp)
1366       && (CORE_ADDR)sp == backchain)
1367     {
1368       /* We don't know which registers were saved, but it will have
1369          to be at least %r14 and %r15.  This will allow us to continue
1370          unwinding, but other prev-frame registers may be incorrect ...  */
1371       info->saved_regs[S390_SP_REGNUM].addr = backchain + 15*word_size;
1372       info->saved_regs[S390_RETADDR_REGNUM].addr = backchain + 14*word_size;
1373
1374       /* Function return will set PC to %r14.  */
1375       info->saved_regs[S390_PC_REGNUM] = info->saved_regs[S390_RETADDR_REGNUM];
1376
1377       /* We use the current value of the frame register as local_base,
1378          and the top of the register save area as frame_base.  */
1379       info->frame_base = backchain + 16*word_size + 32;
1380       info->local_base = reg;
1381     }
1382
1383   info->func = get_frame_pc (this_frame);
1384 }
1385
1386 static struct s390_unwind_cache *
1387 s390_frame_unwind_cache (struct frame_info *this_frame,
1388                          void **this_prologue_cache)
1389 {
1390   struct s390_unwind_cache *info;
1391   if (*this_prologue_cache)
1392     return *this_prologue_cache;
1393
1394   info = FRAME_OBSTACK_ZALLOC (struct s390_unwind_cache);
1395   *this_prologue_cache = info;
1396   info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
1397   info->func = -1;
1398   info->frame_base = -1;
1399   info->local_base = -1;
1400
1401   /* Try to use prologue analysis to fill the unwind cache.
1402      If this fails, fall back to reading the stack backchain.  */
1403   if (!s390_prologue_frame_unwind_cache (this_frame, info))
1404     s390_backchain_frame_unwind_cache (this_frame, info);
1405
1406   return info;
1407 }
1408
1409 static void
1410 s390_frame_this_id (struct frame_info *this_frame,
1411                     void **this_prologue_cache,
1412                     struct frame_id *this_id)
1413 {
1414   struct s390_unwind_cache *info
1415     = s390_frame_unwind_cache (this_frame, this_prologue_cache);
1416
1417   if (info->frame_base == -1)
1418     return;
1419
1420   *this_id = frame_id_build (info->frame_base, info->func);
1421 }
1422
1423 static struct value *
1424 s390_frame_prev_register (struct frame_info *this_frame,
1425                           void **this_prologue_cache, int regnum)
1426 {
1427   struct s390_unwind_cache *info
1428     = s390_frame_unwind_cache (this_frame, this_prologue_cache);
1429   return trad_frame_get_prev_register (this_frame, info->saved_regs, regnum);
1430 }
1431
1432 static const struct frame_unwind s390_frame_unwind = {
1433   NORMAL_FRAME,
1434   s390_frame_this_id,
1435   s390_frame_prev_register,
1436   NULL,
1437   default_frame_sniffer
1438 };
1439
1440
1441 /* Code stubs and their stack frames.  For things like PLTs and NULL
1442    function calls (where there is no true frame and the return address
1443    is in the RETADDR register).  */
1444
1445 struct s390_stub_unwind_cache
1446 {
1447   CORE_ADDR frame_base;
1448   struct trad_frame_saved_reg *saved_regs;
1449 };
1450
1451 static struct s390_stub_unwind_cache *
1452 s390_stub_frame_unwind_cache (struct frame_info *this_frame,
1453                               void **this_prologue_cache)
1454 {
1455   struct gdbarch *gdbarch = get_frame_arch (this_frame);
1456   int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1457   struct s390_stub_unwind_cache *info;
1458   ULONGEST reg;
1459
1460   if (*this_prologue_cache)
1461     return *this_prologue_cache;
1462
1463   info = FRAME_OBSTACK_ZALLOC (struct s390_stub_unwind_cache);
1464   *this_prologue_cache = info;
1465   info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
1466
1467   /* The return address is in register %r14.  */
1468   info->saved_regs[S390_PC_REGNUM].realreg = S390_RETADDR_REGNUM;
1469
1470   /* Retrieve stack pointer and determine our frame base.  */
1471   reg = get_frame_register_unsigned (this_frame, S390_SP_REGNUM);
1472   info->frame_base = reg + 16*word_size + 32;
1473
1474   return info;
1475 }
1476
1477 static void
1478 s390_stub_frame_this_id (struct frame_info *this_frame,
1479                          void **this_prologue_cache,
1480                          struct frame_id *this_id)
1481 {
1482   struct s390_stub_unwind_cache *info
1483     = s390_stub_frame_unwind_cache (this_frame, this_prologue_cache);
1484   *this_id = frame_id_build (info->frame_base, get_frame_pc (this_frame));
1485 }
1486
1487 static struct value *
1488 s390_stub_frame_prev_register (struct frame_info *this_frame,
1489                                void **this_prologue_cache, int regnum)
1490 {
1491   struct s390_stub_unwind_cache *info
1492     = s390_stub_frame_unwind_cache (this_frame, this_prologue_cache);
1493   return trad_frame_get_prev_register (this_frame, info->saved_regs, regnum);
1494 }
1495
1496 static int
1497 s390_stub_frame_sniffer (const struct frame_unwind *self,
1498                          struct frame_info *this_frame,
1499                          void **this_prologue_cache)
1500 {
1501   CORE_ADDR addr_in_block;
1502   bfd_byte insn[S390_MAX_INSTR_SIZE];
1503
1504   /* If the current PC points to non-readable memory, we assume we
1505      have trapped due to an invalid function pointer call.  We handle
1506      the non-existing current function like a PLT stub.  */
1507   addr_in_block = get_frame_address_in_block (this_frame);
1508   if (in_plt_section (addr_in_block, NULL)
1509       || s390_readinstruction (insn, get_frame_pc (this_frame)) < 0)
1510     return 1;
1511   return 0;
1512 }
1513
1514 static const struct frame_unwind s390_stub_frame_unwind = {
1515   NORMAL_FRAME,
1516   s390_stub_frame_this_id,
1517   s390_stub_frame_prev_register,
1518   NULL,
1519   s390_stub_frame_sniffer
1520 };
1521
1522
1523 /* Signal trampoline stack frames.  */
1524
1525 struct s390_sigtramp_unwind_cache {
1526   CORE_ADDR frame_base;
1527   struct trad_frame_saved_reg *saved_regs;
1528 };
1529
1530 static struct s390_sigtramp_unwind_cache *
1531 s390_sigtramp_frame_unwind_cache (struct frame_info *this_frame,
1532                                   void **this_prologue_cache)
1533 {
1534   struct gdbarch *gdbarch = get_frame_arch (this_frame);
1535   int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1536   struct s390_sigtramp_unwind_cache *info;
1537   ULONGEST this_sp, prev_sp;
1538   CORE_ADDR next_ra, next_cfa, sigreg_ptr;
1539   int i;
1540
1541   if (*this_prologue_cache)
1542     return *this_prologue_cache;
1543
1544   info = FRAME_OBSTACK_ZALLOC (struct s390_sigtramp_unwind_cache);
1545   *this_prologue_cache = info;
1546   info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
1547
1548   this_sp = get_frame_register_unsigned (this_frame, S390_SP_REGNUM);
1549   next_ra = get_frame_pc (this_frame);
1550   next_cfa = this_sp + 16*word_size + 32;
1551
1552   /* New-style RT frame:
1553         retcode + alignment (8 bytes)
1554         siginfo (128 bytes)
1555         ucontext (contains sigregs at offset 5 words)  */
1556   if (next_ra == next_cfa)
1557     {
1558       sigreg_ptr = next_cfa + 8 + 128 + align_up (5*word_size, 8);
1559     }
1560
1561   /* Old-style RT frame and all non-RT frames:
1562         old signal mask (8 bytes)
1563         pointer to sigregs  */
1564   else
1565     {
1566       sigreg_ptr = read_memory_unsigned_integer (next_cfa + 8, word_size);
1567     }
1568
1569   /* The sigregs structure looks like this:
1570             long   psw_mask;
1571             long   psw_addr;
1572             long   gprs[16];
1573             int    acrs[16];
1574             int    fpc;
1575             int    __pad;
1576             double fprs[16];  */
1577
1578   /* Let's ignore the PSW mask, it will not be restored anyway.  */
1579   sigreg_ptr += word_size;
1580
1581   /* Next comes the PSW address.  */
1582   info->saved_regs[S390_PC_REGNUM].addr = sigreg_ptr;
1583   sigreg_ptr += word_size;
1584
1585   /* Then the GPRs.  */
1586   for (i = 0; i < 16; i++)
1587     {
1588       info->saved_regs[S390_R0_REGNUM + i].addr = sigreg_ptr;
1589       sigreg_ptr += word_size;
1590     }
1591
1592   /* Then the ACRs.  */
1593   for (i = 0; i < 16; i++)
1594     {
1595       info->saved_regs[S390_A0_REGNUM + i].addr = sigreg_ptr;
1596       sigreg_ptr += 4;
1597     }
1598
1599   /* The floating-point control word.  */
1600   info->saved_regs[S390_FPC_REGNUM].addr = sigreg_ptr;
1601   sigreg_ptr += 8;
1602
1603   /* And finally the FPRs.  */
1604   for (i = 0; i < 16; i++)
1605     {
1606       info->saved_regs[S390_F0_REGNUM + i].addr = sigreg_ptr;
1607       sigreg_ptr += 8;
1608     }
1609
1610   /* Restore the previous frame's SP.  */
1611   prev_sp = read_memory_unsigned_integer (
1612                         info->saved_regs[S390_SP_REGNUM].addr,
1613                         word_size);
1614
1615   /* Determine our frame base.  */
1616   info->frame_base = prev_sp + 16*word_size + 32;
1617
1618   return info;
1619 }
1620
1621 static void
1622 s390_sigtramp_frame_this_id (struct frame_info *this_frame,
1623                              void **this_prologue_cache,
1624                              struct frame_id *this_id)
1625 {
1626   struct s390_sigtramp_unwind_cache *info
1627     = s390_sigtramp_frame_unwind_cache (this_frame, this_prologue_cache);
1628   *this_id = frame_id_build (info->frame_base, get_frame_pc (this_frame));
1629 }
1630
1631 static struct value *
1632 s390_sigtramp_frame_prev_register (struct frame_info *this_frame,
1633                                    void **this_prologue_cache, int regnum)
1634 {
1635   struct s390_sigtramp_unwind_cache *info
1636     = s390_sigtramp_frame_unwind_cache (this_frame, this_prologue_cache);
1637   return trad_frame_get_prev_register (this_frame, info->saved_regs, regnum);
1638 }
1639
1640 static int
1641 s390_sigtramp_frame_sniffer (const struct frame_unwind *self,
1642                              struct frame_info *this_frame,
1643                              void **this_prologue_cache)
1644 {
1645   CORE_ADDR pc = get_frame_pc (this_frame);
1646   bfd_byte sigreturn[2];
1647
1648   if (target_read_memory (pc, sigreturn, 2))
1649     return 0;
1650
1651   if (sigreturn[0] != 0x0a /* svc */)
1652     return 0;
1653
1654   if (sigreturn[1] != 119 /* sigreturn */
1655       && sigreturn[1] != 173 /* rt_sigreturn */)
1656     return 0;
1657   
1658   return 1;
1659 }
1660
1661 static const struct frame_unwind s390_sigtramp_frame_unwind = {
1662   SIGTRAMP_FRAME,
1663   s390_sigtramp_frame_this_id,
1664   s390_sigtramp_frame_prev_register,
1665   NULL,
1666   s390_sigtramp_frame_sniffer
1667 };
1668
1669
1670 /* Frame base handling.  */
1671
1672 static CORE_ADDR
1673 s390_frame_base_address (struct frame_info *this_frame, void **this_cache)
1674 {
1675   struct s390_unwind_cache *info
1676     = s390_frame_unwind_cache (this_frame, this_cache);
1677   return info->frame_base;
1678 }
1679
1680 static CORE_ADDR
1681 s390_local_base_address (struct frame_info *this_frame, void **this_cache)
1682 {
1683   struct s390_unwind_cache *info
1684     = s390_frame_unwind_cache (this_frame, this_cache);
1685   return info->local_base;
1686 }
1687
1688 static const struct frame_base s390_frame_base = {
1689   &s390_frame_unwind,
1690   s390_frame_base_address,
1691   s390_local_base_address,
1692   s390_local_base_address
1693 };
1694
1695 static CORE_ADDR
1696 s390_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
1697 {
1698   ULONGEST pc;
1699   pc = frame_unwind_register_unsigned (next_frame, S390_PC_REGNUM);
1700   return gdbarch_addr_bits_remove (gdbarch, pc);
1701 }
1702
1703 static CORE_ADDR
1704 s390_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
1705 {
1706   ULONGEST sp;
1707   sp = frame_unwind_register_unsigned (next_frame, S390_SP_REGNUM);
1708   return gdbarch_addr_bits_remove (gdbarch, sp);
1709 }
1710
1711
1712 /* DWARF-2 frame support.  */
1713
1714 static void
1715 s390_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
1716                             struct dwarf2_frame_state_reg *reg,
1717                             struct frame_info *this_frame)
1718 {
1719   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1720
1721   switch (tdep->abi)
1722     {
1723     case ABI_LINUX_S390:
1724       /* Call-saved registers.  */
1725       if ((regnum >= S390_R6_REGNUM && regnum <= S390_R15_REGNUM)
1726           || regnum == S390_F4_REGNUM
1727           || regnum == S390_F6_REGNUM)
1728         reg->how = DWARF2_FRAME_REG_SAME_VALUE;
1729
1730       /* Call-clobbered registers.  */
1731       else if ((regnum >= S390_R0_REGNUM && regnum <= S390_R5_REGNUM)
1732                || (regnum >= S390_F0_REGNUM && regnum <= S390_F15_REGNUM
1733                    && regnum != S390_F4_REGNUM && regnum != S390_F6_REGNUM))
1734         reg->how = DWARF2_FRAME_REG_UNDEFINED;
1735
1736       /* The return address column.  */
1737       else if (regnum == S390_PC_REGNUM)
1738         reg->how = DWARF2_FRAME_REG_RA;
1739       break;
1740
1741     case ABI_LINUX_ZSERIES:
1742       /* Call-saved registers.  */
1743       if ((regnum >= S390_R6_REGNUM && regnum <= S390_R15_REGNUM)
1744           || (regnum >= S390_F8_REGNUM && regnum <= S390_F15_REGNUM))
1745         reg->how = DWARF2_FRAME_REG_SAME_VALUE;
1746
1747       /* Call-clobbered registers.  */
1748       else if ((regnum >= S390_R0_REGNUM && regnum <= S390_R5_REGNUM)
1749                || (regnum >= S390_F0_REGNUM && regnum <= S390_F7_REGNUM))
1750         reg->how = DWARF2_FRAME_REG_UNDEFINED;
1751
1752       /* The return address column.  */
1753       else if (regnum == S390_PC_REGNUM)
1754         reg->how = DWARF2_FRAME_REG_RA;
1755       break;
1756     }
1757 }
1758
1759
1760 /* Dummy function calls.  */
1761
1762 /* Return non-zero if TYPE is an integer-like type, zero otherwise.
1763    "Integer-like" types are those that should be passed the way
1764    integers are: integers, enums, ranges, characters, and booleans.  */
1765 static int
1766 is_integer_like (struct type *type)
1767 {
1768   enum type_code code = TYPE_CODE (type);
1769
1770   return (code == TYPE_CODE_INT
1771           || code == TYPE_CODE_ENUM
1772           || code == TYPE_CODE_RANGE
1773           || code == TYPE_CODE_CHAR
1774           || code == TYPE_CODE_BOOL);
1775 }
1776
1777 /* Return non-zero if TYPE is a pointer-like type, zero otherwise.
1778    "Pointer-like" types are those that should be passed the way
1779    pointers are: pointers and references.  */
1780 static int
1781 is_pointer_like (struct type *type)
1782 {
1783   enum type_code code = TYPE_CODE (type);
1784
1785   return (code == TYPE_CODE_PTR
1786           || code == TYPE_CODE_REF);
1787 }
1788
1789
1790 /* Return non-zero if TYPE is a `float singleton' or `double
1791    singleton', zero otherwise.
1792
1793    A `T singleton' is a struct type with one member, whose type is
1794    either T or a `T singleton'.  So, the following are all float
1795    singletons:
1796
1797    struct { float x };
1798    struct { struct { float x; } x; };
1799    struct { struct { struct { float x; } x; } x; };
1800
1801    ... and so on.
1802
1803    All such structures are passed as if they were floats or doubles,
1804    as the (revised) ABI says.  */
1805 static int
1806 is_float_singleton (struct type *type)
1807 {
1808   if (TYPE_CODE (type) == TYPE_CODE_STRUCT && TYPE_NFIELDS (type) == 1)
1809     {
1810       struct type *singleton_type = TYPE_FIELD_TYPE (type, 0);
1811       CHECK_TYPEDEF (singleton_type);
1812
1813       return (TYPE_CODE (singleton_type) == TYPE_CODE_FLT
1814               || TYPE_CODE (singleton_type) == TYPE_CODE_DECFLOAT
1815               || is_float_singleton (singleton_type));
1816     }
1817
1818   return 0;
1819 }
1820
1821
1822 /* Return non-zero if TYPE is a struct-like type, zero otherwise.
1823    "Struct-like" types are those that should be passed as structs are:
1824    structs and unions.
1825
1826    As an odd quirk, not mentioned in the ABI, GCC passes float and
1827    double singletons as if they were a plain float, double, etc.  (The
1828    corresponding union types are handled normally.)  So we exclude
1829    those types here.  *shrug* */
1830 static int
1831 is_struct_like (struct type *type)
1832 {
1833   enum type_code code = TYPE_CODE (type);
1834
1835   return (code == TYPE_CODE_UNION
1836           || (code == TYPE_CODE_STRUCT && ! is_float_singleton (type)));
1837 }
1838
1839
1840 /* Return non-zero if TYPE is a float-like type, zero otherwise.
1841    "Float-like" types are those that should be passed as
1842    floating-point values are.
1843
1844    You'd think this would just be floats, doubles, long doubles, etc.
1845    But as an odd quirk, not mentioned in the ABI, GCC passes float and
1846    double singletons as if they were a plain float, double, etc.  (The
1847    corresponding union types are handled normally.)  So we include
1848    those types here.  *shrug* */
1849 static int
1850 is_float_like (struct type *type)
1851 {
1852   return (TYPE_CODE (type) == TYPE_CODE_FLT
1853           || TYPE_CODE (type) == TYPE_CODE_DECFLOAT
1854           || is_float_singleton (type));
1855 }
1856
1857
1858 static int
1859 is_power_of_two (unsigned int n)
1860 {
1861   return ((n & (n - 1)) == 0);
1862 }
1863
1864 /* Return non-zero if TYPE should be passed as a pointer to a copy,
1865    zero otherwise.  */
1866 static int
1867 s390_function_arg_pass_by_reference (struct type *type)
1868 {
1869   unsigned length = TYPE_LENGTH (type);
1870   if (length > 8)
1871     return 1;
1872
1873   /* FIXME: All complex and vector types are also returned by reference.  */
1874   return is_struct_like (type) && !is_power_of_two (length);
1875 }
1876
1877 /* Return non-zero if TYPE should be passed in a float register
1878    if possible.  */
1879 static int
1880 s390_function_arg_float (struct type *type)
1881 {
1882   unsigned length = TYPE_LENGTH (type);
1883   if (length > 8)
1884     return 0;
1885
1886   return is_float_like (type);
1887 }
1888
1889 /* Return non-zero if TYPE should be passed in an integer register
1890    (or a pair of integer registers) if possible.  */
1891 static int
1892 s390_function_arg_integer (struct type *type)
1893 {
1894   unsigned length = TYPE_LENGTH (type);
1895   if (length > 8)
1896     return 0;
1897
1898    return is_integer_like (type)
1899           || is_pointer_like (type)
1900           || (is_struct_like (type) && is_power_of_two (length));
1901 }
1902
1903 /* Return ARG, a `SIMPLE_ARG', sign-extended or zero-extended to a full
1904    word as required for the ABI.  */
1905 static LONGEST
1906 extend_simple_arg (struct value *arg)
1907 {
1908   struct type *type = value_type (arg);
1909
1910   /* Even structs get passed in the least significant bits of the
1911      register / memory word.  It's not really right to extract them as
1912      an integer, but it does take care of the extension.  */
1913   if (TYPE_UNSIGNED (type))
1914     return extract_unsigned_integer (value_contents (arg),
1915                                      TYPE_LENGTH (type));
1916   else
1917     return extract_signed_integer (value_contents (arg),
1918                                    TYPE_LENGTH (type));
1919 }
1920
1921
1922 /* Return the alignment required by TYPE.  */
1923 static int
1924 alignment_of (struct type *type)
1925 {
1926   int alignment;
1927
1928   if (is_integer_like (type)
1929       || is_pointer_like (type)
1930       || TYPE_CODE (type) == TYPE_CODE_FLT
1931       || TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
1932     alignment = TYPE_LENGTH (type);
1933   else if (TYPE_CODE (type) == TYPE_CODE_STRUCT
1934            || TYPE_CODE (type) == TYPE_CODE_UNION)
1935     {
1936       int i;
1937
1938       alignment = 1;
1939       for (i = 0; i < TYPE_NFIELDS (type); i++)
1940         {
1941           int field_alignment = alignment_of (TYPE_FIELD_TYPE (type, i));
1942
1943           if (field_alignment > alignment)
1944             alignment = field_alignment;
1945         }
1946     }
1947   else
1948     alignment = 1;
1949
1950   /* Check that everything we ever return is a power of two.  Lots of
1951      code doesn't want to deal with aligning things to arbitrary
1952      boundaries.  */
1953   gdb_assert ((alignment & (alignment - 1)) == 0);
1954
1955   return alignment;
1956 }
1957
1958
1959 /* Put the actual parameter values pointed to by ARGS[0..NARGS-1] in
1960    place to be passed to a function, as specified by the "GNU/Linux
1961    for S/390 ELF Application Binary Interface Supplement".
1962
1963    SP is the current stack pointer.  We must put arguments, links,
1964    padding, etc. whereever they belong, and return the new stack
1965    pointer value.
1966    
1967    If STRUCT_RETURN is non-zero, then the function we're calling is
1968    going to return a structure by value; STRUCT_ADDR is the address of
1969    a block we've allocated for it on the stack.
1970
1971    Our caller has taken care of any type promotions needed to satisfy
1972    prototypes or the old K&R argument-passing rules.  */
1973 static CORE_ADDR
1974 s390_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
1975                       struct regcache *regcache, CORE_ADDR bp_addr,
1976                       int nargs, struct value **args, CORE_ADDR sp,
1977                       int struct_return, CORE_ADDR struct_addr)
1978 {
1979   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1980   int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1981   ULONGEST orig_sp;
1982   int i;
1983
1984   /* If the i'th argument is passed as a reference to a copy, then
1985      copy_addr[i] is the address of the copy we made.  */
1986   CORE_ADDR *copy_addr = alloca (nargs * sizeof (CORE_ADDR));
1987
1988   /* Build the reference-to-copy area.  */
1989   for (i = 0; i < nargs; i++)
1990     {
1991       struct value *arg = args[i];
1992       struct type *type = value_type (arg);
1993       unsigned length = TYPE_LENGTH (type);
1994
1995       if (s390_function_arg_pass_by_reference (type))
1996         {
1997           sp -= length;
1998           sp = align_down (sp, alignment_of (type));
1999           write_memory (sp, value_contents (arg), length);
2000           copy_addr[i] = sp;
2001         }
2002     }
2003
2004   /* Reserve space for the parameter area.  As a conservative
2005      simplification, we assume that everything will be passed on the
2006      stack.  Since every argument larger than 8 bytes will be 
2007      passed by reference, we use this simple upper bound.  */
2008   sp -= nargs * 8;
2009
2010   /* After all that, make sure it's still aligned on an eight-byte
2011      boundary.  */
2012   sp = align_down (sp, 8);
2013
2014   /* Finally, place the actual parameters, working from SP towards
2015      higher addresses.  The code above is supposed to reserve enough
2016      space for this.  */
2017   {
2018     int fr = 0;
2019     int gr = 2;
2020     CORE_ADDR starg = sp;
2021
2022     /* A struct is returned using general register 2.  */
2023     if (struct_return)
2024       {
2025         regcache_cooked_write_unsigned (regcache, S390_R0_REGNUM + gr,
2026                                         struct_addr);
2027         gr++;
2028       }
2029
2030     for (i = 0; i < nargs; i++)
2031       {
2032         struct value *arg = args[i];
2033         struct type *type = value_type (arg);
2034         unsigned length = TYPE_LENGTH (type);
2035
2036         if (s390_function_arg_pass_by_reference (type))
2037           {
2038             if (gr <= 6)
2039               {
2040                 regcache_cooked_write_unsigned (regcache, S390_R0_REGNUM + gr,
2041                                                 copy_addr[i]);
2042                 gr++;
2043               }
2044             else
2045               {
2046                 write_memory_unsigned_integer (starg, word_size, copy_addr[i]);
2047                 starg += word_size;
2048               }
2049           }
2050         else if (s390_function_arg_float (type))
2051           {
2052             /* The GNU/Linux for S/390 ABI uses FPRs 0 and 2 to pass arguments,
2053                the GNU/Linux for zSeries ABI uses 0, 2, 4, and 6.  */
2054             if (fr <= (tdep->abi == ABI_LINUX_S390 ? 2 : 6))
2055               {
2056                 /* When we store a single-precision value in an FP register,
2057                    it occupies the leftmost bits.  */
2058                 regcache_cooked_write_part (regcache, S390_F0_REGNUM + fr,
2059                                             0, length, value_contents (arg));
2060                 fr += 2;
2061               }
2062             else
2063               {
2064                 /* When we store a single-precision value in a stack slot,
2065                    it occupies the rightmost bits.  */
2066                 starg = align_up (starg + length, word_size);
2067                 write_memory (starg - length, value_contents (arg), length);
2068               }
2069           }
2070         else if (s390_function_arg_integer (type) && length <= word_size)
2071           {
2072             if (gr <= 6)
2073               {
2074                 /* Integer arguments are always extended to word size.  */
2075                 regcache_cooked_write_signed (regcache, S390_R0_REGNUM + gr,
2076                                               extend_simple_arg (arg));
2077                 gr++;
2078               }
2079             else
2080               {
2081                 /* Integer arguments are always extended to word size.  */
2082                 write_memory_signed_integer (starg, word_size,
2083                                              extend_simple_arg (arg));
2084                 starg += word_size;
2085               }
2086           }
2087         else if (s390_function_arg_integer (type) && length == 2*word_size)
2088           {
2089             if (gr <= 5)
2090               {
2091                 regcache_cooked_write (regcache, S390_R0_REGNUM + gr,
2092                                        value_contents (arg));
2093                 regcache_cooked_write (regcache, S390_R0_REGNUM + gr + 1,
2094                                        value_contents (arg) + word_size);
2095                 gr += 2;
2096               }
2097             else
2098               {
2099                 /* If we skipped r6 because we couldn't fit a DOUBLE_ARG
2100                    in it, then don't go back and use it again later.  */
2101                 gr = 7;
2102
2103                 write_memory (starg, value_contents (arg), length);
2104                 starg += length;
2105               }
2106           }
2107         else
2108           internal_error (__FILE__, __LINE__, _("unknown argument type"));
2109       }
2110   }
2111
2112   /* Allocate the standard frame areas: the register save area, the
2113      word reserved for the compiler (which seems kind of meaningless),
2114      and the back chain pointer.  */
2115   sp -= 16*word_size + 32;
2116
2117   /* Store return address.  */
2118   regcache_cooked_write_unsigned (regcache, S390_RETADDR_REGNUM, bp_addr);
2119   
2120   /* Store updated stack pointer.  */
2121   regcache_cooked_write_unsigned (regcache, S390_SP_REGNUM, sp);
2122
2123   /* We need to return the 'stack part' of the frame ID,
2124      which is actually the top of the register save area.  */
2125   return sp + 16*word_size + 32;
2126 }
2127
2128 /* Assuming THIS_FRAME is a dummy, return the frame ID of that
2129    dummy frame.  The frame ID's base needs to match the TOS value
2130    returned by push_dummy_call, and the PC match the dummy frame's
2131    breakpoint.  */
2132 static struct frame_id
2133 s390_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
2134 {
2135   int word_size = gdbarch_ptr_bit (gdbarch) / 8;
2136   CORE_ADDR sp = get_frame_register_unsigned (this_frame, S390_SP_REGNUM);
2137   sp = gdbarch_addr_bits_remove (gdbarch, sp);
2138
2139   return frame_id_build (sp + 16*word_size + 32,
2140                          get_frame_pc (this_frame));
2141 }
2142
2143 static CORE_ADDR
2144 s390_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
2145 {
2146   /* Both the 32- and 64-bit ABI's say that the stack pointer should
2147      always be aligned on an eight-byte boundary.  */
2148   return (addr & -8);
2149 }
2150
2151
2152 /* Function return value access.  */
2153
2154 static enum return_value_convention
2155 s390_return_value_convention (struct gdbarch *gdbarch, struct type *type)
2156 {
2157   int length = TYPE_LENGTH (type);
2158   if (length > 8)
2159     return RETURN_VALUE_STRUCT_CONVENTION;
2160
2161   switch (TYPE_CODE (type))
2162     {
2163     case TYPE_CODE_STRUCT:
2164     case TYPE_CODE_UNION:
2165     case TYPE_CODE_ARRAY:
2166       return RETURN_VALUE_STRUCT_CONVENTION;
2167
2168     default:
2169       return RETURN_VALUE_REGISTER_CONVENTION;
2170     }
2171 }
2172
2173 static enum return_value_convention
2174 s390_return_value (struct gdbarch *gdbarch, struct type *func_type,
2175                    struct type *type, struct regcache *regcache,
2176                    gdb_byte *out, const gdb_byte *in)
2177 {
2178   int word_size = gdbarch_ptr_bit (gdbarch) / 8;
2179   int length = TYPE_LENGTH (type);
2180   enum return_value_convention rvc = 
2181                         s390_return_value_convention (gdbarch, type);
2182   if (in)
2183     {
2184       switch (rvc)
2185         {
2186         case RETURN_VALUE_REGISTER_CONVENTION:
2187           if (TYPE_CODE (type) == TYPE_CODE_FLT
2188               || TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
2189             {
2190               /* When we store a single-precision value in an FP register,
2191                  it occupies the leftmost bits.  */
2192               regcache_cooked_write_part (regcache, S390_F0_REGNUM, 
2193                                           0, length, in);
2194             }
2195           else if (length <= word_size)
2196             {
2197               /* Integer arguments are always extended to word size.  */
2198               if (TYPE_UNSIGNED (type))
2199                 regcache_cooked_write_unsigned (regcache, S390_R2_REGNUM,
2200                         extract_unsigned_integer (in, length));
2201               else
2202                 regcache_cooked_write_signed (regcache, S390_R2_REGNUM,
2203                         extract_signed_integer (in, length));
2204             }
2205           else if (length == 2*word_size)
2206             {
2207               regcache_cooked_write (regcache, S390_R2_REGNUM, in);
2208               regcache_cooked_write (regcache, S390_R3_REGNUM, in + word_size);
2209             }
2210           else
2211             internal_error (__FILE__, __LINE__, _("invalid return type"));
2212           break;
2213
2214         case RETURN_VALUE_STRUCT_CONVENTION:
2215           error (_("Cannot set function return value."));
2216           break;
2217         }
2218     }
2219   else if (out)
2220     {
2221       switch (rvc)
2222         {
2223         case RETURN_VALUE_REGISTER_CONVENTION:
2224           if (TYPE_CODE (type) == TYPE_CODE_FLT
2225               || TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
2226             {
2227               /* When we store a single-precision value in an FP register,
2228                  it occupies the leftmost bits.  */
2229               regcache_cooked_read_part (regcache, S390_F0_REGNUM, 
2230                                          0, length, out);
2231             }
2232           else if (length <= word_size)
2233             {
2234               /* Integer arguments occupy the rightmost bits.  */
2235               regcache_cooked_read_part (regcache, S390_R2_REGNUM, 
2236                                          word_size - length, length, out);
2237             }
2238           else if (length == 2*word_size)
2239             {
2240               regcache_cooked_read (regcache, S390_R2_REGNUM, out);
2241               regcache_cooked_read (regcache, S390_R3_REGNUM, out + word_size);
2242             }
2243           else
2244             internal_error (__FILE__, __LINE__, _("invalid return type"));
2245           break;
2246
2247         case RETURN_VALUE_STRUCT_CONVENTION:
2248           error (_("Function return value unknown."));
2249           break;
2250         }
2251     }
2252
2253   return rvc;
2254 }
2255
2256
2257 /* Breakpoints.  */
2258
2259 static const gdb_byte *
2260 s390_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
2261 {
2262   static const gdb_byte breakpoint[] = { 0x0, 0x1 };
2263
2264   *lenptr = sizeof (breakpoint);
2265   return breakpoint;
2266 }
2267
2268
2269 /* Address handling.  */
2270
2271 static CORE_ADDR
2272 s390_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr)
2273 {
2274   return addr & 0x7fffffff;
2275 }
2276
2277 static int
2278 s390_address_class_type_flags (int byte_size, int dwarf2_addr_class)
2279 {
2280   if (byte_size == 4)
2281     return TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1;
2282   else
2283     return 0;
2284 }
2285
2286 static const char *
2287 s390_address_class_type_flags_to_name (struct gdbarch *gdbarch, int type_flags)
2288 {
2289   if (type_flags & TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1)
2290     return "mode32";
2291   else
2292     return NULL;
2293 }
2294
2295 static int
2296 s390_address_class_name_to_type_flags (struct gdbarch *gdbarch, const char *name,
2297                                        int *type_flags_ptr)
2298 {
2299   if (strcmp (name, "mode32") == 0)
2300     {
2301       *type_flags_ptr = TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1;
2302       return 1;
2303     }
2304   else
2305     return 0;
2306 }
2307
2308 /* Set up gdbarch struct.  */
2309
2310 static struct gdbarch *
2311 s390_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
2312 {
2313   struct gdbarch *gdbarch;
2314   struct gdbarch_tdep *tdep;
2315
2316   /* First see if there is already a gdbarch that can satisfy the request.  */
2317   arches = gdbarch_list_lookup_by_info (arches, &info);
2318   if (arches != NULL)
2319     return arches->gdbarch;
2320
2321   /* None found: is the request for a s390 architecture? */
2322   if (info.bfd_arch_info->arch != bfd_arch_s390)
2323     return NULL;                /* No; then it's not for us.  */
2324
2325   /* Yes: create a new gdbarch for the specified machine type.  */
2326   tdep = XCALLOC (1, struct gdbarch_tdep);
2327   gdbarch = gdbarch_alloc (&info, tdep);
2328
2329   set_gdbarch_believe_pcc_promotion (gdbarch, 0);
2330   set_gdbarch_char_signed (gdbarch, 0);
2331
2332   /* S/390 GNU/Linux uses either 64-bit or 128-bit long doubles.
2333      We can safely let them default to 128-bit, since the debug info
2334      will give the size of type actually used in each case.  */
2335   set_gdbarch_long_double_bit (gdbarch, 128);
2336   set_gdbarch_long_double_format (gdbarch, floatformats_ia64_quad);
2337
2338   /* Amount PC must be decremented by after a breakpoint.  This is
2339      often the number of bytes returned by gdbarch_breakpoint_from_pc but not
2340      always.  */
2341   set_gdbarch_decr_pc_after_break (gdbarch, 2);
2342   /* Stack grows downward.  */
2343   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
2344   set_gdbarch_breakpoint_from_pc (gdbarch, s390_breakpoint_from_pc);
2345   set_gdbarch_skip_prologue (gdbarch, s390_skip_prologue);
2346   set_gdbarch_in_function_epilogue_p (gdbarch, s390_in_function_epilogue_p);
2347
2348   set_gdbarch_pc_regnum (gdbarch, S390_PC_REGNUM);
2349   set_gdbarch_sp_regnum (gdbarch, S390_SP_REGNUM);
2350   set_gdbarch_fp0_regnum (gdbarch, S390_F0_REGNUM);
2351   set_gdbarch_num_regs (gdbarch, S390_NUM_REGS);
2352   set_gdbarch_num_pseudo_regs (gdbarch, S390_NUM_PSEUDO_REGS);
2353   set_gdbarch_register_name (gdbarch, s390_register_name);
2354   set_gdbarch_register_type (gdbarch, s390_register_type);
2355   set_gdbarch_stab_reg_to_regnum (gdbarch, s390_dwarf_reg_to_regnum);
2356   set_gdbarch_dwarf2_reg_to_regnum (gdbarch, s390_dwarf_reg_to_regnum);
2357   set_gdbarch_value_from_register (gdbarch, s390_value_from_register);
2358   set_gdbarch_register_reggroup_p (gdbarch, s390_register_reggroup_p);
2359   set_gdbarch_regset_from_core_section (gdbarch,
2360                                         s390_regset_from_core_section);
2361
2362   /* Inferior function calls.  */
2363   set_gdbarch_push_dummy_call (gdbarch, s390_push_dummy_call);
2364   set_gdbarch_dummy_id (gdbarch, s390_dummy_id);
2365   set_gdbarch_frame_align (gdbarch, s390_frame_align);
2366   set_gdbarch_return_value (gdbarch, s390_return_value);
2367
2368   /* Frame handling.  */
2369   dwarf2_frame_set_init_reg (gdbarch, s390_dwarf2_frame_init_reg);
2370   dwarf2_append_unwinders (gdbarch);
2371   frame_base_append_sniffer (gdbarch, dwarf2_frame_base_sniffer);
2372   frame_unwind_append_unwinder (gdbarch, &s390_stub_frame_unwind);
2373   frame_unwind_append_unwinder (gdbarch, &s390_sigtramp_frame_unwind);
2374   frame_unwind_append_unwinder (gdbarch, &s390_frame_unwind);
2375   frame_base_set_default (gdbarch, &s390_frame_base);
2376   set_gdbarch_unwind_pc (gdbarch, s390_unwind_pc);
2377   set_gdbarch_unwind_sp (gdbarch, s390_unwind_sp);
2378
2379   switch (info.bfd_arch_info->mach)
2380     {
2381     case bfd_mach_s390_31:
2382       tdep->abi = ABI_LINUX_S390;
2383
2384       tdep->gregset = &s390_gregset;
2385       tdep->sizeof_gregset = s390_sizeof_gregset;
2386       tdep->fpregset = &s390_fpregset;
2387       tdep->sizeof_fpregset = s390_sizeof_fpregset;
2388
2389       set_gdbarch_addr_bits_remove (gdbarch, s390_addr_bits_remove);
2390       set_gdbarch_pseudo_register_read (gdbarch, s390_pseudo_register_read);
2391       set_gdbarch_pseudo_register_write (gdbarch, s390_pseudo_register_write);
2392       set_solib_svr4_fetch_link_map_offsets
2393         (gdbarch, svr4_ilp32_fetch_link_map_offsets);
2394
2395       break;
2396     case bfd_mach_s390_64:
2397       tdep->abi = ABI_LINUX_ZSERIES;
2398
2399       tdep->gregset = &s390x_gregset;
2400       tdep->sizeof_gregset = s390x_sizeof_gregset;
2401       tdep->fpregset = &s390_fpregset;
2402       tdep->sizeof_fpregset = s390_sizeof_fpregset;
2403
2404       set_gdbarch_long_bit (gdbarch, 64);
2405       set_gdbarch_long_long_bit (gdbarch, 64);
2406       set_gdbarch_ptr_bit (gdbarch, 64);
2407       set_gdbarch_pseudo_register_read (gdbarch, s390x_pseudo_register_read);
2408       set_gdbarch_pseudo_register_write (gdbarch, s390x_pseudo_register_write);
2409       set_solib_svr4_fetch_link_map_offsets
2410         (gdbarch, svr4_lp64_fetch_link_map_offsets);
2411       set_gdbarch_address_class_type_flags (gdbarch,
2412                                             s390_address_class_type_flags);
2413       set_gdbarch_address_class_type_flags_to_name (gdbarch,
2414                                                     s390_address_class_type_flags_to_name);
2415       set_gdbarch_address_class_name_to_type_flags (gdbarch,
2416                                                     s390_address_class_name_to_type_flags);
2417       break;
2418     }
2419
2420   set_gdbarch_print_insn (gdbarch, print_insn_s390);
2421
2422   set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
2423
2424   /* Enable TLS support.  */
2425   set_gdbarch_fetch_tls_load_module_address (gdbarch,
2426                                              svr4_fetch_objfile_link_map);
2427
2428   return gdbarch;
2429 }
2430
2431
2432
2433 extern initialize_file_ftype _initialize_s390_tdep; /* -Wmissing-prototypes */
2434
2435 void
2436 _initialize_s390_tdep (void)
2437 {
2438
2439   /* Hook us into the gdbarch mechanism.  */
2440   register_gdbarch_init (bfd_arch_s390, s390_gdbarch_init);
2441 }