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 #include "arch-utils.h"
  25 #include "frame.h"
  26 #include "inferior.h"
  27 #include "infrun.h"
  28 #include "symtab.h"
  29 #include "target.h"
  30 #include "gdbcore.h"
  31 #include "gdbcmd.h"
  32 #include "objfiles.h"
  33 #include "osabi.h"
  34 #include "regcache.h"
  35 #include "trad-frame.h"
  36 #include "frame-base.h"
  37 #include "frame-unwind.h"
  38 #include "dwarf2-frame.h"
  39 #include "reggroups.h"
  40 #include "regset.h"
  41 #include "value.h"
  42 #include "dis-asm.h"
  43 #include "solib-svr4.h"
  44 #include "prologue-value.h"
  45 #include "linux-tdep.h"
  46 #include "s390-tdep.h"
  47 #include "s390-linux-tdep.h"
  48 #include "linux-record.h"
  49 #include "record-full.h"
  50 #include "auxv.h"
  51 #include "xml-syscall.h"
  52
  53 #include "stap-probe.h"
  54 #include "ax.h"
  55 #include "ax-gdb.h"
  56 #include "user-regs.h"
  57 #include "cli/cli-utils.h"
  58 #include <ctype.h>
  59 #include "elf/common.h"
  60 #include "elf/s390.h"
  61 #include "elf-bfd.h"
  62 #include <algorithm>
  63
  64 #include "features/s390-linux32.c"
  65 #include "features/s390-linux32v1.c"
  66 #include "features/s390-linux32v2.c"
  67 #include "features/s390-linux64.c"
  68 #include "features/s390-linux64v1.c"
  69 #include "features/s390-linux64v2.c"
  70 #include "features/s390-te-linux64.c"
  71 #include "features/s390-vx-linux64.c"
  72 #include "features/s390-tevx-linux64.c"
  73 #include "features/s390-gs-linux64.c"
  74 #include "features/s390x-linux64.c"
  75 #include "features/s390x-linux64v1.c"
  76 #include "features/s390x-linux64v2.c"
  77 #include "features/s390x-te-linux64.c"
  78 #include "features/s390x-vx-linux64.c"
  79 #include "features/s390x-tevx-linux64.c"
  80 #include "features/s390x-gs-linux64.c"
  81
  82 #define XML_SYSCALL_FILENAME_S390 "syscalls/s390-linux.xml"
  83 #define XML_SYSCALL_FILENAME_S390X "syscalls/s390x-linux.xml"
  84
  85 static int
  86 s390_cannot_store_register (struct gdbarch *gdbarch, int regnum)
  87 {
  88   /* The last-break address is read-only.  */
  89   return regnum == S390_LAST_BREAK_REGNUM;
  90 }
  91
  92 static void
  93 s390_write_pc (struct regcache *regcache, CORE_ADDR pc)
  94 {
  95   struct gdbarch *gdbarch = regcache->arch ();
  96   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
  97
  98   regcache_cooked_write_unsigned (regcache, tdep->pc_regnum, pc);
  99
 100   /* Set special SYSTEM_CALL register to 0 to prevent the kernel from
 101      messing with the PC we just installed, if we happen to be within
 102      an interrupted system call that the kernel wants to restart.
 103
 104      Note that after we return from the dummy call, the SYSTEM_CALL and
 105      ORIG_R2 registers will be automatically restored, and the kernel
 106      continues to restart the system call at this point.  */
 107   if (register_size (gdbarch, S390_SYSTEM_CALL_REGNUM) > 0)
 108     regcache_cooked_write_unsigned (regcache, S390_SYSTEM_CALL_REGNUM, 0);
 109 }
 110
 111 /* Maps for register sets.  */
 112
 113 static const struct regcache_map_entry s390_gregmap[] =
 114   {
 115     { 1, S390_PSWM_REGNUM },
 116     { 1, S390_PSWA_REGNUM },
 117     { 16, S390_R0_REGNUM },
 118     { 16, S390_A0_REGNUM },
 119     { 1, S390_ORIG_R2_REGNUM },
 120     { 0 }
 121   };
 122
 123 static const struct regcache_map_entry s390_fpregmap[] =
 124   {
 125     { 1, S390_FPC_REGNUM, 8 },
 126     { 16, S390_F0_REGNUM, 8 },
 127     { 0 }
 128   };
 129
 130 static const struct regcache_map_entry s390_regmap_upper[] =
 131   {
 132     { 16, S390_R0_UPPER_REGNUM, 4 },
 133     { 0 }
 134   };
 135
 136 static const struct regcache_map_entry s390_regmap_last_break[] =
 137   {
 138     { 1, REGCACHE_MAP_SKIP, 4 },
 139     { 1, S390_LAST_BREAK_REGNUM, 4 },
 140     { 0 }
 141   };
 142
 143 static const struct regcache_map_entry s390x_regmap_last_break[] =
 144   {
 145     { 1, S390_LAST_BREAK_REGNUM, 8 },
 146     { 0 }
 147   };
 148
 149 static const struct regcache_map_entry s390_regmap_system_call[] =
 150   {
 151     { 1, S390_SYSTEM_CALL_REGNUM, 4 },
 152     { 0 }
 153   };
 154
 155 static const struct regcache_map_entry s390_regmap_tdb[] =
 156   {
 157     { 1, S390_TDB_DWORD0_REGNUM, 8 },
 158     { 1, S390_TDB_ABORT_CODE_REGNUM, 8 },
 159     { 1, S390_TDB_CONFLICT_TOKEN_REGNUM, 8 },
 160     { 1, S390_TDB_ATIA_REGNUM, 8 },
 161     { 12, REGCACHE_MAP_SKIP, 8 },
 162     { 16, S390_TDB_R0_REGNUM, 8 },
 163     { 0 }
 164   };
 165
 166 static const struct regcache_map_entry s390_regmap_vxrs_low[] =
 167   {
 168     { 16, S390_V0_LOWER_REGNUM, 8 },
 169     { 0 }
 170   };
 171
 172 static const struct regcache_map_entry s390_regmap_vxrs_high[] =
 173   {
 174     { 16, S390_V16_REGNUM, 16 },
 175     { 0 }
 176   };
 177
 178 static const struct regcache_map_entry s390_regmap_gs[] =
 179   {
 180     { 1, REGCACHE_MAP_SKIP, 8 },
 181     { 1, S390_GSD_REGNUM, 8 },
 182     { 1, S390_GSSM_REGNUM, 8 },
 183     { 1, S390_GSEPLA_REGNUM, 8 },
 184     { 0 }
 185   };
 186
 187 static const struct regcache_map_entry s390_regmap_gsbc[] =
 188   {
 189     { 1, REGCACHE_MAP_SKIP, 8 },
 190     { 1, S390_BC_GSD_REGNUM, 8 },
 191     { 1, S390_BC_GSSM_REGNUM, 8 },
 192     { 1, S390_BC_GSEPLA_REGNUM, 8 },
 193     { 0 }
 194   };
 195
 196
 197 /* Supply the TDB regset.  Like regcache_supply_regset, but invalidate
 198    the TDB registers unless the TDB format field is valid.  */
 199
 200 static void
 201 s390_supply_tdb_regset (const struct regset *regset, struct regcache *regcache,
 202                     int regnum, const void *regs, size_t len)
 203 {
 204   ULONGEST tdw;
 205   enum register_status ret;
 206
 207   regcache_supply_regset (regset, regcache, regnum, regs, len);
 208   ret = regcache_cooked_read_unsigned (regcache, S390_TDB_DWORD0_REGNUM, &tdw);
 209   if (ret != REG_VALID || (tdw >> 56) != 1)
 210     regcache_supply_regset (regset, regcache, regnum, NULL, len);
 211 }
 212
 213 const struct regset s390_gregset = {
 214   s390_gregmap,
 215   regcache_supply_regset,
 216   regcache_collect_regset
 217 };
 218
 219 const struct regset s390_fpregset = {
 220   s390_fpregmap,
 221   regcache_supply_regset,
 222   regcache_collect_regset
 223 };
 224
 225 static const struct regset s390_upper_regset = {
 226   s390_regmap_upper,
 227   regcache_supply_regset,
 228   regcache_collect_regset
 229 };
 230
 231 const struct regset s390_last_break_regset = {
 232   s390_regmap_last_break,
 233   regcache_supply_regset,
 234   regcache_collect_regset
 235 };
 236
 237 const struct regset s390x_last_break_regset = {
 238   s390x_regmap_last_break,
 239   regcache_supply_regset,
 240   regcache_collect_regset
 241 };
 242
 243 const struct regset s390_system_call_regset = {
 244   s390_regmap_system_call,
 245   regcache_supply_regset,
 246   regcache_collect_regset
 247 };
 248
 249 const struct regset s390_tdb_regset = {
 250   s390_regmap_tdb,
 251   s390_supply_tdb_regset,
 252   regcache_collect_regset
 253 };
 254
 255 const struct regset s390_vxrs_low_regset = {
 256   s390_regmap_vxrs_low,
 257   regcache_supply_regset,
 258   regcache_collect_regset
 259 };
 260
 261 const struct regset s390_vxrs_high_regset = {
 262   s390_regmap_vxrs_high,
 263   regcache_supply_regset,
 264   regcache_collect_regset
 265 };
 266
 267 const struct regset s390_gs_regset = {
 268   s390_regmap_gs,
 269   regcache_supply_regset,
 270   regcache_collect_regset
 271 };
 272
 273 const struct regset s390_gsbc_regset = {
 274   s390_regmap_gsbc,
 275   regcache_supply_regset,
 276   regcache_collect_regset
 277 };
 278
 279 /* Iterate over supported core file register note sections. */
 280
 281 static void
 282 s390_iterate_over_regset_sections (struct gdbarch *gdbarch,
 283                                    iterate_over_regset_sections_cb *cb,
 284                                    void *cb_data,
 285                                    const struct regcache *regcache)
 286 {
 287   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 288   const int gregset_size = (tdep->abi == ABI_LINUX_S390 ?
 289                             s390_sizeof_gregset : s390x_sizeof_gregset);
 290
 291   cb (".reg", gregset_size, &s390_gregset, NULL, cb_data);
 292   cb (".reg2", s390_sizeof_fpregset, &s390_fpregset, NULL, cb_data);
 293
 294   if (tdep->abi == ABI_LINUX_S390 && tdep->gpr_full_regnum != -1)
 295     cb (".reg-s390-high-gprs", 16 * 4, &s390_upper_regset,
 296         "s390 GPR upper halves", cb_data);
 297
 298   if (tdep->have_linux_v1)
 299     cb (".reg-s390-last-break", 8,
 300         (gdbarch_ptr_bit (gdbarch) == 32
 301          ? &s390_last_break_regset : &s390x_last_break_regset),
 302         "s390 last-break address", cb_data);
 303
 304   if (tdep->have_linux_v2)
 305     cb (".reg-s390-system-call", 4, &s390_system_call_regset,
 306         "s390 system-call", cb_data);
 307
 308   /* If regcache is set, we are in "write" (gcore) mode.  In this
 309      case, don't iterate over the TDB unless its registers are
 310      available.  */
 311   if (tdep->have_tdb
 312       && (regcache == NULL
 313           || REG_VALID == regcache_register_status (regcache,
 314                                                     S390_TDB_DWORD0_REGNUM)))
 315     cb (".reg-s390-tdb", s390_sizeof_tdbregset, &s390_tdb_regset,
 316         "s390 TDB", cb_data);
 317
 318   if (tdep->v0_full_regnum != -1)
 319     {
 320       cb (".reg-s390-vxrs-low", 16 * 8, &s390_vxrs_low_regset,
 321           "s390 vector registers 0-15 lower half", cb_data);
 322       cb (".reg-s390-vxrs-high", 16 * 16, &s390_vxrs_high_regset,
 323           "s390 vector registers 16-31", cb_data);
 324     }
 325
 326   /* Iterate over the guarded-storage regsets if in "read" mode, or if
 327      their registers are available.  */
 328   if (tdep->have_gs)
 329     {
 330       if (regcache == NULL
 331           || REG_VALID == regcache_register_status (regcache,
 332                                                     S390_GSD_REGNUM))
 333         cb (".reg-s390-gs-cb", 4 * 8, &s390_gs_regset,
 334             "s390 guarded-storage registers", cb_data);
 335
 336       if (regcache == NULL
 337           || REG_VALID == regcache_register_status (regcache,
 338                                                     S390_BC_GSD_REGNUM))
 339         cb (".reg-s390-gs-bc", 4 * 8, &s390_gsbc_regset,
 340             "s390 guarded-storage broadcast control", cb_data);
 341     }
 342 }
 343
 344 static const struct target_desc *
 345 s390_core_read_description (struct gdbarch *gdbarch,
 346                             struct target_ops *target, bfd *abfd)
 347 {
 348   asection *section = bfd_get_section_by_name (abfd, ".reg");
 349   CORE_ADDR hwcap = 0;
 350   bool high_gprs, v1, v2, te, vx, gs;
 351
 352   target_auxv_search (target, AT_HWCAP, &hwcap);
 353   if (!section)
 354     return NULL;
 355
 356   high_gprs = (bfd_get_section_by_name (abfd, ".reg-s390-high-gprs")
 357                != NULL);
 358   v1 = (bfd_get_section_by_name (abfd, ".reg-s390-last-break") != NULL);
 359   v2 = (bfd_get_section_by_name (abfd, ".reg-s390-system-call") != NULL);
 360   vx = (hwcap & HWCAP_S390_VX);
 361   te = (hwcap & HWCAP_S390_TE);
 362   gs = (hwcap & HWCAP_S390_GS);
 363
 364   switch (bfd_section_size (abfd, section))
 365     {
 366     case s390_sizeof_gregset:
 367       if (high_gprs)
 368         return (gs ? tdesc_s390_gs_linux64 :
 369                 te && vx ? tdesc_s390_tevx_linux64 :
 370                 vx ? tdesc_s390_vx_linux64 :
 371                 te ? tdesc_s390_te_linux64 :
 372                 v2 ? tdesc_s390_linux64v2 :
 373                 v1 ? tdesc_s390_linux64v1 : tdesc_s390_linux64);
 374       else
 375         return (v2 ? tdesc_s390_linux32v2 :
 376                 v1 ? tdesc_s390_linux32v1 : tdesc_s390_linux32);
 377
 378     case s390x_sizeof_gregset:
 379       return (gs ? tdesc_s390x_gs_linux64 :
 380               te && vx ? tdesc_s390x_tevx_linux64 :
 381               vx ? tdesc_s390x_vx_linux64 :
 382               te ? tdesc_s390x_te_linux64 :
 383               v2 ? tdesc_s390x_linux64v2 :
 384               v1 ? tdesc_s390x_linux64v1 : tdesc_s390x_linux64);
 385
 386     default:
 387       return NULL;
 388     }
 389 }
 390
 391 /* Signal trampoline stack frames.  */
 392
 393 struct s390_sigtramp_unwind_cache {
 394   CORE_ADDR frame_base;
 395   struct trad_frame_saved_reg *saved_regs;
 396 };
 397
 398 static struct s390_sigtramp_unwind_cache *
 399 s390_sigtramp_frame_unwind_cache (struct frame_info *this_frame,
 400                                   void **this_prologue_cache)
 401 {
 402   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 403   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 404   int word_size = gdbarch_ptr_bit (gdbarch) / 8;
 405   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 406   struct s390_sigtramp_unwind_cache *info;
 407   ULONGEST this_sp, prev_sp;
 408   CORE_ADDR next_ra, next_cfa, sigreg_ptr, sigreg_high_off;
 409   int i;
 410
 411   if (*this_prologue_cache)
 412     return (struct s390_sigtramp_unwind_cache *) *this_prologue_cache;
 413
 414   info = FRAME_OBSTACK_ZALLOC (struct s390_sigtramp_unwind_cache);
 415   *this_prologue_cache = info;
 416   info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
 417
 418   this_sp = get_frame_register_unsigned (this_frame, S390_SP_REGNUM);
 419   next_ra = get_frame_pc (this_frame);
 420   next_cfa = this_sp + 16*word_size + 32;
 421
 422   /* New-style RT frame:
 423         retcode + alignment (8 bytes)
 424         siginfo (128 bytes)
 425         ucontext (contains sigregs at offset 5 words).  */
 426   if (next_ra == next_cfa)
 427     {
 428       sigreg_ptr = next_cfa + 8 + 128 + align_up (5*word_size, 8);
 429       /* sigregs are followed by uc_sigmask (8 bytes), then by the
 430          upper GPR halves if present.  */
 431       sigreg_high_off = 8;
 432     }
 433
 434   /* Old-style RT frame and all non-RT frames:
 435         old signal mask (8 bytes)
 436         pointer to sigregs.  */
 437   else
 438     {
 439       sigreg_ptr = read_memory_unsigned_integer (next_cfa + 8,
 440                                                  word_size, byte_order);
 441       /* sigregs are followed by signo (4 bytes), then by the
 442          upper GPR halves if present.  */
 443       sigreg_high_off = 4;
 444     }
 445
 446   /* The sigregs structure looks like this:
 447             long   psw_mask;
 448             long   psw_addr;
 449             long   gprs[16];
 450             int    acrs[16];
 451             int    fpc;
 452             int    __pad;
 453             double fprs[16];  */
 454
 455   /* PSW mask and address.  */
 456   info->saved_regs[S390_PSWM_REGNUM].addr = sigreg_ptr;
 457   sigreg_ptr += word_size;
 458   info->saved_regs[S390_PSWA_REGNUM].addr = sigreg_ptr;
 459   sigreg_ptr += word_size;
 460
 461   /* Then the GPRs.  */
 462   for (i = 0; i < 16; i++)
 463     {
 464       info->saved_regs[S390_R0_REGNUM + i].addr = sigreg_ptr;
 465       sigreg_ptr += word_size;
 466     }
 467
 468   /* Then the ACRs.  */
 469   for (i = 0; i < 16; i++)
 470     {
 471       info->saved_regs[S390_A0_REGNUM + i].addr = sigreg_ptr;
 472       sigreg_ptr += 4;
 473     }
 474
 475   /* The floating-point control word.  */
 476   info->saved_regs[S390_FPC_REGNUM].addr = sigreg_ptr;
 477   sigreg_ptr += 8;
 478
 479   /* And finally the FPRs.  */
 480   for (i = 0; i < 16; i++)
 481     {
 482       info->saved_regs[S390_F0_REGNUM + i].addr = sigreg_ptr;
 483       sigreg_ptr += 8;
 484     }
 485
 486   /* If we have them, the GPR upper halves are appended at the end.  */
 487   sigreg_ptr += sigreg_high_off;
 488   if (tdep->gpr_full_regnum != -1)
 489     for (i = 0; i < 16; i++)
 490       {
 491         info->saved_regs[S390_R0_UPPER_REGNUM + i].addr = sigreg_ptr;
 492         sigreg_ptr += 4;
 493       }
 494
 495   /* Restore the previous frame's SP.  */
 496   prev_sp = read_memory_unsigned_integer (
 497                         info->saved_regs[S390_SP_REGNUM].addr,
 498                         word_size, byte_order);
 499
 500   /* Determine our frame base.  */
 501   info->frame_base = prev_sp + 16*word_size + 32;
 502
 503   return info;
 504 }
 505
 506 static void
 507 s390_sigtramp_frame_this_id (struct frame_info *this_frame,
 508                              void **this_prologue_cache,
 509                              struct frame_id *this_id)
 510 {
 511   struct s390_sigtramp_unwind_cache *info
 512     = s390_sigtramp_frame_unwind_cache (this_frame, this_prologue_cache);
 513   *this_id = frame_id_build (info->frame_base, get_frame_pc (this_frame));
 514 }
 515
 516 static struct value *
 517 s390_sigtramp_frame_prev_register (struct frame_info *this_frame,
 518                                    void **this_prologue_cache, int regnum)
 519 {
 520   struct s390_sigtramp_unwind_cache *info
 521     = s390_sigtramp_frame_unwind_cache (this_frame, this_prologue_cache);
 522   return s390_trad_frame_prev_register (this_frame, info->saved_regs, regnum);
 523 }
 524
 525 static int
 526 s390_sigtramp_frame_sniffer (const struct frame_unwind *self,
 527                              struct frame_info *this_frame,
 528                              void **this_prologue_cache)
 529 {
 530   CORE_ADDR pc = get_frame_pc (this_frame);
 531   bfd_byte sigreturn[2];
 532
 533   if (target_read_memory (pc, sigreturn, 2))
 534     return 0;
 535
 536   if (sigreturn[0] != op_svc)
 537     return 0;
 538
 539   if (sigreturn[1] != 119 /* sigreturn */
 540       && sigreturn[1] != 173 /* rt_sigreturn */)
 541     return 0;
 542
 543   return 1;
 544 }
 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 /* Retrieve the syscall number at a ptrace syscall-stop.  Return -1
 556    upon error. */
 557
 558 static LONGEST
 559 s390_linux_get_syscall_number (struct gdbarch *gdbarch,
 560                                ptid_t ptid)
 561 {
 562   struct regcache *regs = get_thread_regcache (ptid);
 563   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 564   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 565   ULONGEST pc;
 566   ULONGEST svc_number = -1;
 567   unsigned opcode;
 568
 569   /* Assume that the PC points after the 2-byte SVC instruction.  We
 570      don't currently support SVC via EXECUTE. */
 571   regcache_cooked_read_unsigned (regs, tdep->pc_regnum, &pc);
 572   pc -= 2;
 573   opcode = read_memory_unsigned_integer ((CORE_ADDR) pc, 1, byte_order);
 574   if (opcode != op_svc)
 575     return -1;
 576
 577   svc_number = read_memory_unsigned_integer ((CORE_ADDR) pc + 1, 1,
 578                                              byte_order);
 579   if (svc_number == 0)
 580     regcache_cooked_read_unsigned (regs, S390_R1_REGNUM, &svc_number);
 581
 582   return svc_number;
 583 }
 584
 585 /* Process record-replay */
 586
 587 static struct linux_record_tdep s390_linux_record_tdep;
 588 static struct linux_record_tdep s390x_linux_record_tdep;
 589
 590 /* Record all registers but PC register for process-record.  */
 591
 592 static int
 593 s390_all_but_pc_registers_record (struct regcache *regcache)
 594 {
 595   struct gdbarch *gdbarch = regcache->arch ();
 596   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 597   int i;
 598
 599   for (i = 0; i < 16; i++)
 600     {
 601       if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + i))
 602         return -1;
 603       if (record_full_arch_list_add_reg (regcache, S390_A0_REGNUM + i))
 604         return -1;
 605       if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + i))
 606         return -1;
 607       if (tdep->gpr_full_regnum != -1)
 608         if (record_full_arch_list_add_reg (regcache, S390_R0_UPPER_REGNUM + i))
 609           return -1;
 610       if (tdep->v0_full_regnum != -1)
 611         {
 612           if (record_full_arch_list_add_reg (regcache, S390_V0_LOWER_REGNUM + i))
 613             return -1;
 614           if (record_full_arch_list_add_reg (regcache, S390_V16_REGNUM + i))
 615             return -1;
 616         }
 617     }
 618   if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
 619     return -1;
 620   if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
 621     return -1;
 622
 623   return 0;
 624 }
 625
 626 static enum gdb_syscall
 627 s390_canonicalize_syscall (int syscall, enum s390_abi_kind abi)
 628 {
 629   switch (syscall)
 630     {
 631     /* s390 syscall numbers < 222 are mostly the same as x86, so just list
 632        the exceptions.  */
 633     case 0:
 634       return gdb_sys_no_syscall;
 635     case 7:
 636       return gdb_sys_restart_syscall;
 637     /* These syscalls work only on 31-bit.  */
 638     case 13: /* time */
 639     case 16: /* lchown[16] */
 640     case 23: /* setuid[16] */
 641     case 24: /* getuid[16] */
 642     case 25: /* stime */
 643     case 46: /* setgid[16] */
 644     case 47: /* getgid[16] */
 645     case 49: /* seteuid[16] */
 646     case 50: /* getegid[16] */
 647     case 70: /* setreuid[16] */
 648     case 71: /* setregid[16] */
 649     case 76: /* [old_]getrlimit */
 650     case 80: /* getgroups[16] */
 651     case 81: /* setgroups[16] */
 652     case 95: /* fchown[16] */
 653     case 101: /* ioperm */
 654     case 138: /* setfsuid[16] */
 655     case 139: /* setfsgid[16] */
 656     case 140: /* _llseek */
 657     case 164: /* setresuid[16] */
 658     case 165: /* getresuid[16] */
 659     case 170: /* setresgid[16] */
 660     case 171: /* getresgid[16] */
 661     case 182: /* chown[16] */
 662     case 192: /* mmap2 */
 663     case 193: /* truncate64 */
 664     case 194: /* ftruncate64 */
 665     case 195: /* stat64 */
 666     case 196: /* lstat64 */
 667     case 197: /* fstat64 */
 668     case 221: /* fcntl64 */
 669       if (abi == ABI_LINUX_S390)
 670         return (enum gdb_syscall) syscall;
 671       return gdb_sys_no_syscall;
 672     /* These syscalls don't exist on s390.  */
 673     case 17: /* break */
 674     case 18: /* oldstat */
 675     case 28: /* oldfstat */
 676     case 31: /* stty */
 677     case 32: /* gtty */
 678     case 35: /* ftime */
 679     case 44: /* prof */
 680     case 53: /* lock */
 681     case 56: /* mpx */
 682     case 58: /* ulimit */
 683     case 59: /* oldolduname */
 684     case 68: /* sgetmask */
 685     case 69: /* ssetmask */
 686     case 82: /* [old_]select */
 687     case 84: /* oldlstat */
 688     case 98: /* profil */
 689     case 109: /* olduname */
 690     case 113: /* vm86old */
 691     case 123: /* modify_ldt */
 692     case 166: /* vm86 */
 693       return gdb_sys_no_syscall;
 694     case 110:
 695       return gdb_sys_lookup_dcookie;
 696     /* Here come the differences.  */
 697     case 222:
 698       return gdb_sys_readahead;
 699     case 223:
 700       if (abi == ABI_LINUX_S390)
 701         return gdb_sys_sendfile64;
 702       return gdb_sys_no_syscall;
 703     /* 224-235 handled below */
 704     case 236:
 705       return gdb_sys_gettid;
 706     case 237:
 707       return gdb_sys_tkill;
 708     case 238:
 709       return gdb_sys_futex;
 710     case 239:
 711       return gdb_sys_sched_setaffinity;
 712     case 240:
 713       return gdb_sys_sched_getaffinity;
 714     case 241:
 715       return gdb_sys_tgkill;
 716     /* 242 reserved */
 717     case 243:
 718       return gdb_sys_io_setup;
 719     case 244:
 720       return gdb_sys_io_destroy;
 721     case 245:
 722       return gdb_sys_io_getevents;
 723     case 246:
 724       return gdb_sys_io_submit;
 725     case 247:
 726       return gdb_sys_io_cancel;
 727     case 248:
 728       return gdb_sys_exit_group;
 729     case 249:
 730       return gdb_sys_epoll_create;
 731     case 250:
 732       return gdb_sys_epoll_ctl;
 733     case 251:
 734       return gdb_sys_epoll_wait;
 735     case 252:
 736       return gdb_sys_set_tid_address;
 737     case 253:
 738       return gdb_sys_fadvise64;
 739     /* 254-262 handled below */
 740     /* 263 reserved */
 741     case 264:
 742       if (abi == ABI_LINUX_S390)
 743         return gdb_sys_fadvise64_64;
 744       return gdb_sys_no_syscall;
 745     case 265:
 746       return gdb_sys_statfs64;
 747     case 266:
 748       return gdb_sys_fstatfs64;
 749     case 267:
 750       return gdb_sys_remap_file_pages;
 751     /* 268-270 reserved */
 752     /* 271-277 handled below */
 753     case 278:
 754       return gdb_sys_add_key;
 755     case 279:
 756       return gdb_sys_request_key;
 757     case 280:
 758       return gdb_sys_keyctl;
 759     case 281:
 760       return gdb_sys_waitid;
 761     /* 282-312 handled below */
 762     case 293:
 763       if (abi == ABI_LINUX_S390)
 764         return gdb_sys_fstatat64;
 765       return gdb_sys_newfstatat;
 766     /* 313+ not yet supported */
 767     default:
 768       {
 769         int ret;
 770
 771         /* Most "old" syscalls copied from i386.  */
 772         if (syscall <= 221)
 773           ret = syscall;
 774         /* xattr syscalls.  */
 775         else if (syscall >= 224 && syscall <= 235)
 776           ret = syscall + 2;
 777         /* timer syscalls.  */
 778         else if (syscall >= 254 && syscall <= 262)
 779           ret = syscall + 5;
 780         /* mq_* and kexec_load */
 781         else if (syscall >= 271 && syscall <= 277)
 782           ret = syscall + 6;
 783         /* ioprio_set .. epoll_pwait */
 784         else if (syscall >= 282 && syscall <= 312)
 785           ret = syscall + 7;
 786         else
 787           ret = gdb_sys_no_syscall;
 788
 789         return (enum gdb_syscall) ret;
 790       }
 791     }
 792 }
 793
 794 static int
 795 s390_linux_syscall_record (struct regcache *regcache, LONGEST syscall_native)
 796 {
 797   struct gdbarch *gdbarch = regcache->arch ();
 798   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 799   int ret;
 800   enum gdb_syscall syscall_gdb;
 801
 802   /* On s390, syscall number can be passed either as immediate field of svc
 803      instruction, or in %r1 (with svc 0).  */
 804   if (syscall_native == 0)
 805     regcache_raw_read_signed (regcache, S390_R1_REGNUM, &syscall_native);
 806
 807   syscall_gdb = s390_canonicalize_syscall (syscall_native, tdep->abi);
 808
 809   if (syscall_gdb < 0)
 810     {
 811       printf_unfiltered (_("Process record and replay target doesn't "
 812                            "support syscall number %s\n"),
 813                          plongest (syscall_native));
 814       return -1;
 815     }
 816
 817   if (syscall_gdb == gdb_sys_sigreturn
 818       || syscall_gdb == gdb_sys_rt_sigreturn)
 819     {
 820       if (s390_all_but_pc_registers_record (regcache))
 821         return -1;
 822       return 0;
 823     }
 824
 825   if (tdep->abi == ABI_LINUX_ZSERIES)
 826     ret = record_linux_system_call (syscall_gdb, regcache,
 827                                     &s390x_linux_record_tdep);
 828   else
 829     ret = record_linux_system_call (syscall_gdb, regcache,
 830                                     &s390_linux_record_tdep);
 831
 832   if (ret)
 833     return ret;
 834
 835   /* Record the return value of the system call.  */
 836   if (record_full_arch_list_add_reg (regcache, S390_R2_REGNUM))
 837     return -1;
 838
 839   return 0;
 840 }
 841
 842 static int
 843 s390_linux_record_signal (struct gdbarch *gdbarch, struct regcache *regcache,
 844                           enum gdb_signal signal)
 845 {
 846   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 847   /* There are two kinds of signal frames on s390. rt_sigframe is always
 848      the larger one, so don't even bother with sigframe.  */
 849   const int sizeof_rt_sigframe = (tdep->abi == ABI_LINUX_ZSERIES ?
 850                                   160 + 8 + 128 + 1024 : 96 + 8 + 128 + 1000);
 851   ULONGEST sp;
 852   int i;
 853
 854   for (i = 0; i < 16; i++)
 855     {
 856       if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + i))
 857         return -1;
 858       if (tdep->gpr_full_regnum != -1)
 859         if (record_full_arch_list_add_reg (regcache, S390_R0_UPPER_REGNUM + i))
 860           return -1;
 861     }
 862   if (record_full_arch_list_add_reg (regcache, S390_PSWA_REGNUM))
 863     return -1;
 864   if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
 865     return -1;
 866
 867   /* Record the change in the stack.
 868      frame-size = sizeof (struct rt_sigframe) + SIGNAL_FRAMESIZE  */
 869   regcache_raw_read_unsigned (regcache, S390_SP_REGNUM, &sp);
 870   sp -= sizeof_rt_sigframe;
 871
 872   if (record_full_arch_list_add_mem (sp, sizeof_rt_sigframe))
 873     return -1;
 874
 875   if (record_full_arch_list_add_end ())
 876     return -1;
 877
 878   return 0;
 879 }
 880
 881 /* Process record and replay helpers.  */
 882
 883 /* Takes the intermediate sum of address calculations and masks off upper
 884    bits according to current addressing mode.  */
 885
 886 static CORE_ADDR
 887 s390_record_address_mask (struct gdbarch *gdbarch, struct regcache *regcache,
 888                          CORE_ADDR val) {
 889   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 890   ULONGEST pswm, pswa;
 891   int am;
 892   if (tdep->abi == ABI_LINUX_S390)
 893     {
 894       regcache_raw_read_unsigned (regcache, S390_PSWA_REGNUM, &pswa);
 895       am = pswa >> 31 & 1;
 896     }
 897   else
 898     {
 899       regcache_raw_read_unsigned (regcache, S390_PSWM_REGNUM, &pswm);
 900       am = pswm >> 31 & 3;
 901     }
 902   switch (am)
 903     {
 904     case 0:
 905       return val & 0xffffff;
 906     case 1:
 907       return val & 0x7fffffff;
 908     case 3:
 909       return val;
 910     default:
 911       fprintf_unfiltered (gdb_stdlog, "Warning: Addressing mode %d used.", am);
 912       return 0;
 913     }
 914 }
 915
 916 /* Calculates memory address using pre-calculated index, raw instruction word
 917    with b and d/dl fields, and raw instruction byte with dh field.  Index and
 918    dh should be set to 0 if unused.  */
 919
 920 static CORE_ADDR
 921 s390_record_calc_disp_common (struct gdbarch *gdbarch, struct regcache *regcache,
 922                              ULONGEST x, uint16_t bd, int8_t dh)
 923 {
 924   uint8_t rb = bd >> 12 & 0xf;
 925   int32_t d = (bd & 0xfff) | ((int32_t)dh << 12);
 926   ULONGEST b;
 927   CORE_ADDR res = d + x;
 928   if (rb)
 929     {
 930       regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + rb, &b);
 931       res += b;
 932     }
 933   return s390_record_address_mask (gdbarch, regcache, res);
 934 }
 935
 936 /* Calculates memory address using raw x, b + d/dl, dh fields from
 937    instruction.  rx and dh should be set to 0 if unused.  */
 938
 939 static CORE_ADDR
 940 s390_record_calc_disp (struct gdbarch *gdbarch, struct regcache *regcache,
 941                       uint8_t rx, uint16_t bd, int8_t dh)
 942 {
 943   ULONGEST x = 0;
 944   if (rx)
 945     regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + rx, &x);
 946   return s390_record_calc_disp_common (gdbarch, regcache, x, bd, dh);
 947 }
 948
 949 /* Calculates memory address for VSCE[GF] instructions.  */
 950
 951 static int
 952 s390_record_calc_disp_vsce (struct gdbarch *gdbarch, struct regcache *regcache,
 953                             uint8_t vx, uint8_t el, uint8_t es, uint16_t bd,
 954                             int8_t dh, CORE_ADDR *res)
 955 {
 956   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 957   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 958   ULONGEST x;
 959   gdb_byte buf[16];
 960   if (tdep->v0_full_regnum == -1 || el * es >= 16)
 961     return -1;
 962   if (vx < 16)
 963     regcache_cooked_read (regcache, tdep->v0_full_regnum + vx, buf);
 964   else
 965     regcache_raw_read (regcache, S390_V16_REGNUM + vx - 16, buf);
 966   x = extract_unsigned_integer (buf + el * es, es, byte_order);
 967   *res = s390_record_calc_disp_common (gdbarch, regcache, x, bd, dh);
 968   return 0;
 969 }
 970
 971 /* Calculates memory address for instructions with relative long addressing.  */
 972
 973 static CORE_ADDR
 974 s390_record_calc_rl (struct gdbarch *gdbarch, struct regcache *regcache,
 975                     CORE_ADDR addr, uint16_t i1, uint16_t i2)
 976 {
 977   int32_t ri = i1 << 16 | i2;
 978   return s390_record_address_mask (gdbarch, regcache, addr + (LONGEST)ri * 2);
 979 }
 980
 981 /* Population count helper.  */
 982
 983 static int s390_popcnt (unsigned int x) {
 984   int res = 0;
 985   while (x)
 986     {
 987       if (x & 1)
 988         res++;
 989       x >>= 1;
 990     }
 991   return res;
 992 }
 993
 994 /* Record 64-bit register.  */
 995
 996 static int
 997 s390_record_gpr_g (struct gdbarch *gdbarch, struct regcache *regcache, int i)
 998 {
 999   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1000   if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + i))
