debase-ruby_core_source 3.2.1 → 3.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 14d52aed359a025b1ab08e069187282eb2decc5c1f51b4f5e17b7414d07d76d9
-  data.tar.gz: e68d3aa94b796d4e20ec194085065195c3ec6931baf392cd12218e6cd5ad984a
+  metadata.gz: f3f80f8cffab69100083129a38efef3346d80035b6e8a57b0809e6869ea1846c
+  data.tar.gz: eddce4523d7a7ae783d9b2e7d0ca0926ecdd349f7a2852e519e754c2396138e7
 SHA512:
-  metadata.gz: df845a44dc291df62869976c6cb61a43bbf1b85c2e40ca1b4c5bf43ecb610ecebe524c4848f025fcce8e72f67a6c8273d10766e9416ede3ee7aa95783592edd8
-  data.tar.gz: 31d6f3238490fc53bc17436afbf6bf8a8146c56efc4e1e872a8ed41012e4ec43c4fed6c61c2713657e91f90b7fa7a44b5c726112ac7ea54de572c3e043551547
+  metadata.gz: 3697bae670caecc8ae9276ae60adf2802d64c3f2531bf0601afc528a4d21085bc9e32b1cc8a63c88d83fa6726d53badee0714b1415b6bbb6aae911692214b57f
+  data.tar.gz: 991f262f4460a2c7ed36fe0b99336579f2f145d59e9cbb52358028bebfdfccbabb901d7401419cbcfe3b7f00020a6cb544ede897058a4e9369ed6e9dc1534691

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## [3.2.2](https://github.com/ruby-debug/debase-ruby_core_source/compare/3.2.2...3.2.1)
+
+* ruby-3.3.0-preview2 sources added
+* ruby-3.3.0-preview1 sources removed
+
 ## [3.2.1](https://github.com/ruby-debug/debase-ruby_core_source/compare/3.2.1...v3.2.0)
 
 * ruby-3.3.0-preview1 sources added

data/lib/debase/ruby_core_source/ruby-3.3.0-preview2/darray.h

