GDB (xrefs)
/tmp/gdb-7.10/gdb/exec.c
Go to the documentation of this file.
1 /* Work with executable files, for GDB.
2 
3  Copyright (C) 1988-2015 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 #include "gcore.h"
38 
39 #include <fcntl.h>
40 #include "readline/readline.h"
41 #include "gdbcore.h"
42 
43 #include <ctype.h>
44 #include <sys/stat.h>
45 #include "solist.h"
46 
48 
49 /* Prototypes for local functions */
50 
51 static void file_command (char *, int);
52 
53 static void set_section_command (char *, int);
54 
55 static void exec_files_info (struct target_ops *);
56 
57 static void init_exec_ops (void);
58 
59 void _initialize_exec (void);
60 
61 /* The target vector for executable files. */
62 
63 static struct target_ops exec_ops;
64 
65 /* Whether to open exec and core files read-only or read-write. */
66 
67 int write_files = 0;
68 static void
69 show_write_files (struct ui_file *file, int from_tty,
70  struct cmd_list_element *c, const char *value)
71 {
72  fprintf_filtered (file, _("Writing into executable and core files is %s.\n"),
73  value);
74 }
75 
76 
77 static void
78 exec_open (const char *args, int from_tty)
79 {
80  target_preopen (from_tty);
81  exec_file_attach (args, from_tty);
82 }
83 
84 /* Close and clear exec_bfd. If we end up with no target sections to
85  read memory from, this unpushes the exec_ops target. */
86 
87 void
88 exec_close (void)
89 {
90  if (exec_bfd)
91  {
92  bfd *abfd = exec_bfd;
93 
94  gdb_bfd_unref (abfd);
95 
96  /* Removing target sections may close the exec_ops target.
97  Clear exec_bfd before doing so to prevent recursion. */
98  exec_bfd = NULL;
99  exec_bfd_mtime = 0;
100 
102 
104  exec_filename = NULL;
105  }
106 }
107 
108 /* This is the target_close implementation. Clears all target
109  sections and closes all executable bfds from all program spaces. */
110 
111 static void
112 exec_close_1 (struct target_ops *self)
113 {
114  struct program_space *ss;
115  struct cleanup *old_chain;
116 
117  old_chain = save_current_program_space ();
118  ALL_PSPACES (ss)
119  {
122  exec_close ();
123  }
124 
125  do_cleanups (old_chain);
126 }
127 
128 void
129 exec_file_clear (int from_tty)
130 {
131  /* Remove exec file. */
132  exec_close ();
133 
134  if (from_tty)
135  printf_unfiltered (_("No executable file now.\n"));
136 }
137 
138 /* See gdbcore.h. */
139 
140 void
141 exec_file_locate_attach (int pid, int from_tty)
142 {
143  char *exec_file, *full_exec_path = NULL;
144 
145  /* Do nothing if we already have an executable filename. */
146  exec_file = (char *) get_exec_file (0);
147  if (exec_file != NULL)
148  return;
149 
150  /* Try to determine a filename from the process itself. */
151  exec_file = target_pid_to_exec_file (pid);
152  if (exec_file == NULL)
153  return;
154 
155  /* If gdb_sysroot is not empty and the discovered filename
156  is absolute then prefix the filename with gdb_sysroot. */
157  if (*gdb_sysroot != '\0' && IS_ABSOLUTE_PATH (exec_file))
158  full_exec_path = exec_file_find (exec_file, NULL);
159 
160  if (full_exec_path == NULL)
161  {
162  /* It's possible we don't have a full path, but rather just a
163  filename. Some targets, such as HP-UX, don't provide the
164  full path, sigh.
165 
166  Attempt to qualify the filename against the source path.
167  (If that fails, we'll just fall back on the original
168  filename. Not much more we can do...) */
169  if (!source_full_path_of (exec_file, &full_exec_path))
170  full_exec_path = xstrdup (exec_file);
171  }
172 
173  exec_file_attach (full_exec_path, from_tty);
174  symbol_file_add_main (full_exec_path, from_tty);
175 }
176 
177 /* Set FILENAME as the new exec file.
178 
179  This function is intended to be behave essentially the same
180  as exec_file_command, except that the latter will detect when
181  a target is being debugged, and will ask the user whether it
182  should be shut down first. (If the answer is "no", then the
183  new file is ignored.)
184 
185  This file is used by exec_file_command, to do the work of opening
186  and processing the exec file after any prompting has happened.
187 
188  And, it is used by child_attach, when the attach command was
189  given a pid but not a exec pathname, and the attach command could
190  figure out the pathname from the pid. (In this case, we shouldn't
191  ask the user whether the current target should be shut down --
192  we're supplying the exec pathname late for good reason.) */
193 
194 void
195 exec_file_attach (const char *filename, int from_tty)
196 {
197  struct cleanup *cleanups;
198 
199  /* First, acquire a reference to the current exec_bfd. We release
200  this at the end of the function; but acquiring it now lets the
201  BFD cache return it if this call refers to the same file. */
203  cleanups = make_cleanup_bfd_unref (exec_bfd);
204 
205  /* Remove any previous exec file. */
206  exec_close ();
207 
208  /* Now open and digest the file the user requested, if any. */
209 
210  if (!filename)
211  {
212  if (from_tty)
213  printf_unfiltered (_("No executable file now.\n"));
214 
215  set_gdbarch_from_file (NULL);
216  }
217  else
218  {
219  int load_via_target = 0;
220  char *scratch_pathname, *canonical_pathname;
221  int scratch_chan;
222  struct target_section *sections = NULL, *sections_end = NULL;
223  char **matching;
224 
225  if (is_target_filename (filename))
226  {
228  filename += strlen (TARGET_SYSROOT_PREFIX);
229  else
230  load_via_target = 1;
231  }
232 
233  if (load_via_target)
234  {
235  /* gdb_bfd_fopen does not support "target:" filenames. */
236  if (write_files)
237  warning (_("writing into executable files is "
238  "not supported for %s sysroots"),
240 
241  scratch_pathname = xstrdup (filename);
242  make_cleanup (xfree, scratch_pathname);
243 
244  scratch_chan = -1;
245 
246  canonical_pathname = scratch_pathname;
247  }
248  else
249  {
250  scratch_chan = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST,
251  filename, write_files ?
252  O_RDWR | O_BINARY : O_RDONLY | O_BINARY,
253  &scratch_pathname);
254 #if defined(__GO32__) || defined(_WIN32) || defined(__CYGWIN__)
255  if (scratch_chan < 0)
256  {
257  char *exename = alloca (strlen (filename) + 5);
258 
259  strcat (strcpy (exename, filename), ".exe");
260  scratch_chan = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST,
261  exename, write_files ?
262  O_RDWR | O_BINARY
263  : O_RDONLY | O_BINARY,
264  &scratch_pathname);
265  }
266 #endif
267  if (scratch_chan < 0)
268  perror_with_name (filename);
269 
270  make_cleanup (xfree, scratch_pathname);
271 
272  /* gdb_bfd_open (and its variants) prefers canonicalized
273  pathname for better BFD caching. */
274  canonical_pathname = gdb_realpath (scratch_pathname);
275  make_cleanup (xfree, canonical_pathname);
276  }
277 
278  if (write_files && !load_via_target)
279  exec_bfd = gdb_bfd_fopen (canonical_pathname, gnutarget,
280  FOPEN_RUB, scratch_chan);
281  else
282  exec_bfd = gdb_bfd_open (canonical_pathname, gnutarget, scratch_chan);
283 
284  if (!exec_bfd)
285  {
286  error (_("\"%s\": could not open as an executable file: %s"),
287  scratch_pathname, bfd_errmsg (bfd_get_error ()));
288  }
289 
290  /* gdb_realpath_keepfile resolves symlinks on the local
291  filesystem and so cannot be used for "target:" files. */
292  gdb_assert (exec_filename == NULL);
293  if (load_via_target)
294  exec_filename = xstrdup (bfd_get_filename (exec_bfd));
295  else
296  exec_filename = gdb_realpath_keepfile (scratch_pathname);
297 
298  if (!bfd_check_format_matches (exec_bfd, bfd_object, &matching))
299  {
300  /* Make sure to close exec_bfd, or else "run" might try to use
301  it. */
302  exec_close ();
303  error (_("\"%s\": not in executable format: %s"),
304  scratch_pathname,
305  gdb_bfd_errmsg (bfd_get_error (), matching));
306  }
307 
308  if (build_section_table (exec_bfd, &sections, &sections_end))
309  {
310  /* Make sure to close exec_bfd, or else "run" might try to use
311  it. */
312  exec_close ();
313  error (_("\"%s\": can't find the file sections: %s"),
314  scratch_pathname, bfd_errmsg (bfd_get_error ()));
315  }
316 
317  exec_bfd_mtime = bfd_get_mtime (exec_bfd);
318 
319  validate_files ();
320 
322 
323  /* Add the executable's sections to the current address spaces'
324  list of sections. This possibly pushes the exec_ops
325  target. */
326  add_target_sections (&exec_bfd, sections, sections_end);
327  xfree (sections);
328 
329  /* Tell display code (if any) about the changed file name. */
331  (*deprecated_exec_file_display_hook) (filename);
332  }
333 
334  do_cleanups (cleanups);
335 
336  bfd_cache_close_all ();
338 }
339 
340 /* Process the first arg in ARGS as the new exec file.
341 
342  Note that we have to explicitly ignore additional args, since we can
343  be called from file_command(), which also calls symbol_file_command()
344  which can take multiple args.
345 
346  If ARGS is NULL, we just want to close the exec file. */
347 
348 static void
349 exec_file_command (char *args, int from_tty)
350 {
351  char **argv;
352  char *filename;
353 
354  if (from_tty && target_has_execution
355  && !query (_("A program is being debugged already.\n"
356  "Are you sure you want to change the file? ")))
357  error (_("File not changed."));
358 
359  if (args)
360  {
361  struct cleanup *cleanups;
362 
363  /* Scan through the args and pick up the first non option arg
364  as the filename. */
365 
366  argv = gdb_buildargv (args);
367  cleanups = make_cleanup_freeargv (argv);
368 
369  for (; (*argv != NULL) && (**argv == '-'); argv++)
370  {;
371  }
372  if (*argv == NULL)
373  error (_("No executable file name was specified"));
374 
375  filename = tilde_expand (*argv);
376  make_cleanup (xfree, filename);
377  exec_file_attach (filename, from_tty);
378 
379  do_cleanups (cleanups);
380  }
381  else
382  exec_file_attach (NULL, from_tty);
383 }
384 
385 /* Set both the exec file and the symbol file, in one command.
386  What a novelty. Why did GDB go through four major releases before this
387  command was added? */
388 
389 static void
390 file_command (char *arg, int from_tty)
391 {
392  /* FIXME, if we lose on reading the symbol file, we should revert
393  the exec file, but that's rough. */
394  exec_file_command (arg, from_tty);
395  symbol_file_command (arg, from_tty);
398 }
399 
400 
401 /* Locate all mappable sections of a BFD file.
402  table_pp_char is a char * to get it through bfd_map_over_sections;
403  we cast it back to its proper type. */
404 
405 static void
406 add_to_section_table (bfd *abfd, struct bfd_section *asect,
407  void *table_pp_char)
408 {
409  struct target_section **table_pp = (struct target_section **) table_pp_char;
410  flagword aflag;
411 
412  gdb_assert (abfd == asect->owner);
413 
414  /* Check the section flags, but do not discard zero-length sections, since
415  some symbols may still be attached to this section. For instance, we
416  encountered on sparc-solaris 2.10 a shared library with an empty .bss
417  section to which a symbol named "_end" was attached. The address
418  of this symbol still needs to be relocated. */
419  aflag = bfd_get_section_flags (abfd, asect);
420  if (!(aflag & SEC_ALLOC))
421  return;
422 
423  (*table_pp)->owner = NULL;
424  (*table_pp)->the_bfd_section = asect;
425  (*table_pp)->addr = bfd_section_vma (abfd, asect);
426  (*table_pp)->endaddr = (*table_pp)->addr + bfd_section_size (abfd, asect);
427  (*table_pp)++;
428 }
429 
430 /* See exec.h. */
431 
432 void
434 {
435  xfree (table->sections);
436  table->sections = table->sections_end = NULL;
437 }
438 
439 /* Resize section table TABLE by ADJUSTMENT.
440  ADJUSTMENT may be negative, in which case the caller must have already
441  removed the sections being deleted.
442  Returns the old size. */
443 
444 static int
445 resize_section_table (struct target_section_table *table, int adjustment)
446 {
447  int old_count;
448  int new_count;
449 
450  old_count = table->sections_end - table->sections;
451 
452  new_count = adjustment + old_count;
453 
454  if (new_count)
455  {
456  table->sections = xrealloc (table->sections,
457  sizeof (struct target_section) * new_count);
458  table->sections_end = table->sections + new_count;
459  }
460  else
461  clear_section_table (table);
462 
463  return old_count;
464 }
465 
466 /* Builds a section table, given args BFD, SECTABLE_PTR, SECEND_PTR.
467  Returns 0 if OK, 1 on error. */
468 
469 int
470 build_section_table (struct bfd *some_bfd, struct target_section **start,
471  struct target_section **end)
472 {
473  unsigned count;
474 
475  count = bfd_count_sections (some_bfd);
476  if (*start)
477  xfree (* start);
478  *start = (struct target_section *) xmalloc (count * sizeof (**start));
479  *end = *start;
480  bfd_map_over_sections (some_bfd, add_to_section_table, (char *) end);
481  if (*end > *start + count)
482  internal_error (__FILE__, __LINE__,
483  _("failed internal consistency check"));
484  /* We could realloc the table, but it probably loses for most files. */
485  return 0;
486 }
487 
488 /* Add the sections array defined by [SECTIONS..SECTIONS_END[ to the
489  current set of target sections. */
490 
491 void
493  struct target_section *sections,
494  struct target_section *sections_end)
495 {
496  int count;
498 
499  count = sections_end - sections;
500 
501  if (count > 0)
502  {
503  int space = resize_section_table (table, count);
504  int i;
505 
506  for (i = 0; i < count; ++i)
507  {
508  table->sections[space + i] = sections[i];
509  table->sections[space + i].owner = owner;
510  }
511 
512  /* If these are the first file sections we can provide memory
513  from, push the file_stratum target. */
514  if (!target_is_pushed (&exec_ops))
516  }
517 }
518 
519 /* Add the sections of OBJFILE to the current set of target sections. */
520 
521 void
523 {
525  struct obj_section *osect;
526  int space;
527  unsigned count = 0;
528  struct target_section *ts;
529 
530  if (objfile == NULL)
531  return;
532 
533  /* Compute the number of sections to add. */
534  ALL_OBJFILE_OSECTIONS (objfile, osect)
535  {
536  if (bfd_get_section_size (osect->the_bfd_section) == 0)
537  continue;
538  count++;
539  }
540 
541  if (count == 0)
542  return;
543 
544  space = resize_section_table (table, count);
545 
546  ts = table->sections + space;
547 
548  ALL_OBJFILE_OSECTIONS (objfile, osect)
549  {
550  if (bfd_get_section_size (osect->the_bfd_section) == 0)
551  continue;
552 
553  gdb_assert (ts < table->sections + space + count);
554 
555  ts->addr = obj_section_addr (osect);
556  ts->endaddr = obj_section_endaddr (osect);
557  ts->the_bfd_section = osect->the_bfd_section;
558  ts->owner = (void *) objfile;
559 
560  ts++;
561  }
562 }
563 
564 /* Remove all target sections owned by OWNER.
565  OWNER must be the same value passed to add_target_sections. */
566 
567 void
569 {
570  struct target_section *src, *dest;
572 
573  gdb_assert (owner != NULL);
574 
575  dest = table->sections;
576  for (src = table->sections; src < table->sections_end; src++)
577  if (src->owner != owner)
578  {
579  /* Keep this section. */
580  if (dest < src)
581  *dest = *src;
582  dest++;
583  }
584 
585  /* If we've dropped any sections, resize the section table. */
586  if (dest < src)
587  {
588  int old_count;
589 
590  old_count = resize_section_table (table, dest - src);
591 
592  /* If we don't have any more sections to read memory from,
593  remove the file_stratum target from the stack. */
594  if (old_count + (dest - src) == 0)
595  {
596  struct program_space *pspace;
597 
598  ALL_PSPACES (pspace)
599  if (pspace->target_sections.sections
600  != pspace->target_sections.sections_end)
601  return;
602 
604  }
605  }
606 }
607 
608 
609 
612  ULONGEST len, ULONGEST *xfered_len)
613 {
614  /* It's unduly pedantic to refuse to look at the executable for
615  read-only pieces; so do the equivalent of readonly regions aka
616  QTro packet. */
617  if (exec_bfd != NULL)
618  {
619  asection *s;
620  bfd_size_type size;
621  bfd_vma vma;
622 
623  for (s = exec_bfd->sections; s; s = s->next)
624  {
625  if ((s->flags & SEC_LOAD) == 0
626  || (s->flags & SEC_READONLY) == 0)
627  continue;
628 
629  vma = s->vma;
630  size = bfd_get_section_size (s);
631  if (vma <= offset && offset < (vma + size))
632  {
633  ULONGEST amt;
634 
635  amt = (vma + size) - offset;
636  if (amt > len)
637  amt = len;
638 
639  amt = bfd_get_section_contents (exec_bfd, s,
640  readbuf, offset - vma, amt);
641 
642  if (amt == 0)
643  return TARGET_XFER_EOF;
644  else
645  {
646  *xfered_len = amt;
647  return TARGET_XFER_OK;
648  }
649  }
650  }
651  }
652 
653  /* Indicate failure to find the requested memory block. */
654  return TARGET_XFER_E_IO;
655 }
656 
657 /* Appends all read-only memory ranges found in the target section
658  table defined by SECTIONS and SECTIONS_END, starting at (and
659  intersected with) MEMADDR for LEN bytes. Returns the augmented
660  VEC. */
661 
662 static VEC(mem_range_s) *
663 section_table_available_memory (VEC(mem_range_s) *memory,
664  CORE_ADDR memaddr, ULONGEST len,
665  struct target_section *sections,
666  struct target_section *sections_end)
667 {
668  struct target_section *p;
669 
670  for (p = sections; p < sections_end; p++)
671  {
672  if ((bfd_get_section_flags (p->the_bfd_section->owner,
673  p->the_bfd_section)
674  & SEC_READONLY) == 0)
675  continue;
676 
677  /* Copy the meta-data, adjusted. */
678  if (mem_ranges_overlap (p->addr, p->endaddr - p->addr, memaddr, len))
679  {
680  ULONGEST lo1, hi1, lo2, hi2;
681  struct mem_range *r;
682 
683  lo1 = memaddr;
684  hi1 = memaddr + len;
685 
686  lo2 = p->addr;
687  hi2 = p->endaddr;
688 
689  r = VEC_safe_push (mem_range_s, memory, NULL);
690 
691  r->start = max (lo1, lo2);
692  r->length = min (hi1, hi2) - r->start;
693  }
694  }
695 
696  return memory;
697 }
698 
701  ULONGEST len, ULONGEST *xfered_len)
702 {
703  VEC(mem_range_s) *available_memory = NULL;
704  struct target_section_table *table;
705  struct cleanup *old_chain;
706  mem_range_s *r;
707  int i;
708 
710  available_memory = section_table_available_memory (available_memory,
711  offset, len,
712  table->sections,
713  table->sections_end);
714 
715  old_chain = make_cleanup (VEC_cleanup(mem_range_s),
716  &available_memory);
717 
718  normalize_mem_ranges (available_memory);
719 
720  for (i = 0;
721  VEC_iterate (mem_range_s, available_memory, i, r);
722  i++)
723  {
724  if (mem_ranges_overlap (r->start, r->length, offset, len))
725  {
726  CORE_ADDR end;
728 
729  /* Get the intersection window. */
730  end = min (offset + len, r->start + r->length);
731 
732  gdb_assert (end - offset <= len);
733 
734  if (offset >= r->start)
735  status = exec_read_partial_read_only (readbuf, offset,
736  end - offset,
737  xfered_len);
738  else
739  {
740  *xfered_len = r->start - offset;
741  status = TARGET_XFER_UNAVAILABLE;
742  }
743  do_cleanups (old_chain);
744  return status;
745  }
746  }
747  do_cleanups (old_chain);
748 
749  *xfered_len = len;
751 }
752 
756  ULONGEST *xfered_len,
757  struct target_section *sections,
758  struct target_section *sections_end,
759  const char *section_name)
760 {
761  int res;
762  struct target_section *p;
763  ULONGEST memaddr = offset;
764  ULONGEST memend = memaddr + len;
765 
766  if (len == 0)
767  internal_error (__FILE__, __LINE__,
768  _("failed internal consistency check"));
769 
770  for (p = sections; p < sections_end; p++)
771  {
772  struct bfd_section *asect = p->the_bfd_section;
773  bfd *abfd = asect->owner;
774 
775  if (section_name && strcmp (section_name, asect->name) != 0)
776  continue; /* not the section we need. */
777  if (memaddr >= p->addr)
778  {
779  if (memend <= p->endaddr)
780  {
781  /* Entire transfer is within this section. */
782  if (writebuf)
783  res = bfd_set_section_contents (abfd, asect,
784  writebuf, memaddr - p->addr,
785  len);
786  else
787  res = bfd_get_section_contents (abfd, asect,
788  readbuf, memaddr - p->addr,
789  len);
790 
791  if (res != 0)
792  {
793  *xfered_len = len;
794  return TARGET_XFER_OK;
795  }
796  else
797  return TARGET_XFER_EOF;
798  }
799  else if (memaddr >= p->endaddr)
800  {
801  /* This section ends before the transfer starts. */
802  continue;
803  }
804  else
805  {
806  /* This section overlaps the transfer. Just do half. */
807  len = p->endaddr - memaddr;
808  if (writebuf)
809  res = bfd_set_section_contents (abfd, asect,
810  writebuf, memaddr - p->addr,
811  len);
812  else
813  res = bfd_get_section_contents (abfd, asect,
814  readbuf, memaddr - p->addr,
815  len);
816  if (res != 0)
817  {
818  *xfered_len = len;
819  return TARGET_XFER_OK;
820  }
821  else
822  return TARGET_XFER_EOF;
823  }
824  }
825  }
826 
827  return TARGET_XFER_EOF; /* We can't help. */
828 }
829 
830 static struct target_section_table *
832 {
834 }
835 
836 static enum target_xfer_status
837 exec_xfer_partial (struct target_ops *ops, enum target_object object,
838  const char *annex, gdb_byte *readbuf,
839  const gdb_byte *writebuf,
840  ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
841 {
842  struct target_section_table *table = target_get_section_table (ops);
843 
844  if (object == TARGET_OBJECT_MEMORY)
845  return section_table_xfer_memory_partial (readbuf, writebuf,
846  offset, len, xfered_len,
847  table->sections,
848  table->sections_end,
849  NULL);
850  else
851  return TARGET_XFER_E_IO;
852 }
853 
854 
855 void
857 {
858  struct gdbarch *gdbarch = gdbarch_from_bfd (abfd);
859  struct target_section *p;
860  /* FIXME: 16 is not wide enough when gdbarch_addr_bit > 64. */
861  int wid = gdbarch_addr_bit (gdbarch) <= 32 ? 8 : 16;
862 
863  printf_filtered ("\t`%s', ", bfd_get_filename (abfd));
864  wrap_here (" ");
865  printf_filtered (_("file type %s.\n"), bfd_get_target (abfd));
866  if (abfd == exec_bfd)
867  {
868  /* gcc-3.4 does not like the initialization in
869  <p == t->sections_end>. */
870  bfd_vma displacement = 0;
871  bfd_vma entry_point;
872 
873  for (p = t->sections; p < t->sections_end; p++)
874  {
875  struct bfd_section *psect = p->the_bfd_section;
876  bfd *pbfd = psect->owner;
877 
878  if ((bfd_get_section_flags (pbfd, psect) & (SEC_ALLOC | SEC_LOAD))
879  != (SEC_ALLOC | SEC_LOAD))
880  continue;
881 
882  if (bfd_get_section_vma (pbfd, psect) <= abfd->start_address
883  && abfd->start_address < (bfd_get_section_vma (pbfd, psect)
884  + bfd_get_section_size (psect)))
885  {
886  displacement = p->addr - bfd_get_section_vma (pbfd, psect);
887  break;
888  }
889  }
890  if (p == t->sections_end)
891  warning (_("Cannot find section for the entry point of %s."),
892  bfd_get_filename (abfd));
893 
894  entry_point = gdbarch_addr_bits_remove (gdbarch,
895  bfd_get_start_address (abfd)
896  + displacement);
897  printf_filtered (_("\tEntry point: %s\n"),
898  paddress (gdbarch, entry_point));
899  }
900  for (p = t->sections; p < t->sections_end; p++)
901  {
902  struct bfd_section *psect = p->the_bfd_section;
903  bfd *pbfd = psect->owner;
904 
905  printf_filtered ("\t%s", hex_string_custom (p->addr, wid));
906  printf_filtered (" - %s", hex_string_custom (p->endaddr, wid));
907 
908  /* FIXME: A format of "08l" is not wide enough for file offsets
909  larger than 4GB. OTOH, making it "016l" isn't desirable either
910  since most output will then be much wider than necessary. It
911  may make sense to test the size of the file and choose the
912  format string accordingly. */
913  /* FIXME: i18n: Need to rewrite this sentence. */
914  if (info_verbose)
915  printf_filtered (" @ %s",
916  hex_string_custom (psect->filepos, 8));
917  printf_filtered (" is %s", bfd_section_name (pbfd, psect));
918  if (pbfd != abfd)
919  printf_filtered (" in %s", bfd_get_filename (pbfd));
920  printf_filtered ("\n");
921  }
922 }
923 
924 static void
926 {
927  if (exec_bfd)
929  else
930  puts_filtered (_("\t<no file loaded>\n"));
931 }
932 
933 static void
934 set_section_command (char *args, int from_tty)
935 {
936  struct target_section *p;
937  char *secname;
938  unsigned seclen;
939  unsigned long secaddr;
940  char secprint[100];
941  long offset;
942  struct target_section_table *table;
943 
944  if (args == 0)
945  error (_("Must specify section name and its virtual address"));
946 
947  /* Parse out section name. */
948  for (secname = args; !isspace (*args); args++);
949  seclen = args - secname;
950 
951  /* Parse out new virtual address. */
952  secaddr = parse_and_eval_address (args);
953 
954  table = current_target_sections;
955  for (p = table->sections; p < table->sections_end; p++)
956  {
957  if (!strncmp (secname, bfd_section_name (p->bfd,
958  p->the_bfd_section), seclen)
959  && bfd_section_name (p->bfd, p->the_bfd_section)[seclen] == '\0')
960  {
961  offset = secaddr - p->addr;
962  p->addr += offset;
963  p->endaddr += offset;
964  if (from_tty)
966  return;
967  }
968  }
969  if (seclen >= sizeof (secprint))
970  seclen = sizeof (secprint) - 1;
971  strncpy (secprint, secname, seclen);
972  secprint[seclen] = '\0';
973  error (_("Section %s not found"), secprint);
974 }
975 
976 /* If we can find a section in FILENAME with BFD index INDEX, adjust
977  it to ADDRESS. */
978 
979 void
980 exec_set_section_address (const char *filename, int index, CORE_ADDR address)
981 {
982  struct target_section *p;
983  struct target_section_table *table;
984 
985  table = current_target_sections;
986  for (p = table->sections; p < table->sections_end; p++)
987  {
988  if (filename_cmp (filename, p->the_bfd_section->owner->filename) == 0
989  && index == p->the_bfd_section->index)
990  {
991  p->endaddr += address - p->addr;
992  p->addr = address;
993  }
994  }
995 }
996 
997 /* If mourn is being called in all the right places, this could be say
998  `gdb internal error' (since generic_mourn calls
999  breakpoint_init_inferior). */
1000 
1001 static int
1002 ignore (struct target_ops *ops, struct gdbarch *gdbarch,
1003  struct bp_target_info *bp_tgt)
1004 {
1005  return 0;
1006 }
1007 
1008 static int
1010 {
1011  /* We can provide memory if we have any file/target sections to read
1012  from. */
1013  return (current_target_sections->sections
1014  != current_target_sections->sections_end);
1015 }
1016 
1017 static char *
1018 exec_make_note_section (struct target_ops *self, bfd *obfd, int *note_size)
1019 {
1020  error (_("Can't create a corefile"));
1021 }
1022 
1023 /* Fill in the exec file target vector. Very few entries need to be
1024  defined. */
1025 
1026 static void
1028 {
1029  exec_ops.to_shortname = "exec";
1030  exec_ops.to_longname = "Local exec file";
1031  exec_ops.to_doc = "Use an executable file as a target.\n\
1032 Specify the filename of the executable file.";
1045 }
1046 
1047 void
1049 {
1050  struct cmd_list_element *c;
1051 
1052  init_exec_ops ();
1053 
1054  if (!dbx_commands)
1055  {
1056  c = add_cmd ("file", class_files, file_command, _("\
1057 Use FILE as program to be debugged.\n\
1058 It is read for its symbols, for getting the contents of pure memory,\n\
1059 and it is the program executed when you use the `run' command.\n\
1060 If FILE cannot be found as specified, your execution directory path\n\
1061 ($PATH) is searched for a command of that name.\n\
1062 No arg means to have no executable file and no symbols."), &cmdlist);
1063  set_cmd_completer (c, filename_completer);
1064  }
1065 
1066  c = add_cmd ("exec-file", class_files, exec_file_command, _("\
1067 Use FILE as program for getting contents of pure memory.\n\
1068 If FILE cannot be found as specified, your execution directory path\n\
1069 is searched for a command of that name.\n\
1070 No arg means have no executable file."), &cmdlist);
1071  set_cmd_completer (c, filename_completer);
1072 
1073  add_com ("section", class_files, set_section_command, _("\
1074 Change the base address of section SECTION of the exec file to ADDR.\n\
1075 This can be used if the exec file does not contain section addresses,\n\
1076 (such as in the a.out format), or when the addresses specified in the\n\
1077 file itself are wrong. Each section must be changed separately. The\n\
1078 ``info files'' command lists all the sections and their addresses."));
1079 
1080  add_setshow_boolean_cmd ("write", class_support, &write_files, _("\
1081 Set writing into executable and core files."), _("\
1082 Show writing into executable and core files."), NULL,
1083  NULL,
1085  &setlist, &showlist);
1086 
1087  add_target_with_completer (&exec_ops, filename_completer);
1088 }
struct cleanup * make_cleanup_freeargv(char **arg)
Definition: utils.c:165
char * gdb_realpath(const char *filename)
Definition: utils.c:2840
const char * to_longname
Definition: target.h:433
int dbx_commands
Definition: main.c:54
int source_full_path_of(const char *, char **)
Definition: source.c:914
int(* to_find_memory_regions)(struct target_ops *, find_memory_region_ftype func, void *data) TARGET_DEFAULT_FUNC(dummy_find_memory_regions)
Definition: target.h:671
static void exec_close_1(struct target_ops *self)
Definition: exec.c:112
bfd_vma CORE_ADDR
Definition: common-types.h:41
void xfree(void *)
Definition: common-utils.c:97
struct target_section * sections_end
Definition: target.h:2277
struct bfd_section * the_bfd_section
Definition: objfiles.h:121
int(* to_has_memory)(struct target_ops *)
Definition: target.h:652
void warning(const char *fmt,...)
Definition: errors.c:26
int query(const char *ctlstr,...)
Definition: utils.c:1364
static char * exec_make_note_section(struct target_ops *self, bfd *obfd, int *note_size)
Definition: exec.c:1018
void push_target(struct target_ops *t)
Definition: target.c:664
int(* to_insert_breakpoint)(struct target_ops *, struct gdbarch *, struct bp_target_info *) TARGET_DEFAULT_FUNC(memory_insert_breakpoint)
Definition: target.h:481
int build_section_table(struct bfd *some_bfd, struct target_section **start, struct target_section **end)
Definition: exec.c:470
#define exec_bfd_mtime
Definition: exec.h:33
hook_type deprecated_exec_file_display_hook
Definition: corefile.c:51
int unpush_target(struct target_ops *t)
Definition: target.c:711
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
#define obj_section_endaddr(s)
Definition: objfiles.h:141
int info_verbose
Definition: top.c:1699
void(* to_close)(struct target_ops *)
Definition: target.h:448
#define ALL_OBJFILE_OSECTIONS(objfile, osect)
Definition: objfiles.h:627
#define exec_filename
Definition: exec.h:34
#define VEC_safe_push(T, V, O)
Definition: vec.h:260
void observer_notify_executable_changed(void)
struct cmd_list_element * cmdlist
Definition: cli-cmds.c:103
int(* to_remove_breakpoint)(struct target_ops *, struct gdbarch *, struct bp_target_info *) TARGET_DEFAULT_FUNC(memory_remove_breakpoint)
Definition: target.h:484
#define _(String)
Definition: gdb_locale.h:40
void * owner
Definition: target.h:2269
#define target_pid_to_exec_file(pid)
Definition: target.h:1792
struct bfd * gdb_bfd_open(const char *name, const char *target, int fd)
Definition: gdb_bfd.c:320
enum target_xfer_status section_table_xfer_memory_partial(gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len, struct target_section *sections, struct target_section *sections_end, const char *section_name)
Definition: exec.c:754
void printf_filtered(const char *format,...)
Definition: utils.c:2388
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: utils.c:2743
static void exec_file_command(char *args, int from_tty)
Definition: exec.c:349
void set_current_program_space(struct program_space *pspace)
Definition: progspace.c:199
void(* to_files_info)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:479
static void show_write_files(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: exec.c:69
#define TARGET_SYSROOT_PREFIX
Definition: gdb_bfd.h:30
#define obj_section_addr(s)
Definition: objfiles.h:135
void gdb_bfd_ref(struct bfd *abfd)
Definition: gdb_bfd.c:439
static struct target_ops exec_ops
Definition: exec.c:63
static void set_section_command(char *, int)
Definition: exec.c:934
struct cmd_list_element * setlist
Definition: cli-cmds.c:135
#define VEC_iterate(T, V, I, P)
Definition: vec.h:165
#define OPS_MAGIC
Definition: target.h:1233
int mem_ranges_overlap(CORE_ADDR start1, int len1, CORE_ADDR start2, int len2)
Definition: memrange.c:24
void exec_file_clear(int from_tty)
Definition: exec.c:129
#define OPF_TRY_CWD_FIRST
Definition: defs.h:317
char * gdb_realpath_keepfile(const char *filename)
Definition: utils.c:2894
int write_files
Definition: exec.c:67
char * gnutarget
Definition: corefile.c:437
static void add_to_section_table(bfd *abfd, struct bfd_section *asect, void *table_pp_char)
Definition: exec.c:406
static int ignore(struct target_ops *ops, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
Definition: exec.c:1002
void gdb_bfd_unref(struct bfd *abfd)
Definition: gdb_bfd.c:475
CORE_ADDR gdbarch_addr_bits_remove(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: gdbarch.c:2992
void set_gdbarch_from_file(bfd *abfd)
Definition: arch-utils.c:573
#define exec_bfd
Definition: exec.h:32
char * gdb_sysroot
Definition: main.c:57
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2351
int openp(const char *, int, const char *, int, char **)
Definition: source.c:739
static struct target_section_table * exec_get_section_table(struct target_ops *ops)
Definition: exec.c:831
void set_cmd_completer(struct cmd_list_element *cmd, completer_ftype *completer)
Definition: cli-decode.c:159
static int exec_has_memory(struct target_ops *ops)
Definition: exec.c:1009
struct target_section_table target_sections
Definition: progspace.h:192
#define current_target_sections
Definition: progspace.h:224
void remove_target_sections(void *owner)
Definition: exec.c:568
mach_port_t mach_port_t name mach_port_t mach_port_t name error_t int status
Definition: gnu-nat.c:1816
bfd * gdb_bfd_fopen(const char *filename, const char *target, const char *mode, int fd)
Definition: gdb_bfd.c:675
struct cmd_list_element * showlist
Definition: cli-cmds.c:143
#define target_filesystem_is_local()
Definition: target.h:1987
struct target_section_table *(* to_get_section_table)(struct target_ops *) TARGET_DEFAULT_RETURN(NULL)
Definition: target.h:648
void puts_filtered(const char *string)
Definition: utils.c:2428
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc, struct cmd_list_element **list)
Definition: cli-decode.c:192
static enum target_xfer_status exec_xfer_partial(struct target_ops *ops, enum target_object object, const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
Definition: exec.c:837
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:117
struct target_section * sections
Definition: target.h:2276
target_xfer_status
Definition: target.h:219
void add_target_with_completer(struct target_ops *t, completer_ftype *completer)
Definition: target.c:368
void exec_file_locate_attach(int pid, int from_tty)
Definition: exec.c:141
enum target_xfer_status exec_read_partial_read_only(gdb_byte *readbuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
Definition: exec.c:611
#define gdb_assert(expr)
Definition: gdb_assert.h:33
#define min(a, b)
Definition: defs.h:106
static void file_command(char *, int)
Definition: exec.c:390
const char * to_doc
Definition: target.h:434
CORE_ADDR endaddr
Definition: target.h:2260
int gdbarch_addr_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1707
#define target_has_execution
Definition: target.h:1726
enum target_xfer_status(* to_xfer_partial)(struct target_ops *ops, enum target_object object, const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len) TARGET_DEFAULT_RETURN(TARGET_XFER_E_IO)
Definition: target.h:724
void wrap_here(char *indent)
Definition: utils.c:1930
const char * gdb_bfd_errmsg(bfd_error_type error_tag, char **matching)
Definition: utils.c:3069
void printf_unfiltered(const char *format,...)
Definition: utils.c:2399
struct bfd_section * the_bfd_section
Definition: target.h:2262
void * xmalloc(YYSIZE_T)
struct cleanup * make_cleanup_bfd_unref(bfd *abfd)
Definition: utils.c:189
char *(* to_make_corefile_notes)(struct target_ops *, bfd *, int *) TARGET_DEFAULT_FUNC(dummy_make_corefile_notes)
Definition: target.h:675
enum target_xfer_status section_table_read_available_memory(gdb_byte *readbuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
Definition: exec.c:700
target_object
Definition: target.h:136
int target_is_pushed(struct target_ops *t)
Definition: target.c:775
CORE_ADDR addr
Definition: target.h:2259
void symbol_file_add_main(const char *args, int from_tty)
Definition: symfile.c:1309
Definition: value.c:172
int objfile_find_memory_regions(struct target_ops *self, find_memory_region_ftype func, void *obfd)
Definition: gcore.c:503
void exec_set_section_address(const char *filename, int index, CORE_ADDR address)
Definition: exec.c:980
PTR xrealloc(PTR ptr, size_t size)
Definition: common-utils.c:51
bfd_byte gdb_byte
Definition: common-types.h:38
void exec_file_attach(const char *filename, int from_tty)
Definition: exec.c:195
struct gdbarch * gdbarch_from_bfd(bfd *abfd)
Definition: arch-utils.c:560
static int resize_section_table(struct target_section_table *table, int adjustment)
Definition: exec.c:445
#define O_BINARY
Definition: defs.h:100
void void void void void void void void void perror_with_name(const char *string) ATTRIBUTE_NORETURN
Definition: utils.c:979
#define max(a, b)
Definition: defs.h:109
#define ALL_PSPACES(pspace)
Definition: progspace.h:232
CORE_ADDR parse_and_eval_address(const char *exp)
Definition: eval.c:96
void add_target_sections(void *owner, struct target_section *sections, struct target_section *sections_end)
Definition: exec.c:492
enum strata to_stratum
Definition: target.h:650
void symbol_file_command(char *, int)
Definition: symfile.c:1642
void(* deprecated_file_changed_hook)(char *)
Definition: exec.c:47
void(* to_open)(const char *, int)
Definition: target.h:443
int offset
Definition: agent.c:65
void validate_files(void)
Definition: corefile.c:163
char ** gdb_buildargv(const char *s)
Definition: utils.c:3036
char * exec_file_find(char *in_pathname, int *fd)
Definition: solib.c:387
static void init_exec_ops(void)
Definition: exec.c:1027
void normalize_mem_ranges(VEC(mem_range_s)*ranges)
Definition: memrange.c:61
const char * to_shortname
Definition: target.h:432
void exec_close(void)
Definition: exec.c:88
char * get_exec_file(int err)
Definition: corefile.c:179
struct target_section_table * target_get_section_table(struct target_ops *target)
Definition: target.c:982
unsigned long long ULONGEST
Definition: common-types.h:53
struct cleanup * save_current_program_space(void)
Definition: progspace.c:228
int to_magic
Definition: target.h:1224
#define VEC_cleanup(T)
Definition: vec.h:187
int length
Definition: memrange.h:33
static void exec_files_info(struct target_ops *)
Definition: exec.c:925
void add_target_sections_of_objfile(struct objfile *objfile)
Definition: exec.c:522
void * arg
Definition: cleanups.c:43
void target_preopen(int from_tty)
Definition: target.c:2171
static void exec_open(const char *args, int from_tty)
Definition: exec.c:78
void _initialize_exec(void)
Definition: exec.c:1048
int is_target_filename(const char *name)
Definition: gdb_bfd.c:145
void clear_section_table(struct target_section_table *table)
Definition: exec.c:433
void error(const char *fmt,...)
Definition: errors.c:38
size_t size
Definition: go32-nat.c:242
struct cmd_list_element * add_com(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc)
Definition: cli-decode.c:873
mach_port_t mach_port_t name mach_port_t mach_port_t name error_t int int rusage_t pid_t pid
Definition: gnu-nat.c:1818
void print_section_info(struct target_section_table *t, bfd *abfd)
Definition: exec.c:856
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175
void add_setshow_boolean_cmd(const char *name, enum command_class theclass, int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:541
const ULONGEST const LONGEST len
Definition: target.h:309
static VEC(mem_range_s)
Definition: exec.c:662
CORE_ADDR start
Definition: memrange.h:30