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

Subversion Repositories openrisc_me

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

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 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 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 <signal.h>
24
#include "gdb_string.h"
25
#include "symtab.h"
26
#include "gdbtypes.h"
27
#include "frame.h"
28
#include "inferior.h"
29
#include "environ.h"
30
#include "value.h"
31
#include "gdbcmd.h"
32
#include "symfile.h"
33
#include "gdbcore.h"
34
#include "target.h"
35
#include "language.h"
36
#include "symfile.h"
37
#include "objfiles.h"
38
#include "completer.h"
39
#include "ui-out.h"
40
#include "event-top.h"
41
#include "parser-defs.h"
42
#include "regcache.h"
43
#include "reggroups.h"
44
#include "block.h"
45
#include "solib.h"
46
#include <ctype.h>
47
#include "gdb_assert.h"
48
#include "observer.h"
49
#include "target-descriptions.h"
50
#include "user-regs.h"
51
 
52
/* Functions exported for general use, in inferior.h: */
53
 
54
void all_registers_info (char *, int);
55
 
56
void registers_info (char *, int);
57
 
58
void nexti_command (char *, int);
59
 
60
void stepi_command (char *, int);
61
 
62
void continue_command (char *, int);
63
 
64
void interrupt_target_command (char *args, int from_tty);
65
 
66
/* Local functions: */
67
 
68
static void nofp_registers_info (char *, int);
69
 
70
static void print_return_value (struct type *value_type);
71
 
72
static void finish_command_continuation (struct continuation_arg *);
73
 
74
static void until_next_command (int);
75
 
76
static void until_command (char *, int);
77
 
78
static void path_info (char *, int);
79
 
80
static void path_command (char *, int);
81
 
82
static void unset_command (char *, int);
83
 
84
static void float_info (char *, int);
85
 
86
static void detach_command (char *, int);
87
 
88
static void disconnect_command (char *, int);
89
 
90
static void unset_environment_command (char *, int);
91
 
92
static void set_environment_command (char *, int);
93
 
94
static void environment_info (char *, int);
95
 
96
static void program_info (char *, int);
97
 
98
static void finish_command (char *, int);
99
 
100
static void signal_command (char *, int);
101
 
102
static void jump_command (char *, int);
103
 
104
static void step_1 (int, int, char *);
105
static void step_once (int skip_subroutines, int single_inst, int count);
106
static void step_1_continuation (struct continuation_arg *arg);
107
 
108
static void next_command (char *, int);
109
 
110
static void step_command (char *, int);
111
 
112
static void run_command (char *, int);
113
 
114
static void run_no_args_command (char *args, int from_tty);
115
 
116
static void go_command (char *line_no, int from_tty);
117
 
118
static int strip_bg_char (char **);
119
 
120
void _initialize_infcmd (void);
121
 
122
#define GO_USAGE   "Usage: go <location>\n"
123
 
124
#define ERROR_NO_INFERIOR \
125
   if (!target_has_execution) error (_("The program is not being run."));
126
 
127
/* String containing arguments to give to the program, separated by spaces.
128
   Empty string (pointer to '\0') means no args.  */
129
 
130
static char *inferior_args;
131
 
132
/* The inferior arguments as a vector.  If INFERIOR_ARGC is nonzero,
133
   then we must compute INFERIOR_ARGS from this (via the target).  */
134
 
135
static int inferior_argc;
136
static char **inferior_argv;
137
 
138
/* File name for default use for standard in/out in the inferior.  */
139
 
140
static char *inferior_io_terminal;
141
 
142
/* Pid of our debugged inferior, or 0 if no inferior now.
143
   Since various parts of infrun.c test this to see whether there is a program
144
   being debugged it should be nonzero (currently 3 is used) for remote
145
   debugging.  */
146
 
147
ptid_t inferior_ptid;
148
 
149
/* Last signal that the inferior received (why it stopped).  */
150
 
151
enum target_signal stop_signal;
152
 
153
/* Address at which inferior stopped.  */
154
 
155
CORE_ADDR stop_pc;
156
 
157
/* Chain containing status of breakpoint(s) that we have stopped at.  */
158
 
159
bpstat stop_bpstat;
160
 
161
/* Flag indicating that a command has proceeded the inferior past the
162
   current breakpoint.  */
163
 
164
int breakpoint_proceeded;
165
 
166
/* Nonzero if stopped due to a step command.  */
167
 
168
int stop_step;
169
 
170
/* Nonzero if stopped due to completion of a stack dummy routine.  */
171
 
172
int stop_stack_dummy;
173
 
174
/* Nonzero if stopped due to a random (unexpected) signal in inferior
175
   process.  */
176
 
177
int stopped_by_random_signal;
178
 
179
/* Range to single step within.
180
   If this is nonzero, respond to a single-step signal
181
   by continuing to step if the pc is in this range.  */
182
 
183
CORE_ADDR step_range_start;     /* Inclusive */
184
CORE_ADDR step_range_end;       /* Exclusive */
185
 
186
/* Stack frame address as of when stepping command was issued.
187
   This is how we know when we step into a subroutine call,
188
   and how to set the frame for the breakpoint used to step out.  */
189
 
190
struct frame_id step_frame_id;
191
 
192
enum step_over_calls_kind step_over_calls;
193
 
194
/* If stepping, nonzero means step count is > 1
195
   so don't print frame next time inferior stops
196
   if it stops due to stepping.  */
197
 
198
int step_multi;
199
 
200
/* Environment to use for running inferior,
201
   in format described in environ.h.  */
202
 
203
struct gdb_environ *inferior_environ;
204
 
205
/* Accessor routines. */
206
 
207
void
208
set_inferior_io_terminal (const char *terminal_name)
209
{
210
  if (inferior_io_terminal)
211
    xfree (inferior_io_terminal);
212
 
213
  if (!terminal_name)
214
    inferior_io_terminal = NULL;
215
  else
216
    inferior_io_terminal = savestring (terminal_name, strlen (terminal_name));
217
}
218
 
219
const char *
220
get_inferior_io_terminal (void)
221
{
222
  return inferior_io_terminal;
223
}
224
 
225
char *
226
get_inferior_args (void)
227
{
228
  if (inferior_argc != 0)
229
    {
230
      char *n, *old;
231
 
232
      n = gdbarch_construct_inferior_arguments (current_gdbarch,
233
                                                inferior_argc, inferior_argv);
234
      old = set_inferior_args (n);
235
      xfree (old);
236
    }
237
 
238
  if (inferior_args == NULL)
239
    inferior_args = xstrdup ("");
240
 
241
  return inferior_args;
242
}
243
 
244
char *
245
set_inferior_args (char *newargs)
246
{
247
  char *saved_args = inferior_args;
248
 
249
  inferior_args = newargs;
250
  inferior_argc = 0;
251
  inferior_argv = 0;
252
 
253
  return saved_args;
254
}
255
 
256
void
257
set_inferior_args_vector (int argc, char **argv)
258
{
259
  inferior_argc = argc;
260
  inferior_argv = argv;
261
}
262
 
263
/* Notice when `set args' is run.  */
264
static void
265
notice_args_set (char *args, int from_tty, struct cmd_list_element *c)
266
{
267
  inferior_argc = 0;
268
  inferior_argv = 0;
269
}
270
 
271
/* Notice when `show args' is run.  */
272
static void
273
notice_args_read (struct ui_file *file, int from_tty,
274
                  struct cmd_list_element *c, const char *value)
275
{
276
  deprecated_show_value_hack (file, from_tty, c, value);
277
  /* Might compute the value.  */
278
  get_inferior_args ();
279
}
280
 
281
 
282
/* Compute command-line string given argument vector.  This does the
283
   same shell processing as fork_inferior.  */
284
char *
285
construct_inferior_arguments (struct gdbarch *gdbarch, int argc, char **argv)
286
{
287
  char *result;
288
 
289
  if (STARTUP_WITH_SHELL)
290
    {
291
      /* This holds all the characters considered special to the
292
         typical Unix shells.  We include `^' because the SunOS
293
         /bin/sh treats it as a synonym for `|'.  */
294
      char *special = "\"!#$&*()\\|[]{}<>?'\"`~^; \t\n";
295
      int i;
296
      int length = 0;
297
      char *out, *cp;
298
 
299
      /* We over-compute the size.  It shouldn't matter.  */
300
      for (i = 0; i < argc; ++i)
301
        length += 2 * strlen (argv[i]) + 1 + 2 * (argv[i][0] == '\0');
302
 
303
      result = (char *) xmalloc (length);
304
      out = result;
305
 
306
      for (i = 0; i < argc; ++i)
307
        {
308
          if (i > 0)
309
            *out++ = ' ';
310
 
311
          /* Need to handle empty arguments specially.  */
312
          if (argv[i][0] == '\0')
313
            {
314
              *out++ = '\'';
315
              *out++ = '\'';
316
            }
317
          else
318
            {
319
              for (cp = argv[i]; *cp; ++cp)
320
                {
321
                  if (strchr (special, *cp) != NULL)
322
                    *out++ = '\\';
323
                  *out++ = *cp;
324
                }
325
            }
326
        }
327
      *out = '\0';
328
    }
329
  else
330
    {
331
      /* In this case we can't handle arguments that contain spaces,
332
         tabs, or newlines -- see breakup_args().  */
333
      int i;
334
      int length = 0;
335
 
336
      for (i = 0; i < argc; ++i)
337
        {
338
          char *cp = strchr (argv[i], ' ');
339
          if (cp == NULL)
340
            cp = strchr (argv[i], '\t');
341
          if (cp == NULL)
342
            cp = strchr (argv[i], '\n');
343
          if (cp != NULL)
344
            error (_("can't handle command-line argument containing whitespace"));
345
          length += strlen (argv[i]) + 1;
346
        }
347
 
348
      result = (char *) xmalloc (length);
349
      result[0] = '\0';
350
      for (i = 0; i < argc; ++i)
351
        {
352
          if (i > 0)
353
            strcat (result, " ");
354
          strcat (result, argv[i]);
355
        }
356
    }
357
 
358
  return result;
359
}
360
 
