Andrew Kelley
86f362ce8e
elide redundant safety check when switching on tagged unions
2019-06-22 16:18:42 -04:00
Shawn Landden
71e014caec
stage1: add @sin @cos @exp @exp2 @ln @log2 @log10 @fabs @floor @ceil @trunc @round
...
and expand @sqrt
This revealed that the accuracy of ln is not as good as the current algorithm in
musl and glibc, and should be ported again.
v2: actually include tests
v3: fix reversal of in and out arguments on f128M_sqrt()
add test for @sqrt on comptime_float
do not include @nearbyInt() until it works on all targets.
2019-06-22 14:34:34 -05:00
Andrew Kelley
142e77abbb
fix extern functions returning byval structs
2019-06-21 14:44:49 -04:00
Andrew Kelley
237233b04b
fix coroutines
2019-06-20 18:27:04 -04:00
Andrew Kelley
78eeb6e9ae
fix double getelementptr of runtime global
2019-06-19 22:29:39 -04:00
Andrew Kelley
04c25efe11
Merge remote-tracking branch 'origin/master' into copy-elision-3
2019-06-19 19:01:28 -04:00
Andrew Kelley
4ffab5b85f
fix optional pointer to size zero struct
2019-06-19 18:47:02 -04:00
Andrew Kelley
96931228af
fix comptime test error for empty error set
2019-06-19 16:29:46 -04:00
Andrew Kelley
974db231a0
fix extraneous nested union field instruction
2019-06-19 16:16:47 -04:00
Andrew Kelley
b588a803bf
fix comptime modification of const struct field
2019-06-19 14:35:59 -04:00
Shawn Landden
fce2d2d18b
stage1: add support for @mulAdd fused-multiply-add for floats and vectors of floats
...
Not all of the softfloat library is being built....
Vector support is very buggy at the moment, but should work when the bugs are fixed.
(as I had the same code working with another vector function, that hasn't been merged yet).
2019-06-19 12:07:02 -05:00
Andrew Kelley
e27da17ff2
back to many behavioral tests passing
2019-06-18 17:07:27 -04:00
Jonathan Marler
21dff1c4e2
Remove duplicate exe name with zig run
2019-06-17 14:10:10 -04:00
Andrew Kelley
b025193de5
inferred comptime values rather than elided scopes
...
because of this example:
```zig
export fn entry(b: bool) usize {
var runtime = [1]i32{3};
comptime var i: usize = 0;
inline while (i < 2) : (i += 1) {
const result = if (i == 0) [1]i32{2} else runtime;
}
comptime {
return i;
}
}
```
The problem is that the concept of "resetting" a result location,
introduced in the previous commit, cannot handle elision scopes.
This concept is inherently broken with inline loops.
2019-06-17 13:31:19 -04:00
Andrew Kelley
9564c05cd5
better result location handling of inline loops
2019-06-15 19:19:13 -04:00
Andrew Kelley
6bf193af19
better result location semantics with optionals and return locations
...
somewhere along this branch, #1901 has been fixed.
2019-06-15 12:28:21 -04:00
Andrew Kelley
60025a3704
Merge remote-tracking branch 'origin/master' into copy-elision-3
2019-06-15 10:34:04 -04:00
Andrew Kelley
7c5ceb0c4c
standard library integrates with knowledge of stripped debug info
2019-06-14 18:45:41 -04:00
Andrew Kelley
362c79140f
expose builtin.strip_debug_info
...
zig code now can be made aware that it will not have any debug
information available at runtime.
2019-06-14 18:18:43 -04:00
Andrew Kelley
f8f054b354
fix @export for arrays not respecting the symbol name
...
Previously, the symbol name parameter of `@export` would be ignored for
variables, and the variable name would be used for the symbol name.
Now it works as expected.
See #2679
2019-06-14 17:23:24 -04:00
Andrew Kelley
2ba29a1907
fix peer result location with error code and payload
2019-06-14 11:01:38 -04:00
emekoi
3ed6acd2d2
fixed infinite loop when caching packages
2019-06-11 19:19:44 -05:00
emekoi
e12c7d88b2
made root package available to itself
2019-06-11 16:06:24 -05:00
emekoi
4ea7685a5b
made root package available to all other packages
2019-06-11 16:05:56 -05:00
Andrew Kelley
b3a4ec1bd2
fix returning scalar values
...
```zig
export fn entry1() i32 {
return bar();
}
```
```llvm
define i32 @entry1() #2 !dbg !35 {
Entry:
%0 = call fastcc i32 @bar(), !dbg !39
ret i32 %0, !dbg !41
}
```
2019-06-11 16:04:04 -04:00
Andrew Kelley
e1d14e73b5
fix @bitCast semantics when there is no parent result loc
2019-06-11 15:44:06 -04:00
Andrew Kelley
fc8d881240
fix struct and array init when result casted to anyerror!?T
2019-06-11 13:27:01 -04:00
Andrew Kelley
06f307ff77
fix implicit casting return value struct/arary init to optional
2019-06-11 12:19:57 -04:00
Andrew Kelley
7411a88d5f
fix comptime function calls
2019-06-11 00:27:10 -04:00
Andrew Kelley
d504318f2e
remove the final legacy stack allocation
2019-06-10 23:54:28 -04:00
Andrew Kelley
f6d4e2565e
use result loc for ref instruction
2019-06-10 23:51:43 -04:00
Andrew Kelley
4582ec518f
result location semantics for vector to array
...
```zig
export fn entry() void {
var x: @Vector(4, i32) = undefined;
var y: [4]i32 = x;
}
```
```llvm
define void @entry() #2 !dbg !35 {
Entry:
%x = alloca <4 x i32>, align 16
%y = alloca [4 x i32], align 4
%0 = bitcast <4 x i32>* %x to i8*, !dbg !47
call void @llvm.memset.p0i8.i64(i8* align 16 %0, i8 -86, i64 16, i1 false), !dbg !47
call void @llvm.dbg.declare(metadata <4 x i32>* %x, metadata !39 , metadata !DIExpression()), !dbg !47
%1 = load <4 x i32>, <4 x i32>* %x, align 16, !dbg !48
%2 = bitcast [4 x i32]* %y to <4 x i32>*, !dbg !48
store <4 x i32> %1, <4 x i32>* %2, align 16, !dbg !48
call void @llvm.dbg.declare(metadata [4 x i32]* %y, metadata !45 , metadata !DIExpression()), !dbg !49
ret void, !dbg !50
}
```
2019-06-10 19:49:24 -04:00
Andrew Kelley
9a324ecb42
result loc semantics for loading packed struct pointer to packed struct
...
```zig
export fn entry() void {
var x = foo();
var ptr = &x.b;
var y = ptr.*;
}
const Foo = packed struct {
a: u24 = 1,
b: Bar = Bar{},
};
const Bar = packed struct {
a: u4 = 2,
b: u4 = 3,
};
```
```llvm
define void @entry() #2 !dbg !35 {
Entry:
%x = alloca %Foo, align 1
%ptr = alloca i32*, align 8
%y = alloca %Bar, align 1
call fastcc void @foo(%Foo* sret %x), !dbg !55
call void @llvm.dbg.declare(metadata %Foo* %x, metadata !39 , metadata !DIExpression()), !dbg !56
%0 = getelementptr inbounds %Foo, %Foo* %x, i32 0, i32 0, !dbg !57
store i32* %0, i32** %ptr, align 8, !dbg !57
call void @llvm.dbg.declare(metadata i32** %ptr, metadata !51 , metadata !DIExpression()), !dbg !58
%1 = load i32*, i32** %ptr, align 8, !dbg !59
%2 = load i32, i32* %1, align 1, !dbg !60
%3 = lshr i32 %2, 24, !dbg !60
%4 = trunc i32 %3 to i8, !dbg !60
%5 = bitcast %Bar* %y to i8*, !dbg !60
store i8 %4, i8* %5, !dbg !60
call void @llvm.dbg.declare(metadata %Bar* %y, metadata !54 , metadata !DIExpression()), !dbg !61
ret void, !dbg !62
}
```
2019-06-10 19:11:34 -04:00
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
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
5784631fab
update the default macos version min to 10.14
2019-06-07 12:20:02 -04:00
LemonBoy
80cd142c96
Propagate DIFlags to LLVM
2019-06-04 09:05:33 +02:00
LemonBoy
ebe921e48f
Make void a signed type
...
Follow the convention set by C so that lldb stops complaining about it.
2019-06-04 09:05:12 +02: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
