Merge pull request #15481 from ziglang/use-mem-intrinsics

actually use the new memory intrinsics

1 files changed, 29 insertions, 23 deletions

diff --git a/src/Sema.zig b/src/Sema.zig
index 8b47f1877b..327ff3800f 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -206,9 +206,9 @@ pub const InstMap = struct {
 
         const start_diff = old_start - better_start;
         const new_items = try allocator.alloc(Air.Inst.Ref, better_capacity);
-        mem.set(Air.Inst.Ref, new_items[0..start_diff], .none);
-        mem.copy(Air.Inst.Ref, new_items[start_diff..], map.items);
-        mem.set(Air.Inst.Ref, new_items[start_diff + map.items.len ..], .none);
+        @memset(new_items[0..start_diff], .none);
+        @memcpy(new_items[start_diff..][0..map.items.len], map.items);
+        @memset(new_items[start_diff + map.items.len ..], .none);
 
         allocator.free(map.items);
         map.items = new_items;
@@ -4307,7 +4307,7 @@ fn validateStructInit(
     // Maps field index to field_ptr index of where it was already initialized.
     const found_fields = try gpa.alloc(Zir.Inst.Index, struct_ty.structFieldCount());
     defer gpa.free(found_fields);
-    mem.set(Zir.Inst.Index, found_fields, 0);
+    @memset(found_fields, 0);
 
     var struct_ptr_zir_ref: Zir.Inst.Ref = undefined;
 
@@ -5113,7 +5113,7 @@ fn zirIntBig(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
     const byte_count = int.len * @sizeOf(std.math.big.Limb);
     const limb_bytes = sema.code.string_bytes[int.start..][0..byte_count];
     const limbs = try arena.alloc(std.math.big.Limb, int.len);
-    mem.copy(u8, mem.sliceAsBytes(limbs), limb_bytes);
+    @memcpy(mem.sliceAsBytes(limbs), limb_bytes);
 
     return sema.addConstant(
         Type.initTag(.comptime_int),
@@ -5967,7 +5967,7 @@ fn addDbgVar(
     const elements_used = name.len / 4 + 1;
     try sema.air_extra.ensureUnusedCapacity(sema.gpa, elements_used);
     const buffer = mem.sliceAsBytes(sema.air_extra.unusedCapacitySlice());
-    mem.copy(u8, buffer, name);
+    @memcpy(buffer[0..name.len], name);
     buffer[name.len] = 0;
     sema.air_extra.items.len += elements_used;
 
@@ -10354,7 +10354,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
         .Enum => {
             seen_enum_fields = try gpa.alloc(?Module.SwitchProngSrc, operand_ty.enumFieldCount());
             empty_enum = seen_enum_fields.len == 0 and !operand_ty.isNonexhaustiveEnum();
-            mem.set(?Module.SwitchProngSrc, seen_enum_fields, null);
+            @memset(seen_enum_fields, null);
             // `range_set` is used for non-exhaustive enum values that do not correspond to any tags.
 
             var extra_index: usize = special.end;
@@ -12809,8 +12809,8 @@ fn analyzeTupleMul(
         }
         i = 0;
         while (i < factor) : (i += 1) {
-            mem.copy(Type, types[tuple_len * i ..], types[0..tuple_len]);
-            mem.copy(Value, values[tuple_len * i ..], values[0..tuple_len]);
+            mem.copyForwards(Type, types[tuple_len * i ..], types[0..tuple_len]);
+            mem.copyForwards(Value, values[tuple_len * i ..], values[0..tuple_len]);
         }
         break :rs runtime_src;
     };
@@ -12835,7 +12835,7 @@ fn analyzeTupleMul(
     }
     i = 1;
     while (i < factor) : (i += 1) {
-        mem.copy(Air.Inst.Ref, element_refs[tuple_len * i ..], element_refs[0..tuple_len]);
+        @memcpy(element_refs[tuple_len * i ..][0..tuple_len], element_refs[0..tuple_len]);
     }
 
     return block.addAggregateInit(tuple_ty, element_refs);
@@ -15057,29 +15057,29 @@ fn zirAsm(
     sema.appendRefsAssumeCapacity(args);
     for (outputs) |o| {
         const buffer = mem.sliceAsBytes(sema.air_extra.unusedCapacitySlice());
-        mem.copy(u8, buffer, o.c);
+        @memcpy(buffer[0..o.c.len], o.c);
         buffer[o.c.len] = 0;
-        mem.copy(u8, buffer[o.c.len + 1 ..], o.n);
+        @memcpy(buffer[o.c.len + 1 ..][0..o.n.len], o.n);
         buffer[o.c.len + 1 + o.n.len] = 0;
         sema.air_extra.items.len += (o.c.len + o.n.len + (2 + 3)) / 4;
     }
     for (inputs) |input| {
         const buffer = mem.sliceAsBytes(sema.air_extra.unusedCapacitySlice());
-        mem.copy(u8, buffer, input.c);
+        @memcpy(buffer[0..input.c.len], input.c);
         buffer[input.c.len] = 0;
-        mem.copy(u8, buffer[input.c.len + 1 ..], input.n);
+        @memcpy(buffer[input.c.len + 1 ..][0..input.n.len], input.n);
         buffer[input.c.len + 1 + input.n.len] = 0;
         sema.air_extra.items.len += (input.c.len + input.n.len + (2 + 3)) / 4;
     }
     for (clobbers) |clobber| {
         const buffer = mem.sliceAsBytes(sema.air_extra.unusedCapacitySlice());
-        mem.copy(u8, buffer, clobber);
+        @memcpy(buffer[0..clobber.len], clobber);
         buffer[clobber.len] = 0;
         sema.air_extra.items.len += clobber.len / 4 + 1;
     }
     {
         const buffer = mem.sliceAsBytes(sema.air_extra.unusedCapacitySlice());
-        mem.copy(u8, buffer, asm_source);
+        @memcpy(buffer[0..asm_source.len], asm_source);
         sema.air_extra.items.len += (asm_source.len + 3) / 4;
     }
     return asm_air;
@@ -17582,7 +17582,7 @@ fn structInitEmpty(
     // The init values to use for the struct instance.
     const field_inits = try gpa.alloc(Air.Inst.Ref, struct_ty.structFieldCount());
     defer gpa.free(field_inits);
-    mem.set(Air.Inst.Ref, field_inits, .none);
+    @memset(field_inits, .none);
 
     return sema.finishStructInit(block, init_src, dest_src, field_inits, struct_ty, false);
 }
@@ -17675,7 +17675,7 @@ fn zirStructInit(
         // The init values to use for the struct instance.
         const field_inits = try gpa.alloc(Air.Inst.Ref, resolved_ty.structFieldCount());
         defer gpa.free(field_inits);
-        mem.set(Air.Inst.Ref, field_inits, .none);
+        @memset(field_inits, .none);
 
         var field_i: u32 = 0;
         var extra_index = extra.end;
@@ -22039,7 +22039,7 @@ fn zirMemset(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void
         if (try sema.resolveMaybeUndefVal(uncoerced_elem)) |_| {
             for (0..len) |i| {
                 const elem_index = try sema.addIntUnsigned(Type.usize, i);
-                const elem_ptr = try sema.elemPtr(
+                const elem_ptr = try sema.elemPtrOneLayerOnly(
                     block,
                     src,
                     dest_ptr,
@@ -26953,9 +26953,13 @@ fn storePtrVal(
             defer sema.gpa.free(buffer);
             reinterpret.val_ptr.*.writeToMemory(mut_kit.ty, sema.mod, buffer) catch |err| switch (err) {
                 error.ReinterpretDeclRef => unreachable,
+                error.IllDefinedMemoryLayout => unreachable, // Sema was supposed to emit a compile error already
+                error.Unimplemented => return sema.fail(block, src, "TODO: implement writeToMemory for type '{}'", .{mut_kit.ty.fmt(sema.mod)}),
             };
             operand_val.writeToMemory(operand_ty, sema.mod, buffer[reinterpret.byte_offset..]) catch |err| switch (err) {
                 error.ReinterpretDeclRef => unreachable,
+                error.IllDefinedMemoryLayout => unreachable, // Sema was supposed to emit a compile error already
+                error.Unimplemented => return sema.fail(block, src, "TODO: implement writeToMemory for type '{}'", .{mut_kit.ty.fmt(sema.mod)}),
             };
 
             const arena = mut_kit.beginArena(sema.mod);
@@ -27075,7 +27079,7 @@ fn beginComptimePtrMutation(
                                 const array_len_including_sentinel =
                                     try sema.usizeCast(block, src, parent.ty.arrayLenIncludingSentinel());
                                 const elems = try arena.alloc(Value, array_len_including_sentinel);
-                                mem.set(Value, elems, Value.undef);
+                                @memset(elems, Value.undef);
 
                                 val_ptr.* = try Value.Tag.aggregate.create(arena, elems);
 
@@ -27273,7 +27277,7 @@ fn beginComptimePtrMutation(
                         switch (parent.ty.zigTypeTag()) {
                             .Struct => {
                                 const fields = try arena.alloc(Value, parent.ty.structFieldCount());
-                                mem.set(Value, fields, Value.undef);
+                                @memset(fields, Value.undef);
 
                                 val_ptr.* = try Value.Tag.aggregate.create(arena, fields);
 
@@ -27905,6 +27909,8 @@ fn bitCastVal(
     defer sema.gpa.free(buffer);
     val.writeToMemory(old_ty, sema.mod, buffer) catch |err| switch (err) {
         error.ReinterpretDeclRef => return null,
+        error.IllDefinedMemoryLayout => unreachable, // Sema was supposed to emit a compile error already
+        error.Unimplemented => return sema.fail(block, src, "TODO: implement writeToMemory for type '{}'", .{old_ty.fmt(sema.mod)}),
     };
     return try Value.readFromMemory(new_ty, sema.mod, buffer[buffer_offset..], sema.arena);
 }
@@ -28419,7 +28425,7 @@ fn coerceTupleToStruct(
     const fields = struct_ty.structFields();
     const field_vals = try sema.arena.alloc(Value, fields.count());
     const field_refs = try sema.arena.alloc(Air.Inst.Ref, field_vals.len);
-    mem.set(Air.Inst.Ref, field_refs, .none);
+    @memset(field_refs, .none);
 
     const inst_ty = sema.typeOf(inst);
     var runtime_src: ?LazySrcLoc = null;
@@ -28508,7 +28514,7 @@ fn coerceTupleToTuple(
     const dest_field_count = tuple_ty.structFieldCount();
     const field_vals = try sema.arena.alloc(Value, dest_field_count);
     const field_refs = try sema.arena.alloc(Air.Inst.Ref, field_vals.len);
-    mem.set(Air.Inst.Ref, field_refs, .none);
+    @memset(field_refs, .none);
 
     const inst_ty = sema.typeOf(inst);
     const inst_field_count = inst_ty.structFieldCount();