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, Boston, MA 02111-1307, USA.  */
  20
  21 #include "defs.h"
  22 #include "inferior.h"
  23 #include "target.h"
  24 #include "gdbcore.h"
  25 #include "xcoffsolib.h"
  26 #include "symfile.h"
  27 #include "objfiles.h"
  28 #include "libbfd.h"  /* For bfd_cache_lookup (FIXME) */
  29 #include "bfd.h"
  30 #include "gdb-stabs.h"
  31
  32 #include <sys/ptrace.h>
  33 #include <sys/reg.h>
  34
  35 #include <sys/param.h>
  36 #include <sys/dir.h>
  37 #include <sys/user.h>
  38 #include <signal.h>
  39 #include <sys/ioctl.h>
  40 #include <fcntl.h>
  41
  42 #include <a.out.h>
  43 #include <sys/file.h>
  44 #include "gdb_stat.h"
  45 #include <sys/core.h>
  46 #include <sys/ldr.h>
  47
  48 extern int errno;
  49
  50 extern struct vmap * map_vmap PARAMS ((bfd *bf, bfd *arch));
  51
  52 extern struct target_ops exec_ops;
  53
  54 static void
  55 vmap_exec PARAMS ((void));
  56
  57 static void
  58 vmap_ldinfo PARAMS ((struct ld_info *));
  59
  60 static struct vmap *
  61 add_vmap PARAMS ((struct ld_info *));
  62
  63 static int
  64 objfile_symbol_add PARAMS ((char *));
  65
  66 static void
  67 vmap_symtab PARAMS ((struct vmap *));
  68
  69 static void
  70 fetch_core_registers PARAMS ((char *, unsigned int, int, CORE_ADDR));
  71
  72 static void
  73 exec_one_dummy_insn PARAMS ((void));
  74
  75 extern void
  76 fixup_breakpoints PARAMS ((CORE_ADDR low, CORE_ADDR high, CORE_ADDR delta));
  77
  78 /* Conversion from gdb-to-system special purpose register numbers.. */
  79
  80 static int special_regs[] = {
  81   IAR,                          /* PC_REGNUM    */
  82   MSR,                          /* PS_REGNUM    */
  83   CR,                           /* CR_REGNUM    */
  84   LR,                           /* LR_REGNUM    */
  85   CTR,                          /* CTR_REGNUM   */
  86   XER,                          /* XER_REGNUM   */
  87   MQ                            /* MQ_REGNUM    */
  88 };
  89
  90 void
  91 fetch_inferior_registers (regno)
  92   int regno;
  93 {
  94   int ii;
  95   extern char registers[];
  96
  97   if (regno < 0) {                      /* for all registers */
  98
  99     /* read 32 general purpose registers. */
 100
 101     for (ii=0; ii < 32; ++ii)
 102       *(int*)&registers[REGISTER_BYTE (ii)] =
 103         ptrace (PT_READ_GPR, inferior_pid, (PTRACE_ARG3_TYPE) ii, 0, 0);
 104
 105     /* read general purpose floating point registers. */
 106
 107     for (ii=0; ii < 32; ++ii)
 108       ptrace (PT_READ_FPR, inferior_pid,
 109               (PTRACE_ARG3_TYPE) &registers [REGISTER_BYTE (FP0_REGNUM+ii)],
 110               FPR0+ii, 0);
 111
 112     /* read special registers. */
 113     for (ii=0; ii <= LAST_SP_REGNUM-FIRST_SP_REGNUM; ++ii)
 114       *(int*)&registers[REGISTER_BYTE (FIRST_SP_REGNUM+ii)] =
 115         ptrace (PT_READ_GPR, inferior_pid, (PTRACE_ARG3_TYPE) special_regs[ii],
 116                 0, 0);
 117
 118     registers_fetched ();
 119     return;
 120   }
 121
 122   /* else an individual register is addressed. */
 123
 124   else if (regno < FP0_REGNUM) {                /* a GPR */
 125     *(int*)&registers[REGISTER_BYTE (regno)] =
 126         ptrace (PT_READ_GPR, inferior_pid, (PTRACE_ARG3_TYPE) regno, 0, 0);
 127   }
 128   else if (regno <= FPLAST_REGNUM) {            /* a FPR */
 129     ptrace (PT_READ_FPR, inferior_pid,
 130             (PTRACE_ARG3_TYPE) &registers [REGISTER_BYTE (regno)],
 131             (regno-FP0_REGNUM+FPR0), 0);
 132   }
 133   else if (regno <= LAST_SP_REGNUM) {           /* a special register */
 134     *(int*)&registers[REGISTER_BYTE (regno)] =
 135         ptrace (PT_READ_GPR, inferior_pid,
 136                 (PTRACE_ARG3_TYPE) special_regs[regno-FIRST_SP_REGNUM], 0, 0);
 137   }
 138   else
 139     fprintf_unfiltered (gdb_stderr, "gdb error: register no %d not implemented.\n", regno);
 140
 141   register_valid [regno] = 1;
 142 }
 143
 144 /* Store our register values back into the inferior.
 145    If REGNO is -1, do this for all registers.
 146    Otherwise, REGNO specifies which register (so we can save time).  */
 147
 148 void
 149 store_inferior_registers (regno)
 150      int regno;
 151 {
 152   extern char registers[];
 153
 154   errno = 0;
 155
 156   if (regno == -1)
 157     {                   /* for all registers..  */
 158       int ii;
 159
 160        /* execute one dummy instruction (which is a breakpoint) in inferior
 161           process. So give kernel a chance to do internal house keeping.
 162           Otherwise the following ptrace(2) calls will mess up user stack
 163           since kernel will get confused about the bottom of the stack (%sp) */
 164
 165        exec_one_dummy_insn ();
 166
 167       /* write general purpose registers first! */
 168       for ( ii=GPR0; ii<=GPR31; ++ii)
 169         {
 170           ptrace (PT_WRITE_GPR, inferior_pid, (PTRACE_ARG3_TYPE) ii,
 171                   *(int*)&registers[REGISTER_BYTE (ii)], 0);
 172           if (errno)
 173             {
 174               perror ("ptrace write_gpr");
 175               errno = 0;
 176             }
 177         }
 178
 179       /* write floating point registers now. */
 180       for ( ii=0; ii < 32; ++ii)
 181         {
 182           ptrace (PT_WRITE_FPR, inferior_pid,
 183                   (PTRACE_ARG3_TYPE) &registers[REGISTER_BYTE (FP0_REGNUM+ii)],
 184                   FPR0+ii, 0);
 185           if (errno)
 186             {
 187               perror ("ptrace write_fpr");
 188               errno = 0;
 189             }
 190         }
 191
 192       /* write special registers. */
 193       for (ii=0; ii <= LAST_SP_REGNUM-FIRST_SP_REGNUM; ++ii)
 194         {
 195           ptrace (PT_WRITE_GPR, inferior_pid,
 196                   (PTRACE_ARG3_TYPE) special_regs[ii],
 197                   *(int*)&registers[REGISTER_BYTE (FIRST_SP_REGNUM+ii)], 0);
 198           if (errno)
 199             {
 200               perror ("ptrace write_gpr");
 201               errno = 0;
 202             }
 203         }
 204     }
 205
 206   /* else, a specific register number is given... */
 207
 208   else if (regno < FP0_REGNUM)                  /* a GPR */
 209     {
 210       ptrace (PT_WRITE_GPR, inferior_pid, (PTRACE_ARG3_TYPE) regno,
 211               *(int*)&registers[REGISTER_BYTE (regno)], 0);
 212     }
 213
 214   else if (regno <= FPLAST_REGNUM)              /* a FPR */
 215     {
 216       ptrace (PT_WRITE_FPR, inferior_pid,
 217               (PTRACE_ARG3_TYPE) &registers[REGISTER_BYTE (regno)],
 218               regno - FP0_REGNUM + FPR0, 0);
 219     }
 220
 221   else if (regno <= LAST_SP_REGNUM)             /* a special register */
 222     {
 223       ptrace (PT_WRITE_GPR, inferior_pid,
 224               (PTRACE_ARG3_TYPE) special_regs [regno-FIRST_SP_REGNUM],
 225               *(int*)&registers[REGISTER_BYTE (regno)], 0);
 226     }
 227
 228   else
 229     fprintf_unfiltered (gdb_stderr, "Gdb error: register no %d not implemented.\n", regno);
 230
 231   if (errno)
 232     {
 233       perror ("ptrace write");
 234       errno = 0;
 235     }
 236 }
 237
 238 /* Execute one dummy breakpoint instruction.  This way we give the kernel
 239    a chance to do some housekeeping and update inferior's internal data,
 240    including u_area. */
 241
 242 static void
 243 exec_one_dummy_insn ()
 244 {
 245 #define DUMMY_INSN_ADDR (TEXT_SEGMENT_BASE)+0x200
 246
 247   char shadow_contents[BREAKPOINT_MAX]; /* Stash old bkpt addr contents */
 248   int status, pid;
 249   CORE_ADDR prev_pc;
 250
 251   /* We plant one dummy breakpoint into DUMMY_INSN_ADDR address. We assume that
 252      this address will never be executed again by the real code. */
 253
 254   target_insert_breakpoint (DUMMY_INSN_ADDR, shadow_contents);
 255
 256   errno = 0;
 257
 258   /* You might think this could be done with a single ptrace call, and
 259      you'd be correct for just about every platform I've ever worked
 260      on.  However, rs6000-ibm-aix4.1.3 seems to have screwed this up --
 261      the inferior never hits the breakpoint (it's also worth noting
 262      powerpc-ibm-aix4.1.3 works correctly).  */
 263   prev_pc = read_pc ();
 264   write_pc (DUMMY_INSN_ADDR);
 265   ptrace (PT_CONTINUE, inferior_pid, (PTRACE_ARG3_TYPE)1, 0, 0);
 266
 267   if (errno)
 268     perror ("pt_continue");
 269
 270   do {
 271     pid = wait (&status);
 272   } while (pid != inferior_pid);
 273
 274   write_pc (prev_pc);
 275   target_remove_breakpoint (DUMMY_INSN_ADDR, shadow_contents);
 276 }
 277
 278 static void
 279 fetch_core_registers (core_reg_sect, core_reg_size, which, reg_addr)
 280      char *core_reg_sect;
 281      unsigned core_reg_size;
 282      int which;
 283      CORE_ADDR reg_addr;        /* Unused in this version */
 284 {
 285   /* fetch GPRs and special registers from the first register section
 286      in core bfd. */
 287   if (which == 0)
 288     {
 289       /* copy GPRs first. */
 290       memcpy (registers, core_reg_sect, 32 * 4);
 291
 292       /* gdb's internal register template and bfd's register section layout
 293          should share a common include file. FIXMEmgo */
 294       /* then comes special registes. They are supposed to be in the same
 295          order in gdb template and bfd `.reg' section. */
 296       core_reg_sect += (32 * 4);
 297       memcpy (&registers [REGISTER_BYTE (FIRST_SP_REGNUM)], core_reg_sect,
 298               (LAST_SP_REGNUM - FIRST_SP_REGNUM + 1) * 4);
 299     }
 300
 301   /* fetch floating point registers from register section 2 in core bfd. */
 302   else if (which == 2)
 303     memcpy (&registers [REGISTER_BYTE (FP0_REGNUM)], core_reg_sect, 32 * 8);
 304
 305   else
 306     fprintf_unfiltered (gdb_stderr, "Gdb error: unknown parameter to fetch_core_registers().\n");
 307 }
 308 \f
 309 /* handle symbol translation on vmapping */
 310
 311 static void
 312 vmap_symtab (vp)
 313      register struct vmap *vp;
 314 {
 315   register struct objfile *objfile;
 316   struct section_offsets *new_offsets;
 317   int i;
 318
 319   objfile = vp->objfile;
 320   if (objfile == NULL)
 321     {
 322       /* OK, it's not an objfile we opened ourselves.
 323          Currently, that can only happen with the exec file, so
 324          relocate the symbols for the symfile.  */
 325       if (symfile_objfile == NULL)
 326         return;
 327       objfile = symfile_objfile;
 328     }
 329
 330   new_offsets = alloca
 331     (sizeof (struct section_offsets)
 332      + sizeof (new_offsets->offsets) * objfile->num_sections);
 333
 334   for (i = 0; i < objfile->num_sections; ++i)
 335     ANOFFSET (new_offsets, i) = ANOFFSET (objfile->section_offsets, i);
 336
 337   /* The symbols in the object file are linked to the VMA of the section,
 338      relocate them VMA relative.  */
 339   ANOFFSET (new_offsets, SECT_OFF_TEXT) = vp->tstart - vp->tvma;
 340   ANOFFSET (new_offsets, SECT_OFF_DATA) = vp->dstart - vp->dvma;
 341   ANOFFSET (new_offsets, SECT_OFF_BSS) = vp->dstart - vp->dvma;
 342
 343   objfile_relocate (objfile, new_offsets);
 344 }
 345 \f
 346 /* Add symbols for an objfile.  */
 347
 348 static int
 349 objfile_symbol_add (arg)
 350      char *arg;
 351 {
 352   struct objfile *obj = (struct objfile *) arg;
 353
 354   syms_from_objfile (obj, 0, 0, 0);
 355   new_symfile_objfile (obj, 0, 0);
 356   return 1;
 357 }
 358
 359 /* Add a new vmap entry based on ldinfo() information.
 360
 361    If ldi->ldinfo_fd is not valid (e.g. this struct ld_info is from a
 362    core file), the caller should set it to -1, and we will open the file.
 363
 364    Return the vmap new entry.  */
 365
 366 static struct vmap *
 367 add_vmap (ldi)
 368      register struct ld_info *ldi;
 369 {
 370   bfd *abfd, *last;
 371   register char *mem, *objname;
 372   struct objfile *obj;
 373   struct vmap *vp;
 374
 375   /* This ldi structure was allocated using alloca() in
 376      xcoff_relocate_symtab(). Now we need to have persistent object
 377      and member names, so we should save them. */
 378
 379   mem = ldi->ldinfo_filename + strlen (ldi->ldinfo_filename) + 1;
 380   mem = savestring (mem, strlen (mem));
 381   objname = savestring (ldi->ldinfo_filename, strlen (ldi->ldinfo_filename));
 382
 383   if (ldi->ldinfo_fd < 0)
 384     /* Note that this opens it once for every member; a possible
 385        enhancement would be to only open it once for every object.  */
 386     abfd = bfd_openr (objname, gnutarget);
 387   else
 388     abfd = bfd_fdopenr (objname, gnutarget, ldi->ldinfo_fd);
 389   if (!abfd)
 390     error ("Could not open `%s' as an executable file: %s",
 391            objname, bfd_errmsg (bfd_get_error ()));
 392
 393   /* make sure we have an object file */
 394
 395   if (bfd_check_format (abfd, bfd_object))
 396     vp = map_vmap (abfd, 0);
 397
 398   else if (bfd_check_format (abfd, bfd_archive))
 399     {
 400       last = 0;
 401       /* FIXME??? am I tossing BFDs?  bfd? */
 402       while ((last = bfd_openr_next_archived_file (abfd, last)))
 403         if (STREQ (mem, last->filename))
 404           break;
 405
 406       if (!last)
 407         {
 408           bfd_close (abfd);
 409           /* FIXME -- should be error */
 410           warning ("\"%s\": member \"%s\" missing.", abfd->filename, mem);
 411           return 0;
 412         }
 413
 414       if (!bfd_check_format(last, bfd_object))
 415         {
 416           bfd_close (last);     /* XXX???       */
 417           goto obj_err;
 418         }
 419
 420       vp = map_vmap (last, abfd);
 421     }
 422   else
 423     {
 424     obj_err:
 425       bfd_close (abfd);
 426       error ("\"%s\": not in executable format: %s.",
 427              objname, bfd_errmsg (bfd_get_error ()));
 428       /*NOTREACHED*/
 429     }
 430   obj = allocate_objfile (vp->bfd, 0);
 431   vp->objfile = obj;
 432
 433 #ifndef SOLIB_SYMBOLS_MANUAL
 434   if (catch_errors (objfile_symbol_add, (char *)obj,
 435                     "Error while reading shared library symbols:\n",
 436                     RETURN_MASK_ALL))
 437     {
 438       /* Note this is only done if symbol reading was successful.  */
 439       vmap_symtab (vp);
 440       vp->loaded = 1;
 441     }
 442 #endif
 443   return vp;
 444 }
 445 \f
 446 /* update VMAP info with ldinfo() information
 447    Input is ptr to ldinfo() results.  */
 448
 449 static void
 450 vmap_ldinfo (ldi)
 451      register struct ld_info *ldi;
 452 {
 453   struct stat ii, vi;
 454   register struct vmap *vp;
 455   int got_one, retried;
 456   int got_exec_file = 0;
 457
 458   /* For each *ldi, see if we have a corresponding *vp.
 459      If so, update the mapping, and symbol table.
 460      If not, add an entry and symbol table.  */
 461
 462   do {
 463     char *name = ldi->ldinfo_filename;
 464     char *memb = name + strlen(name) + 1;
 465
 466     retried = 0;
 467
 468     if (fstat (ldi->ldinfo_fd, &ii) < 0)
 469       {
 470         /* The kernel sets ld_info to -1, if the process is still using the
 471            object, and the object is removed. Keep the symbol info for the
 472            removed object and issue a warning.  */
 473         warning ("%s (fd=%d) has disappeared, keeping its symbols",
 474                  name, ldi->ldinfo_fd);
 475         continue;
 476       }
 477   retry:
 478     for (got_one = 0, vp = vmap; vp; vp = vp->nxt)
 479       {
 480         struct objfile *objfile;
 481
 482         /* First try to find a `vp', which is the same as in ldinfo.
 483            If not the same, just continue and grep the next `vp'. If same,
 484            relocate its tstart, tend, dstart, dend values. If no such `vp'
 485            found, get out of this for loop, add this ldi entry as a new vmap
 486            (add_vmap) and come back, find its `vp' and so on... */
 487
 488         /* The filenames are not always sufficient to match on. */
 489
 490         if ((name[0] == '/' && !STREQ(name, vp->name))
 491             || (memb[0] && !STREQ(memb, vp->member)))
 492           continue;
 493
 494         /* See if we are referring to the same file.
 495            We have to check objfile->obfd, symfile.c:reread_symbols might
 496            have updated the obfd after a change.  */
 497         objfile = vp->objfile == NULL ? symfile_objfile : vp->objfile;
 498         if (objfile == NULL
 499             || objfile->obfd == NULL
 500             || bfd_stat (objfile->obfd, &vi) < 0)
 501           {
 502             warning ("Unable to stat %s, keeping its symbols", name);
 503             continue;
 504           }
 505
 506         if (ii.st_dev != vi.st_dev || ii.st_ino != vi.st_ino)
 507           continue;
 508
 509         if (!retried)
 510           close (ldi->ldinfo_fd);
 511
 512         ++got_one;
 513
 514         /* Found a corresponding VMAP.  Remap!  */
 515
 516         /* We can assume pointer == CORE_ADDR, this code is native only.  */
 517         vp->tstart = (CORE_ADDR) ldi->ldinfo_textorg;
 518         vp->tend   = vp->tstart + ldi->ldinfo_textsize;
 519         vp->dstart = (CORE_ADDR) ldi->ldinfo_dataorg;
 520         vp->dend   = vp->dstart + ldi->ldinfo_datasize;
 521
 522         /* The run time loader maps the file header in addition to the text
 523            section and returns a pointer to the header in ldinfo_textorg.
 524            Adjust the text start address to point to the real start address
 525            of the text section.  */
 526         vp->tstart += vp->toffs;
 527
 528         /* The objfile is only NULL for the exec file.  */
 529         if (vp->objfile == NULL)
 530           got_exec_file = 1;
 531
 532         /* relocate symbol table(s). */
 533         vmap_symtab (vp);
 534
 535         /* There may be more, so we don't break out of the loop.  */
 536       }
 537
 538     /* if there was no matching *vp, we must perforce create the sucker(s) */
 539     if (!got_one && !retried)
 540       {
 541         add_vmap (ldi);
 542         ++retried;
 543         goto retry;
 544       }
 545   } while (ldi->ldinfo_next
 546            && (ldi = (void *) (ldi->ldinfo_next + (char *) ldi)));
 547
 548   /* If we don't find the symfile_objfile anywhere in the ldinfo, it
 549      is unlikely that the symbol file is relocated to the proper
 550      address.  And we might have attached to a process which is
 551      running a different copy of the same executable.  */
 552   if (symfile_objfile != NULL && !got_exec_file)
 553     {
 554       warning_begin ();
 555       fputs_unfiltered ("Symbol file ", gdb_stderr);
 556       fputs_unfiltered (symfile_objfile->name, gdb_stderr);
 557       fputs_unfiltered ("\nis not mapped; discarding it.\n\
 558 If in fact that file has symbols which the mapped files listed by\n\
 559 \"info files\" lack, you can load symbols with the \"symbol-file\" or\n\
 560 \"add-symbol-file\" commands (note that you must take care of relocating\n\
 561 symbols to the proper address).\n", gdb_stderr);
 562       free_objfile (symfile_objfile);
 563       symfile_objfile = NULL;
 564     }
 565   breakpoint_re_set ();
 566 }
 567 \f
 568 /* As well as symbol tables, exec_sections need relocation. After
 569    the inferior process' termination, there will be a relocated symbol
 570    table exist with no corresponding inferior process. At that time, we
 571    need to use `exec' bfd, rather than the inferior process's memory space
 572    to look up symbols.
 573
 574    `exec_sections' need to be relocated only once, as long as the exec
 575    file remains unchanged.
 576 */
 577
 578 static void
 579 vmap_exec ()
 580 {
 581   static bfd *execbfd;
 582   int i;
 583
 584   if (execbfd == exec_bfd)
 585     return;
 586
 587   execbfd = exec_bfd;
 588
 589   if (!vmap || !exec_ops.to_sections)
 590     error ("vmap_exec: vmap or exec_ops.to_sections == 0\n");
 591
 592   for (i=0; &exec_ops.to_sections[i] < exec_ops.to_sections_end; i++)
 593     {
 594       if (STREQ(".text", exec_ops.to_sections[i].the_bfd_section->name))
 595         {
 596           exec_ops.to_sections[i].addr += vmap->tstart - vmap->tvma;
 597           exec_ops.to_sections[i].endaddr += vmap->tstart - vmap->tvma;
 598         }
 599       else if (STREQ(".data", exec_ops.to_sections[i].the_bfd_section->name))
 600         {
 601           exec_ops.to_sections[i].addr += vmap->dstart - vmap->dvma;
 602           exec_ops.to_sections[i].endaddr += vmap->dstart - vmap->dvma;
 603         }
 604       else if (STREQ(".bss", exec_ops.to_sections[i].the_bfd_section->name))
 605         {
 606           exec_ops.to_sections[i].addr += vmap->dstart - vmap->dvma;
 607           exec_ops.to_sections[i].endaddr += vmap->dstart - vmap->dvma;
 608         }
 609     }
 610 }
 611 \f
 612 /* xcoff_relocate_symtab -      hook for symbol table relocation.
 613    also reads shared libraries.. */
 614
 615 void
 616 xcoff_relocate_symtab (pid)
 617      unsigned int pid;
 618 {
 619 #define MAX_LOAD_SEGS 64                /* maximum number of load segments */
 620
 621   struct ld_info *ldi;
 622
 623   ldi = (void *) alloca(MAX_LOAD_SEGS * sizeof (*ldi));
 624
 625   /* According to my humble theory, AIX has some timing problems and
 626      when the user stack grows, kernel doesn't update stack info in time
 627      and ptrace calls step on user stack. That is why we sleep here a little,
 628      and give kernel to update its internals. */
 629
 630   usleep (36000);
 631
 632   errno = 0;
 633   ptrace (PT_LDINFO, pid, (PTRACE_ARG3_TYPE) ldi,
 634           MAX_LOAD_SEGS * sizeof(*ldi), (int *) ldi);
 635   if (errno)
 636     perror_with_name ("ptrace ldinfo");
 637
 638   vmap_ldinfo (ldi);
 639
 640   /* relocate the exec and core sections as well. */
 641   vmap_exec ();
 642 }
 643 \f
 644 /* Core file stuff.  */
 645
 646 /* Relocate symtabs and read in shared library info, based on symbols
 647    from the core file.  */
 648
 649 void
 650 xcoff_relocate_core (target)
 651      struct target_ops *target;
 652 {
 653 /* Offset of member MEMBER in a struct of type TYPE.  */
 654 #ifndef offsetof
 655 #define offsetof(TYPE, MEMBER) ((int) &((TYPE *)0)->MEMBER)
 656 #endif
 657
 658 /* Size of a struct ld_info except for the variable-length filename.  */
 659 #define LDINFO_SIZE (offsetof (struct ld_info, ldinfo_filename))
 660
 661   sec_ptr ldinfo_sec;
 662   int offset = 0;
 663   struct ld_info *ldip;
 664   struct vmap *vp;
 665
 666   /* Allocated size of buffer.  */
 667   int buffer_size = LDINFO_SIZE;
 668   char *buffer = xmalloc (buffer_size);
 669   struct cleanup *old = make_cleanup (free_current_contents, &buffer);
 670
 671   /* FIXME, this restriction should not exist.  For now, though I'll
 672      avoid coredumps with error() pending a real fix.  */
 673   if (vmap == NULL)
 674     error
 675       ("Can't debug a core file without an executable file (on the RS/6000)");
 676
 677   ldinfo_sec = bfd_get_section_by_name (core_bfd, ".ldinfo");
 678   if (ldinfo_sec == NULL)
 679     {
 680     bfd_err:
 681       fprintf_filtered (gdb_stderr, "Couldn't get ldinfo from core file: %s\n",
 682                         bfd_errmsg (bfd_get_error ()));
 683       do_cleanups (old);
 684       return;
 685     }
 686   do
 687     {
 688       int i;
 689       int names_found = 0;
 690
 691       /* Read in everything but the name.  */
 692       if (bfd_get_section_contents (core_bfd, ldinfo_sec, buffer,
 693                                     offset, LDINFO_SIZE) == 0)
 694         goto bfd_err;
 695
 696       /* Now the name.  */
 697       i = LDINFO_SIZE;
 698       do
 699         {
 700           if (i == buffer_size)
 701             {
 702               buffer_size *= 2;
 703               buffer = xrealloc (buffer, buffer_size);
 704             }
 705           if (bfd_get_section_contents (core_bfd, ldinfo_sec, &buffer[i],
 706                                         offset + i, 1) == 0)
 707             goto bfd_err;
 708           if (buffer[i++] == '\0')
 709             ++names_found;
 710         } while (names_found < 2);
 711
 712       ldip = (struct ld_info *) buffer;
 713
 714       /* Can't use a file descriptor from the core file; need to open it.  */
 715       ldip->ldinfo_fd = -1;
 716
 717       /* The first ldinfo is for the exec file, allocated elsewhere.  */
 718       if (offset == 0)
 719         vp = vmap;
 720       else
 721         vp = add_vmap (ldip);
 722
 723       offset += ldip->ldinfo_next;
 724
 725       /* We can assume pointer == CORE_ADDR, this code is native only.  */
 726       vp->tstart = (CORE_ADDR) ldip->ldinfo_textorg;
 727       vp->tend = vp->tstart + ldip->ldinfo_textsize;
 728       vp->dstart = (CORE_ADDR) ldip->ldinfo_dataorg;
 729       vp->dend = vp->dstart + ldip->ldinfo_datasize;
 730
 731       /* The run time loader maps the file header in addition to the text
 732          section and returns a pointer to the header in ldinfo_textorg.
 733          Adjust the text start address to point to the real start address
 734          of the text section.  */
 735       vp->tstart += vp->toffs;
 736
 737       /* Unless this is the exec file,
 738          add our sections to the section table for the core target.  */
 739       if (vp != vmap)
 740         {
 741           int count;
 742           struct section_table *stp;
 743           int update_coreops;
 744
 745           /* We must update the to_sections field in the core_ops structure
 746              now to avoid dangling pointer dereferences.  */
 747           update_coreops = core_ops.to_sections == target->to_sections;
 748
 749           count = target->to_sections_end - target->to_sections;
 750           count += 2;
 751           target->to_sections = (struct section_table *)
 752             xrealloc (target->to_sections,
 753                       sizeof (struct section_table) * count);
 754           target->to_sections_end = target->to_sections + count;
 755
 756           /* Update the to_sections field in the core_ops structure
 757              if needed.  */
 758           if (update_coreops)
 759             {
 760               core_ops.to_sections = target->to_sections;
 761               core_ops.to_sections_end = target->to_sections_end;
 762             }
 763           stp = target->to_sections_end - 2;
 764
 765           stp->bfd = vp->bfd;
 766           stp->the_bfd_section = bfd_get_section_by_name (stp->bfd, ".text");
 767           stp->addr = vp->tstart;
 768           stp->endaddr = vp->tend;
 769           stp++;
 770
 771           stp->bfd = vp->bfd;
 772           stp->the_bfd_section = bfd_get_section_by_name (stp->bfd, ".data");
 773           stp->addr = vp->dstart;
 774           stp->endaddr = vp->dend;
 775         }
 776
 777       vmap_symtab (vp);
 778     } while (ldip->ldinfo_next != 0);
 779   vmap_exec ();
 780   breakpoint_re_set ();
 781   do_cleanups (old);
 782 }
 783
 784 int
 785 kernel_u_size ()
 786 {
 787   return (sizeof (struct user));
 788 }
 789 \f
 790 /* Under AIX, we have to pass the correct TOC pointer to a function
 791    when calling functions in the inferior.
 792    We try to find the relative toc offset of the objfile containing PC
 793    and add the current load address of the data segment from the vmap.  */
 794
 795 static CORE_ADDR
 796 find_toc_address (pc)
 797      CORE_ADDR pc;
 798 {
 799   struct vmap *vp;
 800
 801   for (vp = vmap; vp; vp = vp->nxt)
 802     {
 803       if (pc >= vp->tstart && pc < vp->tend)
 804         {
 805           /* vp->objfile is only NULL for the exec file.  */
 806           return vp->dstart + get_toc_offset (vp->objfile == NULL
 807                                               ? symfile_objfile
 808                                               : vp->objfile);
 809         }
 810     }
 811   error ("Unable to find TOC entry for pc 0x%x\n", pc);
 812 }
 813 \f
 814 /* Register that we are able to handle rs6000 core file formats. */
 815
 816 static struct core_fns rs6000_core_fns =
 817 {
 818   bfd_target_coff_flavour,
 819   fetch_core_registers,
 820   NULL
 821 };
 822
 823 void
 824 _initialize_core_rs6000 ()
 825 {
 826   /* Initialize hook in rs6000-tdep.c for determining the TOC address when
 827      calling functions in the inferior.  */
 828   find_toc_address_hook = &find_toc_address;
 829
 830   /* For native configurations, where this module is included, inform
 831      the xcoffsolib module where it can find the function for symbol table
 832      relocation at runtime. */
 833   xcoff_relocate_symtab_hook = &xcoff_relocate_symtab;
 834   add_core_fns (&rs6000_core_fns);
 835 }