X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fbreakpoint.c;h=805079f2ee78b8d6551d27accc9d79e2b46c5a49;hb=39f770628a4eaf018fec8d55684bf2ec16ada9cc;hp=37454c5547bf55b13fadf0149b8eac44133e3953;hpb=c3f6f71df382eaaaac4440a91e6f310d03fb8da6;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c index 37454c5547..805079f2ee 100644 --- a/gdb/breakpoint.c +++ b/gdb/breakpoint.c @@ -1,6 +1,6 @@ /* Everything about breakpoints, for GDB. - Copyright 1986, 87, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 1999 - Free Software Foundation, Inc. + Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, + 1996, 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc. This file is part of GDB. @@ -39,6 +39,10 @@ #include "annotate.h" #include "symfile.h" #include "objfiles.h" +#include "linespec.h" +#ifdef UI_OUT +#include "ui-out.h" +#endif #include "gdb-events.h" @@ -46,105 +50,73 @@ static void until_break_command_continuation (struct continuation_arg *arg); -static void -catch_command_1 PARAMS ((char *, int, int)); +static void catch_command_1 (char *, int, int); -static void -enable_delete_command PARAMS ((char *, int)); +static void enable_delete_command (char *, int); -static void -enable_delete_breakpoint PARAMS ((struct breakpoint *)); +static void enable_delete_breakpoint (struct breakpoint *); -static void -enable_once_command PARAMS ((char *, int)); +static void enable_once_command (char *, int); -static void -enable_once_breakpoint PARAMS ((struct breakpoint *)); +static void enable_once_breakpoint (struct breakpoint *); -static void -disable_command PARAMS ((char *, int)); +static void disable_command (char *, int); -static void -enable_command PARAMS ((char *, int)); +static void enable_command (char *, int); -static void -map_breakpoint_numbers PARAMS ((char *, void (*)(struct breakpoint *))); +static void map_breakpoint_numbers (char *, void (*)(struct breakpoint *)); -static void -ignore_command PARAMS ((char *, int)); - -static int breakpoint_re_set_one PARAMS ((PTR)); +static void ignore_command (char *, int); -static void -clear_command PARAMS ((char *, int)); +static int breakpoint_re_set_one (PTR); -static void -catch_command PARAMS ((char *, int)); +static void clear_command (char *, int); -static void -handle_gnu_4_16_catch_command PARAMS ((char *, int, int)); +static void catch_command (char *, int); -static struct symtabs_and_lines -get_catch_sals PARAMS ((int)); +static void handle_gnu_4_16_catch_command (char *, int, int); -static void -watch_command PARAMS ((char *, int)); +static struct symtabs_and_lines get_catch_sals (int); -static int -can_use_hardware_watchpoint PARAMS ((struct value *)); +static void watch_command (char *, int); -static void break_at_finish_command PARAMS ((char *, int)); -static void break_at_finish_at_depth_command PARAMS ((char *, int)); +static int can_use_hardware_watchpoint (struct value *); -void -tbreak_command PARAMS ((char *, int)); +static void break_at_finish_command (char *, int); +static void break_at_finish_at_depth_command (char *, int); -static void tbreak_at_finish_command PARAMS ((char *, int)); +static void tbreak_at_finish_command (char *, int); -static void -break_command_1 PARAMS ((char *, int, int)); +static void break_command_1 (char *, int, int); -static void -mention PARAMS ((struct breakpoint *)); +static void mention (struct breakpoint *); -struct breakpoint * - set_raw_breakpoint PARAMS ((struct symtab_and_line)); +struct breakpoint *set_raw_breakpoint (struct symtab_and_line); -static void -check_duplicates PARAMS ((CORE_ADDR, asection *)); +static void check_duplicates (CORE_ADDR, asection *); -static void -describe_other_breakpoints PARAMS ((CORE_ADDR, asection *)); +static void describe_other_breakpoints (CORE_ADDR, asection *); -static void -breakpoints_info PARAMS ((char *, int)); +static void breakpoints_info (char *, int); -static void -breakpoint_1 PARAMS ((int, int)); +static void breakpoint_1 (int, int); -static bpstat - bpstat_alloc PARAMS ((struct breakpoint *, bpstat)); +static bpstat bpstat_alloc (struct breakpoint *, bpstat); -static int breakpoint_cond_eval PARAMS ((PTR)); +static int breakpoint_cond_eval (PTR); -static void -cleanup_executing_breakpoints PARAMS ((PTR)); +static void cleanup_executing_breakpoints (PTR); -static void -commands_command PARAMS ((char *, int)); +static void commands_command (char *, int); -static void -condition_command PARAMS ((char *, int)); +static void condition_command (char *, int); -static int -get_number_trailer PARAMS ((char **, int)); +static int get_number_trailer (char **, int); -void -set_breakpoint_count PARAMS ((int)); +void set_breakpoint_count (int); #if 0 -static struct breakpoint * - create_temp_exception_breakpoint PARAMS ((CORE_ADDR)); +static struct breakpoint *create_temp_exception_breakpoint (CORE_ADDR); #endif typedef enum @@ -154,10 +126,9 @@ typedef enum } insertion_state_t; -static int -remove_breakpoint PARAMS ((struct breakpoint *, insertion_state_t)); +static int remove_breakpoint (struct breakpoint *, insertion_state_t); -static enum print_stop_action print_it_typical PARAMS ((bpstat)); +static enum print_stop_action print_it_typical (bpstat); static enum print_stop_action print_bp_stop_message (bpstat bs); @@ -168,95 +139,80 @@ typedef struct } args_for_catchpoint_enable; -static int watchpoint_check PARAMS ((PTR)); +static int watchpoint_check (PTR); -static int cover_target_enable_exception_callback PARAMS ((PTR)); +static int cover_target_enable_exception_callback (PTR); -static void maintenance_info_breakpoints PARAMS ((char *, int)); +static void maintenance_info_breakpoints (char *, int); #ifdef GET_LONGJMP_TARGET -static void create_longjmp_breakpoint PARAMS ((char *)); +static void create_longjmp_breakpoint (char *); #endif -static int hw_breakpoint_used_count PARAMS ((void)); +static int hw_breakpoint_used_count (void); -static int hw_watchpoint_used_count PARAMS ((enum bptype, int *)); +static int hw_watchpoint_used_count (enum bptype, int *); -static void hbreak_command PARAMS ((char *, int)); +static void hbreak_command (char *, int); -static void thbreak_command PARAMS ((char *, int)); +static void thbreak_command (char *, int); -static void watch_command_1 PARAMS ((char *, int, int)); +static void watch_command_1 (char *, int, int); -static void rwatch_command PARAMS ((char *, int)); +static void rwatch_command (char *, int); -static void awatch_command PARAMS ((char *, int)); +static void awatch_command (char *, int); -static void do_enable_breakpoint PARAMS ((struct breakpoint *, enum bpdisp)); +static void do_enable_breakpoint (struct breakpoint *, enum bpdisp); -static void solib_load_unload_1 PARAMS ((char *hookname, - int tempflag, - char *dll_pathname, - char *cond_string, - enum bptype bp_kind)); +static void solib_load_unload_1 (char *hookname, + int tempflag, + char *dll_pathname, + char *cond_string, enum bptype bp_kind); -static void create_fork_vfork_event_catchpoint PARAMS ((int tempflag, - char *cond_string, - enum bptype bp_kind)); +static void create_fork_vfork_event_catchpoint (int tempflag, + char *cond_string, + enum bptype bp_kind); -static void break_at_finish_at_depth_command_1 PARAMS ((char *arg, - int flag, - int from_tty)); +static void break_at_finish_at_depth_command_1 (char *arg, + int flag, int from_tty); -static void break_at_finish_command_1 PARAMS ((char *arg, - int flag, - int from_tty)); +static void break_at_finish_command_1 (char *arg, int flag, int from_tty); -static void stop_command PARAMS ((char *arg, int from_tty)); +static void stop_command (char *arg, int from_tty); -static void stopin_command PARAMS ((char *arg, int from_tty)); +static void stopin_command (char *arg, int from_tty); -static void stopat_command PARAMS ((char *arg, int from_tty)); +static void stopat_command (char *arg, int from_tty); -static char *ep_find_event_name_end PARAMS ((char *arg)); +static char *ep_find_event_name_end (char *arg); -static char *ep_parse_optional_if_clause PARAMS ((char **arg)); +static char *ep_parse_optional_if_clause (char **arg); -static char *ep_parse_optional_filename PARAMS ((char **arg)); +static char *ep_parse_optional_filename (char **arg); #if defined(CHILD_INSERT_EXEC_CATCHPOINT) -static void catch_exec_command_1 PARAMS ((char *arg, int tempflag, - int from_tty)); +static void catch_exec_command_1 (char *arg, int tempflag, int from_tty); #endif -static void create_exception_catchpoint - PARAMS ((int tempflag, char *cond_string, - enum exception_event_kind ex_event, - struct symtab_and_line * sal)); +static void create_exception_catchpoint (int tempflag, char *cond_string, + enum exception_event_kind ex_event, + struct symtab_and_line *sal); -static void catch_exception_command_1 - PARAMS ((enum exception_event_kind ex_event, - char *arg, int tempflag, int from_tty)); +static void catch_exception_command_1 (enum exception_event_kind ex_event, + char *arg, int tempflag, int from_tty); -static void tcatch_command PARAMS ((char *arg, int from_tty)); +static void tcatch_command (char *arg, int from_tty); -static void ep_skip_leading_whitespace PARAMS ((char **s)); +static void ep_skip_leading_whitespace (char **s); /* Prototypes for exported functions. */ -static void -awatch_command PARAMS ((char *, int)); - -static void -do_enable_breakpoint PARAMS ((struct breakpoint *, enum bpdisp)); - /* If FALSE, gdb will not use hardware support for watchpoints, even if such is available. */ static int can_use_hw_watchpoints; -void _initialize_breakpoint PARAMS ((void)); - -void set_breakpoint_count PARAMS ((int)); +void _initialize_breakpoint (void); extern int addressprint; /* Print machine addresses? */ @@ -365,8 +321,7 @@ int exception_support_initialized = 0; /* Set breakpoint count to NUM. */ void -set_breakpoint_count (num) - int num; +set_breakpoint_count (int num) { breakpoint_count = num; set_internalvar (lookup_internalvar ("bpnum"), @@ -376,7 +331,7 @@ set_breakpoint_count (num) /* Used in run_command to zero the hit count when a new run starts. */ void -clear_breakpoint_hit_counts () +clear_breakpoint_hit_counts (void) { struct breakpoint *b; @@ -406,9 +361,7 @@ int default_breakpoint_line; TRAILER is a character which can be found after the number; most commonly this is `-'. If you don't want a trailer, use \0. */ static int -get_number_trailer (pp, trailer) - char **pp; - int trailer; +get_number_trailer (char **pp, int trailer) { int retval = 0; /* default */ char *p = *pp; @@ -472,8 +425,7 @@ get_number_trailer (pp, trailer) /* Like get_number_trailer, but don't allow a trailer. */ int -get_number (pp) - char **pp; +get_number (char **pp) { return get_number_trailer (pp, '\0'); } @@ -495,8 +447,7 @@ get_number (pp) */ int -get_number_or_range (pp) - char **pp; +get_number_or_range (char **pp) { static int last_retval, end_value; static char *end_ptr; @@ -560,9 +511,7 @@ get_number_or_range (pp) /* condition N EXP -- set break condition of breakpoint N to EXP. */ static void -condition_command (arg, from_tty) - char *arg; - int from_tty; +condition_command (char *arg, int from_tty) { register struct breakpoint *b; char *p; @@ -581,11 +530,11 @@ condition_command (arg, from_tty) { if (b->cond) { - free ((PTR) b->cond); + xfree (b->cond); b->cond = 0; } if (b->cond_string != NULL) - free ((PTR) b->cond_string); + xfree (b->cond_string); if (*p == 0) { @@ -613,9 +562,7 @@ condition_command (arg, from_tty) /* ARGSUSED */ static void -commands_command (arg, from_tty) - char *arg; - int from_tty; +commands_command (char *arg, int from_tty) { register struct breakpoint *b; char *p; @@ -660,10 +607,7 @@ commands_command (arg, from_tty) shadow contents, not the breakpoints themselves. From breakpoint.c. */ int -read_memory_nobpt (memaddr, myaddr, len) - CORE_ADDR memaddr; - char *myaddr; - unsigned len; +read_memory_nobpt (CORE_ADDR memaddr, char *myaddr, unsigned len) { int status; struct breakpoint *b; @@ -744,10 +688,9 @@ read_memory_nobpt (memaddr, myaddr, len) if (bp_addr + bp_size < memaddr + len) { /* Copy the section of memory after the breakpoint. */ - status = read_memory_nobpt - (bp_addr + bp_size, - myaddr + bp_addr + bp_size - memaddr, - memaddr + len - (bp_addr + bp_size)); + status = read_memory_nobpt (bp_addr + bp_size, + myaddr + bp_addr + bp_size - memaddr, + memaddr + len - (bp_addr + bp_size)); if (status != 0) return status; } @@ -765,7 +708,7 @@ read_memory_nobpt (memaddr, myaddr, len) or an `errno' value if could not write the inferior. */ int -insert_breakpoints () +insert_breakpoints (void) { register struct breakpoint *b, *temp; int return_val = 0; /* return success code. */ @@ -915,6 +858,7 @@ insert_breakpoints () b->type == bp_read_watchpoint || b->type == bp_access_watchpoint) && b->enable == enabled + && b->disposition != del_at_next_stop && !b->inserted && !b->duplicate) { @@ -970,24 +914,39 @@ insert_breakpoints () if (VALUE_LVAL (v) == lval_memory && ! VALUE_LAZY (v)) { - CORE_ADDR addr; - int len, type; - - addr = VALUE_ADDRESS (v) + VALUE_OFFSET (v); - len = TYPE_LENGTH (VALUE_TYPE (v)); - type = hw_write; - if (b->type == bp_read_watchpoint) - type = hw_read; - else if (b->type == bp_access_watchpoint) - type = hw_access; - - val = target_insert_watchpoint (addr, len, type); - if (val == -1) + struct type *vtype = check_typedef (VALUE_TYPE (v)); + + /* We only watch structs and arrays if user asked + for it explicitly, never if they just happen to + appear in the middle of some value chain. */ + if (v == b->val_chain + || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT + && TYPE_CODE (vtype) != TYPE_CODE_ARRAY)) { - b->inserted = 0; - break; + CORE_ADDR addr; + int len, type; + + addr = VALUE_ADDRESS (v) + VALUE_OFFSET (v); + len = TYPE_LENGTH (VALUE_TYPE (v)); + type = hw_write; + if (b->type == bp_read_watchpoint) + type = hw_read; + else if (b->type == bp_access_watchpoint) + type = hw_access; + + val = target_insert_watchpoint (addr, len, type); + if (val == -1) + { + /* Don't exit the loop, try to insert + every value on the value chain. That's + because we will be removing all the + watches below, and removing a + watchpoint we didn't insert could have + adverse effects. */ + b->inserted = 0; + } + val = 0; } - val = 0; } } /* Failure to insert a watchpoint on any memory value in the @@ -1002,7 +961,7 @@ insert_breakpoints () } else { - printf_filtered ("Hardware watchpoint %d deleted", b->number); + printf_filtered ("Hardware watchpoint %d deleted ", b->number); printf_filtered ("because the program has left the block \n"); printf_filtered ("in which its expression is valid.\n"); if (b->related_breakpoint) @@ -1013,7 +972,7 @@ insert_breakpoints () /* Restore the frame and level. */ if ((saved_frame != selected_frame) || (saved_level != selected_frame_level)) - select_and_print_frame (saved_frame, saved_level); + select_frame (saved_frame, saved_level); if (val) return_val = val; /* remember failure */ @@ -1029,13 +988,13 @@ insert_breakpoints () switch (b->type) { case bp_catch_fork: - val = target_insert_fork_catchpoint (inferior_pid); + val = target_insert_fork_catchpoint (PIDGET (inferior_ptid)); break; case bp_catch_vfork: - val = target_insert_vfork_catchpoint (inferior_pid); + val = target_insert_vfork_catchpoint (PIDGET (inferior_ptid)); break; case bp_catch_exec: - val = target_insert_exec_catchpoint (inferior_pid); + val = target_insert_exec_catchpoint (PIDGET (inferior_ptid)); break; default: warning ("Internal error, %s line %d.", __FILE__, __LINE__); @@ -1059,7 +1018,7 @@ insert_breakpoints () int -remove_breakpoints () +remove_breakpoints (void) { register struct breakpoint *b; int val; @@ -1077,15 +1036,35 @@ remove_breakpoints () } int -reattach_breakpoints (pid) - int pid; +remove_hw_watchpoints (void) +{ + register struct breakpoint *b; + int val; + + ALL_BREAKPOINTS (b) + { + if (b->inserted + && (b->type == bp_hardware_watchpoint + || b->type == bp_read_watchpoint + || b->type == bp_access_watchpoint)) + { + val = remove_breakpoint (b, mark_uninserted); + if (val != 0) + return val; + } + } + return 0; +} + +int +reattach_breakpoints (int pid) { register struct breakpoint *b; int val; - int saved_inferior_pid = inferior_pid; + ptid_t saved_inferior_ptid = inferior_ptid; - /* FIXME: use a cleanup, to insure that inferior_pid gets replaced! */ - inferior_pid = pid; /* Because remove_breakpoint will use this global. */ + /* FIXME: use a cleanup, to insure that inferior_ptid gets replaced! */ + inferior_ptid = pid_to_ptid (pid); /* Because remove_breakpoint will use this global. */ ALL_BREAKPOINTS (b) { if (b->inserted) @@ -1097,17 +1076,17 @@ reattach_breakpoints (pid) val = target_insert_breakpoint (b->address, b->shadow_contents); if (val != 0) { - inferior_pid = saved_inferior_pid; + inferior_ptid = saved_inferior_ptid; return val; } } } - inferior_pid = saved_inferior_pid; + inferior_ptid = saved_inferior_ptid; return 0; } void -update_breakpoints_after_exec () +update_breakpoints_after_exec (void) { struct breakpoint *b; struct breakpoint *temp; @@ -1222,18 +1201,17 @@ update_breakpoints_after_exec () } int -detach_breakpoints (pid) - int pid; +detach_breakpoints (int pid) { register struct breakpoint *b; int val; - int saved_inferior_pid = inferior_pid; + ptid_t saved_inferior_ptid = inferior_ptid; - if (pid == inferior_pid) - error ("Cannot detach breakpoints of inferior_pid"); + if (pid == PIDGET (inferior_ptid)) + error ("Cannot detach breakpoints of inferior_ptid"); - /* FIXME: use a cleanup, to insure that inferior_pid gets replaced! */ - inferior_pid = pid; /* Because remove_breakpoint will use this global. */ + /* FIXME: use a cleanup, to insure that inferior_ptid gets replaced! */ + inferior_ptid = pid_to_ptid (pid); /* Because remove_breakpoint will use this global. */ ALL_BREAKPOINTS (b) { if (b->inserted) @@ -1241,19 +1219,17 @@ detach_breakpoints (pid) val = remove_breakpoint (b, mark_inserted); if (val != 0) { - inferior_pid = saved_inferior_pid; + inferior_ptid = saved_inferior_ptid; return val; } } } - inferior_pid = saved_inferior_pid; + inferior_ptid = saved_inferior_ptid; return 0; } static int -remove_breakpoint (b, is) - struct breakpoint *b; - insertion_state_t is; +remove_breakpoint (struct breakpoint *b, insertion_state_t is) { int val; @@ -1282,7 +1258,7 @@ remove_breakpoint (b, is) /* Check to see if breakpoint is in an overlay section; if so, we should remove the breakpoint at the LMA address. If that is not equal to the raw address, then we should - presumable remove the breakpoint there as well. */ + presumably remove the breakpoint there as well. */ if (overlay_debugging && b->section && section_is_overlay (b->section)) { @@ -1323,21 +1299,28 @@ remove_breakpoint (b, is) if (VALUE_LVAL (v) == lval_memory && ! VALUE_LAZY (v)) { - CORE_ADDR addr; - int len, type; + struct type *vtype = check_typedef (VALUE_TYPE (v)); - addr = VALUE_ADDRESS (v) + VALUE_OFFSET (v); - len = TYPE_LENGTH (VALUE_TYPE (v)); - type = hw_write; - if (b->type == bp_read_watchpoint) - type = hw_read; - else if (b->type == bp_access_watchpoint) - type = hw_access; - - val = target_remove_watchpoint (addr, len, type); - if (val == -1) - b->inserted = 1; - val = 0; + if (v == b->val_chain + || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT + && TYPE_CODE (vtype) != TYPE_CODE_ARRAY)) + { + CORE_ADDR addr; + int len, type; + + addr = VALUE_ADDRESS (v) + VALUE_OFFSET (v); + len = TYPE_LENGTH (VALUE_TYPE (v)); + type = hw_write; + if (b->type == bp_read_watchpoint) + type = hw_read; + else if (b->type == bp_access_watchpoint) + type = hw_access; + + val = target_remove_watchpoint (addr, len, type); + if (val == -1) + b->inserted = 1; + val = 0; + } } } /* Failure to remove any of the hardware watchpoints comes here. */ @@ -1364,13 +1347,13 @@ remove_breakpoint (b, is) switch (b->type) { case bp_catch_fork: - val = target_remove_fork_catchpoint (inferior_pid); + val = target_remove_fork_catchpoint (PIDGET (inferior_ptid)); break; case bp_catch_vfork: - val = target_remove_vfork_catchpoint (inferior_pid); + val = target_remove_vfork_catchpoint (PIDGET (inferior_ptid)); break; case bp_catch_exec: - val = target_remove_exec_catchpoint (inferior_pid); + val = target_remove_exec_catchpoint (PIDGET (inferior_ptid)); break; default: warning ("Internal error, %s line %d.", __FILE__, __LINE__); @@ -1410,7 +1393,7 @@ remove_breakpoint (b, is) /* Clear the "inserted" flag in all breakpoints. */ void -mark_breakpoints_out () +mark_breakpoints_out (void) { register struct breakpoint *b; @@ -1431,8 +1414,7 @@ mark_breakpoints_out () void -breakpoint_init_inferior (context) - enum inf_context context; +breakpoint_init_inferior (enum inf_context context) { register struct breakpoint *b, *temp; static int warning_needed = 0; @@ -1499,8 +1481,7 @@ breakpoint_init_inferior (context) the target, to advance the PC past the breakpoint. */ enum breakpoint_here -breakpoint_here_p (pc) - CORE_ADDR pc; +breakpoint_here_p (CORE_ADDR pc) { register struct breakpoint *b; int any_breakpoint_here = 0; @@ -1529,8 +1510,7 @@ breakpoint_here_p (pc) at PC. */ int -breakpoint_inserted_here_p (pc) - CORE_ADDR pc; +breakpoint_inserted_here_p (CORE_ADDR pc) { register struct breakpoint *b; @@ -1556,8 +1536,7 @@ breakpoint_inserted_here_p (pc) bp_call_dummy breakpoint. */ int -frame_in_dummy (frame) - struct frame_info *frame; +frame_in_dummy (struct frame_info *frame) { struct breakpoint *b; @@ -1582,18 +1561,16 @@ frame_in_dummy (frame) return 0; } -/* breakpoint_match_thread (PC, PID) returns true if the breakpoint at PC - is valid for process/thread PID. */ +/* breakpoint_thread_match (PC, PID) returns true if the breakpoint at + PC is valid for process/thread PID. */ int -breakpoint_thread_match (pc, pid) - CORE_ADDR pc; - int pid; +breakpoint_thread_match (CORE_ADDR pc, ptid_t ptid) { struct breakpoint *b; int thread; - thread = pid_to_thread_id (pid); + thread = pid_to_thread_id (ptid); ALL_BREAKPOINTS (b) if (b->enable != disabled @@ -1618,8 +1595,7 @@ breakpoint_thread_match (pc, pid) in breakpoint.h. */ int -ep_is_catchpoint (ep) - struct breakpoint *ep; +ep_is_catchpoint (struct breakpoint *ep) { return (ep->type == bp_catch_load) @@ -1628,39 +1604,32 @@ ep_is_catchpoint (ep) || (ep->type == bp_catch_vfork) || (ep->type == bp_catch_exec) || (ep->type == bp_catch_catch) - || (ep->type == bp_catch_throw) - + || (ep->type == bp_catch_throw); /* ??rehrauer: Add more kinds here, as are implemented... */ - ; } int -ep_is_shlib_catchpoint (ep) - struct breakpoint *ep; +ep_is_shlib_catchpoint (struct breakpoint *ep) { return (ep->type == bp_catch_load) - || (ep->type == bp_catch_unload) - ; + || (ep->type == bp_catch_unload); } int -ep_is_exception_catchpoint (ep) - struct breakpoint *ep; +ep_is_exception_catchpoint (struct breakpoint *ep) { return (ep->type == bp_catch_catch) - || (ep->type == bp_catch_throw) - ; + || (ep->type == bp_catch_throw); } /* Clear a bpstat so that it says we are not at any breakpoint. Also free any storage that is part of a bpstat. */ void -bpstat_clear (bsp) - bpstat *bsp; +bpstat_clear (bpstat *bsp) { bpstat p; bpstat q; @@ -1673,7 +1642,7 @@ bpstat_clear (bsp) q = p->next; if (p->old_val != NULL) value_free (p->old_val); - free ((PTR) p); + xfree (p); p = q; } *bsp = NULL; @@ -1683,8 +1652,7 @@ bpstat_clear (bsp) is part of the bpstat is copied as well. */ bpstat -bpstat_copy (bs) - bpstat bs; +bpstat_copy (bpstat bs) { bpstat p = NULL; bpstat tmp; @@ -1711,9 +1679,7 @@ bpstat_copy (bs) /* Find the bpstat associated with this breakpoint */ bpstat -bpstat_find_breakpoint (bsp, breakpoint) - bpstat bsp; - struct breakpoint *breakpoint; +bpstat_find_breakpoint (bpstat bsp, struct breakpoint *breakpoint) { if (bsp == NULL) return NULL; @@ -1735,8 +1701,7 @@ bpstat_find_breakpoint (bsp, breakpoint) See wait_for_inferior's use of this function. */ struct breakpoint * -bpstat_find_step_resume_breakpoint (bsp) - bpstat bsp; +bpstat_find_step_resume_breakpoint (bpstat bsp) { if (bsp == NULL) error ("Internal error (bpstat_find_step_resume_breakpoint)"); @@ -1759,8 +1724,7 @@ bpstat_find_step_resume_breakpoint (bsp) Return 0 if passed a bpstat which does not indicate any breakpoints. */ int -bpstat_num (bsp) - bpstat *bsp; +bpstat_num (bpstat *bsp) { struct breakpoint *b; @@ -1780,8 +1744,7 @@ bpstat_num (bsp) /* Modify BS so that the actions will not be performed. */ void -bpstat_clear_actions (bs) - bpstat bs; +bpstat_clear_actions (bpstat bs) { for (; bs != NULL; bs = bs->next) { @@ -1797,8 +1760,7 @@ bpstat_clear_actions (bs) /* Stub for cleaning up our state if we error-out of a breakpoint command */ /* ARGSUSED */ static void -cleanup_executing_breakpoints (ignore) - PTR ignore; +cleanup_executing_breakpoints (PTR ignore) { executing_breakpoint_commands = 0; } @@ -1809,8 +1771,7 @@ cleanup_executing_breakpoints (ignore) the global "breakpoint_proceeded" after each command. */ void -bpstat_do_actions (bsp) - bpstat *bsp; +bpstat_do_actions (bpstat *bsp) { bpstat bs; struct cleanup *old_chain; @@ -1885,9 +1846,14 @@ top: analysis. */ static enum print_stop_action -print_it_typical (bs) - bpstat bs; +print_it_typical (bpstat bs) { +#ifdef UI_OUT + struct cleanup *old_chain; + struct ui_stream *stb; + stb = ui_out_stream_new (uiout); + old_chain = make_cleanup_ui_out_stream_delete (stb); +#endif /* UI_OUT */ /* bs->breakpoint_at can be NULL if it was a momentary breakpoint which has since been deleted. */ if (bs->breakpoint_at == NULL) @@ -1897,11 +1863,21 @@ print_it_typical (bs) { case bp_breakpoint: case bp_hardware_breakpoint: +#ifdef UI_OUT + annotate_breakpoint (bs->breakpoint_at->number); + ui_out_text (uiout, "\nBreakpoint "); + if (interpreter_p && strcmp (interpreter_p, "mi") == 0) + ui_out_field_string (uiout, "reason", "breakpoint-hit"); + ui_out_field_int (uiout, "bkptno", bs->breakpoint_at->number); + ui_out_text (uiout, ", "); + return PRINT_SRC_AND_LOC; +#else /* I think the user probably only wants to see one breakpoint number, not all of them. */ annotate_breakpoint (bs->breakpoint_at->number); printf_filtered ("\nBreakpoint %d, ", bs->breakpoint_at->number); return PRINT_SRC_AND_LOC; +#endif break; case bp_shlib_event: @@ -2034,6 +2010,20 @@ print_it_typical (bs) if (bs->old_val != NULL) { annotate_watchpoint (bs->breakpoint_at->number); +#ifdef UI_OUT + if (interpreter_p && strcmp (interpreter_p, "mi") == 0) + ui_out_field_string (uiout, "reason", "watchpoint-trigger"); + mention (bs->breakpoint_at); + ui_out_list_begin (uiout, "value"); + ui_out_text (uiout, "\nOld value = "); + value_print (bs->old_val, stb->stream, 0, Val_pretty_default); + ui_out_field_stream (uiout, "old", stb); + ui_out_text (uiout, "\nNew value = "); + value_print (bs->breakpoint_at->val, stb->stream, 0, Val_pretty_default); + ui_out_field_stream (uiout, "new", stb); + ui_out_list_end (uiout); + ui_out_text (uiout, "\n"); +#else mention (bs->breakpoint_at); printf_filtered ("\nOld value = "); value_print (bs->old_val, gdb_stdout, 0, Val_pretty_default); @@ -2041,6 +2031,7 @@ print_it_typical (bs) value_print (bs->breakpoint_at->val, gdb_stdout, 0, Val_pretty_default); printf_filtered ("\n"); +#endif value_free (bs->old_val); bs->old_val = NULL; } @@ -2049,15 +2040,55 @@ print_it_typical (bs) break; case bp_read_watchpoint: +#ifdef UI_OUT + if (interpreter_p && strcmp (interpreter_p, "mi") == 0) + ui_out_field_string (uiout, "reason", "read-watchpoint-trigger"); + mention (bs->breakpoint_at); + ui_out_list_begin (uiout, "value"); + ui_out_text (uiout, "\nValue = "); + value_print (bs->breakpoint_at->val, stb->stream, 0, Val_pretty_default); + ui_out_field_stream (uiout, "value", stb); + ui_out_list_end (uiout); + ui_out_text (uiout, "\n"); +#else mention (bs->breakpoint_at); printf_filtered ("\nValue = "); value_print (bs->breakpoint_at->val, gdb_stdout, 0, Val_pretty_default); printf_filtered ("\n"); +#endif return PRINT_UNKNOWN; break; case bp_access_watchpoint: +#ifdef UI_OUT + if (bs->old_val != NULL) + { + annotate_watchpoint (bs->breakpoint_at->number); + if (interpreter_p && strcmp (interpreter_p, "mi") == 0) + ui_out_field_string (uiout, "reason", "access-watchpoint-trigger"); + mention (bs->breakpoint_at); + ui_out_list_begin (uiout, "value"); + ui_out_text (uiout, "\nOld value = "); + value_print (bs->old_val, stb->stream, 0, Val_pretty_default); + ui_out_field_stream (uiout, "old", stb); + value_free (bs->old_val); + bs->old_val = NULL; + ui_out_text (uiout, "\nNew value = "); + } + else + { + mention (bs->breakpoint_at); + if (interpreter_p && strcmp (interpreter_p, "mi") == 0) + ui_out_field_string (uiout, "reason", "access-watchpoint-trigger"); + ui_out_list_begin (uiout, "value"); + ui_out_text (uiout, "\nValue = "); + } + value_print (bs->breakpoint_at->val, stb->stream, 0,Val_pretty_default); + ui_out_field_stream (uiout, "new", stb); + ui_out_list_end (uiout); + ui_out_text (uiout, "\n"); +#else if (bs->old_val != NULL) { annotate_watchpoint (bs->breakpoint_at->number); @@ -2076,6 +2107,7 @@ print_it_typical (bs) value_print (bs->breakpoint_at->val, gdb_stdout, 0, Val_pretty_default); printf_filtered ("\n"); +#endif return PRINT_UNKNOWN; break; @@ -2083,7 +2115,21 @@ print_it_typical (bs) here. */ case bp_finish: +#ifdef UI_OUT + if (interpreter_p && strcmp (interpreter_p, "mi") == 0) + ui_out_field_string (uiout, "reason", "function-finished"); +#endif + return PRINT_UNKNOWN; + break; + case bp_until: +#ifdef UI_OUT + if (interpreter_p && strcmp (interpreter_p, "mi") == 0) + ui_out_field_string (uiout, "reason", "location-reached"); +#endif + return PRINT_UNKNOWN; + break; + case bp_none: case bp_longjmp: case bp_longjmp_resume: @@ -2123,7 +2169,8 @@ print_bp_stop_message (bpstat bs) return print_it_typical (bs); break; default: - internal_error ("print_bp_stop_message: unrecognized enum value"); + internal_error (__FILE__, __LINE__, + "print_bp_stop_message: unrecognized enum value"); break; } } @@ -2149,8 +2196,7 @@ print_bp_stop_message (bpstat bs) further info to be printed.*/ enum print_stop_action -bpstat_print (bs) - bpstat bs; +bpstat_print (bpstat bs) { int val; @@ -2178,8 +2224,7 @@ bpstat_print (bs) make it pass through catch_errors. */ static int -breakpoint_cond_eval (exp) - PTR exp; +breakpoint_cond_eval (PTR exp) { value_ptr mark = value_mark (); int i = !value_true (evaluate_expression ((struct expression *) exp)); @@ -2190,9 +2235,7 @@ breakpoint_cond_eval (exp) /* Allocate a new bpstat and chain it to the current one. */ static bpstat -bpstat_alloc (b, cbs) - register struct breakpoint *b; - bpstat cbs; /* Current "bs" value */ +bpstat_alloc (struct breakpoint *b, bpstat cbs /* Current "bs" value */ ) { bpstat bs; @@ -2221,8 +2264,7 @@ bpstat_alloc (b, cbs) /* Check watchpoint condition. */ static int -watchpoint_check (p) - PTR p; +watchpoint_check (PTR p) { bpstat bs = (bpstat) p; struct breakpoint *b; @@ -2288,9 +2330,18 @@ watchpoint_check (p) in this case, by the time we call print_it_typical() this bp will be deleted already. So we have no choice but print the information here. */ +#ifdef UI_OUT + if (interpreter_p && strcmp (interpreter_p, "mi") == 0) + ui_out_field_string (uiout, "reason", "watchpoint-scope"); + ui_out_text (uiout, "\nWatchpoint "); + ui_out_field_int (uiout, "wpnum", bs->breakpoint_at->number); + ui_out_text (uiout, " deleted because the program has left the block in\n\ +which its expression is valid.\n"); +#else printf_filtered ("\ Watchpoint %d deleted because the program has left the block in\n\ which its expression is valid.\n", bs->breakpoint_at->number); +#endif if (b->related_breakpoint) b->related_breakpoint->disposition = del_at_next_stop; @@ -2321,9 +2372,7 @@ which its expression is valid.\n", bs->breakpoint_at->number); commands, FIXME??? fields. */ bpstat -bpstat_stop_status (pc, not_a_breakpoint) - CORE_ADDR *pc; - int not_a_breakpoint; +bpstat_stop_status (CORE_ADDR *pc, int not_a_breakpoint) { register struct breakpoint *b, *temp; CORE_ADDR bp_addr; @@ -2338,7 +2387,7 @@ bpstat_stop_status (pc, not_a_breakpoint) char message[sizeof (message1) + 30 /* slop */ ]; /* Get the address where the breakpoint would have been. */ - bp_addr = *pc - (not_a_breakpoint && !SOFTWARE_SINGLE_STEP_P ? + bp_addr = *pc - (not_a_breakpoint && !SOFTWARE_SINGLE_STEP_P () ? 0 : DECR_PC_AFTER_BREAK); ALL_BREAKPOINTS_SAFE (b, temp) @@ -2373,10 +2422,11 @@ bpstat_stop_status (pc, not_a_breakpoint) ignore it. */ if ((b->type == bp_catch_load) #if defined(SOLIB_HAVE_LOAD_EVENT) - && (!SOLIB_HAVE_LOAD_EVENT (inferior_pid) + && (!SOLIB_HAVE_LOAD_EVENT (PIDGET (inferior_ptid)) || ((b->dll_pathname != NULL) && (strcmp (b->dll_pathname, - SOLIB_LOADED_LIBRARY_PATHNAME (inferior_pid)) + SOLIB_LOADED_LIBRARY_PATHNAME ( + PIDGET (inferior_ptid))) != 0))) #endif ) @@ -2384,25 +2434,28 @@ bpstat_stop_status (pc, not_a_breakpoint) if ((b->type == bp_catch_unload) #if defined(SOLIB_HAVE_UNLOAD_EVENT) - && (!SOLIB_HAVE_UNLOAD_EVENT (inferior_pid) + && (!SOLIB_HAVE_UNLOAD_EVENT (PIDGET (inferior_ptid)) || ((b->dll_pathname != NULL) && (strcmp (b->dll_pathname, - SOLIB_UNLOADED_LIBRARY_PATHNAME (inferior_pid)) + SOLIB_UNLOADED_LIBRARY_PATHNAME ( + PIDGET (inferior_ptid))) != 0))) #endif ) continue; if ((b->type == bp_catch_fork) - && !target_has_forked (inferior_pid, &b->forked_inferior_pid)) + && !target_has_forked (PIDGET (inferior_ptid), + &b->forked_inferior_pid)) continue; if ((b->type == bp_catch_vfork) - && !target_has_vforked (inferior_pid, &b->forked_inferior_pid)) + && !target_has_vforked (PIDGET (inferior_ptid), + &b->forked_inferior_pid)) continue; if ((b->type == bp_catch_exec) - && !target_has_execd (inferior_pid, &b->exec_pathname)) + && !target_has_execd (PIDGET (inferior_ptid), &b->exec_pathname)) continue; if (ep_is_exception_catchpoint (b) && @@ -2472,14 +2525,21 @@ bpstat_stop_status (pc, not_a_breakpoint) if (VALUE_LVAL (v) == lval_memory && ! VALUE_LAZY (v)) { - CORE_ADDR vaddr; - - vaddr = VALUE_ADDRESS (v) + VALUE_OFFSET (v); - /* Exact match not required. Within range is sufficient. - */ - if (addr >= vaddr && - addr < vaddr + TYPE_LENGTH (VALUE_TYPE (v))) - found = 1; + struct type *vtype = check_typedef (VALUE_TYPE (v)); + + if (v == b->val_chain + || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT + && TYPE_CODE (vtype) != TYPE_CODE_ARRAY)) + { + CORE_ADDR vaddr; + + vaddr = VALUE_ADDRESS (v) + VALUE_OFFSET (v); + /* Exact match not required. Within range is + sufficient. */ + if (addr >= vaddr && + addr < vaddr + TYPE_LENGTH (VALUE_TYPE (v))) + found = 1; + } } } if (found) @@ -2492,6 +2552,17 @@ bpstat_stop_status (pc, not_a_breakpoint) /* Stop. */ break; case WP_VALUE_CHANGED: + if (b->type == bp_read_watchpoint) + { + /* Don't stop: read watchpoints shouldn't fire if + the value has changed. This is for targets which + cannot set read-only watchpoints. */ + bs->print_it = print_it_noop; + bs->stop = 0; + continue; + } + ++(b->hit_count); + break; case WP_VALUE_NOT_CHANGED: /* Stop. */ ++(b->hit_count); @@ -2623,8 +2694,7 @@ bpstat_stop_status (pc, not_a_breakpoint) /* Tell what to do about this bpstat. */ struct bpstat_what -bpstat_what (bs) - bpstat bs; +bpstat_what (bpstat bs) { /* Classify each bpstat as one of the following. */ enum class @@ -2703,7 +2773,7 @@ bpstat_what (bs) back and decide something of a lower priority is better. The ordering is: - kc < clr sgl shl slr sn sr ss ts + kc < clr sgl shl shlr slr sn sr ss ts sgl < clrs shl shlr slr sn sr ss ts slr < err shl shlr sn sr ss ts clr < clrs err shl shlr sn sr ss ts @@ -2748,7 +2818,7 @@ bpstat_what (bs) /*bp_noisy */ {sn, sn, sn, sn, sn, sn, sn, sr, ts, shl, shlr}, /*long_jump */ - {slr, ss, sn, slr, err, err, err, sr, ts, shl, shlr}, + {slr, ss, sn, slr, slr, err, err, sr, ts, shl, shlr}, /*long_resume */ {clr, ss, sn, clrs, err, err, err, sr, ts, shl, shlr}, /*step_resume */ @@ -2901,18 +2971,18 @@ bpstat_what (bs) just to things like whether watchpoints are set. */ int -bpstat_should_step () +bpstat_should_step (void) { struct breakpoint *b; ALL_BREAKPOINTS (b) if (b->enable == enabled && b->type == bp_watchpoint) - return 1; + return 1; return 0; } /* Nonzero if there are enabled hardware watchpoints. */ int -bpstat_have_active_hw_watchpoints () +bpstat_have_active_hw_watchpoints (void) { struct breakpoint *b; ALL_BREAKPOINTS (b) @@ -2921,7 +2991,7 @@ bpstat_have_active_hw_watchpoints () ((b->type == bp_hardware_watchpoint) || (b->type == bp_read_watchpoint) || (b->type == bp_access_watchpoint))) - return 1; + return 1; return 0; } @@ -2930,9 +3000,7 @@ bpstat_have_active_hw_watchpoints () function returns another bpstat which contains only the catchpoints on that first list, if any. */ void -bpstat_get_triggered_catchpoints (ep_list, cp_list) - bpstat ep_list; - bpstat *cp_list; +bpstat_get_triggered_catchpoints (bpstat ep_list, bpstat *cp_list) { struct bpstats root_bs[1]; bpstat bs = root_bs; @@ -2968,11 +3036,13 @@ bpstat_get_triggered_catchpoints (ep_list, cp_list) catchpoint triggers. Clients who may wish to know the name later must get it from the catchpoint itself.) */ if (ep->triggered_dll_pathname != NULL) - free (ep->triggered_dll_pathname); + xfree (ep->triggered_dll_pathname); if (ep->type == bp_catch_load) - dll_pathname = SOLIB_LOADED_LIBRARY_PATHNAME (inferior_pid); + dll_pathname = SOLIB_LOADED_LIBRARY_PATHNAME ( + PIDGET (inferior_ptid)); else - dll_pathname = SOLIB_UNLOADED_LIBRARY_PATHNAME (inferior_pid); + dll_pathname = SOLIB_UNLOADED_LIBRARY_PATHNAME ( + PIDGET (inferior_ptid)); #else dll_pathname = NULL; #endif @@ -3033,37 +3103,68 @@ print_one_breakpoint (struct breakpoint *b, {"del", "dstp", "dis", "keep"}; static char bpenables[] = "nynny"; char wrap_indent[80]; +#ifdef UI_OUT + struct ui_stream *stb = ui_out_stream_new (uiout); + struct cleanup *old_chain = make_cleanup_ui_out_stream_delete (stb); +#endif annotate_record (); +#ifdef UI_OUT + ui_out_list_begin (uiout, "bkpt"); +#endif /* 1 */ annotate_field (0); +#ifdef UI_OUT + ui_out_field_int (uiout, "number", b->number); +#else printf_filtered ("%-3d ", b->number); +#endif /* 2 */ annotate_field (1); if (((int) b->type > (sizeof (bptypes) / sizeof (bptypes[0]))) || ((int) b->type != bptypes[(int) b->type].type)) - internal_error ("bptypes table does not describe type #%d.", + internal_error (__FILE__, __LINE__, + "bptypes table does not describe type #%d.", (int) b->type); +#ifdef UI_OUT + ui_out_field_string (uiout, "type", bptypes[(int) b->type].description); +#else printf_filtered ("%-14s ", bptypes[(int) b->type].description); +#endif /* 3 */ annotate_field (2); +#ifdef UI_OUT + ui_out_field_string (uiout, "disp", bpdisps[(int) b->disposition]); +#else printf_filtered ("%-4s ", bpdisps[(int) b->disposition]); +#endif /* 4 */ annotate_field (3); +#ifdef UI_OUT + ui_out_field_fmt (uiout, "enabled", "%c", bpenables[(int) b->enable]); + ui_out_spaces (uiout, 2); +#else printf_filtered ("%-3c ", bpenables[(int) b->enable]); +#endif /* 5 and 6 */ strcpy (wrap_indent, " "); if (addressprint) - strcat (wrap_indent, " "); + { + if (TARGET_ADDR_BIT <= 32) + strcat (wrap_indent, " "); + else + strcat (wrap_indent, " "); + } switch (b->type) { case bp_none: - internal_error ("print_one_breakpoint: bp_none encountered\n"); + internal_error (__FILE__, __LINE__, + "print_one_breakpoint: bp_none encountered\n"); break; case bp_watchpoint: @@ -3073,8 +3174,16 @@ print_one_breakpoint (struct breakpoint *b, /* Field 4, the address, is omitted (which makes the columns not line up too nicely with the headers, but the effect is relatively readable). */ +#ifdef UI_OUT + if (addressprint) + ui_out_field_skip (uiout, "addr"); + annotate_field (5); + print_expression (b->exp, stb->stream); + ui_out_field_stream (uiout, "what", stb); +#else annotate_field (5); print_expression (b->exp, gdb_stdout); +#endif break; case bp_catch_load: @@ -3082,11 +3191,28 @@ print_one_breakpoint (struct breakpoint *b, /* Field 4, the address, is omitted (which makes the columns not line up too nicely with the headers, but the effect is relatively readable). */ +#ifdef UI_OUT + if (addressprint) + ui_out_field_skip (uiout, "addr"); + annotate_field (5); + if (b->dll_pathname == NULL) + { + ui_out_field_string (uiout, "what", ""); + ui_out_spaces (uiout, 1); + } + else + { + ui_out_text (uiout, "library \""); + ui_out_field_string (uiout, "what", b->dll_pathname); + ui_out_text (uiout, "\" "); + } +#else annotate_field (5); if (b->dll_pathname == NULL) printf_filtered (" "); else printf_filtered ("library \"%s\" ", b->dll_pathname); +#endif break; case bp_catch_fork: @@ -3094,34 +3220,74 @@ print_one_breakpoint (struct breakpoint *b, /* Field 4, the address, is omitted (which makes the columns not line up too nicely with the headers, but the effect is relatively readable). */ +#ifdef UI_OUT + if (addressprint) + ui_out_field_skip (uiout, "addr"); + annotate_field (5); + if (b->forked_inferior_pid != 0) + { + ui_out_text (uiout, "process "); + ui_out_field_int (uiout, "what", b->forked_inferior_pid); + ui_out_spaces (uiout, 1); + } +#else annotate_field (5); if (b->forked_inferior_pid != 0) printf_filtered ("process %d ", b->forked_inferior_pid); break; +#endif case bp_catch_exec: /* Field 4, the address, is omitted (which makes the columns not line up too nicely with the headers, but the effect is relatively readable). */ +#ifdef UI_OUT + if (addressprint) + ui_out_field_skip (uiout, "addr"); + annotate_field (5); + if (b->exec_pathname != NULL) + { + ui_out_text (uiout, "program \""); + ui_out_field_string (uiout, "what", b->exec_pathname); + ui_out_text (uiout, "\" "); + } +#else annotate_field (5); if (b->exec_pathname != NULL) printf_filtered ("program \"%s\" ", b->exec_pathname); +#endif break; case bp_catch_catch: /* Field 4, the address, is omitted (which makes the columns not line up too nicely with the headers, but the effect is relatively readable). */ +#ifdef UI_OUT + if (addressprint) + ui_out_field_skip (uiout, "addr"); + annotate_field (5); + ui_out_field_string (uiout, "what", "exception catch"); + ui_out_spaces (uiout, 1); +#else annotate_field (5); printf_filtered ("exception catch "); +#endif break; case bp_catch_throw: /* Field 4, the address, is omitted (which makes the columns not line up too nicely with the headers, but the effect is relatively readable). */ +#ifdef UI_OUT + if (addressprint) + ui_out_field_skip (uiout, "addr"); + annotate_field (5); + ui_out_field_string (uiout, "what", "exception throw"); + ui_out_spaces (uiout, 1); +#else annotate_field (5); printf_filtered ("exception throw "); +#endif break; case bp_breakpoint: @@ -3136,15 +3302,49 @@ print_one_breakpoint (struct breakpoint *b, case bp_call_dummy: case bp_shlib_event: case bp_thread_event: +#ifdef UI_OUT + if (addressprint) + { + annotate_field (4); + ui_out_field_core_addr (uiout, "addr", b->address); + } + annotate_field (5); + *last_addr = b->address; + if (b->source_file) + { + sym = find_pc_sect_function (b->address, b->section); + if (sym) + { + ui_out_text (uiout, "in "); + ui_out_field_string (uiout, "func", + SYMBOL_SOURCE_NAME (sym)); + ui_out_wrap_hint (uiout, wrap_indent); + ui_out_text (uiout, " at "); + } + ui_out_field_string (uiout, "file", b->source_file); + ui_out_text (uiout, ":"); + ui_out_field_int (uiout, "line", b->line_number); + } + else + { + print_address_symbolic (b->address, stb->stream, demangle, ""); + ui_out_field_stream (uiout, "at", stb); + } +#else if (addressprint) { + char *tmp; + annotate_field (4); - /* FIXME-32x64: need a print_address_numeric with - field width */ - printf_filtered - ("%s ", - local_hex_string_custom - ((unsigned long) b->address, "08l")); + + if (TARGET_ADDR_BIT <= 32) + tmp = longest_local_hex_string_custom (b->address + & (CORE_ADDR) 0xffffffff, + "08l"); + else + tmp = longest_local_hex_string_custom (b->address, "016l"); + + printf_filtered ("%s ", tmp); } annotate_field (5); *last_addr = b->address; @@ -3163,64 +3363,132 @@ print_one_breakpoint (struct breakpoint *b, } else print_address_symbolic (b->address, gdb_stdout, demangle, " "); +#endif break; } if (b->thread != -1) { +#ifdef UI_OUT + /* FIXME: This seems to be redundant and lost here; see the + "stop only in" line a little further down. */ + ui_out_text (uiout, " thread "); + ui_out_field_int (uiout, "thread", b->thread); +#else printf_filtered (" thread %d", b->thread); +#endif } +#ifdef UI_OUT + ui_out_text (uiout, "\n"); +#else printf_filtered ("\n"); +#endif if (b->frame) { annotate_field (6); +#ifdef UI_OUT + ui_out_text (uiout, "\tstop only in stack frame at "); + ui_out_field_core_addr (uiout, "frame", b->frame); + ui_out_text (uiout, "\n"); +#else printf_filtered ("\tstop only in stack frame at "); print_address_numeric (b->frame, 1, gdb_stdout); printf_filtered ("\n"); +#endif } if (b->cond) { annotate_field (7); +#ifdef UI_OUT + ui_out_text (uiout, "\tstop only if "); + print_expression (b->cond, stb->stream); + ui_out_field_stream (uiout, "cond", stb); + ui_out_text (uiout, "\n"); +#else printf_filtered ("\tstop only if "); print_expression (b->cond, gdb_stdout); printf_filtered ("\n"); +#endif } if (b->thread != -1) { /* FIXME should make an annotation for this */ +#ifdef UI_OUT + ui_out_text (uiout, "\tstop only in thread "); + ui_out_field_int (uiout, "thread", b->thread); + ui_out_text (uiout, "\n"); +#else printf_filtered ("\tstop only in thread %d\n", b->thread); +#endif } if (show_breakpoint_hit_counts && b->hit_count) { /* FIXME should make an annotation for this */ +#ifdef UI_OUT + if (ep_is_catchpoint (b)) + ui_out_text (uiout, "\tcatchpoint"); + else + ui_out_text (uiout, "\tbreakpoint"); + ui_out_text (uiout, " already hit "); + ui_out_field_int (uiout, "times", b->hit_count); + if (b->hit_count == 1) + ui_out_text (uiout, " time\n"); + else + ui_out_text (uiout, " times\n"); +#else if (ep_is_catchpoint (b)) printf_filtered ("\tcatchpoint"); else printf_filtered ("\tbreakpoint"); printf_filtered (" already hit %d time%s\n", b->hit_count, (b->hit_count == 1 ? "" : "s")); +#endif } +#ifdef UI_OUT + /* Output the count also if it is zero, but only if this is + mi. FIXME: Should have a better test for this. */ + if (interpreter_p && strcmp (interpreter_p, "mi") == 0) + if (show_breakpoint_hit_counts && b->hit_count == 0) + ui_out_field_int (uiout, "times", b->hit_count); +#endif + if (b->ignore_count) { annotate_field (8); +#ifdef UI_OUT + ui_out_text (uiout, "\tignore next "); + ui_out_field_int (uiout, "ignore", b->ignore_count); + ui_out_text (uiout, " hits\n"); +#else printf_filtered ("\tignore next %d hits\n", b->ignore_count); +#endif } if ((l = b->commands)) { annotate_field (9); +#ifdef UI_OUT + ui_out_list_begin (uiout, "script"); + print_command_lines (uiout, l, 4); + ui_out_list_end (uiout); +#else while (l) { print_command_line (l, 4, gdb_stdout); l = l->next; } +#endif } +#ifdef UI_OUT + ui_out_list_end (uiout); + do_cleanups (old_chain); +#endif } struct captured_breakpoint_query_args @@ -3261,14 +3529,19 @@ gdb_breakpoint_query (/* output object, */ int bnum) is nonzero, process only watchpoints. */ static void -breakpoint_1 (bnum, allflag) - int bnum; - int allflag; +breakpoint_1 (int bnum, int allflag) { register struct breakpoint *b; CORE_ADDR last_addr = (CORE_ADDR) -1; int found_a_breakpoint = 0; +#ifdef UI_OUT + if (addressprint) + ui_out_table_begin (uiout, 6, "BreakpointTable"); + else + ui_out_table_begin (uiout, 5, "BreakpointTable"); +#endif /* UI_OUT */ + ALL_BREAKPOINTS (b) if (bnum == -1 || bnum == b->number) @@ -3294,6 +3567,27 @@ breakpoint_1 (bnum, allflag) if (!found_a_breakpoint++) { annotate_breakpoints_headers (); +#ifdef UI_OUT + annotate_field (0); + ui_out_table_header (uiout, 3, ui_left, "Num"); /* 1 */ + annotate_field (1); + ui_out_table_header (uiout, 14, ui_left, "Type"); /* 2 */ + annotate_field (2); + ui_out_table_header (uiout, 4, ui_left, "Disp"); /* 3 */ + annotate_field (3); + ui_out_table_header (uiout, 3, ui_left, "Enb"); /* 4 */ + if (addressprint) + { + annotate_field (4); + if (TARGET_ADDR_BIT <= 32) + ui_out_table_header (uiout, 10, ui_left, "Address"); /* 5 */ + else + ui_out_table_header (uiout, 18, ui_left, "Address"); /* 5 */ + } + annotate_field (5); + ui_out_table_header (uiout, 40, ui_noalign, "What"); /* 6 */ + ui_out_table_body (uiout); +#else annotate_field (0); printf_filtered ("Num "); annotate_field (1); @@ -3305,10 +3599,14 @@ breakpoint_1 (bnum, allflag) if (addressprint) { annotate_field (4); - printf_filtered ("Address "); + if (TARGET_ADDR_BIT <= 32) + printf_filtered ("Address "); + else + printf_filtered ("Address "); } annotate_field (5); printf_filtered ("What\n"); +#endif /* UI_OUT */ annotate_breakpoints_table (); } @@ -3317,10 +3615,18 @@ breakpoint_1 (bnum, allflag) if (!found_a_breakpoint) { +#ifdef UI_OUT + if (bnum == -1) + ui_out_message (uiout, 0, "No breakpoints or watchpoints.\n"); + else + ui_out_message (uiout, 0, "No breakpoint or watchpoint number %d.\n", + bnum); +#else if (bnum == -1) printf_filtered ("No breakpoints or watchpoints.\n"); else printf_filtered ("No breakpoint or watchpoint number %d.\n", bnum); +#endif /* UI_OUT */ } else { @@ -3330,6 +3636,9 @@ breakpoint_1 (bnum, allflag) set_next_address (last_addr); } +#ifdef UI_OUT + ui_out_table_end (uiout); +#endif /* UI_OUT */ /* FIXME? Should this be moved up so that it is only called when there have been breakpoints? */ annotate_breakpoints_table_end (); @@ -3337,28 +3646,24 @@ breakpoint_1 (bnum, allflag) /* ARGSUSED */ static void -breakpoints_info (bnum_exp, from_tty) - char *bnum_exp; - int from_tty; +breakpoints_info (char *bnum_exp, int from_tty) { int bnum = -1; if (bnum_exp) - bnum = parse_and_eval_address (bnum_exp); + bnum = parse_and_eval_long (bnum_exp); breakpoint_1 (bnum, 0); } /* ARGSUSED */ static void -maintenance_info_breakpoints (bnum_exp, from_tty) - char *bnum_exp; - int from_tty; +maintenance_info_breakpoints (char *bnum_exp, int from_tty) { int bnum = -1; if (bnum_exp) - bnum = parse_and_eval_address (bnum_exp); + bnum = parse_and_eval_long (bnum_exp); breakpoint_1 (bnum, 1); } @@ -3366,9 +3671,7 @@ maintenance_info_breakpoints (bnum_exp, from_tty) /* Print a message describing any breakpoints set at PC. */ static void -describe_other_breakpoints (pc, section) - CORE_ADDR pc; - asection *section; +describe_other_breakpoints (CORE_ADDR pc, asection *section) { register int others = 0; register struct breakpoint *b; @@ -3387,15 +3690,15 @@ describe_other_breakpoints (pc, section) b->section == section) { others--; - printf_filtered - ("%d%s%s ", - b->number, - ((b->enable == disabled || - b->enable == shlib_disabled || - b->enable == call_disabled) ? " (disabled)" - : b->enable == permanent ? " (permanent)" - : ""), - (others > 1) ? "," : ((others == 1) ? " and" : "")); + printf_filtered ("%d%s%s ", + b->number, + ((b->enable == disabled || + b->enable == shlib_disabled || + b->enable == call_disabled) ? " (disabled)" + : b->enable == permanent ? " (permanent)" + : ""), + (others > 1) ? "," + : ((others == 1) ? " and" : "")); } printf_filtered ("also set at pc "); print_address_numeric (pc, 1, gdb_stdout); @@ -3407,11 +3710,8 @@ describe_other_breakpoints (pc, section) for the `break' command with no arguments. */ void -set_default_breakpoint (valid, addr, symtab, line) - int valid; - CORE_ADDR addr; - struct symtab *symtab; - int line; +set_default_breakpoint (int valid, CORE_ADDR addr, struct symtab *symtab, + int line) { default_breakpoint_valid = valid; default_breakpoint_address = addr; @@ -3426,9 +3726,7 @@ set_default_breakpoint (valid, addr, symtab, line) the official one, and the rest as duplicates. */ static void -check_duplicates (address, section) - CORE_ADDR address; - asection *section; +check_duplicates (CORE_ADDR address, asection *section) { register struct breakpoint *b; register int count = 0; @@ -3464,14 +3762,16 @@ check_duplicates (address, section) /* Permanent breakpoint should always be inserted. */ if (! perm_bp->inserted) - internal_error ("allegedly permanent breakpoint is not " + internal_error (__FILE__, __LINE__, + "allegedly permanent breakpoint is not " "actually inserted"); ALL_BREAKPOINTS (b) if (b != perm_bp) { if (b->inserted) - internal_error ("another breakpoint was inserted on top of " + internal_error (__FILE__, __LINE__, + "another breakpoint was inserted on top of " "a permanent breakpoint"); if (b->enable != disabled @@ -3495,8 +3795,7 @@ check_duplicates (address, section) your arguments BEFORE calling this routine! */ struct breakpoint * -set_raw_breakpoint (sal) - struct symtab_and_line sal; +set_raw_breakpoint (struct symtab_and_line sal) { register struct breakpoint *b, *b1; @@ -3559,8 +3858,7 @@ make_breakpoint_permanent (struct breakpoint *b) #ifdef GET_LONGJMP_TARGET static void -create_longjmp_breakpoint (func_name) - char *func_name; +create_longjmp_breakpoint (char *func_name) { struct symtab_and_line sal; struct breakpoint *b; @@ -3587,7 +3885,7 @@ create_longjmp_breakpoint (func_name) b->enable = disabled; b->silent = 1; if (func_name) - b->addr_string = strsave (func_name); + b->addr_string = xstrdup (func_name); b->number = internal_breakpoint_number--; } @@ -3598,7 +3896,7 @@ create_longjmp_breakpoint (func_name) set_longjmp_resume_breakpoint() to figure out where we are going. */ void -enable_longjmp_breakpoint () +enable_longjmp_breakpoint (void) { register struct breakpoint *b; @@ -3611,7 +3909,7 @@ enable_longjmp_breakpoint () } void -disable_longjmp_breakpoint () +disable_longjmp_breakpoint (void) { register struct breakpoint *b; @@ -3625,8 +3923,7 @@ disable_longjmp_breakpoint () } struct breakpoint * -create_thread_event_breakpoint (address) - CORE_ADDR address; +create_thread_event_breakpoint (CORE_ADDR address) { struct breakpoint *b; struct symtab_and_line sal; @@ -3645,7 +3942,7 @@ create_thread_event_breakpoint (address) b->enable = enabled; /* addr_string has to be used or breakpoint_re_set will delete me. */ sprintf (addr_string, "*0x%s", paddr (b->address)); - b->addr_string = strsave (addr_string); + b->addr_string = xstrdup (addr_string); return b; } @@ -3662,18 +3959,17 @@ remove_thread_event_breakpoints (void) #ifdef SOLIB_ADD void -remove_solib_event_breakpoints () +remove_solib_event_breakpoints (void) { register struct breakpoint *b, *temp; ALL_BREAKPOINTS_SAFE (b, temp) if (b->type == bp_shlib_event) - delete_breakpoint (b); + delete_breakpoint (b); } struct breakpoint * -create_solib_event_breakpoint (address) - CORE_ADDR address; +create_solib_event_breakpoint (CORE_ADDR address) { struct breakpoint *b; struct symtab_and_line sal; @@ -3693,8 +3989,7 @@ create_solib_event_breakpoint (address) apply to enabled breakpoints, disabled ones can just stay disabled. */ void -disable_breakpoints_in_shlibs (silent) - int silent; +disable_breakpoints_in_shlibs (int silent) { struct breakpoint *b; int disabled_shlib_breaks = 0; @@ -3727,7 +4022,7 @@ disable_breakpoints_in_shlibs (silent) /* Try to reenable any breakpoints in shared libraries. */ void -re_enable_breakpoints_in_shlibs () +re_enable_breakpoints_in_shlibs (void) { struct breakpoint *b; @@ -3746,12 +4041,8 @@ re_enable_breakpoints_in_shlibs () #endif static void -solib_load_unload_1 (hookname, tempflag, dll_pathname, cond_string, bp_kind) - char *hookname; - int tempflag; - char *dll_pathname; - char *cond_string; - enum bptype bp_kind; +solib_load_unload_1 (char *hookname, int tempflag, char *dll_pathname, + char *cond_string, enum bptype bp_kind) { struct breakpoint *b; struct symtabs_and_lines sals; @@ -3782,13 +4073,13 @@ solib_load_unload_1 (hookname, tempflag, dll_pathname, cond_string, bp_kind) /* Make sure that all storage allocated in decode_line_1 gets freed in case the following errors out. */ - old_chain = make_cleanup (free, sals.sals); + old_chain = make_cleanup (xfree, sals.sals); if (canonical != (char **) NULL) { - make_cleanup (free, canonical); + make_cleanup (xfree, canonical); canonical_strings_chain = make_cleanup (null_cleanup, 0); if (canonical[0] != NULL) - make_cleanup (free, canonical[0]); + make_cleanup (xfree, canonical[0]); } resolve_sal_pc (&sals.sals[0]); @@ -3827,34 +4118,24 @@ solib_load_unload_1 (hookname, tempflag, dll_pathname, cond_string, bp_kind) } void -create_solib_load_event_breakpoint (hookname, tempflag, - dll_pathname, cond_string) - char *hookname; - int tempflag; - char *dll_pathname; - char *cond_string; +create_solib_load_event_breakpoint (char *hookname, int tempflag, + char *dll_pathname, char *cond_string) { solib_load_unload_1 (hookname, tempflag, dll_pathname, cond_string, bp_catch_load); } void -create_solib_unload_event_breakpoint (hookname, tempflag, - dll_pathname, cond_string) - char *hookname; - int tempflag; - char *dll_pathname; - char *cond_string; +create_solib_unload_event_breakpoint (char *hookname, int tempflag, + char *dll_pathname, char *cond_string) { solib_load_unload_1 (hookname,tempflag, dll_pathname, cond_string, bp_catch_unload); } static void -create_fork_vfork_event_catchpoint (tempflag, cond_string, bp_kind) - int tempflag; - char *cond_string; - enum bptype bp_kind; +create_fork_vfork_event_catchpoint (int tempflag, char *cond_string, + enum bptype bp_kind) { struct symtab_and_line sal; struct breakpoint *b; @@ -3883,25 +4164,19 @@ create_fork_vfork_event_catchpoint (tempflag, cond_string, bp_kind) } void -create_fork_event_catchpoint (tempflag, cond_string) - int tempflag; - char *cond_string; +create_fork_event_catchpoint (int tempflag, char *cond_string) { create_fork_vfork_event_catchpoint (tempflag, cond_string, bp_catch_fork); } void -create_vfork_event_catchpoint (tempflag, cond_string) - int tempflag; - char *cond_string; +create_vfork_event_catchpoint (int tempflag, char *cond_string) { create_fork_vfork_event_catchpoint (tempflag, cond_string, bp_catch_vfork); } void -create_exec_event_catchpoint (tempflag, cond_string) - int tempflag; - char *cond_string; +create_exec_event_catchpoint (int tempflag, char *cond_string) { struct symtab_and_line sal; struct breakpoint *b; @@ -3929,7 +4204,7 @@ create_exec_event_catchpoint (tempflag, cond_string) } static int -hw_breakpoint_used_count () +hw_breakpoint_used_count (void) { register struct breakpoint *b; int i = 0; @@ -3944,9 +4219,7 @@ hw_breakpoint_used_count () } static int -hw_watchpoint_used_count (type, other_type_used) - enum bptype type; - int *other_type_used; +hw_watchpoint_used_count (enum bptype type, int *other_type_used) { register struct breakpoint *b; int i = 0; @@ -3975,9 +4248,7 @@ hw_watchpoint_used_count (type, other_type_used) that gets deleted automatically... */ void -set_longjmp_resume_breakpoint (pc, frame) - CORE_ADDR pc; - struct frame_info *frame; +set_longjmp_resume_breakpoint (CORE_ADDR pc, struct frame_info *frame) { register struct breakpoint *b; @@ -3996,7 +4267,7 @@ set_longjmp_resume_breakpoint (pc, frame) } void -disable_watchpoints_before_interactive_call_start () +disable_watchpoints_before_interactive_call_start (void) { struct breakpoint *b; @@ -4016,7 +4287,7 @@ disable_watchpoints_before_interactive_call_start () } void -enable_watchpoints_after_interactive_call_stop () +enable_watchpoints_after_interactive_call_stop (void) { struct breakpoint *b; @@ -4041,10 +4312,8 @@ enable_watchpoints_after_interactive_call_stop () Restrict it to frame FRAME if FRAME is nonzero. */ struct breakpoint * -set_momentary_breakpoint (sal, frame, type) - struct symtab_and_line sal; - struct frame_info *frame; - enum bptype type; +set_momentary_breakpoint (struct symtab_and_line sal, struct frame_info *frame, + enum bptype type) { register struct breakpoint *b; b = set_raw_breakpoint (sal); @@ -4056,8 +4325,8 @@ set_momentary_breakpoint (sal, frame, type) /* If we're debugging a multi-threaded program, then we want momentary breakpoints to be active in only a single thread of control. */ - if (in_thread_list (inferior_pid)) - b->thread = pid_to_thread_id (inferior_pid); + if (in_thread_list (inferior_ptid)) + b->thread = pid_to_thread_id (inferior_ptid); return b; } @@ -4066,10 +4335,16 @@ set_momentary_breakpoint (sal, frame, type) /* Tell the user we have just set a breakpoint B. */ static void -mention (b) - struct breakpoint *b; +mention (struct breakpoint *b) { int say_where = 0; +#ifdef UI_OUT + struct cleanup *old_chain; + struct ui_stream *stb; + + stb = ui_out_stream_new (uiout); + old_chain = make_cleanup_ui_out_stream_delete (stb); +#endif /* UI_OUT */ /* FIXME: This is misplaced; mention() is called by things (like hitting a watchpoint) other than breakpoint creation. It should be possible to @@ -4085,6 +4360,26 @@ mention (b) case bp_none: printf_filtered ("(apparently deleted?) Eventpoint %d: ", b->number); break; +#ifdef UI_OUT + case bp_watchpoint: + ui_out_text (uiout, "Watchpoint "); + ui_out_list_begin (uiout, "wpt"); + ui_out_field_int (uiout, "number", b->number); + ui_out_text (uiout, ": "); + print_expression (b->exp, stb->stream); + ui_out_field_stream (uiout, "exp", stb); + ui_out_list_end (uiout); + break; + case bp_hardware_watchpoint: + ui_out_text (uiout, "Hardware watchpoint "); + ui_out_list_begin (uiout, "wpt"); + ui_out_field_int (uiout, "number", b->number); + ui_out_text (uiout, ": "); + print_expression (b->exp, stb->stream); + ui_out_field_stream (uiout, "exp", stb); + ui_out_list_end (uiout); + break; +#else case bp_watchpoint: printf_filtered ("Watchpoint %d: ", b->number); print_expression (b->exp, gdb_stdout); @@ -4093,6 +4388,27 @@ mention (b) printf_filtered ("Hardware watchpoint %d: ", b->number); print_expression (b->exp, gdb_stdout); break; +#endif +#ifdef UI_OUT + case bp_read_watchpoint: + ui_out_text (uiout, "Hardware read watchpoint "); + ui_out_list_begin (uiout, "hw-rwpt"); + ui_out_field_int (uiout, "number", b->number); + ui_out_text (uiout, ": "); + print_expression (b->exp, stb->stream); + ui_out_field_stream (uiout, "exp", stb); + ui_out_list_end (uiout); + break; + case bp_access_watchpoint: + ui_out_text (uiout, "Hardware access (read/write) watchpoint "); + ui_out_list_begin (uiout, "hw-awpt"); + ui_out_field_int (uiout, "number", b->number); + ui_out_text (uiout, ": "); + print_expression (b->exp, stb->stream); + ui_out_field_stream (uiout, "exp", stb); + ui_out_list_end (uiout); + break; +#else case bp_read_watchpoint: printf_filtered ("Hardware read watchpoint %d: ", b->number); print_expression (b->exp, gdb_stdout); @@ -4102,11 +4418,26 @@ mention (b) b->number); print_expression (b->exp, gdb_stdout); break; +#endif case bp_breakpoint: +#ifdef UI_OUT + if (interpreter_p && strcmp (interpreter_p, "mi") == 0) + { + say_where = 0; + break; + } +#endif printf_filtered ("Breakpoint %d", b->number); say_where = 1; break; case bp_hardware_breakpoint: +#ifdef UI_OUT + if (interpreter_p && strcmp (interpreter_p, "mi") == 0) + { + say_where = 0; + break; + } +#endif printf_filtered ("Hardware assisted breakpoint %d", b->number); say_where = 1; break; @@ -4160,6 +4491,13 @@ mention (b) TUIDO (((TuiOpaqueFuncPtr) tui_vAllSetHasBreakAt, b, 1)); TUIDO (((TuiOpaqueFuncPtr) tuiUpdateAllExecInfos)); } +#ifdef UI_OUT + do_cleanups (old_chain); +#endif +#ifdef UI_OUT + if (interpreter_p && strcmp (interpreter_p, "mi") == 0) + return; +#endif printf_filtered ("\n"); } @@ -4323,9 +4661,7 @@ breakpoint_sals_to_pc (struct symtabs_and_lines *sals, second bit : 0 normal breakpoint, 1 hardware breakpoint. */ static void -break_command_1 (arg, flag, from_tty) - char *arg; - int flag, from_tty; +break_command_1 (char *arg, int flag, int from_tty) { int tempflag, hardwareflag; struct symtabs_and_lines sals; @@ -4356,18 +4692,18 @@ break_command_1 (arg, flag, from_tty) old_chain = make_cleanup (null_cleanup, 0); /* Make sure that all storage allocated to SALS gets freed. */ - make_cleanup (free, sals.sals); + make_cleanup (xfree, sals.sals); /* Cleanup the addr_string array but not its contents. */ - make_cleanup (free, addr_string); + make_cleanup (xfree, addr_string); /* Allocate space for all the cond expressions. */ cond = xcalloc (sals.nelts, sizeof (struct expression *)); - make_cleanup (free, cond); + make_cleanup (xfree, cond); /* Allocate space for all the cond strings. */ cond_string = xcalloc (sals.nelts, sizeof (char **)); - make_cleanup (free, cond_string); + make_cleanup (xfree, cond_string); /* ----------------------------- SNIP ----------------------------- Anything added to the cleanup chain beyond this point is assumed @@ -4381,7 +4717,7 @@ break_command_1 (arg, flag, from_tty) for (i = 0; i < sals.nelts; i++) { if (addr_string[i] != NULL) - make_cleanup (free, addr_string[i]); + make_cleanup (xfree, addr_string[i]); } /* Resolve all line numbers to PC's and verify that the addresses @@ -4415,10 +4751,10 @@ break_command_1 (arg, flag, from_tty) { tok = cond_start = end_tok + 1; cond[i] = parse_exp_1 (&tok, block_for_pc (sals.sals[i].pc), 0); - make_cleanup (free, cond[i]); + make_cleanup (xfree, cond[i]); cond_end = tok; cond_string[i] = savestring (cond_start, cond_end - cond_start); - make_cleanup (free, cond_string[i]); + make_cleanup (xfree, cond_string[i]); } else if (toklen >= 1 && strncmp (tok, "thread", toklen) == 0) { @@ -4497,18 +4833,18 @@ do_captured_breakpoint (void *data) old_chain = make_cleanup (null_cleanup, 0); /* Always have a addr_string array, even if it is empty. */ - make_cleanup (free, addr_string); + make_cleanup (xfree, addr_string); /* Make sure that all storage allocated to SALS gets freed. */ - make_cleanup (free, sals.sals); + make_cleanup (xfree, sals.sals); /* Allocate space for all the cond expressions. */ cond = xcalloc (sals.nelts, sizeof (struct expression *)); - make_cleanup (free, cond); + make_cleanup (xfree, cond); /* Allocate space for all the cond strings. */ cond_string = xcalloc (sals.nelts, sizeof (char **)); - make_cleanup (free, cond_string); + make_cleanup (xfree, cond_string); /* ----------------------------- SNIP ----------------------------- Anything added to the cleanup chain beyond this point is assumed @@ -4522,7 +4858,7 @@ do_captured_breakpoint (void *data) for (i = 0; i < sals.nelts; i++) { if (addr_string[i] != NULL) - make_cleanup (free, addr_string[i]); + make_cleanup (xfree, addr_string[i]); } /* Wait until now before checking for garbage at the end of the @@ -4544,7 +4880,7 @@ do_captured_breakpoint (void *data) cond[i] = parse_exp_1 (&tok, block_for_pc (sals.sals[i].pc), 0); if (*tok != '\0') error ("Garbage %s follows condition", tok); - make_cleanup (free, cond[i]); + make_cleanup (xfree, cond[i]); cond_string[i] = xstrdup (args->condition); } } @@ -4580,14 +4916,13 @@ gdb_breakpoint (char *address, char *condition, static void -break_at_finish_at_depth_command_1 (arg, flag, from_tty) - char *arg; - int flag; - int from_tty; +break_at_finish_at_depth_command_1 (char *arg, int flag, int from_tty) { struct frame_info *frame; CORE_ADDR low, high, selected_pc = 0; - char *extra_args, *level_arg, *addr_string; + char *extra_args = NULL; + char *level_arg; + char *addr_string; int extra_args_len = 0, if_arg = 0; if (!arg || @@ -4647,7 +4982,7 @@ break_at_finish_at_depth_command_1 (arg, flag, from_tty) else sprintf (addr_string, "*0x%s", paddr_nz (high)); break_command_1 (addr_string, flag, from_tty); - free (addr_string); + xfree (addr_string); } else error ("No function contains the specified address"); @@ -4658,17 +4993,14 @@ break_at_finish_at_depth_command_1 (arg, flag, from_tty) static void -break_at_finish_command_1 (arg, flag, from_tty) - char *arg; - int flag; - int from_tty; +break_at_finish_command_1 (char *arg, int flag, int from_tty) { char *addr_string, *break_string, *beg_addr_string; CORE_ADDR low, high; struct symtabs_and_lines sals; struct symtab_and_line sal; struct cleanup *old_chain; - char *extra_args; + char *extra_args = NULL; int extra_args_len = 0; int i, if_arg = 0; @@ -4719,8 +5051,8 @@ break_at_finish_command_1 (arg, flag, from_tty) sals = decode_line_1 (&addr_string, 1, (struct symtab *) NULL, 0, (char ***) NULL); - free (beg_addr_string); - old_chain = make_cleanup (free, sals.sals); + xfree (beg_addr_string); + old_chain = make_cleanup (xfree, sals.sals); for (i = 0; (i < sals.nelts); i++) { sal = sals.sals[i]; @@ -4732,7 +5064,7 @@ break_at_finish_command_1 (arg, flag, from_tty) else sprintf (break_string, "*0x%s", paddr_nz (high)); break_command_1 (break_string, flag, from_tty); - free (break_string); + xfree (break_string); } else error ("No function contains the specified address"); @@ -4749,8 +5081,7 @@ break_at_finish_command_1 (arg, flag, from_tty) /* Helper function for break_command_1 and disassemble_command. */ void -resolve_sal_pc (sal) - struct symtab_and_line *sal; +resolve_sal_pc (struct symtab_and_line *sal) { CORE_ADDR pc; @@ -4797,65 +5128,49 @@ resolve_sal_pc (sal) } void -break_command (arg, from_tty) - char *arg; - int from_tty; +break_command (char *arg, int from_tty) { break_command_1 (arg, 0, from_tty); } static void -break_at_finish_command (arg, from_tty) - char *arg; - int from_tty; +break_at_finish_command (char *arg, int from_tty) { break_at_finish_command_1 (arg, 0, from_tty); } static void -break_at_finish_at_depth_command (arg, from_tty) - char *arg; - int from_tty; +break_at_finish_at_depth_command (char *arg, int from_tty) { break_at_finish_at_depth_command_1 (arg, 0, from_tty); } void -tbreak_command (arg, from_tty) - char *arg; - int from_tty; +tbreak_command (char *arg, int from_tty) { break_command_1 (arg, BP_TEMPFLAG, from_tty); } static void -tbreak_at_finish_command (arg, from_tty) - char *arg; - int from_tty; +tbreak_at_finish_command (char *arg, int from_tty) { break_at_finish_command_1 (arg, BP_TEMPFLAG, from_tty); } static void -hbreak_command (arg, from_tty) - char *arg; - int from_tty; +hbreak_command (char *arg, int from_tty) { break_command_1 (arg, BP_HARDWAREFLAG, from_tty); } static void -thbreak_command (arg, from_tty) - char *arg; - int from_tty; +thbreak_command (char *arg, int from_tty) { break_command_1 (arg, (BP_TEMPFLAG | BP_HARDWAREFLAG), from_tty); } static void -stop_command (arg, from_tty) - char *arg; - int from_tty; +stop_command (char *arg, int from_tty) { printf_filtered ("Specify the type of breakpoint to set.\n\ Usage: stop in \n\ @@ -4863,9 +5178,7 @@ Usage: stop in \n\ } static void -stopin_command (arg, from_tty) - char *arg; - int from_tty; +stopin_command (char *arg, int from_tty) { int badInput = 0; @@ -4898,9 +5211,7 @@ stopin_command (arg, from_tty) } static void -stopat_command (arg, from_tty) - char *arg; - int from_tty; +stopat_command (char *arg, int from_tty) { int badInput = 0; @@ -4936,10 +5247,7 @@ stopat_command (arg, from_tty) hw_read: watch read, hw_access: watch access (read or write) */ static void -watch_command_1 (arg, accessflag, from_tty) - char *arg; - int accessflag; - int from_tty; +watch_command_1 (char *arg, int accessflag, int from_tty) { struct breakpoint *b; struct symtab_and_line sal; @@ -5022,7 +5330,7 @@ watch_command_1 (arg, accessflag, from_tty) startup sequence by the dynamic linker. However, I tried avoiding that by having HP-UX's implementation of - TARGET_CAN_USE_HW_WATCHPOINT return FALSE if there was no inferior_pid + TARGET_CAN_USE_HW_WATCHPOINT return FALSE if there was no inferior_ptid yet, which forced slow watches before a "run" or "attach", and it still fails somewhere in the startup code. @@ -5115,14 +5423,14 @@ watch_command_1 (arg, accessflag, from_tty) #if !defined(TARGET_REGION_OK_FOR_HW_WATCHPOINT) #define TARGET_REGION_OK_FOR_HW_WATCHPOINT(ADDR,LEN) \ - TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT(LEN) + (TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT(LEN)) #endif static int -can_use_hardware_watchpoint (v) - struct value *v; +can_use_hardware_watchpoint (struct value *v) { int found_memory_cnt = 0; + struct value *head = v; /* Did the user specifically forbid us to use hardware watchpoints? */ if (!can_use_hw_watchpoints) @@ -5160,13 +5468,23 @@ can_use_hardware_watchpoint (v) { /* Ahh, memory we actually used! Check if we can cover it with hardware watchpoints. */ - CORE_ADDR vaddr = VALUE_ADDRESS (v) + VALUE_OFFSET (v); - int len = TYPE_LENGTH (VALUE_TYPE (v)); + struct type *vtype = check_typedef (VALUE_TYPE (v)); + + /* We only watch structs and arrays if user asked for it + explicitly, never if they just happen to appear in a + middle of some value chain. */ + if (v == head + || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT + && TYPE_CODE (vtype) != TYPE_CODE_ARRAY)) + { + CORE_ADDR vaddr = VALUE_ADDRESS (v) + VALUE_OFFSET (v); + int len = TYPE_LENGTH (VALUE_TYPE (v)); - if (!TARGET_REGION_OK_FOR_HW_WATCHPOINT (vaddr, len)) - return 0; - else - found_memory_cnt++; + if (!TARGET_REGION_OK_FOR_HW_WATCHPOINT (vaddr, len)) + return 0; + else + found_memory_cnt++; + } } } else if (v->lval != not_lval && v->modifiable == 0) @@ -5180,26 +5498,41 @@ can_use_hardware_watchpoint (v) return found_memory_cnt; } +#ifdef UI_OUT +void +watch_command_wrapper (char *arg, int from_tty) +{ + watch_command (arg, from_tty); +} +#endif static void -watch_command (arg, from_tty) - char *arg; - int from_tty; +watch_command (char *arg, int from_tty) { watch_command_1 (arg, hw_write, from_tty); } +#ifdef UI_OUT +void +rwatch_command_wrapper (char *arg, int from_tty) +{ + rwatch_command (arg, from_tty); +} +#endif static void -rwatch_command (arg, from_tty) - char *arg; - int from_tty; +rwatch_command (char *arg, int from_tty) { watch_command_1 (arg, hw_read, from_tty); } +#ifdef UI_OUT +void +awatch_command_wrapper (char *arg, int from_tty) +{ + awatch_command (arg, from_tty); +} +#endif static void -awatch_command (arg, from_tty) - char *arg; - int from_tty; +awatch_command (char *arg, int from_tty) { watch_command_1 (arg, hw_access, from_tty); } @@ -5215,23 +5548,23 @@ awatch_command (arg, from_tty) static void until_break_command_continuation (struct continuation_arg *arg) { - /* Do all the exec cleanups, which at this point should only be the - one set up in the first part of the until_break_command - function. */ - do_exec_cleanups (ALL_CLEANUPS); + struct cleanup *cleanups; + + cleanups = (struct cleanup *) arg->data.pointer; + do_exec_cleanups (cleanups); } /* ARGSUSED */ void -until_break_command (arg, from_tty) - char *arg; - int from_tty; +until_break_command (char *arg, int from_tty) { struct symtabs_and_lines sals; struct symtab_and_line sal; struct frame_info *prev_frame = get_prev_frame (selected_frame); struct breakpoint *breakpoint; struct cleanup *old_chain; + struct continuation_arg *arg1; + clear_proceed_status (); @@ -5249,7 +5582,7 @@ until_break_command (arg, from_tty) error ("Couldn't get information on specified line."); sal = sals.sals[0]; - free ((PTR) sals.sals); /* malloc'd, so freed */ + xfree (sals.sals); /* malloc'd, so freed */ if (*arg) error ("Junk at end of arguments."); @@ -5259,10 +5592,9 @@ until_break_command (arg, from_tty) breakpoint = set_momentary_breakpoint (sal, selected_frame, bp_until); if (!event_loop_p || !target_can_async_p ()) - old_chain = make_cleanup ((make_cleanup_func) delete_breakpoint, - breakpoint); + old_chain = make_cleanup_delete_breakpoint (breakpoint); else - make_exec_cleanup ((make_cleanup_func) delete_breakpoint, breakpoint); + old_chain = make_exec_cleanup_delete_breakpoint (breakpoint); /* If we are running asynchronously, and the target supports async execution, we are not waiting for the target to stop, in the call @@ -5273,11 +5605,16 @@ until_break_command (arg, from_tty) if (event_loop_p && target_can_async_p ()) { - /* In this case we don't need args for the continuation, because - all it needs to do is do the cleanups in the - exec_cleanup_chain, which will be only those inserted by this - function. We can get away by using ALL_CLEANUPS. */ - add_continuation (until_break_command_continuation, NULL); + /* In this case the arg for the continuation is just the point + in the exec_cleanups chain from where to start doing + cleanups, because all the continuation does is the cleanups in + the exec_cleanup_chain. */ + arg1 = + (struct continuation_arg *) xmalloc (sizeof (struct continuation_arg)); + arg1->next = NULL; + arg1->data.pointer = old_chain; + + add_continuation (until_break_command_continuation, arg1); } /* Keep within the current frame */ @@ -5288,9 +5625,9 @@ until_break_command (arg, from_tty) sal.pc = prev_frame->pc; breakpoint = set_momentary_breakpoint (sal, prev_frame, bp_until); if (!event_loop_p || !target_can_async_p ()) - make_cleanup ((make_cleanup_func) delete_breakpoint, breakpoint); + make_cleanup_delete_breakpoint (breakpoint); else - make_exec_cleanup ((make_cleanup_func) delete_breakpoint, breakpoint); + make_exec_cleanup_delete_breakpoint (breakpoint); } proceed (-1, TARGET_SIGNAL_DEFAULT, 0); @@ -5304,23 +5641,22 @@ until_break_command (arg, from_tty) /* These aren't used; I don't konw what they were for. */ /* Set a breakpoint at the catch clause for NAME. */ static int -catch_breakpoint (name) - char *name; +catch_breakpoint (char *name) { } static int -disable_catch_breakpoint () +disable_catch_breakpoint (void) { } static int -delete_catch_breakpoint () +delete_catch_breakpoint (void) { } static int -enable_catch_breakpoint () +enable_catch_breakpoint (void) { } #endif /* 0 */ @@ -5340,9 +5676,7 @@ struct sal_chain /* For each catch clause identified in ARGS, run FUNCTION with that clause as an argument. */ static struct symtabs_and_lines -map_catch_names (args, function) - char *args; - int (*function) (); +map_catch_names (char *args, int (*function) ()) { register char *p = args; register char *p1; @@ -5401,8 +5735,7 @@ map_catch_names (args, function) /* This shares a lot of code with `print_frame_label_vars' from stack.c. */ static struct symtabs_and_lines -get_catch_sals (this_level_only) - int this_level_only; +get_catch_sals (int this_level_only) { register struct blockvector *bl; register struct block *block; @@ -5514,8 +5847,7 @@ get_catch_sals (this_level_only) } static void -ep_skip_leading_whitespace (s) - char **s; +ep_skip_leading_whitespace (char **s) { if ((s == NULL) || (*s == NULL)) return; @@ -5529,8 +5861,7 @@ ep_skip_leading_whitespace (s) the token is returned. Else, NULL is returned. */ static char * -ep_find_event_name_end (arg) - char *arg; +ep_find_event_name_end (char *arg) { char *s = arg; char *event_name_end = NULL; @@ -5563,8 +5894,7 @@ ep_find_event_name_end (arg) if clause in the arg string. */ static char * -ep_parse_optional_if_clause (arg) - char **arg; +ep_parse_optional_if_clause (char **arg) { char *cond_string; @@ -5596,8 +5926,7 @@ ep_parse_optional_if_clause (arg) Note that clients needing to preserve the returned filename for future access should copy it to their own buffers. */ static char * -ep_parse_optional_filename (arg) - char **arg; +ep_parse_optional_filename (char **arg) { static char filename[1024]; char *arg_p = *arg; @@ -5632,17 +5961,12 @@ typedef enum catch_fork_kind; #if defined(CHILD_INSERT_FORK_CATCHPOINT) || defined(CHILD_INSERT_VFORK_CATCHPOINT) -static void catch_fork_command_1 PARAMS ((catch_fork_kind fork_kind, - char *arg, - int tempflag, - int from_tty)); +static void catch_fork_command_1 (catch_fork_kind fork_kind, + char *arg, int tempflag, int from_tty); static void -catch_fork_command_1 (fork_kind, arg, tempflag, from_tty) - catch_fork_kind fork_kind; - char *arg; - int tempflag; - int from_tty; +catch_fork_command_1 (catch_fork_kind fork_kind, char *arg, int tempflag, + int from_tty) { char *cond_string = NULL; @@ -5677,10 +6001,7 @@ catch_fork_command_1 (fork_kind, arg, tempflag, from_tty) #if defined(CHILD_INSERT_EXEC_CATCHPOINT) static void -catch_exec_command_1 (arg, tempflag, from_tty) - char *arg; - int tempflag; - int from_tty; +catch_exec_command_1 (char *arg, int tempflag, int from_tty) { char *cond_string = NULL; @@ -5704,10 +6025,7 @@ catch_exec_command_1 (arg, tempflag, from_tty) #if defined(SOLIB_ADD) static void -catch_load_command_1 (arg, tempflag, from_tty) - char *arg; - int tempflag; - int from_tty; +catch_load_command_1 (char *arg, int tempflag, int from_tty) { char *dll_pathname = NULL; char *cond_string = NULL; @@ -5744,15 +6062,12 @@ catch_load_command_1 (arg, tempflag, from_tty) /* Create a load breakpoint that only triggers when a load of the specified dll (or any dll, if no pathname was specified) occurs. */ - SOLIB_CREATE_CATCH_LOAD_HOOK (inferior_pid, tempflag, + SOLIB_CREATE_CATCH_LOAD_HOOK (PIDGET (inferior_ptid), tempflag, dll_pathname, cond_string); } static void -catch_unload_command_1 (arg, tempflag, from_tty) - char *arg; - int tempflag; - int from_tty; +catch_unload_command_1 (char *arg, int tempflag, int from_tty) { char *dll_pathname = NULL; char *cond_string = NULL; @@ -5789,7 +6104,7 @@ catch_unload_command_1 (arg, tempflag, from_tty) /* Create an unload breakpoint that only triggers when an unload of the specified dll (or any dll, if no pathname was specified) occurs. */ - SOLIB_CREATE_CATCH_UNLOAD_HOOK (inferior_pid, tempflag, + SOLIB_CREATE_CATCH_UNLOAD_HOOK (PIDGET (inferior_ptid), tempflag, dll_pathname, cond_string); } #endif /* SOLIB_ADD */ @@ -5800,11 +6115,9 @@ catch_unload_command_1 (arg, tempflag, from_tty) exception event callback */ static void -create_exception_catchpoint (tempflag, cond_string, ex_event, sal) - int tempflag; - char *cond_string; - enum exception_event_kind ex_event; - struct symtab_and_line *sal; +create_exception_catchpoint (int tempflag, char *cond_string, + enum exception_event_kind ex_event, + struct symtab_and_line *sal) { struct breakpoint *b; int thread = -1; /* All threads. */ @@ -5841,11 +6154,8 @@ create_exception_catchpoint (tempflag, cond_string, ex_event, sal) /* Deal with "catch catch" and "catch throw" commands */ static void -catch_exception_command_1 (ex_event, arg, tempflag, from_tty) - enum exception_event_kind ex_event; - char *arg; - int tempflag; - int from_tty; +catch_exception_command_1 (enum exception_event_kind ex_event, char *arg, + int tempflag, int from_tty) { char *cond_string = NULL; struct symtab_and_line *sal = NULL; @@ -5896,8 +6206,7 @@ catch_exception_command_1 (ex_event, arg, tempflag, from_tty) inside a catch_errors */ static int -cover_target_enable_exception_callback (arg) - PTR arg; +cover_target_enable_exception_callback (PTR arg) { args_for_catchpoint_enable *args = arg; struct symtab_and_line *sal; @@ -5925,10 +6234,7 @@ cover_target_enable_exception_callback (arg) static void -handle_gnu_4_16_catch_command (arg, tempflag, from_tty) - char *arg; - int tempflag; - int from_tty; +handle_gnu_4_16_catch_command (char *arg, int tempflag, int from_tty) { /* First, translate ARG into something we can deal with in terms of breakpoints. */ @@ -6017,15 +6323,14 @@ handle_gnu_4_16_catch_command (arg, tempflag, from_tty) warning ("Multiple breakpoints were set."); warning ("Use the \"delete\" command to delete unwanted breakpoints."); } - free ((PTR) sals.sals); + xfree (sals.sals); } #if 0 /* This creates a temporary internal breakpoint just to placate infrun */ static struct breakpoint * -create_temp_exception_breakpoint (pc) - CORE_ADDR pc; +create_temp_exception_breakpoint (CORE_ADDR pc) { struct symtab_and_line sal; struct breakpoint *b; @@ -6049,10 +6354,7 @@ create_temp_exception_breakpoint (pc) #endif static void -catch_command_1 (arg, tempflag, from_tty) - char *arg; - int tempflag; - int from_tty; +catch_command_1 (char *arg, int tempflag, int from_tty) { /* The first argument may be an event name, such as "start" or "load". @@ -6175,8 +6477,7 @@ catch_command_1 (arg, tempflag, from_tty) /* Used by the gui, could be made a worker for other things. */ struct breakpoint * -set_breakpoint_sal (sal) - struct symtab_and_line sal; +set_breakpoint_sal (struct symtab_and_line sal) { struct breakpoint *b; b = set_raw_breakpoint (sal); @@ -6192,51 +6493,42 @@ set_breakpoint_sal (sal) /* These aren't used; I don't know what they were for. */ /* Disable breakpoints on all catch clauses described in ARGS. */ static void -disable_catch (args) - char *args; +disable_catch (char *args) { /* Map the disable command to catch clauses described in ARGS. */ } /* Enable breakpoints on all catch clauses described in ARGS. */ static void -enable_catch (args) - char *args; +enable_catch (char *args) { /* Map the disable command to catch clauses described in ARGS. */ } /* Delete breakpoints on all catch clauses in the active scope. */ static void -delete_catch (args) - char *args; +delete_catch (char *args) { /* Map the delete command to catch clauses described in ARGS. */ } #endif /* 0 */ static void -catch_command (arg, from_tty) - char *arg; - int from_tty; +catch_command (char *arg, int from_tty) { catch_command_1 (arg, 0, from_tty); } static void -tcatch_command (arg, from_tty) - char *arg; - int from_tty; +tcatch_command (char *arg, int from_tty) { catch_command_1 (arg, 1, from_tty); } static void -clear_command (arg, from_tty) - char *arg; - int from_tty; +clear_command (char *arg, int from_tty) { register struct breakpoint *b, *b1; int default_match; @@ -6366,7 +6658,7 @@ clear_command (arg, from_tty) if (from_tty) putchar_unfiltered ('\n'); } - free ((PTR) sals.sals); + xfree (sals.sals); } /* Delete breakpoint in BS if they are `delete' breakpoints and @@ -6374,8 +6666,7 @@ clear_command (arg, from_tty) This is called after any breakpoint is hit, or after errors. */ void -breakpoint_auto_delete (bs) - bpstat bs; +breakpoint_auto_delete (bpstat bs) { struct breakpoint *b, *temp; @@ -6395,8 +6686,7 @@ breakpoint_auto_delete (bs) structures. */ void -delete_breakpoint (bpt) - struct breakpoint *bpt; +delete_breakpoint (struct breakpoint *bpt) { register struct breakpoint *b; register bpstat bs; @@ -6506,7 +6796,8 @@ delete_breakpoint (bpt) If there is a permanent breakpoint somewhere, it should always be the only one inserted. */ if (b->enable == permanent) - internal_error ("another breakpoint was inserted on top of " + internal_error (__FILE__, __LINE__, + "another breakpoint was inserted on top of " "a permanent breakpoint"); if (b->type == bp_hardware_breakpoint) @@ -6527,25 +6818,25 @@ delete_breakpoint (bpt) free_command_lines (&bpt->commands); if (bpt->cond) - free (bpt->cond); + xfree (bpt->cond); if (bpt->cond_string != NULL) - free (bpt->cond_string); + xfree (bpt->cond_string); if (bpt->addr_string != NULL) - free (bpt->addr_string); + xfree (bpt->addr_string); if (bpt->exp != NULL) - free (bpt->exp); + xfree (bpt->exp); if (bpt->exp_string != NULL) - free (bpt->exp_string); + xfree (bpt->exp_string); if (bpt->val != NULL) value_free (bpt->val); if (bpt->source_file != NULL) - free (bpt->source_file); + xfree (bpt->source_file); if (bpt->dll_pathname != NULL) - free (bpt->dll_pathname); + xfree (bpt->dll_pathname); if (bpt->triggered_dll_pathname != NULL) - free (bpt->triggered_dll_pathname); + xfree (bpt->triggered_dll_pathname); if (bpt->exec_pathname != NULL) - free (bpt->exec_pathname); + xfree (bpt->exec_pathname); /* Be sure no bpstat's are pointing at it after it's been freed. */ /* FIXME, how can we find all bpstat's? @@ -6567,13 +6858,29 @@ delete_breakpoint (bpt) bp, we mark it as deleted before freeing its storage. */ bpt->type = bp_none; - free ((PTR) bpt); + xfree (bpt); +} + +static void +do_delete_breakpoint_cleanup (void *b) +{ + delete_breakpoint (b); +} + +struct cleanup * +make_cleanup_delete_breakpoint (struct breakpoint *b) +{ + return make_cleanup (do_delete_breakpoint_cleanup, b); +} + +struct cleanup * +make_exec_cleanup_delete_breakpoint (struct breakpoint *b) +{ + return make_exec_cleanup (do_delete_breakpoint_cleanup, b); } void -delete_command (arg, from_tty) - char *arg; - int from_tty; +delete_command (char *arg, int from_tty) { struct breakpoint *b, *temp; @@ -6616,8 +6923,7 @@ delete_command (arg, from_tty) Unused in this case. */ static int -breakpoint_re_set_one (bint) - PTR bint; +breakpoint_re_set_one (PTR bint) { /* get past catch_errs */ struct breakpoint *b = (struct breakpoint *) bint; @@ -6662,7 +6968,7 @@ breakpoint_re_set_one (bint) { s = b->cond_string; if (b->cond) - free ((PTR) b->cond); + xfree (b->cond); b->cond = parse_exp_1 (&s, block_for_pc (sals.sals[i].pc), 0); } @@ -6681,7 +6987,7 @@ breakpoint_re_set_one (bint) ) { if (b->source_file != NULL) - free (b->source_file); + xfree (b->source_file); if (sals.sals[i].symtab == NULL) b->source_file = NULL; else @@ -6710,7 +7016,7 @@ breakpoint_re_set_one (bint) check_duplicates (b->address, b->section); } - free ((PTR) sals.sals); + xfree (sals.sals); break; case bp_watchpoint: @@ -6728,7 +7034,7 @@ breakpoint_re_set_one (bint) /* So for now, just use a global context. */ if (b->exp) - free ((PTR) b->exp); + xfree (b->exp); b->exp = parse_expression (b->exp_string); b->exp_valid_block = innermost_block; mark = value_mark (); @@ -6743,7 +7049,7 @@ breakpoint_re_set_one (bint) { s = b->cond_string; if (b->cond) - free ((PTR) b->cond); + xfree (b->cond); b->cond = parse_exp_1 (&s, (struct block *) 0, 0); } if (b->enable == enabled) @@ -6796,7 +7102,7 @@ breakpoint_re_set_one (bint) /* Re-set all breakpoints after symbols have been re-loaded. */ void -breakpoint_re_set () +breakpoint_re_set (void) { struct breakpoint *b, *temp; enum language save_language; @@ -6838,21 +7144,19 @@ breakpoint_re_set () /* Reset the thread number of this breakpoint: - If the breakpoint is for all threads, leave it as-is. - - Else, reset it to the current thread for inferior_pid. */ + - Else, reset it to the current thread for inferior_ptid. */ void -breakpoint_re_set_thread (b) - struct breakpoint *b; +breakpoint_re_set_thread (struct breakpoint *b) { if (b->thread != -1) { - if (in_thread_list (inferior_pid)) - b->thread = pid_to_thread_id (inferior_pid); + if (in_thread_list (inferior_ptid)) + b->thread = pid_to_thread_id (inferior_ptid); } } void -set_ignore_count (bptnum, count, from_tty) - int bptnum, count, from_tty; +set_ignore_count (int bptnum, int count, int from_tty) { register struct breakpoint *b; @@ -6883,7 +7187,7 @@ set_ignore_count (bptnum, count, from_tty) /* Clear the ignore counts of all breakpoints. */ void -breakpoint_clear_ignore_counts () +breakpoint_clear_ignore_counts (void) { struct breakpoint *b; @@ -6894,9 +7198,7 @@ breakpoint_clear_ignore_counts () /* Command to set ignore-count of breakpoint N to COUNT. */ static void -ignore_command (args, from_tty) - char *args; - int from_tty; +ignore_command (char *args, int from_tty) { char *p = args; register int num; @@ -6921,9 +7223,7 @@ ignore_command (args, from_tty) whose numbers are given in ARGS. */ static void -map_breakpoint_numbers (args, function) - char *args; - void (*function) PARAMS ((struct breakpoint *)); +map_breakpoint_numbers (char *args, void (*function) (struct breakpoint *)) { register char *p = args; char *p1; @@ -6964,8 +7264,7 @@ map_breakpoint_numbers (args, function) } void -disable_breakpoint (bpt) - struct breakpoint *bpt; +disable_breakpoint (struct breakpoint *bpt) { /* Never disable a watchpoint scope breakpoint; we want to hit them when we leave scope so we can delete both the @@ -6988,9 +7287,7 @@ disable_breakpoint (bpt) /* ARGSUSED */ static void -disable_command (args, from_tty) - char *args; - int from_tty; +disable_command (char *args, int from_tty) { register struct breakpoint *bpt; if (args == 0) @@ -7023,9 +7320,7 @@ disable_command (args, from_tty) } static void -do_enable_breakpoint (bpt, disposition) - struct breakpoint *bpt; - enum bpdisp disposition; +do_enable_breakpoint (struct breakpoint *bpt, enum bpdisp disposition) { struct frame_info *save_selected_frame = NULL; int save_selected_frame_level = -1; @@ -7111,8 +7406,7 @@ have been allocated for other watchpoints.\n", bpt->number); } if (save_selected_frame_level >= 0) - select_and_print_frame (save_selected_frame, - save_selected_frame_level); + select_frame (save_selected_frame, save_selected_frame_level); value_free_to_mark (mark); } if (modify_breakpoint_hook) @@ -7121,8 +7415,7 @@ have been allocated for other watchpoints.\n", bpt->number); } void -enable_breakpoint (bpt) - struct breakpoint *bpt; +enable_breakpoint (struct breakpoint *bpt) { do_enable_breakpoint (bpt, bpt->disposition); } @@ -7133,9 +7426,7 @@ enable_breakpoint (bpt) /* ARGSUSED */ static void -enable_command (args, from_tty) - char *args; - int from_tty; +enable_command (char *args, int from_tty) { register struct breakpoint *bpt; if (args == 0) @@ -7168,33 +7459,27 @@ enable_command (args, from_tty) } static void -enable_once_breakpoint (bpt) - struct breakpoint *bpt; +enable_once_breakpoint (struct breakpoint *bpt) { do_enable_breakpoint (bpt, disable); } /* ARGSUSED */ static void -enable_once_command (args, from_tty) - char *args; - int from_tty; +enable_once_command (char *args, int from_tty) { map_breakpoint_numbers (args, enable_once_breakpoint); } static void -enable_delete_breakpoint (bpt) - struct breakpoint *bpt; +enable_delete_breakpoint (struct breakpoint *bpt) { do_enable_breakpoint (bpt, del); } /* ARGSUSED */ static void -enable_delete_command (args, from_tty) - char *args; - int from_tty; +enable_delete_command (char *args, int from_tty) { map_breakpoint_numbers (args, enable_delete_breakpoint); } @@ -7202,9 +7487,7 @@ enable_delete_command (args, from_tty) /* Use default_breakpoint_'s, or nothing if they aren't valid. */ struct symtabs_and_lines -decode_line_spec_1 (string, funfirstline) - char *string; - int funfirstline; +decode_line_spec_1 (char *string, int funfirstline) { struct symtabs_and_lines sals; if (string == 0) @@ -7223,7 +7506,7 @@ decode_line_spec_1 (string, funfirstline) } void -_initialize_breakpoint () +_initialize_breakpoint (void) { struct cmd_list_element *c;