gdb/s390-linux-tdep.c

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