@@ -0,0 +1,246 @@
+#ifndef RUBY_DARRAY_H
+#define RUBY_DARRAY_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include <stdlib.h>
+
+#include "internal/bits.h"
+#include "internal/gc.h"
+
+// Type for a dynamic array. Use to declare a dynamic array.
+// It is a pointer so it fits in st_table nicely. Designed
+// to be fairly type-safe.
+//
+// NULL is a valid empty dynamic array.
+//
+// Example:
+//      rb_darray(char) char_array = NULL;
+//      rb_darray_append(&char_array, 'e');
+//      printf("pushed %c\n", *rb_darray_ref(char_array, 0));
+//      rb_darray_free(char_array);
+//
+#define rb_darray(T) struct { rb_darray_meta_t meta; T data[]; } *
+
+// Copy an element out of the array. Warning: not bounds checked.
+//
+// T rb_darray_get(rb_darray(T) ary, size_t idx);
+//
+#define rb_darray_get(ary, idx) ((ary)->data[(idx)])
+
+// Assign to an element. Warning: not bounds checked.
+//
+// void rb_darray_set(rb_darray(T) ary, size_t idx, T element);
+//
+#define rb_darray_set(ary, idx, element) ((ary)->data[(idx)] = (element))
+
+// Get a pointer to an element. Warning: not bounds checked.
+//
+// T *rb_darray_ref(rb_darray(T) ary, size_t idx);
+//
+#define rb_darray_ref(ary, idx) (&((ary)->data[(idx)]))
+
+/* Copy a new element into the array. ptr_to_ary is evaluated multiple times.
+ *
+ * void rb_darray_append(rb_darray(T) *ptr_to_ary, T element);
+ */
+#define rb_darray_append(ptr_to_ary, element) \
+    rb_darray_append_impl(ptr_to_ary, element, rb_xrealloc_mul_add)
+
+#define rb_darray_append_without_gc(ptr_to_ary, element) \
+    rb_darray_append_impl(ptr_to_ary, element, rb_darray_realloc_mul_add_without_gc)
+
+#define rb_darray_append_impl(ptr_to_ary, element, realloc_func) do {  \
+    rb_darray_ensure_space((ptr_to_ary), \
+                           sizeof(**(ptr_to_ary)), \
+                           sizeof((*(ptr_to_ary))->data[0]), \
+                           realloc_func); \
+    rb_darray_set(*(ptr_to_ary), \
+                  (*(ptr_to_ary))->meta.size, \
+                  (element)); \
+    (*(ptr_to_ary))->meta.size++; \
+} while (0)
+
+// Iterate over items of the array in a for loop
+//
+#define rb_darray_foreach(ary, idx_name, elem_ptr_var) \
+    for (size_t idx_name = 0; idx_name < rb_darray_size(ary) && ((elem_ptr_var) = rb_darray_ref(ary, idx_name)); ++idx_name)
+
+// Iterate over valid indices in the array in a for loop
+//
+#define rb_darray_for(ary, idx_name) \
+    for (size_t idx_name = 0; idx_name < rb_darray_size(ary); ++idx_name)
+
+/* Make a dynamic array of a certain size. All bytes backing the elements are set to zero.
+ * Return 1 on success and 0 on failure.
+ *
+ * Note that NULL is a valid empty dynamic array.
+ *
+ * void rb_darray_make(rb_darray(T) *ptr_to_ary, size_t size);
+ */
+#define rb_darray_make(ptr_to_ary, size) \
+    rb_darray_make_impl((ptr_to_ary), size, sizeof(**(ptr_to_ary)), \
+                         sizeof((*(ptr_to_ary))->data[0]), rb_xcalloc_mul_add)
+
+#define rb_darray_make_without_gc(ptr_to_ary, size) \
+    rb_darray_make_impl((ptr_to_ary), size, sizeof(**(ptr_to_ary)), \
+                        sizeof((*(ptr_to_ary))->data[0]), rb_darray_calloc_mul_add_without_gc)
+
+/* Resize the darray to a new capacity. The new capacity must be greater than
+ * or equal to the size of the darray.
+ *
+ * void rb_darray_resize_capa(rb_darray(T) *ptr_to_ary, size_t capa);
+ */
+#define rb_darray_resize_capa_without_gc(ptr_to_ary, capa) \
+    rb_darray_resize_capa_impl((ptr_to_ary), rb_darray_next_power_of_two(capa), sizeof(**(ptr_to_ary)), \
+                               sizeof((*(ptr_to_ary))->data[0]), rb_darray_realloc_mul_add_without_gc)
+
+#define rb_darray_data_ptr(ary) ((ary)->data)
+
+typedef struct rb_darray_meta {
+    size_t size;
+    size_t capa;
+} rb_darray_meta_t;
+
+/* Set the size of the array to zero without freeing the backing memory.
+ * Allows reusing the same array. */
+static inline void
+rb_darray_clear(void *ary)
+{
+    rb_darray_meta_t *meta = ary;
+    if (meta) {
+        meta->size = 0;
+    }
+}
+
+// Get the size of the dynamic array.
+//
+static inline size_t
+rb_darray_size(const void *ary)
+{
+    const rb_darray_meta_t *meta = ary;
+    return meta ? meta->size : 0;
+}
+
+// Get the capacity of the dynamic array.
+//
+static inline size_t
+rb_darray_capa(const void *ary)
+{
+    const rb_darray_meta_t *meta = ary;
+    return meta ? meta->capa : 0;
+}
+
+/* Free the dynamic array. */
+static inline void
+rb_darray_free(void *ary)
+{
+    rb_darray_meta_t *meta = ary;
+    if (meta) ruby_sized_xfree(ary, meta->capa);
+}
+
+static inline void
+rb_darray_free_without_gc(void *ary)
+{
+    free(ary);
+}
+
+/* Internal function. Like rb_xcalloc_mul_add but does not trigger GC and does
+ * not check for overflow in arithmetic. */
+static inline void *
+rb_darray_calloc_mul_add_without_gc(size_t x, size_t y, size_t z)
+{
+    size_t size = (x * y) + z;
+
+    void *ptr = calloc(1, size);
+    if (ptr == NULL) rb_bug("rb_darray_calloc_mul_add_without_gc: failed");
+
+    return ptr;
+}
+
+/* Internal function. Like rb_xrealloc_mul_add but does not trigger GC and does
+ * not check for overflow in arithmetic. */
+static inline void *
+rb_darray_realloc_mul_add_without_gc(const void *orig_ptr, size_t x, size_t y, size_t z)
+{
+    size_t size = (x * y) + z;
+
+    void *ptr = realloc((void *)orig_ptr, size);
+    if (ptr == NULL) rb_bug("rb_darray_realloc_mul_add_without_gc: failed");
+
+    return ptr;
+}
+
+/* Internal function. Returns the next power of two that is greater than or
+ * equal to n. */
+static inline size_t
+rb_darray_next_power_of_two(size_t n)
+{
+    return (size_t)(1 << (64 - nlz_int64(n)));
+}
+
+/* Internal function. Resizes the capacity of a darray. The new capacity must
+ * be greater than or equal to the size of the darray. */
+static inline void
+rb_darray_resize_capa_impl(void *ptr_to_ary, size_t new_capa, size_t header_size, size_t element_size,
+                           void *(*realloc_mul_add_impl)(const void *, size_t, size_t, size_t))
+{
+    rb_darray_meta_t **ptr_to_ptr_to_meta = ptr_to_ary;
+    rb_darray_meta_t *meta = *ptr_to_ptr_to_meta;
+
+    rb_darray_meta_t *new_ary = realloc_mul_add_impl(meta, new_capa, element_size, header_size);
+
+    if (meta == NULL) {
+        /* First allocation. Initialize size. On subsequence allocations
+         * realloc takes care of carrying over the size. */
+        new_ary->size = 0;
+    }
+
+    assert(new_ary->size <= new_capa);
+
+    new_ary->capa = new_capa;
+
+    // We don't have access to the type of the dynamic array in function context.
+    // Write out result with memcpy to avoid strict aliasing issue.
+    memcpy(ptr_to_ary, &new_ary, sizeof(new_ary));
+}
+
+// Internal function
+// Ensure there is space for one more element.
+// Note: header_size can be bigger than sizeof(rb_darray_meta_t) when T is __int128_t, for example.
+static inline void
+rb_darray_ensure_space(void *ptr_to_ary, size_t header_size, size_t element_size,
+                       void *(*realloc_mul_add_impl)(const void *, size_t, size_t, size_t))
+{
+    rb_darray_meta_t **ptr_to_ptr_to_meta = ptr_to_ary;
+    rb_darray_meta_t *meta = *ptr_to_ptr_to_meta;
+    size_t current_capa = rb_darray_capa(meta);
+    if (rb_darray_size(meta) < current_capa) return;
+
+    // Double the capacity
+    size_t new_capa = current_capa == 0 ? 1 : current_capa * 2;
+
+    rb_darray_resize_capa_impl(ptr_to_ary, new_capa, header_size, element_size, realloc_mul_add_impl);
+}
+
+static inline void
+rb_darray_make_impl(void *ptr_to_ary, size_t array_size, size_t header_size, size_t element_size,
+                    void *(*calloc_mul_add_impl)(size_t, size_t, size_t))
+{
+    rb_darray_meta_t **ptr_to_ptr_to_meta = ptr_to_ary;
+    if (array_size == 0) {
+        *ptr_to_ptr_to_meta = NULL;
+        return;
+    }
+
+    rb_darray_meta_t *meta = calloc_mul_add_impl(array_size, element_size, header_size);
+
+    meta->size = array_size;
+    meta->capa = array_size;
+
+    // We don't have access to the type of the dynamic array in function context.
+    // Write out result with memcpy to avoid strict aliasing issue.
+    memcpy(ptr_to_ary, &meta, sizeof(meta));
+}
+
+#endif /* RUBY_DARRAY_H */

