intn: remove redundant mn suffix: e.g.: addmn -> add

bettio · bettio · commit 38cdd9bc4418 · 2025-10-25T16:53:40.000+02:00
Names with `mn` prefix were less readable.

Signed-off-by: Davide Bettio &lt;davide@uninstall.it&gt;
diff --git a/src/libAtomVM/bif.c b/src/libAtomVM/bif.c
@@ -568,7 +568,7 @@ static term add_maybe_bigint(Context *ctx, uint32_t fail_label, uint32_t live, t
 
     intn_digit_t bigres[INTN_MAX_RES_LEN];
     intn_integer_sign_t res_sign;
-    bigres_len = intn_addmn(bn1, bn1_len, bn1_sign, bn2, bn2_len, bn2_sign, bigres, &res_sign);
+    bigres_len = intn_add(bn1, bn1_len, bn1_sign, bn2, bn2_len, bn2_sign, bigres, &res_sign);
 
     return make_bigint(ctx, fail_label, live, bigres, bigres_len, res_sign);
 }
@@ -706,7 +706,7 @@ static term sub_maybe_bigint(Context *ctx, uint32_t fail_label, uint32_t live, t
 
     intn_digit_t bigres[INTN_MAX_RES_LEN];
     intn_integer_sign_t res_sign;
-    bigres_len = intn_submn(bn1, bn1_len, bn1_sign, bn2, bn2_len, bn2_sign, bigres, &res_sign);
+    bigres_len = intn_sub(bn1, bn1_len, bn1_sign, bn2, bn2_len, bn2_sign, bigres, &res_sign);
 
     return make_bigint(ctx, fail_label, live, bigres, bigres_len, res_sign);
 }
@@ -887,7 +887,7 @@ static term mul_maybe_bigint(Context *ctx, uint32_t fail_label, uint32_t live, t
 
     intn_digit_t bigres[INTN_MAX_RES_LEN];
     intn_integer_sign_t res_sign;
-    intn_mulmn(bn1, bn1_len, bn1_sign, bn2, bn2_len, bn2_sign, bigres, &res_sign);
+    intn_mul(bn1, bn1_len, bn1_sign, bn2, bn2_len, bn2_sign, bigres, &res_sign);
 
     return make_bigint(ctx, fail_label, live, bigres, bigres_len, res_sign);
 }
@@ -1055,7 +1055,7 @@ static term div_maybe_bigint(Context *ctx, uint32_t fail_label, uint32_t live, t
 
     intn_digit_t bigres[INTN_MAX_RES_LEN];
     intn_integer_sign_t res_sign;
-    size_t bigres_len = intn_divmn(bn1, bn1_len, bn1_sign, bn2, bn2_len, bn2_sign, bigres, &res_sign, NULL, NULL);
+    size_t bigres_len = intn_div(bn1, bn1_len, bn1_sign, bn2, bn2_len, bn2_sign, bigres, &res_sign, NULL, NULL);
 
     return make_bigint(ctx, fail_label, live, bigres, bigres_len, res_sign);
 }
@@ -1377,7 +1377,7 @@ static term rem_maybe_bigint(Context *ctx, uint32_t fail_label, uint32_t live, t
     intn_digit_t q[INTN_MAX_RES_LEN];
     intn_digit_t bigres[INTN_MAX_RES_LEN];
     size_t bigres_len;
-    intn_divmnu(bn1, bn1_len, bn2, bn2_len, q, bigres, &bigres_len);
+    intn_divu(bn1, bn1_len, bn2, bn2_len, q, bigres, &bigres_len);
 
     return make_bigint(ctx, fail_label, live, bigres, bigres_len, bn1_sign);
 }
@@ -1649,7 +1649,7 @@ term bif_erlang_bor_2(Context *ctx, uint32_t fail_label, int live, term arg1, te
     if (LIKELY(term_is_integer(arg1) && term_is_integer(arg2))) {
         return arg1 | arg2;
     } else {
-        return bitwise_helper(ctx, fail_label, live, arg1, arg2, bor, intn_bormn);
+        return bitwise_helper(ctx, fail_label, live, arg1, arg2, bor, intn_bor);
     }
 }
 
@@ -1663,7 +1663,7 @@ term bif_erlang_band_2(Context *ctx, uint32_t fail_label, int live, term arg1, t
     if (LIKELY(term_is_integer(arg1) && term_is_integer(arg2))) {
         return arg1 & arg2;
     } else {
-        return bitwise_helper(ctx, fail_label, live, arg1, arg2, band, intn_bandmn);
+        return bitwise_helper(ctx, fail_label, live, arg1, arg2, band, intn_band);
     }
 }
 
