Unbox float TrueDivide and mixed float/int ops to DoubleBinaryOp

Summary:
Two related optimizations in the Simplify pass:

1. When both operands of a FloatBinaryOp<TrueDivide> are FloatExact, lower
   to unboxed DoubleBinaryOp<TrueDivide> (a single divsd instruction) with
   a guard for divide-by-zero. Previously only Add/Subtract/Multiply were
   unboxed; TrueDivide fell through to the boxed CPython float_div slot.

2. When a BinaryOp has one FloatExact operand and one LongExact operand
   with a known constant value (object specialization), convert the int
   constant to a double at compile time and emit an unboxed DoubleBinaryOp
   directly. This handles patterns like `x * 2`, `1.0 / y`, `dt / 3`
   where one side is a float and the other is a small constant integer.
   Supported for Add, Subtract, Multiply, TrueDivide, and Power.

Reviewed By: jbower-fb

Differential Revision: D96742433

fbshipit-source-id: 6ac1f11a69d829a1f24280dceccd81f948365ed6

Author: alexmalyshev

cinderx/Jit/hir/simplify.cpp

@@ -744,6 +744,55 @@ Register* simplifyBinaryOp(Env& env, const BinaryOp* instr) {
     return env.emit<FloatBinaryOp>(instr->op(), lhs, rhs, *instr->frameState());
   }
 
