Re: change of behavior in block_innermost_frame... ("inline" patch?)

[Daniel Jacobowitz <drow@false.org>]

On Fri, Aug 28, 2009 at 11:17:10AM -0400, Joel Brobecker wrote:
> Hi Daniel,
> 
> I was trying to resync AdaCore's patches vs the current HEAD sources
> at the FSF, and I noticed that there was a slight change in behavior
> inside block_innermost_frame. I wanted to have your thoughts on this.
> 
> The situation we have is that we have a nested procedure from which
> we're trying to print the value of a variable defined in the outer
> procedure. In other words:
> 
>    procedure Test_Nesting is
>       N: Integer;
>       procedure Inner1 (Y: INTEGER) is
>       begin
>          if (Y < N) then
>             Inner1 (Y * 2);
>          else
>             --gdb: break nesting.adb:15
>             --gdb: cont
>             Put (Integer'Image (Y));    -- BREAK
> 
> We stopped at the last quoted line ("BREAK"), and tried to print
> the value of N. Normally, what would happen is that value_of_variable
> calls block_innermost_frame to find the frame where this variable
> is defined (in my case frame #6), and then pass that frame to
> read_var_value for actual reading. What happens in that case is
> that we changed the logic of block_innermost_frame to use the
> block.c::contained_in function to match the frame to our given block,
> which relies on superblock relationship. As a result, in my case
> above, block_innermost_frame now returns frame 0 (which corresponds
> to procedure Inner1), because the corresponding block is in fact
> contained in the block I'm looking for. This is of course the wrong
> frame to be using in order to print variable N :-(.
> 
> I was wondering what was the reason for the change. I would like to fix
> the issue while at the same time not causing a regression... Any additional
> thoughts?

The old version of block_innermost_frame did this:

      calling_pc = get_frame_address_in_block (frame);
      if (calling_pc >= start && calling_pc < end)
        return frame;

Suppose calling_pc is at the location of an inlined function.  We
don't want to print variables of the caller looking at the inlined
function; they're not in scope.

The comment of block_innermost_frame is a bit ambiguous for your
example:

/* Return the innermost stack frame executing inside of BLOCK,
   or NULL if there is no such frame.  If BLOCK is NULL, just return
   NULL.  */

It does make sense that the nested function's frame would be executing
inside of the outer function's block.  It also makes sense that it
wouldn't be.  Anyway, you don't want it to be.  I think contained_in
is going to have to be where you fix this.

I remember a lot of headaches about nested functions.  Having the same
block representation for nested functions and for inlined functions is
confusing.  Anyway, see block_linkage_function for an analogous check
in the opposite sense.  contained_in must want something like:

  if (BLOCK_FUNCTION (a) != NULL && !block_inlined_p (a))
    return 0;

Something trickier will be required if this function is ever passed a
global or static block at file scope.

-- 
Daniel Jacobowitz
CodeSourcery