LibCrypto: Remove the concept of invalid big integers

devgianlu · devgianlu · commit fe566ff8cc4f · 2025-04-25T23:12:46.000+02:00
This concept is rarely used in codebase and very much error-prone
if you forget to check it.

Instead, make it so that operations that would produce invalid integers
return an error instead.
diff --git a/Libraries/LibCrypto/BigInt/Algorithms/BitwiseOperations.cpp b/Libraries/LibCrypto/BigInt/Algorithms/BitwiseOperations.cpp
@@ -23,16 +23,6 @@ FLATTEN void UnsignedBigIntegerAlgorithms::bitwise_or_without_allocation(
     UnsignedBigInteger const& right,
     UnsignedBigInteger& output)
 {
-    // If either of the BigInts are invalid, the output is just the other one.
-    if (left.is_invalid()) {
-        output.set_to(right);
-        return;
-    }
-    if (right.is_invalid()) {
-        output.set_to(left);
-        return;
-    }
-
     UnsignedBigInteger const *shorter, *longer;
     if (left.length() < right.length()) {
         shorter = &left;
@@ -62,16 +52,6 @@ FLATTEN void UnsignedBigIntegerAlgorithms::bitwise_and_without_allocation(
     UnsignedBigInteger const& right,
     UnsignedBigInteger& output)
 {
-    // If either of the BigInts are invalid, the output is just the other one.
-    if (left.is_invalid()) {
-        output.set_to(right);
-        return;
-    }
-    if (right.is_invalid()) {
-        output.set_to(left);
-        return;
-    }
-
     UnsignedBigInteger const *shorter, *longer;
     if (left.length() < right.length()) {
         shorter = &left;
@@ -101,16 +81,6 @@ FLATTEN void UnsignedBigIntegerAlgorithms::bitwise_xor_without_allocation(
     UnsignedBigInteger const& right,
     UnsignedBigInteger& output)
 {
-    // If either of the BigInts are invalid, the output is just the other one.
-    if (left.is_invalid()) {
-        output.set_to(right);
-        return;
-    }
-    if (right.is_invalid()) {
-        output.set_to(left);
-        return;
-    }
-
     UnsignedBigInteger const *shorter, *longer;
     if (left.length() < right.length()) {
         shorter = &left;
@@ -137,12 +107,6 @@ FLATTEN ErrorOr<void> UnsignedBigIntegerAlgorithms::bitwise_not_fill_to_one_base
     size_t index,
     UnsignedBigInteger& output)
 {
-    // If the value is invalid, the output value is invalid as well.
-    if (right.is_invalid()) {
-        output.invalidate();
-        return {};
-    }
-
     if (index == 0) {
         output.set_to_0();
         return {};
diff --git a/Libraries/LibCrypto/BigInt/Algorithms/GCD.cpp b/Libraries/LibCrypto/BigInt/Algorithms/GCD.cpp
@@ -68,7 +68,7 @@ void UnsignedBigIntegerAlgorithms::extended_GCD_without_allocation(
         while (gcd < temp_1) {
             add_into_accumulator_without_allocation(gcd, b);
         }
-        subtract_without_allocation(gcd, temp_1, temp_r);
+        MUST(subtract_without_allocation(gcd, temp_1, temp_r));
         gcd.set_to(temp_2);
 
         // (old_s, s) := (s, old_s − quotient × s)
@@ -77,7 +77,7 @@ void UnsignedBigIntegerAlgorithms::extended_GCD_without_allocation(
         while (x < temp_1) {
             add_into_accumulator_without_allocation(x, b);
         }
-        subtract_without_allocation(x, temp_1, temp_s);
+        MUST(subtract_without_allocation(x, temp_1, temp_s));
         x.set_to(temp_2);
 
         // (old_t, t) := (t, old_t − quotient × t)
@@ -86,7 +86,7 @@ void UnsignedBigIntegerAlgorithms::extended_GCD_without_allocation(
         while (y < temp_1) {
             add_into_accumulator_without_allocation(y, b);
         }
-        subtract_without_allocation(y, temp_1, temp_t);
+        MUST(subtract_without_allocation(y, temp_1, temp_t));
         y.set_to(temp_2);
     }
 }
diff --git a/Libraries/LibCrypto/BigInt/Algorithms/ModularPower.cpp b/Libraries/LibCrypto/BigInt/Algorithms/ModularPower.cpp
@@ -262,7 +262,7 @@ void UnsignedBigIntegerAlgorithms::montgomery_modular_power_with_minimal_allocat
     // Note : Since we were using "almost montgomery" multiplications, we aren't guaranteed to be under the modulo already.
     // So, if we're here, we need to respect the modulo.
     // We can, however, start by trying to subtract the modulo, just in case we're close.
-    subtract_without_allocation(zz, modulo, result);
+    MUST(subtract_without_allocation(zz, modulo, result));
 
     if (modulo < zz) {
         // Note: This branch shouldn't happen in theory (as noted in https://github.com/rust-num/num-bigint/blob/master/src/biguint/monty.rs#L210)
diff --git a/Libraries/LibCrypto/BigInt/Algorithms/SimpleOperations.cpp b/Libraries/LibCrypto/BigInt/Algorithms/SimpleOperations.cpp
@@ -73,14 +73,13 @@ void UnsignedBigIntegerAlgorithms::add_into_accumulator_without_allocation(Unsig
 /**
  * Complexity: O(N) where N is the number of words in the larger number
  */
-void UnsignedBigIntegerAlgorithms::subtract_without_allocation(
+ErrorOr<void> UnsignedBigIntegerAlgorithms::subtract_without_allocation(
     UnsignedBigInteger const& left,
     UnsignedBigInteger const& right,
     UnsignedBigInteger& output)
 {
     if (left < right) {
-        output.invalidate();
-        return;
+        return Error::from_string_literal("Invalid subtraction: left < right");
     }
 
     u8 borrow = 0;
@@ -103,6 +102,8 @@ void UnsignedBigIntegerAlgorithms::subtract_without_allocation(
 
     // This assertion should not fail, because we verified that *this>=other at the beginning of the function
     VERIFY(borrow == 0);
+
+    return {};
 }
 
 }
diff --git a/Libraries/LibCrypto/BigInt/Algorithms/UnsignedBigIntegerAlgorithms.h b/Libraries/LibCrypto/BigInt/Algorithms/UnsignedBigIntegerAlgorithms.h
@@ -16,7 +16,7 @@ class UnsignedBigIntegerAlgorithms {
 public:
     static void add_without_allocation(UnsignedBigInteger const& left, UnsignedBigInteger const& right, UnsignedBigInteger& output);
     static void add_into_accumulator_without_allocation(UnsignedBigInteger& accumulator, UnsignedBigInteger const& value);
-    static void subtract_without_allocation(UnsignedBigInteger const& left, UnsignedBigInteger const& right, UnsignedBigInteger& output);
+    static ErrorOr<void> subtract_without_allocation(UnsignedBigInteger const& left, UnsignedBigInteger const& right, UnsignedBigInteger& output);
     static void bitwise_or_without_allocation(UnsignedBigInteger const& left, UnsignedBigInteger const& right, UnsignedBigInteger& output);
     static void bitwise_and_without_allocation(UnsignedBigInteger const& left, UnsignedBigInteger const& right, UnsignedBigInteger& output);
     static void bitwise_xor_without_allocation(UnsignedBigInteger const& left, UnsignedBigInteger const& right, UnsignedBigInteger& output);
diff --git a/Libraries/LibCrypto/BigInt/SignedBigInteger.cpp b/Libraries/LibCrypto/BigInt/SignedBigInteger.cpp
@@ -109,23 +109,23 @@ FLATTEN SignedBigInteger SignedBigInteger::minus(SignedBigInteger const& other)
         // x - y = - (y - x)
         if (m_unsigned_data < other.m_unsigned_data) {
             // The result will be negative.
-            return { other.m_unsigned_data.minus(m_unsigned_data), true };
+            return { MUST(other.m_unsigned_data.minus(m_unsigned_data)), true };
         }
 
         // The result will be either zero, or positive.
-        return SignedBigInteger { m_unsigned_data.minus(other.m_unsigned_data) };
+        return SignedBigInteger { MUST(m_unsigned_data.minus(other.m_unsigned_data)) };
     }
 
     // Both operands are negative.
     // -x - -y = y - x
     if (m_unsigned_data < other.m_unsigned_data) {
         // The result will be positive.
-        return SignedBigInteger { other.m_unsigned_data.minus(m_unsigned_data) };
+        return SignedBigInteger { MUST(other.m_unsigned_data.minus(m_unsigned_data)) };
     }
     // y - x = - (x - y)
     if (m_unsigned_data > other.m_unsigned_data) {
         // The result will be negative.
-        return SignedBigInteger { m_unsigned_data.minus(other.m_unsigned_data), true };
+        return SignedBigInteger { MUST(m_unsigned_data.minus(other.m_unsigned_data)), true };
     }
     // Both operands have the same magnitude, the result is positive zero.
     return SignedBigInteger { 0 };
@@ -135,9 +135,9 @@ FLATTEN SignedBigInteger SignedBigInteger::plus(UnsignedBigInteger const& other)
 {
     if (m_sign) {
         if (other < m_unsigned_data)
-            return { m_unsigned_data.minus(other), true };
+            return { MUST(m_unsigned_data.minus(other)), true };
 
-        return { other.minus(m_unsigned_data), false };
+        return { MUST(other.minus(m_unsigned_data)), false };
     }
 
     return { m_unsigned_data.plus(other), false };
@@ -149,9 +149,9 @@ FLATTEN SignedBigInteger SignedBigInteger::minus(UnsignedBigInteger const& other
         return { m_unsigned_data.plus(m_unsigned_data), true };
 
     if (other < m_unsigned_data)
-        return { m_unsigned_data.minus(other), false };
+        return { MUST(m_unsigned_data.minus(other)), false };
 
-    return { other.minus(m_unsigned_data), true };
+    return { MUST(other.minus(m_unsigned_data)), true };
 }
 
 FLATTEN SignedBigInteger SignedBigInteger::bitwise_not() const
@@ -190,16 +190,16 @@ FLATTEN SignedBigInteger SignedBigInteger::bitwise_or(SignedBigInteger const& ot
     // This saves one ~.
     if (is_negative() && !other.is_negative()) {
         size_t index = unsigned_value().one_based_index_of_highest_set_bit();
-        return { unsigned_value().minus(1).bitwise_and(other.unsigned_value().bitwise_not_fill_to_one_based_index(index)).plus(1), true };
+        return { MUST(unsigned_value().minus(1)).bitwise_and(other.unsigned_value().bitwise_not_fill_to_one_based_index(index)).plus(1), true };
     }
 
     // -(A | -B) == ~A & (B - 1) + 1
     if (!is_negative() && other.is_negative()) {
         size_t index = other.unsigned_value().one_based_index_of_highest_set_bit();
-        return { unsigned_value().bitwise_not_fill_to_one_based_index(index).bitwise_and(other.unsigned_value().minus(1)).plus(1), true };
+        return { unsigned_value().bitwise_not_fill_to_one_based_index(index).bitwise_and(MUST(other.unsigned_value().minus(1))).plus(1), true };
     }
 
-    return { unsigned_value().minus(1).bitwise_and(other.unsigned_value().minus(1)).plus(1), true };
+    return { MUST(unsigned_value().minus(1)).bitwise_and(MUST(other.unsigned_value().minus(1))).plus(1), true };
 }
 
 FLATTEN SignedBigInteger SignedBigInteger::bitwise_and(SignedBigInteger const& other) const
@@ -237,7 +237,7 @@ FLATTEN SignedBigInteger SignedBigInteger::bitwise_and(SignedBigInteger const& o
     //   -A & -B == -( (A - 1) | (B - 1) + 1)
     // So we can compute the bitwise and by returning a negative number with magnitude (A - 1) | (B - 1) + 1.
     // This is better than the naive (~A + 1) & (~B + 1) because it needs just one O(n) scan for the or instead of 2 for the ~s.
-    return { unsigned_value().minus(1).bitwise_or(other.unsigned_value().minus(1)).plus(1), true };
+    return { MUST(unsigned_value().minus(1)).bitwise_or(MUST(other.unsigned_value().minus(1))).plus(1), true };
 }
 
 FLATTEN SignedBigInteger SignedBigInteger::bitwise_xor(SignedBigInteger const& other) const
@@ -333,9 +333,6 @@ void SignedBigInteger::set_bit_inplace(size_t bit_index)
 
 bool SignedBigInteger::operator==(SignedBigInteger const& other) const
 {
-    if (is_invalid() != other.is_invalid())
-        return false;
-
     if (m_unsigned_data == 0 && other.m_unsigned_data == 0)
         return true;
 
diff --git a/Libraries/LibCrypto/BigInt/SignedBigInteger.h b/Libraries/LibCrypto/BigInt/SignedBigInteger.h
@@ -92,13 +92,6 @@ class SignedBigInteger {
         m_sign = other.m_sign;
     }
 
-    void invalidate()
-    {
-        m_unsigned_data.invalidate();
-    }
-
-    [[nodiscard]] bool is_invalid() const { return m_unsigned_data.is_invalid(); }
-
     // These get + 1 byte for the sign.
     [[nodiscard]] size_t length() const { return m_unsigned_data.length() + 1; }
     [[nodiscard]] size_t trimmed_length() const { return m_unsigned_data.trimmed_length() + 1; }
diff --git a/Libraries/LibCrypto/BigInt/UnsignedBigInteger.cpp b/Libraries/LibCrypto/BigInt/UnsignedBigInteger.cpp
@@ -179,7 +179,6 @@ u64 UnsignedBigInteger::to_u64() const
 
 double UnsignedBigInteger::to_double(UnsignedBigInteger::RoundingMode rounding_mode) const
 {
-    VERIFY(!is_invalid());
     auto highest_bit = one_based_index_of_highest_set_bit();
     if (highest_bit == 0)
         return 0;
@@ -342,14 +341,12 @@ double UnsignedBigInteger::to_double(UnsignedBigInteger::RoundingMode rounding_m
 void UnsignedBigInteger::set_to_0()
 {
     m_words.clear_with_capacity();
-    m_is_invalid = false;
     m_cached_trimmed_length = {};
     m_cached_hash = 0;
 }
 
 void UnsignedBigInteger::set_to(UnsignedBigInteger::Word other)
 {
-    m_is_invalid = false;
     m_words.resize_and_keep_capacity(1);
     m_words[0] = other;
     m_cached_trimmed_length = {};
@@ -358,7 +355,6 @@ void UnsignedBigInteger::set_to(UnsignedBigInteger::Word other)
 
 void UnsignedBigInteger::set_to(UnsignedBigInteger const& other)
 {
-    m_is_invalid = other.m_is_invalid;
     m_words.resize_and_keep_capacity(other.m_words.size());
     __builtin_memcpy(m_words.data(), other.m_words.data(), other.m_words.size() * sizeof(u32));
     m_cached_trimmed_length = {};
@@ -424,11 +420,11 @@ FLATTEN UnsignedBigInteger UnsignedBigInteger::plus(UnsignedBigInteger const& ot
     return result;
 }
 
-FLATTEN UnsignedBigInteger UnsignedBigInteger::minus(UnsignedBigInteger const& other) const
+FLATTEN ErrorOr<UnsignedBigInteger> UnsignedBigInteger::minus(UnsignedBigInteger const& other) const
 {
     UnsignedBigInteger result;
 
-    UnsignedBigIntegerAlgorithms::subtract_without_allocation(*this, other, result);
+    TRY(UnsignedBigIntegerAlgorithms::subtract_without_allocation(*this, other, result));
 
     return result;
 }
@@ -577,9 +573,6 @@ void UnsignedBigInteger::set_bit_inplace(size_t bit_index)
 
 bool UnsignedBigInteger::operator==(UnsignedBigInteger const& other) const
 {
-    if (is_invalid() != other.is_invalid())
-        return false;
-
     auto length = trimmed_length();
 
     if (length != other.trimmed_length())
@@ -771,9 +764,6 @@ UnsignedBigInteger::CompareResult UnsignedBigInteger::compare_to_double(double v
 
 ErrorOr<void> AK::Formatter<Crypto::UnsignedBigInteger>::format(FormatBuilder& fmtbuilder, Crypto::UnsignedBigInteger const& value)
 {
-    if (value.is_invalid())
-        return fmtbuilder.put_string("invalid"sv);
-
     StringBuilder builder;
     for (int i = value.length() - 1; i >= 0; --i)
         TRY(builder.try_appendff("{}|", value.words()[i]));
diff --git a/Libraries/LibCrypto/BigInt/UnsignedBigInteger.h b/Libraries/LibCrypto/BigInt/UnsignedBigInteger.h
@@ -83,16 +83,8 @@ class UnsignedBigInteger {
     void set_to(Word other);
     void set_to(UnsignedBigInteger const& other);
 
-    void invalidate()
-    {
-        m_is_invalid = true;
-        m_cached_trimmed_length = {};
-        m_cached_hash = 0;
-    }
-
     [[nodiscard]] bool is_zero() const;
     [[nodiscard]] bool is_odd() const { return m_words.size() && (m_words[0] & 1); }
-    [[nodiscard]] bool is_invalid() const { return m_is_invalid; }
 
     [[nodiscard]] size_t length() const { return m_words.size(); }
     // The "trimmed length" is the number of words after trimming leading zeroed words
@@ -107,7 +99,7 @@ class UnsignedBigInteger {
     size_t one_based_index_of_highest_set_bit() const;
 
     [[nodiscard]] UnsignedBigInteger plus(UnsignedBigInteger const& other) const;
-    [[nodiscard]] UnsignedBigInteger minus(UnsignedBigInteger const& other) const;
+    [[nodiscard]] ErrorOr<UnsignedBigInteger> minus(UnsignedBigInteger const& other) const;
     [[nodiscard]] UnsignedBigInteger bitwise_or(UnsignedBigInteger const& other) const;
     [[nodiscard]] UnsignedBigInteger bitwise_and(UnsignedBigInteger const& other) const;
     [[nodiscard]] UnsignedBigInteger bitwise_xor(UnsignedBigInteger const& other) const;
@@ -153,10 +145,6 @@ class UnsignedBigInteger {
     }
 
     mutable u32 m_cached_hash { 0 };
-
-    // Used to indicate a negative result, or a result of an invalid operation
-    bool m_is_invalid { false };
-
     mutable Optional<size_t> m_cached_trimmed_length;
 };
 
@@ -179,19 +167,13 @@ inline Crypto::UnsignedBigInteger operator""_bigint(char const* string, size_t l
 
 inline Crypto::UnsignedBigInteger operator""_bigint(unsigned long long value)
 {
-    auto result = Crypto::UnsignedBigInteger { static_cast<u64>(value) };
-    VERIFY(!result.is_invalid());
-
-    return result;
+    return Crypto::UnsignedBigInteger { static_cast<u64>(value) };
 }
 
 inline Crypto::UnsignedBigInteger operator""_bigint(long double value)
 {
     VERIFY(value >= 0);
     VERIFY(value < static_cast<long double>(NumericLimits<double>::max()));
 
-    auto result = Crypto::UnsignedBigInteger { static_cast<double>(value) };
-    VERIFY(!result.is_invalid());
-
-    return result;
+    return Crypto::UnsignedBigInteger { static_cast<double>(value) };
 }
diff --git a/Libraries/LibJS/Runtime/BigInt.cpp b/Libraries/LibJS/Runtime/BigInt.cpp
@@ -21,7 +21,6 @@ GC::Ref<BigInt> BigInt::create(VM& vm, Crypto::SignedBigInteger big_integer)
 BigInt::BigInt(Crypto::SignedBigInteger big_integer)
     : m_big_integer(move(big_integer))
 {
-    VERIFY(!m_big_integer.is_invalid());
 }
 
 ErrorOr<String> BigInt::to_string() const
diff --git a/Libraries/LibJS/Runtime/Temporal/AbstractOperations.cpp b/Libraries/LibJS/Runtime/Temporal/AbstractOperations.cpp
@@ -965,7 +965,7 @@ Crypto::SignedBigInteger apply_unsigned_rounding_mode(Crypto::SignedDivisionResu
     auto d1 = x.remainder.unsigned_value();
 
     // 7. Let d2 be r2 – x.
-    auto d2 = increment.minus(x.remainder.unsigned_value());
+    auto d2 = MUST(increment.minus(x.remainder.unsigned_value()));
 
     // 8. If d1 < d2, return r1.
     if (d1 < d2)
diff --git a/Tests/LibCrypto/TestBigInteger.cpp b/Tests/LibCrypto/TestBigInteger.cpp

Original file line number	Diff line number	Diff line change
`@@ -68,7 +68,7 @@ void UnsignedBigIntegerAlgorithms::extended_GCD_without_allocation(`
`68`	`68`	`while (gcd < temp_1) {`
`69`	`69`	`add_into_accumulator_without_allocation(gcd, b);`
`70`	`70`	`}`
`71`		`- subtract_without_allocation(gcd, temp_1, temp_r);`
	`71`	`+ MUST(subtract_without_allocation(gcd, temp_1, temp_r));`
`72`	`72`	`gcd.set_to(temp_2);`
`73`	`73`
`74`	`74`	`// (old_s, s) := (s, old_s − quotient × s)`
`@@ -77,7 +77,7 @@ void UnsignedBigIntegerAlgorithms::extended_GCD_without_allocation(`
`77`	`77`	`while (x < temp_1) {`
`78`	`78`	`add_into_accumulator_without_allocation(x, b);`
`79`	`79`	`}`
`80`		`- subtract_without_allocation(x, temp_1, temp_s);`
	`80`	`+ MUST(subtract_without_allocation(x, temp_1, temp_s));`
`81`	`81`	`x.set_to(temp_2);`
`82`	`82`
`83`	`83`	`// (old_t, t) := (t, old_t − quotient × t)`
`@@ -86,7 +86,7 @@ void UnsignedBigIntegerAlgorithms::extended_GCD_without_allocation(`
`86`	`86`	`while (y < temp_1) {`
`87`	`87`	`add_into_accumulator_without_allocation(y, b);`
`88`	`88`	`}`
`89`		`- subtract_without_allocation(y, temp_1, temp_t);`
	`89`	`+ MUST(subtract_without_allocation(y, temp_1, temp_t));`
`90`	`90`	`y.set_to(temp_2);`
`91`	`91`	`}`
`92`	`92`	`}`
Original file line number	Diff line number	Diff line change
`@@ -73,14 +73,13 @@ void UnsignedBigIntegerAlgorithms::add_into_accumulator_without_allocation(Unsig`
`73`	`73`	`/**`
`74`	`74`	`* Complexity: O(N) where N is the number of words in the larger number`
`75`	`75`	`*/`
`76`		`-void UnsignedBigIntegerAlgorithms::subtract_without_allocation(`
	`76`	`+ErrorOr<void> UnsignedBigIntegerAlgorithms::subtract_without_allocation(`
`77`	`77`	`UnsignedBigInteger const& left,`
`78`	`78`	`UnsignedBigInteger const& right,`
`79`	`79`	`UnsignedBigInteger& output)`
`80`	`80`	`{`
`81`	`81`	`if (left < right) {`
`82`		`- output.invalidate();`
`83`		`- return;`
	`82`	`+ return Error::from_string_literal("Invalid subtraction: left < right");`
`84`	`83`	`}`
`85`	`84`
`86`	`85`	`u8 borrow = 0;`
`@@ -103,6 +102,8 @@ void UnsignedBigIntegerAlgorithms::subtract_without_allocation(`
`103`	`102`
`104`	`103`	`// This assertion should not fail, because we verified that *this>=other at the beginning of the function`
`105`	`104`	`VERIFY(borrow == 0);`
	`105`	`+`
	`106`	`+ return {};`
`106`	`107`	`}`
`107`	`108`
`108`	`109`	`}`
Original file line number	Diff line number	Diff line change
`@@ -179,7 +179,6 @@ u64 UnsignedBigInteger::to_u64() const`
`179`	`179`
`180`	`180`	`double UnsignedBigInteger::to_double(UnsignedBigInteger::RoundingMode rounding_mode) const`
`181`	`181`	`{`
`182`		`- VERIFY(!is_invalid());`
`183`	`182`	`auto highest_bit = one_based_index_of_highest_set_bit();`
`184`	`183`	`if (highest_bit == 0)`
`185`	`184`	`return 0;`
`@@ -342,14 +341,12 @@ double UnsignedBigInteger::to_double(UnsignedBigInteger::RoundingMode rounding_m`
`342`	`341`	`void UnsignedBigInteger::set_to_0()`
`343`	`342`	`{`
`344`	`343`	`m_words.clear_with_capacity();`
`345`		`- m_is_invalid = false;`
`346`	`344`	`m_cached_trimmed_length = {};`
`347`	`345`	`m_cached_hash = 0;`
`348`	`346`	`}`
`349`	`347`
`350`	`348`	`void UnsignedBigInteger::set_to(UnsignedBigInteger::Word other)`
`351`	`349`	`{`
`352`		`- m_is_invalid = false;`
`353`	`350`	`m_words.resize_and_keep_capacity(1);`
`354`	`351`	`m_words[0] = other;`
`355`	`352`	`m_cached_trimmed_length = {};`
`@@ -358,7 +355,6 @@ void UnsignedBigInteger::set_to(UnsignedBigInteger::Word other)`
`358`	`355`
`359`	`356`	`void UnsignedBigInteger::set_to(UnsignedBigInteger const& other)`
`360`	`357`	`{`
`361`		`- m_is_invalid = other.m_is_invalid;`
`362`	`358`	`m_words.resize_and_keep_capacity(other.m_words.size());`
`363`	`359`	`__builtin_memcpy(m_words.data(), other.m_words.data(), other.m_words.size() * sizeof(u32));`
`364`	`360`	`m_cached_trimmed_length = {};`
`@@ -424,11 +420,11 @@ FLATTEN UnsignedBigInteger UnsignedBigInteger::plus(UnsignedBigInteger const& ot`
`424`	`420`	`return result;`
`425`	`421`	`}`
`426`	`422`
`427`		`-FLATTEN UnsignedBigInteger UnsignedBigInteger::minus(UnsignedBigInteger const& other) const`
	`423`	`+FLATTEN ErrorOr<UnsignedBigInteger> UnsignedBigInteger::minus(UnsignedBigInteger const& other) const`
`428`	`424`	`{`
`429`	`425`	`UnsignedBigInteger result;`
`430`	`426`
`431`		`- UnsignedBigIntegerAlgorithms::subtract_without_allocation(*this, other, result);`
	`427`	`+ TRY(UnsignedBigIntegerAlgorithms::subtract_without_allocation(*this, other, result));`
`432`	`428`
`433`	`429`	`return result;`
`434`	`430`	`}`
`@@ -577,9 +573,6 @@ void UnsignedBigInteger::set_bit_inplace(size_t bit_index)`
`577`	`573`
`578`	`574`	`bool UnsignedBigInteger::operator==(UnsignedBigInteger const& other) const`
`579`	`575`	`{`
`580`		`- if (is_invalid() != other.is_invalid())`
`581`		`- return false;`
`582`		`-`
`583`	`576`	`auto length = trimmed_length();`
`584`	`577`
`585`	`578`	`if (length != other.trimmed_length())`
`@@ -771,9 +764,6 @@ UnsignedBigInteger::CompareResult UnsignedBigInteger::compare_to_double(double v`
`771`	`764`
`772`	`765`	`ErrorOr<void> AK::Formatter<Crypto::UnsignedBigInteger>::format(FormatBuilder& fmtbuilder, Crypto::UnsignedBigInteger const& value)`
`773`	`766`	`{`
`774`		`- if (value.is_invalid())`
`775`		`- return fmtbuilder.put_string("invalid"sv);`
`776`		`-`
`777`	`767`	`StringBuilder builder;`
`778`	`768`	`for (int i = value.length() - 1; i >= 0; --i)`
`779`	`769`	`TRY(builder.try_appendff("{}\|", value.words()[i]));`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,6 @@ GC::Ref<BigInt> BigInt::create(VM& vm, Crypto::SignedBigInteger big_integer)`
`21`	`21`	`BigInt::BigInt(Crypto::SignedBigInteger big_integer)`
`22`	`22`	`: m_big_integer(move(big_integer))`
`23`	`23`	`{`
`24`		`- VERIFY(!m_big_integer.is_invalid());`
`25`	`24`	`}`
`26`	`25`
`27`	`26`	`ErrorOr<String> BigInt::to_string() const`