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