Julia: Strange Behavior for try-while-errorcondition on Julia 0.7-beta2

[antimon2]

Simple example:

function calc(x, y, z)
    if z > 5
        throw(ArgumentError("z ($z) must to be ≤ 5."))
    end
    x + y * z
end

function calc_z(n)
    z = 0
    try
        while calc(0, 3, z) < n
            z += 1
        end
    catch ex
        if ex isa ArgumentError
            # pass
        else
            rethrow()
        end
    end    
    z - 1
end

calc_z(10)
# => 3, expected

calc_z(20)
# => -1, unexpected, 5 is expected

Is this correct behavior on Julia v0.7?
(On Julia v0.6, calc_z(20) returns 5 as I expect)

versioninfo():

Julia Version 0.7.0-beta2.0
Commit b145832402* (2018-07-13 19:54 UTC)
Platform Info:
  OS: macOS (x86_64-apple-darwin14.5.0)
  CPU: Intel(R) Core(TM) i7-5557U CPU @ 3.10GHz
  WORD_SIZE: 64
  LIBM: libopenlibm
  LLVM: libLLVM-6.0.0 (ORCJIT, broadwell)

see details: https://gist.github.com/antimon2/1dca9305e9aee13a4df642076e95c4c3

[JeffBezanson]

When the exception is caught, z is reverting to its pre-try-block value (0). @Keno seems to be φᶜ-related.

[Liozou]

MWE:

julia> @noinline make_error(n) =  n == 5 ? error() : true
make_error (generic function with 1 method)

julia> function foo()
           z = 0
           try
               while make_error(z)
                   z+=1
               end
           catch end
           return z
       end
foo (generic function with 1 method)

julia> foo()
0

[Keno]

Thanks, the bug in the MWE is very obvious:

julia> @code_typed foo()
CodeInfo(
  1 ─      nothing                                                                                                            │
3 2 ─      :($(Expr(:enter, 4)))                                                                                              │
4 3 ┄ %3 = φ (2 => 0, 3 => %6)::Int64                                                                                         │
  │   %4 = ϒ (0)::Int64                                                                                                       │
  │        invoke Main.make_error(%3::Int64)                                                                                  │
5 │   %6 = Base.add_int(%3, 1)::Int64                                                                                         │╻ +
  │   %7 = ϒ (%6)::Int64                                                                                                      │
  └──      goto 3                                                                                                             │
  4 ┄ %9 = φᶜ (%4, %7)::Int64                                                                                                 │
  └──      :($(Expr(:leave, 1)))                                                                                              │
8 5 ─      return %9                                                                                                          │
  6 ─      goto 4                                                                                                             │
) => Int64

The initial upsilon node is placed in the first BB after the enter, but that also happens to be the target of the backedge from the while loop, so the value of the phic gets reset. I'll see if we can insert an extra BB to break the critical edge. Alternatively, we may be able to add the initial Upsilon nodes in the :enter BB

[affans]

@Keno If you have some time available, do you mind explaining what the problem was? What does " φᶜ-related" mean?

[Keno]

φᶜ nodes are one of the node types of the extended SSA representation of the new optimizer in Julia 0.7. See documentation here: https://github.com/JuliaLang/julia/blob/master/doc/src/devdocs/ssair.md#phic-nodes-and-upsilon-nodes