GDB (xrefs)
Loading...
Searching...
No Matches
/tmp/gdb-13.1/gdb/infcmd.c
Go to the documentation of this file.
1/* Memory-access and commands for "inferior" process, for GDB.
2
3 Copyright (C) 1986-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 "arch-utils.h"
22#include "symtab.h"
23#include "gdbtypes.h"
24#include "frame.h"
25#include "inferior.h"
26#include "infrun.h"
27#include "gdbsupport/environ.h"
28#include "value.h"
29#include "gdbcmd.h"
30#include "symfile.h"
31#include "gdbcore.h"
32#include "target.h"
33#include "language.h"
34#include "objfiles.h"
35#include "completer.h"
36#include "ui-out.h"
37#include "regcache.h"
38#include "reggroups.h"
39#include "block.h"
40#include "solib.h"
41#include <ctype.h>
42#include "observable.h"
43#include "target-descriptions.h"
44#include "user-regs.h"
45#include "gdbthread.h"
46#include "valprint.h"
47#include "inline-frame.h"
48#include "tracepoint.h"
49#include "inf-loop.h"
50#include "linespec.h"
51#include "thread-fsm.h"
52#include "top.h"
53#include "interps.h"
54#include "skip.h"
55#include "gdbsupport/gdb_optional.h"
56#include "source.h"
57#include "cli/cli-style.h"
58#include "dwarf2/loc.h"
59
60/* Local functions: */
61
62static void until_next_command (int);
63
64static void step_1 (int, int, const char *);
65
66#define ERROR_NO_INFERIOR \
67 if (!target_has_execution ()) error (_("The program is not being run."));
68
69/* Scratch area where string containing arguments to give to the
70 program will be stored by 'set args'. As soon as anything is
71 stored, notice_args_set will move it into per-inferior storage.
72 Arguments are separated by spaces. Empty string (pointer to '\0')
73 means no args. */
74
75static std::string inferior_args_scratch;
76
77/* Scratch area where the new cwd will be stored by 'set cwd'. */
78
79static std::string inferior_cwd_scratch;
80
81/* Scratch area where 'set inferior-tty' will store user-provided value.
82 We'll immediate copy it into per-inferior storage. */
83
85
86/* Pid of our debugged inferior, or 0 if no inferior now.
87 Since various parts of infrun.c test this to see whether there is a program
88 being debugged it should be nonzero (currently 3 is used) for remote
89 debugging. */
90
92
93/* Nonzero if stopped due to completion of a stack dummy routine. */
94
96
97/* Nonzero if stopped due to a random (unexpected) signal in inferior
98 process. */
99
101
102
103/* Whether "finish" should print the value. */
104
105static bool finish_print = true;
106
107
108
109static void
110set_inferior_tty_command (const char *args, int from_tty,
111 struct cmd_list_element *c)
112{
113 /* CLI has assigned the user-provided value to inferior_io_terminal_scratch.
114 Now route it to current inferior. */
116}
117
118static void
119show_inferior_tty_command (struct ui_file *file, int from_tty,
120 struct cmd_list_element *c, const char *value)
121{
122 /* Note that we ignore the passed-in value in favor of computing it
123 directly. */
124 const std::string &inferior_tty = current_inferior ()->tty ();
125
126 gdb_printf (file,
127 _("Terminal for future runs of program being debugged "
128 "is \"%s\".\n"), inferior_tty.c_str ());
129}
130
131void
132set_inferior_args_vector (int argc, char **argv)
133{
134 gdb::array_view<char * const> args (argv, argc);
135 std::string n = construct_inferior_arguments (args);
136 current_inferior ()->set_args (std::move (n));
137}
138
139/* Notice when `set args' is run. */
140
141static void
142set_args_command (const char *args, int from_tty, struct cmd_list_element *c)
143{
144 /* CLI has assigned the user-provided value to inferior_args_scratch.
145 Now route it to current inferior. */
147}
148
149/* Notice when `show args' is run. */
150
151static void
152show_args_command (struct ui_file *file, int from_tty,
153 struct cmd_list_element *c, const char *value)
154{
155 /* Note that we ignore the passed-in value in favor of computing it
156 directly. */
157 deprecated_show_value_hack (file, from_tty, c,
158 current_inferior ()->args ().c_str ());
159}
160
161/* See gdbsupport/common-inferior.h. */
162
163const std::string &
165{
166 return current_inferior ()->cwd ();
167}
168
169/* Handle the 'set cwd' command. */
170
171static void
172set_cwd_command (const char *args, int from_tty, struct cmd_list_element *c)
173{
175}
176
177/* Handle the 'show cwd' command. */
178
179static void
180show_cwd_command (struct ui_file *file, int from_tty,
181 struct cmd_list_element *c, const char *value)
182{
183 const std::string &cwd = current_inferior ()->cwd ();
184
185 if (cwd.empty ())
186 gdb_printf (file,
187 _("\
188You have not set the inferior's current working directory.\n\
189The inferior will inherit GDB's cwd if native debugging, or the remote\n\
190server's cwd if remote debugging.\n"));
191 else
192 gdb_printf (file,
193 _("Current working directory that will be used "
194 "when starting the inferior is \"%s\".\n"),
195 cwd.c_str ());
196}
197
198
199/* This function strips the '&' character (indicating background
200 execution) that is added as *the last* of the arguments ARGS of a
201 command. A copy of the incoming ARGS without the '&' is returned,
202 unless the resulting string after stripping is empty, in which case
203 NULL is returned. *BG_CHAR_P is an output boolean that indicates
204 whether the '&' character was found. */
205
206static gdb::unique_xmalloc_ptr<char>
207strip_bg_char (const char *args, int *bg_char_p)
208{
209 const char *p;
210
211 if (args == nullptr || *args == '\0')
212 {
213 *bg_char_p = 0;
214 return nullptr;
215 }
216
217 p = args + strlen (args);
218 if (p[-1] == '&')
219 {
220 p--;
221 while (p > args && isspace (p[-1]))
222 p--;
223
224 *bg_char_p = 1;
225 if (p != args)
226 return gdb::unique_xmalloc_ptr<char>
227 (savestring (args, p - args));
228 else
229 return gdb::unique_xmalloc_ptr<char> (nullptr);
230 }
231
232 *bg_char_p = 0;
233 return make_unique_xstrdup (args);
234}
235
236/* Common actions to take after creating any sort of inferior, by any
237 means (running, attaching, connecting, et cetera). The target
238 should be stopped. */
239
240void
242{
243
244 /* Be sure we own the terminal in case write operations are performed. */
246
247 infrun_debug_show_threads ("threads in the newly created inferior",
248 current_inferior ()->non_exited_threads ());
249
250 /* If the target hasn't taken care of this already, do it now.
251 Targets which need to access registers during to_open,
252 to_create_inferior, or to_attach should do it earlier; but many
253 don't need to. */
255
256 /* Now that we know the register layout, retrieve current PC. But
257 if the PC is unavailable (e.g., we're opening a core file with
258 missing registers info), ignore it. */
260
261 thr->clear_stop_pc ();
262 try
263 {
264 regcache *rc = get_thread_regcache (thr);
265 thr->set_stop_pc (regcache_read_pc (rc));
266 }
267 catch (const gdb_exception_error &ex)
268 {
269 if (ex.error != NOT_AVAILABLE_ERROR)
270 throw;
271 }
272
274 {
275 const unsigned solib_add_generation
277
278 scoped_restore restore_in_initial_library_scan
279 = make_scoped_restore (&current_inferior ()->in_initial_library_scan,
280 true);
281
282 /* Create the hooks to handle shared library load and unload
283 events. */
285
286 if (current_program_space->solib_add_generation == solib_add_generation)
287 {
288 /* The platform-specific hook should load initial shared libraries,
289 but didn't. FROM_TTY will be incorrectly 0 but such solib
290 targets should be fixed anyway. Call it only after the solib
291 target has been initialized by solib_create_inferior_hook. */
292
293 if (info_verbose)
294 warning (_("platform-specific solib_create_inferior_hook did "
295 "not load initial shared libraries."));
296
297 /* If the solist is global across processes, there's no need to
298 refetch it here. */
300 solib_add (nullptr, 0, auto_solib_add);
301 }
302 }
303
304 /* If the user sets watchpoints before execution having started,
305 then she gets software watchpoints, because GDB can't know which
306 target will end up being pushed, or if it supports hardware
307 watchpoints or not. breakpoint_re_set takes care of promoting
308 watchpoints to hardware watchpoints if possible, however, if this
309 new inferior doesn't load shared libraries or we don't pull in
310 symbols from any other source on this target/arch,
311 breakpoint_re_set is never called. Call it now so that software
312 watchpoints get a chance to be promoted to hardware watchpoints
313 if the now pushed target supports hardware watchpoints. */
315
317}
318
319/* Kill the inferior if already running. This function is designed
320 to be called when we are about to start the execution of the program
321 from the beginning. Ask the user to confirm that he wants to restart
322 the program being debugged when FROM_TTY is non-null. */
323
324static void
326{
327 if (inferior_ptid != null_ptid && target_has_execution ())
328 {
329 /* Bail out before killing the program if we will not be able to
330 restart it. */
332
333 if (from_tty
334 && !query (_("The program being debugged has been started already.\n\
335Start it from the beginning? ")))
336 error (_("Program not restarted."));
337 target_kill ();
338 }
339}
340
341/* See inferior.h. */
342
343void
344prepare_execution_command (struct target_ops *target, int background)
345{
346 /* If we get a request for running in the bg but the target
347 doesn't support it, error out. */
348 if (background && !target_can_async_p (target))
349 error (_("Asynchronous execution not supported on this target."));
350
351 if (!background)
352 {
353 /* If we get a request for running in the fg, then we need to
354 simulate synchronous (fg) execution. Note no cleanup is
355 necessary for this. stdin is re-enabled whenever an error
356 reaches the top level. */
358 }
359}
360
361/* Determine how the new inferior will behave. */
362
364 {
365 /* Run program without any explicit stop during startup. */
367
368 /* Stop at the beginning of the program's main function. */
370
371 /* Stop at the first instruction of the program. */
373 };
374
375/* Implement the "run" command. Force a stop during program start if
376 requested by RUN_HOW. */
377
378static void
379run_command_1 (const char *args, int from_tty, enum run_how run_how)
380{
381 const char *exec_file;
382 struct ui_out *uiout = current_uiout;
383 struct target_ops *run_target;
384 int async_exec;
385
386 dont_repeat ();
387
388 scoped_disable_commit_resumed disable_commit_resumed ("running");
389
390 kill_if_already_running (from_tty);
391
394
395 /* Clean up any leftovers from other runs. Some other things from
396 this function should probably be moved into target_pre_inferior. */
397 target_pre_inferior (from_tty);
398
399 /* The comment here used to read, "The exec file is re-read every
400 time we do a generic_mourn_inferior, so we just have to worry
401 about the symbol file." The `generic_mourn_inferior' function
402 gets called whenever the program exits. However, suppose the
403 program exits, and *then* the executable file changes? We need
404 to check again here. Since reopen_exec_file doesn't do anything
405 if the timestamp hasn't changed, I don't see the harm. */
407 reread_symbols (from_tty);
408
409 gdb::unique_xmalloc_ptr<char> stripped = strip_bg_char (args, &async_exec);
410 args = stripped.get ();
411
412 /* Do validation and preparation before possibly changing anything
413 in the inferior. */
414
415 run_target = find_run_target ();
416
417 prepare_execution_command (run_target, async_exec);
418
419 if (non_stop && !run_target->supports_non_stop ())
420 error (_("The target does not support running in non-stop mode."));
421
422 /* Done. Can now set breakpoints, change inferior args, etc. */
423
424 /* Insert temporary breakpoint in main function if requested. */
426 {
427 /* To avoid other inferiors hitting this breakpoint, make it
428 inferior-specific using a condition. A better solution would be to
429 have proper inferior-specific breakpoint support, in the breakpoint
430 machinery. We could then avoid inserting a breakpoint in the program
431 spaces unrelated to this inferior. */
432 const char *op
435 || current_language->la_language == language_m2) ? "=" : "==");
436 std::string arg = string_printf
437 ("-qualified %s if $_inferior %s %d", main_name (), op,
438 current_inferior ()->num);
439 tbreak_command (arg.c_str (), 0);
440 }
441
442 exec_file = get_exec_file (0);
443
444 /* We keep symbols from add-symbol-file, on the grounds that the
445 user might want to add some symbols before running the program
446 (right?). But sometimes (dynamic loading where the user manually
447 introduces the new symbols with add-symbol-file), the code which
448 the symbols describe does not persist between runs. Currently
449 the user has to manually nuke all symbols between runs if they
450 want them to go away (PR 2207). This is probably reasonable. */
451
452 /* If there were other args, beside '&', process them. */
453 if (args != nullptr)
454 current_inferior ()->set_args (args);
455
456 if (from_tty)
457 {
458 uiout->field_string (nullptr, "Starting program");
459 uiout->text (": ");
460 if (exec_file)
461 uiout->field_string ("execfile", exec_file,
463 uiout->spaces (1);
464 uiout->field_string ("infargs", current_inferior ()->args ());
465 uiout->text ("\n");
466 uiout->flush ();
467 }
468
469 run_target->create_inferior (exec_file,
470 current_inferior ()->args (),
471 current_inferior ()->environment.envp (),
472 from_tty);
473 /* to_create_inferior should push the target, so after this point we
474 shouldn't refer to run_target again. */
475 run_target = nullptr;
476
477 infrun_debug_show_threads ("immediately after create_process",
478 current_inferior ()->non_exited_threads ());
479
480 /* We're starting off a new process. When we get out of here, in
481 non-stop mode, finish the state of all threads of that process,
482 but leave other threads alone, as they may be stopped in internal
483 events --- the frontend shouldn't see them as stopped. In
484 all-stop, always finish the state of all threads, as we may be
485 resuming more than just the new process. */
486 process_stratum_target *finish_target;
487 ptid_t finish_ptid;
488 if (non_stop)
489 {
490 finish_target = current_inferior ()->process_target ();
491 finish_ptid = ptid_t (current_inferior ()->pid);
492 }
493 else
494 {
495 finish_target = nullptr;
496 finish_ptid = minus_one_ptid;
497 }
498 scoped_finish_thread_state finish_state (finish_target, finish_ptid);
499
500 /* Pass zero for FROM_TTY, because at this point the "run" command
501 has done its thing; now we are setting up the running program. */
503
504 /* Queue a pending event so that the program stops immediately. */
506 {
509 ws.set_stopped (GDB_SIGNAL_0);
510 thr->set_pending_waitstatus (ws);
511 }
512
513 /* Start the target running. Do not use -1 continuation as it would skip
514 breakpoint right at the entry point. */
515 proceed (regcache_read_pc (get_current_regcache ()), GDB_SIGNAL_0);
516
517 /* Since there was no error, there's no need to finish the thread
518 states here. */
519 finish_state.release ();
520
521 disable_commit_resumed.reset_and_commit ();
522}
523
524static void
525run_command (const char *args, int from_tty)
526{
527 run_command_1 (args, from_tty, RUN_NORMAL);
528}
529
530/* Start the execution of the program up until the beginning of the main
531 program. */
532
533static void
534start_command (const char *args, int from_tty)
535{
536 /* Some languages such as Ada need to search inside the program
537 minimal symbols for the location where to put the temporary
538 breakpoint before starting. */
539 if (!have_minimal_symbols ())
540 error (_("No symbol table loaded. Use the \"file\" command."));
541
542 /* Run the program until reaching the main procedure... */
543 run_command_1 (args, from_tty, RUN_STOP_AT_MAIN);
544}
545
546/* Start the execution of the program stopping at the first
547 instruction. */
548
549static void
550starti_command (const char *args, int from_tty)
551{
552 run_command_1 (args, from_tty, RUN_STOP_AT_FIRST_INSN);
553}
554
555static int
556proceed_thread_callback (struct thread_info *thread, void *arg)
557{
558 /* We go through all threads individually instead of compressing
559 into a single target `resume_all' request, because some threads
560 may be stopped in internal breakpoints/events, or stopped waiting
561 for its turn in the displaced stepping queue (that is, they are
562 running && !executing). The target side has no idea about why
563 the thread is stopped, so a `resume_all' command would resume too
564 much. If/when GDB gains a way to tell the target `hold this
565 thread stopped until I say otherwise', then we can optimize
566 this. */
567 if (thread->state != THREAD_STOPPED)
568 return 0;
569
570 if (!thread->inf->has_execution ())
571 return 0;
572
573 switch_to_thread (thread);
575 proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT);
576 return 0;
577}
578
579static void
581{
582 if (inferior_ptid == null_ptid
583 || inferior_thread ()->state == THREAD_EXITED)
584 error (_("Cannot execute this command without a live selected thread."));
585}
586
587/* If the user is looking at trace frames, any resumption of execution
588 is likely to mix up recorded and live target data. So simply
589 disallow those commands. */
590
591static void
593{
594 if (get_traceframe_number () >= 0)
595 error (_("Cannot execute this command while looking at trace frames."));
596}
597
598/* Throw an error indicating the current thread is running. */
599
600static void
602{
603 error (_("Cannot execute this command while "
604 "the selected thread is running."));
605}
606
607/* Calls error_is_running if the current thread is running. */
608
609static void
611{
612 if (inferior_thread ()->state == THREAD_RUNNING)
614}
615
616void
618{
621
622 if (non_stop && all_threads)
623 {
624 /* Don't error out if the current thread is running, because
625 there may be other stopped threads. */
626
627 /* Backup current thread and selected frame and restore on scope
628 exit. */
629 scoped_restore_current_thread restore_thread;
630 scoped_disable_commit_resumed disable_commit_resumed
631 ("continue all threads in non-stop");
632
634
636 {
637 /* If all threads in the target were already running,
638 proceed_thread_callback ends up never calling proceed,
639 and so nothing calls this to put the inferior's terminal
640 settings in effect and remove stdin from the event loop,
641 which we must when running a foreground command. E.g.:
642
643 (gdb) c -a&
644 Continuing.
645 <all threads are running now>
646 (gdb) c -a
647 Continuing.
648 <no thread was resumed, but the inferior now owns the terminal>
649 */
651 }
652
653 disable_commit_resumed.reset_and_commit ();
654 }
655 else
656 {
660 proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT);
661 }
662}
663
664/* continue [-a] [proceed-count] [&] */
665
666static void
667continue_command (const char *args, int from_tty)
668{
669 int async_exec;
670 bool all_threads_p = false;
671
673
674 /* Find out whether we must run in the background. */
675 gdb::unique_xmalloc_ptr<char> stripped = strip_bg_char (args, &async_exec);
676 args = stripped.get ();
677
678 if (args != nullptr)
679 {
680 if (startswith (args, "-a"))
681 {
682 all_threads_p = true;
683 args += sizeof ("-a") - 1;
684 if (*args == '\0')
685 args = nullptr;
686 }
687 }
688
689 if (!non_stop && all_threads_p)
690 error (_("`-a' is meaningless in all-stop mode."));
691
692 if (args != nullptr && all_threads_p)
693 error (_("Can't resume all threads and specify "
694 "proceed count simultaneously."));
695
696 /* If we have an argument left, set proceed count of breakpoint we
697 stopped at. */
698 if (args != nullptr)
699 {
700 bpstat *bs = nullptr;
701 int num, stat;
702 int stopped = 0;
703 struct thread_info *tp;
704
705 if (non_stop)
706 tp = inferior_thread ();
707 else
708 {
709 process_stratum_target *last_target;
710 ptid_t last_ptid;
711
712 get_last_target_status (&last_target, &last_ptid, nullptr);
713 tp = find_thread_ptid (last_target, last_ptid);
714 }
715 if (tp != nullptr)
716 bs = tp->control.stop_bpstat;
717
718 while ((stat = bpstat_num (&bs, &num)) != 0)
719 if (stat > 0)
720 {
721 set_ignore_count (num,
722 parse_and_eval_long (args) - 1,
723 from_tty);
724 /* set_ignore_count prints a message ending with a period.
725 So print two spaces before "Continuing.". */
726 if (from_tty)
727 gdb_printf (" ");
728 stopped = 1;
729 }
730
731 if (!stopped && from_tty)
732 {
734 ("Not stopped at any breakpoint; argument ignored.\n");
735 }
736 }
737
740
741 if (!non_stop || !all_threads_p)
742 {
745 }
746
747 prepare_execution_command (current_inferior ()->top_target (), async_exec);
748
749 if (from_tty)
750 gdb_printf (_("Continuing.\n"));
751
752 continue_1 (all_threads_p);
753}
754
755/* Record in TP the starting point of a "step" or "next" command. */
756
757static void
759{
760 /* This can be removed once this function no longer implicitly relies on the
761 inferior_ptid value. */
762 gdb_assert (inferior_ptid == tp->ptid);
763
765
766 symtab_and_line sal = find_frame_sal (frame);
767 set_step_info (tp, frame, sal);
768
769 CORE_ADDR pc = get_frame_pc (frame);
771}
772
773/* Step until outside of current statement. */
774
775static void
776step_command (const char *count_string, int from_tty)
777{
778 step_1 (0, 0, count_string);
779}
780
781/* Likewise, but skip over subroutine calls as if single instructions. */
782
783static void
784next_command (const char *count_string, int from_tty)
785{
786 step_1 (1, 0, count_string);
787}
788
789/* Likewise, but step only one instruction. */
790
791static void
792stepi_command (const char *count_string, int from_tty)
793{
794 step_1 (0, 1, count_string);
795}
796
797static void
798nexti_command (const char *count_string, int from_tty)
799{
800 step_1 (1, 1, count_string);
801}
802
803/* Data for the FSM that manages the step/next/stepi/nexti
804 commands. */
805
807{
808 /* How many steps left in a "step N"-like command. */
809 int count;
810
811 /* If true, this is a next/nexti, otherwise a step/stepi. */
813
814 /* If true, this is a stepi/nexti, otherwise a step/step. */
816
817 explicit step_command_fsm (struct interp *cmd_interp)
818 : thread_fsm (cmd_interp)
819 {
820 }
821
822 void clean_up (struct thread_info *thread) override;
823 bool should_stop (struct thread_info *thread) override;
825};
826
827/* Prepare for a step/next/etc. command. Any target resource
828 allocated here is undone in the FSM's clean_up method. */
829
830static void
832 int skip_subroutines, int single_inst,
833 int count, struct thread_info *thread)
834{
835 sm->skip_subroutines = skip_subroutines;
836 sm->single_inst = single_inst;
837 sm->count = count;
838
839 /* Leave the si command alone. */
840 if (!sm->single_inst || sm->skip_subroutines)
842
843 thread->control.stepping_command = 1;
844}
845
846static int prepare_one_step (thread_info *, struct step_command_fsm *sm);
847
848static void
849step_1 (int skip_subroutines, int single_inst, const char *count_string)
850{
851 int count;
852 int async_exec;
853 struct thread_info *thr;
854 struct step_command_fsm *step_sm;
855
860
861 gdb::unique_xmalloc_ptr<char> stripped
862 = strip_bg_char (count_string, &async_exec);
863 count_string = stripped.get ();
864
865 prepare_execution_command (current_inferior ()->top_target (), async_exec);
866
867 count = count_string ? parse_and_eval_long (count_string) : 1;
868
870
871 /* Setup the execution command state machine to handle all the COUNT
872 steps. */
873 thr = inferior_thread ();
874 step_sm = new step_command_fsm (command_interp ());
875 thr->set_thread_fsm (std::unique_ptr<thread_fsm> (step_sm));
876
878 single_inst, count, thr);
879
880 /* Do only one step for now, before returning control to the event
881 loop. Let the continuation figure out how many other steps we
882 need to do, and handle them one at the time, through
883 step_once. */
884 if (!prepare_one_step (thr, step_sm))
885 proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT);
886 else
887 {
888 int proceeded;
889
890 /* Stepped into an inline frame. Pretend that we've
891 stopped. */
892 thr->thread_fsm ()->clean_up (thr);
893 proceeded = normal_stop ();
894 if (!proceeded)
897 }
898}
899
900/* Implementation of the 'should_stop' FSM method for stepping
901 commands. Called after we are done with one step operation, to
902 check whether we need to step again, before we print the prompt and
903 return control to the user. If count is > 1, returns false, as we
904 will need to keep going. */
905
906bool
908{
909 if (tp->control.stop_step)
910 {
911 /* There are more steps to make, and we did stop due to
912 ending a stepping range. Do another step. */
913 if (--count > 0)
914 return prepare_one_step (tp, this);
915
916 set_finished ();
917 }
918
919 return true;
920}
921
922/* Implementation of the 'clean_up' FSM method for stepping commands. */
923
924void
926{
929}
930
931/* Implementation of the 'async_reply_reason' FSM method for stepping
932 commands. */
933
936{
938}
939
940/* Prepare for one step in "step N". The actual target resumption is
941 done by the caller. Return true if we're done and should thus
942 report a stop to the user. Returns false if the target needs to be
943 resumed. */
944
945static int
947{
948 /* This can be removed once this function no longer implicitly relies on the
949 inferior_ptid value. */
950 gdb_assert (inferior_ptid == tp->ptid);
951
952 if (sm->count > 0)
953 {
955
956 set_step_frame (tp);
957
958 if (!sm->single_inst)
959 {
960 CORE_ADDR pc;
961
962 /* Step at an inlined function behaves like "down". */
963 if (!sm->skip_subroutines
964 && inline_skipped_frames (tp))
965 {
966 ptid_t resume_ptid;
967 const char *fn = nullptr;
968 symtab_and_line sal;
969 struct symbol *sym;
970
971 /* Pretend that we've ran. */
972 resume_ptid = user_visible_resume_ptid (1);
973 set_running (tp->inf->process_target (), resume_ptid, true);
974
976
977 frame = get_current_frame ();
978 sal = find_frame_sal (frame);
979 sym = get_frame_function (frame);
980
981 if (sym != nullptr)
982 fn = sym->print_name ();
983
984 if (sal.line == 0
986 {
987 sm->count--;
988 return prepare_one_step (tp, sm);
989 }
990 }
991
992 pc = get_frame_pc (frame);
996
997 /* There's a problem in gcc (PR gcc/98780) that causes missing line
998 table entries, which results in a too large stepping range.
999 Use inlined_subroutine info to make the range more narrow. */
1000 if (inline_skipped_frames (tp) > 0)
1001 {
1002 symbol *sym = inline_skipped_symbol (tp);
1003 if (sym->aclass () == LOC_BLOCK)
1004 {
1005 const block *block = sym->value_block ();
1006 if (block->end () < tp->control.step_range_end)
1007 tp->control.step_range_end = block->end ();
1008 }
1009 }
1010
1011 tp->control.may_range_step = 1;
1012
1013 /* If we have no line info, switch to stepi mode. */
1015 {
1017 tp->control.may_range_step = 0;
1018 }
1019 else if (tp->control.step_range_end == 0)
1020 {
1021 const char *name;
1022
1025 &tp->control.step_range_end) == 0)
1026 error (_("Cannot find bounds of current function"));
1027
1029 gdb_printf (_("Single stepping until exit from function %s,"
1030 "\nwhich has no line number information.\n"),
1031 name);
1032 }
1033 }
1034 else
1035 {
1036 /* Say we are stepping, but stop after one insn whatever it does. */
1038 if (!sm->skip_subroutines)
1039 /* It is stepi.
1040 Don't step over function calls, not even to functions lacking
1041 line numbers. */
1043 }
1044
1045 if (sm->skip_subroutines)
1047
1048 return 0;
1049 }
1050
1051 /* Done. */
1052 sm->set_finished ();
1053 return 1;
1054}
1055
1056
1057/* Continue program at specified address. */
1058
1059static void
1060jump_command (const char *arg, int from_tty)
1061{
1062 struct gdbarch *gdbarch = get_current_arch ();
1063 CORE_ADDR addr;
1064 struct symbol *fn;
1065 struct symbol *sfn;
1066 int async_exec;
1067
1072
1073 /* Find out whether we must run in the background. */
1074 gdb::unique_xmalloc_ptr<char> stripped = strip_bg_char (arg, &async_exec);
1075 arg = stripped.get ();
1076
1077 prepare_execution_command (current_inferior ()->top_target (), async_exec);
1078
1079 if (!arg)
1080 error_no_arg (_("starting address"));
1081
1082 std::vector<symtab_and_line> sals
1084 if (sals.size () != 1)
1085 error (_("Unreasonable jump request"));
1086
1087 symtab_and_line &sal = sals[0];
1088
1089 if (sal.symtab == 0 && sal.pc == 0)
1090 error (_("No source file has been specified."));
1091
1092 resolve_sal_pc (&sal); /* May error out. */
1093
1094 /* See if we are trying to jump to another function. */
1096 sfn = find_pc_function (sal.pc);
1097 if (fn != nullptr && sfn != fn)
1098 {
1099 if (!query (_("Line %d is not in `%s'. Jump anyway? "), sal.line,
1100 fn->print_name ()))
1101 {
1102 error (_("Not confirmed."));
1103 /* NOTREACHED */
1104 }
1105 }
1106
1107 if (sfn != nullptr)
1108 {
1109 struct obj_section *section;
1110
1111 fixup_symbol_section (sfn, 0);
1112 section = sfn->obj_section (sfn->objfile ());
1113 if (section_is_overlay (section)
1114 && !section_is_mapped (section))
1115 {
1116 if (!query (_("WARNING!!! Destination is in "
1117 "unmapped overlay! Jump anyway? ")))
1118 {
1119 error (_("Not confirmed."));
1120 /* NOTREACHED */
1121 }
1122 }
1123 }
1124
1125 addr = sal.pc;
1126
1127 if (from_tty)
1128 {
1129 gdb_printf (_("Continuing at "));
1131 gdb_printf (".\n");
1132 }
1133
1135 proceed (addr, GDB_SIGNAL_0);
1136}
1137
1138/* Continue program giving it specified signal. */
1139
1140static void
1141signal_command (const char *signum_exp, int from_tty)
1142{
1143 enum gdb_signal oursig;
1144 int async_exec;
1145
1146 dont_repeat (); /* Too dangerous. */
1151
1152 /* Find out whether we must run in the background. */
1153 gdb::unique_xmalloc_ptr<char> stripped
1154 = strip_bg_char (signum_exp, &async_exec);
1155 signum_exp = stripped.get ();
1156
1157 prepare_execution_command (current_inferior ()->top_target (), async_exec);
1158
1159 if (!signum_exp)
1160 error_no_arg (_("signal number"));
1161
1162 /* It would be even slicker to make signal names be valid expressions,
1163 (the type could be "enum $signal" or some such), then the user could
1164 assign them to convenience variables. */
1165 oursig = gdb_signal_from_name (signum_exp);
1166
1167 if (oursig == GDB_SIGNAL_UNKNOWN)
1168 {
1169 /* No, try numeric. */
1170 int num = parse_and_eval_long (signum_exp);
1171
1172 if (num == 0)
1173 oursig = GDB_SIGNAL_0;
1174 else
1175 oursig = gdb_signal_from_command (num);
1176 }
1177
1178 /* Look for threads other than the current that this command ends up
1179 resuming too (due to schedlock off), and warn if they'll get a
1180 signal delivered. "signal 0" is used to suppress a previous
1181 signal, but if the current thread is no longer the one that got
1182 the signal, then the user is potentially suppressing the signal
1183 of the wrong thread. */
1184 if (!non_stop)
1185 {
1186 int must_confirm = 0;
1187
1188 /* This indicates what will be resumed. Either a single thread,
1189 a whole process, or all threads of all processes. */
1190 ptid_t resume_ptid = user_visible_resume_ptid (0);
1191 process_stratum_target *resume_target
1192 = user_visible_resume_target (resume_ptid);
1193
1194 thread_info *current = inferior_thread ();
1195
1196 for (thread_info *tp : all_non_exited_threads (resume_target, resume_ptid))
1197 {
1198 if (tp == current)
1199 continue;
1200
1201 if (tp->stop_signal () != GDB_SIGNAL_0
1202 && signal_pass_state (tp->stop_signal ()))
1203 {
1204 if (!must_confirm)
1205 gdb_printf (_("Note:\n"));
1206 gdb_printf (_(" Thread %s previously stopped with signal %s, %s.\n"),
1207 print_thread_id (tp),
1208 gdb_signal_to_name (tp->stop_signal ()),
1209 gdb_signal_to_string (tp->stop_signal ()));
1210 must_confirm = 1;
1211 }
1212 }
1213
1214 if (must_confirm
1215 && !query (_("Continuing thread %s (the current thread) with specified signal will\n"
1216 "still deliver the signals noted above to their respective threads.\n"
1217 "Continue anyway? "),
1219 error (_("Not confirmed."));
1220 }
1221
1222 if (from_tty)
1223 {
1224 if (oursig == GDB_SIGNAL_0)
1225 gdb_printf (_("Continuing with no signal.\n"));
1226 else
1227 gdb_printf (_("Continuing with signal %s.\n"),
1228 gdb_signal_to_name (oursig));
1229 }
1230
1232 proceed ((CORE_ADDR) -1, oursig);
1233}
1234
1235/* Queue a signal to be delivered to the current thread. */
1236
1237static void
1238queue_signal_command (const char *signum_exp, int from_tty)
1239{
1240 enum gdb_signal oursig;
1241 struct thread_info *tp;
1242
1247
1248 if (signum_exp == nullptr)
1249 error_no_arg (_("signal number"));
1250
1251 /* It would be even slicker to make signal names be valid expressions,
1252 (the type could be "enum $signal" or some such), then the user could
1253 assign them to convenience variables. */
1254 oursig = gdb_signal_from_name (signum_exp);
1255
1256 if (oursig == GDB_SIGNAL_UNKNOWN)
1257 {
1258 /* No, try numeric. */
1259 int num = parse_and_eval_long (signum_exp);
1260
1261 if (num == 0)
1262 oursig = GDB_SIGNAL_0;
1263 else
1264 oursig = gdb_signal_from_command (num);
1265 }
1266
1267 if (oursig != GDB_SIGNAL_0
1268 && !signal_pass_state (oursig))
1269 error (_("Signal handling set to not pass this signal to the program."));
1270
1271 tp = inferior_thread ();
1272 tp->set_stop_signal (oursig);
1273}
1274
1275/* Data for the FSM that manages the until (with no argument)
1276 command. */
1277
1279{
1280 /* The thread that as current when the command was executed. */
1282
1283 until_next_fsm (struct interp *cmd_interp, int thread)
1284 : thread_fsm (cmd_interp),
1285 thread (thread)
1286 {
1287 }
1288
1289 bool should_stop (struct thread_info *thread) override;
1290 void clean_up (struct thread_info *thread) override;
1292};
1293
1294/* Implementation of the 'should_stop' FSM method for the until (with
1295 no arg) command. */
1296
1297bool
1299{
1300 if (tp->control.stop_step)
1301 set_finished ();
1302
1303 return true;
1304}
1305
1306/* Implementation of the 'clean_up' FSM method for the until (with no
1307 arg) command. */
1308
1309void
1311{
1312 delete_longjmp_breakpoint (thread->global_num);
1313}
1314
1315/* Implementation of the 'async_reply_reason' FSM method for the until
1316 (with no arg) command. */
1317
1320{
1322}
1323
1324/* Proceed until we reach a different source line with pc greater than
1325 our current one or exit the function. We skip calls in both cases.
1326
1327 Note that eventually this command should probably be changed so
1328 that only source lines are printed out when we hit the breakpoint
1329 we set. This may involve changes to wait_for_inferior and the
1330 proceed status code. */
1331
1332static void
1334{
1335 frame_info_ptr frame;
1336 CORE_ADDR pc;
1337 struct symbol *func;
1338 struct symtab_and_line sal;
1339 struct thread_info *tp = inferior_thread ();
1340 int thread = tp->global_num;
1341 struct until_next_fsm *sm;
1342
1344 set_step_frame (tp);
1345
1346 frame = get_current_frame ();
1347
1348 /* Step until either exited from this function or greater
1349 than the current line (if in symbolic section) or pc (if
1350 not). */
1351
1352 pc = get_frame_pc (frame);
1353 func = find_pc_function (pc);
1354
1355 if (!func)
1356 {
1358
1359 if (msymbol.minsym == nullptr)
1360 error (_("Execution is not within a known function."));
1361
1362 tp->control.step_range_start = msymbol.value_address ();
1363 /* The upper-bound of step_range is exclusive. In order to make PC
1364 within the range, set the step_range_end with PC + 1. */
1365 tp->control.step_range_end = pc + 1;
1366 }
1367 else
1368 {
1369 sal = find_pc_line (pc, 0);
1370
1371 tp->control.step_range_start = func->value_block ()->entry_pc ();
1372 tp->control.step_range_end = sal.end;
1373
1374 /* By setting the step_range_end based on the current pc, we are
1375 assuming that the last line table entry for any given source line
1376 will have is_stmt set to true. This is not necessarily the case,
1377 there may be additional entries for the same source line with
1378 is_stmt set false. Consider the following code:
1379
1380 for (int i = 0; i < 10; i++)
1381 loop_body ();
1382
1383 Clang-13, will generate multiple line table entries at the end of
1384 the loop all associated with the 'for' line. The first of these
1385 entries is marked is_stmt true, but the other entries are is_stmt
1386 false.
1387
1388 If we only use the values in SAL, then our stepping range may not
1389 extend to the end of the loop. The until command will reach the
1390 end of the range, find a non is_stmt instruction, and step to the
1391 next is_stmt instruction. This stopping point, however, will be
1392 inside the loop, which is not what we wanted.
1393
1394 Instead, we now check any subsequent line table entries to see if
1395 they are for the same line. If they are, and they are marked
1396 is_stmt false, then we extend the end of our stepping range.
1397
1398 When we finish this process the end of the stepping range will
1399 point either to a line with a different line number, or, will
1400 point at an address for the same line number that is marked as a
1401 statement. */
1402
1403 struct symtab_and_line final_sal
1405
1406 while (final_sal.line == sal.line && final_sal.symtab == sal.symtab
1407 && !final_sal.is_stmt)
1408 {
1409 tp->control.step_range_end = final_sal.end;
1410 final_sal = find_pc_line (final_sal.end, 0);
1411 }
1412 }
1413 tp->control.may_range_step = 1;
1414
1416
1418 delete_longjmp_breakpoint_cleanup lj_deleter (thread);
1419
1420 sm = new until_next_fsm (command_interp (), tp->global_num);
1421 tp->set_thread_fsm (std::unique_ptr<thread_fsm> (sm));
1422 lj_deleter.release ();
1423
1424 proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT);
1425}
1426
1427static void
1428until_command (const char *arg, int from_tty)
1429{
1430 int async_exec;
1431
1436
1437 /* Find out whether we must run in the background. */
1438 gdb::unique_xmalloc_ptr<char> stripped = strip_bg_char (arg, &async_exec);
1439 arg = stripped.get ();
1440
1441 prepare_execution_command (current_inferior ()->top_target (), async_exec);
1442
1443 if (arg)
1444 until_break_command (arg, from_tty, 0);
1445 else
1446 until_next_command (from_tty);
1447}
1448
1449static void
1450advance_command (const char *arg, int from_tty)
1451{
1452 int async_exec;
1453
1458
1459 if (arg == nullptr)
1460 error_no_arg (_("a location"));
1461
1462 /* Find out whether we must run in the background. */
1463 gdb::unique_xmalloc_ptr<char> stripped = strip_bg_char (arg, &async_exec);
1464 arg = stripped.get ();
1465
1466 prepare_execution_command (current_inferior ()->top_target (), async_exec);
1467
1468 until_break_command (arg, from_tty, 1);
1469}
1470
1471/* See inferior.h. */
1472
1473struct value *
1474get_return_value (struct symbol *func_symbol, struct value *function)
1475{
1476 regcache *stop_regs = get_current_regcache ();
1477 struct gdbarch *gdbarch = stop_regs->arch ();
1478 struct value *value;
1479
1480 struct type *value_type
1481 = check_typedef (func_symbol->type ()->target_type ());
1482 gdb_assert (value_type->code () != TYPE_CODE_VOID);
1483
1485 {
1486 warning (_("Function '%s' does not follow the target calling "
1487 "convention, cannot determine its returned value."),
1488 func_symbol->print_name ());
1489
1490 return nullptr;
1491 }
1492
1493 /* FIXME: 2003-09-27: When returning from a nested inferior function
1494 call, it's possible (with no help from the architecture vector)
1495 to locate and return/print a "struct return" value. This is just
1496 a more complicated case of what is already being done in the
1497 inferior function call code. In fact, when inferior function
1498 calls are made async, this will likely be made the norm. */
1499
1500 switch (gdbarch_return_value (gdbarch, function, value_type,
1501 nullptr, nullptr, nullptr))
1502 {
1507 gdbarch_return_value (gdbarch, function, value_type, stop_regs,
1508 value_contents_raw (value).data (), nullptr);
1509 break;
1511 value = nullptr;
1512 break;
1513 default:
1514 internal_error (_("bad switch"));
1515 }
1516
1517 return value;
1518}
1519
1520/* The captured function return value/type and its position in the
1521 value history. */
1522
1524{
1525 /* The captured return value. May be NULL if we weren't able to
1526 retrieve it. See get_return_value. */
1527 struct value *value;
1528
1529 /* The return type. In some cases, we'll not be able extract the
1530 return value, but we always know the type. */
1531 struct type *type;
1532
1533 /* If we captured a value, this is the value history index. */
1535};
1536
1537/* Helper for print_return_value. */
1538
1539static void
1541{
1542 if (rv->value != nullptr)
1543 {
1544 /* Print it. */
1545 uiout->text ("Value returned is ");
1546 uiout->field_fmt ("gdb-result-var", "$%d",
1548 uiout->text (" = ");
1549
1550 if (finish_print)
1551 {
1552 struct value_print_options opts;
1553 get_user_print_options (&opts);
1554
1555 string_file stb;
1556 value_print (rv->value, &stb, &opts);
1557 uiout->field_stream ("return-value", stb);
1558 }
1559 else
1560 uiout->field_string ("return-value", _("<not displayed>"),
1562 uiout->text ("\n");
1563 }
1564 else
1565 {
1566 std::string type_name = type_to_string (rv->type);
1567 uiout->text ("Value returned has type: ");
1568 uiout->field_string ("return-type", type_name);
1569 uiout->text (".");
1570 uiout->text (" Cannot determine contents\n");
1571 }
1572}
1573
1574/* Print the result of a function at the end of a 'finish' command.
1575 RV points at an object representing the captured return value/type
1576 and its position in the value history. */
1577
1578void
1580{
1581 if (rv->type == nullptr
1582 || check_typedef (rv->type)->code () == TYPE_CODE_VOID)
1583 return;
1584
1585 try
1586 {
1587 /* print_return_value_1 can throw an exception in some
1588 circumstances. We need to catch this so that we still
1589 delete the breakpoint. */
1590 print_return_value_1 (uiout, rv);
1591 }
1592 catch (const gdb_exception &ex)
1593 {
1595 }
1596}
1597
1598/* Data for the FSM that manages the finish command. */
1599
1601{
1602 /* The momentary breakpoint set at the function's return address in
1603 the caller. */
1605
1606 /* The function that we're stepping out of. */
1607 struct symbol *function = nullptr;
1608
1609 /* If the FSM finishes successfully, this stores the function's
1610 return value. */
1612
1613 /* If the current function uses the "struct return convention",
1614 this holds the address at which the value being returned will
1615 be stored, or zero if that address could not be determined or
1616 the "struct return convention" is not being used. */
1617 CORE_ADDR return_buf;
1618
1619 explicit finish_command_fsm (struct interp *cmd_interp)
1620 : thread_fsm (cmd_interp)
1621 {
1622 }
1623
1624 bool should_stop (struct thread_info *thread) override;
1625 void clean_up (struct thread_info *thread) override;
1626 struct return_value_info *return_value () override;
1628};
1629
1630/* Implementation of the 'should_stop' FSM method for the finish
1631 commands. Detects whether the thread stepped out of the function
1632 successfully, and if so, captures the function's return value and
1633 marks the FSM finished. */
1634
1635bool
1637{
1639
1640 if (function != nullptr
1642 breakpoint.get ()) != nullptr)
1643 {
1644 /* We're done. */
1645 set_finished ();
1646
1647 rv->type = function->type ()->target_type ();
1648 if (rv->type == nullptr)
1649 internal_error (_("finish_command: function has no target type"));
1650
1651 if (check_typedef (rv->type)->code () != TYPE_CODE_VOID)
1652 {
1653 struct value *func;
1654
1656
1657 if (return_buf != 0)
1658 /* Retrieve return value from the buffer where it was saved. */
1659 rv->value = value_at (rv->type, return_buf);
1660 else
1661 rv->value = get_return_value (function, func);
1662
1663 if (rv->value != nullptr)
1664 rv->value_history_index = record_latest_value (rv->value);
1665 }
1666 }
1667 else if (tp->control.stop_step)
1668 {
1669 /* Finishing from an inline frame, or reverse finishing. In
1670 either case, there's no way to retrieve the return value. */
1671 set_finished ();
1672 }
1673
1674 return true;
1675}
1676
1677/* Implementation of the 'clean_up' FSM method for the finish
1678 commands. */
1679
1680void
1682{
1683 breakpoint.reset ();
1685}
1686
1687/* Implementation of the 'return_value' FSM method for the finish
1688 commands. */
1689
1690struct return_value_info *
1692{
1693 return &return_value_info;
1694}
1695
1696/* Implementation of the 'async_reply_reason' FSM method for the
1697 finish commands. */
1698
1701{
1704 else
1706}
1707
1708/* finish_backward -- helper function for finish_command. */
1709
1710static void
1712{
1713 struct symtab_and_line sal;
1714 struct thread_info *tp = inferior_thread ();
1715 CORE_ADDR pc;
1716 CORE_ADDR func_addr;
1717
1719
1720 if (find_pc_partial_function (pc, nullptr, &func_addr, nullptr) == 0)
1721 error (_("Cannot find bounds of current function"));
1722
1723 sal = find_pc_line (func_addr, 0);
1724
1725 tp->control.proceed_to_finish = 1;
1726 /* Special case: if we're sitting at the function entry point,
1727 then all we need to do is take a reverse singlestep. We
1728 don't need to set a breakpoint, and indeed it would do us
1729 no good to do so.
1730
1731 Note that this can only happen at frame #0, since there's
1732 no way that a function up the stack can have a return address
1733 that's equal to its entry point. */
1734
1735 if (sal.pc != pc)
1736 {
1737 frame_info_ptr frame = get_selected_frame (nullptr);
1738 struct gdbarch *gdbarch = get_frame_arch (frame);
1739
1740 /* Set a step-resume at the function's entry point. Once that's
1741 hit, we'll do one more step backwards. */
1742 symtab_and_line sr_sal;
1743 sr_sal.pc = sal.pc;
1744 sr_sal.pspace = get_frame_program_space (frame);
1746 sr_sal, null_frame_id);
1747
1748 proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT);
1749 }
1750 else
1751 {
1752 /* We're almost there -- we just need to back up by one more
1753 single-step. */
1755 proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT);
1756 }
1757}
1758
1759/* finish_forward -- helper function for finish_command. FRAME is the
1760 frame that called the function we're about to step out of. */
1761
1762static void
1764{
1765 struct frame_id frame_id = get_frame_id (frame);
1766 struct gdbarch *gdbarch = get_frame_arch (frame);
1767 struct symtab_and_line sal;
1768 struct thread_info *tp = inferior_thread ();
1769
1770 sal = find_pc_line (get_frame_pc (frame), 0);
1771 sal.pc = get_frame_pc (frame);
1772
1774 get_stack_frame_id (frame),
1775 bp_finish);
1776
1777 /* set_momentary_breakpoint invalidates FRAME. */
1778 frame = nullptr;
1779
1781
1782 /* We want to print return value, please... */
1783 tp->control.proceed_to_finish = 1;
1784
1785 proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT);
1786}
1787
1788/* Skip frames for "finish". */
1789
1790static frame_info_ptr
1792{
1793 frame_info_ptr start;
1794
1795 do
1796 {
1797 start = frame;
1798
1799 frame = skip_tailcall_frames (frame);
1800 if (frame == nullptr)
1801 break;
1802
1803 frame = skip_unwritable_frames (frame);
1804 if (frame == nullptr)
1805 break;
1806 }
1807 while (start != frame);
1808
1809 return frame;
1810}
1811
1812/* "finish": Set a temporary breakpoint at the place the selected
1813 frame will return to, then continue. */
1814
1815static void
1816finish_command (const char *arg, int from_tty)
1817{
1818 frame_info_ptr frame;
1819 int async_exec;
1820 struct finish_command_fsm *sm;
1821 struct thread_info *tp;
1822
1827
1828 /* Find out whether we must run in the background. */
1829 gdb::unique_xmalloc_ptr<char> stripped = strip_bg_char (arg, &async_exec);
1830 arg = stripped.get ();
1831
1832 prepare_execution_command (current_inferior ()->top_target (), async_exec);
1833
1834 if (arg)
1835 error (_("The \"finish\" command does not take any arguments."));
1836
1837 frame = get_prev_frame (get_selected_frame (_("No selected frame.")));
1838 if (frame == 0)
1839 error (_("\"finish\" not meaningful in the outermost frame."));
1840 frame.prepare_reinflate ();
1841
1843
1844 tp = inferior_thread ();
1845
1846 sm = new finish_command_fsm (command_interp ());
1847
1848 tp->set_thread_fsm (std::unique_ptr<thread_fsm> (sm));
1849
1850 /* Finishing from an inline frame is completely different. We don't
1851 try to show the "return value" - no way to locate it. */
1852 if (get_frame_type (get_selected_frame (_("No selected frame.")))
1853 == INLINE_FRAME)
1854 {
1855 /* Claim we are stepping in the calling frame. An empty step
1856 range means that we will stop once we aren't in a function
1857 called by that frame. We don't use the magic "1" value for
1858 step_range_end, because then infrun will think this is nexti,
1859 and not step over the rest of this inlined function call. */
1860 set_step_info (tp, frame, {});
1864
1865 /* Print info on the selected frame, including level number but not
1866 source. */
1867 if (from_tty)
1868 {
1869 gdb_printf (_("Run till exit from "));
1871 }
1872
1873 proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT);
1874 return;
1875 }
1876
1877 /* Find the function we will return from. */
1878 frame_info_ptr callee_frame = get_selected_frame (nullptr);
1879 sm->function = find_pc_function (get_frame_pc (callee_frame));
1880 sm->return_buf = 0; /* Initialize buffer address is not available. */
1881
1882 /* Determine the return convention. If it is RETURN_VALUE_STRUCT_CONVENTION,
1883 attempt to determine the address of the return buffer. */
1884 if (sm->function != nullptr)
1885 {
1886 enum return_value_convention return_value;
1887 struct gdbarch *gdbarch = get_frame_arch (callee_frame);
1888
1889 struct type * val_type
1890 = check_typedef (sm->function->type ()->target_type ());
1891
1892 return_value = gdbarch_return_value (gdbarch,
1893 read_var_value (sm->function, nullptr,
1894 callee_frame),
1895 val_type, nullptr, nullptr, nullptr);
1896
1897 if (return_value == RETURN_VALUE_STRUCT_CONVENTION
1898 && val_type->code () != TYPE_CODE_VOID)
1900 callee_frame);
1901 }
1902
1903 /* Print info on the selected frame, including level number but not
1904 source. */
1905 if (from_tty)
1906 {
1908 gdb_printf (_("Run back to call of "));
1909 else
1910 {
1911 if (sm->function != nullptr && TYPE_NO_RETURN (sm->function->type ())
1912 && !query (_("warning: Function %s does not return normally.\n"
1913 "Try to finish anyway? "),
1914 sm->function->print_name ()))
1915 error (_("Not confirmed."));
1916 gdb_printf (_("Run till exit from "));
1917 }
1918
1919 print_stack_frame (callee_frame, 1, LOCATION, 0);
1920 }
1921 frame.reinflate ();
1922
1924 finish_backward (sm);
1925 else
1926 {
1927 frame = skip_finish_frames (frame);
1928
1929 if (frame == nullptr)
1930 error (_("Cannot find the caller frame."));
1931
1932 finish_forward (sm, frame);
1933 }
1934}
1935
1936
1937static void
1938info_program_command (const char *args, int from_tty)
1939{
1940 bpstat *bs;
1941 int num, stat;
1942 ptid_t ptid;
1943 process_stratum_target *proc_target;
1944
1945 if (!target_has_execution ())
1946 {
1947 gdb_printf (_("The program being debugged is not being run.\n"));
1948 return;
1949 }
1950
1951 if (non_stop)
1952 {
1953 ptid = inferior_ptid;
1954 proc_target = current_inferior ()->process_target ();
1955 }
1956 else
1957 get_last_target_status (&proc_target, &ptid, nullptr);
1958
1959 if (ptid == null_ptid || ptid == minus_one_ptid)
1960 error (_("No selected thread."));
1961
1962 thread_info *tp = find_thread_ptid (proc_target, ptid);
1963
1964 if (tp->state == THREAD_EXITED)
1965 error (_("Invalid selected thread."));
1966 else if (tp->state == THREAD_RUNNING)
1967 error (_("Selected thread is running."));
1968
1969 bs = tp->control.stop_bpstat;
1970 stat = bpstat_num (&bs, &num);
1971
1973 gdb_printf (_("Program stopped at %s.\n"),
1974 paddress (target_gdbarch (), tp->stop_pc ()));
1975 if (tp->control.stop_step)
1976 gdb_printf (_("It stopped after being stepped.\n"));
1977 else if (stat != 0)
1978 {
1979 /* There may be several breakpoints in the same place, so this
1980 isn't as strange as it seems. */
1981 while (stat != 0)
1982 {
1983 if (stat < 0)
1984 {
1985 gdb_printf (_("It stopped at a breakpoint "
1986 "that has since been deleted.\n"));
1987 }
1988 else
1989 gdb_printf (_("It stopped at breakpoint %d.\n"), num);
1990 stat = bpstat_num (&bs, &num);
1991 }
1992 }
1993 else if (tp->stop_signal () != GDB_SIGNAL_0)
1994 {
1995 gdb_printf (_("It stopped with signal %s, %s.\n"),
1996 gdb_signal_to_name (tp->stop_signal ()),
1997 gdb_signal_to_string (tp->stop_signal ()));
1998 }
1999
2000 if (from_tty)
2001 {
2002 gdb_printf (_("Type \"info stack\" or \"info "
2003 "registers\" for more information.\n"));
2004 }
2005}
2006
2007static void
2008environment_info (const char *var, int from_tty)
2009{
2010 if (var)
2011 {
2012 const char *val = current_inferior ()->environment.get (var);
2013
2014 if (val)
2015 {
2016 gdb_puts (var);
2017 gdb_puts (" = ");
2018 gdb_puts (val);
2019 gdb_puts ("\n");
2020 }
2021 else
2022 {
2023 gdb_puts ("Environment variable \"");
2024 gdb_puts (var);
2025 gdb_puts ("\" not defined.\n");
2026 }
2027 }
2028 else
2029 {
2030 char **envp = current_inferior ()->environment.envp ();
2031
2032 for (int idx = 0; envp[idx] != nullptr; ++idx)
2033 {
2034 gdb_puts (envp[idx]);
2035 gdb_puts ("\n");
2036 }
2037 }
2038}
2039
2040static void
2041set_environment_command (const char *arg, int from_tty)
2042{
2043 const char *p, *val;
2044 int nullset = 0;
2045
2046 if (arg == 0)
2047 error_no_arg (_("environment variable and value"));
2048
2049 /* Find separation between variable name and value. */
2050 p = (char *) strchr (arg, '=');
2051 val = (char *) strchr (arg, ' ');
2052
2053 if (p != 0 && val != 0)
2054 {
2055 /* We have both a space and an equals. If the space is before the
2056 equals, walk forward over the spaces til we see a nonspace
2057 (possibly the equals). */
2058 if (p > val)
2059 while (*val == ' ')
2060 val++;
2061
2062 /* Now if the = is after the char following the spaces,
2063 take the char following the spaces. */
2064 if (p > val)
2065 p = val - 1;
2066 }
2067 else if (val != 0 && p == 0)
2068 p = val;
2069
2070 if (p == arg)
2071 error_no_arg (_("environment variable to set"));
2072
2073 if (p == 0 || p[1] == 0)
2074 {
2075 nullset = 1;
2076 if (p == 0)
2077 p = arg + strlen (arg); /* So that savestring below will work. */
2078 }
2079 else
2080 {
2081 /* Not setting variable value to null. */
2082 val = p + 1;
2083 while (*val == ' ' || *val == '\t')
2084 val++;
2085 }
2086
2087 while (p != arg && (p[-1] == ' ' || p[-1] == '\t'))
2088 p--;
2089
2090 std::string var (arg, p - arg);
2091 if (nullset)
2092 {
2093 gdb_printf (_("Setting environment variable "
2094 "\"%s\" to null value.\n"),
2095 var.c_str ());
2096 current_inferior ()->environment.set (var.c_str (), "");
2097 }
2098 else
2099 current_inferior ()->environment.set (var.c_str (), val);
2100}
2101
2102static void
2103unset_environment_command (const char *var, int from_tty)
2104{
2105 if (var == 0)
2106 {
2107 /* If there is no argument, delete all environment variables.
2108 Ask for confirmation if reading from the terminal. */
2109 if (!from_tty || query (_("Delete all environment variables? ")))
2110 current_inferior ()->environment.clear ();
2111 }
2112 else
2113 current_inferior ()->environment.unset (var);
2114}
2115
2116/* Handle the execution path (PATH variable). */
2117
2118static const char path_var_name[] = "PATH";
2119
2120static void
2121path_info (const char *args, int from_tty)
2122{
2123 gdb_puts ("Executable and object file path: ");
2124 gdb_puts (current_inferior ()->environment.get (path_var_name));
2125 gdb_puts ("\n");
2126}
2127
2128/* Add zero or more directories to the front of the execution path. */
2129
2130static void
2131path_command (const char *dirname, int from_tty)
2132{
2133 const char *env;
2134
2135 dont_repeat ();
2137 /* Can be null if path is not set. */
2138 if (!env)
2139 env = "";
2140 std::string exec_path = env;
2141 mod_path (dirname, exec_path);
2142 current_inferior ()->environment.set (path_var_name, exec_path.c_str ());
2143 if (from_tty)
2144 path_info (nullptr, from_tty);
2145}
2146
2147
2148static void
2149pad_to_column (string_file &stream, int col)
2150{
2151 /* At least one space must be printed to separate columns. */
2152 stream.putc (' ');
2153 const int size = stream.size ();
2154 if (size < col)
2155 stream.puts (n_spaces (col - size));
2156}
2157
2158/* Print out the register NAME with value VAL, to FILE, in the default
2159 fashion. */
2160
2161static void
2163 const char *name,
2164 struct value *val)
2165{
2166 struct type *regtype = value_type (val);
2167 int print_raw_format;
2168 string_file format_stream;
2169 enum tab_stops
2170 {
2171 value_column_1 = 15,
2172 /* Give enough room for "0x", 16 hex digits and two spaces in
2173 preceding column. */
2174 value_column_2 = value_column_1 + 2 + 16 + 2,
2175 };
2176
2177 format_stream.puts (name);
2178 pad_to_column (format_stream, value_column_1);
2179
2180 print_raw_format = (value_entirely_available (val)
2181 && !value_optimized_out (val));
2182
2183 /* If virtual format is floating, print it that way, and in raw
2184 hex. */
2185 if (regtype->code () == TYPE_CODE_FLT
2186 || regtype->code () == TYPE_CODE_DECFLOAT)
2187 {
2188 struct value_print_options opts;
2189 const gdb_byte *valaddr = value_contents_for_printing (val).data ();
2190 enum bfd_endian byte_order = type_byte_order (regtype);
2191
2192 get_user_print_options (&opts);
2193 opts.deref_ref = 1;
2194
2195 common_val_print (val, &format_stream, 0, &opts, current_language);
2196
2197 if (print_raw_format)
2198 {
2199 pad_to_column (format_stream, value_column_2);
2200 format_stream.puts ("(raw ");
2201 print_hex_chars (&format_stream, valaddr, regtype->length (),
2202 byte_order, true);
2203 format_stream.putc (')');
2204 }
2205 }
2206 else
2207 {
2208 struct value_print_options opts;
2209
2210 /* Print the register in hex. */
2211 get_formatted_print_options (&opts, 'x');
2212 opts.deref_ref = 1;
2213 common_val_print (val, &format_stream, 0, &opts, current_language);
2214 /* If not a vector register, print it also according to its
2215 natural format. */
2216 if (print_raw_format && regtype->is_vector () == 0)
2217 {
2218 pad_to_column (format_stream, value_column_2);
2219 get_user_print_options (&opts);
2220 opts.deref_ref = 1;
2221 common_val_print (val, &format_stream, 0, &opts, current_language);
2222 }
2223 }
2224
2225 gdb_puts (format_stream.c_str (), file);
2226 gdb_printf (file, "\n");
2227}
2228
2229/* Print out the machine register regnum. If regnum is -1, print all
2230 registers (print_all == 1) or all non-float and non-vector
2231 registers (print_all == 0).
2232
2233 For most machines, having all_registers_info() print the
2234 register(s) one per line is good enough. If a different format is
2235 required, (eg, for MIPS or Pyramid 90x, which both have lots of
2236 regs), or there is an existing convention for showing all the
2237 registers, define the architecture method PRINT_REGISTERS_INFO to
2238 provide that format. */
2239
2240void
2242 struct ui_file *file,
2243 frame_info_ptr frame,
2244 int regnum, int print_all)
2245{
2246 int i;
2247 const int numregs = gdbarch_num_cooked_regs (gdbarch);
2248
2249 for (i = 0; i < numregs; i++)
2250 {
2251 /* Decide between printing all regs, non-float / vector regs, or
2252 specific reg. */
2253 if (regnum == -1)
2254 {
2255 if (print_all)
2256 {
2258 continue;
2259 }
2260 else
2261 {
2263 continue;
2264 }
2265 }
2266 else
2267 {
2268 if (i != regnum)
2269 continue;
2270 }
2271
2272 /* If the register name is empty, it is undefined for this
2273 processor, so don't display anything. */
2274 if (*(gdbarch_register_name (gdbarch, i)) == '\0')
2275 continue;
2276
2279 value_of_register (i, frame));
2280 }
2281}
2282
2283void
2284registers_info (const char *addr_exp, int fpregs)
2285{
2286 frame_info_ptr frame;
2287 struct gdbarch *gdbarch;
2288
2289 if (!target_has_registers ())
2290 error (_("The program has no registers now."));
2291 frame = get_selected_frame (nullptr);
2292 gdbarch = get_frame_arch (frame);
2293
2294 if (!addr_exp)
2295 {
2297 frame, -1, fpregs);
2298 return;
2299 }
2300
2301 while (*addr_exp != '\0')
2302 {
2303 const char *start;
2304 const char *end;
2305
2306 /* Skip leading white space. */
2307 addr_exp = skip_spaces (addr_exp);
2308
2309 /* Discard any leading ``$''. Check that there is something
2310 resembling a register following it. */
2311 if (addr_exp[0] == '$')
2312 addr_exp++;
2313 if (isspace ((*addr_exp)) || (*addr_exp) == '\0')
2314 error (_("Missing register name"));
2315
2316 /* Find the start/end of this register name/num/group. */
2317 start = addr_exp;
2318 while ((*addr_exp) != '\0' && !isspace ((*addr_exp)))
2319 addr_exp++;
2320 end = addr_exp;
2321
2322 /* Figure out what we've found and display it. */
2323
2324 /* A register name? */
2325 {
2326 int regnum = user_reg_map_name_to_regnum (gdbarch, start, end - start);
2327
2328 if (regnum >= 0)
2329 {
2330 /* User registers lie completely outside of the range of
2331 normal registers. Catch them early so that the target
2332 never sees them. */
2334 {
2335 struct value *regval = value_of_user_reg (regnum, frame);
2336 const char *regname = user_reg_map_regnum_to_name (gdbarch,
2337 regnum);
2338
2339 /* Print in the same fashion
2340 gdbarch_print_registers_info's default
2341 implementation prints. */
2343 regname,
2344 regval);
2345 }
2346 else
2348 frame, regnum, fpregs);
2349 continue;
2350 }
2351 }
2352
2353 /* A register group? */
2354 {
2355 const struct reggroup *group = nullptr;
2356 for (const struct reggroup *g : gdbarch_reggroups (gdbarch))
2357 {
2358 /* Don't bother with a length check. Should the user
2359 enter a short register group name, go with the first
2360 group that matches. */
2361 if (strncmp (start, g->name (), end - start) == 0)
2362 {
2363 group = g;
2364 break;
2365 }
2366 }
2367 if (group != nullptr)
2368 {
2369 int regnum;
2370
2371 for (regnum = 0;
2373 regnum++)
2374 {
2377 gdb_stdout, frame,
2378 regnum, fpregs);
2379 }
2380 continue;
2381 }
2382 }
2383
2384 /* Nothing matched. */
2385 error (_("Invalid register `%.*s'"), (int) (end - start), start);
2386 }
2387}
2388
2389static void
2390info_all_registers_command (const char *addr_exp, int from_tty)
2391{
2392 registers_info (addr_exp, 1);
2393}
2394
2395static void
2396info_registers_command (const char *addr_exp, int from_tty)
2397{
2398 registers_info (addr_exp, 0);
2399}
2400
2401static void
2403 frame_info_ptr frame, const char *args)
2404{
2405 struct gdbarch *gdbarch = get_frame_arch (frame);
2406
2408 gdbarch_print_vector_info (gdbarch, file, frame, args);
2409 else
2410 {
2411 int regnum;
2412 int printed_something = 0;
2413
2415 {
2417 {
2418 printed_something = 1;
2419 gdbarch_print_registers_info (gdbarch, file, frame, regnum, 1);
2420 }
2421 }
2422 if (!printed_something)
2423 gdb_printf (file, "No vector information\n");
2424 }
2425}
2426
2427static void
2428info_vector_command (const char *args, int from_tty)
2429{
2430 if (!target_has_registers ())
2431 error (_("The program has no registers now."));
2432
2434}
2435
2436/* Kill the inferior process. Make us have no inferior. */
2437
2438static void
2439kill_command (const char *arg, int from_tty)
2440{
2441 /* FIXME: This should not really be inferior_ptid (or target_has_execution).
2442 It should be a distinct flag that indicates that a target is active, cuz
2443 some targets don't have processes! */
2444
2445 if (inferior_ptid == null_ptid)
2446 error (_("The program is not being run."));
2447 if (!query (_("Kill the program being debugged? ")))
2448 error (_("Not confirmed."));
2449
2450 int pid = current_inferior ()->pid;
2451 /* Save the pid as a string before killing the inferior, since that
2452 may unpush the current target, and we need the string after. */
2453 std::string pid_str = target_pid_to_str (ptid_t (pid));
2454 int infnum = current_inferior ()->num;
2455
2456 target_kill ();
2457 bfd_cache_close_all ();
2458
2460 gdb_printf (_("[Inferior %d (%s) killed]\n"),
2461 infnum, pid_str.c_str ());
2462}
2463
2464/* Used in `attach&' command. Proceed threads of inferior INF iff
2465 they stopped due to debugger request, and when they did, they
2466 reported a clean stop (GDB_SIGNAL_0). Do not proceed threads that
2467 have been explicitly been told to stop. */
2468
2469static void
2471{
2472 /* Don't error out if the current thread is running, because
2473 there may be other stopped threads. */
2474
2475 /* Backup current thread and selected frame. */
2476 scoped_restore_current_thread restore_thread;
2477
2478 for (thread_info *thread : inf->non_exited_threads ())
2479 if (!thread->executing ()
2480 && !thread->stop_requested
2481 && thread->stop_signal () == GDB_SIGNAL_0)
2482 {
2483 switch_to_thread (thread);
2485 proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT);
2486 }
2487}
2488
2489/* See inferior.h. */
2490
2491void
2492setup_inferior (int from_tty)
2493{
2494 struct inferior *inferior;
2495
2497 inferior->needs_setup = false;
2498
2499 /* If no exec file is yet known, try to determine it from the
2500 process itself. */
2501 if (get_exec_file (0) == nullptr)
2502 exec_file_locate_attach (inferior_ptid.pid (), 1, from_tty);
2503 else
2504 {
2506 reread_symbols (from_tty);
2507 }
2508
2509 /* Take any necessary post-attaching actions for this platform. */
2511
2512 post_create_inferior (from_tty);
2513}
2514
2515/* What to do after the first program stops after attaching. */
2517{
2518 /* Do nothing. Leaves threads as they are. */
2520
2521 /* Re-resume threads that are marked running. */
2523
2524 /* Stop all threads. */
2526};
2527
2528/* Called after we've attached to a process and we've seen it stop for
2529 the first time. Resume, stop, or don't touch the threads according
2530 to MODE. */
2531
2532static void
2534{
2535 struct inferior *inferior;
2536
2539
2540 if (inferior->needs_setup)
2541 setup_inferior (from_tty);
2542
2543 if (mode == ATTACH_POST_WAIT_RESUME)
2544 {
2545 /* The user requested an `attach&', so be sure to leave threads
2546 that didn't get a signal running. */
2547
2548 /* Immediately resume all suspended threads of this inferior,
2549 and this inferior only. This should have no effect on
2550 already running threads. If a thread has been stopped with a
2551 signal, leave it be. */
2552 if (non_stop)
2554 else
2555 {
2556 if (inferior_thread ()->stop_signal () == GDB_SIGNAL_0)
2557 {
2559 proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT);
2560 }
2561 }
2562 }
2563 else if (mode == ATTACH_POST_WAIT_STOP)
2564 {
2565 /* The user requested a plain `attach', so be sure to leave
2566 the inferior stopped. */
2567
2568 /* At least the current thread is already stopped. */
2569
2570 /* In all-stop, by definition, all threads have to be already
2571 stopped at this point. In non-stop, however, although the
2572 selected thread is stopped, others may still be executing.
2573 Be sure to explicitly stop all threads of the process. This
2574 should have no effect on already stopped threads. */
2575 if (non_stop)
2576 target_stop (ptid_t (inferior->pid));
2577 else if (target_is_non_stop_p ())
2578 {
2579 struct thread_info *lowest = inferior_thread ();
2580
2581 stop_all_threads ("attaching");
2582
2583 /* It's not defined which thread will report the attach
2584 stop. For consistency, always select the thread with
2585 lowest GDB number, which should be the main thread, if it
2586 still exists. */
2587 for (thread_info *thread : current_inferior ()->non_exited_threads ())
2588 if (thread->inf->num < lowest->inf->num
2589 || thread->per_inf_num < lowest->per_inf_num)
2590 lowest = thread;
2591
2592 switch_to_thread (lowest);
2593 }
2594
2595 /* Tell the user/frontend where we're stopped. */
2596 normal_stop ();
2599 }
2600}
2601
2602/* "attach" command entry point. Takes a program started up outside
2603 of gdb and ``attaches'' to it. This stops it cold in its tracks
2604 and allows us to start debugging it. */
2605
2606void
2607attach_command (const char *args, int from_tty)
2608{
2609 int async_exec;
2610 struct target_ops *attach_target;
2611 struct inferior *inferior = current_inferior ();
2612 enum attach_post_wait_mode mode;
2613
2614 dont_repeat (); /* Not for the faint of heart */
2615
2616 scoped_disable_commit_resumed disable_commit_resumed ("attaching");
2617
2619 /* Don't complain if all processes share the same symbol
2620 space. */
2621 ;
2622 else if (target_has_execution ())
2623 {
2624 if (query (_("A program is being debugged already. Kill it? ")))
2625 target_kill ();
2626 else
2627 error (_("Not killed."));
2628 }
2629
2630 /* Clean up any leftovers from other runs. Some other things from
2631 this function should probably be moved into target_pre_inferior. */
2632 target_pre_inferior (from_tty);
2633
2634 gdb::unique_xmalloc_ptr<char> stripped = strip_bg_char (args, &async_exec);
2635 args = stripped.get ();
2636
2637 attach_target = find_attach_target ();
2638
2639 prepare_execution_command (attach_target, async_exec);
2640
2641 if (non_stop && !attach_target->supports_non_stop ())
2642 error (_("Cannot attach to this target in non-stop mode"));
2643
2644 attach_target->attach (args, from_tty);
2645 /* to_attach should push the target, so after this point we
2646 shouldn't refer to attach_target again. */
2647 attach_target = nullptr;
2648
2649 infrun_debug_show_threads ("immediately after attach",
2651
2652 /* Enable async mode if it is supported by the target. */
2653 if (target_can_async_p ())
2654 target_async (true);
2655
2656 /* Set up the "saved terminal modes" of the inferior
2657 based on what modes we are starting it with. */
2659
2660 /* Install inferior's terminal modes. This may look like a no-op,
2661 as we've just saved them above, however, this does more than
2662 restore terminal settings:
2663
2664 - installs a SIGINT handler that forwards SIGINT to the inferior.
2665 Otherwise a Ctrl-C pressed just while waiting for the initial
2666 stop would end up as a spurious Quit.
2667
2668 - removes stdin from the event loop, which we need if attaching
2669 in the foreground, otherwise on targets that report an initial
2670 stop on attach (which are most) we'd process input/commands
2671 while we're in the event loop waiting for that stop. That is,
2672 before the attach continuation runs and the command is really
2673 finished. */
2675
2676 /* Set up execution context to know that we should return from
2677 wait_for_inferior as soon as the target reports a stop. */
2679
2680 inferior->needs_setup = true;
2681
2682 if (target_is_non_stop_p ())
2683 {
2684 /* If we find that the current thread isn't stopped, explicitly
2685 do so now, because we're going to install breakpoints and
2686 poke at memory. */
2687
2688 if (async_exec)
2689 /* The user requested an `attach&'; stop just one thread. */
2691 else
2692 /* The user requested an `attach', so stop all threads of this
2693 inferior. */
2694 target_stop (ptid_t (inferior_ptid.pid ()));
2695 }
2696
2697 /* Check for exec file mismatch, and let the user solve it. */
2698 validate_exec_file (from_tty);
2699
2700 mode = async_exec ? ATTACH_POST_WAIT_RESUME : ATTACH_POST_WAIT_STOP;
2701
2702 /* Some system don't generate traps when attaching to inferior.
2703 E.g. Mach 3 or GNU hurd. */
2704 if (!target_attach_no_wait ())
2705 {
2706 /* Careful here. See comments in inferior.h. Basically some
2707 OSes don't ignore SIGSTOPs on continue requests anymore. We
2708 need a way for handle_inferior_event to reset the stop_signal
2709 variable after an attach, and this is what
2710 STOP_QUIETLY_NO_SIGSTOP is for. */
2712
2713 /* Wait for stop. */
2714 inferior->add_continuation ([=] ()
2715 {
2716 attach_post_wait (from_tty, mode);
2717 });
2718
2719 /* Let infrun consider waiting for events out of this
2720 target. */
2722
2723 if (!target_is_async_p ())
2725 return;
2726 }
2727 else
2728 attach_post_wait (from_tty, mode);
2729
2730 disable_commit_resumed.reset_and_commit ();
2731}
2732
2733/* We had just found out that the target was already attached to an
2734 inferior. PTID points at a thread of this new inferior, that is
2735 the most likely to be stopped right now, but not necessarily so.
2736 The new inferior is assumed to be already added to the inferior
2737 list at this point. If LEAVE_RUNNING, then leave the threads of
2738 this inferior running, except those we've explicitly seen reported
2739 as stopped. */
2740
2741void
2742notice_new_inferior (thread_info *thr, bool leave_running, int from_tty)
2743{
2744 enum attach_post_wait_mode mode
2746
2747 gdb::optional<scoped_restore_current_thread> restore_thread;
2748
2749 if (inferior_ptid != null_ptid)
2750 restore_thread.emplace ();
2751
2752 /* Avoid reading registers -- we haven't fetched the target
2753 description yet. */
2755
2756 /* When we "notice" a new inferior we need to do all the things we
2757 would normally do if we had just attached to it. */
2758
2759 if (thr->executing ())
2760 {
2761 struct inferior *inferior = current_inferior ();
2762
2763 /* We're going to install breakpoints, and poke at memory,
2764 ensure that the inferior is stopped for a moment while we do
2765 that. */
2767
2769
2770 /* Wait for stop before proceeding. */
2771 inferior->add_continuation ([=] ()
2772 {
2773 attach_post_wait (from_tty, mode);
2774 });
2775
2776 return;
2777 }
2778
2779 attach_post_wait (from_tty, mode);
2780}
2781
2782/*
2783 * detach_command --
2784 * takes a program previously attached to and detaches it.
2785 * The program resumes execution and will no longer stop
2786 * on signals, etc. We better not have left any breakpoints
2787 * in the program or it'll die when it hits one. For this
2788 * to work, it may be necessary for the process to have been
2789 * previously attached. It *might* work if the program was
2790 * started via the normal ptrace (PTRACE_TRACEME).
2791 */
2792
2793void
2794detach_command (const char *args, int from_tty)
2795{
2796 dont_repeat (); /* Not for the faint of heart. */
2797
2798 if (inferior_ptid == null_ptid)
2799 error (_("The program is not being run."));
2800
2801 scoped_disable_commit_resumed disable_commit_resumed ("detaching");
2802
2803 query_if_trace_running (from_tty);
2804
2806
2807 /* Hold a strong reference to the target while (maybe)
2808 detaching the parent. Otherwise detaching could close the
2809 target. */
2810 auto target_ref
2811 = target_ops_ref::new_reference (current_inferior ()->process_target ());
2812
2813 /* Save this before detaching, since detaching may unpush the
2814 process_stratum target. */
2815 bool was_non_stop_p = target_is_non_stop_p ();
2816
2817 target_detach (current_inferior (), from_tty);
2818
2819 /* The current inferior process was just detached successfully. Get
2820 rid of breakpoints that no longer make sense. Note we don't do
2821 this within target_detach because that is also used when
2822 following child forks, and in that case we will want to transfer
2823 breakpoints to the child, not delete them. */
2825
2826 /* If the solist is global across inferiors, don't clear it when we
2827 detach from a single inferior. */
2829 no_shared_libraries (nullptr, from_tty);
2830
2833
2834 if (!was_non_stop_p)
2836
2837 disable_commit_resumed.reset_and_commit ();
2838}
2839
2840/* Disconnect from the current target without resuming it (leaving it
2841 waiting for a debugger).
2842
2843 We'd better not have left any breakpoints in the program or the
2844 next debugger will get confused. Currently only supported for some
2845 remote targets, since the normal attach mechanisms don't work on
2846 stopped processes on some native platforms (e.g. GNU/Linux). */
2847
2848static void
2849disconnect_command (const char *args, int from_tty)
2850{
2851 dont_repeat (); /* Not for the faint of heart. */
2852 query_if_trace_running (from_tty);
2854 target_disconnect (args, from_tty);
2855 no_shared_libraries (nullptr, from_tty);
2859}
2860
2861/* Stop PTID in the current target, and tag the PTID threads as having
2862 been explicitly requested to stop. PTID can be a thread, a
2863 process, or minus_one_ptid, meaning all threads of all inferiors of
2864 the current target. */
2865
2866static void
2868{
2869 target_stop (ptid);
2870
2871 /* Tag the thread as having been explicitly requested to stop, so
2872 other parts of gdb know not to resume this thread automatically,
2873 if it was stopped due to an internal event. Limit this to
2874 non-stop mode, as when debugging a multi-threaded application in
2875 all-stop mode, we will only get one stop event --- it's undefined
2876 which thread will report the event. */
2878 ptid, 1);
2879}
2880
2881/* See inferior.h. */
2882
2883void
2885{
2886 scoped_disable_commit_resumed disable_commit_resumed ("interrupting");
2887
2888 if (non_stop)
2889 {
2890 if (all_threads)
2891 {
2892 scoped_restore_current_thread restore_thread;
2893
2894 for (inferior *inf : all_inferiors ())
2895 {
2897 stop_current_target_threads_ns (minus_one_ptid);
2898 }
2899 }
2900 else
2902 }
2903 else
2905
2906 disable_commit_resumed.reset_and_commit ();
2907}
2908
2909/* interrupt [-a]
2910 Stop the execution of the target while running in async mode, in
2911 the background. In all-stop, stop the whole process. In non-stop
2912 mode, stop the current thread only by default, or stop all threads
2913 if the `-a' switch is used. */
2914
2915static void
2916interrupt_command (const char *args, int from_tty)
2917{
2918 if (target_can_async_p ())
2919 {
2920 int all_threads = 0;
2921
2922 dont_repeat (); /* Not for the faint of heart. */
2923
2924 if (args != nullptr
2925 && startswith (args, "-a"))
2926 all_threads = 1;
2927
2929 }
2930}
2931
2932/* See inferior.h. */
2933
2934void
2936 frame_info_ptr frame, const char *args)
2937{
2938 int regnum;
2939 int printed_something = 0;
2940
2942 {
2944 {
2945 printed_something = 1;
2946 gdbarch_print_registers_info (gdbarch, file, frame, regnum, 1);
2947 }
2948 }
2949 if (!printed_something)
2950 gdb_printf (file, "No floating-point info "
2951 "available for this processor.\n");
2952}
2953
2954static void
2955info_float_command (const char *args, int from_tty)
2956{
2957 frame_info_ptr frame;
2958
2959 if (!target_has_registers ())
2960 error (_("The program has no registers now."));
2961
2962 frame = get_selected_frame (nullptr);
2964}
2965
2966/* Implement `info proc' family of commands. */
2967
2968static void
2969info_proc_cmd_1 (const char *args, enum info_proc_what what, int from_tty)
2970{
2971 struct gdbarch *gdbarch = get_current_arch ();
2972
2973 if (!target_info_proc (args, what))
2974 {
2976 gdbarch_info_proc (gdbarch, args, what);
2977 else
2978 error (_("Not supported on this target."));
2979 }
2980}
2981
2982/* Implement `info proc' when given without any further parameters. */
2983
2984static void
2985info_proc_cmd (const char *args, int from_tty)
2986{
2987 info_proc_cmd_1 (args, IP_MINIMAL, from_tty);
2988}
2989
2990/* Implement `info proc mappings'. */
2991
2992static void
2993info_proc_cmd_mappings (const char *args, int from_tty)
2994{
2995 info_proc_cmd_1 (args, IP_MAPPINGS, from_tty);
2996}
2997
2998/* Implement `info proc stat'. */
2999
3000static void
3001info_proc_cmd_stat (const char *args, int from_tty)
3002{
3003 info_proc_cmd_1 (args, IP_STAT, from_tty);
3004}
3005
3006/* Implement `info proc status'. */
3007
3008static void
3009info_proc_cmd_status (const char *args, int from_tty)
3010{
3011 info_proc_cmd_1 (args, IP_STATUS, from_tty);
3012}
3013
3014/* Implement `info proc cwd'. */
3015
3016static void
3017info_proc_cmd_cwd (const char *args, int from_tty)
3018{
3019 info_proc_cmd_1 (args, IP_CWD, from_tty);
3020}
3021
3022/* Implement `info proc cmdline'. */
3023
3024static void
3025info_proc_cmd_cmdline (const char *args, int from_tty)
3026{
3027 info_proc_cmd_1 (args, IP_CMDLINE, from_tty);
3028}
3029
3030/* Implement `info proc exe'. */
3031
3032static void
3033info_proc_cmd_exe (const char *args, int from_tty)
3034{
3035 info_proc_cmd_1 (args, IP_EXE, from_tty);
3036}
3037
3038/* Implement `info proc files'. */
3039
3040static void
3041info_proc_cmd_files (const char *args, int from_tty)
3042{
3043 info_proc_cmd_1 (args, IP_FILES, from_tty);
3044}
3045
3046/* Implement `info proc all'. */
3047
3048static void
3049info_proc_cmd_all (const char *args, int from_tty)
3050{
3051 info_proc_cmd_1 (args, IP_ALL, from_tty);
3052}
3053
3054/* Implement `show print finish'. */
3055
3056static void
3057show_print_finish (struct ui_file *file, int from_tty,
3058 struct cmd_list_element *c,
3059 const char *value)
3060{
3061 gdb_printf (file, _("\
3062Printing of return value after `finish' is %s.\n"),
3063 value);
3064}
3065
3066
3067/* This help string is used for the run, start, and starti commands.
3068 It is defined as a macro to prevent duplication. */
3069
3070#define RUN_ARGS_HELP \
3071"You may specify arguments to give it.\n\
3072Args may include \"*\", or \"[...]\"; they are expanded using the\n\
3073shell that will start the program (specified by the \"$SHELL\" environment\n\
3074variable). Input and output redirection with \">\", \"<\", or \">>\"\n\
3075are also allowed.\n\
3076\n\
3077With no arguments, uses arguments last specified (with \"run\" or \n\
3078\"set args\"). To cancel previous arguments and run with no arguments,\n\
3079use \"set args\" without arguments.\n\
3080\n\
3081To start the inferior without using a shell, use \"set startup-with-shell off\"."
3082
3083void _initialize_infcmd ();
3084void
3086{
3087 static struct cmd_list_element *info_proc_cmdlist;
3088 struct cmd_list_element *c = nullptr;
3089 const char *cmd_name;
3090
3091 /* Add the filename of the terminal connected to inferior I/O. */
3094Set terminal for future runs of program being debugged."), _("\
3095Show terminal for future runs of program being debugged."), _("\
3096Usage: set inferior-tty [TTY]\n\n\
3097If TTY is omitted, the default behavior of using the same terminal as GDB\n\
3098is restored."),
3101 &setlist, &showlist);
3102 cmd_name = "inferior-tty";
3103 c = lookup_cmd (&cmd_name, setlist, "", nullptr, -1, 1);
3104 gdb_assert (c != nullptr);
3105 add_alias_cmd ("tty", c, class_run, 0, &cmdlist);
3106
3107 cmd_name = "args";
3110Set argument list to give program being debugged when it is started."), _("\
3111Show argument list to give program being debugged when it is started."), _("\
3112Follow this command with any number of args, to be passed to the program."),
3115 &setlist, &showlist);
3116 c = lookup_cmd (&cmd_name, setlist, "", nullptr, -1, 1);
3117 gdb_assert (c != nullptr);
3119
3120 cmd_name = "cwd";
3123Set the current working directory to be used when the inferior is started.\n\
3124Changing this setting does not have any effect on inferiors that are\n\
3125already running."),
3126 _("\
3127Show the current working directory that is used when the inferior is started."),
3128 _("\
3129Use this command to change the current working directory that will be used\n\
3130when the inferior is started. This setting does not affect GDB's current\n\
3131working directory."),
3134 &setlist, &showlist);
3135 c = lookup_cmd (&cmd_name, setlist, "", nullptr, -1, 1);
3136 gdb_assert (c != nullptr);
3138
3139 c = add_cmd ("environment", no_class, environment_info, _("\
3140The environment to give the program, or one variable's value.\n\
3141With an argument VAR, prints the value of environment variable VAR to\n\
3142give the program being debugged. With no arguments, prints the entire\n\
3143environment to be given to the program."), &showlist);
3145
3147 _("Complement to certain \"set\" commands."),
3148 &unsetlist, 0, &cmdlist);
3149
3150 c = add_cmd ("environment", class_run, unset_environment_command, _("\
3151Cancel environment variable VAR for the program.\n\
3152This does not affect the program until the next \"run\" command."),
3153 &unsetlist);
3155
3156 c = add_cmd ("environment", class_run, set_environment_command, _("\
3157Set environment variable value to give the program.\n\
3158Arguments are VAR VALUE where VAR is variable name and VALUE is value.\n\
3159VALUES of environment variables are uninterpreted strings.\n\
3160This does not affect the program until the next \"run\" command."),
3161 &setlist);
3163
3164 c = add_com ("path", class_files, path_command, _("\
3165Add directory DIR(s) to beginning of search path for object files.\n\
3166$cwd in the path means the current working directory.\n\
3167This path is equivalent to the $PATH shell variable. It is a list of\n\
3168directories, separated by colons. These directories are searched to find\n\
3169fully linked executable files and separately compiled object files as \
3170needed."));
3172
3173 c = add_cmd ("paths", no_class, path_info, _("\
3174Current search path for finding object files.\n\
3175$cwd in the path means the current working directory.\n\
3176This path is equivalent to the $PATH shell variable. It is a list of\n\
3177directories, separated by colons. These directories are searched to find\n\
3178fully linked executable files and separately compiled object files as \
3179needed."),
3180 &showlist);
3182
3184 _("Kill execution of program being debugged."),
3185 &killlist, 0, &cmdlist);
3186
3187 add_com ("attach", class_run, attach_command, _("\
3188Attach to a process or file outside of GDB.\n\
3189This command attaches to another target, of the same type as your last\n\
3190\"target\" command (\"info files\" will show your target stack).\n\
3191The command may take as argument a process id or a device file.\n\
3192For a process id, you must have permission to send the process a signal,\n\
3193and it must have the same effective uid as the debugger.\n\
3194When using \"attach\" with a process id, the debugger finds the\n\
3195program running in the process, looking first in the current working\n\
3196directory, or (if not found there) using the source file search path\n\
3197(see the \"directory\" command). You can also use the \"file\" command\n\
3198to specify the program, and to load its symbol table."));
3199
3200 add_prefix_cmd ("detach", class_run, detach_command, _("\
3201Detach a process or file previously attached.\n\
3202If a process, it is no longer traced, and it continues its execution. If\n\
3203you were debugging a file, the file is closed and gdb no longer accesses it."),
3204 &detachlist, 0, &cmdlist);
3205
3206 add_com ("disconnect", class_run, disconnect_command, _("\
3207Disconnect from a target.\n\
3208The target will wait for another debugger to connect. Not available for\n\
3209all targets."));
3210
3211 c = add_com ("signal", class_run, signal_command, _("\
3212Continue program with the specified signal.\n\
3213Usage: signal SIGNAL\n\
3214The SIGNAL argument is processed the same as the handle command.\n\
3215\n\
3216An argument of \"0\" means continue the program without sending it a signal.\n\
3217This is useful in cases where the program stopped because of a signal,\n\
3218and you want to resume the program while discarding the signal.\n\
3219\n\
3220In a multi-threaded program the signal is delivered to, or discarded from,\n\
3221the current thread only."));
3223
3224 c = add_com ("queue-signal", class_run, queue_signal_command, _("\
3225Queue a signal to be delivered to the current thread when it is resumed.\n\
3226Usage: queue-signal SIGNAL\n\
3227The SIGNAL argument is processed the same as the handle command.\n\
3228It is an error if the handling state of SIGNAL is \"nopass\".\n\
3229\n\
3230An argument of \"0\" means remove any currently queued signal from\n\
3231the current thread. This is useful in cases where the program stopped\n\
3232because of a signal, and you want to resume it while discarding the signal.\n\
3233\n\
3234In a multi-threaded program the signal is queued with, or discarded from,\n\
3235the current thread only."));
3237
3238 cmd_list_element *stepi_cmd
3239 = add_com ("stepi", class_run, stepi_command, _("\
3240Step one instruction exactly.\n\
3241Usage: stepi [N]\n\
3242Argument N means step N times (or till program stops for another \
3243reason)."));
3244 add_com_alias ("si", stepi_cmd, class_run, 0);
3245
3246 cmd_list_element *nexti_cmd
3247 = add_com ("nexti", class_run, nexti_command, _("\
3248Step one instruction, but proceed through subroutine calls.\n\
3249Usage: nexti [N]\n\
3250Argument N means step N times (or till program stops for another \
3251reason)."));
3252 add_com_alias ("ni", nexti_cmd, class_run, 0);
3253
3254 cmd_list_element *finish_cmd
3255 = add_com ("finish", class_run, finish_command, _("\
3256Execute until selected stack frame returns.\n\
3257Usage: finish\n\
3258Upon return, the value returned is printed and put in the value history."));
3259 add_com_alias ("fin", finish_cmd, class_run, 1);
3260
3262 = add_com ("next", class_run, next_command, _("\
3263Step program, proceeding through subroutine calls.\n\
3264Usage: next [N]\n\
3265Unlike \"step\", if the current source line calls a subroutine,\n\
3266this command does not enter the subroutine, but instead steps over\n\
3267the call, in effect treating it as a single source line."));
3268 add_com_alias ("n", next_cmd, class_run, 1);
3269
3270 cmd_list_element *step_cmd
3271 = add_com ("step", class_run, step_command, _("\
3272Step program until it reaches a different source line.\n\
3273Usage: step [N]\n\
3274Argument N means step N times (or till program stops for another \
3275reason)."));
3276 add_com_alias ("s", step_cmd, class_run, 1);
3277
3278 cmd_list_element *until_cmd
3279 = add_com ("until", class_run, until_command, _("\
3280Execute until past the current line or past a LOCATION.\n\
3281Execute until the program reaches a source line greater than the current\n\
3282or a specified location (same args as break command) within the current \
3283frame."));
3285 add_com_alias ("u", until_cmd, class_run, 1);
3286
3287 c = add_com ("advance", class_run, advance_command, _("\
3288Continue the program up to the given location (same form as args for break \
3289command).\n\
3290Execution will also stop upon exit from the current stack frame."));
3292
3293 cmd_list_element *jump_cmd
3294 = add_com ("jump", class_run, jump_command, _("\
3295Continue program being debugged at specified line or address.\n\
3296Usage: jump LOCATION\n\
3297Give as argument either LINENUM or *ADDR, where ADDR is an expression\n\
3298for an address to start at."));
3300 add_com_alias ("j", jump_cmd, class_run, 1);
3301
3302 cmd_list_element *continue_cmd
3303 = add_com ("continue", class_run, continue_command, _("\
3304Continue program being debugged, after signal or breakpoint.\n\
3305Usage: continue [N]\n\
3306If proceeding from breakpoint, a number N may be used as an argument,\n\
3307which means to set the ignore count of that breakpoint to N - 1 (so that\n\
3308the breakpoint won't break until the Nth time it is reached).\n\
3309\n\
3310If non-stop mode is enabled, continue only the current thread,\n\
3311otherwise all the threads in the program are continued. To \n\
3312continue all stopped threads in non-stop mode, use the -a option.\n\
3313Specifying -a and an ignore count simultaneously is an error."));
3314 add_com_alias ("c", continue_cmd, class_run, 1);
3315 add_com_alias ("fg", continue_cmd, class_run, 1);
3316
3317 cmd_list_element *run_cmd
3318 = add_com ("run", class_run, run_command, _("\
3319Start debugged program.\n"
3322 add_com_alias ("r", run_cmd, class_run, 1);
3323
3324 c = add_com ("start", class_run, start_command, _("\
3325Start the debugged program stopping at the beginning of the main procedure.\n"
3328
3329 c = add_com ("starti", class_run, starti_command, _("\
3330Start the debugged program stopping at the first instruction.\n"
3333
3334 add_com ("interrupt", class_run, interrupt_command,
3335 _("Interrupt the execution of the debugged program.\n\
3336If non-stop mode is enabled, interrupt only the current thread,\n\
3337otherwise all the threads in the program are stopped. To \n\
3338interrupt all running threads in non-stop mode, use the -a option."));
3339
3340 cmd_list_element *info_registers_cmd
3341 = add_info ("registers", info_registers_command, _("\
3342List of integer registers and their contents, for selected stack frame.\n\
3343One or more register names as argument means describe the given registers.\n\
3344One or more register group names as argument means describe the registers\n\
3345in the named register groups."));
3346 add_info_alias ("r", info_registers_cmd, 1);
3347 set_cmd_completer (info_registers_cmd, reg_or_group_completer);
3348
3349 c = add_info ("all-registers", info_all_registers_command, _("\
3350List of all registers and their contents, for selected stack frame.\n\
3351One or more register names as argument means describe the given registers.\n\
3352One or more register group names as argument means describe the registers\n\
3353in the named register groups."));
3355
3356 add_info ("program", info_program_command,
3357 _("Execution status of the program."));
3358
3359 add_info ("float", info_float_command,
3360 _("Print the status of the floating point unit."));
3361
3362 add_info ("vector", info_vector_command,
3363 _("Print the status of the vector unit."));
3364
3366 _("\
3367Show additional information about a process.\n\
3368Specify any process id, or use the program being debugged by default."),
3369 &info_proc_cmdlist,
3370 1/*allow-unknown*/, &infolist);
3371
3372 add_cmd ("mappings", class_info, info_proc_cmd_mappings, _("\
3373List memory regions mapped by the specified process."),
3374 &info_proc_cmdlist);
3375
3376 add_cmd ("stat", class_info, info_proc_cmd_stat, _("\
3377List process info from /proc/PID/stat."),
3378 &info_proc_cmdlist);
3379
3380 add_cmd ("status", class_info, info_proc_cmd_status, _("\
3381List process info from /proc/PID/status."),
3382 &info_proc_cmdlist);
3383
3384 add_cmd ("cwd", class_info, info_proc_cmd_cwd, _("\
3385List current working directory of the specified process."),
3386 &info_proc_cmdlist);
3387
3388 add_cmd ("cmdline", class_info, info_proc_cmd_cmdline, _("\
3389List command line arguments of the specified process."),
3390 &info_proc_cmdlist);
3391
3392 add_cmd ("exe", class_info, info_proc_cmd_exe, _("\
3393List absolute filename for executable of the specified process."),
3394 &info_proc_cmdlist);
3395
3396 add_cmd ("files", class_info, info_proc_cmd_files, _("\
3397List files opened by the specified process."),
3398 &info_proc_cmdlist);
3399
3400 add_cmd ("all", class_info, info_proc_cmd_all, _("\
3401List all available info about the specified process."),
3402 &info_proc_cmdlist);
3403
3405 &finish_print, _("\
3406Set whether `finish' prints the return value."), _("\
3407Show whether `finish' prints the return value."), nullptr,
3408 nullptr,
3411}
int regnum
Definition: aarch64-tdep.c:68
const char *const name
Definition: aarch64-tdep.c:67
struct gdbarch * get_current_arch(void)
Definition: arch-utils.c:846
struct gdbarch * target_gdbarch(void)
Definition: arch-utils.c:1453
struct symbol * find_pc_function(CORE_ADDR pc)
Definition: blockframe.c:150
bool find_pc_partial_function(CORE_ADDR pc, const char **name, CORE_ADDR *address, CORE_ADDR *endaddr, const struct block **block)
Definition: blockframe.c:373
struct symbol * get_frame_function(frame_info_ptr frame)
Definition: blockframe.c:118
void breakpoint_re_set(void)
Definition: breakpoint.c:12917
void breakpoint_init_inferior(enum inf_context context)
Definition: breakpoint.c:4087
void until_break_command(const char *arg, int from_tty, int anywhere)
Definition: breakpoint.c:10592
int bpstat_num(bpstat **bsp, int *num)
Definition: breakpoint.c:4485
void resolve_sal_pc(struct symtab_and_line *sal)
Definition: breakpoint.c:9170
bpstat * bpstat_find_breakpoint(bpstat *bsp, struct breakpoint *breakpoint)
Definition: breakpoint.c:4445
void set_ignore_count(int bptnum, int count, int from_tty)
Definition: breakpoint.c:12992
void tbreak_command(const char *arg, int from_tty)
Definition: breakpoint.c:9229
void clear_breakpoint_hit_counts(void)
Definition: breakpoint.c:800
breakpoint_up set_momentary_breakpoint(struct gdbarch *gdbarch, struct symtab_and_line sal, struct frame_id frame_id, enum bptype type)
Definition: breakpoint.c:8096
void delete_longjmp_breakpoint(int thread)
Definition: breakpoint.c:7507
static int next_cmd
Definition: breakpoint.c:13785
void set_longjmp_breakpoint(struct thread_info *tp, struct frame_id frame)
Definition: breakpoint.c:7483
@ bp_finish
Definition: breakpoint.h:90
@ inf_exited
Definition: breakpoint.h:1344
std::unique_ptr< struct breakpoint, breakpoint_deleter > breakpoint_up
Definition: breakpoint.h:1430
stop_stack_kind
Definition: breakpoint.h:1180
ui_file_style style() const
Definition: cli-style.c:169
void prepare_reinflate()
Definition: frame-info.c:32
void reinflate()
Definition: frame-info.c:43
inferior_control_state control
Definition: inferior.h:535
int pid
Definition: inferior.h:526
void set_args(std::string args)
Definition: inferior.h:490
gdb_environ environment
Definition: inferior.h:555
const std::string & cwd() const
Definition: inferior.h:515
bool has_execution()
Definition: inferior.h:426
struct process_stratum_target * process_target()
Definition: inferior.h:419
bool needs_setup
Definition: inferior.h:586
const std::string & args() const
Definition: inferior.h:498
void add_continuation(std::function< void()> &&cont)
Definition: inferior.c:171
const std::string & tty()
Definition: inferior.c:165
inf_non_exited_threads_range non_exited_threads()
Definition: inferior.h:451
void set_tty(std::string terminal_name)
Definition: inferior.c:159
void set_cwd(std::string cwd)
Definition: inferior.h:506
int num
Definition: inferior.h:522
Definition: interps.h:43
gdbarch * arch() const
Definition: regcache.c:230
size_t size() const
Definition: ui-file.h:219
const char * c_str() const
Definition: ui-file.h:218
static void inferior()
Definition: target.c:947
static void init()
Definition: target.c:937
static void ours_for_output()
Definition: target.c:1083
void set_pending_waitstatus(const target_waitstatus &ws)
Definition: thread.c:375
CORE_ADDR stop_pc() const
Definition: gdbthread.h:361
void set_thread_fsm(std::unique_ptr< struct thread_fsm > fsm)
Definition: gdbthread.h:467
void clear_stop_pc()
Definition: gdbthread.h:376
enum thread_state state
Definition: gdbthread.h:336
int per_inf_num
Definition: gdbthread.h:295
int global_num
Definition: gdbthread.h:290
ptid_t ptid
Definition: gdbthread.h:256
gdb_signal stop_signal() const
Definition: gdbthread.h:421
struct thread_fsm * thread_fsm() const
Definition: gdbthread.h:449
bool executing() const
Definition: gdbthread.h:316
struct inferior * inf
Definition: gdbthread.h:298
void set_stop_pc(CORE_ADDR stop_pc)
Definition: gdbthread.h:369
void set_stop_signal(gdb_signal sig)
Definition: gdbthread.h:428
thread_control_state control
Definition: gdbthread.h:340
virtual void puts(const char *str)
Definition: ui-file.h:74
void putc(int c)
Definition: ui-file.c:64
Definition: ui-out.h:160
void void void spaces(int numspaces)
Definition: ui-out.c:560
void field_string(const char *fldname, const char *string, const ui_file_style &style=ui_file_style())
Definition: ui-out.c:511
void field_fmt(const char *fldname, const char *format,...) ATTRIBUTE_PRINTF(3
Definition: ui-out.c:525
void text(const char *string)
Definition: ui-out.c:566
void field_stream(const char *fldname, string_file &stream, const ui_file_style &style=ui_file_style())
Definition: ui-out.c:486
void flush()
Definition: ui-out.c:791
struct cmd_list_element * showlist
Definition: cli-cmds.c:125
struct cmd_list_element * showprintlist
Definition: cli-cmds.c:161
struct cmd_list_element * infolist
Definition: cli-cmds.c:89
void error_no_arg(const char *why)
Definition: cli-cmds.c:204
struct cmd_list_element * cmdlist
Definition: cli-cmds.c:85
struct cmd_list_element * setprintlist
Definition: cli-cmds.c:159
struct cmd_list_element * setlist
Definition: cli-cmds.c:117
struct cmd_list_element * detachlist
Definition: cli-cmds.c:109
struct cmd_list_element * killlist
Definition: cli-cmds.c:113
struct cmd_list_element * unsetlist
Definition: cli-cmds.c:121
struct cmd_list_element * add_alias_cmd(const char *name, cmd_list_element *target, enum command_class theclass, int abbrev_flag, struct cmd_list_element **list)
Definition: cli-decode.c:294
struct cmd_list_element * lookup_cmd(const char **line, struct cmd_list_element *list, const char *cmdtype, std::string *default_args, int allow_unknown, int ignore_help_classes)
Definition: cli-decode.c:2133
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
cmd_list_element * add_com_alias(const char *name, cmd_list_element *target, command_class theclass, int abbrev_flag)
Definition: cli-decode.c:1323
set_show_commands add_setshow_optional_filename_cmd(const char *name, enum command_class theclass, std::string *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:934
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)
Definition: cli-decode.c:1310
struct cmd_list_element * add_prefix_cmd(const char *name, enum command_class theclass, cmd_simple_func_ftype *fun, const char *doc, struct cmd_list_element **subcommands, int allow_unknown, struct cmd_list_element **list)
Definition: cli-decode.c:357
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
cmd_list_element * add_info_alias(const char *name, cmd_list_element *target, int abbrev_flag)
Definition: cli-decode.c:1302
set_show_commands add_setshow_string_noescape_cmd(const char *name, enum command_class theclass, std::string *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:883
struct cmd_list_element * add_basic_prefix_cmd(const char *name, enum command_class theclass, const char *doc, struct cmd_list_element **subcommands, int allow_unknown, struct cmd_list_element **list)
Definition: cli-decode.c:391
struct cmd_list_element * add_info(const char *name, cmd_simple_func_ftype *fun, const char *doc)
Definition: cli-decode.c:1294
cli_style_option file_name_style
cli_style_option metadata_style
void dont_repeat()
Definition: top.c:809
show_value_ftype deprecated_show_value_hack
@ class_support
Definition: command.h:58
@ class_run
Definition: command.h:54
@ class_files
Definition: command.h:57
@ no_class
Definition: command.h:53
@ class_info
Definition: command.h:59
void signal_completer(struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *word)
Definition: completer.c:1756
void noop_completer(struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *prefix)
Definition: completer.c:195
void location_completer(struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *)
Definition: completer.c:927
void reg_or_group_completer(struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *word)
Definition: completer.c:1834
void filename_completer(struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *word)
Definition: completer.c:204
void reopen_exec_file(void)
Definition: corefile.c:105
const char * get_exec_file(int err)
Definition: corefile.c:149
bool info_verbose
Definition: top.c:2022
void(* deprecated_detach_hook)(void)
Definition: top.c:245
void(* deprecated_attach_hook)(void)
Definition: top.c:244
info_proc_what
Definition: defs.h:381
@ IP_CMDLINE
Definition: defs.h:395
@ IP_EXE
Definition: defs.h:398
@ IP_ALL
Definition: defs.h:407
@ IP_FILES
Definition: defs.h:404
@ IP_MAPPINGS
Definition: defs.h:386
@ IP_STATUS
Definition: defs.h:389
@ IP_MINIMAL
Definition: defs.h:383
@ IP_CWD
Definition: defs.h:401
@ IP_STAT
Definition: defs.h:392
@ language_ada
Definition: defs.h:226
@ language_m2
Definition: defs.h:220
@ language_pascal
Definition: defs.h:222
return_value_convention
Definition: defs.h:258
@ RETURN_VALUE_ABI_RETURNS_ADDRESS
Definition: defs.h:274
@ RETURN_VALUE_REGISTER_CONVENTION
Definition: defs.h:261
@ RETURN_VALUE_STRUCT_CONVENTION
Definition: defs.h:268
@ RETURN_VALUE_ABI_PRESERVES_ADDRESS
Definition: defs.h:280
LONGEST parse_and_eval_long(const char *exp)
Definition: eval.c:62
struct ui * current_ui
Definition: event-top.c:483
void exception_print(struct ui_file *file, const struct gdb_exception &e)
Definition: exceptions.c:105
void exec_file_locate_attach(int pid, int defer_bp_reset, int from_tty)
Definition: exec.c:314
void validate_exec_file(int from_tty)
Definition: exec.c:213
struct value * value_of_register(int regnum, frame_info_ptr frame)
Definition: findvar.c:254
struct value * read_var_value(struct symbol *var, const struct block *var_block, frame_info_ptr frame)
Definition: findvar.c:787
const struct frame_id null_frame_id
Definition: frame.c:664
struct program_space * get_frame_program_space(frame_info_ptr frame)
Definition: frame.c:2845
frame_info_ptr skip_unwritable_frames(frame_info_ptr frame)
Definition: frame.c:528
CORE_ADDR get_frame_pc(frame_info_ptr frame)
Definition: frame.c:2592
struct frame_id get_stack_frame_id(frame_info_ptr next_frame)
Definition: frame.c:638
struct gdbarch * get_frame_arch(frame_info_ptr this_frame)
Definition: frame.c:2907
enum frame_type get_frame_type(frame_info_ptr frame)
Definition: frame.c:2835
frame_info_ptr get_selected_frame(const char *message)
Definition: frame.c:1813
frame_info_ptr get_current_frame(void)
Definition: frame.c:1615
frame_info_ptr skip_tailcall_frames(frame_info_ptr frame)
Definition: frame.c:543
struct frame_id get_frame_id(frame_info_ptr fi)
Definition: frame.c:607
frame_info_ptr get_prev_frame(frame_info_ptr this_frame)
Definition: frame.c:2494
symtab_and_line find_frame_sal(frame_info_ptr frame)
Definition: frame.c:2701
@ LOCATION
Definition: frame.h:592
@ INLINE_FRAME
Definition: frame.h:185
void print_stack_frame(frame_info_ptr, int print_level, enum print_what print_what, int set_current_sal)
Definition: stack.c:356
enum return_value_convention gdbarch_return_value(struct gdbarch *gdbarch, struct value *function, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
Definition: gdbarch.c:2579
const char * gdbarch_register_name(struct gdbarch *gdbarch, int regnr)
Definition: gdbarch.c:2142
void gdbarch_print_registers_info(struct gdbarch *gdbarch, struct ui_file *file, frame_info_ptr frame, int regnum, int all)
Definition: gdbarch.c:2296
bool gdbarch_print_vector_info_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:2330
void gdbarch_print_float_info(struct gdbarch *gdbarch, struct ui_file *file, frame_info_ptr frame, const char *args)
Definition: gdbarch.c:2313
bool gdbarch_info_proc_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:4924
int gdbarch_has_global_solist(struct gdbarch *gdbarch)
Definition: gdbarch.c:4754
int gdbarch_register_reggroup_p(struct gdbarch *gdbarch, int regnum, const struct reggroup *reggroup)
Definition: gdbarch.c:3604
void gdbarch_print_vector_info(struct gdbarch *gdbarch, struct ui_file *file, frame_info_ptr frame, const char *args)
Definition: gdbarch.c:2337
CORE_ADDR gdbarch_get_return_buf_addr(struct gdbarch *gdbarch, struct type *val_type, frame_info_ptr cur_frame)
Definition: gdbarch.c:2596
void gdbarch_info_proc(struct gdbarch *gdbarch, const char *args, enum info_proc_what what)
Definition: gdbarch.c:4931
static int gdbarch_num_cooked_regs(gdbarch *arch)
Definition: gdbarch.h:377
all_matching_threads_range all_threads(process_stratum_target *proc_target=nullptr, ptid_t filter_ptid=minus_one_ptid)
Definition: gdbthread.h:732
thread_info * find_thread_ptid(inferior *inf, ptid_t ptid)
Definition: thread.c:528
void switch_to_thread_no_regs(struct thread_info *thread)
Definition: thread.c:1303
all_non_exited_threads_range all_non_exited_threads(process_stratum_target *proc_target=nullptr, ptid_t filter_ptid=minus_one_ptid)
Definition: gdbthread.h:743
@ THREAD_STOPPED
Definition: gdbthread.h:72
@ THREAD_RUNNING
Definition: gdbthread.h:75
@ THREAD_EXITED
Definition: gdbthread.h:79
void set_stop_requested(process_stratum_target *targ, ptid_t ptid, bool stop)
Definition: thread.c:903
struct thread_info * inferior_thread(void)
Definition: thread.c:83
void switch_to_thread(struct thread_info *thr)
Definition: thread.c:1335
void set_running(process_stratum_target *targ, ptid_t ptid, bool running)
Definition: thread.c:863
struct thread_info * iterate_over_threads(thread_callback_func, void *)
Definition: thread.c:565
FORWARD_SCOPE_EXIT(finish_thread_state) scoped_finish_thread_state
Definition: gdbthread.h:827
@ STEP_OVER_NONE
Definition: gdbthread.h:88
@ STEP_OVER_ALL
Definition: gdbthread.h:89
const char * print_thread_id(struct thread_info *thr)
Definition: thread.c:1431
void init_thread_list(void)
Definition: thread.c:233
enum bfd_endian type_byte_order(const struct type *type)
Definition: gdbtypes.c:4018
bool is_nocall_function(const struct type *type)
Definition: gdbtypes.c:4038
struct type * check_typedef(struct type *type)
Definition: gdbtypes.c:3010
#define TYPE_NO_RETURN(thistype)
Definition: gdbtypes.h:2105
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
size_t size
Definition: go32-nat.c:241
void inferior_event_handler(enum inferior_event_type event_type)
Definition: inf-loop.c:36
static void signal_command(const char *signum_exp, int from_tty)
Definition: infcmd.c:1141
void attach_command(const char *args, int from_tty)
Definition: infcmd.c:2607
static void path_command(const char *dirname, int from_tty)
Definition: infcmd.c:2131
static void info_vector_command(const char *args, int from_tty)
Definition: infcmd.c:2428
static void show_inferior_tty_command(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: infcmd.c:119
static void finish_command(const char *arg, int from_tty)
Definition: infcmd.c:1816
static void kill_if_already_running(int from_tty)
Definition: infcmd.c:325
static void pad_to_column(string_file &stream, int col)
Definition: infcmd.c:2149
void continue_1(int all_threads)
Definition: infcmd.c:617
static void finish_backward(struct finish_command_fsm *sm)
Definition: infcmd.c:1711
static void interrupt_command(const char *args, int from_tty)
Definition: infcmd.c:2916
static void set_step_frame(thread_info *tp)
Definition: infcmd.c:758
static bool finish_print
Definition: infcmd.c:105
static void info_proc_cmd_status(const char *args, int from_tty)
Definition: infcmd.c:3009
static void info_proc_cmd_1(const char *args, enum info_proc_what what, int from_tty)
Definition: infcmd.c:2969
static void set_environment_command(const char *arg, int from_tty)
Definition: infcmd.c:2041
static void stop_current_target_threads_ns(ptid_t ptid)
Definition: infcmd.c:2867
static std::string inferior_args_scratch
Definition: infcmd.c:75
static void show_print_finish(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: infcmd.c:3057
void prepare_execution_command(struct target_ops *target, int background)
Definition: infcmd.c:344
static void environment_info(const char *var, int from_tty)
Definition: infcmd.c:2008
static void step_command(const char *count_string, int from_tty)
Definition: infcmd.c:776
static void ensure_not_tfind_mode(void)
Definition: infcmd.c:592
static void info_float_command(const char *args, int from_tty)
Definition: infcmd.c:2955
static void print_return_value_1(struct ui_out *uiout, struct return_value_info *rv)
Definition: infcmd.c:1540
ptid_t inferior_ptid
Definition: infcmd.c:91
static void disconnect_command(const char *args, int from_tty)
Definition: infcmd.c:2849
static void stepi_command(const char *count_string, int from_tty)
Definition: infcmd.c:792
static void run_command_1(const char *args, int from_tty, enum run_how run_how)
Definition: infcmd.c:379
static void info_proc_cmd_cwd(const char *args, int from_tty)
Definition: infcmd.c:3017
static void nexti_command(const char *count_string, int from_tty)
Definition: infcmd.c:798
static void set_cwd_command(const char *args, int from_tty, struct cmd_list_element *c)
Definition: infcmd.c:172
static frame_info_ptr skip_finish_frames(frame_info_ptr frame)
Definition: infcmd.c:1791
void default_print_registers_info(struct gdbarch *gdbarch, struct ui_file *file, frame_info_ptr frame, int regnum, int print_all)
Definition: infcmd.c:2241
static void unset_environment_command(const char *var, int from_tty)
Definition: infcmd.c:2103
static void attach_post_wait(int from_tty, enum attach_post_wait_mode mode)
Definition: infcmd.c:2533
attach_post_wait_mode
Definition: infcmd.c:2517
@ ATTACH_POST_WAIT_RESUME
Definition: infcmd.c:2522
@ ATTACH_POST_WAIT_NOTHING
Definition: infcmd.c:2519
@ ATTACH_POST_WAIT_STOP
Definition: infcmd.c:2525
static void step_command_fsm_prepare(struct step_command_fsm *sm, int skip_subroutines, int single_inst, int count, struct thread_info *thread)
Definition: infcmd.c:831
static void info_proc_cmd_stat(const char *args, int from_tty)
Definition: infcmd.c:3001
void detach_command(const char *args, int from_tty)
Definition: infcmd.c:2794
static void until_next_command(int)
Definition: infcmd.c:1333
static void info_proc_cmd_mappings(const char *args, int from_tty)
Definition: infcmd.c:2993
void set_inferior_args_vector(int argc, char **argv)
Definition: infcmd.c:132
static void ensure_valid_thread(void)
Definition: infcmd.c:580
static void queue_signal_command(const char *signum_exp, int from_tty)
Definition: infcmd.c:1238
static void info_proc_cmd_exe(const char *args, int from_tty)
Definition: infcmd.c:3033
#define ERROR_NO_INFERIOR
Definition: infcmd.c:66
static void info_proc_cmd(const char *args, int from_tty)
Definition: infcmd.c:2985
static void starti_command(const char *args, int from_tty)
Definition: infcmd.c:550
static void info_all_registers_command(const char *addr_exp, int from_tty)
Definition: infcmd.c:2390
static std::string inferior_cwd_scratch
Definition: infcmd.c:79
void _initialize_infcmd()
Definition: infcmd.c:3085
static void continue_command(const char *args, int from_tty)
Definition: infcmd.c:667
static gdb::unique_xmalloc_ptr< char > strip_bg_char(const char *args, int *bg_char_p)
Definition: infcmd.c:207
static void advance_command(const char *arg, int from_tty)
Definition: infcmd.c:1450
static void info_registers_command(const char *addr_exp, int from_tty)
Definition: infcmd.c:2396
void interrupt_target_1(bool all_threads)
Definition: infcmd.c:2884
void registers_info(const char *addr_exp, int fpregs)
Definition: infcmd.c:2284
struct value * get_return_value(struct symbol *func_symbol, struct value *function)
Definition: infcmd.c:1474
static void error_is_running(void)
Definition: infcmd.c:601
int stopped_by_random_signal
Definition: infcmd.c:100
static void show_args_command(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: infcmd.c:152
static void start_command(const char *args, int from_tty)
Definition: infcmd.c:534
static void run_command(const char *args, int from_tty)
Definition: infcmd.c:525
run_how
Definition: infcmd.c:364
@ RUN_NORMAL
Definition: infcmd.c:366
@ RUN_STOP_AT_MAIN
Definition: infcmd.c:369
@ RUN_STOP_AT_FIRST_INSN
Definition: infcmd.c:372
static void set_args_command(const char *args, int from_tty, struct cmd_list_element *c)
Definition: infcmd.c:142
static void default_print_one_register_info(struct ui_file *file, const char *name, struct value *val)
Definition: infcmd.c:2162
static void finish_forward(struct finish_command_fsm *sm, frame_info_ptr frame)
Definition: infcmd.c:1763
const std::string & get_inferior_cwd()
Definition: infcmd.c:164
static void info_program_command(const char *args, int from_tty)
Definition: infcmd.c:1938
static void info_proc_cmd_files(const char *args, int from_tty)
Definition: infcmd.c:3041
static void set_inferior_tty_command(const char *args, int from_tty, struct cmd_list_element *c)
Definition: infcmd.c:110
static void info_proc_cmd_all(const char *args, int from_tty)
Definition: infcmd.c:3049
static int prepare_one_step(thread_info *, struct step_command_fsm *sm)
Definition: infcmd.c:946
static int proceed_thread_callback(struct thread_info *thread, void *arg)
Definition: infcmd.c:556
static void next_command(const char *count_string, int from_tty)
Definition: infcmd.c:784
static void jump_command(const char *arg, int from_tty)
Definition: infcmd.c:1060
void setup_inferior(int from_tty)
Definition: infcmd.c:2492
void notice_new_inferior(thread_info *thr, bool leave_running, int from_tty)
Definition: infcmd.c:2742
enum stop_stack_kind stop_stack_dummy
Definition: infcmd.c:95
static void path_info(const char *args, int from_tty)
Definition: infcmd.c:2121
void default_print_float_info(struct gdbarch *gdbarch, struct ui_file *file, frame_info_ptr frame, const char *args)
Definition: infcmd.c:2935
static std::string inferior_io_terminal_scratch
Definition: infcmd.c:84
void post_create_inferior(int from_tty)
Definition: infcmd.c:241
static void step_1(int, int, const char *)
Definition: infcmd.c:849
static void info_proc_cmd_cmdline(const char *args, int from_tty)
Definition: infcmd.c:3025
static void until_command(const char *arg, int from_tty)
Definition: infcmd.c:1428
void print_return_value(struct ui_out *uiout, struct return_value_info *rv)
Definition: infcmd.c:1579
#define RUN_ARGS_HELP
Definition: infcmd.c:3070
static void proceed_after_attach(inferior *inf)
Definition: infcmd.c:2470
static void print_vector_info(struct ui_file *file, frame_info_ptr frame, const char *args)
Definition: infcmd.c:2402
static void ensure_not_running(void)
Definition: infcmd.c:610
static const char path_var_name[]
Definition: infcmd.c:2118
static void show_cwd_command(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: infcmd.c:180
static void kill_command(const char *arg, int from_tty)
Definition: infcmd.c:2439
bool print_inferior_events
Definition: inferior.c:46
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
@ NO_STOP_QUIETLY
Definition: inferior.h:299
@ STOP_QUIETLY_REMOTE
Definition: inferior.h:301
@ STOP_QUIETLY_NO_SIGSTOP
Definition: inferior.h:302
FORWARD_SCOPE_EXIT(delete_longjmp_breakpoint) delete_longjmp_breakpoint_cleanup
Definition: inferior.h:237
void set_step_info(thread_info *tp, frame_info_ptr frame, struct symtab_and_line sal)
Definition: infrun.c:4299
void insert_step_resume_breakpoint_at_sal(struct gdbarch *gdbarch, struct symtab_and_line sr_sal, struct frame_id sr_id)
Definition: infrun.c:7883
void mark_infrun_async_event_handler(void)
Definition: infrun.c:135
bool step_stop_if_no_debug
Definition: infrun.c:143
int normal_stop(void)
Definition: infrun.c:8583
process_stratum_target * user_visible_resume_target(ptid_t resume_ptid)
Definition: infrun.c:2170
void restart_after_all_stop_detach(process_stratum_target *proc_target)
Definition: infrun.c:7590
void clear_proceed_status(int step)
Definition: infrun.c:2760
enum exec_direction_kind execution_direction
Definition: infrun.c:9451
bool non_stop
Definition: infrun.c:203
int signal_pass_state(int signo)
Definition: infrun.c:8780
void all_uis_on_sync_execution_starting(void)
Definition: infrun.c:4099
enum gdb_signal gdb_signal_from_command(int num)
Definition: infrun.c:9064
void all_uis_check_sync_execution_done(void)
Definition: infrun.c:4088
void stop_all_threads(const char *reason, inferior *inf)
Definition: infrun.c:5038
void init_wait_for_inferior(void)
Definition: infrun.c:3426
void get_last_target_status(process_stratum_target **target, ptid_t *ptid, target_waitstatus *status)
Definition: infrun.c:4345
void proceed(CORE_ADDR addr, enum gdb_signal siggnal)
Definition: infrun.c:3132
ptid_t user_visible_resume_ptid(int step)
Definition: infrun.c:2128
@ EXEC_REVERSE
Definition: infrun.h:114
static void infrun_debug_show_threads(const char *title, ThreadRange threads)
Definition: infrun.h:61
int inline_skipped_frames(thread_info *thread)
Definition: inline-frame.c:410
void step_into_inline_frame(thread_info *thread)
Definition: inline-frame.c:397
struct symbol * inline_skipped_symbol(thread_info *thread)
Definition: inline-frame.c:424
struct interp * command_interp(void)
Definition: interps.c:304
const struct language_defn * current_language
Definition: language.c:83
std::vector< symtab_and_line > decode_line_with_last_displayed(const char *string, int flags)
Definition: linespec.c:3234
@ DECODE_LINE_FUNFIRSTLINE
Definition: linespec.h:30
async_reply_reason
Definition: mi-common.h:26
@ EXEC_ASYNC_FUNCTION_FINISHED
Definition: mi-common.h:31
@ EXEC_ASYNC_END_STEPPING_RANGE
Definition: mi-common.h:34
struct bound_minimal_symbol lookup_minimal_symbol_by_pc(CORE_ADDR pc)
Definition: minsyms.c:977
observable< inferior * > inferior_created
int have_minimal_symbols(void)
Definition: objfiles.c:852
static process_stratum_target * as_process_stratum_target(target_ops *target)
struct program_space * current_program_space
Definition: progspace.c:39
CORE_ADDR regcache_read_pc(struct regcache *regcache)
Definition: regcache.c:1324
struct regcache * get_current_regcache(void)
Definition: regcache.c:426
struct regcache * get_thread_regcache(process_stratum_target *target, ptid_t ptid)
Definition: regcache.c:397
const reggroup *const general_reggroup
Definition: reggroups.c:251
const reggroup *const float_reggroup
Definition: reggroups.c:252
const reggroup *const all_reggroup
Definition: reggroups.c:255
const std::vector< const reggroup * > & gdbarch_reggroups(struct gdbarch *gdbarch)
Definition: reggroups.c:136
const reggroup *const vector_reggroup
Definition: reggroups.c:254
void(* func)(remote_target *remote, char *)
bool function_name_is_marked_for_skip(const char *function_name, const symtab_and_line &function_sal)
Definition: skip.c:614
void solib_create_inferior_hook(int from_tty)
Definition: solib.c:1245
void solib_add(const char *pattern, int from_tty, int readsyms)
Definition: solib.c:983
void no_shared_libraries(const char *ignored, int from_tty)
Definition: solib.c:1277
void mod_path(const char *dirname, std::string &which_path)
Definition: source.c:506
Definition: block.h:109
CORE_ADDR end() const
Definition: block.h:119
CORE_ADDR value_address() const
Definition: minsyms.h:41
struct minimal_symbol * minsym
Definition: minsyms.h:49
breakpoint_up breakpoint
Definition: infcmd.c:1604
CORE_ADDR return_buf
Definition: infcmd.c:1617
enum async_reply_reason do_async_reply_reason() override
Definition: infcmd.c:1700
void clean_up(struct thread_info *thread) override
Definition: infcmd.c:1681
struct symbol * function
Definition: infcmd.c:1607
struct return_value_info * return_value() override
Definition: infcmd.c:1691
bool should_stop(struct thread_info *thread) override
Definition: infcmd.c:1636
finish_command_fsm(struct interp *cmd_interp)
Definition: infcmd.c:1619
const char * print_name() const
Definition: symtab.h:474
struct obj_section * obj_section(const struct objfile *objfile) const
Definition: symtab.c:1088
Definition: gnu-nat.c:154
enum stop_kind stop_soon
Definition: inferior.h:331
enum language la_language
Definition: language.h:275
CORE_ADDR addr() const
Definition: objfiles.h:822
unsigned int solib_add_generation
Definition: progspace.h:363
bfd * exec_bfd() const
Definition: progspace.h:264
int value_history_index
Definition: infcmd.c:1534
struct type * type
Definition: infcmd.c:1531
struct value * value
Definition: infcmd.c:1527
step_command_fsm(struct interp *cmd_interp)
Definition: infcmd.c:817
void clean_up(struct thread_info *thread) override
Definition: infcmd.c:925
int skip_subroutines
Definition: infcmd.c:812
bool should_stop(struct thread_info *thread) override
Definition: infcmd.c:907
enum async_reply_reason do_async_reply_reason() override
Definition: infcmd.c:935
const block * value_block() const
Definition: symtab.h:1348
address_class aclass() const
Definition: symtab.h:1235
struct type * type() const
Definition: symtab.h:1285
struct objfile * objfile() const
Definition: symtab.c:6477
struct symtab * symtab
Definition: symtab.h:2263
CORE_ADDR pc
Definition: symtab.h:2272
CORE_ADDR end
Definition: symtab.h:2273
struct program_space * pspace
Definition: symtab.h:2261
virtual void create_inferior(const char *, const std::string &, char **, int)
Definition: target.c:3049
virtual bool supports_non_stop() TARGET_DEFAULT_RETURN(false)
virtual void attach(const char *, int)
Definition: target.c:3037
target_waitstatus & set_stopped(gdb_signal sig)
Definition: waitstatus.h:230
CORE_ADDR step_range_start
Definition: gdbthread.h:124
CORE_ADDR step_range_end
Definition: gdbthread.h:125
bpstat * stop_bpstat
Definition: gdbthread.h:168
enum step_over_calls_kind step_over_calls
Definition: gdbthread.h:161
struct symbol * step_start_function
Definition: gdbthread.h:128
virtual void clean_up(struct thread_info *thread)
Definition: thread-fsm.h:48
void set_finished()
Definition: thread-fsm.h:82
Definition: gdbtypes.h:922
struct type * target_type() const
Definition: gdbtypes.h:1000
type_code code() const
Definition: gdbtypes.h:927
ULONGEST length() const
Definition: gdbtypes.h:954
bool is_vector() const
Definition: gdbtypes.h:1149
enum prompt_state prompt_state
Definition: top.h:131
enum async_reply_reason do_async_reply_reason() override
Definition: infcmd.c:1319
until_next_fsm(struct interp *cmd_interp, int thread)
Definition: infcmd.c:1283
bool should_stop(struct thread_info *thread) override
Definition: infcmd.c:1298
void clean_up(struct thread_info *thread) override
Definition: infcmd.c:1310
Definition: value.c:181
int section_is_mapped(struct obj_section *osect)
Definition: symfile.c:2978
bool auto_solib_add
Definition: symfile.c:151
void reread_symbols(int from_tty)
Definition: symfile.c:2421
int section_is_overlay(struct obj_section *section)
Definition: symfile.c:2940
bool find_pc_line_pc_range(CORE_ADDR pc, CORE_ADDR *startptr, CORE_ADDR *endptr)
Definition: symtab.c:3588
struct symbol * fixup_symbol_section(struct symbol *sym, struct objfile *objfile)
Definition: symtab.c:1788
const char * main_name()
Definition: symtab.c:6309
struct symtab_and_line find_pc_line(CORE_ADDR pc, int notcurrent)
Definition: symtab.c:3297
@ LOC_BLOCK
Definition: symtab.h:999
void target_find_description(void)
struct target_ops * find_run_target(void)
Definition: target.c:2909
void target_require_runnable(void)
Definition: target.c:2801
void target_post_attach(int pid)
Definition: target.c:233
bool target_is_async_p()
Definition: target.c:403
struct target_ops * find_attach_target(void)
Definition: target.c:2891
void target_pre_inferior(int from_tty)
Definition: target.c:2435
void target_async(bool enable)
Definition: target.c:4330
void target_interrupt()
Definition: target.c:3791
void target_detach(inferior *inf, int from_tty)
Definition: target.c:2512
bool target_can_async_p()
Definition: target.c:385
void target_kill(void)
Definition: target.c:908
bool target_has_execution(inferior *inf)
Definition: target.c:202
void target_disconnect(const char *args, int from_tty)
Definition: target.c:2552
int target_has_registers()
Definition: target.c:190
bool target_attach_no_wait()
Definition: target.c:225
void target_stop(ptid_t ptid)
Definition: target.c:3775
bool target_is_non_stop_p()
Definition: target.c:4387
std::string target_pid_to_str(ptid_t ptid)
Definition: target.c:2602
int target_info_proc(const char *args, enum info_proc_what what)
Definition: target.c:2933
void target_files_info()
Definition: target.c:299
@ INF_EXEC_COMPLETE
Definition: target.h:131
@ PROMPT_BLOCKED
Definition: top.h:36
void disconnect_tracing(void)
Definition: tracepoint.c:2058
int get_traceframe_number(void)
Definition: tracepoint.c:2918
void query_if_trace_running(int from_tty)
Definition: tracepoint.c:2017
std::string type_to_string(struct type *type)
Definition: typeprint.c:402
#define current_uiout
Definition: ui-out.h:40
const char * user_reg_map_regnum_to_name(struct gdbarch *gdbarch, int regnum)
Definition: user-regs.c:187
int user_reg_map_name_to_regnum(struct gdbarch *gdbarch, const char *name, int len)
Definition: user-regs.c:132
struct value * value_of_user_reg(int regnum, frame_info_ptr frame)
Definition: user-regs.c:206
int query(const char *ctlstr,...)
Definition: utils.c:1010
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: utils.c:3114
const char * n_spaces(int n)
Definition: utils.c:1926
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
struct value * value_at(struct type *type, CORE_ADDR addr)
Definition: valops.c:1017
void get_formatted_print_options(struct value_print_options *opts, char format)
Definition: valprint.c:145
void value_print(struct value *val, struct ui_file *stream, const struct value_print_options *options)
Definition: valprint.c:1172
void get_user_print_options(struct value_print_options *opts)
Definition: valprint.c:128
void print_hex_chars(struct ui_file *stream, const gdb_byte *valaddr, unsigned len, enum bfd_endian byte_order, bool zero_pad)
Definition: valprint.c:1822
void common_val_print(struct value *value, struct ui_file *stream, int recurse, const struct value_print_options *options, const struct language_defn *language)
Definition: valprint.c:1014
struct type * value_type(const struct value *value)
Definition: value.c:1109
int value_entirely_available(struct value *value)
Definition: value.c:408
struct value * allocate_value(struct type *type)
Definition: value.c:1053
int record_latest_value(struct value *val)
Definition: value.c:1926
gdb::array_view< gdb_byte > value_contents_raw(struct value *value)
Definition: value.c:1167
int value_optimized_out(struct value *value)
Definition: value.c:1481
gdb::array_view< const gdb_byte > value_contents_for_printing(struct value *value)
Definition: value.c:1265