gdb/s390-linux-tdep.c

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