Merge pull request #23708 from ziglang/memmove-followups

`@memmove` followups

3 files changed, 21 insertions, 57 deletions

diff --git a/src/Sema.zig b/src/Sema.zig
index 06a4d5edf7..644410dc20 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -1574,17 +1574,17 @@ fn analyzeBodyInner(
                 continue;
             },
             .memcpy => {
-                try sema.zirMemcpy(block, inst);
+                try sema.zirMemcpy(block, inst, .memcpy, true);
                 i += 1;
                 continue;
             },
-            .memset => {
-                try sema.zirMemset(block, inst);
+            .memmove => {
+                try sema.zirMemcpy(block, inst, .memmove, false);
                 i += 1;
                 continue;
             },
-            .memmove => {
-                try sema.zirMemmove(block, inst);
+            .memset => {
+                try sema.zirMemset(block, inst);
                 i += 1;
                 continue;
             },
@@ -25630,19 +25630,12 @@ fn upgradeToArrayPtr(sema: *Sema, block: *Block, ptr: Air.Inst.Ref, len: u64) !A
     return block.addBitCast(new_ty, non_slice_ptr);
 }
 
-fn zirMemcpy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void {
-    return sema.analyzeCopy(block, inst, .memcpy);
-}
-
-fn zirMemmove(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void {
-    return sema.analyzeCopy(block, inst, .memmove);
-}
-
-fn analyzeCopy(
+fn zirMemcpy(
     sema: *Sema,
     block: *Block,
     inst: Zir.Inst.Index,
-    op: enum { memcpy, memmove },
+    air_tag: Air.Inst.Tag,
+    check_aliasing: bool,
 ) CompileError!void {
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
@@ -25659,12 +25652,12 @@ fn analyzeCopy(
     const zcu = pt.zcu;
 
     if (dest_ty.isConstPtr(zcu)) {
-        return sema.fail(block, dest_src, "cannot {s} to constant pointer", .{@tagName(op)});
+        return sema.fail(block, dest_src, "cannot copy to constant pointer", .{});
     }
 
     if (dest_len == .none and src_len == .none) {
         const msg = msg: {
-            const msg = try sema.errMsg(src, "unknown @{s} length", .{@tagName(op)});
+            const msg = try sema.errMsg(src, "unknown copy length", .{});
             errdefer msg.destroy(sema.gpa);
             try sema.errNote(dest_src, msg, "destination type '{}' provides no length", .{
                 dest_ty.fmt(pt),
@@ -25710,7 +25703,7 @@ fn analyzeCopy(
             if (try sema.resolveDefinedValue(block, src_src, src_len)) |src_len_val| {
                 if (!(try sema.valuesEqual(dest_len_val, src_len_val, Type.usize))) {
                     const msg = msg: {
-                        const msg = try sema.errMsg(src, "non-matching @{s} lengths", .{@tagName(op)});
+                        const msg = try sema.errMsg(src, "non-matching copy lengths", .{});
                         errdefer msg.destroy(sema.gpa);
                         try sema.errNote(dest_src, msg, "length {} here", .{
                             dest_len_val.fmtValueSema(pt, sema),
@@ -25730,11 +25723,7 @@ fn analyzeCopy(
 
         if (block.wantSafety()) {
             const ok = try block.addBinOp(.cmp_eq, dest_len, src_len);
-            const panic_id: Zcu.SimplePanicId = switch (op) {
-                .memcpy => .memcpy_len_mismatch,
-                .memmove => .memmove_len_mismatch,
-            };
-            try sema.addSafetyCheck(block, src, ok, panic_id);
+            try sema.addSafetyCheck(block, src, ok, .copy_len_mismatch);
         }
     } else if (dest_len != .none) {
         if (try sema.resolveDefinedValue(block, dest_src, dest_len)) |dest_len_val| {
@@ -25762,11 +25751,6 @@ fn analyzeCopy(
         return;
     }
 
-    const check_aliasing = switch (op) {
-        .memcpy => true,
-        .memmove => false,
-    };
-
     const runtime_src = rs: {
         const dest_ptr_val = try sema.resolveDefinedValue(block, dest_src, dest_ptr) orelse break :rs dest_src;
         const src_ptr_val = try sema.resolveDefinedValue(block, src_src, src_ptr) orelse break :rs src_src;
@@ -25898,10 +25882,7 @@ fn analyzeCopy(
     }
 
     _ = try block.addInst(.{
-        .tag = switch (op) {
-            .memcpy => .memcpy,
-            .memmove => .memmove,
-        },
+        .tag = air_tag,
         .data = .{ .bin_op = .{
             .lhs = new_dest_ptr,
             .rhs = new_src_ptr,
@@ -38153,9 +38134,8 @@ fn getExpectedBuiltinFnType(sema: *Sema, decl: Zcu.BuiltinDecl) CompileError!Typ
         .@"panic.shiftRhsTooBig",
         .@"panic.invalidEnumValue",
         .@"panic.forLenMismatch",
-        .@"panic.memcpyLenMismatch",
+        .@"panic.copyLenMismatch",
         .@"panic.memcpyAlias",
-        .@"panic.memmoveLenMismatch",
         .@"panic.noreturnReturned",
         => try pt.funcType(.{
             .param_types = &.{},
diff --git a/src/Zcu.zig b/src/Zcu.zig
index 6ff8c98cf8..3e2640fa1a 100644
--- a/src/Zcu.zig
+++ b/src/Zcu.zig
@@ -300,9 +300,8 @@ pub const BuiltinDecl = enum {
     @"panic.shiftRhsTooBig",
     @"panic.invalidEnumValue",
     @"panic.forLenMismatch",
-    @"panic.memcpyLenMismatch",
+    @"panic.copyLenMismatch",
     @"panic.memcpyAlias",
-    @"panic.memmoveLenMismatch",
     @"panic.noreturnReturned",
 
     VaList,
@@ -378,9 +377,8 @@ pub const BuiltinDecl = enum {
             .@"panic.shiftRhsTooBig",
             .@"panic.invalidEnumValue",
             .@"panic.forLenMismatch",
-            .@"panic.memcpyLenMismatch",
+            .@"panic.copyLenMismatch",
             .@"panic.memcpyAlias",
-            .@"panic.memmoveLenMismatch",
             .@"panic.noreturnReturned",
             => .func,
         };
@@ -446,9 +444,8 @@ pub const SimplePanicId = enum {
     shift_rhs_too_big,
     invalid_enum_value,
     for_len_mismatch,
-    memcpy_len_mismatch,
+    copy_len_mismatch,
     memcpy_alias,
-    memmove_len_mismatch,
     noreturn_returned,
 
     pub fn toBuiltin(id: SimplePanicId) BuiltinDecl {
@@ -471,9 +468,8 @@ pub const SimplePanicId = enum {
             .shift_rhs_too_big          => .@"panic.shiftRhsTooBig",
             .invalid_enum_value         => .@"panic.invalidEnumValue",
             .for_len_mismatch           => .@"panic.forLenMismatch",
-            .memcpy_len_mismatch        => .@"panic.memcpyLenMismatch",
+            .copy_len_mismatch          => .@"panic.copyLenMismatch",
             .memcpy_alias               => .@"panic.memcpyAlias",
-            .memmove_len_mismatch       => .@"panic.memmoveLenMismatch",
             .noreturn_returned          => .@"panic.noreturnReturned",
             // zig fmt: on
         };
diff --git a/src/codegen/c.zig b/src/codegen/c.zig
index e7883b9def..e124355bc7 100644
--- a/src/codegen/c.zig
+++ b/src/codegen/c.zig
@@ -3348,8 +3348,8 @@ fn genBodyInner(f: *Function, body: []const Air.Inst.Index) error{ AnalysisFail,
             .atomic_load      => try airAtomicLoad(f, inst),
             .memset           => try airMemset(f, inst, false),
             .memset_safe      => try airMemset(f, inst, true),
-            .memcpy           => try airMemcpy(f, inst),
-            .memmove          => try airMemmove(f, inst),
+            .memcpy           => try airMemcpy(f, inst, "memcpy("),
+            .memmove          => try airMemcpy(f, inst, "memmove("),
             .set_union_tag    => try airSetUnionTag(f, inst),
             .get_union_tag    => try airGetUnionTag(f, inst),
             .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 {
     return .none;
 }
 
-fn airMemcpy(f: *Function, inst: Air.Inst.Index) !CValue {
-    return copyOp(f, inst, .memcpy);
-}
-
-fn airMemmove(f: *Function, inst: Air.Inst.Index) !CValue {
-    return copyOp(f, inst, .memmove);
-}
-
-fn copyOp(f: *Function, inst: Air.Inst.Index, op: enum { memcpy, memmove }) !CValue {
+fn airMemcpy(f: *Function, inst: Air.Inst.Index, function_paren: []const u8) !CValue {
     const pt = f.object.dg.pt;
     const zcu = pt.zcu;
     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
         try writeArrayLen(f, writer, dest_ptr, dest_ty);
         try writer.writeAll(" != 0) ");
     }
-    const function_paren = switch (op) {
-        .memcpy => "memcpy(",
-        .memmove => "memmove(",
-    };
     try writer.writeAll(function_paren);
     try writeSliceOrPtr(f, writer, dest_ptr, dest_ty);
     try writer.writeAll(", ");