1 /* Memory-access and commands for "inferior" (child) process, for GDB.
2 Copyright 1986, 1987, 1988, 1989, 1991, 1992 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
22 #include <sys/param.h>
36 continue_command
PARAMS ((char *, int));
39 until_next_command
PARAMS ((int));
42 until_command
PARAMS ((char *, int));
45 path_info
PARAMS ((char *, int));
48 path_command
PARAMS ((char *, int));
51 unset_command
PARAMS ((char *, int));
54 float_info
PARAMS ((char *, int));
57 detach_command
PARAMS ((char *, int));
60 nofp_registers_info
PARAMS ((char *, int));
63 all_registers_info
PARAMS ((char *, int));
66 registers_info
PARAMS ((char *, int));
69 do_registers_info
PARAMS ((int, int));
72 unset_environment_command
PARAMS ((char *, int));
75 set_environment_command
PARAMS ((char *, int));
78 environment_info
PARAMS ((char *, int));
81 program_info
PARAMS ((char *, int));
84 finish_command
PARAMS ((char *, int));
87 signal_command
PARAMS ((char *, int));
90 jump_command
PARAMS ((char *, int));
93 step_1
PARAMS ((int, int, char *));
96 nexti_command
PARAMS ((char *, int));
99 stepi_command
PARAMS ((char *, int));
102 next_command
PARAMS ((char *, int));
105 step_command
PARAMS ((char *, int));
108 run_command
PARAMS ((char *, int));
110 #define ERROR_NO_INFERIOR \
111 if (!target_has_execution) error ("The program is not being run.");
113 /* String containing arguments to give to the program, separated by spaces.
114 Empty string (pointer to '\0') means no args. */
116 static char *inferior_args
;
118 /* File name for default use for standard in/out in the inferior. */
120 char *inferior_io_terminal
;
122 /* Pid of our debugged inferior, or 0 if no inferior now.
123 Since various parts of infrun.c test this to see whether there is a program
124 being debugged it should be nonzero (currently 3 is used) for remote
129 /* Last signal that the inferior received (why it stopped). */
131 enum target_signal stop_signal
;
133 /* Address at which inferior stopped. */
137 /* Stack frame when program stopped. */
139 FRAME_ADDR stop_frame_address
;
141 /* Chain containing status of breakpoint(s) that we have stopped at. */
145 /* Flag indicating that a command has proceeded the inferior past the
146 current breakpoint. */
148 int breakpoint_proceeded
;
150 /* Nonzero if stopped due to a step command. */
154 /* Nonzero if stopped due to completion of a stack dummy routine. */
156 int stop_stack_dummy
;
158 /* Nonzero if stopped due to a random (unexpected) signal in inferior
161 int stopped_by_random_signal
;
163 /* Range to single step within.
164 If this is nonzero, respond to a single-step signal
165 by continuing to step if the pc is in this range. */
167 CORE_ADDR step_range_start
; /* Inclusive */
168 CORE_ADDR step_range_end
; /* Exclusive */
170 /* Stack frame address as of when stepping command was issued.
171 This is how we know when we step into a subroutine call,
172 and how to set the frame for the breakpoint used to step out. */
174 FRAME_ADDR step_frame_address
;
176 /* 1 means step over all subroutine calls.
177 0 means don't step over calls (used by stepi).
178 -1 means step over calls to undebuggable functions. */
182 /* If stepping, nonzero means step count is > 1
183 so don't print frame next time inferior stops
184 if it stops due to stepping. */
188 /* Environment to use for running inferior,
189 in format described in environ.h. */
191 struct environ
*inferior_environ
;
196 tty_command (file
, from_tty
)
201 error_no_arg ("terminal name for running target process");
203 inferior_io_terminal
= savestring (file
, strlen (file
));
207 run_command (args
, from_tty
)
215 /* Shouldn't this be target_has_execution? FIXME. */
219 !query ("The program being debugged has been started already.\n\
220 Start it from the beginning? "))
221 error ("Program not restarted.");
225 exec_file
= (char *) get_exec_file (0);
227 /* The exec file is re-read every time we do a generic_mourn_inferior, so
228 we just have to worry about the symbol file. */
231 /* We keep symbols from add-symbol-file, on the grounds that the
232 user might want to add some symbols before running the program
233 (right?). But sometimes (dynamic loading where the user manually
234 introduces the new symbols with add-symbol-file), the code which
235 the symbols describe does not persist between runs. Currently
236 the user has to manually nuke all symbols between runs if they
237 want them to go away (PR 2207). This is probably reasonable. */
242 cmd
= concat ("set args ", args
, NULL
);
243 make_cleanup (free
, cmd
);
244 execute_command (cmd
, from_tty
);
249 puts_filtered("Starting program: ");
251 puts_filtered(exec_file
);
253 puts_filtered(inferior_args
);
255 gdb_flush (gdb_stdout
);
258 target_create_inferior (exec_file
, inferior_args
,
259 environ_vector (inferior_environ
));
263 continue_command (proc_count_exp
, from_tty
)
264 char *proc_count_exp
;
269 /* If have argument, set proceed count of breakpoint we stopped at. */
271 if (proc_count_exp
!= NULL
)
273 bpstat bs
= stop_bpstat
;
274 int num
= bpstat_num (&bs
);
275 if (num
== 0 && from_tty
)
278 ("Not stopped at any breakpoint; argument ignored.\n");
282 set_ignore_count (num
,
283 parse_and_eval_address (proc_count_exp
) - 1,
285 /* set_ignore_count prints a message ending with a period.
286 So print two spaces before "Continuing.". */
288 printf_filtered (" ");
289 num
= bpstat_num (&bs
);
294 printf_filtered ("Continuing.\n");
296 clear_proceed_status ();
298 proceed ((CORE_ADDR
) -1, -1, 0);
301 /* Step until outside of current statement. */
305 step_command (count_string
, from_tty
)
309 step_1 (0, 0, count_string
);
312 /* Likewise, but skip over subroutine calls as if single instructions. */
316 next_command (count_string
, from_tty
)
320 step_1 (1, 0, count_string
);
323 /* Likewise, but step only one instruction. */
327 stepi_command (count_string
, from_tty
)
331 step_1 (0, 1, count_string
);
336 nexti_command (count_string
, from_tty
)
340 step_1 (1, 1, count_string
);
344 step_1 (skip_subroutines
, single_inst
, count_string
)
345 int skip_subroutines
;
349 register int count
= 1;
351 struct cleanup
*cleanups
= 0;
354 count
= count_string
? parse_and_eval_address (count_string
) : 1;
356 if (!single_inst
|| skip_subroutines
) /* leave si command alone */
358 enable_longjmp_breakpoint();
359 cleanups
= make_cleanup(disable_longjmp_breakpoint
, 0);
362 for (; count
> 0; count
--)
364 clear_proceed_status ();
366 fr
= get_current_frame ();
367 if (!fr
) /* Avoid coredump here. Why tho? */
368 error ("No current frame");
369 step_frame_address
= FRAME_FP (fr
);
373 find_pc_line_pc_range (stop_pc
, &step_range_start
, &step_range_end
);
374 if (step_range_end
== 0)
377 if (find_pc_partial_function (stop_pc
, &name
, &step_range_start
,
378 &step_range_end
) == 0)
379 error ("Cannot find bounds of current function");
381 target_terminal_ours ();
383 Single stepping until exit from function %s, \n\
384 which has no line number information.\n", name
);
385 gdb_flush (gdb_stdout
);
390 /* Say we are stepping, but stop after one insn whatever it does. */
391 step_range_start
= step_range_end
= 1;
392 if (!skip_subroutines
)
394 Don't step over function calls, not even to functions lacking
399 if (skip_subroutines
)
402 step_multi
= (count
> 1);
403 proceed ((CORE_ADDR
) -1, -1, 1);
407 /* FIXME: On nexti, this may have already been done (when we hit the
408 step resume break, I think). Probably this should be moved to
409 wait_for_inferior (near the top). */
410 #if defined (SHIFT_INST_REGS)
415 if (!single_inst
|| skip_subroutines
)
416 do_cleanups(cleanups
);
419 /* Continue program at specified address. */
422 jump_command (arg
, from_tty
)
426 register CORE_ADDR addr
;
427 struct symtabs_and_lines sals
;
428 struct symtab_and_line sal
;
435 error_no_arg ("starting address");
437 sals
= decode_line_spec_1 (arg
, 1);
440 error ("Unreasonable jump request");
444 free ((PTR
)sals
.sals
);
446 if (sal
.symtab
== 0 && sal
.pc
== 0)
447 error ("No source file has been specified.");
449 resolve_sal_pc (&sal
); /* May error out */
451 /* See if we are trying to jump to another function. */
452 fn
= get_frame_function (get_current_frame ());
453 sfn
= find_pc_function (sal
.pc
);
454 if (fn
!= NULL
&& sfn
!= fn
)
456 if (!query ("Line %d is not in `%s'. Jump anyway? ", sal
.line
,
457 SYMBOL_SOURCE_NAME (fn
)))
459 error ("Not confirmed.");
467 printf_filtered ("Continuing at %s.\n",
468 local_hex_string((unsigned long) addr
));
470 clear_proceed_status ();
471 proceed (addr
, TARGET_SIGNAL_0
, 0);
474 /* Continue program giving it specified signal. */
477 signal_command (signum_exp
, from_tty
)
481 enum target_signal oursig
;
483 dont_repeat (); /* Too dangerous. */
487 error_no_arg ("signal number");
489 /* It would be even slicker to make signal names be valid expressions,
490 (the type could be "enum $signal" or some such), then the user could
491 assign them to convenience variables. */
492 oursig
= target_signal_from_name (signum_exp
);
494 if (oursig
== TARGET_SIGNAL_UNKNOWN
)
496 /* Not found as a name, try it as an expression. */
497 /* The numeric signal refers to our own internal signal numbering
498 from target.h, not to host/target signal number. This is a
499 feature; users really should be using symbolic names anyway,
500 and the common ones like SIGHUP, SIGINT, SIGALRM, etc. will
501 work right anyway. */
502 int signum
= parse_and_eval_address (signum_exp
);
504 || signum
>= (int)TARGET_SIGNAL_LAST
505 || signum
== (int)TARGET_SIGNAL_UNKNOWN
)
506 error ("Invalid signal number %d.", signum
);
512 if (oursig
== TARGET_SIGNAL_0
)
513 printf_filtered ("Continuing with no signal.\n");
515 printf_filtered ("Continuing with signal %s.\n",
516 target_signal_to_name (oursig
));
519 clear_proceed_status ();
520 proceed (stop_pc
, oursig
, 0);
523 /* Call breakpoint_auto_delete on the current contents of the bpstat
524 pointed to by arg (which is really a bpstat *). */
526 breakpoint_auto_delete_contents (arg
)
529 breakpoint_auto_delete (*(bpstat
*)arg
);
532 /* Execute a "stack dummy", a piece of code stored in the stack
533 by the debugger to be executed in the inferior.
535 To call: first, do PUSH_DUMMY_FRAME.
536 Then push the contents of the dummy. It should end with a breakpoint insn.
537 Then call here, passing address at which to start the dummy.
539 The contents of all registers are saved before the dummy frame is popped
540 and copied into the buffer BUFFER.
542 The dummy's frame is automatically popped whenever that break is hit.
543 If that is the first time the program stops, run_stack_dummy
544 returns to its caller with that frame already gone and returns 0.
545 Otherwise, run_stack-dummy returns 1 (the frame will eventually be popped
546 when we do hit that breakpoint). */
548 /* DEBUG HOOK: 4 => return instead of letting the stack dummy run. */
550 static int stack_dummy_testing
= 0;
553 run_stack_dummy (addr
, buffer
)
555 char buffer
[REGISTER_BYTES
];
557 struct cleanup
*old_cleanups
= make_cleanup (null_cleanup
, 0);
559 /* Now proceed, having reached the desired place. */
560 clear_proceed_status ();
561 if (stack_dummy_testing
& 4)
566 #ifdef CALL_DUMMY_BREAKPOINT_OFFSET
568 struct breakpoint
*bpt
;
569 struct symtab_and_line sal
;
571 #if CALL_DUMMY_LOCATION != AT_ENTRY_POINT
572 sal
.pc
= addr
- CALL_DUMMY_START_OFFSET
+ CALL_DUMMY_BREAKPOINT_OFFSET
;
574 sal
.pc
= entry_point_address ();
579 /* Set up a FRAME for the dummy frame so we can pass it to
580 set_momentary_breakpoint. We need to give the breakpoint a
581 frame in case there is only one copy of the dummy (e.g.
582 CALL_DUMMY_LOCATION == AFTER_TEXT_END). */
583 flush_cached_frames ();
584 set_current_frame (create_new_frame (read_fp (), sal
.pc
));
586 /* If defined, CALL_DUMMY_BREAKPOINT_OFFSET is where we need to put
587 a breakpoint instruction. If not, the call dummy already has the
588 breakpoint instruction in it.
590 addr is the address of the call dummy plus the CALL_DUMMY_START_OFFSET,
591 so we need to subtract the CALL_DUMMY_START_OFFSET. */
592 bpt
= set_momentary_breakpoint (sal
,
593 get_current_frame (),
595 bpt
->disposition
= delete;
597 /* If all error()s out of proceed ended up calling normal_stop (and
598 perhaps they should; it already does in the special case of error
599 out of resume()), then we wouldn't need this. */
600 make_cleanup (breakpoint_auto_delete_contents
, &stop_bpstat
);
602 #endif /* CALL_DUMMY_BREAKPOINT_OFFSET. */
604 proceed_to_finish
= 1; /* We want stop_registers, please... */
605 proceed (addr
, TARGET_SIGNAL_0
, 0);
607 discard_cleanups (old_cleanups
);
609 if (!stop_stack_dummy
)
612 /* On return, the stack dummy has been popped already. */
614 memcpy (buffer
, stop_registers
, sizeof stop_registers
);
618 /* Proceed until we reach a different source line with pc greater than
619 our current one or exit the function. We skip calls in both cases.
621 Note that eventually this command should probably be changed so
622 that only source lines are printed out when we hit the breakpoint
623 we set. I'm going to postpone this until after a hopeful rewrite
624 of wait_for_inferior and the proceed status code. -- randy */
628 until_next_command (from_tty
)
634 struct symtab_and_line sal
;
636 clear_proceed_status ();
638 frame
= get_current_frame ();
640 /* Step until either exited from this function or greater
641 than the current line (if in symbolic section) or pc (if
645 func
= find_pc_function (pc
);
649 struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (pc
);
652 error ("Execution is not within a known function.");
654 step_range_start
= SYMBOL_VALUE_ADDRESS (msymbol
);
659 sal
= find_pc_line (pc
, 0);
661 step_range_start
= BLOCK_START (SYMBOL_BLOCK_VALUE (func
));
662 step_range_end
= sal
.end
;
666 step_frame_address
= FRAME_FP (frame
);
668 step_multi
= 0; /* Only one call to proceed */
670 proceed ((CORE_ADDR
) -1, -1, 1);
674 until_command (arg
, from_tty
)
678 if (!target_has_execution
)
679 error ("The program is not running.");
681 until_break_command (arg
, from_tty
);
683 until_next_command (from_tty
);
686 /* "finish": Set a temporary breakpoint at the place
687 the selected frame will return to, then continue. */
690 finish_command (arg
, from_tty
)
694 struct symtab_and_line sal
;
695 register FRAME frame
;
696 struct frame_info
*fi
;
697 register struct symbol
*function
;
698 struct breakpoint
*breakpoint
;
699 struct cleanup
*old_chain
;
702 error ("The \"finish\" command does not take any arguments.");
703 if (!target_has_execution
)
704 error ("The program is not running.");
705 if (selected_frame
== NULL
)
706 error ("No selected frame.");
708 frame
= get_prev_frame (selected_frame
);
710 error ("\"finish\" not meaningful in the outermost frame.");
712 clear_proceed_status ();
714 fi
= get_frame_info (frame
);
715 sal
= find_pc_line (fi
->pc
, 0);
718 breakpoint
= set_momentary_breakpoint (sal
, frame
, bp_finish
);
720 old_chain
= make_cleanup(delete_breakpoint
, breakpoint
);
722 /* Find the function we will return from. */
724 fi
= get_frame_info (selected_frame
);
725 function
= find_pc_function (fi
->pc
);
727 /* Print info on the selected frame, including level number
731 printf_filtered ("Run till exit from ");
732 print_stack_frame (selected_frame
, selected_frame_level
, 0);
735 proceed_to_finish
= 1; /* We want stop_registers, please... */
736 proceed ((CORE_ADDR
) -1, -1, 0);
738 /* Did we stop at our breakpoint? */
739 if (bpstat_find_breakpoint(stop_bpstat
, breakpoint
) != NULL
742 struct type
*value_type
;
746 value_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (function
));
748 fatal ("internal: finish_command: function has no target type");
750 if (TYPE_CODE (value_type
) == TYPE_CODE_VOID
)
753 funcaddr
= BLOCK_START (SYMBOL_BLOCK_VALUE (function
));
755 val
= value_being_returned (value_type
, stop_registers
,
756 using_struct_return (value_of_variable (function
, NULL
),
759 BLOCK_GCC_COMPILED (SYMBOL_BLOCK_VALUE (function
))));
761 printf_filtered ("Value returned is $%d = ", record_latest_value (val
));
762 value_print (val
, gdb_stdout
, 0, Val_no_prettyprint
);
763 printf_filtered ("\n");
765 do_cleanups(old_chain
);
770 program_info (args
, from_tty
)
774 bpstat bs
= stop_bpstat
;
775 int num
= bpstat_num (&bs
);
777 if (!target_has_execution
)
779 printf_filtered ("The program being debugged is not being run.\n");
783 target_files_info ();
784 printf_filtered ("Program stopped at %s.\n",
785 local_hex_string((unsigned long) stop_pc
));
787 printf_filtered ("It stopped after being stepped.\n");
790 /* There may be several breakpoints in the same place, so this
791 isn't as strange as it seems. */
795 printf_filtered ("It stopped at a breakpoint that has since been deleted.\n");
797 printf_filtered ("It stopped at breakpoint %d.\n", num
);
798 num
= bpstat_num (&bs
);
801 else if (stop_signal
!= TARGET_SIGNAL_0
)
803 printf_filtered ("It stopped with signal %s, %s.\n",
804 target_signal_to_name (stop_signal
),
805 target_signal_to_string (stop_signal
));
809 printf_filtered ("Type \"info stack\" or \"info registers\" for more information.\n");
813 environment_info (var
, from_tty
)
819 register char *val
= get_in_environ (inferior_environ
, var
);
823 puts_filtered (" = ");
825 puts_filtered ("\n");
829 puts_filtered ("Environment variable \"");
831 puts_filtered ("\" not defined.\n");
836 register char **vector
= environ_vector (inferior_environ
);
839 puts_filtered (*vector
++);
840 puts_filtered ("\n");
846 set_environment_command (arg
, from_tty
)
850 register char *p
, *val
, *var
;
854 error_no_arg ("environment variable and value");
856 /* Find seperation between variable name and value */
857 p
= (char *) strchr (arg
, '=');
858 val
= (char *) strchr (arg
, ' ');
860 if (p
!= 0 && val
!= 0)
862 /* We have both a space and an equals. If the space is before the
863 equals, walk forward over the spaces til we see a nonspace
864 (possibly the equals). */
869 /* Now if the = is after the char following the spaces,
870 take the char following the spaces. */
874 else if (val
!= 0 && p
== 0)
878 error_no_arg ("environment variable to set");
880 if (p
== 0 || p
[1] == 0)
884 p
= arg
+ strlen (arg
); /* So that savestring below will work */
888 /* Not setting variable value to null */
890 while (*val
== ' ' || *val
== '\t')
894 while (p
!= arg
&& (p
[-1] == ' ' || p
[-1] == '\t')) p
--;
896 var
= savestring (arg
, p
- arg
);
899 printf_filtered ("Setting environment variable \"%s\" to null value.\n", var
);
900 set_in_environ (inferior_environ
, var
, "");
903 set_in_environ (inferior_environ
, var
, val
);
908 unset_environment_command (var
, from_tty
)
914 /* If there is no argument, delete all environment variables.
915 Ask for confirmation if reading from the terminal. */
916 if (!from_tty
|| query ("Delete all environment variables? "))
918 free_environ (inferior_environ
);
919 inferior_environ
= make_environ ();
923 unset_in_environ (inferior_environ
, var
);
926 /* Handle the execution path (PATH variable) */
928 static const char path_var_name
[] = "PATH";
932 path_info (args
, from_tty
)
936 puts_filtered ("Executable and object file path: ");
937 puts_filtered (get_in_environ (inferior_environ
, path_var_name
));
938 puts_filtered ("\n");
941 /* Add zero or more directories to the front of the execution path. */
944 path_command (dirname
, from_tty
)
951 exec_path
= strsave (get_in_environ (inferior_environ
, path_var_name
));
952 mod_path (dirname
, &exec_path
);
953 set_in_environ (inferior_environ
, path_var_name
, exec_path
);
956 path_info ((char *)NULL
, from_tty
);
959 /* This routine is getting awfully cluttered with #if's. It's probably
960 time to turn this into READ_PC and define it in the tm.h file.
961 Ditto for write_pc. */
966 #ifdef TARGET_READ_PC
967 return TARGET_READ_PC ();
969 return ADDR_BITS_REMOVE ((CORE_ADDR
) read_register (PC_REGNUM
));
977 #ifdef TARGET_WRITE_PC
978 TARGET_WRITE_PC (val
);
980 write_register (PC_REGNUM
, (long) val
);
982 write_register (NPC_REGNUM
, (long) val
+ 4);
984 write_register (NNPC_REGNUM
, (long) val
+ 8);
990 /* Cope with strage ways of getting to the stack and frame pointers */
995 #ifdef TARGET_READ_SP
996 return TARGET_READ_SP ();
998 return read_register (SP_REGNUM
);
1006 #ifdef TARGET_WRITE_SP
1007 TARGET_WRITE_SP (val
);
1009 write_register (SP_REGNUM
, val
);
1017 #ifdef TARGET_READ_FP
1018 return TARGET_READ_FP ();
1020 return read_register (FP_REGNUM
);
1028 #ifdef TARGET_WRITE_FP
1029 TARGET_WRITE_FP (val
);
1031 write_register (FP_REGNUM
, val
);
1035 const char * const reg_names
[] = REGISTER_NAMES
;
1037 /* Print out the machine register regnum. If regnum is -1,
1038 print all registers (fpregs == 1) or all non-float registers
1041 For most machines, having all_registers_info() print the
1042 register(s) one per line is good enough. If a different format
1043 is required, (eg, for MIPS or Pyramid 90x, which both have
1044 lots of regs), or there is an existing convention for showing
1045 all the registers, define the macro DO_REGISTERS_INFO(regnum, fp)
1046 to provide that format. */
1048 #if !defined (DO_REGISTERS_INFO)
1049 #define DO_REGISTERS_INFO(regnum, fp) do_registers_info(regnum, fp)
1051 do_registers_info (regnum
, fpregs
)
1057 for (i
= 0; i
< NUM_REGS
; i
++)
1059 char raw_buffer
[MAX_REGISTER_RAW_SIZE
];
1060 char virtual_buffer
[MAX_REGISTER_VIRTUAL_SIZE
];
1062 /* Decide between printing all regs, nonfloat regs, or specific reg. */
1064 if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (i
)) == TYPE_CODE_FLT
&& !fpregs
)
1071 fputs_filtered (reg_names
[i
], gdb_stdout
);
1072 print_spaces_filtered (15 - strlen (reg_names
[i
]), gdb_stdout
);
1074 /* Get the data in raw format. */
1075 if (read_relative_register_raw_bytes (i
, raw_buffer
))
1077 printf_filtered ("Invalid register contents\n");
1081 /* Convert raw data to virtual format if necessary. */
1082 #ifdef REGISTER_CONVERTIBLE
1083 if (REGISTER_CONVERTIBLE (i
))
1085 REGISTER_CONVERT_TO_VIRTUAL (i
, REGISTER_VIRTUAL_TYPE (i
),
1086 raw_buffer
, virtual_buffer
);
1090 memcpy (virtual_buffer
, raw_buffer
,
1091 REGISTER_VIRTUAL_SIZE (i
));
1093 /* If virtual format is floating, print it that way, and in raw hex. */
1094 if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (i
)) == TYPE_CODE_FLT
1095 && ! INVALID_FLOAT (virtual_buffer
, REGISTER_VIRTUAL_SIZE (i
)))
1099 val_print (REGISTER_VIRTUAL_TYPE (i
), virtual_buffer
, 0,
1100 gdb_stdout
, 0, 1, 0, Val_pretty_default
);
1102 printf_filtered ("\t(raw 0x");
1103 for (j
= 0; j
< REGISTER_RAW_SIZE (i
); j
++)
1104 printf_filtered ("%02x", (unsigned char)raw_buffer
[j
]);
1105 printf_filtered (")");
1108 /* FIXME! val_print probably can handle all of these cases now... */
1110 /* Else if virtual format is too long for printf,
1111 print in hex a byte at a time. */
1112 else if (REGISTER_VIRTUAL_SIZE (i
) > sizeof (long))
1115 printf_filtered ("0x");
1116 for (j
= 0; j
< REGISTER_VIRTUAL_SIZE (i
); j
++)
1117 printf_filtered ("%02x", (unsigned char)virtual_buffer
[j
]);
1119 /* Else print as integer in hex and in decimal. */
1122 val_print (REGISTER_VIRTUAL_TYPE (i
), raw_buffer
, 0,
1123 gdb_stdout
, 'x', 1, 0, Val_pretty_default
);
1124 printf_filtered ("\t");
1125 val_print (REGISTER_VIRTUAL_TYPE (i
), raw_buffer
, 0,
1126 gdb_stdout
, 0, 1, 0, Val_pretty_default
);
1129 /* The SPARC wants to print even-numbered float regs as doubles
1130 in addition to printing them as floats. */
1131 #ifdef PRINT_REGISTER_HOOK
1132 PRINT_REGISTER_HOOK (i
);
1135 printf_filtered ("\n");
1138 #endif /* no DO_REGISTERS_INFO. */
1141 registers_info (addr_exp
, fpregs
)
1148 if (!target_has_registers
)
1149 error ("The program has no registers now.");
1153 DO_REGISTERS_INFO(-1, fpregs
);
1159 if (addr_exp
[0] == '$')
1162 while (*end
!= '\0' && *end
!= ' ' && *end
!= '\t')
1164 for (regnum
= 0; regnum
< NUM_REGS
; regnum
++)
1165 if (!strncmp (addr_exp
, reg_names
[regnum
], end
- addr_exp
)
1166 && strlen (reg_names
[regnum
]) == end
- addr_exp
)
1168 if (*addr_exp
>= '0' && *addr_exp
<= '9')
1169 regnum
= atoi (addr_exp
); /* Take a number */
1170 if (regnum
>= NUM_REGS
) /* Bad name, or bad number */
1171 error ("%.*s: invalid register", end
- addr_exp
, addr_exp
);
1174 DO_REGISTERS_INFO(regnum
, fpregs
);
1177 while (*addr_exp
== ' ' || *addr_exp
== '\t')
1179 } while (*addr_exp
!= '\0');
1183 all_registers_info (addr_exp
, from_tty
)
1187 registers_info (addr_exp
, 1);
1191 nofp_registers_info (addr_exp
, from_tty
)
1195 registers_info (addr_exp
, 0);
1200 * Should save/restore the tty state since it might be that the
1201 * program to be debugged was started on this tty and it wants
1202 * the tty in some state other than what we want. If it's running
1203 * on another terminal or without a terminal, then saving and
1204 * restoring the tty state is a harmless no-op.
1205 * This only needs to be done if we are attaching to a process.
1210 takes a program started up outside of gdb and ``attaches'' to it.
1211 This stops it cold in its tracks and allows us to start debugging it.
1212 and wait for the trace-trap that results from attaching. */
1215 attach_command (args
, from_tty
)
1219 dont_repeat (); /* Not for the faint of heart */
1221 if (target_has_execution
)
1223 if (query ("A program is being debugged already. Kill it? "))
1226 error ("Not killed.");
1229 target_attach (args
, from_tty
);
1231 /* Set up the "saved terminal modes" of the inferior
1232 based on what modes we are starting it with. */
1233 target_terminal_init ();
1235 /* Install inferior's terminal modes. */
1236 target_terminal_inferior ();
1238 /* Set up execution context to know that we should return from
1239 wait_for_inferior as soon as the target reports a stop. */
1240 init_wait_for_inferior ();
1241 clear_proceed_status ();
1242 stop_soon_quietly
= 1;
1244 wait_for_inferior ();
1247 /* Add shared library symbols from the newly attached process, if any. */
1248 SOLIB_ADD ((char *)0, from_tty
, (struct target_ops
*)0);
1256 * takes a program previously attached to and detaches it.
1257 * The program resumes execution and will no longer stop
1258 * on signals, etc. We better not have left any breakpoints
1259 * in the program or it'll die when it hits one. For this
1260 * to work, it may be necessary for the process to have been
1261 * previously attached. It *might* work if the program was
1262 * started via the normal ptrace (PTRACE_TRACEME).
1266 detach_command (args
, from_tty
)
1270 dont_repeat (); /* Not for the faint of heart */
1271 target_detach (args
, from_tty
);
1276 float_info (addr_exp
, from_tty
)
1283 printf_filtered ("No floating point info available for this processor.\n");
1289 unset_command (args
, from_tty
)
1293 printf_filtered ("\"unset\" must be followed by the name of an unset subcommand.\n");
1294 help_list (unsetlist
, "unset ", -1, gdb_stdout
);
1298 _initialize_infcmd ()
1300 struct cmd_list_element
*c
;
1302 add_com ("tty", class_run
, tty_command
,
1303 "Set terminal for future runs of program being debugged.");
1306 (add_set_cmd ("args", class_run
, var_string_noescape
, (char *)&inferior_args
,
1308 "Set arguments to give program being debugged when it is started.\n\
1309 Follow this command with any number of args, to be passed to the program.",
1314 ("environment", no_class
, environment_info
,
1315 "The environment to give the program, or one variable's value.\n\
1316 With an argument VAR, prints the value of environment variable VAR to\n\
1317 give the program being debugged. With no arguments, prints the entire\n\
1318 environment to be given to the program.", &showlist
);
1319 c
->completer
= noop_completer
;
1321 add_prefix_cmd ("unset", no_class
, unset_command
,
1322 "Complement to certain \"set\" commands",
1323 &unsetlist
, "unset ", 0, &cmdlist
);
1325 c
= add_cmd ("environment", class_run
, unset_environment_command
,
1326 "Cancel environment variable VAR for the program.\n\
1327 This does not affect the program until the next \"run\" command.",
1329 c
->completer
= noop_completer
;
1331 c
= add_cmd ("environment", class_run
, set_environment_command
,
1332 "Set environment variable value to give the program.\n\
1333 Arguments are VAR VALUE where VAR is variable name and VALUE is value.\n\
1334 VALUES of environment variables are uninterpreted strings.\n\
1335 This does not affect the program until the next \"run\" command.",
1337 c
->completer
= noop_completer
;
1339 add_com ("path", class_files
, path_command
,
1340 "Add directory DIR(s) to beginning of search path for object files.\n\
1341 $cwd in the path means the current working directory.\n\
1342 This path is equivalent to the $PATH shell variable. It is a list of\n\
1343 directories, separated by colons. These directories are searched to find\n\
1344 fully linked executable files and separately compiled object files as needed.");
1346 c
= add_cmd ("paths", no_class
, path_info
,
1347 "Current search path for finding object files.\n\
1348 $cwd in the path means the current working directory.\n\
1349 This path is equivalent to the $PATH shell variable. It is a list of\n\
1350 directories, separated by colons. These directories are searched to find\n\
1351 fully linked executable files and separately compiled object files as needed.", &showlist
);
1352 c
->completer
= noop_completer
;
1354 add_com ("attach", class_run
, attach_command
,
1355 "Attach to a process or file outside of GDB.\n\
1356 This command attaches to another target, of the same type as your last\n\
1357 `target' command (`info files' will show your target stack).\n\
1358 The command may take as argument a process id or a device file.\n\
1359 For a process id, you must have permission to send the process a signal,\n\
1360 and it must have the same effective uid as the debugger.\n\
1361 When using \"attach\", you should use the \"file\" command to specify\n\
1362 the program running in the process, and to load its symbol table.");
1364 add_com ("detach", class_run
, detach_command
,
1365 "Detach a process or file previously attached.\n\
1366 If a process, it is no longer traced, and it continues its execution. If you\n\
1367 were debugging a file, the file is closed and gdb no longer accesses it.");
1369 add_com ("signal", class_run
, signal_command
,
1370 "Continue program giving it signal number SIGNUMBER.");
1372 add_com ("stepi", class_run
, stepi_command
,
1373 "Step one instruction exactly.\n\
1374 Argument N means do this N times (or till program stops for another reason).");
1375 add_com_alias ("si", "stepi", class_alias
, 0);
1377 add_com ("nexti", class_run
, nexti_command
,
1378 "Step one instruction, but proceed through subroutine calls.\n\
1379 Argument N means do this N times (or till program stops for another reason).");
1380 add_com_alias ("ni", "nexti", class_alias
, 0);
1382 add_com ("finish", class_run
, finish_command
,
1383 "Execute until selected stack frame returns.\n\
1384 Upon return, the value returned is printed and put in the value history.");
1386 add_com ("next", class_run
, next_command
,
1387 "Step program, proceeding through subroutine calls.\n\
1388 Like the \"step\" command as long as subroutine calls do not happen;\n\
1389 when they do, the call is treated as one instruction.\n\
1390 Argument N means do this N times (or till program stops for another reason).");
1391 add_com_alias ("n", "next", class_run
, 1);
1393 add_com ("step", class_run
, step_command
,
1394 "Step program until it reaches a different source line.\n\
1395 Argument N means do this N times (or till program stops for another reason).");
1396 add_com_alias ("s", "step", class_run
, 1);
1398 add_com ("until", class_run
, until_command
,
1399 "Execute until the program reaches a source line greater than the current\n\
1400 or a specified line or address or function (same args as break command).\n\
1401 Execution will also stop upon exit from the current stack frame.");
1402 add_com_alias ("u", "until", class_run
, 1);
1404 add_com ("jump", class_run
, jump_command
,
1405 "Continue program being debugged at specified line or address.\n\
1406 Give as argument either LINENUM or *ADDR, where ADDR is an expression\n\
1407 for an address to start at.");
1409 add_com ("continue", class_run
, continue_command
,
1410 "Continue program being debugged, after signal or breakpoint.\n\
1411 If proceeding from breakpoint, a number N may be used as an argument,\n\
1412 which means to set the ignore count of that breakpoint to N - 1 (so that\n\
1413 the breakpoint won't break until the Nth time it is reached).");
1414 add_com_alias ("c", "cont", class_run
, 1);
1415 add_com_alias ("fg", "cont", class_run
, 1);
1417 add_com ("run", class_run
, run_command
,
1418 "Start debugged program. You may specify arguments to give it.\n\
1419 Args may include \"*\", or \"[...]\"; they are expanded using \"sh\".\n\
1420 Input and output redirection with \">\", \"<\", or \">>\" are also allowed.\n\n\
1421 With no arguments, uses arguments last specified (with \"run\" or \"set args\").\n\
1422 To cancel previous arguments and run with no arguments,\n\
1423 use \"set args\" without arguments.");
1424 add_com_alias ("r", "run", class_run
, 1);
1426 add_info ("registers", nofp_registers_info
,
1427 "List of integer registers and their contents, for selected stack frame.\n\
1428 Register name as argument means describe only that register.");
1430 add_info ("all-registers", all_registers_info
,
1431 "List of all registers and their contents, for selected stack frame.\n\
1432 Register name as argument means describe only that register.");
1434 add_info ("program", program_info
,
1435 "Execution status of the program.");
1437 add_info ("float", float_info
,
1438 "Print the status of the floating point unit\n");
1440 inferior_args
= savestring ("", 1); /* Initially no args */
1441 inferior_environ
= make_environ ();
1442 init_environ (inferior_environ
);