gdb/rs6000-nat.c

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