authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2025-04-28 15:06:18-04:00
committergravatar for noreply@github.comGitHub <noreply@github.com> 2025-04-28 15:06:18-04:00
log8facd99d41b1290f9b29ec22c9dcce680d972810
tree0ab61812da58df4127b8b56ec43eb88c0e6d5eb2
parentd038676a1f46ecab2bd095d3503ab05bcd8de58c
parent8be4511061f18e1bf2b6f7bf108482c6d1e30aa6
signaturebadge-check Signed by PGP key B5690EEEBB952194

Merge pull request #23708 from ziglang/memmove-followups

`@memmove` followups

13 files changed, 60 insertions(+), 96 deletions(-)

lib/std/debug.zig+4-6
......@@ -126,18 +126,16 @@ pub fn FullPanic(comptime panicFn: fn ([]const u8, ?usize) noreturn) type {
126126 @branchHint(.cold);
127127 call("for loop over objects with non-equal lengths", @returnAddress());
128128 }
129 pub fn memcpyLenMismatch() noreturn {
129 /// Delete after next zig1.wasm update
130 pub const memcpyLenMismatch = copyLenMismatch;
131 pub fn copyLenMismatch() noreturn {
130132 @branchHint(.cold);
131 call("@memcpy arguments have non-equal lengths", @returnAddress());
133 call("source and destination arguments have non-equal lengths", @returnAddress());
132134 }
133135 pub fn memcpyAlias() noreturn {
134136 @branchHint(.cold);
135137 call("@memcpy arguments alias", @returnAddress());
136138 }
137 pub fn memmoveLenMismatch() noreturn {
138 @branchHint(.cold);
139 call("@memmove arguments have non-equal lengths", @returnAddress());
140 }
141139 pub fn noreturnReturned() noreturn {
142140 @branchHint(.cold);
143141 call("'noreturn' function returned", @returnAddress());
lib/std/debug/no_panic.zig+4-6
......@@ -125,17 +125,15 @@ pub fn forLenMismatch() noreturn {
125125 @trap();
126126}
127127
128pub fn memcpyLenMismatch() noreturn {
129 @branchHint(.cold);
130 @trap();
131}
128/// Delete after next zig1.wasm update
129pub const memcpyLenMismatch = copyLenMismatch;
132130
133pub fn memcpyAlias() noreturn {
131pub fn copyLenMismatch() noreturn {
134132 @branchHint(.cold);
135133 @trap();
136134}
137135
138pub fn memmoveLenMismatch() noreturn {
136pub fn memcpyAlias() noreturn {
139137 @branchHint(.cold);
140138 @trap();
141139}
lib/std/debug/simple_panic.zig+5-6
......@@ -120,18 +120,17 @@ pub fn forLenMismatch() noreturn {
120120 call("for loop over objects with non-equal lengths", null);
121121}
122122
123pub fn memcpyLenMismatch() noreturn {
124 call("@memcpy arguments have non-equal lengths", null);
123/// Delete after next zig1.wasm update
124pub const memcpyLenMismatch = copyLenMismatch;
125
126pub fn copyLenMismatch() noreturn {
127 call("source and destination have non-equal lengths", null);
125128}
126129
127130pub fn memcpyAlias() noreturn {
128131 call("@memcpy arguments alias", null);
129132}
130133
131pub fn memmoveLenMismatch() noreturn {
132 call("@memmove arguments have non-equal lengths", null);
133}
134
135134pub fn noreturnReturned() noreturn {
136135 call("'noreturn' function returned", null);
137136}
lib/std/zig/Zir.zig+3-3
......@@ -983,12 +983,12 @@ pub const Inst = struct {
983983 /// Implements the `@memcpy` builtin.
984984 /// Uses the `pl_node` union field with payload `Bin`.
985985 memcpy,
986 /// Implements the `@memset` builtin.
987 /// Uses the `pl_node` union field with payload `Bin`.
988 memset,
989986 /// Implements the `@memmove` builtin.
990987 /// Uses the `pl_node` union field with payload `Bin`.
991988 memmove,
989 /// Implements the `@memset` builtin.
990 /// Uses the `pl_node` union field with payload `Bin`.
991 memset,
992992 /// Implements the `@min` builtin for 2 args.
993993 /// Uses the `pl_node` union field with payload `Bin`
994994 min,
src/Sema.zig+14-34
......@@ -1574,17 +1574,17 @@ fn analyzeBodyInner(
15741574 continue;
15751575 },
15761576 .memcpy => {
1577 try sema.zirMemcpy(block, inst);
1577 try sema.zirMemcpy(block, inst, .memcpy, true);
15781578 i += 1;
15791579 continue;
15801580 },
1581 .memset => {
1582 try sema.zirMemset(block, inst);
1581 .memmove => {
1582 try sema.zirMemcpy(block, inst, .memmove, false);
15831583 i += 1;
15841584 continue;
15851585 },
1586 .memmove => {
1587 try sema.zirMemmove(block, inst);
1586 .memset => {
1587 try sema.zirMemset(block, inst);
15881588 i += 1;
15891589 continue;
15901590 },
......@@ -25630,19 +25630,12 @@ fn upgradeToArrayPtr(sema: *Sema, block: *Block, ptr: Air.Inst.Ref, len: u64) !A
2563025630 return block.addBitCast(new_ty, non_slice_ptr);
2563125631}
2563225632
25633fn zirMemcpy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void {
25634 return sema.analyzeCopy(block, inst, .memcpy);
25635}
25636
25637fn zirMemmove(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void {
25638 return sema.analyzeCopy(block, inst, .memmove);
25639}
25640
25641fn analyzeCopy(
25633fn zirMemcpy(
2564225634 sema: *Sema,
2564325635 block: *Block,
2564425636 inst: Zir.Inst.Index,
25645 op: enum { memcpy, memmove },
25637 air_tag: Air.Inst.Tag,
25638 check_aliasing: bool,
2564625639) CompileError!void {
2564725640 const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
2564825641 const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
......@@ -25659,12 +25652,12 @@ fn analyzeCopy(
2565925652 const zcu = pt.zcu;
2566025653
2566125654 if (dest_ty.isConstPtr(zcu)) {
25662 return sema.fail(block, dest_src, "cannot {s} to constant pointer", .{@tagName(op)});
25655 return sema.fail(block, dest_src, "cannot copy to constant pointer", .{});
2566325656 }
2566425657
2566525658 if (dest_len == .none and src_len == .none) {
2566625659 const msg = msg: {
25667 const msg = try sema.errMsg(src, "unknown @{s} length", .{@tagName(op)});
25660 const msg = try sema.errMsg(src, "unknown copy length", .{});
2566825661 errdefer msg.destroy(sema.gpa);
2566925662 try sema.errNote(dest_src, msg, "destination type '{}' provides no length", .{
2567025663 dest_ty.fmt(pt),
......@@ -25710,7 +25703,7 @@ fn analyzeCopy(
2571025703 if (try sema.resolveDefinedValue(block, src_src, src_len)) |src_len_val| {
2571125704 if (!(try sema.valuesEqual(dest_len_val, src_len_val, Type.usize))) {
2571225705 const msg = msg: {
25713 const msg = try sema.errMsg(src, "non-matching @{s} lengths", .{@tagName(op)});
25706 const msg = try sema.errMsg(src, "non-matching copy lengths", .{});
2571425707 errdefer msg.destroy(sema.gpa);
2571525708 try sema.errNote(dest_src, msg, "length {} here", .{
2571625709 dest_len_val.fmtValueSema(pt, sema),
......@@ -25730,11 +25723,7 @@ fn analyzeCopy(
2573025723
2573125724 if (block.wantSafety()) {
2573225725 const ok = try block.addBinOp(.cmp_eq, dest_len, src_len);
25733 const panic_id: Zcu.SimplePanicId = switch (op) {
25734 .memcpy => .memcpy_len_mismatch,
25735 .memmove => .memmove_len_mismatch,
25736 };
25737 try sema.addSafetyCheck(block, src, ok, panic_id);
25726 try sema.addSafetyCheck(block, src, ok, .copy_len_mismatch);
2573825727 }
2573925728 } else if (dest_len != .none) {
2574025729 if (try sema.resolveDefinedValue(block, dest_src, dest_len)) |dest_len_val| {
......@@ -25762,11 +25751,6 @@ fn analyzeCopy(
2576225751 return;
2576325752 }
2576425753
25765 const check_aliasing = switch (op) {
25766 .memcpy => true,
25767 .memmove => false,
25768 };
25769
2577025754 const runtime_src = rs: {
2577125755 const dest_ptr_val = try sema.resolveDefinedValue(block, dest_src, dest_ptr) orelse break :rs dest_src;
2577225756 const src_ptr_val = try sema.resolveDefinedValue(block, src_src, src_ptr) orelse break :rs src_src;
......@@ -25898,10 +25882,7 @@ fn analyzeCopy(
2589825882 }
2589925883
2590025884 _ = try block.addInst(.{
25901 .tag = switch (op) {
25902 .memcpy => .memcpy,
25903 .memmove => .memmove,
25904 },
25885 .tag = air_tag,
2590525886 .data = .{ .bin_op = .{
2590625887 .lhs = new_dest_ptr,
2590725888 .rhs = new_src_ptr,
......@@ -38153,9 +38134,8 @@ fn getExpectedBuiltinFnType(sema: *Sema, decl: Zcu.BuiltinDecl) CompileError!Typ
3815338134 .@"panic.shiftRhsTooBig",
3815438135 .@"panic.invalidEnumValue",
3815538136 .@"panic.forLenMismatch",
38156 .@"panic.memcpyLenMismatch",
38137 .@"panic.copyLenMismatch",
3815738138 .@"panic.memcpyAlias",
38158 .@"panic.memmoveLenMismatch",
3815938139 .@"panic.noreturnReturned",
3816038140 => try pt.funcType(.{
3816138141 .param_types = &.{},
src/Zcu.zig+4-8
......@@ -300,9 +300,8 @@ pub const BuiltinDecl = enum {
300300 @"panic.shiftRhsTooBig",
301301 @"panic.invalidEnumValue",
302302 @"panic.forLenMismatch",
303 @"panic.memcpyLenMismatch",
303 @"panic.copyLenMismatch",
304304 @"panic.memcpyAlias",
305 @"panic.memmoveLenMismatch",
306305 @"panic.noreturnReturned",
307306
308307 VaList,
......@@ -378,9 +377,8 @@ pub const BuiltinDecl = enum {
378377 .@"panic.shiftRhsTooBig",
379378 .@"panic.invalidEnumValue",
380379 .@"panic.forLenMismatch",
381 .@"panic.memcpyLenMismatch",
380 .@"panic.copyLenMismatch",
382381 .@"panic.memcpyAlias",
383 .@"panic.memmoveLenMismatch",
384382 .@"panic.noreturnReturned",
385383 => .func,
386384 };
......@@ -446,9 +444,8 @@ pub const SimplePanicId = enum {
446444 shift_rhs_too_big,
447445 invalid_enum_value,
448446 for_len_mismatch,
449 memcpy_len_mismatch,
447 copy_len_mismatch,
450448 memcpy_alias,
451 memmove_len_mismatch,
452449 noreturn_returned,
453450
454451 pub fn toBuiltin(id: SimplePanicId) BuiltinDecl {
......@@ -471,9 +468,8 @@ pub const SimplePanicId = enum {
471468 .shift_rhs_too_big => .@"panic.shiftRhsTooBig",
472469 .invalid_enum_value => .@"panic.invalidEnumValue",
473470 .for_len_mismatch => .@"panic.forLenMismatch",
474 .memcpy_len_mismatch => .@"panic.memcpyLenMismatch",
471 .copy_len_mismatch => .@"panic.copyLenMismatch",
475472 .memcpy_alias => .@"panic.memcpyAlias",
476 .memmove_len_mismatch => .@"panic.memmoveLenMismatch",
477473 .noreturn_returned => .@"panic.noreturnReturned",
478474 // zig fmt: on
479475 };
src/codegen/c.zig+3-15
......@@ -3348,8 +3348,8 @@ fn genBodyInner(f: *Function, body: []const Air.Inst.Index) error{ AnalysisFail,
33483348 .atomic_load => try airAtomicLoad(f, inst),
33493349 .memset => try airMemset(f, inst, false),
33503350 .memset_safe => try airMemset(f, inst, true),
3351 .memcpy => try airMemcpy(f, inst),
3352 .memmove => try airMemmove(f, inst),
3351 .memcpy => try airMemcpy(f, inst, "memcpy("),
3352 .memmove => try airMemcpy(f, inst, "memmove("),
33533353 .set_union_tag => try airSetUnionTag(f, inst),
33543354 .get_union_tag => try airGetUnionTag(f, inst),
33553355 .clz => try airUnBuiltinCall(f, inst, air_datas[@intFromEnum(inst)].ty_op.operand, "clz", .bits),
......@@ -6976,15 +6976,7 @@ fn airMemset(f: *Function, inst: Air.Inst.Index, safety: bool) !CValue {
69766976 return .none;
69776977}
69786978
6979fn airMemcpy(f: *Function, inst: Air.Inst.Index) !CValue {
6980 return copyOp(f, inst, .memcpy);
6981}
6982
6983fn airMemmove(f: *Function, inst: Air.Inst.Index) !CValue {
6984 return copyOp(f, inst, .memmove);
6985}
6986
6987fn copyOp(f: *Function, inst: Air.Inst.Index, op: enum { memcpy, memmove }) !CValue {
6979fn airMemcpy(f: *Function, inst: Air.Inst.Index, function_paren: []const u8) !CValue {
69886980 const pt = f.object.dg.pt;
69896981 const zcu = pt.zcu;
69906982 const bin_op = f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
......@@ -6999,10 +6991,6 @@ fn copyOp(f: *Function, inst: Air.Inst.Index, op: enum { memcpy, memmove }) !CVa
69996991 try writeArrayLen(f, writer, dest_ptr, dest_ty);
70006992 try writer.writeAll(" != 0) ");
70016993 }
7002 const function_paren = switch (op) {
7003 .memcpy => "memcpy(",
7004 .memmove => "memmove(",
7005 };
70066994 try writer.writeAll(function_paren);
70076995 try writeSliceOrPtr(f, writer, dest_ptr, dest_ty);
70086996 try writer.writeAll(", ");
test/cases/compile_errors/bad_panic_call_signature.zig+3-2
......@@ -27,9 +27,10 @@ pub const panic = struct {
2727 pub const shiftRhsTooBig = simple_panic.shiftRhsTooBig;
2828 pub const invalidEnumValue = simple_panic.invalidEnumValue;
2929 pub const forLenMismatch = simple_panic.forLenMismatch;
30 pub const memcpyLenMismatch = simple_panic.memcpyLenMismatch;
30 /// Delete after next zig1.wasm update
31 pub const memcpyLenMismatch = copyLenMismatch;
32 pub const copyLenMismatch = simple_panic.copyLenMismatch;
3133 pub const memcpyAlias = simple_panic.memcpyAlias;
32 pub const memmoveLenMismatch = simple_panic.memmoveLenMismatch;
3334 pub const noreturnReturned = simple_panic.noreturnReturned;
3435};
3536
test/cases/compile_errors/bad_panic_generic_signature.zig+3-2
......@@ -23,9 +23,10 @@ pub const panic = struct {
2323 pub const shiftRhsTooBig = simple_panic.shiftRhsTooBig;
2424 pub const invalidEnumValue = simple_panic.invalidEnumValue;
2525 pub const forLenMismatch = simple_panic.forLenMismatch;
26 pub const memcpyLenMismatch = simple_panic.memcpyLenMismatch;
26 /// Delete after next zig1.wasm update
27 pub const memcpyLenMismatch = copyLenMismatch;
28 pub const copyLenMismatch = simple_panic.copyLenMismatch;
2729 pub const memcpyAlias = simple_panic.memcpyAlias;
28 pub const memmoveLenMismatch = simple_panic.memmoveLenMismatch;
2930 pub const noreturnReturned = simple_panic.noreturnReturned;
3031};
3132
test/cases/compile_errors/incorrect_type_to_memset_memcpy.zig+6-6
......@@ -66,29 +66,29 @@ pub export fn memset_array() void {
6666// backend=stage2
6767// target=native
6868//
69// :5:5: error: unknown @memcpy length
69// :5:5: error: unknown copy length
7070// :5:18: note: destination type '[*]u8' provides no length
7171// :5:24: note: source type '[*]const u8' provides no length
7272// :10:13: error: type '*u8' is not an indexable pointer
7373// :10:13: note: operand must be a slice, a many pointer or a pointer to an array
7474// :15:13: error: type '*u8' is not an indexable pointer
7575// :15:13: note: operand must be a slice, a many pointer or a pointer to an array
76// :20:5: error: non-matching @memcpy lengths
76// :20:5: error: non-matching copy lengths
7777// :20:13: note: length 6 here
7878// :20:20: note: length 5 here
7979// :24:13: error: cannot memset constant pointer
80// :29:13: error: cannot memcpy to constant pointer
80// :29:13: error: cannot copy to constant pointer
8181// :33:13: error: type '[5]u8' is not an indexable pointer
8282// :33:13: note: operand must be a slice, a many pointer or a pointer to an array
83// :39:5: error: unknown @memmove length
83// :39:5: error: unknown copy length
8484// :39:19: note: destination type '[*]u8' provides no length
8585// :39:25: note: source type '[*]const u8' provides no length
8686// :44:14: error: type '*u8' is not an indexable pointer
8787// :44:14: note: operand must be a slice, a many pointer or a pointer to an array
88// :49:5: error: non-matching @memmove lengths
88// :49:5: error: non-matching copy lengths
8989// :49:14: note: length 6 here
9090// :49:21: note: length 5 here
91// :54:14: error: cannot memmove to constant pointer
91// :54:14: error: cannot copy to constant pointer
9292// :58:14: error: type '[5]u8' is not an indexable pointer
9393// :58:14: note: operand must be a slice, a many pointer or a pointer to an array
9494// :62:13: error: type '[5]u8' is not an indexable pointer
test/cases/safety/memcpy_len_mismatch.zig+1-1
......@@ -2,7 +2,7 @@ const std = @import("std");
22
33pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
44 _ = stack_trace;
5 if (std.mem.eql(u8, message, "@memcpy arguments have non-equal lengths")) {
5 if (std.mem.eql(u8, message, "source and destination arguments have non-equal lengths")) {
66 std.process.exit(0);
77 }
88 std.process.exit(1);
test/cases/safety/memmove_len_mismatch.zig+1-1
......@@ -2,7 +2,7 @@ const std = @import("std");
22
33pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
44 _ = stack_trace;
5 if (std.mem.eql(u8, message, "@memmove arguments have non-equal lengths")) {
5 if (std.mem.eql(u8, message, "source and destination arguments have non-equal lengths")) {
66 std.process.exit(0);
77 }
88 std.process.exit(1);
test/incremental/change_panic_handler_explicit+9-6
......@@ -37,9 +37,10 @@ pub const panic = struct {
3737 pub const shiftRhsTooBig = no_panic.shiftRhsTooBig;
3838 pub const invalidEnumValue = no_panic.invalidEnumValue;
3939 pub const forLenMismatch = no_panic.forLenMismatch;
40 pub const memcpyLenMismatch = no_panic.memcpyLenMismatch;
40 /// Delete after next zig1.wasm update
41 pub const memcpyLenMismatch = copyLenMismatch;
42 pub const copyLenMismatch = no_panic.copyLenMismatch;
4143 pub const memcpyAlias = no_panic.memcpyAlias;
42 pub const memmoveLenMismatch = no_panic.memmoveLenMismatch;
4344 pub const noreturnReturned = no_panic.noreturnReturned;
4445};
4546fn myPanic(msg: []const u8, _: ?usize) noreturn {
......@@ -85,9 +86,10 @@ pub const panic = struct {
8586 pub const shiftRhsTooBig = no_panic.shiftRhsTooBig;
8687 pub const invalidEnumValue = no_panic.invalidEnumValue;
8788 pub const forLenMismatch = no_panic.forLenMismatch;
88 pub const memcpyLenMismatch = no_panic.memcpyLenMismatch;
89 /// Delete after next zig1.wasm update
90 pub const memcpyLenMismatch = copyLenMismatch;
91 pub const copyLenMismatch = no_panic.copyLenMismatch;
8992 pub const memcpyAlias = no_panic.memcpyAlias;
90 pub const memmoveLenMismatch = no_panic.memmoveLenMismatch;
9193 pub const noreturnReturned = no_panic.noreturnReturned;
9294};
9395fn myPanic(msg: []const u8, _: ?usize) noreturn {
......@@ -133,9 +135,10 @@ pub const panic = struct {
133135 pub const shiftRhsTooBig = no_panic.shiftRhsTooBig;
134136 pub const invalidEnumValue = no_panic.invalidEnumValue;
135137 pub const forLenMismatch = no_panic.forLenMismatch;
136 pub const memcpyLenMismatch = no_panic.memcpyLenMismatch;
138 /// Delete after next zig1.wasm update
139 pub const memcpyLenMismatch = copyLenMismatch;
140 pub const copyLenMismatch = no_panic.copyLenMismatch;
137141 pub const memcpyAlias = no_panic.memcpyAlias;
138 pub const memmoveLenMismatch = no_panic.memmoveLenMismatch;
139142 pub const noreturnReturned = no_panic.noreturnReturned;
140143};
141144fn myPanicNew(msg: []const u8, _: ?usize) noreturn {