Local variable not updated in closure state

[yamam]

Environment

jruby 9.2.3.0 (2.5.0) 2018-11-09 5833e2d Java HotSpot(TM) 64-Bit Server VM 25.191-b12 on 1.8.0_191-b12 +jit [mswin32-x86_64]

Expected Behavior

test.rb

var = 0

pr = proc do |v|
    puts "pr is called"
    if var == 0
        puts "ERROR!"
    end
end

def foo(&proc)
  proc.call
end

foo do
    begin
        var = 1
        puts "call pr"
        pr.call
    ensure
      var = 0
      puts "ensure end"
    end
end

jruby-9.2.0.0/bin/jruby test.rb
call pr
pr is called
ensure end

Actual Behavior

jruby-9.2.3.0/bin/jruby test.rb
call pr
pr is called
ERROR!
ensure end

[headius]

This does not appear to be affected by Java integration; if I make JavaClass.new into a pure-Ruby method it behaves the same way. I will update the issue description to reflect this.

[headius]

This is definitely some oddity with IR. If I do any of the following, the error goes away:

• Eliminate the ensure block
• Add a puts at the beginning of the ensure block

Something about the ensure is causing the write to var to not go directly to the heap.

I think it may be eliminating the intermediate write to var because it sees that the ensure overwrites that value.

@subbuss @enebo When are heap variables written back to the heap? I know we do it around closure boundaries, since they need to see the most current state. In this case, after the update var = 1 a proc is called that needs to see that value, but we don't seem to push it back to the heap for either the puts call or the pr.call call.

Here's the IR for the broken version, with the main body and fall-through ensure:

block #4 (out: 5,6): CL2_LBL_0:9
  0:             line_num(lineNumber: 15)
  1:             line_num(lineNumber: 16)
  2:  %cl_2_8 := copy(str<call pr>)
  3:  %cl_2_7 := call_1o(self<%self>, %cl_2_8, callType: FUNCTIONAL, name: puts, potentiallyRefined: false)
  4:             line_num(lineNumber: 17)
  5:  %cl_2_9 := call_0o(*pr, callType: NORMAL, name: call, potentiallyRefined: false)
  6:  %cl_2_6 := copy(%cl_2_9)

block #5 (out: 11): CL2_LBL_4:20
  0:             line_num(lineNumber: 19)
  1:     *var := copy(fix<0>)
  2:             line_num(lineNumber: 20)
  3:  %cl_2_5 := copy(str<ensure end>)
  4:  %cl_2_4 := call_1o(self<%self>, %cl_2_5, callType: FUNCTIONAL, name: puts, potentiallyRefined: false)
  5:             pop_binding
  6:             restore_binding_viz(%cl_2_13)
  7:             pop_block_frame(%cl_2_14)
  8:             return(%cl_2_6)

Note there's no var = 1 at all.

If I add a puts to the ensure, it changes:

block #4 (out: 5,6): CL2_LBL_0:9
  00:             line_num(lineNumber: 15)
  01:     *var := copy(fix<1>)
  02:             line_num(lineNumber: 16)
  03: %cl_2_10 := copy(str<call pr>)
  04:  %cl_2_9 := call_1o(self<%self>, %cl_2_10, callType: FUNCTIONAL, name: puts, potentiallyRefined: false)
  05:             line_num(lineNumber: 17)
  06: %cl_2_11 := call_0o(*pr, callType: NORMAL, name: call, potentiallyRefined: false)
  07:  %cl_2_8 := copy(%cl_2_11)

block #5 (out: 11): CL2_LBL_4:20
  00:             line_num(lineNumber: 19)
  01:  %cl_2_5 := copy(str<ensure start>)
  02:  %cl_2_4 := call_1o(self<%self>, %cl_2_5, callType: FUNCTIONAL, name: puts, potentiallyRefined: false)
  03:             line_num(lineNumber: 20)
  04:     *var := copy(fix<0>)
  05:             line_num(lineNumber: 21)
  06:  %cl_2_7 := copy(str<ensure end>)
  07:  %cl_2_6 := call_1o(self<%self>, %cl_2_7, callType: FUNCTIONAL, name: puts, potentiallyRefined: false)
  08:             pop_binding
  09:             restore_binding_viz(%cl_2_15)
  10:             pop_block_frame(%cl_2_16)
  11:             return(%cl_2_8)

Looking at this I may have a theory: because there's no call immediately before var = 0 in the ensure, somehow the IR doesn't think there's any calls after var = 1, so it eliminates the assignment completely. Adding the puts causes it to propagate var to the heap.

[headius]

Trivial reproduction that seems to support my theory:

var = 0
pr = ->(){p var}
1.times do
  var = 1
  pr.call
ensure
  var = 2
end
# => 0, not 2 because the ensure does not actually fire before pr.call

[headius]

This appears to be a regression. JRuby 9.2 properly updates var here.

[subbuss]

This is what I see locally with master

[subbu@earth:~/jruby] jruby -X-C /tmp/x.rb
1
[subbu@earth:~/jruby] jruby /tmp/x.rb
0
[subbu@earth:~/jruby] jruby -X+C /tmp/x.rb
0

[enebo]

@SubuSS @headius make sure you are running same passes as much as you can. Last comment points to jit or pass but I am being on a pass -X-C is not running

[subbuss]

It has been so long that I no longer remember how to run specific passes :-) .. but, I found that ast --ir still runs and looks like Dead Code Elimination kills the "var = 1" assignment which means information about escaped variables has somehow been lost between 9.2 and master .. could be because of twiddling of flags on operations / instructions, etc .. for example.

[subbuss]

Reverting ae777f0 seems to fix it.

[subbuss]

I did a blind revert - didn't analyze what was broken with it. Maybe @enebo and @headius and figure out. I don't have any more time today to look into this. Reopening so that we figure out what is going on.