From 0cf6dd1543299e30c82397ef49d00b32af911a63 Mon Sep 17 00:00:00 2001 From: Thiago Jung Bauermann Date: Wed, 7 Jul 2010 16:15:18 +0000 Subject: 2010-07-07 Sergio Durigan Junior Thiago Jung Bauermann Support for hw accelerated condition watchpoints in booke powerpc. * breakpoint.c (fetch_watchpoint_value): Rename to fetch_subexp_value and move to eval.c. Change callers. (insert_bp_location): Pass watchpoint condition in target_insert_watchpoint. (remove_breakpoint_1) Pass watchpoint condition in target_remove_watchpoint. (watchpoint_locations_match): Call target_can_accel_watchpoint_condition. * eval.c: Include wrapper.h. (fetch_subexp_value): Moved from breakpoint.c. * ppc-linux-nat.c (ppc_linux_region_ok_for_hw_watchpoint): Formatting fix. (can_use_watchpoint_cond_accel): New function. (calculate_dvc): Likewise. (num_memory_accesses): Likewise. (check_condition): Likewise. (ppc_linux_can_accel_watchpoint_condition): Likewise (ppc_linux_insert_watchpoint): Call can_use_watchpoint_cond_accel, check_condition and calculate_dvc. (ppc_linux_remove_watchpoint): Likewise. (_initialize_ppc_linux_nat): Set to_can_accel_watchpoint_condition to ppc_linux_can_accel_watchpoint_condition * target.c (debug_to_insert_watchpoint): Add argument for watchpoint condition. (debug_to_remove_watchpoint): Likewise. (debug_to_can_accel_watchpoint_condition): New function. (update_current_target): Set to_can_accel_watchpoint_condition. (setup_target_debug): Set to_can_accel_watchpoint_condition. * target.h: Add opaque declaration for struct expression. (struct target_ops) , : Add new arguments to pass the watchpoint : New member. condition. Update all callers and implementations. (target_can_accel_watchpoint_condition): New macro. * value.c (free_value_chain): New function. * value.h (fetch_subexp_value): New prototype. (free_value_chain): Likewise. --- gdb/target.h | 34 ++++++++++++++++++++++++++++------ 1 file changed, 28 insertions(+), 6 deletions(-) (limited to 'gdb/target.h') diff --git a/gdb/target.h b/gdb/target.h index 3c8a616..3c8c017 100644 --- a/gdb/target.h +++ b/gdb/target.h @@ -37,6 +37,8 @@ struct uploaded_tsv; struct uploaded_tp; struct static_tracepoint_marker; +struct expression; + /* This include file defines the interface between the main part of the debugger, and the part which is target-specific, or specific to the communications interface between us and the @@ -426,8 +428,12 @@ struct target_ops int (*to_can_use_hw_breakpoint) (int, int, int); int (*to_insert_hw_breakpoint) (struct gdbarch *, struct bp_target_info *); int (*to_remove_hw_breakpoint) (struct gdbarch *, struct bp_target_info *); - int (*to_remove_watchpoint) (CORE_ADDR, int, int); - int (*to_insert_watchpoint) (CORE_ADDR, int, int); + + /* Documentation of what the two routines below are expected to do is + provided with the corresponding target_* macros. */ + int (*to_remove_watchpoint) (CORE_ADDR, int, int, struct expression *); + int (*to_insert_watchpoint) (CORE_ADDR, int, int, struct expression *); + int (*to_stopped_by_watchpoint) (void); int to_have_steppable_watchpoint; int to_have_continuable_watchpoint; @@ -435,6 +441,8 @@ struct target_ops int (*to_watchpoint_addr_within_range) (struct target_ops *, CORE_ADDR, CORE_ADDR, int); int (*to_region_ok_for_hw_watchpoint) (CORE_ADDR, int); + int (*to_can_accel_watchpoint_condition) (CORE_ADDR, int, int, + struct expression *); void (*to_terminal_init) (void); void (*to_terminal_inferior) (void); void (*to_terminal_ours_for_output) (void); @@ -1298,14 +1306,15 @@ extern char *normal_pid_to_str (ptid_t ptid); /* Set/clear a hardware watchpoint starting at ADDR, for LEN bytes. TYPE is 0 for write, 1 for read, and 2 for read/write accesses. + COND is the expression for its condition, or NULL if there's none. Returns 0 for success, 1 if the watchpoint type is not supported, -1 for failure. */ -#define target_insert_watchpoint(addr, len, type) \ - (*current_target.to_insert_watchpoint) (addr, len, type) +#define target_insert_watchpoint(addr, len, type, cond) \ + (*current_target.to_insert_watchpoint) (addr, len, type, cond) -#define target_remove_watchpoint(addr, len, type) \ - (*current_target.to_remove_watchpoint) (addr, len, type) +#define target_remove_watchpoint(addr, len, type, cond) \ + (*current_target.to_remove_watchpoint) (addr, len, type, cond) #define target_insert_hw_breakpoint(gdbarch, bp_tgt) \ (*current_target.to_insert_hw_breakpoint) (gdbarch, bp_tgt) @@ -1322,6 +1331,19 @@ extern char *normal_pid_to_str (ptid_t ptid); #define target_watchpoint_addr_within_range(target, addr, start, length) \ (*target.to_watchpoint_addr_within_range) (target, addr, start, length) +/* Return non-zero if the target is capable of using hardware to evaluate + the condition expression. In this case, if the condition is false when + the watched memory location changes, execution may continue without the + debugger being notified. + + Due to limitations in the hardware implementation, it may be capable of + avoiding triggering the watchpoint in some cases where the condition + expression is false, but may report some false positives as well. + For this reason, GDB will still evaluate the condition expression when + the watchpoint triggers. */ +#define target_can_accel_watchpoint_condition(addr, len, type, cond) \ + (*current_target.to_can_accel_watchpoint_condition) (addr, len, type, cond) + /* Target can execute in reverse? */ #define target_can_execute_reverse \ (current_target.to_can_execute_reverse ? \ -- cgit v1.1