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