home *** CD-ROM | disk | FTP | other *** search
# 1 "infrun.c" # 1 "u:\\c\\gnu\\include\\stdio.h" 1 # 1 "u:\\c\\gnu\\include\\compiler.h" 1 # 54 "u:\\c\\gnu\\include\\compiler.h" # 69 "u:\\c\\gnu\\include\\compiler.h" # 98 "u:\\c\\gnu\\include\\compiler.h" # 115 "u:\\c\\gnu\\include\\compiler.h" # 167 "u:\\c\\gnu\\include\\compiler.h" # 11 "u:\\c\\gnu\\include\\stdio.h" 2 typedef unsigned long size_t; typedef struct { long _cnt; unsigned char *_ptr; unsigned char *_base; unsigned int _flag; int _file; long _bsiz; unsigned char _ch; } FILE; typedef unsigned long fpos_t; extern FILE _iob[]; int remove (const char *) ; int rename (const char *, const char *) ; char * tmpnam (char *) ; FILE * tmpfile (void) ; int fclose (FILE *) ; int fflush (FILE *) ; FILE * fopen (const char *, const char *) ; FILE * freopen (const char *, const char *, FILE *) ; void setbuf (FILE *, char *) ; int setvbuf (FILE *, char *, int, size_t) ; int fscanf (FILE *, const char *, ...) ; int scanf (const char *, ...) ; int sscanf (const char *, const char *, ...) ; int fprintf (FILE *, const char *, ...) ; int printf (const char *, ...) ; int sprintf (char *, const char *, ...) ; int vfprintf (FILE *, const char *, char * ) ; int vprintf (const char *, char * ) ; int vsprintf (char *, const char *, char * ) ; int fgetc (FILE *) ; char *fgets (char *, int, FILE *) ; char *gets (char *) ; int fputc (int c, FILE *) ; int fputs (const char *, FILE *) ; int puts (const char *) ; int fungetc (int, FILE *) ; size_t fread (void *, size_t, size_t, FILE *) ; size_t fwrite (const void *, size_t, size_t, FILE *) ; int fgetpos (FILE *, fpos_t *) ; int fsetpos (FILE *, fpos_t *) ; int fseek (FILE *, long, int) ; long ftell (FILE *) ; void rewind (FILE *) ; void perror (const char *) ; FILE *fdopen (int, const char *) ; FILE *popen (const char *, const char *) ; int pclose (FILE *) ; void _binmode (int) ; long getl (FILE *) ; long putl (long, FILE *) ; short getw (FILE *) ; short putw (short, FILE *) ; int _filbuf (FILE *) ; # 182 "u:\\c\\gnu\\include\\stdio.h" # 119 "infrun.c" 2 # 1 "defs.h" 1 extern char *savestring (); extern char *concat (); extern char *xmalloc (), *xrealloc (); extern int parse_escape (); extern char *reg_names[]; extern int quit_flag; extern int immediate_quit; enum command_class { no_class = -1, class_run = 0, class_vars, class_stack, class_files, class_support, class_info, class_breakpoint, class_alias, class_obscure, class_user, }; struct cleanup { struct cleanup *next; void (*function) (); int arg; }; extern void do_cleanups (); extern void discard_cleanups (); extern struct cleanup *make_cleanup (); extern struct cleanup *save_cleanups (); extern void restore_cleanups (); extern void free_current_contents (); extern void reinitialize_more_filter (); extern void fputs_filtered (); extern void fprintf_filtered (); extern void printf_filtered (); extern void print_spaces_filtered (); extern char *tilde_expand (); struct command_line { struct command_line *next; char *line; }; struct command_line *read_command_lines (); char *current_directory; # 120 "infrun.c" 2 # 1 "param.h" 1 # 281 "param.h" # 340 "param.h" # 355 "param.h" # 378 "param.h" # 121 "infrun.c" 2 # 1 "symtab.h" 1 # 1 "u:\\c\\gnu\\include\\obstack.h" 1 struct _obstack_chunk { char *limit; struct _obstack_chunk *prev; char contents[4]; }; struct obstack { size_t chunk_size; struct _obstack_chunk* chunk; char *object_base; char *next_free; char *chunk_limit; long temp; int alignment_mask; struct _obstack_chunk *(*chunkfun) (size_t) ; void (*freefun) (struct _obstack_chunk*) ; char maybe_empty_object; }; extern void _obstack_newchunk (struct obstack *, size_t); extern void _obstack_free (struct obstack *, void *); extern void _obstack_begin (struct obstack *, size_t, int, void *(*) (), void (*) ()); void obstack_init (struct obstack *obstack); void * obstack_alloc (struct obstack *obstack, size_t size); void * obstack_copy (struct obstack *obstack, void *address, size_t size); void * obstack_copy0 (struct obstack *obstack, void *address, size_t size); void obstack_free (struct obstack *obstack, void *block); void obstack_blank (struct obstack *obstack, size_t size); void obstack_grow (struct obstack *obstack, void *data, size_t size); void obstack_grow0 (struct obstack *obstack, void *data, size_t size); void obstack_1grow (struct obstack *obstack, int data_char); void obstack_ptr_grow (struct obstack *obstack, void *data); void obstack_int_grow (struct obstack *obstack, int data); void obstack_long_grow (struct obstack *obstack, long data); void * obstack_finish (struct obstack *obstack); size_t obstack_object_size (struct obstack *obstack); size_t obstack_room (struct obstack *obstack); void obstack_1grow_fast (struct obstack *obstack, int data_char); void obstack_ptr_grow_fast (struct obstack *obstack, void *data); void obstack_int_grow_fast (struct obstack *obstack, int data); void obstack_blank_fast (struct obstack *obstack, size_t size); void * obstack_base (struct obstack *obstack); void * obstack_next_free (struct obstack *obstack); int obstack_alignment_mask (struct obstack *obstack); size_t obstack_chunk_size (struct obstack *obstack); # 272 "u:\\c\\gnu\\include\\obstack.h" # 283 "u:\\c\\gnu\\include\\obstack.h" # 367 "u:\\c\\gnu\\include\\obstack.h" # 470 "u:\\c\\gnu\\include\\obstack.h" # 20 "symtab.h" 2 extern struct obstack *symbol_obstack; extern struct obstack *psymbol_obstack; extern char *xmalloc (); extern void free (); enum misc_function_type {mf_unknown = 0, mf_text, mf_data, mf_bss, mf_abs}; struct misc_function { char *name; unsigned int address; unsigned char type; }; struct misc_function *misc_function_vector; int misc_function_count; # 1 "symseg.h" 1 enum language {language_c}; struct symbol_root { int format; int length; int ldsymoff; int textrel; int datarel; int bssrel; char *filename; char *filedir; struct blockvector *blockvector; struct typevector *typevector; enum language language; char *version; char *compilation; int databeg; int bssbeg; struct sourcevector *sourcevector; }; struct typevector { int length; struct type *type[1]; }; enum type_code { TYPE_CODE_UNDEF, TYPE_CODE_PTR, TYPE_CODE_ARRAY, TYPE_CODE_STRUCT, TYPE_CODE_UNION, TYPE_CODE_ENUM, TYPE_CODE_FUNC, TYPE_CODE_INT, TYPE_CODE_FLT, TYPE_CODE_VOID, TYPE_CODE_SET, TYPE_CODE_RANGE, TYPE_CODE_PASCAL_ARRAY, TYPE_CODE_MEMBER, TYPE_CODE_METHOD, TYPE_CODE_REF, }; struct type { enum type_code code; char *name; int length; struct type *target_type; struct type *pointer_type; struct type *reference_type; struct type **arg_types; struct type *function_type; struct type *main_variant, *next_variant; short flags; short nfields; struct field { int bitpos; int bitsize; struct type *type; char *name; } *fields; int *private_field_bits; int *protected_field_bits; short nfn_fields; short n_baseclasses; int nfn_fields_total; struct fn_fieldlist { char *name; int length; struct fn_field { struct type *type; struct type **args; char *physname; int voffset; } *fn_fields; int *private_fn_field_bits; int *protected_fn_field_bits; } *fn_fieldlists; unsigned char via_protected; unsigned char via_public; struct type *vptr_basetype; int vptr_fieldno; struct type **baseclasses; }; struct blockvector { int nblocks; struct block *block[1]; }; struct block { int startaddr, endaddr; struct symbol *function; struct block *superblock; unsigned char gcc_compile_flag; int nsyms; struct symbol *sym[1]; }; enum namespace { UNDEF_NAMESPACE, VAR_NAMESPACE, STRUCT_NAMESPACE, LABEL_NAMESPACE, }; enum address_class { LOC_UNDEF, LOC_CONST, LOC_STATIC, LOC_REGISTER, LOC_ARG, LOC_REF_ARG, LOC_REGPARM, LOC_LOCAL, LOC_TYPEDEF, LOC_LABEL, LOC_BLOCK, LOC_EXTERNAL, LOC_CONST_BYTES }; struct symbol { char *name; enum namespace namespace; enum address_class class; struct type *type; union { long value; struct block *block; char *bytes; } value; }; struct partial_symbol { char *name; enum namespace namespace; enum address_class class; union { long value; } value; }; extern struct psymbol_allocation_list { struct partial_symbol *list, *next; int size; } global_psymbols, static_psymbols; struct sourcevector { int length; struct source *source[1]; }; struct linetable_entry { int line; unsigned int pc; }; struct linetable { int nitems; struct linetable_entry item[1]; }; struct source { char *name; struct linetable contents; }; # 64 "symtab.h" 2 struct symtab { struct symtab *next; struct blockvector *blockvector; struct linetable *linetable; struct typevector *typevector; char *filename; enum free_code {free_nothing, free_contents, free_linetable} free_code; char *free_ptr; int nlines; int *line_charpos; enum language language; char *version; char *compilation; int ldsymoff; char *fullname; }; struct partial_symtab { struct partial_symtab *next; char *filename; int ldsymoff, ldsymlen; int textlow, texthigh; unsigned char readin; struct partial_symtab **dependencies; int number_of_dependencies; int globals_offset, n_global_syms; int statics_offset, n_static_syms; }; struct symtab *symtab_list; struct partial_symtab *partial_symtab_list; struct symtab *current_source_symtab; int current_source_line; extern struct symtab *lookup_symtab (); extern struct symbol *lookup_symbol (); extern struct type *lookup_typename (); extern struct type *lookup_unsigned_typename (); extern struct type *lookup_struct (); extern struct type *lookup_union (); extern struct type *lookup_enum (); extern struct type *lookup_struct_elt_type (); extern struct type *lookup_pointer_type (); extern struct type *lookup_function_type (); extern struct type *lookup_basetype_type (); extern struct type *create_array_type (); extern struct symbol *block_function (); extern struct symbol *find_pc_function (); extern int find_pc_partial_function (); extern struct partial_symtab *find_pc_psymtab (); extern struct symtab *find_pc_symtab (); extern struct partial_symbol *find_pc_psymbol (); extern int find_pc_misc_function (); extern struct type *lookup_reference_type (); extern struct type *lookup_member_type (); extern struct type *lookup_class (); extern struct type *builtin_type_void; extern struct type *builtin_type_char; extern struct type *builtin_type_short; extern struct type *builtin_type_int; extern struct type *builtin_type_long; extern struct type *builtin_type_unsigned_char; extern struct type *builtin_type_unsigned_short; extern struct type *builtin_type_unsigned_int; extern struct type *builtin_type_unsigned_long; extern struct type *builtin_type_float; extern struct type *builtin_type_double; # 334 "symtab.h" struct symtab_and_line { struct symtab *symtab; int line; unsigned int pc; unsigned int end; }; struct symtabs_and_lines { struct symtab_and_line *sals; int nelts; }; struct symtab_and_line find_pc_line (); struct symtabs_and_lines decode_line_spec (); struct symtabs_and_lines decode_line_spec_1 (); struct symtabs_and_lines decode_line_1 (); # 122 "infrun.c" 2 # 1 "frame.h" 1 typedef struct frame_info *FRAME; typedef unsigned int FRAME_ADDR; struct frame_info { FRAME_ADDR frame; unsigned int pc; FRAME_ADDR next_frame; FRAME next, prev; }; struct frame_saved_regs { unsigned int regs[18 ]; }; extern FRAME selected_frame; extern struct frame_info *get_frame_info (); extern struct frame_info *get_prev_frame_info (); extern FRAME create_new_frame (); extern void get_frame_saved_regs (); extern FRAME get_prev_frame (); extern FRAME get_current_frame (); extern FRAME get_next_frame (); extern struct block *get_frame_block (); extern struct block *get_current_block (); extern struct block *get_selected_block (); extern struct symbol *get_frame_function (); extern struct symbol *get_pc_function (); extern FRAME find_relative_frame (); # 123 "infrun.c" 2 # 1 "inferior.h" 1 struct inferior_status { int pc_changed; int stop_signal; int stop_pc; int stop_frame_address; int stop_breakpoint; int stop_step; int stop_stack_dummy; int stopped_by_random_signal; int trap_expected; unsigned int step_range_start; unsigned int step_range_end; FRAME_ADDR step_frame_address; int step_over_calls; unsigned int step_resume_break_address; int stop_after_trap; int stop_after_attach; FRAME_ADDR selected_frame_address; int selected_level; struct command_line *breakpoint_commands; char stop_registers[(16*4+8) ]; int restore_stack_info; }; void save_inferior_status (), restore_inferior_status (); extern char *inferior_io_terminal; extern int inferior_pid; extern int remote_debugging; int remote_read_inferior_memory (); int remote_write_inferior_memory (); extern int stop_signal; extern unsigned int stop_pc; extern FRAME_ADDR stop_frame_address; extern int stop_breakpoint; extern int stop_step; extern int stop_stack_dummy; extern int stopped_by_random_signal; extern unsigned int step_range_start; extern unsigned int step_range_end; extern FRAME_ADDR step_frame_address; extern int step_over_calls; extern int step_multi; extern char stop_registers[(16*4+8) ]; extern int pc_changed; long read_memory_integer (); # 124 "infrun.c" 2 # 1 "wait.h" 1 # 27 "wait.h" # 125 "infrun.c" 2 # 1 "u:\\c\\gnu\\include\\signal.h" 1 typedef void (*__Sigfunc) (int signum) ; typedef short sig_atomic_t; __Sigfunc signal (int sig, __Sigfunc func) ; int raise (int sig) ; struct sigaction { __Sigfunc sa_handler; long sa_mask; int sa_flags; }; long sigsetmask (long mask) ; long sigblock (long mask) ; int sigaction (int, const struct sigaction *, struct sigaction *) ; # 127 "infrun.c" 2 # 1 "u:\\c\\gnu\\include\\sys/file.h" 1 # 1 "u:\\c\\gnu\\include\\file.h" 1 int flock (int, int) ; # 1 "u:\\c\\gnu\\include\\fcntl.h" 1 struct flock { short l_type; short l_whence; long l_start; long l_len; short l_pid; }; struct __open_file { short status; short flags; }; # 99 "u:\\c\\gnu\\include\\fcntl.h" extern struct __open_file __open_stat[40 ]; int fcntl (int f, int cmd, ...) ; # 18 "u:\\c\\gnu\\include\\file.h" 2 # 4 "u:\\c\\gnu\\include\\sys/file.h" 2 # 133 "infrun.c" 2 # 1 "u:\\c\\gnu\\include\\sys/types.h" 1 # 1 "u:\\c\\gnu\\include\\types.h" 1 typedef long time_t; typedef long off_t; typedef unsigned char u_char; typedef unsigned short u_short; typedef unsigned long u_long; typedef unsigned short dev_t; typedef u_long ino_t; typedef unsigned short uid_t; typedef unsigned short gid_t; typedef int pid_t; typedef void * caddr_t; # 1 "u:\\c\\gnu\\include\\utime.h" 1 struct utimbuf { time_t actime; time_t modtime; }; # 38 "u:\\c\\gnu\\include\\types.h" 2 # 4 "u:\\c\\gnu\\include\\sys/types.h" 2 # 143 "infrun.c" 2 # 1 "u:\\c\\gnu\\include\\sys/dir.h" 1 # 1 "u:\\c\\gnu\\include\\dirent.h" 1 # 1 "u:\\c\\gnu\\include\\limits.h" 1 # 15 "u:\\c\\gnu\\include\\dirent.h" 2 # 1 "u:\\c\\gnu\\include\\ostruct.h" 1 typedef struct { long b_free; long b_total; long b_secsiz; long b_clsiz; } _DISKINFO; typedef struct { short time; short date; } _DOSTIME; typedef struct { unsigned char maxlen; unsigned char actuallen; char buffer[255]; } _CCONLINE; typedef struct _dta { char dta_buf[21]; char dta_attribute; unsigned short dta_time; unsigned short dta_date; long dta_size; char dta_name[14]; } _DTA; typedef struct { short recsiz; short clsiz; short clsizb; short rdlen; short fsiz; short fatrec; short datrec; short numcl; short bflags; } _BPB; typedef struct _md { struct _md *md_next; long md_start; long md_length; long md_owner; } _MD; typedef struct { _MD *mp_free; _MD *mp_used; _MD *mp_rover; } _MPB; typedef struct { char *ibuf; short ibufsiz; short ibufhd; short ibuftl; short ibuflow; short ibufhi; } _IOREC; typedef struct { char topmode; char buttons; char xparam; char yparam; } _PARAM; typedef struct { void (*midivec) (void) ; void (*vkbderr) (void) ; void (*vmiderr) (void) ; void (*statvec) (void *) ; void (*mousevec) (void *) ; void (*clockvec) (void *) ; void (*joyvec) (void *) ; long (*midisys) (void) ; long (*ikbdsys) (void) ; char kbstate; } _KBDVECS; typedef struct { void *unshift; void *shift; void *caps; } _KEYTAB; typedef struct { void *pb_scrptr; int pb_offset; int pb_width; int pb_height; int pb_left; int pb_right; int pb_screz; int pb_prrez; void *pb_colptr; int pb_prtype; int pb_prport; void *pb_mask; } _PBDEF; # 20 "u:\\c\\gnu\\include\\dirent.h" 2 struct dirent { long d_ino; off_t d_off; short d_reclen; char d_name[ 31 +1]; }; # 57 "u:\\c\\gnu\\include\\dirent.h" typedef struct _DIR { short status; _DTA dta; char *dirname; struct dirent buf; long handle; } DIR; DIR * opendir (const char *dirname) ; struct dirent *readdir (DIR *dirp) ; off_t telldir (DIR *dirp) ; void seekdir (DIR *dirp, off_t loc) ; void rewinddir (DIR *dirp) ; int closedir (DIR *dirp) ; # 17 "u:\\c\\gnu\\include\\sys/dir.h" 2 # 145 "infrun.c" 2 # 1 "u:\\c\\gnu\\include\\sys/param.h" 1 # 147 "infrun.c" 2 extern char *sys_siglist[]; extern int errno; static char signal_stop[ 31 ]; static char signal_print[ 31 ]; static char signal_program[ 31 ]; static int breakpoints_inserted; static struct symbol *step_start_function; static char break_insn[] = {0x4e, 0x4f} ; static unsigned int step_resume_break_address; static char step_resume_break_shadow[sizeof break_insn]; static int step_resume_break_duplicate; static int trap_expected; static int trap_expected_after_continue; int stop_after_trap; int stop_after_attach; int pc_changed; int remote_debugging; char stop_registers[(16*4+8) ]; static int breakpoints_failed; static int running_in_shell; static int stop_print_frame; static void insert_step_breakpoint (); static void remove_step_breakpoint (); static void wait_for_inferior (); static void normal_stop (); void clear_proceed_status () { trap_expected = 0; step_range_start = 0; step_range_end = 0; step_frame_address = 0; step_over_calls = -1; step_resume_break_address = 0; stop_after_trap = 0; stop_after_attach = 0; clear_breakpoint_commands (); } void proceed (addr, signal, step) unsigned int addr; int signal; int step; { int oneproc = 0; if (step > 0) step_start_function = find_pc_function (read_pc ()); if (step < 0) stop_after_trap = 1; if (addr == -1) { if (!pc_changed && breakpoint_here_p (read_pc ())) oneproc = 1; } else { write_register (17 , addr); } if (trap_expected_after_continue) { oneproc = 1; trap_expected_after_continue = 0; } if (oneproc) trap_expected = 1; else { int temp = insert_breakpoints (); if (temp) { print_sys_errmsg ("ptrace", temp); error ("Cannot insert breakpoints.\nThe same program may be running in another process."); } breakpoints_inserted = 1; } terminal_inferior (); if (signal >= 0) stop_signal = signal; else if (stop_signal < 31 && !signal_program[stop_signal]) stop_signal= 0; resume (oneproc || step, stop_signal); wait_for_inferior (); normal_stop (); } void writing_pc (val) unsigned int val; { stop_pc = val; pc_changed = 1; } void start_inferior () { trap_expected = 2; running_in_shell = 0; trap_expected_after_continue = 0; breakpoints_inserted = 0; mark_breakpoints_out (); terminal_init_inferior (); terminal_inferior (); if (remote_debugging) { trap_expected = 0; fetch_inferior_registers(); set_current_frame (create_new_frame (read_register (14 ), read_pc ())); stop_frame_address = ((get_current_frame())->frame) ; inferior_pid = 3; if (insert_breakpoints()) fatal("Can't insert breakpoints"); breakpoints_inserted = 1; proceed(-1, -1, 0); } else { wait_for_inferior (); normal_stop (); } } void start_remote () { clear_proceed_status (); running_in_shell = 0; trap_expected = 0; inferior_pid = 3; breakpoints_inserted = 0; mark_breakpoints_out (); wait_for_inferior (); normal_stop(); } void attach_program (pid) int pid; { attach (pid); inferior_pid = pid; mark_breakpoints_out (); terminal_init_inferior (); clear_proceed_status (); stop_after_attach = 1; terminal_inferior (); wait_for_inferior (); normal_stop (); } static void wait_for_inferior () { register int pid; int w; unsigned int pc; int tem; int another_trap; int random_signal; unsigned int stop_sp, prev_sp; unsigned int prev_func_start, stop_func_start; char *prev_func_name, *stop_func_name; unsigned int prologue_pc; int stop_step_resume_break; unsigned int step_resume_break_sp; int newmisc; int newfun_pc; struct symtab_and_line sal; int prev_pc; extern unsigned int text_end; int remove_breakpoints_on_following_step = 0; prev_pc = read_pc (); (void) find_pc_partial_function (prev_pc, &prev_func_name, &prev_func_start); prev_func_start += 0 ; prev_sp = read_register (15 ); while (1) { pc_changed = 0; flush_cached_frames (); if (remote_debugging) remote_wait (&w); else { } if ((((w)&0377) == 0) ) { terminal_ours_for_output (); if (((w) >> 8) ) printf ("\nProgram exited with code 0%o.\n", ((w) >> 8) ); else printf ("\nProgram exited normally.\n"); fflush ((&_iob[1]) ); inferior_died (); stop_print_frame = 0; break; } else if (!(((w)&0377) == 0177) ) { kill_inferior (); stop_print_frame = 0; stop_signal = ((w) & 0177) ; terminal_ours_for_output (); printf ("\nProgram terminated with signal %d, %s\n", stop_signal, stop_signal < 31 ? sys_siglist[stop_signal] : "(undocumented)"); printf ("The inferior process no longer exists.\n"); fflush ((&_iob[1]) ); break; } fetch_inferior_registers (); stop_pc = read_pc (); set_current_frame ( create_new_frame (read_register (14 ), read_pc ())); stop_frame_address = ((get_current_frame ())->frame) ; stop_sp = read_register (15 ); stop_func_start = 0; stop_func_name = 0; (void) find_pc_partial_function (stop_pc, &stop_func_name, &stop_func_start); stop_func_start += 0 ; another_trap = 0; stop_breakpoint = 0; stop_step = 0; stop_stack_dummy = 0; stop_print_frame = 1; stop_step_resume_break = 0; random_signal = 0; stopped_by_random_signal = 0; breakpoints_failed = 0; stop_signal = ((w) >> 8) ; if (stop_signal == 5 || (breakpoints_inserted && (stop_signal == 4 || stop_signal == 7 )) || stop_after_attach) { if (stop_signal == 5 && stop_after_trap) { stop_print_frame = 0; break; } if (stop_after_attach) break; if (stop_signal == 5 && trap_expected) stop_breakpoint = 0; else { if (!(prev_pc != stop_pc - 2 && step_range_end && !step_resume_break_address)) { if (stop_pc - 2 == step_resume_break_address) { stop_step_resume_break = 1; if (2 ) { stop_pc -= 2 ; write_register (17 , stop_pc); pc_changed = 0; } } else { stop_breakpoint = breakpoint_stop_status (stop_pc, stop_frame_address); stop_print_frame = 1; if (stop_breakpoint && 2 ) { stop_pc -= 2 ; write_register (17 , stop_pc); pc_changed = 0; } } } } if (stop_signal == 5 ) random_signal = !(stop_breakpoint || trap_expected || stop_step_resume_break || (stop_sp < stop_pc && stop_pc < stop_frame_address) || (step_range_end && !step_resume_break_address)); else { random_signal = !(stop_breakpoint || stop_step_resume_break ); if (!random_signal) stop_signal = 5 ; } } else random_signal = 1; if (random_signal && !(running_in_shell && stop_signal == 11 )) { int printed = 0; stopped_by_random_signal = 1; if (stop_signal >= 31 || signal_print[stop_signal]) { printed = 1; terminal_ours_for_output (); printf ("\nProgram received signal %d, %s\n", stop_signal, stop_signal < 31 ? sys_siglist[stop_signal] : "(undocumented)"); fflush ((&_iob[1]) ); } if (stop_signal >= 31 || signal_stop[stop_signal]) break; else if (printed) terminal_inferior (); } if (!random_signal && (stop_breakpoint || stop_step_resume_break)) { if (stop_breakpoint && stop_breakpoint != -1 && stop_breakpoint != -0x1000001) { if ((stop_breakpoint > 0 ? stop_breakpoint : -stop_breakpoint) & 0x1000000) { stop_print_frame = 0; if (stop_breakpoint > 0) stop_breakpoint -= 0x1000000; else stop_breakpoint += 0x1000000; } break; } if (stop_step_resume_break && (step_frame_address == 0 || (stop_frame_address == step_frame_address))) { remove_step_breakpoint (); step_resume_break_address = 0; } else { remove_breakpoints (); remove_step_breakpoint (); breakpoints_inserted = 0; another_trap = 1; } } if (stop_sp < stop_pc && stop_pc < stop_frame_address) { stop_print_frame = 0; stop_stack_dummy = 1; break; } if (step_resume_break_address) ; else if (!random_signal && step_range_end && stop_pc >= step_range_start && stop_pc < step_range_end && !(stop_pc == step_range_start && stop_frame_address && (stop_sp < prev_sp || stop_frame_address != step_frame_address))) { if ((read_memory_integer (stop_pc, 2) == 0x4e75) ) { stop_step = 1; break; } } else if (!random_signal && step_range_end) { if (stop_func_start) { prologue_pc = stop_func_start; { register int op = read_memory_integer (prologue_pc, 2); if (op == 0047126) prologue_pc += 4; else if (op == 0044016) prologue_pc += 6; } ; } if ( stop_func_name && !strcmp ("_sigtramp", stop_func_name) && ! prev_func_name && !strcmp ("_sigtramp", prev_func_name) ) { step_resume_break_address = prev_pc; step_resume_break_duplicate = breakpoint_here_p (step_resume_break_address); step_resume_break_sp = stop_sp; if (breakpoints_inserted) insert_step_breakpoint (); if (step_range_end == 1) step_range_end = (step_range_start = prev_pc) + 1; remove_breakpoints_on_following_step = 1; } else if (stop_pc == stop_func_start && (stop_func_start != prev_func_start || prologue_pc != stop_func_start || stop_sp != prev_sp)) { if (step_over_calls > 0 || (step_over_calls && find_pc_function (stop_pc) == 0)) { step_resume_break_address = read_memory_integer (read_register (15 ), 4) ; step_resume_break_duplicate = breakpoint_here_p (step_resume_break_address); step_resume_break_sp = stop_sp; if (breakpoints_inserted) insert_step_breakpoint (); } else if (step_over_calls) { { register int op = read_memory_integer (stop_func_start, 2); if (op == 0047126) stop_func_start += 4; else if (op == 0044016) stop_func_start += 6; } ; sal = find_pc_line (stop_func_start, 0); if (sal.end && sal.pc != stop_func_start) stop_func_start = sal.end; if (stop_func_start == stop_pc) { stop_step = 1; break; } else { step_resume_break_address = stop_func_start; step_resume_break_sp = stop_sp; step_resume_break_duplicate = breakpoint_here_p (step_resume_break_address); if (breakpoints_inserted) insert_step_breakpoint (); step_frame_address = 0; step_range_end = step_range_start; } } else { stop_step = 1; break; } } else { stop_step = 1; break; } } prev_pc = read_pc (); prev_func_start = stop_func_start; prev_func_name = stop_func_name; prev_sp = stop_sp; if (trap_expected > 1) { trap_expected--; running_in_shell = 1; resume (0, 0); } else if (running_in_shell && stop_signal == 11 ) { resume (0, 11 ); } else if (trap_expected && stop_signal != 5 ) { resume ((step_range_end && !step_resume_break_address) || trap_expected, stop_signal); } else { running_in_shell = 0; if (!step_resume_break_address && remove_breakpoints_on_following_step) { remove_breakpoints_on_following_step = 0; remove_breakpoints (); breakpoints_inserted = 0; } else if (!breakpoints_inserted && !another_trap) { insert_step_breakpoint (); breakpoints_failed = insert_breakpoints (); if (breakpoints_failed) break; breakpoints_inserted = 1; } trap_expected = another_trap; if (stop_signal == 5 ) stop_signal = 0; resume ((step_range_end && !step_resume_break_address) || trap_expected, stop_signal); } } } static void normal_stop () { if (inferior_pid) (get_current_frame ())->pc = read_pc (); if (breakpoints_failed) { terminal_ours_for_output (); print_sys_errmsg ("ptrace", breakpoints_failed); printf ("Stopped; cannot insert breakpoints.\nThe same program may be running in another process.\n"); } if (inferior_pid) remove_step_breakpoint (); if (inferior_pid && breakpoints_inserted) if (remove_breakpoints ()) { terminal_ours_for_output (); printf ("Cannot remove breakpoints because program is no longer writable.\nIt must be running in another process.\nFurther execution is probably impossible.\n"); } breakpoints_inserted = 0; breakpoint_auto_delete (stop_breakpoint); if (stopped_by_random_signal) disable_current_display (); if (step_multi && stop_step) return; terminal_ours (); if (running_in_shell) { if (stop_signal == 11 ) { char *exec_file = (char *) get_exec_file (1); if (access (exec_file, 1 ) != 0) printf ("The file \"%s\" is not executable.\n", exec_file); else printf ("You have just encountered a bug in \"sh\". GDB starts your program\nby running \"sh\" with a command to exec your program.\nThis is so that \"sh\" will process wildcards and I/O redirection.\nThis time, \"sh\" crashed.\n\nOne known bug in \"sh\" bites when the environment takes up a lot of space.\nTry \"info env\" to see the environment; then use \"delete env\" to kill\nsome variables whose values are large; then do \"run\" again.\n\nIf that works, you might want to put those \"delete env\" commands\ninto a \".gdbinit\" file in this directory so they will happen every time.\n"); # 1112 "infrun.c" } stop_print_frame = 0; } if (inferior_pid == 0) return; if (!stop_stack_dummy) { select_frame (get_current_frame (), 0); if (stop_print_frame) { if (stop_breakpoint > 0) printf ("\nBpt %d, ", stop_breakpoint); print_sel_frame (stop_step && step_frame_address == stop_frame_address && step_start_function == find_pc_function (stop_pc)); do_displays (); } } read_register_bytes (0, stop_registers, (16*4+8) ); if (stop_stack_dummy) { { register FRAME frame = get_current_frame (); register unsigned int fp; register int regnum; struct frame_saved_regs fsr; struct frame_info *fi; fi = get_frame_info (frame); fp = fi->frame; get_frame_saved_regs (fi, &fsr); for (regnum = 14 - 1; regnum >= 0; regnum--) if (fsr.regs[regnum]) write_register (regnum, read_memory_integer (fsr.regs[regnum], 4)); if (fsr.regs[16 ]) write_register (16 , read_memory_integer (fsr.regs[16 ], 4)); write_register (14 , read_memory_integer (fp, 4)); write_register (17 , read_memory_integer (fp + 4, 4)); write_register (15 , fp + 8); flush_cached_frames (); set_current_frame ( create_new_frame (read_register (14 ), read_pc ())); } ; select_frame (get_current_frame (), 0); } } static void insert_step_breakpoint () { if (step_resume_break_address && !step_resume_break_duplicate) { read_memory (step_resume_break_address, step_resume_break_shadow, sizeof break_insn); write_memory (step_resume_break_address, break_insn, sizeof break_insn); } } static void remove_step_breakpoint () { if (step_resume_break_address && !step_resume_break_duplicate) write_memory (step_resume_break_address, step_resume_break_shadow, sizeof break_insn); } static void handle_command (args, from_tty) char *args; int from_tty; { register char *p = args; int signum = 0; register int digits, wordlen; if (!args) error_no_arg ("signal to handle"); while (*p) { for (wordlen = 0; p[wordlen] && p[wordlen] != ' ' && p[wordlen] != '\t'; wordlen++); for (digits = 0; p[digits] >= '0' && p[digits] <= '9'; digits++); if (digits == wordlen) { signum = atoi (p); if (signum <= 0 || signum >= 31 ) { p[wordlen] = '\0'; error ("Invalid signal %s given as argument to \"handle\".", p); } if (signum == 5 || signum == 2 ) { if (!query ("Signal %d is used by the debugger.\nAre you sure you want to change it? ", signum)) error ("Not confirmed."); } } else if (signum == 0) error ("First argument is not a signal number."); else if (!strncmp (p, "stop", wordlen)) { signal_stop[signum] = 1; signal_print[signum] = 1; } else if (wordlen >= 2 && !strncmp (p, "print", wordlen)) signal_print[signum] = 1; else if (wordlen >= 2 && !strncmp (p, "pass", wordlen)) signal_program[signum] = 1; else if (!strncmp (p, "ignore", wordlen)) signal_program[signum] = 0; else if (wordlen >= 3 && !strncmp (p, "nostop", wordlen)) signal_stop[signum] = 0; else if (wordlen >= 4 && !strncmp (p, "noprint", wordlen)) { signal_print[signum] = 0; signal_stop[signum] = 0; } else if (wordlen >= 4 && !strncmp (p, "nopass", wordlen)) signal_program[signum] = 0; else if (wordlen >= 3 && !strncmp (p, "noignore", wordlen)) signal_program[signum] = 1; else { p[wordlen] = 0; error ("Unrecognized flag word: \"%s\".", p); } p += wordlen; while (*p == ' ' || *p == '\t') p++; } if (from_tty) { printf ("Number\tStop\tPrint\tPass to program\tDescription\n"); printf ("%d\t", signum); printf ("%s\t", signal_stop[signum] ? "Yes" : "No"); printf ("%s\t", signal_print[signum] ? "Yes" : "No"); printf ("%s\t\t", signal_program[signum] ? "Yes" : "No"); printf ("%s\n", sys_siglist[signum]); } } static void signals_info (signum_exp) char *signum_exp; { register int i; printf_filtered ("Number\tStop\tPrint\tPass to program\tDescription\n"); if (signum_exp) { i = parse_and_eval_address (signum_exp); if (i >= 31 || i < 0) error ("Signal number out of bounds."); printf_filtered ("%d\t", i); printf_filtered ("%s\t", signal_stop[i] ? "Yes" : "No"); printf_filtered ("%s\t", signal_print[i] ? "Yes" : "No"); printf_filtered ("%s\t\t", signal_program[i] ? "Yes" : "No"); printf_filtered ("%s\n", sys_siglist[i]); return; } printf_filtered ("\n"); for (i = 0; i < 31 ; i++) { { if (quit_flag) quit (); } ; printf_filtered ("%d\t", i); printf_filtered ("%s\t", signal_stop[i] ? "Yes" : "No"); printf_filtered ("%s\t", signal_print[i] ? "Yes" : "No"); printf_filtered ("%s\t\t", signal_program[i] ? "Yes" : "No"); printf_filtered ("%s\n", sys_siglist[i]); } printf_filtered ("\nUse the \"handle\" command to change these tables.\n"); } struct command_line *get_breakpoint_commands (); void save_inferior_status (inf_status, restore_stack_info) struct inferior_status *inf_status; int restore_stack_info; { inf_status->pc_changed = pc_changed; inf_status->stop_signal = stop_signal; inf_status->stop_pc = stop_pc; inf_status->stop_frame_address = stop_frame_address; inf_status->stop_breakpoint = stop_breakpoint; inf_status->stop_step = stop_step; inf_status->stop_stack_dummy = stop_stack_dummy; inf_status->stopped_by_random_signal = stopped_by_random_signal; inf_status->trap_expected = trap_expected; inf_status->step_range_start = step_range_start; inf_status->step_range_end = step_range_end; inf_status->step_frame_address = step_frame_address; inf_status->step_over_calls = step_over_calls; inf_status->step_resume_break_address = step_resume_break_address; inf_status->stop_after_trap = stop_after_trap; inf_status->stop_after_attach = stop_after_attach; inf_status->breakpoint_commands = get_breakpoint_commands (); inf_status->restore_stack_info = restore_stack_info; bcopy (stop_registers, inf_status->stop_registers, (16*4+8) ); record_selected_frame (&(inf_status->selected_frame_address), &(inf_status->selected_level)); return; } void restore_inferior_status (inf_status) struct inferior_status *inf_status; { FRAME fid; int level = inf_status->selected_level; pc_changed = inf_status->pc_changed; stop_signal = inf_status->stop_signal; stop_pc = inf_status->stop_pc; stop_frame_address = inf_status->stop_frame_address; stop_breakpoint = inf_status->stop_breakpoint; stop_step = inf_status->stop_step; stop_stack_dummy = inf_status->stop_stack_dummy; stopped_by_random_signal = inf_status->stopped_by_random_signal; trap_expected = inf_status->trap_expected; step_range_start = inf_status->step_range_start; step_range_end = inf_status->step_range_end; step_frame_address = inf_status->step_frame_address; step_over_calls = inf_status->step_over_calls; step_resume_break_address = inf_status->step_resume_break_address; stop_after_trap = inf_status->stop_after_trap; stop_after_attach = inf_status->stop_after_attach; set_breakpoint_commands (inf_status->breakpoint_commands); bcopy (inf_status->stop_registers, stop_registers, (16*4+8) ); if (have_inferior_p() && inf_status->restore_stack_info) { fid = find_relative_frame (get_current_frame (), &level); if (fid == 0 || ((fid)->frame) != inf_status->selected_frame_address || level != 0) { fprintf ((&_iob[2]) , "Unable to restore previously selected frame.\n"); select_frame (get_current_frame (), 0); return; } select_frame (fid, inf_status->selected_level); } return; } void _initialize_infrun () { register int i; add_info ("signals", signals_info, "What debugger does when program gets various signals.\nSpecify a signal number as argument to print info on that signal only."); add_com ("handle", class_run, handle_command, "Specify how to handle a signal.\nArgs are signal number followed by flags.\nFlags allowed are \"stop\", \"print\", \"pass\",\n \"nostop\", \"noprint\" or \"nopass\".\nPrint means print a message if this signal happens.\nStop means reenter debugger if this signal happens (implies print).\nPass means let program see this signal; otherwise program doesn't know.\nPass and Stop may be combined."); for (i = 0; i < 31 ; i++) { signal_stop[i] = 1; signal_print[i] = 1; signal_program[i] = 1; } signal_program[ 5 ] = 0; signal_program[ 2 ] = 0; signal_stop[ 14 ] = 0; signal_print[ 14 ] = 0; signal_stop[26 ] = 0; signal_print[26 ] = 0; signal_stop[ 27 ] = 0; signal_print[ 27 ] = 0; signal_stop[ 20 ] = 0; signal_print[ 20 ] = 0; signal_stop[ 23 ] = 0; signal_print[ 23 ] = 0; signal_stop[ 16 ] = 0; signal_print[ 16 ] = 0; } 
