gdb/rs6000-nat.c

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