GDB (xrefs)
Loading...
Searching...
No Matches
exec.c
Go to the documentation of this file.
1/* Work with executable files, for GDB.
2
3 Copyright (C) 1988-2023 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 "observable.h"
33#include "arch-utils.h"
34#include "gdbthread.h"
35#include "progspace.h"
37#include "gdb_bfd.h"
38#include "gcore.h"
39#include "source.h"
40#include "build-id.h"
41
42#include <fcntl.h>
43#include "readline/tilde.h"
44#include "gdbcore.h"
45
46#include <ctype.h>
47#include <sys/stat.h>
48#include "solist.h"
49#include <algorithm>
50#include "gdbsupport/pathstuff.h"
51#include "cli/cli-style.h"
52#include "gdbsupport/buildargv.h"
53
54void (*deprecated_file_changed_hook) (const char *);
55
57 "exec",
58 N_("Local exec file"),
59 N_("Use an executable file as a target.\n\
60Specify the filename of the executable file.")
61};
62
63/* The target vector for executable files. */
64
65struct exec_target final : public target_ops
66{
67 const target_info &info () const override
68 { return exec_target_info; }
69
70 strata stratum () const override { return file_stratum; }
71
72 void close () override;
74 const char *annex,
75 gdb_byte *readbuf,
76 const gdb_byte *writebuf,
77 ULONGEST offset, ULONGEST len,
78 ULONGEST *xfered_len) override;
79 void files_info () override;
80
81 bool has_memory () override;
82 gdb::unique_xmalloc_ptr<char> make_corefile_notes (bfd *, int *) override;
83 int find_memory_regions (find_memory_region_ftype func, void *data) override;
84};
85
87
88/* How to handle a mismatch between the current exec file and the exec
89 file determined from target. */
90
91static const char *const exec_file_mismatch_names[]
92 = {"ask", "warn", "off", NULL };
94 {
96 };
100
101/* Show command. */
102static void
103show_exec_file_mismatch_command (struct ui_file *file, int from_tty,
104 struct cmd_list_element *c, const char *value)
105{
106 gdb_printf (file,
107 _("exec-file-mismatch handling is currently \"%s\".\n"),
109}
110
111/* Set command. Change the setting for range checking. */
112static void
114 int from_tty, struct cmd_list_element *c)
115{
117 ;
118 mode = static_cast<enum exec_file_mismatch_mode>(1 + (int) mode))
119 {
120 if (strcmp (exec_file_mismatch, exec_file_mismatch_names[mode]) == 0)
121 {
123 return;
124 }
125 if (mode == exec_file_mismatch_off)
126 internal_error (_("Unrecognized exec-file-mismatch setting: \"%s\""),
128 }
129}
130
131/* Whether to open exec and core files read-only or read-write. */
132
133bool write_files = false;
134static void
135show_write_files (struct ui_file *file, int from_tty,
136 struct cmd_list_element *c, const char *value)
137{
138 gdb_printf (file, _("Writing into executable and core files is %s.\n"),
139 value);
140}
141
142
143static void
144exec_target_open (const char *args, int from_tty)
145{
146 target_preopen (from_tty);
147 exec_file_attach (args, from_tty);
148}
149
150/* This is the target_close implementation. Clears all target
151 sections and closes all executable bfds from all program spaces. */
152
153void
155{
156 for (struct program_space *ss : program_spaces)
157 {
158 ss->clear_target_sections ();
159 ss->exec_close ();
160 }
161}
162
163/* See gdbcore.h. */
164
165void
166try_open_exec_file (const char *exec_file_host, struct inferior *inf,
167 symfile_add_flags add_flags)
168{
169 struct gdb_exception prev_err;
170
171 /* exec_file_attach and symbol_file_add_main may throw an error if the file
172 cannot be opened either locally or remotely.
173
174 This happens for example, when the file is first found in the local
175 sysroot (above), and then disappears (a TOCTOU race), or when it doesn't
176 exist in the target filesystem, or when the file does exist, but
177 is not readable.
178
179 Even without a symbol file, the remote-based debugging session should
180 continue normally instead of ending abruptly. Hence we catch thrown
181 errors/exceptions in the following code. */
182 try
183 {
184 /* We must do this step even if exec_file_host is NULL, so that
185 exec_file_attach will clear state. */
186 exec_file_attach (exec_file_host, add_flags & SYMFILE_VERBOSE);
187 }
188 catch (gdb_exception_error &err)
189 {
190 if (err.message != NULL)
191 warning ("%s", err.what ());
192
193 prev_err = std::move (err);
194 }
195
196 if (exec_file_host != NULL)
197 {
198 try
199 {
200 symbol_file_add_main (exec_file_host, add_flags);
201 }
202 catch (const gdb_exception_error &err)
203 {
204 if (prev_err != err)
205 warning ("%s", err.what ());
206 }
207 }
208}
209
210/* See gdbcore.h. */
211
212void
213validate_exec_file (int from_tty)
214{
215 /* If user asked to ignore the mismatch, do nothing. */
217 return;
218
219 const char *current_exec_file = get_exec_file (0);
220 struct inferior *inf = current_inferior ();
221 /* Try to determine a filename from the process itself. */
222 const char *pid_exec_file = target_pid_to_exec_file (inf->pid);
223 bool build_id_mismatch = false;
224
225 /* If we cannot validate the exec file, return. */
226 if (current_exec_file == NULL || pid_exec_file == NULL)
227 return;
228
229 /* Try validating via build-id, if available. This is the most
230 reliable check. */
231
232 /* In case current_exec_file was changed, reopen_exec_file ensures
233 an up to date build_id (will do nothing if the file timestamp
234 did not change). If exec file changed, reopen_exec_file has
235 allocated another file name, so get_exec_file again. */
237 current_exec_file = get_exec_file (0);
238
239 const bfd_build_id *exec_file_build_id
241 if (exec_file_build_id != nullptr)
242 {
243 /* Prepend the target prefix, to force gdb_bfd_open to open the
244 file on the remote file system (if indeed remote). */
245 std::string target_pid_exec_file
246 = std::string (TARGET_SYSROOT_PREFIX) + pid_exec_file;
247
248 gdb_bfd_ref_ptr abfd (gdb_bfd_open (target_pid_exec_file.c_str (),
249 gnutarget, -1, false));
250 if (abfd != nullptr)
251 {
252 const bfd_build_id *target_exec_file_build_id
253 = build_id_bfd_get (abfd.get ());
254
255 if (target_exec_file_build_id != nullptr)
256 {
257 if (exec_file_build_id->size == target_exec_file_build_id->size
258 && memcmp (exec_file_build_id->data,
259 target_exec_file_build_id->data,
260 exec_file_build_id->size) == 0)
261 {
262 /* Match. */
263 return;
264 }
265 else
266 build_id_mismatch = true;
267 }
268 }
269 }
270
271 if (build_id_mismatch)
272 {
273 std::string exec_file_target (pid_exec_file);
274
275 /* In case the exec file is not local, exec_file_target has to point at
276 the target file system. */
277 if (is_target_filename (current_exec_file) && !target_filesystem_is_local ())
278 exec_file_target = TARGET_SYSROOT_PREFIX + exec_file_target;
279
280 warning
281 (_("Build ID mismatch between current exec-file %ps\n"
282 "and automatically determined exec-file %ps\n"
283 "exec-file-mismatch handling is currently \"%s\""),
284 styled_string (file_name_style.style (), current_exec_file),
285 styled_string (file_name_style.style (), exec_file_target.c_str ()),
288 {
289 symfile_add_flags add_flags = SYMFILE_MAINLINE;
290 if (from_tty)
291 {
292 add_flags |= SYMFILE_VERBOSE;
293 add_flags |= SYMFILE_ALWAYS_CONFIRM;
294 }
295 try
296 {
297 symbol_file_add_main (exec_file_target.c_str (), add_flags);
298 exec_file_attach (exec_file_target.c_str (), from_tty);
299 }
300 catch (gdb_exception_error &err)
301 {
302 warning (_("loading %ps %s"),
304 exec_file_target.c_str ()),
305 err.message != NULL ? err.what () : "error");
306 }
307 }
308 }
309}
310
311/* See gdbcore.h. */
312
313void
314exec_file_locate_attach (int pid, int defer_bp_reset, int from_tty)
315{
316 const char *exec_file_target;
317 symfile_add_flags add_flags = 0;
318
319 /* Do nothing if we already have an executable filename. */
320 if (get_exec_file (0) != NULL)
321 return;
322
323 /* Try to determine a filename from the process itself. */
324 exec_file_target = target_pid_to_exec_file (pid);
325 if (exec_file_target == NULL)
326 {
327 warning (_("No executable has been specified and target does not "
328 "support\n"
329 "determining executable automatically. "
330 "Try using the \"file\" command."));
331 return;
332 }
333
334 gdb::unique_xmalloc_ptr<char> exec_file_host
335 = exec_file_find (exec_file_target, NULL);
336
337 if (defer_bp_reset)
338 add_flags |= SYMFILE_DEFER_BP_RESET;
339
340 if (from_tty)
341 add_flags |= SYMFILE_VERBOSE;
342
343 /* Attempt to open the exec file. */
344 try_open_exec_file (exec_file_host.get (), current_inferior (), add_flags);
345}
346
347/* Set FILENAME as the new exec file.
348
349 This function is intended to be behave essentially the same
350 as exec_file_command, except that the latter will detect when
351 a target is being debugged, and will ask the user whether it
352 should be shut down first. (If the answer is "no", then the
353 new file is ignored.)
354
355 This file is used by exec_file_command, to do the work of opening
356 and processing the exec file after any prompting has happened.
357
358 And, it is used by child_attach, when the attach command was
359 given a pid but not a exec pathname, and the attach command could
360 figure out the pathname from the pid. (In this case, we shouldn't
361 ask the user whether the current target should be shut down --
362 we're supplying the exec pathname late for good reason.) */
363
364void
365exec_file_attach (const char *filename, int from_tty)
366{
367 /* First, acquire a reference to the exec_bfd. We release
368 this at the end of the function; but acquiring it now lets the
369 BFD cache return it if this call refers to the same file. */
370 gdb_bfd_ref_ptr exec_bfd_holder
371 = gdb_bfd_ref_ptr::new_reference (current_program_space->exec_bfd ());
372
373 /* Remove any previous exec file. */
375
376 /* Now open and digest the file the user requested, if any. */
377
378 if (!filename)
379 {
380 if (from_tty)
381 gdb_printf (_("No executable file now.\n"));
382
384 }
385 else
386 {
387 int load_via_target = 0;
388 const char *scratch_pathname, *canonical_pathname;
389 int scratch_chan;
390 char **matching;
391
392 if (is_target_filename (filename))
393 {
395 filename += strlen (TARGET_SYSROOT_PREFIX);
396 else
397 load_via_target = 1;
398 }
399
400 gdb::unique_xmalloc_ptr<char> canonical_storage, scratch_storage;
401 if (load_via_target)
402 {
403 /* gdb_bfd_fopen does not support "target:" filenames. */
404 if (write_files)
405 warning (_("writing into executable files is "
406 "not supported for %s sysroots"),
408
409 scratch_pathname = filename;
410 scratch_chan = -1;
411 canonical_pathname = scratch_pathname;
412 }
413 else
414 {
415 scratch_chan = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST,
416 filename, write_files ?
417 O_RDWR | O_BINARY : O_RDONLY | O_BINARY,
418 &scratch_storage);
419#if defined(__GO32__) || defined(_WIN32) || defined(__CYGWIN__)
420 if (scratch_chan < 0)
421 {
422 int first_errno = errno;
423 char *exename = (char *) alloca (strlen (filename) + 5);
424
425 strcat (strcpy (exename, filename), ".exe");
426 scratch_chan = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST,
427 exename, write_files ?
428 O_RDWR | O_BINARY
429 : O_RDONLY | O_BINARY,
430 &scratch_storage);
431 if (scratch_chan < 0)
432 errno = first_errno;
433 }
434#endif
435 if (scratch_chan < 0)
436 perror_with_name (filename);
437
438 scratch_pathname = scratch_storage.get ();
439
440 /* gdb_bfd_open (and its variants) prefers canonicalized
441 pathname for better BFD caching. */
442 canonical_storage = gdb_realpath (scratch_pathname);
443 canonical_pathname = canonical_storage.get ();
444 }
445
446 gdb_bfd_ref_ptr temp;
447 if (write_files && !load_via_target)
448 temp = gdb_bfd_fopen (canonical_pathname, gnutarget,
449 FOPEN_RUB, scratch_chan);
450 else
451 temp = gdb_bfd_open (canonical_pathname, gnutarget, scratch_chan);
452 current_program_space->set_exec_bfd (std::move (temp));
453
455 {
456 error (_("\"%s\": could not open as an executable file: %s."),
457 scratch_pathname, bfd_errmsg (bfd_get_error ()));
458 }
459
460 /* gdb_realpath_keepfile resolves symlinks on the local
461 filesystem and so cannot be used for "target:" files. */
462 gdb_assert (current_program_space->exec_filename == nullptr);
463 if (load_via_target)
465 = (make_unique_xstrdup
466 (bfd_get_filename (current_program_space->exec_bfd ())));
467 else
469 = make_unique_xstrdup (gdb_realpath_keepfile
470 (scratch_pathname).c_str ());
471
472 if (!bfd_check_format_matches (current_program_space->exec_bfd (),
473 bfd_object, &matching))
474 {
475 /* Make sure to close exec_bfd, or else "run" might try to use
476 it. */
478 error (_("\"%s\": not in executable format: %s"), scratch_pathname,
479 gdb_bfd_errmsg (bfd_get_error (), matching).c_str ());
480 }
481
482 target_section_table sections
484
486 = bfd_get_mtime (current_program_space->exec_bfd ());
487
489
491
492 /* Add the executable's sections to the current address spaces'
493 list of sections. This possibly pushes the exec_ops
494 target. */
496 sections);
497
498 /* Tell display code (if any) about the changed file name. */
500 (*deprecated_exec_file_display_hook) (filename);
501 }
502
503 bfd_cache_close_all ();
505}
506
507/* Process the first arg in ARGS as the new exec file.
508
509 Note that we have to explicitly ignore additional args, since we can
510 be called from file_command(), which also calls symbol_file_command()
511 which can take multiple args.
512
513 If ARGS is NULL, we just want to close the exec file. */
514
515static void
516exec_file_command (const char *args, int from_tty)
517{
518 if (from_tty && target_has_execution ()
519 && !query (_("A program is being debugged already.\n"
520 "Are you sure you want to change the file? ")))
521 error (_("File not changed."));
522
523 if (args)
524 {
525 /* Scan through the args and pick up the first non option arg
526 as the filename. */
527
528 gdb_argv built_argv (args);
529 char **argv = built_argv.get ();
530
531 for (; (*argv != NULL) && (**argv == '-'); argv++)
532 {;
533 }
534 if (*argv == NULL)
535 error (_("No executable file name was specified"));
536
537 gdb::unique_xmalloc_ptr<char> filename (tilde_expand (*argv));
538 exec_file_attach (filename.get (), from_tty);
539 }
540 else
541 exec_file_attach (NULL, from_tty);
542}
543
544/* Set both the exec file and the symbol file, in one command.
545 What a novelty. Why did GDB go through four major releases before this
546 command was added? */
547
548static void
549file_command (const char *arg, int from_tty)
550{
551 /* FIXME, if we lose on reading the symbol file, we should revert
552 the exec file, but that's rough. */
553 exec_file_command (arg, from_tty);
554 symbol_file_command (arg, from_tty);
557}
558
559
560/* Builds a section table, given args BFD, TABLE. */
561
563build_section_table (struct bfd *some_bfd)
564{
566
567 for (asection *asect : gdb_bfd_sections (some_bfd))
568 {
569 flagword aflag;
570
571 /* Check the section flags, but do not discard zero-length
572 sections, since some symbols may still be attached to this
573 section. For instance, we encountered on sparc-solaris 2.10
574 a shared library with an empty .bss section to which a symbol
575 named "_end" was attached. The address of this symbol still
576 needs to be relocated. */
577 aflag = bfd_section_flags (asect);
578 if (!(aflag & SEC_ALLOC))
579 continue;
580
581 table.emplace_back (bfd_section_vma (asect),
582 bfd_section_vma (asect) + bfd_section_size (asect),
583 asect);
584 }
585
586 return table;
587}
588
589/* Add the sections array defined by [SECTIONS..SECTIONS_END[ to the
590 current set of target sections. */
591
592void
594 const target_section_table &sections)
595{
596 if (!sections.empty ())
597 {
598 for (const target_section &s : sections)
599 {
600 m_target_sections.push_back (s);
601 m_target_sections.back ().owner = owner;
602 }
603
604 scoped_restore_current_pspace_and_thread restore_pspace_thread;
605
606 /* If these are the first file sections we can provide memory
607 from, push the file_stratum target. Must do this in all
608 inferiors sharing the program space. */
609 for (inferior *inf : all_inferiors ())
610 {
611 if (inf->pspace != this)
612 continue;
613
614 if (inf->target_is_pushed (&exec_ops))
615 continue;
616
618 inf->push_target (&exec_ops);
619 }
620 }
621}
622
623/* Add the sections of OBJFILE to the current set of target sections. */
624
625void
627{
628 struct obj_section *osect;
629
630 gdb_assert (objfile != nullptr);
631
632 /* Compute the number of sections to add. */
634 {
635 if (bfd_section_size (osect->the_bfd_section) == 0)
636 continue;
637
638 m_target_sections.emplace_back (osect->addr (), osect->endaddr (),
639 osect->the_bfd_section, (void *) objfile);
640 }
641}
642
643/* Remove all target sections owned by OWNER.
644 OWNER must be the same value passed to add_target_sections. */
645
646void
648{
649 gdb_assert (owner != NULL);
650
651 auto it = std::remove_if (m_target_sections.begin (),
652 m_target_sections.end (),
653 [&] (target_section &sect)
654 {
655 return sect.owner == owner;
656 });
657 m_target_sections.erase (it, m_target_sections.end ());
658
659 /* If we don't have any more sections to read memory from,
660 remove the file_stratum target from the stack of each
661 inferior sharing the program space. */
662 if (m_target_sections.empty ())
663 {
664 scoped_restore_current_pspace_and_thread restore_pspace_thread;
665
666 for (inferior *inf : all_inferiors ())
667 {
668 if (inf->pspace != this)
669 continue;
670
672 inf->unpush_target (&exec_ops);
673 }
674 }
675}
676
677/* See exec.h. */
678
679void
681{
682 if (!vfork_child->pspace->target_sections ().empty ())
683 vfork_child->push_target (&exec_ops);
684}
685
686
687
689exec_read_partial_read_only (gdb_byte *readbuf, ULONGEST offset,
690 ULONGEST len, ULONGEST *xfered_len)
691{
692 /* It's unduly pedantic to refuse to look at the executable for
693 read-only pieces; so do the equivalent of readonly regions aka
694 QTro packet. */
695 if (current_program_space->exec_bfd () != NULL)
696 {
697 asection *s;
698 bfd_size_type size;
699 bfd_vma vma;
700
701 for (s = current_program_space->exec_bfd ()->sections; s; s = s->next)
702 {
703 if ((s->flags & SEC_LOAD) == 0
704 || (s->flags & SEC_READONLY) == 0)
705 continue;
706
707 vma = s->vma;
708 size = bfd_section_size (s);
709 if (vma <= offset && offset < (vma + size))
710 {
711 ULONGEST amt;
712
713 amt = (vma + size) - offset;
714 if (amt > len)
715 amt = len;
716
717 amt = bfd_get_section_contents (current_program_space->exec_bfd (), s,
718 readbuf, offset - vma, amt);
719
720 if (amt == 0)
721 return TARGET_XFER_EOF;
722 else
723 {
724 *xfered_len = amt;
725 return TARGET_XFER_OK;
726 }
727 }
728 }
729 }
730
731 /* Indicate failure to find the requested memory block. */
732 return TARGET_XFER_E_IO;
733}
734
735/* Return all read-only memory ranges found in the target section
736 table defined by SECTIONS and SECTIONS_END, starting at (and
737 intersected with) MEMADDR for LEN bytes. */
738
739static std::vector<mem_range>
740section_table_available_memory (CORE_ADDR memaddr, ULONGEST len,
741 const target_section_table &sections)
742{
743 std::vector<mem_range> memory;
744
745 for (const target_section &p : sections)
746 {
747 if ((bfd_section_flags (p.the_bfd_section) & SEC_READONLY) == 0)
748 continue;
749
750 /* Copy the meta-data, adjusted. */
751 if (mem_ranges_overlap (p.addr, p.endaddr - p.addr, memaddr, len))
752 {
753 ULONGEST lo1, hi1, lo2, hi2;
754
755 lo1 = memaddr;
756 hi1 = memaddr + len;
757
758 lo2 = p.addr;
759 hi2 = p.endaddr;
760
761 CORE_ADDR start = std::max (lo1, lo2);
762 int length = std::min (hi1, hi2) - start;
763
764 memory.emplace_back (start, length);
765 }
766 }
767
768 return memory;
769}
770
772section_table_read_available_memory (gdb_byte *readbuf, ULONGEST offset,
773 ULONGEST len, ULONGEST *xfered_len)
774{
775 const target_section_table *table
776 = target_get_section_table (current_inferior ()->top_target ());
777 std::vector<mem_range> available_memory
778 = section_table_available_memory (offset, len, *table);
779
780 normalize_mem_ranges (&available_memory);
781
782 for (const mem_range &r : available_memory)
783 {
784 if (mem_ranges_overlap (r.start, r.length, offset, len))
785 {
786 CORE_ADDR end;
788
789 /* Get the intersection window. */
790 end = std::min<CORE_ADDR> (offset + len, r.start + r.length);
791
792 gdb_assert (end - offset <= len);
793
794 if (offset >= r.start)
796 end - offset,
797 xfered_len);
798 else
799 {
800 *xfered_len = r.start - offset;
802 }
803 return status;
804 }
805 }
806
807 *xfered_len = len;
809}
810
812section_table_xfer_memory_partial (gdb_byte *readbuf, const gdb_byte *writebuf,
813 ULONGEST offset, ULONGEST len,
814 ULONGEST *xfered_len,
815 const target_section_table &sections,
816 gdb::function_view<bool
817 (const struct target_section *)> match_cb)
818{
819 int res;
820 ULONGEST memaddr = offset;
821 ULONGEST memend = memaddr + len;
822
823 gdb_assert (len != 0);
824
825 for (const target_section &p : sections)
826 {
827 struct bfd_section *asect = p.the_bfd_section;
828 bfd *abfd = asect->owner;
829
830 if (match_cb != nullptr && !match_cb (&p))
831 continue; /* not the section we need. */
832 if (memaddr >= p.addr)
833 {
834 if (memend <= p.endaddr)
835 {
836 /* Entire transfer is within this section. */
837 if (writebuf)
838 res = bfd_set_section_contents (abfd, asect,
839 writebuf, memaddr - p.addr,
840 len);
841 else
842 res = bfd_get_section_contents (abfd, asect,
843 readbuf, memaddr - p.addr,
844 len);
845
846 if (res != 0)
847 {
848 *xfered_len = len;
849 return TARGET_XFER_OK;
850 }
851 else
852 return TARGET_XFER_EOF;
853 }
854 else if (memaddr >= p.endaddr)
855 {
856 /* This section ends before the transfer starts. */
857 continue;
858 }
859 else
860 {
861 /* This section overlaps the transfer. Just do half. */
862 len = p.endaddr - memaddr;
863 if (writebuf)
864 res = bfd_set_section_contents (abfd, asect,
865 writebuf, memaddr - p.addr,
866 len);
867 else
868 res = bfd_get_section_contents (abfd, asect,
869 readbuf, memaddr - p.addr,
870 len);
871 if (res != 0)
872 {
873 *xfered_len = len;
874 return TARGET_XFER_OK;
875 }
876 else
877 return TARGET_XFER_EOF;
878 }
879 }
880 }
881
882 return TARGET_XFER_EOF; /* We can't help. */
883}
884
887 const char *annex, gdb_byte *readbuf,
888 const gdb_byte *writebuf,
889 ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
890{
892
893 if (object == TARGET_OBJECT_MEMORY)
894 return section_table_xfer_memory_partial (readbuf, writebuf,
895 offset, len, xfered_len,
896 *table);
897 else
898 return TARGET_XFER_E_IO;
899}
900
901
902void
904{
905 struct gdbarch *gdbarch = gdbarch_from_bfd (abfd);
906 /* FIXME: 16 is not wide enough when gdbarch_addr_bit > 64. */
907 int wid = gdbarch_addr_bit (gdbarch) <= 32 ? 8 : 16;
908
909 gdb_printf ("\t`%ps', ",
911 bfd_get_filename (abfd)));
912 gdb_stdout->wrap_here (8);
913 gdb_printf (_("file type %s.\n"), bfd_get_target (abfd));
914 if (abfd == current_program_space->exec_bfd ())
915 {
916 /* gcc-3.4 does not like the initialization in
917 <p == t->sections_end>. */
918 bfd_vma displacement = 0;
919 bfd_vma entry_point;
920 bool found = false;
921
922 for (const target_section &p : *t)
923 {
924 struct bfd_section *psect = p.the_bfd_section;
925
926 if ((bfd_section_flags (psect) & (SEC_ALLOC | SEC_LOAD))
927 != (SEC_ALLOC | SEC_LOAD))
928 continue;
929
930 if (bfd_section_vma (psect) <= abfd->start_address
931 && abfd->start_address < (bfd_section_vma (psect)
932 + bfd_section_size (psect)))
933 {
934 displacement = p.addr - bfd_section_vma (psect);
935 found = true;
936 break;
937 }
938 }
939 if (!found)
940 warning (_("Cannot find section for the entry point of %ps."),
942 bfd_get_filename (abfd)));
943
944 entry_point = gdbarch_addr_bits_remove (gdbarch,
945 bfd_get_start_address (abfd)
946 + displacement);
947 gdb_printf (_("\tEntry point: %s\n"),
948 paddress (gdbarch, entry_point));
949 }
950 for (const target_section &p : *t)
951 {
952 struct bfd_section *psect = p.the_bfd_section;
953 bfd *pbfd = psect->owner;
954
955 gdb_printf ("\t%s", hex_string_custom (p.addr, wid));
956 gdb_printf (" - %s", hex_string_custom (p.endaddr, wid));
957
958 /* FIXME: A format of "08l" is not wide enough for file offsets
959 larger than 4GB. OTOH, making it "016l" isn't desirable either
960 since most output will then be much wider than necessary. It
961 may make sense to test the size of the file and choose the
962 format string accordingly. */
963 /* FIXME: i18n: Need to rewrite this sentence. */
964 if (info_verbose)
965 gdb_printf (" @ %s",
966 hex_string_custom (psect->filepos, 8));
967 gdb_printf (" is %s", bfd_section_name (psect));
968 if (pbfd != abfd)
969 gdb_printf (" in %ps",
971 bfd_get_filename (pbfd)));
972 gdb_printf ("\n");
973 }
974}
975
976void
978{
982 else
983 gdb_puts (_("\t<no file loaded>\n"));
984}
985
986static void
987set_section_command (const char *args, int from_tty)
988{
989 const char *secname;
990
991 if (args == 0)
992 error (_("Must specify section name and its virtual address"));
993
994 /* Parse out section name. */
995 for (secname = args; !isspace (*args); args++);
996 unsigned seclen = args - secname;
997
998 /* Parse out new virtual address. */
999 CORE_ADDR secaddr = parse_and_eval_address (args);
1000
1002 {
1003 if (!strncmp (secname, bfd_section_name (p.the_bfd_section), seclen)
1004 && bfd_section_name (p.the_bfd_section)[seclen] == '\0')
1005 {
1006 long offset = secaddr - p.addr;
1007 p.addr += offset;
1008 p.endaddr += offset;
1009 if (from_tty)
1011 return;
1012 }
1013 }
1014
1015 std::string secprint (secname, seclen);
1016 error (_("Section %s not found"), secprint.c_str ());
1017}
1018
1019/* If we can find a section in FILENAME with BFD index INDEX, adjust
1020 it to ADDRESS. */
1021
1022void
1023exec_set_section_address (const char *filename, int index, CORE_ADDR address)
1024{
1026 {
1027 if (filename_cmp (filename,
1028 bfd_get_filename (p.the_bfd_section->owner)) == 0
1029 && index == p.the_bfd_section->index)
1030 {
1031 p.endaddr += address - p.addr;
1032 p.addr = address;
1033 }
1034 }
1035}
1036
1037bool
1039{
1040 /* We can provide memory if we have any file/target sections to read
1041 from. */
1042 return !current_program_space->target_sections ().empty ();
1043}
1044
1045gdb::unique_xmalloc_ptr<char>
1047{
1048 error (_("Can't create a corefile"));
1049}
1050
1051int
1053{
1054 return objfile_find_memory_regions (this, func, data);
1055}
1056
1057void _initialize_exec ();
1058void
1060{
1061 struct cmd_list_element *c;
1062
1063 c = add_cmd ("file", class_files, file_command, _("\
1064Use FILE as program to be debugged.\n\
1065It is read for its symbols, for getting the contents of pure memory,\n\
1066and it is the program executed when you use the `run' command.\n\
1067If FILE cannot be found as specified, your execution directory path\n\
1068($PATH) is searched for a command of that name.\n\
1069No arg means to have no executable file and no symbols."), &cmdlist);
1071
1072 c = add_cmd ("exec-file", class_files, exec_file_command, _("\
1073Use FILE as program for getting contents of pure memory.\n\
1074If FILE cannot be found as specified, your execution directory path\n\
1075is searched for a command of that name.\n\
1076No arg means have no executable file."), &cmdlist);
1078
1079 add_com ("section", class_files, set_section_command, _("\
1080Change the base address of section SECTION of the exec file to ADDR.\n\
1081This can be used if the exec file does not contain section addresses,\n\
1082(such as in the a.out format), or when the addresses specified in the\n\
1083file itself are wrong. Each section must be changed separately. The\n\
1084``info files'' command lists all the sections and their addresses."));
1085
1087Set writing into executable and core files."), _("\
1088Show writing into executable and core files."), NULL,
1089 NULL,
1091 &setlist, &showlist);
1092
1093 add_setshow_enum_cmd ("exec-file-mismatch", class_support,
1096 _("\
1097Set exec-file-mismatch handling (ask|warn|off)."),
1098 _("\
1099Show exec-file-mismatch handling (ask|warn|off)."),
1100 _("\
1101Specifies how to handle a mismatch between the current exec-file\n\
1102loaded by GDB and the exec-file automatically determined when attaching\n\
1103to a process:\n\n\
1104 ask - warn the user and ask whether to load the determined exec-file.\n\
1105 warn - warn the user, but do not change the exec-file.\n\
1106 off - do not check for mismatch.\n\
1107\n\
1108GDB detects a mismatch by comparing the build IDs of the files.\n\
1109If the user confirms loading the determined exec-file, then its symbols\n\
1110will be loaded as well."),
1113 &setlist, &showlist);
1114
1116}
struct gdbarch * gdbarch_from_bfd(bfd *abfd)
Definition arch-utils.c:637
void set_gdbarch_from_file(bfd *abfd)
Definition arch-utils.c:649
const struct bfd_build_id * build_id_bfd_get(bfd *abfd)
Definition build-id.c:33
ui_file_style style() const
Definition cli-style.c:169
void push_target(struct target_ops *t)
Definition inferior.h:376
const std::string & args() const
Definition inferior.h:498
struct program_space * pspace
Definition inferior.h:547
struct cmd_list_element * showlist
Definition cli-cmds.c:125
struct cmd_list_element * cmdlist
Definition cli-cmds.c:85
struct cmd_list_element * setlist
Definition cli-cmds.c:117
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, const char *doc, struct cmd_list_element **list)
Definition cli-decode.c:233
void set_cmd_completer(struct cmd_list_element *cmd, completer_ftype *completer)
Definition cli-decode.c:117
struct cmd_list_element * add_com(const char *name, enum command_class theclass, cmd_simple_func_ftype *fun, const char *doc)
set_show_commands add_setshow_enum_cmd(const char *name, enum command_class theclass, const char *const *enumlist, const char **var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition cli-decode.c:618
set_show_commands add_setshow_boolean_cmd(const char *name, enum command_class theclass, bool *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition cli-decode.c:739
cli_style_option file_name_style
@ class_support
Definition command.h:58
@ class_files
Definition command.h:57
void filename_completer(struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *word)
Definition completer.c:204
void validate_files(void)
Definition corefile.c:133
void reopen_exec_file(void)
Definition corefile.c:105
const char * get_exec_file(int err)
Definition corefile.c:149
hook_type deprecated_exec_file_display_hook
Definition corefile.c:48
const char * gnutarget
Definition corefile.c:394
#define O_BINARY
Definition defs.h:116
bool info_verbose
Definition top.c:2022
int(* find_memory_region_ftype)(CORE_ADDR addr, unsigned long size, int read, int write, int exec, int modified, bool memory_tagged, void *data)
Definition defs.h:351
void symbol_file_command(const char *, int)
Definition symfile.c:1592
CORE_ADDR parse_and_eval_address(const char *exp)
Definition eval.c:52
bool write_files
Definition exec.c:133
enum target_xfer_status section_table_xfer_memory_partial(gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len, const target_section_table &sections, gdb::function_view< bool(const struct target_section *)> match_cb)
Definition exec.c:812
static void show_exec_file_mismatch_command(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition exec.c:103
static void exec_file_command(const char *args, int from_tty)
Definition exec.c:516
static void exec_target_open(const char *args, int from_tty)
Definition exec.c:144
void exec_set_section_address(const char *filename, int index, CORE_ADDR address)
Definition exec.c:1023
enum target_xfer_status section_table_read_available_memory(gdb_byte *readbuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
Definition exec.c:772
target_section_table build_section_table(struct bfd *some_bfd)
Definition exec.c:563
void exec_file_attach(const char *filename, int from_tty)
Definition exec.c:365
static const char * exec_file_mismatch
Definition exec.c:97
void exec_file_locate_attach(int pid, int defer_bp_reset, int from_tty)
Definition exec.c:314
void try_open_exec_file(const char *exec_file_host, struct inferior *inf, symfile_add_flags add_flags)
Definition exec.c:166
static void file_command(const char *arg, int from_tty)
Definition exec.c:549
void print_section_info(const target_section_table *t, bfd *abfd)
Definition exec.c:903
static const char *const exec_file_mismatch_names[]
Definition exec.c:92
static const target_info exec_target_info
Definition exec.c:56
void _initialize_exec()
Definition exec.c:1059
void validate_exec_file(int from_tty)
Definition exec.c:213
static void set_exec_file_mismatch_command(const char *ignore, int from_tty, struct cmd_list_element *c)
Definition exec.c:113
void(* deprecated_file_changed_hook)(const char *)
Definition exec.c:54
enum target_xfer_status exec_read_partial_read_only(gdb_byte *readbuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
Definition exec.c:689
exec_file_mismatch_mode
Definition exec.c:94
@ exec_file_mismatch_off
Definition exec.c:95
@ exec_file_mismatch_warn
Definition exec.c:95
@ exec_file_mismatch_ask
Definition exec.c:95
void exec_on_vfork(inferior *vfork_child)
Definition exec.c:680
static void show_write_files(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition exec.c:135
static exec_target exec_ops
Definition exec.c:86
static std::vector< mem_range > section_table_available_memory(CORE_ADDR memaddr, ULONGEST len, const target_section_table &sections)
Definition exec.c:740
static void set_section_command(const char *args, int from_tty)
Definition exec.c:987
int objfile_find_memory_regions(struct target_ops *self, find_memory_region_ftype func, void *obfd)
Definition gcore.c:512
gdb_bfd_ref_ptr gdb_bfd_fopen(const char *filename, const char *target, const char *mode, int fd)
Definition gdb_bfd.c:875
std::string gdb_bfd_errmsg(bfd_error_type error_tag, char **matching)
Definition gdb_bfd.c:1048
int is_target_filename(const char *name)
Definition gdb_bfd.c:207
gdb_bfd_ref_ptr gdb_bfd_open(const char *name, const char *target, int fd, bool warn_if_slow)
Definition gdb_bfd.c:491
#define TARGET_SYSROOT_PREFIX
Definition gdb_bfd.h:40
gdb::ref_ptr< struct bfd, gdb_bfd_ref_policy > gdb_bfd_ref_ptr
Definition gdb_bfd.h:78
static gdb_bfd_section_range gdb_bfd_sections(bfd *abfd)
Definition gdb_bfd.h:222
int gdbarch_addr_bit(struct gdbarch *gdbarch)
Definition gdbarch.c:1708
bfd int * note_size
bfd * obfd
CORE_ADDR gdbarch_addr_bits_remove(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition gdbarch.c:3087
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t err
Definition gnu-nat.c:1790
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int int rusage_t pid_t pid
Definition gnu-nat.c:1792
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int status
Definition gnu-nat.c:1791
size_t size
Definition go32-nat.c:241
struct inferior * current_inferior(void)
Definition inferior.c:54
void switch_to_inferior_no_thread(inferior *inf)
Definition inferior.c:671
all_inferiors_range all_inferiors(process_stratum_target *proc_target=nullptr)
Definition inferior.h:758
int mem_ranges_overlap(CORE_ADDR start1, int len1, CORE_ADDR start2, int len2)
Definition memrange.c:25
void normalize_mem_ranges(std::vector< mem_range > *memory)
Definition memrange.c:45
observable executable_changed
#define ALL_OBJFILE_OSECTIONS(objfile, osect)
Definition objfiles.h:130
struct program_space * current_program_space
Definition progspace.c:39
std::vector< struct program_space * > program_spaces
Definition progspace.c:36
void(* func)(remote_target *remote, char *)
gdb::unique_xmalloc_ptr< char > exec_file_find(const char *in_pathname, int *fd)
Definition solib.c:340
int openp(const char *path, openp_flags opts, const char *string, int mode, gdb::unique_xmalloc_ptr< char > *filename_opened)
Definition source.c:805
@ OPF_TRY_CWD_FIRST
Definition source.h:30
enum target_xfer_status xfer_partial(enum target_object object, const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len) override
Definition exec.c:886
gdb::unique_xmalloc_ptr< char > make_corefile_notes(bfd *, int *) override
Definition exec.c:1046
bool has_memory() override
Definition exec.c:1038
void files_info() override
Definition exec.c:977
void close() override
Definition exec.c:154
int find_memory_regions(find_memory_region_ftype func, void *data) override
Definition exec.c:1052
strata stratum() const override
Definition exec.c:70
const target_info & info() const override
Definition exec.c:67
Definition gnu-nat.c:154
pid_t pid
Definition gnu-nat.c:166
CORE_ADDR addr() const
Definition objfiles.h:822
CORE_ADDR endaddr() const
Definition objfiles.h:829
CORE_ADDR offset() const
Definition objfiles.h:810
struct bfd_section * the_bfd_section
Definition objfiles.h:835
void remove_target_sections(void *owner)
Definition exec.c:647
void add_target_sections(void *owner, const target_section_table &sections)
Definition exec.c:593
gdb_bfd_ref_ptr ebfd
Definition progspace.h:315
target_section_table m_target_sections
Definition progspace.h:379
void exec_close()
Definition progspace.c:184
target_section_table & target_sections()
Definition progspace.h:303
bfd * exec_bfd() const
Definition progspace.h:264
void set_exec_bfd(gdb_bfd_ref_ptr &&abfd)
Definition progspace.h:270
gdb::unique_xmalloc_ptr< char > exec_filename
Definition progspace.h:321
Definition value.c:181
@ SYMFILE_MAINLINE
@ SYMFILE_VERBOSE
@ SYMFILE_DEFER_BP_RESET
@ SYMFILE_ALWAYS_CONFIRM
void symbol_file_add_main(const char *args, symfile_add_flags add_flags)
Definition symfile.c:1194
std::vector< target_section > target_section_table
bool target_filesystem_is_local()
Definition target.c:609
const char * target_pid_to_exec_file(int pid)
Definition target.c:427
bool target_has_execution(inferior *inf)
Definition target.c:202
const target_section_table * target_get_section_table(struct target_ops *target)
Definition target.c:1371
void add_target(const target_info &t, target_open_ftype *func, completer_ftype *completer)
Definition target.c:863
void target_preopen(int from_tty)
Definition target.c:2479
target_xfer_status
Definition target.h:214
@ TARGET_XFER_E_IO
Definition target.h:227
@ TARGET_XFER_EOF
Definition target.h:219
@ TARGET_XFER_OK
Definition target.h:216
@ TARGET_XFER_UNAVAILABLE
Definition target.h:222
target_object
Definition target.h:138
@ TARGET_OBJECT_MEMORY
Definition target.h:142
strata
Definition target.h:89
@ file_stratum
Definition target.h:91
static styled_string_s * styled_string(const ui_file_style &style, const char *str, styled_string_s &&tmp={})
Definition ui-out.h:151
void perror_with_name(const char *string)
Definition utils.c:643
int query(const char *ctlstr,...)
Definition utils.c:1010
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition utils.c:3114
void gdb_printf(struct ui_file *stream, const char *format,...)
Definition utils.c:1865
void gdb_puts(const char *linebuffer, struct ui_file *stream)
Definition utils.c:1788
#define gdb_stdout
Definition utils.h:188