* Rename remote-es1800.c to remote-es.c
[deliverable/binutils-gdb.git] / gdb / xcoffexec.c
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.
5
6 This file is part of GDB.
7
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.
12
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.
17
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. */
21
22 /* xcoff-exec - deal with executing XCOFF files. */
23
24 #include "defs.h"
25
26 #include <sys/types.h>
27 #include <sys/param.h>
28 #include <fcntl.h>
29 #include <string.h>
30 #include <ctype.h>
31 #include <sys/stat.h>
32 #include <sys/ldr.h>
33
34 #include "frame.h"
35 #include "inferior.h"
36 #include "target.h"
37 #include "gdbcmd.h"
38 #include "gdbcore.h"
39 #include "symfile.h"
40 #include "objfiles.h"
41
42 #include "libbfd.h" /* BFD internals (sigh!) FIXME */
43 #include "bfd.h"
44 #include "xcoffsolib.h"
45
46 /* Prototypes for local functions */
47
48 static void
49 file_command PARAMS ((char *, int));
50
51 static void
52 exec_close PARAMS ((int));
53
54 static struct vmap *
55 map_vmap PARAMS ((bfd *, bfd *));
56
57 struct section_table *exec_sections, *exec_sections_end;
58
59 /* Whether to open exec and core files read-only or read-write. */
60
61 int write_files = 0;
62
63 extern int info_verbose;
64
65 bfd *exec_bfd; /* needed by core.c */
66
67 extern char *getenv();
68 extern void add_syms_addr_command ();
69 extern void symbol_file_command ();
70 static void exec_files_info();
71
72 struct vmap *vmap; /* current vmap */
73
74 extern struct target_ops exec_ops;
75
76
77 /* exec_close - done with exec file, clean up all resources. */
78
79 static void
80 exec_close(quitting)
81 {
82 register struct vmap *vp, *nxt;
83 struct objfile *obj;
84
85 for (nxt = vmap; vp = nxt; )
86 {
87 nxt = vp->nxt;
88
89 /* if there is an objfile associated with this bfd,
90 free_objfile() will do proper cleanup of objfile *and* bfd. */
91
92 if (vp->objfile)
93 free_objfile (vp->objfile);
94 else
95 bfd_close(vp->bfd);
96
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);
101 free(vp);
102 }
103
104 vmap = 0;
105
106 /* exec_bfd was already closed (the exec file has a vmap entry). */
107 exec_bfd = NULL;
108
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;
113 }
114 }
115
116 /*
117 * exec_file_command - handle the "exec" command, &c.
118 */
119 void
120 exec_file_command(filename, from_tty)
121 char *filename;
122 {
123 target_preopen(from_tty);
124
125 /* Remove any previous exec file. */
126 unpush_target(&exec_ops);
127
128 /* Now open and digest the file the user requested, if any. */
129
130 if (filename) {
131 char *scratch_pathname;
132 int scratch_chan;
133
134 filename = tilde_expand(filename);
135 make_cleanup (free, filename);
136
137 scratch_chan = openp(getenv("PATH"), 1, filename,
138 write_files? O_RDWR: O_RDONLY, 0,
139 &scratch_pathname);
140 if (scratch_chan < 0)
141 perror_with_name(filename);
142
143 exec_bfd = bfd_fdopenr(scratch_pathname, NULL, scratch_chan);
144 if (!exec_bfd)
145 error("Could not open `%s' as an executable file: %s"
146 , scratch_pathname, bfd_errmsg(bfd_error));
147
148 /* make sure we have an object file */
149
150 if (!bfd_check_format(exec_bfd, bfd_object))
151 error("\"%s\": not in executable format: %s.",
152 scratch_pathname, bfd_errmsg(bfd_error));
153
154
155 /* setup initial vmap */
156
157 map_vmap (exec_bfd, 0);
158 if (!vmap)
159 error("Can't find the file sections in `%s': %s",
160 exec_bfd->filename, bfd_errmsg(bfd_error));
161
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));
166
167 /* make sure core, if present, matches */
168 validate_files();
169
170 push_target(&exec_ops);
171
172 /* Tell display code(if any) about the changed file name. */
173
174 if (exec_file_display_hook)
175 (*exec_file_display_hook)(filename);
176 }
177 else {
178 exec_close(0); /* just in case */
179 if (from_tty)
180 printf("No exec file now.\n");
181 }
182 }
183
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
186 * command was added?
187 */
188 static void
189 file_command(arg, from_tty)
190 char *arg; {
191
192 exec_file_command(arg, from_tty);
193 symbol_file_command(arg, from_tty);
194 }
195
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. */
199
200 static void
201 add_to_section_table (abfd, asect, table_pp_char)
202 bfd *abfd;
203 sec_ptr asect;
204 char *table_pp_char;
205 {
206 struct section_table **table_pp = (struct section_table **)table_pp_char;
207 flagword aflag;
208
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))
212 return;
213 if (0 == bfd_section_size (abfd, asect))
214 return;
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);
219 (*table_pp)++;
220 }
221
222 int
223 build_section_table (some_bfd, start, end)
224 bfd *some_bfd;
225 struct section_table **start, **end;
226 {
227 unsigned count;
228
229 count = bfd_count_sections (some_bfd);
230 if (count == 0)
231 fatal ("aborting"); /* return 1? */
232 if (*start)
233 free (*start);
234 *start = (struct section_table *) xmalloc (count * sizeof (**start));
235 *end = *start;
236 bfd_map_over_sections (some_bfd, add_to_section_table, (char *)end);
237 if (*end > *start + count)
238 fatal ("aborting");
239 /* We could realloc the table, but it probably loses for most files. */
240 return 0;
241 }
242 \f
243 void
244 sex_to_vmap(bfd *bf, sec_ptr sex, PTR arg3)
245 {
246 struct vmap_and_bfd *vmap_bfd = (struct vmap_and_bfd *)arg3;
247 register struct vmap *vp, **vpp;
248 register struct symtab *syms;
249 bfd *arch = vmap_bfd->pbfd;
250 vp = vmap_bfd->pvmap;
251
252 if ((bfd_get_section_flags(bf, sex) & SEC_LOAD) == 0)
253 return;
254
255 if (STREQ(bfd_section_name(bf, sex), ".text")) {
256 vp->tstart = 0;
257 vp->tend = vp->tstart + bfd_section_size(bf, sex);
258
259 /* When it comes to this adjustment value, in contrast to our previous
260 belief shared objects should behave the same as the main load segment.
261 This is the offset from the beginning of text section to the first
262 real instruction. */
263
264 vp->tadj = sex->filepos - bfd_section_vma(bf, sex);
265 }
266
267 else if (STREQ(bfd_section_name(bf, sex), ".data")) {
268 vp->dstart = 0;
269 vp->dend = vp->dstart + bfd_section_size(bf, sex);
270 }
271
272 else if (STREQ(bfd_section_name(bf, sex), ".bss")) /* FIXMEmgo */
273 printf ("bss section in exec! Don't know what the heck to do!\n");
274 }
275
276 /* Make a vmap for the BFD "bf", which might be a member of the archive
277 BFD "arch". Return the new vmap. */
278 struct vmap *
279 map_vmap (bfd *bf, bfd *arch)
280 {
281 struct vmap_and_bfd vmap_bfd;
282 struct vmap *vp, **vpp;
283 struct objfile *obj;
284
285 vp = (void*) xmalloc (sizeof (*vp));
286 bzero (vp, sizeof (*vp));
287 vp->nxt = 0;
288 vp->bfd = bf;
289 vp->name = bfd_get_filename(arch ? arch : bf);
290 vp->member = arch ? bfd_get_filename(bf) : "";
291
292 vmap_bfd.pbfd = arch;
293 vmap_bfd.pvmap = vp;
294 bfd_map_over_sections (bf, sex_to_vmap, &vmap_bfd);
295
296 /* find the end of the list, and append. */
297 for (vpp = &vmap; *vpp; vpp = &(*vpp)->nxt)
298 ;
299 *vpp = vp;
300
301 return vp;
302 }
303
304
305 /* vmap_symtab - handle symbol translation on vmapping */
306
307 static void
308 vmap_symtab (vp)
309 register struct vmap *vp;
310 {
311 register struct objfile *objfile;
312 asection *textsec;
313 asection *datasec;
314 asection *bsssec;
315 CORE_ADDR text_delta;
316 CORE_ADDR data_delta;
317 CORE_ADDR bss_delta;
318 struct section_offsets *new_offsets;
319 int i;
320
321 objfile = vp->objfile;
322 if (objfile == NULL)
323 {
324 /* OK, it's not an objfile we opened ourselves.
325 Currently, that can only happen with the exec file, so
326 relocate the symbols for the symfile. */
327 if (symfile_objfile == NULL)
328 return;
329 objfile = symfile_objfile;
330 }
331
332 new_offsets = alloca
333 (sizeof (struct section_offsets)
334 + sizeof (new_offsets->offsets) * objfile->num_sections);
335
336 for (i = 0; i < objfile->num_sections; ++i)
337 ANOFFSET (new_offsets, i) = ANOFFSET (objfile->section_offsets, i);
338
339 textsec = bfd_get_section_by_name (vp->bfd, ".text");
340 text_delta =
341 vp->tstart - ANOFFSET (objfile->section_offsets, textsec->target_index);
342 ANOFFSET (new_offsets, textsec->target_index) = vp->tstart;
343
344 datasec = bfd_get_section_by_name (vp->bfd, ".data");
345 data_delta =
346 vp->dstart - ANOFFSET (objfile->section_offsets, datasec->target_index);
347 ANOFFSET (new_offsets, datasec->target_index) = vp->dstart;
348
349 bsssec = bfd_get_section_by_name (vp->bfd, ".bss");
350 bss_delta =
351 vp->dstart - ANOFFSET (objfile->section_offsets, bsssec->target_index);
352 ANOFFSET (new_offsets, bsssec->target_index) = vp->dstart;
353
354 objfile_relocate (objfile, new_offsets);
355
356 {
357 struct obj_section *s;
358 for (s = objfile->sections; s < objfile->sections_end; ++s)
359 {
360 if (s->sec_ptr->target_index == textsec->target_index)
361 {
362 s->addr += text_delta;
363 s->endaddr += text_delta;
364 }
365 else if (s->sec_ptr->target_index == datasec->target_index)
366 {
367 s->addr += data_delta;
368 s->endaddr += data_delta;
369 }
370 else if (s->sec_ptr->target_index == bsssec->target_index)
371 {
372 s->addr += bss_delta;
373 s->endaddr += bss_delta;
374 }
375 }
376 }
377
378 if (text_delta != 0)
379 /* breakpoints need to be relocated as well. */
380 fixup_breakpoints (0, TEXT_SEGMENT_BASE, text_delta);
381 }
382
383 /* Add symbols for an objfile. */
384 static int
385 objfile_symbol_add (arg)
386 char *arg;
387 {
388 struct objfile *obj = (struct objfile *) arg;
389 syms_from_objfile (obj, 0, 0, 0);
390 new_symfile_objfile (obj, 0, 0);
391 return 1;
392 }
393
394 static struct vmap *add_vmap PARAMS ((struct ld_info *));
395
396 /* Add a new vmap entry based on ldinfo() information.
397
398 If ldi->ldinfo_fd is not valid (e.g. this struct ld_info is from a
399 core file), the caller should set it to -1, and we will open the file.
400
401 Return the vmap new entry. */
402 static struct vmap *
403 add_vmap(ldi)
404 register struct ld_info *ldi;
405 {
406 bfd *bfd, *last;
407 register char *mem, *objname;
408 struct objfile *obj;
409 struct vmap *vp;
410
411 /* This ldi structure was allocated using alloca() in
412 xcoff_relocate_symtab(). Now we need to have persistent object
413 and member names, so we should save them. */
414
415 mem = ldi->ldinfo_filename + strlen(ldi->ldinfo_filename) + 1;
416 mem = savestring (mem, strlen (mem));
417 objname = savestring (ldi->ldinfo_filename, strlen (ldi->ldinfo_filename));
418
419 if (ldi->ldinfo_fd < 0)
420 /* Note that this opens it once for every member; a possible
421 enhancement would be to only open it once for every object. */
422 bfd = bfd_openr (objname, NULL);
423 else
424 bfd = bfd_fdopenr(objname, NULL, ldi->ldinfo_fd);
425 if (!bfd)
426 error("Could not open `%s' as an executable file: %s",
427 objname, bfd_errmsg(bfd_error));
428
429
430 /* make sure we have an object file */
431
432 if (bfd_check_format(bfd, bfd_object))
433 vp = map_vmap (bfd, 0);
434
435 else if (bfd_check_format(bfd, bfd_archive)) {
436 last = 0;
437 /*
438 * FIXME??? am I tossing BFDs? bfd?
439 */
440 while (last = bfd_openr_next_archived_file(bfd, last))
441 if (STREQ(mem, last->filename))
442 break;
443
444 if (!last) {
445 bfd_close(bfd);
446 /* FIXME -- should be error */
447 warning("\"%s\": member \"%s\" missing.", bfd->filename, mem);
448 return;
449 }
450
451 if (!bfd_check_format(last, bfd_object)) {
452 bfd_close(last); /* XXX??? */
453 goto obj_err;
454 }
455
456 vp = map_vmap (last, bfd);
457 }
458 else {
459 obj_err:
460 bfd_close(bfd);
461 error ("\"%s\": not in executable format: %s.",
462 objname, bfd_errmsg(bfd_error));
463 /*NOTREACHED*/
464 }
465 obj = allocate_objfile (vp->bfd, 0);
466 vp->objfile = obj;
467
468 #ifndef SOLIB_SYMBOLS_MANUAL
469 if (catch_errors (objfile_symbol_add, (char *)obj,
470 "Error while reading shared library symbols:\n"))
471 {
472 /* Note this is only done if symbol reading was successful. */
473 vmap_symtab (vp);
474 vp->loaded = 1;
475 }
476 #endif
477 return vp;
478 }
479
480
481 /* As well as symbol tables, exec_sections need relocation. After
482 the inferior process' termination, there will be a relocated symbol
483 table exist with no corresponding inferior process. At that time, we
484 need to use `exec' bfd, rather than the inferior process's memory space
485 to look up symbols.
486
487 `exec_sections' need to be relocated only once, as long as the exec
488 file remains unchanged.
489 */
490 vmap_exec ()
491 {
492 static bfd *execbfd;
493 int i;
494
495 if (execbfd == exec_bfd)
496 return;
497
498 execbfd = exec_bfd;
499
500 if (!vmap || !exec_ops.to_sections)
501 error ("vmap_exec: vmap or exec_ops.to_sections == 0\n");
502
503 for (i=0; &exec_ops.to_sections[i] < exec_ops.to_sections_end; i++)
504 {
505 if (STREQ(".text", exec_ops.to_sections[i].sec_ptr->name))
506 {
507 exec_ops.to_sections[i].addr += vmap->tstart;
508 exec_ops.to_sections[i].endaddr += vmap->tstart;
509 }
510 else if (STREQ(".data", exec_ops.to_sections[i].sec_ptr->name))
511 {
512 exec_ops.to_sections[i].addr += vmap->dstart;
513 exec_ops.to_sections[i].endaddr += vmap->dstart;
514 }
515 }
516 }
517
518 #if 0
519 /* This was for the old, half-assed, core file support. */
520 int
521 text_adjustment (abfd)
522 bfd *abfd;
523 {
524 static bfd *execbfd;
525 static int adjustment;
526 sec_ptr sect;
527
528 if (exec_bfd == execbfd)
529 return adjustment;
530
531 sect = bfd_get_section_by_name (abfd, ".text");
532 if (sect)
533 adjustment = sect->filepos - sect->vma;
534 else
535 adjustment = 0x200; /* just a wild assumption */
536
537 return adjustment;
538 }
539 #endif
540
541 /*
542 * vmap_ldinfo - update VMAP info with ldinfo() information
543 *
544 * Input:
545 * ldi - ^ to ldinfo() results.
546 */
547 vmap_ldinfo(ldi)
548 register struct ld_info *ldi;
549 {
550 struct stat ii, vi;
551 register struct vmap *vp;
552 register got_one, retried;
553 CORE_ADDR ostart;
554
555 /*
556 * for each *ldi, see if we have a corresponding *vp
557 * if so, update the mapping, and symbol table.
558 * if not, add an entry and symbol table.
559 */
560 do {
561 char *name = ldi->ldinfo_filename;
562 char *memb = name + strlen(name) + 1;
563
564 retried = 0;
565
566 if (fstat(ldi->ldinfo_fd, &ii) < 0)
567 fatal("cannot fstat(%d) on %s"
568 , ldi->ldinfo_fd
569 , name);
570 retry:
571 for (got_one = 0, vp = vmap; vp; vp = vp->nxt) {
572 FILE *io;
573
574 /* First try to find a `vp', which is the same as in ldinfo.
575 If not the same, just continue and grep the next `vp'. If same,
576 relocate its tstart, tend, dstart, dend values. If no such `vp'
577 found, get out of this for loop, add this ldi entry as a new vmap
578 (add_vmap) and come back, fins its `vp' and so on... */
579
580 /* The filenames are not always sufficient to match on. */
581
582 if ((name[0] == '/' && !STREQ(name, vp->name))
583 || (memb[0] && !STREQ(memb, vp->member)))
584 continue;
585
586 io = bfd_cache_lookup(vp->bfd); /* totally opaque! */
587 if (!io)
588 fatal("cannot find BFD's iostream for %s", vp->name);
589
590 /* see if we are referring to the same file */
591
592 if (fstat(fileno(io), &vi) < 0)
593 fatal("cannot fstat BFD for %s", vp->name);
594
595 if (ii.st_dev != vi.st_dev || ii.st_ino != vi.st_ino)
596 continue;
597
598 if (!retried)
599 close(ldi->ldinfo_fd);
600
601 ++got_one;
602
603 /* found a corresponding VMAP. remap! */
604 ostart = vp->tstart;
605
606 /* We can assume pointer == CORE_ADDR, this code is native only. */
607 vp->tstart = (CORE_ADDR) ldi->ldinfo_textorg;
608 vp->tend = vp->tstart + ldi->ldinfo_textsize;
609 vp->dstart = (CORE_ADDR) ldi->ldinfo_dataorg;
610 vp->dend = vp->dstart + ldi->ldinfo_datasize;
611
612 if (vp->tadj) {
613 vp->tstart += vp->tadj;
614 vp->tend += vp->tadj;
615 }
616
617 /* relocate symbol table(s). */
618 vmap_symtab (vp);
619
620 /* there may be more, so we don't break out of the loop. */
621 }
622
623 /* if there was no matching *vp, we must perforce create the sucker(s) */
624 if (!got_one && !retried) {
625 add_vmap(ldi);
626 ++retried;
627 goto retry;
628 }
629 } while (ldi->ldinfo_next
630 && (ldi = (void *) (ldi->ldinfo_next + (char *) ldi)));
631
632 }
633
634 /*
635 * vmap_inferior - print VMAP info for inferior
636 */
637 vmap_inferior() {
638
639 if (inferior_pid == 0)
640 return 0; /* normal processing */
641
642 exec_files_info();
643 return 1;
644 }
645
646 /* Read or write the exec file.
647
648 Args are address within exec file, address within gdb address-space,
649 length, and a flag indicating whether to read or write.
650
651 Result is a length:
652
653 0: We cannot handle this address and length.
654 > 0: We have handled N bytes starting at this address.
655 (If N == length, we did it all.) We might be able
656 to handle more bytes beyond this length, but no
657 promises.
658 < 0: We cannot handle this address, but if somebody
659 else handles (-N) bytes, we can start from there.
660
661 The same routine is used to handle both core and exec files;
662 we just tail-call it with more arguments to select between them. */
663
664 int
665 xfer_memory (memaddr, myaddr, len, write, target)
666 CORE_ADDR memaddr;
667 char *myaddr;
668 int len;
669 int write;
670 struct target_ops *target;
671 {
672 boolean res;
673 struct section_table *p;
674 CORE_ADDR nextsectaddr, memend;
675 boolean (*xfer_fn) PARAMS ((bfd *, sec_ptr, PTR, file_ptr, bfd_size_type));
676
677 if (len <= 0)
678 fatal ("aborting");
679
680 memend = memaddr + len;
681 xfer_fn = write? bfd_set_section_contents: bfd_get_section_contents;
682 nextsectaddr = memend;
683
684 for (p = target->to_sections; p < target->to_sections_end; p++)
685 {
686 if (p->addr <= memaddr)
687 if (p->endaddr >= memend)
688 {
689 /* Entire transfer is within this section. */
690 res = xfer_fn (p->bfd, p->sec_ptr, myaddr, memaddr - p->addr, len);
691 return (res != false)? len: 0;
692 }
693 else if (p->endaddr <= memaddr)
694 {
695 /* This section ends before the transfer starts. */
696 continue;
697 }
698 else
699 {
700 /* This section overlaps the transfer. Just do half. */
701 len = p->endaddr - memaddr;
702 res = xfer_fn (p->bfd, p->sec_ptr, myaddr, memaddr - p->addr, len);
703 return (res != false)? len: 0;
704 }
705 else if (p->addr < nextsectaddr)
706 nextsectaddr = p->addr;
707 }
708
709 if (nextsectaddr >= memend)
710 return 0; /* We can't help */
711 else
712 return - (nextsectaddr - memaddr); /* Next boundary where we can help */
713 }
714
715 void
716 print_section_info (t, abfd)
717 struct target_ops *t;
718 bfd *abfd;
719 {
720 struct section_table *p;
721
722 printf_filtered ("\t`%s', ", bfd_get_filename(abfd));
723 wrap_here (" ");
724 printf_filtered ("file type %s.\n", bfd_get_target(abfd));
725
726 for (p = t->to_sections; p < t->to_sections_end; p++) {
727 printf_filtered ("\t%s", local_hex_string_custom (p->addr, "08"));
728 printf_filtered (" - %s", local_hex_string_custom (p->endaddr, "08"));
729 if (info_verbose)
730 printf_filtered (" @ %s",
731 local_hex_string_custom (p->sec_ptr->filepos, "08"));
732 printf_filtered (" is %s", bfd_section_name (p->bfd, p->sec_ptr));
733 if (p->bfd != abfd) {
734 printf_filtered (" in %s", bfd_get_filename (p->bfd));
735 }
736 printf_filtered ("\n");
737 }
738 }
739
740
741 static void
742 exec_files_info (t)
743 struct target_ops *t;
744 {
745 register struct vmap *vp = vmap;
746
747 print_section_info (t, exec_bfd);
748
749 if (!vp)
750 return;
751
752 printf("\tMapping info for file `%s'.\n", vp->name);
753
754 printf("\t %8.8s %8.8s %8.8s %8.8s %8.8s %s\n",
755 "tstart", "tend", "dstart", "dend", "section", "file(member)");
756
757 for (; vp; vp = vp->nxt)
758 printf("\t0x%8.8x 0x%8.8x 0x%8.8x 0x%8.8x %s%s%s%s\n",
759 vp->tstart,
760 vp->tend,
761 vp->dstart,
762 vp->dend,
763 vp->name,
764 *vp->member ? "(" : "",
765 vp->member,
766 *vp->member ? ")" : "");
767 }
768
769 #ifdef DAMON
770 /* Damon's implementation of set_section_command! It is based on the sex member
771 (which is a section pointer from vmap) of vmap.
772 We will not have multiple vmap entries (one for each section), rather transmit
773 text and data base offsets and fix them at the same time. Elimination of sex
774 entry in vmap make this function obsolute, use the one from exec.c.
775 Need further testing!! FIXMEmgo. */
776
777 static void
778 set_section_command(args, from_tty)
779 char *args;
780 {
781 register struct vmap *vp = vmap;
782 char *secname;
783 unsigned seclen;
784 unsigned long secaddr;
785 char secprint[100];
786 long offset;
787
788 if (args == 0)
789 error("Must specify section name and its virtual address");
790
791 /* Parse out section name */
792 for (secname = args; !isspace(*args); args++)
793 ;
794 seclen = args - secname;
795
796 /* Parse out new virtual address */
797 secaddr = parse_and_eval_address(args);
798
799 for (vp = vmap; vp; vp = vp->nxt) {
800 if (!strncmp(secname
801 , bfd_section_name(vp->bfd, vp->sex), seclen)
802 && bfd_section_name(vp->bfd, vp->sex)[seclen] == '\0') {
803 offset = secaddr - vp->tstart;
804 vp->tstart += offset;
805 vp->tend += offset;
806 exec_files_info();
807 return;
808 }
809 }
810
811 if (seclen >= sizeof(secprint))
812 seclen = sizeof(secprint) - 1;
813 strncpy(secprint, secname, seclen);
814 secprint[seclen] = '\0';
815 error("Section %s not found", secprint);
816 }
817 #else
818 static void
819 set_section_command (args, from_tty)
820 char *args;
821 int from_tty;
822 {
823 struct section_table *p;
824 char *secname;
825 unsigned seclen;
826 unsigned long secaddr;
827 char secprint[100];
828 long offset;
829
830 if (args == 0)
831 error ("Must specify section name and its virtual address");
832
833 /* Parse out section name */
834 for (secname = args; !isspace(*args); args++) ;
835 seclen = args - secname;
836
837 /* Parse out new virtual address */
838 secaddr = parse_and_eval_address (args);
839
840 for (p = exec_ops.to_sections; p < exec_ops.to_sections_end; p++) {
841 if (!strncmp (secname, bfd_section_name (exec_bfd, p->sec_ptr), seclen)
842 && bfd_section_name (exec_bfd, p->sec_ptr)[seclen] == '\0') {
843 offset = secaddr - p->addr;
844 p->addr += offset;
845 p->endaddr += offset;
846 if (from_tty)
847 exec_files_info(&exec_ops);
848 return;
849 }
850 }
851 if (seclen >= sizeof (secprint))
852 seclen = sizeof (secprint) - 1;
853 strncpy (secprint, secname, seclen);
854 secprint[seclen] = '\0';
855 error ("Section %s not found", secprint);
856 }
857
858 #endif /* !DAMON */
859
860 struct target_ops exec_ops = {
861 "exec", "Local exec file",
862 "Use an executable file as a target.\n\
863 Specify the filename of the executable file.",
864 exec_file_command, exec_close, /* open, close */
865 find_default_attach, 0, 0, 0, /* attach, detach, resume, wait, */
866 0, 0, /* fetch_registers, store_registers, */
867 0, /* prepare_to_store */
868 xfer_memory, exec_files_info,
869 0, 0, /* insert_breakpoint, remove_breakpoint, */
870 0, 0, 0, 0, 0, /* terminal stuff */
871 0, 0, /* kill, load */
872 0, /* lookup sym */
873 find_default_create_inferior,
874 0, /* mourn_inferior */
875 0, /* can_run */
876 0, /* notice_signals */
877 file_stratum, 0, /* next */
878 0, 1, 0, 0, 0, /* all mem, mem, stack, regs, exec */
879 0, 0, /* section pointers */
880 OPS_MAGIC, /* Always the last thing */
881 };
882 \f
883 /* Core file stuff. */
884
885 /* Relocate symtabs and read in shared library info, based on symbols
886 from the core file. */
887 void
888 xcoff_relocate_core ()
889 {
890 /* Offset of member MEMBER in a struct of type TYPE. */
891 #ifndef offsetof
892 #define offsetof(TYPE, MEMBER) ((int) &((TYPE *)0)->MEMBER)
893 #endif
894
895 /* Size of a struct ld_info except for the variable-length filename. */
896 #define LDINFO_SIZE (offsetof (struct ld_info, ldinfo_filename))
897
898 sec_ptr ldinfo_sec;
899 int offset = 0;
900 struct ld_info *ldip;
901 struct vmap *vp;
902
903 /* Allocated size of buffer. */
904 int buffer_size = LDINFO_SIZE;
905 char *buffer = xmalloc (buffer_size);
906 struct cleanup *old = make_cleanup (free_current_contents, &buffer);
907
908 /* FIXME, this restriction should not exist. For now, though I'll
909 avoid coredumps with error() pending a real fix. */
910 if (vmap == NULL)
911 error
912 ("Can't debug a core file without an executable file (on the RS/6000)");
913
914 ldinfo_sec = bfd_get_section_by_name (core_bfd, ".ldinfo");
915 if (ldinfo_sec == NULL)
916 {
917 bfd_err:
918 fprintf_filtered (stderr, "Couldn't get ldinfo from core file: %s\n",
919 bfd_errmsg (bfd_error));
920 do_cleanups (old);
921 return;
922 }
923 do
924 {
925 int i;
926 int names_found = 0;
927
928 /* Read in everything but the name. */
929 if (bfd_get_section_contents (core_bfd, ldinfo_sec, buffer,
930 offset, LDINFO_SIZE) == 0)
931 goto bfd_err;
932
933 /* Now the name. */
934 i = LDINFO_SIZE;
935 do
936 {
937 if (i == buffer_size)
938 {
939 buffer_size *= 2;
940 buffer = xrealloc (buffer, buffer_size);
941 }
942 if (bfd_get_section_contents (core_bfd, ldinfo_sec, &buffer[i],
943 offset + i, 1) == 0)
944 goto bfd_err;
945 if (buffer[i++] == '\0')
946 ++names_found;
947 } while (names_found < 2);
948
949 ldip = (struct ld_info *)buffer;
950
951 /* Can't use a file descriptor from the core file; need to open it. */
952 ldip->ldinfo_fd = -1;
953
954 /* The first ldinfo is for the exec file, allocated elsewhere. */
955 if (offset == 0)
956 vp = vmap;
957 else
958 vp = add_vmap (ldip);
959
960 offset += ldip->ldinfo_next;
961
962 /* We can assume pointer == CORE_ADDR, this code is native only. */
963 vp->tstart = (CORE_ADDR) ldip->ldinfo_textorg;
964 vp->tend = vp->tstart + ldip->ldinfo_textsize;
965 vp->dstart = (CORE_ADDR) ldip->ldinfo_dataorg;
966 vp->dend = vp->dstart + ldip->ldinfo_datasize;
967
968 if (vp->tadj != 0) {
969 vp->tstart += vp->tadj;
970 vp->tend += vp->tadj;
971 }
972
973 /* Unless this is the exec file,
974 add our sections to the section table for the core target. */
975 if (vp != vmap)
976 {
977 int count;
978 struct section_table *stp;
979
980 count = core_ops.to_sections_end - core_ops.to_sections;
981 count += 2;
982 core_ops.to_sections = (struct section_table *)
983 xrealloc (core_ops.to_sections,
984 sizeof (struct section_table) * count);
985 core_ops.to_sections_end = core_ops.to_sections + count;
986 stp = core_ops.to_sections_end - 2;
987
988 /* "Why do we add bfd_section_vma?", I hear you cry.
989 Well, the start of the section in the file is actually
990 that far into the section as the struct vmap understands it.
991 So for text sections, bfd_section_vma tends to be 0x200,
992 and if vp->tstart is 0xd0002000, then the first byte of
993 the text section on disk corresponds to address 0xd0002200. */
994 stp->bfd = vp->bfd;
995 stp->sec_ptr = bfd_get_section_by_name (stp->bfd, ".text");
996 stp->addr = bfd_section_vma (stp->bfd, stp->sec_ptr) + vp->tstart;
997 stp->endaddr = bfd_section_vma (stp->bfd, stp->sec_ptr) + vp->tend;
998 stp++;
999
1000 stp->bfd = vp->bfd;
1001 stp->sec_ptr = bfd_get_section_by_name (stp->bfd, ".data");
1002 stp->addr = bfd_section_vma (stp->bfd, stp->sec_ptr) + vp->dstart;
1003 stp->endaddr = bfd_section_vma (stp->bfd, stp->sec_ptr) + vp->dend;
1004 }
1005
1006 vmap_symtab (vp);
1007
1008 add_text_to_loadinfo ((CORE_ADDR)ldip->ldinfo_textorg,
1009 (CORE_ADDR)ldip->ldinfo_dataorg);
1010 } while (ldip->ldinfo_next != 0);
1011 vmap_exec ();
1012 do_cleanups (old);
1013 }
1014
1015 void
1016 _initialize_exec()
1017 {
1018
1019 add_com("file", class_files, file_command,
1020 "Use FILE as program to be debugged.\n\
1021 It is read for its symbols, for getting the contents of pure memory,\n\
1022 and it is the program executed when you use the `run' command.\n\
1023 If FILE cannot be found as specified, your execution directory path\n\
1024 ($PATH) is searched for a command of that name.\n\
1025 No arg means to have no executable file and no symbols.");
1026
1027 add_com("exec-file", class_files, exec_file_command,
1028 "Use FILE as program for getting contents of pure memory.\n\
1029 If FILE cannot be found as specified, your execution directory path\n\
1030 is searched for a command of that name.\n\
1031 No arg means have no executable file.");
1032
1033 add_com("section", class_files, set_section_command,
1034 "Change the base address of section SECTION of the exec file to ADDR.\n\
1035 This can be used if the exec file does not contain section addresses,\n\
1036 (such as in the a.out format), or when the addresses specified in the\n\
1037 file itself are wrong. Each section must be changed separately. The\n\
1038 ``info files'' command lists all the sections and their addresses.");
1039
1040 add_target(&exec_ops);
1041 }
This page took 0.04971 seconds and 4 git commands to generate.