gdb/s390-linux-tdep.c

   1 /* Target-dependent code for GDB, the GNU debugger.
   2
   3    Copyright (C) 2001-2014 Free Software Foundation, Inc.
   4
   5    Contributed by D.J. Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
   6    for IBM Deutschland Entwicklung GmbH, IBM Corporation.
   7
   8    This file is part of GDB.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  22
  23 #include "defs.h"
  24 #include "arch-utils.h"
  25 #include "frame.h"
  26 #include "inferior.h"
  27 #include "infrun.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 "dis-asm.h"
  43 #include "solib-svr4.h"
  44 #include "prologue-value.h"
  45 #include "linux-tdep.h"
  46 #include "s390-linux-tdep.h"
  47 #include "auxv.h"
  48 #include "xml-syscall.h"
  49
  50 #include "stap-probe.h"
  51 #include "ax.h"
  52 #include "ax-gdb.h"
  53 #include "user-regs.h"
  54 #include "cli/cli-utils.h"
  55 #include <ctype.h>
  56 #include "elf/common.h"
  57
  58 #include "features/s390-linux32.c"
  59 #include "features/s390-linux32v1.c"
  60 #include "features/s390-linux32v2.c"
  61 #include "features/s390-linux64.c"
  62 #include "features/s390-linux64v1.c"
  63 #include "features/s390-linux64v2.c"
  64 #include "features/s390-te-linux64.c"
  65 #include "features/s390x-linux64.c"
  66 #include "features/s390x-linux64v1.c"
  67 #include "features/s390x-linux64v2.c"
  68 #include "features/s390x-te-linux64.c"
  69
  70 #define XML_SYSCALL_FILENAME_S390 "syscalls/s390-linux.xml"
  71 #define XML_SYSCALL_FILENAME_S390X "syscalls/s390x-linux.xml"
  72
  73 /* The tdep structure.  */
  74
  75 struct gdbarch_tdep
  76 {
  77   /* ABI version.  */
  78   enum { ABI_LINUX_S390, ABI_LINUX_ZSERIES } abi;
  79
  80   /* Pseudo register numbers.  */
  81   int gpr_full_regnum;
  82   int pc_regnum;
  83   int cc_regnum;
  84
  85   int have_linux_v1;
  86   int have_linux_v2;
  87   int have_tdb;
  88 };
  89
  90
  91 /* ABI call-saved register information.  */
  92
  93 static int
  94 s390_register_call_saved (struct gdbarch *gdbarch, int regnum)
  95 {
  96   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
  97
  98   switch (tdep->abi)
  99     {
 100     case ABI_LINUX_S390:
 101       if ((regnum >= S390_R6_REGNUM && regnum <= S390_R15_REGNUM)
 102           || regnum == S390_F4_REGNUM || regnum == S390_F6_REGNUM
 103           || regnum == S390_A0_REGNUM)
 104         return 1;
 105
 106       break;
 107
 108     case ABI_LINUX_ZSERIES:
 109       if ((regnum >= S390_R6_REGNUM && regnum <= S390_R15_REGNUM)
 110           || (regnum >= S390_F8_REGNUM && regnum <= S390_F15_REGNUM)
 111           || (regnum >= S390_A0_REGNUM && regnum <= S390_A1_REGNUM))
 112         return 1;
 113
 114       break;
 115     }
 116
 117   return 0;
 118 }
 119
 120 static int
 121 s390_cannot_store_register (struct gdbarch *gdbarch, int regnum)
 122 {
 123   /* The last-break address is read-only.  */
 124   return regnum == S390_LAST_BREAK_REGNUM;
 125 }
 126
 127 static void
 128 s390_write_pc (struct regcache *regcache, CORE_ADDR pc)
 129 {
 130   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 131   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 132
 133   regcache_cooked_write_unsigned (regcache, tdep->pc_regnum, pc);
 134
 135   /* Set special SYSTEM_CALL register to 0 to prevent the kernel from
 136      messing with the PC we just installed, if we happen to be within
 137      an interrupted system call that the kernel wants to restart.
 138
 139      Note that after we return from the dummy call, the SYSTEM_CALL and
 140      ORIG_R2 registers will be automatically restored, and the kernel
 141      continues to restart the system call at this point.  */
 142   if (register_size (gdbarch, S390_SYSTEM_CALL_REGNUM) > 0)
 143     regcache_cooked_write_unsigned (regcache, S390_SYSTEM_CALL_REGNUM, 0);
 144 }
 145
 146
 147 /* DWARF Register Mapping.  */
 148
 149 static const short s390_dwarf_regmap[] =
 150 {
 151   /* General Purpose Registers.  */
 152   S390_R0_REGNUM, S390_R1_REGNUM, S390_R2_REGNUM, S390_R3_REGNUM,
 153   S390_R4_REGNUM, S390_R5_REGNUM, S390_R6_REGNUM, S390_R7_REGNUM,
 154   S390_R8_REGNUM, S390_R9_REGNUM, S390_R10_REGNUM, S390_R11_REGNUM,
 155   S390_R12_REGNUM, S390_R13_REGNUM, S390_R14_REGNUM, S390_R15_REGNUM,
 156
 157   /* Floating Point Registers.  */
 158   S390_F0_REGNUM, S390_F2_REGNUM, S390_F4_REGNUM, S390_F6_REGNUM,
 159   S390_F1_REGNUM, S390_F3_REGNUM, S390_F5_REGNUM, S390_F7_REGNUM,
 160   S390_F8_REGNUM, S390_F10_REGNUM, S390_F12_REGNUM, S390_F14_REGNUM,
 161   S390_F9_REGNUM, S390_F11_REGNUM, S390_F13_REGNUM, S390_F15_REGNUM,
 162
 163   /* Control Registers (not mapped).  */
 164   -1, -1, -1, -1, -1, -1, -1, -1,
 165   -1, -1, -1, -1, -1, -1, -1, -1,
 166
 167   /* Access Registers.  */
 168   S390_A0_REGNUM, S390_A1_REGNUM, S390_A2_REGNUM, S390_A3_REGNUM,
 169   S390_A4_REGNUM, S390_A5_REGNUM, S390_A6_REGNUM, S390_A7_REGNUM,
 170   S390_A8_REGNUM, S390_A9_REGNUM, S390_A10_REGNUM, S390_A11_REGNUM,
 171   S390_A12_REGNUM, S390_A13_REGNUM, S390_A14_REGNUM, S390_A15_REGNUM,
 172
 173   /* Program Status Word.  */
 174   S390_PSWM_REGNUM,
 175   S390_PSWA_REGNUM,
 176
 177   /* GPR Lower Half Access.  */
 178   S390_R0_REGNUM, S390_R1_REGNUM, S390_R2_REGNUM, S390_R3_REGNUM,
 179   S390_R4_REGNUM, S390_R5_REGNUM, S390_R6_REGNUM, S390_R7_REGNUM,
 180   S390_R8_REGNUM, S390_R9_REGNUM, S390_R10_REGNUM, S390_R11_REGNUM,
 181   S390_R12_REGNUM, S390_R13_REGNUM, S390_R14_REGNUM, S390_R15_REGNUM,
 182
 183   /* GNU/Linux-specific registers (not mapped).  */
 184   -1, -1, -1,
 185 };
 186
 187 /* Convert DWARF register number REG to the appropriate register
 188    number used by GDB.  */
 189 static int
 190 s390_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int reg)
 191 {
 192   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 193
 194   /* In a 32-on-64 debug scenario, debug info refers to the full 64-bit
 195      GPRs.  Note that call frame information still refers to the 32-bit
 196      lower halves, because s390_adjust_frame_regnum uses register numbers
 197      66 .. 81 to access GPRs.  */
 198   if (tdep->gpr_full_regnum != -1 && reg >= 0 && reg < 16)
 199     return tdep->gpr_full_regnum + reg;
 200
 201   if (reg >= 0 && reg < ARRAY_SIZE (s390_dwarf_regmap))
 202     return s390_dwarf_regmap[reg];
 203
 204   warning (_("Unmapped DWARF Register #%d encountered."), reg);
 205   return -1;
 206 }
 207
 208 /* Translate a .eh_frame register to DWARF register, or adjust a
 209    .debug_frame register.  */
 210 static int
 211 s390_adjust_frame_regnum (struct gdbarch *gdbarch, int num, int eh_frame_p)
 212 {
 213   /* See s390_dwarf_reg_to_regnum for comments.  */
 214   return (num >= 0 && num < 16)? num + 66 : num;
 215 }
 216
 217
 218 /* Pseudo registers.  */
 219
 220 static int
 221 regnum_is_gpr_full (struct gdbarch_tdep *tdep, int regnum)
 222 {
 223   return (tdep->gpr_full_regnum != -1
 224           && regnum >= tdep->gpr_full_regnum
 225           && regnum <= tdep->gpr_full_regnum + 15);
 226 }
 227
 228 static const char *
 229 s390_pseudo_register_name (struct gdbarch *gdbarch, int regnum)
 230 {
 231   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 232
 233   if (regnum == tdep->pc_regnum)
 234     return "pc";
 235
 236   if (regnum == tdep->cc_regnum)
 237     return "cc";
 238
 239   if (regnum_is_gpr_full (tdep, regnum))
 240     {
 241       static const char *full_name[] = {
 242         "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
 243         "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
 244       };
 245       return full_name[regnum - tdep->gpr_full_regnum];
 246     }
 247
 248   internal_error (__FILE__, __LINE__, _("invalid regnum"));
 249 }
 250
 251 static struct type *
 252 s390_pseudo_register_type (struct gdbarch *gdbarch, int regnum)
 253 {
 254   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 255
 256   if (regnum == tdep->pc_regnum)
 257     return builtin_type (gdbarch)->builtin_func_ptr;
 258
 259   if (regnum == tdep->cc_regnum)
 260     return builtin_type (gdbarch)->builtin_int;
 261
 262   if (regnum_is_gpr_full (tdep, regnum))
 263     return builtin_type (gdbarch)->builtin_uint64;
 264
 265   internal_error (__FILE__, __LINE__, _("invalid regnum"));
 266 }
 267
 268 static enum register_status
 269 s390_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
 270                            int regnum, gdb_byte *buf)
 271 {
 272   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 273   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 274   int regsize = register_size (gdbarch, regnum);
 275   ULONGEST val;
 276
 277   if (regnum == tdep->pc_regnum)
 278     {
 279       enum register_status status;
 280
 281       status = regcache_raw_read_unsigned (regcache, S390_PSWA_REGNUM, &val);
 282       if (status == REG_VALID)
 283         {
 284           if (register_size (gdbarch, S390_PSWA_REGNUM) == 4)
 285             val &= 0x7fffffff;
 286           store_unsigned_integer (buf, regsize, byte_order, val);
 287         }
 288       return status;
 289     }
 290
 291   if (regnum == tdep->cc_regnum)
 292     {
 293       enum register_status status;
 294
 295       status = regcache_raw_read_unsigned (regcache, S390_PSWM_REGNUM, &val);
 296       if (status == REG_VALID)
 297         {
 298           if (register_size (gdbarch, S390_PSWA_REGNUM) == 4)
 299             val = (val >> 12) & 3;
 300           else
 301             val = (val >> 44) & 3;
 302           store_unsigned_integer (buf, regsize, byte_order, val);
 303         }
 304       return status;
 305     }
 306
 307   if (regnum_is_gpr_full (tdep, regnum))
 308     {
 309       enum register_status status;
 310       ULONGEST val_upper;
 311
 312       regnum -= tdep->gpr_full_regnum;
 313
 314       status = regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + regnum, &val);
 315       if (status == REG_VALID)
 316         status = regcache_raw_read_unsigned (regcache, S390_R0_UPPER_REGNUM + regnum,
 317                                              &val_upper);
 318       if (status == REG_VALID)
 319         {
 320           val |= val_upper << 32;
 321           store_unsigned_integer (buf, regsize, byte_order, val);
 322         }
 323       return status;
 324     }
 325
 326   internal_error (__FILE__, __LINE__, _("invalid regnum"));
 327 }
 328
 329 static void
 330 s390_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
 331                             int regnum, const gdb_byte *buf)
 332 {
 333   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 334   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 335   int regsize = register_size (gdbarch, regnum);
 336   ULONGEST val, psw;
 337
 338   if (regnum == tdep->pc_regnum)
 339     {
 340       val = extract_unsigned_integer (buf, regsize, byte_order);
 341       if (register_size (gdbarch, S390_PSWA_REGNUM) == 4)
 342         {
 343           regcache_raw_read_unsigned (regcache, S390_PSWA_REGNUM, &psw);
 344           val = (psw & 0x80000000) | (val & 0x7fffffff);
 345         }
 346       regcache_raw_write_unsigned (regcache, S390_PSWA_REGNUM, val);
 347       return;
 348     }
 349
 350   if (regnum == tdep->cc_regnum)
 351     {
 352       val = extract_unsigned_integer (buf, regsize, byte_order);
 353       regcache_raw_read_unsigned (regcache, S390_PSWM_REGNUM, &psw);
 354       if (register_size (gdbarch, S390_PSWA_REGNUM) == 4)
 355         val = (psw & ~((ULONGEST)3 << 12)) | ((val & 3) << 12);
 356       else
 357         val = (psw & ~((ULONGEST)3 << 44)) | ((val & 3) << 44);
 358       regcache_raw_write_unsigned (regcache, S390_PSWM_REGNUM, val);
 359       return;
 360     }
 361
 362   if (regnum_is_gpr_full (tdep, regnum))
 363     {
 364       regnum -= tdep->gpr_full_regnum;
 365       val = extract_unsigned_integer (buf, regsize, byte_order);
 366       regcache_raw_write_unsigned (regcache, S390_R0_REGNUM + regnum,
 367                                    val & 0xffffffff);
 368       regcache_raw_write_unsigned (regcache, S390_R0_UPPER_REGNUM + regnum,
 369                                    val >> 32);
 370       return;
 371     }
 372
 373   internal_error (__FILE__, __LINE__, _("invalid regnum"));
 374 }
 375
 376 /* 'float' values are stored in the upper half of floating-point
 377    registers, even though we are otherwise a big-endian platform.  */
 378
 379 static struct value *
 380 s390_value_from_register (struct gdbarch *gdbarch, struct type *type,
 381                           int regnum, struct frame_id frame_id)
 382 {
 383   struct value *value = default_value_from_register (gdbarch, type,
 384                                                      regnum, frame_id);
 385   check_typedef (type);
 386
 387   if (regnum >= S390_F0_REGNUM && regnum <= S390_F15_REGNUM
 388       && TYPE_LENGTH (type) < 8)
 389     set_value_offset (value, 0);
 390
 391   return value;
 392 }
 393
 394 /* Register groups.  */
 395
 396 static int
 397 s390_pseudo_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
 398                                  struct reggroup *group)
 399 {
 400   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 401
 402   /* We usually save/restore the whole PSW, which includes PC and CC.
 403      However, some older gdbservers may not support saving/restoring
 404      the whole PSW yet, and will return an XML register description
 405      excluding those from the save/restore register groups.  In those
 406      cases, we still need to explicitly save/restore PC and CC in order
 407      to push or pop frames.  Since this doesn't hurt anything if we
 408      already save/restore the whole PSW (it's just redundant), we add
 409      PC and CC at this point unconditionally.  */
 410   if (group == save_reggroup || group == restore_reggroup)
 411     return regnum == tdep->pc_regnum || regnum == tdep->cc_regnum;
 412
 413   return default_register_reggroup_p (gdbarch, regnum, group);
 414 }
 415
 416
 417 /* Maps for register sets.  */
 418
 419 static const struct regcache_map_entry s390_gregmap[] =
 420   {
 421     { 1, S390_PSWM_REGNUM },
 422     { 1, S390_PSWA_REGNUM },
 423     { 16, S390_R0_REGNUM },
 424     { 16, S390_A0_REGNUM },
 425     { 1, S390_ORIG_R2_REGNUM },
 426     { 0 }
 427   };
 428
 429 static const struct regcache_map_entry s390_fpregmap[] =
 430   {
 431     { 1, S390_FPC_REGNUM, 8 },
 432     { 16, S390_F0_REGNUM, 8 },
 433     { 0 }
 434   };
 435
 436 static const struct regcache_map_entry s390_regmap_upper[] =
 437   {
 438     { 16, S390_R0_UPPER_REGNUM, 4 },
 439     { 0 }
 440   };
 441
 442 static const struct regcache_map_entry s390_regmap_last_break[] =
 443   {
 444     { 1, REGCACHE_MAP_SKIP, 4 },
 445     { 1, S390_LAST_BREAK_REGNUM, 4 },
 446     { 0 }
 447   };
 448
 449 static const struct regcache_map_entry s390x_regmap_last_break[] =
 450   {
 451     { 1, S390_LAST_BREAK_REGNUM, 8 },
 452     { 0 }
 453   };
 454
 455 static const struct regcache_map_entry s390_regmap_system_call[] =
 456   {
 457     { 1, S390_SYSTEM_CALL_REGNUM, 4 },
 458     { 0 }
 459   };
 460
 461 static const struct regcache_map_entry s390_regmap_tdb[] =
 462   {
 463     { 1, S390_TDB_DWORD0_REGNUM, 8 },
 464     { 1, S390_TDB_ABORT_CODE_REGNUM, 8 },
 465     { 1, S390_TDB_CONFLICT_TOKEN_REGNUM, 8 },
 466     { 1, S390_TDB_ATIA_REGNUM, 8 },
 467     { 12, REGCACHE_MAP_SKIP, 8 },
 468     { 16, S390_TDB_R0_REGNUM, 8 },
 469     { 0 }
 470   };
 471
 472
 473 /* Supply the TDB regset.  Like regcache_supply_regset, but invalidate
 474    the TDB registers unless the TDB format field is valid.  */
 475
 476 static void
 477 s390_supply_tdb_regset (const struct regset *regset, struct regcache *regcache,
 478                     int regnum, const void *regs, size_t len)
 479 {
 480   ULONGEST tdw;
 481   enum register_status ret;
 482   int i;
 483
 484   regcache_supply_regset (regset, regcache, regnum, regs, len);
 485   ret = regcache_cooked_read_unsigned (regcache, S390_TDB_DWORD0_REGNUM, &tdw);
 486   if (ret != REG_VALID || (tdw >> 56) != 1)
 487     regcache_supply_regset (regset, regcache, regnum, NULL, len);
 488 }
 489
 490 const struct regset s390_gregset = {
 491   s390_gregmap,
 492   regcache_supply_regset,
 493   regcache_collect_regset
 494 };
 495
 496 const struct regset s390_fpregset = {
 497   s390_fpregmap,
 498   regcache_supply_regset,
 499   regcache_collect_regset
 500 };
 501
 502 static const struct regset s390_upper_regset = {
 503   s390_regmap_upper,
 504   regcache_supply_regset,
 505   regcache_collect_regset
 506 };
 507
 508 const struct regset s390_last_break_regset = {
 509   s390_regmap_last_break,
 510   regcache_supply_regset,
 511   regcache_collect_regset
 512 };
 513
 514 const struct regset s390x_last_break_regset = {
 515   s390x_regmap_last_break,
 516   regcache_supply_regset,
 517   regcache_collect_regset
 518 };
 519
 520 const struct regset s390_system_call_regset = {
 521   s390_regmap_system_call,
 522   regcache_supply_regset,
 523   regcache_collect_regset
 524 };
 525
 526 const struct regset s390_tdb_regset = {
 527   s390_regmap_tdb,
 528   s390_supply_tdb_regset,
 529   regcache_collect_regset
 530 };
 531
 532 /* Iterate over supported core file register note sections. */
 533
 534 static void
 535 s390_iterate_over_regset_sections (struct gdbarch *gdbarch,
 536                                    iterate_over_regset_sections_cb *cb,
 537                                    void *cb_data,
 538                                    const struct regcache *regcache)
 539 {
 540   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 541   const int gregset_size = (tdep->abi == ABI_LINUX_S390 ?
 542                             s390_sizeof_gregset : s390x_sizeof_gregset);
 543
 544   cb (".reg", gregset_size, &s390_gregset, NULL, cb_data);
 545   cb (".reg2", s390_sizeof_fpregset, &s390_fpregset, NULL, cb_data);
 546
 547   if (tdep->abi == ABI_LINUX_S390 && tdep->gpr_full_regnum != -1)
 548     cb (".reg-s390-high-gprs", 16 * 4, &s390_upper_regset,
 549         "s390 GPR upper halves", cb_data);
 550
 551   if (tdep->have_linux_v1)
 552     cb (".reg-s390-last-break", 8,
 553         (gdbarch_ptr_bit (gdbarch) == 32
 554          ? &s390_last_break_regset : &s390x_last_break_regset),
 555         "s930 last-break address", cb_data);
 556
 557   if (tdep->have_linux_v2)
 558     cb (".reg-s390-system-call", 4, &s390_system_call_regset,
 559         "s390 system-call", cb_data);
 560
 561   /* If regcache is set, we are in "write" (gcore) mode.  In this
 562      case, don't iterate over the TDB unless its registers are
 563      available.  */
 564   if (tdep->have_tdb
 565       && (regcache == NULL
 566           || REG_VALID == regcache_register_status (regcache,
 567                                                     S390_TDB_DWORD0_REGNUM)))
 568     cb (".reg-s390-tdb", s390_sizeof_tdbregset, &s390_tdb_regset,
 569         "s390 TDB", cb_data);
 570 }
 571
 572 static const struct target_desc *
 573 s390_core_read_description (struct gdbarch *gdbarch,
 574                             struct target_ops *target, bfd *abfd)
 575 {
 576   asection *high_gprs = bfd_get_section_by_name (abfd, ".reg-s390-high-gprs");
 577   asection *v1 = bfd_get_section_by_name (abfd, ".reg-s390-last-break");
 578   asection *v2 = bfd_get_section_by_name (abfd, ".reg-s390-system-call");
 579   asection *section = bfd_get_section_by_name (abfd, ".reg");
 580   CORE_ADDR hwcap = 0;
 581
 582   target_auxv_search (target, AT_HWCAP, &hwcap);
 583   if (!section)
 584     return NULL;
 585
 586   switch (bfd_section_size (abfd, section))
 587     {
 588     case s390_sizeof_gregset:
 589       if (high_gprs)
 590         return ((hwcap & HWCAP_S390_TE) ? tdesc_s390_te_linux64 :
 591                 v2? tdesc_s390_linux64v2 :
 592                 v1? tdesc_s390_linux64v1 : tdesc_s390_linux64);
 593       else
 594         return (v2? tdesc_s390_linux32v2 :
 595                 v1? tdesc_s390_linux32v1 : tdesc_s390_linux32);
 596
 597     case s390x_sizeof_gregset:
 598       return ((hwcap & HWCAP_S390_TE) ? tdesc_s390x_te_linux64 :
 599               v2? tdesc_s390x_linux64v2 :
 600               v1? tdesc_s390x_linux64v1 : tdesc_s390x_linux64);
 601
 602     default:
 603       return NULL;
 604     }
 605 }
 606
 607
 608 /* Decoding S/390 instructions.  */
 609
 610 /* Named opcode values for the S/390 instructions we recognize.  Some
 611    instructions have their opcode split across two fields; those are the
 612    op1_* and op2_* enums.  */
 613 enum
 614   {
 615     op1_lhi  = 0xa7,   op2_lhi  = 0x08,
 616     op1_lghi = 0xa7,   op2_lghi = 0x09,
 617     op1_lgfi = 0xc0,   op2_lgfi = 0x01,
 618     op_lr    = 0x18,
 619     op_lgr   = 0xb904,
 620     op_l     = 0x58,
 621     op1_ly   = 0xe3,   op2_ly   = 0x58,
 622     op1_lg   = 0xe3,   op2_lg   = 0x04,
 623     op_lm    = 0x98,
 624     op1_lmy  = 0xeb,   op2_lmy  = 0x98,
 625     op1_lmg  = 0xeb,   op2_lmg  = 0x04,
 626     op_st    = 0x50,
 627     op1_sty  = 0xe3,   op2_sty  = 0x50,
 628     op1_stg  = 0xe3,   op2_stg  = 0x24,
 629     op_std   = 0x60,
 630     op_stm   = 0x90,
 631     op1_stmy = 0xeb,   op2_stmy = 0x90,
 632     op1_stmg = 0xeb,   op2_stmg = 0x24,
 633     op1_aghi = 0xa7,   op2_aghi = 0x0b,
 634     op1_ahi  = 0xa7,   op2_ahi  = 0x0a,
 635     op1_agfi = 0xc2,   op2_agfi = 0x08,
 636     op1_afi  = 0xc2,   op2_afi  = 0x09,
 637     op1_algfi= 0xc2,   op2_algfi= 0x0a,
 638     op1_alfi = 0xc2,   op2_alfi = 0x0b,
 639     op_ar    = 0x1a,
 640     op_agr   = 0xb908,
 641     op_a     = 0x5a,
 642     op1_ay   = 0xe3,   op2_ay   = 0x5a,
 643     op1_ag   = 0xe3,   op2_ag   = 0x08,
 644     op1_slgfi= 0xc2,   op2_slgfi= 0x04,
 645     op1_slfi = 0xc2,   op2_slfi = 0x05,
 646     op_sr    = 0x1b,
 647     op_sgr   = 0xb909,
 648     op_s     = 0x5b,
 649     op1_sy   = 0xe3,   op2_sy   = 0x5b,
 650     op1_sg   = 0xe3,   op2_sg   = 0x09,
 651     op_nr    = 0x14,
 652     op_ngr   = 0xb980,
 653     op_la    = 0x41,
 654     op1_lay  = 0xe3,   op2_lay  = 0x71,
 655     op1_larl = 0xc0,   op2_larl = 0x00,
 656     op_basr  = 0x0d,
 657     op_bas   = 0x4d,
 658     op_bcr   = 0x07,
 659     op_bc    = 0x0d,
 660     op_bctr  = 0x06,
 661     op_bctgr = 0xb946,
 662     op_bct   = 0x46,
 663     op1_bctg = 0xe3,   op2_bctg = 0x46,
 664     op_bxh   = 0x86,
 665     op1_bxhg = 0xeb,   op2_bxhg = 0x44,
 666     op_bxle  = 0x87,
 667     op1_bxleg= 0xeb,   op2_bxleg= 0x45,
 668     op1_bras = 0xa7,   op2_bras = 0x05,
 669     op1_brasl= 0xc0,   op2_brasl= 0x05,
 670     op1_brc  = 0xa7,   op2_brc  = 0x04,
 671     op1_brcl = 0xc0,   op2_brcl = 0x04,
 672     op1_brct = 0xa7,   op2_brct = 0x06,
 673     op1_brctg= 0xa7,   op2_brctg= 0x07,
 674     op_brxh  = 0x84,
 675     op1_brxhg= 0xec,   op2_brxhg= 0x44,
 676     op_brxle = 0x85,
 677     op1_brxlg= 0xec,   op2_brxlg= 0x45,
 678     op_svc   = 0x0a,
 679   };
 680
 681
 682 /* Read a single instruction from address AT.  */
 683
 684 #define S390_MAX_INSTR_SIZE 6
 685 static int
 686 s390_readinstruction (bfd_byte instr[], CORE_ADDR at)
 687 {
 688   static int s390_instrlen[] = { 2, 4, 4, 6 };
 689   int instrlen;
 690
 691   if (target_read_memory (at, &instr[0], 2))
 692     return -1;
 693   instrlen = s390_instrlen[instr[0] >> 6];
 694   if (instrlen > 2)
 695     {
 696       if (target_read_memory (at + 2, &instr[2], instrlen - 2))
 697         return -1;
 698     }
 699   return instrlen;
 700 }
 701
 702
 703 /* The functions below are for recognizing and decoding S/390
 704    instructions of various formats.  Each of them checks whether INSN
 705    is an instruction of the given format, with the specified opcodes.
 706    If it is, it sets the remaining arguments to the values of the
 707    instruction's fields, and returns a non-zero value; otherwise, it
 708    returns zero.
 709
 710    These functions' arguments appear in the order they appear in the
 711    instruction, not in the machine-language form.  So, opcodes always
 712    come first, even though they're sometimes scattered around the
 713    instructions.  And displacements appear before base and extension
 714    registers, as they do in the assembly syntax, not at the end, as
 715    they do in the machine language.  */
 716 static int
 717 is_ri (bfd_byte *insn, int op1, int op2, unsigned int *r1, int *i2)
 718 {
 719   if (insn[0] == op1 && (insn[1] & 0xf) == op2)
 720     {
 721       *r1 = (insn[1] >> 4) & 0xf;
 722       /* i2 is a 16-bit signed quantity.  */
 723       *i2 = (((insn[2] << 8) | insn[3]) ^ 0x8000) - 0x8000;
 724       return 1;
 725     }
 726   else
 727     return 0;
 728 }
 729
 730
 731 static int
 732 is_ril (bfd_byte *insn, int op1, int op2,
 733         unsigned int *r1, int *i2)
 734 {
 735   if (insn[0] == op1 && (insn[1] & 0xf) == op2)
 736     {
 737       *r1 = (insn[1] >> 4) & 0xf;
 738       /* i2 is a signed quantity.  If the host 'int' is 32 bits long,
 739          no sign extension is necessary, but we don't want to assume
 740          that.  */
 741       *i2 = (((insn[2] << 24)
 742               | (insn[3] << 16)
 743               | (insn[4] << 8)
 744               | (insn[5])) ^ 0x80000000) - 0x80000000;
 745       return 1;
 746     }
 747   else
 748     return 0;
 749 }
 750
 751
 752 static int
 753 is_rr (bfd_byte *insn, int op, unsigned int *r1, unsigned int *r2)
 754 {
 755   if (insn[0] == op)
 756     {
 757       *r1 = (insn[1] >> 4) & 0xf;
 758       *r2 = insn[1] & 0xf;
 759       return 1;
 760     }
 761   else
 762     return 0;
 763 }
 764
 765
 766 static int
 767 is_rre (bfd_byte *insn, int op, unsigned int *r1, unsigned int *r2)
 768 {
 769   if (((insn[0] << 8) | insn[1]) == op)
 770     {
 771       /* Yes, insn[3].  insn[2] is unused in RRE format.  */
 772       *r1 = (insn[3] >> 4) & 0xf;
 773       *r2 = insn[3] & 0xf;
 774       return 1;
 775     }
 776   else
 777     return 0;
 778 }
 779
 780
 781 static int
 782 is_rs (bfd_byte *insn, int op,
 783        unsigned int *r1, unsigned int *r3, int *d2, unsigned int *b2)
 784 {
 785   if (insn[0] == op)
 786     {
 787       *r1 = (insn[1] >> 4) & 0xf;
 788       *r3 = insn[1] & 0xf;
 789       *b2 = (insn[2] >> 4) & 0xf;
 790       *d2 = ((insn[2] & 0xf) << 8) | insn[3];
 791       return 1;
 792     }
 793   else
 794     return 0;
 795 }
 796
 797
 798 static int
 799 is_rsy (bfd_byte *insn, int op1, int op2,
 800         unsigned int *r1, unsigned int *r3, int *d2, unsigned int *b2)
 801 {
 802   if (insn[0] == op1
 803       && insn[5] == op2)
 804     {
 805       *r1 = (insn[1] >> 4) & 0xf;
 806       *r3 = insn[1] & 0xf;
 807       *b2 = (insn[2] >> 4) & 0xf;
 808       /* The 'long displacement' is a 20-bit signed integer.  */
 809       *d2 = ((((insn[2] & 0xf) << 8) | insn[3] | (insn[4] << 12))
 810                 ^ 0x80000) - 0x80000;
 811       return 1;
 812     }
 813   else
 814     return 0;
 815 }
 816
 817
 818 static int
 819 is_rsi (bfd_byte *insn, int op,
 820         unsigned int *r1, unsigned int *r3, int *i2)
 821 {
 822   if (insn[0] == op)
 823     {
 824       *r1 = (insn[1] >> 4) & 0xf;
 825       *r3 = insn[1] & 0xf;
 826       /* i2 is a 16-bit signed quantity.  */
 827       *i2 = (((insn[2] << 8) | insn[3]) ^ 0x8000) - 0x8000;
 828       return 1;
 829     }
 830   else
 831     return 0;
 832 }
 833
 834
 835 static int
 836 is_rie (bfd_byte *insn, int op1, int op2,
 837         unsigned int *r1, unsigned int *r3, int *i2)
 838 {
 839   if (insn[0] == op1
 840       && insn[5] == op2)
 841     {
 842       *r1 = (insn[1] >> 4) & 0xf;
 843       *r3 = insn[1] & 0xf;
 844       /* i2 is a 16-bit signed quantity.  */
 845       *i2 = (((insn[2] << 8) | insn[3]) ^ 0x8000) - 0x8000;
 846       return 1;
 847     }
 848   else
 849     return 0;
 850 }
 851
 852
 853 static int
 854 is_rx (bfd_byte *insn, int op,
 855        unsigned int *r1, int *d2, unsigned int *x2, unsigned int *b2)
 856 {
 857   if (insn[0] == op)
 858     {
 859       *r1 = (insn[1] >> 4) & 0xf;
 860       *x2 = insn[1] & 0xf;
 861       *b2 = (insn[2] >> 4) & 0xf;
 862       *d2 = ((insn[2] & 0xf) << 8) | insn[3];
 863       return 1;
 864     }
 865   else
 866     return 0;
 867 }
 868
 869
 870 static int
 871 is_rxy (bfd_byte *insn, int op1, int op2,
 872         unsigned int *r1, int *d2, unsigned int *x2, unsigned int *b2)
 873 {
 874   if (insn[0] == op1
 875       && insn[5] == op2)
 876     {
 877       *r1 = (insn[1] >> 4) & 0xf;
 878       *x2 = insn[1] & 0xf;
 879       *b2 = (insn[2] >> 4) & 0xf;
 880       /* The 'long displacement' is a 20-bit signed integer.  */
 881       *d2 = ((((insn[2] & 0xf) << 8) | insn[3] | (insn[4] << 12))
 882                 ^ 0x80000) - 0x80000;
 883       return 1;
 884     }
 885   else
 886     return 0;
 887 }
 888
 889
 890 /* Prologue analysis.  */
 891
 892 #define S390_NUM_GPRS 16
 893 #define S390_NUM_FPRS 16
 894
 895 struct s390_prologue_data {
 896
 897   /* The stack.  */
 898   struct pv_area *stack;
 899
 900   /* The size and byte-order of a GPR or FPR.  */
 901   int gpr_size;
 902   int fpr_size;
 903   enum bfd_endian byte_order;
 904
 905   /* The general-purpose registers.  */
 906   pv_t gpr[S390_NUM_GPRS];
 907
 908   /* The floating-point registers.  */
 909   pv_t fpr[S390_NUM_FPRS];
 910
 911   /* The offset relative to the CFA where the incoming GPR N was saved
 912      by the function prologue.  0 if not saved or unknown.  */
 913   int gpr_slot[S390_NUM_GPRS];
 914
 915   /* Likewise for FPRs.  */
 916   int fpr_slot[S390_NUM_FPRS];
 917
 918   /* Nonzero if the backchain was saved.  This is assumed to be the
 919      case when the incoming SP is saved at the current SP location.  */
 920   int back_chain_saved_p;
 921 };
 922
 923 /* Return the effective address for an X-style instruction, like:
 924
 925         L R1, D2(X2, B2)
 926
 927    Here, X2 and B2 are registers, and D2 is a signed 20-bit
 928    constant; the effective address is the sum of all three.  If either
 929    X2 or B2 are zero, then it doesn't contribute to the sum --- this
 930    means that r0 can't be used as either X2 or B2.  */
 931 static pv_t
 932 s390_addr (struct s390_prologue_data *data,
 933            int d2, unsigned int x2, unsigned int b2)
 934 {
 935   pv_t result;
 936
 937   result = pv_constant (d2);
 938   if (x2)
 939     result = pv_add (result, data->gpr[x2]);
 940   if (b2)
 941     result = pv_add (result, data->gpr[b2]);
 942
 943   return result;
 944 }
 945
 946 /* Do a SIZE-byte store of VALUE to D2(X2,B2).  */
 947 static void
 948 s390_store (struct s390_prologue_data *data,
 949             int d2, unsigned int x2, unsigned int b2, CORE_ADDR size,
 950             pv_t value)
 951 {
 952   pv_t addr = s390_addr (data, d2, x2, b2);
 953   pv_t offset;
 954
 955   /* Check whether we are storing the backchain.  */
 956   offset = pv_subtract (data->gpr[S390_SP_REGNUM - S390_R0_REGNUM], addr);
 957
 958   if (pv_is_constant (offset) && offset.k == 0)
 959     if (size == data->gpr_size
 960         && pv_is_register_k (value, S390_SP_REGNUM, 0))
 961       {
 962         data->back_chain_saved_p = 1;
 963         return;
 964       }
 965
 966
 967   /* Check whether we are storing a register into the stack.  */
 968   if (!pv_area_store_would_trash (data->stack, addr))
 969     pv_area_store (data->stack, addr, size, value);
 970
 971
 972   /* Note: If this is some store we cannot identify, you might think we
 973      should forget our cached values, as any of those might have been hit.
 974
 975      However, we make the assumption that the register save areas are only
 976      ever stored to once in any given function, and we do recognize these
 977      stores.  Thus every store we cannot recognize does not hit our data.  */
 978 }
 979
 980 /* Do a SIZE-byte load from D2(X2,B2).  */
 981 static pv_t
 982 s390_load (struct s390_prologue_data *data,
 983            int d2, unsigned int x2, unsigned int b2, CORE_ADDR size)
 984
 985 {
 986   pv_t addr = s390_addr (data, d2, x2, b2);
 987
 988   /* If it's a load from an in-line constant pool, then we can
 989      simulate that, under the assumption that the code isn't
 990      going to change between the time the processor actually
 991      executed it creating the current frame, and the time when
 992      we're analyzing the code to unwind past that frame.  */
 993   if (pv_is_constant (addr))
 994     {
 995       struct target_section *secp;
 996       secp = target_section_by_addr (&current_target, addr.k);
 997       if (secp != NULL
 998           && (bfd_get_section_flags (secp->the_bfd_section->owner,
 999                                      secp->the_bfd_section)
1000               & SEC_READONLY))
1001         return pv_constant (read_memory_integer (addr.k, size,
1002                                                  data->byte_order));
1003     }
1004
1005   /* Check whether we are accessing one of our save slots.  */
1006   return pv_area_fetch (data->stack, addr, size);
1007 }
1008
1009 /* Function for finding saved registers in a 'struct pv_area'; we pass
1010    this to pv_area_scan.
1011
1012    If VALUE is a saved register, ADDR says it was saved at a constant
1013    offset from the frame base, and SIZE indicates that the whole
1014    register was saved, record its offset in the reg_offset table in
1015    PROLOGUE_UNTYPED.  */
1016 static void
1017 s390_check_for_saved (void *data_untyped, pv_t addr,
1018                       CORE_ADDR size, pv_t value)
1019 {
1020   struct s390_prologue_data *data = data_untyped;
1021   int i, offset;
1022
1023   if (!pv_is_register (addr, S390_SP_REGNUM))
1024     return;
1025
1026   offset = 16 * data->gpr_size + 32 - addr.k;
1027
1028   /* If we are storing the original value of a register, we want to
1029      record the CFA offset.  If the same register is stored multiple
1030      times, the stack slot with the highest address counts.  */
1031
1032   for (i = 0; i < S390_NUM_GPRS; i++)
1033     if (size == data->gpr_size
1034         && pv_is_register_k (value, S390_R0_REGNUM + i, 0))
1035       if (data->gpr_slot[i] == 0
1036           || data->gpr_slot[i] > offset)
1037         {
1038           data->gpr_slot[i] = offset;
1039           return;
1040         }
1041
1042   for (i = 0; i < S390_NUM_FPRS; i++)
1043     if (size == data->fpr_size
1044         && pv_is_register_k (value, S390_F0_REGNUM + i, 0))
1045       if (data->fpr_slot[i] == 0
1046           || data->fpr_slot[i] > offset)
1047         {
1048           data->fpr_slot[i] = offset;
1049           return;
1050         }
1051 }
1052
1053 /* Analyze the prologue of the function starting at START_PC,
1054    continuing at most until CURRENT_PC.  Initialize DATA to
1055    hold all information we find out about the state of the registers
1056    and stack slots.  Return the address of the instruction after
1057    the last one that changed the SP, FP, or back chain; or zero
1058    on error.  */
1059 static CORE_ADDR
1060 s390_analyze_prologue (struct gdbarch *gdbarch,
1061                        CORE_ADDR start_pc,
1062                        CORE_ADDR current_pc,
1063                        struct s390_prologue_data *data)
1064 {
1065   int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1066
1067   /* Our return value:
1068      The address of the instruction after the last one that changed
1069      the SP, FP, or back chain;  zero if we got an error trying to
1070      read memory.  */
1071   CORE_ADDR result = start_pc;
1072
1073   /* The current PC for our abstract interpretation.  */
1074   CORE_ADDR pc;
1075
1076   /* The address of the next instruction after that.  */
1077   CORE_ADDR next_pc;
1078
1079   /* Set up everything's initial value.  */
1080   {
1081     int i;
1082
1083     data->stack = make_pv_area (S390_SP_REGNUM, gdbarch_addr_bit (gdbarch));
1084
1085     /* For the purpose of prologue tracking, we consider the GPR size to
1086        be equal to the ABI word size, even if it is actually larger
1087        (i.e. when running a 32-bit binary under a 64-bit kernel).  */
1088     data->gpr_size = word_size;
1089     data->fpr_size = 8;
1090     data->byte_order = gdbarch_byte_order (gdbarch);
1091
1092     for (i = 0; i < S390_NUM_GPRS; i++)
1093       data->gpr[i] = pv_register (S390_R0_REGNUM + i, 0);
1094
1095     for (i = 0; i < S390_NUM_FPRS; i++)
1096       data->fpr[i] = pv_register (S390_F0_REGNUM + i, 0);
1097
1098     for (i = 0; i < S390_NUM_GPRS; i++)
1099       data->gpr_slot[i]  = 0;
1100
1101     for (i = 0; i < S390_NUM_FPRS; i++)
1102       data->fpr_slot[i]  = 0;
1103
1104     data->back_chain_saved_p = 0;
1105   }
1106
1107   /* Start interpreting instructions, until we hit the frame's
1108      current PC or the first branch instruction.  */
1109   for (pc = start_pc; pc > 0 && pc < current_pc; pc = next_pc)
1110     {
1111       bfd_byte insn[S390_MAX_INSTR_SIZE];
1112       int insn_len = s390_readinstruction (insn, pc);
1113
1114       bfd_byte dummy[S390_MAX_INSTR_SIZE] = { 0 };
1115       bfd_byte *insn32 = word_size == 4 ? insn : dummy;
1116       bfd_byte *insn64 = word_size == 8 ? insn : dummy;
1117
1118       /* Fields for various kinds of instructions.  */
1119       unsigned int b2, r1, r2, x2, r3;
1120       int i2, d2;
1121
1122       /* The values of SP and FP before this instruction,
1123          for detecting instructions that change them.  */
1124       pv_t pre_insn_sp, pre_insn_fp;
1125       /* Likewise for the flag whether the back chain was saved.  */
1126       int pre_insn_back_chain_saved_p;
1127
1128       /* If we got an error trying to read the instruction, report it.  */
1129       if (insn_len < 0)
1130         {
1131           result = 0;
1132           break;
1133         }
1134
1135       next_pc = pc + insn_len;
1136
1137       pre_insn_sp = data->gpr[S390_SP_REGNUM - S390_R0_REGNUM];
1138       pre_insn_fp = data->gpr[S390_FRAME_REGNUM - S390_R0_REGNUM];
1139       pre_insn_back_chain_saved_p = data->back_chain_saved_p;
1140
1141
1142       /* LHI r1, i2 --- load halfword immediate.  */
1143       /* LGHI r1, i2 --- load halfword immediate (64-bit version).  */
1144       /* LGFI r1, i2 --- load fullword immediate.  */
1145       if (is_ri (insn32, op1_lhi, op2_lhi, &r1, &i2)
1146           || is_ri (insn64, op1_lghi, op2_lghi, &r1, &i2)
1147           || is_ril (insn, op1_lgfi, op2_lgfi, &r1, &i2))
1148         data->gpr[r1] = pv_constant (i2);
1149
1150       /* LR r1, r2 --- load from register.  */
1151       /* LGR r1, r2 --- load from register (64-bit version).  */
1152       else if (is_rr (insn32, op_lr, &r1, &r2)
1153                || is_rre (insn64, op_lgr, &r1, &r2))
1154         data->gpr[r1] = data->gpr[r2];
1155
1156       /* L r1, d2(x2, b2) --- load.  */
1157       /* LY r1, d2(x2, b2) --- load (long-displacement version).  */
1158       /* LG r1, d2(x2, b2) --- load (64-bit version).  */
1159       else if (is_rx (insn32, op_l, &r1, &d2, &x2, &b2)
1160                || is_rxy (insn32, op1_ly, op2_ly, &r1, &d2, &x2, &b2)
1161                || is_rxy (insn64, op1_lg, op2_lg, &r1, &d2, &x2, &b2))
1162         data->gpr[r1] = s390_load (data, d2, x2, b2, data->gpr_size);
1163
1164       /* ST r1, d2(x2, b2) --- store.  */
1165       /* STY r1, d2(x2, b2) --- store (long-displacement version).  */
1166       /* STG r1, d2(x2, b2) --- store (64-bit version).  */
1167       else if (is_rx (insn32, op_st, &r1, &d2, &x2, &b2)
1168                || is_rxy (insn32, op1_sty, op2_sty, &r1, &d2, &x2, &b2)
1169                || is_rxy (insn64, op1_stg, op2_stg, &r1, &d2, &x2, &b2))
1170         s390_store (data, d2, x2, b2, data->gpr_size, data->gpr[r1]);
1171
1172       /* STD r1, d2(x2,b2) --- store floating-point register.  */
1173       else if (is_rx (insn, op_std, &r1, &d2, &x2, &b2))
1174         s390_store (data, d2, x2, b2, data->fpr_size, data->fpr[r1]);
1175
1176       /* STM r1, r3, d2(b2) --- store multiple.  */
1177       /* STMY r1, r3, d2(b2) --- store multiple (long-displacement
1178          version).  */
1179       /* STMG r1, r3, d2(b2) --- store multiple (64-bit version).  */
1180       else if (is_rs (insn32, op_stm, &r1, &r3, &d2, &b2)
1181                || is_rsy (insn32, op1_stmy, op2_stmy, &r1, &r3, &d2, &b2)
1182                || is_rsy (insn64, op1_stmg, op2_stmg, &r1, &r3, &d2, &b2))
1183         {
1184           for (; r1 <= r3; r1++, d2 += data->gpr_size)
1185             s390_store (data, d2, 0, b2, data->gpr_size, data->gpr[r1]);
1186         }
1187
1188       /* AHI r1, i2 --- add halfword immediate.  */
1189       /* AGHI r1, i2 --- add halfword immediate (64-bit version).  */
1190       /* AFI r1, i2 --- add fullword immediate.  */
1191       /* AGFI r1, i2 --- add fullword immediate (64-bit version).  */
1192       else if (is_ri (insn32, op1_ahi, op2_ahi, &r1, &i2)
1193                || is_ri (insn64, op1_aghi, op2_aghi, &r1, &i2)
1194                || is_ril (insn32, op1_afi, op2_afi, &r1, &i2)
1195                || is_ril (insn64, op1_agfi, op2_agfi, &r1, &i2))
1196         data->gpr[r1] = pv_add_constant (data->gpr[r1], i2);
1197
1198       /* ALFI r1, i2 --- add logical immediate.  */
1199       /* ALGFI r1, i2 --- add logical immediate (64-bit version).  */
1200       else if (is_ril (insn32, op1_alfi, op2_alfi, &r1, &i2)
1201                || is_ril (insn64, op1_algfi, op2_algfi, &r1, &i2))
1202         data->gpr[r1] = pv_add_constant (data->gpr[r1],
1203                                          (CORE_ADDR)i2 & 0xffffffff);
1204
1205       /* AR r1, r2 -- add register.  */
1206       /* AGR r1, r2 -- add register (64-bit version).  */
1207       else if (is_rr (insn32, op_ar, &r1, &r2)
1208                || is_rre (insn64, op_agr, &r1, &r2))
1209         data->gpr[r1] = pv_add (data->gpr[r1], data->gpr[r2]);
1210
1211       /* A r1, d2(x2, b2) -- add.  */
1212       /* AY r1, d2(x2, b2) -- add (long-displacement version).  */
1213       /* AG r1, d2(x2, b2) -- add (64-bit version).  */
1214       else if (is_rx (insn32, op_a, &r1, &d2, &x2, &b2)
1215                || is_rxy (insn32, op1_ay, op2_ay, &r1, &d2, &x2, &b2)
1216                || is_rxy (insn64, op1_ag, op2_ag, &r1, &d2, &x2, &b2))
1217         data->gpr[r1] = pv_add (data->gpr[r1],
1218                                 s390_load (data, d2, x2, b2, data->gpr_size));
1219
1220       /* SLFI r1, i2 --- subtract logical immediate.  */
1221       /* SLGFI r1, i2 --- subtract logical immediate (64-bit version).  */
1222       else if (is_ril (insn32, op1_slfi, op2_slfi, &r1, &i2)
1223                || is_ril (insn64, op1_slgfi, op2_slgfi, &r1, &i2))
1224         data->gpr[r1] = pv_add_constant (data->gpr[r1],
1225                                          -((CORE_ADDR)i2 & 0xffffffff));
1226
1227       /* SR r1, r2 -- subtract register.  */
1228       /* SGR r1, r2 -- subtract register (64-bit version).  */
1229       else if (is_rr (insn32, op_sr, &r1, &r2)
1230                || is_rre (insn64, op_sgr, &r1, &r2))
1231         data->gpr[r1] = pv_subtract (data->gpr[r1], data->gpr[r2]);
1232
1233       /* S r1, d2(x2, b2) -- subtract.  */
1234       /* SY r1, d2(x2, b2) -- subtract (long-displacement version).  */
1235       /* SG r1, d2(x2, b2) -- subtract (64-bit version).  */
1236       else if (is_rx (insn32, op_s, &r1, &d2, &x2, &b2)
1237                || is_rxy (insn32, op1_sy, op2_sy, &r1, &d2, &x2, &b2)
1238                || is_rxy (insn64, op1_sg, op2_sg, &r1, &d2, &x2, &b2))
1239         data->gpr[r1] = pv_subtract (data->gpr[r1],
1240                                 s390_load (data, d2, x2, b2, data->gpr_size));
1241
1242       /* LA r1, d2(x2, b2) --- load address.  */
1243       /* LAY r1, d2(x2, b2) --- load address (long-displacement version).  */
1244       else if (is_rx (insn, op_la, &r1, &d2, &x2, &b2)
1245                || is_rxy (insn, op1_lay, op2_lay, &r1, &d2, &x2, &b2))
1246         data->gpr[r1] = s390_addr (data, d2, x2, b2);
1247
1248       /* LARL r1, i2 --- load address relative long.  */
1249       else if (is_ril (insn, op1_larl, op2_larl, &r1, &i2))
1250         data->gpr[r1] = pv_constant (pc + i2 * 2);
1251
1252       /* BASR r1, 0 --- branch and save.
1253          Since r2 is zero, this saves the PC in r1, but doesn't branch.  */
1254       else if (is_rr (insn, op_basr, &r1, &r2)
1255                && r2 == 0)
1256         data->gpr[r1] = pv_constant (next_pc);
1257
1258       /* BRAS r1, i2 --- branch relative and save.  */
1259       else if (is_ri (insn, op1_bras, op2_bras, &r1, &i2))
1260         {
1261           data->gpr[r1] = pv_constant (next_pc);
1262           next_pc = pc + i2 * 2;
1263
1264           /* We'd better not interpret any backward branches.  We'll
1265              never terminate.  */
1266           if (next_pc <= pc)
1267             break;
1268         }
1269
1270       /* Terminate search when hitting any other branch instruction.  */
1271       else if (is_rr (insn, op_basr, &r1, &r2)
1272                || is_rx (insn, op_bas, &r1, &d2, &x2, &b2)
1273                || is_rr (insn, op_bcr, &r1, &r2)
1274                || is_rx (insn, op_bc, &r1, &d2, &x2, &b2)
1275                || is_ri (insn, op1_brc, op2_brc, &r1, &i2)
1276                || is_ril (insn, op1_brcl, op2_brcl, &r1, &i2)
1277                || is_ril (insn, op1_brasl, op2_brasl, &r2, &i2))
1278         break;
1279
1280       else
1281         {
1282           /* An instruction we don't know how to simulate.  The only
1283              safe thing to do would be to set every value we're tracking
1284              to 'unknown'.  Instead, we'll be optimistic: we assume that
1285              we *can* interpret every instruction that the compiler uses
1286              to manipulate any of the data we're interested in here --
1287              then we can just ignore anything else.  */
1288         }
1289
1290       /* Record the address after the last instruction that changed
1291          the FP, SP, or backlink.  Ignore instructions that changed
1292          them back to their original values --- those are probably
1293          restore instructions.  (The back chain is never restored,
1294          just popped.)  */
1295       {
1296         pv_t sp = data->gpr[S390_SP_REGNUM - S390_R0_REGNUM];
1297         pv_t fp = data->gpr[S390_FRAME_REGNUM - S390_R0_REGNUM];
1298
1299         if ((! pv_is_identical (pre_insn_sp, sp)
1300              && ! pv_is_register_k (sp, S390_SP_REGNUM, 0)
1301              && sp.kind != pvk_unknown)
1302             || (! pv_is_identical (pre_insn_fp, fp)
1303                 && ! pv_is_register_k (fp, S390_FRAME_REGNUM, 0)
1304                 && fp.kind != pvk_unknown)
1305             || pre_insn_back_chain_saved_p != data->back_chain_saved_p)
1306           result = next_pc;
1307       }
1308     }
1309
1310   /* Record where all the registers were saved.  */
1311   pv_area_scan (data->stack, s390_check_for_saved, data);
1312
1313   free_pv_area (data->stack);
1314   data->stack = NULL;
1315
1316   return result;
1317 }
1318
1319 /* Advance PC across any function entry prologue instructions to reach
1320    some "real" code.  */
1321 static CORE_ADDR
1322 s390_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
1323 {
1324   struct s390_prologue_data data;
1325   CORE_ADDR skip_pc;
1326   skip_pc = s390_analyze_prologue (gdbarch, pc, (CORE_ADDR)-1, &data);
1327   return skip_pc ? skip_pc : pc;
1328 }
1329
1330 /* Return true if we are in the functin's epilogue, i.e. after the
1331    instruction that destroyed the function's stack frame.  */
1332 static int
1333 s390_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
1334 {
1335   int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1336
1337   /* In frameless functions, there's not frame to destroy and thus
1338      we don't care about the epilogue.
1339
1340      In functions with frame, the epilogue sequence is a pair of
1341      a LM-type instruction that restores (amongst others) the
1342      return register %r14 and the stack pointer %r15, followed
1343      by a branch 'br %r14' --or equivalent-- that effects the
1344      actual return.
1345
1346      In that situation, this function needs to return 'true' in
1347      exactly one case: when pc points to that branch instruction.
1348
1349      Thus we try to disassemble the one instructions immediately
1350      preceding pc and check whether it is an LM-type instruction
1351      modifying the stack pointer.
1352
1353      Note that disassembling backwards is not reliable, so there
1354      is a slight chance of false positives here ...  */
1355
1356   bfd_byte insn[6];
1357   unsigned int r1, r3, b2;
1358   int d2;
1359
1360   if (word_size == 4
1361       && !target_read_memory (pc - 4, insn, 4)
1362       && is_rs (insn, op_lm, &r1, &r3, &d2, &b2)
1363       && r3 == S390_SP_REGNUM - S390_R0_REGNUM)
1364     return 1;
1365
1366   if (word_size == 4
1367       && !target_read_memory (pc - 6, insn, 6)
1368       && is_rsy (insn, op1_lmy, op2_lmy, &r1, &r3, &d2, &b2)
1369       && r3 == S390_SP_REGNUM - S390_R0_REGNUM)
1370     return 1;
1371
1372   if (word_size == 8
1373       && !target_read_memory (pc - 6, insn, 6)
1374       && is_rsy (insn, op1_lmg, op2_lmg, &r1, &r3, &d2, &b2)
1375       && r3 == S390_SP_REGNUM - S390_R0_REGNUM)
1376     return 1;
1377
1378   return 0;
1379 }
1380
1381 /* Displaced stepping.  */
1382
1383 /* Fix up the state of registers and memory after having single-stepped
1384    a displaced instruction.  */
1385 static void
1386 s390_displaced_step_fixup (struct gdbarch *gdbarch,
1387                            struct displaced_step_closure *closure,
1388                            CORE_ADDR from, CORE_ADDR to,
1389                            struct regcache *regs)
1390 {
1391   /* Since we use simple_displaced_step_copy_insn, our closure is a
1392      copy of the instruction.  */
1393   gdb_byte *insn = (gdb_byte *) closure;
1394   static int s390_instrlen[] = { 2, 4, 4, 6 };
1395   int insnlen = s390_instrlen[insn[0] >> 6];
1396
1397   /* Fields for various kinds of instructions.  */
1398   unsigned int b2, r1, r2, x2, r3;
1399   int i2, d2;
1400
1401   /* Get current PC and addressing mode bit.  */
1402   CORE_ADDR pc = regcache_read_pc (regs);
1403   ULONGEST amode = 0;
1404
1405   if (register_size (gdbarch, S390_PSWA_REGNUM) == 4)
1406     {
1407       regcache_cooked_read_unsigned (regs, S390_PSWA_REGNUM, &amode);
1408       amode &= 0x80000000;
1409     }
1410
1411   if (debug_displaced)
1412     fprintf_unfiltered (gdb_stdlog,
1413                         "displaced: (s390) fixup (%s, %s) pc %s len %d amode 0x%x\n",
1414                         paddress (gdbarch, from), paddress (gdbarch, to),
1415                         paddress (gdbarch, pc), insnlen, (int) amode);
1416
1417   /* Handle absolute branch and save instructions.  */
1418   if (is_rr (insn, op_basr, &r1, &r2)
1419       || is_rx (insn, op_bas, &r1, &d2, &x2, &b2))
1420     {
1421       /* Recompute saved return address in R1.  */
1422       regcache_cooked_write_unsigned (regs, S390_R0_REGNUM + r1,
1423                                       amode | (from + insnlen));
1424     }
1425
1426   /* Handle absolute branch instructions.  */
1427   else if (is_rr (insn, op_bcr, &r1, &r2)
1428            || is_rx (insn, op_bc, &r1, &d2, &x2, &b2)
1429            || is_rr (insn, op_bctr, &r1, &r2)
1430            || is_rre (insn, op_bctgr, &r1, &r2)
1431            || is_rx (insn, op_bct, &r1, &d2, &x2, &b2)
1432            || is_rxy (insn, op1_bctg, op2_brctg, &r1, &d2, &x2, &b2)
1433            || is_rs (insn, op_bxh, &r1, &r3, &d2, &b2)
1434            || is_rsy (insn, op1_bxhg, op2_bxhg, &r1, &r3, &d2, &b2)
1435            || is_rs (insn, op_bxle, &r1, &r3, &d2, &b2)
1436            || is_rsy (insn, op1_bxleg, op2_bxleg, &r1, &r3, &d2, &b2))
1437     {
1438       /* Update PC iff branch was *not* taken.  */
1439       if (pc == to + insnlen)
1440         regcache_write_pc (regs, from + insnlen);
1441     }
1442
1443   /* Handle PC-relative branch and save instructions.  */
1444   else if (is_ri (insn, op1_bras, op2_bras, &r1, &i2)
1445            || is_ril (insn, op1_brasl, op2_brasl, &r1, &i2))
1446     {
1447       /* Update PC.  */
1448       regcache_write_pc (regs, pc - to + from);
1449       /* Recompute saved return address in R1.  */
1450       regcache_cooked_write_unsigned (regs, S390_R0_REGNUM + r1,
1451                                       amode | (from + insnlen));
1452     }
1453
1454   /* Handle PC-relative branch instructions.  */
1455   else if (is_ri (insn, op1_brc, op2_brc, &r1, &i2)
1456            || is_ril (insn, op1_brcl, op2_brcl, &r1, &i2)
1457            || is_ri (insn, op1_brct, op2_brct, &r1, &i2)
1458            || is_ri (insn, op1_brctg, op2_brctg, &r1, &i2)
1459            || is_rsi (insn, op_brxh, &r1, &r3, &i2)
1460            || is_rie (insn, op1_brxhg, op2_brxhg, &r1, &r3, &i2)
1461            || is_rsi (insn, op_brxle, &r1, &r3, &i2)
1462            || is_rie (insn, op1_brxlg, op2_brxlg, &r1, &r3, &i2))
1463     {
1464       /* Update PC.  */
1465       regcache_write_pc (regs, pc - to + from);
1466     }
1467
1468   /* Handle LOAD ADDRESS RELATIVE LONG.  */
1469   else if (is_ril (insn, op1_larl, op2_larl, &r1, &i2))
1470     {
1471       /* Update PC.  */
1472       regcache_write_pc (regs, from + insnlen);
1473       /* Recompute output address in R1.  */
1474       regcache_cooked_write_unsigned (regs, S390_R0_REGNUM + r1,
1475                                       amode | (from + i2 * 2));
1476     }
1477
1478   /* If we executed a breakpoint instruction, point PC right back at it.  */
1479   else if (insn[0] == 0x0 && insn[1] == 0x1)
1480     regcache_write_pc (regs, from);
1481
1482   /* For any other insn, PC points right after the original instruction.  */
1483   else
1484     regcache_write_pc (regs, from + insnlen);
1485
1486   if (debug_displaced)
1487     fprintf_unfiltered (gdb_stdlog,
1488                         "displaced: (s390) pc is now %s\n",
1489                         paddress (gdbarch, regcache_read_pc (regs)));
1490 }
1491
1492
1493 /* Helper routine to unwind pseudo registers.  */
1494
1495 static struct value *
1496 s390_unwind_pseudo_register (struct frame_info *this_frame, int regnum)
1497 {
1498   struct gdbarch *gdbarch = get_frame_arch (this_frame);
1499   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1500   struct type *type = register_type (gdbarch, regnum);
1501
1502   /* Unwind PC via PSW address.  */
1503   if (regnum == tdep->pc_regnum)
1504     {
1505       struct value *val;
1506
1507       val = frame_unwind_register_value (this_frame, S390_PSWA_REGNUM);
1508       if (!value_optimized_out (val))
1509         {
1510           LONGEST pswa = value_as_long (val);
1511
1512           if (TYPE_LENGTH (type) == 4)
1513             return value_from_pointer (type, pswa & 0x7fffffff);
1514           else
1515             return value_from_pointer (type, pswa);
1516         }
1517     }
1518
1519   /* Unwind CC via PSW mask.  */
1520   if (regnum == tdep->cc_regnum)
1521     {
1522       struct value *val;
1523
1524       val = frame_unwind_register_value (this_frame, S390_PSWM_REGNUM);
1525       if (!value_optimized_out (val))
1526         {
1527           LONGEST pswm = value_as_long (val);
1528
1529           if (TYPE_LENGTH (type) == 4)
1530             return value_from_longest (type, (pswm >> 12) & 3);
1531           else
1532             return value_from_longest (type, (pswm >> 44) & 3);
1533         }
1534     }
1535
1536   /* Unwind full GPRs to show at least the lower halves (as the
1537      upper halves are undefined).  */
1538   if (regnum_is_gpr_full (tdep, regnum))
1539     {
1540       int reg = regnum - tdep->gpr_full_regnum;
1541       struct value *val;
1542
1543       val = frame_unwind_register_value (this_frame, S390_R0_REGNUM + reg);
1544       if (!value_optimized_out (val))
1545         return value_cast (type, val);
1546     }
1547
1548   return allocate_optimized_out_value (type);
1549 }
1550
1551 static struct value *
1552 s390_trad_frame_prev_register (struct frame_info *this_frame,
1553                                struct trad_frame_saved_reg saved_regs[],
1554                                int regnum)
1555 {
1556   if (regnum < S390_NUM_REGS)
1557     return trad_frame_get_prev_register (this_frame, saved_regs, regnum);
1558   else
1559     return s390_unwind_pseudo_register (this_frame, regnum);
1560 }
1561
1562
1563 /* Normal stack frames.  */
1564
1565 struct s390_unwind_cache {
1566
1567   CORE_ADDR func;
1568   CORE_ADDR frame_base;
1569   CORE_ADDR local_base;
1570
1571   struct trad_frame_saved_reg *saved_regs;
1572 };
1573
1574 static int
1575 s390_prologue_frame_unwind_cache (struct frame_info *this_frame,
1576                                   struct s390_unwind_cache *info)
1577 {
1578   struct gdbarch *gdbarch = get_frame_arch (this_frame);
1579   int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1580   struct s390_prologue_data data;
1581   pv_t *fp = &data.gpr[S390_FRAME_REGNUM - S390_R0_REGNUM];
1582   pv_t *sp = &data.gpr[S390_SP_REGNUM - S390_R0_REGNUM];
1583   int i;
1584   CORE_ADDR cfa;
1585   CORE_ADDR func;
1586   CORE_ADDR result;
1587   ULONGEST reg;
1588   CORE_ADDR prev_sp;
1589   int frame_pointer;
1590   int size;
1591   struct frame_info *next_frame;
1592
1593   /* Try to find the function start address.  If we can't find it, we don't
1594      bother searching for it -- with modern compilers this would be mostly
1595      pointless anyway.  Trust that we'll either have valid DWARF-2 CFI data
1596      or else a valid backchain ...  */
1597   func = get_frame_func (this_frame);
1598   if (!func)
1599     return 0;
1600
1601   /* Try to analyze the prologue.  */
1602   result = s390_analyze_prologue (gdbarch, func,
1603                                   get_frame_pc (this_frame), &data);
1604   if (!result)
1605     return 0;
1606
1607   /* If this was successful, we should have found the instruction that
1608      sets the stack pointer register to the previous value of the stack
1609      pointer minus the frame size.  */
1610   if (!pv_is_register (*sp, S390_SP_REGNUM))
1611     return 0;
1612
1613   /* A frame size of zero at this point can mean either a real
1614      frameless function, or else a failure to find the prologue.
1615      Perform some sanity checks to verify we really have a
1616      frameless function.  */
1617   if (sp->k == 0)
1618     {
1619       /* If the next frame is a NORMAL_FRAME, this frame *cannot* have frame
1620          size zero.  This is only possible if the next frame is a sentinel
1621          frame, a dummy frame, or a signal trampoline frame.  */
1622       /* FIXME: cagney/2004-05-01: This sanity check shouldn't be
1623          needed, instead the code should simpliy rely on its
1624          analysis.  */
1625       next_frame = get_next_frame (this_frame);
1626       while (next_frame && get_frame_type (next_frame) == INLINE_FRAME)
1627         next_frame = get_next_frame (next_frame);
1628       if (next_frame
1629           && get_frame_type (get_next_frame (this_frame)) == NORMAL_FRAME)
1630         return 0;
1631
1632       /* If we really have a frameless function, %r14 must be valid
1633          -- in particular, it must point to a different function.  */
1634       reg = get_frame_register_unsigned (this_frame, S390_RETADDR_REGNUM);
1635       reg = gdbarch_addr_bits_remove (gdbarch, reg) - 1;
1636       if (get_pc_function_start (reg) == func)
1637         {
1638           /* However, there is one case where it *is* valid for %r14
1639              to point to the same function -- if this is a recursive
1640              call, and we have stopped in the prologue *before* the
1641              stack frame was allocated.
1642
1643              Recognize this case by looking ahead a bit ...  */
1644
1645           struct s390_prologue_data data2;
1646           pv_t *sp = &data2.gpr[S390_SP_REGNUM - S390_R0_REGNUM];
1647
1648           if (!(s390_analyze_prologue (gdbarch, func, (CORE_ADDR)-1, &data2)
1649                 && pv_is_register (*sp, S390_SP_REGNUM)
1650                 && sp->k != 0))
1651             return 0;
1652         }
1653     }
1654
1655
1656   /* OK, we've found valid prologue data.  */
1657   size = -sp->k;
1658
1659   /* If the frame pointer originally also holds the same value
1660      as the stack pointer, we're probably using it.  If it holds
1661      some other value -- even a constant offset -- it is most
1662      likely used as temp register.  */
1663   if (pv_is_identical (*sp, *fp))
1664     frame_pointer = S390_FRAME_REGNUM;
1665   else
1666     frame_pointer = S390_SP_REGNUM;
1667
1668   /* If we've detected a function with stack frame, we'll still have to
1669      treat it as frameless if we're currently within the function epilog
1670      code at a point where the frame pointer has already been restored.
1671      This can only happen in an innermost frame.  */
1672   /* FIXME: cagney/2004-05-01: This sanity check shouldn't be needed,
1673      instead the code should simpliy rely on its analysis.  */
1674   next_frame = get_next_frame (this_frame);
1675   while (next_frame && get_frame_type (next_frame) == INLINE_FRAME)
1676     next_frame = get_next_frame (next_frame);
1677   if (size > 0
1678       && (next_frame == NULL
1679           || get_frame_type (get_next_frame (this_frame)) != NORMAL_FRAME))
1680     {
1681       /* See the comment in s390_in_function_epilogue_p on why this is
1682          not completely reliable ...  */
1683       if (s390_in_function_epilogue_p (gdbarch, get_frame_pc (this_frame)))
1684         {
1685           memset (&data, 0, sizeof (data));
1686           size = 0;
1687           frame_pointer = S390_SP_REGNUM;
1688         }
1689     }
1690
1691   /* Once we know the frame register and the frame size, we can unwind
1692      the current value of the frame register from the next frame, and
1693      add back the frame size to arrive that the previous frame's
1694      stack pointer value.  */
1695   prev_sp = get_frame_register_unsigned (this_frame, frame_pointer) + size;
1696   cfa = prev_sp + 16*word_size + 32;
1697
1698   /* Set up ABI call-saved/call-clobbered registers.  */
1699   for (i = 0; i < S390_NUM_REGS; i++)
1700     if (!s390_register_call_saved (gdbarch, i))
1701       trad_frame_set_unknown (info->saved_regs, i);
1702
1703   /* CC is always call-clobbered.  */
1704   trad_frame_set_unknown (info->saved_regs, S390_PSWM_REGNUM);
1705
1706   /* Record the addresses of all register spill slots the prologue parser
1707      has recognized.  Consider only registers defined as call-saved by the
1708      ABI; for call-clobbered registers the parser may have recognized
1709      spurious stores.  */
1710
1711   for (i = 0; i < 16; i++)
1712     if (s390_register_call_saved (gdbarch, S390_R0_REGNUM + i)
1713         && data.gpr_slot[i] != 0)
1714       info->saved_regs[S390_R0_REGNUM + i].addr = cfa - data.gpr_slot[i];
1715
1716   for (i = 0; i < 16; i++)
1717     if (s390_register_call_saved (gdbarch, S390_F0_REGNUM + i)
1718         && data.fpr_slot[i] != 0)
1719       info->saved_regs[S390_F0_REGNUM + i].addr = cfa - data.fpr_slot[i];
1720
1721   /* Function return will set PC to %r14.  */
1722   info->saved_regs[S390_PSWA_REGNUM] = info->saved_regs[S390_RETADDR_REGNUM];
1723
1724   /* In frameless functions, we unwind simply by moving the return
1725      address to the PC.  However, if we actually stored to the
1726      save area, use that -- we might only think the function frameless
1727      because we're in the middle of the prologue ...  */
1728   if (size == 0
1729       && !trad_frame_addr_p (info->saved_regs, S390_PSWA_REGNUM))
1730     {
1731       info->saved_regs[S390_PSWA_REGNUM].realreg = S390_RETADDR_REGNUM;
1732     }
1733
1734   /* Another sanity check: unless this is a frameless function,
1735      we should have found spill slots for SP and PC.
1736      If not, we cannot unwind further -- this happens e.g. in
1737      libc's thread_start routine.  */
1738   if (size > 0)
1739     {
1740       if (!trad_frame_addr_p (info->saved_regs, S390_SP_REGNUM)
1741           || !trad_frame_addr_p (info->saved_regs, S390_PSWA_REGNUM))
1742         prev_sp = -1;
1743     }
1744
1745   /* We use the current value of the frame register as local_base,
1746      and the top of the register save area as frame_base.  */
1747   if (prev_sp != -1)
1748     {
1749       info->frame_base = prev_sp + 16*word_size + 32;
1750       info->local_base = prev_sp - size;
1751     }
1752
1753   info->func = func;
1754   return 1;
1755 }
1756
1757 static void
1758 s390_backchain_frame_unwind_cache (struct frame_info *this_frame,
1759                                    struct s390_unwind_cache *info)
1760 {
1761   struct gdbarch *gdbarch = get_frame_arch (this_frame);
1762   int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1763   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1764   CORE_ADDR backchain;
1765   ULONGEST reg;
1766   LONGEST sp;
1767   int i;
1768
1769   /* Set up ABI call-saved/call-clobbered registers.  */
1770   for (i = 0; i < S390_NUM_REGS; i++)
1771     if (!s390_register_call_saved (gdbarch, i))
1772       trad_frame_set_unknown (info->saved_regs, i);
1773
1774   /* CC is always call-clobbered.  */
1775   trad_frame_set_unknown (info->saved_regs, S390_PSWM_REGNUM);
1776
1777   /* Get the backchain.  */
1778   reg = get_frame_register_unsigned (this_frame, S390_SP_REGNUM);
1779   backchain = read_memory_unsigned_integer (reg, word_size, byte_order);
1780
1781   /* A zero backchain terminates the frame chain.  As additional
1782      sanity check, let's verify that the spill slot for SP in the
1783      save area pointed to by the backchain in fact links back to
1784      the save area.  */
1785   if (backchain != 0
1786       && safe_read_memory_integer (backchain + 15*word_size,
1787                                    word_size, byte_order, &sp)
1788       && (CORE_ADDR)sp == backchain)
1789     {
1790       /* We don't know which registers were saved, but it will have
1791          to be at least %r14 and %r15.  This will allow us to continue
1792          unwinding, but other prev-frame registers may be incorrect ...  */
1793       info->saved_regs[S390_SP_REGNUM].addr = backchain + 15*word_size;
1794       info->saved_regs[S390_RETADDR_REGNUM].addr = backchain + 14*word_size;
1795
1796       /* Function return will set PC to %r14.  */
1797       info->saved_regs[S390_PSWA_REGNUM]
1798         = info->saved_regs[S390_RETADDR_REGNUM];
1799
1800       /* We use the current value of the frame register as local_base,
1801          and the top of the register save area as frame_base.  */
1802       info->frame_base = backchain + 16*word_size + 32;
1803       info->local_base = reg;
1804     }
1805
1806   info->func = get_frame_pc (this_frame);
1807 }
1808
1809 static struct s390_unwind_cache *
1810 s390_frame_unwind_cache (struct frame_info *this_frame,
1811                          void **this_prologue_cache)
1812 {
1813   volatile struct gdb_exception ex;
1814   struct s390_unwind_cache *info;
1815
1816   if (*this_prologue_cache)
1817     return *this_prologue_cache;
1818
1819   info = FRAME_OBSTACK_ZALLOC (struct s390_unwind_cache);
1820   *this_prologue_cache = info;
1821   info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
1822   info->func = -1;
1823   info->frame_base = -1;
1824   info->local_base = -1;
1825
1826   TRY_CATCH (ex, RETURN_MASK_ERROR)
1827     {
1828       /* Try to use prologue analysis to fill the unwind cache.
1829          If this fails, fall back to reading the stack backchain.  */
1830       if (!s390_prologue_frame_unwind_cache (this_frame, info))
1831         s390_backchain_frame_unwind_cache (this_frame, info);
1832     }
1833   if (ex.reason < 0 && ex.error != NOT_AVAILABLE_ERROR)
1834     throw_exception (ex);
1835
1836   return info;
1837 }
1838
1839 static void
1840 s390_frame_this_id (struct frame_info *this_frame,
1841                     void **this_prologue_cache,
1842                     struct frame_id *this_id)
1843 {
1844   struct s390_unwind_cache *info
1845     = s390_frame_unwind_cache (this_frame, this_prologue_cache);
1846
1847   if (info->frame_base == -1)
1848     return;
1849
1850   *this_id = frame_id_build (info->frame_base, info->func);
1851 }
1852
1853 static struct value *
1854 s390_frame_prev_register (struct frame_info *this_frame,
1855                           void **this_prologue_cache, int regnum)
1856 {
1857   struct gdbarch *gdbarch = get_frame_arch (this_frame);
1858   struct s390_unwind_cache *info
1859     = s390_frame_unwind_cache (this_frame, this_prologue_cache);
1860
1861   return s390_trad_frame_prev_register (this_frame, info->saved_regs, regnum);
1862 }
1863
1864 static const struct frame_unwind s390_frame_unwind = {
1865   NORMAL_FRAME,
1866   default_frame_unwind_stop_reason,
1867   s390_frame_this_id,
1868   s390_frame_prev_register,
1869   NULL,
1870   default_frame_sniffer
1871 };
1872
1873
1874 /* Code stubs and their stack frames.  For things like PLTs and NULL
1875    function calls (where there is no true frame and the return address
1876    is in the RETADDR register).  */
1877
1878 struct s390_stub_unwind_cache
1879 {
1880   CORE_ADDR frame_base;
1881   struct trad_frame_saved_reg *saved_regs;
1882 };
1883
1884 static struct s390_stub_unwind_cache *
1885 s390_stub_frame_unwind_cache (struct frame_info *this_frame,
1886                               void **this_prologue_cache)
1887 {
1888   struct gdbarch *gdbarch = get_frame_arch (this_frame);
1889   int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1890   struct s390_stub_unwind_cache *info;
1891   ULONGEST reg;
1892
1893   if (*this_prologue_cache)
1894     return *this_prologue_cache;
1895
1896   info = FRAME_OBSTACK_ZALLOC (struct s390_stub_unwind_cache);
1897   *this_prologue_cache = info;
1898   info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
1899
1900   /* The return address is in register %r14.  */
1901   info->saved_regs[S390_PSWA_REGNUM].realreg = S390_RETADDR_REGNUM;
1902
1903   /* Retrieve stack pointer and determine our frame base.  */
1904   reg = get_frame_register_unsigned (this_frame, S390_SP_REGNUM);
1905   info->frame_base = reg + 16*word_size + 32;
1906
1907   return info;
1908 }
1909
1910 static void
1911 s390_stub_frame_this_id (struct frame_info *this_frame,
1912                          void **this_prologue_cache,
1913                          struct frame_id *this_id)
1914 {
1915   struct s390_stub_unwind_cache *info
1916     = s390_stub_frame_unwind_cache (this_frame, this_prologue_cache);
1917   *this_id = frame_id_build (info->frame_base, get_frame_pc (this_frame));
1918 }
1919
1920 static struct value *
1921 s390_stub_frame_prev_register (struct frame_info *this_frame,
1922                                void **this_prologue_cache, int regnum)
1923 {
1924   struct s390_stub_unwind_cache *info
1925     = s390_stub_frame_unwind_cache (this_frame, this_prologue_cache);
1926   return s390_trad_frame_prev_register (this_frame, info->saved_regs, regnum);
1927 }
1928
1929 static int
1930 s390_stub_frame_sniffer (const struct frame_unwind *self,
1931                          struct frame_info *this_frame,
1932                          void **this_prologue_cache)
1933 {
1934   CORE_ADDR addr_in_block;
1935   bfd_byte insn[S390_MAX_INSTR_SIZE];
1936
1937   /* If the current PC points to non-readable memory, we assume we
1938      have trapped due to an invalid function pointer call.  We handle
1939      the non-existing current function like a PLT stub.  */
1940   addr_in_block = get_frame_address_in_block (this_frame);
1941   if (in_plt_section (addr_in_block)
1942       || s390_readinstruction (insn, get_frame_pc (this_frame)) < 0)
1943     return 1;
1944   return 0;
1945 }
1946
1947 static const struct frame_unwind s390_stub_frame_unwind = {
1948   NORMAL_FRAME,
1949   default_frame_unwind_stop_reason,
1950   s390_stub_frame_this_id,
1951   s390_stub_frame_prev_register,
1952   NULL,
1953   s390_stub_frame_sniffer
1954 };
1955
1956
1957 /* Signal trampoline stack frames.  */
1958
1959 struct s390_sigtramp_unwind_cache {
1960   CORE_ADDR frame_base;
1961   struct trad_frame_saved_reg *saved_regs;
1962 };
1963
1964 static struct s390_sigtramp_unwind_cache *
1965 s390_sigtramp_frame_unwind_cache (struct frame_info *this_frame,
1966                                   void **this_prologue_cache)
1967 {
1968   struct gdbarch *gdbarch = get_frame_arch (this_frame);
1969   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1970   int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1971   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1972   struct s390_sigtramp_unwind_cache *info;
1973   ULONGEST this_sp, prev_sp;
1974   CORE_ADDR next_ra, next_cfa, sigreg_ptr, sigreg_high_off;
1975   int i;
1976
1977   if (*this_prologue_cache)
1978     return *this_prologue_cache;
1979
1980   info = FRAME_OBSTACK_ZALLOC (struct s390_sigtramp_unwind_cache);
1981   *this_prologue_cache = info;
1982   info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
1983
1984   this_sp = get_frame_register_unsigned (this_frame, S390_SP_REGNUM);
1985   next_ra = get_frame_pc (this_frame);
1986   next_cfa = this_sp + 16*word_size + 32;
1987
1988   /* New-style RT frame:
1989         retcode + alignment (8 bytes)
1990         siginfo (128 bytes)
1991         ucontext (contains sigregs at offset 5 words).  */
1992   if (next_ra == next_cfa)
1993     {
1994       sigreg_ptr = next_cfa + 8 + 128 + align_up (5*word_size, 8);
1995       /* sigregs are followed by uc_sigmask (8 bytes), then by the
1996          upper GPR halves if present.  */
1997       sigreg_high_off = 8;
1998     }
1999
2000   /* Old-style RT frame and all non-RT frames:
2001         old signal mask (8 bytes)
2002         pointer to sigregs.  */
2003   else
2004     {
2005       sigreg_ptr = read_memory_unsigned_integer (next_cfa + 8,
2006                                                  word_size, byte_order);
2007       /* sigregs are followed by signo (4 bytes), then by the
2008          upper GPR halves if present.  */
2009       sigreg_high_off = 4;
2010     }
2011
2012   /* The sigregs structure looks like this:
2013             long   psw_mask;
2014             long   psw_addr;
2015             long   gprs[16];
2016             int    acrs[16];
2017             int    fpc;
2018             int    __pad;
2019             double fprs[16];  */
2020
2021   /* PSW mask and address.  */
2022   info->saved_regs[S390_PSWM_REGNUM].addr = sigreg_ptr;
2023   sigreg_ptr += word_size;
2024   info->saved_regs[S390_PSWA_REGNUM].addr = sigreg_ptr;
2025   sigreg_ptr += word_size;
2026
2027   /* Then the GPRs.  */
2028   for (i = 0; i < 16; i++)
2029     {
2030       info->saved_regs[S390_R0_REGNUM + i].addr = sigreg_ptr;
2031       sigreg_ptr += word_size;
2032     }
2033
2034   /* Then the ACRs.  */
2035   for (i = 0; i < 16; i++)
2036     {
2037       info->saved_regs[S390_A0_REGNUM + i].addr = sigreg_ptr;
2038       sigreg_ptr += 4;
2039     }
2040
2041   /* The floating-point control word.  */
2042   info->saved_regs[S390_FPC_REGNUM].addr = sigreg_ptr;
2043   sigreg_ptr += 8;
2044
2045   /* And finally the FPRs.  */
2046   for (i = 0; i < 16; i++)
2047     {
2048       info->saved_regs[S390_F0_REGNUM + i].addr = sigreg_ptr;
2049       sigreg_ptr += 8;
2050     }
2051
2052   /* If we have them, the GPR upper halves are appended at the end.  */
2053   sigreg_ptr += sigreg_high_off;
2054   if (tdep->gpr_full_regnum != -1)
2055     for (i = 0; i < 16; i++)
2056       {
2057         info->saved_regs[S390_R0_UPPER_REGNUM + i].addr = sigreg_ptr;
2058         sigreg_ptr += 4;
2059       }
2060
2061   /* Restore the previous frame's SP.  */
2062   prev_sp = read_memory_unsigned_integer (
2063                         info->saved_regs[S390_SP_REGNUM].addr,
2064                         word_size, byte_order);
2065
2066   /* Determine our frame base.  */
2067   info->frame_base = prev_sp + 16*word_size + 32;
2068
2069   return info;
2070 }
2071
2072 static void
2073 s390_sigtramp_frame_this_id (struct frame_info *this_frame,
2074                              void **this_prologue_cache,
2075                              struct frame_id *this_id)
2076 {
2077   struct s390_sigtramp_unwind_cache *info
2078     = s390_sigtramp_frame_unwind_cache (this_frame, this_prologue_cache);
2079   *this_id = frame_id_build (info->frame_base, get_frame_pc (this_frame));
2080 }
2081
2082 static struct value *
2083 s390_sigtramp_frame_prev_register (struct frame_info *this_frame,
2084                                    void **this_prologue_cache, int regnum)
2085 {
2086   struct s390_sigtramp_unwind_cache *info
2087     = s390_sigtramp_frame_unwind_cache (this_frame, this_prologue_cache);
2088   return s390_trad_frame_prev_register (this_frame, info->saved_regs, regnum);
2089 }
2090
2091 static int
2092 s390_sigtramp_frame_sniffer (const struct frame_unwind *self,
2093                              struct frame_info *this_frame,
2094                              void **this_prologue_cache)
2095 {
2096   CORE_ADDR pc = get_frame_pc (this_frame);
2097   bfd_byte sigreturn[2];
2098
2099   if (target_read_memory (pc, sigreturn, 2))
2100     return 0;
2101
2102   if (sigreturn[0] != op_svc)
2103     return 0;
2104
2105   if (sigreturn[1] != 119 /* sigreturn */
2106       && sigreturn[1] != 173 /* rt_sigreturn */)
2107     return 0;
2108
2109   return 1;
2110 }
2111
2112 static const struct frame_unwind s390_sigtramp_frame_unwind = {
2113   SIGTRAMP_FRAME,
2114   default_frame_unwind_stop_reason,
2115   s390_sigtramp_frame_this_id,
2116   s390_sigtramp_frame_prev_register,
2117   NULL,
2118   s390_sigtramp_frame_sniffer
2119 };
2120
2121 /* Retrieve the syscall number at a ptrace syscall-stop.  Return -1
2122    upon error. */
2123
2124 static LONGEST
2125 s390_linux_get_syscall_number (struct gdbarch *gdbarch,
2126                                ptid_t ptid)
2127 {
2128   struct regcache *regs = get_thread_regcache (ptid);
2129   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2130   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2131   ULONGEST pc;
2132   ULONGEST svc_number = -1;
2133   unsigned opcode;
2134
2135   /* Assume that the PC points after the 2-byte SVC instruction.  We
2136      don't currently support SVC via EXECUTE. */
2137   regcache_cooked_read_unsigned (regs, tdep->pc_regnum, &pc);
2138   pc -= 2;
2139   opcode = read_memory_unsigned_integer ((CORE_ADDR) pc, 1, byte_order);
2140   if (opcode != op_svc)
2141     return -1;
2142
2143   svc_number = read_memory_unsigned_integer ((CORE_ADDR) pc + 1, 1,
2144                                              byte_order);
2145   if (svc_number == 0)
2146     regcache_cooked_read_unsigned (regs, S390_R1_REGNUM, &svc_number);
2147
2148   return svc_number;
2149 }
2150
2151
2152 /* Frame base handling.  */
2153
2154 static CORE_ADDR
2155 s390_frame_base_address (struct frame_info *this_frame, void **this_cache)
2156 {
2157   struct s390_unwind_cache *info
2158     = s390_frame_unwind_cache (this_frame, this_cache);
2159   return info->frame_base;
2160 }
2161
2162 static CORE_ADDR
2163 s390_local_base_address (struct frame_info *this_frame, void **this_cache)
2164 {
2165   struct s390_unwind_cache *info
2166     = s390_frame_unwind_cache (this_frame, this_cache);
2167   return info->local_base;
2168 }
2169
2170 static const struct frame_base s390_frame_base = {
2171   &s390_frame_unwind,
2172   s390_frame_base_address,
2173   s390_local_base_address,
2174   s390_local_base_address
2175 };
2176
2177 static CORE_ADDR
2178 s390_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
2179 {
2180   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2181   ULONGEST pc;
2182   pc = frame_unwind_register_unsigned (next_frame, tdep->pc_regnum);
2183   return gdbarch_addr_bits_remove (gdbarch, pc);
2184 }
2185
2186 static CORE_ADDR
2187 s390_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
2188 {
2189   ULONGEST sp;
2190   sp = frame_unwind_register_unsigned (next_frame, S390_SP_REGNUM);
2191   return gdbarch_addr_bits_remove (gdbarch, sp);
2192 }
2193
2194
2195 /* DWARF-2 frame support.  */
2196
2197 static struct value *
2198 s390_dwarf2_prev_register (struct frame_info *this_frame, void **this_cache,
2199                            int regnum)
2200 {
2201   return s390_unwind_pseudo_register (this_frame, regnum);
2202 }
2203
2204 static void
2205 s390_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
2206                             struct dwarf2_frame_state_reg *reg,
2207                             struct frame_info *this_frame)
2208 {
2209   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2210
2211   /* The condition code (and thus PSW mask) is call-clobbered.  */
2212   if (regnum == S390_PSWM_REGNUM)
2213     reg->how = DWARF2_FRAME_REG_UNDEFINED;
2214
2215   /* The PSW address unwinds to the return address.  */
2216   else if (regnum == S390_PSWA_REGNUM)
2217     reg->how = DWARF2_FRAME_REG_RA;
2218
2219   /* Fixed registers are call-saved or call-clobbered
2220      depending on the ABI in use.  */
2221   else if (regnum < S390_NUM_REGS)
2222     {
2223       if (s390_register_call_saved (gdbarch, regnum))
2224         reg->how = DWARF2_FRAME_REG_SAME_VALUE;
2225       else
2226         reg->how = DWARF2_FRAME_REG_UNDEFINED;
2227     }
2228
2229   /* We install a special function to unwind pseudos.  */
2230   else
2231     {
2232       reg->how = DWARF2_FRAME_REG_FN;
2233       reg->loc.fn = s390_dwarf2_prev_register;
2234     }
2235 }
2236
2237
2238 /* Dummy function calls.  */
2239
2240 /* Return non-zero if TYPE is an integer-like type, zero otherwise.
2241    "Integer-like" types are those that should be passed the way
2242    integers are: integers, enums, ranges, characters, and booleans.  */
2243 static int
2244 is_integer_like (struct type *type)
2245 {
2246   enum type_code code = TYPE_CODE (type);
2247
2248   return (code == TYPE_CODE_INT
2249           || code == TYPE_CODE_ENUM
2250           || code == TYPE_CODE_RANGE
2251           || code == TYPE_CODE_CHAR
2252           || code == TYPE_CODE_BOOL);
2253 }
2254
2255 /* Return non-zero if TYPE is a pointer-like type, zero otherwise.
2256    "Pointer-like" types are those that should be passed the way
2257    pointers are: pointers and references.  */
2258 static int
2259 is_pointer_like (struct type *type)
2260 {
2261   enum type_code code = TYPE_CODE (type);
2262
2263   return (code == TYPE_CODE_PTR
2264           || code == TYPE_CODE_REF);
2265 }
2266
2267
2268 /* Return non-zero if TYPE is a `float singleton' or `double
2269    singleton', zero otherwise.
2270
2271    A `T singleton' is a struct type with one member, whose type is
2272    either T or a `T singleton'.  So, the following are all float
2273    singletons:
2274
2275    struct { float x };
2276    struct { struct { float x; } x; };
2277    struct { struct { struct { float x; } x; } x; };
2278
2279    ... and so on.
2280
2281    All such structures are passed as if they were floats or doubles,
2282    as the (revised) ABI says.  */
2283 static int
2284 is_float_singleton (struct type *type)
2285 {
2286   if (TYPE_CODE (type) == TYPE_CODE_STRUCT && TYPE_NFIELDS (type) == 1)
2287     {
2288       struct type *singleton_type = TYPE_FIELD_TYPE (type, 0);
2289       CHECK_TYPEDEF (singleton_type);
2290
2291       return (TYPE_CODE (singleton_type) == TYPE_CODE_FLT
2292               || TYPE_CODE (singleton_type) == TYPE_CODE_DECFLOAT
2293               || is_float_singleton (singleton_type));
2294     }
2295
2296   return 0;
2297 }
2298
2299
2300 /* Return non-zero if TYPE is a struct-like type, zero otherwise.
2301    "Struct-like" types are those that should be passed as structs are:
2302    structs and unions.
2303
2304    As an odd quirk, not mentioned in the ABI, GCC passes float and
2305    double singletons as if they were a plain float, double, etc.  (The
2306    corresponding union types are handled normally.)  So we exclude
2307    those types here.  *shrug* */
2308 static int
2309 is_struct_like (struct type *type)
2310 {
2311   enum type_code code = TYPE_CODE (type);
2312
2313   return (code == TYPE_CODE_UNION
2314           || (code == TYPE_CODE_STRUCT && ! is_float_singleton (type)));
2315 }
2316
2317
2318 /* Return non-zero if TYPE is a float-like type, zero otherwise.
2319    "Float-like" types are those that should be passed as
2320    floating-point values are.
2321
2322    You'd think this would just be floats, doubles, long doubles, etc.
2323    But as an odd quirk, not mentioned in the ABI, GCC passes float and
2324    double singletons as if they were a plain float, double, etc.  (The
2325    corresponding union types are handled normally.)  So we include
2326    those types here.  *shrug* */
2327 static int
2328 is_float_like (struct type *type)
2329 {
2330   return (TYPE_CODE (type) == TYPE_CODE_FLT
2331           || TYPE_CODE (type) == TYPE_CODE_DECFLOAT
2332           || is_float_singleton (type));
2333 }
2334
2335
2336 static int
2337 is_power_of_two (unsigned int n)
2338 {
2339   return ((n & (n - 1)) == 0);
2340 }
2341
2342 /* Return non-zero if TYPE should be passed as a pointer to a copy,
2343    zero otherwise.  */
2344 static int
2345 s390_function_arg_pass_by_reference (struct type *type)
2346 {
2347   if (TYPE_LENGTH (type) > 8)
2348     return 1;
2349
2350   return (is_struct_like (type) && !is_power_of_two (TYPE_LENGTH (type)))
2351           || TYPE_CODE (type) == TYPE_CODE_COMPLEX
2352           || (TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type));
2353 }
2354
2355 /* Return non-zero if TYPE should be passed in a float register
2356    if possible.  */
2357 static int
2358 s390_function_arg_float (struct type *type)
2359 {
2360   if (TYPE_LENGTH (type) > 8)
2361     return 0;
2362
2363   return is_float_like (type);
2364 }
2365
2366 /* Return non-zero if TYPE should be passed in an integer register
2367    (or a pair of integer registers) if possible.  */
2368 static int
2369 s390_function_arg_integer (struct type *type)
2370 {
2371   if (TYPE_LENGTH (type) > 8)
2372     return 0;
2373
2374    return is_integer_like (type)
2375           || is_pointer_like (type)
2376           || (is_struct_like (type) && is_power_of_two (TYPE_LENGTH (type)));
2377 }
2378
2379 /* Return ARG, a `SIMPLE_ARG', sign-extended or zero-extended to a full
2380    word as required for the ABI.  */
2381 static LONGEST
2382 extend_simple_arg (struct gdbarch *gdbarch, struct value *arg)
2383 {
2384   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2385   struct type *type = check_typedef (value_type (arg));
2386
2387   /* Even structs get passed in the least significant bits of the
2388      register / memory word.  It's not really right to extract them as
2389      an integer, but it does take care of the extension.  */
2390   if (TYPE_UNSIGNED (type))
2391     return extract_unsigned_integer (value_contents (arg),
2392                                      TYPE_LENGTH (type), byte_order);
2393   else
2394     return extract_signed_integer (value_contents (arg),
2395                                    TYPE_LENGTH (type), byte_order);
2396 }
2397
2398
2399 /* Return the alignment required by TYPE.  */
2400 static int
2401 alignment_of (struct type *type)
2402 {
2403   int alignment;
2404
2405   if (is_integer_like (type)
2406       || is_pointer_like (type)
2407       || TYPE_CODE (type) == TYPE_CODE_FLT
2408       || TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
2409     alignment = TYPE_LENGTH (type);
2410   else if (TYPE_CODE (type) == TYPE_CODE_STRUCT
2411            || TYPE_CODE (type) == TYPE_CODE_UNION)
2412     {
2413       int i;
2414
2415       alignment = 1;
2416       for (i = 0; i < TYPE_NFIELDS (type); i++)
2417         {
2418           int field_alignment
2419             = alignment_of (check_typedef (TYPE_FIELD_TYPE (type, i)));
2420
2421           if (field_alignment > alignment)
2422             alignment = field_alignment;
2423         }
2424     }
2425   else
2426     alignment = 1;
2427
2428   /* Check that everything we ever return is a power of two.  Lots of
2429      code doesn't want to deal with aligning things to arbitrary
2430      boundaries.  */
2431   gdb_assert ((alignment & (alignment - 1)) == 0);
2432
2433   return alignment;
2434 }
2435
2436
2437 /* Put the actual parameter values pointed to by ARGS[0..NARGS-1] in
2438    place to be passed to a function, as specified by the "GNU/Linux
2439    for S/390 ELF Application Binary Interface Supplement".
2440
2441    SP is the current stack pointer.  We must put arguments, links,
2442    padding, etc. whereever they belong, and return the new stack
2443    pointer value.
2444
2445    If STRUCT_RETURN is non-zero, then the function we're calling is
2446    going to return a structure by value; STRUCT_ADDR is the address of
2447    a block we've allocated for it on the stack.
2448
2449    Our caller has taken care of any type promotions needed to satisfy
2450    prototypes or the old K&R argument-passing rules.  */
2451 static CORE_ADDR
2452 s390_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
2453                       struct regcache *regcache, CORE_ADDR bp_addr,
2454                       int nargs, struct value **args, CORE_ADDR sp,
2455                       int struct_return, CORE_ADDR struct_addr)
2456 {
2457   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2458   int word_size = gdbarch_ptr_bit (gdbarch) / 8;
2459   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2460   int i;
2461
2462   /* If the i'th argument is passed as a reference to a copy, then
2463      copy_addr[i] is the address of the copy we made.  */
2464   CORE_ADDR *copy_addr = alloca (nargs * sizeof (CORE_ADDR));
2465
2466   /* Reserve space for the reference-to-copy area.  */
2467   for (i = 0; i < nargs; i++)
2468     {
2469       struct value *arg = args[i];
2470       struct type *type = check_typedef (value_type (arg));
2471
2472       if (s390_function_arg_pass_by_reference (type))
2473         {
2474           sp -= TYPE_LENGTH (type);
2475           sp = align_down (sp, alignment_of (type));
2476           copy_addr[i] = sp;
2477         }
2478     }
2479
2480   /* Reserve space for the parameter area.  As a conservative
2481      simplification, we assume that everything will be passed on the
2482      stack.  Since every argument larger than 8 bytes will be
2483      passed by reference, we use this simple upper bound.  */
2484   sp -= nargs * 8;
2485
2486   /* After all that, make sure it's still aligned on an eight-byte
2487      boundary.  */
2488   sp = align_down (sp, 8);
2489
2490   /* Allocate the standard frame areas: the register save area, the
2491      word reserved for the compiler (which seems kind of meaningless),
2492      and the back chain pointer.  */
2493   sp -= 16*word_size + 32;
2494
2495   /* Now we have the final SP value.  Make sure we didn't underflow;
2496      on 31-bit, this would result in addresses with the high bit set,
2497      which causes confusion elsewhere.  Note that if we error out
2498      here, stack and registers remain untouched.  */
2499   if (gdbarch_addr_bits_remove (gdbarch, sp) != sp)
2500     error (_("Stack overflow"));
2501
2502
2503   /* Finally, place the actual parameters, working from SP towards
2504      higher addresses.  The code above is supposed to reserve enough
2505      space for this.  */
2506   {
2507     int fr = 0;
2508     int gr = 2;
2509     CORE_ADDR starg = sp + 16*word_size + 32;
2510
2511     /* A struct is returned using general register 2.  */
2512     if (struct_return)
2513       {
2514         regcache_cooked_write_unsigned (regcache, S390_R0_REGNUM + gr,
2515                                         struct_addr);
2516         gr++;
2517       }
2518
2519     for (i = 0; i < nargs; i++)
2520       {
2521         struct value *arg = args[i];
2522         struct type *type = check_typedef (value_type (arg));
2523         unsigned length = TYPE_LENGTH (type);
2524
2525         if (s390_function_arg_pass_by_reference (type))
2526           {
2527             /* Actually copy the argument contents to the stack slot
2528                that was reserved above.  */
2529             write_memory (copy_addr[i], value_contents (arg), length);
2530
2531             if (gr <= 6)
2532               {
2533                 regcache_cooked_write_unsigned (regcache, S390_R0_REGNUM + gr,
2534                                                 copy_addr[i]);
2535                 gr++;
2536               }
2537             else
2538               {
2539                 write_memory_unsigned_integer (starg, word_size, byte_order,
2540                                                copy_addr[i]);
2541                 starg += word_size;
2542               }
2543           }
2544         else if (s390_function_arg_float (type))
2545           {
2546             /* The GNU/Linux for S/390 ABI uses FPRs 0 and 2 to pass arguments,
2547                the GNU/Linux for zSeries ABI uses 0, 2, 4, and 6.  */
2548             if (fr <= (tdep->abi == ABI_LINUX_S390 ? 2 : 6))
2549               {
2550                 /* When we store a single-precision value in an FP register,
2551                    it occupies the leftmost bits.  */
2552                 regcache_cooked_write_part (regcache, S390_F0_REGNUM + fr,
2553                                             0, length, value_contents (arg));
2554                 fr += 2;
2555               }
2556             else
2557               {
2558                 /* When we store a single-precision value in a stack slot,
2559                    it occupies the rightmost bits.  */
2560                 starg = align_up (starg + length, word_size);
2561                 write_memory (starg - length, value_contents (arg), length);
2562               }
2563           }
2564         else if (s390_function_arg_integer (type) && length <= word_size)
2565           {
2566             if (gr <= 6)
2567               {
2568                 /* Integer arguments are always extended to word size.  */
2569                 regcache_cooked_write_signed (regcache, S390_R0_REGNUM + gr,
2570                                               extend_simple_arg (gdbarch,
2571                                                                  arg));
2572                 gr++;
2573               }
2574             else
2575               {
2576                 /* Integer arguments are always extended to word size.  */
2577                 write_memory_signed_integer (starg, word_size, byte_order,
2578                                              extend_simple_arg (gdbarch, arg));
2579                 starg += word_size;
2580               }
2581           }
2582         else if (s390_function_arg_integer (type) && length == 2*word_size)
2583           {
2584             if (gr <= 5)
2585               {
2586                 regcache_cooked_write (regcache, S390_R0_REGNUM + gr,
2587                                        value_contents (arg));
2588                 regcache_cooked_write (regcache, S390_R0_REGNUM + gr + 1,
2589                                        value_contents (arg) + word_size);
2590                 gr += 2;
2591               }
2592             else
2593               {
2594                 /* If we skipped r6 because we couldn't fit a DOUBLE_ARG
2595                    in it, then don't go back and use it again later.  */
2596                 gr = 7;
2597
2598                 write_memory (starg, value_contents (arg), length);
2599                 starg += length;
2600               }
2601           }
2602         else
2603           internal_error (__FILE__, __LINE__, _("unknown argument type"));
2604       }
2605   }
2606
2607   /* Store return PSWA.  In 31-bit mode, keep addressing mode bit.  */
2608   if (word_size == 4)
2609     {
2610       ULONGEST pswa;
2611       regcache_cooked_read_unsigned (regcache, S390_PSWA_REGNUM, &pswa);
2612       bp_addr = (bp_addr & 0x7fffffff) | (pswa & 0x80000000);
2613     }
2614   regcache_cooked_write_unsigned (regcache, S390_RETADDR_REGNUM, bp_addr);
2615
2616   /* Store updated stack pointer.  */
2617   regcache_cooked_write_unsigned (regcache, S390_SP_REGNUM, sp);
2618
2619   /* We need to return the 'stack part' of the frame ID,
2620      which is actually the top of the register save area.  */
2621   return sp + 16*word_size + 32;
2622 }
2623
2624 /* Assuming THIS_FRAME is a dummy, return the frame ID of that
2625    dummy frame.  The frame ID's base needs to match the TOS value
2626    returned by push_dummy_call, and the PC match the dummy frame's
2627    breakpoint.  */
2628 static struct frame_id
2629 s390_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
2630 {
2631   int word_size = gdbarch_ptr_bit (gdbarch) / 8;
2632   CORE_ADDR sp = get_frame_register_unsigned (this_frame, S390_SP_REGNUM);
2633   sp = gdbarch_addr_bits_remove (gdbarch, sp);
2634
2635   return frame_id_build (sp + 16*word_size + 32,
2636                          get_frame_pc (this_frame));
2637 }
2638
2639 static CORE_ADDR
2640 s390_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
2641 {
2642   /* Both the 32- and 64-bit ABI's say that the stack pointer should
2643      always be aligned on an eight-byte boundary.  */
2644   return (addr & -8);
2645 }
2646
2647
2648 /* Function return value access.  */
2649
2650 static enum return_value_convention
2651 s390_return_value_convention (struct gdbarch *gdbarch, struct type *type)
2652 {
2653   if (TYPE_LENGTH (type) > 8)
2654     return RETURN_VALUE_STRUCT_CONVENTION;
2655
2656   switch (TYPE_CODE (type))
2657     {
2658     case TYPE_CODE_STRUCT:
2659     case TYPE_CODE_UNION:
2660     case TYPE_CODE_ARRAY:
2661     case TYPE_CODE_COMPLEX:
2662       return RETURN_VALUE_STRUCT_CONVENTION;
2663
2664     default:
2665       return RETURN_VALUE_REGISTER_CONVENTION;
2666     }
2667 }
2668
2669 static enum return_value_convention
2670 s390_return_value (struct gdbarch *gdbarch, struct value *function,
2671                    struct type *type, struct regcache *regcache,
2672                    gdb_byte *out, const gdb_byte *in)
2673 {
2674   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2675   int word_size = gdbarch_ptr_bit (gdbarch) / 8;
2676   enum return_value_convention rvc;
2677   int length;
2678
2679   type = check_typedef (type);
2680   rvc = s390_return_value_convention (gdbarch, type);
2681   length = TYPE_LENGTH (type);
2682
2683   if (in)
2684     {
2685       switch (rvc)
2686         {
2687         case RETURN_VALUE_REGISTER_CONVENTION:
2688           if (TYPE_CODE (type) == TYPE_CODE_FLT
2689               || TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
2690             {
2691               /* When we store a single-precision value in an FP register,
2692                  it occupies the leftmost bits.  */
2693               regcache_cooked_write_part (regcache, S390_F0_REGNUM,
2694                                           0, length, in);
2695             }
2696           else if (length <= word_size)
2697             {
2698               /* Integer arguments are always extended to word size.  */
2699               if (TYPE_UNSIGNED (type))
2700                 regcache_cooked_write_unsigned (regcache, S390_R2_REGNUM,
2701                         extract_unsigned_integer (in, length, byte_order));
2702               else
2703                 regcache_cooked_write_signed (regcache, S390_R2_REGNUM,
2704                         extract_signed_integer (in, length, byte_order));
2705             }
2706           else if (length == 2*word_size)
2707             {
2708               regcache_cooked_write (regcache, S390_R2_REGNUM, in);
2709               regcache_cooked_write (regcache, S390_R3_REGNUM, in + word_size);
2710             }
2711           else
2712             internal_error (__FILE__, __LINE__, _("invalid return type"));
2713           break;
2714
2715         case RETURN_VALUE_STRUCT_CONVENTION:
2716           error (_("Cannot set function return value."));
2717           break;
2718         }
2719     }
2720   else if (out)
2721     {
2722       switch (rvc)
2723         {
2724         case RETURN_VALUE_REGISTER_CONVENTION:
2725           if (TYPE_CODE (type) == TYPE_CODE_FLT
2726               || TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
2727             {
2728               /* When we store a single-precision value in an FP register,
2729                  it occupies the leftmost bits.  */
2730               regcache_cooked_read_part (regcache, S390_F0_REGNUM,
2731                                          0, length, out);
2732             }
2733           else if (length <= word_size)
2734             {
2735               /* Integer arguments occupy the rightmost bits.  */
2736               regcache_cooked_read_part (regcache, S390_R2_REGNUM,
2737                                          word_size - length, length, out);
2738             }
2739           else if (length == 2*word_size)
2740             {
2741               regcache_cooked_read (regcache, S390_R2_REGNUM, out);
2742               regcache_cooked_read (regcache, S390_R3_REGNUM, out + word_size);
2743             }
2744           else
2745             internal_error (__FILE__, __LINE__, _("invalid return type"));
2746           break;
2747
2748         case RETURN_VALUE_STRUCT_CONVENTION:
2749           error (_("Function return value unknown."));
2750           break;
2751         }
2752     }
2753
2754   return rvc;
2755 }
2756
2757
2758 /* Breakpoints.  */
2759
2760 static const gdb_byte *
2761 s390_breakpoint_from_pc (struct gdbarch *gdbarch,
2762                          CORE_ADDR *pcptr, int *lenptr)
2763 {
2764   static const gdb_byte breakpoint[] = { 0x0, 0x1 };
2765
2766   *lenptr = sizeof (breakpoint);
2767   return breakpoint;
2768 }
2769
2770
2771 /* Address handling.  */
2772
2773 static CORE_ADDR
2774 s390_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr)
2775 {
2776   return addr & 0x7fffffff;
2777 }
2778
2779 static int
2780 s390_address_class_type_flags (int byte_size, int dwarf2_addr_class)
2781 {
2782   if (byte_size == 4)
2783     return TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1;
2784   else
2785     return 0;
2786 }
2787
2788 static const char *
2789 s390_address_class_type_flags_to_name (struct gdbarch *gdbarch, int type_flags)
2790 {
2791   if (type_flags & TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1)
2792     return "mode32";
2793   else
2794     return NULL;
2795 }
2796
2797 static int
2798 s390_address_class_name_to_type_flags (struct gdbarch *gdbarch,
2799                                        const char *name,
2800                                        int *type_flags_ptr)
2801 {
2802   if (strcmp (name, "mode32") == 0)
2803     {
2804       *type_flags_ptr = TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1;
2805       return 1;
2806     }
2807   else
2808     return 0;
2809 }
2810
2811 /* Implementation of `gdbarch_stap_is_single_operand', as defined in
2812    gdbarch.h.  */
2813
2814 static int
2815 s390_stap_is_single_operand (struct gdbarch *gdbarch, const char *s)
2816 {
2817   return ((isdigit (*s) && s[1] == '(' && s[2] == '%') /* Displacement
2818                                                           or indirection.  */
2819           || *s == '%' /* Register access.  */
2820           || isdigit (*s)); /* Literal number.  */
2821 }
2822
2823 /* Set up gdbarch struct.  */
2824
2825 static struct gdbarch *
2826 s390_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
2827 {
2828   const struct target_desc *tdesc = info.target_desc;
2829   struct tdesc_arch_data *tdesc_data = NULL;
2830   struct gdbarch *gdbarch;
2831   struct gdbarch_tdep *tdep;
2832   int tdep_abi;
2833   int have_upper = 0;
2834   int have_linux_v1 = 0;
2835   int have_linux_v2 = 0;
2836   int have_tdb = 0;
2837   int first_pseudo_reg, last_pseudo_reg;
2838   static const char *const stap_register_prefixes[] = { "%", NULL };
2839   static const char *const stap_register_indirection_prefixes[] = { "(",
2840                                                                     NULL };
2841   static const char *const stap_register_indirection_suffixes[] = { ")",
2842                                                                     NULL };
2843
2844   /* Default ABI and register size.  */
2845   switch (info.bfd_arch_info->mach)
2846     {
2847     case bfd_mach_s390_31:
2848       tdep_abi = ABI_LINUX_S390;
2849       break;
2850
2851     case bfd_mach_s390_64:
2852       tdep_abi = ABI_LINUX_ZSERIES;
2853       break;
2854
2855     default:
2856       return NULL;
2857     }
2858
2859   /* Use default target description if none provided by the target.  */
2860   if (!tdesc_has_registers (tdesc))
2861     {
2862       if (tdep_abi == ABI_LINUX_S390)
2863         tdesc = tdesc_s390_linux32;
2864       else
2865         tdesc = tdesc_s390x_linux64;
2866     }
2867
2868   /* Check any target description for validity.  */
2869   if (tdesc_has_registers (tdesc))
2870     {
2871       static const char *const gprs[] = {
2872         "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2873         "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
2874       };
2875       static const char *const fprs[] = {
2876         "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
2877         "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15"
2878       };
2879       static const char *const acrs[] = {
2880         "acr0", "acr1", "acr2", "acr3", "acr4", "acr5", "acr6", "acr7",
2881         "acr8", "acr9", "acr10", "acr11", "acr12", "acr13", "acr14", "acr15"
2882       };
2883       static const char *const gprs_lower[] = {
2884         "r0l", "r1l", "r2l", "r3l", "r4l", "r5l", "r6l", "r7l",
2885         "r8l", "r9l", "r10l", "r11l", "r12l", "r13l", "r14l", "r15l"
2886       };
2887       static const char *const gprs_upper[] = {
2888         "r0h", "r1h", "r2h", "r3h", "r4h", "r5h", "r6h", "r7h",
2889         "r8h", "r9h", "r10h", "r11h", "r12h", "r13h", "r14h", "r15h"
2890       };
2891       static const char *const tdb_regs[] = {
2892         "tdb0", "tac", "tct", "atia",
2893         "tr0", "tr1", "tr2", "tr3", "tr4", "tr5", "tr6", "tr7",
2894         "tr8", "tr9", "tr10", "tr11", "tr12", "tr13", "tr14", "tr15"
2895       };
2896       const struct tdesc_feature *feature;
2897       int i, valid_p = 1;
2898
2899       feature = tdesc_find_feature (tdesc, "org.gnu.gdb.s390.core");
2900       if (feature == NULL)
2901         return NULL;
2902
2903       tdesc_data = tdesc_data_alloc ();
2904
2905       valid_p &= tdesc_numbered_register (feature, tdesc_data,
2906                                           S390_PSWM_REGNUM, "pswm");
2907       valid_p &= tdesc_numbered_register (feature, tdesc_data,
2908                                           S390_PSWA_REGNUM, "pswa");
2909
2910       if (tdesc_unnumbered_register (feature, "r0"))
2911         {
2912           for (i = 0; i < 16; i++)
2913             valid_p &= tdesc_numbered_register (feature, tdesc_data,
2914                                                 S390_R0_REGNUM + i, gprs[i]);
2915         }
2916       else
2917         {
2918           have_upper = 1;
2919
2920           for (i = 0; i < 16; i++)
2921             valid_p &= tdesc_numbered_register (feature, tdesc_data,
2922                                                 S390_R0_REGNUM + i,
2923                                                 gprs_lower[i]);
2924           for (i = 0; i < 16; i++)
2925             valid_p &= tdesc_numbered_register (feature, tdesc_data,
2926                                                 S390_R0_UPPER_REGNUM + i,
2927                                                 gprs_upper[i]);
2928         }
2929
2930       feature = tdesc_find_feature (tdesc, "org.gnu.gdb.s390.fpr");
2931       if (feature == NULL)
2932         {
2933           tdesc_data_cleanup (tdesc_data);
2934           return NULL;
2935         }
2936
2937       valid_p &= tdesc_numbered_register (feature, tdesc_data,
2938                                           S390_FPC_REGNUM, "fpc");
2939       for (i = 0; i < 16; i++)
2940         valid_p &= tdesc_numbered_register (feature, tdesc_data,
2941                                             S390_F0_REGNUM + i, fprs[i]);
2942
2943       feature = tdesc_find_feature (tdesc, "org.gnu.gdb.s390.acr");
2944       if (feature == NULL)
2945         {
2946           tdesc_data_cleanup (tdesc_data);
2947           return NULL;
2948         }
2949
2950       for (i = 0; i < 16; i++)
2951         valid_p &= tdesc_numbered_register (feature, tdesc_data,
2952                                             S390_A0_REGNUM + i, acrs[i]);
2953
2954       /* Optional GNU/Linux-specific "registers".  */
2955       feature = tdesc_find_feature (tdesc, "org.gnu.gdb.s390.linux");
2956       if (feature)
2957         {
2958           tdesc_numbered_register (feature, tdesc_data,
2959                                    S390_ORIG_R2_REGNUM, "orig_r2");
2960
2961           if (tdesc_numbered_register (feature, tdesc_data,
2962                                        S390_LAST_BREAK_REGNUM, "last_break"))
2963             have_linux_v1 = 1;
2964
2965           if (tdesc_numbered_register (feature, tdesc_data,
2966                                        S390_SYSTEM_CALL_REGNUM, "system_call"))
2967             have_linux_v2 = 1;
2968
2969           if (have_linux_v2 > have_linux_v1)
2970             valid_p = 0;
2971         }
2972
2973       /* Transaction diagnostic block.  */
2974       feature = tdesc_find_feature (tdesc, "org.gnu.gdb.s390.tdb");
2975       if (feature)
2976         {
2977           for (i = 0; i < ARRAY_SIZE (tdb_regs); i++)
2978             valid_p &= tdesc_numbered_register (feature, tdesc_data,
2979                                                 S390_TDB_DWORD0_REGNUM + i,
2980                                                 tdb_regs[i]);
2981           have_tdb = 1;
2982         }
2983
2984       if (!valid_p)
2985         {
2986           tdesc_data_cleanup (tdesc_data);
2987           return NULL;
2988         }
2989     }
2990
2991   /* Find a candidate among extant architectures.  */
2992   for (arches = gdbarch_list_lookup_by_info (arches, &info);
2993        arches != NULL;
2994        arches = gdbarch_list_lookup_by_info (arches->next, &info))
2995     {
2996       tdep = gdbarch_tdep (arches->gdbarch);
2997       if (!tdep)
2998         continue;
2999       if (tdep->abi != tdep_abi)
3000         continue;
3001       if ((tdep->gpr_full_regnum != -1) != have_upper)
3002         continue;
3003       if (tdesc_data != NULL)
3004         tdesc_data_cleanup (tdesc_data);
3005       return arches->gdbarch;
3006     }
3007
3008   /* Otherwise create a new gdbarch for the specified machine type.  */
3009   tdep = XCNEW (struct gdbarch_tdep);
3010   tdep->abi = tdep_abi;
3011   tdep->have_linux_v1 = have_linux_v1;
3012   tdep->have_linux_v2 = have_linux_v2;
3013   tdep->have_tdb = have_tdb;
3014   gdbarch = gdbarch_alloc (&info, tdep);
3015
3016   set_gdbarch_believe_pcc_promotion (gdbarch, 0);
3017   set_gdbarch_char_signed (gdbarch, 0);
3018
3019   /* S/390 GNU/Linux uses either 64-bit or 128-bit long doubles.
3020      We can safely let them default to 128-bit, since the debug info
3021      will give the size of type actually used in each case.  */
3022   set_gdbarch_long_double_bit (gdbarch, 128);
3023   set_gdbarch_long_double_format (gdbarch, floatformats_ia64_quad);
3024
3025   /* Amount PC must be decremented by after a breakpoint.  This is
3026      often the number of bytes returned by gdbarch_breakpoint_from_pc but not
3027      always.  */
3028   set_gdbarch_decr_pc_after_break (gdbarch, 2);
3029   /* Stack grows downward.  */
3030   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
3031   set_gdbarch_breakpoint_from_pc (gdbarch, s390_breakpoint_from_pc);
3032   set_gdbarch_skip_prologue (gdbarch, s390_skip_prologue);
3033   set_gdbarch_in_function_epilogue_p (gdbarch, s390_in_function_epilogue_p);
3034
3035   set_gdbarch_num_regs (gdbarch, S390_NUM_REGS);
3036   set_gdbarch_sp_regnum (gdbarch, S390_SP_REGNUM);
3037   set_gdbarch_fp0_regnum (gdbarch, S390_F0_REGNUM);
3038   set_gdbarch_stab_reg_to_regnum (gdbarch, s390_dwarf_reg_to_regnum);
3039   set_gdbarch_dwarf2_reg_to_regnum (gdbarch, s390_dwarf_reg_to_regnum);
3040   set_gdbarch_value_from_register (gdbarch, s390_value_from_register);
3041   set_gdbarch_core_read_description (gdbarch, s390_core_read_description);
3042   set_gdbarch_iterate_over_regset_sections (gdbarch,
3043                                             s390_iterate_over_regset_sections);
3044   set_gdbarch_cannot_store_register (gdbarch, s390_cannot_store_register);
3045   set_gdbarch_write_pc (gdbarch, s390_write_pc);
3046   set_gdbarch_pseudo_register_read (gdbarch, s390_pseudo_register_read);
3047   set_gdbarch_pseudo_register_write (gdbarch, s390_pseudo_register_write);
3048   set_tdesc_pseudo_register_name (gdbarch, s390_pseudo_register_name);
3049   set_tdesc_pseudo_register_type (gdbarch, s390_pseudo_register_type);
3050   set_tdesc_pseudo_register_reggroup_p (gdbarch,
3051                                         s390_pseudo_register_reggroup_p);
3052   tdesc_use_registers (gdbarch, tdesc, tdesc_data);
3053
3054   /* Assign pseudo register numbers.  */
3055   first_pseudo_reg = gdbarch_num_regs (gdbarch);
3056   last_pseudo_reg = first_pseudo_reg;
3057   tdep->gpr_full_regnum = -1;
3058   if (have_upper)
3059     {
3060       tdep->gpr_full_regnum = last_pseudo_reg;
3061       last_pseudo_reg += 16;
3062     }
3063   tdep->pc_regnum = last_pseudo_reg++;
3064   tdep->cc_regnum = last_pseudo_reg++;
3065   set_gdbarch_pc_regnum (gdbarch, tdep->pc_regnum);
3066   set_gdbarch_num_pseudo_regs (gdbarch, last_pseudo_reg - first_pseudo_reg);
3067
3068   /* Inferior function calls.  */
3069   set_gdbarch_push_dummy_call (gdbarch, s390_push_dummy_call);
3070   set_gdbarch_dummy_id (gdbarch, s390_dummy_id);
3071   set_gdbarch_frame_align (gdbarch, s390_frame_align);
3072   set_gdbarch_return_value (gdbarch, s390_return_value);
3073
3074   /* Syscall handling.  */
3075   set_gdbarch_get_syscall_number (gdbarch, s390_linux_get_syscall_number);
3076
3077   /* Frame handling.  */
3078   dwarf2_frame_set_init_reg (gdbarch, s390_dwarf2_frame_init_reg);
3079   dwarf2_frame_set_adjust_regnum (gdbarch, s390_adjust_frame_regnum);
3080   dwarf2_append_unwinders (gdbarch);
3081   frame_base_append_sniffer (gdbarch, dwarf2_frame_base_sniffer);
3082   frame_unwind_append_unwinder (gdbarch, &s390_stub_frame_unwind);
3083   frame_unwind_append_unwinder (gdbarch, &s390_sigtramp_frame_unwind);
3084   frame_unwind_append_unwinder (gdbarch, &s390_frame_unwind);
3085   frame_base_set_default (gdbarch, &s390_frame_base);
3086   set_gdbarch_unwind_pc (gdbarch, s390_unwind_pc);
3087   set_gdbarch_unwind_sp (gdbarch, s390_unwind_sp);
3088
3089   /* Displaced stepping.  */
3090   set_gdbarch_displaced_step_copy_insn (gdbarch,
3091                                         simple_displaced_step_copy_insn);
3092   set_gdbarch_displaced_step_fixup (gdbarch, s390_displaced_step_fixup);
3093   set_gdbarch_displaced_step_free_closure (gdbarch,
3094                                            simple_displaced_step_free_closure);
3095   set_gdbarch_displaced_step_location (gdbarch,
3096                                        displaced_step_at_entry_point);
3097   set_gdbarch_max_insn_length (gdbarch, S390_MAX_INSTR_SIZE);
3098
3099   /* Note that GNU/Linux is the only OS supported on this
3100      platform.  */
3101   linux_init_abi (info, gdbarch);
3102
3103   switch (tdep->abi)
3104     {
3105     case ABI_LINUX_S390:
3106       set_gdbarch_addr_bits_remove (gdbarch, s390_addr_bits_remove);
3107       set_solib_svr4_fetch_link_map_offsets
3108         (gdbarch, svr4_ilp32_fetch_link_map_offsets);
3109
3110       set_xml_syscall_file_name (XML_SYSCALL_FILENAME_S390);
3111       break;
3112
3113     case ABI_LINUX_ZSERIES:
3114       set_gdbarch_long_bit (gdbarch, 64);
3115       set_gdbarch_long_long_bit (gdbarch, 64);
3116       set_gdbarch_ptr_bit (gdbarch, 64);
3117       set_solib_svr4_fetch_link_map_offsets
3118         (gdbarch, svr4_lp64_fetch_link_map_offsets);
3119       set_gdbarch_address_class_type_flags (gdbarch,
3120                                             s390_address_class_type_flags);
3121       set_gdbarch_address_class_type_flags_to_name (gdbarch,
3122                                                     s390_address_class_type_flags_to_name);
3123       set_gdbarch_address_class_name_to_type_flags (gdbarch,
3124                                                     s390_address_class_name_to_type_flags);
3125       set_xml_syscall_file_name (XML_SYSCALL_FILENAME_S390);
3126       break;
3127     }
3128
3129   set_gdbarch_print_insn (gdbarch, print_insn_s390);
3130
3131   set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
3132
3133   /* Enable TLS support.  */
3134   set_gdbarch_fetch_tls_load_module_address (gdbarch,
3135                                              svr4_fetch_objfile_link_map);
3136
3137   set_gdbarch_get_siginfo_type (gdbarch, linux_get_siginfo_type);
3138
3139   /* SystemTap functions.  */
3140   set_gdbarch_stap_register_prefixes (gdbarch, stap_register_prefixes);
3141   set_gdbarch_stap_register_indirection_prefixes (gdbarch,
3142                                           stap_register_indirection_prefixes);
3143   set_gdbarch_stap_register_indirection_suffixes (gdbarch,
3144                                           stap_register_indirection_suffixes);
3145   set_gdbarch_stap_is_single_operand (gdbarch, s390_stap_is_single_operand);
3146
3147   return gdbarch;
3148 }
3149
3150
3151 extern initialize_file_ftype _initialize_s390_tdep; /* -Wmissing-prototypes */
3152
3153 void
3154 _initialize_s390_tdep (void)
3155 {
3156   /* Hook us into the gdbarch mechanism.  */
3157   register_gdbarch_init (bfd_arch_s390, s390_gdbarch_init);
3158
3159   /* Initialize the GNU/Linux target descriptions.  */
3160   initialize_tdesc_s390_linux32 ();
3161   initialize_tdesc_s390_linux32v1 ();
3162   initialize_tdesc_s390_linux32v2 ();
3163   initialize_tdesc_s390_linux64 ();
3164   initialize_tdesc_s390_linux64v1 ();
3165   initialize_tdesc_s390_linux64v2 ();
3166   initialize_tdesc_s390_te_linux64 ();
3167   initialize_tdesc_s390x_linux64 ();
3168   initialize_tdesc_s390x_linux64v1 ();
3169   initialize_tdesc_s390x_linux64v2 ();
3170   initialize_tdesc_s390x_te_linux64 ();
3171 }