1 /* Darwin support for GDB, the GNU debugger. 2 Copyright (C) 1997-2023 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 warning (_("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 warning (_("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 warning (_("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 warning (_("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 unsigned int gp_count = x86_THREAD_STATE_COUNT; 483 kern_return_t ret; 484 485 ret = thread_get_state (thread, x86_THREAD_STATE, 486 (thread_state_t) &gp_regs, &gp_count); 487 if (ret != KERN_SUCCESS) 488 { 489 MACH_CHECK_ERROR (ret); 490 return; 491 } 492 493 gdbarch_info info; 494 gdbarch_info_fill (&info); 495 info.byte_order = gdbarch_byte_order (target_gdbarch ()); 496 info.osabi = GDB_OSABI_DARWIN; 497 if (gp_regs.tsh.flavor == x86_THREAD_STATE64) 498 info.bfd_arch_info = bfd_lookup_arch (bfd_arch_i386, 499 bfd_mach_x86_64); 500 else 501 info.bfd_arch_info = bfd_lookup_arch (bfd_arch_i386, 502 bfd_mach_i386_i386); 503 gdbarch_update_p (info); 504 } 505 } 506 507 #define X86_EFLAGS_T 0x100UL 508 509 /* Returning from a signal trampoline is done by calling a 510 special system call (sigreturn). This system call 511 restores the registers that were saved when the signal was 512 raised, including %eflags/%rflags. That means that single-stepping 513 won't work. Instead, we'll have to modify the signal context 514 that's about to be restored, and set the trace flag there. */ 515 516 static int 517 i386_darwin_sstep_at_sigreturn (x86_thread_state_t *regs) 518 { 519 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ()); 520 static const gdb_byte darwin_syscall[] = { 0xcd, 0x80 }; /* int 0x80 */ 521 gdb_byte buf[sizeof (darwin_syscall)]; 522 523 /* Check if PC is at a sigreturn system call. */ 524 if (target_read_memory (regs->uts.ts32.__eip, buf, sizeof (buf)) == 0 525 && memcmp (buf, darwin_syscall, sizeof (darwin_syscall)) == 0 526 && regs->uts.ts32.__eax == 0xb8 /* SYS_sigreturn */) 527 { 528 ULONGEST uctx_addr; 529 ULONGEST mctx_addr; 530 ULONGEST flags_addr; 531 unsigned int eflags; 532 533 uctx_addr = read_memory_unsigned_integer 534 (regs->uts.ts32.__esp + 4, 4, byte_order); 535 mctx_addr = read_memory_unsigned_integer 536 (uctx_addr + 28, 4, byte_order); 537 538 flags_addr = mctx_addr + 12 + 9 * 4; 539 read_memory (flags_addr, (gdb_byte *) &eflags, 4); 540 eflags |= X86_EFLAGS_T; 541 write_memory (flags_addr, (gdb_byte *) &eflags, 4); 542 543 return 1; 544 } 545 return 0; 546 } 547 548 #ifdef BFD64 549 static int 550 amd64_darwin_sstep_at_sigreturn (x86_thread_state_t *regs) 551 { 552 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ()); 553 static const gdb_byte darwin_syscall[] = { 0x0f, 0x05 }; /* syscall */ 554 gdb_byte buf[sizeof (darwin_syscall)]; 555 556 /* Check if PC is at a sigreturn system call. */ 557 if (target_read_memory (regs->uts.ts64.__rip, buf, sizeof (buf)) == 0 558 && memcmp (buf, darwin_syscall, sizeof (darwin_syscall)) == 0 559 && (regs->uts.ts64.__rax & 0xffffffff) == 0x20000b8 /* SYS_sigreturn */) 560 { 561 ULONGEST mctx_addr; 562 ULONGEST flags_addr; 563 unsigned int rflags; 564 565 mctx_addr = read_memory_unsigned_integer 566 (regs->uts.ts64.__rdi + 48, 8, byte_order); 567 flags_addr = mctx_addr + 16 + 17 * 8; 568 569 /* AMD64 is little endian. */ 570 read_memory (flags_addr, (gdb_byte *) &rflags, 4); 571 rflags |= X86_EFLAGS_T; 572 write_memory (flags_addr, (gdb_byte *) &rflags, 4); 573 574 return 1; 575 } 576 return 0; 577 } 578 #endif 579 580 void 581 darwin_set_sstep (thread_t thread, int enable) 582 { 583 x86_thread_state_t regs; 584 unsigned int count = x86_THREAD_STATE_COUNT; 585 kern_return_t kret; 586 587 kret = thread_get_state (thread, x86_THREAD_STATE, 588 (thread_state_t) ®s, &count); 589 if (kret != KERN_SUCCESS) 590 { 591 warning (_("darwin_set_sstep: error %x, thread=%x\n"), 592 kret, thread); 593 return; 594 } 595 596 switch (regs.tsh.flavor) 597 { 598 case x86_THREAD_STATE32: 599 { 600 __uint32_t bit = enable ? X86_EFLAGS_T : 0; 601 602 if (enable && i386_darwin_sstep_at_sigreturn (®s)) 603 return; 604 if ((regs.uts.ts32.__eflags & X86_EFLAGS_T) == bit) 605 return; 606 regs.uts.ts32.__eflags 607 = (regs.uts.ts32.__eflags & ~X86_EFLAGS_T) | bit; 608 kret = thread_set_state (thread, x86_THREAD_STATE, 609 (thread_state_t) ®s, count); 610 MACH_CHECK_ERROR (kret); 611 } 612 break; 613 #ifdef BFD64 614 case x86_THREAD_STATE64: 615 { 616 __uint64_t bit = enable ? X86_EFLAGS_T : 0; 617 618 if (enable && amd64_darwin_sstep_at_sigreturn (®s)) 619 return; 620 if ((regs.uts.ts64.__rflags & X86_EFLAGS_T) == bit) 621 return; 622 regs.uts.ts64.__rflags 623 = (regs.uts.ts64.__rflags & ~X86_EFLAGS_T) | bit; 624 kret = thread_set_state (thread, x86_THREAD_STATE, 625 (thread_state_t) ®s, count); 626 MACH_CHECK_ERROR (kret); 627 } 628 break; 629 #endif 630 default: 631 error (_("darwin_set_sstep: unknown flavour: %d"), regs.tsh.flavor); 632 } 633 } 634 635 void _initialize_i386_darwin_nat (); 636 void 637 _initialize_i386_darwin_nat () 638 { 639 #ifdef BFD64 640 amd64_native_gregset64_reg_offset = amd64_darwin_thread_state_reg_offset; 641 amd64_native_gregset64_num_regs = amd64_darwin_thread_state_num_regs; 642 amd64_native_gregset32_reg_offset = i386_darwin_thread_state_reg_offset; 643 amd64_native_gregset32_num_regs = i386_darwin_thread_state_num_regs; 644 #endif 645 646 x86_dr_low.set_control = i386_darwin_dr_set_control; 647 x86_dr_low.set_addr = i386_darwin_dr_set_addr; 648 x86_dr_low.get_addr = i386_darwin_dr_get_addr; 649 x86_dr_low.get_status = i386_darwin_dr_get_status; 650 x86_dr_low.get_control = i386_darwin_dr_get_control; 651 652 /* Let's assume that the kernel is 64 bits iff the executable is. */ 653 #ifdef __x86_64__ 654 x86_set_debug_register_length (8); 655 #else 656 x86_set_debug_register_length (4); 657 #endif 658 659 add_inf_child_target (&darwin_target); 660 } 661