gdb/rs6000-nat.c

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