+  // Mixed float/int binary ops where the int is a known constant: convert the
+  // int to a double at compile time and emit an unboxed DoubleBinaryOp.  This
+  // avoids going through CPython's generic binary op dispatch which would do
+  // the int-to-float conversion at runtime.
+  if ((op == BinaryOpKind::kAdd || op == BinaryOpKind::kSubtract ||
+       op == BinaryOpKind::kMultiply || op == BinaryOpKind::kTrueDivide ||
+       op == BinaryOpKind::kPower)) {
+    Register* float_reg = nullptr;
+    Register* int_reg = nullptr;
+    bool int_on_right = false;
+    if (lhs->isA(TFloatExact) && rhs->isA(TLongExact) &&
+        rhs->type().hasObjectSpec()) {
+      float_reg = lhs;
+      int_reg = rhs;
+      int_on_right = true;
+    } else if (
+        lhs->isA(TLongExact) && rhs->isA(TFloatExact) &&
+        lhs->type().hasObjectSpec()) {
+      float_reg = rhs;
+      int_reg = lhs;
+      int_on_right = false;
+    }
+    if (float_reg != nullptr) {
+      int overflow;
+      long long_val =
+          PyLong_AsLongAndOverflow(int_reg->type().objectSpec(), &overflow);
+      if (!overflow) {
+        auto double_val = static_cast<double>(long_val);
+        env.emit<UseType>(float_reg, TFloatExact);
+        env.emit<UseType>(int_reg, int_reg->type());
+        Register* unbox_float = env.emit<PrimitiveUnbox>(float_reg, TCDouble);
+        Register* const_double =
+            env.emit<LoadConst>(Type::fromCDouble(double_val));
+        Register* unbox_left = int_on_right ? unbox_float : const_double;
+        Register* unbox_right = int_on_right ? const_double : unbox_float;
+        // Need to guard against division by zero.
+        if (op == BinaryOpKind::kTrueDivide) {
+          Register* zero = env.emit<LoadConst>(Type::fromCDouble(0.0));
+          Register* is_nonzero = env.emit<PrimitiveCompare>(
+              PrimitiveCompareOp::kNotEqual, unbox_right, zero);
+          env.emitInstr<Guard>(is_nonzero);
+        }
+        Register* result =
+            env.emit<DoubleBinaryOp>(op, unbox_left, unbox_right);
+        return env.emit<PrimitiveBox>(result, TCDouble, *instr->frameState());
+      }
+    }
+  }
+
   if ((lhs->isA(TUnicodeExact) && rhs->isA(TLongExact)) &&
       (op == BinaryOpKind::kMultiply)) {
     Register* unboxed_rhs = env.emit<IndexUnbox>(rhs, PyExc_OverflowError);
@@ -870,6 +919,19 @@ Register* simplifyFloatBinaryOp(Env& env, const FloatBinaryOp* instr) {
     return env.emit<PrimitiveBox>(result, TCDouble, *instr->frameState());
   }
 
+  // True-divide is similar to add/sub/mul, but needs to guard against division
+  // by zero as that would raise a ZeroDivisionError in the interpreter.
+  if (op == BinaryOpKind::kTrueDivide) {
+    Register* unbox_left = env.emit<PrimitiveUnbox>(instr->left(), TCDouble);
+    Register* unbox_right = env.emit<PrimitiveUnbox>(instr->right(), TCDouble);
+    Register* zero = env.emit<LoadConst>(Type::fromCDouble(0.0));
+    Register* is_nonzero = env.emit<PrimitiveCompare>(
+        PrimitiveCompareOp::kNotEqual, unbox_right, zero);
+    env.emitInstr<Guard>(is_nonzero);
+    Register* result = env.emit<DoubleBinaryOp>(op, unbox_left, unbox_right);
+    return env.emit<PrimitiveBox>(result, TCDouble, *instr->frameState());
+  }
+
   // `x ** 0.5`, convert to the unboxed path.  The LIR generator can lower this
   // into a call to sqrt().
   if (op == BinaryOpKind::kPower) {

cinderx/RuntimeTests/hir_tests/simplify_test.txt

@@ -6155,6 +6155,200 @@ fun test {
   }
 }
 --- Test Name ---
+BinaryOpMulFloatExactAndConstIntToUnboxed
+--- Input ---
+# HIR
+fun test {
+  bb 0 {
+    v1 = LoadArg<0>
+    v2:ImmortalLongExact[3] = LoadConst<ImmortalLongExact[3]>
+    v3 = RefineType<FloatExact> v1
+    v4 = BinaryOp<Multiply> v3 v2
+    Return v4
+  }
+}
+--- Expected 3.10 ---
+fun test {
+  bb 0 {
+    v1:Object = LoadArg<0>
+    v2:ImmortalLongExact[3] = LoadConst<ImmortalLongExact[3]>
+    v3:FloatExact = RefineType<FloatExact> v1
+    UseType<FloatExact> v3
+    UseType<ImmortalLongExact[3]> v2
+    v5:CDouble = PrimitiveUnbox<CDouble> v3
+    v6:CDouble[3] = LoadConst<CDouble[3]>
+    v7:CDouble = DoubleBinaryOp<Multiply> v5 v6
+    v8:FloatExact = PrimitiveBox<CDouble> v7 {
+      FrameState {
+        CurInstrOffset -2
+      }
+    }
+    Return v8
+  }
+}
+--- Expected 3.12 ---
+fun test {
+  bb 0 {
+    v1:Object = LoadArg<0>
+    v2:ImmortalLongExact[3] = LoadConst<ImmortalLongExact[3]>
+    v3:FloatExact = RefineType<FloatExact> v1
+    UseType<FloatExact> v3
+    UseType<ImmortalLongExact[3]> v2
+    v5:CDouble = PrimitiveUnbox<CDouble> v3
+    v6:CDouble[3] = LoadConst<CDouble[3]>
+    v7:CDouble = DoubleBinaryOp<Multiply> v5 v6
+    v8:FloatExact = PrimitiveBox<CDouble> v7 {
+      FrameState {
+        CurInstrOffset -2
+      }
+    }
+    Return v8
+  }
+}
+--- Expected 3.14 ---
+fun test {
+  bb 0 {
+    v1:Object = LoadArg<0>
+    v2:ImmortalLongExact[3] = LoadConst<ImmortalLongExact[3]>
+    v3:FloatExact = RefineType<FloatExact> v1
+    UseType<FloatExact> v3
+    UseType<ImmortalLongExact[3]> v2
+    v5:CDouble = PrimitiveUnbox<CDouble> v3
+    v6:CDouble[3] = LoadConst<CDouble[3]>
+    v7:CDouble = DoubleBinaryOp<Multiply> v5 v6
+    v8:FloatExact = PrimitiveBox<CDouble> v7 {
+      FrameState {
+        CurInstrOffset -2
+      }
+    }
+    Return v8
+  }
+}
+--- Expected 3.15 ---
+fun test {
+  bb 0 {
+    v1:Object = LoadArg<0>
+    v2:ImmortalLongExact[3] = LoadConst<ImmortalLongExact[3]>
+    v3:FloatExact = RefineType<FloatExact> v1
+    UseType<FloatExact> v3
+    UseType<ImmortalLongExact[3]> v2
+    v5:CDouble = PrimitiveUnbox<CDouble> v3
+    v6:CDouble[3] = LoadConst<CDouble[3]>
+    v7:CDouble = DoubleBinaryOp<Multiply> v5 v6
+    v8:FloatExact = PrimitiveBox<CDouble> v7 {
+      FrameState {
+        CurInstrOffset -2
+      }
+    }
+    Return v8
+  }
+}
+--- Test Name ---
+BinaryOpTrueDivideConstIntAndFloatExactToUnboxed
+--- Input ---
+# HIR
+fun test {
+  bb 0 {
+    v2 = LoadArg<0>
+    v1:MortalLongExact[1] = LoadConst<MortalLongExact[1]>
+    v3 = RefineType<FloatExact> v2
+    v4 = BinaryOp<TrueDivide> v1 v3
+    Return v4
+  }
+}
+--- Expected 3.10 ---
+fun test {
+  bb 0 {
+    v2:Object = LoadArg<0>
+    v1:ImmortalLongExact[1] = LoadConst<ImmortalLongExact[1]>
+    v3:FloatExact = RefineType<FloatExact> v2
+    UseType<FloatExact> v3
+    UseType<ImmortalLongExact[1]> v1
+    v5:CDouble = PrimitiveUnbox<CDouble> v3
+    v6:CDouble[1] = LoadConst<CDouble[1]>
+    v7:CDouble[0] = LoadConst<CDouble[0]>
+    v8:CBool = PrimitiveCompare<NotEqual> v5 v7
+    Guard v8 {
+    }
+    v9:CDouble = DoubleBinaryOp<TrueDivide> v6 v5
+    v10:FloatExact = PrimitiveBox<CDouble> v9 {
+      FrameState {
+        CurInstrOffset -2
+      }
+    }
+    Return v10
+  }
+}
+--- Expected 3.12 ---
+fun test {
+  bb 0 {
+    v2:Object = LoadArg<0>
+    v1:ImmortalLongExact[1] = LoadConst<ImmortalLongExact[1]>
+    v3:FloatExact = RefineType<FloatExact> v2
+    UseType<FloatExact> v3
+    UseType<ImmortalLongExact[1]> v1
+    v5:CDouble = PrimitiveUnbox<CDouble> v3
+    v6:CDouble[1] = LoadConst<CDouble[1]>
+    v7:CDouble[0] = LoadConst<CDouble[0]>
+    v8:CBool = PrimitiveCompare<NotEqual> v5 v7
+    Guard v8 {
+    }
+    v9:CDouble = DoubleBinaryOp<TrueDivide> v6 v5
+    v10:FloatExact = PrimitiveBox<CDouble> v9 {
+      FrameState {
+        CurInstrOffset -2
+      }
+    }
+    Return v10
+  }
+}
+--- Expected 3.14 ---
+fun test {
+  bb 0 {
+    v2:Object = LoadArg<0>
+    v1:ImmortalLongExact[1] = LoadConst<ImmortalLongExact[1]>
+    v3:FloatExact = RefineType<FloatExact> v2
+    UseType<FloatExact> v3
+    UseType<ImmortalLongExact[1]> v1
+    v5:CDouble = PrimitiveUnbox<CDouble> v3
+    v6:CDouble[1] = LoadConst<CDouble[1]>
+    v7:CDouble[0] = LoadConst<CDouble[0]>
+    v8:CBool = PrimitiveCompare<NotEqual> v5 v7
+    Guard v8 {
+    }
+    v9:CDouble = DoubleBinaryOp<TrueDivide> v6 v5
+    v10:FloatExact = PrimitiveBox<CDouble> v9 {
+      FrameState {
+        CurInstrOffset -2
+      }
+    }
+    Return v10
+  }
+}
+--- Expected 3.15 ---
+fun test {
+  bb 0 {
+    v2:Object = LoadArg<0>
+    v1:ImmortalLongExact[1] = LoadConst<ImmortalLongExact[1]>
+    v3:FloatExact = RefineType<FloatExact> v2
+    UseType<FloatExact> v3
+    UseType<ImmortalLongExact[1]> v1
+    v5:CDouble = PrimitiveUnbox<CDouble> v3
+    v6:CDouble[1] = LoadConst<CDouble[1]>
+    v7:CDouble[0] = LoadConst<CDouble[0]>
+    v8:CBool = PrimitiveCompare<NotEqual> v5 v7
+    Guard v8 {
+    }
+    v9:CDouble = DoubleBinaryOp<TrueDivide> v6 v5
+    v10:FloatExact = PrimitiveBox<CDouble> v9 {
+      FrameState {
+        CurInstrOffset -2
+      }
+    }
+    Return v10
+  }
+}
+--- Test Name ---
 BinaryOpWithObjSpecLeftAndRightLongExactTurnsIntoLoadConst
 --- Input ---
 # HIR
@@ -14135,6 +14329,108 @@ fun test {
   }
 }
 --- Test Name ---
