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 executable 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 = xstrdup (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   target_preopen (from_tty);
 319   exec_file_attach (args, from_tty);
 320 }
 321
 322 /* Set both the exec file and the symbol file, in one command.
 323    What a novelty.  Why did GDB go through four major releases before this
 324    command was added?  */
 325
 326 static void
 327 file_command (arg, from_tty)
 328      char *arg;
 329      int from_tty;
 330 {
 331   /* FIXME, if we lose on reading the symbol file, we should revert
 332      the exec file, but that's rough.  */
 333   exec_file_command (arg, from_tty);
 334   symbol_file_command (arg, from_tty);
 335   if (file_changed_hook)
 336     file_changed_hook (arg);
 337 }
 338 \f
 339
 340 /* Locate all mappable sections of a BFD file.
 341    table_pp_char is a char * to get it through bfd_map_over_sections;
 342    we cast it back to its proper type.  */
 343
 344 static void
 345 add_to_section_table (abfd, asect, table_pp_char)
 346      bfd *abfd;
 347      sec_ptr asect;
 348      PTR table_pp_char;
 349 {
 350   struct section_table **table_pp = (struct section_table **) table_pp_char;
 351   flagword aflag;
 352
 353   aflag = bfd_get_section_flags (abfd, asect);
 354   if (!(aflag & SEC_ALLOC))
 355     return;
 356   if (0 == bfd_section_size (abfd, asect))
 357     return;
 358   (*table_pp)->bfd = abfd;
 359   (*table_pp)->the_bfd_section = asect;
 360   (*table_pp)->addr = bfd_section_vma (abfd, asect);
 361   (*table_pp)->endaddr = (*table_pp)->addr + bfd_section_size (abfd, asect);
 362   (*table_pp)++;
 363 }
 364
 365 /* Builds a section table, given args BFD, SECTABLE_PTR, SECEND_PTR.
 366    Returns 0 if OK, 1 on error.  */
 367
 368 int
 369 build_section_table (some_bfd, start, end)
 370      bfd *some_bfd;
 371      struct section_table **start, **end;
 372 {
 373   unsigned count;
 374
 375   count = bfd_count_sections (some_bfd);
 376   if (*start)
 377     free ((PTR) * start);
 378   *start = (struct section_table *) xmalloc (count * sizeof (**start));
 379   *end = *start;
 380   bfd_map_over_sections (some_bfd, add_to_section_table, (char *) end);
 381   if (*end > *start + count)
 382     abort ();
 383   /* We could realloc the table, but it probably loses for most files.  */
 384   return 0;
 385 }
 386 \f
 387 static void
 388 bfdsec_to_vmap (abfd, sect, arg3)
 389      bfd *abfd;
 390      sec_ptr sect;
 391      PTR arg3;
 392 {
 393   struct vmap_and_bfd *vmap_bfd = (struct vmap_and_bfd *) arg3;
 394   struct vmap *vp;
 395
 396   vp = vmap_bfd->pvmap;
 397
 398   if ((bfd_get_section_flags (abfd, sect) & SEC_LOAD) == 0)
 399     return;
 400
 401   if (STREQ (bfd_section_name (abfd, sect), ".text"))
 402     {
 403       vp->tstart = bfd_section_vma (abfd, sect);
 404       vp->tend = vp->tstart + bfd_section_size (abfd, sect);
 405       vp->tvma = bfd_section_vma (abfd, sect);
 406       vp->toffs = sect->filepos;
 407     }
 408   else if (STREQ (bfd_section_name (abfd, sect), ".data"))
 409     {
 410       vp->dstart = bfd_section_vma (abfd, sect);
 411       vp->dend = vp->dstart + bfd_section_size (abfd, sect);
 412       vp->dvma = bfd_section_vma (abfd, sect);
 413     }
 414   /* Silently ignore other types of sections. (FIXME?)  */
 415 }
 416
 417 /* Make a vmap for ABFD which might be a member of the archive ARCH.
 418    Return the new vmap.  */
 419
 420 struct vmap *
 421 map_vmap (abfd, arch)
 422      bfd *abfd;
 423      bfd *arch;
 424 {
 425   struct vmap_and_bfd vmap_bfd;
 426   struct vmap *vp, **vpp;
 427
 428   vp = (struct vmap *) xmalloc (sizeof (*vp));
 429   memset ((char *) vp, '\0', sizeof (*vp));
 430   vp->nxt = 0;
 431   vp->bfd = abfd;
 432   vp->name = bfd_get_filename (arch ? arch : abfd);
 433   vp->member = arch ? bfd_get_filename (abfd) : "";
 434
 435   vmap_bfd.pbfd = arch;
 436   vmap_bfd.pvmap = vp;
 437   bfd_map_over_sections (abfd, bfdsec_to_vmap, &vmap_bfd);
 438
 439   /* Find the end of the list and append. */
 440   for (vpp = &vmap; *vpp; vpp = &(*vpp)->nxt)
 441     ;
 442   *vpp = vp;
 443
 444   return vp;
 445 }
 446 \f
 447 /* Read or write the exec file.
 448
 449    Args are address within a BFD file, address within gdb address-space,
 450    length, and a flag indicating whether to read or write.
 451
 452    Result is a length:
 453
 454    0:    We cannot handle this address and length.
 455    > 0:  We have handled N bytes starting at this address.
 456    (If N == length, we did it all.)  We might be able
 457    to handle more bytes beyond this length, but no
 458    promises.
 459    < 0:  We cannot handle this address, but if somebody
 460    else handles (-N) bytes, we can start from there.
 461
 462    The same routine is used to handle both core and exec files;
 463    we just tail-call it with more arguments to select between them.  */
 464
 465 int
 466 xfer_memory (memaddr, myaddr, len, write, target)
 467      CORE_ADDR memaddr;
 468      char *myaddr;
 469      int len;
 470      int write;
 471      struct target_ops *target;
 472 {
 473   boolean res;
 474   struct section_table *p;
 475   CORE_ADDR nextsectaddr, memend;
 476   boolean (*xfer_fn) PARAMS ((bfd *, sec_ptr, PTR, file_ptr, bfd_size_type));
 477   asection *section;
 478
 479   if (len <= 0)
 480     abort ();
 481
 482   if (overlay_debugging)
 483     {
 484       section = find_pc_overlay (memaddr);
 485       if (pc_in_unmapped_range (memaddr, section))
 486         memaddr = overlay_mapped_address (memaddr, section);
 487     }
 488
 489   memend = memaddr + len;
 490   xfer_fn = write ? bfd_set_section_contents : bfd_get_section_contents;
 491   nextsectaddr = memend;
 492
 493 #if 0                           /* Stu's implementation */
 494 /* If a section has been specified, try to use it.  Note that we cannot use the
 495    specified section directly.  This is because it usually comes from the
 496    symbol file, which may be different from the exec or core file.  Instead, we
 497    have to lookup the specified section by name in the bfd associated with
 498    to_sections.  */
 499
 500   if (target_memory_bfd_section)
 501     {
 502       asection *s;
 503       bfd *abfd;
 504       asection *target_section;
 505       bfd *target_bfd;
 506
 507       s = target_memory_bfd_section;
 508       abfd = s->owner;
 509
 510       target_bfd = target->to_sections->bfd;
 511       target_section = bfd_get_section_by_name (target_bfd, bfd_section_name (abfd, s));
 512
 513       if (target_section)
 514         {
 515           bfd_vma sec_addr;
 516           bfd_size_type sec_size;
 517
 518           sec_addr = bfd_section_vma (target_bfd, target_section);
 519           sec_size = target_section->_raw_size;
 520
 521           /* Make sure the requested memory starts inside the section.  */
 522
 523           if (memaddr >= sec_addr
 524               && memaddr < sec_addr + sec_size)
 525             {
 526               /* Cut back length in case request overflows the end of the section. */
 527               len = min (len, sec_addr + sec_size - memaddr);
 528
 529               res = xfer_fn (target_bfd, target_section, myaddr, memaddr - sec_addr, len);
 530
 531               return res ? len : 0;
 532             }
 533         }
 534     }
 535 #endif /* 0, Stu's implementation */
 536   for (p = target->to_sections; p < target->to_sections_end; p++)
 537     {
 538       if (overlay_debugging && section && p->the_bfd_section &&
 539           strcmp (section->name, p->the_bfd_section->name) != 0)
 540         continue;               /* not the section we need */
 541       if (memaddr >= p->addr)
 542         if (memend <= p->endaddr)
 543           {
 544             /* Entire transfer is within this section.  */
 545             res = xfer_fn (p->bfd, p->the_bfd_section, myaddr,
 546                            memaddr - p->addr, len);
 547             return (res != 0) ? len : 0;
 548           }
 549         else if (memaddr >= p->endaddr)
 550           {
 551             /* This section ends before the transfer starts.  */
 552             continue;
 553           }
 554         else
 555           {
 556             /* This section overlaps the transfer.  Just do half.  */
 557             len = p->endaddr - memaddr;
 558             res = xfer_fn (p->bfd, p->the_bfd_section, myaddr,
 559                            memaddr - p->addr, len);
 560             return (res != 0) ? len : 0;
 561           }
 562       else
 563         nextsectaddr = min (nextsectaddr, p->addr);
 564     }
 565
 566   if (nextsectaddr >= memend)
 567     return 0;                   /* We can't help */
 568   else
 569     return -(nextsectaddr - memaddr);   /* Next boundary where we can help */
 570 }
 571 \f
 572
 573 void
 574 print_section_info (t, abfd)
 575      struct target_ops *t;
 576      bfd *abfd;
 577 {
 578   struct section_table *p;
 579
 580   printf_filtered ("\t`%s', ", bfd_get_filename (abfd));
 581   wrap_here ("        ");
 582   printf_filtered ("file type %s.\n", bfd_get_target (abfd));
 583   if (abfd == exec_bfd)
 584     {
 585       printf_filtered ("\tEntry point: ");
 586       print_address_numeric (bfd_get_start_address (abfd), 1, gdb_stdout);
 587       printf_filtered ("\n");
 588     }
 589   for (p = t->to_sections; p < t->to_sections_end; p++)
 590     {
 591       /* FIXME-32x64 need a print_address_numeric with field width */
 592       printf_filtered ("\t%s", local_hex_string_custom ((unsigned long) p->addr, "08l"));
 593       printf_filtered (" - %s", local_hex_string_custom ((unsigned long) p->endaddr, "08l"));
 594       if (info_verbose)
 595         printf_filtered (" @ %s",
 596                          local_hex_string_custom ((unsigned long) p->the_bfd_section->filepos, "08l"));
 597       printf_filtered (" is %s", bfd_section_name (p->bfd, p->the_bfd_section));
 598       if (p->bfd != abfd)
 599         {
 600           printf_filtered (" in %s", bfd_get_filename (p->bfd));
 601         }
 602       printf_filtered ("\n");
 603     }
 604 }
 605
 606 static void
 607 exec_files_info (t)
 608      struct target_ops *t;
 609 {
 610   print_section_info (t, exec_bfd);
 611
 612   if (vmap)
 613     {
 614       struct vmap *vp;
 615
 616       printf_unfiltered ("\tMapping info for file `%s'.\n", vmap->name);
 617       printf_unfiltered ("\t  %*s   %*s   %*s   %*s %8.8s %s\n",
 618                          strlen_paddr (), "tstart",
 619                          strlen_paddr (), "tend",
 620                          strlen_paddr (), "dstart",
 621                          strlen_paddr (), "dend",
 622                          "section",
 623                          "file(member)");
 624
 625       for (vp = vmap; vp; vp = vp->nxt)
 626         printf_unfiltered ("\t0x%s 0x%s 0x%s 0x%s %s%s%s%s\n",
 627                            paddr (vp->tstart),
 628                            paddr (vp->tend),
 629                            paddr (vp->dstart),
 630                            paddr (vp->dend),
 631                            vp->name,
 632                            *vp->member ? "(" : "", vp->member,
 633                            *vp->member ? ")" : "");
 634     }
 635 }
 636
 637 /* msnyder 5/21/99:
 638    exec_set_section_offsets sets the offsets of all the sections
 639    in the exec objfile.  */
 640
 641 void
 642 exec_set_section_offsets (text_off, data_off, bss_off)
 643      bfd_signed_vma text_off;
 644      bfd_signed_vma data_off;
 645      bfd_signed_vma bss_off;
 646 {
 647   struct section_table *sect;
 648
 649   for (sect = exec_ops.to_sections;
 650        sect < exec_ops.to_sections_end;
 651        sect++)
 652     {
 653       flagword flags;
 654
 655       flags = bfd_get_section_flags (exec_bfd, sect->the_bfd_section);
 656
 657       if (flags & SEC_CODE)
 658         {
 659           sect->addr += text_off;
 660           sect->endaddr += text_off;
 661         }
 662       else if (flags & (SEC_DATA | SEC_LOAD))
 663         {
 664           sect->addr += data_off;
 665           sect->endaddr += data_off;
 666         }
 667       else if (flags & SEC_ALLOC)
 668         {
 669           sect->addr += bss_off;
 670           sect->endaddr += bss_off;
 671         }
 672     }
 673 }
 674
 675 static void
 676 set_section_command (args, from_tty)
 677      char *args;
 678      int from_tty;
 679 {
 680   struct section_table *p;
 681   char *secname;
 682   unsigned seclen;
 683   unsigned long secaddr;
 684   char secprint[100];
 685   long offset;
 686
 687   if (args == 0)
 688     error ("Must specify section name and its virtual address");
 689
 690   /* Parse out section name */
 691   for (secname = args; !isspace (*args); args++);
 692   seclen = args - secname;
 693
 694   /* Parse out new virtual address */
 695   secaddr = parse_and_eval_address (args);
 696
 697   for (p = exec_ops.to_sections; p < exec_ops.to_sections_end; p++)
 698     {
 699       if (!strncmp (secname, bfd_section_name (exec_bfd, p->the_bfd_section), seclen)
 700           && bfd_section_name (exec_bfd, p->the_bfd_section)[seclen] == '\0')
 701         {
 702           offset = secaddr - p->addr;
 703           p->addr += offset;
 704           p->endaddr += offset;
 705           if (from_tty)
 706             exec_files_info (&exec_ops);
 707           return;
 708         }
 709     }
 710   if (seclen >= sizeof (secprint))
 711     seclen = sizeof (secprint) - 1;
 712   strncpy (secprint, secname, seclen);
 713   secprint[seclen] = '\0';
 714   error ("Section %s not found", secprint);
 715 }
 716
 717 /* If mourn is being called in all the right places, this could be say
 718    `gdb internal error' (since generic_mourn calls
 719    breakpoint_init_inferior).  */
 720
 721 static int
 722 ignore (addr, contents)
 723      CORE_ADDR addr;
 724      char *contents;
 725 {
 726   return 0;
 727 }
 728
 729 /* Fill in the exec file target vector.  Very few entries need to be
 730    defined.  */
 731
 732 void
 733 init_exec_ops ()
 734 {
 735   exec_ops.to_shortname = "exec";
 736   exec_ops.to_longname = "Local exec file";
 737   exec_ops.to_doc = "Use an executable file as a target.\n\
 738 Specify the filename of the executable file.";
 739   exec_ops.to_open = exec_file_command;
 740   exec_ops.to_close = exec_close;
 741   exec_ops.to_attach = find_default_attach;
 742   exec_ops.to_require_attach = find_default_require_attach;
 743   exec_ops.to_require_detach = find_default_require_detach;
 744   exec_ops.to_xfer_memory = xfer_memory;
 745   exec_ops.to_files_info = exec_files_info;
 746   exec_ops.to_insert_breakpoint = ignore;
 747   exec_ops.to_remove_breakpoint = ignore;
 748   exec_ops.to_create_inferior = find_default_create_inferior;
 749   exec_ops.to_clone_and_follow_inferior = find_default_clone_and_follow_inferior;
 750   exec_ops.to_stratum = file_stratum;
 751   exec_ops.to_has_memory = 1;
 752   exec_ops.to_magic = OPS_MAGIC;
 753 }
 754
 755 void
 756 _initialize_exec ()
 757 {
 758   struct cmd_list_element *c;
 759
 760   init_exec_ops ();
 761
 762   if (!dbx_commands)
 763     {
 764       c = add_cmd ("file", class_files, file_command,
 765                    "Use FILE as program to be debugged.\n\
 766 It is read for its symbols, for getting the contents of pure memory,\n\
 767 and it is the program executed when you use the `run' command.\n\
 768 If FILE cannot be found as specified, your execution directory path\n\
 769 ($PATH) is searched for a command of that name.\n\
 770 No arg means to have no executable file and no symbols.", &cmdlist);
 771       c->completer = filename_completer;
 772     }
 773
 774   c = add_cmd ("exec-file", class_files, exec_file_command,
 775                "Use FILE as program for getting contents of pure memory.\n\
 776 If FILE cannot be found as specified, your execution directory path\n\
 777 is searched for a command of that name.\n\
 778 No arg means have no executable file.", &cmdlist);
 779   c->completer = filename_completer;
 780
 781   add_com ("section", class_files, set_section_command,
 782            "Change the base address of section SECTION of the exec file to ADDR.\n\
 783 This can be used if the exec file does not contain section addresses,\n\
 784 (such as in the a.out format), or when the addresses specified in the\n\
 785 file itself are wrong.  Each section must be changed separately.  The\n\
 786 ``info files'' command lists all the sections and their addresses.");
 787
 788   add_show_from_set
 789     (add_set_cmd ("write", class_support, var_boolean, (char *) &write_files,
 790                   "Set writing into executable and core files.",
 791                   &setlist),
 792      &showlist);
 793
 794   add_target (&exec_ops);
 795 }