Make bsr work with signed numbers

Signed-off-by: Davide Bettio <davide@uninstall.it>

Author: bettio

src/libAtomVM/bif.c

@@ -1648,7 +1648,7 @@ term bif_erlang_bsr_2(Context *ctx, uint32_t fail_label, int live, term arg1, te
         args_to_bigint(arg1, arg2, tmp_buf1, tmp_buf2, &m, &m_len, &m_sign, &n, &n_len, &n_sign);
 
         intn_digit_t bigres[INTN_MAX_RES_LEN];
-        size_t bigres_len = intn_bsr(m, m_len, b, bigres);
+        size_t bigres_len = intn_bsr(m, m_len, m_sign, b, bigres);
 
         return make_bigint(ctx, fail_label, live, bigres, bigres_len, m_sign);
     } else {

src/libAtomVM/intn.c

@@ -35,6 +35,9 @@
 #define MIN(a, b) (((a) < (b)) ? (a) : (b))
 #define MAX(a, b) (((a) > (b)) ? (a) : (b))
 
+static size_t cond_neg_in_place(intn_integer_sign_t sign, intn_digit_t out[]);
+static size_t neg_in_place(intn_digit_t out[], size_t len);
+
 /*
  * Multiplication
  */
@@ -380,18 +383,23 @@ size_t intn_addmnu(
     return i;
 }
 
+static void neg(const intn_digit_t in[], size_t in_len, intn_digit_t out[])
+{
+    uint32_t carry = 1;
+    for (size_t i = 0; i < in_len; i++) {
+        uint64_t temp = (uint64_t) (~in[i]) + (uint64_t) carry;
+        out[i] = (uint32_t) temp;
+        carry = temp >> 32;
+    }
+}
+
 static void cond_neg(
     intn_integer_sign_t sign, const intn_digit_t in[], size_t in_len, intn_digit_t out[])
 {
     if (sign == IntNPositiveInteger) {
         memcpy(out, in, sizeof(intn_digit_t) * in_len);
     } else {
-        uint32_t carry = 1;
-        for (size_t i = 0; i < in_len; i++) {
-            uint64_t temp = (uint64_t) (~in[i]) + (uint64_t) carry;
-            out[i] = (uint32_t) temp;
-            carry = temp >> 32;
-        }
+        neg(in, in_len, out);
     }
 }
 
@@ -604,21 +612,15 @@ size_t intn_bsl(const uint32_t num[], size_t len, size_t n, uint32_t *out)
     return initial_zeros + i;
 }
 
-size_t intn_bsr(const uint32_t num[], size_t len, size_t n, uint32_t *out)
+size_t bsru(const uint32_t num[], size_t effective_bits_len, size_t n, uint32_t last_digit, uint32_t *out)
 {
     size_t digit_bit_size = sizeof(uint32_t) * 8;
 
     size_t digit_right_bit_shift = n % 32;
     size_t left_shift_n = (32 - digit_right_bit_shift);
 
-    size_t counted_digits = intn_count_digits(num, len);
-    size_t ms_digit_bits = 32 - uint32_nlz(num[counted_digits - 1]);
-    size_t effective_bits_len = (counted_digits - 1) * digit_bit_size + ms_digit_bits;
-
-    if (n > effective_bits_len) {
-        out[0] = 0;
-        return 1;
-    }
+    size_t len = size_round_to(effective_bits_len, digit_bit_size) / digit_bit_size;
+    size_t counted_digits = len;
 
     ///size_t new_bits_len = size_round_to(effective_bits_len - n, digit_bit_size);
 
@@ -637,7 +639,7 @@ size_t intn_bsr(const uint32_t num[], size_t len, size_t n, uint32_t *out)
         uint32_t digit = num[i];
         out[i - discarded] = (digit >> digit_right_bit_shift) | (next_digit << left_shift_n);
     }