@@ -1677,7 +1677,7 @@ term bif_erlang_bxor_2(Context *ctx, uint32_t fail_label, int live, term arg1, t
     if (LIKELY(term_is_integer(arg1) && term_is_integer(arg2))) {
         return (arg1 ^ arg2) | TERM_INTEGER_TAG;
     } else {
-        return bitwise_helper(ctx, fail_label, live, arg1, arg2, bxor, intn_bxormn);
+        return bitwise_helper(ctx, fail_label, live, arg1, arg2, bxor, intn_bxor);
     }
 }
 
diff --git a/src/libAtomVM/intn.c b/src/libAtomVM/intn.c
@@ -122,7 +122,7 @@ static void mulmnu32(const uint32_t u[], size_t m, const uint32_t v[], size_t n,
     */
 }
 
-void intn_mulmnu(const uint32_t m[], size_t m_len, const uint32_t n[], size_t n_len, uint32_t out[])
+void intn_mulu(const uint32_t m[], size_t m_len, const uint32_t n[], size_t n_len, uint32_t out[])
 {
     mulmnu32(m, m_len, n, n_len, out);
 }
@@ -175,7 +175,7 @@ static void mulmnu16(const uint16_t u[], size_t m, const uint16_t v[], size_t n,
     */
 }
 
