Commit daf91ed8d1
Changed files (15)
src
arch
aarch64
arm
riscv64
sparc64
wasm
x86_64
Liveness
src/arch/aarch64/CodeGen.zig
@@ -287,7 +287,7 @@ const BigTomb = struct {
fn feed(bt: *BigTomb, op_ref: Air.Inst.Ref) void {
const dies = bt.lbt.feed();
- const op_index = Air.refToIndex(op_ref) orelse return;
+ const op_index = op_ref.toIndex() orelse return;
if (!dies) return;
bt.function.processDeath(op_index);
}
@@ -444,7 +444,7 @@ fn addInst(self: *Self, inst: Mir.Inst) error{OutOfMemory}!Mir.Inst.Index {
try self.mir_instructions.ensureUnusedCapacity(gpa, 1);
- const result_index = @as(Air.Inst.Index, @intCast(self.mir_instructions.len));
+ const result_index: Mir.Inst.Index = @intCast(self.mir_instructions.len);
self.mir_instructions.appendAssumeCapacity(inst);
return result_index;
}
@@ -522,7 +522,7 @@ fn gen(self: *Self) !void {
// The first AIR instructions of the main body are guaranteed
// to be the functions arguments
const inst = self.air.getMainBody()[arg_index];
- assert(self.air.instructions.items(.tag)[inst] == .arg);
+ assert(self.air.instructions.items(.tag)[@intFromEnum(inst)] == .arg);
const ty = self.typeOfIndex(inst);
@@ -668,7 +668,7 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
const old_air_bookkeeping = self.air_bookkeeping;
try self.ensureProcessDeathCapacity(Liveness.bpi);
- switch (air_tags[inst]) {
+ switch (air_tags[@intFromEnum(inst)]) {
// zig fmt: off
.add => try self.airBinOp(inst, .add),
.add_wrap => try self.airBinOp(inst, .add_wrap),
@@ -914,7 +914,7 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
if (std.debug.runtime_safety) {
if (self.air_bookkeeping < old_air_bookkeeping + 1) {
- std.debug.panic("in codegen.zig, handling of AIR instruction %{d} ('{}') did not do proper bookkeeping. Look for a missing call to finishAir.", .{ inst, air_tags[inst] });
+ std.debug.panic("in codegen.zig, handling of AIR instruction %{d} ('{}') did not do proper bookkeeping. Look for a missing call to finishAir.", .{ inst, air_tags[@intFromEnum(inst)] });
}
}
}
@@ -954,7 +954,7 @@ fn finishAir(self: *Self, inst: Air.Inst.Index, result: MCValue, operands: [Live
const dies = @as(u1, @truncate(tomb_bits)) != 0;
tomb_bits >>= 1;
if (!dies) continue;
- const op_index = Air.refToIndex(op) orelse continue;
+ const op_index = op.toIndex() orelse continue;
self.processDeath(op_index);
}
const is_used = @as(u1, @truncate(tomb_bits)) == 0;
@@ -1160,19 +1160,19 @@ fn airRetPtr(self: *Self, inst: Air.Inst.Index) !void {
}
fn airFptrunc(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airFptrunc for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airFpext(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airFpext for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airIntCast(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
if (self.liveness.isUnused(inst))
return self.finishAir(inst, .dead, .{ ty_op.operand, .none, .none });
@@ -1277,7 +1277,7 @@ fn trunc(
defer if (lock) |reg| self.register_manager.unlockReg(reg);
const dest_reg = if (maybe_inst) |inst| blk: {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
if (operand == .register and self.reuseOperand(inst, ty_op.operand, 0, operand)) {
break :blk self.registerAlias(operand_reg, dest_ty);
@@ -1299,7 +1299,7 @@ fn trunc(
}
fn airTrunc(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand = try self.resolveInst(ty_op.operand);
const operand_ty = self.typeOf(ty_op.operand);
const dest_ty = self.typeOfIndex(inst);
@@ -1312,14 +1312,14 @@ fn airTrunc(self: *Self, inst: Air.Inst.Index) !void {
}
fn airIntFromBool(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try self.resolveInst(un_op);
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else operand;
return self.finishAir(inst, result, .{ un_op, .none, .none });
}
fn airNot(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const mod = self.bin_file.options.module.?;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const operand = try self.resolveInst(ty_op.operand);
@@ -1488,8 +1488,8 @@ fn minMax(
}
fn airMinMax(self: *Self, inst: Air.Inst.Index) !void {
- const tag = self.air.instructions.items(.tag)[inst];
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const tag = self.air.instructions.items(.tag)[@intFromEnum(inst)];
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const lhs_ty = self.typeOf(bin_op.lhs);
const rhs_ty = self.typeOf(bin_op.rhs);
@@ -1506,7 +1506,7 @@ fn airMinMax(self: *Self, inst: Air.Inst.Index) !void {
}
fn airSlice(self: *Self, inst: Air.Inst.Index) !void {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const ptr = try self.resolveInst(bin_op.lhs);
@@ -1662,7 +1662,7 @@ fn allocRegs(
arg.reg.* = self.registerAlias(raw_reg, arg.ty);
} else {
const track_inst: ?Air.Inst.Index = switch (arg.bind) {
- .inst => |inst| Air.refToIndex(inst).?,
+ .inst => |inst| inst.toIndex().?,
else => null,
};
const raw_reg = try self.register_manager.allocReg(track_inst, gp);
@@ -1725,7 +1725,7 @@ fn allocRegs(
if (mcv != .register) {
if (arg.bind == .inst) {
const branch = &self.branch_stack.items[self.branch_stack.items.len - 1];
- const inst = Air.refToIndex(arg.bind.inst).?;
+ const inst = arg.bind.inst.toIndex().?;
// Overwrite the MCValue associated with this inst
branch.inst_table.putAssumeCapacity(inst, .{ .register = arg.reg.* });
@@ -2430,7 +2430,7 @@ fn ptrArithmetic(
}
fn airBinOp(self: *Self, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const lhs_ty = self.typeOf(bin_op.lhs);
const rhs_ty = self.typeOf(bin_op.rhs);
@@ -2480,7 +2480,7 @@ fn airBinOp(self: *Self, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void {
}
fn airPtrArithmetic(self: *Self, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
const lhs_ty = self.typeOf(bin_op.lhs);
const rhs_ty = self.typeOf(bin_op.rhs);
@@ -2495,26 +2495,26 @@ fn airPtrArithmetic(self: *Self, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void
}
fn airAddSat(self: *Self, inst: Air.Inst.Index) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement add_sat for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
}
fn airSubSat(self: *Self, inst: Air.Inst.Index) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement sub_sat for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
}
fn airMulSat(self: *Self, inst: Air.Inst.Index) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement mul_sat for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
}
fn airOverflow(self: *Self, inst: Air.Inst.Index) !void {
- const tag = self.air.instructions.items(.tag)[inst];
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const tag = self.air.instructions.items(.tag)[@intFromEnum(inst)];
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.Bin, ty_pl.payload).data;
const mod = self.bin_file.options.module.?;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
@@ -2641,7 +2641,7 @@ fn airOverflow(self: *Self, inst: Air.Inst.Index) !void {
}
fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.Bin, ty_pl.payload).data;
if (self.liveness.isUnused(inst)) return self.finishAir(inst, .dead, .{ extra.lhs, extra.rhs, .none });
const mod = self.bin_file.options.module.?;
@@ -2865,7 +2865,7 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
}
fn airShlWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.Bin, ty_pl.payload).data;
if (self.liveness.isUnused(inst)) return self.finishAir(inst, .dead, .{ extra.lhs, extra.rhs, .none });
const mod = self.bin_file.options.module.?;
@@ -3000,13 +3000,13 @@ fn airShlWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
}
fn airShlSat(self: *Self, inst: Air.Inst.Index) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement shl_sat for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
}
fn airOptionalPayload(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const optional_ty = self.typeOf(ty_op.operand);
const mcv = try self.resolveInst(ty_op.operand);
@@ -3042,13 +3042,13 @@ fn optionalPayload(self: *Self, inst: Air.Inst.Index, mcv: MCValue, optional_ty:
}
fn airOptionalPayloadPtr(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement .optional_payload_ptr for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airOptionalPayloadPtrSet(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement .optional_payload_ptr_set for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
@@ -3123,7 +3123,7 @@ fn errUnionErr(
}
fn airUnwrapErrErr(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const error_union_bind: ReadArg.Bind = .{ .inst = ty_op.operand };
const error_union_ty = self.typeOf(ty_op.operand);
@@ -3203,7 +3203,7 @@ fn errUnionPayload(
}
fn airUnwrapErrPayload(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const error_union_bind: ReadArg.Bind = .{ .inst = ty_op.operand };
const error_union_ty = self.typeOf(ty_op.operand);
@@ -3215,20 +3215,20 @@ fn airUnwrapErrPayload(self: *Self, inst: Air.Inst.Index) !void {
// *(E!T) -> E
fn airUnwrapErrErrPtr(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement unwrap error union error ptr for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
// *(E!T) -> *T
fn airUnwrapErrPayloadPtr(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement unwrap error union payload ptr for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airErrUnionPayloadPtrSet(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement .errunion_payload_ptr_set for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
@@ -3253,7 +3253,7 @@ fn airSaveErrReturnTraceIndex(self: *Self, inst: Air.Inst.Index) !void {
fn airWrapOptional(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
if (self.liveness.isUnused(inst)) {
return self.finishAir(inst, .dead, .{ ty_op.operand, .none, .none });
@@ -3298,9 +3298,9 @@ fn airWrapOptional(self: *Self, inst: Air.Inst.Index) !void {
/// T to E!T
fn airWrapErrUnionPayload(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
- const error_union_ty = self.air.getRefType(ty_op.ty);
+ const error_union_ty = ty_op.ty.toType();
const error_ty = error_union_ty.errorUnionSet(mod);
const payload_ty = error_union_ty.errorUnionPayload(mod);
const operand = try self.resolveInst(ty_op.operand);
@@ -3321,10 +3321,10 @@ fn airWrapErrUnionPayload(self: *Self, inst: Air.Inst.Index) !void {
/// E to E!T
fn airWrapErrUnionErr(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const mod = self.bin_file.options.module.?;
- const error_union_ty = self.air.getRefType(ty_op.ty);
+ const error_union_ty = ty_op.ty.toType();
const error_ty = error_union_ty.errorUnionSet(mod);
const payload_ty = error_union_ty.errorUnionPayload(mod);
const operand = try self.resolveInst(ty_op.operand);
@@ -3361,7 +3361,7 @@ fn slicePtr(mcv: MCValue) MCValue {
}
fn airSlicePtr(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const mcv = try self.resolveInst(ty_op.operand);
break :result slicePtr(mcv);
@@ -3370,7 +3370,7 @@ fn airSlicePtr(self: *Self, inst: Air.Inst.Index) !void {
}
fn airSliceLen(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const ptr_bits = 64;
const ptr_bytes = @divExact(ptr_bits, 8);
@@ -3394,7 +3394,7 @@ fn airSliceLen(self: *Self, inst: Air.Inst.Index) !void {
}
fn airPtrSliceLenPtr(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const ptr_bits = 64;
const ptr_bytes = @divExact(ptr_bits, 8);
@@ -3411,7 +3411,7 @@ fn airPtrSliceLenPtr(self: *Self, inst: Air.Inst.Index) !void {
}
fn airPtrSlicePtrPtr(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const mcv = try self.resolveInst(ty_op.operand);
switch (mcv) {
@@ -3427,7 +3427,7 @@ fn airPtrSlicePtrPtr(self: *Self, inst: Air.Inst.Index) !void {
fn airSliceElemVal(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const slice_ty = self.typeOf(bin_op.lhs);
const result: MCValue = if (!slice_ty.isVolatilePtr(mod) and self.liveness.isUnused(inst)) .dead else result: {
const ptr_ty = slice_ty.slicePtrFieldType(mod);
@@ -3467,7 +3467,7 @@ fn ptrElemVal(
}
fn airSliceElemPtr(self: *Self, inst: Air.Inst.Index) !void {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.Bin, ty_pl.payload).data;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const slice_mcv = try self.resolveInst(extra.lhs);
@@ -3486,14 +3486,14 @@ fn airSliceElemPtr(self: *Self, inst: Air.Inst.Index) !void {
}
fn airArrayElemVal(self: *Self, inst: Air.Inst.Index) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement array_elem_val for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
}
fn airPtrElemVal(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const ptr_ty = self.typeOf(bin_op.lhs);
const result: MCValue = if (!ptr_ty.isVolatilePtr(mod) and self.liveness.isUnused(inst)) .dead else result: {
const base_bind: ReadArg.Bind = .{ .inst = bin_op.lhs };
@@ -3505,7 +3505,7 @@ fn airPtrElemVal(self: *Self, inst: Air.Inst.Index) !void {
}
fn airPtrElemPtr(self: *Self, inst: Air.Inst.Index) !void {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.Bin, ty_pl.payload).data;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const ptr_bind: ReadArg.Bind = .{ .inst = extra.lhs };
@@ -3521,55 +3521,55 @@ fn airPtrElemPtr(self: *Self, inst: Air.Inst.Index) !void {
}
fn airSetUnionTag(self: *Self, inst: Air.Inst.Index) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
_ = bin_op;
return self.fail("TODO implement airSetUnionTag for {}", .{self.target.cpu.arch});
}
fn airGetUnionTag(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airGetUnionTag for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airClz(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airClz for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airCtz(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airCtz for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airPopcount(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airPopcount for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airAbs(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airAbs for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airByteSwap(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airByteSwap for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airBitReverse(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airBitReverse for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airUnaryMath(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const result: MCValue = if (self.liveness.isUnused(inst))
.dead
else
@@ -3609,7 +3609,7 @@ fn reuseOperand(
// That makes us responsible for doing the rest of the stuff that processDeath would have done.
const branch = &self.branch_stack.items[self.branch_stack.items.len - 1];
- branch.inst_table.putAssumeCapacity(Air.refToIndex(operand).?, .dead);
+ branch.inst_table.putAssumeCapacity(operand.toIndex().?, .dead);
return true;
}
@@ -3864,7 +3864,7 @@ fn genInlineMemsetCode(
fn airLoad(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const elem_ty = self.typeOfIndex(inst);
const elem_size = elem_ty.abiSize(mod);
const result: MCValue = result: {
@@ -4066,7 +4066,7 @@ fn airStore(self: *Self, inst: Air.Inst.Index, safety: bool) !void {
} else {
// TODO if the value is undef, don't lower this instruction
}
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const ptr = try self.resolveInst(bin_op.lhs);
const value = try self.resolveInst(bin_op.rhs);
const ptr_ty = self.typeOf(bin_op.lhs);
@@ -4078,14 +4078,14 @@ fn airStore(self: *Self, inst: Air.Inst.Index, safety: bool) !void {
}
fn airStructFieldPtr(self: *Self, inst: Air.Inst.Index) !void {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.StructField, ty_pl.payload).data;
const result = try self.structFieldPtr(inst, extra.struct_operand, extra.field_index);
return self.finishAir(inst, result, .{ extra.struct_operand, .none, .none });
}
fn airStructFieldPtrIndex(self: *Self, inst: Air.Inst.Index, index: u8) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result = try self.structFieldPtr(inst, ty_op.operand, index);
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
@@ -4112,7 +4112,7 @@ fn structFieldPtr(self: *Self, inst: Air.Inst.Index, operand: Air.Inst.Ref, inde
}
fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) !void {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.StructField, ty_pl.payload).data;
const operand = extra.struct_operand;
const index = extra.field_index;
@@ -4168,11 +4168,11 @@ fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) !void {
fn airFieldParentPtr(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.FieldParentPtr, ty_pl.payload).data;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const field_ptr = try self.resolveInst(extra.field_ptr);
- const struct_ty = self.air.getRefType(ty_pl.ty).childType(mod);
+ const struct_ty = ty_pl.ty.toType().childType(mod);
const struct_field_offset = @as(u32, @intCast(struct_ty.structFieldOffset(extra.field_index, mod)));
switch (field_ptr) {
.ptr_stack_offset => |off| {
@@ -4197,8 +4197,8 @@ fn airArg(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
const ty = self.typeOfIndex(inst);
- const tag = self.air.instructions.items(.tag)[inst];
- const src_index = self.air.instructions.items(.data)[inst].arg.src_index;
+ const tag = self.air.instructions.items(.tag)[@intFromEnum(inst)];
+ const src_index = self.air.instructions.items(.data)[@intFromEnum(inst)].arg.src_index;
const name = mod.getParamName(self.func_index, src_index);
try self.dbg_info_relocs.append(self.gpa, .{
@@ -4245,7 +4245,7 @@ fn airFence(self: *Self) !void {
fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier) !void {
if (modifier == .always_tail) return self.fail("TODO implement tail calls for aarch64", .{});
- const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const callee = pl_op.operand;
const extra = self.air.extraData(Air.Call, pl_op.payload);
const args = @as([]const Air.Inst.Ref, @ptrCast(self.air.extra[extra.end..][0..extra.data.args_len]));
@@ -4423,7 +4423,7 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier
fn airRet(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try self.resolveInst(un_op);
const ret_ty = self.fn_type.fnReturnType(mod);
@@ -4455,7 +4455,7 @@ fn airRet(self: *Self, inst: Air.Inst.Index) !void {
fn airRetLoad(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const ptr = try self.resolveInst(un_op);
const ptr_ty = self.typeOf(un_op);
const ret_ty = self.fn_type.fnReturnType(mod);
@@ -4476,8 +4476,8 @@ fn airRetLoad(self: *Self, inst: Air.Inst.Index) !void {
// here. Else we need to load the result from the location
// pointed to by the operand and store it to the result
// location.
- const op_inst = Air.refToIndex(un_op).?;
- if (self.air.instructions.items(.tag)[op_inst] != .ret_ptr) {
+ const op_inst = un_op.toIndex().?;
+ if (self.air.instructions.items(.tag)[@intFromEnum(op_inst)] != .ret_ptr) {
const abi_size = @as(u32, @intCast(ret_ty.abiSize(mod)));
const abi_align = ret_ty.abiAlignment(mod);
@@ -4497,7 +4497,7 @@ fn airRetLoad(self: *Self, inst: Air.Inst.Index) !void {
}
fn airCmp(self: *Self, inst: Air.Inst.Index, op: math.CompareOperator) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const lhs_ty = self.typeOf(bin_op.lhs);
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else blk: {
@@ -4599,7 +4599,7 @@ fn airCmpVector(self: *Self, inst: Air.Inst.Index) !void {
}
fn airCmpLtErrorsLen(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try self.resolveInst(un_op);
_ = operand;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airCmpLtErrorsLen for {}", .{self.target.cpu.arch});
@@ -4607,7 +4607,7 @@ fn airCmpLtErrorsLen(self: *Self, inst: Air.Inst.Index) !void {
}
fn airDbgStmt(self: *Self, inst: Air.Inst.Index) !void {
- const dbg_stmt = self.air.instructions.items(.data)[inst].dbg_stmt;
+ const dbg_stmt = self.air.instructions.items(.data)[@intFromEnum(inst)].dbg_stmt;
_ = try self.addInst(.{
.tag = .dbg_line,
@@ -4621,7 +4621,7 @@ fn airDbgStmt(self: *Self, inst: Air.Inst.Index) !void {
}
fn airDbgInline(self: *Self, inst: Air.Inst.Index) !void {
- const ty_fn = self.air.instructions.items(.data)[inst].ty_fn;
+ const ty_fn = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_fn;
const mod = self.bin_file.options.module.?;
const func = mod.funcInfo(ty_fn.func);
// TODO emit debug info for function change
@@ -4635,9 +4635,9 @@ fn airDbgBlock(self: *Self, inst: Air.Inst.Index) !void {
}
fn airDbgVar(self: *Self, inst: Air.Inst.Index) !void {
- const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const operand = pl_op.operand;
- const tag = self.air.instructions.items(.tag)[inst];
+ const tag = self.air.instructions.items(.tag)[@intFromEnum(inst)];
const ty = self.typeOf(operand);
const mcv = try self.resolveInst(operand);
const name = self.air.nullTerminatedString(pl_op.payload);
@@ -4686,11 +4686,11 @@ fn condBr(self: *Self, condition: MCValue) !Mir.Inst.Index {
}
fn airCondBr(self: *Self, inst: Air.Inst.Index) !void {
- const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const cond = try 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 then_body: []const Air.Inst.Index = @ptrCast(self.air.extra[extra.end..][0..extra.data.then_body_len]);
+ const else_body: []const Air.Inst.Index = @ptrCast(self.air.extra[extra.end + then_body.len ..][0..extra.data.else_body_len]);
const liveness_condbr = self.liveness.getCondBr(inst);
const reloc = try self.condBr(cond);
@@ -4699,7 +4699,7 @@ fn airCondBr(self: *Self, inst: Air.Inst.Index) !void {
// that death now instead of later as this has an effect on
// whether it needs to be spilled in the branches
if (self.liveness.operandDies(inst, 0)) {
- if (Air.refToIndex(pl_op.operand)) |op_index| {
+ if (pl_op.operand.toIndex()) |op_index| {
self.processDeath(op_index);
}
}
@@ -4917,7 +4917,7 @@ fn isNonErr(
}
fn airIsNull(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const operand = try self.resolveInst(un_op);
const operand_ty = self.typeOf(un_op);
@@ -4929,7 +4929,7 @@ fn airIsNull(self: *Self, inst: Air.Inst.Index) !void {
fn airIsNullPtr(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const operand_ptr = try self.resolveInst(un_op);
const ptr_ty = self.typeOf(un_op);
@@ -4944,7 +4944,7 @@ fn airIsNullPtr(self: *Self, inst: Air.Inst.Index) !void {
}
fn airIsNonNull(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const operand = try self.resolveInst(un_op);
const operand_ty = self.typeOf(un_op);
@@ -4956,7 +4956,7 @@ fn airIsNonNull(self: *Self, inst: Air.Inst.Index) !void {
fn airIsNonNullPtr(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const operand_ptr = try self.resolveInst(un_op);
const ptr_ty = self.typeOf(un_op);
@@ -4971,7 +4971,7 @@ fn airIsNonNullPtr(self: *Self, inst: Air.Inst.Index) !void {
}
fn airIsErr(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const error_union_bind: ReadArg.Bind = .{ .inst = un_op };
const error_union_ty = self.typeOf(un_op);
@@ -4983,7 +4983,7 @@ fn airIsErr(self: *Self, inst: Air.Inst.Index) !void {
fn airIsErrPtr(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const operand_ptr = try self.resolveInst(un_op);
const ptr_ty = self.typeOf(un_op);
@@ -4998,7 +4998,7 @@ fn airIsErrPtr(self: *Self, inst: Air.Inst.Index) !void {
}
fn airIsNonErr(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const error_union_bind: ReadArg.Bind = .{ .inst = un_op };
const error_union_ty = self.typeOf(un_op);
@@ -5010,7 +5010,7 @@ fn airIsNonErr(self: *Self, inst: Air.Inst.Index) !void {
fn airIsNonErrPtr(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const operand_ptr = try self.resolveInst(un_op);
const ptr_ty = self.typeOf(un_op);
@@ -5026,9 +5026,9 @@ fn airIsNonErrPtr(self: *Self, inst: Air.Inst.Index) !void {
fn airLoop(self: *Self, inst: Air.Inst.Index) !void {
// A loop is a setup to be able to jump back to the beginning.
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(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];
+ const body: []const Air.Inst.Index = @ptrCast(self.air.extra[loop.end..][0..loop.data.body_len]);
const start_index = @as(u32, @intCast(self.mir_instructions.len));
try self.genBody(body);
@@ -5058,9 +5058,9 @@ fn airBlock(self: *Self, inst: Air.Inst.Index) !void {
});
defer self.blocks.getPtr(inst).?.relocs.deinit(self.gpa);
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.Block, ty_pl.payload);
- const body = self.air.extra[extra.end..][0..extra.data.body_len];
+ const body: []const Air.Inst.Index = @ptrCast(self.air.extra[extra.end..][0..extra.data.body_len]);
try self.genBody(body);
// relocations for `br` instructions
@@ -5080,7 +5080,7 @@ fn airBlock(self: *Self, inst: Air.Inst.Index) !void {
}
fn airSwitch(self: *Self, inst: Air.Inst.Index) !void {
- const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const condition_ty = self.typeOf(pl_op.operand);
const switch_br = self.air.extraData(Air.SwitchBr, pl_op.payload);
const liveness = try self.liveness.getSwitchBr(
@@ -5096,7 +5096,7 @@ fn airSwitch(self: *Self, inst: Air.Inst.Index) !void {
const case = self.air.extraData(Air.SwitchBr.Case, extra_index);
const items = @as([]const Air.Inst.Ref, @ptrCast(self.air.extra[case.end..][0..case.data.items_len]));
assert(items.len > 0);
- const case_body = self.air.extra[case.end + items.len ..][0..case.data.body_len];
+ const case_body: []const Air.Inst.Index = @ptrCast(self.air.extra[case.end + items.len ..][0..case.data.body_len]);
extra_index = case.end + items.len + case_body.len;
// For every item, we compare it to condition and branch into
@@ -5167,7 +5167,7 @@ fn airSwitch(self: *Self, inst: Air.Inst.Index) !void {
}
if (switch_br.data.else_body_len > 0) {
- const else_body = self.air.extra[extra_index..][0..switch_br.data.else_body_len];
+ const else_body: []const Air.Inst.Index = @ptrCast(self.air.extra[extra_index..][0..switch_br.data.else_body_len]);
// Capture the state of register and stack allocation state so that we can revert to it.
const parent_next_stack_offset = self.next_stack_offset;
@@ -5212,15 +5212,15 @@ fn airSwitch(self: *Self, inst: Air.Inst.Index) !void {
fn performReloc(self: *Self, inst: Mir.Inst.Index) !void {
const tag = self.mir_instructions.items(.tag)[inst];
switch (tag) {
- .cbz => self.mir_instructions.items(.data)[inst].r_inst.inst = @as(Mir.Inst.Index, @intCast(self.mir_instructions.len)),
- .b_cond => self.mir_instructions.items(.data)[inst].inst_cond.inst = @as(Mir.Inst.Index, @intCast(self.mir_instructions.len)),
- .b => self.mir_instructions.items(.data)[inst].inst = @as(Mir.Inst.Index, @intCast(self.mir_instructions.len)),
+ .cbz => self.mir_instructions.items(.data)[inst].r_inst.inst = @intCast(self.mir_instructions.len),
+ .b_cond => self.mir_instructions.items(.data)[inst].inst_cond.inst = @intCast(self.mir_instructions.len),
+ .b => self.mir_instructions.items(.data)[inst].inst = @intCast(self.mir_instructions.len),
else => unreachable,
}
}
fn airBr(self: *Self, inst: Air.Inst.Index) !void {
- const branch = self.air.instructions.items(.data)[inst].br;
+ const branch = self.air.instructions.items(.data)[@intFromEnum(inst)].br;
try self.br(branch.block_inst, branch.operand);
return self.finishAir(inst, .dead, .{ branch.operand, .none, .none });
}
@@ -5263,7 +5263,7 @@ fn brVoid(self: *Self, block: Air.Inst.Index) !void {
}
fn airAsm(self: *Self, inst: Air.Inst.Index) !void {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.Asm, ty_pl.payload);
const is_volatile = @as(u1, @truncate(extra.data.flags >> 31)) != 0;
const clobbers_len = @as(u31, @truncate(extra.data.flags));
@@ -5907,13 +5907,13 @@ fn genSetStackArgument(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) I
}
fn airIntFromPtr(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const result = try self.resolveInst(un_op);
return self.finishAir(inst, result, .{ un_op, .none, .none });
}
fn airBitCast(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result = if (self.liveness.isUnused(inst)) .dead else result: {
const operand = try self.resolveInst(ty_op.operand);
if (self.reuseOperand(inst, ty_op.operand, 0, operand)) break :result operand;
@@ -5935,7 +5935,7 @@ fn airBitCast(self: *Self, inst: Air.Inst.Index) !void {
fn airArrayToSlice(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const ptr_ty = self.typeOf(ty_op.operand);
const ptr = try self.resolveInst(ty_op.operand);
@@ -5951,7 +5951,7 @@ fn airArrayToSlice(self: *Self, inst: Air.Inst.Index) !void {
}
fn airFloatFromInt(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airFloatFromInt for {}", .{
self.target.cpu.arch,
});
@@ -5959,7 +5959,7 @@ fn airFloatFromInt(self: *Self, inst: Air.Inst.Index) !void {
}
fn airIntFromFloat(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airIntFromFloat for {}", .{
self.target.cpu.arch,
});
@@ -5967,7 +5967,7 @@ fn airIntFromFloat(self: *Self, inst: Air.Inst.Index) !void {
}
fn airCmpxchg(self: *Self, inst: Air.Inst.Index) !void {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.Block, ty_pl.payload);
_ = extra;
@@ -6008,7 +6008,7 @@ fn airMemcpy(self: *Self, inst: Air.Inst.Index) !void {
}
fn airTagName(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try self.resolveInst(un_op);
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else {
_ = operand;
@@ -6018,7 +6018,7 @@ fn airTagName(self: *Self, inst: Air.Inst.Index) !void {
}
fn airErrorName(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try self.resolveInst(un_op);
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else {
_ = operand;
@@ -6028,27 +6028,27 @@ fn airErrorName(self: *Self, inst: Air.Inst.Index) !void {
}
fn airSplat(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airSplat for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airSelect(self: *Self, inst: Air.Inst.Index) !void {
- const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const extra = self.air.extraData(Air.Bin, pl_op.payload).data;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airSelect for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ pl_op.operand, extra.lhs, extra.rhs });
}
fn airShuffle(self: *Self, inst: Air.Inst.Index) !void {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.Shuffle, ty_pl.payload).data;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airShuffle for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ extra.a, extra.b, .none });
}
fn airReduce(self: *Self, inst: Air.Inst.Index) !void {
- const reduce = self.air.instructions.items(.data)[inst].reduce;
+ const reduce = self.air.instructions.items(.data)[@intFromEnum(inst)].reduce;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airReduce for aarch64", .{});
return self.finishAir(inst, result, .{ reduce.operand, .none, .none });
}
@@ -6057,7 +6057,7 @@ fn airAggregateInit(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
const vector_ty = self.typeOfIndex(inst);
const len = vector_ty.vectorLen(mod);
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const elements = @as([]const Air.Inst.Ref, @ptrCast(self.air.extra[ty_pl.payload..][0..len]));
const result: MCValue = res: {
if (self.liveness.isUnused(inst)) break :res MCValue.dead;
@@ -6077,19 +6077,19 @@ fn airAggregateInit(self: *Self, inst: Air.Inst.Index) !void {
}
fn airUnionInit(self: *Self, inst: Air.Inst.Index) !void {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.UnionInit, ty_pl.payload).data;
_ = extra;
return self.fail("TODO implement airUnionInit for aarch64", .{});
}
fn airPrefetch(self: *Self, inst: Air.Inst.Index) !void {
- const prefetch = self.air.instructions.items(.data)[inst].prefetch;
+ const prefetch = self.air.instructions.items(.data)[@intFromEnum(inst)].prefetch;
return self.finishAir(inst, MCValue.dead, .{ prefetch.ptr, .none, .none });
}
fn airMulAdd(self: *Self, inst: Air.Inst.Index) !void {
- const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const extra = self.air.extraData(Air.Bin, pl_op.payload).data;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else {
return self.fail("TODO implement airMulAdd for aarch64", .{});
@@ -6099,9 +6099,9 @@ fn airMulAdd(self: *Self, inst: Air.Inst.Index) !void {
fn airTry(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const extra = self.air.extraData(Air.Try, pl_op.payload);
- const body = self.air.extra[extra.end..][0..extra.data.body_len];
+ const body: []const Air.Inst.Index = @ptrCast(self.air.extra[extra.end..][0..extra.data.body_len]);
const result: MCValue = result: {
const error_union_bind: ReadArg.Bind = .{ .inst = pl_op.operand };
const error_union_ty = self.typeOf(pl_op.operand);
@@ -6126,7 +6126,7 @@ fn airTry(self: *Self, inst: Air.Inst.Index) !void {
}
fn airTryPtr(self: *Self, inst: Air.Inst.Index) !void {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.TryPtr, ty_pl.payload);
const body = self.air.extra[extra.end..][0..extra.data.body_len];
_ = body;
@@ -6142,7 +6142,7 @@ fn resolveInst(self: *Self, inst: Air.Inst.Ref) InnerError!MCValue {
if (!inst_ty.hasRuntimeBitsIgnoreComptime(mod) and !inst_ty.isError(mod))
return MCValue{ .none = {} };
- const inst_index = Air.refToIndex(inst) orelse return self.genTypedValue(.{
+ const inst_index = inst.toIndex() orelse return self.genTypedValue(.{
.ty = inst_ty,
.val = (try self.air.value(inst, mod)).?,
});
src/arch/arm/CodeGen.zig
@@ -200,7 +200,7 @@ const BigTomb = struct {
fn feed(bt: *BigTomb, op_ref: Air.Inst.Ref) void {
const dies = bt.lbt.feed();
- const op_index = Air.refToIndex(op_ref) orelse return;
+ const op_index = op_ref.toIndex() orelse return;
if (!dies) return;
bt.function.processDeath(op_index);
}
@@ -450,7 +450,7 @@ fn addInst(self: *Self, inst: Mir.Inst) error{OutOfMemory}!Mir.Inst.Index {
try self.mir_instructions.ensureUnusedCapacity(gpa, 1);
- const result_index = @as(Air.Inst.Index, @intCast(self.mir_instructions.len));
+ const result_index: Mir.Inst.Index = @intCast(self.mir_instructions.len);
self.mir_instructions.appendAssumeCapacity(inst);
return result_index;
}
@@ -470,11 +470,11 @@ pub fn addExtra(self: *Self, extra: anytype) Allocator.Error!u32 {
pub fn addExtraAssumeCapacity(self: *Self, extra: anytype) u32 {
const fields = std.meta.fields(@TypeOf(extra));
- const result = @as(u32, @intCast(self.mir_extra.items.len));
+ const result: u32 = @intCast(self.mir_extra.items.len);
inline for (fields) |field| {
self.mir_extra.appendAssumeCapacity(switch (field.type) {
u32 => @field(extra, field.name),
- i32 => @as(u32, @bitCast(@field(extra, field.name))),
+ i32 => @bitCast(@field(extra, field.name)),
else => @compileError("bad field type"),
});
}
@@ -522,11 +522,11 @@ fn gen(self: *Self) !void {
// The first AIR instructions of the main body are guaranteed
// to be the functions arguments
const inst = self.air.getMainBody()[arg_index];
- assert(self.air.instructions.items(.tag)[inst] == .arg);
+ assert(self.air.instructions.items(.tag)[@intFromEnum(inst)] == .arg);
const ty = self.typeOfIndex(inst);
- const abi_size = @as(u32, @intCast(ty.abiSize(mod)));
+ const abi_size: u32 = @intCast(ty.abiSize(mod));
const abi_align = ty.abiAlignment(mod);
const stack_offset = try self.allocMem(abi_size, abi_align, inst);
try self.genSetStack(ty, stack_offset, MCValue{ .register = reg });
@@ -592,7 +592,7 @@ fn gen(self: *Self) !void {
for (self.exitlude_jump_relocs.items) |jmp_reloc| {
self.mir_instructions.set(jmp_reloc, .{
.tag = .b,
- .data = .{ .inst = @as(u32, @intCast(self.mir_instructions.len)) },
+ .data = .{ .inst = @intCast(self.mir_instructions.len) },
});
}
@@ -654,7 +654,7 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
const old_air_bookkeeping = self.air_bookkeeping;
try self.ensureProcessDeathCapacity(Liveness.bpi);
- switch (air_tags[inst]) {
+ switch (air_tags[@intFromEnum(inst)]) {
// zig fmt: off
.add, => try self.airBinOp(inst, .add),
.add_wrap => try self.airBinOp(inst, .add_wrap),
@@ -900,7 +900,7 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
if (std.debug.runtime_safety) {
if (self.air_bookkeeping < old_air_bookkeeping + 1) {
- std.debug.panic("in codegen.zig, handling of AIR instruction %{d} ('{}') did not do proper bookkeeping. Look for a missing call to finishAir.", .{ inst, air_tags[inst] });
+ std.debug.panic("in codegen.zig, handling of AIR instruction %{d} ('{}') did not do proper bookkeeping. Look for a missing call to finishAir.", .{ inst, air_tags[@intFromEnum(inst)] });
}
}
}
@@ -942,7 +942,7 @@ fn finishAir(self: *Self, inst: Air.Inst.Index, result: MCValue, operands: [Live
const dies = @as(u1, @truncate(tomb_bits)) != 0;
tomb_bits >>= 1;
if (!dies) continue;
- const op_index = Air.refToIndex(op) orelse continue;
+ const op_index = op.toIndex() orelse continue;
self.processDeath(op_index);
}
const is_used = @as(u1, @truncate(tomb_bits)) == 0;
@@ -1018,7 +1018,7 @@ fn allocMemPtr(self: *Self, inst: Air.Inst.Index) !u32 {
// return the stack offset 0. Stack offset 0 will be where all
// zero-sized stack allocations live as non-zero-sized
// allocations will always have an offset > 0.
- return @as(u32, 0);
+ return 0;
}
const abi_size = math.cast(u32, elem_ty.abiSize(mod)) orelse {
@@ -1139,20 +1139,20 @@ fn airRetPtr(self: *Self, inst: Air.Inst.Index) !void {
}
fn airFptrunc(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airFptrunc for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airFpext(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airFpext for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airIntCast(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
if (self.liveness.isUnused(inst))
return self.finishAir(inst, .dead, .{ ty_op.operand, .none, .none });
@@ -1204,7 +1204,7 @@ fn truncRegister(
.rd = dest_reg,
.rn = operand_reg,
.lsb = 0,
- .width = @as(u6, @intCast(int_bits)),
+ .width = @intCast(int_bits),
} },
});
}
@@ -1260,7 +1260,7 @@ fn trunc(
}
fn airTrunc(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand_bind: ReadArg.Bind = .{ .inst = ty_op.operand };
const operand_ty = self.typeOf(ty_op.operand);
const dest_ty = self.typeOfIndex(inst);
@@ -1273,14 +1273,14 @@ fn airTrunc(self: *Self, inst: Air.Inst.Index) !void {
}
fn airIntFromBool(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try self.resolveInst(un_op);
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else operand;
return self.finishAir(inst, result, .{ un_op, .none, .none });
}
fn airNot(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const mod = self.bin_file.options.module.?;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const operand_bind: ReadArg.Bind = .{ .inst = ty_op.operand };
@@ -1465,8 +1465,8 @@ fn minMax(
}
fn airMinMax(self: *Self, inst: Air.Inst.Index) !void {
- const tag = self.air.instructions.items(.tag)[inst];
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const tag = self.air.instructions.items(.tag)[@intFromEnum(inst)];
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const lhs_ty = self.typeOf(bin_op.lhs);
const rhs_ty = self.typeOf(bin_op.rhs);
@@ -1483,7 +1483,7 @@ fn airMinMax(self: *Self, inst: Air.Inst.Index) !void {
}
fn airSlice(self: *Self, inst: Air.Inst.Index) !void {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const ptr = try self.resolveInst(bin_op.lhs);
@@ -1500,7 +1500,7 @@ fn airSlice(self: *Self, inst: Air.Inst.Index) !void {
}
fn airBinOp(self: *Self, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const lhs_ty = self.typeOf(bin_op.lhs);
const rhs_ty = self.typeOf(bin_op.rhs);
@@ -1550,7 +1550,7 @@ fn airBinOp(self: *Self, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void {
}
fn airPtrArithmetic(self: *Self, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
const lhs_ty = self.typeOf(bin_op.lhs);
const rhs_ty = self.typeOf(bin_op.rhs);
@@ -1565,26 +1565,26 @@ fn airPtrArithmetic(self: *Self, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void
}
fn airAddSat(self: *Self, inst: Air.Inst.Index) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement add_sat for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
}
fn airSubSat(self: *Self, inst: Air.Inst.Index) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement sub_sat for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
}
fn airMulSat(self: *Self, inst: Air.Inst.Index) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement mul_sat for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
}
fn airOverflow(self: *Self, inst: Air.Inst.Index) !void {
- const tag = self.air.instructions.items(.tag)[inst];
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const tag = self.air.instructions.items(.tag)[@intFromEnum(inst)];
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.Bin, ty_pl.payload).data;
const mod = self.bin_file.options.module.?;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
@@ -1594,9 +1594,9 @@ fn airOverflow(self: *Self, inst: Air.Inst.Index) !void {
const rhs_ty = self.typeOf(extra.rhs);
const tuple_ty = self.typeOfIndex(inst);
- const tuple_size = @as(u32, @intCast(tuple_ty.abiSize(mod)));
+ const tuple_size: u32 = @intCast(tuple_ty.abiSize(mod));
const tuple_align = tuple_ty.abiAlignment(mod);
- const overflow_bit_offset = @as(u32, @intCast(tuple_ty.structFieldOffset(1, mod)));
+ const overflow_bit_offset: u32 = @intCast(tuple_ty.structFieldOffset(1, mod));
switch (lhs_ty.zigTypeTag(mod)) {
.Vector => return self.fail("TODO implement add_with_overflow/sub_with_overflow for vectors", .{}),
@@ -1696,7 +1696,7 @@ fn airOverflow(self: *Self, inst: Air.Inst.Index) !void {
}
fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.Bin, ty_pl.payload).data;
if (self.liveness.isUnused(inst)) return self.finishAir(inst, .dead, .{ extra.lhs, extra.rhs, .none });
const mod = self.bin_file.options.module.?;
@@ -1707,9 +1707,9 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
const rhs_ty = self.typeOf(extra.rhs);
const tuple_ty = self.typeOfIndex(inst);
- const tuple_size = @as(u32, @intCast(tuple_ty.abiSize(mod)));
+ const tuple_size: u32 = @intCast(tuple_ty.abiSize(mod));
const tuple_align = tuple_ty.abiAlignment(mod);
- const overflow_bit_offset = @as(u32, @intCast(tuple_ty.structFieldOffset(1, mod)));
+ const overflow_bit_offset: u32 = @intCast(tuple_ty.structFieldOffset(1, mod));
switch (lhs_ty.zigTypeTag(mod)) {
.Vector => return self.fail("TODO implement mul_with_overflow for vectors", .{}),
@@ -1860,7 +1860,7 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
}
fn airShlWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.Bin, ty_pl.payload).data;
if (self.liveness.isUnused(inst)) return self.finishAir(inst, .dead, .{ extra.lhs, extra.rhs, .none });
const mod = self.bin_file.options.module.?;
@@ -1869,9 +1869,9 @@ fn airShlWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
const rhs_ty = self.typeOf(extra.rhs);
const tuple_ty = self.typeOfIndex(inst);
- const tuple_size = @as(u32, @intCast(tuple_ty.abiSize(mod)));
+ const tuple_size: u32 = @intCast(tuple_ty.abiSize(mod));
const tuple_align = tuple_ty.abiAlignment(mod);
- const overflow_bit_offset = @as(u32, @intCast(tuple_ty.structFieldOffset(1, mod)));
+ const overflow_bit_offset: u32 = @intCast(tuple_ty.structFieldOffset(1, mod));
switch (lhs_ty.zigTypeTag(mod)) {
.Vector => return self.fail("TODO implement shl_with_overflow for vectors", .{}),
@@ -1918,7 +1918,7 @@ fn airShlWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
.data = .{ .rr_shift = .{
.rd = dest_reg,
.rm = lhs_reg,
- .shift_amount = Instruction.ShiftAmount.imm(@as(u5, @intCast(rhs_mcv.immediate))),
+ .shift_amount = Instruction.ShiftAmount.imm(@intCast(rhs_mcv.immediate)),
} },
});
@@ -1930,7 +1930,7 @@ fn airShlWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
.data = .{ .rr_shift = .{
.rd = reconstructed_reg,
.rm = dest_reg,
- .shift_amount = Instruction.ShiftAmount.imm(@as(u5, @intCast(rhs_mcv.immediate))),
+ .shift_amount = Instruction.ShiftAmount.imm(@intCast(rhs_mcv.immediate)),
} },
});
} else {
@@ -1995,35 +1995,35 @@ fn airShlWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
}
fn airShlSat(self: *Self, inst: Air.Inst.Index) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement shl_sat for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
}
fn airOptionalPayload(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement .optional_payload for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airOptionalPayloadPtr(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement .optional_payload_ptr for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airOptionalPayloadPtrSet(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement .optional_payload_ptr_set for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airWrapOptional(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const optional_ty = self.typeOfIndex(inst);
- const abi_size = @as(u32, @intCast(optional_ty.abiSize(mod)));
+ const abi_size: u32 = @intCast(optional_ty.abiSize(mod));
// Optional with a zero-bit payload type is just a boolean true
if (abi_size == 1) {
@@ -2052,7 +2052,7 @@ fn errUnionErr(
return try error_union_bind.resolveToMcv(self);
}
- const err_offset = @as(u32, @intCast(errUnionErrorOffset(payload_ty, mod)));
+ const err_offset: u32 = @intCast(errUnionErrorOffset(payload_ty, mod));
switch (try error_union_bind.resolveToMcv(self)) {
.register => {
var operand_reg: Register = undefined;
@@ -2074,15 +2074,15 @@ fn errUnionErr(
);
const err_bit_offset = err_offset * 8;
- const err_bit_size = @as(u32, @intCast(err_ty.abiSize(mod))) * 8;
+ const err_bit_size: u32 = @intCast(err_ty.abiSize(mod) * 8);
_ = try self.addInst(.{
.tag = .ubfx, // errors are unsigned integers
.data = .{ .rr_lsb_width = .{
.rd = dest_reg,
.rn = operand_reg,
- .lsb = @as(u5, @intCast(err_bit_offset)),
- .width = @as(u6, @intCast(err_bit_size)),
+ .lsb = @intCast(err_bit_offset),
+ .width = @intCast(err_bit_size),
} },
});
@@ -2102,7 +2102,7 @@ fn errUnionErr(
}
fn airUnwrapErrErr(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const error_union_bind: ReadArg.Bind = .{ .inst = ty_op.operand };
const error_union_ty = self.typeOf(ty_op.operand);
@@ -2129,7 +2129,7 @@ fn errUnionPayload(
return MCValue.none;
}
- const payload_offset = @as(u32, @intCast(errUnionPayloadOffset(payload_ty, mod)));
+ const payload_offset: u32 = @intCast(errUnionPayloadOffset(payload_ty, mod));
switch (try error_union_bind.resolveToMcv(self)) {
.register => {
var operand_reg: Register = undefined;
@@ -2151,15 +2151,15 @@ fn errUnionPayload(
);
const payload_bit_offset = payload_offset * 8;
- const payload_bit_size = @as(u32, @intCast(payload_ty.abiSize(mod))) * 8;
+ const payload_bit_size: u32 = @intCast(payload_ty.abiSize(mod) * 8);
_ = try self.addInst(.{
.tag = if (payload_ty.isSignedInt(mod)) Mir.Inst.Tag.sbfx else .ubfx,
.data = .{ .rr_lsb_width = .{
.rd = dest_reg,
.rn = operand_reg,
- .lsb = @as(u5, @intCast(payload_bit_offset)),
- .width = @as(u6, @intCast(payload_bit_size)),
+ .lsb = @intCast(payload_bit_offset),
+ .width = @intCast(payload_bit_size),
} },
});
@@ -2179,7 +2179,7 @@ fn errUnionPayload(
}
fn airUnwrapErrPayload(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const error_union_bind: ReadArg.Bind = .{ .inst = ty_op.operand };
const error_union_ty = self.typeOf(ty_op.operand);
@@ -2191,20 +2191,20 @@ fn airUnwrapErrPayload(self: *Self, inst: Air.Inst.Index) !void {
// *(E!T) -> E
fn airUnwrapErrErrPtr(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement unwrap error union error ptr for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
// *(E!T) -> *T
fn airUnwrapErrPayloadPtr(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement unwrap error union payload ptr for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airErrUnionPayloadPtrSet(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement .errunion_payload_ptr_set for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
@@ -2230,17 +2230,17 @@ fn airSaveErrReturnTraceIndex(self: *Self, inst: Air.Inst.Index) !void {
/// T to E!T
fn airWrapErrUnionPayload(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
- const error_union_ty = self.air.getRefType(ty_op.ty);
+ const error_union_ty = ty_op.ty.toType();
const error_ty = error_union_ty.errorUnionSet(mod);
const payload_ty = error_union_ty.errorUnionPayload(mod);
const operand = try self.resolveInst(ty_op.operand);
if (!payload_ty.hasRuntimeBitsIgnoreComptime(mod)) break :result operand;
- const abi_size = @as(u32, @intCast(error_union_ty.abiSize(mod)));
+ const abi_size: u32 = @intCast(error_union_ty.abiSize(mod));
const abi_align = error_union_ty.abiAlignment(mod);
- const stack_offset = @as(u32, @intCast(try self.allocMem(abi_size, abi_align, inst)));
+ const stack_offset: u32 = @intCast(try self.allocMem(abi_size, abi_align, inst));
const payload_off = errUnionPayloadOffset(payload_ty, mod);
const err_off = errUnionErrorOffset(payload_ty, mod);
try self.genSetStack(payload_ty, stack_offset - @as(u32, @intCast(payload_off)), operand);
@@ -2254,17 +2254,17 @@ fn airWrapErrUnionPayload(self: *Self, inst: Air.Inst.Index) !void {
/// E to E!T
fn airWrapErrUnionErr(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
- const error_union_ty = self.air.getRefType(ty_op.ty);
+ const error_union_ty = ty_op.ty.toType();
const error_ty = error_union_ty.errorUnionSet(mod);
const payload_ty = error_union_ty.errorUnionPayload(mod);
const operand = try self.resolveInst(ty_op.operand);
if (!payload_ty.hasRuntimeBitsIgnoreComptime(mod)) break :result operand;
- const abi_size = @as(u32, @intCast(error_union_ty.abiSize(mod)));
+ const abi_size: u32 = @intCast(error_union_ty.abiSize(mod));
const abi_align = error_union_ty.abiAlignment(mod);
- const stack_offset = @as(u32, @intCast(try self.allocMem(abi_size, abi_align, inst)));
+ const stack_offset: u32 = @intCast(try self.allocMem(abi_size, abi_align, inst));
const payload_off = errUnionPayloadOffset(payload_ty, mod);
const err_off = errUnionErrorOffset(payload_ty, mod);
try self.genSetStack(error_ty, stack_offset - @as(u32, @intCast(err_off)), operand);
@@ -2293,7 +2293,7 @@ fn slicePtr(mcv: MCValue) MCValue {
}
fn airSlicePtr(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const mcv = try self.resolveInst(ty_op.operand);
break :result slicePtr(mcv);
@@ -2302,7 +2302,7 @@ fn airSlicePtr(self: *Self, inst: Air.Inst.Index) !void {
}
fn airSliceLen(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const mcv = try self.resolveInst(ty_op.operand);
switch (mcv) {
@@ -2323,7 +2323,7 @@ fn airSliceLen(self: *Self, inst: Air.Inst.Index) !void {
}
fn airPtrSliceLenPtr(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const mcv = try self.resolveInst(ty_op.operand);
switch (mcv) {
@@ -2343,7 +2343,7 @@ fn airPtrSliceLenPtr(self: *Self, inst: Air.Inst.Index) !void {
}
fn airPtrSlicePtrPtr(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const mcv = try self.resolveInst(ty_op.operand);
switch (mcv) {
@@ -2372,7 +2372,7 @@ fn ptrElemVal(
) !MCValue {
const mod = self.bin_file.options.module.?;
const elem_ty = ptr_ty.childType(mod);
- const elem_size = @as(u32, @intCast(elem_ty.abiSize(mod)));
+ const elem_size: u32 = @intCast(elem_ty.abiSize(mod));
switch (elem_size) {
1, 4 => {
@@ -2430,7 +2430,7 @@ fn ptrElemVal(
fn airSliceElemVal(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const slice_ty = self.typeOf(bin_op.lhs);
const result: MCValue = if (!slice_ty.isVolatilePtr(mod) and self.liveness.isUnused(inst)) .dead else result: {
const ptr_ty = slice_ty.slicePtrFieldType(mod);
@@ -2447,7 +2447,7 @@ fn airSliceElemVal(self: *Self, inst: Air.Inst.Index) !void {
}
fn airSliceElemPtr(self: *Self, inst: Air.Inst.Index) !void {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.Bin, ty_pl.payload).data;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const slice_mcv = try self.resolveInst(extra.lhs);
@@ -2483,7 +2483,7 @@ fn arrayElemVal(
=> {
const ptr_to_mcv = switch (mcv) {
.stack_offset => |off| MCValue{ .ptr_stack_offset = off },
- .memory => |addr| MCValue{ .immediate = @as(u32, @intCast(addr)) },
+ .memory => |addr| MCValue{ .immediate = @intCast(addr) },
.stack_argument_offset => |off| blk: {
const reg = try self.register_manager.allocReg(null, gp);
@@ -2516,7 +2516,7 @@ fn arrayElemVal(
}
fn airArrayElemVal(self: *Self, inst: Air.Inst.Index) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const array_bind: ReadArg.Bind = .{ .inst = bin_op.lhs };
const index_bind: ReadArg.Bind = .{ .inst = bin_op.rhs };
@@ -2529,7 +2529,7 @@ fn airArrayElemVal(self: *Self, inst: Air.Inst.Index) !void {
fn airPtrElemVal(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const ptr_ty = self.typeOf(bin_op.lhs);
const result: MCValue = if (!ptr_ty.isVolatilePtr(mod) and self.liveness.isUnused(inst)) .dead else result: {
const base_bind: ReadArg.Bind = .{ .inst = bin_op.lhs };
@@ -2541,7 +2541,7 @@ fn airPtrElemVal(self: *Self, inst: Air.Inst.Index) !void {
}
fn airPtrElemPtr(self: *Self, inst: Air.Inst.Index) !void {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.Bin, ty_pl.payload).data;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const ptr_bind: ReadArg.Bind = .{ .inst = extra.lhs };
@@ -2557,63 +2557,63 @@ fn airPtrElemPtr(self: *Self, inst: Air.Inst.Index) !void {
}
fn airSetUnionTag(self: *Self, inst: Air.Inst.Index) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
_ = bin_op;
return self.fail("TODO implement airSetUnionTag for {}", .{self.target.cpu.arch});
// return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
}
fn airGetUnionTag(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
_ = ty_op;
return self.fail("TODO implement airGetUnionTag for {}", .{self.target.cpu.arch});
// return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airClz(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
_ = ty_op;
return self.fail("TODO implement airClz for {}", .{self.target.cpu.arch});
// return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airCtz(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
_ = ty_op;
return self.fail("TODO implement airCtz for {}", .{self.target.cpu.arch});
// return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airPopcount(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
_ = ty_op;
return self.fail("TODO implement airPopcount for {}", .{self.target.cpu.arch});
// return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airAbs(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
_ = ty_op;
return self.fail("TODO implement airAbs for {}", .{self.target.cpu.arch});
// return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airByteSwap(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
_ = ty_op;
return self.fail("TODO implement airByteSwap for {}", .{self.target.cpu.arch});
// return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airBitReverse(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
_ = ty_op;
return self.fail("TODO implement airBitReverse for {}", .{self.target.cpu.arch});
// return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airUnaryMath(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const result: MCValue = if (self.liveness.isUnused(inst))
.dead
else
@@ -2656,7 +2656,7 @@ fn reuseOperand(
// That makes us responsible for doing the rest of the stuff that processDeath would have done.
const branch = &self.branch_stack.items[self.branch_stack.items.len - 1];
- branch.inst_table.putAssumeCapacity(Air.refToIndex(operand).?, .dead);
+ branch.inst_table.putAssumeCapacity(operand.toIndex().?, .dead);
return true;
}
@@ -2664,7 +2664,7 @@ fn reuseOperand(
fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!void {
const mod = self.bin_file.options.module.?;
const elem_ty = ptr_ty.childType(mod);
- const elem_size = @as(u32, @intCast(elem_ty.abiSize(mod)));
+ const elem_size: u32 = @intCast(elem_ty.abiSize(mod));
switch (ptr) {
.none => unreachable,
@@ -2740,7 +2740,7 @@ fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!vo
fn airLoad(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const elem_ty = self.typeOfIndex(inst);
const result: MCValue = result: {
if (!elem_ty.hasRuntimeBits(mod))
@@ -2769,7 +2769,7 @@ fn airLoad(self: *Self, inst: Air.Inst.Index) !void {
fn store(self: *Self, ptr: MCValue, value: MCValue, ptr_ty: Type, value_ty: Type) InnerError!void {
const mod = self.bin_file.options.module.?;
- const elem_size = @as(u32, @intCast(value_ty.abiSize(mod)));
+ const elem_size: u32 = @intCast(value_ty.abiSize(mod));
switch (ptr) {
.none => unreachable,
@@ -2824,7 +2824,7 @@ fn store(self: *Self, ptr: MCValue, value: MCValue, ptr_ty: Type, value_ty: Type
// sub src_reg, fp, #off
try self.genSetReg(ptr_ty, src_reg, .{ .ptr_stack_offset = off });
},
- .memory => |addr| try self.genSetReg(ptr_ty, src_reg, .{ .immediate = @as(u32, @intCast(addr)) }),
+ .memory => |addr| try self.genSetReg(ptr_ty, src_reg, .{ .immediate = @intCast(addr) }),
.stack_argument_offset => |off| {
_ = try self.addInst(.{
.tag = .ldr_ptr_stack_argument,
@@ -2862,7 +2862,7 @@ fn airStore(self: *Self, inst: Air.Inst.Index, safety: bool) !void {
} else {
// TODO if the value is undef, don't lower this instruction
}
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const ptr = try self.resolveInst(bin_op.lhs);
const value = try self.resolveInst(bin_op.rhs);
const ptr_ty = self.typeOf(bin_op.lhs);
@@ -2874,14 +2874,14 @@ fn airStore(self: *Self, inst: Air.Inst.Index, safety: bool) !void {
}
fn airStructFieldPtr(self: *Self, inst: Air.Inst.Index) !void {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.StructField, ty_pl.payload).data;
const result = try self.structFieldPtr(inst, extra.struct_operand, extra.field_index);
return self.finishAir(inst, result, .{ extra.struct_operand, .none, .none });
}
fn airStructFieldPtrIndex(self: *Self, inst: Air.Inst.Index, index: u8) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result = try self.structFieldPtr(inst, ty_op.operand, index);
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
@@ -2892,7 +2892,7 @@ fn structFieldPtr(self: *Self, inst: Air.Inst.Index, operand: Air.Inst.Ref, inde
const mcv = try self.resolveInst(operand);
const ptr_ty = self.typeOf(operand);
const struct_ty = ptr_ty.childType(mod);
- const struct_field_offset = @as(u32, @intCast(struct_ty.structFieldOffset(index, mod)));
+ const struct_field_offset: u32 = @intCast(struct_ty.structFieldOffset(index, mod));
switch (mcv) {
.ptr_stack_offset => |off| {
break :result MCValue{ .ptr_stack_offset = off - struct_field_offset };
@@ -2908,7 +2908,7 @@ fn structFieldPtr(self: *Self, inst: Air.Inst.Index, operand: Air.Inst.Ref, inde
}
fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) !void {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.StructField, ty_pl.payload).data;
const operand = extra.struct_operand;
const index = extra.field_index;
@@ -2916,7 +2916,7 @@ fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) !void {
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const mcv = try self.resolveInst(operand);
const struct_ty = self.typeOf(operand);
- const struct_field_offset = @as(u32, @intCast(struct_ty.structFieldOffset(index, mod)));
+ const struct_field_offset: u32 = @intCast(struct_ty.structFieldOffset(index, mod));
const struct_field_ty = struct_ty.structFieldType(index, mod);
switch (mcv) {
@@ -2980,15 +2980,15 @@ fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) !void {
);
const field_bit_offset = struct_field_offset * 8;
- const field_bit_size = @as(u32, @intCast(struct_field_ty.abiSize(mod))) * 8;
+ const field_bit_size: u32 = @intCast(struct_field_ty.abiSize(mod) * 8);
_ = try self.addInst(.{
.tag = if (struct_field_ty.isSignedInt(mod)) Mir.Inst.Tag.sbfx else .ubfx,
.data = .{ .rr_lsb_width = .{
.rd = dest_reg,
.rn = operand_reg,
- .lsb = @as(u5, @intCast(field_bit_offset)),
- .width = @as(u6, @intCast(field_bit_size)),
+ .lsb = @intCast(field_bit_offset),
+ .width = @intCast(field_bit_size),
} },
});
@@ -3003,17 +3003,17 @@ fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) !void {
fn airFieldParentPtr(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.FieldParentPtr, ty_pl.payload).data;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const field_ptr = try self.resolveInst(extra.field_ptr);
- const struct_ty = self.air.getRefType(ty_pl.ty).childType(mod);
+ const struct_ty = ty_pl.ty.toType().childType(mod);
if (struct_ty.zigTypeTag(mod) == .Union) {
return self.fail("TODO implement @fieldParentPtr codegen for unions", .{});
}
- const struct_field_offset = @as(u32, @intCast(struct_ty.structFieldOffset(extra.field_index, mod)));
+ const struct_field_offset: u32 = @intCast(struct_ty.structFieldOffset(extra.field_index, mod));
switch (field_ptr) {
.ptr_stack_offset => |off| {
break :result MCValue{ .ptr_stack_offset = off + struct_field_offset };
@@ -3168,7 +3168,7 @@ fn allocRegs(
arg.reg.* = mcv.register;
} else {
const track_inst: ?Air.Inst.Index = switch (arg.bind) {
- .inst => |inst| Air.refToIndex(inst).?,
+ .inst => |inst| inst.toIndex().?,
else => null,
};
arg.reg.* = try self.register_manager.allocReg(track_inst, arg.class);
@@ -3225,7 +3225,7 @@ fn allocRegs(
if (mcv != .register) {
if (arg.bind == .inst) {
const branch = &self.branch_stack.items[self.branch_stack.items.len - 1];
- const inst = Air.refToIndex(arg.bind.inst).?;
+ const inst = arg.bind.inst.toIndex().?;
// Overwrite the MCValue associated with this inst
branch.inst_table.putAssumeCapacity(inst, .{ .register = arg.reg.* });
@@ -3374,7 +3374,7 @@ fn binOpImmediate(
=> .{ .rr_shift = .{
.rd = dest_reg,
.rm = lhs_reg,
- .shift_amount = Instruction.ShiftAmount.imm(@as(u5, @intCast(rhs_immediate))),
+ .shift_amount = Instruction.ShiftAmount.imm(@intCast(rhs_immediate)),
} },
else => unreachable,
};
@@ -3905,7 +3905,7 @@ fn ptrArithmetic(
.One => ptr_ty.childType(mod).childType(mod), // ptr to array, so get array element type
else => ptr_ty.childType(mod),
};
- const elem_size = @as(u32, @intCast(elem_ty.abiSize(mod)));
+ const elem_size: u32 = @intCast(elem_ty.abiSize(mod));
const base_tag: Air.Inst.Tag = switch (tag) {
.ptr_add => .add,
@@ -4032,7 +4032,7 @@ fn genInlineMemcpy(
_ = try self.addInst(.{
.tag = .b,
.cond = .ge,
- .data = .{ .inst = @as(u32, @intCast(self.mir_instructions.len + 5)) },
+ .data = .{ .inst = @intCast(self.mir_instructions.len + 5) },
});
// ldrb tmp, [src, count]
@@ -4068,7 +4068,7 @@ fn genInlineMemcpy(
// b loop
_ = try self.addInst(.{
.tag = .b,
- .data = .{ .inst = @as(u32, @intCast(self.mir_instructions.len - 5)) },
+ .data = .{ .inst = @intCast(self.mir_instructions.len - 5) },
});
// end:
@@ -4136,7 +4136,7 @@ fn genInlineMemsetCode(
_ = try self.addInst(.{
.tag = .b,
.cond = .ge,
- .data = .{ .inst = @as(u32, @intCast(self.mir_instructions.len + 4)) },
+ .data = .{ .inst = @intCast(self.mir_instructions.len + 4) },
});
// strb val, [src, count]
@@ -4162,7 +4162,7 @@ fn genInlineMemsetCode(
// b loop
_ = try self.addInst(.{
.tag = .b,
- .data = .{ .inst = @as(u32, @intCast(self.mir_instructions.len - 4)) },
+ .data = .{ .inst = @intCast(self.mir_instructions.len - 4) },
});
// end:
@@ -4176,8 +4176,8 @@ fn airArg(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
const ty = self.typeOfIndex(inst);
- const tag = self.air.instructions.items(.tag)[inst];
- const src_index = self.air.instructions.items(.data)[inst].arg.src_index;
+ const tag = self.air.instructions.items(.tag)[@intFromEnum(inst)];
+ const src_index = self.air.instructions.items(.data)[@intFromEnum(inst)].arg.src_index;
const name = mod.getParamName(self.func_index, src_index);
try self.dbg_info_relocs.append(self.gpa, .{
@@ -4224,10 +4224,10 @@ fn airFence(self: *Self) !void {
fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier) !void {
if (modifier == .always_tail) return self.fail("TODO implement tail calls for arm", .{});
- const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const callee = pl_op.operand;
const extra = self.air.extraData(Air.Call, pl_op.payload);
- const args = @as([]const Air.Inst.Ref, @ptrCast(self.air.extra[extra.end..][0..extra.data.args_len]));
+ const args: []const Air.Inst.Ref = @ptrCast(self.air.extra[extra.end..][0..extra.data.args_len]);
const ty = self.typeOf(callee);
const mod = self.bin_file.options.module.?;
@@ -4305,7 +4305,7 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier
const sym_index = try elf_file.zigObjectPtr().?.getOrCreateMetadataForDecl(elf_file, func.owner_decl);
const sym = elf_file.symbol(sym_index);
_ = try sym.getOrCreateZigGotEntry(sym_index, elf_file);
- const got_addr = @as(u32, @intCast(sym.zigGotAddress(elf_file)));
+ const got_addr: u32 = @intCast(sym.zigGotAddress(elf_file));
try self.genSetReg(Type.usize, .lr, .{ .memory = got_addr });
} else if (self.bin_file.cast(link.File.MachO)) |_| {
unreachable; // unsupported architecture for MachO
@@ -4381,7 +4381,7 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier
fn airRet(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try self.resolveInst(un_op);
const ret_ty = self.fn_type.fnReturnType(mod);
@@ -4413,7 +4413,7 @@ fn airRet(self: *Self, inst: Air.Inst.Index) !void {
fn airRetLoad(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const ptr = try self.resolveInst(un_op);
const ptr_ty = self.typeOf(un_op);
const ret_ty = self.fn_type.fnReturnType(mod);
@@ -4434,9 +4434,9 @@ fn airRetLoad(self: *Self, inst: Air.Inst.Index) !void {
// here. Else we need to load the result from the location
// pointed to by the operand and store it to the result
// location.
- const op_inst = Air.refToIndex(un_op).?;
- if (self.air.instructions.items(.tag)[op_inst] != .ret_ptr) {
- const abi_size = @as(u32, @intCast(ret_ty.abiSize(mod)));
+ const op_inst = un_op.toIndex().?;
+ if (self.air.instructions.items(.tag)[@intFromEnum(op_inst)] != .ret_ptr) {
+ const abi_size: u32 = @intCast(ret_ty.abiSize(mod));
const abi_align = ret_ty.abiAlignment(mod);
const offset = try self.allocMem(abi_size, abi_align, null);
@@ -4456,7 +4456,7 @@ fn airRetLoad(self: *Self, inst: Air.Inst.Index) !void {
}
fn airCmp(self: *Self, inst: Air.Inst.Index, op: math.CompareOperator) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const lhs_ty = self.typeOf(bin_op.lhs);
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else blk: {
@@ -4556,7 +4556,7 @@ fn airCmpVector(self: *Self, inst: Air.Inst.Index) !void {
}
fn airCmpLtErrorsLen(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try self.resolveInst(un_op);
_ = operand;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airCmpLtErrorsLen for {}", .{self.target.cpu.arch});
@@ -4564,7 +4564,7 @@ fn airCmpLtErrorsLen(self: *Self, inst: Air.Inst.Index) !void {
}
fn airDbgStmt(self: *Self, inst: Air.Inst.Index) !void {
- const dbg_stmt = self.air.instructions.items(.data)[inst].dbg_stmt;
+ const dbg_stmt = self.air.instructions.items(.data)[@intFromEnum(inst)].dbg_stmt;
_ = try self.addInst(.{
.tag = .dbg_line,
@@ -4579,7 +4579,7 @@ fn airDbgStmt(self: *Self, inst: Air.Inst.Index) !void {
}
fn airDbgInline(self: *Self, inst: Air.Inst.Index) !void {
- const ty_fn = self.air.instructions.items(.data)[inst].ty_fn;
+ const ty_fn = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_fn;
const mod = self.bin_file.options.module.?;
const func = mod.funcInfo(ty_fn.func);
// TODO emit debug info for function change
@@ -4593,9 +4593,9 @@ fn airDbgBlock(self: *Self, inst: Air.Inst.Index) !void {
}
fn airDbgVar(self: *Self, inst: Air.Inst.Index) !void {
- const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const operand = pl_op.operand;
- const tag = self.air.instructions.items(.tag)[inst];
+ const tag = self.air.instructions.items(.tag)[@intFromEnum(inst)];
const ty = self.typeOf(operand);
const mcv = try self.resolveInst(operand);
const name = self.air.nullTerminatedString(pl_op.payload);
@@ -4647,11 +4647,11 @@ fn condBr(self: *Self, condition: MCValue) !Mir.Inst.Index {
}
fn airCondBr(self: *Self, inst: Air.Inst.Index) !void {
- const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const cond_inst = try 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 then_body: []const Air.Inst.Index = @ptrCast(self.air.extra[extra.end..][0..extra.data.then_body_len]);
+ const else_body: []const Air.Inst.Index = @ptrCast(self.air.extra[extra.end + then_body.len ..][0..extra.data.else_body_len]);
const liveness_condbr = self.liveness.getCondBr(inst);
const reloc: Mir.Inst.Index = try self.condBr(cond_inst);
@@ -4660,7 +4660,7 @@ fn airCondBr(self: *Self, inst: Air.Inst.Index) !void {
// that death now instead of later as this has an effect on
// whether it needs to be spilled in the branches
if (self.liveness.operandDies(inst, 0)) {
- if (Air.refToIndex(pl_op.operand)) |op_index| {
+ if (pl_op.operand.toIndex()) |op_index| {
self.processDeath(op_index);
}
}
@@ -4818,7 +4818,7 @@ fn isNonNull(
}
fn airIsNull(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const operand_bind: ReadArg.Bind = .{ .inst = un_op };
const operand_ty = self.typeOf(un_op);
@@ -4830,7 +4830,7 @@ fn airIsNull(self: *Self, inst: Air.Inst.Index) !void {
fn airIsNullPtr(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const operand_ptr = try self.resolveInst(un_op);
const ptr_ty = self.typeOf(un_op);
@@ -4845,7 +4845,7 @@ fn airIsNullPtr(self: *Self, inst: Air.Inst.Index) !void {
}
fn airIsNonNull(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const operand_bind: ReadArg.Bind = .{ .inst = un_op };
const operand_ty = self.typeOf(un_op);
@@ -4857,7 +4857,7 @@ fn airIsNonNull(self: *Self, inst: Air.Inst.Index) !void {
fn airIsNonNullPtr(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const operand_ptr = try self.resolveInst(un_op);
const ptr_ty = self.typeOf(un_op);
@@ -4907,7 +4907,7 @@ fn isNonErr(
}
fn airIsErr(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const error_union_bind: ReadArg.Bind = .{ .inst = un_op };
const error_union_ty = self.typeOf(un_op);
@@ -4919,7 +4919,7 @@ fn airIsErr(self: *Self, inst: Air.Inst.Index) !void {
fn airIsErrPtr(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const operand_ptr = try self.resolveInst(un_op);
const ptr_ty = self.typeOf(un_op);
@@ -4934,7 +4934,7 @@ fn airIsErrPtr(self: *Self, inst: Air.Inst.Index) !void {
}
fn airIsNonErr(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const error_union_bind: ReadArg.Bind = .{ .inst = un_op };
const error_union_ty = self.typeOf(un_op);
@@ -4946,7 +4946,7 @@ fn airIsNonErr(self: *Self, inst: Air.Inst.Index) !void {
fn airIsNonErrPtr(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const operand_ptr = try self.resolveInst(un_op);
const ptr_ty = self.typeOf(un_op);
@@ -4962,10 +4962,10 @@ fn airIsNonErrPtr(self: *Self, inst: Air.Inst.Index) !void {
fn airLoop(self: *Self, inst: Air.Inst.Index) !void {
// A loop is a setup to be able to jump back to the beginning.
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(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];
- const start_index = @as(Mir.Inst.Index, @intCast(self.mir_instructions.len));
+ const body: []const Air.Inst.Index = @ptrCast(self.air.extra[loop.end..][0..loop.data.body_len]);
+ const start_index: Mir.Inst.Index = @intCast(self.mir_instructions.len);
try self.genBody(body);
try self.jump(start_index);
@@ -4994,9 +4994,9 @@ fn airBlock(self: *Self, inst: Air.Inst.Index) !void {
});
defer self.blocks.getPtr(inst).?.relocs.deinit(self.gpa);
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.Block, ty_pl.payload);
- const body = self.air.extra[extra.end..][0..extra.data.body_len];
+ const body: []const Air.Inst.Index = @ptrCast(self.air.extra[extra.end..][0..extra.data.body_len]);
try self.genBody(body);
// relocations for `br` instructions
@@ -5016,7 +5016,7 @@ fn airBlock(self: *Self, inst: Air.Inst.Index) !void {
}
fn airSwitch(self: *Self, inst: Air.Inst.Index) !void {
- const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const condition_ty = self.typeOf(pl_op.operand);
const switch_br = self.air.extraData(Air.SwitchBr, pl_op.payload);
const liveness = try self.liveness.getSwitchBr(
@@ -5030,9 +5030,9 @@ fn airSwitch(self: *Self, inst: Air.Inst.Index) !void {
var case_i: u32 = 0;
while (case_i < switch_br.data.cases_len) : (case_i += 1) {
const case = self.air.extraData(Air.SwitchBr.Case, extra_index);
- const items = @as([]const Air.Inst.Ref, @ptrCast(self.air.extra[case.end..][0..case.data.items_len]));
+ const items: []const Air.Inst.Ref = @ptrCast(self.air.extra[case.end..][0..case.data.items_len]);
assert(items.len > 0);
- const case_body = self.air.extra[case.end + items.len ..][0..case.data.body_len];
+ const case_body: []const Air.Inst.Index = @ptrCast(self.air.extra[case.end + items.len ..][0..case.data.body_len]);
extra_index = case.end + items.len + case_body.len;
// For every item, we compare it to condition and branch into
@@ -5103,7 +5103,7 @@ fn airSwitch(self: *Self, inst: Air.Inst.Index) !void {
}
if (switch_br.data.else_body_len > 0) {
- const else_body = self.air.extra[extra_index..][0..switch_br.data.else_body_len];
+ const else_body: []const Air.Inst.Index = @ptrCast(self.air.extra[extra_index..][0..switch_br.data.else_body_len]);
// Capture the state of register and stack allocation state so that we can revert to it.
const parent_next_stack_offset = self.next_stack_offset;
@@ -5148,13 +5148,13 @@ fn airSwitch(self: *Self, inst: Air.Inst.Index) !void {
fn performReloc(self: *Self, inst: Mir.Inst.Index) !void {
const tag = self.mir_instructions.items(.tag)[inst];
switch (tag) {
- .b => self.mir_instructions.items(.data)[inst].inst = @as(Air.Inst.Index, @intCast(self.mir_instructions.len)),
+ .b => self.mir_instructions.items(.data)[inst].inst = @intCast(self.mir_instructions.len),
else => unreachable,
}
}
fn airBr(self: *Self, inst: Air.Inst.Index) !void {
- const branch = self.air.instructions.items(.data)[inst].br;
+ const branch = self.air.instructions.items(.data)[@intFromEnum(inst)].br;
try self.br(branch.block_inst, branch.operand);
return self.finishAir(inst, .dead, .{ branch.operand, .none, .none });
}
@@ -5195,14 +5195,14 @@ fn brVoid(self: *Self, block: Air.Inst.Index) !void {
}
fn airAsm(self: *Self, inst: Air.Inst.Index) !void {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.Asm, ty_pl.payload);
const is_volatile = @as(u1, @truncate(extra.data.flags >> 31)) != 0;
- const clobbers_len = @as(u31, @truncate(extra.data.flags));
+ const clobbers_len: u31 = @truncate(extra.data.flags);
var extra_i: usize = extra.end;
- const outputs = @as([]const Air.Inst.Ref, @ptrCast(self.air.extra[extra_i..][0..extra.data.outputs_len]));
+ const outputs: []const Air.Inst.Ref = @ptrCast(self.air.extra[extra_i..][0..extra.data.outputs_len]);
extra_i += outputs.len;
- const inputs = @as([]const Air.Inst.Ref, @ptrCast(self.air.extra[extra_i..][0..extra.data.inputs_len]));
+ const inputs: []const Air.Inst.Ref = @ptrCast(self.air.extra[extra_i..][0..extra.data.inputs_len]);
extra_i += inputs.len;
const dead = !is_volatile and self.liveness.isUnused(inst);
@@ -5332,7 +5332,7 @@ fn setRegOrMem(self: *Self, ty: Type, loc: MCValue, val: MCValue) !void {
fn genSetStack(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) InnerError!void {
const mod = self.bin_file.options.module.?;
- const abi_size = @as(u32, @intCast(ty.abiSize(mod)));
+ const abi_size: u32 = @intCast(ty.abiSize(mod));
switch (mcv) {
.dead => unreachable,
.unreach, .none => return, // Nothing to do.
@@ -5385,7 +5385,7 @@ fn genSetStack(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) InnerErro
},
2 => {
const offset = if (stack_offset <= math.maxInt(u8)) blk: {
- break :blk Instruction.ExtraLoadStoreOffset.imm(@as(u8, @intCast(stack_offset)));
+ break :blk Instruction.ExtraLoadStoreOffset.imm(@intCast(stack_offset));
} else Instruction.ExtraLoadStoreOffset.reg(try self.copyToTmpRegister(Type.u32, MCValue{ .immediate = stack_offset }));
_ = try self.addInst(.{
@@ -5413,7 +5413,7 @@ fn genSetStack(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) InnerErro
try self.genSetStack(wrapped_ty, stack_offset, .{ .register = reg });
const overflow_bit_ty = ty.structFieldType(1, mod);
- const overflow_bit_offset = @as(u32, @intCast(ty.structFieldOffset(1, mod)));
+ const overflow_bit_offset: u32 = @intCast(ty.structFieldOffset(1, mod));
const cond_reg = try self.register_manager.allocReg(null, gp);
// C flag: movcs reg, #1
@@ -5466,7 +5466,7 @@ fn genSetStack(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) InnerErro
// sub src_reg, fp, #off
try self.genSetReg(ptr_ty, src_reg, .{ .ptr_stack_offset = off });
},
- .memory => |addr| try self.genSetReg(ptr_ty, src_reg, .{ .immediate = @as(u32, @intCast(addr)) }),
+ .memory => |addr| try self.genSetReg(ptr_ty, src_reg, .{ .immediate = @intCast(addr) }),
.stack_argument_offset => |off| {
_ = try self.addInst(.{
.tag = .ldr_ptr_stack_argument,
@@ -5563,7 +5563,7 @@ fn genSetReg(self: *Self, ty: Type, reg: Register, mcv: MCValue) InnerError!void
.tag = .movw,
.data = .{ .r_imm16 = .{
.rd = reg,
- .imm16 = @as(u16, @intCast(x)),
+ .imm16 = @intCast(x),
} },
});
} else {
@@ -5571,7 +5571,7 @@ fn genSetReg(self: *Self, ty: Type, reg: Register, mcv: MCValue) InnerError!void
.tag = .mov,
.data = .{ .r_op_mov = .{
.rd = reg,
- .op = Instruction.Operand.imm(@as(u8, @truncate(x)), 0),
+ .op = Instruction.Operand.imm(@truncate(x), 0),
} },
});
_ = try self.addInst(.{
@@ -5579,7 +5579,7 @@ fn genSetReg(self: *Self, ty: Type, reg: Register, mcv: MCValue) InnerError!void
.data = .{ .rr_op = .{
.rd = reg,
.rn = reg,
- .op = Instruction.Operand.imm(@as(u8, @truncate(x >> 8)), 12),
+ .op = Instruction.Operand.imm(@truncate(x >> 8), 12),
} },
});
}
@@ -5594,14 +5594,14 @@ fn genSetReg(self: *Self, ty: Type, reg: Register, mcv: MCValue) InnerError!void
.tag = .movw,
.data = .{ .r_imm16 = .{
.rd = reg,
- .imm16 = @as(u16, @truncate(x)),
+ .imm16 = @truncate(x),
} },
});
_ = try self.addInst(.{
.tag = .movt,
.data = .{ .r_imm16 = .{
.rd = reg,
- .imm16 = @as(u16, @truncate(x >> 16)),
+ .imm16 = @truncate(x >> 16),
} },
});
} else {
@@ -5614,7 +5614,7 @@ fn genSetReg(self: *Self, ty: Type, reg: Register, mcv: MCValue) InnerError!void
.tag = .mov,
.data = .{ .r_op_mov = .{
.rd = reg,
- .op = Instruction.Operand.imm(@as(u8, @truncate(x)), 0),
+ .op = Instruction.Operand.imm(@truncate(x), 0),
} },
});
_ = try self.addInst(.{
@@ -5622,7 +5622,7 @@ fn genSetReg(self: *Self, ty: Type, reg: Register, mcv: MCValue) InnerError!void
.data = .{ .rr_op = .{
.rd = reg,
.rn = reg,
- .op = Instruction.Operand.imm(@as(u8, @truncate(x >> 8)), 12),
+ .op = Instruction.Operand.imm(@truncate(x >> 8), 12),
} },
});
_ = try self.addInst(.{
@@ -5630,7 +5630,7 @@ fn genSetReg(self: *Self, ty: Type, reg: Register, mcv: MCValue) InnerError!void
.data = .{ .rr_op = .{
.rd = reg,
.rn = reg,
- .op = Instruction.Operand.imm(@as(u8, @truncate(x >> 16)), 8),
+ .op = Instruction.Operand.imm(@truncate(x >> 16), 8),
} },
});
_ = try self.addInst(.{
@@ -5638,7 +5638,7 @@ fn genSetReg(self: *Self, ty: Type, reg: Register, mcv: MCValue) InnerError!void
.data = .{ .rr_op = .{
.rd = reg,
.rn = reg,
- .op = Instruction.Operand.imm(@as(u8, @truncate(x >> 24)), 4),
+ .op = Instruction.Operand.imm(@truncate(x >> 24), 4),
} },
});
}
@@ -5663,12 +5663,12 @@ fn genSetReg(self: *Self, ty: Type, reg: Register, mcv: MCValue) InnerError!void
.memory => |addr| {
// The value is in memory at a hard-coded address.
// If the type is a pointer, it means the pointer address is at this memory location.
- try self.genSetReg(ty, reg, .{ .immediate = @as(u32, @intCast(addr)) });
+ try self.genSetReg(ty, reg, .{ .immediate = @intCast(addr) });
try self.genLdrRegister(reg, reg, ty);
},
.stack_offset => |off| {
// TODO: maybe addressing from sp instead of fp
- const abi_size = @as(u32, @intCast(ty.abiSize(mod)));
+ const abi_size: u32 = @intCast(ty.abiSize(mod));
const tag: Mir.Inst.Tag = switch (abi_size) {
1 => if (ty.isSignedInt(mod)) Mir.Inst.Tag.ldrsb else .ldrb,
@@ -5686,7 +5686,7 @@ fn genSetReg(self: *Self, ty: Type, reg: Register, mcv: MCValue) InnerError!void
if (extra_offset) {
const offset = if (off <= math.maxInt(u8)) blk: {
- break :blk Instruction.ExtraLoadStoreOffset.imm(@as(u8, @intCast(off)));
+ break :blk Instruction.ExtraLoadStoreOffset.imm(@intCast(off));
} else Instruction.ExtraLoadStoreOffset.reg(try self.copyToTmpRegister(Type.usize, MCValue{ .immediate = off }));
_ = try self.addInst(.{
@@ -5702,7 +5702,7 @@ fn genSetReg(self: *Self, ty: Type, reg: Register, mcv: MCValue) InnerError!void
});
} else {
const offset = if (off <= math.maxInt(u12)) blk: {
- break :blk Instruction.Offset.imm(@as(u12, @intCast(off)));
+ break :blk Instruction.Offset.imm(@intCast(off));
} else Instruction.Offset.reg(try self.copyToTmpRegister(Type.usize, MCValue{ .immediate = off }), .none);
_ = try self.addInst(.{
@@ -5741,7 +5741,7 @@ fn genSetReg(self: *Self, ty: Type, reg: Register, mcv: MCValue) InnerError!void
fn genSetStackArgument(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) InnerError!void {
const mod = self.bin_file.options.module.?;
- const abi_size = @as(u32, @intCast(ty.abiSize(mod)));
+ const abi_size: u32 = @intCast(ty.abiSize(mod));
switch (mcv) {
.dead => unreachable,
.none, .unreach => return,
@@ -5780,7 +5780,7 @@ fn genSetStackArgument(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) I
},
2 => {
const offset = if (stack_offset <= math.maxInt(u8)) blk: {
- break :blk Instruction.ExtraLoadStoreOffset.imm(@as(u8, @intCast(stack_offset)));
+ break :blk Instruction.ExtraLoadStoreOffset.imm(@intCast(stack_offset));
} else Instruction.ExtraLoadStoreOffset.reg(try self.copyToTmpRegister(Type.u32, MCValue{ .immediate = stack_offset }));
_ = try self.addInst(.{
@@ -5823,7 +5823,7 @@ fn genSetStackArgument(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) I
// sub src_reg, fp, #off
try self.genSetReg(ptr_ty, src_reg, .{ .ptr_stack_offset = off });
},
- .memory => |addr| try self.genSetReg(ptr_ty, src_reg, .{ .immediate = @as(u32, @intCast(addr)) }),
+ .memory => |addr| try self.genSetReg(ptr_ty, src_reg, .{ .immediate = @intCast(addr) }),
.stack_argument_offset => |off| {
_ = try self.addInst(.{
.tag = .ldr_ptr_stack_argument,
@@ -5867,13 +5867,13 @@ fn genSetStackArgument(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) I
}
fn airIntFromPtr(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const result = try self.resolveInst(un_op);
return self.finishAir(inst, result, .{ un_op, .none, .none });
}
fn airBitCast(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result = if (self.liveness.isUnused(inst)) .dead else result: {
const operand = try self.resolveInst(ty_op.operand);
if (self.reuseOperand(inst, ty_op.operand, 0, operand)) break :result operand;
@@ -5897,12 +5897,12 @@ fn airBitCast(self: *Self, inst: Air.Inst.Index) !void {
fn airArrayToSlice(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const ptr_ty = self.typeOf(ty_op.operand);
const ptr = try self.resolveInst(ty_op.operand);
const array_ty = ptr_ty.childType(mod);
- const array_len = @as(u32, @intCast(array_ty.arrayLen(mod)));
+ const array_len: u32 = @intCast(array_ty.arrayLen(mod));
const stack_offset = try self.allocMem(8, .@"8", inst);
try self.genSetStack(ptr_ty, stack_offset, ptr);
@@ -5913,7 +5913,7 @@ fn airArrayToSlice(self: *Self, inst: Air.Inst.Index) !void {
}
fn airFloatFromInt(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airFloatFromInt for {}", .{
self.target.cpu.arch,
});
@@ -5921,7 +5921,7 @@ fn airFloatFromInt(self: *Self, inst: Air.Inst.Index) !void {
}
fn airIntFromFloat(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airIntFromFloat for {}", .{
self.target.cpu.arch,
});
@@ -5929,7 +5929,7 @@ fn airIntFromFloat(self: *Self, inst: Air.Inst.Index) !void {
}
fn airCmpxchg(self: *Self, inst: Air.Inst.Index) !void {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.Block, ty_pl.payload);
_ = extra;
@@ -5970,7 +5970,7 @@ fn airMemcpy(self: *Self, inst: Air.Inst.Index) !void {
}
fn airTagName(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try self.resolveInst(un_op);
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else {
_ = operand;
@@ -5980,7 +5980,7 @@ fn airTagName(self: *Self, inst: Air.Inst.Index) !void {
}
fn airErrorName(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try self.resolveInst(un_op);
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else {
_ = operand;
@@ -5990,26 +5990,26 @@ fn airErrorName(self: *Self, inst: Air.Inst.Index) !void {
}
fn airSplat(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airSplat for arm", .{});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airSelect(self: *Self, inst: Air.Inst.Index) !void {
- const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const extra = self.air.extraData(Air.Bin, pl_op.payload).data;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airSelect for arm", .{});
return self.finishAir(inst, result, .{ pl_op.operand, extra.lhs, extra.rhs });
}
fn airShuffle(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airShuffle for arm", .{});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airReduce(self: *Self, inst: Air.Inst.Index) !void {
- const reduce = self.air.instructions.items(.data)[inst].reduce;
+ const reduce = self.air.instructions.items(.data)[@intFromEnum(inst)].reduce;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airReduce for arm", .{});
return self.finishAir(inst, result, .{ reduce.operand, .none, .none });
}
@@ -6018,8 +6018,8 @@ fn airAggregateInit(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
const vector_ty = self.typeOfIndex(inst);
const len = vector_ty.vectorLen(mod);
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
- const elements = @as([]const Air.Inst.Ref, @ptrCast(self.air.extra[ty_pl.payload..][0..len]));
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
+ const elements: []const Air.Inst.Ref = @ptrCast(self.air.extra[ty_pl.payload..][0..len]);
const result: MCValue = res: {
if (self.liveness.isUnused(inst)) break :res MCValue.dead;
return self.fail("TODO implement airAggregateInit for arm", .{});
@@ -6038,7 +6038,7 @@ fn airAggregateInit(self: *Self, inst: Air.Inst.Index) !void {
}
fn airUnionInit(self: *Self, inst: Air.Inst.Index) !void {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.UnionInit, ty_pl.payload).data;
_ = extra;
@@ -6046,12 +6046,12 @@ fn airUnionInit(self: *Self, inst: Air.Inst.Index) !void {
}
fn airPrefetch(self: *Self, inst: Air.Inst.Index) !void {
- const prefetch = self.air.instructions.items(.data)[inst].prefetch;
+ const prefetch = self.air.instructions.items(.data)[@intFromEnum(inst)].prefetch;
return self.finishAir(inst, MCValue.dead, .{ prefetch.ptr, .none, .none });
}
fn airMulAdd(self: *Self, inst: Air.Inst.Index) !void {
- const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const extra = self.air.extraData(Air.Bin, pl_op.payload).data;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else {
return self.fail("TODO implement airMulAdd for arm", .{});
@@ -6060,14 +6060,14 @@ fn airMulAdd(self: *Self, inst: Air.Inst.Index) !void {
}
fn airTry(self: *Self, inst: Air.Inst.Index) !void {
- const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const extra = self.air.extraData(Air.Try, pl_op.payload);
- const body = self.air.extra[extra.end..][0..extra.data.body_len];
+ const body: []const Air.Inst.Index = @ptrCast(self.air.extra[extra.end..][0..extra.data.body_len]);
const result: MCValue = result: {
const error_union_bind: ReadArg.Bind = .{ .inst = pl_op.operand };
const error_union_ty = self.typeOf(pl_op.operand);
const mod = self.bin_file.options.module.?;
- const error_union_size = @as(u32, @intCast(error_union_ty.abiSize(mod)));
+ const error_union_size: u32 = @intCast(error_union_ty.abiSize(mod));
const error_union_align = error_union_ty.abiAlignment(mod);
// The error union will die in the body. However, we need the
@@ -6088,7 +6088,7 @@ fn airTry(self: *Self, inst: Air.Inst.Index) !void {
}
fn airTryPtr(self: *Self, inst: Air.Inst.Index) !void {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.TryPtr, ty_pl.payload);
const body = self.air.extra[extra.end..][0..extra.data.body_len];
_ = body;
@@ -6104,7 +6104,7 @@ fn resolveInst(self: *Self, inst: Air.Inst.Ref) InnerError!MCValue {
if (!inst_ty.hasRuntimeBitsIgnoreComptime(mod) and !inst_ty.isError(mod))
return MCValue{ .none = {} };
- const inst_index = Air.refToIndex(inst) orelse return self.genTypedValue(.{
+ const inst_index = inst.toIndex() orelse return self.genTypedValue(.{
.ty = inst_ty,
.val = (try self.air.value(inst, mod)).?,
});
@@ -6136,7 +6136,7 @@ fn genTypedValue(self: *Self, arg_tv: TypedValue) InnerError!MCValue {
.none => .none,
.undef => .undef,
.load_got, .load_symbol, .load_direct, .load_tlv => unreachable, // TODO
- .immediate => |imm| .{ .immediate = @as(u32, @truncate(imm)) },
+ .immediate => |imm| .{ .immediate = @truncate(imm) },
.memory => |addr| .{ .memory = addr },
},
.fail => |msg| {
@@ -6194,7 +6194,7 @@ fn resolveCallingConventionValues(self: *Self, fn_ty: Type) !CallMCValues {
} else if (!ret_ty.hasRuntimeBitsIgnoreComptime(mod)) {
result.return_value = .{ .none = {} };
} else {
- const ret_ty_size = @as(u32, @intCast(ret_ty.abiSize(mod)));
+ const ret_ty_size: u32 = @intCast(ret_ty.abiSize(mod));
// TODO handle cases where multiple registers are used
if (ret_ty_size <= 4) {
result.return_value = .{ .register = c_abi_int_return_regs[0] };
@@ -6212,7 +6212,7 @@ fn resolveCallingConventionValues(self: *Self, fn_ty: Type) !CallMCValues {
if (Type.fromInterned(ty).abiAlignment(mod) == .@"8")
ncrn = std.mem.alignForward(usize, ncrn, 2);
- const param_size = @as(u32, @intCast(Type.fromInterned(ty).abiSize(mod)));
+ const param_size: u32 = @intCast(Type.fromInterned(ty).abiSize(mod));
if (std.math.divCeil(u32, param_size, 4) catch unreachable <= 4 - ncrn) {
if (param_size <= 4) {
result_arg.* = .{ .register = c_abi_int_param_regs[ncrn] };
@@ -6241,7 +6241,7 @@ fn resolveCallingConventionValues(self: *Self, fn_ty: Type) !CallMCValues {
} else if (!ret_ty.hasRuntimeBitsIgnoreComptime(mod) and !ret_ty.isError(mod)) {
result.return_value = .{ .none = {} };
} else {
- const ret_ty_size = @as(u32, @intCast(ret_ty.abiSize(mod)));
+ const ret_ty_size: u32 = @intCast(ret_ty.abiSize(mod));
if (ret_ty_size == 0) {
assert(ret_ty.isError(mod));
result.return_value = .{ .immediate = 0 };
src/arch/riscv64/CodeGen.zig
@@ -198,7 +198,7 @@ const BigTomb = struct {
fn feed(bt: *BigTomb, op_ref: Air.Inst.Ref) void {
const dies = bt.lbt.feed();
- const op_index = Air.refToIndex(op_ref) orelse return;
+ const op_index = op_ref.toIndex() orelse return;
if (!dies) return;
bt.function.processDeath(op_index);
}
@@ -325,7 +325,7 @@ fn addInst(self: *Self, inst: Mir.Inst) error{OutOfMemory}!Mir.Inst.Index {
try self.mir_instructions.ensureUnusedCapacity(gpa, 1);
- const result_index = @as(Air.Inst.Index, @intCast(self.mir_instructions.len));
+ const result_index: Mir.Inst.Index = @intCast(self.mir_instructions.len);
self.mir_instructions.appendAssumeCapacity(inst);
return result_index;
}
@@ -338,11 +338,11 @@ pub fn addExtra(self: *Self, extra: anytype) Allocator.Error!u32 {
pub fn addExtraAssumeCapacity(self: *Self, extra: anytype) u32 {
const fields = std.meta.fields(@TypeOf(extra));
- const result = @as(u32, @intCast(self.mir_extra.items.len));
+ const result: u32 = @intCast(self.mir_extra.items.len);
inline for (fields) |field| {
self.mir_extra.appendAssumeCapacity(switch (field.type) {
u32 => @field(extra, field.name),
- i32 => @as(u32, @bitCast(@field(extra, field.name))),
+ i32 => @bitCast(@field(extra, field.name)),
else => @compileError("bad field type"),
});
}
@@ -486,7 +486,7 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
const old_air_bookkeeping = self.air_bookkeeping;
try self.ensureProcessDeathCapacity(Liveness.bpi);
- switch (air_tags[inst]) {
+ switch (air_tags[@intFromEnum(inst)]) {
// zig fmt: off
.ptr_add => try self.airPtrArithmetic(inst, .ptr_add),
.ptr_sub => try self.airPtrArithmetic(inst, .ptr_sub),
@@ -725,7 +725,7 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
}
if (std.debug.runtime_safety) {
if (self.air_bookkeeping < old_air_bookkeeping + 1) {
- std.debug.panic("in codegen.zig, handling of AIR instruction %{d} ('{}') did not do proper bookkeeping. Look for a missing call to finishAir.", .{ inst, air_tags[inst] });
+ std.debug.panic("in codegen.zig, handling of AIR instruction %{d} ('{}') did not do proper bookkeeping. Look for a missing call to finishAir.", .{ inst, air_tags[@intFromEnum(inst)] });
}
}
}
@@ -758,7 +758,7 @@ fn finishAir(self: *Self, inst: Air.Inst.Index, result: MCValue, operands: [Live
const dies = @as(u1, @truncate(tomb_bits)) != 0;
tomb_bits >>= 1;
if (!dies) continue;
- const op_index = Air.refToIndex(op) orelse continue;
+ const op_index = op.toIndex() orelse continue;
self.processDeath(op_index);
}
const is_used = @as(u1, @truncate(tomb_bits)) == 0;
@@ -877,19 +877,19 @@ fn airRetPtr(self: *Self, inst: Air.Inst.Index) !void {
}
fn airFptrunc(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airFptrunc for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airFpext(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airFpext for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airIntCast(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
if (self.liveness.isUnused(inst))
return self.finishAir(inst, .dead, .{ ty_op.operand, .none, .none });
@@ -909,7 +909,7 @@ fn airIntCast(self: *Self, inst: Air.Inst.Index) !void {
}
fn airTrunc(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
if (self.liveness.isUnused(inst))
return self.finishAir(inst, .dead, .{ ty_op.operand, .none, .none });
@@ -920,32 +920,32 @@ fn airTrunc(self: *Self, inst: Air.Inst.Index) !void {
}
fn airIntFromBool(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try self.resolveInst(un_op);
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else operand;
return self.finishAir(inst, result, .{ un_op, .none, .none });
}
fn airNot(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement NOT for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airMin(self: *Self, inst: Air.Inst.Index) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement min for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
}
fn airMax(self: *Self, inst: Air.Inst.Index) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement max for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
}
fn airSlice(self: *Self, inst: Air.Inst.Index) !void {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement slice for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
@@ -981,8 +981,8 @@ fn binOpRegister(
const lhs_reg = if (lhs_is_register) lhs.register else blk: {
const track_inst: ?Air.Inst.Index = if (maybe_inst) |inst| inst: {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
- break :inst Air.refToIndex(bin_op.lhs).?;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
+ break :inst bin_op.lhs.toIndex().?;
} else null;
const reg = try self.register_manager.allocReg(track_inst, gp);
@@ -996,8 +996,8 @@ fn binOpRegister(
const rhs_reg = if (rhs_is_register) rhs.register else blk: {
const track_inst: ?Air.Inst.Index = if (maybe_inst) |inst| inst: {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
- break :inst Air.refToIndex(bin_op.rhs).?;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
+ break :inst bin_op.rhs.toIndex().?;
} else null;
const reg = try self.register_manager.allocReg(track_inst, gp);
@@ -1010,7 +1010,7 @@ fn binOpRegister(
defer if (new_rhs_lock) |reg| self.register_manager.unlockReg(reg);
const dest_reg = if (maybe_inst) |inst| blk: {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
if (lhs_is_register and self.reuseOperand(inst, bin_op.lhs, 0, lhs)) {
break :blk lhs_reg;
@@ -1123,7 +1123,7 @@ fn binOp(
}
fn airBinOp(self: *Self, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const lhs = try self.resolveInst(bin_op.lhs);
const rhs = try self.resolveInst(bin_op.rhs);
const lhs_ty = self.typeOf(bin_op.lhs);
@@ -1134,7 +1134,7 @@ fn airBinOp(self: *Self, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void {
}
fn airPtrArithmetic(self: *Self, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
const lhs = try self.resolveInst(bin_op.lhs);
const rhs = try self.resolveInst(bin_op.rhs);
@@ -1146,43 +1146,43 @@ fn airPtrArithmetic(self: *Self, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void
}
fn airAddWrap(self: *Self, inst: Air.Inst.Index) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement addwrap for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
}
fn airAddSat(self: *Self, inst: Air.Inst.Index) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement add_sat for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
}
fn airSubWrap(self: *Self, inst: Air.Inst.Index) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement subwrap for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
}
fn airSubSat(self: *Self, inst: Air.Inst.Index) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement sub_sat for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
}
fn airMul(self: *Self, inst: Air.Inst.Index) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement mul for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
}
fn airMulWrap(self: *Self, inst: Air.Inst.Index) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement mulwrap for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
}
fn airMulSat(self: *Self, inst: Air.Inst.Index) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement mul_sat for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
}
@@ -1208,105 +1208,105 @@ fn airShlWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
}
fn airDiv(self: *Self, inst: Air.Inst.Index) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement div for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
}
fn airRem(self: *Self, inst: Air.Inst.Index) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement rem for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
}
fn airMod(self: *Self, inst: Air.Inst.Index) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement mod for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
}
fn airBitAnd(self: *Self, inst: Air.Inst.Index) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement bitwise and for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
}
fn airBitOr(self: *Self, inst: Air.Inst.Index) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement bitwise or for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
}
fn airXor(self: *Self, inst: Air.Inst.Index) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement xor for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
}
fn airShl(self: *Self, inst: Air.Inst.Index) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement shl for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
}
fn airShlSat(self: *Self, inst: Air.Inst.Index) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement shl_sat for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
}
fn airShr(self: *Self, inst: Air.Inst.Index) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement shr for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
}
fn airOptionalPayload(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement .optional_payload for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airOptionalPayloadPtr(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement .optional_payload_ptr for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airOptionalPayloadPtrSet(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement .optional_payload_ptr_set for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airUnwrapErrErr(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement unwrap error union error for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airUnwrapErrPayload(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement unwrap error union payload for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
// *(E!T) -> E
fn airUnwrapErrErrPtr(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement unwrap error union error ptr for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
// *(E!T) -> *T
fn airUnwrapErrPayloadPtr(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement unwrap error union payload ptr for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airErrUnionPayloadPtrSet(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement .errunion_payload_ptr_set for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
@@ -1330,7 +1330,7 @@ fn airSaveErrReturnTraceIndex(self: *Self, inst: Air.Inst.Index) !void {
}
fn airWrapOptional(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const mod = self.bin_file.options.module.?;
const optional_ty = self.typeOfIndex(inst);
@@ -1346,127 +1346,127 @@ fn airWrapOptional(self: *Self, inst: Air.Inst.Index) !void {
/// T to E!T
fn airWrapErrUnionPayload(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement wrap errunion payload for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
/// E to E!T
fn airWrapErrUnionErr(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement wrap errunion error for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airSlicePtr(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement slice_ptr for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airSliceLen(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement slice_len for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airPtrSliceLenPtr(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement ptr_slice_len_ptr for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airPtrSlicePtrPtr(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement ptr_slice_ptr_ptr for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airSliceElemVal(self: *Self, inst: Air.Inst.Index) !void {
const is_volatile = false; // TODO
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const result: MCValue = if (!is_volatile and self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement slice_elem_val for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
}
fn airSliceElemPtr(self: *Self, inst: Air.Inst.Index) !void {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.Bin, ty_pl.payload).data;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement slice_elem_ptr for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ extra.lhs, extra.rhs, .none });
}
fn airArrayElemVal(self: *Self, inst: Air.Inst.Index) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement array_elem_val for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
}
fn airPtrElemVal(self: *Self, inst: Air.Inst.Index) !void {
const is_volatile = false; // TODO
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const result: MCValue = if (!is_volatile and self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement ptr_elem_val for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
}
fn airPtrElemPtr(self: *Self, inst: Air.Inst.Index) !void {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.Bin, ty_pl.payload).data;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement ptr_elem_ptr for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ extra.lhs, extra.rhs, .none });
}
fn airSetUnionTag(self: *Self, inst: Air.Inst.Index) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
_ = bin_op;
return self.fail("TODO implement airSetUnionTag for {}", .{self.target.cpu.arch});
// return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
}
fn airGetUnionTag(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airGetUnionTag for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airClz(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airClz for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airCtz(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airCtz for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airPopcount(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airPopcount for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airAbs(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airAbs for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airByteSwap(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airByteSwap for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airBitReverse(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airBitReverse for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airUnaryMath(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const result: MCValue = if (self.liveness.isUnused(inst))
.dead
else
@@ -1500,7 +1500,7 @@ fn reuseOperand(self: *Self, inst: Air.Inst.Index, operand: Air.Inst.Ref, op_ind
// That makes us responsible for doing the rest of the stuff that processDeath would have done.
const branch = &self.branch_stack.items[self.branch_stack.items.len - 1];
- branch.inst_table.putAssumeCapacity(Air.refToIndex(operand).?, .dead);
+ branch.inst_table.putAssumeCapacity(operand.toIndex().?, .dead);
return true;
}
@@ -1533,7 +1533,7 @@ fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!vo
fn airLoad(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const elem_ty = self.typeOfIndex(inst);
const result: MCValue = result: {
if (!elem_ty.hasRuntimeBits(mod))
@@ -1590,7 +1590,7 @@ fn airStore(self: *Self, inst: Air.Inst.Index, safety: bool) !void {
} else {
// TODO if the value is undef, don't lower this instruction
}
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const ptr = try self.resolveInst(bin_op.lhs);
const value = try self.resolveInst(bin_op.rhs);
const ptr_ty = self.typeOf(bin_op.lhs);
@@ -1602,13 +1602,13 @@ fn airStore(self: *Self, inst: Air.Inst.Index, safety: bool) !void {
}
fn airStructFieldPtr(self: *Self, inst: Air.Inst.Index) !void {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.StructField, ty_pl.payload).data;
return self.structFieldPtr(extra.struct_operand, ty_pl.ty, extra.field_index);
}
fn airStructFieldPtrIndex(self: *Self, inst: Air.Inst.Index, index: u8) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
return self.structFieldPtr(ty_op.operand, ty_op.ty, index);
}
fn structFieldPtr(self: *Self, operand: Air.Inst.Ref, ty: Air.Inst.Ref, index: u32) !void {
@@ -1620,7 +1620,7 @@ fn structFieldPtr(self: *Self, operand: Air.Inst.Ref, ty: Air.Inst.Ref, index: u
}
fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) !void {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.StructField, ty_pl.payload).data;
_ = extra;
return self.fail("TODO implement codegen struct_field_val", .{});
@@ -1634,8 +1634,8 @@ fn airFieldParentPtr(self: *Self, inst: Air.Inst.Index) !void {
fn genArgDbgInfo(self: Self, inst: Air.Inst.Index, mcv: MCValue) !void {
const mod = self.bin_file.options.module.?;
- const arg = self.air.instructions.items(.data)[inst].arg;
- const ty = self.air.getRefType(arg.ty);
+ const arg = self.air.instructions.items(.data)[@intFromEnum(inst)].arg;
+ const ty = arg.ty.toType();
const owner_decl = mod.funcOwnerDeclIndex(self.func_index);
const name = mod.getParamName(self.func_index, arg.src_index);
@@ -1712,11 +1712,11 @@ fn airFence(self: *Self) !void {
fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier) !void {
const mod = self.bin_file.options.module.?;
if (modifier == .always_tail) return self.fail("TODO implement tail calls for riscv64", .{});
- const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const fn_ty = self.typeOf(pl_op.operand);
const callee = pl_op.operand;
const extra = self.air.extraData(Air.Call, pl_op.payload);
- const args = @as([]const Air.Inst.Ref, @ptrCast(self.air.extra[extra.end..][0..extra.data.args_len]));
+ const args: []const Air.Inst.Ref = @ptrCast(self.air.extra[extra.end..][0..extra.data.args_len]);
var info = try self.resolveCallingConventionValues(fn_ty);
defer info.deinit(self);
@@ -1755,7 +1755,7 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier
const sym_index = try elf_file.zigObjectPtr().?.getOrCreateMetadataForDecl(elf_file, func.owner_decl);
const sym = elf_file.symbol(sym_index);
_ = try sym.getOrCreateZigGotEntry(sym_index, elf_file);
- const got_addr = @as(u32, @intCast(sym.zigGotAddress(elf_file)));
+ const got_addr: u32 = @intCast(sym.zigGotAddress(elf_file));
try self.genSetReg(Type.usize, .ra, .{ .memory = got_addr });
_ = try self.addInst(.{
.tag = .jalr,
@@ -1824,14 +1824,14 @@ fn ret(self: *Self, mcv: MCValue) !void {
}
fn airRet(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try self.resolveInst(un_op);
try self.ret(operand);
return self.finishAir(inst, .dead, .{ un_op, .none, .none });
}
fn airRetLoad(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const ptr = try self.resolveInst(un_op);
_ = ptr;
return self.fail("TODO implement airRetLoad for {}", .{self.target.cpu.arch});
@@ -1839,7 +1839,7 @@ fn airRetLoad(self: *Self, inst: Air.Inst.Index) !void {
}
fn airCmp(self: *Self, inst: Air.Inst.Index, op: math.CompareOperator) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
if (self.liveness.isUnused(inst))
return self.finishAir(inst, .dead, .{ bin_op.lhs, bin_op.rhs, .none });
const ty = self.typeOf(bin_op.lhs);
@@ -1864,7 +1864,7 @@ fn airCmpVector(self: *Self, inst: Air.Inst.Index) !void {
}
fn airCmpLtErrorsLen(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try self.resolveInst(un_op);
_ = operand;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airCmpLtErrorsLen for {}", .{self.target.cpu.arch});
@@ -1872,7 +1872,7 @@ fn airCmpLtErrorsLen(self: *Self, inst: Air.Inst.Index) !void {
}
fn airDbgStmt(self: *Self, inst: Air.Inst.Index) !void {
- const dbg_stmt = self.air.instructions.items(.data)[inst].dbg_stmt;
+ const dbg_stmt = self.air.instructions.items(.data)[@intFromEnum(inst)].dbg_stmt;
_ = try self.addInst(.{
.tag = .dbg_line,
@@ -1886,7 +1886,7 @@ fn airDbgStmt(self: *Self, inst: Air.Inst.Index) !void {
}
fn airDbgInline(self: *Self, inst: Air.Inst.Index) !void {
- const ty_fn = self.air.instructions.items(.data)[inst].ty_fn;
+ const ty_fn = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_fn;
const mod = self.bin_file.options.module.?;
const func = mod.funcInfo(ty_fn.func);
// TODO emit debug info for function change
@@ -1900,7 +1900,7 @@ fn airDbgBlock(self: *Self, inst: Air.Inst.Index) !void {
}
fn airDbgVar(self: *Self, inst: Air.Inst.Index) !void {
- const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const name = self.air.nullTerminatedString(pl_op.payload);
const operand = pl_op.operand;
// TODO emit debug info for this variable
@@ -1944,7 +1944,7 @@ fn isNonErr(self: *Self, operand: MCValue) !MCValue {
}
fn airIsNull(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const operand = try self.resolveInst(un_op);
break :result try self.isNull(operand);
@@ -1953,7 +1953,7 @@ fn airIsNull(self: *Self, inst: Air.Inst.Index) !void {
}
fn airIsNullPtr(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const operand_ptr = try self.resolveInst(un_op);
const operand: MCValue = blk: {
@@ -1971,7 +1971,7 @@ fn airIsNullPtr(self: *Self, inst: Air.Inst.Index) !void {
}
fn airIsNonNull(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const operand = try self.resolveInst(un_op);
break :result try self.isNonNull(operand);
@@ -1980,7 +1980,7 @@ fn airIsNonNull(self: *Self, inst: Air.Inst.Index) !void {
}
fn airIsNonNullPtr(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const operand_ptr = try self.resolveInst(un_op);
const operand: MCValue = blk: {
@@ -1998,7 +1998,7 @@ fn airIsNonNullPtr(self: *Self, inst: Air.Inst.Index) !void {
}
fn airIsErr(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const operand = try self.resolveInst(un_op);
break :result try self.isErr(operand);
@@ -2007,7 +2007,7 @@ fn airIsErr(self: *Self, inst: Air.Inst.Index) !void {
}
fn airIsErrPtr(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const operand_ptr = try self.resolveInst(un_op);
const operand: MCValue = blk: {
@@ -2025,7 +2025,7 @@ fn airIsErrPtr(self: *Self, inst: Air.Inst.Index) !void {
}
fn airIsNonErr(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const operand = try self.resolveInst(un_op);
break :result try self.isNonErr(operand);
@@ -2034,7 +2034,7 @@ fn airIsNonErr(self: *Self, inst: Air.Inst.Index) !void {
}
fn airIsNonErrPtr(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const operand_ptr = try self.resolveInst(un_op);
const operand: MCValue = blk: {
@@ -2053,9 +2053,9 @@ fn airIsNonErrPtr(self: *Self, inst: Air.Inst.Index) !void {
fn airLoop(self: *Self, inst: Air.Inst.Index) !void {
// A loop is a setup to be able to jump back to the beginning.
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(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];
+ const body: []const Air.Inst.Index = @ptrCast(self.air.extra[loop.end..][0..loop.data.body_len]);
const start_index = self.code.items.len;
try self.genBody(body);
try self.jump(start_index);
@@ -2081,9 +2081,9 @@ fn airBlock(self: *Self, inst: Air.Inst.Index) !void {
});
defer self.blocks.getPtr(inst).?.relocs.deinit(self.gpa);
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.Block, ty_pl.payload);
- const body = self.air.extra[extra.end..][0..extra.data.body_len];
+ const body: []const Air.Inst.Index = @ptrCast(self.air.extra[extra.end..][0..extra.data.body_len]);
try self.genBody(body);
for (self.blocks.getPtr(inst).?.relocs.items) |reloc| try self.performReloc(reloc);
@@ -2093,7 +2093,7 @@ fn airBlock(self: *Self, inst: Air.Inst.Index) !void {
}
fn airSwitch(self: *Self, inst: Air.Inst.Index) !void {
- const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const condition = pl_op.operand;
_ = condition;
return self.fail("TODO airSwitch for {}", .{self.target.cpu.arch});
@@ -2109,13 +2109,13 @@ fn performReloc(self: *Self, reloc: Reloc) !void {
}
fn airBr(self: *Self, inst: Air.Inst.Index) !void {
- const branch = self.air.instructions.items(.data)[inst].br;
+ const branch = self.air.instructions.items(.data)[@intFromEnum(inst)].br;
try self.br(branch.block_inst, branch.operand);
return self.finishAir(inst, .dead, .{ branch.operand, .none, .none });
}
fn airBoolOp(self: *Self, inst: Air.Inst.Index) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const air_tags = self.air.instructions.items(.tag);
_ = air_tags;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement boolean operations for {}", .{self.target.cpu.arch});
@@ -2148,14 +2148,14 @@ fn brVoid(self: *Self, block: Air.Inst.Index) !void {
}
fn airAsm(self: *Self, inst: Air.Inst.Index) !void {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.Asm, ty_pl.payload);
const is_volatile = @as(u1, @truncate(extra.data.flags >> 31)) != 0;
- const clobbers_len = @as(u31, @truncate(extra.data.flags));
+ const clobbers_len: u31 = @truncate(extra.data.flags);
var extra_i: usize = extra.end;
- const outputs = @as([]const Air.Inst.Ref, @ptrCast(self.air.extra[extra_i..][0..extra.data.outputs_len]));
+ const outputs: []const Air.Inst.Ref = @ptrCast(self.air.extra[extra_i..][0..extra.data.outputs_len]);
extra_i += outputs.len;
- const inputs = @as([]const Air.Inst.Ref, @ptrCast(self.air.extra[extra_i..][0..extra.data.inputs_len]));
+ const inputs: []const Air.Inst.Ref = @ptrCast(self.air.extra[extra_i..][0..extra.data.inputs_len]);
extra_i += inputs.len;
const dead = !is_volatile and self.liveness.isUnused(inst);
@@ -2300,20 +2300,20 @@ fn genSetReg(self: *Self, ty: Type, reg: Register, mcv: MCValue) InnerError!void
return self.genSetReg(ty, reg, .{ .immediate = 0xaaaaaaaaaaaaaaaa });
},
.immediate => |unsigned_x| {
- const x = @as(i64, @bitCast(unsigned_x));
+ const x: i64 = @bitCast(unsigned_x);
if (math.minInt(i12) <= x and x <= math.maxInt(i12)) {
_ = try self.addInst(.{
.tag = .addi,
.data = .{ .i_type = .{
.rd = reg,
.rs1 = .zero,
- .imm12 = @as(i12, @intCast(x)),
+ .imm12 = @intCast(x),
} },
});
} else if (math.minInt(i32) <= x and x <= math.maxInt(i32)) {
- const lo12 = @as(i12, @truncate(x));
+ const lo12: i12 = @truncate(x);
const carry: i32 = if (lo12 < 0) 1 else 0;
- const hi20 = @as(i20, @truncate((x >> 12) +% carry));
+ const hi20: i20 = @truncate((x >> 12) +% carry);
// TODO: add test case for 32-bit immediate
_ = try self.addInst(.{
@@ -2373,13 +2373,13 @@ fn genSetReg(self: *Self, ty: Type, reg: Register, mcv: MCValue) InnerError!void
}
fn airIntFromPtr(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const result = try self.resolveInst(un_op);
return self.finishAir(inst, result, .{ un_op, .none, .none });
}
fn airBitCast(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result = if (self.liveness.isUnused(inst)) .dead else result: {
const operand = try self.resolveInst(ty_op.operand);
if (self.reuseOperand(inst, ty_op.operand, 0, operand)) break :result operand;
@@ -2398,7 +2398,7 @@ fn airBitCast(self: *Self, inst: Air.Inst.Index) !void {
}
fn airArrayToSlice(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airArrayToSlice for {}", .{
self.target.cpu.arch,
});
@@ -2406,7 +2406,7 @@ fn airArrayToSlice(self: *Self, inst: Air.Inst.Index) !void {
}
fn airFloatFromInt(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airFloatFromInt for {}", .{
self.target.cpu.arch,
});
@@ -2414,7 +2414,7 @@ fn airFloatFromInt(self: *Self, inst: Air.Inst.Index) !void {
}
fn airIntFromFloat(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airIntFromFloat for {}", .{
self.target.cpu.arch,
});
@@ -2422,7 +2422,7 @@ fn airIntFromFloat(self: *Self, inst: Air.Inst.Index) !void {
}
fn airCmpxchg(self: *Self, inst: Air.Inst.Index) !void {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.Block, ty_pl.payload);
_ = extra;
return self.fail("TODO implement airCmpxchg for {}", .{
@@ -2463,7 +2463,7 @@ fn airMemcpy(self: *Self, inst: Air.Inst.Index) !void {
}
fn airTagName(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try self.resolveInst(un_op);
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else {
_ = operand;
@@ -2473,7 +2473,7 @@ fn airTagName(self: *Self, inst: Air.Inst.Index) !void {
}
fn airErrorName(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try self.resolveInst(un_op);
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else {
_ = operand;
@@ -2483,26 +2483,26 @@ fn airErrorName(self: *Self, inst: Air.Inst.Index) !void {
}
fn airSplat(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airSplat for riscv64", .{});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airSelect(self: *Self, inst: Air.Inst.Index) !void {
- const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const extra = self.air.extraData(Air.Bin, pl_op.payload).data;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airSelect for riscv64", .{});
return self.finishAir(inst, result, .{ pl_op.operand, extra.lhs, extra.rhs });
}
fn airShuffle(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airShuffle for riscv64", .{});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airReduce(self: *Self, inst: Air.Inst.Index) !void {
- const reduce = self.air.instructions.items(.data)[inst].reduce;
+ const reduce = self.air.instructions.items(.data)[@intFromEnum(inst)].reduce;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airReduce for riscv64", .{});
return self.finishAir(inst, result, .{ reduce.operand, .none, .none });
}
@@ -2511,8 +2511,8 @@ fn airAggregateInit(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
const vector_ty = self.typeOfIndex(inst);
const len = vector_ty.vectorLen(mod);
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
- const elements = @as([]const Air.Inst.Ref, @ptrCast(self.air.extra[ty_pl.payload..][0..len]));
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
+ const elements: []const Air.Inst.Ref = @ptrCast(self.air.extra[ty_pl.payload..][0..len]);
const result: MCValue = res: {
if (self.liveness.isUnused(inst)) break :res MCValue.dead;
return self.fail("TODO implement airAggregateInit for riscv64", .{});
@@ -2531,7 +2531,7 @@ fn airAggregateInit(self: *Self, inst: Air.Inst.Index) !void {
}
fn airUnionInit(self: *Self, inst: Air.Inst.Index) !void {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.UnionInit, ty_pl.payload).data;
_ = extra;
return self.fail("TODO implement airUnionInit for riscv64", .{});
@@ -2539,12 +2539,12 @@ fn airUnionInit(self: *Self, inst: Air.Inst.Index) !void {
}
fn airPrefetch(self: *Self, inst: Air.Inst.Index) !void {
- const prefetch = self.air.instructions.items(.data)[inst].prefetch;
+ const prefetch = self.air.instructions.items(.data)[@intFromEnum(inst)].prefetch;
return self.finishAir(inst, MCValue.dead, .{ prefetch.ptr, .none, .none });
}
fn airMulAdd(self: *Self, inst: Air.Inst.Index) !void {
- const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const extra = self.air.extraData(Air.Bin, pl_op.payload).data;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else {
return self.fail("TODO implement airMulAdd for riscv64", .{});
@@ -2560,7 +2560,7 @@ fn resolveInst(self: *Self, inst: Air.Inst.Ref) InnerError!MCValue {
if (!inst_ty.hasRuntimeBits(mod))
return MCValue{ .none = {} };
- const inst_index = Air.refToIndex(inst) orelse return self.genTypedValue(.{
+ const inst_index = inst.toIndex() orelse return self.genTypedValue(.{
.ty = inst_ty,
.val = (try self.air.value(inst, mod)).?,
});
@@ -2656,7 +2656,7 @@ fn resolveCallingConventionValues(self: *Self, fn_ty: Type) !CallMCValues {
const argument_registers = [_]Register{ .a0, .a1, .a2, .a3, .a4, .a5, .a6, .a7 };
for (fn_info.param_types.get(ip), result.args) |ty, *result_arg| {
- const param_size = @as(u32, @intCast(Type.fromInterned(ty).abiSize(mod)));
+ const param_size: u32 = @intCast(Type.fromInterned(ty).abiSize(mod));
if (param_size <= 8) {
if (next_register < argument_registers.len) {
result_arg.* = .{ .register = argument_registers[next_register] };
@@ -2693,7 +2693,7 @@ fn resolveCallingConventionValues(self: *Self, fn_ty: Type) !CallMCValues {
} else switch (cc) {
.Naked => unreachable,
.Unspecified, .C => {
- const ret_ty_size = @as(u32, @intCast(ret_ty.abiSize(mod)));
+ const ret_ty_size: u32 = @intCast(ret_ty.abiSize(mod));
if (ret_ty_size <= 8) {
result.return_value = .{ .register = .a0 };
} else if (ret_ty_size <= 16) {
src/arch/sparc64/CodeGen.zig
@@ -243,7 +243,7 @@ const BigTomb = struct {
fn feed(bt: *BigTomb, op_ref: Air.Inst.Ref) void {
const dies = bt.lbt.feed();
- const op_index = Air.refToIndex(op_ref) orelse return;
+ const op_index = op_ref.toIndex() orelse return;
if (!dies) return;
bt.function.processDeath(op_index);
}
@@ -504,7 +504,7 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
const old_air_bookkeeping = self.air_bookkeeping;
try self.ensureProcessDeathCapacity(Liveness.bpi);
- switch (air_tags[inst]) {
+ switch (air_tags[@intFromEnum(inst)]) {
// zig fmt: off
.ptr_add => try self.airPtrArithmetic(inst, .ptr_add),
.ptr_sub => try self.airPtrArithmetic(inst, .ptr_sub),
@@ -746,21 +746,21 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
if (std.debug.runtime_safety) {
if (self.air_bookkeeping < old_air_bookkeeping + 1) {
- std.debug.panic("in codegen.zig, handling of AIR instruction %{d} ('{}') did not do proper bookkeeping. Look for a missing call to finishAir.", .{ inst, air_tags[inst] });
+ std.debug.panic("in codegen.zig, handling of AIR instruction %{d} ('{}') did not do proper bookkeeping. Look for a missing call to finishAir.", .{ inst, air_tags[@intFromEnum(inst)] });
}
}
}
}
fn airAddSat(self: *Self, inst: Air.Inst.Index) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement add_sat for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
}
fn airAddSubWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
- const tag = self.air.instructions.items(.tag)[inst];
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const tag = self.air.instructions.items(.tag)[@intFromEnum(inst)];
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.Bin, ty_pl.payload).data;
const mod = self.bin_file.options.module.?;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
@@ -843,7 +843,7 @@ fn airAggregateInit(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
const vector_ty = self.typeOfIndex(inst);
const len = vector_ty.vectorLen(mod);
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const elements = @as([]const Air.Inst.Ref, @ptrCast(self.air.extra[ty_pl.payload..][0..len]));
const result: MCValue = res: {
if (self.liveness.isUnused(inst)) break :res MCValue.dead;
@@ -868,14 +868,14 @@ fn airAlloc(self: *Self, inst: Air.Inst.Index) !void {
}
fn airArrayElemVal(self: *Self, inst: Air.Inst.Index) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement array_elem_val for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
}
fn airArrayToSlice(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const ptr_ty = self.typeOf(ty_op.operand);
const ptr = try self.resolveInst(ty_op.operand);
@@ -891,7 +891,7 @@ fn airArrayToSlice(self: *Self, inst: Air.Inst.Index) !void {
}
fn airAsm(self: *Self, inst: Air.Inst.Index) !void {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.Asm, ty_pl.payload);
const is_volatile = (extra.data.flags & 0x80000000) != 0;
const clobbers_len = @as(u31, @truncate(extra.data.flags));
@@ -1047,7 +1047,7 @@ fn airArg(self: *Self, inst: Air.Inst.Index) !void {
}
fn airAtomicLoad(self: *Self, inst: Air.Inst.Index) !void {
- _ = self.air.instructions.items(.data)[inst].atomic_load;
+ _ = self.air.instructions.items(.data)[@intFromEnum(inst)].atomic_load;
return self.fail("TODO implement airAtomicLoad for {}", .{
self.target.cpu.arch,
@@ -1055,7 +1055,7 @@ fn airAtomicLoad(self: *Self, inst: Air.Inst.Index) !void {
}
fn airAtomicRmw(self: *Self, inst: Air.Inst.Index) !void {
- _ = self.air.instructions.items(.data)[inst].pl_op;
+ _ = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
return self.fail("TODO implement airAtomicRmw for {}", .{
self.target.cpu.arch,
@@ -1063,7 +1063,7 @@ fn airAtomicRmw(self: *Self, inst: Air.Inst.Index) !void {
}
fn airBinOp(self: *Self, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const lhs = try self.resolveInst(bin_op.lhs);
const rhs = try self.resolveInst(bin_op.rhs);
const lhs_ty = self.typeOf(bin_op.lhs);
@@ -1080,14 +1080,14 @@ fn airBinOp(self: *Self, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void {
}
fn airIntFromBool(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try self.resolveInst(un_op);
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else operand;
return self.finishAir(inst, result, .{ un_op, .none, .none });
}
fn airPtrArithmetic(self: *Self, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
const lhs = try self.resolveInst(bin_op.lhs);
const rhs = try self.resolveInst(bin_op.rhs);
@@ -1105,7 +1105,7 @@ fn airPtrArithmetic(self: *Self, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void
}
fn airBitCast(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result = if (self.liveness.isUnused(inst)) .dead else result: {
const operand = try self.resolveInst(ty_op.operand);
if (self.reuseOperand(inst, ty_op.operand, 0, operand)) break :result operand;
@@ -1125,7 +1125,7 @@ fn airBitCast(self: *Self, inst: Air.Inst.Index) !void {
}
fn airBitReverse(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airBitReverse for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
@@ -1143,9 +1143,9 @@ fn airBlock(self: *Self, inst: Air.Inst.Index) !void {
});
defer self.blocks.getPtr(inst).?.relocs.deinit(self.gpa);
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.Block, ty_pl.payload);
- const body = self.air.extra[extra.end..][0..extra.data.body_len];
+ const body: []const Air.Inst.Index = @ptrCast(self.air.extra[extra.end..][0..extra.data.body_len]);
try self.genBody(body);
// relocations for `bpcc` instructions
@@ -1170,7 +1170,7 @@ fn airBlock(self: *Self, inst: Air.Inst.Index) !void {
}
fn airBr(self: *Self, inst: Air.Inst.Index) !void {
- const branch = self.air.instructions.items(.data)[inst].br;
+ const branch = self.air.instructions.items(.data)[@intFromEnum(inst)].br;
try self.br(branch.block_inst, branch.operand);
return self.finishAir(inst, .dead, .{ branch.operand, .none, .none });
}
@@ -1207,7 +1207,7 @@ fn airBreakpoint(self: *Self) !void {
fn airByteSwap(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
// We have hardware byteswapper in SPARCv9, don't let mainstream compilers mislead you.
// That being said, the strategy to lower this is:
@@ -1293,7 +1293,7 @@ fn airByteSwap(self: *Self, inst: Air.Inst.Index) !void {
fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier) !void {
if (modifier == .always_tail) return self.fail("TODO implement tail calls for {}", .{self.target.cpu.arch});
- const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const callee = pl_op.operand;
const extra = self.air.extraData(Air.Call, pl_op.payload);
const args = @as([]const Air.Inst.Ref, @ptrCast(self.air.extra[extra.end .. extra.end + extra.data.args_len]));
@@ -1423,13 +1423,13 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier
}
fn airClz(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airClz for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airCmp(self: *Self, inst: Air.Inst.Index, op: math.CompareOperator) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const mod = self.bin_file.options.module.?;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const lhs = try self.resolveInst(bin_op.lhs);
@@ -1486,7 +1486,7 @@ fn airCmp(self: *Self, inst: Air.Inst.Index, op: math.CompareOperator) !void {
}
fn airCmpLtErrorsLen(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try self.resolveInst(un_op);
_ = operand;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airCmpLtErrorsLen for {}", .{self.target.cpu.arch});
@@ -1494,7 +1494,7 @@ fn airCmpLtErrorsLen(self: *Self, inst: Air.Inst.Index) !void {
}
fn airCmpxchg(self: *Self, inst: Air.Inst.Index) !void {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.Block, ty_pl.payload);
_ = extra;
@@ -1504,11 +1504,11 @@ fn airCmpxchg(self: *Self, inst: Air.Inst.Index) !void {
}
fn airCondBr(self: *Self, inst: Air.Inst.Index) !void {
- const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const condition = try 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 then_body: []const Air.Inst.Index = @ptrCast(self.air.extra[extra.end..][0..extra.data.then_body_len]);
+ const else_body: []const Air.Inst.Index = @ptrCast(self.air.extra[extra.end + then_body.len ..][0..extra.data.else_body_len]);
const liveness_condbr = self.liveness.getCondBr(inst);
// Here we emit a branch to the false section.
@@ -1518,7 +1518,7 @@ fn airCondBr(self: *Self, inst: Air.Inst.Index) !void {
// that death now instead of later as this has an effect on
// whether it needs to be spilled in the branches
if (self.liveness.operandDies(inst, 0)) {
- if (Air.refToIndex(pl_op.operand)) |op_index| {
+ if (pl_op.operand.toIndex()) |op_index| {
self.processDeath(op_index);
}
}
@@ -1650,7 +1650,7 @@ fn airCondBr(self: *Self, inst: Air.Inst.Index) !void {
}
fn airCtz(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airCtz for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
@@ -1661,7 +1661,7 @@ fn airDbgBlock(self: *Self, inst: Air.Inst.Index) !void {
}
fn airDbgInline(self: *Self, inst: Air.Inst.Index) !void {
- const ty_fn = self.air.instructions.items(.data)[inst].ty_fn;
+ const ty_fn = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_fn;
const mod = self.bin_file.options.module.?;
const func = mod.funcInfo(ty_fn.func);
// TODO emit debug info for function change
@@ -1670,7 +1670,7 @@ fn airDbgInline(self: *Self, inst: Air.Inst.Index) !void {
}
fn airDbgStmt(self: *Self, inst: Air.Inst.Index) !void {
- const dbg_stmt = self.air.instructions.items(.data)[inst].dbg_stmt;
+ const dbg_stmt = self.air.instructions.items(.data)[@intFromEnum(inst)].dbg_stmt;
_ = try self.addInst(.{
.tag = .dbg_line,
@@ -1686,7 +1686,7 @@ fn airDbgStmt(self: *Self, inst: Air.Inst.Index) !void {
}
fn airDbgVar(self: *Self, inst: Air.Inst.Index) !void {
- const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const name = self.air.nullTerminatedString(pl_op.payload);
const operand = pl_op.operand;
// TODO emit debug info for this variable
@@ -1695,13 +1695,13 @@ fn airDbgVar(self: *Self, inst: Air.Inst.Index) !void {
}
fn airDiv(self: *Self, inst: Air.Inst.Index) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement div for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
}
fn airErrorName(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try self.resolveInst(un_op);
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else {
_ = operand;
@@ -1711,14 +1711,14 @@ fn airErrorName(self: *Self, inst: Air.Inst.Index) !void {
}
fn airErrUnionPayloadPtrSet(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement .errunion_payload_ptr_set for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airFence(self: *Self, inst: Air.Inst.Index) !void {
// TODO weaken this as needed, currently this implements the strongest membar form
- const fence = self.air.instructions.items(.data)[inst].fence;
+ const fence = self.air.instructions.items(.data)[@intFromEnum(inst)].fence;
_ = fence;
// membar #StoreStore | #LoadStore | #StoreLoad | #LoadLoad
@@ -1740,7 +1740,7 @@ fn airFence(self: *Self, inst: Air.Inst.Index) !void {
}
fn airIntFromFloat(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airIntFromFloat for {}", .{
self.target.cpu.arch,
});
@@ -1748,13 +1748,13 @@ fn airIntFromFloat(self: *Self, inst: Air.Inst.Index) !void {
}
fn airGetUnionTag(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airGetUnionTag for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airIntCast(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
if (self.liveness.isUnused(inst))
return self.finishAir(inst, .dead, .{ ty_op.operand, .none, .none });
@@ -1773,7 +1773,7 @@ fn airIntCast(self: *Self, inst: Air.Inst.Index) !void {
}
fn airFloatFromInt(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airFloatFromInt for {}", .{
self.target.cpu.arch,
});
@@ -1781,7 +1781,7 @@ fn airFloatFromInt(self: *Self, inst: Air.Inst.Index) !void {
}
fn airIsErr(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const operand = try self.resolveInst(un_op);
const ty = self.typeOf(un_op);
@@ -1791,7 +1791,7 @@ fn airIsErr(self: *Self, inst: Air.Inst.Index) !void {
}
fn airIsNonErr(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const operand = try self.resolveInst(un_op);
const ty = self.typeOf(un_op);
@@ -1801,7 +1801,7 @@ fn airIsNonErr(self: *Self, inst: Air.Inst.Index) !void {
}
fn airIsNull(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const operand = try self.resolveInst(un_op);
break :result try self.isNull(operand);
@@ -1810,7 +1810,7 @@ fn airIsNull(self: *Self, inst: Air.Inst.Index) !void {
}
fn airIsNonNull(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const operand = try self.resolveInst(un_op);
break :result try self.isNonNull(operand);
@@ -1820,7 +1820,7 @@ fn airIsNonNull(self: *Self, inst: Air.Inst.Index) !void {
fn airLoad(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const elem_ty = self.typeOfIndex(inst);
const elem_size = elem_ty.abiSize(mod);
const result: MCValue = result: {
@@ -1851,9 +1851,9 @@ fn airLoad(self: *Self, inst: Air.Inst.Index) !void {
fn airLoop(self: *Self, inst: Air.Inst.Index) !void {
// A loop is a setup to be able to jump back to the beginning.
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const loop = self.air.extraData(Air.Block, ty_pl.payload);
- const body = self.air.extra[loop.end .. loop.end + loop.data.body_len];
+ const body: []const Air.Inst.Index = @ptrCast(self.air.extra[loop.end .. loop.end + loop.data.body_len]);
const start = @as(u32, @intCast(self.mir_instructions.len));
try self.genBody(body);
@@ -1868,7 +1868,7 @@ fn airMemset(self: *Self, inst: Air.Inst.Index, safety: bool) !void {
} else {
// TODO if the value is undef, don't lower this instruction
}
- const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const extra = self.air.extraData(Air.Bin, pl_op.payload);
const operand = pl_op.operand;
@@ -1882,8 +1882,8 @@ fn airMemset(self: *Self, inst: Air.Inst.Index, safety: bool) !void {
}
fn airMinMax(self: *Self, inst: Air.Inst.Index) !void {
- const tag = self.air.instructions.items(.tag)[inst];
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const tag = self.air.instructions.items(.tag)[@intFromEnum(inst)];
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const lhs = try self.resolveInst(bin_op.lhs);
const rhs = try self.resolveInst(bin_op.rhs);
const lhs_ty = self.typeOf(bin_op.lhs);
@@ -1898,7 +1898,7 @@ fn airMinMax(self: *Self, inst: Air.Inst.Index) !void {
}
fn airMod(self: *Self, inst: Air.Inst.Index) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const lhs = try self.resolveInst(bin_op.lhs);
const rhs = try self.resolveInst(bin_op.rhs);
const lhs_ty = self.typeOf(bin_op.lhs);
@@ -2036,14 +2036,14 @@ fn airMod(self: *Self, inst: Air.Inst.Index) !void {
}
fn airMulSat(self: *Self, inst: Air.Inst.Index) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement mul_sat for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
}
fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
- //const tag = self.air.instructions.items(.tag)[inst];
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ //const tag = self.air.instructions.items(.tag)[@intFromEnum(inst)];
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.Bin, ty_pl.payload).data;
const mod = self.bin_file.options.module.?;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
@@ -2108,7 +2108,7 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
}
fn airNot(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const mod = self.bin_file.options.module.?;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const operand = try self.resolveInst(ty_op.operand);
@@ -2204,51 +2204,51 @@ fn airNot(self: *Self, inst: Air.Inst.Index) !void {
}
fn airOptionalPayload(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement .optional_payload for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airOptionalPayloadPtr(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement .optional_payload_ptr for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airOptionalPayloadPtrSet(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement .optional_payload_ptr_set for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airPopcount(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airPopcount for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airPrefetch(self: *Self, inst: Air.Inst.Index) !void {
- const prefetch = self.air.instructions.items(.data)[inst].prefetch;
+ const prefetch = self.air.instructions.items(.data)[@intFromEnum(inst)].prefetch;
// TODO Emit a PREFETCH/IPREFETCH as necessary, see A.7 and A.42
return self.finishAir(inst, MCValue.dead, .{ prefetch.ptr, .none, .none });
}
fn airPtrElemVal(self: *Self, inst: Air.Inst.Index) !void {
const is_volatile = false; // TODO
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const result: MCValue = if (!is_volatile and self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement ptr_elem_val for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
}
fn airPtrElemPtr(self: *Self, inst: Air.Inst.Index) !void {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.Bin, ty_pl.payload).data;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement ptr_elem_ptr for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ extra.lhs, extra.rhs, .none });
}
fn airPtrSliceLenPtr(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const ptr_bits = self.target.ptrBitWidth();
const ptr_bytes = @divExact(ptr_bits, 8);
@@ -2265,7 +2265,7 @@ fn airPtrSliceLenPtr(self: *Self, inst: Air.Inst.Index) !void {
}
fn airPtrSlicePtrPtr(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const mcv = try self.resolveInst(ty_op.operand);
switch (mcv) {
@@ -2280,13 +2280,13 @@ fn airPtrSlicePtrPtr(self: *Self, inst: Air.Inst.Index) !void {
}
fn airIntFromPtr(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const result = try self.resolveInst(un_op);
return self.finishAir(inst, result, .{ un_op, .none, .none });
}
fn airRem(self: *Self, inst: Air.Inst.Index) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const lhs = try self.resolveInst(bin_op.lhs);
const rhs = try self.resolveInst(bin_op.rhs);
const lhs_ty = self.typeOf(bin_op.lhs);
@@ -2307,14 +2307,14 @@ fn airRem(self: *Self, inst: Air.Inst.Index) !void {
}
fn airRet(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try self.resolveInst(un_op);
try self.ret(operand);
return self.finishAir(inst, .dead, .{ un_op, .none, .none });
}
fn airRetLoad(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const ptr = try self.resolveInst(un_op);
_ = ptr;
return self.fail("TODO implement airRetLoad for {}", .{self.target.cpu.arch});
@@ -2327,19 +2327,19 @@ fn airRetPtr(self: *Self, inst: Air.Inst.Index) !void {
}
fn airSetUnionTag(self: *Self, inst: Air.Inst.Index) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
_ = bin_op;
return self.fail("TODO implement airSetUnionTag for {}", .{self.target.cpu.arch});
}
fn airShlSat(self: *Self, inst: Air.Inst.Index) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement shl_sat for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
}
fn airShlWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.Bin, ty_pl.payload).data;
const mod = self.bin_file.options.module.?;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
@@ -2429,7 +2429,7 @@ fn airShlWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
}
fn airSlice(self: *Self, inst: Air.Inst.Index) !void {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const ptr = try self.resolveInst(bin_op.lhs);
@@ -2448,7 +2448,7 @@ fn airSlice(self: *Self, inst: Air.Inst.Index) !void {
fn airSliceElemVal(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
const is_volatile = false; // TODO
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
if (!is_volatile and self.liveness.isUnused(inst)) return self.finishAir(inst, .dead, .{ bin_op.lhs, bin_op.rhs, .none });
const result: MCValue = result: {
@@ -2490,7 +2490,7 @@ fn airSliceElemVal(self: *Self, inst: Air.Inst.Index) !void {
}
fn airSliceLen(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const ptr_bits = self.target.ptrBitWidth();
const ptr_bytes = @divExact(ptr_bits, 8);
@@ -2511,7 +2511,7 @@ fn airSliceLen(self: *Self, inst: Air.Inst.Index) !void {
}
fn airSlicePtr(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const mcv = try self.resolveInst(ty_op.operand);
switch (mcv) {
@@ -2530,7 +2530,7 @@ fn airSlicePtr(self: *Self, inst: Air.Inst.Index) !void {
}
fn airSplat(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airSplat for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
@@ -2541,7 +2541,7 @@ fn airStore(self: *Self, inst: Air.Inst.Index, safety: bool) !void {
} else {
// TODO if the value is undef, don't lower this instruction
}
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const ptr = try self.resolveInst(bin_op.lhs);
const value = try self.resolveInst(bin_op.rhs);
const ptr_ty = self.typeOf(bin_op.lhs);
@@ -2553,20 +2553,20 @@ fn airStore(self: *Self, inst: Air.Inst.Index, safety: bool) !void {
}
fn airStructFieldPtr(self: *Self, inst: Air.Inst.Index) !void {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.StructField, ty_pl.payload).data;
const result = try self.structFieldPtr(inst, extra.struct_operand, extra.field_index);
return self.finishAir(inst, result, .{ extra.struct_operand, .none, .none });
}
fn airStructFieldPtrIndex(self: *Self, inst: Air.Inst.Index, index: u8) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result = try self.structFieldPtr(inst, ty_op.operand, index);
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) !void {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.StructField, ty_pl.payload).data;
const operand = extra.struct_operand;
const index = extra.field_index;
@@ -2636,7 +2636,7 @@ fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) !void {
}
fn airSubSat(self: *Self, inst: Air.Inst.Index) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement sub_sat for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
}
@@ -2647,7 +2647,7 @@ fn airSwitch(self: *Self, inst: Air.Inst.Index) !void {
}
fn airTagName(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try self.resolveInst(un_op);
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else {
_ = operand;
@@ -2657,7 +2657,7 @@ fn airTagName(self: *Self, inst: Air.Inst.Index) !void {
}
fn airTrunc(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand = try self.resolveInst(ty_op.operand);
const operand_ty = self.typeOf(ty_op.operand);
const dest_ty = self.typeOfIndex(inst);
@@ -2670,9 +2670,9 @@ fn airTrunc(self: *Self, inst: Air.Inst.Index) !void {
}
fn airTry(self: *Self, inst: Air.Inst.Index) !void {
- const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const extra = self.air.extraData(Air.Try, pl_op.payload);
- const body = self.air.extra[extra.end..][0..extra.data.body_len];
+ const body: []const Air.Inst.Index = @ptrCast(self.air.extra[extra.end..][0..extra.data.body_len]);
const result: MCValue = result: {
const error_union_ty = self.typeOf(pl_op.operand);
const error_union = try self.resolveInst(pl_op.operand);
@@ -2688,7 +2688,7 @@ fn airTry(self: *Self, inst: Air.Inst.Index) !void {
}
fn airUnaryMath(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const result: MCValue = if (self.liveness.isUnused(inst))
.dead
else
@@ -2697,7 +2697,7 @@ fn airUnaryMath(self: *Self, inst: Air.Inst.Index) !void {
}
fn airUnionInit(self: *Self, inst: Air.Inst.Index) !void {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.UnionInit, ty_pl.payload).data;
_ = extra;
return self.fail("TODO implement airUnionInit for {}", .{self.target.cpu.arch});
@@ -2705,7 +2705,7 @@ fn airUnionInit(self: *Self, inst: Air.Inst.Index) !void {
fn airUnwrapErrErr(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const error_union_ty = self.typeOf(ty_op.operand);
const payload_ty = error_union_ty.errorUnionPayload(mod);
@@ -2719,7 +2719,7 @@ fn airUnwrapErrErr(self: *Self, inst: Air.Inst.Index) !void {
fn airUnwrapErrPayload(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const error_union_ty = self.typeOf(ty_op.operand);
const payload_ty = error_union_ty.errorUnionPayload(mod);
@@ -2733,9 +2733,9 @@ fn airUnwrapErrPayload(self: *Self, inst: Air.Inst.Index) !void {
/// E to E!T
fn airWrapErrUnionErr(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
- const error_union_ty = self.air.getRefType(ty_op.ty);
+ const error_union_ty = ty_op.ty.toType();
const payload_ty = error_union_ty.errorUnionPayload(mod);
const mcv = try self.resolveInst(ty_op.operand);
if (!payload_ty.hasRuntimeBits(mod)) break :result mcv;
@@ -2747,14 +2747,14 @@ fn airWrapErrUnionErr(self: *Self, inst: Air.Inst.Index) !void {
/// T to E!T
fn airWrapErrUnionPayload(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement wrap errunion payload for {}", .{self.target.cpu.arch});
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
fn airWrapOptional(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const optional_ty = self.typeOfIndex(inst);
@@ -2772,7 +2772,7 @@ fn airWrapOptional(self: *Self, inst: Air.Inst.Index) !void {
fn addInst(self: *Self, inst: Mir.Inst) error{OutOfMemory}!Mir.Inst.Index {
const gpa = self.gpa;
try self.mir_instructions.ensureUnusedCapacity(gpa, 1);
- const result_index = @as(Air.Inst.Index, @intCast(self.mir_instructions.len));
+ const result_index: Mir.Inst.Index = @intCast(self.mir_instructions.len);
self.mir_instructions.appendAssumeCapacity(inst);
return result_index;
}
@@ -3143,9 +3143,7 @@ fn binOpImmediate(
const lhs_reg = if (lhs_is_register) lhs.register else blk: {
const track_inst: ?Air.Inst.Index = if (metadata) |md| inst: {
- break :inst Air.refToIndex(
- if (lhs_and_rhs_swapped) md.rhs else md.lhs,
- ).?;
+ break :inst (if (lhs_and_rhs_swapped) md.rhs else md.lhs).toIndex().?;
} else null;
const reg = try self.register_manager.allocReg(track_inst, gp);
@@ -3284,7 +3282,7 @@ fn binOpRegister(
const lhs_reg = if (lhs_is_register) lhs.register else blk: {
const track_inst: ?Air.Inst.Index = if (metadata) |md| inst: {
- break :inst Air.refToIndex(md.lhs).?;
+ break :inst md.lhs.toIndex().?;
} else null;
const reg = try self.register_manager.allocReg(track_inst, gp);
@@ -3308,7 +3306,7 @@ fn binOpRegister(
const rhs_reg = if (rhs_is_register) rhs.register else blk: {
const track_inst: ?Air.Inst.Index = if (metadata) |md| inst: {
- break :inst Air.refToIndex(md.rhs).?;
+ break :inst md.rhs.toIndex().?;
} else null;
const reg = try self.register_manager.allocReg(track_inst, gp);
@@ -3566,7 +3564,7 @@ fn finishAir(self: *Self, inst: Air.Inst.Index, result: MCValue, operands: [Live
const dies = @as(u1, @truncate(tomb_bits)) != 0;
tomb_bits >>= 1;
if (!dies) continue;
- const op_index = Air.refToIndex(op) orelse continue;
+ const op_index = op.toIndex() orelse continue;
self.processDeath(op_index);
}
const is_used = @as(u1, @truncate(tomb_bits)) == 0;
@@ -3594,8 +3592,8 @@ fn finishAir(self: *Self, inst: Air.Inst.Index, result: MCValue, operands: [Live
fn genArgDbgInfo(self: Self, inst: Air.Inst.Index, mcv: MCValue) !void {
const mod = self.bin_file.options.module.?;
- const arg = self.air.instructions.items(.data)[inst].arg;
- const ty = self.air.getRefType(arg.ty);
+ const arg = self.air.instructions.items(.data)[@intFromEnum(inst)].arg;
+ const ty = arg.ty.toType();
const owner_decl = mod.funcOwnerDeclIndex(self.func_index);
const name = mod.getParamName(self.func_index, arg.src_index);
@@ -4411,8 +4409,8 @@ fn parseRegName(name: []const u8) ?Register {
fn performReloc(self: *Self, inst: Mir.Inst.Index) !void {
const tag = self.mir_instructions.items(.tag)[inst];
switch (tag) {
- .bpcc => self.mir_instructions.items(.data)[inst].branch_predict_int.inst = @as(Mir.Inst.Index, @intCast(self.mir_instructions.len)),
- .bpr => self.mir_instructions.items(.data)[inst].branch_predict_reg.inst = @as(Mir.Inst.Index, @intCast(self.mir_instructions.len)),
+ .bpcc => self.mir_instructions.items(.data)[inst].branch_predict_int.inst = @intCast(self.mir_instructions.len),
+ .bpr => self.mir_instructions.items(.data)[inst].branch_predict_reg.inst = @intCast(self.mir_instructions.len),
else => unreachable,
}
}
@@ -4550,7 +4548,7 @@ fn resolveInst(self: *Self, ref: Air.Inst.Ref) InnerError!MCValue {
// If the type has no codegen bits, no need to store it.
if (!ty.hasRuntimeBitsIgnoreComptime(mod)) return .none;
- if (Air.refToIndex(ref)) |inst| {
+ if (ref.toIndex()) |inst| {
return self.getResolvedInstValue(inst);
}
@@ -4606,7 +4604,7 @@ fn reuseOperand(self: *Self, inst: Air.Inst.Index, operand: Air.Inst.Ref, op_ind
// That makes us responsible for doing the rest of the stuff that processDeath would have done.
const branch = &self.branch_stack.items[self.branch_stack.items.len - 1];
- branch.inst_table.putAssumeCapacity(Air.refToIndex(operand).?, .dead);
+ branch.inst_table.putAssumeCapacity(operand.toIndex().?, .dead);
return true;
}
@@ -4767,7 +4765,7 @@ fn trunc(
defer if (lock) |reg| self.register_manager.unlockReg(reg);
const dest_reg = if (maybe_inst) |inst| blk: {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
if (operand == .register and self.reuseOperand(inst, ty_op.operand, 0, operand)) {
break :blk operand_reg;
src/arch/wasm/CodeGen.zig
@@ -828,7 +828,7 @@ fn finishAir(func: *CodeGen, inst: Air.Inst.Index, result: WValue, operands: []c
if (result != .none) {
assert(result != .stack); // it's illegal to store a stack value as we cannot track its position
const branch = func.currentBranch();
- branch.values.putAssumeCapacityNoClobber(Air.indexToRef(inst), result);
+ branch.values.putAssumeCapacityNoClobber(inst.toRef(), result);
}
if (builtin.mode == .Debug) {
@@ -864,7 +864,7 @@ const BigTomb = struct {
fn finishAir(bt: *BigTomb, result: WValue) void {
assert(result != .stack);
if (result != .none) {
- bt.gen.currentBranch().values.putAssumeCapacityNoClobber(Air.indexToRef(bt.inst), result);
+ bt.gen.currentBranch().values.putAssumeCapacityNoClobber(bt.inst.toRef(), result);
}
if (builtin.mode == .Debug) {
@@ -883,7 +883,7 @@ fn iterateBigTomb(func: *CodeGen, inst: Air.Inst.Index, operand_count: usize) !B
}
fn processDeath(func: *CodeGen, ref: Air.Inst.Ref) void {
- if (Air.refToIndex(ref) == null) return;
+ if (ref.toIndex() == null) return;
// Branches are currently only allowed to free locals allocated
// within their own branch.
// TODO: Upon branch consolidation free any locals if needed.
@@ -893,7 +893,7 @@ fn processDeath(func: *CodeGen, ref: Air.Inst.Ref) void {
if (value.local.value < reserved_indexes) {
return; // function arguments can never be re-used
}
- log.debug("Decreasing reference for ref: %{?d}, using local '{d}'", .{ Air.refToIndex(ref), value.local.value });
+ log.debug("Decreasing reference for ref: %{d}, using local '{d}'", .{ @intFromEnum(ref.toIndex().?), value.local.value });
value.local.references -= 1; // if this panics, a call to `reuseOperand` was forgotten by the developer
if (value.local.references == 0) {
value.free(func);
@@ -1265,7 +1265,7 @@ fn genFunc(func: *CodeGen) InnerError!void {
// In case we have a return value, but the last instruction is a noreturn (such as a while loop)
// we emit an unreachable instruction to tell the stack validator that part will never be reached.
if (func_type.returns.len != 0 and func.air.instructions.len > 0) {
- const inst = @as(u32, @intCast(func.air.instructions.len - 1));
+ const inst: Air.Inst.Index = @enumFromInt(func.air.instructions.len - 1);
const last_inst_ty = func.typeOfIndex(inst);
if (!last_inst_ty.hasRuntimeBitsIgnoreComptime(mod) or last_inst_ty.isNoReturn(mod)) {
try func.addTag(.@"unreachable");
@@ -1828,7 +1828,7 @@ fn buildPointerOffset(func: *CodeGen, ptr_value: WValue, offset: u64, action: en
fn genInst(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
const air_tags = func.air.instructions.items(.tag);
- return switch (air_tags[inst]) {
+ return switch (air_tags[@intFromEnum(inst)]) {
.inferred_alloc, .inferred_alloc_comptime => unreachable,
.add => func.airBinOp(inst, .add),
@@ -2086,7 +2086,7 @@ fn genBody(func: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
if (builtin.mode == .Debug and func.air_bookkeeping < old_bookkeeping_value + 1) {
std.debug.panic("Missing call to `finishAir` in AIR instruction %{d} ('{}')", .{
inst,
- func.air.instructions.items(.tag)[inst],
+ func.air.instructions.items(.tag)[@intFromEnum(inst)],
});
}
}
@@ -2094,7 +2094,7 @@ fn genBody(func: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
fn airRet(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
const mod = func.bin_file.base.options.module.?;
- const un_op = func.air.instructions.items(.data)[inst].un_op;
+ const un_op = func.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try func.resolveInst(un_op);
const fn_info = mod.typeToFunc(func.decl.ty).?;
const ret_ty = Type.fromInterned(fn_info.return_type);
@@ -2157,7 +2157,7 @@ fn airRetPtr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
fn airRetLoad(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
const mod = func.bin_file.base.options.module.?;
- const un_op = func.air.instructions.items(.data)[inst].un_op;
+ const un_op = func.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try func.resolveInst(un_op);
const ret_ty = func.typeOf(un_op).childType(mod);
@@ -2178,7 +2178,7 @@ fn airRetLoad(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
fn airCall(func: *CodeGen, inst: Air.Inst.Index, modifier: std.builtin.CallModifier) InnerError!void {
if (modifier == .always_tail) return func.fail("TODO implement tail calls for wasm", .{});
- const pl_op = func.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = func.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const extra = func.air.extraData(Air.Call, pl_op.payload);
const args = @as([]const Air.Inst.Ref, @ptrCast(func.air.extra[extra.end..][0..extra.data.args_len]));
const ty = func.typeOf(pl_op.operand);
@@ -2301,7 +2301,7 @@ fn airStore(func: *CodeGen, inst: Air.Inst.Index, safety: bool) InnerError!void
} else {
// TODO if the value is undef, don't lower this instruction
}
- const bin_op = func.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = func.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const lhs = try func.resolveInst(bin_op.lhs);
const rhs = try func.resolveInst(bin_op.rhs);
@@ -2457,9 +2457,9 @@ fn store(func: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, offset: u32) InnerE
fn airLoad(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
const mod = func.bin_file.base.options.module.?;
- const ty_op = func.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand = try func.resolveInst(ty_op.operand);
- const ty = func.air.getRefType(ty_op.ty);
+ const ty = ty_op.ty.toType();
const ptr_ty = func.typeOf(ty_op.operand);
const ptr_info = ptr_ty.ptrInfo(mod);
@@ -2569,7 +2569,7 @@ fn airArg(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
switch (func.debug_output) {
.dwarf => |dwarf| {
- const src_index = func.air.instructions.items(.data)[inst].arg.src_index;
+ const src_index = func.air.instructions.items(.data)[@intFromEnum(inst)].arg.src_index;
const name = mod.getParamName(func.func_index, src_index);
try dwarf.genArgDbgInfo(name, arg_ty, mod.funcOwnerDeclIndex(func.func_index), .{
.wasm_local = arg.local.value,
@@ -2583,7 +2583,7 @@ fn airArg(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
fn airBinOp(func: *CodeGen, inst: Air.Inst.Index, op: Op) InnerError!void {
const mod = func.bin_file.base.options.module.?;
- const bin_op = func.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = func.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const lhs = try func.resolveInst(bin_op.lhs);
const rhs = try func.resolveInst(bin_op.rhs);
const lhs_ty = func.typeOf(bin_op.lhs);
@@ -2789,7 +2789,7 @@ const FloatOp = enum {
fn airAbs(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
const mod = func.bin_file.base.options.module.?;
- const ty_op = func.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand = try func.resolveInst(ty_op.operand);
const ty = func.typeOf(ty_op.operand);
const scalar_ty = ty.scalarType(mod);
@@ -2864,7 +2864,7 @@ fn airAbs(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
}
fn airUnaryFloatOp(func: *CodeGen, inst: Air.Inst.Index, op: FloatOp) InnerError!void {
- const un_op = func.air.instructions.items(.data)[inst].un_op;
+ const un_op = func.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try func.resolveInst(un_op);
const ty = func.typeOf(un_op);
@@ -2980,7 +2980,7 @@ fn floatNeg(func: *CodeGen, ty: Type, arg: WValue) InnerError!WValue {
fn airWrapBinOp(func: *CodeGen, inst: Air.Inst.Index, op: Op) InnerError!void {
const mod = func.bin_file.base.options.module.?;
- const bin_op = func.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = func.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const lhs = try func.resolveInst(bin_op.lhs);
const rhs = try func.resolveInst(bin_op.rhs);
@@ -3473,11 +3473,11 @@ fn intStorageAsI32(storage: InternPool.Key.Int.Storage, mod: *Module) i32 {
fn airBlock(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
const mod = func.bin_file.base.options.module.?;
- const ty_pl = func.air.instructions.items(.data)[inst].ty_pl;
- const block_ty = func.air.getRefType(ty_pl.ty);
+ const ty_pl = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
+ const block_ty = ty_pl.ty.toType();
const wasm_block_ty = genBlockType(block_ty, mod);
const extra = func.air.extraData(Air.Block, ty_pl.payload);
- const body = func.air.extra[extra.end..][0..extra.data.body_len];
+ const body: []const Air.Inst.Index = @ptrCast(func.air.extra[extra.end..][0..extra.data.body_len]);
// if wasm_block_ty is non-empty, we create a register to store the temporary value
const block_result: WValue = if (wasm_block_ty != wasm.block_empty) blk: {
@@ -3518,9 +3518,9 @@ fn endBlock(func: *CodeGen) !void {
}
fn airLoop(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
- const ty_pl = func.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const loop = func.air.extraData(Air.Block, ty_pl.payload);
- const body = func.air.extra[loop.end..][0..loop.data.body_len];
+ const body: []const Air.Inst.Index = @ptrCast(func.air.extra[loop.end..][0..loop.data.body_len]);
// result type of loop is always 'noreturn', meaning we can always
// emit the wasm type 'block_empty'.
@@ -3535,11 +3535,11 @@ fn airLoop(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
}
fn airCondBr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
- const pl_op = func.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = func.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const condition = try func.resolveInst(pl_op.operand);
const extra = func.air.extraData(Air.CondBr, pl_op.payload);
- const then_body = func.air.extra[extra.end..][0..extra.data.then_body_len];
- const else_body = func.air.extra[extra.end + then_body.len ..][0..extra.data.else_body_len];
+ const then_body: []const Air.Inst.Index = @ptrCast(func.air.extra[extra.end..][0..extra.data.then_body_len]);
+ const else_body: []const Air.Inst.Index = @ptrCast(func.air.extra[extra.end + then_body.len ..][0..extra.data.else_body_len]);
const liveness_condbr = func.liveness.getCondBr(inst);
// result type is always noreturn, so use `block_empty` as type.
@@ -3579,7 +3579,7 @@ fn airCondBr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
}
fn airCmp(func: *CodeGen, inst: Air.Inst.Index, op: std.math.CompareOperator) InnerError!void {
- const bin_op = func.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = func.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const lhs = try func.resolveInst(bin_op.lhs);
const rhs = try func.resolveInst(bin_op.rhs);
@@ -3705,7 +3705,7 @@ fn airCmpVector(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
}
fn airCmpLtErrorsLen(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
- const un_op = func.air.instructions.items(.data)[inst].un_op;
+ const un_op = func.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try func.resolveInst(un_op);
const sym_index = try func.bin_file.getGlobalSymbol("__zig_errors_len", null);
const errors_len = WValue{ .memory = sym_index };
@@ -3721,7 +3721,7 @@ fn airCmpLtErrorsLen(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
fn airBr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
const mod = func.bin_file.base.options.module.?;
- const br = func.air.instructions.items(.data)[inst].br;
+ const br = func.air.instructions.items(.data)[@intFromEnum(inst)].br;
const block = func.blocks.get(br.block_inst).?;
// if operand has codegen bits we should break with a value
@@ -3743,7 +3743,7 @@ fn airBr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
}
fn airNot(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
- const ty_op = func.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand = try func.resolveInst(ty_op.operand);
const operand_ty = func.typeOf(ty_op.operand);
@@ -3809,7 +3809,7 @@ fn airUnreachable(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
}
fn airBitcast(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
- const ty_op = func.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result = result: {
const operand = try func.resolveInst(ty_op.operand);
const wanted_ty = func.typeOfIndex(inst);
@@ -3853,7 +3853,7 @@ fn bitcast(func: *CodeGen, wanted_ty: Type, given_ty: Type, operand: WValue) Inn
fn airStructFieldPtr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
const mod = func.bin_file.base.options.module.?;
- const ty_pl = func.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = func.air.extraData(Air.StructField, ty_pl.payload);
const struct_ptr = try func.resolveInst(extra.data.struct_operand);
@@ -3865,7 +3865,7 @@ fn airStructFieldPtr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
fn airStructFieldPtrIndex(func: *CodeGen, inst: Air.Inst.Index, index: u32) InnerError!void {
const mod = func.bin_file.base.options.module.?;
- const ty_op = func.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const struct_ptr = try func.resolveInst(ty_op.operand);
const struct_ptr_ty = func.typeOf(ty_op.operand);
const struct_ty = struct_ptr_ty.childType(mod);
@@ -3916,7 +3916,7 @@ fn structFieldPtr(
fn airStructFieldVal(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
const mod = func.bin_file.base.options.module.?;
const ip = &mod.intern_pool;
- const ty_pl = func.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const struct_field = func.air.extraData(Air.StructField, ty_pl.payload).data;
const struct_ty = func.typeOf(struct_field.struct_operand);
@@ -4016,7 +4016,7 @@ fn airSwitchBr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
const mod = func.bin_file.base.options.module.?;
// result type is always 'noreturn'
const blocktype = wasm.block_empty;
- const pl_op = func.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = func.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const target = try func.resolveInst(pl_op.operand);
const target_ty = func.typeOf(pl_op.operand);
const switch_br = func.air.extraData(Air.SwitchBr, pl_op.payload);
@@ -4040,8 +4040,8 @@ fn airSwitchBr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
var highest_maybe: ?i32 = null;
while (case_i < switch_br.data.cases_len) : (case_i += 1) {
const case = func.air.extraData(Air.SwitchBr.Case, extra_index);
- const items = @as([]const Air.Inst.Ref, @ptrCast(func.air.extra[case.end..][0..case.data.items_len]));
- const case_body = func.air.extra[case.end + items.len ..][0..case.data.body_len];
+ const items: []const Air.Inst.Ref = @ptrCast(func.air.extra[case.end..][0..case.data.items_len]);
+ const case_body: []const Air.Inst.Index = @ptrCast(func.air.extra[case.end + items.len ..][0..case.data.body_len]);
extra_index = case.end + items.len + case_body.len;
const values = try func.gpa.alloc(CaseValue, items.len);
errdefer func.gpa.free(values);
@@ -4072,7 +4072,7 @@ fn airSwitchBr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
// TODO: Benchmark this to find a proper value, LLVM seems to draw the line at '40~45'.
const is_sparse = highest - lowest > 50 or target_ty.bitSize(mod) > 32;
- const else_body = func.air.extra[extra_index..][0..switch_br.data.else_body_len];
+ const else_body: []const Air.Inst.Index = @ptrCast(func.air.extra[extra_index..][0..switch_br.data.else_body_len]);
const has_else_body = else_body.len != 0;
if (has_else_body) {
try func.startBlock(.block, blocktype);
@@ -4194,7 +4194,7 @@ fn airSwitchBr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
fn airIsErr(func: *CodeGen, inst: Air.Inst.Index, opcode: wasm.Opcode) InnerError!void {
const mod = func.bin_file.base.options.module.?;
- const un_op = func.air.instructions.items(.data)[inst].un_op;
+ const un_op = func.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try func.resolveInst(un_op);
const err_union_ty = func.typeOf(un_op);
const pl_ty = err_union_ty.errorUnionPayload(mod);
@@ -4229,7 +4229,7 @@ fn airIsErr(func: *CodeGen, inst: Air.Inst.Index, opcode: wasm.Opcode) InnerErro
fn airUnwrapErrUnionPayload(func: *CodeGen, inst: Air.Inst.Index, op_is_ptr: bool) InnerError!void {
const mod = func.bin_file.base.options.module.?;
- const ty_op = func.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand = try func.resolveInst(ty_op.operand);
const op_ty = func.typeOf(ty_op.operand);
@@ -4257,7 +4257,7 @@ fn airUnwrapErrUnionPayload(func: *CodeGen, inst: Air.Inst.Index, op_is_ptr: boo
fn airUnwrapErrUnionError(func: *CodeGen, inst: Air.Inst.Index, op_is_ptr: bool) InnerError!void {
const mod = func.bin_file.base.options.module.?;
- const ty_op = func.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand = try func.resolveInst(ty_op.operand);
const op_ty = func.typeOf(ty_op.operand);
@@ -4281,7 +4281,7 @@ fn airUnwrapErrUnionError(func: *CodeGen, inst: Air.Inst.Index, op_is_ptr: bool)
fn airWrapErrUnionPayload(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
const mod = func.bin_file.base.options.module.?;
- const ty_op = func.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand = try func.resolveInst(ty_op.operand);
const err_ty = func.typeOfIndex(inst);
@@ -4311,10 +4311,10 @@ fn airWrapErrUnionPayload(func: *CodeGen, inst: Air.Inst.Index) InnerError!void
fn airWrapErrUnionErr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
const mod = func.bin_file.base.options.module.?;
- const ty_op = func.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand = try func.resolveInst(ty_op.operand);
- const err_ty = func.air.getRefType(ty_op.ty);
+ const err_ty = ty_op.ty.toType();
const pl_ty = err_ty.errorUnionPayload(mod);
const result = result: {
@@ -4337,9 +4337,9 @@ fn airWrapErrUnionErr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
}
fn airIntcast(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
- const ty_op = func.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
- const ty = func.air.getRefType(ty_op.ty);
+ const ty = ty_op.ty.toType();
const operand = try func.resolveInst(ty_op.operand);
const operand_ty = func.typeOf(ty_op.operand);
const mod = func.bin_file.base.options.module.?;
@@ -4434,7 +4434,7 @@ fn intcast(func: *CodeGen, operand: WValue, given: Type, wanted: Type) InnerErro
fn airIsNull(func: *CodeGen, inst: Air.Inst.Index, opcode: wasm.Opcode, op_kind: enum { value, ptr }) InnerError!void {
const mod = func.bin_file.base.options.module.?;
- const un_op = func.air.instructions.items(.data)[inst].un_op;
+ const un_op = func.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try func.resolveInst(un_op);
const op_ty = func.typeOf(un_op);
@@ -4476,7 +4476,7 @@ fn isNull(func: *CodeGen, operand: WValue, optional_ty: Type, opcode: wasm.Opcod
fn airOptionalPayload(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
const mod = func.bin_file.base.options.module.?;
- const ty_op = func.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const opt_ty = func.typeOf(ty_op.operand);
const payload_ty = func.typeOfIndex(inst);
if (!payload_ty.hasRuntimeBitsIgnoreComptime(mod)) {
@@ -4499,7 +4499,7 @@ fn airOptionalPayload(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
fn airOptionalPayloadPtr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
const mod = func.bin_file.base.options.module.?;
- const ty_op = func.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand = try func.resolveInst(ty_op.operand);
const opt_ty = func.typeOf(ty_op.operand).childType(mod);
@@ -4516,7 +4516,7 @@ fn airOptionalPayloadPtr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
fn airOptionalPayloadPtrSet(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
const mod = func.bin_file.base.options.module.?;
- const ty_op = func.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand = try func.resolveInst(ty_op.operand);
const opt_ty = func.typeOf(ty_op.operand).childType(mod);
const payload_ty = opt_ty.optionalChild(mod);
@@ -4541,7 +4541,7 @@ fn airOptionalPayloadPtrSet(func: *CodeGen, inst: Air.Inst.Index) InnerError!voi
}
fn airWrapOptional(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
- const ty_op = func.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const payload_ty = func.typeOf(ty_op.operand);
const mod = func.bin_file.base.options.module.?;
@@ -4578,7 +4578,7 @@ fn airWrapOptional(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
}
fn airSlice(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
- const ty_pl = func.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const bin_op = func.air.extraData(Air.Bin, ty_pl.payload).data;
const lhs = try func.resolveInst(bin_op.lhs);
@@ -4593,7 +4593,7 @@ fn airSlice(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
}
fn airSliceLen(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
- const ty_op = func.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand = try func.resolveInst(ty_op.operand);
func.finishAir(inst, try func.sliceLen(operand), &.{ty_op.operand});
@@ -4601,7 +4601,7 @@ fn airSliceLen(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
fn airSliceElemVal(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
const mod = func.bin_file.base.options.module.?;
- const bin_op = func.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = func.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const slice_ty = func.typeOf(bin_op.lhs);
const slice = try func.resolveInst(bin_op.lhs);
@@ -4631,10 +4631,10 @@ fn airSliceElemVal(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
fn airSliceElemPtr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
const mod = func.bin_file.base.options.module.?;
- const ty_pl = func.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const bin_op = func.air.extraData(Air.Bin, ty_pl.payload).data;
- const elem_ty = func.air.getRefType(ty_pl.ty).childType(mod);
+ const elem_ty = ty_pl.ty.toType().childType(mod);
const elem_size = elem_ty.abiSize(mod);
const slice = try func.resolveInst(bin_op.lhs);
@@ -4654,7 +4654,7 @@ fn airSliceElemPtr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
}
fn airSlicePtr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
- const ty_op = func.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand = try func.resolveInst(ty_op.operand);
func.finishAir(inst, try func.slicePtr(operand), &.{ty_op.operand});
}
@@ -4670,10 +4670,10 @@ fn sliceLen(func: *CodeGen, operand: WValue) InnerError!WValue {
}
fn airTrunc(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
- const ty_op = func.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand = try func.resolveInst(ty_op.operand);
- const wanted_ty = func.air.getRefType(ty_op.ty);
+ const wanted_ty = ty_op.ty.toType();
const op_ty = func.typeOf(ty_op.operand);
const result = try func.trunc(operand, wanted_ty, op_ty);
@@ -4699,7 +4699,7 @@ fn trunc(func: *CodeGen, operand: WValue, wanted_ty: Type, given_ty: Type) Inner
}
fn airIntFromBool(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
- const un_op = func.air.instructions.items(.data)[inst].un_op;
+ const un_op = func.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try func.resolveInst(un_op);
const result = func.reuseOperand(un_op, operand);
@@ -4708,11 +4708,11 @@ fn airIntFromBool(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
fn airArrayToSlice(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
const mod = func.bin_file.base.options.module.?;
- const ty_op = func.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand = try func.resolveInst(ty_op.operand);
const array_ty = func.typeOf(ty_op.operand).childType(mod);
- const slice_ty = func.air.getRefType(ty_op.ty);
+ const slice_ty = ty_op.ty.toType();
// create a slice on the stack
const slice_local = try func.allocStack(slice_ty);
@@ -4731,7 +4731,7 @@ fn airArrayToSlice(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
fn airIntFromPtr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
const mod = func.bin_file.base.options.module.?;
- const un_op = func.air.instructions.items(.data)[inst].un_op;
+ const un_op = func.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try func.resolveInst(un_op);
const ptr_ty = func.typeOf(un_op);
const result = if (ptr_ty.isSlice(mod))
@@ -4746,7 +4746,7 @@ fn airIntFromPtr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
fn airPtrElemVal(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
const mod = func.bin_file.base.options.module.?;
- const bin_op = func.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = func.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const ptr_ty = func.typeOf(bin_op.lhs);
const ptr = try func.resolveInst(bin_op.lhs);
@@ -4783,11 +4783,11 @@ fn airPtrElemVal(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
fn airPtrElemPtr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
const mod = func.bin_file.base.options.module.?;
- const ty_pl = func.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const bin_op = func.air.extraData(Air.Bin, ty_pl.payload).data;
const ptr_ty = func.typeOf(bin_op.lhs);
- const elem_ty = func.air.getRefType(ty_pl.ty).childType(mod);
+ const elem_ty = ty_pl.ty.toType().childType(mod);
const elem_size = elem_ty.abiSize(mod);
const ptr = try func.resolveInst(bin_op.lhs);
@@ -4813,7 +4813,7 @@ fn airPtrElemPtr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
fn airPtrBinOp(func: *CodeGen, inst: Air.Inst.Index, op: Op) InnerError!void {
const mod = func.bin_file.base.options.module.?;
- const ty_pl = func.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const bin_op = func.air.extraData(Air.Bin, ty_pl.payload).data;
const ptr = try func.resolveInst(bin_op.lhs);
@@ -4846,7 +4846,7 @@ fn airMemset(func: *CodeGen, inst: Air.Inst.Index, safety: bool) InnerError!void
} else {
// TODO if the value is undef, don't lower this instruction
}
- const bin_op = func.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = func.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const ptr = try func.resolveInst(bin_op.lhs);
const ptr_ty = func.typeOf(bin_op.lhs);
@@ -4963,7 +4963,7 @@ fn memset(func: *CodeGen, elem_ty: Type, ptr: WValue, len: WValue, value: WValue
fn airArrayElemVal(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
const mod = func.bin_file.base.options.module.?;
- const bin_op = func.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = func.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const array_ty = func.typeOf(bin_op.lhs);
const array = try func.resolveInst(bin_op.lhs);
@@ -5032,7 +5032,7 @@ fn airArrayElemVal(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
fn airIntFromFloat(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
const mod = func.bin_file.base.options.module.?;
- const ty_op = func.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand = try func.resolveInst(ty_op.operand);
const op_ty = func.typeOf(ty_op.operand);
@@ -5077,7 +5077,7 @@ fn airIntFromFloat(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
fn airFloatFromInt(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
const mod = func.bin_file.base.options.module.?;
- const ty_op = func.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand = try func.resolveInst(ty_op.operand);
const op_ty = func.typeOf(ty_op.operand);
@@ -5123,7 +5123,7 @@ fn airFloatFromInt(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
fn airSplat(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
const mod = func.bin_file.base.options.module.?;
- const ty_op = func.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand = try func.resolveInst(ty_op.operand);
const ty = func.typeOfIndex(inst);
const elem_ty = ty.childType(mod);
@@ -5193,7 +5193,7 @@ fn airSplat(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
}
fn airSelect(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
- const pl_op = func.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = func.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const operand = try func.resolveInst(pl_op.operand);
_ = operand;
@@ -5203,7 +5203,7 @@ fn airSelect(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
fn airShuffle(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
const mod = func.bin_file.base.options.module.?;
const inst_ty = func.typeOfIndex(inst);
- const ty_pl = func.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = func.air.extraData(Air.Shuffle, ty_pl.payload).data;
const a = try func.resolveInst(extra.a);
@@ -5262,7 +5262,7 @@ fn airShuffle(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
}
fn airReduce(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
- const reduce = func.air.instructions.items(.data)[inst].reduce;
+ const reduce = func.air.instructions.items(.data)[@intFromEnum(inst)].reduce;
const operand = try func.resolveInst(reduce.operand);
_ = operand;
@@ -5272,7 +5272,7 @@ fn airReduce(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
fn airAggregateInit(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
const mod = func.bin_file.base.options.module.?;
const ip = &mod.intern_pool;
- const ty_pl = func.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const result_ty = func.typeOfIndex(inst);
const len = @as(usize, @intCast(result_ty.arrayLen(mod)));
const elements = @as([]const Air.Inst.Ref, @ptrCast(func.air.extra[ty_pl.payload..][0..len]));
@@ -5402,7 +5402,7 @@ fn airAggregateInit(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
fn airUnionInit(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
const mod = func.bin_file.base.options.module.?;
const ip = &mod.intern_pool;
- const ty_pl = func.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = func.air.extraData(Air.UnionInit, ty_pl.payload).data;
const result = result: {
@@ -5474,12 +5474,12 @@ fn airUnionInit(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
}
fn airPrefetch(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
- const prefetch = func.air.instructions.items(.data)[inst].prefetch;
+ const prefetch = func.air.instructions.items(.data)[@intFromEnum(inst)].prefetch;
func.finishAir(inst, .none, &.{prefetch.ptr});
}
fn airWasmMemorySize(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
- const pl_op = func.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = func.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const result = try func.allocLocal(func.typeOfIndex(inst));
try func.addLabel(.memory_size, pl_op.payload);
@@ -5488,7 +5488,7 @@ fn airWasmMemorySize(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
}
fn airWasmMemoryGrow(func: *CodeGen, inst: Air.Inst.Index) !void {
- const pl_op = func.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = func.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const operand = try func.resolveInst(pl_op.operand);
const result = try func.allocLocal(func.typeOfIndex(inst));
@@ -5578,7 +5578,7 @@ fn cmpBigInt(func: *CodeGen, lhs: WValue, rhs: WValue, operand_ty: Type, op: std
fn airSetUnionTag(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
const mod = func.bin_file.base.options.module.?;
- const bin_op = func.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = func.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const un_ty = func.typeOf(bin_op.lhs).childType(mod);
const tag_ty = func.typeOf(bin_op.rhs);
const layout = un_ty.unionGetLayout(mod);
@@ -5602,7 +5602,7 @@ fn airSetUnionTag(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
fn airGetUnionTag(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
const mod = func.bin_file.base.options.module.?;
- const ty_op = func.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const un_ty = func.typeOf(ty_op.operand);
const tag_ty = func.typeOfIndex(inst);
@@ -5621,7 +5621,7 @@ fn airGetUnionTag(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
}
fn airFpext(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
- const ty_op = func.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const dest_ty = func.typeOfIndex(inst);
const operand = try func.resolveInst(ty_op.operand);
@@ -5666,7 +5666,7 @@ fn fpext(func: *CodeGen, operand: WValue, given: Type, wanted: Type) InnerError!
}
fn airFptrunc(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
- const ty_op = func.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const dest_ty = func.typeOfIndex(inst);
const operand = try func.resolveInst(ty_op.operand);
@@ -5707,7 +5707,7 @@ fn fptrunc(func: *CodeGen, operand: WValue, given: Type, wanted: Type) InnerErro
fn airErrUnionPayloadPtrSet(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
const mod = func.bin_file.base.options.module.?;
- const ty_op = func.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const err_set_ty = func.typeOf(ty_op.operand).childType(mod);
const payload_ty = err_set_ty.errorUnionPayload(mod);
@@ -5733,11 +5733,11 @@ fn airErrUnionPayloadPtrSet(func: *CodeGen, inst: Air.Inst.Index) InnerError!voi
fn airFieldParentPtr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
const mod = func.bin_file.base.options.module.?;
- const ty_pl = func.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = func.air.extraData(Air.FieldParentPtr, ty_pl.payload).data;
const field_ptr = try func.resolveInst(extra.field_ptr);
- const parent_ty = func.air.getRefType(ty_pl.ty).childType(mod);
+ const parent_ty = ty_pl.ty.toType().childType(mod);
const field_offset = parent_ty.structFieldOffset(extra.field_index, mod);
const result = if (field_offset != 0) result: {
@@ -5763,7 +5763,7 @@ fn sliceOrArrayPtr(func: *CodeGen, ptr: WValue, ptr_ty: Type) InnerError!WValue
fn airMemcpy(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
const mod = func.bin_file.base.options.module.?;
- const bin_op = func.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = func.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const dst = try func.resolveInst(bin_op.lhs);
const dst_ty = func.typeOf(bin_op.lhs);
const ptr_elem_ty = dst_ty.childType(mod);
@@ -5803,7 +5803,7 @@ fn airRetAddr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
fn airPopcount(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
const mod = func.bin_file.base.options.module.?;
- const ty_op = func.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand = try func.resolveInst(ty_op.operand);
const op_ty = func.typeOf(ty_op.operand);
@@ -5847,7 +5847,7 @@ fn airPopcount(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
}
fn airErrorName(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
- const un_op = func.air.instructions.items(.data)[inst].un_op;
+ const un_op = func.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try func.resolveInst(un_op);
// First retrieve the symbol index to the error name table
@@ -5889,7 +5889,7 @@ fn airErrorName(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
}
fn airPtrSliceFieldPtr(func: *CodeGen, inst: Air.Inst.Index, offset: u32) InnerError!void {
- const ty_op = func.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const slice_ptr = try func.resolveInst(ty_op.operand);
const result = try func.buildPointerOffset(slice_ptr, offset, .new);
func.finishAir(inst, result, &.{ty_op.operand});
@@ -5897,7 +5897,7 @@ fn airPtrSliceFieldPtr(func: *CodeGen, inst: Air.Inst.Index, offset: u32) InnerE
fn airAddSubWithOverflow(func: *CodeGen, inst: Air.Inst.Index, op: Op) InnerError!void {
assert(op == .add or op == .sub);
- const ty_pl = func.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = func.air.extraData(Air.Bin, ty_pl.payload).data;
const lhs_op = try func.resolveInst(extra.lhs);
@@ -6041,7 +6041,7 @@ fn addSubWithOverflowBigInt(func: *CodeGen, lhs: WValue, rhs: WValue, ty: Type,
fn airShlWithOverflow(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
const mod = func.bin_file.base.options.module.?;
- const ty_pl = func.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = func.air.extraData(Air.Bin, ty_pl.payload).data;
const lhs = try func.resolveInst(extra.lhs);
@@ -6097,7 +6097,7 @@ fn airShlWithOverflow(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
}
fn airMulWithOverflow(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
- const ty_pl = func.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = func.air.extraData(Air.Bin, ty_pl.payload).data;
const lhs = try func.resolveInst(extra.lhs);
@@ -6275,7 +6275,7 @@ fn airMaxMin(func: *CodeGen, inst: Air.Inst.Index, op: Op) InnerError!void {
assert(op == .max or op == .min);
const mod = func.bin_file.base.options.module.?;
const target = mod.getTarget();
- const bin_op = func.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = func.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const ty = func.typeOfIndex(inst);
if (ty.zigTypeTag(mod) == .Vector) {
@@ -6318,7 +6318,7 @@ fn airMaxMin(func: *CodeGen, inst: Air.Inst.Index, op: Op) InnerError!void {
fn airMulAdd(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
const mod = func.bin_file.base.options.module.?;
- const pl_op = func.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = func.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const bin_op = func.air.extraData(Air.Bin, pl_op.payload).data;
const ty = func.typeOfIndex(inst);
@@ -6352,7 +6352,7 @@ fn airMulAdd(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
fn airClz(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
const mod = func.bin_file.base.options.module.?;
- const ty_op = func.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const ty = func.typeOf(ty_op.operand);
const result_ty = func.typeOfIndex(inst);
@@ -6405,7 +6405,7 @@ fn airClz(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
fn airCtz(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
const mod = func.bin_file.base.options.module.?;
- const ty_op = func.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const ty = func.typeOf(ty_op.operand);
const result_ty = func.typeOfIndex(inst);
@@ -6472,7 +6472,7 @@ fn airDbgVar(func: *CodeGen, inst: Air.Inst.Index, is_ptr: bool) !void {
if (func.debug_output != .dwarf) return func.finishAir(inst, .none, &.{});
const mod = func.bin_file.base.options.module.?;
- const pl_op = func.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = func.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const ty = func.typeOf(pl_op.operand);
const operand = try func.resolveInst(pl_op.operand);
@@ -6496,7 +6496,7 @@ fn airDbgVar(func: *CodeGen, inst: Air.Inst.Index, is_ptr: bool) !void {
fn airDbgStmt(func: *CodeGen, inst: Air.Inst.Index) !void {
if (func.debug_output != .dwarf) return func.finishAir(inst, .none, &.{});
- const dbg_stmt = func.air.instructions.items(.data)[inst].dbg_stmt;
+ const dbg_stmt = func.air.instructions.items(.data)[@intFromEnum(inst)].dbg_stmt;
try func.addInst(.{ .tag = .dbg_line, .data = .{
.payload = try func.addExtra(Mir.DbgLineColumn{
.line = dbg_stmt.line,
@@ -6507,10 +6507,10 @@ fn airDbgStmt(func: *CodeGen, inst: Air.Inst.Index) !void {
}
fn airTry(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
- const pl_op = func.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = func.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const err_union = try func.resolveInst(pl_op.operand);
const extra = func.air.extraData(Air.Try, pl_op.payload);
- const body = func.air.extra[extra.end..][0..extra.data.body_len];
+ const body: []const Air.Inst.Index = @ptrCast(func.air.extra[extra.end..][0..extra.data.body_len]);
const err_union_ty = func.typeOf(pl_op.operand);
const result = try lowerTry(func, inst, err_union, body, err_union_ty, false);
func.finishAir(inst, result, &.{pl_op.operand});
@@ -6518,10 +6518,10 @@ fn airTry(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
fn airTryPtr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
const mod = func.bin_file.base.options.module.?;
- const ty_pl = func.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = func.air.extraData(Air.TryPtr, ty_pl.payload);
const err_union_ptr = try func.resolveInst(extra.data.ptr);
- const body = func.air.extra[extra.end..][0..extra.data.body_len];
+ const body: []const Air.Inst.Index = @ptrCast(func.air.extra[extra.end..][0..extra.data.body_len]);
const err_union_ty = func.typeOf(extra.data.ptr).childType(mod);
const result = try lowerTry(func, inst, err_union_ptr, body, err_union_ty, true);
func.finishAir(inst, result, &.{extra.data.ptr});
@@ -6585,7 +6585,7 @@ fn lowerTry(
fn airByteSwap(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
const mod = func.bin_file.base.options.module.?;
- const ty_op = func.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const ty = func.typeOfIndex(inst);
const operand = try func.resolveInst(ty_op.operand);
@@ -6656,7 +6656,7 @@ fn airByteSwap(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
fn airDiv(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
const mod = func.bin_file.base.options.module.?;
- const bin_op = func.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = func.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const ty = func.typeOfIndex(inst);
const lhs = try func.resolveInst(bin_op.lhs);
@@ -6671,7 +6671,7 @@ fn airDiv(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
fn airDivTrunc(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
const mod = func.bin_file.base.options.module.?;
- const bin_op = func.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = func.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const ty = func.typeOfIndex(inst);
const lhs = try func.resolveInst(bin_op.lhs);
@@ -6691,7 +6691,7 @@ fn airDivTrunc(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
}
fn airDivFloor(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
- const bin_op = func.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = func.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const mod = func.bin_file.base.options.module.?;
const ty = func.typeOfIndex(inst);
@@ -6834,7 +6834,7 @@ fn divSigned(func: *CodeGen, lhs: WValue, rhs: WValue, ty: Type) InnerError!WVal
/// Remainder after floor division, defined by:
/// @divFloor(a, b) * b + @mod(a, b) = a
fn airMod(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
- const bin_op = func.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = func.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const mod = func.bin_file.base.options.module.?;
const ty = func.typeOfIndex(inst);
@@ -6917,7 +6917,7 @@ fn signExtendInt(func: *CodeGen, operand: WValue, ty: Type) InnerError!WValue {
fn airSatBinOp(func: *CodeGen, inst: Air.Inst.Index, op: Op) InnerError!void {
assert(op == .add or op == .sub);
- const bin_op = func.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = func.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const mod = func.bin_file.base.options.module.?;
const ty = func.typeOfIndex(inst);
@@ -7032,7 +7032,7 @@ fn signedSat(func: *CodeGen, lhs_operand: WValue, rhs_operand: WValue, ty: Type,
}
fn airShlSat(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
- const bin_op = func.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = func.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const mod = func.bin_file.base.options.module.?;
const ty = func.typeOfIndex(inst);
@@ -7193,7 +7193,7 @@ fn callIntrinsic(
}
fn airTagName(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
- const un_op = func.air.instructions.items(.data)[inst].un_op;
+ const un_op = func.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try func.resolveInst(un_op);
const enum_ty = func.typeOf(un_op);
@@ -7365,10 +7365,10 @@ fn getTagNameFunction(func: *CodeGen, enum_ty: Type) InnerError!u32 {
fn airErrorSetHasValue(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
const mod = func.bin_file.base.options.module.?;
- const ty_op = func.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand = try func.resolveInst(ty_op.operand);
- const error_set_ty = func.air.getRefType(ty_op.ty);
+ const error_set_ty = ty_op.ty.toType();
const result = try func.allocLocal(Type.bool);
const names = error_set_ty.errorSetNames(mod);
@@ -7450,7 +7450,7 @@ inline fn useAtomicFeature(func: *const CodeGen) bool {
fn airCmpxchg(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
const mod = func.bin_file.base.options.module.?;
- const ty_pl = func.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = func.air.extraData(Air.Cmpxchg, ty_pl.payload).data;
const ptr_ty = func.typeOf(extra.ptr);
@@ -7523,7 +7523,7 @@ fn airCmpxchg(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
fn airAtomicLoad(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
const mod = func.bin_file.base.options.module.?;
- const atomic_load = func.air.instructions.items(.data)[inst].atomic_load;
+ const atomic_load = func.air.instructions.items(.data)[@intFromEnum(inst)].atomic_load;
const ptr = try func.resolveInst(atomic_load.ptr);
const ty = func.typeOfIndex(inst);
@@ -7550,7 +7550,7 @@ fn airAtomicLoad(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
fn airAtomicRmw(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
const mod = func.bin_file.base.options.module.?;
- const pl_op = func.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = func.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const extra = func.air.extraData(Air.AtomicRmw, pl_op.payload).data;
const ptr = try func.resolveInst(pl_op.operand);
@@ -7736,7 +7736,7 @@ fn airFence(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
fn airAtomicStore(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
const mod = func.bin_file.base.options.module.?;
- const bin_op = func.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = func.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const ptr = try func.resolveInst(bin_op.lhs);
const operand = try func.resolveInst(bin_op.rhs);
src/arch/x86_64/CodeGen.zig
@@ -1901,7 +1901,7 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
const old_air_bookkeeping = self.air_bookkeeping;
try self.inst_tracking.ensureUnusedCapacity(self.gpa, 1);
- switch (air_tags[inst]) {
+ switch (air_tags[@intFromEnum(inst)]) {
// zig fmt: off
.not,
=> |tag| try self.airUnOp(inst, tag),
@@ -2148,7 +2148,7 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
if (std.debug.runtime_safety) {
if (self.air_bookkeeping < old_air_bookkeeping + 1) {
- std.debug.panic("in codegen.zig, handling of AIR instruction %{d} ('{}') did not do proper bookkeeping. Look for a missing call to finishAir.", .{ inst, air_tags[inst] });
+ std.debug.panic("in codegen.zig, handling of AIR instruction %{d} ('{}') did not do proper bookkeeping. Look for a missing call to finishAir.", .{ inst, air_tags[@intFromEnum(inst)] });
}
{ // check consistency of tracked registers
@@ -2251,7 +2251,7 @@ fn freeValue(self: *Self, value: MCValue) !void {
}
fn feed(self: *Self, bt: *Liveness.BigTomb, operand: Air.Inst.Ref) !void {
- if (bt.feed()) if (Air.refToIndex(operand)) |inst| try self.processDeath(inst);
+ if (bt.feed()) if (operand.toIndex()) |inst| try self.processDeath(inst);
}
/// Asserts there is already capacity to insert into top branch inst_table.
@@ -2292,7 +2292,7 @@ fn finishAir(
const dies = @as(u1, @truncate(tomb_bits)) != 0;
tomb_bits >>= 1;
if (!dies) continue;
- try self.processDeath(Air.refToIndexAllowNone(op) orelse continue);
+ try self.processDeath(op.toIndexAllowNone() orelse continue);
}
self.finishAirResult(inst, result);
}
@@ -2683,7 +2683,7 @@ fn airRetPtr(self: *Self, inst: Air.Inst.Index) !void {
}
fn airFptrunc(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const dst_ty = self.typeOfIndex(inst);
const dst_bits = dst_ty.floatBits(self.target.*);
const src_ty = self.typeOf(ty_op.operand);
@@ -2782,7 +2782,7 @@ fn airFptrunc(self: *Self, inst: Air.Inst.Index) !void {
}
fn airFpext(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const dst_ty = self.typeOfIndex(inst);
const dst_bits = dst_ty.floatBits(self.target.*);
const src_ty = self.typeOf(ty_op.operand);
@@ -2882,7 +2882,7 @@ fn airFpext(self: *Self, inst: Air.Inst.Index) !void {
fn airIntCast(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = result: {
const src_ty = self.typeOf(ty_op.operand);
const src_int_info = src_ty.intInfo(mod);
@@ -2973,7 +2973,7 @@ fn airIntCast(self: *Self, inst: Air.Inst.Index) !void {
fn airTrunc(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const dst_ty = self.typeOfIndex(inst);
const dst_abi_size: u32 = @intCast(dst_ty.abiSize(mod));
@@ -3086,7 +3086,7 @@ fn airTrunc(self: *Self, inst: Air.Inst.Index) !void {
}
fn airIntFromBool(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const ty = self.typeOfIndex(inst);
const operand = try self.resolveInst(un_op);
@@ -3100,7 +3100,7 @@ fn airIntFromBool(self: *Self, inst: Air.Inst.Index) !void {
fn airSlice(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
const slice_ty = self.typeOfIndex(inst);
@@ -3123,14 +3123,14 @@ fn airSlice(self: *Self, inst: Air.Inst.Index) !void {
}
fn airUnOp(self: *Self, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const dst_mcv = try self.genUnOp(inst, tag, ty_op.operand);
return self.finishAir(inst, dst_mcv, .{ ty_op.operand, .none, .none });
}
fn airBinOp(self: *Self, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void {
const mod = self.bin_file.options.module.?;
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const dst_mcv = try self.genBinOp(inst, tag, bin_op.lhs, bin_op.rhs);
const dst_ty = self.typeOfIndex(inst);
@@ -3163,7 +3163,7 @@ fn airBinOp(self: *Self, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void {
}
fn airPtrArithmetic(self: *Self, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
const dst_mcv = try self.genBinOp(inst, tag, bin_op.lhs, bin_op.rhs);
return self.finishAir(inst, dst_mcv, .{ bin_op.lhs, bin_op.rhs, .none });
@@ -3176,10 +3176,10 @@ fn activeIntBits(self: *Self, dst_air: Air.Inst.Ref) u16 {
const dst_ty = self.typeOf(dst_air);
const dst_info = dst_ty.intInfo(mod);
- if (Air.refToIndex(dst_air)) |inst| {
- switch (air_tag[inst]) {
+ if (dst_air.toIndex()) |inst| {
+ switch (air_tag[@intFromEnum(inst)]) {
.intcast => {
- const src_ty = self.typeOf(air_data[inst].ty_op.operand);
+ const src_ty = self.typeOf(air_data[@intFromEnum(inst)].ty_op.operand);
const src_info = src_ty.intInfo(mod);
return @min(switch (src_info.signedness) {
.signed => switch (dst_info.signedness) {
@@ -3194,7 +3194,7 @@ fn activeIntBits(self: *Self, dst_air: Air.Inst.Ref) u16 {
},
else => {},
}
- } else if (Air.refToInterned(dst_air)) |ip_index| {
+ } else if (dst_air.toInterned()) |ip_index| {
var space: Value.BigIntSpace = undefined;
const src_int = Value.fromInterned(ip_index).toBigInt(&space, mod);
return @as(u16, @intCast(src_int.bitCountTwosComp())) +
@@ -3205,9 +3205,9 @@ fn activeIntBits(self: *Self, dst_air: Air.Inst.Ref) u16 {
fn airMulDivBinOp(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const result = result: {
- const tag = self.air.instructions.items(.tag)[inst];
+ const tag = self.air.instructions.items(.tag)[@intFromEnum(inst)];
const dst_ty = self.typeOfIndex(inst);
switch (dst_ty.zigTypeTag(mod)) {
.Float, .Vector => break :result try self.genBinOp(inst, tag, bin_op.lhs, bin_op.rhs),
@@ -3431,7 +3431,7 @@ fn airMulDivBinOp(self: *Self, inst: Air.Inst.Index) !void {
fn airAddSat(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const ty = self.typeOf(bin_op.lhs);
if (ty.zigTypeTag(mod) == .Vector or ty.abiSize(mod) > 8) return self.fail(
"TODO implement airAddSat for {}",
@@ -3514,7 +3514,7 @@ fn airAddSat(self: *Self, inst: Air.Inst.Index) !void {
fn airSubSat(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const ty = self.typeOf(bin_op.lhs);
if (ty.zigTypeTag(mod) == .Vector or ty.abiSize(mod) > 8) return self.fail(
"TODO implement airSubSat for {}",
@@ -3590,7 +3590,7 @@ fn airSubSat(self: *Self, inst: Air.Inst.Index) !void {
fn airMulSat(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const ty = self.typeOf(bin_op.lhs);
const result = result: {
@@ -3730,10 +3730,10 @@ fn airMulSat(self: *Self, inst: Air.Inst.Index) !void {
fn airAddSubWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
const result: MCValue = result: {
- const tag = self.air.instructions.items(.tag)[inst];
+ const tag = self.air.instructions.items(.tag)[@intFromEnum(inst)];
const ty = self.typeOf(bin_op.lhs);
switch (ty.zigTypeTag(mod)) {
.Vector => return self.fail("TODO implement add/sub with overflow for Vector type", .{}),
@@ -3791,7 +3791,7 @@ fn airAddSubWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
fn airShlWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
const result: MCValue = result: {
const lhs_ty = self.typeOf(bin_op.lhs);
@@ -3934,7 +3934,7 @@ fn genSetFrameTruncatedOverflowCompare(
fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
const tuple_ty = self.typeOfIndex(inst);
const dst_ty = self.typeOf(bin_op.lhs);
@@ -4270,10 +4270,10 @@ fn genInlineIntDivFloor(self: *Self, ty: Type, lhs: MCValue, rhs: MCValue) !MCVa
fn airShlShrBinOp(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const air_tags = self.air.instructions.items(.tag);
- const tag = air_tags[inst];
+ const tag = air_tags[@intFromEnum(inst)];
const lhs_ty = self.typeOf(bin_op.lhs);
const rhs_ty = self.typeOf(bin_op.rhs);
const result: MCValue = result: {
@@ -4449,7 +4449,7 @@ fn airShlShrBinOp(self: *Self, inst: Air.Inst.Index) !void {
},
else => {},
}
- } else if (Air.refToIndex(bin_op.rhs)) |rhs_inst| switch (air_tags[rhs_inst]) {
+ } else if (bin_op.rhs.toIndex()) |rhs_inst| switch (air_tags[@intFromEnum(rhs_inst)]) {
.splat => {
const abi_size: u32 = @intCast(lhs_ty.abiSize(mod));
@@ -4537,7 +4537,7 @@ fn airShlShrBinOp(self: *Self, inst: Air.Inst.Index) !void {
}
fn airShlSat(self: *Self, inst: Air.Inst.Index) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
_ = bin_op;
return self.fail("TODO implement shl_sat for {}", .{self.target.cpu.arch});
//return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
@@ -4545,7 +4545,7 @@ fn airShlSat(self: *Self, inst: Air.Inst.Index) !void {
fn airOptionalPayload(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = result: {
const pl_ty = self.typeOfIndex(inst);
if (!pl_ty.hasRuntimeBitsIgnoreComptime(mod)) break :result .none;
@@ -4577,7 +4577,7 @@ fn airOptionalPayload(self: *Self, inst: Air.Inst.Index) !void {
}
fn airOptionalPayloadPtr(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const dst_ty = self.typeOfIndex(inst);
const opt_mcv = try self.resolveInst(ty_op.operand);
@@ -4591,7 +4591,7 @@ fn airOptionalPayloadPtr(self: *Self, inst: Air.Inst.Index) !void {
fn airOptionalPayloadPtrSet(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result = result: {
const dst_ty = self.typeOfIndex(inst);
const src_ty = self.typeOf(ty_op.operand);
@@ -4625,7 +4625,7 @@ fn airOptionalPayloadPtrSet(self: *Self, inst: Air.Inst.Index) !void {
fn airUnwrapErrUnionErr(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const err_union_ty = self.typeOf(ty_op.operand);
const err_ty = err_union_ty.errorUnionSet(mod);
const payload_ty = err_union_ty.errorUnionPayload(mod);
@@ -4667,7 +4667,7 @@ fn airUnwrapErrUnionErr(self: *Self, inst: Air.Inst.Index) !void {
}
fn airUnwrapErrUnionPayload(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand_ty = self.typeOf(ty_op.operand);
const operand = try self.resolveInst(ty_op.operand);
const result = try self.genUnwrapErrUnionPayloadMir(inst, operand_ty, operand);
@@ -4677,7 +4677,7 @@ fn airUnwrapErrUnionPayload(self: *Self, inst: Air.Inst.Index) !void {
// *(E!T) -> E
fn airUnwrapErrUnionErrPtr(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const src_ty = self.typeOf(ty_op.operand);
const src_mcv = try self.resolveInst(ty_op.operand);
@@ -4715,7 +4715,7 @@ fn airUnwrapErrUnionErrPtr(self: *Self, inst: Air.Inst.Index) !void {
// *(E!T) -> *T
fn airUnwrapErrUnionPayloadPtr(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand_ty = self.typeOf(ty_op.operand);
const operand = try self.resolveInst(ty_op.operand);
const result = try self.genUnwrapErrUnionPayloadPtrMir(inst, operand_ty, operand);
@@ -4724,7 +4724,7 @@ fn airUnwrapErrUnionPayloadPtr(self: *Self, inst: Air.Inst.Index) !void {
fn airErrUnionPayloadPtrSet(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = result: {
const src_ty = self.typeOf(ty_op.operand);
const src_mcv = try self.resolveInst(ty_op.operand);
@@ -4866,7 +4866,7 @@ fn airSaveErrReturnTraceIndex(self: *Self, inst: Air.Inst.Index) !void {
fn airWrapOptional(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = result: {
const pl_ty = self.typeOf(ty_op.operand);
if (!pl_ty.hasRuntimeBits(mod)) break :result .{ .immediate = 1 };
@@ -4920,9 +4920,9 @@ fn airWrapOptional(self: *Self, inst: Air.Inst.Index) !void {
/// T to E!T
fn airWrapErrUnionPayload(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
- const eu_ty = self.air.getRefType(ty_op.ty);
+ const eu_ty = ty_op.ty.toType();
const pl_ty = eu_ty.errorUnionPayload(mod);
const err_ty = eu_ty.errorUnionSet(mod);
const operand = try self.resolveInst(ty_op.operand);
@@ -4943,9 +4943,9 @@ fn airWrapErrUnionPayload(self: *Self, inst: Air.Inst.Index) !void {
/// E to E!T
fn airWrapErrUnionErr(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
- const eu_ty = self.air.getRefType(ty_op.ty);
+ const eu_ty = ty_op.ty.toType();
const pl_ty = eu_ty.errorUnionPayload(mod);
const err_ty = eu_ty.errorUnionSet(mod);
@@ -4964,7 +4964,7 @@ fn airWrapErrUnionErr(self: *Self, inst: Air.Inst.Index) !void {
}
fn airSlicePtr(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result = result: {
const src_mcv = try self.resolveInst(ty_op.operand);
if (self.reuseOperand(inst, ty_op.operand, 0, src_mcv)) break :result src_mcv;
@@ -4978,7 +4978,7 @@ fn airSlicePtr(self: *Self, inst: Air.Inst.Index) !void {
}
fn airSliceLen(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = result: {
const src_mcv = try self.resolveInst(ty_op.operand);
@@ -5002,7 +5002,7 @@ fn airSliceLen(self: *Self, inst: Air.Inst.Index) !void {
fn airPtrSliceLenPtr(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const src_ty = self.typeOf(ty_op.operand);
const src_mcv = try self.resolveInst(ty_op.operand);
@@ -5036,7 +5036,7 @@ fn airPtrSliceLenPtr(self: *Self, inst: Air.Inst.Index) !void {
}
fn airPtrSlicePtrPtr(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const dst_ty = self.typeOfIndex(inst);
const opt_mcv = try self.resolveInst(ty_op.operand);
@@ -5106,7 +5106,7 @@ fn genSliceElemPtr(self: *Self, lhs: Air.Inst.Ref, rhs: Air.Inst.Ref) !MCValue {
fn airSliceElemVal(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const result: MCValue = result: {
const elem_ty = self.typeOfIndex(inst);
@@ -5123,7 +5123,7 @@ fn airSliceElemVal(self: *Self, inst: Air.Inst.Index) !void {
}
fn airSliceElemPtr(self: *Self, inst: Air.Inst.Index) !void {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.Bin, ty_pl.payload).data;
const dst_mcv = try self.genSliceElemPtr(extra.lhs, extra.rhs);
return self.finishAir(inst, dst_mcv, .{ extra.lhs, extra.rhs, .none });
@@ -5131,7 +5131,7 @@ fn airSliceElemPtr(self: *Self, inst: Air.Inst.Index) !void {
fn airArrayElemVal(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const array_ty = self.typeOf(bin_op.lhs);
const array = try self.resolveInst(bin_op.lhs);
@@ -5205,7 +5205,7 @@ fn airArrayElemVal(self: *Self, inst: Air.Inst.Index) !void {
fn airPtrElemVal(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const ptr_ty = self.typeOf(bin_op.lhs);
// this is identical to the `airPtrElemPtr` codegen expect here an
@@ -5255,7 +5255,7 @@ fn airPtrElemVal(self: *Self, inst: Air.Inst.Index) !void {
fn airPtrElemPtr(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.Bin, ty_pl.payload).data;
const ptr_ty = self.typeOf(extra.lhs);
@@ -5288,7 +5288,7 @@ fn airPtrElemPtr(self: *Self, inst: Air.Inst.Index) !void {
fn airSetUnionTag(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const ptr_union_ty = self.typeOf(bin_op.lhs);
const union_ty = ptr_union_ty.childType(mod);
const tag_ty = self.typeOf(bin_op.rhs);
@@ -5332,7 +5332,7 @@ fn airSetUnionTag(self: *Self, inst: Air.Inst.Index) !void {
fn airGetUnionTag(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const tag_ty = self.typeOfIndex(inst);
const union_ty = self.typeOf(ty_op.operand);
@@ -5386,7 +5386,7 @@ fn airGetUnionTag(self: *Self, inst: Air.Inst.Index) !void {
fn airClz(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result = result: {
const dst_ty = self.typeOfIndex(inst);
const src_ty = self.typeOf(ty_op.operand);
@@ -5545,7 +5545,7 @@ fn airClz(self: *Self, inst: Air.Inst.Index) !void {
fn airCtz(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result = result: {
const dst_ty = self.typeOfIndex(inst);
const src_ty = self.typeOf(ty_op.operand);
@@ -5663,7 +5663,7 @@ fn airCtz(self: *Self, inst: Air.Inst.Index) !void {
fn airPopCount(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result: MCValue = result: {
try self.spillEflagsIfOccupied();
@@ -5818,7 +5818,7 @@ fn genByteSwap(
mem_ok: bool,
) !MCValue {
const mod = self.bin_file.options.module.?;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
if (src_ty.zigTypeTag(mod) == .Vector) return self.fail(
"TODO implement genByteSwap for {}",
@@ -5909,7 +5909,7 @@ fn genByteSwap(
fn airByteSwap(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const src_ty = self.typeOf(ty_op.operand);
const abi_size: u32 = @intCast(src_ty.abiSize(mod));
@@ -5931,7 +5931,7 @@ fn airByteSwap(self: *Self, inst: Air.Inst.Index) !void {
fn airBitReverse(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const src_ty = self.typeOf(ty_op.operand);
const abi_size: u32 = @intCast(src_ty.abiSize(mod));
@@ -6053,7 +6053,7 @@ fn airBitReverse(self: *Self, inst: Air.Inst.Index) !void {
fn floatSign(self: *Self, inst: Air.Inst.Index, operand: Air.Inst.Ref, ty: Type) !void {
const mod = self.bin_file.options.module.?;
- const tag = self.air.instructions.items(.tag)[inst];
+ const tag = self.air.instructions.items(.tag)[@intFromEnum(inst)];
const result = result: {
const scalar_bits = ty.scalarType(mod).floatBits(self.target.*);
@@ -6179,7 +6179,7 @@ fn floatSign(self: *Self, inst: Air.Inst.Index, operand: Air.Inst.Ref, ty: Type)
}
fn airFloatSign(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const ty = self.typeOf(un_op);
return self.floatSign(inst, un_op, ty);
}
@@ -6204,7 +6204,7 @@ const RoundMode = packed struct(u5) {
};
fn airRound(self: *Self, inst: Air.Inst.Index, mode: RoundMode) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const ty = self.typeOf(un_op);
const result = result: {
@@ -6327,7 +6327,7 @@ fn genRound(self: *Self, ty: Type, dst_reg: Register, src_mcv: MCValue, mode: Ro
fn airAbs(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const ty = self.typeOf(ty_op.operand);
const result: MCValue = result: {
@@ -6467,7 +6467,7 @@ fn airAbs(self: *Self, inst: Air.Inst.Index) !void {
fn airSqrt(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const ty = self.typeOf(un_op);
const abi_size: u32 = @intCast(ty.abiSize(mod));
@@ -6634,7 +6634,7 @@ fn airSqrt(self: *Self, inst: Air.Inst.Index) !void {
}
fn airUnaryMath(self: *Self, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const ty = self.typeOf(un_op);
var callee_buf: ["__round?".len]u8 = undefined;
const result = try self.genCall(.{ .lib = .{
@@ -6704,7 +6704,7 @@ fn reuseOperandAdvanced(
// Prevent the operand deaths processing code from deallocating it.
self.liveness.clearOperandDeath(inst, op_index);
- const op_inst = Air.refToIndex(operand).?;
+ const op_inst = operand.toIndex().?;
self.getResolvedInstValue(op_inst).reuse(self, maybe_tracked_inst, op_inst);
return true;
@@ -6852,7 +6852,7 @@ fn load(self: *Self, dst_mcv: MCValue, ptr_ty: Type, ptr_mcv: MCValue) InnerErro
fn airLoad(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const elem_ty = self.typeOfIndex(inst);
const result: MCValue = result: {
if (!elem_ty.hasRuntimeBitsIgnoreComptime(mod)) break :result .none;
@@ -7051,7 +7051,7 @@ fn airStore(self: *Self, inst: Air.Inst.Index, safety: bool) !void {
const reg_locks = self.register_manager.lockRegsAssumeUnused(3, .{ .rdi, .rsi, .rcx });
defer for (reg_locks) |lock| self.register_manager.unlockReg(lock);
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const ptr_mcv = try self.resolveInst(bin_op.lhs);
const ptr_ty = self.typeOf(bin_op.lhs);
const src_mcv = try self.resolveInst(bin_op.rhs);
@@ -7064,14 +7064,14 @@ fn airStore(self: *Self, inst: Air.Inst.Index, safety: bool) !void {
}
fn airStructFieldPtr(self: *Self, inst: Air.Inst.Index) !void {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.StructField, ty_pl.payload).data;
const result = try self.fieldPtr(inst, extra.struct_operand, extra.field_index);
return self.finishAir(inst, result, .{ extra.struct_operand, .none, .none });
}
fn airStructFieldPtrIndex(self: *Self, inst: Air.Inst.Index, index: u8) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const result = try self.fieldPtr(inst, ty_op.operand, index);
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
@@ -7103,7 +7103,7 @@ fn fieldPtr(self: *Self, inst: Air.Inst.Index, operand: Air.Inst.Ref, index: u32
fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.StructField, ty_pl.payload).data;
const result: MCValue = result: {
const operand = extra.struct_operand;
@@ -7389,7 +7389,7 @@ fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) !void {
fn airFieldParentPtr(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.FieldParentPtr, ty_pl.payload).data;
const inst_ty = self.typeOfIndex(inst);
@@ -7943,7 +7943,7 @@ fn genShiftBinOp(
const dst_mcv: MCValue = dst: {
if (maybe_inst) |inst| {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
if (self.reuseOperand(inst, bin_op.lhs, 0, lhs_mcv)) break :dst lhs_mcv;
}
const dst_mcv = try self.allocRegOrMemAdvanced(lhs_ty, maybe_inst, true);
@@ -10496,7 +10496,7 @@ fn airArg(self: *Self, inst: Air.Inst.Index) !void {
else => return self.fail("TODO implement arg for {}", .{src_mcv}),
};
- const src_index = self.air.instructions.items(.data)[inst].arg.src_index;
+ const src_index = self.air.instructions.items(.data)[@intFromEnum(inst)].arg.src_index;
const name = mod.getParamName(self.owner.func_index, src_index);
try self.genArgDbgInfo(arg_ty, name, src_mcv);
@@ -10609,7 +10609,7 @@ fn airFrameAddress(self: *Self, inst: Air.Inst.Index) !void {
}
fn airFence(self: *Self, inst: Air.Inst.Index) !void {
- const order = self.air.instructions.items(.data)[inst].fence;
+ const order = self.air.instructions.items(.data)[@intFromEnum(inst)].fence;
switch (order) {
.Unordered, .Monotonic => unreachable,
.Acquire, .Release, .AcqRel => {},
@@ -10621,7 +10621,7 @@ fn airFence(self: *Self, inst: Air.Inst.Index) !void {
fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier) !void {
if (modifier == .always_tail) return self.fail("TODO implement tail calls for x86_64", .{});
- const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const extra = self.air.extraData(Air.Call, pl_op.payload);
const arg_refs: []const Air.Inst.Ref =
@ptrCast(self.air.extra[extra.end..][0..extra.data.args_len]);
@@ -10883,7 +10883,7 @@ fn genCall(self: *Self, info: union(enum) {
fn airRet(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const ret_ty = self.fn_type.fnReturnType(mod);
switch (self.ret_mcv.short) {
@@ -10911,7 +10911,7 @@ fn airRet(self: *Self, inst: Air.Inst.Index) !void {
}
fn airRetLoad(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const ptr = try self.resolveInst(un_op);
const ptr_ty = self.typeOf(un_op);
@@ -10932,7 +10932,7 @@ fn airRetLoad(self: *Self, inst: Air.Inst.Index) !void {
fn airCmp(self: *Self, inst: Air.Inst.Index, op: math.CompareOperator) !void {
const mod = self.bin_file.options.module.?;
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const ty = self.typeOf(bin_op.lhs);
const result: Condition = result: {
@@ -11313,7 +11313,7 @@ fn airCmp(self: *Self, inst: Air.Inst.Index, op: math.CompareOperator) !void {
}
fn airCmpVector(self: *Self, inst: Air.Inst.Index) !void {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.VectorCmp, ty_pl.payload).data;
const dst_mcv = try self.genBinOp(
inst,
@@ -11326,7 +11326,7 @@ fn airCmpVector(self: *Self, inst: Air.Inst.Index) !void {
fn airCmpLtErrorsLen(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const addr_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp);
const addr_lock = self.register_manager.lockRegAssumeUnused(addr_reg);
@@ -11356,18 +11356,18 @@ fn airCmpLtErrorsLen(self: *Self, inst: Air.Inst.Index) !void {
}
fn airTry(self: *Self, inst: Air.Inst.Index) !void {
- const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const extra = self.air.extraData(Air.Try, pl_op.payload);
- const body = self.air.extra[extra.end..][0..extra.data.body_len];
+ const body: []const Air.Inst.Index = @ptrCast(self.air.extra[extra.end..][0..extra.data.body_len]);
const operand_ty = self.typeOf(pl_op.operand);
const result = try self.genTry(inst, pl_op.operand, body, operand_ty, false);
return self.finishAir(inst, result, .{ .none, .none, .none });
}
fn airTryPtr(self: *Self, inst: Air.Inst.Index) !void {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.TryPtr, ty_pl.payload);
- const body = self.air.extra[extra.end..][0..extra.data.body_len];
+ const body: []const Air.Inst.Index = @ptrCast(self.air.extra[extra.end..][0..extra.data.body_len]);
const operand_ty = self.typeOf(extra.data.ptr);
const result = try self.genTry(inst, extra.data.ptr, body, operand_ty, true);
return self.finishAir(inst, result, .{ .none, .none, .none });
@@ -11392,7 +11392,7 @@ fn genTry(
const reloc = try self.genCondBrMir(Type.anyerror, is_err_mcv);
if (self.liveness.operandDies(inst, 0)) {
- if (Air.refToIndex(operand)) |operand_inst| try self.processDeath(operand_inst);
+ if (operand.toIndex()) |operand_inst| try self.processDeath(operand_inst);
}
self.scope_generation += 1;
@@ -11421,7 +11421,7 @@ fn genTry(
}
fn airDbgStmt(self: *Self, inst: Air.Inst.Index) !void {
- const dbg_stmt = self.air.instructions.items(.data)[inst].dbg_stmt;
+ const dbg_stmt = self.air.instructions.items(.data)[@intFromEnum(inst)].dbg_stmt;
_ = try self.addInst(.{
.tag = .pseudo,
.ops = .pseudo_dbg_line_line_column,
@@ -11434,7 +11434,7 @@ fn airDbgStmt(self: *Self, inst: Air.Inst.Index) !void {
}
fn airDbgInline(self: *Self, inst: Air.Inst.Index) !void {
- const ty_fn = self.air.instructions.items(.data)[inst].ty_fn;
+ const ty_fn = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_fn;
_ = try self.addInst(.{
.tag = .pseudo,
.ops = .pseudo_dbg_inline_func,
@@ -11450,14 +11450,14 @@ fn airDbgBlock(self: *Self, inst: Air.Inst.Index) !void {
}
fn airDbgVar(self: *Self, inst: Air.Inst.Index) !void {
- const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const operand = pl_op.operand;
const ty = self.typeOf(operand);
const mcv = try self.resolveInst(operand);
const name = self.air.nullTerminatedString(pl_op.payload);
- const tag = self.air.instructions.items(.tag)[inst];
+ const tag = self.air.instructions.items(.tag)[@intFromEnum(inst)];
try self.genVarDbgInfo(tag, ty, mcv, name);
return self.finishAir(inst, .unreach, .{ operand, .none, .none });
@@ -11492,19 +11492,21 @@ fn genCondBrMir(self: *Self, ty: Type, mcv: MCValue) !Mir.Inst.Index {
}
fn airCondBr(self: *Self, inst: Air.Inst.Index) !void {
- const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const cond = try self.resolveInst(pl_op.operand);
const cond_ty = self.typeOf(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 then_body: []const Air.Inst.Index =
+ @ptrCast(self.air.extra[extra.end..][0..extra.data.then_body_len]);
+ const else_body: []const Air.Inst.Index =
+ @ptrCast(self.air.extra[extra.end + then_body.len ..][0..extra.data.else_body_len]);
const liveness_cond_br = self.liveness.getCondBr(inst);
// If the condition dies here in this condbr instruction, process
// that death now instead of later as this has an effect on
// whether it needs to be spilled in the branches
if (self.liveness.operandDies(inst, 0)) {
- if (Air.refToIndex(pl_op.operand)) |op_inst| try self.processDeath(op_inst);
+ if (pl_op.operand.toIndex()) |op_inst| try self.processDeath(op_inst);
}
self.scope_generation += 1;
@@ -11789,7 +11791,7 @@ fn isNonErrPtr(self: *Self, inst: Air.Inst.Index, ptr_ty: Type, ptr_mcv: MCValue
}
fn airIsNull(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try self.resolveInst(un_op);
const ty = self.typeOf(un_op);
const result = try self.isNull(inst, ty, operand);
@@ -11797,7 +11799,7 @@ fn airIsNull(self: *Self, inst: Air.Inst.Index) !void {
}
fn airIsNullPtr(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try self.resolveInst(un_op);
const ty = self.typeOf(un_op);
const result = try self.isNullPtr(inst, ty, operand);
@@ -11805,7 +11807,7 @@ fn airIsNullPtr(self: *Self, inst: Air.Inst.Index) !void {
}
fn airIsNonNull(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try self.resolveInst(un_op);
const ty = self.typeOf(un_op);
const result = switch (try self.isNull(inst, ty, operand)) {
@@ -11816,7 +11818,7 @@ fn airIsNonNull(self: *Self, inst: Air.Inst.Index) !void {
}
fn airIsNonNullPtr(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try self.resolveInst(un_op);
const ty = self.typeOf(un_op);
const result = switch (try self.isNullPtr(inst, ty, operand)) {
@@ -11827,7 +11829,7 @@ fn airIsNonNullPtr(self: *Self, inst: Air.Inst.Index) !void {
}
fn airIsErr(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try self.resolveInst(un_op);
const ty = self.typeOf(un_op);
const result = try self.isErr(inst, ty, operand);
@@ -11835,7 +11837,7 @@ fn airIsErr(self: *Self, inst: Air.Inst.Index) !void {
}
fn airIsErrPtr(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try self.resolveInst(un_op);
const ty = self.typeOf(un_op);
const result = try self.isErrPtr(inst, ty, operand);
@@ -11843,7 +11845,7 @@ fn airIsErrPtr(self: *Self, inst: Air.Inst.Index) !void {
}
fn airIsNonErr(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try self.resolveInst(un_op);
const ty = self.typeOf(un_op);
const result = try self.isNonErr(inst, ty, operand);
@@ -11851,7 +11853,7 @@ fn airIsNonErr(self: *Self, inst: Air.Inst.Index) !void {
}
fn airIsNonErrPtr(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try self.resolveInst(un_op);
const ty = self.typeOf(un_op);
const result = try self.isNonErrPtr(inst, ty, operand);
@@ -11860,9 +11862,9 @@ fn airIsNonErrPtr(self: *Self, inst: Air.Inst.Index) !void {
fn airLoop(self: *Self, inst: Air.Inst.Index) !void {
// A loop is a setup to be able to jump back to the beginning.
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(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];
+ const body: []const Air.Inst.Index = @ptrCast(self.air.extra[loop.end..][0..loop.data.body_len]);
self.scope_generation += 1;
const state = try self.saveState();
@@ -11889,9 +11891,9 @@ fn airBlock(self: *Self, inst: Air.Inst.Index) !void {
try self.blocks.putNoClobber(self.gpa, inst, .{ .state = self.initRetroactiveState() });
const liveness = self.liveness.getBlock(inst);
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.Block, ty_pl.payload);
- const body = self.air.extra[extra.end..][0..extra.data.body_len];
+ const body: []const Air.Inst.Index = @ptrCast(self.air.extra[extra.end..][0..extra.data.body_len]);
try self.genBody(body);
var block_data = self.blocks.fetchRemove(inst).?;
@@ -11914,7 +11916,7 @@ fn airBlock(self: *Self, inst: Air.Inst.Index) !void {
}
fn airSwitchBr(self: *Self, inst: Air.Inst.Index) !void {
- const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const condition = try self.resolveInst(pl_op.operand);
const condition_ty = self.typeOf(pl_op.operand);
const switch_br = self.air.extraData(Air.SwitchBr, pl_op.payload);
@@ -11927,7 +11929,7 @@ fn airSwitchBr(self: *Self, inst: Air.Inst.Index) !void {
// that death now instead of later as this has an effect on
// whether it needs to be spilled in the branches
if (self.liveness.operandDies(inst, 0)) {
- if (Air.refToIndex(pl_op.operand)) |op_inst| try self.processDeath(op_inst);
+ if (pl_op.operand.toIndex()) |op_inst| try self.processDeath(op_inst);
}
self.scope_generation += 1;
@@ -11937,7 +11939,8 @@ fn airSwitchBr(self: *Self, inst: Air.Inst.Index) !void {
const case = self.air.extraData(Air.SwitchBr.Case, extra_index);
const items: []const Air.Inst.Ref =
@ptrCast(self.air.extra[case.end..][0..case.data.items_len]);
- const case_body = self.air.extra[case.end + items.len ..][0..case.data.body_len];
+ const case_body: []const Air.Inst.Index =
+ @ptrCast(self.air.extra[case.end + items.len ..][0..case.data.body_len]);
extra_index = case.end + items.len + case_body.len;
var relocs = try self.gpa.alloc(Mir.Inst.Index, items.len);
@@ -11975,7 +11978,8 @@ fn airSwitchBr(self: *Self, inst: Air.Inst.Index) !void {
}
if (switch_br.data.else_body_len > 0) {
- const else_body = self.air.extra[extra_index..][0..switch_br.data.else_body_len];
+ const else_body: []const Air.Inst.Index =
+ @ptrCast(self.air.extra[extra_index..][0..switch_br.data.else_body_len]);
const else_deaths = liveness.deaths.len - 1;
for (liveness.deaths[else_deaths]) |operand| try self.processDeath(operand);
@@ -12008,7 +12012,7 @@ fn performReloc(self: *Self, reloc: Mir.Inst.Index) !void {
fn airBr(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const br = self.air.instructions.items(.data)[inst].br;
+ const br = self.air.instructions.items(.data)[@intFromEnum(inst)].br;
const block_ty = self.typeOfIndex(br.block_inst);
const block_unused =
@@ -12043,7 +12047,7 @@ fn airBr(self: *Self, inst: Air.Inst.Index) !void {
// Process operand death so that it is properly accounted for in the State below.
if (self.liveness.operandDies(inst, 0)) {
- if (Air.refToIndex(br.operand)) |op_inst| try self.processDeath(op_inst);
+ if (br.operand.toIndex()) |op_inst| try self.processDeath(op_inst);
}
if (first_br) {
@@ -12069,7 +12073,7 @@ fn airBr(self: *Self, inst: Air.Inst.Index) !void {
fn airAsm(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.Asm, ty_pl.payload);
const clobbers_len: u31 = @truncate(extra.data.flags);
var extra_i: usize = extra.end;
@@ -13784,7 +13788,7 @@ fn genLazySymbolRef(
}
fn airIntFromPtr(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const result = result: {
// TODO: handle case where the operand is a slice not a raw pointer
const src_mcv = try self.resolveInst(un_op);
@@ -13800,7 +13804,7 @@ fn airIntFromPtr(self: *Self, inst: Air.Inst.Index) !void {
fn airBitCast(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const dst_ty = self.typeOfIndex(inst);
const src_ty = self.typeOf(ty_op.operand);
@@ -13858,7 +13862,7 @@ fn airBitCast(self: *Self, inst: Air.Inst.Index) !void {
fn airArrayToSlice(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const slice_ty = self.typeOfIndex(inst);
const ptr_ty = self.typeOf(ty_op.operand);
@@ -13881,7 +13885,7 @@ fn airArrayToSlice(self: *Self, inst: Air.Inst.Index) !void {
fn airFloatFromInt(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const dst_ty = self.typeOfIndex(inst);
const dst_bits = dst_ty.floatBits(self.target.*);
@@ -13960,7 +13964,7 @@ fn airFloatFromInt(self: *Self, inst: Air.Inst.Index) !void {
fn airIntFromFloat(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const dst_ty = self.typeOfIndex(inst);
const dst_bits: u32 = @intCast(dst_ty.bitSize(mod));
@@ -14031,7 +14035,7 @@ fn airIntFromFloat(self: *Self, inst: Air.Inst.Index) !void {
fn airCmpxchg(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.Cmpxchg, ty_pl.payload).data;
const ptr_ty = self.typeOf(extra.ptr);
@@ -14388,7 +14392,7 @@ fn atomicOp(
}
fn airAtomicRmw(self: *Self, inst: Air.Inst.Index) !void {
- const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const extra = self.air.extraData(Air.AtomicRmw, pl_op.payload).data;
try self.spillRegisters(&.{ .rax, .rdx, .rbx, .rcx });
@@ -14409,7 +14413,7 @@ fn airAtomicRmw(self: *Self, inst: Air.Inst.Index) !void {
}
fn airAtomicLoad(self: *Self, inst: Air.Inst.Index) !void {
- const atomic_load = self.air.instructions.items(.data)[inst].atomic_load;
+ const atomic_load = self.air.instructions.items(.data)[@intFromEnum(inst)].atomic_load;
const ptr_ty = self.typeOf(atomic_load.ptr);
const ptr_mcv = try self.resolveInst(atomic_load.ptr);
@@ -14430,7 +14434,7 @@ fn airAtomicLoad(self: *Self, inst: Air.Inst.Index) !void {
}
fn airAtomicStore(self: *Self, inst: Air.Inst.Index, order: std.builtin.AtomicOrder) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const ptr_ty = self.typeOf(bin_op.lhs);
const ptr_mcv = try self.resolveInst(bin_op.lhs);
@@ -14450,7 +14454,7 @@ fn airMemset(self: *Self, inst: Air.Inst.Index, safety: bool) !void {
// TODO if the value is undef, don't lower this instruction
}
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
try self.spillRegisters(&.{ .rdi, .rsi, .rcx });
const reg_locks = self.register_manager.lockRegsAssumeUnused(3, .{ .rdi, .rsi, .rcx });
@@ -14571,7 +14575,7 @@ fn airMemset(self: *Self, inst: Air.Inst.Index, safety: bool) !void {
fn airMemcpy(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
try self.spillRegisters(&.{ .rdi, .rsi, .rcx });
const reg_locks = self.register_manager.lockRegsAssumeUnused(3, .{ .rdi, .rsi, .rcx });
@@ -14626,7 +14630,7 @@ fn airMemcpy(self: *Self, inst: Air.Inst.Index) !void {
fn airTagName(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const inst_ty = self.typeOfIndex(inst);
const enum_ty = self.typeOf(un_op);
const resolved_cc = abi.resolveCallingConvention(.Unspecified, self.target.*);
@@ -14668,7 +14672,7 @@ fn airTagName(self: *Self, inst: Air.Inst.Index) !void {
fn airErrorName(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const err_ty = self.typeOf(un_op);
const err_mcv = try self.resolveInst(un_op);
@@ -14770,7 +14774,7 @@ fn airErrorName(self: *Self, inst: Air.Inst.Index) !void {
fn airSplat(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const vector_ty = self.typeOfIndex(inst);
const vector_len = vector_ty.vectorLen(mod);
const dst_rc = self.regClassForType(vector_ty);
@@ -15106,7 +15110,7 @@ fn airSplat(self: *Self, inst: Air.Inst.Index) !void {
}
fn airSelect(self: *Self, inst: Air.Inst.Index) !void {
- const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const extra = self.air.extraData(Air.Bin, pl_op.payload).data;
_ = extra;
return self.fail("TODO implement airSelect for x86_64", .{});
@@ -15114,7 +15118,7 @@ fn airSelect(self: *Self, inst: Air.Inst.Index) !void {
}
fn airShuffle(self: *Self, inst: Air.Inst.Index) !void {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
_ = ty_pl;
return self.fail("TODO implement airShuffle for x86_64", .{});
//return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
@@ -15122,7 +15126,7 @@ fn airShuffle(self: *Self, inst: Air.Inst.Index) !void {
fn airReduce(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const reduce = self.air.instructions.items(.data)[inst].reduce;
+ const reduce = self.air.instructions.items(.data)[@intFromEnum(inst)].reduce;
const result: MCValue = result: {
const operand_ty = self.typeOf(reduce.operand);
@@ -15181,7 +15185,7 @@ fn airAggregateInit(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
const result_ty = self.typeOfIndex(inst);
const len: usize = @intCast(result_ty.arrayLen(mod));
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const elements: []const Air.Inst.Ref = @ptrCast(self.air.extra[ty_pl.payload..][0..len]);
const result: MCValue = result: {
switch (result_ty.zigTypeTag(mod)) {
@@ -15321,7 +15325,7 @@ fn airAggregateInit(self: *Self, inst: Air.Inst.Index) !void {
fn airUnionInit(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
const ip = &mod.intern_pool;
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.UnionInit, ty_pl.payload).data;
const result: MCValue = result: {
const union_ty = self.typeOfIndex(inst);
@@ -15365,13 +15369,13 @@ fn airUnionInit(self: *Self, inst: Air.Inst.Index) !void {
}
fn airPrefetch(self: *Self, inst: Air.Inst.Index) !void {
- const prefetch = self.air.instructions.items(.data)[inst].prefetch;
+ const prefetch = self.air.instructions.items(.data)[@intFromEnum(inst)].prefetch;
return self.finishAir(inst, .unreach, .{ prefetch.ptr, .none, .none });
}
fn airMulAdd(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const extra = self.air.extraData(Air.Bin, pl_op.payload).data;
const ty = self.typeOfIndex(inst);
@@ -15538,7 +15542,7 @@ fn airMulAdd(self: *Self, inst: Air.Inst.Index) !void {
fn airVaStart(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const va_list_ty = self.air.instructions.items(.data)[inst].ty;
+ const va_list_ty = self.air.instructions.items(.data)[@intFromEnum(inst)].ty;
const ptr_anyopaque_ty = try mod.singleMutPtrType(Type.anyopaque);
const result: MCValue = switch (abi.resolveCallingConvention(
@@ -15591,7 +15595,7 @@ fn airVaStart(self: *Self, inst: Air.Inst.Index) !void {
fn airVaArg(self: *Self, inst: Air.Inst.Index) !void {
const mod = self.bin_file.options.module.?;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const ty = self.typeOfIndex(inst);
const promote_ty = self.promoteVarArg(ty);
const ptr_anyopaque_ty = try mod.singleMutPtrType(Type.anyopaque);
@@ -15785,7 +15789,7 @@ fn airVaArg(self: *Self, inst: Air.Inst.Index) !void {
}
fn airVaCopy(self: *Self, inst: Air.Inst.Index) !void {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const ptr_va_list_ty = self.typeOf(ty_op.operand);
const dst_mcv = try self.allocRegOrMem(inst, true);
@@ -15794,7 +15798,7 @@ fn airVaCopy(self: *Self, inst: Air.Inst.Index) !void {
}
fn airVaEnd(self: *Self, inst: Air.Inst.Index) !void {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
return self.finishAir(inst, .unreach, .{ un_op, .none, .none });
}
@@ -15805,10 +15809,10 @@ fn resolveInst(self: *Self, ref: Air.Inst.Ref) InnerError!MCValue {
// If the type has no codegen bits, no need to store it.
if (!ty.hasRuntimeBitsIgnoreComptime(mod)) return .none;
- const mcv = if (Air.refToIndex(ref)) |inst| mcv: {
+ const mcv = if (ref.toIndex()) |inst| mcv: {
break :mcv self.inst_tracking.getPtr(inst).?.short;
} else mcv: {
- const ip_index = Air.refToInterned(ref).?;
+ const ip_index = ref.toInterned().?;
const gop = try self.const_tracking.getOrPut(self.gpa, ip_index);
if (!gop.found_existing) gop.value_ptr.* = InstTracking.init(init: {
const const_mcv = try self.genTypedValue(.{ .ty = ty, .val = Value.fromInterned(ip_index) });
src/codegen/c.zig
@@ -329,9 +329,13 @@ pub const Function = struct {
return .{ .new_local = @intCast(f.locals.items.len - 1) };
}
- fn allocLocal(f: *Function, inst: Air.Inst.Index, ty: Type) !CValue {
+ fn allocLocal(f: *Function, inst: ?Air.Inst.Index, ty: Type) !CValue {
const result = try f.allocAlignedLocal(ty, .{}, .none);
- log.debug("%{d}: allocating t{d}", .{ inst, result.new_local });
+ if (inst) |i| {
+ log.debug("%{d}: allocating t{d}", .{ i, result.new_local });
+ } else {
+ log.debug("allocating t{d}", .{result.new_local});
+ }
return result;
}
@@ -2951,7 +2955,7 @@ fn genBodyResolveState(f: *Function, inst: Air.Inst.Index, leading_deaths: []con
const pre_locals_len = @as(LocalIndex, @intCast(f.locals.items.len));
for (leading_deaths) |death| {
- try die(f, inst, Air.indexToRef(death));
+ try die(f, inst, death.toRef());
}
if (inner) {
@@ -2969,11 +2973,11 @@ fn genBodyResolveState(f: *Function, inst: Air.Inst.Index, leading_deaths: []con
// them, unless they were used to store allocs.
for (pre_locals_len..f.locals.items.len) |local_i| {
- const local_index = @as(LocalIndex, @intCast(local_i));
+ const local_index: LocalIndex = @intCast(local_i);
if (f.allocs.contains(local_index)) {
continue;
}
- try freeLocal(f, inst, local_index, 0);
+ try freeLocal(f, inst, local_index, null);
}
}
@@ -2986,7 +2990,7 @@ fn genBodyInner(f: *Function, body: []const Air.Inst.Index) error{ AnalysisFail,
if (f.liveness.isUnused(inst) and !f.air.mustLower(inst, ip))
continue;
- const result_value = switch (air_tags[inst]) {
+ const result_value = switch (air_tags[@intFromEnum(inst)]) {
// zig fmt: off
.inferred_alloc, .inferred_alloc_comptime => unreachable,
@@ -3013,7 +3017,7 @@ fn genBodyInner(f: *Function, body: []const Air.Inst.Index) error{ AnalysisFail,
.div_trunc, .div_exact => try airBinOp(f, inst, "/", "div_trunc", .none),
.rem => blk: {
- const bin_op = f.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const lhs_scalar_ty = f.typeOf(bin_op.lhs).scalarType(mod);
// For binary operations @TypeOf(lhs)==@TypeOf(rhs),
// so we only check one.
@@ -3061,16 +3065,16 @@ fn genBodyInner(f: *Function, body: []const Air.Inst.Index) error{ AnalysisFail,
.slice => try airSlice(f, inst),
- .cmp_gt => try airCmpOp(f, inst, f.air.instructions.items(.data)[inst].bin_op, .gt),
- .cmp_gte => try airCmpOp(f, inst, f.air.instructions.items(.data)[inst].bin_op, .gte),
- .cmp_lt => try airCmpOp(f, inst, f.air.instructions.items(.data)[inst].bin_op, .lt),
- .cmp_lte => try airCmpOp(f, inst, f.air.instructions.items(.data)[inst].bin_op, .lte),
+ .cmp_gt => try airCmpOp(f, inst, f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op, .gt),
+ .cmp_gte => try airCmpOp(f, inst, f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op, .gte),
+ .cmp_lt => try airCmpOp(f, inst, f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op, .lt),
+ .cmp_lte => try airCmpOp(f, inst, f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op, .lte),
.cmp_eq => try airEquality(f, inst, .eq),
.cmp_neq => try airEquality(f, inst, .neq),
.cmp_vector => blk: {
- const ty_pl = f.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = f.air.extraData(Air.VectorCmp, ty_pl.payload).data;
break :blk try airCmpOp(f, inst, extra, extra.compareOperator());
},
@@ -3256,7 +3260,7 @@ fn genBodyInner(f: *Function, body: []const Air.Inst.Index) error{ AnalysisFail,
if (result_value == .new_local) {
log.debug("map %{d} to t{d}", .{ inst, result_value.new_local });
}
- try f.value_map.putNoClobber(Air.indexToRef(inst), switch (result_value) {
+ try f.value_map.putNoClobber(inst.toRef(), switch (result_value) {
.none => continue,
.new_local => |i| .{ .local = i },
else => result_value,
@@ -3265,7 +3269,7 @@ fn genBodyInner(f: *Function, body: []const Air.Inst.Index) error{ AnalysisFail,
}
fn airSliceField(f: *Function, inst: Air.Inst.Index, is_ptr: bool, field_name: []const u8) !CValue {
- const ty_op = f.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const inst_ty = f.typeOfIndex(inst);
const operand = try f.resolveInst(ty_op.operand);
@@ -3287,7 +3291,7 @@ fn airSliceField(f: *Function, inst: Air.Inst.Index, is_ptr: bool, field_name: [
fn airPtrElemVal(f: *Function, inst: Air.Inst.Index) !CValue {
const mod = f.object.dg.module;
const inst_ty = f.typeOfIndex(inst);
- const bin_op = f.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
if (!inst_ty.hasRuntimeBitsIgnoreComptime(mod)) {
try reap(f, inst, &.{ bin_op.lhs, bin_op.rhs });
return .none;
@@ -3312,7 +3316,7 @@ fn airPtrElemVal(f: *Function, inst: Air.Inst.Index) !CValue {
fn airPtrElemPtr(f: *Function, inst: Air.Inst.Index) !CValue {
const mod = f.object.dg.module;
- const ty_pl = f.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const bin_op = f.air.extraData(Air.Bin, ty_pl.payload).data;
const inst_ty = f.typeOfIndex(inst);
@@ -3349,7 +3353,7 @@ fn airPtrElemPtr(f: *Function, inst: Air.Inst.Index) !CValue {
fn airSliceElemVal(f: *Function, inst: Air.Inst.Index) !CValue {
const mod = f.object.dg.module;
const inst_ty = f.typeOfIndex(inst);
- const bin_op = f.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
if (!inst_ty.hasRuntimeBitsIgnoreComptime(mod)) {
try reap(f, inst, &.{ bin_op.lhs, bin_op.rhs });
return .none;
@@ -3374,7 +3378,7 @@ fn airSliceElemVal(f: *Function, inst: Air.Inst.Index) !CValue {
fn airSliceElemPtr(f: *Function, inst: Air.Inst.Index) !CValue {
const mod = f.object.dg.module;
- const ty_pl = f.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const bin_op = f.air.extraData(Air.Bin, ty_pl.payload).data;
const inst_ty = f.typeOfIndex(inst);
@@ -3404,7 +3408,7 @@ fn airSliceElemPtr(f: *Function, inst: Air.Inst.Index) !CValue {
fn airArrayElemVal(f: *Function, inst: Air.Inst.Index) !CValue {
const mod = f.object.dg.module;
- const bin_op = f.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const inst_ty = f.typeOfIndex(inst);
if (!inst_ty.hasRuntimeBitsIgnoreComptime(mod)) {
try reap(f, inst, &.{ bin_op.lhs, bin_op.rhs });
@@ -3486,7 +3490,7 @@ fn airArg(f: *Function, inst: Air.Inst.Index) !CValue {
fn airLoad(f: *Function, inst: Air.Inst.Index) !CValue {
const mod = f.object.dg.module;
- const ty_op = f.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const ptr_ty = f.typeOf(ty_op.operand);
const ptr_scalar_ty = ptr_ty.scalarType(mod);
@@ -3573,14 +3577,14 @@ fn airLoad(f: *Function, inst: Air.Inst.Index) !CValue {
fn airRet(f: *Function, inst: Air.Inst.Index, is_ptr: bool) !CValue {
const mod = f.object.dg.module;
- const un_op = f.air.instructions.items(.data)[inst].un_op;
+ const un_op = f.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const writer = f.object.writer();
- const op_inst = Air.refToIndex(un_op);
+ const op_inst = un_op.toIndex();
const op_ty = f.typeOf(un_op);
const ret_ty = if (is_ptr) op_ty.childType(mod) else op_ty;
const lowered_ret_ty = try lowerFnRetTy(ret_ty, mod);
- if (op_inst != null and f.air.instructions.items(.tag)[op_inst.?] == .call_always_tail) {
+ if (op_inst != null and f.air.instructions.items(.tag)[@intFromEnum(op_inst.?)] == .call_always_tail) {
try reap(f, inst, &.{un_op});
_ = try airCall(f, op_inst.?, .always_tail);
} else if (lowered_ret_ty.hasRuntimeBitsIgnoreComptime(mod)) {
@@ -3611,7 +3615,7 @@ fn airRet(f: *Function, inst: Air.Inst.Index, is_ptr: bool) !CValue {
try f.writeCValue(writer, ret_val, .Other);
try writer.writeAll(";\n");
if (is_array) {
- try freeLocal(f, inst, ret_val.new_local, 0);
+ try freeLocal(f, inst, ret_val.new_local, null);
}
} else {
try reap(f, inst, &.{un_op});
@@ -3623,7 +3627,7 @@ fn airRet(f: *Function, inst: Air.Inst.Index, is_ptr: bool) !CValue {
fn airIntCast(f: *Function, inst: Air.Inst.Index) !CValue {
const mod = f.object.dg.module;
- const ty_op = f.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand = try f.resolveInst(ty_op.operand);
try reap(f, inst, &.{ty_op.operand});
@@ -3649,7 +3653,7 @@ fn airIntCast(f: *Function, inst: Air.Inst.Index) !CValue {
fn airTrunc(f: *Function, inst: Air.Inst.Index) !CValue {
const mod = f.object.dg.module;
- const ty_op = f.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand = try f.resolveInst(ty_op.operand);
try reap(f, inst, &.{ty_op.operand});
@@ -3732,7 +3736,7 @@ fn airTrunc(f: *Function, inst: Air.Inst.Index) !CValue {
}
fn airIntFromBool(f: *Function, inst: Air.Inst.Index) !CValue {
- const un_op = f.air.instructions.items(.data)[inst].un_op;
+ const un_op = f.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try f.resolveInst(un_op);
try reap(f, inst, &.{un_op});
const writer = f.object.writer();
@@ -3749,7 +3753,7 @@ fn airIntFromBool(f: *Function, inst: Air.Inst.Index) !CValue {
fn airStore(f: *Function, inst: Air.Inst.Index, safety: bool) !CValue {
const mod = f.object.dg.module;
// *a = b;
- const bin_op = f.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const ptr_ty = f.typeOf(bin_op.lhs);
const ptr_scalar_ty = ptr_ty.scalarType(mod);
@@ -3815,7 +3819,7 @@ fn airStore(f: *Function, inst: Air.Inst.Index, safety: bool) !CValue {
try f.renderType(writer, src_ty);
try writer.writeAll("))");
if (src_val == .constant) {
- try freeLocal(f, inst, array_src.new_local, 0);
+ try freeLocal(f, inst, array_src.new_local, null);
}
} else if (ptr_info.packed_offset.host_size > 0 and ptr_info.flags.vector_index == .none) {
const host_bits = ptr_info.packed_offset.host_size * 8;
@@ -3887,7 +3891,7 @@ fn airStore(f: *Function, inst: Air.Inst.Index, safety: bool) !CValue {
fn airOverflow(f: *Function, inst: Air.Inst.Index, operation: []const u8, info: BuiltinInfo) !CValue {
const mod = f.object.dg.module;
- const ty_pl = f.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const bin_op = f.air.extraData(Air.Bin, ty_pl.payload).data;
const lhs = try f.resolveInst(bin_op.lhs);
@@ -3925,7 +3929,7 @@ fn airOverflow(f: *Function, inst: Air.Inst.Index, operation: []const u8, info:
fn airNot(f: *Function, inst: Air.Inst.Index) !CValue {
const mod = f.object.dg.module;
- const ty_op = f.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand_ty = f.typeOf(ty_op.operand);
const scalar_ty = operand_ty.scalarType(mod);
if (scalar_ty.ip_index != .bool_type) return try airUnBuiltinCall(f, inst, "not", .bits);
@@ -3958,7 +3962,7 @@ fn airBinOp(
info: BuiltinInfo,
) !CValue {
const mod = f.object.dg.module;
- const bin_op = f.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const operand_ty = f.typeOf(bin_op.lhs);
const scalar_ty = operand_ty.scalarType(mod);
if ((scalar_ty.isInt(mod) and scalar_ty.bitSize(mod) > 64) or scalar_ty.isRuntimeFloat())
@@ -4046,7 +4050,7 @@ fn airEquality(
operator: std.math.CompareOperator,
) !CValue {
const mod = f.object.dg.module;
- const bin_op = f.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const operand_ty = f.typeOf(bin_op.lhs);
const operand_bits = operand_ty.bitSize(mod);
@@ -4109,7 +4113,7 @@ fn airEquality(
}
fn airCmpLtErrorsLen(f: *Function, inst: Air.Inst.Index) !CValue {
- const un_op = f.air.instructions.items(.data)[inst].un_op;
+ const un_op = f.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const inst_ty = f.typeOfIndex(inst);
const operand = try f.resolveInst(un_op);
@@ -4126,7 +4130,7 @@ fn airCmpLtErrorsLen(f: *Function, inst: Air.Inst.Index) !CValue {
fn airPtrAddSub(f: *Function, inst: Air.Inst.Index, operator: u8) !CValue {
const mod = f.object.dg.module;
- const ty_pl = f.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const bin_op = f.air.extraData(Air.Bin, ty_pl.payload).data;
const lhs = try f.resolveInst(bin_op.lhs);
@@ -4174,7 +4178,7 @@ fn airPtrAddSub(f: *Function, inst: Air.Inst.Index, operator: u8) !CValue {
fn airMinMax(f: *Function, inst: Air.Inst.Index, operator: u8, operation: []const u8) !CValue {
const mod = f.object.dg.module;
- const bin_op = f.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const inst_ty = f.typeOfIndex(inst);
const inst_scalar_ty = inst_ty.scalarType(mod);
@@ -4216,7 +4220,7 @@ fn airMinMax(f: *Function, inst: Air.Inst.Index, operator: u8, operation: []cons
fn airSlice(f: *Function, inst: Air.Inst.Index) !CValue {
const mod = f.object.dg.module;
- const ty_pl = f.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const bin_op = f.air.extraData(Air.Bin, ty_pl.payload).data;
const ptr = try f.resolveInst(bin_op.lhs);
@@ -4260,7 +4264,7 @@ fn airCall(
const gpa = f.object.dg.gpa;
const writer = f.object.writer();
- const pl_op = f.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = f.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const extra = f.air.extraData(Air.Call, pl_op.payload);
const args = @as([]const Air.Inst.Ref, @ptrCast(f.air.extra[extra.end..][0..extra.data.args_len]));
@@ -4366,7 +4370,7 @@ fn airCall(
if (resolved_arg == .none) continue;
if (args_written != 0) try writer.writeAll(", ");
try f.writeCValue(writer, resolved_arg, .FunctionArgument);
- if (resolved_arg == .new_local) try freeLocal(f, inst, resolved_arg.new_local, 0);
+ if (resolved_arg == .new_local) try freeLocal(f, inst, resolved_arg.new_local, null);
args_written += 1;
}
try writer.writeAll(");\n");
@@ -4383,7 +4387,7 @@ fn airCall(
try writer.writeAll(", sizeof(");
try f.renderType(writer, ret_ty);
try writer.writeAll("));\n");
- try freeLocal(f, inst, result_local.new_local, 0);
+ try freeLocal(f, inst, result_local.new_local, null);
break :result array_local;
};
@@ -4391,7 +4395,7 @@ fn airCall(
}
fn airDbgStmt(f: *Function, inst: Air.Inst.Index) !CValue {
- const dbg_stmt = f.air.instructions.items(.data)[inst].dbg_stmt;
+ const dbg_stmt = f.air.instructions.items(.data)[@intFromEnum(inst)].dbg_stmt;
const writer = f.object.writer();
// TODO re-evaluate whether to emit these or not. If we naively emit
// these directives, the output file will report bogus line numbers because
@@ -4406,7 +4410,7 @@ fn airDbgStmt(f: *Function, inst: Air.Inst.Index) !CValue {
}
fn airDbgInline(f: *Function, inst: Air.Inst.Index) !CValue {
- const ty_fn = f.air.instructions.items(.data)[inst].ty_fn;
+ const ty_fn = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_fn;
const mod = f.object.dg.module;
const writer = f.object.writer();
const owner_decl = mod.funcOwnerDeclPtr(ty_fn.func);
@@ -4418,7 +4422,7 @@ fn airDbgInline(f: *Function, inst: Air.Inst.Index) !CValue {
fn airDbgVar(f: *Function, inst: Air.Inst.Index) !CValue {
const mod = f.object.dg.module;
- const pl_op = f.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = f.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const name = f.air.nullTerminatedString(pl_op.payload);
const operand_is_undef = if (try f.air.value(pl_op.operand, mod)) |v| v.isUndefDeep(mod) else false;
if (!operand_is_undef) _ = try f.resolveInst(pl_op.operand);
@@ -4431,9 +4435,9 @@ fn airDbgVar(f: *Function, inst: Air.Inst.Index) !CValue {
fn airBlock(f: *Function, inst: Air.Inst.Index) !CValue {
const mod = f.object.dg.module;
- const ty_pl = f.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = f.air.extraData(Air.Block, ty_pl.payload);
- const body = f.air.extra[extra.end..][0..extra.data.body_len];
+ const body: []const Air.Inst.Index = @ptrCast(f.air.extra[extra.end..][0..extra.data.body_len]);
const liveness_block = f.liveness.getBlock(inst);
const block_id: usize = f.next_block_index;
@@ -4457,7 +4461,7 @@ fn airBlock(f: *Function, inst: Air.Inst.Index) !CValue {
// The body might result in some values we had beforehand being killed
for (liveness_block.deaths) |death| {
- try die(f, inst, Air.indexToRef(death));
+ try die(f, inst, death.toRef());
}
try f.object.indent_writer.insertNewline();
@@ -4472,18 +4476,18 @@ fn airBlock(f: *Function, inst: Air.Inst.Index) !CValue {
}
fn airTry(f: *Function, inst: Air.Inst.Index) !CValue {
- const pl_op = f.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = f.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const extra = f.air.extraData(Air.Try, pl_op.payload);
- const body = f.air.extra[extra.end..][0..extra.data.body_len];
+ const body: []const Air.Inst.Index = @ptrCast(f.air.extra[extra.end..][0..extra.data.body_len]);
const err_union_ty = f.typeOf(pl_op.operand);
return lowerTry(f, inst, pl_op.operand, body, err_union_ty, false);
}
fn airTryPtr(f: *Function, inst: Air.Inst.Index) !CValue {
const mod = f.object.dg.module;
- const ty_pl = f.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = f.air.extraData(Air.TryPtr, ty_pl.payload);
- const body = f.air.extra[extra.end..][0..extra.data.body_len];
+ const body: []const Air.Inst.Index = @ptrCast(f.air.extra[extra.end..][0..extra.data.body_len]);
const err_union_ty = f.typeOf(extra.data.ptr).childType(mod);
return lowerTry(f, inst, extra.data.ptr, body, err_union_ty, true);
}
@@ -4529,7 +4533,7 @@ fn lowerTry(
// Now we have the "then branch" (in terms of the liveness data); process any deaths.
for (liveness_condbr.then_deaths) |death| {
- try die(f, inst, Air.indexToRef(death));
+ try die(f, inst, death.toRef());
}
if (!payload_has_bits) {
@@ -4559,7 +4563,7 @@ fn lowerTry(
}
fn airBr(f: *Function, inst: Air.Inst.Index) !CValue {
- const branch = f.air.instructions.items(.data)[inst].br;
+ const branch = f.air.instructions.items(.data)[@intFromEnum(inst)].br;
const block = f.blocks.get(branch.block_inst).?;
const result = block.result;
const writer = f.object.writer();
@@ -4582,7 +4586,7 @@ fn airBr(f: *Function, inst: Air.Inst.Index) !CValue {
}
fn airBitcast(f: *Function, inst: Air.Inst.Index) !CValue {
- const ty_op = f.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const dest_ty = f.typeOfIndex(inst);
const operand = try f.resolveInst(ty_op.operand);
@@ -4624,7 +4628,7 @@ const LocalResult = struct {
fn free(lr: LocalResult, f: *Function) !void {
if (lr.need_free) {
- try freeLocal(f, 0, lr.c_value.new_local, 0);
+ try freeLocal(f, null, lr.c_value.new_local, null);
}
}
};
@@ -4648,7 +4652,7 @@ fn bitcast(f: *Function, dest_ty: Type, operand: CValue, operand_ty: Type) !Loca
}
if (dest_ty.isPtrAtRuntime(mod) and operand_ty.isPtrAtRuntime(mod)) {
- const local = try f.allocLocal(0, dest_ty);
+ const local = try f.allocLocal(null, dest_ty);
try f.writeCValue(writer, local, .Other);
try writer.writeAll(" = (");
try f.renderType(writer, dest_ty);
@@ -4662,7 +4666,7 @@ fn bitcast(f: *Function, dest_ty: Type, operand: CValue, operand_ty: Type) !Loca
}
const operand_lval = if (operand == .constant) blk: {
- const operand_local = try f.allocLocal(0, operand_ty);
+ const operand_local = try f.allocLocal(null, operand_ty);
try f.writeCValue(writer, operand_local, .Other);
if (operand_ty.isAbiInt(mod)) {
try writer.writeAll(" = ");
@@ -4676,7 +4680,7 @@ fn bitcast(f: *Function, dest_ty: Type, operand: CValue, operand_ty: Type) !Loca
break :blk operand_local;
} else operand;
- const local = try f.allocLocal(0, dest_ty);
+ const local = try f.allocLocal(null, dest_ty);
try writer.writeAll("memcpy(&");
try f.writeCValue(writer, local, .Other);
try writer.writeAll(", &");
@@ -4741,7 +4745,7 @@ fn bitcast(f: *Function, dest_ty: Type, operand: CValue, operand_ty: Type) !Loca
}
if (operand == .constant) {
- try freeLocal(f, 0, operand_lval.new_local, 0);
+ try freeLocal(f, null, operand_lval.new_local, null);
}
return .{
@@ -4784,7 +4788,7 @@ fn airFrameAddress(f: *Function, inst: Air.Inst.Index) !CValue {
}
fn airFence(f: *Function, inst: Air.Inst.Index) !CValue {
- const atomic_order = f.air.instructions.items(.data)[inst].fence;
+ const atomic_order = f.air.instructions.items(.data)[@intFromEnum(inst)].fence;
const writer = f.object.writer();
try writer.writeAll("zig_fence(");
@@ -4803,9 +4807,9 @@ fn airUnreach(f: *Function) !CValue {
}
fn airLoop(f: *Function, inst: Air.Inst.Index) !CValue {
- const ty_pl = f.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const loop = f.air.extraData(Air.Block, ty_pl.payload);
- const body = f.air.extra[loop.end..][0..loop.data.body_len];
+ const body: []const Air.Inst.Index = @ptrCast(f.air.extra[loop.end..][0..loop.data.body_len]);
const writer = f.object.writer();
try writer.writeAll("for (;;) ");
@@ -4816,12 +4820,12 @@ fn airLoop(f: *Function, inst: Air.Inst.Index) !CValue {
}
fn airCondBr(f: *Function, inst: Air.Inst.Index) !CValue {
- const pl_op = f.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = f.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const cond = try f.resolveInst(pl_op.operand);
try reap(f, inst, &.{pl_op.operand});
const extra = f.air.extraData(Air.CondBr, pl_op.payload);
- const then_body = f.air.extra[extra.end..][0..extra.data.then_body_len];
- const else_body = f.air.extra[extra.end + then_body.len ..][0..extra.data.else_body_len];
+ const then_body: []const Air.Inst.Index = @ptrCast(f.air.extra[extra.end..][0..extra.data.then_body_len]);
+ const else_body: []const Air.Inst.Index = @ptrCast(f.air.extra[extra.end + then_body.len ..][0..extra.data.else_body_len]);
const liveness_condbr = f.liveness.getCondBr(inst);
const writer = f.object.writer();
@@ -4837,7 +4841,7 @@ fn airCondBr(f: *Function, inst: Air.Inst.Index) !CValue {
// `free_locals_map` well defined (our parent is responsible for doing that).
for (liveness_condbr.else_deaths) |death| {
- try die(f, inst, Air.indexToRef(death));
+ try die(f, inst, death.toRef());
}
// We never actually need an else block, because our branches are noreturn so must (for
@@ -4850,7 +4854,7 @@ fn airCondBr(f: *Function, inst: Air.Inst.Index) !CValue {
fn airSwitchBr(f: *Function, inst: Air.Inst.Index) !CValue {
const mod = f.object.dg.module;
- const pl_op = f.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = f.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const condition = try f.resolveInst(pl_op.operand);
try reap(f, inst, &.{pl_op.operand});
const condition_ty = f.typeOf(pl_op.operand);
@@ -4883,7 +4887,7 @@ fn airSwitchBr(f: *Function, inst: Air.Inst.Index) !CValue {
for (0..switch_br.data.cases_len) |case_i| {
const case = f.air.extraData(Air.SwitchBr.Case, extra_index);
const items = @as([]const Air.Inst.Ref, @ptrCast(f.air.extra[case.end..][0..case.data.items_len]));
- const case_body = f.air.extra[case.end + items.len ..][0..case.data.body_len];
+ const case_body: []const Air.Inst.Index = @ptrCast(f.air.extra[case.end + items.len ..][0..case.data.body_len]);
extra_index = case.end + case.data.items_len + case_body.len;
for (items) |item| {
@@ -4903,7 +4907,7 @@ fn airSwitchBr(f: *Function, inst: Air.Inst.Index) !CValue {
try genBodyResolveState(f, inst, liveness.deaths[case_i], case_body, false);
} else {
for (liveness.deaths[case_i]) |death| {
- try die(f, inst, Air.indexToRef(death));
+ try die(f, inst, death.toRef());
}
try genBody(f, case_body);
}
@@ -4911,12 +4915,12 @@ fn airSwitchBr(f: *Function, inst: Air.Inst.Index) !CValue {
// The case body must be noreturn so we don't need to insert a break.
}
- const else_body = f.air.extra[extra_index..][0..switch_br.data.else_body_len];
+ const else_body: []const Air.Inst.Index = @ptrCast(f.air.extra[extra_index..][0..switch_br.data.else_body_len]);
try f.object.indent_writer.insertNewline();
if (else_body.len > 0) {
// Note that this must be the last case (i.e. the `last_case_i` case was not hit above)
for (liveness.deaths[liveness.deaths.len - 1]) |death| {
- try die(f, inst, Air.indexToRef(death));
+ try die(f, inst, death.toRef());
}
try writer.writeAll("default: ");
try genBody(f, else_body);
@@ -4951,7 +4955,7 @@ fn asmInputNeedsLocal(f: *Function, constraint: []const u8, value: CValue) bool
fn airAsm(f: *Function, inst: Air.Inst.Index) !CValue {
const mod = f.object.dg.module;
- const ty_pl = f.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = f.air.extraData(Air.Asm, ty_pl.payload);
const is_volatile = @as(u1, @truncate(extra.data.flags >> 31)) != 0;
const clobbers_len = @as(u31, @truncate(extra.data.flags));
@@ -5213,7 +5217,7 @@ fn airIsNull(
is_ptr: bool,
) !CValue {
const mod = f.object.dg.module;
- const un_op = f.air.instructions.items(.data)[inst].un_op;
+ const un_op = f.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const writer = f.object.writer();
const operand = try f.resolveInst(un_op);
@@ -5259,7 +5263,7 @@ fn airIsNull(
fn airOptionalPayload(f: *Function, inst: Air.Inst.Index) !CValue {
const mod = f.object.dg.module;
- const ty_op = f.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand = try f.resolveInst(ty_op.operand);
try reap(f, inst, &.{ty_op.operand});
@@ -5293,7 +5297,7 @@ fn airOptionalPayload(f: *Function, inst: Air.Inst.Index) !CValue {
fn airOptionalPayloadPtr(f: *Function, inst: Air.Inst.Index) !CValue {
const mod = f.object.dg.module;
- const ty_op = f.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const writer = f.object.writer();
const operand = try f.resolveInst(ty_op.operand);
@@ -5324,7 +5328,7 @@ fn airOptionalPayloadPtr(f: *Function, inst: Air.Inst.Index) !CValue {
fn airOptionalPayloadPtrSet(f: *Function, inst: Air.Inst.Index) !CValue {
const mod = f.object.dg.module;
- const ty_op = f.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const writer = f.object.writer();
const operand = try f.resolveInst(ty_op.operand);
try reap(f, inst, &.{ty_op.operand});
@@ -5433,7 +5437,7 @@ fn fieldLocation(
}
fn airStructFieldPtr(f: *Function, inst: Air.Inst.Index) !CValue {
- const ty_pl = f.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = f.air.extraData(Air.StructField, ty_pl.payload).data;
const container_ptr_val = try f.resolveInst(extra.struct_operand);
@@ -5443,7 +5447,7 @@ fn airStructFieldPtr(f: *Function, inst: Air.Inst.Index) !CValue {
}
fn airStructFieldPtrIndex(f: *Function, inst: Air.Inst.Index, index: u8) !CValue {
- const ty_op = f.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const container_ptr_val = try f.resolveInst(ty_op.operand);
try reap(f, inst, &.{ty_op.operand});
@@ -5453,7 +5457,7 @@ fn airStructFieldPtrIndex(f: *Function, inst: Air.Inst.Index, index: u8) !CValue
fn airFieldParentPtr(f: *Function, inst: Air.Inst.Index) !CValue {
const mod = f.object.dg.module;
- const ty_pl = f.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = f.air.extraData(Air.FieldParentPtr, ty_pl.payload).data;
const container_ptr_ty = f.typeOfIndex(inst);
@@ -5558,7 +5562,7 @@ fn fieldPtr(
fn airStructFieldVal(f: *Function, inst: Air.Inst.Index) !CValue {
const mod = f.object.dg.module;
const ip = &mod.intern_pool;
- const ty_pl = f.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = f.air.extraData(Air.StructField, ty_pl.payload).data;
const inst_ty = f.typeOfIndex(inst);
@@ -5634,7 +5638,7 @@ fn airStructFieldVal(f: *Function, inst: Air.Inst.Index) !CValue {
try writer.writeAll(", sizeof(");
try f.renderType(writer, inst_ty);
try writer.writeAll("));\n");
- try freeLocal(f, inst, temp_local.new_local, 0);
+ try freeLocal(f, inst, temp_local.new_local, null);
return local;
},
},
@@ -5666,7 +5670,7 @@ fn airStructFieldVal(f: *Function, inst: Air.Inst.Index) !CValue {
try writer.writeAll("));\n");
if (struct_byval == .constant) {
- try freeLocal(f, inst, operand_lval.new_local, 0);
+ try freeLocal(f, inst, operand_lval.new_local, null);
}
return local;
@@ -5695,7 +5699,7 @@ fn airStructFieldVal(f: *Function, inst: Air.Inst.Index) !CValue {
/// Note that the result is never a pointer.
fn airUnwrapErrUnionErr(f: *Function, inst: Air.Inst.Index) !CValue {
const mod = f.object.dg.module;
- const ty_op = f.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const inst_ty = f.typeOfIndex(inst);
const operand = try f.resolveInst(ty_op.operand);
@@ -5736,7 +5740,7 @@ fn airUnwrapErrUnionErr(f: *Function, inst: Air.Inst.Index) !CValue {
fn airUnwrapErrUnionPay(f: *Function, inst: Air.Inst.Index, is_ptr: bool) !CValue {
const mod = f.object.dg.module;
- const ty_op = f.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const inst_ty = f.typeOfIndex(inst);
const operand = try f.resolveInst(ty_op.operand);
@@ -5772,7 +5776,7 @@ fn airUnwrapErrUnionPay(f: *Function, inst: Air.Inst.Index, is_ptr: bool) !CValu
fn airWrapOptional(f: *Function, inst: Air.Inst.Index) !CValue {
const mod = f.object.dg.module;
- const ty_op = f.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const inst_ty = f.typeOfIndex(inst);
const repr_is_payload = inst_ty.optionalReprIsPayload(mod);
@@ -5804,7 +5808,7 @@ fn airWrapOptional(f: *Function, inst: Air.Inst.Index) !CValue {
fn airWrapErrUnionErr(f: *Function, inst: Air.Inst.Index) !CValue {
const mod = f.object.dg.module;
- const ty_op = f.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const inst_ty = f.typeOfIndex(inst);
const payload_ty = inst_ty.errorUnionPayload(mod);
@@ -5844,7 +5848,7 @@ fn airWrapErrUnionErr(f: *Function, inst: Air.Inst.Index) !CValue {
fn airErrUnionPayloadPtrSet(f: *Function, inst: Air.Inst.Index) !CValue {
const mod = f.object.dg.module;
const writer = f.object.writer();
- const ty_op = f.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand = try f.resolveInst(ty_op.operand);
const error_union_ty = f.typeOf(ty_op.operand).childType(mod);
@@ -5894,7 +5898,7 @@ fn airSaveErrReturnTraceIndex(f: *Function, inst: Air.Inst.Index) !CValue {
fn airWrapErrUnionPay(f: *Function, inst: Air.Inst.Index) !CValue {
const mod = f.object.dg.module;
- const ty_op = f.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const inst_ty = f.typeOfIndex(inst);
const payload_ty = inst_ty.errorUnionPayload(mod);
@@ -5928,7 +5932,7 @@ fn airWrapErrUnionPay(f: *Function, inst: Air.Inst.Index) !CValue {
fn airIsErr(f: *Function, inst: Air.Inst.Index, is_ptr: bool, operator: []const u8) !CValue {
const mod = f.object.dg.module;
- const un_op = f.air.instructions.items(.data)[inst].un_op;
+ const un_op = f.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const writer = f.object.writer();
const operand = try f.resolveInst(un_op);
@@ -5963,7 +5967,7 @@ fn airIsErr(f: *Function, inst: Air.Inst.Index, is_ptr: bool, operator: []const
fn airArrayToSlice(f: *Function, inst: Air.Inst.Index) !CValue {
const mod = f.object.dg.module;
- const ty_op = f.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand = try f.resolveInst(ty_op.operand);
try reap(f, inst, &.{ty_op.operand});
@@ -5994,7 +5998,7 @@ fn airArrayToSlice(f: *Function, inst: Air.Inst.Index) !CValue {
fn airFloatCast(f: *Function, inst: Air.Inst.Index) !CValue {
const mod = f.object.dg.module;
- const ty_op = f.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const inst_ty = f.typeOfIndex(inst);
const operand = try f.resolveInst(ty_op.operand);
@@ -6037,7 +6041,7 @@ fn airFloatCast(f: *Function, inst: Air.Inst.Index) !CValue {
fn airIntFromPtr(f: *Function, inst: Air.Inst.Index) !CValue {
const mod = f.object.dg.module;
- const un_op = f.air.instructions.items(.data)[inst].un_op;
+ const un_op = f.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try f.resolveInst(un_op);
const operand_ty = f.typeOf(un_op);
@@ -6066,7 +6070,7 @@ fn airUnBuiltinCall(
info: BuiltinInfo,
) !CValue {
const mod = f.object.dg.module;
- const ty_op = f.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand = try f.resolveInst(ty_op.operand);
try reap(f, inst, &.{ty_op.operand});
@@ -6110,7 +6114,7 @@ fn airBinBuiltinCall(
info: BuiltinInfo,
) !CValue {
const mod = f.object.dg.module;
- const bin_op = f.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const operand_ty = f.typeOf(bin_op.lhs);
const operand_cty = try f.typeToCType(operand_ty, .complete);
@@ -6215,7 +6219,7 @@ fn airCmpBuiltinCall(
fn airCmpxchg(f: *Function, inst: Air.Inst.Index, flavor: [*:0]const u8) !CValue {
const mod = f.object.dg.module;
- const ty_pl = f.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = f.air.extraData(Air.Cmpxchg, ty_pl.payload).data;
const inst_ty = f.typeOfIndex(inst);
const ptr = try f.resolveInst(extra.ptr);
@@ -6311,7 +6315,7 @@ fn airCmpxchg(f: *Function, inst: Air.Inst.Index, flavor: [*:0]const u8) !CValue
try new_value_mat.end(f, inst);
if (f.liveness.isUnused(inst)) {
- try freeLocal(f, inst, local.new_local, 0);
+ try freeLocal(f, inst, local.new_local, null);
return .none;
}
@@ -6320,7 +6324,7 @@ fn airCmpxchg(f: *Function, inst: Air.Inst.Index, flavor: [*:0]const u8) !CValue
fn airAtomicRmw(f: *Function, inst: Air.Inst.Index) !CValue {
const mod = f.object.dg.module;
- const pl_op = f.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = f.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const extra = f.air.extraData(Air.AtomicRmw, pl_op.payload).data;
const inst_ty = f.typeOfIndex(inst);
const ptr_ty = f.typeOf(pl_op.operand);
@@ -6366,7 +6370,7 @@ fn airAtomicRmw(f: *Function, inst: Air.Inst.Index) !CValue {
try operand_mat.end(f, inst);
if (f.liveness.isUnused(inst)) {
- try freeLocal(f, inst, local.new_local, 0);
+ try freeLocal(f, inst, local.new_local, null);
return .none;
}
@@ -6375,7 +6379,7 @@ fn airAtomicRmw(f: *Function, inst: Air.Inst.Index) !CValue {
fn airAtomicLoad(f: *Function, inst: Air.Inst.Index) !CValue {
const mod = f.object.dg.module;
- const atomic_load = f.air.instructions.items(.data)[inst].atomic_load;
+ const atomic_load = f.air.instructions.items(.data)[@intFromEnum(inst)].atomic_load;
const ptr = try f.resolveInst(atomic_load.ptr);
try reap(f, inst, &.{atomic_load.ptr});
const ptr_ty = f.typeOf(atomic_load.ptr);
@@ -6411,7 +6415,7 @@ fn airAtomicLoad(f: *Function, inst: Air.Inst.Index) !CValue {
fn airAtomicStore(f: *Function, inst: Air.Inst.Index, order: [*:0]const u8) !CValue {
const mod = f.object.dg.module;
- const bin_op = f.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const ptr_ty = f.typeOf(bin_op.lhs);
const ty = ptr_ty.childType(mod);
const ptr = try f.resolveInst(bin_op.lhs);
@@ -6455,7 +6459,7 @@ fn writeSliceOrPtr(f: *Function, writer: anytype, ptr: CValue, ptr_ty: Type) !vo
fn airMemset(f: *Function, inst: Air.Inst.Index, safety: bool) !CValue {
const mod = f.object.dg.module;
- const bin_op = f.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const dest_ty = f.typeOf(bin_op.lhs);
const dest_slice = try f.resolveInst(bin_op.lhs);
const value = try f.resolveInst(bin_op.rhs);
@@ -6542,7 +6546,7 @@ fn airMemset(f: *Function, inst: Air.Inst.Index, safety: bool) !CValue {
try a.end(f, writer);
try reap(f, inst, &.{ bin_op.lhs, bin_op.rhs });
- try freeLocal(f, inst, index.new_local, 0);
+ try freeLocal(f, inst, index.new_local, null);
return .none;
}
@@ -6577,7 +6581,7 @@ fn airMemset(f: *Function, inst: Air.Inst.Index, safety: bool) !CValue {
fn airMemcpy(f: *Function, inst: Air.Inst.Index) !CValue {
const mod = f.object.dg.module;
- const bin_op = f.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const dest_ptr = try f.resolveInst(bin_op.lhs);
const src_ptr = try f.resolveInst(bin_op.rhs);
const dest_ty = f.typeOf(bin_op.lhs);
@@ -6616,7 +6620,7 @@ fn airMemcpy(f: *Function, inst: Air.Inst.Index) !CValue {
fn airSetUnionTag(f: *Function, inst: Air.Inst.Index) !CValue {
const mod = f.object.dg.module;
- const bin_op = f.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const union_ptr = try f.resolveInst(bin_op.lhs);
const new_tag = try f.resolveInst(bin_op.rhs);
try reap(f, inst, &.{ bin_op.lhs, bin_op.rhs });
@@ -6637,7 +6641,7 @@ fn airSetUnionTag(f: *Function, inst: Air.Inst.Index) !CValue {
fn airGetUnionTag(f: *Function, inst: Air.Inst.Index) !CValue {
const mod = f.object.dg.module;
- const ty_op = f.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand = try f.resolveInst(ty_op.operand);
try reap(f, inst, &.{ty_op.operand});
@@ -6659,7 +6663,7 @@ fn airGetUnionTag(f: *Function, inst: Air.Inst.Index) !CValue {
fn airTagName(f: *Function, inst: Air.Inst.Index) !CValue {
const mod = f.object.dg.module;
- const un_op = f.air.instructions.items(.data)[inst].un_op;
+ const un_op = f.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const inst_ty = f.typeOfIndex(inst);
const enum_ty = f.typeOf(un_op);
@@ -6679,7 +6683,7 @@ fn airTagName(f: *Function, inst: Air.Inst.Index) !CValue {
}
fn airErrorName(f: *Function, inst: Air.Inst.Index) !CValue {
- const un_op = f.air.instructions.items(.data)[inst].un_op;
+ const un_op = f.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const writer = f.object.writer();
const inst_ty = f.typeOfIndex(inst);
@@ -6696,7 +6700,7 @@ fn airErrorName(f: *Function, inst: Air.Inst.Index) !CValue {
fn airSplat(f: *Function, inst: Air.Inst.Index) !CValue {
const mod = f.object.dg.module;
- const ty_op = f.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand = try f.resolveInst(ty_op.operand);
try reap(f, inst, &.{ty_op.operand});
@@ -6719,7 +6723,7 @@ fn airSplat(f: *Function, inst: Air.Inst.Index) !CValue {
}
fn airSelect(f: *Function, inst: Air.Inst.Index) !CValue {
- const pl_op = f.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = f.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const extra = f.air.extraData(Air.Bin, pl_op.payload).data;
const pred = try f.resolveInst(pl_op.operand);
@@ -6751,7 +6755,7 @@ fn airSelect(f: *Function, inst: Air.Inst.Index) !CValue {
fn airShuffle(f: *Function, inst: Air.Inst.Index) !CValue {
const mod = f.object.dg.module;
- const ty_pl = f.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = f.air.extraData(Air.Shuffle, ty_pl.payload).data;
const mask = Value.fromInterned(extra.mask);
@@ -6783,7 +6787,7 @@ fn airShuffle(f: *Function, inst: Air.Inst.Index) !CValue {
fn airReduce(f: *Function, inst: Air.Inst.Index) !CValue {
const mod = f.object.dg.module;
- const reduce = f.air.instructions.items(.data)[inst].reduce;
+ const reduce = f.air.instructions.items(.data)[@intFromEnum(inst)].reduce;
const scalar_ty = f.typeOfIndex(inst);
const operand = try f.resolveInst(reduce.operand);
@@ -6939,7 +6943,7 @@ fn airReduce(f: *Function, inst: Air.Inst.Index) !CValue {
fn airAggregateInit(f: *Function, inst: Air.Inst.Index) !CValue {
const mod = f.object.dg.module;
const ip = &mod.intern_pool;
- const ty_pl = f.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const inst_ty = f.typeOfIndex(inst);
const len = @as(usize, @intCast(inst_ty.arrayLen(mod)));
const elements = @as([]const Air.Inst.Ref, @ptrCast(f.air.extra[ty_pl.payload..][0..len]));
@@ -7069,7 +7073,7 @@ fn airAggregateInit(f: *Function, inst: Air.Inst.Index) !CValue {
fn airUnionInit(f: *Function, inst: Air.Inst.Index) !CValue {
const mod = f.object.dg.module;
const ip = &mod.intern_pool;
- const ty_pl = f.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = f.air.extraData(Air.UnionInit, ty_pl.payload).data;
const union_ty = f.typeOfIndex(inst);
@@ -7117,7 +7121,7 @@ fn airUnionInit(f: *Function, inst: Air.Inst.Index) !CValue {
fn airPrefetch(f: *Function, inst: Air.Inst.Index) !CValue {
const mod = f.object.dg.module;
- const prefetch = f.air.instructions.items(.data)[inst].prefetch;
+ const prefetch = f.air.instructions.items(.data)[@intFromEnum(inst)].prefetch;
const ptr_ty = f.typeOf(prefetch.ptr);
const ptr = try f.resolveInst(prefetch.ptr);
@@ -7142,7 +7146,7 @@ fn airPrefetch(f: *Function, inst: Air.Inst.Index) !CValue {
}
fn airWasmMemorySize(f: *Function, inst: Air.Inst.Index) !CValue {
- const pl_op = f.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = f.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const writer = f.object.writer();
const inst_ty = f.typeOfIndex(inst);
@@ -7156,7 +7160,7 @@ fn airWasmMemorySize(f: *Function, inst: Air.Inst.Index) !CValue {
}
fn airWasmMemoryGrow(f: *Function, inst: Air.Inst.Index) !CValue {
- const pl_op = f.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = f.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const writer = f.object.writer();
const inst_ty = f.typeOfIndex(inst);
@@ -7174,7 +7178,7 @@ fn airWasmMemoryGrow(f: *Function, inst: Air.Inst.Index) !CValue {
fn airFloatNeg(f: *Function, inst: Air.Inst.Index) !CValue {
const mod = f.object.dg.module;
- const un_op = f.air.instructions.items(.data)[inst].un_op;
+ const un_op = f.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try f.resolveInst(un_op);
try reap(f, inst, &.{un_op});
@@ -7200,7 +7204,7 @@ fn airFloatNeg(f: *Function, inst: Air.Inst.Index) !CValue {
fn airAbs(f: *Function, inst: Air.Inst.Index) !CValue {
const mod = f.object.dg.module;
- const ty_op = f.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand = try f.resolveInst(ty_op.operand);
const ty = f.typeOf(ty_op.operand);
const scalar_ty = ty.scalarType(mod);
@@ -7239,7 +7243,7 @@ fn unFloatOp(f: *Function, inst: Air.Inst.Index, operand: CValue, ty: Type, oper
}
fn airUnFloatOp(f: *Function, inst: Air.Inst.Index, operation: []const u8) !CValue {
- const un_op = f.air.instructions.items(.data)[inst].un_op;
+ const un_op = f.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try f.resolveInst(un_op);
try reap(f, inst, &.{un_op});
@@ -7250,7 +7254,7 @@ fn airUnFloatOp(f: *Function, inst: Air.Inst.Index, operation: []const u8) !CVal
fn airBinFloatOp(f: *Function, inst: Air.Inst.Index, operation: []const u8) !CValue {
const mod = f.object.dg.module;
- const bin_op = f.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const lhs = try f.resolveInst(bin_op.lhs);
const rhs = try f.resolveInst(bin_op.rhs);
@@ -7282,7 +7286,7 @@ fn airBinFloatOp(f: *Function, inst: Air.Inst.Index, operation: []const u8) !CVa
fn airMulAdd(f: *Function, inst: Air.Inst.Index) !CValue {
const mod = f.object.dg.module;
- const pl_op = f.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = f.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const bin_op = f.air.extraData(Air.Bin, pl_op.payload).data;
const mulend1 = try f.resolveInst(bin_op.lhs);
@@ -7336,7 +7340,7 @@ fn airCVaStart(f: *Function, inst: Air.Inst.Index) !CValue {
}
fn airCVaArg(f: *Function, inst: Air.Inst.Index) !CValue {
- const ty_op = f.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const inst_ty = f.typeOfIndex(inst);
const va_list = try f.resolveInst(ty_op.operand);
@@ -7348,13 +7352,13 @@ fn airCVaArg(f: *Function, inst: Air.Inst.Index) !CValue {
try writer.writeAll(" = va_arg(*(va_list *)");
try f.writeCValue(writer, va_list, .Other);
try writer.writeAll(", ");
- try f.renderType(writer, f.air.getRefType(ty_op.ty));
+ try f.renderType(writer, ty_op.ty.toType());
try writer.writeAll(");\n");
return local;
}
fn airCVaEnd(f: *Function, inst: Air.Inst.Index) !CValue {
- const un_op = f.air.instructions.items(.data)[inst].un_op;
+ const un_op = f.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const va_list = try f.resolveInst(un_op);
try reap(f, inst, &.{un_op});
@@ -7367,7 +7371,7 @@ fn airCVaEnd(f: *Function, inst: Air.Inst.Index) !CValue {
}
fn airCVaCopy(f: *Function, inst: Air.Inst.Index) !CValue {
- const ty_op = f.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const inst_ty = f.typeOfIndex(inst);
const va_list = try f.resolveInst(ty_op.operand);
@@ -7836,7 +7840,7 @@ const Materialize = struct {
pub fn end(self: Materialize, f: *Function, inst: Air.Inst.Index) !void {
switch (self.local) {
- .new_local => |local| try freeLocal(f, inst, local, 0),
+ .new_local => |local| try freeLocal(f, inst, local, null),
else => {},
}
}
@@ -7926,7 +7930,7 @@ const Vectorize = struct {
if (self.index != .none) {
f.object.indent_writer.popIndent();
try writer.writeAll("}\n");
- try freeLocal(f, inst, self.index.new_local, 0);
+ try freeLocal(f, inst, self.index.new_local, null);
}
}
};
@@ -7972,7 +7976,7 @@ fn reap(f: *Function, inst: Air.Inst.Index, operands: []const Air.Inst.Ref) !voi
}
fn die(f: *Function, inst: Air.Inst.Index, ref: Air.Inst.Ref) !void {
- const ref_inst = Air.refToIndex(ref) orelse return;
+ const ref_inst = ref.toIndex() orelse return;
const c_value = (f.value_map.fetchRemove(ref) orelse return).value;
const local_index = switch (c_value) {
.local, .new_local => |l| l,
@@ -7981,10 +7985,22 @@ fn die(f: *Function, inst: Air.Inst.Index, ref: Air.Inst.Ref) !void {
try freeLocal(f, inst, local_index, ref_inst);
}
-fn freeLocal(f: *Function, inst: Air.Inst.Index, local_index: LocalIndex, ref_inst: Air.Inst.Index) !void {
+fn freeLocal(f: *Function, inst: ?Air.Inst.Index, local_index: LocalIndex, ref_inst: ?Air.Inst.Index) !void {
const gpa = f.object.dg.gpa;
const local = &f.locals.items[local_index];
- log.debug("%{d}: freeing t{d} (operand %{d})", .{ inst, local_index, ref_inst });
+ if (inst) |i| {
+ if (ref_inst) |operand| {
+ log.debug("%{d}: freeing t{d} (operand %{d})", .{ @intFromEnum(i), local_index, operand });
+ } else {
+ log.debug("%{d}: freeing t{d}", .{ @intFromEnum(i), local_index });
+ }
+ } else {
+ if (ref_inst) |operand| {
+ log.debug("freeing t{d} (operand %{d})", .{ local_index, operand });
+ } else {
+ log.debug("freeing t{d}", .{local_index});
+ }
+ }
const gop = try f.free_locals_map.getOrPut(gpa, local.getType());
if (!gop.found_existing) gop.value_ptr.* = .{};
if (std.debug.runtime_safety) {
src/codegen/llvm.zig
@@ -4850,7 +4850,7 @@ pub const FuncGen = struct {
for (body, 0..) |inst, i| {
if (self.liveness.isUnused(inst) and !self.air.mustLower(inst, ip)) continue;
- const val: Builder.Value = switch (air_tags[inst]) {
+ const val: Builder.Value = switch (air_tags[@intFromEnum(inst)]) {
// zig fmt: off
.add => try self.airAdd(inst, .normal),
.add_optimized => try self.airAdd(inst, .fast),
@@ -5090,7 +5090,7 @@ pub const FuncGen = struct {
.work_group_id => try self.airWorkGroupId(inst),
// zig fmt: on
};
- if (val != .none) try self.func_inst_table.putNoClobber(self.gpa, Air.indexToRef(inst), val);
+ if (val != .none) try self.func_inst_table.putNoClobber(self.gpa, inst.toRef(), val);
}
}
@@ -5103,7 +5103,7 @@ pub const FuncGen = struct {
};
fn airCall(self: *FuncGen, inst: Air.Inst.Index, modifier: std.builtin.CallModifier) !Builder.Value {
- const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const extra = self.air.extraData(Air.Call, pl_op.payload);
const args: []const Air.Inst.Ref = @ptrCast(self.air.extra[extra.end..][0..extra.data.args_len]);
const o = self.dg.object;
@@ -5450,7 +5450,7 @@ pub const FuncGen = struct {
fn airRet(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const ret_ty = self.typeOf(un_op);
if (self.ret_ptr != .none) {
const operand = try self.resolveInst(un_op);
@@ -5508,7 +5508,7 @@ pub const FuncGen = struct {
fn airRetLoad(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const ptr_ty = self.typeOf(un_op);
const ret_ty = ptr_ty.childType(mod);
const fn_info = mod.typeToFunc(self.dg.decl.ty).?;
@@ -5536,9 +5536,9 @@ pub const FuncGen = struct {
fn airCVaArg(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const list = try self.resolveInst(ty_op.operand);
- const arg_ty = self.air.getRefType(ty_op.ty);
+ const arg_ty = ty_op.ty.toType();
const llvm_arg_ty = try o.lowerType(arg_ty);
return self.wip.vaArg(list, llvm_arg_ty, "");
@@ -5546,9 +5546,9 @@ pub const FuncGen = struct {
fn airCVaCopy(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const src_list = try self.resolveInst(ty_op.operand);
- const va_list_ty = self.air.getRefType(ty_op.ty);
+ const va_list_ty = ty_op.ty.toType();
const llvm_va_list_ty = try o.lowerType(va_list_ty);
const mod = o.module;
@@ -5563,7 +5563,7 @@ pub const FuncGen = struct {
}
fn airCVaEnd(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const src_list = try self.resolveInst(un_op);
_ = try self.wip.callIntrinsic(.normal, .none, .va_end, &.{}, &.{src_list}, "");
@@ -5592,7 +5592,7 @@ pub const FuncGen = struct {
op: math.CompareOperator,
fast: Builder.FastMathKind,
) !Builder.Value {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const lhs = try self.resolveInst(bin_op.lhs);
const rhs = try self.resolveInst(bin_op.rhs);
const operand_ty = self.typeOf(bin_op.lhs);
@@ -5601,7 +5601,7 @@ pub const FuncGen = struct {
}
fn airCmpVector(self: *FuncGen, inst: Air.Inst.Index, fast: Builder.FastMathKind) !Builder.Value {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.VectorCmp, ty_pl.payload).data;
const lhs = try self.resolveInst(extra.lhs);
@@ -5614,7 +5614,7 @@ pub const FuncGen = struct {
fn airCmpLtErrorsLen(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try self.resolveInst(un_op);
const llvm_fn = try self.getCmpLtErrorsLenFunction();
return self.wip.call(
@@ -5733,9 +5733,9 @@ pub const FuncGen = struct {
fn airBlock(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.Block, ty_pl.payload);
- const body = self.air.extra[extra.end..][0..extra.data.body_len];
+ const body: []const Air.Inst.Index = @ptrCast(self.air.extra[extra.end..][0..extra.data.body_len]);
const inst_ty = self.typeOfIndex(inst);
if (inst_ty.isNoReturn(mod)) {
@@ -5785,7 +5785,7 @@ pub const FuncGen = struct {
fn airBr(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
- const branch = self.air.instructions.items(.data)[inst].br;
+ const branch = self.air.instructions.items(.data)[@intFromEnum(inst)].br;
const block = self.blocks.get(branch.block_inst).?;
// Add the values to the lists only if the break provides a value.
@@ -5803,11 +5803,11 @@ pub const FuncGen = struct {
}
fn airCondBr(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
- const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const cond = try 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 then_body: []const Air.Inst.Index = @ptrCast(self.air.extra[extra.end..][0..extra.data.then_body_len]);
+ const else_body: []const Air.Inst.Index = @ptrCast(self.air.extra[extra.end + then_body.len ..][0..extra.data.else_body_len]);
const then_block = try self.wip.block(1, "Then");
const else_block = try self.wip.block(1, "Else");
@@ -5827,10 +5827,10 @@ pub const FuncGen = struct {
const o = self.dg.object;
const mod = o.module;
const inst = body_tail[0];
- const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const err_union = try self.resolveInst(pl_op.operand);
const extra = self.air.extraData(Air.Try, pl_op.payload);
- const body = self.air.extra[extra.end..][0..extra.data.body_len];
+ const body: []const Air.Inst.Index = @ptrCast(self.air.extra[extra.end..][0..extra.data.body_len]);
const err_union_ty = self.typeOf(pl_op.operand);
const payload_ty = self.typeOfIndex(inst);
const can_elide_load = if (isByRef(payload_ty, mod)) self.canElideLoad(body_tail) else false;
@@ -5841,10 +5841,10 @@ pub const FuncGen = struct {
fn airTryPtr(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.TryPtr, ty_pl.payload);
const err_union_ptr = try self.resolveInst(extra.data.ptr);
- const body = self.air.extra[extra.end..][0..extra.data.body_len];
+ const body: []const Air.Inst.Index = @ptrCast(self.air.extra[extra.end..][0..extra.data.body_len]);
const err_union_ty = self.typeOf(extra.data.ptr).childType(mod);
const is_unused = self.liveness.isUnused(inst);
return lowerTry(self, err_union_ptr, body, err_union_ty, true, true, is_unused);
@@ -5924,7 +5924,7 @@ pub const FuncGen = struct {
fn airSwitchBr(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
- const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const cond = try self.resolveInst(pl_op.operand);
const switch_br = self.air.extraData(Air.SwitchBr, pl_op.payload);
const else_block = try self.wip.block(1, "Default");
@@ -5956,7 +5956,7 @@ pub const FuncGen = struct {
const case = self.air.extraData(Air.SwitchBr.Case, extra_index);
const items: []const Air.Inst.Ref =
@ptrCast(self.air.extra[case.end..][0..case.data.items_len]);
- const case_body = self.air.extra[case.end + items.len ..][0..case.data.body_len];
+ const case_body: []const Air.Inst.Index = @ptrCast(self.air.extra[case.end + items.len ..][0..case.data.body_len]);
extra_index = case.end + case.data.items_len + case_body.len;
const case_block = try self.wip.block(@intCast(items.len), "Case");
@@ -5975,7 +5975,7 @@ pub const FuncGen = struct {
}
self.wip.cursor = .{ .block = else_block };
- const else_body = self.air.extra[extra_index..][0..switch_br.data.else_body_len];
+ const else_body: []const Air.Inst.Index = @ptrCast(self.air.extra[extra_index..][0..switch_br.data.else_body_len]);
if (else_body.len != 0) {
try self.genBody(else_body);
} else {
@@ -5989,9 +5989,9 @@ pub const FuncGen = struct {
fn airLoop(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(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];
+ const body: []const Air.Inst.Index = @ptrCast(self.air.extra[loop.end..][0..loop.data.body_len]);
const loop_block = try self.wip.block(2, "Loop");
_ = try self.wip.br(loop_block);
@@ -6013,7 +6013,7 @@ pub const FuncGen = struct {
fn airArrayToSlice(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand_ty = self.typeOf(ty_op.operand);
const array_ty = operand_ty.childType(mod);
const llvm_usize = try o.lowerType(Type.usize);
@@ -6031,7 +6031,7 @@ pub const FuncGen = struct {
fn airFloatFromInt(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const workaround_operand = try self.resolveInst(ty_op.operand);
const operand_ty = self.typeOf(ty_op.operand);
@@ -6116,7 +6116,7 @@ pub const FuncGen = struct {
const o = self.dg.object;
const mod = o.module;
const target = mod.getTarget();
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand = try self.resolveInst(ty_op.operand);
const operand_ty = self.typeOf(ty_op.operand);
@@ -6203,7 +6203,7 @@ pub const FuncGen = struct {
}
fn airSliceField(self: *FuncGen, inst: Air.Inst.Index, index: u32) !Builder.Value {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand = try self.resolveInst(ty_op.operand);
return self.wip.extractValue(operand, &.{index}, "");
}
@@ -6211,7 +6211,7 @@ pub const FuncGen = struct {
fn airPtrSliceFieldPtr(self: *FuncGen, inst: Air.Inst.Index, index: c_uint) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const slice_ptr = try self.resolveInst(ty_op.operand);
const slice_ptr_ty = self.typeOf(ty_op.operand);
const slice_llvm_ty = try o.lowerPtrElemTy(slice_ptr_ty.childType(mod));
@@ -6223,7 +6223,7 @@ pub const FuncGen = struct {
const o = self.dg.object;
const mod = o.module;
const inst = body_tail[0];
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const slice_ty = self.typeOf(bin_op.lhs);
const slice = try self.resolveInst(bin_op.lhs);
const index = try self.resolveInst(bin_op.rhs);
@@ -6245,7 +6245,7 @@ pub const FuncGen = struct {
fn airSliceElemPtr(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
const slice_ty = self.typeOf(bin_op.lhs);
@@ -6261,7 +6261,7 @@ pub const FuncGen = struct {
const mod = o.module;
const inst = body_tail[0];
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const array_ty = self.typeOf(bin_op.lhs);
const array_llvm_val = try self.resolveInst(bin_op.lhs);
const rhs = try self.resolveInst(bin_op.rhs);
@@ -6278,12 +6278,12 @@ pub const FuncGen = struct {
const elem_alignment = elem_ty.abiAlignment(mod).toLlvm();
return self.loadByRef(elem_ptr, elem_ty, elem_alignment, .normal);
} else {
- if (Air.refToIndex(bin_op.lhs)) |lhs_index| {
- if (self.air.instructions.items(.tag)[lhs_index] == .load) {
- const load_data = self.air.instructions.items(.data)[lhs_index];
+ if (bin_op.lhs.toIndex()) |lhs_index| {
+ if (self.air.instructions.items(.tag)[@intFromEnum(lhs_index)] == .load) {
+ const load_data = self.air.instructions.items(.data)[@intFromEnum(lhs_index)];
const load_ptr = load_data.ty_op.operand;
- if (Air.refToIndex(load_ptr)) |load_ptr_index| {
- const load_ptr_tag = self.air.instructions.items(.tag)[load_ptr_index];
+ if (load_ptr.toIndex()) |load_ptr_index| {
+ const load_ptr_tag = self.air.instructions.items(.tag)[@intFromEnum(load_ptr_index)];
switch (load_ptr_tag) {
.struct_field_ptr,
.struct_field_ptr_index_0,
@@ -6320,7 +6320,7 @@ pub const FuncGen = struct {
const o = self.dg.object;
const mod = o.module;
const inst = body_tail[0];
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const ptr_ty = self.typeOf(bin_op.lhs);
const elem_ty = ptr_ty.childType(mod);
const llvm_elem_ty = try o.lowerPtrElemTy(elem_ty);
@@ -6344,7 +6344,7 @@ pub const FuncGen = struct {
fn airPtrElemPtr(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
const ptr_ty = self.typeOf(bin_op.lhs);
const elem_ty = ptr_ty.childType(mod);
@@ -6353,7 +6353,7 @@ pub const FuncGen = struct {
const base_ptr = try self.resolveInst(bin_op.lhs);
const rhs = try self.resolveInst(bin_op.rhs);
- const elem_ptr = self.air.getRefType(ty_pl.ty);
+ const elem_ptr = ty_pl.ty.toType();
if (elem_ptr.ptrInfo(mod).flags.vector_index != .none) return base_ptr;
const llvm_elem_ty = try o.lowerPtrElemTy(elem_ty);
@@ -6365,7 +6365,7 @@ pub const FuncGen = struct {
}
fn airStructFieldPtr(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const struct_field = self.air.extraData(Air.StructField, ty_pl.payload).data;
const struct_ptr = try self.resolveInst(struct_field.struct_operand);
const struct_ptr_ty = self.typeOf(struct_field.struct_operand);
@@ -6377,7 +6377,7 @@ pub const FuncGen = struct {
inst: Air.Inst.Index,
field_index: u32,
) !Builder.Value {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const struct_ptr = try self.resolveInst(ty_op.operand);
const struct_ptr_ty = self.typeOf(ty_op.operand);
return self.fieldPtr(inst, struct_ptr, struct_ptr_ty, field_index);
@@ -6387,7 +6387,7 @@ pub const FuncGen = struct {
const o = self.dg.object;
const mod = o.module;
const inst = body_tail[0];
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const struct_field = self.air.extraData(Air.StructField, ty_pl.payload).data;
const struct_ty = self.typeOf(struct_field.struct_operand);
const struct_llvm_val = try self.resolveInst(struct_field.struct_operand);
@@ -6491,16 +6491,16 @@ pub const FuncGen = struct {
fn airFieldParentPtr(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.FieldParentPtr, ty_pl.payload).data;
const field_ptr = try self.resolveInst(extra.field_ptr);
- const parent_ty = self.air.getRefType(ty_pl.ty).childType(mod);
+ const parent_ty = ty_pl.ty.toType().childType(mod);
const field_offset = parent_ty.structFieldOffset(extra.field_index, mod);
if (field_offset == 0) return field_ptr;
- const res_ty = try o.lowerType(self.air.getRefType(ty_pl.ty));
+ const res_ty = try o.lowerType(ty_pl.ty.toType());
const llvm_usize = try o.lowerType(Type.usize);
const field_ptr_int = try self.wip.cast(.ptrtoint, field_ptr, llvm_usize, "");
@@ -6514,7 +6514,7 @@ pub const FuncGen = struct {
}
fn airNot(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand = try self.resolveInst(ty_op.operand);
return self.wip.not(operand, "");
@@ -6528,7 +6528,7 @@ pub const FuncGen = struct {
fn airDbgStmt(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const di_scope = self.di_scope orelse return .none;
- const dbg_stmt = self.air.instructions.items(.data)[inst].dbg_stmt;
+ const dbg_stmt = self.air.instructions.items(.data)[@intFromEnum(inst)].dbg_stmt;
self.prev_dbg_line = @intCast(self.base_line + dbg_stmt.line + 1);
self.prev_dbg_column = @intCast(dbg_stmt.column + 1);
const inlined_at = if (self.dbg_inlined.items.len > 0)
@@ -6547,7 +6547,7 @@ pub const FuncGen = struct {
fn airDbgInlineBegin(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
const dib = o.di_builder orelse return .none;
- const ty_fn = self.air.instructions.items(.data)[inst].ty_fn;
+ const ty_fn = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_fn;
const mod = o.module;
const func = mod.funcInfo(ty_fn.func);
@@ -6596,7 +6596,7 @@ pub const FuncGen = struct {
fn airDbgInlineEnd(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
if (o.di_builder == null) return .none;
- const ty_fn = self.air.instructions.items(.data)[inst].ty_fn;
+ const ty_fn = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_fn;
const mod = o.module;
const decl = mod.funcOwnerDeclPtr(ty_fn.func);
@@ -6629,7 +6629,7 @@ pub const FuncGen = struct {
const o = self.dg.object;
const mod = o.module;
const dib = o.di_builder orelse return .none;
- const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const operand = try self.resolveInst(pl_op.operand);
const name = self.air.nullTerminatedString(pl_op.payload);
const ptr_ty = self.typeOf(pl_op.operand);
@@ -6656,7 +6656,7 @@ pub const FuncGen = struct {
fn airDbgVarVal(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
const dib = o.di_builder orelse return .none;
- const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const operand = try self.resolveInst(pl_op.operand);
const operand_ty = self.typeOf(pl_op.operand);
const name = self.air.nullTerminatedString(pl_op.payload);
@@ -6700,7 +6700,7 @@ pub const FuncGen = struct {
// this implementation feeds the inline assembly code directly to LLVM.
const o = self.dg.object;
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.Asm, ty_pl.payload);
const is_volatile = @as(u1, @truncate(extra.data.flags >> 31)) != 0;
const clobbers_len: u31 = @truncate(extra.data.flags);
@@ -7081,7 +7081,7 @@ pub const FuncGen = struct {
) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try self.resolveInst(un_op);
const operand_ty = self.typeOf(un_op);
const optional_ty = if (operand_is_ptr) operand_ty.childType(mod) else operand_ty;
@@ -7125,7 +7125,7 @@ pub const FuncGen = struct {
) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try self.resolveInst(un_op);
const operand_ty = self.typeOf(un_op);
const err_union_ty = if (operand_is_ptr) operand_ty.childType(mod) else operand_ty;
@@ -7164,7 +7164,7 @@ pub const FuncGen = struct {
fn airOptionalPayloadPtr(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand = try self.resolveInst(ty_op.operand);
const optional_ty = self.typeOf(ty_op.operand).childType(mod);
const payload_ty = optional_ty.optionalChild(mod);
@@ -7185,7 +7185,7 @@ pub const FuncGen = struct {
const o = self.dg.object;
const mod = o.module;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand = try self.resolveInst(ty_op.operand);
const optional_ty = self.typeOf(ty_op.operand).childType(mod);
const payload_ty = optional_ty.optionalChild(mod);
@@ -7217,7 +7217,7 @@ pub const FuncGen = struct {
const o = self.dg.object;
const mod = o.module;
const inst = body_tail[0];
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand = try self.resolveInst(ty_op.operand);
const optional_ty = self.typeOf(ty_op.operand);
const payload_ty = self.typeOfIndex(inst);
@@ -7241,7 +7241,7 @@ pub const FuncGen = struct {
const o = self.dg.object;
const mod = o.module;
const inst = body_tail[0];
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand = try self.resolveInst(ty_op.operand);
const operand_ty = self.typeOf(ty_op.operand);
const err_union_ty = if (operand_is_ptr) operand_ty.childType(mod) else operand_ty;
@@ -7275,7 +7275,7 @@ pub const FuncGen = struct {
) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand = try self.resolveInst(ty_op.operand);
const operand_ty = self.typeOf(ty_op.operand);
const error_type = try o.errorIntType();
@@ -7308,7 +7308,7 @@ pub const FuncGen = struct {
fn airErrUnionPayloadPtrSet(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand = try self.resolveInst(ty_op.operand);
const err_union_ty = self.typeOf(ty_op.operand).childType(mod);
@@ -7340,15 +7340,15 @@ pub const FuncGen = struct {
}
fn airSetErrReturnTrace(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
self.err_ret_trace = try self.resolveInst(un_op);
return .none;
}
fn airSaveErrReturnTraceIndex(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
- const struct_ty = self.air.getRefType(ty_pl.ty);
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
+ const struct_ty = ty_pl.ty.toType();
const field_index = ty_pl.payload;
const mod = o.module;
@@ -7378,7 +7378,7 @@ pub const FuncGen = struct {
) bool {
const air_tags = self.air.instructions.items(.tag);
for (body_tail[1..]) |body_inst| {
- switch (air_tags[body_inst]) {
+ switch (air_tags[@intFromEnum(body_inst)]) {
.ret => return true,
.dbg_block_begin, .dbg_stmt => continue,
else => return false,
@@ -7393,7 +7393,7 @@ pub const FuncGen = struct {
const o = self.dg.object;
const mod = o.module;
const inst = body_tail[0];
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const payload_ty = self.typeOf(ty_op.operand);
const non_null_bit = try o.builder.intValue(.i8, 1);
comptime assert(optional_layout_version == 3);
@@ -7426,7 +7426,7 @@ pub const FuncGen = struct {
const o = self.dg.object;
const mod = o.module;
const inst = body_tail[0];
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const err_un_ty = self.typeOfIndex(inst);
const operand = try self.resolveInst(ty_op.operand);
const payload_ty = self.typeOf(ty_op.operand);
@@ -7467,7 +7467,7 @@ pub const FuncGen = struct {
const o = self.dg.object;
const mod = o.module;
const inst = body_tail[0];
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const err_un_ty = self.typeOfIndex(inst);
const payload_ty = err_un_ty.errorUnionPayload(mod);
const operand = try self.resolveInst(ty_op.operand);
@@ -7505,7 +7505,7 @@ pub const FuncGen = struct {
fn airWasmMemorySize(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
- const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const index = pl_op.payload;
return self.wip.callIntrinsic(.normal, .none, .@"wasm.memory.size", &.{.i32}, &.{
try o.builder.intValue(.i32, index),
@@ -7514,7 +7514,7 @@ pub const FuncGen = struct {
fn airWasmMemoryGrow(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
- const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const index = pl_op.payload;
return self.wip.callIntrinsic(.normal, .none, .@"wasm.memory.grow", &.{.i32}, &.{
try o.builder.intValue(.i32, index), try self.resolveInst(pl_op.operand),
@@ -7524,7 +7524,7 @@ pub const FuncGen = struct {
fn airVectorStoreElem(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const data = self.air.instructions.items(.data)[inst].vector_store_elem;
+ const data = self.air.instructions.items(.data)[@intFromEnum(inst)].vector_store_elem;
const extra = self.air.extraData(Air.Bin, data.payload).data;
const vector_ptr = try self.resolveInst(data.vector_ptr);
@@ -7546,7 +7546,7 @@ pub const FuncGen = struct {
fn airMin(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const lhs = try self.resolveInst(bin_op.lhs);
const rhs = try self.resolveInst(bin_op.rhs);
const inst_ty = self.typeOfIndex(inst);
@@ -7566,7 +7566,7 @@ pub const FuncGen = struct {
fn airMax(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const lhs = try self.resolveInst(bin_op.lhs);
const rhs = try self.resolveInst(bin_op.rhs);
const inst_ty = self.typeOfIndex(inst);
@@ -7585,7 +7585,7 @@ pub const FuncGen = struct {
fn airSlice(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
const ptr = try self.resolveInst(bin_op.lhs);
const len = try self.resolveInst(bin_op.rhs);
@@ -7596,7 +7596,7 @@ pub const FuncGen = struct {
fn airAdd(self: *FuncGen, inst: Air.Inst.Index, fast: Builder.FastMathKind) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const lhs = try self.resolveInst(bin_op.lhs);
const rhs = try self.resolveInst(bin_op.rhs);
const inst_ty = self.typeOfIndex(inst);
@@ -7615,7 +7615,7 @@ pub const FuncGen = struct {
const o = fg.dg.object;
const mod = o.module;
- const bin_op = fg.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = fg.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const lhs = try fg.resolveInst(bin_op.lhs);
const rhs = try fg.resolveInst(bin_op.rhs);
const inst_ty = fg.typeOfIndex(inst);
@@ -7652,7 +7652,7 @@ pub const FuncGen = struct {
}
fn airAddWrap(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const lhs = try self.resolveInst(bin_op.lhs);
const rhs = try self.resolveInst(bin_op.rhs);
@@ -7662,7 +7662,7 @@ pub const FuncGen = struct {
fn airAddSat(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const lhs = try self.resolveInst(bin_op.lhs);
const rhs = try self.resolveInst(bin_op.rhs);
const inst_ty = self.typeOfIndex(inst);
@@ -7682,7 +7682,7 @@ pub const FuncGen = struct {
fn airSub(self: *FuncGen, inst: Air.Inst.Index, fast: Builder.FastMathKind) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const lhs = try self.resolveInst(bin_op.lhs);
const rhs = try self.resolveInst(bin_op.rhs);
const inst_ty = self.typeOfIndex(inst);
@@ -7693,7 +7693,7 @@ pub const FuncGen = struct {
}
fn airSubWrap(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const lhs = try self.resolveInst(bin_op.lhs);
const rhs = try self.resolveInst(bin_op.rhs);
@@ -7703,7 +7703,7 @@ pub const FuncGen = struct {
fn airSubSat(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const lhs = try self.resolveInst(bin_op.lhs);
const rhs = try self.resolveInst(bin_op.rhs);
const inst_ty = self.typeOfIndex(inst);
@@ -7723,7 +7723,7 @@ pub const FuncGen = struct {
fn airMul(self: *FuncGen, inst: Air.Inst.Index, fast: Builder.FastMathKind) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const lhs = try self.resolveInst(bin_op.lhs);
const rhs = try self.resolveInst(bin_op.rhs);
const inst_ty = self.typeOfIndex(inst);
@@ -7734,7 +7734,7 @@ pub const FuncGen = struct {
}
fn airMulWrap(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const lhs = try self.resolveInst(bin_op.lhs);
const rhs = try self.resolveInst(bin_op.rhs);
@@ -7744,7 +7744,7 @@ pub const FuncGen = struct {
fn airMulSat(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const lhs = try self.resolveInst(bin_op.lhs);
const rhs = try self.resolveInst(bin_op.rhs);
const inst_ty = self.typeOfIndex(inst);
@@ -7762,7 +7762,7 @@ pub const FuncGen = struct {
}
fn airDivFloat(self: *FuncGen, inst: Air.Inst.Index, fast: Builder.FastMathKind) !Builder.Value {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const lhs = try self.resolveInst(bin_op.lhs);
const rhs = try self.resolveInst(bin_op.rhs);
const inst_ty = self.typeOfIndex(inst);
@@ -7773,7 +7773,7 @@ pub const FuncGen = struct {
fn airDivTrunc(self: *FuncGen, inst: Air.Inst.Index, fast: Builder.FastMathKind) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const lhs = try self.resolveInst(bin_op.lhs);
const rhs = try self.resolveInst(bin_op.rhs);
const inst_ty = self.typeOfIndex(inst);
@@ -7789,7 +7789,7 @@ pub const FuncGen = struct {
fn airDivFloor(self: *FuncGen, inst: Air.Inst.Index, fast: Builder.FastMathKind) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const lhs = try self.resolveInst(bin_op.lhs);
const rhs = try self.resolveInst(bin_op.rhs);
const inst_ty = self.typeOfIndex(inst);
@@ -7821,7 +7821,7 @@ pub const FuncGen = struct {
fn airDivExact(self: *FuncGen, inst: Air.Inst.Index, fast: Builder.FastMathKind) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const lhs = try self.resolveInst(bin_op.lhs);
const rhs = try self.resolveInst(bin_op.rhs);
const inst_ty = self.typeOfIndex(inst);
@@ -7839,7 +7839,7 @@ pub const FuncGen = struct {
fn airRem(self: *FuncGen, inst: Air.Inst.Index, fast: Builder.FastMathKind) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const lhs = try self.resolveInst(bin_op.lhs);
const rhs = try self.resolveInst(bin_op.rhs);
const inst_ty = self.typeOfIndex(inst);
@@ -7856,7 +7856,7 @@ pub const FuncGen = struct {
fn airMod(self: *FuncGen, inst: Air.Inst.Index, fast: Builder.FastMathKind) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const lhs = try self.resolveInst(bin_op.lhs);
const rhs = try self.resolveInst(bin_op.rhs);
const inst_ty = self.typeOfIndex(inst);
@@ -7892,7 +7892,7 @@ pub const FuncGen = struct {
fn airPtrAdd(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
const ptr = try self.resolveInst(bin_op.lhs);
const offset = try self.resolveInst(bin_op.rhs);
@@ -7914,7 +7914,7 @@ pub const FuncGen = struct {
fn airPtrSub(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
const ptr = try self.resolveInst(bin_op.lhs);
const offset = try self.resolveInst(bin_op.rhs);
@@ -7942,7 +7942,7 @@ pub const FuncGen = struct {
) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.Bin, ty_pl.payload).data;
const lhs = try self.resolveInst(extra.lhs);
@@ -8283,7 +8283,7 @@ pub const FuncGen = struct {
}
fn airMulAdd(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
- const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const extra = self.air.extraData(Air.Bin, pl_op.payload).data;
const mulend1 = try self.resolveInst(extra.lhs);
@@ -8297,7 +8297,7 @@ pub const FuncGen = struct {
fn airShlWithOverflow(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.Bin, ty_pl.payload).data;
const lhs = try self.resolveInst(extra.lhs);
@@ -8344,21 +8344,21 @@ pub const FuncGen = struct {
}
fn airAnd(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const lhs = try self.resolveInst(bin_op.lhs);
const rhs = try self.resolveInst(bin_op.rhs);
return self.wip.bin(.@"and", lhs, rhs, "");
}
fn airOr(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const lhs = try self.resolveInst(bin_op.lhs);
const rhs = try self.resolveInst(bin_op.rhs);
return self.wip.bin(.@"or", lhs, rhs, "");
}
fn airXor(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const lhs = try self.resolveInst(bin_op.lhs);
const rhs = try self.resolveInst(bin_op.rhs);
return self.wip.bin(.xor, lhs, rhs, "");
@@ -8367,7 +8367,7 @@ pub const FuncGen = struct {
fn airShlExact(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const lhs = try self.resolveInst(bin_op.lhs);
const rhs = try self.resolveInst(bin_op.rhs);
@@ -8384,7 +8384,7 @@ pub const FuncGen = struct {
fn airShl(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const lhs = try self.resolveInst(bin_op.lhs);
const rhs = try self.resolveInst(bin_op.rhs);
@@ -8398,7 +8398,7 @@ pub const FuncGen = struct {
fn airShlSat(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const lhs = try self.resolveInst(bin_op.lhs);
const rhs = try self.resolveInst(bin_op.rhs);
@@ -8440,7 +8440,7 @@ pub const FuncGen = struct {
fn airShr(self: *FuncGen, inst: Air.Inst.Index, is_exact: bool) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const lhs = try self.resolveInst(bin_op.lhs);
const rhs = try self.resolveInst(bin_op.rhs);
@@ -8459,7 +8459,7 @@ pub const FuncGen = struct {
fn airAbs(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand = try self.resolveInst(ty_op.operand);
const operand_ty = self.typeOf(ty_op.operand);
const scalar_ty = operand_ty.scalarType(mod);
@@ -8481,7 +8481,7 @@ pub const FuncGen = struct {
fn airIntCast(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const dest_ty = self.typeOfIndex(inst);
const dest_llvm_ty = try o.lowerType(dest_ty);
const operand = try self.resolveInst(ty_op.operand);
@@ -8496,7 +8496,7 @@ pub const FuncGen = struct {
fn airTrunc(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand = try self.resolveInst(ty_op.operand);
const dest_llvm_ty = try o.lowerType(self.typeOfIndex(inst));
return self.wip.cast(.trunc, operand, dest_llvm_ty, "");
@@ -8505,7 +8505,7 @@ pub const FuncGen = struct {
fn airFptrunc(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand = try self.resolveInst(ty_op.operand);
const operand_ty = self.typeOf(ty_op.operand);
const dest_ty = self.typeOfIndex(inst);
@@ -8539,7 +8539,7 @@ pub const FuncGen = struct {
fn airFpext(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand = try self.resolveInst(ty_op.operand);
const operand_ty = self.typeOf(ty_op.operand);
const dest_ty = self.typeOfIndex(inst);
@@ -8572,7 +8572,7 @@ pub const FuncGen = struct {
fn airIntFromPtr(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try self.resolveInst(un_op);
const ptr_ty = self.typeOf(un_op);
const operand_ptr = try self.sliceOrArrayPtr(operand, ptr_ty);
@@ -8581,7 +8581,7 @@ pub const FuncGen = struct {
}
fn airBitCast(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand_ty = self.typeOf(ty_op.operand);
const inst_ty = self.typeOfIndex(inst);
const operand = try self.resolveInst(ty_op.operand);
@@ -8698,7 +8698,7 @@ pub const FuncGen = struct {
}
fn airIntFromBool(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try self.resolveInst(un_op);
return operand;
}
@@ -8713,7 +8713,7 @@ pub const FuncGen = struct {
if (o.di_builder) |dib| {
if (needDbgVarWorkaround(o)) return arg_val;
- const src_index = self.air.instructions.items(.data)[inst].arg.src_index;
+ const src_index = self.air.instructions.items(.data)[@intFromEnum(inst)].arg.src_index;
const func_index = self.dg.decl.getOwnedFunctionIndex();
const func = mod.funcInfo(func_index);
const lbrace_line = mod.declPtr(func.owner_decl).src_line + func.lbrace_line + 1;
@@ -8796,7 +8796,7 @@ pub const FuncGen = struct {
fn airStore(self: *FuncGen, inst: Air.Inst.Index, safety: bool) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const dest_ptr = try self.resolveInst(bin_op.lhs);
const ptr_ty = self.typeOf(bin_op.lhs);
const operand_ty = ptr_ty.childType(mod);
@@ -8860,7 +8860,7 @@ pub const FuncGen = struct {
const o = fg.dg.object;
const mod = o.module;
const inst = body_tail[0];
- const ty_op = fg.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = fg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const ptr_ty = fg.typeOf(ty_op.operand);
const ptr_info = ptr_ty.ptrInfo(mod);
const ptr = try fg.resolveInst(ty_op.operand);
@@ -8910,7 +8910,7 @@ pub const FuncGen = struct {
}
fn airFence(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
- const atomic_order = self.air.instructions.items(.data)[inst].fence;
+ const atomic_order = self.air.instructions.items(.data)[@intFromEnum(inst)].fence;
const ordering = toLlvmAtomicOrdering(atomic_order);
_ = try self.wip.fence(self.sync_scope, ordering);
return .none;
@@ -8923,7 +8923,7 @@ pub const FuncGen = struct {
) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.Cmpxchg, ty_pl.payload).data;
const ptr = try self.resolveInst(extra.ptr);
const ptr_ty = self.typeOf(extra.ptr);
@@ -8973,7 +8973,7 @@ pub const FuncGen = struct {
fn airAtomicRmw(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const extra = self.air.extraData(Air.AtomicRmw, pl_op.payload).data;
const ptr = try self.resolveInst(pl_op.operand);
const ptr_ty = self.typeOf(pl_op.operand);
@@ -9036,7 +9036,7 @@ pub const FuncGen = struct {
fn airAtomicLoad(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const atomic_load = self.air.instructions.items(.data)[inst].atomic_load;
+ const atomic_load = self.air.instructions.items(.data)[@intFromEnum(inst)].atomic_load;
const ptr = try self.resolveInst(atomic_load.ptr);
const ptr_ty = self.typeOf(atomic_load.ptr);
const info = ptr_ty.ptrInfo(mod);
@@ -9083,7 +9083,7 @@ pub const FuncGen = struct {
) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const ptr_ty = self.typeOf(bin_op.lhs);
const operand_ty = ptr_ty.childType(mod);
if (!operand_ty.isFnOrHasRuntimeBitsIgnoreComptime(mod)) return .none;
@@ -9107,7 +9107,7 @@ pub const FuncGen = struct {
fn airMemset(self: *FuncGen, inst: Air.Inst.Index, safety: bool) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const dest_slice = try self.resolveInst(bin_op.lhs);
const ptr_ty = self.typeOf(bin_op.lhs);
const elem_ty = self.typeOf(bin_op.rhs);
@@ -9259,7 +9259,7 @@ pub const FuncGen = struct {
fn airMemcpy(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const dest_slice = try self.resolveInst(bin_op.lhs);
const dest_ptr_ty = self.typeOf(bin_op.lhs);
const src_slice = try self.resolveInst(bin_op.rhs);
@@ -9312,7 +9312,7 @@ pub const FuncGen = struct {
fn airSetUnionTag(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const un_ty = self.typeOf(bin_op.lhs).childType(mod);
const layout = un_ty.unionGetLayout(mod);
if (layout.tag_size == 0) return .none;
@@ -9333,7 +9333,7 @@ pub const FuncGen = struct {
fn airGetUnionTag(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const un_ty = self.typeOf(ty_op.operand);
const layout = un_ty.unionGetLayout(mod);
if (layout.tag_size == 0) return .none;
@@ -9354,7 +9354,7 @@ pub const FuncGen = struct {
}
fn airUnaryOp(self: *FuncGen, inst: Air.Inst.Index, comptime op: FloatOp) !Builder.Value {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try self.resolveInst(un_op);
const operand_ty = self.typeOf(un_op);
@@ -9362,7 +9362,7 @@ pub const FuncGen = struct {
}
fn airNeg(self: *FuncGen, inst: Air.Inst.Index, fast: Builder.FastMathKind) !Builder.Value {
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try self.resolveInst(un_op);
const operand_ty = self.typeOf(un_op);
@@ -9371,7 +9371,7 @@ pub const FuncGen = struct {
fn airClzCtz(self: *FuncGen, inst: Air.Inst.Index, intrinsic: Builder.Intrinsic) !Builder.Value {
const o = self.dg.object;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const inst_ty = self.typeOfIndex(inst);
const operand_ty = self.typeOf(ty_op.operand);
const operand = try self.resolveInst(ty_op.operand);
@@ -9389,7 +9389,7 @@ pub const FuncGen = struct {
fn airBitOp(self: *FuncGen, inst: Air.Inst.Index, intrinsic: Builder.Intrinsic) !Builder.Value {
const o = self.dg.object;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const inst_ty = self.typeOfIndex(inst);
const operand_ty = self.typeOf(ty_op.operand);
const operand = try self.resolveInst(ty_op.operand);
@@ -9408,7 +9408,7 @@ pub const FuncGen = struct {
fn airByteSwap(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand_ty = self.typeOf(ty_op.operand);
var bits = operand_ty.intInfo(mod).bits;
assert(bits % 8 == 0);
@@ -9442,9 +9442,9 @@ pub const FuncGen = struct {
fn airErrorSetHasValue(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand = try self.resolveInst(ty_op.operand);
- const error_set_ty = self.air.getRefType(ty_op.ty);
+ const error_set_ty = ty_op.ty.toType();
const names = error_set_ty.errorSetNames(mod);
const valid_block = try self.wip.block(@intCast(names.len), "Valid");
@@ -9472,7 +9472,7 @@ pub const FuncGen = struct {
fn airIsNamedEnumValue(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try self.resolveInst(un_op);
const enum_ty = self.typeOf(un_op);
@@ -9542,7 +9542,7 @@ pub const FuncGen = struct {
fn airTagName(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try self.resolveInst(un_op);
const enum_ty = self.typeOf(un_op);
@@ -9654,7 +9654,7 @@ pub const FuncGen = struct {
fn airErrorName(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand = try self.resolveInst(un_op);
const slice_ty = self.typeOfIndex(inst);
const slice_llvm_ty = try o.lowerType(slice_ty);
@@ -9669,14 +9669,14 @@ pub const FuncGen = struct {
fn airSplat(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const scalar = try self.resolveInst(ty_op.operand);
const vector_ty = self.typeOfIndex(inst);
return self.wip.splatVector(try o.lowerType(vector_ty), scalar, "");
}
fn airSelect(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
- const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const extra = self.air.extraData(Air.Bin, pl_op.payload).data;
const pred = try self.resolveInst(pl_op.operand);
const a = try self.resolveInst(extra.lhs);
@@ -9688,7 +9688,7 @@ pub const FuncGen = struct {
fn airShuffle(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
const mod = o.module;
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.Shuffle, ty_pl.payload).data;
const a = try self.resolveInst(extra.a);
const b = try self.resolveInst(extra.b);
@@ -9799,7 +9799,7 @@ pub const FuncGen = struct {
const mod = o.module;
const target = mod.getTarget();
- const reduce = self.air.instructions.items(.data)[inst].reduce;
+ const reduce = self.air.instructions.items(.data)[@intFromEnum(inst)].reduce;
const operand = try self.resolveInst(reduce.operand);
const operand_ty = self.typeOf(reduce.operand);
const llvm_operand_ty = try o.lowerType(operand_ty);
@@ -9908,7 +9908,7 @@ pub const FuncGen = struct {
const o = self.dg.object;
const mod = o.module;
const ip = &mod.intern_pool;
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const result_ty = self.typeOfIndex(inst);
const len: usize = @intCast(result_ty.arrayLen(mod));
const elements: []const Air.Inst.Ref = @ptrCast(self.air.extra[ty_pl.payload..][0..len]);
@@ -10031,7 +10031,7 @@ pub const FuncGen = struct {
const o = self.dg.object;
const mod = o.module;
const ip = &mod.intern_pool;
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.UnionInit, ty_pl.payload).data;
const union_ty = self.typeOfIndex(inst);
const union_llvm_ty = try o.lowerType(union_ty);
@@ -10151,7 +10151,7 @@ pub const FuncGen = struct {
fn airPrefetch(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
- const prefetch = self.air.instructions.items(.data)[inst].prefetch;
+ const prefetch = self.air.instructions.items(.data)[@intFromEnum(inst)].prefetch;
comptime assert(@intFromEnum(std.builtin.PrefetchOptions.Rw.read) == 0);
comptime assert(@intFromEnum(std.builtin.PrefetchOptions.Rw.write) == 1);
@@ -10201,7 +10201,7 @@ pub const FuncGen = struct {
fn airAddrSpaceCast(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
const o = self.dg.object;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const inst_ty = self.typeOfIndex(inst);
const operand = try self.resolveInst(ty_op.operand);
@@ -10227,7 +10227,7 @@ pub const FuncGen = struct {
const target = o.module.getTarget();
assert(target.cpu.arch == .amdgcn); // TODO is to port this function to other GPU architectures
- const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const dimension = pl_op.payload;
return self.amdgcnWorkIntrinsic(dimension, 0, "amdgcn.workitem.id");
}
@@ -10237,7 +10237,7 @@ pub const FuncGen = struct {
const target = o.module.getTarget();
assert(target.cpu.arch == .amdgcn); // TODO is to port this function to other GPU architectures
- const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const dimension = pl_op.payload;
if (dimension >= 3) return o.builder.intValue(.i32, 1);
@@ -10260,7 +10260,7 @@ pub const FuncGen = struct {
const target = o.module.getTarget();
assert(target.cpu.arch == .amdgcn); // TODO is to port this function to other GPU architectures
- const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const dimension = pl_op.payload;
return self.amdgcnWorkIntrinsic(dimension, 0, "amdgcn.workgroup.id");
}
src/codegen/spirv.zig
@@ -445,7 +445,7 @@ const DeclGen = struct {
return try self.constant(ty, val, .direct);
}
- const index = Air.refToIndex(inst).?;
+ const index = inst.toIndex().?;
return self.inst_results.get(index).?; // Assertion means instruction does not dominate usage.
}
@@ -2089,7 +2089,7 @@ const DeclGen = struct {
return;
const air_tags = self.air.instructions.items(.tag);
- const maybe_result_id: ?IdRef = switch (air_tags[inst]) {
+ const maybe_result_id: ?IdRef = switch (air_tags[@intFromEnum(inst)]) {
// zig fmt: off
.add, .add_wrap => try self.airArithOp(inst, .OpFAdd, .OpIAdd, .OpIAdd, true),
.sub, .sub_wrap => try self.airArithOp(inst, .OpFSub, .OpISub, .OpISub, true),
@@ -2255,7 +2255,7 @@ const DeclGen = struct {
fn airBinOpSimple(self: *DeclGen, inst: Air.Inst.Index, comptime opcode: Opcode) !?IdRef {
if (self.liveness.isUnused(inst)) return null;
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const lhs_id = try self.resolve(bin_op.lhs);
const rhs_id = try self.resolve(bin_op.rhs);
const ty = self.typeOf(bin_op.lhs);
@@ -2265,7 +2265,7 @@ const DeclGen = struct {
fn airShift(self: *DeclGen, inst: Air.Inst.Index, comptime opcode: Opcode) !?IdRef {
if (self.liveness.isUnused(inst)) return null;
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const lhs_id = try self.resolve(bin_op.lhs);
const rhs_id = try self.resolve(bin_op.rhs);
const result_type_id = try self.resolveTypeId(self.typeOfIndex(inst));
@@ -2291,7 +2291,7 @@ const DeclGen = struct {
fn airMinMax(self: *DeclGen, inst: Air.Inst.Index, op: std.math.CompareOperator) !?IdRef {
if (self.liveness.isUnused(inst)) return null;
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const lhs_id = try self.resolve(bin_op.lhs);
const rhs_id = try self.resolve(bin_op.rhs);
const result_ty = self.typeOfIndex(inst);
@@ -2395,7 +2395,7 @@ const DeclGen = struct {
// LHS and RHS are guaranteed to have the same type, and AIR guarantees
// the result to be the same as the LHS and RHS, which matches SPIR-V.
const ty = self.typeOfIndex(inst);
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const lhs_id = try self.resolve(bin_op.lhs);
const rhs_id = try self.resolve(bin_op.rhs);
@@ -2492,7 +2492,7 @@ const DeclGen = struct {
) !?IdRef {
if (self.liveness.isUnused(inst)) return null;
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.Bin, ty_pl.payload).data;
const lhs = try self.resolve(extra.lhs);
const rhs = try self.resolve(extra.rhs);
@@ -2601,7 +2601,7 @@ const DeclGen = struct {
const mod = self.module;
if (self.liveness.isUnused(inst)) return null;
const ty = self.typeOfIndex(inst);
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.Shuffle, ty_pl.payload).data;
const a = try self.resolve(extra.a);
const b = try self.resolve(extra.b);
@@ -2719,7 +2719,7 @@ const DeclGen = struct {
fn airPtrAdd(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
if (self.liveness.isUnused(inst)) return null;
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
const ptr_id = try self.resolve(bin_op.lhs);
const offset_id = try self.resolve(bin_op.rhs);
@@ -2731,7 +2731,7 @@ const DeclGen = struct {
fn airPtrSub(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
if (self.liveness.isUnused(inst)) return null;
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
const ptr_id = try self.resolve(bin_op.lhs);
const ptr_ty = self.typeOf(bin_op.lhs);
@@ -2919,7 +2919,7 @@ const DeclGen = struct {
comptime op: std.math.CompareOperator,
) !?IdRef {
if (self.liveness.isUnused(inst)) return null;
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const lhs_id = try self.resolve(bin_op.lhs);
const rhs_id = try self.resolve(bin_op.rhs);
const ty = self.typeOf(bin_op.lhs);
@@ -2931,7 +2931,7 @@ const DeclGen = struct {
fn airVectorCmp(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
if (self.liveness.isUnused(inst)) return null;
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const vec_cmp = self.air.extraData(Air.VectorCmp, ty_pl.payload).data;
const lhs_id = try self.resolve(vec_cmp.lhs);
const rhs_id = try self.resolve(vec_cmp.rhs);
@@ -2999,7 +2999,7 @@ const DeclGen = struct {
fn airBitCast(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
if (self.liveness.isUnused(inst)) return null;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand_id = try self.resolve(ty_op.operand);
const operand_ty = self.typeOf(ty_op.operand);
const result_ty = self.typeOfIndex(inst);
@@ -3009,7 +3009,7 @@ const DeclGen = struct {
fn airIntCast(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
if (self.liveness.isUnused(inst)) return null;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand_id = try self.resolve(ty_op.operand);
const src_ty = self.typeOf(ty_op.operand);
const dst_ty = self.typeOfIndex(inst);
@@ -3057,7 +3057,7 @@ const DeclGen = struct {
fn airIntFromPtr(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
if (self.liveness.isUnused(inst)) return null;
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand_id = try self.resolve(un_op);
return try self.intFromPtr(operand_id);
}
@@ -3065,7 +3065,7 @@ const DeclGen = struct {
fn airFloatFromInt(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
if (self.liveness.isUnused(inst)) return null;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand_ty = self.typeOf(ty_op.operand);
const operand_id = try self.resolve(ty_op.operand);
const operand_info = try self.arithmeticTypeInfo(operand_ty);
@@ -3091,7 +3091,7 @@ const DeclGen = struct {
fn airIntFromFloat(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
if (self.liveness.isUnused(inst)) return null;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand_id = try self.resolve(ty_op.operand);
const dest_ty = self.typeOfIndex(inst);
const dest_info = try self.arithmeticTypeInfo(dest_ty);
@@ -3116,7 +3116,7 @@ const DeclGen = struct {
fn airFloatCast(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
if (self.liveness.isUnused(inst)) return null;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand_id = try self.resolve(ty_op.operand);
const dest_ty = self.typeOfIndex(inst);
const dest_ty_id = try self.resolveTypeId(dest_ty);
@@ -3132,7 +3132,7 @@ const DeclGen = struct {
fn airNot(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
if (self.liveness.isUnused(inst)) return null;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand_id = try self.resolve(ty_op.operand);
const result_ty = self.typeOfIndex(inst);
const result_ty_id = try self.resolveTypeId(result_ty);
@@ -3166,7 +3166,7 @@ const DeclGen = struct {
if (self.liveness.isUnused(inst)) return null;
const mod = self.module;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const array_ptr_ty = self.typeOf(ty_op.operand);
const array_ty = array_ptr_ty.childType(mod);
const slice_ty = self.typeOfIndex(inst);
@@ -3195,7 +3195,7 @@ const DeclGen = struct {
fn airSlice(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
if (self.liveness.isUnused(inst)) return null;
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
const ptr_id = try self.resolve(bin_op.lhs);
const len_id = try self.resolve(bin_op.rhs);
@@ -3216,7 +3216,7 @@ const DeclGen = struct {
const mod = self.module;
const ip = &mod.intern_pool;
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const result_ty = self.typeOfIndex(inst);
const len: usize = @intCast(result_ty.arrayLen(mod));
const elements: []const Air.Inst.Ref = @ptrCast(self.air.extra[ty_pl.payload..][0..len]);
@@ -3316,7 +3316,7 @@ const DeclGen = struct {
}
fn airMemcpy(self: *DeclGen, inst: Air.Inst.Index) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const dest_slice = try self.resolve(bin_op.lhs);
const src_slice = try self.resolve(bin_op.rhs);
const dest_ty = self.typeOf(bin_op.lhs);
@@ -3333,7 +3333,7 @@ const DeclGen = struct {
fn airSliceField(self: *DeclGen, inst: Air.Inst.Index, field: u32) !?IdRef {
if (self.liveness.isUnused(inst)) return null;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const field_ty = self.typeOfIndex(inst);
const operand_id = try self.resolve(ty_op.operand);
return try self.extractField(field_ty, operand_id, field);
@@ -3341,7 +3341,7 @@ const DeclGen = struct {
fn airSliceElemPtr(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
const mod = self.module;
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
const slice_ty = self.typeOf(bin_op.lhs);
if (!slice_ty.isVolatilePtr(mod) and self.liveness.isUnused(inst)) return null;
@@ -3358,7 +3358,7 @@ const DeclGen = struct {
fn airSliceElemVal(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
const mod = self.module;
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const slice_ty = self.typeOf(bin_op.lhs);
if (!slice_ty.isVolatilePtr(mod) and self.liveness.isUnused(inst)) return null;
@@ -3392,7 +3392,7 @@ const DeclGen = struct {
if (self.liveness.isUnused(inst)) return null;
const mod = self.module;
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
const src_ptr_ty = self.typeOf(bin_op.lhs);
const elem_ty = src_ptr_ty.childType(mod);
@@ -3411,7 +3411,7 @@ const DeclGen = struct {
if (self.liveness.isUnused(inst)) return null;
const mod = self.module;
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const array_ty = self.typeOf(bin_op.lhs);
const elem_ty = array_ty.childType(mod);
const array_id = try self.resolve(bin_op.lhs);
@@ -3433,7 +3433,7 @@ const DeclGen = struct {
if (self.liveness.isUnused(inst)) return null;
const mod = self.module;
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const ptr_ty = self.typeOf(bin_op.lhs);
const elem_ty = self.typeOfIndex(inst);
const ptr_id = try self.resolve(bin_op.lhs);
@@ -3444,7 +3444,7 @@ const DeclGen = struct {
fn airSetUnionTag(self: *DeclGen, inst: Air.Inst.Index) !void {
const mod = self.module;
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const un_ptr_ty = self.typeOf(bin_op.lhs);
const un_ty = un_ptr_ty.childType(mod);
const layout = self.unionLayout(un_ty);
@@ -3468,7 +3468,7 @@ const DeclGen = struct {
fn airGetUnionTag(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
if (self.liveness.isUnused(inst)) return null;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const un_ty = self.typeOf(ty_op.operand);
const mod = self.module;
@@ -3555,7 +3555,7 @@ const DeclGen = struct {
const mod = self.module;
const ip = &mod.intern_pool;
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.UnionInit, ty_pl.payload).data;
const ty = self.typeOfIndex(inst);
@@ -3572,7 +3572,7 @@ const DeclGen = struct {
if (self.liveness.isUnused(inst)) return null;
const mod = self.module;
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const struct_field = self.air.extraData(Air.StructField, ty_pl.payload).data;
const object_ty = self.typeOf(struct_field.struct_operand);
@@ -3616,11 +3616,11 @@ const DeclGen = struct {
fn airFieldParentPtr(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
const mod = self.module;
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.FieldParentPtr, ty_pl.payload).data;
- const parent_ty = self.air.getRefType(ty_pl.ty).childType(mod);
- const res_ty = try self.resolveType(self.air.getRefType(ty_pl.ty), .indirect);
+ const parent_ty = ty_pl.ty.toType().childType(mod);
+ const res_ty = try self.resolveType(ty_pl.ty.toType(), .indirect);
const usize_ty = Type.usize;
const usize_ty_ref = try self.resolveType(usize_ty, .direct);
@@ -3692,7 +3692,7 @@ const DeclGen = struct {
fn airStructFieldPtrIndex(self: *DeclGen, inst: Air.Inst.Index, field_index: u32) !?IdRef {
if (self.liveness.isUnused(inst)) return null;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const struct_ptr = try self.resolve(ty_op.operand);
const struct_ptr_ty = self.typeOf(ty_op.operand);
const result_ptr_ty = self.typeOfIndex(inst);
@@ -3918,8 +3918,9 @@ const DeclGen = struct {
const mod = self.module;
const ty = self.typeOfIndex(inst);
const inst_datas = self.air.instructions.items(.data);
- const extra = self.air.extraData(Air.Block, inst_datas[inst].ty_pl.payload);
- const body = self.air.extra[extra.end..][0..extra.data.body_len];
+ const extra = self.air.extraData(Air.Block, inst_datas[@intFromEnum(inst)].ty_pl.payload);
+ const body: []const Air.Inst.Index =
+ @ptrCast(self.air.extra[extra.end..][0..extra.data.body_len]);
const have_block_result = ty.isFnOrHasRuntimeBitsIgnoreComptime(mod);
const cf = switch (self.control_flow) {
@@ -3983,7 +3984,7 @@ const DeclGen = struct {
// Check if the target of the branch was this current block.
const block_id_ty_ref = try self.intType(.unsigned, 32);
- const this_block = try self.constInt(block_id_ty_ref, inst);
+ const this_block = try self.constInt(block_id_ty_ref, @intFromEnum(inst));
const jump_to_this_block_id = self.spv.allocId();
const bool_ty_ref = try self.resolveType(Type.bool, .direct);
try self.func.body.emit(self.spv.gpa, .OpIEqual, .{
@@ -4052,7 +4053,7 @@ const DeclGen = struct {
fn airBr(self: *DeclGen, inst: Air.Inst.Index) !void {
const mod = self.module;
- const br = self.air.instructions.items(.data)[inst].br;
+ const br = self.air.instructions.items(.data)[@intFromEnum(inst)].br;
const operand_ty = self.typeOf(br.operand);
switch (self.control_flow) {
@@ -4064,7 +4065,7 @@ const DeclGen = struct {
}
const block_id_ty_ref = try self.intType(.unsigned, 32);
- const next_block = try self.constInt(block_id_ty_ref, br.block_inst);
+ const next_block = try self.constInt(block_id_ty_ref, @intFromEnum(br.block_inst));
try self.structuredBreak(next_block);
},
.unstructured => |cf| {
@@ -4089,10 +4090,10 @@ const DeclGen = struct {
}
fn airCondBr(self: *DeclGen, inst: Air.Inst.Index) !void {
- const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const cond_br = self.air.extraData(Air.CondBr, pl_op.payload);
- const then_body = self.air.extra[cond_br.end..][0..cond_br.data.then_body_len];
- const else_body = self.air.extra[cond_br.end + then_body.len ..][0..cond_br.data.else_body_len];
+ const then_body: []const Air.Inst.Index = @ptrCast(self.air.extra[cond_br.end..][0..cond_br.data.then_body_len]);
+ const else_body: []const Air.Inst.Index = @ptrCast(self.air.extra[cond_br.end + then_body.len ..][0..cond_br.data.else_body_len]);
const condition_id = try self.resolve(pl_op.operand);
const then_label = self.spv.allocId();
@@ -4149,9 +4150,9 @@ const DeclGen = struct {
}
fn airLoop(self: *DeclGen, inst: Air.Inst.Index) !void {
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(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];
+ const body: []const Air.Inst.Index = @ptrCast(self.air.extra[loop.end..][0..loop.data.body_len]);
const body_label = self.spv.allocId();
@@ -4197,7 +4198,7 @@ const DeclGen = struct {
fn airLoad(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
const mod = self.module;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const ptr_ty = self.typeOf(ty_op.operand);
const elem_ty = self.typeOfIndex(inst);
const operand = try self.resolve(ty_op.operand);
@@ -4207,7 +4208,7 @@ const DeclGen = struct {
}
fn airStore(self: *DeclGen, inst: Air.Inst.Index) !void {
- const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
const ptr_ty = self.typeOf(bin_op.lhs);
const elem_ty = ptr_ty.childType(self.module);
const ptr = try self.resolve(bin_op.lhs);
@@ -4217,7 +4218,7 @@ const DeclGen = struct {
}
fn airRet(self: *DeclGen, inst: Air.Inst.Index) !void {
- const operand = self.air.instructions.items(.data)[inst].un_op;
+ const operand = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const ret_ty = self.typeOf(operand);
const mod = self.module;
if (!ret_ty.hasRuntimeBitsIgnoreComptime(mod)) {
@@ -4241,7 +4242,7 @@ const DeclGen = struct {
fn airRetLoad(self: *DeclGen, inst: Air.Inst.Index) !void {
const mod = self.module;
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const ptr_ty = self.typeOf(un_op);
const ret_ty = ptr_ty.childType(mod);
@@ -4269,10 +4270,10 @@ const DeclGen = struct {
fn airTry(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
const mod = self.module;
- const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const err_union_id = try self.resolve(pl_op.operand);
const extra = self.air.extraData(Air.Try, pl_op.payload);
- const body = self.air.extra[extra.end..][0..extra.data.body_len];
+ const body: []const Air.Inst.Index = @ptrCast(self.air.extra[extra.end..][0..extra.data.body_len]);
const err_union_ty = self.typeOf(pl_op.operand);
const payload_ty = self.typeOfIndex(inst);
@@ -4344,7 +4345,7 @@ const DeclGen = struct {
if (self.liveness.isUnused(inst)) return null;
const mod = self.module;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand_id = try self.resolve(ty_op.operand);
const err_union_ty = self.typeOf(ty_op.operand);
const err_ty_ref = try self.resolveType(Type.anyerror, .direct);
@@ -4368,7 +4369,7 @@ const DeclGen = struct {
fn airErrUnionPayload(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
if (self.liveness.isUnused(inst)) return null;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand_id = try self.resolve(ty_op.operand);
const payload_ty = self.typeOfIndex(inst);
const eu_layout = self.errorUnionLayout(payload_ty);
@@ -4384,7 +4385,7 @@ const DeclGen = struct {
if (self.liveness.isUnused(inst)) return null;
const mod = self.module;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const err_union_ty = self.typeOfIndex(inst);
const payload_ty = err_union_ty.errorUnionPayload(mod);
const operand_id = try self.resolve(ty_op.operand);
@@ -4410,7 +4411,7 @@ const DeclGen = struct {
fn airWrapErrUnionPayload(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
if (self.liveness.isUnused(inst)) return null;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const err_union_ty = self.typeOfIndex(inst);
const operand_id = try self.resolve(ty_op.operand);
const payload_ty = self.typeOf(ty_op.operand);
@@ -4436,7 +4437,7 @@ const DeclGen = struct {
if (self.liveness.isUnused(inst)) return null;
const mod = self.module;
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand_id = try self.resolve(un_op);
const optional_ty = self.typeOf(un_op);
@@ -4493,7 +4494,7 @@ const DeclGen = struct {
if (self.liveness.isUnused(inst)) return null;
const mod = self.module;
- const un_op = self.air.instructions.items(.data)[inst].un_op;
+ const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
const operand_id = try self.resolve(un_op);
const err_union_ty = self.typeOf(un_op);
@@ -4529,7 +4530,7 @@ const DeclGen = struct {
if (self.liveness.isUnused(inst)) return null;
const mod = self.module;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const operand_id = try self.resolve(ty_op.operand);
const optional_ty = self.typeOf(ty_op.operand);
const payload_ty = self.typeOfIndex(inst);
@@ -4547,7 +4548,7 @@ const DeclGen = struct {
if (self.liveness.isUnused(inst)) return null;
const mod = self.module;
- const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+ const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
const payload_ty = self.typeOf(ty_op.operand);
if (!payload_ty.hasRuntimeBitsIgnoreComptime(mod)) {
@@ -4569,7 +4570,7 @@ const DeclGen = struct {
fn airSwitchBr(self: *DeclGen, inst: Air.Inst.Index) !void {
const mod = self.module;
- const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const cond_ty = self.typeOf(pl_op.operand);
const cond = try self.resolve(pl_op.operand);
const cond_indirect = try self.convertToIndirect(cond_ty, cond);
@@ -4679,8 +4680,8 @@ const DeclGen = struct {
var extra_index: usize = switch_br.end;
for (0..num_cases) |case_i| {
const case = self.air.extraData(Air.SwitchBr.Case, extra_index);
- const items = @as([]const Air.Inst.Ref, @ptrCast(self.air.extra[case.end..][0..case.data.items_len]));
- const case_body = self.air.extra[case.end + items.len ..][0..case.data.body_len];
+ const items: []const Air.Inst.Ref = @ptrCast(self.air.extra[case.end..][0..case.data.items_len]);
+ const case_body: []const Air.Inst.Index = @ptrCast(self.air.extra[case.end + items.len ..][0..case.data.body_len]);
extra_index = case.end + case.data.items_len + case_body.len;
const label = IdResult{ .id = @intCast(first_case_label.id + case_i) };
@@ -4702,7 +4703,7 @@ const DeclGen = struct {
}
}
- const else_body = self.air.extra[extra_index..][0..switch_br.data.else_body_len];
+ const else_body: []const Air.Inst.Index = @ptrCast(self.air.extra[extra_index..][0..switch_br.data.else_body_len]);
try self.beginSpvBlock(default);
if (else_body.len != 0) {
switch (self.control_flow) {
@@ -4734,7 +4735,7 @@ const DeclGen = struct {
}
fn airDbgStmt(self: *DeclGen, inst: Air.Inst.Index) !void {
- const dbg_stmt = self.air.instructions.items(.data)[inst].dbg_stmt;
+ const dbg_stmt = self.air.instructions.items(.data)[@intFromEnum(inst)].dbg_stmt;
const mod = self.module;
const decl = mod.declPtr(self.decl_index);
const path = decl.getFileScope(mod).sub_file_path;
@@ -4749,7 +4750,7 @@ const DeclGen = struct {
fn airDbgInlineBegin(self: *DeclGen, inst: Air.Inst.Index) !void {
const mod = self.module;
- const fn_ty = self.air.instructions.items(.data)[inst].ty_fn;
+ const fn_ty = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_fn;
const decl_index = mod.funcInfo(fn_ty.func).owner_decl;
const decl = mod.declPtr(decl_index);
try self.base_line_stack.append(self.gpa, decl.src_line);
@@ -4761,7 +4762,7 @@ const DeclGen = struct {
}
fn airDbgVar(self: *DeclGen, inst: Air.Inst.Index) !void {
- const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const target_id = try self.resolve(pl_op.operand);
const name = self.air.nullTerminatedString(pl_op.payload);
try self.spv.debugName(target_id, name);
@@ -4769,7 +4770,7 @@ const DeclGen = struct {
fn airAssembly(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
const mod = self.module;
- const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.Asm, ty_pl.payload);
const is_volatile = @as(u1, @truncate(extra.data.flags >> 31)) != 0;
@@ -4901,7 +4902,7 @@ const DeclGen = struct {
_ = modifier;
const mod = self.module;
- const pl_op = self.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const extra = self.air.extraData(Air.Call, pl_op.payload);
const args = @as([]const Air.Inst.Ref, @ptrCast(self.air.extra[extra.end..][0..extra.data.args_len]));
const callee_ty = self.typeOf(pl_op.operand);
src/Liveness/Verify.zig
@@ -37,7 +37,7 @@ fn verifyBody(self: *Verify, body: []const Air.Inst.Index) Error!void {
continue;
}
- switch (tag[inst]) {
+ switch (tag[@intFromEnum(inst)]) {
// no operands
.arg,
.alloc,
@@ -112,7 +112,7 @@ fn verifyBody(self: *Verify, body: []const Air.Inst.Index) Error!void {
.c_va_copy,
.abs,
=> {
- const ty_op = data[inst].ty_op;
+ const ty_op = data[@intFromEnum(inst)].ty_op;
try self.verifyInstOperands(inst, .{ ty_op.operand, .none, .none });
},
.is_null,
@@ -147,13 +147,13 @@ fn verifyBody(self: *Verify, body: []const Air.Inst.Index) Error!void {
.set_err_return_trace,
.c_va_end,
=> {
- const un_op = data[inst].un_op;
+ const un_op = data[@intFromEnum(inst)].un_op;
try self.verifyInstOperands(inst, .{ un_op, .none, .none });
},
.ret,
.ret_load,
=> {
- const un_op = data[inst].un_op;
+ const un_op = data[@intFromEnum(inst)].un_op;
try self.verifyInstOperands(inst, .{ un_op, .none, .none });
// This instruction terminates the function, so everything should be dead
if (self.live.count() > 0) return invalid("%{}: instructions still alive", .{inst});
@@ -162,36 +162,36 @@ fn verifyBody(self: *Verify, body: []const Air.Inst.Index) Error!void {
.dbg_var_val,
.wasm_memory_grow,
=> {
- const pl_op = data[inst].pl_op;
+ const pl_op = data[@intFromEnum(inst)].pl_op;
try self.verifyInstOperands(inst, .{ pl_op.operand, .none, .none });
},
.prefetch => {
- const prefetch = data[inst].prefetch;
+ const prefetch = data[@intFromEnum(inst)].prefetch;
try self.verifyInstOperands(inst, .{ prefetch.ptr, .none, .none });
},
.reduce,
.reduce_optimized,
=> {
- const reduce = data[inst].reduce;
+ const reduce = data[@intFromEnum(inst)].reduce;
try self.verifyInstOperands(inst, .{ reduce.operand, .none, .none });
},
.union_init => {
- const ty_pl = data[inst].ty_pl;
+ const ty_pl = data[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.UnionInit, ty_pl.payload).data;
try self.verifyInstOperands(inst, .{ extra.init, .none, .none });
},
.struct_field_ptr, .struct_field_val => {
- const ty_pl = data[inst].ty_pl;
+ const ty_pl = data[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.StructField, ty_pl.payload).data;
try self.verifyInstOperands(inst, .{ extra.struct_operand, .none, .none });
},
.field_parent_ptr => {
- const ty_pl = data[inst].ty_pl;
+ const ty_pl = data[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.FieldParentPtr, ty_pl.payload).data;
try self.verifyInstOperands(inst, .{ extra.field_ptr, .none, .none });
},
.atomic_load => {
- const atomic_load = data[inst].atomic_load;
+ const atomic_load = data[@intFromEnum(inst)].atomic_load;
try self.verifyInstOperands(inst, .{ atomic_load.ptr, .none, .none });
},
@@ -261,7 +261,7 @@ fn verifyBody(self: *Verify, body: []const Air.Inst.Index) Error!void {
.memset_safe,
.memcpy,
=> {
- const bin_op = data[inst].bin_op;
+ const bin_op = data[@intFromEnum(inst)].bin_op;
try self.verifyInstOperands(inst, .{ bin_op.lhs, bin_op.rhs, .none });
},
.add_with_overflow,
@@ -274,56 +274,56 @@ fn verifyBody(self: *Verify, body: []const Air.Inst.Index) Error!void {
.slice_elem_ptr,
.slice,
=> {
- const ty_pl = data[inst].ty_pl;
+ const ty_pl = data[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.Bin, ty_pl.payload).data;
try self.verifyInstOperands(inst, .{ extra.lhs, extra.rhs, .none });
},
.shuffle => {
- const ty_pl = data[inst].ty_pl;
+ const ty_pl = data[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.Shuffle, ty_pl.payload).data;
try self.verifyInstOperands(inst, .{ extra.a, extra.b, .none });
},
.cmp_vector,
.cmp_vector_optimized,
=> {
- const ty_pl = data[inst].ty_pl;
+ const ty_pl = data[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.VectorCmp, ty_pl.payload).data;
try self.verifyInstOperands(inst, .{ extra.lhs, extra.rhs, .none });
},
.atomic_rmw => {
- const pl_op = data[inst].pl_op;
+ const pl_op = data[@intFromEnum(inst)].pl_op;
const extra = self.air.extraData(Air.AtomicRmw, pl_op.payload).data;
try self.verifyInstOperands(inst, .{ pl_op.operand, extra.operand, .none });
},
// ternary
.select => {
- const pl_op = data[inst].pl_op;
+ const pl_op = data[@intFromEnum(inst)].pl_op;
const extra = self.air.extraData(Air.Bin, pl_op.payload).data;
try self.verifyInstOperands(inst, .{ pl_op.operand, extra.lhs, extra.rhs });
},
.mul_add => {
- const pl_op = data[inst].pl_op;
+ const pl_op = data[@intFromEnum(inst)].pl_op;
const extra = self.air.extraData(Air.Bin, pl_op.payload).data;
try self.verifyInstOperands(inst, .{ extra.lhs, extra.rhs, pl_op.operand });
},
.vector_store_elem => {
- const vector_store_elem = data[inst].vector_store_elem;
+ const vector_store_elem = data[@intFromEnum(inst)].vector_store_elem;
const extra = self.air.extraData(Air.Bin, vector_store_elem.payload).data;
try self.verifyInstOperands(inst, .{ vector_store_elem.vector_ptr, extra.lhs, extra.rhs });
},
.cmpxchg_strong,
.cmpxchg_weak,
=> {
- const ty_pl = data[inst].ty_pl;
+ const ty_pl = data[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.Cmpxchg, ty_pl.payload).data;
try self.verifyInstOperands(inst, .{ extra.ptr, extra.expected_value, extra.new_value });
},
// big tombs
.aggregate_init => {
- const ty_pl = data[inst].ty_pl;
- const aggregate_ty = self.air.getRefType(ty_pl.ty);
+ const ty_pl = data[@intFromEnum(inst)].ty_pl;
+ const aggregate_ty = ty_pl.ty.toType();
const len = @as(usize, @intCast(aggregate_ty.arrayLenIp(ip)));
const elements = @as([]const Air.Inst.Ref, @ptrCast(self.air.extra[ty_pl.payload..][0..len]));
@@ -334,7 +334,7 @@ fn verifyBody(self: *Verify, body: []const Air.Inst.Index) Error!void {
try self.verifyInst(inst);
},
.call, .call_always_tail, .call_never_tail, .call_never_inline => {
- const pl_op = data[inst].pl_op;
+ const pl_op = data[@intFromEnum(inst)].pl_op;
const extra = self.air.extraData(Air.Call, pl_op.payload);
const args = @as(
[]const Air.Inst.Ref,
@@ -349,7 +349,7 @@ fn verifyBody(self: *Verify, body: []const Air.Inst.Index) Error!void {
try self.verifyInst(inst);
},
.assembly => {
- const ty_pl = data[inst].ty_pl;
+ const ty_pl = data[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.Asm, ty_pl.payload);
var extra_i = extra.end;
const outputs = @as(
@@ -377,9 +377,9 @@ fn verifyBody(self: *Verify, body: []const Air.Inst.Index) Error!void {
// control flow
.@"try" => {
- const pl_op = data[inst].pl_op;
+ const pl_op = data[@intFromEnum(inst)].pl_op;
const extra = self.air.extraData(Air.Try, pl_op.payload);
- const try_body = self.air.extra[extra.end..][0..extra.data.body_len];
+ const try_body: []const Air.Inst.Index = @ptrCast(self.air.extra[extra.end..][0..extra.data.body_len]);
const cond_br_liveness = self.liveness.getCondBr(inst);
@@ -399,9 +399,9 @@ fn verifyBody(self: *Verify, body: []const Air.Inst.Index) Error!void {
try self.verifyInst(inst);
},
.try_ptr => {
- const ty_pl = data[inst].ty_pl;
+ const ty_pl = data[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.TryPtr, ty_pl.payload);
- const try_body = self.air.extra[extra.end..][0..extra.data.body_len];
+ const try_body: []const Air.Inst.Index = @ptrCast(self.air.extra[extra.end..][0..extra.data.body_len]);
const cond_br_liveness = self.liveness.getCondBr(inst);
@@ -421,7 +421,7 @@ fn verifyBody(self: *Verify, body: []const Air.Inst.Index) Error!void {
try self.verifyInst(inst);
},
.br => {
- const br = data[inst].br;
+ const br = data[@intFromEnum(inst)].br;
const gop = try self.blocks.getOrPut(self.gpa, br.block_inst);
try self.verifyOperand(inst, br.operand, self.liveness.operandDies(inst, 0));
@@ -433,10 +433,10 @@ fn verifyBody(self: *Verify, body: []const Air.Inst.Index) Error!void {
try self.verifyInst(inst);
},
.block => {
- const ty_pl = data[inst].ty_pl;
- const block_ty = self.air.getRefType(ty_pl.ty);
+ const ty_pl = data[@intFromEnum(inst)].ty_pl;
+ const block_ty = ty_pl.ty.toType();
const extra = self.air.extraData(Air.Block, ty_pl.payload);
- const block_body = self.air.extra[extra.end..][0..extra.data.body_len];
+ const block_body: []const Air.Inst.Index = @ptrCast(self.air.extra[extra.end..][0..extra.data.body_len]);
const block_liveness = self.liveness.getBlock(inst);
var orig_live = try self.live.clone(self.gpa);
@@ -464,9 +464,9 @@ fn verifyBody(self: *Verify, body: []const Air.Inst.Index) Error!void {
try self.verifyInstOperands(inst, .{ .none, .none, .none });
},
.loop => {
- const ty_pl = data[inst].ty_pl;
+ const ty_pl = data[@intFromEnum(inst)].ty_pl;
const extra = self.air.extraData(Air.Block, ty_pl.payload);
- const loop_body = self.air.extra[extra.end..][0..extra.data.body_len];
+ const loop_body: []const Air.Inst.Index = @ptrCast(self.air.extra[extra.end..][0..extra.data.body_len]);
var live = try self.live.clone(self.gpa);
defer live.deinit(self.gpa);
@@ -479,10 +479,10 @@ fn verifyBody(self: *Verify, body: []const Air.Inst.Index) Error!void {
try self.verifyInstOperands(inst, .{ .none, .none, .none });
},
.cond_br => {
- const pl_op = data[inst].pl_op;
+ const pl_op = data[@intFromEnum(inst)].pl_op;
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 then_body: []const Air.Inst.Index = @ptrCast(self.air.extra[extra.end..][0..extra.data.then_body_len]);
+ const else_body: []const Air.Inst.Index = @ptrCast(self.air.extra[extra.end + then_body.len ..][0..extra.data.else_body_len]);
const cond_br_liveness = self.liveness.getCondBr(inst);
try self.verifyOperand(inst, pl_op.operand, self.liveness.operandDies(inst, 0));
@@ -502,7 +502,7 @@ fn verifyBody(self: *Verify, body: []const Air.Inst.Index) Error!void {
try self.verifyInst(inst);
},
.switch_br => {
- const pl_op = data[inst].pl_op;
+ const pl_op = data[@intFromEnum(inst)].pl_op;
const switch_br = self.air.extraData(Air.SwitchBr, pl_op.payload);
var extra_index = switch_br.end;
var case_i: u32 = 0;
@@ -524,7 +524,7 @@ fn verifyBody(self: *Verify, body: []const Air.Inst.Index) Error!void {
[]const Air.Inst.Ref,
@ptrCast(self.air.extra[case.end..][0..case.data.items_len]),
);
- const case_body = self.air.extra[case.end + items.len ..][0..case.data.body_len];
+ const case_body: []const Air.Inst.Index = @ptrCast(self.air.extra[case.end + items.len ..][0..case.data.body_len]);
extra_index = case.end + items.len + case_body.len;
self.live.deinit(self.gpa);
@@ -534,7 +534,7 @@ fn verifyBody(self: *Verify, body: []const Air.Inst.Index) Error!void {
try self.verifyBody(case_body);
}
- const else_body = self.air.extra[extra_index..][0..switch_br.data.else_body_len];
+ const else_body: []const Air.Inst.Index = @ptrCast(self.air.extra[extra_index..][0..switch_br.data.else_body_len]);
if (else_body.len > 0) {
self.live.deinit(self.gpa);
self.live = try live.clone(self.gpa);
@@ -550,11 +550,11 @@ fn verifyBody(self: *Verify, body: []const Air.Inst.Index) Error!void {
}
fn verifyDeath(self: *Verify, inst: Air.Inst.Index, operand: Air.Inst.Index) Error!void {
- try self.verifyOperand(inst, Air.indexToRef(operand), true);
+ try self.verifyOperand(inst, operand.toRef(), true);
}
fn verifyOperand(self: *Verify, inst: Air.Inst.Index, op_ref: Air.Inst.Ref, dies: bool) Error!void {
- const operand = Air.refToIndexAllowNone(op_ref) orelse {
+ const operand = op_ref.toIndexAllowNone() orelse {
assert(!dies);
return;
};
src/Air.zig
@@ -875,7 +875,19 @@ pub const Inst = struct {
};
/// The position of an AIR instruction within the `Air` instructions array.
- pub const Index = u32;
+ pub const Index = enum(u32) {
+ _,
+
+ pub fn toRef(i: Index) Inst.Ref {
+ assert(@intFromEnum(i) >> 31 == 0);
+ return @enumFromInt((1 << 31) | @intFromEnum(i));
+ }
+
+ pub fn toTargetIndex(i: Index) u31 {
+ assert(@intFromEnum(i) >> 31 == 1);
+ return @truncate(@intFromEnum(i));
+ }
+ };
/// Either a reference to a value stored in the InternPool, or a reference to an AIR instruction.
/// The most-significant bit of the value is a tag bit. This bit is 1 if the value represents an
@@ -976,6 +988,41 @@ pub const Inst = struct {
/// value and may instead be used as a sentinel to indicate null.
none = @intFromEnum(InternPool.Index.none),
_,
+
+ pub fn toInterned(ref: Ref) ?InternPool.Index {
+ assert(ref != .none);
+ return ref.toInternedAllowNone();
+ }
+
+ pub fn toInternedAllowNone(ref: Ref) ?InternPool.Index {
+ return switch (ref) {
+ .var_args_param_type => .var_args_param_type,
+ .none => .none,
+ else => if (@intFromEnum(ref) >> 31 == 0)
+ @enumFromInt(@as(u31, @truncate(@intFromEnum(ref))))
+ else
+ null,
+ };
+ }
+
+ pub fn toIndex(ref: Ref) ?Index {
+ assert(ref != .none);
+ return ref.toIndexAllowNone();
+ }
+
+ pub fn toIndexAllowNone(ref: Ref) ?Index {
+ return switch (ref) {
+ .var_args_param_type, .none => null,
+ else => if (@intFromEnum(ref) >> 31 != 0)
+ @enumFromInt(@as(u31, @truncate(@intFromEnum(ref))))
+ else
+ null,
+ };
+ }
+
+ pub fn toType(ref: Ref) Type {
+ return Type.fromInterned(ref.toInterned().?);
+ }
};
/// All instructions have an 8-byte payload, which is contained within
@@ -1216,20 +1263,20 @@ pub const UnionInit = struct {
pub fn getMainBody(air: Air) []const Air.Inst.Index {
const body_index = air.extra[@intFromEnum(ExtraIndex.main_block)];
const extra = air.extraData(Block, body_index);
- return air.extra[extra.end..][0..extra.data.body_len];
+ return @ptrCast(air.extra[extra.end..][0..extra.data.body_len]);
}
pub fn typeOf(air: *const Air, inst: Air.Inst.Ref, ip: *const InternPool) Type {
- if (refToInterned(inst)) |ip_index| {
+ if (inst.toInterned()) |ip_index| {
return Type.fromInterned(ip.typeOf(ip_index));
} else {
- return air.typeOfIndex(refToIndex(inst).?, ip);
+ return air.typeOfIndex(inst.toIndex().?, ip);
}
}
pub fn typeOfIndex(air: *const Air, inst: Air.Inst.Index, ip: *const InternPool) Type {
const datas = air.instructions.items(.data);
- switch (air.instructions.items(.tag)[inst]) {
+ switch (air.instructions.items(.tag)[@intFromEnum(inst)]) {
.add,
.add_safe,
.add_wrap,
@@ -1269,7 +1316,7 @@ pub fn typeOfIndex(air: *const Air, inst: Air.Inst.Index, ip: *const InternPool)
.div_exact_optimized,
.rem_optimized,
.mod_optimized,
- => return air.typeOf(datas[inst].bin_op.lhs, ip),
+ => return air.typeOf(datas[@intFromEnum(inst)].bin_op.lhs, ip),
.sqrt,
.sin,
@@ -1286,7 +1333,7 @@ pub fn typeOfIndex(air: *const Air, inst: Air.Inst.Index, ip: *const InternPool)
.trunc_float,
.neg,
.neg_optimized,
- => return air.typeOf(datas[inst].un_op, ip),
+ => return air.typeOf(datas[@intFromEnum(inst)].un_op, ip),
.cmp_lt,
.cmp_lte,
@@ -1317,9 +1364,9 @@ pub fn typeOfIndex(air: *const Air, inst: Air.Inst.Index, ip: *const InternPool)
.ret_ptr,
.err_return_trace,
.c_va_start,
- => return datas[inst].ty,
+ => return datas[@intFromEnum(inst)].ty,
- .arg => return air.getRefType(datas[inst].arg.ty),
+ .arg => return datas[@intFromEnum(inst)].arg.ty.toType(),
.assembly,
.block,
@@ -1343,7 +1390,7 @@ pub fn typeOfIndex(air: *const Air, inst: Air.Inst.Index, ip: *const InternPool)
.ptr_add,
.ptr_sub,
.try_ptr,
- => return air.getRefType(datas[inst].ty_pl.ty),
+ => return datas[@intFromEnum(inst)].ty_pl.ty.toType(),
.not,
.bitcast,
@@ -1385,7 +1432,7 @@ pub fn typeOfIndex(air: *const Air, inst: Air.Inst.Index, ip: *const InternPool)
.c_va_arg,
.c_va_copy,
.abs,
- => return air.getRefType(datas[inst].ty_op.ty),
+ => return datas[@intFromEnum(inst)].ty_op.ty.toType(),
.loop,
.br,
@@ -1437,36 +1484,36 @@ pub fn typeOfIndex(air: *const Air, inst: Air.Inst.Index, ip: *const InternPool)
.tag_name, .error_name => return Type.slice_const_u8_sentinel_0,
.call, .call_always_tail, .call_never_tail, .call_never_inline => {
- const callee_ty = air.typeOf(datas[inst].pl_op.operand, ip);
+ const callee_ty = air.typeOf(datas[@intFromEnum(inst)].pl_op.operand, ip);
return Type.fromInterned(ip.funcTypeReturnType(callee_ty.toIntern()));
},
.slice_elem_val, .ptr_elem_val, .array_elem_val => {
- const ptr_ty = air.typeOf(datas[inst].bin_op.lhs, ip);
+ const ptr_ty = air.typeOf(datas[@intFromEnum(inst)].bin_op.lhs, ip);
return ptr_ty.childTypeIp(ip);
},
.atomic_load => {
- const ptr_ty = air.typeOf(datas[inst].atomic_load.ptr, ip);
+ const ptr_ty = air.typeOf(datas[@intFromEnum(inst)].atomic_load.ptr, ip);
return ptr_ty.childTypeIp(ip);
},
.atomic_rmw => {
- const ptr_ty = air.typeOf(datas[inst].pl_op.operand, ip);
+ const ptr_ty = air.typeOf(datas[@intFromEnum(inst)].pl_op.operand, ip);
return ptr_ty.childTypeIp(ip);
},
.reduce, .reduce_optimized => {
- const operand_ty = air.typeOf(datas[inst].reduce.operand, ip);
+ const operand_ty = air.typeOf(datas[@intFromEnum(inst)].reduce.operand, ip);
return Type.fromInterned(ip.indexToKey(operand_ty.ip_index).vector_type.child);
},
- .mul_add => return air.typeOf(datas[inst].pl_op.operand, ip),
+ .mul_add => return air.typeOf(datas[@intFromEnum(inst)].pl_op.operand, ip),
.select => {
- const extra = air.extraData(Air.Bin, datas[inst].pl_op.payload).data;
+ const extra = air.extraData(Air.Bin, datas[@intFromEnum(inst)].pl_op.payload).data;
return air.typeOf(extra.lhs, ip);
},
.@"try" => {
- const err_union_ty = air.typeOf(datas[inst].pl_op.operand, ip);
+ const err_union_ty = air.typeOf(datas[@intFromEnum(inst)].pl_op.operand, ip);
return Type.fromInterned(ip.indexToKey(err_union_ty.ip_index).error_union_type.payload_type);
},
@@ -1480,11 +1527,6 @@ pub fn typeOfIndex(air: *const Air, inst: Air.Inst.Index, ip: *const InternPool)
}
}
-pub fn getRefType(air: Air, ref: Air.Inst.Ref) Type {
- _ = air; // TODO: remove this parameter
- return Type.fromInterned(refToInterned(ref).?);
-}
-
/// Returns the requested data, as well as the new index which is at the start of the
/// trailers for the object.
pub fn extraData(air: Air, comptime T: type, index: usize) struct { data: T, end: usize } {
@@ -1513,21 +1555,6 @@ pub fn deinit(air: *Air, gpa: std.mem.Allocator) void {
air.* = undefined;
}
-pub fn refToInternedAllowNone(ref: Inst.Ref) ?InternPool.Index {
- return switch (ref) {
- .var_args_param_type => .var_args_param_type,
- .none => .none,
- else => if (@intFromEnum(ref) >> 31 == 0) {
- return @as(InternPool.Index, @enumFromInt(@intFromEnum(ref)));
- } else null,
- };
-}
-
-pub fn refToInterned(ref: Inst.Ref) ?InternPool.Index {
- assert(ref != .none);
- return refToInternedAllowNone(ref);
-}
-
pub fn internedToRef(ip_index: InternPool.Index) Inst.Ref {
return switch (ip_index) {
.var_args_param_type => .var_args_param_type,
@@ -1539,31 +1566,12 @@ pub fn internedToRef(ip_index: InternPool.Index) Inst.Ref {
};
}
-pub fn refToIndexAllowNone(ref: Inst.Ref) ?Inst.Index {
- return switch (ref) {
- .var_args_param_type, .none => null,
- else => if (@intFromEnum(ref) >> 31 != 0) {
- return @as(u31, @truncate(@intFromEnum(ref)));
- } else null,
- };
-}
-
-pub fn refToIndex(ref: Inst.Ref) ?Inst.Index {
- assert(ref != .none);
- return refToIndexAllowNone(ref);
-}
-
-pub fn indexToRef(inst: Inst.Index) Inst.Ref {
- assert(inst >> 31 == 0);
- return @enumFromInt((1 << 31) | inst);
-}
-
/// Returns `null` if runtime-known.
pub fn value(air: Air, inst: Inst.Ref, mod: *Module) !?Value {
- if (refToInterned(inst)) |ip_index| {
+ if (inst.toInterned()) |ip_index| {
return Value.fromInterned(ip_index);
}
- const index = refToIndex(inst).?;
+ const index = inst.toIndex().?;
return air.typeOfIndex(index, &mod.intern_pool).onePossibleValue(mod);
}
@@ -1581,8 +1589,8 @@ pub fn nullTerminatedString(air: Air, index: usize) [:0]const u8 {
/// lowered, and Liveness determines its result is unused, backends should
/// avoid lowering it.
pub fn mustLower(air: Air, inst: Air.Inst.Index, ip: *const InternPool) bool {
- const data = air.instructions.items(.data)[inst];
- return switch (air.instructions.items(.tag)[inst]) {
+ const data = air.instructions.items(.data)[@intFromEnum(inst)];
+ return switch (air.instructions.items(.tag)[@intFromEnum(inst)]) {
.arg,
.block,
.loop,
src/Liveness.zig
@@ -177,31 +177,31 @@ pub fn analyze(gpa: Allocator, air: Air, intern_pool: *const InternPool) Allocat
}
pub fn getTombBits(l: Liveness, inst: Air.Inst.Index) Bpi {
- const usize_index = (inst * bpi) / @bitSizeOf(usize);
+ const usize_index = (@intFromEnum(inst) * bpi) / @bitSizeOf(usize);
return @as(Bpi, @truncate(l.tomb_bits[usize_index] >>
- @as(Log2Int(usize), @intCast((inst % (@bitSizeOf(usize) / bpi)) * bpi))));
+ @as(Log2Int(usize), @intCast((@intFromEnum(inst) % (@bitSizeOf(usize) / bpi)) * bpi))));
}
pub fn isUnused(l: Liveness, inst: Air.Inst.Index) bool {
- const usize_index = (inst * bpi) / @bitSizeOf(usize);
+ const usize_index = (@intFromEnum(inst) * bpi) / @bitSizeOf(usize);
const mask = @as(usize, 1) <<
- @as(Log2Int(usize), @intCast((inst % (@bitSizeOf(usize) / bpi)) * bpi + (bpi - 1)));
+ @as(Log2Int(usize), @intCast((@intFromEnum(inst) % (@bitSizeOf(usize) / bpi)) * bpi + (bpi - 1)));
return (l.tomb_bits[usize_index] & mask) != 0;
}
pub fn operandDies(l: Liveness, inst: Air.Inst.Index, operand: OperandInt) bool {
assert(operand < bpi - 1);
- const usize_index = (inst * bpi) / @bitSizeOf(usize);
+ const usize_index = (@intFromEnum(inst) * bpi) / @bitSizeOf(usize);
const mask = @as(usize, 1) <<
- @as(Log2Int(usize), @intCast((inst % (@bitSizeOf(usize) / bpi)) * bpi + operand));
+ @as(Log2Int(usize), @intCast((@intFromEnum(inst) % (@bitSizeOf(usize) / bpi)) * bpi + operand));
return (l.tomb_bits[usize_index] & mask) != 0;
}
pub fn clearOperandDeath(l: Liveness, inst: Air.Inst.Index, operand: OperandInt) void {
assert(operand < bpi - 1);
- const usize_index = (inst * bpi) / @bitSizeOf(usize);
+ const usize_index = (@intFromEnum(inst) * bpi) / @bitSizeOf(usize);
const mask = @as(usize, 1) <<
- @as(Log2Int(usize), @intCast((inst % (@bitSizeOf(usize) / bpi)) * bpi + operand));
+ @as(Log2Int(usize), @intCast((@intFromEnum(inst) % (@bitSizeOf(usize) / bpi)) * bpi + operand));
l.tomb_bits[usize_index] &= ~mask;
}
@@ -229,8 +229,8 @@ pub fn categorizeOperand(
) OperandCategory {
const air_tags = air.instructions.items(.tag);
const air_datas = air.instructions.items(.data);
- const operand_ref = Air.indexToRef(operand);
- switch (air_tags[inst]) {
+ const operand_ref = operand.toRef();
+ switch (air_tags[@intFromEnum(inst)]) {
.add,
.add_safe,
.add_wrap,
@@ -287,7 +287,7 @@ pub fn categorizeOperand(
.cmp_gt_optimized,
.cmp_neq_optimized,
=> {
- const o = air_datas[inst].bin_op;
+ const o = air_datas[@intFromEnum(inst)].bin_op;
if (o.lhs == operand_ref) return matchOperandSmallIndex(l, inst, 0, .none);
if (o.rhs == operand_ref) return matchOperandSmallIndex(l, inst, 1, .none);
return .none;
@@ -304,14 +304,14 @@ pub fn categorizeOperand(
.memset_safe,
.memcpy,
=> {
- const o = air_datas[inst].bin_op;
+ const o = air_datas[@intFromEnum(inst)].bin_op;
if (o.lhs == operand_ref) return matchOperandSmallIndex(l, inst, 0, .write);
if (o.rhs == operand_ref) return matchOperandSmallIndex(l, inst, 1, .write);
return .write;
},
.vector_store_elem => {
- const o = air_datas[inst].vector_store_elem;
+ const o = air_datas[@intFromEnum(inst)].vector_store_elem;
const extra = air.extraData(Air.Bin, o.payload).data;
if (o.vector_ptr == operand_ref) return matchOperandSmallIndex(l, inst, 0, .write);
if (extra.lhs == operand_ref) return matchOperandSmallIndex(l, inst, 1, .none);
@@ -386,7 +386,7 @@ pub fn categorizeOperand(
.c_va_copy,
.abs,
=> {
- const o = air_datas[inst].ty_op;
+ const o = air_datas[@intFromEnum(inst)].ty_op;
if (o.operand == operand_ref) return matchOperandSmallIndex(l, inst, 0, .none);
return .none;
},
@@ -394,7 +394,7 @@ pub fn categorizeOperand(
.optional_payload_ptr_set,
.errunion_payload_ptr_set,
=> {
- const o = air_datas[inst].ty_op;
+ const o = air_datas[@intFromEnum(inst)].ty_op;
if (o.operand == operand_ref) return matchOperandSmallIndex(l, inst, 0, .write);
return .write;
},
@@ -429,7 +429,7 @@ pub fn categorizeOperand(
.cmp_lt_errors_len,
.c_va_end,
=> {
- const o = air_datas[inst].un_op;
+ const o = air_datas[@intFromEnum(inst)].un_op;
if (o == operand_ref) return matchOperandSmallIndex(l, inst, 0, .none);
return .none;
},
@@ -437,13 +437,13 @@ pub fn categorizeOperand(
.ret,
.ret_load,
=> {
- const o = air_datas[inst].un_op;
+ const o = air_datas[@intFromEnum(inst)].un_op;
if (o == operand_ref) return matchOperandSmallIndex(l, inst, 0, .noret);
return .noret;
},
.set_err_return_trace => {
- const o = air_datas[inst].un_op;
+ const o = air_datas[@intFromEnum(inst)].un_op;
if (o == operand_ref) return matchOperandSmallIndex(l, inst, 0, .write);
return .write;
},
@@ -458,7 +458,7 @@ pub fn categorizeOperand(
.slice_elem_ptr,
.slice,
=> {
- const ty_pl = air_datas[inst].ty_pl;
+ const ty_pl = air_datas[@intFromEnum(inst)].ty_pl;
const extra = air.extraData(Air.Bin, ty_pl.payload).data;
if (extra.lhs == operand_ref) return matchOperandSmallIndex(l, inst, 0, .none);
if (extra.rhs == operand_ref) return matchOperandSmallIndex(l, inst, 1, .none);
@@ -468,19 +468,19 @@ pub fn categorizeOperand(
.dbg_var_ptr,
.dbg_var_val,
=> {
- const o = air_datas[inst].pl_op.operand;
+ const o = air_datas[@intFromEnum(inst)].pl_op.operand;
if (o == operand_ref) return matchOperandSmallIndex(l, inst, 0, .none);
return .none;
},
.prefetch => {
- const prefetch = air_datas[inst].prefetch;
+ const prefetch = air_datas[@intFromEnum(inst)].prefetch;
if (prefetch.ptr == operand_ref) return matchOperandSmallIndex(l, inst, 0, .none);
return .none;
},
.call, .call_always_tail, .call_never_tail, .call_never_inline => {
- const inst_data = air_datas[inst].pl_op;
+ const inst_data = air_datas[@intFromEnum(inst)].pl_op;
const callee = inst_data.operand;
const extra = air.extraData(Air.Call, inst_data.payload);
const args = @as([]const Air.Inst.Ref, @ptrCast(air.extra[extra.end..][0..extra.data.args_len]));
@@ -507,7 +507,7 @@ pub fn categorizeOperand(
return .write;
},
.select => {
- const pl_op = air_datas[inst].pl_op;
+ const pl_op = air_datas[@intFromEnum(inst)].pl_op;
const extra = air.extraData(Air.Bin, pl_op.payload).data;
if (pl_op.operand == operand_ref) return matchOperandSmallIndex(l, inst, 0, .none);
if (extra.lhs == operand_ref) return matchOperandSmallIndex(l, inst, 1, .none);
@@ -515,25 +515,25 @@ pub fn categorizeOperand(
return .none;
},
.shuffle => {
- const extra = air.extraData(Air.Shuffle, air_datas[inst].ty_pl.payload).data;
+ const extra = air.extraData(Air.Shuffle, air_datas[@intFromEnum(inst)].ty_pl.payload).data;
if (extra.a == operand_ref) return matchOperandSmallIndex(l, inst, 0, .none);
if (extra.b == operand_ref) return matchOperandSmallIndex(l, inst, 1, .none);
return .none;
},
.reduce, .reduce_optimized => {
- const reduce = air_datas[inst].reduce;
+ const reduce = air_datas[@intFromEnum(inst)].reduce;
if (reduce.operand == operand_ref) return matchOperandSmallIndex(l, inst, 0, .none);
return .none;
},
.cmp_vector, .cmp_vector_optimized => {
- const extra = air.extraData(Air.VectorCmp, air_datas[inst].ty_pl.payload).data;
+ const extra = air.extraData(Air.VectorCmp, air_datas[@intFromEnum(inst)].ty_pl.payload).data;
if (extra.lhs == operand_ref) return matchOperandSmallIndex(l, inst, 0, .none);
if (extra.rhs == operand_ref) return matchOperandSmallIndex(l, inst, 1, .none);
return .none;
},
.aggregate_init => {
- const ty_pl = air_datas[inst].ty_pl;
- const aggregate_ty = air.getRefType(ty_pl.ty);
+ const ty_pl = air_datas[@intFromEnum(inst)].ty_pl;
+ const aggregate_ty = ty_pl.ty.toType();
const len = @as(usize, @intCast(aggregate_ty.arrayLenIp(ip)));
const elements = @as([]const Air.Inst.Ref, @ptrCast(air.extra[ty_pl.payload..][0..len]));
@@ -555,29 +555,29 @@ pub fn categorizeOperand(
return .write;
},
.union_init => {
- const extra = air.extraData(Air.UnionInit, air_datas[inst].ty_pl.payload).data;
+ const extra = air.extraData(Air.UnionInit, air_datas[@intFromEnum(inst)].ty_pl.payload).data;
if (extra.init == operand_ref) return matchOperandSmallIndex(l, inst, 0, .none);
return .none;
},
.struct_field_ptr, .struct_field_val => {
- const extra = air.extraData(Air.StructField, air_datas[inst].ty_pl.payload).data;
+ const extra = air.extraData(Air.StructField, air_datas[@intFromEnum(inst)].ty_pl.payload).data;
if (extra.struct_operand == operand_ref) return matchOperandSmallIndex(l, inst, 0, .none);
return .none;
},
.field_parent_ptr => {
- const extra = air.extraData(Air.FieldParentPtr, air_datas[inst].ty_pl.payload).data;
+ const extra = air.extraData(Air.FieldParentPtr, air_datas[@intFromEnum(inst)].ty_pl.payload).data;
if (extra.field_ptr == operand_ref) return matchOperandSmallIndex(l, inst, 0, .none);
return .none;
},
.cmpxchg_strong, .cmpxchg_weak => {
- const extra = air.extraData(Air.Cmpxchg, air_datas[inst].ty_pl.payload).data;
+ const extra = air.extraData(Air.Cmpxchg, air_datas[@intFromEnum(inst)].ty_pl.payload).data;
if (extra.ptr == operand_ref) return matchOperandSmallIndex(l, inst, 0, .write);
if (extra.expected_value == operand_ref) return matchOperandSmallIndex(l, inst, 1, .write);
if (extra.new_value == operand_ref) return matchOperandSmallIndex(l, inst, 2, .write);
return .write;
},
.mul_add => {
- const pl_op = air_datas[inst].pl_op;
+ const pl_op = air_datas[@intFromEnum(inst)].pl_op;
const extra = air.extraData(Air.Bin, pl_op.payload).data;
if (extra.lhs == operand_ref) return matchOperandSmallIndex(l, inst, 0, .none);
if (extra.rhs == operand_ref) return matchOperandSmallIndex(l, inst, 1, .none);
@@ -585,12 +585,12 @@ pub fn categorizeOperand(
return .none;
},
.atomic_load => {
- const ptr = air_datas[inst].atomic_load.ptr;
+ const ptr = air_datas[@intFromEnum(inst)].atomic_load.ptr;
if (ptr == operand_ref) return matchOperandSmallIndex(l, inst, 0, .none);
return .none;
},
.atomic_rmw => {
- const pl_op = air_datas[inst].pl_op;
+ const pl_op = air_datas[@intFromEnum(inst)].pl_op;
const extra = air.extraData(Air.AtomicRmw, pl_op.payload).data;
if (pl_op.operand == operand_ref) return matchOperandSmallIndex(l, inst, 0, .write);
if (extra.operand == operand_ref) return matchOperandSmallIndex(l, inst, 1, .write);
@@ -598,7 +598,7 @@ pub fn categorizeOperand(
},
.br => {
- const br = air_datas[inst].br;
+ const br = air_datas[@intFromEnum(inst)].br;
if (br.operand == operand_ref) return matchOperandSmallIndex(l, inst, 0, .noret);
return .noret;
},
@@ -606,16 +606,16 @@ pub fn categorizeOperand(
return .complex;
},
.block => {
- const extra = air.extraData(Air.Block, air_datas[inst].ty_pl.payload);
- const body = air.extra[extra.end..][0..extra.data.body_len];
+ const extra = air.extraData(Air.Block, air_datas[@intFromEnum(inst)].ty_pl.payload);
+ const body: []const Air.Inst.Index = @ptrCast(air.extra[extra.end..][0..extra.data.body_len]);
- if (body.len == 1 and air_tags[body[0]] == .cond_br) {
+ if (body.len == 1 and air_tags[@intFromEnum(body[0])] == .cond_br) {
// Peephole optimization for "panic-like" conditionals, which have
// one empty branch and another which calls a `noreturn` function.
// This allows us to infer that safety checks do not modify memory,
// as far as control flow successors are concerned.
- const inst_data = air_datas[body[0]].pl_op;
+ const inst_data = air_datas[@intFromEnum(body[0])].pl_op;
const cond_extra = air.extraData(Air.CondBr, inst_data.payload);
if (inst_data.operand == operand_ref and operandDies(l, body[0], 0))
return .tomb;
@@ -623,21 +623,21 @@ pub fn categorizeOperand(
if (cond_extra.data.then_body_len > 2 or cond_extra.data.else_body_len > 2)
return .complex;
- const then_body = air.extra[cond_extra.end..][0..cond_extra.data.then_body_len];
- const else_body = air.extra[cond_extra.end + cond_extra.data.then_body_len ..][0..cond_extra.data.else_body_len];
- if (then_body.len > 1 and air_tags[then_body[1]] != .unreach)
+ const then_body: []const Air.Inst.Index = @ptrCast(air.extra[cond_extra.end..][0..cond_extra.data.then_body_len]);
+ const else_body: []const Air.Inst.Index = @ptrCast(air.extra[cond_extra.end + cond_extra.data.then_body_len ..][0..cond_extra.data.else_body_len]);
+ if (then_body.len > 1 and air_tags[@intFromEnum(then_body[1])] != .unreach)
return .complex;
- if (else_body.len > 1 and air_tags[else_body[1]] != .unreach)
+ if (else_body.len > 1 and air_tags[@intFromEnum(else_body[1])] != .unreach)
return .complex;
var operand_live: bool = true;
- for (&[_]u32{ then_body[0], else_body[0] }) |cond_inst| {
+ for (&[_]Air.Inst.Index{ then_body[0], else_body[0] }) |cond_inst| {
if (l.categorizeOperand(air, cond_inst, operand, ip) == .tomb)
operand_live = false;
- switch (air_tags[cond_inst]) {
+ switch (air_tags[@intFromEnum(cond_inst)]) {
.br => { // Breaks immediately back to block
- const br = air_datas[cond_inst].br;
+ const br = air_datas[@intFromEnum(cond_inst)].br;
if (br.block_inst != inst)
return .complex;
},
@@ -666,7 +666,7 @@ pub fn categorizeOperand(
return .complex;
},
.wasm_memory_grow => {
- const pl_op = air_datas[inst].pl_op;
+ const pl_op = air_datas[@intFromEnum(inst)].pl_op;
if (pl_op.operand == operand_ref) return matchOperandSmallIndex(l, inst, 0, .none);
return .none;
},
@@ -701,11 +701,11 @@ pub fn getCondBr(l: Liveness, inst: Air.Inst.Index) CondBrSlices {
index += 1;
const else_death_count = l.extra[index];
index += 1;
- const then_deaths = l.extra[index..][0..then_death_count];
+ const then_deaths: []const Air.Inst.Index = @ptrCast(l.extra[index..][0..then_death_count]);
index += then_death_count;
return .{
.then_deaths = then_deaths,
- .else_deaths = l.extra[index..][0..else_death_count],
+ .else_deaths = @ptrCast(l.extra[index..][0..else_death_count]),
};
}
@@ -731,13 +731,13 @@ pub fn getSwitchBr(l: Liveness, gpa: Allocator, inst: Air.Inst.Index, cases_len:
while (case_i < cases_len - 1) : (case_i += 1) {
const case_death_count: u32 = l.extra[index];
index += 1;
- const case_deaths = l.extra[index..][0..case_death_count];
+ const case_deaths: []const Air.Inst.Index = @ptrCast(l.extra[index..][0..case_death_count]);
index += case_death_count;
deaths.appendAssumeCapacity(case_deaths);
}
{
// Else
- const else_deaths = l.extra[index..][0..else_death_count];
+ const else_deaths: []const Air.Inst.Index = @ptrCast(l.extra[index..][0..else_death_count]);
deaths.appendAssumeCapacity(else_deaths);
}
return SwitchBrTable{
@@ -756,7 +756,7 @@ pub fn getBlock(l: Liveness, inst: Air.Inst.Index) BlockSlices {
.deaths = &.{},
};
const death_count = l.extra[index];
- const deaths = l.extra[index + 1 ..][0..death_count];
+ const deaths: []const Air.Inst.Index = @ptrCast(l.extra[index + 1 ..][0..death_count]);
return .{
.deaths = deaths,
};
@@ -883,7 +883,7 @@ fn analyzeInst(
const inst_tags = a.air.instructions.items(.tag);
const inst_datas = a.air.instructions.items(.data);
- switch (inst_tags[inst]) {
+ switch (inst_tags[@intFromEnum(inst)]) {
.add,
.add_safe,
.add_optimized,
@@ -949,12 +949,12 @@ fn analyzeInst(
.memset_safe,
.memcpy,
=> {
- const o = inst_datas[inst].bin_op;
+ const o = inst_datas[@intFromEnum(inst)].bin_op;
return analyzeOperands(a, pass, data, inst, .{ o.lhs, o.rhs, .none });
},
.vector_store_elem => {
- const o = inst_datas[inst].vector_store_elem;
+ const o = inst_datas[@intFromEnum(inst)].vector_store_elem;
const extra = a.air.extraData(Air.Bin, o.payload).data;
return analyzeOperands(a, pass, data, inst, .{ o.vector_ptr, extra.lhs, extra.rhs });
},
@@ -1029,7 +1029,7 @@ fn analyzeInst(
.c_va_copy,
.abs,
=> {
- const o = inst_datas[inst].ty_op;
+ const o = inst_datas[@intFromEnum(inst)].ty_op;
return analyzeOperands(a, pass, data, inst, .{ o.operand, .none, .none });
},
@@ -1065,14 +1065,14 @@ fn analyzeInst(
.set_err_return_trace,
.c_va_end,
=> {
- const operand = inst_datas[inst].un_op;
+ const operand = inst_datas[@intFromEnum(inst)].un_op;
return analyzeOperands(a, pass, data, inst, .{ operand, .none, .none });
},
.ret,
.ret_load,
=> {
- const operand = inst_datas[inst].un_op;
+ const operand = inst_datas[@intFromEnum(inst)].un_op;
return analyzeFuncEnd(a, pass, data, inst, .{ operand, .none, .none });
},
@@ -1086,7 +1086,7 @@ fn analyzeInst(
.slice_elem_ptr,
.slice,
=> {
- const ty_pl = inst_datas[inst].ty_pl;
+ const ty_pl = inst_datas[@intFromEnum(inst)].ty_pl;
const extra = a.air.extraData(Air.Bin, ty_pl.payload).data;
return analyzeOperands(a, pass, data, inst, .{ extra.lhs, extra.rhs, .none });
},
@@ -1094,17 +1094,17 @@ fn analyzeInst(
.dbg_var_ptr,
.dbg_var_val,
=> {
- const operand = inst_datas[inst].pl_op.operand;
+ const operand = inst_datas[@intFromEnum(inst)].pl_op.operand;
return analyzeOperands(a, pass, data, inst, .{ operand, .none, .none });
},
.prefetch => {
- const prefetch = inst_datas[inst].prefetch;
+ const prefetch = inst_datas[@intFromEnum(inst)].prefetch;
return analyzeOperands(a, pass, data, inst, .{ prefetch.ptr, .none, .none });
},
.call, .call_always_tail, .call_never_tail, .call_never_inline => {
- const inst_data = inst_datas[inst].pl_op;
+ const inst_data = inst_datas[@intFromEnum(inst)].pl_op;
const callee = inst_data.operand;
const extra = a.air.extraData(Air.Call, inst_data.payload);
const args = @as([]const Air.Inst.Ref, @ptrCast(a.air.extra[extra.end..][0..extra.data.args_len]));
@@ -1126,25 +1126,25 @@ fn analyzeInst(
return big.finish();
},
.select => {
- const pl_op = inst_datas[inst].pl_op;
+ const pl_op = inst_datas[@intFromEnum(inst)].pl_op;
const extra = a.air.extraData(Air.Bin, pl_op.payload).data;
return analyzeOperands(a, pass, data, inst, .{ pl_op.operand, extra.lhs, extra.rhs });
},
.shuffle => {
- const extra = a.air.extraData(Air.Shuffle, inst_datas[inst].ty_pl.payload).data;
+ const extra = a.air.extraData(Air.Shuffle, inst_datas[@intFromEnum(inst)].ty_pl.payload).data;
return analyzeOperands(a, pass, data, inst, .{ extra.a, extra.b, .none });
},
.reduce, .reduce_optimized => {
- const reduce = inst_datas[inst].reduce;
+ const reduce = inst_datas[@intFromEnum(inst)].reduce;
return analyzeOperands(a, pass, data, inst, .{ reduce.operand, .none, .none });
},
.cmp_vector, .cmp_vector_optimized => {
- const extra = a.air.extraData(Air.VectorCmp, inst_datas[inst].ty_pl.payload).data;
+ const extra = a.air.extraData(Air.VectorCmp, inst_datas[@intFromEnum(inst)].ty_pl.payload).data;
return analyzeOperands(a, pass, data, inst, .{ extra.lhs, extra.rhs, .none });
},
.aggregate_init => {
- const ty_pl = inst_datas[inst].ty_pl;
- const aggregate_ty = a.air.getRefType(ty_pl.ty);
+ const ty_pl = inst_datas[@intFromEnum(inst)].ty_pl;
+ const aggregate_ty = ty_pl.ty.toType();
const len = @as(usize, @intCast(aggregate_ty.arrayLenIp(ip)));
const elements = @as([]const Air.Inst.Ref, @ptrCast(a.air.extra[ty_pl.payload..][0..len]));
@@ -1164,32 +1164,32 @@ fn analyzeInst(
return big.finish();
},
.union_init => {
- const extra = a.air.extraData(Air.UnionInit, inst_datas[inst].ty_pl.payload).data;
+ const extra = a.air.extraData(Air.UnionInit, inst_datas[@intFromEnum(inst)].ty_pl.payload).data;
return analyzeOperands(a, pass, data, inst, .{ extra.init, .none, .none });
},
.struct_field_ptr, .struct_field_val => {
- const extra = a.air.extraData(Air.StructField, inst_datas[inst].ty_pl.payload).data;
+ const extra = a.air.extraData(Air.StructField, inst_datas[@intFromEnum(inst)].ty_pl.payload).data;
return analyzeOperands(a, pass, data, inst, .{ extra.struct_operand, .none, .none });
},
.field_parent_ptr => {
- const extra = a.air.extraData(Air.FieldParentPtr, inst_datas[inst].ty_pl.payload).data;
+ const extra = a.air.extraData(Air.FieldParentPtr, inst_datas[@intFromEnum(inst)].ty_pl.payload).data;
return analyzeOperands(a, pass, data, inst, .{ extra.field_ptr, .none, .none });
},
.cmpxchg_strong, .cmpxchg_weak => {
- const extra = a.air.extraData(Air.Cmpxchg, inst_datas[inst].ty_pl.payload).data;
+ const extra = a.air.extraData(Air.Cmpxchg, inst_datas[@intFromEnum(inst)].ty_pl.payload).data;
return analyzeOperands(a, pass, data, inst, .{ extra.ptr, extra.expected_value, extra.new_value });
},
.mul_add => {
- const pl_op = inst_datas[inst].pl_op;
+ const pl_op = inst_datas[@intFromEnum(inst)].pl_op;
const extra = a.air.extraData(Air.Bin, pl_op.payload).data;
return analyzeOperands(a, pass, data, inst, .{ extra.lhs, extra.rhs, pl_op.operand });
},
.atomic_load => {
- const ptr = inst_datas[inst].atomic_load.ptr;
+ const ptr = inst_datas[@intFromEnum(inst)].atomic_load.ptr;
return analyzeOperands(a, pass, data, inst, .{ ptr, .none, .none });
},
.atomic_rmw => {
- const pl_op = inst_datas[inst].pl_op;
+ const pl_op = inst_datas[@intFromEnum(inst)].pl_op;
const extra = a.air.extraData(Air.AtomicRmw, pl_op.payload).data;
return analyzeOperands(a, pass, data, inst, .{ pl_op.operand, extra.operand, .none });
},
@@ -1197,7 +1197,7 @@ fn analyzeInst(
.br => return analyzeInstBr(a, pass, data, inst),
.assembly => {
- const extra = a.air.extraData(Air.Asm, inst_datas[inst].ty_pl.payload);
+ const extra = a.air.extraData(Air.Asm, inst_datas[@intFromEnum(inst)].ty_pl.payload);
var extra_i: usize = extra.end;
const outputs = @as([]const Air.Inst.Ref, @ptrCast(a.air.extra[extra_i..][0..extra.data.outputs_len]));
extra_i += outputs.len;
@@ -1246,7 +1246,7 @@ fn analyzeInst(
.switch_br => return analyzeInstSwitchBr(a, pass, data, inst),
.wasm_memory_grow => {
- const pl_op = inst_datas[inst].pl_op;
+ const pl_op = inst_datas[@intFromEnum(inst)].pl_op;
return analyzeOperands(a, pass, data, inst, .{ pl_op.operand, .none, .none });
},
}
@@ -1270,20 +1270,20 @@ fn analyzeOperands(
_ = data.live_set.remove(inst);
for (operands) |op_ref| {
- const operand = Air.refToIndexAllowNone(op_ref) orelse continue;
+ const operand = op_ref.toIndexAllowNone() orelse continue;
_ = try data.live_set.put(gpa, operand, {});
}
},
.main_analysis => {
- const usize_index = (inst * bpi) / @bitSizeOf(usize);
+ const usize_index = (@intFromEnum(inst) * bpi) / @bitSizeOf(usize);
// This logic must synchronize with `will_die_immediately` in `AnalyzeBigOperands.init`.
const immediate_death = if (data.live_set.remove(inst)) blk: {
- log.debug("[{}] %{}: removed from live set", .{ pass, inst });
+ log.debug("[{}] %{}: removed from live set", .{ pass, @intFromEnum(inst) });
break :blk false;
} else blk: {
- log.debug("[{}] %{}: immediate death", .{ pass, inst });
+ log.debug("[{}] %{}: immediate death", .{ pass, @intFromEnum(inst) });
break :blk true;
};
@@ -1299,19 +1299,19 @@ fn analyzeOperands(
while (i > 0) {
i -= 1;
const op_ref = operands[i];
- const operand = Air.refToIndexAllowNone(op_ref) orelse continue;
+ const operand = op_ref.toIndexAllowNone() orelse continue;
const mask = @as(Bpi, 1) << @as(OperandInt, @intCast(i));
if ((try data.live_set.fetchPut(gpa, operand, {})) == null) {
- log.debug("[{}] %{}: added %{} to live set (operand dies here)", .{ pass, inst, operand });
+ log.debug("[{}] %{}: added %{} to live set (operand dies here)", .{ pass, @intFromEnum(inst), operand });
tomb_bits |= mask;
}
}
}
a.tomb_bits[usize_index] |= @as(usize, tomb_bits) <<
- @as(Log2Int(usize), @intCast((inst % (@bitSizeOf(usize) / bpi)) * bpi));
+ @as(Log2Int(usize), @intCast((@intFromEnum(inst) % (@bitSizeOf(usize) / bpi)) * bpi));
},
}
}
@@ -1346,7 +1346,7 @@ fn analyzeInstBr(
inst: Air.Inst.Index,
) !void {
const inst_datas = a.air.instructions.items(.data);
- const br = inst_datas[inst].br;
+ const br = inst_datas[@intFromEnum(inst)].br;
const gpa = a.gpa;
switch (pass) {
@@ -1373,9 +1373,9 @@ fn analyzeInstBlock(
inst: Air.Inst.Index,
) !void {
const inst_datas = a.air.instructions.items(.data);
- const ty_pl = inst_datas[inst].ty_pl;
+ const ty_pl = inst_datas[@intFromEnum(inst)].ty_pl;
const extra = a.air.extraData(Air.Block, ty_pl.payload);
- const body = a.air.extra[extra.end..][0..extra.data.body_len];
+ const body: []const Air.Inst.Index = @ptrCast(a.air.extra[extra.end..][0..extra.data.body_len]);
const gpa = a.gpa;
@@ -1405,7 +1405,7 @@ fn analyzeInstBlock(
// If the block is noreturn, block deaths not only aren't useful, they're impossible to
// find: there could be more stuff alive after the block than before it!
- if (!a.intern_pool.isNoReturn(a.air.getRefType(ty_pl.ty).ip_index)) {
+ if (!a.intern_pool.isNoReturn(ty_pl.ty.toType().ip_index)) {
// The block kills the difference in the live sets
const block_scope = data.block_scopes.get(inst).?;
const num_deaths = data.live_set.count() - block_scope.live_set.count();
@@ -1421,7 +1421,7 @@ fn analyzeInstBlock(
const alive = key.*;
if (!block_scope.live_set.contains(alive)) {
// Dies in block
- a.extra.appendAssumeCapacity(alive);
+ a.extra.appendAssumeCapacity(@intFromEnum(alive));
measured_num += 1;
}
}
@@ -1430,7 +1430,7 @@ fn analyzeInstBlock(
log.debug("[{}] %{}: block deaths are {}", .{
pass,
inst,
- fmtInstList(a.extra.items[extra_index + 1 ..][0..num_deaths]),
+ fmtInstList(@ptrCast(a.extra.items[extra_index + 1 ..][0..num_deaths])),
});
}
},
@@ -1444,8 +1444,8 @@ fn analyzeInstLoop(
inst: Air.Inst.Index,
) !void {
const inst_datas = a.air.instructions.items(.data);
- const extra = a.air.extraData(Air.Block, inst_datas[inst].ty_pl.payload);
- const body = a.air.extra[extra.end..][0..extra.data.body_len];
+ const extra = a.air.extraData(Air.Block, inst_datas[@intFromEnum(inst)].ty_pl.payload);
+ const body: []const Air.Inst.Index = @ptrCast(a.air.extra[extra.end..][0..extra.data.body_len]);
const gpa = a.gpa;
try analyzeOperands(a, pass, data, inst, .{ .none, .none, .none });
@@ -1469,7 +1469,7 @@ fn analyzeInstLoop(
var it = data.breaks.keyIterator();
while (it.next()) |key| {
const block_inst = key.*;
- a.extra.appendAssumeCapacity(block_inst);
+ a.extra.appendAssumeCapacity(@intFromEnum(block_inst));
}
log.debug("[{}] %{}: includes breaks to {}", .{ pass, inst, fmtInstSet(&data.breaks) });
@@ -1481,7 +1481,7 @@ fn analyzeInstLoop(
it = data.live_set.keyIterator();
while (it.next()) |key| {
const alive = key.*;
- a.extra.appendAssumeCapacity(alive);
+ a.extra.appendAssumeCapacity(@intFromEnum(alive));
}
log.debug("[{}] %{}: maintain liveness of {}", .{ pass, inst, fmtInstSet(&data.live_set) });
@@ -1506,15 +1506,15 @@ fn analyzeInstLoop(
const extra_idx = a.special.fetchRemove(inst).?.value; // remove because this data does not exist after analysis
const num_breaks = data.old_extra.items[extra_idx];
- const breaks = data.old_extra.items[extra_idx + 1 ..][0..num_breaks];
+ const breaks: []const Air.Inst.Index = @ptrCast(data.old_extra.items[extra_idx + 1 ..][0..num_breaks]);
const num_loop_live = data.old_extra.items[extra_idx + num_breaks + 1];
- const loop_live = data.old_extra.items[extra_idx + num_breaks + 2 ..][0..num_loop_live];
+ const loop_live: []const Air.Inst.Index = @ptrCast(data.old_extra.items[extra_idx + num_breaks + 2 ..][0..num_loop_live]);
// This is necessarily not in the same control flow branch, because loops are noreturn
data.live_set.clearRetainingCapacity();
- try data.live_set.ensureUnusedCapacity(gpa, @as(u32, @intCast(loop_live.len)));
+ try data.live_set.ensureUnusedCapacity(gpa, @intCast(loop_live.len));
for (loop_live) |alive| {
data.live_set.putAssumeCapacity(alive, {});
}
@@ -1551,25 +1551,25 @@ fn analyzeInstCondBr(
const gpa = a.gpa;
const extra = switch (inst_type) {
- .cond_br => a.air.extraData(Air.CondBr, inst_datas[inst].pl_op.payload),
- .@"try" => a.air.extraData(Air.Try, inst_datas[inst].pl_op.payload),
- .try_ptr => a.air.extraData(Air.TryPtr, inst_datas[inst].ty_pl.payload),
+ .cond_br => a.air.extraData(Air.CondBr, inst_datas[@intFromEnum(inst)].pl_op.payload),
+ .@"try" => a.air.extraData(Air.Try, inst_datas[@intFromEnum(inst)].pl_op.payload),
+ .try_ptr => a.air.extraData(Air.TryPtr, inst_datas[@intFromEnum(inst)].ty_pl.payload),
};
const condition = switch (inst_type) {
- .cond_br, .@"try" => inst_datas[inst].pl_op.operand,
+ .cond_br, .@"try" => inst_datas[@intFromEnum(inst)].pl_op.operand,
.try_ptr => extra.data.ptr,
};
- const then_body = switch (inst_type) {
- .cond_br => a.air.extra[extra.end..][0..extra.data.then_body_len],
- else => {}, // we won't use this
+ const then_body: []const Air.Inst.Index = switch (inst_type) {
+ .cond_br => @ptrCast(a.air.extra[extra.end..][0..extra.data.then_body_len]),
+ else => &.{}, // we won't use this
};
- const else_body = switch (inst_type) {
+ const else_body: []const Air.Inst.Index = @ptrCast(switch (inst_type) {
.cond_br => a.air.extra[extra.end + then_body.len ..][0..extra.data.else_body_len],
.@"try", .try_ptr => a.air.extra[extra.end..][0..extra.data.body_len],
- };
+ });
switch (pass) {
.loop_analysis => {
@@ -1645,8 +1645,8 @@ fn analyzeInstCondBr(
.then_death_count = then_death_count,
.else_death_count = else_death_count,
});
- a.extra.appendSliceAssumeCapacity(then_mirrored_deaths.items);
- a.extra.appendSliceAssumeCapacity(else_mirrored_deaths.items);
+ a.extra.appendSliceAssumeCapacity(@ptrCast(then_mirrored_deaths.items));
+ a.extra.appendSliceAssumeCapacity(@ptrCast(else_mirrored_deaths.items));
try a.special.put(gpa, inst, extra_index);
},
}
@@ -1661,7 +1661,7 @@ fn analyzeInstSwitchBr(
inst: Air.Inst.Index,
) !void {
const inst_datas = a.air.instructions.items(.data);
- const pl_op = inst_datas[inst].pl_op;
+ const pl_op = inst_datas[@intFromEnum(inst)].pl_op;
const condition = pl_op.operand;
const switch_br = a.air.extraData(Air.SwitchBr, pl_op.payload);
const gpa = a.gpa;
@@ -1672,12 +1672,12 @@ fn analyzeInstSwitchBr(
var air_extra_index: usize = switch_br.end;
for (0..ncases) |_| {
const case = a.air.extraData(Air.SwitchBr.Case, air_extra_index);
- const case_body = a.air.extra[case.end + case.data.items_len ..][0..case.data.body_len];
+ const case_body: []const Air.Inst.Index = @ptrCast(a.air.extra[case.end + case.data.items_len ..][0..case.data.body_len]);
air_extra_index = case.end + case.data.items_len + case_body.len;
try analyzeBody(a, pass, data, case_body);
}
{ // else
- const else_body = a.air.extra[air_extra_index..][0..switch_br.data.else_body_len];
+ const else_body: []const Air.Inst.Index = @ptrCast(a.air.extra[air_extra_index..][0..switch_br.data.else_body_len]);
try analyzeBody(a, pass, data, else_body);
}
},
@@ -1698,13 +1698,13 @@ fn analyzeInstSwitchBr(
var air_extra_index: usize = switch_br.end;
for (case_live_sets[0..ncases]) |*live_set| {
const case = a.air.extraData(Air.SwitchBr.Case, air_extra_index);
- const case_body = a.air.extra[case.end + case.data.items_len ..][0..case.data.body_len];
+ const case_body: []const Air.Inst.Index = @ptrCast(a.air.extra[case.end + case.data.items_len ..][0..case.data.body_len]);
air_extra_index = case.end + case.data.items_len + case_body.len;
try analyzeBody(a, pass, data, case_body);
live_set.* = data.live_set.move();
}
{ // else
- const else_body = a.air.extra[air_extra_index..][0..switch_br.data.else_body_len];
+ const else_body: []const Air.Inst.Index = @ptrCast(a.air.extra[air_extra_index..][0..switch_br.data.else_body_len]);
try analyzeBody(a, pass, data, else_body);
case_live_sets[ncases] = data.live_set.move();
}
@@ -1757,10 +1757,10 @@ fn analyzeInstSwitchBr(
const num = @as(u32, @intCast(mirrored.items.len));
try a.extra.ensureUnusedCapacity(gpa, num + 1);
a.extra.appendAssumeCapacity(num);
- a.extra.appendSliceAssumeCapacity(mirrored.items);
+ a.extra.appendSliceAssumeCapacity(@ptrCast(mirrored.items));
}
try a.extra.ensureUnusedCapacity(gpa, else_death_count);
- a.extra.appendSliceAssumeCapacity(mirrored_deaths[ncases].items);
+ a.extra.appendSliceAssumeCapacity(@ptrCast(mirrored_deaths[ncases].items));
try a.special.put(gpa, inst, extra_index);
},
}
@@ -1826,7 +1826,7 @@ fn AnalyzeBigOperands(comptime pass: LivenessPass) type {
return;
}
- const operand = Air.refToIndex(op_ref) orelse return;
+ const operand = op_ref.toIndex() orelse return;
// If our result is unused and the instruction doesn't need to be lowered, backends will
// skip the lowering of this instruction, so we don't want to record uses of operands.
src/Module.zig
@@ -4591,8 +4591,8 @@ pub fn analyzeFnBody(mod: *Module, func_index: InternPool.Index, arena: Allocato
gop.value_ptr.* = Air.internedToRef(opv.toIntern());
continue;
}
- const arg_index: u32 = @intCast(sema.air_instructions.len);
- gop.value_ptr.* = Air.indexToRef(arg_index);
+ const arg_index: Air.Inst.Index = @enumFromInt(sema.air_instructions.len);
+ gop.value_ptr.* = arg_index.toRef();
inner_block.instructions.appendAssumeCapacity(arg_index);
sema.air_instructions.appendAssumeCapacity(.{
.tag = .arg,
@@ -4626,7 +4626,7 @@ pub fn analyzeFnBody(mod: *Module, func_index: InternPool.Index, arena: Allocato
while (it.next()) |ptr_inst| {
// The lack of a resolve_inferred_alloc means that this instruction
// is unused so it just has to be a no-op.
- sema.air_instructions.set(ptr_inst.*, .{
+ sema.air_instructions.set(@intFromEnum(ptr_inst.*), .{
.tag = .alloc,
.data = .{ .ty = Type.single_const_pointer_to_comptime_int },
});
@@ -4659,7 +4659,7 @@ pub fn analyzeFnBody(mod: *Module, func_index: InternPool.Index, arena: Allocato
const main_block_index = sema.addExtraAssumeCapacity(Air.Block{
.body_len = @intCast(inner_block.instructions.items.len),
});
- sema.air_extra.appendSliceAssumeCapacity(inner_block.instructions.items);
+ sema.air_extra.appendSliceAssumeCapacity(@ptrCast(inner_block.instructions.items));
sema.air_extra.items[@intFromEnum(Air.ExtraIndex.main_block)] = main_block_index;
// Resolving inferred error sets is done *before* setting the function
src/print_air.zig
@@ -94,7 +94,7 @@ const Writer = struct {
}
fn writeInst(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
- const tag = w.air.instructions.items(.tag)[inst];
+ const tag = w.air.instructions.items(.tag)[@intFromEnum(inst)];
try s.writeByteNTimes(' ', w.indent);
try s.print("%{d}{c}= {s}(", .{
inst,
@@ -329,14 +329,14 @@ const Writer = struct {
}
fn writeBinOp(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
- const bin_op = w.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = w.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
try w.writeOperand(s, inst, 0, bin_op.lhs);
try s.writeAll(", ");
try w.writeOperand(s, inst, 1, bin_op.rhs);
}
fn writeUnOp(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
- const un_op = w.air.instructions.items(.data)[inst].un_op;
+ const un_op = w.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
try w.writeOperand(s, inst, 0, un_op);
}
@@ -351,33 +351,33 @@ const Writer = struct {
}
fn writeTy(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
- const ty = w.air.instructions.items(.data)[inst].ty;
+ const ty = w.air.instructions.items(.data)[@intFromEnum(inst)].ty;
try w.writeType(s, ty);
}
fn writeArg(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
- const arg = w.air.instructions.items(.data)[inst].arg;
- try w.writeType(s, w.air.getRefType(arg.ty));
+ const arg = w.air.instructions.items(.data)[@intFromEnum(inst)].arg;
+ try w.writeType(s, arg.ty.toType());
try s.print(", {d}", .{arg.src_index});
}
fn writeTyOp(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
- const ty_op = w.air.instructions.items(.data)[inst].ty_op;
- try w.writeType(s, w.air.getRefType(ty_op.ty));
+ const ty_op = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
+ try w.writeType(s, ty_op.ty.toType());
try s.writeAll(", ");
try w.writeOperand(s, inst, 0, ty_op.operand);
}
fn writeBlock(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
- const ty_pl = w.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = w.air.extraData(Air.Block, ty_pl.payload);
- const body = w.air.extra[extra.end..][0..extra.data.body_len];
+ const body: []const Air.Inst.Index = @ptrCast(w.air.extra[extra.end..][0..extra.data.body_len]);
const liveness_block = if (w.liveness) |liveness|
liveness.getBlock(inst)
else
Liveness.BlockSlices{ .deaths = &.{} };
- try w.writeType(s, w.air.getRefType(ty_pl.ty));
+ try w.writeType(s, ty_pl.ty.toType());
if (w.skip_body) return s.writeAll(", ...");
try s.writeAll(", {\n");
const old_indent = w.indent;
@@ -393,11 +393,11 @@ const Writer = struct {
}
fn writeLoop(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
- const ty_pl = w.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = w.air.extraData(Air.Block, ty_pl.payload);
- const body = w.air.extra[extra.end..][0..extra.data.body_len];
+ const body: []const Air.Inst.Index = @ptrCast(w.air.extra[extra.end..][0..extra.data.body_len]);
- try w.writeType(s, w.air.getRefType(ty_pl.ty));
+ try w.writeType(s, ty_pl.ty.toType());
if (w.skip_body) return s.writeAll(", ...");
try s.writeAll(", {\n");
const old_indent = w.indent;
@@ -410,8 +410,8 @@ const Writer = struct {
fn writeAggregateInit(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
const mod = w.module;
- const ty_pl = w.air.instructions.items(.data)[inst].ty_pl;
- const vector_ty = w.air.getRefType(ty_pl.ty);
+ const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
+ const vector_ty = ty_pl.ty.toType();
const len = @as(usize, @intCast(vector_ty.arrayLen(mod)));
const elements = @as([]const Air.Inst.Ref, @ptrCast(w.air.extra[ty_pl.payload..][0..len]));
@@ -425,7 +425,7 @@ const Writer = struct {
}
fn writeUnionInit(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
- const ty_pl = w.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = w.air.extraData(Air.UnionInit, ty_pl.payload).data;
try s.print("{d}, ", .{extra.field_index});
@@ -433,7 +433,7 @@ const Writer = struct {
}
fn writeStructField(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
- const ty_pl = w.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = w.air.extraData(Air.StructField, ty_pl.payload).data;
try w.writeOperand(s, inst, 0, extra.struct_operand);
@@ -442,10 +442,10 @@ const Writer = struct {
fn writeTyPlBin(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
const data = w.air.instructions.items(.data);
- const ty_pl = data[inst].ty_pl;
+ const ty_pl = data[@intFromEnum(inst)].ty_pl;
const extra = w.air.extraData(Air.Bin, ty_pl.payload).data;
- const inst_ty = w.air.getRefType(data[inst].ty_pl.ty);
+ const inst_ty = data[@intFromEnum(inst)].ty_pl.ty.toType();
try w.writeType(s, inst_ty);
try s.writeAll(", ");
try w.writeOperand(s, inst, 0, extra.lhs);
@@ -454,7 +454,7 @@ const Writer = struct {
}
fn writeCmpxchg(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
- const ty_pl = w.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = w.air.extraData(Air.Cmpxchg, ty_pl.payload).data;
try w.writeOperand(s, inst, 0, extra.ptr);
@@ -468,7 +468,7 @@ const Writer = struct {
}
fn writeMulAdd(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
- const pl_op = w.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const extra = w.air.extraData(Air.Bin, pl_op.payload).data;
try w.writeOperand(s, inst, 0, extra.lhs);
@@ -479,7 +479,7 @@ const Writer = struct {
}
fn writeShuffle(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
- const ty_pl = w.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = w.air.extraData(Air.Shuffle, ty_pl.payload).data;
try w.writeOperand(s, inst, 0, extra.a);
@@ -490,7 +490,7 @@ const Writer = struct {
fn writeSelect(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
const mod = w.module;
- const pl_op = w.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const extra = w.air.extraData(Air.Bin, pl_op.payload).data;
const elem_ty = w.typeOfIndex(inst).childType(mod);
@@ -504,14 +504,14 @@ const Writer = struct {
}
fn writeReduce(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
- const reduce = w.air.instructions.items(.data)[inst].reduce;
+ const reduce = w.air.instructions.items(.data)[@intFromEnum(inst)].reduce;
try w.writeOperand(s, inst, 0, reduce.operand);
try s.print(", {s}", .{@tagName(reduce.operation)});
}
fn writeCmpVector(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
- const ty_pl = w.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = w.air.extraData(Air.VectorCmp, ty_pl.payload).data;
try s.print("{s}, ", .{@tagName(extra.compareOperator())});
@@ -521,7 +521,7 @@ const Writer = struct {
}
fn writeVectorStoreElem(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
- const data = w.air.instructions.items(.data)[inst].vector_store_elem;
+ const data = w.air.instructions.items(.data)[@intFromEnum(inst)].vector_store_elem;
const extra = w.air.extraData(Air.VectorCmp, data.payload).data;
try w.writeOperand(s, inst, 0, data.vector_ptr);
@@ -532,20 +532,20 @@ const Writer = struct {
}
fn writeFence(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
- const atomic_order = w.air.instructions.items(.data)[inst].fence;
+ const atomic_order = w.air.instructions.items(.data)[@intFromEnum(inst)].fence;
try s.print("{s}", .{@tagName(atomic_order)});
}
fn writeAtomicLoad(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
- const atomic_load = w.air.instructions.items(.data)[inst].atomic_load;
+ const atomic_load = w.air.instructions.items(.data)[@intFromEnum(inst)].atomic_load;
try w.writeOperand(s, inst, 0, atomic_load.ptr);
try s.print(", {s}", .{@tagName(atomic_load.order)});
}
fn writePrefetch(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
- const prefetch = w.air.instructions.items(.data)[inst].prefetch;
+ const prefetch = w.air.instructions.items(.data)[@intFromEnum(inst)].prefetch;
try w.writeOperand(s, inst, 0, prefetch.ptr);
try s.print(", {s}, {d}, {s}", .{
@@ -559,7 +559,7 @@ const Writer = struct {
inst: Air.Inst.Index,
order: std.builtin.AtomicOrder,
) @TypeOf(s).Error!void {
- const bin_op = w.air.instructions.items(.data)[inst].bin_op;
+ const bin_op = w.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
try w.writeOperand(s, inst, 0, bin_op.lhs);
try s.writeAll(", ");
try w.writeOperand(s, inst, 1, bin_op.rhs);
@@ -567,7 +567,7 @@ const Writer = struct {
}
fn writeAtomicRmw(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
- const pl_op = w.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const extra = w.air.extraData(Air.AtomicRmw, pl_op.payload).data;
try w.writeOperand(s, inst, 0, pl_op.operand);
@@ -577,7 +577,7 @@ const Writer = struct {
}
fn writeFieldParentPtr(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
- const ty_pl = w.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = w.air.extraData(Air.FieldParentPtr, ty_pl.payload).data;
try w.writeOperand(s, inst, 0, extra.field_ptr);
@@ -585,7 +585,7 @@ const Writer = struct {
}
fn writeAssembly(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
- const ty_pl = w.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = w.air.extraData(Air.Asm, ty_pl.payload);
const is_volatile = @as(u1, @truncate(extra.data.flags >> 31)) != 0;
const clobbers_len = @as(u31, @truncate(extra.data.flags));
@@ -658,26 +658,26 @@ const Writer = struct {
}
fn writeDbgStmt(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
- const dbg_stmt = w.air.instructions.items(.data)[inst].dbg_stmt;
+ const dbg_stmt = w.air.instructions.items(.data)[@intFromEnum(inst)].dbg_stmt;
try s.print("{d}:{d}", .{ dbg_stmt.line + 1, dbg_stmt.column + 1 });
}
fn writeDbgInline(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
- const ty_fn = w.air.instructions.items(.data)[inst].ty_fn;
+ const ty_fn = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_fn;
const func_index = ty_fn.func;
const owner_decl = w.module.funcOwnerDeclPtr(func_index);
try s.print("{}", .{owner_decl.name.fmt(&w.module.intern_pool)});
}
fn writeDbgVar(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
- const pl_op = w.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
try w.writeOperand(s, inst, 0, pl_op.operand);
const name = w.air.nullTerminatedString(pl_op.payload);
try s.print(", \"{}\"", .{std.zig.fmtEscapes(name)});
}
fn writeCall(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
- const pl_op = w.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const extra = w.air.extraData(Air.Call, pl_op.payload);
const args = @as([]const Air.Inst.Ref, @ptrCast(w.air.extra[extra.end..][0..extra.data.args_len]));
try w.writeOperand(s, inst, 0, pl_op.operand);
@@ -690,16 +690,16 @@ const Writer = struct {
}
fn writeBr(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
- const br = w.air.instructions.items(.data)[inst].br;
+ const br = w.air.instructions.items(.data)[@intFromEnum(inst)].br;
try w.writeInstIndex(s, br.block_inst, false);
try s.writeAll(", ");
try w.writeOperand(s, inst, 0, br.operand);
}
fn writeTry(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
- const pl_op = w.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const extra = w.air.extraData(Air.Try, pl_op.payload);
- const body = w.air.extra[extra.end..][0..extra.data.body_len];
+ const body: []const Air.Inst.Index = @ptrCast(w.air.extra[extra.end..][0..extra.data.body_len]);
const liveness_condbr = if (w.liveness) |liveness|
liveness.getCondBr(inst)
else
@@ -731,9 +731,9 @@ const Writer = struct {
}
fn writeTryPtr(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
- const ty_pl = w.air.instructions.items(.data)[inst].ty_pl;
+ const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
const extra = w.air.extraData(Air.TryPtr, ty_pl.payload);
- const body = w.air.extra[extra.end..][0..extra.data.body_len];
+ const body: []const Air.Inst.Index = @ptrCast(w.air.extra[extra.end..][0..extra.data.body_len]);
const liveness_condbr = if (w.liveness) |liveness|
liveness.getCondBr(inst)
else
@@ -742,7 +742,7 @@ const Writer = struct {
try w.writeOperand(s, inst, 0, extra.data.ptr);
try s.writeAll(", ");
- try w.writeType(s, w.air.getRefType(ty_pl.ty));
+ try w.writeType(s, ty_pl.ty.toType());
if (w.skip_body) return s.writeAll(", ...");
try s.writeAll(", {\n");
const old_indent = w.indent;
@@ -768,10 +768,10 @@ const Writer = struct {
}
fn writeCondBr(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
- const pl_op = w.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const extra = w.air.extraData(Air.CondBr, pl_op.payload);
- const then_body = w.air.extra[extra.end..][0..extra.data.then_body_len];
- const else_body = w.air.extra[extra.end + then_body.len ..][0..extra.data.else_body_len];
+ const then_body: []const Air.Inst.Index = @ptrCast(w.air.extra[extra.end..][0..extra.data.then_body_len]);
+ const else_body: []const Air.Inst.Index = @ptrCast(w.air.extra[extra.end + then_body.len ..][0..extra.data.else_body_len]);
const liveness_condbr = if (w.liveness) |liveness|
liveness.getCondBr(inst)
else
@@ -813,7 +813,7 @@ const Writer = struct {
}
fn writeSwitchBr(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
- const pl_op = w.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
const switch_br = w.air.extraData(Air.SwitchBr, pl_op.payload);
const liveness = if (w.liveness) |liveness|
liveness.getSwitchBr(w.gpa, inst, switch_br.data.cases_len + 1) catch
@@ -836,7 +836,7 @@ const Writer = struct {
while (case_i < switch_br.data.cases_len) : (case_i += 1) {
const case = w.air.extraData(Air.SwitchBr.Case, extra_index);
const items = @as([]const Air.Inst.Ref, @ptrCast(w.air.extra[case.end..][0..case.data.items_len]));
- const case_body = w.air.extra[case.end + items.len ..][0..case.data.body_len];
+ const case_body: []const Air.Inst.Index = @ptrCast(w.air.extra[case.end + items.len ..][0..case.data.body_len]);
extra_index = case.end + case.data.items_len + case_body.len;
try s.writeAll(", [");
@@ -863,7 +863,7 @@ const Writer = struct {
try s.writeAll("}");
}
- const else_body = w.air.extra[extra_index..][0..switch_br.data.else_body_len];
+ const else_body: []const Air.Inst.Index = @ptrCast(w.air.extra[extra_index..][0..switch_br.data.else_body_len]);
if (else_body.len != 0) {
try s.writeAll(", else => {\n");
w.indent += 2;
@@ -889,18 +889,18 @@ const Writer = struct {
}
fn writeWasmMemorySize(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
- const pl_op = w.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
try s.print("{d}", .{pl_op.payload});
}
fn writeWasmMemoryGrow(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
- const pl_op = w.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
try s.print("{d}, ", .{pl_op.payload});
try w.writeOperand(s, inst, 0, pl_op.operand);
}
fn writeWorkDimension(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
- const pl_op = w.air.instructions.items(.data)[inst].pl_op;
+ const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
try s.print("{d}", .{pl_op.payload});
}
@@ -938,7 +938,7 @@ const Writer = struct {
) @TypeOf(s).Error!void {
if (@intFromEnum(operand) < InternPool.static_len) {
return s.print("@{}", .{operand});
- } else if (Air.refToInterned(operand)) |ip_index| {
+ } else if (operand.toInterned()) |ip_index| {
const mod = w.module;
const ty = Type.fromInterned(mod.intern_pool.indexToKey(ip_index).typeOf());
try s.print("<{}, {}>", .{
@@ -946,7 +946,7 @@ const Writer = struct {
Value.fromInterned(ip_index).fmtValue(ty, mod),
});
} else {
- return w.writeInstIndex(s, Air.refToIndex(operand).?, dies);
+ return w.writeInstIndex(s, operand.toIndex().?, dies);
}
}
src/Sema.zig
@@ -741,7 +741,7 @@ pub const Block = struct {
}
pub fn addInst(block: *Block, inst: Air.Inst) error{OutOfMemory}!Air.Inst.Ref {
- return Air.indexToRef(try block.addInstAsIndex(inst));
+ return (try block.addInstAsIndex(inst)).toRef();
}
pub fn addInstAsIndex(block: *Block, inst: Air.Inst) error{OutOfMemory}!Air.Inst.Index {
@@ -751,7 +751,7 @@ pub const Block = struct {
try sema.air_instructions.ensureUnusedCapacity(gpa, 1);
try block.instructions.ensureUnusedCapacity(gpa, 1);
- const result_index: Air.Inst.Index = @intCast(sema.air_instructions.len);
+ const result_index: Air.Inst.Index = @enumFromInt(sema.air_instructions.len);
sema.air_instructions.appendAssumeCapacity(inst);
block.instructions.appendAssumeCapacity(result_index);
return result_index;
@@ -760,7 +760,7 @@ pub const Block = struct {
/// Insert an instruction into the block at `index`. Moves all following
/// instructions forward in the block to make room. Operation is O(N).
pub fn insertInst(block: *Block, index: Air.Inst.Index, inst: Air.Inst) error{OutOfMemory}!Air.Inst.Ref {
- return Air.indexToRef(try block.insertInstAsIndex(index, inst));
+ return (try block.insertInstAsIndex(index, inst)).toRef();
}
pub fn insertInstAsIndex(block: *Block, index: Air.Inst.Index, inst: Air.Inst) error{OutOfMemory}!Air.Inst.Index {
@@ -769,10 +769,10 @@ pub const Block = struct {
try sema.air_instructions.ensureUnusedCapacity(gpa, 1);
- const result_index: Air.Inst.Index = @intCast(sema.air_instructions.len);
+ const result_index: Air.Inst.Index = @enumFromInt(sema.air_instructions.len);
sema.air_instructions.appendAssumeCapacity(inst);
- try block.instructions.insert(gpa, index, result_index);
+ try block.instructions.insert(gpa, @intFromEnum(index), result_index);
return result_index;
}
@@ -935,7 +935,7 @@ pub fn analyzeBodyBreak(
else => |e| return e,
};
if (block.instructions.items.len != 0 and
- sema.isNoReturn(Air.indexToRef(block.instructions.items[block.instructions.items.len - 1])))
+ sema.isNoReturn(block.instructions.items[block.instructions.items.len - 1].toRef()))
return null;
const break_data = sema.code.instructions.items(.data)[@intFromEnum(break_inst)].@"break";
const extra = sema.code.extraData(Zir.Inst.Break, break_data.payload_index).data;
@@ -1638,7 +1638,7 @@ fn analyzeBodyInner(
// Comptime control flow populates the map, so we don't actually know
// if this is a post-hoc runtime block until we check the
// post_hoc_block map.
- const new_block_inst = Air.refToIndex(new_block_ref) orelse break :ph;
+ const new_block_inst = new_block_ref.toIndex() orelse break :ph;
const labeled_block = sema.post_hoc_blocks.get(new_block_inst) orelse
break :ph;
@@ -1817,7 +1817,7 @@ fn analyzeBodyInner(
if (sema.isNoReturn(air_inst)) {
// We're going to assume that the body itself is noreturn, so let's ensure that now
assert(block.instructions.items.len > 0);
- assert(sema.isNoReturn(Air.indexToRef(block.instructions.items[block.instructions.items.len - 1])));
+ assert(sema.isNoReturn(block.instructions.items[block.instructions.items.len - 1].toRef()));
break always_noreturn;
}
map.putAssumeCapacity(inst, air_inst);
@@ -2003,7 +2003,7 @@ fn genericPoisonReason(sema: *Sema, ref: Zir.Inst.Ref) GenericPoisonReason {
const operand_ref = sema.resolveInst(un_node.operand) catch |err| switch (err) {
error.GenericPoison => unreachable, // this is a type, not a value
};
- const operand_val = Air.refToInterned(operand_ref) orelse return .unknown;
+ const operand_val = operand_ref.toInterned() orelse return .unknown;
if (operand_val == .generic_poison_type) {
// The pointer was generic poison - keep looking.
cur = un_node.operand;
@@ -2158,14 +2158,14 @@ fn resolveValueAllowVariables(sema: *Sema, inst: Air.Inst.Ref) CompileError!?Val
const air_tags = sema.air_instructions.items(.tag);
if (try sema.typeHasOnePossibleValue(sema.typeOf(inst))) |opv| {
- if (Air.refToInterned(inst)) |ip_index| {
+ if (inst.toInterned()) |ip_index| {
const val = Value.fromInterned(ip_index);
if (val.getVariable(sema.mod) != null) return val;
}
return opv;
}
- const ip_index = Air.refToInterned(inst) orelse {
- switch (air_tags[Air.refToIndex(inst).?]) {
+ const ip_index = inst.toInterned() orelse {
+ switch (air_tags[@intFromEnum(inst.toIndex().?)]) {
.inferred_alloc => unreachable,
.inferred_alloc_comptime => unreachable,
else => return null,
@@ -3543,7 +3543,7 @@ fn zirAllocExtended(
.is_const = small.is_const,
} },
});
- return Air.indexToRef(@intCast(sema.air_instructions.len - 1));
+ return @as(Air.Inst.Index, @enumFromInt(sema.air_instructions.len - 1)).toRef();
}
}
@@ -3562,7 +3562,7 @@ fn zirAllocExtended(
});
const ptr = try block.addTy(.alloc, ptr_type);
if (small.is_const) {
- const ptr_inst = Air.refToIndex(ptr).?;
+ const ptr_inst = ptr.toIndex().?;
try sema.maybe_comptime_allocs.put(gpa, ptr_inst, .{ .runtime_index = block.runtime_index });
try sema.base_allocs.put(gpa, ptr_inst, ptr_inst);
}
@@ -3581,7 +3581,7 @@ fn zirAllocExtended(
try sema.maybe_comptime_allocs.put(gpa, result_index, .{ .runtime_index = block.runtime_index });
try sema.base_allocs.put(gpa, result_index, result_index);
}
- return Air.indexToRef(result_index);
+ return result_index.toRef();
}
fn zirAllocComptime(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
@@ -3654,7 +3654,7 @@ fn resolveComptimeKnownAllocValue(sema: *Sema, block: *Block, alloc: Air.Inst.Re
const ptr_info = alloc_ty.ptrInfo(mod);
const elem_ty = Type.fromInterned(ptr_info.child);
- const alloc_inst = Air.refToIndex(alloc) orelse return null;
+ const alloc_inst = alloc.toIndex() orelse return null;
const comptime_info = sema.maybe_comptime_allocs.fetchRemove(alloc_inst) orelse return null;
const stores = comptime_info.value.stores.items;
@@ -3674,10 +3674,10 @@ fn resolveComptimeKnownAllocValue(sema: *Sema, block: *Block, alloc: Air.Inst.Re
simple: {
if (stores.len != 1) break :simple;
const store_inst = stores[0];
- const store_data = sema.air_instructions.items(.data)[store_inst].bin_op;
+ const store_data = sema.air_instructions.items(.data)[@intFromEnum(store_inst)].bin_op;
if (store_data.lhs != alloc) break :simple;
- const val = Air.refToInterned(store_data.rhs).?;
+ const val = store_data.rhs.toInterned().?;
assert(mod.intern_pool.typeOf(val) == elem_ty.toIntern());
return sema.finishResolveComptimeKnownAllocValue(val, alloc_inst, comptime_info.value);
}
@@ -3704,8 +3704,8 @@ fn resolveComptimeKnownAllocValue(sema: *Sema, block: *Block, alloc: Air.Inst.Re
var to_map = try std.ArrayList(Air.Inst.Index).initCapacity(sema.arena, stores.len);
for (stores) |store_inst| {
- const bin_op = sema.air_instructions.items(.data)[store_inst].bin_op;
- to_map.appendAssumeCapacity(Air.refToIndex(bin_op.lhs).?);
+ const bin_op = sema.air_instructions.items(.data)[@intFromEnum(store_inst)].bin_op;
+ to_map.appendAssumeCapacity(bin_op.lhs.toIndex().?);
}
const tmp_air = sema.getTmpAir();
@@ -3719,12 +3719,12 @@ fn resolveComptimeKnownAllocValue(sema: *Sema, block: *Block, alloc: Air.Inst.Re
field: u32,
elem: u64,
};
- const inst_tag = tmp_air.instructions.items(.tag)[air_ptr];
+ const inst_tag = tmp_air.instructions.items(.tag)[@intFromEnum(air_ptr)];
const air_parent_ptr: Air.Inst.Ref, const method: PointerMethod = switch (inst_tag) {
.struct_field_ptr => blk: {
const data = tmp_air.extraData(
Air.StructField,
- tmp_air.instructions.items(.data)[air_ptr].ty_pl.payload,
+ tmp_air.instructions.items(.data)[@intFromEnum(air_ptr)].ty_pl.payload,
).data;
break :blk .{
data.struct_operand,
@@ -3736,7 +3736,7 @@ fn resolveComptimeKnownAllocValue(sema: *Sema, block: *Block, alloc: Air.Inst.Re
.struct_field_ptr_index_2,
.struct_field_ptr_index_3,
=> .{
- tmp_air.instructions.items(.data)[air_ptr].ty_op.operand,
+ tmp_air.instructions.items(.data)[@intFromEnum(air_ptr)].ty_op.operand,
.{ .field = switch (inst_tag) {
.struct_field_ptr_index_0 => 0,
.struct_field_ptr_index_1 => 1,
@@ -3746,17 +3746,17 @@ fn resolveComptimeKnownAllocValue(sema: *Sema, block: *Block, alloc: Air.Inst.Re
} },
},
.ptr_slice_ptr_ptr => .{
- tmp_air.instructions.items(.data)[air_ptr].ty_op.operand,
+ tmp_air.instructions.items(.data)[@intFromEnum(air_ptr)].ty_op.operand,
.{ .field = Value.slice_ptr_index },
},
.ptr_slice_len_ptr => .{
- tmp_air.instructions.items(.data)[air_ptr].ty_op.operand,
+ tmp_air.instructions.items(.data)[@intFromEnum(air_ptr)].ty_op.operand,
.{ .field = Value.slice_len_index },
},
.ptr_elem_ptr => blk: {
const data = tmp_air.extraData(
Air.Bin,
- tmp_air.instructions.items(.data)[air_ptr].ty_pl.payload,
+ tmp_air.instructions.items(.data)[@intFromEnum(air_ptr)].ty_pl.payload,
).data;
const idx_val = (try sema.resolveValue(data.rhs)).?;
break :blk .{
@@ -3765,24 +3765,24 @@ fn resolveComptimeKnownAllocValue(sema: *Sema, block: *Block, alloc: Air.Inst.Re
};
},
.bitcast => .{
- tmp_air.instructions.items(.data)[air_ptr].ty_op.operand,
+ tmp_air.instructions.items(.data)[@intFromEnum(air_ptr)].ty_op.operand,
.same_addr,
},
.optional_payload_ptr_set => .{
- tmp_air.instructions.items(.data)[air_ptr].ty_op.operand,
+ tmp_air.instructions.items(.data)[@intFromEnum(air_ptr)].ty_op.operand,
.opt_payload,
},
.errunion_payload_ptr_set => .{
- tmp_air.instructions.items(.data)[air_ptr].ty_op.operand,
+ tmp_air.instructions.items(.data)[@intFromEnum(air_ptr)].ty_op.operand,
.eu_payload,
},
else => unreachable,
};
- const decl_parent_ptr = ptr_mapping.get(Air.refToIndex(air_parent_ptr).?) orelse {
+ const decl_parent_ptr = ptr_mapping.get(air_parent_ptr.toIndex().?) orelse {
// Resolve the parent pointer first.
// Note that we add in what seems like the wrong order, because we're popping from the end of this array.
- try to_map.appendSlice(&.{ air_ptr, Air.refToIndex(air_parent_ptr).? });
+ try to_map.appendSlice(&.{ air_ptr, air_parent_ptr.toIndex().? });
continue;
};
const new_ptr_ty = tmp_air.typeOfIndex(air_ptr, &mod.intern_pool).toIntern();
@@ -3811,12 +3811,12 @@ fn resolveComptimeKnownAllocValue(sema: *Sema, block: *Block, alloc: Air.Inst.Re
// We have a correlation between AIR pointers and decl pointers. Perform all stores at comptime.
for (stores) |store_inst| {
- switch (sema.air_instructions.items(.tag)[store_inst]) {
+ switch (sema.air_instructions.items(.tag)[@intFromEnum(store_inst)]) {
.set_union_tag => {
// If this tag has an OPV payload, there won't be a corresponding
// store instruction, so we must set the union payload now.
- const bin_op = sema.air_instructions.items(.data)[store_inst].bin_op;
- const air_ptr_inst = Air.refToIndex(bin_op.lhs).?;
+ const bin_op = sema.air_instructions.items(.data)[@intFromEnum(store_inst)].bin_op;
+ const air_ptr_inst = bin_op.lhs.toIndex().?;
const tag_val = (try sema.resolveValue(bin_op.rhs)).?;
const union_ty = sema.typeOf(bin_op.lhs).childType(mod);
const payload_ty = union_ty.unionFieldType(tag_val, mod).?;
@@ -3827,8 +3827,8 @@ fn resolveComptimeKnownAllocValue(sema: *Sema, block: *Block, alloc: Air.Inst.Re
}
},
.store, .store_safe => {
- const bin_op = sema.air_instructions.items(.data)[store_inst].bin_op;
- const air_ptr_inst = Air.refToIndex(bin_op.lhs).?;
+ const bin_op = sema.air_instructions.items(.data)[@intFromEnum(store_inst)].bin_op;
+ const air_ptr_inst = bin_op.lhs.toIndex().?;
const store_val = (try sema.resolveValue(bin_op.rhs)).?;
const new_ptr = ptr_mapping.get(air_ptr_inst).?;
try sema.storePtrVal(block, .unneeded, Value.fromInterned(new_ptr), store_val, Type.fromInterned(mod.intern_pool.typeOf(store_val.toIntern())));
@@ -3858,12 +3858,12 @@ fn finishResolveComptimeKnownAllocValue(sema: *Sema, result_val: InternPool.Inde
// Liveness to elide it.
const nop_inst: Air.Inst = .{ .tag = .bitcast, .data = .{ .ty_op = .{ .ty = .u8_type, .operand = .zero_u8 } } };
- sema.air_instructions.set(alloc_inst, nop_inst);
+ sema.air_instructions.set(@intFromEnum(alloc_inst), nop_inst);
for (comptime_info.stores.items) |store_inst| {
- sema.air_instructions.set(store_inst, nop_inst);
+ sema.air_instructions.set(@intFromEnum(store_inst), nop_inst);
}
for (comptime_info.non_elideable_pointers.items) |ptr_inst| {
- sema.air_instructions.set(ptr_inst, nop_inst);
+ sema.air_instructions.set(@intFromEnum(ptr_inst), nop_inst);
}
return result_val;
@@ -3905,7 +3905,7 @@ fn zirAllocInferredComptime(
.is_const = is_const,
} },
});
- return Air.indexToRef(@intCast(sema.air_instructions.len - 1));
+ return @as(Air.Inst.Index, @enumFromInt(sema.air_instructions.len - 1)).toRef();
}
fn zirAlloc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
@@ -3925,7 +3925,7 @@ fn zirAlloc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.I
});
try sema.queueFullTypeResolution(var_ty);
const ptr = try block.addTy(.alloc, ptr_type);
- const ptr_inst = Air.refToIndex(ptr).?;
+ const ptr_inst = ptr.toIndex().?;
try sema.maybe_comptime_allocs.put(sema.gpa, ptr_inst, .{ .runtime_index = block.runtime_index });
try sema.base_allocs.put(sema.gpa, ptr_inst, ptr_inst);
return ptr;
@@ -3974,7 +3974,7 @@ fn zirAllocInferred(
.is_const = is_const,
} },
});
- return Air.indexToRef(@intCast(sema.air_instructions.len - 1));
+ return @as(Air.Inst.Index, @enumFromInt(sema.air_instructions.len - 1)).toRef();
}
const result_index = try block.addInstAsIndex(.{
@@ -3987,7 +3987,7 @@ fn zirAllocInferred(
try sema.unresolved_inferred_allocs.putNoClobber(gpa, result_index, .{});
try sema.maybe_comptime_allocs.put(gpa, result_index, .{ .runtime_index = block.runtime_index });
try sema.base_allocs.put(sema.gpa, result_index, result_index);
- return Air.indexToRef(result_index);
+ return result_index.toRef();
}
fn zirResolveInferredAlloc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void {
@@ -4000,12 +4000,12 @@ fn zirResolveInferredAlloc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Com
const src = inst_data.src();
const ty_src: LazySrcLoc = .{ .node_offset_var_decl_ty = inst_data.src_node };
const ptr = try sema.resolveInst(inst_data.operand);
- const ptr_inst = Air.refToIndex(ptr).?;
+ const ptr_inst = ptr.toIndex().?;
const target = mod.getTarget();
- switch (sema.air_instructions.items(.tag)[ptr_inst]) {
+ switch (sema.air_instructions.items(.tag)[@intFromEnum(ptr_inst)]) {
.inferred_alloc_comptime => {
- const iac = sema.air_instructions.items(.data)[ptr_inst].inferred_alloc_comptime;
+ const iac = sema.air_instructions.items(.data)[@intFromEnum(ptr_inst)].inferred_alloc_comptime;
const decl_index = iac.decl_index;
const decl = mod.declPtr(decl_index);
@@ -4022,7 +4022,7 @@ fn zirResolveInferredAlloc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Com
if (std.debug.runtime_safety) {
// The inferred_alloc_comptime should never be referenced again
- sema.air_instructions.set(ptr_inst, .{ .tag = undefined, .data = undefined });
+ sema.air_instructions.set(@intFromEnum(ptr_inst), .{ .tag = undefined, .data = undefined });
}
try sema.maybeQueueFuncBodyAnalysis(decl_index);
@@ -4039,12 +4039,12 @@ fn zirResolveInferredAlloc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Com
sema.inst_map.putAssumeCapacity(inst_data.operand.toIndex().?, Air.internedToRef(interned));
},
.inferred_alloc => {
- const ia1 = sema.air_instructions.items(.data)[ptr_inst].inferred_alloc;
+ const ia1 = sema.air_instructions.items(.data)[@intFromEnum(ptr_inst)].inferred_alloc;
const ia2 = sema.unresolved_inferred_allocs.fetchRemove(ptr_inst).?.value;
const peer_vals = try sema.arena.alloc(Air.Inst.Ref, ia2.prongs.items.len);
for (peer_vals, ia2.prongs.items) |*peer_val, store_inst| {
- assert(sema.air_instructions.items(.tag)[store_inst] == .store);
- const bin_op = sema.air_instructions.items(.data)[store_inst].bin_op;
+ assert(sema.air_instructions.items(.tag)[@intFromEnum(store_inst)] == .store);
+ const bin_op = sema.air_instructions.items(.data)[@intFromEnum(store_inst)].bin_op;
peer_val.* = bin_op.rhs;
}
const final_elem_ty = try sema.resolvePeerTypes(block, ty_src, peer_vals, .none);
@@ -4083,7 +4083,7 @@ fn zirResolveInferredAlloc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Com
try sema.queueFullTypeResolution(final_elem_ty);
// Change it to a normal alloc.
- sema.air_instructions.set(ptr_inst, .{
+ sema.air_instructions.set(@intFromEnum(ptr_inst), .{
.tag = .alloc,
.data = .{ .ty = final_ptr_ty },
});
@@ -4095,15 +4095,15 @@ fn zirResolveInferredAlloc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Com
var replacement_block = block.makeSubBlock();
defer replacement_block.instructions.deinit(gpa);
- assert(sema.air_instructions.items(.tag)[placeholder_inst] == .store);
- const bin_op = sema.air_instructions.items(.data)[placeholder_inst].bin_op;
+ assert(sema.air_instructions.items(.tag)[@intFromEnum(placeholder_inst)] == .store);
+ const bin_op = sema.air_instructions.items(.data)[@intFromEnum(placeholder_inst)].bin_op;
try sema.storePtr2(&replacement_block, src, bin_op.lhs, src, bin_op.rhs, src, .store);
// If only one instruction is produced then we can replace the store
// placeholder instruction with this instruction; no need for an entire block.
if (replacement_block.instructions.items.len == 1) {
const only_inst = replacement_block.instructions.items[0];
- sema.air_instructions.set(placeholder_inst, sema.air_instructions.get(only_inst));
+ sema.air_instructions.set(@intFromEnum(placeholder_inst), sema.air_instructions.get(@intFromEnum(only_inst)));
continue;
}
@@ -4114,7 +4114,7 @@ fn zirResolveInferredAlloc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Com
gpa,
@typeInfo(Air.Block).Struct.fields.len + replacement_block.instructions.items.len,
);
- sema.air_instructions.set(placeholder_inst, .{
+ sema.air_instructions.set(@intFromEnum(placeholder_inst), .{
.tag = .block,
.data = .{ .ty_pl = .{
.ty = .void_type,
@@ -4123,7 +4123,7 @@ fn zirResolveInferredAlloc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Com
}),
} },
});
- sema.air_extra.appendSliceAssumeCapacity(replacement_block.instructions.items);
+ sema.air_extra.appendSliceAssumeCapacity(@ptrCast(replacement_block.instructions.items));
}
},
else => unreachable,
@@ -4584,18 +4584,18 @@ fn validateUnionInit(
var init_val: ?Value = null;
while (block_index > 0) : (block_index -= 1) {
const store_inst = block.instructions.items[block_index];
- if (Air.indexToRef(store_inst) == field_ptr_ref) break;
- switch (air_tags[store_inst]) {
+ if (store_inst.toRef() == field_ptr_ref) break;
+ switch (air_tags[@intFromEnum(store_inst)]) {
.store, .store_safe => {},
else => continue,
}
- const bin_op = air_datas[store_inst].bin_op;
+ const bin_op = air_datas[@intFromEnum(store_inst)].bin_op;
var ptr_ref = bin_op.lhs;
- if (Air.refToIndex(ptr_ref)) |ptr_inst| if (air_tags[ptr_inst] == .bitcast) {
- ptr_ref = air_datas[ptr_inst].ty_op.operand;
+ if (ptr_ref.toIndex()) |ptr_inst| if (air_tags[@intFromEnum(ptr_inst)] == .bitcast) {
+ ptr_ref = air_datas[@intFromEnum(ptr_inst)].ty_op.operand;
};
if (ptr_ref != field_ptr_ref) continue;
- first_block_index = @min(if (Air.refToIndex(field_ptr_ref)) |field_ptr_inst|
+ first_block_index = @min(if (field_ptr_ref.toIndex()) |field_ptr_inst|
std.mem.lastIndexOfScalar(
Air.Inst.Index,
block.instructions.items[0..block_index],
@@ -4615,18 +4615,18 @@ fn validateUnionInit(
// instead a single `store` to the result ptr with a comptime union value.
block_index = first_block_index;
for (block.instructions.items[first_block_index..]) |cur_inst| {
- switch (air_tags[cur_inst]) {
+ switch (air_tags[@intFromEnum(cur_inst)]) {
.struct_field_ptr,
.struct_field_ptr_index_0,
.struct_field_ptr_index_1,
.struct_field_ptr_index_2,
.struct_field_ptr_index_3,
- => if (Air.indexToRef(cur_inst) == field_ptr_ref) continue,
- .bitcast => if (air_datas[cur_inst].ty_op.operand == field_ptr_ref) continue,
+ => if (cur_inst.toRef() == field_ptr_ref) continue,
+ .bitcast => if (air_datas[@intFromEnum(cur_inst)].ty_op.operand == field_ptr_ref) continue,
.store, .store_safe => {
- var ptr_ref = air_datas[cur_inst].bin_op.lhs;
- if (Air.refToIndex(ptr_ref)) |ptr_inst| if (air_tags[ptr_inst] == .bitcast) {
- ptr_ref = air_datas[ptr_inst].ty_op.operand;
+ var ptr_ref = air_datas[@intFromEnum(cur_inst)].bin_op.lhs;
+ if (ptr_ref.toIndex()) |ptr_inst| if (air_tags[@intFromEnum(ptr_inst)] == .bitcast) {
+ ptr_ref = air_datas[@intFromEnum(ptr_inst)].ty_op.operand;
};
if (ptr_ref == field_ptr_ref) continue;
},
@@ -4807,21 +4807,21 @@ fn validateStructInit(
var block_index = block.instructions.items.len -| 1;
while (block_index > 0) : (block_index -= 1) {
const store_inst = block.instructions.items[block_index];
- if (Air.indexToRef(store_inst) == field_ptr_ref) {
+ if (store_inst.toRef() == field_ptr_ref) {
struct_is_comptime = false;
continue :field;
}
- switch (air_tags[store_inst]) {
+ switch (air_tags[@intFromEnum(store_inst)]) {
.store, .store_safe => {},
else => continue,
}
- const bin_op = air_datas[store_inst].bin_op;
+ const bin_op = air_datas[@intFromEnum(store_inst)].bin_op;
var ptr_ref = bin_op.lhs;
- if (Air.refToIndex(ptr_ref)) |ptr_inst| if (air_tags[ptr_inst] == .bitcast) {
- ptr_ref = air_datas[ptr_inst].ty_op.operand;
+ if (ptr_ref.toIndex()) |ptr_inst| if (air_tags[@intFromEnum(ptr_inst)] == .bitcast) {
+ ptr_ref = air_datas[@intFromEnum(ptr_inst)].ty_op.operand;
};
if (ptr_ref != field_ptr_ref) continue;
- first_block_index = @min(if (Air.refToIndex(field_ptr_ref)) |field_ptr_inst|
+ first_block_index = @min(if (field_ptr_ref.toIndex()) |field_ptr_inst|
std.mem.lastIndexOfScalar(
Air.Inst.Index,
block.instructions.items[0..block_index],
@@ -4895,18 +4895,18 @@ fn validateStructInit(
if (try field_ty.onePossibleValue(mod)) |_| continue;
field_ptr_ref = sema.inst_map.get(instrs[init_index]).?;
}
- switch (air_tags[cur_inst]) {
+ switch (air_tags[@intFromEnum(cur_inst)]) {
.struct_field_ptr,
.struct_field_ptr_index_0,
.struct_field_ptr_index_1,
.struct_field_ptr_index_2,
.struct_field_ptr_index_3,
- => if (Air.indexToRef(cur_inst) == field_ptr_ref) continue,
- .bitcast => if (air_datas[cur_inst].ty_op.operand == field_ptr_ref) continue,
+ => if (cur_inst.toRef() == field_ptr_ref) continue,
+ .bitcast => if (air_datas[@intFromEnum(cur_inst)].ty_op.operand == field_ptr_ref) continue,
.store, .store_safe => {
- var ptr_ref = air_datas[cur_inst].bin_op.lhs;
- if (Air.refToIndex(ptr_ref)) |ptr_inst| if (air_tags[ptr_inst] == .bitcast) {
- ptr_ref = air_datas[ptr_inst].ty_op.operand;
+ var ptr_ref = air_datas[@intFromEnum(cur_inst)].bin_op.lhs;
+ if (ptr_ref.toIndex()) |ptr_inst| if (air_tags[@intFromEnum(ptr_inst)] == .bitcast) {
+ ptr_ref = air_datas[@intFromEnum(ptr_inst)].ty_op.operand;
};
if (ptr_ref == field_ptr_ref) {
field_ptr_ref = .none;
@@ -5063,21 +5063,21 @@ fn zirValidatePtrArrayInit(
var block_index = block.instructions.items.len -| 1;
while (block_index > 0) : (block_index -= 1) {
const store_inst = block.instructions.items[block_index];
- if (Air.indexToRef(store_inst) == elem_ptr_ref) {
+ if (store_inst.toRef() == elem_ptr_ref) {
array_is_comptime = false;
continue :outer;
}
- switch (air_tags[store_inst]) {
+ switch (air_tags[@intFromEnum(store_inst)]) {
.store, .store_safe => {},
else => continue,
}
- const bin_op = air_datas[store_inst].bin_op;
+ const bin_op = air_datas[@intFromEnum(store_inst)].bin_op;
var ptr_ref = bin_op.lhs;
- if (Air.refToIndex(ptr_ref)) |ptr_inst| if (air_tags[ptr_inst] == .bitcast) {
- ptr_ref = air_datas[ptr_inst].ty_op.operand;
+ if (ptr_ref.toIndex()) |ptr_inst| if (air_tags[@intFromEnum(ptr_inst)] == .bitcast) {
+ ptr_ref = air_datas[@intFromEnum(ptr_inst)].ty_op.operand;
};
if (ptr_ref != elem_ptr_ref) continue;
- first_block_index = @min(if (Air.refToIndex(elem_ptr_ref)) |elem_ptr_inst|
+ first_block_index = @min(if (elem_ptr_ref.toIndex()) |elem_ptr_inst|
std.mem.lastIndexOfScalar(
Air.Inst.Index,
block.instructions.items[0..block_index],
@@ -5117,13 +5117,13 @@ fn zirValidatePtrArrayInit(
if (array_ty.isTuple(mod) and array_ty.structFieldIsComptime(elem_index, mod)) continue;
elem_ptr_ref = sema.inst_map.get(instrs[elem_index]).?;
}
- switch (air_tags[cur_inst]) {
- .ptr_elem_ptr => if (Air.indexToRef(cur_inst) == elem_ptr_ref) continue,
- .bitcast => if (air_datas[cur_inst].ty_op.operand == elem_ptr_ref) continue,
+ switch (air_tags[@intFromEnum(cur_inst)]) {
+ .ptr_elem_ptr => if (cur_inst.toRef() == elem_ptr_ref) continue,
+ .bitcast => if (air_datas[@intFromEnum(cur_inst)].ty_op.operand == elem_ptr_ref) continue,
.store, .store_safe => {
- var ptr_ref = air_datas[cur_inst].bin_op.lhs;
- if (Air.refToIndex(ptr_ref)) |ptr_inst| if (air_tags[ptr_inst] == .bitcast) {
- ptr_ref = air_datas[ptr_inst].ty_op.operand;
+ var ptr_ref = air_datas[@intFromEnum(cur_inst)].bin_op.lhs;
+ if (ptr_ref.toIndex()) |ptr_inst| if (air_tags[@intFromEnum(ptr_inst)] == .bitcast) {
+ ptr_ref = air_datas[@intFromEnum(ptr_inst)].ty_op.operand;
};
if (ptr_ref == elem_ptr_ref) {
elem_ptr_ref = .none;
@@ -5336,12 +5336,12 @@ fn zirStoreToInferredPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Compi
const bin_inst = sema.code.instructions.items(.data)[@intFromEnum(inst)].bin;
const ptr = try sema.resolveInst(bin_inst.lhs);
const operand = try sema.resolveInst(bin_inst.rhs);
- const ptr_inst = Air.refToIndex(ptr).?;
+ const ptr_inst = ptr.toIndex().?;
const air_datas = sema.air_instructions.items(.data);
- switch (sema.air_instructions.items(.tag)[ptr_inst]) {
+ switch (sema.air_instructions.items(.tag)[@intFromEnum(ptr_inst)]) {
.inferred_alloc_comptime => {
- const iac = &air_datas[ptr_inst].inferred_alloc_comptime;
+ const iac = &air_datas[@intFromEnum(ptr_inst)].inferred_alloc_comptime;
return sema.storeToInferredAllocComptime(block, src, operand, iac);
},
.inferred_alloc => {
@@ -5365,7 +5365,7 @@ fn storeToInferredAlloc(
try sema.checkComptimeKnownStore(block, dummy_store);
// Add the stored instruction to the set we will use to resolve peer types
// for the inferred allocation.
- try inferred_alloc.prongs.append(sema.arena, Air.refToIndex(dummy_store).?);
+ try inferred_alloc.prongs.append(sema.arena, dummy_store.toIndex().?);
}
fn storeToInferredAllocComptime(
@@ -5635,8 +5635,8 @@ fn zirLoop(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileError
// Reserve space for a Loop instruction so that generated Break instructions can
// point to it, even if it doesn't end up getting used because the code ends up being
// comptime evaluated.
- const block_inst: Air.Inst.Index = @intCast(sema.air_instructions.len);
- const loop_inst = block_inst + 1;
+ const block_inst: Air.Inst.Index = @enumFromInt(sema.air_instructions.len);
+ const loop_inst: Air.Inst.Index = @enumFromInt(@intFromEnum(block_inst) + 1);
try sema.air_instructions.ensureUnusedCapacity(gpa, 2);
sema.air_instructions.appendAssumeCapacity(.{
.tag = .block,
@@ -5674,7 +5674,7 @@ fn zirLoop(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileError
try sema.analyzeBody(&loop_block, body);
const loop_block_len = loop_block.instructions.items.len;
- if (loop_block_len > 0 and sema.typeOf(Air.indexToRef(loop_block.instructions.items[loop_block_len - 1])).isNoReturn(mod)) {
+ if (loop_block_len > 0 and sema.typeOf(loop_block.instructions.items[loop_block_len - 1].toRef()).isNoReturn(mod)) {
// If the loop ended with a noreturn terminator, then there is no way for it to loop,
// so we can just use the block instead.
try child_block.instructions.appendSlice(gpa, loop_block.instructions.items);
@@ -5682,10 +5682,10 @@ fn zirLoop(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileError
try child_block.instructions.append(gpa, loop_inst);
try sema.air_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.Block).Struct.fields.len + loop_block_len);
- sema.air_instructions.items(.data)[loop_inst].ty_pl.payload = sema.addExtraAssumeCapacity(
+ sema.air_instructions.items(.data)[@intFromEnum(loop_inst)].ty_pl.payload = sema.addExtraAssumeCapacity(
Air.Block{ .body_len = @intCast(loop_block_len) },
);
- sema.air_extra.appendSliceAssumeCapacity(loop_block.instructions.items);
+ sema.air_extra.appendSliceAssumeCapacity(@ptrCast(loop_block.instructions.items));
}
return sema.analyzeBlockBody(parent_block, src, &child_block, merges);
}
@@ -5793,7 +5793,7 @@ fn zirBlock(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index, force_compt
// Reserve space for a Block instruction so that generated Break instructions can
// point to it, even if it doesn't end up getting used because the code ends up being
// comptime evaluated or is an unlabeled block.
- const block_inst: Air.Inst.Index = @intCast(sema.air_instructions.len);
+ const block_inst: Air.Inst.Index = @enumFromInt(sema.air_instructions.len);
try sema.air_instructions.append(gpa, .{
.tag = .block,
.data = undefined,
@@ -5887,13 +5887,13 @@ fn analyzeBlockBody(
// Blocks must terminate with noreturn instruction.
assert(child_block.instructions.items.len != 0);
- assert(sema.typeOf(Air.indexToRef(child_block.instructions.items[child_block.instructions.items.len - 1])).isNoReturn(mod));
+ assert(sema.typeOf(child_block.instructions.items[child_block.instructions.items.len - 1].toRef()).isNoReturn(mod));
if (merges.results.items.len == 0) {
// No need for a block instruction. We can put the new instructions
// directly into the parent block.
try parent_block.instructions.appendSlice(gpa, child_block.instructions.items);
- return Air.indexToRef(child_block.instructions.items[child_block.instructions.items.len - 1]);
+ return child_block.instructions.items[child_block.instructions.items.len - 1].toRef();
}
if (merges.results.items.len == 1) {
const last_inst_index = child_block.instructions.items.len - 1;
@@ -5936,17 +5936,17 @@ fn analyzeBlockBody(
const ty_inst = Air.internedToRef(resolved_ty.toIntern());
try sema.air_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.Block).Struct.fields.len +
child_block.instructions.items.len);
- sema.air_instructions.items(.data)[merges.block_inst] = .{ .ty_pl = .{
+ sema.air_instructions.items(.data)[@intFromEnum(merges.block_inst)] = .{ .ty_pl = .{
.ty = ty_inst,
.payload = sema.addExtraAssumeCapacity(Air.Block{
.body_len = @intCast(child_block.instructions.items.len),
}),
} };
- sema.air_extra.appendSliceAssumeCapacity(child_block.instructions.items);
+ sema.air_extra.appendSliceAssumeCapacity(@ptrCast(child_block.instructions.items));
// Now that the block has its type resolved, we need to go back into all the break
// instructions, and insert type coercion on the operands.
for (merges.br_list.items) |br| {
- const br_operand = sema.air_instructions.items(.data)[br].br.operand;
+ const br_operand = sema.air_instructions.items(.data)[@intFromEnum(br)].br.operand;
const br_operand_src = src;
const br_operand_ty = sema.typeOf(br_operand);
if (br_operand_ty.eql(resolved_ty, mod)) {
@@ -5959,10 +5959,10 @@ fn analyzeBlockBody(
// If no instructions were produced, such as in the case of a coercion of a
// constant value to a new type, we can simply point the br operand to it.
if (coerce_block.instructions.items.len == 0) {
- sema.air_instructions.items(.data)[br].br.operand = coerced_operand;
+ sema.air_instructions.items(.data)[@intFromEnum(br)].br.operand = coerced_operand;
continue;
}
- assert(Air.indexToRef(coerce_block.instructions.items[coerce_block.instructions.items.len - 1]) == coerced_operand);
+ assert(coerce_block.instructions.items[coerce_block.instructions.items.len - 1].toRef() == coerced_operand);
// Convert the br instruction to a block instruction that has the coercion
// and then a new br inside that returns the coerced instruction.
@@ -5970,17 +5970,17 @@ fn analyzeBlockBody(
try sema.air_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.Block).Struct.fields.len +
sub_block_len);
try sema.air_instructions.ensureUnusedCapacity(gpa, 1);
- const sub_br_inst: Air.Inst.Index = @intCast(sema.air_instructions.len);
+ const sub_br_inst: Air.Inst.Index = @enumFromInt(sema.air_instructions.len);
- sema.air_instructions.items(.tag)[br] = .block;
- sema.air_instructions.items(.data)[br] = .{ .ty_pl = .{
+ sema.air_instructions.items(.tag)[@intFromEnum(br)] = .block;
+ sema.air_instructions.items(.data)[@intFromEnum(br)] = .{ .ty_pl = .{
.ty = .noreturn_type,
.payload = sema.addExtraAssumeCapacity(Air.Block{
.body_len = sub_block_len,
}),
} };
- sema.air_extra.appendSliceAssumeCapacity(coerce_block.instructions.items);
- sema.air_extra.appendAssumeCapacity(sub_br_inst);
+ sema.air_extra.appendSliceAssumeCapacity(@ptrCast(coerce_block.instructions.items));
+ sema.air_extra.appendAssumeCapacity(@intFromEnum(sub_br_inst));
sema.air_instructions.appendAssumeCapacity(.{
.tag = .br,
@@ -5990,7 +5990,7 @@ fn analyzeBlockBody(
} },
});
}
- return Air.indexToRef(merges.block_inst);
+ return merges.block_inst.toRef();
}
fn zirExport(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void {
@@ -6249,7 +6249,7 @@ fn zirBreak(sema: *Sema, start_block: *Block, inst: Zir.Inst.Index) CompileError
null;
try label.merges.src_locs.append(sema.gpa, src_loc);
try label.merges.results.append(sema.gpa, operand);
- try label.merges.br_list.append(sema.gpa, Air.refToIndex(br_ref).?);
+ try label.merges.br_list.append(sema.gpa, br_ref.toIndex().?);
block.runtime_index.increment();
if (block.runtime_cond == null and block.runtime_loop == null) {
block.runtime_cond = start_block.runtime_cond orelse start_block.runtime_loop;
@@ -6273,9 +6273,9 @@ fn zirDbgStmt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!voi
if (block.instructions.items.len != 0) {
const idx = block.instructions.items[block.instructions.items.len - 1];
- if (sema.air_instructions.items(.tag)[idx] == .dbg_stmt) {
+ if (sema.air_instructions.items(.tag)[@intFromEnum(idx)] == .dbg_stmt) {
// The previous dbg_stmt didn't correspond to any actual code, so replace it.
- sema.air_instructions.items(.data)[idx].dbg_stmt = .{
+ sema.air_instructions.items(.data)[@intFromEnum(idx)].dbg_stmt = .{
.line = inst_data.line,
.column = inst_data.column,
};
@@ -6609,7 +6609,7 @@ fn popErrorReturnTrace(
then_block.instructions.items.len + else_block.instructions.items.len +
@typeInfo(Air.Block).Struct.fields.len + 1); // +1 for the sole .cond_br instruction in the .block
- const cond_br_inst: Air.Inst.Index = @intCast(sema.air_instructions.len);
+ const cond_br_inst: Air.Inst.Index = @enumFromInt(sema.air_instructions.len);
try sema.air_instructions.append(gpa, .{ .tag = .cond_br, .data = .{ .pl_op = .{
.operand = is_non_error_inst,
.payload = sema.addExtraAssumeCapacity(Air.CondBr{
@@ -6617,11 +6617,11 @@ fn popErrorReturnTrace(
.else_body_len = @intCast(else_block.instructions.items.len),
}),
} } });
- sema.air_extra.appendSliceAssumeCapacity(then_block.instructions.items);
- sema.air_extra.appendSliceAssumeCapacity(else_block.instructions.items);
+ sema.air_extra.appendSliceAssumeCapacity(@ptrCast(then_block.instructions.items));
+ sema.air_extra.appendSliceAssumeCapacity(@ptrCast(else_block.instructions.items));
- sema.air_instructions.items(.data)[cond_block_inst].ty_pl.payload = sema.addExtraAssumeCapacity(Air.Block{ .body_len = 1 });
- sema.air_extra.appendAssumeCapacity(cond_br_inst);
+ sema.air_instructions.items(.data)[@intFromEnum(cond_block_inst)].ty_pl.payload = sema.addExtraAssumeCapacity(Air.Block{ .body_len = 1 });
+ sema.air_extra.appendAssumeCapacity(@intFromEnum(cond_br_inst));
}
}
@@ -6668,7 +6668,7 @@ fn zirCall(
const func_ty = try sema.checkCallArgumentCount(block, func, callee_src, callee_ty, total_args, callee == .method);
// The block index before the call, so we can potentially insert an error trace save here later.
- const block_index: Air.Inst.Index = @intCast(block.instructions.items.len);
+ const block_index: Air.Inst.Index = @enumFromInt(block.instructions.items.len);
// This will be set by `analyzeCall` to indicate whether any parameter was an error (making the
// error trace potentially dirty).
@@ -7283,7 +7283,7 @@ fn analyzeCall(
// set to in the `Block`.
// This block instruction will be used to capture the return value from the
// inlined function.
- const block_inst: Air.Inst.Index = @intCast(sema.air_instructions.len);
+ const block_inst: Air.Inst.Index = @enumFromInt(sema.air_instructions.len);
try sema.air_instructions.append(gpa, .{
.tag = .block,
.data = undefined,
@@ -9737,12 +9737,12 @@ fn zirParam(
sema.inst_map.putAssumeCapacityNoClobber(inst, .generic_poison);
} else {
// Otherwise we need a dummy runtime instruction.
- const result_index: Air.Inst.Index = @intCast(sema.air_instructions.len);
+ const result_index: Air.Inst.Index = @enumFromInt(sema.air_instructions.len);
try sema.air_instructions.append(sema.gpa, .{
.tag = .alloc,
.data = .{ .ty = param_ty },
});
- sema.inst_map.putAssumeCapacityNoClobber(inst, Air.indexToRef(result_index));
+ sema.inst_map.putAssumeCapacityNoClobber(inst, result_index.toRef());
}
}
@@ -10991,7 +10991,7 @@ const SwitchProngAnalysis = struct {
cases_extra.appendAssumeCapacity(1); // items_len
cases_extra.appendAssumeCapacity(@intCast(coerce_block.instructions.items.len)); // body_len
cases_extra.appendAssumeCapacity(@intFromEnum(case_vals[idx])); // item
- cases_extra.appendSliceAssumeCapacity(coerce_block.instructions.items); // body
+ cases_extra.appendSliceAssumeCapacity(@ptrCast(coerce_block.instructions.items)); // body
}
}
const else_body_len = len: {
@@ -11006,7 +11006,7 @@ const SwitchProngAnalysis = struct {
const coerced = try coerce_block.addBitCast(capture_ty, uncoerced);
_ = try coerce_block.addBr(capture_block_inst, coerced);
- try cases_extra.appendSlice(coerce_block.instructions.items);
+ try cases_extra.appendSlice(@ptrCast(coerce_block.instructions.items));
break :len coerce_block.instructions.items.len;
};
@@ -11029,12 +11029,12 @@ const SwitchProngAnalysis = struct {
sema.air_extra.appendSliceAssumeCapacity(cases_extra.items);
// Set up block body
- sema.air_instructions.items(.data)[capture_block_inst].ty_pl.payload = sema.addExtraAssumeCapacity(Air.Block{
+ sema.air_instructions.items(.data)[@intFromEnum(capture_block_inst)].ty_pl.payload = sema.addExtraAssumeCapacity(Air.Block{
.body_len = 1,
});
sema.air_extra.appendAssumeCapacity(switch_br_inst);
- return Air.indexToRef(capture_block_inst);
+ return capture_block_inst.toRef();
},
.ErrorSet => {
if (capture_byref) {
@@ -11780,7 +11780,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r
.tag_capture_inst = tag_capture_inst,
};
- const block_inst: Air.Inst.Index = @intCast(sema.air_instructions.len);
+ const block_inst: Air.Inst.Index = @enumFromInt(sema.air_instructions.len);
try sema.air_instructions.append(gpa, .{
.tag = .block,
.data = undefined,
@@ -12023,7 +12023,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r
cases_extra.appendAssumeCapacity(1); // items_len
cases_extra.appendAssumeCapacity(@intCast(case_block.instructions.items.len));
cases_extra.appendAssumeCapacity(@intFromEnum(item));
- cases_extra.appendSliceAssumeCapacity(case_block.instructions.items);
+ cases_extra.appendSliceAssumeCapacity(@ptrCast(case_block.instructions.items));
}
var is_first = true;
@@ -12110,7 +12110,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r
cases_extra.appendAssumeCapacity(1); // items_len
cases_extra.appendAssumeCapacity(@intCast(case_block.instructions.items.len));
cases_extra.appendAssumeCapacity(@intFromEnum(item_ref));
- cases_extra.appendSliceAssumeCapacity(case_block.instructions.items);
+ cases_extra.appendSliceAssumeCapacity(@ptrCast(case_block.instructions.items));
if (item.compareScalar(.eq, item_last, operand_ty, mod)) break;
}
@@ -12160,7 +12160,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r
cases_extra.appendAssumeCapacity(1); // items_len
cases_extra.appendAssumeCapacity(@intCast(case_block.instructions.items.len));
cases_extra.appendAssumeCapacity(@intFromEnum(item));
- cases_extra.appendSliceAssumeCapacity(case_block.instructions.items);
+ cases_extra.appendSliceAssumeCapacity(@ptrCast(case_block.instructions.items));
}
extra_index += info.body_len;
@@ -12213,7 +12213,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r
cases_extra.appendAssumeCapacity(@intFromEnum(item));
}
- cases_extra.appendSliceAssumeCapacity(case_block.instructions.items);
+ cases_extra.appendSliceAssumeCapacity(@ptrCast(case_block.instructions.items));
} else {
for (items) |item| {
const cmp_ok = try case_block.addBinOp(if (case_block.float_mode == .Optimized) .cmp_eq_optimized else .cmp_eq, operand, item);
@@ -12295,13 +12295,13 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r
@typeInfo(Air.CondBr).Struct.fields.len + prev_then_body.len + cond_body.len,
);
- sema.air_instructions.items(.data)[prev_cond_br].pl_op.payload =
+ sema.air_instructions.items(.data)[@intFromEnum(prev_cond_br)].pl_op.payload =
sema.addExtraAssumeCapacity(Air.CondBr{
.then_body_len = @intCast(prev_then_body.len),
.else_body_len = @intCast(cond_body.len),
});
- sema.air_extra.appendSliceAssumeCapacity(prev_then_body);
- sema.air_extra.appendSliceAssumeCapacity(cond_body);
+ sema.air_extra.appendSliceAssumeCapacity(@ptrCast(prev_then_body));
+ sema.air_extra.appendSliceAssumeCapacity(@ptrCast(cond_body));
}
gpa.free(prev_then_body);
prev_then_body = try case_block.instructions.toOwnedSlice(gpa);
@@ -12356,7 +12356,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r
cases_extra.appendAssumeCapacity(1); // items_len
cases_extra.appendAssumeCapacity(@intCast(case_block.instructions.items.len));
cases_extra.appendAssumeCapacity(@intFromEnum(item_ref));
- cases_extra.appendSliceAssumeCapacity(case_block.instructions.items);
+ cases_extra.appendSliceAssumeCapacity(@ptrCast(case_block.instructions.items));
}
},
.ErrorSet => {
@@ -12397,7 +12397,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r
cases_extra.appendAssumeCapacity(1); // items_len
cases_extra.appendAssumeCapacity(@intCast(case_block.instructions.items.len));
cases_extra.appendAssumeCapacity(@intFromEnum(item_ref));
- cases_extra.appendSliceAssumeCapacity(case_block.instructions.items);
+ cases_extra.appendSliceAssumeCapacity(@ptrCast(case_block.instructions.items));
}
},
.Int => {
@@ -12428,7 +12428,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r
cases_extra.appendAssumeCapacity(1); // items_len
cases_extra.appendAssumeCapacity(@intCast(case_block.instructions.items.len));
cases_extra.appendAssumeCapacity(@intFromEnum(item_ref));
- cases_extra.appendSliceAssumeCapacity(case_block.instructions.items);
+ cases_extra.appendSliceAssumeCapacity(@ptrCast(case_block.instructions.items));
}
},
.Bool => {
@@ -12456,7 +12456,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r
cases_extra.appendAssumeCapacity(1); // items_len
cases_extra.appendAssumeCapacity(@intCast(case_block.instructions.items.len));
cases_extra.appendAssumeCapacity(@intFromEnum(Air.Inst.Ref.bool_true));
- cases_extra.appendSliceAssumeCapacity(case_block.instructions.items);
+ cases_extra.appendSliceAssumeCapacity(@ptrCast(case_block.instructions.items));
}
if (false_count == 0) {
cases_len += 1;
@@ -12482,7 +12482,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r
cases_extra.appendAssumeCapacity(1); // items_len
cases_extra.appendAssumeCapacity(@intCast(case_block.instructions.items.len));
cases_extra.appendAssumeCapacity(@intFromEnum(Air.Inst.Ref.bool_false));
- cases_extra.appendSliceAssumeCapacity(case_block.instructions.items);
+ cases_extra.appendSliceAssumeCapacity(@ptrCast(case_block.instructions.items));
}
},
else => return sema.fail(block, special_prong_src, "cannot enumerate values of type '{}' for 'inline else'", .{
@@ -12544,13 +12544,13 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r
try sema.air_extra.ensureUnusedCapacity(gpa, prev_then_body.len +
@typeInfo(Air.CondBr).Struct.fields.len + case_block.instructions.items.len);
- sema.air_instructions.items(.data)[prev_cond_br].pl_op.payload =
+ sema.air_instructions.items(.data)[@intFromEnum(prev_cond_br)].pl_op.payload =
sema.addExtraAssumeCapacity(Air.CondBr{
.then_body_len = @intCast(prev_then_body.len),
.else_body_len = @intCast(case_block.instructions.items.len),
});
- sema.air_extra.appendSliceAssumeCapacity(prev_then_body);
- sema.air_extra.appendSliceAssumeCapacity(case_block.instructions.items);
+ sema.air_extra.appendSliceAssumeCapacity(@ptrCast(prev_then_body));
+ sema.air_extra.appendSliceAssumeCapacity(@ptrCast(case_block.instructions.items));
final_else_body = first_else_body;
}
}
@@ -12565,8 +12565,8 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r
.else_body_len = @intCast(final_else_body.len),
}),
} } });
- sema.air_extra.appendSliceAssumeCapacity(cases_extra.items);
- sema.air_extra.appendSliceAssumeCapacity(final_else_body);
+ sema.air_extra.appendSliceAssumeCapacity(@ptrCast(cases_extra.items));
+ sema.air_extra.appendSliceAssumeCapacity(@ptrCast(final_else_body));
return sema.analyzeBlockBody(block, src, &child_block, merges);
}
@@ -18140,7 +18140,7 @@ fn zirBoolBr(
return sema.resolveBody(parent_block, body, inst);
}
- const block_inst: Air.Inst.Index = @intCast(sema.air_instructions.len);
+ const block_inst: Air.Inst.Index = @enumFromInt(sema.air_instructions.len);
try sema.air_instructions.append(gpa, .{
.tag = .block,
.data = .{ .ty_pl = .{
@@ -18205,21 +18205,21 @@ fn finishCondBr(
.then_body_len = @intCast(then_block.instructions.items.len),
.else_body_len = @intCast(else_block.instructions.items.len),
});
- sema.air_extra.appendSliceAssumeCapacity(then_block.instructions.items);
- sema.air_extra.appendSliceAssumeCapacity(else_block.instructions.items);
+ sema.air_extra.appendSliceAssumeCapacity(@ptrCast(then_block.instructions.items));
+ sema.air_extra.appendSliceAssumeCapacity(@ptrCast(else_block.instructions.items));
_ = try child_block.addInst(.{ .tag = .cond_br, .data = .{ .pl_op = .{
.operand = cond,
.payload = cond_br_payload,
} } });
- sema.air_instructions.items(.data)[block_inst].ty_pl.payload = sema.addExtraAssumeCapacity(
+ sema.air_instructions.items(.data)[@intFromEnum(block_inst)].ty_pl.payload = sema.addExtraAssumeCapacity(
Air.Block{ .body_len = @intCast(child_block.instructions.items.len) },
);
- sema.air_extra.appendSliceAssumeCapacity(child_block.instructions.items);
+ sema.air_extra.appendSliceAssumeCapacity(@ptrCast(child_block.instructions.items));
try parent_block.instructions.append(gpa, block_inst);
- return Air.indexToRef(block_inst);
+ return block_inst.toRef();
}
fn checkNullableType(sema: *Sema, block: *Block, src: LazySrcLoc, ty: Type) !void {
@@ -18382,8 +18382,8 @@ fn zirCondbr(
}),
} },
});
- sema.air_extra.appendSliceAssumeCapacity(true_instructions);
- sema.air_extra.appendSliceAssumeCapacity(sub_block.instructions.items);
+ sema.air_extra.appendSliceAssumeCapacity(@ptrCast(true_instructions));
+ sema.air_extra.appendSliceAssumeCapacity(@ptrCast(sub_block.instructions.items));
return always_noreturn;
}
@@ -18429,7 +18429,7 @@ fn zirTry(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileError!
}),
} },
});
- sema.air_extra.appendSliceAssumeCapacity(sub_block.instructions.items);
+ sema.air_extra.appendSliceAssumeCapacity(@ptrCast(sub_block.instructions.items));
return try_inst;
}
@@ -18489,7 +18489,7 @@ fn zirTryPtr(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileErr
}),
} },
});
- sema.air_extra.appendSliceAssumeCapacity(sub_block.instructions.items);
+ sema.air_extra.appendSliceAssumeCapacity(@ptrCast(sub_block.instructions.items));
return try_inst;
}
@@ -18501,8 +18501,8 @@ fn addRuntimeBreak(sema: *Sema, child_block: *Block, break_data: BreakData) !voi
const labeled_block = if (!gop.found_existing) blk: {
try sema.post_hoc_blocks.ensureUnusedCapacity(sema.gpa, 1);
- const new_block_inst: Air.Inst.Index = @intCast(sema.air_instructions.len);
- gop.value_ptr.* = Air.indexToRef(new_block_inst);
+ const new_block_inst: Air.Inst.Index = @enumFromInt(sema.air_instructions.len);
+ gop.value_ptr.* = new_block_inst.toRef();
try sema.air_instructions.append(sema.gpa, .{
.tag = .block,
.data = undefined,
@@ -18533,7 +18533,7 @@ fn addRuntimeBreak(sema: *Sema, child_block: *Block, break_data: BreakData) !voi
sema.post_hoc_blocks.putAssumeCapacityNoClobber(new_block_inst, labeled_block);
break :blk labeled_block;
} else blk: {
- const new_block_inst = Air.refToIndex(gop.value_ptr.*).?;
+ const new_block_inst = gop.value_ptr.*.toIndex().?;
const labeled_block = sema.post_hoc_blocks.get(new_block_inst).?;
break :blk labeled_block;
};
@@ -18541,7 +18541,7 @@ fn addRuntimeBreak(sema: *Sema, child_block: *Block, break_data: BreakData) !voi
const operand = try sema.resolveInst(break_data.operand);
const br_ref = try child_block.addBr(labeled_block.label.merges.block_inst, operand);
try labeled_block.label.merges.results.append(sema.gpa, operand);
- try labeled_block.label.merges.br_list.append(sema.gpa, Air.refToIndex(br_ref).?);
+ try labeled_block.label.merges.br_list.append(sema.gpa, br_ref.toIndex().?);
labeled_block.block.runtime_index.increment();
if (labeled_block.block.runtime_cond == null and labeled_block.block.runtime_loop == null) {
labeled_block.block.runtime_cond = child_block.runtime_cond orelse child_block.runtime_loop;
@@ -18719,8 +18719,8 @@ fn retWithErrTracing(
.then_body_len = @intCast(then_block.instructions.items.len),
.else_body_len = @intCast(else_block.instructions.items.len),
});
- sema.air_extra.appendSliceAssumeCapacity(then_block.instructions.items);
- sema.air_extra.appendSliceAssumeCapacity(else_block.instructions.items);
+ sema.air_extra.appendSliceAssumeCapacity(@ptrCast(then_block.instructions.items));
+ sema.air_extra.appendSliceAssumeCapacity(@ptrCast(else_block.instructions.items));
_ = try block.addInst(.{ .tag = .cond_br, .data = .{ .pl_op = .{
.operand = is_non_err,
@@ -25856,9 +25856,9 @@ fn addSafetyCheckExtra(
fail_block.instructions.items.len);
try sema.air_instructions.ensureUnusedCapacity(gpa, 3);
- const block_inst: Air.Inst.Index = @intCast(sema.air_instructions.len);
- const cond_br_inst = block_inst + 1;
- const br_inst = cond_br_inst + 1;
+ const block_inst: Air.Inst.Index = @enumFromInt(sema.air_instructions.len);
+ const cond_br_inst: Air.Inst.Index = @enumFromInt(@intFromEnum(block_inst) + 1);
+ const br_inst: Air.Inst.Index = @enumFromInt(@intFromEnum(cond_br_inst) + 1);
sema.air_instructions.appendAssumeCapacity(.{
.tag = .block,
.data = .{ .ty_pl = .{
@@ -25868,7 +25868,7 @@ fn addSafetyCheckExtra(
}),
} },
});
- sema.air_extra.appendAssumeCapacity(cond_br_inst);
+ sema.air_extra.appendAssumeCapacity(@intFromEnum(cond_br_inst));
sema.air_instructions.appendAssumeCapacity(.{
.tag = .cond_br,
@@ -25880,8 +25880,8 @@ fn addSafetyCheckExtra(
}),
} },
});
- sema.air_extra.appendAssumeCapacity(br_inst);
- sema.air_extra.appendSliceAssumeCapacity(fail_block.instructions.items);
+ sema.air_extra.appendAssumeCapacity(@intFromEnum(br_inst));
+ sema.air_extra.appendSliceAssumeCapacity(@ptrCast(fail_block.instructions.items));
sema.air_instructions.appendAssumeCapacity(.{
.tag = .br,
@@ -29621,10 +29621,10 @@ fn storePtr2(
try sema.queueFullTypeResolution(elem_ty);
if (ptr_ty.ptrInfo(mod).flags.vector_index == .runtime) {
- const ptr_inst = Air.refToIndex(ptr).?;
+ const ptr_inst = ptr.toIndex().?;
const air_tags = sema.air_instructions.items(.tag);
- if (air_tags[ptr_inst] == .ptr_elem_ptr) {
- const ty_pl = sema.air_instructions.items(.data)[ptr_inst].ty_pl;
+ if (air_tags[@intFromEnum(ptr_inst)] == .ptr_elem_ptr) {
+ const ty_pl = sema.air_instructions.items(.data)[@intFromEnum(ptr_inst)].ty_pl;
const bin_op = sema.getTmpAir().extraData(Air.Bin, ty_pl.payload).data;
_ = try block.addInst(.{
.tag = .vector_store_elem,
@@ -29657,9 +29657,9 @@ fn storePtr2(
/// comptime-known store to a local alloc, and updates `maybe_comptime_allocs`
/// accordingly.
fn checkComptimeKnownStore(sema: *Sema, block: *Block, store_inst_ref: Air.Inst.Ref) !void {
- const store_inst = Air.refToIndex(store_inst_ref).?;
- const inst_data = sema.air_instructions.items(.data)[store_inst].bin_op;
- const ptr = Air.refToIndex(inst_data.lhs) orelse return;
+ const store_inst = store_inst_ref.toIndex().?;
+ const inst_data = sema.air_instructions.items(.data)[@intFromEnum(store_inst)].bin_op;
+ const ptr = inst_data.lhs.toIndex() orelse return;
const operand = inst_data.rhs;
const maybe_base_alloc = sema.base_allocs.get(ptr) orelse return;
@@ -29679,19 +29679,19 @@ fn checkComptimeKnownStore(sema: *Sema, block: *Block, store_inst_ref: Air.Inst.
/// ptr_elem_ptr, bitcast, etc), checks whether the base pointer refers to a
/// local alloc, and updates `base_allocs` accordingly.
fn checkKnownAllocPtr(sema: *Sema, base_ptr: Air.Inst.Ref, new_ptr: Air.Inst.Ref) !void {
- const base_ptr_inst = Air.refToIndex(base_ptr) orelse return;
- const new_ptr_inst = Air.refToIndex(new_ptr) orelse return;
+ const base_ptr_inst = base_ptr.toIndex() orelse return;
+ const new_ptr_inst = new_ptr.toIndex() orelse return;
const alloc_inst = sema.base_allocs.get(base_ptr_inst) orelse return;
try sema.base_allocs.put(sema.gpa, new_ptr_inst, alloc_inst);
- switch (sema.air_instructions.items(.tag)[new_ptr_inst]) {
+ switch (sema.air_instructions.items(.tag)[@intFromEnum(new_ptr_inst)]) {
.optional_payload_ptr_set, .errunion_payload_ptr_set => {
const maybe_comptime_alloc = sema.maybe_comptime_allocs.getPtr(alloc_inst) orelse return;
try maybe_comptime_alloc.non_elideable_pointers.append(sema.arena, new_ptr_inst);
},
.ptr_elem_ptr => {
const tmp_air = sema.getTmpAir();
- const pl_idx = tmp_air.instructions.items(.data)[new_ptr_inst].ty_pl.payload;
+ const pl_idx = tmp_air.instructions.items(.data)[@intFromEnum(new_ptr_inst)].ty_pl.payload;
const bin = tmp_air.extraData(Air.Bin, pl_idx).data;
const index_ref = bin.rhs;
@@ -29713,15 +29713,15 @@ fn obtainBitCastedVectorPtr(sema: *Sema, ptr: Air.Inst.Ref) ?Air.Inst.Ref {
const array_ty = sema.typeOf(ptr).childType(mod);
if (array_ty.zigTypeTag(mod) != .Array) return null;
var ptr_ref = ptr;
- var ptr_inst = Air.refToIndex(ptr_ref) orelse return null;
+ var ptr_inst = ptr_ref.toIndex() orelse return null;
const air_datas = sema.air_instructions.items(.data);
const air_tags = sema.air_instructions.items(.tag);
- const vector_ty = while (air_tags[ptr_inst] == .bitcast) {
- ptr_ref = air_datas[ptr_inst].ty_op.operand;
+ const vector_ty = while (air_tags[@intFromEnum(ptr_inst)] == .bitcast) {
+ ptr_ref = air_datas[@intFromEnum(ptr_inst)].ty_op.operand;
if (!sema.isKnownZigType(ptr_ref, .Pointer)) return null;
const child_ty = sema.typeOf(ptr_ref).childType(mod);
if (child_ty.zigTypeTag(mod) == .Vector) break child_ty;
- ptr_inst = Air.refToIndex(ptr_ref) orelse return null;
+ ptr_inst = ptr_ref.toIndex() orelse return null;
} else return null;
// We have a pointer-to-array and a pointer-to-vector. If the elements and
@@ -31631,7 +31631,7 @@ fn analyzeDeclVal(
}
const decl_ref = try sema.analyzeDeclRefInner(decl_index, false);
const result = try sema.analyzeLoad(block, src, decl_ref, src);
- if (Air.refToInterned(result) != null) {
+ if (result.toInterned() != null) {
if (!block.is_typeof) {
try sema.decl_val_table.put(sema.gpa, decl_index, result);
}
@@ -31811,10 +31811,10 @@ fn analyzeLoad(
}
if (ptr_ty.ptrInfo(mod).flags.vector_index == .runtime) {
- const ptr_inst = Air.refToIndex(ptr).?;
+ const ptr_inst = ptr.toIndex().?;
const air_tags = sema.air_instructions.items(.tag);
- if (air_tags[ptr_inst] == .ptr_elem_ptr) {
- const ty_pl = sema.air_instructions.items(.data)[ptr_inst].ty_pl;
+ if (air_tags[@intFromEnum(ptr_inst)] == .ptr_elem_ptr) {
+ const ty_pl = sema.air_instructions.items(.data)[@intFromEnum(ptr_inst)].ty_pl;
const bin_op = sema.getTmpAir().extraData(Air.Bin, ty_pl.payload).data;
return block.addBinOp(.ptr_elem_val, bin_op.lhs, bin_op.rhs);
}
@@ -31932,8 +31932,8 @@ fn analyzeIsNonErrComptimeOnly(
return .bool_false;
}
- if (Air.refToIndex(operand)) |operand_inst| {
- switch (sema.air_instructions.items(.tag)[operand_inst]) {
+ if (operand.toIndex()) |operand_inst| {
+ switch (sema.air_instructions.items(.tag)[@intFromEnum(operand_inst)]) {
.wrap_errunion_payload => return .bool_true,
.wrap_errunion_err => return .bool_false,
else => {},
@@ -37089,8 +37089,8 @@ fn appendRefsAssumeCapacity(sema: *Sema, refs: []const Air.Inst.Ref) void {
fn getBreakBlock(sema: *Sema, inst_index: Air.Inst.Index) ?Air.Inst.Index {
const air_datas = sema.air_instructions.items(.data);
const air_tags = sema.air_instructions.items(.tag);
- switch (air_tags[inst_index]) {
- .br => return air_datas[inst_index].br.block_inst,
+ switch (air_tags[@intFromEnum(inst_index)]) {
+ .br => return air_datas[@intFromEnum(inst_index)].br.block_inst,
else => return null,
}
}
@@ -38121,7 +38121,7 @@ fn errorSetMerge(sema: *Sema, lhs: Type, rhs: Type) !Type {
/// Avoids crashing the compiler when asking if inferred allocations are noreturn.
fn isNoReturn(sema: *Sema, ref: Air.Inst.Ref) bool {
if (ref == .unreachable_value) return true;
- if (Air.refToIndex(ref)) |inst| switch (sema.air_instructions.items(.tag)[inst]) {
+ if (ref.toIndex()) |inst| switch (sema.air_instructions.items(.tag)[@intFromEnum(inst)]) {
.inferred_alloc, .inferred_alloc_comptime => return false,
else => {},
};
@@ -38130,7 +38130,7 @@ fn isNoReturn(sema: *Sema, ref: Air.Inst.Ref) bool {
/// Avoids crashing the compiler when asking if inferred allocations are known to be a certain zig type.
fn isKnownZigType(sema: *Sema, ref: Air.Inst.Ref, tag: std.builtin.TypeId) bool {
- if (Air.refToIndex(ref)) |inst| switch (sema.air_instructions.items(.tag)[inst]) {
+ if (ref.toIndex()) |inst| switch (sema.air_instructions.items(.tag)[@intFromEnum(inst)]) {
.inferred_alloc, .inferred_alloc_comptime => return false,
else => {},
};