continue inside inline for cause compiler crash

[hcff]

Version : 0.4.0+d1b6f29d
This is similar to #834.

const std = @import("std");

const ints = []u32{ 42, 1337, 0xdeadbeef };

fn do_thing(int: u32) error{IsALeet}!void {
    std.debug.warn("{}\n", int);
    if (int == 1337) return error.IsALeet;
}

pub fn main() void {
    inline for (ints) |int| {
        do_thing(int) catch |_| continue;
        std.debug.warn("not a leet\n");
    }
}

The code above gives a compiler crash.

 $ gdb zig
GNU gdb (GDB) Fedora 8.2-6.fc29
...
(gdb) run build-exe main.zig
Starting program: zig build-exe main.zig

Program received signal SIGSEGV, Segmentation fault.
0x00007ffff634a220 in llvm::BasicBlock::getContext() const ()
(gdb) bt
#0  0x00007ffff634a220 in llvm::BasicBlock::getContext() const ()
#1  0x00007ffff63dea89 in llvm::BranchInst::BranchInst(llvm::BasicBlock*, llvm::BasicBlock*, llvm::Value*, llvm::Instruction*) ()
#2  0x00007ffff63761e8 in LLVMBuildCondBr ()
#3  0x00007ffff250249a in ir_render_instruction(CodeGen*, IrExecutable*, IrInstruction*) [clone .isra.206] ()
#4  0x00007ffff2503cf5 in do_code_gen(CodeGen*) ()
#5  0x00007ffff2507407 in codegen_build_and_link(CodeGen*) ()
#6  0x00007ffff24302bd in main ()

A if on the error union will give a comptime control flow inside runtime block error :

pub fn main() void {
    inline for (ints) |int| {
        if (do_thing(int)) |_| {}
        else |_| { continue; }
        std.debug.warn("not a leet\n");
    }
}

By the way, I don't think doing that should be an error since breaking on the inner block compile correctly, and is essentially the same thing.

pub fn main() void {
    inline for (ints) |int| blk: {
        do_thing(int) catch |_| break :blk;
        std.debug.warn("not a leet\n");
    }
}

 $ zig build-exe main.zig
 $ ./main 
42
not a leet
1337
3735928559
not a leet

[Sahnvour]

I think I had more or less the same bug on another snippet:

const std = @import("std");
const builtin = @import("builtin");
const meta = std.meta;
test "foo" {
    const Foo = union(enum) {
        A: u32,
        B: u32,
    };

    const key = Foo{ .A = 1 };

    switch (@typeInfo(Foo)) {
        // builtin.TypeId.Union => |info| {
        builtin.TypeId.Union => |info| blk: {
            if (info.tag_type) |tag_type| {
                const tag = meta.activeTag(key);
                inline for (info.fields) |field| {
                    const enum_field = field.enum_field.?;
                    if (enum_field.value == @enumToInt(tag)) {
                        std.debug.warn("{}", enum_field.name);
                        // return;
                        break :blk;
                    }
                }
            }
        },
        else => {},
    }
}

break :blk; causes a crash.

Callstack:

>	zig.exe!llvm::Value::getType() Line 245	C++
 	zig.exe!llvm::BasicBlock::getContext() Line 34	C++
 	zig.exe!llvm::BranchInst::BranchInst(llvm::BasicBlock * IfTrue, llvm::Instruction * InsertBefore) Line 987	C++
 	zig.exe!llvm::BranchInst::Create(llvm::BasicBlock * IfTrue, llvm::Instruction * InsertBefore) Line 3023	C++
 	zig.exe!llvm::IRBuilder<llvm::ConstantFolder,llvm::IRBuilderDefaultInserter>::CreateBr(llvm::BasicBlock * Dest) Line 849	C++
 	zig.exe!LLVMBuildBr(LLVMOpaqueBuilder * B, LLVMOpaqueBasicBlock * Dest) Line 2960	C++
 	zig.exe!ir_render_br(CodeGen * g, IrExecutable * executable, IrInstructionBr * br_instruction) Line 3323	C++
 	zig.exe!ir_render_instruction(CodeGen * g, IrExecutable * executable, IrInstruction * instruction) Line 5652	C++
 	zig.exe!ir_render(CodeGen * g, ZigFn * fn_entry) Line 5834	C++
 	zig.exe!do_code_gen(CodeGen * g) Line 6849	C++
 	zig.exe!codegen_build_and_link(CodeGen * g) Line 9616	C++
 	zig.exe!main(int argc, char * * argv) Line 1204	C++

In ir_render_br, dest_block->llvm_block is null, but I didn't have time to investigate further. Or rather, to make substantial findings.

[andrewrk]

I just pushed a fix for the original test case, which now gives error: comptime control flow inside runtime block.

By the way, I don't think doing that should be an error since breaking on the inner block compile correctly, and is essentially the same thing.

Making this not a compile error needs to be a separate proposal. More examples need to be examined and an implementation will be nontrivial.

@Sahnvour your test case still crashes, turns out it is a separate issue.

[xxxbxxx]

I think I had the same issue?

this fails to compile:

export fn func() u32 {
    var s : u32 = 0;
    inline for ([_]u8{1,2}) |phase| {
        var i: u32 = 0;
        while (i<4) : (i+=1) {
            if (phase == i) 
                continue;
            s += i;
        }
    }
    return s;
}

And, if I reverse the if to avoid the continue, it compiles and works:
(and the same workaround works on my more complex actual code)

export fn func() u32 {
    var s : u32 = 0;
    inline for ([_]u8{1,2}) |phase| {
        var i: u32 = 0;
        while (i<4) : (i+=1) {
            if (phase != i)  {
                 s += i;
            }
        }
    }
    return s;
}

I'd guess it is related to control flow with 'goto' like constructs (had similar issues with break :label value when trying to find a workaournd).
I have the feeling it tries to jump to the label from the wrong iteration of the unrolled for or something..