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. */
26 #include <sys/types.h>
27 #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
);
129 bfd_close (exec_bfd
);
132 if (exec_ops
.to_sections
) {
133 free (exec_ops
.to_sections
);
134 exec_ops
.to_sections
= NULL
;
135 exec_ops
.to_sections_end
= NULL
;
140 * exec_file_command - handle the "exec" command, &c.
143 exec_file_command(filename
, from_tty
)
146 target_preopen(from_tty
);
148 /* Remove any previous exec file. */
149 unpush_target(&exec_ops
);
151 /* Now open and digest the file the user requested, if any. */
154 char *scratch_pathname
;
157 filename
= tilde_expand(filename
);
158 make_cleanup (free
, filename
);
160 scratch_chan
= openp(getenv("PATH"), 1, filename
,
161 write_files
? O_RDWR
: O_RDONLY
, 0,
163 if (scratch_chan
< 0)
164 perror_with_name(filename
);
166 exec_bfd
= bfd_fdopenr(scratch_pathname
, NULL
, scratch_chan
);
168 error("Could not open `%s' as an executable file: %s"
169 , scratch_pathname
, bfd_errmsg(bfd_error
));
171 /* make sure we have an object file */
173 if (!bfd_check_format(exec_bfd
, bfd_object
))
174 error("\"%s\": not in executable format: %s.",
175 scratch_pathname
, bfd_errmsg(bfd_error
));
178 /* setup initial vmap */
180 map_vmap (exec_bfd
, 0);
182 error("Can't find the file sections in `%s': %s",
183 exec_bfd
->filename
, bfd_errmsg(bfd_error
));
185 if (build_section_table (exec_bfd
, &exec_ops
.to_sections
,
186 &exec_ops
.to_sections_end
))
187 error ("Can't find the file sections in `%s': %s",
188 exec_bfd
->filename
, bfd_errmsg (bfd_error
));
190 /* make sure core, if present, matches */
193 push_target(&exec_ops
);
195 /* Tell display code(if any) about the changed file name. */
197 if (exec_file_display_hook
)
198 (*exec_file_display_hook
)(filename
);
201 exec_close(0); /* just in case */
203 printf("No exec file now.\n");
207 /* Set both the exec file and the symbol file, in one command. What a
208 * novelty. Why did GDB go through four major releases before this
212 file_command(arg
, from_tty
)
215 exec_file_command(arg
, from_tty
);
216 symbol_file_command(arg
, from_tty
);
219 /* Locate all mappable sections of a BFD file.
220 table_pp_char is a char * to get it through bfd_map_over_sections;
221 we cast it back to its proper type. */
224 add_to_section_table (abfd
, asect
, table_pp_char
)
229 struct section_table
**table_pp
= (struct section_table
**)table_pp_char
;
232 aflag
= bfd_get_section_flags (abfd
, asect
);
233 /* FIXME, we need to handle BSS segment here...it alloc's but doesn't load */
234 if (!(aflag
& SEC_LOAD
))
236 if (0 == bfd_section_size (abfd
, asect
))
238 (*table_pp
)->bfd
= abfd
;
239 (*table_pp
)->sec_ptr
= asect
;
240 (*table_pp
)->addr
= bfd_section_vma (abfd
, asect
);
241 (*table_pp
)->endaddr
= (*table_pp
)->addr
+ bfd_section_size (abfd
, asect
);
246 build_section_table (some_bfd
, start
, end
)
248 struct section_table
**start
, **end
;
252 count
= bfd_count_sections (some_bfd
);
254 abort(); /* return 1? */
257 *start
= (struct section_table
*) xmalloc (count
* sizeof (**start
));
259 bfd_map_over_sections (some_bfd
, add_to_section_table
, (char *)end
);
260 if (*end
> *start
+ count
)
262 /* We could realloc the table, but it probably loses for most files. */
267 * lookup_symtab_bfd - find if we currently have any symbol tables from bfd
270 lookup_objfile_bfd(bfd
*bfd
) {
271 register struct objfile
*s
;
273 for (s
= object_files
; s
; s
= s
->next
)
281 sex_to_vmap(bfd
*bf
, sec_ptr sex
, struct vmap_and_bfd
*vmap_bfd
)
283 register struct vmap
*vp
, **vpp
;
284 register struct symtab
*syms
;
285 bfd
*arch
= vmap_bfd
->pbfd
;
286 vp
= vmap_bfd
->pvmap
;
288 if ((bfd_get_section_flags(bf
, sex
) & SEC_LOAD
) == 0)
291 if (!strcmp(bfd_section_name(bf
, sex
), ".text")) {
293 vp
->tend
= vp
->tstart
+ bfd_section_size(bf
, sex
);
295 /* When it comes to this adjustment value, in contrast to our previous
296 belief shared objects should behave the same as the main load segment.
297 This is the offset from the beginning of text section to the first
300 vp
->tadj
= sex
->filepos
- bfd_section_vma(bf
, sex
);
303 else if (!strcmp(bfd_section_name(bf
, sex
), ".data")) {
305 vp
->dend
= vp
->dstart
+ bfd_section_size(bf
, sex
);
308 else if (!strcmp(bfd_section_name(bf
, sex
), ".bss")) /* FIXMEmgo */
309 printf ("bss section in exec! Don't know what the heck to do!\n");
312 /* Make a vmap for the BFD "bf", which might be a member of the archive
313 BFD "arch". If we have not yet read in symbols for this file, do so. */
315 map_vmap (bfd
*bf
, bfd
*arch
)
317 struct vmap_and_bfd vmap_bfd
;
318 struct vmap
*vp
, **vpp
;
321 vp
= (void*) xmalloc (sizeof (*vp
));
324 vp
->name
= bfd_get_filename(arch
? arch
: bf
);
325 vp
->member
= arch
? bfd_get_filename(bf
) : "";
327 vmap_bfd
.pbfd
= arch
;
329 bfd_map_over_sections (bf
, sex_to_vmap
, &vmap_bfd
);
331 obj
= lookup_objfile_bfd (bf
);
332 if (exec_bfd
&& !obj
) {
333 obj
= allocate_objfile (bf
, 0);
334 syms_from_objfile (obj
, 0, 0, 0);
337 /* find the end of the list, and append. */
338 for (vpp
= &vmap
; *vpp
; vpp
= &(*vpp
)->nxt
)
344 #define FASTER_MSYMBOL_RELOCATION 1
346 #ifdef FASTER_MSYMBOL_RELOCATION
348 /* Used to relocate an object file's minimal symbols. */
351 reloc_objfile_msymbols (objf
, addr
)
352 struct objfile
*objf
;
355 register struct minimal_symbol
*msymbol
;
358 for (msymbol
= objf
->msymbols
, ii
=0;
359 msymbol
&& ii
< objf
->minimal_symbol_count
; ++msymbol
, ++ii
)
361 if (msymbol
->address
< TEXT_SEGMENT_BASE
)
362 msymbol
->address
+= addr
;
365 #else /* !FASTER_MSYMBOL_RELOCATION */
367 /* Called via iterate_over_msymbols to relocate minimal symbols */
370 relocate_minimal_symbol (objfile
, msymbol
, arg1
, arg2
, arg3
)
371 struct objfile
*objfile
;
372 struct minimal_symbol
*msymbol
;
377 if (msymbol
->address
< TEXT_SEGMENT_BASE
)
378 msymbol
-> address
+= (int) arg1
;
380 /* return 0, otherwise `iterate_over_msymbols()' will stop at the
384 #endif /* FASTER_MSYMBOL_RELOCATION */
386 /* true, if symbol table and minimal symbol table are relocated. */
388 int symtab_relocated
= 0;
391 /* vmap_symtab - handle symbol translation on vmapping */
393 vmap_symtab(vp
, old_start
, vip
)
394 register struct vmap
*vp
;
398 register struct symtab
*s
;
399 register struct objfile
*objfile
;
402 * for each symbol table generated from the vp->bfd
404 for (objfile
= object_files
; objfile
!= NULL
; objfile
= objfile
-> next
)
406 for (s
= objfile
-> symtabs
; s
!= NULL
; s
= s
-> next
) {
408 /* skip over if this is not relocatable and doesn't have a line table */
409 if (s
->nonreloc
&& !LINETABLE (s
))
412 /* matching the symbol table's BFD and the *vp's BFD is hairy.
413 exec_file creates a seperate BFD for possibly the
414 same file as symbol_file.FIXME ALL THIS MUST BE RECTIFIED. */
416 if (objfile
->obfd
== vp
->bfd
) {
417 /* if they match, we luck out. */
419 } else if (vp
->member
[0]) {
420 /* no match, and member present, not this one. */
427 * no match, and no member. need to be sure.
429 io
= bfd_cache_lookup(objfile
->obfd
);
431 fatal("cannot find BFD's iostream for sym");
433 * see if we are referring to the same file
435 if (fstat(fileno(io
), &si
) < 0)
436 fatal("cannot fstat BFD for sym");
438 if (si
.st_dev
!= vip
->st_dev
439 || si
.st_ino
!= vip
->st_ino
)
443 if (vp
->tstart
!= old_start
) {
445 /* Once we find a relocation base address for one of the symtabs
446 in this objfile, it will be the same for all symtabs in this
447 objfile. Clean this algorithm. FIXME. */
449 for (; s
; s
= s
->next
)
450 if (!s
->nonreloc
|| LINETABLE(s
))
451 vmap_symtab_1(s
, vp
, old_start
);
453 #ifdef FASTER_MSYMBOL_RELOCATION
454 /* we can rely on the fact that at least one symtab in this objfile
455 will get relocated. Thus, we can be sure that minimal symbol
456 vector is guaranteed for relocation. */
458 reloc_objfile_msymbols (objfile
, vp
->tstart
- old_start
);
465 if (vp
->tstart
!= old_start
) {
466 #ifndef FASTER_MSYMBOL_RELOCATION
467 (void) iterate_over_msymbols (relocate_minimal_symbol
,
468 (PTR
) (vp
->tstart
- old_start
),
469 (PTR
) NULL
, (PTR
) NULL
);
472 /* breakpoints need to be relocated as well. */
473 fixup_breakpoints (0, TEXT_SEGMENT_BASE
, vp
->tstart
- old_start
);
476 symtab_relocated
= 1;
480 vmap_symtab_1(s
, vp
, old_start
)
481 register struct symtab
*s
;
482 register struct vmap
*vp
;
487 register struct linetable
*l
;
488 struct blockvector
*bv
;
489 register struct block
*b
;
491 register ulong reloc
, dreloc
;
493 if ((reloc
= vp
->tstart
- old_start
) == 0)
496 dreloc
= vp
->dstart
; /* data relocation */
499 * The line table must be relocated. This is only present for
500 * .text sections, so only vp->text type maps need be considered.
505 for (i
= 0; i
< len
; i
++)
506 l
->item
[i
].pc
+= reloc
;
509 /* if this symbol table is not relocatable, only line table should
510 be relocated and the rest ignored. */
515 len
= BLOCKVECTOR_NBLOCKS(bv
);
517 for (i
= 0; i
< len
; i
++) {
518 b
= BLOCKVECTOR_BLOCK(bv
, i
);
520 BLOCK_START(b
) += reloc
;
521 BLOCK_END(b
) += reloc
;
523 blen
= BLOCK_NSYMS(b
);
524 for (j
= 0; j
< blen
; j
++) {
525 register struct symbol
*sym
;
527 sym
= BLOCK_SYM(b
, j
);
528 switch (SYMBOL_NAMESPACE(sym
)) {
529 case STRUCT_NAMESPACE
:
530 case UNDEF_NAMESPACE
:
533 case LABEL_NAMESPACE
:
538 switch (SYMBOL_CLASS(sym
)) {
540 case LOC_CONST_BYTES
:
554 SYMBOL_VALUE_ADDRESS(sym
) += reloc
;
558 SYMBOL_VALUE_ADDRESS(sym
) += dreloc
;
565 fatal("botched symbol class %x"
566 , SYMBOL_CLASS(sym
));
574 * add_vmap - add a new vmap entry based on ldinfo() information
577 register struct ld_info
*ldi
; {
579 register char *mem
, *objname
;
581 /* This ldi structure was allocated using alloca() in
582 aixcoff_relocate_symtab(). Now we need to have persistent object
583 and member names, so we should save them. */
585 mem
= ldi
->ldinfo_filename
+ strlen(ldi
->ldinfo_filename
) + 1;
586 mem
= savestring (mem
, strlen (mem
));
587 objname
= savestring (ldi
->ldinfo_filename
, strlen (ldi
->ldinfo_filename
));
589 bfd
= bfd_fdopenr(objname
, NULL
, ldi
->ldinfo_fd
);
591 error("Could not open `%s' as an executable file: %s",
592 objname
, bfd_errmsg(bfd_error
));
595 /* make sure we have an object file */
597 if (bfd_check_format(bfd
, bfd_object
))
600 else if (bfd_check_format(bfd
, bfd_archive
)) {
603 * FIXME??? am I tossing BFDs? bfd?
605 while (last
= bfd_openr_next_archived_file(bfd
, last
))
606 if (eq(mem
, last
->filename
))
611 /* FIXME -- should be error */
612 warning("\"%s\": member \"%s\" missing.", bfd
->filename
, mem
);
616 if (!bfd_check_format(last
, bfd_object
)) {
617 bfd_close(last
); /* XXX??? */
621 map_vmap (last
, bfd
);
626 /* FIXME -- should be error */
627 warning("\"%s\": not in executable format: %s."
628 , objname
, bfd_errmsg(bfd_error
));
634 /* As well as symbol tables, exec_sections need relocation. After
635 the inferior process' termination, there will be a relocated symbol
636 table exist with no corresponding inferior process. At that time, we
637 need to use `exec' bfd, rather than the inferior process's memory space
640 `exec_sections' need to be relocated only once, as long as the exec
641 file remains unchanged.
646 if (execbfd
== exec_bfd
)
651 /* First exec section is `.text', second is `.data'. If this is changed,
652 then this routine will choke. */
654 if (!vmap
|| !exec_ops
.to_sections
||
655 strcmp (exec_ops
.to_sections
[0].sec_ptr
->name
, ".text") ||
656 strcmp (exec_ops
.to_sections
[1].sec_ptr
->name
, ".data"))
658 fatal ("aix: Improper exec_ops sections.");
660 exec_ops
.to_sections
[0].addr
+= vmap
->tstart
;
661 exec_ops
.to_sections
[0].endaddr
+= vmap
->tstart
;
662 exec_ops
.to_sections
[1].addr
+= vmap
->dstart
;
663 exec_ops
.to_sections
[1].endaddr
+= vmap
->dstart
;
668 text_adjustment (abfd
)
672 static int adjustment
;
675 if (exec_bfd
== execbfd
)
678 sect
= bfd_get_section_by_name (abfd
, ".text");
680 adjustment
= sect
->filepos
- sect
->vma
;
682 adjustment
= 0x200; /* just a wild assumption */
689 * vmap_ldinfo - update VMAP info with ldinfo() information
692 * ldi - ^ to ldinfo() results.
695 register struct ld_info
*ldi
;
698 register struct vmap
*vp
;
699 register got_one
, retried
;
703 * for each *ldi, see if we have a corresponding *vp
704 * if so, update the mapping, and symbol table.
705 * if not, add an entry and symbol table.
708 char *name
= ldi
->ldinfo_filename
;
709 char *memb
= name
+ strlen(name
) + 1;
713 if (fstat(ldi
->ldinfo_fd
, &ii
) < 0)
714 fatal("cannot fstat(%d) on %s"
718 for (got_one
= 0, vp
= vmap
; vp
; vp
= vp
->nxt
) {
721 /* The filenames are not always sufficient to match on. */
723 && !eq(name
, vp
->name
))
724 || (memb
[0] && !eq(memb
, vp
->member
)))
727 /* totally opaque! */
728 io
= bfd_cache_lookup(vp
->bfd
);
730 fatal("cannot find BFD's iostream for %s"
733 /* see if we are referring to the same file */
734 if (fstat(fileno(io
), &vi
) < 0)
735 fatal("cannot fstat BFD for %s", vp
->name
);
737 if (ii
.st_dev
!= vi
.st_dev
|| ii
.st_ino
!= vi
.st_ino
)
741 close(ldi
->ldinfo_fd
);
745 /* found a corresponding VMAP. remap! */
748 vp
->tstart
= ldi
->ldinfo_textorg
;
749 vp
->tend
= vp
->tstart
+ ldi
->ldinfo_textsize
;
750 vp
->dstart
= ldi
->ldinfo_dataorg
;
751 vp
->dend
= vp
->dstart
+ ldi
->ldinfo_datasize
;
754 vp
->tstart
+= vp
->tadj
;
755 vp
->tend
+= vp
->tadj
;
758 /* relocate symbol table(s). */
759 vmap_symtab(vp
, ostart
, &vi
);
761 /* there may be more, so we don't break out of the loop. */
765 * if there was no matching *vp, we must perforce create
768 if (!got_one
&& !retried
) {
773 } while (ldi
->ldinfo_next
774 && (ldi
= (void *) (ldi
->ldinfo_next
+ (char *) ldi
)));
779 * vmap_inferior - print VMAP info for inferior
783 if (inferior_pid
== 0)
784 return 0; /* normal processing */
790 /* Read or write the exec file.
792 Args are address within exec file, address within gdb address-space,
793 length, and a flag indicating whether to read or write.
797 0: We cannot handle this address and length.
798 > 0: We have handled N bytes starting at this address.
799 (If N == length, we did it all.) We might be able
800 to handle more bytes beyond this length, but no
802 < 0: We cannot handle this address, but if somebody
803 else handles (-N) bytes, we can start from there.
805 The same routine is used to handle both core and exec files;
806 we just tail-call it with more arguments to select between them. */
809 xfer_memory (memaddr
, myaddr
, len
, write
, target
)
814 struct target_ops
*target
;
817 struct section_table
*p
;
818 CORE_ADDR nextsectaddr
, memend
;
819 boolean (*xfer_fn
) PARAMS ((bfd
*, sec_ptr
, PTR
, file_ptr
, bfd_size_type
));
824 memend
= memaddr
+ len
;
825 xfer_fn
= write
? bfd_set_section_contents
: bfd_get_section_contents
;
826 nextsectaddr
= memend
;
828 for (p
= target
->to_sections
; p
< target
->to_sections_end
; p
++)
830 if (p
->addr
<= memaddr
)
831 if (p
->endaddr
>= memend
)
833 /* Entire transfer is within this section. */
834 res
= xfer_fn (p
->bfd
, p
->sec_ptr
, myaddr
, memaddr
- p
->addr
, len
);
835 return (res
!= false)? len
: 0;
837 else if (p
->endaddr
<= memaddr
)
839 /* This section ends before the transfer starts. */
844 /* This section overlaps the transfer. Just do half. */
845 len
= p
->endaddr
- memaddr
;
846 res
= xfer_fn (p
->bfd
, p
->sec_ptr
, myaddr
, memaddr
- p
->addr
, len
);
847 return (res
!= false)? len
: 0;
849 else if (p
->addr
< nextsectaddr
)
850 nextsectaddr
= p
->addr
;
853 if (nextsectaddr
>= memend
)
854 return 0; /* We can't help */
856 return - (nextsectaddr
- memaddr
); /* Next boundary where we can help */
860 print_section_info (t
, abfd
)
861 struct target_ops
*t
;
864 struct section_table
*p
;
866 printf_filtered ("\t`%s', ", bfd_get_filename(abfd
));
868 printf_filtered ("file type %s.\n", bfd_get_target(abfd
));
870 for (p
= t
->to_sections
; p
< t
->to_sections_end
; p
++) {
871 printf_filtered ("\t%s", local_hex_string_custom (p
->addr
, "08"));
872 printf_filtered (" - %s", local_hex_string_custom (p
->endaddr
, "08"));
874 printf_filtered (" @ %s",
875 local_hex_string_custom (p
->sec_ptr
->filepos
, "08"));
876 printf_filtered (" is %s", bfd_section_name (p
->bfd
, p
->sec_ptr
));
877 if (p
->bfd
!= abfd
) {
878 printf_filtered (" in %s", bfd_get_filename (p
->bfd
));
880 printf_filtered ("\n");
887 struct target_ops
*t
;
889 register struct vmap
*vp
= vmap
;
891 print_section_info (t
, exec_bfd
);
896 printf("\n\tMapping info for file `%s'.\n", vp
->name
);
897 printf("\t %8.8s %8.8s %8.8s %s\n",
898 "start", "end", "section", "file(member)");
900 for (; vp
; vp
= vp
->nxt
)
901 printf("\t0x%8.8x 0x%8.8x %s%s%s%s\n",
905 vp
->member
? "(" : "",
907 vp
->member
? ")" : "");
911 /* Damon's implementation of set_section_command! It is based on the sex member
912 (which is a section pointer from vmap) of vmap.
913 We will not have multiple vmap entries (one for each section), rather transmit
914 text and data base offsets and fix them at the same time. Elimination of sex
915 entry in vmap make this function obsolute, use the one from exec.c.
916 Need further testing!! FIXMEmgo. */
919 set_section_command(args
, from_tty
)
922 register struct vmap
*vp
= vmap
;
925 unsigned long secaddr
;
930 error("Must specify section name and its virtual address");
932 /* Parse out section name */
933 for (secname
= args
; !isspace(*args
); args
++)
935 seclen
= args
- secname
;
937 /* Parse out new virtual address */
938 secaddr
= parse_and_eval_address(args
);
940 for (vp
= vmap
; vp
; vp
= vp
->nxt
) {
942 , bfd_section_name(vp
->bfd
, vp
->sex
), seclen
)
943 && bfd_section_name(vp
->bfd
, vp
->sex
)[seclen
] == '\0') {
944 offset
= secaddr
- vp
->tstart
;
945 vp
->tstart
+= offset
;
952 if (seclen
>= sizeof(secprint
))
953 seclen
= sizeof(secprint
) - 1;
954 strncpy(secprint
, secname
, seclen
);
955 secprint
[seclen
] = '\0';
956 error("Section %s not found", secprint
);
960 set_section_command (args
, from_tty
)
964 struct section_table
*p
;
967 unsigned long secaddr
;
972 error ("Must specify section name and its virtual address");
974 /* Parse out section name */
975 for (secname
= args
; !isspace(*args
); args
++) ;
976 seclen
= args
- secname
;
978 /* Parse out new virtual address */
979 secaddr
= parse_and_eval_address (args
);
981 for (p
= exec_ops
.to_sections
; p
< exec_ops
.to_sections_end
; p
++) {
982 if (!strncmp (secname
, bfd_section_name (exec_bfd
, p
->sec_ptr
), seclen
)
983 && bfd_section_name (exec_bfd
, p
->sec_ptr
)[seclen
] == '\0') {
984 offset
= secaddr
- p
->addr
;
986 p
->endaddr
+= offset
;
988 exec_files_info(&exec_ops
);
992 if (seclen
>= sizeof (secprint
))
993 seclen
= sizeof (secprint
) - 1;
994 strncpy (secprint
, secname
, seclen
);
995 secprint
[seclen
] = '\0';
996 error ("Section %s not found", secprint
);
1001 struct target_ops exec_ops
= {
1002 "exec", "Local exec file",
1003 "Use an executable file as a target.\n\
1004 Specify the filename of the executable file.",
1005 exec_file_command
, exec_close
, /* open, close */
1006 child_attach
, 0, 0, 0, /* attach, detach, resume, wait, */
1007 0, 0, /* fetch_registers, store_registers, */
1008 0, 0, 0, /* prepare_to_store, conv_to, conv_from, */
1009 xfer_memory
, exec_files_info
,
1010 0, 0, /* insert_breakpoint, remove_breakpoint, */
1011 0, 0, 0, 0, 0, /* terminal stuff */
1012 0, 0, /* kill, load */
1014 child_create_inferior
,
1015 0, /* mourn_inferior */
1016 file_stratum
, 0, /* next */
1017 0, 1, 0, 0, 0, /* all mem, mem, stack, regs, exec */
1018 0, 0, /* section pointers */
1019 OPS_MAGIC
, /* Always the last thing */
1027 add_com("file", class_files
, file_command
,
1028 "Use FILE as program to be debugged.\n\
1029 It is read for its symbols, for getting the contents of pure memory,\n\
1030 and it is the program executed when you use the `run' command.\n\
1031 If FILE cannot be found as specified, your execution directory path\n\
1032 ($PATH) is searched for a command of that name.\n\
1033 No arg means to have no executable file and no symbols.");
1035 add_com("exec-file", class_files
, exec_file_command
,
1036 "Use FILE as program for getting contents of pure memory.\n\
1037 If FILE cannot be found as specified, your execution directory path\n\
1038 is searched for a command of that name.\n\
1039 No arg means have no executable file.");
1041 add_com("section", class_files
, set_section_command
,
1042 "Change the base address of section SECTION of the exec file to ADDR.\n\
1043 This can be used if the exec file does not contain section addresses,\n\
1044 (such as in the a.out format), or when the addresses specified in the\n\
1045 file itself are wrong. Each section must be changed separately. The\n\
1046 ``info files'' command lists all the sections and their addresses.");
1048 add_target(&exec_ops
);
This page took 0.074582 seconds and 5 git commands to generate.