Ekdohibs/zig
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
5,831 Commits 1 Branch 0 Tags
Commit Graph

1186 Commits

Author SHA1 Message Date
Andrew Kelley
3ec766abe3
remove ResultLocField dead code 2019-06-09 10:46:13 -04:00
Andrew Kelley
771e88951a
result location mechanism for struct initialization 
```zig
export fn entry() void {
    const static = Foo{
        .x = 9,
        .bar = Bar{ .y = 10 },
    };
    const runtime = foo(true);
}

fn foo(c: bool) Foo {
    return Foo{
        .x = 12,
        .bar = if (c) bar1() else bar2(),
    };
}

fn bar1() Bar {
    return Bar{ .y = 34 };
}

fn bar2() Bar {
    return Bar{ .y = 56 };
}
```

```llvm
@0 = internal unnamed_addr constant %Foo { i32 9, %Bar { i32 10 } }, align 4
@1 = internal unnamed_addr constant %Bar { i32 34 }, align 4
@2 = internal unnamed_addr constant %Bar { i32 56 }, align 4

define void @entry() #2 !dbg !35 {
Entry:
  %runtime = alloca %Foo, align 4
  call void @llvm.dbg.declare(metadata %Foo* @0, metadata !39, metadata !DIExpression()), !dbg !50
  call fastcc void @foo(%Foo* sret %runtime, i1 true), !dbg !51
  call void @llvm.dbg.declare(metadata %Foo* %runtime, metadata !49, metadata !DIExpression()), !dbg !52
  ret void, !dbg !53
}

define internal fastcc void @foo(%Foo* nonnull sret, i1) unnamed_addr #2 !dbg !54 {
Entry:
  %c = alloca i1, align 1
  store i1 %1, i1* %c, align 1
  call void @llvm.dbg.declare(metadata i1* %c, metadata !60, metadata !DIExpression()), !dbg !61
  %2 = getelementptr inbounds %Foo, %Foo* %0, i32 0, i32 0, !dbg !62
  store i32 12, i32* %2, align 4, !dbg !62
  %3 = getelementptr inbounds %Foo, %Foo* %0, i32 0, i32 1, !dbg !64
  %4 = load i1, i1* %c, align 1, !dbg !65
  br i1 %4, label %Then, label %Else, !dbg !65

Then:                                             ; preds = %Entry
  call fastcc void @bar1(%Bar* sret %3), !dbg !66
  br label %EndIf, !dbg !64

Else:                                             ; preds = %Entry
  call fastcc void @bar2(%Bar* sret %3), !dbg !67
  br label %EndIf, !dbg !64

EndIf:                                            ; preds = %Else, %Then
  ret void, !dbg !68
}

define internal fastcc void @bar1(%Bar* nonnull sret) unnamed_addr #2 !dbg !69 {
Entry:
  %1 = bitcast %Bar* %0 to i8*, !dbg !73
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %1, i8* align 4 bitcast (%Bar* @1 to i8*), i64 4, i1 false), !dbg !73
  ret void, !dbg !73
}

define internal fastcc void @bar2(%Bar* nonnull sret) unnamed_addr #2 !dbg !75 {
Entry:
  %1 = bitcast %Bar* %0 to i8*, !dbg !76
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %1, i8* align 4 bitcast (%Bar* @2 to i8*), i64 4, i1 false), !dbg !76
  ret void, !dbg !76
}

!39 = !DILocalVariable(name: "static", scope: !40, file: !5, line: 2, type: !41)
!49 = !DILocalVariable(name: "runtime", scope: !40, file: !5, line: 6, type: !41)
```
 2019-06-08 18:51:31 -04:00
Andrew Kelley
52eb347188
hook up result locs for try 2019-06-08 01:16:19 -04:00
Andrew Kelley
a2fff2628f
hook up peer result locs to orelse keyword 2019-06-08 01:09:19 -04:00
Andrew Kelley
b1efba0c70
hook up peer result locs to catch 
```zig
export fn entry() void {
    var x = crap() catch bar();
}
```

