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
   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 "gdb_stdint.h"
  40 #include "observer.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 (current_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 gdbarch *);
 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 (const 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 (gdbarch);
 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 regcache *regcache, int regno)
 338 {
 339   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 340   if (regno != -1)
 341     fetch_register (regcache, regno);
 342
 343   else
 344     {
 345       struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 346
 347       /* Read 32 general purpose registers.  */
 348       for (regno = tdep->ppc_gp0_regnum;
 349            regno < tdep->ppc_gp0_regnum + ppc_num_gprs;
 350            regno++)
 351         {
 352           fetch_register (regcache, regno);
 353         }
 354
 355       /* Read general purpose floating point registers.  */
 356       if (tdep->ppc_fp0_regnum >= 0)
 357         for (regno = 0; regno < ppc_num_fprs; regno++)
 358           fetch_register (regcache, tdep->ppc_fp0_regnum + regno);
 359
 360       /* Read special registers.  */
 361       fetch_register (regcache, gdbarch_pc_regnum (gdbarch));
 362       fetch_register (regcache, tdep->ppc_ps_regnum);
 363       fetch_register (regcache, tdep->ppc_cr_regnum);
 364       fetch_register (regcache, tdep->ppc_lr_regnum);
 365       fetch_register (regcache, tdep->ppc_ctr_regnum);
 366       fetch_register (regcache, tdep->ppc_xer_regnum);
 367       if (tdep->ppc_fpscr_regnum >= 0)
 368         fetch_register (regcache, tdep->ppc_fpscr_regnum);
 369       if (tdep->ppc_mq_regnum >= 0)
 370         fetch_register (regcache, tdep->ppc_mq_regnum);
 371     }
 372 }
 373
 374 /* Store our register values back into the inferior.
 375    If REGNO is -1, do this for all registers.
 376    Otherwise, REGNO specifies which register (so we can save time).  */
 377
 378 static void
 379 rs6000_store_inferior_registers (struct regcache *regcache, int regno)
 380 {
 381   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 382   if (regno != -1)
 383     store_register (regcache, regno);
 384
 385   else
 386     {
 387       struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 388
 389       /* Write general purpose registers first.  */
 390       for (regno = tdep->ppc_gp0_regnum;
 391            regno < tdep->ppc_gp0_regnum + ppc_num_gprs;
 392            regno++)
 393         {
 394           store_register (regcache, regno);
 395         }
 396
 397       /* Write floating point registers.  */
 398       if (tdep->ppc_fp0_regnum >= 0)
 399         for (regno = 0; regno < ppc_num_fprs; regno++)
 400           store_register (regcache, tdep->ppc_fp0_regnum + regno);
 401
 402       /* Write special registers.  */
 403       store_register (regcache, gdbarch_pc_regnum (gdbarch));
 404       store_register (regcache, tdep->ppc_ps_regnum);
 405       store_register (regcache, tdep->ppc_cr_regnum);
 406       store_register (regcache, tdep->ppc_lr_regnum);
 407       store_register (regcache, tdep->ppc_ctr_regnum);
 408       store_register (regcache, tdep->ppc_xer_regnum);
 409       if (tdep->ppc_fpscr_regnum >= 0)
 410         store_register (regcache, tdep->ppc_fpscr_regnum);
 411       if (tdep->ppc_mq_regnum >= 0)
 412         store_register (regcache, tdep->ppc_mq_regnum);
 413     }
 414 }
 415
 416
 417 /* Attempt a transfer all LEN bytes starting at OFFSET between the
 418    inferior's OBJECT:ANNEX space and GDB's READBUF/WRITEBUF buffer.
 419    Return the number of bytes actually transferred.  */
 420
 421 static LONGEST
 422 rs6000_xfer_partial (struct target_ops *ops, enum target_object object,
 423                      const char *annex, gdb_byte *readbuf,
 424                      const gdb_byte *writebuf,
 425                      ULONGEST offset, LONGEST len)
 426 {
 427   pid_t pid = ptid_get_pid (inferior_ptid);
 428   int arch64 = ARCH64 ();
 429
 430   switch (object)
 431     {
 432     case TARGET_OBJECT_MEMORY:
 433       {
 434         union
 435         {
 436           PTRACE_TYPE_RET word;
 437           gdb_byte byte[sizeof (PTRACE_TYPE_RET)];
 438         } buffer;
 439         ULONGEST rounded_offset;
 440         LONGEST partial_len;
 441
 442         /* Round the start offset down to the next long word
 443            boundary.  */
 444         rounded_offset = offset & -(ULONGEST) sizeof (PTRACE_TYPE_RET);
 445
 446         /* Since ptrace will transfer a single word starting at that
 447            rounded_offset the partial_len needs to be adjusted down to
 448            that (remember this function only does a single transfer).
 449            Should the required length be even less, adjust it down
 450            again.  */
 451         partial_len = (rounded_offset + sizeof (PTRACE_TYPE_RET)) - offset;
 452         if (partial_len > len)
 453           partial_len = len;
 454
 455         if (writebuf)
 456           {
 457             /* If OFFSET:PARTIAL_LEN is smaller than
 458                ROUNDED_OFFSET:WORDSIZE then a read/modify write will
 459                be needed.  Read in the entire word.  */
 460             if (rounded_offset < offset
 461                 || (offset + partial_len
 462                     < rounded_offset + sizeof (PTRACE_TYPE_RET)))
 463               {
 464                 /* Need part of initial word -- fetch it.  */
 465                 if (arch64)
 466                   buffer.word = rs6000_ptrace64 (PT_READ_I, pid,
 467                                                  rounded_offset, 0, NULL);
 468                 else
 469                   buffer.word = rs6000_ptrace32 (PT_READ_I, pid,
 470                                                  (int *)(uintptr_t)rounded_offset,
 471                                                  0, NULL);
 472               }
 473
 474             /* Copy data to be written over corresponding part of
 475                buffer.  */
 476             memcpy (buffer.byte + (offset - rounded_offset),
 477                     writebuf, partial_len);
 478
 479             errno = 0;
 480             if (arch64)
 481               rs6000_ptrace64 (PT_WRITE_D, pid,
 482                                rounded_offset, buffer.word, NULL);
 483             else
 484               rs6000_ptrace32 (PT_WRITE_D, pid,
 485                                (int *)(uintptr_t)rounded_offset, buffer.word, NULL);
 486             if (errno)
 487               return 0;
 488           }
 489
 490         if (readbuf)
 491           {
 492             errno = 0;
 493             if (arch64)
 494               buffer.word = rs6000_ptrace64 (PT_READ_I, pid,
 495                                              rounded_offset, 0, NULL);
 496             else
 497               buffer.word = rs6000_ptrace32 (PT_READ_I, pid,
 498                                              (int *)(uintptr_t)rounded_offset,
 499                                              0, NULL);
 500             if (errno)
 501               return 0;
 502
 503             /* Copy appropriate bytes out of the buffer.  */
 504             memcpy (readbuf, buffer.byte + (offset - rounded_offset),
 505                     partial_len);
 506           }
 507
 508         return partial_len;
 509       }
 510
 511     default:
 512       return -1;
 513     }
 514 }
 515
 516 /* Wait for the child specified by PTID to do something.  Return the
 517    process ID of the child, or MINUS_ONE_PTID in case of error; store
 518    the status in *OURSTATUS.  */
 519
 520 static ptid_t
 521 rs6000_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
 522 {
 523   pid_t pid;
 524   int status, save_errno;
 525
 526   do
 527     {
 528       set_sigint_trap ();
 529       set_sigio_trap ();
 530
 531       do
 532         {
 533           pid = waitpid (ptid_get_pid (ptid), &status, 0);
 534           save_errno = errno;
 535         }
 536       while (pid == -1 && errno == EINTR);
 537
 538       clear_sigio_trap ();
 539       clear_sigint_trap ();
 540
 541       if (pid == -1)
 542         {
 543           fprintf_unfiltered (gdb_stderr,
 544                               _("Child process unexpectedly missing: %s.\n"),
 545                               safe_strerror (save_errno));
 546
 547           /* Claim it exited with unknown signal.  */
 548           ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
 549           ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
 550           return minus_one_ptid;
 551         }
 552
 553       /* Ignore terminated detached child processes.  */
 554       if (!WIFSTOPPED (status) && pid != ptid_get_pid (inferior_ptid))
 555         pid = -1;
 556     }
 557   while (pid == -1);
 558
 559   /* AIX has a couple of strange returns from wait().  */
 560
 561   /* stop after load" status.  */
 562   if (status == 0x57c)
 563     ourstatus->kind = TARGET_WAITKIND_LOADED;
 564   /* signal 0. I have no idea why wait(2) returns with this status word.  */
 565   else if (status == 0x7f)
 566     ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
 567   /* A normal waitstatus.  Let the usual macros deal with it.  */
 568   else
 569     store_waitstatus (ourstatus, status);
 570
 571   return pid_to_ptid (pid);
 572 }
 573
 574 /* Execute one dummy breakpoint instruction.  This way we give the kernel
 575    a chance to do some housekeeping and update inferior's internal data,
 576    including u_area. */
 577
 578 static void
 579 exec_one_dummy_insn (struct gdbarch *gdbarch)
 580 {
 581 #define DUMMY_INSN_ADDR gdbarch_tdep (gdbarch)->text_segment_base+0x200
 582
 583   int ret, status, pid;
 584   CORE_ADDR prev_pc;
 585   void *bp;
 586
 587   /* We plant one dummy breakpoint into DUMMY_INSN_ADDR address. We
 588      assume that this address will never be executed again by the real
 589      code. */
 590
 591   bp = deprecated_insert_raw_breakpoint (DUMMY_INSN_ADDR);
 592
 593   /* You might think this could be done with a single ptrace call, and
 594      you'd be correct for just about every platform I've ever worked
 595      on.  However, rs6000-ibm-aix4.1.3 seems to have screwed this up --
 596      the inferior never hits the breakpoint (it's also worth noting
 597      powerpc-ibm-aix4.1.3 works correctly).  */
 598   prev_pc = read_pc ();
 599   write_pc (DUMMY_INSN_ADDR);
 600   if (ARCH64 ())
 601     ret = rs6000_ptrace64 (PT_CONTINUE, PIDGET (inferior_ptid), 1, 0, NULL);
 602   else
 603     ret = rs6000_ptrace32 (PT_CONTINUE, PIDGET (inferior_ptid), (int *)1, 0, NULL);
 604
 605   if (ret != 0)
 606     perror ("pt_continue");
 607
 608   do
 609     {
 610       pid = wait (&status);
 611     }
 612   while (pid != PIDGET (inferior_ptid));
 613
 614   write_pc (prev_pc);
 615   deprecated_remove_raw_breakpoint (bp);
 616 }
 617 \f
 618
 619 /* Copy information about text and data sections from LDI to VP for a 64-bit
 620    process if ARCH64 and for a 32-bit process otherwise. */
 621
 622 static void
 623 vmap_secs (struct vmap *vp, LdInfo *ldi, int arch64)
 624 {
 625   if (arch64)
 626     {
 627       vp->tstart = (CORE_ADDR) ldi->l64.ldinfo_textorg;
 628       vp->tend = vp->tstart + ldi->l64.ldinfo_textsize;
 629       vp->dstart = (CORE_ADDR) ldi->l64.ldinfo_dataorg;
 630       vp->dend = vp->dstart + ldi->l64.ldinfo_datasize;
 631     }
 632   else
 633     {
 634       vp->tstart = (unsigned long) ldi->l32.ldinfo_textorg;
 635       vp->tend = vp->tstart + ldi->l32.ldinfo_textsize;
 636       vp->dstart = (unsigned long) ldi->l32.ldinfo_dataorg;
 637       vp->dend = vp->dstart + ldi->l32.ldinfo_datasize;
 638     }
 639
 640   /* The run time loader maps the file header in addition to the text
 641      section and returns a pointer to the header in ldinfo_textorg.
 642      Adjust the text start address to point to the real start address
 643      of the text section.  */
 644   vp->tstart += vp->toffs;
 645 }
 646
 647 /* handle symbol translation on vmapping */
 648
 649 static void
 650 vmap_symtab (struct vmap *vp)
 651 {
 652   struct objfile *objfile;
 653   struct section_offsets *new_offsets;
 654   int i;
 655
 656   objfile = vp->objfile;
 657   if (objfile == NULL)
 658     {
 659       /* OK, it's not an objfile we opened ourselves.
 660          Currently, that can only happen with the exec file, so
 661          relocate the symbols for the symfile.  */
 662       if (symfile_objfile == NULL)
 663         return;
 664       objfile = symfile_objfile;
 665     }
 666   else if (!vp->loaded)
 667     /* If symbols are not yet loaded, offsets are not yet valid. */
 668     return;
 669
 670   new_offsets =
 671     (struct section_offsets *)
 672     alloca (SIZEOF_N_SECTION_OFFSETS (objfile->num_sections));
 673
 674   for (i = 0; i < objfile->num_sections; ++i)
 675     new_offsets->offsets[i] = ANOFFSET (objfile->section_offsets, i);
 676
 677   /* The symbols in the object file are linked to the VMA of the section,
 678      relocate them VMA relative.  */
 679   new_offsets->offsets[SECT_OFF_TEXT (objfile)] = vp->tstart - vp->tvma;
 680   new_offsets->offsets[SECT_OFF_DATA (objfile)] = vp->dstart - vp->dvma;
 681   new_offsets->offsets[SECT_OFF_BSS (objfile)] = vp->dstart - vp->dvma;
 682
 683   objfile_relocate (objfile, new_offsets);
 684 }
 685 \f
 686 /* Add symbols for an objfile.  */
 687
 688 static int
 689 objfile_symbol_add (void *arg)
 690 {
 691   struct objfile *obj = (struct objfile *) arg;
 692
 693   syms_from_objfile (obj, NULL, 0, 0, 0, 0);
 694   new_symfile_objfile (obj, 0, 0);
 695   return 1;
 696 }
 697
 698 /* Add symbols for a vmap. Return zero upon error.  */
 699
 700 int
 701 vmap_add_symbols (struct vmap *vp)
 702 {
 703   if (catch_errors (objfile_symbol_add, vp->objfile,
 704                     "Error while reading shared library symbols:\n",
 705                     RETURN_MASK_ALL))
 706     {
 707       /* Note this is only done if symbol reading was successful.  */
 708       vp->loaded = 1;
 709       vmap_symtab (vp);
 710       return 1;
 711     }
 712   return 0;
 713 }
 714
 715 /* Add a new vmap entry based on ldinfo() information.
 716
 717    If ldi->ldinfo_fd is not valid (e.g. this struct ld_info is from a
 718    core file), the caller should set it to -1, and we will open the file.
 719
 720    Return the vmap new entry.  */
 721
 722 static struct vmap *
 723 add_vmap (LdInfo *ldi)
 724 {
 725   bfd *abfd, *last;
 726   char *mem, *objname, *filename;
 727   struct objfile *obj;
 728   struct vmap *vp;
 729   int fd;
 730   ARCH64_DECL (arch64);
 731
 732   /* This ldi structure was allocated using alloca() in
 733      xcoff_relocate_symtab(). Now we need to have persistent object
 734      and member names, so we should save them. */
 735
 736   filename = LDI_FILENAME (ldi, arch64);
 737   mem = filename + strlen (filename) + 1;
 738   mem = savestring (mem, strlen (mem));
 739   objname = savestring (filename, strlen (filename));
 740
 741   fd = LDI_FD (ldi, arch64);
 742   if (fd < 0)
 743     /* Note that this opens it once for every member; a possible
 744        enhancement would be to only open it once for every object.  */
 745     abfd = bfd_openr (objname, gnutarget);
 746   else
 747     abfd = bfd_fdopenr (objname, gnutarget, fd);
 748   if (!abfd)
 749     {
 750       warning (_("Could not open `%s' as an executable file: %s"),
 751                objname, bfd_errmsg (bfd_get_error ()));
 752       return NULL;
 753     }
 754
 755   /* make sure we have an object file */
 756
 757   if (bfd_check_format (abfd, bfd_object))
 758     vp = map_vmap (abfd, 0);
 759
 760   else if (bfd_check_format (abfd, bfd_archive))
 761     {
 762       last = 0;
 763       /* FIXME??? am I tossing BFDs?  bfd? */
 764       while ((last = bfd_openr_next_archived_file (abfd, last)))
 765         if (strcmp (mem, last->filename) == 0)
 766           break;
 767
 768       if (!last)
 769         {
 770           warning (_("\"%s\": member \"%s\" missing."), objname, mem);
 771           bfd_close (abfd);
 772           return NULL;
 773         }
 774
 775       if (!bfd_check_format (last, bfd_object))
 776         {
 777           warning (_("\"%s\": member \"%s\" not in executable format: %s."),
 778                    objname, mem, bfd_errmsg (bfd_get_error ()));
 779           bfd_close (last);
 780           bfd_close (abfd);
 781           return NULL;
 782         }
 783
 784       vp = map_vmap (last, abfd);
 785     }
 786   else
 787     {
 788       warning (_("\"%s\": not in executable format: %s."),
 789                objname, bfd_errmsg (bfd_get_error ()));
 790       bfd_close (abfd);
 791       return NULL;
 792     }
 793   obj = allocate_objfile (vp->bfd, 0);
 794   vp->objfile = obj;
 795
 796   /* Always add symbols for the main objfile.  */
 797   if (vp == vmap || auto_solib_add)
 798     vmap_add_symbols (vp);
 799   return vp;
 800 }
 801 \f
 802 /* update VMAP info with ldinfo() information
 803    Input is ptr to ldinfo() results.  */
 804
 805 static void
 806 vmap_ldinfo (LdInfo *ldi)
 807 {
 808   struct stat ii, vi;
 809   struct vmap *vp;
 810   int got_one, retried;
 811   int got_exec_file = 0;
 812   uint next;
 813   int arch64 = ARCH64 ();
 814
 815   /* For each *ldi, see if we have a corresponding *vp.
 816      If so, update the mapping, and symbol table.
 817      If not, add an entry and symbol table.  */
 818
 819   do
 820     {
 821       char *name = LDI_FILENAME (ldi, arch64);
 822       char *memb = name + strlen (name) + 1;
 823       int fd = LDI_FD (ldi, arch64);
 824
 825       retried = 0;
 826
 827       if (fstat (fd, &ii) < 0)
 828         {
 829           /* The kernel sets ld_info to -1, if the process is still using the
 830              object, and the object is removed. Keep the symbol info for the
 831              removed object and issue a warning.  */
 832           warning (_("%s (fd=%d) has disappeared, keeping its symbols"),
 833                    name, fd);
 834           continue;
 835         }
 836     retry:
 837       for (got_one = 0, vp = vmap; vp; vp = vp->nxt)
 838         {
 839           struct objfile *objfile;
 840
 841           /* First try to find a `vp', which is the same as in ldinfo.
 842              If not the same, just continue and grep the next `vp'. If same,
 843              relocate its tstart, tend, dstart, dend values. If no such `vp'
 844              found, get out of this for loop, add this ldi entry as a new vmap
 845              (add_vmap) and come back, find its `vp' and so on... */
 846
 847           /* The filenames are not always sufficient to match on. */
 848
 849           if ((name[0] == '/' && strcmp (name, vp->name) != 0)
 850               || (memb[0] && strcmp (memb, vp->member) != 0))
 851             continue;
 852
 853           /* See if we are referring to the same file.
 854              We have to check objfile->obfd, symfile.c:reread_symbols might
 855              have updated the obfd after a change.  */
 856           objfile = vp->objfile == NULL ? symfile_objfile : vp->objfile;
 857           if (objfile == NULL
 858               || objfile->obfd == NULL
 859               || bfd_stat (objfile->obfd, &vi) < 0)
 860             {
 861               warning (_("Unable to stat %s, keeping its symbols"), name);
 862               continue;
 863             }
 864
 865           if (ii.st_dev != vi.st_dev || ii.st_ino != vi.st_ino)
 866             continue;
 867
 868           if (!retried)
 869             close (fd);
 870
 871           ++got_one;
 872
 873           /* Found a corresponding VMAP.  Remap!  */
 874
 875           vmap_secs (vp, ldi, arch64);
 876
 877           /* The objfile is only NULL for the exec file.  */
 878           if (vp->objfile == NULL)
 879             got_exec_file = 1;
 880
 881           /* relocate symbol table(s). */
 882           vmap_symtab (vp);
 883
 884           /* Announce new object files.  Doing this after symbol relocation
 885              makes aix-thread.c's job easier.  */
 886           if (vp->objfile)
 887             observer_notify_new_objfile (vp->objfile);
 888
 889           /* There may be more, so we don't break out of the loop.  */
 890         }
 891
 892       /* if there was no matching *vp, we must perforce create the sucker(s) */
 893       if (!got_one && !retried)
 894         {
 895           add_vmap (ldi);
 896           ++retried;
 897           goto retry;
 898         }
 899     }
 900   while ((next = LDI_NEXT (ldi, arch64))
 901          && (ldi = (void *) (next + (char *) ldi)));
 902
 903   /* If we don't find the symfile_objfile anywhere in the ldinfo, it
 904      is unlikely that the symbol file is relocated to the proper
 905      address.  And we might have attached to a process which is
 906      running a different copy of the same executable.  */
 907   if (symfile_objfile != NULL && !got_exec_file)
 908     {
 909       warning (_("Symbol file %s\nis not mapped; discarding it.\n\
 910 If in fact that file has symbols which the mapped files listed by\n\
 911 \"info files\" lack, you can load symbols with the \"symbol-file\" or\n\
 912 \"add-symbol-file\" commands (note that you must take care of relocating\n\
 913 symbols to the proper address)."),
 914                symfile_objfile->name);
 915       free_objfile (symfile_objfile);
 916       symfile_objfile = NULL;
 917     }
 918   breakpoint_re_set ();
 919 }
 920 \f
 921 /* As well as symbol tables, exec_sections need relocation. After
 922    the inferior process' termination, there will be a relocated symbol
 923    table exist with no corresponding inferior process. At that time, we
 924    need to use `exec' bfd, rather than the inferior process's memory space
 925    to look up symbols.
 926
 927    `exec_sections' need to be relocated only once, as long as the exec
 928    file remains unchanged.
 929  */
 930
 931 static void
 932 vmap_exec (void)
 933 {
 934   static bfd *execbfd;
 935   int i;
 936
 937   if (execbfd == exec_bfd)
 938     return;
 939
 940   execbfd = exec_bfd;
 941
 942   if (!vmap || !exec_ops.to_sections)
 943     error (_("vmap_exec: vmap or exec_ops.to_sections == 0."));
 944
 945   for (i = 0; &exec_ops.to_sections[i] < exec_ops.to_sections_end; i++)
 946     {
 947       if (strcmp (".text", exec_ops.to_sections[i].the_bfd_section->name) == 0)
 948         {
 949           exec_ops.to_sections[i].addr += vmap->tstart - vmap->tvma;
 950           exec_ops.to_sections[i].endaddr += vmap->tstart - vmap->tvma;
 951         }
 952       else if (strcmp (".data",
 953                        exec_ops.to_sections[i].the_bfd_section->name) == 0)
 954         {
 955           exec_ops.to_sections[i].addr += vmap->dstart - vmap->dvma;
 956           exec_ops.to_sections[i].endaddr += vmap->dstart - vmap->dvma;
 957         }
 958       else if (strcmp (".bss",
 959                        exec_ops.to_sections[i].the_bfd_section->name) == 0)
 960         {
 961           exec_ops.to_sections[i].addr += vmap->dstart - vmap->dvma;
 962           exec_ops.to_sections[i].endaddr += vmap->dstart - vmap->dvma;
 963         }
 964     }
 965 }
 966
 967 /* Set the current architecture from the host running GDB.  Called when
 968    starting a child process. */
 969
 970 static void (*super_create_inferior) (char *exec_file, char *allargs,
 971                                       char **env, int from_tty);
 972 static void
 973 rs6000_create_inferior (char *exec_file, char *allargs, char **env, int from_tty)
 974 {
 975   enum bfd_architecture arch;
 976   unsigned long mach;
 977   bfd abfd;
 978   struct gdbarch_info info;
 979
 980   super_create_inferior (exec_file, allargs, env, from_tty);
 981
 982   if (__power_rs ())
 983     {
 984       arch = bfd_arch_rs6000;
 985       mach = bfd_mach_rs6k;
 986     }
 987   else
 988     {
 989       arch = bfd_arch_powerpc;
 990       mach = bfd_mach_ppc;
 991     }
 992
 993   /* FIXME: schauer/2002-02-25:
 994      We don't know if we are executing a 32 or 64 bit executable,
 995      and have no way to pass the proper word size to rs6000_gdbarch_init.
 996      So we have to avoid switching to a new architecture, if the architecture
 997      matches already.
 998      Blindly calling rs6000_gdbarch_init used to work in older versions of
 999      GDB, as rs6000_gdbarch_init incorrectly used the previous tdep to
1000      determine the wordsize.  */
1001   if (exec_bfd)
1002     {
1003       const struct bfd_arch_info *exec_bfd_arch_info;
1004
1005       exec_bfd_arch_info = bfd_get_arch_info (exec_bfd);
1006       if (arch == exec_bfd_arch_info->arch)
1007         return;
1008     }
1009
1010   bfd_default_set_arch_mach (&abfd, arch, mach);
1011
1012   gdbarch_info_init (&info);
1013   info.bfd_arch_info = bfd_get_arch_info (&abfd);
1014   info.abfd = exec_bfd;
1015
1016   if (!gdbarch_update_p (info))
1017     internal_error (__FILE__, __LINE__,
1018                     _("rs6000_create_inferior: failed to select architecture"));
1019 }
1020
1021 \f
1022 /* xcoff_relocate_symtab -      hook for symbol table relocation.
1023
1024    This is only applicable to live processes, and is a no-op when
1025    debugging a core file.  */
1026
1027 void
1028 xcoff_relocate_symtab (unsigned int pid)
1029 {
1030   int load_segs = 64; /* number of load segments */
1031   int rc;
1032   LdInfo *ldi = NULL;
1033   int arch64 = ARCH64 ();
1034   int ldisize = arch64 ? sizeof (ldi->l64) : sizeof (ldi->l32);
1035   int size;
1036
1037   if (ptid_equal (inferior_ptid, null_ptid))
1038     return;
1039
1040   do
1041     {
1042       size = load_segs * ldisize;
1043       ldi = (void *) xrealloc (ldi, size);
1044
1045 #if 0
1046       /* According to my humble theory, AIX has some timing problems and
1047          when the user stack grows, kernel doesn't update stack info in time
1048          and ptrace calls step on user stack. That is why we sleep here a
1049          little, and give kernel to update its internals. */
1050       usleep (36000);
1051 #endif
1052
1053       if (arch64)
1054         rc = rs6000_ptrace64 (PT_LDINFO, pid, (unsigned long) ldi, size, NULL);
1055       else
1056         rc = rs6000_ptrace32 (PT_LDINFO, pid, (int *) ldi, size, NULL);
1057
1058       if (rc == -1)
1059         {
1060           if (errno == ENOMEM)
1061             load_segs *= 2;
1062           else
1063             perror_with_name (_("ptrace ldinfo"));
1064         }
1065       else
1066         {
1067           vmap_ldinfo (ldi);
1068           vmap_exec (); /* relocate the exec and core sections as well. */
1069         }
1070     } while (rc == -1);
1071   if (ldi)
1072     xfree (ldi);
1073 }
1074 \f
1075 /* Core file stuff.  */
1076
1077 /* Relocate symtabs and read in shared library info, based on symbols
1078    from the core file.  */
1079
1080 void
1081 xcoff_relocate_core (struct target_ops *target)
1082 {
1083   struct bfd_section *ldinfo_sec;
1084   int offset = 0;
1085   LdInfo *ldi;
1086   struct vmap *vp;
1087   int arch64 = ARCH64 ();
1088
1089   /* Size of a struct ld_info except for the variable-length filename. */
1090   int nonfilesz = (int)LDI_FILENAME ((LdInfo *)0, arch64);
1091
1092   /* Allocated size of buffer.  */
1093   int buffer_size = nonfilesz;
1094   char *buffer = xmalloc (buffer_size);
1095   struct cleanup *old = make_cleanup (free_current_contents, &buffer);
1096
1097   ldinfo_sec = bfd_get_section_by_name (core_bfd, ".ldinfo");
1098   if (ldinfo_sec == NULL)
1099     {
1100     bfd_err:
1101       fprintf_filtered (gdb_stderr, "Couldn't get ldinfo from core file: %s\n",
1102                         bfd_errmsg (bfd_get_error ()));
1103       do_cleanups (old);
1104       return;
1105     }
1106   do
1107     {
1108       int i;
1109       int names_found = 0;
1110
1111       /* Read in everything but the name.  */
1112       if (bfd_get_section_contents (core_bfd, ldinfo_sec, buffer,
1113                                     offset, nonfilesz) == 0)
1114         goto bfd_err;
1115
1116       /* Now the name.  */
1117       i = nonfilesz;
1118       do
1119         {
1120           if (i == buffer_size)
1121             {
1122               buffer_size *= 2;
1123               buffer = xrealloc (buffer, buffer_size);
1124             }
1125           if (bfd_get_section_contents (core_bfd, ldinfo_sec, &buffer[i],
1126                                         offset + i, 1) == 0)
1127             goto bfd_err;
1128           if (buffer[i++] == '\0')
1129             ++names_found;
1130         }
1131       while (names_found < 2);
1132
1133       ldi = (LdInfo *) buffer;
1134
1135       /* Can't use a file descriptor from the core file; need to open it.  */
1136       if (arch64)
1137         ldi->l64.ldinfo_fd = -1;
1138       else
1139         ldi->l32.ldinfo_fd = -1;
1140
1141       /* The first ldinfo is for the exec file, allocated elsewhere.  */
1142       if (offset == 0 && vmap != NULL)
1143         vp = vmap;
1144       else
1145         vp = add_vmap (ldi);
1146
1147       /* Process next shared library upon error. */
1148       offset += LDI_NEXT (ldi, arch64);
1149       if (vp == NULL)
1150         continue;
1151
1152       vmap_secs (vp, ldi, arch64);
1153
1154       /* Unless this is the exec file,
1155          add our sections to the section table for the core target.  */
1156       if (vp != vmap)
1157         {
1158           struct section_table *stp;
1159
1160           target_resize_to_sections (target, 2);
1161           stp = target->to_sections_end - 2;
1162
1163           stp->bfd = vp->bfd;
1164           stp->the_bfd_section = bfd_get_section_by_name (stp->bfd, ".text");
1165           stp->addr = vp->tstart;
1166           stp->endaddr = vp->tend;
1167           stp++;
1168
1169           stp->bfd = vp->bfd;
1170           stp->the_bfd_section = bfd_get_section_by_name (stp->bfd, ".data");
1171           stp->addr = vp->dstart;
1172           stp->endaddr = vp->dend;
1173         }
1174
1175       vmap_symtab (vp);
1176
1177       if (vp != vmap && vp->objfile)
1178         observer_notify_new_objfile (vp->objfile);
1179     }
1180   while (LDI_NEXT (ldi, arch64) != 0);
1181   vmap_exec ();
1182   breakpoint_re_set ();
1183   do_cleanups (old);
1184 }
1185 \f
1186 /* Under AIX, we have to pass the correct TOC pointer to a function
1187    when calling functions in the inferior.
1188    We try to find the relative toc offset of the objfile containing PC
1189    and add the current load address of the data segment from the vmap.  */
1190
1191 static CORE_ADDR
1192 find_toc_address (CORE_ADDR pc)
1193 {
1194   struct vmap *vp;
1195   extern CORE_ADDR get_toc_offset (struct objfile *);   /* xcoffread.c */
1196
1197   for (vp = vmap; vp; vp = vp->nxt)
1198     {
1199       if (pc >= vp->tstart && pc < vp->tend)
1200         {
1201           /* vp->objfile is only NULL for the exec file.  */
1202           return vp->dstart + get_toc_offset (vp->objfile == NULL
1203                                               ? symfile_objfile
1204                                               : vp->objfile);
1205         }
1206     }
1207   error (_("Unable to find TOC entry for pc %s."), hex_string (pc));
1208 }
1209 \f
1210
1211 void
1212 _initialize_rs6000_nat (void)
1213 {
1214   struct target_ops *t;
1215
1216   t = inf_ptrace_target ();
1217   t->to_fetch_registers = rs6000_fetch_inferior_registers;
1218   t->to_store_registers = rs6000_store_inferior_registers;
1219   t->to_xfer_partial = rs6000_xfer_partial;
1220
1221   super_create_inferior = t->to_create_inferior;
1222   t->to_create_inferior = rs6000_create_inferior;
1223
1224   t->to_wait = rs6000_wait;
1225
1226   add_target (t);
1227
1228   /* Initialize hook in rs6000-tdep.c for determining the TOC address
1229      when calling functions in the inferior.  */
1230   rs6000_find_toc_address_hook = find_toc_address;
1231 }