1 /* Execute AIXcoff files, for GDB.
2 Copyright 1988, 1989, 1991, 1992 Free Software Foundation, Inc.
3 Derived from exec.c. Modified by IBM Corporation.
4 Donated by IBM Corporation and Cygnus Support.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
22 /* xcoff-exec - deal with executing XCOFF files. */
25 #include <sys/types.h>
26 #include <sys/param.h>
41 #include "libbfd.h" /* BFD internals (sigh!) FIXME */
43 /* Prototypes for local functions */
46 file_command
PARAMS ((char *, int));
49 exec_close
PARAMS ((int));
51 struct section_table
*exec_sections
, *exec_sections_end
;
53 #define eq(s0, s1) !strcmp(s0, s1)
55 /* Whether to open exec and core files read-only or read-write. */
59 extern int info_verbose
;
61 bfd
*exec_bfd
; /* needed by core.c */
63 extern char *getenv();
64 extern void child_create_inferior (), child_attach ();
65 extern void add_syms_addr_command ();
66 extern void symbol_file_command ();
67 static void exec_files_info();
68 extern struct objfile
*lookup_objfile_bfd ();
71 * the vmap struct is used to describe the virtual address space of
72 * the target we are manipulating. The first entry is always the "exec"
73 * file. Subsequent entries correspond to other objects that are
74 * mapped into the address space of a process created from the "exec" file.
75 * These are either in response to exec()ing the file, in which case all
76 * shared libraries are loaded, or a "load" system call, followed by the
77 * user's issuance of a "load" command.
80 struct vmap
*nxt
; /* ^ to next in chain */
81 bfd
*bfd
; /* BFD for mappable object library */
82 char *name
; /* ^ to object file name */
83 char *member
; /* ^ to member name */
84 CORE_ADDR tstart
; /* virtual addr where member is mapped */
85 CORE_ADDR tend
; /* virtual upper bound of member */
86 CORE_ADDR tadj
; /* heuristically derived adjustment */
87 CORE_ADDR dstart
; /* virtual address of data start */
88 CORE_ADDR dend
; /* vitrual address of data end */
97 static struct vmap
*vmap
; /* current vmap */
99 extern struct target_ops exec_ops
;
102 /* exec_close - done with exec file, clean up all resources. */
107 register struct vmap
*vp
, *nxt
;
110 for (nxt
= vmap
; vp
= nxt
; )
114 /* if there is an objfile associated with this bfd,
115 free_objfile() will do proper cleanup of objfile *and* bfd. */
117 if (obj
= lookup_objfile_bfd (vp
->bfd
))
122 free_named_symtabs(vp
->name
);
131 * exec_file_command - handle the "exec" command, &c.
134 exec_file_command(filename
, from_tty
)
139 target_preopen(from_tty
);
140 unpush_target(&exec_ops
);
142 /* Now open and digest the file the user requested, if any. */
145 char *scratch_pathname
;
148 filename
= tilde_expand(filename
);
149 make_cleanup (free
, filename
);
151 scratch_chan
= openp(getenv("PATH"), 1, filename
, O_RDONLY
, 0
152 , &scratch_pathname
);
153 if (scratch_chan
< 0)
154 perror_with_name(filename
);
156 bfd
= bfd_fdopenr(scratch_pathname
, NULL
, scratch_chan
);
158 error("Could not open `%s' as an executable file: %s"
159 , scratch_pathname
, bfd_errmsg(bfd_error
));
161 /* make sure we have an object file */
163 if (!bfd_check_format(bfd
, bfd_object
))
164 error("\"%s\": not in executable format: %s."
165 , scratch_pathname
, bfd_errmsg(bfd_error
));
168 /* setup initial vmap */
172 error("Can't find the file sections in `%s': %s"
173 , bfd
->filename
, bfd_errmsg(bfd_error
));
177 if (build_section_table (exec_bfd
, &exec_sections
, &exec_sections_end
))
178 error ("Can't find the file sections in `%s': %s",
179 exec_bfd
->filename
, bfd_errmsg (bfd_error
));
181 /* make sure core, if present, matches */
184 push_target(&exec_ops
);
186 /* Tell display code(if any) about the changed file name. */
188 if (exec_file_display_hook
)
189 (*exec_file_display_hook
)(filename
);
192 exec_close(0); /* just in case */
194 printf("No exec file now.\n");
198 /* Set both the exec file and the symbol file, in one command. What a
199 * novelty. Why did GDB go through four major releases before this
203 file_command(arg
, from_tty
)
206 exec_file_command(arg
, from_tty
);
207 symbol_file_command(arg
, from_tty
);
210 /* Locate all mappable sections of a BFD file.
211 table_pp_char is a char * to get it through bfd_map_over_sections;
212 we cast it back to its proper type. */
215 add_to_section_table (abfd
, asect
, table_pp_char
)
220 struct section_table
**table_pp
= (struct section_table
**)table_pp_char
;
223 aflag
= bfd_get_section_flags (abfd
, asect
);
224 /* FIXME, we need to handle BSS segment here...it alloc's but doesn't load */
225 if (!(aflag
& SEC_LOAD
))
227 (*table_pp
)->sec_ptr
= asect
;
228 (*table_pp
)->addr
= bfd_section_vma (abfd
, asect
);
229 (*table_pp
)->endaddr
= (*table_pp
)->addr
+ bfd_section_size (abfd
, asect
);
234 build_section_table (some_bfd
, start
, end
)
236 struct section_table
**start
, **end
;
240 count
= bfd_count_sections (some_bfd
);
242 abort(); /* return 1? */
245 *start
= (struct section_table
*) xmalloc (count
* sizeof (**start
));
247 bfd_map_over_sections (some_bfd
, add_to_section_table
, (char *)end
);
248 if (*end
> *start
+ count
)
250 /* We could realloc the table, but it probably loses for most files. */
255 * lookup_symtab_bfd - find if we currently have any symbol tables from bfd
258 lookup_objfile_bfd(bfd
*bfd
) {
259 register struct objfile
*s
;
261 for (s
= object_files
; s
; s
= s
->next
)
269 sex_to_vmap(bfd
*bf
, sec_ptr sex
, struct vmap_and_bfd
*vmap_bfd
)
271 register struct vmap
*vp
, **vpp
;
272 register struct symtab
*syms
;
273 bfd
*arch
= vmap_bfd
->pbfd
;
274 vp
= vmap_bfd
->pvmap
;
276 if ((bfd_get_section_flags(bf
, sex
) & SEC_LOAD
) == 0)
279 if (!strcmp(bfd_section_name(bf
, sex
), ".text")) {
281 vp
->tend
= vp
->tstart
+ bfd_section_size(bf
, sex
);
283 /* This is quite a tacky way to recognize the `exec' load segment (rather
284 than shared libraries. You should use `arch' instead. FIXMEmgo */
286 vp
->tadj
= sex
->filepos
- bfd_section_vma(bf
, sex
);
291 else if (!strcmp(bfd_section_name(bf
, sex
), ".data")) {
293 vp
->dend
= vp
->dstart
+ bfd_section_size(bf
, sex
);
296 else if (!strcmp(bfd_section_name(bf
, sex
), ".bss")) /* FIXMEmgo */
297 printf ("bss section in exec! Don't know what the heck to do!\n");
300 /* Make a vmap for the BFD "bf", which might be a member of the archive
301 BFD "arch". If we have not yet read in symbols for this file, do so. */
303 map_vmap (bfd
*bf
, bfd
*arch
)
305 struct vmap_and_bfd vmap_bfd
;
306 struct vmap
*vp
, **vpp
;
309 vp
= (void*) xmalloc (sizeof (*vp
));
312 vp
->name
= bfd_get_filename(arch
? arch
: bf
);
313 vp
->member
= arch
? bfd_get_filename(bf
) : "";
315 vmap_bfd
.pbfd
= arch
;
317 bfd_map_over_sections (bf
, sex_to_vmap
, &vmap_bfd
);
319 obj
= lookup_objfile_bfd (bf
);
320 if (exec_bfd
&& !obj
) {
321 obj
= allocate_objfile (bf
, bfd_get_filename (bf
), 0);
322 syms_from_objfile (obj
, 0, 0, 0);
325 /* find the end of the list, and append. */
326 for (vpp
= &vmap
; *vpp
; vpp
= &(*vpp
)->nxt
)
331 /* Called via iterate_over_msymbols to relocate minimal symbols */
334 relocate_minimal_symbol (objfile
, msymbol
, arg1
, arg2
, arg3
)
335 struct objfile
*objfile
;
336 struct minimal_symbol
*msymbol
;
341 if (msymbol
->address
< TEXT_SEGMENT_BASE
)
342 msymbol
-> address
+= (int) arg1
;
345 /* true, if symbol table and minimal symbol table are relocated. */
347 int symtab_relocated
= 0;
350 /* vmap_symtab - handle symbol translation on vmapping */
352 vmap_symtab(vp
, old_start
, vip
)
353 register struct vmap
*vp
;
357 register struct symtab
*s
;
358 register struct objfile
*objfile
;
361 * for each symbol table generated from the vp->bfd
363 for (objfile
= object_files
; objfile
!= NULL
; objfile
= objfile
-> next
)
365 for (s
= objfile
-> symtabs
; s
!= NULL
; s
= s
-> next
) {
367 /* skip over if this is not relocatable and doesn't have a line table */
368 if (s
->nonreloc
&& !LINETABLE (s
))
371 /* matching the symbol table's BFD and the *vp's BFD is hairy.
372 exec_file creates a seperate BFD for possibly the
373 same file as symbol_file.FIXME ALL THIS MUST BE RECTIFIED. */
375 if (objfile
->obfd
== vp
->bfd
) {
376 /* if they match, we luck out. */
378 } else if (vp
->member
[0]) {
379 /* no match, and member present, not this one. */
386 * no match, and no member. need to be sure.
388 io
= bfd_cache_lookup(objfile
->obfd
);
390 fatal("cannot find BFD's iostream for sym");
392 * see if we are referring to the same file
394 if (fstat(fileno(io
), &si
) < 0)
395 fatal("cannot fstat BFD for sym");
397 if (si
.st_dev
!= vip
->st_dev
398 || si
.st_ino
!= vip
->st_ino
)
402 if (vp
->tstart
!= old_start
)
403 vmap_symtab_1(s
, vp
, old_start
);
406 if (vp
->tstart
!= old_start
) {
407 iterate_over_msymbols (relocate_minimal_symbol
,
408 (PTR
) (vp
->tstart
- old_start
),
409 (PTR
) NULL
, (PTR
) NULL
);
411 /* breakpoints need to be relocated as well. */
412 fixup_breakpoints (0, TEXT_SEGMENT_BASE
, vp
->tstart
- old_start
);
415 symtab_relocated
= 1;
418 vmap_symtab_1(s
, vp
, old_start
)
419 register struct symtab
*s
;
420 register struct vmap
*vp
;
425 register struct linetable
*l
;
426 struct blockvector
*bv
;
427 register struct block
*b
;
429 register ulong reloc
, dreloc
;
431 if ((reloc
= vp
->tstart
- old_start
) == 0)
434 dreloc
= vp
->dstart
; /* data relocation */
437 * The line table must be relocated. This is only present for
438 * .text sections, so only vp->text type maps need be considered.
443 for (i
= 0; i
< len
; i
++)
444 l
->item
[i
].pc
+= reloc
;
447 /* if this symbol table is not relocatable, only line table should
448 be relocated and the rest ignored. */
453 len
= BLOCKVECTOR_NBLOCKS(bv
);
455 for (i
= 0; i
< len
; i
++) {
456 b
= BLOCKVECTOR_BLOCK(bv
, i
);
458 BLOCK_START(b
) += reloc
;
459 BLOCK_END(b
) += reloc
;
461 blen
= BLOCK_NSYMS(b
);
462 for (j
= 0; j
< blen
; j
++) {
463 register struct symbol
*sym
;
465 sym
= BLOCK_SYM(b
, j
);
466 switch (SYMBOL_NAMESPACE(sym
)) {
467 case STRUCT_NAMESPACE
:
468 case UNDEF_NAMESPACE
:
471 case LABEL_NAMESPACE
:
476 switch (SYMBOL_CLASS(sym
)) {
478 case LOC_CONST_BYTES
:
492 SYMBOL_VALUE_ADDRESS(sym
) += reloc
;
496 SYMBOL_VALUE_ADDRESS(sym
) += dreloc
;
503 fatal("botched symbol class %x"
504 , SYMBOL_CLASS(sym
));
512 * add_vmap - add a new vmap entry based on ldinfo() information
515 register struct ld_info
*ldi
; {
519 mem
= ldi
->ldinfo_filename
+ strlen(ldi
->ldinfo_filename
) + 1;
520 bfd
= bfd_fdopenr(ldi
->ldinfo_filename
, NULL
, ldi
->ldinfo_fd
);
522 error("Could not open `%s' as an executable file: %s"
523 , ldi
->ldinfo_filename
, bfd_errmsg(bfd_error
));
526 /* make sure we have an object file */
528 if (bfd_check_format(bfd
, bfd_object
))
531 else if (bfd_check_format(bfd
, bfd_archive
)) {
534 * FIXME??? am I tossing BFDs? bfd?
536 while (last
= bfd_openr_next_archived_file(bfd
, last
))
537 if (eq(mem
, last
->filename
))
542 /* FIXME -- should be error */
543 warning("\"%s\": member \"%s\" missing.",
548 if (!bfd_check_format(last
, bfd_object
)) {
549 bfd_close(last
); /* XXX??? */
553 map_vmap (last
, bfd
);
559 /* FIXME -- bfd doesn't recognize /lib/libc.a as an archive */
560 /* FIXME -- should be error */
561 warning("\"%s\": not in executable format: %s."
562 , ldi
->ldinfo_filename
, bfd_errmsg(bfd_error
));
569 /* As well as symbol tables, exec_sections need relocation. Otherwise after
570 the inferior process terminates, symbol table is relocated but there is
571 no inferior process. Thus, we have to use `exec' bfd, rather than the inferior
572 process's memory space, when lookipng at symbols.
573 `exec_sections' need to be relocated only once though, as long as the exec
574 file was not changed.
579 if (execbfd
== exec_bfd
)
584 if (!vmap
|| !exec_sections
) {
585 printf ("WARNING: vmap not found in vmap_exec()!\n");
588 /* First exec section is `.text', second is `.data'. If this is changed,
589 then this routine will choke. Better you should check section names,
591 exec_sections
[0].addr
+= vmap
->tstart
;
592 exec_sections
[0].endaddr
+= vmap
->tstart
;
593 exec_sections
[1].addr
+= vmap
->dstart
;
594 exec_sections
[1].endaddr
+= vmap
->dstart
;
599 text_adjustment (abfd
)
603 static int adjustment
;
606 if (exec_bfd
== execbfd
)
609 sect
= bfd_get_section_by_name (abfd
, ".text");
611 adjustment
= sect
->filepos
- sect
->vma
;
613 adjustment
= 0x200; /* just a wild assumption */
620 * vmap_ldinfo - update VMAP info with ldinfo() information
623 * ldi - ^ to ldinfo() results.
626 register struct ld_info
*ldi
;
629 register struct vmap
*vp
;
630 register got_one
, retried
;
634 * for each *ldi, see if we have a corresponding *vp
635 * if so, update the mapping, and symbol table.
636 * if not, add an entry and symbol table.
639 char *name
= ldi
->ldinfo_filename
;
640 char *memb
= name
+ strlen(name
) + 1;
644 if (fstat(ldi
->ldinfo_fd
, &ii
) < 0)
645 fatal("cannot fstat(%d) on %s"
649 for (got_one
= 0, vp
= vmap
; vp
; vp
= vp
->nxt
) {
652 /* The filenames are not always sufficient to match on. */
654 && !eq(name
, vp
->name
))
655 || (memb
[0] && !eq(memb
, vp
->member
)))
658 /* totally opaque! */
659 io
= bfd_cache_lookup(vp
->bfd
);
661 fatal("cannot find BFD's iostream for %s"
664 /* see if we are referring to the same file */
665 if (fstat(fileno(io
), &vi
) < 0)
666 fatal("cannot fstat BFD for %s", vp
->name
);
668 if (ii
.st_dev
!= vi
.st_dev
|| ii
.st_ino
!= vi
.st_ino
)
672 close(ldi
->ldinfo_fd
);
676 /* found a corresponding VMAP. remap! */
679 vp
->tstart
= ldi
->ldinfo_textorg
;
680 vp
->tend
= vp
->tstart
+ ldi
->ldinfo_textsize
;
681 vp
->dstart
= ldi
->ldinfo_dataorg
;
682 vp
->dend
= vp
->dstart
+ ldi
->ldinfo_datasize
;
685 vp
->tstart
+= vp
->tadj
;
686 vp
->tend
+= vp
->tadj
;
689 /* relocate symbol table(s). */
690 vmap_symtab(vp
, ostart
, &vi
);
692 /* there may be more, so we don't break out of the loop. */
696 * if there was no matching *vp, we must perforce create
699 if (!got_one
&& !retried
) {
704 } while (ldi
->ldinfo_next
705 && (ldi
= (void *) (ldi
->ldinfo_next
+ (char *) ldi
)));
710 * vmap_inferior - print VMAP info for inferior
714 if (inferior_pid
== 0)
715 return 0; /* normal processing */
722 /* Read or write the exec file.
724 Args are address within exec file, address within gdb address-space,
725 length, and a flag indicating whether to read or write.
729 0: We cannot handle this address and length.
730 > 0: We have handled N bytes starting at this address.
731 (If N == length, we did it all.) We might be able
732 to handle more bytes beyond this length, but no
734 < 0: We cannot handle this address, but if somebody
735 else handles (-N) bytes, we can start from there.
737 The same routine is used to handle both core and exec files;
738 we just tail-call it with more arguments to select between them. */
741 xfer_memory (memaddr
, myaddr
, len
, write
, target
)
746 struct target_ops
*target
;
749 struct section_table
*p
;
750 CORE_ADDR nextsectaddr
, memend
;
751 boolean (*xfer_fn
) PARAMS ((bfd
*, sec_ptr
, PTR
, file_ptr
, bfd_size_type
));
756 memend
= memaddr
+ len
;
757 xfer_fn
= write
? bfd_set_section_contents
: bfd_get_section_contents
;
758 nextsectaddr
= memend
;
760 for (p
= target
->to_sections
; p
< target
->to_sections_end
; p
++)
762 if (p
->addr
<= memaddr
)
763 if (p
->endaddr
>= memend
)
765 /* Entire transfer is within this section. */
766 res
= xfer_fn (p
->bfd
, p
->sec_ptr
, myaddr
, memaddr
- p
->addr
, len
);
767 return (res
!= false)? len
: 0;
769 else if (p
->endaddr
<= memaddr
)
771 /* This section ends before the transfer starts. */
776 /* This section overlaps the transfer. Just do half. */
777 len
= p
->endaddr
- memaddr
;
778 res
= xfer_fn (p
->bfd
, p
->sec_ptr
, myaddr
, memaddr
- p
->addr
, len
);
779 return (res
!= false)? len
: 0;
781 else if (p
->addr
< nextsectaddr
)
782 nextsectaddr
= p
->addr
;
785 if (nextsectaddr
>= memend
)
786 return 0; /* We can't help */
788 return - (nextsectaddr
- memaddr
); /* Next boundary where we can help */
792 print_section_info (t
, abfd
)
793 struct target_ops
*t
;
797 struct section_table
*p
;
799 printf_filtered ("\t`%s', ", bfd_get_filename(abfd
));
801 printf_filtered ("file type %s.\n", bfd_get_target(abfd
));
803 for (p
= t
->to_sections
; p
< t
->to_sections_end
; p
++) {
804 printf_filtered ("\t%s", local_hex_string_custom (p
->addr
, "08"));
805 printf_filtered (" - %s", local_hex_string_custom (p
->endaddr
, "08"));
807 printf_filtered (" @ %s",
808 local_hex_string_custom (p
->sec_ptr
->filepos
, "08"));
809 printf_filtered (" is %s", bfd_section_name (p
->bfd
, p
->sec_ptr
));
810 if (p
->bfd
!= abfd
) {
811 printf_filtered (" in %s", bfd_get_filename (p
->bfd
));
813 printf_filtered ("\n");
816 register struct vmap
*vp
= vmap
;
821 printf("\tMapping info for file `%s'.\n", vp
->name
);
822 printf("\t %8.8s %8.8s %8.8s %s\n"
823 , "start", "end", "section", "file(member)");
825 for (; vp
; vp
= vp
->nxt
)
826 printf("\t0x%8.8x 0x%8.8x %s%s%s%s\n"
830 , *vp
->member
? "(" : ""
832 , *vp
->member
? ")" : "");
838 struct target_ops
*t
;
840 print_section_info (t
, exec_bfd
);
844 /* Damon's implementation of set_section_command! It is based on the sex member
845 (which is a section pointer from vmap) of vmap.
846 We will not have multiple vmap entries (one for each section), rather transmit
847 text and data base offsets and fix them at the same time. Elimination of sex
848 entry in vmap make this function obsolute, use the one from exec.c.
849 Need further testing!! FIXMEmgo. */
852 set_section_command(args
, from_tty
)
855 register struct vmap
*vp
= vmap
;
858 unsigned long secaddr
;
863 error("Must specify section name and its virtual address");
865 /* Parse out section name */
866 for (secname
= args
; !isspace(*args
); args
++)
868 seclen
= args
- secname
;
870 /* Parse out new virtual address */
871 secaddr
= parse_and_eval_address(args
);
873 for (vp
= vmap
; vp
; vp
= vp
->nxt
) {
875 , bfd_section_name(vp
->bfd
, vp
->sex
), seclen
)
876 && bfd_section_name(vp
->bfd
, vp
->sex
)[seclen
] == '\0') {
877 offset
= secaddr
- vp
->tstart
;
878 vp
->tstart
+= offset
;
885 if (seclen
>= sizeof(secprint
))
886 seclen
= sizeof(secprint
) - 1;
887 strncpy(secprint
, secname
, seclen
);
888 secprint
[seclen
] = '\0';
889 error("Section %s not found", secprint
);
893 set_section_command (args
, from_tty
)
897 struct section_table
*p
;
900 unsigned long secaddr
;
905 error ("Must specify section name and its virtual address");
907 /* Parse out section name */
908 for (secname
= args
; !isspace(*args
); args
++) ;
909 seclen
= args
- secname
;
911 /* Parse out new virtual address */
912 secaddr
= parse_and_eval_address (args
);
914 for (p
= exec_sections
; p
< exec_sections_end
; p
++) {
915 if (!strncmp (secname
, bfd_section_name (exec_bfd
, p
->sec_ptr
), seclen
)
916 && bfd_section_name (exec_bfd
, p
->sec_ptr
)[seclen
] == '\0') {
917 offset
= secaddr
- p
->addr
;
919 p
->endaddr
+= offset
;
924 if (seclen
>= sizeof (secprint
))
925 seclen
= sizeof (secprint
) - 1;
926 strncpy (secprint
, secname
, seclen
);
927 secprint
[seclen
] = '\0';
928 error ("Section %s not found", secprint
);
933 struct target_ops exec_ops
= {
934 "exec", "Local exec file",
935 "Use an executable file as a target.\n\
936 Specify the filename of the executable file.",
937 exec_file_command
, exec_close
, /* open, close */
938 child_attach
, 0, 0, 0, /* attach, detach, resume, wait, */
939 0, 0, /* fetch_registers, store_registers, */
940 0, 0, 0, /* prepare_to_store, conv_to, conv_from, */
941 xfer_memory
, exec_files_info
,
942 0, 0, /* insert_breakpoint, remove_breakpoint, */
943 0, 0, 0, 0, 0, /* terminal stuff */
944 0, 0, /* kill, load */
946 child_create_inferior
,
947 0, /* mourn_inferior */
948 file_stratum
, 0, /* next */
949 0, 1, 0, 0, 0, /* all mem, mem, stack, regs, exec */
950 0, 0, /* section pointers */
951 OPS_MAGIC
, /* Always the last thing */
959 add_com("file", class_files
, file_command
,
960 "Use FILE as program to be debugged.\n\
961 It is read for its symbols, for getting the contents of pure memory,\n\
962 and it is the program executed when you use the `run' command.\n\
963 If FILE cannot be found as specified, your execution directory path\n\
964 ($PATH) is searched for a command of that name.\n\
965 No arg means to have no executable file and no symbols.");
967 add_com("exec-file", class_files
, exec_file_command
,
968 "Use FILE as program for getting contents of pure memory.\n\
969 If FILE cannot be found as specified, your execution directory path\n\
970 is searched for a command of that name.\n\
971 No arg means have no executable file.");
973 add_com("section", class_files
, set_section_command
,
974 "Change the base address of section SECTION of the exec file to ADDR.\n\
975 This can be used if the exec file does not contain section addresses,\n\
976 (such as in the a.out format), or when the addresses specified in the\n\
977 file itself are wrong. Each section must be changed separately. The\n\
978 ``info files'' command lists all the sections and their addresses.");
980 add_target(&exec_ops
);
This page took 0.070885 seconds and 5 git commands to generate.