py/smallint: Update mp_small_int_mul_overflow() to perform the multiply.

projectgus · projectgus · commit 5b58624b6e22 · 2025-07-17T13:49:41.000+10:00
Makes it compatible with the __builtin_mul_overflow() syntax, used in
follow-up commit.

Includes optimisation in runtime.c to minimise the code size impact from
additional param.

Signed-off-by: Damien George &lt;damien@micropython.org&gt;
Signed-off-by: Angus Gratton &lt;angus@redyak.com.au&gt;
diff --git a/py/parsenum.c b/py/parsenum.c
@@ -99,10 +99,10 @@ mp_obj_t mp_parse_num_integer(const char *restrict str_, size_t len, int base, m
         }
 
         // add next digi and check for overflow
-        if (mp_small_int_mul_overflow(int_val, base)) {
+        if (mp_small_int_mul_overflow(int_val, base, &int_val)) {
             goto overflow;
         }
-        int_val = int_val * base + dig;
+        int_val += dig;
         if (!MP_SMALL_INT_FITS(int_val)) {
             goto overflow;
         }
diff --git a/py/runtime.c b/py/runtime.c
@@ -505,13 +505,14 @@ mp_obj_t MICROPY_WRAP_MP_BINARY_OP(mp_binary_op)(mp_binary_op_t op, mp_obj_t lhs
                     }
                     #endif
 
-                    if (mp_small_int_mul_overflow(lhs_val, rhs_val)) {
+                    mp_int_t int_res;
+                    if (mp_small_int_mul_overflow(lhs_val, rhs_val, &int_res)) {
                         // use higher precision
                         lhs = mp_obj_new_int_from_ll(lhs_val);
                         goto generic_binary_op;
                     } else {
                         // use standard precision
-                        return MP_OBJ_NEW_SMALL_INT(lhs_val * rhs_val);
+                        return MP_OBJ_NEW_SMALL_INT(int_res);
                     }
                 }
                 case MP_BINARY_OP_FLOOR_DIVIDE:
@@ -552,19 +553,19 @@ mp_obj_t MICROPY_WRAP_MP_BINARY_OP(mp_binary_op)(mp_binary_op_t op, mp_obj_t lhs
                         mp_int_t ans = 1;
                         while (rhs_val > 0) {
                             if (rhs_val & 1) {
-                                if (mp_small_int_mul_overflow(ans, lhs_val)) {
+                                if (mp_small_int_mul_overflow(ans, lhs_val, &ans)) {
                                     goto power_overflow;
                                 }
-                                ans *= lhs_val;
                             }
                             if (rhs_val == 1) {
                                 break;
                             }
                             rhs_val /= 2;
-                            if (mp_small_int_mul_overflow(lhs_val, lhs_val)) {
+                            mp_int_t int_res;
+                            if (mp_small_int_mul_overflow(lhs_val, lhs_val, &int_res)) {
                                 goto power_overflow;
                             }
-                            lhs_val *= lhs_val;
+                            lhs_val = int_res;
                         }
                         lhs_val = ans;
                     }
diff --git a/py/smallint.c b/py/smallint.c
@@ -26,7 +26,7 @@
 
 #include "py/smallint.h"
 
-bool mp_small_int_mul_overflow(mp_int_t x, mp_int_t y) {
+bool mp_small_int_mul_overflow(mp_int_t x, mp_int_t y, mp_int_t *res) {
     // Check for multiply overflow; see CERT INT32-C
     if (x > 0) { // x is positive
         if (y > 0) { // x and y are positive
@@ -49,6 +49,9 @@ bool mp_small_int_mul_overflow(mp_int_t x, mp_int_t y) {
             }
         } // End if x and y are nonpositive
     } // End if x is nonpositive
+
+    // Result doesn't overflow
+    *res = x * y;
     return false;
 }
 
diff --git a/py/smallint.h b/py/smallint.h
@@ -68,7 +68,10 @@
 // The number of bits in a MP_SMALL_INT including the sign bit.
 #define MP_SMALL_INT_BITS (MP_IMAX_BITS(MP_SMALL_INT_MAX) + 1)
 
-bool mp_small_int_mul_overflow(mp_int_t x, mp_int_t y);
+// Multiply two small ints.
+// If returns false, the correct result is stored in 'res'
+// If returns true, the multiplication would have overflowed. 'res' is unchanged.
+bool mp_small_int_mul_overflow(mp_int_t x, mp_int_t y, mp_int_t *res);
 mp_int_t mp_small_int_modulo(mp_int_t dividend, mp_int_t divisor);
 mp_int_t mp_small_int_floor_divide(mp_int_t num, mp_int_t denom);
 

Original file line number	Diff line number	Diff line change
`@@ -99,10 +99,10 @@ mp_obj_t mp_parse_num_integer(const char *restrict str_, size_t len, int base, m`
`99`	`99`	`}`
`100`	`100`
`101`	`101`	`// add next digi and check for overflow`
`102`		`- if (mp_small_int_mul_overflow(int_val, base)) {`
	`102`	`+ if (mp_small_int_mul_overflow(int_val, base, &int_val)) {`
`103`	`103`	`goto overflow;`
`104`	`104`	`}`
`105`		`- int_val = int_val * base + dig;`
	`105`	`+ int_val += dig;`
`106`	`106`	`if (!MP_SMALL_INT_FITS(int_val)) {`
`107`	`107`	`goto overflow;`
`108`	`108`	`}`
Original file line number	Diff line number	Diff line change
`@@ -505,13 +505,14 @@ mp_obj_t MICROPY_WRAP_MP_BINARY_OP(mp_binary_op)(mp_binary_op_t op, mp_obj_t lhs`
`505`	`505`	`}`
`506`	`506`	`#endif`
`507`	`507`
`508`		`- if (mp_small_int_mul_overflow(lhs_val, rhs_val)) {`
	`508`	`+ mp_int_t int_res;`
	`509`	`+ if (mp_small_int_mul_overflow(lhs_val, rhs_val, &int_res)) {`
`509`	`510`	`// use higher precision`
`510`	`511`	`lhs = mp_obj_new_int_from_ll(lhs_val);`
`511`	`512`	`goto generic_binary_op;`
`512`	`513`	`} else {`
`513`	`514`	`// use standard precision`
`514`		`- return MP_OBJ_NEW_SMALL_INT(lhs_val * rhs_val);`
	`515`	`+ return MP_OBJ_NEW_SMALL_INT(int_res);`
`515`	`516`	`}`
`516`	`517`	`}`
`517`	`518`	`case MP_BINARY_OP_FLOOR_DIVIDE:`
`@@ -552,19 +553,19 @@ mp_obj_t MICROPY_WRAP_MP_BINARY_OP(mp_binary_op)(mp_binary_op_t op, mp_obj_t lhs`
`552`	`553`	`mp_int_t ans = 1;`
`553`	`554`	`while (rhs_val > 0) {`
`554`	`555`	`if (rhs_val & 1) {`
`555`		`- if (mp_small_int_mul_overflow(ans, lhs_val)) {`
	`556`	`+ if (mp_small_int_mul_overflow(ans, lhs_val, &ans)) {`
`556`	`557`	`goto power_overflow;`
`557`	`558`	`}`
`558`		`- ans *= lhs_val;`
`559`	`559`	`}`
`560`	`560`	`if (rhs_val == 1) {`
`561`	`561`	`break;`
`562`	`562`	`}`
`563`	`563`	`rhs_val /= 2;`
`564`		`- if (mp_small_int_mul_overflow(lhs_val, lhs_val)) {`
	`564`	`+ mp_int_t int_res;`
	`565`	`+ if (mp_small_int_mul_overflow(lhs_val, lhs_val, &int_res)) {`
`565`	`566`	`goto power_overflow;`
`566`	`567`	`}`
`567`		`- lhs_val *= lhs_val;`
	`568`	`+ lhs_val = int_res;`
`568`	`569`	`}`
`569`	`570`	`lhs_val = ans;`
`570`	`571`	`}`