OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.2/] [gdb/] [infcmd.c] - Blame information for rev 330

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 330 jeremybenn
/* Memory-access and commands for "inferior" process, for GDB.
2
 
3
   Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4
   1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
5
   2008, 2009, 2010 Free Software Foundation, Inc.
6
 
7
   This file is part of GDB.
8
 
9
   This program is free software; you can redistribute it and/or modify
10
   it under the terms of the GNU General Public License as published by
11
   the Free Software Foundation; either version 3 of the License, or
12
   (at your option) any later version.
13
 
14
   This program is distributed in the hope that it will be useful,
15
   but WITHOUT ANY WARRANTY; without even the implied warranty of
16
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17
   GNU General Public License for more details.
18
 
19
   You should have received a copy of the GNU General Public License
20
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
21
 
22
#include "defs.h"
23
#include "arch-utils.h"
24
#include <signal.h>
25
#include "gdb_string.h"
26
#include "symtab.h"
27
#include "gdbtypes.h"
28
#include "frame.h"
29
#include "inferior.h"
30
#include "environ.h"
31
#include "value.h"
32
#include "gdbcmd.h"
33
#include "symfile.h"
34
#include "gdbcore.h"
35
#include "target.h"
36
#include "language.h"
37
#include "symfile.h"
38
#include "objfiles.h"
39
#include "completer.h"
40
#include "ui-out.h"
41
#include "event-top.h"
42
#include "parser-defs.h"
43
#include "regcache.h"
44
#include "reggroups.h"
45
#include "block.h"
46
#include "solib.h"
47
#include <ctype.h>
48
#include "gdb_assert.h"
49
#include "observer.h"
50
#include "target-descriptions.h"
51
#include "user-regs.h"
52
#include "exceptions.h"
53
#include "cli/cli-decode.h"
54
#include "gdbthread.h"
55
#include "valprint.h"
56
#include "inline-frame.h"
57
#include "tracepoint.h"
58
 
59
/* Functions exported for general use, in inferior.h: */
60
 
61
void all_registers_info (char *, int);
62
 
63
void registers_info (char *, int);
64
 
65
void nexti_command (char *, int);
66
 
67
void stepi_command (char *, int);
68
 
69
void continue_command (char *, int);
70
 
71
void interrupt_target_command (char *args, int from_tty);
72
 
73
/* Local functions: */
74
 
75
static void nofp_registers_info (char *, int);
76
 
77
static void print_return_value (struct type *func_type,
78
                                struct type *value_type);
79
 
80
static void until_next_command (int);
81
 
82
static void until_command (char *, int);
83
 
84
static void path_info (char *, int);
85
 
86
static void path_command (char *, int);
87
 
88
static void unset_command (char *, int);
89
 
90
static void float_info (char *, int);
91
 
92
static void disconnect_command (char *, int);
93
 
94
static void unset_environment_command (char *, int);
95
 
96
static void set_environment_command (char *, int);
97
 
98
static void environment_info (char *, int);
99
 
100
static void program_info (char *, int);
101
 
102
static void finish_command (char *, int);
103
 
104
static void signal_command (char *, int);
105
 
106
static void jump_command (char *, int);
107
 
108
static void step_1 (int, int, char *);
109
static void step_once (int skip_subroutines, int single_inst, int count, int thread);
110
 
111
static void next_command (char *, int);
112
 
113
static void step_command (char *, int);
114
 
115
static void run_command (char *, int);
116
 
117
static void run_no_args_command (char *args, int from_tty);
118
 
119
static void go_command (char *line_no, int from_tty);
120
 
121
static int strip_bg_char (char **);
122
 
123
void _initialize_infcmd (void);
124
 
125
#define ERROR_NO_INFERIOR \
126
   if (!target_has_execution) error (_("The program is not being run."));
127
 
128
/* Scratch area where string containing arguments to give to the program will be
129
   stored by 'set args'.  As soon as anything is stored, notice_args_set will
130
   move it into per-inferior storage.  Arguments are separated by spaces. Empty
131
   string (pointer to '\0') means no args.  */
132
 
133
static char *inferior_args_scratch;
134
 
135
/* Scratch area where 'set inferior-tty' will store user-provided value.
136
   We'll immediate copy it into per-inferior storage.  */
137
 
138
static char *inferior_io_terminal_scratch;
139
 
140
/* Pid of our debugged inferior, or 0 if no inferior now.
141
   Since various parts of infrun.c test this to see whether there is a program
142
   being debugged it should be nonzero (currently 3 is used) for remote
143
   debugging.  */
144
 
145
ptid_t inferior_ptid;
146
 
147
/* Address at which inferior stopped.  */
148
 
149
CORE_ADDR stop_pc;
150
 
151
/* Flag indicating that a command has proceeded the inferior past the
152
   current breakpoint.  */
153
 
154
int breakpoint_proceeded;
155
 
156
/* Nonzero if stopped due to completion of a stack dummy routine.  */
157
 
158
enum stop_stack_kind stop_stack_dummy;
159
 
160
/* Nonzero if stopped due to a random (unexpected) signal in inferior
161
   process.  */
162
 
163
int stopped_by_random_signal;
164
 
165
 
166
/* Accessor routines. */
167
 
168
/* Set the io terminal for the current inferior.  Ownership of
169
   TERMINAL_NAME is not transferred.  */
170
 
171
void
172
set_inferior_io_terminal (const char *terminal_name)
173
{
174
  xfree (current_inferior ()->terminal);
175
  current_inferior ()->terminal = terminal_name ? xstrdup (terminal_name) : 0;
176
}
177
 
178
const char *
179
get_inferior_io_terminal (void)
180
{
181
  return current_inferior ()->terminal;
182
}
183
 
184
static void
185
set_inferior_tty_command (char *args, int from_tty,
186
                          struct cmd_list_element *c)
187
{
188
  /* CLI has assigned the user-provided value to inferior_io_terminal_scratch.
189
     Now route it to current inferior.  */
190
  set_inferior_io_terminal (inferior_io_terminal_scratch);
191
}
192
 
193
static void
194
show_inferior_tty_command (struct ui_file *file, int from_tty,
195
                           struct cmd_list_element *c, const char *value)
196
{
197
  /* Note that we ignore the passed-in value in favor of computing it
198
     directly.  */
199
  const char *inferior_io_terminal = get_inferior_io_terminal ();
200
 
201
  if (inferior_io_terminal == NULL)
202
    inferior_io_terminal = "";
203
  fprintf_filtered (gdb_stdout,
204
                    _("Terminal for future runs of program being debugged "
205
                      "is \"%s\".\n"), inferior_io_terminal);
206
}
207
 
208
char *
209
get_inferior_args (void)
210
{
211
  if (current_inferior ()->argc != 0)
212
    {
213
      char *n;
214
 
215
      n = construct_inferior_arguments (current_inferior ()->argc,
216
                                        current_inferior ()->argv);
217
      set_inferior_args (n);
218
      xfree (n);
219
    }
220
 
221
  if (current_inferior ()->args == NULL)
222
    current_inferior ()->args = xstrdup ("");
223
 
224
  return current_inferior ()->args;
225
}
226
 
227
/* Set the arguments for the current inferior.  Ownership of
228
   NEWARGS is not transferred.  */
229
 
230
void
231
set_inferior_args (char *newargs)
232
{
233
  xfree (current_inferior ()->args);
234
  current_inferior ()->args = newargs ? xstrdup (newargs) : NULL;
235
  current_inferior ()->argc = 0;
236
  current_inferior ()->argv = 0;
237
}
238
 
239
void
240
set_inferior_args_vector (int argc, char **argv)
241
{
242
  current_inferior ()->argc = argc;
243
  current_inferior ()->argv = argv;
244
}
245
 
246
/* Notice when `set args' is run.  */
247
static void
248
set_args_command (char *args, int from_tty, struct cmd_list_element *c)
249
{
250
  /* CLI has assigned the user-provided value to inferior_args_scratch.
251
     Now route it to current inferior.  */
252
  set_inferior_args (inferior_args_scratch);
253
}
254
 
255
/* Notice when `show args' is run.  */
256
static void
257
show_args_command (struct ui_file *file, int from_tty,
258
                   struct cmd_list_element *c, const char *value)
259
{
260
  /* Note that we ignore the passed-in value in favor of computing it
261
     directly.  */
262
  deprecated_show_value_hack (file, from_tty, c, get_inferior_args ());
263
}
264
 
265
 
266
/* Compute command-line string given argument vector.  This does the
267
   same shell processing as fork_inferior.  */
268
char *
269
construct_inferior_arguments (int argc, char **argv)
270
{
271
  char *result;
272
 
273
  if (STARTUP_WITH_SHELL)
274
    {
275
      /* This holds all the characters considered special to the
276
         typical Unix shells.  We include `^' because the SunOS
277
         /bin/sh treats it as a synonym for `|'.  */
278
      char *special = "\"!#$&*()\\|[]{}<>?'\"`~^; \t\n";
279
      int i;
280
      int length = 0;
281
      char *out, *cp;
282
 
283
      /* We over-compute the size.  It shouldn't matter.  */
284
      for (i = 0; i < argc; ++i)
285
        length += 3 * strlen (argv[i]) + 1 + 2 * (argv[i][0] == '\0');
286
 
287
      result = (char *) xmalloc (length);
288
      out = result;
289
 
290
      for (i = 0; i < argc; ++i)
291
        {
292
          if (i > 0)
293
            *out++ = ' ';
294
 
295
          /* Need to handle empty arguments specially.  */
296
          if (argv[i][0] == '\0')
297
            {
298
              *out++ = '\'';
299
              *out++ = '\'';
300
            }
301
          else
302
            {
303
              for (cp = argv[i]; *cp; ++cp)
304
                {
305
                  if (*cp == '\n')
306
                    {
307
                      /* A newline cannot be quoted with a backslash (it
308
                         just disappears), only by putting it inside
309
                         quotes.  */
310
                      *out++ = '\'';
311
                      *out++ = '\n';
312
                      *out++ = '\'';
313
                    }
314
                  else
315
                    {
316
                      if (strchr (special, *cp) != NULL)
317
                        *out++ = '\\';
318
                      *out++ = *cp;
319
                    }
320
                }
321
            }
322
        }
323
      *out = '\0';
324
    }
325
  else
326
    {
327
      /* In this case we can't handle arguments that contain spaces,
328
         tabs, or newlines -- see breakup_args().  */
329
      int i;
330
      int length = 0;
331
 
332
      for (i = 0; i < argc; ++i)
333
        {
334
          char *cp = strchr (argv[i], ' ');
335
          if (cp == NULL)
336
            cp = strchr (argv[i], '\t');
337
          if (cp == NULL)
338
            cp = strchr (argv[i], '\n');
339
          if (cp != NULL)
340
            error (_("can't handle command-line argument containing whitespace"));
341
          length += strlen (argv[i]) + 1;
342
        }
343
 
344
      result = (char *) xmalloc (length);
345
      result[0] = '\0';
346
      for (i = 0; i < argc; ++i)
347
        {
348
          if (i > 0)
349
            strcat (result, " ");
350
          strcat (result, argv[i]);
351
        }
352
    }
353
 
354
  return result;
355
}
356
 
357
 
358
/* This function detects whether or not a '&' character (indicating
359
   background execution) has been added as *the last* of the arguments ARGS
360
   of a command. If it has, it removes it and returns 1. Otherwise it
361
   does nothing and returns 0. */
362
static int
363
strip_bg_char (char **args)
364
{
365
  char *p = NULL;
366
 
367
  p = strchr (*args, '&');
368
 
369
  if (p)
370
    {
371
      if (p == (*args + strlen (*args) - 1))
372
        {
373
          if (strlen (*args) > 1)
374
            {
375
              do
376
                p--;
377
              while (*p == ' ' || *p == '\t');
378
              *(p + 1) = '\0';
379
            }
380
          else
381
            *args = 0;
382
          return 1;
383
        }
384
    }
385
  return 0;
386
}
387
 
388
/* Common actions to take after creating any sort of inferior, by any
389
   means (running, attaching, connecting, et cetera).  The target
390
   should be stopped.  */
391
 
