1 /* Target-dependent code for GNU/Linux i386. 2 3 Copyright (C) 2000-2023 Free Software Foundation, Inc. 4 5 This file is part of GDB. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20 #include "defs.h" 21 #include "gdbcore.h" 22 #include "frame.h" 23 #include "value.h" 24 #include "regcache.h" 25 #include "regset.h" 26 #include "inferior.h" 27 #include "osabi.h" 28 #include "reggroups.h" 29 #include "dwarf2/frame.h" 30 #include "i386-tdep.h" 31 #include "i386-linux-tdep.h" 32 #include "linux-tdep.h" 33 #include "utils.h" 34 #include "glibc-tdep.h" 35 #include "solib-svr4.h" 36 #include "symtab.h" 37 #include "arch-utils.h" 38 #include "xml-syscall.h" 39 #include "infrun.h" 40 41 #include "i387-tdep.h" 42 #include "gdbsupport/x86-xstate.h" 43 44 /* The syscall's XML filename for i386. */ 45 #define XML_SYSCALL_FILENAME_I386 "syscalls/i386-linux.xml" 46 47 #include "record-full.h" 48 #include "linux-record.h" 49 50 #include "arch/i386.h" 51 #include "target-descriptions.h" 52 53 /* Return non-zero, when the register is in the corresponding register 54 group. Put the LINUX_ORIG_EAX register in the system group. */ 55 static int 56 i386_linux_register_reggroup_p (struct gdbarch *gdbarch, int regnum, 57 const struct reggroup *group) 58 { 59 if (regnum == I386_LINUX_ORIG_EAX_REGNUM) 60 return (group == system_reggroup 61 || group == save_reggroup 62 || group == restore_reggroup); 63 return i386_register_reggroup_p (gdbarch, regnum, group); 64 } 65 66 67 /* Recognizing signal handler frames. */ 68 69 /* GNU/Linux has two flavors of signals. Normal signal handlers, and 70 "realtime" (RT) signals. The RT signals can provide additional 71 information to the signal handler if the SA_SIGINFO flag is set 72 when establishing a signal handler using `sigaction'. It is not 73 unlikely that future versions of GNU/Linux will support SA_SIGINFO 74 for normal signals too. */ 75 76 /* When the i386 Linux kernel calls a signal handler and the 77 SA_RESTORER flag isn't set, the return address points to a bit of 78 code on the stack. This function returns whether the PC appears to 79 be within this bit of code. 80 81 The instruction sequence for normal signals is 82 pop %eax 83 mov $0x77, %eax 84 int $0x80 85 or 0x58 0xb8 0x77 0x00 0x00 0x00 0xcd 0x80. 86 87 Checking for the code sequence should be somewhat reliable, because 88 the effect is to call the system call sigreturn. This is unlikely 89 to occur anywhere other than in a signal trampoline. 90 91 It kind of sucks that we have to read memory from the process in 92 order to identify a signal trampoline, but there doesn't seem to be 93 any other way. Therefore we only do the memory reads if no 94 function name could be identified, which should be the case since 95 the code is on the stack. 96 97 Detection of signal trampolines for handlers that set the 98 SA_RESTORER flag is in general not possible. Unfortunately this is 99 what the GNU C Library has been doing for quite some time now. 100 However, as of version 2.1.2, the GNU C Library uses signal 101 trampolines (named __restore and __restore_rt) that are identical 102 to the ones used by the kernel. Therefore, these trampolines are 103 supported too. */ 104 105 #define LINUX_SIGTRAMP_INSN0 0x58 /* pop %eax */ 106 #define LINUX_SIGTRAMP_OFFSET0 0 107 #define LINUX_SIGTRAMP_INSN1 0xb8 /* mov $NNNN, %eax */ 108 #define LINUX_SIGTRAMP_OFFSET1 1 109 #define LINUX_SIGTRAMP_INSN2 0xcd /* int */ 110 #define LINUX_SIGTRAMP_OFFSET2 6 111 112 static const gdb_byte linux_sigtramp_code[] = 113 { 114 LINUX_SIGTRAMP_INSN0, /* pop %eax */ 115 LINUX_SIGTRAMP_INSN1, 0x77, 0x00, 0x00, 0x00, /* mov $0x77, %eax */ 116 LINUX_SIGTRAMP_INSN2, 0x80 /* int $0x80 */ 117 }; 118 119 #define LINUX_SIGTRAMP_LEN (sizeof linux_sigtramp_code) 120 121 /* If THIS_FRAME is a sigtramp routine, return the address of the 122 start of the routine. Otherwise, return 0. */ 123 124 static CORE_ADDR 125 i386_linux_sigtramp_start (frame_info_ptr this_frame) 126 { 127 CORE_ADDR pc = get_frame_pc (this_frame); 128 gdb_byte buf[LINUX_SIGTRAMP_LEN]; 129 130 /* We only recognize a signal trampoline if PC is at the start of 131 one of the three instructions. We optimize for finding the PC at 132 the start, as will be the case when the trampoline is not the 133 first frame on the stack. We assume that in the case where the 134 PC is not at the start of the instruction sequence, there will be 135 a few trailing readable bytes on the stack. */ 136 137 if (!safe_frame_unwind_memory (this_frame, pc, buf)) 138 return 0; 139 140 if (buf[0] != LINUX_SIGTRAMP_INSN0) 141 { 142 int adjust; 143 144 switch (buf[0]) 145 { 146 case LINUX_SIGTRAMP_INSN1: 147 adjust = LINUX_SIGTRAMP_OFFSET1; 148 break; 149 case LINUX_SIGTRAMP_INSN2: 150 adjust = LINUX_SIGTRAMP_OFFSET2; 151 break; 152 default: 153 return 0; 154 } 155 156 pc -= adjust; 157 158 if (!safe_frame_unwind_memory (this_frame, pc, buf)) 159 return 0; 160 } 161 162 if (memcmp (buf, linux_sigtramp_code, LINUX_SIGTRAMP_LEN) != 0) 163 return 0; 164 165 return pc; 166 } 167 168 /* This function does the same for RT signals. Here the instruction 169 sequence is 170 mov $0xad, %eax 171 int $0x80 172 or 0xb8 0xad 0x00 0x00 0x00 0xcd 0x80. 173 174 The effect is to call the system call rt_sigreturn. */ 175 176 #define LINUX_RT_SIGTRAMP_INSN0 0xb8 /* mov $NNNN, %eax */ 177 #define LINUX_RT_SIGTRAMP_OFFSET0 0 178 #define LINUX_RT_SIGTRAMP_INSN1 0xcd /* int */ 179 #define LINUX_RT_SIGTRAMP_OFFSET1 5 180 181 static const gdb_byte linux_rt_sigtramp_code[] = 182 { 183 LINUX_RT_SIGTRAMP_INSN0, 0xad, 0x00, 0x00, 0x00, /* mov $0xad, %eax */ 184 LINUX_RT_SIGTRAMP_INSN1, 0x80 /* int $0x80 */ 185 }; 186 187 #define LINUX_RT_SIGTRAMP_LEN (sizeof linux_rt_sigtramp_code) 188 189 /* If THIS_FRAME is an RT sigtramp routine, return the address of the 190 start of the routine. Otherwise, return 0. */ 191 192 static CORE_ADDR 193 i386_linux_rt_sigtramp_start (frame_info_ptr this_frame) 194 { 195 CORE_ADDR pc = get_frame_pc (this_frame); 196 gdb_byte buf[LINUX_RT_SIGTRAMP_LEN]; 197 198 /* We only recognize a signal trampoline if PC is at the start of 199 one of the two instructions. We optimize for finding the PC at 200 the start, as will be the case when the trampoline is not the 201 first frame on the stack. We assume that in the case where the 202 PC is not at the start of the instruction sequence, there will be 203 a few trailing readable bytes on the stack. */ 204 205 if (!safe_frame_unwind_memory (this_frame, pc, buf)) 206 return 0; 207 208 if (buf[0] != LINUX_RT_SIGTRAMP_INSN0) 209 { 210 if (buf[0] != LINUX_RT_SIGTRAMP_INSN1) 211 return 0; 212 213 pc -= LINUX_RT_SIGTRAMP_OFFSET1; 214 215 if (!safe_frame_unwind_memory (this_frame, pc, 216 buf)) 217 return 0; 218 } 219 220 if (memcmp (buf, linux_rt_sigtramp_code, LINUX_RT_SIGTRAMP_LEN) != 0) 221 return 0; 222 223 return pc; 224 } 225 226 /* Return whether THIS_FRAME corresponds to a GNU/Linux sigtramp 227 routine. */ 228 229 static int 230 i386_linux_sigtramp_p (frame_info_ptr this_frame) 231 { 232 CORE_ADDR pc = get_frame_pc (this_frame); 233 const char *name; 234 235 find_pc_partial_function (pc, &name, NULL, NULL); 236 237 /* If we have NAME, we can optimize the search. The trampolines are 238 named __restore and __restore_rt. However, they aren't dynamically 239 exported from the shared C library, so the trampoline may appear to 240 be part of the preceding function. This should always be sigaction, 241 __sigaction, or __libc_sigaction (all aliases to the same function). */ 242 if (name == NULL || strstr (name, "sigaction") != NULL) 243 return (i386_linux_sigtramp_start (this_frame) != 0 244 || i386_linux_rt_sigtramp_start (this_frame) != 0); 245 246 return (strcmp ("__restore", name) == 0 247 || strcmp ("__restore_rt", name) == 0); 248 } 249 250 /* Return one if the PC of THIS_FRAME is in a signal trampoline which 251 may have DWARF-2 CFI. */ 252 253 static int 254 i386_linux_dwarf_signal_frame_p (struct gdbarch *gdbarch, 255 frame_info_ptr this_frame) 256 { 257 CORE_ADDR pc = get_frame_pc (this_frame); 258 const char *name; 259 260 find_pc_partial_function (pc, &name, NULL, NULL); 261 262 /* If a vsyscall DSO is in use, the signal trampolines may have these 263 names. */ 264 if (name && (strcmp (name, "__kernel_sigreturn") == 0 265 || strcmp (name, "__kernel_rt_sigreturn") == 0)) 266 return 1; 267 268 return 0; 269 } 270 271 /* Offset to struct sigcontext in ucontext, from <asm/ucontext.h>. */ 272 #define I386_LINUX_UCONTEXT_SIGCONTEXT_OFFSET 20 273 274 /* Assuming THIS_FRAME is a GNU/Linux sigtramp routine, return the 275 address of the associated sigcontext structure. */ 276 277 static CORE_ADDR 278 i386_linux_sigcontext_addr (frame_info_ptr this_frame) 279 { 280 struct gdbarch *gdbarch = get_frame_arch (this_frame); 281 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 282 CORE_ADDR pc; 283 CORE_ADDR sp; 284 gdb_byte buf[4]; 285 286 get_frame_register (this_frame, I386_ESP_REGNUM, buf); 287 sp = extract_unsigned_integer (buf, 4, byte_order); 288 289 pc = i386_linux_sigtramp_start (this_frame); 290 if (pc) 291 { 292 /* The sigcontext structure lives on the stack, right after 293 the signum argument. We determine the address of the 294 sigcontext structure by looking at the frame's stack 295 pointer. Keep in mind that the first instruction of the 296 sigtramp code is "pop %eax". If the PC is after this 297 instruction, adjust the returned value accordingly. */ 298 if (pc == get_frame_pc (this_frame)) 299 return sp + 4; 300 return sp; 301 } 302 303 pc = i386_linux_rt_sigtramp_start (this_frame); 304 if (pc) 305 { 306 CORE_ADDR ucontext_addr; 307 308 /* The sigcontext structure is part of the user context. A 309 pointer to the user context is passed as the third argument 310 to the signal handler. */ 311 read_memory (sp + 8, buf, 4); 312 ucontext_addr = extract_unsigned_integer (buf, 4, byte_order); 313 return ucontext_addr + I386_LINUX_UCONTEXT_SIGCONTEXT_OFFSET; 314 } 315 316 error (_("Couldn't recognize signal trampoline.")); 317 return 0; 318 } 319 320 /* Set the program counter for process PTID to PC. */ 321 322 static void 323 i386_linux_write_pc (struct regcache *regcache, CORE_ADDR pc) 324 { 325 regcache_cooked_write_unsigned (regcache, I386_EIP_REGNUM, pc); 326 327 /* We must be careful with modifying the program counter. If we 328 just interrupted a system call, the kernel might try to restart 329 it when we resume the inferior. On restarting the system call, 330 the kernel will try backing up the program counter even though it 331 no longer points at the system call. This typically results in a 332 SIGSEGV or SIGILL. We can prevent this by writing `-1' in the 333 "orig_eax" pseudo-register. 334 335 Note that "orig_eax" is saved when setting up a dummy call frame. 336 This means that it is properly restored when that frame is 337 popped, and that the interrupted system call will be restarted 338 when we resume the inferior on return from a function call from 339 within GDB. In all other cases the system call will not be 340 restarted. */ 341 regcache_cooked_write_unsigned (regcache, I386_LINUX_ORIG_EAX_REGNUM, -1); 342 } 343 344 /* Record all registers but IP register for process-record. */ 345 346 static int 347 i386_all_but_ip_registers_record (struct regcache *regcache) 348 { 349 if (record_full_arch_list_add_reg (regcache, I386_EAX_REGNUM)) 350 return -1; 351 if (record_full_arch_list_add_reg (regcache, I386_ECX_REGNUM)) 352 return -1; 353 if (record_full_arch_list_add_reg (regcache, I386_EDX_REGNUM)) 354 return -1; 355 if (record_full_arch_list_add_reg (regcache, I386_EBX_REGNUM)) 356 return -1; 357 if (record_full_arch_list_add_reg (regcache, I386_ESP_REGNUM)) 358 return -1; 359 if (record_full_arch_list_add_reg (regcache, I386_EBP_REGNUM)) 360 return -1; 361 if (record_full_arch_list_add_reg (regcache, I386_ESI_REGNUM)) 362 return -1; 363 if (record_full_arch_list_add_reg (regcache, I386_EDI_REGNUM)) 364 return -1; 365 if (record_full_arch_list_add_reg (regcache, I386_EFLAGS_REGNUM)) 366 return -1; 367 368 return 0; 369 } 370 371 /* i386_canonicalize_syscall maps from the native i386 Linux set 372 of syscall ids into a canonical set of syscall ids used by 373 process record (a mostly trivial mapping, since the canonical 374 set was originally taken from the i386 set). */ 375 376 static enum gdb_syscall 377 i386_canonicalize_syscall (int syscall) 378 { 379 enum { i386_syscall_max = 499 }; 380 381 if (syscall <= i386_syscall_max) 382 return (enum gdb_syscall) syscall; 383 else 384 return gdb_sys_no_syscall; 385 } 386 387 /* Value of the sigcode in case of a boundary fault. */ 388 389 #define SIG_CODE_BONDARY_FAULT 3 390 391 /* i386 GNU/Linux implementation of the report_signal_info 392 gdbarch hook. Displays information related to MPX bound 393 violations. */ 394 void 395 i386_linux_report_signal_info (struct gdbarch *gdbarch, struct ui_out *uiout, 396 enum gdb_signal siggnal) 397 { 398 /* -Wmaybe-uninitialized */ 399 CORE_ADDR lower_bound = 0, upper_bound = 0, access = 0; 400 int is_upper; 401 long sig_code = 0; 402 403 if (!i386_mpx_enabled () || siggnal != GDB_SIGNAL_SEGV) 404 return; 405 406 try 407 { 408 /* Sigcode evaluates if the actual segfault is a boundary violation. */ 409 sig_code = parse_and_eval_long ("$_siginfo.si_code\n"); 410 411 lower_bound 412 = parse_and_eval_long ("$_siginfo._sifields._sigfault._addr_bnd._lower"); 413 upper_bound 414 = parse_and_eval_long ("$_siginfo._sifields._sigfault._addr_bnd._upper"); 415 access 416 = parse_and_eval_long ("$_siginfo._sifields._sigfault.si_addr"); 417 } 418 catch (const gdb_exception &exception) 419 { 420 return; 421 } 422 423 /* If this is not a boundary violation just return. */ 424 if (sig_code != SIG_CODE_BONDARY_FAULT) 425 return; 426 427 is_upper = (access > upper_bound ? 1 : 0); 428 429 uiout->text ("\n"); 430 if (is_upper) 431 uiout->field_string ("sigcode-meaning", _("Upper bound violation")); 432 else 433 uiout->field_string ("sigcode-meaning", _("Lower bound violation")); 434 435 uiout->text (_(" while accessing address ")); 436 uiout->field_core_addr ("bound-access", gdbarch, access); 437 438 uiout->text (_("\nBounds: [lower = ")); 439 uiout->field_core_addr ("lower-bound", gdbarch, lower_bound); 440 441 uiout->text (_(", upper = ")); 442 uiout->field_core_addr ("upper-bound", gdbarch, upper_bound); 443 444 uiout->text (_("]")); 445 } 446 447 /* Parse the arguments of current system call instruction and record 448 the values of the registers and memory that will be changed into 449 "record_arch_list". This instruction is "int 0x80" (Linux 450 Kernel2.4) or "sysenter" (Linux Kernel 2.6). 451 452 Return -1 if something wrong. */ 453 454 static struct linux_record_tdep i386_linux_record_tdep; 455 456 static int 457 i386_linux_intx80_sysenter_syscall_record (struct regcache *regcache) 458 { 459 int ret; 460 LONGEST syscall_native; 461 enum gdb_syscall syscall_gdb; 462 463 regcache_raw_read_signed (regcache, I386_EAX_REGNUM, &syscall_native); 464 465 syscall_gdb = i386_canonicalize_syscall (syscall_native); 466 467 if (syscall_gdb < 0) 468 { 469 gdb_printf (gdb_stderr, 470 _("Process record and replay target doesn't " 471 "support syscall number %s\n"), 472 plongest (syscall_native)); 473 return -1; 474 } 475 476 if (syscall_gdb == gdb_sys_sigreturn 477 || syscall_gdb == gdb_sys_rt_sigreturn) 478 { 479 if (i386_all_but_ip_registers_record (regcache)) 480 return -1; 481 return 0; 482 } 483 484 ret = record_linux_system_call (syscall_gdb, regcache, 485 &i386_linux_record_tdep); 486 if (ret) 487 return ret; 488 489 /* Record the return value of the system call. */ 490 if (record_full_arch_list_add_reg (regcache, I386_EAX_REGNUM)) 491 return -1; 492 493 return 0; 494 } 495 496 #define I386_LINUX_xstate 270 497 #define I386_LINUX_frame_size 732 498 499 static int 500 i386_linux_record_signal (struct gdbarch *gdbarch, 501 struct regcache *regcache, 502 enum gdb_signal signal) 503 { 504 ULONGEST esp; 505 506 if (i386_all_but_ip_registers_record (regcache)) 507 return -1; 508 509 if (record_full_arch_list_add_reg (regcache, I386_EIP_REGNUM)) 510 return -1; 511 512 /* Record the change in the stack. */ 513 regcache_raw_read_unsigned (regcache, I386_ESP_REGNUM, &esp); 514 /* This is for xstate. 515 sp -= sizeof (struct _fpstate); */ 516 esp -= I386_LINUX_xstate; 517 /* This is for frame_size. 518 sp -= sizeof (struct rt_sigframe); */ 519 esp -= I386_LINUX_frame_size; 520 if (record_full_arch_list_add_mem (esp, 521 I386_LINUX_xstate + I386_LINUX_frame_size)) 522 return -1; 523 524 if (record_full_arch_list_add_end ()) 525 return -1; 526 527 return 0; 528 } 529 530 531 /* Core of the implementation for gdbarch get_syscall_number. Get pending 532 syscall number from REGCACHE. If there is no pending syscall -1 will be 533 returned. Pending syscall means ptrace has stepped into the syscall but 534 another ptrace call will step out. PC is right after the int $0x80 535 / syscall / sysenter instruction in both cases, PC does not change during 536 the second ptrace step. */ 537 538 static LONGEST 539 i386_linux_get_syscall_number_from_regcache (struct regcache *regcache) 540 { 541 struct gdbarch *gdbarch = regcache->arch (); 542 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 543 /* The content of a register. */ 544 gdb_byte buf[4]; 545 /* The result. */ 546 LONGEST ret; 547 548 /* Getting the system call number from the register. 549 When dealing with x86 architecture, this information 550 is stored at %eax register. */ 551 regcache->cooked_read (I386_LINUX_ORIG_EAX_REGNUM, buf); 552 553 ret = extract_signed_integer (buf, byte_order); 554 555 return ret; 556 } 557 558 /* Wrapper for i386_linux_get_syscall_number_from_regcache to make it 559 compatible with gdbarch get_syscall_number method prototype. */ 560 561 static LONGEST 562 i386_linux_get_syscall_number (struct gdbarch *gdbarch, 563 thread_info *thread) 564 { 565 struct regcache *regcache = get_thread_regcache (thread); 566 567 return i386_linux_get_syscall_number_from_regcache (regcache); 568 } 569 570 /* The register sets used in GNU/Linux ELF core-dumps are identical to 571 the register sets in `struct user' that are used for a.out 572 core-dumps. These are also used by ptrace(2). The corresponding 573 types are `elf_gregset_t' for the general-purpose registers (with 574 `elf_greg_t' the type of a single GP register) and `elf_fpregset_t' 575 for the floating-point registers. 576 577 Those types used to be available under the names `gregset_t' and 578 `fpregset_t' too, and GDB used those names in the past. But those 579 names are now used for the register sets used in the `mcontext_t' 580 type, which have a different size and layout. */ 581 582 /* Mapping between the general-purpose registers in `struct user' 583 format and GDB's register cache layout. */ 584 585 /* From <sys/reg.h>. */ 586 int i386_linux_gregset_reg_offset[] = 587 { 588 6 * 4, /* %eax */ 589 1 * 4, /* %ecx */ 590 2 * 4, /* %edx */ 591 0 * 4, /* %ebx */ 592 15 * 4, /* %esp */ 593 5 * 4, /* %ebp */ 594 3 * 4, /* %esi */ 595 4 * 4, /* %edi */ 596 12 * 4, /* %eip */ 597 14 * 4, /* %eflags */ 598 13 * 4, /* %cs */ 599 16 * 4, /* %ss */ 600 7 * 4, /* %ds */ 601 8 * 4, /* %es */ 602 9 * 4, /* %fs */ 603 10 * 4, /* %gs */ 604 -1, -1, -1, -1, -1, -1, -1, -1, 605 -1, -1, -1, -1, -1, -1, -1, -1, 606 -1, -1, -1, -1, -1, -1, -1, -1, 607 -1, 608 -1, -1, -1, -1, -1, -1, -1, -1, 609 -1, -1, -1, -1, /* MPX registers BND0 ... BND3. */ 610 -1, -1, /* MPX registers BNDCFGU, BNDSTATUS. */ 611 -1, -1, -1, -1, -1, -1, -1, -1, /* k0 ... k7 (AVX512) */ 612 -1, -1, -1, -1, -1, -1, -1, -1, /* zmm0 ... zmm7 (AVX512) */ 613 -1, /* PKRU register */ 614 11 * 4, /* "orig_eax" */ 615 }; 616 617 /* Mapping between the general-purpose registers in `struct 618 sigcontext' format and GDB's register cache layout. */ 619 620 /* From <asm/sigcontext.h>. */ 621 static int i386_linux_sc_reg_offset[] = 622 { 623 11 * 4, /* %eax */ 624 10 * 4, /* %ecx */ 625 9 * 4, /* %edx */ 626 8 * 4, /* %ebx */ 627 7 * 4, /* %esp */ 628 6 * 4, /* %ebp */ 629 5 * 4, /* %esi */ 630 4 * 4, /* %edi */ 631 14 * 4, /* %eip */ 632 16 * 4, /* %eflags */ 633 15 * 4, /* %cs */ 634 18 * 4, /* %ss */ 635 3 * 4, /* %ds */ 636 2 * 4, /* %es */ 637 1 * 4, /* %fs */ 638 0 * 4 /* %gs */ 639 }; 640 641 /* Get XSAVE extended state xcr0 from core dump. */ 642 643 uint64_t 644 i386_linux_core_read_xcr0 (bfd *abfd) 645 { 646 asection *xstate = bfd_get_section_by_name (abfd, ".reg-xstate"); 647 uint64_t xcr0; 648 649 if (xstate) 650 { 651 size_t size = bfd_section_size (xstate); 652 653 /* Check extended state size. */ 654 if (size < X86_XSTATE_AVX_SIZE) 655 xcr0 = X86_XSTATE_SSE_MASK; 656 else 657 { 658 char contents[8]; 659 660 if (! bfd_get_section_contents (abfd, xstate, contents, 661 I386_LINUX_XSAVE_XCR0_OFFSET, 662 8)) 663 { 664 warning (_("Couldn't read `xcr0' bytes from " 665 "`.reg-xstate' section in core file.")); 666 return 0; 667 } 668 669 xcr0 = bfd_get_64 (abfd, contents); 670 } 671 } 672 else 673 xcr0 = 0; 674 675 return xcr0; 676 } 677 678 /* See i386-linux-tdep.h. */ 679 680 const struct target_desc * 681 i386_linux_read_description (uint64_t xcr0) 682 { 683 if (xcr0 == 0) 684 return NULL; 685 686 static struct target_desc *i386_linux_tdescs \ 687 [2/*X87*/][2/*SSE*/][2/*AVX*/][2/*MPX*/][2/*AVX512*/][2/*PKRU*/] = {}; 688 struct target_desc **tdesc; 689 690 tdesc = &i386_linux_tdescs[(xcr0 & X86_XSTATE_X87) ? 1 : 0] 691 [(xcr0 & X86_XSTATE_SSE) ? 1 : 0] 692 [(xcr0 & X86_XSTATE_AVX) ? 1 : 0] 693 [(xcr0 & X86_XSTATE_MPX) ? 1 : 0] 694 [(xcr0 & X86_XSTATE_AVX512) ? 1 : 0] 695 [(xcr0 & X86_XSTATE_PKRU) ? 1 : 0]; 696 697 if (*tdesc == NULL) 698 *tdesc = i386_create_target_description (xcr0, true, false); 699 700 return *tdesc; 701 } 702 703 /* Get Linux/x86 target description from core dump. */ 704 705 static const struct target_desc * 706 i386_linux_core_read_description (struct gdbarch *gdbarch, 707 struct target_ops *target, 708 bfd *abfd) 709 { 710 /* Linux/i386. */ 711 uint64_t xcr0 = i386_linux_core_read_xcr0 (abfd); 712 const struct target_desc *tdesc = i386_linux_read_description (xcr0); 713 714 if (tdesc != NULL) 715 return tdesc; 716 717 if (bfd_get_section_by_name (abfd, ".reg-xfp") != NULL) 718 return i386_linux_read_description (X86_XSTATE_SSE_MASK); 719 else 720 return i386_linux_read_description (X86_XSTATE_X87_MASK); 721 } 722 723 /* Similar to i386_supply_fpregset, but use XSAVE extended state. */ 724 725 static void 726 i386_linux_supply_xstateregset (const struct regset *regset, 727 struct regcache *regcache, int regnum, 728 const void *xstateregs, size_t len) 729 { 730 i387_supply_xsave (regcache, regnum, xstateregs); 731 } 732 733 struct type * 734 x86_linux_get_siginfo_type (struct gdbarch *gdbarch) 735 { 736 return linux_get_siginfo_type_with_fields (gdbarch, LINUX_SIGINFO_FIELD_ADDR_BND); 737 } 738 739 /* Similar to i386_collect_fpregset, but use XSAVE extended state. */ 740 741 static void 742 i386_linux_collect_xstateregset (const struct regset *regset, 743 const struct regcache *regcache, 744 int regnum, void *xstateregs, size_t len) 745 { 746 i387_collect_xsave (regcache, regnum, xstateregs, 1); 747 } 748 749 /* Register set definitions. */ 750 751 static const struct regset i386_linux_xstateregset = 752 { 753 NULL, 754 i386_linux_supply_xstateregset, 755 i386_linux_collect_xstateregset 756 }; 757 758 /* Iterate over core file register note sections. */ 759 760 static void 761 i386_linux_iterate_over_regset_sections (struct gdbarch *gdbarch, 762 iterate_over_regset_sections_cb *cb, 763 void *cb_data, 764 const struct regcache *regcache) 765 { 766 i386_gdbarch_tdep *tdep = gdbarch_tdep<i386_gdbarch_tdep> (gdbarch); 767 768 cb (".reg", 68, 68, &i386_gregset, NULL, cb_data); 769 770 if (tdep->xcr0 & X86_XSTATE_AVX) 771 cb (".reg-xstate", X86_XSTATE_SIZE (tdep->xcr0), 772 X86_XSTATE_SIZE (tdep->xcr0), &i386_linux_xstateregset, 773 "XSAVE extended state", cb_data); 774 else if (tdep->xcr0 & X86_XSTATE_SSE) 775 cb (".reg-xfp", 512, 512, &i386_fpregset, "extended floating-point", 776 cb_data); 777 else 778 cb (".reg2", 108, 108, &i386_fpregset, NULL, cb_data); 779 } 780 781 /* Linux kernel shows PC value after the 'int $0x80' instruction even if 782 inferior is still inside the syscall. On next PTRACE_SINGLESTEP it will 783 finish the syscall but PC will not change. 784 785 Some vDSOs contain 'int $0x80; ret' and during stepping out of the syscall 786 i386_displaced_step_fixup would keep PC at the displaced pad location. 787 As PC is pointing to the 'ret' instruction before the step 788 i386_displaced_step_fixup would expect inferior has just executed that 'ret' 789 and PC should not be adjusted. In reality it finished syscall instead and 790 PC should get relocated back to its vDSO address. Hide the 'ret' 791 instruction by 'nop' so that i386_displaced_step_fixup is not confused. 792 793 It is not fully correct as the bytes in struct 794 displaced_step_copy_insn_closure will not match the inferior code. But we 795 would need some new flag in displaced_step_copy_insn_closure otherwise to 796 keep the state that syscall is finishing for the later 797 i386_displaced_step_fixup execution as the syscall execution is already no 798 longer detectable there. The new flag field would mean i386-linux-tdep.c 799 needs to wrap all the displacement methods of i386-tdep.c which does not seem 800 worth it. The same effect is achieved by patching that 'nop' instruction 801 there instead. */ 802 803 static displaced_step_copy_insn_closure_up 804 i386_linux_displaced_step_copy_insn (struct gdbarch *gdbarch, 805 CORE_ADDR from, CORE_ADDR to, 806 struct regcache *regs) 807 { 808 displaced_step_copy_insn_closure_up closure_ 809 = i386_displaced_step_copy_insn (gdbarch, from, to, regs); 810 811 if (i386_linux_get_syscall_number_from_regcache (regs) != -1) 812 { 813 /* The closure returned by i386_displaced_step_copy_insn is simply a 814 buffer with a copy of the instruction. */ 815 i386_displaced_step_copy_insn_closure *closure 816 = (i386_displaced_step_copy_insn_closure *) closure_.get (); 817 818 /* Fake nop. */ 819 closure->buf[0] = 0x90; 820 } 821 822 return closure_; 823 } 824 825 static void 826 i386_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) 827 { 828 i386_gdbarch_tdep *tdep = gdbarch_tdep<i386_gdbarch_tdep> (gdbarch); 829 const struct target_desc *tdesc = info.target_desc; 830 struct tdesc_arch_data *tdesc_data = info.tdesc_data; 831 const struct tdesc_feature *feature; 832 int valid_p; 833 834 gdb_assert (tdesc_data); 835 836 linux_init_abi (info, gdbarch, 1); 837 838 /* GNU/Linux uses ELF. */ 839 i386_elf_init_abi (info, gdbarch); 840 841 /* Reserve a number for orig_eax. */ 842 set_gdbarch_num_regs (gdbarch, I386_LINUX_NUM_REGS); 843 844 if (! tdesc_has_registers (tdesc)) 845 tdesc = i386_linux_read_description (X86_XSTATE_SSE_MASK); 846 tdep->tdesc = tdesc; 847 848 feature = tdesc_find_feature (tdesc, "org.gnu.gdb.i386.linux"); 849 if (feature == NULL) 850 return; 851 852 valid_p = tdesc_numbered_register (feature, tdesc_data, 853 I386_LINUX_ORIG_EAX_REGNUM, 854 "orig_eax"); 855 if (!valid_p) 856 return; 857 858 /* Add the %orig_eax register used for syscall restarting. */ 859 set_gdbarch_write_pc (gdbarch, i386_linux_write_pc); 860 861 tdep->register_reggroup_p = i386_linux_register_reggroup_p; 862 863 tdep->gregset_reg_offset = i386_linux_gregset_reg_offset; 864 tdep->gregset_num_regs = ARRAY_SIZE (i386_linux_gregset_reg_offset); 865 tdep->sizeof_gregset = 17 * 4; 866 867 tdep->jb_pc_offset = 20; /* From <bits/setjmp.h>. */ 868 869 tdep->sigtramp_p = i386_linux_sigtramp_p; 870 tdep->sigcontext_addr = i386_linux_sigcontext_addr; 871 tdep->sc_reg_offset = i386_linux_sc_reg_offset; 872 tdep->sc_num_regs = ARRAY_SIZE (i386_linux_sc_reg_offset); 873 874 tdep->xsave_xcr0_offset = I386_LINUX_XSAVE_XCR0_OFFSET; 875 876 set_gdbarch_process_record (gdbarch, i386_process_record); 877 set_gdbarch_process_record_signal (gdbarch, i386_linux_record_signal); 878 879 /* Initialize the i386_linux_record_tdep. */ 880 /* These values are the size of the type that will be used in a system 881 call. They are obtained from Linux Kernel source. */ 882 i386_linux_record_tdep.size_pointer 883 = gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT; 884 i386_linux_record_tdep.size__old_kernel_stat = 32; 885 i386_linux_record_tdep.size_tms = 16; 886 i386_linux_record_tdep.size_loff_t = 8; 887 i386_linux_record_tdep.size_flock = 16; 888 i386_linux_record_tdep.size_oldold_utsname = 45; 889 i386_linux_record_tdep.size_ustat = 20; 890 i386_linux_record_tdep.size_old_sigaction = 16; 891 i386_linux_record_tdep.size_old_sigset_t = 4; 892 i386_linux_record_tdep.size_rlimit = 8; 893 i386_linux_record_tdep.size_rusage = 72; 894 i386_linux_record_tdep.size_timeval = 8; 895 i386_linux_record_tdep.size_timezone = 8; 896 i386_linux_record_tdep.size_old_gid_t = 2; 897 i386_linux_record_tdep.size_old_uid_t = 2; 898 i386_linux_record_tdep.size_fd_set = 128; 899 i386_linux_record_tdep.size_old_dirent = 268; 900 i386_linux_record_tdep.size_statfs = 64; 901 i386_linux_record_tdep.size_statfs64 = 84; 902 i386_linux_record_tdep.size_sockaddr = 16; 903 i386_linux_record_tdep.size_int 904 = gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT; 905 i386_linux_record_tdep.size_long 906 = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT; 907 i386_linux_record_tdep.size_ulong 908 = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT; 909 i386_linux_record_tdep.size_msghdr = 28; 910 i386_linux_record_tdep.size_itimerval = 16; 911 i386_linux_record_tdep.size_stat = 88; 912 i386_linux_record_tdep.size_old_utsname = 325; 913 i386_linux_record_tdep.size_sysinfo = 64; 914 i386_linux_record_tdep.size_msqid_ds = 88; 915 i386_linux_record_tdep.size_shmid_ds = 84; 916 i386_linux_record_tdep.size_new_utsname = 390; 917 i386_linux_record_tdep.size_timex = 128; 918 i386_linux_record_tdep.size_mem_dqinfo = 24; 919 i386_linux_record_tdep.size_if_dqblk = 68; 920 i386_linux_record_tdep.size_fs_quota_stat = 68; 921 i386_linux_record_tdep.size_timespec = 8; 922 i386_linux_record_tdep.size_pollfd = 8; 923 i386_linux_record_tdep.size_NFS_FHSIZE = 32; 924 i386_linux_record_tdep.size_knfsd_fh = 132; 925 i386_linux_record_tdep.size_TASK_COMM_LEN = 16; 926 i386_linux_record_tdep.size_sigaction = 20; 927 i386_linux_record_tdep.size_sigset_t = 8; 928 i386_linux_record_tdep.size_siginfo_t = 128; 929 i386_linux_record_tdep.size_cap_user_data_t = 12; 930 i386_linux_record_tdep.size_stack_t = 12; 931 i386_linux_record_tdep.size_off_t = i386_linux_record_tdep.size_long; 932 i386_linux_record_tdep.size_stat64 = 96; 933 i386_linux_record_tdep.size_gid_t = 4; 934 i386_linux_record_tdep.size_uid_t = 4; 935 i386_linux_record_tdep.size_PAGE_SIZE = 4096; 936 i386_linux_record_tdep.size_flock64 = 24; 937 i386_linux_record_tdep.size_user_desc = 16; 938 i386_linux_record_tdep.size_io_event = 32; 939 i386_linux_record_tdep.size_iocb = 64; 940 i386_linux_record_tdep.size_epoll_event = 12; 941 i386_linux_record_tdep.size_itimerspec 942 = i386_linux_record_tdep.size_timespec * 2; 943 i386_linux_record_tdep.size_mq_attr = 32; 944 i386_linux_record_tdep.size_termios = 36; 945 i386_linux_record_tdep.size_termios2 = 44; 946 i386_linux_record_tdep.size_pid_t = 4; 947 i386_linux_record_tdep.size_winsize = 8; 948 i386_linux_record_tdep.size_serial_struct = 60; 949 i386_linux_record_tdep.size_serial_icounter_struct = 80; 950 i386_linux_record_tdep.size_hayes_esp_config = 12; 951 i386_linux_record_tdep.size_size_t = 4; 952 i386_linux_record_tdep.size_iovec = 8; 953 i386_linux_record_tdep.size_time_t = 4; 954 955 /* These values are the second argument of system call "sys_ioctl". 956 They are obtained from Linux Kernel source. */ 957 i386_linux_record_tdep.ioctl_TCGETS = 0x5401; 958 i386_linux_record_tdep.ioctl_TCSETS = 0x5402; 959 i386_linux_record_tdep.ioctl_TCSETSW = 0x5403; 960 i386_linux_record_tdep.ioctl_TCSETSF = 0x5404; 961 i386_linux_record_tdep.ioctl_TCGETA = 0x5405; 962 i386_linux_record_tdep.ioctl_TCSETA = 0x5406; 963 i386_linux_record_tdep.ioctl_TCSETAW = 0x5407; 964 i386_linux_record_tdep.ioctl_TCSETAF = 0x5408; 965 i386_linux_record_tdep.ioctl_TCSBRK = 0x5409; 966 i386_linux_record_tdep.ioctl_TCXONC = 0x540A; 967 i386_linux_record_tdep.ioctl_TCFLSH = 0x540B; 968 i386_linux_record_tdep.ioctl_TIOCEXCL = 0x540C; 969 i386_linux_record_tdep.ioctl_TIOCNXCL = 0x540D; 970 i386_linux_record_tdep.ioctl_TIOCSCTTY = 0x540E; 971 i386_linux_record_tdep.ioctl_TIOCGPGRP = 0x540F; 972 i386_linux_record_tdep.ioctl_TIOCSPGRP = 0x5410; 973 i386_linux_record_tdep.ioctl_TIOCOUTQ = 0x5411; 974 i386_linux_record_tdep.ioctl_TIOCSTI = 0x5412; 975 i386_linux_record_tdep.ioctl_TIOCGWINSZ = 0x5413; 976 i386_linux_record_tdep.ioctl_TIOCSWINSZ = 0x5414; 977 i386_linux_record_tdep.ioctl_TIOCMGET = 0x5415; 978 i386_linux_record_tdep.ioctl_TIOCMBIS = 0x5416; 979 i386_linux_record_tdep.ioctl_TIOCMBIC = 0x5417; 980 i386_linux_record_tdep.ioctl_TIOCMSET = 0x5418; 981 i386_linux_record_tdep.ioctl_TIOCGSOFTCAR = 0x5419; 982 i386_linux_record_tdep.ioctl_TIOCSSOFTCAR = 0x541A; 983 i386_linux_record_tdep.ioctl_FIONREAD = 0x541B; 984 i386_linux_record_tdep.ioctl_TIOCINQ = i386_linux_record_tdep.ioctl_FIONREAD; 985 i386_linux_record_tdep.ioctl_TIOCLINUX = 0x541C; 986 i386_linux_record_tdep.ioctl_TIOCCONS = 0x541D; 987 i386_linux_record_tdep.ioctl_TIOCGSERIAL = 0x541E; 988 i386_linux_record_tdep.ioctl_TIOCSSERIAL = 0x541F; 989 i386_linux_record_tdep.ioctl_TIOCPKT = 0x5420; 990 i386_linux_record_tdep.ioctl_FIONBIO = 0x5421; 991 i386_linux_record_tdep.ioctl_TIOCNOTTY = 0x5422; 992 i386_linux_record_tdep.ioctl_TIOCSETD = 0x5423; 993 i386_linux_record_tdep.ioctl_TIOCGETD = 0x5424; 994 i386_linux_record_tdep.ioctl_TCSBRKP = 0x5425; 995 i386_linux_record_tdep.ioctl_TIOCTTYGSTRUCT = 0x5426; 996 i386_linux_record_tdep.ioctl_TIOCSBRK = 0x5427; 997 i386_linux_record_tdep.ioctl_TIOCCBRK = 0x5428; 998 i386_linux_record_tdep.ioctl_TIOCGSID = 0x5429; 999 i386_linux_record_tdep.ioctl_TCGETS2 = 0x802c542a; 1000 i386_linux_record_tdep.ioctl_TCSETS2 = 0x402c542b; 1001 i386_linux_record_tdep.ioctl_TCSETSW2 = 0x402c542c; 1002 i386_linux_record_tdep.ioctl_TCSETSF2 = 0x402c542d; 1003 i386_linux_record_tdep.ioctl_TIOCGPTN = 0x80045430; 1004 i386_linux_record_tdep.ioctl_TIOCSPTLCK = 0x40045431; 1005 i386_linux_record_tdep.ioctl_FIONCLEX = 0x5450; 1006 i386_linux_record_tdep.ioctl_FIOCLEX = 0x5451; 1007 i386_linux_record_tdep.ioctl_FIOASYNC = 0x5452; 1008 i386_linux_record_tdep.ioctl_TIOCSERCONFIG = 0x5453; 1009 i386_linux_record_tdep.ioctl_TIOCSERGWILD = 0x5454; 1010 i386_linux_record_tdep.ioctl_TIOCSERSWILD = 0x5455; 1011 i386_linux_record_tdep.ioctl_TIOCGLCKTRMIOS = 0x5456; 1012 i386_linux_record_tdep.ioctl_TIOCSLCKTRMIOS = 0x5457; 1013 i386_linux_record_tdep.ioctl_TIOCSERGSTRUCT = 0x5458; 1014 i386_linux_record_tdep.ioctl_TIOCSERGETLSR = 0x5459; 1015 i386_linux_record_tdep.ioctl_TIOCSERGETMULTI = 0x545A; 1016 i386_linux_record_tdep.ioctl_TIOCSERSETMULTI = 0x545B; 1017 i386_linux_record_tdep.ioctl_TIOCMIWAIT = 0x545C; 1018 i386_linux_record_tdep.ioctl_TIOCGICOUNT = 0x545D; 1019 i386_linux_record_tdep.ioctl_TIOCGHAYESESP = 0x545E; 1020 i386_linux_record_tdep.ioctl_TIOCSHAYESESP = 0x545F; 1021 i386_linux_record_tdep.ioctl_FIOQSIZE = 0x5460; 1022 1023 /* These values are the second argument of system call "sys_fcntl" 1024 and "sys_fcntl64". They are obtained from Linux Kernel source. */ 1025 i386_linux_record_tdep.fcntl_F_GETLK = 5; 1026 i386_linux_record_tdep.fcntl_F_GETLK64 = 12; 1027 i386_linux_record_tdep.fcntl_F_SETLK64 = 13; 1028 i386_linux_record_tdep.fcntl_F_SETLKW64 = 14; 1029 1030 i386_linux_record_tdep.arg1 = I386_EBX_REGNUM; 1031 i386_linux_record_tdep.arg2 = I386_ECX_REGNUM; 1032 i386_linux_record_tdep.arg3 = I386_EDX_REGNUM; 1033 i386_linux_record_tdep.arg4 = I386_ESI_REGNUM; 1034 i386_linux_record_tdep.arg5 = I386_EDI_REGNUM; 1035 i386_linux_record_tdep.arg6 = I386_EBP_REGNUM; 1036 1037 tdep->i386_intx80_record = i386_linux_intx80_sysenter_syscall_record; 1038 tdep->i386_sysenter_record = i386_linux_intx80_sysenter_syscall_record; 1039 tdep->i386_syscall_record = i386_linux_intx80_sysenter_syscall_record; 1040 1041 /* N_FUN symbols in shared libraries have 0 for their values and need 1042 to be relocated. */ 1043 set_gdbarch_sofun_address_maybe_missing (gdbarch, 1); 1044 1045 /* GNU/Linux uses SVR4-style shared libraries. */ 1046 set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target); 1047 set_solib_svr4_fetch_link_map_offsets 1048 (gdbarch, linux_ilp32_fetch_link_map_offsets); 1049 1050 /* GNU/Linux uses the dynamic linker included in the GNU C Library. */ 1051 set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver); 1052 1053 dwarf2_frame_set_signal_frame_p (gdbarch, i386_linux_dwarf_signal_frame_p); 1054 1055 /* Enable TLS support. */ 1056 set_gdbarch_fetch_tls_load_module_address (gdbarch, 1057 svr4_fetch_objfile_link_map); 1058 1059 /* Core file support. */ 1060 set_gdbarch_iterate_over_regset_sections 1061 (gdbarch, i386_linux_iterate_over_regset_sections); 1062 set_gdbarch_core_read_description (gdbarch, 1063 i386_linux_core_read_description); 1064 1065 /* Displaced stepping. */ 1066 set_gdbarch_displaced_step_copy_insn (gdbarch, 1067 i386_linux_displaced_step_copy_insn); 1068 set_gdbarch_displaced_step_fixup (gdbarch, i386_displaced_step_fixup); 1069 1070 /* Functions for 'catch syscall'. */ 1071 set_xml_syscall_file_name (gdbarch, XML_SYSCALL_FILENAME_I386); 1072 set_gdbarch_get_syscall_number (gdbarch, 1073 i386_linux_get_syscall_number); 1074 1075 set_gdbarch_get_siginfo_type (gdbarch, x86_linux_get_siginfo_type); 1076 set_gdbarch_report_signal_info (gdbarch, i386_linux_report_signal_info); 1077 } 1078 1079 void _initialize_i386_linux_tdep (); 1080 void 1081 _initialize_i386_linux_tdep () 1082 { 1083 gdbarch_register_osabi (bfd_arch_i386, 0, GDB_OSABI_LINUX, 1084 i386_linux_init_abi); 1085 } 1086