Re: [PATCH] Compare contents when evaluating an array watchpoint

[Andrew Cagney <ac131313 at redhat dot com>]

[suggest RFA rather than PATCH]

> > There's two phases to the process by which GDB handles watchpoints,  a "trigger" phase, where GDB causes itself to be stopped in any circumstance where the watchpoint might have been changed (either by hardware registers, page-protections, or single-stepping), and a "compare" phase, where it checks the value of the data being watched to see if it has actually changed.  My patch doesn't change the behavior of the trigger phase at all --- this phase has always set the trigger to watch the entire contents of the array.
> >
> > My patch changes only the "compare" phase, by causing it to actually compare the contents of the array.  The one performance implication I can think of is that watching large arrays could be unpleasant on systems that can only do breakpoints via single-stepping (whereas before it would have been impossible, so I'm not overly concerned).
(Like Eli, I'm puzzled by the existing behavior :-)

Just to get this straight.  given:
	int a[10];
then:
	(gdb) watch a
sets up the hardware to look for a change in ``*a@10'' but then 
evaluates ``a'' and hence, while stopping when ever `a' changes, never 
trigger the watchpoint?

Would it be better to make it possible for the user to clearly 
differentiate between these two cases and specify any of:

	int a[10];
	int *b;
	(gdb) watch a
	(gdb) watch b
	(gdb) watch *b@10
	(gdb) watch *a@sizeof(a)

While the existing ``watch a'' might have annoying semantics, it would 
make its behavior consistent with C.  An array is converted to a pointer 
in an expression.  I'm not sure how well this would work with the 
expression evaluator though.

What ever the outcome, this desperatly needs a testcase.  Otherwize 
we're all going to keep spinning our weels wondering what the behavior 
was ment to be.

Andrew




> On Monday, October 7, 2002, at 01:53 AM, Eli Zaretskii wrote:
>
> On Sun, 6 Oct 2002, Klee Dienes wrote:
>
> > The following patch allows one to set watchpoints on arrays, and have
> > the watchpoint triggered if any element in the array changes.  Without
> > the patch, the C value_equal semantics causes the address of the array
> > to be checked for change, not the contents --- resulting in a
> > watchpoint that can never be hit.
> >
> > This is particularly useful if one wants to do commands like watch
> > {char[80]} 0xfff0000, or similar, in order to watch an arbitrary region
> > of memory.
> >
> > What will this do to hardware watchpoints on arrays/array elements?  On
> > many platforms, hardware watchpoints have size limitations, so large
> > arrays cannot be watched in their entirety.

>