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>
42 #include "libbfd.h" /* BFD internals (sigh!) FIXME */
44 #include "xcoffsolib.h"
46 /* Prototypes for local functions */
49 file_command
PARAMS ((char *, int));
52 exec_close
PARAMS ((int));
55 map_vmap
PARAMS ((bfd
*, bfd
*));
57 struct section_table
*exec_sections
, *exec_sections_end
;
59 /* Whether to open exec and core files read-only or read-write. */
63 extern int info_verbose
;
65 bfd
*exec_bfd
; /* needed by core.c */
67 extern char *getenv();
68 extern void add_syms_addr_command ();
69 extern void symbol_file_command ();
70 static void exec_files_info();
72 struct vmap
*vmap
; /* current vmap */
74 extern struct target_ops exec_ops
;
77 /* exec_close - done with exec file, clean up all resources. */
82 register struct vmap
*vp
, *nxt
;
85 for (nxt
= vmap
; vp
= nxt
; )
89 /* if there is an objfile associated with this bfd,
90 free_objfile() will do proper cleanup of objfile *and* bfd. */
93 free_objfile (vp
->objfile
);
97 /* FIXME: This routine is #if 0'd in symfile.c. What should we
98 be doing here? Should we just free everything in
99 vp->objfile->symtabs? Should free_objfile do that? */
100 free_named_symtabs(vp
->name
);
106 /* exec_bfd was already closed (the exec file has a vmap entry). */
109 if (exec_ops
.to_sections
) {
110 free (exec_ops
.to_sections
);
111 exec_ops
.to_sections
= NULL
;
112 exec_ops
.to_sections_end
= NULL
;
117 * exec_file_command - handle the "exec" command, &c.
120 exec_file_command(filename
, from_tty
)
123 target_preopen(from_tty
);
125 /* Remove any previous exec file. */
126 unpush_target(&exec_ops
);
128 /* Now open and digest the file the user requested, if any. */
131 char *scratch_pathname
;
134 filename
= tilde_expand(filename
);
135 make_cleanup (free
, filename
);
137 scratch_chan
= openp(getenv("PATH"), 1, filename
,
138 write_files
? O_RDWR
: O_RDONLY
, 0,
140 if (scratch_chan
< 0)
141 perror_with_name(filename
);
143 exec_bfd
= bfd_fdopenr(scratch_pathname
, NULL
, scratch_chan
);
145 error("Could not open `%s' as an executable file: %s"
146 , scratch_pathname
, bfd_errmsg(bfd_error
));
148 /* make sure we have an object file */
150 if (!bfd_check_format(exec_bfd
, bfd_object
))
151 error("\"%s\": not in executable format: %s.",
152 scratch_pathname
, bfd_errmsg(bfd_error
));
155 /* setup initial vmap */
157 map_vmap (exec_bfd
, 0);
159 error("Can't find the file sections in `%s': %s",
160 exec_bfd
->filename
, bfd_errmsg(bfd_error
));
162 if (build_section_table (exec_bfd
, &exec_ops
.to_sections
,
163 &exec_ops
.to_sections_end
))
164 error ("Can't find the file sections in `%s': %s",
165 exec_bfd
->filename
, bfd_errmsg (bfd_error
));
167 /* make sure core, if present, matches */
170 push_target(&exec_ops
);
172 /* Tell display code(if any) about the changed file name. */
174 if (exec_file_display_hook
)
175 (*exec_file_display_hook
)(filename
);
178 exec_close(0); /* just in case */
180 printf("No exec file now.\n");
184 /* Set both the exec file and the symbol file, in one command. What a
185 * novelty. Why did GDB go through four major releases before this
189 file_command(arg
, from_tty
)
192 exec_file_command(arg
, from_tty
);
193 symbol_file_command(arg
, from_tty
);
196 /* Locate all mappable sections of a BFD file.
197 table_pp_char is a char * to get it through bfd_map_over_sections;
198 we cast it back to its proper type. */
201 add_to_section_table (abfd
, asect
, table_pp_char
)
206 struct section_table
**table_pp
= (struct section_table
**)table_pp_char
;
209 aflag
= bfd_get_section_flags (abfd
, asect
);
210 /* FIXME, we need to handle BSS segment here...it alloc's but doesn't load */
211 if (!(aflag
& SEC_LOAD
))
213 if (0 == bfd_section_size (abfd
, asect
))
215 (*table_pp
)->bfd
= abfd
;
216 (*table_pp
)->sec_ptr
= asect
;
217 (*table_pp
)->addr
= bfd_section_vma (abfd
, asect
);
218 (*table_pp
)->endaddr
= (*table_pp
)->addr
+ bfd_section_size (abfd
, asect
);
223 build_section_table (some_bfd
, start
, end
)
225 struct section_table
**start
, **end
;
229 count
= bfd_count_sections (some_bfd
);
231 abort(); /* return 1? */
234 *start
= (struct section_table
*) xmalloc (count
* sizeof (**start
));
236 bfd_map_over_sections (some_bfd
, add_to_section_table
, (char *)end
);
237 if (*end
> *start
+ count
)
239 /* We could realloc the table, but it probably loses for most files. */
244 sex_to_vmap(bfd
*bf
, sec_ptr sex
, struct vmap_and_bfd
*vmap_bfd
)
246 register struct vmap
*vp
, **vpp
;
247 register struct symtab
*syms
;
248 bfd
*arch
= vmap_bfd
->pbfd
;
249 vp
= vmap_bfd
->pvmap
;
251 if ((bfd_get_section_flags(bf
, sex
) & SEC_LOAD
) == 0)
254 if (STREQ(bfd_section_name(bf
, sex
), ".text")) {
256 vp
->tend
= vp
->tstart
+ bfd_section_size(bf
, sex
);
258 /* When it comes to this adjustment value, in contrast to our previous
259 belief shared objects should behave the same as the main load segment.
260 This is the offset from the beginning of text section to the first
263 vp
->tadj
= sex
->filepos
- bfd_section_vma(bf
, sex
);
266 else if (STREQ(bfd_section_name(bf
, sex
), ".data")) {
268 vp
->dend
= vp
->dstart
+ bfd_section_size(bf
, sex
);
271 else if (STREQ(bfd_section_name(bf
, sex
), ".bss")) /* FIXMEmgo */
272 printf ("bss section in exec! Don't know what the heck to do!\n");
275 /* Make a vmap for the BFD "bf", which might be a member of the archive
276 BFD "arch". Return the new vmap. */
278 map_vmap (bfd
*bf
, bfd
*arch
)
280 struct vmap_and_bfd vmap_bfd
;
281 struct vmap
*vp
, **vpp
;
284 vp
= (void*) xmalloc (sizeof (*vp
));
285 bzero (vp
, sizeof (*vp
));
288 vp
->name
= bfd_get_filename(arch
? arch
: bf
);
289 vp
->member
= arch
? bfd_get_filename(bf
) : "";
291 vmap_bfd
.pbfd
= arch
;
293 bfd_map_over_sections (bf
, sex_to_vmap
, &vmap_bfd
);
295 /* find the end of the list, and append. */
296 for (vpp
= &vmap
; *vpp
; vpp
= &(*vpp
)->nxt
)
304 /* vmap_symtab - handle symbol translation on vmapping */
308 register struct vmap
*vp
;
310 register struct objfile
*objfile
;
314 CORE_ADDR old_text_offset
;
315 struct section_offsets
*new_offsets
;
318 objfile
= vp
->objfile
;
321 /* OK, it's not an objfile we opened ourselves.
322 Currently, that can only happen with the exec file, so
323 relocate the symbols for the symfile. */
324 if (symfile_objfile
== NULL
)
326 objfile
= symfile_objfile
;
330 (sizeof (struct section_offsets
)
331 + sizeof (new_offsets
->offsets
) * objfile
->num_sections
);
333 for (i
= 0; i
< objfile
->num_sections
; ++i
)
334 ANOFFSET (new_offsets
, i
) = ANOFFSET (objfile
->section_offsets
, i
);
336 textsec
= bfd_get_section_by_name (vp
->bfd
, ".text");
337 old_text_offset
= ANOFFSET (objfile
->section_offsets
, textsec
->target_index
);
338 ANOFFSET (new_offsets
, textsec
->target_index
) = vp
->tstart
;
339 datasec
= bfd_get_section_by_name (vp
->bfd
, ".data");
340 ANOFFSET (new_offsets
, datasec
->target_index
) = vp
->dstart
;
341 bsssec
= bfd_get_section_by_name (vp
->bfd
, ".bss");
342 ANOFFSET (new_offsets
, bsssec
->target_index
) = vp
->dstart
;
344 objfile_relocate (objfile
, new_offsets
);
346 if (old_text_offset
!= ANOFFSET (new_offsets
, textsec
->target_index
))
347 /* breakpoints need to be relocated as well. */
348 fixup_breakpoints (0, TEXT_SEGMENT_BASE
, vp
->tstart
- old_text_offset
);
351 /* Add symbols for an objfile. */
353 objfile_symbol_add (arg
)
356 struct objfile
*obj
= (struct objfile
*) arg
;
357 syms_from_objfile (obj
, 0, 0, 0);
358 new_symfile_objfile (obj
, 0, 0);
362 static struct vmap
*add_vmap
PARAMS ((struct ld_info
*));
364 /* Add a new vmap entry based on ldinfo() information.
366 If ldi->ldinfo_fd is not valid (e.g. this struct ld_info is from a
367 core file), the caller should set it to -1, and we will open the file.
369 Return the vmap new entry. */
372 register struct ld_info
*ldi
;
375 register char *mem
, *objname
;
379 /* This ldi structure was allocated using alloca() in
380 xcoff_relocate_symtab(). Now we need to have persistent object
381 and member names, so we should save them. */
383 mem
= ldi
->ldinfo_filename
+ strlen(ldi
->ldinfo_filename
) + 1;
384 mem
= savestring (mem
, strlen (mem
));
385 objname
= savestring (ldi
->ldinfo_filename
, strlen (ldi
->ldinfo_filename
));
387 if (ldi
->ldinfo_fd
< 0)
388 /* Note that this opens it once for every member; a possible
389 enhancement would be to only open it once for every object. */
390 bfd
= bfd_openr (objname
, NULL
);
392 bfd
= bfd_fdopenr(objname
, NULL
, ldi
->ldinfo_fd
);
394 error("Could not open `%s' as an executable file: %s",
395 objname
, bfd_errmsg(bfd_error
));
398 /* make sure we have an object file */
400 if (bfd_check_format(bfd
, bfd_object
))
401 vp
= map_vmap (bfd
, 0);
403 else if (bfd_check_format(bfd
, bfd_archive
)) {
406 * FIXME??? am I tossing BFDs? bfd?
408 while (last
= bfd_openr_next_archived_file(bfd
, last
))
409 if (STREQ(mem
, last
->filename
))
414 /* FIXME -- should be error */
415 warning("\"%s\": member \"%s\" missing.", bfd
->filename
, mem
);
419 if (!bfd_check_format(last
, bfd_object
)) {
420 bfd_close(last
); /* XXX??? */
424 vp
= map_vmap (last
, bfd
);
429 error ("\"%s\": not in executable format: %s.",
430 objname
, bfd_errmsg(bfd_error
));
433 obj
= allocate_objfile (vp
->bfd
, 0);
436 #ifndef SOLIB_SYMBOLS_MANUAL
437 if (catch_errors (objfile_symbol_add
, (char *)obj
,
438 "Error while reading shared library symbols:\n"))
440 /* Note this is only done if symbol reading was successful. */
449 /* As well as symbol tables, exec_sections need relocation. After
450 the inferior process' termination, there will be a relocated symbol
451 table exist with no corresponding inferior process. At that time, we
452 need to use `exec' bfd, rather than the inferior process's memory space
455 `exec_sections' need to be relocated only once, as long as the exec
456 file remains unchanged.
463 if (execbfd
== exec_bfd
)
468 if (!vmap
|| !exec_ops
.to_sections
)
469 error ("vmap_exec: vmap or exec_ops.to_sections == 0\n");
471 for (i
=0; &exec_ops
.to_sections
[i
] < exec_ops
.to_sections_end
; i
++)
473 if (STREQ(".text", exec_ops
.to_sections
[i
].sec_ptr
->name
))
475 exec_ops
.to_sections
[i
].addr
+= vmap
->tstart
;
476 exec_ops
.to_sections
[i
].endaddr
+= vmap
->tstart
;
478 else if (STREQ(".data", exec_ops
.to_sections
[i
].sec_ptr
->name
))
480 exec_ops
.to_sections
[i
].addr
+= vmap
->dstart
;
481 exec_ops
.to_sections
[i
].endaddr
+= vmap
->dstart
;
487 /* This was for the old, half-assed, core file support. */
489 text_adjustment (abfd
)
493 static int adjustment
;
496 if (exec_bfd
== execbfd
)
499 sect
= bfd_get_section_by_name (abfd
, ".text");
501 adjustment
= sect
->filepos
- sect
->vma
;
503 adjustment
= 0x200; /* just a wild assumption */
510 * vmap_ldinfo - update VMAP info with ldinfo() information
513 * ldi - ^ to ldinfo() results.
516 register struct ld_info
*ldi
;
519 register struct vmap
*vp
;
520 register got_one
, retried
;
524 * for each *ldi, see if we have a corresponding *vp
525 * if so, update the mapping, and symbol table.
526 * if not, add an entry and symbol table.
529 char *name
= ldi
->ldinfo_filename
;
530 char *memb
= name
+ strlen(name
) + 1;
534 if (fstat(ldi
->ldinfo_fd
, &ii
) < 0)
535 fatal("cannot fstat(%d) on %s"
539 for (got_one
= 0, vp
= vmap
; vp
; vp
= vp
->nxt
) {
542 /* First try to find a `vp', which is the same as in ldinfo.
543 If not the same, just continue and grep the next `vp'. If same,
544 relocate its tstart, tend, dstart, dend values. If no such `vp'
545 found, get out of this for loop, add this ldi entry as a new vmap
546 (add_vmap) and come back, fins its `vp' and so on... */
548 /* The filenames are not always sufficient to match on. */
550 if ((name
[0] == '/' && !STREQ(name
, vp
->name
))
551 || (memb
[0] && !STREQ(memb
, vp
->member
)))
554 io
= bfd_cache_lookup(vp
->bfd
); /* totally opaque! */
556 fatal("cannot find BFD's iostream for %s", vp
->name
);
558 /* see if we are referring to the same file */
560 if (fstat(fileno(io
), &vi
) < 0)
561 fatal("cannot fstat BFD for %s", vp
->name
);
563 if (ii
.st_dev
!= vi
.st_dev
|| ii
.st_ino
!= vi
.st_ino
)
567 close(ldi
->ldinfo_fd
);
571 /* found a corresponding VMAP. remap! */
574 vp
->tstart
= ldi
->ldinfo_textorg
;
575 vp
->tend
= vp
->tstart
+ ldi
->ldinfo_textsize
;
576 vp
->dstart
= ldi
->ldinfo_dataorg
;
577 vp
->dend
= vp
->dstart
+ ldi
->ldinfo_datasize
;
580 vp
->tstart
+= vp
->tadj
;
581 vp
->tend
+= vp
->tadj
;
584 /* relocate symbol table(s). */
587 /* there may be more, so we don't break out of the loop. */
590 /* if there was no matching *vp, we must perforce create the sucker(s) */
591 if (!got_one
&& !retried
) {
596 } while (ldi
->ldinfo_next
597 && (ldi
= (void *) (ldi
->ldinfo_next
+ (char *) ldi
)));
602 * vmap_inferior - print VMAP info for inferior
606 if (inferior_pid
== 0)
607 return 0; /* normal processing */
613 /* Read or write the exec file.
615 Args are address within exec file, address within gdb address-space,
616 length, and a flag indicating whether to read or write.
620 0: We cannot handle this address and length.
621 > 0: We have handled N bytes starting at this address.
622 (If N == length, we did it all.) We might be able
623 to handle more bytes beyond this length, but no
625 < 0: We cannot handle this address, but if somebody
626 else handles (-N) bytes, we can start from there.
628 The same routine is used to handle both core and exec files;
629 we just tail-call it with more arguments to select between them. */
632 xfer_memory (memaddr
, myaddr
, len
, write
, target
)
637 struct target_ops
*target
;
640 struct section_table
*p
;
641 CORE_ADDR nextsectaddr
, memend
;
642 boolean (*xfer_fn
) PARAMS ((bfd
*, sec_ptr
, PTR
, file_ptr
, bfd_size_type
));
647 memend
= memaddr
+ len
;
648 xfer_fn
= write
? bfd_set_section_contents
: bfd_get_section_contents
;
649 nextsectaddr
= memend
;
651 for (p
= target
->to_sections
; p
< target
->to_sections_end
; p
++)
653 if (p
->addr
<= memaddr
)
654 if (p
->endaddr
>= memend
)
656 /* Entire transfer is within this section. */
657 res
= xfer_fn (p
->bfd
, p
->sec_ptr
, myaddr
, memaddr
- p
->addr
, len
);
658 return (res
!= false)? len
: 0;
660 else if (p
->endaddr
<= memaddr
)
662 /* This section ends before the transfer starts. */
667 /* This section overlaps the transfer. Just do half. */
668 len
= p
->endaddr
- memaddr
;
669 res
= xfer_fn (p
->bfd
, p
->sec_ptr
, myaddr
, memaddr
- p
->addr
, len
);
670 return (res
!= false)? len
: 0;
672 else if (p
->addr
< nextsectaddr
)
673 nextsectaddr
= p
->addr
;
676 if (nextsectaddr
>= memend
)
677 return 0; /* We can't help */
679 return - (nextsectaddr
- memaddr
); /* Next boundary where we can help */
683 print_section_info (t
, abfd
)
684 struct target_ops
*t
;
687 struct section_table
*p
;
689 printf_filtered ("\t`%s', ", bfd_get_filename(abfd
));
691 printf_filtered ("file type %s.\n", bfd_get_target(abfd
));
693 for (p
= t
->to_sections
; p
< t
->to_sections_end
; p
++) {
694 printf_filtered ("\t%s", local_hex_string_custom (p
->addr
, "08"));
695 printf_filtered (" - %s", local_hex_string_custom (p
->endaddr
, "08"));
697 printf_filtered (" @ %s",
698 local_hex_string_custom (p
->sec_ptr
->filepos
, "08"));
699 printf_filtered (" is %s", bfd_section_name (p
->bfd
, p
->sec_ptr
));
700 if (p
->bfd
!= abfd
) {
701 printf_filtered (" in %s", bfd_get_filename (p
->bfd
));
703 printf_filtered ("\n");
710 struct target_ops
*t
;
712 register struct vmap
*vp
= vmap
;
714 print_section_info (t
, exec_bfd
);
719 printf("\tMapping info for file `%s'.\n", vp
->name
);
721 printf("\t %8.8s %8.8s %8.8s %8.8s %8.8s %s\n",
722 "tstart", "tend", "dstart", "dend", "section", "file(member)");
724 for (; vp
; vp
= vp
->nxt
)
725 printf("\t0x%8.8x 0x%8.8x 0x%8.8x 0x%8.8x %s%s%s%s\n",
731 *vp
->member
? "(" : "",
733 *vp
->member
? ")" : "");
737 /* Damon's implementation of set_section_command! It is based on the sex member
738 (which is a section pointer from vmap) of vmap.
739 We will not have multiple vmap entries (one for each section), rather transmit
740 text and data base offsets and fix them at the same time. Elimination of sex
741 entry in vmap make this function obsolute, use the one from exec.c.
742 Need further testing!! FIXMEmgo. */
745 set_section_command(args
, from_tty
)
748 register struct vmap
*vp
= vmap
;
751 unsigned long secaddr
;
756 error("Must specify section name and its virtual address");
758 /* Parse out section name */
759 for (secname
= args
; !isspace(*args
); args
++)
761 seclen
= args
- secname
;
763 /* Parse out new virtual address */
764 secaddr
= parse_and_eval_address(args
);
766 for (vp
= vmap
; vp
; vp
= vp
->nxt
) {
768 , bfd_section_name(vp
->bfd
, vp
->sex
), seclen
)
769 && bfd_section_name(vp
->bfd
, vp
->sex
)[seclen
] == '\0') {
770 offset
= secaddr
- vp
->tstart
;
771 vp
->tstart
+= offset
;
778 if (seclen
>= sizeof(secprint
))
779 seclen
= sizeof(secprint
) - 1;
780 strncpy(secprint
, secname
, seclen
);
781 secprint
[seclen
] = '\0';
782 error("Section %s not found", secprint
);
786 set_section_command (args
, from_tty
)
790 struct section_table
*p
;
793 unsigned long secaddr
;
798 error ("Must specify section name and its virtual address");
800 /* Parse out section name */
801 for (secname
= args
; !isspace(*args
); args
++) ;
802 seclen
= args
- secname
;
804 /* Parse out new virtual address */
805 secaddr
= parse_and_eval_address (args
);
807 for (p
= exec_ops
.to_sections
; p
< exec_ops
.to_sections_end
; p
++) {
808 if (!strncmp (secname
, bfd_section_name (exec_bfd
, p
->sec_ptr
), seclen
)
809 && bfd_section_name (exec_bfd
, p
->sec_ptr
)[seclen
] == '\0') {
810 offset
= secaddr
- p
->addr
;
812 p
->endaddr
+= offset
;
814 exec_files_info(&exec_ops
);
818 if (seclen
>= sizeof (secprint
))
819 seclen
= sizeof (secprint
) - 1;
820 strncpy (secprint
, secname
, seclen
);
821 secprint
[seclen
] = '\0';
822 error ("Section %s not found", secprint
);
827 struct target_ops exec_ops
= {
828 "exec", "Local exec file",
829 "Use an executable file as a target.\n\
830 Specify the filename of the executable file.",
831 exec_file_command
, exec_close
, /* open, close */
832 find_default_attach
, 0, 0, 0, /* attach, detach, resume, wait, */
833 0, 0, /* fetch_registers, store_registers, */
834 0, /* prepare_to_store */
835 xfer_memory
, exec_files_info
,
836 0, 0, /* insert_breakpoint, remove_breakpoint, */
837 0, 0, 0, 0, 0, /* terminal stuff */
838 0, 0, /* kill, load */
840 find_default_create_inferior
,
841 0, /* mourn_inferior */
843 0, /* notice_signals */
844 file_stratum
, 0, /* next */
845 0, 1, 0, 0, 0, /* all mem, mem, stack, regs, exec */
846 0, 0, /* section pointers */
847 OPS_MAGIC
, /* Always the last thing */
850 /* Core file stuff. */
852 /* Relocate symtabs and read in shared library info, based on symbols
853 from the core file. */
855 xcoff_relocate_core ()
857 /* Offset of member MEMBER in a struct of type TYPE. */
859 #define offsetof(TYPE, MEMBER) ((int) &((TYPE *)0)->MEMBER)
862 /* Size of a struct ld_info except for the variable-length filename. */
863 #define LDINFO_SIZE (offsetof (struct ld_info, ldinfo_filename))
867 struct ld_info
*ldip
;
870 /* Allocated size of buffer. */
871 int buffer_size
= LDINFO_SIZE
;
872 char *buffer
= xmalloc (buffer_size
);
873 struct cleanup
*old
= make_cleanup (free_current_contents
, &buffer
);
875 ldinfo_sec
= bfd_get_section_by_name (core_bfd
, ".ldinfo");
876 if (ldinfo_sec
== NULL
)
879 fprintf_filtered (stderr
, "Couldn't get ldinfo from core file: %s\n",
880 bfd_errmsg (bfd_error
));
889 /* Read in everything but the name. */
890 if (bfd_get_section_contents (core_bfd
, ldinfo_sec
, buffer
,
891 offset
, LDINFO_SIZE
) == 0)
898 if (i
== buffer_size
)
901 buffer
= xrealloc (buffer
, buffer_size
);
903 if (bfd_get_section_contents (core_bfd
, ldinfo_sec
, &buffer
[i
],
906 if (buffer
[i
++] == '\0')
908 } while (names_found
< 2);
910 ldip
= (struct ld_info
*)buffer
;
912 /* Can't use a file descriptor from the core file; need to open it. */
913 ldip
->ldinfo_fd
= -1;
915 /* The first ldinfo is for the exec file, allocated elsewhere. */
919 vp
= add_vmap (ldip
);
921 offset
+= ldip
->ldinfo_next
;
923 vp
->tstart
= ldip
->ldinfo_textorg
;
924 vp
->tend
= vp
->tstart
+ ldip
->ldinfo_textsize
;
925 vp
->dstart
= ldip
->ldinfo_dataorg
;
926 vp
->dend
= vp
->dstart
+ ldip
->ldinfo_datasize
;
929 vp
->tstart
+= vp
->tadj
;
930 vp
->tend
+= vp
->tadj
;
933 /* Unless this is the exec file,
934 add our sections to the section table for the core target. */
938 struct section_table
*stp
;
940 count
= core_ops
.to_sections_end
- core_ops
.to_sections
;
942 core_ops
.to_sections
= (struct section_table
*)
943 xrealloc (core_ops
.to_sections
,
944 sizeof (struct section_table
) * count
);
945 core_ops
.to_sections_end
= core_ops
.to_sections
+ count
;
946 stp
= core_ops
.to_sections_end
- 2;
948 /* "Why do we add bfd_section_vma?", I hear you cry.
949 Well, the start of the section in the file is actually
950 that far into the section as the struct vmap understands it.
951 So for text sections, bfd_section_vma tends to be 0x200,
952 and if vp->tstart is 0xd0002000, then the first byte of
953 the text section on disk corresponds to address 0xd0002200. */
955 stp
->sec_ptr
= bfd_get_section_by_name (stp
->bfd
, ".text");
956 stp
->addr
= bfd_section_vma (stp
->bfd
, stp
->sec_ptr
) + vp
->tstart
;
957 stp
->endaddr
= bfd_section_vma (stp
->bfd
, stp
->sec_ptr
) + vp
->tend
;
961 stp
->sec_ptr
= bfd_get_section_by_name (stp
->bfd
, ".data");
962 stp
->addr
= bfd_section_vma (stp
->bfd
, stp
->sec_ptr
) + vp
->dstart
;
963 stp
->endaddr
= bfd_section_vma (stp
->bfd
, stp
->sec_ptr
) + vp
->dend
;
968 add_text_to_loadinfo (ldip
->ldinfo_textorg
, ldip
->ldinfo_dataorg
);
969 } while (ldip
->ldinfo_next
!= 0);
978 add_com("file", class_files
, file_command
,
979 "Use FILE as program to be debugged.\n\
980 It is read for its symbols, for getting the contents of pure memory,\n\
981 and it is the program executed when you use the `run' command.\n\
982 If FILE cannot be found as specified, your execution directory path\n\
983 ($PATH) is searched for a command of that name.\n\
984 No arg means to have no executable file and no symbols.");
986 add_com("exec-file", class_files
, exec_file_command
,
987 "Use FILE as program for getting contents of pure memory.\n\
988 If FILE cannot be found as specified, your execution directory path\n\
989 is searched for a command of that name.\n\
990 No arg means have no executable file.");
992 add_com("section", class_files
, set_section_command
,
993 "Change the base address of section SECTION of the exec file to ADDR.\n\
994 This can be used if the exec file does not contain section addresses,\n\
995 (such as in the a.out format), or when the addresses specified in the\n\
996 file itself are wrong. Each section must be changed separately. The\n\
997 ``info files'' command lists all the sections and their addresses.");
999 add_target(&exec_ops
);