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

actually use the new memory intrinsics

11 files changed, 78 insertions, 59 deletions

diff --git a/src/link/Coff.zig b/src/link/Coff.zig
index ed3e213b0e..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,13 +2378,13 @@ 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);
-        mem.set(u8, header.name[name.len..], 0);
+        @memcpy(header.name[0..name.len], name);
+        @memset(header.name[name.len..], 0);
         return;
     }
     const offset = try self.strtab.insert(self.base.allocator, name);
     const name_offset = fmt.bufPrint(&header.name, "/{d}", .{offset}) catch unreachable;
-    mem.set(u8, header.name[name_offset.len..], 0);
+    @memset(header.name[name_offset.len..], 0);
 }
 
 fn getSectionName(self: *const Coff, header: *const coff.SectionHeader) []const u8 {
@@ -2385,17 +2397,17 @@ 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);
-        mem.set(u8, symbol.name[name.len..], 0);
+        @memcpy(symbol.name[0..name.len], name);
+        @memset(symbol.name[name.len..], 0);
         return;
     }
     const offset = try self.strtab.insert(self.base.allocator, name);
-    mem.set(u8, symbol.name[0..4], 0);
+    @memset(symbol.name[0..4], 0);
     mem.writeIntLittle(u32, symbol.name[4..8], offset);
 }
 
 fn logSymAttributes(sym: *const coff.Symbol, buf: *[4]u8) []const u8 {
-    mem.set(u8, buf[0..4], '_');
+    @memset(buf[0..4], '_');
     switch (sym.section_number) {
         .UNDEFINED => {
             buf[3] = 'u';
diff --git a/src/link/Dwarf.zig b/src/link/Dwarf.zig
index 0f2dfbda0e..7a008ca732 100644
--- a/src/link/Dwarf.zig
+++ b/src/link/Dwarf.zig
@@ -1189,7 +1189,7 @@ pub fn commitDeclState(
                         if (needed_size > segment_size) {
                             log.debug("  allocating {d} bytes for 'debug line' information", .{needed_size - segment_size});
                             try debug_line.resize(self.allocator, needed_size);
-                            mem.set(u8, debug_line.items[segment_size..], 0);
+                            @memset(debug_line.items[segment_size..], 0);
                         }
                         debug_line.items.len = needed_size;
                     }
@@ -1458,7 +1458,7 @@ fn writeDeclDebugInfo(self: *Dwarf, atom_index: Atom.Index, dbg_info_buf: []cons
                 if (needed_size > segment_size) {
                     log.debug("  allocating {d} bytes for 'debug info' information", .{needed_size - segment_size});
                     try debug_info.resize(self.allocator, needed_size);
-                    mem.set(u8, debug_info.items[segment_size..], 0);
+                    @memset(debug_info.items[segment_size..], 0);
                 }
                 debug_info.items.len = needed_size;
             }
@@ -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;
@@ -2076,9 +2076,9 @@ fn writeDbgInfoNopsToArrayList(
         buffer.items.len,
         offset + content.len + next_padding_size + 1,
     ));
-    mem.set(u8, buffer.items[offset - prev_padding_size .. offset], @enumToInt(AbbrevKind.pad1));
-    mem.copy(u8, buffer.items[offset..], content);
-    mem.set(u8, buffer.items[offset + content.len ..][0..next_padding_size], @enumToInt(AbbrevKind.pad1));
+    @memset(buffer.items[offset - prev_padding_size .. offset], @enumToInt(AbbrevKind.pad1));
+    @memcpy(buffer.items[offset..][0..content.len], content);
+    @memset(buffer.items[offset + content.len ..][0..next_padding_size], @enumToInt(AbbrevKind.pad1));
 
     if (trailing_zero) {
         buffer.items[offset + content.len + next_padding_size] = 0;
@@ -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/Elf.zig b/src/link/Elf.zig
index 4a6bb99818..48d952b6cc 100644
--- a/src/link/Elf.zig
+++ b/src/link/Elf.zig
@@ -1997,7 +1997,7 @@ fn writeElfHeader(self: *Elf) !void {
     // OS ABI, often set to 0 regardless of target platform
     // ABI Version, possibly used by glibc but not by static executables
     // padding
-    mem.set(u8, hdr_buf[index..][0..9], 0);
+    @memset(hdr_buf[index..][0..9], 0);
     index += 9;
 
     assert(index == 16);
diff --git a/src/link/MachO.zig b/src/link/MachO.zig
index df9b8a768a..21633dea64 100644
--- a/src/link/MachO.zig
+++ b/src/link/MachO.zig
@@ -1454,7 +1454,7 @@ fn createThreadLocalDescriptorAtom(self: *MachO, sym_name: []const u8, target: S
     });
 
     var code: [size]u8 = undefined;
-    mem.set(u8, &code, 0);
+    @memset(&code, 0);
     try self.writeAtom(atom_index, &code);
 
     return atom_index;
@@ -3234,7 +3234,7 @@ fn writeDyldInfoData(self: *MachO) !void {
 
     var buffer = try gpa.alloc(u8, needed_size);
     defer gpa.free(buffer);
-    mem.set(u8, buffer, 0);
+    @memset(buffer, 0);
 
     var stream = std.io.fixedBufferStream(buffer);
     const writer = stream.writer();
@@ -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);
-    mem.set(u8, 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;
 }
 
@@ -4096,8 +4095,8 @@ pub fn logSections(self: *MachO) void {
 }
 
 fn logSymAttributes(sym: macho.nlist_64, buf: *[4]u8) []const u8 {
-    mem.set(u8, buf[0..4], '_');
-    mem.set(u8, buf[4..], ' ');
+    @memset(buf[0..4], '_');
+    @memset(buf[4..], ' ');
     if (sym.sect()) {
         buf[0] = 's';
     }
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/Object.zig b/src/link/MachO/Object.zig
index e407457e03..7cc6f78c7d 100644
--- a/src/link/MachO/Object.zig
+++ b/src/link/MachO/Object.zig
@@ -156,7 +156,7 @@ pub fn parse(self: *Object, allocator: Allocator, cpu_arch: std.Target.Cpu.Arch)
 
     // Prepopulate relocations per section lookup table.
     try self.section_relocs_lookup.resize(allocator, nsects);
-    mem.set(u32, self.section_relocs_lookup.items, 0);
+    @memset(self.section_relocs_lookup.items, 0);
 
     // Parse symtab.
     const symtab = while (it.next()) |cmd| switch (cmd.cmd()) {
@@ -189,10 +189,10 @@ pub fn parse(self: *Object, allocator: Allocator, cpu_arch: std.Target.Cpu.Arch)
         };
     }
 
-    mem.set(i64, self.globals_lookup, -1);
-    mem.set(AtomIndex, self.atom_by_index_table, 0);
-    mem.set(Entry, self.source_section_index_lookup, .{});
-    mem.set(Entry, self.relocs_lookup, .{});
+    @memset(self.globals_lookup, -1);
+    @memset(self.atom_by_index_table, 0);
+    @memset(self.source_section_index_lookup, .{});
+    @memset(self.relocs_lookup, .{});
 
     // You would expect that the symbol table is at least pre-sorted based on symbol's type:
     // local < extern defined < undefined. Unfortunately, this is not guaranteed! For instance,
@@ -252,7 +252,7 @@ pub fn parse(self: *Object, allocator: Allocator, cpu_arch: std.Target.Cpu.Arch)
     self.unwind_info_sect_id = self.getSourceSectionIndexByName("__LD", "__compact_unwind");
     if (self.hasUnwindRecords()) {
         self.unwind_relocs_lookup = try allocator.alloc(Record, self.getUnwindRecords().len);
-        mem.set(Record, self.unwind_relocs_lookup, .{ .dead = true, .reloc = .{} });
+        @memset(self.unwind_relocs_lookup, .{ .dead = true, .reloc = .{} });
     }
 }
 
diff --git a/src/link/MachO/Trie.zig b/src/link/MachO/Trie.zig
index a97e18a186..34200db7dc 100644
--- a/src/link/MachO/Trie.zig
+++ b/src/link/MachO/Trie.zig
@@ -499,7 +499,7 @@ fn expectEqualHexStrings(expected: []const u8, given: []const u8) !void {
     const idx = mem.indexOfDiff(u8, expected_fmt, given_fmt).?;
     var padding = try testing.allocator.alloc(u8, idx + 5);
     defer testing.allocator.free(padding);
-    mem.set(u8, padding, ' ');
+    @memset(padding, ' ');
     std.debug.print("\nEXP: {s}\nGIV: {s}\n{s}^ -- first differing byte\n", .{ expected_fmt, given_fmt, padding });
     return error.TestFailed;
 }
diff --git a/src/link/MachO/UnwindInfo.zig b/src/link/MachO/UnwindInfo.zig
index e59f5fe250..0071657f8b 100644
--- a/src/link/MachO/UnwindInfo.zig
+++ b/src/link/MachO/UnwindInfo.zig
@@ -659,7 +659,7 @@ pub fn write(info: *UnwindInfo, zld: *Zld) !void {
     const padding = buffer.items.len - cwriter.bytes_written;
     if (padding > 0) {
         const offset = math.cast(usize, cwriter.bytes_written) orelse return error.Overflow;
-        mem.set(u8, buffer.items[offset..], 0);
+        @memset(buffer.items[offset..], 0);
     }
 
     try zld.file.pwriteAll(buffer.items, sect.offset);
diff --git a/src/link/MachO/zld.zig b/src/link/MachO/zld.zig
index bc658fc8d2..7e6870ecbc 100644
--- a/src/link/MachO/zld.zig
+++ b/src/link/MachO/zld.zig
@@ -2140,7 +2140,7 @@ pub const Zld = struct {
 
         var buffer = try gpa.alloc(u8, needed_size);
         defer gpa.free(buffer);
-        mem.set(u8, buffer, 0);
+        @memset(buffer, 0);
 
         var stream = std.io.fixedBufferStream(buffer);
         const writer = stream.writer();
@@ -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);
-        mem.set(u8, 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);
-        mem.set(u8, 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;
     }
 
@@ -3199,7 +3201,7 @@ pub const Zld = struct {
             scoped_log.debug("  object({d}): {s}", .{ id, object.name });
             if (object.in_symtab == null) continue;
             for (object.symtab, 0..) |sym, sym_id| {
-                mem.set(u8, &buf, '_');
+                @memset(&buf, '_');
                 scoped_log.debug("    %{d}: {s} @{x} in sect({d}), {s}", .{
                     sym_id,
                     object.getSymbolName(@intCast(u32, sym_id)),
@@ -4007,7 +4009,7 @@ pub fn linkWithZld(macho_file: *MachO, comp: *Compilation, prog_node: *std.Progr
                 log.debug("zeroing out zerofill area of length {x} at {x}", .{ size, start });
                 var padding = try zld.gpa.alloc(u8, size);
                 defer zld.gpa.free(padding);
-                mem.set(u8, padding, 0);
+                @memset(padding, 0);
                 try zld.file.pwriteAll(padding, start);
             }
         }
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 0fe9ec5e3b..b6f4a4cc59 100644
--- a/src/link/Wasm.zig
+++ b/src/link/Wasm.zig
@@ -1976,7 +1976,7 @@ fn parseAtom(wasm: *Wasm, atom_index: Atom.Index, kind: Kind) !void {
             // We do not have to do this when exporting the memory (the default) because the runtime
             // will do it for us, and we do not emit the bss segment at all.
             if ((wasm.base.options.output_mode == .Obj or wasm.base.options.import_memory) and kind.data == .uninitialized) {
-                std.mem.set(u8, atom.code.items, 0);
+                @memset(atom.code.items, 0);
             }
 
             const should_merge = wasm.base.options.output_mode != .Obj;
@@ -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 {