Simplify mixed width div

Author: mborland

include/boost/decimal/detail/u128.hpp

@@ -2023,43 +2023,26 @@ constexpr void div_mod_impl(const u128& lhs, const std::uint64_t rhs, u128& quot
             remainder.low %= rhs;
         }
     }
-
-    // Setup for Knuth Division
-    // Includes the normalization step here instead of in main function for simplicity
-    const auto offset { countl_zero(static_cast<std::uint32_t>(rhs >> 32)) };
-
-    std::uint32_t u[5]{};
-
-    if (offset != 0)
-    {
-        u[0] = static_cast<std::uint32_t>(lhs.low << offset);
-        u[1] = static_cast<std::uint32_t>(lhs.low >> (32 - offset));
-        u[2] = static_cast<std::uint32_t>(lhs.high << offset) |
-               static_cast<std::uint32_t>(lhs.low >> (64 - offset));
-        u[3] = static_cast<std::uint32_t>(lhs.high >> (32 - offset));
-        u[4] = static_cast<std::uint32_t>(lhs.high >> (64 - offset));
-    }
     else
     {
-        u[0] = static_cast<std::uint32_t>(lhs.low);
-        u[1] = static_cast<std::uint32_t>(lhs.low >> 32);
-        u[2] = static_cast<std::uint32_t>(lhs.high);
-        u[3] = static_cast<std::uint32_t>(lhs.high >> 32);
-    }
+        const auto rhs32 = static_cast<std::uint32_t>(rhs);
 
-    std::uint32_t v[2]
-    {
-        static_cast<std::uint32_t>(rhs << offset),
-        static_cast<std::uint32_t>(rhs >> (32 - offset))
-    };
+        auto current = static_cast<std::uint64_t>(lhs.high >> 32U);
+        quotient.high = static_cast<std::uint64_t>(static_cast<std::uint64_t>(static_cast<std::uint32_t>(current / rhs32)) << 32U);
+        remainder.low = static_cast<std::uint64_t>(current % rhs32);
 
-    std::uint32_t q[3]{};
+        current = static_cast<std::uint64_t>(remainder.low << 32U) | static_cast<std::uint32_t>(lhs.high);
+        quotient.high |= static_cast<std::uint32_t>(current / rhs32);
+        remainder.low = static_cast<std::uint64_t>(current % rhs32);
 
-    divide_knuth_core(u, v, q);
+        current = static_cast<std::uint64_t>(remainder.low << 32U) | static_cast<std::uint32_t>(lhs.low >> 32U);
+        quotient.low = static_cast<std::uint64_t>(static_cast<std::uint64_t>(static_cast<std::uint32_t>(current / rhs32)) << 32U);
+        remainder.low = static_cast<std::uint64_t>(current % rhs32);
 
-    quotient.low = (static_cast<std::uint64_t>(q[1]) << 32) | q[0];
-    quotient.high = q[2];
-    remainder.low = (static_cast<std::uint64_t>(u[1]) << (32 - offset)) | (static_cast<std::uint64_t>(u[0]) >> offset);
+        current = remainder.low << 32U | static_cast<std::uint32_t>(lhs.low);
+        quotient.low |= static_cast<std::uint32_t>(current / rhs32);
+        remainder.low = static_cast<std::uint32_t>(current % rhs32);
+    }
 }
 
 BOOST_DECIMAL_FORCE_INLINE constexpr void div_mod_impl(const u128& lhs, const u128& rhs, u128& quotient, u128& remainder) noexcept
@@ -2272,11 +2255,14 @@ constexpr u128 operator/(const u128 lhs, const u128 rhs) noexcept
 
         #endif
     }
-    else if (rhs > lhs)
+    else if ((lhs.high == 0 && rhs.high != 0) || rhs.low == 0)
     {
-        // This would imply rhs.high != 0 and lhs.high == 0 which is always 0
         return {0, 0};
     }
+    else if (lhs.high == 0)
+    {
+        return { 0, lhs.low / rhs.low };
+    }
     else
     {
         u128 quotient {};