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