fix: replace __int128 with builtin overflow checks for 32-bit ARM

The device target (Cortex-M7) is 32-bit and has no __int128. Use
__builtin_mul_overflow / __builtin_add_overflow on int64 instead,
demoting exact rationals to double on overflow.

Author: 1e1

src/value.cpp

@@ -21,37 +21,14 @@ int64_t gcd64(int64_t a, int64_t b) {
   return a;
 }
 
-__int128 gcd128(__int128 a, __int128 b) {
-  if (a < 0) a = -a;
-  if (b < 0) b = -b;
-  while (b) {
-    __int128 t = a % b;
-    a = b;
-    b = t;
-  }
-  return a;
+// Overflow-checked 64-bit arithmetic. The target (32-bit Cortex-M7) has no
+// __int128, so we rely on the compiler builtins and demote to double whenever
+// an exact result would overflow int64.
+inline bool mulOverflow(int64_t a, int64_t b, int64_t* out) {
+  return __builtin_mul_overflow(a, b, out);
 }
-
-bool fitsInt64(__int128 x) {
-  return x <= (__int128)INT64_MAX && x >= (__int128)INT64_MIN;
-}
-
-// Build an exact value from a 128-bit fraction, demoting to APPROX on overflow.
-Value fromFraction128(__int128 num, __int128 den) {
-  if (den == 0) return Value::undefined();
-  if (den < 0) {
-    num = -num;
-    den = -den;
-  }
-  __int128 g = gcd128(num, den);
-  if (g != 0) {
-    num /= g;
-    den /= g;
-  }
-  if (fitsInt64(num) && fitsInt64(den)) {
-    return Value::rational((int64_t)num, (int64_t)den);
-  }
-  return Value::real((double)num / (double)den);
+inline bool addOverflow(int64_t a, int64_t b, int64_t* out) {
+  return __builtin_add_overflow(a, b, out);
 }
 
 int64_t isqrt64(int64_t n) {
@@ -100,9 +77,13 @@ Value Value::inverse() const {
 Value Value::add(const Value& a, const Value& b) {
   if (a.m_undef || b.m_undef) return undefined();
   if (a.isExact() && b.isExact()) {
-    return fromFraction128(
-        (__int128)a.m_num * b.m_den + (__int128)b.m_num * a.m_den,
-        (__int128)a.m_den * b.m_den);
+    int64_t left, right, num, den;
+    if (!mulOverflow(a.m_num, b.m_den, &left) &&
+        !mulOverflow(b.m_num, a.m_den, &right) &&
+        !addOverflow(left, right, &num) &&
+        !mulOverflow(a.m_den, b.m_den, &den)) {
+      return rational(num, den);
+    }
   }
   return real(a.toDouble() + b.toDouble());
 }
@@ -114,8 +95,11 @@ Value Value::sub(const Value& a, const Value& b) {
 Value Value::mul(const Value& a, const Value& b) {
   if (a.m_undef || b.m_undef) return undefined();
   if (a.isExact() && b.isExact()) {
-    return fromFraction128((__int128)a.m_num * b.m_num,
-                           (__int128)a.m_den * b.m_den);
+    int64_t num, den;
+    if (!mulOverflow(a.m_num, b.m_num, &num) &&
+        !mulOverflow(a.m_den, b.m_den, &den)) {
+      return rational(num, den);
+    }
   }
   return real(a.toDouble() * b.toDouble());
 }
@@ -124,8 +108,11 @@ Value Value::div(const Value& a, const Value& b) {
   if (a.m_undef || b.m_undef) return undefined();
   if (a.isExact() && b.isExact()) {
     if (b.m_num == 0) return undefined();
-    return fromFraction128((__int128)a.m_num * b.m_den,
-                           (__int128)a.m_den * b.m_num);
+    int64_t num, den;
+    if (!mulOverflow(a.m_num, b.m_den, &num) &&
+        !mulOverflow(a.m_den, b.m_num, &den)) {
+      return rational(num, den);
+    }
   }
   double d = b.toDouble();
   if (d == 0.0) return undefined();
@@ -134,22 +121,23 @@ Value Value::div(const Value& a, const Value& b) {
 
 Value Value::pow(const Value& a, const Value& b) {
   if (a.m_undef || b.m_undef) return undefined();
-  // Exact when the exponent is an integer that fits a reasonable range.
+  // Exact when the exponent is an integer in a reasonable range.
   if (a.isExact() && b.isExact() && b.m_den == 1 && b.m_num <= 63 &&
       b.m_num >= -63) {
     int64_t e = b.m_num;
     bool negativeExponent = e < 0;
     if (negativeExponent) e = -e;
-    __int128 num = 1, den = 1;
-    for (int64_t i = 0; i < e; i++) {
-      num *= a.m_num;
-      den *= a.m_den;
-      if (!fitsInt64(num) || !fitsInt64(den)) {
-        return real(::pow(a.toDouble(), b.toDouble()));
-      }
+    int64_t num = 1, den = 1;
+    bool overflow = false;
+    for (int64_t i = 0; i < e && !overflow; i++) {
+      overflow = mulOverflow(num, a.m_num, &num) ||
+                 mulOverflow(den, a.m_den, &den);
+    }
+    if (!overflow) {
+      Value result = rational(num, den);
+      return negativeExponent ? result.inverse() : result;
     }
-    Value result = fromFraction128(num, den);
-    return negativeExponent ? result.inverse() : result;
+    return real(::pow(a.toDouble(), b.toDouble()));
   }
   double base = a.toDouble();
   double exp = b.toDouble();