OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-6.8/] [gdb/] [s390-tdep.c] - Blame information for rev 840

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* 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_long;
100
  if (regnum >= S390_R0_REGNUM && regnum <= S390_R15_REGNUM)
101
    return builtin_type_long;
102
  if (regnum >= S390_A0_REGNUM && regnum <= S390_A15_REGNUM)
103
    return builtin_type_int;
104
  if (regnum == S390_FPC_REGNUM)
105
    return builtin_type_int;
106
  if (regnum >= S390_F0_REGNUM && regnum <= S390_F15_REGNUM)
107
    return builtin_type_double;
108
  if (regnum == S390_PC_REGNUM)
109
    return builtin_type_void_func_ptr;
110
  if (regnum == S390_CC_REGNUM)
111
    return builtin_type_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 (read_memory_nobpt (at, &instr[0], 2))
507
    return -1;
508
  instrlen = s390_instrlen[instr[0] >> 6];
509
  if (instrlen > 2)
510
    {
511
      if (read_memory_nobpt (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
      && !read_memory_nobpt (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
      && !read_memory_nobpt (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
      && !read_memory_nobpt (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 *next_frame,
1169
                                  struct s390_unwind_cache *info)
1170
{
1171
  struct gdbarch *gdbarch = get_frame_arch (next_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 = frame_func_unwind (next_frame, NORMAL_FRAME);
1191
  if (!func)
1192
    return 0;
1193
 
1194
  /* Try to analyze the prologue.  */
1195
  result = s390_analyze_prologue (gdbarch, func,
1196
                                  frame_pc_unwind (next_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_frame_type (next_frame) == NORMAL_FRAME)
1219
        return 0;
1220
 
1221
      /* If we really have a frameless function, %r14 must be valid
1222
         -- in particular, it must point to a different function.  */
1223
      reg = frame_unwind_register_unsigned (next_frame, S390_RETADDR_REGNUM);
1224
      reg = gdbarch_addr_bits_remove (gdbarch, reg) - 1;
1225
      if (get_pc_function_start (reg) == func)
1226
        {
1227
          /* However, there is one case where it *is* valid for %r14
1228
             to point to the same function -- if this is a recursive
1229
             call, and we have stopped in the prologue *before* the
1230
             stack frame was allocated.
1231
 
1232
             Recognize this case by looking ahead a bit ...  */
1233
 
1234
          struct s390_prologue_data data2;
1235
          pv_t *sp = &data2.gpr[S390_SP_REGNUM - S390_R0_REGNUM];
1236
 
1237
          if (!(s390_analyze_prologue (gdbarch, func, (CORE_ADDR)-1, &data2)
1238
                && pv_is_register (*sp, S390_SP_REGNUM)
1239
                && sp->k != 0))
1240
            return 0;
1241
        }
1242
    }
1243
 
1244
 
1245
  /* OK, we've found valid prologue data.  */
1246
  size = -sp->k;
1247
 
1248
  /* If the frame pointer originally also holds the same value
1249
     as the stack pointer, we're probably using it.  If it holds
1250
     some other value -- even a constant offset -- it is most
1251
     likely used as temp register.  */
1252
  if (pv_is_identical (*sp, *fp))
1253
    frame_pointer = S390_FRAME_REGNUM;
1254
  else
1255
    frame_pointer = S390_SP_REGNUM;
1256
 
1257
  /* If we've detected a function with stack frame, we'll still have to
1258
     treat it as frameless if we're currently within the function epilog
1259
     code at a point where the frame pointer has already been restored.
1260
     This can only happen in an innermost frame.  */
1261
  /* FIXME: cagney/2004-05-01: This sanity check shouldn't be needed,
1262
     instead the code should simpliy rely on its analysis.  */
1263
  if (size > 0 && get_frame_type (next_frame) != NORMAL_FRAME)
1264
    {
1265
      /* See the comment in s390_in_function_epilogue_p on why this is
1266
         not completely reliable ...  */
1267
      if (s390_in_function_epilogue_p (gdbarch, frame_pc_unwind (next_frame)))
1268
        {
1269
          memset (&data, 0, sizeof (data));
1270
          size = 0;
1271
          frame_pointer = S390_SP_REGNUM;
1272
        }
1273
    }
1274
 
1275
  /* Once we know the frame register and the frame size, we can unwind
1276
     the current value of the frame register from the next frame, and
1277
     add back the frame size to arrive that the previous frame's
1278
     stack pointer value.  */
1279
  prev_sp = frame_unwind_register_unsigned (next_frame, frame_pointer) + size;
1280
  cfa = prev_sp + 16*word_size + 32;
1281
 
1282
  /* Record the addresses of all register spill slots the prologue parser
1283
     has recognized.  Consider only registers defined as call-saved by the
1284
     ABI; for call-clobbered registers the parser may have recognized
1285
     spurious stores.  */
1286
 
1287
  for (i = 6; i <= 15; i++)
1288
    if (data.gpr_slot[i] != 0)
1289
      info->saved_regs[S390_R0_REGNUM + i].addr = cfa - data.gpr_slot[i];
1290
 
1291
  switch (tdep->abi)
1292
    {
1293
    case ABI_LINUX_S390:
1294
      if (data.fpr_slot[4] != 0)
1295
        info->saved_regs[S390_F4_REGNUM].addr = cfa - data.fpr_slot[4];
1296
      if (data.fpr_slot[6] != 0)
1297
        info->saved_regs[S390_F6_REGNUM].addr = cfa - data.fpr_slot[6];
1298
      break;
1299
 
1300
    case ABI_LINUX_ZSERIES:
1301
      for (i = 8; i <= 15; i++)
1302
        if (data.fpr_slot[i] != 0)
1303
          info->saved_regs[S390_F0_REGNUM + i].addr = cfa - data.fpr_slot[i];
1304
      break;
1305
    }
1306
 
1307
  /* Function return will set PC to %r14.  */
1308
  info->saved_regs[S390_PC_REGNUM] = info->saved_regs[S390_RETADDR_REGNUM];
1309
 
1310
  /* In frameless functions, we unwind simply by moving the return
1311
     address to the PC.  However, if we actually stored to the
1312
     save area, use that -- we might only think the function frameless
1313
     because we're in the middle of the prologue ...  */
1314
  if (size == 0
1315
      && !trad_frame_addr_p (info->saved_regs, S390_PC_REGNUM))
1316
    {
1317
      info->saved_regs[S390_PC_REGNUM].realreg = S390_RETADDR_REGNUM;
1318
    }
1319
 
1320
  /* Another sanity check: unless this is a frameless function,
1321
     we should have found spill slots for SP and PC.
1322
     If not, we cannot unwind further -- this happens e.g. in
1323
     libc's thread_start routine.  */
1324
  if (size > 0)
1325
    {
1326
      if (!trad_frame_addr_p (info->saved_regs, S390_SP_REGNUM)
1327
          || !trad_frame_addr_p (info->saved_regs, S390_PC_REGNUM))
1328
        prev_sp = -1;
1329
    }
1330
 
1331
  /* We use the current value of the frame register as local_base,
1332
     and the top of the register save area as frame_base.  */
1333
  if (prev_sp != -1)
1334
    {
1335
      info->frame_base = prev_sp + 16*word_size + 32;
1336
      info->local_base = prev_sp - size;
1337
    }
1338
 
1339
  info->func = func;
1340
  return 1;
1341
}
1342
 
1343
static void
1344
s390_backchain_frame_unwind_cache (struct frame_info *next_frame,
1345
                                   struct s390_unwind_cache *info)
1346
{
1347
  struct gdbarch *gdbarch = get_frame_arch (next_frame);
1348
  int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1349
  CORE_ADDR backchain;
1350
  ULONGEST reg;
1351
  LONGEST sp;
1352
 
1353
  /* Get the backchain.  */
1354
  reg = frame_unwind_register_unsigned (next_frame, S390_SP_REGNUM);
1355
  backchain = read_memory_unsigned_integer (reg, word_size);
1356
 
1357
  /* A zero backchain terminates the frame chain.  As additional
1358
     sanity check, let's verify that the spill slot for SP in the
1359
     save area pointed to by the backchain in fact links back to
1360
     the save area.  */
1361
  if (backchain != 0
1362
      && safe_read_memory_integer (backchain + 15*word_size, word_size, &sp)
1363
      && (CORE_ADDR)sp == backchain)
1364
    {
1365
      /* We don't know which registers were saved, but it will have
1366
         to be at least %r14 and %r15.  This will allow us to continue
1367
         unwinding, but other prev-frame registers may be incorrect ...  */
1368
      info->saved_regs[S390_SP_REGNUM].addr = backchain + 15*word_size;
1369
      info->saved_regs[S390_RETADDR_REGNUM].addr = backchain + 14*word_size;
1370
 
1371
      /* Function return will set PC to %r14.  */
1372
      info->saved_regs[S390_PC_REGNUM] = info->saved_regs[S390_RETADDR_REGNUM];
1373
 
1374
      /* We use the current value of the frame register as local_base,
1375
         and the top of the register save area as frame_base.  */
1376
      info->frame_base = backchain + 16*word_size + 32;
1377
      info->local_base = reg;
1378
    }
1379
 
1380
  info->func = frame_pc_unwind (next_frame);
1381
}
1382
 
1383
static struct s390_unwind_cache *
1384
s390_frame_unwind_cache (struct frame_info *next_frame,
1385
                         void **this_prologue_cache)
1386
{
1387
  struct s390_unwind_cache *info;
1388
  if (*this_prologue_cache)
1389
    return *this_prologue_cache;
1390
 
1391
  info = FRAME_OBSTACK_ZALLOC (struct s390_unwind_cache);
1392
  *this_prologue_cache = info;
1393
  info->saved_regs = trad_frame_alloc_saved_regs (next_frame);
1394
  info->func = -1;
1395
  info->frame_base = -1;
1396
  info->local_base = -1;
1397
 
1398
  /* Try to use prologue analysis to fill the unwind cache.
1399
     If this fails, fall back to reading the stack backchain.  */
1400
  if (!s390_prologue_frame_unwind_cache (next_frame, info))
1401
    s390_backchain_frame_unwind_cache (next_frame, info);
1402
 
1403
  return info;
1404
}
1405
 
1406
static void
1407
s390_frame_this_id (struct frame_info *next_frame,
1408
                    void **this_prologue_cache,
1409
                    struct frame_id *this_id)
1410
{
1411
  struct s390_unwind_cache *info
1412
    = s390_frame_unwind_cache (next_frame, this_prologue_cache);
1413
 
1414
  if (info->frame_base == -1)
1415
    return;
1416
 
1417
  *this_id = frame_id_build (info->frame_base, info->func);
1418
}
1419
 
1420
static void
1421
s390_frame_prev_register (struct frame_info *next_frame,
1422
                          void **this_prologue_cache,
1423
                          int regnum, int *optimizedp,
1424
                          enum lval_type *lvalp, CORE_ADDR *addrp,
1425
                          int *realnump, gdb_byte *bufferp)
1426
{
1427
  struct s390_unwind_cache *info
1428
    = s390_frame_unwind_cache (next_frame, this_prologue_cache);
1429
  trad_frame_get_prev_register (next_frame, info->saved_regs, regnum,
1430
                                optimizedp, lvalp, addrp, realnump, bufferp);
1431
}
1432
 
1433
static const struct frame_unwind s390_frame_unwind = {
1434
  NORMAL_FRAME,
1435
  s390_frame_this_id,
1436
  s390_frame_prev_register
1437
};
1438
 
1439
static const struct frame_unwind *
1440
s390_frame_sniffer (struct frame_info *next_frame)
1441
{
1442
  return &s390_frame_unwind;
1443
}
1444
 
1445
 
1446
/* Code stubs and their stack frames.  For things like PLTs and NULL
1447
   function calls (where there is no true frame and the return address
1448
   is in the RETADDR register).  */
1449
 
1450
struct s390_stub_unwind_cache
1451
{
1452
  CORE_ADDR frame_base;
1453
  struct trad_frame_saved_reg *saved_regs;
1454
};
1455
 
1456
static struct s390_stub_unwind_cache *
1457
s390_stub_frame_unwind_cache (struct frame_info *next_frame,
1458
                              void **this_prologue_cache)
1459
{
1460
  struct gdbarch *gdbarch = get_frame_arch (next_frame);
1461
  int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1462
  struct s390_stub_unwind_cache *info;
1463
  ULONGEST reg;
1464
 
1465
  if (*this_prologue_cache)
1466
    return *this_prologue_cache;
1467
 
1468
  info = FRAME_OBSTACK_ZALLOC (struct s390_stub_unwind_cache);
1469
  *this_prologue_cache = info;
1470
  info->saved_regs = trad_frame_alloc_saved_regs (next_frame);
1471
 
1472
  /* The return address is in register %r14.  */
1473
  info->saved_regs[S390_PC_REGNUM].realreg = S390_RETADDR_REGNUM;
1474
 
1475
  /* Retrieve stack pointer and determine our frame base.  */
1476
  reg = frame_unwind_register_unsigned (next_frame, S390_SP_REGNUM);
1477
  info->frame_base = reg + 16*word_size + 32;
1478
 
1479
  return info;
1480
}
1481
 
1482
static void
1483
s390_stub_frame_this_id (struct frame_info *next_frame,
1484
                         void **this_prologue_cache,
1485
                         struct frame_id *this_id)
1486
{
1487
  struct s390_stub_unwind_cache *info
1488
    = s390_stub_frame_unwind_cache (next_frame, this_prologue_cache);
1489
  *this_id = frame_id_build (info->frame_base, frame_pc_unwind (next_frame));
1490
}
1491
 
1492
static void
1493
s390_stub_frame_prev_register (struct frame_info *next_frame,
1494
                               void **this_prologue_cache,
1495
                               int regnum, int *optimizedp,
1496
                               enum lval_type *lvalp, CORE_ADDR *addrp,
1497
                               int *realnump, gdb_byte *bufferp)
1498
{
1499
  struct s390_stub_unwind_cache *info
1500
    = s390_stub_frame_unwind_cache (next_frame, this_prologue_cache);
1501
  trad_frame_get_prev_register (next_frame, info->saved_regs, regnum,
1502
                                optimizedp, lvalp, addrp, realnump, bufferp);
1503
}
1504
 
1505
static const struct frame_unwind s390_stub_frame_unwind = {
1506
  NORMAL_FRAME,
1507
  s390_stub_frame_this_id,
1508
  s390_stub_frame_prev_register
1509
};
1510
 
1511
static const struct frame_unwind *
1512
s390_stub_frame_sniffer (struct frame_info *next_frame)
1513
{
1514
  CORE_ADDR addr_in_block;
1515
  bfd_byte insn[S390_MAX_INSTR_SIZE];
1516
 
1517
  /* If the current PC points to non-readable memory, we assume we
1518
     have trapped due to an invalid function pointer call.  We handle
1519
     the non-existing current function like a PLT stub.  */
1520
  addr_in_block = frame_unwind_address_in_block (next_frame, NORMAL_FRAME);
1521
  if (in_plt_section (addr_in_block, NULL)
1522
      || s390_readinstruction (insn, frame_pc_unwind (next_frame)) < 0)
1523
    return &s390_stub_frame_unwind;
1524
  return NULL;
1525
}
1526
 
1527
 
1528
/* Signal trampoline stack frames.  */
1529
 
1530
struct s390_sigtramp_unwind_cache {
1531
  CORE_ADDR frame_base;
1532
  struct trad_frame_saved_reg *saved_regs;
1533
};
1534
 
1535
static struct s390_sigtramp_unwind_cache *
1536
s390_sigtramp_frame_unwind_cache (struct frame_info *next_frame,
1537
                                  void **this_prologue_cache)
1538
{
1539
  struct gdbarch *gdbarch = get_frame_arch (next_frame);
1540
  int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1541
  struct s390_sigtramp_unwind_cache *info;
1542
  ULONGEST this_sp, prev_sp;
1543
  CORE_ADDR next_ra, next_cfa, sigreg_ptr;
1544
  int i;
1545
 
1546
  if (*this_prologue_cache)
1547
    return *this_prologue_cache;
1548
 
1549
  info = FRAME_OBSTACK_ZALLOC (struct s390_sigtramp_unwind_cache);
1550
  *this_prologue_cache = info;
1551
  info->saved_regs = trad_frame_alloc_saved_regs (next_frame);
1552
 
1553
  this_sp = frame_unwind_register_unsigned (next_frame, S390_SP_REGNUM);
1554
  next_ra = frame_pc_unwind (next_frame);
1555
  next_cfa = this_sp + 16*word_size + 32;
1556
 
1557
  /* New-style RT frame:
1558
        retcode + alignment (8 bytes)
1559
        siginfo (128 bytes)
1560
        ucontext (contains sigregs at offset 5 words)  */
1561
  if (next_ra == next_cfa)
1562
    {
1563
      sigreg_ptr = next_cfa + 8 + 128 + align_up (5*word_size, 8);
1564
    }
1565
 
1566
  /* Old-style RT frame and all non-RT frames:
1567
        old signal mask (8 bytes)
1568
        pointer to sigregs  */
1569
  else
1570
    {
1571
      sigreg_ptr = read_memory_unsigned_integer (next_cfa + 8, word_size);
1572
    }
1573
 
1574
  /* The sigregs structure looks like this:
1575
            long   psw_mask;
1576
            long   psw_addr;
1577
            long   gprs[16];
1578
            int    acrs[16];
1579
            int    fpc;
1580
            int    __pad;
1581
            double fprs[16];  */
1582
 
1583
  /* Let's ignore the PSW mask, it will not be restored anyway.  */
1584
  sigreg_ptr += word_size;
1585
 
1586
  /* Next comes the PSW address.  */
1587
  info->saved_regs[S390_PC_REGNUM].addr = sigreg_ptr;
1588
  sigreg_ptr += word_size;
1589
 
1590
  /* Then the GPRs.  */
1591
  for (i = 0; i < 16; i++)
1592
    {
1593
      info->saved_regs[S390_R0_REGNUM + i].addr = sigreg_ptr;
1594
      sigreg_ptr += word_size;
1595
    }
1596
 
1597
  /* Then the ACRs.  */
1598
  for (i = 0; i < 16; i++)
1599
    {
1600
      info->saved_regs[S390_A0_REGNUM + i].addr = sigreg_ptr;
1601
      sigreg_ptr += 4;
1602
    }
1603
 
1604
  /* The floating-point control word.  */
1605
  info->saved_regs[S390_FPC_REGNUM].addr = sigreg_ptr;
1606
  sigreg_ptr += 8;
1607
 
1608
  /* And finally the FPRs.  */
1609
  for (i = 0; i < 16; i++)
1610
    {
1611
      info->saved_regs[S390_F0_REGNUM + i].addr = sigreg_ptr;
1612
      sigreg_ptr += 8;
1613
    }
1614
 
1615
  /* Restore the previous frame's SP.  */
1616
  prev_sp = read_memory_unsigned_integer (
1617
                        info->saved_regs[S390_SP_REGNUM].addr,
1618
                        word_size);
1619
 
1620
  /* Determine our frame base.  */
1621
  info->frame_base = prev_sp + 16*word_size + 32;
1622
 
1623
  return info;
1624
}
1625
 
1626
static void
1627
s390_sigtramp_frame_this_id (struct frame_info *next_frame,
1628
                             void **this_prologue_cache,
1629
                             struct frame_id *this_id)
1630
{
1631
  struct s390_sigtramp_unwind_cache *info
1632
    = s390_sigtramp_frame_unwind_cache (next_frame, this_prologue_cache);
1633
  *this_id = frame_id_build (info->frame_base, frame_pc_unwind (next_frame));
1634
}
1635
 
1636
static void
1637
s390_sigtramp_frame_prev_register (struct frame_info *next_frame,
1638
                                   void **this_prologue_cache,
1639
                                   int regnum, int *optimizedp,
1640
                                   enum lval_type *lvalp, CORE_ADDR *addrp,
1641
                                   int *realnump, gdb_byte *bufferp)
1642
{
1643
  struct s390_sigtramp_unwind_cache *info
1644
    = s390_sigtramp_frame_unwind_cache (next_frame, this_prologue_cache);
1645
  trad_frame_get_prev_register (next_frame, info->saved_regs, regnum,
1646
                                optimizedp, lvalp, addrp, realnump, bufferp);
1647
}
1648
 
1649
static const struct frame_unwind s390_sigtramp_frame_unwind = {
1650
  SIGTRAMP_FRAME,
1651
  s390_sigtramp_frame_this_id,
1652
  s390_sigtramp_frame_prev_register
1653
};
1654
 
1655
static const struct frame_unwind *
1656
s390_sigtramp_frame_sniffer (struct frame_info *next_frame)
1657
{
1658
  CORE_ADDR pc = frame_pc_unwind (next_frame);
1659
  bfd_byte sigreturn[2];
1660
 
1661
  if (read_memory_nobpt (pc, sigreturn, 2))
1662
    return NULL;
1663
 
1664
  if (sigreturn[0] != 0x0a /* svc */)
1665
    return NULL;
1666
 
1667
  if (sigreturn[1] != 119 /* sigreturn */
1668
      && sigreturn[1] != 173 /* rt_sigreturn */)
1669
    return NULL;
1670
 
1671
  return &s390_sigtramp_frame_unwind;
1672
}
1673
 
1674
 
1675
/* Frame base handling.  */
1676
 
1677
static CORE_ADDR
1678
s390_frame_base_address (struct frame_info *next_frame, void **this_cache)
1679
{
1680
  struct s390_unwind_cache *info
1681
    = s390_frame_unwind_cache (next_frame, this_cache);
1682
  return info->frame_base;
1683
}
1684
 
1685
static CORE_ADDR
1686
s390_local_base_address (struct frame_info *next_frame, void **this_cache)
1687
{
1688
  struct s390_unwind_cache *info
1689
    = s390_frame_unwind_cache (next_frame, this_cache);
1690
  return info->local_base;
1691
}
1692
 
1693
static const struct frame_base s390_frame_base = {
1694
  &s390_frame_unwind,
1695
  s390_frame_base_address,
1696
  s390_local_base_address,
1697
  s390_local_base_address
1698
};
1699
 
1700
static CORE_ADDR
1701
s390_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
1702
{
1703
  ULONGEST pc;
1704
  pc = frame_unwind_register_unsigned (next_frame, S390_PC_REGNUM);
1705
  return gdbarch_addr_bits_remove (gdbarch, pc);
1706
}
1707
 
1708
static CORE_ADDR
1709
s390_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
1710
{
1711
  ULONGEST sp;
1712
  sp = frame_unwind_register_unsigned (next_frame, S390_SP_REGNUM);
1713
  return gdbarch_addr_bits_remove (gdbarch, sp);
1714
}
1715
 
1716
 
1717
/* DWARF-2 frame support.  */
1718
 
1719
static void
1720
s390_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
1721
                            struct dwarf2_frame_state_reg *reg,
1722
                            struct frame_info *next_frame)
1723
{
1724
  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1725
 
1726
  switch (tdep->abi)
1727
    {
1728
    case ABI_LINUX_S390:
1729
      /* Call-saved registers.  */
1730
      if ((regnum >= S390_R6_REGNUM && regnum <= S390_R15_REGNUM)
1731
          || regnum == S390_F4_REGNUM
1732
          || regnum == S390_F6_REGNUM)
1733
        reg->how = DWARF2_FRAME_REG_SAME_VALUE;
1734
 
1735
      /* Call-clobbered registers.  */
1736
      else if ((regnum >= S390_R0_REGNUM && regnum <= S390_R5_REGNUM)
1737
               || (regnum >= S390_F0_REGNUM && regnum <= S390_F15_REGNUM
1738
                   && regnum != S390_F4_REGNUM && regnum != S390_F6_REGNUM))
1739
        reg->how = DWARF2_FRAME_REG_UNDEFINED;
1740
 
1741
      /* The return address column.  */
1742
      else if (regnum == S390_PC_REGNUM)
1743
        reg->how = DWARF2_FRAME_REG_RA;
1744
      break;
1745
 
1746
    case ABI_LINUX_ZSERIES:
1747
      /* Call-saved registers.  */
1748
      if ((regnum >= S390_R6_REGNUM && regnum <= S390_R15_REGNUM)
1749
          || (regnum >= S390_F8_REGNUM && regnum <= S390_F15_REGNUM))
1750
        reg->how = DWARF2_FRAME_REG_SAME_VALUE;
1751
 
1752
      /* Call-clobbered registers.  */
1753
      else if ((regnum >= S390_R0_REGNUM && regnum <= S390_R5_REGNUM)
1754
               || (regnum >= S390_F0_REGNUM && regnum <= S390_F7_REGNUM))
1755
        reg->how = DWARF2_FRAME_REG_UNDEFINED;
1756
 
1757
      /* The return address column.  */
1758
      else if (regnum == S390_PC_REGNUM)
1759
        reg->how = DWARF2_FRAME_REG_RA;
1760
      break;
1761
    }
1762
}
1763
 
1764
 
1765
/* Dummy function calls.  */
1766
 
1767
/* Return non-zero if TYPE is an integer-like type, zero otherwise.
1768
   "Integer-like" types are those that should be passed the way
1769
   integers are: integers, enums, ranges, characters, and booleans.  */
1770
static int
1771
is_integer_like (struct type *type)
1772
{
1773
  enum type_code code = TYPE_CODE (type);
1774
 
1775
  return (code == TYPE_CODE_INT
1776
          || code == TYPE_CODE_ENUM
1777
          || code == TYPE_CODE_RANGE
1778
          || code == TYPE_CODE_CHAR
1779
          || code == TYPE_CODE_BOOL);
1780
}
1781
 
1782
/* Return non-zero if TYPE is a pointer-like type, zero otherwise.
1783
   "Pointer-like" types are those that should be passed the way
1784
   pointers are: pointers and references.  */
1785
static int
1786
is_pointer_like (struct type *type)
1787
{
1788
  enum type_code code = TYPE_CODE (type);
1789
 
1790
  return (code == TYPE_CODE_PTR
1791
          || code == TYPE_CODE_REF);
1792
}
1793
 
1794
 
1795
/* Return non-zero if TYPE is a `float singleton' or `double
1796
   singleton', zero otherwise.
1797
 
1798
   A `T singleton' is a struct type with one member, whose type is
1799
   either T or a `T singleton'.  So, the following are all float
1800
   singletons:
1801
 
1802
   struct { float x };
1803
   struct { struct { float x; } x; };
1804
   struct { struct { struct { float x; } x; } x; };
1805
 
1806
   ... and so on.
1807
 
1808
   All such structures are passed as if they were floats or doubles,
1809
   as the (revised) ABI says.  */
1810
static int
1811
is_float_singleton (struct type *type)
1812
{
1813
  if (TYPE_CODE (type) == TYPE_CODE_STRUCT && TYPE_NFIELDS (type) == 1)
1814
    {
1815
      struct type *singleton_type = TYPE_FIELD_TYPE (type, 0);
1816
      CHECK_TYPEDEF (singleton_type);
1817
 
1818
      return (TYPE_CODE (singleton_type) == TYPE_CODE_FLT
1819
              || TYPE_CODE (singleton_type) == TYPE_CODE_DECFLOAT
1820
              || is_float_singleton (singleton_type));
1821
    }
1822
 
1823
  return 0;
1824
}
1825
 
1826
 
1827
/* Return non-zero if TYPE is a struct-like type, zero otherwise.
1828
   "Struct-like" types are those that should be passed as structs are:
1829
   structs and unions.
1830
 
1831
   As an odd quirk, not mentioned in the ABI, GCC passes float and
1832
   double singletons as if they were a plain float, double, etc.  (The
1833
   corresponding union types are handled normally.)  So we exclude
1834
   those types here.  *shrug* */
1835
static int
1836
is_struct_like (struct type *type)
1837
{
1838
  enum type_code code = TYPE_CODE (type);
1839
 
1840
  return (code == TYPE_CODE_UNION
1841
          || (code == TYPE_CODE_STRUCT && ! is_float_singleton (type)));
1842
}
1843
 
1844
 
1845
/* Return non-zero if TYPE is a float-like type, zero otherwise.
1846
   "Float-like" types are those that should be passed as
1847
   floating-point values are.
1848
 
1849
   You'd think this would just be floats, doubles, long doubles, etc.
1850
   But as an odd quirk, not mentioned in the ABI, GCC passes float and
1851
   double singletons as if they were a plain float, double, etc.  (The
1852
   corresponding union types are handled normally.)  So we include
1853
   those types here.  *shrug* */
1854
static int
1855
is_float_like (struct type *type)
1856
{
1857
  return (TYPE_CODE (type) == TYPE_CODE_FLT
1858
          || TYPE_CODE (type) == TYPE_CODE_DECFLOAT
1859
          || is_float_singleton (type));
1860
}
1861
 
1862
 
1863
static int
1864
is_power_of_two (unsigned int n)
1865
{
1866
  return ((n & (n - 1)) == 0);
1867
}
1868
 
1869
/* Return non-zero if TYPE should be passed as a pointer to a copy,
1870
   zero otherwise.  */
1871
static int
1872
s390_function_arg_pass_by_reference (struct type *type)
1873
{
1874
  unsigned length = TYPE_LENGTH (type);
1875
  if (length > 8)
1876
    return 1;
1877
 
1878
  /* FIXME: All complex and vector types are also returned by reference.  */
1879
  return is_struct_like (type) && !is_power_of_two (length);
1880
}
1881
 
1882
/* Return non-zero if TYPE should be passed in a float register
1883
   if possible.  */
1884
static int
1885
s390_function_arg_float (struct type *type)
1886
{
1887
  unsigned length = TYPE_LENGTH (type);
1888
  if (length > 8)
1889
    return 0;
1890
 
1891
  return is_float_like (type);
1892
}
1893
 
1894
/* Return non-zero if TYPE should be passed in an integer register
1895
   (or a pair of integer registers) if possible.  */
1896
static int
1897
s390_function_arg_integer (struct type *type)
1898
{
1899
  unsigned length = TYPE_LENGTH (type);
1900
  if (length > 8)
1901
    return 0;
1902
 
1903
   return is_integer_like (type)
1904
          || is_pointer_like (type)
1905
          || (is_struct_like (type) && is_power_of_two (length));
1906
}
1907
 
1908
/* Return ARG, a `SIMPLE_ARG', sign-extended or zero-extended to a full
1909
   word as required for the ABI.  */
1910
static LONGEST
1911
extend_simple_arg (struct value *arg)
1912
{
1913
  struct type *type = value_type (arg);
1914
 
1915
  /* Even structs get passed in the least significant bits of the
1916
     register / memory word.  It's not really right to extract them as
1917
     an integer, but it does take care of the extension.  */
1918
  if (TYPE_UNSIGNED (type))
1919
    return extract_unsigned_integer (value_contents (arg),
1920
                                     TYPE_LENGTH (type));
1921
  else
1922
    return extract_signed_integer (value_contents (arg),
1923
                                   TYPE_LENGTH (type));
1924
}
1925
 
1926
 
1927
/* Return the alignment required by TYPE.  */
1928
static int
1929
alignment_of (struct type *type)
1930
{
1931
  int alignment;
1932
 
1933
  if (is_integer_like (type)
1934
      || is_pointer_like (type)
1935
      || TYPE_CODE (type) == TYPE_CODE_FLT
1936
      || TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
1937
    alignment = TYPE_LENGTH (type);
1938
  else if (TYPE_CODE (type) == TYPE_CODE_STRUCT
1939
           || TYPE_CODE (type) == TYPE_CODE_UNION)
1940
    {
1941
      int i;
1942
 
1943
      alignment = 1;
1944
      for (i = 0; i < TYPE_NFIELDS (type); i++)
1945
        {
1946
          int field_alignment = alignment_of (TYPE_FIELD_TYPE (type, i));
1947
 
1948
          if (field_alignment > alignment)
1949
            alignment = field_alignment;
1950
        }
1951
    }
1952
  else
1953
    alignment = 1;
1954
 
1955
  /* Check that everything we ever return is a power of two.  Lots of
1956
     code doesn't want to deal with aligning things to arbitrary
1957
     boundaries.  */
1958
  gdb_assert ((alignment & (alignment - 1)) == 0);
1959
 
1960
  return alignment;
1961
}
1962
 
1963
 
1964
/* Put the actual parameter values pointed to by ARGS[0..NARGS-1] in
1965
   place to be passed to a function, as specified by the "GNU/Linux
1966
   for S/390 ELF Application Binary Interface Supplement".
1967
 
1968
   SP is the current stack pointer.  We must put arguments, links,
1969
   padding, etc. whereever they belong, and return the new stack
1970
   pointer value.
1971
 
1972
   If STRUCT_RETURN is non-zero, then the function we're calling is
1973
   going to return a structure by value; STRUCT_ADDR is the address of
1974
   a block we've allocated for it on the stack.
1975
 
1976
   Our caller has taken care of any type promotions needed to satisfy
1977
   prototypes or the old K&R argument-passing rules.  */
1978
static CORE_ADDR
1979
s390_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
1980
                      struct regcache *regcache, CORE_ADDR bp_addr,
1981
                      int nargs, struct value **args, CORE_ADDR sp,
1982
                      int struct_return, CORE_ADDR struct_addr)
1983
{
1984
  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1985
  int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1986
  ULONGEST orig_sp;
1987
  int i;
1988
 
1989
  /* If the i'th argument is passed as a reference to a copy, then
1990
     copy_addr[i] is the address of the copy we made.  */
1991
  CORE_ADDR *copy_addr = alloca (nargs * sizeof (CORE_ADDR));
1992
 
1993
  /* Build the reference-to-copy area.  */
1994
  for (i = 0; i < nargs; i++)
1995
    {
1996
      struct value *arg = args[i];
1997
      struct type *type = value_type (arg);
1998
      unsigned length = TYPE_LENGTH (type);
1999
 
2000
      if (s390_function_arg_pass_by_reference (type))
2001
        {
2002
          sp -= length;
2003
          sp = align_down (sp, alignment_of (type));
2004
          write_memory (sp, value_contents (arg), length);
2005
          copy_addr[i] = sp;
2006
        }
2007
    }
2008
 
2009
  /* Reserve space for the parameter area.  As a conservative
2010
     simplification, we assume that everything will be passed on the
2011
     stack.  Since every argument larger than 8 bytes will be
2012
     passed by reference, we use this simple upper bound.  */
2013
  sp -= nargs * 8;
2014
 
2015
  /* After all that, make sure it's still aligned on an eight-byte
2016
     boundary.  */
2017
  sp = align_down (sp, 8);
2018
 
2019
  /* Finally, place the actual parameters, working from SP towards
2020
     higher addresses.  The code above is supposed to reserve enough
2021
     space for this.  */
2022
  {
2023
    int fr = 0;
2024
    int gr = 2;
2025
    CORE_ADDR starg = sp;
2026
 
2027
    /* A struct is returned using general register 2.  */
2028
    if (struct_return)
2029
      {
2030
        regcache_cooked_write_unsigned (regcache, S390_R0_REGNUM + gr,
2031
                                        struct_addr);
2032
        gr++;
2033
      }
2034
 
2035
    for (i = 0; i < nargs; i++)
2036
      {
2037
        struct value *arg = args[i];
2038
        struct type *type = value_type (arg);
2039
        unsigned length = TYPE_LENGTH (type);
2040
 
2041
        if (s390_function_arg_pass_by_reference (type))
2042
          {
2043
            if (gr <= 6)
2044
              {
2045
                regcache_cooked_write_unsigned (regcache, S390_R0_REGNUM + gr,
2046
                                                copy_addr[i]);
2047
                gr++;
2048
              }
2049
            else
2050
              {
2051
                write_memory_unsigned_integer (starg, word_size, copy_addr[i]);
2052
                starg += word_size;
2053
              }
2054
          }
2055
        else if (s390_function_arg_float (type))
2056
          {
2057
            /* The GNU/Linux for S/390 ABI uses FPRs 0 and 2 to pass arguments,
2058
               the GNU/Linux for zSeries ABI uses 0, 2, 4, and 6.  */
2059
            if (fr <= (tdep->abi == ABI_LINUX_S390 ? 2 : 6))
2060
              {
2061
                /* When we store a single-precision value in an FP register,
2062
                   it occupies the leftmost bits.  */
2063
                regcache_cooked_write_part (regcache, S390_F0_REGNUM + fr,
2064
                                            0, length, value_contents (arg));
2065
                fr += 2;
2066
              }
2067
            else
2068
              {
2069
                /* When we store a single-precision value in a stack slot,
2070
                   it occupies the rightmost bits.  */
2071
                starg = align_up (starg + length, word_size);
2072
                write_memory (starg - length, value_contents (arg), length);
2073
              }
2074
          }
2075
        else if (s390_function_arg_integer (type) && length <= word_size)
2076
          {
2077
            if (gr <= 6)
2078
              {
2079
                /* Integer arguments are always extended to word size.  */
2080
                regcache_cooked_write_signed (regcache, S390_R0_REGNUM + gr,
2081
                                              extend_simple_arg (arg));
2082
                gr++;
2083
              }
2084
            else
2085
              {
2086
                /* Integer arguments are always extended to word size.  */
2087
                write_memory_signed_integer (starg, word_size,
2088
                                             extend_simple_arg (arg));
2089
                starg += word_size;
2090
              }
2091
          }
2092
        else if (s390_function_arg_integer (type) && length == 2*word_size)
2093
          {
2094
            if (gr <= 5)
2095
              {
2096
                regcache_cooked_write (regcache, S390_R0_REGNUM + gr,
2097
                                       value_contents (arg));
2098
                regcache_cooked_write (regcache, S390_R0_REGNUM + gr + 1,
2099
                                       value_contents (arg) + word_size);
2100
                gr += 2;
2101
              }
2102
            else
2103
              {
2104
                /* If we skipped r6 because we couldn't fit a DOUBLE_ARG
2105
                   in it, then don't go back and use it again later.  */
2106
                gr = 7;
2107
 
2108
                write_memory (starg, value_contents (arg), length);
2109
                starg += length;
2110
              }
2111
          }
2112
        else
2113
          internal_error (__FILE__, __LINE__, _("unknown argument type"));
2114
      }
2115
  }
2116
 
2117
  /* Allocate the standard frame areas: the register save area, the
2118
     word reserved for the compiler (which seems kind of meaningless),
2119
     and the back chain pointer.  */
2120
  sp -= 16*word_size + 32;
2121
 
2122
  /* Store return address.  */
2123
  regcache_cooked_write_unsigned (regcache, S390_RETADDR_REGNUM, bp_addr);
2124
 
2125
  /* Store updated stack pointer.  */
2126
  regcache_cooked_write_unsigned (regcache, S390_SP_REGNUM, sp);
2127
 
2128
  /* We need to return the 'stack part' of the frame ID,
2129
     which is actually the top of the register save area.  */
2130
  return sp + 16*word_size + 32;
2131
}
2132
 
2133
/* Assuming NEXT_FRAME->prev is a dummy, return the frame ID of that
2134
   dummy frame.  The frame ID's base needs to match the TOS value
2135
   returned by push_dummy_call, and the PC match the dummy frame's
2136
   breakpoint.  */
2137
static struct frame_id
2138
s390_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
2139
{
2140
  int word_size = gdbarch_ptr_bit (gdbarch) / 8;
2141
  CORE_ADDR sp = s390_unwind_sp (gdbarch, next_frame);
2142
 
2143
  return frame_id_build (sp + 16*word_size + 32,
2144
                         frame_pc_unwind (next_frame));
2145
}
2146
 
2147
static CORE_ADDR
2148
s390_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
2149
{
2150
  /* Both the 32- and 64-bit ABI's say that the stack pointer should
2151
     always be aligned on an eight-byte boundary.  */
2152
  return (addr & -8);
2153
}
2154
 
2155
 
2156
/* Function return value access.  */
2157
 
2158
static enum return_value_convention
2159
s390_return_value_convention (struct gdbarch *gdbarch, struct type *type)
2160
{
2161
  int length = TYPE_LENGTH (type);
2162
  if (length > 8)
2163
    return RETURN_VALUE_STRUCT_CONVENTION;
2164
 
2165
  switch (TYPE_CODE (type))
2166
    {
2167
    case TYPE_CODE_STRUCT:
2168
    case TYPE_CODE_UNION:
2169
    case TYPE_CODE_ARRAY:
2170
      return RETURN_VALUE_STRUCT_CONVENTION;
2171
 
2172
    default:
2173
      return RETURN_VALUE_REGISTER_CONVENTION;
2174
    }
2175
}
2176
 
2177
static enum return_value_convention
2178
s390_return_value (struct gdbarch *gdbarch, struct type *type,
2179
                   struct regcache *regcache, gdb_byte *out,
2180
                   const gdb_byte *in)
2181
{
2182
  int word_size = gdbarch_ptr_bit (gdbarch) / 8;
2183
  int length = TYPE_LENGTH (type);
2184
  enum return_value_convention rvc =
2185
                        s390_return_value_convention (gdbarch, type);
2186
  if (in)
2187
    {
2188
      switch (rvc)
2189
        {
2190
        case RETURN_VALUE_REGISTER_CONVENTION:
2191
          if (TYPE_CODE (type) == TYPE_CODE_FLT
2192
              || TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
2193
            {
2194
              /* When we store a single-precision value in an FP register,
2195
                 it occupies the leftmost bits.  */
2196
              regcache_cooked_write_part (regcache, S390_F0_REGNUM,
2197
                                          0, length, in);
2198
            }
2199
          else if (length <= word_size)
2200
            {
2201
              /* Integer arguments are always extended to word size.  */
2202
              if (TYPE_UNSIGNED (type))
2203
                regcache_cooked_write_unsigned (regcache, S390_R2_REGNUM,
2204
                        extract_unsigned_integer (in, length));
2205
              else
2206
                regcache_cooked_write_signed (regcache, S390_R2_REGNUM,
2207
                        extract_signed_integer (in, length));
2208
            }
2209
          else if (length == 2*word_size)
2210
            {
2211
              regcache_cooked_write (regcache, S390_R2_REGNUM, in);
2212
              regcache_cooked_write (regcache, S390_R3_REGNUM, in + word_size);
2213
            }
2214
          else
2215
            internal_error (__FILE__, __LINE__, _("invalid return type"));
2216
          break;
2217
 
2218
        case RETURN_VALUE_STRUCT_CONVENTION:
2219
          error (_("Cannot set function return value."));
2220
          break;
2221
        }
2222
    }
2223
  else if (out)
2224
    {
2225
      switch (rvc)
2226
        {
2227
        case RETURN_VALUE_REGISTER_CONVENTION:
2228
          if (TYPE_CODE (type) == TYPE_CODE_FLT
2229
              || TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
2230
            {
2231
              /* When we store a single-precision value in an FP register,
2232
                 it occupies the leftmost bits.  */
2233
              regcache_cooked_read_part (regcache, S390_F0_REGNUM,
2234
                                         0, length, out);
2235
            }
2236
          else if (length <= word_size)
2237
            {
2238
              /* Integer arguments occupy the rightmost bits.  */
2239
              regcache_cooked_read_part (regcache, S390_R2_REGNUM,
2240
                                         word_size - length, length, out);
2241
            }
2242
          else if (length == 2*word_size)
2243
            {
2244
              regcache_cooked_read (regcache, S390_R2_REGNUM, out);
2245
              regcache_cooked_read (regcache, S390_R3_REGNUM, out + word_size);
2246
            }
2247
          else
2248
            internal_error (__FILE__, __LINE__, _("invalid return type"));
2249
          break;
2250
 
2251
        case RETURN_VALUE_STRUCT_CONVENTION:
2252
          error (_("Function return value unknown."));
2253
          break;
2254
        }
2255
    }
2256
 
2257
  return rvc;
2258
}
2259
 
2260
 
2261
/* Breakpoints.  */
2262
 
2263
static const gdb_byte *
2264
s390_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
2265
{
2266
  static const gdb_byte breakpoint[] = { 0x0, 0x1 };
2267
 
2268
  *lenptr = sizeof (breakpoint);
2269
  return breakpoint;
2270
}
2271
 
2272
 
2273
/* Address handling.  */
2274
 
2275
static CORE_ADDR
2276
s390_addr_bits_remove (CORE_ADDR addr)
2277
{
2278
  return addr & 0x7fffffff;
2279
}
2280
 
2281
static int
2282
s390_address_class_type_flags (int byte_size, int dwarf2_addr_class)
2283
{
2284
  if (byte_size == 4)
2285
    return TYPE_FLAG_ADDRESS_CLASS_1;
2286
  else
2287
    return 0;
2288
}
2289
 
2290
static const char *
2291
s390_address_class_type_flags_to_name (struct gdbarch *gdbarch, int type_flags)
2292
{
2293
  if (type_flags & TYPE_FLAG_ADDRESS_CLASS_1)
2294
    return "mode32";
2295
  else
2296
    return NULL;
2297
}
2298
 
2299
static int
2300
s390_address_class_name_to_type_flags (struct gdbarch *gdbarch, const char *name,
2301
                                       int *type_flags_ptr)
2302
{
2303
  if (strcmp (name, "mode32") == 0)
2304
    {
2305
      *type_flags_ptr = TYPE_FLAG_ADDRESS_CLASS_1;
2306
      return 1;
2307
    }
2308
  else
2309
    return 0;
2310
}
2311
 
2312
/* Set up gdbarch struct.  */
2313
 
2314
static struct gdbarch *
2315
s390_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
2316
{
2317
  struct gdbarch *gdbarch;
2318
  struct gdbarch_tdep *tdep;
2319
 
2320
  /* First see if there is already a gdbarch that can satisfy the request.  */
2321
  arches = gdbarch_list_lookup_by_info (arches, &info);
2322
  if (arches != NULL)
2323
    return arches->gdbarch;
2324
 
2325
  /* None found: is the request for a s390 architecture? */
2326
  if (info.bfd_arch_info->arch != bfd_arch_s390)
2327
    return NULL;                /* No; then it's not for us.  */
2328
 
2329
  /* Yes: create a new gdbarch for the specified machine type.  */
2330
  tdep = XCALLOC (1, struct gdbarch_tdep);
2331
  gdbarch = gdbarch_alloc (&info, tdep);
2332
 
2333
  set_gdbarch_believe_pcc_promotion (gdbarch, 0);
2334
  set_gdbarch_char_signed (gdbarch, 0);
2335
 
2336
  /* S/390 GNU/Linux uses either 64-bit or 128-bit long doubles.
2337
     We can safely let them default to 128-bit, since the debug info
2338
     will give the size of type actually used in each case.  */
2339
  set_gdbarch_long_double_bit (gdbarch, 128);
2340
  set_gdbarch_long_double_format (gdbarch, floatformats_ia64_quad);
2341
 
2342
  /* Amount PC must be decremented by after a breakpoint.  This is
2343
     often the number of bytes returned by gdbarch_breakpoint_from_pc but not
2344
     always.  */
2345
  set_gdbarch_decr_pc_after_break (gdbarch, 2);
2346
  /* Stack grows downward.  */
2347
  set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
2348
  set_gdbarch_breakpoint_from_pc (gdbarch, s390_breakpoint_from_pc);
2349
  set_gdbarch_skip_prologue (gdbarch, s390_skip_prologue);
2350
  set_gdbarch_in_function_epilogue_p (gdbarch, s390_in_function_epilogue_p);
2351
 
2352
  set_gdbarch_pc_regnum (gdbarch, S390_PC_REGNUM);
2353
  set_gdbarch_sp_regnum (gdbarch, S390_SP_REGNUM);
2354
  set_gdbarch_fp0_regnum (gdbarch, S390_F0_REGNUM);
2355
  set_gdbarch_num_regs (gdbarch, S390_NUM_REGS);
2356
  set_gdbarch_num_pseudo_regs (gdbarch, S390_NUM_PSEUDO_REGS);
2357
  set_gdbarch_register_name (gdbarch, s390_register_name);
2358
  set_gdbarch_register_type (gdbarch, s390_register_type);
2359
  set_gdbarch_stab_reg_to_regnum (gdbarch, s390_dwarf_reg_to_regnum);
2360
  set_gdbarch_dwarf_reg_to_regnum (gdbarch, s390_dwarf_reg_to_regnum);
2361
  set_gdbarch_dwarf2_reg_to_regnum (gdbarch, s390_dwarf_reg_to_regnum);
2362
  set_gdbarch_value_from_register (gdbarch, s390_value_from_register);
2363
  set_gdbarch_register_reggroup_p (gdbarch, s390_register_reggroup_p);
2364
  set_gdbarch_regset_from_core_section (gdbarch,
2365
                                        s390_regset_from_core_section);
2366
 
2367
  /* Inferior function calls.  */
2368
  set_gdbarch_push_dummy_call (gdbarch, s390_push_dummy_call);
2369
  set_gdbarch_unwind_dummy_id (gdbarch, s390_unwind_dummy_id);
2370
  set_gdbarch_frame_align (gdbarch, s390_frame_align);
2371
  set_gdbarch_return_value (gdbarch, s390_return_value);
2372
 
2373
  /* Frame handling.  */
2374
  dwarf2_frame_set_init_reg (gdbarch, s390_dwarf2_frame_init_reg);
2375
  frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer);
2376
  frame_base_append_sniffer (gdbarch, dwarf2_frame_base_sniffer);
2377
  frame_unwind_append_sniffer (gdbarch, s390_stub_frame_sniffer);
2378
  frame_unwind_append_sniffer (gdbarch, s390_sigtramp_frame_sniffer);
2379
  frame_unwind_append_sniffer (gdbarch, s390_frame_sniffer);
2380
  frame_base_set_default (gdbarch, &s390_frame_base);
2381
  set_gdbarch_unwind_pc (gdbarch, s390_unwind_pc);
2382
  set_gdbarch_unwind_sp (gdbarch, s390_unwind_sp);
2383
 
2384
  switch (info.bfd_arch_info->mach)
2385
    {
2386
    case bfd_mach_s390_31:
2387
      tdep->abi = ABI_LINUX_S390;
2388
 
2389
      tdep->gregset = &s390_gregset;
2390
      tdep->sizeof_gregset = s390_sizeof_gregset;
2391
      tdep->fpregset = &s390_fpregset;
2392
      tdep->sizeof_fpregset = s390_sizeof_fpregset;
2393
 
2394
      set_gdbarch_addr_bits_remove (gdbarch, s390_addr_bits_remove);
2395
      set_gdbarch_pseudo_register_read (gdbarch, s390_pseudo_register_read);
2396
      set_gdbarch_pseudo_register_write (gdbarch, s390_pseudo_register_write);
2397
      set_solib_svr4_fetch_link_map_offsets
2398
        (gdbarch, svr4_ilp32_fetch_link_map_offsets);
2399
 
2400
      break;
2401
    case bfd_mach_s390_64:
2402
      tdep->abi = ABI_LINUX_ZSERIES;
2403
 
2404
      tdep->gregset = &s390x_gregset;
2405
      tdep->sizeof_gregset = s390x_sizeof_gregset;
2406
      tdep->fpregset = &s390_fpregset;
2407
      tdep->sizeof_fpregset = s390_sizeof_fpregset;
2408
 
2409
      set_gdbarch_long_bit (gdbarch, 64);
2410
      set_gdbarch_long_long_bit (gdbarch, 64);
2411
      set_gdbarch_ptr_bit (gdbarch, 64);
2412
      set_gdbarch_pseudo_register_read (gdbarch, s390x_pseudo_register_read);
2413
      set_gdbarch_pseudo_register_write (gdbarch, s390x_pseudo_register_write);
2414
      set_solib_svr4_fetch_link_map_offsets
2415
        (gdbarch, svr4_lp64_fetch_link_map_offsets);
2416
      set_gdbarch_address_class_type_flags (gdbarch,
2417
                                            s390_address_class_type_flags);
2418
      set_gdbarch_address_class_type_flags_to_name (gdbarch,
2419
                                                    s390_address_class_type_flags_to_name);
2420
      set_gdbarch_address_class_name_to_type_flags (gdbarch,
2421
                                                    s390_address_class_name_to_type_flags);
2422
      break;
2423
    }
2424
 
2425
  set_gdbarch_print_insn (gdbarch, print_insn_s390);
2426
 
2427
  set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
2428
 
2429
  /* Enable TLS support.  */
2430
  set_gdbarch_fetch_tls_load_module_address (gdbarch,
2431
                                             svr4_fetch_objfile_link_map);
2432
 
2433
  return gdbarch;
2434
}
2435
 
2436
 
2437
 
2438
extern initialize_file_ftype _initialize_s390_tdep; /* -Wmissing-prototypes */
2439
 
2440
void
2441
_initialize_s390_tdep (void)
2442
{
2443
 
2444
  /* Hook us into the gdbarch mechanism.  */
2445
  register_gdbarch_init (bfd_arch_s390, s390_gdbarch_init);
2446
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.