361
 
362
/* This function detects whether or not a '&' character (indicating
363
   background execution) has been added as *the last* of the arguments ARGS
364
   of a command. If it has, it removes it and returns 1. Otherwise it
365
   does nothing and returns 0. */
366
static int
367
strip_bg_char (char **args)
368
{
369
  char *p = NULL;
370
 
371
  p = strchr (*args, '&');
372
 
373
  if (p)
374
    {
375
      if (p == (*args + strlen (*args) - 1))
376
        {
377
          if (strlen (*args) > 1)
378
            {
379
              do
380
                p--;
381
              while (*p == ' ' || *p == '\t');
382
              *(p + 1) = '\0';
383
            }
384
          else
385
            *args = 0;
386
          return 1;
387
        }
388
    }
389
  return 0;
390
}
391
 
392
void
393
tty_command (char *file, int from_tty)
394
{
395
  if (file == 0)
396
    error_no_arg (_("terminal name for running target process"));
397
 
398
  set_inferior_io_terminal (file);
399
}
400
 
401
/* Common actions to take after creating any sort of inferior, by any
402
   means (running, attaching, connecting, et cetera).  The target
403
   should be stopped.  */
404
 
405
void
406
post_create_inferior (struct target_ops *target, int from_tty)
407
{
408
  /* Be sure we own the terminal in case write operations are performed.  */
409
  target_terminal_ours ();
410
 
411
  /* If the target hasn't taken care of this already, do it now.
412
     Targets which need to access registers during to_open,
413
     to_create_inferior, or to_attach should do it earlier; but many
414
     don't need to.  */
415
  target_find_description ();
416
 
417
  if (exec_bfd)
418
    {
419
      /* Sometimes the platform-specific hook loads initial shared
420
         libraries, and sometimes it doesn't.  Try to do so first, so
421
         that we can add them with the correct value for FROM_TTY.
422
         If we made all the inferior hook methods consistent,
423
         this call could be removed.  */
424
#ifdef SOLIB_ADD
425
      SOLIB_ADD (NULL, from_tty, target, auto_solib_add);
426
#else
427
      solib_add (NULL, from_tty, target, auto_solib_add);
428
#endif
429
 
430
      /* Create the hooks to handle shared library load and unload
431
         events.  */
432
#ifdef SOLIB_CREATE_INFERIOR_HOOK
433
      SOLIB_CREATE_INFERIOR_HOOK (PIDGET (inferior_ptid));
434
#else
435
      solib_create_inferior_hook ();
436
#endif
437
    }
438
 
439
  observer_notify_inferior_created (target, from_tty);
440
}
441
 
442
/* Kill the inferior if already running.  This function is designed
443
   to be called when we are about to start the execution of the program
444
   from the beginning.  Ask the user to confirm that he wants to restart
445
   the program being debugged when FROM_TTY is non-null.  */
446
 
