2013-01-31 Aleksandar Ristovski <aristovski@qnx.com>
[deliverable/binutils-gdb.git] / gdb / exec.c
1 /* Work with executable files, for GDB.
2
3 Copyright (C) 1988-2013 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20 #include "defs.h"
21 #include "frame.h"
22 #include "inferior.h"
23 #include "target.h"
24 #include "gdbcmd.h"
25 #include "language.h"
26 #include "filenames.h"
27 #include "symfile.h"
28 #include "objfiles.h"
29 #include "completer.h"
30 #include "value.h"
31 #include "exec.h"
32 #include "observer.h"
33 #include "arch-utils.h"
34 #include "gdbthread.h"
35 #include "progspace.h"
36 #include "gdb_bfd.h"
37
38 #include <fcntl.h>
39 #include "readline/readline.h"
40 #include "gdb_string.h"
41
42 #include "gdbcore.h"
43
44 #include <ctype.h>
45 #include "gdb_stat.h"
46
47 #include "xcoffsolib.h"
48
49 struct vmap *map_vmap (bfd *, bfd *);
50
51 void (*deprecated_file_changed_hook) (char *);
52
53 /* Prototypes for local functions */
54
55 static void file_command (char *, int);
56
57 static void set_section_command (char *, int);
58
59 static void exec_files_info (struct target_ops *);
60
61 static void init_exec_ops (void);
62
63 void _initialize_exec (void);
64
65 /* The target vector for executable files. */
66
67 struct target_ops exec_ops;
68
69 /* True if the exec target is pushed on the stack. */
70 static int using_exec_ops;
71
72 /* Whether to open exec and core files read-only or read-write. */
73
74 int write_files = 0;
75 static void
76 show_write_files (struct ui_file *file, int from_tty,
77 struct cmd_list_element *c, const char *value)
78 {
79 fprintf_filtered (file, _("Writing into executable and core files is %s.\n"),
80 value);
81 }
82
83
84 struct vmap *vmap;
85
86 static void
87 exec_open (char *args, int from_tty)
88 {
89 target_preopen (from_tty);
90 exec_file_attach (args, from_tty);
91 }
92
93 /* Close and clear exec_bfd. If we end up with no target sections to
94 read memory from, this unpushes the exec_ops target. */
95
96 void
97 exec_close (void)
98 {
99 if (exec_bfd)
100 {
101 bfd *abfd = exec_bfd;
102
103 gdb_bfd_unref (abfd);
104
105 /* Removing target sections may close the exec_ops target.
106 Clear exec_bfd before doing so to prevent recursion. */
107 exec_bfd = NULL;
108 exec_bfd_mtime = 0;
109
110 remove_target_sections (&exec_bfd, abfd);
111 }
112 }
113
114 /* This is the target_close implementation. Clears all target
115 sections and closes all executable bfds from all program spaces. */
116
117 static void
118 exec_close_1 (int quitting)
119 {
120 struct vmap *vp, *nxt;
121
122 using_exec_ops = 0;
123
124 for (nxt = vmap; nxt != NULL;)
125 {
126 vp = nxt;
127 nxt = vp->nxt;
128
129 if (vp->objfile)
130 free_objfile (vp->objfile);
131
132 gdb_bfd_unref (vp->bfd);
133
134 xfree (vp);
135 }
136
137 vmap = NULL;
138
139 {
140 struct program_space *ss;
141 struct cleanup *old_chain;
142
143 old_chain = save_current_program_space ();
144 ALL_PSPACES (ss)
145 {
146 set_current_program_space (ss);
147
148 /* Delete all target sections. */
149 resize_section_table
150 (current_target_sections,
151 -resize_section_table (current_target_sections, 0));
152
153 exec_close ();
154 }
155
156 do_cleanups (old_chain);
157 }
158 }
159
160 void
161 exec_file_clear (int from_tty)
162 {
163 /* Remove exec file. */
164 exec_close ();
165
166 if (from_tty)
167 printf_unfiltered (_("No executable file now.\n"));
168 }
169
170 /* Set FILENAME as the new exec file.
171
172 This function is intended to be behave essentially the same
173 as exec_file_command, except that the latter will detect when
174 a target is being debugged, and will ask the user whether it
175 should be shut down first. (If the answer is "no", then the
176 new file is ignored.)
177
178 This file is used by exec_file_command, to do the work of opening
179 and processing the exec file after any prompting has happened.
180
181 And, it is used by child_attach, when the attach command was
182 given a pid but not a exec pathname, and the attach command could
183 figure out the pathname from the pid. (In this case, we shouldn't
184 ask the user whether the current target should be shut down --
185 we're supplying the exec pathname late for good reason.) */
186
187 void
188 exec_file_attach (char *filename, int from_tty)
189 {
190 /* Remove any previous exec file. */
191 exec_close ();
192
193 /* Now open and digest the file the user requested, if any. */
194
195 if (!filename)
196 {
197 if (from_tty)
198 printf_unfiltered (_("No executable file now.\n"));
199
200 set_gdbarch_from_file (NULL);
201 }
202 else
203 {
204 struct cleanup *cleanups;
205 char *scratch_pathname;
206 int scratch_chan;
207 struct target_section *sections = NULL, *sections_end = NULL;
208 char **matching;
209
210 scratch_chan = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST, filename,
211 write_files ? O_RDWR | O_BINARY : O_RDONLY | O_BINARY,
212 &scratch_pathname);
213 #if defined(__GO32__) || defined(_WIN32) || defined(__CYGWIN__)
214 if (scratch_chan < 0)
215 {
216 char *exename = alloca (strlen (filename) + 5);
217
218 strcat (strcpy (exename, filename), ".exe");
219 scratch_chan = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST, exename,
220 write_files ? O_RDWR | O_BINARY : O_RDONLY | O_BINARY,
221 &scratch_pathname);
222 }
223 #endif
224 if (scratch_chan < 0)
225 perror_with_name (filename);
226
227 cleanups = make_cleanup (xfree, scratch_pathname);
228
229 if (write_files)
230 exec_bfd = gdb_bfd_fopen (scratch_pathname, gnutarget,
231 FOPEN_RUB, scratch_chan);
232 else
233 exec_bfd = gdb_bfd_open (scratch_pathname, gnutarget, scratch_chan);
234
235 if (!exec_bfd)
236 {
237 error (_("\"%s\": could not open as an executable file: %s"),
238 scratch_pathname, bfd_errmsg (bfd_get_error ()));
239 }
240
241 if (!bfd_check_format_matches (exec_bfd, bfd_object, &matching))
242 {
243 /* Make sure to close exec_bfd, or else "run" might try to use
244 it. */
245 exec_close ();
246 error (_("\"%s\": not in executable format: %s"),
247 scratch_pathname,
248 gdb_bfd_errmsg (bfd_get_error (), matching));
249 }
250
251 /* FIXME - This should only be run for RS6000, but the ifdef is a poor
252 way to accomplish. */
253 #ifdef DEPRECATED_IBM6000_TARGET
254 /* Setup initial vmap. */
255
256 map_vmap (exec_bfd, 0);
257 if (vmap == NULL)
258 {
259 /* Make sure to close exec_bfd, or else "run" might try to use
260 it. */
261 exec_close ();
262 error (_("\"%s\": can't find the file sections: %s"),
263 scratch_pathname, bfd_errmsg (bfd_get_error ()));
264 }
265 #endif /* DEPRECATED_IBM6000_TARGET */
266
267 if (build_section_table (exec_bfd, &sections, &sections_end))
268 {
269 /* Make sure to close exec_bfd, or else "run" might try to use
270 it. */
271 exec_close ();
272 error (_("\"%s\": can't find the file sections: %s"),
273 scratch_pathname, bfd_errmsg (bfd_get_error ()));
274 }
275
276 exec_bfd_mtime = bfd_get_mtime (exec_bfd);
277
278 validate_files ();
279
280 set_gdbarch_from_file (exec_bfd);
281
282 /* Add the executable's sections to the current address spaces'
283 list of sections. This possibly pushes the exec_ops
284 target. */
285 add_target_sections (&exec_bfd, sections, sections_end);
286 xfree (sections);
287
288 /* Tell display code (if any) about the changed file name. */
289 if (deprecated_exec_file_display_hook)
290 (*deprecated_exec_file_display_hook) (filename);
291
292 do_cleanups (cleanups);
293 }
294 bfd_cache_close_all ();
295 observer_notify_executable_changed ();
296 }
297
298 /* Process the first arg in ARGS as the new exec file.
299
300 Note that we have to explicitly ignore additional args, since we can
301 be called from file_command(), which also calls symbol_file_command()
302 which can take multiple args.
303
304 If ARGS is NULL, we just want to close the exec file. */
305
306 static void
307 exec_file_command (char *args, int from_tty)
308 {
309 char **argv;
310 char *filename;
311
312 if (from_tty && target_has_execution
313 && !query (_("A program is being debugged already.\n"
314 "Are you sure you want to change the file? ")))
315 error (_("File not changed."));
316
317 if (args)
318 {
319 struct cleanup *cleanups;
320
321 /* Scan through the args and pick up the first non option arg
322 as the filename. */
323
324 argv = gdb_buildargv (args);
325 cleanups = make_cleanup_freeargv (argv);
326
327 for (; (*argv != NULL) && (**argv == '-'); argv++)
328 {;
329 }
330 if (*argv == NULL)
331 error (_("No executable file name was specified"));
332
333 filename = tilde_expand (*argv);
334 make_cleanup (xfree, filename);
335 exec_file_attach (filename, from_tty);
336
337 do_cleanups (cleanups);
338 }
339 else
340 exec_file_attach (NULL, from_tty);
341 }
342
343 /* Set both the exec file and the symbol file, in one command.
344 What a novelty. Why did GDB go through four major releases before this
345 command was added? */
346
347 static void
348 file_command (char *arg, int from_tty)
349 {
350 /* FIXME, if we lose on reading the symbol file, we should revert
351 the exec file, but that's rough. */
352 exec_file_command (arg, from_tty);
353 symbol_file_command (arg, from_tty);
354 if (deprecated_file_changed_hook)
355 deprecated_file_changed_hook (arg);
356 }
357 \f
358
359 /* Locate all mappable sections of a BFD file.
360 table_pp_char is a char * to get it through bfd_map_over_sections;
361 we cast it back to its proper type. */
362
363 static void
364 add_to_section_table (bfd *abfd, struct bfd_section *asect,
365 void *table_pp_char)
366 {
367 struct target_section **table_pp = (struct target_section **) table_pp_char;
368 flagword aflag;
369
370 /* Check the section flags, but do not discard zero-length sections, since
371 some symbols may still be attached to this section. For instance, we
372 encountered on sparc-solaris 2.10 a shared library with an empty .bss
373 section to which a symbol named "_end" was attached. The address
374 of this symbol still needs to be relocated. */
375 aflag = bfd_get_section_flags (abfd, asect);
376 if (!(aflag & SEC_ALLOC))
377 return;
378
379 (*table_pp)->key = NULL;
380 (*table_pp)->bfd = abfd;
381 (*table_pp)->the_bfd_section = asect;
382 (*table_pp)->addr = bfd_section_vma (abfd, asect);
383 (*table_pp)->endaddr = (*table_pp)->addr + bfd_section_size (abfd, asect);
384 (*table_pp)++;
385 }
386
387 int
388 resize_section_table (struct target_section_table *table, int num_added)
389 {
390 int old_count;
391 int new_count;
392
393 old_count = table->sections_end - table->sections;
394
395 new_count = num_added + old_count;
396
397 if (new_count)
398 {
399 table->sections = xrealloc (table->sections,
400 sizeof (struct target_section) * new_count);
401 table->sections_end = table->sections + new_count;
402 }
403 else
404 {
405 xfree (table->sections);
406 table->sections = table->sections_end = NULL;
407 }
408
409 return old_count;
410 }
411
412 /* Builds a section table, given args BFD, SECTABLE_PTR, SECEND_PTR.
413 Returns 0 if OK, 1 on error. */
414
415 int
416 build_section_table (struct bfd *some_bfd, struct target_section **start,
417 struct target_section **end)
418 {
419 unsigned count;
420
421 count = bfd_count_sections (some_bfd);
422 if (*start)
423 xfree (* start);
424 *start = (struct target_section *) xmalloc (count * sizeof (**start));
425 *end = *start;
426 bfd_map_over_sections (some_bfd, add_to_section_table, (char *) end);
427 if (*end > *start + count)
428 internal_error (__FILE__, __LINE__,
429 _("failed internal consistency check"));
430 /* We could realloc the table, but it probably loses for most files. */
431 return 0;
432 }
433
434 /* Add the sections array defined by [SECTIONS..SECTIONS_END[ to the
435 current set of target sections. */
436
437 void
438 add_target_sections (void *key,
439 struct target_section *sections,
440 struct target_section *sections_end)
441 {
442 int count;
443 struct target_section_table *table = current_target_sections;
444
445 count = sections_end - sections;
446
447 if (count > 0)
448 {
449 int space = resize_section_table (table, count);
450 int i;
451
452 for (i = 0; i < count; ++i)
453 {
454 table->sections[space + i] = sections[i];
455 table->sections[space + i].key = key;
456 }
457
458 /* If these are the first file sections we can provide memory
459 from, push the file_stratum target. */
460 if (!using_exec_ops)
461 {
462 using_exec_ops = 1;
463 push_target (&exec_ops);
464 }
465 }
466 }
467
468 /* Remove all target sections taken from ABFD. */
469
470 void
471 remove_target_sections (void *key, bfd *abfd)
472 {
473 struct target_section *src, *dest;
474 struct target_section_table *table = current_target_sections;
475
476 dest = table->sections;
477 for (src = table->sections; src < table->sections_end; src++)
478 if (src->key != key || src->bfd != abfd)
479 {
480 /* Keep this section. */
481 if (dest < src)
482 *dest = *src;
483 dest++;
484 }
485
486 /* If we've dropped any sections, resize the section table. */
487 if (dest < src)
488 {
489 int old_count;
490
491 old_count = resize_section_table (table, dest - src);
492
493 /* If we don't have any more sections to read memory from,
494 remove the file_stratum target from the stack. */
495 if (old_count + (dest - src) == 0)
496 {
497 struct program_space *pspace;
498
499 ALL_PSPACES (pspace)
500 if (pspace->target_sections.sections
501 != pspace->target_sections.sections_end)
502 return;
503
504 unpush_target (&exec_ops);
505 }
506 }
507 }
508
509 \f
510 static void
511 bfdsec_to_vmap (struct bfd *abfd, struct bfd_section *sect, void *arg3)
512 {
513 struct vmap_and_bfd *vmap_bfd = (struct vmap_and_bfd *) arg3;
514 struct vmap *vp;
515
516 vp = vmap_bfd->pvmap;
517
518 if ((bfd_get_section_flags (abfd, sect) & SEC_LOAD) == 0)
519 return;
520
521 if (strcmp (bfd_section_name (abfd, sect), ".text") == 0)
522 {
523 vp->tstart = bfd_section_vma (abfd, sect);
524 vp->tend = vp->tstart + bfd_section_size (abfd, sect);
525 vp->tvma = bfd_section_vma (abfd, sect);
526 vp->toffs = sect->filepos;
527 }
528 else if (strcmp (bfd_section_name (abfd, sect), ".data") == 0)
529 {
530 vp->dstart = bfd_section_vma (abfd, sect);
531 vp->dend = vp->dstart + bfd_section_size (abfd, sect);
532 vp->dvma = bfd_section_vma (abfd, sect);
533 }
534 /* Silently ignore other types of sections. (FIXME?) */
535 }
536
537 /* Make a vmap for ABFD which might be a member of the archive ARCH.
538 Return the new vmap. */
539
540 struct vmap *
541 map_vmap (bfd *abfd, bfd *arch)
542 {
543 struct vmap_and_bfd vmap_bfd;
544 struct vmap *vp, **vpp;
545
546 vp = (struct vmap *) xmalloc (sizeof (*vp));
547 memset ((char *) vp, '\0', sizeof (*vp));
548 vp->nxt = 0;
549 vp->bfd = abfd;
550 gdb_bfd_ref (abfd);
551 vp->name = bfd_get_filename (arch ? arch : abfd);
552 vp->member = arch ? bfd_get_filename (abfd) : "";
553
554 vmap_bfd.pbfd = arch;
555 vmap_bfd.pvmap = vp;
556 bfd_map_over_sections (abfd, bfdsec_to_vmap, &vmap_bfd);
557
558 /* Find the end of the list and append. */
559 for (vpp = &vmap; *vpp; vpp = &(*vpp)->nxt)
560 ;
561 *vpp = vp;
562
563 return vp;
564 }
565 \f
566
567 VEC(mem_range_s) *
568 section_table_available_memory (VEC(mem_range_s) *memory,
569 CORE_ADDR memaddr, ULONGEST len,
570 struct target_section *sections,
571 struct target_section *sections_end)
572 {
573 struct target_section *p;
574
575 for (p = sections; p < sections_end; p++)
576 {
577 if ((bfd_get_section_flags (p->bfd, p->the_bfd_section)
578 & SEC_READONLY) == 0)
579 continue;
580
581 /* Copy the meta-data, adjusted. */
582 if (mem_ranges_overlap (p->addr, p->endaddr - p->addr, memaddr, len))
583 {
584 ULONGEST lo1, hi1, lo2, hi2;
585 struct mem_range *r;
586
587 lo1 = memaddr;
588 hi1 = memaddr + len;
589
590 lo2 = p->addr;
591 hi2 = p->endaddr;
592
593 r = VEC_safe_push (mem_range_s, memory, NULL);
594
595 r->start = max (lo1, lo2);
596 r->length = min (hi1, hi2) - r->start;
597 }
598 }
599
600 return memory;
601 }
602
603 int
604 section_table_xfer_memory_partial (gdb_byte *readbuf, const gdb_byte *writebuf,
605 ULONGEST offset, LONGEST len,
606 struct target_section *sections,
607 struct target_section *sections_end,
608 const char *section_name)
609 {
610 int res;
611 struct target_section *p;
612 ULONGEST memaddr = offset;
613 ULONGEST memend = memaddr + len;
614
615 if (len <= 0)
616 internal_error (__FILE__, __LINE__,
617 _("failed internal consistency check"));
618
619 for (p = sections; p < sections_end; p++)
620 {
621 if (section_name && strcmp (section_name, p->the_bfd_section->name) != 0)
622 continue; /* not the section we need. */
623 if (memaddr >= p->addr)
624 {
625 if (memend <= p->endaddr)
626 {
627 /* Entire transfer is within this section. */
628 if (writebuf)
629 res = bfd_set_section_contents (p->bfd, p->the_bfd_section,
630 writebuf, memaddr - p->addr,
631 len);
632 else
633 res = bfd_get_section_contents (p->bfd, p->the_bfd_section,
634 readbuf, memaddr - p->addr,
635 len);
636 return (res != 0) ? len : 0;
637 }
638 else if (memaddr >= p->endaddr)
639 {
640 /* This section ends before the transfer starts. */
641 continue;
642 }
643 else
644 {
645 /* This section overlaps the transfer. Just do half. */
646 len = p->endaddr - memaddr;
647 if (writebuf)
648 res = bfd_set_section_contents (p->bfd, p->the_bfd_section,
649 writebuf, memaddr - p->addr,
650 len);
651 else
652 res = bfd_get_section_contents (p->bfd, p->the_bfd_section,
653 readbuf, memaddr - p->addr,
654 len);
655 return (res != 0) ? len : 0;
656 }
657 }
658 }
659
660 return 0; /* We can't help. */
661 }
662
663 static struct target_section_table *
664 exec_get_section_table (struct target_ops *ops)
665 {
666 return current_target_sections;
667 }
668
669 static LONGEST
670 exec_xfer_partial (struct target_ops *ops, enum target_object object,
671 const char *annex, gdb_byte *readbuf,
672 const gdb_byte *writebuf,
673 ULONGEST offset, LONGEST len)
674 {
675 struct target_section_table *table = target_get_section_table (ops);
676
677 if (object == TARGET_OBJECT_MEMORY)
678 return section_table_xfer_memory_partial (readbuf, writebuf,
679 offset, len,
680 table->sections,
681 table->sections_end,
682 NULL);
683 else
684 return -1;
685 }
686 \f
687
688 void
689 print_section_info (struct target_section_table *t, bfd *abfd)
690 {
691 struct gdbarch *gdbarch = gdbarch_from_bfd (abfd);
692 struct target_section *p;
693 /* FIXME: 16 is not wide enough when gdbarch_addr_bit > 64. */
694 int wid = gdbarch_addr_bit (gdbarch) <= 32 ? 8 : 16;
695
696 printf_filtered ("\t`%s', ", bfd_get_filename (abfd));
697 wrap_here (" ");
698 printf_filtered (_("file type %s.\n"), bfd_get_target (abfd));
699 if (abfd == exec_bfd)
700 {
701 /* gcc-3.4 does not like the initialization in
702 <p == t->sections_end>. */
703 bfd_vma displacement = 0;
704 bfd_vma entry_point;
705
706 for (p = t->sections; p < t->sections_end; p++)
707 {
708 asection *asect = p->the_bfd_section;
709
710 if ((bfd_get_section_flags (abfd, asect) & (SEC_ALLOC | SEC_LOAD))
711 != (SEC_ALLOC | SEC_LOAD))
712 continue;
713
714 if (bfd_get_section_vma (abfd, asect) <= abfd->start_address
715 && abfd->start_address < (bfd_get_section_vma (abfd, asect)
716 + bfd_get_section_size (asect)))
717 {
718 displacement = p->addr - bfd_get_section_vma (abfd, asect);
719 break;
720 }
721 }
722 if (p == t->sections_end)
723 warning (_("Cannot find section for the entry point of %s."),
724 bfd_get_filename (abfd));
725
726 entry_point = gdbarch_addr_bits_remove (gdbarch,
727 bfd_get_start_address (abfd)
728 + displacement);
729 printf_filtered (_("\tEntry point: %s\n"),
730 paddress (gdbarch, entry_point));
731 }
732 for (p = t->sections; p < t->sections_end; p++)
733 {
734 printf_filtered ("\t%s", hex_string_custom (p->addr, wid));
735 printf_filtered (" - %s", hex_string_custom (p->endaddr, wid));
736
737 /* FIXME: A format of "08l" is not wide enough for file offsets
738 larger than 4GB. OTOH, making it "016l" isn't desirable either
739 since most output will then be much wider than necessary. It
740 may make sense to test the size of the file and choose the
741 format string accordingly. */
742 /* FIXME: i18n: Need to rewrite this sentence. */
743 if (info_verbose)
744 printf_filtered (" @ %s",
745 hex_string_custom (p->the_bfd_section->filepos, 8));
746 printf_filtered (" is %s", bfd_section_name (p->bfd,
747 p->the_bfd_section));
748 if (p->bfd != abfd)
749 printf_filtered (" in %s", bfd_get_filename (p->bfd));
750 printf_filtered ("\n");
751 }
752 }
753
754 static void
755 exec_files_info (struct target_ops *t)
756 {
757 if (exec_bfd)
758 print_section_info (current_target_sections, exec_bfd);
759 else
760 puts_filtered (_("\t<no file loaded>\n"));
761
762 if (vmap)
763 {
764 int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
765 struct vmap *vp;
766
767 printf_unfiltered (_("\tMapping info for file `%s'.\n"), vmap->name);
768 printf_unfiltered ("\t %*s %*s %*s %*s %8.8s %s\n",
769 addr_size * 2, "tstart",
770 addr_size * 2, "tend",
771 addr_size * 2, "dstart",
772 addr_size * 2, "dend",
773 "section",
774 "file(member)");
775
776 for (vp = vmap; vp; vp = vp->nxt)
777 printf_unfiltered ("\t0x%s 0x%s 0x%s 0x%s %s%s%s%s\n",
778 phex (vp->tstart, addr_size),
779 phex (vp->tend, addr_size),
780 phex (vp->dstart, addr_size),
781 phex (vp->dend, addr_size),
782 vp->name,
783 *vp->member ? "(" : "", vp->member,
784 *vp->member ? ")" : "");
785 }
786 }
787
788 static void
789 set_section_command (char *args, int from_tty)
790 {
791 struct target_section *p;
792 char *secname;
793 unsigned seclen;
794 unsigned long secaddr;
795 char secprint[100];
796 long offset;
797 struct target_section_table *table;
798
799 if (args == 0)
800 error (_("Must specify section name and its virtual address"));
801
802 /* Parse out section name. */
803 for (secname = args; !isspace (*args); args++);
804 seclen = args - secname;
805
806 /* Parse out new virtual address. */
807 secaddr = parse_and_eval_address (args);
808
809 table = current_target_sections;
810 for (p = table->sections; p < table->sections_end; p++)
811 {
812 if (!strncmp (secname, bfd_section_name (p->bfd,
813 p->the_bfd_section), seclen)
814 && bfd_section_name (p->bfd, p->the_bfd_section)[seclen] == '\0')
815 {
816 offset = secaddr - p->addr;
817 p->addr += offset;
818 p->endaddr += offset;
819 if (from_tty)
820 exec_files_info (&exec_ops);
821 return;
822 }
823 }
824 if (seclen >= sizeof (secprint))
825 seclen = sizeof (secprint) - 1;
826 strncpy (secprint, secname, seclen);
827 secprint[seclen] = '\0';
828 error (_("Section %s not found"), secprint);
829 }
830
831 /* If we can find a section in FILENAME with BFD index INDEX, adjust
832 it to ADDRESS. */
833
834 void
835 exec_set_section_address (const char *filename, int index, CORE_ADDR address)
836 {
837 struct target_section *p;
838 struct target_section_table *table;
839
840 table = current_target_sections;
841 for (p = table->sections; p < table->sections_end; p++)
842 {
843 if (filename_cmp (filename, p->bfd->filename) == 0
844 && index == p->the_bfd_section->index)
845 {
846 p->endaddr += address - p->addr;
847 p->addr = address;
848 }
849 }
850 }
851
852 /* If mourn is being called in all the right places, this could be say
853 `gdb internal error' (since generic_mourn calls
854 breakpoint_init_inferior). */
855
856 static int
857 ignore (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
858 {
859 return 0;
860 }
861
862 static int
863 exec_has_memory (struct target_ops *ops)
864 {
865 /* We can provide memory if we have any file/target sections to read
866 from. */
867 return (current_target_sections->sections
868 != current_target_sections->sections_end);
869 }
870
871 /* Find mapped memory. */
872
873 extern void
874 exec_set_find_memory_regions (int (*func) (find_memory_region_ftype, void *))
875 {
876 exec_ops.to_find_memory_regions = func;
877 }
878
879 static char *exec_make_note_section (bfd *, int *);
880
881 /* Fill in the exec file target vector. Very few entries need to be
882 defined. */
883
884 static void
885 init_exec_ops (void)
886 {
887 exec_ops.to_shortname = "exec";
888 exec_ops.to_longname = "Local exec file";
889 exec_ops.to_doc = "Use an executable file as a target.\n\
890 Specify the filename of the executable file.";
891 exec_ops.to_open = exec_open;
892 exec_ops.to_close = exec_close_1;
893 exec_ops.to_attach = find_default_attach;
894 exec_ops.to_xfer_partial = exec_xfer_partial;
895 exec_ops.to_get_section_table = exec_get_section_table;
896 exec_ops.to_files_info = exec_files_info;
897 exec_ops.to_insert_breakpoint = ignore;
898 exec_ops.to_remove_breakpoint = ignore;
899 exec_ops.to_create_inferior = find_default_create_inferior;
900 exec_ops.to_stratum = file_stratum;
901 exec_ops.to_has_memory = exec_has_memory;
902 exec_ops.to_make_corefile_notes = exec_make_note_section;
903 exec_ops.to_magic = OPS_MAGIC;
904 }
905
906 void
907 _initialize_exec (void)
908 {
909 struct cmd_list_element *c;
910
911 init_exec_ops ();
912
913 if (!dbx_commands)
914 {
915 c = add_cmd ("file", class_files, file_command, _("\
916 Use FILE as program to be debugged.\n\
917 It is read for its symbols, for getting the contents of pure memory,\n\
918 and it is the program executed when you use the `run' command.\n\
919 If FILE cannot be found as specified, your execution directory path\n\
920 ($PATH) is searched for a command of that name.\n\
921 No arg means to have no executable file and no symbols."), &cmdlist);
922 set_cmd_completer (c, filename_completer);
923 }
924
925 c = add_cmd ("exec-file", class_files, exec_file_command, _("\
926 Use FILE as program for getting contents of pure memory.\n\
927 If FILE cannot be found as specified, your execution directory path\n\
928 is searched for a command of that name.\n\
929 No arg means have no executable file."), &cmdlist);
930 set_cmd_completer (c, filename_completer);
931
932 add_com ("section", class_files, set_section_command, _("\
933 Change the base address of section SECTION of the exec file to ADDR.\n\
934 This can be used if the exec file does not contain section addresses,\n\
935 (such as in the a.out format), or when the addresses specified in the\n\
936 file itself are wrong. Each section must be changed separately. The\n\
937 ``info files'' command lists all the sections and their addresses."));
938
939 add_setshow_boolean_cmd ("write", class_support, &write_files, _("\
940 Set writing into executable and core files."), _("\
941 Show writing into executable and core files."), NULL,
942 NULL,
943 show_write_files,
944 &setlist, &showlist);
945
946 add_target (&exec_ops);
947 }
948
949 static char *
950 exec_make_note_section (bfd *obfd, int *note_size)
951 {
952 error (_("Can't create a corefile"));
953 }
This page took 0.065342 seconds and 5 git commands to generate.