srctree

 

.mul_with_overflow => try self.airMulOverflow(inst),

.opencl => try self.spv.importInstructionSet(.@"OpenCL.std"),

.vulkan => try self.spv.importInstructionSet(.@"GLSL.std.450"),

fn airMulOverflow(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {

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

 

const result_ty = self.typeOfIndex(inst);

const operand_ty = self.typeOf(extra.lhs);

const ov_ty = result_ty.structFieldType(1, self.module);

 

const info = self.arithmeticTypeInfo(operand_ty);

switch (info.class) {

.composite_integer => return self.todo("overflow ops for composite integers", .{}),

.strange_integer, .integer => {},

.float, .bool => unreachable,

}

 

var wip_result = try self.elementWise(operand_ty, true);

defer wip_result.deinit();

var wip_ov = try self.elementWise(ov_ty, true);

defer wip_ov.deinit();

 

const zero_id = try self.constInt(wip_result.ty_ref, 0);

const zero_ov_id = try self.constInt(wip_ov.ty_ref, 0);

const one_ov_id = try self.constInt(wip_ov.ty_ref, 1);

 

for (wip_result.results, wip_ov.results, 0..) |*result_id, *ov_id, i| {

const lhs_elem_id = try wip_result.elementAt(operand_ty, lhs, i);

const rhs_elem_id = try wip_result.elementAt(operand_ty, rhs, i);

 

result_id.* = try self.arithOp(wip_result.ty, lhs_elem_id, rhs_elem_id, .OpFMul, .OpIMul, .OpIMul);

 

// (a != 0) and (x / a != b)

const not_zero_id = try self.cmp(.neq, Type.bool, wip_result.ty, lhs_elem_id, zero_id);

const res_rhs_id = try self.arithOp(wip_result.ty, result_id.*, lhs_elem_id, .OpFDiv, .OpSDiv, .OpUDiv);

const res_rhs_not_rhs_id = try self.cmp(.neq, Type.bool, wip_result.ty, res_rhs_id, rhs_elem_id);

const cond_id = try self.binOpSimple(Type.bool, not_zero_id, res_rhs_not_rhs_id, .OpLogicalAnd);

 

ov_id.* = self.spv.allocId();

try self.func.body.emit(self.spv.gpa, .OpSelect, .{

.id_result_type = wip_ov.ty_id,

.id_result = ov_id.*,

.condition = cond_id,

.object_1 = one_ov_id,

.object_2 = zero_ov_id,

});

}

 

return try self.constructStruct(

result_ty,

&.{ operand_ty, ov_ty },

&.{ try wip_result.finalize(), try wip_ov.finalize() },

);

}

 

const set_tag = std.meta.stringToEnum(spec.InstructionSet, set_name) orelse {

return self.fail(set_name_offset, "unknown instruction set: {s}", .{set_name});

};

break :blk .{ .value = try self.spv.importInstructionSet(set_tag) };