Div by zero

src/intrinsics/native/divmod.rs

@@ -101,10 +101,10 @@ pub fn udivmod4(
     // Unfortunately, there is no 256-bit equivalent on x86_64, but we can still
     // shortcut if the high and low values of the operands are 0:
     if a.high() | b.high() == 0 {
+        res.write(U256::from_words(0, a.low() / b.low()));
         if let Some(rem) = rem {
             rem.write(U256::from_words(0, a.low() % b.low()));
         }
-        res.write(U256::from_words(0, a.low() / b.low()));
         return;
     }
 
@@ -164,9 +164,15 @@ pub fn udivmod4(
 
 // See Knuth, TAOCP, Volume 2, section 4.3.1, Algorithm D.
 // https://skanthak.homepage.t-online.de/division.html
+// The high word of v (the divisor) must be non-zero.
 #[inline]
 pub fn div_mod_knuth(u: &U256, v: &U256) -> (U256, U256) {
     const N_UDWORD_BITS: u32 = 128;
+    assert_ne!(
+        *u.high(),
+        0,
+        "The second operand must be greater than u128::MAX"
+    );
 
     #[inline]
     fn full_shl(a: &U256, shift: u32) -> [u128; 3] {
@@ -266,7 +272,6 @@ pub fn div_mod_knuth(u: &U256, v: &U256) -> (U256, U256) {
     let shift = v.high().leading_zeros();
     debug_assert!(shift < N_UDWORD_BITS);
     let v = v << shift;
-    debug_assert!(v.high() >> (N_UDWORD_BITS - 1) == 1);
     // u will store the remainder (shifted)
     let mut u = full_shl(u, shift);
 
@@ -275,6 +280,14 @@ pub fn div_mod_knuth(u: &U256, v: &U256) -> (U256, U256) {
     let v_n_1 = *v.high();
     let v_n_2 = *v.low();
 
+    if v_n_1 >> (N_UDWORD_BITS - 1) != 1 {
+        debug_assert!(false);
+
+        // SAFETY: `v_n_1` must be normalized because input `v` has
+        // been checked to be non-zero.
+        unsafe { core::hint::unreachable_unchecked() }
+    }
+
     // D2. D7. - unrolled loop j == 0, n == 2, m == 0 (only one possible iteration)
     let mut r_hat: u128 = 0;
     let u_jn = u[2];