1 /* Darwin support for GDB, the GNU debugger. 2 Copyright (C) 1997-2020 Free Software Foundation, Inc. 3 4 Contributed by Apple Computer, Inc. 5 6 This file is part of GDB. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 3 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 20 21 #include "defs.h" 22 #include "frame.h" 23 #include "inferior.h" 24 #include "target.h" 25 #include "symfile.h" 26 #include "symtab.h" 27 #include "objfiles.h" 28 #include "gdbcmd.h" 29 #include "regcache.h" 30 #include "i386-tdep.h" 31 #include "i387-tdep.h" 32 #include "gdbarch.h" 33 #include "arch-utils.h" 34 #include "gdbcore.h" 35 36 #include "x86-nat.h" 37 #include "darwin-nat.h" 38 #include "i386-darwin-tdep.h" 39 40 #ifdef BFD64 41 #include "amd64-nat.h" 42 #include "amd64-tdep.h" 43 #include "amd64-darwin-tdep.h" 44 #endif 45 46 struct i386_darwin_nat_target final : public x86_nat_target<darwin_nat_target> 47 { 48 /* Add our register access methods. */ 49 void fetch_registers (struct regcache *, int) override; 50 void store_registers (struct regcache *, int) override; 51 }; 52 53 static struct i386_darwin_nat_target darwin_target; 54 55 /* Read register values from the inferior process. 56 If REGNO is -1, do this for all registers. 57 Otherwise, REGNO specifies which register (so we can save time). */ 58 59 void 60 i386_darwin_nat_target::fetch_registers (struct regcache *regcache, int regno) 61 { 62 thread_t current_thread = regcache->ptid ().tid (); 63 int fetched = 0; 64 struct gdbarch *gdbarch = regcache->arch (); 65 66 #ifdef BFD64 67 if (gdbarch_ptr_bit (gdbarch) == 64) 68 { 69 if (regno == -1 || amd64_native_gregset_supplies_p (gdbarch, regno)) 70 { 71 x86_thread_state_t gp_regs; 72 unsigned int gp_count = x86_THREAD_STATE_COUNT; 73 kern_return_t ret; 74 75 ret = thread_get_state 76 (current_thread, x86_THREAD_STATE, (thread_state_t) & gp_regs, 77 &gp_count); 78 if (ret != KERN_SUCCESS) 79 { 80 printf_unfiltered (_("Error calling thread_get_state for " 81 "GP registers for thread 0x%lx\n"), 82 (unsigned long) current_thread); 83 MACH_CHECK_ERROR (ret); 84 } 85 86 /* Some kernels don't sanitize the values. */ 87 gp_regs.uts.ts64.__fs &= 0xffff; 88 gp_regs.uts.ts64.__gs &= 0xffff; 89 90 amd64_supply_native_gregset (regcache, &gp_regs.uts, -1); 91 fetched++; 92 } 93 94 if (regno == -1 || !amd64_native_gregset_supplies_p (gdbarch, regno)) 95 { 96 x86_float_state_t fp_regs; 97 unsigned int fp_count = x86_FLOAT_STATE_COUNT; 98 kern_return_t ret; 99 100 ret = thread_get_state 101 (current_thread, x86_FLOAT_STATE, (thread_state_t) & fp_regs, 102 &fp_count); 103 if (ret != KERN_SUCCESS) 104 { 105 printf_unfiltered (_("Error calling thread_get_state for " 106 "float registers for thread 0x%lx\n"), 107 (unsigned long) current_thread); 108 MACH_CHECK_ERROR (ret); 109 } 110 amd64_supply_fxsave (regcache, -1, &fp_regs.ufs.fs64.__fpu_fcw); 111 fetched++; 112 } 113 } 114 else 115 #endif 116 { 117 if (regno == -1 || regno < I386_NUM_GREGS) 118 { 119 x86_thread_state32_t gp_regs; 120 unsigned int gp_count = x86_THREAD_STATE32_COUNT; 121 kern_return_t ret; 122 int i; 123 124 ret = thread_get_state 125 (current_thread, x86_THREAD_STATE32, (thread_state_t) &gp_regs, 126 &gp_count); 127 if (ret != KERN_SUCCESS) 128 { 129 printf_unfiltered (_("Error calling thread_get_state for " 130 "GP registers for thread 0x%lx\n"), 131 (unsigned long) current_thread); 132 MACH_CHECK_ERROR (ret); 133 } 134 for (i = 0; i < I386_NUM_GREGS; i++) 135 regcache->raw_supply 136 (i, (char *) &gp_regs + i386_darwin_thread_state_reg_offset[i]); 137 138 fetched++; 139 } 140 141 if (regno == -1 142 || (regno >= I386_ST0_REGNUM && regno < I386_SSE_NUM_REGS)) 143 { 144 x86_float_state32_t fp_regs; 145 unsigned int fp_count = x86_FLOAT_STATE32_COUNT; 146 kern_return_t ret; 147 148 ret = thread_get_state 149 (current_thread, x86_FLOAT_STATE32, (thread_state_t) &fp_regs, 150 &fp_count); 151 if (ret != KERN_SUCCESS) 152 { 153 printf_unfiltered (_("Error calling thread_get_state for " 154 "float registers for thread 0x%lx\n"), 155 (unsigned long) current_thread); 156 MACH_CHECK_ERROR (ret); 157 } 158 i387_supply_fxsave (regcache, -1, &fp_regs.__fpu_fcw); 159 fetched++; 160 } 161 } 162 163 if (! fetched) 164 { 165 warning (_("unknown register %d"), regno); 166 regcache->raw_supply (regno, NULL); 167 } 168 } 169 170 /* Store our register values back into the inferior. 171 If REGNO is -1, do this for all registers. 172 Otherwise, REGNO specifies which register (so we can save time). */ 173 174 void 175 i386_darwin_nat_target::store_registers (struct regcache *regcache, 176 int regno) 177 { 178 thread_t current_thread = regcache->ptid ().tid (); 179 struct gdbarch *gdbarch = regcache->arch (); 180 181 #ifdef BFD64 182 if (gdbarch_ptr_bit (gdbarch) == 64) 183 { 184 if (regno == -1 || amd64_native_gregset_supplies_p (gdbarch, regno)) 185 { 186 x86_thread_state_t gp_regs; 187 kern_return_t ret; 188 unsigned int gp_count = x86_THREAD_STATE_COUNT; 189 190 ret = thread_get_state 191 (current_thread, x86_THREAD_STATE, (thread_state_t) &gp_regs, 192 &gp_count); 193 MACH_CHECK_ERROR (ret); 194 gdb_assert (gp_regs.tsh.flavor == x86_THREAD_STATE64); 195 gdb_assert (gp_regs.tsh.count == x86_THREAD_STATE64_COUNT); 196 197 amd64_collect_native_gregset (regcache, &gp_regs.uts, regno); 198 199 /* Some kernels don't sanitize the values. */ 200 gp_regs.uts.ts64.__fs &= 0xffff; 201 gp_regs.uts.ts64.__gs &= 0xffff; 202 203 ret = thread_set_state (current_thread, x86_THREAD_STATE, 204 (thread_state_t) &gp_regs, 205 x86_THREAD_STATE_COUNT); 206 MACH_CHECK_ERROR (ret); 207 } 208 209 if (regno == -1 || !amd64_native_gregset_supplies_p (gdbarch, regno)) 210 { 211 x86_float_state_t fp_regs; 212 kern_return_t ret; 213 unsigned int fp_count = x86_FLOAT_STATE_COUNT; 214 215 ret = thread_get_state 216 (current_thread, x86_FLOAT_STATE, (thread_state_t) & fp_regs, 217 &fp_count); 218 MACH_CHECK_ERROR (ret); 219 gdb_assert (fp_regs.fsh.flavor == x86_FLOAT_STATE64); 220 gdb_assert (fp_regs.fsh.count == x86_FLOAT_STATE64_COUNT); 221 222 amd64_collect_fxsave (regcache, regno, &fp_regs.ufs.fs64.__fpu_fcw); 223 224 ret = thread_set_state (current_thread, x86_FLOAT_STATE, 225 (thread_state_t) & fp_regs, 226 x86_FLOAT_STATE_COUNT); 227 MACH_CHECK_ERROR (ret); 228 } 229 } 230 else 231 #endif 232 { 233 if (regno == -1 || regno < I386_NUM_GREGS) 234 { 235 x86_thread_state32_t gp_regs; 236 kern_return_t ret; 237 unsigned int gp_count = x86_THREAD_STATE32_COUNT; 238 int i; 239 240 ret = thread_get_state 241 (current_thread, x86_THREAD_STATE32, (thread_state_t) &gp_regs, 242 &gp_count); 243 MACH_CHECK_ERROR (ret); 244 245 for (i = 0; i < I386_NUM_GREGS; i++) 246 if (regno == -1 || regno == i) 247 regcache->raw_collect 248 (i, (char *) &gp_regs + i386_darwin_thread_state_reg_offset[i]); 249 250 ret = thread_set_state (current_thread, x86_THREAD_STATE32, 251 (thread_state_t) &gp_regs, 252 x86_THREAD_STATE32_COUNT); 253 MACH_CHECK_ERROR (ret); 254 } 255 256 if (regno == -1 257 || (regno >= I386_ST0_REGNUM && regno < I386_SSE_NUM_REGS)) 258 { 259 x86_float_state32_t fp_regs; 260 unsigned int fp_count = x86_FLOAT_STATE32_COUNT; 261 kern_return_t ret; 262 263 ret = thread_get_state 264 (current_thread, x86_FLOAT_STATE32, (thread_state_t) & fp_regs, 265 &fp_count); 266 MACH_CHECK_ERROR (ret); 267 268 i387_collect_fxsave (regcache, regno, &fp_regs.__fpu_fcw); 269 270 ret = thread_set_state (current_thread, x86_FLOAT_STATE32, 271 (thread_state_t) &fp_regs, 272 x86_FLOAT_STATE32_COUNT); 273 MACH_CHECK_ERROR (ret); 274 } 275 } 276 } 277 278 /* Support for debug registers, boosted mostly from i386-linux-nat.c. */ 279 280 static void 281 i386_darwin_dr_set (int regnum, CORE_ADDR value) 282 { 283 thread_t current_thread; 284 x86_debug_state_t dr_regs; 285 kern_return_t ret; 286 unsigned int dr_count; 287 288 gdb_assert (regnum >= 0 && regnum <= DR_CONTROL); 289 290 current_thread = inferior_ptid.tid (); 291 292 dr_regs.dsh.flavor = x86_DEBUG_STATE; 293 dr_regs.dsh.count = x86_DEBUG_STATE_COUNT; 294 dr_count = x86_DEBUG_STATE_COUNT; 295 ret = thread_get_state (current_thread, x86_DEBUG_STATE, 296 (thread_state_t) &dr_regs, &dr_count); 297 MACH_CHECK_ERROR (ret); 298 299 switch (dr_regs.dsh.flavor) 300 { 301 case x86_DEBUG_STATE32: 302 switch (regnum) 303 { 304 case 0: 305 dr_regs.uds.ds32.__dr0 = value; 306 break; 307 case 1: 308 dr_regs.uds.ds32.__dr1 = value; 309 break; 310 case 2: 311 dr_regs.uds.ds32.__dr2 = value; 312 break; 313 case 3: 314 dr_regs.uds.ds32.__dr3 = value; 315 break; 316 case 4: 317 dr_regs.uds.ds32.__dr4 = value; 318 break; 319 case 5: 320 dr_regs.uds.ds32.__dr5 = value; 321 break; 322 case 6: 323 dr_regs.uds.ds32.__dr6 = value; 324 break; 325 case 7: 326 dr_regs.uds.ds32.__dr7 = value; 327 break; 328 } 329 break; 330 #ifdef BFD64 331 case x86_DEBUG_STATE64: 332 switch (regnum) 333 { 334 case 0: 335 dr_regs.uds.ds64.__dr0 = value; 336 break; 337 case 1: 338 dr_regs.uds.ds64.__dr1 = value; 339 break; 340 case 2: 341 dr_regs.uds.ds64.__dr2 = value; 342 break; 343 case 3: 344 dr_regs.uds.ds64.__dr3 = value; 345 break; 346 case 4: 347 dr_regs.uds.ds64.__dr4 = value; 348 break; 349 case 5: 350 dr_regs.uds.ds64.__dr5 = value; 351 break; 352 case 6: 353 dr_regs.uds.ds64.__dr6 = value; 354 break; 355 case 7: 356 dr_regs.uds.ds64.__dr7 = value; 357 break; 358 } 359 break; 360 #endif 361 } 362 363 ret = thread_set_state (current_thread, dr_regs.dsh.flavor, 364 (thread_state_t) &dr_regs.uds, dr_count); 365 366 MACH_CHECK_ERROR (ret); 367 } 368 369 static CORE_ADDR 370 i386_darwin_dr_get (int regnum) 371 { 372 thread_t current_thread; 373 x86_debug_state_t dr_regs; 374 kern_return_t ret; 375 unsigned int dr_count; 376 377 gdb_assert (regnum >= 0 && regnum <= DR_CONTROL); 378 379 current_thread = inferior_ptid.tid (); 380 381 dr_regs.dsh.flavor = x86_DEBUG_STATE; 382 dr_regs.dsh.count = x86_DEBUG_STATE_COUNT; 383 dr_count = x86_DEBUG_STATE_COUNT; 384 ret = thread_get_state (current_thread, x86_DEBUG_STATE, 385 (thread_state_t) &dr_regs, &dr_count); 386 MACH_CHECK_ERROR (ret); 387 388 switch (dr_regs.dsh.flavor) 389 { 390 case x86_DEBUG_STATE32: 391 switch (regnum) 392 { 393 case 0: 394 return dr_regs.uds.ds32.__dr0; 395 case 1: 396 return dr_regs.uds.ds32.__dr1; 397 case 2: 398 return dr_regs.uds.ds32.__dr2; 399 case 3: 400 return dr_regs.uds.ds32.__dr3; 401 case 4: 402 return dr_regs.uds.ds32.__dr4; 403 case 5: 404 return dr_regs.uds.ds32.__dr5; 405 case 6: 406 return dr_regs.uds.ds32.__dr6; 407 case 7: 408 return dr_regs.uds.ds32.__dr7; 409 default: 410 return -1; 411 } 412 break; 413 #ifdef BFD64 414 case x86_DEBUG_STATE64: 415 switch (regnum) 416 { 417 case 0: 418 return dr_regs.uds.ds64.__dr0; 419 case 1: 420 return dr_regs.uds.ds64.__dr1; 421 case 2: 422 return dr_regs.uds.ds64.__dr2; 423 case 3: 424 return dr_regs.uds.ds64.__dr3; 425 case 4: 426 return dr_regs.uds.ds64.__dr4; 427 case 5: 428 return dr_regs.uds.ds64.__dr5; 429 case 6: 430 return dr_regs.uds.ds64.__dr6; 431 case 7: 432 return dr_regs.uds.ds64.__dr7; 433 default: 434 return -1; 435 } 436 break; 437 #endif 438 default: 439 return -1; 440 } 441 } 442 443 static void 444 i386_darwin_dr_set_control (unsigned long control) 445 { 446 i386_darwin_dr_set (DR_CONTROL, control); 447 } 448 449 static void 450 i386_darwin_dr_set_addr (int regnum, CORE_ADDR addr) 451 { 452 gdb_assert (regnum >= 0 && regnum <= DR_LASTADDR - DR_FIRSTADDR); 453 454 i386_darwin_dr_set (DR_FIRSTADDR + regnum, addr); 455 } 456 457 static CORE_ADDR 458 i386_darwin_dr_get_addr (int regnum) 459 { 460 return i386_darwin_dr_get (regnum); 461 } 462 463 static unsigned long 464 i386_darwin_dr_get_status (void) 465 { 466 return i386_darwin_dr_get (DR_STATUS); 467 } 468 469 static unsigned long 470 i386_darwin_dr_get_control (void) 471 { 472 return i386_darwin_dr_get (DR_CONTROL); 473 } 474 475 void 476 darwin_check_osabi (darwin_inferior *inf, thread_t thread) 477 { 478 if (gdbarch_osabi (target_gdbarch ()) == GDB_OSABI_UNKNOWN) 479 { 480 /* Attaching to a process. Let's figure out what kind it is. */ 481 x86_thread_state_t gp_regs; 482 struct gdbarch_info info; 483 unsigned int gp_count = x86_THREAD_STATE_COUNT; 484 kern_return_t ret; 485 486 ret = thread_get_state (thread, x86_THREAD_STATE, 487 (thread_state_t) &gp_regs, &gp_count); 488 if (ret != KERN_SUCCESS) 489 { 490 MACH_CHECK_ERROR (ret); 491 return; 492 } 493 494 gdbarch_info_init (&info); 495 gdbarch_info_fill (&info); 496 info.byte_order = gdbarch_byte_order (target_gdbarch ()); 497 info.osabi = GDB_OSABI_DARWIN; 498 if (gp_regs.tsh.flavor == x86_THREAD_STATE64) 499 info.bfd_arch_info = bfd_lookup_arch (bfd_arch_i386, 500 bfd_mach_x86_64); 501 else 502 info.bfd_arch_info = bfd_lookup_arch (bfd_arch_i386, 503 bfd_mach_i386_i386); 504 gdbarch_update_p (info); 505 } 506 } 507 508 #define X86_EFLAGS_T 0x100UL 509 510 /* Returning from a signal trampoline is done by calling a 511 special system call (sigreturn). This system call 512 restores the registers that were saved when the signal was 513 raised, including %eflags/%rflags. That means that single-stepping 514 won't work. Instead, we'll have to modify the signal context 515 that's about to be restored, and set the trace flag there. */ 516 517 static int 518 i386_darwin_sstep_at_sigreturn (x86_thread_state_t *regs) 519 { 520 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ()); 521 static const gdb_byte darwin_syscall[] = { 0xcd, 0x80 }; /* int 0x80 */ 522 gdb_byte buf[sizeof (darwin_syscall)]; 523 524 /* Check if PC is at a sigreturn system call. */ 525 if (target_read_memory (regs->uts.ts32.__eip, buf, sizeof (buf)) == 0 526 && memcmp (buf, darwin_syscall, sizeof (darwin_syscall)) == 0 527 && regs->uts.ts32.__eax == 0xb8 /* SYS_sigreturn */) 528 { 529 ULONGEST uctx_addr; 530 ULONGEST mctx_addr; 531 ULONGEST flags_addr; 532 unsigned int eflags; 533 534 uctx_addr = read_memory_unsigned_integer 535 (regs->uts.ts32.__esp + 4, 4, byte_order); 536 mctx_addr = read_memory_unsigned_integer 537 (uctx_addr + 28, 4, byte_order); 538 539 flags_addr = mctx_addr + 12 + 9 * 4; 540 read_memory (flags_addr, (gdb_byte *) &eflags, 4); 541 eflags |= X86_EFLAGS_T; 542 write_memory (flags_addr, (gdb_byte *) &eflags, 4); 543 544 return 1; 545 } 546 return 0; 547 } 548 549 #ifdef BFD64 550 static int 551 amd64_darwin_sstep_at_sigreturn (x86_thread_state_t *regs) 552 { 553 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ()); 554 static const gdb_byte darwin_syscall[] = { 0x0f, 0x05 }; /* syscall */ 555 gdb_byte buf[sizeof (darwin_syscall)]; 556 557 /* Check if PC is at a sigreturn system call. */ 558 if (target_read_memory (regs->uts.ts64.__rip, buf, sizeof (buf)) == 0 559 && memcmp (buf, darwin_syscall, sizeof (darwin_syscall)) == 0 560 && (regs->uts.ts64.__rax & 0xffffffff) == 0x20000b8 /* SYS_sigreturn */) 561 { 562 ULONGEST mctx_addr; 563 ULONGEST flags_addr; 564 unsigned int rflags; 565 566 mctx_addr = read_memory_unsigned_integer 567 (regs->uts.ts64.__rdi + 48, 8, byte_order); 568 flags_addr = mctx_addr + 16 + 17 * 8; 569 570 /* AMD64 is little endian. */ 571 read_memory (flags_addr, (gdb_byte *) &rflags, 4); 572 rflags |= X86_EFLAGS_T; 573 write_memory (flags_addr, (gdb_byte *) &rflags, 4); 574 575 return 1; 576 } 577 return 0; 578 } 579 #endif 580 581 void 582 darwin_set_sstep (thread_t thread, int enable) 583 { 584 x86_thread_state_t regs; 585 unsigned int count = x86_THREAD_STATE_COUNT; 586 kern_return_t kret; 587 588 kret = thread_get_state (thread, x86_THREAD_STATE, 589 (thread_state_t) ®s, &count); 590 if (kret != KERN_SUCCESS) 591 { 592 printf_unfiltered (_("darwin_set_sstep: error %x, thread=%x\n"), 593 kret, thread); 594 return; 595 } 596 597 switch (regs.tsh.flavor) 598 { 599 case x86_THREAD_STATE32: 600 { 601 __uint32_t bit = enable ? X86_EFLAGS_T : 0; 602 603 if (enable && i386_darwin_sstep_at_sigreturn (®s)) 604 return; 605 if ((regs.uts.ts32.__eflags & X86_EFLAGS_T) == bit) 606 return; 607 regs.uts.ts32.__eflags 608 = (regs.uts.ts32.__eflags & ~X86_EFLAGS_T) | bit; 609 kret = thread_set_state (thread, x86_THREAD_STATE, 610 (thread_state_t) ®s, count); 611 MACH_CHECK_ERROR (kret); 612 } 613 break; 614 #ifdef BFD64 615 case x86_THREAD_STATE64: 616 { 617 __uint64_t bit = enable ? X86_EFLAGS_T : 0; 618 619 if (enable && amd64_darwin_sstep_at_sigreturn (®s)) 620 return; 621 if ((regs.uts.ts64.__rflags & X86_EFLAGS_T) == bit) 622 return; 623 regs.uts.ts64.__rflags 624 = (regs.uts.ts64.__rflags & ~X86_EFLAGS_T) | bit; 625 kret = thread_set_state (thread, x86_THREAD_STATE, 626 (thread_state_t) ®s, count); 627 MACH_CHECK_ERROR (kret); 628 } 629 break; 630 #endif 631 default: 632 error (_("darwin_set_sstep: unknown flavour: %d"), regs.tsh.flavor); 633 } 634 } 635 636 void _initialize_i386_darwin_nat (); 637 void 638 _initialize_i386_darwin_nat () 639 { 640 #ifdef BFD64 641 amd64_native_gregset64_reg_offset = amd64_darwin_thread_state_reg_offset; 642 amd64_native_gregset64_num_regs = amd64_darwin_thread_state_num_regs; 643 amd64_native_gregset32_reg_offset = i386_darwin_thread_state_reg_offset; 644 amd64_native_gregset32_num_regs = i386_darwin_thread_state_num_regs; 645 #endif 646 647 x86_dr_low.set_control = i386_darwin_dr_set_control; 648 x86_dr_low.set_addr = i386_darwin_dr_set_addr; 649 x86_dr_low.get_addr = i386_darwin_dr_get_addr; 650 x86_dr_low.get_status = i386_darwin_dr_get_status; 651 x86_dr_low.get_control = i386_darwin_dr_get_control; 652 653 /* Let's assume that the kernel is 64 bits iff the executable is. */ 654 #ifdef __x86_64__ 655 x86_set_debug_register_length (8); 656 #else 657 x86_set_debug_register_length (4); 658 #endif 659 660 add_inf_child_target (&darwin_target); 661 } 662