392
void
393
post_create_inferior (struct target_ops *target, int from_tty)
394
{
395
  /* Be sure we own the terminal in case write operations are performed.  */
396
  target_terminal_ours ();
397
 
398
  /* If the target hasn't taken care of this already, do it now.
399
     Targets which need to access registers during to_open,
400
     to_create_inferior, or to_attach should do it earlier; but many
401
     don't need to.  */
402
  target_find_description ();
403
 
404
  /* Now that we know the register layout, retrieve current PC.  */
405
  stop_pc = regcache_read_pc (get_current_regcache ());
406
 
407
  if (exec_bfd)
408
    {
409
      /* Create the hooks to handle shared library load and unload
410
         events.  */
411
#ifdef SOLIB_CREATE_INFERIOR_HOOK
412
      SOLIB_CREATE_INFERIOR_HOOK (PIDGET (inferior_ptid));
413
#else
414
      solib_create_inferior_hook (from_tty);
415
#endif
416
    }
417
 
418
  /* If the solist is global across processes, there's no need to
419
     refetch it here.  */
420
  if (exec_bfd && !gdbarch_has_global_solist (target_gdbarch))
421
    {
422
      /* Sometimes the platform-specific hook loads initial shared
423
         libraries, and sometimes it doesn't.  If it doesn't FROM_TTY will be
424
         incorrectly 0 but such solib targets should be fixed anyway.  If we
425
         made all the inferior hook methods consistent, this call could be
426
         removed.  Call it only after the solib target has been initialized by
427
         solib_create_inferior_hook.  */
428
 
429
#ifdef SOLIB_ADD
430
      SOLIB_ADD (NULL, 0, target, auto_solib_add);
431
#else
432
      solib_add (NULL, 0, target, auto_solib_add);
433
#endif
434
    }
435
 
436
  /* If the user sets watchpoints before execution having started,
437
     then she gets software watchpoints, because GDB can't know which
438
     target will end up being pushed, or if it supports hardware
439
     watchpoints or not.  breakpoint_re_set takes care of promoting
440
     watchpoints to hardware watchpoints if possible, however, if this
441
     new inferior doesn't load shared libraries or we don't pull in
442
     symbols from any other source on this target/arch,
443
     breakpoint_re_set is never called.  Call it now so that software
444
     watchpoints get a chance to be promoted to hardware watchpoints
445
     if the now pushed target supports hardware watchpoints.  */
446
  breakpoint_re_set ();
447
 
448
  observer_notify_inferior_created (target, from_tty);
449
}
450
 
451
/* Kill the inferior if already running.  This function is designed
452
   to be called when we are about to start the execution of the program
453
   from the beginning.  Ask the user to confirm that he wants to restart
454
   the program being debugged when FROM_TTY is non-null.  */
455
 
