gdb/xcoffexec.c

   1 /* Execute AIXcoff files, for GDB.
   2    Copyright 1988, 1989, 1991, 1992 Free Software Foundation, Inc.
   3    Derived from exec.c.  Modified by IBM Corporation.
   4    Donated by IBM Corporation and Cygnus Support.
   5
   6 This file is part of GDB.
   7
   8 This program is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2 of the License, or
  11 (at your option) any later version.
  12
  13 This program is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with this program; if not, write to the Free Software
  20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  21
  22 /* xcoff-exec - deal with executing XCOFF files.  */
  23
  24 #include "defs.h"
  25
  26 #include <sys/types.h>
  27 #include <sys/param.h>
  28 #include <fcntl.h>
  29 #include <string.h>
  30 #include <ctype.h>
  31 #include <sys/stat.h>
  32 #include <sys/ldr.h>
  33
  34 #include "frame.h"
  35 #include "inferior.h"
  36 #include "target.h"
  37 #include "gdbcmd.h"
  38 #include "gdbcore.h"
  39 #include "symfile.h"
  40 #include "objfiles.h"
  41
  42 #include "libbfd.h"             /* BFD internals (sigh!)  FIXME */
  43 #include "xcoffsolib.h"
  44
  45 /* Prototypes for local functions */
  46
  47 static void
  48 file_command PARAMS ((char *, int));
  49
  50 static void
  51 exec_close PARAMS ((int));
  52
  53 struct section_table *exec_sections, *exec_sections_end;
  54
  55 /* Whether to open exec and core files read-only or read-write.  */
  56
  57 int write_files = 0;
  58
  59 extern int info_verbose;
  60
  61 bfd *exec_bfd;                  /* needed by core.c     */
  62
  63 extern char *getenv();
  64 extern void add_syms_addr_command ();
  65 extern void symbol_file_command ();
  66 static void exec_files_info();
  67 extern struct objfile *lookup_objfile_bfd ();
  68
  69 #if 0
  70 /*
  71  * the vmap struct is used to describe the virtual address space of
  72  * the target we are manipulating.  The first entry is always the "exec"
  73  * file.  Subsequent entries correspond to other objects that are
  74  * mapped into the address space of a process created from the "exec" file.
  75  * These are either in response to exec()ing the file, in which case all
  76  * shared libraries are loaded, or a "load" system call, followed by the
  77  * user's issuance of a "load" command.
  78  */
  79 struct vmap {
  80         struct vmap *nxt;       /* ^ to next in chain                   */
  81         bfd *bfd;               /* BFD for mappable object library      */
  82         char *name;             /* ^ to object file name                */
  83         char *member;           /* ^ to member name                     */
  84         CORE_ADDR tstart;       /* virtual addr where member is mapped  */
  85         CORE_ADDR tend;         /* virtual upper bound of member        */
  86         CORE_ADDR tadj;         /* heuristically derived adjustment     */
  87         CORE_ADDR dstart;       /* virtual address of data start        */
  88         CORE_ADDR dend;         /* vitrual address of data end          */
  89 };
  90
  91
  92 struct vmap_and_bfd {
  93   bfd *pbfd;
  94   struct vmap *pvmap;
  95 };
  96
  97 static struct vmap *vmap;       /* current vmap                         */
  98 #endif /* 0 */
  99
 100 struct vmap *vmap;              /* current vmap */
 101
 102 extern struct target_ops exec_ops;
 103
 104
 105 /* exec_close - done with exec file, clean up all resources. */
 106
 107 static void
 108 exec_close(quitting)
 109 {
 110   register struct vmap *vp, *nxt;
 111   struct objfile *obj;
 112
 113   for (nxt = vmap; vp = nxt; )
 114     {
 115       nxt = vp->nxt;
 116
 117       /* if there is an objfile associated with this bfd,
 118          free_objfile() will do proper cleanup of objfile *and* bfd. */
 119
 120       if (obj = lookup_objfile_bfd (vp->bfd))
 121         free_objfile (obj);
 122       else
 123         bfd_close(vp->bfd);
 124
 125       free_named_symtabs(vp->name);
 126       free(vp);
 127     }
 128
 129   vmap = 0;
 130
 131   if (exec_bfd) {
 132     bfd_close (exec_bfd);
 133     exec_bfd = NULL;
 134   }
 135   if (exec_ops.to_sections) {
 136     free (exec_ops.to_sections);
 137     exec_ops.to_sections = NULL;
 138     exec_ops.to_sections_end = NULL;
 139   }
 140 }
 141
 142 /*
 143  * exec_file_command -  handle the "exec" command, &c.
 144  */
 145 void
 146 exec_file_command(filename, from_tty)
 147 char *filename;
 148 {
 149   target_preopen(from_tty);
 150
 151   /* Remove any previous exec file.  */
 152   unpush_target(&exec_ops);
 153
 154   /* Now open and digest the file the user requested, if any. */
 155
 156   if (filename) {
 157         char *scratch_pathname;
 158         int scratch_chan;
 159
 160         filename = tilde_expand(filename);
 161         make_cleanup (free, filename);
 162
 163         scratch_chan = openp(getenv("PATH"), 1, filename,
 164                              write_files? O_RDWR: O_RDONLY, 0,
 165                              &scratch_pathname);
 166         if (scratch_chan < 0)
 167           perror_with_name(filename);
 168
 169         exec_bfd = bfd_fdopenr(scratch_pathname, NULL, scratch_chan);
 170         if (!exec_bfd)
 171           error("Could not open `%s' as an executable file: %s"
 172                       , scratch_pathname, bfd_errmsg(bfd_error));
 173
 174         /* make sure we have an object file */
 175
 176         if (!bfd_check_format(exec_bfd, bfd_object))
 177                 error("\"%s\": not in executable format: %s.",
 178                       scratch_pathname, bfd_errmsg(bfd_error));
 179
 180
 181         /* setup initial vmap */
 182
 183         map_vmap (exec_bfd, 0);
 184         if (!vmap)
 185                 error("Can't find the file sections in `%s': %s",
 186                       exec_bfd->filename, bfd_errmsg(bfd_error));
 187
 188         if (build_section_table (exec_bfd, &exec_ops.to_sections,
 189                                 &exec_ops.to_sections_end))
 190           error ("Can't find the file sections in `%s': %s",
 191                 exec_bfd->filename, bfd_errmsg (bfd_error));
 192
 193         /* make sure core, if present, matches */
 194         validate_files();
 195
 196         push_target(&exec_ops);
 197
 198         /* Tell display code(if any) about the changed file name. */
 199
 200         if (exec_file_display_hook)
 201                 (*exec_file_display_hook)(filename);
 202   }
 203   else {
 204         exec_close(0);  /* just in case */
 205         if (from_tty)
 206           printf("No exec file now.\n");
 207   }
 208 }
 209
 210 /* Set both the exec file and the symbol file, in one command.  What a
 211  * novelty.  Why did GDB go through four major releases before this
 212  * command was added?
 213  */
 214 static void
 215 file_command(arg, from_tty)
 216 char *arg; {
 217
 218         exec_file_command(arg, from_tty);
 219         symbol_file_command(arg, from_tty);
 220 }
 221
 222 /* Locate all mappable sections of a BFD file.
 223    table_pp_char is a char * to get it through bfd_map_over_sections;
 224    we cast it back to its proper type.  */
 225
 226 static void
 227 add_to_section_table (abfd, asect, table_pp_char)
 228      bfd *abfd;
 229      sec_ptr asect;
 230      char *table_pp_char;
 231 {
 232   struct section_table **table_pp = (struct section_table **)table_pp_char;
 233   flagword aflag;
 234
 235   aflag = bfd_get_section_flags (abfd, asect);
 236   /* FIXME, we need to handle BSS segment here...it alloc's but doesn't load */
 237   if (!(aflag & SEC_LOAD))
 238     return;
 239   if (0 == bfd_section_size (abfd, asect))
 240     return;
 241   (*table_pp)->bfd = abfd;
 242   (*table_pp)->sec_ptr = asect;
 243   (*table_pp)->addr = bfd_section_vma (abfd, asect);
 244   (*table_pp)->endaddr = (*table_pp)->addr + bfd_section_size (abfd, asect);
 245   (*table_pp)++;
 246 }
 247
 248 int
 249 build_section_table (some_bfd, start, end)
 250      bfd *some_bfd;
 251      struct section_table **start, **end;
 252 {
 253   unsigned count;
 254
 255   count = bfd_count_sections (some_bfd);
 256   if (count == 0)
 257     abort();    /* return 1? */
 258   if (*start)
 259     free (*start);
 260   *start = (struct section_table *) xmalloc (count * sizeof (**start));
 261   *end = *start;
 262   bfd_map_over_sections (some_bfd, add_to_section_table, (char *)end);
 263   if (*end > *start + count)
 264     abort();
 265   /* We could realloc the table, but it probably loses for most files.  */
 266   return 0;
 267 }
 268
 269 /*
 270  * lookup_symtab_bfd -  find if we currently have any symbol tables from bfd
 271  */
 272 struct objfile *
 273 lookup_objfile_bfd(bfd *bfd) {
 274         register struct objfile *s;
 275
 276         for (s = object_files; s; s = s->next)
 277                 if (s->obfd == bfd)
 278                         return s;
 279         return 0;
 280 }
 281
 282
 283 void
 284 sex_to_vmap(bfd *bf, sec_ptr sex, struct vmap_and_bfd *vmap_bfd)
 285 {
 286   register struct vmap *vp, **vpp;
 287   register struct symtab *syms;
 288   bfd *arch = vmap_bfd->pbfd;
 289   vp = vmap_bfd->pvmap;
 290
 291   if ((bfd_get_section_flags(bf, sex) & SEC_LOAD) == 0)
 292     return;
 293
 294   if (STREQ(bfd_section_name(bf, sex), ".text")) {
 295     vp->tstart = 0;
 296     vp->tend   = vp->tstart + bfd_section_size(bf, sex);
 297
 298     /* When it comes to this adjustment value, in contrast to our previous
 299        belief shared objects should behave the same as the main load segment.
 300        This is the offset from the beginning of text section to the first
 301        real instruction. */
 302
 303     vp->tadj = sex->filepos - bfd_section_vma(bf, sex);
 304   }
 305
 306   else if (STREQ(bfd_section_name(bf, sex), ".data")) {
 307     vp->dstart = 0;
 308     vp->dend   = vp->dstart + bfd_section_size(bf, sex);
 309   }
 310
 311   else if (STREQ(bfd_section_name(bf, sex), ".bss"))    /* FIXMEmgo */
 312     printf ("bss section in exec! Don't know what the heck to do!\n");
 313 }
 314
 315 /* Make a vmap for the BFD "bf", which might be a member of the archive
 316    BFD "arch".  If we have not yet read in symbols for this file, do so.  */
 317
 318 map_vmap (bfd *bf, bfd *arch)
 319 {
 320   struct vmap_and_bfd vmap_bfd;
 321   struct vmap *vp, **vpp;
 322   struct objfile *obj;
 323
 324   vp = (void*) xmalloc (sizeof (*vp));
 325   bzero (vp, sizeof (*vp));
 326   vp->nxt = 0;
 327   vp->bfd = bf;
 328   vp->name = bfd_get_filename(arch ? arch : bf);
 329   vp->member = arch ? bfd_get_filename(bf) : "";
 330
 331   vmap_bfd.pbfd = arch;
 332   vmap_bfd.pvmap = vp;
 333   bfd_map_over_sections (bf, sex_to_vmap, &vmap_bfd);
 334
 335 #if 0
 336   /* This is only needed if we want to load shared libraries no matter what.
 337      Since we provide the choice of incremental loading of shared objects
 338      now, we do not have to load them as default anymore. */
 339
 340   obj = lookup_objfile_bfd (bf);
 341   if (exec_bfd && !obj) {
 342     obj = allocate_objfile (bf, 0);
 343
 344     syms_from_objfile (obj, 0, 0, 0);
 345     new_symfile_objfile (obj, 0, 0);
 346   }
 347 #endif
 348
 349   /* find the end of the list, and append. */
 350   for (vpp = &vmap; *vpp; vpp = &(*vpp)->nxt)
 351   ;
 352   *vpp = vp;
 353 }
 354
 355
 356 /* true, if symbol table and minimal symbol table are relocated. */
 357
 358 int symtab_relocated = 0;
 359
 360
 361 /*  vmap_symtab -       handle symbol translation on vmapping */
 362
 363 vmap_symtab(vp, old_start, vip)
 364 register struct vmap *vp;
 365 CORE_ADDR old_start;
 366 struct stat *vip;
 367 {
 368   register struct symtab *s;
 369   register struct objfile *objfile;
 370   register struct minimal_symbol *msymbol;
 371
 372   /*
 373    * for each symbol table generated from the vp->bfd
 374    */
 375   ALL_OBJFILES (objfile)
 376     {
 377       for (s = objfile -> symtabs; s != NULL; s = s -> next) {
 378
 379         /* skip over if this is not relocatable and doesn't have a line table */
 380         if (s->nonreloc && !LINETABLE (s))
 381           continue;
 382
 383         /* matching the symbol table's BFD and the *vp's BFD is hairy.
 384            exec_file creates a seperate BFD for possibly the
 385            same file as symbol_file.FIXME ALL THIS MUST BE RECTIFIED. */
 386
 387         if (objfile->obfd == vp->bfd) {
 388           /* if they match, we luck out. */
 389           ;
 390         } else if (vp->member[0]) {
 391           /* no match, and member present, not this one. */
 392           continue;
 393         } else if (vip) {
 394           /* No match, and no member. need to be sure.
 395              If we were given a stat structure, see if the open file
 396              underlying this BFD matches.  */
 397           struct stat si;
 398           FILE *io;
 399
 400           io = bfd_cache_lookup(objfile->obfd);
 401           if (!io)
 402             fatal("cannot find BFD's iostream for sym");
 403
 404           /* see if we are referring to the same file */
 405           if (fstat(fileno(io), &si) < 0)
 406             fatal("cannot fstat BFD for sym");
 407
 408           if ((si.st_dev != vip->st_dev
 409               || si.st_ino != vip->st_ino))
 410             continue;
 411         } else {
 412           continue;     /* No stat struct: no way to match it */
 413         }
 414
 415         if (vp->tstart != old_start) {
 416
 417           /* Once we find a relocation base address for one of the symtabs
 418              in this objfile, it will be the same for all symtabs in this
 419              objfile. Clean this algorithm. FIXME. */
 420
 421           for (; s; s = s->next)
 422             if (!s->nonreloc || LINETABLE(s))
 423                 vmap_symtab_1(s, vp, old_start);
 424
 425 #if 0
 426           Himm.., recently we nullified trampoline entry names in order not
 427           to confuse them with real symbols.  Appearently this turned into a
 428           problem, and msymbol vector did not get relocated properly.  If
 429           msymbols have to have non-null names, then we should name
 430           trampoline entries with empty strings.
 431
 432           ALL_MSYMBOLS (objfile, msymbol)
 433 #else
 434           for (msymbol = objfile->msymbols;
 435                SYMBOL_NAME (msymbol) || SYMBOL_VALUE_ADDRESS (msymbol);
 436                (msymbol)++)
 437 #endif
 438               if (SYMBOL_VALUE_ADDRESS (msymbol) < TEXT_SEGMENT_BASE)
 439                 SYMBOL_VALUE_ADDRESS (msymbol) += vp->tstart - old_start;
 440
 441            break;
 442         }
 443       }
 444     }
 445
 446   if (vp->tstart != old_start) {
 447     /* breakpoints need to be relocated as well. */
 448     fixup_breakpoints (0, TEXT_SEGMENT_BASE, vp->tstart - old_start);
 449   }
 450
 451   symtab_relocated = 1;
 452 }
 453
 454
 455 vmap_symtab_1(s, vp, old_start)
 456 register struct symtab *s;
 457 register struct vmap *vp;
 458 CORE_ADDR old_start;
 459 {
 460     register int i, j;
 461     int len, blen;
 462     register struct linetable *l;
 463     struct blockvector *bv;
 464     register struct block *b;
 465     int depth;
 466     register ulong reloc, dreloc;
 467
 468     if ((reloc = vp->tstart - old_start) == 0)
 469         return;
 470
 471     dreloc = vp->dstart;                        /* data relocation */
 472
 473     /*
 474      * The line table must be relocated.  This is only present for
 475      * .text sections, so only vp->text type maps need be considered.
 476      */
 477     l = LINETABLE (s);
 478     if (l) {
 479       len = l->nitems;
 480       for (i = 0; i < len; i++)
 481         l->item[i].pc += reloc;
 482     }
 483
 484     /* if this symbol table is not relocatable, only line table should
 485        be relocated and the rest ignored. */
 486     if (s->nonreloc)
 487       return;
 488
 489     bv  = BLOCKVECTOR(s);
 490     len = BLOCKVECTOR_NBLOCKS(bv);
 491
 492     for (i = 0; i < len; i++) {
 493         b = BLOCKVECTOR_BLOCK(bv, i);
 494
 495         BLOCK_START(b) += reloc;
 496         BLOCK_END(b)   += reloc;
 497
 498         blen = BLOCK_NSYMS(b);
 499         for (j = 0; j < blen; j++) {
 500             register struct symbol *sym;
 501
 502             sym = BLOCK_SYM(b, j);
 503             switch (SYMBOL_NAMESPACE(sym)) {
 504               case STRUCT_NAMESPACE:
 505               case UNDEF_NAMESPACE:
 506                 continue;
 507
 508               case LABEL_NAMESPACE:
 509               case VAR_NAMESPACE:
 510                 break;
 511             }
 512
 513             switch (SYMBOL_CLASS(sym)) {
 514               case LOC_CONST:
 515               case LOC_CONST_BYTES:
 516               case LOC_LOCAL:
 517               case LOC_REGISTER:
 518               case LOC_ARG:
 519               case LOC_LOCAL_ARG:
 520               case LOC_REF_ARG:
 521               case LOC_REGPARM:
 522               case LOC_TYPEDEF:
 523                 continue;
 524
 525 #ifdef FIXME
 526               case LOC_EXTERNAL:
 527 #endif
 528               case LOC_LABEL:
 529                 SYMBOL_VALUE_ADDRESS(sym) += reloc;
 530                 break;
 531
 532               case LOC_STATIC:
 533                 SYMBOL_VALUE_ADDRESS(sym) += dreloc;
 534                 break;
 535
 536               case LOC_BLOCK:
 537                 break;
 538
 539               default:
 540                 fatal("botched symbol class %x"
 541                       , SYMBOL_CLASS(sym));
 542                 break;
 543             }
 544         }
 545     }
 546 }
 547
 548 /*
 549  * add_vmap -   add a new vmap entry based on ldinfo() information
 550  */
 551 add_vmap(ldi)
 552 register struct ld_info *ldi; {
 553         bfd *bfd, *last;
 554         register char *mem, *objname;
 555
 556         /* This ldi structure was allocated using alloca() in
 557            xcoff_relocate_symtab(). Now we need to have persistent object
 558            and member names, so we should save them. */
 559
 560         mem = ldi->ldinfo_filename + strlen(ldi->ldinfo_filename) + 1;
 561         mem = savestring (mem, strlen (mem));
 562         objname = savestring (ldi->ldinfo_filename, strlen (ldi->ldinfo_filename));
 563
 564         bfd = bfd_fdopenr(objname, NULL, ldi->ldinfo_fd);
 565         if (!bfd)
 566           error("Could not open `%s' as an executable file: %s",
 567                                         objname, bfd_errmsg(bfd_error));
 568
 569
 570         /* make sure we have an object file */
 571
 572         if (bfd_check_format(bfd, bfd_object))
 573           map_vmap (bfd, 0);
 574
 575         else if (bfd_check_format(bfd, bfd_archive)) {
 576                 last = 0;
 577                 /*
 578                  * FIXME??? am I tossing BFDs?  bfd?
 579                  */
 580                 while (last = bfd_openr_next_archived_file(bfd, last))
 581                         if (STREQ(mem, last->filename))
 582                                 break;
 583
 584                 if (!last) {
 585                   bfd_close(bfd);
 586                   /* FIXME -- should be error */
 587                   warning("\"%s\": member \"%s\" missing.", bfd->filename, mem);
 588                   return;
 589                 }
 590
 591                 if (!bfd_check_format(last, bfd_object)) {
 592                         bfd_close(last);        /* XXX???       */
 593                         goto obj_err;
 594                 }
 595
 596                 map_vmap (last, bfd);
 597         }
 598         else {
 599             obj_err:
 600                 bfd_close(bfd);
 601 /* FIXME -- should be error */
 602                 warning("\"%s\": not in executable format: %s."
 603                       , objname, bfd_errmsg(bfd_error));
 604                 return;
 605         }
 606 }
 607
 608
 609 /* As well as symbol tables, exec_sections need relocation. After
 610    the inferior process' termination, there will be a relocated symbol
 611    table exist with no corresponding inferior process. At that time, we
 612    need to use `exec' bfd, rather than the inferior process's memory space
 613    to look up symbols.
 614
 615    `exec_sections' need to be relocated only once, as long as the exec
 616    file remains unchanged.
 617 */
 618 vmap_exec ()
 619 {
 620   static bfd *execbfd;
 621   int i;
 622
 623   if (execbfd == exec_bfd)
 624     return;
 625
 626   execbfd = exec_bfd;
 627
 628   if (!vmap || !exec_ops.to_sections)
 629     error ("vmap_exec: vmap or exec_ops.to_sections == 0\n");
 630
 631   for (i=0; &exec_ops.to_sections[i] < exec_ops.to_sections_end; i++)
 632     {
 633       if (STREQ(".text", exec_ops.to_sections[i].sec_ptr->name))
 634         {
 635           exec_ops.to_sections[i].addr += vmap->tstart;
 636           exec_ops.to_sections[i].endaddr += vmap->tstart;
 637         }
 638       else if (STREQ(".data", exec_ops.to_sections[i].sec_ptr->name))
 639         {
 640           exec_ops.to_sections[i].addr += vmap->dstart;
 641           exec_ops.to_sections[i].endaddr += vmap->dstart;
 642         }
 643     }
 644 }
 645
 646
 647 int
 648 text_adjustment (abfd)
 649 bfd *abfd;
 650 {
 651   static bfd *execbfd;
 652   static int adjustment;
 653   sec_ptr  sect;
 654
 655   if (exec_bfd == execbfd)
 656     return adjustment;
 657
 658   sect = bfd_get_section_by_name (abfd, ".text");
 659   if (sect)
 660     adjustment = sect->filepos - sect->vma;
 661   else
 662     adjustment = 0x200;                         /* just a wild assumption */
 663
 664   return adjustment;
 665 }
 666
 667
 668 /*
 669  * vmap_ldinfo -        update VMAP info with ldinfo() information
 670  *
 671  * Input:
 672  *      ldi     -       ^ to ldinfo() results.
 673  */
 674 vmap_ldinfo(ldi)
 675 register struct ld_info *ldi;
 676 {
 677   struct stat ii, vi;
 678   register struct vmap *vp;
 679   register got_one, retried;
 680   CORE_ADDR ostart;
 681
 682   /*
 683    * for each *ldi, see if we have a corresponding *vp
 684    *    if so, update the mapping, and symbol table.
 685    *    if not, add an entry and symbol table.
 686    */
 687   do {
 688         char *name = ldi->ldinfo_filename;
 689         char *memb = name + strlen(name) + 1;
 690
 691         retried = 0;
 692
 693         if (fstat(ldi->ldinfo_fd, &ii) < 0)
 694                 fatal("cannot fstat(%d) on %s"
 695                       , ldi->ldinfo_fd
 696                       , name);
 697 retry:
 698         for (got_one = 0, vp = vmap; vp; vp = vp->nxt) {
 699           FILE *io;
 700
 701           /* First try to find a `vp', which is the same as in ldinfo.
 702              If not the same, just continue and grep the next `vp'. If same,
 703              relocate its tstart, tend, dstart, dend values. If no such `vp'
 704              found, get out of this for loop, add this ldi entry as a new vmap
 705              (add_vmap) and come back, fins its `vp' and so on... */
 706
 707           /* The filenames are not always sufficient to match on. */
 708
 709           if ((name[0] == '/' && !STREQ(name, vp->name))
 710                 || (memb[0] && !STREQ(memb, vp->member)))
 711             continue;
 712
 713           io = bfd_cache_lookup(vp->bfd);               /* totally opaque! */
 714           if (!io)
 715             fatal("cannot find BFD's iostream for %s", vp->name);
 716
 717           /* see if we are referring to the same file */
 718
 719           if (fstat(fileno(io), &vi) < 0)
 720             fatal("cannot fstat BFD for %s", vp->name);
 721
 722           if (ii.st_dev != vi.st_dev || ii.st_ino != vi.st_ino)
 723             continue;
 724
 725           if (!retried)
 726             close(ldi->ldinfo_fd);
 727
 728           ++got_one;
 729
 730           /* found a corresponding VMAP. remap! */
 731           ostart = vp->tstart;
 732
 733           vp->tstart = ldi->ldinfo_textorg;
 734           vp->tend   = vp->tstart + ldi->ldinfo_textsize;
 735           vp->dstart = ldi->ldinfo_dataorg;
 736           vp->dend   = vp->dstart + ldi->ldinfo_datasize;
 737
 738           if (vp->tadj) {
 739             vp->tstart += vp->tadj;
 740             vp->tend   += vp->tadj;
 741           }
 742
 743           /* relocate symbol table(s). */
 744           vmap_symtab(vp, ostart, &vi);
 745
 746           /* there may be more, so we don't break out of the loop. */
 747         }
 748
 749         /* if there was no matching *vp, we must perforce create the sucker(s) */
 750         if (!got_one && !retried) {
 751           add_vmap(ldi);
 752           ++retried;
 753           goto retry;
 754         }
 755   } while (ldi->ldinfo_next
 756          && (ldi = (void *) (ldi->ldinfo_next + (char *) ldi)));
 757
 758 }
 759
 760 /*
 761  * vmap_inferior -      print VMAP info for inferior
 762  */
 763 vmap_inferior() {
 764
 765         if (inferior_pid == 0)
 766           return 0;                             /* normal processing    */
 767
 768         exec_files_info();
 769         return 1;
 770 }
 771
 772 /* Read or write the exec file.
 773
 774    Args are address within exec file, address within gdb address-space,
 775    length, and a flag indicating whether to read or write.
 776
 777    Result is a length:
 778
 779         0:    We cannot handle this address and length.
 780         > 0:  We have handled N bytes starting at this address.
 781               (If N == length, we did it all.)  We might be able
 782               to handle more bytes beyond this length, but no
 783               promises.
 784         < 0:  We cannot handle this address, but if somebody
 785               else handles (-N) bytes, we can start from there.
 786
 787     The same routine is used to handle both core and exec files;
 788     we just tail-call it with more arguments to select between them.  */
 789
 790 int
 791 xfer_memory (memaddr, myaddr, len, write, target)
 792      CORE_ADDR memaddr;
 793      char *myaddr;
 794      int len;
 795      int write;
 796      struct target_ops *target;
 797 {
 798   boolean res;
 799   struct section_table *p;
 800   CORE_ADDR nextsectaddr, memend;
 801   boolean (*xfer_fn) PARAMS ((bfd *, sec_ptr, PTR, file_ptr, bfd_size_type));
 802
 803   if (len <= 0)
 804     abort();
 805
 806   memend = memaddr + len;
 807   xfer_fn = write? bfd_set_section_contents: bfd_get_section_contents;
 808   nextsectaddr = memend;
 809
 810   for (p = target->to_sections; p < target->to_sections_end; p++)
 811     {
 812       if (p->addr <= memaddr)
 813         if (p->endaddr >= memend)
 814           {
 815             /* Entire transfer is within this section.  */
 816             res = xfer_fn (p->bfd, p->sec_ptr, myaddr, memaddr - p->addr, len);
 817             return (res != false)? len: 0;
 818           }
 819         else if (p->endaddr <= memaddr)
 820           {
 821             /* This section ends before the transfer starts.  */
 822             continue;
 823           }
 824         else
 825           {
 826             /* This section overlaps the transfer.  Just do half.  */
 827             len = p->endaddr - memaddr;
 828             res = xfer_fn (p->bfd, p->sec_ptr, myaddr, memaddr - p->addr, len);
 829             return (res != false)? len: 0;
 830           }
 831       else if (p->addr < nextsectaddr)
 832         nextsectaddr = p->addr;
 833     }
 834
 835   if (nextsectaddr >= memend)
 836     return 0;                           /* We can't help */
 837   else
 838     return - (nextsectaddr - memaddr);  /* Next boundary where we can help */
 839 }
 840
 841 void
 842 print_section_info (t, abfd)
 843   struct target_ops *t;
 844   bfd *abfd;
 845 {
 846   struct section_table *p;
 847
 848   printf_filtered ("\t`%s', ", bfd_get_filename(abfd));
 849   wrap_here ("        ");
 850   printf_filtered ("file type %s.\n", bfd_get_target(abfd));
 851
 852   for (p = t->to_sections; p < t->to_sections_end; p++) {
 853     printf_filtered ("\t%s", local_hex_string_custom (p->addr, "08"));
 854     printf_filtered (" - %s", local_hex_string_custom (p->endaddr, "08"));
 855     if (info_verbose)
 856       printf_filtered (" @ %s",
 857                        local_hex_string_custom (p->sec_ptr->filepos, "08"));
 858     printf_filtered (" is %s", bfd_section_name (p->bfd, p->sec_ptr));
 859     if (p->bfd != abfd) {
 860       printf_filtered (" in %s", bfd_get_filename (p->bfd));
 861     }
 862     printf_filtered ("\n");
 863   }
 864 }
 865
 866
 867 static void
 868 exec_files_info (t)
 869   struct target_ops *t;
 870 {
 871   register struct vmap *vp = vmap;
 872
 873   print_section_info (t, exec_bfd);
 874
 875   if (!vp)
 876     return;
 877
 878   printf("\tMapping info for file `%s'.\n", vp->name);
 879
 880   printf("\t  %8.8s   %8.8s   %8.8s   %8.8s %8.8s %s\n",
 881     "tstart", "tend", "dstart", "dend", "section", "file(member)");
 882
 883   for (; vp; vp = vp->nxt)
 884      printf("\t0x%8.8x 0x%8.8x 0x%8.8x 0x%8.8x %s%s%s%s\n",
 885         vp->tstart,
 886         vp->tend,
 887         vp->dstart,
 888         vp->dend,
 889         vp->name,
 890         *vp->member ? "(" : "",
 891         vp->member,
 892         *vp->member ? ")" : "");
 893 }
 894
 895 #ifdef DAMON
 896 /*  Damon's implementation of set_section_command! It is based on the sex member
 897   (which is a section pointer from vmap) of vmap.
 898   We will not have multiple vmap entries (one for each section), rather transmit
 899   text and data base offsets and fix them at the same time. Elimination of sex
 900   entry in vmap make this function obsolute, use the one from exec.c.
 901   Need further testing!!        FIXMEmgo.  */
 902
 903 static void
 904 set_section_command(args, from_tty)
 905 char *args;
 906 {
 907         register struct vmap *vp = vmap;
 908         char *secname;
 909         unsigned seclen;
 910         unsigned long secaddr;
 911         char secprint[100];
 912         long offset;
 913
 914         if (args == 0)
 915                 error("Must specify section name and its virtual address");
 916
 917         /* Parse out section name */
 918         for (secname = args; !isspace(*args); args++)
 919                 ;
 920         seclen = args - secname;
 921
 922         /* Parse out new virtual address */
 923         secaddr = parse_and_eval_address(args);
 924
 925         for (vp = vmap; vp; vp = vp->nxt) {
 926                 if (!strncmp(secname
 927                              , bfd_section_name(vp->bfd, vp->sex), seclen)
 928                     && bfd_section_name(vp->bfd, vp->sex)[seclen] == '\0') {
 929                         offset = secaddr - vp->tstart;
 930                         vp->tstart += offset;
 931                         vp->tend   += offset;
 932                         exec_files_info();
 933                         return;
 934                 }
 935         }
 936
 937         if (seclen >= sizeof(secprint))
 938                 seclen = sizeof(secprint) - 1;
 939         strncpy(secprint, secname, seclen);
 940         secprint[seclen] = '\0';
 941         error("Section %s not found", secprint);
 942 }
 943 #else
 944 static void
 945 set_section_command (args, from_tty)
 946      char *args;
 947      int from_tty;
 948 {
 949   struct section_table *p;
 950   char *secname;
 951   unsigned seclen;
 952   unsigned long secaddr;
 953   char secprint[100];
 954   long offset;
 955
 956   if (args == 0)
 957     error ("Must specify section name and its virtual address");
 958
 959   /* Parse out section name */
 960   for (secname = args; !isspace(*args); args++) ;
 961   seclen = args - secname;
 962
 963   /* Parse out new virtual address */
 964   secaddr = parse_and_eval_address (args);
 965
 966   for (p = exec_ops.to_sections; p < exec_ops.to_sections_end; p++) {
 967     if (!strncmp (secname, bfd_section_name (exec_bfd, p->sec_ptr), seclen)
 968         && bfd_section_name (exec_bfd, p->sec_ptr)[seclen] == '\0') {
 969       offset = secaddr - p->addr;
 970       p->addr += offset;
 971       p->endaddr += offset;
 972       if (from_tty)
 973         exec_files_info(&exec_ops);
 974       return;
 975     }
 976   }
 977   if (seclen >= sizeof (secprint))
 978     seclen = sizeof (secprint) - 1;
 979   strncpy (secprint, secname, seclen);
 980   secprint[seclen] = '\0';
 981   error ("Section %s not found", secprint);
 982 }
 983
 984 #endif /* !DAMON */
 985
 986 struct target_ops exec_ops = {
 987         "exec", "Local exec file",
 988         "Use an executable file as a target.\n\
 989 Specify the filename of the executable file.",
 990         exec_file_command, exec_close, /* open, close */
 991         find_default_attach, 0, 0, 0, /* attach, detach, resume, wait, */
 992         0, 0, /* fetch_registers, store_registers, */
 993         0, /* prepare_to_store */
 994         xfer_memory, exec_files_info,
 995         0, 0, /* insert_breakpoint, remove_breakpoint, */
 996         0, 0, 0, 0, 0, /* terminal stuff */
 997         0, 0, /* kill, load */
 998         0, /* lookup sym */
 999         find_default_create_inferior,
1000         0, /* mourn_inferior */
1001         0, /* can_run */
1002         0, /* notice_signals */
1003         file_stratum, 0, /* next */
1004         0, 1, 0, 0, 0,  /* all mem, mem, stack, regs, exec */
1005         0, 0,                   /* section pointers */
1006         OPS_MAGIC,              /* Always the last thing */
1007 };
1008
1009
1010 void
1011 _initialize_exec()
1012 {
1013
1014   add_com("file", class_files, file_command,
1015            "Use FILE as program to be debugged.\n\
1016 It is read for its symbols, for getting the contents of pure memory,\n\
1017 and it is the program executed when you use the `run' command.\n\
1018 If FILE cannot be found as specified, your execution directory path\n\
1019 ($PATH) is searched for a command of that name.\n\
1020 No arg means to have no executable file and no symbols.");
1021
1022   add_com("exec-file", class_files, exec_file_command,
1023            "Use FILE as program for getting contents of pure memory.\n\
1024 If FILE cannot be found as specified, your execution directory path\n\
1025 is searched for a command of that name.\n\
1026 No arg means have no executable file.");
1027
1028   add_com("section", class_files, set_section_command,
1029    "Change the base address of section SECTION of the exec file to ADDR.\n\
1030 This can be used if the exec file does not contain section addresses,\n\
1031 (such as in the a.out format), or when the addresses specified in the\n\
1032 file itself are wrong.  Each section must be changed separately.  The\n\
1033 ``info files'' command lists all the sections and their addresses.");
1034
1035   add_target(&exec_ops);
1036 }