gdb/rs6000-nat.c

   1 /* IBM RS/6000 native-dependent code for GDB, the GNU debugger.
   2
   3    Copyright (C) 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
   4    1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007
   5    Free Software Foundation, Inc.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 2 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 51 Franklin Street, Fifth Floor,
  22    Boston, MA 02110-1301, USA.  */
  23
  24 #include "defs.h"
  25 #include "inferior.h"
  26 #include "target.h"
  27 #include "gdbcore.h"
  28 #include "xcoffsolib.h"
  29 #include "symfile.h"
  30 #include "objfiles.h"
  31 #include "libbfd.h"             /* For bfd_default_set_arch_mach (FIXME) */
  32 #include "bfd.h"
  33 #include "exceptions.h"
  34 #include "gdb-stabs.h"
  35 #include "regcache.h"
  36 #include "arch-utils.h"
  37 #include "inf-ptrace.h"
  38 #include "ppc-tdep.h"
  39 #include "rs6000-tdep.h"
  40 #include "exec.h"
  41 #include "gdb_stdint.h"
  42
  43 #include <sys/ptrace.h>
  44 #include <sys/reg.h>
  45
  46 #include <sys/param.h>
  47 #include <sys/dir.h>
  48 #include <sys/user.h>
  49 #include <signal.h>
  50 #include <sys/ioctl.h>
  51 #include <fcntl.h>
  52 #include <errno.h>
  53
  54 #include <a.out.h>
  55 #include <sys/file.h>
  56 #include "gdb_stat.h"
  57 #include <sys/core.h>
  58 #define __LDINFO_PTRACE32__     /* for __ld_info32 */
  59 #define __LDINFO_PTRACE64__     /* for __ld_info64 */
  60 #include <sys/ldr.h>
  61 #include <sys/systemcfg.h>
  62
  63 /* On AIX4.3+, sys/ldr.h provides different versions of struct ld_info for
  64    debugging 32-bit and 64-bit processes.  Define a typedef and macros for
  65    accessing fields in the appropriate structures. */
  66
  67 /* In 32-bit compilation mode (which is the only mode from which ptrace()
  68    works on 4.3), __ld_info32 is #defined as equivalent to ld_info. */
  69
  70 #ifdef __ld_info32
  71 # define ARCH3264
  72 #endif
  73
  74 /* Return whether the current architecture is 64-bit. */
  75
  76 #ifndef ARCH3264
  77 # define ARCH64() 0
  78 #else
  79 # define ARCH64() (register_size (current_gdbarch, 0) == 8)
  80 #endif
  81
  82 /* Union of 32-bit and 64-bit versions of ld_info. */
  83
  84 typedef union {
  85 #ifndef ARCH3264
  86   struct ld_info l32;
  87   struct ld_info l64;
  88 #else
  89   struct __ld_info32 l32;
  90   struct __ld_info64 l64;
  91 #endif
  92 } LdInfo;
  93
  94 /* If compiling with 32-bit and 64-bit debugging capability (e.g. AIX 4.x),
  95    declare and initialize a variable named VAR suitable for use as the arch64
  96    parameter to the various LDI_*() macros. */
  97
  98 #ifndef ARCH3264
  99 # define ARCH64_DECL(var)
 100 #else
 101 # define ARCH64_DECL(var) int var = ARCH64 ()
 102 #endif
 103
 104 /* Return LDI's FIELD for a 64-bit process if ARCH64 and for a 32-bit process
 105    otherwise.  This technique only works for FIELDs with the same data type in
 106    32-bit and 64-bit versions of ld_info. */
 107
 108 #ifndef ARCH3264
 109 # define LDI_FIELD(ldi, arch64, field) (ldi)->l32.ldinfo_##field
 110 #else
 111 # define LDI_FIELD(ldi, arch64, field) \
 112   (arch64 ? (ldi)->l64.ldinfo_##field : (ldi)->l32.ldinfo_##field)
 113 #endif
 114
 115 /* Return various LDI fields for a 64-bit process if ARCH64 and for a 32-bit
 116    process otherwise. */
 117
 118 #define LDI_NEXT(ldi, arch64)           LDI_FIELD(ldi, arch64, next)
 119 #define LDI_FD(ldi, arch64)             LDI_FIELD(ldi, arch64, fd)
 120 #define LDI_FILENAME(ldi, arch64)       LDI_FIELD(ldi, arch64, filename)
 121
 122 extern struct vmap *map_vmap (bfd * bf, bfd * arch);
 123
 124 static void vmap_exec (void);
 125
 126 static void vmap_ldinfo (LdInfo *);
 127
 128 static struct vmap *add_vmap (LdInfo *);
 129
 130 static int objfile_symbol_add (void *);
 131
 132 static void vmap_symtab (struct vmap *);
 133
 134 static void exec_one_dummy_insn (void);
 135
 136 extern void fixup_breakpoints (CORE_ADDR low, CORE_ADDR high, CORE_ADDR delta);
 137
 138 /* Given REGNO, a gdb register number, return the corresponding
 139    number suitable for use as a ptrace() parameter.  Return -1 if
 140    there's no suitable mapping.  Also, set the int pointed to by
 141    ISFLOAT to indicate whether REGNO is a floating point register.  */
 142
 143 static int
 144 regmap (int regno, int *isfloat)
 145 {
 146   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
 147
 148   *isfloat = 0;
 149   if (tdep->ppc_gp0_regnum <= regno
 150       && regno < tdep->ppc_gp0_regnum + ppc_num_gprs)
 151     return regno;
 152   else if (tdep->ppc_fp0_regnum >= 0
 153            && tdep->ppc_fp0_regnum <= regno
 154            && regno < tdep->ppc_fp0_regnum + ppc_num_fprs)
 155     {
 156       *isfloat = 1;
 157       return regno - tdep->ppc_fp0_regnum + FPR0;
 158     }
 159   else if (regno == PC_REGNUM)
 160     return IAR;
 161   else if (regno == tdep->ppc_ps_regnum)
 162     return MSR;
 163   else if (regno == tdep->ppc_cr_regnum)
 164     return CR;
 165   else if (regno == tdep->ppc_lr_regnum)
 166     return LR;
 167   else if (regno == tdep->ppc_ctr_regnum)
 168     return CTR;
 169   else if (regno == tdep->ppc_xer_regnum)
 170     return XER;
 171   else if (tdep->ppc_fpscr_regnum >= 0
 172            && regno == tdep->ppc_fpscr_regnum)
 173     return FPSCR;
 174   else if (tdep->ppc_mq_regnum >= 0 && regno == tdep->ppc_mq_regnum)
 175     return MQ;
 176   else
 177     return -1;
 178 }
 179
 180 /* Call ptrace(REQ, ID, ADDR, DATA, BUF). */
 181
 182 static int
 183 rs6000_ptrace32 (int req, int id, int *addr, int data, int *buf)
 184 {
 185   int ret = ptrace (req, id, (int *)addr, data, buf);
 186 #if 0
 187   printf ("rs6000_ptrace32 (%d, %d, 0x%x, %08x, 0x%x) = 0x%x\n",
 188           req, id, (unsigned int)addr, data, (unsigned int)buf, ret);
 189 #endif
 190   return ret;
 191 }
 192
 193 /* Call ptracex(REQ, ID, ADDR, DATA, BUF). */
 194
 195 static int
 196 rs6000_ptrace64 (int req, int id, long long addr, int data, void *buf)
 197 {
 198 #ifdef ARCH3264
 199   int ret = ptracex (req, id, addr, data, buf);
 200 #else
 201   int ret = 0;
 202 #endif
 203 #if 0
 204   printf ("rs6000_ptrace64 (%d, %d, 0x%llx, %08x, 0x%x) = 0x%x\n",
 205           req, id, addr, data, (unsigned int)buf, ret);
 206 #endif
 207   return ret;
 208 }
 209
 210 /* Fetch register REGNO from the inferior. */
 211
 212 static void
 213 fetch_register (int regno)
 214 {
 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 (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 >= NUM_REGS)
 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 (current_gdbarch, regno) == 8)
 249             memcpy (addr, &buf, 8);
 250           else
 251             *addr = buf;
 252         }
 253     }
 254
 255   if (!errno)
 256     regcache_raw_supply (current_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 (int regno)
 271 {
 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 (current_regcache, regno, addr);
 277
 278   /* -1 can be a successful return value, so infer errors from errno. */
 279   errno = 0;
 280
 281   nr = regmap (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 >= NUM_REGS)
 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 == SP_REGNUM)
 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 ();
 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 (current_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 (int regno)
 337 {
 338   if (regno != -1)
 339     fetch_register (regno);
 340
 341   else
 342     {
 343       struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
 344
 345       /* Read 32 general purpose registers.  */
 346       for (regno = tdep->ppc_gp0_regnum;
 347            regno < tdep->ppc_gp0_regnum + ppc_num_gprs;
 348            regno++)
 349         {
 350           fetch_register (regno);
 351         }
 352
 353       /* Read general purpose floating point registers.  */
 354       if (tdep->ppc_fp0_regnum >= 0)
 355         for (regno = 0; regno < ppc_num_fprs; regno++)
 356           fetch_register (tdep->ppc_fp0_regnum + regno);
 357
 358       /* Read special registers.  */
 359       fetch_register (PC_REGNUM);
 360       fetch_register (tdep->ppc_ps_regnum);
 361       fetch_register (tdep->ppc_cr_regnum);
 362       fetch_register (tdep->ppc_lr_regnum);
 363       fetch_register (tdep->ppc_ctr_regnum);
 364       fetch_register (tdep->ppc_xer_regnum);
 365       if (tdep->ppc_fpscr_regnum >= 0)
 366         fetch_register (tdep->ppc_fpscr_regnum);
 367       if (tdep->ppc_mq_regnum >= 0)
 368         fetch_register (tdep->ppc_mq_regnum);
 369     }
 370 }
 371
 372 /* Store our register values back into the inferior.
 373    If REGNO is -1, do this for all registers.
 374    Otherwise, REGNO specifies which register (so we can save time).  */
 375
 376 static void
 377 rs6000_store_inferior_registers (int regno)
 378 {
 379   if (regno != -1)
 380     store_register (regno);
 381
 382   else
 383     {
 384       struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
 385
 386       /* Write general purpose registers first.  */
 387       for (regno = tdep->ppc_gp0_regnum;
 388            regno < tdep->ppc_gp0_regnum + ppc_num_gprs;
 389            regno++)
 390         {
 391           store_register (regno);
 392         }
 393
 394       /* Write floating point registers.  */
 395       if (tdep->ppc_fp0_regnum >= 0)
 396         for (regno = 0; regno < ppc_num_fprs; regno++)
 397           store_register (tdep->ppc_fp0_regnum + regno);
 398
 399       /* Write special registers.  */
 400       store_register (PC_REGNUM);
 401       store_register (tdep->ppc_ps_regnum);
 402       store_register (tdep->ppc_cr_regnum);
 403       store_register (tdep->ppc_lr_regnum);
 404       store_register (tdep->ppc_ctr_regnum);
 405       store_register (tdep->ppc_xer_regnum);
 406       if (tdep->ppc_fpscr_regnum >= 0)
 407         store_register (tdep->ppc_fpscr_regnum);
 408       if (tdep->ppc_mq_regnum >= 0)
 409         store_register (tdep->ppc_mq_regnum);
 410     }
 411 }
 412
 413
 414 /* Attempt a transfer all LEN bytes starting at OFFSET between the
 415    inferior's OBJECT:ANNEX space and GDB's READBUF/WRITEBUF buffer.
 416    Return the number of bytes actually transferred.  */
 417
 418 static LONGEST
 419 rs6000_xfer_partial (struct target_ops *ops, enum target_object object,
 420                      const char *annex, gdb_byte *readbuf,
 421                      const gdb_byte *writebuf,
 422                      ULONGEST offset, LONGEST len)
 423 {
 424   pid_t pid = ptid_get_pid (inferior_ptid);
 425   int arch64 = ARCH64 ();
 426
 427   switch (object)
 428     {
 429     case TARGET_OBJECT_MEMORY:
 430       {
 431         union
 432         {
 433           PTRACE_TYPE_RET word;
 434           gdb_byte byte[sizeof (PTRACE_TYPE_RET)];
 435         } buffer;
 436         ULONGEST rounded_offset;
 437         LONGEST partial_len;
 438
 439         /* Round the start offset down to the next long word
 440            boundary.  */
 441         rounded_offset = offset & -(ULONGEST) sizeof (PTRACE_TYPE_RET);
 442
 443         /* Since ptrace will transfer a single word starting at that
 444            rounded_offset the partial_len needs to be adjusted down to
 445            that (remember this function only does a single transfer).
 446            Should the required length be even less, adjust it down
 447            again.  */
 448         partial_len = (rounded_offset + sizeof (PTRACE_TYPE_RET)) - offset;
 449         if (partial_len > len)
 450           partial_len = len;
 451
 452         if (writebuf)
 453           {
 454             /* If OFFSET:PARTIAL_LEN is smaller than
 455                ROUNDED_OFFSET:WORDSIZE then a read/modify write will
 456                be needed.  Read in the entire word.  */
 457             if (rounded_offset < offset
 458                 || (offset + partial_len
 459                     < rounded_offset + sizeof (PTRACE_TYPE_RET)))
 460               {
 461                 /* Need part of initial word -- fetch it.  */
 462                 if (arch64)
 463                   buffer.word = rs6000_ptrace64 (PT_READ_I, pid,
 464                                                  rounded_offset, 0, NULL);
 465                 else
 466                   buffer.word = rs6000_ptrace32 (PT_READ_I, pid,
 467                                                  (int *)(uintptr_t)rounded_offset,
 468                                                  0, NULL);
 469               }
 470
 471             /* Copy data to be written over corresponding part of
 472                buffer.  */
 473             memcpy (buffer.byte + (offset - rounded_offset),
 474                     writebuf, partial_len);
 475
 476             errno = 0;
 477             if (arch64)
 478               rs6000_ptrace64 (PT_WRITE_D, pid,
 479                                rounded_offset, buffer.word, NULL);
 480             else
 481               rs6000_ptrace32 (PT_WRITE_D, pid,
 482                                (int *)(uintptr_t)rounded_offset, buffer.word, NULL);
 483             if (errno)
 484               return 0;
 485           }
 486
 487         if (readbuf)
 488           {
 489             errno = 0;
 490             if (arch64)
 491               buffer.word = rs6000_ptrace64 (PT_READ_I, pid,
 492                                              rounded_offset, 0, NULL);
 493             else
 494               buffer.word = rs6000_ptrace32 (PT_READ_I, pid,
 495                                              (int *)(uintptr_t)rounded_offset,
 496                                              0, NULL);
 497             if (errno)
 498               return 0;
 499
 500             /* Copy appropriate bytes out of the buffer.  */
 501             memcpy (readbuf, buffer.byte + (offset - rounded_offset),
 502                     partial_len);
 503           }
 504
 505         return partial_len;
 506       }
 507
 508     default:
 509       return -1;
 510     }
 511 }
 512
 513 /* Wait for the child specified by PTID to do something.  Return the
 514    process ID of the child, or MINUS_ONE_PTID in case of error; store
 515    the status in *OURSTATUS.  */
 516
 517 static ptid_t
 518 rs6000_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
 519 {
 520   pid_t pid;
 521   int status, save_errno;
 522
 523   do
 524     {
 525       set_sigint_trap ();
 526       set_sigio_trap ();
 527
 528       do
 529         {
 530           pid = waitpid (ptid_get_pid (ptid), &status, 0);
 531           save_errno = errno;
 532         }
 533       while (pid == -1 && errno == EINTR);
 534
 535       clear_sigio_trap ();
 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 minus_one_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 (void)
 577 {
 578 #define DUMMY_INSN_ADDR gdbarch_tdep (current_gdbarch)->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 (DEPRECATED_STREQ (mem, last->filename))
 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] == '/' && !DEPRECATED_STREQ (name, vp->name))
 847               || (memb[0] && !DEPRECATED_STREQ (memb, vp->member)))
 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 (deprecated_target_new_objfile_hook && vp->objfile)
 884             deprecated_target_new_objfile_hook (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 (DEPRECATED_STREQ (".text", exec_ops.to_sections[i].the_bfd_section->name))
 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 (DEPRECATED_STREQ (".data", exec_ops.to_sections[i].the_bfd_section->name))
 950         {
 951           exec_ops.to_sections[i].addr += vmap->dstart - vmap->dvma;
 952           exec_ops.to_sections[i].endaddr += vmap->dstart - vmap->dvma;
 953         }
 954       else if (DEPRECATED_STREQ (".bss", exec_ops.to_sections[i].the_bfd_section->name))
 955         {
 956           exec_ops.to_sections[i].addr += vmap->dstart - vmap->dvma;
 957           exec_ops.to_sections[i].endaddr += vmap->dstart - vmap->dvma;
 958         }
 959     }
 960 }
 961
 962 /* Set the current architecture from the host running GDB.  Called when
 963    starting a child process. */
 964
 965 static void (*super_create_inferior) (char *exec_file, char *allargs,
 966                                       char **env, int from_tty);
 967 static void
 968 rs6000_create_inferior (char *exec_file, char *allargs, char **env, int from_tty)
 969 {
 970   enum bfd_architecture arch;
 971   unsigned long mach;
 972   bfd abfd;
 973   struct gdbarch_info info;
 974
 975   super_create_inferior (exec_file, allargs, env, from_tty);
 976
 977   if (__power_rs ())
 978     {
 979       arch = bfd_arch_rs6000;
 980       mach = bfd_mach_rs6k;
 981     }
 982   else
 983     {
 984       arch = bfd_arch_powerpc;
 985       mach = bfd_mach_ppc;
 986     }
 987
 988   /* FIXME: schauer/2002-02-25:
 989      We don't know if we are executing a 32 or 64 bit executable,
 990      and have no way to pass the proper word size to rs6000_gdbarch_init.
 991      So we have to avoid switching to a new architecture, if the architecture
 992      matches already.
 993      Blindly calling rs6000_gdbarch_init used to work in older versions of
 994      GDB, as rs6000_gdbarch_init incorrectly used the previous tdep to
 995      determine the wordsize.  */
 996   if (exec_bfd)
 997     {
 998       const struct bfd_arch_info *exec_bfd_arch_info;
 999
1000       exec_bfd_arch_info = bfd_get_arch_info (exec_bfd);
1001       if (arch == exec_bfd_arch_info->arch)
1002         return;
1003     }
1004
1005   bfd_default_set_arch_mach (&abfd, arch, mach);
1006
1007   gdbarch_info_init (&info);
1008   info.bfd_arch_info = bfd_get_arch_info (&abfd);
1009   info.abfd = exec_bfd;
1010
1011   if (!gdbarch_update_p (info))
1012     internal_error (__FILE__, __LINE__,
1013                     _("rs6000_create_inferior: failed to select architecture"));
1014 }
1015
1016 \f
1017 /* xcoff_relocate_symtab -      hook for symbol table relocation.
1018    also reads shared libraries.  */
1019
1020 void
1021 xcoff_relocate_symtab (unsigned int pid)
1022 {
1023   int load_segs = 64; /* number of load segments */
1024   int rc;
1025   LdInfo *ldi = NULL;
1026   int arch64 = ARCH64 ();
1027   int ldisize = arch64 ? sizeof (ldi->l64) : sizeof (ldi->l32);
1028   int size;
1029
1030   do
1031     {
1032       size = load_segs * ldisize;
1033       ldi = (void *) xrealloc (ldi, size);
1034
1035 #if 0
1036       /* According to my humble theory, AIX has some timing problems and
1037          when the user stack grows, kernel doesn't update stack info in time
1038          and ptrace calls step on user stack. That is why we sleep here a
1039          little, and give kernel to update its internals. */
1040       usleep (36000);
1041 #endif
1042
1043       if (arch64)
1044         rc = rs6000_ptrace64 (PT_LDINFO, pid, (unsigned long) ldi, size, NULL);
1045       else
1046         rc = rs6000_ptrace32 (PT_LDINFO, pid, (int *) ldi, size, NULL);
1047
1048       if (rc == -1)
1049         {
1050           if (errno == ENOMEM)
1051             load_segs *= 2;
1052           else
1053             perror_with_name (_("ptrace ldinfo"));
1054         }
1055       else
1056         {
1057           vmap_ldinfo (ldi);
1058           vmap_exec (); /* relocate the exec and core sections as well. */
1059         }
1060     } while (rc == -1);
1061   if (ldi)
1062     xfree (ldi);
1063 }
1064 \f
1065 /* Core file stuff.  */
1066
1067 /* Relocate symtabs and read in shared library info, based on symbols
1068    from the core file.  */
1069
1070 void
1071 xcoff_relocate_core (struct target_ops *target)
1072 {
1073   struct bfd_section *ldinfo_sec;
1074   int offset = 0;
1075   LdInfo *ldi;
1076   struct vmap *vp;
1077   int arch64 = ARCH64 ();
1078
1079   /* Size of a struct ld_info except for the variable-length filename. */
1080   int nonfilesz = (int)LDI_FILENAME ((LdInfo *)0, arch64);
1081
1082   /* Allocated size of buffer.  */
1083   int buffer_size = nonfilesz;
1084   char *buffer = xmalloc (buffer_size);
1085   struct cleanup *old = make_cleanup (free_current_contents, &buffer);
1086
1087   ldinfo_sec = bfd_get_section_by_name (core_bfd, ".ldinfo");
1088   if (ldinfo_sec == NULL)
1089     {
1090     bfd_err:
1091       fprintf_filtered (gdb_stderr, "Couldn't get ldinfo from core file: %s\n",
1092                         bfd_errmsg (bfd_get_error ()));
1093       do_cleanups (old);
1094       return;
1095     }
1096   do
1097     {
1098       int i;
1099       int names_found = 0;
1100
1101       /* Read in everything but the name.  */
1102       if (bfd_get_section_contents (core_bfd, ldinfo_sec, buffer,
1103                                     offset, nonfilesz) == 0)
1104         goto bfd_err;
1105
1106       /* Now the name.  */
1107       i = nonfilesz;
1108       do
1109         {
1110           if (i == buffer_size)
1111             {
1112               buffer_size *= 2;
1113               buffer = xrealloc (buffer, buffer_size);
1114             }
1115           if (bfd_get_section_contents (core_bfd, ldinfo_sec, &buffer[i],
1116                                         offset + i, 1) == 0)
1117             goto bfd_err;
1118           if (buffer[i++] == '\0')
1119             ++names_found;
1120         }
1121       while (names_found < 2);
1122
1123       ldi = (LdInfo *) buffer;
1124
1125       /* Can't use a file descriptor from the core file; need to open it.  */
1126       if (arch64)
1127         ldi->l64.ldinfo_fd = -1;
1128       else
1129         ldi->l32.ldinfo_fd = -1;
1130
1131       /* The first ldinfo is for the exec file, allocated elsewhere.  */
1132       if (offset == 0 && vmap != NULL)
1133         vp = vmap;
1134       else
1135         vp = add_vmap (ldi);
1136
1137       /* Process next shared library upon error. */
1138       offset += LDI_NEXT (ldi, arch64);
1139       if (vp == NULL)
1140         continue;
1141
1142       vmap_secs (vp, ldi, arch64);
1143
1144       /* Unless this is the exec file,
1145          add our sections to the section table for the core target.  */
1146       if (vp != vmap)
1147         {
1148           struct section_table *stp;
1149
1150           target_resize_to_sections (target, 2);
1151           stp = target->to_sections_end - 2;
1152
1153           stp->bfd = vp->bfd;
1154           stp->the_bfd_section = bfd_get_section_by_name (stp->bfd, ".text");
1155           stp->addr = vp->tstart;
1156           stp->endaddr = vp->tend;
1157           stp++;
1158
1159           stp->bfd = vp->bfd;
1160           stp->the_bfd_section = bfd_get_section_by_name (stp->bfd, ".data");
1161           stp->addr = vp->dstart;
1162           stp->endaddr = vp->dend;
1163         }
1164
1165       vmap_symtab (vp);
1166
1167       if (deprecated_target_new_objfile_hook && vp != vmap && vp->objfile)
1168         deprecated_target_new_objfile_hook (vp->objfile);
1169     }
1170   while (LDI_NEXT (ldi, arch64) != 0);
1171   vmap_exec ();
1172   breakpoint_re_set ();
1173   do_cleanups (old);
1174 }
1175 \f
1176 /* Under AIX, we have to pass the correct TOC pointer to a function
1177    when calling functions in the inferior.
1178    We try to find the relative toc offset of the objfile containing PC
1179    and add the current load address of the data segment from the vmap.  */
1180
1181 static CORE_ADDR
1182 find_toc_address (CORE_ADDR pc)
1183 {
1184   struct vmap *vp;
1185   extern CORE_ADDR get_toc_offset (struct objfile *);   /* xcoffread.c */
1186
1187   for (vp = vmap; vp; vp = vp->nxt)
1188     {
1189       if (pc >= vp->tstart && pc < vp->tend)
1190         {
1191           /* vp->objfile is only NULL for the exec file.  */
1192           return vp->dstart + get_toc_offset (vp->objfile == NULL
1193                                               ? symfile_objfile
1194                                               : vp->objfile);
1195         }
1196     }
1197   error (_("Unable to find TOC entry for pc %s."), hex_string (pc));
1198 }
1199 \f
1200
1201 void
1202 _initialize_rs6000_nat (void)
1203 {
1204   struct target_ops *t;
1205
1206   t = inf_ptrace_target ();
1207   t->to_fetch_registers = rs6000_fetch_inferior_registers;
1208   t->to_store_registers = rs6000_store_inferior_registers;
1209   t->to_xfer_partial = rs6000_xfer_partial;
1210
1211   super_create_inferior = t->to_create_inferior;
1212   t->to_create_inferior = rs6000_create_inferior;
1213
1214   t->to_wait = rs6000_wait;
1215
1216   add_target (t);
1217
1218   /* Initialize hook in rs6000-tdep.c for determining the TOC address
1219      when calling functions in the inferior.  */
1220   rs6000_find_toc_address_hook = find_toc_address;
1221 }