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