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