```llvm
define void @entry() #2 !dbg !40 {
Entry:
  %0 = alloca { i16, %Foo }, align 4
  %x = alloca %Foo, align 4
  call fastcc void @crap({ i16, %Foo }* sret %0), !dbg !50
  %1 = getelementptr inbounds { i16, %Foo }, { i16, %Foo }* %0, i32 0, i32 0, !dbg !51
  %2 = load i16, i16* %1, align 2, !dbg !51
  %3 = icmp ne i16 %2, 0, !dbg !51
  br i1 %3, label %UnwrapErrError, label %UnwrapErrOk, !dbg !51

UnwrapErrError:                                   ; preds = %Entry
  call fastcc void @bar(%Foo* sret %x), !dbg !52
  br label %UnwrapErrEnd, !dbg !51

UnwrapErrOk:                                      ; preds = %Entry
  %4 = getelementptr inbounds { i16, %Foo }, { i16, %Foo }* %0, i32 0, i32 1, !dbg !51
  %5 = bitcast %Foo* %4 to i8*, !dbg !51
  %6 = bitcast %Foo* %x to i8*, !dbg !51
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %6, i8* align 4 %5, i64 4, i1 false), !dbg !51
  br label %UnwrapErrEnd, !dbg !51

UnwrapErrEnd:                                     ; preds = %UnwrapErrOk, %UnwrapErrError
  ret void, !dbg !53
}
```
 2019-06-07 17:37:29 -04:00
Andrew Kelley
2b0a1b7b14
hook up result locs to for loops 
```zig
export fn entry() void {
    var buf: [10]u8 = undefined;
    var x = for (buf) |x| break foo() else bar();
}
```

```llvm
define void @entry() #2 !dbg !35 {
Entry:
  %buf = alloca [10 x i8], align 1
  %i = alloca i64, align 8
  %x = alloca %Foo, align 4
  %0 = bitcast [10 x i8]* %buf to i8*, !dbg !51
  call void @llvm.memset.p0i8.i64(i8* align 1 %0, i8 -86, i64 10, i1 false), !dbg !51
  call void @llvm.dbg.declare(metadata [10 x i8]* %buf, metadata !39, metadata !DIExpression()), !dbg !51
  store i64 0, i64* %i, align 8, !dbg !52
  call void @llvm.dbg.declare(metadata i64* %i, metadata !44, metadata !DIExpression()), !dbg !52
  br label %ForCond, !dbg !52

ForCond:                                          ; preds = %Entry
  %1 = load i64, i64* %i, align 8, !dbg !52
  %2 = icmp ult i64 %1, 10, !dbg !52
  br i1 %2, label %ForBody, label %ForElse, !dbg !52

ForBody:                                          ; preds = %ForCond
  %3 = getelementptr inbounds [10 x i8], [10 x i8]* %buf, i64 0, i64 %1, !dbg !52
  call void @llvm.dbg.declare(metadata i8* %3, metadata !45, metadata !DIExpression()), !dbg !53
  call fastcc void @foo(%Foo* sret %x), !dbg !54
  br label %ForEnd, !dbg !55

ForElse:                                          ; preds = %ForCond
  call fastcc void @bar(%Foo* sret %x), !dbg !56
  br label %ForEnd, !dbg !52

ForEnd:                                           ; preds = %ForElse, %ForBody
  call void @llvm.dbg.declare(metadata %Foo* %x, metadata !46, metadata !DIExpression()), !dbg !57
  ret void, !dbg !58
}
```
 2019-06-07 15:58:18 -04:00
Andrew Kelley
ede3436b08
hook up peer result locs to while bool and optional 2019-06-07 15:48:28 -04:00
Andrew Kelley
ec8d8a9774
hook up while on error unions with result locations 
```zig
export fn entry() void {
    var c: anyerror!i32 = 1234;
    var x = while (c) |y| break foo() else |e| bar();
}
```

