fix platform specific fixnum boundaries

Author: AlexaCampusano

array.c

@@ -476,12 +476,12 @@ ary_narrow_count(VALUE ary, long needle)
     return count;
 }
 
-/* Sum as a long.  Cannot overflow below 2**31 elements; callers check. */
-static long
+/* long long, not long (32-bit on LLP64).  Callers check the length. */
+static long long
 ary_narrow_sum(VALUE ary)
 {
     const long len = RARRAY_LEN(ary);
-    long acc = 0;
+    long long acc = 0;
     ARY_NARROW_DISPATCH(ary, T, p, {
         for (long i = 0; i < len; i++) acc += p[i];
     });
@@ -5888,9 +5888,20 @@ recursive_eql(VALUE ary1, VALUE ary2, int recur)
                     rb_array_stride(ary2) != RARRAY_STRIDE_VALUE)) {
         return ary_narrow_equal(ary1, ary2, true);
     }
-    for (i = 0; i < RARRAY_LEN(ary1); i++) {
-        if (!rb_eql(rb_ary_elt(ary1, i), rb_ary_elt(ary2, i)))
-            return Qfalse;
+
+    /* rb_eql() can resize either array and evacuate ptrs */
+    p1 = RARRAY_CONST_PTR(ary1);
+    p2 = RARRAY_CONST_PTR(ary2);
+    len1 = RARRAY_LEN(ary1);
+
+    for (i = 0; i < len1; i++) {
+        if (p1[i] != p2[i]) {
+            if (!rb_eql(p1[i], p2[i])) return Qfalse;
+            len1 = RARRAY_LEN(ary1);
+            if (len1 != RARRAY_LEN(ary2)) return Qfalse;
+            p1 = RARRAY_CONST_PTR(ary1);
+            p2 = RARRAY_CONST_PTR(ary2);
+        }
     }
     return Qtrue;
 }
@@ -6020,12 +6031,15 @@ rb_ary_includes(VALUE ary, VALUE item)
 }
 
 /* Test hooks for the stride machinery.  Not public API. */
+
+/* :nodoc: */
 static VALUE
 rb_ary_narrow_bang(VALUE ary)
 {
     return INT2FIX(ary_try_narrow(ary));
 }
 
+/* :nodoc: */
 static VALUE
 rb_ary_stride_m(VALUE ary)
 {
@@ -8796,7 +8810,7 @@ rb_ary_sum(int argc, VALUE *argv, VALUE ary)
     if (!block_given && FIXNUM_P(v) &&
         RB_UNLIKELY(rb_array_stride(ary) != RARRAY_STRIDE_VALUE) &&
         RARRAY_LEN(ary) < (1L << 30)) {
-        return rb_int_plus(LONG2NUM(ary_narrow_sum(ary)), v);
+        return rb_int_plus(LL2NUM(ary_narrow_sum(ary)), v);
     }
 
     bool init_is_float = RB_FLOAT_TYPE_P(v);

internal/array.h

@@ -34,30 +34,30 @@ rarray_raw_ptr(VALUE ary)
 }
 
 /* Load element i of a narrowed array as a C integer.  The single place that
- * knows the width/sign encoding. */
-static inline long
+ * knows the width/sign encoding.  int64_t, not long: long is 32-bit on
+ * LLP64 platforms.  Dispatches once on the stride and sign flag bits
+ * together, the same way io.c switches on FMODE_READABLE|FMODE_WRITABLE. */
+static inline int64_t
 rarray_narrow_load_int(VALUE ary, long i)
 {
     const void *p = rarray_raw_ptr(ary);
-    if (rb_array_stride_unsigned_p(ary)) {
-        switch (rb_array_stride(ary)) {
-          case RARRAY_STRIDE_W8:  return (long)((const uint8_t  *)p)[i];
-          case RARRAY_STRIDE_W16: return (long)((const uint16_t *)p)[i];
-          default:                return (long)((const uint32_t *)p)[i];
-        }
-    }
-    switch (rb_array_stride(ary)) {
-      case RARRAY_STRIDE_W8:  return ((const int8_t  *)p)[i];
-      case RARRAY_STRIDE_W16: return ((const int16_t *)p)[i];
-      default:                return ((const int32_t *)p)[i];
+#define W(stride) ((VALUE)(stride) << RARRAY_STRIDE_SHIFT)
+    switch (RBASIC(ary)->flags & (RARRAY_STRIDE_MASK | RARRAY_STRIDE_UNSIGNED)) {
+      case W(RARRAY_STRIDE_W8):                           return ((const int8_t   *)p)[i];
+      case W(RARRAY_STRIDE_W16):                          return ((const int16_t  *)p)[i];
+      case W(RARRAY_STRIDE_W32):                          return ((const int32_t  *)p)[i];
+      case W(RARRAY_STRIDE_W8)  | RARRAY_STRIDE_UNSIGNED: return ((const uint8_t  *)p)[i];
+      case W(RARRAY_STRIDE_W16) | RARRAY_STRIDE_UNSIGNED: return ((const uint16_t *)p)[i];
+      default:                                            return ((const uint32_t *)p)[i];
     }
+#undef W
 }
 
 /* Decode element i of a narrowed array into a ::VALUE. */
 static inline VALUE
 rarray_narrow_aref(VALUE ary, long i)
 {
-    return LONG2FIX(rarray_narrow_load_int(ary, i));
+    return LL2NUM(rarray_narrow_load_int(ary, i));
 }
 
 /* Core's RARRAY_AREF replaces the public macro.  It adds a bounds assertion