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