Commit 2438f61f1c
src/codegen/wasm.zig
@@ -483,8 +483,8 @@ pub const Result = union(enum) {
externally_managed: []const u8,
};
-/// Hashmap to store generated `WValue` for each `Inst`
-pub const ValueTable = std.AutoHashMapUnmanaged(Air.Inst.Index, WValue);
+/// Hashmap to store generated `WValue` for each `Air.Inst.Ref`
+pub const ValueTable = std.AutoHashMapUnmanaged(Air.Inst.Ref, WValue);
/// Code represents the `Code` section of wasm that
/// belongs to a function
@@ -495,7 +495,7 @@ pub const Context = struct {
air: Air,
liveness: Liveness,
gpa: *mem.Allocator,
- /// Table to save `WValue`'s generated by an `Inst`
+ /// Table to save `WValue`'s generated by an `Air.Inst`
values: ValueTable,
/// Mapping from Air.Inst.Index to block ids
blocks: std.AutoArrayHashMapUnmanaged(Air.Inst.Index, u32) = .{},
@@ -547,14 +547,15 @@ pub const Context = struct {
/// Resolves the `WValue` for the given instruction `inst`
/// When the given instruction has a `Value`, it returns a constant instead
- fn resolveInst(self: Context, inst: Air.Inst) Index {
- if (!inst.ty.hasCodeGenBits()) return .none;
+ fn resolveInst(self: Context, ref: Air.Inst.Ref) WValue {
+ const ref_type = self.air.getRefType(ref);
+ if (ref_type.hasCodeGenBits()) return .none;
- if (inst.value()) |_| {
- return WValue{ .constant = inst };
+ if (self.air.instructions.items(.tag)[@enumToInt(ref)] == .constant) {
+ return WValue{ .constant = @enumToInt(ref) };
}
- return self.values.get(inst).?; // Instruction does not dominate all uses!
+ return self.values.get(ref).?; // Instruction does not dominate all uses!
}
/// Using a given `Type`, returns the corresponding wasm Valtype
@@ -610,7 +611,12 @@ pub const Context = struct {
try writer.writeByte(wasm.opcode(.local_get));
try leb.writeULEB128(writer, idx);
},
- .constant => |inst| try self.emitConstant(inst.value().?, inst.ty), // creates a new constant onto the stack
+ .constant => |index| {
+ const ty_pl = self.air.instructions.items(.data)[index].ty_pl;
+ const value = self.air.values[ty_pl.payload];
+ // create a new constant onto the stack
+ try self.emitConstant(value, self.air.getRefType(ty_pl.ty));
+ },
}
}
@@ -626,10 +632,7 @@ pub const Context = struct {
const fields_len = @intCast(u32, struct_data.fields.count());
try self.locals.ensureCapacity(self.gpa, self.locals.items.len + fields_len);
for (struct_data.fields.values()) |*value| {
- const val_type = try self.genValtype(
- .{ .node_offset = struct_data.node_offset },
- value.ty,
- );
+ const val_type = try self.genValtype(value.ty);
self.locals.appendAssumeCapacity(val_type);
self.local_index += 1;
}
@@ -640,7 +643,7 @@ pub const Context = struct {
},
.ErrorUnion => {
const payload_type = ty.errorUnionChild();
- const val_type = try self.genValtype(.{ .node_offset = 0 }, payload_type);
+ const val_type = try self.genValtype(payload_type);
// we emit the error value as the first local, and the payload as the following.
// The first local is also used to find the index of the error and payload.
@@ -657,7 +660,7 @@ pub const Context = struct {
} };
},
else => {
- const valtype = try self.genValtype(.{ .node_offset = 0 }, ty);
+ const valtype = try self.genValtype(ty);
try self.locals.append(self.gpa, valtype);
self.local_index += 1;
return WValue{ .local = initial_index };
@@ -708,8 +711,7 @@ pub const Context = struct {
}
}
- pub fn genFunc(self: *Context, func: *Module.Fn) InnerError!Result {
- _ = func;
+ pub fn genFunc(self: *Context) InnerError!Result {
try self.genFunctype();
// TODO: check for and handle death of instructions
@@ -790,44 +792,43 @@ pub const Context = struct {
fn genInst(self: *Context, inst: Air.Inst.Index) !WValue {
const air_tags = self.air.instructions.items(.tag);
return switch (air_tags[inst]) {
- // .add => self.genBinOp(inst.castTag(.add).?, .add),
- // .alloc => self.genAlloc(inst.castTag(.alloc).?),
- // .arg => self.genArg(inst.castTag(.arg).?),
- // .bit_and => self.genBinOp(inst.castTag(.bit_and).?, .@"and"),
- // .bitcast => self.genBitcast(inst.castTag(.bitcast).?),
- // .bit_or => self.genBinOp(inst.castTag(.bit_or).?, .@"or"),
- // .block => self.genBlock(inst.castTag(.block).?),
- // .bool_and => self.genBinOp(inst.castTag(.bool_and).?, .@"and"),
- // .bool_or => self.genBinOp(inst.castTag(.bool_or).?, .@"or"),
- // .breakpoint => self.genBreakpoint(inst.castTag(.breakpoint).?),
- // .br => self.genBr(inst.castTag(.br).?),
- // .call => self.genCall(inst.castTag(.call).?),
- // .cmp_eq => self.genCmp(inst.castTag(.cmp_eq).?, .eq),
- // .cmp_gte => self.genCmp(inst.castTag(.cmp_gte).?, .gte),
- // .cmp_gt => self.genCmp(inst.castTag(.cmp_gt).?, .gt),
- // .cmp_lte => self.genCmp(inst.castTag(.cmp_lte).?, .lte),
- // .cmp_lt => self.genCmp(inst.castTag(.cmp_lt).?, .lt),
- // .cmp_neq => self.genCmp(inst.castTag(.cmp_neq).?, .neq),
- // .condbr => self.genCondBr(inst.castTag(.condbr).?),
- // .constant => unreachable,
- // .dbg_stmt => WValue.none,
- // .div => self.genBinOp(inst.castTag(.div).?, .div),
- // .is_err => self.genIsErr(inst.castTag(.is_err).?, .i32_ne),
- // .is_non_err => self.genIsErr(inst.castTag(.is_non_err).?, .i32_eq),
- // .load => self.genLoad(inst.castTag(.load).?),
- // .loop => self.genLoop(inst.castTag(.loop).?),
- // .mul => self.genBinOp(inst.castTag(.mul).?, .mul),
- // .not => self.genNot(inst.castTag(.not).?),
- // .ret => self.genRet(inst.castTag(.ret).?),
- // .retvoid => WValue.none,
- // .store => self.genStore(inst.castTag(.store).?),
- // .struct_field_ptr => self.genStructFieldPtr(inst.castTag(.struct_field_ptr).?),
- // .sub => self.genBinOp(inst.castTag(.sub).?, .sub),
- // .switchbr => self.genSwitchBr(inst.castTag(.switchbr).?),
- // .unreach => self.genUnreachable(inst.castTag(.unreach).?),
- // .unwrap_errunion_payload => self.genUnwrapErrUnionPayload(inst.castTag(.unwrap_errunion_payload).?),
- // .wrap_errunion_payload => self.genWrapErrUnionPayload(inst.castTag(.wrap_errunion_payload).?),
- // .xor => self.genBinOp(inst.castTag(.xor).?, .xor),
+ .add => self.genBinOp(inst, .add),
+ .alloc => self.genAlloc(inst),
+ .arg => self.genArg(inst),
+ .bit_and => self.genBinOp(inst, .@"and"),
+ .bitcast => self.genBitcast(inst),
+ .bit_or => self.genBinOp(inst, .@"or"),
+ .block => self.genBlock(inst),
+ .bool_and => self.genBinOp(inst, .@"and"),
+ .bool_or => self.genBinOp(inst, .@"or"),
+ .breakpoint => self.genBreakpoint(inst),
+ .br => self.genBr(inst),
+ .call => self.genCall(inst),
+ .cmp_eq => self.genCmp(inst, .eq),
+ .cmp_gte => self.genCmp(inst, .gte),
+ .cmp_gt => self.genCmp(inst, .gt),
+ .cmp_lte => self.genCmp(inst, .lte),
+ .cmp_lt => self.genCmp(inst, .lt),
+ .cmp_neq => self.genCmp(inst, .neq),
+ .cond_br => self.genCondBr(inst),
+ .constant => unreachable,
+ .dbg_stmt => WValue.none,
+ .div => self.genBinOp(inst, .div),
+ .is_err => self.genIsErr(inst, .i32_ne),
+ .is_non_err => self.genIsErr(inst, .i32_eq),
+ .load => self.genLoad(inst),
+ .loop => self.genLoop(inst),
+ .mul => self.genBinOp(inst, .mul),
+ .not => self.genNot(inst),
+ .ret => self.genRet(inst),
+ .store => self.genStore(inst),
+ .struct_field_ptr => self.genStructFieldPtr(inst),
+ .sub => self.genBinOp(inst, .sub),
+ .switch_br => self.genSwitchBr(inst),
+ .unreach => self.genUnreachable(inst),
+ .unwrap_errunion_payload => self.genUnwrapErrUnionPayload(inst),
+ .wrap_errunion_payload => self.genWrapErrUnionPayload(inst),
+ .xor => self.genBinOp(inst, .xor),
else => |tag| self.fail("TODO: Implement wasm inst: {s}", .{@tagName(tag)}),
};
}
@@ -835,22 +836,27 @@ pub const Context = struct {
fn genBody(self: *Context, body: []const Air.Inst.Index) InnerError!void {
for (body) |inst| {
const result = try self.genInst(inst);
- try self.values.putNoClobber(self.gpa, inst, result);
+ try self.values.putNoClobber(self.gpa, @intToEnum(Air.Inst.Ref, inst), result);
}
}
fn genRet(self: *Context, inst: Air.Inst.Index) InnerError!WValue {
- // TODO: Implement tail calls
- const operand = self.resolveInst(inst.operand);
+ const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const operand = self.resolveInst(un_op);
try self.emitWValue(operand);
try self.code.append(wasm.opcode(.@"return"));
return .none;
}
fn genCall(self: *Context, inst: Air.Inst.Index) InnerError!WValue {
- const func_val = inst.func.value().?;
+ const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const extra = self.air.extraData(Air.Call, pl_op.payload);
+ const args = self.air.extra[extra.end..][0..extra.data.args_len];
const target: *Decl = blk: {
+ const ty_pl = self.air.instructions.items(.data)[@enumToInt(pl_op.operand)].ty_pl;
+ const func_val = self.air.values[ty_pl.payload];
+
if (func_val.castTag(.function)) |func| {
break :blk func.data.owner_decl;
} else if (func_val.castTag(.extern_fn)) |ext_fn| {
@@ -859,8 +865,8 @@ pub const Context = struct {
return self.fail("Expected a function, but instead found type '{s}'", .{func_val.tag()});
};
- for (inst.args) |arg| {
- const arg_val = self.resolveInst(arg);
+ for (args) |arg| {
+ const arg_val = self.resolveInst(@intToEnum(Air.Inst.Ref, arg));
try self.emitWValue(arg_val);
}
@@ -877,15 +883,16 @@ pub const Context = struct {
}
fn genAlloc(self: *Context, inst: Air.Inst.Index) InnerError!WValue {
- const elem_type = inst.base.ty.elemType();
+ const elem_type = self.air.getType(inst).elemType();
return self.allocLocal(elem_type);
}
fn genStore(self: *Context, inst: Air.Inst.Index) InnerError!WValue {
+ const bin_op = self.air.instructions.items(.data)[inst].bin_op;
const writer = self.code.writer();
- const lhs = self.resolveInst(inst.lhs);
- const rhs = self.resolveInst(inst.rhs);
+ const lhs = self.resolveInst(bin_op.lhs);
+ const rhs = self.resolveInst(bin_op.rhs);
switch (lhs) {
.multi_value => |multi_value| switch (rhs) {
@@ -893,7 +900,7 @@ pub const Context = struct {
// we simply assign the local_index to the rhs one.
// This allows us to update struct fields without having to individually
// set each local as each field's index will be calculated off the struct's base index
- .multi_value => self.values.put(self.gpa, inst.lhs, rhs) catch unreachable, // Instruction does not dominate all uses!
+ .multi_value => self.values.put(self.gpa, bin_op.lhs, rhs) catch unreachable, // Instruction does not dominate all uses!
.constant, .none => {
// emit all values onto the stack if constant
try self.emitWValue(rhs);
@@ -920,7 +927,8 @@ pub const Context = struct {
}
fn genLoad(self: *Context, inst: Air.Inst.Index) InnerError!WValue {
- return self.resolveInst(inst.operand);
+ const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ return self.resolveInst(ty_op.operand);
}
fn genArg(self: *Context, inst: Air.Inst.Index) InnerError!WValue {
@@ -931,8 +939,9 @@ pub const Context = struct {
}
fn genBinOp(self: *Context, inst: Air.Inst.Index, op: Op) InnerError!WValue {
- const lhs = self.resolveInst(inst.lhs);
- const rhs = self.resolveInst(inst.rhs);
+ const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const lhs = self.resolveInst(bin_op.lhs);
+ const rhs = self.resolveInst(bin_op.rhs);
// it's possible for both lhs and/or rhs to return an offset as well,
// in which case we return the first offset occurance we find.
@@ -945,10 +954,11 @@ pub const Context = struct {
try self.emitWValue(lhs);
try self.emitWValue(rhs);
+ const bin_ty = self.air.getRefType(bin_op.lhs);
const opcode: wasm.Opcode = buildOpcode(.{
.op = op,
- .valtype1 = try self.typeToValtype(inst.base.ty),
- .signedness = if (inst.base.ty.isSignedInt()) .signed else .unsigned,
+ .valtype1 = try self.typeToValtype(bin_ty),
+ .signedness = if (bin_ty.isSignedInt()) .signed else .unsigned,
});
try self.code.append(wasm.opcode(opcode));
return WValue{ .code_offset = offset };
@@ -1064,14 +1074,17 @@ pub const Context = struct {
}
}
- fn genBlock(self: *Context, block: Air.Inst.Index) InnerError!WValue {
- const block_ty = try self.genBlockType(block.base.ty);
+ fn genBlock(self: *Context, inst: Air.Inst.Index) InnerError!WValue {
+ const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const block_ty = try self.genBlockType(self.air.getRefType(ty_pl.ty));
+ const extra = self.air.extraData(Air.Block, ty_pl.payload);
+ const body = self.air.extra[extra.end..][0..extra.data.body_len];
try self.startBlock(.block, block_ty, null);
// Here we set the current block idx, so breaks know the depth to jump
// to when breaking out.
- try self.blocks.putNoClobber(self.gpa, block, self.block_depth);
- try self.genBody(block.body);
+ try self.blocks.putNoClobber(self.gpa, inst, self.block_depth);
+ try self.genBody(body);
try self.endBlock();
return .none;
@@ -1095,11 +1108,15 @@ pub const Context = struct {
self.block_depth -= 1;
}
- fn genLoop(self: *Context, loop: Air.Inst.Index) InnerError!WValue {
- const loop_ty = try self.genBlockType(loop.base.ty);
+ fn genLoop(self: *Context, inst: Air.Inst.Index) InnerError!WValue {
+ const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const loop = self.air.extraData(Air.Block, ty_pl.payload);
+ const body = self.air.extra[loop.end..][0..loop.data.body_len];
- try self.startBlock(.loop, loop_ty, null);
- try self.genBody(loop.body);
+ // result type of loop is always 'noreturn', meaning we can always
+ // emit the wasm type 'block_empty'.
+ try self.startBlock(.loop, wasm.block_empty, null);
+ try self.genBody(body);
// breaking to the index of a loop block will continue the loop instead
try self.code.append(wasm.opcode(.br));
@@ -1110,8 +1127,12 @@ pub const Context = struct {
return .none;
}
- fn genCondBr(self: *Context, condbr: Air.Inst.Index) InnerError!WValue {
- const condition = self.resolveInst(condbr.condition);
+ fn genCondBr(self: *Context, inst: Air.Inst.Index) InnerError!WValue {
+ const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const condition = self.resolveInst(pl_op.operand);
+ const extra = self.air.extraData(Air.CondBr, pl_op.payload);
+ const then_body = self.air.extra[extra.end..][0..extra.data.then_body_len];
+ const else_body = self.air.extra[extra.end + then_body.len ..][0..extra.data.else_body_len];
const writer = self.code.writer();
// TODO: Handle death instructions for then and else body
@@ -1126,8 +1147,9 @@ pub const Context = struct {
break :blk offset;
},
};
- const block_ty = try self.genBlockType(condbr.base.ty);
- try self.startBlock(.block, block_ty, offset);
+
+ // result type is always noreturn, so use `block_empty` as type.
+ try self.startBlock(.block, wasm.block_empty, offset);
// we inserted the block in front of the condition
// so now check if condition matches. If not, break outside this block
@@ -1135,11 +1157,11 @@ pub const Context = struct {
try writer.writeByte(wasm.opcode(.br_if));
try leb.writeULEB128(writer, @as(u32, 0));
- try self.genBody(condbr.else_body);
+ try self.genBody(else_body);
try self.endBlock();
// Outer block that matches the condition
- try self.genBody(condbr.then_body);
+ try self.genBody(then_body);
return .none;
}
@@ -1149,21 +1171,23 @@ pub const Context = struct {
// the comparison that we can later jump back to
const offset = self.code.items.len;
- const lhs = self.resolveInst(inst.lhs);
- const rhs = self.resolveInst(inst.rhs);
+ const data: Air.Inst.Data = self.air.instructions.items(.data)[inst];
+ const lhs = self.resolveInst(data.bin_op.lhs);
+ const rhs = self.resolveInst(data.bin_op.rhs);
+ const lhs_ty = self.air.getRefType(data.bin_op.lhs);
try self.emitWValue(lhs);
try self.emitWValue(rhs);
const signedness: std.builtin.Signedness = blk: {
// by default we tell the operand type is unsigned (i.e. bools and enum values)
- if (inst.lhs.ty.zigTypeTag() != .Int) break :blk .unsigned;
+ if (lhs_ty.zigTypeTag() != .Int) break :blk .unsigned;
// incase of an actual integer, we emit the correct signedness
- break :blk inst.lhs.ty.intInfo(self.target).signedness;
+ break :blk lhs_ty.intInfo(self.target).signedness;
};
const opcode: wasm.Opcode = buildOpcode(.{
- .valtype1 = try self.typeToValtype(inst.lhs.ty),
+ .valtype1 = try self.typeToValtype(lhs_ty),
.op = switch (op) {
.lt => .lt,
.lte => .le,
@@ -1178,16 +1202,17 @@ pub const Context = struct {
return WValue{ .code_offset = offset };
}
- fn genBr(self: *Context, br: Air.Inst.Index) InnerError!WValue {
+ fn genBr(self: *Context, inst: Air.Inst.Index) InnerError!WValue {
+ const br = self.air.instructions.items(.data)[inst].br;
+
// if operand has codegen bits we should break with a value
- if (br.operand.ty.hasCodeGenBits()) {
- const operand = self.resolveInst(br.operand);
- try self.emitWValue(operand);
+ if (self.air.getRefType(br.operand).hasCodeGenBits()) {
+ try self.emitWValue(self.resolveInst(br.operand));
}
// We map every block to its block index.
// We then determine how far we have to jump to it by substracting it from current block depth
- const idx: u32 = self.block_depth - self.blocks.get(br.block).?;
+ const idx: u32 = self.block_depth - self.blocks.get(br.block_inst).?;
const writer = self.code.writer();
try writer.writeByte(wasm.opcode(.br));
try leb.writeULEB128(writer, idx);
@@ -1195,10 +1220,11 @@ pub const Context = struct {
return .none;
}
- fn genNot(self: *Context, not: Air.Inst.Index) InnerError!WValue {
+ fn genNot(self: *Context, inst: Air.Inst.Index) InnerError!WValue {
+ const ty_op = self.air.instructions.items(.data)[inst].ty_op;
const offset = self.code.items.len;
- const operand = self.resolveInst(not.operand);
+ const operand = self.resolveInst(ty_op.operand);
try self.emitWValue(operand);
// wasm does not have booleans nor the `not` instruction, therefore compare with 0
@@ -1212,35 +1238,44 @@ pub const Context = struct {
return WValue{ .code_offset = offset };
}
- fn genBreakpoint(self: *Context, breakpoint: Air.Inst.Index) InnerError!WValue {
+ fn genBreakpoint(self: *Context, inst: Air.Inst.Index) InnerError!WValue {
_ = self;
- _ = breakpoint;
+ _ = inst;
// unsupported by wasm itself. Can be implemented once we support DWARF
// for wasm
return .none;
}
- fn genUnreachable(self: *Context, unreach: Air.Inst.Index) InnerError!WValue {
- _ = unreach;
+ fn genUnreachable(self: *Context, inst: Air.Inst.Index) InnerError!WValue {
+ _ = inst;
try self.code.append(wasm.opcode(.@"unreachable"));
return .none;
}
- fn genBitcast(self: *Context, bitcast: Air.Inst.Index) InnerError!WValue {
- return self.resolveInst(bitcast.operand);
+ fn genBitcast(self: *Context, inst: Air.Inst.Index) InnerError!WValue {
+ const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ return self.resolveInst(ty_op.operand);
}
fn genStructFieldPtr(self: *Context, inst: Air.Inst.Index) InnerError!WValue {
- const struct_ptr = self.resolveInst(inst.struct_ptr);
+ const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const extra = self.air.extraData(Air.StructField, ty_pl.payload);
+ const struct_ptr = self.resolveInst(extra.data.struct_ptr);
- return WValue{ .local = struct_ptr.multi_value.index + @intCast(u32, inst.field_index) };
+ return WValue{ .local = struct_ptr.multi_value.index + @intCast(u32, extra.data.field_index) };
}
fn genSwitchBr(self: *Context, inst: Air.Inst.Index) InnerError!WValue {
- const target = self.resolveInst(inst.target);
- const target_ty = inst.target.ty;
- const valtype = try self.typeToValtype(.{ .node_offset = 0 }, target_ty);
- const blocktype = try self.genBlockType(inst.base.ty);
+ const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const extra = self.air.extraData(Air.SwitchBr, pl_op.payload);
+ const cases = self.air.extra[extra.end..][0..extra.data.cases_len];
+ const else_body = self.air.extra[extra.end + cases.len ..][0..extra.data.else_body_len];
+
+ const target = self.resolveInst(pl_op.operand);
+ const target_ty = self.air.getRefType(pl_op.operand);
+ const valtype = try self.typeToValtype(target_ty);
+ // result type is always 'noreturn'
+ const blocktype = wasm.block_empty;
const signedness: std.builtin.Signedness = blk: {
// by default we tell the operand type is unsigned (i.e. bools and enum values)
@@ -1249,11 +1284,18 @@ pub const Context = struct {
// incase of an actual integer, we emit the correct signedness
break :blk target_ty.intInfo(self.target).signedness;
};
- for (inst.cases) |case| {
+ for (cases) |case_idx| {
+ const case = self.air.extraData(Air.SwitchBr.Case, case_idx);
+ const case_body = self.air.extra[case.end..][0..case.data.body_len];
+
// create a block for each case, when the condition does not match we break out of it
try self.startBlock(.block, blocktype, null);
try self.emitWValue(target);
- try self.emitConstant(.{ .node_offset = 0 }, case.item, target_ty);
+
+ // cases must represent a constant of which its type is in the `typed_value_map`
+ // Therefore we can simply retrieve it.
+ const ty_val = Air.Inst.Ref.typed_value_map[@enumToInt(case.data.item)];
+ try self.emitConstant(ty_val.val, target_ty);
const opcode = buildOpcode(.{
.valtype1 = valtype,
.op = .ne, // not equal because we jump out the block if it does not match the condition
@@ -1264,7 +1306,7 @@ pub const Context = struct {
try leb.writeULEB128(self.code.writer(), @as(u32, 0));
// emit our block code
- try self.genBody(case.body);
+ try self.genBody(case_body);
// end the block we created earlier
try self.endBlock();
@@ -1272,13 +1314,14 @@ pub const Context = struct {
// finally, emit the else case if it exists. Here we will not have to
// check for a condition, so also no need to emit a block.
- try self.genBody(inst.else_body);
+ try self.genBody(else_body);
return .none;
}
fn genIsErr(self: *Context, inst: Air.Inst.Index, opcode: wasm.Opcode) InnerError!WValue {
- const operand = self.resolveInst(inst.operand);
+ const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const operand = self.resolveInst(un_op);
const offset = self.code.items.len;
const writer = self.code.writer();
@@ -1294,7 +1337,8 @@ pub const Context = struct {
}
fn genUnwrapErrUnionPayload(self: *Context, inst: Air.Inst.Index) InnerError!WValue {
- const operand = self.resolveInst(inst.operand);
+ const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const operand = self.resolveInst(ty_op.operand);
// The index of multi_value contains the error code. To get the initial index of the payload we get
// the following index. Next, convert it to a `WValue.local`
//
@@ -1303,6 +1347,7 @@ pub const Context = struct {
}
fn genWrapErrUnionPayload(self: *Context, inst: Air.Inst.Index) InnerError!WValue {
- return self.resolveInst(inst.operand);
+ const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ return self.resolveInst(ty_op.operand);
}
};
src/link/Wasm.zig
@@ -220,7 +220,7 @@ pub fn updateFunc(self: *Wasm, module: *Module, func: *Module.Fn, air: Air, live
defer context.deinit();
// generate the 'code' section for the function declaration
- const result = context.genFunc(func) catch |err| switch (err) {
+ const result = context.genFunc() catch |err| switch (err) {
error.CodegenFail => {
decl.analysis = .codegen_failure;
try module.failed_decls.put(module.gpa, decl, context.err_msg);