gdb/rs6000-nat.c

   1 /* IBM RS/6000 native-dependent code for GDB, the GNU debugger.
   2
   3    Copyright (C) 1986-2013 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 "libbfd.h"             /* For bfd_default_set_arch_mach (FIXME) */
  27 #include "bfd.h"
  28 #include "exceptions.h"
  29 #include "gdb-stabs.h"
  30 #include "regcache.h"
  31 #include "arch-utils.h"
  32 #include "inf-child.h"
  33 #include "inf-ptrace.h"
  34 #include "ppc-tdep.h"
  35 #include "rs6000-tdep.h"
  36 #include "rs6000-aix-tdep.h"
  37 #include "exec.h"
  38 #include "observer.h"
  39 #include "xcoffread.h"
  40
  41 #include <sys/ptrace.h>
  42 #include <sys/reg.h>
  43
  44 #include <sys/dir.h>
  45 #include <sys/user.h>
  46 #include <signal.h>
  47 #include <sys/ioctl.h>
  48 #include <fcntl.h>
  49 #include <errno.h>
  50
  51 #include <a.out.h>
  52 #include <sys/file.h>
  53 #include "gdb_stat.h"
  54 #include "gdb_bfd.h"
  55 #include <sys/core.h>
  56 #define __LDINFO_PTRACE32__     /* for __ld_info32 */
  57 #define __LDINFO_PTRACE64__     /* for __ld_info64 */
  58 #include <sys/ldr.h>
  59 #include <sys/systemcfg.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
  80 static void exec_one_dummy_insn (struct regcache *);
  81
  82 static LONGEST rs6000_xfer_shared_libraries
  83   (struct target_ops *ops, enum target_object object,
  84    const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf,
  85    ULONGEST offset, LONGEST len);
  86
  87 /* Given REGNO, a gdb register number, return the corresponding
  88    number suitable for use as a ptrace() parameter.  Return -1 if
  89    there's no suitable mapping.  Also, set the int pointed to by
  90    ISFLOAT to indicate whether REGNO is a floating point register.  */
  91
  92 static int
  93 regmap (struct gdbarch *gdbarch, int regno, int *isfloat)
  94 {
  95   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
  96
  97   *isfloat = 0;
  98   if (tdep->ppc_gp0_regnum <= regno
  99       && regno < tdep->ppc_gp0_regnum + ppc_num_gprs)
 100     return regno;
 101   else if (tdep->ppc_fp0_regnum >= 0
 102            && tdep->ppc_fp0_regnum <= regno
 103            && regno < tdep->ppc_fp0_regnum + ppc_num_fprs)
 104     {
 105       *isfloat = 1;
 106       return regno - tdep->ppc_fp0_regnum + FPR0;
 107     }
 108   else if (regno == gdbarch_pc_regnum (gdbarch))
 109     return IAR;
 110   else if (regno == tdep->ppc_ps_regnum)
 111     return MSR;
 112   else if (regno == tdep->ppc_cr_regnum)
 113     return CR;
 114   else if (regno == tdep->ppc_lr_regnum)
 115     return LR;
 116   else if (regno == tdep->ppc_ctr_regnum)
 117     return CTR;
 118   else if (regno == tdep->ppc_xer_regnum)
 119     return XER;
 120   else if (tdep->ppc_fpscr_regnum >= 0
 121            && regno == tdep->ppc_fpscr_regnum)
 122     return FPSCR;
 123   else if (tdep->ppc_mq_regnum >= 0 && regno == tdep->ppc_mq_regnum)
 124     return MQ;
 125   else
 126     return -1;
 127 }
 128
 129 /* Call ptrace(REQ, ID, ADDR, DATA, BUF).  */
 130
 131 static int
 132 rs6000_ptrace32 (int req, int id, int *addr, int data, int *buf)
 133 {
 134 #ifdef HAVE_PTRACE64
 135   int ret = ptrace64 (req, id, (uintptr_t) addr, data, buf);
 136 #else
 137   int ret = ptrace (req, id, (int *)addr, data, buf);
 138 #endif
 139 #if 0
 140   printf ("rs6000_ptrace32 (%d, %d, 0x%x, %08x, 0x%x) = 0x%x\n",
 141           req, id, (unsigned int)addr, data, (unsigned int)buf, ret);
 142 #endif
 143   return ret;
 144 }
 145
 146 /* Call ptracex(REQ, ID, ADDR, DATA, BUF).  */
 147
 148 static int
 149 rs6000_ptrace64 (int req, int id, long long addr, int data, void *buf)
 150 {
 151 #ifdef ARCH3264
 152 #  ifdef HAVE_PTRACE64
 153   int ret = ptrace64 (req, id, addr, data, buf);
 154 #  else
 155   int ret = ptracex (req, id, addr, data, buf);
 156 #  endif
 157 #else
 158   int ret = 0;
 159 #endif
 160 #if 0
 161   printf ("rs6000_ptrace64 (%d, %d, %s, %08x, 0x%x) = 0x%x\n",
 162           req, id, hex_string (addr), data, (unsigned int)buf, ret);
 163 #endif
 164   return ret;
 165 }
 166
 167 /* Fetch register REGNO from the inferior.  */
 168
 169 static void
 170 fetch_register (struct regcache *regcache, int regno)
 171 {
 172   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 173   int addr[MAX_REGISTER_SIZE];
 174   int nr, isfloat;
 175
 176   /* Retrieved values may be -1, so infer errors from errno.  */
 177   errno = 0;
 178
 179   nr = regmap (gdbarch, regno, &isfloat);
 180
 181   /* Floating-point registers.  */
 182   if (isfloat)
 183     rs6000_ptrace32 (PT_READ_FPR, PIDGET (inferior_ptid), addr, nr, 0);
 184
 185   /* Bogus register number.  */
 186   else if (nr < 0)
 187     {
 188       if (regno >= gdbarch_num_regs (gdbarch))
 189         fprintf_unfiltered (gdb_stderr,
 190                             "gdb error: register no %d not implemented.\n",
 191                             regno);
 192       return;
 193     }
 194
 195   /* Fixed-point registers.  */
 196   else
 197     {
 198       if (!ARCH64 ())
 199         *addr = rs6000_ptrace32 (PT_READ_GPR, PIDGET (inferior_ptid),
 200                                  (int *) nr, 0, 0);
 201       else
 202         {
 203           /* PT_READ_GPR requires the buffer parameter to point to long long,
 204              even if the register is really only 32 bits.  */
 205           long long buf;
 206           rs6000_ptrace64 (PT_READ_GPR, PIDGET (inferior_ptid), nr, 0, &buf);
 207           if (register_size (gdbarch, regno) == 8)
 208             memcpy (addr, &buf, 8);
 209           else
 210             *addr = buf;
 211         }
 212     }
 213
 214   if (!errno)
 215     regcache_raw_supply (regcache, regno, (char *) addr);
 216   else
 217     {
 218 #if 0
 219       /* FIXME: this happens 3 times at the start of each 64-bit program.  */
 220       perror (_("ptrace read"));
 221 #endif
 222       errno = 0;
 223     }
 224 }
 225
 226 /* Store register REGNO back into the inferior.  */
 227
 228 static void
 229 store_register (struct regcache *regcache, int regno)
 230 {
 231   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 232   int addr[MAX_REGISTER_SIZE];
 233   int nr, isfloat;
 234
 235   /* Fetch the register's value from the register cache.  */
 236   regcache_raw_collect (regcache, regno, addr);
 237
 238   /* -1 can be a successful return value, so infer errors from errno.  */
 239   errno = 0;
 240
 241   nr = regmap (gdbarch, regno, &isfloat);
 242
 243   /* Floating-point registers.  */
 244   if (isfloat)
 245     rs6000_ptrace32 (PT_WRITE_FPR, PIDGET (inferior_ptid), addr, nr, 0);
 246
 247   /* Bogus register number.  */
 248   else if (nr < 0)
 249     {
 250       if (regno >= gdbarch_num_regs (gdbarch))
 251         fprintf_unfiltered (gdb_stderr,
 252                             "gdb error: register no %d not implemented.\n",
 253                             regno);
 254     }
 255
 256   /* Fixed-point registers.  */
 257   else
 258     {
 259       if (regno == gdbarch_sp_regnum (gdbarch))
 260         /* Execute one dummy instruction (which is a breakpoint) in inferior
 261            process to give kernel a chance to do internal housekeeping.
 262            Otherwise the following ptrace(2) calls will mess up user stack
 263            since kernel will get confused about the bottom of the stack
 264            (%sp).  */
 265         exec_one_dummy_insn (regcache);
 266
 267       /* The PT_WRITE_GPR operation is rather odd.  For 32-bit inferiors,
 268          the register's value is passed by value, but for 64-bit inferiors,
 269          the address of a buffer containing the value is passed.  */
 270       if (!ARCH64 ())
 271         rs6000_ptrace32 (PT_WRITE_GPR, PIDGET (inferior_ptid),
 272                          (int *) nr, *addr, 0);
 273       else
 274         {
 275           /* PT_WRITE_GPR requires the buffer parameter to point to an 8-byte
 276              area, even if the register is really only 32 bits.  */
 277           long long buf;
 278           if (register_size (gdbarch, regno) == 8)
 279             memcpy (&buf, addr, 8);
 280           else
 281             buf = *addr;
 282           rs6000_ptrace64 (PT_WRITE_GPR, PIDGET (inferior_ptid), nr, 0, &buf);
 283         }
 284     }
 285
 286   if (errno)
 287     {
 288       perror (_("ptrace write"));
 289       errno = 0;
 290     }
 291 }
 292
 293 /* Read from the inferior all registers if REGNO == -1 and just register
 294    REGNO otherwise.  */
 295
 296 static void
 297 rs6000_fetch_inferior_registers (struct target_ops *ops,
 298                                  struct regcache *regcache, int regno)
 299 {
 300   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 301   if (regno != -1)
 302     fetch_register (regcache, regno);
 303
 304   else
 305     {
 306       struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 307
 308       /* Read 32 general purpose registers.  */
 309       for (regno = tdep->ppc_gp0_regnum;
 310            regno < tdep->ppc_gp0_regnum + ppc_num_gprs;
 311            regno++)
 312         {
 313           fetch_register (regcache, regno);
 314         }
 315
 316       /* Read general purpose floating point registers.  */
 317       if (tdep->ppc_fp0_regnum >= 0)
 318         for (regno = 0; regno < ppc_num_fprs; regno++)
 319           fetch_register (regcache, tdep->ppc_fp0_regnum + regno);
 320
 321       /* Read special registers.  */
 322       fetch_register (regcache, gdbarch_pc_regnum (gdbarch));
 323       fetch_register (regcache, tdep->ppc_ps_regnum);
 324       fetch_register (regcache, tdep->ppc_cr_regnum);
 325       fetch_register (regcache, tdep->ppc_lr_regnum);
 326       fetch_register (regcache, tdep->ppc_ctr_regnum);
 327       fetch_register (regcache, tdep->ppc_xer_regnum);
 328       if (tdep->ppc_fpscr_regnum >= 0)
 329         fetch_register (regcache, tdep->ppc_fpscr_regnum);
 330       if (tdep->ppc_mq_regnum >= 0)
 331         fetch_register (regcache, tdep->ppc_mq_regnum);
 332     }
 333 }
 334
 335 /* Store our register values back into the inferior.
 336    If REGNO is -1, do this for all registers.
 337    Otherwise, REGNO specifies which register (so we can save time).  */
 338
 339 static void
 340 rs6000_store_inferior_registers (struct target_ops *ops,
 341                                  struct regcache *regcache, int regno)
 342 {
 343   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 344   if (regno != -1)
 345     store_register (regcache, regno);
 346
 347   else
 348     {
 349       struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 350
 351       /* Write general purpose registers first.  */
 352       for (regno = tdep->ppc_gp0_regnum;
 353            regno < tdep->ppc_gp0_regnum + ppc_num_gprs;
 354            regno++)
 355         {
 356           store_register (regcache, regno);
 357         }
 358
 359       /* Write floating point registers.  */
 360       if (tdep->ppc_fp0_regnum >= 0)
 361         for (regno = 0; regno < ppc_num_fprs; regno++)
 362           store_register (regcache, tdep->ppc_fp0_regnum + regno);
 363
 364       /* Write special registers.  */
 365       store_register (regcache, gdbarch_pc_regnum (gdbarch));
 366       store_register (regcache, tdep->ppc_ps_regnum);
 367       store_register (regcache, tdep->ppc_cr_regnum);
 368       store_register (regcache, tdep->ppc_lr_regnum);
 369       store_register (regcache, tdep->ppc_ctr_regnum);
 370       store_register (regcache, tdep->ppc_xer_regnum);
 371       if (tdep->ppc_fpscr_regnum >= 0)
 372         store_register (regcache, tdep->ppc_fpscr_regnum);
 373       if (tdep->ppc_mq_regnum >= 0)
 374         store_register (regcache, tdep->ppc_mq_regnum);
 375     }
 376 }
 377
 378
 379 /* Attempt a transfer all LEN bytes starting at OFFSET between the
 380    inferior's OBJECT:ANNEX space and GDB's READBUF/WRITEBUF buffer.
 381    Return the number of bytes actually transferred.  */
 382
 383 static LONGEST
 384 rs6000_xfer_partial (struct target_ops *ops, enum target_object object,
 385                      const char *annex, gdb_byte *readbuf,
 386                      const gdb_byte *writebuf,
 387                      ULONGEST offset, LONGEST len)
 388 {
 389   pid_t pid = ptid_get_pid (inferior_ptid);
 390   int arch64 = ARCH64 ();
 391
 392   switch (object)
 393     {
 394     case TARGET_OBJECT_LIBRARIES_AIX:
 395       return rs6000_xfer_shared_libraries (ops, object, annex,
 396                                            readbuf, writebuf,
 397                                            offset, len);
 398     case TARGET_OBJECT_MEMORY:
 399       {
 400         union
 401         {
 402           PTRACE_TYPE_RET word;
 403           gdb_byte byte[sizeof (PTRACE_TYPE_RET)];
 404         } buffer;
 405         ULONGEST rounded_offset;
 406         LONGEST partial_len;
 407
 408         /* Round the start offset down to the next long word
 409            boundary.  */
 410         rounded_offset = offset & -(ULONGEST) sizeof (PTRACE_TYPE_RET);
 411
 412         /* Since ptrace will transfer a single word starting at that
 413            rounded_offset the partial_len needs to be adjusted down to
 414            that (remember this function only does a single transfer).
 415            Should the required length be even less, adjust it down
 416            again.  */
 417         partial_len = (rounded_offset + sizeof (PTRACE_TYPE_RET)) - offset;
 418         if (partial_len > len)
 419           partial_len = len;
 420
 421         if (writebuf)
 422           {
 423             /* If OFFSET:PARTIAL_LEN is smaller than
 424                ROUNDED_OFFSET:WORDSIZE then a read/modify write will
 425                be needed.  Read in the entire word.  */
 426             if (rounded_offset < offset
 427                 || (offset + partial_len
 428                     < rounded_offset + sizeof (PTRACE_TYPE_RET)))
 429               {
 430                 /* Need part of initial word -- fetch it.  */
 431                 if (arch64)
 432                   buffer.word = rs6000_ptrace64 (PT_READ_I, pid,
 433                                                  rounded_offset, 0, NULL);
 434                 else
 435                   buffer.word = rs6000_ptrace32 (PT_READ_I, pid,
 436                                                  (int *) (uintptr_t)
 437                                                  rounded_offset,
 438                                                  0, NULL);
 439               }
 440
 441             /* Copy data to be written over corresponding part of
 442                buffer.  */
 443             memcpy (buffer.byte + (offset - rounded_offset),
 444                     writebuf, partial_len);
 445
 446             errno = 0;
 447             if (arch64)
 448               rs6000_ptrace64 (PT_WRITE_D, pid,
 449                                rounded_offset, buffer.word, NULL);
 450             else
 451               rs6000_ptrace32 (PT_WRITE_D, pid,
 452                                (int *) (uintptr_t) rounded_offset,
 453                                buffer.word, NULL);
 454             if (errno)
 455               return 0;
 456           }
 457
 458         if (readbuf)
 459           {
 460             errno = 0;
 461             if (arch64)
 462               buffer.word = rs6000_ptrace64 (PT_READ_I, pid,
 463                                              rounded_offset, 0, NULL);
 464             else
 465               buffer.word = rs6000_ptrace32 (PT_READ_I, pid,
 466                                              (int *)(uintptr_t)rounded_offset,
 467                                              0, NULL);
 468             if (errno)
 469               return 0;
 470
 471             /* Copy appropriate bytes out of the buffer.  */
 472             memcpy (readbuf, buffer.byte + (offset - rounded_offset),
 473                     partial_len);
 474           }
 475
 476         return partial_len;
 477       }
 478
 479     default:
 480       return -1;
 481     }
 482 }
 483
 484 /* Wait for the child specified by PTID to do something.  Return the
 485    process ID of the child, or MINUS_ONE_PTID in case of error; store
 486    the status in *OURSTATUS.  */
 487
 488 static ptid_t
 489 rs6000_wait (struct target_ops *ops,
 490              ptid_t ptid, struct target_waitstatus *ourstatus, int options)
 491 {
 492   pid_t pid;
 493   int status, save_errno;
 494
 495   do
 496     {
 497       set_sigint_trap ();
 498
 499       do
 500         {
 501           pid = waitpid (ptid_get_pid (ptid), &status, 0);
 502           save_errno = errno;
 503         }
 504       while (pid == -1 && errno == EINTR);
 505
 506       clear_sigint_trap ();
 507
 508       if (pid == -1)
 509         {
 510           fprintf_unfiltered (gdb_stderr,
 511                               _("Child process unexpectedly missing: %s.\n"),
 512                               safe_strerror (save_errno));
 513
 514           /* Claim it exited with unknown signal.  */
 515           ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
 516           ourstatus->value.sig = GDB_SIGNAL_UNKNOWN;
 517           return inferior_ptid;
 518         }
 519
 520       /* Ignore terminated detached child processes.  */
 521       if (!WIFSTOPPED (status) && pid != ptid_get_pid (inferior_ptid))
 522         pid = -1;
 523     }
 524   while (pid == -1);
 525
 526   /* AIX has a couple of strange returns from wait().  */
 527
 528   /* stop after load" status.  */
 529   if (status == 0x57c)
 530     ourstatus->kind = TARGET_WAITKIND_LOADED;
 531   /* signal 0.  I have no idea why wait(2) returns with this status word.  */
 532   else if (status == 0x7f)
 533     ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
 534   /* A normal waitstatus.  Let the usual macros deal with it.  */
 535   else
 536     store_waitstatus (ourstatus, status);
 537
 538   return pid_to_ptid (pid);
 539 }
 540
 541 /* Execute one dummy breakpoint instruction.  This way we give the kernel
 542    a chance to do some housekeeping and update inferior's internal data,
 543    including u_area.  */
 544
 545 static void
 546 exec_one_dummy_insn (struct regcache *regcache)
 547 {
 548 #define DUMMY_INSN_ADDR AIX_TEXT_SEGMENT_BASE+0x200
 549
 550   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 551   int ret, status, pid;
 552   CORE_ADDR prev_pc;
 553   void *bp;
 554
 555   /* We plant one dummy breakpoint into DUMMY_INSN_ADDR address.  We
 556      assume that this address will never be executed again by the real
 557      code.  */
 558
 559   bp = deprecated_insert_raw_breakpoint (gdbarch, NULL, DUMMY_INSN_ADDR);
 560
 561   /* You might think this could be done with a single ptrace call, and
 562      you'd be correct for just about every platform I've ever worked
 563      on.  However, rs6000-ibm-aix4.1.3 seems to have screwed this up --
 564      the inferior never hits the breakpoint (it's also worth noting
 565      powerpc-ibm-aix4.1.3 works correctly).  */
 566   prev_pc = regcache_read_pc (regcache);
 567   regcache_write_pc (regcache, DUMMY_INSN_ADDR);
 568   if (ARCH64 ())
 569     ret = rs6000_ptrace64 (PT_CONTINUE, PIDGET (inferior_ptid), 1, 0, NULL);
 570   else
 571     ret = rs6000_ptrace32 (PT_CONTINUE, PIDGET (inferior_ptid),
 572                            (int *) 1, 0, NULL);
 573
 574   if (ret != 0)
 575     perror (_("pt_continue"));
 576
 577   do
 578     {
 579       pid = waitpid (PIDGET (inferior_ptid), &status, 0);
 580     }
 581   while (pid != PIDGET (inferior_ptid));
 582
 583   regcache_write_pc (regcache, prev_pc);
 584   deprecated_remove_raw_breakpoint (gdbarch, bp);
 585 }
 586 \f
 587
 588 /* Set the current architecture from the host running GDB.  Called when
 589    starting a child process.  */
 590
 591 static void (*super_create_inferior) (struct target_ops *,char *exec_file,
 592                                       char *allargs, char **env, int from_tty);
 593 static void
 594 rs6000_create_inferior (struct target_ops * ops, char *exec_file,
 595                         char *allargs, char **env, int from_tty)
 596 {
 597   enum bfd_architecture arch;
 598   unsigned long mach;
 599   bfd abfd;
 600   struct gdbarch_info info;
 601
 602   super_create_inferior (ops, exec_file, allargs, env, from_tty);
 603
 604   if (__power_rs ())
 605     {
 606       arch = bfd_arch_rs6000;
 607       mach = bfd_mach_rs6k;
 608     }
 609   else
 610     {
 611       arch = bfd_arch_powerpc;
 612       mach = bfd_mach_ppc;
 613     }
 614
 615   /* FIXME: schauer/2002-02-25:
 616      We don't know if we are executing a 32 or 64 bit executable,
 617      and have no way to pass the proper word size to rs6000_gdbarch_init.
 618      So we have to avoid switching to a new architecture, if the architecture
 619      matches already.
 620      Blindly calling rs6000_gdbarch_init used to work in older versions of
 621      GDB, as rs6000_gdbarch_init incorrectly used the previous tdep to
 622      determine the wordsize.  */
 623   if (exec_bfd)
 624     {
 625       const struct bfd_arch_info *exec_bfd_arch_info;
 626
 627       exec_bfd_arch_info = bfd_get_arch_info (exec_bfd);
 628       if (arch == exec_bfd_arch_info->arch)
 629         return;
 630     }
 631
 632   bfd_default_set_arch_mach (&abfd, arch, mach);
 633
 634   gdbarch_info_init (&info);
 635   info.bfd_arch_info = bfd_get_arch_info (&abfd);
 636   info.abfd = exec_bfd;
 637
 638   if (!gdbarch_update_p (info))
 639     internal_error (__FILE__, __LINE__,
 640                     _("rs6000_create_inferior: failed "
 641                       "to select architecture"));
 642 }
 643 \f
 644
 645 /* Shared Object support.  */
 646
 647 /* Return the LdInfo data for the given process.  Raises an error
 648    if the data could not be obtained.
 649
 650    The returned value must be deallocated after use.  */
 651
 652 static gdb_byte *
 653 rs6000_ptrace_ldinfo (ptid_t ptid)
 654 {
 655   const int pid = ptid_get_pid (ptid);
 656   int ldi_size = 1024;
 657   gdb_byte *ldi = xmalloc (ldi_size);
 658   int rc = -1;
 659
 660   while (1)
 661     {
 662       if (ARCH64 ())
 663         rc = rs6000_ptrace64 (PT_LDINFO, pid, (unsigned long) ldi, ldi_size,
 664                               NULL);
 665       else
 666         rc = rs6000_ptrace32 (PT_LDINFO, pid, (int *) ldi, ldi_size, NULL);
 667
 668       if (rc != -1)
 669         break; /* Success, we got the entire ld_info data.  */
 670
 671       if (errno != ENOMEM)
 672         perror_with_name (_("ptrace ldinfo"));
 673
 674       /* ldi is not big enough.  Double it and try again.  */
 675       ldi_size *= 2;
 676       ldi = xrealloc (ldi, ldi_size);
 677     }
 678
 679   return ldi;
 680 }
 681
 682 /* Implement the to_xfer_partial target_ops method for
 683    TARGET_OBJECT_LIBRARIES_AIX objects.  */
 684
 685 static LONGEST
 686 rs6000_xfer_shared_libraries
 687   (struct target_ops *ops, enum target_object object,
 688    const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf,
 689    ULONGEST offset, LONGEST len)
 690 {
 691   gdb_byte *ldi_buf;
 692   ULONGEST result;
 693   struct cleanup *cleanup;
 694
 695   /* This function assumes that it is being run with a live process.
 696      Core files are handled via gdbarch.  */
 697   gdb_assert (target_has_execution);
 698
 699   if (writebuf)
 700     return -1;
 701
 702   ldi_buf = rs6000_ptrace_ldinfo (inferior_ptid);
 703   gdb_assert (ldi_buf != NULL);
 704   cleanup = make_cleanup (xfree, ldi_buf);
 705   result = rs6000_aix_ld_info_to_xml (target_gdbarch (), ldi_buf,
 706                                       readbuf, offset, len, 1);
 707   xfree (ldi_buf);
 708
 709   do_cleanups (cleanup);
 710   return result;
 711 }
 712
 713 void _initialize_rs6000_nat (void);
 714
 715 void
 716 _initialize_rs6000_nat (void)
 717 {
 718   struct target_ops *t;
 719
 720   t = inf_ptrace_target ();
 721   t->to_fetch_registers = rs6000_fetch_inferior_registers;
 722   t->to_store_registers = rs6000_store_inferior_registers;
 723   t->to_xfer_partial = rs6000_xfer_partial;
 724
 725   super_create_inferior = t->to_create_inferior;
 726   t->to_create_inferior = rs6000_create_inferior;
 727
 728   t->to_wait = rs6000_wait;
 729
 730   add_target (t);
 731 }