gdb/s390-linux-tdep.c

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