{#syntax#}@fieldParentPtr(comptime field_name: []const u8, field_ptr: *T) anytype{#endsyntax#}
- Given a pointer to a struct field, returns a pointer to the struct containing that field. - The return type (and struct in question) is the inferred result type. + Given a pointer to a struct or union field, returns a pointer to the struct or union containing that field. + The return type (pointer to the parent struct or union in question) is the inferred result type.
If {#syntax#}field_ptr{#endsyntax#} does not point to the {#syntax#}field_name{#endsyntax#} field of an instance of @@ -6277,10 +6277,6 @@ fn cmpxchgWeakButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_val
TODO: thread local variables
Zig programmers can implement their own allocators by fulfilling the Allocator interface. - In order to do this one must read carefully the documentation comments in std/mem.zig and - then supply a {#syntax#}allocFn{#endsyntax#} and a {#syntax#}resizeFn{#endsyntax#}. -
- There are many example allocators to look at for inspiration. Look at std/heap.zig and - {#syntax#}std.heap.GeneralPurposeAllocator{#endsyntax#}. -
Many programming languages choose to handle the possibility of heap allocation failure by diff --git a/doc/langref/destructuring_block.zig b/doc/langref/destructuring_block.zig index 7eec318796..4aae87381b 100644 --- a/doc/langref/destructuring_block.zig +++ b/doc/langref/destructuring_block.zig @@ -15,8 +15,8 @@ pub fn main() void { break :blk .{ min, max }; }; - print("min = {}", .{ min }); - print("max = {}", .{ max }); + print("min = {}\n", .{ min }); + print("max = {}\n", .{ max }); } // exe=succeed diff --git a/lib/build-web/fuzz.zig b/lib/build-web/fuzz.zig index 29b37e3465..c694e9e69e 100644 --- a/lib/build-web/fuzz.zig +++ b/lib/build-web/fuzz.zig @@ -101,22 +101,22 @@ const SourceLocationIndex = enum(u32) { fn sourceLocationLinkHtml( sli: SourceLocationIndex, - out: *std.ArrayListUnmanaged(u8), + out: *std.ArrayList(u8), focused: bool, - ) Allocator.Error!void { + ) error{OutOfMemory}!void { const sl = sli.ptr(); - try out.writer(gpa).print("", .{ + try out.print(gpa, "", .{ @as([]const u8, if (focused) " class=\"status-running\"" else ""), }); try sli.appendPath(out); - try out.writer(gpa).print(":{d}:{d} View", .{ + try out.print(gpa, ":{d}:{d} View", .{ sl.line, sl.column, @intFromEnum(sli), }); } - fn appendPath(sli: SourceLocationIndex, out: *std.ArrayListUnmanaged(u8)) Allocator.Error!void { + fn appendPath(sli: SourceLocationIndex, out: *std.ArrayList(u8)) error{OutOfMemory}!void { const sl = sli.ptr(); const file = coverage.fileAt(sl.file); const file_name = coverage.stringAt(file.basename); @@ -294,7 +294,7 @@ fn updateStats() error{OutOfMemory}!void { } fn updateEntryPoints() error{OutOfMemory}!void { - var html: std.ArrayListUnmanaged(u8) = .empty; + var html: std.ArrayList(u8) = .empty; defer html.deinit(gpa); for (entry_points.items) |sli| { try html.appendSlice(gpa, ""); diff --git a/lib/build-web/time_report.zig b/lib/build-web/time_report.zig index aa37e501be..1495b7207a 100644 --- a/lib/build-web/time_report.zig +++ b/lib/build-web/time_report.zig @@ -44,7 +44,7 @@ pub fn genericResultMessage(msg_bytes: []u8) error{OutOfMemory}!void { js.updateGeneric(msg.step_idx, inner_html.ptr, inner_html.len); } -pub fn compileResultMessage(msg_bytes: []u8) error{OutOfMemory}!void { +pub fn compileResultMessage(msg_bytes: []u8) error{ OutOfMemory, WriteFailed }!void { const max_table_rows = 500; if (msg_bytes.len < @sizeOf(abi.CompileResult)) @panic("malformed CompileResult message"); @@ -166,10 +166,11 @@ pub fn compileResultMessage(msg_bytes: []u8) error{OutOfMemory}!void { }); defer gpa.free(inner_html); - var file_table_html: std.ArrayListUnmanaged(u8) = .empty; - defer file_table_html.deinit(gpa); + var file_table_html: std.Io.Writer.Allocating = .init(gpa); + defer file_table_html.deinit(); + for (slowest_files[0..@min(max_table_rows, slowest_files.len)]) |file| { - try file_table_html.writer(gpa).print( + try file_table_html.writer.print( \\ \\ {f} \\ {D} @@ -187,17 +188,17 @@ pub fn compileResultMessage(msg_bytes: []u8) error{OutOfMemory}!void { }); } if (slowest_files.len > max_table_rows) { - try file_table_html.writer(gpa).print( + try file_table_html.writer.print( \\{d} more rows omitted \\ , .{slowest_files.len - max_table_rows}); } - var decl_table_html: std.ArrayListUnmanaged(u8) = .empty; - defer decl_table_html.deinit(gpa); + var decl_table_html: std.Io.Writer.Allocating = .init(gpa); + defer decl_table_html.deinit(); for (slowest_decls[0..@min(max_table_rows, slowest_decls.len)]) |decl| { - try decl_table_html.writer(gpa).print( + try decl_table_html.writer.print( \\ \\ {f} \\ {f} @@ -219,7 +220,7 @@ pub fn compileResultMessage(msg_bytes: []u8) error{OutOfMemory}!void { }); } if (slowest_decls.len > max_table_rows) { - try decl_table_html.writer(gpa).print( + try decl_table_html.writer.print( \\{d} more rows omitted \\ , .{slowest_decls.len - max_table_rows}); @@ -229,10 +230,10 @@ pub fn compileResultMessage(msg_bytes: []u8) error{OutOfMemory}!void { hdr.step_idx, inner_html.ptr, inner_html.len, - file_table_html.items.ptr, - file_table_html.items.len, - decl_table_html.items.ptr, - decl_table_html.items.len, + file_table_html.written().ptr, + file_table_html.written().len, + decl_table_html.written().ptr, + decl_table_html.written().len, hdr.flags.use_llvm, ); } diff --git a/lib/compiler/reduce.zig b/lib/compiler/reduce.zig index d9955b9e33..b20a2fcba3 100644 --- a/lib/compiler/reduce.zig +++ b/lib/compiler/reduce.zig @@ -114,10 +114,10 @@ pub fn main() !void { interestingness_argv.appendAssumeCapacity(checker_path); interestingness_argv.appendSliceAssumeCapacity(argv); - var rendered = std.array_list.Managed(u8).init(gpa); + var rendered: std.Io.Writer.Allocating = .init(gpa); defer rendered.deinit(); - var astgen_input = std.array_list.Managed(u8).init(gpa); + var astgen_input: std.Io.Writer.Allocating = .init(gpa); defer astgen_input.deinit(); var tree = try parse(gpa, root_source_file_path); @@ -138,10 +138,10 @@ pub fn main() !void { } } - var fixups: Ast.Fixups = .{}; + var fixups: Ast.Render.Fixups = .{}; defer fixups.deinit(gpa); - var more_fixups: Ast.Fixups = .{}; + var more_fixups: Ast.Render.Fixups = .{}; defer more_fixups.deinit(gpa); var rng = std.Random.DefaultPrng.init(seed); @@ -188,15 +188,14 @@ pub fn main() !void { try transformationsToFixups(gpa, arena, root_source_file_path, this_set, &fixups); rendered.clearRetainingCapacity(); - try tree.renderToArrayList(&rendered, fixups); + try tree.render(gpa, &rendered.writer, fixups); // The transformations we applied may have resulted in unused locals, // in which case we would like to add the respective discards. { - try astgen_input.resize(rendered.items.len); - @memcpy(astgen_input.items, rendered.items); - try astgen_input.append(0); - const source_with_null = astgen_input.items[0 .. astgen_input.items.len - 1 :0]; + try astgen_input.writer.writeAll(rendered.written()); + try astgen_input.writer.writeByte(0); + const source_with_null = astgen_input.written()[0..(astgen_input.written().len - 1) :0]; var astgen_tree = try Ast.parse(gpa, source_with_null, .zig); defer astgen_tree.deinit(gpa); if (astgen_tree.errors.len != 0) { @@ -228,12 +227,12 @@ pub fn main() !void { } if (more_fixups.count() != 0) { rendered.clearRetainingCapacity(); - try astgen_tree.renderToArrayList(&rendered, more_fixups); + try astgen_tree.render(gpa, &rendered.writer, more_fixups); } } } - try std.fs.cwd().writeFile(.{ .sub_path = root_source_file_path, .data = rendered.items }); + try std.fs.cwd().writeFile(.{ .sub_path = root_source_file_path, .data = rendered.written() }); // std.debug.print("trying this code:\n{s}\n", .{rendered.items}); const interestingness = try runCheck(arena, interestingness_argv.items); @@ -273,8 +272,8 @@ pub fn main() !void { // Revert the source back to not be transformed. fixups.clearRetainingCapacity(); rendered.clearRetainingCapacity(); - try tree.renderToArrayList(&rendered, fixups); - try std.fs.cwd().writeFile(.{ .sub_path = root_source_file_path, .data = rendered.items }); + try tree.render(gpa, &rendered.writer, fixups); + try std.fs.cwd().writeFile(.{ .sub_path = root_source_file_path, .data = rendered.written() }); return std.process.cleanExit(); } @@ -318,7 +317,7 @@ fn transformationsToFixups( arena: Allocator, root_source_file_path: []const u8, transforms: []const Walk.Transformation, - fixups: *Ast.Fixups, + fixups: *Ast.Render.Fixups, ) !void { fixups.clearRetainingCapacity(); @@ -359,7 +358,7 @@ fn transformationsToFixups( other_file_ast.deinit(gpa); } - var inlined_fixups: Ast.Fixups = .{}; + var inlined_fixups: Ast.Render.Fixups = .{}; defer inlined_fixups.deinit(gpa); if (std.fs.path.dirname(inline_imported_file.imported_string)) |dirname| { inlined_fixups.rebase_imported_paths = dirname; @@ -382,16 +381,16 @@ fn transformationsToFixups( } } - var other_source = std.array_list.Managed(u8).init(gpa); + var other_source: std.io.Writer.Allocating = .init(gpa); defer other_source.deinit(); - try other_source.appendSlice("struct {\n"); - try other_file_ast.renderToArrayList(&other_source, inlined_fixups); - try other_source.appendSlice("}"); + try other_source.writer.writeAll("struct {\n"); + try other_file_ast.render(gpa, &other_source.writer, inlined_fixups); + try other_source.writer.writeAll("}"); try fixups.replace_nodes_with_string.put( gpa, inline_imported_file.builtin_call_node, - try arena.dupe(u8, other_source.items), + try arena.dupe(u8, other_source.written()), ); }, }; diff --git a/lib/compiler/reduce/Walk.zig b/lib/compiler/reduce/Walk.zig index 4e41fdf1a2..7a448fad21 100644 --- a/lib/compiler/reduce/Walk.zig +++ b/lib/compiler/reduce/Walk.zig @@ -501,6 +501,10 @@ fn walkExpression(w: *Walk, node: Ast.Node.Index) Error!void { .@"asm", => return walkAsm(w, ast.fullAsm(node).?), + .asm_legacy => { + return walkAsmLegacy(w, ast.legacyAsm(node).?); + }, + .enum_literal => { return walkIdentifier(w, ast.nodeMainToken(node)); // name }, @@ -665,7 +669,7 @@ fn walkStructInit( fn walkCall(w: *Walk, call: Ast.full.Call) Error!void { try walkExpression(w, call.ast.fn_expr); - try walkParamList(w, call.ast.params); + try walkExpressions(w, call.ast.params); } fn walkSlice( @@ -830,7 +834,7 @@ fn walkWhile(w: *Walk, node_index: Ast.Node.Index, while_node: Ast.full.While) E } fn walkFor(w: *Walk, for_node: Ast.full.For) Error!void { - try walkParamList(w, for_node.ast.inputs); + try walkExpressions(w, for_node.ast.inputs); try walkExpression(w, for_node.ast.then_expr); if (for_node.ast.else_expr.unwrap()) |else_expr| { try walkExpression(w, else_expr); @@ -874,15 +878,12 @@ fn walkIf(w: *Walk, node_index: Ast.Node.Index, if_node: Ast.full.If) Error!void fn walkAsm(w: *Walk, asm_node: Ast.full.Asm) Error!void { try walkExpression(w, asm_node.ast.template); - for (asm_node.ast.items) |item| { - try walkExpression(w, item); - } + try walkExpressions(w, asm_node.ast.items); } -fn walkParamList(w: *Walk, params: []const Ast.Node.Index) Error!void { - for (params) |param_node| { - try walkExpression(w, param_node); - } +fn walkAsmLegacy(w: *Walk, asm_node: Ast.full.AsmLegacy) Error!void { + try walkExpression(w, asm_node.ast.template); + try walkExpressions(w, asm_node.ast.items); } /// Check if it is already gutted (i.e. its body replaced with `@trap()`). diff --git a/lib/compiler/resinator/compile.zig b/lib/compiler/resinator/compile.zig index 60d91eeb73..6f050b0a00 100644 --- a/lib/compiler/resinator/compile.zig +++ b/lib/compiler/resinator/compile.zig @@ -674,7 +674,7 @@ pub const Compiler = struct { } try file_reader.seekTo(entry.data_offset_from_start_of_file); - var header_bytes = (file_reader.interface.takeArray(16) catch { + var header_bytes: [16]u8 align(@alignOf(ico.BitmapHeader)) = (file_reader.interface.takeArray(16) catch { return self.iconReadError( error.UnexpectedEOF, filename_utf8, diff --git a/lib/compiler_rt/arm.zig b/lib/compiler_rt/arm.zig index e349e18630..3c55df5f3b 100644 --- a/lib/compiler_rt/arm.zig +++ b/lib/compiler_rt/arm.zig @@ -37,7 +37,7 @@ comptime { @export(&__aeabi_memclr4, .{ .name = "__aeabi_memclr4", .linkage = common.linkage, .visibility = common.visibility }); @export(&__aeabi_memclr8, .{ .name = "__aeabi_memclr8", .linkage = common.linkage, .visibility = common.visibility }); - if (builtin.os.tag == .linux) { + if (builtin.os.tag == .linux or builtin.os.tag == .freebsd) { @export(&__aeabi_read_tp, .{ .name = "__aeabi_read_tp", .linkage = common.linkage, .visibility = common.visibility }); } diff --git a/lib/init/build.zig b/lib/init/build.zig index 481b586a44..88c42f760e 100644 --- a/lib/init/build.zig +++ b/lib/init/build.zig @@ -44,7 +44,7 @@ pub fn build(b: *std.Build) void { // Here we define an executable. An executable needs to have a root module // which needs to expose a `main` function. While we could add a main function // to the module defined above, it's sometimes preferable to split business - // business logic and the CLI into two separate modules. + // logic and the CLI into two separate modules. // // If your goal is to create a Zig library for others to use, consider if // it might benefit from also exposing a CLI tool. A parser library for a diff --git a/lib/libc/include/generic-glibc/arpa/inet.h b/lib/libc/include/generic-glibc/arpa/inet.h index 84602130a9..07113deb0f 100644 --- a/lib/libc/include/generic-glibc/arpa/inet.h +++ b/lib/libc/include/generic-glibc/arpa/inet.h @@ -101,10 +101,13 @@ extern char *inet_nsap_ntoa (int __len, const unsigned char *__cp, char *__buf) __THROW; #endif +// zig patch: inet was fortified in glibc 2.42 +#if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 42) || __GLIBC__ > 2 #if __USE_FORTIFY_LEVEL > 0 && defined __fortify_function /* Include functions with security checks. */ # include #endif +#endif __END_DECLS diff --git a/lib/libc/musl/src/fenv/loongarch64/fenv-sf.c b/lib/libc/musl/src/fenv/loongarch64/fenv-sf.c new file mode 100644 index 0000000000..41154673ab --- /dev/null +++ b/lib/libc/musl/src/fenv/loongarch64/fenv-sf.c @@ -0,0 +1,3 @@ +#ifdef __loongarch_soft_float +#include "../fenv.c" +#endif diff --git a/lib/std/Build.zig b/lib/std/Build.zig index 548f951991..9b394f60f3 100644 --- a/lib/std/Build.zig +++ b/lib/std/Build.zig @@ -2524,7 +2524,10 @@ pub const LazyPath = union(enum) { .up = gen.up, .sub_path = dupePathInner(allocator, gen.sub_path), } }, - .dependency => |dep| .{ .dependency = dep }, + .dependency => |dep| .{ .dependency = .{ + .dependency = dep.dependency, + .sub_path = dupePathInner(allocator, dep.sub_path), + } }, }; } }; diff --git a/lib/std/Build/Step/Compile.zig b/lib/std/Build/Step/Compile.zig index 79d3694c02..b64ce59778 100644 --- a/lib/std/Build/Step/Compile.zig +++ b/lib/std/Build/Step/Compile.zig @@ -1827,7 +1827,26 @@ fn getZigArgs(compile: *Compile, fuzz: bool) ![][]const u8 { _ = try std.fmt.bufPrint(&args_hex_hash, "{x}", .{&args_hash}); const args_file = "args" ++ fs.path.sep_str ++ args_hex_hash; - try b.cache_root.handle.writeFile(.{ .sub_path = args_file, .data = args }); + if (b.cache_root.handle.access(args_file, .{})) |_| { + // The args file is already present from a previous run. + } else |err| switch (err) { + error.FileNotFound => { + try b.cache_root.handle.makePath("tmp"); + const rand_int = std.crypto.random.int(u64); + const tmp_path = "tmp" ++ fs.path.sep_str ++ std.fmt.hex(rand_int); + try b.cache_root.handle.writeFile(.{ .sub_path = tmp_path, .data = args }); + defer b.cache_root.handle.deleteFile(tmp_path) catch { + // It's fine if the temporary file can't be cleaned up. + }; + b.cache_root.handle.rename(tmp_path, args_file) catch |rename_err| switch (rename_err) { + error.PathAlreadyExists => { + // The args file was created by another concurrent build process. + }, + else => |other_err| return other_err, + }; + }, + else => |other_err| return other_err, + } const resolved_args_file = try mem.concat(arena, u8, &.{ "@", diff --git a/lib/std/Build/Step/TranslateC.zig b/lib/std/Build/Step/TranslateC.zig index dabf2200df..b8ef5d334f 100644 --- a/lib/std/Build/Step/TranslateC.zig +++ b/lib/std/Build/Step/TranslateC.zig @@ -163,6 +163,12 @@ fn make(step: *Step, options: Step.MakeOptions) !void { try argv_list.append("-fno-clang"); } + try argv_list.append("--cache-dir"); + try argv_list.append(b.cache_root.path orelse "."); + + try argv_list.append("--global-cache-dir"); + try argv_list.append(b.graph.global_cache_root.path orelse "."); + try argv_list.append("--listen=-"); if (!translate_c.target.query.isNative()) { diff --git a/lib/std/Build/WebServer.zig b/lib/std/Build/WebServer.zig index 780e249323..451f4b9d34 100644 --- a/lib/std/Build/WebServer.zig +++ b/lib/std/Build/WebServer.zig @@ -323,7 +323,7 @@ fn serveWebSocket(ws: *WebServer, sock: *http.Server.WebSocket) !noreturn { // Temporarily unlock, then re-lock after the message is sent. ws.time_report_mutex.unlock(); defer ws.time_report_mutex.lock(); - try sock.writeMessage(msg, .binary); + try sock.writeMessage(owned_msg, .binary); } } diff --git a/lib/std/Io/Reader.zig b/lib/std/Io/Reader.zig index 5e08ad6d0c..58e413bb9b 100644 --- a/lib/std/Io/Reader.zig +++ b/lib/std/Io/Reader.zig @@ -400,10 +400,11 @@ pub fn defaultReadVec(r: *Reader, data: [][]u8) Error!usize { .vtable = &.{ .drain = Writer.fixedDrain }, }; const limit: Limit = .limited(writer.buffer.len - writer.end); - r.end += r.vtable.stream(r, &writer, limit) catch |err| switch (err) { + const n = r.vtable.stream(r, &writer, limit) catch |err| switch (err) { error.WriteFailed => unreachable, else => |e| return e, }; + r.end += n; return 0; } @@ -448,7 +449,6 @@ pub fn readVecAll(r: *Reader, data: [][]u8) Error!void { /// is returned instead. /// /// See also: -/// * `peek` /// * `toss` pub fn peek(r: *Reader, n: usize) Error![]u8 { try r.fill(n); @@ -699,7 +699,7 @@ pub const DelimiterError = error{ }; /// Returns a slice of the next bytes of buffered data from the stream until -/// `sentinel` is found, advancing the seek position. +/// `sentinel` is found, advancing the seek position past the sentinel. /// /// Returned slice has a sentinel. /// @@ -732,7 +732,7 @@ pub fn peekSentinel(r: *Reader, comptime sentinel: u8) DelimiterError![:sentinel } /// Returns a slice of the next bytes of buffered data from the stream until -/// `delimiter` is found, advancing the seek position. +/// `delimiter` is found, advancing the seek position past the delimiter. /// /// Returned slice includes the delimiter as the last byte. /// @@ -760,31 +760,42 @@ pub fn takeDelimiterInclusive(r: *Reader, delimiter: u8) DelimiterError![]u8 { /// * `peekDelimiterExclusive` /// * `takeDelimiterInclusive` pub fn peekDelimiterInclusive(r: *Reader, delimiter: u8) DelimiterError![]u8 { - const buffer = r.buffer[0..r.end]; - const seek = r.seek; - if (std.mem.indexOfScalarPos(u8, buffer, seek, delimiter)) |end| { - @branchHint(.likely); - return buffer[seek .. end + 1]; - } - // TODO take a parameter for max search length rather than relying on buffer capacity - try rebase(r, r.buffer.len); - while (r.buffer.len - r.end != 0) { - const end_cap = r.buffer[r.end..]; - var writer: Writer = .fixed(end_cap); - const n = r.vtable.stream(r, &writer, .limited(end_cap.len)) catch |err| switch (err) { - error.WriteFailed => unreachable, - else => |e| return e, - }; - r.end += n; - if (std.mem.indexOfScalarPos(u8, end_cap[0..n], 0, delimiter)) |end| { - return r.buffer[0 .. r.end - n + end + 1]; + { + const contents = r.buffer[0..r.end]; + const seek = r.seek; + if (std.mem.indexOfScalarPos(u8, contents, seek, delimiter)) |end| { + @branchHint(.likely); + return contents[seek .. end + 1]; } } - return error.StreamTooLong; + while (true) { + const content_len = r.end - r.seek; + if (r.buffer.len - content_len == 0) break; + try fillMore(r); + const seek = r.seek; + const contents = r.buffer[0..r.end]; + if (std.mem.indexOfScalarPos(u8, contents, seek + content_len, delimiter)) |end| { + return contents[seek .. end + 1]; + } + } + // It might or might not be end of stream. There is no more buffer space + // left to disambiguate. If `StreamTooLong` was added to `RebaseError` then + // this logic could be replaced by removing the exit condition from the + // above while loop. That error code would represent when `buffer` capacity + // is too small for an operation, replacing the current use of asserts. + var failing_writer = Writer.failing; + while (r.vtable.stream(r, &failing_writer, .limited(1))) |n| { + assert(n == 0); + } else |err| switch (err) { + error.WriteFailed => return error.StreamTooLong, + error.ReadFailed => |e| return e, + error.EndOfStream => |e| return e, + } } /// Returns a slice of the next bytes of buffered data from the stream until -/// `delimiter` is found, advancing the seek position. +/// `delimiter` is found, advancing the seek position up to (but not past) +/// the delimiter. /// /// Returned slice excludes the delimiter. End-of-stream is treated equivalent /// to a delimiter, unless it would result in a length 0 return value, in which @@ -798,20 +809,44 @@ pub fn peekDelimiterInclusive(r: *Reader, delimiter: u8) DelimiterError![]u8 { /// Invalidates previously returned values from `peek`. /// /// See also: +/// * `takeDelimiter` /// * `takeDelimiterInclusive` /// * `peekDelimiterExclusive` pub fn takeDelimiterExclusive(r: *Reader, delimiter: u8) DelimiterError![]u8 { - const result = r.peekDelimiterInclusive(delimiter) catch |err| switch (err) { + const result = try r.peekDelimiterExclusive(delimiter); + r.toss(result.len); + return result; +} + +/// Returns a slice of the next bytes of buffered data from the stream until +/// `delimiter` is found, advancing the seek position past the delimiter. +/// +/// Returned slice excludes the delimiter. End-of-stream is treated equivalent +/// to a delimiter, unless it would result in a length 0 return value, in which +/// case `null` is returned instead. +/// +/// If the delimiter is not found within a number of bytes matching the +/// capacity of this `Reader`, `error.StreamTooLong` is returned. In +/// such case, the stream state is unmodified as if this function was never +/// called. +/// +/// Invalidates previously returned values from `peek`. +/// +/// See also: +/// * `takeDelimiterInclusive` +/// * `takeDelimiterExclusive` +pub fn takeDelimiter(r: *Reader, delimiter: u8) error{ ReadFailed, StreamTooLong }!?[]u8 { + const inclusive = r.peekDelimiterInclusive(delimiter) catch |err| switch (err) { error.EndOfStream => { const remaining = r.buffer[r.seek..r.end]; - if (remaining.len == 0) return error.EndOfStream; + if (remaining.len == 0) return null; r.toss(remaining.len); return remaining; }, else => |e| return e, }; - r.toss(result.len); - return result[0 .. result.len - 1]; + r.toss(inclusive.len); + return inclusive[0 .. inclusive.len - 1]; } /// Returns a slice of the next bytes of buffered data from the stream until @@ -1334,6 +1369,9 @@ test peekSentinel { var r: Reader = .fixed("ab\nc"); try testing.expectEqualStrings("ab", try r.peekSentinel('\n')); try testing.expectEqualStrings("ab", try r.peekSentinel('\n')); + r.toss(3); + try testing.expectError(error.EndOfStream, r.peekSentinel('\n')); + try testing.expectEqualStrings("c", try r.peek(1)); } test takeDelimiterInclusive { @@ -1348,22 +1386,52 @@ test peekDelimiterInclusive { try testing.expectEqualStrings("ab\n", try r.peekDelimiterInclusive('\n')); r.toss(3); try testing.expectError(error.EndOfStream, r.peekDelimiterInclusive('\n')); + try testing.expectEqualStrings("c", try r.peek(1)); } test takeDelimiterExclusive { var r: Reader = .fixed("ab\nc"); + try testing.expectEqualStrings("ab", try r.takeDelimiterExclusive('\n')); + try testing.expectEqualStrings("", try r.takeDelimiterExclusive('\n')); + try testing.expectEqualStrings("", try r.takeDelimiterExclusive('\n')); + try testing.expectEqualStrings("\n", try r.take(1)); + try testing.expectEqualStrings("c", try r.takeDelimiterExclusive('\n')); try testing.expectError(error.EndOfStream, r.takeDelimiterExclusive('\n')); } test peekDelimiterExclusive { var r: Reader = .fixed("ab\nc"); + try testing.expectEqualStrings("ab", try r.peekDelimiterExclusive('\n')); try testing.expectEqualStrings("ab", try r.peekDelimiterExclusive('\n')); - r.toss(3); + r.toss(2); + try testing.expectEqualStrings("", try r.peekDelimiterExclusive('\n')); + try testing.expectEqualStrings("\n", try r.take(1)); + try testing.expectEqualStrings("c", try r.peekDelimiterExclusive('\n')); try testing.expectEqualStrings("c", try r.peekDelimiterExclusive('\n')); + r.toss(1); + try testing.expectError(error.EndOfStream, r.peekDelimiterExclusive('\n')); +} + +test takeDelimiter { + var r: Reader = .fixed("ab\nc\n\nd"); + try testing.expectEqualStrings("ab", (try r.takeDelimiter('\n')).?); + try testing.expectEqualStrings("c", (try r.takeDelimiter('\n')).?); + try testing.expectEqualStrings("", (try r.takeDelimiter('\n')).?); + try testing.expectEqualStrings("d", (try r.takeDelimiter('\n')).?); + try testing.expectEqual(null, try r.takeDelimiter('\n')); + try testing.expectEqual(null, try r.takeDelimiter('\n')); + + r = .fixed("ab\nc\n\nd\n"); // one trailing newline does not affect behavior + try testing.expectEqualStrings("ab", (try r.takeDelimiter('\n')).?); + try testing.expectEqualStrings("c", (try r.takeDelimiter('\n')).?); + try testing.expectEqualStrings("", (try r.takeDelimiter('\n')).?); + try testing.expectEqualStrings("d", (try r.takeDelimiter('\n')).?); + try testing.expectEqual(null, try r.takeDelimiter('\n')); + try testing.expectEqual(null, try r.takeDelimiter('\n')); } test streamDelimiter { @@ -1533,6 +1601,18 @@ test "readSliceShort with smaller buffer than Reader" { try testing.expectEqualStrings(str, &buf); } +test "readSliceShort with indirect reader" { + var r: Reader = .fixed("HelloFren"); + var ri_buf: [3]u8 = undefined; + var ri: std.testing.ReaderIndirect = .init(&r, &ri_buf); + var buf: [5]u8 = undefined; + try testing.expectEqual(5, try ri.interface.readSliceShort(&buf)); + try testing.expectEqualStrings("Hello", buf[0..5]); + try testing.expectEqual(4, try ri.interface.readSliceShort(&buf)); + try testing.expectEqualStrings("Fren", buf[0..4]); + try testing.expectEqual(0, try ri.interface.readSliceShort(&buf)); +} + test readVec { var r: Reader = .fixed(std.ascii.letters); var flat_buffer: [52]u8 = undefined; @@ -1642,6 +1722,26 @@ test "takeDelimiterInclusive when it rebases" { } } +test "takeDelimiterInclusive on an indirect reader when it rebases" { + const written_line = "ABCDEFGHIJKLMNOPQRSTUVWXYZ\n"; + var buffer: [128]u8 = undefined; + var tr: std.testing.Reader = .init(&buffer, &.{ + .{ .buffer = written_line[0..4] }, + .{ .buffer = written_line[4..] }, + .{ .buffer = written_line }, + .{ .buffer = written_line }, + .{ .buffer = written_line }, + .{ .buffer = written_line }, + .{ .buffer = written_line }, + }); + var indirect_buffer: [128]u8 = undefined; + var tri: std.testing.ReaderIndirect = .init(&tr.interface, &indirect_buffer); + const r = &tri.interface; + for (0..6) |_| { + try std.testing.expectEqualStrings(written_line, try r.takeDelimiterInclusive('\n')); + } +} + test "takeStruct and peekStruct packed" { var r: Reader = .fixed(&.{ 0b11110000, 0b00110011 }); const S = packed struct(u16) { a: u2, b: u6, c: u7, d: u1 }; diff --git a/lib/std/Io/Reader/Limited.zig b/lib/std/Io/Reader/Limited.zig index c2e9ee2f49..5d87200869 100644 --- a/lib/std/Io/Reader/Limited.zig +++ b/lib/std/Io/Reader/Limited.zig @@ -27,6 +27,7 @@ pub fn init(reader: *Reader, limit: Limit, buffer: []u8) Limited { fn stream(r: *Reader, w: *Writer, limit: Limit) Reader.StreamError!usize { const l: *Limited = @fieldParentPtr("interface", r); + if (l.remaining == .nothing) return error.EndOfStream; const combined_limit = limit.min(l.remaining); const n = try l.unlimited.stream(w, combined_limit); l.remaining = l.remaining.subtract(n).?; @@ -51,8 +52,51 @@ test stream { fn discard(r: *Reader, limit: Limit) Reader.Error!usize { const l: *Limited = @fieldParentPtr("interface", r); + if (l.remaining == .nothing) return error.EndOfStream; const combined_limit = limit.min(l.remaining); const n = try l.unlimited.discard(combined_limit); l.remaining = l.remaining.subtract(n).?; return n; } + +test "end of stream, read, hit limit exactly" { + var f: Reader = .fixed("i'm dying"); + var l = f.limited(.limited(4), &.{}); + const r = &l.interface; + + var buf: [2]u8 = undefined; + try r.readSliceAll(&buf); + try r.readSliceAll(&buf); + try std.testing.expectError(error.EndOfStream, l.interface.readSliceAll(&buf)); +} + +test "end of stream, read, hit limit after partial read" { + var f: Reader = .fixed("i'm dying"); + var l = f.limited(.limited(5), &.{}); + const r = &l.interface; + + var buf: [2]u8 = undefined; + try r.readSliceAll(&buf); + try r.readSliceAll(&buf); + try std.testing.expectError(error.EndOfStream, l.interface.readSliceAll(&buf)); +} + +test "end of stream, discard, hit limit exactly" { + var f: Reader = .fixed("i'm dying"); + var l = f.limited(.limited(4), &.{}); + const r = &l.interface; + + try r.discardAll(2); + try r.discardAll(2); + try std.testing.expectError(error.EndOfStream, l.interface.discardAll(2)); +} + +test "end of stream, discard, hit limit after partial read" { + var f: Reader = .fixed("i'm dying"); + var l = f.limited(.limited(5), &.{}); + const r = &l.interface; + + try r.discardAll(2); + try r.discardAll(2); + try std.testing.expectError(error.EndOfStream, l.interface.discardAll(2)); +} diff --git a/lib/std/Io/Writer.zig b/lib/std/Io/Writer.zig index 707ed9cb94..2bb86fd219 100644 --- a/lib/std/Io/Writer.zig +++ b/lib/std/Io/Writer.zig @@ -917,10 +917,12 @@ pub fn sendFileHeader( return n; } -/// Asserts nonzero buffer capacity. +/// Asserts nonzero buffer capacity and nonzero `limit`. pub fn sendFileReading(w: *Writer, file_reader: *File.Reader, limit: Limit) FileReadingError!usize { + assert(limit != .nothing); const dest = limit.slice(try w.writableSliceGreedy(1)); - const n = try file_reader.read(dest); + const n = try file_reader.interface.readSliceShort(dest); + if (n == 0) return error.EndOfStream; w.advance(n); return n; } @@ -2655,7 +2657,8 @@ pub const Allocating = struct { if (additional == 0) return error.EndOfStream; list.ensureUnusedCapacity(gpa, limit.minInt64(additional)) catch return error.WriteFailed; const dest = limit.slice(list.unusedCapacitySlice()); - const n = try file_reader.read(dest); + const n = try file_reader.interface.readSliceShort(dest); + if (n == 0) return error.EndOfStream; list.items.len += n; return n; } @@ -2714,18 +2717,40 @@ test "allocating sendFile" { const file = try tmp_dir.dir.createFile("input.txt", .{ .read = true }); defer file.close(); - var r_buffer: [256]u8 = undefined; + var r_buffer: [2]u8 = undefined; var file_writer: std.fs.File.Writer = .init(file, &r_buffer); - try file_writer.interface.writeByte('h'); + try file_writer.interface.writeAll("abcd"); try file_writer.interface.flush(); var file_reader = file_writer.moveToReader(); try file_reader.seekTo(0); + try file_reader.interface.fill(2); var allocating: Writer.Allocating = .init(testing.allocator); defer allocating.deinit(); + try allocating.ensureUnusedCapacity(1); + try testing.expectEqual(4, allocating.writer.sendFileAll(&file_reader, .unlimited)); + try testing.expectEqualStrings("abcd", allocating.writer.buffered()); +} - _ = try file_reader.interface.streamRemaining(&allocating.writer); +test sendFileReading { + var tmp_dir = testing.tmpDir(.{}); + defer tmp_dir.cleanup(); + + const file = try tmp_dir.dir.createFile("input.txt", .{ .read = true }); + defer file.close(); + var r_buffer: [2]u8 = undefined; + var file_writer: std.fs.File.Writer = .init(file, &r_buffer); + try file_writer.interface.writeAll("abcd"); + try file_writer.interface.flush(); + + var file_reader = file_writer.moveToReader(); + try file_reader.seekTo(0); + try file_reader.interface.fill(2); + + var w_buffer: [1]u8 = undefined; + var discarding: Writer.Discarding = .init(&w_buffer); + try testing.expectEqual(4, discarding.writer.sendFileReadingAll(&file_reader, .unlimited)); } test writeStruct { diff --git a/lib/std/Target.zig b/lib/std/Target.zig index 2aa3e0a70c..6613820255 100644 --- a/lib/std/Target.zig +++ b/lib/std/Target.zig @@ -3075,6 +3075,10 @@ pub fn cTypeAlignment(target: *const Target, c_type: CType) u16 { }, else => {}, }, + .m68k => switch (c_type) { + .int, .uint, .long, .ulong => return 2, + else => {}, + }, .powerpc, .powerpcle, .powerpc64, .powerpc64le => switch (target.os.tag) { .aix => switch (c_type) { .double, .longdouble => return 4, @@ -3175,6 +3179,10 @@ pub fn cTypePreferredAlignment(target: *const Target, c_type: CType) u16 { else => {}, }, }, + .m68k => switch (c_type) { + .int, .uint, .long, .ulong => return 2, + else => {}, + }, .wasm32, .wasm64 => switch (target.os.tag) { .emscripten => switch (c_type) { .longdouble => return 8, diff --git a/lib/std/Thread.zig b/lib/std/Thread.zig index 63af3796b7..4c559cf30a 100644 --- a/lib/std/Thread.zig +++ b/lib/std/Thread.zig @@ -83,10 +83,9 @@ pub fn sleep(nanoseconds: u64) void { req = rem; continue; }, - .FAULT, - .INVAL, - .OPNOTSUPP, - => unreachable, + .FAULT => unreachable, + .INVAL => unreachable, + .OPNOTSUPP => unreachable, else => return, } } diff --git a/lib/std/c.zig b/lib/std/c.zig index 9d5e5bf9ab..a3f98c7564 100644 --- a/lib/std/c.zig +++ b/lib/std/c.zig @@ -2235,40 +2235,70 @@ pub const S = switch (native_os) { } }, .dragonfly => struct { + pub const IFMT = 0o170000; + + pub const IFIFO = 0o010000; + pub const IFCHR = 0o020000; + pub const IFDIR = 0o040000; + pub const IFBLK = 0o060000; + pub const IFREG = 0o100000; + pub const IFLNK = 0o120000; + pub const IFSOCK = 0o140000; + pub const IFWHT = 0o160000; + + pub const ISUID = 0o4000; + pub const ISGID = 0o2000; + pub const ISVTX = 0o1000; + pub const IRWXU = 0o700; + pub const IRUSR = 0o400; + pub const IWUSR = 0o200; + pub const IXUSR = 0o100; + pub const IRWXG = 0o070; + pub const IRGRP = 0o040; + pub const IWGRP = 0o020; + pub const IXGRP = 0o010; + pub const IRWXO = 0o007; + pub const IROTH = 0o004; + pub const IWOTH = 0o002; + pub const IXOTH = 0o001; + pub const IREAD = IRUSR; pub const IEXEC = IXUSR; pub const IWRITE = IWUSR; - pub const IXOTH = 1; - pub const IWOTH = 2; - pub const IROTH = 4; - pub const IRWXO = 7; - pub const IXGRP = 8; - pub const IWGRP = 16; - pub const IRGRP = 32; - pub const IRWXG = 56; - pub const IXUSR = 64; - pub const IWUSR = 128; - pub const IRUSR = 256; - pub const IRWXU = 448; pub const ISTXT = 512; pub const BLKSIZE = 512; - pub const ISVTX = 512; - pub const ISGID = 1024; - pub const ISUID = 2048; - pub const IFIFO = 4096; - pub const IFCHR = 8192; - pub const IFDIR = 16384; - pub const IFBLK = 24576; - pub const IFREG = 32768; - pub const IFDB = 36864; - pub const IFLNK = 40960; - pub const IFSOCK = 49152; - pub const IFWHT = 57344; - pub const IFMT = 61440; + + pub fn ISFIFO(m: u32) bool { + return m & IFMT == IFIFO; + } pub fn ISCHR(m: u32) bool { return m & IFMT == IFCHR; } + + pub fn ISDIR(m: u32) bool { + return m & IFMT == IFDIR; + } + + pub fn ISBLK(m: u32) bool { + return m & IFMT == IFBLK; + } + + pub fn ISREG(m: u32) bool { + return m & IFMT == IFREG; + } + + pub fn ISLNK(m: u32) bool { + return m & IFMT == IFLNK; + } + + pub fn ISSOCK(m: u32) bool { + return m & IFMT == IFSOCK; + } + + pub fn IWHT(m: u32) bool { + return m & IFMT == IFWHT; + } }, .haiku => struct { pub const IFMT = 0o170000; @@ -3091,8 +3121,17 @@ pub const SIG = switch (native_os) { pub const UNBLOCK = 2; pub const SETMASK = 3; }, + // https://github.com/SerenityOS/serenity/blob/046c23f567a17758d762a33bdf04bacbfd088f9f/Kernel/API/POSIX/signal.h // https://github.com/SerenityOS/serenity/blob/046c23f567a17758d762a33bdf04bacbfd088f9f/Kernel/API/POSIX/signal_numbers.h .serenity => struct { + pub const DFL: ?Sigaction.handler_fn = @ptrFromInt(0); + pub const ERR: ?Sigaction.handler_fn = @ptrFromInt(maxInt(usize)); + pub const IGN: ?Sigaction.handler_fn = @ptrFromInt(1); + + pub const BLOCK = 1; + pub const UNBLOCK = 2; + pub const SETMASK = 3; + pub const INVAL = 0; pub const HUP = 1; pub const INT = 2; @@ -5685,6 +5724,23 @@ pub const MSG = switch (native_os) { pub const WAITFORONE = 0x2000; pub const NOTIFICATION = 0x4000; }, + // https://github.com/openbsd/src/blob/42a7be81bef70c04732f45ec573622effe56b563/sys/sys/socket.h#L506 + .openbsd => struct { + pub const OOB = 0x1; + pub const PEEK = 0x2; + pub const DONTROUTE = 0x4; + pub const EOR = 0x8; + pub const TRUNC = 0x10; + pub const CTRUNC = 0x20; + pub const WAITALL = 0x40; + pub const DONTWAIT = 0x80; + pub const BCAST = 0x100; + pub const MCAST = 0x200; + pub const NOSIGNAL = 0x400; + pub const CMSG_CLOEXEC = 0x800; + pub const WAITFORONE = 0x1000; + pub const CMSG_CLOFORK = 0x2000; + }, else => void, }; pub const SOCK = switch (native_os) { @@ -6664,7 +6720,12 @@ pub const SOMAXCONN = switch (native_os) { .windows => ws2_32.SOMAXCONN, // https://github.com/SerenityOS/serenity/blob/ac44ec5ebc707f9dd0c3d4759a1e17e91db5d74f/Kernel/API/POSIX/sys/socket.h#L128 .solaris, .illumos, .serenity => 128, - .openbsd => 28, + // https://github.com/freebsd/freebsd-src/blob/9ab31f821ad1c6bad474510447387c50bef2c24c/sys/sys/socket.h#L434 + // https://github.com/DragonFlyBSD/DragonFlyBSD/blob/fd3d1949d526ffa646e57037770acd6f2f3bb617/sys/sys/socket.h#L393 + // https://github.com/NetBSD/src/blob/a673fb3f8487e974c669216064f7588207229fea/sys/sys/socket.h#L472 + // https://github.com/openbsd/src/blob/8ba9cd88f10123fef7af805b8e5ccc2463ad8fa4/sys/sys/socket.h#L483 + // https://github.com/apple/darwin-xnu/blob/2ff845c2e033bd0ff64b5b6aa6063a1f8f65aa32/bsd/sys/socket.h#L815 + .freebsd, .dragonfly, .netbsd, .openbsd, .driverkit, .macos, .ios, .tvos, .watchos, .visionos => 128, else => void, }; pub const IFNAMESIZE = switch (native_os) { diff --git a/lib/std/crypto/aes_ocb.zig b/lib/std/crypto/aes_ocb.zig index b5a0e24f1a..44a0fb2430 100644 --- a/lib/std/crypto/aes_ocb.zig +++ b/lib/std/crypto/aes_ocb.zig @@ -155,12 +155,12 @@ fn AesOcb(comptime Aes: anytype) type { xorWith(&offset, lx.star); var pad = offset; aes_enc_ctx.encrypt(&pad, &pad); - for (m[i * 16 ..], 0..) |x, j| { - c[i * 16 + j] = pad[j] ^ x; - } var e = [_]u8{0} ** 16; @memcpy(e[0..leftover], m[i * 16 ..][0..leftover]); e[leftover] = 0x80; + for (m[i * 16 ..], 0..) |x, j| { + c[i * 16 + j] = pad[j] ^ x; + } xorWith(&sum, e); } var e = xorBlocks(xorBlocks(sum, offset), lx.dol); @@ -354,3 +354,32 @@ test "AesOcb test vector 4" { try Aes128Ocb.decrypt(&m2, &c, tag, &ad, nonce, k); assert(mem.eql(u8, &m, &m2)); } + +test "AesOcb in-place encryption-decryption" { + if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; + + var k: [Aes128Ocb.key_length]u8 = undefined; + var nonce: [Aes128Ocb.nonce_length]u8 = undefined; + var tag: [Aes128Ocb.tag_length]u8 = undefined; + var m: [40]u8 = undefined; + var original_m: [m.len]u8 = undefined; + _ = try hexToBytes(&k, "000102030405060708090A0B0C0D0E0F"); + _ = try hexToBytes(&m, "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F2021222324252627"); + _ = try hexToBytes(&nonce, "BBAA9988776655443322110D"); + const ad = m; + + @memcpy(&original_m, &m); + + Aes128Ocb.encrypt(&m, &tag, &m, &ad, nonce, k); + + var expected_c: [m.len]u8 = undefined; + var expected_tag: [tag.len]u8 = undefined; + _ = try hexToBytes(&expected_tag, "ED07BA06A4A69483A7035490C5769E60"); + _ = try hexToBytes(&expected_c, "D5CA91748410C1751FF8A2F618255B68A0A12E093FF454606E59F9C1D0DDC54B65E8628E568BAD7A"); + + try testing.expectEqualSlices(u8, &expected_tag, &tag); + try testing.expectEqualSlices(u8, &expected_c, &m); + try Aes128Ocb.decrypt(&m, &m, tag, &ad, nonce, k); + + try testing.expectEqualSlices(u8, &original_m, &m); +} diff --git a/lib/std/crypto/tls/Client.zig b/lib/std/crypto/tls/Client.zig index f9c897e3f0..b697d624fa 100644 --- a/lib/std/crypto/tls/Client.zig +++ b/lib/std/crypto/tls/Client.zig @@ -320,6 +320,7 @@ pub fn init(input: *Reader, output: *Writer, options: Options) InitError!Client var handshake_state: HandshakeState = .hello; var handshake_cipher: tls.HandshakeCipher = undefined; var main_cert_pub_key: CertificatePublicKey = undefined; + var tls12_negotiated_group: ?tls.NamedGroup = null; const now_sec = std.time.timestamp(); var cleartext_fragment_start: usize = 0; @@ -679,6 +680,7 @@ pub fn init(input: *Reader, output: *Writer, options: Options) InitError!Client const curve_type = hsd.decode(u8); if (curve_type != 0x03) return error.TlsIllegalParameter; // named_curve const named_group = hsd.decode(tls.NamedGroup); + tls12_negotiated_group = named_group; const key_size = hsd.decode(u8); try hsd.ensure(key_size); const server_pub_key = hsd.slice(key_size); @@ -691,10 +693,19 @@ pub fn init(input: *Reader, output: *Writer, options: Options) InitError!Client if (cipher_state != .cleartext) return error.TlsUnexpectedMessage; if (handshake_state != .server_hello_done) return error.TlsUnexpectedMessage; - const client_key_exchange_msg = .{@intFromEnum(tls.ContentType.handshake)} ++ + const public_key_bytes: []const u8 = switch (tls12_negotiated_group orelse .secp256r1) { + .secp256r1 => &key_share.secp256r1_kp.public_key.toUncompressedSec1(), + .secp384r1 => &key_share.secp384r1_kp.public_key.toUncompressedSec1(), + .x25519 => &key_share.x25519_kp.public_key, + else => return error.TlsIllegalParameter, + }; + + const client_key_exchange_prefix = .{@intFromEnum(tls.ContentType.handshake)} ++ int(u16, @intFromEnum(tls.ProtocolVersion.tls_1_2)) ++ - array(u16, u8, .{@intFromEnum(tls.HandshakeType.client_key_exchange)} ++ - array(u24, u8, array(u8, u8, key_share.secp256r1_kp.public_key.toUncompressedSec1()))); + int(u16, @intCast(public_key_bytes.len + 5)) ++ // record length + .{@intFromEnum(tls.HandshakeType.client_key_exchange)} ++ + int(u24, @intCast(public_key_bytes.len + 1)) ++ // handshake message length + .{@as(u8, @intCast(public_key_bytes.len))}; // public key length const client_change_cipher_spec_msg = .{@intFromEnum(tls.ContentType.change_cipher_spec)} ++ int(u16, @intFromEnum(tls.ProtocolVersion.tls_1_2)) ++ array(u16, tls.ChangeCipherSpecType, .{.change_cipher_spec}); @@ -703,7 +714,8 @@ pub fn init(input: *Reader, output: *Writer, options: Options) InitError!Client inline else => |*p| { const P = @TypeOf(p.*).A; p.transcript_hash.update(wrapped_handshake); - p.transcript_hash.update(client_key_exchange_msg[tls.record_header_len..]); + p.transcript_hash.update(client_key_exchange_prefix[tls.record_header_len..]); + p.transcript_hash.update(public_key_bytes); const master_secret = hmacExpandLabel(P.Hmac, pre_master_secret, &.{ "master secret", &client_hello_rand, @@ -757,8 +769,9 @@ pub fn init(input: *Reader, output: *Writer, options: Options) InitError!Client nonce, pv.app_cipher.client_write_key, ); - var all_msgs_vec: [3][]const u8 = .{ - &client_key_exchange_msg, + var all_msgs_vec: [4][]const u8 = .{ + &client_key_exchange_prefix, + public_key_bytes, &client_change_cipher_spec_msg, &client_verify_msg, }; @@ -929,7 +942,6 @@ fn drain(w: *Writer, data: []const []const u8, splat: usize) Writer.Error!usize if (prepared.cleartext_len < buf.len) break :done; } for (data[0 .. data.len - 1]) |buf| { - if (buf.len < min_buffer_len) break :done; const prepared = prepareCiphertextRecord(c, ciphertext_buf[ciphertext_end..], buf, .application_data); total_clear += prepared.cleartext_len; ciphertext_end += prepared.ciphertext_end; @@ -937,7 +949,6 @@ fn drain(w: *Writer, data: []const []const u8, splat: usize) Writer.Error!usize } const buf = data[data.len - 1]; for (0..splat) |_| { - if (buf.len < min_buffer_len) break :done; const prepared = prepareCiphertextRecord(c, ciphertext_buf[ciphertext_end..], buf, .application_data); total_clear += prepared.cleartext_len; ciphertext_end += prepared.ciphertext_end; diff --git a/lib/std/debug.zig b/lib/std/debug.zig index ebbcad627b..51896c4bb0 100644 --- a/lib/std/debug.zig +++ b/lib/std/debug.zig @@ -569,7 +569,7 @@ pub fn assertReadable(slice: []const volatile u8) void { /// Invokes detectable illegal behavior when the provided array is not aligned /// to the provided amount. pub fn assertAligned(ptr: anytype, comptime alignment: std.mem.Alignment) void { - const aligned_ptr: *align(alignment.toByteUnits()) anyopaque = @ptrCast(@alignCast(ptr)); + const aligned_ptr: *align(alignment.toByteUnits()) const anyopaque = @ptrCast(@alignCast(ptr)); _ = aligned_ptr; } diff --git a/lib/std/fs/Dir.zig b/lib/std/fs/Dir.zig index 16418d216f..768efdeff5 100644 --- a/lib/std/fs/Dir.zig +++ b/lib/std/fs/Dir.zig @@ -2583,8 +2583,9 @@ pub fn updateFile( error.ReadFailed => return src_reader.err.?, error.WriteFailed => return atomic_file.file_writer.err.?, }; + try atomic_file.flush(); try atomic_file.file_writer.file.updateTimes(src_stat.atime, src_stat.mtime); - try atomic_file.finish(); + try atomic_file.renameIntoPlace(); return .stale; } diff --git a/lib/std/fs/File.zig b/lib/std/fs/File.zig index 4465701f1a..420cf43aa6 100644 --- a/lib/std/fs/File.zig +++ b/lib/std/fs/File.zig @@ -1242,7 +1242,7 @@ pub const Reader = struct { pub fn seekBy(r: *Reader, offset: i64) Reader.SeekError!void { switch (r.mode) { .positional, .positional_reading => { - setPosAdjustingBuffer(r, @intCast(@as(i64, @intCast(r.pos)) + offset)); + setLogicalPos(r, @intCast(@as(i64, @intCast(logicalPos(r))) + offset)); }, .streaming, .streaming_reading => { if (posix.SEEK == void) { @@ -1251,7 +1251,7 @@ pub const Reader = struct { } const seek_err = r.seek_err orelse e: { if (posix.lseek_CUR(r.file.handle, offset)) |_| { - setPosAdjustingBuffer(r, @intCast(@as(i64, @intCast(r.pos)) + offset)); + setLogicalPos(r, @intCast(@as(i64, @intCast(logicalPos(r))) + offset)); return; } else |err| { r.seek_err = err; @@ -1275,16 +1275,17 @@ pub const Reader = struct { pub fn seekTo(r: *Reader, offset: u64) Reader.SeekError!void { switch (r.mode) { .positional, .positional_reading => { - setPosAdjustingBuffer(r, offset); + setLogicalPos(r, offset); }, .streaming, .streaming_reading => { - if (offset >= r.pos) return Reader.seekBy(r, @intCast(offset - r.pos)); + const logical_pos = logicalPos(r); + if (offset >= logical_pos) return Reader.seekBy(r, @intCast(offset - logical_pos)); if (r.seek_err) |err| return err; posix.lseek_SET(r.file.handle, offset) catch |err| { r.seek_err = err; return err; }; - setPosAdjustingBuffer(r, offset); + setLogicalPos(r, offset); }, .failure => return r.seek_err.?, } @@ -1294,7 +1295,7 @@ pub const Reader = struct { return r.pos - r.interface.bufferedLen(); } - fn setPosAdjustingBuffer(r: *Reader, offset: u64) void { + fn setLogicalPos(r: *Reader, offset: u64) void { const logical_pos = logicalPos(r); if (offset < logical_pos or offset >= r.pos) { r.interface.seek = 0; @@ -1322,13 +1323,15 @@ pub const Reader = struct { }, .positional_reading => { const dest = limit.slice(try w.writableSliceGreedy(1)); - const n = try readPositional(r, dest); + var data: [1][]u8 = .{dest}; + const n = try readVecPositional(r, &data); w.advance(n); return n; }, .streaming_reading => { const dest = limit.slice(try w.writableSliceGreedy(1)); - const n = try readStreaming(r, dest); + var data: [1][]u8 = .{dest}; + const n = try readVecStreaming(r, &data); w.advance(n); return n; }, @@ -1339,94 +1342,100 @@ pub const Reader = struct { fn readVec(io_reader: *std.Io.Reader, data: [][]u8) std.Io.Reader.Error!usize { const r: *Reader = @alignCast(@fieldParentPtr("interface", io_reader)); switch (r.mode) { - .positional, .positional_reading => { - if (is_windows) { - // Unfortunately, `ReadFileScatter` cannot be used since it - // requires page alignment. - if (io_reader.seek == io_reader.end) { - io_reader.seek = 0; - io_reader.end = 0; - } - const first = data[0]; - if (first.len >= io_reader.buffer.len - io_reader.end) { - return readPositional(r, first); - } else { - io_reader.end += try readPositional(r, io_reader.buffer[io_reader.end..]); - return 0; - } - } - var iovecs_buffer: [max_buffers_len]posix.iovec = undefined; - const dest_n, const data_size = try io_reader.writableVectorPosix(&iovecs_buffer, data); - const dest = iovecs_buffer[0..dest_n]; - assert(dest[0].len > 0); - const n = posix.preadv(r.file.handle, dest, r.pos) catch |err| switch (err) { - error.Unseekable => { - r.mode = r.mode.toStreaming(); - const pos = r.pos; - if (pos != 0) { - r.pos = 0; - r.seekBy(@intCast(pos)) catch { - r.mode = .failure; - return error.ReadFailed; - }; - } - return 0; - }, - else => |e| { - r.err = e; - return error.ReadFailed; - }, - }; - if (n == 0) { - r.size = r.pos; - return error.EndOfStream; - } - r.pos += n; - if (n > data_size) { - io_reader.end += n - data_size; - return data_size; - } - return n; - }, - .streaming, .streaming_reading => { - if (is_windows) { - // Unfortunately, `ReadFileScatter` cannot be used since it - // requires page alignment. - if (io_reader.seek == io_reader.end) { - io_reader.seek = 0; - io_reader.end = 0; - } - const first = data[0]; - if (first.len >= io_reader.buffer.len - io_reader.end) { - return readPositional(r, first); - } else { - io_reader.end += try readPositional(r, io_reader.buffer[io_reader.end..]); - return 0; - } - } - var iovecs_buffer: [max_buffers_len]posix.iovec = undefined; - const dest_n, const data_size = try io_reader.writableVectorPosix(&iovecs_buffer, data); - const dest = iovecs_buffer[0..dest_n]; - assert(dest[0].len > 0); - const n = posix.readv(r.file.handle, dest) catch |err| { - r.err = err; - return error.ReadFailed; - }; - if (n == 0) { - r.size = r.pos; - return error.EndOfStream; - } - r.pos += n; - if (n > data_size) { - io_reader.end += n - data_size; - return data_size; - } - return n; - }, + .positional, .positional_reading => return readVecPositional(r, data), + .streaming, .streaming_reading => return readVecStreaming(r, data), .failure => return error.ReadFailed, } } + fn readVecPositional(r: *Reader, data: [][]u8) std.Io.Reader.Error!usize { + const io_reader = &r.interface; + if (is_windows) { + // Unfortunately, `ReadFileScatter` cannot be used since it + // requires page alignment. + if (io_reader.seek == io_reader.end) { + io_reader.seek = 0; + io_reader.end = 0; + } + const first = data[0]; + if (first.len >= io_reader.buffer.len - io_reader.end) { + return readPositional(r, first); + } else { + io_reader.end += try readPositional(r, io_reader.buffer[io_reader.end..]); + return 0; + } + } + var iovecs_buffer: [max_buffers_len]posix.iovec = undefined; + const dest_n, const data_size = try io_reader.writableVectorPosix(&iovecs_buffer, data); + const dest = iovecs_buffer[0..dest_n]; + assert(dest[0].len > 0); + const n = posix.preadv(r.file.handle, dest, r.pos) catch |err| switch (err) { + error.Unseekable => { + r.mode = r.mode.toStreaming(); + const pos = r.pos; + if (pos != 0) { + r.pos = 0; + r.seekBy(@intCast(pos)) catch { + r.mode = .failure; + return error.ReadFailed; + }; + } + return 0; + }, + else => |e| { + r.err = e; + return error.ReadFailed; + }, + }; + if (n == 0) { + r.size = r.pos; + return error.EndOfStream; + } + r.pos += n; + if (n > data_size) { + io_reader.end += n - data_size; + return data_size; + } + return n; + } + + fn readVecStreaming(r: *Reader, data: [][]u8) std.Io.Reader.Error!usize { + const io_reader = &r.interface; + if (is_windows) { + // Unfortunately, `ReadFileScatter` cannot be used since it + // requires page alignment. + if (io_reader.seek == io_reader.end) { + io_reader.seek = 0; + io_reader.end = 0; + } + const first = data[0]; + if (first.len >= io_reader.buffer.len - io_reader.end) { + return readStreaming(r, first); + } else { + io_reader.end += try readStreaming(r, io_reader.buffer[io_reader.end..]); + return 0; + } + } + var iovecs_buffer: [max_buffers_len]posix.iovec = undefined; + const dest_n, const data_size = try io_reader.writableVectorPosix(&iovecs_buffer, data); + const dest = iovecs_buffer[0..dest_n]; + assert(dest[0].len > 0); + const n = posix.readv(r.file.handle, dest) catch |err| { + r.err = err; + return error.ReadFailed; + }; + if (n == 0) { + r.size = r.pos; + return error.EndOfStream; + } + r.pos += n; + if (n > data_size) { + io_reader.end += n - data_size; + return data_size; + } + return n; + } + fn discard(io_reader: *std.Io.Reader, limit: std.Io.Limit) std.Io.Reader.Error!usize { const r: *Reader = @alignCast(@fieldParentPtr("interface", io_reader)); const file = r.file; @@ -1493,7 +1502,7 @@ pub const Reader = struct { } } - pub fn readPositional(r: *Reader, dest: []u8) std.Io.Reader.Error!usize { + fn readPositional(r: *Reader, dest: []u8) std.Io.Reader.Error!usize { const n = r.file.pread(dest, r.pos) catch |err| switch (err) { error.Unseekable => { r.mode = r.mode.toStreaming(); @@ -1520,7 +1529,7 @@ pub const Reader = struct { return n; } - pub fn readStreaming(r: *Reader, dest: []u8) std.Io.Reader.Error!usize { + fn readStreaming(r: *Reader, dest: []u8) std.Io.Reader.Error!usize { const n = r.file.read(dest) catch |err| { r.err = err; return error.ReadFailed; @@ -1533,14 +1542,6 @@ pub const Reader = struct { return n; } - pub fn read(r: *Reader, dest: []u8) std.Io.Reader.Error!usize { - switch (r.mode) { - .positional, .positional_reading => return readPositional(r, dest), - .streaming, .streaming_reading => return readStreaming(r, dest), - .failure => return error.ReadFailed, - } - } - pub fn atEnd(r: *Reader) bool { // Even if stat fails, size is set when end is encountered. const size = r.size orelse return false; @@ -1783,7 +1784,7 @@ pub const Writer = struct { ) std.Io.Writer.FileError!usize { const reader_buffered = file_reader.interface.buffered(); if (reader_buffered.len >= @intFromEnum(limit)) - return sendFileBuffered(io_w, file_reader, reader_buffered); + return sendFileBuffered(io_w, file_reader, limit.slice(reader_buffered)); const writer_buffered = io_w.buffered(); const file_limit = @intFromEnum(limit) - reader_buffered.len; const w: *Writer = @alignCast(@fieldParentPtr("interface", io_w)); @@ -1855,7 +1856,7 @@ pub const Writer = struct { return error.EndOfStream; } const consumed = io_w.consume(@intCast(sbytes)); - file_reader.seekTo(file_reader.pos + consumed) catch return error.ReadFailed; + file_reader.seekBy(@intCast(consumed)) catch return error.ReadFailed; return consumed; } @@ -1916,7 +1917,7 @@ pub const Writer = struct { return error.EndOfStream; } const consumed = io_w.consume(@bitCast(len)); - file_reader.seekTo(file_reader.pos + consumed) catch return error.ReadFailed; + file_reader.seekBy(@intCast(consumed)) catch return error.ReadFailed; return consumed; } @@ -1967,7 +1968,7 @@ pub const Writer = struct { const copy_file_range = switch (native_os) { .freebsd => std.os.freebsd.copy_file_range, - .linux => if (std.c.versionCheck(if (builtin.abi.isAndroid()) .{ .major = 34, .minor = 0, .patch = 0 } else .{ .major = 2, .minor = 27, .patch = 0 })) std.os.linux.wrapped.copy_file_range else {}, + .linux => std.os.linux.wrapped.copy_file_range, else => {}, }; if (@TypeOf(copy_file_range) != void) cfr: { @@ -2049,7 +2050,7 @@ pub const Writer = struct { reader_buffered: []const u8, ) std.Io.Writer.FileError!usize { const n = try drain(io_w, &.{reader_buffered}, 1); - file_reader.seekTo(file_reader.pos + n) catch return error.ReadFailed; + file_reader.seekBy(@intCast(n)) catch return error.ReadFailed; return n; } diff --git a/lib/std/fs/test.zig b/lib/std/fs/test.zig index 60879a5ead..bbfd98b1a0 100644 --- a/lib/std/fs/test.zig +++ b/lib/std/fs/test.zig @@ -1515,6 +1515,41 @@ test "sendfile" { try testing.expectEqualStrings("header1\nsecond header\nine1\nsecontrailer1\nsecond trailer\n", written_buf[0..amt]); } +test "sendfile with buffered data" { + var tmp = tmpDir(.{}); + defer tmp.cleanup(); + + try tmp.dir.makePath("os_test_tmp"); + + var dir = try tmp.dir.openDir("os_test_tmp", .{}); + defer dir.close(); + + var src_file = try dir.createFile("sendfile1.txt", .{ .read = true }); + defer src_file.close(); + + try src_file.writeAll("AAAABBBB"); + + var dest_file = try dir.createFile("sendfile2.txt", .{ .read = true }); + defer dest_file.close(); + + var src_buffer: [32]u8 = undefined; + var file_reader = src_file.reader(&src_buffer); + + try file_reader.seekTo(0); + try file_reader.interface.fill(8); + + var fallback_buffer: [32]u8 = undefined; + var file_writer = dest_file.writer(&fallback_buffer); + + try std.testing.expectEqual(4, try file_writer.interface.sendFileAll(&file_reader, .limited(4))); + + var written_buf: [8]u8 = undefined; + const amt = try dest_file.preadAll(&written_buf, 0); + + try std.testing.expectEqual(4, amt); + try std.testing.expectEqualSlices(u8, "AAAA", written_buf[0..amt]); +} + test "copyRangeAll" { var tmp = tmpDir(.{}); defer tmp.cleanup(); @@ -2145,3 +2180,34 @@ test "seekBy" { try testing.expectEqual(15, n); try testing.expectEqualStrings("t's test seekBy", buffer[0..15]); } + +test "File.Writer sendfile with buffered contents" { + var tmp_dir = testing.tmpDir(.{}); + defer tmp_dir.cleanup(); + + { + try tmp_dir.dir.writeFile(.{ .sub_path = "a", .data = "bcd" }); + const in = try tmp_dir.dir.openFile("a", .{}); + defer in.close(); + const out = try tmp_dir.dir.createFile("b", .{}); + defer out.close(); + + var in_buf: [2]u8 = undefined; + var in_r = in.reader(&in_buf); + _ = try in_r.getSize(); // Catch seeks past end by populating size + try in_r.interface.fill(2); + + var out_buf: [1]u8 = undefined; + var out_w = out.writerStreaming(&out_buf); + try out_w.interface.writeByte('a'); + try testing.expectEqual(3, try out_w.interface.sendFileAll(&in_r, .unlimited)); + try out_w.interface.flush(); + } + + var check = try tmp_dir.dir.openFile("b", .{}); + defer check.close(); + var check_buf: [4]u8 = undefined; + var check_r = check.reader(&check_buf); + try testing.expectEqualStrings("abcd", try check_r.interface.take(4)); + try testing.expectError(error.EndOfStream, check_r.interface.takeByte()); +} diff --git a/lib/std/http/Client.zig b/lib/std/http/Client.zig index b507128c9c..3757391735 100644 --- a/lib/std/http/Client.zig +++ b/lib/std/http/Client.zig @@ -1375,7 +1375,7 @@ pub const basic_authorization = struct { var buf: [max_user_len + 1 + max_password_len]u8 = undefined; var w: Writer = .fixed(&buf); const user: Uri.Component = uri.user orelse .empty; - const password: Uri.Component = uri.user orelse .empty; + const password: Uri.Component = uri.password orelse .empty; user.formatUser(&w) catch unreachable; w.writeByte(':') catch unreachable; password.formatPassword(&w) catch unreachable; @@ -1797,9 +1797,10 @@ pub fn fetch(client: *Client, options: FetchOptions) FetchError!FetchResult { if (options.payload) |payload| { req.transfer_encoding = .{ .content_length = payload.len }; - var body = try req.sendBody(&.{}); + var body = try req.sendBodyUnflushed(&.{}); try body.writer.writeAll(payload); try body.end(); + try req.connection.?.flush(); } else { try req.sendBodiless(); } diff --git a/lib/std/http/test.zig b/lib/std/http/test.zig index 91a57dbbe2..fac241ede4 100644 --- a/lib/std/http/test.zig +++ b/lib/std/http/test.zig @@ -1105,8 +1105,8 @@ fn createTestServer(S: type) !*TestServer { const test_server = try std.testing.allocator.create(TestServer); test_server.* = .{ .net_server = try address.listen(.{ .reuse_address = true }), - .server_thread = try std.Thread.spawn(.{}, S.run, .{test_server}), .shutting_down = false, + .server_thread = try std.Thread.spawn(.{}, S.run, .{test_server}), }; return test_server; } diff --git a/lib/std/json/static.zig b/lib/std/json/static.zig index 540f5338f9..ced6894027 100644 --- a/lib/std/json/static.zig +++ b/lib/std/json/static.zig @@ -567,8 +567,8 @@ pub fn innerParseFromValue( switch (source) { .float => |f| { if (@round(f) != f) return error.InvalidNumber; - if (f > std.math.maxInt(T)) return error.Overflow; - if (f < std.math.minInt(T)) return error.Overflow; + if (f > @as(@TypeOf(f), @floatFromInt(std.math.maxInt(T)))) return error.Overflow; + if (f < @as(@TypeOf(f), @floatFromInt(std.math.minInt(T)))) return error.Overflow; return @as(T, @intFromFloat(f)); }, .integer => |i| { @@ -770,7 +770,7 @@ fn sliceToInt(comptime T: type, slice: []const u8) !T { // Try to coerce a float to an integer. const float = try std.fmt.parseFloat(f128, slice); if (@round(float) != float) return error.InvalidNumber; - if (float > std.math.maxInt(T) or float < std.math.minInt(T)) return error.Overflow; + if (float > @as(f128, @floatFromInt(std.math.maxInt(T))) or float < @as(f128, @floatFromInt(std.math.minInt(T)))) return error.Overflow; return @as(T, @intCast(@as(i128, @intFromFloat(float)))); } diff --git a/lib/std/math/big/int.zig b/lib/std/math/big/int.zig index b0380444f4..427f2861b7 100644 --- a/lib/std/math/big/int.zig +++ b/lib/std/math/big/int.zig @@ -786,11 +786,10 @@ pub const Mutable = struct { assert(rma.limbs.ptr != b.limbs.ptr); // illegal aliasing if (a.limbs.len == 1 and b.limbs.len == 1) { - const ov = @mulWithOverflow(a.limbs[0], b.limbs[0]); - rma.limbs[0] = ov[0]; - if (ov[1] == 0) { + rma.limbs[0], const overflow_bit = @mulWithOverflow(a.limbs[0], b.limbs[0]); + if (overflow_bit == 0) { rma.len = 1; - rma.positive = (a.positive == b.positive); + rma.positive = (a.positive == b.positive) or rma.limbs[0] == 0; return; } } diff --git a/lib/std/math/powi.zig b/lib/std/math/powi.zig index aed79e097c..285dc5e209 100644 --- a/lib/std/math/powi.zig +++ b/lib/std/math/powi.zig @@ -13,6 +13,7 @@ const testing = std.testing; /// Errors: /// - Overflow: Integer overflow or Infinity /// - Underflow: Absolute value of result smaller than 1 +/// /// Edge case rules ordered by precedence: /// - powi(T, x, 0) = 1 unless T is i1, i0, u0 /// - powi(T, 0, x) = 0 when x > 0 diff --git a/lib/std/mem.zig b/lib/std/mem.zig index f688bafcae..6a5e654fab 100644 --- a/lib/std/mem.zig +++ b/lib/std/mem.zig @@ -3785,6 +3785,7 @@ test rotate { /// Replace needle with replacement as many times as possible, writing to an output buffer which is assumed to be of /// appropriate size. Use replacementSize to calculate an appropriate buffer size. +/// The `input` and `output` slices must not overlap. /// The needle must not be empty. /// Returns the number of replacements made. pub fn replace(comptime T: type, input: []const T, needle: []const T, replacement: []const T, output: []T) usize { @@ -4484,7 +4485,8 @@ pub fn doNotOptimizeAway(val: anytype) void { } else doNotOptimizeAway(&val); }, .float => { - if ((t.float.bits == 32 or t.float.bits == 64) and builtin.zig_backend != .stage2_c) { + // https://github.com/llvm/llvm-project/issues/159200 + if ((t.float.bits == 32 or t.float.bits == 64) and builtin.zig_backend != .stage2_c and !builtin.cpu.arch.isLoongArch()) { asm volatile ("" : : [_] "rm" (val), diff --git a/lib/std/mem/Allocator.zig b/lib/std/mem/Allocator.zig index b81a916702..897f1d2b31 100644 --- a/lib/std/mem/Allocator.zig +++ b/lib/std/mem/Allocator.zig @@ -358,8 +358,10 @@ pub fn remap(self: Allocator, allocation: anytype, new_len: usize) t: { return mem.bytesAsSlice(T, new_memory); } -/// This function requests a new byte size for an existing allocation, which +/// This function requests a new size for an existing allocation, which /// can be larger, smaller, or the same size as the old memory allocation. +/// The result is an array of `new_n` items of the same type as the existing +/// allocation. /// /// If `new_n` is 0, this is the same as `free` and it always succeeds. /// diff --git a/lib/std/net.zig b/lib/std/net.zig index 083bda85d5..03383b0f89 100644 --- a/lib/std/net.zig +++ b/lib/std/net.zig @@ -1393,7 +1393,7 @@ fn parseHosts( br: *Io.Reader, ) error{ OutOfMemory, ReadFailed }!void { while (true) { - const line = br.takeDelimiterExclusive('\n') catch |err| switch (err) { + const line = br.takeDelimiter('\n') catch |err| switch (err) { error.StreamTooLong => { // Skip lines that are too long. _ = br.discardDelimiterInclusive('\n') catch |e| switch (e) { @@ -1403,7 +1403,8 @@ fn parseHosts( continue; }, error.ReadFailed => return error.ReadFailed, - error.EndOfStream => break, + } orelse { + break; // end of stream }; var split_it = mem.splitScalar(u8, line, '#'); const no_comment_line = split_it.first(); diff --git a/lib/std/os/linux.zig b/lib/std/os/linux.zig index 1aa9ea2852..c2aa40f552 100644 --- a/lib/std/os/linux.zig +++ b/lib/std/os/linux.zig @@ -1238,11 +1238,14 @@ pub fn access(path: [*:0]const u8, mode: u32) usize { if (@hasField(SYS, "access")) { return syscall2(.access, @intFromPtr(path), mode); } else { - return syscall4(.faccessat, @as(usize, @bitCast(@as(isize, AT.FDCWD))), @intFromPtr(path), mode, 0); + return faccessat(AT.FDCWD, path, mode, 0); } } pub fn faccessat(dirfd: i32, path: [*:0]const u8, mode: u32, flags: u32) usize { + if (flags == 0) { + return syscall3(.faccessat, @as(usize, @bitCast(@as(isize, dirfd))), @intFromPtr(path), mode); + } return syscall4(.faccessat2, @as(usize, @bitCast(@as(isize, dirfd))), @intFromPtr(path), mode, flags); } @@ -9799,7 +9802,9 @@ pub const wrapped = struct { }; pub fn copy_file_range(fd_in: fd_t, off_in: ?*i64, fd_out: fd_t, off_out: ?*i64, len: usize, flags: u32) CopyFileRangeError!usize { - const rc = system.copy_file_range(fd_in, off_in, fd_out, off_out, len, flags); + const use_c = std.c.versionCheck(if (builtin.abi.isAndroid()) .{ .major = 34, .minor = 0, .patch = 0 } else .{ .major = 2, .minor = 27, .patch = 0 }); + const sys = if (use_c) std.c else std.os.linux; + const rc = sys.copy_file_range(fd_in, off_in, fd_out, off_out, len, flags); switch (errno(rc)) { .SUCCESS => return @intCast(rc), .BADF => return error.BadFileFlags, diff --git a/lib/std/os/linux/bpf.zig b/lib/std/os/linux/bpf.zig index 86bc071030..a0d5956af8 100644 --- a/lib/std/os/linux/bpf.zig +++ b/lib/std/os/linux/bpf.zig @@ -642,7 +642,7 @@ pub const Insn = packed struct { .dst = @intFromEnum(dst), .src = @intFromEnum(src), .off = 0, - .imm = @as(i32, @intCast(@as(u32, @truncate(imm)))), + .imm = @as(i32, @bitCast(@as(u32, @truncate(imm)))), }; } @@ -652,7 +652,7 @@ pub const Insn = packed struct { .dst = 0, .src = 0, .off = 0, - .imm = @as(i32, @intCast(@as(u32, @truncate(imm >> 32)))), + .imm = @as(i32, @bitCast(@as(u32, @truncate(imm >> 32)))), }; } diff --git a/lib/std/os/linux/powerpc.zig b/lib/std/os/linux/powerpc.zig index 018ea2309c..ee1887143a 100644 --- a/lib/std/os/linux/powerpc.zig +++ b/lib/std/os/linux/powerpc.zig @@ -15,84 +15,125 @@ const sockaddr = linux.sockaddr; const timespec = linux.timespec; pub fn syscall0(number: SYS) usize { + // r0 is both an input register and a clobber. musl and glibc achieve this with + // a "+" constraint, which isn't supported in Zig, so instead we separately list + // r0 as both an input and an output. (Listing it as an input and a clobber would + // cause the C backend to emit invalid code; see #25209.) + var r0_out: usize = undefined; return asm volatile ( \\ sc \\ bns+ 1f \\ neg 3, 3 \\ 1: : [ret] "={r3}" (-> usize), + [r0_out] "={r0}" (r0_out), : [number] "{r0}" (@intFromEnum(number)), - : .{ .memory = true, .cr0 = true, .r0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true }); + : .{ .memory = true, .cr0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true }); } pub fn syscall1(number: SYS, arg1: usize) usize { + // r0 is both an input and a clobber. + var r0_out: usize = undefined; return asm volatile ( \\ sc \\ bns+ 1f \\ neg 3, 3 \\ 1: : [ret] "={r3}" (-> usize), + [r0_out] "={r0}" (r0_out), : [number] "{r0}" (@intFromEnum(number)), [arg1] "{r3}" (arg1), - : .{ .memory = true, .cr0 = true, .r0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true }); + : .{ .memory = true, .cr0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true }); } pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize { + // These registers are both inputs and clobbers. + var r0_out: usize = undefined; + var r4_out: usize = undefined; return asm volatile ( \\ sc \\ bns+ 1f \\ neg 3, 3 \\ 1: : [ret] "={r3}" (-> usize), + [r0_out] "={r0}" (r0_out), + [r4_out] "={r4}" (r4_out), : [number] "{r0}" (@intFromEnum(number)), [arg1] "{r3}" (arg1), [arg2] "{r4}" (arg2), - : .{ .memory = true, .cr0 = true, .r0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true }); + : .{ .memory = true, .cr0 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true }); } pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize { + // These registers are both inputs and clobbers. + var r0_out: usize = undefined; + var r4_out: usize = undefined; + var r5_out: usize = undefined; return asm volatile ( \\ sc \\ bns+ 1f \\ neg 3, 3 \\ 1: : [ret] "={r3}" (-> usize), + [r0_out] "={r0}" (r0_out), + [r4_out] "={r4}" (r4_out), + [r5_out] "={r5}" (r5_out), : [number] "{r0}" (@intFromEnum(number)), [arg1] "{r3}" (arg1), [arg2] "{r4}" (arg2), [arg3] "{r5}" (arg3), - : .{ .memory = true, .cr0 = true, .r0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true }); + : .{ .memory = true, .cr0 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true }); } pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize { + // These registers are both inputs and clobbers. + var r0_out: usize = undefined; + var r4_out: usize = undefined; + var r5_out: usize = undefined; + var r6_out: usize = undefined; return asm volatile ( \\ sc \\ bns+ 1f \\ neg 3, 3 \\ 1: : [ret] "={r3}" (-> usize), + [r0_out] "={r0}" (r0_out), + [r4_out] "={r4}" (r4_out), + [r5_out] "={r5}" (r5_out), + [r6_out] "={r6}" (r6_out), : [number] "{r0}" (@intFromEnum(number)), [arg1] "{r3}" (arg1), [arg2] "{r4}" (arg2), [arg3] "{r5}" (arg3), [arg4] "{r6}" (arg4), - : .{ .memory = true, .cr0 = true, .r0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true }); + : .{ .memory = true, .cr0 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true }); } pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize { + // These registers are both inputs and clobbers. + var r0_out: usize = undefined; + var r4_out: usize = undefined; + var r5_out: usize = undefined; + var r6_out: usize = undefined; + var r7_out: usize = undefined; return asm volatile ( \\ sc \\ bns+ 1f \\ neg 3, 3 \\ 1: : [ret] "={r3}" (-> usize), + [r0_out] "={r0}" (r0_out), + [r4_out] "={r4}" (r4_out), + [r5_out] "={r5}" (r5_out), + [r6_out] "={r6}" (r6_out), + [r7_out] "={r7}" (r7_out), : [number] "{r0}" (@intFromEnum(number)), [arg1] "{r3}" (arg1), [arg2] "{r4}" (arg2), [arg3] "{r5}" (arg3), [arg4] "{r6}" (arg4), [arg5] "{r7}" (arg5), - : .{ .memory = true, .cr0 = true, .r0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true }); + : .{ .memory = true, .cr0 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true }); } pub fn syscall6( @@ -104,12 +145,25 @@ pub fn syscall6( arg5: usize, arg6: usize, ) usize { + // These registers are both inputs and clobbers. + var r0_out: usize = undefined; + var r4_out: usize = undefined; + var r5_out: usize = undefined; + var r6_out: usize = undefined; + var r7_out: usize = undefined; + var r8_out: usize = undefined; return asm volatile ( \\ sc \\ bns+ 1f \\ neg 3, 3 \\ 1: : [ret] "={r3}" (-> usize), + [r0_out] "={r0}" (r0_out), + [r4_out] "={r4}" (r4_out), + [r5_out] "={r5}" (r5_out), + [r6_out] "={r6}" (r6_out), + [r7_out] "={r7}" (r7_out), + [r8_out] "={r8}" (r8_out), : [number] "{r0}" (@intFromEnum(number)), [arg1] "{r3}" (arg1), [arg2] "{r4}" (arg2), @@ -117,7 +171,7 @@ pub fn syscall6( [arg4] "{r6}" (arg4), [arg5] "{r7}" (arg5), [arg6] "{r8}" (arg6), - : .{ .memory = true, .cr0 = true, .r0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true }); + : .{ .memory = true, .cr0 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true }); } pub fn clone() callconv(.naked) usize { @@ -193,11 +247,19 @@ pub fn clone() callconv(.naked) usize { pub const restore = restore_rt; pub fn restore_rt() callconv(.naked) noreturn { - asm volatile ( - \\ sc - : - : [number] "{r0}" (@intFromEnum(SYS.rt_sigreturn)), - : .{ .memory = true, .cr0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true }); + switch (@import("builtin").zig_backend) { + .stage2_c => asm volatile ( + \\ li 0, %[number] + \\ sc + : + : [number] "i" (@intFromEnum(SYS.rt_sigreturn)), + : .{ .memory = true, .cr0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true }), + else => _ = asm volatile ( + \\ sc + : + : [number] "{r0}" (@intFromEnum(SYS.rt_sigreturn)), + : .{ .memory = true, .cr0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true }), + } } pub const F = struct { diff --git a/lib/std/os/linux/powerpc64.zig b/lib/std/os/linux/powerpc64.zig index d737738c4c..ffb17551e3 100644 --- a/lib/std/os/linux/powerpc64.zig +++ b/lib/std/os/linux/powerpc64.zig @@ -15,84 +15,125 @@ const sockaddr = linux.sockaddr; const timespec = linux.timespec; pub fn syscall0(number: SYS) usize { + // r0 is both an input register and a clobber. musl and glibc achieve this with + // a "+" constraint, which isn't supported in Zig, so instead we separately list + // r0 as both an input and an output. (Listing it as an input and a clobber would + // cause the C backend to emit invalid code; see #25209.) + var r0_out: usize = undefined; return asm volatile ( \\ sc \\ bns+ 1f \\ neg 3, 3 \\ 1: : [ret] "={r3}" (-> usize), + [r0_out] "={r0}" (r0_out), : [number] "{r0}" (@intFromEnum(number)), - : .{ .memory = true, .cr0 = true, .r0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true }); + : .{ .memory = true, .cr0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true }); } pub fn syscall1(number: SYS, arg1: usize) usize { + // r0 is both an input and a clobber. + var r0_out: usize = undefined; return asm volatile ( \\ sc \\ bns+ 1f \\ neg 3, 3 \\ 1: : [ret] "={r3}" (-> usize), + [r0_out] "={r0}" (r0_out), : [number] "{r0}" (@intFromEnum(number)), [arg1] "{r3}" (arg1), - : .{ .memory = true, .cr0 = true, .r0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true }); + : .{ .memory = true, .cr0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true }); } pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize { + // These registers are both inputs and clobbers. + var r0_out: usize = undefined; + var r4_out: usize = undefined; return asm volatile ( \\ sc \\ bns+ 1f \\ neg 3, 3 \\ 1: : [ret] "={r3}" (-> usize), + [r0_out] "={r0}" (r0_out), + [r4_out] "={r4}" (r4_out), : [number] "{r0}" (@intFromEnum(number)), [arg1] "{r3}" (arg1), [arg2] "{r4}" (arg2), - : .{ .memory = true, .cr0 = true, .r0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true }); + : .{ .memory = true, .cr0 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true }); } pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize { + // These registers are both inputs and clobbers. + var r0_out: usize = undefined; + var r4_out: usize = undefined; + var r5_out: usize = undefined; return asm volatile ( \\ sc \\ bns+ 1f \\ neg 3, 3 \\ 1: : [ret] "={r3}" (-> usize), + [r0_out] "={r0}" (r0_out), + [r4_out] "={r4}" (r4_out), + [r5_out] "={r5}" (r5_out), : [number] "{r0}" (@intFromEnum(number)), [arg1] "{r3}" (arg1), [arg2] "{r4}" (arg2), [arg3] "{r5}" (arg3), - : .{ .memory = true, .cr0 = true, .r0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true }); + : .{ .memory = true, .cr0 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true }); } pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize { + // These registers are both inputs and clobbers. + var r0_out: usize = undefined; + var r4_out: usize = undefined; + var r5_out: usize = undefined; + var r6_out: usize = undefined; return asm volatile ( \\ sc \\ bns+ 1f \\ neg 3, 3 \\ 1: : [ret] "={r3}" (-> usize), + [r0_out] "={r0}" (r0_out), + [r4_out] "={r4}" (r4_out), + [r5_out] "={r5}" (r5_out), + [r6_out] "={r6}" (r6_out), : [number] "{r0}" (@intFromEnum(number)), [arg1] "{r3}" (arg1), [arg2] "{r4}" (arg2), [arg3] "{r5}" (arg3), [arg4] "{r6}" (arg4), - : .{ .memory = true, .cr0 = true, .r0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true }); + : .{ .memory = true, .cr0 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true }); } pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize { + // These registers are both inputs and clobbers. + var r0_out: usize = undefined; + var r4_out: usize = undefined; + var r5_out: usize = undefined; + var r6_out: usize = undefined; + var r7_out: usize = undefined; return asm volatile ( \\ sc \\ bns+ 1f \\ neg 3, 3 \\ 1: : [ret] "={r3}" (-> usize), + [r0_out] "={r0}" (r0_out), + [r4_out] "={r4}" (r4_out), + [r5_out] "={r5}" (r5_out), + [r6_out] "={r6}" (r6_out), + [r7_out] "={r7}" (r7_out), : [number] "{r0}" (@intFromEnum(number)), [arg1] "{r3}" (arg1), [arg2] "{r4}" (arg2), [arg3] "{r5}" (arg3), [arg4] "{r6}" (arg4), [arg5] "{r7}" (arg5), - : .{ .memory = true, .cr0 = true, .r0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true }); + : .{ .memory = true, .cr0 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true }); } pub fn syscall6( @@ -104,12 +145,25 @@ pub fn syscall6( arg5: usize, arg6: usize, ) usize { + // These registers are both inputs and clobbers. + var r0_out: usize = undefined; + var r4_out: usize = undefined; + var r5_out: usize = undefined; + var r6_out: usize = undefined; + var r7_out: usize = undefined; + var r8_out: usize = undefined; return asm volatile ( \\ sc \\ bns+ 1f \\ neg 3, 3 \\ 1: : [ret] "={r3}" (-> usize), + [r0_out] "={r0}" (r0_out), + [r4_out] "={r4}" (r4_out), + [r5_out] "={r5}" (r5_out), + [r6_out] "={r6}" (r6_out), + [r7_out] "={r7}" (r7_out), + [r8_out] "={r8}" (r8_out), : [number] "{r0}" (@intFromEnum(number)), [arg1] "{r3}" (arg1), [arg2] "{r4}" (arg2), @@ -117,7 +171,7 @@ pub fn syscall6( [arg4] "{r6}" (arg4), [arg5] "{r7}" (arg5), [arg6] "{r8}" (arg6), - : .{ .memory = true, .cr0 = true, .r0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true }); + : .{ .memory = true, .cr0 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true }); } pub fn clone() callconv(.naked) usize { @@ -178,11 +232,19 @@ pub fn clone() callconv(.naked) usize { pub const restore = restore_rt; pub fn restore_rt() callconv(.naked) noreturn { - asm volatile ( - \\ sc - : - : [number] "{r0}" (@intFromEnum(SYS.rt_sigreturn)), - : .{ .memory = true, .cr0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true }); + switch (@import("builtin").zig_backend) { + .stage2_c => asm volatile ( + \\ li 0, %[number] + \\ sc + : + : [number] "i" (@intFromEnum(SYS.rt_sigreturn)), + : .{ .memory = true, .cr0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true }), + else => _ = asm volatile ( + \\ sc + : + : [number] "{r0}" (@intFromEnum(SYS.rt_sigreturn)), + : .{ .memory = true, .cr0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true }), + } } pub const F = struct { diff --git a/lib/std/os/uefi/protocol/service_binding.zig b/lib/std/os/uefi/protocol/service_binding.zig index 06cc64001e..ddbda29ee6 100644 --- a/lib/std/os/uefi/protocol/service_binding.zig +++ b/lib/std/os/uefi/protocol/service_binding.zig @@ -1,5 +1,5 @@ const std = @import("std"); -const uefi = std.uefi; +const uefi = std.os.uefi; const Guid = uefi.Guid; const Handle = uefi.Handle; const Status = uefi.Status; diff --git a/lib/std/os/uefi/tables.zig b/lib/std/os/uefi/tables.zig index ad163dbdbf..90e525c507 100644 --- a/lib/std/os/uefi/tables.zig +++ b/lib/std/os/uefi/tables.zig @@ -90,7 +90,7 @@ pub const MemoryType = enum(u32) { return @truncate(as_int - vendor_start); } - pub fn format(self: MemoryType, w: *std.io.Writer) std.io.WriteError!void { + pub fn format(self: MemoryType, w: *std.io.Writer) std.io.Writer.Error!void { if (self.toOem()) |oemval| try w.print("OEM({X})", .{oemval}) else if (self.toVendor()) |vendorval| diff --git a/lib/std/pie.zig b/lib/std/pie.zig index 09b875ca15..403c1e8f1a 100644 --- a/lib/std/pie.zig +++ b/lib/std/pie.zig @@ -177,7 +177,7 @@ inline fn getDynamicSymbol() [*]const elf.Dyn { \\ jg 2f \\ 1: .quad _DYNAMIC - . \\ 2: - : [ret] "=r" (-> [*]const elf.Dyn), + : [ret] "=a" (-> [*]const elf.Dyn), ), // The compiler does not necessarily have any obligation to load the `l7` register (pointing // to the GOT), so do it ourselves just in case. diff --git a/lib/std/posix.zig b/lib/std/posix.zig index 90ab157f0c..0b5a0e62b6 100644 --- a/lib/std/posix.zig +++ b/lib/std/posix.zig @@ -6387,14 +6387,16 @@ pub const CopyFileRangeError = error{ /// /// Maximum offsets on Linux and FreeBSD are `maxInt(i64)`. pub fn copy_file_range(fd_in: fd_t, off_in: u64, fd_out: fd_t, off_out: u64, len: usize, flags: u32) CopyFileRangeError!usize { - if (builtin.os.tag == .freebsd or - (comptime builtin.os.tag == .linux and std.c.versionCheck(if (builtin.abi.isAndroid()) .{ .major = 34, .minor = 0, .patch = 0 } else .{ .major = 2, .minor = 27, .patch = 0 }))) - { + if (builtin.os.tag == .freebsd or builtin.os.tag == .linux) { + const use_c = native_os != .linux or + std.c.versionCheck(if (builtin.abi.isAndroid()) .{ .major = 34, .minor = 0, .patch = 0 } else .{ .major = 2, .minor = 27, .patch = 0 }); + const sys = if (use_c) std.c else linux; + var off_in_copy: i64 = @bitCast(off_in); var off_out_copy: i64 = @bitCast(off_out); while (true) { - const rc = system.copy_file_range(fd_in, &off_in_copy, fd_out, &off_out_copy, len, flags); + const rc = sys.copy_file_range(fd_in, &off_in_copy, fd_out, &off_out_copy, len, flags); if (native_os == .freebsd) { switch (errno(rc)) { .SUCCESS => return @intCast(rc), diff --git a/lib/std/posix/test.zig b/lib/std/posix/test.zig index 55a53518d9..7577cd5400 100644 --- a/lib/std/posix/test.zig +++ b/lib/std/posix/test.zig @@ -883,7 +883,6 @@ test "sigrtmin/max" { try std.testing.expect(posix.sigrtmin() >= 32); try std.testing.expect(posix.sigrtmin() >= posix.system.sigrtmin()); try std.testing.expect(posix.sigrtmin() < posix.system.sigrtmax()); - try std.testing.expect(posix.sigrtmax() < posix.NSIG); } test "sigset empty/full" { diff --git a/lib/std/process.zig b/lib/std/process.zig index 2e9cb1fe85..efe0a9b0e9 100644 --- a/lib/std/process.zig +++ b/lib/std/process.zig @@ -1753,7 +1753,8 @@ pub fn totalSystemMemory() TotalSystemMemoryError!u64 { if (std.os.linux.E.init(result) != .SUCCESS) { return error.UnknownTotalSystemMemory; } - return info.totalram * info.mem_unit; + // Promote to u64 to avoid overflow on systems where info.totalram is a 32-bit usize + return @as(u64, info.totalram) * info.mem_unit; }, .freebsd => { var physmem: c_ulong = undefined; @@ -1762,7 +1763,20 @@ pub fn totalSystemMemory() TotalSystemMemoryError!u64 { error.NameTooLong, error.UnknownName => unreachable, else => return error.UnknownTotalSystemMemory, }; - return @as(usize, @intCast(physmem)); + return @as(u64, @intCast(physmem)); + }, + // whole Darwin family + .driverkit, .ios, .macos, .tvos, .visionos, .watchos => { + // "hw.memsize" returns uint64_t + var physmem: u64 = undefined; + var len: usize = @sizeOf(u64); + posix.sysctlbynameZ("hw.memsize", &physmem, &len, null, 0) catch |err| switch (err) { + error.PermissionDenied => unreachable, // only when setting values, + error.SystemResources => unreachable, // memory already on the stack + error.UnknownName => unreachable, // constant, known good value + else => return error.UnknownTotalSystemMemory, + }; + return physmem; }, .openbsd => { const mib: [2]c_int = [_]c_int{ diff --git a/lib/std/process/Child.zig b/lib/std/process/Child.zig index ca5e61b243..39dab9f394 100644 --- a/lib/std/process/Child.zig +++ b/lib/std/process/Child.zig @@ -52,6 +52,8 @@ term: ?(SpawnError!Term), argv: []const []const u8, /// Leave as null to use the current env map using the supplied allocator. +/// Required if unable to access the current env map (e.g. building a library on +/// some platforms). env_map: ?*const EnvMap, stdin_behavior: StdIo, @@ -414,6 +416,8 @@ pub fn run(args: struct { argv: []const []const u8, cwd: ?[]const u8 = null, cwd_dir: ?fs.Dir = null, + /// Required if unable to access the current env map (e.g. building a + /// library on some platforms). env_map: ?*const EnvMap = null, max_output_bytes: usize = 50 * 1024, expand_arg0: Arg0Expand = .no_expand, @@ -614,7 +618,7 @@ fn spawnPosix(self: *ChildProcess) SpawnError!void { })).ptr; } else { // TODO come up with a solution for this. - @compileError("missing std lib enhancement: ChildProcess implementation has no way to collect the environment variables to forward to the child process"); + @panic("missing std lib enhancement: ChildProcess implementation has no way to collect the environment variables to forward to the child process"); } }; diff --git a/lib/std/sort/pdq.zig b/lib/std/sort/pdq.zig index 55bd17ae93..e1f4f72136 100644 --- a/lib/std/sort/pdq.zig +++ b/lib/std/sort/pdq.zig @@ -227,7 +227,7 @@ fn partialInsertionSort(a: usize, b: usize, context: anytype) bool { // shift the smaller element to the left. if (i - a >= 2) { var j = i - 1; - while (j >= 1) : (j -= 1) { + while (j > a) : (j -= 1) { if (!context.lessThan(j, j - 1)) break; context.swap(j, j - 1); } @@ -328,3 +328,50 @@ fn reverseRange(a: usize, b: usize, context: anytype) void { j -= 1; } } + +test "pdqContext respects arbitrary range boundaries" { + // Regression test for issue #25250 + // pdqsort should never access indices outside the specified [a, b) range + var data: [2000]i32 = @splat(0); + + // Fill with data that triggers the partialInsertionSort path + for (0..data.len) |i| { + data[i] = @intCast(@mod(@as(i32, @intCast(i)) * 7, 100)); + } + + const TestContext = struct { + items: []i32, + range_start: usize, + range_end: usize, + + pub fn lessThan(ctx: @This(), a: usize, b: usize) bool { + // Assert indices are within the expected range + testing.expect(a >= ctx.range_start and a < ctx.range_end) catch @panic("index a out of range"); + testing.expect(b >= ctx.range_start and b < ctx.range_end) catch @panic("index b out of range"); + return ctx.items[a] < ctx.items[b]; + } + + pub fn swap(ctx: @This(), a: usize, b: usize) void { + // Assert indices are within the expected range + testing.expect(a >= ctx.range_start and a < ctx.range_end) catch @panic("index a out of range"); + testing.expect(b >= ctx.range_start and b < ctx.range_end) catch @panic("index b out of range"); + mem.swap(i32, &ctx.items[a], &ctx.items[b]); + } + }; + + // Test sorting a sub-range that doesn't start at 0 + const start = 1118; + const end = 1764; + const ctx = TestContext{ + .items = &data, + .range_start = start, + .range_end = end, + }; + + pdqContext(start, end, ctx); + + // Verify the range is sorted + for ((start + 1)..end) |i| { + try testing.expect(data[i - 1] <= data[i]); + } +} diff --git a/lib/std/testing.zig b/lib/std/testing.zig index e80e961b13..af2a0e3dc9 100644 --- a/lib/std/testing.zig +++ b/lib/std/testing.zig @@ -1249,3 +1249,63 @@ pub const Reader = struct { return n; } }; + +/// A `std.Io.Reader` that gets its data from another `std.Io.Reader`, and always +/// writes to its own buffer (and returns 0) during `stream` and `readVec`. +pub const ReaderIndirect = struct { + in: *std.Io.Reader, + interface: std.Io.Reader, + + pub fn init(in: *std.Io.Reader, buffer: []u8) ReaderIndirect { + return .{ + .in = in, + .interface = .{ + .vtable = &.{ + .stream = stream, + .readVec = readVec, + }, + .buffer = buffer, + .seek = 0, + .end = 0, + }, + }; + } + + fn readVec(r: *std.Io.Reader, _: [][]u8) std.Io.Reader.Error!usize { + try streamInner(r); + return 0; + } + + fn stream(r: *std.Io.Reader, _: *std.Io.Writer, _: std.Io.Limit) std.Io.Reader.StreamError!usize { + try streamInner(r); + return 0; + } + + fn streamInner(r: *std.Io.Reader) std.Io.Reader.Error!void { + const r_indirect: *ReaderIndirect = @alignCast(@fieldParentPtr("interface", r)); + + // If there's no room remaining in the buffer at all, make room. + if (r.buffer.len == r.end) { + try r.rebase(r.buffer.len); + } + + var writer: std.Io.Writer = .{ + .buffer = r.buffer, + .end = r.end, + .vtable = &.{ + .drain = std.Io.Writer.unreachableDrain, + .rebase = std.Io.Writer.unreachableRebase, + }, + }; + defer r.end = writer.end; + + r_indirect.in.streamExact(&writer, r.buffer.len - r.end) catch |err| switch (err) { + // Only forward EndOfStream if no new bytes were written to the buffer + error.EndOfStream => |e| if (r.end == writer.end) { + return e; + }, + error.WriteFailed => unreachable, + else => |e| return e, + }; + } +}; diff --git a/lib/std/zig/llvm/BitcodeReader.zig b/lib/std/zig/llvm/BitcodeReader.zig index e0d1632527..a876dcd2eb 100644 --- a/lib/std/zig/llvm/BitcodeReader.zig +++ b/lib/std/zig/llvm/BitcodeReader.zig @@ -154,7 +154,11 @@ pub fn next(bc: *BitcodeReader) !?Item { Abbrev.Builtin.enter_subblock.toRecordId() => { const block_id: u32 = @intCast(record.operands[0]); switch (block_id) { - Block.block_info => try bc.parseBlockInfoBlock(), + Block.block_info => { + try bc.startBlock(Block.block_info, @intCast(record.operands[1])); + try bc.parseBlockInfoBlock(); + try bc.endBlock(); + }, Block.first_reserved...Block.last_standard => return error.UnsupportedBlockId, else => { try bc.startBlock(block_id, @intCast(record.operands[1])); diff --git a/lib/std/zig/system.zig b/lib/std/zig/system.zig index ba43543ee2..0c6de34d5a 100644 --- a/lib/std/zig/system.zig +++ b/lib/std/zig/system.zig @@ -102,6 +102,7 @@ pub fn getExternalExecutor( else => "qemu-mips64el", }, }, + .or1k => Executor{ .qemu = "qemu-or1k" }, .powerpc => Executor{ .qemu = "qemu-ppc" }, .powerpc64 => Executor{ .qemu = "qemu-ppc64" }, .powerpc64le => Executor{ .qemu = "qemu-ppc64le" }, @@ -109,7 +110,7 @@ pub fn getExternalExecutor( .riscv64 => Executor{ .qemu = "qemu-riscv64" }, .s390x => Executor{ .qemu = "qemu-s390x" }, .sparc => Executor{ - .qemu = if (candidate.cpu.has(.sparc, .v9)) + .qemu = if (candidate.cpu.has(.sparc, .v8plus)) "qemu-sparc32plus" else "qemu-sparc", @@ -121,7 +122,7 @@ pub fn getExternalExecutor( else => Executor{ .qemu = "qemu-x86_64" }, }, .xtensa => Executor{ .qemu = "qemu-xtensa" }, - else => return bad_result, + else => bad_result, }; } diff --git a/lib/std/zig/system/linux.zig b/lib/std/zig/system/linux.zig index df70e71f5b..c0fe9a9ceb 100644 --- a/lib/std/zig/system/linux.zig +++ b/lib/std/zig/system/linux.zig @@ -358,14 +358,11 @@ fn CpuinfoParser(comptime impl: anytype) type { return struct { fn parse(arch: Target.Cpu.Arch, reader: *std.Io.Reader) !?Target.Cpu { var obj: impl = .{}; - while (reader.takeDelimiterExclusive('\n')) |line| { + while (try reader.takeDelimiter('\n')) |line| { const colon_pos = mem.indexOfScalar(u8, line, ':') orelse continue; const key = mem.trimEnd(u8, line[0..colon_pos], " \t"); const value = mem.trimStart(u8, line[colon_pos + 1 ..], " \t"); if (!try obj.line_hook(key, value)) break; - } else |err| switch (err) { - error.EndOfStream => {}, - else => |e| return e, } return obj.finalize(arch); } diff --git a/lib/std/zon/parse.zig b/lib/std/zon/parse.zig index 5f74400c29..313e30eb48 100644 --- a/lib/std/zon/parse.zig +++ b/lib/std/zon/parse.zig @@ -717,6 +717,7 @@ const Parser = struct { elem.* = try self.parseExpr(array_info.child, nodes.at(@intCast(i))); } + if (array_info.sentinel()) |s| result[result.len] = s; return result; } diff --git a/lib/ubsan_rt.zig b/lib/ubsan_rt.zig index 63f1d466cb..ffca7eff28 100644 --- a/lib/ubsan_rt.zig +++ b/lib/ubsan_rt.zig @@ -627,7 +627,7 @@ fn exportHandler( // Work around x86_64 backend limitation. const linkage = if (builtin.zig_backend == .stage2_x86_64 and builtin.os.tag == .windows) .internal else .weak; const N = "__ubsan_handle_" ++ sym_name; - @export(handler, .{ .name = N, .linkage = linkage }); + @export(handler, .{ .name = N, .linkage = linkage, .visibility = if (linkage == .internal) .default else .hidden }); } fn exportHandlerWithAbort( @@ -639,11 +639,11 @@ fn exportHandlerWithAbort( const linkage = if (builtin.zig_backend == .stage2_x86_64 and builtin.os.tag == .windows) .internal else .weak; { const N = "__ubsan_handle_" ++ sym_name; - @export(handler, .{ .name = N, .linkage = linkage }); + @export(handler, .{ .name = N, .linkage = linkage, .visibility = if (linkage == .internal) .default else .hidden }); } { const N = "__ubsan_handle_" ++ sym_name ++ "_abort"; - @export(abort_handler, .{ .name = N, .linkage = linkage }); + @export(abort_handler, .{ .name = N, .linkage = linkage, .visibility = if (linkage == .internal) .default else .hidden }); } } diff --git a/src/Compilation.zig b/src/Compilation.zig index 43f4e434d3..3752e93a0d 100644 --- a/src/Compilation.zig +++ b/src/Compilation.zig @@ -2053,7 +2053,14 @@ pub fn create(gpa: Allocator, arena: Allocator, diag: *CreateDiagnostic, options break :s .none; // only LLD can handle ubsan-rt for this target } else true, }; - if (have_zcu and (!need_llvm or use_llvm)) break :s .zcu; + if (have_zcu and (!need_llvm or use_llvm)) { + // ubsan-rt's exports use hidden visibility. If we're building a Windows DLL and + // exported functions are going to be dllexported, LLVM will complain that + // dllexported functions must use default or protected visibility. So we can't use + // the ZCU strategy in this case. + if (options.config.dll_export_fns) break :s .lib; + break :s .zcu; + } if (need_llvm and !build_options.have_llvm) break :s .none; // impossible to build without llvm if (is_exe_or_dyn_lib) break :s .lib; break :s .obj; @@ -3659,6 +3666,7 @@ const Header = extern struct { items_len: u32, extra_len: u32, limbs_len: u32, + strings_len: u32, string_bytes_len: u32, tracked_insts_len: u32, files_len: u32, @@ -3707,7 +3715,8 @@ pub fn saveState(comp: *Compilation) !void { .items_len = @intCast(local.mutate.items.len), .extra_len = @intCast(local.mutate.extra.len), .limbs_len = @intCast(local.mutate.limbs.len), - .string_bytes_len = @intCast(local.mutate.strings.len), + .strings_len = @intCast(local.mutate.strings.len), + .string_bytes_len = @intCast(local.mutate.string_bytes.len), .tracked_insts_len = @intCast(local.mutate.tracked_insts.len), .files_len = @intCast(local.mutate.files.len), }, @@ -3750,8 +3759,11 @@ pub fn saveState(comp: *Compilation) !void { addBuf(&bufs, @ptrCast(local.shared.items.view().items(.data)[0..pt_header.intern_pool.items_len])); addBuf(&bufs, @ptrCast(local.shared.items.view().items(.tag)[0..pt_header.intern_pool.items_len])); } + if (pt_header.intern_pool.strings_len > 0) { + addBuf(&bufs, @ptrCast(local.shared.strings.view().items(.@"0")[0..pt_header.intern_pool.strings_len])); + } if (pt_header.intern_pool.string_bytes_len > 0) { - addBuf(&bufs, local.shared.strings.view().items(.@"0")[0..pt_header.intern_pool.string_bytes_len]); + addBuf(&bufs, local.shared.string_bytes.view().items(.@"0")[0..pt_header.intern_pool.string_bytes_len]); } if (pt_header.intern_pool.tracked_insts_len > 0) { addBuf(&bufs, @ptrCast(local.shared.tracked_insts.view().items(.@"0")[0..pt_header.intern_pool.tracked_insts_len])); @@ -6836,10 +6848,6 @@ pub fn addCCArgs( try argv.append("-municode"); } - if (mod.code_model != .default) { - try argv.append(try std.fmt.allocPrint(arena, "-mcmodel={s}", .{@tagName(mod.code_model)})); - } - try argv.ensureUnusedCapacity(2); switch (comp.config.debug_format) { .strip => {}, @@ -7129,6 +7137,10 @@ pub fn addCCArgs( .ll, .bc, => { + if (mod.code_model != .default) { + try argv.append(try std.fmt.allocPrint(arena, "-mcmodel={s}", .{@tagName(mod.code_model)})); + } + if (target_util.clangSupportsTargetCpuArg(target)) { if (target.cpu.model.llvm_name) |llvm_name| { try argv.appendSlice(&[_][]const u8{ @@ -8086,7 +8098,7 @@ pub fn addLinkLib(comp: *Compilation, lib_name: []const u8) !void { /// compiler-rt, libcxx, libc, libunwind, etc. pub fn compilerRtOptMode(comp: Compilation) std.builtin.OptimizeMode { if (comp.debug_compiler_runtime_libs) { - return comp.root_mod.optimize_mode; + return .Debug; } const target = &comp.root_mod.resolved_target.result; switch (comp.root_mod.optimize_mode) { diff --git a/src/InternPool.zig b/src/InternPool.zig index 5f108e3224..fc6634d925 100644 --- a/src/InternPool.zig +++ b/src/InternPool.zig @@ -182,7 +182,7 @@ pub const TrackedInst = extern struct { pub fn wrap(unwrapped: Unwrapped, ip: *const InternPool) TrackedInst.Index { assert(@intFromEnum(unwrapped.tid) <= ip.getTidMask()); assert(unwrapped.index <= ip.getIndexMask(u32)); - return @enumFromInt(@as(u32, @intFromEnum(unwrapped.tid)) << ip.tid_shift_32 | + return @enumFromInt(@shlExact(@as(u32, @intFromEnum(unwrapped.tid)), ip.tid_shift_32) | unwrapped.index); } }; @@ -480,7 +480,7 @@ pub const ComptimeUnit = extern struct { fn wrap(unwrapped: Unwrapped, ip: *const InternPool) ComptimeUnit.Id { assert(@intFromEnum(unwrapped.tid) <= ip.getTidMask()); assert(unwrapped.index <= ip.getIndexMask(u32)); - return @enumFromInt(@as(u32, @intFromEnum(unwrapped.tid)) << ip.tid_shift_32 | + return @enumFromInt(@shlExact(@as(u32, @intFromEnum(unwrapped.tid)), ip.tid_shift_32) | unwrapped.index); } }; @@ -699,7 +699,7 @@ pub const Nav = struct { fn wrap(unwrapped: Unwrapped, ip: *const InternPool) Nav.Index { assert(@intFromEnum(unwrapped.tid) <= ip.getTidMask()); assert(unwrapped.index <= ip.getIndexMask(u32)); - return @enumFromInt(@as(u32, @intFromEnum(unwrapped.tid)) << ip.tid_shift_32 | + return @enumFromInt(@shlExact(@as(u32, @intFromEnum(unwrapped.tid)), ip.tid_shift_32) | unwrapped.index); } }; @@ -1047,6 +1047,7 @@ const Local = struct { extra: ListMutate, limbs: ListMutate, strings: ListMutate, + string_bytes: ListMutate, tracked_insts: ListMutate, files: ListMutate, maps: ListMutate, @@ -1061,6 +1062,7 @@ const Local = struct { extra: Extra, limbs: Limbs, strings: Strings, + string_bytes: StringBytes, tracked_insts: TrackedInsts, files: List(File), maps: Maps, @@ -1084,7 +1086,8 @@ const Local = struct { @sizeOf(u64) => List(struct { u64 }), else => @compileError("unsupported host"), }; - const Strings = List(struct { u8 }); + const Strings = List(struct { u32 }); + const StringBytes = List(struct { u8 }); const TrackedInsts = List(struct { TrackedInst.MaybeLost }); const Maps = List(struct { FieldMap }); const Navs = List(Nav.Repr); @@ -1414,11 +1417,7 @@ const Local = struct { }; } - /// In order to store references to strings in fewer bytes, we copy all - /// string bytes into here. String bytes can be null. It is up to whomever - /// is referencing the data here whether they want to store both index and length, - /// thus allowing null bytes, or store only index, and use null-termination. The - /// `strings` array is agnostic to either usage. + /// A list of offsets into `string_bytes` for each string. pub fn getMutableStrings(local: *Local, gpa: Allocator) Strings.Mutable { return .{ .gpa = gpa, @@ -1428,6 +1427,20 @@ const Local = struct { }; } + /// In order to store references to strings in fewer bytes, we copy all + /// string bytes into here. String bytes can be null. It is up to whomever + /// is referencing the data here whether they want to store both index and length, + /// thus allowing null bytes, or store only index, and use null-termination. The + /// `strings_bytes` array is agnostic to either usage. + pub fn getMutableStringBytes(local: *Local, gpa: Allocator) StringBytes.Mutable { + return .{ + .gpa = gpa, + .arena = &local.mutate.arena, + .mutate = &local.mutate.string_bytes, + .list = &local.shared.string_bytes, + }; + } + /// An index into `tracked_insts` gives a reference to a single ZIR instruction which /// persists across incremental updates. pub fn getMutableTrackedInsts(local: *Local, gpa: Allocator) TrackedInsts.Mutable { @@ -1597,7 +1610,7 @@ const Shard = struct { }; fn getTidMask(ip: *const InternPool) u32 { - return (@as(u32, 1) << ip.tid_width) - 1; + return @shlExact(@as(u32, 1), ip.tid_width) - 1; } fn getIndexMask(ip: *const InternPool, comptime BackingInt: type) u32 { @@ -1652,7 +1665,7 @@ pub const MapIndex = enum(u32) { fn wrap(unwrapped: Unwrapped, ip: *const InternPool) MapIndex { assert(@intFromEnum(unwrapped.tid) <= ip.getTidMask()); assert(unwrapped.index <= ip.getIndexMask(u32)); - return @enumFromInt(@as(u32, @intFromEnum(unwrapped.tid)) << ip.tid_shift_32 | + return @enumFromInt(@shlExact(@as(u32, @intFromEnum(unwrapped.tid)), ip.tid_shift_32) | unwrapped.index); } }; @@ -1678,7 +1691,7 @@ pub const NamespaceIndex = enum(u32) { assert(@intFromEnum(unwrapped.tid) <= ip.getTidMask()); assert(unwrapped.bucket_index <= ip.getIndexMask(u32) >> Local.namespaces_bucket_width); assert(unwrapped.index <= Local.namespaces_bucket_mask); - return @enumFromInt(@as(u32, @intFromEnum(unwrapped.tid)) << ip.tid_shift_32 | + return @enumFromInt(@shlExact(@as(u32, @intFromEnum(unwrapped.tid)), ip.tid_shift_32) | unwrapped.bucket_index << Local.namespaces_bucket_width | unwrapped.index); } @@ -1721,7 +1734,7 @@ pub const FileIndex = enum(u32) { fn wrap(unwrapped: Unwrapped, ip: *const InternPool) FileIndex { assert(@intFromEnum(unwrapped.tid) <= ip.getTidMask()); assert(unwrapped.index <= ip.getIndexMask(u32)); - return @enumFromInt(@as(u32, @intFromEnum(unwrapped.tid)) << ip.tid_shift_32 | + return @enumFromInt(@shlExact(@as(u32, @intFromEnum(unwrapped.tid)), ip.tid_shift_32) | unwrapped.index); } }; @@ -1780,7 +1793,8 @@ pub const String = enum(u32) { fn wrap(unwrapped: Unwrapped, ip: *const InternPool) String { assert(@intFromEnum(unwrapped.tid) <= ip.getTidMask()); assert(unwrapped.index <= ip.getIndexMask(u32)); - return @enumFromInt(@as(u32, @intFromEnum(unwrapped.tid)) << ip.tid_shift_32 | unwrapped.index); + return @enumFromInt(@shlExact(@as(u32, @intFromEnum(unwrapped.tid)), ip.tid_shift_32) | + unwrapped.index); } }; fn unwrap(string: String, ip: *const InternPool) Unwrapped { @@ -1791,9 +1805,11 @@ pub const String = enum(u32) { } fn toOverlongSlice(string: String, ip: *const InternPool) []const u8 { - const unwrapped_string = string.unwrap(ip); - const strings = ip.getLocalShared(unwrapped_string.tid).strings.acquire(); - return strings.view().items(.@"0")[unwrapped_string.index..]; + const unwrapped = string.unwrap(ip); + const local_shared = ip.getLocalShared(unwrapped.tid); + const strings = local_shared.strings.acquire().view().items(.@"0"); + const string_bytes = local_shared.string_bytes.acquire().view().items(.@"0"); + return string_bytes[strings[unwrapped.index]..]; } const debug_state = InternPool.debug_state; @@ -1848,12 +1864,18 @@ pub const NullTerminatedString = enum(u32) { } pub fn toSlice(string: NullTerminatedString, ip: *const InternPool) [:0]const u8 { - const overlong_slice = string.toString().toOverlongSlice(ip); - return overlong_slice[0..std.mem.indexOfScalar(u8, overlong_slice, 0).? :0]; + const unwrapped = string.toString().unwrap(ip); + const local_shared = ip.getLocalShared(unwrapped.tid); + const strings = local_shared.strings.acquire().view().items(.@"0"); + const string_bytes = local_shared.string_bytes.acquire().view().items(.@"0"); + return string_bytes[strings[unwrapped.index] .. strings[unwrapped.index + 1] - 1 :0]; } pub fn length(string: NullTerminatedString, ip: *const InternPool) u32 { - return @intCast(string.toSlice(ip).len); + const unwrapped = string.toString().unwrap(ip); + const local_shared = ip.getLocalShared(unwrapped.tid); + const strings = local_shared.strings.acquire().view().items(.@"0"); + return strings[unwrapped.index + 1] - 1 - strings[unwrapped.index]; } pub fn eqlSlice(string: NullTerminatedString, slice: []const u8, ip: *const InternPool) bool { @@ -4767,7 +4789,8 @@ pub const Index = enum(u32) { fn wrap(unwrapped: Unwrapped, ip: *const InternPool) Index { assert(@intFromEnum(unwrapped.tid) <= ip.getTidMask()); assert(unwrapped.index <= ip.getIndexMask(u30)); - return @enumFromInt(@as(u32, @intFromEnum(unwrapped.tid)) << ip.tid_shift_30 | unwrapped.index); + return @enumFromInt(@shlExact(@as(u32, @intFromEnum(unwrapped.tid)), ip.tid_shift_30) | + unwrapped.index); } pub fn getExtra(unwrapped: Unwrapped, ip: *const InternPool) Local.Extra { @@ -6784,6 +6807,7 @@ pub fn init(ip: *InternPool, gpa: Allocator, available_threads: usize) !void { .extra = .empty, .limbs = .empty, .strings = .empty, + .string_bytes = .empty, .tracked_insts = .empty, .files = .empty, .maps = .empty, @@ -6799,6 +6823,7 @@ pub fn init(ip: *InternPool, gpa: Allocator, available_threads: usize) !void { .extra = .empty, .limbs = .empty, .strings = .empty, + .string_bytes = .empty, .tracked_insts = .empty, .files = .empty, .maps = .empty, @@ -6808,6 +6833,7 @@ pub fn init(ip: *InternPool, gpa: Allocator, available_threads: usize) !void { .namespaces = .empty, }, }); + for (ip.locals) |*local| try local.getMutableStrings(gpa).append(.{0}); ip.tid_width = @intCast(std.math.log2_int_ceil(usize, used_threads)); ip.tid_shift_30 = if (single_threaded) 0 else 30 - ip.tid_width; @@ -8515,30 +8541,30 @@ pub fn get(ip: *InternPool, gpa: Allocator, tid: Zcu.PerThread.Id, key: Key) All } if (child == .u8_type) bytes: { - const strings = ip.getLocal(tid).getMutableStrings(gpa); - const start = strings.mutate.len; - try strings.ensureUnusedCapacity(@intCast(len_including_sentinel + 1)); + const string_bytes = ip.getLocal(tid).getMutableStringBytes(gpa); + const start = string_bytes.mutate.len; + try string_bytes.ensureUnusedCapacity(@intCast(len_including_sentinel + 1)); try extra.ensureUnusedCapacity(@typeInfo(Bytes).@"struct".fields.len); switch (aggregate.storage) { - .bytes => |bytes| strings.appendSliceAssumeCapacity(.{bytes.toSlice(len, ip)}), + .bytes => |bytes| string_bytes.appendSliceAssumeCapacity(.{bytes.toSlice(len, ip)}), .elems => |elems| for (elems[0..@intCast(len)]) |elem| switch (ip.indexToKey(elem)) { .undef => { - strings.shrinkRetainingCapacity(start); + string_bytes.shrinkRetainingCapacity(start); break :bytes; }, - .int => |int| strings.appendAssumeCapacity(.{@intCast(int.storage.u64)}), + .int => |int| string_bytes.appendAssumeCapacity(.{@intCast(int.storage.u64)}), else => unreachable, }, .repeated_elem => |elem| switch (ip.indexToKey(elem)) { .undef => break :bytes, .int => |int| @memset( - strings.addManyAsSliceAssumeCapacity(@intCast(len))[0], + string_bytes.addManyAsSliceAssumeCapacity(@intCast(len))[0], @intCast(int.storage.u64), ), else => unreachable, }, } - if (sentinel != .none) strings.appendAssumeCapacity(.{ + if (sentinel != .none) string_bytes.appendAssumeCapacity(.{ @intCast(ip.indexToKey(sentinel).int.storage.u64), }); const string = try ip.getOrPutTrailingString( @@ -11754,10 +11780,10 @@ pub fn getOrPutString( slice: []const u8, comptime embedded_nulls: EmbeddedNulls, ) Allocator.Error!embedded_nulls.StringType() { - const strings = ip.getLocal(tid).getMutableStrings(gpa); - try strings.ensureUnusedCapacity(slice.len + 1); - strings.appendSliceAssumeCapacity(.{slice}); - strings.appendAssumeCapacity(.{0}); + const string_bytes = ip.getLocal(tid).getMutableStringBytes(gpa); + try string_bytes.ensureUnusedCapacity(slice.len + 1); + string_bytes.appendSliceAssumeCapacity(.{slice}); + string_bytes.appendAssumeCapacity(.{0}); return ip.getOrPutTrailingString(gpa, tid, @intCast(slice.len + 1), embedded_nulls); } @@ -11772,8 +11798,8 @@ pub fn getOrPutStringFmt( // ensure that references to strings in args do not get invalidated const format_z = format ++ .{0}; const len: u32 = @intCast(std.fmt.count(format_z, args)); - const strings = ip.getLocal(tid).getMutableStrings(gpa); - const slice = try strings.addManyAsSlice(len); + const string_bytes = ip.getLocal(tid).getMutableStringBytes(gpa); + const slice = try string_bytes.addManyAsSlice(len); assert((std.fmt.bufPrint(slice[0], format_z, args) catch unreachable).len == len); return ip.getOrPutTrailingString(gpa, tid, len, embedded_nulls); } @@ -11797,21 +11823,27 @@ pub fn getOrPutTrailingString( len: u32, comptime embedded_nulls: EmbeddedNulls, ) Allocator.Error!embedded_nulls.StringType() { - const strings = ip.getLocal(tid).getMutableStrings(gpa); - const start: u32 = @intCast(strings.mutate.len - len); - if (len > 0 and strings.view().items(.@"0")[strings.mutate.len - 1] == 0) { - strings.mutate.len -= 1; + const local = ip.getLocal(tid); + const strings = local.getMutableStrings(gpa); + try strings.ensureUnusedCapacity(1); + const string_bytes = local.getMutableStringBytes(gpa); + const start: u32 = @intCast(string_bytes.mutate.len - len); + if (len > 0 and string_bytes.view().items(.@"0")[string_bytes.mutate.len - 1] == 0) { + string_bytes.mutate.len -= 1; } else { - try strings.ensureUnusedCapacity(1); + try string_bytes.ensureUnusedCapacity(1); } - const key: []const u8 = strings.view().items(.@"0")[start..]; - const value: embedded_nulls.StringType() = - @enumFromInt(@intFromEnum((String.Unwrapped{ .tid = tid, .index = start }).wrap(ip))); + const key: []const u8 = string_bytes.view().items(.@"0")[start..]; + const value: embedded_nulls.StringType() = @enumFromInt(@intFromEnum((String.Unwrapped{ + .tid = tid, + .index = strings.mutate.len - 1, + }).wrap(ip))); const has_embedded_null = std.mem.indexOfScalar(u8, key, 0) != null; switch (embedded_nulls) { .no_embedded_nulls => assert(!has_embedded_null), .maybe_embedded_nulls => if (has_embedded_null) { - strings.appendAssumeCapacity(.{0}); + string_bytes.appendAssumeCapacity(.{0}); + strings.appendAssumeCapacity(.{string_bytes.mutate.len}); return value; }, } @@ -11829,7 +11861,7 @@ pub fn getOrPutTrailingString( const index = entry.acquire().unwrap() orelse break; if (entry.hash != hash) continue; if (!index.eqlSlice(key, ip)) continue; - strings.shrinkRetainingCapacity(start); + string_bytes.shrinkRetainingCapacity(start); return @enumFromInt(@intFromEnum(index)); } shard.mutate.string_map.mutex.lock(); @@ -11845,19 +11877,20 @@ pub fn getOrPutTrailingString( const index = entry.acquire().unwrap() orelse break; if (entry.hash != hash) continue; if (!index.eqlSlice(key, ip)) continue; - strings.shrinkRetainingCapacity(start); + string_bytes.shrinkRetainingCapacity(start); return @enumFromInt(@intFromEnum(index)); } defer shard.mutate.string_map.len += 1; const map_header = map.header().*; if (shard.mutate.string_map.len < map_header.capacity * 3 / 5) { - strings.appendAssumeCapacity(.{0}); + string_bytes.appendAssumeCapacity(.{0}); + strings.appendAssumeCapacity(.{string_bytes.mutate.len}); const entry = &map.entries[map_index]; entry.hash = hash; entry.release(@enumFromInt(@intFromEnum(value))); return value; } - const arena_state = &ip.getLocal(tid).mutate.arena; + const arena_state = &local.mutate.arena; var arena = arena_state.promote(gpa); defer arena_state.* = arena.state; const new_map_capacity = map_header.capacity * 2; @@ -11893,7 +11926,8 @@ pub fn getOrPutTrailingString( map_index &= new_map_mask; if (map.entries[map_index].value == .none) break; } - strings.appendAssumeCapacity(.{0}); + string_bytes.appendAssumeCapacity(.{0}); + strings.appendAssumeCapacity(.{string_bytes.mutate.len}); map.entries[map_index] = .{ .value = @enumFromInt(@intFromEnum(value)), .hash = hash, diff --git a/src/Package/Fetch.zig b/src/Package/Fetch.zig index bf77f88e93..3d2cc4cfb8 100644 --- a/src/Package/Fetch.zig +++ b/src/Package/Fetch.zig @@ -735,28 +735,34 @@ fn queueJobsForDeps(f: *Fetch) RunError!void { // calling run(); no need to add it again. // // If we add a dep as lazy and then later try to add the same dep as eager, - // eagerness takes precedence and the existing entry is updated. + // eagerness takes precedence and the existing entry is updated and re-scheduled + // for fetching. for (dep_names, deps) |dep_name, dep| { + var promoted_existing_to_eager = false; const new_fetch = &new_fetches[new_fetch_index]; const location: Location = switch (dep.location) { - .url => |url| .{ .remote = .{ - .url = url, - .hash = h: { - const h = dep.hash orelse break :h null; - const pkg_hash: Package.Hash = .fromSlice(h); - if (h.len == 0) break :h pkg_hash; - const gop = f.job_queue.table.getOrPutAssumeCapacity(pkg_hash); - if (gop.found_existing) { - if (!dep.lazy) { - gop.value_ptr.*.lazy_status = .eager; + .url => |url| .{ + .remote = .{ + .url = url, + .hash = h: { + const h = dep.hash orelse break :h null; + const pkg_hash: Package.Hash = .fromSlice(h); + if (h.len == 0) break :h pkg_hash; + const gop = f.job_queue.table.getOrPutAssumeCapacity(pkg_hash); + if (gop.found_existing) { + if (!dep.lazy and gop.value_ptr.*.lazy_status != .eager) { + gop.value_ptr.*.lazy_status = .eager; + promoted_existing_to_eager = true; + } else { + continue; + } } - continue; - } - gop.value_ptr.* = new_fetch; - break :h pkg_hash; + gop.value_ptr.* = new_fetch; + break :h pkg_hash; + }, }, - } }, + }, .path => |rel_path| l: { // This might produce an invalid path, which is checked for // at the beginning of run(). @@ -764,10 +770,12 @@ fn queueJobsForDeps(f: *Fetch) RunError!void { const pkg_hash = relativePathDigest(new_root, cache_root); const gop = f.job_queue.table.getOrPutAssumeCapacity(pkg_hash); if (gop.found_existing) { - if (!dep.lazy) { + if (!dep.lazy and gop.value_ptr.*.lazy_status != .eager) { gop.value_ptr.*.lazy_status = .eager; + promoted_existing_to_eager = true; + } else { + continue; } - continue; } gop.value_ptr.* = new_fetch; break :l .{ .relative_path = new_root }; @@ -775,7 +783,9 @@ fn queueJobsForDeps(f: *Fetch) RunError!void { }; prog_names[new_fetch_index] = dep_name; new_fetch_index += 1; - f.job_queue.all_fetches.appendAssumeCapacity(new_fetch); + if (!promoted_existing_to_eager) { + f.job_queue.all_fetches.appendAssumeCapacity(new_fetch); + } new_fetch.* = .{ .arena = std.heap.ArenaAllocator.init(gpa), .location = location, diff --git a/src/Sema.zig b/src/Sema.zig index 4d05441a83..2da8f18c31 100644 --- a/src/Sema.zig +++ b/src/Sema.zig @@ -4375,8 +4375,9 @@ fn zirResolveInferredAlloc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Com if (zcu.intern_pool.isFuncBody(val)) { const ty: Type = .fromInterned(zcu.intern_pool.typeOf(val)); if (try ty.fnHasRuntimeBitsSema(pt)) { - try sema.addReferenceEntry(block, src, AnalUnit.wrap(.{ .func = val })); - try zcu.ensureFuncBodyAnalysisQueued(val); + const orig_fn_index = zcu.intern_pool.unwrapCoercedFunc(val); + try sema.addReferenceEntry(block, src, .wrap(.{ .func = orig_fn_index })); + try zcu.ensureFuncBodyAnalysisQueued(orig_fn_index); } } @@ -5588,16 +5589,21 @@ fn zirPanic(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void } try sema.ensureMemoizedStateResolved(src, .panic); - try zcu.ensureFuncBodyAnalysisQueued(zcu.builtin_decl_values.get(.@"panic.call")); - - const panic_fn = Air.internedToRef(zcu.builtin_decl_values.get(.@"panic.call")); - + const panic_fn_index = zcu.builtin_decl_values.get(.@"panic.call"); const opt_usize_ty = try pt.optionalType(.usize_type); const null_ret_addr = Air.internedToRef((try pt.intern(.{ .opt = .{ .ty = opt_usize_ty.toIntern(), .val = .none, } }))); - try sema.callBuiltin(block, src, panic_fn, .auto, &.{ coerced_msg, null_ret_addr }, .@"@panic"); + // `callBuiltin` also calls `addReferenceEntry` to the function body for us. + try sema.callBuiltin( + block, + src, + .fromIntern(panic_fn_index), + .auto, + &.{ coerced_msg, null_ret_addr }, + .@"@panic", + ); } fn zirTrap(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void { @@ -7566,8 +7572,9 @@ fn analyzeCall( ref_func: { const runtime_func_val = try sema.resolveValue(runtime_func) orelse break :ref_func; if (!ip.isFuncBody(runtime_func_val.toIntern())) break :ref_func; - try sema.addReferenceEntry(block, call_src, .wrap(.{ .func = runtime_func_val.toIntern() })); - try zcu.ensureFuncBodyAnalysisQueued(runtime_func_val.toIntern()); + const orig_fn_index = ip.unwrapCoercedFunc(runtime_func_val.toIntern()); + try sema.addReferenceEntry(block, call_src, .wrap(.{ .func = orig_fn_index })); + try zcu.ensureFuncBodyAnalysisQueued(orig_fn_index); } const call_tag: Air.Inst.Tag = switch (modifier) { @@ -25292,7 +25299,6 @@ fn zirMemset(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void const elem = try sema.coerce(block, dest_elem_ty, uncoerced_elem, value_src); const runtime_src = rs: { - const ptr_val = try sema.resolveDefinedValue(block, dest_src, dest_ptr) orelse break :rs dest_src; const len_air_ref = try sema.fieldVal(block, src, dest_ptr, try ip.getOrPutString(gpa, pt.tid, "len", .no_embedded_nulls), dest_src); const len_val = (try sema.resolveDefinedValue(block, dest_src, len_air_ref)) orelse break :rs dest_src; const len_u64 = try len_val.toUnsignedIntSema(pt); @@ -25302,6 +25308,7 @@ fn zirMemset(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void return; } + const ptr_val = try sema.resolveDefinedValue(block, dest_src, dest_ptr) orelse break :rs dest_src; if (!sema.isComptimeMutablePtr(ptr_val)) break :rs dest_src; const elem_val = try sema.resolveValue(elem) orelse break :rs value_src; const array_ty = try pt.arrayType(.{ @@ -26360,23 +26367,27 @@ fn explainWhyTypeIsNotPacked( /// instructions. This function ensures the panic function will be available to /// be called during that time. fn preparePanicId(sema: *Sema, src: LazySrcLoc, panic_id: Zcu.SimplePanicId) !void { + const zcu = sema.pt.zcu; + // If the backend doesn't support `.panic_fn`, it doesn't want us to lower the panic handlers. // The backend will transform panics into traps instead. - if (sema.pt.zcu.backendSupportsFeature(.panic_fn)) { - _ = try sema.getPanicIdFunc(src, panic_id); - } + if (!zcu.backendSupportsFeature(.panic_fn)) return; + + const fn_index = try sema.getPanicIdFunc(src, panic_id); + const orig_fn_index = zcu.intern_pool.unwrapCoercedFunc(fn_index); + try sema.addReferenceEntry(null, src, .wrap(.{ .func = orig_fn_index })); + try zcu.ensureFuncBodyAnalysisQueued(orig_fn_index); } fn getPanicIdFunc(sema: *Sema, src: LazySrcLoc, panic_id: Zcu.SimplePanicId) !InternPool.Index { const zcu = sema.pt.zcu; try sema.ensureMemoizedStateResolved(src, .panic); - const panic_func = zcu.builtin_decl_values.get(panic_id.toBuiltin()); - try zcu.ensureFuncBodyAnalysisQueued(panic_func); + const panic_fn_index = zcu.builtin_decl_values.get(panic_id.toBuiltin()); switch (sema.owner.unwrap()) { .@"comptime", .nav_ty, .nav_val, .type, .memoized_state => {}, .func => |owner_func| zcu.intern_pool.funcSetHasErrorTrace(owner_func, true), } - return panic_func; + return panic_fn_index; } fn addSafetyCheck( @@ -31164,6 +31175,11 @@ fn addReferenceEntry( referenced_unit: AnalUnit, ) !void { const zcu = sema.pt.zcu; + const ip = &zcu.intern_pool; + switch (referenced_unit.unwrap()) { + .func => |f| assert(ip.unwrapCoercedFunc(f) == f), // for `.{ .func = f }`, `f` must be uncoerced + else => {}, + } if (!zcu.comp.incremental and zcu.comp.reference_trace == 0) return; const gop = try sema.references.getOrPut(sema.gpa, referenced_unit); if (gop.found_existing) return; @@ -31350,8 +31366,9 @@ fn maybeQueueFuncBodyAnalysis(sema: *Sema, block: *Block, src: LazySrcLoc, nav_i const nav_val = zcu.navValue(nav_index); if (!ip.isFuncBody(nav_val.toIntern())) return; - try sema.addReferenceEntry(block, src, AnalUnit.wrap(.{ .func = nav_val.toIntern() })); - try zcu.ensureFuncBodyAnalysisQueued(nav_val.toIntern()); + const orig_fn_index = ip.unwrapCoercedFunc(nav_val.toIntern()); + try sema.addReferenceEntry(block, src, .wrap(.{ .func = orig_fn_index })); + try zcu.ensureFuncBodyAnalysisQueued(orig_fn_index); } fn analyzeRef( @@ -34958,7 +34975,7 @@ fn resolveInferredErrorSet( const resolved_ty = func.resolvedErrorSetUnordered(ip); if (resolved_ty != .none) return resolved_ty; - if (zcu.analysis_in_progress.contains(AnalUnit.wrap(.{ .func = func_index }))) { + if (zcu.analysis_in_progress.contains(.wrap(.{ .func = func_index }))) { return sema.fail(block, src, "unable to resolve inferred error set", .{}); } @@ -34984,8 +35001,9 @@ fn resolveInferredErrorSet( } // In this case we are dealing with the actual InferredErrorSet object that // corresponds to the function, not one created to track an inline/comptime call. - try sema.addReferenceEntry(block, src, AnalUnit.wrap(.{ .func = func_index })); - try pt.ensureFuncBodyUpToDate(func_index); + const orig_func_index = ip.unwrapCoercedFunc(func_index); + try sema.addReferenceEntry(block, src, .wrap(.{ .func = orig_func_index })); + try pt.ensureFuncBodyUpToDate(orig_func_index); } // This will now have been resolved by the logic at the end of `Zcu.analyzeFnBody` diff --git a/src/Type.zig b/src/Type.zig index f8f13ada44..3ef95b285c 100644 --- a/src/Type.zig +++ b/src/Type.zig @@ -3914,15 +3914,17 @@ pub fn getUnionLayout(loaded_union: InternPool.LoadedUnionType, zcu: *const Zcu) explicit_align else field_ty.abiAlignment(zcu); - const field_size = field_ty.abiSize(zcu); - if (field_size > payload_size) { - payload_size = field_size; - biggest_field = @intCast(field_index); - } - if (field_size > 0 and field_align.compare(.gte, most_aligned_field_align)) { - most_aligned_field = @intCast(field_index); - most_aligned_field_align = field_align; - most_aligned_field_size = field_size; + if (field_ty.hasRuntimeBits(zcu)) { + const field_size = field_ty.abiSize(zcu); + if (field_size > payload_size) { + payload_size = field_size; + biggest_field = @intCast(field_index); + } + if (field_size > 0 and field_align.compare(.gte, most_aligned_field_align)) { + most_aligned_field = @intCast(field_index); + most_aligned_field_align = field_align; + most_aligned_field_size = field_size; + } } payload_align = payload_align.max(field_align); } diff --git a/src/Value.zig b/src/Value.zig index d2e6c9f1ac..b4330705db 100644 --- a/src/Value.zig +++ b/src/Value.zig @@ -66,8 +66,8 @@ pub fn toIpString(val: Value, ty: Type, pt: Zcu.PerThread) !InternPool.NullTermi .repeated_elem => |elem| { const byte: u8 = @intCast(Value.fromInterned(elem).toUnsignedInt(zcu)); const len: u32 = @intCast(ty.arrayLen(zcu)); - const strings = ip.getLocal(pt.tid).getMutableStrings(zcu.gpa); - try strings.appendNTimes(.{byte}, len); + const string_bytes = ip.getLocal(pt.tid).getMutableStringBytes(zcu.gpa); + try string_bytes.appendNTimes(.{byte}, len); return ip.getOrPutTrailingString(zcu.gpa, pt.tid, len, .no_embedded_nulls); }, } @@ -109,16 +109,16 @@ fn arrayToIpString(val: Value, len_u64: u64, pt: Zcu.PerThread) !InternPool.Null const gpa = zcu.gpa; const ip = &zcu.intern_pool; const len: u32 = @intCast(len_u64); - const strings = ip.getLocal(pt.tid).getMutableStrings(gpa); - try strings.ensureUnusedCapacity(len); + const string_bytes = ip.getLocal(pt.tid).getMutableStringBytes(gpa); + try string_bytes.ensureUnusedCapacity(len); for (0..len) |i| { // I don't think elemValue has the possibility to affect ip.string_bytes. Let's // assert just to be sure. - const prev_len = strings.mutate.len; + const prev_len = string_bytes.mutate.len; const elem_val = try val.elemValue(pt, i); - assert(strings.mutate.len == prev_len); + assert(string_bytes.mutate.len == prev_len); const byte: u8 = @intCast(elem_val.toUnsignedInt(zcu)); - strings.appendAssumeCapacity(.{byte}); + string_bytes.appendAssumeCapacity(.{byte}); } return ip.getOrPutTrailingString(gpa, pt.tid, len, .no_embedded_nulls); } @@ -2149,15 +2149,18 @@ pub fn makeBool(x: bool) Value { return if (x) .true else .false; } -/// `parent_ptr` must be a single-pointer to some optional. +/// `parent_ptr` must be a single-pointer or C pointer to some optional. +/// /// Returns a pointer to the payload of the optional. +/// /// May perform type resolution. pub fn ptrOptPayload(parent_ptr: Value, pt: Zcu.PerThread) !Value { const zcu = pt.zcu; const parent_ptr_ty = parent_ptr.typeOf(zcu); const opt_ty = parent_ptr_ty.childType(zcu); + const ptr_size = parent_ptr_ty.ptrSize(zcu); - assert(parent_ptr_ty.ptrSize(zcu) == .one); + assert(ptr_size == .one or ptr_size == .c); assert(opt_ty.zigTypeTag(zcu) == .optional); const result_ty = try pt.ptrTypeSema(info: { @@ -2212,9 +2215,12 @@ pub fn ptrEuPayload(parent_ptr: Value, pt: Zcu.PerThread) !Value { } })); } -/// `parent_ptr` must be a single-pointer to a struct, union, or slice. +/// `parent_ptr` must be a single-pointer or c pointer to a struct, union, or slice. +/// /// Returns a pointer to the aggregate field at the specified index. +/// /// For slices, uses `slice_ptr_index` and `slice_len_index`. +/// /// May perform type resolution. pub fn ptrField(parent_ptr: Value, field_idx: u32, pt: Zcu.PerThread) !Value { const zcu = pt.zcu; @@ -2222,7 +2228,7 @@ pub fn ptrField(parent_ptr: Value, field_idx: u32, pt: Zcu.PerThread) !Value { const aggregate_ty = parent_ptr_ty.childType(zcu); const parent_ptr_info = parent_ptr_ty.ptrInfo(zcu); - assert(parent_ptr_info.flags.size == .one); + assert(parent_ptr_info.flags.size == .one or parent_ptr_info.flags.size == .c); // Exiting this `switch` indicates that the `field` pointer representation should be used. // `field_align` may be `.none` to represent the natural alignment of `field_ty`, but is not necessarily. diff --git a/src/Zcu.zig b/src/Zcu.zig index 53da90a9c2..d26417c8f7 100644 --- a/src/Zcu.zig +++ b/src/Zcu.zig @@ -1116,8 +1116,8 @@ pub const File = struct { pub fn internFullyQualifiedName(file: File, pt: Zcu.PerThread) !InternPool.NullTerminatedString { const gpa = pt.zcu.gpa; const ip = &pt.zcu.intern_pool; - const strings = ip.getLocal(pt.tid).getMutableStrings(gpa); - var w: Writer = .fixed((try strings.addManyAsSlice(file.fullyQualifiedNameLen()))[0]); + const string_bytes = ip.getLocal(pt.tid).getMutableStringBytes(gpa); + var w: Writer = .fixed((try string_bytes.addManyAsSlice(file.fullyQualifiedNameLen()))[0]); file.renderFullyQualifiedName(&w) catch unreachable; assert(w.end == w.buffer.len); return ip.getOrPutTrailingString(gpa, pt.tid, @intCast(w.end), .no_embedded_nulls); @@ -3451,8 +3451,11 @@ pub fn mapOldZirToNew( /// will be analyzed when it returns: for that, see `ensureFuncBodyAnalyzed`. pub fn ensureFuncBodyAnalysisQueued(zcu: *Zcu, func_index: InternPool.Index) !void { const ip = &zcu.intern_pool; + const func = zcu.funcInfo(func_index); + assert(func.ty == func.uncoerced_ty); // analyze the body of the original function, not a coerced one + if (zcu.func_body_analysis_queued.contains(func_index)) return; if (func.analysisUnordered(ip).is_analyzed) { diff --git a/src/Zcu/PerThread.zig b/src/Zcu/PerThread.zig index 3c2bb27dab..a4024be07a 100644 --- a/src/Zcu/PerThread.zig +++ b/src/Zcu/PerThread.zig @@ -700,7 +700,7 @@ fn analyzeMemoizedState(pt: Zcu.PerThread, stage: InternPool.MemoizedStateStage) const unit: AnalUnit = .wrap(.{ .memoized_state = stage }); - try zcu.analysis_in_progress.put(gpa, unit, {}); + try zcu.analysis_in_progress.putNoClobber(gpa, unit, {}); defer assert(zcu.analysis_in_progress.swapRemove(unit)); // Before we begin, collect: @@ -864,7 +864,7 @@ fn analyzeComptimeUnit(pt: Zcu.PerThread, cu_id: InternPool.ComptimeUnit.Id) Zcu const file = zcu.fileByIndex(inst_resolved.file); const zir = file.zir.?; - try zcu.analysis_in_progress.put(gpa, anal_unit, {}); + try zcu.analysis_in_progress.putNoClobber(gpa, anal_unit, {}); defer assert(zcu.analysis_in_progress.swapRemove(anal_unit)); var analysis_arena: std.heap.ArenaAllocator = .init(gpa); @@ -958,6 +958,8 @@ pub fn ensureNavValUpToDate(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu log.debug("ensureNavValUpToDate {f}", .{zcu.fmtAnalUnit(anal_unit)}); + assert(!zcu.analysis_in_progress.contains(anal_unit)); + // Determine whether or not this `Nav`'s value is outdated. This also includes checking if the // status is `.unresolved`, which indicates that the value is outdated because it has *never* // been analyzed so far. @@ -1090,10 +1092,19 @@ fn analyzeNavVal(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.CompileErr const inst_resolved = old_nav.analysis.?.zir_index.resolveFull(ip) orelse return error.AnalysisFail; const file = zcu.fileByIndex(inst_resolved.file); const zir = file.zir.?; + const zir_decl = zir.getDeclaration(inst_resolved.inst); - try zcu.analysis_in_progress.put(gpa, anal_unit, {}); + try zcu.analysis_in_progress.putNoClobber(gpa, anal_unit, {}); errdefer _ = zcu.analysis_in_progress.swapRemove(anal_unit); + // If there's no type body, we are also resolving the type here. + if (zir_decl.type_body == null) { + try zcu.analysis_in_progress.putNoClobber(gpa, .wrap(.{ .nav_ty = nav_id }), {}); + } + errdefer if (zir_decl.type_body == null) { + _ = zcu.analysis_in_progress.swapRemove(.wrap(.{ .nav_ty = nav_id })); + }; + var analysis_arena: std.heap.ArenaAllocator = .init(gpa); defer analysis_arena.deinit(); @@ -1133,8 +1144,6 @@ fn analyzeNavVal(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.CompileErr }; defer block.instructions.deinit(gpa); - const zir_decl = zir.getDeclaration(inst_resolved.inst); - const ty_src = block.src(.{ .node_offset_var_decl_ty = .zero }); const init_src = block.src(.{ .node_offset_var_decl_init = .zero }); const align_src = block.src(.{ .node_offset_var_decl_align = .zero }); @@ -1305,6 +1314,9 @@ fn analyzeNavVal(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.CompileErr // Mark the unit as completed before evaluating the export! assert(zcu.analysis_in_progress.swapRemove(anal_unit)); + if (zir_decl.type_body == null) { + assert(zcu.analysis_in_progress.swapRemove(.wrap(.{ .nav_ty = nav_id }))); + } if (zir_decl.linkage == .@"export") { const export_src = block.src(.{ .token_offset = @enumFromInt(@intFromBool(zir_decl.is_pub)) }); @@ -1347,6 +1359,8 @@ pub fn ensureNavTypeUpToDate(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zc log.debug("ensureNavTypeUpToDate {f}", .{zcu.fmtAnalUnit(anal_unit)}); + assert(!zcu.analysis_in_progress.contains(anal_unit)); + const type_resolved_by_value: bool = from_val: { const analysis = nav.analysis orelse break :from_val false; const inst_resolved = analysis.zir_index.resolveFull(ip) orelse break :from_val false; @@ -1463,8 +1477,8 @@ fn analyzeNavType(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.CompileEr const file = zcu.fileByIndex(inst_resolved.file); const zir = file.zir.?; - try zcu.analysis_in_progress.put(gpa, anal_unit, {}); - defer _ = zcu.analysis_in_progress.swapRemove(anal_unit); + try zcu.analysis_in_progress.putNoClobber(gpa, anal_unit, {}); + defer assert(zcu.analysis_in_progress.swapRemove(anal_unit)); const zir_decl = zir.getDeclaration(inst_resolved.inst); const type_body = zir_decl.type_body.?; @@ -1571,7 +1585,7 @@ fn analyzeNavType(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.CompileEr return .{ .type_changed = true }; } -pub fn ensureFuncBodyUpToDate(pt: Zcu.PerThread, maybe_coerced_func_index: InternPool.Index) Zcu.SemaError!void { +pub fn ensureFuncBodyUpToDate(pt: Zcu.PerThread, func_index: InternPool.Index) Zcu.SemaError!void { dev.check(.sema); const tracy = trace(@src()); @@ -1581,15 +1595,17 @@ pub fn ensureFuncBodyUpToDate(pt: Zcu.PerThread, maybe_coerced_func_index: Inter const gpa = zcu.gpa; const ip = &zcu.intern_pool; - _ = zcu.func_body_analysis_queued.swapRemove(maybe_coerced_func_index); + _ = zcu.func_body_analysis_queued.swapRemove(func_index); - // We only care about the uncoerced function. - const func_index = ip.unwrapCoercedFunc(maybe_coerced_func_index); const anal_unit: AnalUnit = .wrap(.{ .func = func_index }); log.debug("ensureFuncBodyUpToDate {f}", .{zcu.fmtAnalUnit(anal_unit)}); - const func = zcu.funcInfo(maybe_coerced_func_index); + assert(!zcu.analysis_in_progress.contains(anal_unit)); + + const func = zcu.funcInfo(func_index); + + assert(func.ty == func.uncoerced_ty); // analyze the body of the original function, not a coerced one const was_outdated = zcu.outdated.swapRemove(anal_unit) or zcu.potentially_outdated.swapRemove(anal_unit); @@ -2443,10 +2459,10 @@ fn updateEmbedFileInner( // The loaded bytes of the file, including a sentinel 0 byte. const ip_str: InternPool.String = str: { - const strings = ip.getLocal(tid).getMutableStrings(gpa); - const old_len = strings.mutate.len; - errdefer strings.shrinkRetainingCapacity(old_len); - const bytes = (try strings.addManyAsSlice(size_plus_one))[0]; + const string_bytes = ip.getLocal(tid).getMutableStringBytes(gpa); + const old_len = string_bytes.mutate.len; + errdefer string_bytes.shrinkRetainingCapacity(old_len); + const bytes = (try string_bytes.addManyAsSlice(size_plus_one))[0]; var fr = file.reader(&.{}); fr.size = stat.size; fr.interface.readSliceAll(bytes[0..size]) catch |err| switch (err) { @@ -2781,7 +2797,7 @@ fn analyzeFnBodyInner(pt: Zcu.PerThread, func_index: InternPool.Index) Zcu.SemaE const file = zcu.fileByIndex(inst_info.file); const zir = file.zir.?; - try zcu.analysis_in_progress.put(gpa, anal_unit, {}); + try zcu.analysis_in_progress.putNoClobber(gpa, anal_unit, {}); errdefer _ = zcu.analysis_in_progress.swapRemove(anal_unit); func.setAnalyzed(ip); diff --git a/src/arch/x86_64/CodeGen.zig b/src/arch/x86_64/CodeGen.zig index 5b0181cdcd..e1ad9e3d07 100644 --- a/src/arch/x86_64/CodeGen.zig +++ b/src/arch/x86_64/CodeGen.zig @@ -2291,7 +2291,7 @@ fn genBodyBlock(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { } fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { - @setEvalBranchQuota(29_400); + @setEvalBranchQuota(29_500); const pt = cg.pt; const zcu = pt.zcu; const ip = &zcu.intern_pool; @@ -7263,10 +7263,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, .{ ._, .vp_d, .add, .dst0x, .src0x, .src1x, ._ }, .{ ._, .vp_d, .sra, .tmp2x, .src0x, .ui(31), ._ }, - .{ ._, .vp_d, .cmpgt, .tmp3x, .dst0x, .src0x, ._ }, + .{ ._, .vp_d, .cmpgt, .tmp3x, .src0x, .dst0x, ._ }, .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .lea(.tmp0x), ._ }, .{ ._, .vp_, .xor, .tmp3x, .tmp3x, .src1x, ._ }, - .{ ._, .v_ps, .blendv, .dst0x, .tmp2x, .dst0x, .tmp3x }, + .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp2x, .tmp3x }, } }, }, .{ .required_features = .{ .sse4_1, null, null, null }, @@ -7332,10 +7332,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, .{ ._, .vp_d, .add, .dst0y, .src0y, .src1y, ._ }, .{ ._, .vp_d, .sra, .tmp2y, .src0y, .ui(31), ._ }, - .{ ._, .vp_d, .cmpgt, .tmp3y, .dst0y, .src0y, ._ }, + .{ ._, .vp_d, .cmpgt, .tmp3y, .src0y, .dst0y, ._ }, .{ ._, .vp_, .xor, .tmp2y, .tmp2y, .lea(.tmp0y), ._ }, .{ ._, .vp_, .xor, .tmp3y, .tmp3y, .src1y, ._ }, - .{ ._, .v_ps, .blendv, .dst0y, .tmp2y, .dst0y, .tmp3y }, + .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .tmp2y, .tmp3y }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -7615,10 +7615,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ }, .{ ._, .vp_q, .add, .dst0x, .src0x, .src1x, ._ }, .{ ._, .vp_q, .cmpgt, .tmp2x, .tmp2x, .src0x, ._ }, - .{ ._, .vp_q, .cmpgt, .tmp3x, .dst0x, .src0x, ._ }, + .{ ._, .vp_q, .cmpgt, .tmp3x, .src0x, .dst0x, ._ }, .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .lea(.tmp0x), ._ }, .{ ._, .vp_, .xor, .tmp3x, .tmp3x, .src1x, ._ }, - .{ ._, .v_pd, .blendv, .dst0x, .tmp2x, .dst0x, .tmp3x }, + .{ ._, .v_pd, .blendv, .dst0x, .dst0x, .tmp2x, .tmp3x }, } }, }, .{ .required_features = .{ .sse4_2, null, null, null }, @@ -7685,10 +7685,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, .vp_, .xor, .tmp2y, .tmp2y, .tmp2y, ._ }, .{ ._, .vp_q, .add, .dst0y, .src0y, .src1y, ._ }, .{ ._, .vp_q, .cmpgt, .tmp2y, .tmp2y, .src0y, ._ }, - .{ ._, .vp_q, .cmpgt, .tmp3y, .dst0y, .src0y, ._ }, + .{ ._, .vp_q, .cmpgt, .tmp3y, .src0y, .dst0y, ._ }, .{ ._, .vp_, .xor, .tmp2y, .tmp2y, .lea(.tmp0y), ._ }, .{ ._, .vp_, .xor, .tmp3y, .tmp3y, .src1y, ._ }, - .{ ._, .v_pd, .blendv, .dst0y, .tmp2y, .dst0y, .tmp3y }, + .{ ._, .v_pd, .blendv, .dst0y, .dst0y, .tmp2y, .tmp3y }, } }, }, .{ .required_features = .{ .avx2, null, null, null }, @@ -7724,8 +7724,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp2x, .tmp3x }, .{ ._, .vp_q, .cmpeq, .tmp3x, .tmp3x, .tmp3x, ._ }, .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .tmp3x, ._ }, - .{ ._, .vp_q, .cmpgt, .tmp3x, .dst0x, .tmp2x, ._ }, - .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp2x, .tmp3x }, + .{ ._, .vp_q, .cmpgt, .tmp3x, .tmp2x, .dst0x, ._ }, + .{ ._, .vp_b, .blendv, .dst0x, .tmp2x, .dst0x, .tmp3x }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -7761,8 +7761,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp2x, .tmp3x }, .{ ._, .vp_q, .cmpeq, .tmp3x, .tmp3x, .tmp3x, ._ }, .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .tmp3x, ._ }, - .{ ._, .vp_q, .cmpgt, .tmp3x, .dst0x, .tmp2x, ._ }, - .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp2x, .tmp3x }, + .{ ._, .vp_q, .cmpgt, .tmp3x, .tmp2x, .dst0x, ._ }, + .{ ._, .vp_b, .blendv, .dst0x, .tmp2x, .dst0x, .tmp3x }, } }, }, .{ .required_features = .{ .sse4_2, null, null, null }, @@ -7837,8 +7837,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, .vp_b, .blendv, .dst0y, .dst0y, .tmp2y, .tmp3y }, .{ ._, .vp_q, .cmpeq, .tmp3y, .tmp3y, .tmp3y, ._ }, .{ ._, .vp_, .xor, .tmp2y, .tmp2y, .tmp3y, ._ }, - .{ ._, .vp_q, .cmpgt, .tmp3y, .dst0y, .tmp2y, ._ }, - .{ ._, .vp_b, .blendv, .dst0y, .dst0y, .tmp2y, .tmp3y }, + .{ ._, .vp_q, .cmpgt, .tmp3y, .tmp2y, .dst0y, ._ }, + .{ ._, .vp_b, .blendv, .dst0y, .tmp2y, .dst0y, .tmp3y }, } }, }, .{ .required_features = .{ .avx2, null, null, null }, @@ -10714,10 +10714,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, .v_dqa, .mov, .tmp4y, .memia(.src1y, .tmp0, .add_unaligned_size), ._, ._ }, .{ ._, .vp_d, .add, .tmp5y, .tmp3y, .tmp4y, ._ }, .{ ._, .vp_d, .sra, .tmp6y, .tmp3y, .ui(31), ._ }, - .{ ._, .vp_d, .cmpgt, .tmp3y, .tmp5y, .tmp3y, ._ }, + .{ ._, .vp_d, .cmpgt, .tmp3y, .tmp3y, .tmp5y, ._ }, .{ ._, .vp_, .xor, .tmp6y, .tmp6y, .tmp2y, ._ }, .{ ._, .vp_, .xor, .tmp3y, .tmp3y, .tmp4y, ._ }, - .{ ._, .v_ps, .blendv, .tmp3y, .tmp6y, .tmp5y, .tmp3y }, + .{ ._, .v_ps, .blendv, .tmp3y, .tmp5y, .tmp6y, .tmp3y }, .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp3y, ._, ._ }, .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, @@ -10755,10 +10755,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, .v_dqa, .mov, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, .{ ._, .vp_d, .add, .tmp5x, .tmp3x, .tmp4x, ._ }, .{ ._, .vp_d, .sra, .tmp6x, .tmp3x, .ui(31), ._ }, - .{ ._, .vp_d, .cmpgt, .tmp3x, .tmp5x, .tmp3x, ._ }, + .{ ._, .vp_d, .cmpgt, .tmp3x, .tmp3x, .tmp5x, ._ }, .{ ._, .vp_, .xor, .tmp6x, .tmp6x, .tmp2x, ._ }, .{ ._, .vp_, .xor, .tmp3x, .tmp3x, .tmp4x, ._ }, - .{ ._, .v_ps, .blendv, .tmp3x, .tmp6x, .tmp5x, .tmp3x }, + .{ ._, .v_ps, .blendv, .tmp3x, .tmp5x, .tmp6x, .tmp3x }, .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, @@ -11543,10 +11543,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, .vp_, .xor, .tmp5y, .tmp5y, .tmp5y, ._ }, .{ ._, .vp_q, .add, .tmp6y, .tmp3y, .tmp4y, ._ }, .{ ._, .vp_q, .cmpgt, .tmp5y, .tmp5y, .tmp3y, ._ }, - .{ ._, .vp_q, .cmpgt, .tmp3y, .tmp6y, .tmp3y, ._ }, + .{ ._, .vp_q, .cmpgt, .tmp3y, .tmp3y, .tmp6y, ._ }, .{ ._, .vp_, .xor, .tmp5y, .tmp5y, .tmp2y, ._ }, .{ ._, .vp_, .xor, .tmp3y, .tmp3y, .tmp4y, ._ }, - .{ ._, .v_pd, .blendv, .tmp5y, .tmp5y, .tmp6y, .tmp3y }, + .{ ._, .v_pd, .blendv, .tmp5y, .tmp6y, .tmp5y, .tmp3y }, .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp5y, ._, ._ }, .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, @@ -11585,10 +11585,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, .vp_, .xor, .tmp5x, .tmp5x, .tmp5x, ._ }, .{ ._, .vp_q, .add, .tmp6x, .tmp3x, .tmp4x, ._ }, .{ ._, .vp_q, .cmpgt, .tmp5x, .tmp5x, .tmp3x, ._ }, - .{ ._, .vp_q, .cmpgt, .tmp3x, .tmp6x, .tmp3x, ._ }, + .{ ._, .vp_q, .cmpgt, .tmp3x, .tmp3x, .tmp6x, ._ }, .{ ._, .vp_, .xor, .tmp5x, .tmp5x, .tmp2x, ._ }, .{ ._, .vp_, .xor, .tmp3x, .tmp3x, .tmp4x, ._ }, - .{ ._, .v_pd, .blendv, .tmp5x, .tmp5x, .tmp6x, .tmp3x }, + .{ ._, .v_pd, .blendv, .tmp5x, .tmp6x, .tmp5x, .tmp3x }, .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp5x, ._, ._ }, .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, @@ -11607,11 +11607,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, .{ .type = .i64, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .none } } }, .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, - .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, - .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, - .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, - .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, .{ .type = .vector_2_i64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, + .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, + .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, + .unused, .unused, .unused, .unused, @@ -11628,12 +11628,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._dqa, .mov, .tmp6x, .tmp3x, ._, ._ }, .{ ._, .p_q, .add, .tmp6x, .tmp4x, ._, ._ }, .{ ._, .p_q, .cmpgt, .tmp5x, .tmp3x, ._, ._ }, - .{ ._, ._dqa, .mov, .tmp7x, .tmp6x, ._, ._ }, - .{ ._, .p_q, .cmpgt, .tmp7x, .tmp3x, ._, ._ }, + .{ ._, .p_q, .cmpgt, .tmp3x, .tmp6x, ._, ._ }, .{ ._, .p_, .xor, .tmp5x, .tmp2x, ._, ._ }, - .{ ._, .p_, .xor, .tmp7x, .tmp4x, ._, ._ }, - .{ ._, ._pd, .blendv, .tmp5x, .tmp6x, .tmp7x, ._ }, - .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp5x, ._, ._ }, + .{ ._, .p_, .xor, .tmp3x, .tmp4x, ._, ._ }, + .{ ._, ._pd, .blendv, .tmp6x, .tmp5x, .tmp3x, ._ }, + .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp6x, ._, ._ }, .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, } }, @@ -22284,8 +22283,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, .vp_w, .movsxb, .dst0y, .src0x, ._, ._ }, .{ ._, .vp_w, .movsxb, .tmp0y, .src1x, ._, ._ }, .{ ._, .vp_w, .mull, .dst0y, .dst0y, .tmp0y, ._ }, - .{ ._, .vp_b, .ackssw, .dst0y, .dst0y, .dst0y, ._ }, - .{ ._, .v_q, .perm, .dst0y, .dst0y, .ui(0b10_00_10_00), ._ }, + .{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ }, + .{ ._, .vp_b, .ackssw, .dst0x, .dst0x, .tmp0x, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -22415,8 +22414,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, .vp_w, .movzxb, .dst0y, .src0x, ._, ._ }, .{ ._, .vp_w, .movzxb, .tmp0y, .src1x, ._, ._ }, .{ ._, .vp_w, .mull, .dst0y, .dst0y, .tmp0y, ._ }, - .{ ._, .vp_b, .ackusw, .dst0y, .dst0y, .dst0y, ._ }, - .{ ._, .v_q, .perm, .dst0y, .dst0y, .ui(0b10_00_10_00), ._ }, + .{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ }, + .{ ._, .vp_b, .ackusw, .dst0x, .dst0x, .tmp0x, ._ }, } }, }, .{ .required_features = .{ .avx2, null, null, null }, @@ -22448,8 +22447,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .@"0:", .vp_w, .movsxb, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, .{ ._, .vp_w, .movsxb, .tmp2y, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, .{ ._, .vp_w, .mull, .tmp1y, .tmp1y, .tmp2y, ._ }, - .{ ._, .vp_b, .ackssw, .tmp1y, .tmp1y, .tmp1y, ._ }, - .{ ._, .v_q, .perm, .tmp1y, .tmp1y, .ui(0b10_00_10_00), ._ }, + .{ ._, .v_i128, .extract, .tmp2x, .tmp1y, .ui(1), ._ }, + .{ ._, .vp_b, .ackssw, .tmp1x, .tmp1x, .tmp2x, ._ }, .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, @@ -22660,8 +22659,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .@"0:", .vp_w, .movzxb, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, .{ ._, .vp_w, .movzxb, .tmp2y, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, .{ ._, .vp_w, .mull, .tmp1y, .tmp1y, .tmp2y, ._ }, - .{ ._, .vp_b, .ackusw, .tmp1y, .tmp1y, .tmp1y, ._ }, - .{ ._, .v_q, .perm, .tmp1y, .tmp1y, .ui(0b10_00_10_00), ._ }, + .{ ._, .v_i128, .extract, .tmp2x, .tmp1y, .ui(1), ._ }, + .{ ._, .vp_b, .ackusw, .tmp1x, .tmp1x, .tmp2x, ._ }, .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, @@ -31490,7 +31489,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._x, .ado, .tmp8q, .tmp3q, ._, ._ }, .{ ._, ._x, .adc, .tmp8q, .tmp3q, ._, ._ }, .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, - .{ .@"1:", ._, .@"or", .tmp8q, .leai(.tmp1q, .tmp4), ._, ._ }, + .{ .@"1:", ._, .@"or", .tmp8q, .leaid(.tmp1q, .tmp4, 8), ._, ._ }, .{ .@"2:", ._, .sub, .tmp4d, .si(8), ._, ._ }, .{ ._, ._ae, .j, .@"1b", ._, ._, ._ }, .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ }, @@ -31814,7 +31813,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._x, .ado, .tmp8q, .tmp3q, ._, ._ }, .{ ._, ._x, .adc, .tmp8q, .tmp3q, ._, ._ }, .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, - .{ .@"1:", ._, .@"or", .tmp8q, .leai(.tmp1q, .tmp4), ._, ._ }, + .{ .@"1:", ._, .@"or", .tmp8q, .leaid(.tmp1q, .tmp4, 8), ._, ._ }, .{ .@"2:", ._, .sub, .tmp4d, .si(8), ._, ._ }, .{ ._, ._ae, .j, .@"1b", ._, ._, ._ }, .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ }, @@ -32175,7 +32174,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._x, .ado, .tmp8q, .tmp3q, ._, ._ }, .{ ._, ._x, .adc, .tmp8q, .tmp3q, ._, ._ }, .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, - .{ .@"1:", ._, .@"or", .tmp8q, .leai(.tmp1q, .tmp4), ._, ._ }, + .{ .@"1:", ._, .@"or", .tmp8q, .leaid(.tmp1q, .tmp4, 8), ._, ._ }, .{ .@"2:", ._, .sub, .tmp4d, .si(8), ._, ._ }, .{ ._, ._ae, .j, .@"1b", ._, ._, ._ }, .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ }, @@ -55062,7 +55061,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._x, .ado, .tmp8q, .tmp3q, ._, ._ }, .{ ._, ._x, .adc, .tmp8q, .tmp3q, ._, ._ }, .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, - .{ .@"1:", ._, .@"or", .tmp8q, .leai(.tmp1q, .tmp4), ._, ._ }, + .{ .@"1:", ._, .@"or", .tmp8q, .leaid(.tmp1q, .tmp4, 8), ._, ._ }, .{ .@"2:", ._, .sub, .tmp4d, .si(8), ._, ._ }, .{ ._, ._ae, .j, .@"1b", ._, ._, ._ }, .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ }, @@ -55361,7 +55360,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._x, .ado, .tmp8q, .tmp3q, ._, ._ }, .{ ._, ._x, .adc, .tmp8q, .tmp3q, ._, ._ }, .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, - .{ .@"1:", ._, .@"or", .tmp8q, .leai(.tmp1q, .tmp4), ._, ._ }, + .{ .@"1:", ._, .@"or", .tmp8q, .leaid(.tmp1q, .tmp4, 8), ._, ._ }, .{ .@"2:", ._, .sub, .tmp4d, .si(8), ._, ._ }, .{ ._, ._ae, .j, .@"1b", ._, ._, ._ }, .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ }, @@ -55690,7 +55689,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._x, .ado, .tmp8q, .tmp3q, ._, ._ }, .{ ._, ._x, .adc, .tmp8q, .tmp3q, ._, ._ }, .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, - .{ .@"1:", ._, .@"or", .tmp8q, .leai(.tmp1q, .tmp4), ._, ._ }, + .{ .@"1:", ._, .@"or", .tmp8q, .leaid(.tmp1q, .tmp4, 8), ._, ._ }, .{ .@"2:", ._, .sub, .tmp4d, .si(8), ._, ._ }, .{ ._, ._ae, .j, .@"1b", ._, ._, ._ }, .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ }, @@ -82560,7 +82559,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, .{ .kind = .{ .rc = .sse } }, - .unused, + .{ .kind = .{ .rc = .sse } }, .unused, .unused, .unused, @@ -82577,8 +82576,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, .{ .@"0:", .v_dqu, .mov, .tmp3y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, .{ ._, .vp_w, .cmpeq, .tmp3y, .tmp3y, .memia(.src1y, .tmp0, .add_size), ._ }, - .{ ._, .vp_b, .ackssw, .tmp3y, .tmp3y, .tmp3y, ._ }, - .{ ._, .vp_b, .movmsk, .tmp2d, .tmp3y, ._, ._ }, + .{ ._, .v_i128, .extract, .tmp4x, .tmp3y, .ui(1), ._ }, + .{ ._, .vp_b, .ackssw, .tmp3x, .tmp3x, .tmp4x, ._ }, + .{ ._, .vp_b, .movmsk, .tmp2d, .tmp3x, ._, ._ }, .{ ._, ._, .mov, .memi(.dst0w, .tmp1), .tmp2w, ._, ._ }, .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 2), ._, ._ }, .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, @@ -82589,8 +82589,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, .{ .@"0:", .v_dqu, .mov, .tmp3y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, .{ ._, .vp_w, .cmpeq, .tmp3y, .tmp3y, .memia(.src1y, .tmp0, .add_size), ._ }, - .{ ._, .vp_b, .ackssw, .tmp3y, .tmp3y, .tmp3y, ._ }, - .{ ._, .vp_b, .movmsk, .tmp2d, .tmp3y, ._, ._ }, + .{ ._, .v_i128, .extract, .tmp4x, .tmp3y, .ui(1), ._ }, + .{ ._, .vp_b, .ackssw, .tmp3x, .tmp3x, .tmp4x, ._ }, + .{ ._, .vp_b, .movmsk, .tmp2d, .tmp3x, ._, ._ }, .{ ._, ._, .not, .tmp2d, ._, ._, ._ }, .{ ._, ._, .mov, .memi(.dst0w, .tmp1), .tmp2w, ._, ._ }, .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 2), ._, ._ }, @@ -86773,52 +86774,313 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { const is_non_err = try cg.tempInit(.bool, .{ .eflags = .e }); try is_non_err.finish(inst, &.{un_op}, &ops, cg); }, - .load => fallback: { + .load => { const ty_op = air_datas[@intFromEnum(inst)].ty_op; const val_ty = ty_op.ty.toType(); - const ptr_ty = cg.typeOf(ty_op.operand); - const ptr_info = ptr_ty.ptrInfo(zcu); - if (ptr_info.packed_offset.host_size > 0 and - (ptr_info.flags.vector_index == .none or val_ty.toIntern() == .bool_type)) - break :fallback try cg.airLoad(inst); var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); - const res = try ops[0].load(val_ty, .{ - .disp = switch (ptr_info.flags.vector_index) { - .none => 0, - .runtime => unreachable, - else => |vector_index| @intCast(val_ty.abiSize(zcu) * @intFromEnum(vector_index)), + var res: [1]Temp = undefined; + cg.select(&res, &.{val_ty}, &ops, comptime &.{ .{ + .src_constraints = .{ .{ .ptr_bool_vec_elem = .byte }, .any, .any }, + .patterns = &.{ + .{ .src = .{ .to_gpr, .none, .none } }, }, - }, cg); - try res.finish(inst, &.{ty_op.operand}, &ops, cg); + .extra_temps = .{ + .{ .type = .u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .{ .cc = .c }, .unused }, + .clobbers = .{ .eflags = true }, + .each = .{ .once = &.{ + .{ ._, ._, .movzx, .tmp0d, .lea(.src0b), ._, ._ }, + .{ ._, ._, .bt, .tmp0d, .ua(.src0, .add_vector_index), ._, ._ }, + } }, + }, .{ + .src_constraints = .{ .{ .ptr_bool_vec_elem = .word }, .any, .any }, + .patterns = &.{ + .{ .src = .{ .to_gpr, .none, .none } }, + }, + .dst_temps = .{ .{ .cc = .c }, .unused }, + .clobbers = .{ .eflags = true }, + .each = .{ .once = &.{ + .{ ._, ._, .bt, .lea(.src0w), .ua(.src0, .add_vector_index), ._, ._ }, + } }, + }, .{ + .src_constraints = .{ .ptr_any_bool_vec_elem, .any, .any }, + .patterns = &.{ + .{ .src = .{ .to_gpr, .none, .none } }, + }, + .dst_temps = .{ .{ .cc = .c }, .unused }, + .clobbers = .{ .eflags = true }, + .each = .{ .once = &.{ + .{ ._, ._, .bt, .leaa(.src0d, .add_vector_index_div_8_down_4), .ua(.src0, .add_vector_index_rem_32), ._, ._ }, + } }, + } }) catch |err| switch (err) { + error.SelectFailed => res[0] = try ops[0].load(val_ty, .{ + .disp = switch (cg.typeOf(ty_op.operand).ptrInfo(zcu).flags.vector_index) { + .none => 0, + .runtime => unreachable, + else => |vector_index| @intCast(val_ty.abiSize(zcu) * @intFromEnum(vector_index)), + }, + }, cg), + else => |e| return e, + }; + try res[0].finish(inst, &.{ty_op.operand}, &ops, cg); }, .ret => try cg.airRet(inst, false), .ret_safe => try cg.airRet(inst, true), .ret_load => try cg.airRetLoad(inst), - .store, .store_safe => |air_tag| fallback: { + .store, .store_safe => |air_tag| { const bin_op = air_datas[@intFromEnum(inst)].bin_op; - const ptr_ty = cg.typeOf(bin_op.lhs); - const ptr_info = ptr_ty.ptrInfo(zcu); - const val_ty = cg.typeOf(bin_op.rhs); - if (ptr_info.packed_offset.host_size > 0 and - (ptr_info.flags.vector_index == .none or val_ty.toIntern() == .bool_type)) - break :fallback try cg.airStore(inst, switch (air_tag) { - else => unreachable, - .store => false, - .store_safe => true, - }); var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); - try ops[0].store(&ops[1], .{ - .disp = switch (ptr_info.flags.vector_index) { - .none => 0, - .runtime => unreachable, - else => |vector_index| @intCast(val_ty.abiSize(zcu) * @intFromEnum(vector_index)), + cg.select(&.{}, &.{}, &ops, comptime &.{ .{ + .src_constraints = .{ .{ .ptr_bool_vec_elem = .byte }, .bool, .any }, + .patterns = &.{ + .{ .src = .{ .to_gpr, .{ .imm = 0 }, .none } }, }, - .safe = switch (air_tag) { - else => unreachable, - .store => false, - .store_safe => true, + .extra_temps = .{ + .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, }, - }, cg); + .clobbers = .{ .eflags = true }, + .each = .{ .once = &.{ + .{ ._, ._, .movzx, .tmp0d, .lea(.src0b), ._, ._ }, + .{ ._, ._r, .bt, .tmp0d, .ua(.src0, .add_vector_index), ._, ._ }, + .{ ._, ._, .mov, .lea(.src0b), .tmp0b, ._, ._ }, + } }, + }, .{ + .src_constraints = .{ .{ .ptr_bool_vec_elem = .byte }, .bool, .any }, + .patterns = &.{ + .{ .src = .{ .to_gpr, .{ .imm = 1 }, .none } }, + }, + .extra_temps = .{ + .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .clobbers = .{ .eflags = true }, + .each = .{ .once = &.{ + .{ ._, ._, .movzx, .tmp0d, .lea(.src0b), ._, ._ }, + .{ ._, ._s, .bt, .tmp0d, .ua(.src0, .add_vector_index), ._, ._ }, + .{ ._, ._, .mov, .lea(.src0b), .tmp0b, ._, ._ }, + } }, + }, .{ + .required_features = .{ .cmov, null, null, null }, + .src_constraints = .{ .{ .ptr_bool_vec_elem = .byte }, .bool, .any }, + .patterns = &.{ + .{ .src = .{ .to_gpr, .to_gpr, .none } }, + }, + .extra_temps = .{ + .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .clobbers = .{ .eflags = true }, + .each = .{ .once = &.{ + .{ ._, ._, .movzx, .tmp0d, .lea(.src0b), ._, ._ }, + .{ ._, ._, .mov, .tmp1d, .tmp0d, ._, ._ }, + .{ ._, ._r, .bt, .tmp1d, .ua(.src0, .add_vector_index), ._, ._ }, + .{ ._, ._s, .bt, .tmp0d, .ua(.src0, .add_vector_index), ._, ._ }, + .{ ._, ._, .@"test", .src1b, .si(1), ._, ._ }, + .{ ._, ._z, .cmov, .tmp0d, .tmp1d, ._, ._ }, + .{ ._, ._, .mov, .lea(.src0b), .tmp0b, ._, ._ }, + } }, + }, .{ + .src_constraints = .{ .{ .ptr_bool_vec_elem = .byte }, .bool, .any }, + .patterns = &.{ + .{ .src = .{ .to_gpr, .to_gpr, .none } }, + }, + .extra_temps = .{ + .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .clobbers = .{ .eflags = true }, + .each = .{ .once = &.{ + .{ ._, ._, .movzx, .tmp0d, .lea(.src0b), ._, ._ }, + .{ ._, ._, .@"test", .src1b, .si(1), ._, ._ }, + .{ ._, ._nz, .j, .@"0f", ._, ._, ._ }, + .{ ._, ._r, .bt, .tmp0d, .ua(.src0, .add_vector_index), ._, ._ }, + .{ ._, ._mp, .j, .@"1f", ._, ._, ._ }, + .{ .@"0:", ._s, .bt, .tmp0d, .ua(.src0, .add_vector_index), ._, ._ }, + .{ .@"1:", ._, .mov, .lea(.src0b), .tmp0b, ._, ._ }, + } }, + }, .{ + .src_constraints = .{ .{ .ptr_bool_vec_elem = .word }, .bool, .any }, + .patterns = &.{ + .{ .src = .{ .to_gpr, .{ .imm = 0 }, .none } }, + }, + .clobbers = .{ .eflags = true }, + .each = .{ .once = &.{ + .{ ._, ._r, .bt, .lea(.src0w), .ua(.src0, .add_vector_index), ._, ._ }, + } }, + }, .{ + .src_constraints = .{ .{ .ptr_bool_vec_elem = .word }, .bool, .any }, + .patterns = &.{ + .{ .src = .{ .to_gpr, .{ .imm = 1 }, .none } }, + }, + .clobbers = .{ .eflags = true }, + .each = .{ .once = &.{ + .{ ._, ._s, .bt, .lea(.src0w), .ua(.src0, .add_vector_index), ._, ._ }, + } }, + }, .{ + .required_features = .{ .cmov, null, null, null }, + .src_constraints = .{ .{ .ptr_bool_vec_elem = .word }, .bool, .any }, + .patterns = &.{ + .{ .src = .{ .to_gpr, .to_gpr, .none } }, + }, + .extra_temps = .{ + .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .clobbers = .{ .eflags = true }, + .each = .{ .once = &.{ + .{ ._, ._, .movzx, .tmp0d, .lea(.src0w), ._, ._ }, + .{ ._, ._, .mov, .tmp1d, .tmp0d, ._, ._ }, + .{ ._, ._r, .bt, .tmp1d, .ua(.src0, .add_vector_index), ._, ._ }, + .{ ._, ._s, .bt, .tmp0d, .ua(.src0, .add_vector_index), ._, ._ }, + .{ ._, ._, .@"test", .src1b, .si(1), ._, ._ }, + .{ ._, ._z, .cmov, .tmp0d, .tmp1d, ._, ._ }, + .{ ._, ._, .mov, .lea(.src0w), .tmp0w, ._, ._ }, + } }, + }, .{ + .src_constraints = .{ .{ .ptr_bool_vec_elem = .word }, .bool, .any }, + .patterns = &.{ + .{ .src = .{ .to_gpr, .to_gpr, .none } }, + }, + .clobbers = .{ .eflags = true }, + .each = .{ .once = &.{ + .{ ._, ._, .@"test", .src1b, .si(1), ._, ._ }, + .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, + .{ ._, ._r, .bt, .lea(.src0w), .ua(.src0, .add_vector_index), ._, ._ }, + .{ ._, ._mp, .j, .@"0f", ._, ._, ._ }, + .{ .@"1:", ._s, .bt, .lea(.src0w), .ua(.src0, .add_vector_index), ._, ._ }, + } }, + }, .{ + .src_constraints = .{ .ptr_any_bool_vec_elem, .bool, .any }, + .patterns = &.{ + .{ .src = .{ .to_gpr, .{ .imm = 0 }, .none } }, + }, + .clobbers = .{ .eflags = true }, + .each = .{ .once = &.{ + .{ ._, ._r, .bt, .leaa(.src0d, .add_vector_index_div_8_down_4), .ua(.src0, .add_vector_index_rem_32), ._, ._ }, + } }, + }, .{ + .src_constraints = .{ .ptr_any_bool_vec_elem, .bool, .any }, + .patterns = &.{ + .{ .src = .{ .to_gpr, .{ .imm = 1 }, .none } }, + }, + .clobbers = .{ .eflags = true }, + .each = .{ .once = &.{ + .{ ._, ._s, .bt, .leaa(.src0d, .add_vector_index_div_8_down_4), .ua(.src0, .add_vector_index_rem_32), ._, ._ }, + } }, + }, .{ + .required_features = .{ .cmov, null, null, null }, + .src_constraints = .{ .ptr_any_bool_vec_elem, .bool, .any }, + .patterns = &.{ + .{ .src = .{ .to_gpr, .to_gpr, .none } }, + }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .clobbers = .{ .eflags = true }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .leaa(.src0d, .add_vector_index_div_8_down_4), ._, ._ }, + .{ ._, ._, .mov, .tmp1d, .tmp0d, ._, ._ }, + .{ ._, ._r, .bt, .tmp1d, .ua(.src0, .add_vector_index_rem_32), ._, ._ }, + .{ ._, ._s, .bt, .tmp0d, .ua(.src0, .add_vector_index_rem_32), ._, ._ }, + .{ ._, ._, .@"test", .src1b, .si(1), ._, ._ }, + .{ ._, ._z, .cmov, .tmp0d, .tmp1d, ._, ._ }, + .{ ._, ._, .mov, .leaa(.src0d, .add_vector_index_div_8_down_4), .tmp0d, ._, ._ }, + } }, + }, .{ + .src_constraints = .{ .ptr_any_bool_vec_elem, .bool, .any }, + .patterns = &.{ + .{ .src = .{ .to_gpr, .to_gpr, .none } }, + }, + .clobbers = .{ .eflags = true }, + .each = .{ .once = &.{ + .{ ._, ._, .@"test", .src1b, .si(1), ._, ._ }, + .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, + .{ ._, ._r, .bt, .leaa(.src0d, .add_vector_index_div_8_down_4), .ua(.src0, .add_vector_index_rem_32), ._, ._ }, + .{ ._, ._mp, .j, .@"0f", ._, ._, ._ }, + .{ .@"1:", ._s, .bt, .leaa(.src0d, .add_vector_index_div_8_down_4), .ua(.src0, .add_vector_index_rem_32), ._, ._ }, + } }, + } }) catch |err| switch (err) { + error.SelectFailed => try ops[0].store(&ops[1], .{ + .disp = switch (cg.typeOf(bin_op.lhs).ptrInfo(zcu).flags.vector_index) { + .none => 0, + .runtime => unreachable, + else => |vector_index| @intCast(cg.typeOf(bin_op.rhs).abiSize(zcu) * @intFromEnum(vector_index)), + }, + .safe = switch (air_tag) { + else => unreachable, + .store => false, + .store_safe => true, + }, + }, cg), + else => |e| return e, + }; for (ops) |op| try op.die(cg); }, .unreach => {}, @@ -90325,7 +90587,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .{ .required_features = .{ .avx, null, null, null }, .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .word } }, .any, .any }, - .dst_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .byte } }, .any }, + .dst_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .qword, .is = .byte } }, .any }, .patterns = &.{ .{ .src = .{ .to_sse, .none, .none } }, }, @@ -90347,7 +90609,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .{ .required_features = .{ .sse2, null, null, null }, .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .word } }, .any, .any }, - .dst_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .byte } }, .any }, + .dst_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .qword, .is = .byte } }, .any }, .patterns = &.{ .{ .src = .{ .to_mut_sse, .none, .none } }, }, @@ -90362,20 +90624,46 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .patterns = &.{ .{ .src = .{ .to_sse, .none, .none } }, }, - .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, + .dst_temps = .{ .{ .rc = .sse }, .unused }, .each = .{ .once = &.{ - .{ ._, .vp_b, .ackssw, .dst0y, .src0y, .dst0y, ._ }, + .{ ._, .v_i128, .extract, .dst0x, .src0y, .ui(1), ._ }, + .{ ._, .vp_b, .ackssw, .dst0x, .src0x, .dst0x, ._ }, + } }, + }, .{ + .required_features = .{ .avx, null, null, null }, + .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .word } }, .any, .any }, + .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_sse, .none, .none } }, + }, + .dst_temps = .{ .{ .rc = .sse }, .unused }, + .each = .{ .once = &.{ + .{ ._, .v_f128, .extract, .dst0x, .src0y, .ui(1), ._ }, + .{ ._, .vp_b, .ackssw, .dst0x, .src0x, .dst0x, ._ }, } }, }, .{ .required_features = .{ .avx2, null, null, null }, .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .word } }, .any, .any }, - .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .byte } }, .any }, + .dst_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any }, .patterns = &.{ .{ .src = .{ .to_sse, .none, .none } }, }, - .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, + .dst_temps = .{ .{ .rc = .sse }, .unused }, .each = .{ .once = &.{ - .{ ._, .vp_b, .ackusw, .dst0y, .src0y, .dst0y, ._ }, + .{ ._, .v_i128, .extract, .dst0x, .src0y, .ui(1), ._ }, + .{ ._, .vp_b, .ackusw, .dst0x, .src0x, .dst0x, ._ }, + } }, + }, .{ + .required_features = .{ .avx, null, null, null }, + .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .word } }, .any, .any }, + .dst_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_sse, .none, .none } }, + }, + .dst_temps = .{ .{ .rc = .sse }, .unused }, + .each = .{ .once = &.{ + .{ ._, .v_f128, .extract, .dst0x, .src0y, .ui(1), ._ }, + .{ ._, .vp_b, .ackusw, .dst0x, .src0x, .dst0x, ._ }, } }, }, .{ .required_features = .{ .slow_incdec, null, null, null }, @@ -90449,7 +90737,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .{ .required_features = .{ .avx, null, null, null }, .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any }, - .dst_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .byte } }, .any }, + .dst_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .dword, .is = .byte } }, .any }, .patterns = &.{ .{ .src = .{ .to_sse, .none, .none } }, }, @@ -90473,7 +90761,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .{ .required_features = .{ .sse4_1, null, null, null }, .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any }, - .dst_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .byte } }, .any }, + .dst_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .dword, .is = .byte } }, .any }, .patterns = &.{ .{ .src = .{ .to_mut_sse, .none, .none } }, }, @@ -90489,22 +90777,50 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .patterns = &.{ .{ .src = .{ .to_sse, .none, .none } }, }, - .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, + .dst_temps = .{ .{ .rc = .sse }, .unused }, .each = .{ .once = &.{ - .{ ._, .vp_w, .ackssd, .dst0y, .src0y, .dst0y, ._ }, - .{ ._, .vp_b, .ackssw, .dst0y, .dst0y, .dst0y, ._ }, + .{ ._, .v_i128, .extract, .dst0x, .src0y, .ui(1), ._ }, + .{ ._, .vp_w, .ackssd, .dst0x, .src0x, .dst0x, ._ }, + .{ ._, .vp_b, .ackssw, .dst0x, .dst0x, .dst0x, ._ }, + } }, + }, .{ + .required_features = .{ .avx, null, null, null }, + .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any }, + .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_sse, .none, .none } }, + }, + .dst_temps = .{ .{ .rc = .sse }, .unused }, + .each = .{ .once = &.{ + .{ ._, .v_f128, .extract, .dst0x, .src0y, .ui(1), ._ }, + .{ ._, .vp_w, .ackssd, .dst0x, .src0x, .dst0x, ._ }, + .{ ._, .vp_b, .ackssw, .dst0x, .dst0x, .dst0x, ._ }, } }, }, .{ .required_features = .{ .avx2, null, null, null }, .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any }, - .dst_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .byte } }, .any }, + .dst_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .qword, .is = .byte } }, .any }, .patterns = &.{ .{ .src = .{ .to_sse, .none, .none } }, }, - .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, + .dst_temps = .{ .{ .rc = .sse }, .unused }, .each = .{ .once = &.{ - .{ ._, .vp_w, .ackusd, .dst0y, .src0y, .dst0y, ._ }, - .{ ._, .vp_b, .ackusw, .dst0y, .dst0y, .dst0y, ._ }, + .{ ._, .v_i128, .extract, .dst0x, .src0y, .ui(1), ._ }, + .{ ._, .vp_w, .ackusd, .dst0x, .src0x, .dst0x, ._ }, + .{ ._, .vp_b, .ackusw, .dst0x, .dst0x, .dst0x, ._ }, + } }, + }, .{ + .required_features = .{ .avx, null, null, null }, + .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any }, + .dst_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .qword, .is = .byte } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_sse, .none, .none } }, + }, + .dst_temps = .{ .{ .rc = .sse }, .unused }, + .each = .{ .once = &.{ + .{ ._, .v_f128, .extract, .dst0x, .src0y, .ui(1), ._ }, + .{ ._, .vp_w, .ackusd, .dst0x, .src0x, .dst0x, ._ }, + .{ ._, .vp_b, .ackusw, .dst0x, .dst0x, .dst0x, ._ }, } }, }, .{ .required_features = .{ .slow_incdec, null, null, null }, @@ -90723,7 +91039,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .{ .required_features = .{ .avx, null, null, null }, .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any }, - .dst_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .word } }, .any }, + .dst_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .qword, .is = .word } }, .any }, .patterns = &.{ .{ .src = .{ .to_sse, .none, .none } }, }, @@ -90745,7 +91061,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .{ .required_features = .{ .sse4_1, null, null, null }, .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any }, - .dst_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .word } }, .any }, + .dst_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .qword, .is = .word } }, .any }, .patterns = &.{ .{ .src = .{ .to_mut_sse, .none, .none } }, }, @@ -90760,20 +91076,46 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .patterns = &.{ .{ .src = .{ .to_sse, .none, .none } }, }, - .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, + .dst_temps = .{ .{ .rc = .sse }, .unused }, .each = .{ .once = &.{ - .{ ._, .vp_w, .ackssd, .dst0y, .src0y, .dst0y, ._ }, + .{ ._, .v_i128, .extract, .dst0x, .src0y, .ui(1), ._ }, + .{ ._, .vp_w, .ackssd, .dst0x, .src0x, .dst0x, ._ }, + } }, + }, .{ + .required_features = .{ .avx, null, null, null }, + .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any }, + .dst_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_sse, .none, .none } }, + }, + .dst_temps = .{ .{ .rc = .sse }, .unused }, + .each = .{ .once = &.{ + .{ ._, .v_f128, .extract, .dst0x, .src0y, .ui(1), ._ }, + .{ ._, .vp_w, .ackssd, .dst0x, .src0x, .dst0x, ._ }, } }, }, .{ .required_features = .{ .avx2, null, null, null }, .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any }, - .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .word } }, .any }, + .dst_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any }, .patterns = &.{ .{ .src = .{ .to_sse, .none, .none } }, }, - .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, + .dst_temps = .{ .{ .rc = .sse }, .unused }, .each = .{ .once = &.{ - .{ ._, .vp_w, .ackusd, .dst0y, .src0y, .dst0y, ._ }, + .{ ._, .v_i128, .extract, .dst0x, .src0y, .ui(1), ._ }, + .{ ._, .vp_w, .ackusd, .dst0x, .src0x, .dst0x, ._ }, + } }, + }, .{ + .required_features = .{ .avx, null, null, null }, + .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any }, + .dst_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_sse, .none, .none } }, + }, + .dst_temps = .{ .{ .rc = .sse }, .unused }, + .each = .{ .once = &.{ + .{ ._, .v_f128, .extract, .dst0x, .src0y, .ui(1), ._ }, + .{ ._, .vp_w, .ackusd, .dst0x, .src0x, .dst0x, ._ }, } }, }, .{ .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any, .any }, @@ -92414,7 +92756,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .vp_d, .movzxb, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .vp_d, .movzxb, .tmp1y, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"4", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, @@ -100782,7 +101124,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .{ .cc = .c }, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .bt, .src0d, .ua(.none, .add_src1_rem_32), ._, ._ }, + .{ ._, ._, .bt, .src0d, .ua(.none, .add_src1), ._, ._ }, } }, }, .{ .src_constraints = .{ .{ .bool_vec = .dword }, .any, .any }, @@ -100803,7 +101145,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .{ .cc = .c }, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .bt, .src0q, .ua(.none, .add_src1_rem_64), ._, ._ }, + .{ ._, ._, .bt, .src0q, .ua(.none, .add_src1), ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", null, null, null }, @@ -165240,7 +165582,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .each = .{ .once = &.{ .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ }, - .{ ._, .v_ps, .shuf, .tmp1x, .tmp1x, .src0x, .ui(0b00_00_00_00) }, + .{ ._, .v_ps, .shuf, .tmp1x, .src0x, .src0x, .ui(0b00_00_00_00) }, .{ .@"0:", .v_ps, .mova, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ }, .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, @@ -174400,114 +174742,6 @@ fn reuseOperandAdvanced( return true; } -fn packedLoad(self: *CodeGen, dst_mcv: MCValue, ptr_ty: Type, ptr_mcv: MCValue) InnerError!void { - const pt = self.pt; - const zcu = pt.zcu; - - const ptr_info = ptr_ty.ptrInfo(zcu); - const val_ty: Type = .fromInterned(ptr_info.child); - if (!val_ty.hasRuntimeBitsIgnoreComptime(zcu)) return; - const val_abi_size: u32 = @intCast(val_ty.abiSize(zcu)); - - const val_bit_size: u32 = @intCast(val_ty.bitSize(zcu)); - const ptr_bit_off = ptr_info.packed_offset.bit_offset + switch (ptr_info.flags.vector_index) { - .none => 0, - .runtime => unreachable, - else => |vector_index| @intFromEnum(vector_index) * val_bit_size, - }; - if (ptr_bit_off % 8 == 0) { - { - const mat_ptr_mcv: MCValue = switch (ptr_mcv) { - .immediate, .register, .register_offset, .lea_frame => ptr_mcv, - else => .{ .register = try self.copyToTmpRegister(ptr_ty, ptr_mcv) }, - }; - const mat_ptr_lock = switch (mat_ptr_mcv) { - .register => |mat_ptr_reg| self.register_manager.lockReg(mat_ptr_reg), - else => null, - }; - defer if (mat_ptr_lock) |lock| self.register_manager.unlockReg(lock); - - try self.load(dst_mcv, ptr_ty, mat_ptr_mcv.offset(@intCast(@divExact(ptr_bit_off, 8)))); - } - - if (val_abi_size * 8 > val_bit_size) { - if (dst_mcv.isRegister()) { - try self.truncateRegister(val_ty, dst_mcv.getReg().?); - } else { - const tmp_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp); - const tmp_lock = self.register_manager.lockRegAssumeUnused(tmp_reg); - defer self.register_manager.unlockReg(tmp_lock); - - const hi_mcv = dst_mcv.address().offset(@intCast(val_bit_size / 64 * 8)).deref(); - try self.genSetReg(tmp_reg, .usize, hi_mcv, .{}); - try self.truncateRegister(val_ty, tmp_reg); - try self.genCopy(.usize, hi_mcv, .{ .register = tmp_reg }, .{}); - } - } - return; - } - - if (val_abi_size > 8) return self.fail("TODO implement packed load of {f}", .{val_ty.fmt(pt)}); - - const limb_abi_size: u31 = @min(val_abi_size, 8); - const limb_abi_bits = limb_abi_size * 8; - const val_byte_off: i32 = @intCast(ptr_bit_off / limb_abi_bits * limb_abi_size); - const val_bit_off = ptr_bit_off % limb_abi_bits; - const val_extra_bits = self.regExtraBits(val_ty); - - const ptr_reg = try self.copyToTmpRegister(ptr_ty, ptr_mcv); - const ptr_lock = self.register_manager.lockRegAssumeUnused(ptr_reg); - defer self.register_manager.unlockReg(ptr_lock); - - const dst_reg = switch (dst_mcv) { - .register => |reg| reg, - else => try self.register_manager.allocReg(null, abi.RegisterClass.gp), - }; - const dst_lock = self.register_manager.lockReg(dst_reg); - defer if (dst_lock) |lock| self.register_manager.unlockReg(lock); - - const load_abi_size = - if (val_bit_off < val_extra_bits) val_abi_size else val_abi_size * 2; - if (load_abi_size <= 8) { - const load_reg = registerAlias(dst_reg, load_abi_size); - try self.asmRegisterMemory(.{ ._, .mov }, load_reg, .{ - .base = .{ .reg = ptr_reg }, - .mod = .{ .rm = .{ - .size = .fromSize(load_abi_size), - .disp = val_byte_off, - } }, - }); - try self.spillEflagsIfOccupied(); - try self.asmRegisterImmediate(.{ ._r, .sh }, load_reg, .u(val_bit_off)); - } else { - const tmp_reg = - registerAlias(try self.register_manager.allocReg(null, abi.RegisterClass.gp), val_abi_size); - const tmp_lock = self.register_manager.lockRegAssumeUnused(tmp_reg); - defer self.register_manager.unlockReg(tmp_lock); - - const dst_alias = registerAlias(dst_reg, val_abi_size); - try self.asmRegisterMemory(.{ ._, .mov }, dst_alias, .{ - .base = .{ .reg = ptr_reg }, - .mod = .{ .rm = .{ - .size = .fromSize(val_abi_size), - .disp = val_byte_off, - } }, - }); - try self.asmRegisterMemory(.{ ._, .mov }, tmp_reg, .{ - .base = .{ .reg = ptr_reg }, - .mod = .{ .rm = .{ - .size = .fromSize(val_abi_size), - .disp = val_byte_off + limb_abi_size, - } }, - }); - try self.spillEflagsIfOccupied(); - try self.asmRegisterRegisterImmediate(.{ ._rd, .sh }, dst_alias, tmp_reg, .u(val_bit_off)); - } - - if (val_extra_bits > 0) try self.truncateRegister(val_ty, dst_reg); - try self.genCopy(val_ty, dst_mcv, .{ .register = dst_reg }, .{}); -} - fn load(self: *CodeGen, dst_mcv: MCValue, ptr_ty: Type, ptr_mcv: MCValue) InnerError!void { const pt = self.pt; const zcu = pt.zcu; @@ -174555,174 +174789,6 @@ fn load(self: *CodeGen, dst_mcv: MCValue, ptr_ty: Type, ptr_mcv: MCValue) InnerE } } -fn airLoad(self: *CodeGen, inst: Air.Inst.Index) !void { - const pt = self.pt; - const zcu = pt.zcu; - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; - const elem_ty = self.typeOfIndex(inst); - const result: MCValue = result: { - if (!elem_ty.hasRuntimeBitsIgnoreComptime(zcu)) break :result .none; - - try self.spillRegisters(&.{ .rdi, .rsi, .rcx }); - const reg_locks = self.register_manager.lockRegsAssumeUnused(3, .{ .rdi, .rsi, .rcx }); - defer for (reg_locks) |lock| self.register_manager.unlockReg(lock); - - const ptr_ty = self.typeOf(ty_op.operand); - const elem_size = elem_ty.abiSize(zcu); - - const elem_rs = self.regSetForType(elem_ty); - const ptr_rs = self.regSetForType(ptr_ty); - - const ptr_mcv = try self.resolveInst(ty_op.operand); - const dst_mcv = if (elem_size <= 8 and std.math.isPowerOfTwo(elem_size) and - elem_rs.supersetOf(ptr_rs) and self.reuseOperand(inst, ty_op.operand, 0, ptr_mcv)) - // The MCValue that holds the pointer can be re-used as the value. - ptr_mcv - else - try self.allocRegOrMem(inst, true); - - const ptr_info = ptr_ty.ptrInfo(zcu); - if (ptr_info.flags.vector_index != .none or ptr_info.packed_offset.host_size > 0) { - try self.packedLoad(dst_mcv, ptr_ty, ptr_mcv); - } else { - try self.load(dst_mcv, ptr_ty, ptr_mcv); - } - - if (elem_ty.isAbiInt(zcu) and elem_size * 8 > elem_ty.bitSize(zcu)) { - const high_mcv: MCValue = switch (dst_mcv) { - .register => |dst_reg| .{ .register = dst_reg }, - .register_pair => |dst_regs| .{ .register = dst_regs[1] }, - else => dst_mcv.address().offset(@intCast((elem_size - 1) / 8 * 8)).deref(), - }; - const high_reg = if (high_mcv.isRegister()) - high_mcv.getReg().? - else - try self.copyToTmpRegister(.usize, high_mcv); - const high_lock = self.register_manager.lockReg(high_reg); - defer if (high_lock) |lock| self.register_manager.unlockReg(lock); - - try self.truncateRegister(elem_ty, high_reg); - if (!high_mcv.isRegister()) try self.genCopy( - if (elem_size <= 8) elem_ty else .usize, - high_mcv, - .{ .register = high_reg }, - .{}, - ); - } - break :result dst_mcv; - }; - return self.finishAir(inst, result, .{ ty_op.operand, .none, .none }); -} - -fn packedStore(self: *CodeGen, ptr_ty: Type, ptr_mcv: MCValue, src_mcv: MCValue) InnerError!void { - const pt = self.pt; - const zcu = pt.zcu; - const ptr_info = ptr_ty.ptrInfo(zcu); - const src_ty: Type = .fromInterned(ptr_info.child); - if (!src_ty.hasRuntimeBitsIgnoreComptime(zcu)) return; - - const limb_abi_size: u16 = @min(ptr_info.packed_offset.host_size, 8); - const limb_abi_bits = limb_abi_size * 8; - const limb_ty = try pt.intType(.unsigned, limb_abi_bits); - - const src_bit_size = src_ty.bitSize(zcu); - const ptr_bit_off = ptr_info.packed_offset.bit_offset + switch (ptr_info.flags.vector_index) { - .none => 0, - .runtime => unreachable, - else => |vector_index| @intFromEnum(vector_index) * src_bit_size, - }; - const src_byte_off: i32 = @intCast(ptr_bit_off / limb_abi_bits * limb_abi_size); - const src_bit_off = ptr_bit_off % limb_abi_bits; - - const ptr_reg = try self.copyToTmpRegister(ptr_ty, ptr_mcv); - const ptr_lock = self.register_manager.lockRegAssumeUnused(ptr_reg); - defer self.register_manager.unlockReg(ptr_lock); - - const mat_src_mcv: MCValue = mat_src_mcv: switch (src_mcv) { - .register => if (src_bit_size > 64) { - const frame_index = try self.allocFrameIndex(.initSpill(src_ty, self.pt.zcu)); - try self.genSetMem(.{ .frame = frame_index }, 0, src_ty, src_mcv, .{}); - break :mat_src_mcv .{ .load_frame = .{ .index = frame_index } }; - } else src_mcv, - else => src_mcv, - }; - - var limb_i: u16 = 0; - while (limb_i * limb_abi_bits < src_bit_off + src_bit_size) : (limb_i += 1) { - const part_bit_off = if (limb_i == 0) src_bit_off else 0; - const part_bit_size = - @min(src_bit_off + src_bit_size - limb_i * limb_abi_bits, limb_abi_bits) - part_bit_off; - const limb_mem: Memory = .{ - .base = .{ .reg = ptr_reg }, - .mod = .{ .rm = .{ - .size = .fromSize(limb_abi_size), - .disp = src_byte_off + limb_i * limb_abi_size, - } }, - }; - - const part_mask = (@as(u64, std.math.maxInt(u64)) >> @intCast(64 - part_bit_size)) << - @intCast(part_bit_off); - const part_mask_not = part_mask ^ (@as(u64, std.math.maxInt(u64)) >> @intCast(64 - limb_abi_bits)); - if (limb_abi_size <= 4) { - try self.asmMemoryImmediate(.{ ._, .@"and" }, limb_mem, .u(part_mask_not)); - } else if (std.math.cast(i32, @as(i64, @bitCast(part_mask_not)))) |small| { - try self.asmMemoryImmediate(.{ ._, .@"and" }, limb_mem, .s(small)); - } else { - const part_mask_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp); - try self.asmRegisterImmediate(.{ ._, .mov }, part_mask_reg, .u(part_mask_not)); - try self.asmMemoryRegister(.{ ._, .@"and" }, limb_mem, part_mask_reg); - } - - if (src_bit_size <= 64) { - const tmp_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp); - const tmp_mcv = MCValue{ .register = tmp_reg }; - const tmp_lock = self.register_manager.lockRegAssumeUnused(tmp_reg); - defer self.register_manager.unlockReg(tmp_lock); - - try self.genSetReg(tmp_reg, limb_ty, mat_src_mcv, .{}); - switch (limb_i) { - 0 => try self.genShiftBinOpMir( - .{ ._l, .sh }, - limb_ty, - tmp_mcv, - .u8, - .{ .immediate = src_bit_off }, - ), - 1 => try self.genShiftBinOpMir( - .{ ._r, .sh }, - limb_ty, - tmp_mcv, - .u8, - .{ .immediate = limb_abi_bits - src_bit_off }, - ), - else => unreachable, - } - try self.genBinOpMir(.{ ._, .@"and" }, limb_ty, tmp_mcv, .{ .immediate = part_mask }); - try self.asmMemoryRegister( - .{ ._, .@"or" }, - limb_mem, - registerAlias(tmp_reg, limb_abi_size), - ); - } else if (src_bit_size <= 128 and src_bit_off == 0) { - const tmp_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp); - const tmp_mcv = MCValue{ .register = tmp_reg }; - const tmp_lock = self.register_manager.lockRegAssumeUnused(tmp_reg); - defer self.register_manager.unlockReg(tmp_lock); - - try self.genSetReg(tmp_reg, limb_ty, switch (limb_i) { - 0 => mat_src_mcv, - else => mat_src_mcv.address().offset(limb_i * limb_abi_size).deref(), - }, .{}); - try self.genBinOpMir(.{ ._, .@"and" }, limb_ty, tmp_mcv, .{ .immediate = part_mask }); - try self.asmMemoryRegister( - .{ ._, .@"or" }, - limb_mem, - registerAlias(tmp_reg, limb_abi_size), - ); - } else return self.fail("TODO: implement packed store of {f}", .{src_ty.fmt(pt)}); - } -} - fn store( self: *CodeGen, ptr_ty: Type, @@ -174776,35 +174842,6 @@ fn store( } } -fn airStore(self: *CodeGen, inst: Air.Inst.Index, safety: bool) !void { - const pt = self.pt; - const zcu = pt.zcu; - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; - - result: { - if (!safety and (try self.resolveInst(bin_op.rhs)) == .undef) break :result; - - try self.spillRegisters(&.{ .rdi, .rsi, .rcx }); - const reg_locks = self.register_manager.lockRegsAssumeUnused(3, .{ .rdi, .rsi, .rcx }); - defer for (reg_locks) |lock| self.register_manager.unlockReg(lock); - - const ptr_ty = self.typeOf(bin_op.lhs); - const ptr_info = ptr_ty.ptrInfo(zcu); - const is_packed = ptr_info.flags.vector_index != .none or ptr_info.packed_offset.host_size > 0; - if (is_packed) try self.spillEflagsIfOccupied(); - - const src_mcv = try self.resolveInst(bin_op.rhs); - const ptr_mcv = try self.resolveInst(bin_op.lhs); - - if (is_packed) { - try self.packedStore(ptr_ty, ptr_mcv, src_mcv); - } else { - try self.store(ptr_ty, ptr_mcv, src_mcv, .{ .safety = safety }); - } - } - return self.finishAir(inst, .none, .{ bin_op.lhs, bin_op.rhs, .none }); -} - fn genUnOp(self: *CodeGen, maybe_inst: ?Air.Inst.Index, tag: Air.Inst.Tag, src_air: Air.Inst.Ref) !MCValue { const pt = self.pt; const zcu = pt.zcu; @@ -180076,50 +180113,65 @@ fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void { } var mnem_size: struct { + op_has_size: std.StaticBitSet(4), + size: Memory.Size, used: bool, - size: ?Memory.Size, - fn use(size: *@This()) ?Memory.Size { + fn init(size: ?Memory.Size) @This() { + return .{ + .op_has_size = if (size) |_| .initFull() else .initEmpty(), + .size = size orelse .none, + .used = false, + }; + } + fn use(size: *@This(), op_index: usize) ?Memory.Size { + if (!size.op_has_size.isSet(op_index)) return null; size.used = true; return size.size; } - } = .{ - .used = false, - .size = if (prefix == .directive) - null - else if (std.mem.endsWith(u8, mnem_str, "b")) - .byte - else if (std.mem.endsWith(u8, mnem_str, "w")) - .word - else if (std.mem.endsWith(u8, mnem_str, "l")) - .dword - else if (std.mem.endsWith(u8, mnem_str, "q") and - (std.mem.indexOfScalar(u8, "vp", mnem_str[0]) == null or !std.mem.endsWith(u8, mnem_str, "dq"))) - .qword - else if (std.mem.endsWith(u8, mnem_str, "t")) - .tbyte - else - null, - }; + } = .init(if (prefix == .directive) + null + else if (std.mem.endsWith(u8, mnem_str, "b")) + .byte + else if (std.mem.endsWith(u8, mnem_str, "w")) + .word + else if (std.mem.endsWith(u8, mnem_str, "l")) + .dword + else if (std.mem.endsWith(u8, mnem_str, "q") and + (std.mem.indexOfScalar(u8, "vp", mnem_str[0]) == null or !std.mem.endsWith(u8, mnem_str, "dq"))) + .qword + else if (std.mem.endsWith(u8, mnem_str, "t")) + .tbyte + else + null); var mnem_tag = while (true) break std.meta.stringToEnum( encoder.Instruction.Mnemonic, - mnem_str[0 .. mnem_str.len - @intFromBool(mnem_size.size != null)], - ) orelse if (mnem_size.size) |_| { - mnem_size.size = null; + mnem_str[0 .. mnem_str.len - @intFromBool(mnem_size.size != .none)], + ) orelse if (mnem_size.size != .none) { + mnem_size = .init(null); continue; } else return self.fail("invalid mnemonic: '{s}'", .{mnem_str}); - if (@as(?Memory.Size, switch (mnem_tag) { - .clflush => .byte, - .fldcw, .fnstcw, .fstcw, .fnstsw, .fstsw => .word, - .fldenv, .fnstenv, .fstenv => .none, - .frstor, .fsave, .fnsave, .fxrstor, .fxrstor64, .fxsave, .fxsave64 => .none, - .invlpg => .none, - .invpcid => .xword, - .ldmxcsr, .stmxcsr, .vldmxcsr, .vstmxcsr => .dword, - else => null, - })) |fixed_mnem_size| { - if (mnem_size.size) |size| if (size != fixed_mnem_size) + fixed_mnem_size: { + const fixed_mnem_size: Memory.Size = switch (mnem_tag) { + .clflush => .byte, + .fldcw, .fnstcw, .fstcw, .fnstsw, .fstsw => .word, + .fldenv, .fnstenv, .fstenv => .none, + .frstor, .fsave, .fnsave, .fxrstor, .fxrstor64, .fxsave, .fxsave64 => .none, + .in => { + mnem_size.op_has_size.unset(0); + break :fixed_mnem_size; + }, + .invlpg => .none, + .invpcid => .xword, + .ldmxcsr, .stmxcsr, .vldmxcsr, .vstmxcsr => .dword, + .out => { + mnem_size.op_has_size.unset(1); + break :fixed_mnem_size; + }, + else => break :fixed_mnem_size, + }; + if (mnem_size.size != .none and mnem_size.size != fixed_mnem_size) return self.fail("invalid size: '{s}'", .{mnem_str}); - mnem_size.size = fixed_mnem_size; + mnem_size = .init(fixed_mnem_size); } var ops: [4]Operand = @splat(.none); @@ -180127,7 +180179,7 @@ fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void { var last_op = false; var op_it = std.mem.splitScalar(u8, mnem_it.rest(), ','); - next_op: for (&ops) |*op| { + next_op: for (&ops, 0..) |*op, op_index| { const op_str = while (!last_op) { const full_str = op_it.next() orelse break :next_op; const code_str = if (std.mem.indexOfScalar(u8, full_str, '#') orelse @@ -180149,13 +180201,13 @@ fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void { op.* = .{ .mem = .{ .base = .{ .reg = reg }, .mod = .{ .rm = .{ - .size = mnem_size.use() orelse + .size = mnem_size.use(op_index) orelse return self.fail("unknown size: '{s}'", .{op_str}), .disp = disp, } }, } }; } else { - if (mnem_size.use()) |size| if (reg.size().bitSize(self.target) != size.bitSize(self.target)) + if (mnem_size.use(op_index)) |size| if (reg.size().bitSize(self.target) != size.bitSize(self.target)) return self.fail("invalid register size: '{s}'", .{op_str}); op.* = .{ .reg = reg }; } @@ -180174,14 +180226,14 @@ fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void { else return self.fail("invalid modifier: '{s}'", .{modifier}), .register => |reg| if (std.mem.eql(u8, modifier, "")) - .{ .reg = if (mnem_size.use()) |size| reg.toSize(size, self.target) else reg } + .{ .reg = if (mnem_size.use(op_index)) |size| reg.toSize(size, self.target) else reg } else return self.fail("invalid modifier: '{s}'", .{modifier}), .memory => |addr| if (std.mem.eql(u8, modifier, "") or std.mem.eql(u8, modifier, "P")) .{ .mem = .{ .base = .{ .reg = .ds }, .mod = .{ .rm = .{ - .size = mnem_size.use() orelse + .size = mnem_size.use(op_index) orelse return self.fail("unknown size: '{s}'", .{op_str}), .disp = @intCast(@as(i64, @bitCast(addr))), } }, @@ -180192,7 +180244,7 @@ fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void { .{ .mem = .{ .base = .{ .reg = reg_off.reg }, .mod = .{ .rm = .{ - .size = mnem_size.use() orelse + .size = mnem_size.use(op_index) orelse return self.fail("unknown size: '{s}'", .{op_str}), .disp = reg_off.off, } }, @@ -180203,7 +180255,7 @@ fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void { .{ .mem = .{ .base = .{ .frame = frame_addr.index }, .mod = .{ .rm = .{ - .size = mnem_size.use() orelse + .size = mnem_size.use(op_index) orelse return self.fail("unknown size: '{s}'", .{op_str}), .disp = frame_addr.off, } }, @@ -180285,7 +180337,7 @@ fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void { else .none, .mod = .{ .rm = .{ - .size = mnem_size.use() orelse return self.fail("unknown size: '{s}'", .{op_str}), + .size = mnem_size.use(op_index) orelse return self.fail("unknown size: '{s}'", .{op_str}), .index = if (index_str.len > 0) parseRegName(index_str["%%".len..]) orelse return self.fail("invalid index register: '{s}'", .{op_str}) @@ -180338,14 +180390,14 @@ fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void { // convert from att syntax to intel syntax std.mem.reverse(Operand, ops[0..ops_len]); - if (!mnem_size.used) if (mnem_size.size) |size| { + if (mnem_size.size != .none and !mnem_size.used) { comptime var max_mnem_len: usize = 0; inline for (@typeInfo(encoder.Instruction.Mnemonic).@"enum".fields) |mnem| max_mnem_len = @max(mnem.name.len, max_mnem_len); var intel_mnem_buf: [max_mnem_len + 1]u8 = undefined; const intel_mnem_str = std.fmt.bufPrint(&intel_mnem_buf, "{s}{c}", .{ @tagName(mnem_tag), - @as(u8, switch (size) { + @as(u8, switch (mnem_size.size) { .byte => 'b', .word => 'w', .dword => 'd', @@ -180355,7 +180407,7 @@ fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void { }), }) catch unreachable; if (std.meta.stringToEnum(encoder.Instruction.Mnemonic, intel_mnem_str)) |intel_mnem_tag| mnem_tag = intel_mnem_tag; - }; + } const mnem_name = @tagName(mnem_tag); const mnem_fixed_tag: Mir.Inst.FixedTag = if (prefix == .directive) .{ ._, .pseudo } @@ -184633,6 +184685,8 @@ fn airAggregateInit(self: *CodeGen, inst: Air.Inst.Index) !void { if (result_ty.isVector(zcu) and elem_ty.toIntern() == .bool_type) { const result_size: u32 = @intCast(result_ty.abiSize(zcu)); const dst_reg = try self.register_manager.allocReg(inst, abi.RegisterClass.gp); + const dst_lock = self.register_manager.lockRegAssumeUnused(dst_reg); + defer self.register_manager.unlockReg(dst_lock); try self.asmRegisterRegister( .{ ._, .xor }, registerAlias(dst_reg, @min(result_size, 4)), @@ -186940,6 +186994,10 @@ const Temp = struct { assert(src_regs.len - part_index == std.math.divCeil(u32, src_abi_size, 8) catch unreachable); break :part_ty .u64; }, + .tuple_type => |tuple_type| { + assert(tuple_type.types.len == src_regs.len); + break :part_ty .fromInterned(tuple_type.types.get(ip)[part_index]); + }, }; const part_size: u31 = @intCast(part_ty.abiSize(zcu)); const src_rc = src_reg.class(); @@ -192076,6 +192134,8 @@ const Select = struct { exact_bool_vec: u16, ptr_any_bool_vec, ptr_bool_vec: Memory.Size, + ptr_any_bool_vec_elem, + ptr_bool_vec_elem: Memory.Size, remainder_bool_vec: OfIsSizes, exact_remainder_bool_vec: struct { of: Memory.Size, is: u16 }, signed_int_vec: Memory.Size, @@ -192178,6 +192238,22 @@ const Select = struct { .vector_type => |vector_type| vector_type.child == .bool_type and size.bitSize(cg.target) >= vector_type.len, else => false, }, + .ptr_any_bool_vec_elem => { + const ptr_info = ty.ptrInfo(zcu); + return switch (ptr_info.flags.vector_index) { + .none => false, + .runtime => unreachable, + else => ptr_info.child == .bool_type, + }; + }, + .ptr_bool_vec_elem => |size| { + const ptr_info = ty.ptrInfo(zcu); + return switch (ptr_info.flags.vector_index) { + .none => false, + .runtime => unreachable, + else => ptr_info.child == .bool_type and size.bitSize(cg.target) >= ptr_info.packed_offset.host_size, + }; + }, .remainder_bool_vec => |of_is| ty.isVector(zcu) and ty.scalarType(zcu).toIntern() == .bool_type and of_is.is.bitSize(cg.target) >= (ty.vectorLen(zcu) - 1) % of_is.of.bitSize(cg.target) + 1, .exact_remainder_bool_vec => |of_is| ty.isVector(zcu) and ty.scalarType(zcu).toIntern() == .bool_type and @@ -193171,7 +193247,7 @@ const Select = struct { ref: Ref, scale: Memory.Scale = .@"1", } = .{ .ref = .none }, - unused: u3 = 0, + unused: u2 = 0, }, imm: i32 = 0, @@ -193184,9 +193260,9 @@ const Select = struct { lea, mem, }; - const Adjust = packed struct(u10) { + const Adjust = packed struct(u11) { sign: enum(u1) { neg, pos }, - lhs: enum(u5) { + lhs: enum(u6) { none, ptr_size, ptr_bit_size, @@ -193208,6 +193284,7 @@ const Select = struct { src0_elem_size, dst0_elem_size, src0_elem_size_mul_src1, + vector_index, src1, src1_sub_bit_size, log2_src0_elem_size, @@ -193278,9 +193355,13 @@ const Select = struct { const sub_src0_elem_size: Adjust = .{ .sign = .neg, .lhs = .src0_elem_size, .op = .mul, .rhs = .@"1" }; const add_src0_elem_size_mul_src1: Adjust = .{ .sign = .pos, .lhs = .src0_elem_size_mul_src1, .op = .mul, .rhs = .@"1" }; const sub_src0_elem_size_mul_src1: Adjust = .{ .sign = .neg, .lhs = .src0_elem_size_mul_src1, .op = .mul, .rhs = .@"1" }; + const add_vector_index: Adjust = .{ .sign = .pos, .lhs = .vector_index, .op = .mul, .rhs = .@"1" }; + const add_vector_index_rem_32: Adjust = .{ .sign = .pos, .lhs = .vector_index, .op = .rem_8_mul, .rhs = .@"4" }; + const add_vector_index_div_8_down_4: Adjust = .{ .sign = .pos, .lhs = .vector_index, .op = .div_8_down, .rhs = .@"4" }; const add_dst0_elem_size: Adjust = .{ .sign = .pos, .lhs = .dst0_elem_size, .op = .mul, .rhs = .@"1" }; const sub_dst0_elem_size: Adjust = .{ .sign = .neg, .lhs = .dst0_elem_size, .op = .mul, .rhs = .@"1" }; const add_src1_div_8_down_4: Adjust = .{ .sign = .pos, .lhs = .src1, .op = .div_8_down, .rhs = .@"4" }; + const add_src1: Adjust = .{ .sign = .pos, .lhs = .src1, .op = .mul, .rhs = .@"1" }; const add_src1_rem_32: Adjust = .{ .sign = .pos, .lhs = .src1, .op = .rem_8_mul, .rhs = .@"4" }; const add_src1_rem_64: Adjust = .{ .sign = .pos, .lhs = .src1, .op = .rem_8_mul, .rhs = .@"8" }; const add_src1_sub_bit_size: Adjust = .{ .sign = .pos, .lhs = .src1_sub_bit_size, .op = .mul, .rhs = .@"1" }; @@ -194163,6 +194244,10 @@ const Select = struct { .dst0_elem_size => @intCast(Select.Operand.Ref.dst0.typeOf(s).elemType2(s.cg.pt.zcu).abiSize(s.cg.pt.zcu)), .src0_elem_size_mul_src1 => @intCast(Select.Operand.Ref.src0.typeOf(s).elemType2(s.cg.pt.zcu).abiSize(s.cg.pt.zcu) * Select.Operand.Ref.src1.valueOf(s).immediate), + .vector_index => switch (op.flags.base.ref.typeOf(s).ptrInfo(s.cg.pt.zcu).flags.vector_index) { + .none, .runtime => unreachable, + else => |vector_index| @intFromEnum(vector_index), + }, .src1 => @intCast(Select.Operand.Ref.src1.valueOf(s).immediate), .src1_sub_bit_size => @as(SignedImm, @intCast(Select.Operand.Ref.src1.valueOf(s).immediate)) - @as(SignedImm, @intCast(s.cg.nonBoolScalarBitSize(op.flags.base.ref.typeOf(s)))), diff --git a/src/codegen/aarch64/Assemble.zig b/src/codegen/aarch64/Assemble.zig index 4b5aa8e04f..5cf9c2da3c 100644 --- a/src/codegen/aarch64/Assemble.zig +++ b/src/codegen/aarch64/Assemble.zig @@ -42,8 +42,11 @@ fn zonCast(comptime Result: type, zon_value: anytype, symbols: anytype) Result { .@"struct" => |zon_struct| switch (@typeInfo(Result)) { .pointer => |result_pointer| { comptime assert(result_pointer.size == .slice and result_pointer.is_const); - var elems: [zon_value.len]result_pointer.child = undefined; - inline for (&elems, zon_value) |*elem, zon_elem| elem.* = zonCast(result_pointer.child, zon_elem, symbols); + const elems = comptime blk: { + var temp_elems: [zon_value.len]result_pointer.child = undefined; + for (&temp_elems, zon_value) |*elem, zon_elem| elem.* = zonCast(result_pointer.child, zon_elem, symbols); + break :blk temp_elems; + }; return &elems; }, .@"struct" => |result_struct| { diff --git a/src/codegen/aarch64/Select.zig b/src/codegen/aarch64/Select.zig index b4550b28a5..48fc1911b8 100644 --- a/src/codegen/aarch64/Select.zig +++ b/src/codegen/aarch64/Select.zig @@ -5821,29 +5821,21 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory, if (air.next()) |next_air_tag| continue :air_tag next_air_tag; }, .unwrap_errunion_err_ptr => { - if (isel.live_values.fetchRemove(air.inst_index)) |error_ptr_vi| unused: { - defer error_ptr_vi.value.deref(isel); + if (isel.live_values.fetchRemove(air.inst_index)) |error_vi| { + defer error_vi.value.deref(isel); const ty_op = air.data(air.inst_index).ty_op; - switch (codegen.errUnionErrorOffset( - isel.air.typeOf(ty_op.operand, ip).childType(zcu).errorUnionPayload(zcu), - zcu, - )) { - 0 => try error_ptr_vi.value.move(isel, ty_op.operand), - else => |error_offset| { - const error_ptr_ra = try error_ptr_vi.value.defReg(isel) orelse break :unused; - const error_union_ptr_vi = try isel.use(ty_op.operand); - const error_union_ptr_mat = try error_union_ptr_vi.matReg(isel); - const lo12: u12 = @truncate(error_offset >> 0); - const hi12: u12 = @intCast(error_offset >> 12); - if (hi12 > 0) try isel.emit(.add( - error_ptr_ra.x(), - if (lo12 > 0) error_ptr_ra.x() else error_union_ptr_mat.ra.x(), - .{ .shifted_immediate = .{ .immediate = hi12, .lsl = .@"12" } }, - )); - if (lo12 > 0) try isel.emit(.add(error_ptr_ra.x(), error_union_ptr_mat.ra.x(), .{ .immediate = lo12 })); - try error_union_ptr_mat.finish(isel); - }, - } + const error_union_ptr_ty = isel.air.typeOf(ty_op.operand, ip); + const error_union_ptr_info = error_union_ptr_ty.ptrInfo(zcu); + const error_union_ptr_vi = try isel.use(ty_op.operand); + const error_union_ptr_mat = try error_union_ptr_vi.matReg(isel); + _ = try error_vi.value.load(isel, ty_op.ty.toType(), error_union_ptr_mat.ra, .{ + .offset = codegen.errUnionErrorOffset( + ZigType.fromInterned(error_union_ptr_info.child).errorUnionPayload(zcu), + zcu, + ), + .@"volatile" = error_union_ptr_info.flags.is_volatile, + }); + try error_union_ptr_mat.finish(isel); } if (air.next()) |next_air_tag| continue :air_tag next_air_tag; }, @@ -8011,6 +8003,7 @@ pub fn layout( while (save_index < saves.len) { if (save_index + 2 <= saves.len and saves[save_index + 1].needs_restore and saves[save_index + 0].class == saves[save_index + 1].class and + saves[save_index + 0].size == saves[save_index + 1].size and saves[save_index + 0].offset + saves[save_index + 0].size == saves[save_index + 1].offset) { try isel.emit(.ldp( @@ -8317,7 +8310,7 @@ fn elemPtr( }), 2 => { const shift: u6 = @intCast(@ctz(elem_size)); - const temp_ra = temp_ra: switch (op) { + const temp_ra, const free_temp_ra = temp_ra: switch (op) { .add => switch (base_ra) { else => { const temp_ra = try isel.allocIntReg(); @@ -8326,7 +8319,7 @@ fn elemPtr( .register = temp_ra.x(), .shift = .{ .lsl = shift }, } })); - break :temp_ra temp_ra; + break :temp_ra .{ temp_ra, true }; }, .zr => { if (shift > 0) try isel.emit(.ubfm(elem_ptr_ra.x(), elem_ptr_ra.x(), .{ @@ -8334,7 +8327,7 @@ fn elemPtr( .immr = -%shift, .imms = ~shift, })); - break :temp_ra elem_ptr_ra; + break :temp_ra .{ elem_ptr_ra, false }; }, }, .sub => { @@ -8344,10 +8337,10 @@ fn elemPtr( .register = temp_ra.x(), .shift = .{ .lsl = shift }, } })); - break :temp_ra temp_ra; + break :temp_ra .{ temp_ra, true }; }, }; - defer if (temp_ra != elem_ptr_ra) isel.freeReg(temp_ra); + defer if (free_temp_ra) isel.freeReg(temp_ra); try isel.emit(.add(temp_ra.x(), index_mat.ra.x(), .{ .shifted_register = .{ .register = index_mat.ra.x(), .shift = .{ .lsl = @intCast(63 - @clz(elem_size) - shift) }, @@ -9276,7 +9269,14 @@ pub const Value = struct { part_offset -= part_size; var wrapped_res_part_it = res_vi.field(ty, part_offset, part_size); const wrapped_res_part_vi = try wrapped_res_part_it.only(isel); - const wrapped_res_part_ra = try wrapped_res_part_vi.?.defReg(isel) orelse if (need_carry) .zr else continue; + const wrapped_res_part_ra = wrapped_res_part_ra: { + const overflow_ra_lock: RegLock = switch (opts.overflow) { + .ra => |ra| isel.lockReg(ra), + else => .empty, + }; + defer overflow_ra_lock.unlock(isel); + break :wrapped_res_part_ra try wrapped_res_part_vi.?.defReg(isel) orelse if (need_carry) .zr else continue; + }; const unwrapped_res_part_ra = unwrapped_res_part_ra: { if (!need_wrap) break :unwrapped_res_part_ra wrapped_res_part_ra; if (int_info.bits % 32 == 0) { diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig index 5c683a965a..bd2c7bd022 100644 --- a/src/codegen/llvm.zig +++ b/src/codegen/llvm.zig @@ -2508,7 +2508,7 @@ pub const Object = struct { o.debug_compile_unit, // Scope 0, // Line .none, // Underlying type - ty.abiSize(zcu) * 8, + layout.payload_size * 8, (ty.abiAlignment(zcu).toByteUnits() orelse 0) * 8, try o.builder.metadataTuple(fields.items), ); @@ -9761,6 +9761,7 @@ pub const FuncGen = struct { const ptr = try fg.resolveInst(ty_op.operand); elide: { + if (ptr_info.flags.alignment != .none) break :elide; if (!isByRef(Type.fromInterned(ptr_info.child), zcu)) break :elide; if (!canElideLoad(fg, body_tail)) break :elide; return ptr; diff --git a/src/fmt.zig b/src/fmt.zig index 1287334132..4a3c321877 100644 --- a/src/fmt.zig +++ b/src/fmt.zig @@ -156,7 +156,7 @@ pub fn run(gpa: Allocator, arena: Allocator, args: []const []const u8) !void { } if (input_files.items.len == 0) { - fatal("expected at least one source file argument", .{}); + fatal("expected at least one file or directory argument", .{}); } var stdout_buffer: [4096]u8 = undefined; diff --git a/src/libs/libcxx.zig b/src/libs/libcxx.zig index 40da4dd92f..3c296d477f 100644 --- a/src/libs/libcxx.zig +++ b/src/libs/libcxx.zig @@ -9,25 +9,30 @@ const trace = @import("../tracy.zig").trace; const Module = @import("../Package/Module.zig"); const libcxxabi_files = [_][]const u8{ - "src/abort_message.cpp", "src/cxa_aux_runtime.cpp", "src/cxa_default_handlers.cpp", "src/cxa_demangle.cpp", - "src/cxa_exception.cpp", "src/cxa_exception_storage.cpp", "src/cxa_guard.cpp", "src/cxa_handlers.cpp", - "src/cxa_noexception.cpp", - "src/cxa_personality.cpp", - "src/cxa_thread_atexit.cpp", "src/cxa_vector.cpp", "src/cxa_virtual.cpp", - "src/fallback_malloc.cpp", - "src/private_typeinfo.cpp", + "src/stdlib_exception.cpp", - "src/stdlib_new_delete.cpp", "src/stdlib_stdexcept.cpp", "src/stdlib_typeinfo.cpp", + "src/stdlib_new_delete.cpp", + + "src/abort_message.cpp", + "src/fallback_malloc.cpp", + "src/private_typeinfo.cpp", + + "src/cxa_exception.cpp", + "src/cxa_personality.cpp", + + "src/cxa_noexception.cpp", + + "src/cxa_thread_atexit.cpp", }; const libcxx_base_files = [_][]const u8{ @@ -388,17 +393,20 @@ pub fn buildLibCxxAbi(comp: *Compilation, prog_node: std.Progress.Node) BuildErr var c_source_files = try std.array_list.Managed(Compilation.CSourceFile).initCapacity(arena, libcxxabi_files.len); for (libcxxabi_files) |cxxabi_src| { - if (!comp.config.any_non_single_threaded and std.mem.startsWith(u8, cxxabi_src, "src/cxa_thread_atexit.cpp")) + if (!comp.config.any_non_single_threaded and std.mem.eql(u8, cxxabi_src, "src/cxa_thread_atexit.cpp")) continue; if (target.os.tag == .wasi and (std.mem.eql(u8, cxxabi_src, "src/cxa_exception.cpp") or std.mem.eql(u8, cxxabi_src, "src/cxa_personality.cpp"))) continue; + if (target.os.tag != .wasi and std.mem.eql(u8, cxxabi_src, "src/cxa_noexception.cpp")) + continue; var cflags = std.array_list.Managed([]const u8).init(arena); try addCxxArgs(comp, arena, &cflags); try cflags.append("-DNDEBUG"); + try cflags.append("-D_LIBCPP_BUILDING_LIBRARY"); try cflags.append("-D_LIBCXXABI_BUILDING_LIBRARY"); if (!comp.config.any_non_single_threaded) { try cflags.append("-D_LIBCXXABI_HAS_NO_THREADS"); @@ -509,19 +517,19 @@ pub fn addCxxArgs( try cflags.append(try std.fmt.allocPrint(arena, "-D_LIBCPP_ABI_NAMESPACE=__{d}", .{ abi_version, })); - try cflags.append(try std.fmt.allocPrint(arena, "-D_LIBCPP_HAS_{s}THREADS", .{ - if (!comp.config.any_non_single_threaded) "NO_" else "", + try cflags.append(try std.fmt.allocPrint(arena, "-D_LIBCPP_HAS_THREADS={d}", .{ + @as(u1, if (comp.config.any_non_single_threaded) 1 else 0), })); try cflags.append("-D_LIBCPP_HAS_MONOTONIC_CLOCK"); try cflags.append("-D_LIBCPP_HAS_TERMINAL"); - try cflags.append(try std.fmt.allocPrint(arena, "-D_LIBCPP_HAS_{s}MUSL_LIBC", .{ - if (!target.abi.isMusl()) "NO_" else "", + try cflags.append(try std.fmt.allocPrint(arena, "-D_LIBCPP_HAS_MUSL_LIBC={d}", .{ + @as(u1, if (target.abi.isMusl()) 1 else 0), })); try cflags.append("-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS"); try cflags.append("-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS"); - try cflags.append("-D_LIBCPP_HAS_NO_VENDOR_AVAILABILITY_ANNOTATIONS"); - try cflags.append(try std.fmt.allocPrint(arena, "-D_LIBCPP_HAS_{s}FILESYSTEM", .{ - if (target.os.tag == .wasi) "NO_" else "", + try cflags.append("-D_LIBCPP_HAS_VENDOR_AVAILABILITY_ANNOTATIONS=0"); + try cflags.append(try std.fmt.allocPrint(arena, "-D_LIBCPP_HAS_FILESYSTEM={d}", .{ + @as(u1, if (target.os.tag == .wasi) 0 else 1), })); try cflags.append("-D_LIBCPP_HAS_RANDOM_DEVICE"); try cflags.append("-D_LIBCPP_HAS_LOCALIZATION"); @@ -545,7 +553,7 @@ pub fn addCxxArgs( if (target.isGnuLibC()) { // glibc 2.16 introduced aligned_alloc if (target.os.versionRange().gnuLibCVersion().?.order(.{ .major = 2, .minor = 16, .patch = 0 }) == .lt) { - try cflags.append("-D_LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION"); + try cflags.append("-D_LIBCPP_HAS_LIBRARY_ALIGNED_ALLOCATION=0"); } } try cflags.append("-D_LIBCPP_ENABLE_CXX17_REMOVED_UNEXPECTED_FUNCTIONS"); diff --git a/src/libs/musl.zig b/src/libs/musl.zig index 750252aa56..be7b0502f7 100644 --- a/src/libs/musl.zig +++ b/src/libs/musl.zig @@ -627,6 +627,7 @@ const src_files = [_][]const u8{ "musl/src/fenv/hexagon/fenv.S", "musl/src/fenv/i386/fenv.s", "musl/src/fenv/loongarch64/fenv.S", + "musl/src/fenv/loongarch64/fenv-sf.c", "musl/src/fenv/m68k/fenv.c", "musl/src/fenv/mips64/fenv.S", "musl/src/fenv/mips64/fenv-sf.c", diff --git a/src/link/Elf/ZigObject.zig b/src/link/Elf/ZigObject.zig index 20e5b3d2e3..c9ba0cb1b3 100644 --- a/src/link/Elf/ZigObject.zig +++ b/src/link/Elf/ZigObject.zig @@ -1140,7 +1140,109 @@ fn getNavShdrIndex( const ptr_size = elf_file.ptrWidthBytes(); const ip = &zcu.intern_pool; const nav_val = zcu.navValue(nav_index); - if (ip.isFunctionType(nav_val.typeOf(zcu).toIntern())) { + const is_func = ip.isFunctionType(nav_val.typeOf(zcu).toIntern()); + if (ip.getNav(nav_index).getLinkSection().unwrap()) |@"linksection"| { + const section_name = @"linksection".toSlice(ip); + if (elf_file.sectionByName(section_name)) |osec| { + if (is_func) { + elf_file.sections.items(.shdr)[osec].sh_flags |= elf.SHF_EXECINSTR; + } else { + elf_file.sections.items(.shdr)[osec].sh_flags |= elf.SHF_WRITE; + } + return osec; + } + const osec = try elf_file.addSection(.{ + .type = elf.SHT_PROGBITS, + .flags = elf.SHF_ALLOC | @as(u64, if (is_func) elf.SHF_EXECINSTR else elf.SHF_WRITE), + .name = try elf_file.insertShString(section_name), + .addralign = 1, + }); + const section_index = try self.addSectionSymbol(gpa, try self.addString(gpa, section_name), osec); + if (std.mem.eql(u8, section_name, ".text")) { + elf_file.sections.items(.shdr)[osec].sh_flags = elf.SHF_ALLOC | elf.SHF_EXECINSTR; + self.text_index = section_index; + } else if (std.mem.startsWith(u8, section_name, ".text.")) { + elf_file.sections.items(.shdr)[osec].sh_flags = elf.SHF_ALLOC | elf.SHF_EXECINSTR; + } else if (std.mem.eql(u8, section_name, ".rodata")) { + elf_file.sections.items(.shdr)[osec].sh_flags = elf.SHF_ALLOC; + self.rodata_index = section_index; + } else if (std.mem.startsWith(u8, section_name, ".rodata.")) { + elf_file.sections.items(.shdr)[osec].sh_flags = elf.SHF_ALLOC; + } else if (std.mem.eql(u8, section_name, ".data.rel.ro")) { + elf_file.sections.items(.shdr)[osec].sh_flags = elf.SHF_ALLOC | elf.SHF_WRITE; + self.data_relro_index = section_index; + } else if (std.mem.eql(u8, section_name, ".data")) { + elf_file.sections.items(.shdr)[osec].sh_flags = elf.SHF_ALLOC | elf.SHF_WRITE; + self.data_index = section_index; + } else if (std.mem.startsWith(u8, section_name, ".data.")) { + elf_file.sections.items(.shdr)[osec].sh_flags = elf.SHF_ALLOC | elf.SHF_WRITE; + } else if (std.mem.eql(u8, section_name, ".bss")) { + const shdr = &elf_file.sections.items(.shdr)[osec]; + shdr.sh_type = elf.SHT_NOBITS; + shdr.sh_flags = elf.SHF_ALLOC | elf.SHF_WRITE; + self.bss_index = section_index; + } else if (std.mem.startsWith(u8, section_name, ".bss.")) { + const shdr = &elf_file.sections.items(.shdr)[osec]; + shdr.sh_type = elf.SHT_NOBITS; + shdr.sh_flags = elf.SHF_ALLOC | elf.SHF_WRITE; + } else if (std.mem.eql(u8, section_name, ".tdata")) { + elf_file.sections.items(.shdr)[osec].sh_flags = elf.SHF_ALLOC | elf.SHF_WRITE | elf.SHF_TLS; + self.tdata_index = section_index; + } else if (std.mem.startsWith(u8, section_name, ".tdata.")) { + elf_file.sections.items(.shdr)[osec].sh_flags = elf.SHF_ALLOC | elf.SHF_WRITE | elf.SHF_TLS; + } else if (std.mem.eql(u8, section_name, ".tbss")) { + const shdr = &elf_file.sections.items(.shdr)[osec]; + shdr.sh_type = elf.SHT_NOBITS; + shdr.sh_flags = elf.SHF_ALLOC | elf.SHF_WRITE | elf.SHF_TLS; + self.tbss_index = section_index; + } else if (std.mem.startsWith(u8, section_name, ".tbss.")) { + const shdr = &elf_file.sections.items(.shdr)[osec]; + shdr.sh_type = elf.SHT_NOBITS; + shdr.sh_flags = elf.SHF_ALLOC | elf.SHF_WRITE | elf.SHF_TLS; + } else if (std.mem.eql(u8, section_name, ".eh_frame")) { + const target = &zcu.navFileScope(nav_index).mod.?.resolved_target.result; + const shdr = &elf_file.sections.items(.shdr)[osec]; + if (target.cpu.arch == .x86_64) shdr.sh_type = elf.SHT_X86_64_UNWIND; + shdr.sh_flags = elf.SHF_ALLOC; + self.eh_frame_index = section_index; + } else if (std.mem.eql(u8, section_name, ".debug_info")) { + elf_file.sections.items(.shdr)[osec].sh_flags = 0; + self.debug_info_index = section_index; + } else if (std.mem.eql(u8, section_name, ".debug_abbrev")) { + elf_file.sections.items(.shdr)[osec].sh_flags = 0; + self.debug_abbrev_index = section_index; + } else if (std.mem.eql(u8, section_name, ".debug_aranges")) { + elf_file.sections.items(.shdr)[osec].sh_flags = 0; + self.debug_aranges_index = section_index; + } else if (std.mem.eql(u8, section_name, ".debug_str")) { + elf_file.sections.items(.shdr)[osec].sh_flags = 0; + self.debug_str_index = section_index; + } else if (std.mem.eql(u8, section_name, ".debug_line")) { + elf_file.sections.items(.shdr)[osec].sh_flags = 0; + self.debug_line_index = section_index; + } else if (std.mem.eql(u8, section_name, ".debug_line_str")) { + elf_file.sections.items(.shdr)[osec].sh_flags = 0; + self.debug_line_str_index = section_index; + } else if (std.mem.eql(u8, section_name, ".debug_loclists")) { + elf_file.sections.items(.shdr)[osec].sh_flags = 0; + self.debug_loclists_index = section_index; + } else if (std.mem.eql(u8, section_name, ".debug_rnglists")) { + elf_file.sections.items(.shdr)[osec].sh_flags = 0; + self.debug_rnglists_index = section_index; + } else if (std.mem.startsWith(u8, section_name, ".debug")) { + elf_file.sections.items(.shdr)[osec].sh_flags = 0; + } else if (std.mem.eql(u8, section_name, ".init_array") or std.mem.startsWith(u8, section_name, ".init_array.")) { + const shdr = &elf_file.sections.items(.shdr)[osec]; + shdr.sh_type = elf.SHT_INIT_ARRAY; + shdr.sh_flags = elf.SHF_ALLOC | elf.SHF_WRITE; + } else if (std.mem.eql(u8, section_name, ".fini_array") or std.mem.startsWith(u8, section_name, ".fini_array.")) { + const shdr = &elf_file.sections.items(.shdr)[osec]; + shdr.sh_type = elf.SHT_FINI_ARRAY; + shdr.sh_flags = elf.SHF_ALLOC | elf.SHF_WRITE; + } + return osec; + } + if (is_func) { if (self.text_index) |symbol_index| return self.symbol(symbol_index).outputShndx(elf_file).?; const osec = try elf_file.addSection(.{ diff --git a/src/link/Lld.zig b/src/link/Lld.zig index 48872f7077..1868270502 100644 --- a/src/link/Lld.zig +++ b/src/link/Lld.zig @@ -505,7 +505,7 @@ fn coffLink(lld: *Lld, arena: Allocator) !void { try argv.append(try allocPrint(arena, "-OUT:{s}", .{full_out_path})); if (comp.emit_implib) |raw_emit_path| { - const path = try comp.resolveEmitPathFlush(arena, .temp, raw_emit_path); + const path = try comp.resolveEmitPathFlush(arena, .artifact, raw_emit_path); try argv.append(try allocPrint(arena, "-IMPLIB:{f}", .{path})); } diff --git a/src/main.zig b/src/main.zig index 02b1b8f84b..036adbf852 100644 --- a/src/main.zig +++ b/src/main.zig @@ -87,6 +87,7 @@ const normal_usage = \\ build-lib Create library from source or object files \\ build-obj Create object from source or object files \\ test Perform unit testing + \\ test-obj Create object for unit testing \\ run Create executable and run immediately \\ \\ ast-check Look for simple compile errors in any set of files @@ -538,8 +539,8 @@ const usage_build_generic = \\ -funwind-tables Always produce unwind table entries for all functions \\ -fasync-unwind-tables Always produce asynchronous unwind table entries for all functions \\ -fno-unwind-tables Never produce unwind table entries - \\ -ferror-tracing Enable error tracing in ReleaseFast mode - \\ -fno-error-tracing Disable error tracing in Debug and ReleaseSafe mode + \\ -ferror-tracing Enable error tracing in release builds + \\ -fno-error-tracing Disable error tracing in debug builds \\ -fsingle-threaded Code assumes there is only one thread \\ -fno-single-threaded Code may not assume there is only one thread \\ -fstrip Omit debug symbols @@ -1063,8 +1064,8 @@ fn buildOutputType( } } else if (mem.eql(u8, arg, "--dep")) { var it = mem.splitScalar(u8, args_iter.nextOrFatal(), '='); - const key = it.next().?; - const value = it.next() orelse key; + const key = it.first(); + const value = if (it.peek() != null) it.rest() else key; if (mem.eql(u8, key, "std") and !mem.eql(u8, value, "std")) { fatal("unable to import as '{s}': conflicts with builtin module", .{ key, @@ -1083,8 +1084,8 @@ fn buildOutputType( }); } else if (mem.startsWith(u8, arg, "-M")) { var it = mem.splitScalar(u8, arg["-M".len..], '='); - const mod_name = it.next().?; - const root_src_orig = it.next(); + const mod_name = it.first(); + const root_src_orig = if (it.peek() != null) it.rest() else null; try handleModArg( arena, mod_name, @@ -3394,6 +3395,14 @@ fn buildOutputType( var file_system_inputs: std.ArrayListUnmanaged(u8) = .empty; defer file_system_inputs.deinit(gpa); + // Deduplicate rpath entries + var rpath_dedup = std.StringArrayHashMapUnmanaged(void){}; + for (create_module.rpath_list.items) |rpath| { + try rpath_dedup.put(arena, rpath, {}); + } + create_module.rpath_list.clearRetainingCapacity(); + try create_module.rpath_list.appendSlice(arena, rpath_dedup.keys()); + var create_diag: Compilation.CreateDiagnostic = undefined; const comp = Compilation.create(gpa, arena, &create_diag, .{ .dirs = dirs, diff --git a/src/target.zig b/src/target.zig index ee9d39fbf3..f8201d691b 100644 --- a/src/target.zig +++ b/src/target.zig @@ -236,7 +236,7 @@ pub fn hasLldSupport(ofmt: std.Target.ObjectFormat) bool { pub fn selfHostedBackendIsAsRobustAsLlvm(target: *const std.Target) bool { if (target.cpu.arch.isSpirV()) return true; if (target.cpu.arch == .x86_64 and target.ptrBitWidth() == 64) { - if (target.os.tag == .netbsd or target.os.tag == .openbsd) { + if (target.os.tag.isBSD()) { // Self-hosted linker needs work: https://github.com/ziglang/zig/issues/24341 return false; } diff --git a/src/translate_c.zig b/src/translate_c.zig index d481643e35..41a1a040a9 100644 --- a/src/translate_c.zig +++ b/src/translate_c.zig @@ -7,10 +7,10 @@ const meta = std.meta; const clang = @import("clang.zig"); const aro = @import("aro"); const CToken = aro.Tokenizer.Token; -const Node = ast.Node; -const Tag = Node.Tag; const common = @import("aro_translate_c"); const ast = common.ast; +const Node = ast.Node; +const Tag = Node.Tag; const Error = common.Error; const MacroProcessingError = common.MacroProcessingError; const TypeError = common.TypeError; @@ -5985,10 +5985,11 @@ fn parseCCondExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!Node { } _ = m.next(); + const cond_body = try macroIntToBool(c, node); const then_body = try parseCOrExpr(c, m, scope); try m.skip(c, .colon); const else_body = try parseCCondExpr(c, m, scope); - return Tag.@"if".create(c.arena, .{ .cond = node, .then = then_body, .@"else" = else_body }); + return Tag.@"if".create(c.arena, .{ .cond = cond_body, .then = then_body, .@"else" = else_body }); } fn parseCOrExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!Node { diff --git a/test/behavior/cast.zig b/test/behavior/cast.zig index 7eee20e3e0..51ce6c2c6b 100644 --- a/test/behavior/cast.zig +++ b/test/behavior/cast.zig @@ -607,26 +607,212 @@ test "@intCast on vector" { const S = struct { fn doTheTest() !void { - // Upcast (implicit, equivalent to @intCast) - var up0: @Vector(2, u8) = [_]u8{ 0x55, 0xaa }; - _ = &up0; - const up1: @Vector(2, u16) = up0; - const up2: @Vector(2, u32) = up0; - const up3: @Vector(2, u64) = up0; - // Downcast (safety-checked) - var down0 = up3; - _ = &down0; - const down1: @Vector(2, u32) = @intCast(down0); - const down2: @Vector(2, u16) = @intCast(down0); - const down3: @Vector(2, u8) = @intCast(down0); + { + // Upcast (implicit, equivalent to @intCast) + var up0: @Vector(2, u8) = .{ 0x55, 0xaa }; + _ = &up0; + const up1: @Vector(2, u16) = up0; + const up2: @Vector(2, u32) = up0; + const up3: @Vector(2, u64) = up0; - try expect(mem.eql(u16, &@as([2]u16, up1), &[2]u16{ 0x55, 0xaa })); - try expect(mem.eql(u32, &@as([2]u32, up2), &[2]u32{ 0x55, 0xaa })); - try expect(mem.eql(u64, &@as([2]u64, up3), &[2]u64{ 0x55, 0xaa })); + try expect(mem.eql(u16, &@as([2]u16, up1), &[2]u16{ 0x55, 0xaa })); + try expect(mem.eql(u32, &@as([2]u32, up2), &[2]u32{ 0x55, 0xaa })); + try expect(mem.eql(u64, &@as([2]u64, up3), &[2]u64{ 0x55, 0xaa })); - try expect(mem.eql(u32, &@as([2]u32, down1), &[2]u32{ 0x55, 0xaa })); - try expect(mem.eql(u16, &@as([2]u16, down2), &[2]u16{ 0x55, 0xaa })); - try expect(mem.eql(u8, &@as([2]u8, down3), &[2]u8{ 0x55, 0xaa })); + { + // Downcast (safety-checked) + const down2: @Vector(2, u32) = @intCast(up3); + const down1: @Vector(2, u16) = @intCast(up3); + const down0: @Vector(2, u8) = @intCast(up3); + + try expect(mem.eql(u32, &@as([2]u32, down2), &[2]u32{ 0x55, 0xaa })); + try expect(mem.eql(u16, &@as([2]u16, down1), &[2]u16{ 0x55, 0xaa })); + try expect(mem.eql(u8, &@as([2]u8, down0), &[2]u8{ 0x55, 0xaa })); + } + + { + // Downcast (safety-checked) + const down1: @Vector(2, u16) = @intCast(up2); + const down0: @Vector(2, u8) = @intCast(up2); + + try expect(mem.eql(u16, &@as([2]u16, down1), &[2]u16{ 0x55, 0xaa })); + try expect(mem.eql(u8, &@as([2]u8, down0), &[2]u8{ 0x55, 0xaa })); + } + + { + // Downcast (safety-checked) + const down0: @Vector(2, u8) = @intCast(up1); + + try expect(mem.eql(u8, &@as([2]u8, down0), &[2]u8{ 0x55, 0xaa })); + } + } + { + // Upcast (implicit, equivalent to @intCast) + var up0: @Vector(4, u8) = .{ 0x00, 0x55, 0xaa, 0xff }; + _ = &up0; + const up1: @Vector(4, u16) = up0; + const up2: @Vector(4, u32) = up0; + const up3: @Vector(4, u64) = up0; + + try expect(mem.eql(u16, &@as([4]u16, up1), &[4]u16{ 0x00, 0x55, 0xaa, 0xff })); + try expect(mem.eql(u32, &@as([4]u32, up2), &[4]u32{ 0x00, 0x55, 0xaa, 0xff })); + try expect(mem.eql(u64, &@as([4]u64, up3), &[4]u64{ 0x00, 0x55, 0xaa, 0xff })); + + { + // Downcast (safety-checked) + const down2: @Vector(4, u32) = @intCast(up3); + const down1: @Vector(4, u16) = @intCast(up3); + const down0: @Vector(4, u8) = @intCast(up3); + + try expect(mem.eql(u32, &@as([4]u32, down2), &[4]u32{ 0x00, 0x55, 0xaa, 0xff })); + try expect(mem.eql(u16, &@as([4]u16, down1), &[4]u16{ 0x00, 0x55, 0xaa, 0xff })); + try expect(mem.eql(u8, &@as([4]u8, down0), &[4]u8{ 0x00, 0x55, 0xaa, 0xff })); + } + + { + // Downcast (safety-checked) + const down1: @Vector(4, u16) = @intCast(up2); + const down0: @Vector(4, u8) = @intCast(up2); + + try expect(mem.eql(u16, &@as([4]u16, down1), &[4]u16{ 0x00, 0x55, 0xaa, 0xff })); + try expect(mem.eql(u8, &@as([4]u8, down0), &[4]u8{ 0x00, 0x55, 0xaa, 0xff })); + } + + { + // Downcast (safety-checked) + const down0: @Vector(4, u8) = @intCast(up1); + + try expect(mem.eql(u8, &@as([4]u8, down0), &[4]u8{ 0x00, 0x55, 0xaa, 0xff })); + } + } + { + // Upcast (implicit, equivalent to @intCast) + var up0: @Vector(8, u8) = .{ + 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, + }; + _ = &up0; + const up1: @Vector(8, u16) = up0; + const up2: @Vector(8, u32) = up0; + const up3: @Vector(8, u64) = up0; + + try expect(mem.eql(u16, &@as([8]u16, up1), &[8]u16{ + 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, + })); + try expect(mem.eql(u32, &@as([8]u32, up2), &[8]u32{ + 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, + })); + try expect(mem.eql(u64, &@as([8]u64, up3), &[8]u64{ + 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, + })); + + { + // Downcast (safety-checked) + const down2: @Vector(8, u32) = @intCast(up3); + const down1: @Vector(8, u16) = @intCast(up3); + const down0: @Vector(8, u8) = @intCast(up3); + + try expect(mem.eql(u32, &@as([8]u32, down2), &[8]u32{ + 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, + })); + try expect(mem.eql(u16, &@as([8]u16, down1), &[8]u16{ + 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, + })); + try expect(mem.eql(u8, &@as([8]u8, down0), &[8]u8{ + 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, + })); + } + + { + // Downcast (safety-checked) + const down1: @Vector(8, u16) = @intCast(up2); + const down0: @Vector(8, u8) = @intCast(up2); + + try expect(mem.eql(u16, &@as([8]u16, down1), &[8]u16{ + 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, + })); + try expect(mem.eql(u8, &@as([8]u8, down0), &[8]u8{ + 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, + })); + } + + { + // Downcast (safety-checked) + const down0: @Vector(8, u8) = @intCast(up1); + + try expect(mem.eql(u8, &@as([8]u8, down0), &[8]u8{ + 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, + })); + } + } + { + // Upcast (implicit, equivalent to @intCast) + var up0: @Vector(16, u8) = .{ + 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, + 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, + }; + _ = &up0; + const up1: @Vector(16, u16) = up0; + const up2: @Vector(16, u32) = up0; + const up3: @Vector(16, u64) = up0; + + try expect(mem.eql(u16, &@as([16]u16, up1), &[16]u16{ + 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, + 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, + })); + try expect(mem.eql(u32, &@as([16]u32, up2), &[16]u32{ + 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, + 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, + })); + try expect(mem.eql(u64, &@as([16]u64, up3), &[16]u64{ + 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, + 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, + })); + + { + // Downcast (safety-checked) + const down2: @Vector(16, u32) = @intCast(up3); + const down1: @Vector(16, u16) = @intCast(up3); + const down0: @Vector(16, u8) = @intCast(up3); + + try expect(mem.eql(u32, &@as([16]u32, down2), &[16]u32{ + 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, + 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, + })); + try expect(mem.eql(u16, &@as([16]u16, down1), &[16]u16{ + 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, + 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, + })); + try expect(mem.eql(u8, &@as([16]u8, down0), &[16]u8{ + 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, + 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, + })); + } + + { + // Downcast (safety-checked) + const down1: @Vector(16, u16) = @intCast(up2); + const down0: @Vector(16, u8) = @intCast(up2); + + try expect(mem.eql(u16, &@as([16]u16, down1), &[16]u16{ + 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, + 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, + })); + try expect(mem.eql(u8, &@as([16]u8, down0), &[16]u8{ + 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, + 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, + })); + } + + { + // Downcast (safety-checked) + const down0: @Vector(16, u8) = @intCast(up1); + + try expect(mem.eql(u8, &@as([16]u8, down0), &[16]u8{ + 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, + 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, + })); + } + } } }; diff --git a/test/behavior/enum.zig b/test/behavior/enum.zig index d719a611e6..269fba13ba 100644 --- a/test/behavior/enum.zig +++ b/test/behavior/enum.zig @@ -1325,3 +1325,10 @@ test "large enum field values" { try expect(@intFromEnum(e) == std.math.maxInt(i128)); } } + +test "comptime @enumFromInt with signed arithmetic" { + const E = enum(i8) { foo = -1, bar = 0 }; + const x: E = @enumFromInt(@as(i8, -1) * 0); + comptime assert(x == .bar); + comptime assert(@intFromEnum(x) == 0); +} diff --git a/test/behavior/memset.zig b/test/behavior/memset.zig index 0a15dc3cce..1efd90a2c6 100644 --- a/test/behavior/memset.zig +++ b/test/behavior/memset.zig @@ -175,3 +175,8 @@ test "zero keys with @memset" { try expect(!Keys.keys.left); try expect(!Keys.keys.right); } + +test "@memset with zero-length array" { + var array: [0]usize = undefined; + @memset(&array, 0); +} diff --git a/test/behavior/struct.zig b/test/behavior/struct.zig index 29e9986e5e..f1c10a1461 100644 --- a/test/behavior/struct.zig +++ b/test/behavior/struct.zig @@ -2136,3 +2136,21 @@ test "field access through mem ptr arg" { &.{ .field = 0x0ced271f }, ) == 0x0ced271f); } + +test "align 1 struct parameter dereferenced and returned" { + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; + + const S = extern struct { + a: u32, + + fn gimme(p: *align(1) @This()) @This() { + return p.*; + } + }; + var buffer: [5]u8 align(4) = .{ 1, 2, 3, 4, 5 }; + const s = S.gimme(@ptrCast(buffer[1..])); + switch (native_endian) { + .big => try expect(s.a == 0x02030405), + .little => try expect(s.a == 0x05040302), + } +} diff --git a/test/behavior/switch_on_captured_error.zig b/test/behavior/switch_on_captured_error.zig index 9aae1c7fbe..fcf51f6c9a 100644 --- a/test/behavior/switch_on_captured_error.zig +++ b/test/behavior/switch_on_captured_error.zig @@ -300,7 +300,6 @@ test "switch on error union catch capture" { } test "switch on error union if else capture" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; diff --git a/test/behavior/try.zig b/test/behavior/try.zig index fd120fc86f..df852abfa1 100644 --- a/test/behavior/try.zig +++ b/test/behavior/try.zig @@ -122,7 +122,6 @@ test "'return try' through conditional" { } test "try ptr propagation const" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; @@ -155,7 +154,6 @@ test "try ptr propagation const" { } test "try ptr propagation mutate" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; diff --git a/test/behavior/union.zig b/test/behavior/union.zig index 04d07f91ae..f821097c27 100644 --- a/test/behavior/union.zig +++ b/test/behavior/union.zig @@ -2321,3 +2321,21 @@ test "initialize empty field of union inside comptime-known struct constant" { const val: Wrapper = .{ .inner = .{ .none = {} } }; comptime assert(val.inner.none == {}); } + +test "union with function body field" { + const U = union { + f: fn () void, + fn foo() void {} + fn bar() void {} + }; + const x: U = .{ .f = U.foo }; + try std.testing.expect(x.f == U.foo); + x.f(); + + comptime var y: U = .{ .f = U.bar }; + try std.testing.expect(y.f == U.bar); + y.f(); + y.f = U.foo; + try std.testing.expect(y.f == U.foo); + y.f(); +} diff --git a/test/behavior/vector.zig b/test/behavior/vector.zig index d90f48d86d..0cd792b460 100644 --- a/test/behavior/vector.zig +++ b/test/behavior/vector.zig @@ -7,16 +7,50 @@ const expect = std.testing.expect; const expectEqual = std.testing.expectEqual; test "implicit cast vector to array - bool" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.cpu.arch == .aarch64_be and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; const S = struct { fn doTheTest() !void { - const a: @Vector(4, bool) = [_]bool{ true, false, true, false }; - const result_array: [4]bool = a; - try expect(mem.eql(bool, &result_array, &[4]bool{ true, false, true, false })); + { + var v: @Vector(4, bool) = undefined; + v = .{ true, false, true, false }; + const a: [4]bool = v; + try expect(mem.eql(bool, &a, &.{ true, false, true, false })); + } + { + var v: @Vector(25, bool) = undefined; + v = .{ false, false, false, false, true, true, false, false, false, true, false, true, false, false, true, false, false, true, false, false, true, true, true, false, false }; + const a: [25]bool = v; + try expect(mem.eql(bool, &a, &.{ false, false, false, false, true, true, false, false, false, true, false, true, false, false, true, false, false, true, false, false, true, true, true, false, false })); + } + } + }; + try S.doTheTest(); + try comptime S.doTheTest(); +} + +test "implicit cast array to vector - bool" { + if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; + + const S = struct { + fn doTheTest() !void { + { + var a: [4]bool = undefined; + a = .{ true, false, false, true }; + const v: @Vector(4, bool) = a; + try expect(mem.eql(bool, &@as([4]bool, v), &.{ true, false, false, true })); + } + { + var a: [25]bool = undefined; + a = .{ true, false, false, true, false, false, false, false, false, true, true, true, true, false, false, false, false, true, false, false, false, true, true, true, false }; + const v: @Vector(25, bool) = a; + try expect(mem.eql(bool, &@as([25]bool, v), &.{ true, false, false, true, false, false, false, false, false, true, true, true, true, false, false, false, false, true, false, false, false, true, true, true, false })); + } } }; try S.doTheTest(); @@ -968,6 +1002,73 @@ test "saturating add" { const expected = i8x3{ 127, 127, 127 }; try expect(mem.eql(i8, &@as([3]i8, expected), &@as([3]i8, result))); } + try testElemType(i4); + try testElemType(u4); + try testElemType(i8); + try testElemType(u8); + try testElemType(i12); + try testElemType(u12); + try testElemType(i16); + try testElemType(u16); + try testElemType(i24); + try testElemType(u24); + try testElemType(i32); + try testElemType(u32); + try testElemType(i48); + try testElemType(u48); + try testElemType(i64); + try testElemType(u64); + } + fn testElemType(comptime Elem: type) !void { + const min = std.math.minInt(Elem); + const max = std.math.maxInt(Elem); + + var v: @Vector(4, Elem) = .{ 0, 1, 0, 1 }; + v +|= .{ 0, 0, 1, 1 }; + try expect(v[0] == 0); + try expect(v[1] == 1); + try expect(v[2] == 1); + try expect(v[3] == 2); + + v = .{ 0, max, 1, max }; + v +|= .{ max, 0, max, 1 }; + try expect(v[0] == max); + try expect(v[1] == max); + try expect(v[2] == max); + try expect(v[3] == max); + + v = .{ 1, max - 1, max / 2, max }; + v +|= .{ max - 1, 1, max / 2, max }; + try expect(v[0] == max); + try expect(v[1] == max); + try expect(v[2] == max - 1); + try expect(v[3] == max); + + switch (@typeInfo(Elem).int.signedness) { + .signed => { + v = .{ -1, -1, 0, -1 }; + v +|= .{ 1, 0, -1, -1 }; + try expect(v[0] == 0); + try expect(v[1] == -1); + try expect(v[2] == -1); + try expect(v[3] == -2); + + v = .{ 0, min, -1, min }; + v +|= .{ min, 0, min, -1 }; + try expect(v[0] == min); + try expect(v[1] == min); + try expect(v[2] == min); + try expect(v[3] == min); + + v = .{ -1, min + 1, min / 2, min }; + v +|= .{ min + 1, -1, min / 2, min }; + try expect(v[0] == min); + try expect(v[1] == min); + try expect(v[2] == min); + try expect(v[3] == min); + }, + .unsigned => {}, + } } }; try S.doTheTest(); @@ -984,14 +1085,83 @@ test "saturating subtraction" { const S = struct { fn doTheTest() !void { - // Broken out to avoid https://github.com/ziglang/zig/issues/11251 - const u8x3 = @Vector(3, u8); - var lhs = u8x3{ 0, 0, 0 }; - var rhs = u8x3{ 255, 255, 255 }; - _ = .{ &lhs, &rhs }; - const result = lhs -| rhs; - const expected = u8x3{ 0, 0, 0 }; - try expect(mem.eql(u8, &@as([3]u8, expected), &@as([3]u8, result))); + { + // Broken out to avoid https://github.com/ziglang/zig/issues/11251 + const u8x3 = @Vector(3, u8); + var lhs = u8x3{ 0, 0, 0 }; + var rhs = u8x3{ 255, 255, 255 }; + _ = .{ &lhs, &rhs }; + const result = lhs -| rhs; + const expected = u8x3{ 0, 0, 0 }; + try expect(mem.eql(u8, &@as([3]u8, expected), &@as([3]u8, result))); + } + try testElemType(i4); + try testElemType(u4); + try testElemType(i8); + try testElemType(u8); + try testElemType(i12); + try testElemType(u12); + try testElemType(i16); + try testElemType(u16); + try testElemType(i24); + try testElemType(u24); + try testElemType(i32); + try testElemType(u32); + try testElemType(i48); + try testElemType(u48); + try testElemType(i64); + try testElemType(u64); + } + fn testElemType(comptime Elem: type) !void { + const min = std.math.minInt(Elem); + const max = std.math.maxInt(Elem); + + var v: @Vector(4, Elem) = .{ 0, 1, 0, 1 }; + v -|= .{ 0, 0, 1, 1 }; + try expect(v[0] == 0); + try expect(v[1] == 1); + try expect(v[2] == @max(min, -1)); + try expect(v[3] == 0); + + v = .{ 0, max, 1, max }; + v -|= .{ max, 0, max, 1 }; + try expect(v[0] == @min(min + 1, 0)); + try expect(v[1] == max); + try expect(v[2] == @min(min + 2, 0)); + try expect(v[3] == max - 1); + + v = .{ 1, max - 1, max / 2, max }; + v -|= .{ max - 1, 1, max / 2, max }; + try expect(v[0] == @min(min + 3, 0)); + try expect(v[1] == max - 2); + try expect(v[2] == 0); + try expect(v[3] == 0); + + switch (@typeInfo(Elem).int.signedness) { + .signed => { + v = .{ -1, -1, 0, -1 }; + v -|= .{ -1, 0, 1, 1 }; + try expect(v[0] == 0); + try expect(v[1] == -1); + try expect(v[2] == -1); + try expect(v[3] == -2); + + v = .{ 0, min, -1, min }; + v -|= .{ max, 0, max, 1 }; + try expect(v[0] == min + 1); + try expect(v[1] == min); + try expect(v[2] == min); + try expect(v[3] == min); + + v = .{ -1, min + 1, min / 2, min }; + v -|= .{ max, 1, max / 2, max }; + try expect(v[0] == min); + try expect(v[1] == min); + try expect(v[2] == min + 1); + try expect(v[3] == min); + }, + .unsigned => {}, + } } }; try S.doTheTest(); diff --git a/test/cases/export_from_body_of_coerced_fn.zig b/test/cases/export_from_body_of_coerced_fn.zig new file mode 100644 index 0000000000..541cd0c86f --- /dev/null +++ b/test/cases/export_from_body_of_coerced_fn.zig @@ -0,0 +1,19 @@ +fn original() usize { + _ = struct { + export const val: u32 = 123; + }; + return 0; +} + +pub fn main() void { + const coerced: fn () u64 = original; + _ = coerced(); + + const S = struct { + extern const val: u32; + }; + if (S.val != 123) @panic("wrong value"); +} + +// run +// target=x86_64-linux diff --git a/test/cases/translate_c/tenary_in_macro.c b/test/cases/translate_c/tenary_in_macro.c new file mode 100644 index 0000000000..a9cdb2724c --- /dev/null +++ b/test/cases/translate_c/tenary_in_macro.c @@ -0,0 +1,21 @@ +#define TERNARY_CHECK(i) check(i) +#define TERNARY_CALL(i) (TERNARY_CHECK(i) ? (i+1) : (i-1)) + +static inline int check(int obj) { + return obj % 2; +} +int target_func(int a) { + return TERNARY_CALL(a); +} + +// translate-c +// c_frontend=clang +// +// pub inline fn TERNARY_CHECK(i: anytype) @TypeOf(check(i)) { +// _ = &i; +// return check(i); +// } +// pub inline fn TERNARY_CALL(i: anytype) @TypeOf(if (TERNARY_CHECK(i) != 0) i + @as(c_int, 1) else i - @as(c_int, 1)) { +// _ = &i; +// return if (TERNARY_CHECK(i) != 0) i + @as(c_int, 1) else i - @as(c_int, 1); +// } \ No newline at end of file diff --git a/test/link/elf.zig b/test/link/elf.zig index 1d6de32f0d..161dcf2d32 100644 --- a/test/link/elf.zig +++ b/test/link/elf.zig @@ -2,6 +2,9 @@ pub fn testAll(b: *Build, build_opts: BuildOptions) *Step { _ = build_opts; const elf_step = b.step("test-elf", "Run ELF tests"); + // https://github.com/ziglang/zig/issues/25323 + if (builtin.os.tag == .freebsd) return elf_step; + const default_target = b.resolveTargetQuery(.{ .cpu_arch = .x86_64, // TODO relax this once ELF linker is able to handle other archs .os_tag = .linux, @@ -73,6 +76,7 @@ pub fn testAll(b: *Build, build_opts: BuildOptions) *Step { elf_step.dependOn(testLinkingC(b, .{ .target = musl_target })); elf_step.dependOn(testLinkingCpp(b, .{ .target = musl_target })); elf_step.dependOn(testLinkingZig(b, .{ .target = musl_target })); + elf_step.dependOn(testLinksection(b, .{ .target = musl_target })); elf_step.dependOn(testMergeStrings(b, .{ .target = musl_target })); elf_step.dependOn(testMergeStrings2(b, .{ .target = musl_target })); // https://github.com/ziglang/zig/issues/17451 @@ -165,6 +169,7 @@ pub fn testAll(b: *Build, build_opts: BuildOptions) *Step { elf_step.dependOn(testLinkingObj(b, .{ .use_llvm = false, .target = default_target })); elf_step.dependOn(testLinkingStaticLib(b, .{ .use_llvm = false, .target = default_target })); elf_step.dependOn(testLinkingZig(b, .{ .use_llvm = false, .target = default_target })); + elf_step.dependOn(testLinksection(b, .{ .use_llvm = false, .target = default_target })); elf_step.dependOn(testImportingDataDynamic(b, .{ .use_llvm = false, .target = x86_64_gnu })); elf_step.dependOn(testImportingDataStatic(b, .{ .use_llvm = false, .target = x86_64_musl })); @@ -2439,6 +2444,43 @@ fn testLinkingZig(b: *Build, opts: Options) *Step { return test_step; } +fn testLinksection(b: *Build, opts: Options) *Step { + const test_step = addTestStep(b, "linksection", opts); + + const obj = addObject(b, opts, .{ .name = "main", .zig_source_bytes = + \\export var test_global: u32 linksection(".TestGlobal") = undefined; + \\export fn testFn() linksection(".TestFn") callconv(.c) void { + \\ TestGenericFn("A").f(); + \\} + \\fn TestGenericFn(comptime suffix: []const u8) type { + \\ return struct { + \\ fn f() linksection(".TestGenFn" ++ suffix) void {} + \\ }; + \\} + }); + + const check = obj.checkObject(); + check.checkInSymtab(); + check.checkContains("SECTION LOCAL DEFAULT .TestGlobal"); + check.checkInSymtab(); + check.checkContains("SECTION LOCAL DEFAULT .TestFn"); + check.checkInSymtab(); + check.checkContains("SECTION LOCAL DEFAULT .TestGenFnA"); + check.checkInSymtab(); + check.checkContains("OBJECT GLOBAL DEFAULT test_global"); + check.checkInSymtab(); + check.checkContains("FUNC GLOBAL DEFAULT testFn"); + + if (opts.optimize == .Debug) { + check.checkInSymtab(); + check.checkContains("FUNC LOCAL DEFAULT main.TestGenericFn("); + } + + test_step.dependOn(&check.step); + + return test_step; +} + // Adapted from https://github.com/rui314/mold/blob/main/test/elf/mergeable-strings.sh fn testMergeStrings(b: *Build, opts: Options) *Step { const test_step = addTestStep(b, "merge-strings", opts); @@ -4246,6 +4288,7 @@ const addStaticLibrary = link.addStaticLibrary; const expectLinkErrors = link.expectLinkErrors; const link = @import("link.zig"); const std = @import("std"); +const builtin = @import("builtin"); const Build = std.Build; const BuildOptions = link.BuildOptions; diff --git a/test/src/StackTrace.zig b/test/src/StackTrace.zig index d956e27cd7..87fa9a3ca1 100644 --- a/test/src/StackTrace.zig +++ b/test/src/StackTrace.zig @@ -44,7 +44,7 @@ fn addCaseInner(self: *StackTrace, config: Config, use_llvm: bool) void { fn shouldTestNonLlvm(target: *const std.Target) bool { return switch (target.cpu.arch) { .x86_64 => switch (target.ofmt) { - .elf => true, + .elf => !target.os.tag.isBSD(), else => false, }, else => false, diff --git a/test/stack_traces.zig b/test/stack_traces.zig index 40a6168297..0bd5a760cb 100644 --- a/test/stack_traces.zig +++ b/test/stack_traces.zig @@ -793,6 +793,7 @@ pub fn addCases(cases: *tests.StackTracesContext) void { , .Debug = .{ .exclude_os = &.{ + .freebsd, .openbsd, // integer overflow .windows, // TODO intermittent failures }, @@ -837,6 +838,7 @@ pub fn addCases(cases: *tests.StackTracesContext) void { }, .ReleaseSafe = .{ .exclude_os = &.{ + .freebsd, .windows, // TODO .linux, // defeated by aggressive inlining .macos, // Broken in LLVM 20. diff --git a/test/standalone/build.zig.zon b/test/standalone/build.zig.zon index c57837c8e6..b48a389f40 100644 --- a/test/standalone/build.zig.zon +++ b/test/standalone/build.zig.zon @@ -136,9 +136,6 @@ .c_embed_path = .{ .path = "c_embed_path", }, - .pie = .{ - .path = "pie", - }, .issue_12706 = .{ .path = "issue_12706", }, diff --git a/test/standalone/pie/build.zig b/test/standalone/pie/build.zig deleted file mode 100644 index 79d078a9eb..0000000000 --- a/test/standalone/pie/build.zig +++ /dev/null @@ -1,26 +0,0 @@ -const std = @import("std"); - -pub fn build(b: *std.Build) void { - const test_step = b.step("test", "Test it"); - b.default_step = test_step; - - const optimize: std.builtin.OptimizeMode = .Debug; - const target = b.resolveTargetQuery(.{ - .os_tag = .linux, - .cpu_arch = .x86_64, - }); - - const main = b.addTest(.{ - .root_module = b.createModule(.{ - .root_source_file = b.path("main.zig"), - .optimize = optimize, - .target = target, - }), - }); - main.pie = true; - - const run = b.addRunArtifact(main); - run.skip_foreign_checks = true; - - test_step.dependOn(&run.step); -} diff --git a/test/standalone/pie/main.zig b/test/standalone/pie/main.zig deleted file mode 100644 index edf6a3fcaa..0000000000 --- a/test/standalone/pie/main.zig +++ /dev/null @@ -1,15 +0,0 @@ -const std = @import("std"); -const elf = std.elf; - -threadlocal var foo: u8 = 42; - -test "Check ELF header" { - // PIE executables are marked as ET_DYN, regular exes as ET_EXEC. - const header = @as(*elf.Ehdr, @ptrFromInt(std.process.getBaseAddress())); - try std.testing.expectEqual(elf.ET.DYN, header.e_type); -} - -test "TLS is initialized" { - // Ensure the TLS is initialized by the startup code. - try std.testing.expectEqual(@as(u8, 42), foo); -} diff --git a/test/standalone/stack_iterator/build.zig b/test/standalone/stack_iterator/build.zig index 8d2c448215..b6ac2a9aee 100644 --- a/test/standalone/stack_iterator/build.zig +++ b/test/standalone/stack_iterator/build.zig @@ -61,8 +61,12 @@ pub fn build(b: *std.Build) void { .use_llvm = true, }); - const run_cmd = b.addRunArtifact(exe); - test_step.dependOn(&run_cmd.step); + if (builtin.os.tag != .freebsd) { + const run_cmd = b.addRunArtifact(exe); + test_step.dependOn(&run_cmd.step); + } else { + test_step.dependOn(&exe.step); + } } // https://github.com/ziglang/zig/issues/24522 diff --git a/test/standalone/stack_iterator/unwind_freestanding.zig b/test/standalone/stack_iterator/unwind_freestanding.zig index ec4bb5d00e..f655507b32 100644 --- a/test/standalone/stack_iterator/unwind_freestanding.zig +++ b/test/standalone/stack_iterator/unwind_freestanding.zig @@ -37,7 +37,7 @@ noinline fn frame0(expected: *[4]usize, unwound: *[4]usize) void { } // No-OS entrypoint -export fn _start() callconv(.c) noreturn { +export fn _start() callconv(.withStackAlign(.c, 1)) noreturn { var expected: [4]usize = undefined; var unwound: [4]usize = undefined; frame0(&expected, &unwound); diff --git a/test/tests.zig b/test/tests.zig index 1e5db67f07..6b14685a6f 100644 --- a/test/tests.zig +++ b/test/tests.zig @@ -2488,8 +2488,9 @@ pub fn wouldUseLlvm(use_llvm: ?bool, query: std.Target.Query, optimize_mode: Opt else => return true, } const cpu_arch = query.cpu_arch orelse builtin.cpu.arch; + const os_tag = query.os_tag orelse builtin.os.tag; switch (cpu_arch) { - .x86_64 => if (std.Target.ptrBitWidth_arch_abi(cpu_arch, query.abi orelse .none) != 64) return true, + .x86_64 => if (os_tag.isBSD() or std.Target.ptrBitWidth_arch_abi(cpu_arch, query.abi orelse .none) != 64) return true, .spirv32, .spirv64 => return false, else => return true, } diff --git a/test/translate_c.zig b/test/translate_c.zig index 6d1a8916f2..49eb2f210c 100644 --- a/test/translate_c.zig +++ b/test/translate_c.zig @@ -3101,8 +3101,8 @@ pub fn addCases(cases: *tests.TranslateCContext) void { \\ int a, b, c; \\#define FOO a ? b : c , &[_][]const u8{ - \\pub inline fn FOO() @TypeOf(if (a) b else c) { - \\ return if (a) b else c; + \\pub inline fn FOO() @TypeOf(if (a != 0) b else c) { + \\ return if (a != 0) b else c; \\} });
{f}