```llvm
define void @entry() #2 !dbg !39 {
Entry:
  %c = alloca { i16, i32 }, align 4
  %x = alloca %Foo, align 4
  %0 = bitcast { i16, i32 }* %c to i8*, !dbg !56
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %0, i8* align 4 bitcast ({ i16, i32 }* @0 to i8*), i64 8, i1 false), !dbg !56
  call void @llvm.dbg.declare(metadata { i16, i32 }* %c, metadata !43, metadata !DIExpression()), !dbg !56
  br label %WhileCond, !dbg !57

WhileCond:                                        ; preds = %Entry
  %1 = getelementptr inbounds { i16, i32 }, { i16, i32 }* %c, i32 0, i32 0, !dbg !58
  %2 = load i16, i16* %1, align 2, !dbg !58
  %3 = icmp ne i16 %2, 0, !dbg !58
  br i1 %3, label %WhileElse, label %WhileBody, !dbg !58

WhileBody:                                        ; preds = %WhileCond
  %4 = getelementptr inbounds { i16, i32 }, { i16, i32 }* %c, i32 0, i32 1, !dbg !57
  call void @llvm.dbg.declare(metadata i32* %4, metadata !50, metadata !DIExpression()), !dbg !57
  call fastcc void @foo(%Foo* sret %x), !dbg !59
  br label %WhileEnd, !dbg !60

WhileElse:                                        ; preds = %WhileCond
  %5 = getelementptr inbounds { i16, i32 }, { i16, i32 }* %c, i32 0, i32 0, !dbg !61
  call void @llvm.dbg.declare(metadata i16* %5, metadata !51, metadata !DIExpression()), !dbg !61
  call fastcc void @bar(%Foo* sret %x), !dbg !61
  br label %WhileEnd, !dbg !57

WhileEnd:                                         ; preds = %WhileElse, %WhileBody
  call void @llvm.dbg.declare(metadata %Foo* %x, metadata !52, metadata !DIExpression()), !dbg !62
  ret void, !dbg !63
}
```
 2019-06-07 15:22:21 -04:00
Andrew Kelley
0e8b65c537
hook up peer result locs to if optional and if err 2019-06-07 14:49:26 -04:00
Andrew Kelley
ec17f4ebbe
fix behavior for peer result locs with one prong unreachable 2019-06-07 14:20:35 -04:00
Andrew Kelley
4c222a482f
fix behavior for non sret fn calls 2019-06-07 11:51:50 -04:00
Andrew Kelley
76a3938d69
no-copy semantics for peer result function calls 
```zig
export fn entry() void {
    var c = true;
    var x = if (c) foo() else bar();
}
```

```llvm
define void @entry() #2 !dbg !35 {
Entry:
  %c = alloca i1, align 1
  %x = alloca %Foo, align 4
  store i1 true, i1* %c, align 1, !dbg !47
  call void @llvm.dbg.declare(metadata i1* %c, metadata !39, metadata !DIExpression()), !dbg !48
  %0 = load i1, i1* %c, align 1, !dbg !49
  br i1 %0, label %Then, label %Else, !dbg !49

Then:                                             ; preds = %Entry
  call fastcc void @foo(%Foo* sret %x), !dbg !50
  br label %EndIf, !dbg !51

Else:                                             ; preds = %Entry
  call fastcc void @bar(%Foo* sret %x), !dbg !52
  br label %EndIf, !dbg !51

EndIf:                                            ; preds = %Else, %Then
  call void @llvm.dbg.declare(metadata %Foo* %x, metadata !42, metadata !DIExpression()), !dbg !53
  ret void, !dbg !54
}
```
 2019-06-07 11:34:47 -04:00
Andrew Kelley
b19b1c1298
no-copy semantics for switch expressions 
```zig
export fn entry() void {
    var c: i32 = 1234;
    var x = switch (c) {
        1 => u8(1),
        2...4 => u16(2),
        else => u32(3),
    };
}
```

```llvm
define void @entry() #2 !dbg !35 {
Entry:
  %c = alloca i32, align 4
  %x = alloca i32, align 4
  store i32 1234, i32* %c, align 4, !dbg !44
  call void @llvm.dbg.declare(metadata i32* %c, metadata !39, metadata !DIExpression()), !dbg !44
  %0 = load i32, i32* %c, align 4, !dbg !45
  %1 = icmp sge i32 %0, 2, !dbg !46
  %2 = icmp sle i32 %0, 4, !dbg !46
  %3 = and i1 %1, %2, !dbg !46
  br i1 %3, label %SwitchRangeYes, label %SwitchRangeNo, !dbg !46

SwitchRangeYes:                                   ; preds = %Entry
  br label %SwitchEnd, !dbg !45

SwitchElse:                                       ; preds = %SwitchRangeNo
  br label %SwitchEnd, !dbg !45

SwitchProng:                                      ; preds = %SwitchRangeNo
  br label %SwitchEnd, !dbg !45

SwitchEnd:                                        ; preds = %SwitchProng, %SwitchElse, %SwitchRangeYes
  %4 = phi i32 [ 2, %SwitchRangeYes ], [ 3, %SwitchElse ], [ 1, %SwitchProng ], !dbg !45
  store i32 %4, i32* %x, align 4, !dbg !45
  call void @llvm.dbg.declare(metadata i32* %x, metadata !42, metadata !DIExpression()), !dbg !47
  ret void, !dbg !48

SwitchRangeNo:                                    ; preds = %Entry
  switch i32 %0, label %SwitchElse [
    i32 1, label %SwitchProng
  ], !dbg !45
}
```
 2019-06-04 14:47:01 -04:00
