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