gdb/rs6000-nat.c

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