Andrew Kelley
057b96006b
fix the rest of the ir_build_alloca_src callsites 
except for switch expressions
 2019-06-03 22:21:50 -04:00
Andrew Kelley
a32abcd365
no-copy semantics for if optional and if error union 
if expressions no longer introduce a stack allocation.

```zig
export fn entry() void {
    var x: anyerror!i32 = 1234;
    if (x) |i| {} else |e| {}
}
```

```llvm
define void @entry() #2 !dbg !39 {
Entry:
  %x = alloca { i16, i32 }, align 4
  %0 = bitcast { i16, i32 }* %x to i8*, !dbg !52
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %0, i8* align 4 bitcast ({ i16, i32 }* @0 to i8*), i64 8, i1 false), !dbg !52
  call void @llvm.dbg.declare(metadata { i16, i32 }* %x, metadata !43, metadata !DIExpression()), !dbg !52
  %1 = getelementptr inbounds { i16, i32 }, { i16, i32 }* %x, i32 0, i32 0, !dbg !53
  %2 = load i16, i16* %1, align 2, !dbg !53
  %3 = icmp ne i16 %2, 0, !dbg !53
  br i1 %3, label %TryElse, label %TryOk, !dbg !53

TryOk:                                            ; preds = %Entry
  %4 = getelementptr inbounds { i16, i32 }, { i16, i32 }* %x, i32 0, i32 1, !dbg !53
  call void @llvm.dbg.declare(metadata i32* %4, metadata !50, metadata !DIExpression()), !dbg !53
  br label %TryEnd, !dbg !53

TryElse:                                          ; preds = %Entry
  %5 = getelementptr inbounds { i16, i32 }, { i16, i32 }* %x, i32 0, i32 0, !dbg !53
  call void @llvm.dbg.declare(metadata i16* %5, metadata !51, metadata !DIExpression()), !dbg !53
  br label %TryEnd, !dbg !53

TryEnd:                                           ; preds = %TryElse, %TryOk
  ret void, !dbg !54
}
```
 2019-06-03 21:53:32 -04:00
Andrew Kelley
143d6ada8f
no-copy semantics for for loops 
Note that only the index variable requires a stack allocation, and the
memcpy for the element is gone.

```zig
export fn entry() void {
    var buf: [10]i32 = undefined;
    for (buf) |x| {}
}
```

```llvm
define void @entry() #2 !dbg !35 {
Entry:
  %buf = alloca [10 x i32], align 4
  %i = alloca i64, align 8
  %0 = bitcast [10 x i32]* %buf to i8*, !dbg !47
  call void @llvm.memset.p0i8.i64(i8* align 4 %0, i8 -86, i64 40, i1 false), !dbg !47
  call void @llvm.dbg.declare(metadata [10 x i32]* %buf, metadata !39, metadata !DIExpression()), !dbg !47
  store i64 0, i64* %i, align 8, !dbg !48
  call void @llvm.dbg.declare(metadata i64* %i, metadata !45, metadata !DIExpression()), !dbg !48
  br label %ForCond, !dbg !48

ForCond:                                          ; preds = %ForBody, %Entry
  %1 = load i64, i64* %i, align 8, !dbg !48
  %2 = icmp ult i64 %1, 10, !dbg !48
  br i1 %2, label %ForBody, label %ForEnd, !dbg !48

ForBody:                                          ; preds = %ForCond
  %3 = getelementptr inbounds [10 x i32], [10 x i32]* %buf, i64 0, i64 %1, !dbg !48
  call void @llvm.dbg.declare(metadata i32* %3, metadata !46, metadata !DIExpression()), !dbg !49
  %4 = add nuw i64 %1, 1, !dbg !48
  store i64 %4, i64* %i, align 8, !dbg !48
  br label %ForCond, !dbg !48

ForEnd:                                           ; preds = %ForCond
  ret void, !dbg !50
}
```
 2019-06-03 21:40:56 -04:00
