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