gdb/rs6000-nat.c

   1 /* IBM RS/6000 native-dependent code for GDB, the GNU debugger.
   2    Copyright 1986, 1987, 1989, 1991, 1992, 1994 Free Software Foundation, Inc.
   3
   4 This file is part of GDB.
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 #include "defs.h"
  21 #include "inferior.h"
  22 #include "target.h"
  23 #include "gdbcore.h"
  24 #include "xcoffsolib.h"
  25 #include "symfile.h"
  26 #include "objfiles.h"
  27 #include "libbfd.h"  /* For bfd_cache_lookup (FIXME) */
  28 #include "bfd.h"
  29
  30 #include <sys/ptrace.h>
  31 #include <sys/reg.h>
  32
  33 #include <sys/param.h>
  34 #include <sys/dir.h>
  35 #include <sys/user.h>
  36 #include <signal.h>
  37 #include <sys/ioctl.h>
  38 #include <fcntl.h>
  39
  40 #include <a.out.h>
  41 #include <sys/file.h>
  42 #include <sys/stat.h>
  43 #include <sys/core.h>
  44 #include <sys/ldr.h>
  45
  46 extern int errno;
  47
  48 extern struct vmap * map_vmap PARAMS ((bfd *bf, bfd *arch));
  49
  50 extern struct target_ops exec_ops;
  51
  52 static void
  53 exec_one_dummy_insn PARAMS ((void));
  54
  55 extern void
  56 add_text_to_loadinfo PARAMS ((CORE_ADDR textaddr, CORE_ADDR dataaddr));
  57
  58 extern void
  59 fixup_breakpoints PARAMS ((CORE_ADDR low, CORE_ADDR high, CORE_ADDR delta));
  60
  61 /* Conversion from gdb-to-system special purpose register numbers.. */
  62
  63 static int special_regs[] = {
  64   IAR,                          /* PC_REGNUM    */
  65   MSR,                          /* PS_REGNUM    */
  66   CR,                           /* CR_REGNUM    */
  67   LR,                           /* LR_REGNUM    */
  68   CTR,                          /* CTR_REGNUM   */
  69   XER,                          /* XER_REGNUM   */
  70   MQ                            /* MQ_REGNUM    */
  71 };
  72
  73 void
  74 fetch_inferior_registers (regno)
  75   int regno;
  76 {
  77   int ii;
  78   extern char registers[];
  79
  80   if (regno < 0) {                      /* for all registers */
  81
  82     /* read 32 general purpose registers. */
  83
  84     for (ii=0; ii < 32; ++ii)
  85       *(int*)&registers[REGISTER_BYTE (ii)] =
  86         ptrace (PT_READ_GPR, inferior_pid, (PTRACE_ARG3_TYPE) ii, 0, 0);
  87
  88     /* read general purpose floating point registers. */
  89
  90     for (ii=0; ii < 32; ++ii)
  91       ptrace (PT_READ_FPR, inferior_pid,
  92               (PTRACE_ARG3_TYPE) &registers [REGISTER_BYTE (FP0_REGNUM+ii)],
  93               FPR0+ii, 0);
  94
  95     /* read special registers. */
  96     for (ii=0; ii <= LAST_SP_REGNUM-FIRST_SP_REGNUM; ++ii)
  97       *(int*)&registers[REGISTER_BYTE (FIRST_SP_REGNUM+ii)] =
  98         ptrace (PT_READ_GPR, inferior_pid, (PTRACE_ARG3_TYPE) special_regs[ii],
  99                 0, 0);
 100
 101     registers_fetched ();
 102     return;
 103   }
 104
 105   /* else an individual register is addressed. */
 106
 107   else if (regno < FP0_REGNUM) {                /* a GPR */
 108     *(int*)&registers[REGISTER_BYTE (regno)] =
 109         ptrace (PT_READ_GPR, inferior_pid, (PTRACE_ARG3_TYPE) regno, 0, 0);
 110   }
 111   else if (regno <= FPLAST_REGNUM) {            /* a FPR */
 112     ptrace (PT_READ_FPR, inferior_pid,
 113             (PTRACE_ARG3_TYPE) &registers [REGISTER_BYTE (regno)],
 114             (regno-FP0_REGNUM+FPR0), 0);
 115   }
 116   else if (regno <= LAST_SP_REGNUM) {           /* a special register */
 117     *(int*)&registers[REGISTER_BYTE (regno)] =
 118         ptrace (PT_READ_GPR, inferior_pid,
 119                 (PTRACE_ARG3_TYPE) special_regs[regno-FIRST_SP_REGNUM], 0, 0);
 120   }
 121   else
 122     fprintf_unfiltered (gdb_stderr, "gdb error: register no %d not implemented.\n", regno);
 123
 124   register_valid [regno] = 1;
 125 }
 126
 127 /* Store our register values back into the inferior.
 128    If REGNO is -1, do this for all registers.
 129    Otherwise, REGNO specifies which register (so we can save time).  */
 130
 131 void
 132 store_inferior_registers (regno)
 133      int regno;
 134 {
 135   extern char registers[];
 136
 137   errno = 0;
 138
 139   if (regno == -1)
 140     {                   /* for all registers..  */
 141       int ii;
 142
 143        /* execute one dummy instruction (which is a breakpoint) in inferior
 144           process. So give kernel a chance to do internal house keeping.
 145           Otherwise the following ptrace(2) calls will mess up user stack
 146           since kernel will get confused about the bottom of the stack (%sp) */
 147
 148        exec_one_dummy_insn ();
 149
 150       /* write general purpose registers first! */
 151       for ( ii=GPR0; ii<=GPR31; ++ii)
 152         {
 153           ptrace (PT_WRITE_GPR, inferior_pid, (PTRACE_ARG3_TYPE) ii,
 154                   *(int*)&registers[REGISTER_BYTE (ii)], 0);
 155           if (errno)
 156             {
 157               perror ("ptrace write_gpr");
 158               errno = 0;
 159             }
 160         }
 161
 162       /* write floating point registers now. */
 163       for ( ii=0; ii < 32; ++ii)
 164         {
 165           ptrace (PT_WRITE_FPR, inferior_pid,
 166                   (PTRACE_ARG3_TYPE) &registers[REGISTER_BYTE (FP0_REGNUM+ii)],
 167                   FPR0+ii, 0);
 168           if (errno)
 169             {
 170               perror ("ptrace write_fpr");
 171               errno = 0;
 172             }
 173         }
 174
 175       /* write special registers. */
 176       for (ii=0; ii <= LAST_SP_REGNUM-FIRST_SP_REGNUM; ++ii)
 177         {
 178           ptrace (PT_WRITE_GPR, inferior_pid,
 179                   (PTRACE_ARG3_TYPE) special_regs[ii],
 180                   *(int*)&registers[REGISTER_BYTE (FIRST_SP_REGNUM+ii)], 0);
 181           if (errno)
 182             {
 183               perror ("ptrace write_gpr");
 184               errno = 0;
 185             }
 186         }
 187     }
 188
 189   /* else, a specific register number is given... */
 190
 191   else if (regno < FP0_REGNUM)                  /* a GPR */
 192     {
 193       ptrace (PT_WRITE_GPR, inferior_pid, (PTRACE_ARG3_TYPE) regno,
 194               *(int*)&registers[REGISTER_BYTE (regno)], 0);
 195     }
 196
 197   else if (regno <= FPLAST_REGNUM)              /* a FPR */
 198     {
 199       ptrace (PT_WRITE_FPR, inferior_pid,
 200               (PTRACE_ARG3_TYPE) &registers[REGISTER_BYTE (regno)],
 201               regno - FP0_REGNUM + FPR0, 0);
 202     }
 203
 204   else if (regno <= LAST_SP_REGNUM)             /* a special register */
 205     {
 206       ptrace (PT_WRITE_GPR, inferior_pid,
 207               (PTRACE_ARG3_TYPE) special_regs [regno-FIRST_SP_REGNUM],
 208               *(int*)&registers[REGISTER_BYTE (regno)], 0);
 209     }
 210
 211   else
 212     fprintf_unfiltered (gdb_stderr, "Gdb error: register no %d not implemented.\n", regno);
 213
 214   if (errno)
 215     {
 216       perror ("ptrace write");
 217       errno = 0;
 218     }
 219 }
 220
 221 /* Execute one dummy breakpoint instruction.  This way we give the kernel
 222    a chance to do some housekeeping and update inferior's internal data,
 223    including u_area. */
 224
 225 static void
 226 exec_one_dummy_insn ()
 227 {
 228 #define DUMMY_INSN_ADDR (TEXT_SEGMENT_BASE)+0x200
 229
 230   char shadow_contents[BREAKPOINT_MAX]; /* Stash old bkpt addr contents */
 231   unsigned int status, pid;
 232
 233   /* We plant one dummy breakpoint into DUMMY_INSN_ADDR address. We assume that
 234      this address will never be executed again by the real code. */
 235
 236   target_insert_breakpoint (DUMMY_INSN_ADDR, shadow_contents);
 237
 238   errno = 0;
 239   ptrace (PT_CONTINUE, inferior_pid, (PTRACE_ARG3_TYPE) DUMMY_INSN_ADDR, 0, 0);
 240   if (errno)
 241     perror ("pt_continue");
 242
 243   do {
 244     pid = wait (&status);
 245   } while (pid != inferior_pid);
 246
 247   target_remove_breakpoint (DUMMY_INSN_ADDR, shadow_contents);
 248 }
 249
 250 void
 251 fetch_core_registers (core_reg_sect, core_reg_size, which, reg_addr)
 252      char *core_reg_sect;
 253      unsigned core_reg_size;
 254      int which;
 255      unsigned int reg_addr;     /* Unused in this version */
 256 {
 257   /* fetch GPRs and special registers from the first register section
 258      in core bfd. */
 259   if (which == 0)
 260     {
 261       /* copy GPRs first. */
 262       memcpy (registers, core_reg_sect, 32 * 4);
 263
 264       /* gdb's internal register template and bfd's register section layout
 265          should share a common include file. FIXMEmgo */
 266       /* then comes special registes. They are supposed to be in the same
 267          order in gdb template and bfd `.reg' section. */
 268       core_reg_sect += (32 * 4);
 269       memcpy (&registers [REGISTER_BYTE (FIRST_SP_REGNUM)], core_reg_sect,
 270               (LAST_SP_REGNUM - FIRST_SP_REGNUM + 1) * 4);
 271     }
 272
 273   /* fetch floating point registers from register section 2 in core bfd. */
 274   else if (which == 2)
 275     memcpy (&registers [REGISTER_BYTE (FP0_REGNUM)], core_reg_sect, 32 * 8);
 276
 277   else
 278     fprintf_unfiltered (gdb_stderr, "Gdb error: unknown parameter to fetch_core_registers().\n");
 279 }
 280 \f
 281 /* handle symbol translation on vmapping */
 282
 283 static void
 284 vmap_symtab (vp)
 285      register struct vmap *vp;
 286 {
 287   register struct objfile *objfile;
 288   asection *textsec;
 289   asection *datasec;
 290   asection *bsssec;
 291   CORE_ADDR text_delta;
 292   CORE_ADDR data_delta;
 293   CORE_ADDR bss_delta;
 294   struct section_offsets *new_offsets;
 295   int i;
 296
 297   objfile = vp->objfile;
 298   if (objfile == NULL)
 299     {
 300       /* OK, it's not an objfile we opened ourselves.
 301          Currently, that can only happen with the exec file, so
 302          relocate the symbols for the symfile.  */
 303       if (symfile_objfile == NULL)
 304         return;
 305       objfile = symfile_objfile;
 306     }
 307
 308   new_offsets = alloca
 309     (sizeof (struct section_offsets)
 310      + sizeof (new_offsets->offsets) * objfile->num_sections);
 311
 312   for (i = 0; i < objfile->num_sections; ++i)
 313     ANOFFSET (new_offsets, i) = ANOFFSET (objfile->section_offsets, i);
 314
 315   textsec = bfd_get_section_by_name (vp->bfd, ".text");
 316   text_delta =
 317     vp->tstart - ANOFFSET (objfile->section_offsets, textsec->target_index);
 318   ANOFFSET (new_offsets, textsec->target_index) = vp->tstart;
 319
 320   datasec = bfd_get_section_by_name (vp->bfd, ".data");
 321   data_delta =
 322     vp->dstart - ANOFFSET (objfile->section_offsets, datasec->target_index);
 323   ANOFFSET (new_offsets, datasec->target_index) = vp->dstart;
 324
 325   bsssec = bfd_get_section_by_name (vp->bfd, ".bss");
 326   bss_delta =
 327     vp->dstart - ANOFFSET (objfile->section_offsets, bsssec->target_index);
 328   ANOFFSET (new_offsets, bsssec->target_index) = vp->dstart;
 329
 330   objfile_relocate (objfile, new_offsets);
 331
 332   {
 333     struct obj_section *s;
 334     for (s = objfile->sections; s < objfile->sections_end; ++s)
 335       {
 336         if (s->the_bfd_section->target_index == textsec->target_index)
 337           {
 338             s->addr += text_delta;
 339             s->endaddr += text_delta;
 340           }
 341         else if (s->the_bfd_section->target_index == datasec->target_index)
 342           {
 343             s->addr += data_delta;
 344             s->endaddr += data_delta;
 345           }
 346         else if (s->the_bfd_section->target_index == bsssec->target_index)
 347           {
 348             s->addr += bss_delta;
 349             s->endaddr += bss_delta;
 350           }
 351       }
 352   }
 353
 354   if (text_delta != 0)
 355     /* breakpoints need to be relocated as well. */
 356     fixup_breakpoints (0, TEXT_SEGMENT_BASE, text_delta);
 357 }
 358 \f
 359 /* Add symbols for an objfile.  */
 360
 361 static int
 362 objfile_symbol_add (arg)
 363      char *arg;
 364 {
 365   struct objfile *obj = (struct objfile *) arg;
 366
 367   syms_from_objfile (obj, 0, 0, 0);
 368   new_symfile_objfile (obj, 0, 0);
 369   return 1;
 370 }
 371
 372 /* Add a new vmap entry based on ldinfo() information.
 373
 374    If ldi->ldinfo_fd is not valid (e.g. this struct ld_info is from a
 375    core file), the caller should set it to -1, and we will open the file.
 376
 377    Return the vmap new entry.  */
 378
 379 static struct vmap *
 380 add_vmap (ldi)
 381      register struct ld_info *ldi;
 382 {
 383   bfd *abfd, *last;
 384   register char *mem, *objname;
 385   struct objfile *obj;
 386   struct vmap *vp;
 387
 388   /* This ldi structure was allocated using alloca() in
 389      xcoff_relocate_symtab(). Now we need to have persistent object
 390      and member names, so we should save them. */
 391
 392   mem = ldi->ldinfo_filename + strlen (ldi->ldinfo_filename) + 1;
 393   mem = savestring (mem, strlen (mem));
 394   objname = savestring (ldi->ldinfo_filename, strlen (ldi->ldinfo_filename));
 395
 396   if (ldi->ldinfo_fd < 0)
 397     /* Note that this opens it once for every member; a possible
 398        enhancement would be to only open it once for every object.  */
 399     abfd = bfd_openr (objname, gnutarget);
 400   else
 401     abfd = bfd_fdopenr (objname, gnutarget, ldi->ldinfo_fd);
 402   if (!abfd)
 403     error ("Could not open `%s' as an executable file: %s",
 404            objname, bfd_errmsg (bfd_get_error ()));
 405
 406   /* make sure we have an object file */
 407
 408   if (bfd_check_format (abfd, bfd_object))
 409     vp = map_vmap (abfd, 0);
 410
 411   else if (bfd_check_format (abfd, bfd_archive))
 412     {
 413       last = 0;
 414       /* FIXME??? am I tossing BFDs?  bfd? */
 415       while ((last = bfd_openr_next_archived_file (abfd, last)))
 416         if (STREQ (mem, last->filename))
 417           break;
 418
 419       if (!last)
 420         {
 421           bfd_close (abfd);
 422           /* FIXME -- should be error */
 423           warning ("\"%s\": member \"%s\" missing.", abfd->filename, mem);
 424           return;
 425         }
 426
 427       if (!bfd_check_format(last, bfd_object))
 428         {
 429           bfd_close (last);     /* XXX???       */
 430           goto obj_err;
 431         }
 432
 433       vp = map_vmap (last, abfd);
 434     }
 435   else
 436     {
 437     obj_err:
 438       bfd_close (abfd);
 439       error ("\"%s\": not in executable format: %s.",
 440              objname, bfd_errmsg (bfd_get_error ()));
 441       /*NOTREACHED*/
 442     }
 443   obj = allocate_objfile (vp->bfd, 0);
 444   vp->objfile = obj;
 445
 446 #ifndef SOLIB_SYMBOLS_MANUAL
 447   if (catch_errors (objfile_symbol_add, (char *)obj,
 448                     "Error while reading shared library symbols:\n",
 449                     RETURN_MASK_ALL))
 450     {
 451       /* Note this is only done if symbol reading was successful.  */
 452       vmap_symtab (vp);
 453       vp->loaded = 1;
 454     }
 455 #endif
 456   return vp;
 457 }
 458 \f
 459 /* update VMAP info with ldinfo() information
 460    Input is ptr to ldinfo() results.  */
 461
 462 static void
 463 vmap_ldinfo (ldi)
 464      register struct ld_info *ldi;
 465 {
 466   struct stat ii, vi;
 467   register struct vmap *vp;
 468   int got_one, retried;
 469   CORE_ADDR ostart;
 470   int got_exec_file;
 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     char *name = ldi->ldinfo_filename;
 478     char *memb = name + strlen(name) + 1;
 479
 480     retried = 0;
 481
 482     if (fstat (ldi->ldinfo_fd, &ii) < 0)
 483       fatal ("cannot fstat(fd=%d) on %s", ldi->ldinfo_fd, name);
 484   retry:
 485     for (got_one = 0, vp = vmap; vp; vp = vp->nxt)
 486       {
 487         FILE *io;
 488
 489         /* First try to find a `vp', which is the same as in ldinfo.
 490            If not the same, just continue and grep the next `vp'. If same,
 491            relocate its tstart, tend, dstart, dend values. If no such `vp'
 492            found, get out of this for loop, add this ldi entry as a new vmap
 493            (add_vmap) and come back, fins its `vp' and so on... */
 494
 495         /* The filenames are not always sufficient to match on. */
 496
 497         if ((name[0] == '/' && !STREQ(name, vp->name))
 498             || (memb[0] && !STREQ(memb, vp->member)))
 499           continue;
 500
 501         io = bfd_cache_lookup (vp->bfd);                /* totally opaque! */
 502         if (!io)
 503           fatal ("cannot find BFD's iostream for %s", vp->name);
 504
 505         /* See if we are referring to the same file. */
 506         /* An error here is innocuous, most likely meaning that
 507            the file descriptor has become worthless. */
 508         if (fstat (fileno(io), &vi) < 0)
 509           continue;
 510
 511         if (ii.st_dev != vi.st_dev || ii.st_ino != vi.st_ino)
 512           continue;
 513
 514         if (!retried)
 515           close (ldi->ldinfo_fd);
 516
 517         ++got_one;
 518
 519         /* found a corresponding VMAP. remap! */
 520         ostart = vp->tstart;
 521
 522         /* We can assume pointer == CORE_ADDR, this code is native only.  */
 523         vp->tstart = (CORE_ADDR) ldi->ldinfo_textorg;
 524         vp->tend   = vp->tstart + ldi->ldinfo_textsize;
 525         vp->dstart = (CORE_ADDR) ldi->ldinfo_dataorg;
 526         vp->dend   = vp->dstart + ldi->ldinfo_datasize;
 527
 528         if (vp->tadj)
 529           {
 530             vp->tstart += vp->tadj;
 531             vp->tend   += vp->tadj;
 532           }
 533
 534         /* The objfile is only NULL for the exec file.  */
 535         if (vp->objfile == NULL)
 536           got_exec_file = 1;
 537
 538         /* relocate symbol table(s). */
 539         vmap_symtab (vp);
 540
 541         /* there may be more, so we don't break out of the loop. */
 542       }
 543
 544     /* if there was no matching *vp, we must perforce create the sucker(s) */
 545     if (!got_one && !retried)
 546       {
 547         add_vmap (ldi);
 548         ++retried;
 549         goto retry;
 550       }
 551   } while (ldi->ldinfo_next
 552            && (ldi = (void *) (ldi->ldinfo_next + (char *) ldi)));
 553
 554   /* If we don't find the symfile_objfile anywhere in the ldinfo, it
 555      is unlikely that the symbol file is relocated to the proper
 556      address.  And we might have attached to a process which is
 557      running a different copy of the same executable.  */
 558   if (symfile_objfile != NULL && !got_exec_file)
 559     {
 560       warning_begin ();
 561       fputs_unfiltered ("Symbol file ", gdb_stderr);
 562       fputs_unfiltered (symfile_objfile->name, gdb_stderr);
 563       fputs_unfiltered ("\nis not mapped; discarding it.\n\
 564 If in fact that file has symbols which the mapped files listed by\n\
 565 \"info files\" lack, you can load symbols with the \"symbol-file\" or\n\
 566 \"add-symbol-file\" commands (note that you must take care of relocating\n\
 567 symbols to the proper address).\n", gdb_stderr);
 568       free_objfile (symfile_objfile);
 569       symfile_objfile = NULL;
 570     }
 571 }
 572 \f
 573 /* As well as symbol tables, exec_sections need relocation. After
 574    the inferior process' termination, there will be a relocated symbol
 575    table exist with no corresponding inferior process. At that time, we
 576    need to use `exec' bfd, rather than the inferior process's memory space
 577    to look up symbols.
 578
 579    `exec_sections' need to be relocated only once, as long as the exec
 580    file remains unchanged.
 581 */
 582
 583 static void
 584 vmap_exec ()
 585 {
 586   static bfd *execbfd;
 587   int i;
 588
 589   if (execbfd == exec_bfd)
 590     return;
 591
 592   execbfd = exec_bfd;
 593
 594   if (!vmap || !exec_ops.to_sections)
 595     error ("vmap_exec: vmap or exec_ops.to_sections == 0\n");
 596
 597   for (i=0; &exec_ops.to_sections[i] < exec_ops.to_sections_end; i++)
 598     {
 599       if (STREQ(".text", exec_ops.to_sections[i].the_bfd_section->name))
 600         {
 601           exec_ops.to_sections[i].addr += vmap->tstart;
 602           exec_ops.to_sections[i].endaddr += vmap->tstart;
 603         }
 604       else if (STREQ(".data", exec_ops.to_sections[i].the_bfd_section->name))
 605         {
 606           exec_ops.to_sections[i].addr += vmap->dstart;
 607           exec_ops.to_sections[i].endaddr += vmap->dstart;
 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), ldi);
 635   if (errno)
 636     perror_with_name ("ptrace ldinfo");
 637
 638   vmap_ldinfo (ldi);
 639
 640   do {
 641     /* We are allowed to assume CORE_ADDR == pointer.  This code is
 642        native only.  */
 643     add_text_to_loadinfo ((CORE_ADDR) ldi->ldinfo_textorg,
 644                           (CORE_ADDR) ldi->ldinfo_dataorg);
 645   } while (ldi->ldinfo_next
 646            && (ldi = (void *) (ldi->ldinfo_next + (char *) ldi)));
 647
 648 #if 0
 649   /* Now that we've jumbled things around, re-sort them.  */
 650   sort_minimal_symbols ();
 651 #endif
 652
 653   /* relocate the exec and core sections as well. */
 654   vmap_exec ();
 655 }
 656 \f
 657 /* Core file stuff.  */
 658
 659 /* Relocate symtabs and read in shared library info, based on symbols
 660    from the core file.  */
 661
 662 void
 663 xcoff_relocate_core (target)
 664      struct target_ops *target;
 665 {
 666 /* Offset of member MEMBER in a struct of type TYPE.  */
 667 #ifndef offsetof
 668 #define offsetof(TYPE, MEMBER) ((int) &((TYPE *)0)->MEMBER)
 669 #endif
 670
 671 /* Size of a struct ld_info except for the variable-length filename.  */
 672 #define LDINFO_SIZE (offsetof (struct ld_info, ldinfo_filename))
 673
 674   sec_ptr ldinfo_sec;
 675   int offset = 0;
 676   struct ld_info *ldip;
 677   struct vmap *vp;
 678
 679   /* Allocated size of buffer.  */
 680   int buffer_size = LDINFO_SIZE;
 681   char *buffer = xmalloc (buffer_size);
 682   struct cleanup *old = make_cleanup (free_current_contents, &buffer);
 683
 684   /* FIXME, this restriction should not exist.  For now, though I'll
 685      avoid coredumps with error() pending a real fix.  */
 686   if (vmap == NULL)
 687     error
 688       ("Can't debug a core file without an executable file (on the RS/6000)");
 689
 690   ldinfo_sec = bfd_get_section_by_name (core_bfd, ".ldinfo");
 691   if (ldinfo_sec == NULL)
 692     {
 693     bfd_err:
 694       fprintf_filtered (gdb_stderr, "Couldn't get ldinfo from core file: %s\n",
 695                         bfd_errmsg (bfd_get_error ()));
 696       do_cleanups (old);
 697       return;
 698     }
 699   do
 700     {
 701       int i;
 702       int names_found = 0;
 703
 704       /* Read in everything but the name.  */
 705       if (bfd_get_section_contents (core_bfd, ldinfo_sec, buffer,
 706                                     offset, LDINFO_SIZE) == 0)
 707         goto bfd_err;
 708
 709       /* Now the name.  */
 710       i = LDINFO_SIZE;
 711       do
 712         {
 713           if (i == buffer_size)
 714             {
 715               buffer_size *= 2;
 716               buffer = xrealloc (buffer, buffer_size);
 717             }
 718           if (bfd_get_section_contents (core_bfd, ldinfo_sec, &buffer[i],
 719                                         offset + i, 1) == 0)
 720             goto bfd_err;
 721           if (buffer[i++] == '\0')
 722             ++names_found;
 723         } while (names_found < 2);
 724
 725       ldip = (struct ld_info *) buffer;
 726
 727       /* Can't use a file descriptor from the core file; need to open it.  */
 728       ldip->ldinfo_fd = -1;
 729
 730       /* The first ldinfo is for the exec file, allocated elsewhere.  */
 731       if (offset == 0)
 732         vp = vmap;
 733       else
 734         vp = add_vmap (ldip);
 735
 736       offset += ldip->ldinfo_next;
 737
 738       /* We can assume pointer == CORE_ADDR, this code is native only.  */
 739       vp->tstart = (CORE_ADDR) ldip->ldinfo_textorg;
 740       vp->tend = vp->tstart + ldip->ldinfo_textsize;
 741       vp->dstart = (CORE_ADDR) ldip->ldinfo_dataorg;
 742       vp->dend = vp->dstart + ldip->ldinfo_datasize;
 743
 744       if (vp->tadj != 0)
 745         {
 746           vp->tstart += vp->tadj;
 747           vp->tend += vp->tadj;
 748         }
 749
 750       /* Unless this is the exec file,
 751          add our sections to the section table for the core target.  */
 752       if (vp != vmap)
 753         {
 754           int count;
 755           struct section_table *stp;
 756
 757           count = target->to_sections_end - target->to_sections;
 758           count += 2;
 759           target->to_sections = (struct section_table *)
 760             xrealloc (target->to_sections,
 761                       sizeof (struct section_table) * count);
 762           target->to_sections_end = target->to_sections + count;
 763           stp = target->to_sections_end - 2;
 764
 765           /* "Why do we add bfd_section_vma?", I hear you cry.
 766              Well, the start of the section in the file is actually
 767              that far into the section as the struct vmap understands it.
 768              So for text sections, bfd_section_vma tends to be 0x200,
 769              and if vp->tstart is 0xd0002000, then the first byte of
 770              the text section on disk corresponds to address 0xd0002200.  */
 771           stp->bfd = vp->bfd;
 772           stp->the_bfd_section = bfd_get_section_by_name (stp->bfd, ".text");
 773           stp->addr = bfd_section_vma (stp->bfd, stp->the_bfd_section) + vp->tstart;
 774           stp->endaddr = bfd_section_vma (stp->bfd, stp->the_bfd_section) + vp->tend;
 775           stp++;
 776
 777           stp->bfd = vp->bfd;
 778           stp->the_bfd_section = bfd_get_section_by_name (stp->bfd, ".data");
 779           stp->addr = bfd_section_vma (stp->bfd, stp->the_bfd_section) + vp->dstart;
 780           stp->endaddr = bfd_section_vma (stp->bfd, stp->the_bfd_section) + vp->dend;
 781         }
 782
 783       vmap_symtab (vp);
 784
 785       add_text_to_loadinfo ((CORE_ADDR)ldip->ldinfo_textorg,
 786                             (CORE_ADDR)ldip->ldinfo_dataorg);
 787     } while (ldip->ldinfo_next != 0);
 788   vmap_exec ();
 789   do_cleanups (old);
 790 }