-void intn_mulmnu(const uint32_t m[], size_t m_len, const uint32_t n[], size_t n_len, uint32_t out[])
+void intn_mulu(const uint32_t m[], size_t m_len, const uint32_t n[], size_t n_len, uint32_t out[])
 {
 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
     mulmnu16((const uint16_t *) m, m_len * 2, (const uint16_t *) n, n_len * 2, (uint16_t *) out);
@@ -198,7 +198,7 @@ void intn_mul_int64(int64_t num1, int64_t num2, intn_digit_t *out, intn_integer_
     intn_from_int64(num2, v, &v_sign);
 
     *out_sign = intn_muldiv_sign(u_sign, v_sign);
-    intn_mulmnu(u, 2, v, 2, (uint32_t *) out);
+    intn_mulu(u, 2, v, 2, (uint32_t *) out);
 }
 
 /*
@@ -384,7 +384,7 @@ static void big_endian_uint16_to_digit_in_place(uint16_t num16[], size_t len16)
 }
 #endif
 
-size_t intn_divmnu(const intn_digit_t m[], size_t m_len, const intn_digit_t n[], size_t n_len,
+size_t intn_divu(const intn_digit_t m[], size_t m_len, const intn_digit_t n[], size_t n_len,
     intn_digit_t q_out[], intn_digit_t r_out[], size_t *r_out_len)
 {
     uint16_t *u;
@@ -458,7 +458,7 @@ int intn_cmp(const intn_digit_t a[], size_t a_len, const intn_digit_t b[], size_
     return 0;
 }
 
-size_t intn_addmnu(
+size_t intn_addu(
     const intn_digit_t a[], size_t a_len, const intn_digit_t b[], size_t b_len, intn_digit_t out[])
 {
     size_t n = MIN(a_len, b_len);
@@ -502,7 +502,7 @@ size_t intn_addmnu(
     return i;
 }
 
-size_t intn_addmn(const intn_digit_t m[], size_t m_len, intn_integer_sign_t m_sign,
+size_t intn_add(const intn_digit_t m[], size_t m_len, intn_integer_sign_t m_sign,
     const intn_digit_t n[], size_t n_len, intn_integer_sign_t n_sign, intn_digit_t out[],
     intn_integer_sign_t *out_sign)
 {
@@ -511,19 +511,19 @@ size_t intn_addmn(const intn_digit_t m[], size_t m_len, intn_integer_sign_t m_si
     // Case 1: Same sign - add magnitudes, keep sign
     if (m_sign == n_sign) {
         *out_sign = m_sign;
-        result_len = intn_addmnu(m, m_len, n, n_len, out);
+        result_len = intn_addu(m, m_len, n, n_len, out);
     }
     // Case 2: Different signs - subtract smaller from larger
     else {
         int cmp = intn_cmp(m, m_len, n, n_len);
         if (cmp >= 0) {
             // |m| >= |n|, result takes sign of m
             *out_sign = m_sign;
-            result_len = intn_submnu(m, m_len, n, n_len, out);
+            result_len = intn_subu(m, m_len, n, n_len, out);
         } else {
             // |m| < |n|, result takes sign of n
             *out_sign = n_sign;
-            result_len = intn_submnu(n, n_len, m, m_len, out);
+            result_len = intn_subu(n, n_len, m, m_len, out);
         }
     }
 
@@ -544,12 +544,12 @@ size_t intn_add_int64(int64_t num1, int64_t num2, intn_digit_t *out, intn_intege
     intn_integer_sign_t v_sign;
     intn_from_int64(num2, v, &v_sign);
 
-    return intn_addmn(u, 2, u_sign, v, 2, v_sign, out, out_sign);
+    return intn_add(u, 2, u_sign, v, 2, v_sign, out, out_sign);
 }
 
 // This function assumes a >= b
 // Caller must ensure this precondition
-size_t intn_submnu(
+size_t intn_subu(
     const intn_digit_t a[], size_t a_len, const intn_digit_t b[], size_t b_len, intn_digit_t out[])
 {
     uint32_t borrow = 0;
@@ -570,13 +570,13 @@ size_t intn_submnu(
     return i;
 }
 
-size_t intn_submn(const intn_digit_t m[], size_t m_len, intn_integer_sign_t m_sign,
+size_t intn_sub(const intn_digit_t m[], size_t m_len, intn_integer_sign_t m_sign,
     const intn_digit_t n[], size_t n_len, intn_integer_sign_t n_sign, intn_digit_t out[],
     intn_integer_sign_t *out_sign)
 {
     // m - n = m + (-n)
     // Just flip the sign of n and call addition
-    return intn_addmn(m, m_len, m_sign, n, n_len, intn_negate_sign(n_sign), out, out_sign);
+    return intn_add(m, m_len, m_sign, n, n_len, intn_negate_sign(n_sign), out, out_sign);
 }
 
 size_t intn_sub_int64(int64_t num1, int64_t num2, intn_digit_t *out, intn_integer_sign_t *out_sign)
@@ -588,7 +588,7 @@ size_t intn_sub_int64(int64_t num1, int64_t num2, intn_digit_t *out, intn_intege
     intn_integer_sign_t v_sign;
     intn_from_int64(num2, v, &v_sign);
 
-    return intn_submn(u, 2, u_sign, v, 2, v_sign, out, out_sign);
+    return intn_sub(u, 2, u_sign, v, 2, v_sign, out, out_sign);
 }
 
 static void neg(const intn_digit_t in[], size_t in_len, intn_digit_t out[])
@@ -692,7 +692,7 @@ static inline intn_digit_t digit_bor(intn_digit_t a, intn_digit_t b)
     return a | b;
 }
 
-size_t intn_bormn(const intn_digit_t m[], size_t m_len, intn_integer_sign_t m_sign,
+size_t intn_bor(const intn_digit_t m[], size_t m_len, intn_integer_sign_t m_sign,
     const intn_digit_t n[], size_t n_len, intn_integer_sign_t n_sign, intn_digit_t out[],
     intn_integer_sign_t *out_sign)
 {
@@ -719,7 +719,7 @@ static inline intn_digit_t digit_band(intn_digit_t a, intn_digit_t b)
     return a & b;
 }
 
-size_t intn_bandmn(const intn_digit_t m[], size_t m_len, intn_integer_sign_t m_sign,
+size_t intn_band(const intn_digit_t m[], size_t m_len, intn_integer_sign_t m_sign,
     const intn_digit_t n[], size_t n_len, intn_integer_sign_t n_sign, intn_digit_t out[],
     intn_integer_sign_t *out_sign)
 {
@@ -746,7 +746,7 @@ static inline intn_digit_t digit_bxor(intn_digit_t a, intn_digit_t b)
     return a ^ b;
 }
 
-size_t intn_bxormn(const intn_digit_t m[], size_t m_len, intn_integer_sign_t m_sign,
+size_t intn_bxor(const intn_digit_t m[], size_t m_len, intn_integer_sign_t m_sign,
     const intn_digit_t n[], size_t n_len, intn_integer_sign_t n_sign, intn_digit_t out[],
     intn_integer_sign_t *out_sign)
 {
@@ -1113,7 +1113,7 @@ int intn_parse(
             intn_digit_t mult[2];
             ipow(base, parsed_digits, mult);
             // TODO: check overflows
-            intn_mulmnu(out, out_len, mult, 2, new_out);
+            intn_mulu(out, out_len, mult, 2, new_out);
             new_out_len = MAX(2, intn_count_digits(new_out, INTN_MUL_OUT_LEN(out_len, 2)));
             if (UNLIKELY(out_len > INTN_MAX_IN_LEN)) {
                 assert(out_len <= INTN_MAX_RES_LEN);
@@ -1127,7 +1127,7 @@ int intn_parse(
         intn_digit_t parsed_as_intn[2];
         intn_from_int64(parsed_chunk, parsed_as_intn, &ignored_sign);
 
-        out_len = intn_addmnu(new_out, new_out_len, parsed_as_intn, 2, out);
+        out_len = intn_addu(new_out, new_out_len, parsed_as_intn, 2, out);
         if (UNLIKELY(out_len > INTN_MAX_IN_LEN)) {
             assert(out_len <= INTN_MAX_RES_LEN);
             // we are above the allowed 256 bits, so it is going to be overflow
diff --git a/src/libAtomVM/intn.h b/src/libAtomVM/intn.h
@@ -76,19 +76,19 @@ typedef uint32_t intn_digit_t;
 
 int intn_cmp(const intn_digit_t a[], size_t a_len, const intn_digit_t b[], size_t b_len);
 
-size_t intn_addmnu(
+size_t intn_addu(
     const intn_digit_t a[], size_t a_len, const intn_digit_t b[], size_t b_len, intn_digit_t out[]);
 
-size_t intn_addmn(const intn_digit_t m[], size_t m_len, intn_integer_sign_t m_sign,
+size_t intn_add(const intn_digit_t m[], size_t m_len, intn_integer_sign_t m_sign,
     const intn_digit_t n[], size_t n_len, intn_integer_sign_t n_sign, intn_digit_t out[],
     intn_integer_sign_t *out_sign);
 
 size_t intn_add_int64(int64_t num1, int64_t num2, intn_digit_t *out, intn_integer_sign_t *out_sign);
 
-size_t intn_submnu(
+size_t intn_subu(
     const intn_digit_t a[], size_t a_len, const intn_digit_t b[], size_t b_len, intn_digit_t out[]);
 
-size_t intn_submn(const intn_digit_t m[], size_t m_len, intn_integer_sign_t m_sign,
+size_t intn_sub(const intn_digit_t m[], size_t m_len, intn_integer_sign_t m_sign,
     const intn_digit_t n[], size_t n_len, intn_integer_sign_t n_sign, intn_digit_t out[],
     intn_integer_sign_t *out_sign);
 
@@ -99,39 +99,39 @@ static inline intn_integer_sign_t intn_muldiv_sign(intn_integer_sign_t s1, intn_
     return (intn_integer_sign_t) ((unsigned int) s1 ^ (unsigned int) s2) & IntNNegativeInteger;
 }
 
-void intn_mulmnu(
+void intn_mulu(
     const intn_digit_t m[], size_t m_len, const intn_digit_t n[], size_t n_len, intn_digit_t out[]);
 
-static inline void intn_mulmn(const intn_digit_t m[], size_t m_len, intn_integer_sign_t m_sign,
+static inline void intn_mul(const intn_digit_t m[], size_t m_len, intn_integer_sign_t m_sign,
     const intn_digit_t n[], size_t n_len, intn_integer_sign_t n_sign, intn_digit_t out[],
     intn_integer_sign_t *out_sign)
 {
     *out_sign = intn_muldiv_sign(m_sign, n_sign);
-    intn_mulmnu(m, m_len, n, n_len, out);
+    intn_mulu(m, m_len, n, n_len, out);
 }
 
 void intn_mul_int64(int64_t num1, int64_t num2, intn_digit_t *out, intn_integer_sign_t *out_sign);
 
-size_t intn_divmnu(const intn_digit_t m[], size_t m_len, const intn_digit_t n[], size_t n_len,
+size_t intn_divu(const intn_digit_t m[], size_t m_len, const intn_digit_t n[], size_t n_len,
     intn_digit_t q_out[], intn_digit_t r_out[], size_t *r_out_len);
 
-static inline size_t intn_divmn(const intn_digit_t m[], size_t m_len, intn_integer_sign_t m_sign,
+static inline size_t intn_div(const intn_digit_t m[], size_t m_len, intn_integer_sign_t m_sign,
     const intn_digit_t n[], size_t n_len, intn_integer_sign_t n_sign, intn_digit_t q_out[],
     intn_integer_sign_t *qout_sign, intn_digit_t r_out[], size_t *r_out_len)
 {
     *qout_sign = intn_muldiv_sign(m_sign, n_sign);
-    return intn_divmnu(m, m_len, n, n_len, q_out, r_out, r_out_len);
+    return intn_divu(m, m_len, n, n_len, q_out, r_out, r_out_len);
 }
 
-size_t intn_bormn(const intn_digit_t m[], size_t m_len, intn_integer_sign_t m_sign,
+size_t intn_bor(const intn_digit_t m[], size_t m_len, intn_integer_sign_t m_sign,
     const intn_digit_t n[], size_t n_len, intn_integer_sign_t n_sign, intn_digit_t out[],
     intn_integer_sign_t *out_sign);
 
-size_t intn_bandmn(const intn_digit_t m[], size_t m_len, intn_integer_sign_t m_sign,
+size_t intn_band(const intn_digit_t m[], size_t m_len, intn_integer_sign_t m_sign,
     const intn_digit_t n[], size_t n_len, intn_integer_sign_t n_sign, intn_digit_t out[],
     intn_integer_sign_t *out_sign);
 
-size_t intn_bxormn(const intn_digit_t m[], size_t m_len, intn_integer_sign_t m_sign,
+size_t intn_bxor(const intn_digit_t m[], size_t m_len, intn_integer_sign_t m_sign,
     const intn_digit_t n[], size_t n_len, intn_integer_sign_t n_sign, intn_digit_t out[],
     intn_integer_sign_t *out_sign);
 
@@ -140,8 +140,8 @@ size_t intn_bnot(const intn_digit_t m[], size_t m_len, intn_integer_sign_t m_sig
 
 size_t intn_bsl(const intn_digit_t num[], size_t len, size_t n, intn_digit_t *out);
 
-size_t intn_bsr(
-    const intn_digit_t num[], size_t len, intn_integer_sign_t num_sign, size_t n, intn_digit_t *out);
+size_t intn_bsr(const intn_digit_t num[], size_t len, intn_integer_sign_t num_sign, size_t n,
+    intn_digit_t *out);
 
 size_t intn_count_digits(const intn_digit_t *num, size_t num_len);
 

Original file line number	Diff line number	Diff line change
`@@ -568,7 +568,7 @@ static term add_maybe_bigint(Context *ctx, uint32_t fail_label, uint32_t live, t`
`568`	`568`
`569`	`569`	`intn_digit_t bigres[INTN_MAX_RES_LEN];`
`570`	`570`	`intn_integer_sign_t res_sign;`
`571`		`- bigres_len = intn_addmn(bn1, bn1_len, bn1_sign, bn2, bn2_len, bn2_sign, bigres, &res_sign);`
	`571`	`+ bigres_len = intn_add(bn1, bn1_len, bn1_sign, bn2, bn2_len, bn2_sign, bigres, &res_sign);`
`572`	`572`
`573`	`573`	`return make_bigint(ctx, fail_label, live, bigres, bigres_len, res_sign);`
`574`	`574`	`}`
`@@ -706,7 +706,7 @@ static term sub_maybe_bigint(Context *ctx, uint32_t fail_label, uint32_t live, t`
`706`	`706`
`707`	`707`	`intn_digit_t bigres[INTN_MAX_RES_LEN];`
`708`	`708`	`intn_integer_sign_t res_sign;`
`709`		`- bigres_len = intn_submn(bn1, bn1_len, bn1_sign, bn2, bn2_len, bn2_sign, bigres, &res_sign);`
	`709`	`+ bigres_len = intn_sub(bn1, bn1_len, bn1_sign, bn2, bn2_len, bn2_sign, bigres, &res_sign);`
`710`	`710`
`711`	`711`	`return make_bigint(ctx, fail_label, live, bigres, bigres_len, res_sign);`
`712`	`712`	`}`
`@@ -887,7 +887,7 @@ static term mul_maybe_bigint(Context *ctx, uint32_t fail_label, uint32_t live, t`
`887`	`887`
`888`	`888`	`intn_digit_t bigres[INTN_MAX_RES_LEN];`
`889`	`889`	`intn_integer_sign_t res_sign;`
`890`		`- intn_mulmn(bn1, bn1_len, bn1_sign, bn2, bn2_len, bn2_sign, bigres, &res_sign);`
	`890`	`+ intn_mul(bn1, bn1_len, bn1_sign, bn2, bn2_len, bn2_sign, bigres, &res_sign);`
`891`	`891`
`892`	`892`	`return make_bigint(ctx, fail_label, live, bigres, bigres_len, res_sign);`
`893`	`893`	`}`
`@@ -1055,7 +1055,7 @@ static term div_maybe_bigint(Context *ctx, uint32_t fail_label, uint32_t live, t`
`1055`	`1055`
`1056`	`1056`	`intn_digit_t bigres[INTN_MAX_RES_LEN];`
`1057`	`1057`	`intn_integer_sign_t res_sign;`
`1058`		`- size_t bigres_len = intn_divmn(bn1, bn1_len, bn1_sign, bn2, bn2_len, bn2_sign, bigres, &res_sign, NULL, NULL);`
	`1058`	`+ size_t bigres_len = intn_div(bn1, bn1_len, bn1_sign, bn2, bn2_len, bn2_sign, bigres, &res_sign, NULL, NULL);`
`1059`	`1059`
`1060`	`1060`	`return make_bigint(ctx, fail_label, live, bigres, bigres_len, res_sign);`
`1061`	`1061`	`}`
`@@ -1377,7 +1377,7 @@ static term rem_maybe_bigint(Context *ctx, uint32_t fail_label, uint32_t live, t`
`1377`	`1377`	`intn_digit_t q[INTN_MAX_RES_LEN];`
`1378`	`1378`	`intn_digit_t bigres[INTN_MAX_RES_LEN];`
`1379`	`1379`	`size_t bigres_len;`
`1380`		`- intn_divmnu(bn1, bn1_len, bn2, bn2_len, q, bigres, &bigres_len);`
	`1380`	`+ intn_divu(bn1, bn1_len, bn2, bn2_len, q, bigres, &bigres_len);`
`1381`	`1381`
`1382`	`1382`	`return make_bigint(ctx, fail_label, live, bigres, bigres_len, bn1_sign);`
`1383`	`1383`	`}`
`@@ -1649,7 +1649,7 @@ term bif_erlang_bor_2(Context *ctx, uint32_t fail_label, int live, term arg1, te`
`1649`	`1649`	`if (LIKELY(term_is_integer(arg1) && term_is_integer(arg2))) {`
`1650`	`1650`	`return arg1 \| arg2;`
`1651`	`1651`	`} else {`
`1652`		`- return bitwise_helper(ctx, fail_label, live, arg1, arg2, bor, intn_bormn);`
	`1652`	`+ return bitwise_helper(ctx, fail_label, live, arg1, arg2, bor, intn_bor);`
`1653`	`1653`	`}`
`1654`	`1654`	`}`
`1655`	`1655`
`@@ -1663,7 +1663,7 @@ term bif_erlang_band_2(Context *ctx, uint32_t fail_label, int live, term arg1, t`
`1663`	`1663`	`if (LIKELY(term_is_integer(arg1) && term_is_integer(arg2))) {`
`1664`	`1664`	`return arg1 & arg2;`
`1665`	`1665`	`} else {`
`1666`		`- return bitwise_helper(ctx, fail_label, live, arg1, arg2, band, intn_bandmn);`
	`1666`	`+ return bitwise_helper(ctx, fail_label, live, arg1, arg2, band, intn_band);`
`1667`	`1667`	`}`
`1668`	`1668`	`}`
`1669`	`1669`
`@@ -1677,7 +1677,7 @@ term bif_erlang_bxor_2(Context *ctx, uint32_t fail_label, int live, term arg1, t`
`1677`	`1677`	`if (LIKELY(term_is_integer(arg1) && term_is_integer(arg2))) {`
`1678`	`1678`	`return (arg1 ^ arg2) \| TERM_INTEGER_TAG;`
`1679`	`1679`	`} else {`
`1680`		`- return bitwise_helper(ctx, fail_label, live, arg1, arg2, bxor, intn_bxormn);`
	`1680`	`+ return bitwise_helper(ctx, fail_label, live, arg1, arg2, bxor, intn_bxor);`
`1681`	`1681`	`}`
`1682`	`1682`	`}`
`1683`	`1683`
Original file line number	Diff line number	Diff line change
`@@ -122,7 +122,7 @@ static void mulmnu32(const uint32_t u[], size_t m, const uint32_t v[], size_t n,`
`122`	`122`	`*/`
`123`	`123`	`}`
`124`	`124`
`125`		`-void intn_mulmnu(const uint32_t m[], size_t m_len, const uint32_t n[], size_t n_len, uint32_t out[])`
	`125`	`+void intn_mulu(const uint32_t m[], size_t m_len, const uint32_t n[], size_t n_len, uint32_t out[])`
`126`	`126`	`{`
`127`	`127`	`mulmnu32(m, m_len, n, n_len, out);`
`128`	`128`	`}`
`@@ -175,7 +175,7 @@ static void mulmnu16(const uint16_t u[], size_t m, const uint16_t v[], size_t n,`
`175`	`175`	`*/`
`176`	`176`	`}`
`177`	`177`
`178`		`-void intn_mulmnu(const uint32_t m[], size_t m_len, const uint32_t n[], size_t n_len, uint32_t out[])`
	`178`	`+void intn_mulu(const uint32_t m[], size_t m_len, const uint32_t n[], size_t n_len, uint32_t out[])`
`179`	`179`	`{`
`180`	`180`	`#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__`
`181`	`181`	`mulmnu16((const uint16_t ) m, m_len 2, (const uint16_t ) n, n_len 2, (uint16_t *) out);`
`@@ -198,7 +198,7 @@ void intn_mul_int64(int64_t num1, int64_t num2, intn_digit_t *out, intn_integer_`
`198`	`198`	`intn_from_int64(num2, v, &v_sign);`
`199`	`199`
`200`	`200`	`*out_sign = intn_muldiv_sign(u_sign, v_sign);`
`201`		`- intn_mulmnu(u, 2, v, 2, (uint32_t *) out);`
	`201`	`+ intn_mulu(u, 2, v, 2, (uint32_t *) out);`
`202`	`202`	`}`
`203`	`203`
`204`	`204`	`/*`
`@@ -384,7 +384,7 @@ static void big_endian_uint16_to_digit_in_place(uint16_t num16[], size_t len16)`
`384`	`384`	`}`
`385`	`385`	`#endif`
`386`	`386`
`387`		`-size_t intn_divmnu(const intn_digit_t m[], size_t m_len, const intn_digit_t n[], size_t n_len,`
	`387`	`+size_t intn_divu(const intn_digit_t m[], size_t m_len, const intn_digit_t n[], size_t n_len,`
`388`	`388`	`intn_digit_t q_out[], intn_digit_t r_out[], size_t *r_out_len)`
`389`	`389`	`{`
`390`	`390`	`uint16_t *u;`
`@@ -458,7 +458,7 @@ int intn_cmp(const intn_digit_t a[], size_t a_len, const intn_digit_t b[], size_`
`458`	`458`	`return 0;`
`459`	`459`	`}`
`460`	`460`
`461`		`-size_t intn_addmnu(`
	`461`	`+size_t intn_addu(`
`462`	`462`	`const intn_digit_t a[], size_t a_len, const intn_digit_t b[], size_t b_len, intn_digit_t out[])`
`463`	`463`	`{`
`464`	`464`	`size_t n = MIN(a_len, b_len);`
`@@ -502,7 +502,7 @@ size_t intn_addmnu(`
`502`	`502`	`return i;`
`503`	`503`	`}`
`504`	`504`
`505`		`-size_t intn_addmn(const intn_digit_t m[], size_t m_len, intn_integer_sign_t m_sign,`
	`505`	`+size_t intn_add(const intn_digit_t m[], size_t m_len, intn_integer_sign_t m_sign,`
`506`	`506`	`const intn_digit_t n[], size_t n_len, intn_integer_sign_t n_sign, intn_digit_t out[],`
`507`	`507`	`intn_integer_sign_t *out_sign)`
`508`	`508`	`{`
`@@ -511,19 +511,19 @@ size_t intn_addmn(const intn_digit_t m[], size_t m_len, intn_integer_sign_t m_si`
`511`	`511`	`// Case 1: Same sign - add magnitudes, keep sign`
`512`	`512`	`if (m_sign == n_sign) {`
`513`	`513`	`*out_sign = m_sign;`
`514`		`- result_len = intn_addmnu(m, m_len, n, n_len, out);`
	`514`	`+ result_len = intn_addu(m, m_len, n, n_len, out);`
`515`	`515`	`}`
`516`	`516`	`// Case 2: Different signs - subtract smaller from larger`
`517`	`517`	`else {`
`518`	`518`	`int cmp = intn_cmp(m, m_len, n, n_len);`
`519`	`519`	`if (cmp >= 0) {`
`520`	`520`	`// \|m\| >= \|n\|, result takes sign of m`
`521`	`521`	`*out_sign = m_sign;`
`522`		`- result_len = intn_submnu(m, m_len, n, n_len, out);`
	`522`	`+ result_len = intn_subu(m, m_len, n, n_len, out);`
`523`	`523`	`} else {`
`524`	`524`	`// \|m\| < \|n\|, result takes sign of n`
`525`	`525`	`*out_sign = n_sign;`
`526`		`- result_len = intn_submnu(n, n_len, m, m_len, out);`
	`526`	`+ result_len = intn_subu(n, n_len, m, m_len, out);`
`527`	`527`	`}`
`528`	`528`	`}`
`529`	`529`
`@@ -544,12 +544,12 @@ size_t intn_add_int64(int64_t num1, int64_t num2, intn_digit_t *out, intn_intege`
`544`	`544`	`intn_integer_sign_t v_sign;`
`545`	`545`	`intn_from_int64(num2, v, &v_sign);`
`546`	`546`
`547`		`- return intn_addmn(u, 2, u_sign, v, 2, v_sign, out, out_sign);`
	`547`	`+ return intn_add(u, 2, u_sign, v, 2, v_sign, out, out_sign);`
`548`	`548`	`}`
`549`	`549`
`550`	`550`	`// This function assumes a >= b`
`551`	`551`	`// Caller must ensure this precondition`
`552`		`-size_t intn_submnu(`
	`552`	`+size_t intn_subu(`
`553`	`553`	`const intn_digit_t a[], size_t a_len, const intn_digit_t b[], size_t b_len, intn_digit_t out[])`
`554`	`554`	`{`
`555`	`555`	`uint32_t borrow = 0;`
`@@ -570,13 +570,13 @@ size_t intn_submnu(`
`570`	`570`	`return i;`
`571`	`571`	`}`
`572`	`572`
`573`		`-size_t intn_submn(const intn_digit_t m[], size_t m_len, intn_integer_sign_t m_sign,`
	`573`	`+size_t intn_sub(const intn_digit_t m[], size_t m_len, intn_integer_sign_t m_sign,`
`574`	`574`	`const intn_digit_t n[], size_t n_len, intn_integer_sign_t n_sign, intn_digit_t out[],`
`575`	`575`	`intn_integer_sign_t *out_sign)`
`576`	`576`	`{`
`577`	`577`	`// m - n = m + (-n)`
`578`	`578`	`// Just flip the sign of n and call addition`
`579`		`- return intn_addmn(m, m_len, m_sign, n, n_len, intn_negate_sign(n_sign), out, out_sign);`
	`579`	`+ return intn_add(m, m_len, m_sign, n, n_len, intn_negate_sign(n_sign), out, out_sign);`
`580`	`580`	`}`
`581`	`581`
`582`	`582`	`size_t intn_sub_int64(int64_t num1, int64_t num2, intn_digit_t out, intn_integer_sign_t out_sign)`
`@@ -588,7 +588,7 @@ size_t intn_sub_int64(int64_t num1, int64_t num2, intn_digit_t *out, intn_intege`
`588`	`588`	`intn_integer_sign_t v_sign;`
`589`	`589`	`intn_from_int64(num2, v, &v_sign);`
`590`	`590`
`591`		`- return intn_submn(u, 2, u_sign, v, 2, v_sign, out, out_sign);`
	`591`	`+ return intn_sub(u, 2, u_sign, v, 2, v_sign, out, out_sign);`
`592`	`592`	`}`
`593`	`593`
`594`	`594`	`static void neg(const intn_digit_t in[], size_t in_len, intn_digit_t out[])`
`@@ -692,7 +692,7 @@ static inline intn_digit_t digit_bor(intn_digit_t a, intn_digit_t b)`
`692`	`692`	`return a \| b;`
`693`	`693`	`}`
`694`	`694`
`695`		`-size_t intn_bormn(const intn_digit_t m[], size_t m_len, intn_integer_sign_t m_sign,`
	`695`	`+size_t intn_bor(const intn_digit_t m[], size_t m_len, intn_integer_sign_t m_sign,`
`696`	`696`	`const intn_digit_t n[], size_t n_len, intn_integer_sign_t n_sign, intn_digit_t out[],`
`697`	`697`	`intn_integer_sign_t *out_sign)`
`698`	`698`	`{`
`@@ -719,7 +719,7 @@ static inline intn_digit_t digit_band(intn_digit_t a, intn_digit_t b)`
`719`	`719`	`return a & b;`
`720`	`720`	`}`
`721`	`721`
`722`		`-size_t intn_bandmn(const intn_digit_t m[], size_t m_len, intn_integer_sign_t m_sign,`
	`722`	`+size_t intn_band(const intn_digit_t m[], size_t m_len, intn_integer_sign_t m_sign,`
`723`	`723`	`const intn_digit_t n[], size_t n_len, intn_integer_sign_t n_sign, intn_digit_t out[],`
`724`	`724`	`intn_integer_sign_t *out_sign)`
`725`	`725`	`{`
`@@ -746,7 +746,7 @@ static inline intn_digit_t digit_bxor(intn_digit_t a, intn_digit_t b)`
`746`	`746`	`return a ^ b;`
`747`	`747`	`}`
`748`	`748`
`749`		`-size_t intn_bxormn(const intn_digit_t m[], size_t m_len, intn_integer_sign_t m_sign,`
	`749`	`+size_t intn_bxor(const intn_digit_t m[], size_t m_len, intn_integer_sign_t m_sign,`
`750`	`750`	`const intn_digit_t n[], size_t n_len, intn_integer_sign_t n_sign, intn_digit_t out[],`
`751`	`751`	`intn_integer_sign_t *out_sign)`
`752`	`752`	`{`
`@@ -1113,7 +1113,7 @@ int intn_parse(`
`1113`	`1113`	`intn_digit_t mult[2];`
`1114`	`1114`	`ipow(base, parsed_digits, mult);`
`1115`	`1115`	`// TODO: check overflows`
`1116`		`- intn_mulmnu(out, out_len, mult, 2, new_out);`
	`1116`	`+ intn_mulu(out, out_len, mult, 2, new_out);`
`1117`	`1117`	`new_out_len = MAX(2, intn_count_digits(new_out, INTN_MUL_OUT_LEN(out_len, 2)));`
`1118`	`1118`	`if (UNLIKELY(out_len > INTN_MAX_IN_LEN)) {`
`1119`	`1119`	`assert(out_len <= INTN_MAX_RES_LEN);`
`@@ -1127,7 +1127,7 @@ int intn_parse(`
`1127`	`1127`	`intn_digit_t parsed_as_intn[2];`
`1128`	`1128`	`intn_from_int64(parsed_chunk, parsed_as_intn, &ignored_sign);`
`1129`	`1129`
`1130`		`- out_len = intn_addmnu(new_out, new_out_len, parsed_as_intn, 2, out);`
	`1130`	`+ out_len = intn_addu(new_out, new_out_len, parsed_as_intn, 2, out);`
`1131`	`1131`	`if (UNLIKELY(out_len > INTN_MAX_IN_LEN)) {`
`1132`	`1132`	`assert(out_len <= INTN_MAX_RES_LEN);`
`1133`	`1133`	`// we are above the allowed 256 bits, so it is going to be overflow`