Segmentation fault in Version 1.0

[billb2050]

I'm working on a Julia Version 1.0.0 program that caused a Segmentation fault.
julia> versioninfo()
Julia Version 1.0.0
Commit 5d4eaca (2018-08-08 20:58 UTC)
Platform Info:
OS: Linux (x86_64-pc-linux-gnu)
CPU: AMD Ryzen 5 2600X Six-Core Processor
WORD_SIZE: 64
LIBM: libopenlibm
LLVM: libLLVM-6.0.0 (ORCJIT, znver1)

It's is reproduceable. I've stripped out most of the other non-related code. And I've isolated the statement causing this. I've got it down to under 90 lines.

Sometimes I work on new routines at the beginning of the program followed by an exit() to keep from going throught the whole program.When I get the routine to do what I want, I move it down into the main program and comment the above testing section out.That's whats happening here, if I comment out the top code I get the seg fault in the main loop. Uncomment the testing part and it runs.

SegFault.jl.tar.gz

[nalimilan]

Thanks for the detailed report. I can also reproduce it on 0.7 and master.

[billb2050]

I found a logic problem in my code that appears to cause the problem. The variable "byr" is undefined in the last "while" code. When I add "println("byr ",byr)" right before the last "while", I get "ERROR: LoadError: UndefVarError: byr not defined" and a "Gentle" termination without the Seg Fault. The proper solution was for me to add the "byr" variable to the global statement within the 1st "while" code. At any rate I should have gotten an "UndefVarError" and not a Seg Fault.

[JeffBezanson]

I reduced it to this:

function f()
    while true
        try
            break
        finally
        end
    end

    while 1==1
        try
            ed = (_not_defined,)
        finally
            break
        end
    end

    ed = string(ed)
end

f()

The local ed is null, but the optimizer seems to think it's defined:

   1 ──       nothing::Nothing                                                   │
2  2 ┄─ %2  = φ (#1 => #undef, #12 => %12)::MaybeUndef(Union{String, Tuple{Any}})│
   │    %3  = φ (#1 => false, #12 => %15)::Bool                                  │
   └─── %4  = φ (#1 => #undef, #12 => %16)::MaybeUndef(Any)                      │
3  3 ──       $(Expr(:enter, #6))                                                │
   4 ── %6  = ϒ (%2)::Union{String, Tuple{Any}}                                  │
4  └───       $(Expr(:leave, 1))                                                 │
   5 ──       goto #8                                                            │
   6 ┄─ %9  = φᶜ (%6)::Union{String, Tuple{Any}}                                 │
   └───       $(Expr(:leave, 1))                                                 │
   7 ── %11 = $(Expr(:the_exception))::Any                                       │
6  8 ┄─ %12 = φ (#5 => %2, #7 => %9)::MaybeUndef(Union{String, Tuple{Any}})      │
   │    %13 = φ (#5 => false, #7 => true)::Bool                                  │
   │    %14 = φ (#5 => true, #7 => false)::Bool                                  │
   │    %15 = φ (#5 => %3, #7 => true)::Bool                                     │
   │    %16 = φ (#5 => %4, #7 => %11)::MaybeUndef(Any)                           │
   └───       goto #10 if not %13                                                │
   9 ──       $(Expr(:throw_undef_if_not, Symbol("#temp#"), :(%15)))::Any        │
   │          $(Expr(:foreigncall, :(:jl_rethrow_other), Union{}, svec(Any), :(:ccall), 1, :(%16)))::Union{}
   └───       $(Expr(:unreachable))::Union{}                                     │
   10 ─       goto #12 if not %14                                                │
   11 ─       goto #13                                                           │
   12 ─       goto #2                                                            │
   13 ─       nothing::Nothing                                                   │
10 14 ─       $(Expr(:enter, #17))                                               │
   15 ─ %26 = ϒ (%12)::Union{String, Tuple{Any}}                                 │
11 │    %27 = (Core.tuple)(Main._not_defined)::Tuple{Any}                        │
   │    %28 = ϒ (%27)::Tuple{Any}                                                │
   └───       $(Expr(:leave, 1))                                                 │
   16 ─       goto #19                                                           │
   17 ┄ %31 = φᶜ (%26, %28)::Union{String, Tuple{Any}}                           │
   └───       $(Expr(:leave, 1))                                                 │
   18 ─       nothing::Nothing                                                   │
13 19 ┄ %34 = φ (#16 => true, #18 => true)::Bool                                 │
   │    %35 = φ (#16 => %27, #18 => %31)::Union{String, Tuple{Any}}              │
17 │          $(Expr(:throw_undef_if_not, :ed, :(%34)))::Any                     │
   │    %37 = π (%35, Tuple{Any})                                                │
   │    %38 = (Main.string)(%37)::String                                         │
   └───       return %38                                                         │

May be related to #29152. If _not_defined is declared local you get a SIGILL.