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