https://git.ruby-lang.org/ruby.git/commit/?id=989068cf70

From 989068cf7087bf48f30c7f7c3f9acfa0bfd263ef Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=8D=9C=E9=83=A8=E6=98=8C=E5=B9=B3?=
 <shyouhei@r...>
Date: Tue, 3 Dec 2019 14:42:53 +0900
Subject: internal/imemo.h rework

Arrange contents and eliminate macros, to make them readable.

Macro IFUNC_NEW was deleted because there was only one usage.

diff --git a/debug.c b/debug.c
index a54be27..7c32f6d 100644
--- a/debug.c
+++ b/debug.c
@@ -19,6 +19,15 @@ https://github.com/ruby/ruby/blob/trunk/debug.c#L19
 #include "symbol.h"
 #include "id.h"
 
+/* This is the only place struct RIMemo is actually used */
+struct RIMemo {
+    VALUE flags;
+    VALUE v0;
+    VALUE v1;
+    VALUE v2;
+    VALUE v3;
+};
+
 /* for gdb */
 const union {
     enum ruby_special_consts    special_consts;
diff --git a/internal.h b/internal.h
index 337aee8..fa6f78b 100644
--- a/internal.h
+++ b/internal.h
@@ -30,6 +30,8 @@ https://github.com/ruby/ruby/blob/trunk/internal.h#L30
 #include "internal/sanitizers.h"
 
 #define numberof(array) ((int)(sizeof(array) / sizeof((array)[0])))
+#define roomof(x, y) (((x) + (y) - 1) / (y))
+#define type_roomof(x, y) roomof(sizeof(x), sizeof(y))
 
 /* Prevent compiler from reordering access */
 #define ACCESS_ONCE(type,x) (*((volatile type *)&(x)))
diff --git a/internal/imemo.h b/internal/imemo.h
index 682582a..d90b763 100644
--- a/internal/imemo.h
+++ b/internal/imemo.h
@@ -9,18 +9,26 @@ https://github.com/ruby/ruby/blob/trunk/internal/imemo.h#L9
  *             modify this file, provided that  the conditions mentioned in the
  *             file COPYING are met.  Consult the file for details.
  */
+#include "ruby/config.h"
+#include <stddef.h>             /* for size_t */
+#include "internal/array.h"     /* for rb_ary_tmp_new_fill */
+#include "internal/gc.h"        /* for RB_OBJ_WRITE */
+#include "internal/stdbool.h"   /* for bool */
+#include "ruby/ruby.h"          /* for rb_block_call_func_t */
 
 #ifndef IMEMO_DEBUG
-#define IMEMO_DEBUG 0
+# define IMEMO_DEBUG 0
 #endif
 
-struct RIMemo {
-    VALUE flags;
-    VALUE v0;
-    VALUE v1;
-    VALUE v2;
-    VALUE v3;
-};
+#define IMEMO_MASK   0x0f
+
+/* FL_USER0 to FL_USER3 is for type */
+#define IMEMO_FL_USHIFT (FL_USHIFT + 4)
+#define IMEMO_FL_USER0 FL_USER4
+#define IMEMO_FL_USER1 FL_USER5
+#define IMEMO_FL_USER2 FL_USER6
+#define IMEMO_FL_USER3 FL_USER7
+#define IMEMO_FL_USER4 FL_USER8
 
 enum imemo_type {
     imemo_env            =  0,
@@ -35,38 +43,6 @@ enum imemo_type { https://github.com/ruby/ruby/blob/trunk/internal/imemo.h#L43
     imemo_ast            =  9,
     imemo_parser_strterm = 10
 };
-#define IMEMO_MASK   0x0f
-
-static inline enum imemo_type
-imemo_type(VALUE imemo)
-{
-    return (RBASIC(imemo)->flags >> FL_USHIFT) & IMEMO_MASK;
-}
-
-static inline int
-imemo_type_p(VALUE imemo, enum imemo_type imemo_type)
-{
-    if (LIKELY(!RB_SPECIAL_CONST_P(imemo))) {
-        /* fixed at compile time if imemo_type is given. */
-        const VALUE mask = (IMEMO_MASK << FL_USHIFT) | RUBY_T_MASK;
-        const VALUE expected_type = (imemo_type << FL_USHIFT) | T_IMEMO;
-        /* fixed at runtime. */
-        return expected_type == (RBASIC(imemo)->flags & mask);
-    }
-    else {
-        return 0;
-    }
-}
-
-VALUE rb_imemo_new(enum imemo_type type, VALUE v1, VALUE v2, VALUE v3, VALUE v0);
-
-/* FL_USER0 to FL_USER3 is for type */
-#define IMEMO_FL_USHIFT (FL_USHIFT + 4)
-#define IMEMO_FL_USER0 FL_USER4
-#define IMEMO_FL_USER1 FL_USER5
-#define IMEMO_FL_USER2 FL_USER6
-#define IMEMO_FL_USER3 FL_USER7
-#define IMEMO_FL_USER4 FL_USER8
 
 /* CREF (Class REFerence) is defined in method.h */
 
@@ -79,9 +55,6 @@ struct vm_svar { https://github.com/ruby/ruby/blob/trunk/internal/imemo.h#L55
     const VALUE others;
 };
 
-
-#define THROW_DATA_CONSUMED IMEMO_FL_USER0
-
 /*! THROW_DATA */
 struct vm_throw_data {
     VALUE flags;
@@ -91,7 +64,7 @@ struct vm_throw_data { https://github.com/ruby/ruby/blob/trunk/internal/imemo.h#L64
     int throw_state;
 };
 
-#define THROW_DATA_P(err) RB_TYPE_P((VALUE)(err), T_IMEMO)
+#define THROW_DATA_CONSUMED IMEMO_FL_USER0
 
 /* IFUNC (Internal FUNCtion) */
 
@@ -113,56 +86,13 @@ struct vm_ifunc { https://github.com/ruby/ruby/blob/trunk/internal/imemo.h#L86
     struct vm_ifunc_argc argc;
 };
 
-#define IFUNC_NEW(a, b, c) ((struct vm_ifunc *)rb_imemo_new(imemo_ifunc, (VALUE)(a), (VALUE)(b), (VALUE)(c), 0))
-struct vm_ifunc *rb_vm_ifunc_new(rb_block_call_func_t func, const void *data, int min_argc, int max_argc);
-static inline struct vm_ifunc *
-rb_vm_ifunc_proc_new(rb_block_call_func_t func, const void *data)
-{
-    return rb_vm_ifunc_new(func, data, 0, UNLIMITED_ARGUMENTS);
-}
-
-typedef struct rb_imemo_tmpbuf_struct {
+struct rb_imemo_tmpbuf_struct {
     VALUE flags;
     VALUE reserved;
     VALUE *ptr; /* malloc'ed buffer */
     struct rb_imemo_tmpbuf_struct *next; /* next imemo */
     size_t cnt; /* buffer size in VALUE */
-} rb_imemo_tmpbuf_t;
-
-#define rb_imemo_tmpbuf_auto_free_pointer() rb_imemo_new(imemo_tmpbuf, 0, 0, 0, 0)
-rb_imemo_tmpbuf_t *rb_imemo_tmpbuf_parser_heap(void *buf, rb_imemo_tmpbuf_t *old_heap, size_t cnt);
-
-#define RB_IMEMO_TMPBUF_PTR(v) \
-    ((void *)(((const struct rb_imemo_tmpbuf_struct *)(v))->ptr))
-
-static inline void *
-rb_imemo_tmpbuf_set_ptr(VALUE v, void *ptr)
-{
-    return ((rb_imemo_tmpbuf_t *)v)->ptr = ptr;
-}
-
-static inline VALUE
-rb_imemo_tmpbuf_auto_free_pointer_new_from_an_RString(VALUE str)
-{
-    const void *src;
-    VALUE imemo;
-    rb_imemo_tmpbuf_t *tmpbuf;
-    void *dst;
-    size_t len;
-
-    SafeStringValue(str);
-    /* create tmpbuf to keep the pointer before xmalloc */
-    imemo = rb_imemo_tmpbuf_auto_free_pointer();
-    tmpbuf = (rb_imemo_tmpbuf_t *)imemo;
-    len = RSTRING_LEN(str);
-    src = RSTRING_PTR(str);
-    dst = ruby_xmalloc(len);
-    memcpy(dst, src, len);
-    tmpbuf->ptr = dst;
-    return imemo;
-}
-
-void rb_strterm_mark(VALUE obj);
+};
 
 /*! MEMO
  *
@@ -181,15 +111,11 @@ struct MEMO { https://github.com/ruby/ruby/blob/trunk/internal/imemo.h#L111
     } u3;
 };
 
-#define MEMO_V1_SET(m, v) RB_OBJ_WRITE((m), &(m)->v1, (v))
-#define MEMO_V2_SET(m, v) RB_OBJ_WRITE((m), &(m)->v2, (v))
-
-#define MEMO_CAST(m) ((struct MEMO *)m)
+/* ment is in method.h */
 
+#define THROW_DATA_P(err) imemo_throw_data_p((VALUE)err)
+#define MEMO_CAST(m) (R_CAST(MEMO)(m))
 #define MEMO_NEW(a, b, c) ((struct MEMO *)rb_imemo_new(imemo_memo, (VALUE)(a), (VALUE)(b), (VALUE)(c), 0))
-
-#define roomof(x, y) (((x) + (y) - 1) / (y))
-#define type_roomof(x, y) roomof(sizeof(x), sizeof(y))
 #define MEMO_FOR(type, value) ((type *)RARRAY_PTR(value))
 #define NEW_MEMO_FOR(type, value) \
   ((value) = rb_ary_tmp_new_fill(type_roomof(type, VALUE)), MEMO_FOR(type, value))
@@ -198,7 +124,21 @@ struct MEMO { https://github.com/ruby/ruby/blob/trunk/internal/imemo.h#L124
    rb_ary_set_len((value), offsetof(type, member) / sizeof(VALUE)), \
    MEMO_FOR(type, value))
 
-/* ment is in method.h */
+typedef struct rb_imemo_tmpbuf_struct rb_imemo_tmpbuf_t;
+VALUE rb_imemo_new(enum imemo_type type, VALUE v1, VALUE v2, VALUE v3, VALUE v0);
+rb_imemo_tmpbuf_t *rb_imemo_tmpbuf_parser_heap(void *buf, rb_imemo_tmpbuf_t *old_heap, size_t cnt);
+struct vm_ifunc *rb_vm_ifunc_new(rb_block_call_func_t func, const void *data, int min_argc, int max_argc);
+void rb_strterm_mark(VALUE obj);
+static inline enum imemo_type imemo_type(VALUE imemo);
+static inline int imemo_type_p(VALUE imemo, enum imemo_type imemo_type);
+static inline bool imemo_throw_data_p(VALUE imemo);
+static inline struct vm_ifunc *rb_vm_ifunc_proc_new(rb_block_call_func_t func, const void *data);
+static inline VALUE rb_imemo_tmpbuf_auto_free_pointer(void);
+static inline void *RB_IMEMO_TMPBUF_PTR(VALUE v);
+static inline void *rb_imemo_tmpbuf_set_ptr(VALUE v, void *ptr);
+static inline VALUE rb_imemo_tmpbuf_auto_free_pointer_new_from_an_RString(VALUE str);
+static inline void MEMO_V1_SET(struct MEMO *m, VALUE v);
+static inline void MEMO_V2_SET(struct MEMO *m, VALUE v);
 
 RUBY_SYMBOL_EXPORT_BEGIN
 #if IMEMO_DEBUG
@@ -209,4 +149,89 @@ VALUE rb_imemo_new(enum imemo_type type, VALUE v1, VALUE v2, VALUE v3, VALUE v0) https://github.com/ruby/ruby/blob/trunk/internal/imemo.h#L149
 #endif
 RUBY_SYMBOL_EXPORT_END
 
+static inline enum imemo_type
+imemo_type(VALUE imemo)
+{
+    return (RBASIC(imemo)->flags >> FL_USHIFT) & IMEMO_MASK;
+}
+
+static inline int
+imemo_type_p(VALUE imemo, enum imemo_type imemo_type)
+{
+    if (LIKELY(!RB_SPECIAL_CONST_P(imemo))) {
+        /* fixed at compile time if imemo_type is given. */
+        const VALUE mask = (IMEMO_MASK << FL_USHIFT) | RUBY_T_MASK;
+        const VALUE expected_type = (imemo_type << FL_USHIFT) | T_IMEMO;
+        /* fixed at runtime. */
+        return expected_type == (RBASIC(imemo)->flags & mask);
+    }
+    else {
+        return 0;
+    }
+}
+
+static inline bool
+imemo_throw_data_p(VALUE imemo)
+{
+    return RB_TYPE_P(imemo, T_IMEMO);
+}
+
+static inline struct vm_ifunc *
+rb_vm_ifunc_proc_new(rb_block_call_func_t func, const void *data)
+{
+    return rb_vm_ifunc_new(func, data, 0, UNLIMITED_ARGUMENTS);
+}
+
+static inline VALUE
+rb_imemo_tmpbuf_auto_free_pointer(void)
+{
+    return rb_imemo_new(imemo_tmpbuf, 0, 0, 0, 0);
+}
+
+static inline void *
+RB_IMEMO_TMPBUF_PTR(VALUE v)
+{
+    const struct rb_imemo_tmpbuf_struct *p = (const void *)v;
+    return p->ptr;
+}
+
+static inline void *
+rb_imemo_tmpbuf_set_ptr(VALUE v, void *ptr)
+{
+    return ((rb_imemo_tmpbuf_t *)v)->ptr = ptr;
+}
+
+static inline VALUE
+rb_imemo_tmpbuf_auto_free_pointer_new_from_an_RString(VALUE str)
+{
+    const void *src;
+    VALUE imemo;
+    rb_imemo_tmpbuf_t *tmpbuf;
+    void *dst;
+    size_t len;
+
+    SafeStringValue(str);
+    /* create tmpbuf to keep the pointer before xmalloc */
+    imemo = rb_imemo_tmpbuf_auto_free_pointer();
+    tmpbuf = (rb_imemo_tmpbuf_t *)imemo;
+    len = RSTRING_LEN(str);
+    src = RSTRING_PTR(str);
+    dst = ruby_xmalloc(len);
+  (... truncated)

--
ML: ruby-changes@q...
Info: http://www.atdot.net/~ko1/quickml/