gdb/rs6000-nat.c

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