gdb/exec.c

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