mirror/zig
1
0
Fork 0
mirror of https://github.com/ziglang/zig.git synced 2026-02-02 04:33:37 +00:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Andrew Kelley 2023-04-27 15:40:00 -07:00
parent 125221cce9
commit 42973d73e6
15 changed files with 82 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/AstGen.zig
View File

@ -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);
}

2
src/Autodoc.zig
View File

@ -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,

6
src/Liveness.zig
View File

@ -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);
};

6
src/arch/x86_64/Encoding.zig
View File

@ -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];

2
src/codegen.zig
View File

@ -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 {

32
src/link/Coff.zig
View File

@ -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;
}

19
src/link/Dwarf.zig
View File

@ -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,
}

7
src/link/MachO.zig
View File

@ -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;
}

2
src/link/MachO/CodeSignature.zig
View File

@ -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 {

14
src/link/MachO/zld.zig
View File

@ -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;
}

2
src/link/Plan9.zig
View File

@ -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.?);

9
src/link/Wasm.zig
View File

@ -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 {

36
src/objcopy.zig
View File

@ -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 &section.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 = .{

2
src/translate_c.zig
View File

@ -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,

2
src/type.zig
View File

@ -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,