Behavior of 'until' command

[Elena Zannoni <ezannoni at redhat dot com>]

The documenation says that 'until' does this:

"@item until
Continue running until a source line past the current line, in the
current stack frame, is reached. [...]@code{until} always stops your
program if it attempts to exit the current stack frame.
[...]

@item until @var{location} 
Continue running your program until either the specified location is
reached, or the current stack frame returns.  @var{location} is any of
the forms of argument acceptable to @code{break}.  This form of the
command uses breakpoints, and hence is quicker than @code{until}
without an argument."

Note the 'will not exit the current stak frame' business.

However, nobody forbids you from saying "until foo" (since that's an
OK argument for break as well).  And foo can be any function, called
by the current frame or not.

It is not clear to me what the doco describes as gdb's
behavior. Concrete example below:

1	static int x;
2	
3	int fun ()
4	{
5	   x = 1;
6	}
7	
8	int fun2 ()
9	{
10	   x = 4;
11	}
12	
13	void foo()
14	{
15	  x = x + 5;
16	  fun2 ();
17	}
18	int main (int ac, char **av)
19	{
20	  x = 3;
21	  foo ();
22	  fun ();
23	  x = 3;
24	  return 0;
25	}


If I am in 'foo' at line 15,and enter the command 'until fun', I
would expect to end up ... where? At line 22?  Or should I end up at
line 5? Right now gdb ends up at 22, i.e. doesn't enter 'fun'. I think
it is consistent with the doco.

Similarly from foo line 15 where should 'until fun2' take me? Inside
fun2, at line 10? Or at line 16? Currently I end up at line 22 which
is in main. This seems clearly wrong either way.

Any thoughts?

Elena