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