gdb/rs6000-nat.c

   1 /* IBM RS/6000 native-dependent code for GDB, the GNU debugger.
   2    Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
   3    1998, 1999, 2000, 2001, 2002
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 59 Temple Place - Suite 330,
  21    Boston, MA 02111-1307, USA.  */
  22
  23 #include "defs.h"
  24 #include "inferior.h"
  25 #include "target.h"
  26 #include "gdbcore.h"
  27 #include "xcoffsolib.h"
  28 #include "symfile.h"
  29 #include "objfiles.h"
  30 #include "libbfd.h"             /* For bfd_cache_lookup (FIXME) */
  31 #include "bfd.h"
  32 #include "gdb-stabs.h"
  33 #include "regcache.h"
  34 #include "arch-utils.h"
  35 #include "language.h"           /* for local_hex_string().  */
  36 #include "ppc-tdep.h"
  37
  38 #include <sys/ptrace.h>
  39 #include <sys/reg.h>
  40
  41 #include <sys/param.h>
  42 #include <sys/dir.h>
  43 #include <sys/user.h>
  44 #include <signal.h>
  45 #include <sys/ioctl.h>
  46 #include <fcntl.h>
  47 #include <errno.h>
  48
  49 #include <a.out.h>
  50 #include <sys/file.h>
  51 #include "gdb_stat.h"
  52 #include <sys/core.h>
  53 #define __LDINFO_PTRACE32__     /* for __ld_info32 */
  54 #define __LDINFO_PTRACE64__     /* for __ld_info64 */
  55 #include <sys/ldr.h>
  56 #include <sys/systemcfg.h>
  57
  58 /* On AIX4.3+, sys/ldr.h provides different versions of struct ld_info for
  59    debugging 32-bit and 64-bit processes.  Define a typedef and macros for
  60    accessing fields in the appropriate structures. */
  61
  62 /* In 32-bit compilation mode (which is the only mode from which ptrace()
  63    works on 4.3), __ld_info32 is #defined as equivalent to ld_info. */
  64
  65 #ifdef __ld_info32
  66 # define ARCH3264
  67 #endif
  68
  69 /* Return whether the current architecture is 64-bit. */
  70
  71 #ifndef ARCH3264
  72 # define ARCH64() 0
  73 #else
  74 # define ARCH64() (REGISTER_RAW_SIZE (0) == 8)
  75 #endif
  76
  77 /* Union of 32-bit and 64-bit ".reg" core file sections. */
  78
  79 typedef union {
  80 #ifdef ARCH3264
  81   struct __context64 r64;
  82 #else
  83   struct mstsave r64;
  84 #endif
  85   struct mstsave r32;
  86 } CoreRegs;
  87
  88 /* Union of 32-bit and 64-bit versions of ld_info. */
  89
  90 typedef union {
  91 #ifndef ARCH3264
  92   struct ld_info l32;
  93   struct ld_info l64;
  94 #else
  95   struct __ld_info32 l32;
  96   struct __ld_info64 l64;
  97 #endif
  98 } LdInfo;
  99
 100 /* If compiling with 32-bit and 64-bit debugging capability (e.g. AIX 4.x),
 101    declare and initialize a variable named VAR suitable for use as the arch64
 102    parameter to the various LDI_*() macros. */
 103
 104 #ifndef ARCH3264
 105 # define ARCH64_DECL(var)
 106 #else
 107 # define ARCH64_DECL(var) int var = ARCH64 ()
 108 #endif
 109
 110 /* Return LDI's FIELD for a 64-bit process if ARCH64 and for a 32-bit process
 111    otherwise.  This technique only works for FIELDs with the same data type in
 112    32-bit and 64-bit versions of ld_info. */
 113
 114 #ifndef ARCH3264
 115 # define LDI_FIELD(ldi, arch64, field) (ldi)->l32.ldinfo_##field
 116 #else
 117 # define LDI_FIELD(ldi, arch64, field) \
 118   (arch64 ? (ldi)->l64.ldinfo_##field : (ldi)->l32.ldinfo_##field)
 119 #endif
 120
 121 /* Return various LDI fields for a 64-bit process if ARCH64 and for a 32-bit
 122    process otherwise. */
 123
 124 #define LDI_NEXT(ldi, arch64)           LDI_FIELD(ldi, arch64, next)
 125 #define LDI_FD(ldi, arch64)             LDI_FIELD(ldi, arch64, fd)
 126 #define LDI_FILENAME(ldi, arch64)       LDI_FIELD(ldi, arch64, filename)
 127
 128 extern struct vmap *map_vmap (bfd * bf, bfd * arch);
 129
 130 extern struct target_ops exec_ops;
 131
 132 static void vmap_exec (void);
 133
 134 static void vmap_ldinfo (LdInfo *);
 135
 136 static struct vmap *add_vmap (LdInfo *);
 137
 138 static int objfile_symbol_add (void *);
 139
 140 static void vmap_symtab (struct vmap *);
 141
 142 static void fetch_core_registers (char *, unsigned int, int, CORE_ADDR);
 143
 144 static void exec_one_dummy_insn (void);
 145
 146 extern void
 147 fixup_breakpoints (CORE_ADDR low, CORE_ADDR high, CORE_ADDR delta);
 148
 149 /* Given REGNO, a gdb register number, return the corresponding
 150    number suitable for use as a ptrace() parameter.  Return -1 if
 151    there's no suitable mapping.  Also, set the int pointed to by
 152    ISFLOAT to indicate whether REGNO is a floating point register.  */
 153
 154 static int
 155 regmap (int regno, int *isfloat)
 156 {
 157   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
 158
 159   *isfloat = 0;
 160   if (tdep->ppc_gp0_regnum <= regno && regno <= tdep->ppc_gplast_regnum)
 161     return regno;
 162   else if (FP0_REGNUM <= regno && regno <= FPLAST_REGNUM)
 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 = alloca (MAX_REGISTER_RAW_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 (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 = alloca (MAX_REGISTER_RAW_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 (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_gplast_regnum;
 355            regno++)
 356         {
 357           fetch_register (regno);
 358         }
 359
 360       /* Read general purpose floating point registers.  */
 361       for (regno = FP0_REGNUM; regno <= FPLAST_REGNUM; 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_gplast_regnum;
 394            regno++)
 395         {
 396           store_register (regno);
 397         }
 398
 399       /* Write floating point registers.  */
 400       for (regno = FP0_REGNUM; regno <= FPLAST_REGNUM; 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, buf + count - 1, arch64))
 490           return 0;
 491
 492       /* Copy supplied data into memory buffer. */
 493       memcpy ((char *)buf + (memaddr - addr), myaddr, len);
 494
 495       /* Store memory one word at a time. */
 496       for (i = 0, errno = 0; i < count; i++, addr += sizeof (int))
 497         {
 498           if (arch64)
 499             rs6000_ptrace64 (PT_WRITE_D, PIDGET (inferior_ptid), addr, buf[i], NULL);
 500           else
 501             rs6000_ptrace32 (PT_WRITE_D, PIDGET (inferior_ptid), (int *)(long) addr,
 502                       buf[i], NULL);
 503
 504           if (errno)
 505             return 0;
 506           QUIT;
 507         }
 508     }
 509
 510   return len;
 511 }
 512
 513 /* Execute one dummy breakpoint instruction.  This way we give the kernel
 514    a chance to do some housekeeping and update inferior's internal data,
 515    including u_area. */
 516
 517 static void
 518 exec_one_dummy_insn (void)
 519 {
 520 #define DUMMY_INSN_ADDR (TEXT_SEGMENT_BASE)+0x200
 521
 522   char shadow_contents[BREAKPOINT_MAX];         /* Stash old bkpt addr contents */
 523   int ret, status, pid;
 524   CORE_ADDR prev_pc;
 525
 526   /* We plant one dummy breakpoint into DUMMY_INSN_ADDR address. We
 527      assume that this address will never be executed again by the real
 528      code. */
 529
 530   target_insert_breakpoint (DUMMY_INSN_ADDR, shadow_contents);
 531
 532   /* You might think this could be done with a single ptrace call, and
 533      you'd be correct for just about every platform I've ever worked
 534      on.  However, rs6000-ibm-aix4.1.3 seems to have screwed this up --
 535      the inferior never hits the breakpoint (it's also worth noting
 536      powerpc-ibm-aix4.1.3 works correctly).  */
 537   prev_pc = read_pc ();
 538   write_pc (DUMMY_INSN_ADDR);
 539   if (ARCH64 ())
 540     ret = rs6000_ptrace64 (PT_CONTINUE, PIDGET (inferior_ptid), 1, 0, NULL);
 541   else
 542     ret = rs6000_ptrace32 (PT_CONTINUE, PIDGET (inferior_ptid), (int *)1, 0, NULL);
 543
 544   if (ret != 0)
 545     perror ("pt_continue");
 546
 547   do
 548     {
 549       pid = wait (&status);
 550     }
 551   while (pid != PIDGET (inferior_ptid));
 552
 553   write_pc (prev_pc);
 554   target_remove_breakpoint (DUMMY_INSN_ADDR, shadow_contents);
 555 }
 556
 557 /* Fetch registers from the register section in core bfd. */
 558
 559 static void
 560 fetch_core_registers (char *core_reg_sect, unsigned core_reg_size,
 561                       int which, CORE_ADDR reg_addr)
 562 {
 563   CoreRegs *regs;
 564   int regi;
 565   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
 566
 567   if (which != 0)
 568     {
 569       fprintf_unfiltered
 570         (gdb_stderr,
 571          "Gdb error: unknown parameter to fetch_core_registers().\n");
 572       return;
 573     }
 574
 575   regs = (CoreRegs *) core_reg_sect;
 576
 577   /* Put the register values from the core file section in the regcache.  */
 578
 579   if (ARCH64 ())
 580     {
 581       for (regi = 0; regi < 32; regi++)
 582         supply_register (regi, (char *) &regs->r64.gpr[regi]);
 583
 584       for (regi = 0; regi < 32; regi++)
 585         supply_register (FP0_REGNUM + regi, (char *) &regs->r64.fpr[regi]);
 586
 587       supply_register (PC_REGNUM, (char *) &regs->r64.iar);
 588       supply_register (tdep->ppc_ps_regnum, (char *) &regs->r64.msr);
 589       supply_register (tdep->ppc_cr_regnum, (char *) &regs->r64.cr);
 590       supply_register (tdep->ppc_lr_regnum, (char *) &regs->r64.lr);
 591       supply_register (tdep->ppc_ctr_regnum, (char *) &regs->r64.ctr);
 592       supply_register (tdep->ppc_xer_regnum, (char *) &regs->r64.xer);
 593       supply_register (tdep->ppc_fpscr_regnum, (char *) &regs->r64.fpscr);
 594     }
 595   else
 596     {
 597       for (regi = 0; regi < 32; regi++)
 598         supply_register (regi, (char *) &regs->r32.gpr[regi]);
 599
 600       for (regi = 0; regi < 32; regi++)
 601         supply_register (FP0_REGNUM + regi, (char *) &regs->r32.fpr[regi]);
 602
 603       supply_register (PC_REGNUM, (char *) &regs->r32.iar);
 604       supply_register (tdep->ppc_ps_regnum, (char *) &regs->r32.msr);
 605       supply_register (tdep->ppc_cr_regnum, (char *) &regs->r32.cr);
 606       supply_register (tdep->ppc_lr_regnum, (char *) &regs->r32.lr);
 607       supply_register (tdep->ppc_ctr_regnum, (char *) &regs->r32.ctr);
 608       supply_register (tdep->ppc_xer_regnum, (char *) &regs->r32.xer);
 609       supply_register (tdep->ppc_fpscr_regnum, (char *) &regs->r32.fpscr);
 610       if (tdep->ppc_mq_regnum >= 0)
 611         supply_register (tdep->ppc_mq_regnum, (char *) &regs->r32.mq);
 612     }
 613 }
 614 \f
 615
 616 /* Copy information about text and data sections from LDI to VP for a 64-bit
 617    process if ARCH64 and for a 32-bit process otherwise. */
 618
 619 static void
 620 vmap_secs (struct vmap *vp, LdInfo *ldi, int arch64)
 621 {
 622   if (arch64)
 623     {
 624       vp->tstart = (CORE_ADDR) ldi->l64.ldinfo_textorg;
 625       vp->tend = vp->tstart + ldi->l64.ldinfo_textsize;
 626       vp->dstart = (CORE_ADDR) ldi->l64.ldinfo_dataorg;
 627       vp->dend = vp->dstart + ldi->l64.ldinfo_datasize;
 628     }
 629   else
 630     {
 631       vp->tstart = (unsigned long) ldi->l32.ldinfo_textorg;
 632       vp->tend = vp->tstart + ldi->l32.ldinfo_textsize;
 633       vp->dstart = (unsigned long) ldi->l32.ldinfo_dataorg;
 634       vp->dend = vp->dstart + ldi->l32.ldinfo_datasize;
 635     }
 636
 637   /* The run time loader maps the file header in addition to the text
 638      section and returns a pointer to the header in ldinfo_textorg.
 639      Adjust the text start address to point to the real start address
 640      of the text section.  */
 641   vp->tstart += vp->toffs;
 642 }
 643
 644 /* handle symbol translation on vmapping */
 645
 646 static void
 647 vmap_symtab (struct vmap *vp)
 648 {
 649   register struct objfile *objfile;
 650   struct section_offsets *new_offsets;
 651   int i;
 652
 653   objfile = vp->objfile;
 654   if (objfile == NULL)
 655     {
 656       /* OK, it's not an objfile we opened ourselves.
 657          Currently, that can only happen with the exec file, so
 658          relocate the symbols for the symfile.  */
 659       if (symfile_objfile == NULL)
 660         return;
 661       objfile = symfile_objfile;
 662     }
 663   else if (!vp->loaded)
 664     /* If symbols are not yet loaded, offsets are not yet valid. */
 665     return;
 666
 667   new_offsets = (struct section_offsets *) alloca (SIZEOF_SECTION_OFFSETS);
 668
 669   for (i = 0; i < objfile->num_sections; ++i)
 670     new_offsets->offsets[i] = ANOFFSET (objfile->section_offsets, i);
 671
 672   /* The symbols in the object file are linked to the VMA of the section,
 673      relocate them VMA relative.  */
 674   new_offsets->offsets[SECT_OFF_TEXT (objfile)] = vp->tstart - vp->tvma;
 675   new_offsets->offsets[SECT_OFF_DATA (objfile)] = vp->dstart - vp->dvma;
 676   new_offsets->offsets[SECT_OFF_BSS (objfile)] = vp->dstart - vp->dvma;
 677
 678   objfile_relocate (objfile, new_offsets);
 679 }
 680 \f
 681 /* Add symbols for an objfile.  */
 682
 683 static int
 684 objfile_symbol_add (void *arg)
 685 {
 686   struct objfile *obj = (struct objfile *) arg;
 687
 688   syms_from_objfile (obj, NULL, 0, 0);
 689   new_symfile_objfile (obj, 0, 0);
 690   return 1;
 691 }
 692
 693 /* Add symbols for a vmap. Return zero upon error.  */
 694
 695 int
 696 vmap_add_symbols (struct vmap *vp)
 697 {
 698   if (catch_errors (objfile_symbol_add, vp->objfile,
 699                     "Error while reading shared library symbols:\n",
 700                     RETURN_MASK_ALL))
 701     {
 702       /* Note this is only done if symbol reading was successful.  */
 703       vp->loaded = 1;
 704       vmap_symtab (vp);
 705       return 1;
 706     }
 707   return 0;
 708 }
 709
 710 /* Add a new vmap entry based on ldinfo() information.
 711
 712    If ldi->ldinfo_fd is not valid (e.g. this struct ld_info is from a
 713    core file), the caller should set it to -1, and we will open the file.
 714
 715    Return the vmap new entry.  */
 716
 717 static struct vmap *
 718 add_vmap (LdInfo *ldi)
 719 {
 720   bfd *abfd, *last;
 721   register char *mem, *objname, *filename;
 722   struct objfile *obj;
 723   struct vmap *vp;
 724   int fd;
 725   ARCH64_DECL (arch64);
 726
 727   /* This ldi structure was allocated using alloca() in
 728      xcoff_relocate_symtab(). Now we need to have persistent object
 729      and member names, so we should save them. */
 730
 731   filename = LDI_FILENAME (ldi, arch64);
 732   mem = filename + strlen (filename) + 1;
 733   mem = savestring (mem, strlen (mem));
 734   objname = savestring (filename, strlen (filename));
 735
 736   fd = LDI_FD (ldi, arch64);
 737   if (fd < 0)
 738     /* Note that this opens it once for every member; a possible
 739        enhancement would be to only open it once for every object.  */
 740     abfd = bfd_openr (objname, gnutarget);
 741   else
 742     abfd = bfd_fdopenr (objname, gnutarget, fd);
 743   if (!abfd)
 744     {
 745       warning ("Could not open `%s' as an executable file: %s",
 746                objname, bfd_errmsg (bfd_get_error ()));
 747       return NULL;
 748     }
 749
 750   /* make sure we have an object file */
 751
 752   if (bfd_check_format (abfd, bfd_object))
 753     vp = map_vmap (abfd, 0);
 754
 755   else if (bfd_check_format (abfd, bfd_archive))
 756     {
 757       last = 0;
 758       /* FIXME??? am I tossing BFDs?  bfd? */
 759       while ((last = bfd_openr_next_archived_file (abfd, last)))
 760         if (STREQ (mem, last->filename))
 761           break;
 762
 763       if (!last)
 764         {
 765           warning ("\"%s\": member \"%s\" missing.", objname, mem);
 766           bfd_close (abfd);
 767           return NULL;
 768         }
 769
 770       if (!bfd_check_format (last, bfd_object))
 771         {
 772           warning ("\"%s\": member \"%s\" not in executable format: %s.",
 773                    objname, mem, bfd_errmsg (bfd_get_error ()));
 774           bfd_close (last);
 775           bfd_close (abfd);
 776           return NULL;
 777         }
 778
 779       vp = map_vmap (last, abfd);
 780     }
 781   else
 782     {
 783       warning ("\"%s\": not in executable format: %s.",
 784                objname, bfd_errmsg (bfd_get_error ()));
 785       bfd_close (abfd);
 786       return NULL;
 787     }
 788   obj = allocate_objfile (vp->bfd, 0);
 789   vp->objfile = obj;
 790
 791   /* Always add symbols for the main objfile.  */
 792   if (vp == vmap || auto_solib_add)
 793     vmap_add_symbols (vp);
 794   return vp;
 795 }
 796 \f
 797 /* update VMAP info with ldinfo() information
 798    Input is ptr to ldinfo() results.  */
 799
 800 static void
 801 vmap_ldinfo (LdInfo *ldi)
 802 {
 803   struct stat ii, vi;
 804   register struct vmap *vp;
 805   int got_one, retried;
 806   int got_exec_file = 0;
 807   uint next;
 808   int arch64 = ARCH64 ();
 809
 810   /* For each *ldi, see if we have a corresponding *vp.
 811      If so, update the mapping, and symbol table.
 812      If not, add an entry and symbol table.  */
 813
 814   do
 815     {
 816       char *name = LDI_FILENAME (ldi, arch64);
 817       char *memb = name + strlen (name) + 1;
 818       int fd = LDI_FD (ldi, arch64);
 819
 820       retried = 0;
 821
 822       if (fstat (fd, &ii) < 0)
 823         {
 824           /* The kernel sets ld_info to -1, if the process is still using the
 825              object, and the object is removed. Keep the symbol info for the
 826              removed object and issue a warning.  */
 827           warning ("%s (fd=%d) has disappeared, keeping its symbols",
 828                    name, fd);
 829           continue;
 830         }
 831     retry:
 832       for (got_one = 0, vp = vmap; vp; vp = vp->nxt)
 833         {
 834           struct objfile *objfile;
 835
 836           /* First try to find a `vp', which is the same as in ldinfo.
 837              If not the same, just continue and grep the next `vp'. If same,
 838              relocate its tstart, tend, dstart, dend values. If no such `vp'
 839              found, get out of this for loop, add this ldi entry as a new vmap
 840              (add_vmap) and come back, find its `vp' and so on... */
 841
 842           /* The filenames are not always sufficient to match on. */
 843
 844           if ((name[0] == '/' && !STREQ (name, vp->name))
 845               || (memb[0] && !STREQ (memb, vp->member)))
 846             continue;
 847
 848           /* See if we are referring to the same file.
 849              We have to check objfile->obfd, symfile.c:reread_symbols might
 850              have updated the obfd after a change.  */
 851           objfile = vp->objfile == NULL ? symfile_objfile : vp->objfile;
 852           if (objfile == NULL
 853               || objfile->obfd == NULL
 854               || bfd_stat (objfile->obfd, &vi) < 0)
 855             {
 856               warning ("Unable to stat %s, keeping its symbols", name);
 857               continue;
 858             }
 859
 860           if (ii.st_dev != vi.st_dev || ii.st_ino != vi.st_ino)
 861             continue;
 862
 863           if (!retried)
 864             close (fd);
 865
 866           ++got_one;
 867
 868           /* Found a corresponding VMAP.  Remap!  */
 869
 870           vmap_secs (vp, ldi, arch64);
 871
 872           /* The objfile is only NULL for the exec file.  */
 873           if (vp->objfile == NULL)
 874             got_exec_file = 1;
 875
 876           /* relocate symbol table(s). */
 877           vmap_symtab (vp);
 878
 879           /* Announce new object files.  Doing this after symbol relocation
 880              makes aix-thread.c's job easier. */
 881           if (target_new_objfile_hook && vp->objfile)
 882             target_new_objfile_hook (vp->objfile);
 883
 884           /* There may be more, so we don't break out of the loop.  */
 885         }
 886
 887       /* if there was no matching *vp, we must perforce create the sucker(s) */
 888       if (!got_one && !retried)
 889         {
 890           add_vmap (ldi);
 891           ++retried;
 892           goto retry;
 893         }
 894     }
 895   while ((next = LDI_NEXT (ldi, arch64))
 896          && (ldi = (void *) (next + (char *) ldi)));
 897
 898   /* If we don't find the symfile_objfile anywhere in the ldinfo, it
 899      is unlikely that the symbol file is relocated to the proper
 900      address.  And we might have attached to a process which is
 901      running a different copy of the same executable.  */
 902   if (symfile_objfile != NULL && !got_exec_file)
 903     {
 904       warning ("Symbol file %s\nis not mapped; discarding it.\n\
 905 If in fact that file has symbols which the mapped files listed by\n\
 906 \"info files\" lack, you can load symbols with the \"symbol-file\" or\n\
 907 \"add-symbol-file\" commands (note that you must take care of relocating\n\
 908 symbols to the proper address).",
 909                symfile_objfile->name);
 910       free_objfile (symfile_objfile);
 911       symfile_objfile = NULL;
 912     }
 913   breakpoint_re_set ();
 914 }
 915 \f
 916 /* As well as symbol tables, exec_sections need relocation. After
 917    the inferior process' termination, there will be a relocated symbol
 918    table exist with no corresponding inferior process. At that time, we
 919    need to use `exec' bfd, rather than the inferior process's memory space
 920    to look up symbols.
 921
 922    `exec_sections' need to be relocated only once, as long as the exec
 923    file remains unchanged.
 924  */
 925
 926 static void
 927 vmap_exec (void)
 928 {
 929   static bfd *execbfd;
 930   int i;
 931
 932   if (execbfd == exec_bfd)
 933     return;
 934
 935   execbfd = exec_bfd;
 936
 937   if (!vmap || !exec_ops.to_sections)
 938     error ("vmap_exec: vmap or exec_ops.to_sections == 0\n");
 939
 940   for (i = 0; &exec_ops.to_sections[i] < exec_ops.to_sections_end; i++)
 941     {
 942       if (STREQ (".text", exec_ops.to_sections[i].the_bfd_section->name))
 943         {
 944           exec_ops.to_sections[i].addr += vmap->tstart - vmap->tvma;
 945           exec_ops.to_sections[i].endaddr += vmap->tstart - vmap->tvma;
 946         }
 947       else if (STREQ (".data", exec_ops.to_sections[i].the_bfd_section->name))
 948         {
 949           exec_ops.to_sections[i].addr += vmap->dstart - vmap->dvma;
 950           exec_ops.to_sections[i].endaddr += vmap->dstart - vmap->dvma;
 951         }
 952       else if (STREQ (".bss", exec_ops.to_sections[i].the_bfd_section->name))
 953         {
 954           exec_ops.to_sections[i].addr += vmap->dstart - vmap->dvma;
 955           exec_ops.to_sections[i].endaddr += vmap->dstart - vmap->dvma;
 956         }
 957     }
 958 }
 959
 960 /* Set the current architecture from the host running GDB.  Called when
 961    starting a child process. */
 962
 963 static void
 964 set_host_arch (int pid)
 965 {
 966   enum bfd_architecture arch;
 967   unsigned long mach;
 968   bfd abfd;
 969   struct gdbarch_info info;
 970
 971   if (__power_rs ())
 972     {
 973       arch = bfd_arch_rs6000;
 974       mach = bfd_mach_rs6k;
 975     }
 976   else
 977     {
 978       arch = bfd_arch_powerpc;
 979       mach = bfd_mach_ppc;
 980     }
 981
 982   /* FIXME: schauer/2002-02-25:
 983      We don't know if we are executing a 32 or 64 bit executable,
 984      and have no way to pass the proper word size to rs6000_gdbarch_init.
 985      So we have to avoid switching to a new architecture, if the architecture
 986      matches already.
 987      Blindly calling rs6000_gdbarch_init used to work in older versions of
 988      GDB, as rs6000_gdbarch_init incorrectly used the previous tdep to
 989      determine the wordsize.  */
 990   if (exec_bfd)
 991     {
 992       const struct bfd_arch_info *exec_bfd_arch_info;
 993
 994       exec_bfd_arch_info = bfd_get_arch_info (exec_bfd);
 995       if (arch == exec_bfd_arch_info->arch)
 996         return;
 997     }
 998
 999   bfd_default_set_arch_mach (&abfd, arch, mach);
1000
1001   gdbarch_info_init (&info);
1002   info.bfd_arch_info = bfd_get_arch_info (&abfd);
1003
1004   if (!gdbarch_update_p (info))
1005     {
1006       internal_error (__FILE__, __LINE__,
1007                       "set_host_arch: failed to select architecture");
1008     }
1009 }
1010
1011 \f
1012 /* xcoff_relocate_symtab -      hook for symbol table relocation.
1013    also reads shared libraries.. */
1014
1015 void
1016 xcoff_relocate_symtab (unsigned int pid)
1017 {
1018   int load_segs = 64; /* number of load segments */
1019   int rc;
1020   LdInfo *ldi = NULL;
1021   int arch64 = ARCH64 ();
1022   int ldisize = arch64 ? sizeof (ldi->l64) : sizeof (ldi->l32);
1023   int size;
1024
1025   do
1026     {
1027       size = load_segs * ldisize;
1028       ldi = (void *) xrealloc (ldi, size);
1029
1030 #if 0
1031       /* According to my humble theory, AIX has some timing problems and
1032          when the user stack grows, kernel doesn't update stack info in time
1033          and ptrace calls step on user stack. That is why we sleep here a
1034          little, and give kernel to update its internals. */
1035       usleep (36000);
1036 #endif
1037
1038       if (arch64)
1039         rc = rs6000_ptrace64 (PT_LDINFO, pid, (unsigned long) ldi, size, NULL);
1040       else
1041         rc = rs6000_ptrace32 (PT_LDINFO, pid, (int *) ldi, size, NULL);
1042
1043       if (rc == -1)
1044         {
1045           if (errno == ENOMEM)
1046             load_segs *= 2;
1047           else
1048             perror_with_name ("ptrace ldinfo");
1049         }
1050       else
1051         {
1052           vmap_ldinfo (ldi);
1053           vmap_exec (); /* relocate the exec and core sections as well. */
1054         }
1055     } while (rc == -1);
1056   if (ldi)
1057     xfree (ldi);
1058 }
1059 \f
1060 /* Core file stuff.  */
1061
1062 /* Relocate symtabs and read in shared library info, based on symbols
1063    from the core file.  */
1064
1065 void
1066 xcoff_relocate_core (struct target_ops *target)
1067 {
1068   sec_ptr ldinfo_sec;
1069   int offset = 0;
1070   LdInfo *ldi;
1071   struct vmap *vp;
1072   int arch64 = ARCH64 ();
1073
1074   /* Size of a struct ld_info except for the variable-length filename. */
1075   int nonfilesz = (int)LDI_FILENAME ((LdInfo *)0, arch64);
1076
1077   /* Allocated size of buffer.  */
1078   int buffer_size = nonfilesz;
1079   char *buffer = xmalloc (buffer_size);
1080   struct cleanup *old = make_cleanup (free_current_contents, &buffer);
1081
1082   ldinfo_sec = bfd_get_section_by_name (core_bfd, ".ldinfo");
1083   if (ldinfo_sec == NULL)
1084     {
1085     bfd_err:
1086       fprintf_filtered (gdb_stderr, "Couldn't get ldinfo from core file: %s\n",
1087                         bfd_errmsg (bfd_get_error ()));
1088       do_cleanups (old);
1089       return;
1090     }
1091   do
1092     {
1093       int i;
1094       int names_found = 0;
1095
1096       /* Read in everything but the name.  */
1097       if (bfd_get_section_contents (core_bfd, ldinfo_sec, buffer,
1098                                     offset, nonfilesz) == 0)
1099         goto bfd_err;
1100
1101       /* Now the name.  */
1102       i = nonfilesz;
1103       do
1104         {
1105           if (i == buffer_size)
1106             {
1107               buffer_size *= 2;
1108               buffer = xrealloc (buffer, buffer_size);
1109             }
1110           if (bfd_get_section_contents (core_bfd, ldinfo_sec, &buffer[i],
1111                                         offset + i, 1) == 0)
1112             goto bfd_err;
1113           if (buffer[i++] == '\0')
1114             ++names_found;
1115         }
1116       while (names_found < 2);
1117
1118       ldi = (LdInfo *) buffer;
1119
1120       /* Can't use a file descriptor from the core file; need to open it.  */
1121       if (arch64)
1122         ldi->l64.ldinfo_fd = -1;
1123       else
1124         ldi->l32.ldinfo_fd = -1;
1125
1126       /* The first ldinfo is for the exec file, allocated elsewhere.  */
1127       if (offset == 0 && vmap != NULL)
1128         vp = vmap;
1129       else
1130         vp = add_vmap (ldi);
1131
1132       /* Process next shared library upon error. */
1133       offset += LDI_NEXT (ldi, arch64);
1134       if (vp == NULL)
1135         continue;
1136
1137       vmap_secs (vp, ldi, arch64);
1138
1139       /* Unless this is the exec file,
1140          add our sections to the section table for the core target.  */
1141       if (vp != vmap)
1142         {
1143           struct section_table *stp;
1144
1145           target_resize_to_sections (target, 2);
1146           stp = target->to_sections_end - 2;
1147
1148           stp->bfd = vp->bfd;
1149           stp->the_bfd_section = bfd_get_section_by_name (stp->bfd, ".text");
1150           stp->addr = vp->tstart;
1151           stp->endaddr = vp->tend;
1152           stp++;
1153
1154           stp->bfd = vp->bfd;
1155           stp->the_bfd_section = bfd_get_section_by_name (stp->bfd, ".data");
1156           stp->addr = vp->dstart;
1157           stp->endaddr = vp->dend;
1158         }
1159
1160       vmap_symtab (vp);
1161
1162       if (target_new_objfile_hook && vp != vmap && vp->objfile)
1163         target_new_objfile_hook (vp->objfile);
1164     }
1165   while (LDI_NEXT (ldi, arch64) != 0);
1166   vmap_exec ();
1167   breakpoint_re_set ();
1168   do_cleanups (old);
1169 }
1170
1171 int
1172 kernel_u_size (void)
1173 {
1174   return (sizeof (struct user));
1175 }
1176 \f
1177 /* Under AIX, we have to pass the correct TOC pointer to a function
1178    when calling functions in the inferior.
1179    We try to find the relative toc offset of the objfile containing PC
1180    and add the current load address of the data segment from the vmap.  */
1181
1182 static CORE_ADDR
1183 find_toc_address (CORE_ADDR pc)
1184 {
1185   struct vmap *vp;
1186   extern CORE_ADDR get_toc_offset (struct objfile *);   /* xcoffread.c */
1187
1188   for (vp = vmap; vp; vp = vp->nxt)
1189     {
1190       if (pc >= vp->tstart && pc < vp->tend)
1191         {
1192           /* vp->objfile is only NULL for the exec file.  */
1193           return vp->dstart + get_toc_offset (vp->objfile == NULL
1194                                               ? symfile_objfile
1195                                               : vp->objfile);
1196         }
1197     }
1198   error ("Unable to find TOC entry for pc %s\n", local_hex_string (pc));
1199 }
1200 \f
1201 /* Register that we are able to handle rs6000 core file formats. */
1202
1203 static struct core_fns rs6000_core_fns =
1204 {
1205   bfd_target_xcoff_flavour,             /* core_flavour */
1206   default_check_format,                 /* check_format */
1207   default_core_sniffer,                 /* core_sniffer */
1208   fetch_core_registers,                 /* core_read_registers */
1209   NULL                                  /* next */
1210 };
1211
1212 void
1213 _initialize_core_rs6000 (void)
1214 {
1215   /* Initialize hook in rs6000-tdep.c for determining the TOC address when
1216      calling functions in the inferior.  */
1217   rs6000_find_toc_address_hook = find_toc_address;
1218
1219   /* Initialize hook in rs6000-tdep.c to set the current architecture when
1220      starting a child process. */
1221   rs6000_set_host_arch_hook = set_host_arch;
1222
1223   add_core_fns (&rs6000_core_fns);
1224 }