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
  24 #include "auxv.h"
  25 #include "elf/common.h"
  26 #include "frame-base.h"
  27 #include "frame-unwind.h"
  28 #include "gdbarch.h"
  29 #include "gdbcore.h"
  30 #include "linux-record.h"
  31 #include "linux-tdep.h"
  32 #include "objfiles.h"
  33 #include "osabi.h"
  34 #include "regcache.h"
  35 #include "record-full.h"
  36 #include "regset.h"
  37 #include "s390-tdep.h"
  38 #include "s390-linux-tdep.h"
  39 #include "solib-svr4.h"
  40 #include "target.h"
  41 #include "trad-frame.h"
  42 #include "xml-syscall.h"
  43
  44 #include "features/s390-linux32v1.c"
  45 #include "features/s390-linux32v2.c"
  46 #include "features/s390-linux64.c"
  47 #include "features/s390-linux64v1.c"
  48 #include "features/s390-linux64v2.c"
  49 #include "features/s390-te-linux64.c"
  50 #include "features/s390-vx-linux64.c"
  51 #include "features/s390-tevx-linux64.c"
  52 #include "features/s390-gs-linux64.c"
  53 #include "features/s390x-linux64v1.c"
  54 #include "features/s390x-linux64v2.c"
  55 #include "features/s390x-te-linux64.c"
  56 #include "features/s390x-vx-linux64.c"
  57 #include "features/s390x-tevx-linux64.c"
  58 #include "features/s390x-gs-linux64.c"
  59
  60 #define XML_SYSCALL_FILENAME_S390 "syscalls/s390-linux.xml"
  61 #define XML_SYSCALL_FILENAME_S390X "syscalls/s390x-linux.xml"
  62
  63
  64 /* Register handling.  */
  65
  66 /* Implement cannot_store_register gdbarch method.  */
  67
  68 static int
  69 s390_cannot_store_register (struct gdbarch *gdbarch, int regnum)
  70 {
  71   /* The last-break address is read-only.  */
  72   return regnum == S390_LAST_BREAK_REGNUM;
  73 }
  74
  75 /* Implement write_pc gdbarch method.  */
  76
  77 static void
  78 s390_write_pc (struct regcache *regcache, CORE_ADDR pc)
  79 {
  80   struct gdbarch *gdbarch = regcache->arch ();
  81   s390_gdbarch_tdep *tdep = gdbarch_tdep<s390_gdbarch_tdep> (gdbarch);
  82
  83   regcache_cooked_write_unsigned (regcache, tdep->pc_regnum, pc);
  84
  85   /* Set special SYSTEM_CALL register to 0 to prevent the kernel from
  86      messing with the PC we just installed, if we happen to be within
  87      an interrupted system call that the kernel wants to restart.
  88
  89      Note that after we return from the dummy call, the SYSTEM_CALL and
  90      ORIG_R2 registers will be automatically restored, and the kernel
  91      continues to restart the system call at this point.  */
  92   if (register_size (gdbarch, S390_SYSTEM_CALL_REGNUM) > 0)
  93     regcache_cooked_write_unsigned (regcache, S390_SYSTEM_CALL_REGNUM, 0);
  94 }
  95
  96 /* Maps for register sets.  */
  97
  98 static const struct regcache_map_entry s390_gregmap[] =
  99   {
 100     { 1, S390_PSWM_REGNUM },
 101     { 1, S390_PSWA_REGNUM },
 102     { 16, S390_R0_REGNUM },
 103     { 16, S390_A0_REGNUM },
 104     { 1, S390_ORIG_R2_REGNUM },
 105     { 0 }
 106   };
 107
 108 static const struct regcache_map_entry s390_fpregmap[] =
 109   {
 110     { 1, S390_FPC_REGNUM, 8 },
 111     { 16, S390_F0_REGNUM, 8 },
 112     { 0 }
 113   };
 114
 115 static const struct regcache_map_entry s390_regmap_upper[] =
 116   {
 117     { 16, S390_R0_UPPER_REGNUM, 4 },
 118     { 0 }
 119   };
 120
 121 static const struct regcache_map_entry s390_regmap_last_break[] =
 122   {
 123     { 1, REGCACHE_MAP_SKIP, 4 },
 124     { 1, S390_LAST_BREAK_REGNUM, 4 },
 125     { 0 }
 126   };
 127
 128 static const struct regcache_map_entry s390x_regmap_last_break[] =
 129   {
 130     { 1, S390_LAST_BREAK_REGNUM, 8 },
 131     { 0 }
 132   };
 133
 134 static const struct regcache_map_entry s390_regmap_system_call[] =
 135   {
 136     { 1, S390_SYSTEM_CALL_REGNUM, 4 },
 137     { 0 }
 138   };
 139
 140 static const struct regcache_map_entry s390_regmap_tdb[] =
 141   {
 142     { 1, S390_TDB_DWORD0_REGNUM, 8 },
 143     { 1, S390_TDB_ABORT_CODE_REGNUM, 8 },
 144     { 1, S390_TDB_CONFLICT_TOKEN_REGNUM, 8 },
 145     { 1, S390_TDB_ATIA_REGNUM, 8 },
 146     { 12, REGCACHE_MAP_SKIP, 8 },
 147     { 16, S390_TDB_R0_REGNUM, 8 },
 148     { 0 }
 149   };
 150
 151 static const struct regcache_map_entry s390_regmap_vxrs_low[] =
 152   {
 153     { 16, S390_V0_LOWER_REGNUM, 8 },
 154     { 0 }
 155   };
 156
 157 static const struct regcache_map_entry s390_regmap_vxrs_high[] =
 158   {
 159     { 16, S390_V16_REGNUM, 16 },
 160     { 0 }
 161   };
 162
 163 static const struct regcache_map_entry s390_regmap_gs[] =
 164   {
 165     { 1, REGCACHE_MAP_SKIP, 8 },
 166     { 1, S390_GSD_REGNUM, 8 },
 167     { 1, S390_GSSM_REGNUM, 8 },
 168     { 1, S390_GSEPLA_REGNUM, 8 },
 169     { 0 }
 170   };
 171
 172 static const struct regcache_map_entry s390_regmap_gsbc[] =
 173   {
 174     { 1, REGCACHE_MAP_SKIP, 8 },
 175     { 1, S390_BC_GSD_REGNUM, 8 },
 176     { 1, S390_BC_GSSM_REGNUM, 8 },
 177     { 1, S390_BC_GSEPLA_REGNUM, 8 },
 178     { 0 }
 179   };
 180
 181 /* Supply the TDB regset.  Like regcache_supply_regset, but invalidate
 182    the TDB registers unless the TDB format field is valid.  */
 183
 184 static void
 185 s390_supply_tdb_regset (const struct regset *regset, struct regcache *regcache,
 186                     int regnum, const void *regs, size_t len)
 187 {
 188   ULONGEST tdw;
 189   enum register_status ret;
 190
 191   regcache_supply_regset (regset, regcache, regnum, regs, len);
 192   ret = regcache_cooked_read_unsigned (regcache, S390_TDB_DWORD0_REGNUM, &tdw);
 193   if (ret != REG_VALID || (tdw >> 56) != 1)
 194     regcache_supply_regset (regset, regcache, regnum, NULL, len);
 195 }
 196
 197 const struct regset s390_gregset = {
 198   s390_gregmap,
 199   regcache_supply_regset,
 200   regcache_collect_regset
 201 };
 202
 203 const struct regset s390_fpregset = {
 204   s390_fpregmap,
 205   regcache_supply_regset,
 206   regcache_collect_regset
 207 };
 208
 209 static const struct regset s390_upper_regset = {
 210   s390_regmap_upper,
 211   regcache_supply_regset,
 212   regcache_collect_regset
 213 };
 214
 215 const struct regset s390_last_break_regset = {
 216   s390_regmap_last_break,
 217   regcache_supply_regset,
 218   regcache_collect_regset
 219 };
 220
 221 const struct regset s390x_last_break_regset = {
 222   s390x_regmap_last_break,
 223   regcache_supply_regset,
 224   regcache_collect_regset
 225 };
 226
 227 const struct regset s390_system_call_regset = {
 228   s390_regmap_system_call,
 229   regcache_supply_regset,
 230   regcache_collect_regset
 231 };
 232
 233 const struct regset s390_tdb_regset = {
 234   s390_regmap_tdb,
 235   s390_supply_tdb_regset,
 236   regcache_collect_regset
 237 };
 238
 239 const struct regset s390_vxrs_low_regset = {
 240   s390_regmap_vxrs_low,
 241   regcache_supply_regset,
 242   regcache_collect_regset
 243 };
 244
 245 const struct regset s390_vxrs_high_regset = {
 246   s390_regmap_vxrs_high,
 247   regcache_supply_regset,
 248   regcache_collect_regset
 249 };
 250
 251 const struct regset s390_gs_regset = {
 252   s390_regmap_gs,
 253   regcache_supply_regset,
 254   regcache_collect_regset
 255 };
 256
 257 const struct regset s390_gsbc_regset = {
 258   s390_regmap_gsbc,
 259   regcache_supply_regset,
 260   regcache_collect_regset
 261 };
 262
 263 /* Iterate over supported core file register note sections. */
 264
 265 static void
 266 s390_iterate_over_regset_sections (struct gdbarch *gdbarch,
 267                                    iterate_over_regset_sections_cb *cb,
 268                                    void *cb_data,
 269                                    const struct regcache *regcache)
 270 {
 271   s390_gdbarch_tdep *tdep = gdbarch_tdep<s390_gdbarch_tdep> (gdbarch);
 272   const int gregset_size = (tdep->abi == ABI_LINUX_S390 ?
 273                             s390_sizeof_gregset : s390x_sizeof_gregset);
 274
 275   cb (".reg", gregset_size, gregset_size, &s390_gregset, NULL, cb_data);
 276   cb (".reg2", s390_sizeof_fpregset, s390_sizeof_fpregset, &s390_fpregset, NULL,
 277       cb_data);
 278
 279   if (tdep->abi == ABI_LINUX_S390 && tdep->gpr_full_regnum != -1)
 280     cb (".reg-s390-high-gprs", 16 * 4, 16 * 4, &s390_upper_regset,
 281         "s390 GPR upper halves", cb_data);
 282
 283   if (tdep->have_linux_v1)
 284     cb (".reg-s390-last-break", 8, 8,
 285         (gdbarch_ptr_bit (gdbarch) == 32
 286          ? &s390_last_break_regset : &s390x_last_break_regset),
 287         "s390 last-break address", cb_data);
 288
 289   if (tdep->have_linux_v2)
 290     cb (".reg-s390-system-call", 4, 4, &s390_system_call_regset,
 291         "s390 system-call", cb_data);
 292
 293   /* If regcache is set, we are in "write" (gcore) mode.  In this
 294      case, don't iterate over the TDB unless its registers are
 295      available.  */
 296   if (tdep->have_tdb
 297       && (regcache == NULL
 298           || (REG_VALID
 299               == regcache->get_register_status (S390_TDB_DWORD0_REGNUM))))
 300     cb (".reg-s390-tdb", s390_sizeof_tdbregset, s390_sizeof_tdbregset,
 301         &s390_tdb_regset, "s390 TDB", cb_data);
 302
 303   if (tdep->v0_full_regnum != -1)
 304     {
 305       cb (".reg-s390-vxrs-low", 16 * 8, 16 * 8, &s390_vxrs_low_regset,
 306           "s390 vector registers 0-15 lower half", cb_data);
 307       cb (".reg-s390-vxrs-high", 16 * 16, 16 * 16, &s390_vxrs_high_regset,
 308           "s390 vector registers 16-31", cb_data);
 309     }
 310
 311   /* Iterate over the guarded-storage regsets if in "read" mode, or if
 312      their registers are available.  */
 313   if (tdep->have_gs)
 314     {
 315       if (regcache == NULL
 316           || REG_VALID == regcache->get_register_status (S390_GSD_REGNUM))
 317         cb (".reg-s390-gs-cb", 4 * 8, 4 * 8, &s390_gs_regset,
 318             "s390 guarded-storage registers", cb_data);
 319
 320       if (regcache == NULL
 321           || REG_VALID == regcache->get_register_status (S390_BC_GSD_REGNUM))
 322         cb (".reg-s390-gs-bc", 4 * 8, 4 * 8, &s390_gsbc_regset,
 323             "s390 guarded-storage broadcast control", cb_data);
 324     }
 325 }
 326
 327 /* Implement core_read_description gdbarch method.  */
 328
 329 static const struct target_desc *
 330 s390_core_read_description (struct gdbarch *gdbarch,
 331                             struct target_ops *target, bfd *abfd)
 332 {
 333   asection *section = bfd_get_section_by_name (abfd, ".reg");
 334   std::optional<gdb::byte_vector> auxv = target_read_auxv_raw (target);
 335   CORE_ADDR hwcap = linux_get_hwcap (auxv, target, gdbarch);
 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   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 (const frame_info_ptr &this_frame,
 390                                   void **this_prologue_cache)
 391 {
 392   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 393   s390_gdbarch_tdep *tdep = gdbarch_tdep<s390_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].set_addr (sigreg_ptr);
 447   sigreg_ptr += word_size;
 448   info->saved_regs[S390_PSWA_REGNUM].set_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].set_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].set_addr (sigreg_ptr);
 462       sigreg_ptr += 4;
 463     }
 464
 465   /* The floating-point control word.  */
 466   info->saved_regs[S390_FPC_REGNUM].set_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].set_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].set_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 (const frame_info_ptr &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 (const frame_info_ptr &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                              const frame_info_ptr &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_legacy s390_sigtramp_frame_unwind (
 545   "s390 linux sigtramp",
 546   SIGTRAMP_FRAME,
 547   FRAME_UNWIND_ARCH,
 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 }