From d75fa86d7084bd41f68d1cd03763bd7cf2a87052 Mon Sep 17 00:00:00 2001 From: Veikka Tuominen Date: Thu, 21 Jul 2022 14:40:00 +0300 Subject: stage2: implement `@setFloatMode` --- src/Sema.zig | 142 ++++++++++++++++++++++++++++++++++------------------------- 1 file changed, 81 insertions(+), 61 deletions(-) (limited to 'src/Sema.zig') diff --git a/src/Sema.zig b/src/Sema.zig index e675690a1e..7aaff7043f 100644 --- a/src/Sema.zig +++ b/src/Sema.zig @@ -144,6 +144,9 @@ pub const Block = struct { /// when null, it is determined by build mode, changed by @setRuntimeSafety want_safety: ?bool = null, + /// What mode to generate float operations in, set by @setFloatMode + float_mode: std.builtin.FloatMode = .Strict, + c_import_buf: ?*std.ArrayList(u8) = null, /// type of `err` in `else => |err|` @@ -206,6 +209,7 @@ pub const Block = struct { .runtime_loop = parent.runtime_loop, .runtime_index = parent.runtime_index, .want_safety = parent.want_safety, + .float_mode = parent.float_mode, .c_import_buf = parent.c_import_buf, .switch_else_err_ty = parent.switch_else_err_ty, }; @@ -414,7 +418,7 @@ pub const Block = struct { fn addCmpVector(block: *Block, lhs: Air.Inst.Ref, rhs: Air.Inst.Ref, cmp_op: std.math.CompareOperator, vector_ty: Air.Inst.Ref) !Air.Inst.Ref { return block.addInst(.{ - .tag = .cmp_vector, + .tag = if (block.float_mode == .Optimized) .cmp_vector_optimized else .cmp_vector, .data = .{ .ty_pl = .{ .ty = vector_ty, .payload = try block.sema.addExtra(Air.VectorCmp{ @@ -714,10 +718,10 @@ fn analyzeBodyInner( .closure_get => try sema.zirClosureGet(block, inst), .cmp_lt => try sema.zirCmp(block, inst, .lt), .cmp_lte => try sema.zirCmp(block, inst, .lte), - .cmp_eq => try sema.zirCmpEq(block, inst, .eq, .cmp_eq), + .cmp_eq => try sema.zirCmpEq(block, inst, .eq, Air.Inst.Tag.fromCmpOp(.eq, block.float_mode == .Optimized)), .cmp_gte => try sema.zirCmp(block, inst, .gte), .cmp_gt => try sema.zirCmp(block, inst, .gt), - .cmp_neq => try sema.zirCmpEq(block, inst, .neq, .cmp_neq), + .cmp_neq => try sema.zirCmpEq(block, inst, .neq, Air.Inst.Tag.fromCmpOp(.neq, block.float_mode == .Optimized)), .coerce_result_ptr => try sema.zirCoerceResultPtr(block, inst), .decl_ref => try sema.zirDeclRef(block, inst), .decl_val => try sema.zirDeclVal(block, inst), @@ -4705,6 +4709,7 @@ fn zirBlock(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileErro .inlining = parent_block.inlining, .is_comptime = parent_block.is_comptime, .want_safety = parent_block.want_safety, + .float_mode = parent_block.float_mode, }; defer child_block.instructions.deinit(gpa); @@ -5042,13 +5047,7 @@ fn zirSetCold(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!voi fn zirSetFloatMode(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData) CompileError!void { const extra = sema.code.extraData(Zir.Inst.UnNode, extended.operand).data; const src: LazySrcLoc = .{ .node_offset_builtin_call_arg0 = extra.node }; - const float_mode = try sema.resolveBuiltinEnum(block, src, extra.operand, "FloatMode", "operand to @setFloatMode must be comptime known"); - switch (float_mode) { - .Strict => return, - .Optimized => { - // TODO implement optimized float mode - }, - } + block.float_mode = try sema.resolveBuiltinEnum(block, src, extra.operand, "FloatMode", "operand to @setFloatMode must be comptime known"); } fn zirSetRuntimeSafety(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void { @@ -8092,7 +8091,7 @@ fn intCast( const ok = if (is_vector) ok: { const is_in_range = try block.addCmpVector(diff_unsigned, dest_range, .lte, try sema.addType(operand_ty)); const all_in_range = try block.addInst(.{ - .tag = .reduce, + .tag = if (block.float_mode == .Optimized) .reduce_optimized else .reduce, .data = .{ .reduce = .{ .operand = is_in_range, .operation = .And, @@ -8109,7 +8108,7 @@ fn intCast( const ok = if (is_vector) ok: { const is_in_range = try block.addCmpVector(diff, dest_max, .lte, try sema.addType(operand_ty)); const all_in_range = try block.addInst(.{ - .tag = .reduce, + .tag = if (block.float_mode == .Optimized) .reduce_optimized else .reduce, .data = .{ .reduce = .{ .operand = is_in_range, .operation = .And, @@ -8130,7 +8129,7 @@ fn intCast( const zero_inst = try sema.addConstant(operand_ty, zero_val); const is_in_range = try block.addCmpVector(operand, zero_inst, .gte, try sema.addType(operand_ty)); const all_in_range = try block.addInst(.{ - .tag = .reduce, + .tag = if (block.float_mode == .Optimized) .reduce_optimized else .reduce, .data = .{ .reduce = .{ .operand = is_in_range, .operation = .And, @@ -9391,7 +9390,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError } else { for (items) |item_ref| { const item = try sema.resolveInst(item_ref); - const cmp_ok = try case_block.addBinOp(.cmp_eq, operand, item); + const cmp_ok = try case_block.addBinOp(if (case_block.float_mode == .Optimized) .cmp_eq_optimized else .cmp_eq, operand, item); if (any_ok != .none) { any_ok = try case_block.addBinOp(.bool_or, any_ok, cmp_ok); } else { @@ -9411,12 +9410,12 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError // operand >= first and operand <= last const range_first_ok = try case_block.addBinOp( - .cmp_gte, + if (case_block.float_mode == .Optimized) .cmp_gte_optimized else .cmp_gte, operand, item_first, ); const range_last_ok = try case_block.addBinOp( - .cmp_lte, + if (case_block.float_mode == .Optimized) .cmp_lte_optimized else .cmp_lte, operand, item_last, ); @@ -10023,7 +10022,7 @@ fn zirShl( const ov_bit = try sema.tupleFieldValByIndex(block, src, op_ov, 1, op_ov_tuple_ty); const any_ov_bit = if (lhs_ty.zigTypeTag() == .Vector) try block.addInst(.{ - .tag = .reduce, + .tag = if (block.float_mode == .Optimized) .reduce_optimized else .reduce, .data = .{ .reduce = .{ .operand = ov_bit, .operation = .Or, @@ -10120,7 +10119,7 @@ fn zirShr( const ok = if (rhs_ty.zigTypeTag() == .Vector) ok: { const eql = try block.addCmpVector(lhs, back, .eq, try sema.addType(rhs_ty)); break :ok try block.addInst(.{ - .tag = .reduce, + .tag = if (block.float_mode == .Optimized) .reduce_optimized else .reduce, .data = .{ .reduce = .{ .operand = eql, .operation = .And, @@ -10719,7 +10718,7 @@ fn zirNegate(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air. return sema.addConstant(rhs_ty, try rhs_val.floatNeg(rhs_ty, sema.arena, target)); } try sema.requireRuntimeBlock(block, src, null); - return block.addUnOp(.neg, rhs); + return block.addUnOp(if (block.float_mode == .Optimized) .neg_optimized else .neg, rhs); } const lhs = if (rhs_ty.zigTypeTag() == .Vector) @@ -11078,6 +11077,7 @@ fn analyzeArithmetic( return casted_lhs; } } + const air_tag: Air.Inst.Tag = if (block.float_mode == .Optimized) .add_optimized else .add; if (maybe_lhs_val) |lhs_val| { if (lhs_val.isUndef()) { if (is_int) { @@ -11100,8 +11100,8 @@ fn analyzeArithmetic( try sema.floatAdd(lhs_val, rhs_val, resolved_type), ); } - } else break :rs .{ .src = rhs_src, .air_tag = .add }; - } else break :rs .{ .src = lhs_src, .air_tag = .add }; + } else break :rs .{ .src = rhs_src, .air_tag = air_tag }; + } else break :rs .{ .src = lhs_src, .air_tag = air_tag }; }, .addwrap => { // Integers only; floats are checked above. @@ -11112,6 +11112,7 @@ fn analyzeArithmetic( return casted_rhs; } } + const air_tag: Air.Inst.Tag = if (block.float_mode == .Optimized) .addwrap_optimized else .addwrap; if (maybe_rhs_val) |rhs_val| { if (rhs_val.isUndef()) { return sema.addConstUndef(resolved_type); @@ -11124,8 +11125,8 @@ fn analyzeArithmetic( resolved_type, try sema.numberAddWrap(block, src, lhs_val, rhs_val, resolved_type), ); - } else break :rs .{ .src = lhs_src, .air_tag = .addwrap }; - } else break :rs .{ .src = rhs_src, .air_tag = .addwrap }; + } else break :rs .{ .src = lhs_src, .air_tag = air_tag }; + } else break :rs .{ .src = rhs_src, .air_tag = air_tag }; }, .add_sat => { // Integers only; floats are checked above. @@ -11173,6 +11174,7 @@ fn analyzeArithmetic( return casted_lhs; } } + const air_tag: Air.Inst.Tag = if (block.float_mode == .Optimized) .sub_optimized else .sub; if (maybe_lhs_val) |lhs_val| { if (lhs_val.isUndef()) { if (is_int) { @@ -11195,8 +11197,8 @@ fn analyzeArithmetic( try sema.floatSub(lhs_val, rhs_val, resolved_type), ); } - } else break :rs .{ .src = rhs_src, .air_tag = .sub }; - } else break :rs .{ .src = lhs_src, .air_tag = .sub }; + } else break :rs .{ .src = rhs_src, .air_tag = air_tag }; + } else break :rs .{ .src = lhs_src, .air_tag = air_tag }; }, .subwrap => { // Integers only; floats are checked above. @@ -11210,6 +11212,7 @@ fn analyzeArithmetic( return casted_lhs; } } + const air_tag: Air.Inst.Tag = if (block.float_mode == .Optimized) .subwrap_optimized else .subwrap; if (maybe_lhs_val) |lhs_val| { if (lhs_val.isUndef()) { return sema.addConstUndef(resolved_type); @@ -11219,8 +11222,8 @@ fn analyzeArithmetic( resolved_type, try sema.numberSubWrap(block, src, lhs_val, rhs_val, resolved_type), ); - } else break :rs .{ .src = rhs_src, .air_tag = .subwrap }; - } else break :rs .{ .src = lhs_src, .air_tag = .subwrap }; + } else break :rs .{ .src = rhs_src, .air_tag = air_tag }; + } else break :rs .{ .src = lhs_src, .air_tag = air_tag }; }, .sub_sat => { // Integers only; floats are checked above. @@ -11327,14 +11330,14 @@ fn analyzeArithmetic( if (is_int) { break :rs .{ .src = rhs_src, .air_tag = .div_trunc }; } else { - break :rs .{ .src = rhs_src, .air_tag = .div_float }; + break :rs .{ .src = rhs_src, .air_tag = if (block.float_mode == .Optimized) .div_float_optimized else .div_float }; } } } else { if (is_int) { break :rs .{ .src = lhs_src, .air_tag = .div_trunc }; } else { - break :rs .{ .src = lhs_src, .air_tag = .div_float }; + break :rs .{ .src = lhs_src, .air_tag = if (block.float_mode == .Optimized) .div_float_optimized else .div_float }; } } }, @@ -11373,6 +11376,7 @@ fn analyzeArithmetic( return sema.failWithDivideByZero(block, rhs_src); } } + const air_tag: Air.Inst.Tag = if (block.float_mode == .Optimized) .div_trunc_optimized else .div_trunc; if (maybe_lhs_val) |lhs_val| { if (lhs_val.isUndef()) { if (lhs_scalar_ty.isSignedInt() and rhs_scalar_ty.isSignedInt()) { @@ -11398,8 +11402,8 @@ fn analyzeArithmetic( try lhs_val.floatDivTrunc(rhs_val, resolved_type, sema.arena, target), ); } - } else break :rs .{ .src = rhs_src, .air_tag = .div_trunc }; - } else break :rs .{ .src = lhs_src, .air_tag = .div_trunc }; + } else break :rs .{ .src = rhs_src, .air_tag = air_tag }; + } else break :rs .{ .src = lhs_src, .air_tag = air_tag }; }, .div_floor => { // For integers: @@ -11436,6 +11440,7 @@ fn analyzeArithmetic( return sema.failWithDivideByZero(block, rhs_src); } } + const air_tag: Air.Inst.Tag = if (block.float_mode == .Optimized) .div_floor_optimized else .div_floor; if (maybe_lhs_val) |lhs_val| { if (lhs_val.isUndef()) { if (lhs_scalar_ty.isSignedInt() and rhs_scalar_ty.isSignedInt()) { @@ -11461,8 +11466,8 @@ fn analyzeArithmetic( try lhs_val.floatDivFloor(rhs_val, resolved_type, sema.arena, target), ); } - } else break :rs .{ .src = rhs_src, .air_tag = .div_floor }; - } else break :rs .{ .src = lhs_src, .air_tag = .div_floor }; + } else break :rs .{ .src = rhs_src, .air_tag = air_tag }; + } else break :rs .{ .src = lhs_src, .air_tag = air_tag }; }, .div_exact => { // For integers: @@ -11498,6 +11503,7 @@ fn analyzeArithmetic( return sema.failWithDivideByZero(block, rhs_src); } } + const air_tag: Air.Inst.Tag = if (block.float_mode == .Optimized) .div_exact_optimized else .div_exact; if (maybe_lhs_val) |lhs_val| { if (maybe_rhs_val) |rhs_val| { if (is_int) { @@ -11513,8 +11519,8 @@ fn analyzeArithmetic( try lhs_val.floatDiv(rhs_val, resolved_type, sema.arena, target), ); } - } else break :rs .{ .src = rhs_src, .air_tag = .div_exact }; - } else break :rs .{ .src = lhs_src, .air_tag = .div_exact }; + } else break :rs .{ .src = rhs_src, .air_tag = air_tag }; + } else break :rs .{ .src = lhs_src, .air_tag = air_tag }; }, .mul => { // For integers: @@ -11535,6 +11541,7 @@ fn analyzeArithmetic( } } } + const air_tag: Air.Inst.Tag = if (block.float_mode == .Optimized) .mul_optimized else .mul; if (maybe_rhs_val) |rhs_val| { if (rhs_val.isUndef()) { if (is_int) { @@ -11570,8 +11577,8 @@ fn analyzeArithmetic( try lhs_val.floatMul(rhs_val, resolved_type, sema.arena, target), ); } - } else break :rs .{ .src = lhs_src, .air_tag = .mul }; - } else break :rs .{ .src = rhs_src, .air_tag = .mul }; + } else break :rs .{ .src = lhs_src, .air_tag = air_tag }; + } else break :rs .{ .src = rhs_src, .air_tag = air_tag }; }, .mulwrap => { // Integers only; floats are handled above. @@ -11588,6 +11595,7 @@ fn analyzeArithmetic( } } } + const air_tag: Air.Inst.Tag = if (block.float_mode == .Optimized) .mulwrap_optimized else .mulwrap; if (maybe_rhs_val) |rhs_val| { if (rhs_val.isUndef()) { return sema.addConstUndef(resolved_type); @@ -11606,8 +11614,8 @@ fn analyzeArithmetic( resolved_type, try lhs_val.numberMulWrap(rhs_val, resolved_type, sema.arena, target), ); - } else break :rs .{ .src = lhs_src, .air_tag = .mulwrap }; - } else break :rs .{ .src = rhs_src, .air_tag = .mulwrap }; + } else break :rs .{ .src = lhs_src, .air_tag = air_tag }; + } else break :rs .{ .src = rhs_src, .air_tag = air_tag }; }, .mul_sat => { // Integers only; floats are checked above. @@ -11777,6 +11785,7 @@ fn analyzeArithmetic( return sema.failWithDivideByZero(block, rhs_src); } } + const air_tag: Air.Inst.Tag = if (block.float_mode == .Optimized) .rem_optimized else .rem; if (maybe_lhs_val) |lhs_val| { if (lhs_val.isUndef()) { return sema.addConstUndef(resolved_type); @@ -11786,8 +11795,8 @@ fn analyzeArithmetic( resolved_type, try lhs_val.floatRem(rhs_val, resolved_type, sema.arena, target), ); - } else break :rs .{ .src = rhs_src, .air_tag = .rem }; - } else break :rs .{ .src = lhs_src, .air_tag = .rem }; + } else break :rs .{ .src = rhs_src, .air_tag = air_tag }; + } else break :rs .{ .src = lhs_src, .air_tag = air_tag }; }, .mod => { // For integers: @@ -11834,6 +11843,7 @@ fn analyzeArithmetic( return sema.failWithDivideByZero(block, rhs_src); } } + const air_tag: Air.Inst.Tag = if (block.float_mode == .Optimized) .mod_optimized else .mod; if (maybe_lhs_val) |lhs_val| { if (lhs_val.isUndef()) { return sema.addConstUndef(resolved_type); @@ -11843,8 +11853,8 @@ fn analyzeArithmetic( resolved_type, try lhs_val.floatMod(rhs_val, resolved_type, sema.arena, target), ); - } else break :rs .{ .src = rhs_src, .air_tag = .mod }; - } else break :rs .{ .src = lhs_src, .air_tag = .mod }; + } else break :rs .{ .src = rhs_src, .air_tag = air_tag }; + } else break :rs .{ .src = lhs_src, .air_tag = air_tag }; }, else => unreachable, } @@ -11874,7 +11884,7 @@ fn analyzeArithmetic( const ov_bit = try sema.tupleFieldValByIndex(block, src, op_ov, 1, op_ov_tuple_ty); const any_ov_bit = if (resolved_type.zigTypeTag() == .Vector) try block.addInst(.{ - .tag = .reduce, + .tag = if (block.float_mode == .Optimized) .reduce_optimized else .reduce, .data = .{ .reduce = .{ .operand = ov_bit, .operation = .Or, @@ -11890,13 +11900,17 @@ fn analyzeArithmetic( } } switch (rs.air_tag) { - .div_float, .div_exact, .div_trunc, .div_floor => { + // zig fmt: off + .div_float, .div_exact, .div_trunc, .div_floor, .div_float_optimized, + .div_exact_optimized, .div_trunc_optimized, .div_floor_optimized + // zig fmt: on + => if (scalar_tag == .Int or block.float_mode == .Optimized) { const ok = if (resolved_type.zigTypeTag() == .Vector) ok: { const zero_val = try Value.Tag.repeated.create(sema.arena, Value.zero); const zero = try sema.addConstant(sema.typeOf(casted_rhs), zero_val); const ok = try block.addCmpVector(casted_rhs, zero, .neq, try sema.addType(resolved_type)); break :ok try block.addInst(.{ - .tag = .reduce, + .tag = if (block.float_mode == .Optimized) .reduce_optimized else .reduce, .data = .{ .reduce = .{ .operand = ok, .operation = .And, @@ -11904,17 +11918,17 @@ fn analyzeArithmetic( }); } else ok: { const zero = try sema.addConstant(sema.typeOf(casted_rhs), Value.zero); - break :ok try block.addBinOp(.cmp_neq, casted_rhs, zero); + break :ok try block.addBinOp(if (block.float_mode == .Optimized) .cmp_neq_optimized else .cmp_neq, casted_rhs, zero); }; try sema.addSafetyCheck(block, ok, .divide_by_zero); }, - .rem, .mod => { + .rem, .mod, .rem_optimized, .mod_optimized => { const ok = if (resolved_type.zigTypeTag() == .Vector) ok: { const zero_val = try Value.Tag.repeated.create(sema.arena, Value.zero); const zero = try sema.addConstant(sema.typeOf(casted_rhs), zero_val); const ok = try block.addCmpVector(casted_rhs, zero, if (scalar_tag == .Int) .gt else .neq, try sema.addType(resolved_type)); break :ok try block.addInst(.{ - .tag = .reduce, + .tag = if (block.float_mode == .Optimized) .reduce_optimized else .reduce, .data = .{ .reduce = .{ .operand = ok, .operation = .And, @@ -11922,13 +11936,19 @@ fn analyzeArithmetic( }); } else ok: { const zero = try sema.addConstant(sema.typeOf(casted_rhs), Value.zero); - break :ok try block.addBinOp(if (scalar_tag == .Int) .cmp_gt else .cmp_neq, casted_rhs, zero); + const air_tag = if (scalar_tag == .Int) + Air.Inst.Tag.cmp_gt + else if (block.float_mode == .Optimized) + Air.Inst.Tag.cmp_neq_optimized + else + Air.Inst.Tag.cmp_neq; + break :ok try block.addBinOp(air_tag, casted_rhs, zero); }; try sema.addSafetyCheck(block, ok, .remainder_division_zero_negative); }, else => {}, } - if (rs.air_tag == .div_exact) { + if (rs.air_tag == .div_exact or rs.air_tag == .div_exact_optimized) { const result = try block.addBinOp(.div_exact, casted_lhs, casted_rhs); const ok = if (scalar_tag == .Float) ok: { const floored = try block.addUnOp(.floor, result); @@ -11936,14 +11956,14 @@ fn analyzeArithmetic( if (resolved_type.zigTypeTag() == .Vector) { const eql = try block.addCmpVector(result, floored, .eq, try sema.addType(resolved_type)); break :ok try block.addInst(.{ - .tag = .reduce, + .tag = if (block.float_mode == .Optimized) .reduce_optimized else .reduce, .data = .{ .reduce = .{ .operand = eql, .operation = .And, } }, }); } else { - const is_in_range = try block.addBinOp(.cmp_eq, result, floored); + const is_in_range = try block.addBinOp(if (block.float_mode == .Optimized) .cmp_eq_optimized else .cmp_eq, result, floored); break :ok is_in_range; } } else ok: { @@ -11962,7 +11982,7 @@ fn analyzeArithmetic( }); } else { const zero = try sema.addConstant(sema.typeOf(casted_rhs), Value.zero); - const is_in_range = try block.addBinOp(.cmp_eq, remainder, zero); + const is_in_range = try block.addBinOp(if (block.float_mode == .Optimized) .cmp_eq_optimized else .cmp_eq, remainder, zero); break :ok is_in_range; } }; @@ -12476,7 +12496,7 @@ fn cmpSelf( const result_ty_ref = try sema.addType(result_ty); return block.addCmpVector(casted_lhs, casted_rhs, op, result_ty_ref); } - const tag = Air.Inst.Tag.fromCmpOp(op); + const tag = Air.Inst.Tag.fromCmpOp(op, block.float_mode == .Optimized); return block.addBinOp(tag, casted_lhs, casted_rhs); } @@ -15954,12 +15974,12 @@ fn zirFloatToInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError! } try sema.requireRuntimeBlock(block, inst_data.src(), operand_src); - const result = try block.addTyOp(.float_to_int, dest_ty, operand); + const result = try block.addTyOp(if (block.float_mode == .Optimized) .float_to_int_optimized else .float_to_int, dest_ty, operand); if (block.wantSafety()) { const back = try block.addTyOp(.int_to_float, operand_ty, result); const diff = try block.addBinOp(.sub, operand, back); - const ok_pos = try block.addBinOp(.cmp_lt, diff, try sema.addConstant(operand_ty, Value.one)); - const ok_neg = try block.addBinOp(.cmp_gt, diff, try sema.addConstant(operand_ty, Value.negative_one)); + const ok_pos = try block.addBinOp(if (block.float_mode == .Optimized) .cmp_lt_optimized else .cmp_lt, diff, try sema.addConstant(operand_ty, Value.one)); + const ok_neg = try block.addBinOp(if (block.float_mode == .Optimized) .cmp_gt_optimized else .cmp_gt, diff, try sema.addConstant(operand_ty, Value.negative_one)); const ok = try block.addBinOp(.bool_and, ok_pos, ok_neg); try sema.addSafetyCheck(block, ok, .integer_part_out_of_bounds); } @@ -17194,7 +17214,7 @@ fn zirReduce(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air. try sema.requireRuntimeBlock(block, inst_data.src(), operand_src); return block.addInst(.{ - .tag = .reduce, + .tag = if (block.float_mode == .Optimized) .reduce_optimized else .reduce, .data = .{ .reduce = .{ .operand = operand, .operation = operation, @@ -24489,7 +24509,7 @@ fn cmpNumeric( }; const casted_lhs = try sema.coerce(block, dest_ty, lhs, lhs_src); const casted_rhs = try sema.coerce(block, dest_ty, rhs, rhs_src); - return block.addBinOp(Air.Inst.Tag.fromCmpOp(op), casted_lhs, casted_rhs); + return block.addBinOp(Air.Inst.Tag.fromCmpOp(op, block.float_mode == .Optimized), casted_lhs, casted_rhs); } // For mixed unsigned integer sizes, implicit cast both operands to the larger integer. // For mixed signed and unsigned integers, implicit cast both operands to a signed @@ -24610,7 +24630,7 @@ fn cmpNumeric( const casted_lhs = try sema.coerce(block, dest_ty, lhs, lhs_src); const casted_rhs = try sema.coerce(block, dest_ty, rhs, rhs_src); - return block.addBinOp(Air.Inst.Tag.fromCmpOp(op), casted_lhs, casted_rhs); + return block.addBinOp(Air.Inst.Tag.fromCmpOp(op, block.float_mode == .Optimized), casted_lhs, casted_rhs); } /// Asserts that lhs and rhs types are both vectors. -- cgit v1.2.3