447
void
448
kill_if_already_running (int from_tty)
449
{
450
  if (! ptid_equal (inferior_ptid, null_ptid) && target_has_execution)
451
    {
452
      if (from_tty
453
          && !query ("The program being debugged has been started already.\n\
454
Start it from the beginning? "))
455
        error (_("Program not restarted."));
456
      target_kill ();
457
      no_shared_libraries (NULL, from_tty);
458
      init_wait_for_inferior ();
459
    }
460
}
461
 
462
/* Implement the "run" command. If TBREAK_AT_MAIN is set, then insert
463
   a temporary breakpoint at the begining of the main program before
464
   running the program.  */
465
 
466
static void
467
run_command_1 (char *args, int from_tty, int tbreak_at_main)
468
{
469
  char *exec_file;
470
 
471
  dont_repeat ();
472
 
473
  kill_if_already_running (from_tty);
474
  clear_breakpoint_hit_counts ();
475
 
476
  /* Clean up any leftovers from other runs.  Some other things from
477
     this function should probably be moved into target_pre_inferior.  */
478
  target_pre_inferior (from_tty);
479
 
480
  /* Purge old solib objfiles. */
481
  objfile_purge_solibs ();
482
 
483
  clear_solib ();
484
 
485
  /* The comment here used to read, "The exec file is re-read every
486
     time we do a generic_mourn_inferior, so we just have to worry
487
     about the symbol file."  The `generic_mourn_inferior' function
488
     gets called whenever the program exits.  However, suppose the
489
     program exits, and *then* the executable file changes?  We need
490
     to check again here.  Since reopen_exec_file doesn't do anything
491
     if the timestamp hasn't changed, I don't see the harm.  */
492
  reopen_exec_file ();
493
  reread_symbols ();
494
 
495
  /* Insert the temporary breakpoint if a location was specified.  */
496
  if (tbreak_at_main)
497
    tbreak_command (main_name (), 0);
498
 
499
  exec_file = (char *) get_exec_file (0);
500
 
501
  /* We keep symbols from add-symbol-file, on the grounds that the
502
     user might want to add some symbols before running the program
503
     (right?).  But sometimes (dynamic loading where the user manually
504
     introduces the new symbols with add-symbol-file), the code which
505
     the symbols describe does not persist between runs.  Currently
506
     the user has to manually nuke all symbols between runs if they
507
     want them to go away (PR 2207).  This is probably reasonable.  */
508
 
509
  if (!args)
510
    {
511
      if (target_can_async_p ())
512
        async_disable_stdin ();
513
    }
514
  else
515
    {
516
      int async_exec = strip_bg_char (&args);
517
 
518
      /* If we get a request for running in the bg but the target
519
         doesn't support it, error out. */
520
      if (async_exec && !target_can_async_p ())
521
        error (_("Asynchronous execution not supported on this target."));
522
 
523
      /* If we don't get a request of running in the bg, then we need
524
         to simulate synchronous (fg) execution. */
525
      if (!async_exec && target_can_async_p ())
526
        {
527
          /* Simulate synchronous execution */
528
          async_disable_stdin ();
529
        }
530
 
531
      /* If there were other args, beside '&', process them. */
532
      if (args)
533
        {
534
          char *old_args = set_inferior_args (xstrdup (args));
535
          xfree (old_args);
536
        }
537
    }
538
 
539
  if (from_tty)
540
    {
541
      ui_out_field_string (uiout, NULL, "Starting program");
542
      ui_out_text (uiout, ": ");
543
      if (exec_file)
544
        ui_out_field_string (uiout, "execfile", exec_file);
545
      ui_out_spaces (uiout, 1);
546
      /* We call get_inferior_args() because we might need to compute
547
         the value now.  */
548
      ui_out_field_string (uiout, "infargs", get_inferior_args ());
549
      ui_out_text (uiout, "\n");
550
      ui_out_flush (uiout);
551
    }
552
 
553
  /* We call get_inferior_args() because we might need to compute
554
     the value now.  */
555
  target_create_inferior (exec_file, get_inferior_args (),
556
                          environ_vector (inferior_environ), from_tty);
557
 
558
  /* Pass zero for FROM_TTY, because at this point the "run" command
559
     has done its thing; now we are setting up the running program.  */
560
  post_create_inferior (&current_target, 0);
561
 
562
  /* Start the target running.  */
563
  proceed ((CORE_ADDR) -1, TARGET_SIGNAL_0, 0);
564
}
565
 
566
 
567
static void
568
run_command (char *args, int from_tty)
569
{
570
  run_command_1 (args, from_tty, 0);
571
}
572
 
573
static void
574
run_no_args_command (char *args, int from_tty)
575
{
576
  char *old_args = set_inferior_args (xstrdup (""));
577
  xfree (old_args);
578
}
579
 
580
 
581
/* Start the execution of the program up until the beginning of the main
582
   program.  */
583
 
584
static void
585
start_command (char *args, int from_tty)
586
{
587
  /* Some languages such as Ada need to search inside the program
588
     minimal symbols for the location where to put the temporary
589
     breakpoint before starting.  */
590
  if (!have_minimal_symbols ())
591
    error (_("No symbol table loaded.  Use the \"file\" command."));
592
 
593
  /* Run the program until reaching the main procedure...  */
594
  run_command_1 (args, from_tty, 1);
595
}
596
 
597
void
598
continue_command (char *proc_count_exp, int from_tty)
599
{
600
  int async_exec = 0;
601
  ERROR_NO_INFERIOR;
602
 
603
  /* Find out whether we must run in the background. */
604
  if (proc_count_exp != NULL)
605
    async_exec = strip_bg_char (&proc_count_exp);
606
 
607
  /* If we must run in the background, but the target can't do it,
608
     error out. */
609
  if (async_exec && !target_can_async_p ())
610
    error (_("Asynchronous execution not supported on this target."));
611
 
612
  /* If we are not asked to run in the bg, then prepare to run in the
613
     foreground, synchronously. */
614
  if (!async_exec && target_can_async_p ())
615
    {
616
      /* Simulate synchronous execution */
617
      async_disable_stdin ();
618
    }
619
 
620
  /* If have argument (besides '&'), set proceed count of breakpoint
621
     we stopped at.  */
622
  if (proc_count_exp != NULL)
623
    {
624
      bpstat bs = stop_bpstat;
625
      int num, stat;
626
      int stopped = 0;
627
 
628
      while ((stat = bpstat_num (&bs, &num)) != 0)
629
        if (stat > 0)
630
          {
631
            set_ignore_count (num,
632
                              parse_and_eval_long (proc_count_exp) - 1,
633
                              from_tty);
634
            /* set_ignore_count prints a message ending with a period.
635
               So print two spaces before "Continuing.".  */
636
            if (from_tty)
637
              printf_filtered ("  ");
638
            stopped = 1;
639
          }
640
 
641
      if (!stopped && from_tty)
642
        {
643
          printf_filtered
644
            ("Not stopped at any breakpoint; argument ignored.\n");
645
        }
646
    }
647
 
648
  if (from_tty)
649
    printf_filtered (_("Continuing.\n"));
650
 
651
  clear_proceed_status ();
652
 
653
  proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 0);
654
}
655
 
656
/* Step until outside of current statement.  */
657
 
658
static void
659
step_command (char *count_string, int from_tty)
660
{
661
  step_1 (0, 0, count_string);
662
}
663
 
664
/* Likewise, but skip over subroutine calls as if single instructions.  */
665
 
666
static void
667
next_command (char *count_string, int from_tty)
668
{
669
  step_1 (1, 0, count_string);
670
}
671
 
672
/* Likewise, but step only one instruction.  */
673
 
674
void
675
stepi_command (char *count_string, int from_tty)
676
{
677
  step_1 (0, 1, count_string);
678
}
679
 
680
void
681
nexti_command (char *count_string, int from_tty)
682
{
683
  step_1 (1, 1, count_string);
684
}
685
 
686
static void
687
disable_longjmp_breakpoint_cleanup (void *ignore)
688
{
689
  disable_longjmp_breakpoint ();
690
}
691
 
692
static void
693
step_1 (int skip_subroutines, int single_inst, char *count_string)
694
{
695
  int count = 1;
696
  struct frame_info *frame;
697
  struct cleanup *cleanups = 0;
698
  int async_exec = 0;
699
 
700
  ERROR_NO_INFERIOR;
701
 
702
  if (count_string)
703
    async_exec = strip_bg_char (&count_string);
704
 
705
  /* If we get a request for running in the bg but the target
706
     doesn't support it, error out. */
707
  if (async_exec && !target_can_async_p ())
708
    error (_("Asynchronous execution not supported on this target."));
709
 
710
  /* If we don't get a request of running in the bg, then we need
711
     to simulate synchronous (fg) execution. */
712
  if (!async_exec && target_can_async_p ())
713
    {
714
      /* Simulate synchronous execution */
715
      async_disable_stdin ();
716
    }
717
 
718
  count = count_string ? parse_and_eval_long (count_string) : 1;
719
 
720
  if (!single_inst || skip_subroutines)         /* leave si command alone */
721
    {
722
      enable_longjmp_breakpoint ();
723
      if (!target_can_async_p ())
724
        cleanups = make_cleanup (disable_longjmp_breakpoint_cleanup, 0 /*ignore*/);
725
      else
726
        make_exec_cleanup (disable_longjmp_breakpoint_cleanup, 0 /*ignore*/);
727
    }
728
 
729
  /* In synchronous case, all is well, just use the regular for loop. */
730
  if (!target_can_async_p ())
731
    {
732
      for (; count > 0; count--)
733
        {
734
          clear_proceed_status ();
735
 
736
          frame = get_current_frame ();
737
          if (!frame)           /* Avoid coredump here.  Why tho? */
738
            error (_("No current frame"));
739
          step_frame_id = get_frame_id (frame);
740
 
741
          if (!single_inst)
742
            {
743
              find_pc_line_pc_range (stop_pc, &step_range_start, &step_range_end);
744
              if (step_range_end == 0)
745
                {
746
                  char *name;
747
                  if (find_pc_partial_function (stop_pc, &name, &step_range_start,
748
                                                &step_range_end) == 0)
749
                    error (_("Cannot find bounds of current function"));
750
 
751
                  target_terminal_ours ();
752
                  printf_filtered (_("\
753
Single stepping until exit from function %s, \n\
754
which has no line number information.\n"), name);
755
                }
756
            }
757
          else
758
            {
759
              /* Say we are stepping, but stop after one insn whatever it does.  */
760
              step_range_start = step_range_end = 1;
761
              if (!skip_subroutines)
762
                /* It is stepi.
763
                   Don't step over function calls, not even to functions lacking
764
                   line numbers.  */
765
                step_over_calls = STEP_OVER_NONE;
766
            }
767
 
768
          if (skip_subroutines)
769
            step_over_calls = STEP_OVER_ALL;
770
 
771
          step_multi = (count > 1);
772
          proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 1);
773
 
774
          if (!stop_step)
775
            break;
776
        }
777
 
778
      if (!single_inst || skip_subroutines)
779
        do_cleanups (cleanups);
780
      return;
781
    }
782
  /* In case of asynchronous target things get complicated, do only
783
     one step for now, before returning control to the event loop. Let
784
     the continuation figure out how many other steps we need to do,
785
     and handle them one at the time, through step_once(). */
786
  else
787
    {
788
      if (target_can_async_p ())
789
        step_once (skip_subroutines, single_inst, count);
790
    }
791
}
792
 
793
/* Called after we are done with one step operation, to check whether
794
   we need to step again, before we print the prompt and return control
795
   to the user. If count is > 1, we will need to do one more call to
796
   proceed(), via step_once(). Basically it is like step_once and
797
   step_1_continuation are co-recursive. */
798
static void
799
step_1_continuation (struct continuation_arg *arg)
800
{
801
  int count;
802
  int skip_subroutines;
803
  int single_inst;
804
 
805
  skip_subroutines = arg->data.integer;
806
  single_inst      = arg->next->data.integer;
807
  count            = arg->next->next->data.integer;
808
 
809
  if (stop_step)
810
    step_once (skip_subroutines, single_inst, count - 1);
811
  else
812
    if (!single_inst || skip_subroutines)
813
      do_exec_cleanups (ALL_CLEANUPS);
814
}
815
 
816
/* Do just one step operation. If count >1 we will have to set up a
817
   continuation to be done after the target stops (after this one
818
   step). This is useful to implement the 'step n' kind of commands, in
819
   case of asynchronous targets. We had to split step_1 into two parts,
820
   one to be done before proceed() and one afterwards. This function is
821
   called in case of step n with n>1, after the first step operation has
822
   been completed.*/
823
static void
824
step_once (int skip_subroutines, int single_inst, int count)
825
{
826
  struct continuation_arg *arg1;
827
  struct continuation_arg *arg2;
828
  struct continuation_arg *arg3;
829
  struct frame_info *frame;
830
 
831
  if (count > 0)
832
    {
833
      clear_proceed_status ();
834
 
835
      frame = get_current_frame ();
836
      if (!frame)               /* Avoid coredump here.  Why tho? */
837
        error (_("No current frame"));
838
      step_frame_id = get_frame_id (frame);
839
 
840
      if (!single_inst)
841
        {
842
          find_pc_line_pc_range (stop_pc, &step_range_start, &step_range_end);
843
 
844
          /* If we have no line info, switch to stepi mode.  */
845
          if (step_range_end == 0 && step_stop_if_no_debug)
846
            {
847
              step_range_start = step_range_end = 1;
848
            }
849
          else if (step_range_end == 0)
850
            {
851
              char *name;
852
              if (find_pc_partial_function (stop_pc, &name, &step_range_start,
853
                                            &step_range_end) == 0)
854
                error (_("Cannot find bounds of current function"));
855
 
856
              target_terminal_ours ();
857
              printf_filtered (_("\
858
Single stepping until exit from function %s, \n\
859
which has no line number information.\n"), name);
860
            }
861
        }
862
      else
863
        {
864
          /* Say we are stepping, but stop after one insn whatever it does.  */
865
          step_range_start = step_range_end = 1;
866
          if (!skip_subroutines)
867
            /* It is stepi.
868
               Don't step over function calls, not even to functions lacking
869
               line numbers.  */
870
            step_over_calls = STEP_OVER_NONE;
871
        }
872
 
873
      if (skip_subroutines)
874
        step_over_calls = STEP_OVER_ALL;
875
 
876
      step_multi = (count > 1);
877
      arg1 =
878
        (struct continuation_arg *) xmalloc (sizeof (struct continuation_arg));
879
      arg2 =
880
        (struct continuation_arg *) xmalloc (sizeof (struct continuation_arg));
881
      arg3 =
882
        (struct continuation_arg *) xmalloc (sizeof (struct continuation_arg));
883
      arg1->next = arg2;
884
      arg1->data.integer = skip_subroutines;
885
      arg2->next = arg3;
886
      arg2->data.integer = single_inst;
887
      arg3->next = NULL;
888
      arg3->data.integer = count;
889
      add_intermediate_continuation (step_1_continuation, arg1);
890
      proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 1);
891
    }
892
}
893
 
894
 
895
/* Continue program at specified address.  */
896
 
897
static void
898
jump_command (char *arg, int from_tty)
899
{
900
  CORE_ADDR addr;
901
  struct symtabs_and_lines sals;
902
  struct symtab_and_line sal;
903
  struct symbol *fn;
904
  struct symbol *sfn;
905
  int async_exec = 0;
906
 
907
  ERROR_NO_INFERIOR;
908
 
909
  /* Find out whether we must run in the background. */
910
  if (arg != NULL)
911
    async_exec = strip_bg_char (&arg);
912
 
913
  /* If we must run in the background, but the target can't do it,
914
     error out. */
915
  if (async_exec && !target_can_async_p ())
916
    error (_("Asynchronous execution not supported on this target."));
917
 
918
  /* If we are not asked to run in the bg, then prepare to run in the
919
     foreground, synchronously. */
920
  if (!async_exec && target_can_async_p ())
921
    {
922
      /* Simulate synchronous execution */
923
      async_disable_stdin ();
924
    }
925
 
926
  if (!arg)
927
    error_no_arg (_("starting address"));
928
 
929
  sals = decode_line_spec_1 (arg, 1);
930
  if (sals.nelts != 1)
931
    {
932
      error (_("Unreasonable jump request"));
933
    }
934
 
935
  sal = sals.sals[0];
936
  xfree (sals.sals);
937
 
938
  if (sal.symtab == 0 && sal.pc == 0)
939
    error (_("No source file has been specified."));
940
 
941
  resolve_sal_pc (&sal);        /* May error out */
942
 
943
  /* See if we are trying to jump to another function. */
944
  fn = get_frame_function (get_current_frame ());
945
  sfn = find_pc_function (sal.pc);
946
  if (fn != NULL && sfn != fn)
947
    {
948
      if (!query ("Line %d is not in `%s'.  Jump anyway? ", sal.line,
949
                  SYMBOL_PRINT_NAME (fn)))
950
        {
951
          error (_("Not confirmed."));
952
          /* NOTREACHED */
953
        }
954
    }
955
 
956
  if (sfn != NULL)
957
    {
958
      fixup_symbol_section (sfn, 0);
959
      if (section_is_overlay (SYMBOL_BFD_SECTION (sfn)) &&
960
          !section_is_mapped (SYMBOL_BFD_SECTION (sfn)))
961
        {
962
          if (!query ("WARNING!!!  Destination is in unmapped overlay!  Jump anyway? "))
963
            {
964
              error (_("Not confirmed."));
965
              /* NOTREACHED */
966
            }
967
        }
968
    }
969
 
970
  addr = sal.pc;
971
 
972
  if (from_tty)
973
    {
974
      printf_filtered (_("Continuing at "));
975
      fputs_filtered (paddress (addr), gdb_stdout);
976
      printf_filtered (".\n");
977
    }
978
 
979
  clear_proceed_status ();
980
  proceed (addr, TARGET_SIGNAL_0, 0);
981
}
982
 
983
 
984
/* Go to line or address in current procedure */
985
static void
986
go_command (char *line_no, int from_tty)
987
{
988
  if (line_no == (char *) NULL || !*line_no)
989
    printf_filtered (GO_USAGE);
990
  else
991
    {
992
      tbreak_command (line_no, from_tty);
993
      jump_command (line_no, from_tty);
994
    }
995
}
996
 
997
 
998
/* Continue program giving it specified signal.  */
999
 
1000
static void
1001
signal_command (char *signum_exp, int from_tty)
1002
{
1003
  enum target_signal oursig;
1004
 
1005
  dont_repeat ();               /* Too dangerous.  */
1006
  ERROR_NO_INFERIOR;
1007
 
1008
  if (!signum_exp)
1009
    error_no_arg (_("signal number"));
1010
 
1011
  /* It would be even slicker to make signal names be valid expressions,
1012
     (the type could be "enum $signal" or some such), then the user could
1013
     assign them to convenience variables.  */
1014
  oursig = target_signal_from_name (signum_exp);
1015
 
1016
  if (oursig == TARGET_SIGNAL_UNKNOWN)
1017
    {
1018
      /* No, try numeric.  */
1019
      int num = parse_and_eval_long (signum_exp);
1020
 
1021
      if (num == 0)
1022
        oursig = TARGET_SIGNAL_0;
1023
      else
1024
        oursig = target_signal_from_command (num);
1025
    }
1026
 
1027
  if (from_tty)
1028
    {
1029
      if (oursig == TARGET_SIGNAL_0)
1030
        printf_filtered (_("Continuing with no signal.\n"));
1031
      else
1032
        printf_filtered (_("Continuing with signal %s.\n"),
1033
                         target_signal_to_name (oursig));
1034
    }
1035
 
1036
  clear_proceed_status ();
1037
  /* "signal 0" should not get stuck if we are stopped at a breakpoint.
1038
     FIXME: Neither should "signal foo" but when I tried passing
1039
     (CORE_ADDR)-1 unconditionally I got a testsuite failure which I haven't
1040
     tried to track down yet.  */
1041
  proceed (oursig == TARGET_SIGNAL_0 ? (CORE_ADDR) -1 : stop_pc, oursig, 0);
1042
}
1043
 
1044
/* Proceed until we reach a different source line with pc greater than
1045
   our current one or exit the function.  We skip calls in both cases.
1046
 
1047
   Note that eventually this command should probably be changed so
1048
   that only source lines are printed out when we hit the breakpoint
1049
   we set.  This may involve changes to wait_for_inferior and the
1050
   proceed status code.  */
1051
 
1052
static void
1053
until_next_command (int from_tty)
1054
{
1055
  struct frame_info *frame;
1056
  CORE_ADDR pc;
1057
  struct symbol *func;
1058
  struct symtab_and_line sal;
1059
 
1060
  clear_proceed_status ();
1061
 
1062
  frame = get_current_frame ();
1063
 
1064
  /* Step until either exited from this function or greater
1065
     than the current line (if in symbolic section) or pc (if
1066
     not). */
1067
 
1068
  pc = read_pc ();
1069
  func = find_pc_function (pc);
1070
 
1071
  if (!func)
1072
    {
1073
      struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (pc);
1074
 
1075
      if (msymbol == NULL)
1076
        error (_("Execution is not within a known function."));
1077
 
1078
      step_range_start = SYMBOL_VALUE_ADDRESS (msymbol);
1079
      step_range_end = pc;
1080
    }
1081
  else
1082
    {
1083
      sal = find_pc_line (pc, 0);
1084
 
1085
      step_range_start = BLOCK_START (SYMBOL_BLOCK_VALUE (func));
1086
      step_range_end = sal.end;
1087
    }
1088
 
1089
  step_over_calls = STEP_OVER_ALL;
1090
  step_frame_id = get_frame_id (frame);
1091
 
1092
  step_multi = 0;                /* Only one call to proceed */
1093
 
1094
  proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 1);
1095
}
1096
 
1097
static void
1098
until_command (char *arg, int from_tty)
1099
{
1100
  int async_exec = 0;
1101
 
1102
  if (!target_has_execution)
1103
    error (_("The program is not running."));
1104
 
1105
  /* Find out whether we must run in the background. */
1106
  if (arg != NULL)
1107
    async_exec = strip_bg_char (&arg);
1108
 
1109
  /* If we must run in the background, but the target can't do it,
1110
     error out. */
1111
  if (async_exec && !target_can_async_p ())
1112
    error (_("Asynchronous execution not supported on this target."));
1113
 
1114
  /* If we are not asked to run in the bg, then prepare to run in the
1115
     foreground, synchronously. */
1116
  if (!async_exec && target_can_async_p ())
1117
    {
1118
      /* Simulate synchronous execution */
1119
      async_disable_stdin ();
1120
    }
1121
 
1122
  if (arg)
1123
    until_break_command (arg, from_tty, 0);
1124
  else
1125
    until_next_command (from_tty);
1126
}
1127
 
1128
static void
1129
advance_command (char *arg, int from_tty)
1130
{
1131
  int async_exec = 0;
1132
 
1133
  if (!target_has_execution)
1134
    error (_("The program is not running."));
1135
 
1136
  if (arg == NULL)
1137
    error_no_arg (_("a location"));
1138
 
1139
  /* Find out whether we must run in the background.  */
1140
  if (arg != NULL)
1141
    async_exec = strip_bg_char (&arg);
1142
 
1143
  /* If we must run in the background, but the target can't do it,
1144
     error out.  */
1145
  if (async_exec && !target_can_async_p ())
1146
    error (_("Asynchronous execution not supported on this target."));
1147
 
1148
  /* If we are not asked to run in the bg, then prepare to run in the
1149
     foreground, synchronously.  */
1150
  if (!async_exec && target_can_async_p ())
1151
    {
1152
      /* Simulate synchronous execution.  */
1153
      async_disable_stdin ();
1154
    }
1155
 
1156
  until_break_command (arg, from_tty, 1);
1157
}
1158
 
1159
/* Print the result of a function at the end of a 'finish' command.  */
1160
 
1161
static void
1162
print_return_value (struct type *value_type)
1163
{
1164
  struct gdbarch *gdbarch = current_gdbarch;
1165
  struct cleanup *old_chain;
1166
  struct ui_stream *stb;
1167
  struct value *value;
1168
 
1169
  CHECK_TYPEDEF (value_type);
1170
  gdb_assert (TYPE_CODE (value_type) != TYPE_CODE_VOID);
1171
 
1172
  /* FIXME: 2003-09-27: When returning from a nested inferior function
1173
     call, it's possible (with no help from the architecture vector)
1174
     to locate and return/print a "struct return" value.  This is just
1175
     a more complicated case of what is already being done in in the
1176
     inferior function call code.  In fact, when inferior function
1177
     calls are made async, this will likely be made the norm.  */
1178
 
1179
  switch (gdbarch_return_value (gdbarch, value_type, NULL, NULL, NULL))
1180
    {
1181
    case RETURN_VALUE_REGISTER_CONVENTION:
1182
    case RETURN_VALUE_ABI_RETURNS_ADDRESS:
1183
    case RETURN_VALUE_ABI_PRESERVES_ADDRESS:
1184
      value = allocate_value (value_type);
1185
      gdbarch_return_value (gdbarch, value_type, stop_registers,
1186
                            value_contents_raw (value), NULL);
1187
      break;
1188
    case RETURN_VALUE_STRUCT_CONVENTION:
1189
      value = NULL;
1190
      break;
1191
    default:
1192
      internal_error (__FILE__, __LINE__, _("bad switch"));
1193
    }
1194
 
1195
  if (value)
1196
    {
1197
      /* Print it.  */
1198
      stb = ui_out_stream_new (uiout);
1199
      old_chain = make_cleanup_ui_out_stream_delete (stb);
1200
      ui_out_text (uiout, "Value returned is ");
1201
      ui_out_field_fmt (uiout, "gdb-result-var", "$%d",
1202
                        record_latest_value (value));
1203
      ui_out_text (uiout, " = ");
1204
      value_print (value, stb->stream, 0, Val_no_prettyprint);
1205
      ui_out_field_stream (uiout, "return-value", stb);
1206
      ui_out_text (uiout, "\n");
1207
      do_cleanups (old_chain);
1208
    }
1209
  else
1210
    {
1211
      ui_out_text (uiout, "Value returned has type: ");
1212
      ui_out_field_string (uiout, "return-type", TYPE_NAME (value_type));
1213
      ui_out_text (uiout, ".");
1214
      ui_out_text (uiout, " Cannot determine contents\n");
1215
    }
1216
}
1217
 
1218
/* Stuff that needs to be done by the finish command after the target
1219
   has stopped.  In asynchronous mode, we wait for the target to stop
1220
   in the call to poll or select in the event loop, so it is
1221
   impossible to do all the stuff as part of the finish_command
1222
   function itself.  The only chance we have to complete this command
1223
   is in fetch_inferior_event, which is called by the event loop as
1224
   soon as it detects that the target has stopped. This function is
1225
   called via the cmd_continuation pointer.  */
1226
 
1227
static void
1228
finish_command_continuation (struct continuation_arg *arg)
1229
{
1230
  struct symbol *function;
1231
  struct breakpoint *breakpoint;
1232
  struct cleanup *cleanups;
1233
 
1234
  breakpoint = (struct breakpoint *) arg->data.pointer;
1235
  function = (struct symbol *) arg->next->data.pointer;
1236
  cleanups = (struct cleanup *) arg->next->next->data.pointer;
1237
 
1238
  if (bpstat_find_breakpoint (stop_bpstat, breakpoint) != NULL
1239
      && function != NULL)
1240
    {
1241
      struct type *value_type;
1242
 
1243
      value_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (function));
1244
      if (!value_type)
1245
        internal_error (__FILE__, __LINE__,
1246
                        _("finish_command: function has no target type"));
1247
 
1248
      if (TYPE_CODE (value_type) != TYPE_CODE_VOID)
1249
        print_return_value (value_type);
1250
    }
1251
 
1252
  do_exec_cleanups (cleanups);
1253
}
1254
 
1255
/* "finish": Set a temporary breakpoint at the place the selected
1256
   frame will return to, then continue.  */
1257
 
1258
static void
1259
finish_command (char *arg, int from_tty)
1260
{
1261
  struct symtab_and_line sal;
1262
  struct frame_info *frame;
1263
  struct symbol *function;
1264
  struct breakpoint *breakpoint;
1265
  struct cleanup *old_chain;
1266
  struct continuation_arg *arg1, *arg2, *arg3;
1267
 
1268
  int async_exec = 0;
1269
 
1270
  /* Find out whether we must run in the background.  */
1271
  if (arg != NULL)
1272
    async_exec = strip_bg_char (&arg);
1273
 
1274
  /* If we must run in the background, but the target can't do it,
1275
     error out.  */
1276
  if (async_exec && !target_can_async_p ())
1277
    error (_("Asynchronous execution not supported on this target."));
1278
 
1279
  /* If we are not asked to run in the bg, then prepare to run in the
1280
     foreground, synchronously.  */
1281
  if (!async_exec && target_can_async_p ())
1282
    {
1283
      /* Simulate synchronous execution.  */
1284
      async_disable_stdin ();
1285
    }
1286
 
1287
  if (arg)
1288
    error (_("The \"finish\" command does not take any arguments."));
1289
  if (!target_has_execution)
1290
    error (_("The program is not running."));
1291
 
1292
  frame = get_prev_frame (get_selected_frame (_("No selected frame.")));
1293
  if (frame == 0)
1294
    error (_("\"finish\" not meaningful in the outermost frame."));
1295
 
1296
  clear_proceed_status ();
1297
 
1298
  sal = find_pc_line (get_frame_pc (frame), 0);
1299
  sal.pc = get_frame_pc (frame);
1300
 
1301
  breakpoint = set_momentary_breakpoint (sal, get_frame_id (frame), bp_finish);
1302
 
1303
  if (!target_can_async_p ())
1304
    old_chain = make_cleanup_delete_breakpoint (breakpoint);
1305
  else
1306
    old_chain = make_exec_cleanup_delete_breakpoint (breakpoint);
1307
 
1308
  /* Find the function we will return from.  */
1309
 
1310
  function = find_pc_function (get_frame_pc (get_selected_frame (NULL)));
1311
 
1312
  /* Print info on the selected frame, including level number but not
1313
     source.  */
1314
  if (from_tty)
1315
    {
1316
      printf_filtered (_("Run till exit from "));
1317
      print_stack_frame (get_selected_frame (NULL), 1, LOCATION);
1318
    }
1319
 
1320
  /* If running asynchronously and the target support asynchronous
1321
     execution, set things up for the rest of the finish command to be
1322
     completed later on, when gdb has detected that the target has
1323
     stopped, in fetch_inferior_event.  */
1324
  if (target_can_async_p ())
1325
    {
1326
      arg1 =
1327
        (struct continuation_arg *) xmalloc (sizeof (struct continuation_arg));
1328
      arg2 =
1329
        (struct continuation_arg *) xmalloc (sizeof (struct continuation_arg));
1330
      arg3 =
1331
        (struct continuation_arg *) xmalloc (sizeof (struct continuation_arg));
1332
      arg1->next = arg2;
1333
      arg2->next = arg3;
1334
      arg3->next = NULL;
1335
      arg1->data.pointer = breakpoint;
1336
      arg2->data.pointer = function;
1337
      arg3->data.pointer = old_chain;
1338
      add_continuation (finish_command_continuation, arg1);
1339
    }
1340
 
1341
  proceed_to_finish = 1;        /* We want stop_registers, please...  */
1342
  proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 0);
1343
 
1344
  /* Do this only if not running asynchronously or if the target
1345
     cannot do async execution.  Otherwise, complete this command when
1346
     the target actually stops, in fetch_inferior_event.  */
1347
  if (!target_can_async_p ())
1348
    {
1349
      /* Did we stop at our breakpoint?  */
1350
      if (bpstat_find_breakpoint (stop_bpstat, breakpoint) != NULL
1351
          && function != NULL)
1352
        {
1353
          struct type *value_type;
1354
 
1355
          value_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (function));
1356
          if (!value_type)
1357
            internal_error (__FILE__, __LINE__,
1358
                            _("finish_command: function has no target type"));
1359
 
1360
          if (TYPE_CODE (value_type) != TYPE_CODE_VOID)
1361
            print_return_value (value_type);
1362
        }
1363
 
1364
      do_cleanups (old_chain);
1365
    }
