gitback/zig
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
5,466 Commits 1 Branch 0 Tags 279 MiB
1d2fc446bd
Commit Graph

5466 Commits

This Branch
This Branch
All Branches
Author SHA1 Message Date
Andrew Kelley
12b2950bf2
Merge pull request #2424 from daurnimator/single-linked-list 
Add SinglyLinkedList
 2019-06-10 09:54:03 -04:00
daurnimator
b0648bfbd3
std.heap.ArenaAllocator: use singly linked list 2019-06-10 15:41:40 +10:00
daurnimator
ddf7942aaa
std: Add singly linked list 2019-06-10 15:41:40 +10:00
daurnimator
ed41d10a06
std: existing LinkedList is actually a TailQueue 2019-06-10 15:41:40 +10:00
Andrew Kelley
b7811d3269
whitespace cleanup 2019-06-10 00:45:24 -04:00
Andrew Kelley
9c2ed8d103
Merge pull request #2525 from daurnimator/uring 
std: linux uring kernel interfaces
 2019-06-10 00:43:47 -04:00
SamTebbs33
6c160b8856 Add check for null body in if, for and while 2019-06-10 00:41:33 -04:00
daurnimator
4565f50efe
std: add linux kernel definitions for io_uring 2019-06-10 14:40:54 +10:00
daurnimator
ae604b4464
std: add linux kernel_rwf type and preadv2+pwritev2 2019-06-10 14:40:54 +10:00
daurnimator
a712a5515d
std: testing.expectEqual on structs now works 2019-06-10 14:39:44 +10:00
Andrew Kelley
39bc82561a
fix array literal syntax 2019-06-10 00:39:40 -04:00
daurnimator
ebedc99ac1
std: add math.isPowerOfTwo 2019-06-10 14:39:40 +10:00
Andrew Kelley
af35b73b99
Merge branch 'sfc64' of https://github.com/Sahnvour/zig into Sahnvour-sfc64 2019-06-10 00:38:58 -04:00
Andrew Kelley
5017a1d895 fix build on macos 2019-06-10 00:35:27 -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
Sahnvour
69d9f322ee implementation of the Sfc64 RNG from PractRand 2019-06-09 15:25:21 +02:00
Sahnvour
8e0670198b allow comptime_int in math.shl and math.shr 2019-06-09 14:44:41 +02:00
markfirmware
10e33b3536 grammar 2019-06-09 01:34:13 -04:00
Jonathan Pentecost
ad064b4a0b docs: update for else example 
Updates: #2614
 2019-06-08 22:58:31 -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
Shawn Landden
720ed74413 add bcmp implementation as LLVM 9 now emits those 
The optimizer will now convert calls to memcmp into a calls to bcmp
in some circumstances. Users who are building freestanding code (not
depending on the platform’s libc) without specifying -ffreestanding may
need to either pass -fno-builtin-bcmp, or provide a bcmp function.

http://llvm.org/docs/ReleaseNotes.html#non-comprehensive-list-of-changes-in-this-release
 2019-06-08 17:24:30 -04:00
Shritesh Bhattarai
404e4b0268 docs: add comment about for else and break 2019-06-08 16:21:46 -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
5784631fab
update the default macos version min to 10.14 2019-06-07 12:20:02 -04:00
Andrew Kelley
786f3cdd13
ci: let's try a new build of llvm+clang on 10.14 2019-06-07 12:07:23 -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
fb5e03b983
Merge pull request #2628 from emekoi/error-unexpected 
windows.unexpectedError prints a human friendly string
 2019-06-06 12:37:51 -04:00
Andrew Kelley
a682b0acb6
Merge pull request #2630 from squeek502/hashmap-pow2 
std.HashMap: optimize by taking advantage of power of two capacity
 2019-06-06 12:26:27 -04:00
Ryan Liptak
8f4229a61c std.HashMap: use std.math.ceilPowerOfTwo 2019-06-05 23:36:51 -07:00
Ryan Liptak
656ac43735 std.HashMap: optimize indexing by avoiding modulo operator 
x % y can be optimized if y is a power of two by doing x & (y-1) instead. HashMap already enforces power of two capacity, so we can take advantage of this optimization.
 2019-06-05 23:26:48 -07:00
emekoi
26613bfa01 switched to fixed-length buffer for error messages 2019-06-05 17:34:58 -05:00
emekoi
0288034c2f fixed mismatched types 2019-06-05 15:30:01 -05:00
emekoi
ddfab40e30 updated std.c.{freebsd, netbsd} to usingnamespace 2019-06-05 16:06:21 -04:00
emekoi
0aabfb09f9 removed duplicate definitions 2019-06-05 14:57:20 -05:00
emekoi
b74bcc9d76 windows.unexpectedError prints a human friendly string 2019-06-05 14:42:36 -05:00
mrkishi
fdddd13106 add cache-control headers to tarballs on ci 2019-06-04 23:25:24 -04:00
Andrew Kelley
ca989a95d3
Merge pull request #2617 from squeek502/ceil-power-of-two 
std.math: Add ceilPowerOfTwo and ceilPowerOfTwoPromote
 2019-06-04 23:24:34 -04:00
Ryan Liptak
a0d66fa1e6 std.math: Clarify ceilPowerOfTwo inputs and disallow zero as an input 2019-06-04 15:49:27 -07:00