Andrew Kelley
65f6ea66f4
result loc semantics for @sliceToBytes and @bytesToSlice
2019-06-10 18:34:27 -04:00
Andrew Kelley
ee3f7e20f6
result location semantics for cmpxchg
2019-06-10 17:49:36 -04:00
Andrew Kelley
b9c033ae1a
result location semantics for error union wrapping an error
2019-06-10 17:28:25 -04:00
Andrew Kelley
4f085b8d2c
result location semantics for error union wrapping a payload
2019-06-10 16:55:07 -04:00
Andrew Kelley
eaa9d8bdac
result location semantics for optional wrap
2019-06-10 16:20:13 -04:00
Andrew Kelley
c362895116
result location semantics for slices
...
```zig
export fn entry() void {
var buf: [10]u8 = undefined;
const slice1: []const u8 = &buf;
const slice2 = buf[0..];
}
```
```llvm
define void @entry() #2 !dbg !35 {
Entry:
%buf = alloca [10 x i8], align 1
%slice1 = alloca %"[]u8", align 8
%slice2 = alloca %"[]u8", align 8
%0 = bitcast [10 x i8]* %buf to i8*, !dbg !46
call void @llvm.memset.p0i8.i64(i8* align 1 %0, i8 -86, i64 10, i1 false), !dbg !46
call void @llvm.dbg.declare(metadata [10 x i8]* %buf, metadata !39 , metadata !DIExpression()), !dbg !46
%1 = getelementptr inbounds %"[]u8", %"[]u8"* %slice1, i32 0, i32 0, !dbg !47
%2 = getelementptr inbounds [10 x i8], [10 x i8]* %buf, i64 0, i64 0, !dbg !47
store i8* %2, i8** %1, align 8, !dbg !47
%3 = getelementptr inbounds %"[]u8", %"[]u8"* %slice1, i32 0, i32 1, !dbg !47
store i64 10, i64* %3, align 8, !dbg !47
call void @llvm.dbg.declare(metadata %"[]u8"* %slice1, metadata !44 , metadata !DIExpression()), !dbg !48
%4 = getelementptr inbounds %"[]u8", %"[]u8"* %slice2, i32 0, i32 0, !dbg !49
%5 = getelementptr inbounds [10 x i8], [10 x i8]* %buf, i64 0, i64 0, !dbg !49
store i8* %5, i8** %4, align 8, !dbg !49
%6 = getelementptr inbounds %"[]u8", %"[]u8"* %slice2, i32 0, i32 1, !dbg !49
store i64 10, i64* %6, align 8, !dbg !49
call void @llvm.dbg.declare(metadata %"[]u8"* %slice2, metadata !45 , metadata !DIExpression()), !dbg !50
ret void, !dbg !51
}
```
2019-06-10 15:49:45 -04:00
Andrew Kelley
17b1ac5d03
result location semantics for @bitCast
...
```zig
export fn entry() void {
var x = @bitCast(f32, foo());
}
```
```llvm
define void @entry() #2 !dbg !35 {
Entry:
%x = alloca float, align 4
%0 = bitcast float* %x to %Foo*, !dbg !42
call fastcc void @foo(%Foo* sret %0), !dbg !42
call void @llvm.dbg.declare(metadata float* %x, metadata !39 , metadata !DIExpression()), !dbg !43
ret void, !dbg !44
}
```
2019-06-10 12:24:19 -04:00
Andrew Kelley
1a51bf6304
hook up result locations for union initializations
...
```zig
export fn entry() void {
var x = Foo{ .bar = bar() };
}
```
```llvm
define void @entry() #2 !dbg !44 {
Entry:
%x = alloca %Foo, align 4
%0 = getelementptr inbounds %Foo, %Foo* %x, i32 0, i32 1, !dbg !68
store i1 true, i1* %0, align 1, !dbg !68
%1 = getelementptr inbounds %Foo, %Foo* %x, i32 0, i32 0, !dbg !68
%2 = bitcast { i32, [4 x i8] }* %1 to %Bar*, !dbg !68
call fastcc void @bar(%Bar* sret %2), !dbg !68
call void @llvm.dbg.declare(metadata %Foo* %x, metadata !48 , metadata !DIExpression()), !dbg !69
ret void, !dbg !70
}
```
2019-06-10 11:15:32 -04:00
Andrew Kelley
4e2b2822f1
inferred array size of array literals works
2019-06-09 19:55:15 -04:00
Andrew Kelley
3a4b749c8a
Merge remote-tracking branch 'origin/master' into copy-elision-3
2019-06-09 19:44:01 -04:00
Andrew Kelley
b735764898
different array literal syntax when inferring the size
...
old syntax: []i32{1, 2, 3}
new syntax: [_]i32{1, 2, 3}
closes #1797
2019-06-09 19:26:32 -04:00
Andrew Kelley
59fe13772f
result loc semantics for array initialization
...
```zig
export fn entry() void {
var x = [3]Bar{ bar(), bar(), Bar{ .y = 12 } };
}
```
```llvm
define void @entry() #2 !dbg !35 {
Entry:
%x = alloca [3 x %Bar], align 4
%0 = getelementptr inbounds [3 x %Bar], [3 x %Bar]* %x, i64 0, i64 0, !dbg !48
call fastcc void @bar(%Bar* sret %0), !dbg !48
%1 = getelementptr inbounds [3 x %Bar], [3 x %Bar]* %x, i64 0, i64 1, !dbg !49
call fastcc void @bar(%Bar* sret %1), !dbg !49
%2 = getelementptr inbounds [3 x %Bar], [3 x %Bar]* %x, i64 0, i64 2, !dbg !50
%3 = bitcast %Bar* %2 to i8*, !dbg !50
call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %3, i8* align 4 bitcast (%Bar* @0 to i8*), i64 4, i1 false), !dbg !50
call void @llvm.dbg.declare(metadata [3 x %Bar]* %x, metadata !39 , metadata !DIExpression()), !dbg !51
ret void, !dbg !52
}
```
2019-06-09 12:03:15 -04:00
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