Andrew Kelley
d4054e35fe
while loops 
Note that neither the payload capture variable nor the error capture
variable require a stack allocation.

```zig
export fn entry() void {
    var c: anyerror!i32 = 1234;
    while (c) |hi| {} else |e| {}
}
```

```llvm
define void @entry() #2 !dbg !39 {
Entry:
  %c = alloca { i16, i32 }, align 4
  %0 = bitcast { i16, i32 }* %c to i8*, !dbg !52
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %0, i8* align 4 bitcast ({ i16, i32 }* @0 to i8*), i64 8, i1 false), !dbg !52
  call void @llvm.dbg.declare(metadata { i16, i32 }* %c, metadata !43, metadata !DIExpression()), !dbg !52
  br label %WhileCond, !dbg !53

WhileCond:                                        ; preds = %WhileBody, %Entry
  %1 = getelementptr inbounds { i16, i32 }, { i16, i32 }* %c, i32 0, i32 0, !dbg !54
  %2 = load i16, i16* %1, align 2, !dbg !54
  %3 = icmp ne i16 %2, 0, !dbg !54
  br i1 %3, label %WhileElse, label %WhileBody, !dbg !54

WhileBody:                                        ; preds = %WhileCond
  %4 = getelementptr inbounds { i16, i32 }, { i16, i32 }* %c, i32 0, i32 1, !dbg !53
  call void @llvm.dbg.declare(metadata i32* %4, metadata !50, metadata !DIExpression()), !dbg !53
  br label %WhileCond, !dbg !53

WhileElse:                                        ; preds = %WhileCond
  %5 = getelementptr inbounds { i16, i32 }, { i16, i32 }* %c, i32 0, i32 0, !dbg !55
  call void @llvm.dbg.declare(metadata i16* %5, metadata !51, metadata !DIExpression()), !dbg !55
  ret void, !dbg !56
}
```
 2019-06-03 20:56:22 -04:00
Andrew Kelley
b6108eed52
fix alignment of consts 2019-06-03 19:11:41 -04:00
Andrew Kelley
eb8a132d23
var types, alignment, and comptime 2019-06-03 17:46:58 -04:00
Andrew Kelley
735543d502
add missing ir_expr_wrap calls 2019-06-03 15:44:53 -04:00
Andrew Kelley
ccce3d8526
no-copy semantics for function forwarding 
```zig
fn foo() Foo {
    return bar();
}
```

```llvm
define internal fastcc void @foo(%Foo* nonnull sret) unnamed_addr #2 !dbg !48 {
Entry:
  call fastcc void @bar(%Foo* sret %0), !dbg !52
  ret void, !dbg !54
}
```
 2019-05-31 01:36:57 -04:00
Andrew Kelley
461382ae94
no-copy semantics for function call init var and literal 
```zig
export fn entry() void {
    var x = foo();
}
const Foo = struct {
    x: i32,
};
fn foo() Foo {
    return Foo{
        .x = 1234,
    };
}
```

```llvm
define void @entry() #2 !dbg !35 {
Entry:
  %x = alloca %Foo, align 4
  call fastcc void @foo(%Foo* sret %x), !dbg !45
  call void @llvm.dbg.declare(metadata %Foo* %x, metadata !39, metadata !DIExpression()), !dbg !46
  ret void, !dbg !47
}
define internal fastcc void @foo(%Foo* nonnull sret) unnamed_addr #2 !dbg !48 {
Entry:
  %1 = bitcast %Foo* %0 to i8*, !dbg !52
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %1, i8* align 4 bitcast (%Foo* @0 to i8*), i64 4, i1 false), !dbg !52
  ret void, !dbg !52
}
```
 2019-05-31 01:08:16 -04:00
Andrew Kelley
8aba0643a5
peer result locations with mixed runtime/comptime 
```zig
export fn entry() void {
    var c = true;
    var a = u8(4);
    const x = if (c) a else u32(8);
}
```

