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