-    uint32_t maybe_last_out = (num[i] >> digit_right_bit_shift);
+    uint32_t maybe_last_out = (num[i] >> digit_right_bit_shift) | (last_digit << left_shift_n);
 
 /*
     if (initial_zeros + i > new_digits_count) {
@@ -653,6 +655,35 @@ size_t intn_bsr(const uint32_t num[], size_t len, size_t n, uint32_t *out)
     return i - discarded;
 }
 
+size_t intn_bsr(const uint32_t num[], size_t len, intn_integer_sign_t num_sign, size_t n, uint32_t *out)
+{
+    size_t digit_bit_size = sizeof(uint32_t) * 8;
+    size_t counted_digits = intn_count_digits(num, len);
+    size_t ms_digit_bits = 32 - uint32_nlz(num[counted_digits - 1]);
+    size_t effective_bits_len = (counted_digits - 1) * digit_bit_size + ms_digit_bits;
+
+    if (n > effective_bits_len) {
+        out[0] = (num_sign == IntNPositiveInteger) ? 0 : 1;
+        return 1;
+    }
+
+    if (num_sign == IntNPositiveInteger) {
+        return bsru(num, effective_bits_len, n, 0, out);
+    } else {
+        uint32_t tmp_buf[INTN_MAX_RES_LEN];
+        memset(out, 0, INTN_MAX_RES_LEN * sizeof(const uint32_t));
+        neg(num, counted_digits, tmp_buf);
+        size_t shifted_len = bsru(tmp_buf, effective_bits_len, n, (uint32_t) -1, out);
+
+        size_t len = size_round_to(effective_bits_len - n, digit_bit_size) / digit_bit_size;
+        neg_in_place(out, len);
+
+        fprintf(stderr, "shifted: %i, len: %i\n", (int) shifted_len, (int) len);
+        print_num(out, len);
+        return len;
+    }
+}
+
 
 
 /*
@@ -912,26 +943,32 @@ int intn_parse(
     return out_len;
 }
 
+static size_t neg_in_place(intn_digit_t out[], size_t len)
+{
+    uint32_t carry = 1;
+    size_t i;
+    int last_non_zero = -1;
+    for (i = 0; i < len; i++) {
+        uint64_t temp = (uint64_t) (~out[i]) + (uint64_t) carry;
+        if ((uint32_t) temp != 0) {
+            last_non_zero = i;
+        }
+        out[i] = (uint32_t) temp;
+        carry = temp >> 32;
+    }
+    if (carry) {
+        abort();
+        out[i] = carry;
+        return i;
+    } else {
+        return last_non_zero + 1;
+    }
+}
+
 static size_t cond_neg_in_place(intn_integer_sign_t sign, intn_digit_t out[])
 {
     if (sign == IntNNegativeInteger) {
-        uint32_t carry = 1;
-        size_t i;
-        int last_non_zero = -1;
-        for (i = 0; i < INTN_MAX_RES_LEN - 1; i++) {
-            uint64_t temp = (uint64_t) (~out[i]) + (uint64_t) carry;
-            if ((uint32_t) temp != 0) {
-                last_non_zero = i;
-            }
-            out[i] = (uint32_t) temp;
-            carry = temp >> 32;
-        }
-        if (carry) {
-            out[i] = carry;
-            return i;
-        } else {
-            return last_non_zero + 1;
-        }
+        return neg_in_place(out, INTN_MAX_RES_LEN - 1);
     } else {
         return intn_count_digits(out, INTN_MAX_IN_LEN);
     }

src/libAtomVM/intn.h

@@ -86,7 +86,7 @@ size_t intn_bxormn(const intn_digit_t m[], size_t m_len, intn_integer_sign_t m_s
     intn_integer_sign_t *out_sign);
 
 size_t intn_bsl(const uint32_t num[], size_t len, size_t n, uint32_t *out);
-size_t intn_bsr(const uint32_t num[], size_t len, size_t n, uint32_t *out);
+size_t intn_bsr(const uint32_t num[], size_t len, intn_integer_sign_t num_sign, size_t n, uint32_t *out);
 
 size_t intn_count_digits(const intn_digit_t *num, size_t num_len);
 

tests/erlang_tests/bigint.erl

@@ -952,17 +952,17 @@ test_bsr() ->
     <<"0">> = erlang:integer_to_binary(Pattern1 bsr ?MODULE:id(250), 16),
     <<"0">> = erlang:integer_to_binary(Pattern1 bsr ?MODULE:id(256), 16),
 
-    %Pattern2 = erlang:binary_to_integer(?MODULE:id(<<"-CAFE1234AABBCCDD98765432987654321">>), 16),
-    %<<"-CAFE1234AABBCCDD98765432988">> = erlang:integer_to_binary(Pattern2 bsr ?MODULE:id(24), 16),
-    %<<"-657F091A555DE66ECC3B2A194D">> = erlang:integer_to_binary(Pattern2 bsr ?MODULE:id(29), 16),
-    %<<"-CAFE1234AABBCCDD98765432A">> = erlang:integer_to_binary(Pattern2 bsr ?MODULE:id(32), 16),
-    %<<"-195FC2469557799BB30ECA866">> = erlang:integer_to_binary(Pattern2 bsr ?MODULE:id(35), 16),
-    %<<"-CAFE1234AABBCCDD98766">> = erlang:integer_to_binary(Pattern2 bsr ?MODULE:id(48), 16),
-    %<<"-195FC2469557799BB30ED">> = erlang:integer_to_binary(Pattern2 bsr ?MODULE:id(51), 16),
-    %<<"-CAFE1234AABBCCDDA">> = erlang:integer_to_binary(Pattern2 bsr ?MODULE:id(64), 16),
-    %<<"-D">> = erlang:integer_to_binary(Pattern2 bsr ?MODULE:id(128), 16),
-    %<<"-1">> = erlang:integer_to_binary(Pattern2 bsr ?MODULE:id(250), 16),
-    %<<"-1">> = erlang:integer_to_binary(Pattern2 bsr ?MODULE:id(256), 16),
+    Pattern2 = erlang:binary_to_integer(?MODULE:id(<<"-CAFE1234AABBCCDD98765432987654321">>), 16),
+    <<"-CAFE1234AABBCCDD98765432988">> = erlang:integer_to_binary(Pattern2 bsr ?MODULE:id(24), 16),
+    <<"-657F091A555DE66ECC3B2A194D">> = erlang:integer_to_binary(Pattern2 bsr ?MODULE:id(29), 16),
+    <<"-CAFE1234AABBCCDD98765432A">> = erlang:integer_to_binary(Pattern2 bsr ?MODULE:id(32), 16),
+    <<"-195FC2469557799BB30ECA866">> = erlang:integer_to_binary(Pattern2 bsr ?MODULE:id(35), 16),
+    <<"-CAFE1234AABBCCDD98766">> = erlang:integer_to_binary(Pattern2 bsr ?MODULE:id(48), 16),
+    <<"-195FC2469557799BB30ED">> = erlang:integer_to_binary(Pattern2 bsr ?MODULE:id(51), 16),
+    <<"-CAFE1234AABBCCDDA">> = erlang:integer_to_binary(Pattern2 bsr ?MODULE:id(64), 16),
+    <<"-D">> = erlang:integer_to_binary(Pattern2 bsr ?MODULE:id(128), 16),
+    <<"-1">> = erlang:integer_to_binary(Pattern2 bsr ?MODULE:id(250), 16),
+    <<"-1">> = erlang:integer_to_binary(Pattern2 bsr ?MODULE:id(256), 16),
 
     0.