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