1001     return -1;
1002   if (tdep->abi == ABI_LINUX_S390)
1003     if (record_full_arch_list_add_reg (regcache, S390_R0_UPPER_REGNUM + i))
1004       return -1;
1005   return 0;
1006 }
1007
1008 /* Record high 32 bits of a register.  */
1009
1010 static int
1011 s390_record_gpr_h (struct gdbarch *gdbarch, struct regcache *regcache, int i)
1012 {
1013   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1014   if (tdep->abi == ABI_LINUX_S390)
1015     {
1016       if (record_full_arch_list_add_reg (regcache, S390_R0_UPPER_REGNUM + i))
1017         return -1;
1018     }
1019   else
1020     {
1021       if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + i))
1022         return -1;
1023     }
1024   return 0;
1025 }
1026
1027 /* Record vector register.  */
1028
1029 static int
1030 s390_record_vr (struct gdbarch *gdbarch, struct regcache *regcache, int i)
1031 {
1032   if (i < 16)
1033     {
1034       if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + i))
1035         return -1;
1036       if (record_full_arch_list_add_reg (regcache, S390_V0_LOWER_REGNUM + i))
1037         return -1;
1038     }
1039   else
1040     {
1041       if (record_full_arch_list_add_reg (regcache, S390_V16_REGNUM + i - 16))
1042         return -1;
1043     }
1044   return 0;
1045 }
1046
1047 static int
1048 s390_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
1049                     CORE_ADDR addr)
1050 {
1051   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1052   uint16_t insn[3] = {0};
1053   /* Instruction as bytes.  */
1054   uint8_t ibyte[6];
1055   /* Instruction as nibbles.  */
1056   uint8_t inib[12];
1057   /* Instruction vector registers.  */
1058   uint8_t ivec[4];
1059   CORE_ADDR oaddr, oaddr2, oaddr3;
1060   ULONGEST tmp;
1061   int i, n;
1062   /* if EX/EXRL instruction used, here's the reg parameter */
1063   int ex = -1;
1064   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1065
1066   /* Attempting to use EX or EXRL jumps back here */
1067 ex:
1068
1069   /* Read instruction.  */
1070   insn[0] = read_memory_unsigned_integer (addr, 2, byte_order);
1071   /* If execute was involved, do the adjustment.  */
1072   if (ex != -1)
1073     insn[0] |= ex & 0xff;
1074   /* Two highest bits determine instruction size.  */
1075   if (insn[0] >= 0x4000)
1076     insn[1] = read_memory_unsigned_integer (addr+2, 2, byte_order);
1077   else
1078     /* Not necessary, but avoids uninitialized variable warnings.  */
1079     insn[1] = 0;
1080   if (insn[0] >= 0xc000)
1081     insn[2] = read_memory_unsigned_integer (addr+4, 2, byte_order);
1082   else
1083     insn[2] = 0;
1084   /* Split instruction into bytes and nibbles.  */
1085   for (i = 0; i < 3; i++)
1086     {
1087       ibyte[i*2] = insn[i] >> 8 & 0xff;
1088       ibyte[i*2+1] = insn[i] & 0xff;
1089     }
1090   for (i = 0; i < 6; i++)
1091     {
1092       inib[i*2] = ibyte[i] >> 4 & 0xf;
1093       inib[i*2+1] = ibyte[i] & 0xf;
1094     }
1095   /* Compute vector registers, if applicable.  */
1096   ivec[0] = (inib[9] >> 3 & 1) << 4 | inib[2];
1097   ivec[1] = (inib[9] >> 2 & 1) << 4 | inib[3];
1098   ivec[2] = (inib[9] >> 1 & 1) << 4 | inib[4];
1099   ivec[3] = (inib[9] >> 0 & 1) << 4 | inib[8];
1100
1101   switch (ibyte[0])
1102     {
1103     /* 0x00 undefined */
1104
1105     case 0x01:
1106       /* E-format instruction */
1107       switch (ibyte[1])
1108         {
1109         /* 0x00 undefined */
1110         /* 0x01 unsupported: PR - program return */
1111         /* 0x02 unsupported: UPT */
1112         /* 0x03 undefined */
1113         /* 0x04 privileged: PTFF - perform timing facility function */
1114         /* 0x05-0x06 undefined */
1115         /* 0x07 privileged: SCKPF - set clock programmable field */
1116         /* 0x08-0x09 undefined */
1117
1118         case 0x0a: /* PFPO - perform floating point operation */
1119           regcache_raw_read_unsigned (regcache, S390_R0_REGNUM, &tmp);
1120           if (!(tmp & 0x80000000u))
1121             {
1122               uint8_t ofc = tmp >> 16 & 0xff;
1123               switch (ofc)
1124                 {
1125                 case 0x00: /* HFP32 */
1126                 case 0x01: /* HFP64 */
1127                 case 0x05: /* BFP32 */
1128                 case 0x06: /* BFP64 */
1129                 case 0x08: /* DFP32 */
1130                 case 0x09: /* DFP64 */
1131                   if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM))
1132                     return -1;
1133                   break;
1134                 case 0x02: /* HFP128 */
1135                 case 0x07: /* BFP128 */
1136                 case 0x0a: /* DFP128 */
1137                   if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM))
1138                     return -1;
1139                   if (record_full_arch_list_add_reg (regcache, S390_F2_REGNUM))
1140                     return -1;
1141                   break;
1142                 default:
1143                   fprintf_unfiltered (gdb_stdlog, "Warning: Unknown PFPO OFC %02x at %s.\n",
1144                                       ofc, paddress (gdbarch, addr));
1145                   return -1;
1146                 }
1147
1148               if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
1149                 return -1;
1150             }
1151           if (record_full_arch_list_add_reg (regcache, S390_R1_REGNUM))
1152             return -1;
1153           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
1154             return -1;
1155           break;
1156
1157         case 0x0b: /* TAM - test address mode */
1158         case 0x0c: /* SAM24 - set address mode 24 */
1159         case 0x0d: /* SAM31 - set address mode 31 */
1160         case 0x0e: /* SAM64 - set address mode 64 */
1161           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
1162             return -1;
1163           break;
1164
1165         /* 0x0f-0xfe undefined */
1166
1167         /* 0xff unsupported: TRAP */
1168
1169         default:
1170           goto UNKNOWN_OP;
1171         }
1172       break;
1173
1174     /* 0x02 undefined */
1175     /* 0x03 undefined */
1176
1177     case 0x04: /* SPM - set program mask */
1178       if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
1179         return -1;
1180       break;
1181
1182     case 0x05: /* BALR - branch and link */
1183     case 0x45: /* BAL - branch and link */
1184     case 0x06: /* BCTR - branch on count */
1185     case 0x46: /* BCT - branch on count */
1186     case 0x0d: /* BASR - branch and save */
1187     case 0x4d: /* BAS - branch and save */
1188     case 0x84: /* BRXH - branch relative on index high */
1189     case 0x85: /* BRXLE - branch relative on index low or equal */
1190     case 0x86: /* BXH - branch on index high */
1191     case 0x87: /* BXLE - branch on index low or equal */
1192       /* BA[SL]* use native-size destination for linkage info, BCT*, BRX*, BX*
1193          use 32-bit destination as counter.  */
1194       if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
1195         return -1;
1196       break;
1197
1198     case 0x07: /* BCR - branch on condition */
1199     case 0x47: /* BC - branch on condition */
1200       /* No effect other than PC transfer.  */
1201       break;
1202
1203     /* 0x08 undefined */
1204     /* 0x09 undefined */
1205
1206     case 0x0a:
1207       /* SVC - supervisor call */
1208       if (tdep->s390_syscall_record != NULL)
1209         {
1210           if (tdep->s390_syscall_record (regcache, ibyte[1]))
1211             return -1;
1212         }
1213       else
1214         {
1215           printf_unfiltered (_("no syscall record support\n"));
1216           return -1;
1217         }
1218       break;
1219
1220     case 0x0b: /* BSM - branch and set mode */
1221       if (inib[2])
1222         if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
1223           return -1;
1224       if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
1225         return -1;
1226       break;
1227
1228     case 0x0c: /* BASSM - branch and save and set mode */
1229       if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
1230         return -1;
1231       if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
1232         return -1;
1233       break;
1234
1235     case 0x0e: /* MVCL - move long [interruptible] */
1236       regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + inib[2], &tmp);
1237       oaddr = s390_record_address_mask (gdbarch, regcache, tmp);
1238       regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + (inib[2] | 1), &tmp);
1239       tmp &= 0xffffff;
1240       if (record_full_arch_list_add_mem (oaddr, tmp))
1241         return -1;
1242       if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
1243         return -1;
1244       if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[2] | 1)))
1245         return -1;
1246       if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[3]))
1247         return -1;
1248       if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[3] | 1)))
1249         return -1;
1250       if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
1251         return -1;
1252       break;
1253
1254     case 0x0f: /* CLCL - compare logical long [interruptible] */
1255     case 0xa9: /* CLCLE - compare logical long extended [partial] */
1256       if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
1257         return -1;
1258       if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[2] | 1)))
1259         return -1;
1260       if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[3]))
1261         return -1;
1262       if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[3] | 1)))
1263         return -1;
1264       if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
1265         return -1;
1266       break;
1267
1268     case 0x10: /* LPR - load positive */
1269     case 0x11: /* LNR - load negative */
1270     case 0x12: /* LTR - load and test */
1271     case 0x13: /* LCR - load complement */
1272     case 0x14: /* NR - and */
1273     case 0x16: /* OR - or */
1274     case 0x17: /* XR - xor */
1275     case 0x1a: /* AR - add */
1276     case 0x1b: /* SR - subtract */
1277     case 0x1e: /* ALR - add logical */
1278     case 0x1f: /* SLR - subtract logical */
1279     case 0x54: /* N - and */
1280     case 0x56: /* O - or */
1281     case 0x57: /* X - xor */
1282     case 0x5a: /* A - add */
1283     case 0x5b: /* S - subtract */
1284     case 0x5e: /* AL - add logical */
1285     case 0x5f: /* SL - subtract logical */
1286     case 0x4a: /* AH - add halfword */
1287     case 0x4b: /* SH - subtract halfword */
1288     case 0x8a: /* SRA - shift right single */
1289     case 0x8b: /* SLA - shift left single */
1290     case 0xbf: /* ICM - insert characters under mask */
1291       /* 32-bit destination + flags */
1292       if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
1293         return -1;
1294       if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
1295         return -1;
1296       break;
1297
1298     case 0x15: /* CLR - compare logical */
1299     case 0x55: /* CL - compare logical */
1300     case 0x19: /* CR - compare */
1301     case 0x29: /* CDR - compare */
1302     case 0x39: /* CER - compare */
1303     case 0x49: /* CH - compare halfword */
1304     case 0x59: /* C - compare */
1305     case 0x69: /* CD - compare */
1306     case 0x79: /* CE - compare */
1307     case 0x91: /* TM - test under mask */
1308     case 0x95: /* CLI - compare logical */
1309     case 0xbd: /* CLM - compare logical under mask */
1310     case 0xd5: /* CLC - compare logical */
1311       if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
1312         return -1;
1313       break;
1314
1315     case 0x18: /* LR - load */
1316     case 0x48: /* LH - load halfword */
1317     case 0x58: /* L - load */
1318     case 0x41: /* LA - load address */
1319     case 0x43: /* IC - insert character */
1320     case 0x4c: /* MH - multiply halfword */
1321     case 0x71: /* MS - multiply single */
1322     case 0x88: /* SRL - shift right single logical */
1323     case 0x89: /* SLL - shift left single logical */
1324       /* 32-bit, 8-bit (IC), or native width (LA) destination, no flags */
1325       if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
1326         return -1;
1327       break;
1328
1329     case 0x1c: /* MR - multiply */
1330     case 0x5c: /* M - multiply */
1331     case 0x1d: /* DR - divide */
1332     case 0x5d: /* D - divide */
1333     case 0x8c: /* SRDL - shift right double logical */
1334     case 0x8d: /* SLDL - shift left double logical */
1335       /* 32-bit pair destination, no flags */
1336       if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
1337         return -1;
1338       if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[2] | 1)))
1339         return -1;
1340       break;
1341
1342     case 0x20: /* LPDR - load positive */
1343     case 0x30: /* LPER - load positive */
1344     case 0x21: /* LNDR - load negative */
1345     case 0x31: /* LNER - load negative */
1346     case 0x22: /* LTDR - load and test */
1347     case 0x32: /* LTER - load and test */
1348     case 0x23: /* LCDR - load complement */
1349     case 0x33: /* LCER - load complement */
1350     case 0x2a: /* ADR - add */
1351     case 0x3a: /* AER - add */
1352     case 0x6a: /* AD - add */
1353     case 0x7a: /* AE - add */
1354     case 0x2b: /* SDR - subtract */
1355     case 0x3b: /* SER - subtract */
1356     case 0x6b: /* SD - subtract */
1357     case 0x7b: /* SE - subtract */
1358     case 0x2e: /* AWR - add unnormalized */
1359     case 0x3e: /* AUR - add unnormalized */
1360     case 0x6e: /* AW - add unnormalized */
1361     case 0x7e: /* AU - add unnormalized */
1362     case 0x2f: /* SWR - subtract unnormalized */
1363     case 0x3f: /* SUR - subtract unnormalized */
1364     case 0x6f: /* SW - subtract unnormalized */
1365     case 0x7f: /* SU - subtract unnormalized */
1366       /* float destination + flags */
1367       if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[2]))
1368         return -1;
1369       if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
1370         return -1;
1371       break;
1372
1373     case 0x24: /* HDR - halve */
1374     case 0x34: /* HER - halve */
1375     case 0x25: /* LDXR - load rounded */
1376     case 0x35: /* LEDR - load rounded */
1377     case 0x28: /* LDR - load */
1378     case 0x38: /* LER - load */
1379     case 0x68: /* LD - load */
1380     case 0x78: /* LE - load */
1381     case 0x2c: /* MDR - multiply */
1382     case 0x3c: /* MDER - multiply */
1383     case 0x6c: /* MD - multiply */
1384     case 0x7c: /* MDE - multiply */
1385     case 0x2d: /* DDR - divide */
1386     case 0x3d: /* DER - divide */
1387     case 0x6d: /* DD - divide */
1388     case 0x7d: /* DE - divide */
1389       /* float destination, no flags */
1390       if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[2]))
1391         return -1;
1392       break;
1393
1394     case 0x26: /* MXR - multiply */
1395     case 0x27: /* MXDR - multiply */
1396     case 0x67: /* MXD - multiply */
1397       /* float pair destination, no flags */
1398       if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[2]))
1399         return -1;
1400       if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + (inib[2] | 2)))
1401         return -1;
1402       break;
1403
1404     case 0x36: /* AXR - add */
1405     case 0x37: /* SXR - subtract */
1406       /* float pair destination + flags */
1407       if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[2]))
1408         return -1;
1409       if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + (inib[2] | 2)))
1410         return -1;
1411       if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
1412         return -1;
1413       break;
1414
1415     case 0x40: /* STH - store halfword */
1416       oaddr = s390_record_calc_disp (gdbarch, regcache, inib[3], insn[1], 0);
1417       if (record_full_arch_list_add_mem (oaddr, 2))
1418         return -1;
1419       break;
1420
1421     case 0x42: /* STC - store character */
1422       oaddr = s390_record_calc_disp (gdbarch, regcache, inib[3], insn[1], 0);
1423       if (record_full_arch_list_add_mem (oaddr, 1))
1424         return -1;
1425       break;
1426
1427     case 0x44: /* EX - execute */
1428       if (ex != -1)
1429         {
1430           fprintf_unfiltered (gdb_stdlog, "Warning: Double execute at %s.\n",
1431                               paddress (gdbarch, addr));
1432           return -1;
1433         }
1434       addr = s390_record_calc_disp (gdbarch, regcache, inib[3], insn[1], 0);
1435       if (inib[2])
1436         {
1437           regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + inib[2], &tmp);
1438           ex = tmp & 0xff;
1439         }
1440       else
1441         {
1442           ex = 0;
1443         }
1444       goto ex;
1445
1446     case 0x4e: /* CVD - convert to decimal */
1447     case 0x60: /* STD - store */
1448       oaddr = s390_record_calc_disp (gdbarch, regcache, inib[3], insn[1], 0);
1449       if (record_full_arch_list_add_mem (oaddr, 8))
1450         return -1;
1451       break;
1452
1453     case 0x4f: /* CVB - convert to binary */
1454       /* 32-bit gpr destination + FPC (DXC write) */
1455       if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
1456         return -1;
1457       if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
1458         return -1;
1459       break;
1460
1461     case 0x50: /* ST - store */
1462     case 0x70: /* STE - store */
1463       oaddr = s390_record_calc_disp (gdbarch, regcache, inib[3], insn[1], 0);
1464       if (record_full_arch_list_add_mem (oaddr, 4))
1465         return -1;
1466       break;
1467
1468     case 0x51: /* LAE - load address extended */
1469       if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
1470         return -1;
1471       if (record_full_arch_list_add_reg (regcache, S390_A0_REGNUM + inib[2]))
1472         return -1;
1473       break;
1474
1475     /* 0x52 undefined */
1476     /* 0x53 undefined */
1477
1478     /* 0x61-0x66 undefined */
1479
1480     /* 0x72-0x77 undefined */
1481
1482     /* 0x80 privileged: SSM - set system mask */
1483     /* 0x81 undefined */
1484     /* 0x82 privileged: LPSW - load PSW */
1485     /* 0x83 privileged: diagnose */
1486
1487     case 0x8e: /* SRDA - shift right double */
1488     case 0x8f: /* SLDA - shift left double */
1489       /* 32-bit pair destination + flags */
1490       if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
1491         return -1;
1492       if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[2] | 1)))
1493         return -1;
1494       if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
1495         return -1;
1496       break;
1497
1498     case 0x90: /* STM - store multiple */
1499     case 0x9b: /* STAM - store access multiple */
1500       oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
1501       if (inib[2] <= inib[3])
1502         n = inib[3] - inib[2] + 1;
1503       else
1504         n = inib[3] + 0x10 - inib[2] + 1;
1505       if (record_full_arch_list_add_mem (oaddr, n * 4))
1506         return -1;
1507       break;
1508
1509     case 0x92: /* MVI - move */
1510       oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
1511       if (record_full_arch_list_add_mem (oaddr, 1))
1512         return -1;
1513       break;
1514
1515     case 0x93: /* TS - test and set */
1516     case 0x94: /* NI - and */
1517     case 0x96: /* OI - or */
1518     case 0x97: /* XI - xor */
1519       oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
1520       if (record_full_arch_list_add_mem (oaddr, 1))
1521         return -1;
1522       if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
1523         return -1;
1524       break;
1525
1526     case 0x98: /* LM - load multiple */
1527       for (i = inib[2]; i != inib[3]; i++, i &= 0xf)
1528         if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + i))
1529           return -1;
1530       if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[3]))
1531         return -1;
1532       break;
1533
1534     /* 0x99 privileged: TRACE */
1535
1536     case 0x9a: /* LAM - load access multiple */
1537       for (i = inib[2]; i != inib[3]; i++, i &= 0xf)
1538         if (record_full_arch_list_add_reg (regcache, S390_A0_REGNUM + i))
1539           return -1;
1540       if (record_full_arch_list_add_reg (regcache, S390_A0_REGNUM + inib[3]))
1541         return -1;
1542       break;
1543
1544     /* 0x9c-0x9f privileged and obsolete (old I/O) */
1545     /* 0xa0-0xa4 undefined */
1546
1547     case 0xa5:
1548     case 0xa7:
1549       /* RI-format instruction */
1550       switch (ibyte[0] << 4 | inib[3])
1551         {
1552         case 0xa50: /* IIHH - insert immediate */
1553         case 0xa51: /* IIHL - insert immediate */
1554           /* high 32-bit destination */
1555           if (s390_record_gpr_h (gdbarch, regcache, inib[2]))
1556             return -1;
1557           break;
1558
1559         case 0xa52: /* IILH - insert immediate */
1560         case 0xa53: /* IILL - insert immediate */
1561         case 0xa75: /* BRAS - branch relative and save */
1562         case 0xa76: /* BRCT - branch relative on count */
1563         case 0xa78: /* LHI - load halfword immediate */
1564         case 0xa7c: /* MHI - multiply halfword immediate */
1565           /* 32-bit or native destination */
1566           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
1567             return -1;
1568           break;
1569
1570         case 0xa54: /* NIHH - and immediate */
1571         case 0xa55: /* NIHL - and immediate */
1572         case 0xa58: /* OIHH - or immediate */
1573         case 0xa59: /* OIHL - or immediate */
1574           /* high 32-bit destination + flags */
1575           if (s390_record_gpr_h (gdbarch, regcache, inib[2]))
1576             return -1;
1577           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
1578             return -1;
1579           break;
1580
1581         case 0xa56: /* NILH - and immediate */
1582         case 0xa57: /* NILL - and immediate */
1583         case 0xa5a: /* OILH - or immediate */
1584         case 0xa5b: /* OILL - or immediate */
1585         case 0xa7a: /* AHI - add halfword immediate */
1586           /* 32-bit destination + flags */
1587           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
1588             return -1;
1589           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
1590             return -1;
1591           break;
1592
1593         case 0xa5c: /* LLIHH - load logical immediate */
1594         case 0xa5d: /* LLIHL - load logical immediate */
1595         case 0xa5e: /* LLILH - load logical immediate */
1596         case 0xa5f: /* LLILL - load logical immediate */
1597         case 0xa77: /* BRCTG - branch relative on count */
1598         case 0xa79: /* LGHI - load halfword immediate */
1599         case 0xa7d: /* MGHI - multiply halfword immediate */
1600           /* 64-bit destination */
1601           if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
1602             return -1;
1603           break;
1604
1605         case 0xa70: /* TMLH - test under mask */
1606         case 0xa71: /* TMLL - test under mask */
1607         case 0xa72: /* TMHH - test under mask */
1608         case 0xa73: /* TMHL - test under mask */
1609         case 0xa7e: /* CHI - compare halfword immediate */
1610         case 0xa7f: /* CGHI - compare halfword immediate */
1611           /* flags only */
1612           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
1613             return -1;
1614           break;
1615
1616         case 0xa74: /* BRC - branch relative on condition */
1617           /* no register change */
1618           break;
1619
1620         case 0xa7b: /* AGHI - add halfword immediate */
1621           /* 64-bit destination + flags */
1622           if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
1623             return -1;
1624           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
1625             return -1;
1626           break;
1627
1628         default:
1629           goto UNKNOWN_OP;
1630         }
1631       break;
1632
1633     /* 0xa6 undefined */
1634
1635     case 0xa8: /* MVCLE - move long extended [partial] */
1636       regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + inib[2], &tmp);
1637       oaddr = s390_record_address_mask (gdbarch, regcache, tmp);
1638       regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + (inib[2] | 1), &tmp);
1639       if (record_full_arch_list_add_mem (oaddr, tmp))
1640         return -1;
1641       if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
1642         return -1;
1643       if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[2] | 1)))
1644         return -1;
1645       if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[3]))
1646         return -1;
1647       if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[3] | 1)))
1648         return -1;
1649       if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
1650         return -1;
1651       break;
1652
1653     /* 0xaa-0xab undefined */
1654     /* 0xac privileged: STNSM - store then and system mask */
1655     /* 0xad privileged: STOSM - store then or system mask */
1656     /* 0xae privileged: SIGP - signal processor */
1657     /* 0xaf unsupported: MC - monitor call */
1658     /* 0xb0 undefined */
1659     /* 0xb1 privileged: LRA - load real address */
1660
1661     case 0xb2:
1662     case 0xb3:
1663     case 0xb9:
1664       /* S/RRD/RRE/RRF/IE-format instruction */
1665       switch (insn[0])
1666         {
1667         /* 0xb200-0xb204 undefined or privileged */
1668
1669         case 0xb205: /* STCK - store clock */
1670         case 0xb27c: /* STCKF - store clock fast */
1671           oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
1672           if (record_full_arch_list_add_mem (oaddr, 8))
1673             return -1;
1674           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
1675             return -1;
1676           break;
1677
1678         /* 0xb206-0xb219 undefined, privileged, or unsupported */
1679         /* 0xb21a unsupported: CFC */
1680         /* 0xb21b-0xb221 undefined or privileged */
1681
1682         case 0xb222: /* IPM - insert program mask */
1683         case 0xb24f: /* EAR - extract access */
1684         case 0xb252: /* MSR - multiply single */
1685         case 0xb2ec: /* ETND - extract transaction nesting depth */
1686         case 0xb38c: /* EFPC - extract fpc */
1687         case 0xb91f: /* LRVR - load reversed */
1688         case 0xb926: /* LBR - load byte */
1689         case 0xb927: /* LHR - load halfword */
1690         case 0xb994: /* LLCR - load logical character */
1691         case 0xb995: /* LLHR - load logical halfword */
1692         case 0xb9f2: /* LOCR - load on condition */
1693           /* 32-bit gpr destination */
1694           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
1695             return -1;
1696           break;
1697
1698         /* 0xb223-0xb22c privileged or unsupported */
1699
1700         case 0xb22d: /* DXR - divide */
1701         case 0xb325: /* LXDR - load lengthened */
1702         case 0xb326: /* LXER - load lengthened */
1703         case 0xb336: /* SQXR - square root */
1704         case 0xb365: /* LXR - load */
1705         case 0xb367: /* FIXR - load fp integer */
1706         case 0xb376: /* LZXR - load zero */
1707         case 0xb3b6: /* CXFR - convert from fixed */
1708         case 0xb3c6: /* CXGR - convert from fixed */
1709         case 0xb3fe: /* IEXTR - insert biased exponent */
1710           /* float pair destination */
1711           if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[6]))
1712             return -1;
1713           if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + (inib[6] | 2)))
1714             return -1;
1715           break;
1716
1717         /* 0xb22e-0xb240 undefined, privileged, or unsupported */
1718
1719         case 0xb241: /* CKSM - checksum [partial] */
1720           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
1721             return -1;
1722           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[7]))
1723             return -1;
1724           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[7] | 1)))
1725             return -1;
1726           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
1727             return -1;
1728           break;
1729
1730         /* 0xb242-0xb243 undefined */
1731
1732         case 0xb244: /* SQDR - square root */
1733         case 0xb245: /* SQER - square root */
1734         case 0xb324: /* LDER - load lengthened */
1735         case 0xb337: /* MEER - multiply */
1736         case 0xb366: /* LEXR - load rounded */
1737         case 0xb370: /* LPDFR - load positive */
1738         case 0xb371: /* LNDFR - load negative */
1739         case 0xb372: /* CSDFR - copy sign */
1740         case 0xb373: /* LCDFR - load complement */
1741         case 0xb374: /* LZER - load zero */
1742         case 0xb375: /* LZDR - load zero */
1743         case 0xb377: /* FIER - load fp integer */
1744         case 0xb37f: /* FIDR - load fp integer */
1745         case 0xb3b4: /* CEFR - convert from fixed */
1746         case 0xb3b5: /* CDFR - convert from fixed */
1747         case 0xb3c1: /* LDGR - load fpr from gr */
1748         case 0xb3c4: /* CEGR - convert from fixed */
1749         case 0xb3c5: /* CDGR - convert from fixed */
1750         case 0xb3f6: /* IEDTR - insert biased exponent */
1751           /* float destination */
1752           if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[6]))
1753             return -1;
1754           break;
1755
1756         /* 0xb246-0xb24c: privileged or unsupported */
1757
1758         case 0xb24d: /* CPYA - copy access */
1759         case 0xb24e: /* SAR - set access */
1760           if (record_full_arch_list_add_reg (regcache, S390_A0_REGNUM + inib[6]))
1761             return -1;
1762           break;
1763
1764         /* 0xb250-0xb251 undefined or privileged */
1765         /* 0xb253-0xb254 undefined or privileged */
1766
1767         case 0xb255: /* MVST - move string [partial] */
1768           {
1769             uint8_t end;
1770             gdb_byte cur;
1771             ULONGEST num = 0;
1772             /* Read ending byte.  */
1773             regcache_raw_read_unsigned (regcache, S390_R0_REGNUM, &tmp);
1774             end = tmp & 0xff;
1775             /* Get address of second operand.  */
1776             regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + inib[7], &tmp);
1777             oaddr = s390_record_address_mask (gdbarch, regcache, tmp);
1778             /* Search for ending byte and compute length.  */
1779             do {
1780               num++;
1781               if (target_read_memory (oaddr, &cur, 1))
1782                 return -1;
1783               oaddr++;
1784             } while (cur != end);
1785             /* Get address of first operand and record it.  */
1786             regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + inib[6], &tmp);
1787             oaddr = s390_record_address_mask (gdbarch, regcache, tmp);
1788             if (record_full_arch_list_add_mem (oaddr, num))
1789               return -1;
1790             /* Record the registers.  */
1791             if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
1792               return -1;
1793             if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[7]))
1794               return -1;
1795             if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
1796               return -1;
1797           }
1798           break;
1799
1800         /* 0xb256 undefined */
1801
1802         case 0xb257: /* CUSE - compare until substring equal [interruptible] */
1803           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
1804             return -1;
1805           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[6] | 1)))
1806             return -1;
1807           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[7]))
1808             return -1;
1809           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[7] | 1)))
1810             return -1;
1811           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
1812             return -1;
1813           break;
1814
1815         /* 0xb258-0xb25c undefined, privileged, or unsupported */
1816
1817         case 0xb25d: /* CLST - compare logical string [partial] */
1818         case 0xb25e: /* SRST - search string [partial] */
1819         case 0xb9be: /* SRSTU - search string unicode [partial] */
1820           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
1821             return -1;
1822           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[7]))
1823             return -1;
1824           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
1825             return -1;
1826           break;
1827
1828         /* 0xb25f-0xb262 undefined */
1829
1830         case 0xb263: /* CMPSC - compression call [interruptible] */
1831           regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + inib[6], &tmp);
1832           oaddr = s390_record_address_mask (gdbarch, regcache, tmp);
1833           regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + (inib[6] | 1), &tmp);
1834           if (record_full_arch_list_add_mem (oaddr, tmp))
1835             return -1;
1836           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
1837             return -1;
1838           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[6] | 1)))
1839             return -1;
1840           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[7]))
1841             return -1;
1842           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[7] | 1)))
1843             return -1;
1844           if (record_full_arch_list_add_reg (regcache, S390_R1_REGNUM))
1845             return -1;
1846           /* DXC may be written */
1847           if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
1848             return -1;
1849           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
1850             return -1;
1851           break;
1852
1853         /* 0xb264-0xb277 undefined, privileged, or unsupported */
1854
1855         case 0xb278: /* STCKE - store clock extended */
1856           oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
1857           if (record_full_arch_list_add_mem (oaddr, 16))
1858             return -1;
1859           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
1860             return -1;
1861           break;
1862
1863         /* 0xb279-0xb27b undefined or unsupported */
1864         /* 0xb27d-0xb298 undefined or privileged */
1865
1866         case 0xb299: /* SRNM - set rounding mode */
1867         case 0xb2b8: /* SRNMB - set bfp rounding mode */
1868         case 0xb2b9: /* SRNMT - set dfp rounding mode */
1869         case 0xb29d: /* LFPC - load fpc */
1870         case 0xb2bd: /* LFAS - load fpc and signal */
1871         case 0xb384: /* SFPC - set fpc */
1872         case 0xb385: /* SFASR - set fpc and signal */
1873         case 0xb960: /* CGRT - compare and trap */
1874         case 0xb961: /* CLGRT - compare logical and trap */
1875         case 0xb972: /* CRT - compare and trap */
1876         case 0xb973: /* CLRT - compare logical and trap */
1877           /* fpc only - including possible DXC write for trapping insns */
1878           if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
1879             return -1;
1880           break;
1881
1882         /* 0xb29a-0xb29b undefined */
1883
1884         case 0xb29c: /* STFPC - store fpc */
1885           oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
1886           if (record_full_arch_list_add_mem (oaddr, 4))
1887             return -1;
1888           break;
1889
1890         /* 0xb29e-0xb2a4 undefined */
1891
1892         case 0xb2a5: /* TRE - translate extended [partial] */
1893           regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + inib[6], &tmp);
1894           oaddr = s390_record_address_mask (gdbarch, regcache, tmp);
1895           regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + (inib[6] | 1), &tmp);
1896           if (record_full_arch_list_add_mem (oaddr, tmp))
1897             return -1;
1898           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
1899             return -1;
1900           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[6] | 1)))
1901             return -1;
1902           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
1903             return -1;
1904           break;
1905
1906         case 0xb2a6: /* CU21 - convert UTF-16 to UTF-8 [partial] */
1907         case 0xb2a7: /* CU12 - convert UTF-8 to UTF-16 [partial] */
1908         case 0xb9b0: /* CU14 - convert UTF-8 to UTF-32 [partial] */
1909         case 0xb9b1: /* CU24 - convert UTF-16 to UTF-32 [partial] */
1910         case 0xb9b2: /* CU41 - convert UTF-32 to UTF-8 [partial] */
1911         case 0xb9b3: /* CU42 - convert UTF-32 to UTF-16 [partial] */
1912           regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + inib[6], &tmp);
1913           oaddr = s390_record_address_mask (gdbarch, regcache, tmp);
1914           regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + (inib[6] | 1), &tmp);
1915           if (record_full_arch_list_add_mem (oaddr, tmp))
1916             return -1;
1917           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
1918             return -1;
1919           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[6] | 1)))
1920             return -1;
1921           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[7]))
1922             return -1;
1923           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[7] | 1)))
1924             return -1;
1925           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
1926             return -1;
1927           break;
1928
1929         /* 0xb2a8-0xb2af undefined */
1930
1931         case 0xb2b0: /* STFLE - store facility list extended */
1932           oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
1933           regcache_raw_read_unsigned (regcache, S390_R0_REGNUM, &tmp);
1934           tmp &= 0xff;
1935           if (record_full_arch_list_add_mem (oaddr, 8 * (tmp + 1)))
1936             return -1;
1937           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM))
1938             return -1;
1939           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
1940             return -1;
1941           break;
1942
1943         /* 0xb2b1-0xb2b7 undefined or privileged */
1944         /* 0xb2ba-0xb2bc undefined */
1945         /* 0xb2be-0xb2e7 undefined */
1946         /* 0xb2e9-0xb2eb undefined */
1947         /* 0xb2ed-0xb2f7 undefined */
1948         /* 0xb2f8 unsupported: TEND */
1949         /* 0xb2f9 undefined */
1950
1951         case 0xb2e8: /* PPA - perform processor assist */
1952         case 0xb2fa: /* NIAI - next instruction access intent */
1953           /* no visible effects */
1954           break;
1955
1956         /* 0xb2fb undefined */
1957         /* 0xb2fc unsupported: TABORT */
1958         /* 0xb2fd-0xb2fe undefined */
1959         /* 0xb2ff unsupported: TRAP */
1960
1961         case 0xb300: /* LPEBR - load positive */
1962         case 0xb301: /* LNEBR - load negative */
1963         case 0xb303: /* LCEBR - load complement */
1964         case 0xb310: /* LPDBR - load positive */
1965         case 0xb311: /* LNDBR - load negative */
1966         case 0xb313: /* LCDBR - load complement */
1967         case 0xb350: /* TBEDR - convert hfp to bfp */
1968         case 0xb351: /* TBDR - convert hfp to bfp */
1969         case 0xb358: /* THDER - convert bfp to hfp */
1970         case 0xb359: /* THDR - convert bfp to hfp */
1971           /* float destination + flags */
1972           if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[6]))
1973             return -1;
1974           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
1975             return -1;
1976           break;
1977
1978         case 0xb304: /* LDEBR - load lengthened */
1979         case 0xb30c: /* MDEBR - multiply */
1980         case 0xb30d: /* DEBR - divide */
1981         case 0xb314: /* SQEBR - square root */
1982         case 0xb315: /* SQDBR - square root */
1983         case 0xb317: /* MEEBR - multiply */
1984         case 0xb31c: /* MDBR - multiply */
1985         case 0xb31d: /* DDBR - divide */
1986         case 0xb344: /* LEDBRA - load rounded */
1987         case 0xb345: /* LDXBRA - load rounded */
1988         case 0xb346: /* LEXBRA - load rounded */
1989         case 0xb357: /* FIEBRA - load fp integer */
1990         case 0xb35f: /* FIDBRA - load fp integer */
1991         case 0xb390: /* CELFBR - convert from logical */
1992         case 0xb391: /* CDLFBR - convert from logical */
1993         case 0xb394: /* CEFBR - convert from fixed */
1994         case 0xb395: /* CDFBR - convert from fixed */
1995         case 0xb3a0: /* CELGBR - convert from logical */
1996         case 0xb3a1: /* CDLGBR - convert from logical */
1997         case 0xb3a4: /* CEGBR - convert from fixed */
1998         case 0xb3a5: /* CDGBR - convert from fixed */
1999         case 0xb3d0: /* MDTR - multiply */
2000         case 0xb3d1: /* DDTR - divide */
2001         case 0xb3d4: /* LDETR - load lengthened */
2002         case 0xb3d5: /* LEDTR - load lengthened */
2003         case 0xb3d7: /* FIDTR - load fp integer */
2004         case 0xb3dd: /* LDXTR - load lengthened */
2005         case 0xb3f1: /* CDGTR - convert from fixed */
2006         case 0xb3f2: /* CDUTR - convert from unsigned packed */
2007         case 0xb3f3: /* CDSTR - convert from signed packed */
2008         case 0xb3f5: /* QADTR - quantize */
2009         case 0xb3f7: /* RRDTR - reround */
2010         case 0xb951: /* CDFTR - convert from fixed */
2011         case 0xb952: /* CDLGTR - convert from logical */
2012         case 0xb953: /* CDLFTR - convert from logical */
2013           /* float destination + fpc */
2014           if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[6]))
2015             return -1;
2016           if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
2017             return -1;
2018           break;
2019
2020         case 0xb305: /* LXDBR - load lengthened */
2021         case 0xb306: /* LXEBR - load lengthened */
2022         case 0xb307: /* MXDBR - multiply */
2023         case 0xb316: /* SQXBR - square root */
2024         case 0xb34c: /* MXBR - multiply */
2025         case 0xb34d: /* DXBR - divide */
2026         case 0xb347: /* FIXBRA - load fp integer */
2027         case 0xb392: /* CXLFBR - convert from logical */
2028         case 0xb396: /* CXFBR - convert from fixed */
2029         case 0xb3a2: /* CXLGBR - convert from logical */
2030         case 0xb3a6: /* CXGBR - convert from fixed */
2031         case 0xb3d8: /* MXTR - multiply */
2032         case 0xb3d9: /* DXTR - divide */
2033         case 0xb3dc: /* LXDTR - load lengthened */
2034         case 0xb3df: /* FIXTR - load fp integer */
2035         case 0xb3f9: /* CXGTR - convert from fixed */
2036         case 0xb3fa: /* CXUTR - convert from unsigned packed */
2037         case 0xb3fb: /* CXSTR - convert from signed packed */
2038         case 0xb3fd: /* QAXTR - quantize */
2039         case 0xb3ff: /* RRXTR - reround */
2040         case 0xb959: /* CXFTR - convert from fixed */
2041         case 0xb95a: /* CXLGTR - convert from logical */
2042         case 0xb95b: /* CXLFTR - convert from logical */
2043           /* float pair destination + fpc */
2044           if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[6]))
2045             return -1;
2046           if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + (inib[6] | 2)))
2047             return -1;
2048           if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
2049             return -1;
2050           break;
2051
2052         case 0xb308: /* KEBR - compare and signal */
2053         case 0xb309: /* CEBR - compare */
2054         case 0xb318: /* KDBR - compare and signal */
2055         case 0xb319: /* CDBR - compare */
2056         case 0xb348: /* KXBR - compare and signal */
2057         case 0xb349: /* CXBR - compare */
2058         case 0xb3e0: /* KDTR - compare and signal */
2059         case 0xb3e4: /* CDTR - compare */
2060         case 0xb3e8: /* KXTR - compare and signal */
2061         case 0xb3ec: /* CXTR - compare */
2062           /* flags + fpc only */
2063           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
2064             return -1;
2065           if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
2066             return -1;
2067           break;
2068
2069         case 0xb302: /* LTEBR - load and test */
2070         case 0xb312: /* LTDBR - load and test */
2071         case 0xb30a: /* AEBR - add */
2072         case 0xb30b: /* SEBR - subtract */
2073         case 0xb31a: /* ADBR - add */
2074         case 0xb31b: /* SDBR - subtract */
2075         case 0xb3d2: /* ADTR - add */
2076         case 0xb3d3: /* SDTR - subtract */
2077         case 0xb3d6: /* LTDTR - load and test */
2078           /* float destination + flags + fpc */
2079           if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[6]))
2080             return -1;
2081           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
2082             return -1;
2083           if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
2084             return -1;
2085           break;
2086
2087         case 0xb30e: /* MAEBR - multiply and add */
2088         case 0xb30f: /* MSEBR - multiply and subtract */
2089         case 0xb31e: /* MADBR - multiply and add */
2090         case 0xb31f: /* MSDBR - multiply and subtract */
2091           /* float destination [RRD] + fpc */
2092           if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[4]))
2093             return -1;
2094           if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
2095             return -1;
2096           break;
2097
2098         /* 0xb320-0xb323 undefined */
2099         /* 0xb327-0xb32d undefined */
2100
2101         case 0xb32e: /* MAER - multiply and add */
2102         case 0xb32f: /* MSER - multiply and subtract */
2103         case 0xb338: /* MAYLR - multiply and add unnormalized */
2104         case 0xb339: /* MYLR - multiply unnormalized */
2105         case 0xb33c: /* MAYHR - multiply and add unnormalized */
2106         case 0xb33d: /* MYHR - multiply unnormalized */
2107         case 0xb33e: /* MADR - multiply and add */
2108         case 0xb33f: /* MSDR - multiply and subtract */
2109           /* float destination [RRD] */
2110           if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[4]))
2111             return -1;
2112           break;
2113
2114         /* 0xb330-0xb335 undefined */
2115
2116         case 0xb33a: /* MAYR - multiply and add unnormalized */
2117         case 0xb33b: /* MYR - multiply unnormalized */
2118           /* float pair destination [RRD] */
2119           if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[4]))
2120             return -1;
2121           if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + (inib[4] | 2)))
2122             return -1;
2123           break;
2124
2125         case 0xb340: /* LPXBR - load positive */
2126         case 0xb341: /* LNXBR - load negative */
2127         case 0xb343: /* LCXBR - load complement */
2128         case 0xb360: /* LPXR - load positive */
2129         case 0xb361: /* LNXR - load negative */
2130         case 0xb362: /* LTXR - load and test */
2131         case 0xb363: /* LCXR - load complement */
2132           /* float pair destination + flags */
2133           if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[6]))
2134             return -1;
2135           if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + (inib[6] | 2)))
2136             return -1;
2137           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
2138             return -1;
2139           break;
2140
2141         case 0xb342: /* LTXBR - load and test */
2142         case 0xb34a: /* AXBR - add */
2143         case 0xb34b: /* SXBR - subtract */
2144         case 0xb3da: /* AXTR - add */
2145         case 0xb3db: /* SXTR - subtract */
2146         case 0xb3de: /* LTXTR - load and test */
2147           /* float pair destination + flags + fpc */
2148           if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[6]))
2149             return -1;
2150           if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + (inib[6] | 2)))
2151             return -1;
2152           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
2153             return -1;
2154           if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
2155             return -1;
2156           break;
2157
2158         /* 0xb34e-0xb34f undefined */
2159         /* 0xb352 undefined */
2160
2161         case 0xb353: /* DIEBR - divide to integer */
2162         case 0xb35b: /* DIDBR - divide to integer */
2163           /* two float destinations + flags + fpc */
2164           if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[4]))
2165             return -1;
2166           if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[6]))
2167             return -1;
2168           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
2169             return -1;
2170           if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
2171             return -1;
2172           break;
2173
2174         /* 0xb354-0xb356 undefined */
2175         /* 0xb35a undefined */
2176
2177         /* 0xb35c-0xb35e undefined */
2178         /* 0xb364 undefined */
2179         /* 0xb368 undefined */
2180
2181         case 0xb369: /* CXR - compare */
2182         case 0xb3f4: /* CEDTR - compare biased exponent */
2183         case 0xb3fc: /* CEXTR - compare biased exponent */
2184         case 0xb920: /* CGR - compare */
2185         case 0xb921: /* CLGR - compare logical */
2186         case 0xb930: /* CGFR - compare */
2187         case 0xb931: /* CLGFR - compare logical */
2188         case 0xb9cd: /* CHHR - compare high */
2189         case 0xb9cf: /* CLHHR - compare logical high */
2190         case 0xb9dd: /* CHLR - compare high */
2191         case 0xb9df: /* CLHLR - compare logical high */
2192           /* flags only */
2193           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
2194             return -1;
2195           break;
2196
2197         /* 0xb36a-0xb36f undefined */
2198         /* 0xb377-0xb37e undefined */
2199         /* 0xb380-0xb383 undefined */
2200         /* 0xb386-0xb38b undefined */
2201         /* 0xb38d-0xb38f undefined */
2202         /* 0xb393 undefined */
2203         /* 0xb397 undefined */
2204
2205         case 0xb398: /* CFEBR - convert to fixed */
2206         case 0xb399: /* CFDBR - convert to fixed */
2207         case 0xb39a: /* CFXBR - convert to fixed */
2208         case 0xb39c: /* CLFEBR - convert to logical */
2209         case 0xb39d: /* CLFDBR - convert to logical */
2210         case 0xb39e: /* CLFXBR - convert to logical */
2211         case 0xb941: /* CFDTR - convert to fixed */
2212         case 0xb949: /* CFXTR - convert to fixed */
2213         case 0xb943: /* CLFDTR - convert to logical */
2214         case 0xb94b: /* CLFXTR - convert to logical */
2215           /* 32-bit gpr destination + flags + fpc */
2216           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
2217             return -1;
2218           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
2219             return -1;
2220           if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
2221             return -1;
2222           break;
2223
2224         /* 0xb39b undefined */
2225         /* 0xb39f undefined */
2226
2227         /* 0xb3a3 undefined */
2228         /* 0xb3a7 undefined */
2229
2230         case 0xb3a8: /* CGEBR - convert to fixed */
2231         case 0xb3a9: /* CGDBR - convert to fixed */
2232         case 0xb3aa: /* CGXBR - convert to fixed */
2233         case 0xb3ac: /* CLGEBR - convert to logical */
2234         case 0xb3ad: /* CLGDBR - convert to logical */
2235         case 0xb3ae: /* CLGXBR - convert to logical */
2236         case 0xb3e1: /* CGDTR - convert to fixed */
2237         case 0xb3e9: /* CGXTR - convert to fixed */
2238         case 0xb942: /* CLGDTR - convert to logical */
2239         case 0xb94a: /* CLGXTR - convert to logical */
2240           /* 64-bit gpr destination + flags + fpc */
2241           if (s390_record_gpr_g (gdbarch, regcache, inib[6]))
2242             return -1;
2243           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
2244             return -1;
2245           if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
2246             return -1;
2247           break;
2248
2249         /* 0xb3ab undefined */
2250         /* 0xb3af-0xb3b3 undefined */
2251         /* 0xb3b7 undefined */
2252
2253         case 0xb3b8: /* CFER - convert to fixed */
2254         case 0xb3b9: /* CFDR - convert to fixed */
2255         case 0xb3ba: /* CFXR - convert to fixed */
2256         case 0xb998: /* ALCR - add logical with carry */
2257         case 0xb999: /* SLBR - subtract logical with borrow */
2258         case 0xb9f4: /* NRK - and */
2259         case 0xb9f6: /* ORK - or */
2260         case 0xb9f7: /* XRK - xor */
2261         case 0xb9f8: /* ARK - add */
2262         case 0xb9f9: /* SRK - subtract */
2263         case 0xb9fa: /* ALRK - add logical */
2264         case 0xb9fb: /* SLRK - subtract logical */
2265           /* 32-bit gpr destination + flags */
2266           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
2267             return -1;
2268           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
2269             return -1;
2270           break;
2271
2272         case 0xb3c8: /* CGER - convert to fixed */
2273         case 0xb3c9: /* CGDR - convert to fixed */
2274         case 0xb3ca: /* CGXR - convert to fixed */
2275         case 0xb900: /* LPGR - load positive */
2276         case 0xb901: /* LNGR - load negative */
2277         case 0xb902: /* LTGR - load and test */
2278         case 0xb903: /* LCGR - load complement */
2279         case 0xb908: /* AGR - add */
2280         case 0xb909: /* SGR - subtract */
2281         case 0xb90a: /* ALGR - add logical */
2282         case 0xb90b: /* SLGR - subtract logical */
2283         case 0xb910: /* LPGFR - load positive */
2284         case 0xb911: /* LNGFR - load negative */
2285         case 0xb912: /* LTGFR - load and test */
2286         case 0xb913: /* LCGFR - load complement */
2287         case 0xb918: /* AGFR - add */
2288         case 0xb919: /* SGFR - subtract */
2289         case 0xb91a: /* ALGFR - add logical */
2290         case 0xb91b: /* SLGFR - subtract logical */
2291         case 0xb980: /* NGR - and */
2292         case 0xb981: /* OGR - or */
2293         case 0xb982: /* XGR - xor */
2294         case 0xb988: /* ALCGR - add logical with carry */
2295         case 0xb989: /* SLBGR - subtract logical with borrow */
2296         case 0xb9e1: /* POPCNT - population count */
2297         case 0xb9e4: /* NGRK - and */
2298         case 0xb9e6: /* OGRK - or */
2299         case 0xb9e7: /* XGRK - xor */
2300         case 0xb9e8: /* AGRK - add */
2301         case 0xb9e9: /* SGRK - subtract */
2302         case 0xb9ea: /* ALGRK - add logical */
2303         case 0xb9eb: /* SLGRK - subtract logical */
2304         case 0xb9ed: /* MSGRKC - multiply single 64x64 -> 64 */
2305         case 0xb9fd: /* MSRKC - multiply single 32x32 -> 32 */
2306           /* 64-bit gpr destination + flags */
2307           if (s390_record_gpr_g (gdbarch, regcache, inib[6]))
2308             return -1;
2309           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
2310             return -1;
2311           break;
2312
2313         /* 0xb3bb-0xb3c0 undefined */
2314         /* 0xb3c2-0xb3c3 undefined */
2315         /* 0xb3c7 undefined */
2316         /* 0xb3cb-0xb3cc undefined */
2317
2318         case 0xb3cd: /* LGDR - load gr from fpr */
2319         case 0xb3e2: /* CUDTR - convert to unsigned packed */
2320         case 0xb3e3: /* CSDTR - convert to signed packed */
2321         case 0xb3e5: /* EEDTR - extract biased exponent */
2322         case 0xb3e7: /* ESDTR - extract significance */
2323         case 0xb3ed: /* EEXTR - extract biased exponent */
2324         case 0xb3ef: /* ESXTR - extract significance */
2325         case 0xb904: /* LGR - load */
2326         case 0xb906: /* LGBR - load byte */
2327         case 0xb907: /* LGHR - load halfword */
2328         case 0xb90c: /* MSGR - multiply single */
2329         case 0xb90f: /* LRVGR - load reversed */
2330         case 0xb914: /* LGFR - load */
2331         case 0xb916: /* LLGFR - load logical */
2332         case 0xb917: /* LLGTR - load logical thirty one bits */
2333         case 0xb91c: /* MSGFR - multiply single 64<32 */
2334         case 0xb946: /* BCTGR - branch on count */
2335         case 0xb984: /* LLGCR - load logical character */
2336         case 0xb985: /* LLGHR - load logical halfword */
2337         case 0xb9e2: /* LOCGR - load on condition */
2338           /* 64-bit gpr destination  */
2339           if (s390_record_gpr_g (gdbarch, regcache, inib[6]))
2340             return -1;
2341           break;
2342
2343         /* 0xb3ce-0xb3cf undefined */
2344         /* 0xb3e6 undefined */
2345
2346         case 0xb3ea: /* CUXTR - convert to unsigned packed */
2347         case 0xb3eb: /* CSXTR - convert to signed packed */
2348         case 0xb90d: /* DSGR - divide single */
2349         case 0xb91d: /* DSGFR - divide single */
2350         case 0xb986: /* MLGR - multiply logical */
2351         case 0xb987: /* DLGR - divide logical */
2352         case 0xb9ec: /* MGRK - multiply 64x64 -> 128 */
2353           /* 64-bit gpr pair destination  */
2354           if (s390_record_gpr_g (gdbarch, regcache, inib[6]))
2355             return -1;
2356           if (s390_record_gpr_g (gdbarch, regcache, inib[6] | 1))
2357             return -1;
2358           break;
2359
2360         /* 0xb3ee undefined */
2361         /* 0xb3f0 undefined */
2362         /* 0xb3f8 undefined */
2363
2364         /* 0xb905 privileged */
2365
2366         /* 0xb90e unsupported: EREGG */
2367
2368         /* 0xb915 undefined */
2369
2370         case 0xb91e: /* KMAC - compute message authentication code [partial] */
2371           regcache_raw_read_unsigned (regcache, S390_R1_REGNUM, &tmp);
2372           oaddr = s390_record_address_mask (gdbarch, regcache, tmp);
2373           regcache_raw_read_unsigned (regcache, S390_R0_REGNUM, &tmp);
2374           tmp &= 0xff;
2375           switch (tmp)
2376             {
2377               case 0x00: /* KMAC-Query */
2378                 if (record_full_arch_list_add_mem (oaddr, 16))
2379                   return -1;
2380                 break;
2381
2382               case 0x01: /* KMAC-DEA */
2383               case 0x02: /* KMAC-TDEA-128 */
2384               case 0x03: /* KMAC-TDEA-192 */
2385               case 0x09: /* KMAC-Encrypted-DEA */
2386               case 0x0a: /* KMAC-Encrypted-TDEA-128 */
2387               case 0x0b: /* KMAC-Encrypted-TDEA-192 */
2388                 if (record_full_arch_list_add_mem (oaddr, 8))
2389                   return -1;
2390                 break;
2391
2392               case 0x12: /* KMAC-AES-128 */
2393               case 0x13: /* KMAC-AES-192 */
2394               case 0x14: /* KMAC-AES-256 */
2395               case 0x1a: /* KMAC-Encrypted-AES-128 */
2396               case 0x1b: /* KMAC-Encrypted-AES-192 */
2397               case 0x1c: /* KMAC-Encrypted-AES-256 */
2398                 if (record_full_arch_list_add_mem (oaddr, 16))
2399                   return -1;
2400                 break;
2401
2402               default:
2403                 fprintf_unfiltered (gdb_stdlog, "Warning: Unknown KMAC function %02x at %s.\n",
2404                                     (int)tmp, paddress (gdbarch, addr));
2405                 return -1;
2406             }
2407           if (tmp != 0)
2408             {
2409               if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[7]))
2410                 return -1;
2411               if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[7] | 1)))
2412                 return -1;
2413             }
2414           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
2415             return -1;
2416           break;
2417
2418         /* 0xb922-0xb924 undefined */
2419         /* 0xb925 privileged */
2420         /* 0xb928 privileged */
2421
2422         case 0xb929: /* KMA - cipher message with authentication */
2423         case 0xb92a: /* KMF - cipher message with cipher feedback [partial] */
2424         case 0xb92b: /* KMO - cipher message with output feedback [partial] */
2425         case 0xb92f: /* KMC - cipher message with chaining [partial] */
2426           regcache_raw_read_unsigned (regcache, S390_R1_REGNUM, &tmp);
2427           oaddr = s390_record_address_mask (gdbarch, regcache, tmp);
2428           regcache_raw_read_unsigned (regcache, S390_R0_REGNUM, &tmp);
2429           tmp &= 0x7f;
2430           switch (tmp)
2431             {
2432               case 0x00: /* KM*-Query */
2433                 if (record_full_arch_list_add_mem (oaddr, 16))
2434                   return -1;
2435                 break;
2436
2437               case 0x01: /* KM*-DEA */
2438               case 0x02: /* KM*-TDEA-128 */
2439               case 0x03: /* KM*-TDEA-192 */
2440               case 0x09: /* KM*-Encrypted-DEA */
2441               case 0x0a: /* KM*-Encrypted-TDEA-128 */
2442               case 0x0b: /* KM*-Encrypted-TDEA-192 */
2443                 if (record_full_arch_list_add_mem (oaddr, 8))
2444                   return -1;
2445                 break;
2446
2447               case 0x12: /* KM*-AES-128 */
2448               case 0x13: /* KM*-AES-192 */
2449               case 0x14: /* KM*-AES-256 */
2450               case 0x1a: /* KM*-Encrypted-AES-128 */
2451               case 0x1b: /* KM*-Encrypted-AES-192 */
2452               case 0x1c: /* KM*-Encrypted-AES-256 */
2453                 if (record_full_arch_list_add_mem (oaddr, 16))
2454                   return -1;
2455                 break;
2456
2457               case 0x43: /* KMC-PRNG */
2458                 /* Only valid for KMC.  */
2459                 if (insn[0] == 0xb92f)
2460                   {
2461                     if (record_full_arch_list_add_mem (oaddr, 8))
2462                       return -1;
2463                     break;
2464                   }
2465                 /* For other instructions, fallthru.  */
2466               default:
2467                 fprintf_unfiltered (gdb_stdlog, "Warning: Unknown KM* function %02x at %s.\n",
2468                                     (int)tmp, paddress (gdbarch, addr));
2469                 return -1;
2470             }
2471           if (tmp != 0)
2472             {
2473               regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + inib[6], &tmp);
2474               oaddr2 = s390_record_address_mask (gdbarch, regcache, tmp);
2475               regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + (inib[7] | 1), &tmp);
2476               if (record_full_arch_list_add_mem (oaddr2, tmp))
2477                 return -1;
2478               if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
2479                 return -1;
2480               if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[7]))
2481                 return -1;
2482               if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[7] | 1)))
2483                 return -1;
2484             }
2485           if (tmp != 0 && insn[0] == 0xb929)
2486             {
2487               if (record_full_arch_list_add_reg (regcache,
2488                                                  S390_R0_REGNUM + inib[4]))
2489                 return -1;
2490               if (record_full_arch_list_add_reg (regcache,
2491                                                  S390_R0_REGNUM + (inib[4] | 1)))
2492                 return -1;
2493             }
2494           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
2495             return -1;
2496           break;
2497
2498         case 0xb92c: /* PCC - perform cryptographic computation [partial] */
2499           regcache_raw_read_unsigned (regcache, S390_R1_REGNUM, &tmp);
2500           oaddr = s390_record_address_mask (gdbarch, regcache, tmp);
2501           regcache_raw_read_unsigned (regcache, S390_R0_REGNUM, &tmp);
2502           tmp &= 0x7f;
2503           switch (tmp)
2504             {
2505               case 0x00: /* PCC-Query */
2506                 if (record_full_arch_list_add_mem (oaddr, 16))
2507                   return -1;
2508                 break;
2509
2510               case 0x01: /* PCC-Compute-Last-Block-CMAC-Using-DEA */
2511               case 0x02: /* PCC-Compute-Last-Block-CMAC-Using-TDEA-128 */
2512               case 0x03: /* PCC-Compute-Last-Block-CMAC-Using-TDEA-192 */
2513               case 0x09: /* PCC-Compute-Last-Block-CMAC-Using-Encrypted-DEA */
2514               case 0x0a: /* PCC-Compute-Last-Block-CMAC-Using-Encrypted-TDEA-128 */
2515               case 0x0b: /* PCC-Compute-Last-Block-CMAC-Using-Encrypted-TDEA-192 */
2516                 if (record_full_arch_list_add_mem (oaddr + 0x10, 8))
2517                   return -1;
2518                 break;
2519
2520               case 0x12: /* PCC-Compute-Last-Block-CMAC-Using-AES-128 */
2521               case 0x13: /* PCC-Compute-Last-Block-CMAC-Using-AES-192 */
2522               case 0x14: /* PCC-Compute-Last-Block-CMAC-Using-AES-256 */
2523               case 0x1a: /* PCC-Compute-Last-Block-CMAC-Using-Encrypted-AES-128 */
2524               case 0x1b: /* PCC-Compute-Last-Block-CMAC-Using-Encrypted-AES-192 */
2525               case 0x1c: /* PCC-Compute-Last-Block-CMAC-Using-Encrypted-AES-256 */
2526                 if (record_full_arch_list_add_mem (oaddr + 0x18, 16))
2527                   return -1;
2528                 break;
2529
2530               case 0x32: /* PCC-Compute-XTS-Parameter-Using-AES-128 */
2531                 if (record_full_arch_list_add_mem (oaddr + 0x30, 32))
2532                   return -1;
2533                 break;
2534
2535               case 0x34: /* PCC-Compute-XTS-Parameter-Using-AES-256 */
2536                 if (record_full_arch_list_add_mem (oaddr + 0x40, 32))
2537                   return -1;
2538                 break;
2539
2540               case 0x3a: /* PCC-Compute-XTS-Parameter-Using-Encrypted-AES-128 */
2541                 if (record_full_arch_list_add_mem (oaddr + 0x50, 32))
2542                   return -1;
2543                 break;
2544
2545               case 0x3c: /* PCC-Compute-XTS-Parameter-Using-Encrypted-AES-256 */
2546                 if (record_full_arch_list_add_mem (oaddr + 0x60, 32))
2547                   return -1;
2548                 break;
2549
2550               default:
2551                 fprintf_unfiltered (gdb_stdlog, "Warning: Unknown PCC function %02x at %s.\n",
2552                                     (int)tmp, paddress (gdbarch, addr));
2553                 return -1;
2554             }
2555           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
2556             return -1;
2557           break;
2558
2559         case 0xb92d: /* KMCTR - cipher message with counter [partial] */
2560           regcache_raw_read_unsigned (regcache, S390_R1_REGNUM, &tmp);
2561           oaddr = s390_record_address_mask (gdbarch, regcache, tmp);
2562           regcache_raw_read_unsigned (regcache, S390_R0_REGNUM, &tmp);
2563           tmp &= 0x7f;
2564           switch (tmp)
2565             {
2566               case 0x00: /* KMCTR-Query */
2567                 if (record_full_arch_list_add_mem (oaddr, 16))
2568                   return -1;
2569                 break;
2570
2571               case 0x01: /* KMCTR-DEA */
2572               case 0x02: /* KMCTR-TDEA-128 */
2573               case 0x03: /* KMCTR-TDEA-192 */
2574               case 0x09: /* KMCTR-Encrypted-DEA */
2575               case 0x0a: /* KMCTR-Encrypted-TDEA-128 */
2576               case 0x0b: /* KMCTR-Encrypted-TDEA-192 */
2577               case 0x12: /* KMCTR-AES-128 */
2578               case 0x13: /* KMCTR-AES-192 */
2579               case 0x14: /* KMCTR-AES-256 */
2580               case 0x1a: /* KMCTR-Encrypted-AES-128 */
2581               case 0x1b: /* KMCTR-Encrypted-AES-192 */
2582               case 0x1c: /* KMCTR-Encrypted-AES-256 */
2583                 break;
2584
2585               default:
2586                 fprintf_unfiltered (gdb_stdlog, "Warning: Unknown KMCTR function %02x at %s.\n",
2587                                     (int)tmp, paddress (gdbarch, addr));
2588                 return -1;
2589             }
2590           if (tmp != 0)
2591             {
2592               regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + inib[6], &tmp);
2593               oaddr2 = s390_record_address_mask (gdbarch, regcache, tmp);
2594               regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + (inib[7] | 1), &tmp);
2595               if (record_full_arch_list_add_mem (oaddr2, tmp))
2596                 return -1;
2597               if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
2598                 return -1;
2599               if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[7]))
2600                 return -1;
2601               if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[7] | 1)))
2602                 return -1;
2603               if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[4]))
2604                 return -1;
2605             }
2606           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
2607             return -1;
2608           break;
2609
2610         case 0xb92e: /* KM - cipher message [partial] */
2611           regcache_raw_read_unsigned (regcache, S390_R1_REGNUM, &tmp);
2612           oaddr = s390_record_address_mask (gdbarch, regcache, tmp);
2613           regcache_raw_read_unsigned (regcache, S390_R0_REGNUM, &tmp);
2614           tmp &= 0x7f;
2615           switch (tmp)
2616             {
2617               case 0x00: /* KM-Query */
2618                 if (record_full_arch_list_add_mem (oaddr, 16))
2619                   return -1;
2620                 break;
2621
2622               case 0x01: /* KM-DEA */
2623               case 0x02: /* KM-TDEA-128 */
2624               case 0x03: /* KM-TDEA-192 */
2625               case 0x09: /* KM-Encrypted-DEA */
2626               case 0x0a: /* KM-Encrypted-TDEA-128 */
2627               case 0x0b: /* KM-Encrypted-TDEA-192 */
2628               case 0x12: /* KM-AES-128 */
2629               case 0x13: /* KM-AES-192 */
2630               case 0x14: /* KM-AES-256 */
2631               case 0x1a: /* KM-Encrypted-AES-128 */
2632               case 0x1b: /* KM-Encrypted-AES-192 */
2633               case 0x1c: /* KM-Encrypted-AES-256 */
2634                 break;
2635
2636               case 0x32: /* KM-XTS-AES-128 */
2637                 if (record_full_arch_list_add_mem (oaddr + 0x10, 16))
2638                   return -1;
2639                 break;
2640
2641               case 0x34: /* KM-XTS-AES-256 */
2642                 if (record_full_arch_list_add_mem (oaddr + 0x20, 16))
2643                   return -1;
2644                 break;
2645
2646               case 0x3a: /* KM-XTS-Encrypted-AES-128 */
2647                 if (record_full_arch_list_add_mem (oaddr + 0x30, 16))
2648                   return -1;
2649                 break;
2650
2651               case 0x3c: /* KM-XTS-Encrypted-AES-256 */
2652                 if (record_full_arch_list_add_mem (oaddr + 0x40, 16))
2653                   return -1;
2654                 break;
2655
2656               default:
2657                 fprintf_unfiltered (gdb_stdlog, "Warning: Unknown KM function %02x at %s.\n",
2658                                     (int)tmp, paddress (gdbarch, addr));
2659                 return -1;
2660             }
2661           if (tmp != 0)
2662             {
2663               regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + inib[6], &tmp);
2664               oaddr2 = s390_record_address_mask (gdbarch, regcache, tmp);
2665               regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + (inib[7] | 1), &tmp);
2666               if (record_full_arch_list_add_mem (oaddr2, tmp))
2667                 return -1;
2668               if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
2669                 return -1;
2670               if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[7]))
2671                 return -1;
2672               if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[7] | 1)))
2673                 return -1;
2674             }
2675           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
2676             return -1;
2677           break;
2678
2679         /* 0xb932-0xb93b undefined */
2680
2681         case 0xb93c: /* PPNO - perform pseudorandom number operation [partial] */
2682           regcache_raw_read_unsigned (regcache, S390_R1_REGNUM, &tmp);
2683           oaddr = s390_record_address_mask (gdbarch, regcache, tmp);
2684           regcache_raw_read_unsigned (regcache, S390_R0_REGNUM, &tmp);
2685           tmp &= 0xff;
2686           switch (tmp)
2687             {
2688               case 0x00: /* PPNO-Query */
2689               case 0x80: /* PPNO-Query */
2690                 if (record_full_arch_list_add_mem (oaddr, 16))
2691                   return -1;
2692                 break;
2693
2694               case 0x03: /* PPNO-SHA-512-DRNG - generate */
2695                 if (record_full_arch_list_add_mem (oaddr, 240))
2696                   return -1;
2697                 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + inib[6], &tmp);
2698                 oaddr2 = s390_record_address_mask (gdbarch, regcache, tmp);
2699                 regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + (inib[6] | 1), &tmp);
2700                 if (record_full_arch_list_add_mem (oaddr2, tmp))
2701                   return -1;
2702                 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
2703                   return -1;
2704                 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[6] | 1)))
2705                   return -1;
2706                 break;
2707
2708               case 0x83: /* PPNO-SHA-512-DRNG - seed */
2709                 if (record_full_arch_list_add_mem (oaddr, 240))
2710                   return -1;
2711                 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[7]))
2712                   return -1;
2713                 if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[7] | 1)))
2714                   return -1;
2715                 break;
2716
2717               default:
2718                 fprintf_unfiltered (gdb_stdlog, "Warning: Unknown PPNO function %02x at %s.\n",
2719                                     (int)tmp, paddress (gdbarch, addr));
2720                 return -1;
2721             }
2722           /* DXC may be written */
2723           if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
2724             return -1;
2725           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
2726             return -1;
2727           break;
2728
2729         /* 0xb93d undefined */
2730
2731         case 0xb93e: /* KIMD - compute intermediate message digest [partial] */
2732         case 0xb93f: /* KLMD - compute last message digest [partial] */
2733           regcache_raw_read_unsigned (regcache, S390_R1_REGNUM, &tmp);
2734           oaddr = s390_record_address_mask (gdbarch, regcache, tmp);
2735           regcache_raw_read_unsigned (regcache, S390_R0_REGNUM, &tmp);
2736           tmp &= 0xff;
2737           switch (tmp)
2738             {
2739               case 0x00: /* K*MD-Query */
2740                 if (record_full_arch_list_add_mem (oaddr, 16))
2741                   return -1;
2742                 break;
2743
2744               case 0x01: /* K*MD-SHA-1 */
2745                 if (record_full_arch_list_add_mem (oaddr, 20))
2746                   return -1;
2747                 break;
2748
2749               case 0x02: /* K*MD-SHA-256 */
2750                 if (record_full_arch_list_add_mem (oaddr, 32))
2751                   return -1;
2752                 break;
2753
2754               case 0x03: /* K*MD-SHA-512 */
2755                 if (record_full_arch_list_add_mem (oaddr, 64))
2756                   return -1;
2757                 break;
2758
2759               case 0x41: /* KIMD-GHASH */
2760                 /* Only valid for KIMD.  */
2761                 if (insn[0] == 0xb93e)
2762                   {
2763                     if (record_full_arch_list_add_mem (oaddr, 16))
2764                       return -1;
2765                     break;
2766                   }
2767                 /* For KLMD, fallthru.  */
2768               default:
2769                 fprintf_unfiltered (gdb_stdlog, "Warning: Unknown KMAC function %02x at %s.\n",
2770                                     (int)tmp, paddress (gdbarch, addr));
2771                 return -1;
2772             }
2773           if (tmp != 0)
2774             {
2775               if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[7]))
2776                 return -1;
2777               if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[7] | 1)))
2778                 return -1;
2779             }
2780           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
2781             return -1;
2782           break;
2783
2784         /* 0xb940 undefined */
2785         /* 0xb944-0xb945 undefined */
2786         /* 0xb947-0xb948 undefined */
2787         /* 0xb94c-0xb950 undefined */
2788         /* 0xb954-0xb958 undefined */
2789         /* 0xb95c-0xb95f undefined */
2790         /* 0xb962-0xb971 undefined */
2791         /* 0xb974-0xb97f undefined */
2792
2793         case 0xb983: /* FLOGR - find leftmost one */
2794           /* 64-bit gpr pair destination + flags */
2795           if (s390_record_gpr_g (gdbarch, regcache, inib[6]))
2796             return -1;
2797           if (s390_record_gpr_g (gdbarch, regcache, inib[6] | 1))
2798             return -1;
2799           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
2800             return -1;
2801           break;
2802
2803         /* 0xb98a privileged */
2804         /* 0xb98b-0xb98c undefined */
2805
2806         case 0xb98d: /* EPSW - extract psw */
2807           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
2808             return -1;
2809           if (inib[7])
2810             if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[7]))
2811               return -1;
2812           break;
2813
2814         /* 0xb98e-0xb98f privileged */
2815
2816         case 0xb990: /* TRTT - translate two to two [partial] */
2817         case 0xb991: /* TRTO - translate two to one [partial] */
2818         case 0xb992: /* TROT - translate one to two [partial] */
2819         case 0xb993: /* TROO - translate one to one [partial] */
2820           regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + inib[6], &tmp);
2821           oaddr = s390_record_address_mask (gdbarch, regcache, tmp);
2822           regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + (inib[6] | 1), &tmp);
2823           /* tmp is source length, we want destination length.  Adjust.  */
2824           if (insn[0] == 0xb991)
2825             tmp >>= 1;
2826           if (insn[0] == 0xb992)
2827             tmp <<= 1;
2828           if (record_full_arch_list_add_mem (oaddr, tmp))
2829             return -1;
2830           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
2831             return -1;
2832           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[6] | 1)))
2833             return -1;
2834           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[7]))
2835             return -1;
2836           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
2837             return -1;
2838           break;
2839
2840         case 0xb996: /* MLR - multiply logical */
2841         case 0xb997: /* DLR - divide logical */
2842           /* 32-bit gpr pair destination  */
2843           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
2844             return -1;
2845           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[6] | 1)))
2846             return -1;
2847           break;
2848
2849         /* 0xb99a-0xb9af unsupported, privileged, or undefined */
2850         /* 0xb9b4-0xb9bc undefined */
2851
2852         case 0xb9bd: /* TRTRE - translate and test reverse extended [partial] */
2853         case 0xb9bf: /* TRTE - translate and test extended [partial] */
2854           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[6]))
2855             return -1;
2856           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[6] | 1)))
2857             return -1;
2858           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[7]))
2859             return -1;
2860           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
2861             return -1;
2862           break;
2863
2864         /* 0xb9c0-0xb9c7 undefined */
2865
2866         case 0xb9c8: /* AHHHR - add high */
2867         case 0xb9c9: /* SHHHR - subtract high */
2868         case 0xb9ca: /* ALHHHR - add logical high */
2869         case 0xb9cb: /* SLHHHR - subtract logical high */
2870         case 0xb9d8: /* AHHLR - add high */
2871         case 0xb9d9: /* SHHLR - subtract high */
2872         case 0xb9da: /* ALHHLR - add logical high */
2873         case 0xb9db: /* SLHHLR - subtract logical high */
2874           /* 32-bit high gpr destination + flags */
2875           if (s390_record_gpr_h (gdbarch, regcache, inib[6]))
2876             return -1;
2877           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
2878             return -1;
2879           break;
2880
2881         /* 0xb9cc undefined */
2882         /* 0xb9ce undefined */
2883         /* 0xb9d0-0xb9d7 undefined */
2884         /* 0xb9dc undefined */
2885         /* 0xb9de undefined */
2886
2887         case 0xb9e0: /* LOCFHR - load high on condition */
2888           /* 32-bit high gpr destination */
2889           if (s390_record_gpr_h (gdbarch, regcache, inib[6]))
2890             return -1;
2891           break;
2892
2893         /* 0xb9e3 undefined */
2894         /* 0xb9e5 undefined */
2895         /* 0xb9ee-0xb9f1 undefined */
2896         /* 0xb9f3 undefined */
2897         /* 0xb9f5 undefined */
2898         /* 0xb9fc undefined */
2899         /* 0xb9fe -0xb9ff undefined */
2900
2901         default:
2902           goto UNKNOWN_OP;
2903         }
2904       break;
2905
2906     /* 0xb4-0xb5 undefined */
2907     /* 0xb6 privileged: STCTL - store control */
2908     /* 0xb7 privileged: LCTL - load control */
2909     /* 0xb8 undefined */
2910
2911     case 0xba: /* CS - compare and swap */
2912       oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
2913       if (record_full_arch_list_add_mem (oaddr, 4))
2914         return -1;
2915       if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
2916         return -1;
2917       if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
2918         return -1;
2919       break;
2920
2921     case 0xbb: /* CDS - compare double and swap */
2922       oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
2923       if (record_full_arch_list_add_mem (oaddr, 8))
2924         return -1;
2925       if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
2926         return -1;
2927       if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[2] | 1)))
2928         return -1;
2929       if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
2930         return -1;
2931       break;
2932
2933     /* 0xbc undefined */
2934
2935     case 0xbe: /* STCM - store characters under mask */
2936       oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
2937       if (record_full_arch_list_add_mem (oaddr, s390_popcnt (inib[3])))
2938         return -1;
2939       break;
2940
2941     case 0xc0:
2942     case 0xc2:
2943     case 0xc4:
2944     case 0xc6:
2945     case 0xcc:
2946       /* RIL-format instruction */
2947       switch (ibyte[0] << 4 | inib[3])
2948         {
2949         case 0xc00: /* LARL - load address relative long */
2950         case 0xc05: /* BRASL - branch relative and save long */
2951         case 0xc09: /* IILF - insert immediate */
2952         case 0xc21: /* MSFI - multiply single immediate */
2953         case 0xc42: /* LLHRL - load logical halfword relative long */
2954         case 0xc45: /* LHRL - load halfword relative long */
2955         case 0xc4d: /* LRL - load relative long */
2956           /* 32-bit or native gpr destination */
2957           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
2958             return -1;
2959           break;
2960
2961         case 0xc01: /* LGFI - load immediate */
2962         case 0xc0e: /* LLIHF - load logical immediate */
2963         case 0xc0f: /* LLILF - load logical immediate */
2964         case 0xc20: /* MSGFI - multiply single immediate */
2965         case 0xc44: /* LGHRL - load halfword relative long */
2966         case 0xc46: /* LLGHRL - load logical halfword relative long */
2967         case 0xc48: /* LGRL - load relative long */
2968         case 0xc4c: /* LGFRL - load relative long */
2969         case 0xc4e: /* LLGFRL - load logical relative long */
2970           /* 64-bit gpr destination */
2971           if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
2972             return -1;
2973           break;
2974
2975         /* 0xc02-0xc03 undefined */
2976
2977         case 0xc04: /* BRCL - branch relative on condition long */
2978         case 0xc62: /* PFDRL - prefetch data relative long */
2979           break;
2980
2981         case 0xc06: /* XIHF - xor immediate */
2982         case 0xc0a: /* NIHF - and immediate */
2983         case 0xc0c: /* OIHF - or immediate */
2984         case 0xcc8: /* AIH - add immediate high */
2985         case 0xcca: /* ALSIH - add logical with signed immediate high */
2986           /* 32-bit high gpr destination + flags */
2987           if (s390_record_gpr_h (gdbarch, regcache, inib[2]))
2988             return -1;
2989           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
2990             return -1;
2991           break;
2992
2993         case 0xc07: /* XILF - xor immediate */
2994         case 0xc0b: /* NILF - and immediate */
2995         case 0xc0d: /* OILF - or immediate */
2996         case 0xc25: /* SLFI - subtract logical immediate */
2997         case 0xc29: /* AFI - add immediate */
2998         case 0xc2b: /* ALFI - add logical immediate */
2999           /* 32-bit gpr destination + flags */
3000           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
3001             return -1;
3002           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3003             return -1;
3004           break;
3005
3006         case 0xc08: /* IIHF - insert immediate */
3007         case 0xcc6: /* BRCTH - branch relative on count high */
3008         case 0xccb: /* ALSIHN - add logical with signed immediate high */
3009           /* 32-bit high gpr destination */
3010           if (s390_record_gpr_h (gdbarch, regcache, inib[2]))
3011             return -1;
3012           break;
3013
3014         /* 0xc22-0xc23 undefined */
3015
3016         case 0xc24: /* SLGFI - subtract logical immediate */
3017         case 0xc28: /* AGFI - add immediate */
3018         case 0xc2a: /* ALGFI - add logical immediate */
3019           /* 64-bit gpr destination + flags */
3020           if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
3021             return -1;
3022           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3023             return -1;
3024           break;
3025
3026         /* 0xc26-0xc27 undefined */
3027
3028         case 0xc2c: /* CGFI - compare immediate */
3029         case 0xc2d: /* CFI - compare immediate */
3030         case 0xc2e: /* CLGFI - compare logical immediate */
3031         case 0xc2f: /* CLFI - compare logical immediate */
3032         case 0xc64: /* CGHRL - compare halfword relative long */
3033         case 0xc65: /* CHRL - compare halfword relative long */
3034         case 0xc66: /* CLGHRL - compare logical halfword relative long */
3035         case 0xc67: /* CLHRL - compare logical halfword relative long */
3036         case 0xc68: /* CGRL - compare relative long */
3037         case 0xc6a: /* CLGRL - compare logical relative long */
3038         case 0xc6c: /* CGFRL - compare relative long */
3039         case 0xc6d: /* CRL - compare relative long */
3040         case 0xc6e: /* CLGFRL - compare logical relative long */
3041         case 0xc6f: /* CLRL - compare logical relative long */
3042         case 0xccd: /* CIH - compare immediate high */
3043         case 0xccf: /* CLIH - compare logical immediate high */
3044           /* flags only */
3045           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3046             return -1;
3047           break;
3048
3049         /* 0xc40-0xc41 undefined */
3050         /* 0xc43 undefined */
3051
3052         case 0xc47: /* STHRL - store halfword relative long */
3053           oaddr = s390_record_calc_rl (gdbarch, regcache, addr, insn[1], insn[2]);
3054           if (record_full_arch_list_add_mem (oaddr, 2))
3055             return -1;
3056           break;
3057
3058         /* 0xc49-0xc4a undefined */
3059
3060         case 0xc4b: /* STGRL - store relative long */
3061           oaddr = s390_record_calc_rl (gdbarch, regcache, addr, insn[1], insn[2]);
3062           if (record_full_arch_list_add_mem (oaddr, 8))
3063             return -1;
3064           break;
3065
3066         case 0xc4f: /* STRL - store relative long */
3067           oaddr = s390_record_calc_rl (gdbarch, regcache, addr, insn[1], insn[2]);
3068           if (record_full_arch_list_add_mem (oaddr, 4))
3069             return -1;
3070           break;
3071
3072         case 0xc60: /* EXRL - execute relative long */
3073           if (ex != -1)
3074             {
3075               fprintf_unfiltered (gdb_stdlog, "Warning: Double execute at %s.\n",
3076                                   paddress (gdbarch, addr));
3077               return -1;
3078             }
3079           addr = s390_record_calc_rl (gdbarch, regcache, addr, insn[1], insn[2]);
3080           if (inib[2])
3081             {
3082               regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + inib[2], &tmp);
3083               ex = tmp & 0xff;
3084             }
3085           else
3086             {
3087               ex = 0;
3088             }
3089           goto ex;
3090
3091         /* 0xc61 undefined */
3092         /* 0xc63 undefined */
3093         /* 0xc69 undefined */
3094         /* 0xc6b undefined */
3095         /* 0xcc0-0xcc5 undefined */
3096         /* 0xcc7 undefined */
3097         /* 0xcc9 undefined */
3098         /* 0xccc undefined */
3099         /* 0xcce undefined */
3100
3101         default:
3102           goto UNKNOWN_OP;
3103         }
3104       break;
3105
3106     /* 0xc1 undefined */
3107     /* 0xc3 undefined */
3108
3109     case 0xc5: /* BPRP - branch prediction relative preload */
3110     case 0xc7: /* BPP - branch prediction preload */
3111       /* no visible effect */
3112       break;
3113
3114     case 0xc8:
3115       /* SSF-format instruction */
3116       switch (ibyte[0] << 4 | inib[3])
3117         {
3118         /* 0xc80 unsupported */
3119
3120         case 0xc81: /* ECTG - extract cpu time */
3121           if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
3122             return -1;
3123           if (s390_record_gpr_g (gdbarch, regcache, 0))
3124             return -1;
3125           if (s390_record_gpr_g (gdbarch, regcache, 1))
3126             return -1;
3127           break;
3128
3129         case 0xc82: /* CSST - compare and swap and store */
3130           {
3131             uint8_t fc, sc;
3132             regcache_raw_read_unsigned (regcache, S390_R0_REGNUM, &tmp);
3133             fc = tmp & 0xff;
3134             sc = tmp >> 8 & 0xff;
3135
3136             /* First and third operands.  */
3137             oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
3138             switch (fc)
3139               {
3140                 case 0x00: /* 32-bit */
3141                   if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
3142                     return -1;
3143                   if (record_full_arch_list_add_mem (oaddr, 4))
3144                     return -1;
3145                   break;
3146
3147                 case 0x01: /* 64-bit */
3148                   if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
3149                     return -1;
3150                   if (record_full_arch_list_add_mem (oaddr, 8))
3151                     return -1;
3152                   break;
3153
3154                 case 0x02: /* 128-bit */
3155                   if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
3156                     return -1;
3157                   if (s390_record_gpr_g (gdbarch, regcache, inib[2] | 1))
3158                     return -1;
3159                   if (record_full_arch_list_add_mem (oaddr, 16))
3160                     return -1;
3161                   break;
3162
3163                 default:
3164                   fprintf_unfiltered (gdb_stdlog, "Warning: Unknown CSST FC %02x at %s.\n",
3165                                       fc, paddress (gdbarch, addr));
3166                   return -1;
3167               }
3168
3169             /* Second operand.  */
3170             oaddr2 = s390_record_calc_disp (gdbarch, regcache, 0, insn[2], 0);
3171             if (sc > 4)
3172               {
3173                 fprintf_unfiltered (gdb_stdlog, "Warning: Unknown CSST FC %02x at %s.\n",
3174                                     sc, paddress (gdbarch, addr));
3175                 return -1;
3176               }
3177
3178             if (record_full_arch_list_add_mem (oaddr2, 1 << sc))
3179               return -1;
3180
3181             /* Flags.  */
3182             if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3183               return -1;
3184           }
3185           break;
3186
3187         /* 0xc83 undefined */
3188
3189         case 0xc84: /* LPD - load pair disjoint */
3190           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
3191             return -1;
3192           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[2] | 1)))
3193             return -1;
3194           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3195             return -1;
3196           break;
3197
3198         case 0xc85: /* LPDG - load pair disjoint */
3199           if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
3200             return -1;
3201           if (s390_record_gpr_g (gdbarch, regcache, inib[2] | 1))
3202             return -1;
3203           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3204             return -1;
3205           break;
3206
3207         /* 0xc86-0xc8f undefined */
3208
3209         default:
3210           goto UNKNOWN_OP;
3211         }
3212       break;
3213
3214     /* 0xc9-0xcb undefined */
3215     /* 0xcd-0xcf undefined */
3216
3217     case 0xd0: /* TRTR - translate and test reversed */
3218     case 0xdd: /* TRT - translate and test */
3219       if (record_full_arch_list_add_reg (regcache, S390_R1_REGNUM))
3220         return -1;
3221       if (record_full_arch_list_add_reg (regcache, S390_R2_REGNUM))
3222         return -1;
3223       if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3224         return -1;
3225       break;
3226
3227     case 0xd1: /* MVN - move numbers */
3228     case 0xd2: /* MVC - move */
3229     case 0xd3: /* MVZ - move zones */
3230     case 0xdc: /* TR - translate */
3231     case 0xe8: /* MVCIN - move inverse */
3232       oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
3233       if (record_full_arch_list_add_mem (oaddr, ibyte[1] + 1))
3234         return -1;
3235       break;
3236
3237     case 0xd4: /* NC - and */
3238     case 0xd6: /* OC - or*/
3239     case 0xd7: /* XC - xor */
3240     case 0xe2: /* UNPKU - unpack unicode */
3241     case 0xea: /* UNPKA - unpack ASCII */
3242       oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
3243       if (record_full_arch_list_add_mem (oaddr, ibyte[1] + 1))
3244         return -1;
3245       if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3246         return -1;
3247       break;
3248
3249     case 0xde: /* ED - edit */
3250       oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
3251       if (record_full_arch_list_add_mem (oaddr, ibyte[1] + 1))
3252         return -1;
3253       if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3254         return -1;
3255       /* DXC may be written */
3256       if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
3257         return -1;
3258       break;
3259
3260     case 0xdf: /* EDMK - edit and mark */
3261       oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
3262       if (record_full_arch_list_add_mem (oaddr, ibyte[1] + 1))
3263         return -1;
3264       if (record_full_arch_list_add_reg (regcache, S390_R1_REGNUM))
3265         return -1;
3266       if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3267         return -1;
3268       /* DXC may be written */
3269       if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
3270         return -1;
3271       break;
3272
3273     /* 0xd8 undefined */
3274     /* 0xd9 unsupported: MVCK - move with key */
3275     /* 0xda unsupported: MVCP - move to primary */
3276     /* 0xdb unsupported: MVCS - move to secondary */
3277     /* 0xe0 undefined */
3278
3279     case 0xe1: /* PKU - pack unicode */
3280     case 0xe9: /* PKA - pack ASCII */
3281       oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
3282       if (record_full_arch_list_add_mem (oaddr, 16))
3283         return -1;
3284       break;
3285
3286     case 0xe3:
3287     case 0xe6:
3288     case 0xe7:
3289     case 0xeb:
3290     case 0xed:
3291       /* RXY/RXE/RXF/RSL/RSY/SIY/V*-format instruction */
3292       switch (ibyte[0] << 8 | ibyte[5])
3293         {
3294         /* 0xe300-0xe301 undefined */
3295
3296         case 0xe302: /* LTG - load and test */
3297         case 0xe308: /* AG - add */
3298         case 0xe309: /* SG - subtract */
3299         case 0xe30a: /* ALG - add logical */
3300         case 0xe30b: /* SLG - subtract logical */
3301         case 0xe318: /* AGF - add */
3302         case 0xe319: /* SGF - subtract */
3303         case 0xe31a: /* ALGF - add logical */
3304         case 0xe31b: /* SLGF - subtract logical */
3305         case 0xe332: /* LTGF - load and test */
3306         case 0xe380: /* NG - and */
3307         case 0xe381: /* OG - or */
3308         case 0xe382: /* XG - xor */
3309         case 0xe388: /* ALCG - add logical with carry */
3310         case 0xe389: /* SLBG - subtract logical with borrow */
3311         case 0xeb0a: /* SRAG - shift right single */
3312         case 0xeb0b: /* SLAG - shift left single */
3313           /* 64-bit gpr destination + flags */
3314           if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
3315             return -1;
3316           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3317             return -1;
3318           break;
3319
3320         /* 0xe303 privileged */
3321
3322         case 0xe304: /* LG - load */
3323         case 0xe30c: /* MSG - multiply single */
3324         case 0xe30f: /* LRVG - load reversed */
3325         case 0xe314: /* LGF - load */
3326         case 0xe315: /* LGH - load halfword */
3327         case 0xe316: /* LLGF - load logical */
3328         case 0xe317: /* LLGT - load logical thirty one bits */
3329         case 0xe31c: /* MSGF - multiply single */
3330         case 0xe32a: /* LZRG - load and zero rightmost byte */
3331         case 0xe33a: /* LLZRGF - load logical and zero rightmost byte */
3332         case 0xe33c: /* MGH - multiply halfword 64x16mem -> 64 */
3333         case 0xe346: /* BCTG - branch on count */
3334         case 0xe377: /* LGB - load byte */
3335         case 0xe390: /* LLGC - load logical character */
3336         case 0xe391: /* LLGH - load logical halfword */
3337         case 0xeb0c: /* SRLG - shift right single logical */
3338         case 0xeb0d: /* SLLG - shift left single logical */
3339         case 0xeb1c: /* RLLG - rotate left single logical */
3340         case 0xeb44: /* BXHG - branch on index high */
3341         case 0xeb45: /* BXLEG - branch on index low or equal */
3342         case 0xeb4c: /* ECAG - extract cpu attribute */
3343         case 0xebe2: /* LOCG - load on condition */
3344           /* 64-bit gpr destination */
3345           if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
3346             return -1;
3347           break;
3348
3349         /* 0xe305 undefined */
3350
3351         case 0xe306: /* CVBY - convert to binary */
3352           /* 32-bit or native gpr destination + FPC (DXC write) */
3353           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
3354             return -1;
3355           if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
3356             return -1;
3357           break;
3358
3359         /* 0xe307 undefined */
3360
3361         case 0xe30d: /* DSG - divide single */
3362         case 0xe31d: /* DSGF - divide single */
3363         case 0xe384: /* MG - multiply 64x64mem -> 128 */
3364         case 0xe386: /* MLG - multiply logical */
3365         case 0xe387: /* DLG - divide logical */
3366         case 0xe38f: /* LPQ - load pair from quadword */
3367           /* 64-bit gpr pair destination  */
3368           if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
3369             return -1;
3370           if (s390_record_gpr_g (gdbarch, regcache, inib[2] | 1))
3371             return -1;
3372           break;
3373
3374         case 0xe30e: /* CVBG - convert to binary */
3375           /* 64-bit gpr destination + FPC (DXC write) */
3376           if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
3377             return -1;
3378           if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
3379             return -1;
3380           break;
3381
3382         /* 0xe310-0xe311 undefined */
3383
3384         case 0xe312: /* LT - load and test */
3385         case 0xe338: /* AGH - add halfword to 64 bit value */
3386         case 0xe339: /* SGH - subtract halfword from 64 bit value */
3387         case 0xe353: /* MSC - multiply single 32x32mem -> 32 */
3388         case 0xe354: /* NY - and */
3389         case 0xe356: /* OY - or */
3390         case 0xe357: /* XY - xor */
3391         case 0xe35a: /* AY - add */
3392         case 0xe35b: /* SY - subtract */
3393         case 0xe35e: /* ALY - add logical */
3394         case 0xe35f: /* SLY - subtract logical */
3395         case 0xe37a: /* AHY - add halfword */
3396         case 0xe37b: /* SHY - subtract halfword */
3397         case 0xe383: /* MSGC - multiply single 64x64mem -> 64 */
3398         case 0xe398: /* ALC - add logical with carry */
3399         case 0xe399: /* SLB - subtract logical with borrow */
3400         case 0xe727: /* LCBB - load count to block bounduary */
3401         case 0xeb81: /* ICMY - insert characters under mask */
3402         case 0xebdc: /* SRAK - shift left single */
3403         case 0xebdd: /* SLAK - shift left single */
3404           /* 32/64-bit gpr destination + flags */
3405           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
3406             return -1;
3407           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3408             return -1;
3409           break;
3410
3411         /* 0xe313 privileged */
3412
3413         case 0xe31e: /* LRV - load reversed */
3414         case 0xe31f: /* LRVH - load reversed */
3415         case 0xe33b: /* LZRF - load and zero rightmost byte */
3416         case 0xe351: /* MSY - multiply single */
3417         case 0xe358: /* LY - load */
3418         case 0xe371: /* LAY - load address */
3419         case 0xe373: /* ICY - insert character */
3420         case 0xe376: /* LB - load byte */
3421         case 0xe378: /* LHY - load */
3422         case 0xe37c: /* MHY - multiply halfword */
3423         case 0xe394: /* LLC - load logical character */
3424         case 0xe395: /* LLH - load logical halfword */
3425         case 0xeb1d: /* RLL - rotate left single logical */
3426         case 0xebde: /* SRLK - shift left single logical */
3427         case 0xebdf: /* SLLK - shift left single logical */
3428         case 0xebf2: /* LOC - load on condition */
3429           /* 32-bit or native gpr destination */
3430           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
3431             return -1;
3432           break;
3433
3434         case 0xe320: /* CG - compare */
3435         case 0xe321: /* CLG - compare logical */
3436         case 0xe330: /* CGF - compare */
3437         case 0xe331: /* CLGF - compare logical */
3438         case 0xe334: /* CGH - compare halfword */
3439         case 0xe355: /* CLY - compare logical */
3440         case 0xe359: /* CY - compare */
3441         case 0xe379: /* CHY - compare halfword */
3442         case 0xe3cd: /* CHF - compare high */
3443         case 0xe3cf: /* CLHF - compare logical high */
3444         case 0xeb20: /* CLMH - compare logical under mask high */
3445         case 0xeb21: /* CLMY - compare logical under mask */
3446         case 0xeb51: /* TMY - test under mask */
3447         case 0xeb55: /* CLIY - compare logical */
3448         case 0xebc0: /* TP - test decimal */
3449         case 0xed10: /* TCEB - test data class */
3450         case 0xed11: /* TCDB - test data class */
3451         case 0xed12: /* TCXB - test data class */
3452         case 0xed50: /* TDCET - test data class */
3453         case 0xed51: /* TDGET - test data group */
3454         case 0xed54: /* TDCDT - test data class */
3455         case 0xed55: /* TDGDT - test data group */
3456         case 0xed58: /* TDCXT - test data class */
3457         case 0xed59: /* TDGXT - test data group */
3458           /* flags only */
3459           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3460             return -1;
3461           break;
3462
3463         /* 0xe322-0xe323 undefined */
3464
3465         case 0xe324: /* STG - store */
3466         case 0xe325: /* NTSTG - nontransactional store */
3467         case 0xe326: /* CVDY - convert to decimal */
3468         case 0xe32f: /* STRVG - store reversed */
3469         case 0xebe3: /* STOCG - store on condition */
3470         case 0xed67: /* STDY - store */
3471           oaddr = s390_record_calc_disp (gdbarch, regcache, inib[3], insn[1], ibyte[4]);
3472           if (record_full_arch_list_add_mem (oaddr, 8))
3473             return -1;
3474           break;
3475
3476         /* 0xe327-0xe329 undefined */
3477         /* 0xe32b-0xe32d undefined */
3478
3479         case 0xe32e: /* CVDG - convert to decimal */
3480         case 0xe38e: /* STPQ - store pair to quadword */
3481           oaddr = s390_record_calc_disp (gdbarch, regcache, inib[3], insn[1], ibyte[4]);
3482           if (record_full_arch_list_add_mem (oaddr, 16))
3483             return -1;
3484           break;
3485
3486         /* 0xe333 undefined */
3487         /* 0xe335 undefined */
3488
3489         case 0xe336: /* PFD - prefetch data */
3490           break;
3491
3492         /* 0xe337 undefined */
3493         /* 0xe33c-0xe33d undefined */
3494
3495         case 0xe33e: /* STRV - store reversed */
3496         case 0xe350: /* STY - store */
3497         case 0xe3cb: /* STFH - store high */
3498         case 0xebe1: /* STOCFH - store high on condition */
3499         case 0xebf3: /* STOC - store on condition */
3500         case 0xed66: /* STEY - store */
3501           oaddr = s390_record_calc_disp (gdbarch, regcache, inib[3], insn[1], ibyte[4]);
3502           if (record_full_arch_list_add_mem (oaddr, 4))
3503             return -1;
3504           break;
3505
3506         case 0xe33f: /* STRVH - store reversed */
3507         case 0xe370: /* STHY - store halfword */
3508         case 0xe3c7: /* STHH - store halfword high */
3509           oaddr = s390_record_calc_disp (gdbarch, regcache, inib[3], insn[1], ibyte[4]);
3510           if (record_full_arch_list_add_mem (oaddr, 2))
3511             return -1;
3512           break;
3513
3514         /* 0xe340-0xe345 undefined */
3515
3516         case 0xe347: /* BIC - branch indirect on condition */
3517           break;
3518
3519         /* 0xe348-0xe34f undefined */
3520         /* 0xe352 undefined */
3521
3522         case 0xe35c: /* MFY - multiply */
3523         case 0xe396: /* ML - multiply logical */
3524         case 0xe397: /* DL - divide logical */
3525           /* 32-bit gpr pair destination */
3526           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
3527             return -1;
3528           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[2] | 1)))
3529             return -1;
3530           break;
3531
3532         /* 0xe35d undefined */
3533         /* 0xe360-0xe36f undefined */
3534
3535         case 0xe372: /* STCY - store character */
3536         case 0xe3c3: /* STCH - store character high */
3537           oaddr = s390_record_calc_disp (gdbarch, regcache, inib[3], insn[1], ibyte[4]);
3538           if (record_full_arch_list_add_mem (oaddr, 1))
3539             return -1;
3540           break;
3541
3542         /* 0xe374 undefined */
3543
3544         case 0xe375: /* LAEY - load address extended */
3545           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
3546             return -1;
3547           if (record_full_arch_list_add_reg (regcache, S390_A0_REGNUM + inib[2]))
3548             return -1;
3549           break;
3550
3551         /* 0xe37d-0xe37f undefined */
3552
3553         case 0xe385: /* LGAT - load and trap */
3554         case 0xe39c: /* LLGTAT - load logical thirty one bits and trap */
3555         case 0xe39d: /* LLGFAT - load logical and trap */
3556         case 0xe650: /* VCVB - vector convert to binary 32 bit*/
3557         case 0xe652: /* VCVBG - vector convert to binary 64 bit*/
3558         case 0xe721: /* VLGV - vector load gr from vr element */
3559           /* 64-bit gpr destination + fpc for possible DXC write */
3560           if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
3561             return -1;
3562           if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
3563             return -1;
3564           break;
3565
3566         /* 0xe38a-0xe38d undefined */
3567         /* 0xe392-0xe393 undefined */
3568         /* 0xe39a-0xe39b undefined */
3569         /* 0xe39e undefined */
3570
3571         case 0xe39f: /* LAT - load and trap */
3572           /* 32-bit gpr destination + fpc for possible DXC write */
3573           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
3574             return -1;
3575           if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
3576             return -1;
3577           break;
3578
3579         /* 0xe3a0-0xe3bf undefined */
3580
3581         case 0xe3c0: /* LBH - load byte high */
3582         case 0xe3c2: /* LLCH - load logical character high */
3583         case 0xe3c4: /* LHH - load halfword high */
3584         case 0xe3c6: /* LLHH - load logical halfword high */
3585         case 0xe3ca: /* LFH - load high */
3586         case 0xebe0: /* LOCFH - load high on condition */
3587           /* 32-bit high gpr destination */
3588           if (s390_record_gpr_h (gdbarch, regcache, inib[2]))
3589             return -1;
3590           break;
3591
3592         /* 0xe3c1 undefined */
3593         /* 0xe3c5 undefined */
3594
3595         case 0xe3c8: /* LFHAT - load high and trap */
3596           /* 32-bit high gpr destination + fpc for possible DXC write */
3597           if (s390_record_gpr_h (gdbarch, regcache, inib[2]))
3598             return -1;
3599           if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
3600             return -1;
3601           break;
3602
3603         /* 0xe3c9 undefined */
3604         /* 0xe3cc undefined */
3605         /* 0xe3ce undefined */
3606         /* 0xe3d0-0xe3ff undefined */
3607
3608         case 0xe634: /* VPKZ - vector pack zoned */
3609         case 0xe635: /* VLRL - vector load rightmost with immed. length */
3610         case 0xe637: /* VLRLR - vector load rightmost with length */
3611         case 0xe649: /* VLIP - vector load immediate decimal */
3612         case 0xe700: /* VLEB - vector load element */
3613         case 0xe701: /* VLEH - vector load element */
3614         case 0xe702: /* VLEG - vector load element */
3615         case 0xe703: /* VLEF - vector load element */
3616         case 0xe704: /* VLLEZ - vector load logical element and zero */
3617         case 0xe705: /* VLREP - vector load and replicate */
3618         case 0xe706: /* VL - vector load */
3619         case 0xe707: /* VLBB - vector load to block bounduary */
3620         case 0xe712: /* VGEG - vector gather element */
3621         case 0xe713: /* VGEF - vector gather element */
3622         case 0xe722: /* VLVG - vector load vr element from gr */
3623         case 0xe730: /* VESL - vector element shift left */
3624         case 0xe733: /* VERLL - vector element rotate left logical */
3625         case 0xe737: /* VLL - vector load with length */
3626         case 0xe738: /* VESRL - vector element shift right logical */
3627         case 0xe73a: /* VESRA - vector element shift right arithmetic */
3628         case 0xe740: /* VLEIB - vector load element immediate */
3629         case 0xe741: /* VLEIH - vector load element immediate */
3630         case 0xe742: /* VLEIG - vector load element immediate */
3631         case 0xe743: /* VLEIF - vector load element immediate */
3632         case 0xe744: /* VGBM - vector generate byte mask */
3633         case 0xe745: /* VREPI - vector replicate immediate */
3634         case 0xe746: /* VGM - vector generate mask */
3635         case 0xe74d: /* VREP - vector replicate */
3636         case 0xe750: /* VPOPCT - vector population count */
3637         case 0xe752: /* VCTZ - vector count trailing zeros */
3638         case 0xe753: /* VCLZ - vector count leading zeros */
3639         case 0xe756: /* VLR - vector load */
3640         case 0xe75f: /* VSEG -vector sign extend to doubleword */
3641         case 0xe760: /* VMRL - vector merge low */
3642         case 0xe761: /* VMRH - vector merge high */
3643         case 0xe762: /* VLVGP - vector load vr from grs disjoint */
3644         case 0xe764: /* VSUM - vector sum across word */
3645         case 0xe765: /* VSUMG - vector sum across doubleword */
3646         case 0xe766: /* VCKSM - vector checksum */
3647         case 0xe767: /* VSUMQ - vector sum across quadword */
3648         case 0xe768: /* VN - vector and */
3649         case 0xe769: /* VNC - vector and with complement */
3650         case 0xe76a: /* VO - vector or */
3651         case 0xe76b: /* VNO - vector nor */
3652         case 0xe76c: /* VNX - vector not exclusive or */
3653         case 0xe76d: /* VX - vector xor */
3654         case 0xe76e: /* VNN - vector nand */
3655         case 0xe76f: /* VOC - vector or with complement */
3656         case 0xe770: /* VESLV - vector element shift left */
3657         case 0xe772: /* VERIM - vector element rotate and insert under mask */
3658         case 0xe773: /* VERLLV - vector element rotate left logical */
3659         case 0xe774: /* VSL - vector shift left */
3660         case 0xe775: /* VSLB - vector shift left by byte */
3661         case 0xe777: /* VSLDB - vector shift left double by byte */
3662         case 0xe778: /* VESRLV - vector element shift right logical */
3663         case 0xe77a: /* VESRAV - vector element shift right arithmetic */
3664         case 0xe77c: /* VSRL - vector shift right logical */
3665         case 0xe77d: /* VSRLB - vector shift right logical by byte */
3666         case 0xe77e: /* VSRA - vector shift right arithmetic */
3667         case 0xe77f: /* VSRAB - vector shift right arithmetic by byte */
3668         case 0xe784: /* VPDI - vector permute doubleword immediate */
3669         case 0xe785: /* VBPERM - vector bit permute */
3670         case 0xe78c: /* VPERM - vector permute */
3671         case 0xe78d: /* VSEL - vector select */
3672         case 0xe78e: /* VFMS - vector fp multiply and subtract */
3673         case 0xe78f: /* VFMA - vector fp multiply and add */
3674         case 0xe794: /* VPK - vector pack */
3675         case 0xe79e: /* VFNMS - vector fp negative multiply and subtract */
3676         case 0xe79f: /* VFNMA - vector fp negative multiply and add */
3677         case 0xe7a1: /* VMLH - vector multiply logical high */
3678         case 0xe7a2: /* VML - vector multiply low */
3679         case 0xe7a3: /* VMH - vector multiply high */
3680         case 0xe7a4: /* VMLE - vector multiply logical even */
3681         case 0xe7a5: /* VMLO - vector multiply logical odd */
3682         case 0xe7a6: /* VME - vector multiply even */
3683         case 0xe7a7: /* VMO - vector multiply odd */
3684         case 0xe7a9: /* VMALH - vector multiply and add logical high */
3685         case 0xe7aa: /* VMAL - vector multiply and add low */
3686         case 0xe7ab: /* VMAH - vector multiply and add high */
3687         case 0xe7ac: /* VMALE - vector multiply and add logical even */
3688         case 0xe7ad: /* VMALO - vector multiply and add logical odd */
3689         case 0xe7ae: /* VMAE - vector multiply and add even */
3690         case 0xe7af: /* VMAO - vector multiply and add odd */
3691         case 0xe7b4: /* VGFM - vector Galois field multiply sum */
3692         case 0xe7b8: /* VMSL - vector multiply sum logical */
3693         case 0xe7b9: /* VACCC - vector add with carry compute carry */
3694         case 0xe7bb: /* VAC - vector add with carry */
3695         case 0xe7bc: /* VGFMA - vector Galois field multiply sum and accumulate */
3696         case 0xe7bd: /* VSBCBI - vector subtract with borrow compute borrow indication */
3697         case 0xe7bf: /* VSBI - vector subtract with borrow indication */
3698         case 0xe7c0: /* VCLGD - vector convert to logical 64-bit */
3699         case 0xe7c1: /* VCDLG - vector convert from logical 64-bit */
3700         case 0xe7c2: /* VCGD - vector convert to fixed 64-bit */
3701         case 0xe7c3: /* VCDG - vector convert from fixed 64-bit */
3702         case 0xe7c4: /* VLDE/VFLL - vector fp load lengthened */
3703         case 0xe7c5: /* VLED/VFLR - vector fp load rounded */
3704         case 0xe7c7: /* VFI - vector load fp integer */
3705         case 0xe7cc: /* VFPSO - vector fp perform sign operation */
3706         case 0xe7ce: /* VFSQ - vector fp square root */
3707         case 0xe7d4: /* VUPLL - vector unpack logical low */
3708         case 0xe7d6: /* VUPL - vector unpack low */
3709         case 0xe7d5: /* VUPLH - vector unpack logical high */
3710         case 0xe7d7: /* VUPH - vector unpack high */
3711         case 0xe7de: /* VLC - vector load complement */
3712         case 0xe7df: /* VLP - vector load positive */
3713         case 0xe7e2: /* VFA - vector fp subtract */
3714         case 0xe7e3: /* VFA - vector fp add */
3715         case 0xe7e5: /* VFD - vector fp divide */
3716         case 0xe7e7: /* VFM - vector fp multiply */
3717         case 0xe7ee: /* VFMIN - vector fp minimum */
3718         case 0xe7ef: /* VFMAX - vector fp maximum */
3719         case 0xe7f0: /* VAVGL - vector average logical */
3720         case 0xe7f1: /* VACC - vector add and compute carry */
3721         case 0xe7f2: /* VAVG - vector average */
3722         case 0xe7f3: /* VA - vector add */
3723         case 0xe7f5: /* VSCBI - vector subtract compute borrow indication */
3724         case 0xe7f7: /* VS - vector subtract */
3725         case 0xe7fc: /* VMNL - vector minimum logical */
3726         case 0xe7fd: /* VMXL - vector maximum logical */
3727         case 0xe7fe: /* VMN - vector minimum */
3728         case 0xe7ff: /* VMX - vector maximum */
3729           /* vector destination + FPC */
3730           if (s390_record_vr (gdbarch, regcache, ivec[0]))
3731             return -1;
3732           if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
3733             return -1;
3734           break;
3735
3736         case 0xe63d: /* VSTRL - vector store rightmost with immed. length */
3737           oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
3738           if (record_full_arch_list_add_mem (oaddr, inib[3] + 1))
3739             return -1;
3740           if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
3741             return -1;
3742           break;
3743
3744         case 0xe708: /* VSTEB - vector store element */
3745           oaddr = s390_record_calc_disp (gdbarch, regcache, inib[3], insn[1], 0);
3746           if (record_full_arch_list_add_mem (oaddr, 1))
3747             return -1;
3748           if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
3749             return -1;
3750           break;
3751
3752         case 0xe709: /* VSTEH - vector store element */
3753           oaddr = s390_record_calc_disp (gdbarch, regcache, inib[3], insn[1], 0);
3754           if (record_full_arch_list_add_mem (oaddr, 2))
3755             return -1;
3756           if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
3757             return -1;
3758           break;
3759
3760         case 0xe70a: /* VSTEG - vector store element */
3761           oaddr = s390_record_calc_disp (gdbarch, regcache, inib[3], insn[1], 0);
3762           if (record_full_arch_list_add_mem (oaddr, 8))
3763             return -1;
3764           if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
3765             return -1;
3766           break;
3767
3768         case 0xe70b: /* VSTEF - vector store element */
3769           oaddr = s390_record_calc_disp (gdbarch, regcache, inib[3], insn[1], 0);
3770           if (record_full_arch_list_add_mem (oaddr, 4))
3771             return -1;
3772           if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
3773             return -1;
3774           break;
3775
3776         /* 0xe70c-0xe70d undefined */
3777
3778         case 0xe70e: /* VST - vector store */
3779           oaddr = s390_record_calc_disp (gdbarch, regcache, inib[3], insn[1], 0);
3780           if (record_full_arch_list_add_mem (oaddr, 16))
3781             return -1;
3782           if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
3783             return -1;
3784           break;
3785
3786         /* 0xe70f-0xe711 undefined */
3787         /* 0xe714-0xe719 undefined */
3788
3789         case 0xe71a: /* VSCEG - vector scatter element */
3790           if (s390_record_calc_disp_vsce (gdbarch, regcache, ivec[1], inib[8], 8, insn[1], 0, &oaddr))
3791             return -1;
3792           if (record_full_arch_list_add_mem (oaddr, 8))
3793             return -1;
3794           if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
3795             return -1;
3796           break;
3797
3798         case 0xe71b: /* VSCEF - vector scatter element */
3799           if (s390_record_calc_disp_vsce (gdbarch, regcache, ivec[1], inib[8], 4, insn[1], 0, &oaddr))
3800             return -1;
3801           if (record_full_arch_list_add_mem (oaddr, 4))
3802             return -1;
3803           if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
3804             return -1;
3805           break;
3806
3807         /* 0xe71c-0xe720 undefined */
3808         /* 0xe723-0xe726 undefined */
3809         /* 0xe728-0xe72f undefined */
3810         /* 0xe731-0xe732 undefined */
3811         /* 0xe734-0xe735 undefined */
3812
3813         case 0xe736: /* VLM - vector load multiple */
3814           for (i = ivec[0]; i != ivec[1]; i++, i &= 0x1f)
3815             if (s390_record_vr (gdbarch, regcache, i))
3816               return -1;
3817           if (s390_record_vr (gdbarch, regcache, ivec[1]))
3818             return -1;
3819           if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
3820             return -1;
3821           break;
3822
3823         /* 0xe739 undefined */
3824         /* 0xe73b-0xe73d undefined */
3825
3826         case 0xe73e: /* VSTM - vector store multiple */
3827           oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
3828           if (ivec[0] <= ivec[1])
3829             n = ivec[1] - ivec[0] + 1;
3830           else
3831             n = ivec[1] + 0x20 - ivec[0] + 1;
3832           if (record_full_arch_list_add_mem (oaddr, n * 16))
3833             return -1;
3834           if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
3835             return -1;
3836           break;
3837
3838         case 0xe63c: /* VUPKZ - vector unpack zoned */
3839           oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
3840           if (record_full_arch_list_add_mem (oaddr, (ibyte[1] + 1) & 31))
3841             return -1;
3842           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3843             return -1;
3844           break;
3845
3846         case 0xe63f: /* VSTRLR - vector store rightmost with length */
3847         case 0xe73f: /* VSTL - vector store with length */
3848           oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
3849           regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + inib[3], &tmp);
3850           tmp &= 0xffffffffu;
3851           if (tmp > 15)
3852             tmp = 15;
3853           if (record_full_arch_list_add_mem (oaddr, tmp + 1))
3854             return -1;
3855           if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
3856             return -1;
3857           break;
3858
3859         /* 0xe747-0xe749 undefined */
3860
3861         case 0xe658: /* VCVD - vector convert to decimal 32 bit */
3862         case 0xe659: /* VSRP - vector shift and round decimal */
3863         case 0xe65a: /* VCVDG - vector convert to decimal 64 bit*/
3864         case 0xe65b: /* VPSOP - vector perform sign operation decimal */
3865         case 0xe671: /* VAP - vector add decimal */
3866         case 0xe673: /* VSP - vector subtract decimal */
3867         case 0xe678: /* VMP - vector multiply decimal */
3868         case 0xe679: /* VMSP - vector multiply decimal */
3869         case 0xe67a: /* VDP - vector divide decimal */
3870         case 0xe67b: /* VRP - vector remainder decimal */
3871         case 0xe67e: /* VSDP - vector shift and divide decimal */
3872         case 0xe74a: /* VFTCI - vector fp test data class immediate */
3873         case 0xe75c: /* VISTR - vector isolate string */
3874         case 0xe780: /* VFEE - vector find element equal */
3875         case 0xe781: /* VFENE - vector find element not equal */
3876         case 0xe782: /* VFA - vector find any element equal */
3877         case 0xe78a: /* VSTRC - vector string range compare */
3878         case 0xe795: /* VPKLS - vector pack logical saturate */
3879         case 0xe797: /* VPKS - vector pack saturate */
3880         case 0xe7e8: /* VFCE - vector fp compare equal */
3881         case 0xe7ea: /* VFCHE - vector fp compare high or equal */
3882         case 0xe7eb: /* VFCH - vector fp compare high */
3883         case 0xe7f8: /* VCEQ - vector compare equal */
3884         case 0xe7f9: /* VCHL - vector compare high logical */
3885         case 0xe7fb: /* VCH - vector compare high */
3886           /* vector destination + flags + FPC */
3887           if (s390_record_vr (gdbarch, regcache, ivec[0]))
3888             return -1;
3889           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3890             return -1;
3891           if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
3892             return -1;
3893           break;
3894
3895         case 0xe65f: /* VTP - vector test decimal */
3896           /* flags + FPC */
3897           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3898             return -1;
3899           if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
3900             return -1;
3901           break;
3902
3903         /* 0xe74b-0xe74c undefined */
3904         /* 0xe74e-0xe74f undefined */
3905         /* 0xe751 undefined */
3906         /* 0xe754-0xe755 undefined */
3907         /* 0xe757-0xe75b undefined */
3908         /* 0xe75d-0xe75e undefined */
3909         /* 0xe763 undefined */
3910         /* 0xe771 undefined */
3911         /* 0xe776 undefined */
3912         /* 0xe779 undefined */
3913         /* 0xe77b undefined */
3914         /* 0xe783 undefined */
3915         /* 0xe786-0xe789 undefined */
3916         /* 0xe78b undefined */
3917         /* 0xe790-0xe793 undefined */
3918         /* 0xe796 undefined */
3919         /* 0xe798-0xe79d undefined */
3920         /* 0xe7a0 undefined */
3921         /* 0xe7a8 undefined */
3922         /* 0xe7b0-0xe7b3 undefined */
3923         /* 0xe7b5-0xe7b7 undefined */
3924         /* 0xe7ba undefined */
3925         /* 0xe7be undefined */
3926         /* 0xe7c6 undefined */
3927         /* 0xe7c8-0xe7c9 undefined */
3928
3929         case 0xe677: /* VCP - vector compare decimal */
3930         case 0xe7ca: /* WFK - vector fp compare and signal scalar */
3931         case 0xe7cb: /* WFC - vector fp compare scalar */
3932         case 0xe7d8: /* VTM - vector test under mask */
3933         case 0xe7d9: /* VECL - vector element compare logical */
3934         case 0xe7db: /* VEC - vector element compare */
3935         case 0xed08: /* KEB - compare and signal */
3936         case 0xed09: /* CEB - compare */
3937         case 0xed18: /* KDB - compare and signal */
3938         case 0xed19: /* CDB - compare */
3939           /* flags + fpc only */
3940           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3941             return -1;
3942           if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
3943             return -1;
3944           break;
3945
3946         /* 0xe7cd undefined */
3947         /* 0xe7cf-0xe7d3 undefined */
3948         /* 0xe7da undefined */
3949         /* 0xe7dc-0xe7dd undefined */
3950         /* 0xe7e0-0xe7e1 undefined */
3951         /* 0xe7e4 undefined */
3952         /* 0xe7e6 undefined */
3953         /* 0xe7e9 undefined */
3954         /* 0xe7ec-0xe7ed undefined */
3955         /* 0xe7f4 undefined */
3956         /* 0xe7f6 undefined */
3957         /* 0xe7fa undefined */
3958
3959         /* 0xeb00-0xeb03 undefined */
3960
3961         case 0xeb04: /* LMG - load multiple */
3962           for (i = inib[2]; i != inib[3]; i++, i &= 0xf)
3963             if (s390_record_gpr_g (gdbarch, regcache, i))
3964               return -1;
3965           if (s390_record_gpr_g (gdbarch, regcache, inib[3]))
3966             return -1;
3967           break;
3968
3969         /* 0xeb05-0xeb09 undefined */
3970         /* 0xeb0e undefined */
3971         /* 0xeb0f privileged: TRACG */
3972         /* 0xeb10-0xeb13 undefined */
3973
3974         case 0xeb14: /* CSY - compare and swap */
3975         case 0xebf4: /* LAN - load and and */
3976         case 0xebf6: /* LAO - load and or */
3977         case 0xebf7: /* LAX - load and xor */
3978         case 0xebf8: /* LAA - load and add */
3979         case 0xebfa: /* LAAL - load and add logical */
3980           oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], ibyte[4]);
3981           if (record_full_arch_list_add_mem (oaddr, 4))
3982             return -1;
3983           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
3984             return -1;
3985           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
3986             return -1;
3987           break;
3988
3989         /* 0xeb15-0xeb1b undefined */
3990         /* 0xeb1e-0xeb1f undefined */
3991         /* 0xeb22 undefined */
3992
3993         case 0xeb23: /* CLT - compare logical and trap */
3994         case 0xeb2b: /* CLGT - compare logical and trap */
3995           /* fpc only - including possible DXC write for trapping insns */
3996           if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
3997             return -1;
3998           break;
3999
4000         case 0xeb24: /* STMG - store multiple */
4001           oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], ibyte[4]);
4002           if (inib[2] <= inib[3])
4003             n = inib[3] - inib[2] + 1;
4004           else
4005             n = inib[3] + 0x10 - inib[2] + 1;
4006           if (record_full_arch_list_add_mem (oaddr, n * 8))
4007             return -1;
4008           break;
4009
4010         /* 0xeb25 privileged */
4011
4012         case 0xeb26: /* STMH - store multiple high */
4013         case 0xeb90: /* STMY - store multiple */
4014         case 0xeb9b: /* STAMY - store access multiple */
4015           oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], ibyte[4]);
4016           if (inib[2] <= inib[3])
4017             n = inib[3] - inib[2] + 1;
4018           else
4019             n = inib[3] + 0x10 - inib[2] + 1;
4020           if (record_full_arch_list_add_mem (oaddr, n * 4))
4021             return -1;
4022           break;
4023
4024         /* 0xeb27-0xeb2a undefined */
4025
4026         case 0xeb2c: /* STCMH - store characters under mask */
4027         case 0xeb2d: /* STCMY - store characters under mask */
4028           oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], ibyte[4]);
4029           if (record_full_arch_list_add_mem (oaddr, s390_popcnt (inib[3])))
4030             return -1;
4031           break;
4032
4033         /* 0xeb2e undefined */
4034         /* 0xeb2f privileged */
4035
4036         case 0xeb30: /* CSG - compare and swap */
4037         case 0xebe4: /* LANG - load and and */
4038         case 0xebe6: /* LAOG - load and or */
4039         case 0xebe7: /* LAXG - load and xor */
4040         case 0xebe8: /* LAAG - load and add */
4041         case 0xebea: /* LAALG - load and add logical */
4042           oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], ibyte[4]);
4043           if (record_full_arch_list_add_mem (oaddr, 8))
4044             return -1;
4045           if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
4046             return -1;
4047           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4048             return -1;
4049           break;
4050
4051         case 0xeb31: /* CDSY - compare double and swap */
4052           oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], ibyte[4]);
4053           if (record_full_arch_list_add_mem (oaddr, 8))
4054             return -1;
4055           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
4056             return -1;
4057           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[2] | 1)))
4058             return -1;
4059           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4060             return -1;
4061           break;
4062
4063         /* 0xeb32-0xeb3d undefined */
4064
4065         case 0xeb3e: /* CDSG - compare double and swap */
4066           oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], ibyte[4]);
4067           if (record_full_arch_list_add_mem (oaddr, 16))
4068             return -1;
4069           if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
4070             return -1;
4071           if (s390_record_gpr_g (gdbarch, regcache, inib[2] | 1))
4072             return -1;
4073           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4074             return -1;
4075           break;
4076
4077         /* 0xeb3f-0xeb43 undefined */
4078         /* 0xeb46-0xeb4b undefined */
4079         /* 0xeb4d-0xeb50 undefined */
4080
4081         case 0xeb52: /* MVIY - move */
4082           oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], ibyte[4]);
4083           if (record_full_arch_list_add_mem (oaddr, 1))
4084             return -1;
4085           break;
4086
4087         case 0xeb54: /* NIY - and */
4088         case 0xeb56: /* OIY - or */
4089         case 0xeb57: /* XIY - xor */
4090           oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], ibyte[4]);
4091           if (record_full_arch_list_add_mem (oaddr, 1))
4092             return -1;
4093           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4094             return -1;
4095           break;
4096
4097         /* 0xeb53 undefined */
4098         /* 0xeb58-0xeb69 undefined */
4099
4100         case 0xeb6a: /* ASI - add immediate */
4101         case 0xeb6e: /* ALSI - add immediate */
4102           oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], ibyte[4]);
4103           if (record_full_arch_list_add_mem (oaddr, 4))
4104             return -1;
4105           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4106             return -1;
4107           break;
4108
4109         /* 0xeb6b-0xeb6d undefined */
4110         /* 0xeb6f-0xeb79 undefined */
4111
4112         case 0xeb7a: /* AGSI - add immediate */
4113         case 0xeb7e: /* ALGSI - add immediate */
4114           oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], ibyte[4]);
4115           if (record_full_arch_list_add_mem (oaddr, 8))
4116             return -1;
4117           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4118             return -1;
4119           break;
4120
4121         /* 0xeb7b-0xeb7d undefined */
4122         /* 0xeb7f undefined */
4123
4124         case 0xeb80: /* ICMH - insert characters under mask */
4125           /* 32-bit high gpr destination + flags */
4126           if (s390_record_gpr_h (gdbarch, regcache, inib[2]))
4127             return -1;
4128           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4129             return -1;
4130           break;
4131
4132         /* 0xeb82-0xeb8d undefined */
4133
4134         case 0xeb8e: /* MVCLU - move long unicode [partial] */
4135           regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + inib[2], &tmp);
4136           oaddr = s390_record_address_mask (gdbarch, regcache, tmp);
4137           regcache_raw_read_unsigned (regcache, S390_R0_REGNUM + (inib[2] | 1), &tmp);
4138           if (record_full_arch_list_add_mem (oaddr, tmp))
4139             return -1;
4140           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
4141             return -1;
4142           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[2] | 1)))
4143             return -1;
4144           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[3]))
4145             return -1;
4146           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[3] | 1)))
4147             return -1;
4148           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4149             return -1;
4150           break;
4151
4152         case 0xeb8f: /* CLCLU - compare logical long unicode [partial] */
4153           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
4154             return -1;
4155           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[2] | 1)))
4156             return -1;
4157           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[3]))
4158             return -1;
4159           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + (inib[3] | 1)))
4160             return -1;
4161           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4162             return -1;
4163           break;
4164
4165         /* 0xeb91-0xeb95 undefined */
4166
4167         case 0xeb96: /* LMH - load multiple high */
4168           for (i = inib[2]; i != inib[3]; i++, i &= 0xf)
4169             if (s390_record_gpr_h (gdbarch, regcache, i))
4170               return -1;
4171           if (s390_record_gpr_h (gdbarch, regcache, inib[3]))
4172             return -1;
4173           break;
4174
4175         /* 0xeb97 undefined */
4176
4177         case 0xeb98: /* LMY - load multiple */
4178           for (i = inib[2]; i != inib[3]; i++, i &= 0xf)
4179             if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + i))
4180               return -1;
4181           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[3]))
4182             return -1;
4183           break;
4184
4185         /* 0xeb99 undefined */
4186
4187         case 0xeb9a: /* LAMY - load access multiple */
4188           for (i = inib[2]; i != inib[3]; i++, i &= 0xf)
4189             if (record_full_arch_list_add_reg (regcache, S390_A0_REGNUM + i))
4190               return -1;
4191           if (record_full_arch_list_add_reg (regcache, S390_A0_REGNUM + inib[3]))
4192             return -1;
4193           break;
4194
4195         /* 0xeb9c-0xebbf undefined */
4196         /* 0xebc1-0xebdb undefined */
4197         /* 0xebe5 undefined */
4198         /* 0xebe9 undefined */
4199         /* 0xebeb-0xebf1 undefined */
4200         /* 0xebf5 undefined */
4201         /* 0xebf9 undefined */
4202         /* 0xebfb-0xebff undefined */
4203
4204         /* 0xed00-0xed03 undefined */
4205
4206         case 0xed04: /* LDEB - load lengthened */
4207         case 0xed0c: /* MDEB - multiply */
4208         case 0xed0d: /* DEB - divide */
4209         case 0xed14: /* SQEB - square root */
4210         case 0xed15: /* SQDB - square root */
4211         case 0xed17: /* MEEB - multiply */
4212         case 0xed1c: /* MDB - multiply */
4213         case 0xed1d: /* DDB - divide */
4214           /* float destination + fpc */
4215           if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[2]))
4216             return -1;
4217           if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
4218             return -1;
4219           break;
4220
4221         case 0xed05: /* LXDB - load lengthened */
4222         case 0xed06: /* LXEB - load lengthened */
4223         case 0xed07: /* MXDB - multiply */
4224           /* float pair destination + fpc */
4225           if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[2]))
4226             return -1;
4227           if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + (inib[2] | 2)))
4228             return -1;
4229           if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
4230             return -1;
4231           break;
4232
4233         case 0xed0a: /* AEB - add */
4234         case 0xed0b: /* SEB - subtract */
4235         case 0xed1a: /* ADB - add */
4236         case 0xed1b: /* SDB - subtract */
4237           /* float destination + flags + fpc */
4238           if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[2]))
4239             return -1;
4240           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4241             return -1;
4242           if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
4243             return -1;
4244           break;
4245
4246         case 0xed0e: /* MAEB - multiply and add */
4247         case 0xed0f: /* MSEB - multiply and subtract */
4248         case 0xed1e: /* MADB - multiply and add */
4249         case 0xed1f: /* MSDB - multiply and subtract */
4250         case 0xed40: /* SLDT - shift significand left */
4251         case 0xed41: /* SRDT - shift significand right */
4252         case 0xedaa: /* CDZT - convert from zoned */
4253         case 0xedae: /* CDPT - convert from packed */
4254           /* float destination [RXF] + fpc */
4255           if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[8]))
4256             return -1;
4257           if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
4258             return -1;
4259           break;
4260
4261         /* 0xed13 undefined */
4262         /* 0xed16 undefined */
4263         /* 0xed20-0xed23 undefined */
4264
4265         case 0xed24: /* LDE - load lengthened */
4266         case 0xed34: /* SQE - square root */
4267         case 0xed35: /* SQD - square root */
4268         case 0xed37: /* MEE - multiply */
4269         case 0xed64: /* LEY - load */
4270         case 0xed65: /* LDY - load */
4271           /* float destination */
4272           if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[2]))
4273             return -1;
4274           break;
4275
4276         case 0xed25: /* LXD - load lengthened */
4277         case 0xed26: /* LXE - load lengthened */
4278           /* float pair destination */
4279           if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[2]))
4280             return -1;
4281           if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + (inib[2] | 2)))
4282             return -1;
4283           break;
4284
4285         /* 0xed27-0xed2d undefined */
4286
4287         case 0xed2e: /* MAE - multiply and add */
4288         case 0xed2f: /* MSE - multiply and subtract */
4289         case 0xed38: /* MAYL - multiply and add unnormalized */
4290         case 0xed39: /* MYL - multiply unnormalized */
4291         case 0xed3c: /* MAYH - multiply and add unnormalized */
4292         case 0xed3d: /* MYH - multiply unnormalized */
4293         case 0xed3e: /* MAD - multiply and add */
4294         case 0xed3f: /* MSD - multiply and subtract */
4295           /* float destination [RXF] */
4296           if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[8]))
4297             return -1;
4298           break;
4299
4300         /* 0xed30-0xed33 undefined */
4301         /* 0xed36 undefined */
4302
4303         case 0xed3a: /* MAY - multiply and add unnormalized */
4304         case 0xed3b: /* MY - multiply unnormalized */
4305           /* float pair destination [RXF] */
4306           if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[8]))
4307             return -1;
4308           if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + (inib[8] | 2)))
4309             return -1;
4310           break;
4311
4312         /* 0xed42-0xed47 undefind */
4313
4314         case 0xed48: /* SLXT - shift significand left */
4315         case 0xed49: /* SRXT - shift significand right */
4316         case 0xedab: /* CXZT - convert from zoned */
4317         case 0xedaf: /* CXPT - convert from packed */
4318           /* float pair destination [RXF] + fpc */
4319           if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + inib[8]))
4320             return -1;
4321           if (record_full_arch_list_add_reg (regcache, S390_F0_REGNUM + (inib[8] | 2)))
4322             return -1;
4323           if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
4324             return -1;
4325           break;
4326
4327         /* 0xed4a-0xed4f undefind */
4328         /* 0xed52-0xed53 undefind */
4329         /* 0xed56-0xed57 undefind */
4330         /* 0xed5a-0xed63 undefind */
4331         /* 0xed68-0xeda7 undefined */
4332
4333         case 0xeda8: /* CZDT - convert to zoned */
4334         case 0xeda9: /* CZXT - convert to zoned */
4335         case 0xedac: /* CPDT - convert to packed */
4336         case 0xedad: /* CPXT - convert to packed */
4337           oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
4338           if (record_full_arch_list_add_mem (oaddr, ibyte[1] + 1))
4339             return -1;
4340           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4341             return -1;
4342           break;
4343
4344         /* 0xedb0-0xedff undefined */
4345
4346         default:
4347           goto UNKNOWN_OP;
4348         }
4349       break;
4350
4351     /* 0xe4 undefined */
4352
4353     case 0xe5:
4354       /* SSE/SIL-format instruction */
4355       switch (insn[0])
4356         {
4357         /* 0xe500-0xe543 undefined, privileged, or unsupported */
4358
4359         case 0xe544: /* MVHHI - move */
4360           oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
4361           if (record_full_arch_list_add_mem (oaddr, 2))
4362             return -1;
4363           break;
4364
4365         /* 0xe545-0xe547 undefined */
4366
4367         case 0xe548: /* MVGHI - move */
4368           oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
4369           if (record_full_arch_list_add_mem (oaddr, 8))
4370             return -1;
4371           break;
4372
4373         /* 0xe549-0xe54b undefined */
4374
4375         case 0xe54c: /* MVHI - move */
4376           oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
4377           if (record_full_arch_list_add_mem (oaddr, 4))
4378             return -1;
4379           break;
4380
4381         /* 0xe54d-0xe553 undefined */
4382
4383         case 0xe554: /* CHHSI - compare halfword immediate */
4384         case 0xe555: /* CLHHSI - compare logical immediate */
4385         case 0xe558: /* CGHSI - compare halfword immediate */
4386         case 0xe559: /* CLGHSI - compare logical immediate */
4387         case 0xe55c: /* CHSI - compare halfword immediate */
4388         case 0xe55d: /* CLFHSI - compare logical immediate */
4389           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4390             return -1;
4391           break;
4392
4393         /* 0xe556-0xe557 undefined */
4394         /* 0xe55a-0xe55b undefined */
4395         /* 0xe55e-0xe55f undefined */
4396
4397         case 0xe560: /* TBEGIN - transaction begin */
4398           /* The transaction will be immediately aborted after this
4399              instruction, due to single-stepping.  This instruction is
4400              only supported so that the program can fail a few times
4401              and go to the non-transactional fallback.  */
4402           if (inib[4])
4403             {
4404               /* Transaction diagnostic block - user.  */
4405               oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
4406               if (record_full_arch_list_add_mem (oaddr, 256))
4407                 return -1;
4408             }
4409           /* Transaction diagnostic block - supervisor.  */
4410           if (record_full_arch_list_add_reg (regcache, S390_TDB_DWORD0_REGNUM))
4411             return -1;
4412           if (record_full_arch_list_add_reg (regcache, S390_TDB_ABORT_CODE_REGNUM))
4413             return -1;
4414           if (record_full_arch_list_add_reg (regcache, S390_TDB_CONFLICT_TOKEN_REGNUM))
4415             return -1;
4416           if (record_full_arch_list_add_reg (regcache, S390_TDB_ATIA_REGNUM))
4417             return -1;
4418           for (i = 0; i < 16; i++)
4419             if (record_full_arch_list_add_reg (regcache, S390_TDB_R0_REGNUM + i))
4420               return -1;
4421           /* And flags.  */
4422           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4423             return -1;
4424           break;
4425
4426         /* 0xe561 unsupported: TBEGINC */
4427         /* 0xe562-0xe5ff undefined */
4428
4429         default:
4430           goto UNKNOWN_OP;
4431         }
4432       break;
4433
4434     case 0xec:
4435       /* RIE/RIS/RRS-format instruction */
4436       switch (ibyte[0] << 8 | ibyte[5])
4437         {
4438         /* 0xec00-0xec41 undefined */
4439
4440         case 0xec42: /* LOCHI - load halfword immediate on condition */
4441         case 0xec51: /* RISBLG - rotate then insert selected bits low */
4442           /* 32-bit or native gpr destination */
4443           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
4444             return -1;
4445           break;
4446
4447         /* 0xec43 undefined */
4448
4449         case 0xec44: /* BRXHG - branch relative on index high */
4450         case 0xec45: /* BRXLG - branch relative on index low or equal */
4451         case 0xec46: /* LOCGHI - load halfword immediate on condition */
4452         case 0xec59: /* RISBGN - rotate then insert selected bits */
4453           /* 64-bit gpr destination */
4454           if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
4455             return -1;
4456           break;
4457
4458         /* 0xec47-0xec4d undefined */
4459
4460         case 0xec4e: /* LOCHHI - load halfword immediate on condition */
4461         case 0xec5d: /* RISBHG - rotate then insert selected bits high */
4462           /* 32-bit high gpr destination */
4463           if (s390_record_gpr_h (gdbarch, regcache, inib[2]))
4464             return -1;
4465           break;
4466
4467         /* 0xec4f-0xec50 undefined */
4468         /* 0xec52-0xec53 undefined */
4469
4470         case 0xec54: /* RNSBG - rotate then and selected bits */
4471         case 0xec55: /* RISBG - rotate then insert selected bits */
4472         case 0xec56: /* ROSBG - rotate then or selected bits */
4473         case 0xec57: /* RXSBG - rotate then xor selected bits */
4474         case 0xecd9: /* AGHIK - add immediate */
4475         case 0xecdb: /* ALGHSIK - add logical immediate */
4476           /* 64-bit gpr destination + flags */
4477           if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
4478             return -1;
4479           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4480             return -1;
4481           break;
4482
4483         /* 0xec58 undefined */
4484         /* 0xec5a-0xec5c undefined */
4485         /* 0xec5e-0xec63 undefined */
4486
4487         case 0xec64: /* CGRJ - compare and branch relative */
4488         case 0xec65: /* CLGRJ - compare logical and branch relative */
4489         case 0xec76: /* CRJ - compare and branch relative */
4490         case 0xec77: /* CLRJ - compare logical and branch relative */
4491         case 0xec7c: /* CGIJ - compare immediate and branch relative */
4492         case 0xec7d: /* CLGIJ - compare logical immediate and branch relative */
4493         case 0xec7e: /* CIJ - compare immediate and branch relative */
4494         case 0xec7f: /* CLIJ - compare logical immediate and branch relative */
4495         case 0xece4: /* CGRB - compare and branch */
4496         case 0xece5: /* CLGRB - compare logical and branch */
4497         case 0xecf6: /* CRB - compare and branch */
4498         case 0xecf7: /* CLRB - compare logical and branch */
4499         case 0xecfc: /* CGIB - compare immediate and branch */
4500         case 0xecfd: /* CLGIB - compare logical immediate and branch */
4501         case 0xecfe: /* CIB - compare immediate and branch */
4502         case 0xecff: /* CLIB - compare logical immediate and branch */
4503           break;
4504
4505         /* 0xec66-0xec6f undefined */
4506
4507         case 0xec70: /* CGIT - compare immediate and trap */
4508         case 0xec71: /* CLGIT - compare logical immediate and trap */
4509         case 0xec72: /* CIT - compare immediate and trap */
4510         case 0xec73: /* CLFIT - compare logical immediate and trap */
4511           /* fpc only - including possible DXC write for trapping insns */
4512           if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
4513             return -1;
4514           break;
4515
4516         /* 0xec74-0xec75 undefined */
4517         /* 0xec78-0xec7b undefined */
4518
4519         /* 0xec80-0xecd7 undefined */
4520
4521         case 0xecd8: /* AHIK - add immediate */
4522         case 0xecda: /* ALHSIK - add logical immediate */
4523           /* 32-bit gpr destination + flags */
4524           if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
4525             return -1;
4526           if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4527             return -1;
4528           break;
4529
4530         /* 0xecdc-0xece3 undefined */
4531         /* 0xece6-0xecf5 undefined */
4532         /* 0xecf8-0xecfb undefined */
4533
4534         default:
4535           goto UNKNOWN_OP;
4536         }
4537       break;
4538
4539     case 0xee: /* PLO - perform locked operation */
4540       regcache_raw_read_unsigned (regcache, S390_R0_REGNUM, &tmp);
4541       oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
4542       oaddr2 = s390_record_calc_disp (gdbarch, regcache, 0, insn[2], 0);
4543       if (!(tmp & 0x100))
4544         {
4545           uint8_t fc = tmp & 0xff;
4546           gdb_byte buf[8];
4547           switch (fc)
4548             {
4549             case 0x00: /* CL */
4550               /* op1c */
4551               if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
4552                 return -1;
4553               /* op3 */
4554               if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[3]))
4555                 return -1;
4556               break;
4557
4558             case 0x01: /* CLG */
4559               /* op1c */
4560               if (record_full_arch_list_add_mem (oaddr2 + 0x08, 8))
4561                 return -1;
4562               /* op3 */
4563               if (record_full_arch_list_add_mem (oaddr2 + 0x28, 8))
4564                 return -1;
4565               break;
4566
4567             case 0x02: /* CLGR */
4568               /* op1c */
4569               if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
4570                 return -1;
4571               /* op3 */
4572               if (s390_record_gpr_g (gdbarch, regcache, inib[3]))
4573                 return -1;
4574               break;
4575
4576             case 0x03: /* CLX */
4577               /* op1c */
4578               if (record_full_arch_list_add_mem (oaddr2 + 0x00, 16))
4579                 return -1;
4580               /* op3 */
4581               if (record_full_arch_list_add_mem (oaddr2 + 0x20, 16))
4582                 return -1;
4583               break;
4584
4585             case 0x08: /* DCS */
4586               /* op3c */
4587               if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[3]))
4588                 return -1;
4589               /* fallthru */
4590             case 0x0c: /* CSST */
4591               /* op4 */
4592               if (record_full_arch_list_add_mem (oaddr2, 4))
4593                 return -1;
4594               goto CS;
4595
4596             case 0x14: /* CSTST */
4597               /* op8 */
4598               if (target_read_memory (oaddr2 + 0x88, buf, 8))
4599                 return -1;
4600               oaddr3 = extract_unsigned_integer (buf, 8, byte_order);
4601               oaddr3 = s390_record_address_mask (gdbarch, regcache, oaddr3);
4602               if (record_full_arch_list_add_mem (oaddr3, 4))
4603                 return -1;
4604               /* fallthru */
4605             case 0x10: /* CSDST */
4606               /* op6 */
4607               if (target_read_memory (oaddr2 + 0x68, buf, 8))
4608                 return -1;
4609               oaddr3 = extract_unsigned_integer (buf, 8, byte_order);
4610               oaddr3 = s390_record_address_mask (gdbarch, regcache, oaddr3);
4611               if (record_full_arch_list_add_mem (oaddr3, 4))
4612                 return -1;
4613               /* op4 */
4614               if (target_read_memory (oaddr2 + 0x48, buf, 8))
4615                 return -1;
4616               oaddr3 = extract_unsigned_integer (buf, 8, byte_order);
4617               oaddr3 = s390_record_address_mask (gdbarch, regcache, oaddr3);
4618               if (record_full_arch_list_add_mem (oaddr3, 4))
4619                 return -1;
4620               /* fallthru */
4621             case 0x04: /* CS */
4622 CS:
4623               /* op1c */
4624               if (record_full_arch_list_add_reg (regcache, S390_R0_REGNUM + inib[2]))
4625                 return -1;
4626               /* op2 */
4627               if (record_full_arch_list_add_mem (oaddr, 4))
4628                 return -1;
4629               break;
4630
4631             case 0x09: /* DCSG */
4632               /* op3c */
4633               if (record_full_arch_list_add_mem (oaddr2 + 0x28, 8))
4634                 return -1;
4635               goto CSSTG;
4636
4637             case 0x15: /* CSTSTG */
4638               /* op8 */
4639               if (target_read_memory (oaddr2 + 0x88, buf, 8))
4640                 return -1;
4641               oaddr3 = extract_unsigned_integer (buf, 8, byte_order);
4642               oaddr3 = s390_record_address_mask (gdbarch, regcache, oaddr3);
4643               if (record_full_arch_list_add_mem (oaddr3, 8))
4644                 return -1;
4645               /* fallthru */
4646             case 0x11: /* CSDSTG */
4647               /* op6 */
4648               if (target_read_memory (oaddr2 + 0x68, buf, 8))
4649                 return -1;
4650               oaddr3 = extract_unsigned_integer (buf, 8, byte_order);
4651               oaddr3 = s390_record_address_mask (gdbarch, regcache, oaddr3);
4652               if (record_full_arch_list_add_mem (oaddr3, 8))
4653                 return -1;
4654               /* fallthru */
4655             case 0x0d: /* CSSTG */
4656 CSSTG:
4657               /* op4 */
4658               if (target_read_memory (oaddr2 + 0x48, buf, 8))
4659                 return -1;
4660               oaddr3 = extract_unsigned_integer (buf, 8, byte_order);
4661               oaddr3 = s390_record_address_mask (gdbarch, regcache, oaddr3);
4662               if (record_full_arch_list_add_mem (oaddr3, 8))
4663                 return -1;
4664               /* fallthru */
4665             case 0x05: /* CSG */
4666               /* op1c */
4667               if (record_full_arch_list_add_mem (oaddr2 + 0x08, 8))
4668                 return -1;
4669               /* op2 */
4670               if (record_full_arch_list_add_mem (oaddr, 8))
4671                 return -1;
4672               break;
4673
4674             case 0x0a: /* DCSGR */
4675               /* op3c */
4676               if (s390_record_gpr_g (gdbarch, regcache, inib[3]))
4677                 return -1;
4678               /* fallthru */
4679             case 0x0e: /* CSSTGR */
4680               /* op4 */
4681               if (record_full_arch_list_add_mem (oaddr2, 8))
4682                 return -1;
4683               goto CSGR;
4684
4685             case 0x16: /* CSTSTGR */
4686               /* op8 */
4687               if (target_read_memory (oaddr2 + 0x88, buf, 8))
4688                 return -1;
4689               oaddr3 = extract_unsigned_integer (buf, 8, byte_order);
4690               oaddr3 = s390_record_address_mask (gdbarch, regcache, oaddr3);
4691               if (record_full_arch_list_add_mem (oaddr3, 8))
4692                 return -1;
4693               /* fallthru */
4694             case 0x12: /* CSDSTGR */
4695               /* op6 */
4696               if (target_read_memory (oaddr2 + 0x68, buf, 8))
4697                 return -1;
4698               oaddr3 = extract_unsigned_integer (buf, 8, byte_order);
4699               oaddr3 = s390_record_address_mask (gdbarch, regcache, oaddr3);
4700               if (record_full_arch_list_add_mem (oaddr3, 8))
4701                 return -1;
4702               /* op4 */
4703               if (target_read_memory (oaddr2 + 0x48, buf, 8))
4704                 return -1;
4705               oaddr3 = extract_unsigned_integer (buf, 8, byte_order);
4706               oaddr3 = s390_record_address_mask (gdbarch, regcache, oaddr3);
4707               if (record_full_arch_list_add_mem (oaddr3, 8))
4708                 return -1;
4709               /* fallthru */
4710             case 0x06: /* CSGR */
4711 CSGR:
4712               /* op1c */
4713               if (s390_record_gpr_g (gdbarch, regcache, inib[2]))
4714                 return -1;
4715               /* op2 */
4716               if (record_full_arch_list_add_mem (oaddr, 8))
4717                 return -1;
4718               break;
4719
4720             case 0x0b: /* DCSX */
4721               /* op3c */
4722               if (record_full_arch_list_add_mem (oaddr2 + 0x20, 16))
4723                 return -1;
4724               goto CSSTX;
4725
4726             case 0x17: /* CSTSTX */
4727               /* op8 */
4728               if (target_read_memory (oaddr2 + 0x88, buf, 8))
4729                 return -1;
4730               oaddr3 = extract_unsigned_integer (buf, 8, byte_order);
4731               oaddr3 = s390_record_address_mask (gdbarch, regcache, oaddr3);
4732               if (record_full_arch_list_add_mem (oaddr3, 16))
4733                 return -1;
4734               /* fallthru */
4735             case 0x13: /* CSDSTX */
4736               /* op6 */
4737               if (target_read_memory (oaddr2 + 0x68, buf, 8))
4738                 return -1;
4739               oaddr3 = extract_unsigned_integer (buf, 8, byte_order);
4740               oaddr3 = s390_record_address_mask (gdbarch, regcache, oaddr3);
4741               if (record_full_arch_list_add_mem (oaddr3, 16))
4742                 return -1;
4743               /* fallthru */
4744             case 0x0f: /* CSSTX */
4745 CSSTX:
4746               /* op4 */
4747               if (target_read_memory (oaddr2 + 0x48, buf, 8))
4748                 return -1;
4749               oaddr3 = extract_unsigned_integer (buf, 8, byte_order);
4750               oaddr3 = s390_record_address_mask (gdbarch, regcache, oaddr3);
4751               if (record_full_arch_list_add_mem (oaddr3, 16))
4752                 return -1;
4753               /* fallthru */
4754             case 0x07: /* CSX */
4755               /* op1c */
4756               if (record_full_arch_list_add_mem (oaddr2 + 0x00, 16))
4757                 return -1;
4758               /* op2 */
4759               if (record_full_arch_list_add_mem (oaddr, 16))
4760                 return -1;
4761               break;
4762
4763             default:
4764               fprintf_unfiltered (gdb_stdlog, "Warning: Unknown PLO FC %02x at %s.\n",
4765                                   fc, paddress (gdbarch, addr));
4766               return -1;
4767             }
4768         }
4769       if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4770         return -1;
4771       break;
4772
4773     case 0xef: /* LMD - load multiple disjoint */
4774       for (i = inib[2]; i != inib[3]; i++, i &= 0xf)
4775         if (s390_record_gpr_g (gdbarch, regcache, i))
4776           return -1;
4777       if (s390_record_gpr_g (gdbarch, regcache, inib[3]))
4778         return -1;
4779       break;
4780
4781     case 0xf0: /* SRP - shift and round decimal */
4782     case 0xf8: /* ZAP - zero and add */
4783     case 0xfa: /* AP - add decimal */
4784     case 0xfb: /* SP - subtract decimal */
4785       oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
4786       if (record_full_arch_list_add_mem (oaddr, inib[2] + 1))
4787         return -1;
4788       if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4789         return -1;
4790       /* DXC may be written */
4791       if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
4792         return -1;
4793       break;
4794
4795     case 0xf1: /* MVO - move with offset */
4796     case 0xf2: /* PACK - pack */
4797     case 0xf3: /* UNPK - unpack */
4798       oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
4799       if (record_full_arch_list_add_mem (oaddr, inib[2] + 1))
4800         return -1;
4801       break;
4802
4803     /* 0xf4-0xf7 undefined */
4804
4805     case 0xf9: /* CP - compare decimal */
4806       if (record_full_arch_list_add_reg (regcache, S390_PSWM_REGNUM))
4807         return -1;
4808       /* DXC may be written */
4809       if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
4810         return -1;
4811       break;
4812
4813     case 0xfc: /* MP - multiply decimal */
4814     case 0xfd: /* DP - divide decimal */
4815       oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], 0);
4816       if (record_full_arch_list_add_mem (oaddr, inib[2] + 1))
4817         return -1;
4818       /* DXC may be written */
4819       if (record_full_arch_list_add_reg (regcache, S390_FPC_REGNUM))
4820         return -1;
4821       break;
4822
4823     /* 0xfe-0xff undefined */
4824
4825     default:
4826 UNKNOWN_OP:
4827       fprintf_unfiltered (gdb_stdlog, "Warning: Don't know how to record %04x "
4828                           "at %s.\n", insn[0], paddress (gdbarch, addr));
4829       return -1;
4830   }
4831
4832   if (record_full_arch_list_add_reg (regcache, S390_PSWA_REGNUM))
4833     return -1;
4834   if (record_full_arch_list_add_end ())
4835     return -1;
4836   return 0;
4837 }
4838
4839 /* Initialize linux_record_tdep if not initialized yet.  */
4840
4841 static void
4842 s390_init_linux_record_tdep (struct linux_record_tdep *record_tdep,
4843                              enum s390_abi_kind abi)
4844 {
4845   /* These values are the size of the type that will be used in a system
4846      call.  They are obtained from Linux Kernel source.  */
4847
4848   if (abi == ABI_LINUX_ZSERIES)
4849     {
4850       record_tdep->size_pointer = 8;
4851       /* no _old_kernel_stat */
4852       record_tdep->size_tms = 32;
4853       record_tdep->size_loff_t = 8;
4854       record_tdep->size_flock = 32;
4855       record_tdep->size_ustat = 32;
4856       record_tdep->size_old_sigaction = 32;
4857       record_tdep->size_old_sigset_t = 8;
4858       record_tdep->size_rlimit = 16;
4859       record_tdep->size_rusage = 144;
4860       record_tdep->size_timeval = 16;
4861       record_tdep->size_timezone = 8;
4862       /* old_[ug]id_t never used */
4863       record_tdep->size_fd_set = 128;
4864       record_tdep->size_old_dirent = 280;
4865       record_tdep->size_statfs = 88;
4866       record_tdep->size_statfs64 = 88;
4867       record_tdep->size_sockaddr = 16;
4868       record_tdep->size_int = 4;
4869       record_tdep->size_long = 8;
4870       record_tdep->size_ulong = 8;
4871       record_tdep->size_msghdr = 56;
4872       record_tdep->size_itimerval = 32;
4873       record_tdep->size_stat = 144;
4874       /* old_utsname unused */
4875       record_tdep->size_sysinfo = 112;
4876       record_tdep->size_msqid_ds = 120;
4877       record_tdep->size_shmid_ds = 112;
4878       record_tdep->size_new_utsname = 390;
4879       record_tdep->size_timex = 208;
4880       record_tdep->size_mem_dqinfo = 24;
4881       record_tdep->size_if_dqblk = 72;
4882       record_tdep->size_fs_quota_stat = 80;
4883       record_tdep->size_timespec = 16;
4884       record_tdep->size_pollfd = 8;
4885       record_tdep->size_NFS_FHSIZE = 32;
4886       record_tdep->size_knfsd_fh = 132;
4887       record_tdep->size_TASK_COMM_LEN = 16;
4888       record_tdep->size_sigaction = 32;
4889       record_tdep->size_sigset_t = 8;
4890       record_tdep->size_siginfo_t = 128;
4891       record_tdep->size_cap_user_data_t = 12;
4892       record_tdep->size_stack_t = 24;
4893       record_tdep->size_off_t = 8;
4894       /* stat64 unused */
4895       record_tdep->size_gid_t = 4;
4896       record_tdep->size_uid_t = 4;
4897       record_tdep->size_PAGE_SIZE = 0x1000;        /* 4KB */
4898       record_tdep->size_flock64 = 32;
4899       record_tdep->size_io_event = 32;
4900       record_tdep->size_iocb = 64;
4901       record_tdep->size_epoll_event = 16;
4902       record_tdep->size_itimerspec = 32;
4903       record_tdep->size_mq_attr = 64;
4904       record_tdep->size_termios = 36;
4905       record_tdep->size_termios2 = 44;
4906       record_tdep->size_pid_t = 4;
4907       record_tdep->size_winsize = 8;
4908       record_tdep->size_serial_struct = 72;
4909       record_tdep->size_serial_icounter_struct = 80;
4910       record_tdep->size_size_t = 8;
4911       record_tdep->size_iovec = 16;
4912       record_tdep->size_time_t = 8;
4913     }
4914   else if (abi == ABI_LINUX_S390)
4915     {
4916       record_tdep->size_pointer = 4;
4917       record_tdep->size__old_kernel_stat = 32;
4918       record_tdep->size_tms = 16;
4919       record_tdep->size_loff_t = 8;
4920       record_tdep->size_flock = 16;
4921       record_tdep->size_ustat = 20;
4922       record_tdep->size_old_sigaction = 16;
4923       record_tdep->size_old_sigset_t = 4;
4924       record_tdep->size_rlimit = 8;
4925       record_tdep->size_rusage = 72;
4926       record_tdep->size_timeval = 8;
4927       record_tdep->size_timezone = 8;
4928       record_tdep->size_old_gid_t = 2;
4929       record_tdep->size_old_uid_t = 2;
4930       record_tdep->size_fd_set = 128;
4931       record_tdep->size_old_dirent = 268;
4932       record_tdep->size_statfs = 64;
4933       record_tdep->size_statfs64 = 88;
4934       record_tdep->size_sockaddr = 16;
4935       record_tdep->size_int = 4;
4936       record_tdep->size_long = 4;
4937       record_tdep->size_ulong = 4;
4938       record_tdep->size_msghdr = 28;
4939       record_tdep->size_itimerval = 16;
4940       record_tdep->size_stat = 64;
4941       /* old_utsname unused */
4942       record_tdep->size_sysinfo = 64;
4943       record_tdep->size_msqid_ds = 88;
4944       record_tdep->size_shmid_ds = 84;
4945       record_tdep->size_new_utsname = 390;
4946       record_tdep->size_timex = 128;
4947       record_tdep->size_mem_dqinfo = 24;
4948       record_tdep->size_if_dqblk = 72;
4949       record_tdep->size_fs_quota_stat = 80;
4950       record_tdep->size_timespec = 8;
4951       record_tdep->size_pollfd = 8;
4952       record_tdep->size_NFS_FHSIZE = 32;
4953       record_tdep->size_knfsd_fh = 132;
4954       record_tdep->size_TASK_COMM_LEN = 16;
4955       record_tdep->size_sigaction = 20;
4956       record_tdep->size_sigset_t = 8;
4957       record_tdep->size_siginfo_t = 128;
4958       record_tdep->size_cap_user_data_t = 12;
4959       record_tdep->size_stack_t = 12;
4960       record_tdep->size_off_t = 4;
4961       record_tdep->size_stat64 = 104;
4962       record_tdep->size_gid_t = 4;
4963       record_tdep->size_uid_t = 4;
4964       record_tdep->size_PAGE_SIZE = 0x1000;        /* 4KB */
4965       record_tdep->size_flock64 = 32;
4966       record_tdep->size_io_event = 32;
4967       record_tdep->size_iocb = 64;
4968       record_tdep->size_epoll_event = 16;
4969       record_tdep->size_itimerspec = 16;
4970       record_tdep->size_mq_attr = 32;
4971       record_tdep->size_termios = 36;
4972       record_tdep->size_termios2 = 44;
4973       record_tdep->size_pid_t = 4;
4974       record_tdep->size_winsize = 8;
4975       record_tdep->size_serial_struct = 60;
4976       record_tdep->size_serial_icounter_struct = 80;
4977       record_tdep->size_size_t = 4;
4978       record_tdep->size_iovec = 8;
4979       record_tdep->size_time_t = 4;
4980     }
4981
4982   /* These values are the second argument of system call "sys_fcntl"
4983      and "sys_fcntl64".  They are obtained from Linux Kernel source.  */
4984   record_tdep->fcntl_F_GETLK = 5;
4985   record_tdep->fcntl_F_GETLK64 = 12;
4986   record_tdep->fcntl_F_SETLK64 = 13;
4987   record_tdep->fcntl_F_SETLKW64 = 14;
4988
4989   record_tdep->arg1 = S390_R2_REGNUM;
4990   record_tdep->arg2 = S390_R3_REGNUM;
4991   record_tdep->arg3 = S390_R4_REGNUM;
4992   record_tdep->arg4 = S390_R5_REGNUM;
4993   record_tdep->arg5 = S390_R6_REGNUM;
4994
4995   /* These values are the second argument of system call "sys_ioctl".
4996      They are obtained from Linux Kernel source.
4997      See arch/s390/include/uapi/asm/ioctls.h.  */
4998
4999   record_tdep->ioctl_TCGETS = 0x5401;
5000   record_tdep->ioctl_TCSETS = 0x5402;
5001   record_tdep->ioctl_TCSETSW = 0x5403;
5002   record_tdep->ioctl_TCSETSF = 0x5404;
5003   record_tdep->ioctl_TCGETA = 0x5405;
5004   record_tdep->ioctl_TCSETA = 0x5406;
5005   record_tdep->ioctl_TCSETAW = 0x5407;
5006   record_tdep->ioctl_TCSETAF = 0x5408;
5007   record_tdep->ioctl_TCSBRK = 0x5409;
5008   record_tdep->ioctl_TCXONC = 0x540a;
5009   record_tdep->ioctl_TCFLSH = 0x540b;
5010   record_tdep->ioctl_TIOCEXCL = 0x540c;
5011   record_tdep->ioctl_TIOCNXCL = 0x540d;
5012   record_tdep->ioctl_TIOCSCTTY = 0x540e;
5013   record_tdep->ioctl_TIOCGPGRP = 0x540f;
5014   record_tdep->ioctl_TIOCSPGRP = 0x5410;
5015   record_tdep->ioctl_TIOCOUTQ = 0x5411;
5016   record_tdep->ioctl_TIOCSTI = 0x5412;
5017   record_tdep->ioctl_TIOCGWINSZ = 0x5413;
5018   record_tdep->ioctl_TIOCSWINSZ = 0x5414;
5019   record_tdep->ioctl_TIOCMGET = 0x5415;
5020   record_tdep->ioctl_TIOCMBIS = 0x5416;
5021   record_tdep->ioctl_TIOCMBIC = 0x5417;
5022   record_tdep->ioctl_TIOCMSET = 0x5418;
5023   record_tdep->ioctl_TIOCGSOFTCAR = 0x5419;
5024   record_tdep->ioctl_TIOCSSOFTCAR = 0x541a;
5025   record_tdep->ioctl_FIONREAD = 0x541b;
5026   record_tdep->ioctl_TIOCINQ = 0x541b; /* alias */
5027   record_tdep->ioctl_TIOCLINUX = 0x541c;
5028   record_tdep->ioctl_TIOCCONS = 0x541d;
5029   record_tdep->ioctl_TIOCGSERIAL = 0x541e;
5030   record_tdep->ioctl_TIOCSSERIAL = 0x541f;
5031   record_tdep->ioctl_TIOCPKT = 0x5420;
5032   record_tdep->ioctl_FIONBIO = 0x5421;
5033   record_tdep->ioctl_TIOCNOTTY = 0x5422;
5034   record_tdep->ioctl_TIOCSETD = 0x5423;
5035   record_tdep->ioctl_TIOCGETD = 0x5424;
5036   record_tdep->ioctl_TCSBRKP = 0x5425;
5037   record_tdep->ioctl_TIOCSBRK = 0x5427;
5038   record_tdep->ioctl_TIOCCBRK = 0x5428;
5039   record_tdep->ioctl_TIOCGSID = 0x5429;
5040   record_tdep->ioctl_TCGETS2 = 0x802c542a;
5041   record_tdep->ioctl_TCSETS2 = 0x402c542b;
5042   record_tdep->ioctl_TCSETSW2 = 0x402c542c;
5043   record_tdep->ioctl_TCSETSF2 = 0x402c542d;
5044   record_tdep->ioctl_TIOCGPTN = 0x80045430;
5045   record_tdep->ioctl_TIOCSPTLCK = 0x40045431;
5046   record_tdep->ioctl_FIONCLEX = 0x5450;
5047   record_tdep->ioctl_FIOCLEX = 0x5451;
5048   record_tdep->ioctl_FIOASYNC = 0x5452;
5049   record_tdep->ioctl_TIOCSERCONFIG = 0x5453;
5050   record_tdep->ioctl_TIOCSERGWILD = 0x5454;
5051   record_tdep->ioctl_TIOCSERSWILD = 0x5455;
5052   record_tdep->ioctl_TIOCGLCKTRMIOS = 0x5456;
5053   record_tdep->ioctl_TIOCSLCKTRMIOS = 0x5457;
5054   record_tdep->ioctl_TIOCSERGSTRUCT = 0x5458;
5055   record_tdep->ioctl_TIOCSERGETLSR = 0x5459;
5056   record_tdep->ioctl_TIOCSERGETMULTI = 0x545a;
5057   record_tdep->ioctl_TIOCSERSETMULTI = 0x545b;
5058   record_tdep->ioctl_TIOCMIWAIT = 0x545c;
5059   record_tdep->ioctl_TIOCGICOUNT = 0x545d;
5060   record_tdep->ioctl_FIOQSIZE = 0x545e;
5061 }
5062
5063 /* Initialize OSABI common for GNU/Linux on 31- and 64-bit systems.  */
5064
5065 static void
5066 s390_linux_init_abi_any (struct gdbarch_info info, struct gdbarch *gdbarch)
5067 {
5068   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
5069
5070   tdep->s390_syscall_record = s390_linux_syscall_record;
5071
5072   linux_init_abi (info, gdbarch);
5073
5074   /* Process record-replay */
5075   set_gdbarch_process_record (gdbarch, s390_process_record);
5076
5077   /* Register handling.  */
5078   set_gdbarch_core_read_description (gdbarch, s390_core_read_description);
5079   set_gdbarch_iterate_over_regset_sections (gdbarch,
5080                                             s390_iterate_over_regset_sections);
5081   set_gdbarch_write_pc (gdbarch, s390_write_pc);
5082   set_gdbarch_cannot_store_register (gdbarch, s390_cannot_store_register);
5083
5084   /* Syscall handling.  */
5085   set_gdbarch_get_syscall_number (gdbarch, s390_linux_get_syscall_number);
5086
5087   /* Frame handling.  */
5088   frame_unwind_append_unwinder (gdbarch, &s390_sigtramp_frame_unwind);
5089   set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
5090
5091   /* Enable TLS support.  */
5092   set_gdbarch_fetch_tls_load_module_address (gdbarch,
5093                                              svr4_fetch_objfile_link_map);
5094
5095   /* Support reverse debugging.  */
5096   set_gdbarch_process_record_signal (gdbarch, s390_linux_record_signal);
5097   s390_init_linux_record_tdep (&s390_linux_record_tdep, ABI_LINUX_S390);
5098   s390_init_linux_record_tdep (&s390x_linux_record_tdep, ABI_LINUX_ZSERIES);
5099 }
5100
5101 /* Initialize OSABI for GNU/Linux on 31-bit systems.  */
5102
5103 static void
5104 s390_linux_init_abi_31 (struct gdbarch_info info, struct gdbarch *gdbarch)
5105 {
5106   const struct target_desc *tdesc = info.target_desc;
5107   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
5108
5109   tdep->abi = ABI_LINUX_S390;
5110   if (!tdesc_has_registers (tdesc))
5111     tdesc = tdesc_s390_linux32;
5112   tdep->tdesc = tdesc;
5113
5114   s390_linux_init_abi_any (info, gdbarch);
5115
5116   set_solib_svr4_fetch_link_map_offsets (gdbarch,
5117                                          svr4_ilp32_fetch_link_map_offsets);
5118   set_xml_syscall_file_name (gdbarch, XML_SYSCALL_FILENAME_S390);
5119 }
5120
5121 /* Initialize OSABI for GNU/Linux on 64-bit systems.  */
5122
5123 static void
5124 s390_linux_init_abi_64 (struct gdbarch_info info, struct gdbarch *gdbarch)
5125 {
5126   const struct target_desc *tdesc = info.target_desc;
5127   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
5128
5129   tdep->abi = ABI_LINUX_ZSERIES;
5130   if (!tdesc_has_registers (tdesc))
5131     tdesc = tdesc_s390x_linux64;
5132   tdep->tdesc = tdesc;
5133
5134   s390_linux_init_abi_any (info, gdbarch);
5135
5136   set_solib_svr4_fetch_link_map_offsets (gdbarch,
5137                                          svr4_lp64_fetch_link_map_offsets);
5138   set_xml_syscall_file_name (gdbarch, XML_SYSCALL_FILENAME_S390X);
5139 }
5140
5141 void
5142 _initialize_s390_linux_tdep (void)
5143 {
5144   /* Hook us into the OSABI mechanism.  */
5145   gdbarch_register_osabi (bfd_arch_s390, bfd_mach_s390_31, GDB_OSABI_LINUX,
5146                           s390_linux_init_abi_31);
5147   gdbarch_register_osabi (bfd_arch_s390, bfd_mach_s390_64, GDB_OSABI_LINUX,
5148                           s390_linux_init_abi_64);
5149
5150   /* Initialize the GNU/Linux target descriptions.  */
5151   initialize_tdesc_s390_linux32 ();
5152   initialize_tdesc_s390_linux32v1 ();
5153   initialize_tdesc_s390_linux32v2 ();
5154   initialize_tdesc_s390_linux64 ();
5155   initialize_tdesc_s390_linux64v1 ();
5156   initialize_tdesc_s390_linux64v2 ();
5157   initialize_tdesc_s390_te_linux64 ();
5158   initialize_tdesc_s390_vx_linux64 ();
5159   initialize_tdesc_s390_tevx_linux64 ();
5160   initialize_tdesc_s390_gs_linux64 ();
5161   initialize_tdesc_s390x_linux64 ();
5162   initialize_tdesc_s390x_linux64v1 ();
5163   initialize_tdesc_s390x_linux64v2 ();
5164   initialize_tdesc_s390x_te_linux64 ();
5165   initialize_tdesc_s390x_vx_linux64 ();
5166   initialize_tdesc_s390x_tevx_linux64 ();
5167   initialize_tdesc_s390x_gs_linux64 ();
5168 }