Commit a94304d3e4b9220d2b22501eb2666e5aa89df236 | zig

CMakeLists.txt+1

...	@@ -596,6 +596,7 @@ set(ZIG_STD_FILES	...	@@ -596,6 +596,7 @@ set(ZIG_STD_FILES
596	"os/windows/ntdll.zig"	596	"os/windows/ntdll.zig"
597	"os/windows/ole32.zig"	597	"os/windows/ole32.zig"
598	"os/windows/shell32.zig"	598	"os/windows/shell32.zig"
		599	"os/windows/tls.zig"
599	"os/windows/util.zig"	600	"os/windows/util.zig"
600	"os/zen.zig"	601	"os/zen.zig"
601	"pdb.zig"	602	"pdb.zig"

build.zig+27-8

 @@ -16,7 +16,10 @@ pub fn build(b: *Builder) !void {
     var docgen_exe = b.addExecutable("docgen", "doc/docgen.zig");
     const rel_zig_exe = try os.path.relative(b.allocator, b.build_root, b.zig_exe);
-    const langref_out_path = os.path.join(b.allocator, b.cache_root, "langref.html") catch unreachable;
+    const langref_out_path = os.path.join(
+        b.allocator,
+        [][]const u8{ b.cache_root, "langref.html" },
+    ) catch unreachable;
     var docgen_cmd = b.addCommand(null, b.env_map, [][]const u8{
         docgen_exe.getOutputPath(),
         rel_zig_exe,
 @@ -125,13 +128,19 @@ fn dependOnLib(b: *Builder, lib_exe_obj: var, dep: LibraryDep) void {
     for (dep.libdirs.toSliceConst()) |lib_dir| {
         lib_exe_obj.addLibPath(lib_dir);
     }
-    const lib_dir = os.path.join(b.allocator, dep.prefix, "lib") catch unreachable;
+    const lib_dir = os.path.join(
+        b.allocator,
+        [][]const u8{ dep.prefix, "lib" },
+    ) catch unreachable;
     for (dep.system_libs.toSliceConst()) |lib| {
         const static_bare_name = if (mem.eql(u8, lib, "curses"))
             ([]const u8)("libncurses.a")
         else
             b.fmt("lib{}.a", lib);
-        const static_lib_name = os.path.join(b.allocator, lib_dir, static_bare_name) catch unreachable;
+        const static_lib_name = os.path.join(
+            b.allocator,
+            [][]const u8{ lib_dir, static_bare_name },
+        ) catch unreachable;
         const have_static = fileExists(static_lib_name) catch unreachable;
         if (have_static) {
             lib_exe_obj.addObjectFile(static_lib_name);
 @@ -159,7 +168,11 @@ fn fileExists(filename: []const u8) !bool {
 fn addCppLib(b: *Builder, lib_exe_obj: var, cmake_binary_dir: []const u8, lib_name: []const u8) void {
     const lib_prefix = if (lib_exe_obj.target.isWindows()) "" else "lib";
-    lib_exe_obj.addObjectFile(os.path.join(b.allocator, cmake_binary_dir, "zig_cpp", b.fmt("{}{}{}", lib_prefix, lib_name, lib_exe_obj.target.libFileExt())) catch unreachable);
+    lib_exe_obj.addObjectFile(os.path.join(b.allocator, [][]const u8{
+        cmake_binary_dir,
+        "zig_cpp",
+        b.fmt("{}{}{}", lib_prefix, lib_name, lib_exe_obj.target.libFileExt()),
+    }) catch unreachable);
 }
 const LibraryDep = struct {
 @@ -235,8 +248,11 @@ fn findLLVM(b: *Builder, llvm_config_exe: []const u8) !LibraryDep {
 pub fn installStdLib(b: *Builder, stdlib_files: []const u8) void {
     var it = mem.tokenize(stdlib_files, ";");
     while (it.next()) |stdlib_file| {
-        const src_path = os.path.join(b.allocator, "std", stdlib_file) catch unreachable;
+        const src_path = os.path.join(b.allocator, [][]const u8{ "std", stdlib_file }) catch unreachable;
-        const dest_path = os.path.join(b.allocator, "lib", "zig", "std", stdlib_file) catch unreachable;
+        const dest_path = os.path.join(
+            b.allocator,
+            [][]const u8{ "lib", "zig", "std", stdlib_file },
+        ) catch unreachable;
         b.installFile(src_path, dest_path);
     }
 }
 @@ -244,8 +260,11 @@ pub fn installStdLib(b: *Builder, stdlib_files: []const u8) void {
 pub fn installCHeaders(b: *Builder, c_header_files: []const u8) void {
     var it = mem.tokenize(c_header_files, ";");
     while (it.next()) |c_header_file| {
-        const src_path = os.path.join(b.allocator, "c_headers", c_header_file) catch unreachable;
+        const src_path = os.path.join(b.allocator, [][]const u8{ "c_headers", c_header_file }) catch unreachable;
-        const dest_path = os.path.join(b.allocator, "lib", "zig", "include", c_header_file) catch unreachable;
+        const dest_path = os.path.join(
+            b.allocator,
+            [][]const u8{ "lib", "zig", "include", c_header_file },
+        ) catch unreachable;
         b.installFile(src_path, dest_path);
     }
 }

doc/docgen.zig+20-5

 @@ -990,13 +990,19 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: var
                 try tokenizeAndPrint(tokenizer, out, code.source_token);
                 try out.write("</pre>");
                 const name_plus_ext = try std.fmt.allocPrint(allocator, "{}.zig", code.name);
-                const tmp_source_file_name = try os.path.join(allocator, tmp_dir_name, name_plus_ext);
+                const tmp_source_file_name = try os.path.join(
+                    allocator,
+                    [][]const u8{ tmp_dir_name, name_plus_ext },
+                );
                 try io.writeFile(tmp_source_file_name, trimmed_raw_source);
                 switch (code.id) {
                     Code.Id.Exe => |expected_outcome| {
                         const name_plus_bin_ext = try std.fmt.allocPrint(allocator, "{}{}", code.name, exe_ext);
-                        const tmp_bin_file_name = try os.path.join(allocator, tmp_dir_name, name_plus_bin_ext);
+                        const tmp_bin_file_name = try os.path.join(
+                            allocator,
+                            [][]const u8{ tmp_dir_name, name_plus_bin_ext },
+                        );
                         var build_args = std.ArrayList([]const u8).init(allocator);
                         defer build_args.deinit();
                         try build_args.appendSlice([][]const u8{
 @@ -1024,7 +1030,10 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: var
                         }
                         for (code.link_objects) |link_object| {
                             const name_with_ext = try std.fmt.allocPrint(allocator, "{}{}", link_object, obj_ext);
-                            const full_path_object = try os.path.join(allocator, tmp_dir_name, name_with_ext);
+                            const full_path_object = try os.path.join(
+                                allocator,
+                                [][]const u8{ tmp_dir_name, name_with_ext },
+                            );
                             try build_args.append("--object");
                             try build_args.append(full_path_object);
                             try out.print(" --object {}", name_with_ext);
 @@ -1216,12 +1225,18 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: var
                     },
                     Code.Id.Obj => |maybe_error_match| {
                         const name_plus_obj_ext = try std.fmt.allocPrint(allocator, "{}{}", code.name, obj_ext);
-                        const tmp_obj_file_name = try os.path.join(allocator, tmp_dir_name, name_plus_obj_ext);
+                        const tmp_obj_file_name = try os.path.join(
+                            allocator,
+                            [][]const u8{ tmp_dir_name, name_plus_obj_ext },
+                        );
                         var build_args = std.ArrayList([]const u8).init(allocator);
                         defer build_args.deinit();
                         const name_plus_h_ext = try std.fmt.allocPrint(allocator, "{}.h", code.name);
-                        const output_h_file_name = try os.path.join(allocator, tmp_dir_name, name_plus_h_ext);
+                        const output_h_file_name = try os.path.join(
+                            allocator,
+                            [][]const u8{ tmp_dir_name, name_plus_h_ext },
+                        );
                         try build_args.appendSlice([][]const u8{
                             zig_exe,

doc/langref.html.in+15-6

 @@ -3192,7 +3192,16 @@ fn foo() void { }
       {#code_end#}
       {#header_open|Pass-by-value Parameters#}
       <p>
-      In Zig, structs, unions, and enums with payloads can be passed directly to a function:
+      Primitive types such as {#link|Integers#} and {#link|Floats#} passed as parameters
+      are copied, and then the copy is available in the function body. This is called "passing by value".
+      Copying a primitive type is essentially free and typically involves nothing more than
+      setting a register.
+      </p>
+      <p>
+      Structs, unions, and arrays can sometimes be more efficiently passed as a reference, since a copy
+      could be arbitrarily expensive depending on the size. When these types are passed
+      as parameters, Zig may choose to copy and pass by value, or pass by reference, whichever way
+      Zig decides will be faster. This is made possible, in part, by the fact that parameters are immutable.
       </p>
       {#code_begin|test#}
 const Point = struct {
 @@ -3201,20 +3210,20 @@ const Point = struct {
 };
 fn foo(point: Point) i32 {
+    // Here, `point` could be a reference, or a copy. The function body
+    // can ignore the difference and treat it as a value. Be very careful
+    // taking the address of the parameter - it should be treated as if
+    // the address will become invalid when the function returns.
     return point.x + point.y;
 }
 const assert = @import("std").debug.assert;
-test "pass aggregate type by non-copy value to function" {
+test "pass struct to function" {
     assert(foo(Point{ .x = 1, .y = 2 }) == 3);
 }
       {#code_end#}
       <p>
-      In this case, the value may be passed by reference, or by value, whichever way
-      Zig decides will be faster.
-      </p>
-      <p>
       For extern functions, Zig follows the C ABI for passing structs and unions by value.
       </p>
       {#header_close#}

doc/targets.md deleted-15

...	@@ -1,15 +0,0 @@
1	# How to Add Support For More Targets
2
3	Create bootstrap code in std/bootstrap.zig and add conditional compilation
4	logic. This code is responsible for the real executable entry point, calling
5	main() and making the exit syscall when main returns.
6
7	How to pass a byvalue struct parameter in the C calling convention is
8	target-specific. Add logic for how to do function prototypes and function calls
9	for the target when an exported or external function has a byvalue struct.
10
11	Write the target-specific code in the standard library.
12
13	Update the C integer types to be the correct size for the target.
14
15	Make sure that `c_longdouble` codegens the correct floating point value.

src-self-hosted/compilation.zig+3-3

src-self-hosted/introspect.zig+2-2

...	@@ -8,10 +8,10 @@ const warn = std.debug.warn;	...	@@ -8,10 +8,10 @@ const warn = std.debug.warn;
8		8
9	/// Caller must free result	9	/// Caller must free result
10	pub fn testZigInstallPrefix(allocator: *mem.Allocator, test_path: []const u8) ![]u8 {	10	pub fn testZigInstallPrefix(allocator: *mem.Allocator, test_path: []const u8) ![]u8 {
11	const test_zig_dir = try os.path.join(allocator, test_path, "lib", "zig");	11	const test_zig_dir = try os.path.join(allocator, [][]const u8{ test_path, "lib", "zig" });
12	errdefer allocator.free(test_zig_dir);	12	errdefer allocator.free(test_zig_dir);
13		13
14	const test_index_file = try os.path.join(allocator, test_zig_dir, "std", "index.zig");	14	const test_index_file = try os.path.join(allocator, [][]const u8{ test_zig_dir, "std", "index.zig" });
15	defer allocator.free(test_index_file);	15	defer allocator.free(test_index_file);
16		16
17	var file = try os.File.openRead(test_index_file);	17	var file = try os.File.openRead(test_index_file);

src-self-hosted/libc_installation.zig+13-4

 @@ -230,7 +230,7 @@ pub const LibCInstallation = struct {
         while (path_i < search_paths.len) : (path_i += 1) {
             const search_path_untrimmed = search_paths.at(search_paths.len - path_i - 1);
             const search_path = std.mem.trimLeft(u8, search_path_untrimmed, " ");
-            const stdlib_path = try std.os.path.join(loop.allocator, search_path, "stdlib.h");
+            const stdlib_path = try std.os.path.join(loop.allocator, [][]const u8{ search_path, "stdlib.h" });
             defer loop.allocator.free(stdlib_path);
             if (try fileExists(stdlib_path)) {
 @@ -254,7 +254,10 @@ pub const LibCInstallation = struct {
             const stream = &std.io.BufferOutStream.init(&result_buf).stream;
             try stream.print("{}\\Include\\{}\\ucrt", search.path, search.version);
-            const stdlib_path = try std.os.path.join(loop.allocator, result_buf.toSliceConst(), "stdlib.h");
+            const stdlib_path = try std.os.path.join(
+                loop.allocator,
+                [][]const u8{ result_buf.toSliceConst(), "stdlib.h" },
+            );
             defer loop.allocator.free(stdlib_path);
             if (try fileExists(stdlib_path)) {
 @@ -283,7 +286,10 @@ pub const LibCInstallation = struct {
                 builtin.Arch.aarch64v8 => try stream.write("arm"),
                 else => return error.UnsupportedArchitecture,
             }
-            const ucrt_lib_path = try std.os.path.join(loop.allocator, result_buf.toSliceConst(), "ucrt.lib");
+            const ucrt_lib_path = try std.os.path.join(
+                loop.allocator,
+                [][]const u8{ result_buf.toSliceConst(), "ucrt.lib" },
+            );
             defer loop.allocator.free(ucrt_lib_path);
             if (try fileExists(ucrt_lib_path)) {
                 self.lib_dir = result_buf.toOwnedSlice();
 @@ -358,7 +364,10 @@ pub const LibCInstallation = struct {
                 builtin.Arch.aarch64v8 => try stream.write("arm\\"),
                 else => return error.UnsupportedArchitecture,
             }
-            const kernel32_path = try std.os.path.join(loop.allocator, result_buf.toSliceConst(), "kernel32.lib");
+            const kernel32_path = try std.os.path.join(
+                loop.allocator,
+                [][]const u8{ result_buf.toSliceConst(), "kernel32.lib" },
+            );
             defer loop.allocator.free(kernel32_path);
             if (try fileExists(kernel32_path)) {
                 self.kernel32_lib_dir = result_buf.toOwnedSlice();

src-self-hosted/link.zig+1-1

...	@@ -315,7 +315,7 @@ fn constructLinkerArgsElf(ctx: *Context) !void {	...	@@ -315,7 +315,7 @@ fn constructLinkerArgsElf(ctx: *Context) !void {
315	}	315	}
316		316
317	fn addPathJoin(ctx: *Context, dirname: []const u8, basename: []const u8) !void {	317	fn addPathJoin(ctx: *Context, dirname: []const u8, basename: []const u8) !void {
318	const full_path = try std.os.path.join(&ctx.arena.allocator, dirname, basename);	318	const full_path = try std.os.path.join(&ctx.arena.allocator, [][]const u8{ dirname, basename });
319	const full_path_with_null = try std.cstr.addNullByte(&ctx.arena.allocator, full_path);	319	const full_path_with_null = try std.cstr.addNullByte(&ctx.arena.allocator, full_path);
320	try ctx.args.append(full_path_with_null.ptr);	320	try ctx.args.append(full_path_with_null.ptr);
321	}	321	}

src-self-hosted/main.zig+1-1

...	@@ -757,7 +757,7 @@ async fn fmtPath(fmt: *Fmt, file_path_ref: []const u8, check_mode: bool) FmtErro	...	@@ -757,7 +757,7 @@ async fn fmtPath(fmt: *Fmt, file_path_ref: []const u8, check_mode: bool) FmtErro
757	var group = event.Group(FmtError!void).init(fmt.loop);	757	var group = event.Group(FmtError!void).init(fmt.loop);
758	while (try dir.next()) \|entry\| {	758	while (try dir.next()) \|entry\| {
759	if (entry.kind == std.os.Dir.Entry.Kind.Directory or mem.endsWith(u8, entry.name, ".zig")) {	759	if (entry.kind == std.os.Dir.Entry.Kind.Directory or mem.endsWith(u8, entry.name, ".zig")) {
760	const full_path = try os.path.join(fmt.loop.allocator, file_path, entry.name);	760	const full_path = try os.path.join(fmt.loop.allocator, [][]const u8{ file_path, entry.name });
761	try group.call(fmtPath, fmt, full_path, check_mode);	761	try group.call(fmtPath, fmt, full_path, check_mode);
762	}	762	}
763	}	763	}

src-self-hosted/test.zig+2-2

...	@@ -87,7 +87,7 @@ pub const TestContext = struct {	...	@@ -87,7 +87,7 @@ pub const TestContext = struct {
87	) !void {	87	) !void {
88	var file_index_buf: [20]u8 = undefined;	88	var file_index_buf: [20]u8 = undefined;
89	const file_index = try std.fmt.bufPrint(file_index_buf[0..], "{}", self.file_index.incr());	89	const file_index = try std.fmt.bufPrint(file_index_buf[0..], "{}", self.file_index.incr());
90	const file1_path = try std.os.path.join(allocator, tmp_dir_name, file_index, file1);	90	const file1_path = try std.os.path.join(allocator, [][]const u8{ tmp_dir_name, file_index, file1 });
91		91
92	if (std.os.path.dirname(file1_path)) \|dirname\| {	92	if (std.os.path.dirname(file1_path)) \|dirname\| {
93	try std.os.makePath(allocator, dirname);	93	try std.os.makePath(allocator, dirname);
...	@@ -120,7 +120,7 @@ pub const TestContext = struct {	...	@@ -120,7 +120,7 @@ pub const TestContext = struct {
120	) !void {	120	) !void {
121	var file_index_buf: [20]u8 = undefined;	121	var file_index_buf: [20]u8 = undefined;
122	const file_index = try std.fmt.bufPrint(file_index_buf[0..], "{}", self.file_index.incr());	122	const file_index = try std.fmt.bufPrint(file_index_buf[0..], "{}", self.file_index.incr());
123	const file1_path = try std.os.path.join(allocator, tmp_dir_name, file_index, file1);	123	const file1_path = try std.os.path.join(allocator, [][]const u8{ tmp_dir_name, file_index, file1 });
124		124
125	const output_file = try std.fmt.allocPrint(allocator, "{}-out{}", file1_path, Target(Target.Native).exeFileExt());	125	const output_file = try std.fmt.allocPrint(allocator, "{}-out{}", file1_path, Target(Target.Native).exeFileExt());
126	if (std.os.path.dirname(file1_path)) \|dirname\| {	126	if (std.os.path.dirname(file1_path)) \|dirname\| {

src/all_types.hpp+8-5

 @@ -544,12 +544,7 @@ struct AstNodeDefer {
 };
 struct AstNodeVariableDeclaration {
-    VisibMod visib_mod;
     Buf *symbol;
-    bool is_const;
-    bool is_comptime;
-    bool is_export;
-    bool is_extern;
     // one or both of type and expr will be non null
     AstNode *type;
     AstNode *expr;
 @@ -559,6 +554,13 @@ struct AstNodeVariableDeclaration {
     AstNode *align_expr;
     // populated if the "section(S)" is present
     AstNode *section_expr;
+    Token *threadlocal_tok;
+    VisibMod visib_mod;
+    bool is_const;
+    bool is_comptime;
+    bool is_export;
+    bool is_extern;
 };
 struct AstNodeTestDecl {
 @@ -1873,6 +1875,7 @@ struct ZigVar {
     bool shadowable;
     bool src_is_const;
     bool gen_is_const;
+    bool is_thread_local;
 };
 struct ErrorTableEntry {

src/analyze.cpp+45-24

 @@ -28,28 +28,10 @@ static Error ATTRIBUTE_MUST_USE resolve_enum_zero_bits(CodeGen *g, ZigType *enum
 static Error ATTRIBUTE_MUST_USE resolve_union_zero_bits(CodeGen *g, ZigType *union_type);
 static void analyze_fn_body(CodeGen *g, ZigFn *fn_table_entry);
-ErrorMsg *add_node_error(CodeGen *g, AstNode *node, Buf *msg) {
+static ErrorMsg *add_error_note_token(CodeGen *g, ErrorMsg *parent_msg, ImportTableEntry *owner, Token *token,
-    if (node->owner->c_import_node != nullptr) {
+        Buf *msg)
-        // if this happens, then translate_c generated code that
+{
-        // failed semantic analysis, which isn't supposed to happen
+    if (owner->c_import_node != nullptr) {
-        ErrorMsg *err = add_node_error(g, node->owner->c_import_node,
-            buf_sprintf("compiler bug: @cImport generated invalid zig code"));
-        add_error_note(g, err, node, msg);
-        g->errors.append(err);
-        return err;
-    }
-    ErrorMsg *err = err_msg_create_with_line(node->owner->path, node->line, node->column,
-            node->owner->source_code, node->owner->line_offsets, msg);
-    g->errors.append(err);
-    return err;
-}
-ErrorMsg *add_error_note(CodeGen *g, ErrorMsg *parent_msg, AstNode *node, Buf *msg) {
-    if (node->owner->c_import_node != nullptr) {
         // if this happens, then translate_c generated code that
         // failed semantic analysis, which isn't supposed to happen
 @@ -64,13 +46,46 @@ ErrorMsg *add_error_note(CodeGen *g, ErrorMsg *parent_msg, AstNode *node, Buf *m
         return note;
     }
-    ErrorMsg *err = err_msg_create_with_line(node->owner->path, node->line, node->column,
+    ErrorMsg *err = err_msg_create_with_line(owner->path, token->start_line, token->start_column,
-            node->owner->source_code, node->owner->line_offsets, msg);
+            owner->source_code, owner->line_offsets, msg);
     err_msg_add_note(parent_msg, err);
     return err;
 }
+ErrorMsg *add_token_error(CodeGen *g, ImportTableEntry *owner, Token *token, Buf *msg) {
+    if (owner->c_import_node != nullptr) {
+        // if this happens, then translate_c generated code that
+        // failed semantic analysis, which isn't supposed to happen
+        ErrorMsg *err = add_node_error(g, owner->c_import_node,
+            buf_sprintf("compiler bug: @cImport generated invalid zig code"));
+        add_error_note_token(g, err, owner, token, msg);
+        g->errors.append(err);
+        return err;
+    }
+    ErrorMsg *err = err_msg_create_with_line(owner->path, token->start_line, token->start_column,
+            owner->source_code, owner->line_offsets, msg);
+    g->errors.append(err);
+    return err;
+}
+ErrorMsg *add_node_error(CodeGen *g, AstNode *node, Buf *msg) {
+    Token fake_token;
+    fake_token.start_line = node->line;
+    fake_token.start_column = node->column;
+    return add_token_error(g, node->owner, &fake_token, msg);
+}
+ErrorMsg *add_error_note(CodeGen *g, ErrorMsg *parent_msg, AstNode *node, Buf *msg) {
+    Token fake_token;
+    fake_token.start_line = node->line;
+    fake_token.start_column = node->column;
+    return add_error_note_token(g, parent_msg, node->owner, &fake_token, msg);
+}
 ZigType *new_type_table_entry(ZigTypeId id) {
     ZigType *entry = allocate<ZigType>(1);
     entry->id = id;
 @@ -3668,6 +3683,7 @@ static void resolve_decl_var(CodeGen *g, TldVar *tld_var) {
     bool is_const = var_decl->is_const;
     bool is_extern = var_decl->is_extern;
     bool is_export = var_decl->is_export;
+    bool is_thread_local = var_decl->threadlocal_tok != nullptr;
     ZigType *explicit_type = nullptr;
     if (var_decl->type) {
 @@ -3727,6 +3743,7 @@ static void resolve_decl_var(CodeGen *g, TldVar *tld_var) {
     tld_var->var = add_variable(g, source_node, tld_var->base.parent_scope, var_decl->symbol,
             is_const, init_val, &tld_var->base, type);
     tld_var->var->linkage = linkage;
+    tld_var->var->is_thread_local = is_thread_local;
     if (implicit_type != nullptr && type_is_invalid(implicit_type)) {
         tld_var->var->var_type = g->builtin_types.entry_invalid;
 @@ -3747,6 +3764,10 @@ static void resolve_decl_var(CodeGen *g, TldVar *tld_var) {
         }
     }
+    if (is_thread_local && is_const) {
+        add_node_error(g, source_node, buf_sprintf("threadlocal variable cannot be constant"));
+    }
     g->global_vars.append(tld_var);
 }

src/analyze.hpp+1

...	@@ -12,6 +12,7 @@	...	@@ -12,6 +12,7 @@
12		12
13	void semantic_analyze(CodeGen *g);	13	void semantic_analyze(CodeGen *g);
14	ErrorMsg add_node_error(CodeGen g, AstNode node, Buf msg);	14	ErrorMsg add_node_error(CodeGen g, AstNode node, Buf msg);
		15	ErrorMsg add_token_error(CodeGen g, ImportTableEntry owner, Token token, Buf *msg);
15	ErrorMsg add_error_note(CodeGen g, ErrorMsg parent_msg, AstNode node, Buf *msg);	16	ErrorMsg add_error_note(CodeGen g, ErrorMsg parent_msg, AstNode node, Buf *msg);
16	ZigType *new_type_table_entry(ZigTypeId id);	17	ZigType *new_type_table_entry(ZigTypeId id);
17	ZigType get_pointer_to_type(CodeGen g, ZigType *child_type, bool is_const);	18	ZigType get_pointer_to_type(CodeGen g, ZigType *child_type, bool is_const);

src/ast_render.cpp+6-1

 @@ -132,6 +132,10 @@ static const char *const_or_var_string(bool is_const) {
     return is_const ? "const" : "var";
 }
+static const char *thread_local_string(Token *tok) {
+    return (tok == nullptr) ? "" : "threadlocal ";
+}
 const char *container_string(ContainerKind kind) {
     switch (kind) {
         case ContainerKindEnum: return "enum";
 @@ -554,8 +558,9 @@ static void render_node_extra(AstRender *ar, AstNode *node, bool grouped) {
             {
                 const char *pub_str = visib_mod_string(node->data.variable_declaration.visib_mod);
                 const char *extern_str = extern_string(node->data.variable_declaration.is_extern);
+                const char *thread_local_str = thread_local_string(node->data.variable_declaration.threadlocal_tok);
                 const char *const_or_var = const_or_var_string(node->data.variable_declaration.is_const);
-                fprintf(ar->f, "%s%s%s ", pub_str, extern_str, const_or_var);
+                fprintf(ar->f, "%s%s%s%s ", pub_str, extern_str, thread_local_str, const_or_var);
                 print_symbol(ar, node->data.variable_declaration.symbol);
                 if (node->data.variable_declaration.type) {

src/codegen.cpp+80-77

 @@ -88,7 +88,7 @@ static const char *symbols_that_llvm_depends_on[] = {
 };
 CodeGen *codegen_create(Buf *root_src_path, const ZigTarget *target, OutType out_type, BuildMode build_mode,
-    Buf *zig_lib_dir)
+    Buf *zig_lib_dir, Buf *override_std_dir)
 {
     CodeGen *g = allocate<CodeGen>(1);
 @@ -96,8 +96,12 @@ CodeGen *codegen_create(Buf *root_src_path, const ZigTarget *target, OutType out
     g->zig_lib_dir = zig_lib_dir;
-    g->zig_std_dir = buf_alloc();
+    if (override_std_dir == nullptr) {
-    os_path_join(zig_lib_dir, buf_create_from_str("std"), g->zig_std_dir);
+        g->zig_std_dir = buf_alloc();
+        os_path_join(zig_lib_dir, buf_create_from_str("std"), g->zig_std_dir);
+    } else {
+        g->zig_std_dir = override_std_dir;
+    }
     g->zig_c_headers_dir = buf_alloc();
     os_path_join(zig_lib_dir, buf_create_from_str("include"), g->zig_c_headers_dir);
 @@ -2582,6 +2586,8 @@ static LLVMValueRef gen_rem(CodeGen *g, bool want_runtime_safety, bool want_fast
 }
+typedef LLVMValueRef (*BuildBinOpFunc)(LLVMBuilderRef, LLVMValueRef, LLVMValueRef, const char *);
 static LLVMValueRef ir_render_bin_op(CodeGen *g, IrExecutable *executable,
         IrInstructionBinOp *bin_op_instruction)
 {
 @@ -2640,50 +2646,71 @@ static LLVMValueRef ir_render_bin_op(CodeGen *g, IrExecutable *executable,
             } else {
                 zig_unreachable();
             }
+        case IrBinOpMult:
+        case IrBinOpMultWrap:
         case IrBinOpAdd:
         case IrBinOpAddWrap:
+        case IrBinOpSub:
+        case IrBinOpSubWrap: {
+            // These are lookup table using the AddSubMul enum as the lookup.
+            // If AddSubMul ever changes, then these tables will be out of
+            // date.
+            static const BuildBinOpFunc float_op[3] = { LLVMBuildFAdd, LLVMBuildFSub, LLVMBuildFMul };
+            static const BuildBinOpFunc wrap_op[3] = { LLVMBuildAdd, LLVMBuildSub, LLVMBuildMul };
+            static const BuildBinOpFunc signed_op[3] = { LLVMBuildNSWAdd, LLVMBuildNSWSub, LLVMBuildNSWMul };
+            static const BuildBinOpFunc unsigned_op[3] = { LLVMBuildNUWAdd, LLVMBuildNUWSub, LLVMBuildNUWMul };
+            bool is_vector = type_entry->id == ZigTypeIdVector;
+            bool is_wrapping = (op_id == IrBinOpSubWrap || op_id == IrBinOpAddWrap || op_id == IrBinOpMultWrap);
+            AddSubMul add_sub_mul =
+                op_id == IrBinOpAdd || op_id == IrBinOpAddWrap ? AddSubMulAdd :
+                op_id == IrBinOpSub || op_id == IrBinOpSubWrap ? AddSubMulSub :
+                AddSubMulMul;
+            // The code that is generated for vectors and scalars are the same,
+            // so we can just set type_entry to the vectors elem_type an avoid
+            // a lot of repeated code.
+            if (is_vector)
+                type_entry = type_entry->data.vector.elem_type;
             if (type_entry->id == ZigTypeIdPointer) {
                 assert(type_entry->data.pointer.ptr_len == PtrLenUnknown);
+                LLVMValueRef subscript_value;
+                if (is_vector)
+                    zig_panic("TODO: Implement vector operations on pointers.");
+                switch (add_sub_mul) {
+                    case AddSubMulAdd:
+                        subscript_value = op2_value;
+                        break;
+                    case AddSubMulSub:
+                        subscript_value = LLVMBuildNeg(g->builder, op2_value, "");
+                        break;
+                    case AddSubMulMul:
+                        zig_unreachable();
+                }
                 // TODO runtime safety
-                return LLVMBuildInBoundsGEP(g->builder, op1_value, &op2_value, 1, "");
+                return LLVMBuildInBoundsGEP(g->builder, op1_value, &subscript_value, 1, "");
             } else if (type_entry->id == ZigTypeIdFloat) {
                 ZigLLVMSetFastMath(g->builder, ir_want_fast_math(g, &bin_op_instruction->base));
-                return LLVMBuildFAdd(g->builder, op1_value, op2_value, "");
+                return float_op[add_sub_mul](g->builder, op1_value, op2_value, "");
             } else if (type_entry->id == ZigTypeIdInt) {
-                bool is_wrapping = (op_id == IrBinOpAddWrap);
                 if (is_wrapping) {
-                    return LLVMBuildAdd(g->builder, op1_value, op2_value, "");
+                    return wrap_op[add_sub_mul](g->builder, op1_value, op2_value, "");
                 } else if (want_runtime_safety) {
-                    return gen_overflow_op(g, type_entry, AddSubMulAdd, op1_value, op2_value);
+                    if (is_vector)
+                        zig_panic("TODO: Implement runtime safety vector operations.");
+                    return gen_overflow_op(g, type_entry, add_sub_mul, op1_value, op2_value);
                 } else if (type_entry->data.integral.is_signed) {
-                    return LLVMBuildNSWAdd(g->builder, op1_value, op2_value, "");
+                    return signed_op[add_sub_mul](g->builder, op1_value, op2_value, "");
                 } else {
-                    return LLVMBuildNUWAdd(g->builder, op1_value, op2_value, "");
+                    return unsigned_op[add_sub_mul](g->builder, op1_value, op2_value, "");
-                }
-            } else if (type_entry->id == ZigTypeIdVector) {
-                ZigType *elem_type = type_entry->data.vector.elem_type;
-                if (elem_type->id == ZigTypeIdFloat) {
-                    ZigLLVMSetFastMath(g->builder, ir_want_fast_math(g, &bin_op_instruction->base));
-                    return LLVMBuildFAdd(g->builder, op1_value, op2_value, "");
-                } else if (elem_type->id == ZigTypeIdPointer) {
-                    zig_panic("TODO codegen for pointers in vectors");
-                } else if (elem_type->id == ZigTypeIdInt) {
-                    bool is_wrapping = (op_id == IrBinOpAddWrap);
-                    if (is_wrapping) {
-                        return LLVMBuildAdd(g->builder, op1_value, op2_value, "");
-                    } else if (want_runtime_safety) {
-                        zig_panic("TODO runtime safety for vector integer addition");
-                    } else if (elem_type->data.integral.is_signed) {
-                        return LLVMBuildNSWAdd(g->builder, op1_value, op2_value, "");
-                    } else {
-                        return LLVMBuildNUWAdd(g->builder, op1_value, op2_value, "");
-                    }
-                } else {
-                    zig_unreachable();
                 }
             } else {
                 zig_unreachable();
             }
+        }
         case IrBinOpBinOr:
             return LLVMBuildOr(g->builder, op1_value, op2_value, "");
         case IrBinOpBinXor:
 @@ -2728,49 +2755,6 @@ static LLVMValueRef ir_render_bin_op(CodeGen *g, IrExecutable *executable,
                     return ZigLLVMBuildLShrExact(g->builder, op1_value, op2_casted, "");
                 }
             }
-        case IrBinOpSub:
-        case IrBinOpSubWrap:
-            if (type_entry->id == ZigTypeIdPointer) {
-                assert(type_entry->data.pointer.ptr_len == PtrLenUnknown);
-                // TODO runtime safety
-                LLVMValueRef subscript_value = LLVMBuildNeg(g->builder, op2_value, "");
-                return LLVMBuildInBoundsGEP(g->builder, op1_value, &subscript_value, 1, "");
-            } else if (type_entry->id == ZigTypeIdFloat) {
-                ZigLLVMSetFastMath(g->builder, ir_want_fast_math(g, &bin_op_instruction->base));
-                return LLVMBuildFSub(g->builder, op1_value, op2_value, "");
-            } else if (type_entry->id == ZigTypeIdInt) {
-                bool is_wrapping = (op_id == IrBinOpSubWrap);
-                if (is_wrapping) {
-                    return LLVMBuildSub(g->builder, op1_value, op2_value, "");
-                } else if (want_runtime_safety) {
-                    return gen_overflow_op(g, type_entry, AddSubMulSub, op1_value, op2_value);
-                } else if (type_entry->data.integral.is_signed) {
-                    return LLVMBuildNSWSub(g->builder, op1_value, op2_value, "");
-                } else {
-                    return LLVMBuildNUWSub(g->builder, op1_value, op2_value, "");
-                }
-            } else {
-                zig_unreachable();
-            }
-        case IrBinOpMult:
-        case IrBinOpMultWrap:
-            if (type_entry->id == ZigTypeIdFloat) {
-                ZigLLVMSetFastMath(g->builder, ir_want_fast_math(g, &bin_op_instruction->base));
-                return LLVMBuildFMul(g->builder, op1_value, op2_value, "");
-            } else if (type_entry->id == ZigTypeIdInt) {
-                bool is_wrapping = (op_id == IrBinOpMultWrap);
-                if (is_wrapping) {
-                    return LLVMBuildMul(g->builder, op1_value, op2_value, "");
-                } else if (want_runtime_safety) {
-                    return gen_overflow_op(g, type_entry, AddSubMulMul, op1_value, op2_value);
-                } else if (type_entry->data.integral.is_signed) {
-                    return LLVMBuildNSWMul(g->builder, op1_value, op2_value, "");
-                } else {
-                    return LLVMBuildNUWMul(g->builder, op1_value, op2_value, "");
-                }
-            } else {
-                zig_unreachable();
-            }
         case IrBinOpDivUnspecified:
             return gen_div(g, want_runtime_safety, ir_want_fast_math(g, &bin_op_instruction->base),
                     op1_value, op2_value, type_entry, DivKindFloat);
 @@ -6361,6 +6345,12 @@ static void validate_inline_fns(CodeGen *g) {
     report_errors_and_maybe_exit(g);
 }
+static void set_global_tls(CodeGen *g, ZigVar *var, LLVMValueRef global_value) {
+    if (var->is_thread_local && !g->is_single_threaded) {
+        LLVMSetThreadLocalMode(global_value, LLVMGeneralDynamicTLSModel);
+    }
+}
 static void do_code_gen(CodeGen *g) {
     assert(!g->errors.length);
 @@ -6445,6 +6435,7 @@ static void do_code_gen(CodeGen *g) {
                 maybe_import_dll(g, global_value, GlobalLinkageIdStrong);
                 LLVMSetAlignment(global_value, var->align_bytes);
                 LLVMSetGlobalConstant(global_value, var->gen_is_const);
+                set_global_tls(g, var, global_value);
             }
         } else {
             bool exported = (var->linkage == VarLinkageExport);
 @@ -6470,6 +6461,7 @@ static void do_code_gen(CodeGen *g) {
             }
             LLVMSetGlobalConstant(global_value, var->gen_is_const);
+            set_global_tls(g, var, global_value);
         }
         var->value_ref = global_value;
 @@ -7520,6 +7512,7 @@ static Error define_builtin_compile_vars(CodeGen *g) {
     g->compile_var_package = new_package(buf_ptr(this_dir), builtin_zig_basename);
     g->root_package->package_table.put(buf_create_from_str("builtin"), g->compile_var_package);
     g->std_package->package_table.put(buf_create_from_str("builtin"), g->compile_var_package);
+    g->std_package->package_table.put(buf_create_from_str("std"), g->std_package);
     g->compile_var_import = add_source_file(g, g->compile_var_package, builtin_zig_path, contents);
     scan_import(g, g->compile_var_import);
 @@ -7560,7 +7553,13 @@ static void init(CodeGen *g) {
     LLVMTargetRef target_ref;
     char *err_msg = nullptr;
     if (LLVMGetTargetFromTriple(buf_ptr(&g->triple_str), &target_ref, &err_msg)) {
-        zig_panic("unable to create target based on: %s", buf_ptr(&g->triple_str));
+        fprintf(stderr,
+            "Zig is expecting LLVM to understand this target: '%s'\n"
+            "However LLVM responded with: \"%s\"\n"
+            "Zig is unable to continue. This is a bug in Zig:\n"
+            "https://github.com/ziglang/zig/issues/438\n"
+        , buf_ptr(&g->triple_str), err_msg);
+        exit(1);
     }
     bool is_optimized = g->build_mode != BuildModeDebug;
 @@ -8349,8 +8348,12 @@ static void add_cache_pkg(CodeGen *g, CacheHash *ch, PackageTableEntry *pkg) {
         if (!entry)
             break;
-        cache_buf(ch, entry->key);
+        // TODO: I think we need a more sophisticated detection of
-        add_cache_pkg(g, ch, entry->value);
+        // packages we have already seen
+        if (entry->value != pkg) {
+            cache_buf(ch, entry->key);
+            add_cache_pkg(g, ch, entry->value);
+        }
     }
 }

src/codegen.hpp+1-1

...	@@ -15,7 +15,7 @@	...	@@ -15,7 +15,7 @@
15	#include <stdio.h>	15	#include <stdio.h>
16		16
17	CodeGen codegen_create(Buf root_src_path, const ZigTarget *target, OutType out_type, BuildMode build_mode,	17	CodeGen codegen_create(Buf root_src_path, const ZigTarget *target, OutType out_type, BuildMode build_mode,
18	Buf *zig_lib_dir);	18	Buf zig_lib_dir, Buf override_std_dir);
19		19
20	void codegen_set_clang_argv(CodeGen codegen, const char *args, size_t len);	20	void codegen_set_clang_argv(CodeGen codegen, const char *args, size_t len);
21	void codegen_set_llvm_argv(CodeGen codegen, const char *args, size_t len);	21	void codegen_set_llvm_argv(CodeGen codegen, const char *args, size_t len);

src/ir.cpp+4

 @@ -5204,6 +5204,10 @@ static IrInstruction *ir_gen_var_decl(IrBuilder *irb, Scope *scope, AstNode *nod
         add_node_error(irb->codegen, variable_declaration->section_expr,
             buf_sprintf("cannot set section of local variable '%s'", buf_ptr(variable_declaration->symbol)));
     }
+    if (variable_declaration->threadlocal_tok != nullptr) {
+        add_token_error(irb->codegen, node->owner, variable_declaration->threadlocal_tok,
+            buf_sprintf("function-local variable '%s' cannot be threadlocal", buf_ptr(variable_declaration->symbol)));
+    }
     // Temporarily set the name of the IrExecutable to the VariableDeclaration
     // so that the struct or enum from the init expression inherits the name.

src/link.cpp+1-1

...	@@ -42,7 +42,7 @@ static Buf build_a_raw(CodeGen parent_gen, const char aname, Buf full_path)	...	@@ -42,7 +42,7 @@ static Buf build_a_raw(CodeGen parent_gen, const char aname, Buf full_path)
42	}	42	}
43		43
44	CodeGen *child_gen = codegen_create(full_path, child_target, child_out_type,	44	CodeGen *child_gen = codegen_create(full_path, child_target, child_out_type,
45	parent_gen->build_mode, parent_gen->zig_lib_dir);	45	parent_gen->build_mode, parent_gen->zig_lib_dir, parent_gen->zig_std_dir);
46		46
47	child_gen->out_h_path = nullptr;	47	child_gen->out_h_path = nullptr;
48	child_gen->verbose_tokenize = parent_gen->verbose_tokenize;	48	child_gen->verbose_tokenize = parent_gen->verbose_tokenize;

src/main.cpp+9-3

src/parser.cpp+14-8

...	@@ -844,12 +844,17 @@ static AstNode ast_parse_fn_proto(ParseContext pc) {	...	@@ -844,12 +844,17 @@ static AstNode ast_parse_fn_proto(ParseContext pc) {
844		844
845	// VarDecl <- (KEYWORD_const / KEYWORD_var) IDENTIFIER (COLON TypeExpr)? ByteAlign? LinkSection? (EQUAL Expr)? SEMICOLON	845	// VarDecl <- (KEYWORD_const / KEYWORD_var) IDENTIFIER (COLON TypeExpr)? ByteAlign? LinkSection? (EQUAL Expr)? SEMICOLON
846	static AstNode ast_parse_var_decl(ParseContext pc) {	846	static AstNode ast_parse_var_decl(ParseContext pc) {
847	Token *first = eat_token_if(pc, TokenIdKeywordConst);	847	Token *thread_local_kw = eat_token_if(pc, TokenIdKeywordThreadLocal);
848	if (first == nullptr)	848	Token *mut_kw = eat_token_if(pc, TokenIdKeywordConst);
849	first = eat_token_if(pc, TokenIdKeywordVar);	849	if (mut_kw == nullptr)
850	if (first == nullptr)	850	mut_kw = eat_token_if(pc, TokenIdKeywordVar);
851	return nullptr;	851	if (mut_kw == nullptr) {
852		852	if (thread_local_kw == nullptr) {
		853	return nullptr;
		854	} else {
		855	ast_invalid_token_error(pc, peek_token(pc));
		856	}
		857	}
853	Token *identifier = expect_token(pc, TokenIdSymbol);	858	Token *identifier = expect_token(pc, TokenIdSymbol);
854	AstNode *type_expr = nullptr;	859	AstNode *type_expr = nullptr;
855	if (eat_token_if(pc, TokenIdColon) != nullptr)	860	if (eat_token_if(pc, TokenIdColon) != nullptr)
...	@@ -863,8 +868,9 @@ static AstNode ast_parse_var_decl(ParseContext pc) {	...	@@ -863,8 +868,9 @@ static AstNode ast_parse_var_decl(ParseContext pc) {
863		868
864	expect_token(pc, TokenIdSemicolon);	869	expect_token(pc, TokenIdSemicolon);
865		870
866	AstNode *res = ast_create_node(pc, NodeTypeVariableDeclaration, first);	871	AstNode *res = ast_create_node(pc, NodeTypeVariableDeclaration, mut_kw);
867	res->data.variable_declaration.is_const = first->id == TokenIdKeywordConst;	872	res->data.variable_declaration.threadlocal_tok = thread_local_kw;
		873	res->data.variable_declaration.is_const = mut_kw->id == TokenIdKeywordConst;
868	res->data.variable_declaration.symbol = token_buf(identifier);	874	res->data.variable_declaration.symbol = token_buf(identifier);
869	res->data.variable_declaration.type = type_expr;	875	res->data.variable_declaration.type = type_expr;
870	res->data.variable_declaration.align_expr = align_expr;	876	res->data.variable_declaration.align_expr = align_expr;

src/tokenizer.cpp+2

src/tokenizer.hpp+1

...	@@ -88,6 +88,7 @@ enum TokenId {	...	@@ -88,6 +88,7 @@ enum TokenId {
88	TokenIdKeywordSuspend,	88	TokenIdKeywordSuspend,
89	TokenIdKeywordSwitch,	89	TokenIdKeywordSwitch,
90	TokenIdKeywordTest,	90	TokenIdKeywordTest,
		91	TokenIdKeywordThreadLocal,
91	TokenIdKeywordTrue,	92	TokenIdKeywordTrue,
92	TokenIdKeywordTry,	93	TokenIdKeywordTry,
93	TokenIdKeywordUndefined,	94	TokenIdKeywordUndefined,

std/build.zig+68-19

 @@ -145,8 +145,8 @@ pub const Builder = struct {
     pub fn setInstallPrefix(self: *Builder, maybe_prefix: ?[]const u8) void {
         self.prefix = maybe_prefix orelse "/usr/local"; // TODO better default
-        self.lib_dir = os.path.join(self.allocator, self.prefix, "lib") catch unreachable;
+        self.lib_dir = os.path.join(self.allocator, [][]const u8{ self.prefix, "lib" }) catch unreachable;
-        self.exe_dir = os.path.join(self.allocator, self.prefix, "bin") catch unreachable;
+        self.exe_dir = os.path.join(self.allocator, [][]const u8{ self.prefix, "bin" }) catch unreachable;
     }
     pub fn addExecutable(self: *Builder, name: []const u8, root_src: ?[]const u8) *LibExeObjStep {
 @@ -618,7 +618,10 @@ pub const Builder = struct {
     ///::dest_rel_path is relative to prefix path or it can be an absolute path
     pub fn addInstallFile(self: *Builder, src_path: []const u8, dest_rel_path: []const u8) *InstallFileStep {
-        const full_dest_path = os.path.resolve(self.allocator, self.prefix, dest_rel_path) catch unreachable;
+        const full_dest_path = os.path.resolve(
+            self.allocator,
+            [][]const u8{ self.prefix, dest_rel_path },
+        ) catch unreachable;
         self.pushInstalledFile(full_dest_path);
         const install_step = self.allocator.create(InstallFileStep) catch unreachable;
 @@ -653,7 +656,7 @@ pub const Builder = struct {
     }
     fn pathFromRoot(self: *Builder, rel_path: []const u8) []u8 {
-        return os.path.resolve(self.allocator, self.build_root, rel_path) catch unreachable;
+        return os.path.resolve(self.allocator, [][]const u8{ self.build_root, rel_path }) catch unreachable;
     }
     pub fn fmt(self: *Builder, comptime format: []const u8, args: ...) []u8 {
 @@ -676,7 +679,7 @@ pub const Builder = struct {
                 if (os.path.isAbsolute(name)) {
                     return name;
                 }
-                const full_path = try os.path.join(self.allocator, search_prefix, "bin", self.fmt("{}{}", name, exe_extension));
+                const full_path = try os.path.join(self.allocator, [][]const u8{ search_prefix, "bin", self.fmt("{}{}", name, exe_extension) });
                 if (os.path.real(self.allocator, full_path)) |real_path| {
                     return real_path;
                 } else |_| {
 @@ -691,7 +694,7 @@ pub const Builder = struct {
                 }
                 var it = mem.tokenize(PATH, []u8{os.path.delimiter});
                 while (it.next()) |path| {
-                    const full_path = try os.path.join(self.allocator, path, self.fmt("{}{}", name, exe_extension));
+                    const full_path = try os.path.join(self.allocator, [][]const u8{ path, self.fmt("{}{}", name, exe_extension) });
                     if (os.path.real(self.allocator, full_path)) |real_path| {
                         return real_path;
                     } else |_| {
 @@ -705,7 +708,7 @@ pub const Builder = struct {
                 return name;
             }
             for (paths) |path| {
-                const full_path = try os.path.join(self.allocator, path, self.fmt("{}{}", name, exe_extension));
+                const full_path = try os.path.join(self.allocator, [][]const u8{ path, self.fmt("{}{}", name, exe_extension) });
                 if (os.path.real(self.allocator, full_path)) |real_path| {
                     return real_path;
                 } else |_| {
 @@ -1113,7 +1116,10 @@ pub const LibExeObjStep = struct {
     }
     pub fn getOutputPath(self: *LibExeObjStep) []const u8 {
-        return if (self.output_path) |output_path| output_path else os.path.join(self.builder.allocator, self.builder.cache_root, self.out_filename) catch unreachable;
+        return if (self.output_path) |output_path| output_path else os.path.join(
+            self.builder.allocator,
+            [][]const u8{ self.builder.cache_root, self.out_filename },
+        ) catch unreachable;
     }
     pub fn setOutputHPath(self: *LibExeObjStep, file_path: []const u8) void {
 @@ -1126,7 +1132,10 @@ pub const LibExeObjStep = struct {
     }
     pub fn getOutputHPath(self: *LibExeObjStep) []const u8 {
-        return if (self.output_h_path) |output_h_path| output_h_path else os.path.join(self.builder.allocator, self.builder.cache_root, self.out_h_filename) catch unreachable;
+        return if (self.output_h_path) |output_h_path| output_h_path else os.path.join(
+            self.builder.allocator,
+            [][]const u8{ self.builder.cache_root, self.out_h_filename },
+        ) catch unreachable;
     }
     pub fn addAssemblyFile(self: *LibExeObjStep, path: []const u8) void {
 @@ -1226,7 +1235,10 @@ pub const LibExeObjStep = struct {
         }
         if (self.build_options_contents.len() > 0) {
-            const build_options_file = try os.path.join(builder.allocator, builder.cache_root, builder.fmt("{}_build_options.zig", self.name));
+            const build_options_file = try os.path.join(
+                builder.allocator,
+                [][]const u8{ builder.cache_root, builder.fmt("{}_build_options.zig", self.name) },
+            );
             try std.io.writeFile(build_options_file, self.build_options_contents.toSliceConst());
             try zig_args.append("--pkg-begin");
             try zig_args.append("build_options");
 @@ -1476,7 +1488,10 @@ pub const LibExeObjStep = struct {
                     cc_args.append("-c") catch unreachable;
                     cc_args.append(abs_source_file) catch unreachable;
-                    const cache_o_src = os.path.join(builder.allocator, builder.cache_root, source_file) catch unreachable;
+                    const cache_o_src = os.path.join(
+                        builder.allocator,
+                        [][]const u8{ builder.cache_root, source_file },
+                    ) catch unreachable;
                     if (os.path.dirname(cache_o_src)) |cache_o_dir| {
                         try builder.makePath(cache_o_dir);
                     }
 @@ -1528,7 +1543,10 @@ pub const LibExeObjStep = struct {
                         cc_args.append("-current_version") catch unreachable;
                         cc_args.append(builder.fmt("{}.{}.{}", self.version.major, self.version.minor, self.version.patch)) catch unreachable;
-                        const install_name = builder.pathFromRoot(os.path.join(builder.allocator, builder.cache_root, self.major_only_filename) catch unreachable);
+                        const install_name = builder.pathFromRoot(os.path.join(
+                            builder.allocator,
+                            [][]const u8{ builder.cache_root, self.major_only_filename },
+                        ) catch unreachable);
                         cc_args.append("-install_name") catch unreachable;
                         cc_args.append(install_name) catch unreachable;
                     } else {
 @@ -1594,7 +1612,10 @@ pub const LibExeObjStep = struct {
                     cc_args.append("-c") catch unreachable;
                     cc_args.append(abs_source_file) catch unreachable;
-                    const cache_o_src = os.path.join(builder.allocator, builder.cache_root, source_file) catch unreachable;
+                    const cache_o_src = os.path.join(
+                        builder.allocator,
+                        [][]const u8{ builder.cache_root, source_file },
+                    ) catch unreachable;
                     if (os.path.dirname(cache_o_src)) |cache_o_dir| {
                         try builder.makePath(cache_o_dir);
                     }
 @@ -1686,6 +1707,7 @@ pub const TestStep = struct {
     no_rosegment: bool,
     output_path: ?[]const u8,
     system_linker_hack: bool,
+    override_std_dir: ?[]const u8,
     pub fn init(builder: *Builder, root_src: []const u8) TestStep {
         const step_name = builder.fmt("test {}", root_src);
 @@ -1707,6 +1729,7 @@ pub const TestStep = struct {
             .no_rosegment = false,
             .output_path = null,
             .system_linker_hack = false,
+            .override_std_dir = null,
         };
     }
 @@ -1737,6 +1760,10 @@ pub const TestStep = struct {
         self.build_mode = mode;
     }
+    pub fn overrideStdDir(self: *TestStep, dir_path: []const u8) void {
+        self.override_std_dir = dir_path;
+    }
     pub fn setOutputPath(self: *TestStep, file_path: []const u8) void {
         self.output_path = file_path;
 @@ -1751,7 +1778,10 @@ pub const TestStep = struct {
             return output_path;
         } else {
             const basename = self.builder.fmt("test{}", self.target.exeFileExt());
-            return os.path.join(self.builder.allocator, self.builder.cache_root, basename) catch unreachable;
+            return os.path.join(
+                self.builder.allocator,
+                [][]const u8{ self.builder.cache_root, basename },
+            ) catch unreachable;
         }
     }
 @@ -1914,6 +1944,10 @@ pub const TestStep = struct {
         if (self.system_linker_hack) {
             try zig_args.append("--system-linker-hack");
         }
+        if (self.override_std_dir) |dir| {
+            try zig_args.append("--override-std-dir");
+            try zig_args.append(builder.pathFromRoot(dir));
+        }
         try builder.spawnChild(zig_args.toSliceConst());
     }
 @@ -1969,13 +2003,22 @@ const InstallArtifactStep = struct {
             .builder = builder,
             .step = Step.init(builder.fmt("install {}", artifact.step.name), builder.allocator, make),
             .artifact = artifact,
-            .dest_file = os.path.join(builder.allocator, dest_dir, artifact.out_filename) catch unreachable,
+            .dest_file = os.path.join(
+                builder.allocator,
+                [][]const u8{ dest_dir, artifact.out_filename },
+            ) catch unreachable,
         };
         self.step.dependOn(&artifact.step);
         builder.pushInstalledFile(self.dest_file);
         if (self.artifact.kind == LibExeObjStep.Kind.Lib and !self.artifact.static) {
-            builder.pushInstalledFile(os.path.join(builder.allocator, builder.lib_dir, artifact.major_only_filename) catch unreachable);
+            builder.pushInstalledFile(os.path.join(
-            builder.pushInstalledFile(os.path.join(builder.allocator, builder.lib_dir, artifact.name_only_filename) catch unreachable);
+                builder.allocator,
+                [][]const u8{ builder.lib_dir, artifact.major_only_filename },
+            ) catch unreachable);
+            builder.pushInstalledFile(os.path.join(
+                builder.allocator,
+                [][]const u8{ builder.lib_dir, artifact.name_only_filename },
+            ) catch unreachable);
         }
         return self;
     }
 @@ -2131,13 +2174,19 @@ fn doAtomicSymLinks(allocator: *Allocator, output_path: []const u8, filename_maj
     const out_dir = os.path.dirname(output_path) orelse ".";
     const out_basename = os.path.basename(output_path);
     // sym link for libfoo.so.1 to libfoo.so.1.2.3
-    const major_only_path = os.path.join(allocator, out_dir, filename_major_only) catch unreachable;
+    const major_only_path = os.path.join(
+        allocator,
+        [][]const u8{ out_dir, filename_major_only },
+    ) catch unreachable;
     os.atomicSymLink(allocator, out_basename, major_only_path) catch |err| {
         warn("Unable to symlink {} -> {}\n", major_only_path, out_basename);
         return err;
     };
     // sym link for libfoo.so to libfoo.so.1
-    const name_only_path = os.path.join(allocator, out_dir, filename_name_only) catch unreachable;
+    const name_only_path = os.path.join(
+        allocator,
+        [][]const u8{ out_dir, filename_name_only },
+    ) catch unreachable;
     os.atomicSymLink(allocator, filename_major_only, name_only_path) catch |err| {
         warn("Unable to symlink {} -> {}\n", name_only_path, filename_major_only);
         return err;

std/debug/index.zig+2-3

std/event/fs.zig+2-2

...	@@ -871,7 +871,7 @@ pub fn Watch(comptime V: type) type {	...	@@ -871,7 +871,7 @@ pub fn Watch(comptime V: type) type {
871	}	871	}
872		872
873	async fn addFileKEvent(self: *Self, file_path: []const u8, value: V) !?V {	873	async fn addFileKEvent(self: *Self, file_path: []const u8, value: V) !?V {
874	const resolved_path = try os.path.resolve(self.channel.loop.allocator, file_path);	874	const resolved_path = try os.path.resolve(self.channel.loop.allocator, [][]const u8{file_path});
875	var resolved_path_consumed = false;	875	var resolved_path_consumed = false;
876	defer if (!resolved_path_consumed) self.channel.loop.allocator.free(resolved_path);	876	defer if (!resolved_path_consumed) self.channel.loop.allocator.free(resolved_path);
877		877
...	@@ -1336,7 +1336,7 @@ async fn testFsWatchCantFail(loop: Loop, result: (anyerror!void)) void {	...	@@ -1336,7 +1336,7 @@ async fn testFsWatchCantFail(loop: Loop, result: (anyerror!void)) void {
1336	}	1336	}
1337		1337
1338	async fn testFsWatch(loop: *Loop) !void {	1338	async fn testFsWatch(loop: *Loop) !void {
1339	const file_path = try os.path.join(loop.allocator, test_tmp_dir, "file.txt");	1339	const file_path = try os.path.join(loop.allocator, [][]const u8{ test_tmp_dir, "file.txt" });
1340	defer loop.allocator.free(file_path);	1340	defer loop.allocator.free(file_path);
1341		1341
1342	const contents =	1342	const contents =

std/heap.zig+2-5

std/index.zig+1-1

 @@ -33,8 +33,8 @@ pub const io = @import("io.zig");
 pub const json = @import("json.zig");
 pub const macho = @import("macho.zig");
 pub const math = @import("math/index.zig");
-pub const meta = @import("meta/index.zig");
 pub const mem = @import("mem.zig");
+pub const meta = @import("meta/index.zig");
 pub const net = @import("net.zig");
 pub const os = @import("os/index.zig");
 pub const pdb = @import("pdb.zig");

std/io.zig+5-5

std/io_test.zig+10-1

...	@@ -357,6 +357,15 @@ fn testIntSerializerDeserializer(comptime endian: builtin.Endian, comptime is_pa	...	@@ -357,6 +357,15 @@ fn testIntSerializerDeserializer(comptime endian: builtin.Endian, comptime is_pa
357	const total_packed_bytes = (total_bits / u8_bit_count) + extra_packed_byte;	357	const total_packed_bytes = (total_bits / u8_bit_count) + extra_packed_byte;
358		358
359	assert(in.pos == if (is_packed) total_packed_bytes else total_bytes);	359	assert(in.pos == if (is_packed) total_packed_bytes else total_bytes);
		360
		361	//Verify that empty error set works with serializer.
		362	//deserializer is covered by SliceInStream
		363	const NullError = io.NullOutStream.Error;
		364	var null_out = io.NullOutStream.init();
		365	var null_out_stream = &null_out.stream;
		366	var null_serializer = io.Serializer(endian, is_packed, NullError).init(null_out_stream);
		367	try null_serializer.serialize(data_mem[0..]);
		368	try null_serializer.flush();
360	}	369	}
361		370
362	test "Serializer/Deserializer Int" {	371	test "Serializer/Deserializer Int" {
...	@@ -568,4 +577,4 @@ test "Deserializer bad data" {	...	@@ -568,4 +577,4 @@ test "Deserializer bad data" {
568	try testBadData(builtin.Endian.Little, false);	577	try testBadData(builtin.Endian.Little, false);
569	try testBadData(builtin.Endian.Big, true);	578	try testBadData(builtin.Endian.Big, true);
570	try testBadData(builtin.Endian.Little, true);	579	try testBadData(builtin.Endian.Little, true);
571	}
	\ No newline at end of file
		580	}

std/mem.zig+45-27

...	@@ -882,42 +882,40 @@ pub const SplitIterator = struct {	...	@@ -882,42 +882,40 @@ pub const SplitIterator = struct {
882	}	882	}
883	};	883	};
884		884
885	/// Naively combines a series of strings with a separator.	885	/// Naively combines a series of slices with a separator.
886	/// Allocates memory for the result, which must be freed by the caller.	886	/// Allocates memory for the result, which must be freed by the caller.
887	pub fn join(allocator: *Allocator, sep: u8, strings: ...) ![]u8 {	887	pub fn join(allocator: *Allocator, separator: []const u8, slices: []const []const u8) ![]u8 {
888	comptime assert(strings.len >= 1);	888	if (slices.len == 0) return (([*]u8)(undefined))[0..0];
889	var total_strings_len: usize = strings.len; // 1 sep per string	889
890	{	890	const total_len = blk: {
891	comptime var string_i = 0;	891	var sum: usize = separator.len * (slices.len - 1);
892	inline while (string_i < strings.len) : (string_i += 1) {	892	for (slices) \|slice\|
893	const arg = ([]const u8)(strings[string_i]);	893	sum += slice.len;
894	total_strings_len += arg.len;	894	break :blk sum;
895	}	895	};
896	}
897		896
898	const buf = try allocator.alloc(u8, total_strings_len);	897	const buf = try allocator.alloc(u8, total_len);
899	errdefer allocator.free(buf);	898	errdefer allocator.free(buf);
900		899
901	var buf_index: usize = 0;	900	copy(u8, buf, slices[0]);
902	comptime var string_i = 0;	901	var buf_index: usize = slices[0].len;
903	inline while (true) {	902	for (slices[1..]) \|slice\| {
904	const arg = ([]const u8)(strings[string_i]);	903	copy(u8, buf[buf_index..], separator);
905	string_i += 1;	904	buf_index += separator.len;
906	copy(u8, buf[buf_index..], arg);	905	copy(u8, buf[buf_index..], slice);
907	buf_index += arg.len;	906	buf_index += slice.len;
908	if (string_i >= strings.len) break;
909	if (buf[buf_index - 1] != sep) {
910	buf[buf_index] = sep;
911	buf_index += 1;
912	}
913	}	907	}
914		908
915	return allocator.shrink(u8, buf, buf_index);	909	// No need for shrink since buf is exactly the correct size.
		910	return buf;
916	}	911	}
917		912
918	test "mem.join" {	913	test "mem.join" {
919	assert(eql(u8, try join(debug.global_allocator, ',', "a", "b", "c"), "a,b,c"));	914	var buf: [1024]u8 = undefined;
920	assert(eql(u8, try join(debug.global_allocator, ',', "a"), "a"));	915	const a = &std.heap.FixedBufferAllocator.init(&buf).allocator;
		916	assert(eql(u8, try join(a, ",", [][]const u8{ "a", "b", "c" }), "a,b,c"));
		917	assert(eql(u8, try join(a, ",", [][]const u8{"a"}), "a"));
		918	assert(eql(u8, try join(a, ",", [][]const u8{ "a", "", "b", "", "c" }), "a,,b,,c"));
921	}	919	}
922		920
923	test "testStringEquality" {	921	test "testStringEquality" {
...	@@ -1366,3 +1364,23 @@ test "std.mem.subArrayPtr" {	...	@@ -1366,3 +1364,23 @@ test "std.mem.subArrayPtr" {
1366	sub2[1] = 'X';	1364	sub2[1] = 'X';
1367	debug.assert(std.mem.eql(u8, a2, "abcXef"));	1365	debug.assert(std.mem.eql(u8, a2, "abcXef"));
1368	}	1366	}
		1367
		1368	/// Round an address up to the nearest aligned address
		1369	pub fn alignForward(addr: usize, alignment: usize) usize {
		1370	return (addr + alignment - 1) & ~(alignment - 1);
		1371	}
		1372
		1373	test "std.mem.alignForward" {
		1374	debug.assertOrPanic(alignForward(1, 1) == 1);
		1375	debug.assertOrPanic(alignForward(2, 1) == 2);
		1376	debug.assertOrPanic(alignForward(1, 2) == 2);
		1377	debug.assertOrPanic(alignForward(2, 2) == 2);
		1378	debug.assertOrPanic(alignForward(3, 2) == 4);
		1379	debug.assertOrPanic(alignForward(4, 2) == 4);
		1380	debug.assertOrPanic(alignForward(7, 8) == 8);
		1381	debug.assertOrPanic(alignForward(8, 8) == 8);
		1382	debug.assertOrPanic(alignForward(9, 8) == 16);
		1383	debug.assertOrPanic(alignForward(15, 8) == 16);
		1384	debug.assertOrPanic(alignForward(16, 8) == 16);
		1385	debug.assertOrPanic(alignForward(17, 8) == 24);
		1386	}

std/os/child_process.zig+6-3

...	@@ -574,7 +574,7 @@ pub const ChildProcess = struct {	...	@@ -574,7 +574,7 @@ pub const ChildProcess = struct {
574	// to match posix semantics	574	// to match posix semantics
575	const app_name = x: {	575	const app_name = x: {
576	if (self.cwd) \|cwd\| {	576	if (self.cwd) \|cwd\| {
577	const resolved = try os.path.resolve(self.allocator, cwd, self.argv[0]);	577	const resolved = try os.path.resolve(self.allocator, [][]const u8{ cwd, self.argv[0] });
578	defer self.allocator.free(resolved);	578	defer self.allocator.free(resolved);
579	break :x try cstr.addNullByte(self.allocator, resolved);	579	break :x try cstr.addNullByte(self.allocator, resolved);
580	} else {	580	} else {
...	@@ -597,10 +597,10 @@ pub const ChildProcess = struct {	...	@@ -597,10 +597,10 @@ pub const ChildProcess = struct {
597		597
598	var it = mem.tokenize(PATH, ";");	598	var it = mem.tokenize(PATH, ";");
599	while (it.next()) \|search_path\| {	599	while (it.next()) \|search_path\| {
600	const joined_path = try os.path.join(self.allocator, search_path, app_name);	600	const joined_path = try os.path.join(self.allocator, [][]const u8{ search_path, app_name });
601	defer self.allocator.free(joined_path);	601	defer self.allocator.free(joined_path);
602		602
603	const joined_path_w = try unicode.utf8ToUtf16LeWithNull(self.allocator, app_name);	603	const joined_path_w = try unicode.utf8ToUtf16LeWithNull(self.allocator, joined_path);
604	defer self.allocator.free(joined_path_w);	604	defer self.allocator.free(joined_path_w);
605		605
606	if (windowsCreateProcess(joined_path_w.ptr, cmd_line_w.ptr, envp_ptr, cwd_w_ptr, &siStartInfo, &piProcInfo)) \|_\| {	606	if (windowsCreateProcess(joined_path_w.ptr, cmd_line_w.ptr, envp_ptr, cwd_w_ptr, &siStartInfo, &piProcInfo)) \|_\| {
...	@@ -610,6 +610,9 @@ pub const ChildProcess = struct {	...	@@ -610,6 +610,9 @@ pub const ChildProcess = struct {
610	} else {	610	} else {
611	return err;	611	return err;
612	}	612	}
		613	} else {
		614	// Every other error would have been returned earlier.
		615	return error.FileNotFound;
613	}	616	}
614	};	617	};
615		618

std/os/get_app_data_dir.zig+3-4

std/os/index.zig+68-45

 @@ -8,6 +8,10 @@ const is_posix = switch (builtin.os) {
 };
 const os = @This();
+comptime {
+    assert(@import("std") == std); // You have to run the std lib tests with --override-std-dir
+}
 test "std.os" {
     _ = @import("child_process.zig");
     _ = @import("darwin.zig");
 @@ -692,12 +696,7 @@ pub fn getBaseAddress() usize {
                 return base;
             }
             const phdr = linuxGetAuxVal(std.elf.AT_PHDR);
-            const ElfHeader = switch (@sizeOf(usize)) {
+            return phdr - @sizeOf(std.elf.Ehdr);
-                4 => std.elf.Elf32_Ehdr,
-                8 => std.elf.Elf64_Ehdr,
-                else => @compileError("Unsupported architecture"),
-            };
-            return phdr - @sizeOf(ElfHeader);
         },
         builtin.Os.macosx, builtin.Os.freebsd => return @ptrToInt(&std.c._mh_execute_header),
         builtin.Os.windows => return @ptrToInt(windows.GetModuleHandleW(null)),
 @@ -1285,7 +1284,7 @@ pub fn makeDirPosix(dir_path: []const u8) !void {
 /// already exists and is a directory.
 /// TODO determine if we can remove the allocator requirement from this function
 pub fn makePath(allocator: *Allocator, full_path: []const u8) !void {
-    const resolved_path = try path.resolve(allocator, full_path);
+    const resolved_path = try path.resolve(allocator, [][]const u8{full_path});
     defer allocator.free(resolved_path);
     var end_index: usize = resolved_path.len;
 @@ -2305,18 +2304,17 @@ pub fn selfExePath(out_buffer: *[MAX_PATH_BYTES]u8) ![]u8 {
     switch (builtin.os) {
         Os.linux => return readLink(out_buffer, "/proc/self/exe"),
         Os.freebsd => {
-            var mib = [4]c_int{ posix.CTL_KERN, posix.KERN_PROC, posix.KERN_PROC_PATHNAME, -1};
+            var mib = [4]c_int{ posix.CTL_KERN, posix.KERN_PROC, posix.KERN_PROC_PATHNAME, -1 };
             var out_len: usize = out_buffer.len;
             const err = posix.getErrno(posix.sysctl(&mib, 4, out_buffer, &out_len, null, 0));
-            if (err == 0 ) return mem.toSlice(u8, out_buffer);
+            if (err == 0) return mem.toSlice(u8, out_buffer);
             return switch (err) {
                 posix.EFAULT => error.BadAdress,
                 posix.EPERM => error.PermissionDenied,
                 else => unexpectedErrorPosix(err),
             };
         },
         Os.windows => {
             var utf16le_buf: [windows_util.PATH_MAX_WIDE]u16 = undefined;
 @@ -2908,14 +2906,15 @@ pub const Thread = struct {
     pub const Data = if (use_pthreads)
         struct {
             handle: Thread.Handle,
-            stack_addr: usize,
+            mmap_addr: usize,
-            stack_len: usize,
+            mmap_len: usize,
         }
     else switch (builtin.os) {
         builtin.Os.linux => struct {
             handle: Thread.Handle,
-            stack_addr: usize,
+            mmap_addr: usize,
-            stack_len: usize,
+            mmap_len: usize,
+            tls_end_addr: usize,
         },
         builtin.Os.windows => struct {
             handle: Thread.Handle,
 @@ -2955,7 +2954,7 @@ pub const Thread = struct {
                 posix.EDEADLK => unreachable,
                 else => unreachable,
             }
-            assert(posix.munmap(self.data.stack_addr, self.data.stack_len) == 0);
+            assert(posix.munmap(self.data.mmap_addr, self.data.mmap_len) == 0);
         } else switch (builtin.os) {
             builtin.Os.linux => {
                 while (true) {
 @@ -2969,7 +2968,7 @@ pub const Thread = struct {
                         else => unreachable,
                     }
                 }
-                assert(posix.munmap(self.data.stack_addr, self.data.stack_len) == 0);
+                assert(posix.munmap(self.data.mmap_addr, self.data.mmap_len) == 0);
             },
             builtin.Os.windows => {
                 assert(windows.WaitForSingleObject(self.data.handle, windows.INFINITE) == windows.WAIT_OBJECT_0);
 @@ -3008,6 +3007,9 @@ pub const SpawnThreadError = error{
     Unexpected,
 };
+pub var linux_tls_phdr: ?*std.elf.Phdr = null;
+pub var linux_tls_img_src: [*]const u8 = undefined; // defined if linux_tls_phdr is
 /// caller must call wait on the returned thread
 /// fn startFn(@typeOf(context)) T
 /// where T is u8, noreturn, void, or !void
 @@ -3097,42 +3099,56 @@ pub fn spawnThread(context: var, comptime startFn: var) SpawnThreadError!*Thread
     const MAP_GROWSDOWN = if (builtin.os == builtin.Os.linux) linux.MAP_GROWSDOWN else 0;
-    const mmap_len = default_stack_size;
+    var stack_end_offset: usize = undefined;
-    const stack_addr = posix.mmap(null, mmap_len, posix.PROT_READ | posix.PROT_WRITE, posix.MAP_PRIVATE | posix.MAP_ANONYMOUS | MAP_GROWSDOWN, -1, 0);
+    var thread_start_offset: usize = undefined;
-    if (stack_addr == posix.MAP_FAILED) return error.OutOfMemory;
+    var context_start_offset: usize = undefined;
-    errdefer assert(posix.munmap(stack_addr, mmap_len) == 0);
+    var tls_start_offset: usize = undefined;
+    const mmap_len = blk: {
+        // First in memory will be the stack, which grows downwards.
+        var l: usize = mem.alignForward(default_stack_size, os.page_size);
+        stack_end_offset = l;
+        // Above the stack, so that it can be in the same mmap call, put the Thread object.
+        l = mem.alignForward(l, @alignOf(Thread));
+        thread_start_offset = l;
+        l += @sizeOf(Thread);
+        // Next, the Context object.
+        if (@sizeOf(Context) != 0) {
+            l = mem.alignForward(l, @alignOf(Context));
+            context_start_offset = l;
+            l += @sizeOf(Context);
+        }
+        // Finally, the Thread Local Storage, if any.
+        if (!Thread.use_pthreads) {
+            if (linux_tls_phdr) |tls_phdr| {
+                l = mem.alignForward(l, tls_phdr.p_align);
+                tls_start_offset = l;
+                l += tls_phdr.p_memsz;
+            }
+        }
+        break :blk l;
+    };
+    const mmap_addr = posix.mmap(null, mmap_len, posix.PROT_READ | posix.PROT_WRITE, posix.MAP_PRIVATE | posix.MAP_ANONYMOUS | MAP_GROWSDOWN, -1, 0);
+    if (mmap_addr == posix.MAP_FAILED) return error.OutOfMemory;
+    errdefer assert(posix.munmap(mmap_addr, mmap_len) == 0);
+    const thread_ptr = @alignCast(@alignOf(Thread), @intToPtr(*Thread, mmap_addr + thread_start_offset));
+    thread_ptr.data.mmap_addr = mmap_addr;
+    thread_ptr.data.mmap_len = mmap_len;
-    var stack_end: usize = stack_addr + mmap_len;
     var arg: usize = undefined;
     if (@sizeOf(Context) != 0) {
-        stack_end -= @sizeOf(Context);
+        arg = mmap_addr + context_start_offset;
-        stack_end -= stack_end % @alignOf(Context);
+        const context_ptr = @alignCast(@alignOf(Context), @intToPtr(*Context, arg));
-        assert(stack_end >= stack_addr);
-        const context_ptr = @alignCast(@alignOf(Context), @intToPtr(*Context, stack_end));
         context_ptr.* = context;
-        arg = stack_end;
     }
-    stack_end -= @sizeOf(Thread);
+    if (Thread.use_pthreads) {
-    stack_end -= stack_end % @alignOf(Thread);
-    assert(stack_end >= stack_addr);
-    const thread_ptr = @alignCast(@alignOf(Thread), @intToPtr(*Thread, stack_end));
-    thread_ptr.data.stack_addr = stack_addr;
-    thread_ptr.data.stack_len = mmap_len;
-    if (builtin.os == builtin.Os.windows) {
-        // use windows API directly
-        @compileError("TODO support spawnThread for Windows");
-    } else if (Thread.use_pthreads) {
         // use pthreads
         var attr: c.pthread_attr_t = undefined;
         if (c.pthread_attr_init(&attr) != 0) return SpawnThreadError.SystemResources;
         defer assert(c.pthread_attr_destroy(&attr) == 0);
-        // align to page
+        assert(c.pthread_attr_setstack(&attr, @intToPtr(*c_void, mmap_addr), stack_end_offset) == 0);
-        stack_end -= stack_end % os.page_size;
-        assert(c.pthread_attr_setstack(&attr, @intToPtr(*c_void, stack_addr), stack_end - stack_addr) == 0);
         const err = c.pthread_create(&thread_ptr.data.handle, &attr, MainFuncs.posixThreadMain, @intToPtr(*c_void, arg));
         switch (err) {
 @@ -3143,10 +3159,17 @@ pub fn spawnThread(context: var, comptime startFn: var) SpawnThreadError!*Thread
             else => return unexpectedErrorPosix(@intCast(usize, err)),
         }
     } else if (builtin.os == builtin.Os.linux) {
-        // use linux API directly.  TODO use posix.CLONE_SETTLS and initialize thread local storage correctly
+        var flags: u32 = posix.CLONE_VM | posix.CLONE_FS | posix.CLONE_FILES | posix.CLONE_SIGHAND |
-        const flags = posix.CLONE_VM | posix.CLONE_FS | posix.CLONE_FILES | posix.CLONE_SIGHAND | posix.CLONE_THREAD | posix.CLONE_SYSVSEM | posix.CLONE_PARENT_SETTID | posix.CLONE_CHILD_CLEARTID | posix.CLONE_DETACHED;
+            posix.CLONE_THREAD | posix.CLONE_SYSVSEM | posix.CLONE_PARENT_SETTID | posix.CLONE_CHILD_CLEARTID |
-        const newtls: usize = 0;
+            posix.CLONE_DETACHED;
-        const rc = posix.clone(MainFuncs.linuxThreadMain, stack_end, flags, arg, &thread_ptr.data.handle, newtls, &thread_ptr.data.handle);
+        var newtls: usize = undefined;
+        if (linux_tls_phdr) |tls_phdr| {
+            @memcpy(@intToPtr([*]u8, mmap_addr + tls_start_offset), linux_tls_img_src, tls_phdr.p_filesz);
+            thread_ptr.data.tls_end_addr = mmap_addr + mmap_len;
+            newtls = @ptrToInt(&thread_ptr.data.tls_end_addr);
+            flags |= posix.CLONE_SETTLS;
+        }
+        const rc = posix.clone(MainFuncs.linuxThreadMain, mmap_addr + stack_end_offset, flags, arg, &thread_ptr.data.handle, newtls, &thread_ptr.data.handle);
         const err = posix.getErrno(rc);
         switch (err) {
             0 => return thread_ptr,

std/os/path.zig+92-33

...	@@ -33,40 +33,103 @@ pub fn isSep(byte: u8) bool {	...	@@ -33,40 +33,103 @@ pub fn isSep(byte: u8) bool {
33	}	33	}
34	}	34	}
35		35
		36	/// This is different from mem.join in that the separator will not be repeated if
		37	/// it is found at the end or beginning of a pair of consecutive paths.
		38	fn joinSep(allocator: *Allocator, separator: u8, paths: []const []const u8) ![]u8 {
		39	if (paths.len == 0) return (([*]u8)(undefined))[0..0];
		40
		41	const total_len = blk: {
		42	var sum: usize = paths[0].len;
		43	var i: usize = 1;
		44	while (i < paths.len) : (i += 1) {
		45	const prev_path = paths[i - 1];
		46	const this_path = paths[i];
		47	const prev_sep = (prev_path.len != 0 and prev_path[prev_path.len - 1] == separator);
		48	const this_sep = (this_path.len != 0 and this_path[0] == separator);
		49	sum += @boolToInt(!prev_sep and !this_sep);
		50	sum += if (prev_sep and this_sep) this_path.len - 1 else this_path.len;
		51	}
		52	break :blk sum;
		53	};
		54
		55	const buf = try allocator.alloc(u8, total_len);
		56	errdefer allocator.free(buf);
		57
		58	mem.copy(u8, buf, paths[0]);
		59	var buf_index: usize = paths[0].len;
		60	var i: usize = 1;
		61	while (i < paths.len) : (i += 1) {
		62	const prev_path = paths[i - 1];
		63	const this_path = paths[i];
		64	const prev_sep = (prev_path.len != 0 and prev_path[prev_path.len - 1] == separator);
		65	const this_sep = (this_path.len != 0 and this_path[0] == separator);
		66	if (!prev_sep and !this_sep) {
		67	buf[buf_index] = separator;
		68	buf_index += 1;
		69	}
		70	const adjusted_path = if (prev_sep and this_sep) this_path[1..] else this_path;
		71	mem.copy(u8, buf[buf_index..], adjusted_path);
		72	buf_index += adjusted_path.len;
		73	}
		74
		75	// No need for shrink since buf is exactly the correct size.
		76	return buf;
		77	}
		78
		79	pub const join = if (is_windows) joinWindows else joinPosix;
		80
36	/// Naively combines a series of paths with the native path seperator.	81	/// Naively combines a series of paths with the native path seperator.
37	/// Allocates memory for the result, which must be freed by the caller.	82	/// Allocates memory for the result, which must be freed by the caller.
38	pub fn join(allocator: *Allocator, paths: ...) ![]u8 {	83	pub fn joinWindows(allocator: *Allocator, paths: []const []const u8) ![]u8 {
39	if (is_windows) {	84	return joinSep(allocator, sep_windows, paths);
40	return joinWindows(allocator, paths);	85	}
41	} else {	86
42	return joinPosix(allocator, paths);	87	/// Naively combines a series of paths with the native path seperator.
43	}	88	/// Allocates memory for the result, which must be freed by the caller.
		89	pub fn joinPosix(allocator: *Allocator, paths: []const []const u8) ![]u8 {
		90	return joinSep(allocator, sep_posix, paths);
44	}	91	}
45		92
46	pub fn joinWindows(allocator: *Allocator, paths: ...) ![]u8 {	93	fn testJoinWindows(paths: []const []const u8, expected: []const u8) void {
47	return mem.join(allocator, sep_windows, paths);	94	var buf: [1024]u8 = undefined;
		95	const a = &std.heap.FixedBufferAllocator.init(&buf).allocator;
		96	const actual = joinWindows(a, paths) catch @panic("fail");
		97	debug.assertOrPanic(mem.eql(u8, actual, expected));
48	}	98	}
49		99
50	pub fn joinPosix(allocator: *Allocator, paths: ...) ![]u8 {	100	fn testJoinPosix(paths: []const []const u8, expected: []const u8) void {
51	return mem.join(allocator, sep_posix, paths);	101	var buf: [1024]u8 = undefined;
		102	const a = &std.heap.FixedBufferAllocator.init(&buf).allocator;
		103	const actual = joinPosix(a, paths) catch @panic("fail");
		104	debug.assertOrPanic(mem.eql(u8, actual, expected));
52	}	105	}
53		106
54	test "os.path.join" {	107	test "os.path.join" {
55	assert(mem.eql(u8, try joinWindows(debug.global_allocator, "c:\\a\\b", "c"), "c:\\a\\b\\c"));	108	testJoinWindows([][]const u8{ "c:\\a\\b", "c" }, "c:\\a\\b\\c");
56	assert(mem.eql(u8, try joinWindows(debug.global_allocator, "c:\\a\\b\\", "c"), "c:\\a\\b\\c"));	109	testJoinWindows([][]const u8{ "c:\\a\\b", "c" }, "c:\\a\\b\\c");
		110	testJoinWindows([][]const u8{ "c:\\a\\b\\", "c" }, "c:\\a\\b\\c");
57		111
58	assert(mem.eql(u8, try joinWindows(debug.global_allocator, "c:\\", "a", "b\\", "c"), "c:\\a\\b\\c"));	112	testJoinWindows([][]const u8{ "c:\\", "a", "b\\", "c" }, "c:\\a\\b\\c");
59	assert(mem.eql(u8, try joinWindows(debug.global_allocator, "c:\\a\\", "b\\", "c"), "c:\\a\\b\\c"));	113	testJoinWindows([][]const u8{ "c:\\a\\", "b\\", "c" }, "c:\\a\\b\\c");
60		114
61	assert(mem.eql(u8, try joinWindows(debug.global_allocator, "c:\\home\\andy\\dev\\zig\\build\\lib\\zig\\std", "io.zig"), "c:\\home\\andy\\dev\\zig\\build\\lib\\zig\\std\\io.zig"));	115	testJoinWindows(
		116	[][]const u8{ "c:\\home\\andy\\dev\\zig\\build\\lib\\zig\\std", "io.zig" },
		117	"c:\\home\\andy\\dev\\zig\\build\\lib\\zig\\std\\io.zig",
		118	);
62		119
63	assert(mem.eql(u8, try joinPosix(debug.global_allocator, "/a/b", "c"), "/a/b/c"));	120	testJoinPosix([][]const u8{ "/a/b", "c" }, "/a/b/c");
64	assert(mem.eql(u8, try joinPosix(debug.global_allocator, "/a/b/", "c"), "/a/b/c"));	121	testJoinPosix([][]const u8{ "/a/b/", "c" }, "/a/b/c");
65		122
66	assert(mem.eql(u8, try joinPosix(debug.global_allocator, "/", "a", "b/", "c"), "/a/b/c"));	123	testJoinPosix([][]const u8{ "/", "a", "b/", "c" }, "/a/b/c");
67	assert(mem.eql(u8, try joinPosix(debug.global_allocator, "/a/", "b/", "c"), "/a/b/c"));	124	testJoinPosix([][]const u8{ "/a/", "b/", "c" }, "/a/b/c");
68		125
69	assert(mem.eql(u8, try joinPosix(debug.global_allocator, "/home/andy/dev/zig/build/lib/zig/std", "io.zig"), "/home/andy/dev/zig/build/lib/zig/std/io.zig"));	126	testJoinPosix(
		127	[][]const u8{ "/home/andy/dev/zig/build/lib/zig/std", "io.zig" },
		128	"/home/andy/dev/zig/build/lib/zig/std/io.zig",
		129	);
		130
		131	testJoinPosix([][]const u8{ "a", "/c" }, "a/c");
		132	testJoinPosix([][]const u8{ "a/", "/c" }, "a/c");
70	}	133	}
71		134
72	pub fn isAbsolute(path: []const u8) bool {	135	pub fn isAbsolute(path: []const u8) bool {
...	@@ -312,18 +375,8 @@ fn asciiEqlIgnoreCase(s1: []const u8, s2: []const u8) bool {	...	@@ -312,18 +375,8 @@ fn asciiEqlIgnoreCase(s1: []const u8, s2: []const u8) bool {
312	return true;	375	return true;
313	}	376	}
314		377
315	/// Converts the command line arguments into a slice and calls `resolveSlice`.
316	pub fn resolve(allocator: *Allocator, args: ...) ![]u8 {
317	var paths: [args.len][]const u8 = undefined;
318	comptime var arg_i = 0;
319	inline while (arg_i < args.len) : (arg_i += 1) {
320	paths[arg_i] = args[arg_i];
321	}
322	return resolveSlice(allocator, paths);
323	}
324
325	/// On Windows, this calls `resolveWindows` and on POSIX it calls `resolvePosix`.	378	/// On Windows, this calls `resolveWindows` and on POSIX it calls `resolvePosix`.
326	pub fn resolveSlice(allocator: *Allocator, paths: []const []const u8) ![]u8 {	379	pub fn resolve(allocator: *Allocator, paths: []const []const u8) ![]u8 {
327	if (is_windows) {	380	if (is_windows) {
328	return resolveWindows(allocator, paths);	381	return resolveWindows(allocator, paths);
329	} else {	382	} else {
...	@@ -602,7 +655,10 @@ test "os.path.resolveWindows" {	...	@@ -602,7 +655,10 @@ test "os.path.resolveWindows" {
602	const parsed_cwd = windowsParsePath(cwd);	655	const parsed_cwd = windowsParsePath(cwd);
603	{	656	{
604	const result = testResolveWindows([][]const u8{ "/usr/local", "lib\\zig\\std\\array_list.zig" });	657	const result = testResolveWindows([][]const u8{ "/usr/local", "lib\\zig\\std\\array_list.zig" });
605	const expected = try join(debug.global_allocator, parsed_cwd.disk_designator, "usr\\local\\lib\\zig\\std\\array_list.zig");	658	const expected = try join(debug.global_allocator, [][]const u8{
		659	parsed_cwd.disk_designator,
		660	"usr\\local\\lib\\zig\\std\\array_list.zig",
		661	});
606	if (parsed_cwd.kind == WindowsPath.Kind.Drive) {	662	if (parsed_cwd.kind == WindowsPath.Kind.Drive) {
607	expected[0] = asciiUpper(parsed_cwd.disk_designator[0]);	663	expected[0] = asciiUpper(parsed_cwd.disk_designator[0]);
608	}	664	}
...	@@ -610,7 +666,10 @@ test "os.path.resolveWindows" {	...	@@ -610,7 +666,10 @@ test "os.path.resolveWindows" {
610	}	666	}
611	{	667	{
612	const result = testResolveWindows([][]const u8{ "usr/local", "lib\\zig" });	668	const result = testResolveWindows([][]const u8{ "usr/local", "lib\\zig" });
613	const expected = try join(debug.global_allocator, cwd, "usr\\local\\lib\\zig");	669	const expected = try join(debug.global_allocator, [][]const u8{
		670	cwd,
		671	"usr\\local\\lib\\zig",
		672	});
614	if (parsed_cwd.kind == WindowsPath.Kind.Drive) {	673	if (parsed_cwd.kind == WindowsPath.Kind.Drive) {
615	expected[0] = asciiUpper(parsed_cwd.disk_designator[0]);	674	expected[0] = asciiUpper(parsed_cwd.disk_designator[0]);
616	}	675	}

std/os/test.zig+16

...	@@ -105,3 +105,19 @@ test "AtomicFile" {	...	@@ -105,3 +105,19 @@ test "AtomicFile" {
105		105
106	try os.deleteFile(test_out_file);	106	try os.deleteFile(test_out_file);
107	}	107	}
		108
		109	test "thread local storage" {
		110	if (builtin.single_threaded) return error.SkipZigTest;
		111	const thread1 = try std.os.spawnThread({}, testTls);
		112	const thread2 = try std.os.spawnThread({}, testTls);
		113	testTls({});
		114	thread1.wait();
		115	thread2.wait();
		116	}
		117
		118	threadlocal var x: i32 = 1234;
		119	fn testTls(context: void) void {
		120	if (x != 1234) @panic("bad start value");
		121	x += 1;
		122	if (x != 1235) @panic("bad end value");
		123	}

std/os/windows/index.zig+18-1

...	@@ -49,7 +49,10 @@ pub const UNICODE = false;	...	@@ -49,7 +49,10 @@ pub const UNICODE = false;
49	pub const WCHAR = u16;	49	pub const WCHAR = u16;
50	pub const WORD = u16;	50	pub const WORD = u16;
51	pub const LARGE_INTEGER = i64;	51	pub const LARGE_INTEGER = i64;
52	pub const LONG = c_long;	52	pub const ULONG = u32;
		53	pub const LONG = i32;
		54	pub const ULONGLONG = u64;
		55	pub const LONGLONG = i64;
53		56
54	pub const TRUE = 1;	57	pub const TRUE = 1;
55	pub const FALSE = 0;	58	pub const FALSE = 0;
...	@@ -380,3 +383,17 @@ pub const COORD = extern struct {	...	@@ -380,3 +383,17 @@ pub const COORD = extern struct {
380	};	383	};
381		384
382	pub const CREATE_UNICODE_ENVIRONMENT = 1024;	385	pub const CREATE_UNICODE_ENVIRONMENT = 1024;
		386
		387	pub const TLS_OUT_OF_INDEXES = 4294967295;
		388	pub const IMAGE_TLS_DIRECTORY = extern struct {
		389	StartAddressOfRawData: usize,
		390	EndAddressOfRawData: usize,
		391	AddressOfIndex: usize,
		392	AddressOfCallBacks: usize,
		393	SizeOfZeroFill: u32,
		394	Characteristics: u32,
		395	};
		396	pub const IMAGE_TLS_DIRECTORY64 = IMAGE_TLS_DIRECTORY;
		397	pub const IMAGE_TLS_DIRECTORY32 = IMAGE_TLS_DIRECTORY;
		398
		399	pub const PIMAGE_TLS_CALLBACK = ?extern fn(PVOID, DWORD, PVOID) void;

std/os/windows/kernel32.zig+4

...	@@ -164,6 +164,10 @@ pub extern "kernel32" stdcallcc fn Sleep(dwMilliseconds: DWORD) void;	...	@@ -164,6 +164,10 @@ pub extern "kernel32" stdcallcc fn Sleep(dwMilliseconds: DWORD) void;
164		164
165	pub extern "kernel32" stdcallcc fn TerminateProcess(hProcess: HANDLE, uExitCode: UINT) BOOL;	165	pub extern "kernel32" stdcallcc fn TerminateProcess(hProcess: HANDLE, uExitCode: UINT) BOOL;
166		166
		167	pub extern "kernel32" stdcallcc fn TlsAlloc() DWORD;
		168
		169	pub extern "kernel32" stdcallcc fn TlsFree(dwTlsIndex: DWORD) BOOL;
		170
167	pub extern "kernel32" stdcallcc fn WaitForSingleObject(hHandle: HANDLE, dwMilliseconds: DWORD) DWORD;	171	pub extern "kernel32" stdcallcc fn WaitForSingleObject(hHandle: HANDLE, dwMilliseconds: DWORD) DWORD;
168		172
169	pub extern "kernel32" stdcallcc fn WriteFile(	173	pub extern "kernel32" stdcallcc fn WriteFile(

std/os/windows/tls.zig created+36

...	@@ -0,0 +1,36 @@
1	const std = @import("../../index.zig");
2
3	export var _tls_index: u32 = std.os.windows.TLS_OUT_OF_INDEXES;
4	export var _tls_start: u8 linksection(".tls") = 0;
5	export var _tls_end: u8 linksection(".tls$ZZZ") = 0;
6	export var __xl_a: std.os.windows.PIMAGE_TLS_CALLBACK linksection(".CRT$XLA") = null;
7	export var __xl_z: std.os.windows.PIMAGE_TLS_CALLBACK linksection(".CRT$XLZ") = null;
8
9	// TODO this is how I would like it to be expressed
10	// TODO also note, ReactOS has a +1 on StartAddressOfRawData and AddressOfCallBacks. Investigate
11	// why they do that.
12	//export const _tls_used linksection(".rdata$T") = std.os.windows.IMAGE_TLS_DIRECTORY {
13	// .StartAddressOfRawData = @ptrToInt(&_tls_start),
14	// .EndAddressOfRawData = @ptrToInt(&_tls_end),
15	// .AddressOfIndex = @ptrToInt(&_tls_index),
16	// .AddressOfCallBacks = @ptrToInt(__xl_a),
17	// .SizeOfZeroFill = 0,
18	// .Characteristics = 0,
19	//};
20	// This is the workaround because we can't do @ptrToInt at comptime like that.
21	pub const IMAGE_TLS_DIRECTORY = extern struct {
22	StartAddressOfRawData: *c_void,
23	EndAddressOfRawData: *c_void,
24	AddressOfIndex: *c_void,
25	AddressOfCallBacks: *c_void,
26	SizeOfZeroFill: u32,
27	Characteristics: u32,
28	};
29	export const _tls_used linksection(".rdata$T") = IMAGE_TLS_DIRECTORY {
30	.StartAddressOfRawData = &_tls_start,
31	.EndAddressOfRawData = &_tls_end,
32	.AddressOfIndex = &_tls_index,
33	.AddressOfCallBacks = &__xl_a,
34	.SizeOfZeroFill = 0,
35	.Characteristics = 0,
36	};

std/special/bootstrap.zig+59-4

...	@@ -4,6 +4,7 @@	...	@@ -4,6 +4,7 @@
4	const root = @import("@root");	4	const root = @import("@root");
5	const std = @import("std");	5	const std = @import("std");
6	const builtin = @import("builtin");	6	const builtin = @import("builtin");
		7	const assert = std.debug.assert;
7		8
8	var argc_ptr: [*]usize = undefined;	9	var argc_ptr: [*]usize = undefined;
9		10
...	@@ -44,7 +45,9 @@ nakedcc fn _start() noreturn {	...	@@ -44,7 +45,9 @@ nakedcc fn _start() noreturn {
44		45
45	extern fn WinMainCRTStartup() noreturn {	46	extern fn WinMainCRTStartup() noreturn {
46	@setAlignStack(16);	47	@setAlignStack(16);
47		48	if (!builtin.single_threaded) {
		49	_ = @import("../os/windows/tls.zig");
		50	}
48	std.os.windows.ExitProcess(callMain());	51	std.os.windows.ExitProcess(callMain());
49	}	52	}
50		53
...	@@ -61,9 +64,23 @@ fn posixCallMainAndExit() noreturn {	...	@@ -61,9 +64,23 @@ fn posixCallMainAndExit() noreturn {
61	while (envp_optional[envp_count]) \|_\| : (envp_count += 1) {}	64	while (envp_optional[envp_count]) \|_\| : (envp_count += 1) {}
62	const envp = @ptrCast([][]u8, envp_optional)[0..envp_count];	65	const envp = @ptrCast([][]u8, envp_optional)[0..envp_count];
63	if (builtin.os == builtin.Os.linux) {	66	if (builtin.os == builtin.Os.linux) {
64	const auxv = @ptrCast([*]usize, envp.ptr + envp_count + 1);	67	// Scan auxiliary vector.
65	std.os.linux_elf_aux_maybe = @ptrCast([*]std.elf.Auxv, auxv);	68	const auxv = @ptrCast([*]std.elf.Auxv, envp.ptr + envp_count + 1);
66	std.debug.assert(std.os.linuxGetAuxVal(std.elf.AT_PAGESZ) == std.os.page_size);	69	std.os.linux_elf_aux_maybe = auxv;
		70	var i: usize = 0;
		71	var at_phdr: usize = 0;
		72	var at_phnum: usize = 0;
		73	var at_phent: usize = 0;
		74	while (auxv[i].a_un.a_val != 0) : (i += 1) {
		75	switch (auxv[i].a_type) {
		76	std.elf.AT_PAGESZ => assert(auxv[i].a_un.a_val == std.os.page_size),
		77	std.elf.AT_PHDR => at_phdr = auxv[i].a_un.a_val,
		78	std.elf.AT_PHNUM => at_phnum = auxv[i].a_un.a_val,
		79	std.elf.AT_PHENT => at_phent = auxv[i].a_un.a_val,
		80	else => {},
		81	}
		82	}
		83	if (!builtin.single_threaded) linuxInitializeThreadLocalStorage(at_phdr, at_phnum, at_phent);
67	}	84	}
68		85
69	std.os.posix.exit(callMainWithArgs(argc, argv, envp));	86	std.os.posix.exit(callMainWithArgs(argc, argv, envp));
...	@@ -116,3 +133,41 @@ inline fn callMain() u8 {	...	@@ -116,3 +133,41 @@ inline fn callMain() u8 {
116	else => @compileError("expected return type of main to be 'u8', 'noreturn', 'void', or '!void'"),	133	else => @compileError("expected return type of main to be 'u8', 'noreturn', 'void', or '!void'"),
117	}	134	}
118	}	135	}
		136
		137	var tls_end_addr: usize = undefined;
		138	const main_thread_tls_align = 32;
		139	var main_thread_tls_bytes: [64]u8 align(main_thread_tls_align) = [1]u8{0} ** 64;
		140
		141	fn linuxInitializeThreadLocalStorage(at_phdr: usize, at_phnum: usize, at_phent: usize) void {
		142	var phdr_addr = at_phdr;
		143	var n = at_phnum;
		144	var base: usize = 0;
		145	while (n != 0) : ({n -= 1; phdr_addr += at_phent;}) {
		146	const phdr = @intToPtr(*std.elf.Phdr, phdr_addr);
		147	// TODO look for PT_DYNAMIC when we have https://github.com/ziglang/zig/issues/1917
		148	switch (phdr.p_type) {
		149	std.elf.PT_PHDR => base = at_phdr - phdr.p_vaddr,
		150	std.elf.PT_TLS => std.os.linux_tls_phdr = phdr,
		151	else => continue,
		152	}
		153	}
		154	const tls_phdr = std.os.linux_tls_phdr orelse return;
		155	std.os.linux_tls_img_src = @intToPtr([*]const u8, base + tls_phdr.p_vaddr);
		156	assert(main_thread_tls_bytes.len >= tls_phdr.p_memsz); // not enough preallocated Thread Local Storage
		157	assert(main_thread_tls_align >= tls_phdr.p_align); // preallocated Thread Local Storage not aligned enough
		158	@memcpy(&main_thread_tls_bytes, std.os.linux_tls_img_src, tls_phdr.p_filesz);
		159	tls_end_addr = @ptrToInt(&main_thread_tls_bytes) + tls_phdr.p_memsz;
		160	linuxSetThreadArea(@ptrToInt(&tls_end_addr));
		161	}
		162
		163	fn linuxSetThreadArea(addr: usize) void {
		164	switch (builtin.arch) {
		165	builtin.Arch.x86_64 => {
		166	const ARCH_SET_FS = 0x1002;
		167	const rc = std.os.linux.syscall2(std.os.linux.SYS_arch_prctl, ARCH_SET_FS, addr);
		168	// acrh_prctl is documented to never fail
		169	assert(rc == 0);
		170	},
		171	else => @compileError("Unsupported architecture"),
		172	}
		173	}

test/cli.zig+4-4

test/compile_errors.zig+19

...	@@ -1,6 +1,25 @@	...	@@ -1,6 +1,25 @@
1	const tests = @import("tests.zig");	1	const tests = @import("tests.zig");
2		2
3	pub fn addCases(cases: *tests.CompileErrorContext) void {	3	pub fn addCases(cases: *tests.CompileErrorContext) void {
		4	cases.add(
		5	"threadlocal qualifier on const",
		6	\\threadlocal const x: i32 = 1234;
		7	\\export fn entry() i32 {
		8	\\ return x;
		9	\\}
		10	,
		11	".tmp_source.zig:1:13: error: threadlocal variable cannot be constant",
		12	);
		13
		14	cases.add(
		15	"threadlocal qualifier on local variable",
		16	\\export fn entry() void {
		17	\\ threadlocal var x: i32 = 1234;
		18	\\}
		19	,
		20	".tmp_source.zig:2:5: error: function-local variable 'x' cannot be threadlocal",
		21	);
		22
4	cases.add(	23	cases.add(
5	"@bitCast same size but bit count mismatch",	24	"@bitCast same size but bit count mismatch",
6	\\export fn entry(byte: u8) void {	25	\\export fn entry(byte: u8) void {

test/stage1/behavior/misc.zig+8

...	@@ -685,3 +685,11 @@ test "fn call returning scalar optional in equality expression" {	...	@@ -685,3 +685,11 @@ test "fn call returning scalar optional in equality expression" {
685	fn getNull() ?*i32 {	685	fn getNull() ?*i32 {
686	return null;	686	return null;
687	}	687	}
		688
		689	test "thread local variable" {
		690	const S = struct {
		691	threadlocal var t: i32 = 1234;
		692	};
		693	S.t += 1;
		694	assertOrPanic(S.t == 1235);
		695	}

test/stage1/behavior/vector.zig+7-10

 @@ -1,20 +1,17 @@
 const std = @import("std");
+const mem = std.mem;
 const assertOrPanic = std.debug.assertOrPanic;
-test "implicit array to vector and vector to array" {
+test "vector wrap operators" {
     const S = struct {
         fn doTheTest() void {
-            var v: @Vector(4, i32) = [4]i32{10, 20, 30, 40};
+            const v: @Vector(4, i32) = [4]i32{ 10, 20, 30, 40 };
-            const x: @Vector(4, i32) = [4]i32{1, 2, 3, 4};
+            const x: @Vector(4, i32) = [4]i32{ 1, 2, 3, 4 };
-            v +%= x;
+            assertOrPanic(mem.eql(i32, ([4]i32)(v +% x), [4]i32{ 11, 22, 33, 44 }));
-            const result: [4]i32 = v;
+            assertOrPanic(mem.eql(i32, ([4]i32)(v -% x), [4]i32{ 9, 18, 27, 36 }));
-            assertOrPanic(result[0] == 11);
+            assertOrPanic(mem.eql(i32, ([4]i32)(v *% x), [4]i32{ 10, 40, 90, 160 }));
-            assertOrPanic(result[1] == 22);
-            assertOrPanic(result[2] == 33);
-            assertOrPanic(result[3] == 44);
         }
     };
     S.doTheTest();
     comptime S.doTheTest();
 }

test/tests.zig+47-11

 @@ -194,6 +194,9 @@ pub fn addPkgTests(b: *build.Builder, test_filter: ?[]const u8, root_src: []cons
                     if (link_libc) {
                         these_tests.linkSystemLibrary("c");
                     }
+                    if (mem.eql(u8, name, "std")) {
+                        these_tests.overrideStdDir("std");
+                    }
                     step.dependOn(&these_tests.step);
                 }
             }
 @@ -436,7 +439,10 @@ pub const CompareOutputContext = struct {
     pub fn addCase(self: *CompareOutputContext, case: TestCase) void {
         const b = self.b;
-        const root_src = os.path.join(b.allocator, b.cache_root, case.sources.items[0].filename) catch unreachable;
+        const root_src = os.path.join(
+            b.allocator,
+            [][]const u8{ b.cache_root, case.sources.items[0].filename },
+        ) catch unreachable;
         switch (case.special) {
             Special.Asm => {
 @@ -449,7 +455,10 @@ pub const CompareOutputContext = struct {
                 exe.addAssemblyFile(root_src);
                 for (case.sources.toSliceConst()) |src_file| {
-                    const expanded_src_path = os.path.join(b.allocator, b.cache_root, src_file.filename) catch unreachable;
+                    const expanded_src_path = os.path.join(
+                        b.allocator,
+                        [][]const u8{ b.cache_root, src_file.filename },
+                    ) catch unreachable;
                     const write_src = b.addWriteFile(expanded_src_path, src_file.source);
                     exe.step.dependOn(&write_src.step);
                 }
 @@ -473,7 +482,10 @@ pub const CompareOutputContext = struct {
                     }
                     for (case.sources.toSliceConst()) |src_file| {
-                        const expanded_src_path = os.path.join(b.allocator, b.cache_root, src_file.filename) catch unreachable;
+                        const expanded_src_path = os.path.join(
+                            b.allocator,
+                            [][]const u8{ b.cache_root, src_file.filename },
+                        ) catch unreachable;
                         const write_src = b.addWriteFile(expanded_src_path, src_file.source);
                         exe.step.dependOn(&write_src.step);
                     }
 @@ -496,7 +508,10 @@ pub const CompareOutputContext = struct {
                 }
                 for (case.sources.toSliceConst()) |src_file| {
-                    const expanded_src_path = os.path.join(b.allocator, b.cache_root, src_file.filename) catch unreachable;
+                    const expanded_src_path = os.path.join(
+                        b.allocator,
+                        [][]const u8{ b.cache_root, src_file.filename },
+                    ) catch unreachable;
                     const write_src = b.addWriteFile(expanded_src_path, src_file.source);
                     exe.step.dependOn(&write_src.step);
                 }
 @@ -569,8 +584,14 @@ pub const CompileErrorContext = struct {
             const self = @fieldParentPtr(CompileCmpOutputStep, "step", step);
             const b = self.context.b;
-            const root_src = os.path.join(b.allocator, b.cache_root, self.case.sources.items[0].filename) catch unreachable;
+            const root_src = os.path.join(
-            const obj_path = os.path.join(b.allocator, b.cache_root, "test.o") catch unreachable;
+                b.allocator,
+                [][]const u8{ b.cache_root, self.case.sources.items[0].filename },
+            ) catch unreachable;
+            const obj_path = os.path.join(
+                b.allocator,
+                [][]const u8{ b.cache_root, "test.o" },
+            ) catch unreachable;
             var zig_args = ArrayList([]const u8).init(b.allocator);
             zig_args.append(b.zig_exe) catch unreachable;
 @@ -718,7 +739,10 @@ pub const CompileErrorContext = struct {
             self.step.dependOn(&compile_and_cmp_errors.step);
             for (case.sources.toSliceConst()) |src_file| {
-                const expanded_src_path = os.path.join(b.allocator, b.cache_root, src_file.filename) catch unreachable;
+                const expanded_src_path = os.path.join(
+                    b.allocator,
+                    [][]const u8{ b.cache_root, src_file.filename },
+                ) catch unreachable;
                 const write_src = b.addWriteFile(expanded_src_path, src_file.source);
                 compile_and_cmp_errors.step.dependOn(&write_src.step);
             }
 @@ -849,7 +873,10 @@ pub const TranslateCContext = struct {
             const self = @fieldParentPtr(TranslateCCmpOutputStep, "step", step);
             const b = self.context.b;
-            const root_src = os.path.join(b.allocator, b.cache_root, self.case.sources.items[0].filename) catch unreachable;
+            const root_src = os.path.join(
+                b.allocator,
+                [][]const u8{ b.cache_root, self.case.sources.items[0].filename },
+            ) catch unreachable;
             var zig_args = ArrayList([]const u8).init(b.allocator);
             zig_args.append(b.zig_exe) catch unreachable;
 @@ -983,7 +1010,10 @@ pub const TranslateCContext = struct {
         self.step.dependOn(&translate_c_and_cmp.step);
         for (case.sources.toSliceConst()) |src_file| {
-            const expanded_src_path = os.path.join(b.allocator, b.cache_root, src_file.filename) catch unreachable;
+            const expanded_src_path = os.path.join(
+                b.allocator,
+                [][]const u8{ b.cache_root, src_file.filename },
+            ) catch unreachable;
             const write_src = b.addWriteFile(expanded_src_path, src_file.source);
             translate_c_and_cmp.step.dependOn(&write_src.step);
         }
 @@ -1098,7 +1128,10 @@ pub const GenHContext = struct {
     pub fn addCase(self: *GenHContext, case: *const TestCase) void {
         const b = self.b;
-        const root_src = os.path.join(b.allocator, b.cache_root, case.sources.items[0].filename) catch unreachable;
+        const root_src = os.path.join(
+            b.allocator,
+            [][]const u8{ b.cache_root, case.sources.items[0].filename },
+        ) catch unreachable;
         const mode = builtin.Mode.Debug;
         const annotated_case_name = fmt.allocPrint(self.b.allocator, "gen-h {} ({})", case.name, @tagName(mode)) catch unreachable;
 @@ -1110,7 +1143,10 @@ pub const GenHContext = struct {
         obj.setBuildMode(mode);
         for (case.sources.toSliceConst()) |src_file| {
-            const expanded_src_path = os.path.join(b.allocator, b.cache_root, src_file.filename) catch unreachable;
+            const expanded_src_path = os.path.join(
+                b.allocator,
+                [][]const u8{ b.cache_root, src_file.filename },
+            ) catch unreachable;
             const write_src = b.addWriteFile(expanded_src_path, src_file.source);
             obj.step.dependOn(&write_src.step);
         }

author	Andrew Kelley <andrew@ziglang.org> 2019-02-07 12:21:20-05:00
committer	Andrew Kelley <andrew@ziglang.org> 2019-02-07 12:21:20-05:00
log	a94304d3e4b9220d2b22501eb2666e5aa89df236
tree	a3b85b53581853b62dabf6f763feca099e4fee84
parent	d974afde1d366a28f1b07bff6ebfb5c5756d3b61
parent	2b2bf53a49616192e2b2bdf40b88400964ff1500
signature	Commit is signed but in an unrecognized format.

...	@@ -487,7 +487,7 @@ pub const Compilation = struct {	...	@@ -487,7 +487,7 @@ pub const Compilation = struct {
487	comp.name = try Buffer.init(comp.arena(), name);	487	comp.name = try Buffer.init(comp.arena(), name);
488	comp.llvm_triple = try target.getTriple(comp.arena());	488	comp.llvm_triple = try target.getTriple(comp.arena());
489	comp.llvm_target = try Target.llvmTargetFromTriple(comp.llvm_triple);	489	comp.llvm_target = try Target.llvmTargetFromTriple(comp.llvm_triple);
490	comp.zig_std_dir = try std.os.path.join(comp.arena(), zig_lib_dir, "std");	490	comp.zig_std_dir = try std.os.path.join(comp.arena(), [][]const u8{ zig_lib_dir, "std" });
491		491
492	const opt_level = switch (build_mode) {	492	const opt_level = switch (build_mode) {
493	builtin.Mode.Debug => llvm.CodeGenLevelNone,	493	builtin.Mode.Debug => llvm.CodeGenLevelNone,
...	@@ -1198,7 +1198,7 @@ pub const Compilation = struct {	...	@@ -1198,7 +1198,7 @@ pub const Compilation = struct {
1198	const file_name = try std.fmt.allocPrint(self.gpa(), "{}{}", file_prefix[0..], suffix);	1198	const file_name = try std.fmt.allocPrint(self.gpa(), "{}{}", file_prefix[0..], suffix);
1199	defer self.gpa().free(file_name);	1199	defer self.gpa().free(file_name);
1200		1200
1201	const full_path = try os.path.join(self.gpa(), tmp_dir, file_name[0..]);	1201	const full_path = try os.path.join(self.gpa(), [][]const u8{ tmp_dir, file_name[0..] });
1202	errdefer self.gpa().free(full_path);	1202	errdefer self.gpa().free(full_path);
1203		1203
1204	return Buffer.fromOwnedSlice(self.gpa(), full_path);	1204	return Buffer.fromOwnedSlice(self.gpa(), full_path);
...	@@ -1219,7 +1219,7 @@ pub const Compilation = struct {	...	@@ -1219,7 +1219,7 @@ pub const Compilation = struct {
1219	const zig_dir_path = try getZigDir(self.gpa());	1219	const zig_dir_path = try getZigDir(self.gpa());
1220	defer self.gpa().free(zig_dir_path);	1220	defer self.gpa().free(zig_dir_path);
1221		1221
1222	const tmp_dir = try os.path.join(self.arena(), zig_dir_path, comp_dir_name[0..]);	1222	const tmp_dir = try os.path.join(self.arena(), [][]const u8{ zig_dir_path, comp_dir_name[0..] });
1223	try os.makePath(self.gpa(), tmp_dir);	1223	try os.makePath(self.gpa(), tmp_dir);
1224	return tmp_dir;	1224	return tmp_dir;
1225	}	1225	}

...	@@ -74,6 +74,7 @@ static int print_full_usage(const char *arg0) {	...	@@ -74,6 +74,7 @@ static int print_full_usage(const char *arg0) {
74	" -dirafter [dir] same as -isystem but do it last\n"	74	" -dirafter [dir] same as -isystem but do it last\n"
75	" -isystem [dir] add additional search path for other .h files\n"	75	" -isystem [dir] add additional search path for other .h files\n"
76	" -mllvm [arg] forward an arg to LLVM's option processing\n"	76	" -mllvm [arg] forward an arg to LLVM's option processing\n"
		77	" --override-std-dir [arg] use an alternate Zig standard library\n"
77	"\n"	78	"\n"
78	"Link Options:\n"	79	"Link Options:\n"
79	" --dynamic-linker [path] set the path to ld.so\n"	80	" --dynamic-linker [path] set the path to ld.so\n"
...	@@ -395,6 +396,7 @@ int main(int argc, char **argv) {	...	@@ -395,6 +396,7 @@ int main(int argc, char **argv) {
395	bool system_linker_hack = false;	396	bool system_linker_hack = false;
396	TargetSubsystem subsystem = TargetSubsystemAuto;	397	TargetSubsystem subsystem = TargetSubsystemAuto;
397	bool is_single_threaded = false;	398	bool is_single_threaded = false;
		399	Buf *override_std_dir = nullptr;
398		400
399	if (argc >= 2 && strcmp(argv[1], "build") == 0) {	401	if (argc >= 2 && strcmp(argv[1], "build") == 0) {
400	Buf zig_exe_path_buf = BUF_INIT;	402	Buf zig_exe_path_buf = BUF_INIT;
...	@@ -430,7 +432,8 @@ int main(int argc, char **argv) {	...	@@ -430,7 +432,8 @@ int main(int argc, char **argv) {
430	Buf *build_runner_path = buf_alloc();	432	Buf *build_runner_path = buf_alloc();
431	os_path_join(get_zig_special_dir(), buf_create_from_str("build_runner.zig"), build_runner_path);	433	os_path_join(get_zig_special_dir(), buf_create_from_str("build_runner.zig"), build_runner_path);
432		434
433	CodeGen *g = codegen_create(build_runner_path, nullptr, OutTypeExe, BuildModeDebug, get_zig_lib_dir());	435	CodeGen *g = codegen_create(build_runner_path, nullptr, OutTypeExe, BuildModeDebug, get_zig_lib_dir(),
		436	override_std_dir);
434	g->enable_time_report = timing_info;	437	g->enable_time_report = timing_info;
435	buf_init_from_str(&g->cache_dir, cache_dir ? cache_dir : default_zig_cache_name);	438	buf_init_from_str(&g->cache_dir, cache_dir ? cache_dir : default_zig_cache_name);
436	codegen_set_out_name(g, buf_create_from_str("build"));	439	codegen_set_out_name(g, buf_create_from_str("build"));
...	@@ -645,6 +648,8 @@ int main(int argc, char **argv) {	...	@@ -645,6 +648,8 @@ int main(int argc, char **argv) {
645	clang_argv.append(argv[i]);	648	clang_argv.append(argv[i]);
646		649
647	llvm_argv.append(argv[i]);	650	llvm_argv.append(argv[i]);
		651	} else if (strcmp(arg, "--override-std-dir") == 0) {
		652	override_std_dir = buf_create_from_str(argv[i]);
648	} else if (strcmp(arg, "--library-path") == 0 \|\| strcmp(arg, "-L") == 0) {	653	} else if (strcmp(arg, "--library-path") == 0 \|\| strcmp(arg, "-L") == 0) {
649	lib_dirs.append(argv[i]);	654	lib_dirs.append(argv[i]);
650	} else if (strcmp(arg, "--library") == 0) {	655	} else if (strcmp(arg, "--library") == 0) {
...	@@ -819,7 +824,7 @@ int main(int argc, char **argv) {	...	@@ -819,7 +824,7 @@ int main(int argc, char **argv) {
819		824
820	switch (cmd) {	825	switch (cmd) {
821	case CmdBuiltin: {	826	case CmdBuiltin: {
822	CodeGen *g = codegen_create(nullptr, target, out_type, build_mode, get_zig_lib_dir());	827	CodeGen *g = codegen_create(nullptr, target, out_type, build_mode, get_zig_lib_dir(), override_std_dir);
823	g->is_single_threaded = is_single_threaded;	828	g->is_single_threaded = is_single_threaded;
824	Buf *builtin_source = codegen_generate_builtin_source(g);	829	Buf *builtin_source = codegen_generate_builtin_source(g);
825	if (fwrite(buf_ptr(builtin_source), 1, buf_len(builtin_source), stdout) != buf_len(builtin_source)) {	830	if (fwrite(buf_ptr(builtin_source), 1, buf_len(builtin_source), stdout) != buf_len(builtin_source)) {
...	@@ -878,7 +883,8 @@ int main(int argc, char **argv) {	...	@@ -878,7 +883,8 @@ int main(int argc, char **argv) {
878	if (cmd == CmdRun && buf_out_name == nullptr) {	883	if (cmd == CmdRun && buf_out_name == nullptr) {
879	buf_out_name = buf_create_from_str("run");	884	buf_out_name = buf_create_from_str("run");
880	}	885	}
881	CodeGen *g = codegen_create(zig_root_source_file, target, out_type, build_mode, get_zig_lib_dir());	886	CodeGen *g = codegen_create(zig_root_source_file, target, out_type, build_mode, get_zig_lib_dir(),
		887	override_std_dir);
882	g->subsystem = subsystem;	888	g->subsystem = subsystem;
883		889
884	if (disable_pic) {	890	if (disable_pic) {

...	@@ -146,6 +146,7 @@ static const struct ZigKeyword zig_keywords[] = {	...	@@ -146,6 +146,7 @@ static const struct ZigKeyword zig_keywords[] = {
146	{"suspend", TokenIdKeywordSuspend},	146	{"suspend", TokenIdKeywordSuspend},
147	{"switch", TokenIdKeywordSwitch},	147	{"switch", TokenIdKeywordSwitch},
148	{"test", TokenIdKeywordTest},	148	{"test", TokenIdKeywordTest},
		149	{"threadlocal", TokenIdKeywordThreadLocal},
149	{"true", TokenIdKeywordTrue},	150	{"true", TokenIdKeywordTrue},
150	{"try", TokenIdKeywordTry},	151	{"try", TokenIdKeywordTry},
151	{"undefined", TokenIdKeywordUndefined},	152	{"undefined", TokenIdKeywordUndefined},
...	@@ -1586,6 +1587,7 @@ const char * token_name(TokenId id) {	...	@@ -1586,6 +1587,7 @@ const char * token_name(TokenId id) {
1586	case TokenIdKeywordStruct: return "struct";	1587	case TokenIdKeywordStruct: return "struct";
1587	case TokenIdKeywordSwitch: return "switch";	1588	case TokenIdKeywordSwitch: return "switch";
1588	case TokenIdKeywordTest: return "test";	1589	case TokenIdKeywordTest: return "test";
		1590	case TokenIdKeywordThreadLocal: return "threadlocal";
1589	case TokenIdKeywordTrue: return "true";	1591	case TokenIdKeywordTrue: return "true";
1590	case TokenIdKeywordTry: return "try";	1592	case TokenIdKeywordTry: return "try";
1591	case TokenIdKeywordUndefined: return "undefined";	1593	case TokenIdKeywordUndefined: return "undefined";

...	@@ -37,7 +37,6 @@ const Module = struct {	...	@@ -37,7 +37,6 @@ const Module = struct {
37	var stderr_file: os.File = undefined;	37	var stderr_file: os.File = undefined;
38	var stderr_file_out_stream: os.File.OutStream = undefined;	38	var stderr_file_out_stream: os.File.OutStream = undefined;
39		39
40	/// TODO multithreaded awareness
41	var stderr_stream: ?*io.OutStream(os.File.WriteError) = null;	40	var stderr_stream: ?*io.OutStream(os.File.WriteError) = null;
42	var stderr_mutex = std.Mutex.init();	41	var stderr_mutex = std.Mutex.init();
43	pub fn warn(comptime fmt: []const u8, args: ...) void {	42	pub fn warn(comptime fmt: []const u8, args: ...) void {
...	@@ -775,7 +774,7 @@ fn openSelfDebugInfoWindows(allocator: *mem.Allocator) !DebugInfo {	...	@@ -775,7 +774,7 @@ fn openSelfDebugInfoWindows(allocator: *mem.Allocator) !DebugInfo {
775	const len = try di.coff.getPdbPath(path_buf[0..]);	774	const len = try di.coff.getPdbPath(path_buf[0..]);
776	const raw_path = path_buf[0..len];	775	const raw_path = path_buf[0..len];
777		776
778	const path = try os.path.resolve(allocator, raw_path);	777	const path = try os.path.resolve(allocator, [][]const u8{raw_path});
779		778
780	try di.pdb.openFile(di.coff, path);	779	try di.pdb.openFile(di.coff, path);
781		780
...	@@ -1353,7 +1352,7 @@ const LineNumberProgram = struct {	...	@@ -1353,7 +1352,7 @@ const LineNumberProgram = struct {
1353	return error.InvalidDebugInfo;	1352	return error.InvalidDebugInfo;
1354	} else	1353	} else
1355	self.include_dirs[file_entry.dir_index];	1354	self.include_dirs[file_entry.dir_index];
1356	const file_name = try os.path.join(self.file_entries.allocator, dir_name, file_entry.file_name);	1355	const file_name = try os.path.join(self.file_entries.allocator, [][]const u8{ dir_name, file_entry.file_name });
1357	errdefer self.file_entries.allocator.free(file_name);	1356	errdefer self.file_entries.allocator.free(file_name);
1358	return LineInfo{	1357	return LineInfo{
1359	.line = if (self.prev_line >= 0) @intCast(usize, self.prev_line) else 0,	1358	.line = if (self.prev_line >= 0) @intCast(usize, self.prev_line) else 0,

...	@@ -106,9 +106,7 @@ pub const DirectAllocator = struct {	...	@@ -106,9 +106,7 @@ pub const DirectAllocator = struct {
106	};	106	};
107	const ptr = os.windows.HeapAlloc(heap_handle, 0, amt) orelse return error.OutOfMemory;	107	const ptr = os.windows.HeapAlloc(heap_handle, 0, amt) orelse return error.OutOfMemory;
108	const root_addr = @ptrToInt(ptr);	108	const root_addr = @ptrToInt(ptr);
109	const rem = @rem(root_addr, alignment);	109	const adjusted_addr = mem.alignForward(root_addr, alignment);
110	const march_forward_bytes = if (rem == 0) 0 else (alignment - rem);
111	const adjusted_addr = root_addr + march_forward_bytes;
112	const record_addr = adjusted_addr + n;	110	const record_addr = adjusted_addr + n;
113	@intToPtr(align(1) usize, record_addr). = root_addr;	111	@intToPtr(align(1) usize, record_addr). = root_addr;
114	return @intToPtr([*]u8, adjusted_addr)[0..n];	112	return @intToPtr([*]u8, adjusted_addr)[0..n];
...	@@ -126,8 +124,7 @@ pub const DirectAllocator = struct {	...	@@ -126,8 +124,7 @@ pub const DirectAllocator = struct {
126	const base_addr = @ptrToInt(old_mem.ptr);	124	const base_addr = @ptrToInt(old_mem.ptr);
127	const old_addr_end = base_addr + old_mem.len;	125	const old_addr_end = base_addr + old_mem.len;
128	const new_addr_end = base_addr + new_size;	126	const new_addr_end = base_addr + new_size;
129	const rem = @rem(new_addr_end, os.page_size);	127	const new_addr_end_rounded = mem.alignForward(new_addr_end, os.page_size);
130	const new_addr_end_rounded = new_addr_end + if (rem == 0) 0 else (os.page_size - rem);
131	if (old_addr_end > new_addr_end_rounded) {	128	if (old_addr_end > new_addr_end_rounded) {
132	_ = os.posix.munmap(new_addr_end_rounded, old_addr_end - new_addr_end_rounded);	129	_ = os.posix.munmap(new_addr_end_rounded, old_addr_end - new_addr_end_rounded);
133	}	130	}

...	@@ -912,7 +912,7 @@ pub fn BitOutStream(endian: builtin.Endian, comptime Error: type) type {	...	@@ -912,7 +912,7 @@ pub fn BitOutStream(endian: builtin.Endian, comptime Error: type) type {
912	}	912	}
913		913
914	/// Flush any remaining bits to the stream.	914	/// Flush any remaining bits to the stream.
915	pub fn flushBits(self: *Self) !void {	915	pub fn flushBits(self: *Self) Error!void {
916	if (self.bit_count == 0) return;	916	if (self.bit_count == 0) return;
917	try self.out_stream.writeByte(self.bit_buffer);	917	try self.out_stream.writeByte(self.bit_buffer);
918	self.bit_buffer = 0;	918	self.bit_buffer = 0;
...	@@ -1079,7 +1079,7 @@ pub fn Deserializer(comptime endian: builtin.Endian, is_packed: bool, comptime E	...	@@ -1079,7 +1079,7 @@ pub fn Deserializer(comptime endian: builtin.Endian, is_packed: bool, comptime E
1079	}	1079	}
1080		1080
1081	//@BUG: inferred error issue. See: #1386	1081	//@BUG: inferred error issue. See: #1386
1082	fn deserializeInt(self: *Self, comptime T: type) (Stream.Error \|\| error{EndOfStream})!T {	1082	fn deserializeInt(self: *Self, comptime T: type) (Error \|\| error{EndOfStream})!T {
1083	comptime assert(trait.is(builtin.TypeId.Int)(T) or trait.is(builtin.TypeId.Float)(T));	1083	comptime assert(trait.is(builtin.TypeId.Int)(T) or trait.is(builtin.TypeId.Float)(T));
1084		1084
1085	const u8_bit_count = 8;	1085	const u8_bit_count = 8;
...	@@ -1287,11 +1287,11 @@ pub fn Serializer(comptime endian: builtin.Endian, comptime is_packed: bool, com	...	@@ -1287,11 +1287,11 @@ pub fn Serializer(comptime endian: builtin.Endian, comptime is_packed: bool, com
1287	}	1287	}
1288		1288
1289	/// Flushes any unwritten bits to the stream	1289	/// Flushes any unwritten bits to the stream
1290	pub fn flush(self: *Self) Stream.Error!void {	1290	pub fn flush(self: *Self) Error!void {
1291	if (is_packed) return self.out_stream.flushBits();	1291	if (is_packed) return self.out_stream.flushBits();
1292	}	1292	}
1293		1293
1294	fn serializeInt(self: *Self, value: var) !void {	1294	fn serializeInt(self: *Self, value: var) Error!void {
1295	const T = @typeOf(value);	1295	const T = @typeOf(value);
1296	comptime assert(trait.is(builtin.TypeId.Int)(T) or trait.is(builtin.TypeId.Float)(T));	1296	comptime assert(trait.is(builtin.TypeId.Int)(T) or trait.is(builtin.TypeId.Float)(T));
1297		1297
...	@@ -1323,7 +1323,7 @@ pub fn Serializer(comptime endian: builtin.Endian, comptime is_packed: bool, com	...	@@ -1323,7 +1323,7 @@ pub fn Serializer(comptime endian: builtin.Endian, comptime is_packed: bool, com
1323	}	1323	}
1324		1324
1325	/// Serializes the passed value into the stream	1325	/// Serializes the passed value into the stream
1326	pub fn serialize(self: *Self, value: var) !void {	1326	pub fn serialize(self: *Self, value: var) Error!void {
1327	const T = comptime @typeOf(value);	1327	const T = comptime @typeOf(value);
1328		1328
1329	if (comptime trait.isIndexable(T)) {	1329	if (comptime trait.isIndexable(T)) {

...	@@ -30,7 +30,7 @@ pub fn getAppDataDir(allocator: *mem.Allocator, appname: []const u8) GetAppDataD	...	@@ -30,7 +30,7 @@ pub fn getAppDataDir(allocator: *mem.Allocator, appname: []const u8) GetAppDataD
30	error.OutOfMemory => return error.OutOfMemory,	30	error.OutOfMemory => return error.OutOfMemory,
31	};	31	};
32	defer allocator.free(global_dir);	32	defer allocator.free(global_dir);
33	return os.path.join(allocator, global_dir, appname);	33	return os.path.join(allocator, [][]const u8{ global_dir, appname });
34	},	34	},
35	os.windows.E_OUTOFMEMORY => return error.OutOfMemory,	35	os.windows.E_OUTOFMEMORY => return error.OutOfMemory,
36	else => return error.AppDataDirUnavailable,	36	else => return error.AppDataDirUnavailable,
...	@@ -41,14 +41,14 @@ pub fn getAppDataDir(allocator: *mem.Allocator, appname: []const u8) GetAppDataD	...	@@ -41,14 +41,14 @@ pub fn getAppDataDir(allocator: *mem.Allocator, appname: []const u8) GetAppDataD
41	// TODO look in /etc/passwd	41	// TODO look in /etc/passwd
42	return error.AppDataDirUnavailable;	42	return error.AppDataDirUnavailable;
43	};	43	};
44	return os.path.join(allocator, home_dir, "Library", "Application Support", appname);	44	return os.path.join(allocator, [][]const u8{ home_dir, "Library", "Application Support", appname });
45	},	45	},
46	builtin.Os.linux, builtin.Os.freebsd => {	46	builtin.Os.linux, builtin.Os.freebsd => {
47	const home_dir = os.getEnvPosix("HOME") orelse {	47	const home_dir = os.getEnvPosix("HOME") orelse {
48	// TODO look in /etc/passwd	48	// TODO look in /etc/passwd
49	return error.AppDataDirUnavailable;	49	return error.AppDataDirUnavailable;
50	};	50	};
51	return os.path.join(allocator, home_dir, ".local", "share", appname);	51	return os.path.join(allocator, [][]const u8{ home_dir, ".local", "share", appname });
52	},	52	},
53	else => @compileError("Unsupported OS"),	53	else => @compileError("Unsupported OS"),
54	}	54	}
...	@@ -67,4 +67,3 @@ test "std.os.getAppDataDir" {	...	@@ -67,4 +67,3 @@ test "std.os.getAppDataDir" {
67	// We can't actually validate the result	67	// We can't actually validate the result
68	_ = getAppDataDir(allocator, "zig") catch return;	68	_ = getAppDataDir(allocator, "zig") catch return;
69	}	69	}
70

...	@@ -27,9 +27,9 @@ pub fn main() !void {	...	@@ -27,9 +27,9 @@ pub fn main() !void {
27	std.debug.warn("Expected second argument to be cache root directory path\n");	27	std.debug.warn("Expected second argument to be cache root directory path\n");
28	return error.InvalidArgs;	28	return error.InvalidArgs;
29	});	29	});
30	const zig_exe = try os.path.resolve(a, zig_exe_rel);	30	const zig_exe = try os.path.resolve(a, [][]const u8{zig_exe_rel});
31		31
32	const dir_path = try os.path.join(a, cache_root, "clitest");	32	const dir_path = try os.path.join(a, [][]const u8{ cache_root, "clitest" });
33	const TestFn = fn ([]const u8, []const u8) anyerror!void;	33	const TestFn = fn ([]const u8, []const u8) anyerror!void;
34	const test_fns = []TestFn{	34	const test_fns = []TestFn{
35	testZigInitLib,	35	testZigInitLib,
...	@@ -99,8 +99,8 @@ fn testZigInitExe(zig_exe: []const u8, dir_path: []const u8) !void {	...	@@ -99,8 +99,8 @@ fn testZigInitExe(zig_exe: []const u8, dir_path: []const u8) !void {
99	fn testGodboltApi(zig_exe: []const u8, dir_path: []const u8) anyerror!void {	99	fn testGodboltApi(zig_exe: []const u8, dir_path: []const u8) anyerror!void {
100	if (builtin.os != builtin.Os.linux or builtin.arch != builtin.Arch.x86_64) return;	100	if (builtin.os != builtin.Os.linux or builtin.arch != builtin.Arch.x86_64) return;
101		101
102	const example_zig_path = try os.path.join(a, dir_path, "example.zig");	102	const example_zig_path = try os.path.join(a, [][]const u8{ dir_path, "example.zig" });
103	const example_s_path = try os.path.join(a, dir_path, "example.s");	103	const example_s_path = try os.path.join(a, [][]const u8{ dir_path, "example.s" });
104		104
105	try std.io.writeFile(example_zig_path,	105	try std.io.writeFile(example_zig_path,
106	\\// Type your code here, or load an example.	106	\\// Type your code here, or load an example.

Merge remote-tracking branch 'origin/master' into llvm8