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