1/* IBM RS/6000 native-dependent code for GDB, the GNU debugger. 2 3 Copyright (C) 1986-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 "inferior.h" 22#include "target.h" 23#include "gdbcore.h" 24#include "symfile.h" 25#include "objfiles.h" 26#include "bfd.h" 27#include "gdb-stabs.h" 28#include "regcache.h" 29#include "arch-utils.h" 30#include "inf-child.h" 31#include "inf-ptrace.h" 32#include "ppc-tdep.h" 33#include "rs6000-aix-tdep.h" 34#include "exec.h" 35#include "observable.h" 36#include "xcoffread.h" 37 38#include <sys/ptrace.h> 39#include <sys/reg.h> 40 41#include <sys/dir.h> 42#include <sys/user.h> 43#include <signal.h> 44#include <sys/ioctl.h> 45#include <fcntl.h> 46 47#include <a.out.h> 48#include <sys/file.h> 49#include <sys/stat.h> 50#include "gdb_bfd.h" 51#include <sys/core.h> 52#define __LDINFO_PTRACE32__ /* for __ld_info32 */ 53#define __LDINFO_PTRACE64__ /* for __ld_info64 */ 54#include <sys/ldr.h> 55#include <sys/systemcfg.h> 56 57/* Header files for getting ppid in AIX of a child process. */ 58#include <procinfo.h> 59#include <sys/types.h> 60 61/* On AIX4.3+, sys/ldr.h provides different versions of struct ld_info for 62 debugging 32-bit and 64-bit processes. Define a typedef and macros for 63 accessing fields in the appropriate structures. */ 64 65/* In 32-bit compilation mode (which is the only mode from which ptrace() 66 works on 4.3), __ld_info32 is #defined as equivalent to ld_info. */ 67 68#if defined (__ld_info32) || defined (__ld_info64) 69# define ARCH3264 70#endif 71 72/* Return whether the current architecture is 64-bit. */ 73 74#ifndef ARCH3264 75# define ARCH64() 0 76#else 77# define ARCH64() (register_size (target_gdbarch (), 0) == 8) 78#endif 79 80class rs6000_nat_target final : public inf_ptrace_target 81{ 82public: 83 void fetch_registers (struct regcache *, int) override; 84 void store_registers (struct regcache *, int) override; 85 86 enum target_xfer_status xfer_partial (enum target_object object, 87 const char *annex, 88 gdb_byte *readbuf, 89 const gdb_byte *writebuf, 90 ULONGEST offset, ULONGEST len, 91 ULONGEST *xfered_len) override; 92 93 void create_inferior (const char *, const std::string &, 94 char **, int) override; 95 96 ptid_t wait (ptid_t, struct target_waitstatus *, target_wait_flags) override; 97 98 /* Fork detection related functions, For adding multi process debugging 99 support. */ 100 void follow_fork (inferior *, ptid_t, target_waitkind, bool, bool) override; 101 102protected: 103 104 void post_startup_inferior (ptid_t ptid) override; 105 106private: 107 enum target_xfer_status 108 xfer_shared_libraries (enum target_object object, 109 const char *annex, gdb_byte *readbuf, 110 const gdb_byte *writebuf, 111 ULONGEST offset, ULONGEST len, 112 ULONGEST *xfered_len); 113}; 114 115static rs6000_nat_target the_rs6000_nat_target; 116 117/* The below declaration is to track number of times, parent has 118 reported fork event before its children. */ 119 120static std::list<pid_t> aix_pending_parent; 121 122/* The below declaration is for a child process event that 123 is reported before its corresponding parent process in 124 the event of a fork (). */ 125 126static std::list<pid_t> aix_pending_children; 127 128static void 129aix_remember_child (pid_t pid) 130{ 131 aix_pending_children.push_front (pid); 132} 133 134static void 135aix_remember_parent (pid_t pid) 136{ 137 aix_pending_parent.push_front (pid); 138} 139 140/* This function returns a parent of a child process. */ 141 142static pid_t 143find_my_aix_parent (pid_t child_pid) 144{ 145 struct procsinfo ProcessBuffer1; 146 147 if (getprocs (&ProcessBuffer1, sizeof (ProcessBuffer1), 148 NULL, 0, &child_pid, 1) != 1) 149 return 0; 150 else 151 return ProcessBuffer1.pi_ppid; 152} 153 154/* In the below function we check if there was any child 155 process pending. If it exists we return it from the 156 list, otherwise we return a null. */ 157 158static pid_t 159has_my_aix_child_reported (pid_t parent_pid) 160{ 161 pid_t child = 0; 162 auto it = std::find_if (aix_pending_children.begin (), 163 aix_pending_children.end (), 164 [=] (pid_t child_pid) 165 { 166 return find_my_aix_parent (child_pid) == parent_pid; 167 }); 168 if (it != aix_pending_children.end ()) 169 { 170 child = *it; 171 aix_pending_children.erase (it); 172 } 173 return child; 174} 175 176/* In the below function we check if there was any parent 177 process pending. If it exists we return it from the 178 list, otherwise we return a null. */ 179 180static pid_t 181has_my_aix_parent_reported (pid_t child_pid) 182{ 183 pid_t my_parent = find_my_aix_parent (child_pid); 184 auto it = std::find (aix_pending_parent.begin (), 185 aix_pending_parent.end (), 186 my_parent); 187 if (it != aix_pending_parent.end ()) 188 { 189 aix_pending_parent.erase (it); 190 return my_parent; 191 } 192 return 0; 193} 194 195/* Given REGNO, a gdb register number, return the corresponding 196 number suitable for use as a ptrace() parameter. Return -1 if 197 there's no suitable mapping. Also, set the int pointed to by 198 ISFLOAT to indicate whether REGNO is a floating point register. */ 199 200static int 201regmap (struct gdbarch *gdbarch, int regno, int *isfloat) 202{ 203 ppc_gdbarch_tdep *tdep = gdbarch_tdep<ppc_gdbarch_tdep> (gdbarch); 204 205 *isfloat = 0; 206 if (tdep->ppc_gp0_regnum <= regno 207 && regno < tdep->ppc_gp0_regnum + ppc_num_gprs) 208 return regno; 209 else if (tdep->ppc_fp0_regnum >= 0 210 && tdep->ppc_fp0_regnum <= regno 211 && regno < tdep->ppc_fp0_regnum + ppc_num_fprs) 212 { 213 *isfloat = 1; 214 return regno - tdep->ppc_fp0_regnum + FPR0; 215 } 216 else if (regno == gdbarch_pc_regnum (gdbarch)) 217 return IAR; 218 else if (regno == tdep->ppc_ps_regnum) 219 return MSR; 220 else if (regno == tdep->ppc_cr_regnum) 221 return CR; 222 else if (regno == tdep->ppc_lr_regnum) 223 return LR; 224 else if (regno == tdep->ppc_ctr_regnum) 225 return CTR; 226 else if (regno == tdep->ppc_xer_regnum) 227 return XER; 228 else if (tdep->ppc_fpscr_regnum >= 0 229 && regno == tdep->ppc_fpscr_regnum) 230 return FPSCR; 231 else if (tdep->ppc_mq_regnum >= 0 && regno == tdep->ppc_mq_regnum) 232 return MQ; 233 else 234 return -1; 235} 236 237/* Call ptrace(REQ, ID, ADDR, DATA, BUF). */ 238 239static int 240rs6000_ptrace32 (int req, int id, int *addr, int data, int *buf) 241{ 242#ifdef HAVE_PTRACE64 243 int ret = ptrace64 (req, id, (uintptr_t) addr, data, buf); 244#else 245 int ret = ptrace (req, id, (int *)addr, data, buf); 246#endif 247#if 0 248 printf ("rs6000_ptrace32 (%d, %d, 0x%x, %08x, 0x%x) = 0x%x\n", 249 req, id, (unsigned int)addr, data, (unsigned int)buf, ret); 250#endif 251 return ret; 252} 253 254/* Call ptracex(REQ, ID, ADDR, DATA, BUF). */ 255 256static int 257rs6000_ptrace64 (int req, int id, long long addr, int data, void *buf) 258{ 259#ifdef ARCH3264 260# ifdef HAVE_PTRACE64 261 int ret = ptrace64 (req, id, addr, data, (PTRACE_TYPE_ARG5) buf); 262# else 263 int ret = ptracex (req, id, addr, data, (PTRACE_TYPE_ARG5) buf); 264# endif 265#else 266 int ret = 0; 267#endif 268#if 0 269 printf ("rs6000_ptrace64 (%d, %d, %s, %08x, 0x%x) = 0x%x\n", 270 req, id, hex_string (addr), data, (unsigned int)buf, ret); 271#endif 272 return ret; 273} 274 275void rs6000_nat_target::post_startup_inferior (ptid_t ptid) 276{ 277 278 /* In AIX to turn on multi process debugging in ptrace 279 PT_MULTI is the option to be passed, 280 with the process ID which can fork () and 281 the data parameter [fourth parameter] must be 1. */ 282 283 if (!ARCH64 ()) 284 rs6000_ptrace32 (PT_MULTI, ptid.pid(), 0, 1, 0); 285 else 286 rs6000_ptrace64 (PT_MULTI, ptid.pid(), 0, 1, 0); 287} 288 289void 290rs6000_nat_target::follow_fork (inferior *child_inf, ptid_t child_ptid, 291 target_waitkind fork_kind, bool follow_child, 292 bool detach_fork) 293{ 294 295 /* Once the fork event is detected the infrun.c code 296 calls the target_follow_fork to take care of 297 follow child and detach the child activity which is 298 done using the function below. */ 299 300 inf_ptrace_target::follow_fork (child_inf, child_ptid, fork_kind, 301 follow_child, detach_fork); 302 303 /* If we detach fork and follow child we do not want the child 304 process to geneate events that ptrace can trace. Hence we 305 detach it. */ 306 307 if (detach_fork && !follow_child) 308 { 309 if (ARCH64 ()) 310 rs6000_ptrace64 (PT_DETACH, child_ptid.pid (), 0, 0, 0); 311 else 312 rs6000_ptrace32 (PT_DETACH, child_ptid.pid (), 0, 0, 0); 313 } 314} 315 316/* Fetch register REGNO from the inferior. */ 317 318static void 319fetch_register (struct regcache *regcache, int regno) 320{ 321 struct gdbarch *gdbarch = regcache->arch (); 322 int addr[PPC_MAX_REGISTER_SIZE]; 323 int nr, isfloat; 324 pid_t pid = regcache->ptid ().pid (); 325 326 /* Retrieved values may be -1, so infer errors from errno. */ 327 errno = 0; 328 329 nr = regmap (gdbarch, regno, &isfloat); 330 331 /* Floating-point registers. */ 332 if (isfloat) 333 rs6000_ptrace32 (PT_READ_FPR, pid, addr, nr, 0); 334 335 /* Bogus register number. */ 336 else if (nr < 0) 337 { 338 if (regno >= gdbarch_num_regs (gdbarch)) 339 gdb_printf (gdb_stderr, 340 "gdb error: register no %d not implemented.\n", 341 regno); 342 return; 343 } 344 345 /* Fixed-point registers. */ 346 else 347 { 348 if (!ARCH64 ()) 349 *addr = rs6000_ptrace32 (PT_READ_GPR, pid, (int *) nr, 0, 0); 350 else 351 { 352 /* PT_READ_GPR requires the buffer parameter to point to long long, 353 even if the register is really only 32 bits. */ 354 long long buf; 355 rs6000_ptrace64 (PT_READ_GPR, pid, nr, 0, &buf); 356 if (register_size (gdbarch, regno) == 8) 357 memcpy (addr, &buf, 8); 358 else 359 *addr = buf; 360 } 361 } 362 363 if (!errno) 364 regcache->raw_supply (regno, (char *) addr); 365 else 366 { 367#if 0 368 /* FIXME: this happens 3 times at the start of each 64-bit program. */ 369 perror (_("ptrace read")); 370#endif 371 errno = 0; 372 } 373} 374 375/* Store register REGNO back into the inferior. */ 376 377static void 378store_register (struct regcache *regcache, int regno) 379{ 380 struct gdbarch *gdbarch = regcache->arch (); 381 int addr[PPC_MAX_REGISTER_SIZE]; 382 int nr, isfloat; 383 pid_t pid = regcache->ptid ().pid (); 384 385 /* Fetch the register's value from the register cache. */ 386 regcache->raw_collect (regno, addr); 387 388 /* -1 can be a successful return value, so infer errors from errno. */ 389 errno = 0; 390 391 nr = regmap (gdbarch, regno, &isfloat); 392 393 /* Floating-point registers. */ 394 if (isfloat) 395 rs6000_ptrace32 (PT_WRITE_FPR, pid, addr, nr, 0); 396 397 /* Bogus register number. */ 398 else if (nr < 0) 399 { 400 if (regno >= gdbarch_num_regs (gdbarch)) 401 gdb_printf (gdb_stderr, 402 "gdb error: register no %d not implemented.\n", 403 regno); 404 } 405 406 /* Fixed-point registers. */ 407 else 408 { 409 /* The PT_WRITE_GPR operation is rather odd. For 32-bit inferiors, 410 the register's value is passed by value, but for 64-bit inferiors, 411 the address of a buffer containing the value is passed. */ 412 if (!ARCH64 ()) 413 rs6000_ptrace32 (PT_WRITE_GPR, pid, (int *) nr, *addr, 0); 414 else 415 { 416 /* PT_WRITE_GPR requires the buffer parameter to point to an 8-byte 417 area, even if the register is really only 32 bits. */ 418 long long buf; 419 if (register_size (gdbarch, regno) == 8) 420 memcpy (&buf, addr, 8); 421 else 422 buf = *addr; 423 rs6000_ptrace64 (PT_WRITE_GPR, pid, nr, 0, &buf); 424 } 425 } 426 427 if (errno) 428 { 429 perror (_("ptrace write")); 430 errno = 0; 431 } 432} 433 434/* Read from the inferior all registers if REGNO == -1 and just register 435 REGNO otherwise. */ 436 437void 438rs6000_nat_target::fetch_registers (struct regcache *regcache, int regno) 439{ 440 struct gdbarch *gdbarch = regcache->arch (); 441 if (regno != -1) 442 fetch_register (regcache, regno); 443 444 else 445 { 446 ppc_gdbarch_tdep *tdep = gdbarch_tdep<ppc_gdbarch_tdep> (gdbarch); 447 448 /* Read 32 general purpose registers. */ 449 for (regno = tdep->ppc_gp0_regnum; 450 regno < tdep->ppc_gp0_regnum + ppc_num_gprs; 451 regno++) 452 { 453 fetch_register (regcache, regno); 454 } 455 456 /* Read general purpose floating point registers. */ 457 if (tdep->ppc_fp0_regnum >= 0) 458 for (regno = 0; regno < ppc_num_fprs; regno++) 459 fetch_register (regcache, tdep->ppc_fp0_regnum + regno); 460 461 /* Read special registers. */ 462 fetch_register (regcache, gdbarch_pc_regnum (gdbarch)); 463 fetch_register (regcache, tdep->ppc_ps_regnum); 464 fetch_register (regcache, tdep->ppc_cr_regnum); 465 fetch_register (regcache, tdep->ppc_lr_regnum); 466 fetch_register (regcache, tdep->ppc_ctr_regnum); 467 fetch_register (regcache, tdep->ppc_xer_regnum); 468 if (tdep->ppc_fpscr_regnum >= 0) 469 fetch_register (regcache, tdep->ppc_fpscr_regnum); 470 if (tdep->ppc_mq_regnum >= 0) 471 fetch_register (regcache, tdep->ppc_mq_regnum); 472 } 473} 474 475/* Store our register values back into the inferior. 476 If REGNO is -1, do this for all registers. 477 Otherwise, REGNO specifies which register (so we can save time). */ 478 479void 480rs6000_nat_target::store_registers (struct regcache *regcache, int regno) 481{ 482 struct gdbarch *gdbarch = regcache->arch (); 483 if (regno != -1) 484 store_register (regcache, regno); 485 486 else 487 { 488 ppc_gdbarch_tdep *tdep = gdbarch_tdep<ppc_gdbarch_tdep> (gdbarch); 489 490 /* Write general purpose registers first. */ 491 for (regno = tdep->ppc_gp0_regnum; 492 regno < tdep->ppc_gp0_regnum + ppc_num_gprs; 493 regno++) 494 { 495 store_register (regcache, regno); 496 } 497 498 /* Write floating point registers. */ 499 if (tdep->ppc_fp0_regnum >= 0) 500 for (regno = 0; regno < ppc_num_fprs; regno++) 501 store_register (regcache, tdep->ppc_fp0_regnum + regno); 502 503 /* Write special registers. */ 504 store_register (regcache, gdbarch_pc_regnum (gdbarch)); 505 store_register (regcache, tdep->ppc_ps_regnum); 506 store_register (regcache, tdep->ppc_cr_regnum); 507 store_register (regcache, tdep->ppc_lr_regnum); 508 store_register (regcache, tdep->ppc_ctr_regnum); 509 store_register (regcache, tdep->ppc_xer_regnum); 510 if (tdep->ppc_fpscr_regnum >= 0) 511 store_register (regcache, tdep->ppc_fpscr_regnum); 512 if (tdep->ppc_mq_regnum >= 0) 513 store_register (regcache, tdep->ppc_mq_regnum); 514 } 515} 516 517/* Implement the to_xfer_partial target_ops method. */ 518 519enum target_xfer_status 520rs6000_nat_target::xfer_partial (enum target_object object, 521 const char *annex, gdb_byte *readbuf, 522 const gdb_byte *writebuf, 523 ULONGEST offset, ULONGEST len, 524 ULONGEST *xfered_len) 525{ 526 pid_t pid = inferior_ptid.pid (); 527 int arch64 = ARCH64 (); 528 529 switch (object) 530 { 531 case TARGET_OBJECT_LIBRARIES_AIX: 532 return xfer_shared_libraries (object, annex, 533 readbuf, writebuf, 534 offset, len, xfered_len); 535 case TARGET_OBJECT_MEMORY: 536 { 537 union 538 { 539 PTRACE_TYPE_RET word; 540 gdb_byte byte[sizeof (PTRACE_TYPE_RET)]; 541 } buffer; 542 ULONGEST rounded_offset; 543 LONGEST partial_len; 544 545 /* Round the start offset down to the next long word 546 boundary. */ 547 rounded_offset = offset & -(ULONGEST) sizeof (PTRACE_TYPE_RET); 548 549 /* Since ptrace will transfer a single word starting at that 550 rounded_offset the partial_len needs to be adjusted down to 551 that (remember this function only does a single transfer). 552 Should the required length be even less, adjust it down 553 again. */ 554 partial_len = (rounded_offset + sizeof (PTRACE_TYPE_RET)) - offset; 555 if (partial_len > len) 556 partial_len = len; 557 558 if (writebuf) 559 { 560 /* If OFFSET:PARTIAL_LEN is smaller than 561 ROUNDED_OFFSET:WORDSIZE then a read/modify write will 562 be needed. Read in the entire word. */ 563 if (rounded_offset < offset 564 || (offset + partial_len 565 < rounded_offset + sizeof (PTRACE_TYPE_RET))) 566 { 567 /* Need part of initial word -- fetch it. */ 568 if (arch64) 569 buffer.word = rs6000_ptrace64 (PT_READ_I, pid, 570 rounded_offset, 0, NULL); 571 else 572 buffer.word = rs6000_ptrace32 (PT_READ_I, pid, 573 (int *) (uintptr_t) 574 rounded_offset, 575 0, NULL); 576 } 577 578 /* Copy data to be written over corresponding part of 579 buffer. */ 580 memcpy (buffer.byte + (offset - rounded_offset), 581 writebuf, partial_len); 582 583 errno = 0; 584 if (arch64) 585 rs6000_ptrace64 (PT_WRITE_D, pid, 586 rounded_offset, buffer.word, NULL); 587 else 588 rs6000_ptrace32 (PT_WRITE_D, pid, 589 (int *) (uintptr_t) rounded_offset, 590 buffer.word, NULL); 591 if (errno) 592 return TARGET_XFER_EOF; 593 } 594 595 if (readbuf) 596 { 597 errno = 0; 598 if (arch64) 599 buffer.word = rs6000_ptrace64 (PT_READ_I, pid, 600 rounded_offset, 0, NULL); 601 else 602 buffer.word = rs6000_ptrace32 (PT_READ_I, pid, 603 (int *)(uintptr_t)rounded_offset, 604 0, NULL); 605 if (errno) 606 return TARGET_XFER_EOF; 607 608 /* Copy appropriate bytes out of the buffer. */ 609 memcpy (readbuf, buffer.byte + (offset - rounded_offset), 610 partial_len); 611 } 612 613 *xfered_len = (ULONGEST) partial_len; 614 return TARGET_XFER_OK; 615 } 616 617 default: 618 return TARGET_XFER_E_IO; 619 } 620} 621 622/* Wait for the child specified by PTID to do something. Return the 623 process ID of the child, or MINUS_ONE_PTID in case of error; store 624 the status in *OURSTATUS. */ 625 626ptid_t 627rs6000_nat_target::wait (ptid_t ptid, struct target_waitstatus *ourstatus, 628 target_wait_flags options) 629{ 630 pid_t pid; 631 int status, save_errno; 632 633 while (1) 634 { 635 set_sigint_trap (); 636 637 do 638 { 639 pid = waitpid (ptid.pid (), &status, 0); 640 save_errno = errno; 641 } 642 while (pid == -1 && errno == EINTR); 643 644 clear_sigint_trap (); 645 646 if (pid == -1) 647 { 648 gdb_printf (gdb_stderr, 649 _("Child process unexpectedly missing: %s.\n"), 650 safe_strerror (save_errno)); 651 652 ourstatus->set_ignore (); 653 return minus_one_ptid; 654 } 655 656 /* Ignore terminated detached child processes. */ 657 if (!WIFSTOPPED (status) && find_inferior_pid (this, pid) == nullptr) 658 continue; 659 660 /* Check for a fork () event. */ 661 if ((status & 0xff) == W_SFWTED) 662 { 663 /* Checking whether it is a parent or a child event. */ 664 665 /* If the event is a child we check if there was a parent 666 event recorded before. If yes we got the parent child 667 relationship. If not we push this child and wait for 668 the next fork () event. */ 669 if (find_inferior_pid (this, pid) == nullptr) 670 { 671 pid_t parent_pid = has_my_aix_parent_reported (pid); 672 if (parent_pid > 0) 673 { 674 ourstatus->set_forked (ptid_t (pid)); 675 return ptid_t (parent_pid); 676 } 677 aix_remember_child (pid); 678 } 679 680 /* If the event is a parent we check if there was a child 681 event recorded before. If yes we got the parent child 682 relationship. If not we push this parent and wait for 683 the next fork () event. */ 684 else 685 { 686 pid_t child_pid = has_my_aix_child_reported (pid); 687 if (child_pid > 0) 688 { 689 ourstatus->set_forked (ptid_t (child_pid)); 690 return ptid_t (pid); 691 } 692 aix_remember_parent (pid); 693 } 694 continue; 695 } 696 697 break; 698 } 699 700 /* AIX has a couple of strange returns from wait(). */ 701 702 /* stop after load" status. */ 703 if (status == 0x57c) 704 ourstatus->set_loaded (); 705 /* 0x7f is signal 0. 0x17f and 0x137f are status returned 706 if we follow parent, a switch is made to a child post parent 707 execution and child continues its execution [user switches 708 to child and presses continue]. */ 709 else if (status == 0x7f || status == 0x17f || status == 0x137f) 710 ourstatus->set_spurious (); 711 /* A normal waitstatus. Let the usual macros deal with it. */ 712 else 713 *ourstatus = host_status_to_waitstatus (status); 714 715 return ptid_t (pid); 716} 717 718 719/* Set the current architecture from the host running GDB. Called when 720 starting a child process. */ 721 722void 723rs6000_nat_target::create_inferior (const char *exec_file, 724 const std::string &allargs, 725 char **env, int from_tty) 726{ 727 enum bfd_architecture arch; 728 unsigned long mach; 729 bfd abfd; 730 731 inf_ptrace_target::create_inferior (exec_file, allargs, env, from_tty); 732 733 if (__power_rs ()) 734 { 735 arch = bfd_arch_rs6000; 736 mach = bfd_mach_rs6k; 737 } 738 else 739 { 740 arch = bfd_arch_powerpc; 741 mach = bfd_mach_ppc; 742 } 743 744 /* FIXME: schauer/2002-02-25: 745 We don't know if we are executing a 32 or 64 bit executable, 746 and have no way to pass the proper word size to rs6000_gdbarch_init. 747 So we have to avoid switching to a new architecture, if the architecture 748 matches already. 749 Blindly calling rs6000_gdbarch_init used to work in older versions of 750 GDB, as rs6000_gdbarch_init incorrectly used the previous tdep to 751 determine the wordsize. */ 752 if (current_program_space->exec_bfd ()) 753 { 754 const struct bfd_arch_info *exec_bfd_arch_info; 755 756 exec_bfd_arch_info 757 = bfd_get_arch_info (current_program_space->exec_bfd ()); 758 if (arch == exec_bfd_arch_info->arch) 759 return; 760 } 761 762 bfd_default_set_arch_mach (&abfd, arch, mach); 763 764 gdbarch_info info; 765 info.bfd_arch_info = bfd_get_arch_info (&abfd); 766 info.abfd = current_program_space->exec_bfd (); 767 768 if (!gdbarch_update_p (info)) 769 internal_error (_("rs6000_create_inferior: failed " 770 "to select architecture")); 771} 772 773 774/* Shared Object support. */ 775 776/* Return the LdInfo data for the given process. Raises an error 777 if the data could not be obtained. */ 778 779static gdb::byte_vector 780rs6000_ptrace_ldinfo (ptid_t ptid) 781{ 782 const int pid = ptid.pid (); 783 gdb::byte_vector ldi (1024); 784 int rc = -1; 785 786 while (1) 787 { 788 if (ARCH64 ()) 789 rc = rs6000_ptrace64 (PT_LDINFO, pid, (unsigned long) ldi.data (), 790 ldi.size (), NULL); 791 else 792 rc = rs6000_ptrace32 (PT_LDINFO, pid, (int *) ldi.data (), 793 ldi.size (), NULL); 794 795 if (rc != -1) 796 break; /* Success, we got the entire ld_info data. */ 797 798 if (errno != ENOMEM) 799 perror_with_name (_("ptrace ldinfo")); 800 801 /* ldi is not big enough. Double it and try again. */ 802 ldi.resize (ldi.size () * 2); 803 } 804 805 return ldi; 806} 807 808/* Implement the to_xfer_partial target_ops method for 809 TARGET_OBJECT_LIBRARIES_AIX objects. */ 810 811enum target_xfer_status 812rs6000_nat_target::xfer_shared_libraries 813 (enum target_object object, 814 const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, 815 ULONGEST offset, ULONGEST len, ULONGEST *xfered_len) 816{ 817 ULONGEST result; 818 819 /* This function assumes that it is being run with a live process. 820 Core files are handled via gdbarch. */ 821 gdb_assert (target_has_execution ()); 822 823 if (writebuf) 824 return TARGET_XFER_E_IO; 825 826 gdb::byte_vector ldi_buf = rs6000_ptrace_ldinfo (inferior_ptid); 827 result = rs6000_aix_ld_info_to_xml (target_gdbarch (), ldi_buf.data (), 828 readbuf, offset, len, 1); 829 830 if (result == 0) 831 return TARGET_XFER_EOF; 832 else 833 { 834 *xfered_len = result; 835 return TARGET_XFER_OK; 836 } 837} 838 839void _initialize_rs6000_nat (); 840void 841_initialize_rs6000_nat () 842{ 843 add_inf_child_target (&the_rs6000_nat_target); 844} 845