```llvm
define void @entry() #2 !dbg !35 {
Entry:
  %c = alloca i1, align 1
  %a = alloca i8, align 1
  %x = alloca i32, align 4
  store i1 true, i1* %c, align 1, !dbg !45
  call void @llvm.dbg.declare(metadata i1* %c, metadata !39, metadata !DIExpression()), !dbg !46
  store i8 4, i8* %a, align 1, !dbg !47
  call void @llvm.dbg.declare(metadata i8* %a, metadata !42, metadata !DIExpression()), !dbg !48
  %0 = load i1, i1* %c, align 1, !dbg !49
  br i1 %0, label %Then, label %Else, !dbg !49

Then:                                             ; preds = %Entry
  %1 = load i8, i8* %a, align 1, !dbg !50
  %2 = zext i8 %1 to i32, !dbg !50
  br label %EndIf, !dbg !51

Else:                                             ; preds = %Entry
  br label %EndIf, !dbg !51

EndIf:                                            ; preds = %Else, %Then
  %3 = phi i32 [ %2, %Then ], [ 8, %Else ], !dbg !51
  store i32 %3, i32* %x, align 4, !dbg !51
  call void @llvm.dbg.declare(metadata i32* %x, metadata !43, metadata !DIExpression()), !dbg !52
  ret void, !dbg !53
}
```
 2019-05-31 00:54:10 -04:00
Andrew Kelley
3702c278e3
local consts with comptime init exprs 
```zig
export fn entry() void {
    const x = if (true) u8(4) else u32(8);
}
```

```llvm
define void @entry() #2 !dbg !35 {
Entry:
  call void @llvm.dbg.declare(metadata i8* @0, metadata !39, metadata !DIExpression()), !dbg !41
  ret void, !dbg !42
}
```
 2019-05-31 00:22:12 -04:00
Andrew Kelley
95d9835898
no-copy semantics for nested if 
```zig
export fn entry() void {
    var c = true;
    var x = if (c) u8(4) else if (c) u16(100) else u32(10);
}
```

```llvm
define void @entry() #2 !dbg !35 {
Entry:
  %c = alloca i1, align 1
  %x = alloca i32, align 4
  store i1 true, i1* %c, align 1, !dbg !44
  call void @llvm.dbg.declare(metadata i1* %c, metadata !39, metadata !DIExpression()), !dbg !45
  %0 = load i1, i1* %c, align 1, !dbg !46
  br i1 %0, label %Then2, label %Else, !dbg !46

Else:                                             ; preds = %Entry
  %1 = load i1, i1* %c, align 1, !dbg !47
  br i1 %1, label %Then, label %Else1, !dbg !47

Then:                                             ; preds = %Else
  br label %EndIf, !dbg !48

Else1:                                            ; preds = %Else
  br label %EndIf, !dbg !48

Then2:                                            ; preds = %Entry
  br label %EndIf3, !dbg !49

EndIf:                                            ; preds = %Else1, %Then
  %2 = phi i32 [ 100, %Then ], [ 10, %Else1 ], !dbg !48
  br label %EndIf3, !dbg !49

EndIf3:                                           ; preds = %EndIf, %Then2
  %3 = phi i32 [ 4, %Then2 ], [ %2, %EndIf ], !dbg !49
  store i32 %3, i32* %x, align 4, !dbg !49
  call void @llvm.dbg.declare(metadata i32* %x, metadata !42, metadata !DIExpression()), !dbg !50
  ret void, !dbg !51
}
```
 2019-05-30 23:25:37 -04:00
Andrew Kelley
a4aca78722
no-copy semantics for if expr 
```zig
export fn entry() void {
    var c = true;
    var x = if (c) u8(4) else u32(10);
}
```

```llvm
define void @entry() #2 !dbg !35 {
Entry:
  %c = alloca i1, align 1
  %x = alloca i32, align 4
  store i1 true, i1* %c, align 1, !dbg !44
  call void @llvm.dbg.declare(metadata i1* %c, metadata !39, metadata !DIExpression()), !dbg !45
  %0 = load i1, i1* %c, align 1, !dbg !46
  br i1 %0, label %Then, label %Else, !dbg !46

Then:                                             ; preds = %Entry
  br label %EndIf, !dbg !47

Else:                                             ; preds = %Entry
  br label %EndIf, !dbg !47

EndIf:                                            ; preds = %Else, %Then
  %1 = phi i32 [ 4, %Then ], [ 10, %Else ], !dbg !47
  store i32 %1, i32* %x, align 4, !dbg !47
  call void @llvm.dbg.declare(metadata i32* %x, metadata !42, metadata !DIExpression()), !dbg !48
  ret void, !dbg !49
}
```
 2019-05-30 23:16:11 -04:00
