[libc][math] Improve the performance of subtraction for UInt<>.

[lntue]

Summary

Use built-in sub_with_borrow to improve the performance of subtraction
for UInt<>.

Microbenchmark: https://quick-bench.com/q/UEg6Z6VK4PP2yLBtTi9C0cL9xpY

libc/src/__support/UInt.h

template <size_t Bits> struct UInt {
   UInt<Bits> &operator=(const UInt<Bits> &other) {
     for (size_t i = 0; i < WordCount; ++i)
       val[i] = other.val[i];
     return *this;
   }
 
   // Add x to this number and store the result in this number.
   // Returns the carry value produced by the addition operation.
-  // To prevent overflow from intermediate results, we use the following
-  // property of unsigned integers:
-  //   x + (~x) = 2^(sizeof(x)) - 1.
   constexpr uint64_t add(const UInt<Bits> &x) {
     SumCarry<uint64_t> s{0, 0};
     for (size_t i = 0; i < WordCount; ++i) {
       s = add_with_carry(val[i], x.val[i], s.carry);
       val[i] = s.sum;
     }
     return s.carry;
   }
 
   constexpr UInt<Bits> operator+(const UInt<Bits> &other) const {
     UInt<Bits> result;
     SumCarry<uint64_t> s{0, 0};
     for (size_t i = 0; i < WordCount; ++i) {
       s = add_with_carry(val[i], other.val[i], s.carry);
       result.val[i] = s.sum;
     }
     return result;
   }
 
-  constexpr UInt<Bits> operator+=(const UInt<Bits> &other) {
+  constexpr UInt<Bits> &operator+=(const UInt<Bits> &other) {
     add(other); // Returned carry value is ignored.
     return *this;
   }
 
   // Subtract x to this number and store the result in this number.
   // Returns the carry value produced by the subtraction operation.
-  // To prevent overflow from intermediate results, we use the following
-  // property of unsigned integers:
-  //   x + (~x) = 2^(sizeof(x)) - 1,
-  // So:
-  //   -x = ((~x) + 1) + (-2^(sizeof(x))),
-  // where 2^(sizeof(x)) is represented by the carry bit.
   constexpr uint64_t sub(const UInt<Bits> &x) {
-    bool carry = false;
+    DiffBorrow<uint64_t> d{0, 0};
     for (size_t i = 0; i < WordCount; ++i) {
-      if (!carry) {
-        if (val[i] >= x.val[i])
-          val[i] -= x.val[i];
-        else {
-          val[i] += (~x.val[i]) + 1;
-          carry = true;
-        }
-      } else {
-        if (val[i] > x.val[i]) {
-          val[i] -= x.val[i] + 1;
-          carry = false;
-        } else
-          val[i] += ~x.val[i];
-      }
-    }
-    return carry ? 1 : 0;
+      d = sub_with_borrow(val[i], x.val[i], d.borrow);
+      val[i] = d.diff;
+    return d.borrow;
   }
 
   constexpr UInt<Bits> operator-(const UInt<Bits> &other) const {
-    UInt<Bits> result(*this);
-    result.sub(other);
-    // TODO(lntue): Set overflow flag / errno when carry is true.
+    UInt<Bits> result;
+    DiffBorrow<uint64_t> d{0, 0};
+    for (size_t i = 0; i < WordCount; ++i) {
+      d = sub_with_borrow(val[i], other.val[i], d.borrow);
+      result.val[i] = d.diff;
+    }
     return result;
   }
 
-  constexpr UInt<Bits> operator-=(const UInt<Bits> &other) {
+  constexpr UInt<Bits> &operator-=(const UInt<Bits> &other) {
     // TODO(lntue): Set overflow flag / errno when carry is true.
     sub(other);
     return *this;
   }
 
   // Multiply this number with x and store the result in this number. It is
   // implemented using the long multiplication algorithm by splitting the
   // 64-bit words of this number and |x| in to 32-bit halves but peforming