data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview2}/debug_counter.h

@@ -100,6 +100,13 @@ RB_DEBUG_COUNTER(ccf_opt_block_call)
 RB_DEBUG_COUNTER(ccf_opt_struct_aref)
 RB_DEBUG_COUNTER(ccf_opt_struct_aset)
 RB_DEBUG_COUNTER(ccf_super_method)
+RB_DEBUG_COUNTER(ccf_cfunc_other)
+RB_DEBUG_COUNTER(ccf_cfunc_only_splat)
+RB_DEBUG_COUNTER(ccf_cfunc_only_splat_kw)
+RB_DEBUG_COUNTER(ccf_iseq_bmethod)
+RB_DEBUG_COUNTER(ccf_noniseq_bmethod)
+RB_DEBUG_COUNTER(ccf_opt_send_complex)
+RB_DEBUG_COUNTER(ccf_opt_send_simple)
 
 /*
  * control frame push counts.
@@ -207,7 +214,6 @@ RB_DEBUG_COUNTER(gc_isptr_maybe)
  * * [attr]
  *   * _ptr: R?? is not embed.
  *   * _embed: R?? is embed.
- *   * _transient: R?? uses transient heap.
  * * type specific attr.
  *   * str_shared: str is shared.
  *   * str_nofree:        nofree
@@ -233,7 +239,6 @@ RB_DEBUG_COUNTER(obj_promote)
 RB_DEBUG_COUNTER(obj_wb_unprotect)
 
 RB_DEBUG_COUNTER(obj_obj_embed)
-RB_DEBUG_COUNTER(obj_obj_transient)
 RB_DEBUG_COUNTER(obj_obj_ptr)
 RB_DEBUG_COUNTER(obj_obj_too_complex)
 
@@ -244,7 +249,6 @@ RB_DEBUG_COUNTER(obj_str_nofree)
 RB_DEBUG_COUNTER(obj_str_fstr)
 
 RB_DEBUG_COUNTER(obj_ary_embed)
-RB_DEBUG_COUNTER(obj_ary_transient)
 RB_DEBUG_COUNTER(obj_ary_ptr)
 RB_DEBUG_COUNTER(obj_ary_extracapa)
 /*
@@ -268,11 +272,9 @@ RB_DEBUG_COUNTER(obj_hash_g8)
 RB_DEBUG_COUNTER(obj_hash_null)
 RB_DEBUG_COUNTER(obj_hash_ar)
 RB_DEBUG_COUNTER(obj_hash_st)
-RB_DEBUG_COUNTER(obj_hash_transient)
 RB_DEBUG_COUNTER(obj_hash_force_convert)
 
 RB_DEBUG_COUNTER(obj_struct_embed)
-RB_DEBUG_COUNTER(obj_struct_transient)
 RB_DEBUG_COUNTER(obj_struct_ptr)
 
 RB_DEBUG_COUNTER(obj_data_empty)
@@ -327,11 +329,6 @@ RB_DEBUG_COUNTER(heap_xmalloc)
 RB_DEBUG_COUNTER(heap_xrealloc)
 RB_DEBUG_COUNTER(heap_xfree)
 
-/* transient_heap */
-RB_DEBUG_COUNTER(theap_alloc)
-RB_DEBUG_COUNTER(theap_alloc_fail)
-RB_DEBUG_COUNTER(theap_evacuate)
-
 // VM sync
 RB_DEBUG_COUNTER(vm_sync_lock)
 RB_DEBUG_COUNTER(vm_sync_lock_enter)

