gdb/rs6000-nat.c

   1 /* IBM RS/6000 native-dependent code for GDB, the GNU debugger.
   2
   3    Copyright (C) 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
   4    1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007
   5    Free Software Foundation, Inc.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 2 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 51 Franklin Street, Fifth Floor,
  22    Boston, MA 02110-1301, USA.  */
  23
  24 #include "defs.h"
  25 #include "inferior.h"
  26 #include "target.h"
  27 #include "gdbcore.h"
  28 #include "xcoffsolib.h"
  29 #include "symfile.h"
  30 #include "objfiles.h"
  31 #include "libbfd.h"             /* For bfd_default_set_arch_mach (FIXME) */
  32 #include "bfd.h"
  33 #include "exceptions.h"
  34 #include "gdb-stabs.h"
  35 #include "regcache.h"
  36 #include "arch-utils.h"
  37 #include "inf-ptrace.h"
  38 #include "ppc-tdep.h"
  39 #include "rs6000-tdep.h"
  40 #include "exec.h"
  41 #include "gdb_stdint.h"
  42
  43 #include <sys/ptrace.h>
  44 #include <sys/reg.h>
  45
  46 #include <sys/param.h>
  47 #include <sys/dir.h>
  48 #include <sys/user.h>
  49 #include <signal.h>
  50 #include <sys/ioctl.h>
  51 #include <fcntl.h>
  52 #include <errno.h>
  53
  54 #include <a.out.h>
  55 #include <sys/file.h>
  56 #include "gdb_stat.h"
  57 #include <sys/core.h>
  58 #define __LDINFO_PTRACE32__     /* for __ld_info32 */
  59 #define __LDINFO_PTRACE64__     /* for __ld_info64 */
  60 #include <sys/ldr.h>
  61 #include <sys/systemcfg.h>
  62
  63 /* On AIX4.3+, sys/ldr.h provides different versions of struct ld_info for
  64    debugging 32-bit and 64-bit processes.  Define a typedef and macros for
  65    accessing fields in the appropriate structures. */
  66
  67 /* In 32-bit compilation mode (which is the only mode from which ptrace()
  68    works on 4.3), __ld_info32 is #defined as equivalent to ld_info. */
  69
  70 #ifdef __ld_info32
  71 # define ARCH3264
  72 #endif
  73
  74 /* Return whether the current architecture is 64-bit. */
  75
  76 #ifndef ARCH3264
  77 # define ARCH64() 0
  78 #else
  79 # define ARCH64() (register_size (current_gdbarch, 0) == 8)
  80 #endif
  81
  82 /* Union of 32-bit and 64-bit ".reg" core file sections. */
  83
  84 typedef union {
  85 #ifdef ARCH3264
  86   struct __context64 r64;
  87 #else
  88   struct mstsave r64;
  89 #endif
  90   struct mstsave r32;
  91 } CoreRegs;
  92
  93 /* Union of 32-bit and 64-bit versions of ld_info. */
  94
  95 typedef union {
  96 #ifndef ARCH3264
  97   struct ld_info l32;
  98   struct ld_info l64;
  99 #else
 100   struct __ld_info32 l32;
 101   struct __ld_info64 l64;
 102 #endif
 103 } LdInfo;
 104
 105 /* If compiling with 32-bit and 64-bit debugging capability (e.g. AIX 4.x),
 106    declare and initialize a variable named VAR suitable for use as the arch64
 107    parameter to the various LDI_*() macros. */
 108
 109 #ifndef ARCH3264
 110 # define ARCH64_DECL(var)
 111 #else
 112 # define ARCH64_DECL(var) int var = ARCH64 ()
 113 #endif
 114
 115 /* Return LDI's FIELD for a 64-bit process if ARCH64 and for a 32-bit process
 116    otherwise.  This technique only works for FIELDs with the same data type in
 117    32-bit and 64-bit versions of ld_info. */
 118
 119 #ifndef ARCH3264
 120 # define LDI_FIELD(ldi, arch64, field) (ldi)->l32.ldinfo_##field
 121 #else
 122 # define LDI_FIELD(ldi, arch64, field) \
 123   (arch64 ? (ldi)->l64.ldinfo_##field : (ldi)->l32.ldinfo_##field)
 124 #endif
 125
 126 /* Return various LDI fields for a 64-bit process if ARCH64 and for a 32-bit
 127    process otherwise. */
 128
 129 #define LDI_NEXT(ldi, arch64)           LDI_FIELD(ldi, arch64, next)
 130 #define LDI_FD(ldi, arch64)             LDI_FIELD(ldi, arch64, fd)
 131 #define LDI_FILENAME(ldi, arch64)       LDI_FIELD(ldi, arch64, filename)
 132
 133 extern struct vmap *map_vmap (bfd * bf, bfd * arch);
 134
 135 static void vmap_exec (void);
 136
 137 static void vmap_ldinfo (LdInfo *);
 138
 139 static struct vmap *add_vmap (LdInfo *);
 140
 141 static int objfile_symbol_add (void *);
 142
 143 static void vmap_symtab (struct vmap *);
 144
 145 static void fetch_core_registers (char *, unsigned int, int, CORE_ADDR);
 146
 147 static void exec_one_dummy_insn (void);
 148
 149 extern void fixup_breakpoints (CORE_ADDR low, CORE_ADDR high, CORE_ADDR delta);
 150
 151 /* Given REGNO, a gdb register number, return the corresponding
 152    number suitable for use as a ptrace() parameter.  Return -1 if
 153    there's no suitable mapping.  Also, set the int pointed to by
 154    ISFLOAT to indicate whether REGNO is a floating point register.  */
 155
 156 static int
 157 regmap (int regno, int *isfloat)
 158 {
 159   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
 160
 161   *isfloat = 0;
 162   if (tdep->ppc_gp0_regnum <= regno
 163       && regno < tdep->ppc_gp0_regnum + ppc_num_gprs)
 164     return regno;
 165   else if (tdep->ppc_fp0_regnum >= 0
 166            && tdep->ppc_fp0_regnum <= regno
 167            && regno < tdep->ppc_fp0_regnum + ppc_num_fprs)
 168     {
 169       *isfloat = 1;
 170       return regno - tdep->ppc_fp0_regnum + FPR0;
 171     }
 172   else if (regno == PC_REGNUM)
 173     return IAR;
 174   else if (regno == tdep->ppc_ps_regnum)
 175     return MSR;
 176   else if (regno == tdep->ppc_cr_regnum)
 177     return CR;
 178   else if (regno == tdep->ppc_lr_regnum)
 179     return LR;
 180   else if (regno == tdep->ppc_ctr_regnum)
 181     return CTR;
 182   else if (regno == tdep->ppc_xer_regnum)
 183     return XER;
 184   else if (tdep->ppc_fpscr_regnum >= 0
 185            && regno == tdep->ppc_fpscr_regnum)
 186     return FPSCR;
 187   else if (tdep->ppc_mq_regnum >= 0 && regno == tdep->ppc_mq_regnum)
 188     return MQ;
 189   else
 190     return -1;
 191 }
 192
 193 /* Call ptrace(REQ, ID, ADDR, DATA, BUF). */
 194
 195 static int
 196 rs6000_ptrace32 (int req, int id, int *addr, int data, int *buf)
 197 {
 198   int ret = ptrace (req, id, (int *)addr, data, buf);
 199 #if 0
 200   printf ("rs6000_ptrace32 (%d, %d, 0x%x, %08x, 0x%x) = 0x%x\n",
 201           req, id, (unsigned int)addr, data, (unsigned int)buf, ret);
 202 #endif
 203   return ret;
 204 }
 205
 206 /* Call ptracex(REQ, ID, ADDR, DATA, BUF). */
 207
 208 static int
 209 rs6000_ptrace64 (int req, int id, long long addr, int data, void *buf)
 210 {
 211 #ifdef ARCH3264
 212   int ret = ptracex (req, id, addr, data, buf);
 213 #else
 214   int ret = 0;
 215 #endif
 216 #if 0
 217   printf ("rs6000_ptrace64 (%d, %d, 0x%llx, %08x, 0x%x) = 0x%x\n",
 218           req, id, addr, data, (unsigned int)buf, ret);
 219 #endif
 220   return ret;
 221 }
 222
 223 /* Fetch register REGNO from the inferior. */
 224
 225 static void
 226 fetch_register (int regno)
 227 {
 228   int addr[MAX_REGISTER_SIZE];
 229   int nr, isfloat;
 230
 231   /* Retrieved values may be -1, so infer errors from errno. */
 232   errno = 0;
 233
 234   nr = regmap (regno, &isfloat);
 235
 236   /* Floating-point registers. */
 237   if (isfloat)
 238     rs6000_ptrace32 (PT_READ_FPR, PIDGET (inferior_ptid), addr, nr, 0);
 239
 240   /* Bogus register number. */
 241   else if (nr < 0)
 242     {
 243       if (regno >= NUM_REGS)
 244         fprintf_unfiltered (gdb_stderr,
 245                             "gdb error: register no %d not implemented.\n",
 246                             regno);
 247       return;
 248     }
 249
 250   /* Fixed-point registers. */
 251   else
 252     {
 253       if (!ARCH64 ())
 254         *addr = rs6000_ptrace32 (PT_READ_GPR, PIDGET (inferior_ptid), (int *)nr, 0, 0);
 255       else
 256         {
 257           /* PT_READ_GPR requires the buffer parameter to point to long long,
 258              even if the register is really only 32 bits. */
 259           long long buf;
 260           rs6000_ptrace64 (PT_READ_GPR, PIDGET (inferior_ptid), nr, 0, &buf);
 261           if (register_size (current_gdbarch, regno) == 8)
 262             memcpy (addr, &buf, 8);
 263           else
 264             *addr = buf;
 265         }
 266     }
 267
 268   if (!errno)
 269     regcache_raw_supply (current_regcache, regno, (char *) addr);
 270   else
 271     {
 272 #if 0
 273       /* FIXME: this happens 3 times at the start of each 64-bit program. */
 274       perror ("ptrace read");
 275 #endif
 276       errno = 0;
 277     }
 278 }
 279
 280 /* Store register REGNO back into the inferior. */
 281
 282 static void
 283 store_register (int regno)
 284 {
 285   int addr[MAX_REGISTER_SIZE];
 286   int nr, isfloat;
 287
 288   /* Fetch the register's value from the register cache.  */
 289   regcache_raw_collect (current_regcache, regno, addr);
 290
 291   /* -1 can be a successful return value, so infer errors from errno. */
 292   errno = 0;
 293
 294   nr = regmap (regno, &isfloat);
 295
 296   /* Floating-point registers. */
 297   if (isfloat)
 298     rs6000_ptrace32 (PT_WRITE_FPR, PIDGET (inferior_ptid), addr, nr, 0);
 299
 300   /* Bogus register number. */
 301   else if (nr < 0)
 302     {
 303       if (regno >= NUM_REGS)
 304         fprintf_unfiltered (gdb_stderr,
 305                             "gdb error: register no %d not implemented.\n",
 306                             regno);
 307     }
 308
 309   /* Fixed-point registers. */
 310   else
 311     {
 312       if (regno == SP_REGNUM)
 313         /* Execute one dummy instruction (which is a breakpoint) in inferior
 314            process to give kernel a chance to do internal housekeeping.
 315            Otherwise the following ptrace(2) calls will mess up user stack
 316            since kernel will get confused about the bottom of the stack
 317            (%sp). */
 318         exec_one_dummy_insn ();
 319
 320       /* The PT_WRITE_GPR operation is rather odd.  For 32-bit inferiors,
 321          the register's value is passed by value, but for 64-bit inferiors,
 322          the address of a buffer containing the value is passed.  */
 323       if (!ARCH64 ())
 324         rs6000_ptrace32 (PT_WRITE_GPR, PIDGET (inferior_ptid), (int *)nr, *addr, 0);
 325       else
 326         {
 327           /* PT_WRITE_GPR requires the buffer parameter to point to an 8-byte
 328              area, even if the register is really only 32 bits. */
 329           long long buf;
 330           if (register_size (current_gdbarch, regno) == 8)
 331             memcpy (&buf, addr, 8);
 332           else
 333             buf = *addr;
 334           rs6000_ptrace64 (PT_WRITE_GPR, PIDGET (inferior_ptid), nr, 0, &buf);
 335         }
 336     }
 337
 338   if (errno)
 339     {
 340       perror ("ptrace write");
 341       errno = 0;
 342     }
 343 }
 344
 345 /* Read from the inferior all registers if REGNO == -1 and just register
 346    REGNO otherwise. */
 347
 348 static void
 349 rs6000_fetch_inferior_registers (int regno)
 350 {
 351   if (regno != -1)
 352     fetch_register (regno);
 353
 354   else
 355     {
 356       struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
 357
 358       /* Read 32 general purpose registers.  */
 359       for (regno = tdep->ppc_gp0_regnum;
 360            regno < tdep->ppc_gp0_regnum + ppc_num_gprs;
 361            regno++)
 362         {
 363           fetch_register (regno);
 364         }
 365
 366       /* Read general purpose floating point registers.  */
 367       if (tdep->ppc_fp0_regnum >= 0)
 368         for (regno = 0; regno < ppc_num_fprs; regno++)
 369           fetch_register (tdep->ppc_fp0_regnum + regno);
 370
 371       /* Read special registers.  */
 372       fetch_register (PC_REGNUM);
 373       fetch_register (tdep->ppc_ps_regnum);
 374       fetch_register (tdep->ppc_cr_regnum);
 375       fetch_register (tdep->ppc_lr_regnum);
 376       fetch_register (tdep->ppc_ctr_regnum);
 377       fetch_register (tdep->ppc_xer_regnum);
 378       if (tdep->ppc_fpscr_regnum >= 0)
 379         fetch_register (tdep->ppc_fpscr_regnum);
 380       if (tdep->ppc_mq_regnum >= 0)
 381         fetch_register (tdep->ppc_mq_regnum);
 382     }
 383 }
 384
 385 /* Store our register values back into the inferior.
 386    If REGNO is -1, do this for all registers.
 387    Otherwise, REGNO specifies which register (so we can save time).  */
 388
 389 static void
 390 rs6000_store_inferior_registers (int regno)
 391 {
 392   if (regno != -1)
 393     store_register (regno);
 394
 395   else
 396     {
 397       struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
 398
 399       /* Write general purpose registers first.  */
 400       for (regno = tdep->ppc_gp0_regnum;
 401            regno < tdep->ppc_gp0_regnum + ppc_num_gprs;
 402            regno++)
 403         {
 404           store_register (regno);
 405         }
 406
 407       /* Write floating point registers.  */
 408       if (tdep->ppc_fp0_regnum >= 0)
 409         for (regno = 0; regno < ppc_num_fprs; regno++)
 410           store_register (tdep->ppc_fp0_regnum + regno);
 411
 412       /* Write special registers.  */
 413       store_register (PC_REGNUM);
 414       store_register (tdep->ppc_ps_regnum);
 415       store_register (tdep->ppc_cr_regnum);
 416       store_register (tdep->ppc_lr_regnum);
 417       store_register (tdep->ppc_ctr_regnum);
 418       store_register (tdep->ppc_xer_regnum);
 419       if (tdep->ppc_fpscr_regnum >= 0)
 420         store_register (tdep->ppc_fpscr_regnum);
 421       if (tdep->ppc_mq_regnum >= 0)
 422         store_register (tdep->ppc_mq_regnum);
 423     }
 424 }
 425
 426
 427 /* Attempt a transfer all LEN bytes starting at OFFSET between the
 428    inferior's OBJECT:ANNEX space and GDB's READBUF/WRITEBUF buffer.
 429    Return the number of bytes actually transferred.  */
 430
 431 static LONGEST
 432 rs6000_xfer_partial (struct target_ops *ops, enum target_object object,
 433                      const char *annex, gdb_byte *readbuf,
 434                      const gdb_byte *writebuf,
 435                      ULONGEST offset, LONGEST len)
 436 {
 437   pid_t pid = ptid_get_pid (inferior_ptid);
 438   int arch64 = ARCH64 ();
 439
 440   switch (object)
 441     {
 442     case TARGET_OBJECT_MEMORY:
 443       {
 444         union
 445         {
 446           PTRACE_TYPE_RET word;
 447           gdb_byte byte[sizeof (PTRACE_TYPE_RET)];
 448         } buffer;
 449         ULONGEST rounded_offset;
 450         LONGEST partial_len;
 451
 452         /* Round the start offset down to the next long word
 453            boundary.  */
 454         rounded_offset = offset & -(ULONGEST) sizeof (PTRACE_TYPE_RET);
 455
 456         /* Since ptrace will transfer a single word starting at that
 457            rounded_offset the partial_len needs to be adjusted down to
 458            that (remember this function only does a single transfer).
 459            Should the required length be even less, adjust it down
 460            again.  */
 461         partial_len = (rounded_offset + sizeof (PTRACE_TYPE_RET)) - offset;
 462         if (partial_len > len)
 463           partial_len = len;
 464
 465         if (writebuf)
 466           {
 467             /* If OFFSET:PARTIAL_LEN is smaller than
 468                ROUNDED_OFFSET:WORDSIZE then a read/modify write will
 469                be needed.  Read in the entire word.  */
 470             if (rounded_offset < offset
 471                 || (offset + partial_len
 472                     < rounded_offset + sizeof (PTRACE_TYPE_RET)))
 473               {
 474                 /* Need part of initial word -- fetch it.  */
 475                 if (arch64)
 476                   buffer.word = rs6000_ptrace64 (PT_READ_I, pid,
 477                                                  rounded_offset, 0, NULL);
 478                 else
 479                   buffer.word = rs6000_ptrace32 (PT_READ_I, pid,
 480                                                  (int *)(uintptr_t)rounded_offset,
 481                                                  0, NULL);
 482               }
 483
 484             /* Copy data to be written over corresponding part of
 485                buffer.  */
 486             memcpy (buffer.byte + (offset - rounded_offset),
 487                     writebuf, partial_len);
 488
 489             errno = 0;
 490             if (arch64)
 491               rs6000_ptrace64 (PT_WRITE_D, pid,
 492                                rounded_offset, buffer.word, NULL);
 493             else
 494               rs6000_ptrace32 (PT_WRITE_D, pid,
 495                                (int *)(uintptr_t)rounded_offset, buffer.word, NULL);
 496             if (errno)
 497               return 0;
 498           }
 499
 500         if (readbuf)
 501           {
 502             errno = 0;
 503             if (arch64)
 504               buffer.word = rs6000_ptrace64 (PT_READ_I, pid,
 505                                              rounded_offset, 0, NULL);
 506             else
 507               buffer.word = rs6000_ptrace32 (PT_READ_I, pid,
 508                                              (int *)(uintptr_t)rounded_offset,
 509                                              0, NULL);
 510             if (errno)
 511               return 0;
 512
 513             /* Copy appropriate bytes out of the buffer.  */
 514             memcpy (readbuf, buffer.byte + (offset - rounded_offset),
 515                     partial_len);
 516           }
 517
 518         return partial_len;
 519       }
 520
 521     default:
 522       return -1;
 523     }
 524 }
 525
 526 /* Wait for the child specified by PTID to do something.  Return the
 527    process ID of the child, or MINUS_ONE_PTID in case of error; store
 528    the status in *OURSTATUS.  */
 529
 530 static ptid_t
 531 rs6000_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
 532 {
 533   pid_t pid;
 534   int status, save_errno;
 535
 536   do
 537     {
 538       set_sigint_trap ();
 539       set_sigio_trap ();
 540
 541       do
 542         {
 543           pid = waitpid (ptid_get_pid (ptid), &status, 0);
 544           save_errno = errno;
 545         }
 546       while (pid == -1 && errno == EINTR);
 547
 548       clear_sigio_trap ();
 549       clear_sigint_trap ();
 550
 551       if (pid == -1)
 552         {
 553           fprintf_unfiltered (gdb_stderr,
 554                               _("Child process unexpectedly missing: %s.\n"),
 555                               safe_strerror (save_errno));
 556
 557           /* Claim it exited with unknown signal.  */
 558           ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
 559           ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
 560           return minus_one_ptid;
 561         }
 562
 563       /* Ignore terminated detached child processes.  */
 564       if (!WIFSTOPPED (status) && pid != ptid_get_pid (inferior_ptid))
 565         pid = -1;
 566     }
 567   while (pid == -1);
 568
 569   /* AIX has a couple of strange returns from wait().  */
 570
 571   /* stop after load" status.  */
 572   if (status == 0x57c)
 573     ourstatus->kind = TARGET_WAITKIND_LOADED;
 574   /* signal 0. I have no idea why wait(2) returns with this status word.  */
 575   else if (status == 0x7f)
 576     ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
 577   /* A normal waitstatus.  Let the usual macros deal with it.  */
 578   else
 579     store_waitstatus (ourstatus, status);
 580
 581   return pid_to_ptid (pid);
 582 }
 583
 584 /* Execute one dummy breakpoint instruction.  This way we give the kernel
 585    a chance to do some housekeeping and update inferior's internal data,
 586    including u_area. */
 587
 588 static void
 589 exec_one_dummy_insn (void)
 590 {
 591 #define DUMMY_INSN_ADDR gdbarch_tdep (current_gdbarch)->text_segment_base+0x200
 592
 593   int ret, status, pid;
 594   CORE_ADDR prev_pc;
 595   void *bp;
 596
 597   /* We plant one dummy breakpoint into DUMMY_INSN_ADDR address. We
 598      assume that this address will never be executed again by the real
 599      code. */
 600
 601   bp = deprecated_insert_raw_breakpoint (DUMMY_INSN_ADDR);
 602
 603   /* You might think this could be done with a single ptrace call, and
 604      you'd be correct for just about every platform I've ever worked
 605      on.  However, rs6000-ibm-aix4.1.3 seems to have screwed this up --
 606      the inferior never hits the breakpoint (it's also worth noting
 607      powerpc-ibm-aix4.1.3 works correctly).  */
 608   prev_pc = read_pc ();
 609   write_pc (DUMMY_INSN_ADDR);
 610   if (ARCH64 ())
 611     ret = rs6000_ptrace64 (PT_CONTINUE, PIDGET (inferior_ptid), 1, 0, NULL);
 612   else
 613     ret = rs6000_ptrace32 (PT_CONTINUE, PIDGET (inferior_ptid), (int *)1, 0, NULL);
 614
 615   if (ret != 0)
 616     perror ("pt_continue");
 617
 618   do
 619     {
 620       pid = wait (&status);
 621     }
 622   while (pid != PIDGET (inferior_ptid));
 623
 624   write_pc (prev_pc);
 625   deprecated_remove_raw_breakpoint (bp);
 626 }
 627
 628 /* Fetch registers from the register section in core bfd. */
 629
 630 static void
 631 fetch_core_registers (char *core_reg_sect, unsigned core_reg_size,
 632                       int which, CORE_ADDR reg_addr)
 633 {
 634   CoreRegs *regs;
 635   int regi;
 636   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
 637
 638   if (which != 0)
 639     {
 640       fprintf_unfiltered
 641         (gdb_stderr,
 642          "Gdb error: unknown parameter to fetch_core_registers().\n");
 643       return;
 644     }
 645
 646   regs = (CoreRegs *) core_reg_sect;
 647
 648   /* Put the register values from the core file section in the regcache.  */
 649
 650   if (ARCH64 ())
 651     {
 652       for (regi = 0; regi < ppc_num_gprs; regi++)
 653         regcache_raw_supply (current_regcache, tdep->ppc_gp0_regnum + regi,
 654                              (char *) &regs->r64.gpr[regi]);
 655
 656       if (tdep->ppc_fp0_regnum >= 0)
 657         for (regi = 0; regi < ppc_num_fprs; regi++)
 658           regcache_raw_supply (current_regcache, tdep->ppc_fp0_regnum + regi,
 659                                (char *) &regs->r64.fpr[regi]);
 660
 661       regcache_raw_supply (current_regcache, PC_REGNUM,
 662                            (char *) &regs->r64.iar);
 663       regcache_raw_supply (current_regcache, tdep->ppc_ps_regnum,
 664                            (char *) &regs->r64.msr);
 665       regcache_raw_supply (current_regcache, tdep->ppc_cr_regnum,
 666                            (char *) &regs->r64.cr);
 667       regcache_raw_supply (current_regcache, tdep->ppc_lr_regnum,
 668                            (char *) &regs->r64.lr);
 669       regcache_raw_supply (current_regcache, tdep->ppc_ctr_regnum,
 670                            (char *) &regs->r64.ctr);
 671       regcache_raw_supply (current_regcache, tdep->ppc_xer_regnum,
 672                            (char *) &regs->r64.xer);
 673       if (tdep->ppc_fpscr_regnum >= 0)
 674         regcache_raw_supply (current_regcache, tdep->ppc_fpscr_regnum,
 675                              (char *) &regs->r64.fpscr);
 676     }
 677   else
 678     {
 679       for (regi = 0; regi < ppc_num_gprs; regi++)
 680         regcache_raw_supply (current_regcache, tdep->ppc_gp0_regnum + regi,
 681                              (char *) &regs->r32.gpr[regi]);
 682
 683       if (tdep->ppc_fp0_regnum >= 0)
 684         for (regi = 0; regi < ppc_num_fprs; regi++)
 685           regcache_raw_supply (current_regcache, tdep->ppc_fp0_regnum + regi,
 686                                (char *) &regs->r32.fpr[regi]);
 687
 688       regcache_raw_supply (current_regcache, PC_REGNUM,
 689                            (char *) &regs->r32.iar);
 690       regcache_raw_supply (current_regcache, tdep->ppc_ps_regnum,
 691                            (char *) &regs->r32.msr);
 692       regcache_raw_supply (current_regcache, tdep->ppc_cr_regnum,
 693                            (char *) &regs->r32.cr);
 694       regcache_raw_supply (current_regcache, tdep->ppc_lr_regnum,
 695                            (char *) &regs->r32.lr);
 696       regcache_raw_supply (current_regcache, tdep->ppc_ctr_regnum,
 697                            (char *) &regs->r32.ctr);
 698       regcache_raw_supply (current_regcache, tdep->ppc_xer_regnum,
 699                            (char *) &regs->r32.xer);
 700       if (tdep->ppc_fpscr_regnum >= 0)
 701         regcache_raw_supply (current_regcache, tdep->ppc_fpscr_regnum,
 702                              (char *) &regs->r32.fpscr);
 703       if (tdep->ppc_mq_regnum >= 0)
 704         regcache_raw_supply (current_regcache, tdep->ppc_mq_regnum,
 705                              (char *) &regs->r32.mq);
 706     }
 707 }
 708 \f
 709
 710 /* Copy information about text and data sections from LDI to VP for a 64-bit
 711    process if ARCH64 and for a 32-bit process otherwise. */
 712
 713 static void
 714 vmap_secs (struct vmap *vp, LdInfo *ldi, int arch64)
 715 {
 716   if (arch64)
 717     {
 718       vp->tstart = (CORE_ADDR) ldi->l64.ldinfo_textorg;
 719       vp->tend = vp->tstart + ldi->l64.ldinfo_textsize;
 720       vp->dstart = (CORE_ADDR) ldi->l64.ldinfo_dataorg;
 721       vp->dend = vp->dstart + ldi->l64.ldinfo_datasize;
 722     }
 723   else
 724     {
 725       vp->tstart = (unsigned long) ldi->l32.ldinfo_textorg;
 726       vp->tend = vp->tstart + ldi->l32.ldinfo_textsize;
 727       vp->dstart = (unsigned long) ldi->l32.ldinfo_dataorg;
 728       vp->dend = vp->dstart + ldi->l32.ldinfo_datasize;
 729     }
 730
 731   /* The run time loader maps the file header in addition to the text
 732      section and returns a pointer to the header in ldinfo_textorg.
 733      Adjust the text start address to point to the real start address
 734      of the text section.  */
 735   vp->tstart += vp->toffs;
 736 }
 737
 738 /* handle symbol translation on vmapping */
 739
 740 static void
 741 vmap_symtab (struct vmap *vp)
 742 {
 743   struct objfile *objfile;
 744   struct section_offsets *new_offsets;
 745   int i;
 746
 747   objfile = vp->objfile;
 748   if (objfile == NULL)
 749     {
 750       /* OK, it's not an objfile we opened ourselves.
 751          Currently, that can only happen with the exec file, so
 752          relocate the symbols for the symfile.  */
 753       if (symfile_objfile == NULL)
 754         return;
 755       objfile = symfile_objfile;
 756     }
 757   else if (!vp->loaded)
 758     /* If symbols are not yet loaded, offsets are not yet valid. */
 759     return;
 760
 761   new_offsets =
 762     (struct section_offsets *)
 763     alloca (SIZEOF_N_SECTION_OFFSETS (objfile->num_sections));
 764
 765   for (i = 0; i < objfile->num_sections; ++i)
 766     new_offsets->offsets[i] = ANOFFSET (objfile->section_offsets, i);
 767
 768   /* The symbols in the object file are linked to the VMA of the section,
 769      relocate them VMA relative.  */
 770   new_offsets->offsets[SECT_OFF_TEXT (objfile)] = vp->tstart - vp->tvma;
 771   new_offsets->offsets[SECT_OFF_DATA (objfile)] = vp->dstart - vp->dvma;
 772   new_offsets->offsets[SECT_OFF_BSS (objfile)] = vp->dstart - vp->dvma;
 773
 774   objfile_relocate (objfile, new_offsets);
 775 }
 776 \f
 777 /* Add symbols for an objfile.  */
 778
 779 static int
 780 objfile_symbol_add (void *arg)
 781 {
 782   struct objfile *obj = (struct objfile *) arg;
 783
 784   syms_from_objfile (obj, NULL, 0, 0, 0, 0);
 785   new_symfile_objfile (obj, 0, 0);
 786   return 1;
 787 }
 788
 789 /* Add symbols for a vmap. Return zero upon error.  */
 790
 791 int
 792 vmap_add_symbols (struct vmap *vp)
 793 {
 794   if (catch_errors (objfile_symbol_add, vp->objfile,
 795                     "Error while reading shared library symbols:\n",
 796                     RETURN_MASK_ALL))
 797     {
 798       /* Note this is only done if symbol reading was successful.  */
 799       vp->loaded = 1;
 800       vmap_symtab (vp);
 801       return 1;
 802     }
 803   return 0;
 804 }
 805
 806 /* Add a new vmap entry based on ldinfo() information.
 807
 808    If ldi->ldinfo_fd is not valid (e.g. this struct ld_info is from a
 809    core file), the caller should set it to -1, and we will open the file.
 810
 811    Return the vmap new entry.  */
 812
 813 static struct vmap *
 814 add_vmap (LdInfo *ldi)
 815 {
 816   bfd *abfd, *last;
 817   char *mem, *objname, *filename;
 818   struct objfile *obj;
 819   struct vmap *vp;
 820   int fd;
 821   ARCH64_DECL (arch64);
 822
 823   /* This ldi structure was allocated using alloca() in
 824      xcoff_relocate_symtab(). Now we need to have persistent object
 825      and member names, so we should save them. */
 826
 827   filename = LDI_FILENAME (ldi, arch64);
 828   mem = filename + strlen (filename) + 1;
 829   mem = savestring (mem, strlen (mem));
 830   objname = savestring (filename, strlen (filename));
 831
 832   fd = LDI_FD (ldi, arch64);
 833   if (fd < 0)
 834     /* Note that this opens it once for every member; a possible
 835        enhancement would be to only open it once for every object.  */
 836     abfd = bfd_openr (objname, gnutarget);
 837   else
 838     abfd = bfd_fdopenr (objname, gnutarget, fd);
 839   if (!abfd)
 840     {
 841       warning (_("Could not open `%s' as an executable file: %s"),
 842                objname, bfd_errmsg (bfd_get_error ()));
 843       return NULL;
 844     }
 845
 846   /* make sure we have an object file */
 847
 848   if (bfd_check_format (abfd, bfd_object))
 849     vp = map_vmap (abfd, 0);
 850
 851   else if (bfd_check_format (abfd, bfd_archive))
 852     {
 853       last = 0;
 854       /* FIXME??? am I tossing BFDs?  bfd? */
 855       while ((last = bfd_openr_next_archived_file (abfd, last)))
 856         if (DEPRECATED_STREQ (mem, last->filename))
 857           break;
 858
 859       if (!last)
 860         {
 861           warning (_("\"%s\": member \"%s\" missing."), objname, mem);
 862           bfd_close (abfd);
 863           return NULL;
 864         }
 865
 866       if (!bfd_check_format (last, bfd_object))
 867         {
 868           warning (_("\"%s\": member \"%s\" not in executable format: %s."),
 869                    objname, mem, bfd_errmsg (bfd_get_error ()));
 870           bfd_close (last);
 871           bfd_close (abfd);
 872           return NULL;
 873         }
 874
 875       vp = map_vmap (last, abfd);
 876     }
 877   else
 878     {
 879       warning (_("\"%s\": not in executable format: %s."),
 880                objname, bfd_errmsg (bfd_get_error ()));
 881       bfd_close (abfd);
 882       return NULL;
 883     }
 884   obj = allocate_objfile (vp->bfd, 0);
 885   vp->objfile = obj;
 886
 887   /* Always add symbols for the main objfile.  */
 888   if (vp == vmap || auto_solib_add)
 889     vmap_add_symbols (vp);
 890   return vp;
 891 }
 892 \f
 893 /* update VMAP info with ldinfo() information
 894    Input is ptr to ldinfo() results.  */
 895
 896 static void
 897 vmap_ldinfo (LdInfo *ldi)
 898 {
 899   struct stat ii, vi;
 900   struct vmap *vp;
 901   int got_one, retried;
 902   int got_exec_file = 0;
 903   uint next;
 904   int arch64 = ARCH64 ();
 905
 906   /* For each *ldi, see if we have a corresponding *vp.
 907      If so, update the mapping, and symbol table.
 908      If not, add an entry and symbol table.  */
 909
 910   do
 911     {
 912       char *name = LDI_FILENAME (ldi, arch64);
 913       char *memb = name + strlen (name) + 1;
 914       int fd = LDI_FD (ldi, arch64);
 915
 916       retried = 0;
 917
 918       if (fstat (fd, &ii) < 0)
 919         {
 920           /* The kernel sets ld_info to -1, if the process is still using the
 921              object, and the object is removed. Keep the symbol info for the
 922              removed object and issue a warning.  */
 923           warning (_("%s (fd=%d) has disappeared, keeping its symbols"),
 924                    name, fd);
 925           continue;
 926         }
 927     retry:
 928       for (got_one = 0, vp = vmap; vp; vp = vp->nxt)
 929         {
 930           struct objfile *objfile;
 931
 932           /* First try to find a `vp', which is the same as in ldinfo.
 933              If not the same, just continue and grep the next `vp'. If same,
 934              relocate its tstart, tend, dstart, dend values. If no such `vp'
 935              found, get out of this for loop, add this ldi entry as a new vmap
 936              (add_vmap) and come back, find its `vp' and so on... */
 937
 938           /* The filenames are not always sufficient to match on. */
 939
 940           if ((name[0] == '/' && !DEPRECATED_STREQ (name, vp->name))
 941               || (memb[0] && !DEPRECATED_STREQ (memb, vp->member)))
 942             continue;
 943
 944           /* See if we are referring to the same file.
 945              We have to check objfile->obfd, symfile.c:reread_symbols might
 946              have updated the obfd after a change.  */
 947           objfile = vp->objfile == NULL ? symfile_objfile : vp->objfile;
 948           if (objfile == NULL
 949               || objfile->obfd == NULL
 950               || bfd_stat (objfile->obfd, &vi) < 0)
 951             {
 952               warning (_("Unable to stat %s, keeping its symbols"), name);
 953               continue;
 954             }
 955
 956           if (ii.st_dev != vi.st_dev || ii.st_ino != vi.st_ino)
 957             continue;
 958
 959           if (!retried)
 960             close (fd);
 961
 962           ++got_one;
 963
 964           /* Found a corresponding VMAP.  Remap!  */
 965
 966           vmap_secs (vp, ldi, arch64);
 967
 968           /* The objfile is only NULL for the exec file.  */
 969           if (vp->objfile == NULL)
 970             got_exec_file = 1;
 971
 972           /* relocate symbol table(s). */
 973           vmap_symtab (vp);
 974
 975           /* Announce new object files.  Doing this after symbol relocation
 976              makes aix-thread.c's job easier.  */
 977           if (deprecated_target_new_objfile_hook && vp->objfile)
 978             deprecated_target_new_objfile_hook (vp->objfile);
 979
 980           /* There may be more, so we don't break out of the loop.  */
 981         }
 982
 983       /* if there was no matching *vp, we must perforce create the sucker(s) */
 984       if (!got_one && !retried)
 985         {
 986           add_vmap (ldi);
 987           ++retried;
 988           goto retry;
 989         }
 990     }
 991   while ((next = LDI_NEXT (ldi, arch64))
 992          && (ldi = (void *) (next + (char *) ldi)));
 993
 994   /* If we don't find the symfile_objfile anywhere in the ldinfo, it
 995      is unlikely that the symbol file is relocated to the proper
 996      address.  And we might have attached to a process which is
 997      running a different copy of the same executable.  */
 998   if (symfile_objfile != NULL && !got_exec_file)
 999     {
1000       warning (_("Symbol file %s\nis not mapped; discarding it.\n\
1001 If in fact that file has symbols which the mapped files listed by\n\
1002 \"info files\" lack, you can load symbols with the \"symbol-file\" or\n\
1003 \"add-symbol-file\" commands (note that you must take care of relocating\n\
1004 symbols to the proper address)."),
1005                symfile_objfile->name);
1006       free_objfile (symfile_objfile);
1007       symfile_objfile = NULL;
1008     }
1009   breakpoint_re_set ();
1010 }
1011 \f
1012 /* As well as symbol tables, exec_sections need relocation. After
1013    the inferior process' termination, there will be a relocated symbol
1014    table exist with no corresponding inferior process. At that time, we
1015    need to use `exec' bfd, rather than the inferior process's memory space
1016    to look up symbols.
1017
1018    `exec_sections' need to be relocated only once, as long as the exec
1019    file remains unchanged.
1020  */
1021
1022 static void
1023 vmap_exec (void)
1024 {
1025   static bfd *execbfd;
1026   int i;
1027
1028   if (execbfd == exec_bfd)
1029     return;
1030
1031   execbfd = exec_bfd;
1032
1033   if (!vmap || !exec_ops.to_sections)
1034     error (_("vmap_exec: vmap or exec_ops.to_sections == 0."));
1035
1036   for (i = 0; &exec_ops.to_sections[i] < exec_ops.to_sections_end; i++)
1037     {
1038       if (DEPRECATED_STREQ (".text", exec_ops.to_sections[i].the_bfd_section->name))
1039         {
1040           exec_ops.to_sections[i].addr += vmap->tstart - vmap->tvma;
1041           exec_ops.to_sections[i].endaddr += vmap->tstart - vmap->tvma;
1042         }
1043       else if (DEPRECATED_STREQ (".data", exec_ops.to_sections[i].the_bfd_section->name))
1044         {
1045           exec_ops.to_sections[i].addr += vmap->dstart - vmap->dvma;
1046           exec_ops.to_sections[i].endaddr += vmap->dstart - vmap->dvma;
1047         }
1048       else if (DEPRECATED_STREQ (".bss", exec_ops.to_sections[i].the_bfd_section->name))
1049         {
1050           exec_ops.to_sections[i].addr += vmap->dstart - vmap->dvma;
1051           exec_ops.to_sections[i].endaddr += vmap->dstart - vmap->dvma;
1052         }
1053     }
1054 }
1055
1056 /* Set the current architecture from the host running GDB.  Called when
1057    starting a child process. */
1058
1059 static void (*super_create_inferior) (char *exec_file, char *allargs,
1060                                       char **env, int from_tty);
1061 static void
1062 rs6000_create_inferior (char *exec_file, char *allargs, char **env, int from_tty)
1063 {
1064   enum bfd_architecture arch;
1065   unsigned long mach;
1066   bfd abfd;
1067   struct gdbarch_info info;
1068
1069   super_create_inferior (exec_file, allargs, env, from_tty);
1070
1071   if (__power_rs ())
1072     {
1073       arch = bfd_arch_rs6000;
1074       mach = bfd_mach_rs6k;
1075     }
1076   else
1077     {
1078       arch = bfd_arch_powerpc;
1079       mach = bfd_mach_ppc;
1080     }
1081
1082   /* FIXME: schauer/2002-02-25:
1083      We don't know if we are executing a 32 or 64 bit executable,
1084      and have no way to pass the proper word size to rs6000_gdbarch_init.
1085      So we have to avoid switching to a new architecture, if the architecture
1086      matches already.
1087      Blindly calling rs6000_gdbarch_init used to work in older versions of
1088      GDB, as rs6000_gdbarch_init incorrectly used the previous tdep to
1089      determine the wordsize.  */
1090   if (exec_bfd)
1091     {
1092       const struct bfd_arch_info *exec_bfd_arch_info;
1093
1094       exec_bfd_arch_info = bfd_get_arch_info (exec_bfd);
1095       if (arch == exec_bfd_arch_info->arch)
1096         return;
1097     }
1098
1099   bfd_default_set_arch_mach (&abfd, arch, mach);
1100
1101   gdbarch_info_init (&info);
1102   info.bfd_arch_info = bfd_get_arch_info (&abfd);
1103   info.abfd = exec_bfd;
1104
1105   if (!gdbarch_update_p (info))
1106     internal_error (__FILE__, __LINE__,
1107                     _("rs6000_create_inferior: failed to select architecture"));
1108 }
1109
1110 \f
1111 /* xcoff_relocate_symtab -      hook for symbol table relocation.
1112    also reads shared libraries.  */
1113
1114 void
1115 xcoff_relocate_symtab (unsigned int pid)
1116 {
1117   int load_segs = 64; /* number of load segments */
1118   int rc;
1119   LdInfo *ldi = NULL;
1120   int arch64 = ARCH64 ();
1121   int ldisize = arch64 ? sizeof (ldi->l64) : sizeof (ldi->l32);
1122   int size;
1123
1124   do
1125     {
1126       size = load_segs * ldisize;
1127       ldi = (void *) xrealloc (ldi, size);
1128
1129 #if 0
1130       /* According to my humble theory, AIX has some timing problems and
1131          when the user stack grows, kernel doesn't update stack info in time
1132          and ptrace calls step on user stack. That is why we sleep here a
1133          little, and give kernel to update its internals. */
1134       usleep (36000);
1135 #endif
1136
1137       if (arch64)
1138         rc = rs6000_ptrace64 (PT_LDINFO, pid, (unsigned long) ldi, size, NULL);
1139       else
1140         rc = rs6000_ptrace32 (PT_LDINFO, pid, (int *) ldi, size, NULL);
1141
1142       if (rc == -1)
1143         {
1144           if (errno == ENOMEM)
1145             load_segs *= 2;
1146           else
1147             perror_with_name (_("ptrace ldinfo"));
1148         }
1149       else
1150         {
1151           vmap_ldinfo (ldi);
1152           vmap_exec (); /* relocate the exec and core sections as well. */
1153         }
1154     } while (rc == -1);
1155   if (ldi)
1156     xfree (ldi);
1157 }
1158 \f
1159 /* Core file stuff.  */
1160
1161 /* Relocate symtabs and read in shared library info, based on symbols
1162    from the core file.  */
1163
1164 void
1165 xcoff_relocate_core (struct target_ops *target)
1166 {
1167   struct bfd_section *ldinfo_sec;
1168   int offset = 0;
1169   LdInfo *ldi;
1170   struct vmap *vp;
1171   int arch64 = ARCH64 ();
1172
1173   /* Size of a struct ld_info except for the variable-length filename. */
1174   int nonfilesz = (int)LDI_FILENAME ((LdInfo *)0, arch64);
1175
1176   /* Allocated size of buffer.  */
1177   int buffer_size = nonfilesz;
1178   char *buffer = xmalloc (buffer_size);
1179   struct cleanup *old = make_cleanup (free_current_contents, &buffer);
1180
1181   ldinfo_sec = bfd_get_section_by_name (core_bfd, ".ldinfo");
1182   if (ldinfo_sec == NULL)
1183     {
1184     bfd_err:
1185       fprintf_filtered (gdb_stderr, "Couldn't get ldinfo from core file: %s\n",
1186                         bfd_errmsg (bfd_get_error ()));
1187       do_cleanups (old);
1188       return;
1189     }
1190   do
1191     {
1192       int i;
1193       int names_found = 0;
1194
1195       /* Read in everything but the name.  */
1196       if (bfd_get_section_contents (core_bfd, ldinfo_sec, buffer,
1197                                     offset, nonfilesz) == 0)
1198         goto bfd_err;
1199
1200       /* Now the name.  */
1201       i = nonfilesz;
1202       do
1203         {
1204           if (i == buffer_size)
1205             {
1206               buffer_size *= 2;
1207               buffer = xrealloc (buffer, buffer_size);
1208             }
1209           if (bfd_get_section_contents (core_bfd, ldinfo_sec, &buffer[i],
1210                                         offset + i, 1) == 0)
1211             goto bfd_err;
1212           if (buffer[i++] == '\0')
1213             ++names_found;
1214         }
1215       while (names_found < 2);
1216
1217       ldi = (LdInfo *) buffer;
1218
1219       /* Can't use a file descriptor from the core file; need to open it.  */
1220       if (arch64)
1221         ldi->l64.ldinfo_fd = -1;
1222       else
1223         ldi->l32.ldinfo_fd = -1;
1224
1225       /* The first ldinfo is for the exec file, allocated elsewhere.  */
1226       if (offset == 0 && vmap != NULL)
1227         vp = vmap;
1228       else
1229         vp = add_vmap (ldi);
1230
1231       /* Process next shared library upon error. */
1232       offset += LDI_NEXT (ldi, arch64);
1233       if (vp == NULL)
1234         continue;
1235
1236       vmap_secs (vp, ldi, arch64);
1237
1238       /* Unless this is the exec file,
1239          add our sections to the section table for the core target.  */
1240       if (vp != vmap)
1241         {
1242           struct section_table *stp;
1243
1244           target_resize_to_sections (target, 2);
1245           stp = target->to_sections_end - 2;
1246
1247           stp->bfd = vp->bfd;
1248           stp->the_bfd_section = bfd_get_section_by_name (stp->bfd, ".text");
1249           stp->addr = vp->tstart;
1250           stp->endaddr = vp->tend;
1251           stp++;
1252
1253           stp->bfd = vp->bfd;
1254           stp->the_bfd_section = bfd_get_section_by_name (stp->bfd, ".data");
1255           stp->addr = vp->dstart;
1256           stp->endaddr = vp->dend;
1257         }
1258
1259       vmap_symtab (vp);
1260
1261       if (deprecated_target_new_objfile_hook && vp != vmap && vp->objfile)
1262         deprecated_target_new_objfile_hook (vp->objfile);
1263     }
1264   while (LDI_NEXT (ldi, arch64) != 0);
1265   vmap_exec ();
1266   breakpoint_re_set ();
1267   do_cleanups (old);
1268 }
1269 \f
1270 /* Under AIX, we have to pass the correct TOC pointer to a function
1271    when calling functions in the inferior.
1272    We try to find the relative toc offset of the objfile containing PC
1273    and add the current load address of the data segment from the vmap.  */
1274
1275 static CORE_ADDR
1276 find_toc_address (CORE_ADDR pc)
1277 {
1278   struct vmap *vp;
1279   extern CORE_ADDR get_toc_offset (struct objfile *);   /* xcoffread.c */
1280
1281   for (vp = vmap; vp; vp = vp->nxt)
1282     {
1283       if (pc >= vp->tstart && pc < vp->tend)
1284         {
1285           /* vp->objfile is only NULL for the exec file.  */
1286           return vp->dstart + get_toc_offset (vp->objfile == NULL
1287                                               ? symfile_objfile
1288                                               : vp->objfile);
1289         }
1290     }
1291   error (_("Unable to find TOC entry for pc %s."), hex_string (pc));
1292 }
1293 \f
1294 /* Register that we are able to handle rs6000 core file formats. */
1295
1296 static struct core_fns rs6000_core_fns =
1297 {
1298   bfd_target_xcoff_flavour,             /* core_flavour */
1299   default_check_format,                 /* check_format */
1300   default_core_sniffer,                 /* core_sniffer */
1301   fetch_core_registers,                 /* core_read_registers */
1302   NULL                                  /* next */
1303 };
1304
1305 void
1306 _initialize_core_rs6000 (void)
1307 {
1308   struct target_ops *t;
1309
1310   t = inf_ptrace_target ();
1311   t->to_fetch_registers = rs6000_fetch_inferior_registers;
1312   t->to_store_registers = rs6000_store_inferior_registers;
1313   t->to_xfer_partial = rs6000_xfer_partial;
1314
1315   super_create_inferior = t->to_create_inferior;
1316   t->to_create_inferior = rs6000_create_inferior;
1317
1318   t->to_wait = rs6000_wait;
1319
1320   add_target (t);
1321
1322   /* Initialize hook in rs6000-tdep.c for determining the TOC address
1323      when calling functions in the inferior.  */
1324   rs6000_find_toc_address_hook = find_toc_address;
1325
1326   deprecated_add_core_fns (&rs6000_core_fns);
1327 }