gdb/exec.c

   1 /* Work with executable files, for GDB.
   2    Copyright 1988, 1989, 1991, 1992, 1993, 1994, 1997, 1998
   3    Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 #include "defs.h"
  23 #include "frame.h"
  24 #include "inferior.h"
  25 #include "target.h"
  26 #include "gdbcmd.h"
  27 #include "language.h"
  28 #include "symfile.h"
  29 #include "objfiles.h"
  30
  31 #ifdef USG
  32 #include <sys/types.h>
  33 #endif
  34
  35 #include <fcntl.h>
  36 #include "gdb_string.h"
  37
  38 #include "gdbcore.h"
  39
  40 #include <ctype.h>
  41 #include "gdb_stat.h"
  42 #ifndef O_BINARY
  43 #define O_BINARY 0
  44 #endif
  45
  46 #include "xcoffsolib.h"
  47
  48 struct vmap *map_vmap PARAMS ((bfd *, bfd *));
  49
  50 void (*file_changed_hook) PARAMS ((char *));
  51
  52 /* Prototypes for local functions */
  53
  54 static void add_to_section_table PARAMS ((bfd *, sec_ptr, PTR));
  55
  56 static void exec_close PARAMS ((int));
  57
  58 static void file_command PARAMS ((char *, int));
  59
  60 static void set_section_command PARAMS ((char *, int));
  61
  62 static void exec_files_info PARAMS ((struct target_ops *));
  63
  64 static void bfdsec_to_vmap PARAMS ((bfd *, sec_ptr, PTR));
  65
  66 static int ignore PARAMS ((CORE_ADDR, char *));
  67
  68 static void init_exec_ops PARAMS ((void));
  69
  70 void _initialize_exec PARAMS ((void));
  71
  72 extern int info_verbose;
  73
  74 /* The target vector for executable files.  */
  75
  76 struct target_ops exec_ops;
  77
  78 /* The Binary File Descriptor handle for the executable file.  */
  79
  80 bfd *exec_bfd = NULL;
  81
  82 /* Whether to open exec and core files read-only or read-write.  */
  83
  84 int write_files = 0;
  85
  86 /* Text start and end addresses (KLUDGE) if needed */
  87
  88 #ifndef NEED_TEXT_START_END
  89 #define NEED_TEXT_START_END (0)
  90 #endif
  91 CORE_ADDR text_start = 0;
  92 CORE_ADDR text_end = 0;
  93
  94 struct vmap *vmap;
  95
  96 /* ARGSUSED */
  97 static void
  98 exec_close (quitting)
  99      int quitting;
 100 {
 101   int need_symtab_cleanup = 0;
 102   struct vmap *vp, *nxt;
 103
 104   for (nxt = vmap; nxt != NULL;)
 105     {
 106       vp = nxt;
 107       nxt = vp->nxt;
 108
 109       /* if there is an objfile associated with this bfd,
 110          free_objfile() will do proper cleanup of objfile *and* bfd. */
 111
 112       if (vp->objfile)
 113         {
 114           free_objfile (vp->objfile);
 115           need_symtab_cleanup = 1;
 116         }
 117       else if (vp->bfd != exec_bfd)
 118         /* FIXME-leak: We should be freeing vp->name too, I think.  */
 119         if (!bfd_close (vp->bfd))
 120           warning ("cannot close \"%s\": %s",
 121                    vp->name, bfd_errmsg (bfd_get_error ()));
 122
 123       /* FIXME: This routine is #if 0'd in symfile.c.  What should we
 124          be doing here?  Should we just free everything in
 125          vp->objfile->symtabs?  Should free_objfile do that?
 126          FIXME-as-well: free_objfile already free'd vp->name, so it isn't
 127          valid here.  */
 128       free_named_symtabs (vp->name);
 129       free (vp);
 130     }
 131
 132   vmap = NULL;
 133
 134   if (exec_bfd)
 135     {
 136       char *name = bfd_get_filename (exec_bfd);
 137
 138       if (!bfd_close (exec_bfd))
 139         warning ("cannot close \"%s\": %s",
 140                  name, bfd_errmsg (bfd_get_error ()));
 141       free (name);
 142       exec_bfd = NULL;
 143     }
 144
 145   if (exec_ops.to_sections)
 146     {
 147       free ((PTR) exec_ops.to_sections);
 148       exec_ops.to_sections = NULL;
 149       exec_ops.to_sections_end = NULL;
 150     }
 151 }
 152
 153 /*  Process the first arg in ARGS as the new exec file.
 154
 155    This function is intended to be behave essentially the same
 156    as exec_file_command, except that the latter will detect when
 157    a target is being debugged, and will ask the user whether it
 158    should be shut down first.  (If the answer is "no", then the
 159    new file is ignored.)
 160
 161    This file is used by exec_file_command, to do the work of opening
 162    and processing the exec file after any prompting has happened.
 163
 164    And, it is used by child_attach, when the attach command was
 165    given a pid but not a exec pathname, and the attach command could
 166    figure out the pathname from the pid.  (In this case, we shouldn't
 167    ask the user whether the current target should be shut down --
 168    we're supplying the exec pathname late for good reason.) */
 169
 170 void
 171 exec_file_attach (args, from_tty)
 172      char *args;
 173      int from_tty;
 174 {
 175   char **argv;
 176   char *filename;
 177
 178   /* Remove any previous exec file.  */
 179   unpush_target (&exec_ops);
 180
 181   /* Now open and digest the file the user requested, if any.  */
 182
 183   if (args)
 184     {
 185       char *scratch_pathname;
 186       int scratch_chan;
 187
 188       /* Scan through the args and pick up the first non option arg
 189          as the filename.  */
 190
 191       argv = buildargv (args);
 192       if (argv == NULL)
 193         nomem (0);
 194
 195       make_cleanup_freeargv (argv);
 196
 197       for (; (*argv != NULL) && (**argv == '-'); argv++)
 198         {;
 199         }
 200       if (*argv == NULL)
 201         error ("no exec file name was specified");
 202
 203       filename = tilde_expand (*argv);
 204       make_cleanup (free, filename);
 205
 206       scratch_chan = openp (getenv ("PATH"), 1, filename,
 207                    write_files ? O_RDWR | O_BINARY : O_RDONLY | O_BINARY, 0,
 208                             &scratch_pathname);
 209 #if defined(__GO32__) || defined(_WIN32)
 210       if (scratch_chan < 0)
 211         {
 212           char *exename = alloca (strlen (filename) + 5);
 213           strcat (strcpy (exename, filename), ".exe");
 214           scratch_chan = openp (getenv ("PATH"), 1, exename, write_files ?
 215              O_RDWR | O_BINARY : O_RDONLY | O_BINARY, 0, &scratch_pathname);
 216         }
 217 #endif
 218       if (scratch_chan < 0)
 219         perror_with_name (filename);
 220       exec_bfd = bfd_fdopenr (scratch_pathname, gnutarget, scratch_chan);
 221
 222       if (!exec_bfd)
 223         error ("\"%s\": could not open as an executable file: %s",
 224                scratch_pathname, bfd_errmsg (bfd_get_error ()));
 225
 226       /* At this point, scratch_pathname and exec_bfd->name both point to the
 227          same malloc'd string.  However exec_close() will attempt to free it
 228          via the exec_bfd->name pointer, so we need to make another copy and
 229          leave exec_bfd as the new owner of the original copy. */
 230       scratch_pathname = strdup (scratch_pathname);
 231       make_cleanup (free, scratch_pathname);
 232
 233       if (!bfd_check_format (exec_bfd, bfd_object))
 234         {
 235           /* Make sure to close exec_bfd, or else "run" might try to use
 236              it.  */
 237           exec_close (0);
 238           error ("\"%s\": not in executable format: %s",
 239                  scratch_pathname, bfd_errmsg (bfd_get_error ()));
 240         }
 241
 242       /* FIXME - This should only be run for RS6000, but the ifdef is a poor
 243          way to accomplish.  */
 244 #ifdef IBM6000_TARGET
 245       /* Setup initial vmap. */
 246
 247       map_vmap (exec_bfd, 0);
 248       if (vmap == NULL)
 249         {
 250           /* Make sure to close exec_bfd, or else "run" might try to use
 251              it.  */
 252           exec_close (0);
 253           error ("\"%s\": can't find the file sections: %s",
 254                  scratch_pathname, bfd_errmsg (bfd_get_error ()));
 255         }
 256 #endif /* IBM6000_TARGET */
 257
 258       if (build_section_table (exec_bfd, &exec_ops.to_sections,
 259                                &exec_ops.to_sections_end))
 260         {
 261           /* Make sure to close exec_bfd, or else "run" might try to use
 262              it.  */
 263           exec_close (0);
 264           error ("\"%s\": can't find the file sections: %s",
 265                  scratch_pathname, bfd_errmsg (bfd_get_error ()));
 266         }
 267
 268       /* text_end is sometimes used for where to put call dummies.  A
 269          few ports use these for other purposes too.  */
 270       if (NEED_TEXT_START_END)
 271         {
 272           struct section_table *p;
 273
 274           /* Set text_start to the lowest address of the start of any
 275              readonly code section and set text_end to the highest
 276              address of the end of any readonly code section.  */
 277           /* FIXME: The comment above does not match the code.  The
 278              code checks for sections with are either code *or*
 279              readonly.  */
 280           text_start = ~(CORE_ADDR) 0;
 281           text_end = (CORE_ADDR) 0;
 282           for (p = exec_ops.to_sections; p < exec_ops.to_sections_end; p++)
 283             if (bfd_get_section_flags (p->bfd, p->the_bfd_section)
 284                 & (SEC_CODE | SEC_READONLY))
 285               {
 286                 if (text_start > p->addr)
 287                   text_start = p->addr;
 288                 if (text_end < p->endaddr)
 289                   text_end = p->endaddr;
 290               }
 291         }
 292
 293       validate_files ();
 294
 295       set_gdbarch_from_file (exec_bfd);
 296
 297       push_target (&exec_ops);
 298
 299       /* Tell display code (if any) about the changed file name.  */
 300       if (exec_file_display_hook)
 301         (*exec_file_display_hook) (filename);
 302     }
 303   else if (from_tty)
 304     printf_unfiltered ("No executable file now.\n");
 305 }
 306
 307 /*  Process the first arg in ARGS as the new exec file.
 308
 309    Note that we have to explicitly ignore additional args, since we can
 310    be called from file_command(), which also calls symbol_file_command()
 311    which can take multiple args. */
 312
 313 void
 314 exec_file_command (args, from_tty)
 315      char *args;
 316      int from_tty;
 317 {
 318   char **argv;
 319   char *filename;
 320
 321   target_preopen (from_tty);
 322
 323   exec_file_attach (args, from_tty);
 324 }
 325
 326 /* Set both the exec file and the symbol file, in one command.
 327    What a novelty.  Why did GDB go through four major releases before this
 328    command was added?  */
 329
 330 static void
 331 file_command (arg, from_tty)
 332      char *arg;
 333      int from_tty;
 334 {
 335   /* FIXME, if we lose on reading the symbol file, we should revert
 336      the exec file, but that's rough.  */
 337   exec_file_command (arg, from_tty);
 338   symbol_file_command (arg, from_tty);
 339   if (file_changed_hook)
 340     file_changed_hook (arg);
 341 }
 342 \f
 343
 344 /* Locate all mappable sections of a BFD file.
 345    table_pp_char is a char * to get it through bfd_map_over_sections;
 346    we cast it back to its proper type.  */
 347
 348 static void
 349 add_to_section_table (abfd, asect, table_pp_char)
 350      bfd *abfd;
 351      sec_ptr asect;
 352      PTR table_pp_char;
 353 {
 354   struct section_table **table_pp = (struct section_table **) table_pp_char;
 355   flagword aflag;
 356
 357   aflag = bfd_get_section_flags (abfd, asect);
 358   if (!(aflag & SEC_ALLOC))
 359     return;
 360   if (0 == bfd_section_size (abfd, asect))
 361     return;
 362   (*table_pp)->bfd = abfd;
 363   (*table_pp)->the_bfd_section = asect;
 364   (*table_pp)->addr = bfd_section_vma (abfd, asect);
 365   (*table_pp)->endaddr = (*table_pp)->addr + bfd_section_size (abfd, asect);
 366   (*table_pp)++;
 367 }
 368
 369 /* Builds a section table, given args BFD, SECTABLE_PTR, SECEND_PTR.
 370    Returns 0 if OK, 1 on error.  */
 371
 372 int
 373 build_section_table (some_bfd, start, end)
 374      bfd *some_bfd;
 375      struct section_table **start, **end;
 376 {
 377   unsigned count;
 378
 379   count = bfd_count_sections (some_bfd);
 380   if (*start)
 381     free ((PTR) * start);
 382   *start = (struct section_table *) xmalloc (count * sizeof (**start));
 383   *end = *start;
 384   bfd_map_over_sections (some_bfd, add_to_section_table, (char *) end);
 385   if (*end > *start + count)
 386     abort ();
 387   /* We could realloc the table, but it probably loses for most files.  */
 388   return 0;
 389 }
 390 \f
 391 static void
 392 bfdsec_to_vmap (abfd, sect, arg3)
 393      bfd *abfd;
 394      sec_ptr sect;
 395      PTR arg3;
 396 {
 397   struct vmap_and_bfd *vmap_bfd = (struct vmap_and_bfd *) arg3;
 398   struct vmap *vp;
 399
 400   vp = vmap_bfd->pvmap;
 401
 402   if ((bfd_get_section_flags (abfd, sect) & SEC_LOAD) == 0)
 403     return;
 404
 405   if (STREQ (bfd_section_name (abfd, sect), ".text"))
 406     {
 407       vp->tstart = bfd_section_vma (abfd, sect);
 408       vp->tend = vp->tstart + bfd_section_size (abfd, sect);
 409       vp->tvma = bfd_section_vma (abfd, sect);
 410       vp->toffs = sect->filepos;
 411     }
 412   else if (STREQ (bfd_section_name (abfd, sect), ".data"))
 413     {
 414       vp->dstart = bfd_section_vma (abfd, sect);
 415       vp->dend = vp->dstart + bfd_section_size (abfd, sect);
 416       vp->dvma = bfd_section_vma (abfd, sect);
 417     }
 418   /* Silently ignore other types of sections. (FIXME?)  */
 419 }
 420
 421 /* Make a vmap for ABFD which might be a member of the archive ARCH.
 422    Return the new vmap.  */
 423
 424 struct vmap *
 425 map_vmap (abfd, arch)
 426      bfd *abfd;
 427      bfd *arch;
 428 {
 429   struct vmap_and_bfd vmap_bfd;
 430   struct vmap *vp, **vpp;
 431
 432   vp = (struct vmap *) xmalloc (sizeof (*vp));
 433   memset ((char *) vp, '\0', sizeof (*vp));
 434   vp->nxt = 0;
 435   vp->bfd = abfd;
 436   vp->name = bfd_get_filename (arch ? arch : abfd);
 437   vp->member = arch ? bfd_get_filename (abfd) : "";
 438
 439   vmap_bfd.pbfd = arch;
 440   vmap_bfd.pvmap = vp;
 441   bfd_map_over_sections (abfd, bfdsec_to_vmap, &vmap_bfd);
 442
 443   /* Find the end of the list and append. */
 444   for (vpp = &vmap; *vpp; vpp = &(*vpp)->nxt)
 445     ;
 446   *vpp = vp;
 447
 448   return vp;
 449 }
 450 \f
 451 /* Read or write the exec file.
 452
 453    Args are address within a BFD file, address within gdb address-space,
 454    length, and a flag indicating whether to read or write.
 455
 456    Result is a length:
 457
 458    0:    We cannot handle this address and length.
 459    > 0:  We have handled N bytes starting at this address.
 460    (If N == length, we did it all.)  We might be able
 461    to handle more bytes beyond this length, but no
 462    promises.
 463    < 0:  We cannot handle this address, but if somebody
 464    else handles (-N) bytes, we can start from there.
 465
 466    The same routine is used to handle both core and exec files;
 467    we just tail-call it with more arguments to select between them.  */
 468
 469 int
 470 xfer_memory (memaddr, myaddr, len, write, target)
 471      CORE_ADDR memaddr;
 472      char *myaddr;
 473      int len;
 474      int write;
 475      struct target_ops *target;
 476 {
 477   boolean res;
 478   struct section_table *p;
 479   CORE_ADDR nextsectaddr, memend;
 480   boolean (*xfer_fn) PARAMS ((bfd *, sec_ptr, PTR, file_ptr, bfd_size_type));
 481   asection *section;
 482
 483   if (len <= 0)
 484     abort ();
 485
 486   if (overlay_debugging)
 487     {
 488       section = find_pc_overlay (memaddr);
 489       if (pc_in_unmapped_range (memaddr, section))
 490         memaddr = overlay_mapped_address (memaddr, section);
 491     }
 492
 493   memend = memaddr + len;
 494   xfer_fn = write ? bfd_set_section_contents : bfd_get_section_contents;
 495   nextsectaddr = memend;
 496
 497 #if 0                           /* Stu's implementation */
 498 /* If a section has been specified, try to use it.  Note that we cannot use the
 499    specified section directly.  This is because it usually comes from the
 500    symbol file, which may be different from the exec or core file.  Instead, we
 501    have to lookup the specified section by name in the bfd associated with
 502    to_sections.  */
 503
 504   if (target_memory_bfd_section)
 505     {
 506       asection *s;
 507       bfd *abfd;
 508       asection *target_section;
 509       bfd *target_bfd;
 510
 511       s = target_memory_bfd_section;
 512       abfd = s->owner;
 513
 514       target_bfd = target->to_sections->bfd;
 515       target_section = bfd_get_section_by_name (target_bfd, bfd_section_name (abfd, s));
 516
 517       if (target_section)
 518         {
 519           bfd_vma sec_addr;
 520           bfd_size_type sec_size;
 521
 522           sec_addr = bfd_section_vma (target_bfd, target_section);
 523           sec_size = target_section->_raw_size;
 524
 525           /* Make sure the requested memory starts inside the section.  */
 526
 527           if (memaddr >= sec_addr
 528               && memaddr < sec_addr + sec_size)
 529             {
 530               /* Cut back length in case request overflows the end of the section. */
 531               len = min (len, sec_addr + sec_size - memaddr);
 532
 533               res = xfer_fn (target_bfd, target_section, myaddr, memaddr - sec_addr, len);
 534
 535               return res ? len : 0;
 536             }
 537         }
 538     }
 539 #endif /* 0, Stu's implementation */
 540   for (p = target->to_sections; p < target->to_sections_end; p++)
 541     {
 542       if (overlay_debugging && section && p->the_bfd_section &&
 543           strcmp (section->name, p->the_bfd_section->name) != 0)
 544         continue;               /* not the section we need */
 545       if (memaddr >= p->addr)
 546         if (memend <= p->endaddr)
 547           {
 548             /* Entire transfer is within this section.  */
 549             res = xfer_fn (p->bfd, p->the_bfd_section, myaddr,
 550                            memaddr - p->addr, len);
 551             return (res != 0) ? len : 0;
 552           }
 553         else if (memaddr >= p->endaddr)
 554           {
 555             /* This section ends before the transfer starts.  */
 556             continue;
 557           }
 558         else
 559           {
 560             /* This section overlaps the transfer.  Just do half.  */
 561             len = p->endaddr - memaddr;
 562             res = xfer_fn (p->bfd, p->the_bfd_section, myaddr,
 563                            memaddr - p->addr, len);
 564             return (res != 0) ? len : 0;
 565           }
 566       else
 567         nextsectaddr = min (nextsectaddr, p->addr);
 568     }
 569
 570   if (nextsectaddr >= memend)
 571     return 0;                   /* We can't help */
 572   else
 573     return -(nextsectaddr - memaddr);   /* Next boundary where we can help */
 574 }
 575 \f
 576
 577 void
 578 print_section_info (t, abfd)
 579      struct target_ops *t;
 580      bfd *abfd;
 581 {
 582   struct section_table *p;
 583
 584   printf_filtered ("\t`%s', ", bfd_get_filename (abfd));
 585   wrap_here ("        ");
 586   printf_filtered ("file type %s.\n", bfd_get_target (abfd));
 587   if (abfd == exec_bfd)
 588     {
 589       printf_filtered ("\tEntry point: ");
 590       print_address_numeric (bfd_get_start_address (abfd), 1, gdb_stdout);
 591       printf_filtered ("\n");
 592     }
 593   for (p = t->to_sections; p < t->to_sections_end; p++)
 594     {
 595       /* FIXME-32x64 need a print_address_numeric with field width */
 596       printf_filtered ("\t%s", local_hex_string_custom ((unsigned long) p->addr, "08l"));
 597       printf_filtered (" - %s", local_hex_string_custom ((unsigned long) p->endaddr, "08l"));
 598       if (info_verbose)
 599         printf_filtered (" @ %s",
 600                          local_hex_string_custom ((unsigned long) p->the_bfd_section->filepos, "08l"));
 601       printf_filtered (" is %s", bfd_section_name (p->bfd, p->the_bfd_section));
 602       if (p->bfd != abfd)
 603         {
 604           printf_filtered (" in %s", bfd_get_filename (p->bfd));
 605         }
 606       printf_filtered ("\n");
 607     }
 608 }
 609
 610 static void
 611 exec_files_info (t)
 612      struct target_ops *t;
 613 {
 614   print_section_info (t, exec_bfd);
 615
 616   if (vmap)
 617     {
 618       struct vmap *vp;
 619
 620       printf_unfiltered ("\tMapping info for file `%s'.\n", vmap->name);
 621       printf_unfiltered ("\t  %8.8s   %8.8s   %8.8s   %8.8s %8.8s %s\n",
 622                          "tstart", "tend", "dstart", "dend", "section",
 623                          "file(member)");
 624
 625       for (vp = vmap; vp; vp = vp->nxt)
 626         printf_unfiltered ("\t0x%8.8x 0x%8.8x 0x%8.8x 0x%8.8x %s%s%s%s\n",
 627                        vp->tstart, vp->tend, vp->dstart, vp->dend, vp->name,
 628                            *vp->member ? "(" : "", vp->member,
 629                            *vp->member ? ")" : "");
 630     }
 631 }
 632
 633 /* msnyder 5/21/99:
 634    exec_set_section_offsets sets the offsets of all the sections
 635    in the exec objfile.  */
 636
 637 void
 638 exec_set_section_offsets (text_off, data_off, bss_off)
 639      bfd_signed_vma text_off;
 640      bfd_signed_vma data_off;
 641      bfd_signed_vma bss_off;
 642 {
 643   struct section_table *sect;
 644
 645   for (sect = exec_ops.to_sections;
 646        sect < exec_ops.to_sections_end;
 647        sect++)
 648     {
 649       flagword flags;
 650
 651       flags = bfd_get_section_flags (exec_bfd, sect->the_bfd_section);
 652
 653       if (flags & SEC_CODE)
 654         {
 655           sect->addr += text_off;
 656           sect->endaddr += text_off;
 657         }
 658       else if (flags & (SEC_DATA | SEC_LOAD))
 659         {
 660           sect->addr += data_off;
 661           sect->endaddr += data_off;
 662         }
 663       else if (flags & SEC_ALLOC)
 664         {
 665           sect->addr += bss_off;
 666           sect->endaddr += bss_off;
 667         }
 668     }
 669 }
 670
 671 static void
 672 set_section_command (args, from_tty)
 673      char *args;
 674      int from_tty;
 675 {
 676   struct section_table *p;
 677   char *secname;
 678   unsigned seclen;
 679   unsigned long secaddr;
 680   char secprint[100];
 681   long offset;
 682
 683   if (args == 0)
 684     error ("Must specify section name and its virtual address");
 685
 686   /* Parse out section name */
 687   for (secname = args; !isspace (*args); args++);
 688   seclen = args - secname;
 689
 690   /* Parse out new virtual address */
 691   secaddr = parse_and_eval_address (args);
 692
 693   for (p = exec_ops.to_sections; p < exec_ops.to_sections_end; p++)
 694     {
 695       if (!strncmp (secname, bfd_section_name (exec_bfd, p->the_bfd_section), seclen)
 696           && bfd_section_name (exec_bfd, p->the_bfd_section)[seclen] == '\0')
 697         {
 698           offset = secaddr - p->addr;
 699           p->addr += offset;
 700           p->endaddr += offset;
 701           if (from_tty)
 702             exec_files_info (&exec_ops);
 703           return;
 704         }
 705     }
 706   if (seclen >= sizeof (secprint))
 707     seclen = sizeof (secprint) - 1;
 708   strncpy (secprint, secname, seclen);
 709   secprint[seclen] = '\0';
 710   error ("Section %s not found", secprint);
 711 }
 712
 713 /* If mourn is being called in all the right places, this could be say
 714    `gdb internal error' (since generic_mourn calls
 715    breakpoint_init_inferior).  */
 716
 717 static int
 718 ignore (addr, contents)
 719      CORE_ADDR addr;
 720      char *contents;
 721 {
 722   return 0;
 723 }
 724
 725 /* Fill in the exec file target vector.  Very few entries need to be
 726    defined.  */
 727
 728 void
 729 init_exec_ops ()
 730 {
 731   exec_ops.to_shortname = "exec";
 732   exec_ops.to_longname = "Local exec file";
 733   exec_ops.to_doc = "Use an executable file as a target.\n\
 734 Specify the filename of the executable file.";
 735   exec_ops.to_open = exec_file_command;
 736   exec_ops.to_close = exec_close;
 737   exec_ops.to_attach = find_default_attach;
 738   exec_ops.to_require_attach = find_default_require_attach;
 739   exec_ops.to_require_detach = find_default_require_detach;
 740   exec_ops.to_xfer_memory = xfer_memory;
 741   exec_ops.to_files_info = exec_files_info;
 742   exec_ops.to_insert_breakpoint = ignore;
 743   exec_ops.to_remove_breakpoint = ignore;
 744   exec_ops.to_create_inferior = find_default_create_inferior;
 745   exec_ops.to_clone_and_follow_inferior = find_default_clone_and_follow_inferior;
 746   exec_ops.to_stratum = file_stratum;
 747   exec_ops.to_has_memory = 1;
 748   exec_ops.to_magic = OPS_MAGIC;
 749 }
 750
 751 void
 752 _initialize_exec ()
 753 {
 754   struct cmd_list_element *c;
 755
 756   init_exec_ops ();
 757
 758   if (!dbx_commands)
 759     {
 760       c = add_cmd ("file", class_files, file_command,
 761                    "Use FILE as program to be debugged.\n\
 762 It is read for its symbols, for getting the contents of pure memory,\n\
 763 and it is the program executed when you use the `run' command.\n\
 764 If FILE cannot be found as specified, your execution directory path\n\
 765 ($PATH) is searched for a command of that name.\n\
 766 No arg means to have no executable file and no symbols.", &cmdlist);
 767       c->completer = filename_completer;
 768     }
 769
 770   c = add_cmd ("exec-file", class_files, exec_file_command,
 771                "Use FILE as program for getting contents of pure memory.\n\
 772 If FILE cannot be found as specified, your execution directory path\n\
 773 is searched for a command of that name.\n\
 774 No arg means have no executable file.", &cmdlist);
 775   c->completer = filename_completer;
 776
 777   add_com ("section", class_files, set_section_command,
 778            "Change the base address of section SECTION of the exec file to ADDR.\n\
 779 This can be used if the exec file does not contain section addresses,\n\
 780 (such as in the a.out format), or when the addresses specified in the\n\
 781 file itself are wrong.  Each section must be changed separately.  The\n\
 782 ``info files'' command lists all the sections and their addresses.");
 783
 784   add_show_from_set
 785     (add_set_cmd ("write", class_support, var_boolean, (char *) &write_files,
 786                   "Set writing into executable and core files.",
 787                   &setlist),
 788      &showlist);
 789
 790   add_target (&exec_ops);
 791 }