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