+FloatBinaryOpTrueDivideToUnboxed
+--- Input ---
+# HIR
+fun test {
+  bb 0 {
+    v1 = LoadArg<0>
+    v2 = LoadArg<1>
+    v3 = RefineType<FloatExact> v1
+    v4 = RefineType<FloatExact> v2
+    v5 = FloatBinaryOp<TrueDivide> v3 v4
+    Return v5
+  }
+}
+--- Expected 3.10 ---
+fun test {
+  bb 0 {
+    v1:Object = LoadArg<0>
+    v2:Object = LoadArg<1>
+    v3:FloatExact = RefineType<FloatExact> v1
+    v4:FloatExact = RefineType<FloatExact> v2
+    v6:CDouble = PrimitiveUnbox<CDouble> v3
+    v7:CDouble = PrimitiveUnbox<CDouble> v4
+    v8:CDouble[0] = LoadConst<CDouble[0]>
+    v9:CBool = PrimitiveCompare<NotEqual> v7 v8
+    Guard v9 {
+    }
+    v10:CDouble = DoubleBinaryOp<TrueDivide> v6 v7
+    v11:FloatExact = PrimitiveBox<CDouble> v10 {
+      FrameState {
+        CurInstrOffset -2
+      }
+    }
+    Return v11
+  }
+}
+--- Expected 3.12 ---
+fun test {
+  bb 0 {
+    v1:Object = LoadArg<0>
+    v2:Object = LoadArg<1>
+    v3:FloatExact = RefineType<FloatExact> v1
+    v4:FloatExact = RefineType<FloatExact> v2
+    v6:CDouble = PrimitiveUnbox<CDouble> v3
+    v7:CDouble = PrimitiveUnbox<CDouble> v4
+    v8:CDouble[0] = LoadConst<CDouble[0]>
+    v9:CBool = PrimitiveCompare<NotEqual> v7 v8
+    Guard v9 {
+    }
+    v10:CDouble = DoubleBinaryOp<TrueDivide> v6 v7
+    v11:FloatExact = PrimitiveBox<CDouble> v10 {
+      FrameState {
+        CurInstrOffset -2
+      }
+    }
+    Return v11
+  }
+}
+--- Expected 3.14 ---
+fun test {
+  bb 0 {
+    v1:Object = LoadArg<0>
+    v2:Object = LoadArg<1>
+    v3:FloatExact = RefineType<FloatExact> v1
+    v4:FloatExact = RefineType<FloatExact> v2
+    v6:CDouble = PrimitiveUnbox<CDouble> v3
+    v7:CDouble = PrimitiveUnbox<CDouble> v4
+    v8:CDouble[0] = LoadConst<CDouble[0]>
+    v9:CBool = PrimitiveCompare<NotEqual> v7 v8
+    Guard v9 {
+    }
+    v10:CDouble = DoubleBinaryOp<TrueDivide> v6 v7
+    v11:FloatExact = PrimitiveBox<CDouble> v10 {
+      FrameState {
+        CurInstrOffset -2
+      }
+    }
+    Return v11
+  }
+}
+--- Expected 3.15 ---
+fun test {
+  bb 0 {
+    v1:Object = LoadArg<0>
+    v2:Object = LoadArg<1>
+    v3:FloatExact = RefineType<FloatExact> v1
+    v4:FloatExact = RefineType<FloatExact> v2
+    v6:CDouble = PrimitiveUnbox<CDouble> v3
+    v7:CDouble = PrimitiveUnbox<CDouble> v4
+    v8:CDouble[0] = LoadConst<CDouble[0]>
+    v9:CBool = PrimitiveCompare<NotEqual> v7 v8
+    Guard v9 {
+    }
+    v10:CDouble = DoubleBinaryOp<TrueDivide> v6 v7
+    v11:FloatExact = PrimitiveBox<CDouble> v10 {
+      FrameState {
+        CurInstrOffset -2
+      }
+    }
+    Return v11
+  }
+}
+--- Test Name ---
 InPlaceOpFloatAddToUnboxed
 --- Input ---
 # HIR