456
static void
457
kill_if_already_running (int from_tty)
458
{
459
  if (! ptid_equal (inferior_ptid, null_ptid) && target_has_execution)
460
    {
461
      /* Bail out before killing the program if we will not be able to
462
         restart it.  */
463
      target_require_runnable ();
464
 
465
      if (from_tty
466
          && !query (_("The program being debugged has been started already.\n\
467
Start it from the beginning? ")))
468
        error (_("Program not restarted."));
469
      target_kill ();
470
    }
471
}
472
 
473
/* Implement the "run" command. If TBREAK_AT_MAIN is set, then insert
474
   a temporary breakpoint at the begining of the main program before
475
   running the program.  */
476
 
477
static void
478
run_command_1 (char *args, int from_tty, int tbreak_at_main)
479
{
480
  char *exec_file;
481
  struct cleanup *old_chain;
482
  ptid_t ptid;
483
 
484
  dont_repeat ();
485
 
486
  kill_if_already_running (from_tty);
487
 
488
  init_wait_for_inferior ();
489
  clear_breakpoint_hit_counts ();
490
 
491
  /* Clean up any leftovers from other runs.  Some other things from
492
     this function should probably be moved into target_pre_inferior.  */
493
  target_pre_inferior (from_tty);
494
 
495
  /* The comment here used to read, "The exec file is re-read every
496
     time we do a generic_mourn_inferior, so we just have to worry
497
     about the symbol file."  The `generic_mourn_inferior' function
498
     gets called whenever the program exits.  However, suppose the
499
     program exits, and *then* the executable file changes?  We need
500
     to check again here.  Since reopen_exec_file doesn't do anything
501
     if the timestamp hasn't changed, I don't see the harm.  */
502
  reopen_exec_file ();
503
  reread_symbols ();
504
 
505
  /* Insert the temporary breakpoint if a location was specified.  */
506
  if (tbreak_at_main)
507
    tbreak_command (main_name (), 0);
508
 
509
  exec_file = (char *) get_exec_file (0);
510
 
511
  if (non_stop && !target_supports_non_stop ())
512
    error (_("The target does not support running in non-stop mode."));
513
 
514
  /* We keep symbols from add-symbol-file, on the grounds that the
515
     user might want to add some symbols before running the program
516
     (right?).  But sometimes (dynamic loading where the user manually
517
     introduces the new symbols with add-symbol-file), the code which
518
     the symbols describe does not persist between runs.  Currently
519
     the user has to manually nuke all symbols between runs if they
520
     want them to go away (PR 2207).  This is probably reasonable.  */
521
 
522
  if (!args)
523
    {
524
      if (target_can_async_p ())
525
        async_disable_stdin ();
526
    }
527
  else
528
    {
529
      int async_exec = strip_bg_char (&args);
530
 
531
      /* If we get a request for running in the bg but the target
532
         doesn't support it, error out. */
533
      if (async_exec && !target_can_async_p ())
534
        error (_("Asynchronous execution not supported on this target."));
535
 
536
      /* If we don't get a request of running in the bg, then we need
537
         to simulate synchronous (fg) execution. */
538
      if (!async_exec && target_can_async_p ())
539
        {
540
          /* Simulate synchronous execution */
541
          async_disable_stdin ();
542
        }
543
 
544
      /* If there were other args, beside '&', process them. */
545
      if (args)
546
        set_inferior_args (args);
547
    }
548
 
549
  if (from_tty)
550
    {
551
      ui_out_field_string (uiout, NULL, "Starting program");
552
      ui_out_text (uiout, ": ");
553
      if (exec_file)
554
        ui_out_field_string (uiout, "execfile", exec_file);
555
      ui_out_spaces (uiout, 1);
556
      /* We call get_inferior_args() because we might need to compute
557
         the value now.  */
558
      ui_out_field_string (uiout, "infargs", get_inferior_args ());
559
      ui_out_text (uiout, "\n");
560
      ui_out_flush (uiout);
561
    }
562
 
563
  /* We call get_inferior_args() because we might need to compute
564
     the value now.  */
565
  target_create_inferior (exec_file, get_inferior_args (),
566
                          environ_vector (current_inferior ()->environment), from_tty);
567
 
568
  /* We're starting off a new process.  When we get out of here, in
569
     non-stop mode, finish the state of all threads of that process,
570
     but leave other threads alone, as they may be stopped in internal
571
     events --- the frontend shouldn't see them as stopped.  In
572
     all-stop, always finish the state of all threads, as we may be
573
     resuming more than just the new process.  */
574
  if (non_stop)
575
    ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
576
  else
577
    ptid = minus_one_ptid;
578
  old_chain = make_cleanup (finish_thread_state_cleanup, &ptid);
579
 
580
  /* Pass zero for FROM_TTY, because at this point the "run" command
581
     has done its thing; now we are setting up the running program.  */
582
  post_create_inferior (&current_target, 0);
583
 
584
  /* Start the target running.  Do not use -1 continuation as it would skip
585
     breakpoint right at the entry point.  */
586
  proceed (regcache_read_pc (get_current_regcache ()), TARGET_SIGNAL_0, 0);
587
 
588
  /* Since there was no error, there's no need to finish the thread
589
     states here.  */
590
  discard_cleanups (old_chain);
591
}
592
 
593
static void
594
run_command (char *args, int from_tty)
595
{
596
  run_command_1 (args, from_tty, 0);
597
}
598
 
599
static void
600
run_no_args_command (char *args, int from_tty)
601
{
602
  set_inferior_args ("");
603
}
604
 
605
 
606
/* Start the execution of the program up until the beginning of the main
607
   program.  */
608
 
609
static void
610
start_command (char *args, int from_tty)
611
{
612
  /* Some languages such as Ada need to search inside the program
613
     minimal symbols for the location where to put the temporary
614
     breakpoint before starting.  */
615
  if (!have_minimal_symbols ())
616
    error (_("No symbol table loaded.  Use the \"file\" command."));
617
 
618
  /* Run the program until reaching the main procedure...  */
619
  run_command_1 (args, from_tty, 1);
620
}
621
 
622
static int
623
proceed_thread_callback (struct thread_info *thread, void *arg)
624
{
625
  /* We go through all threads individually instead of compressing
626
     into a single target `resume_all' request, because some threads
627
     may be stopped in internal breakpoints/events, or stopped waiting
628
     for its turn in the displaced stepping queue (that is, they are
629
     running && !executing).  The target side has no idea about why
630
     the thread is stopped, so a `resume_all' command would resume too
631
     much.  If/when GDB gains a way to tell the target `hold this
632
     thread stopped until I say otherwise', then we can optimize
633
     this.  */
634
  if (!is_stopped (thread->ptid))
635
    return 0;
636
 
637
  switch_to_thread (thread->ptid);
638
  clear_proceed_status ();
639
  proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 0);
640
  return 0;
641
}
642
 
643
void
644
ensure_valid_thread (void)
645
{
646
  if (ptid_equal (inferior_ptid, null_ptid)
647
      || is_exited (inferior_ptid))
648
    error (_("\
649
Cannot execute this command without a live selected thread."));
650
}
651
 
652
/* If the user is looking at trace frames, any resumption of execution
653
   is likely to mix up recorded and live target data. So simply
654
   disallow those commands.  */
655
 
656
void
657
ensure_not_tfind_mode (void)
658
{
659
  if (get_traceframe_number () >= 0)
660
    error (_("\
661
Cannot execute this command while looking at trace frames."));
662
}
663
 
664
void
665
continue_1 (int all_threads)
666
{
667
  ERROR_NO_INFERIOR;
668
  ensure_not_tfind_mode ();
669
 
670
  if (non_stop && all_threads)
671
    {
672
      /* Don't error out if the current thread is running, because
673
         there may be other stopped threads.  */
674
      struct cleanup *old_chain;
675
 
676
      /* Backup current thread and selected frame.  */
677
      old_chain = make_cleanup_restore_current_thread ();
678
 
679
      iterate_over_threads (proceed_thread_callback, NULL);
680
 
681
      /* Restore selected ptid.  */
682
      do_cleanups (old_chain);
683
    }
684
  else
685
    {
686
      ensure_valid_thread ();
687
      ensure_not_running ();
688
      clear_proceed_status ();
689
      proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 0);
690
    }
691
}
692
 
693
/* continue [-a] [proceed-count] [&]  */
694
void
695
continue_command (char *args, int from_tty)
696
{
697
  int async_exec = 0;
698
  int all_threads = 0;
699
  ERROR_NO_INFERIOR;
700
 
701
  /* Find out whether we must run in the background. */
702
  if (args != NULL)
703
    async_exec = strip_bg_char (&args);
704
 
705
  /* If we must run in the background, but the target can't do it,
706
     error out. */
707
  if (async_exec && !target_can_async_p ())
708
    error (_("Asynchronous execution not supported on this target."));
709
 
710
  /* If we are not asked to run in the bg, then prepare to run in the
711
     foreground, synchronously. */
712
  if (!async_exec && target_can_async_p ())
713
    {
714
      /* Simulate synchronous execution */
715
      async_disable_stdin ();
716
    }
717
 
718
  if (args != NULL)
719
    {
720
      if (strncmp (args, "-a", sizeof ("-a") - 1) == 0)
721
        {
722
          all_threads = 1;
723
          args += sizeof ("-a") - 1;
724
          if (*args == '\0')
725
            args = NULL;
726
        }
727
    }
728
 
729
  if (!non_stop && all_threads)
730
    error (_("`-a' is meaningless in all-stop mode."));
731
 
732
  if (args != NULL && all_threads)
733
    error (_("\
734
Can't resume all threads and specify proceed count simultaneously."));
735
 
736
  /* If we have an argument left, set proceed count of breakpoint we
737
     stopped at.  */
738
  if (args != NULL)
739
    {
740
      bpstat bs = NULL;
741
      int num, stat;
742
      int stopped = 0;
743
      struct thread_info *tp;
744
 
745
      if (non_stop)
746
        tp = find_thread_ptid (inferior_ptid);
747
      else
748
        {
749
          ptid_t last_ptid;
750
          struct target_waitstatus ws;
751
 
752
          get_last_target_status (&last_ptid, &ws);
753
          tp = find_thread_ptid (last_ptid);
754
        }
755
      if (tp != NULL)
756
        bs = tp->stop_bpstat;
757
 
758
      while ((stat = bpstat_num (&bs, &num)) != 0)
759
        if (stat > 0)
760
          {
761
            set_ignore_count (num,
762
                              parse_and_eval_long (args) - 1,
763
                              from_tty);
764
            /* set_ignore_count prints a message ending with a period.
765
               So print two spaces before "Continuing.".  */
766
            if (from_tty)
767
              printf_filtered ("  ");
768
            stopped = 1;
769
          }
770
 
771
      if (!stopped && from_tty)
772
        {
773
          printf_filtered
774
            ("Not stopped at any breakpoint; argument ignored.\n");
775
        }
776
    }
777
 
778
  if (from_tty)
779
    printf_filtered (_("Continuing.\n"));
780
 
781
  continue_1 (all_threads);
782
}
783
 
784
/* Record the starting point of a "step" or "next" command.  */
785
 
786
static void
787
set_step_frame (void)
788
{
789
  struct symtab_and_line sal;
790
 
791
  find_frame_sal (get_current_frame (), &sal);
792
  set_step_info (get_current_frame (), sal);
793
}
794
 
795
/* Step until outside of current statement.  */
796
 
797
static void
798
step_command (char *count_string, int from_tty)
799
{
800
  step_1 (0, 0, count_string);
801
}
802
 
803
/* Likewise, but skip over subroutine calls as if single instructions.  */
804
 
805
static void
806
next_command (char *count_string, int from_tty)
807
{
808
  step_1 (1, 0, count_string);
809
}
810
 
811
/* Likewise, but step only one instruction.  */
812
 
813
void
814
stepi_command (char *count_string, int from_tty)
815
{
816
  step_1 (0, 1, count_string);
817
}
818
 
819
void
820
nexti_command (char *count_string, int from_tty)
821
{
822
  step_1 (1, 1, count_string);
823
}
824
 
825
static void
826
delete_longjmp_breakpoint_cleanup (void *arg)
827
{
828
  int thread = * (int *) arg;
829
  delete_longjmp_breakpoint (thread);
830
}
831
 
832
static void
833
step_1 (int skip_subroutines, int single_inst, char *count_string)
834
{
835
  int count = 1;
836
  struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
837
  int async_exec = 0;
838
  int thread = -1;
839
 
840
  ERROR_NO_INFERIOR;
841
  ensure_not_tfind_mode ();
842
  ensure_valid_thread ();
843
  ensure_not_running ();
844
 
845
  if (count_string)
846
    async_exec = strip_bg_char (&count_string);
847
 
848
  /* If we get a request for running in the bg but the target
849
     doesn't support it, error out. */
850
  if (async_exec && !target_can_async_p ())
851
    error (_("Asynchronous execution not supported on this target."));
852
 
853
  /* If we don't get a request of running in the bg, then we need
854
     to simulate synchronous (fg) execution. */
855
  if (!async_exec && target_can_async_p ())
856
    {
857
      /* Simulate synchronous execution */
858
      async_disable_stdin ();
859
    }
860
 
861
  count = count_string ? parse_and_eval_long (count_string) : 1;
862
 
863
  if (!single_inst || skip_subroutines)         /* leave si command alone */
864
    {
865
      if (in_thread_list (inferior_ptid))
866
        thread = pid_to_thread_id (inferior_ptid);
867
 
868
      set_longjmp_breakpoint (thread);
869
 
870
      make_cleanup (delete_longjmp_breakpoint_cleanup, &thread);
871
    }
872
 
873
  /* In synchronous case, all is well; each step_once call will step once.  */
874
  if (!target_can_async_p ())
875
    {
876
      for (; count > 0; count--)
877
        {
878
          struct thread_info *tp;
879
 
880
          step_once (skip_subroutines, single_inst, count, thread);
881
 
882
          if (target_has_execution
883
              && !ptid_equal (inferior_ptid, null_ptid))
884
            tp = inferior_thread ();
885
          else
886
            tp = NULL;
887
 
888
          if (!tp || !tp->stop_step || !tp->step_multi)
889
            {
890
              /* If we stopped for some reason that is not stepping
891
                 there are no further steps to make.  */
892
              if (tp)
893
                tp->step_multi = 0;
894
              break;
895
            }
896
        }
897
 
898
      do_cleanups (cleanups);
899
    }
900
  else
901
    {
902
      /* In the case of an asynchronous target things get complicated;
903
         do only one step for now, before returning control to the
904
         event loop.  Let the continuation figure out how many other
905
         steps we need to do, and handle them one at the time, through
906
         step_once.  */
907
      step_once (skip_subroutines, single_inst, count, thread);
908
 
909
      /* We are running, and the continuation is installed.  It will
910
         disable the longjmp breakpoint as appropriate.  */
911
      discard_cleanups (cleanups);
912
    }
913
}
914
 
915
struct step_1_continuation_args
916
{
917
  int count;
918
  int skip_subroutines;
919
  int single_inst;
920
  int thread;
921
};
922
 
923
/* Called after we are done with one step operation, to check whether
924
   we need to step again, before we print the prompt and return control
925
   to the user. If count is > 1, we will need to do one more call to
926
   proceed(), via step_once(). Basically it is like step_once and
927
   step_1_continuation are co-recursive. */
928
static void
929
step_1_continuation (void *args)
930
{
931
  struct step_1_continuation_args *a = args;
932
 
933
  if (target_has_execution)
934
    {
935
      struct thread_info *tp;
936
 
937
      tp = inferior_thread ();
938
      if (tp->step_multi && tp->stop_step)
939
        {
940
          /* There are more steps to make, and we did stop due to
941
             ending a stepping range.  Do another step.  */
942
          step_once (a->skip_subroutines, a->single_inst,
943
                     a->count - 1, a->thread);
944
          return;
945
        }
946
      tp->step_multi = 0;
947
    }
948
 
949
  /* We either stopped for some reason that is not stepping, or there
950
     are no further steps to make.  Cleanup.  */
951
  if (!a->single_inst || a->skip_subroutines)
952
    delete_longjmp_breakpoint (a->thread);
953
}
954
 
955
/* Do just one step operation.  This is useful to implement the 'step
956
   n' kind of commands.  In case of asynchronous targets, we will have
957
   to set up a continuation to be done after the target stops (after
958
   this one step).  For synch targets, the caller handles further
959
   stepping.  */
960
 
961
static void
962
step_once (int skip_subroutines, int single_inst, int count, int thread)
963
{
964
  struct frame_info *frame = get_current_frame ();
965
 
966
  if (count > 0)
967
    {
968
      /* Don't assume THREAD is a valid thread id.  It is set to -1 if
969
         the longjmp breakpoint was not required.  Use the
970
         INFERIOR_PTID thread instead, which is the same thread when
971
         THREAD is set.  */
972
      struct thread_info *tp = inferior_thread ();
973
 
974
      clear_proceed_status ();
975
      set_step_frame ();
976
 
977
      if (!single_inst)
978
        {
979
          CORE_ADDR pc;
980
 
981
          /* Step at an inlined function behaves like "down".  */
982
          if (!skip_subroutines && !single_inst
983
              && inline_skipped_frames (inferior_ptid))
984
            {
985
              step_into_inline_frame (inferior_ptid);
986
              if (count > 1)
987
                step_once (skip_subroutines, single_inst, count - 1, thread);
988
              else
989
                /* Pretend that we've stopped.  */
990
                normal_stop ();
991
              return;
992
            }
993
 
994
          pc = get_frame_pc (frame);
995
          find_pc_line_pc_range (pc,
996
                                 &tp->step_range_start, &tp->step_range_end);
997
 
998
          /* If we have no line info, switch to stepi mode.  */
999
          if (tp->step_range_end == 0 && step_stop_if_no_debug)
1000
            tp->step_range_start = tp->step_range_end = 1;
1001
          else if (tp->step_range_end == 0)
1002
            {
1003
              char *name;
1004
 
1005
              if (find_pc_partial_function (pc, &name,
1006
                                            &tp->step_range_start,
1007
                                            &tp->step_range_end) == 0)
1008
                error (_("Cannot find bounds of current function"));
1009
 
1010
              target_terminal_ours ();
1011
              printf_filtered (_("\
1012
Single stepping until exit from function %s,\n\
1013
which has no line number information.\n"), name);
1014
            }
1015
        }
1016
      else
1017
        {
1018
          /* Say we are stepping, but stop after one insn whatever it does.  */
1019
          tp->step_range_start = tp->step_range_end = 1;
1020
          if (!skip_subroutines)
1021
            /* It is stepi.
1022
               Don't step over function calls, not even to functions lacking
1023
               line numbers.  */
1024
            tp->step_over_calls = STEP_OVER_NONE;
1025
        }
1026
 
1027
      if (skip_subroutines)
1028
        tp->step_over_calls = STEP_OVER_ALL;
1029
 
1030
      tp->step_multi = (count > 1);
1031
      proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 1);
1032
 
1033
      /* For async targets, register a continuation to do any
1034
         additional steps.  For sync targets, the caller will handle
1035
         further stepping.  */
1036
      if (target_can_async_p ())
1037
        {
1038
          struct step_1_continuation_args *args;
1039
 
1040
          args = xmalloc (sizeof (*args));
1041
          args->skip_subroutines = skip_subroutines;
1042
          args->single_inst = single_inst;
1043
          args->count = count;
1044
          args->thread = thread;
1045
 
1046
          add_intermediate_continuation (tp, step_1_continuation, args, xfree);
1047
        }
1048
    }
1049
}
1050
 
1051
 
1052
/* Continue program at specified address.  */
1053
 
1054
static void
1055
jump_command (char *arg, int from_tty)
1056
{
1057
  struct gdbarch *gdbarch = get_current_arch ();
1058
  CORE_ADDR addr;
1059
  struct symtabs_and_lines sals;
1060
  struct symtab_and_line sal;
1061
  struct symbol *fn;
1062
  struct symbol *sfn;
1063
  int async_exec = 0;
1064
 
1065
  ERROR_NO_INFERIOR;
1066
  ensure_not_tfind_mode ();
1067
  ensure_valid_thread ();
1068
  ensure_not_running ();
1069
 
1070
  /* Find out whether we must run in the background. */
1071
  if (arg != NULL)
1072
    async_exec = strip_bg_char (&arg);
1073
 
1074
  /* If we must run in the background, but the target can't do it,
1075
     error out. */
1076
  if (async_exec && !target_can_async_p ())
1077
    error (_("Asynchronous execution not supported on this target."));
1078
 
1079
  if (!arg)
1080
    error_no_arg (_("starting address"));
1081
 
1082
  sals = decode_line_spec_1 (arg, 1);
1083
  if (sals.nelts != 1)
1084
    {
1085
      error (_("Unreasonable jump request"));
1086
    }
1087
 
1088
  sal = sals.sals[0];
1089
  xfree (sals.sals);
1090
 
1091
  if (sal.symtab == 0 && sal.pc == 0)
1092
    error (_("No source file has been specified."));
1093
 
1094
  resolve_sal_pc (&sal);        /* May error out */
1095
 
1096
  /* See if we are trying to jump to another function. */
1097
  fn = get_frame_function (get_current_frame ());
1098
  sfn = find_pc_function (sal.pc);
1099
  if (fn != NULL && sfn != fn)
1100
    {
1101
      if (!query (_("Line %d is not in `%s'.  Jump anyway? "), sal.line,
1102
                  SYMBOL_PRINT_NAME (fn)))
1103
        {
1104
          error (_("Not confirmed."));
1105
          /* NOTREACHED */
1106
        }
1107
    }
1108
 
1109
  if (sfn != NULL)
1110
    {
1111
      fixup_symbol_section (sfn, 0);
1112
      if (section_is_overlay (SYMBOL_OBJ_SECTION (sfn)) &&
1113
          !section_is_mapped (SYMBOL_OBJ_SECTION (sfn)))
1114
        {
1115
          if (!query (_("WARNING!!!  Destination is in unmapped overlay!  Jump anyway? ")))
1116
            {
1117
              error (_("Not confirmed."));
1118
              /* NOTREACHED */
1119
            }
1120
        }
1121
    }
1122
 
1123
  addr = sal.pc;
1124
 
1125
  if (from_tty)
1126
    {
1127
      printf_filtered (_("Continuing at "));
1128
      fputs_filtered (paddress (gdbarch, addr), gdb_stdout);
1129
      printf_filtered (".\n");
1130
    }
1131
 
1132
  /* If we are not asked to run in the bg, then prepare to run in the
1133
     foreground, synchronously. */
1134
  if (!async_exec && target_can_async_p ())
1135
    {
1136
      /* Simulate synchronous execution */
1137
      async_disable_stdin ();
1138
    }
1139
 
1140
  clear_proceed_status ();
1141
  proceed (addr, TARGET_SIGNAL_0, 0);
1142
}
1143
 
1144
 
1145
/* Go to line or address in current procedure */
1146
static void
1147
go_command (char *line_no, int from_tty)
1148
{
1149
  if (line_no == (char *) NULL || !*line_no)
1150
    printf_filtered (_("Usage: go <location>\n"));
1151
  else
1152
    {
1153
      tbreak_command (line_no, from_tty);
1154
      jump_command (line_no, from_tty);
1155
    }
1156
}
1157
 
1158
 
1159
/* Continue program giving it specified signal.  */
1160
 
1161
static void
1162
signal_command (char *signum_exp, int from_tty)
1163
{
1164
  enum target_signal oursig;
1165
  int async_exec = 0;
1166
 
1167
  dont_repeat ();               /* Too dangerous.  */
1168
  ERROR_NO_INFERIOR;
1169
  ensure_not_tfind_mode ();
1170
  ensure_valid_thread ();
1171
  ensure_not_running ();
1172
 
1173
  /* Find out whether we must run in the background.  */
1174
  if (signum_exp != NULL)
1175
    async_exec = strip_bg_char (&signum_exp);
1176
 
1177
  /* If we must run in the background, but the target can't do it,
1178
     error out.  */
1179
  if (async_exec && !target_can_async_p ())
1180
    error (_("Asynchronous execution not supported on this target."));
1181
 
1182
  /* If we are not asked to run in the bg, then prepare to run in the
1183
     foreground, synchronously.  */
1184
  if (!async_exec && target_can_async_p ())
1185
    {
1186
      /* Simulate synchronous execution.  */
1187
      async_disable_stdin ();
1188
    }
1189
 
1190
  if (!signum_exp)
1191
    error_no_arg (_("signal number"));
1192
 
1193
  /* It would be even slicker to make signal names be valid expressions,
1194
     (the type could be "enum $signal" or some such), then the user could
1195
     assign them to convenience variables.  */
1196
  oursig = target_signal_from_name (signum_exp);
1197
 
1198
  if (oursig == TARGET_SIGNAL_UNKNOWN)
1199
    {
1200
      /* No, try numeric.  */
1201
      int num = parse_and_eval_long (signum_exp);
1202
 
1203
      if (num == 0)
1204
        oursig = TARGET_SIGNAL_0;
1205
      else
1206
        oursig = target_signal_from_command (num);
1207
    }
1208
 
1209
  if (from_tty)
1210
    {
1211
      if (oursig == TARGET_SIGNAL_0)
1212
        printf_filtered (_("Continuing with no signal.\n"));
1213
      else
1214
        printf_filtered (_("Continuing with signal %s.\n"),
1215
                         target_signal_to_name (oursig));
1216
    }
1217
 
1218
  clear_proceed_status ();
1219
  proceed ((CORE_ADDR) -1, oursig, 0);
1220
}
1221
 
1222
/* Proceed until we reach a different source line with pc greater than
1223
   our current one or exit the function.  We skip calls in both cases.
1224
 
1225
   Note that eventually this command should probably be changed so
1226
   that only source lines are printed out when we hit the breakpoint
1227
   we set.  This may involve changes to wait_for_inferior and the
1228
   proceed status code.  */
1229
 
1230
static void
1231
until_next_command (int from_tty)
1232
{
1233
  struct frame_info *frame;
1234
  CORE_ADDR pc;
1235
  struct symbol *func;
1236
  struct symtab_and_line sal;
1237
  struct thread_info *tp = inferior_thread ();
1238
 
1239
  clear_proceed_status ();
1240
  set_step_frame ();
1241
 
1242
  frame = get_current_frame ();
1243
 
1244
  /* Step until either exited from this function or greater
1245
     than the current line (if in symbolic section) or pc (if
1246
     not). */
1247
 
1248
  pc = get_frame_pc (frame);
1249
  func = find_pc_function (pc);
1250
 
1251
  if (!func)
1252
    {
1253
      struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (pc);
1254
 
1255
      if (msymbol == NULL)
1256
        error (_("Execution is not within a known function."));
1257
 
1258
      tp->step_range_start = SYMBOL_VALUE_ADDRESS (msymbol);
1259
      tp->step_range_end = pc;
1260
    }
1261
  else
1262
    {
1263
      sal = find_pc_line (pc, 0);
1264
 
1265
      tp->step_range_start = BLOCK_START (SYMBOL_BLOCK_VALUE (func));
1266
      tp->step_range_end = sal.end;
1267
    }
1268
 
1269
  tp->step_over_calls = STEP_OVER_ALL;
1270
 
1271
  tp->step_multi = 0;            /* Only one call to proceed */
1272
 
1273
  proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 1);
1274
}
1275
 
1276
static void
1277
until_command (char *arg, int from_tty)
1278
{
1279
  int async_exec = 0;
1280
 
1281
  ERROR_NO_INFERIOR;
1282
  ensure_not_tfind_mode ();
1283
  ensure_valid_thread ();
1284
  ensure_not_running ();
1285
 
1286
  /* Find out whether we must run in the background. */
1287
  if (arg != NULL)
1288
    async_exec = strip_bg_char (&arg);
1289
 
1290
  /* If we must run in the background, but the target can't do it,
1291
     error out. */
1292
  if (async_exec && !target_can_async_p ())
1293
    error (_("Asynchronous execution not supported on this target."));
1294
 
1295
  /* If we are not asked to run in the bg, then prepare to run in the
1296
     foreground, synchronously. */
1297
  if (!async_exec && target_can_async_p ())
1298
    {
1299
      /* Simulate synchronous execution */
1300
      async_disable_stdin ();
1301
    }
1302
 
1303
  if (arg)
1304
    until_break_command (arg, from_tty, 0);
1305
  else
1306
    until_next_command (from_tty);
1307
}
1308
 
1309
static void
1310
advance_command (char *arg, int from_tty)
1311
{
1312
  int async_exec = 0;
1313
 
1314
  ERROR_NO_INFERIOR;
1315
  ensure_not_tfind_mode ();
1316
  ensure_valid_thread ();
1317
  ensure_not_running ();
1318
 
1319
  if (arg == NULL)
1320
    error_no_arg (_("a location"));
1321
 
1322
  /* Find out whether we must run in the background.  */
1323
  if (arg != NULL)
1324
    async_exec = strip_bg_char (&arg);
1325
 
1326
  /* If we must run in the background, but the target can't do it,
1327
     error out.  */
1328
  if (async_exec && !target_can_async_p ())
1329
    error (_("Asynchronous execution not supported on this target."));
1330
 
1331
  /* If we are not asked to run in the bg, then prepare to run in the
1332
     foreground, synchronously.  */
1333
  if (!async_exec && target_can_async_p ())
1334
    {
1335
      /* Simulate synchronous execution.  */
1336
      async_disable_stdin ();
1337
    }
1338
 
1339
  until_break_command (arg, from_tty, 1);
1340
}
1341
 
1342
/* Print the result of a function at the end of a 'finish' command.  */
1343
 
1344
static void
1345
print_return_value (struct type *func_type, struct type *value_type)
1346
{
1347
  struct gdbarch *gdbarch = get_regcache_arch (stop_registers);
1348
  struct cleanup *old_chain;
1349
  struct ui_stream *stb;
1350
  struct value *value;
1351
 
1352
  CHECK_TYPEDEF (value_type);
1353
  gdb_assert (TYPE_CODE (value_type) != TYPE_CODE_VOID);
1354
 
1355
  /* FIXME: 2003-09-27: When returning from a nested inferior function
1356
     call, it's possible (with no help from the architecture vector)
1357
     to locate and return/print a "struct return" value.  This is just
1358
     a more complicated case of what is already being done in in the
1359
     inferior function call code.  In fact, when inferior function
1360
     calls are made async, this will likely be made the norm.  */
1361
 
1362
  switch (gdbarch_return_value (gdbarch, func_type, value_type,
1363
                                NULL, NULL, NULL))
1364
    {
1365
    case RETURN_VALUE_REGISTER_CONVENTION:
1366
    case RETURN_VALUE_ABI_RETURNS_ADDRESS:
1367
    case RETURN_VALUE_ABI_PRESERVES_ADDRESS:
1368
      value = allocate_value (value_type);
1369
      gdbarch_return_value (gdbarch, func_type, value_type, stop_registers,
1370
                            value_contents_raw (value), NULL);
1371
      break;
1372
    case RETURN_VALUE_STRUCT_CONVENTION:
1373
      value = NULL;
1374
      break;
1375
    default:
1376
      internal_error (__FILE__, __LINE__, _("bad switch"));
1377
    }
1378
 
1379
  if (value)
1380
    {
1381
      struct value_print_options opts;
1382
 
1383
      /* Print it.  */
1384
      stb = ui_out_stream_new (uiout);
1385
      old_chain = make_cleanup_ui_out_stream_delete (stb);
1386
      ui_out_text (uiout, "Value returned is ");
1387
      ui_out_field_fmt (uiout, "gdb-result-var", "$%d",
1388
                        record_latest_value (value));
1389
      ui_out_text (uiout, " = ");
1390
      get_raw_print_options (&opts);
1391
      value_print (value, stb->stream, &opts);
1392
      ui_out_field_stream (uiout, "return-value", stb);
1393
      ui_out_text (uiout, "\n");
1394
      do_cleanups (old_chain);
1395
    }
1396
  else
1397
    {
1398
      ui_out_text (uiout, "Value returned has type: ");
1399
      ui_out_field_string (uiout, "return-type", TYPE_NAME (value_type));
1400
      ui_out_text (uiout, ".");
1401
      ui_out_text (uiout, " Cannot determine contents\n");
1402
    }
1403
}
1404
 
1405
/* Stuff that needs to be done by the finish command after the target
1406
   has stopped.  In asynchronous mode, we wait for the target to stop
1407
   in the call to poll or select in the event loop, so it is
1408
   impossible to do all the stuff as part of the finish_command
1409
   function itself.  The only chance we have to complete this command
1410
   is in fetch_inferior_event, which is called by the event loop as
1411
   soon as it detects that the target has stopped. This function is
1412
   called via the cmd_continuation pointer.  */
1413
 
1414
struct finish_command_continuation_args
1415
{
1416
  struct breakpoint *breakpoint;
1417
  struct symbol *function;
1418
};
1419
 
1420
static void
1421
finish_command_continuation (void *arg)
1422
{
1423
  struct finish_command_continuation_args *a = arg;
1424
  struct thread_info *tp = NULL;
1425
  bpstat bs = NULL;
1426
 
1427
  if (!ptid_equal (inferior_ptid, null_ptid)
1428
      && target_has_execution
1429
      && is_stopped (inferior_ptid))
1430
    {
1431
      tp = inferior_thread ();
1432
      bs = tp->stop_bpstat;
1433
    }
1434
 
1435
  if (bpstat_find_breakpoint (bs, a->breakpoint) != NULL
1436
      && a->function != NULL)
1437
    {
1438
      struct type *value_type;
1439
 
1440
      value_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (a->function));
1441
      if (!value_type)
1442
        internal_error (__FILE__, __LINE__,
1443
                        _("finish_command: function has no target type"));
1444
 
1445
      if (TYPE_CODE (value_type) != TYPE_CODE_VOID)
1446
        {
1447
          volatile struct gdb_exception ex;
1448
 
1449
          TRY_CATCH (ex, RETURN_MASK_ALL)
1450
            {
1451
              /* print_return_value can throw an exception in some
1452
                 circumstances.  We need to catch this so that we still
1453
                 delete the breakpoint.  */
1454
              print_return_value (SYMBOL_TYPE (a->function), value_type);
1455
            }
1456
          if (ex.reason < 0)
1457
            exception_print (gdb_stdout, ex);
1458
        }
1459
    }
1460
 
1461
  /* We suppress normal call of normal_stop observer and do it here so
1462
     that the *stopped notification includes the return value.  */
1463
  if (bs != NULL && tp->proceed_to_finish)
1464
    observer_notify_normal_stop (bs, 1 /* print frame */);
1465
  delete_breakpoint (a->breakpoint);
1466
}
1467
 
1468
static void
1469
finish_command_continuation_free_arg (void *arg)
1470
{
1471
  xfree (arg);
1472
}
1473
 
1474
/* finish_backward -- helper function for finish_command.  */
1475
 
1476
static void
1477
finish_backward (struct symbol *function)
1478
{
1479
  struct symtab_and_line sal;
1480
  struct thread_info *tp = inferior_thread ();
1481
  struct breakpoint *breakpoint;
1482
  struct cleanup *old_chain;
1483
  CORE_ADDR pc;
1484
  CORE_ADDR func_addr;
1485
  int back_up;
1486
 
1487
  pc = get_frame_pc (get_current_frame ());
1488
 
1489
  if (find_pc_partial_function (pc, NULL, &func_addr, NULL) == 0)
1490
    internal_error (__FILE__, __LINE__,
1491
                    _("Finish: couldn't find function."));
1492
 
1493
  sal = find_pc_line (func_addr, 0);
1494
 
1495
  /* We don't need a return value.  */
1496
  tp->proceed_to_finish = 0;
1497
  /* Special case: if we're sitting at the function entry point,
1498
     then all we need to do is take a reverse singlestep.  We
1499
     don't need to set a breakpoint, and indeed it would do us
1500
     no good to do so.
1501
 
1502
     Note that this can only happen at frame #0, since there's
1503
     no way that a function up the stack can have a return address
1504
     that's equal to its entry point.  */
1505
 
1506
  if (sal.pc != pc)
1507
    {
1508
      struct frame_info *frame = get_selected_frame (NULL);
1509
      struct gdbarch *gdbarch = get_frame_arch (frame);
1510
 
1511
      /* Set breakpoint and continue.  */
1512
      breakpoint =
1513
        set_momentary_breakpoint (gdbarch, sal,
1514
                                  get_stack_frame_id (frame),
1515
                                  bp_breakpoint);
1516
      /* Tell the breakpoint to keep quiet.  We won't be done
1517
         until we've done another reverse single-step.  */
1518
      make_breakpoint_silent (breakpoint);
1519
      old_chain = make_cleanup_delete_breakpoint (breakpoint);
1520
      proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 0);
1521
      /* We will be stopped when proceed returns.  */
1522
      back_up = bpstat_find_breakpoint (tp->stop_bpstat, breakpoint) != NULL;
1523
      do_cleanups (old_chain);
1524
    }
1525
  else
1526
    back_up = 1;
1527
  if (back_up)
1528
    {
1529
      /* If in fact we hit the step-resume breakpoint (and not
1530
         some other breakpoint), then we're almost there --
1531
         we just need to back up by one more single-step.  */
1532
      tp->step_range_start = tp->step_range_end = 1;
1533
      proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 1);
1534
    }
1535
  return;
1536
}
1537
 
1538
/* finish_forward -- helper function for finish_command.  */
1539
 
1540
static void
1541
finish_forward (struct symbol *function, struct frame_info *frame)
1542
{
1543
  struct gdbarch *gdbarch = get_frame_arch (frame);
1544
  struct symtab_and_line sal;
1545
  struct thread_info *tp = inferior_thread ();
1546
  struct breakpoint *breakpoint;
1547
  struct cleanup *old_chain;
1548
  struct finish_command_continuation_args *cargs;
1549
 
1550
  sal = find_pc_line (get_frame_pc (frame), 0);
1551
  sal.pc = get_frame_pc (frame);
1552
 
1553
  breakpoint = set_momentary_breakpoint (gdbarch, sal,
1554
                                         get_stack_frame_id (frame),
1555
                                         bp_finish);
1556
 
1557
  old_chain = make_cleanup_delete_breakpoint (breakpoint);
1558
 
1559
  tp->proceed_to_finish = 1;    /* We want stop_registers, please...  */
1560
  cargs = xmalloc (sizeof (*cargs));
1561
 
1562
  cargs->breakpoint = breakpoint;
1563
  cargs->function = function;
1564
  add_continuation (tp, finish_command_continuation, cargs,
1565
                    finish_command_continuation_free_arg);
1566
  proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 0);
1567
 
1568
  discard_cleanups (old_chain);
1569
  if (!target_can_async_p ())
1570
    do_all_continuations ();
1571
}
1572
 
1573
/* "finish": Set a temporary breakpoint at the place the selected
1574
   frame will return to, then continue.  */
1575
 
1576
static void
1577
finish_command (char *arg, int from_tty)
1578
{
1579
  struct frame_info *frame;
1580
  struct symbol *function;
1581
 
1582
  int async_exec = 0;
1583
 
1584
  ERROR_NO_INFERIOR;
1585
  ensure_not_tfind_mode ();
1586
  ensure_valid_thread ();
1587
  ensure_not_running ();
1588
 
1589
  /* Find out whether we must run in the background.  */
1590
  if (arg != NULL)
1591
    async_exec = strip_bg_char (&arg);
1592
 
1593
  /* If we must run in the background, but the target can't do it,
1594
     error out.  */
1595
  if (async_exec && !target_can_async_p ())
1596
    error (_("Asynchronous execution not supported on this target."));
1597
 
1598
  /* Don't try to async in reverse.  */
1599
  if (async_exec && execution_direction == EXEC_REVERSE)
1600
    error (_("Asynchronous 'finish' not supported in reverse."));
1601
 
1602
  /* If we are not asked to run in the bg, then prepare to run in the
1603
     foreground, synchronously.  */
1604
  if (!async_exec && target_can_async_p ())
1605
    {
1606
      /* Simulate synchronous execution.  */
1607
      async_disable_stdin ();
1608
    }
1609
 
1610
  if (arg)
1611
    error (_("The \"finish\" command does not take any arguments."));
1612
 
1613
  frame = get_prev_frame (get_selected_frame (_("No selected frame.")));
1614
  if (frame == 0)
1615
    error (_("\"finish\" not meaningful in the outermost frame."));
1616
 
1617
  clear_proceed_status ();
1618
 
1619
  /* Finishing from an inline frame is completely different.  We don't
1620
     try to show the "return value" - no way to locate it.  So we do
1621
     not need a completion.  */
1622
  if (get_frame_type (get_selected_frame (_("No selected frame.")))
1623
      == INLINE_FRAME)
1624
    {
1625
      /* Claim we are stepping in the calling frame.  An empty step
1626
         range means that we will stop once we aren't in a function
1627
         called by that frame.  We don't use the magic "1" value for
1628
         step_range_end, because then infrun will think this is nexti,
1629
         and not step over the rest of this inlined function call.  */
1630
      struct thread_info *tp = inferior_thread ();
1631
      struct symtab_and_line empty_sal;
1632
 
1633
      init_sal (&empty_sal);
1634
      set_step_info (frame, empty_sal);
1635
      tp->step_range_start = tp->step_range_end = get_frame_pc (frame);
1636
      tp->step_over_calls = STEP_OVER_ALL;
1637
 
1638
      /* Print info on the selected frame, including level number but not
1639
         source.  */
1640
      if (from_tty)
1641
        {
1642
          printf_filtered (_("Run till exit from "));
1643
          print_stack_frame (get_selected_frame (NULL), 1, LOCATION);
1644
        }
1645
 
1646
      proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 1);
1647
      return;
1648
    }
1649
 
1650
  /* Find the function we will return from.  */
1651
 
1652
  function = find_pc_function (get_frame_pc (get_selected_frame (NULL)));
1653
 
1654
  /* Print info on the selected frame, including level number but not
1655
     source.  */
1656
  if (from_tty)
1657
    {
1658
      if (execution_direction == EXEC_REVERSE)
1659
        printf_filtered (_("Run back to call of "));
1660
      else
1661
        printf_filtered (_("Run till exit from "));
1662
 
1663
      print_stack_frame (get_selected_frame (NULL), 1, LOCATION);
1664
    }
1665
 
1666
  if (execution_direction == EXEC_REVERSE)
1667
    finish_backward (function);
1668
  else
1669
    finish_forward (function, frame);
1670
}
1671
 
1672
 
1673
static void
1674
program_info (char *args, int from_tty)
1675
{
1676
  bpstat bs;
1677
  int num, stat;
1678
  struct thread_info *tp;
1679
  ptid_t ptid;
1680
 
1681
  if (!target_has_execution)
1682
    {
1683
      printf_filtered (_("The program being debugged is not being run.\n"));
1684
      return;
1685
    }
1686
 
1687
  if (non_stop)
1688
    ptid = inferior_ptid;
1689
  else
1690
    {
1691
      struct target_waitstatus ws;
1692
 
1693
      get_last_target_status (&ptid, &ws);
1694
    }
1695
 
1696
  if (ptid_equal (ptid, null_ptid) || is_exited (ptid))
1697
    error (_("Invalid selected thread."));
1698
  else if (is_running (ptid))
1699
    error (_("Selected thread is running."));
1700
 
1701
  tp = find_thread_ptid (ptid);
1702
  bs = tp->stop_bpstat;
1703
  stat = bpstat_num (&bs, &num);
1704
 
1705
  target_files_info ();
1706
  printf_filtered (_("Program stopped at %s.\n"),
1707
                   paddress (target_gdbarch, stop_pc));
1708
  if (tp->stop_step)
1709
    printf_filtered (_("It stopped after being stepped.\n"));
1710
  else if (stat != 0)
1711
    {
1712
      /* There may be several breakpoints in the same place, so this
1713
         isn't as strange as it seems.  */
1714
      while (stat != 0)
1715
        {
1716
          if (stat < 0)
1717
            {
1718
              printf_filtered (_("\
1719
It stopped at a breakpoint that has since been deleted.\n"));
1720
            }
1721
          else
1722
            printf_filtered (_("It stopped at breakpoint %d.\n"), num);
1723
          stat = bpstat_num (&bs, &num);
1724
        }
1725
    }
1726
  else if (tp->stop_signal != TARGET_SIGNAL_0)
1727
    {
1728
      printf_filtered (_("It stopped with signal %s, %s.\n"),
1729
                       target_signal_to_name (tp->stop_signal),
1730
                       target_signal_to_string (tp->stop_signal));
1731
    }
1732
 
1733
  if (!from_tty)
1734
    {
1735
      printf_filtered (_("\
1736
Type \"info stack\" or \"info registers\" for more information.\n"));
1737
    }
1738
}
1739
 
1740
static void
1741
environment_info (char *var, int from_tty)
1742
{
1743
  if (var)
1744
    {
1745
      char *val = get_in_environ (current_inferior ()->environment, var);
1746
 
1747
      if (val)
1748
        {
1749
          puts_filtered (var);
1750
          puts_filtered (" = ");
1751
          puts_filtered (val);
1752
          puts_filtered ("\n");
1753
        }
1754
      else
1755
        {
1756
          puts_filtered ("Environment variable \"");
1757
          puts_filtered (var);
1758
          puts_filtered ("\" not defined.\n");
1759
        }
1760
    }
1761
  else
1762
    {
1763
      char **vector = environ_vector (current_inferior ()->environment);
1764
 
1765
      while (*vector)
1766
        {
1767
          puts_filtered (*vector++);
1768
          puts_filtered ("\n");
1769
        }
1770
    }
1771
}
1772
 
1773
static void
1774
set_environment_command (char *arg, int from_tty)
1775
{
1776
  char *p, *val, *var;
1777
  int nullset = 0;
1778
 
1779
  if (arg == 0)
1780
    error_no_arg (_("environment variable and value"));
1781
 
1782
  /* Find seperation between variable name and value */
1783
  p = (char *) strchr (arg, '=');
1784
  val = (char *) strchr (arg, ' ');
1785
 
1786
  if (p != 0 && val != 0)
1787
    {
1788
      /* We have both a space and an equals.  If the space is before the
1789
         equals, walk forward over the spaces til we see a nonspace
1790
         (possibly the equals). */
1791
      if (p > val)
1792
        while (*val == ' ')
1793
          val++;
1794
 
1795
      /* Now if the = is after the char following the spaces,
1796
         take the char following the spaces.  */
1797
      if (p > val)
1798
        p = val - 1;
1799
    }
1800
  else if (val != 0 && p == 0)
1801
    p = val;
1802
 
1803
  if (p == arg)
1804
    error_no_arg (_("environment variable to set"));
1805
 
1806
  if (p == 0 || p[1] == 0)
1807
    {
1808
      nullset = 1;
1809
      if (p == 0)
1810
        p = arg + strlen (arg); /* So that savestring below will work */
1811
    }
1812
  else
1813
    {
1814
      /* Not setting variable value to null */
1815
      val = p + 1;
1816
      while (*val == ' ' || *val == '\t')
1817
        val++;
1818
    }
1819
 
1820
  while (p != arg && (p[-1] == ' ' || p[-1] == '\t'))
1821
    p--;
1822
 
1823
  var = savestring (arg, p - arg);
1824
  if (nullset)
1825
    {
1826
      printf_filtered (_("\
1827
Setting environment variable \"%s\" to null value.\n"),
1828
                       var);
1829
      set_in_environ (current_inferior ()->environment, var, "");
1830
    }
1831
  else
1832
    set_in_environ (current_inferior ()->environment, var, val);
1833
  xfree (var);
1834
}
1835
 
1836
static void
1837
unset_environment_command (char *var, int from_tty)
1838
{
1839
  if (var == 0)
1840
    {
1841
      /* If there is no argument, delete all environment variables.
1842
         Ask for confirmation if reading from the terminal.  */
1843
      if (!from_tty || query (_("Delete all environment variables? ")))
1844
        {
1845
          free_environ (current_inferior ()->environment);
1846
          current_inferior ()->environment = make_environ ();
1847
        }
1848
    }
1849
  else
1850
    unset_in_environ (current_inferior ()->environment, var);
1851
}
1852
 
1853
/* Handle the execution path (PATH variable) */
1854
 
1855
static const char path_var_name[] = "PATH";
1856
 
1857
static void
1858
path_info (char *args, int from_tty)
1859
{
1860
  puts_filtered ("Executable and object file path: ");
1861
  puts_filtered (get_in_environ (current_inferior ()->environment, path_var_name));
1862
  puts_filtered ("\n");
1863
}
1864
 
1865
/* Add zero or more directories to the front of the execution path.  */
1866
 
1867
static void
1868
path_command (char *dirname, int from_tty)
1869
{
1870
  char *exec_path;
1871
  char *env;
1872
 
1873
  dont_repeat ();
1874
  env = get_in_environ (current_inferior ()->environment, path_var_name);
1875
  /* Can be null if path is not set */
1876
  if (!env)
1877
    env = "";
1878
  exec_path = xstrdup (env);
1879
  mod_path (dirname, &exec_path);
1880
  set_in_environ (current_inferior ()->environment, path_var_name, exec_path);
1881
  xfree (exec_path);
1882
  if (from_tty)
1883
    path_info ((char *) NULL, from_tty);
1884
}
1885
 
1886
 
1887
/* Print out the machine register regnum. If regnum is -1, print all
1888
   registers (print_all == 1) or all non-float and non-vector
1889
   registers (print_all == 0).
1890
 
1891
   For most machines, having all_registers_info() print the
1892
   register(s) one per line is good enough.  If a different format is
1893
   required, (eg, for MIPS or Pyramid 90x, which both have lots of
1894
   regs), or there is an existing convention for showing all the
1895
   registers, define the architecture method PRINT_REGISTERS_INFO to
1896
   provide that format.  */
1897
 
1898
void
1899
default_print_registers_info (struct gdbarch *gdbarch,
1900
                              struct ui_file *file,
1901
                              struct frame_info *frame,
1902
                              int regnum, int print_all)
1903
{
1904
  int i;
1905
  const int numregs = gdbarch_num_regs (gdbarch)
1906
                      + gdbarch_num_pseudo_regs (gdbarch);
1907
  gdb_byte buffer[MAX_REGISTER_SIZE];
1908
 
1909
  for (i = 0; i < numregs; i++)
1910
    {
1911
      /* Decide between printing all regs, non-float / vector regs, or
1912
         specific reg.  */
1913
      if (regnum == -1)
1914
        {
1915
          if (print_all)
1916
            {
1917
              if (!gdbarch_register_reggroup_p (gdbarch, i, all_reggroup))
1918
                continue;
1919
            }
1920
          else
1921
            {
1922
              if (!gdbarch_register_reggroup_p (gdbarch, i, general_reggroup))
1923
                continue;
1924
            }
1925
        }
1926
      else
1927
        {
1928
          if (i != regnum)
1929
            continue;
1930
        }
1931
 
1932
      /* If the register name is empty, it is undefined for this
1933
         processor, so don't display anything.  */
1934
      if (gdbarch_register_name (gdbarch, i) == NULL
1935
          || *(gdbarch_register_name (gdbarch, i)) == '\0')
1936
        continue;
1937
 
1938
      fputs_filtered (gdbarch_register_name (gdbarch, i), file);
1939
      print_spaces_filtered (15 - strlen (gdbarch_register_name
1940
                                          (gdbarch, i)), file);
1941
 
1942
      /* Get the data in raw format.  */
1943
      if (! frame_register_read (frame, i, buffer))
1944
        {
1945
          fprintf_filtered (file, "*value not available*\n");
1946
          continue;
1947
        }
1948
 
1949
      /* If virtual format is floating, print it that way, and in raw
1950
         hex.  */
1951
      if (TYPE_CODE (register_type (gdbarch, i)) == TYPE_CODE_FLT
1952
          || TYPE_CODE (register_type (gdbarch, i)) == TYPE_CODE_DECFLOAT)
1953
        {
1954
          int j;
1955
          struct value_print_options opts;
1956
 
1957
          get_user_print_options (&opts);
1958
          opts.deref_ref = 1;
1959
          val_print (register_type (gdbarch, i), buffer, 0, 0,
1960
                     file, 0, NULL, &opts, current_language);
1961
 
1962
          fprintf_filtered (file, "\t(raw 0x");
1963
          for (j = 0; j < register_size (gdbarch, i); j++)
1964
            {
1965
              int idx;
1966
 
1967
              if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
1968
                idx = j;
1969
              else
1970
                idx = register_size (gdbarch, i) - 1 - j;
1971
              fprintf_filtered (file, "%02x", (unsigned char) buffer[idx]);
1972
            }
1973
          fprintf_filtered (file, ")");
1974
        }
1975
      else
1976
        {
1977
          struct value_print_options opts;
1978
 
1979
          /* Print the register in hex.  */
1980
          get_formatted_print_options (&opts, 'x');
1981
          opts.deref_ref = 1;
1982
          val_print (register_type (gdbarch, i), buffer, 0, 0,
1983
                     file, 0, NULL, &opts, current_language);
1984
          /* If not a vector register, print it also according to its
1985
             natural format.  */
1986
          if (TYPE_VECTOR (register_type (gdbarch, i)) == 0)
1987
            {
1988
              get_user_print_options (&opts);
1989
              opts.deref_ref = 1;
1990
              fprintf_filtered (file, "\t");
1991
              val_print (register_type (gdbarch, i), buffer, 0, 0,
1992
                         file, 0, NULL, &opts, current_language);
1993
            }
1994
        }
1995
 
1996
      fprintf_filtered (file, "\n");
1997
    }
1998
}
1999
 
2000
void
2001
registers_info (char *addr_exp, int fpregs)
2002
{
2003
  struct frame_info *frame;
2004
  struct gdbarch *gdbarch;
2005
 
2006
  if (!target_has_registers)
2007
    error (_("The program has no registers now."));
2008
  frame = get_selected_frame (NULL);
2009
  gdbarch = get_frame_arch (frame);
2010
 
2011
  if (!addr_exp)
2012
    {
2013
      gdbarch_print_registers_info (gdbarch, gdb_stdout,
2014
                                    frame, -1, fpregs);
2015
      return;
2016
    }
2017
 
2018
  while (*addr_exp != '\0')
2019
    {
2020
      char *start;
2021
      const char *end;
2022
 
2023
      /* Keep skipping leading white space.  */
2024
      if (isspace ((*addr_exp)))
2025
        {
2026
          addr_exp++;
2027
          continue;
2028
        }
2029
 
2030
      /* Discard any leading ``$''.  Check that there is something
2031
         resembling a register following it.  */
2032
      if (addr_exp[0] == '$')
2033
        addr_exp++;
2034
      if (isspace ((*addr_exp)) || (*addr_exp) == '\0')
2035
        error (_("Missing register name"));
2036
 
2037
      /* Find the start/end of this register name/num/group.  */
2038
      start = addr_exp;
2039
      while ((*addr_exp) != '\0' && !isspace ((*addr_exp)))
2040
        addr_exp++;
2041
      end = addr_exp;
2042
 
2043
      /* Figure out what we've found and display it.  */
2044
 
2045
      /* A register name?  */
2046
      {
2047
        int regnum = user_reg_map_name_to_regnum (gdbarch, start, end - start);
2048
 
2049
        if (regnum >= 0)
2050
          {
2051
            /* User registers lie completely outside of the range of
2052
               normal registers.  Catch them early so that the target
2053
               never sees them.  */
2054
            if (regnum >= gdbarch_num_regs (gdbarch)
2055
                          + gdbarch_num_pseudo_regs (gdbarch))
2056
              {
2057
                struct value_print_options opts;
2058
                struct value *val = value_of_user_reg (regnum, frame);
2059
 
2060
                printf_filtered ("%s: ", start);
2061
                get_formatted_print_options (&opts, 'x');
2062
                print_scalar_formatted (value_contents (val),
2063
                                        check_typedef (value_type (val)),
2064
                                        &opts, 0, gdb_stdout);
2065
                printf_filtered ("\n");
2066
              }
2067
            else
2068
              gdbarch_print_registers_info (gdbarch, gdb_stdout,
2069
                                            frame, regnum, fpregs);
2070
            continue;
2071
          }
2072
      }
2073
 
2074
      /* A register group?  */
2075
      {
2076
        struct reggroup *group;
2077
 
2078
        for (group = reggroup_next (gdbarch, NULL);
2079
             group != NULL;
2080
             group = reggroup_next (gdbarch, group))
2081
          {
2082
            /* Don't bother with a length check.  Should the user
2083
               enter a short register group name, go with the first
2084
               group that matches.  */
2085
            if (strncmp (start, reggroup_name (group), end - start) == 0)
2086
              break;
2087
          }
2088
        if (group != NULL)
2089
          {
2090
            int regnum;
2091
 
2092
            for (regnum = 0;
2093
                 regnum < gdbarch_num_regs (gdbarch)
2094
                          + gdbarch_num_pseudo_regs (gdbarch);
2095
                 regnum++)
2096
              {
2097
                if (gdbarch_register_reggroup_p (gdbarch, regnum, group))
2098
                  gdbarch_print_registers_info (gdbarch,
2099
                                                gdb_stdout, frame,
2100
                                                regnum, fpregs);
2101
              }
2102
            continue;
2103
          }
2104
      }
2105
 
2106
      /* Nothing matched.  */
2107
      error (_("Invalid register `%.*s'"), (int) (end - start), start);
2108
    }
2109
}
2110
 
2111
void
2112
all_registers_info (char *addr_exp, int from_tty)
2113
{
2114
  registers_info (addr_exp, 1);
2115
}
2116
 
2117
static void
2118
nofp_registers_info (char *addr_exp, int from_tty)
2119
{
2120
  registers_info (addr_exp, 0);
2121
}
2122
 
2123
static void
2124
print_vector_info (struct ui_file *file,
2125
                   struct frame_info *frame, const char *args)
2126
{
2127
  struct gdbarch *gdbarch = get_frame_arch (frame);
2128
 
2129
  if (gdbarch_print_vector_info_p (gdbarch))
2130
    gdbarch_print_vector_info (gdbarch, file, frame, args);
2131
  else
2132
    {
2133
      int regnum;
2134
      int printed_something = 0;
2135
 
2136
      for (regnum = 0;
2137
           regnum < gdbarch_num_regs (gdbarch)
2138
                    + gdbarch_num_pseudo_regs (gdbarch);
2139
           regnum++)
2140
        {
2141
          if (gdbarch_register_reggroup_p (gdbarch, regnum, vector_reggroup))
2142
            {
2143
              printed_something = 1;
2144
              gdbarch_print_registers_info (gdbarch, file, frame, regnum, 1);
2145
            }
2146
        }
2147
      if (!printed_something)
2148
        fprintf_filtered (file, "No vector information\n");
2149
    }
2150
}
2151
 
2152
static void
2153
vector_info (char *args, int from_tty)
2154
{
2155
  if (!target_has_registers)
2156
    error (_("The program has no registers now."));
2157
 
2158
  print_vector_info (gdb_stdout, get_selected_frame (NULL), args);
2159
}
2160
 
2161
/* Kill the inferior process.  Make us have no inferior.  */
2162
 
2163
static void
2164
kill_command (char *arg, int from_tty)
2165
{
2166
  /* FIXME:  This should not really be inferior_ptid (or target_has_execution).
2167
     It should be a distinct flag that indicates that a target is active, cuz
2168
     some targets don't have processes! */
2169
 
2170
  if (ptid_equal (inferior_ptid, null_ptid))
2171
    error (_("The program is not being run."));
2172
  if (!query (_("Kill the program being debugged? ")))
2173
    error (_("Not confirmed."));
2174
  target_kill ();
2175
 
2176
  /* If we still have other inferiors to debug, then don't mess with
2177
     with their threads.  */
2178
  if (!have_inferiors ())
2179
    {
2180
      init_thread_list ();              /* Destroy thread info */
2181
 
2182
      /* Killing off the inferior can leave us with a core file.  If
2183
         so, print the state we are left in.  */
2184
      if (target_has_stack)
2185
        {
2186
          printf_filtered (_("In %s,\n"), target_longname);
2187
          print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
2188
        }
2189
    }
2190
  bfd_cache_close_all ();
2191
}
2192
 
2193
/* Used in `attach&' command.  ARG is a point to an integer
2194
   representing a process id.  Proceed threads of this process iff
2195
   they stopped due to debugger request, and when they did, they
2196
   reported a clean stop (TARGET_SIGNAL_0).  Do not proceed threads
2197
   that have been explicitly been told to stop.  */
2198
 
2199
static int
2200
proceed_after_attach_callback (struct thread_info *thread,
2201
                               void *arg)
2202
{
2203
  int pid = * (int *) arg;
2204
 
2205
  if (ptid_get_pid (thread->ptid) == pid
2206
      && !is_exited (thread->ptid)
2207
      && !is_executing (thread->ptid)
2208
      && !thread->stop_requested
2209
      && thread->stop_signal == TARGET_SIGNAL_0)
2210
    {
2211
      switch_to_thread (thread->ptid);
2212
      clear_proceed_status ();
2213
      proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 0);
2214
    }
2215
 
2216
  return 0;
2217
}
2218
 
2219
static void
2220
proceed_after_attach (int pid)
2221
{
2222
  /* Don't error out if the current thread is running, because
2223
     there may be other stopped threads.  */
2224
  struct cleanup *old_chain;
2225
 
2226
  /* Backup current thread and selected frame.  */
2227
  old_chain = make_cleanup_restore_current_thread ();
2228
 
2229
  iterate_over_threads (proceed_after_attach_callback, &pid);
2230
 
2231
  /* Restore selected ptid.  */
2232
  do_cleanups (old_chain);
2233
}
2234
 
2235
/*
2236
 * TODO:
2237
 * Should save/restore the tty state since it might be that the
2238
 * program to be debugged was started on this tty and it wants
2239
 * the tty in some state other than what we want.  If it's running
2240
 * on another terminal or without a terminal, then saving and
2241
 * restoring the tty state is a harmless no-op.
2242
 * This only needs to be done if we are attaching to a process.
2243
 */
2244
 
2245
/*
2246
   attach_command --
2247
   takes a program started up outside of gdb and ``attaches'' to it.
2248
   This stops it cold in its tracks and allows us to start debugging it.
2249
   and wait for the trace-trap that results from attaching.  */
2250
 
2251
static void
2252
attach_command_post_wait (char *args, int from_tty, int async_exec)
2253
{
2254
  char *exec_file;
2255
  char *full_exec_path = NULL;
2256
  struct inferior *inferior;
2257
 
2258
  inferior = current_inferior ();
2259
  inferior->stop_soon = NO_STOP_QUIETLY;
2260
 
2261
  /* If no exec file is yet known, try to determine it from the
2262
     process itself.  */
2263
  exec_file = (char *) get_exec_file (0);
2264
  if (!exec_file)
2265
    {
2266
      exec_file = target_pid_to_exec_file (PIDGET (inferior_ptid));
2267
      if (exec_file)
2268
        {
2269
          /* It's possible we don't have a full path, but rather just a
2270
             filename.  Some targets, such as HP-UX, don't provide the
2271
             full path, sigh.
2272
 
2273
             Attempt to qualify the filename against the source path.
2274
             (If that fails, we'll just fall back on the original
2275
             filename.  Not much more we can do...)
2276
           */
2277
          if (!source_full_path_of (exec_file, &full_exec_path))
2278
            full_exec_path = xstrdup (exec_file);
2279
 
2280
          exec_file_attach (full_exec_path, from_tty);
2281
          symbol_file_add_main (full_exec_path, from_tty);
2282
        }
2283
    }
2284
  else
2285
    {
2286
      reopen_exec_file ();
2287
      reread_symbols ();
2288
    }
2289
 
2290
  /* Take any necessary post-attaching actions for this platform.  */
2291
  target_post_attach (PIDGET (inferior_ptid));
2292
 
2293
  post_create_inferior (&current_target, from_tty);
2294
 
2295
  /* Install inferior's terminal modes.  */
2296
  target_terminal_inferior ();
2297
 
2298
  if (async_exec)
2299
    {
2300
      /* The user requested an `attach&', so be sure to leave threads
2301
         that didn't get a signal running.  */
2302
 
2303
      /* Immediatelly resume all suspended threads of this inferior,
2304
         and this inferior only.  This should have no effect on
2305
         already running threads.  If a thread has been stopped with a
2306
         signal, leave it be.  */
2307
      if (non_stop)
2308
        proceed_after_attach (inferior->pid);
2309
      else
2310
        {
2311
          if (inferior_thread ()->stop_signal == TARGET_SIGNAL_0)
2312
            {
2313
              clear_proceed_status ();
2314
              proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 0);
2315
            }
2316
        }
2317
    }
2318
  else
2319
    {
2320
      /* The user requested a plain `attach', so be sure to leave
2321
         the inferior stopped.  */
2322
 
2323
      if (target_can_async_p ())
2324
        async_enable_stdin ();
2325
 
2326
      /* At least the current thread is already stopped.  */
2327
 
2328
      /* In all-stop, by definition, all threads have to be already
2329
         stopped at this point.  In non-stop, however, although the
2330
         selected thread is stopped, others may still be executing.
2331
         Be sure to explicitly stop all threads of the process.  This
2332
         should have no effect on already stopped threads.  */
2333
      if (non_stop)
2334
        target_stop (pid_to_ptid (inferior->pid));
2335
 
2336
      /* Tell the user/frontend where we're stopped.  */
2337
      normal_stop ();
2338
      if (deprecated_attach_hook)
2339
        deprecated_attach_hook ();
2340
    }
2341
}
2342
 
2343
struct attach_command_continuation_args
2344
{
2345
  char *args;
2346
  int from_tty;
2347
  int async_exec;
2348
};
2349
 
2350
static void
2351
attach_command_continuation (void *args)
2352
{
2353
  struct attach_command_continuation_args *a = args;
2354
 
2355
  attach_command_post_wait (a->args, a->from_tty, a->async_exec);
2356
}
2357
 
2358
static void
2359
attach_command_continuation_free_args (void *args)
2360
{
2361
  struct attach_command_continuation_args *a = args;
2362
 
2363
  xfree (a->args);
2364
  xfree (a);
2365
}
2366
 
2367
void
2368
attach_command (char *args, int from_tty)
2369
{
2370
  int async_exec = 0;
2371
  struct cleanup *back_to = make_cleanup (null_cleanup, NULL);
2372
 
2373
  dont_repeat ();               /* Not for the faint of heart */
2374
 
2375
  if (gdbarch_has_global_solist (target_gdbarch))
2376
    /* Don't complain if all processes share the same symbol
2377
       space.  */
2378
    ;
2379
  else if (target_has_execution)
2380
    {
2381
      if (query (_("A program is being debugged already.  Kill it? ")))
2382
        target_kill ();
2383
      else
2384
        error (_("Not killed."));
2385
    }
2386
 
2387
  /* Clean up any leftovers from other runs.  Some other things from
2388
     this function should probably be moved into target_pre_inferior.  */
2389
  target_pre_inferior (from_tty);
2390
 
2391
  if (non_stop && !target_supports_non_stop ())
2392
    error (_("Cannot attach to this target in non-stop mode"));
2393
 
2394
  if (args)
2395
    {
2396
      async_exec = strip_bg_char (&args);
2397
 
2398
      /* If we get a request for running in the bg but the target
2399
         doesn't support it, error out. */
2400
      if (async_exec && !target_can_async_p ())
2401
        error (_("Asynchronous execution not supported on this target."));
2402
    }
2403
 
2404
  /* If we don't get a request of running in the bg, then we need
2405
     to simulate synchronous (fg) execution.  */
2406
  if (!async_exec && target_can_async_p ())
2407
    {
2408
      /* Simulate synchronous execution */
2409
      async_disable_stdin ();
2410
      make_cleanup ((make_cleanup_ftype *)async_enable_stdin, NULL);
2411
    }
2412
 
2413
  target_attach (args, from_tty);
2414
 
2415
  /* Set up the "saved terminal modes" of the inferior
2416
     based on what modes we are starting it with.  */
2417
  target_terminal_init ();
2418
 
2419
  /* Set up execution context to know that we should return from
2420
     wait_for_inferior as soon as the target reports a stop.  */
2421
  init_wait_for_inferior ();
2422
  clear_proceed_status ();
2423
 
2424
  if (non_stop)
2425
    {
2426
      /* If we find that the current thread isn't stopped, explicitly
2427
         do so now, because we're going to install breakpoints and
2428
         poke at memory.  */
2429
 
2430
      if (async_exec)
2431
        /* The user requested an `attach&'; stop just one thread.  */
2432
        target_stop (inferior_ptid);
2433
      else
2434
        /* The user requested an `attach', so stop all threads of this
2435
           inferior.  */
2436
        target_stop (pid_to_ptid (ptid_get_pid (inferior_ptid)));
2437
    }
2438
 
2439
  /* Some system don't generate traps when attaching to inferior.
2440
     E.g. Mach 3 or GNU hurd.  */
2441
  if (!target_attach_no_wait)
2442
    {
2443
      struct inferior *inferior = current_inferior ();
2444
 
2445
      /* Careful here. See comments in inferior.h.  Basically some
2446
         OSes don't ignore SIGSTOPs on continue requests anymore.  We
2447
         need a way for handle_inferior_event to reset the stop_signal
2448
         variable after an attach, and this is what
2449
         STOP_QUIETLY_NO_SIGSTOP is for.  */
2450
      inferior->stop_soon = STOP_QUIETLY_NO_SIGSTOP;
2451
 
2452
      if (target_can_async_p ())
2453
        {
2454
          /* sync_execution mode.  Wait for stop.  */
2455
          struct attach_command_continuation_args *a;
2456
 
2457
          a = xmalloc (sizeof (*a));
2458
          a->args = xstrdup (args);
2459
          a->from_tty = from_tty;
2460
          a->async_exec = async_exec;
2461
          add_inferior_continuation (attach_command_continuation, a,
2462
                                     attach_command_continuation_free_args);
2463
          discard_cleanups (back_to);
2464
          return;
2465
        }
2466
 
2467
      wait_for_inferior (0);
2468
    }
2469
 
2470
  attach_command_post_wait (args, from_tty, async_exec);
2471
  discard_cleanups (back_to);
2472
}
2473
 
2474
/* We had just found out that the target was already attached to an
2475
   inferior.  PTID points at a thread of this new inferior, that is
2476
   the most likely to be stopped right now, but not necessarily so.
2477
   The new inferior is assumed to be already added to the inferior
2478
   list at this point.  If LEAVE_RUNNING, then leave the threads of
2479
   this inferior running, except those we've explicitly seen reported
2480
   as stopped.  */
2481
 
2482
void
2483
notice_new_inferior (ptid_t ptid, int leave_running, int from_tty)
2484
{
2485
  struct cleanup* old_chain;
2486
  int async_exec;
2487
 
2488
  old_chain = make_cleanup (null_cleanup, NULL);
2489
 
2490
  /* If in non-stop, leave threads as running as they were.  If
2491
     they're stopped for some reason other than us telling it to, the
2492
     target reports a signal != TARGET_SIGNAL_0.  We don't try to
2493
     resume threads with such a stop signal.  */
2494
  async_exec = non_stop;
2495
 
2496
  if (!ptid_equal (inferior_ptid, null_ptid))
2497
    make_cleanup_restore_current_thread ();
2498
 
2499
  switch_to_thread (ptid);
2500
 
2501
  /* When we "notice" a new inferior we need to do all the things we
2502
     would normally do if we had just attached to it.  */
2503
 
2504
  if (is_executing (inferior_ptid))
2505
    {
2506
      struct inferior *inferior = current_inferior ();
2507
 
2508
      /* We're going to install breakpoints, and poke at memory,
2509
         ensure that the inferior is stopped for a moment while we do
2510
         that.  */
2511
      target_stop (inferior_ptid);
2512
 
2513
      inferior->stop_soon = STOP_QUIETLY_REMOTE;
2514
 
2515
      /* Wait for stop before proceeding.  */
2516
      if (target_can_async_p ())
2517
        {
2518
          struct attach_command_continuation_args *a;
2519
 
2520
          a = xmalloc (sizeof (*a));
2521
          a->args = xstrdup ("");
2522
          a->from_tty = from_tty;
2523
          a->async_exec = async_exec;
2524
          add_inferior_continuation (attach_command_continuation, a,
2525
                                     attach_command_continuation_free_args);
2526
 
2527
          do_cleanups (old_chain);
2528
          return;
2529
        }
2530
      else
2531
        wait_for_inferior (0);
2532
    }
2533
 
2534
  async_exec = leave_running;
2535
  attach_command_post_wait ("" /* args */, from_tty, async_exec);
2536
 
2537
  do_cleanups (old_chain);
2538
}
2539
 
2540
/*
2541
 * detach_command --
2542
 * takes a program previously attached to and detaches it.
2543
 * The program resumes execution and will no longer stop
2544
 * on signals, etc.  We better not have left any breakpoints
2545
 * in the program or it'll die when it hits one.  For this
2546
 * to work, it may be necessary for the process to have been
2547
 * previously attached.  It *might* work if the program was
2548
 * started via the normal ptrace (PTRACE_TRACEME).
2549
 */
2550
 
2551
void
2552
detach_command (char *args, int from_tty)
2553
{
2554
  dont_repeat ();               /* Not for the faint of heart.  */
2555
 
2556
  if (ptid_equal (inferior_ptid, null_ptid))
2557
    error (_("The program is not being run."));
2558
 
2559
  disconnect_tracing (from_tty);
2560
 
2561
  target_detach (args, from_tty);
2562
 
2563
  /* If the solist is global across inferiors, don't clear it when we
2564
     detach from a single inferior.  */
2565
  if (!gdbarch_has_global_solist (target_gdbarch))
2566
    no_shared_libraries (NULL, from_tty);
2567
 
2568
  /* If we still have inferiors to debug, then don't mess with their
2569
     threads.  */
2570
  if (!have_inferiors ())
2571
    init_thread_list ();
2572
 
2573
  if (deprecated_detach_hook)
2574
    deprecated_detach_hook ();
2575
}
2576
 
2577
/* Disconnect from the current target without resuming it (leaving it
2578
   waiting for a debugger).
2579
 
2580
   We'd better not have left any breakpoints in the program or the
2581
   next debugger will get confused.  Currently only supported for some
2582
   remote targets, since the normal attach mechanisms don't work on
2583
   stopped processes on some native platforms (e.g. GNU/Linux).  */
2584
 
2585
static void
2586
disconnect_command (char *args, int from_tty)
2587
{
2588
  dont_repeat ();               /* Not for the faint of heart */
2589
  target_disconnect (args, from_tty);
2590
  no_shared_libraries (NULL, from_tty);
2591
  init_thread_list ();
2592
  if (deprecated_detach_hook)
2593
    deprecated_detach_hook ();
2594
}
2595
 
2596
void
2597
interrupt_target_1 (int all_threads)
2598
{
2599
  ptid_t ptid;
2600
 
2601
  if (all_threads)
2602
    ptid = minus_one_ptid;
2603
  else
2604
    ptid = inferior_ptid;
2605
  target_stop (ptid);
2606
 
2607
  /* Tag the thread as having been explicitly requested to stop, so
2608
     other parts of gdb know not to resume this thread automatically,
2609
     if it was stopped due to an internal event.  Limit this to
2610
     non-stop mode, as when debugging a multi-threaded application in
2611
     all-stop mode, we will only get one stop event --- it's undefined
2612
     which thread will report the event.  */
2613
  if (non_stop)
2614
    set_stop_requested (ptid, 1);
2615
}
2616
 
2617
/* Stop the execution of the target while running in async mode, in
2618
   the backgound.  In all-stop, stop the whole process.  In non-stop
2619
   mode, stop the current thread only by default, or stop all threads
2620
   if the `-a' switch is used.  */
2621
 
2622
/* interrupt [-a]  */
2623
void
2624
interrupt_target_command (char *args, int from_tty)
2625
{
2626
  if (target_can_async_p ())
2627
    {
2628
      int all_threads = 0;
2629
 
2630
      dont_repeat ();           /* Not for the faint of heart */
2631
 
2632
      if (args != NULL
2633
          && strncmp (args, "-a", sizeof ("-a") - 1) == 0)
2634
        all_threads = 1;
2635
 
2636
      if (!non_stop && all_threads)
2637
        error (_("-a is meaningless in all-stop mode."));
2638
 
2639
      interrupt_target_1 (all_threads);
2640
    }
2641
}
2642
 
2643
static void
2644
print_float_info (struct ui_file *file,
2645
                  struct frame_info *frame, const char *args)
2646
{
2647
  struct gdbarch *gdbarch = get_frame_arch (frame);
2648
 
2649
  if (gdbarch_print_float_info_p (gdbarch))
2650
    gdbarch_print_float_info (gdbarch, file, frame, args);
2651
  else
2652
    {
2653
      int regnum;
2654
      int printed_something = 0;
2655
 
2656
      for (regnum = 0;
2657
           regnum < gdbarch_num_regs (gdbarch)
2658
                    + gdbarch_num_pseudo_regs (gdbarch);
2659
           regnum++)
2660
        {
2661
          if (gdbarch_register_reggroup_p (gdbarch, regnum, float_reggroup))
2662
            {
2663
              printed_something = 1;
2664
              gdbarch_print_registers_info (gdbarch, file, frame, regnum, 1);
2665
            }
2666
        }
2667
      if (!printed_something)
2668
        fprintf_filtered (file, "\
2669
No floating-point info available for this processor.\n");
2670
    }
2671
}
2672
 
2673
static void
2674
float_info (char *args, int from_tty)
2675
{
2676
  if (!target_has_registers)
2677
    error (_("The program has no registers now."));
2678
 
2679
  print_float_info (gdb_stdout, get_selected_frame (NULL), args);
2680
}
2681
 
2682
static void
2683
unset_command (char *args, int from_tty)
2684
{
2685
  printf_filtered (_("\
2686
\"unset\" must be followed by the name of an unset subcommand.\n"));
2687
  help_list (unsetlist, "unset ", -1, gdb_stdout);
2688
}
2689
 
2690
void
2691
_initialize_infcmd (void)
2692
{
2693
  struct cmd_list_element *c = NULL;
2694
 
2695
  /* add the filename of the terminal connected to inferior I/O */
2696
  add_setshow_filename_cmd ("inferior-tty", class_run,
2697
                            &inferior_io_terminal_scratch, _("\
2698
Set terminal for future runs of program being debugged."), _("\
2699
Show terminal for future runs of program being debugged."), _("\
2700
Usage: set inferior-tty /dev/pts/1"),
2701
                            set_inferior_tty_command,
2702
                            show_inferior_tty_command,
2703
                            &setlist, &showlist);
2704
  add_com_alias ("tty", "set inferior-tty", class_alias, 0);
2705
 
2706
  add_setshow_optional_filename_cmd ("args", class_run,
2707
                                     &inferior_args_scratch, _("\
2708
Set argument list to give program being debugged when it is started."), _("\
2709
Show argument list to give program being debugged when it is started."), _("\
2710
Follow this command with any number of args, to be passed to the program."),
2711
                                     set_args_command,
2712
                                     show_args_command,
2713
                                     &setlist, &showlist);
2714
 
2715
  c = add_cmd ("environment", no_class, environment_info, _("\
2716
The environment to give the program, or one variable's value.\n\
2717
With an argument VAR, prints the value of environment variable VAR to\n\
2718
give the program being debugged.  With no arguments, prints the entire\n\
2719
environment to be given to the program."), &showlist);
2720
  set_cmd_completer (c, noop_completer);
2721
 
2722
  add_prefix_cmd ("unset", no_class, unset_command,
2723
                  _("Complement to certain \"set\" commands."),
2724
                  &unsetlist, "unset ", 0, &cmdlist);
2725
 
2726
  c = add_cmd ("environment", class_run, unset_environment_command, _("\
2727
Cancel environment variable VAR for the program.\n\
2728
This does not affect the program until the next \"run\" command."),
2729
               &unsetlist);
2730
  set_cmd_completer (c, noop_completer);
2731
 
2732
  c = add_cmd ("environment", class_run, set_environment_command, _("\
2733
Set environment variable value to give the program.\n\
2734
Arguments are VAR VALUE where VAR is variable name and VALUE is value.\n\
2735
VALUES of environment variables are uninterpreted strings.\n\
2736
This does not affect the program until the next \"run\" command."),
2737
               &setlist);
2738
  set_cmd_completer (c, noop_completer);
2739
 
2740
  c = add_com ("path", class_files, path_command, _("\
2741
Add directory DIR(s) to beginning of search path for object files.\n\
2742
$cwd in the path means the current working directory.\n\
2743
This path is equivalent to the $PATH shell variable.  It is a list of\n\
2744
directories, separated by colons.  These directories are searched to find\n\
2745
fully linked executable files and separately compiled object files as needed."));
2746
  set_cmd_completer (c, filename_completer);
2747
 
2748
  c = add_cmd ("paths", no_class, path_info, _("\
2749
Current search path for finding object files.\n\
2750
$cwd in the path means the current working directory.\n\
2751
This path is equivalent to the $PATH shell variable.  It is a list of\n\
2752
directories, separated by colons.  These directories are searched to find\n\
2753
fully linked executable files and separately compiled object files as needed."),
2754
               &showlist);
2755
  set_cmd_completer (c, noop_completer);
2756
 
2757
  add_prefix_cmd ("kill", class_run, kill_command,
2758
                  _("Kill execution of program being debugged."),
2759
                  &killlist, "kill ", 0, &cmdlist);
2760
 
2761
  add_com ("attach", class_run, attach_command, _("\
2762
Attach to a process or file outside of GDB.\n\
2763
This command attaches to another target, of the same type as your last\n\
2764
\"target\" command (\"info files\" will show your target stack).\n\
2765
The command may take as argument a process id or a device file.\n\
2766
For a process id, you must have permission to send the process a signal,\n\
2767
and it must have the same effective uid as the debugger.\n\
2768
When using \"attach\" with a process id, the debugger finds the\n\
2769
program running in the process, looking first in the current working\n\
2770
directory, or (if not found there) using the source file search path\n\
2771
(see the \"directory\" command).  You can also use the \"file\" command\n\
2772
to specify the program, and to load its symbol table."));
2773
 
2774
  add_prefix_cmd ("detach", class_run, detach_command, _("\
2775
Detach a process or file previously attached.\n\
2776
If a process, it is no longer traced, and it continues its execution.  If\n\
2777
you were debugging a file, the file is closed and gdb no longer accesses it."),
2778
                  &detachlist, "detach ", 0, &cmdlist);
2779
 
2780
  add_com ("disconnect", class_run, disconnect_command, _("\
2781
Disconnect from a target.\n\
2782
The target will wait for another debugger to connect.  Not available for\n\
2783
all targets."));
2784
 
2785
  add_com ("signal", class_run, signal_command, _("\
2786
Continue program giving it signal specified by the argument.\n\
2787
An argument of \"0\" means continue program without giving it a signal."));
2788
 
2789
  add_com ("stepi", class_run, stepi_command, _("\
2790
Step one instruction exactly.\n\
2791
Argument N means do this N times (or till program stops for another reason)."));
2792
  add_com_alias ("si", "stepi", class_alias, 0);
2793
 
2794
  add_com ("nexti", class_run, nexti_command, _("\
2795
Step one instruction, but proceed through subroutine calls.\n\
2796
Argument N means do this N times (or till program stops for another reason)."));
2797
  add_com_alias ("ni", "nexti", class_alias, 0);
2798
 
2799
  add_com ("finish", class_run, finish_command, _("\
2800
Execute until selected stack frame returns.\n\
2801
Upon return, the value returned is printed and put in the value history."));
2802
  add_com_alias ("fin", "finish", class_run, 1);
2803
 
2804
  add_com ("next", class_run, next_command, _("\
2805
Step program, proceeding through subroutine calls.\n\
2806
Like the \"step\" command as long as subroutine calls do not happen;\n\
2807
when they do, the call is treated as one instruction.\n\
2808
Argument N means do this N times (or till program stops for another reason)."));
2809
  add_com_alias ("n", "next", class_run, 1);
2810
  if (xdb_commands)
2811
    add_com_alias ("S", "next", class_run, 1);
2812
 
2813
  add_com ("step", class_run, step_command, _("\
2814
Step program until it reaches a different source line.\n\
2815
Argument N means do this N times (or till program stops for another reason)."));
2816
  add_com_alias ("s", "step", class_run, 1);
2817
 
2818
  c = add_com ("until", class_run, until_command, _("\
2819
Execute until the program reaches a source line greater than the current\n\
2820
or a specified location (same args as break command) within the current frame."));
2821
  set_cmd_completer (c, location_completer);
2822
  add_com_alias ("u", "until", class_run, 1);
2823
 
2824
  c = add_com ("advance", class_run, advance_command, _("\
2825
Continue the program up to the given location (same form as args for break command).\n\
2826
Execution will also stop upon exit from the current stack frame."));
2827
  set_cmd_completer (c, location_completer);
2828
 
2829
  c = add_com ("jump", class_run, jump_command, _("\
2830
Continue program being debugged at specified line or address.\n\
2831
Give as argument either LINENUM or *ADDR, where ADDR is an expression\n\
2832
for an address to start at."));
2833
  set_cmd_completer (c, location_completer);
2834
 
2835
  if (xdb_commands)
2836
    {
2837
      c = add_com ("go", class_run, go_command, _("\
2838
Usage: go <location>\n\
2839
Continue program being debugged, stopping at specified line or \n\
2840
address.\n\
2841
Give as argument either LINENUM or *ADDR, where ADDR is an \n\
2842
expression for an address to start at.\n\
2843
This command is a combination of tbreak and jump."));
2844
      set_cmd_completer (c, location_completer);
2845
    }
2846
 
2847
  if (xdb_commands)
2848
    add_com_alias ("g", "go", class_run, 1);
2849
 
2850
  c = add_com ("continue", class_run, continue_command, _("\
2851
Continue program being debugged, after signal or breakpoint.\n\
2852
If proceeding from breakpoint, a number N may be used as an argument,\n\
2853
which means to set the ignore count of that breakpoint to N - 1 (so that\n\
2854
the breakpoint won't break until the Nth time it is reached).\n\
2855
\n\
2856
If non-stop mode is enabled, continue only the current thread,\n\
2857
otherwise all the threads in the program are continued.  To \n\
2858
continue all stopped threads in non-stop mode, use the -a option.\n\
2859
Specifying -a and an ignore count simultaneously is an error."));
2860
  add_com_alias ("c", "cont", class_run, 1);
2861
  add_com_alias ("fg", "cont", class_run, 1);
2862
 
2863
  c = add_com ("run", class_run, run_command, _("\
2864
Start debugged program.  You may specify arguments to give it.\n\
2865
Args may include \"*\", or \"[...]\"; they are expanded using \"sh\".\n\
2866
Input and output redirection with \">\", \"<\", or \">>\" are also allowed.\n\n\
2867
With no arguments, uses arguments last specified (with \"run\" or \"set args\").\n\
2868
To cancel previous arguments and run with no arguments,\n\
2869
use \"set args\" without arguments."));
2870
  set_cmd_completer (c, filename_completer);
2871
  add_com_alias ("r", "run", class_run, 1);
2872
  if (xdb_commands)
2873
    add_com ("R", class_run, run_no_args_command,
2874
             _("Start debugged program with no arguments."));
2875
 
2876
  c = add_com ("start", class_run, start_command, _("\
2877
Run the debugged program until the beginning of the main procedure.\n\
2878
You may specify arguments to give to your program, just as with the\n\
2879
\"run\" command."));
2880
  set_cmd_completer (c, filename_completer);
2881
 
2882
  c = add_com ("interrupt", class_run, interrupt_target_command,
2883
               _("Interrupt the execution of the debugged program.\n\
2884
If non-stop mode is enabled, interrupt only the current thread,\n\
2885
otherwise all the threads in the program are stopped.  To \n\
2886
interrupt all running threads in non-stop mode, use the -a option."));
2887
 
2888
  add_info ("registers", nofp_registers_info, _("\
2889
List of integer registers and their contents, for selected stack frame.\n\
2890
Register name as argument means describe only that register."));
2891
  add_info_alias ("r", "registers", 1);
2892
 
2893
  if (xdb_commands)
2894
    add_com ("lr", class_info, nofp_registers_info, _("\
2895
List of integer registers and their contents, for selected stack frame.\n\
2896
Register name as argument means describe only that register."));
2897
  add_info ("all-registers", all_registers_info, _("\
2898
List of all registers and their contents, for selected stack frame.\n\
2899
Register name as argument means describe only that register."));
2900
 
2901
  add_info ("program", program_info,
2902
            _("Execution status of the program."));
2903
 
2904
  add_info ("float", float_info,
2905
            _("Print the status of the floating point unit\n"));
2906
 
2907
  add_info ("vector", vector_info,
2908
            _("Print the status of the vector unit\n"));
2909
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.