X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Finfrun.h;h=39be375fbe90e7a8bd4702150ec0bb6cedf1550d;hb=ec8f76882145c71bef81a9cadf0bf51ff9fa5b35;hp=cc9cb33695435493fca027d22fe0a0a434f6e114;hpb=4cb9c816469ef3373d9cdde76e8ab5007cf3739e;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/infrun.h b/gdb/infrun.h index cc9cb33695..39be375fbe 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. @@ -23,6 +23,7 @@ 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; @@ -34,11 +35,6 @@ extern int debug_displaced; of shared library events by the dynamic linker. */ extern int stop_on_solib_events; -/* Are we simulating synchronous execution? This is used in async gdb - to implement the 'run', 'continue' etc commands, which will not - redisplay the prompt until the execution is actually over. */ -extern int sync_execution; - /* True if execution commands resume all threads of all processes by default; otherwise, resume only threads of the current inferior process. */ @@ -61,6 +57,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 { @@ -68,17 +69,8 @@ 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); @@ -88,23 +80,39 @@ extern void start_remote (int from_tty); 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. */ + 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 *); @@ -115,13 +123,19 @@ 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); @@ -147,7 +161,23 @@ extern void print_exited_reason (struct ui_out *uiout, int exitstatus); inferior has stopped. */ extern void print_no_history_reason (struct ui_out *uiout); -extern void print_stop_event (struct target_waitstatus *ws); +/* 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); @@ -188,4 +218,29 @@ 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); + +/* If a UI was in sync execution mode, and now isn't, restore its + prompt (a synchronous execution command has finished, and we're + ready for input). */ +extern void all_uis_check_sync_execution_done (void); + +/* If a UI was in sync execution mode, and hasn't displayed the prompt + yet, re-disable its prompt (a synchronous execution command was + started or re-started). */ +extern void all_uis_on_sync_execution_starting (void); + #endif /* INFRUN_H */