1 /* Work with executable files, for GDB.
3 Copyright (C) 1988-2003, 2007-2012 Free Software Foundation, Inc.
5 This file is part of GDB.
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 3 of the License, or
10 (at your option) any later version.
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.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
26 #include "filenames.h"
29 #include "completer.h"
33 #include "arch-utils.h"
34 #include "gdbthread.h"
35 #include "progspace.h"
39 #include "readline/readline.h"
40 #include "gdb_string.h"
47 #include "xcoffsolib.h"
49 struct vmap
*map_vmap (bfd
*, bfd
*);
51 void (*deprecated_file_changed_hook
) (char *);
53 /* Prototypes for local functions */
55 static void file_command (char *, int);
57 static void set_section_command (char *, int);
59 static void exec_files_info (struct target_ops
*);
61 static void init_exec_ops (void);
63 void _initialize_exec (void);
65 /* The target vector for executable files. */
67 struct target_ops exec_ops
;
69 /* True if the exec target is pushed on the stack. */
70 static int using_exec_ops
;
72 /* Whether to open exec and core files read-only or read-write. */
76 show_write_files (struct ui_file
*file
, int from_tty
,
77 struct cmd_list_element
*c
, const char *value
)
79 fprintf_filtered (file
, _("Writing into executable and core files is %s.\n"),
87 exec_open (char *args
, int from_tty
)
89 target_preopen (from_tty
);
90 exec_file_attach (args
, from_tty
);
93 /* Close and clear exec_bfd. If we end up with no target sections to
94 read memory from, this unpushes the exec_ops target. */
101 bfd
*abfd
= exec_bfd
;
103 gdb_bfd_unref (abfd
);
105 /* Removing target sections may close the exec_ops target.
106 Clear exec_bfd before doing so to prevent recursion. */
110 remove_target_sections (abfd
);
114 /* This is the target_close implementation. Clears all target
115 sections and closes all executable bfds from all program spaces. */
118 exec_close_1 (int quitting
)
120 int need_symtab_cleanup
= 0;
121 struct vmap
*vp
, *nxt
;
125 for (nxt
= vmap
; nxt
!= NULL
;)
130 /* if there is an objfile associated with this bfd,
131 free_objfile() will do proper cleanup of objfile *and* bfd. */
135 free_objfile (vp
->objfile
);
136 need_symtab_cleanup
= 1;
138 else if (vp
->bfd
!= exec_bfd
)
139 gdb_bfd_unref (vp
->bfd
);
147 struct program_space
*ss
;
148 struct cleanup
*old_chain
;
150 old_chain
= save_current_program_space ();
153 set_current_program_space (ss
);
155 /* Delete all target sections. */
157 (current_target_sections
,
158 -resize_section_table (current_target_sections
, 0));
163 do_cleanups (old_chain
);
168 exec_file_clear (int from_tty
)
170 /* Remove exec file. */
174 printf_unfiltered (_("No executable file now.\n"));
177 /* Set FILENAME as the new exec file.
179 This function is intended to be behave essentially the same
180 as exec_file_command, except that the latter will detect when
181 a target is being debugged, and will ask the user whether it
182 should be shut down first. (If the answer is "no", then the
183 new file is ignored.)
185 This file is used by exec_file_command, to do the work of opening
186 and processing the exec file after any prompting has happened.
188 And, it is used by child_attach, when the attach command was
189 given a pid but not a exec pathname, and the attach command could
190 figure out the pathname from the pid. (In this case, we shouldn't
191 ask the user whether the current target should be shut down --
192 we're supplying the exec pathname late for good reason.) */
195 exec_file_attach (char *filename
, int from_tty
)
197 /* Remove any previous exec file. */
200 /* Now open and digest the file the user requested, if any. */
205 printf_unfiltered (_("No executable file now.\n"));
207 set_gdbarch_from_file (NULL
);
211 struct cleanup
*cleanups
;
212 char *scratch_pathname
;
214 struct target_section
*sections
= NULL
, *sections_end
= NULL
;
217 scratch_chan
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
, filename
,
218 write_files
? O_RDWR
| O_BINARY
: O_RDONLY
| O_BINARY
,
220 #if defined(__GO32__) || defined(_WIN32) || defined(__CYGWIN__)
221 if (scratch_chan
< 0)
223 char *exename
= alloca (strlen (filename
) + 5);
225 strcat (strcpy (exename
, filename
), ".exe");
226 scratch_chan
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
, exename
,
227 write_files
? O_RDWR
| O_BINARY
: O_RDONLY
| O_BINARY
,
232 cleanups
= make_cleanup (xfree
, scratch_pathname
);
234 if (scratch_chan
< 0)
235 perror_with_name (filename
);
236 exec_bfd
= gdb_bfd_ref (bfd_fopen (scratch_pathname
, gnutarget
,
237 write_files
? FOPEN_RUB
: FOPEN_RB
,
242 error (_("\"%s\": could not open as an executable file: %s"),
243 scratch_pathname
, bfd_errmsg (bfd_get_error ()));
246 if (!bfd_check_format_matches (exec_bfd
, bfd_object
, &matching
))
248 /* Make sure to close exec_bfd, or else "run" might try to use
251 error (_("\"%s\": not in executable format: %s"),
253 gdb_bfd_errmsg (bfd_get_error (), matching
));
256 gdb_bfd_stash_filename (exec_bfd
);
258 /* FIXME - This should only be run for RS6000, but the ifdef is a poor
259 way to accomplish. */
260 #ifdef DEPRECATED_IBM6000_TARGET
261 /* Setup initial vmap. */
263 map_vmap (exec_bfd
, 0);
266 /* Make sure to close exec_bfd, or else "run" might try to use
269 error (_("\"%s\": can't find the file sections: %s"),
270 scratch_pathname
, bfd_errmsg (bfd_get_error ()));
272 #endif /* DEPRECATED_IBM6000_TARGET */
274 if (build_section_table (exec_bfd
, §ions
, §ions_end
))
276 /* Make sure to close exec_bfd, or else "run" might try to use
279 error (_("\"%s\": can't find the file sections: %s"),
280 scratch_pathname
, bfd_errmsg (bfd_get_error ()));
283 exec_bfd_mtime
= bfd_get_mtime (exec_bfd
);
287 set_gdbarch_from_file (exec_bfd
);
289 /* Add the executable's sections to the current address spaces'
290 list of sections. This possibly pushes the exec_ops
292 add_target_sections (sections
, sections_end
);
295 /* Tell display code (if any) about the changed file name. */
296 if (deprecated_exec_file_display_hook
)
297 (*deprecated_exec_file_display_hook
) (filename
);
299 do_cleanups (cleanups
);
301 bfd_cache_close_all ();
302 observer_notify_executable_changed ();
305 /* Process the first arg in ARGS as the new exec file.
307 Note that we have to explicitly ignore additional args, since we can
308 be called from file_command(), which also calls symbol_file_command()
309 which can take multiple args.
311 If ARGS is NULL, we just want to close the exec file. */
314 exec_file_command (char *args
, int from_tty
)
319 if (from_tty
&& target_has_execution
320 && !query (_("A program is being debugged already.\n"
321 "Are you sure you want to change the file? ")))
322 error (_("File not changed."));
326 struct cleanup
*cleanups
;
328 /* Scan through the args and pick up the first non option arg
331 argv
= gdb_buildargv (args
);
332 cleanups
= make_cleanup_freeargv (argv
);
334 for (; (*argv
!= NULL
) && (**argv
== '-'); argv
++)
338 error (_("No executable file name was specified"));
340 filename
= tilde_expand (*argv
);
341 make_cleanup (xfree
, filename
);
342 exec_file_attach (filename
, from_tty
);
344 do_cleanups (cleanups
);
347 exec_file_attach (NULL
, from_tty
);
350 /* Set both the exec file and the symbol file, in one command.
351 What a novelty. Why did GDB go through four major releases before this
352 command was added? */
355 file_command (char *arg
, int from_tty
)
357 /* FIXME, if we lose on reading the symbol file, we should revert
358 the exec file, but that's rough. */
359 exec_file_command (arg
, from_tty
);
360 symbol_file_command (arg
, from_tty
);
361 if (deprecated_file_changed_hook
)
362 deprecated_file_changed_hook (arg
);
366 /* Locate all mappable sections of a BFD file.
367 table_pp_char is a char * to get it through bfd_map_over_sections;
368 we cast it back to its proper type. */
371 add_to_section_table (bfd
*abfd
, struct bfd_section
*asect
,
374 struct target_section
**table_pp
= (struct target_section
**) table_pp_char
;
377 /* Check the section flags, but do not discard zero-length sections, since
378 some symbols may still be attached to this section. For instance, we
379 encountered on sparc-solaris 2.10 a shared library with an empty .bss
380 section to which a symbol named "_end" was attached. The address
381 of this symbol still needs to be relocated. */
382 aflag
= bfd_get_section_flags (abfd
, asect
);
383 if (!(aflag
& SEC_ALLOC
))
386 (*table_pp
)->bfd
= abfd
;
387 (*table_pp
)->the_bfd_section
= asect
;
388 (*table_pp
)->addr
= bfd_section_vma (abfd
, asect
);
389 (*table_pp
)->endaddr
= (*table_pp
)->addr
+ bfd_section_size (abfd
, asect
);
394 resize_section_table (struct target_section_table
*table
, int num_added
)
396 struct target_section
*old_value
;
400 old_value
= table
->sections
;
401 old_count
= table
->sections_end
- table
->sections
;
403 new_count
= num_added
+ old_count
;
407 table
->sections
= xrealloc (table
->sections
,
408 sizeof (struct target_section
) * new_count
);
409 table
->sections_end
= table
->sections
+ new_count
;
413 xfree (table
->sections
);
414 table
->sections
= table
->sections_end
= NULL
;
420 /* Builds a section table, given args BFD, SECTABLE_PTR, SECEND_PTR.
421 Returns 0 if OK, 1 on error. */
424 build_section_table (struct bfd
*some_bfd
, struct target_section
**start
,
425 struct target_section
**end
)
429 count
= bfd_count_sections (some_bfd
);
432 *start
= (struct target_section
*) xmalloc (count
* sizeof (**start
));
434 bfd_map_over_sections (some_bfd
, add_to_section_table
, (char *) end
);
435 if (*end
> *start
+ count
)
436 internal_error (__FILE__
, __LINE__
,
437 _("failed internal consistency check"));
438 /* We could realloc the table, but it probably loses for most files. */
442 /* Add the sections array defined by [SECTIONS..SECTIONS_END[ to the
443 current set of target sections. */
446 add_target_sections (struct target_section
*sections
,
447 struct target_section
*sections_end
)
450 struct target_section_table
*table
= current_target_sections
;
452 count
= sections_end
- sections
;
456 int space
= resize_section_table (table
, count
);
458 memcpy (table
->sections
+ space
,
459 sections
, count
* sizeof (sections
[0]));
461 /* If these are the first file sections we can provide memory
462 from, push the file_stratum target. */
466 push_target (&exec_ops
);
471 /* Remove all target sections taken from ABFD. */
474 remove_target_sections (bfd
*abfd
)
476 struct target_section
*src
, *dest
;
477 struct target_section_table
*table
= current_target_sections
;
479 dest
= table
->sections
;
480 for (src
= table
->sections
; src
< table
->sections_end
; src
++)
481 if (src
->bfd
!= abfd
)
483 /* Keep this section. */
489 /* If we've dropped any sections, resize the section table. */
494 old_count
= resize_section_table (table
, dest
- src
);
496 /* If we don't have any more sections to read memory from,
497 remove the file_stratum target from the stack. */
498 if (old_count
+ (dest
- src
) == 0)
500 struct program_space
*pspace
;
503 if (pspace
->target_sections
.sections
504 != pspace
->target_sections
.sections_end
)
507 unpush_target (&exec_ops
);
514 bfdsec_to_vmap (struct bfd
*abfd
, struct bfd_section
*sect
, void *arg3
)
516 struct vmap_and_bfd
*vmap_bfd
= (struct vmap_and_bfd
*) arg3
;
519 vp
= vmap_bfd
->pvmap
;
521 if ((bfd_get_section_flags (abfd
, sect
) & SEC_LOAD
) == 0)
524 if (strcmp (bfd_section_name (abfd
, sect
), ".text") == 0)
526 vp
->tstart
= bfd_section_vma (abfd
, sect
);
527 vp
->tend
= vp
->tstart
+ bfd_section_size (abfd
, sect
);
528 vp
->tvma
= bfd_section_vma (abfd
, sect
);
529 vp
->toffs
= sect
->filepos
;
531 else if (strcmp (bfd_section_name (abfd
, sect
), ".data") == 0)
533 vp
->dstart
= bfd_section_vma (abfd
, sect
);
534 vp
->dend
= vp
->dstart
+ bfd_section_size (abfd
, sect
);
535 vp
->dvma
= bfd_section_vma (abfd
, sect
);
537 /* Silently ignore other types of sections. (FIXME?) */
540 /* Make a vmap for ABFD which might be a member of the archive ARCH.
541 Return the new vmap. */
544 map_vmap (bfd
*abfd
, bfd
*arch
)
546 struct vmap_and_bfd vmap_bfd
;
547 struct vmap
*vp
, **vpp
;
549 vp
= (struct vmap
*) xmalloc (sizeof (*vp
));
550 memset ((char *) vp
, '\0', sizeof (*vp
));
553 vp
->name
= bfd_get_filename (arch
? arch
: abfd
);
554 vp
->member
= arch
? bfd_get_filename (abfd
) : "";
556 vmap_bfd
.pbfd
= arch
;
558 bfd_map_over_sections (abfd
, bfdsec_to_vmap
, &vmap_bfd
);
560 /* Find the end of the list and append. */
561 for (vpp
= &vmap
; *vpp
; vpp
= &(*vpp
)->nxt
)
570 section_table_available_memory (VEC(mem_range_s
) *memory
,
571 CORE_ADDR memaddr
, ULONGEST len
,
572 struct target_section
*sections
,
573 struct target_section
*sections_end
)
575 struct target_section
*p
;
577 for (p
= sections
; p
< sections_end
; p
++)
579 if ((bfd_get_section_flags (p
->bfd
, p
->the_bfd_section
)
580 & SEC_READONLY
) == 0)
583 /* Copy the meta-data, adjusted. */
584 if (mem_ranges_overlap (p
->addr
, p
->endaddr
- p
->addr
, memaddr
, len
))
586 ULONGEST lo1
, hi1
, lo2
, hi2
;
595 r
= VEC_safe_push (mem_range_s
, memory
, NULL
);
597 r
->start
= max (lo1
, lo2
);
598 r
->length
= min (hi1
, hi2
) - r
->start
;
606 section_table_xfer_memory_partial (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
607 ULONGEST offset
, LONGEST len
,
608 struct target_section
*sections
,
609 struct target_section
*sections_end
,
610 const char *section_name
)
613 struct target_section
*p
;
614 ULONGEST memaddr
= offset
;
615 ULONGEST memend
= memaddr
+ len
;
618 internal_error (__FILE__
, __LINE__
,
619 _("failed internal consistency check"));
621 for (p
= sections
; p
< sections_end
; p
++)
623 if (section_name
&& strcmp (section_name
, p
->the_bfd_section
->name
) != 0)
624 continue; /* not the section we need. */
625 if (memaddr
>= p
->addr
)
627 if (memend
<= p
->endaddr
)
629 /* Entire transfer is within this section. */
631 res
= bfd_set_section_contents (p
->bfd
, p
->the_bfd_section
,
632 writebuf
, memaddr
- p
->addr
,
635 res
= bfd_get_section_contents (p
->bfd
, p
->the_bfd_section
,
636 readbuf
, memaddr
- p
->addr
,
638 return (res
!= 0) ? len
: 0;
640 else if (memaddr
>= p
->endaddr
)
642 /* This section ends before the transfer starts. */
647 /* This section overlaps the transfer. Just do half. */
648 len
= p
->endaddr
- memaddr
;
650 res
= bfd_set_section_contents (p
->bfd
, p
->the_bfd_section
,
651 writebuf
, memaddr
- p
->addr
,
654 res
= bfd_get_section_contents (p
->bfd
, p
->the_bfd_section
,
655 readbuf
, memaddr
- p
->addr
,
657 return (res
!= 0) ? len
: 0;
662 return 0; /* We can't help. */
665 static struct target_section_table
*
666 exec_get_section_table (struct target_ops
*ops
)
668 return current_target_sections
;
672 exec_xfer_partial (struct target_ops
*ops
, enum target_object object
,
673 const char *annex
, gdb_byte
*readbuf
,
674 const gdb_byte
*writebuf
,
675 ULONGEST offset
, LONGEST len
)
677 struct target_section_table
*table
= target_get_section_table (ops
);
679 if (object
== TARGET_OBJECT_MEMORY
)
680 return section_table_xfer_memory_partial (readbuf
, writebuf
,
691 print_section_info (struct target_section_table
*t
, bfd
*abfd
)
693 struct gdbarch
*gdbarch
= gdbarch_from_bfd (abfd
);
694 struct target_section
*p
;
695 /* FIXME: 16 is not wide enough when gdbarch_addr_bit > 64. */
696 int wid
= gdbarch_addr_bit (gdbarch
) <= 32 ? 8 : 16;
698 printf_filtered ("\t`%s', ", bfd_get_filename (abfd
));
700 printf_filtered (_("file type %s.\n"), bfd_get_target (abfd
));
701 if (abfd
== exec_bfd
)
703 /* gcc-3.4 does not like the initialization in
704 <p == t->sections_end>. */
705 bfd_vma displacement
= 0;
708 for (p
= t
->sections
; p
< t
->sections_end
; p
++)
710 asection
*asect
= p
->the_bfd_section
;
712 if ((bfd_get_section_flags (abfd
, asect
) & (SEC_ALLOC
| SEC_LOAD
))
713 != (SEC_ALLOC
| SEC_LOAD
))
716 if (bfd_get_section_vma (abfd
, asect
) <= abfd
->start_address
717 && abfd
->start_address
< (bfd_get_section_vma (abfd
, asect
)
718 + bfd_get_section_size (asect
)))
720 displacement
= p
->addr
- bfd_get_section_vma (abfd
, asect
);
724 if (p
== t
->sections_end
)
725 warning (_("Cannot find section for the entry point of %s."),
726 bfd_get_filename (abfd
));
728 entry_point
= gdbarch_addr_bits_remove (gdbarch
,
729 bfd_get_start_address (abfd
)
731 printf_filtered (_("\tEntry point: %s\n"),
732 paddress (gdbarch
, entry_point
));
734 for (p
= t
->sections
; p
< t
->sections_end
; p
++)
736 printf_filtered ("\t%s", hex_string_custom (p
->addr
, wid
));
737 printf_filtered (" - %s", hex_string_custom (p
->endaddr
, wid
));
739 /* FIXME: A format of "08l" is not wide enough for file offsets
740 larger than 4GB. OTOH, making it "016l" isn't desirable either
741 since most output will then be much wider than necessary. It
742 may make sense to test the size of the file and choose the
743 format string accordingly. */
744 /* FIXME: i18n: Need to rewrite this sentence. */
746 printf_filtered (" @ %s",
747 hex_string_custom (p
->the_bfd_section
->filepos
, 8));
748 printf_filtered (" is %s", bfd_section_name (p
->bfd
,
749 p
->the_bfd_section
));
751 printf_filtered (" in %s", bfd_get_filename (p
->bfd
));
752 printf_filtered ("\n");
757 exec_files_info (struct target_ops
*t
)
760 print_section_info (current_target_sections
, exec_bfd
);
762 puts_filtered (_("\t<no file loaded>\n"));
766 int addr_size
= gdbarch_addr_bit (target_gdbarch
) / 8;
769 printf_unfiltered (_("\tMapping info for file `%s'.\n"), vmap
->name
);
770 printf_unfiltered ("\t %*s %*s %*s %*s %8.8s %s\n",
771 addr_size
* 2, "tstart",
772 addr_size
* 2, "tend",
773 addr_size
* 2, "dstart",
774 addr_size
* 2, "dend",
778 for (vp
= vmap
; vp
; vp
= vp
->nxt
)
779 printf_unfiltered ("\t0x%s 0x%s 0x%s 0x%s %s%s%s%s\n",
780 phex (vp
->tstart
, addr_size
),
781 phex (vp
->tend
, addr_size
),
782 phex (vp
->dstart
, addr_size
),
783 phex (vp
->dend
, addr_size
),
785 *vp
->member
? "(" : "", vp
->member
,
786 *vp
->member
? ")" : "");
791 set_section_command (char *args
, int from_tty
)
793 struct target_section
*p
;
796 unsigned long secaddr
;
799 struct target_section_table
*table
;
802 error (_("Must specify section name and its virtual address"));
804 /* Parse out section name. */
805 for (secname
= args
; !isspace (*args
); args
++);
806 seclen
= args
- secname
;
808 /* Parse out new virtual address. */
809 secaddr
= parse_and_eval_address (args
);
811 table
= current_target_sections
;
812 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
814 if (!strncmp (secname
, bfd_section_name (p
->bfd
,
815 p
->the_bfd_section
), seclen
)
816 && bfd_section_name (p
->bfd
, p
->the_bfd_section
)[seclen
] == '\0')
818 offset
= secaddr
- p
->addr
;
820 p
->endaddr
+= offset
;
822 exec_files_info (&exec_ops
);
826 if (seclen
>= sizeof (secprint
))
827 seclen
= sizeof (secprint
) - 1;
828 strncpy (secprint
, secname
, seclen
);
829 secprint
[seclen
] = '\0';
830 error (_("Section %s not found"), secprint
);
833 /* If we can find a section in FILENAME with BFD index INDEX, adjust
837 exec_set_section_address (const char *filename
, int index
, CORE_ADDR address
)
839 struct target_section
*p
;
840 struct target_section_table
*table
;
842 table
= current_target_sections
;
843 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
845 if (filename_cmp (filename
, p
->bfd
->filename
) == 0
846 && index
== p
->the_bfd_section
->index
)
848 p
->endaddr
+= address
- p
->addr
;
854 /* If mourn is being called in all the right places, this could be say
855 `gdb internal error' (since generic_mourn calls
856 breakpoint_init_inferior). */
859 ignore (struct gdbarch
*gdbarch
, struct bp_target_info
*bp_tgt
)
865 exec_has_memory (struct target_ops
*ops
)
867 /* We can provide memory if we have any file/target sections to read
869 return (current_target_sections
->sections
870 != current_target_sections
->sections_end
);
873 /* Find mapped memory. */
876 exec_set_find_memory_regions (int (*func
) (find_memory_region_ftype
, void *))
878 exec_ops
.to_find_memory_regions
= func
;
881 static char *exec_make_note_section (bfd
*, int *);
883 /* Fill in the exec file target vector. Very few entries need to be
889 exec_ops
.to_shortname
= "exec";
890 exec_ops
.to_longname
= "Local exec file";
891 exec_ops
.to_doc
= "Use an executable file as a target.\n\
892 Specify the filename of the executable file.";
893 exec_ops
.to_open
= exec_open
;
894 exec_ops
.to_close
= exec_close_1
;
895 exec_ops
.to_attach
= find_default_attach
;
896 exec_ops
.to_xfer_partial
= exec_xfer_partial
;
897 exec_ops
.to_get_section_table
= exec_get_section_table
;
898 exec_ops
.to_files_info
= exec_files_info
;
899 exec_ops
.to_insert_breakpoint
= ignore
;
900 exec_ops
.to_remove_breakpoint
= ignore
;
901 exec_ops
.to_create_inferior
= find_default_create_inferior
;
902 exec_ops
.to_stratum
= file_stratum
;
903 exec_ops
.to_has_memory
= exec_has_memory
;
904 exec_ops
.to_make_corefile_notes
= exec_make_note_section
;
905 exec_ops
.to_magic
= OPS_MAGIC
;
909 _initialize_exec (void)
911 struct cmd_list_element
*c
;
917 c
= add_cmd ("file", class_files
, file_command
, _("\
918 Use FILE as program to be debugged.\n\
919 It is read for its symbols, for getting the contents of pure memory,\n\
920 and it is the program executed when you use the `run' command.\n\
921 If FILE cannot be found as specified, your execution directory path\n\
922 ($PATH) is searched for a command of that name.\n\
923 No arg means to have no executable file and no symbols."), &cmdlist
);
924 set_cmd_completer (c
, filename_completer
);
927 c
= add_cmd ("exec-file", class_files
, exec_file_command
, _("\
928 Use FILE as program for getting contents of pure memory.\n\
929 If FILE cannot be found as specified, your execution directory path\n\
930 is searched for a command of that name.\n\
931 No arg means have no executable file."), &cmdlist
);
932 set_cmd_completer (c
, filename_completer
);
934 add_com ("section", class_files
, set_section_command
, _("\
935 Change the base address of section SECTION of the exec file to ADDR.\n\
936 This can be used if the exec file does not contain section addresses,\n\
937 (such as in the a.out format), or when the addresses specified in the\n\
938 file itself are wrong. Each section must be changed separately. The\n\
939 ``info files'' command lists all the sections and their addresses."));
941 add_setshow_boolean_cmd ("write", class_support
, &write_files
, _("\
942 Set writing into executable and core files."), _("\
943 Show writing into executable and core files."), NULL
,
946 &setlist
, &showlist
);
948 add_target (&exec_ops
);
952 exec_make_note_section (bfd
*obfd
, int *note_size
)
954 error (_("Can't create a corefile"));