authorgravatar for luuk@degram.devLuuk de Gram <luuk@degram.dev> 2022-02-08 19:12:43+01:00
committergravatar for kubkon@jakubkonka.comJakub Konka <kubkon@jakubkonka.com> 2022-02-08 21:01:01+01:00
log37fea3e3ddc1f7d266d95789c3b1005291bcb96b
treeb334600461274faaf19708f79263bfac7a37e699
parent9981b3fd2f7ab85146efa9feebe08a795411d131

wasm: Store stack-offset as WValue

Rather than using runtime to perform pointer arithmetic to set the stack offset as a pointer into a local, we now store the offset as a WValue from the bottom of the stack. This has the benefit of less instructions, few locals, and less performance impact when we allocate a value on the virtual stack.

1 files changed, 126 insertions(+), 91 deletions(-)

src/arch/wasm/CodeGen.zig+126-91
......@@ -51,6 +51,22 @@ const WValue = union(enum) {
5151 /// In wasm function pointers are indexes into a function table,
5252 /// rather than an address in the data section.
5353 function_index: u32,
54 /// Offset from the bottom of the stack, with the offset
55 /// pointing to where the value lives.
56 stack_offset: u32,
57
58 /// Returns the offset from the bottom of the stack. This is useful when
59 /// we use the load or store instruction to ensure we retrieve the value
60 /// from the correct position, rather than the value that lives at the
61 /// bottom of the stack. For instances where `WValue` is not `stack_value`
62 /// this will return 0, which allows us to simply call this function for all
63 /// loads and stores without requiring checks everywhere.
64 fn offset(self: WValue) u32 {
65 switch (self) {
66 .stack_offset => |offset| return offset,
67 else => return 0,
68 }
69 }
5470};
5571
5672/// Wasm ops, but without input/output/signedness information
......@@ -778,6 +794,7 @@ fn emitWValue(self: *Self, value: WValue) InnerError!void {
778794 try self.addInst(.{ .tag = .memory_address, .data = .{ .payload = extra_index } });
779795 },
780796 .function_index => |index| try self.addLabel(.function_index, index), // write function index and generate relocation
797 .stack_offset => try self.addLabel(.local_get, self.bottom_stack_value.local), // caller must ensure to address the offset
781798 }
782799}
783800
......@@ -1372,18 +1389,6 @@ fn restoreStackPointer(self: *Self) !void {
13721389 try self.addLabel(.global_set, 0);
13731390}
13741391
1375/// Saves the current stack size's stack pointer position into a given local
1376/// It does this by retrieving the bottom stack pointer, adding `self.stack_size` and storing
1377/// the result back into the local.
1378fn saveStack(self: *Self) !WValue {
1379 const local = try self.allocLocal(Type.usize);
1380 try self.addLabel(.local_get, self.bottom_stack_value.local);
1381 try self.addImm32(@intCast(i32, self.stack_size));
1382 try self.addTag(.i32_add);
1383 try self.addLabel(.local_set, local.local);
1384 return local;
1385}
1386
13871392/// From a given type, will create space on the virtual stack to store the value of such type.
13881393/// This returns a `WValue` with its active tag set to `local`, containing the index to the local
13891394/// that points to the position on the virtual stack. This function should be used instead of
......@@ -1408,8 +1413,7 @@ fn allocStack(self: *Self, ty: Type) !WValue {
14081413 const offset = std.mem.alignForwardGeneric(u32, self.stack_size, abi_align);
14091414 defer self.stack_size = offset + abi_size;
14101415
1411 // store the stack pointer and return a local to it
1412 return self.saveStack();
1416 return WValue{ .stack_offset = offset };
14131417}
14141418
14151419/// From a given AIR instruction generates a pointer to the stack where
......@@ -1439,8 +1443,7 @@ fn allocStackPtr(self: *Self, inst: Air.Inst.Index) !WValue {
14391443 const offset = std.mem.alignForwardGeneric(u32, self.stack_size, abi_alignment);
14401444 defer self.stack_size = offset + abi_size;
14411445
1442 // store the stack pointer and return a local to it
1443 return self.saveStack();
1446 return WValue{ .stack_offset = offset };
14441447}
14451448
14461449/// From given zig bitsize, returns the wasm bitsize
......@@ -1458,14 +1461,16 @@ fn toWasmIntBits(bits: u16) ?u16 {
14581461fn memCopy(self: *Self, ty: Type, lhs: WValue, rhs: WValue) !void {
14591462 const abi_size = ty.abiSize(self.target);
14601463 var offset: u32 = 0;
1464 const lhs_base = lhs.offset();
1465 const rhs_base = rhs.offset();
14611466 while (offset < abi_size) : (offset += 1) {
14621467 // get lhs' address to store the result
14631468 try self.emitWValue(lhs);
14641469 // load byte from rhs' adress
14651470 try self.emitWValue(rhs);
1466 try self.addMemArg(.i32_load8_u, .{ .offset = offset, .alignment = 1 });
1471 try self.addMemArg(.i32_load8_u, .{ .offset = rhs_base + offset, .alignment = 1 });
14671472 // store the result in lhs (we already have its address on the stack)
1468 try self.addMemArg(.i32_store8, .{ .offset = offset, .alignment = 1 });
1473 try self.addMemArg(.i32_store8, .{ .offset = lhs_base + offset, .alignment = 1 });
14691474 }
14701475}
14711476
......@@ -1533,19 +1538,19 @@ fn isByRef(ty: Type, target: std.Target) bool {
15331538/// local value to store the pointer. This allows for local re-use and improves binary size.
15341539fn buildPointerOffset(self: *Self, ptr_value: WValue, offset: u64, action: enum { modify, new }) InnerError!WValue {
15351540 // do not perform arithmetic when offset is 0.
1536 if (offset == 0) return ptr_value;
1541 if (offset == 0 and ptr_value.offset() == 0) return ptr_value;
15371542 const result_ptr: WValue = switch (action) {
15381543 .new => try self.allocLocal(Type.usize),
15391544 .modify => ptr_value,
15401545 };
15411546 try self.emitWValue(ptr_value);
1542 switch (self.target.cpu.arch.ptrBitWidth()) {
1543 32 => {
1544 try self.addImm32(@bitCast(i32, @intCast(u32, offset)));
1547 switch (self.arch()) {
1548 .wasm32 => {
1549 try self.addImm32(@bitCast(i32, @intCast(u32, offset + ptr_value.offset())));
15451550 try self.addTag(.i32_add);
15461551 },
1547 64 => {
1548 try self.addImm64(offset);
1552 .wasm64 => {
1553 try self.addImm64(offset + ptr_value.offset());
15491554 try self.addTag(.i64_add);
15501555 },
15511556 else => unreachable,
......@@ -1554,16 +1559,6 @@ fn buildPointerOffset(self: *Self, ptr_value: WValue, offset: u64, action: enum
15541559 return result_ptr;
15551560}
15561561
1557/// Creates a new local and sets its value to the given `value` local.
1558/// User must ensure `ty` matches that of given `value`.
1559/// Asserts `value` is a `local`.
1560fn copyLocal(self: *Self, value: WValue, ty: Type) InnerError!WValue {
1561 const copy = try self.allocLocal(ty);
1562 try self.addLabel(.local_get, value.local);
1563 try self.addLabel(.local_set, copy.local);
1564 return copy;
1565}
1566
15671562fn genInst(self: *Self, inst: Air.Inst.Index) !WValue {
15681563 const air_tags = self.air.instructions.items(.tag);
15691564 return switch (air_tags[inst]) {
......@@ -1789,7 +1784,8 @@ fn airCall(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
17891784
17901785 const sret = if (first_param_sret) blk: {
17911786 const sret_local = try self.allocStack(ret_ty);
1792 try self.emitWValue(sret_local);
1787 const ptr_offset = try self.buildPointerOffset(sret_local, 0, .new);
1788 try self.emitWValue(ptr_offset);
17931789 break :blk sret_local;
17941790 } else WValue{ .none = {} };
17951791
......@@ -1799,7 +1795,11 @@ fn airCall(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
17991795
18001796 const arg_ty = self.air.typeOf(arg_ref);
18011797 if (!arg_ty.hasRuntimeBits()) continue;
1802 try self.emitWValue(arg_val);
1798
1799 switch (arg_val) {
1800 .stack_offset => try self.emitWValue(try self.buildPointerOffset(arg_val, 0, .new)),
1801 else => try self.emitWValue(arg_val),
1802 }
18031803 }
18041804
18051805 if (target) |direct| {
......@@ -1865,7 +1865,7 @@ fn store(self: *Self, lhs: WValue, rhs: WValue, ty: Type, offset: u32) InnerErro
18651865 var buf: Type.Payload.ElemType = undefined;
18661866 const pl_ty = ty.optionalChild(&buf);
18671867 if (!pl_ty.hasRuntimeBits()) {
1868 return self.store(lhs, rhs, Type.initTag(.u8), 0);
1868 return self.store(lhs, rhs, Type.u8, 0);
18691869 }
18701870
18711871 return self.memCopy(ty, lhs, rhs);
......@@ -1891,7 +1891,13 @@ fn store(self: *Self, lhs: WValue, rhs: WValue, ty: Type, offset: u32) InnerErro
18911891 else => {},
18921892 }
18931893 try self.emitWValue(lhs);
1894 try self.emitWValue(rhs);
1894 // In this case we're actually interested in storing the stack position
1895 // into lhs, so we calculate that and emit that instead
1896 if (rhs == .stack_offset) {
1897 try self.emitWValue(try self.buildPointerOffset(rhs, 0, .new));
1898 } else {
1899 try self.emitWValue(rhs);
1900 }
18951901 const valtype = typeToValtype(ty, self.target);
18961902 const abi_size = @intCast(u8, ty.abiSize(self.target));
18971903
......@@ -1904,7 +1910,7 @@ fn store(self: *Self, lhs: WValue, rhs: WValue, ty: Type, offset: u32) InnerErro
19041910 // store rhs value at stack pointer's location in memory
19051911 try self.addMemArg(
19061912 Mir.Inst.Tag.fromOpcode(opcode),
1907 .{ .offset = offset, .alignment = ty.abiAlignment(self.target) },
1913 .{ .offset = offset + lhs.offset(), .alignment = ty.abiAlignment(self.target) },
19081914 );
19091915}
19101916
......@@ -1947,7 +1953,7 @@ fn load(self: *Self, operand: WValue, ty: Type, offset: u32) InnerError!WValue {
19471953
19481954 try self.addMemArg(
19491955 Mir.Inst.Tag.fromOpcode(opcode),
1950 .{ .offset = offset, .alignment = ty.abiAlignment(self.target) },
1956 .{ .offset = offset + operand.offset(), .alignment = ty.abiAlignment(self.target) },
19511957 );
19521958
19531959 // store the result in a local
......@@ -2358,7 +2364,12 @@ fn airBr(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
23582364
23592365 // if operand has codegen bits we should break with a value
23602366 if (self.air.typeOf(br.operand).hasRuntimeBits()) {
2361 try self.emitWValue(try self.resolveInst(br.operand));
2367 const operand = try self.resolveInst(br.operand);
2368 const op = switch (operand) {
2369 .stack_offset => try self.buildPointerOffset(operand, 0, .new),
2370 else => operand,
2371 };
2372 try self.emitWValue(op);
23622373
23632374 if (block.value != .none) {
23642375 try self.addLabel(.local_set, block.value.local);
......@@ -2381,8 +2392,7 @@ fn airNot(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
23812392
23822393 // wasm does not have booleans nor the `not` instruction, therefore compare with 0
23832394 // to create the same logic
2384 try self.addImm32(0);
2385 try self.addTag(.i32_eq);
2395 try self.addTag(.i32_eqz);
23862396
23872397 // save the result in the local
23882398 const not_tmp = try self.allocLocal(Type.initTag(.i32));
......@@ -2406,8 +2416,7 @@ fn airUnreachable(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
24062416
24072417fn airBitcast(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
24082418 const ty_op = self.air.instructions.items(.data)[inst].ty_op;
2409 const operand = try self.resolveInst(ty_op.operand);
2410 return operand;
2419 return self.resolveInst(ty_op.operand);
24112420}
24122421
24132422fn airStructFieldPtr(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
......@@ -2437,7 +2446,12 @@ fn airStructFieldPtrIndex(self: *Self, inst: Air.Inst.Index, index: u32) InnerEr
24372446}
24382447
24392448fn structFieldPtr(self: *Self, struct_ptr: WValue, offset: u32) InnerError!WValue {
2440 return self.buildPointerOffset(struct_ptr, offset, .new);
2449 switch (struct_ptr) {
2450 .stack_offset => |stack_offset| {
2451 return WValue{ .stack_offset = stack_offset + offset };
2452 },
2453 else => return self.buildPointerOffset(struct_ptr, offset, .new),
2454 }
24412455}
24422456
24432457fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
......@@ -2455,7 +2469,12 @@ fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
24552469 };
24562470
24572471 if (isByRef(field_ty, self.target)) {
2458 return self.buildPointerOffset(operand, offset, .new);
2472 switch (operand) {
2473 .stack_offset => |stack_offset| {
2474 return WValue{ .stack_offset = stack_offset + offset };
2475 },
2476 else => return self.buildPointerOffset(operand, offset, .new),
2477 }
24592478 }
24602479
24612480 return self.load(operand, field_ty, offset);
......@@ -2621,7 +2640,7 @@ fn airIsErr(self: *Self, inst: Air.Inst.Index, opcode: wasm.Opcode) InnerError!W
26212640 try self.emitWValue(operand);
26222641 if (pl_ty.hasRuntimeBits()) {
26232642 try self.addMemArg(.i32_load16_u, .{
2624 .offset = 0,
2643 .offset = operand.offset(),
26252644 .alignment = err_ty.errorUnionSet().abiAlignment(self.target),
26262645 });
26272646 }
......@@ -2679,9 +2698,9 @@ fn airWrapErrUnionPayload(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
26792698 try self.store(payload_ptr, operand, op_ty, 0);
26802699
26812700 // ensure we also write '0' to the error part, so any present stack value gets overwritten by it.
2682 try self.addLabel(.local_get, err_union.local);
2701 try self.emitWValue(err_union);
26832702 try self.addImm32(0);
2684 try self.addMemArg(.i32_store16, .{ .offset = 0, .alignment = 2 });
2703 try self.addMemArg(.i32_store16, .{ .offset = err_union.offset(), .alignment = 2 });
26852704
26862705 return err_union;
26872706}
......@@ -2752,7 +2771,7 @@ fn isNull(self: *Self, operand: WValue, optional_ty: Type, opcode: wasm.Opcode)
27522771 // When payload is zero-bits, we can treat operand as a value, rather than
27532772 // a pointer to the stack value
27542773 if (payload_ty.hasRuntimeBits()) {
2755 try self.addMemArg(.i32_load8_u, .{ .offset = 0, .alignment = 1 });
2774 try self.addMemArg(.i32_load8_u, .{ .offset = operand.offset(), .alignment = 1 });
27562775 }
27572776 }
27582777
......@@ -2820,7 +2839,7 @@ fn airOptionalPayloadPtrSet(self: *Self, inst: Air.Inst.Index) InnerError!WValue
28202839
28212840 try self.emitWValue(operand);
28222841 try self.addImm32(1);
2823 try self.addMemArg(.i32_store8, .{ .offset = 0, .alignment = 1 });
2842 try self.addMemArg(.i32_store8, .{ .offset = operand.offset(), .alignment = 1 });
28242843
28252844 return self.buildPointerOffset(operand, offset, .new);
28262845}
......@@ -2832,9 +2851,9 @@ fn airWrapOptional(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
28322851 const payload_ty = self.air.typeOf(ty_op.operand);
28332852 if (!payload_ty.hasRuntimeBits()) {
28342853 const non_null_bit = try self.allocStack(Type.initTag(.u1));
2835 try self.addLabel(.local_get, non_null_bit.local);
2854 try self.emitWValue(non_null_bit);
28362855 try self.addImm32(1);
2837 try self.addMemArg(.i32_store8, .{ .offset = 0, .alignment = 1 });
2856 try self.addMemArg(.i32_store8, .{ .offset = non_null_bit.offset(), .alignment = 1 });
28382857 return non_null_bit;
28392858 }
28402859
......@@ -2849,9 +2868,9 @@ fn airWrapOptional(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
28492868
28502869 // Create optional type, set the non-null bit, and store the operand inside the optional type
28512870 const result = try self.allocStack(op_ty);
2852 try self.addLabel(.local_get, result.local);
2871 try self.emitWValue(result);
28532872 try self.addImm32(1);
2854 try self.addMemArg(.i32_store8, .{ .offset = 0, .alignment = 1 });
2873 try self.addMemArg(.i32_store8, .{ .offset = result.offset(), .alignment = 1 });
28552874
28562875 const payload_ptr = try self.buildPointerOffset(result, offset, .new);
28572876 try self.store(payload_ptr, operand, payload_ty, 0);
......@@ -3013,8 +3032,6 @@ fn airArrayToSlice(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
30133032 const ty_op = self.air.instructions.items(.data)[inst].ty_op;
30143033 const operand = try self.resolveInst(ty_op.operand);
30153034 const array_ty = self.air.typeOf(ty_op.operand).childType();
3016 const ty = Type.@"usize";
3017 const ptr_width = @intCast(u32, ty.abiSize(self.target));
30183035 const slice_ty = self.air.getRefType(ty_op.ty);
30193036
30203037 // create a slice on the stack
......@@ -3022,15 +3039,12 @@ fn airArrayToSlice(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
30223039
30233040 // store the array ptr in the slice
30243041 if (array_ty.hasRuntimeBits()) {
3025 try self.store(slice_local, operand, ty, 0);
3042 try self.store(slice_local, operand, Type.usize, 0);
30263043 }
30273044
30283045 // store the length of the array in the slice
3029 const len = array_ty.arrayLen();
3030 try self.addImm32(@bitCast(i32, @intCast(u32, len)));
3031 const len_local = try self.allocLocal(ty);
3032 try self.addLabel(.local_set, len_local.local);
3033 try self.store(slice_local, len_local, ty, ptr_width);
3046 const len = WValue{ .imm32 = @intCast(u32, array_ty.arrayLen()) };
3047 try self.store(slice_local, len, Type.usize, self.ptrSize());
30343048
30353049 return slice_local;
30363050}
......@@ -3038,7 +3052,13 @@ fn airArrayToSlice(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
30383052fn airPtrToInt(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
30393053 if (self.liveness.isUnused(inst)) return WValue{ .none = {} };
30403054 const un_op = self.air.instructions.items(.data)[inst].un_op;
3041 return self.resolveInst(un_op);
3055 const operand = try self.resolveInst(un_op);
3056
3057 switch (operand) {
3058 // for stack offset, return a pointer to this offset.
3059 .stack_offset => return self.buildPointerOffset(operand, 0, .new),
3060 else => return operand,
3061 }
30423062}
30433063
30443064fn airPtrElemVal(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
......@@ -3046,16 +3066,20 @@ fn airPtrElemVal(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
30463066
30473067 const bin_op = self.air.instructions.items(.data)[inst].bin_op;
30483068 const ptr_ty = self.air.typeOf(bin_op.lhs);
3049 const pointer = try self.resolveInst(bin_op.lhs);
3069 const ptr = try self.resolveInst(bin_op.lhs);
30503070 const index = try self.resolveInst(bin_op.rhs);
30513071 const elem_ty = ptr_ty.childType();
30523072 const elem_size = elem_ty.abiSize(self.target);
30533073
30543074 // load pointer onto the stack
30553075 if (ptr_ty.isSlice()) {
3056 const ptr_local = try self.load(pointer, Type.usize, 0);
3076 const ptr_local = try self.load(ptr, Type.usize, 0);
30573077 try self.addLabel(.local_get, ptr_local.local);
30583078 } else {
3079 const pointer = switch (ptr) {
3080 .stack_offset => try self.buildPointerOffset(ptr, 0, .new),
3081 else => ptr,
3082 };
30593083 try self.emitWValue(pointer);
30603084 }
30613085
......@@ -3089,7 +3113,11 @@ fn airPtrElemPtr(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
30893113 const ptr_local = try self.load(ptr, Type.usize, 0);
30903114 try self.addLabel(.local_get, ptr_local.local);
30913115 } else {
3092 try self.emitWValue(ptr);
3116 const pointer = switch (ptr) {
3117 .stack_offset => try self.buildPointerOffset(ptr, 0, .new),
3118 else => ptr,
3119 };
3120 try self.emitWValue(pointer);
30933121 }
30943122
30953123 // calculate index into ptr
......@@ -3118,7 +3146,11 @@ fn airPtrBinOp(self: *Self, inst: Air.Inst.Index, op: Op) InnerError!WValue {
31183146 const mul_opcode = buildOpcode(.{ .valtype1 = valtype, .op = .mul });
31193147 const bin_opcode = buildOpcode(.{ .valtype1 = valtype, .op = op });
31203148
3121 try self.emitWValue(ptr);
3149 const pointer = switch (ptr) {
3150 .stack_offset => try self.buildPointerOffset(ptr, 0, .new),
3151 else => ptr,
3152 };
3153 try self.emitWValue(pointer);
31223154 try self.emitWValue(offset);
31233155 try self.addImm32(@bitCast(i32, @intCast(u32, pointee_ty.abiSize(self.target))));
31243156 try self.addTag(Mir.Inst.Tag.fromOpcode(mul_opcode));
......@@ -3138,7 +3170,7 @@ fn airMemset(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
31383170 const len = try self.resolveInst(bin_op.rhs);
31393171 try self.memSet(ptr, len, value);
31403172
3141 return WValue.none;
3173 return WValue{ .none = {} };
31423174}
31433175
31443176/// Sets a region of memory at `ptr` to the value of `value`
......@@ -3149,7 +3181,10 @@ fn memSet(self: *Self, ptr: WValue, len: WValue, value: WValue) InnerError!void
31493181 // When bulk_memory is enabled, we lower it to wasm's memset instruction.
31503182 // If not, we lower it ourselves
31513183 if (std.Target.wasm.featureSetHas(self.target.cpu.features, .bulk_memory)) {
3152 try self.emitWValue(ptr);
3184 switch (ptr) {
3185 .stack_offset => try self.emitWValue(try self.buildPointerOffset(ptr, 0, .new)),
3186 else => try self.emitWValue(ptr),
3187 }
31533188 try self.emitWValue(value);
31543189 try self.emitWValue(len);
31553190 try self.addExtended(.memory_fill);
......@@ -3172,18 +3207,18 @@ fn memSet(self: *Self, ptr: WValue, len: WValue, value: WValue) InnerError!void
31723207 try self.addLabel(.br_if, 1); // jump out of loop into outer block (finished)
31733208 try self.emitWValue(ptr);
31743209 try self.emitWValue(offset);
3175 switch (self.ptrSize()) {
3176 4 => try self.addTag(.i32_add),
3177 8 => try self.addTag(.i64_add),
3210 switch (self.arch()) {
3211 .wasm32 => try self.addTag(.i32_add),
3212 .wasm64 => try self.addTag(.i64_add),
31783213 else => unreachable,
31793214 }
31803215 try self.emitWValue(value);
3181 const mem_store_op: Mir.Inst.Tag = switch (self.ptrSize()) {
3182 4 => .i32_store8,
3183 8 => .i64_store8,
3216 const mem_store_op: Mir.Inst.Tag = switch (self.arch()) {
3217 .wasm32 => .i32_store8,
3218 .wasm64 => .i64_store8,
31843219 else => unreachable,
31853220 };
3186 try self.addMemArg(mem_store_op, .{ .offset = 0, .alignment = 1 });
3221 try self.addMemArg(mem_store_op, .{ .offset = ptr.offset(), .alignment = 1 });
31873222 try self.emitWValue(offset);
31883223 try self.addImm32(1);
31893224 switch (self.ptrSize()) {
......@@ -3207,14 +3242,18 @@ fn airArrayElemVal(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
32073242 const elem_ty = array_ty.childType();
32083243 const elem_size = elem_ty.abiSize(self.target);
32093244
3210 // calculate index into slice
3211 try self.emitWValue(array);
3245 const array_ptr = switch (array) {
3246 .stack_offset => try self.buildPointerOffset(array, 0, .new),
3247 else => array,
3248 };
3249
3250 try self.emitWValue(array_ptr);
32123251 try self.emitWValue(index);
32133252 try self.addImm32(@bitCast(i32, @intCast(u32, elem_size)));
32143253 try self.addTag(.i32_mul);
32153254 try self.addTag(.i32_add);
32163255
3217 const result = try self.allocLocal(elem_ty);
3256 const result = try self.allocLocal(Type.usize);
32183257 try self.addLabel(.local_set, result.local);
32193258
32203259 if (isByRef(elem_ty, self.target)) {
......@@ -3277,9 +3316,7 @@ fn airVectorInit(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
32773316 if (isByRef(elem_ty, self.target)) {
32783317 // copy stack pointer into a temporary local, which is
32793318 // moved for each element to store each value in the right position.
3280 const offset = try self.allocLocal(Type.usize);
3281 try self.emitWValue(result);
3282 try self.addLabel(.local_set, offset.local);
3319 const offset = try self.buildPointerOffset(result, 0, .new);
32833320 for (elements) |elem, elem_index| {
32843321 const elem_val = try self.resolveInst(elem);
32853322 try self.store(offset, elem_val, elem_ty, 0);
......@@ -3301,9 +3338,7 @@ fn airVectorInit(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
33013338 .Struct => {
33023339 const tuple = vector_ty.castTag(.tuple).?.data;
33033340 const result = try self.allocStack(vector_ty);
3304 const offset = try self.allocLocal(Type.usize); // pointer to offset
3305 try self.emitWValue(result);
3306 try self.addLabel(.local_set, offset.local);
3341 const offset = try self.buildPointerOffset(result, 0, .new); // pointer to offset
33073342 for (elements) |elem, elem_index| {
33083343 if (tuple.values[elem_index].tag() != .unreachable_value) continue;
33093344
......@@ -3379,10 +3414,10 @@ fn cmpBigInt(self: *Self, lhs: WValue, rhs: WValue, operand_ty: Type, op: std.ma
33793414 const result = try self.allocLocal(Type.initTag(.i32));
33803415 {
33813416 try self.startBlock(.block, wasm.block_empty);
3382 const lhs_high_bit = try self.load(lhs, Type.initTag(.u64), 0);
3383 const lhs_low_bit = try self.load(lhs, Type.initTag(.u64), 8);
3384 const rhs_high_bit = try self.load(rhs, Type.initTag(.u64), 0);
3385 const rhs_low_bit = try self.load(rhs, Type.initTag(.u64), 8);
3417 const lhs_high_bit = try self.load(lhs, Type.u64, 0);
3418 const lhs_low_bit = try self.load(lhs, Type.u64, 8);
3419 const rhs_high_bit = try self.load(rhs, Type.u64, 0);
3420 const rhs_low_bit = try self.load(rhs, Type.u64, 8);
33863421 try self.emitWValue(lhs_high_bit);
33873422 try self.emitWValue(rhs_high_bit);
33883423 try self.addTag(.i64_ne);