gdb/s390-linux-tdep.c

   1 /* Target-dependent code for GNU/Linux on s390.
   2
   3    Copyright (C) 2001-2018 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
  25 #include "auxv.h"
  26 #include "elf/common.h"
  27 #include "frame-base.h"
  28 #include "frame-unwind.h"
  29 #include "gdbarch.h"
  30 #include "gdbcore.h"
  31 #include "linux-record.h"
  32 #include "linux-tdep.h"
  33 #include "objfiles.h"
  34 #include "osabi.h"
  35 #include "regcache.h"
  36 #include "record-full.h"
  37 #include "regset.h"
  38 #include "s390-tdep.h"
  39 #include "s390-linux-tdep.h"
  40 #include "solib-svr4.h"
  41 #include "target.h"
  42 #include "trad-frame.h"
  43 #include "xml-syscall.h"
  44
  45 #include "features/s390-linux32.c"
  46 #include "features/s390-linux32v1.c"
  47 #include "features/s390-linux32v2.c"
  48 #include "features/s390-linux64.c"
  49 #include "features/s390-linux64v1.c"
  50 #include "features/s390-linux64v2.c"
  51 #include "features/s390-te-linux64.c"
  52 #include "features/s390-vx-linux64.c"
  53 #include "features/s390-tevx-linux64.c"
  54 #include "features/s390-gs-linux64.c"
  55 #include "features/s390x-linux64.c"
  56 #include "features/s390x-linux64v1.c"
  57 #include "features/s390x-linux64v2.c"
  58 #include "features/s390x-te-linux64.c"
  59 #include "features/s390x-vx-linux64.c"
  60 #include "features/s390x-tevx-linux64.c"
  61 #include "features/s390x-gs-linux64.c"
  62
  63 #define XML_SYSCALL_FILENAME_S390 "syscalls/s390-linux.xml"
  64 #define XML_SYSCALL_FILENAME_S390X "syscalls/s390x-linux.xml"
  65
  66
  67 /* Register handling.  */
  68
  69 /* Implement cannot_store_register gdbarch method.  */
  70
  71 static int
  72 s390_cannot_store_register (struct gdbarch *gdbarch, int regnum)
  73 {
  74   /* The last-break address is read-only.  */
  75   return regnum == S390_LAST_BREAK_REGNUM;
  76 }
  77
  78 /* Implement write_pc gdbarch method.  */
  79
  80 static void
  81 s390_write_pc (struct regcache *regcache, CORE_ADDR pc)
  82 {
  83   struct gdbarch *gdbarch = regcache->arch ();
  84   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
  85
  86   regcache_cooked_write_unsigned (regcache, tdep->pc_regnum, pc);
  87
  88   /* Set special SYSTEM_CALL register to 0 to prevent the kernel from
  89      messing with the PC we just installed, if we happen to be within
  90      an interrupted system call that the kernel wants to restart.
  91
  92      Note that after we return from the dummy call, the SYSTEM_CALL and
  93      ORIG_R2 registers will be automatically restored, and the kernel
  94      continues to restart the system call at this point.  */
  95   if (register_size (gdbarch, S390_SYSTEM_CALL_REGNUM) > 0)
  96     regcache_cooked_write_unsigned (regcache, S390_SYSTEM_CALL_REGNUM, 0);
  97 }
  98
  99 /* Maps for register sets.  */
 100
 101 static const struct regcache_map_entry s390_gregmap[] =
 102   {
 103     { 1, S390_PSWM_REGNUM },
 104     { 1, S390_PSWA_REGNUM },
 105     { 16, S390_R0_REGNUM },
 106     { 16, S390_A0_REGNUM },
 107     { 1, S390_ORIG_R2_REGNUM },
 108     { 0 }
 109   };
 110
 111 static const struct regcache_map_entry s390_fpregmap[] =
 112   {
 113     { 1, S390_FPC_REGNUM, 8 },
 114     { 16, S390_F0_REGNUM, 8 },
 115     { 0 }
 116   };
 117
 118 static const struct regcache_map_entry s390_regmap_upper[] =
 119   {
 120     { 16, S390_R0_UPPER_REGNUM, 4 },
 121     { 0 }
 122   };
 123
 124 static const struct regcache_map_entry s390_regmap_last_break[] =
 125   {
 126     { 1, REGCACHE_MAP_SKIP, 4 },
 127     { 1, S390_LAST_BREAK_REGNUM, 4 },
 128     { 0 }
 129   };
 130
 131 static const struct regcache_map_entry s390x_regmap_last_break[] =
 132   {
 133     { 1, S390_LAST_BREAK_REGNUM, 8 },
 134     { 0 }
 135   };
 136
 137 static const struct regcache_map_entry s390_regmap_system_call[] =
 138   {
 139     { 1, S390_SYSTEM_CALL_REGNUM, 4 },
 140     { 0 }
 141   };
 142
 143 static const struct regcache_map_entry s390_regmap_tdb[] =
 144   {
 145     { 1, S390_TDB_DWORD0_REGNUM, 8 },
 146     { 1, S390_TDB_ABORT_CODE_REGNUM, 8 },
 147     { 1, S390_TDB_CONFLICT_TOKEN_REGNUM, 8 },
 148     { 1, S390_TDB_ATIA_REGNUM, 8 },
 149     { 12, REGCACHE_MAP_SKIP, 8 },
 150     { 16, S390_TDB_R0_REGNUM, 8 },
 151     { 0 }
 152   };
 153
 154 static const struct regcache_map_entry s390_regmap_vxrs_low[] =
 155   {
 156     { 16, S390_V0_LOWER_REGNUM, 8 },
 157     { 0 }
 158   };
 159
 160 static const struct regcache_map_entry s390_regmap_vxrs_high[] =
 161   {
 162     { 16, S390_V16_REGNUM, 16 },
 163     { 0 }
 164   };
 165
 166 static const struct regcache_map_entry s390_regmap_gs[] =
 167   {
 168     { 1, REGCACHE_MAP_SKIP, 8 },
 169     { 1, S390_GSD_REGNUM, 8 },
 170     { 1, S390_GSSM_REGNUM, 8 },
 171     { 1, S390_GSEPLA_REGNUM, 8 },
 172     { 0 }
 173   };
 174
 175 static const struct regcache_map_entry s390_regmap_gsbc[] =
 176   {
 177     { 1, REGCACHE_MAP_SKIP, 8 },
 178     { 1, S390_BC_GSD_REGNUM, 8 },
 179     { 1, S390_BC_GSSM_REGNUM, 8 },
 180     { 1, S390_BC_GSEPLA_REGNUM, 8 },
 181     { 0 }
 182   };
 183
 184 /* Supply the TDB regset.  Like regcache_supply_regset, but invalidate
 185    the TDB registers unless the TDB format field is valid.  */
 186
 187 static void
 188 s390_supply_tdb_regset (const struct regset *regset, struct regcache *regcache,
 189                     int regnum, const void *regs, size_t len)
 190 {
 191   ULONGEST tdw;
 192   enum register_status ret;
 193
 194   regcache_supply_regset (regset, regcache, regnum, regs, len);
 195   ret = regcache_cooked_read_unsigned (regcache, S390_TDB_DWORD0_REGNUM, &tdw);
 196   if (ret != REG_VALID || (tdw >> 56) != 1)
 197     regcache_supply_regset (regset, regcache, regnum, NULL, len);
 198 }
 199
 200 const struct regset s390_gregset = {
 201   s390_gregmap,
 202   regcache_supply_regset,
 203   regcache_collect_regset
 204 };
 205
 206 const struct regset s390_fpregset = {
 207   s390_fpregmap,
 208   regcache_supply_regset,
 209   regcache_collect_regset
 210 };
 211
 212 static const struct regset s390_upper_regset = {
 213   s390_regmap_upper,
 214   regcache_supply_regset,
 215   regcache_collect_regset
 216 };
 217
 218 const struct regset s390_last_break_regset = {
 219   s390_regmap_last_break,
 220   regcache_supply_regset,
 221   regcache_collect_regset
 222 };
 223
 224 const struct regset s390x_last_break_regset = {
 225   s390x_regmap_last_break,
 226   regcache_supply_regset,
 227   regcache_collect_regset
 228 };
 229
 230 const struct regset s390_system_call_regset = {
 231   s390_regmap_system_call,
 232   regcache_supply_regset,
 233   regcache_collect_regset
 234 };
 235
 236 const struct regset s390_tdb_regset = {
 237   s390_regmap_tdb,
 238   s390_supply_tdb_regset,
 239   regcache_collect_regset
 240 };
 241
 242 const struct regset s390_vxrs_low_regset = {
 243   s390_regmap_vxrs_low,
 244   regcache_supply_regset,
 245   regcache_collect_regset
 246 };
 247
 248 const struct regset s390_vxrs_high_regset = {
 249   s390_regmap_vxrs_high,
 250   regcache_supply_regset,
 251   regcache_collect_regset
 252 };
 253
 254 const struct regset s390_gs_regset = {
 255   s390_regmap_gs,
 256   regcache_supply_regset,
 257   regcache_collect_regset
 258 };
 259
 260 const struct regset s390_gsbc_regset = {
 261   s390_regmap_gsbc,
 262   regcache_supply_regset,
 263   regcache_collect_regset
 264 };
 265
 266 /* Iterate over supported core file register note sections. */
 267
 268 static void
 269 s390_iterate_over_regset_sections (struct gdbarch *gdbarch,
 270                                    iterate_over_regset_sections_cb *cb,
 271                                    void *cb_data,
 272                                    const struct regcache *regcache)
 273 {
 274   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 275   const int gregset_size = (tdep->abi == ABI_LINUX_S390 ?
 276                             s390_sizeof_gregset : s390x_sizeof_gregset);
 277
 278   cb (".reg", gregset_size, &s390_gregset, NULL, cb_data);
 279   cb (".reg2", s390_sizeof_fpregset, &s390_fpregset, NULL, cb_data);
 280
 281   if (tdep->abi == ABI_LINUX_S390 && tdep->gpr_full_regnum != -1)
 282     cb (".reg-s390-high-gprs", 16 * 4, &s390_upper_regset,
 283         "s390 GPR upper halves", cb_data);
 284
 285   if (tdep->have_linux_v1)
 286     cb (".reg-s390-last-break", 8,
 287         (gdbarch_ptr_bit (gdbarch) == 32
 288          ? &s390_last_break_regset : &s390x_last_break_regset),
 289         "s390 last-break address", cb_data);
 290
 291   if (tdep->have_linux_v2)
 292     cb (".reg-s390-system-call", 4, &s390_system_call_regset,
 293         "s390 system-call", cb_data);
 294
 295   /* If regcache is set, we are in "write" (gcore) mode.  In this
 296      case, don't iterate over the TDB unless its registers are
 297      available.  */
 298   if (tdep->have_tdb
 299       && (regcache == NULL
 300           || REG_VALID == regcache_register_status (regcache,
 301                                                     S390_TDB_DWORD0_REGNUM)))
 302     cb (".reg-s390-tdb", s390_sizeof_tdbregset, &s390_tdb_regset,
 303         "s390 TDB", cb_data);
 304
 305   if (tdep->v0_full_regnum != -1)
 306     {
 307       cb (".reg-s390-vxrs-low", 16 * 8, &s390_vxrs_low_regset,
 308           "s390 vector registers 0-15 lower half", cb_data);
 309       cb (".reg-s390-vxrs-high", 16 * 16, &s390_vxrs_high_regset,
 310           "s390 vector registers 16-31", cb_data);
 311     }
 312
 313   /* Iterate over the guarded-storage regsets if in "read" mode, or if
 314      their registers are available.  */
 315   if (tdep->have_gs)
 316     {
 317       if (regcache == NULL
 318           || REG_VALID == regcache_register_status (regcache,
 319                                                     S390_GSD_REGNUM))
 320         cb (".reg-s390-gs-cb", 4 * 8, &s390_gs_regset,
 321             "s390 guarded-storage registers", cb_data);
 322
 323       if (regcache == NULL
 324           || REG_VALID == regcache_register_status (regcache,
 325                                                     S390_BC_GSD_REGNUM))
 326         cb (".reg-s390-gs-bc", 4 * 8, &s390_gsbc_regset,
 327             "s390 guarded-storage broadcast control", cb_data);
 328     }
 329 }
 330
 331 /* Implement core_read_description gdbarch method.  */
 332
 333 static const struct target_desc *
 334 s390_core_read_description (struct gdbarch *gdbarch,
 335                             struct target_ops *target, bfd *abfd)
 336 {
 337   asection *section = bfd_get_section_by_name (abfd, ".reg");
 338   CORE_ADDR hwcap = 0;
 339   bool high_gprs, v1, v2, te, vx, gs;
 340
 341   target_auxv_search (target, AT_HWCAP, &hwcap);
 342   if (!section)
 343     return NULL;
 344
 345   high_gprs = (bfd_get_section_by_name (abfd, ".reg-s390-high-gprs")
 346                != NULL);
 347   v1 = (bfd_get_section_by_name (abfd, ".reg-s390-last-break") != NULL);
 348   v2 = (bfd_get_section_by_name (abfd, ".reg-s390-system-call") != NULL);
 349   vx = (hwcap & HWCAP_S390_VX);
 350   te = (hwcap & HWCAP_S390_TE);
 351   gs = (hwcap & HWCAP_S390_GS);
 352
 353   switch (bfd_section_size (abfd, section))
 354     {
 355     case s390_sizeof_gregset:
 356       if (high_gprs)
 357         return (gs ? tdesc_s390_gs_linux64 :
 358                 te && vx ? tdesc_s390_tevx_linux64 :
 359                 vx ? tdesc_s390_vx_linux64 :
 360                 te ? tdesc_s390_te_linux64 :
 361                 v2 ? tdesc_s390_linux64v2 :
 362                 v1 ? tdesc_s390_linux64v1 : tdesc_s390_linux64);
 363       else
 364         return (v2 ? tdesc_s390_linux32v2 :
 365                 v1 ? tdesc_s390_linux32v1 : tdesc_s390_linux32);
 366
 367     case s390x_sizeof_gregset:
 368       return (gs ? tdesc_s390x_gs_linux64 :
 369               te && vx ? tdesc_s390x_tevx_linux64 :
 370               vx ? tdesc_s390x_vx_linux64 :
 371               te ? tdesc_s390x_te_linux64 :
 372               v2 ? tdesc_s390x_linux64v2 :
 373               v1 ? tdesc_s390x_linux64v1 : tdesc_s390x_linux64);
 374
 375     default:
 376       return NULL;
 377     }
 378 }
 379
 380 /* Frame unwinding. */
 381
 382 /* Signal trampoline stack frames.  */
 383
 384 struct s390_sigtramp_unwind_cache {
 385   CORE_ADDR frame_base;
 386   struct trad_frame_saved_reg *saved_regs;
 387 };
 388
 389 /* Unwind THIS_FRAME and return the corresponding unwind cache for
 390    s390_sigtramp_frame_unwind.  */
 391
 392 static struct s390_sigtramp_unwind_cache *
 393 s390_sigtramp_frame_unwind_cache (struct frame_info *this_frame,
 394                                   void **this_prologue_cache)
 395 {
 396   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 397   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 398   int word_size = gdbarch_ptr_bit (gdbarch) / 8;
 399   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 400   struct s390_sigtramp_unwind_cache *info;
 401   ULONGEST this_sp, prev_sp;
 402   CORE_ADDR next_ra, next_cfa, sigreg_ptr, sigreg_high_off;
 403   int i;
 404
 405   if (*this_prologue_cache)
 406     return (struct s390_sigtramp_unwind_cache *) *this_prologue_cache;
 407
 408   info = FRAME_OBSTACK_ZALLOC (struct s390_sigtramp_unwind_cache);
 409   *this_prologue_cache = info;
 410   info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
 411
 412   this_sp = get_frame_register_unsigned (this_frame, S390_SP_REGNUM);
 413   next_ra = get_frame_pc (this_frame);
 414   next_cfa = this_sp + 16*word_size + 32;
 415
 416   /* New-style RT frame:
 417         retcode + alignment (8 bytes)
 418         siginfo (128 bytes)
 419         ucontext (contains sigregs at offset 5 words).  */
 420   if (next_ra == next_cfa)
 421     {
 422       sigreg_ptr = next_cfa + 8 + 128 + align_up (5*word_size, 8);
 423       /* sigregs are followed by uc_sigmask (8 bytes), then by the
 424          upper GPR halves if present.  */
 425       sigreg_high_off = 8;
 426     }
 427
 428   /* Old-style RT frame and all non-RT frames:
 429         old signal mask (8 bytes)
 430         pointer to sigregs.  */
 431   else
 432     {
 433       sigreg_ptr = read_memory_unsigned_integer (next_cfa + 8,
 434                                                  word_size, byte_order);
 435       /* sigregs are followed by signo (4 bytes), then by the
 436          upper GPR halves if present.  */
 437       sigreg_high_off = 4;
 438     }
 439
 440   /* The sigregs structure looks like this:
 441             long   psw_mask;
 442             long   psw_addr;
 443             long   gprs[16];
 444             int    acrs[16];
 445             int    fpc;
 446             int    __pad;
 447             double fprs[16];  */
 448
 449   /* PSW mask and address.  */
 450   info->saved_regs[S390_PSWM_REGNUM].addr = sigreg_ptr;
 451   sigreg_ptr += word_size;
 452   info->saved_regs[S390_PSWA_REGNUM].addr = sigreg_ptr;
 453   sigreg_ptr += word_size;
 454
 455   /* Then the GPRs.  */
 456   for (i = 0; i < 16; i++)
 457     {
 458       info->saved_regs[S390_R0_REGNUM + i].addr = sigreg_ptr;
 459       sigreg_ptr += word_size;
 460     }
 461
 462   /* Then the ACRs.  */
 463   for (i = 0; i < 16; i++)
 464     {
 465       info->saved_regs[S390_A0_REGNUM + i].addr = sigreg_ptr;
 466       sigreg_ptr += 4;
 467     }
 468
 469   /* The floating-point control word.  */
 470   info->saved_regs[S390_FPC_REGNUM].addr = sigreg_ptr;
 471   sigreg_ptr += 8;
 472
 473   /* And finally the FPRs.  */
 474   for (i = 0; i < 16; i++)
 475     {
 476       info->saved_regs[S390_F0_REGNUM + i].addr = sigreg_ptr;
 477       sigreg_ptr += 8;
 478     }
 479
 480   /* If we have them, the GPR upper halves are appended at the end.  */
 481   sigreg_ptr += sigreg_high_off;
 482   if (tdep->gpr_full_regnum != -1)
 483     for (i = 0; i < 16; i++)
 484       {
 485         info->saved_regs[S390_R0_UPPER_REGNUM + i].addr = sigreg_ptr;
 486         sigreg_ptr += 4;
 487       }
 488
 489   /* Restore the previous frame's SP.  */
 490   prev_sp = read_memory_unsigned_integer (
 491                         info->saved_regs[S390_SP_REGNUM].addr,
 492                         word_size, byte_order);
 493
 494   /* Determine our frame base.  */
 495   info->frame_base = prev_sp + 16*word_size + 32;
 496
 497   return info;
 498 }
 499
 500 /* Implement this_id frame_unwind method for s390_sigtramp_frame_unwind.  */
 501
 502 static void
 503 s390_sigtramp_frame_this_id (struct frame_info *this_frame,
 504                              void **this_prologue_cache,
 505                              struct frame_id *this_id)
 506 {
 507   struct s390_sigtramp_unwind_cache *info
 508     = s390_sigtramp_frame_unwind_cache (this_frame, this_prologue_cache);
 509   *this_id = frame_id_build (info->frame_base, get_frame_pc (this_frame));
 510 }
 511
 512 /* Implement prev_register frame_unwind method for sigtramp frames.  */
 513
 514 static struct value *
 515 s390_sigtramp_frame_prev_register (struct frame_info *this_frame,
 516                                    void **this_prologue_cache, int regnum)
 517 {
 518   struct s390_sigtramp_unwind_cache *info
 519     = s390_sigtramp_frame_unwind_cache (this_frame, this_prologue_cache);
 520   return s390_trad_frame_prev_register (this_frame, info->saved_regs, regnum);
 521 }
 522
 523 /* Implement sniffer frame_unwind method for sigtramp frames.  */
 524
 525 static int
 526 s390_sigtramp_frame_sniffer (const struct frame_unwind *self,
 527                              struct frame_info *this_frame,
 528                              void **this_prologue_cache)
 529 {
 530   CORE_ADDR pc = get_frame_pc (this_frame);
 531   bfd_byte sigreturn[2];
 532
 533   if (target_read_memory (pc, sigreturn, 2))
 534     return 0;
 535
 536   if (sigreturn[0] != op_svc)
 537     return 0;
 538
 539   if (sigreturn[1] != 119 /* sigreturn */
 540       && sigreturn[1] != 173 /* rt_sigreturn */)
 541     return 0;
 542
 543   return 1;
 544 }
 545
 546 /* S390 sigtramp frame unwinder.  */
 547
 548 static const struct frame_unwind s390_sigtramp_frame_unwind = {
 549   SIGTRAMP_FRAME,
 550   default_frame_unwind_stop_reason,
 551   s390_sigtramp_frame_this_id,
 552   s390_sigtramp_frame_prev_register,
 553   NULL,
 554   s390_sigtramp_frame_sniffer
 555 };
 556
 557 /* Syscall handling.  */
 558
 559 /* Retrieve the syscall number at a ptrace syscall-stop.  Return -1
 560    upon error. */
 561
 562 static LONGEST
 563 s390_linux_get_syscall_number (struct gdbarch *gdbarch,
 564                                ptid_t ptid)
 565 {
 566   struct regcache *regs = get_thread_regcache (ptid);
 567   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 568   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 569   ULONGEST pc;
 570   ULONGEST svc_number = -1;
 571   unsigned opcode;
 572
 573   /* Assume that the PC points after the 2-byte SVC instruction.  We
 574      don't currently support SVC via EXECUTE. */
 575   regcache_cooked_read_unsigned (regs, tdep->pc_regnum, &pc);
 576   pc -= 2;
 577   opcode = read_memory_unsigned_integer ((CORE_ADDR) pc, 1, byte_order);
 578   if (opcode != op_svc)
 579     return -1;
 580
 581   svc_number = read_memory_unsigned_integer ((CORE_ADDR) pc + 1, 1,
 582                                              byte_order);
 583   if (svc_number == 0)
 584     regcache_cooked_read_unsigned (regs, S390_R1_REGNUM, &svc_number);
 585
 586   return svc_number;
 587 }
 588
 589 /* Process record-replay */
 590
 591 static struct linux_record_tdep s390_linux_record_tdep;
 592 static struct linux_record_tdep s390x_linux_record_tdep;
 593
 594 /* Record all registers but PC register for process-record.  */
 595
 596 static int
 597 s390_all_but_pc_registers_record (struct regcache *regcache)
 598 {
 599   struct gdbarch *gdbarch = regcache->arch ();
 600   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 601   int i;
 602
 603   for (i = 0; i < 16; i++)
 604     {
 605       if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + i))
 606         return -1;
 607       if (record_full_arch_list_add_reg (regcache, S390_A0_REGNUM + i))
 608         return -1;
 609       if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + i))
 610         return -1;
 611       if (tdep->gpr_full_regnum != -1)
 612         if (record_full_arch_list_add_reg (regcache, S390_R0_UPPER_REGNUM + i))
 613           return -1;
 614       if (tdep->v0_full_regnum != -1)
 615         {
 616           if (record_full_arch_list_add_reg (regcache, S390_V0_LOWER_REGNUM + i))
 617             return -1;
 618           if (record_full_arch_list_add_reg (regcache, S390_V16_REGNUM + i))
 619             return -1;
 620         }
 621     }
 622   if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
 623     return -1;
 624   if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
 625     return -1;
 626
 627   return 0;
 628 }
 629
 630 /* Canonicalize system call SYSCALL belonging to ABI.  Helper for
 631    s390_linux_syscall_record.  */
 632
 633 static enum gdb_syscall
 634 s390_canonicalize_syscall (int syscall, enum s390_abi_kind abi)
 635 {
 636   switch (syscall)
 637     {
 638     /* s390 syscall numbers < 222 are mostly the same as x86, so just list
 639        the exceptions.  */
 640     case 0:
 641       return gdb_sys_no_syscall;
 642     case 7:
 643       return gdb_sys_restart_syscall;
 644     /* These syscalls work only on 31-bit.  */
 645     case 13: /* time */
 646     case 16: /* lchown[16] */
 647     case 23: /* setuid[16] */
 648     case 24: /* getuid[16] */
 649     case 25: /* stime */
 650     case 46: /* setgid[16] */
 651     case 47: /* getgid[16] */
 652     case 49: /* seteuid[16] */
 653     case 50: /* getegid[16] */
 654     case 70: /* setreuid[16] */
 655     case 71: /* setregid[16] */
 656     case 76: /* [old_]getrlimit */
 657     case 80: /* getgroups[16] */
 658     case 81: /* setgroups[16] */
 659     case 95: /* fchown[16] */
 660     case 101: /* ioperm */
 661     case 138: /* setfsuid[16] */
 662     case 139: /* setfsgid[16] */
 663     case 140: /* _llseek */
 664     case 164: /* setresuid[16] */
 665     case 165: /* getresuid[16] */
 666     case 170: /* setresgid[16] */
 667     case 171: /* getresgid[16] */
 668     case 182: /* chown[16] */
 669     case 192: /* mmap2 */
 670     case 193: /* truncate64 */
 671     case 194: /* ftruncate64 */
 672     case 195: /* stat64 */
 673     case 196: /* lstat64 */
 674     case 197: /* fstat64 */
 675     case 221: /* fcntl64 */
 676       if (abi == ABI_LINUX_S390)
 677         return (enum gdb_syscall) syscall;
 678       return gdb_sys_no_syscall;
 679     /* These syscalls don't exist on s390.  */
 680     case 17: /* break */
 681     case 18: /* oldstat */
 682     case 28: /* oldfstat */
 683     case 31: /* stty */
 684     case 32: /* gtty */
 685     case 35: /* ftime */
 686     case 44: /* prof */
 687     case 53: /* lock */
 688     case 56: /* mpx */
 689     case 58: /* ulimit */
 690     case 59: /* oldolduname */
 691     case 68: /* sgetmask */
 692     case 69: /* ssetmask */
 693     case 82: /* [old_]select */
 694     case 84: /* oldlstat */
 695     case 98: /* profil */
 696     case 109: /* olduname */
 697     case 113: /* vm86old */
 698     case 123: /* modify_ldt */
 699     case 166: /* vm86 */
 700       return gdb_sys_no_syscall;
 701     case 110:
 702       return gdb_sys_lookup_dcookie;
 703     /* Here come the differences.  */
 704     case 222:
 705       return gdb_sys_readahead;
 706     case 223:
 707       if (abi == ABI_LINUX_S390)
 708         return gdb_sys_sendfile64;
 709       return gdb_sys_no_syscall;
 710     /* 224-235 handled below */
 711     case 236:
 712       return gdb_sys_gettid;
 713     case 237:
 714       return gdb_sys_tkill;
 715     case 238:
 716       return gdb_sys_futex;
 717     case 239:
 718       return gdb_sys_sched_setaffinity;
 719     case 240:
 720       return gdb_sys_sched_getaffinity;
 721     case 241:
 722       return gdb_sys_tgkill;
 723     /* 242 reserved */
 724     case 243:
 725       return gdb_sys_io_setup;
 726     case 244:
 727       return gdb_sys_io_destroy;
 728     case 245:
 729       return gdb_sys_io_getevents;
 730     case 246:
 731       return gdb_sys_io_submit;
 732     case 247:
 733       return gdb_sys_io_cancel;
 734     case 248:
 735       return gdb_sys_exit_group;
 736     case 249:
 737       return gdb_sys_epoll_create;
 738     case 250:
 739       return gdb_sys_epoll_ctl;
 740     case 251:
 741       return gdb_sys_epoll_wait;
 742     case 252:
 743       return gdb_sys_set_tid_address;
 744     case 253:
 745       return gdb_sys_fadvise64;
 746     /* 254-262 handled below */
 747     /* 263 reserved */
 748     case 264:
 749       if (abi == ABI_LINUX_S390)
 750         return gdb_sys_fadvise64_64;
 751       return gdb_sys_no_syscall;
 752     case 265:
 753       return gdb_sys_statfs64;
 754     case 266:
 755       return gdb_sys_fstatfs64;
 756     case 267:
 757       return gdb_sys_remap_file_pages;
 758     /* 268-270 reserved */
 759     /* 271-277 handled below */
 760     case 278:
 761       return gdb_sys_add_key;
 762     case 279:
 763       return gdb_sys_request_key;
 764     case 280:
 765       return gdb_sys_keyctl;
 766     case 281:
 767       return gdb_sys_waitid;
 768     /* 282-312 handled below */
 769     case 293:
 770       if (abi == ABI_LINUX_S390)
 771         return gdb_sys_fstatat64;
 772       return gdb_sys_newfstatat;
 773     /* 313+ not yet supported */
 774     default:
 775       {
 776         int ret;
 777
 778         /* Most "old" syscalls copied from i386.  */
 779         if (syscall <= 221)
 780           ret = syscall;
 781         /* xattr syscalls.  */
 782         else if (syscall >= 224 && syscall <= 235)
 783           ret = syscall + 2;
 784         /* timer syscalls.  */
 785         else if (syscall >= 254 && syscall <= 262)
 786           ret = syscall + 5;
 787         /* mq_* and kexec_load */
 788         else if (syscall >= 271 && syscall <= 277)
 789           ret = syscall + 6;
 790         /* ioprio_set .. epoll_pwait */
 791         else if (syscall >= 282 && syscall <= 312)
 792           ret = syscall + 7;
 793         else
 794           ret = gdb_sys_no_syscall;
 795
 796         return (enum gdb_syscall) ret;
 797       }
 798     }
 799 }
 800
 801 /* Record a system call.  Returns 0 on success, -1 otherwise.
 802    Helper function for s390_process_record.  */
 803
 804 static int
 805 s390_linux_syscall_record (struct regcache *regcache, LONGEST syscall_native)
 806 {
 807   struct gdbarch *gdbarch = regcache->arch ();
 808   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 809   int ret;
 810   enum gdb_syscall syscall_gdb;
 811
 812   /* On s390, syscall number can be passed either as immediate field of svc
 813      instruction, or in %r1 (with svc 0).  */
 814   if (syscall_native == 0)
 815     regcache_raw_read_signed (regcache, S390_R1_REGNUM, &syscall_native);
 816
 817   syscall_gdb = s390_canonicalize_syscall (syscall_native, tdep->abi);
 818
 819   if (syscall_gdb < 0)
 820     {
 821       printf_unfiltered (_("Process record and replay target doesn't "
 822                            "support syscall number %s\n"),
 823                          plongest (syscall_native));
 824       return -1;
 825     }
 826
 827   if (syscall_gdb == gdb_sys_sigreturn
 828       || syscall_gdb == gdb_sys_rt_sigreturn)
 829     {
 830       if (s390_all_but_pc_registers_record (regcache))
 831         return -1;
 832       return 0;
 833     }
 834
 835   if (tdep->abi == ABI_LINUX_ZSERIES)
 836     ret = record_linux_system_call (syscall_gdb, regcache,
 837                                     &s390x_linux_record_tdep);
 838   else
 839     ret = record_linux_system_call (syscall_gdb, regcache,
 840                                     &s390_linux_record_tdep);
 841
 842   if (ret)
 843     return ret;
 844
 845   /* Record the return value of the system call.  */
 846   if (record_full_arch_list_add_reg (regcache, S390_R2_REGNUM))
 847     return -1;
 848
 849   return 0;
 850 }
 851
 852 /* Implement process_record_signal gdbarch method.  */
 853
 854 static int
 855 s390_linux_record_signal (struct gdbarch *gdbarch, struct regcache *regcache,
 856                           enum gdb_signal signal)
 857 {
 858   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 859   /* There are two kinds of signal frames on s390. rt_sigframe is always
 860      the larger one, so don't even bother with sigframe.  */
 861   const int sizeof_rt_sigframe = (tdep->abi == ABI_LINUX_ZSERIES ?
 862                                   160 + 8 + 128 + 1024 : 96 + 8 + 128 + 1000);
 863   ULONGEST sp;
 864   int i;
 865
 866   for (i = 0; i < 16; i++)
 867     {
 868       if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + i))
 869         return -1;
 870       if (tdep->gpr_full_regnum != -1)
 871         if (record_full_arch_list_add_reg (regcache, S390_R0_UPPER_REGNUM + i))
 872           return -1;
 873     }
 874   if (record_full_arch_list_add_reg (regcache, S390_PSWA_REGNUM))
 875     return -1;
 876   if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
 877     return -1;
 878
 879   /* Record the change in the stack.
 880      frame-size = sizeof (struct rt_sigframe) + SIGNAL_FRAMESIZE  */
 881   regcache_raw_read_unsigned (regcache, S390_SP_REGNUM, &sp);
 882   sp -= sizeof_rt_sigframe;
 883
 884   if (record_full_arch_list_add_mem (sp, sizeof_rt_sigframe))
 885     return -1;
 886
 887   if (record_full_arch_list_add_end ())
 888     return -1;
 889
 890   return 0;
 891 }
 892
 893 /* Initialize linux_record_tdep if not initialized yet.  */
 894
 895 static void
 896 s390_init_linux_record_tdep (struct linux_record_tdep *record_tdep,
 897                              enum s390_abi_kind abi)
 898 {
 899   /* These values are the size of the type that will be used in a system
 900      call.  They are obtained from Linux Kernel source.  */
 901
 902   if (abi == ABI_LINUX_ZSERIES)
 903     {
 904       record_tdep->size_pointer = 8;
 905       /* no _old_kernel_stat */
 906       record_tdep->size_tms = 32;
 907       record_tdep->size_loff_t = 8;
 908       record_tdep->size_flock = 32;
 909       record_tdep->size_ustat = 32;
 910       record_tdep->size_old_sigaction = 32;
 911       record_tdep->size_old_sigset_t = 8;
 912       record_tdep->size_rlimit = 16;
 913       record_tdep->size_rusage = 144;
 914       record_tdep->size_timeval = 16;
 915       record_tdep->size_timezone = 8;
 916       /* old_[ug]id_t never used */
 917       record_tdep->size_fd_set = 128;
 918       record_tdep->size_old_dirent = 280;
 919       record_tdep->size_statfs = 88;
 920       record_tdep->size_statfs64 = 88;
 921       record_tdep->size_sockaddr = 16;
 922       record_tdep->size_int = 4;
 923       record_tdep->size_long = 8;
 924       record_tdep->size_ulong = 8;
 925       record_tdep->size_msghdr = 56;
 926       record_tdep->size_itimerval = 32;
 927       record_tdep->size_stat = 144;
 928       /* old_utsname unused */
 929       record_tdep->size_sysinfo = 112;
 930       record_tdep->size_msqid_ds = 120;
 931       record_tdep->size_shmid_ds = 112;
 932       record_tdep->size_new_utsname = 390;
 933       record_tdep->size_timex = 208;
 934       record_tdep->size_mem_dqinfo = 24;
 935       record_tdep->size_if_dqblk = 72;
 936       record_tdep->size_fs_quota_stat = 80;
 937       record_tdep->size_timespec = 16;
 938       record_tdep->size_pollfd = 8;
 939       record_tdep->size_NFS_FHSIZE = 32;
 940       record_tdep->size_knfsd_fh = 132;
 941       record_tdep->size_TASK_COMM_LEN = 16;
 942       record_tdep->size_sigaction = 32;
 943       record_tdep->size_sigset_t = 8;
 944       record_tdep->size_siginfo_t = 128;
 945       record_tdep->size_cap_user_data_t = 12;
 946       record_tdep->size_stack_t = 24;
 947       record_tdep->size_off_t = 8;
 948       /* stat64 unused */
 949       record_tdep->size_gid_t = 4;
 950       record_tdep->size_uid_t = 4;
 951       record_tdep->size_PAGE_SIZE = 0x1000;        /* 4KB */
 952       record_tdep->size_flock64 = 32;
 953       record_tdep->size_io_event = 32;
 954       record_tdep->size_iocb = 64;
 955       record_tdep->size_epoll_event = 16;
 956       record_tdep->size_itimerspec = 32;
 957       record_tdep->size_mq_attr = 64;
 958       record_tdep->size_termios = 36;
 959       record_tdep->size_termios2 = 44;
 960       record_tdep->size_pid_t = 4;
 961       record_tdep->size_winsize = 8;
 962       record_tdep->size_serial_struct = 72;
 963       record_tdep->size_serial_icounter_struct = 80;
 964       record_tdep->size_size_t = 8;
 965       record_tdep->size_iovec = 16;
 966       record_tdep->size_time_t = 8;
 967     }
 968   else if (abi == ABI_LINUX_S390)
 969     {
 970       record_tdep->size_pointer = 4;
 971       record_tdep->size__old_kernel_stat = 32;
 972       record_tdep->size_tms = 16;
 973       record_tdep->size_loff_t = 8;
 974       record_tdep->size_flock = 16;
 975       record_tdep->size_ustat = 20;
 976       record_tdep->size_old_sigaction = 16;
 977       record_tdep->size_old_sigset_t = 4;
 978       record_tdep->size_rlimit = 8;
 979       record_tdep->size_rusage = 72;
 980       record_tdep->size_timeval = 8;
 981       record_tdep->size_timezone = 8;
 982       record_tdep->size_old_gid_t = 2;
 983       record_tdep->size_old_uid_t = 2;
 984       record_tdep->size_fd_set = 128;
 985       record_tdep->size_old_dirent = 268;
 986       record_tdep->size_statfs = 64;
 987       record_tdep->size_statfs64 = 88;
 988       record_tdep->size_sockaddr = 16;
 989       record_tdep->size_int = 4;
 990       record_tdep->size_long = 4;
 991       record_tdep->size_ulong = 4;
 992       record_tdep->size_msghdr = 28;
 993       record_tdep->size_itimerval = 16;
 994       record_tdep->size_stat = 64;
 995       /* old_utsname unused */
 996       record_tdep->size_sysinfo = 64;
 997       record_tdep->size_msqid_ds = 88;
 998       record_tdep->size_shmid_ds = 84;
 999       record_tdep->size_new_utsname = 390;
1000       record_tdep->size_timex = 128;
1001       record_tdep->size_mem_dqinfo = 24;
1002       record_tdep->size_if_dqblk = 72;
1003       record_tdep->size_fs_quota_stat = 80;
1004       record_tdep->size_timespec = 8;
1005       record_tdep->size_pollfd = 8;
1006       record_tdep->size_NFS_FHSIZE = 32;
1007       record_tdep->size_knfsd_fh = 132;
1008       record_tdep->size_TASK_COMM_LEN = 16;
1009       record_tdep->size_sigaction = 20;
1010       record_tdep->size_sigset_t = 8;
1011       record_tdep->size_siginfo_t = 128;
1012       record_tdep->size_cap_user_data_t = 12;
1013       record_tdep->size_stack_t = 12;
1014       record_tdep->size_off_t = 4;
1015       record_tdep->size_stat64 = 104;
1016       record_tdep->size_gid_t = 4;
1017       record_tdep->size_uid_t = 4;
1018       record_tdep->size_PAGE_SIZE = 0x1000;        /* 4KB */
1019       record_tdep->size_flock64 = 32;
1020       record_tdep->size_io_event = 32;
1021       record_tdep->size_iocb = 64;
1022       record_tdep->size_epoll_event = 16;
1023       record_tdep->size_itimerspec = 16;
1024       record_tdep->size_mq_attr = 32;
1025       record_tdep->size_termios = 36;
1026       record_tdep->size_termios2 = 44;
1027       record_tdep->size_pid_t = 4;
1028       record_tdep->size_winsize = 8;
1029       record_tdep->size_serial_struct = 60;
1030       record_tdep->size_serial_icounter_struct = 80;
1031       record_tdep->size_size_t = 4;
1032       record_tdep->size_iovec = 8;
1033       record_tdep->size_time_t = 4;
1034     }
1035
1036   /* These values are the second argument of system call "sys_fcntl"
1037      and "sys_fcntl64".  They are obtained from Linux Kernel source.  */
1038   record_tdep->fcntl_F_GETLK = 5;
1039   record_tdep->fcntl_F_GETLK64 = 12;
1040   record_tdep->fcntl_F_SETLK64 = 13;
1041   record_tdep->fcntl_F_SETLKW64 = 14;
1042
1043   record_tdep->arg1 = S390_R2_REGNUM;
1044   record_tdep->arg2 = S390_R3_REGNUM;
1045   record_tdep->arg3 = S390_R4_REGNUM;
1046   record_tdep->arg4 = S390_R5_REGNUM;
1047   record_tdep->arg5 = S390_R6_REGNUM;
1048
1049   /* These values are the second argument of system call "sys_ioctl".
1050      They are obtained from Linux Kernel source.
1051      See arch/s390/include/uapi/asm/ioctls.h.  */
1052
1053   record_tdep->ioctl_TCGETS = 0x5401;
1054   record_tdep->ioctl_TCSETS = 0x5402;
1055   record_tdep->ioctl_TCSETSW = 0x5403;
1056   record_tdep->ioctl_TCSETSF = 0x5404;
1057   record_tdep->ioctl_TCGETA = 0x5405;
1058   record_tdep->ioctl_TCSETA = 0x5406;
1059   record_tdep->ioctl_TCSETAW = 0x5407;
1060   record_tdep->ioctl_TCSETAF = 0x5408;
1061   record_tdep->ioctl_TCSBRK = 0x5409;
1062   record_tdep->ioctl_TCXONC = 0x540a;
1063   record_tdep->ioctl_TCFLSH = 0x540b;
1064   record_tdep->ioctl_TIOCEXCL = 0x540c;
1065   record_tdep->ioctl_TIOCNXCL = 0x540d;
1066   record_tdep->ioctl_TIOCSCTTY = 0x540e;
1067   record_tdep->ioctl_TIOCGPGRP = 0x540f;
1068   record_tdep->ioctl_TIOCSPGRP = 0x5410;
1069   record_tdep->ioctl_TIOCOUTQ = 0x5411;
1070   record_tdep->ioctl_TIOCSTI = 0x5412;
1071   record_tdep->ioctl_TIOCGWINSZ = 0x5413;
1072   record_tdep->ioctl_TIOCSWINSZ = 0x5414;
1073   record_tdep->ioctl_TIOCMGET = 0x5415;
1074   record_tdep->ioctl_TIOCMBIS = 0x5416;
1075   record_tdep->ioctl_TIOCMBIC = 0x5417;
1076   record_tdep->ioctl_TIOCMSET = 0x5418;
1077   record_tdep->ioctl_TIOCGSOFTCAR = 0x5419;
1078   record_tdep->ioctl_TIOCSSOFTCAR = 0x541a;
1079   record_tdep->ioctl_FIONREAD = 0x541b;
1080   record_tdep->ioctl_TIOCINQ = 0x541b; /* alias */
1081   record_tdep->ioctl_TIOCLINUX = 0x541c;
1082   record_tdep->ioctl_TIOCCONS = 0x541d;
1083   record_tdep->ioctl_TIOCGSERIAL = 0x541e;
1084   record_tdep->ioctl_TIOCSSERIAL = 0x541f;
1085   record_tdep->ioctl_TIOCPKT = 0x5420;
1086   record_tdep->ioctl_FIONBIO = 0x5421;
1087   record_tdep->ioctl_TIOCNOTTY = 0x5422;
1088   record_tdep->ioctl_TIOCSETD = 0x5423;
1089   record_tdep->ioctl_TIOCGETD = 0x5424;
1090   record_tdep->ioctl_TCSBRKP = 0x5425;
1091   record_tdep->ioctl_TIOCSBRK = 0x5427;
1092   record_tdep->ioctl_TIOCCBRK = 0x5428;
1093   record_tdep->ioctl_TIOCGSID = 0x5429;
1094   record_tdep->ioctl_TCGETS2 = 0x802c542a;
1095   record_tdep->ioctl_TCSETS2 = 0x402c542b;
1096   record_tdep->ioctl_TCSETSW2 = 0x402c542c;
1097   record_tdep->ioctl_TCSETSF2 = 0x402c542d;
1098   record_tdep->ioctl_TIOCGPTN = 0x80045430;
1099   record_tdep->ioctl_TIOCSPTLCK = 0x40045431;
1100   record_tdep->ioctl_FIONCLEX = 0x5450;
1101   record_tdep->ioctl_FIOCLEX = 0x5451;
1102   record_tdep->ioctl_FIOASYNC = 0x5452;
1103   record_tdep->ioctl_TIOCSERCONFIG = 0x5453;
1104   record_tdep->ioctl_TIOCSERGWILD = 0x5454;
1105   record_tdep->ioctl_TIOCSERSWILD = 0x5455;
1106   record_tdep->ioctl_TIOCGLCKTRMIOS = 0x5456;
1107   record_tdep->ioctl_TIOCSLCKTRMIOS = 0x5457;
1108   record_tdep->ioctl_TIOCSERGSTRUCT = 0x5458;
1109   record_tdep->ioctl_TIOCSERGETLSR = 0x5459;
1110   record_tdep->ioctl_TIOCSERGETMULTI = 0x545a;
1111   record_tdep->ioctl_TIOCSERSETMULTI = 0x545b;
1112   record_tdep->ioctl_TIOCMIWAIT = 0x545c;
1113   record_tdep->ioctl_TIOCGICOUNT = 0x545d;
1114   record_tdep->ioctl_FIOQSIZE = 0x545e;
1115 }
1116
1117 /* Initialize OSABI common for GNU/Linux on 31- and 64-bit systems.  */
1118
1119 static void
1120 s390_linux_init_abi_any (struct gdbarch_info info, struct gdbarch *gdbarch)
1121 {
1122   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1123
1124   tdep->s390_syscall_record = s390_linux_syscall_record;
1125
1126   linux_init_abi (info, gdbarch);
1127
1128   /* Register handling.  */
1129   set_gdbarch_core_read_description (gdbarch, s390_core_read_description);
1130   set_gdbarch_iterate_over_regset_sections (gdbarch,
1131                                             s390_iterate_over_regset_sections);
1132   set_gdbarch_write_pc (gdbarch, s390_write_pc);
1133   set_gdbarch_cannot_store_register (gdbarch, s390_cannot_store_register);
1134
1135   /* Syscall handling.  */
1136   set_gdbarch_get_syscall_number (gdbarch, s390_linux_get_syscall_number);
1137
1138   /* Frame handling.  */
1139   frame_unwind_append_unwinder (gdbarch, &s390_sigtramp_frame_unwind);
1140   set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
1141
1142   /* Enable TLS support.  */
1143   set_gdbarch_fetch_tls_load_module_address (gdbarch,
1144                                              svr4_fetch_objfile_link_map);
1145
1146   /* Support reverse debugging.  */
1147   set_gdbarch_process_record_signal (gdbarch, s390_linux_record_signal);
1148   s390_init_linux_record_tdep (&s390_linux_record_tdep, ABI_LINUX_S390);
1149   s390_init_linux_record_tdep (&s390x_linux_record_tdep, ABI_LINUX_ZSERIES);
1150 }
1151
1152 /* Initialize OSABI for GNU/Linux on 31-bit systems.  */
1153
1154 static void
1155 s390_linux_init_abi_31 (struct gdbarch_info info, struct gdbarch *gdbarch)
1156 {
1157   const struct target_desc *tdesc = info.target_desc;
1158   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1159
1160   tdep->abi = ABI_LINUX_S390;
1161   if (!tdesc_has_registers (tdesc))
1162     tdesc = tdesc_s390_linux32;
1163   tdep->tdesc = tdesc;
1164
1165   s390_linux_init_abi_any (info, gdbarch);
1166
1167   set_solib_svr4_fetch_link_map_offsets (gdbarch,
1168                                          svr4_ilp32_fetch_link_map_offsets);
1169   set_xml_syscall_file_name (gdbarch, XML_SYSCALL_FILENAME_S390);
1170 }
1171
1172 /* Initialize OSABI for GNU/Linux on 64-bit systems.  */
1173
1174 static void
1175 s390_linux_init_abi_64 (struct gdbarch_info info, struct gdbarch *gdbarch)
1176 {
1177   const struct target_desc *tdesc = info.target_desc;
1178   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1179
1180   tdep->abi = ABI_LINUX_ZSERIES;
1181   if (!tdesc_has_registers (tdesc))
1182     tdesc = tdesc_s390x_linux64;
1183   tdep->tdesc = tdesc;
1184
1185   s390_linux_init_abi_any (info, gdbarch);
1186
1187   set_solib_svr4_fetch_link_map_offsets (gdbarch,
1188                                          svr4_lp64_fetch_link_map_offsets);
1189   set_xml_syscall_file_name (gdbarch, XML_SYSCALL_FILENAME_S390X);
1190 }
1191
1192 void
1193 _initialize_s390_linux_tdep (void)
1194 {
1195   /* Hook us into the OSABI mechanism.  */
1196   gdbarch_register_osabi (bfd_arch_s390, bfd_mach_s390_31, GDB_OSABI_LINUX,
1197                           s390_linux_init_abi_31);
1198   gdbarch_register_osabi (bfd_arch_s390, bfd_mach_s390_64, GDB_OSABI_LINUX,
1199                           s390_linux_init_abi_64);
1200
1201   /* Initialize the GNU/Linux target descriptions.  */
1202   initialize_tdesc_s390_linux32 ();
1203   initialize_tdesc_s390_linux32v1 ();
1204   initialize_tdesc_s390_linux32v2 ();
1205   initialize_tdesc_s390_linux64 ();
1206   initialize_tdesc_s390_linux64v1 ();
1207   initialize_tdesc_s390_linux64v2 ();
1208   initialize_tdesc_s390_te_linux64 ();
1209   initialize_tdesc_s390_vx_linux64 ();
1210   initialize_tdesc_s390_tevx_linux64 ();
1211   initialize_tdesc_s390_gs_linux64 ();
1212   initialize_tdesc_s390x_linux64 ();
1213   initialize_tdesc_s390x_linux64v1 ();
1214   initialize_tdesc_s390x_linux64v2 ();
1215   initialize_tdesc_s390x_te_linux64 ();
1216   initialize_tdesc_s390x_vx_linux64 ();
1217   initialize_tdesc_s390x_tevx_linux64 ();
1218   initialize_tdesc_s390x_gs_linux64 ();
1219 }