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