+2011-01-11 Sergio Durigan Junior <sergiodj@linux.vnet.ibm.com>
+ Thiago Jung Bauermann <bauerman@br.ibm.com>
+
+ Implement support for PowerPC BookE ranged watchpoints.
+ * breakpoint.h
+ (struct breakpoint_ops) <resources_needed>: New method.
+ Initialize to NULL in all existing breakpoint_ops instances.
+ (struct breakpoint) <exact>: New field.
+ (target_exact_watchpoints): Declare external global.
+ * breakpoint.c (target_exact_watchpoints): New global flag.
+ (update_watchpoint): Set b->type to bp_hardware_watchpoint and
+ b->enable_state to bp_enabled before calling
+ hw_watchpoint_used_count.
+ (hw_watchpoint_used_count): Iterate over all bp_locations in a
+ watchpoint. Call breakpoint's breakpoint_ops.resources_needed
+ if available.
+ (insert_watchpoint, remove_watchpoint): Use fixed length of 1 byte
+ if the watchpoint is exact.
+ (resources_needed_watchpoint): New function.
+ (watchpoint_breakpoint_ops): Add resources_needed_watchpoint.
+ (watch_command_1): Set b->exact if the user asked for an exact
+ watchpoint and one can be set.
+ (can_use_hardware_watchpoint): Add exact_watchpoints argument.
+ Pass fixed length of 1 to target_region_ok_for_hw_watchpoint if
+ the user asks for an exact watchpoint and one can be set. Return
+ number of needed debug registers to watch the expression.
+ * gdbtypes.c (is_scalar_type): New function, based on
+ valprint.c:scalar_type_p.
+ (is_scalar_type_recursive): New function.
+ * gdbtypes.h (is_scalar_type_recursive): Declare.
+ * ppc-linux-nat.c (ppc_linux_region_ok_for_hw_watchpoint): Always
+ handle regions when ranged watchpoints are available.
+ (create_watchpoint_request): New function.
+ (ppc_linux_insert_watchpoint, ppc_linux_remove_watchpoint): Use
+ create_watchpoint_request.
+ * rs6000-tdep.c (show_powerpc_exact_watchpoints): New function.
+ (_initialize_rs6000_tdep): Add `exact-watchpoints' boolean to the
+ `set powerpc' and `show powerpc' commands.
+ * target.h (struct target_ops) <to_region_ok_for_hw_watchpoint>:
+ Mention documentation comment in the target macro.
+ (target_region_ok_for_hw_watchpoint): Document return value.
+
2011-01-11 Thiago Jung Bauermann <bauerman@br.ibm.com>
* breakpoint.c (update_watchpoint): Decide on using a software or
NULL, /* insert */
NULL, /* remove */
NULL, /* breakpoint_hit */
+ NULL, /* resources_needed */
print_it_catch_exception,
print_one_catch_exception,
print_mention_catch_exception,
NULL, /* insert */
NULL, /* remove */
NULL, /* breakpoint_hit */
+ NULL, /* resources_needed */
print_it_catch_exception_unhandled,
print_one_catch_exception_unhandled,
print_mention_catch_exception_unhandled,
NULL, /* insert */
NULL, /* remove */
NULL, /* breakpoint_hit */
+ NULL, /* resources_needed */
print_it_catch_assert,
print_one_catch_assert,
print_mention_catch_assert,
static void catch_command (char *, int);
-static int can_use_hardware_watchpoint (struct value *);
+static int can_use_hardware_watchpoint (struct value *, int);
static void break_command_1 (char *, int, int);
/* Are overlay event breakpoints enabled? */
static int overlay_events_enabled;
+/* See description in breakpoint.h. */
+int target_exact_watchpoints = 0;
+
/* Walk the following statement or block through all breakpoints.
ALL_BREAKPOINTS_SAFE does so even if the statment deletes the
current breakpoint. */
if ((b->type == bp_watchpoint || b->type == bp_hardware_watchpoint)
&& reparse)
{
- int mem_cnt;
+ int reg_cnt;
enum bp_loc_type loc_type;
struct bp_location *bl;
- mem_cnt = can_use_hardware_watchpoint (val_chain);
- if (mem_cnt)
+ reg_cnt = can_use_hardware_watchpoint (val_chain, b->exact);
+
+ if (reg_cnt)
{
int i, target_resources_ok, other_type_used;
+ enum enable_state orig_enable_state;
/* We need to determine how many resources are already
- used for all other hardware watchpoints to see if we
- still have enough resources to also fit this watchpoint
- in as well. To avoid the hw_watchpoint_used_count call
- below from counting this watchpoint, make sure that it
- is marked as a software watchpoint. */
- b->type = bp_watchpoint;
+ used for all other hardware watchpoints plus this one
+ to see if we still have enough resources to also fit
+ this watchpoint in as well. To guarantee the
+ hw_watchpoint_used_count call below counts this
+ watchpoint, make sure that it is marked as a hardware
+ watchpoint. */
+ b->type = bp_hardware_watchpoint;
+
+ /* hw_watchpoint_used_count ignores disabled watchpoints,
+ and b might be disabled if we're being called from
+ do_enable_breakpoint. */
+ orig_enable_state = b->enable_state;
+ b->enable_state = bp_enabled;
+
i = hw_watchpoint_used_count (bp_hardware_watchpoint,
&other_type_used);
- target_resources_ok = target_can_use_hardware_watchpoint
- (bp_hardware_watchpoint, i + mem_cnt, other_type_used);
- if (target_resources_ok > 0)
- b->type = bp_hardware_watchpoint;
+ b->enable_state = orig_enable_state;
+
+ target_resources_ok = target_can_use_hardware_watchpoint
+ (bp_hardware_watchpoint, i, other_type_used);
+ if (target_resources_ok <= 0)
+ b->type = bp_watchpoint;
}
else
b->type = bp_watchpoint;
insert_catch_fork,
remove_catch_fork,
breakpoint_hit_catch_fork,
+ NULL, /* resources_needed */
print_it_catch_fork,
print_one_catch_fork,
print_mention_catch_fork,
insert_catch_vfork,
remove_catch_vfork,
breakpoint_hit_catch_vfork,
+ NULL, /* resources_needed */
print_it_catch_vfork,
print_one_catch_vfork,
print_mention_catch_vfork,
insert_catch_syscall,
remove_catch_syscall,
breakpoint_hit_catch_syscall,
+ NULL, /* resources_needed */
print_it_catch_syscall,
print_one_catch_syscall,
print_mention_catch_syscall,
insert_catch_exec,
remove_catch_exec,
breakpoint_hit_catch_exec,
+ NULL, /* resources_needed */
print_it_catch_exec,
print_one_catch_exec,
print_mention_catch_exec,
static int
hw_watchpoint_used_count (enum bptype type, int *other_type_used)
{
- struct breakpoint *b;
int i = 0;
+ struct breakpoint *b;
+ struct bp_location *bl;
*other_type_used = 0;
ALL_BREAKPOINTS (b)
- {
- if (breakpoint_enabled (b))
- {
+ {
+ if (!breakpoint_enabled (b))
+ continue;
+
if (b->type == type)
- i++;
+ for (bl = b->loc; bl; bl = bl->next)
+ {
+ /* Special types of hardware watchpoints may use more than
+ one register. */
+ if (b->ops && b->ops->resources_needed)
+ i += b->ops->resources_needed (bl);
+ else
+ i++;
+ }
else if (is_hardware_watchpoint (b))
*other_type_used = 1;
- }
- }
+ }
+
return i;
}
static int
insert_watchpoint (struct bp_location *bl)
{
- return target_insert_watchpoint (bl->address, bl->length,
- bl->watchpoint_type, bl->owner->cond_exp);
+ int length = bl->owner->exact? 1 : bl->length;
+
+ return target_insert_watchpoint (bl->address, length, bl->watchpoint_type,
+ bl->owner->cond_exp);
}
/* Implement the "remove" breakpoint_ops method for hardware watchpoints. */
static int
remove_watchpoint (struct bp_location *bl)
{
- return target_remove_watchpoint (bl->address, bl->length,
- bl->watchpoint_type, bl->owner->cond_exp);
+ int length = bl->owner->exact? 1 : bl->length;
+
+ return target_remove_watchpoint (bl->address, length, bl->watchpoint_type,
+ bl->owner->cond_exp);
+}
+
+/* Implement the "resources_needed" breakpoint_ops method for
+ hardware watchpoints. */
+
+static int
+resources_needed_watchpoint (const struct bp_location *bl)
+{
+ int length = bl->owner->exact? 1 : bl->length;
+
+ return target_region_ok_for_hw_watchpoint (bl->address, length);
}
/* The breakpoint_ops structure to be used in hardware watchpoints. */
insert_watchpoint,
remove_watchpoint,
NULL, /* breakpoint_hit */
+ resources_needed_watchpoint,
NULL, /* print_it */
NULL, /* print_one */
NULL, /* print_mention */
char *cond_end = NULL;
int i, other_type_used, target_resources_ok = 0;
enum bptype bp_type;
- int mem_cnt = 0;
+ int reg_cnt = 0;
int thread = -1;
int pc = 0;
else
bp_type = bp_hardware_watchpoint;
- mem_cnt = can_use_hardware_watchpoint (val);
- if (mem_cnt == 0 && bp_type != bp_hardware_watchpoint)
+ reg_cnt = can_use_hardware_watchpoint (val, target_exact_watchpoints);
+ if (reg_cnt == 0 && bp_type != bp_hardware_watchpoint)
error (_("Expression cannot be implemented with read/access watchpoint."));
- if (mem_cnt != 0)
+ if (reg_cnt != 0)
{
i = hw_watchpoint_used_count (bp_type, &other_type_used);
target_resources_ok =
- target_can_use_hardware_watchpoint (bp_type, i + mem_cnt,
+ target_can_use_hardware_watchpoint (bp_type, i + reg_cnt,
other_type_used);
if (target_resources_ok == 0 && bp_type != bp_hardware_watchpoint)
error (_("Target does not support this type of hardware watchpoint."));
/* Change the type of breakpoint to an ordinary watchpoint if a
hardware watchpoint could not be set. */
- if (!mem_cnt || target_resources_ok <= 0)
+ if (!reg_cnt || target_resources_ok <= 0)
bp_type = bp_watchpoint;
frame = block_innermost_frame (exp_valid_block);
b->val_valid = 1;
b->ops = &watchpoint_breakpoint_ops;
+ /* Use an exact watchpoint when there's only one memory region to be
+ watched, and only one debug register is needed to watch it. */
+ b->exact = target_exact_watchpoints && reg_cnt == 1;
+
if (cond_start)
b->cond_string = savestring (cond_start, cond_end - cond_start);
else
update_global_location_list (1);
}
-/* Return count of locations need to be watched and can be handled in
- hardware. If the watchpoint can not be handled in hardware return
- zero. */
+/* Return count of debug registers needed to watch the given expression.
+ If EXACT_WATCHPOINTS is 1, then consider that only the address of
+ the start of the watched region will be monitored (i.e., all accesses
+ will be aligned). This uses less debug registers on some targets.
+
+ If the watchpoint cannot be handled in hardware return zero. */
static int
-can_use_hardware_watchpoint (struct value *v)
+can_use_hardware_watchpoint (struct value *v, int exact_watchpoints)
{
int found_memory_cnt = 0;
struct value *head = v;
&& TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
{
CORE_ADDR vaddr = value_address (v);
- int len = TYPE_LENGTH (value_type (v));
+ int len;
+ int num_regs;
+
+ len = (exact_watchpoints
+ && is_scalar_type_recursive (vtype))?
+ 1 : TYPE_LENGTH (value_type (v));
- if (!target_region_ok_for_hw_watchpoint (vaddr, len))
+ num_regs = target_region_ok_for_hw_watchpoint (vaddr, len);
+ if (!num_regs)
return 0;
else
- found_memory_cnt++;
+ found_memory_cnt += num_regs;
}
}
}
NULL, /* insert */
NULL, /* remove */
NULL, /* breakpoint_hit */
+ NULL, /* resources_needed */
print_exception_catchpoint,
print_one_exception_catchpoint,
print_mention_exception_catchpoint,
breakpoint was hit. */
int (*breakpoint_hit) (struct breakpoint *);
+ /* Tell how many hardware resources (debug registers) are needed
+ for this breakpoint. If this function is not provided, then
+ the breakpoint or watchpoint needs one debug register. */
+ int (*resources_needed) (const struct bp_location *);
+
/* The normal print routine for this breakpoint, called when we
hit it. */
enum print_stop_action (*print_it) (struct breakpoint *);
detail to the breakpoints module. */
struct counted_command_line;
+/* Some targets (e.g., embedded PowerPC) need two debug registers to set
+ a watchpoint over a memory region. If this flag is true, GDB will use
+ only one register per watchpoint, thus assuming that all acesses that
+ modify a memory location happen at its starting address. */
+
+extern int target_exact_watchpoints;
+
/* Note that the ->silent field is not currently used by any commands
(though the code is in there if it was to be, and set_raw_breakpoint
does set it to 0). I implemented it because I thought it would be
can sometimes be NULL for enabled GDBs as not all breakpoint
types are tracked by the Python scripting API. */
struct breakpoint_object *py_bp_object;
-};
+
+ /* Whether this watchpoint is exact (see target_exact_watchpoints). */
+ int exact;
+ };
typedef struct breakpoint *breakpoint_p;
DEF_VEC_P(breakpoint_p);
+2011-01-11 Sergio Durigan Junior <sergiodj@linux.vnet.ibm.com>
+ Thiago Jung Bauermann <bauerman@br.ibm.com>
+
+ Implement support for PowerPC BookE ranged watchpoints.
+ * gdb.texinfo (PowerPC Embedded): Document ranged watchpoints and
+ the "set powerpc exact-watchpoints" flag.
+
2011-01-07 Tom Tromey <tromey@redhat.com>
* gdb.texinfo (Python API): Add descriptions to @menu items.
2010-01-06 Paul Pluzhnikov <ppluzhnikov@google.com>
- * gdb.texinfo (Debugging Output): Document "set debug jit".
+ * gdb.texinfo (Debugging Output): Document "set debug jit".
2011-01-06 Tom Tromey <tromey@redhat.com>
if @var{ADDRESS|VARIABLE} == @var{CONSTANT EXPRESSION}
@end smallexample
-The DVC register will be automatically used whenever @value{GDBN} detects
-such pattern in a condition expression. This feature is available in native
-@value{GDBN} running on a Linux kernel version 2.6.34 or newer.
+The DVC register will be automatically used when @value{GDBN} detects
+such pattern in a condition expression, and the created watchpoint uses one
+debug register (either the @code{exact-watchpoints} option is on and the
+variable is scalar, or the variable has a length of one byte). This feature
+is available in native @value{GDBN} running on a Linux kernel version 2.6.34
+or newer.
+
+When running on PowerPC embedded processors, @value{GDBN} automatically uses
+ranged hardware watchpoints, unless the @code{exact-watchpoints} option is on,
+in which case watchpoints using only one debug register are created when
+watching variables of scalar types.
+
+You can create an artificial array to watch an arbitrary memory
+region using one of the following commands (@pxref{Expressions}):
+
+@smallexample
+(@value{GDBP}) watch *((char *) @var{address})@@@var{length}
+(@value{GDBP}) watch @{char[@var{length}]@} @var{address}
+@end smallexample
@value{GDBN} provides the following PowerPC-specific commands:
registers. By default, @value{GDBN} selects the calling convention
based on the selected architecture and the provided executable file.
+@item set powerpc exact-watchpoints
+@itemx show powerpc exact-watchpoints
+Allow @value{GDBN} to use only one debug register when watching a variable
+of scalar type, thus assuming that the variable is accessed through the
+address of its first byte.
+
@kindex target dink32
@item target dink32 @var{dev}
DINK32 ROM monitor.
|| (TYPE_CODE (t) == TYPE_CODE_BOOL)));
}
+/* Return true if TYPE is scalar. */
+
+static int
+is_scalar_type (struct type *type)
+{
+ CHECK_TYPEDEF (type);
+
+ switch (TYPE_CODE (type))
+ {
+ case TYPE_CODE_ARRAY:
+ case TYPE_CODE_STRUCT:
+ case TYPE_CODE_UNION:
+ case TYPE_CODE_SET:
+ case TYPE_CODE_STRING:
+ case TYPE_CODE_BITSTRING:
+ return 0;
+ default:
+ return 1;
+ }
+}
+
+/* Return true if T is scalar, or a composite type which in practice has
+ the memory layout of a scalar type. E.g., an array or struct with only one
+ scalar element inside it, or a union with only scalar elements. */
+
+int
+is_scalar_type_recursive (struct type *t)
+{
+ CHECK_TYPEDEF (t);
+
+ if (is_scalar_type (t))
+ return 1;
+ /* Are we dealing with an array or string of known dimensions? */
+ else if ((TYPE_CODE (t) == TYPE_CODE_ARRAY
+ || TYPE_CODE (t) == TYPE_CODE_STRING) && TYPE_NFIELDS (t) == 1
+ && TYPE_CODE (TYPE_INDEX_TYPE (t)) == TYPE_CODE_RANGE)
+ {
+ LONGEST low_bound, high_bound;
+ struct type *elt_type = check_typedef (TYPE_TARGET_TYPE (t));
+
+ get_discrete_bounds (TYPE_INDEX_TYPE (t), &low_bound, &high_bound);
+
+ return high_bound == low_bound && is_scalar_type_recursive (elt_type);
+ }
+ /* Are we dealing with a struct with one element? */
+ else if (TYPE_CODE (t) == TYPE_CODE_STRUCT && TYPE_NFIELDS (t) == 1)
+ return is_scalar_type_recursive (TYPE_FIELD_TYPE (t, 0));
+ else if (TYPE_CODE (t) == TYPE_CODE_UNION)
+ {
+ int i, n = TYPE_NFIELDS (t);
+
+ /* If all elements of the union are scalar, then the union is scalar. */
+ for (i = 0; i < n; i++)
+ if (!is_scalar_type_recursive (TYPE_FIELD_TYPE (t, i)))
+ return 0;
+
+ return 1;
+ }
+
+ return 0;
+}
+
/* A helper function which returns true if types A and B represent the
"same" class type. This is true if the types have the same main
type, or the same name. */
extern int is_integral_type (struct type *);
+extern int is_scalar_type_recursive (struct type *);
+
extern void maintenance_print_type (char *, int);
extern htab_t create_copied_types_hash (struct objfile *objfile);
to determine the hardcoded watchable region for watchpoints. */
if (have_ptrace_booke_interface ())
{
- if (booke_debug_info.data_bp_alignment
- && (addr + len > (addr & ~(booke_debug_info.data_bp_alignment - 1))
- + booke_debug_info.data_bp_alignment))
+ /* DAC-based processors (i.e., embedded processors), like the PowerPC 440
+ have ranged watchpoints and can watch any access within an arbitrary
+ memory region. This is useful to watch arrays and structs, for
+ instance. It takes two hardware watchpoints though. */
+ if (len > 1
+ && booke_debug_info.features & PPC_DEBUG_FEATURE_DATA_BP_RANGE)
+ return 2;
+ else if (booke_debug_info.data_bp_alignment
+ && (addr + len > (addr & ~(booke_debug_info.data_bp_alignment - 1))
+ + booke_debug_info.data_bp_alignment))
return 0;
}
/* addr+len must fall in the 8 byte watchable region for DABR-based
&& check_condition (addr, cond, &data_value));
}
+/* Set up P with the parameters necessary to request a watchpoint covering
+ LEN bytes starting at ADDR and if possible with condition expression COND
+ evaluated by hardware. INSERT tells if we are creating a request for
+ inserting or removing the watchpoint. */
+
+static void
+create_watchpoint_request (struct ppc_hw_breakpoint *p, CORE_ADDR addr,
+ int len, int rw, struct expression *cond,
+ int insert)
+{
+ if (len == 1)
+ {
+ int use_condition;
+ CORE_ADDR data_value;
+
+ use_condition = (insert? can_use_watchpoint_cond_accel ()
+ : booke_debug_info.num_condition_regs > 0);
+ if (cond && use_condition && check_condition (addr, cond, &data_value))
+ calculate_dvc (addr, len, data_value, &p->condition_mode,
+ &p->condition_value);
+ else
+ {
+ p->condition_mode = PPC_BREAKPOINT_CONDITION_NONE;
+ p->condition_value = 0;
+ }
+
+ p->addr_mode = PPC_BREAKPOINT_MODE_EXACT;
+ p->addr2 = 0;
+ }
+ else
+ {
+ p->addr_mode = PPC_BREAKPOINT_MODE_RANGE_INCLUSIVE;
+ p->condition_mode = PPC_BREAKPOINT_CONDITION_NONE;
+ p->condition_value = 0;
+
+ /* The watchpoint will trigger if the address of the memory access is
+ within the defined range, as follows: p->addr <= address < p->addr2.
+
+ Note that the above sentence just documents how ptrace interprets
+ its arguments; the watchpoint is set to watch the range defined by
+ the user _inclusively_, as specified by the user interface. */
+ p->addr2 = (uint64_t) addr + len;
+ }
+
+ p->version = PPC_DEBUG_CURRENT_VERSION;
+ p->trigger_type = get_trigger_type (rw);
+ p->addr = (uint64_t) addr;
+}
+
static int
ppc_linux_insert_watchpoint (CORE_ADDR addr, int len, int rw,
struct expression *cond)
if (have_ptrace_booke_interface ())
{
struct ppc_hw_breakpoint p;
- CORE_ADDR data_value;
-
- if (cond && can_use_watchpoint_cond_accel ()
- && check_condition (addr, cond, &data_value))
- calculate_dvc (addr, len, data_value, &p.condition_mode,
- &p.condition_value);
- else
- {
- p.condition_mode = PPC_BREAKPOINT_CONDITION_NONE;
- p.condition_value = 0;
- }
- p.version = PPC_DEBUG_CURRENT_VERSION;
- p.trigger_type = get_trigger_type (rw);
- p.addr_mode = PPC_BREAKPOINT_MODE_EXACT;
- p.addr = (uint64_t) addr;
- p.addr2 = 0;
+ create_watchpoint_request (&p, addr, len, rw, cond, 1);
ALL_LWPS (lp, ptid)
booke_insert_point (&p, TIDGET (ptid));
if (have_ptrace_booke_interface ())
{
struct ppc_hw_breakpoint p;
- CORE_ADDR data_value;
-
- if (cond && booke_debug_info.num_condition_regs > 0
- && check_condition (addr, cond, &data_value))
- calculate_dvc (addr, len, data_value, &p.condition_mode,
- &p.condition_value);
- else
- {
- p.condition_mode = PPC_BREAKPOINT_CONDITION_NONE;
- p.condition_value = 0;
- }
- p.version = PPC_DEBUG_CURRENT_VERSION;
- p.trigger_type = get_trigger_type (rw);
- p.addr_mode = PPC_BREAKPOINT_MODE_EXACT;
- p.addr = (uint64_t) addr;
- p.addr2 = 0;
+ create_watchpoint_request (&p, addr, len, rw, cond, 0);
ALL_LWPS (lp, ptid)
booke_remove_point (&p, TIDGET (ptid));
internal_error (__FILE__, __LINE__, _("could not update architecture"));
}
+/* Show the current setting of the exact watchpoints flag. */
+
+static void
+show_powerpc_exact_watchpoints (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c,
+ const char *value)
+{
+ fprintf_filtered (file, _("Use of exact watchpoints is %s.\n"), value);
+}
+
/* Initialization code. */
/* -Wmissing-prototypes */
_("Show the vector ABI."),
NULL, powerpc_set_vector_abi, NULL,
&setpowerpccmdlist, &showpowerpccmdlist);
+
+ add_setshow_boolean_cmd ("exact-watchpoints", class_support,
+ &target_exact_watchpoints,
+ _("\
+Set whether to use just one debug register for watchpoints on scalars."),
+ _("\
+Show whether to use just one debug register for watchpoints on scalars."),
+ _("\
+If true, GDB will use only one debug register when watching a variable of\n\
+scalar type, thus assuming that the variable is accessed through the address\n\
+of its first byte."),
+ NULL, show_powerpc_exact_watchpoints,
+ &setpowerpccmdlist, &showpowerpccmdlist);
}
int (*to_stopped_data_address) (struct target_ops *, CORE_ADDR *);
int (*to_watchpoint_addr_within_range) (struct target_ops *,
CORE_ADDR, CORE_ADDR, int);
+
+ /* Documentation of this routine is provided with the corresponding
+ target_* macro. */
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);
#define target_can_use_hardware_watchpoint(TYPE,CNT,OTHERTYPE) \
(*current_target.to_can_use_hw_breakpoint) (TYPE, CNT, OTHERTYPE);
+/* Returns the number of debug registers needed to watch the given
+ memory region, or zero if not supported. */
+
#define target_region_ok_for_hw_watchpoint(addr, len) \
(*current_target.to_region_ok_for_hw_watchpoint) (addr, len)
projects / binutils-gdb.git / commitdiff