1366
}
1367
 
1368
 
1369
static void
1370
program_info (char *args, int from_tty)
1371
{
1372
  bpstat bs = stop_bpstat;
1373
  int num;
1374
  int stat = bpstat_num (&bs, &num);
1375
 
1376
  if (!target_has_execution)
1377
    {
1378
      printf_filtered (_("The program being debugged is not being run.\n"));
1379
      return;
1380
    }
1381
 
1382
  target_files_info ();
1383
  printf_filtered (_("Program stopped at %s.\n"),
1384
                   hex_string ((unsigned long) stop_pc));
1385
  if (stop_step)
1386
    printf_filtered (_("It stopped after being stepped.\n"));
1387
  else if (stat != 0)
1388
    {
1389
      /* There may be several breakpoints in the same place, so this
1390
         isn't as strange as it seems.  */
1391
      while (stat != 0)
1392
        {
1393
          if (stat < 0)
1394
            {
1395
              printf_filtered (_("\
1396
It stopped at a breakpoint that has since been deleted.\n"));
1397
            }
1398
          else
1399
            printf_filtered (_("It stopped at breakpoint %d.\n"), num);
1400
          stat = bpstat_num (&bs, &num);
1401
        }
1402
    }
1403
  else if (stop_signal != TARGET_SIGNAL_0)
1404
    {
1405
      printf_filtered (_("It stopped with signal %s, %s.\n"),
1406
                       target_signal_to_name (stop_signal),
1407
                       target_signal_to_string (stop_signal));
1408
    }
1409
 
1410
  if (!from_tty)
1411
    {
1412
      printf_filtered (_("\
1413
Type \"info stack\" or \"info registers\" for more information.\n"));
1414
    }
1415
}
1416
 
1417
static void
1418
environment_info (char *var, int from_tty)
1419
{
1420
  if (var)
1421
    {
1422
      char *val = get_in_environ (inferior_environ, var);
1423
      if (val)
1424
        {
1425
          puts_filtered (var);
1426
          puts_filtered (" = ");
1427
          puts_filtered (val);
1428
          puts_filtered ("\n");
1429
        }
1430
      else
1431
        {
1432
          puts_filtered ("Environment variable \"");
1433
          puts_filtered (var);
1434
          puts_filtered ("\" not defined.\n");
1435
        }
1436
    }
1437
  else
1438
    {
1439
      char **vector = environ_vector (inferior_environ);
1440
      while (*vector)
1441
        {
1442
          puts_filtered (*vector++);
1443
          puts_filtered ("\n");
1444
        }
1445
    }
1446
}
1447
 
1448
static void
1449
set_environment_command (char *arg, int from_tty)
1450
{
1451
  char *p, *val, *var;
1452
  int nullset = 0;
1453
 
1454
  if (arg == 0)
1455
    error_no_arg (_("environment variable and value"));
1456
 
1457
  /* Find seperation between variable name and value */
1458
  p = (char *) strchr (arg, '=');
1459
  val = (char *) strchr (arg, ' ');
1460
 
1461
  if (p != 0 && val != 0)
1462
    {
1463
      /* We have both a space and an equals.  If the space is before the
1464
         equals, walk forward over the spaces til we see a nonspace
1465
         (possibly the equals). */
1466
      if (p > val)
1467
        while (*val == ' ')
1468
          val++;
1469
 
1470
      /* Now if the = is after the char following the spaces,
1471
         take the char following the spaces.  */
1472
      if (p > val)
1473
        p = val - 1;
1474
    }
1475
  else if (val != 0 && p == 0)
1476
    p = val;
1477
 
1478
  if (p == arg)
1479
    error_no_arg (_("environment variable to set"));
1480
 
1481
  if (p == 0 || p[1] == 0)
1482
    {
1483
      nullset = 1;
1484
      if (p == 0)
1485
        p = arg + strlen (arg); /* So that savestring below will work */
1486
    }
1487
  else
1488
    {
1489
      /* Not setting variable value to null */
1490
      val = p + 1;
1491
      while (*val == ' ' || *val == '\t')
1492
        val++;
1493
    }
1494
 
1495
  while (p != arg && (p[-1] == ' ' || p[-1] == '\t'))
1496
    p--;
1497
 
1498
  var = savestring (arg, p - arg);
1499
  if (nullset)
1500
    {
1501
      printf_filtered (_("\
1502
Setting environment variable \"%s\" to null value.\n"),
1503
                       var);
1504
      set_in_environ (inferior_environ, var, "");
1505
    }
1506
  else
1507
    set_in_environ (inferior_environ, var, val);
1508
  xfree (var);
1509
}
1510
 
1511
static void
1512
unset_environment_command (char *var, int from_tty)
1513
{
1514
  if (var == 0)
1515
    {
1516
      /* If there is no argument, delete all environment variables.
1517
         Ask for confirmation if reading from the terminal.  */
1518
      if (!from_tty || query (_("Delete all environment variables? ")))
1519
        {
1520
          free_environ (inferior_environ);
1521
          inferior_environ = make_environ ();
1522
        }
1523
    }
1524
  else
1525
    unset_in_environ (inferior_environ, var);
1526
}
1527
 
1528
/* Handle the execution path (PATH variable) */
1529
 
1530
static const char path_var_name[] = "PATH";
1531
 
1532
static void
1533
path_info (char *args, int from_tty)
1534
{
1535
  puts_filtered ("Executable and object file path: ");
1536
  puts_filtered (get_in_environ (inferior_environ, path_var_name));
1537
  puts_filtered ("\n");
1538
}
1539
 
1540
/* Add zero or more directories to the front of the execution path.  */
1541
 
1542
static void
1543
path_command (char *dirname, int from_tty)
1544
{
1545
  char *exec_path;
1546
  char *env;
1547
  dont_repeat ();
1548
  env = get_in_environ (inferior_environ, path_var_name);
1549
  /* Can be null if path is not set */
1550
  if (!env)
1551
    env = "";
1552
  exec_path = xstrdup (env);
1553
  mod_path (dirname, &exec_path);
1554
  set_in_environ (inferior_environ, path_var_name, exec_path);
1555
  xfree (exec_path);
1556
  if (from_tty)
1557
    path_info ((char *) NULL, from_tty);
1558
}
1559
 
1560
 
1561
/* Print out the machine register regnum. If regnum is -1, print all
1562
   registers (print_all == 1) or all non-float and non-vector
1563
   registers (print_all == 0).
1564
 
1565
   For most machines, having all_registers_info() print the
1566
   register(s) one per line is good enough.  If a different format is
1567
   required, (eg, for MIPS or Pyramid 90x, which both have lots of
1568
   regs), or there is an existing convention for showing all the
1569
   registers, define the architecture method PRINT_REGISTERS_INFO to
1570
   provide that format.  */
1571
 
1572
void
1573
default_print_registers_info (struct gdbarch *gdbarch,
1574
                              struct ui_file *file,
1575
                              struct frame_info *frame,
1576
                              int regnum, int print_all)
1577
{
1578
  int i;
1579
  const int numregs = gdbarch_num_regs (gdbarch)
1580
                      + gdbarch_num_pseudo_regs (gdbarch);
1581
  gdb_byte buffer[MAX_REGISTER_SIZE];
1582
 
1583
  for (i = 0; i < numregs; i++)
1584
    {
1585
      /* Decide between printing all regs, non-float / vector regs, or
1586
         specific reg.  */
1587
      if (regnum == -1)
1588
        {
1589
          if (print_all)
1590
            {
1591
              if (!gdbarch_register_reggroup_p (gdbarch, i, all_reggroup))
1592
                continue;
1593
            }
1594
          else
1595
            {
1596
              if (!gdbarch_register_reggroup_p (gdbarch, i, general_reggroup))
1597
                continue;
1598
            }
1599
        }
1600
      else
1601
        {
1602
          if (i != regnum)
1603
            continue;
1604
        }
1605
 
1606
      /* If the register name is empty, it is undefined for this
1607
         processor, so don't display anything.  */
1608
      if (gdbarch_register_name (gdbarch, i) == NULL
1609
          || *(gdbarch_register_name (gdbarch, i)) == '\0')
1610
        continue;
1611
 
1612
      fputs_filtered (gdbarch_register_name (gdbarch, i), file);
1613
      print_spaces_filtered (15 - strlen (gdbarch_register_name
1614
                                          (gdbarch, i)), file);
1615
 
1616
      /* Get the data in raw format.  */
1617
      if (! frame_register_read (frame, i, buffer))
1618
        {
1619
          fprintf_filtered (file, "*value not available*\n");
1620
          continue;
1621
        }
1622
 
1623
      /* If virtual format is floating, print it that way, and in raw
1624
         hex.  */
1625
      if (TYPE_CODE (register_type (gdbarch, i)) == TYPE_CODE_FLT
1626
          || TYPE_CODE (register_type (gdbarch, i)) == TYPE_CODE_DECFLOAT)
1627
        {
1628
          int j;
1629
 
1630
          val_print (register_type (gdbarch, i), buffer, 0, 0,
1631
                     file, 0, 1, 0, Val_pretty_default);
1632
 
1633
          fprintf_filtered (file, "\t(raw 0x");
1634
          for (j = 0; j < register_size (gdbarch, i); j++)
1635
            {
1636
              int idx;
1637
              if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
1638
                idx = j;
1639
              else
1640
                idx = register_size (gdbarch, i) - 1 - j;
1641
              fprintf_filtered (file, "%02x", (unsigned char) buffer[idx]);
1642
            }
1643
          fprintf_filtered (file, ")");
1644
        }
1645
      else
1646
        {
1647
          /* Print the register in hex.  */
1648
          val_print (register_type (gdbarch, i), buffer, 0, 0,
1649
                     file, 'x', 1, 0, Val_pretty_default);
1650
          /* If not a vector register, print it also according to its
1651
             natural format.  */
1652
          if (TYPE_VECTOR (register_type (gdbarch, i)) == 0)
1653
            {
1654
              fprintf_filtered (file, "\t");
1655
              val_print (register_type (gdbarch, i), buffer, 0, 0,
1656
                         file, 0, 1, 0, Val_pretty_default);
1657
            }
1658
        }
1659
 
1660
      fprintf_filtered (file, "\n");
1661
    }
1662
}
1663
 
1664
void
1665
registers_info (char *addr_exp, int fpregs)
1666
{
1667
  struct frame_info *frame;
1668
  struct gdbarch *gdbarch;
1669
  int regnum, numregs;
1670
  char *end;
1671
 
1672
  if (!target_has_registers)
1673
    error (_("The program has no registers now."));
1674
  frame = get_selected_frame (NULL);
1675
  gdbarch = get_frame_arch (frame);
1676
 
1677
  if (!addr_exp)
1678
    {
1679
      gdbarch_print_registers_info (gdbarch, gdb_stdout,
1680
                                    frame, -1, fpregs);
1681
      return;
1682
    }
1683
 
1684
  while (*addr_exp != '\0')
1685
    {
1686
      char *start;
1687
      const char *end;
1688
 
1689
      /* Keep skipping leading white space.  */
1690
      if (isspace ((*addr_exp)))
1691
        {
1692
          addr_exp++;
1693
          continue;
1694
        }
1695
 
1696
      /* Discard any leading ``$''.  Check that there is something
1697
         resembling a register following it.  */
1698
      if (addr_exp[0] == '$')
1699
        addr_exp++;
1700
      if (isspace ((*addr_exp)) || (*addr_exp) == '\0')
1701
        error (_("Missing register name"));
1702
 
1703
      /* Find the start/end of this register name/num/group.  */
1704
      start = addr_exp;
1705
      while ((*addr_exp) != '\0' && !isspace ((*addr_exp)))
1706
        addr_exp++;
1707
      end = addr_exp;
1708
 
1709
      /* Figure out what we've found and display it.  */
1710
 
1711
      /* A register name?  */
1712
      {
1713
        int regnum = frame_map_name_to_regnum (frame, start, end - start);
1714
        if (regnum >= 0)
1715
          {
1716
            /* User registers lie completely outside of the range of
1717
               normal registers.  Catch them early so that the target
1718
               never sees them.  */
1719
            if (regnum >= gdbarch_num_regs (gdbarch)
1720
                          + gdbarch_num_pseudo_regs (gdbarch))
1721
              {
1722
                struct value *val = value_of_user_reg (regnum, frame);
1723
 
1724
                printf_filtered ("%s: ", start);
1725
                print_scalar_formatted (value_contents (val),
1726
                                        check_typedef (value_type (val)),
1727
                                        'x', 0, gdb_stdout);
1728
                printf_filtered ("\n");
1729
              }
1730
            else
1731
              gdbarch_print_registers_info (gdbarch, gdb_stdout,
1732
                                            frame, regnum, fpregs);
1733
            continue;
1734
          }
1735
      }
1736
 
1737
      /* A register number?  (how portable is this one?).  */
1738
      {
1739
        char *endptr;
1740
        int regnum = strtol (start, &endptr, 0);
1741
        if (endptr == end
1742
            && regnum >= 0
1743
            && regnum < gdbarch_num_regs (gdbarch)
1744
                        + gdbarch_num_pseudo_regs (gdbarch))
1745
          {
1746
            gdbarch_print_registers_info (gdbarch, gdb_stdout,
1747
                                          frame, regnum, fpregs);
1748
            continue;
1749
          }
1750
      }
1751
 
1752
      /* A register group?  */
1753
      {
1754
        struct reggroup *group;
1755
        for (group = reggroup_next (gdbarch, NULL);
1756
             group != NULL;
1757
             group = reggroup_next (gdbarch, group))
1758
          {
1759
            /* Don't bother with a length check.  Should the user
1760
               enter a short register group name, go with the first
1761
               group that matches.  */
1762
            if (strncmp (start, reggroup_name (group), end - start) == 0)
1763
              break;
1764
          }
1765
        if (group != NULL)
1766
          {
1767
            int regnum;
1768
            for (regnum = 0;
1769
                 regnum < gdbarch_num_regs (gdbarch)
1770
                          + gdbarch_num_pseudo_regs (gdbarch);
1771
                 regnum++)
1772
              {
1773
                if (gdbarch_register_reggroup_p (gdbarch, regnum, group))
1774
                  gdbarch_print_registers_info (gdbarch,
1775
                                                gdb_stdout, frame,
1776
                                                regnum, fpregs);
1777
              }
1778
            continue;
1779
          }
1780
      }
1781
 
1782
      /* Nothing matched.  */
1783
      error (_("Invalid register `%.*s'"), (int) (end - start), start);
1784
    }
1785
}
1786
 
1787
void
1788
all_registers_info (char *addr_exp, int from_tty)
1789
{
1790
  registers_info (addr_exp, 1);
1791
}
1792
 
1793
static void
1794
nofp_registers_info (char *addr_exp, int from_tty)
1795
{
1796
  registers_info (addr_exp, 0);
1797
}
1798
 
1799
static void
1800
print_vector_info (struct gdbarch *gdbarch, struct ui_file *file,
1801
                   struct frame_info *frame, const char *args)
1802
{
1803
  if (gdbarch_print_vector_info_p (gdbarch))
1804
    gdbarch_print_vector_info (gdbarch, file, frame, args);
1805
  else
1806
    {
1807
      int regnum;
1808
      int printed_something = 0;
1809
 
1810
      for (regnum = 0;
1811
           regnum < gdbarch_num_regs (gdbarch)
1812
                    + gdbarch_num_pseudo_regs (gdbarch);
1813
           regnum++)
1814
        {
1815
          if (gdbarch_register_reggroup_p (gdbarch, regnum, vector_reggroup))
1816
            {
1817
              printed_something = 1;
1818
              gdbarch_print_registers_info (gdbarch, file, frame, regnum, 1);
1819
            }
1820
        }
1821
      if (!printed_something)
1822
        fprintf_filtered (file, "No vector information\n");
1823
    }
1824
}
1825
 
1826
static void
1827
vector_info (char *args, int from_tty)
1828
{
1829
  if (!target_has_registers)
1830
    error (_("The program has no registers now."));
1831
 
1832
  print_vector_info (current_gdbarch, gdb_stdout,
1833
                     get_selected_frame (NULL), args);
1834
}
1835
 
1836
 
1837
/*
1838
 * TODO:
1839
 * Should save/restore the tty state since it might be that the
1840
 * program to be debugged was started on this tty and it wants
1841
 * the tty in some state other than what we want.  If it's running
1842
 * on another terminal or without a terminal, then saving and
1843
 * restoring the tty state is a harmless no-op.
1844
 * This only needs to be done if we are attaching to a process.
1845
 */
1846
 
1847
/*
1848
   attach_command --
1849
   takes a program started up outside of gdb and ``attaches'' to it.
1850
   This stops it cold in its tracks and allows us to start debugging it.
1851
   and wait for the trace-trap that results from attaching.  */
1852
 
1853
void
1854
attach_command (char *args, int from_tty)
1855
{
1856
  char *exec_file;
1857
  char *full_exec_path = NULL;
1858
 
1859
  dont_repeat ();               /* Not for the faint of heart */
1860
 
1861
  if (target_has_execution)
1862
    {
1863
      if (query ("A program is being debugged already.  Kill it? "))
1864
        target_kill ();
1865
      else
1866
        error (_("Not killed."));
1867
    }
1868
 
1869
  /* Clean up any leftovers from other runs.  Some other things from
1870
     this function should probably be moved into target_pre_inferior.  */
1871
  target_pre_inferior (from_tty);
1872
 
1873
  /* Clear out solib state. Otherwise the solib state of the previous
1874
     inferior might have survived and is entirely wrong for the new
1875
     target.  This has been observed on GNU/Linux using glibc 2.3. How
1876
     to reproduce:
1877
 
1878
     bash$ ./foo&
1879
     [1] 4711
1880
     bash$ ./foo&
1881
     [1] 4712
1882
     bash$ gdb ./foo
1883
     [...]
1884
     (gdb) attach 4711
1885
     (gdb) detach
1886
     (gdb) attach 4712
1887
     Cannot access memory at address 0xdeadbeef
1888
  */
1889
  clear_solib ();
1890
 
1891
  target_attach (args, from_tty);
1892
 
1893
  /* Set up the "saved terminal modes" of the inferior
1894
     based on what modes we are starting it with.  */
1895
  target_terminal_init ();
1896
 
1897
  /* Set up execution context to know that we should return from
1898
     wait_for_inferior as soon as the target reports a stop.  */
1899
  init_wait_for_inferior ();
1900
  clear_proceed_status ();
1901
 
1902
  /* No traps are generated when attaching to inferior under Mach 3
1903
     or GNU hurd.  */
1904
#ifndef ATTACH_NO_WAIT
1905
  /* Careful here. See comments in inferior.h.  Basically some OSes
1906
     don't ignore SIGSTOPs on continue requests anymore.  We need a
1907
     way for handle_inferior_event to reset the stop_signal variable
1908
     after an attach, and this is what STOP_QUIETLY_NO_SIGSTOP is for.  */
1909
  stop_soon = STOP_QUIETLY_NO_SIGSTOP;
1910
  wait_for_inferior (0);
1911
  stop_soon = NO_STOP_QUIETLY;
1912
#endif
1913
 
1914
  /*
1915
   * If no exec file is yet known, try to determine it from the
1916
   * process itself.
1917
   */
1918
  exec_file = (char *) get_exec_file (0);
1919
  if (!exec_file)
1920
    {
1921
      exec_file = target_pid_to_exec_file (PIDGET (inferior_ptid));
1922
      if (exec_file)
1923
        {
1924
          /* It's possible we don't have a full path, but rather just a
1925
             filename.  Some targets, such as HP-UX, don't provide the
1926
             full path, sigh.
1927
 
1928
             Attempt to qualify the filename against the source path.
1929
             (If that fails, we'll just fall back on the original
1930
             filename.  Not much more we can do...)
1931
           */
1932
          if (!source_full_path_of (exec_file, &full_exec_path))
1933
            full_exec_path = savestring (exec_file, strlen (exec_file));
1934
 
1935
          exec_file_attach (full_exec_path, from_tty);
1936
          symbol_file_add_main (full_exec_path, from_tty);
1937
        }
1938
    }
1939
  else
1940
    {
1941
      reopen_exec_file ();
1942
      reread_symbols ();
1943
    }
1944
 
1945
  /* Take any necessary post-attaching actions for this platform.
1946
   */
1947
  target_post_attach (PIDGET (inferior_ptid));
1948
 
1949
  post_create_inferior (&current_target, from_tty);
1950
 
1951
  /* Install inferior's terminal modes.  */
1952
  target_terminal_inferior ();
1953
 
1954
  normal_stop ();
1955
 
1956
  if (deprecated_attach_hook)
1957
    deprecated_attach_hook ();
1958
}
1959
 
1960
/*
1961
 * detach_command --
1962
 * takes a program previously attached to and detaches it.
1963
 * The program resumes execution and will no longer stop
1964
 * on signals, etc.  We better not have left any breakpoints
1965
 * in the program or it'll die when it hits one.  For this
1966
 * to work, it may be necessary for the process to have been
1967
 * previously attached.  It *might* work if the program was
1968
 * started via the normal ptrace (PTRACE_TRACEME).
1969
 */
1970
 
1971
static void
1972
detach_command (char *args, int from_tty)
1973
{
1974
  dont_repeat ();               /* Not for the faint of heart.  */
1975
  target_detach (args, from_tty);
1976
  no_shared_libraries (NULL, from_tty);
1977
  if (deprecated_detach_hook)
1978
    deprecated_detach_hook ();
1979
}
1980
 
1981
/* Disconnect from the current target without resuming it (leaving it
1982
   waiting for a debugger).
1983
 
1984
   We'd better not have left any breakpoints in the program or the
1985
   next debugger will get confused.  Currently only supported for some
1986
   remote targets, since the normal attach mechanisms don't work on
1987
   stopped processes on some native platforms (e.g. GNU/Linux).  */
1988
 
1989
static void
1990
disconnect_command (char *args, int from_tty)
1991
{
1992
  dont_repeat ();               /* Not for the faint of heart */
1993
  target_disconnect (args, from_tty);
1994
  no_shared_libraries (NULL, from_tty);
1995
  if (deprecated_detach_hook)
1996
    deprecated_detach_hook ();
1997
}
1998
 
1999
/* Stop the execution of the target while running in async mode, in
2000
   the backgound. */
2001
void
2002
interrupt_target_command (char *args, int from_tty)
2003
{
2004
  if (target_can_async_p ())
2005
    {
2006
      dont_repeat ();           /* Not for the faint of heart */
2007
      target_stop ();
2008
    }
2009
}
2010
 
2011
static void
2012
print_float_info (struct gdbarch *gdbarch, struct ui_file *file,
2013
                  struct frame_info *frame, const char *args)
2014
{
2015
  if (gdbarch_print_float_info_p (gdbarch))
2016
    gdbarch_print_float_info (gdbarch, file, frame, args);
2017
  else
2018
    {
2019
      int regnum;
2020
      int printed_something = 0;
2021
 
2022
      for (regnum = 0;
2023
           regnum < gdbarch_num_regs (gdbarch)
2024
                    + gdbarch_num_pseudo_regs (gdbarch);
2025
           regnum++)
2026
        {
2027
          if (gdbarch_register_reggroup_p (gdbarch, regnum, float_reggroup))
2028
            {
2029
              printed_something = 1;
2030
              gdbarch_print_registers_info (gdbarch, file, frame, regnum, 1);
2031
            }
2032
        }
2033
      if (!printed_something)
2034
        fprintf_filtered (file, "\
2035
No floating-point info available for this processor.\n");
2036
    }
2037
}
2038
 
2039
static void
2040
float_info (char *args, int from_tty)
2041
{
2042
  if (!target_has_registers)
2043
    error (_("The program has no registers now."));
2044
 
2045
  print_float_info (current_gdbarch, gdb_stdout,
2046
                    get_selected_frame (NULL), args);
2047
}
2048
 
2049
static void
2050
unset_command (char *args, int from_tty)
2051
{
2052
  printf_filtered (_("\
2053
\"unset\" must be followed by the name of an unset subcommand.\n"));
2054
  help_list (unsetlist, "unset ", -1, gdb_stdout);
2055
}
2056
 
2057
void
2058
_initialize_infcmd (void)
2059
{
2060
  struct cmd_list_element *c = NULL;
2061
 
2062
  /* add the filename of the terminal connected to inferior I/O */
2063
  add_setshow_filename_cmd ("inferior-tty", class_run,
2064
                            &inferior_io_terminal, _("\
2065
Set terminal for future runs of program being debugged."), _("\
2066
Show terminal for future runs of program being debugged."), _("\
2067
Usage: set inferior-tty /dev/pts/1"), NULL, NULL, &setlist, &showlist);
2068
  add_com_alias ("tty", "set inferior-tty", class_alias, 0);
2069
 
2070
  add_setshow_optional_filename_cmd ("args", class_run,
2071
                                     &inferior_args, _("\
2072
Set argument list to give program being debugged when it is started."), _("\
2073
Show argument list to give program being debugged when it is started."), _("\
2074
Follow this command with any number of args, to be passed to the program."),
2075
                                     notice_args_set,
2076
                                     notice_args_read,
2077
                                     &setlist, &showlist);
2078
 
2079
  c = add_cmd ("environment", no_class, environment_info, _("\
2080
The environment to give the program, or one variable's value.\n\
2081
With an argument VAR, prints the value of environment variable VAR to\n\
2082
give the program being debugged.  With no arguments, prints the entire\n\
2083
environment to be given to the program."), &showlist);
2084
  set_cmd_completer (c, noop_completer);
2085
 
2086
  add_prefix_cmd ("unset", no_class, unset_command,
2087
                  _("Complement to certain \"set\" commands."),
2088
                  &unsetlist, "unset ", 0, &cmdlist);
2089
 
2090
  c = add_cmd ("environment", class_run, unset_environment_command, _("\
2091
Cancel environment variable VAR for the program.\n\
2092
This does not affect the program until the next \"run\" command."),
2093
               &unsetlist);
2094
  set_cmd_completer (c, noop_completer);
2095
 
2096
  c = add_cmd ("environment", class_run, set_environment_command, _("\
2097
Set environment variable value to give the program.\n\
2098
Arguments are VAR VALUE where VAR is variable name and VALUE is value.\n\
2099
VALUES of environment variables are uninterpreted strings.\n\
2100
This does not affect the program until the next \"run\" command."),
2101
               &setlist);
2102
  set_cmd_completer (c, noop_completer);
2103
 
2104
  c = add_com ("path", class_files, path_command, _("\
2105
Add directory DIR(s) to beginning of search path for object files.\n\
2106
$cwd in the path means the current working directory.\n\
2107
This path is equivalent to the $PATH shell variable.  It is a list of\n\
2108
directories, separated by colons.  These directories are searched to find\n\
2109
fully linked executable files and separately compiled object files as needed."));
2110
  set_cmd_completer (c, filename_completer);
2111
 
2112
  c = add_cmd ("paths", no_class, path_info, _("\
2113
Current search path for finding object files.\n\
2114
$cwd in the path means the current working directory.\n\
2115
This path is equivalent to the $PATH shell variable.  It is a list of\n\
2116
directories, separated by colons.  These directories are searched to find\n\
2117
fully linked executable files and separately compiled object files as needed."),
2118
               &showlist);
2119
  set_cmd_completer (c, noop_completer);
2120
 
2121
  add_com ("attach", class_run, attach_command, _("\
2122
Attach to a process or file outside of GDB.\n\
2123
This command attaches to another target, of the same type as your last\n\
2124
\"target\" command (\"info files\" will show your target stack).\n\
2125
The command may take as argument a process id or a device file.\n\
2126
For a process id, you must have permission to send the process a signal,\n\
2127
and it must have the same effective uid as the debugger.\n\
2128
When using \"attach\" with a process id, the debugger finds the\n\
2129
program running in the process, looking first in the current working\n\
2130
directory, or (if not found there) using the source file search path\n\
2131
(see the \"directory\" command).  You can also use the \"file\" command\n\
2132
to specify the program, and to load its symbol table."));
2133
 
2134
  add_prefix_cmd ("detach", class_run, detach_command, _("\
2135
Detach a process or file previously attached.\n\
2136
If a process, it is no longer traced, and it continues its execution.  If\n\
2137
you were debugging a file, the file is closed and gdb no longer accesses it."),
2138
                  &detachlist, "detach ", 0, &cmdlist);
2139
 
2140
  add_com ("disconnect", class_run, disconnect_command, _("\
2141
Disconnect from a target.\n\
2142
The target will wait for another debugger to connect.  Not available for\n\
2143
all targets."));
2144
 
2145
  add_com ("signal", class_run, signal_command, _("\
2146
Continue program giving it signal specified by the argument.\n\
2147
An argument of \"0\" means continue program without giving it a signal."));
2148
 
2149
  add_com ("stepi", class_run, stepi_command, _("\
2150
Step one instruction exactly.\n\
2151
Argument N means do this N times (or till program stops for another reason)."));
2152
  add_com_alias ("si", "stepi", class_alias, 0);
2153
 
2154
  add_com ("nexti", class_run, nexti_command, _("\
2155
Step one instruction, but proceed through subroutine calls.\n\
2156
Argument N means do this N times (or till program stops for another reason)."));
2157
  add_com_alias ("ni", "nexti", class_alias, 0);
2158
 
2159
  add_com ("finish", class_run, finish_command, _("\
2160
Execute until selected stack frame returns.\n\
2161
Upon return, the value returned is printed and put in the value history."));
2162
 
2163
  add_com ("next", class_run, next_command, _("\
2164
Step program, proceeding through subroutine calls.\n\
2165
Like the \"step\" command as long as subroutine calls do not happen;\n\
2166
when they do, the call is treated as one instruction.\n\
2167
Argument N means do this N times (or till program stops for another reason)."));
2168
  add_com_alias ("n", "next", class_run, 1);
2169
  if (xdb_commands)
2170
    add_com_alias ("S", "next", class_run, 1);
2171
 
2172
  add_com ("step", class_run, step_command, _("\
2173
Step program until it reaches a different source line.\n\
2174
Argument N means do this N times (or till program stops for another reason)."));
2175
  add_com_alias ("s", "step", class_run, 1);
2176
 
2177
  c = add_com ("until", class_run, until_command, _("\
2178
Execute until the program reaches a source line greater than the current\n\
2179
or a specified location (same args as break command) within the current frame."));
2180
  set_cmd_completer (c, location_completer);
2181
  add_com_alias ("u", "until", class_run, 1);
2182
 
2183
  c = add_com ("advance", class_run, advance_command, _("\
2184
Continue the program up to the given location (same form as args for break command).\n\
2185
Execution will also stop upon exit from the current stack frame."));
2186
  set_cmd_completer (c, location_completer);
2187
 
2188
  c = add_com ("jump", class_run, jump_command, _("\
2189
Continue program being debugged at specified line or address.\n\
2190
Give as argument either LINENUM or *ADDR, where ADDR is an expression\n\
2191
for an address to start at."));
2192
  set_cmd_completer (c, location_completer);
2193
 
2194
  if (xdb_commands)
2195
    {
2196
      c = add_com ("go", class_run, go_command, _("\
2197
Usage: go <location>\n\
2198
Continue program being debugged, stopping at specified line or \n\
2199
address.\n\
2200
Give as argument either LINENUM or *ADDR, where ADDR is an \n\
2201
expression for an address to start at.\n\
2202
This command is a combination of tbreak and jump."));
2203
      set_cmd_completer (c, location_completer);
2204
    }
2205
 
2206
  if (xdb_commands)
2207
    add_com_alias ("g", "go", class_run, 1);
2208
 
2209
  add_com ("continue", class_run, continue_command, _("\
2210
Continue program being debugged, after signal or breakpoint.\n\
2211
If proceeding from breakpoint, a number N may be used as an argument,\n\
2212
which means to set the ignore count of that breakpoint to N - 1 (so that\n\
2213
the breakpoint won't break until the Nth time it is reached)."));
2214
  add_com_alias ("c", "cont", class_run, 1);
2215
  add_com_alias ("fg", "cont", class_run, 1);
2216
 
2217
  c = add_com ("run", class_run, run_command, _("\
2218
Start debugged program.  You may specify arguments to give it.\n\
2219
Args may include \"*\", or \"[...]\"; they are expanded using \"sh\".\n\
2220
Input and output redirection with \">\", \"<\", or \">>\" are also allowed.\n\n\
2221
With no arguments, uses arguments last specified (with \"run\" or \"set args\").\n\
2222
To cancel previous arguments and run with no arguments,\n\
2223
use \"set args\" without arguments."));
2224
  set_cmd_completer (c, filename_completer);
2225
  add_com_alias ("r", "run", class_run, 1);
2226
  if (xdb_commands)
2227
    add_com ("R", class_run, run_no_args_command,
2228
             _("Start debugged program with no arguments."));
2229
 
2230
  c = add_com ("start", class_run, start_command, _("\
2231
Run the debugged program until the beginning of the main procedure.\n\
2232
You may specify arguments to give to your program, just as with the\n\
2233
\"run\" command."));
2234
  set_cmd_completer (c, filename_completer);
2235
 
2236
  add_com ("interrupt", class_run, interrupt_target_command,
2237
           _("Interrupt the execution of the debugged program."));
2238
 
2239
  add_info ("registers", nofp_registers_info, _("\
2240
List of integer registers and their contents, for selected stack frame.\n\
2241
Register name as argument means describe only that register."));
2242
  add_info_alias ("r", "registers", 1);
2243
 
2244
  if (xdb_commands)
2245
    add_com ("lr", class_info, nofp_registers_info, _("\
2246
List of integer registers and their contents, for selected stack frame.\n\
2247
Register name as argument means describe only that register."));
2248
  add_info ("all-registers", all_registers_info, _("\
2249
List of all registers and their contents, for selected stack frame.\n\
2250
Register name as argument means describe only that register."));
2251
 
2252
  add_info ("program", program_info,
2253
            _("Execution status of the program."));
2254
 
2255
  add_info ("float", float_info,
2256
            _("Print the status of the floating point unit\n"));
2257
 
2258
  add_info ("vector", vector_info,
2259
            _("Print the status of the vector unit\n"));
2260
 
2261
  inferior_environ = make_environ ();
2262
  init_environ (inferior_environ);
2263
}

powered by: WebSVN 2.1.0

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