gdb/s390-linux-tdep.c

   1 /* Target-dependent code for GNU/Linux on s390.
   2
   3    Copyright (C) 2001-2024 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   std::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
 576   ULONGEST val;
 577   if (!safe_read_memory_unsigned_integer ((CORE_ADDR) pc, 1, byte_order,
 578                                           &val))
 579     return -1;
 580   opcode = val;
 581
 582   if (opcode != op_svc)
 583     return -1;
 584
 585   if (!safe_read_memory_unsigned_integer ((CORE_ADDR) pc + 1, 1, byte_order,
 586                                           &val))
 587     return -1;
 588   svc_number = val;
 589
 590   if (svc_number == 0)
 591     regcache_cooked_read_unsigned (regs, S390_R1_REGNUM, &svc_number);
 592
 593   return svc_number;
 594 }
 595
 596 /* Process record-replay */
 597
 598 static struct linux_record_tdep s390_linux_record_tdep;
 599 static struct linux_record_tdep s390x_linux_record_tdep;
 600
 601 /* Record all registers but PC register for process-record.  */
 602
 603 static int
 604 s390_all_but_pc_registers_record (struct regcache *regcache)
 605 {
 606   struct gdbarch *gdbarch = regcache->arch ();
 607   s390_gdbarch_tdep *tdep = gdbarch_tdep<s390_gdbarch_tdep> (gdbarch);
 608   int i;
 609
 610   for (i = 0; i < 16; i++)
 611     {
 612       if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + i))
 613         return -1;
 614       if (record_full_arch_list_add_reg (regcache, S390_A0_REGNUM + i))
 615         return -1;
 616       if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + i))
 617         return -1;
 618       if (tdep->gpr_full_regnum != -1)
 619         if (record_full_arch_list_add_reg (regcache, S390_R0_UPPER_REGNUM + i))
 620           return -1;
 621       if (tdep->v0_full_regnum != -1)
 622         {
 623           if (record_full_arch_list_add_reg (regcache, S390_V0_LOWER_REGNUM + i))
 624             return -1;
 625           if (record_full_arch_list_add_reg (regcache, S390_V16_REGNUM + i))
 626             return -1;
 627         }
 628     }
 629   if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
 630     return -1;
 631   if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
 632     return -1;
 633
 634   return 0;
 635 }
 636
 637 /* Canonicalize system call SYSCALL belonging to ABI.  Helper for
 638    s390_linux_syscall_record.  */
 639
 640 static enum gdb_syscall
 641 s390_canonicalize_syscall (int syscall, enum s390_abi_kind abi)
 642 {
 643   switch (syscall)
 644     {
 645     /* s390 syscall numbers < 222 are mostly the same as x86, so just list
 646        the exceptions.  */
 647     case 0:
 648       return gdb_sys_no_syscall;
 649     case 7:
 650       return gdb_sys_restart_syscall;
 651     /* These syscalls work only on 31-bit.  */
 652     case 13: /* time */
 653     case 16: /* lchown[16] */
 654     case 23: /* setuid[16] */
 655     case 24: /* getuid[16] */
 656     case 25: /* stime */
 657     case 46: /* setgid[16] */
 658     case 47: /* getgid[16] */
 659     case 49: /* seteuid[16] */
 660     case 50: /* getegid[16] */
 661     case 70: /* setreuid[16] */
 662     case 71: /* setregid[16] */
 663     case 76: /* [old_]getrlimit */
 664     case 80: /* getgroups[16] */
 665     case 81: /* setgroups[16] */
 666     case 95: /* fchown[16] */
 667     case 101: /* ioperm */
 668     case 138: /* setfsuid[16] */
 669     case 139: /* setfsgid[16] */
 670     case 140: /* _llseek */
 671     case 164: /* setresuid[16] */
 672     case 165: /* getresuid[16] */
 673     case 170: /* setresgid[16] */
 674     case 171: /* getresgid[16] */
 675     case 182: /* chown[16] */
 676     case 192: /* mmap2 */
 677     case 193: /* truncate64 */
 678     case 194: /* ftruncate64 */
 679     case 195: /* stat64 */
 680     case 196: /* lstat64 */
 681     case 197: /* fstat64 */
 682     case 221: /* fcntl64 */
 683       if (abi == ABI_LINUX_S390)
 684         return (enum gdb_syscall) syscall;
 685       return gdb_sys_no_syscall;
 686     /* These syscalls don't exist on s390.  */
 687     case 17: /* break */
 688     case 18: /* oldstat */
 689     case 28: /* oldfstat */
 690     case 31: /* stty */
 691     case 32: /* gtty */
 692     case 35: /* ftime */
 693     case 44: /* prof */
 694     case 53: /* lock */
 695     case 56: /* mpx */
 696     case 58: /* ulimit */
 697     case 59: /* oldolduname */
 698     case 68: /* sgetmask */
 699     case 69: /* ssetmask */
 700     case 82: /* [old_]select */
 701     case 84: /* oldlstat */
 702     case 98: /* profil */
 703     case 109: /* olduname */
 704     case 113: /* vm86old */
 705     case 123: /* modify_ldt */
 706     case 166: /* vm86 */
 707       return gdb_sys_no_syscall;
 708     case 110:
 709       return gdb_sys_lookup_dcookie;
 710     /* Here come the differences.  */
 711     case 222:
 712       return gdb_sys_readahead;
 713     case 223:
 714       if (abi == ABI_LINUX_S390)
 715         return gdb_sys_sendfile64;
 716       return gdb_sys_no_syscall;
 717     /* 224-235 handled below */
 718     case 236:
 719       return gdb_sys_gettid;
 720     case 237:
 721       return gdb_sys_tkill;
 722     case 238:
 723       return gdb_sys_futex;
 724     case 239:
 725       return gdb_sys_sched_setaffinity;
 726     case 240:
 727       return gdb_sys_sched_getaffinity;
 728     case 241:
 729       return gdb_sys_tgkill;
 730     /* 242 reserved */
 731     case 243:
 732       return gdb_sys_io_setup;
 733     case 244:
 734       return gdb_sys_io_destroy;
 735     case 245:
 736       return gdb_sys_io_getevents;
 737     case 246:
 738       return gdb_sys_io_submit;
 739     case 247:
 740       return gdb_sys_io_cancel;
 741     case 248:
 742       return gdb_sys_exit_group;
 743     case 249:
 744       return gdb_sys_epoll_create;
 745     case 250:
 746       return gdb_sys_epoll_ctl;
 747     case 251:
 748       return gdb_sys_epoll_wait;
 749     case 252:
 750       return gdb_sys_set_tid_address;
 751     case 253:
 752       return gdb_sys_fadvise64;
 753     /* 254-262 handled below */
 754     /* 263 reserved */
 755     case 264:
 756       if (abi == ABI_LINUX_S390)
 757         return gdb_sys_fadvise64_64;
 758       return gdb_sys_no_syscall;
 759     case 265:
 760       return gdb_sys_statfs64;
 761     case 266:
 762       return gdb_sys_fstatfs64;
 763     case 267:
 764       return gdb_sys_remap_file_pages;
 765     /* 268-270 reserved */
 766     /* 271-277 handled below */
 767     case 278:
 768       return gdb_sys_add_key;
 769     case 279:
 770       return gdb_sys_request_key;
 771     case 280:
 772       return gdb_sys_keyctl;
 773     case 281:
 774       return gdb_sys_waitid;
 775     /* 282-312 handled below */
 776     case 293:
 777       if (abi == ABI_LINUX_S390)
 778         return gdb_sys_fstatat64;
 779       return gdb_sys_newfstatat;
 780     /* 313+ not yet supported */
 781     default:
 782       {
 783         int ret;
 784
 785         /* Most "old" syscalls copied from i386.  */
 786         if (syscall <= 221)
 787           ret = syscall;
 788         /* xattr syscalls.  */
 789         else if (syscall >= 224 && syscall <= 235)
 790           ret = syscall + 2;
 791         /* timer syscalls.  */
 792         else if (syscall >= 254 && syscall <= 262)
 793           ret = syscall + 5;
 794         /* mq_* and kexec_load */
 795         else if (syscall >= 271 && syscall <= 277)
 796           ret = syscall + 6;
 797         /* ioprio_set .. epoll_pwait */
 798         else if (syscall >= 282 && syscall <= 312)
 799           ret = syscall + 7;
 800         else if (syscall == 349)
 801           ret = gdb_sys_getrandom;
 802         else
 803           ret = gdb_sys_no_syscall;
 804
 805         return (enum gdb_syscall) ret;
 806       }
 807     }
 808 }
 809
 810 /* Record a system call.  Returns 0 on success, -1 otherwise.
 811    Helper function for s390_process_record.  */
 812
 813 static int
 814 s390_linux_syscall_record (struct regcache *regcache, LONGEST syscall_native)
 815 {
 816   struct gdbarch *gdbarch = regcache->arch ();
 817   s390_gdbarch_tdep *tdep = gdbarch_tdep<s390_gdbarch_tdep> (gdbarch);
 818   int ret;
 819   enum gdb_syscall syscall_gdb;
 820
 821   /* On s390, syscall number can be passed either as immediate field of svc
 822      instruction, or in %r1 (with svc 0).  */
 823   if (syscall_native == 0)
 824     regcache_raw_read_signed (regcache, S390_R1_REGNUM, &syscall_native);
 825
 826   syscall_gdb = s390_canonicalize_syscall (syscall_native, tdep->abi);
 827
 828   if (syscall_gdb < 0)
 829     {
 830       gdb_printf (gdb_stderr,
 831                   _("Process record and replay target doesn't "
 832                     "support syscall number %s\n"),
 833                   plongest (syscall_native));
 834       return -1;
 835     }
 836
 837   if (syscall_gdb == gdb_sys_sigreturn
 838       || syscall_gdb == gdb_sys_rt_sigreturn)
 839     {
 840       if (s390_all_but_pc_registers_record (regcache))
 841         return -1;
 842       return 0;
 843     }
 844
 845   if (tdep->abi == ABI_LINUX_ZSERIES)
 846     ret = record_linux_system_call (syscall_gdb, regcache,
 847                                     &s390x_linux_record_tdep);
 848   else
 849     ret = record_linux_system_call (syscall_gdb, regcache,
 850                                     &s390_linux_record_tdep);
 851
 852   if (ret)
 853     return ret;
 854
 855   /* Record the return value of the system call.  */
 856   if (record_full_arch_list_add_reg (regcache, S390_R2_REGNUM))
 857     return -1;
 858
 859   return 0;
 860 }
 861
 862 /* Implement process_record_signal gdbarch method.  */
 863
 864 static int
 865 s390_linux_record_signal (struct gdbarch *gdbarch, struct regcache *regcache,
 866                           enum gdb_signal signal)
 867 {
 868   s390_gdbarch_tdep *tdep = gdbarch_tdep<s390_gdbarch_tdep> (gdbarch);
 869   /* There are two kinds of signal frames on s390. rt_sigframe is always
 870      the larger one, so don't even bother with sigframe.  */
 871   const int sizeof_rt_sigframe = (tdep->abi == ABI_LINUX_ZSERIES ?
 872                                   160 + 8 + 128 + 1024 : 96 + 8 + 128 + 1000);
 873   ULONGEST sp;
 874   int i;
 875
 876   for (i = 0; i < 16; i++)
 877     {
 878       if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + i))
 879         return -1;
 880       if (tdep->gpr_full_regnum != -1)
 881         if (record_full_arch_list_add_reg (regcache, S390_R0_UPPER_REGNUM + i))
 882           return -1;
 883     }
 884   if (record_full_arch_list_add_reg (regcache, S390_PSWA_REGNUM))
 885     return -1;
 886   if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
 887     return -1;
 888
 889   /* Record the change in the stack.
 890      frame-size = sizeof (struct rt_sigframe) + SIGNAL_FRAMESIZE  */
 891   regcache_raw_read_unsigned (regcache, S390_SP_REGNUM, &sp);
 892   sp -= sizeof_rt_sigframe;
 893
 894   if (record_full_arch_list_add_mem (sp, sizeof_rt_sigframe))
 895     return -1;
 896
 897   if (record_full_arch_list_add_end ())
 898     return -1;
 899
 900   return 0;
 901 }
 902
 903 /* Initialize linux_record_tdep if not initialized yet.  */
 904
 905 static void
 906 s390_init_linux_record_tdep (struct linux_record_tdep *record_tdep,
 907                              enum s390_abi_kind abi)
 908 {
 909   /* These values are the size of the type that will be used in a system
 910      call.  They are obtained from Linux Kernel source.  */
 911
 912   if (abi == ABI_LINUX_ZSERIES)
 913     {
 914       record_tdep->size_pointer = 8;
 915       /* no _old_kernel_stat */
 916       record_tdep->size_tms = 32;
 917       record_tdep->size_loff_t = 8;
 918       record_tdep->size_flock = 32;
 919       record_tdep->size_ustat = 32;
 920       record_tdep->size_old_sigaction = 32;
 921       record_tdep->size_old_sigset_t = 8;
 922       record_tdep->size_rlimit = 16;
 923       record_tdep->size_rusage = 144;
 924       record_tdep->size_timeval = 16;
 925       record_tdep->size_timezone = 8;
 926       /* old_[ug]id_t never used */
 927       record_tdep->size_fd_set = 128;
 928       record_tdep->size_old_dirent = 280;
 929       record_tdep->size_statfs = 88;
 930       record_tdep->size_statfs64 = 88;
 931       record_tdep->size_sockaddr = 16;
 932       record_tdep->size_int = 4;
 933       record_tdep->size_long = 8;
 934       record_tdep->size_ulong = 8;
 935       record_tdep->size_msghdr = 56;
 936       record_tdep->size_itimerval = 32;
 937       record_tdep->size_stat = 144;
 938       /* old_utsname unused */
 939       record_tdep->size_sysinfo = 112;
 940       record_tdep->size_msqid_ds = 120;
 941       record_tdep->size_shmid_ds = 112;
 942       record_tdep->size_new_utsname = 390;
 943       record_tdep->size_timex = 208;
 944       record_tdep->size_mem_dqinfo = 24;
 945       record_tdep->size_if_dqblk = 72;
 946       record_tdep->size_fs_quota_stat = 80;
 947       record_tdep->size_timespec = 16;
 948       record_tdep->size_pollfd = 8;
 949       record_tdep->size_NFS_FHSIZE = 32;
 950       record_tdep->size_knfsd_fh = 132;
 951       record_tdep->size_TASK_COMM_LEN = 16;
 952       record_tdep->size_sigaction = 32;
 953       record_tdep->size_sigset_t = 8;
 954       record_tdep->size_siginfo_t = 128;
 955       record_tdep->size_cap_user_data_t = 12;
 956       record_tdep->size_stack_t = 24;
 957       record_tdep->size_off_t = 8;
 958       /* stat64 unused */
 959       record_tdep->size_gid_t = 4;
 960       record_tdep->size_uid_t = 4;
 961       record_tdep->size_PAGE_SIZE = 0x1000;        /* 4KB */
 962       record_tdep->size_flock64 = 32;
 963       record_tdep->size_io_event = 32;
 964       record_tdep->size_iocb = 64;
 965       record_tdep->size_epoll_event = 16;
 966       record_tdep->size_itimerspec = 32;
 967       record_tdep->size_mq_attr = 64;
 968       record_tdep->size_termios = 36;
 969       record_tdep->size_termios2 = 44;
 970       record_tdep->size_pid_t = 4;
 971       record_tdep->size_winsize = 8;
 972       record_tdep->size_serial_struct = 72;
 973       record_tdep->size_serial_icounter_struct = 80;
 974       record_tdep->size_size_t = 8;
 975       record_tdep->size_iovec = 16;
 976       record_tdep->size_time_t = 8;
 977     }
 978   else if (abi == ABI_LINUX_S390)
 979     {
 980       record_tdep->size_pointer = 4;
 981       record_tdep->size__old_kernel_stat = 32;
 982       record_tdep->size_tms = 16;
 983       record_tdep->size_loff_t = 8;
 984       record_tdep->size_flock = 16;
 985       record_tdep->size_ustat = 20;
 986       record_tdep->size_old_sigaction = 16;
 987       record_tdep->size_old_sigset_t = 4;
 988       record_tdep->size_rlimit = 8;
 989       record_tdep->size_rusage = 72;
 990       record_tdep->size_timeval = 8;
 991       record_tdep->size_timezone = 8;
 992       record_tdep->size_old_gid_t = 2;
 993       record_tdep->size_old_uid_t = 2;
 994       record_tdep->size_fd_set = 128;
 995       record_tdep->size_old_dirent = 268;
 996       record_tdep->size_statfs = 64;
 997       record_tdep->size_statfs64 = 88;
 998       record_tdep->size_sockaddr = 16;
 999       record_tdep->size_int = 4;
1000       record_tdep->size_long = 4;
1001       record_tdep->size_ulong = 4;
1002       record_tdep->size_msghdr = 28;
1003       record_tdep->size_itimerval = 16;
1004       record_tdep->size_stat = 64;
1005       /* old_utsname unused */
1006       record_tdep->size_sysinfo = 64;
1007       record_tdep->size_msqid_ds = 88;
1008       record_tdep->size_shmid_ds = 84;
1009       record_tdep->size_new_utsname = 390;
1010       record_tdep->size_timex = 128;
1011       record_tdep->size_mem_dqinfo = 24;
1012       record_tdep->size_if_dqblk = 72;
1013       record_tdep->size_fs_quota_stat = 80;
1014       record_tdep->size_timespec = 8;
1015       record_tdep->size_pollfd = 8;
1016       record_tdep->size_NFS_FHSIZE = 32;
1017       record_tdep->size_knfsd_fh = 132;
1018       record_tdep->size_TASK_COMM_LEN = 16;
1019       record_tdep->size_sigaction = 20;
1020       record_tdep->size_sigset_t = 8;
1021       record_tdep->size_siginfo_t = 128;
1022       record_tdep->size_cap_user_data_t = 12;
1023       record_tdep->size_stack_t = 12;
1024       record_tdep->size_off_t = 4;
1025       record_tdep->size_stat64 = 104;
1026       record_tdep->size_gid_t = 4;
1027       record_tdep->size_uid_t = 4;
1028       record_tdep->size_PAGE_SIZE = 0x1000;        /* 4KB */
1029       record_tdep->size_flock64 = 32;
1030       record_tdep->size_io_event = 32;
1031       record_tdep->size_iocb = 64;
1032       record_tdep->size_epoll_event = 16;
1033       record_tdep->size_itimerspec = 16;
1034       record_tdep->size_mq_attr = 32;
1035       record_tdep->size_termios = 36;
1036       record_tdep->size_termios2 = 44;
1037       record_tdep->size_pid_t = 4;
1038       record_tdep->size_winsize = 8;
1039       record_tdep->size_serial_struct = 60;
1040       record_tdep->size_serial_icounter_struct = 80;
1041       record_tdep->size_size_t = 4;
1042       record_tdep->size_iovec = 8;
1043       record_tdep->size_time_t = 4;
1044     }
1045
1046   /* These values are the second argument of system call "sys_fcntl"
1047      and "sys_fcntl64".  They are obtained from Linux Kernel source.  */
1048   record_tdep->fcntl_F_GETLK = 5;
1049   record_tdep->fcntl_F_GETLK64 = 12;
1050   record_tdep->fcntl_F_SETLK64 = 13;
1051   record_tdep->fcntl_F_SETLKW64 = 14;
1052
1053   record_tdep->arg1 = S390_R2_REGNUM;
1054   record_tdep->arg2 = S390_R3_REGNUM;
1055   record_tdep->arg3 = S390_R4_REGNUM;
1056   record_tdep->arg4 = S390_R5_REGNUM;
1057   record_tdep->arg5 = S390_R6_REGNUM;
1058
1059   /* These values are the second argument of system call "sys_ioctl".
1060      They are obtained from Linux Kernel source.
1061      See arch/s390/include/uapi/asm/ioctls.h.  */
1062
1063   record_tdep->ioctl_TCGETS = 0x5401;
1064   record_tdep->ioctl_TCSETS = 0x5402;
1065   record_tdep->ioctl_TCSETSW = 0x5403;
1066   record_tdep->ioctl_TCSETSF = 0x5404;
1067   record_tdep->ioctl_TCGETA = 0x5405;
1068   record_tdep->ioctl_TCSETA = 0x5406;
1069   record_tdep->ioctl_TCSETAW = 0x5407;
1070   record_tdep->ioctl_TCSETAF = 0x5408;
1071   record_tdep->ioctl_TCSBRK = 0x5409;
1072   record_tdep->ioctl_TCXONC = 0x540a;
1073   record_tdep->ioctl_TCFLSH = 0x540b;
1074   record_tdep->ioctl_TIOCEXCL = 0x540c;
1075   record_tdep->ioctl_TIOCNXCL = 0x540d;
1076   record_tdep->ioctl_TIOCSCTTY = 0x540e;
1077   record_tdep->ioctl_TIOCGPGRP = 0x540f;
1078   record_tdep->ioctl_TIOCSPGRP = 0x5410;
1079   record_tdep->ioctl_TIOCOUTQ = 0x5411;
1080   record_tdep->ioctl_TIOCSTI = 0x5412;
1081   record_tdep->ioctl_TIOCGWINSZ = 0x5413;
1082   record_tdep->ioctl_TIOCSWINSZ = 0x5414;
1083   record_tdep->ioctl_TIOCMGET = 0x5415;
1084   record_tdep->ioctl_TIOCMBIS = 0x5416;
1085   record_tdep->ioctl_TIOCMBIC = 0x5417;
1086   record_tdep->ioctl_TIOCMSET = 0x5418;
1087   record_tdep->ioctl_TIOCGSOFTCAR = 0x5419;
1088   record_tdep->ioctl_TIOCSSOFTCAR = 0x541a;
1089   record_tdep->ioctl_FIONREAD = 0x541b;
1090   record_tdep->ioctl_TIOCINQ = 0x541b; /* alias */
1091   record_tdep->ioctl_TIOCLINUX = 0x541c;
1092   record_tdep->ioctl_TIOCCONS = 0x541d;
1093   record_tdep->ioctl_TIOCGSERIAL = 0x541e;
1094   record_tdep->ioctl_TIOCSSERIAL = 0x541f;
1095   record_tdep->ioctl_TIOCPKT = 0x5420;
1096   record_tdep->ioctl_FIONBIO = 0x5421;
1097   record_tdep->ioctl_TIOCNOTTY = 0x5422;
1098   record_tdep->ioctl_TIOCSETD = 0x5423;
1099   record_tdep->ioctl_TIOCGETD = 0x5424;
1100   record_tdep->ioctl_TCSBRKP = 0x5425;
1101   record_tdep->ioctl_TIOCSBRK = 0x5427;
1102   record_tdep->ioctl_TIOCCBRK = 0x5428;
1103   record_tdep->ioctl_TIOCGSID = 0x5429;
1104   record_tdep->ioctl_TCGETS2 = 0x802c542a;
1105   record_tdep->ioctl_TCSETS2 = 0x402c542b;
1106   record_tdep->ioctl_TCSETSW2 = 0x402c542c;
1107   record_tdep->ioctl_TCSETSF2 = 0x402c542d;
1108   record_tdep->ioctl_TIOCGPTN = 0x80045430;
1109   record_tdep->ioctl_TIOCSPTLCK = 0x40045431;
1110   record_tdep->ioctl_FIONCLEX = 0x5450;
1111   record_tdep->ioctl_FIOCLEX = 0x5451;
1112   record_tdep->ioctl_FIOASYNC = 0x5452;
1113   record_tdep->ioctl_TIOCSERCONFIG = 0x5453;
1114   record_tdep->ioctl_TIOCSERGWILD = 0x5454;
1115   record_tdep->ioctl_TIOCSERSWILD = 0x5455;
1116   record_tdep->ioctl_TIOCGLCKTRMIOS = 0x5456;
1117   record_tdep->ioctl_TIOCSLCKTRMIOS = 0x5457;
1118   record_tdep->ioctl_TIOCSERGSTRUCT = 0x5458;
1119   record_tdep->ioctl_TIOCSERGETLSR = 0x5459;
1120   record_tdep->ioctl_TIOCSERGETMULTI = 0x545a;
1121   record_tdep->ioctl_TIOCSERSETMULTI = 0x545b;
1122   record_tdep->ioctl_TIOCMIWAIT = 0x545c;
1123   record_tdep->ioctl_TIOCGICOUNT = 0x545d;
1124   record_tdep->ioctl_FIOQSIZE = 0x545e;
1125 }
1126
1127 /* Initialize OSABI common for GNU/Linux on 31- and 64-bit systems.  */
1128
1129 static void
1130 s390_linux_init_abi_any (struct gdbarch_info info, struct gdbarch *gdbarch)
1131 {
1132   s390_gdbarch_tdep *tdep = gdbarch_tdep<s390_gdbarch_tdep> (gdbarch);
1133
1134   tdep->s390_syscall_record = s390_linux_syscall_record;
1135
1136   linux_init_abi (info, gdbarch, 1);
1137
1138   /* Register handling.  */
1139   set_gdbarch_core_read_description (gdbarch, s390_core_read_description);
1140   set_gdbarch_iterate_over_regset_sections (gdbarch,
1141                                             s390_iterate_over_regset_sections);
1142   set_gdbarch_write_pc (gdbarch, s390_write_pc);
1143   set_gdbarch_cannot_store_register (gdbarch, s390_cannot_store_register);
1144
1145   /* Syscall handling.  */
1146   set_gdbarch_get_syscall_number (gdbarch, s390_linux_get_syscall_number);
1147
1148   /* Frame handling.  */
1149   frame_unwind_append_unwinder (gdbarch, &s390_sigtramp_frame_unwind);
1150   set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
1151
1152   /* Enable TLS support.  */
1153   set_gdbarch_fetch_tls_load_module_address (gdbarch,
1154                                              svr4_fetch_objfile_link_map);
1155
1156   /* Support reverse debugging.  */
1157   set_gdbarch_process_record_signal (gdbarch, s390_linux_record_signal);
1158   s390_init_linux_record_tdep (&s390_linux_record_tdep, ABI_LINUX_S390);
1159   s390_init_linux_record_tdep (&s390x_linux_record_tdep, ABI_LINUX_ZSERIES);
1160 }
1161
1162 /* Initialize OSABI for GNU/Linux on 31-bit systems.  */
1163
1164 static void
1165 s390_linux_init_abi_31 (struct gdbarch_info info, struct gdbarch *gdbarch)
1166 {
1167   s390_gdbarch_tdep *tdep = gdbarch_tdep<s390_gdbarch_tdep> (gdbarch);
1168
1169   tdep->abi = ABI_LINUX_S390;
1170
1171   s390_linux_init_abi_any (info, gdbarch);
1172
1173   set_solib_svr4_fetch_link_map_offsets (gdbarch,
1174                                          linux_ilp32_fetch_link_map_offsets);
1175   set_xml_syscall_file_name (gdbarch, XML_SYSCALL_FILENAME_S390);
1176 }
1177
1178 /* Initialize OSABI for GNU/Linux on 64-bit systems.  */
1179
1180 static void
1181 s390_linux_init_abi_64 (struct gdbarch_info info, struct gdbarch *gdbarch)
1182 {
1183   s390_gdbarch_tdep *tdep = gdbarch_tdep<s390_gdbarch_tdep> (gdbarch);
1184
1185   tdep->abi = ABI_LINUX_ZSERIES;
1186
1187   s390_linux_init_abi_any (info, gdbarch);
1188
1189   set_solib_svr4_fetch_link_map_offsets (gdbarch,
1190                                          linux_lp64_fetch_link_map_offsets);
1191   set_xml_syscall_file_name (gdbarch, XML_SYSCALL_FILENAME_S390X);
1192 }
1193
1194 void _initialize_s390_linux_tdep ();
1195 void
1196 _initialize_s390_linux_tdep ()
1197 {
1198   /* Hook us into the OSABI mechanism.  */
1199   gdbarch_register_osabi (bfd_arch_s390, bfd_mach_s390_31, GDB_OSABI_LINUX,
1200                           s390_linux_init_abi_31);
1201   gdbarch_register_osabi (bfd_arch_s390, bfd_mach_s390_64, GDB_OSABI_LINUX,
1202                           s390_linux_init_abi_64);
1203
1204   /* Initialize the GNU/Linux target descriptions.  */
1205   initialize_tdesc_s390_linux32v1 ();
1206   initialize_tdesc_s390_linux32v2 ();
1207   initialize_tdesc_s390_linux64 ();
1208   initialize_tdesc_s390_linux64v1 ();
1209   initialize_tdesc_s390_linux64v2 ();
1210   initialize_tdesc_s390_te_linux64 ();
1211   initialize_tdesc_s390_vx_linux64 ();
1212   initialize_tdesc_s390_tevx_linux64 ();
1213   initialize_tdesc_s390_gs_linux64 ();
1214   initialize_tdesc_s390x_linux64v1 ();
1215   initialize_tdesc_s390x_linux64v2 ();
1216   initialize_tdesc_s390x_te_linux64 ();
1217   initialize_tdesc_s390x_vx_linux64 ();
1218   initialize_tdesc_s390x_tevx_linux64 ();
1219   initialize_tdesc_s390x_gs_linux64 ();
1220 }