Re: dynamic breakpoints/watchpoints

["Ed S. Peschko" <esp5@pge.com>]

On Wed, Mar 14, 2007 at 11:20:18AM +0200, Michael Veksler wrote:
> Ed S. Peschko wrote:
> >For example, 
> >
> >int main()
> >{
> >	==>	int stuff;
> >	aha();
> >	aha2();
> >}
> >
> >
> >int aha()
> >{
> >	fprintf(stderr, "HERE1");
> >}
> >
> >int aha2()
> >{
> >	fprintf(stderr, "HERE");
> >}
> >	
> >Suppose that I'm at the '==>'. if I say bc /HERE/", I would break in the 
> >function 'aha', at the fprintf statement HERE1'. If I said bc /HERE/ at 
> >THAT
> >point, then I'd break at 'HERE2'. The breakpoint changes as you go along.
> >  
> What I usually do is use emacs' tags system to search for the string, 
> and then manually put breakpoints at the relevant locations. This works 
> well when there is only couple of matching lines.

Well, yeah, of course there are workarounds, but they are IMO messy and
hard to deal with. Instead of setting up tags, or grepping through code,
doing a code match in the debugger is far easier. That's why I wrote
it for perl in the first place, I got sick of doing these workarounds.

Plus, I'm not sure if the tags solution is complete. Tags normally only
handles function calls, declarations, etc. as I understand it. How do you 
make breakpoints for statements inside function calls using it without
grepping through the code and manufacturing breakpoints using some sort of 
scripting?

> My normal use case is:
> 
>   1. An error text is printed, or some activity is logged into a file.
>   2. I want to stop right at the place that caused that behavior. So I
>      perform the following:
>         1. Try to guess how the relevant code looks like
>         2. Look for all occurrences of such code using grep/tags
>         3. If search result is too wide or too narrow go to step i.
>         4. Break at all relevant locations
> 
> This process is quite long and prone to errors. It would be much better 
> if it were integrated into gdb+libc+libstdc++ in the following way:
> 
>   1. libc+libstdc++ will have hooks that gdb will be able to use to
>      intercept FILE/stream writes.
>   2. A slower alternative to 1 is for for GDB to intercept write system
>      calls, and check their contents. To improve granularity in C,
>      buffering should be set to line granularity. In C++, buffering
>      should be eliminated (unless people use std::endl instead of the
>      much better "\n").
>   3. GDB will stop at each write, and look for the requested text. If
>      the text is encountered - break.

look, I agree.. having some searching ability is better than none at 
all, and if it is easy to implement this then maybe that is the way to go.

But it's incredibly comforting in perl to have a universal search (in
perl this is of course integrated with regular expressions). I know that 
no matter what I search for, I'll find it as soon as the data is
matched. 

And true, its slow as hell because everything is interpreted, but it would
be far slower for me to track it down manually. 

For gcc and gdb, I'd be willing to build my own special compiler 
instance to carry this functionality, and avoid the overhead for
my regular compiles by having ifdefs in the gcc code .

Another point - unless this functionality is to be linux only, 
I'd be hesitant to put the change into libstdc++ and/or glibc. 
glibc is NOTORIOUSLY unportable, and is far from universal.

> provided by the libstdc++ team. They could add an strcmp looking for the 
> requested string, every time the string is mutated, and then GDB will be 
> able to break on a match. Other data-types are more complicated, and 
> most of them are impractical candidates for dynamic watchpoints (unless 
> GCC is heavily modified to insert hooks for all updates to, for example, 
> int variables - this will be slow as hell).

yeah, but as I indicated above, I think that patching gcc would be
probably the only way to get widespread portability.

Ed