Andrew Kelley
5e1003bc81
no-copy semantics for basic runtime function call variable init 
```zig
export fn entry() void {
    var x: Foo = foo();
}
```

```llvm
define void @entry() #2 !dbg !37 {
Entry:
  %x = alloca %Foo, align 4
  call fastcc void @foo(%Foo* sret %x), !dbg !48
  call void @llvm.dbg.declare(metadata %Foo* %x, metadata !41, metadata !DIExpression()), !dbg !49
  ret void, !dbg !50
}
```
 2019-05-30 17:11:14 -04:00
Andrew Kelley
78f32259da
default struct field initialization expressions 
closes #485
 2019-05-30 15:46:11 -04:00
tgschultz
f9e7bd2682 std.meta/trait: def/definition => decl/declaration 
TypeInfo: defs/Definition => decls/Declarations
 2019-05-29 20:43:07 -04:00
Shawn Landden
4188faeac5 stage1: AstNodes cannot be casted, but are rather accessed via a union. 
Unlike IrInstruction[Foo]s, which all start with:
    IrInstruction base;
AstNodes do not work like this, and instead use a pointer to their
specializations. The code assumed otherwise.
 2019-05-29 20:21:07 -04:00
Andrew Kelley
1ccbd1fb67
use works on unions and enums in addition to structs 2019-05-29 16:31:49 -04:00
Andrew Kelley
b66438eb80
no "use of undeclared identifer" in dead comptime branches 2019-05-28 18:19:27 -04:00
Andrew Kelley
df7aa9a4f0
allow implicit optional pointer to optional c_void pointer 2019-05-26 17:55:20 -04:00
Andrew Kelley
269a53b6af
introduce @hasDecl builtin function 
closes #1439
 2019-05-26 16:21:03 -04:00
Andrew Kelley
21ed939117
support enum literals implicit casting to tagged unions 2019-05-26 12:59:30 -04:00
Robert Scott
9b7ad12481 Implement @unionInit 2019-05-24 01:48:45 -07:00
LemonBoy
6672ee9eb3 Fix too eager comptime evaluation of error ptr 2019-05-19 15:53:32 -04:00
Andrew Kelley
80983ca1ca
fixups to the previous commit 2019-05-16 16:37:58 -04:00
Shawn Landden
1fdb24827f
breaking changes to all bit manipulation intrinsics 
* `@clz`, `@ctz`, `@popCount`, `@bswap`, `@bitreverse` now
   have a type parameter
 * rename @bitreverse to @bitReverse
 * rename @bswap to @byteSwap

Closes #2119
Closes #2120
 2019-05-16 16:37:58 -04:00
Andrew Kelley
057a5d4898
slice types no longer have field access 
* fix crash when doing field access of slice types. closes #2486
 * remove the deprecated Child property from slice types
 * add -Dskip-non-native build option to build script
 2019-05-14 21:21:59 -04:00
Andrew Kelley
e93a05b6e4
switching on error sets makes new error set for capture values 
closes #769
 2019-05-14 19:11:37 -04:00
Andrew Kelley
c08c222d5e
fix regression on switch capture value for multiple cases 2019-05-14 18:25:14 -04:00
Andrew Kelley
df4f77024e
else value when switching on error set has 
optional capture value which is subset.

see #769
 2019-05-14 18:06:57 -04:00
Andrew Kelley
fee0e6c8b9
fix hang for some compile errors 
see #2467
 2019-05-10 16:39:50 -04:00
Michael Dusan
d065f297ab stage1: compile error for loop expr val ignored 
closes #2460
 2019-05-10 10:05:40 -04:00
Jimmi HC
6b10f03b4a Fixes and simplifications for stage 1 parser 2019-05-10 16:09:58 +02:00
Andrew Kelley
010963ce43
stage1: make some asserts print source location 2019-05-09 14:52:06 -04:00
Andrew Kelley
c459edac18
compile error for attempt to cast enum literal to error 
closes #2203
 2019-05-09 13:18:13 -04:00
Andrew Kelley
a4aee8b24d
C pointers support if and orelse 
See #1967
 2019-05-08 18:47:14 -04:00
Andrew Kelley
0099583bd3
C pointers support .? operator 
see #1967
 2019-05-08 17:39:00 -04:00