authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2024-12-11 19:17:37-08:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2025-01-15 15:11:35-08:00
loge21a42723b9acefd27c142bf776a8321621296b8
tree23305aa2b8f5f0593e631d0976ea83ba0fff9a63
parentc96e23632f04c7bffc2257139a19cad82fbe7223

wasm linker: implement name, module name, and type for function imports

4 files changed, 267 insertions(+), 145 deletions(-)

src/arch/wasm/CodeGen.zig+73-134
......@@ -760,7 +760,7 @@ fn resolveInst(cg: *CodeGen, ref: Air.Inst.Ref) InnerError!WValue {
760760 //
761761 // In the other cases, we will simply lower the constant to a value that fits
762762 // into a single local (such as a pointer, integer, bool, etc).
763 const result: WValue = if (isByRef(ty, pt, cg.target))
763 const result: WValue = if (isByRef(ty, zcu, cg.target))
764764 .{ .uav_ref = .{ .ip_index = val.toIntern() } }
765765 else
766766 try cg.lowerConstant(val, ty);
......@@ -953,9 +953,8 @@ fn addExtraAssumeCapacity(cg: *CodeGen, extra: anytype) error{OutOfMemory}!u32 {
953953 return result;
954954}
955955
956/// Using a given `Type`, returns the corresponding valtype for .auto callconv
957fn typeToValtype(ty: Type, pt: Zcu.PerThread, target: *const std.Target) std.wasm.Valtype {
958 const zcu = pt.zcu;
956/// For `std.builtin.CallingConvention.auto`.
957pub fn typeToValtype(ty: Type, zcu: *const Zcu, target: *const std.Target) std.wasm.Valtype {
959958 const ip = &zcu.intern_pool;
960959 return switch (ty.zigTypeTag(zcu)) {
961960 .float => switch (ty.floatBits(target.*)) {
......@@ -973,19 +972,20 @@ fn typeToValtype(ty: Type, pt: Zcu.PerThread, target: *const std.Target) std.was
973972 .@"struct" => blk: {
974973 if (zcu.typeToPackedStruct(ty)) |packed_struct| {
975974 const backing_int_ty = Type.fromInterned(packed_struct.backingIntTypeUnordered(ip));
976 break :blk typeToValtype(backing_int_ty, pt, target);
975 break :blk typeToValtype(backing_int_ty, zcu, target);
977976 } else {
978977 break :blk .i32;
979978 }
980979 },
981 .vector => switch (determineSimdStoreStrategy(ty, zcu, target)) {
980 .vector => switch (CodeGen.determineSimdStoreStrategy(ty, zcu, target)) {
982981 .direct => .v128,
983982 .unrolled => .i32,
984983 },
985984 .@"union" => switch (ty.containerLayout(zcu)) {
986 .@"packed" => blk: {
987 const int_ty = pt.intType(.unsigned, @as(u16, @intCast(ty.bitSize(zcu)))) catch @panic("out of memory");
988 break :blk typeToValtype(int_ty, pt, target);
985 .@"packed" => switch (ty.bitSize(zcu)) {
986 0...32 => .i32,
987 33...64 => .i64,
988 else => .i32,
989989 },
990990 else => .i32,
991991 },
......@@ -994,17 +994,17 @@ fn typeToValtype(ty: Type, pt: Zcu.PerThread, target: *const std.Target) std.was
994994}
995995
996996/// Using a given `Type`, returns the byte representation of its wasm value type
997fn genValtype(ty: Type, pt: Zcu.PerThread, target: *const std.Target) u8 {
998 return @intFromEnum(typeToValtype(ty, pt, target));
997fn genValtype(ty: Type, zcu: *const Zcu, target: *const std.Target) u8 {
998 return @intFromEnum(typeToValtype(ty, zcu, target));
999999}
10001000
10011001/// Using a given `Type`, returns the corresponding wasm value type
10021002/// Differently from `genValtype` this also allows `void` to create a block
10031003/// with no return type
1004fn genBlockType(ty: Type, pt: Zcu.PerThread, target: *const std.Target) u8 {
1004fn genBlockType(ty: Type, zcu: *const Zcu, target: *const std.Target) u8 {
10051005 return switch (ty.ip_index) {
10061006 .void_type, .noreturn_type => std.wasm.block_empty,
1007 else => genValtype(ty, pt, target),
1007 else => genValtype(ty, zcu, target),
10081008 };
10091009}
10101010
......@@ -1086,8 +1086,8 @@ fn getResolvedInst(cg: *CodeGen, ref: Air.Inst.Ref) *WValue {
10861086/// Creates one locals for a given `Type`.
10871087/// Returns a corresponding `Wvalue` with `local` as active tag
10881088fn allocLocal(cg: *CodeGen, ty: Type) InnerError!WValue {
1089 const pt = cg.pt;
1090 const valtype = typeToValtype(ty, pt, cg.target);
1089 const zcu = cg.pt.zcu;
1090 const valtype = typeToValtype(ty, zcu, cg.target);
10911091 const index_or_null = switch (valtype) {
10921092 .i32 => cg.free_locals_i32.popOrNull(),
10931093 .i64 => cg.free_locals_i64.popOrNull(),
......@@ -1106,74 +1106,13 @@ fn allocLocal(cg: *CodeGen, ty: Type) InnerError!WValue {
11061106/// Ensures a new local will be created. This is useful when it's useful
11071107/// to use a zero-initialized local.
11081108fn ensureAllocLocal(cg: *CodeGen, ty: Type) InnerError!WValue {
1109 const pt = cg.pt;
1110 try cg.locals.append(cg.gpa, genValtype(ty, pt, cg.target));
1109 const zcu = cg.pt.zcu;
1110 try cg.locals.append(cg.gpa, genValtype(ty, zcu, cg.target));
11111111 const initial_index = cg.local_index;
11121112 cg.local_index += 1;
11131113 return .{ .local = .{ .value = initial_index, .references = 1 } };
11141114}
11151115
1116fn genFunctype(
1117 wasm: *link.File.Wasm,
1118 cc: std.builtin.CallingConvention,
1119 params: []const InternPool.Index,
1120 return_type: Type,
1121 pt: Zcu.PerThread,
1122 target: *const std.Target,
1123) !link.File.Wasm.FunctionType.Index {
1124 const zcu = pt.zcu;
1125 const gpa = zcu.gpa;
1126 var temp_params: std.ArrayListUnmanaged(std.wasm.Valtype) = .empty;
1127 defer temp_params.deinit(gpa);
1128 var returns: std.ArrayListUnmanaged(std.wasm.Valtype) = .empty;
1129 defer returns.deinit(gpa);
1130
1131 if (firstParamSRet(cc, return_type, pt, target)) {
1132 try temp_params.append(gpa, .i32); // memory address is always a 32-bit handle
1133 } else if (return_type.hasRuntimeBitsIgnoreComptime(zcu)) {
1134 if (cc == .wasm_watc) {
1135 const res_classes = abi.classifyType(return_type, zcu);
1136 assert(res_classes[0] == .direct and res_classes[1] == .none);
1137 const scalar_type = abi.scalarType(return_type, zcu);
1138 try returns.append(gpa, typeToValtype(scalar_type, pt, target));
1139 } else {
1140 try returns.append(gpa, typeToValtype(return_type, pt, target));
1141 }
1142 } else if (return_type.isError(zcu)) {
1143 try returns.append(gpa, .i32);
1144 }
1145
1146 // param types
1147 for (params) |param_type_ip| {
1148 const param_type = Type.fromInterned(param_type_ip);
1149 if (!param_type.hasRuntimeBitsIgnoreComptime(zcu)) continue;
1150
1151 switch (cc) {
1152 .wasm_watc => {
1153 const param_classes = abi.classifyType(param_type, zcu);
1154 if (param_classes[1] == .none) {
1155 if (param_classes[0] == .direct) {
1156 const scalar_type = abi.scalarType(param_type, zcu);
1157 try temp_params.append(gpa, typeToValtype(scalar_type, pt, target));
1158 } else {
1159 try temp_params.append(gpa, typeToValtype(param_type, pt, target));
1160 }
1161 } else {
1162 // i128/f128
1163 try temp_params.append(gpa, .i64);
1164 try temp_params.append(gpa, .i64);
1165 }
1166 },
1167 else => try temp_params.append(gpa, typeToValtype(param_type, pt, target)),
1168 }
1169 }
1170
1171 return wasm.addFuncType(.{
1172 .params = try wasm.internValtypeList(temp_params.items),
1173 .returns = try wasm.internValtypeList(returns.items),
1174 });
1175}
1176
11771116pub const Function = extern struct {
11781117 /// Index into `Wasm.mir_instructions`.
11791118 mir_off: u32,
......@@ -1291,7 +1230,7 @@ pub fn function(
12911230 const fn_ty = zcu.navValue(cg.owner_nav).typeOf(zcu);
12921231 const fn_info = zcu.typeToFunc(fn_ty).?;
12931232 const ip = &zcu.intern_pool;
1294 const fn_ty_index = try genFunctype(wasm, fn_info.cc, fn_info.param_types.get(ip), Type.fromInterned(fn_info.return_type), pt, target);
1233 const fn_ty_index = try wasm.internFunctionType(fn_info.cc, fn_info.param_types.get(ip), .fromInterned(fn_info.return_type), target);
12951234 const returns = fn_ty_index.ptr(wasm).returns.slice(wasm);
12961235 const any_returns = returns.len != 0;
12971236
......@@ -1409,7 +1348,7 @@ fn resolveCallingConventionValues(
14091348
14101349 // Check if we store the result as a pointer to the stack rather than
14111350 // by value
1412 if (firstParamSRet(fn_info.cc, Type.fromInterned(fn_info.return_type), pt, target)) {
1351 if (firstParamSRet(fn_info.cc, Type.fromInterned(fn_info.return_type), zcu, target)) {
14131352 // the sret arg will be passed as first argument, therefore we
14141353 // set the `return_value` before allocating locals for regular args.
14151354 result.return_value = .{ .local = .{ .value = result.local_index, .references = 1 } };
......@@ -1443,17 +1382,17 @@ fn resolveCallingConventionValues(
14431382 return result;
14441383}
14451384
1446fn firstParamSRet(
1385pub fn firstParamSRet(
14471386 cc: std.builtin.CallingConvention,
14481387 return_type: Type,
1449 pt: Zcu.PerThread,
1388 zcu: *const Zcu,
14501389 target: *const std.Target,
14511390) bool {
14521391 switch (cc) {
14531392 .@"inline" => unreachable,
1454 .auto => return isByRef(return_type, pt, target),
1393 .auto => return isByRef(return_type, zcu, target),
14551394 .wasm_watc => {
1456 const ty_classes = abi.classifyType(return_type, pt.zcu);
1395 const ty_classes = abi.classifyType(return_type, zcu);
14571396 if (ty_classes[0] == .indirect) return true;
14581397 if (ty_classes[0] == .direct and ty_classes[1] == .direct) return true;
14591398 return false;
......@@ -1744,8 +1683,7 @@ fn ptrSize(cg: *const CodeGen) u16 {
17441683
17451684/// For a given `Type`, will return true when the type will be passed
17461685/// by reference, rather than by value
1747fn isByRef(ty: Type, pt: Zcu.PerThread, target: *const std.Target) bool {
1748 const zcu = pt.zcu;
1686fn isByRef(ty: Type, zcu: *const Zcu, target: *const std.Target) bool {
17491687 const ip = &zcu.intern_pool;
17501688 switch (ty.zigTypeTag(zcu)) {
17511689 .type,
......@@ -1778,7 +1716,7 @@ fn isByRef(ty: Type, pt: Zcu.PerThread, target: *const std.Target) bool {
17781716 },
17791717 .@"struct" => {
17801718 if (zcu.typeToPackedStruct(ty)) |packed_struct| {
1781 return isByRef(Type.fromInterned(packed_struct.backingIntTypeUnordered(ip)), pt, target);
1719 return isByRef(Type.fromInterned(packed_struct.backingIntTypeUnordered(ip)), zcu, target);
17821720 }
17831721 return ty.hasRuntimeBitsIgnoreComptime(zcu);
17841722 },
......@@ -1816,7 +1754,7 @@ const SimdStoreStrategy = enum {
18161754/// This means when a given type is 128 bits and either the simd128 or relaxed-simd
18171755/// features are enabled, the function will return `.direct`. This would allow to store
18181756/// it using a instruction, rather than an unrolled version.
1819fn determineSimdStoreStrategy(ty: Type, zcu: *Zcu, target: *const std.Target) SimdStoreStrategy {
1757pub fn determineSimdStoreStrategy(ty: Type, zcu: *const Zcu, target: *const std.Target) SimdStoreStrategy {
18201758 assert(ty.zigTypeTag(zcu) == .vector);
18211759 if (ty.bitSize(zcu) != 128) return .unrolled;
18221760 const hasFeature = std.Target.wasm.featureSetHas;
......@@ -2144,7 +2082,7 @@ fn airRet(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
21442082 .op = .load,
21452083 .width = @as(u8, @intCast(scalar_type.abiSize(zcu) * 8)),
21462084 .signedness = if (scalar_type.isSignedInt(zcu)) .signed else .unsigned,
2147 .valtype1 = typeToValtype(scalar_type, pt, cg.target),
2085 .valtype1 = typeToValtype(scalar_type, zcu, cg.target),
21482086 });
21492087 try cg.addMemArg(Mir.Inst.Tag.fromOpcode(opcode), .{
21502088 .offset = operand.offset(),
......@@ -2177,7 +2115,7 @@ fn airRetPtr(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
21772115 }
21782116
21792117 const fn_info = zcu.typeToFunc(zcu.navValue(cg.owner_nav).typeOf(zcu)).?;
2180 if (firstParamSRet(fn_info.cc, Type.fromInterned(fn_info.return_type), pt, cg.target)) {
2118 if (firstParamSRet(fn_info.cc, Type.fromInterned(fn_info.return_type), zcu, cg.target)) {
21812119 break :result cg.return_value;
21822120 }
21832121
......@@ -2199,7 +2137,7 @@ fn airRetLoad(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
21992137 if (ret_ty.isError(zcu)) {
22002138 try cg.addImm32(0);
22012139 }
2202 } else if (!firstParamSRet(fn_info.cc, Type.fromInterned(fn_info.return_type), pt, cg.target)) {
2140 } else if (!firstParamSRet(fn_info.cc, Type.fromInterned(fn_info.return_type), zcu, cg.target)) {
22032141 // leave on the stack
22042142 _ = try cg.load(operand, ret_ty, 0);
22052143 }
......@@ -2227,7 +2165,7 @@ fn airCall(cg: *CodeGen, inst: Air.Inst.Index, modifier: std.builtin.CallModifie
22272165 };
22282166 const ret_ty = fn_ty.fnReturnType(zcu);
22292167 const fn_info = zcu.typeToFunc(fn_ty).?;
2230 const first_param_sret = firstParamSRet(fn_info.cc, Type.fromInterned(fn_info.return_type), pt, cg.target);
2168 const first_param_sret = firstParamSRet(fn_info.cc, Type.fromInterned(fn_info.return_type), zcu, cg.target);
22312169
22322170 const callee: ?InternPool.Nav.Index = blk: {
22332171 const func_val = (try cg.air.value(pl_op.operand, pt)) orelse break :blk null;
......@@ -2267,7 +2205,7 @@ fn airCall(cg: *CodeGen, inst: Air.Inst.Index, modifier: std.builtin.CallModifie
22672205 const operand = try cg.resolveInst(pl_op.operand);
22682206 try cg.emitWValue(operand);
22692207
2270 const fn_type_index = try genFunctype(wasm, fn_info.cc, fn_info.param_types.get(ip), Type.fromInterned(fn_info.return_type), pt, cg.target);
2208 const fn_type_index = try wasm.internFunctionType(fn_info.cc, fn_info.param_types.get(ip), .fromInterned(fn_info.return_type), cg.target);
22712209 try cg.addLabel(.call_indirect, @intFromEnum(fn_type_index));
22722210 }
22732211
......@@ -2328,7 +2266,7 @@ fn airStore(cg: *CodeGen, inst: Air.Inst.Index, safety: bool) InnerError!void {
23282266 // load the value, and then shift+or the rhs into the result location.
23292267 const int_elem_ty = try pt.intType(.unsigned, ptr_info.packed_offset.host_size * 8);
23302268
2331 if (isByRef(int_elem_ty, pt, cg.target)) {
2269 if (isByRef(int_elem_ty, zcu, cg.target)) {
23322270 return cg.fail("TODO: airStore for pointers to bitfields with backing type larger than 64bits", .{});
23332271 }
23342272
......@@ -2394,7 +2332,7 @@ fn store(cg: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, offset: u32) InnerErr
23942332 const len = @as(u32, @intCast(abi_size));
23952333 return cg.memcpy(lhs, rhs, .{ .imm32 = len });
23962334 },
2397 .@"struct", .array, .@"union" => if (isByRef(ty, pt, cg.target)) {
2335 .@"struct", .array, .@"union" => if (isByRef(ty, zcu, cg.target)) {
23982336 const len = @as(u32, @intCast(abi_size));
23992337 return cg.memcpy(lhs, rhs, .{ .imm32 = len });
24002338 },
......@@ -2456,7 +2394,7 @@ fn store(cg: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, offset: u32) InnerErr
24562394 // into lhs, so we calculate that and emit that instead
24572395 try cg.lowerToStack(rhs);
24582396
2459 const valtype = typeToValtype(ty, pt, cg.target);
2397 const valtype = typeToValtype(ty, zcu, cg.target);
24602398 const opcode = buildOpcode(.{
24612399 .valtype1 = valtype,
24622400 .width = @as(u8, @intCast(abi_size * 8)),
......@@ -2485,7 +2423,7 @@ fn airLoad(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
24852423 if (!ty.hasRuntimeBitsIgnoreComptime(zcu)) return cg.finishAir(inst, .none, &.{ty_op.operand});
24862424
24872425 const result = result: {
2488 if (isByRef(ty, pt, cg.target)) {
2426 if (isByRef(ty, zcu, cg.target)) {
24892427 const new_local = try cg.allocStack(ty);
24902428 try cg.store(new_local, operand, ty, 0);
24912429 break :result new_local;
......@@ -2535,7 +2473,7 @@ fn load(cg: *CodeGen, operand: WValue, ty: Type, offset: u32) InnerError!WValue
25352473
25362474 const abi_size: u8 = @intCast(ty.abiSize(zcu));
25372475 const opcode = buildOpcode(.{
2538 .valtype1 = typeToValtype(ty, pt, cg.target),
2476 .valtype1 = typeToValtype(ty, zcu, cg.target),
25392477 .width = abi_size * 8,
25402478 .op = .load,
25412479 .signedness = if (ty.isSignedInt(zcu)) .signed else .unsigned,
......@@ -2632,7 +2570,7 @@ fn binOp(cg: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, op: Op) InnerError!WV
26322570 return cg.floatOp(float_op, ty, &.{ lhs, rhs });
26332571 }
26342572
2635 if (isByRef(ty, pt, cg.target)) {
2573 if (isByRef(ty, zcu, cg.target)) {
26362574 if (ty.zigTypeTag(zcu) == .int) {
26372575 return cg.binOpBigInt(lhs, rhs, ty, op);
26382576 } else {
......@@ -2645,7 +2583,7 @@ fn binOp(cg: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, op: Op) InnerError!WV
26452583
26462584 const opcode: std.wasm.Opcode = buildOpcode(.{
26472585 .op = op,
2648 .valtype1 = typeToValtype(ty, pt, cg.target),
2586 .valtype1 = typeToValtype(ty, zcu, cg.target),
26492587 .signedness = if (ty.isSignedInt(zcu)) .signed else .unsigned,
26502588 });
26512589 try cg.emitWValue(lhs);
......@@ -2949,7 +2887,7 @@ fn floatOp(cg: *CodeGen, float_op: FloatOp, ty: Type, args: []const WValue) Inne
29492887 for (args) |operand| {
29502888 try cg.emitWValue(operand);
29512889 }
2952 const opcode = buildOpcode(.{ .op = op, .valtype1 = typeToValtype(ty, pt, cg.target) });
2890 const opcode = buildOpcode(.{ .op = op, .valtype1 = typeToValtype(ty, zcu, cg.target) });
29532891 try cg.addTag(Mir.Inst.Tag.fromOpcode(opcode));
29542892 return .stack;
29552893 }
......@@ -3174,7 +3112,7 @@ fn lowerPtr(cg: *CodeGen, ptr_val: InternPool.Index, prev_offset: u64) InnerErro
31743112fn lowerConstant(cg: *CodeGen, val: Value, ty: Type) InnerError!WValue {
31753113 const pt = cg.pt;
31763114 const zcu = pt.zcu;
3177 assert(!isByRef(ty, pt, cg.target));
3115 assert(!isByRef(ty, zcu, cg.target));
31783116 const ip = &zcu.intern_pool;
31793117 if (val.isUndefDeep(zcu)) return cg.emitUndefined(ty);
31803118
......@@ -3415,11 +3353,12 @@ fn airBlock(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
34153353
34163354fn lowerBlock(cg: *CodeGen, inst: Air.Inst.Index, block_ty: Type, body: []const Air.Inst.Index) InnerError!void {
34173355 const pt = cg.pt;
3418 const wasm_block_ty = genBlockType(block_ty, pt, cg.target);
3356 const zcu = pt.zcu;
3357 const wasm_block_ty = genBlockType(block_ty, zcu, cg.target);
34193358
34203359 // if wasm_block_ty is non-empty, we create a register to store the temporary value
34213360 const block_result: WValue = if (wasm_block_ty != std.wasm.block_empty) blk: {
3422 const ty: Type = if (isByRef(block_ty, pt, cg.target)) Type.u32 else block_ty;
3361 const ty: Type = if (isByRef(block_ty, zcu, cg.target)) Type.u32 else block_ty;
34233362 break :blk try cg.ensureAllocLocal(ty); // make sure it's a clean local as it may never get overwritten
34243363 } else .none;
34253364
......@@ -3544,7 +3483,7 @@ fn cmp(cg: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, op: std.math.CompareOpe
35443483 }
35453484 } else if (ty.isAnyFloat()) {
35463485 return cg.cmpFloat(ty, lhs, rhs, op);
3547 } else if (isByRef(ty, pt, cg.target)) {
3486 } else if (isByRef(ty, zcu, cg.target)) {
35483487 return cg.cmpBigInt(lhs, rhs, ty, op);
35493488 }
35503489
......@@ -3562,7 +3501,7 @@ fn cmp(cg: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, op: std.math.CompareOpe
35623501 try cg.lowerToStack(rhs);
35633502
35643503 const opcode: std.wasm.Opcode = buildOpcode(.{
3565 .valtype1 = typeToValtype(ty, pt, cg.target),
3504 .valtype1 = typeToValtype(ty, zcu, cg.target),
35663505 .op = switch (op) {
35673506 .lt => .lt,
35683507 .lte => .le,
......@@ -3769,7 +3708,7 @@ fn airBitcast(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
37693708 break :result try cg.bitcast(wanted_ty, given_ty, operand);
37703709 }
37713710
3772 if (isByRef(given_ty, pt, cg.target) and !isByRef(wanted_ty, pt, cg.target)) {
3711 if (isByRef(given_ty, zcu, cg.target) and !isByRef(wanted_ty, zcu, cg.target)) {
37733712 const loaded_memory = try cg.load(operand, wanted_ty, 0);
37743713 if (needs_wrapping) {
37753714 break :result try cg.wrapOperand(loaded_memory, wanted_ty);
......@@ -3777,7 +3716,7 @@ fn airBitcast(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
37773716 break :result loaded_memory;
37783717 }
37793718 }
3780 if (!isByRef(given_ty, pt, cg.target) and isByRef(wanted_ty, pt, cg.target)) {
3719 if (!isByRef(given_ty, zcu, cg.target) and isByRef(wanted_ty, zcu, cg.target)) {
37813720 const stack_memory = try cg.allocStack(wanted_ty);
37823721 try cg.store(stack_memory, operand, given_ty, 0);
37833722 if (needs_wrapping) {
......@@ -3807,8 +3746,8 @@ fn bitcast(cg: *CodeGen, wanted_ty: Type, given_ty: Type, operand: WValue) Inner
38073746
38083747 const opcode = buildOpcode(.{
38093748 .op = .reinterpret,
3810 .valtype1 = typeToValtype(wanted_ty, pt, cg.target),
3811 .valtype2 = typeToValtype(given_ty, pt, cg.target),
3749 .valtype1 = typeToValtype(wanted_ty, zcu, cg.target),
3750 .valtype2 = typeToValtype(given_ty, zcu, cg.target),
38123751 });
38133752 try cg.emitWValue(operand);
38143753 try cg.addTag(Mir.Inst.Tag.fromOpcode(opcode));
......@@ -3930,8 +3869,8 @@ fn airStructFieldVal(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
39303869 break :result try cg.trunc(shifted_value, field_ty, backing_ty);
39313870 },
39323871 .@"union" => result: {
3933 if (isByRef(struct_ty, pt, cg.target)) {
3934 if (!isByRef(field_ty, pt, cg.target)) {
3872 if (isByRef(struct_ty, zcu, cg.target)) {
3873 if (!isByRef(field_ty, zcu, cg.target)) {
39353874 break :result try cg.load(operand, field_ty, 0);
39363875 } else {
39373876 const new_stack_val = try cg.allocStack(field_ty);
......@@ -3957,7 +3896,7 @@ fn airStructFieldVal(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
39573896 const offset = std.math.cast(u32, struct_ty.structFieldOffset(field_index, zcu)) orelse {
39583897 return cg.fail("Field type '{}' too big to fit into stack frame", .{field_ty.fmt(pt)});
39593898 };
3960 if (isByRef(field_ty, pt, cg.target)) {
3899 if (isByRef(field_ty, zcu, cg.target)) {
39613900 switch (operand) {
39623901 .stack_offset => |stack_offset| {
39633902 break :result .{ .stack_offset = .{ .value = stack_offset.value + offset, .references = 1 } };
......@@ -4220,7 +4159,7 @@ fn airUnwrapErrUnionPayload(cg: *CodeGen, inst: Air.Inst.Index, op_is_ptr: bool)
42204159 }
42214160
42224161 const pl_offset = @as(u32, @intCast(errUnionPayloadOffset(payload_ty, zcu)));
4223 if (op_is_ptr or isByRef(payload_ty, pt, cg.target)) {
4162 if (op_is_ptr or isByRef(payload_ty, zcu, cg.target)) {
42244163 break :result try cg.buildPointerOffset(operand, pl_offset, .new);
42254164 }
42264165
......@@ -4446,7 +4385,7 @@ fn airOptionalPayload(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
44464385 const operand = try cg.resolveInst(ty_op.operand);
44474386 if (opt_ty.optionalReprIsPayload(zcu)) break :result cg.reuseOperand(ty_op.operand, operand);
44484387
4449 if (isByRef(payload_ty, pt, cg.target)) {
4388 if (isByRef(payload_ty, zcu, cg.target)) {
44504389 break :result try cg.buildPointerOffset(operand, 0, .new);
44514390 }
44524391
......@@ -4580,7 +4519,7 @@ fn airSliceElemVal(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
45804519 try cg.addTag(.i32_mul);
45814520 try cg.addTag(.i32_add);
45824521
4583 const elem_result = if (isByRef(elem_ty, pt, cg.target))
4522 const elem_result = if (isByRef(elem_ty, zcu, cg.target))
45844523 .stack
45854524 else
45864525 try cg.load(.stack, elem_ty, 0);
......@@ -4739,7 +4678,7 @@ fn airPtrElemVal(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
47394678 try cg.addTag(.i32_mul);
47404679 try cg.addTag(.i32_add);
47414680
4742 const elem_result = if (isByRef(elem_ty, pt, cg.target))
4681 const elem_result = if (isByRef(elem_ty, zcu, cg.target))
47434682 .stack
47444683 else
47454684 try cg.load(.stack, elem_ty, 0);
......@@ -4790,7 +4729,7 @@ fn airPtrBinOp(cg: *CodeGen, inst: Air.Inst.Index, op: Op) InnerError!void {
47904729 else => ptr_ty.childType(zcu),
47914730 };
47924731
4793 const valtype = typeToValtype(Type.usize, pt, cg.target);
4732 const valtype = typeToValtype(Type.usize, zcu, cg.target);
47944733 const mul_opcode = buildOpcode(.{ .valtype1 = valtype, .op = .mul });
47954734 const bin_opcode = buildOpcode(.{ .valtype1 = valtype, .op = op });
47964735
......@@ -4933,7 +4872,7 @@ fn airArrayElemVal(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
49334872 const elem_ty = array_ty.childType(zcu);
49344873 const elem_size = elem_ty.abiSize(zcu);
49354874
4936 if (isByRef(array_ty, pt, cg.target)) {
4875 if (isByRef(array_ty, zcu, cg.target)) {
49374876 try cg.lowerToStack(array);
49384877 try cg.emitWValue(index);
49394878 try cg.addImm32(@intCast(elem_size));
......@@ -4976,7 +4915,7 @@ fn airArrayElemVal(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
49764915 }
49774916 }
49784917
4979 const elem_result = if (isByRef(elem_ty, pt, cg.target))
4918 const elem_result = if (isByRef(elem_ty, zcu, cg.target))
49804919 .stack
49814920 else
49824921 try cg.load(.stack, elem_ty, 0);
......@@ -5027,8 +4966,8 @@ fn airIntFromFloat(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
50274966 try cg.emitWValue(operand);
50284967 const op = buildOpcode(.{
50294968 .op = .trunc,
5030 .valtype1 = typeToValtype(dest_ty, pt, cg.target),
5031 .valtype2 = typeToValtype(op_ty, pt, cg.target),
4969 .valtype1 = typeToValtype(dest_ty, zcu, cg.target),
4970 .valtype2 = typeToValtype(op_ty, zcu, cg.target),
50324971 .signedness = dest_info.signedness,
50334972 });
50344973 try cg.addTag(Mir.Inst.Tag.fromOpcode(op));
......@@ -5080,8 +5019,8 @@ fn airFloatFromInt(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
50805019 try cg.emitWValue(operand);
50815020 const op = buildOpcode(.{
50825021 .op = .convert,
5083 .valtype1 = typeToValtype(dest_ty, pt, cg.target),
5084 .valtype2 = typeToValtype(op_ty, pt, cg.target),
5022 .valtype1 = typeToValtype(dest_ty, zcu, cg.target),
5023 .valtype2 = typeToValtype(op_ty, zcu, cg.target),
50855024 .signedness = op_info.signedness,
50865025 });
50875026 try cg.addTag(Mir.Inst.Tag.fromOpcode(op));
......@@ -5180,7 +5119,7 @@ fn airShuffle(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
51805119 const elem_size = child_ty.abiSize(zcu);
51815120
51825121 // TODO: One of them could be by ref; handle in loop
5183 if (isByRef(cg.typeOf(extra.a), pt, cg.target) or isByRef(inst_ty, pt, cg.target)) {
5122 if (isByRef(cg.typeOf(extra.a), zcu, cg.target) or isByRef(inst_ty, zcu, cg.target)) {
51845123 const result = try cg.allocStack(inst_ty);
51855124
51865125 for (0..mask_len) |index| {
......@@ -5256,7 +5195,7 @@ fn airAggregateInit(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
52565195 // When the element type is by reference, we must copy the entire
52575196 // value. It is therefore safer to move the offset pointer and store
52585197 // each value individually, instead of using store offsets.
5259 if (isByRef(elem_ty, pt, cg.target)) {
5198 if (isByRef(elem_ty, zcu, cg.target)) {
52605199 // copy stack pointer into a temporary local, which is
52615200 // moved for each element to store each value in the right position.
52625201 const offset = try cg.buildPointerOffset(result, 0, .new);
......@@ -5286,7 +5225,7 @@ fn airAggregateInit(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
52865225 },
52875226 .@"struct" => switch (result_ty.containerLayout(zcu)) {
52885227 .@"packed" => {
5289 if (isByRef(result_ty, pt, cg.target)) {
5228 if (isByRef(result_ty, zcu, cg.target)) {
52905229 return cg.fail("TODO: airAggregateInit for packed structs larger than 64 bits", .{});
52915230 }
52925231 const packed_struct = zcu.typeToPackedStruct(result_ty).?;
......@@ -5389,15 +5328,15 @@ fn airUnionInit(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
53895328 if (layout.tag_size == 0) {
53905329 break :result .none;
53915330 }
5392 assert(!isByRef(union_ty, pt, cg.target));
5331 assert(!isByRef(union_ty, zcu, cg.target));
53935332 break :result tag_int;
53945333 }
53955334
5396 if (isByRef(union_ty, pt, cg.target)) {
5335 if (isByRef(union_ty, zcu, cg.target)) {
53975336 const result_ptr = try cg.allocStack(union_ty);
53985337 const payload = try cg.resolveInst(extra.init);
53995338 if (layout.tag_align.compare(.gte, layout.payload_align)) {
5400 if (isByRef(field_ty, pt, cg.target)) {
5339 if (isByRef(field_ty, zcu, cg.target)) {
54015340 const payload_ptr = try cg.buildPointerOffset(result_ptr, layout.tag_size, .new);
54025341 try cg.store(payload_ptr, payload, field_ty, 0);
54035342 } else {
......@@ -5478,7 +5417,7 @@ fn cmpOptionals(cg: *CodeGen, lhs: WValue, rhs: WValue, operand_ty: Type, op: st
54785417
54795418 _ = try cg.load(lhs, payload_ty, 0);
54805419 _ = try cg.load(rhs, payload_ty, 0);
5481 const opcode = buildOpcode(.{ .op = .ne, .valtype1 = typeToValtype(payload_ty, pt, cg.target) });
5420 const opcode = buildOpcode(.{ .op = .ne, .valtype1 = typeToValtype(payload_ty, zcu, cg.target) });
54825421 try cg.addTag(Mir.Inst.Tag.fromOpcode(opcode));
54835422 try cg.addLabel(.br_if, 0);
54845423
......@@ -6521,7 +6460,7 @@ fn lowerTry(
65216460 }
65226461
65236462 const pl_offset: u32 = @intCast(errUnionPayloadOffset(pl_ty, zcu));
6524 if (isByRef(pl_ty, pt, cg.target)) {
6463 if (isByRef(pl_ty, zcu, cg.target)) {
65256464 return buildPointerOffset(cg, err_union, pl_offset, .new);
65266465 }
65276466 const payload = try cg.load(err_union, pl_ty, pl_offset);
......@@ -7100,7 +7039,7 @@ fn callIntrinsic(
71007039
71017040 // Always pass over C-ABI
71027041
7103 const want_sret_param = firstParamSRet(.{ .wasm_watc = .{} }, return_type, pt, cg.target);
7042 const want_sret_param = firstParamSRet(.{ .wasm_watc = .{} }, return_type, zcu, cg.target);
71047043 // if we want return as first param, we allocate a pointer to stack,
71057044 // and emit it as our first argument
71067045 const sret = if (want_sret_param) blk: {
......@@ -7282,7 +7221,7 @@ fn airCmpxchg(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
72827221 break :val ptr_val;
72837222 };
72847223
7285 const result = if (isByRef(result_ty, pt, cg.target)) val: {
7224 const result = if (isByRef(result_ty, zcu, cg.target)) val: {
72867225 try cg.emitWValue(cmp_result);
72877226 try cg.addImm32(~@as(u32, 0));
72887227 try cg.addTag(.i32_xor);
src/arch/wasm/abi.zig+1-1
......@@ -22,7 +22,7 @@ const direct: [2]Class = .{ .direct, .none };
2222/// Classifies a given Zig type to determine how they must be passed
2323/// or returned as value within a wasm function.
2424/// When all elements result in `.none`, no value must be passed in or returned.
25pub fn classifyType(ty: Type, zcu: *Zcu) [2]Class {
25pub fn classifyType(ty: Type, zcu: *const Zcu) [2]Class {
2626 const ip = &zcu.intern_pool;
2727 const target = zcu.getTarget();
2828 if (!ty.hasRuntimeBitsIgnoreComptime(zcu)) return none;
src/link/Wasm.zig+186-3
......@@ -32,6 +32,7 @@ const mem = std.mem;
3232const Air = @import("../Air.zig");
3333const Mir = @import("../arch/wasm/Mir.zig");
3434const CodeGen = @import("../arch/wasm/CodeGen.zig");
35const abi = @import("../arch/wasm/abi.zig");
3536const Compilation = @import("../Compilation.zig");
3637const Dwarf = @import("Dwarf.zig");
3738const InternPool = @import("../InternPool.zig");
......@@ -45,6 +46,7 @@ const lldMain = @import("../main.zig").lldMain;
4546const trace = @import("../tracy.zig").trace;
4647const wasi_libc = @import("../wasi_libc.zig");
4748const Value = @import("../Value.zig");
49const ZcuType = @import("../Type.zig");
4850
4951base: link.File,
5052/// Null-terminated strings, indexes have type String and string_table provides
......@@ -236,6 +238,9 @@ mir_extra: std.ArrayListUnmanaged(u32) = .empty,
236238/// All local types for all Zcu functions.
237239all_zcu_locals: std.ArrayListUnmanaged(u8) = .empty,
238240
241params_scratch: std.ArrayListUnmanaged(std.wasm.Valtype) = .empty,
242returns_scratch: std.ArrayListUnmanaged(std.wasm.Valtype) = .empty,
243
239244pub const UavFixup = extern struct {
240245 ip_index: InternPool.Index,
241246 /// Index into `string_bytes`.
......@@ -650,8 +655,24 @@ pub const FunctionImport = extern struct {
650655 pub const Index = enum(u32) {
651656 _,
652657
653 pub fn ptr(index: FunctionImport.Index, wasm: *const Wasm) *FunctionImport {
654 return &wasm.object_function_imports.items[@intFromEnum(index)];
658 pub fn key(index: Index, wasm: *const Wasm) *String {
659 return &wasm.object_function_imports.keys()[@intFromEnum(index)];
660 }
661
662 pub fn value(index: Index, wasm: *const Wasm) *FunctionImport {
663 return &wasm.object_function_imports.values()[@intFromEnum(index)];
664 }
665
666 pub fn name(index: Index, wasm: *const Wasm) String {
667 return index.key(wasm).*;
668 }
669
670 pub fn moduleName(index: Index, wasm: *const Wasm) String {
671 return index.value(wasm).module_name;
672 }
673
674 pub fn functionType(index: Index, wasm: *const Wasm) FunctionType.Index {
675 return value(index, wasm).type;
655676 }
656677 };
657678};
......@@ -1093,9 +1114,54 @@ pub const ValtypeList = enum(u32) {
10931114 }
10941115};
10951116
1096/// Index into `imports`.
1117/// Index into `Wasm.imports`.
10971118pub const ZcuImportIndex = enum(u32) {
10981119 _,
1120
1121 pub fn ptr(index: ZcuImportIndex, wasm: *const Wasm) *InternPool.Nav.Index {
1122 return &wasm.imports.keys()[@intFromEnum(index)];
1123 }
1124
1125 pub fn name(index: ZcuImportIndex, wasm: *const Wasm) String {
1126 const zcu = wasm.base.comp.zcu.?;
1127 const ip = &zcu.intern_pool;
1128 const nav_index = index.ptr(wasm).*;
1129 const nav = ip.getNav(nav_index);
1130 const ext = switch (ip.indexToKey(nav.status.resolved.val)) {
1131 .@"extern" => |*ext| ext,
1132 else => unreachable,
1133 };
1134 const name_slice = ext.name.toSlice(ip);
1135 return wasm.getExistingString(name_slice).?;
1136 }
1137
1138 pub fn moduleName(index: ZcuImportIndex, wasm: *const Wasm) String {
1139 const zcu = wasm.base.comp.zcu.?;
1140 const ip = &zcu.intern_pool;
1141 const nav_index = index.ptr(wasm).*;
1142 const nav = ip.getNav(nav_index);
1143 const ext = switch (ip.indexToKey(nav.status.resolved.val)) {
1144 .@"extern" => |*ext| ext,
1145 else => unreachable,
1146 };
1147 const lib_name = ext.lib_name.toSlice(ip) orelse return wasm.host_name;
1148 return wasm.getExistingString(lib_name).?;
1149 }
1150
1151 pub fn functionType(index: ZcuImportIndex, wasm: *Wasm) FunctionType.Index {
1152 const comp = wasm.base.comp;
1153 const target = &comp.root_mod.resolved_target.result;
1154 const zcu = comp.zcu.?;
1155 const ip = &zcu.intern_pool;
1156 const nav_index = index.ptr(wasm).*;
1157 const nav = ip.getNav(nav_index);
1158 const ext = switch (ip.indexToKey(nav.status.resolved.val)) {
1159 .@"extern" => |*ext| ext,
1160 else => unreachable,
1161 };
1162 const fn_info = zcu.typeToFunc(.fromInterned(ext.ty)).?;
1163 return getExistingFunctionType(wasm, fn_info.cc, fn_info.param_types.get(ip), .fromInterned(fn_info.return_type), target).?;
1164 }
10991165};
11001166
11011167/// 0. Index into `object_function_imports`.
......@@ -1143,6 +1209,24 @@ pub const FunctionImportId = enum(u32) {
11431209 .zcu_import => return .zig_object_nofile, // TODO give a better source location
11441210 }
11451211 }
1212
1213 pub fn name(id: FunctionImportId, wasm: *const Wasm) String {
1214 return switch (unpack(id, wasm)) {
1215 inline .object_function_import, .zcu_import => |i| i.name(wasm),
1216 };
1217 }
1218
1219 pub fn moduleName(id: FunctionImportId, wasm: *const Wasm) String {
1220 return switch (unpack(id, wasm)) {
1221 inline .object_function_import, .zcu_import => |i| i.moduleName(wasm),
1222 };
1223 }
1224
1225 pub fn functionType(id: FunctionImportId, wasm: *Wasm) FunctionType.Index {
1226 return switch (unpack(id, wasm)) {
1227 inline .object_function_import, .zcu_import => |i| i.functionType(wasm),
1228 };
1229 }
11461230};
11471231
11481232/// 0. Index into `object_global_imports`.
......@@ -1666,6 +1750,9 @@ pub fn deinit(wasm: *Wasm) void {
16661750 wasm.string_bytes.deinit(gpa);
16671751 wasm.string_table.deinit(gpa);
16681752 wasm.dump_argv_list.deinit(gpa);
1753
1754 wasm.params_scratch.deinit(gpa);
1755 wasm.returns_scratch.deinit(gpa);
16691756}
16701757
16711758pub fn updateFunc(wasm: *Wasm, pt: Zcu.PerThread, func_index: InternPool.Index, air: Air, liveness: Liveness) !void {
......@@ -2599,12 +2686,51 @@ pub fn internValtypeList(wasm: *Wasm, valtype_list: []const std.wasm.Valtype) Al
25992686 return .fromString(try internString(wasm, @ptrCast(valtype_list)));
26002687}
26012688
2689pub fn getExistingValtypeList(wasm: *Wasm, valtype_list: []const std.wasm.Valtype) ?ValtypeList {
2690 return .fromString(getExistingString(wasm, @ptrCast(valtype_list)) orelse return null);
2691}
2692
26022693pub fn addFuncType(wasm: *Wasm, ft: FunctionType) Allocator.Error!FunctionType.Index {
26032694 const gpa = wasm.base.comp.gpa;
26042695 const gop = try wasm.func_types.getOrPut(gpa, ft);
26052696 return @enumFromInt(gop.index);
26062697}
26072698
2699pub fn getExistingFuncType(wasm: *Wasm, ft: FunctionType) ?FunctionType.Index {
2700 const index = wasm.func_types.getIndex(ft) orelse return null;
2701 return @enumFromInt(index);
2702}
2703
2704pub fn internFunctionType(
2705 wasm: *Wasm,
2706 cc: std.builtin.CallingConvention,
2707 params: []const InternPool.Index,
2708 return_type: ZcuType,
2709 target: *const std.Target,
2710) Allocator.Error!FunctionType.Index {
2711 try convertZcuFnType(wasm, cc, params, return_type, target, &wasm.params_scratch, &wasm.returns_scratch);
2712 return wasm.addFuncType(.{
2713 .params = try wasm.internValtypeList(wasm.params_scratch.items),
2714 .returns = try wasm.internValtypeList(wasm.returns_scratch.items),
2715 });
2716}
2717
2718pub fn getExistingFunctionType(
2719 wasm: *Wasm,
2720 cc: std.builtin.CallingConvention,
2721 params: []const InternPool.Index,
2722 return_type: ZcuType,
2723 target: *const std.Target,
2724) ?FunctionType.Index {
2725 convertZcuFnType(wasm, cc, params, return_type, target, &wasm.params_scratch, &wasm.returns_scratch) catch |err| switch (err) {
2726 error.OutOfMemory => return null,
2727 };
2728 return wasm.getExistingFuncType(.{
2729 .params = wasm.getExistingValtypeList(wasm.params_scratch.items) orelse return null,
2730 .returns = wasm.getExistingValtypeList(wasm.returns_scratch.items) orelse return null,
2731 });
2732}
2733
26082734pub fn addExpr(wasm: *Wasm, bytes: []const u8) Allocator.Error!Expr {
26092735 const gpa = wasm.base.comp.gpa;
26102736 // We can't use string table deduplication here since these expressions can
......@@ -2644,3 +2770,60 @@ pub fn navSymbolIndex(wasm: *Wasm, nav_index: InternPool.Nav.Index) Allocator.Er
26442770 const gop = try wasm.symbol_table.getOrPut(gpa, name);
26452771 return @enumFromInt(gop.index);
26462772}
2773
2774fn convertZcuFnType(
2775 wasm: *Wasm,
2776 cc: std.builtin.CallingConvention,
2777 params: []const InternPool.Index,
2778 return_type: ZcuType,
2779 target: *const std.Target,
2780 params_buffer: *std.ArrayListUnmanaged(std.wasm.Valtype),
2781 returns_buffer: *std.ArrayListUnmanaged(std.wasm.Valtype),
2782) Allocator.Error!void {
2783 params_buffer.clearRetainingCapacity();
2784 returns_buffer.clearRetainingCapacity();
2785
2786 const comp = wasm.base.comp;
2787 const gpa = comp.gpa;
2788 const zcu = comp.zcu.?;
2789
2790 if (CodeGen.firstParamSRet(cc, return_type, zcu, target)) {
2791 try params_buffer.append(gpa, .i32); // memory address is always a 32-bit handle
2792 } else if (return_type.hasRuntimeBitsIgnoreComptime(zcu)) {
2793 if (cc == .wasm_watc) {
2794 const res_classes = abi.classifyType(return_type, zcu);
2795 assert(res_classes[0] == .direct and res_classes[1] == .none);
2796 const scalar_type = abi.scalarType(return_type, zcu);
2797 try returns_buffer.append(gpa, CodeGen.typeToValtype(scalar_type, zcu, target));
2798 } else {
2799 try returns_buffer.append(gpa, CodeGen.typeToValtype(return_type, zcu, target));
2800 }
2801 } else if (return_type.isError(zcu)) {
2802 try returns_buffer.append(gpa, .i32);
2803 }
2804
2805 // param types
2806 for (params) |param_type_ip| {
2807 const param_type = ZcuType.fromInterned(param_type_ip);
2808 if (!param_type.hasRuntimeBitsIgnoreComptime(zcu)) continue;
2809
2810 switch (cc) {
2811 .wasm_watc => {
2812 const param_classes = abi.classifyType(param_type, zcu);
2813 if (param_classes[1] == .none) {
2814 if (param_classes[0] == .direct) {
2815 const scalar_type = abi.scalarType(param_type, zcu);
2816 try params_buffer.append(gpa, CodeGen.typeToValtype(scalar_type, zcu, target));
2817 } else {
2818 try params_buffer.append(gpa, CodeGen.typeToValtype(param_type, zcu, target));
2819 }
2820 } else {
2821 // i128/f128
2822 try params_buffer.append(gpa, .i64);
2823 try params_buffer.append(gpa, .i64);
2824 }
2825 },
2826 else => try params_buffer.append(gpa, CodeGen.typeToValtype(param_type, zcu, target)),
2827 }
2828 }
2829}
src/link/Wasm/Flush.zig+7-7
......@@ -381,30 +381,30 @@ pub fn finish(f: *Flush, wasm: *Wasm, arena: Allocator) !void {
381381
382382 // Import section
383383 const total_imports_len = wasm.function_imports.entries.len + wasm.global_imports.entries.len +
384 wasm.table_imports.entries.len + wasm.memory_imports.items.len + @intFromBool(import_memory);
384 wasm.table_imports.entries.len + wasm.object_memory_imports.items.len + @intFromBool(import_memory);
385385
386386 if (total_imports_len > 0) {
387387 const header_offset = try reserveVecSectionHeader(gpa, binary_bytes);
388388
389389 for (wasm.function_imports.values()) |*function_import| {
390 const module_name = function_import.module_name.slice(wasm);
390 const module_name = function_import.moduleName(wasm).slice(wasm);
391391 try leb.writeUleb128(binary_writer, @as(u32, @intCast(module_name.len)));
392392 try binary_writer.writeAll(module_name);
393393
394 const name = function_import.name.slice(wasm);
394 const name = function_import.name(wasm).slice(wasm);
395395 try leb.writeUleb128(binary_writer, @as(u32, @intCast(name.len)));
396396 try binary_writer.writeAll(name);
397397
398398 try binary_writer.writeByte(@intFromEnum(std.wasm.ExternalKind.function));
399 try leb.writeUleb128(binary_writer, function_import.index);
399 try leb.writeUleb128(binary_writer, @intFromEnum(function_import.functionType(wasm)));
400400 }
401401
402402 for (wasm.table_imports.values()) |*table_import| {
403 const module_name = table_import.module_name.slice(wasm);
403 const module_name = table_import.moduleName(wasm).slice(wasm);
404404 try leb.writeUleb128(binary_writer, @as(u32, @intCast(module_name.len)));
405405 try binary_writer.writeAll(module_name);
406406
407 const name = table_import.name.slice(wasm);
407 const name = table_import.name(wasm).slice(wasm);
408408 try leb.writeUleb128(binary_writer, @as(u32, @intCast(name.len)));
409409 try binary_writer.writeAll(name);
410410
......@@ -413,7 +413,7 @@ pub fn finish(f: *Flush, wasm: *Wasm, arena: Allocator) !void {
413413 try emitLimits(binary_writer, table_import.limits);
414414 }
415415
416 for (wasm.memory_imports.items) |*memory_import| {
416 for (wasm.object_memory_imports.items) |*memory_import| {
417417 try emitMemoryImport(wasm, binary_writer, memory_import);
418418 } else if (import_memory) {
419419 try emitMemoryImport(wasm, binary_writer, &.{