gdb/rs6000-nat.c

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