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