gdb/s390-linux-tdep.c

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