compiler: use `@memcpy` instead of `std.mem.copy`

7 files changed, 52 insertions, 33 deletions

diff --git a/src/link/Coff.zig b/src/link/Coff.zig
index 489d9e0443..0af681bb5e 100644
--- a/src/link/Coff.zig
+++ b/src/link/Coff.zig
@@ -1916,7 +1916,7 @@ fn writeImportTables(self: *Coff) !void {
             .name_rva = header.virtual_address + dll_names_offset,
             .import_address_table_rva = header.virtual_address + iat_offset,
         };
-        mem.copy(u8, buffer.items[dir_table_offset..], mem.asBytes(&lookup_header));
+        @memcpy(buffer.items[dir_table_offset..][0..@sizeOf(coff.ImportDirectoryEntry)], mem.asBytes(&lookup_header));
         dir_table_offset += dir_header_size;
 
         for (itable.entries.items) |entry| {
@@ -1924,15 +1924,21 @@ fn writeImportTables(self: *Coff) !void {
 
             // IAT and lookup table entry
             const lookup = coff.ImportLookupEntry64.ByName{ .name_table_rva = @intCast(u31, header.virtual_address + names_table_offset) };
-            mem.copy(u8, buffer.items[iat_offset..], mem.asBytes(&lookup));
+            @memcpy(
+                buffer.items[iat_offset..][0..@sizeOf(coff.ImportLookupEntry64.ByName)],
+                mem.asBytes(&lookup),
+            );
             iat_offset += lookup_entry_size;
-            mem.copy(u8, buffer.items[lookup_table_offset..], mem.asBytes(&lookup));
+            @memcpy(
+                buffer.items[lookup_table_offset..][0..@sizeOf(coff.ImportLookupEntry64.ByName)],
+                mem.asBytes(&lookup),
+            );
             lookup_table_offset += lookup_entry_size;
 
             // Names table entry
             mem.writeIntLittle(u16, buffer.items[names_table_offset..][0..2], 0); // Hint set to 0 until we learn how to parse DLLs
             names_table_offset += 2;
-            mem.copy(u8, buffer.items[names_table_offset..], import_name);
+            @memcpy(buffer.items[names_table_offset..][0..import_name.len], import_name);
             names_table_offset += @intCast(u32, import_name.len);
             buffer.items[names_table_offset] = 0;
             names_table_offset += 1;
@@ -1947,13 +1953,16 @@ fn writeImportTables(self: *Coff) !void {
         iat_offset += 8;
 
         // Lookup table sentinel
-        mem.copy(u8, buffer.items[lookup_table_offset..], mem.asBytes(&coff.ImportLookupEntry64.ByName{ .name_table_rva = 0 }));
+        @memcpy(
+            buffer.items[lookup_table_offset..][0..@sizeOf(coff.ImportLookupEntry64.ByName)],
+            mem.asBytes(&coff.ImportLookupEntry64.ByName{ .name_table_rva = 0 }),
+        );
         lookup_table_offset += lookup_entry_size;
 
         // DLL name
-        mem.copy(u8, buffer.items[dll_names_offset..], lib_name);
+        @memcpy(buffer.items[dll_names_offset..][0..lib_name.len], lib_name);
         dll_names_offset += @intCast(u32, lib_name.len);
-        mem.copy(u8, buffer.items[dll_names_offset..], ext);
+        @memcpy(buffer.items[dll_names_offset..][0..ext.len], ext);
         dll_names_offset += @intCast(u32, ext.len);
         buffer.items[dll_names_offset] = 0;
         dll_names_offset += 1;
@@ -1967,7 +1976,10 @@ fn writeImportTables(self: *Coff) !void {
         .name_rva = 0,
         .import_address_table_rva = 0,
     };
-    mem.copy(u8, buffer.items[dir_table_offset..], mem.asBytes(&lookup_header));
+    @memcpy(
+        buffer.items[dir_table_offset..][0..@sizeOf(coff.ImportDirectoryEntry)],
+        mem.asBytes(&lookup_header),
+    );
     dir_table_offset += dir_header_size;
 
     assert(dll_names_offset == needed_size);
@@ -2366,7 +2378,7 @@ pub fn getAtomIndexForSymbol(self: *const Coff, sym_loc: SymbolWithLoc) ?Atom.In
 
 fn setSectionName(self: *Coff, header: *coff.SectionHeader, name: []const u8) !void {
     if (name.len <= 8) {
-        mem.copy(u8, &header.name, name);
+        @memcpy(header.name[0..name.len], name);
         @memset(header.name[name.len..], 0);
         return;
     }
@@ -2385,7 +2397,7 @@ fn getSectionName(self: *const Coff, header: *const coff.SectionHeader) []const
 
 fn setSymbolName(self: *Coff, symbol: *coff.Symbol, name: []const u8) !void {
     if (name.len <= 8) {
-        mem.copy(u8, &symbol.name, name);
+        @memcpy(symbol.name[0..name.len], name);
         @memset(symbol.name[name.len..], 0);
         return;
     }
diff --git a/src/link/Dwarf.zig b/src/link/Dwarf.zig
index a867bf8d80..7a008ca732 100644
--- a/src/link/Dwarf.zig
+++ b/src/link/Dwarf.zig
@@ -1515,7 +1515,7 @@ pub fn updateDeclLineNumber(self: *Dwarf, module: *Module, decl_index: Module.De
             const wasm_file = self.bin_file.cast(File.Wasm).?;
             const offset = atom.off + self.getRelocDbgLineOff();
             const line_atom_index = wasm_file.debug_line_atom.?;
-            mem.copy(u8, wasm_file.getAtomPtr(line_atom_index).code.items[offset..], &data);
+            wasm_file.getAtomPtr(line_atom_index).code.items[offset..][0..data.len].* = data;
         },
         else => unreachable,
     }
@@ -1734,7 +1734,7 @@ pub fn writeDbgAbbrev(self: *Dwarf) !void {
             const wasm_file = self.bin_file.cast(File.Wasm).?;
             const debug_abbrev = &wasm_file.getAtomPtr(wasm_file.debug_abbrev_atom.?).code;
             try debug_abbrev.resize(wasm_file.base.allocator, needed_size);
-            mem.copy(u8, debug_abbrev.items, &abbrev_buf);
+            debug_abbrev.items[0..abbrev_buf.len].* = abbrev_buf;
         },
         else => unreachable,
     }
@@ -1976,7 +1976,7 @@ fn writeDbgLineNopsBuffered(
         }
     }
 
-    mem.copy(u8, buf[offset..], content);
+    @memcpy(buf[offset..][0..content.len], content);
 
     {
         var padding_left = next_padding_size;
@@ -2077,7 +2077,7 @@ fn writeDbgInfoNopsToArrayList(
         offset + content.len + next_padding_size + 1,
     ));
     @memset(buffer.items[offset - prev_padding_size .. offset], @enumToInt(AbbrevKind.pad1));
-    mem.copy(u8, buffer.items[offset..], content);
+    @memcpy(buffer.items[offset..][0..content.len], content);
     @memset(buffer.items[offset + content.len ..][0..next_padding_size], @enumToInt(AbbrevKind.pad1));
 
     if (trailing_zero) {
@@ -2168,7 +2168,7 @@ pub fn writeDbgAranges(self: *Dwarf, addr: u64, size: u64) !void {
             const wasm_file = self.bin_file.cast(File.Wasm).?;
             const debug_ranges = &wasm_file.getAtomPtr(wasm_file.debug_ranges_atom.?).code;
             try debug_ranges.resize(wasm_file.base.allocator, needed_size);
-            mem.copy(u8, debug_ranges.items, di_buf.items);
+            @memcpy(debug_ranges.items[0..di_buf.items.len], di_buf.items);
         },
         else => unreachable,
     }
@@ -2341,9 +2341,12 @@ pub fn writeDbgLineHeader(self: *Dwarf) !void {
             .wasm => {
                 const wasm_file = self.bin_file.cast(File.Wasm).?;
                 const debug_line = &wasm_file.getAtomPtr(wasm_file.debug_line_atom.?).code;
-                mem.copy(u8, buffer, debug_line.items[first_fn.off..]);
+                {
+                    const src = debug_line.items[first_fn.off..];
+                    @memcpy(buffer[0..src.len], src);
+                }
                 try debug_line.resize(self.allocator, debug_line.items.len + delta);
-                mem.copy(u8, debug_line.items[first_fn.off + delta ..], buffer);
+                @memcpy(debug_line.items[first_fn.off + delta ..][0..buffer.len], buffer);
             },
             else => unreachable,
         }
@@ -2537,7 +2540,7 @@ pub fn flushModule(self: *Dwarf, module: *Module) !void {
                 .wasm => {
                     const wasm_file = self.bin_file.cast(File.Wasm).?;
                     const debug_info = wasm_file.getAtomPtr(wasm_file.debug_info_atom.?).code;
-                    mem.copy(u8, debug_info.items[atom.off + reloc.offset ..], &buf);
+                    debug_info.items[atom.off + reloc.offset ..][0..buf.len].* = buf;
                 },
                 else => unreachable,
             }
diff --git a/src/link/MachO.zig b/src/link/MachO.zig
index eebd2ad8a4..21633dea64 100644
--- a/src/link/MachO.zig
+++ b/src/link/MachO.zig
@@ -3389,8 +3389,8 @@ fn writeStrtab(self: *MachO) !void {
 
     const buffer = try gpa.alloc(u8, math.cast(usize, needed_size_aligned) orelse return error.Overflow);
     defer gpa.free(buffer);
-    @memset(buffer, 0);
-    mem.copy(u8, buffer, self.strtab.buffer.items);
+    @memcpy(buffer[0..self.strtab.buffer.items.len], self.strtab.buffer.items);
+    @memset(buffer[self.strtab.buffer.items.len..], 0);
 
     try self.base.file.?.pwriteAll(buffer, offset);
 
@@ -3668,8 +3668,7 @@ fn addUndefined(self: *MachO, name: []const u8, action: ResolveAction.Kind) !u32
 
 pub fn makeStaticString(bytes: []const u8) [16]u8 {
     var buf = [_]u8{0} ** 16;
-    assert(bytes.len <= buf.len);
-    mem.copy(u8, &buf, bytes);
+    @memcpy(buf[0..bytes.len], bytes);
     return buf;
 }
 
diff --git a/src/link/MachO/CodeSignature.zig b/src/link/MachO/CodeSignature.zig
index 6d1cd7b536..59b3e50b07 100644
--- a/src/link/MachO/CodeSignature.zig
+++ b/src/link/MachO/CodeSignature.zig
@@ -100,7 +100,7 @@ const CodeDirectory = struct {
     fn addSpecialHash(self: *CodeDirectory, index: u32, hash: [hash_size]u8) void {
         assert(index > 0);
         self.inner.nSpecialSlots = std.math.max(self.inner.nSpecialSlots, index);
-        mem.copy(u8, &self.special_slots[index - 1], &hash);
+        self.special_slots[index - 1] = hash;
     }
 
     fn slotType(self: CodeDirectory) u32 {
diff --git a/src/link/MachO/zld.zig b/src/link/MachO/zld.zig
index ce19626ff4..7e6870ecbc 100644
--- a/src/link/MachO/zld.zig
+++ b/src/link/MachO/zld.zig
@@ -2352,8 +2352,11 @@ pub const Zld = struct {
 
         const buffer = try self.gpa.alloc(u8, math.cast(usize, needed_size_aligned) orelse return error.Overflow);
         defer self.gpa.free(buffer);
-        @memset(buffer, 0);
-        mem.copy(u8, buffer, mem.sliceAsBytes(out_dice.items));
+        {
+            const src = mem.sliceAsBytes(out_dice.items);
+            @memcpy(buffer[0..src.len], src);
+            @memset(buffer[src.len..], 0);
+        }
 
         log.debug("writing data-in-code from 0x{x} to 0x{x}", .{ offset, offset + needed_size_aligned });
 
@@ -2484,8 +2487,8 @@ pub const Zld = struct {
 
         const buffer = try self.gpa.alloc(u8, math.cast(usize, needed_size_aligned) orelse return error.Overflow);
         defer self.gpa.free(buffer);
-        @memset(buffer, 0);
-        mem.copy(u8, buffer, self.strtab.buffer.items);
+        @memcpy(buffer[0..self.strtab.buffer.items.len], self.strtab.buffer.items);
+        @memset(buffer[self.strtab.buffer.items.len..], 0);
 
         try self.file.pwriteAll(buffer, offset);
 
@@ -2805,8 +2808,7 @@ pub const Zld = struct {
 
     pub fn makeStaticString(bytes: []const u8) [16]u8 {
         var buf = [_]u8{0} ** 16;
-        assert(bytes.len <= buf.len);
-        mem.copy(u8, &buf, bytes);
+        @memcpy(buf[0..bytes.len], bytes);
         return buf;
     }
 
diff --git a/src/link/Plan9.zig b/src/link/Plan9.zig
index e7b401e8af..bef06d1c87 100644
--- a/src/link/Plan9.zig
+++ b/src/link/Plan9.zig
@@ -681,7 +681,7 @@ pub fn flushModule(self: *Plan9, comp: *Compilation, prog_node: *std.Progress.No
         .pcsz = @intCast(u32, linecountinfo.items.len),
         .entry = @intCast(u32, self.entry_val.?),
     };
-    std.mem.copy(u8, hdr_slice, self.hdr.toU8s()[0..hdr_size]);
+    @memcpy(hdr_slice, self.hdr.toU8s()[0..hdr_size]);
     // write the fat header for 64 bit entry points
     if (self.sixtyfour_bit) {
         mem.writeIntSliceBig(u64, hdr_buf[32..40], self.entry_val.?);
diff --git a/src/link/Wasm.zig b/src/link/Wasm.zig
index 74bfd255bd..b6f4a4cc59 100644
--- a/src/link/Wasm.zig
+++ b/src/link/Wasm.zig
@@ -3852,7 +3852,10 @@ fn writeToFile(
     // Only when writing all sections executed properly we write the magic
     // bytes. This allows us to easily detect what went wrong while generating
     // the final binary.
-    mem.copy(u8, binary_bytes.items, &(std.wasm.magic ++ std.wasm.version));
+    {
+        const src = std.wasm.magic ++ std.wasm.version;
+        binary_bytes.items[0..src.len].* = src;
+    }
 
     // finally, write the entire binary into the file.
     var iovec = [_]std.os.iovec_const{.{
@@ -4559,14 +4562,14 @@ fn writeVecSectionHeader(buffer: []u8, offset: u32, section: std.wasm.Section, s
     buf[0] = @enumToInt(section);
     leb.writeUnsignedFixed(5, buf[1..6], size);
     leb.writeUnsignedFixed(5, buf[6..], items);
-    mem.copy(u8, buffer[offset..], &buf);
+    buffer[offset..][0..buf.len].* = buf;
 }
 
 fn writeCustomSectionHeader(buffer: []u8, offset: u32, size: u32) !void {
     var buf: [1 + 5]u8 = undefined;
     buf[0] = 0; // 0 = 'custom' section
     leb.writeUnsignedFixed(5, buf[1..6], size);
-    mem.copy(u8, buffer[offset..], &buf);
+    buffer[offset..][0..buf.len].* = buf;
 }
 
 fn emitLinkSection(wasm: *Wasm, binary_bytes: *std.ArrayList(u8), symbol_table: *std.AutoArrayHashMap(SymbolLoc, u32)) !void {