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

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

[Joel Brobecker]

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?

Thanks,
-- 
Joel

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

[Daniel Jacobowitz]

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