term: implement big integer term_compare

Refactor term_compare to use metadata such as size and sign before
performing any integer comparison (that might be expensive for big
integers).

Perform digit by digit comparison for big integers only when size and
sign are equal.

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

Author: bettio

src/libAtomVM/term.c

@@ -637,12 +637,105 @@ TermCompareResult term_compare(term t, term other, TermCompareOpts opts, GlobalC
             }
 
         } else if (term_is_any_integer(t) && term_is_any_integer(other)) {
-            avm_int64_t t_int = term_maybe_unbox_int64(t);
-            avm_int64_t other_int = term_maybe_unbox_int64(other);
-            if (t_int == other_int) {
-                CMP_POP_AND_CONTINUE();
+            term_integer_sign_t t_sign;
+            size_t t_size;
+            if (term_is_boxed(t)) {
+                t_sign = term_boxed_integer_sign(t);
+                t_size = term_boxed_size(t);
+            } else {
+                t_sign = term_integer_sign_from_int(term_to_int(t));
+                t_size = 0;
+            }
+            term_integer_sign_t other_sign;
+            size_t other_size;
+            if (term_is_boxed(other)) {
+                other_sign = term_boxed_integer_sign(other);
+                other_size = term_boxed_size(other);
+            } else {
+                other_sign = term_integer_sign_from_int(term_to_int(other));
+                other_size = 0;
+            }
+
+            _Static_assert(
+                TermPositiveInteger < TermNegativeInteger, "Unexpected sign definition in term.h");
+            if (t_sign < other_sign) {
+                result = TermGreaterThan;
+                break;
+            } else if (t_sign > other_sign) {
+                result = TermLessThan;
+                break;
+            }
+
+            TermCompareResult more_digits_result;
+            TermCompareResult less_digits_result;
+            if (t_sign == TermPositiveInteger) {
+                more_digits_result = TermGreaterThan;
+                less_digits_result = TermLessThan;
+            } else {
+                more_digits_result = TermLessThan;
+                less_digits_result = TermGreaterThan;
+            }
+
+            if (t_size == other_size) {
+                const term *t_ptr = term_to_const_term_ptr(t);
+                const term *other_ptr = term_to_const_term_ptr(other);
+                bool equals = true;
+                if (t_size == 1) {
+                    if (t_ptr[1] != other_ptr[1]) {
+                        result = (t_ptr[1] > other_ptr[1]) ? TermGreaterThan : TermLessThan;
+                        break;
+                    }
+#if BOXED_TERMS_REQUIRED_FOR_INT64 == 2
+                } else if (t_size == 2) {
+                    avm_int64_t t64 = term_unbox_int64(t);
+                    avm_int64_t other64 = term_unbox_int64(other);
+                    if (t64 != other64) {
+                        result = (t64 > other64) ? TermGreaterThan : TermLessThan;
+                        break;
+                    }
+#endif
+                } else {
+#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+                    // on 64-bit big endian systems, term size is 64 bit, so a term
+                    // contains 2 intn_digit_t
+                    // however inside a big integer digits are in "little endian" order
+                    // so comparison cannot be directly done in 64-bit chunks
+                    intn_digit_t *t_digits = (intn_digit_t *) t_ptr;
+                    intn_digit_t *other_digits = (intn_digit_t *) other_ptr;
+                    size_t digits_per_term = (sizeof(term) / sizeof(intn_digit_t));
+                    size_t digit_count = (1 + t_size) * digits_per_term;
+                    // t_digits[0] ... t_digits[digits_per_term - 1] is the boxed header
+                    for (size_t i = digit_count - 1; i >= digits_per_term; i--) {
+                        if (t_digits[i] != other_digits[i]) {
+                            result = (t_digits[i] > other_digits[i]) ? more_digits_result
+                                                                     : less_digits_result;
+                            equals = false;
+                            break;
+                        }
+                    }
+#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+                    for (size_t i = t_size; i >= 1; i--) {
+                        if (t_ptr[i] != other_ptr[i]) {
+                            result = (t_ptr[i] > other_ptr[i]) ? more_digits_result
+                                                               : less_digits_result;
+                            equals = false;
+                            break;
+                        }
+                    }
+#else
+#error "Unsupported endianess"
+#endif
+                }
+                if (equals) {
+                    CMP_POP_AND_CONTINUE();
+                } else {
+                    break;
+                }
+            } else if (t_size > other_size) {
+                result = more_digits_result;
+                break;
             } else {
-                result = (t_int > other_int) ? TermGreaterThan : TermLessThan;
+                result = less_digits_result;
                 break;
             }
 

src/libAtomVM/term.h

@@ -897,9 +897,15 @@ static inline avm_int64_t term_maybe_unbox_int64(term maybe_boxed_int)
     }
 }
 
+static inline term_integer_sign_t term_integer_sign_from_int(avm_int_t value)
+{
+    avm_uint_t uvalue = ((avm_uint_t) value);
+    return (term_integer_sign_t) ((uvalue >> (TERM_BITS - 1)) << TERM_BOXED_INTEGER_SIGN_BIT_POS);
+}
+
 static inline term term_make_boxed_int(avm_int_t value, Heap *heap)
 {
-    avm_uint_t sign = (((avm_uint_t) value) >> (TERM_BITS - 1)) << TERM_BOXED_INTEGER_SIGN_BIT_POS;
+    avm_uint_t sign = (avm_uint_t) term_integer_sign_from_int(value);
     term *boxed_int = memory_heap_alloc(heap, 1 + BOXED_TERMS_REQUIRED_FOR_INT);
     boxed_int[0] = (BOXED_TERMS_REQUIRED_FOR_INT << 6) | TERM_BOXED_POSITIVE_INTEGER | sign;
     boxed_int[1] = value;