From 6261c1373168b265047db5704d9d0fd5f2e458f2 Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Wed, 26 Apr 2023 13:57:08 -0700 Subject: update codebase to use `@memset` and `@memcpy` --- src/link/MachO.zig | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) (limited to 'src/link/MachO.zig') diff --git a/src/link/MachO.zig b/src/link/MachO.zig index df9b8a768a..eebd2ad8a4 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,7 +3389,7 @@ 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); + @memset(buffer, 0); mem.copy(u8, buffer, self.strtab.buffer.items); try self.base.file.?.pwriteAll(buffer, offset); @@ -4096,8 +4096,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'; } -- cgit v1.2.3 From 42973d73e6b045f242cc67015fba023ff46e9929 Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Thu, 27 Apr 2023 15:40:00 -0700 Subject: compiler: use `@memcpy` instead of `std.mem.copy` --- src/AstGen.zig | 2 +- src/Autodoc.zig | 2 +- src/Liveness.zig | 6 +++--- src/arch/x86_64/Encoding.zig | 6 ++++-- src/codegen.zig | 2 +- src/link/Coff.zig | 32 ++++++++++++++++++++++---------- src/link/Dwarf.zig | 19 +++++++++++-------- src/link/MachO.zig | 7 +++---- src/link/MachO/CodeSignature.zig | 2 +- src/link/MachO/zld.zig | 14 ++++++++------ src/link/Plan9.zig | 2 +- src/link/Wasm.zig | 9 ++++++--- src/objcopy.zig | 36 ++++++++++++++++++------------------ src/translate_c.zig | 2 +- src/type.zig | 2 +- 15 files changed, 82 insertions(+), 61 deletions(-) (limited to 'src/link/MachO.zig') diff --git a/src/AstGen.zig b/src/AstGen.zig index 6c9972bc95..aece3eafec 100644 --- a/src/AstGen.zig +++ b/src/AstGen.zig @@ -3604,7 +3604,7 @@ const WipMembers = struct { fn appendToDeclSlice(self: *Self, data: []const u32) void { assert(self.decls_end + data.len <= self.field_bits_start); - mem.copy(u32, self.payload.items[self.decls_end..], data); + @memcpy(self.payload.items[self.decls_end..][0..data.len], data); self.decls_end += @intCast(u32, data.len); } diff --git a/src/Autodoc.zig b/src/Autodoc.zig index 91e252a3f8..467ff55994 100644 --- a/src/Autodoc.zig +++ b/src/Autodoc.zig @@ -1146,7 +1146,7 @@ fn walkInstruction( const limb_bytes = file.zir.string_bytes[str.start..][0..byte_count]; var limbs = try self.arena.alloc(std.math.big.Limb, str.len); - std.mem.copy(u8, std.mem.sliceAsBytes(limbs), limb_bytes); + @memcpy(std.mem.sliceAsBytes(limbs)[0..limb_bytes.len], limb_bytes); const big_int = std.math.big.int.Const{ .limbs = limbs, diff --git a/src/Liveness.zig b/src/Liveness.zig index deb6c330c2..a1bfb73e2a 100644 --- a/src/Liveness.zig +++ b/src/Liveness.zig @@ -1150,7 +1150,7 @@ fn analyzeInst( if (args.len + 1 <= bpi - 1) { var buf = [1]Air.Inst.Ref{.none} ** (bpi - 1); buf[0] = callee; - std.mem.copy(Air.Inst.Ref, buf[1..], args); + @memcpy(buf[1..][0..args.len], args); return analyzeOperands(a, pass, data, inst, buf); } @@ -1189,7 +1189,7 @@ fn analyzeInst( if (elements.len <= bpi - 1) { var buf = [1]Air.Inst.Ref{.none} ** (bpi - 1); - std.mem.copy(Air.Inst.Ref, &buf, elements); + @memcpy(buf[0..elements.len], elements); return analyzeOperands(a, pass, data, inst, buf); } @@ -1255,7 +1255,7 @@ fn analyzeInst( if (buf_index + inputs.len > buf.len) { break :simple buf_index + inputs.len; } - std.mem.copy(Air.Inst.Ref, buf[buf_index..], inputs); + @memcpy(buf[buf_index..][0..inputs.len], inputs); return analyzeOperands(a, pass, data, inst, buf); }; diff --git a/src/arch/x86_64/Encoding.zig b/src/arch/x86_64/Encoding.zig index ee868e4aea..80407583e8 100644 --- a/src/arch/x86_64/Encoding.zig +++ b/src/arch/x86_64/Encoding.zig @@ -575,8 +575,10 @@ const mnemonic_to_encodings_map = init: { .modrm_ext = entry[4], .mode = entry[5], }; - std.mem.copy(Op, &data.ops, entry[2]); - std.mem.copy(u8, &data.opc, entry[3]); + // TODO: use `@memcpy` for these. When I did that, I got an false positive + // compile error for this copy happening at compile time. + std.mem.copyForwards(Op, &data.ops, entry[2]); + std.mem.copyForwards(u8, &data.opc, entry[3]); while (mnemonic_int < @enumToInt(entry[0])) : (mnemonic_int += 1) { mnemonic_map[mnemonic_int] = data_storage[mnemonic_start..data_index]; diff --git a/src/codegen.zig b/src/codegen.zig index dbcd76118a..bf80a90cc3 100644 --- a/src/codegen.zig +++ b/src/codegen.zig @@ -552,7 +552,7 @@ pub fn generateSymbol( .ty = field_ty, .val = field_val, }, &tmp_list, debug_output, reloc_info)) { - .ok => mem.copy(u8, code.items[current_pos..], tmp_list.items), + .ok => @memcpy(code.items[current_pos..][0..tmp_list.items.len], tmp_list.items), .fail => |em| return Result{ .fail = em }, } } else { 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 { diff --git a/src/objcopy.zig b/src/objcopy.zig index 239f1f3ad7..12129aba9c 100644 --- a/src/objcopy.zig +++ b/src/objcopy.zig @@ -860,7 +860,7 @@ fn ElfFile(comptime is_64: bool) type { if (section.payload) |data| { switch (section.section.sh_type) { elf.DT_VERSYM => { - std.debug.assert(section.section.sh_entsize == @sizeOf(Elf_Verdef)); + assert(section.section.sh_entsize == @sizeOf(Elf_Verdef)); const defs = @ptrCast([*]const Elf_Verdef, data)[0 .. @intCast(usize, section.section.sh_size) / @sizeOf(Elf_Verdef)]; for (defs) |def| { if (def.vd_ndx != elf.SHN_UNDEF) @@ -868,7 +868,7 @@ fn ElfFile(comptime is_64: bool) type { } }, elf.SHT_SYMTAB, elf.SHT_DYNSYM => { - std.debug.assert(section.section.sh_entsize == @sizeOf(Elf_Sym)); + assert(section.section.sh_entsize == @sizeOf(Elf_Sym)); const syms = @ptrCast([*]const Elf_Sym, data)[0 .. @intCast(usize, section.section.sh_size) / @sizeOf(Elf_Sym)]; for (syms) |sym| { @@ -952,11 +952,11 @@ fn ElfFile(comptime is_64: bool) type { const name: []const u8 = ".gnu_debuglink"; const new_offset = @intCast(u32, strtab.payload.?.len); const buf = try allocator.alignedAlloc(u8, section_memory_align, new_offset + name.len + 1); - std.mem.copy(u8, buf[0..new_offset], strtab.payload.?); - std.mem.copy(u8, buf[new_offset .. new_offset + name.len], name); + @memcpy(buf[0..new_offset], strtab.payload.?); + @memcpy(buf[new_offset..][0..name.len], name); buf[new_offset + name.len] = 0; - std.debug.assert(update.action == .keep); + assert(update.action == .keep); update.payload = buf; break :blk new_offset; @@ -978,9 +978,9 @@ fn ElfFile(comptime is_64: bool) type { // program header as-is. // nb: for only-debug files, removing it appears to work, but is invalid by ELF specifcation. { - std.debug.assert(updated_elf_header.e_phoff == @sizeOf(Elf_Ehdr)); + assert(updated_elf_header.e_phoff == @sizeOf(Elf_Ehdr)); const data = std.mem.sliceAsBytes(self.program_segments); - std.debug.assert(data.len == @as(usize, updated_elf_header.e_phentsize) * updated_elf_header.e_phnum); + assert(data.len == @as(usize, updated_elf_header.e_phentsize) * updated_elf_header.e_phnum); cmdbuf.appendAssumeCapacity(.{ .write_data = .{ .data = data, .out_offset = updated_elf_header.e_phoff } }); eof_offset = updated_elf_header.e_phoff + @intCast(Elf_OffSize, data.len); } @@ -1006,7 +1006,7 @@ fn ElfFile(comptime is_64: bool) type { var dest_section_idx: u32 = 1; for (self.sections[1..], sections_update[1..]) |section, update| { if (update.action == .strip) continue; - std.debug.assert(update.remap_idx == dest_section_idx); + assert(update.remap_idx == dest_section_idx); const src = if (update.section) |*s| s else §ion.section; const dest = &dest_sections[dest_section_idx]; @@ -1032,7 +1032,7 @@ fn ElfFile(comptime is_64: bool) type { fatal("zig objcopy: cannot adjust program segments", .{}); } } - std.debug.assert(dest.sh_addr % addralign == dest.sh_offset % addralign); + assert(dest.sh_addr % addralign == dest.sh_offset % addralign); if (update.action == .empty) dest.sh_type = elf.SHT_NOBITS; @@ -1043,7 +1043,7 @@ fn ElfFile(comptime is_64: bool) type { const dest_data = switch (src.sh_type) { elf.DT_VERSYM => dst_data: { const data = try allocator.alignedAlloc(u8, section_memory_align, src_data.len); - std.mem.copy(u8, data, src_data); + @memcpy(data, src_data); const defs = @ptrCast([*]Elf_Verdef, data)[0 .. @intCast(usize, src.sh_size) / @sizeOf(Elf_Verdef)]; for (defs) |*def| { @@ -1055,7 +1055,7 @@ fn ElfFile(comptime is_64: bool) type { }, elf.SHT_SYMTAB, elf.SHT_DYNSYM => dst_data: { const data = try allocator.alignedAlloc(u8, section_memory_align, src_data.len); - std.mem.copy(u8, data, src_data); + @memcpy(data, src_data); const syms = @ptrCast([*]Elf_Sym, data)[0 .. @intCast(usize, src.sh_size) / @sizeOf(Elf_Sym)]; for (syms) |*sym| { @@ -1068,7 +1068,7 @@ fn ElfFile(comptime is_64: bool) type { else => src_data, }; - std.debug.assert(dest_data.len == dest.sh_size); + assert(dest_data.len == dest.sh_size); cmdbuf.appendAssumeCapacity(.{ .write_data = .{ .data = dest_data, .out_offset = dest.sh_offset } }); eof_offset = dest.sh_offset + dest.sh_size; } else { @@ -1087,9 +1087,9 @@ fn ElfFile(comptime is_64: bool) type { const payload = payload: { const crc_offset = std.mem.alignForward(link.name.len + 1, 4); const buf = try allocator.alignedAlloc(u8, 4, crc_offset + 4); - std.mem.copy(u8, buf[0..link.name.len], link.name); + @memcpy(buf[0..link.name.len], link.name); @memset(buf[link.name.len..crc_offset], 0); - std.mem.copy(u8, buf[crc_offset..], std.mem.asBytes(&link.crc32)); + @memcpy(buf[crc_offset..], std.mem.asBytes(&link.crc32)); break :payload buf; }; @@ -1111,7 +1111,7 @@ fn ElfFile(comptime is_64: bool) type { eof_offset += @intCast(Elf_OffSize, payload.len); } - std.debug.assert(dest_section_idx == new_shnum); + assert(dest_section_idx == new_shnum); break :blk dest_sections; }; @@ -1120,7 +1120,7 @@ fn ElfFile(comptime is_64: bool) type { const offset = std.mem.alignForwardGeneric(Elf_OffSize, eof_offset, @alignOf(Elf_Shdr)); const data = std.mem.sliceAsBytes(updated_section_header); - std.debug.assert(data.len == @as(usize, updated_elf_header.e_shentsize) * new_shnum); + assert(data.len == @as(usize, updated_elf_header.e_shentsize) * new_shnum); updated_elf_header.e_shoff = offset; updated_elf_header.e_shnum = new_shnum; @@ -1215,7 +1215,7 @@ const ElfFileHelper = struct { for (cmds) |cmd| { switch (cmd) { .write_data => |data| { - std.debug.assert(data.out_offset >= offset); + assert(data.out_offset >= offset); if (fused_cmd) |prev| { consolidated.appendAssumeCapacity(prev); fused_cmd = null; @@ -1227,7 +1227,7 @@ const ElfFileHelper = struct { offset = data.out_offset + data.data.len; }, .copy_range => |range| { - std.debug.assert(range.out_offset >= offset); + assert(range.out_offset >= offset); if (fused_cmd) |prev| { if (range.in_offset >= prev.copy_range.in_offset + prev.copy_range.len and (range.out_offset - prev.copy_range.out_offset == range.in_offset - prev.copy_range.in_offset)) { fused_cmd = .{ .copy_range = .{ diff --git a/src/translate_c.zig b/src/translate_c.zig index 7ad58329df..bc7a1138da 100644 --- a/src/translate_c.zig +++ b/src/translate_c.zig @@ -113,7 +113,7 @@ const Scope = struct { const alloc_len = self.statements.items.len + @boolToInt(self.base.parent.?.id == .do_loop); var stmts = try c.arena.alloc(Node, alloc_len); stmts.len = self.statements.items.len; - mem.copy(Node, stmts, self.statements.items); + @memcpy(stmts[0..self.statements.items.len], self.statements.items); return Tag.block.create(c.arena, .{ .label = self.label, .stmts = stmts, diff --git a/src/type.zig b/src/type.zig index c7b2844970..816a1ee2e0 100644 --- a/src/type.zig +++ b/src/type.zig @@ -4767,7 +4767,7 @@ pub const Type = extern union { .fn_ccc_void_no_args => return, .function => { const payload = self.castTag(.function).?.data; - std.mem.copy(Type, types, payload.param_types); + @memcpy(types[0..payload.param_types.len], payload.param_types); }, else => unreachable, -- cgit v1.2.3