X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Finfrun.h;h=e79bf2d83dad315868b2fcd719b7fbb645080578;hb=f166f943f30a91792e8754cbca9d7652fc400aae;hp=f0649f33a6101fc0f2db61c4f34177a31fb540a9;hpb=45741a9c329a5afa111f7842ba980bd6a106e020;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/infrun.h b/gdb/infrun.h index f0649f33a6..e79bf2d83d 100644 --- a/gdb/infrun.h +++ b/gdb/infrun.h @@ -1,4 +1,4 @@ -/* Copyright (C) 1986-2014 Free Software Foundation, Inc. +/* Copyright (C) 1986-2016 Free Software Foundation, Inc. This file is part of GDB. @@ -18,12 +18,12 @@ #ifndef INFRUN_H #define INFRUN_H 1 -#include "ptid.h" #include "symtab.h" struct target_waitstatus; struct frame_info; struct address_space; +struct return_value_info; /* True if we are debugging run control. */ extern unsigned int debug_infrun; @@ -62,6 +62,11 @@ extern int non_stop; starting an inferior. */ extern int disable_randomization; +/* Returns a unique identifier for the current stop. This can be used + to tell whether a command has proceeded the inferior past the + current location. */ +extern ULONGEST get_stop_id (void); + /* Reverse execution. */ enum exec_direction_kind { @@ -69,37 +74,50 @@ enum exec_direction_kind EXEC_REVERSE }; -/* The current execution direction. This should only be set to enum - exec_direction_kind values. It is only an int to make it - compatible with make_cleanup_restore_integer. */ -extern int execution_direction; - -/* Save register contents here when executing a "finish" command or - are about to pop a stack dummy frame, if-and-only-if - proceed_to_finish is set. Thus this contains the return value from - the called function (assuming values are returned in a - register). */ -extern struct regcache *stop_registers; +/* The current execution direction. */ +extern enum exec_direction_kind execution_direction; extern void start_remote (int from_tty); -extern void clear_proceed_status (void); +/* Clear out all variables saying what to do when inferior is + continued or stepped. First do this, then set the ones you want, + then call `proceed'. STEP indicates whether we're preparing for a + step/stepi command. */ +extern void clear_proceed_status (int step); -extern void proceed (CORE_ADDR, enum gdb_signal, int); +extern void proceed (CORE_ADDR, enum gdb_signal); /* The `resume' routine should only be called in special circumstances. Normally, use `proceed', which handles a lot of bookkeeping. */ -extern void resume (int, enum gdb_signal); - +extern void resume (enum gdb_signal); + +/* Return a ptid representing the set of threads that we will proceed, + in the perspective of the user/frontend. We may actually resume + fewer threads at first, e.g., if a thread is stopped at a + breakpoint that needs stepping-off, but that should not be visible + to the user/frontend, and neither should the frontend/user be + allowed to proceed any of the threads that happen to be stopped for + internal run control handling, if a previous command wanted them + resumed. */ extern ptid_t user_visible_resume_ptid (int step); extern void wait_for_inferior (void); -extern void normal_stop (void); +/* Return control to GDB when the inferior stops for real. Print + appropriate messages, remove breakpoints, give terminal our modes, + and run the stop hook. Returns true if the stop hook proceeded the + target, false otherwise. */ +extern int normal_stop (void); extern void get_last_target_status (ptid_t *ptid, struct target_waitstatus *status); +extern void set_last_target_status (ptid_t ptid, + struct target_waitstatus status); + +/* Stop all threads. Only returns after everything is halted. */ +extern void stop_all_threads (void); + extern void prepare_for_detach (void); extern void fetch_inferior_event (void *); @@ -110,17 +128,61 @@ extern void insert_step_resume_breakpoint_at_sal (struct gdbarch *, struct symtab_and_line , struct frame_id); -extern void follow_inferior_reset_breakpoints (void); - /* Returns true if we're trying to step past the instruction at ADDRESS in ASPACE. */ extern int stepping_past_instruction_at (struct address_space *aspace, CORE_ADDR address); +/* Returns true if thread whose thread number is THREAD is stepping + over a breakpoint. */ +extern int thread_is_stepping_over_breakpoint (int thread); + +/* Returns true if we're trying to step past an instruction that + triggers a non-steppable watchpoint. */ +extern int stepping_past_nonsteppable_watchpoint (void); + extern void set_step_info (struct frame_info *frame, struct symtab_and_line sal); -extern void print_stop_event (struct target_waitstatus *ws); +/* Several print_*_reason helper functions to print why the inferior + has stopped to the passed in UIOUT. */ + +/* Signal received, print why the inferior has stopped. */ +extern void print_signal_received_reason (struct ui_out *uiout, + enum gdb_signal siggnal); + +/* Print why the inferior has stopped. We are done with a + step/next/si/ni command, print why the inferior has stopped. */ +extern void print_end_stepping_range_reason (struct ui_out *uiout); + +/* The inferior was terminated by a signal, print why it stopped. */ +extern void print_signal_exited_reason (struct ui_out *uiout, + enum gdb_signal siggnal); + +/* The inferior program is finished, print why it stopped. */ +extern void print_exited_reason (struct ui_out *uiout, int exitstatus); + +/* Reverse execution: target ran out of history info, print why the + inferior has stopped. */ +extern void print_no_history_reason (struct ui_out *uiout); + +/* Print the result of a function at the end of a 'finish' command. + RV points at an object representing the captured return value/type + and its position in the value history. */ + +extern void print_return_value (struct ui_out *uiout, + struct return_value_info *rv); + +/* Print current location without a level number, if we have changed + functions or hit a breakpoint. Print source line if we have one. + If the execution command captured a return value, print it. */ + +extern void print_stop_event (struct ui_out *uiout); + +/* Pretty print the results of target_wait, for debugging purposes. */ + +extern void print_target_wait_results (ptid_t waiton_ptid, ptid_t result_ptid, + const struct target_waitstatus *ws); extern int signal_stop_state (int); @@ -161,4 +223,19 @@ extern void signal_catch_update (const unsigned int *); systems. Use of symbolic signal names is strongly encouraged. */ enum gdb_signal gdb_signal_from_command (int num); +/* Enables/disables infrun's async event source in the event loop. */ +extern void infrun_async (int enable); + +/* Call infrun's event handler the next time through the event + loop. */ +extern void mark_infrun_async_event_handler (void); + +/* The global queue of threads that need to do a step-over operation + to get past e.g., a breakpoint. */ +extern struct thread_info *step_over_queue_head; + +/* Remove breakpoints if possible (usually that means, if everything + is stopped). On failure, print a message. */ +extern void maybe_remove_breakpoints (void); + #endif /* INFRUN_H */