gdb/rs6000-nat.c

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