data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview2}/eval_intern.h

@@ -151,6 +151,7 @@ rb_ec_tag_state(const rb_execution_context_t *ec)
     enum ruby_tag_type state = tag->state;
     tag->state = TAG_NONE;
     rb_ec_vm_lock_rec_check(ec, tag->lock_rec);
+    RBIMPL_ASSUME(state != TAG_NONE);
     return state;
 }
 
@@ -158,6 +159,7 @@ NORETURN(static inline void rb_ec_tag_jump(const rb_execution_context_t *ec, enu
 static inline void
 rb_ec_tag_jump(const rb_execution_context_t *ec, enum ruby_tag_type st)
 {
+    RUBY_ASSERT(st != TAG_NONE);
     ec->tag->state = st;
     ruby_longjmp(ec->tag->buf, 1);
 }
@@ -167,7 +169,7 @@ rb_ec_tag_jump(const rb_execution_context_t *ec, enum ruby_tag_type st)
   [ISO/IEC 9899:1999] 7.13.1.1
 */
 #define EC_EXEC_TAG() \
-    (ruby_setjmp(_tag.buf) ? rb_ec_tag_state(VAR_FROM_MEMORY(_ec)) : (EC_REPUSH_TAG(), 0))
+    (UNLIKELY(ruby_setjmp(_tag.buf)) ? rb_ec_tag_state(VAR_FROM_MEMORY(_ec)) : (EC_REPUSH_TAG(), 0))
 
 #define EC_JUMP_TAG(ec, st) rb_ec_tag_jump(ec, st)
 

data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview2}/id.h

@@ -129,6 +129,8 @@ enum ruby_method_ids {
     id_core_sprintf,
     id_debug_created_info,
     tPRESERVED_ID_END,
+
+    /* LOCAL tokens {{{ */
     tTOKEN_LOCAL_BEGIN = tPRESERVED_ID_END-1,
     tMax,
     tMin,
@@ -200,20 +202,39 @@ enum ruby_method_ids {
     tNUMPARAM_9,
     tDefault,
     tTOKEN_LOCAL_END,
+    /* LOCAL tokens }}} */
+
+    /* INSTANCE tokens {{{ */
     tTOKEN_INSTANCE_BEGIN = tTOKEN_LOCAL_END-1,
     tTOKEN_INSTANCE_END,
+    /* INSTANCE tokens }}} */
+
+    /* GLOBAL tokens {{{ */
     tTOKEN_GLOBAL_BEGIN = tTOKEN_INSTANCE_END-1,
     tLASTLINE,
     tBACKREF,
     tERROR_INFO,
     tTOKEN_GLOBAL_END,
+    /* GLOBAL tokens }}} */
+
+    /* CONST tokens {{{ */
     tTOKEN_CONST_BEGIN = tTOKEN_GLOBAL_END-1,
     tTOKEN_CONST_END,
+    /* CONST tokens }}} */
+
+    /* CLASS tokens {{{ */
     tTOKEN_CLASS_BEGIN = tTOKEN_CONST_END-1,
     tTOKEN_CLASS_END,
+    /* CLASS tokens }}} */
+
+    /* ATTRSET tokens {{{ */
     tTOKEN_ATTRSET_BEGIN = tTOKEN_CLASS_END-1,
     tTOKEN_ATTRSET_END,
+    /* ATTRSET tokens }}} */
+
     tNEXT_ID = tTOKEN_ATTRSET_END,
+
+    /* LOCAL IDs {{{ */
 #define DEFINE_LOCALID_FROM_TOKEN(n) id##n = TOKEN2LOCALID(t##n)
     DEFINE_LOCALID_FROM_TOKEN(Max),
     DEFINE_LOCALID_FROM_TOKEN(Min),
@@ -284,14 +305,37 @@ enum ruby_method_ids {
     DEFINE_LOCALID_FROM_TOKEN(NUMPARAM_8),
     DEFINE_LOCALID_FROM_TOKEN(NUMPARAM_9),
     DEFINE_LOCALID_FROM_TOKEN(Default),
+#undef DEFINE_LOCALID_FROM_TOKEN
+    /* LOCAL IDs }}} */
+
+    /* INSTANCE IDs {{{ */
 #define DEFINE_INSTANCEID_FROM_TOKEN(n) id##n = TOKEN2INSTANCEID(t##n)
+#undef DEFINE_INSTANCEID_FROM_TOKEN
+    /* INSTANCE IDs }}} */
+
+    /* GLOBAL IDs {{{ */
 #define DEFINE_GLOBALID_FROM_TOKEN(n) id##n = TOKEN2GLOBALID(t##n)
     DEFINE_GLOBALID_FROM_TOKEN(LASTLINE),
     DEFINE_GLOBALID_FROM_TOKEN(BACKREF),
     DEFINE_GLOBALID_FROM_TOKEN(ERROR_INFO),
+#undef DEFINE_GLOBALID_FROM_TOKEN
+    /* GLOBAL IDs }}} */
+
+    /* CONST IDs {{{ */
 #define DEFINE_CONSTID_FROM_TOKEN(n) id##n = TOKEN2CONSTID(t##n)
+#undef DEFINE_CONSTID_FROM_TOKEN
+    /* CONST IDs }}} */
+
+    /* CLASS IDs {{{ */
 #define DEFINE_CLASSID_FROM_TOKEN(n) id##n = TOKEN2CLASSID(t##n)
+#undef DEFINE_CLASSID_FROM_TOKEN
+    /* CLASS IDs }}} */
+
+    /* ATTRSET IDs {{{ */
 #define DEFINE_ATTRSETID_FROM_TOKEN(n) id##n = TOKEN2ATTRSETID(t##n)
+#undef DEFINE_ATTRSETID_FROM_TOKEN
+    /* ATTRSET IDs }}} */
+
     tLAST_OP_ID = tPRESERVED_ID_END-1,
     idLAST_OP_ID = tLAST_OP_ID >> ID_SCOPE_SHIFT
 };