debase-ruby_core_source 0.10.9 → 0.10.13

data/lib/debase/ruby_core_source/ruby-3.0.0-p0/internal/vm.h

@@ -0,0 +1,136 @@
+#ifndef INTERNAL_VM_H                                    /*-*-C-*-vi:se ft=c:*/
+#define INTERNAL_VM_H
+/**
+ * @file
+ * @author     Ruby developers <ruby-core@ruby-lang.org>
+ * @copyright  This  file  is   a  part  of  the   programming  language  Ruby.
+ *             Permission  is hereby  granted,  to  either redistribute  and/or
+ *             modify this file, provided that  the conditions mentioned in the
+ *             file COPYING are met.  Consult the file for details.
+ * @brief      Internal header for RubyVM.
+ */
+#include "ruby/internal/stdbool.h"         /* for bool */
+#include "internal/serial.h"        /* for rb_serial_t */
+#include "internal/static_assert.h" /* for STATIC_ASSERT */
+#include "ruby/ruby.h"              /* for ID */
+#include "ruby/st.h"                /* for st_table */
+
+#ifdef rb_funcallv
+# undef rb_funcallv
+#endif
+
+#ifdef rb_method_basic_definition_p
+# undef rb_method_basic_definition_p
+#endif
+
+struct rb_callable_method_entry_struct; /* in method.h */
+struct rb_method_definition_struct;     /* in method.h */
+struct rb_execution_context_struct;     /* in vm_core.h */
+struct rb_control_frame_struct;         /* in vm_core.h */
+struct rb_callinfo;                     /* in vm_core.h */
+
+enum method_missing_reason {
+    MISSING_NOENTRY   = 0x00,
+    MISSING_PRIVATE   = 0x01,
+    MISSING_PROTECTED = 0x02,
+    MISSING_FCALL     = 0x04,
+    MISSING_VCALL     = 0x08,
+    MISSING_SUPER     = 0x10,
+    MISSING_MISSING   = 0x20,
+    MISSING_NONE      = 0x40
+};
+
+/* vm_insnhelper.h */
+rb_serial_t rb_next_class_serial(void);
+
+/* vm.c */
+VALUE rb_obj_is_thread(VALUE obj);
+void rb_vm_mark(void *ptr);
+void rb_vm_each_stack_value(void *ptr, void (*cb)(VALUE, void*), void *ctx);
+PUREFUNC(VALUE rb_vm_top_self(void));
+void rb_vm_inc_const_missing_count(void);
+const void **rb_vm_get_insns_address_table(void);
+VALUE rb_source_location(int *pline);
+const char *rb_source_location_cstr(int *pline);
+MJIT_STATIC void rb_vm_pop_cfunc_frame(void);
+int rb_vm_add_root_module(VALUE module);
+void rb_vm_check_redefinition_by_prepend(VALUE klass);
+int rb_vm_check_optimizable_mid(VALUE mid);
+VALUE rb_yield_refine_block(VALUE refinement, VALUE refinements);
+MJIT_STATIC VALUE ruby_vm_special_exception_copy(VALUE);
+PUREFUNC(st_table *rb_vm_fstring_table(void));
+
+MJIT_SYMBOL_EXPORT_BEGIN
+VALUE vm_exec(struct rb_execution_context_struct *, bool); /* used in JIT-ed code */
+MJIT_SYMBOL_EXPORT_END
+
+/* vm_eval.c */
+VALUE rb_current_realfilepath(void);
+VALUE rb_check_block_call(VALUE, ID, int, const VALUE *, rb_block_call_func_t, VALUE);
+typedef void rb_check_funcall_hook(int, VALUE, ID, int, const VALUE *, VALUE);
+VALUE rb_check_funcall_with_hook(VALUE recv, ID mid, int argc, const VALUE *argv,
+                                 rb_check_funcall_hook *hook, VALUE arg);
+VALUE rb_check_funcall_with_hook_kw(VALUE recv, ID mid, int argc, const VALUE *argv,
+                                 rb_check_funcall_hook *hook, VALUE arg, int kw_splat);
+const char *rb_type_str(enum ruby_value_type type);
+VALUE rb_check_funcall_default(VALUE, ID, int, const VALUE *, VALUE);
+VALUE rb_check_funcall_basic_kw(VALUE, ID, VALUE, int, const VALUE*, int);
+VALUE rb_yield_1(VALUE val);
+VALUE rb_yield_force_blockarg(VALUE values);
+VALUE rb_lambda_call(VALUE obj, ID mid, int argc, const VALUE *argv,
+                     rb_block_call_func_t bl_proc, int min_argc, int max_argc,
+                     VALUE data2);
+
+MJIT_SYMBOL_EXPORT_BEGIN
+VALUE rb_vm_call0(struct rb_execution_context_struct *ec, VALUE recv, ID id, int argc, const VALUE *argv, const struct rb_callable_method_entry_struct *me, int kw_splat);
+VALUE rb_vm_call_kw(struct rb_execution_context_struct *ec, VALUE recv, VALUE id, int argc, const VALUE *argv, const struct rb_callable_method_entry_struct *me, int kw_splat);
+VALUE rb_make_no_method_exception(VALUE exc, VALUE format, VALUE obj, int argc, const VALUE *argv, int priv);
+MJIT_SYMBOL_EXPORT_END
+
+/* vm_insnhelper.c */
+VALUE rb_equal_opt(VALUE obj1, VALUE obj2);
+VALUE rb_eql_opt(VALUE obj1, VALUE obj2);
+
+struct rb_iseq_struct;
+MJIT_SYMBOL_EXPORT_BEGIN
+const struct rb_callcache *rb_vm_search_method_slowpath(const struct rb_callinfo *ci, VALUE klass);
+MJIT_SYMBOL_EXPORT_END
+
+/* vm_method.c */
+struct rb_execution_context_struct;
+MJIT_SYMBOL_EXPORT_BEGIN
+int rb_ec_obj_respond_to(struct rb_execution_context_struct *ec, VALUE klass, VALUE obj, ID id, int priv);
+MJIT_SYMBOL_EXPORT_END
+
+/* vm_dump.c */
+void rb_print_backtrace(void);
+
+/* vm_backtrace.c */
+VALUE rb_vm_thread_backtrace(int argc, const VALUE *argv, VALUE thval);
+VALUE rb_vm_thread_backtrace_locations(int argc, const VALUE *argv, VALUE thval);
+VALUE rb_vm_backtrace(int argc, const VALUE * argv, struct rb_execution_context_struct * ec);
+VALUE rb_vm_backtrace_locations(int argc, const VALUE * argv, struct rb_execution_context_struct * ec);
+VALUE rb_make_backtrace(void);
+void rb_backtrace_print_as_bugreport(void);
+int rb_backtrace_p(VALUE obj);
+VALUE rb_backtrace_to_str_ary(VALUE obj);
+VALUE rb_backtrace_to_location_ary(VALUE obj);
+void rb_backtrace_each(VALUE (*iter)(VALUE recv, VALUE str), VALUE output);
+
+MJIT_SYMBOL_EXPORT_BEGIN
+VALUE rb_ec_backtrace_object(const struct rb_execution_context_struct *ec);
+void rb_backtrace_use_iseq_first_lineno_for_last_location(VALUE self);
+MJIT_SYMBOL_EXPORT_END
+
+#define RUBY_DTRACE_CREATE_HOOK(name, arg) \
+    RUBY_DTRACE_HOOK(name##_CREATE, arg)
+#define RUBY_DTRACE_HOOK(name, arg) \
+do { \
+    if (UNLIKELY(RUBY_DTRACE_##name##_ENABLED())) { \
+        int dtrace_line; \
+        const char *dtrace_file = rb_source_location_cstr(&dtrace_line); \
+        if (!dtrace_file) dtrace_file = ""; \
+        RUBY_DTRACE_##name(arg, dtrace_file, dtrace_line); \
+    } \
+} while (0)
+#endif /* INTERNAL_VM_H */

data/lib/debase/ruby_core_source/ruby-3.0.0-p0/internal/warnings.h

@@ -0,0 +1,17 @@
+#ifndef INTERNAL_WARNINGS_H                              /*-*-C-*-vi:se ft=c:*/
+#define INTERNAL_WARNINGS_H
+/**
+ * @file
+ * @author     Ruby developers <ruby-core@ruby-lang.org>
+ * @copyright  This  file  is   a  part  of  the   programming  language  Ruby.
+ *             Permission  is hereby  granted,  to  either redistribute  and/or
+ *             modify this file, provided that  the conditions mentioned in the
+ *             file COPYING are met.  Consult the file for details.
+ * @brief      Internal header to suppres / mandate warnings.
+ */
+#include "ruby/internal/warning_push.h"
+#define COMPILER_WARNING_PUSH          RBIMPL_WARNING_PUSH()
+#define COMPILER_WARNING_POP           RBIMPL_WARNING_POP()
+#define COMPILER_WARNING_ERROR(flag)   RBIMPL_WARNING_ERROR(flag)
+#define COMPILER_WARNING_IGNORED(flag) RBIMPL_WARNING_IGNORED(flag)
+#endif /* INTERNAL_WARNINGS_H */

data/lib/debase/ruby_core_source/ruby-3.0.0-p0/internal.h

@@ -0,0 +1,107 @@
+#ifndef RUBY_INTERNAL_H                                  /*-*-C-*-vi:se ft=c:*/
+#define RUBY_INTERNAL_H 1
+/**
+ * @file
+ * @author     $Author$
+ * @date       Tue May 17 11:42:20 JST 2011
+ * @copyright  Copyright (C) 2011 Yukihiro Matsumoto
+ * @copyright  This  file  is   a  part  of  the   programming  language  Ruby.
+ *             Permission  is hereby  granted,  to  either redistribute  and/or
+ *             modify this file, provided that  the conditions mentioned in the
+ *             file COPYING are met.  Consult the file for details.
+ */
+#include "ruby/internal/config.h"
+
+#ifdef __cplusplus
+# error not for C++
+#endif
+
+#define LIKELY(x) RB_LIKELY(x)
+#define UNLIKELY(x) RB_UNLIKELY(x)
+
+#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)))
+
+#include "ruby/ruby.h"
+
+/* Following macros were formerly defined in this header but moved to somewhere
+ * else.  In order to detect them we undef here. */
+
+/* internal/array.h */
+#undef RARRAY_AREF
+
+/* internal/class.h */
+#undef RClass
+#undef RCLASS_SUPER
+
+/* internal/gc.h */
+#undef NEWOBJ_OF
+#undef RB_NEWOBJ_OF
+#undef RB_OBJ_WRITE
+
+/* internal/hash.h */
+#undef RHASH_IFNONE
+#undef RHASH_SIZE
+#undef RHASH_TBL
+#undef RHASH_EMPTY_P
+
+/* internal/object.h */
+#undef ROBJECT_IV_INDEX_TBL
+
+/* internal/struct.h */
+#undef RSTRUCT_LEN
+#undef RSTRUCT_PTR
+#undef RSTRUCT_SET
+#undef RSTRUCT_GET
+
+/* Also,  we  keep  the  following  macros  here.   They  are  expected  to  be
+ * overridden in each headers. */
+
+/* internal/array.h */
+#define rb_ary_new_from_args(...) rb_nonexistent_symbol(__VA_ARGS__)
+
+/* internal/io.h */
+#define rb_io_fptr_finalize(...) rb_nonexistent_symbol(__VA_ARGS__)
+
+/* internal/string.h */
+#define rb_fstring_cstr(...) rb_nonexistent_symbol(__VA_ARGS__)
+
+/* internal/symbol.h */
+#define rb_sym_intern_ascii_cstr(...) rb_nonexistent_symbol(__VA_ARGS__)
+
+/* internal/vm.h */
+#define rb_funcallv(...) rb_nonexistent_symbol(__VA_ARGS__)
+#define rb_method_basic_definition_p(...) rb_nonexistent_symbol(__VA_ARGS__)
+
+
+/* MRI debug support */
+
+/* gc.c */
+void rb_obj_info_dump(VALUE obj);
+void rb_obj_info_dump_loc(VALUE obj, const char *file, int line, const char *func);
+
+/* debug.c */
+
+RUBY_SYMBOL_EXPORT_BEGIN
+void ruby_debug_breakpoint(void);
+PRINTF_ARGS(void ruby_debug_printf(const char*, ...), 1, 2);
+RUBY_SYMBOL_EXPORT_END
+
+// show obj data structure without any side-effect
+#define rp(obj) rb_obj_info_dump_loc((VALUE)(obj), __FILE__, __LINE__, RUBY_FUNCTION_NAME_STRING)
+
+// same as rp, but add message header
+#define rp_m(msg, obj) do { \
+    fprintf(stderr, "%s", (msg)); \
+    rb_obj_info_dump((VALUE)obj); \
+} while (0)
+
+// `ruby_debug_breakpoint()` does nothing,
+// but breakpoint is set in run.gdb, so `make gdb` can stop here.
+#define bp() ruby_debug_breakpoint()
+
+#endif /* RUBY_INTERNAL_H */

data/lib/debase/ruby_core_source/{ruby-2.7.0-preview2 → ruby-3.0.0-p0}/iseq.h

@@ -1,3 +1,5 @@
+#ifndef RUBY_ISEQ_H
+#define RUBY_ISEQ_H 1
 /**********************************************************************
 
   iseq.h -
@@ -8,9 +10,8 @@
   Copyright (C) 2004-2008 Koichi Sasada
 
 **********************************************************************/
-
-#ifndef RUBY_ISEQ_H
-#define RUBY_ISEQ_H 1
+#include "internal/gc.h"
+#include "vm_core.h"
 
 RUBY_EXTERN const int ruby_api_version[];
 #define ISEQ_MAJOR_VERSION ((unsigned int)ruby_api_version[0])
@@ -23,14 +24,6 @@ typedef struct rb_iseq_struct rb_iseq_t;
 
 extern const ID rb_iseq_shared_exc_local_tbl[];
 
-static inline size_t
-rb_call_info_kw_arg_bytes(int keyword_len)
-{
-    return rb_size_mul_add_or_raise(
-        keyword_len - 1, sizeof(VALUE), sizeof(struct rb_call_info_kw_arg),
-        rb_eRuntimeError);
-}
-
 #define ISEQ_COVERAGE(iseq)           iseq->body->variable.coverage
 #define ISEQ_COVERAGE_SET(iseq, cov)  RB_OBJ_WRITE(iseq, &iseq->body->variable.coverage, cov)
 #define ISEQ_LINE_COVERAGE(iseq)      RARRAY_AREF(ISEQ_COVERAGE(iseq), COVERAGE_INDEX_LINES)
@@ -87,7 +80,7 @@ ISEQ_ORIGINAL_ISEQ_ALLOC(const rb_iseq_t *iseq, long size)
 #define ISEQ_TRANSLATED       IMEMO_FL_USER3
 #define ISEQ_MARKABLE_ISEQ    IMEMO_FL_USER4
 
-#define ISEQ_EXECUTABLE_P(iseq) (FL_TEST_RAW((iseq), ISEQ_NOT_LOADED_YET | ISEQ_USE_COMPILE_DATA) == 0)
+#define ISEQ_EXECUTABLE_P(iseq) (FL_TEST_RAW(((VALUE)iseq), ISEQ_NOT_LOADED_YET | ISEQ_USE_COMPILE_DATA) == 0)
 
 struct iseq_compile_data {
     /* GC is needed */
@@ -112,10 +105,11 @@ struct iseq_compile_data {
     int last_line;
     int label_no;
     int node_level;
+    int isolated_depth;
     unsigned int ci_index;
-    unsigned int ci_kw_index;
     const rb_compile_option_t *option;
     struct rb_id_table *ivar_cache_table;
+    const struct rb_builtin_function *builtin_function_table;
 #if OPT_SUPPORT_JOKE
     st_table *labels_table;
 #endif
@@ -155,6 +149,7 @@ iseq_imemo_alloc(void)
 VALUE rb_iseq_ibf_dump(const rb_iseq_t *iseq, VALUE opt);
 void rb_ibf_load_iseq_complete(rb_iseq_t *iseq);
 const rb_iseq_t *rb_iseq_ibf_load(VALUE str);
+const rb_iseq_t *rb_iseq_ibf_load_bytes(const char *cstr, size_t);
 VALUE rb_iseq_ibf_load_extra_data(VALUE str);
 void rb_iseq_init_trace(rb_iseq_t *iseq);
 int rb_iseq_add_local_tracepoint_recursively(const rb_iseq_t *iseq, rb_event_flag_t turnon_events, VALUE tpval, unsigned int target_line);
@@ -170,7 +165,6 @@ RUBY_SYMBOL_EXPORT_BEGIN
 /* compile.c */
 VALUE rb_iseq_compile_node(rb_iseq_t *iseq, const NODE *node);
 VALUE rb_iseq_compile_callback(rb_iseq_t *iseq, const struct rb_iseq_new_with_callback_callback_func * ifunc);
-int rb_iseq_translate_threaded_code(rb_iseq_t *iseq);
 VALUE *rb_iseq_original_iseq(const rb_iseq_t *iseq);
 void rb_iseq_build_from_ary(rb_iseq_t *iseq, VALUE misc,
 			    VALUE locals, VALUE args,
@@ -180,13 +174,12 @@ void rb_iseq_mark_insn_storage(struct iseq_compile_data_storage *arena);
 /* iseq.c */
 VALUE rb_iseq_load(VALUE data, VALUE parent, VALUE opt);
 VALUE rb_iseq_parameters(const rb_iseq_t *iseq, int is_proc);
-struct st_table *ruby_insn_make_insn_table(void);
 unsigned int rb_iseq_line_no(const rb_iseq_t *iseq, size_t pos);
 void rb_iseq_trace_set(const rb_iseq_t *iseq, rb_event_flag_t turnon_events);
 void rb_iseq_trace_set_all(rb_event_flag_t turnon_events);
-void rb_iseq_trace_on_all(void);
 void rb_iseq_insns_info_encode_positions(const rb_iseq_t *iseq);
 
+struct rb_iseq_constant_body *rb_iseq_constant_body_alloc(void);
 VALUE rb_iseqw_new(const rb_iseq_t *iseq);
 const rb_iseq_t *rb_iseqw_to_iseq(VALUE iseqw);
 
@@ -298,11 +291,11 @@ enum defined_type {
     DEFINED_EXPR,
     DEFINED_IVAR2,
     DEFINED_REF,
-    DEFINED_FUNC
+    DEFINED_FUNC,
+    DEFINED_CONST_FROM
 };
 
 VALUE rb_iseq_defined_string(enum defined_type type);
-void rb_iseq_make_compile_option(struct rb_compile_option_struct *option, VALUE opt);
 
 /* vm.c */
 VALUE rb_iseq_local_variables(const rb_iseq_t *iseq);

data/lib/debase/ruby_core_source/{ruby-2.7.0-preview2 → ruby-3.0.0-p0}/method.h

@@ -1,3 +1,5 @@
+#ifndef RUBY_METHOD_H
+#define RUBY_METHOD_H 1
 /**********************************************************************
 
   method.h -
@@ -8,10 +10,11 @@
   Copyright (C) 2009 Koichi Sasada
 
 **********************************************************************/
-#ifndef RUBY_METHOD_H
-#define RUBY_METHOD_H 1
 
 #include "internal.h"
+#include "internal/imemo.h"
+#include "internal/compilers.h"
+#include "internal/static_assert.h"
 
 #ifndef END_OF_ENUMERATION
 # if defined(__GNUC__) &&! defined(__STRICT_ANSI__)
@@ -66,8 +69,13 @@ typedef struct rb_callable_method_entry_struct { /* same fields with rb_method_e
 
 #define METHOD_ENTRY_VISI(me)  (rb_method_visibility_t)(((me)->flags & (IMEMO_FL_USER0 | IMEMO_FL_USER1)) >> (IMEMO_FL_USHIFT+0))
 #define METHOD_ENTRY_BASIC(me) (int)                   (((me)->flags & (IMEMO_FL_USER2                 )) >> (IMEMO_FL_USHIFT+2))
-#define METHOD_ENTRY_COMPLEMENTED(me)     ((me)->flags & IMEMO_FL_USER3)
-#define METHOD_ENTRY_COMPLEMENTED_SET(me) ((me)->flags = (me)->flags | IMEMO_FL_USER3)
+#define METHOD_ENTRY_COMPLEMENTED(me)        ((me)->flags & IMEMO_FL_USER3)
+#define METHOD_ENTRY_COMPLEMENTED_SET(me)    ((me)->flags |= IMEMO_FL_USER3)
+#define METHOD_ENTRY_CACHED(me)              ((me)->flags & IMEMO_FL_USER4)
+#define METHOD_ENTRY_CACHED_SET(me)          ((me)->flags |= IMEMO_FL_USER4)
+#define METHOD_ENTRY_INVALIDATED(me)         ((me)->flags & IMEMO_FL_USER5)
+#define METHOD_ENTRY_INVALIDATED_SET(me)     ((me)->flags |= IMEMO_FL_USER5)
+#define METHOD_ENTRY_CACHEABLE(me)           !(METHOD_ENTRY_VISI(me) == METHOD_VISI_PROTECTED)
 
 static inline void
 METHOD_ENTRY_VISI_SET(rb_method_entry_t *me, rb_method_visibility_t visi)
@@ -151,6 +159,7 @@ typedef struct rb_method_refined_struct {
 typedef struct rb_method_bmethod_struct {
     VALUE proc; /* should be marked */
     struct rb_hook_list_struct *hooks;
+    VALUE defined_ractor;
 } rb_method_bmethod_t;
 
 enum method_optimized_type {
@@ -177,8 +186,11 @@ struct rb_method_definition_struct {
     } body;
 
     ID original_id;
+    uintptr_t method_serial;
 };
 
+struct rb_id_table;
+
 typedef struct rb_method_definition_struct rb_method_definition_t;
 STATIC_ASSERT(sizeof_method_def, offsetof(rb_method_definition_t, body)==8);
 
@@ -202,7 +214,6 @@ const rb_method_entry_t *rb_method_entry_with_refinements(VALUE klass, ID id, VA
 const rb_method_entry_t *rb_method_entry_without_refinements(VALUE klass, ID id, VALUE *defined_class);
 const rb_method_entry_t *rb_resolve_refined_method(VALUE refinements, const rb_method_entry_t *me);
 RUBY_SYMBOL_EXPORT_BEGIN
-const rb_callable_method_entry_t *rb_resolve_refined_method_callable(VALUE refinements, const rb_callable_method_entry_t *me);
 const rb_method_entry_t *rb_resolve_me_location(const rb_method_entry_t *, VALUE[5]);
 RUBY_SYMBOL_EXPORT_END
 
@@ -215,18 +226,20 @@ int rb_method_entry_eq(const rb_method_entry_t *m1, const rb_method_entry_t *m2)
 st_index_t rb_hash_method_entry(st_index_t hash, const rb_method_entry_t *me);
 
 VALUE rb_method_entry_location(const rb_method_entry_t *me);
-VALUE rb_mod_method_location(VALUE mod, ID id);
-VALUE rb_obj_method_location(VALUE obj, ID id);
 
 void rb_free_method_entry(const rb_method_entry_t *me);
-void rb_sweep_method_entry(void *vm);
 
 const rb_method_entry_t *rb_method_entry_clone(const rb_method_entry_t *me);
 const rb_callable_method_entry_t *rb_method_entry_complement_defined_class(const rb_method_entry_t *src_me, ID called_id, VALUE defined_class);
 void rb_method_entry_copy(rb_method_entry_t *dst, const rb_method_entry_t *src);
 
+void rb_method_table_insert(VALUE klass, struct rb_id_table *table, ID method_id, const rb_method_entry_t *me);
+
 void rb_scope_visibility_set(rb_method_visibility_t);
 
 VALUE rb_unnamed_parameters(int arity);
 
+void rb_clear_method_cache(VALUE klass_or_module, ID mid);
+void rb_clear_method_cache_all(void);
+
 #endif /* RUBY_METHOD_H */

data/lib/debase/ruby_core_source/{ruby-2.7.0-preview2 → ruby-3.0.0-p0}/mjit.h

@@ -1,3 +1,5 @@
+#ifndef RUBY_MJIT_H
+#define RUBY_MJIT_H 1
 /**********************************************************************
 
   mjit.h - Interface to MRI method JIT compiler for Ruby's main thread
@@ -6,13 +8,14 @@
 
 **********************************************************************/
 
-#ifndef RUBY_MJIT_H
-#define RUBY_MJIT_H 1
+#include "ruby/internal/config.h" // defines USE_MJIT
+#include "ruby/internal/stdbool.h"
+#include "vm_core.h"
 
-#include "ruby.h"
-#include "debug_counter.h"
+# if USE_MJIT
 
-#if USE_MJIT
+#include "debug_counter.h"
+#include "ruby.h"
 
 // Special address values of a function generated from the
 // corresponding iseq by MJIT:
@@ -43,6 +46,8 @@ struct mjit_options {
     // Disable compiler optimization and add debug symbols. It can be
     // very slow.
     char debug;
+    // Add arbitrary cflags.
+    char* debug_flags;
     // If not 0, all ISeqs are synchronously compiled. For testing.
     unsigned int wait;
     // Number of calls to trigger JIT compilation. For testing.
@@ -57,12 +62,16 @@ struct mjit_options {
 
 // State of optimization switches
 struct rb_mjit_compile_info {
-    // Disable getinstancevariable/setinstancevariable optimizations based on inline cache
+    // Disable getinstancevariable/setinstancevariable optimizations based on inline cache (T_OBJECT)
     bool disable_ivar_cache;
+    // Disable getinstancevariable/setinstancevariable optimizations based on inline cache (FL_EXIVAR)
+    bool disable_exivar_cache;
     // Disable send/opt_send_without_block optimizations based on inline cache
     bool disable_send_cache;
     // Disable method inlining
     bool disable_inlining;
+    // Disable opt_getinlinecache inlining
+    bool disable_const_cache;
 };
 
 typedef VALUE (*mjit_func_t)(rb_execution_context_t *, rb_control_frame_t *);
@@ -74,13 +83,17 @@ RUBY_EXTERN bool mjit_call_p;
 extern void rb_mjit_add_iseq_to_process(const rb_iseq_t *iseq);
 extern VALUE rb_mjit_wait_call(rb_execution_context_t *ec, struct rb_iseq_constant_body *body);
 extern struct rb_mjit_compile_info* rb_mjit_iseq_compile_info(const struct rb_iseq_constant_body *body);
-extern void rb_mjit_recompile_iseq(const rb_iseq_t *iseq);
+extern void rb_mjit_before_vm_ic_update(void);
+extern void rb_mjit_after_vm_ic_update(void);
+extern void rb_mjit_recompile_send(const rb_iseq_t *iseq);
+extern void rb_mjit_recompile_ivar(const rb_iseq_t *iseq);
+extern void rb_mjit_recompile_exivar(const rb_iseq_t *iseq);
+extern void rb_mjit_recompile_inlining(const rb_iseq_t *iseq);
+extern void rb_mjit_recompile_const(const rb_iseq_t *iseq);
 RUBY_SYMBOL_EXPORT_END
 
-extern bool mjit_compile(FILE *f, const rb_iseq_t *iseq, const char *funcname);
-extern void mjit_init(struct mjit_options *opts);
-extern void mjit_postponed_job_register_start_hook(void);
-extern void mjit_postponed_job_register_finish_hook(void);
+extern bool mjit_compile(FILE *f, const rb_iseq_t *iseq, const char *funcname, int id);
+extern void mjit_init(const struct mjit_options *opts);
 extern void mjit_gc_start_hook(void);
 extern void mjit_gc_exit_hook(void);
 extern void mjit_free_iseq(const rb_iseq_t *iseq);
@@ -90,6 +103,7 @@ extern struct mjit_cont *mjit_cont_new(rb_execution_context_t *ec);
 extern void mjit_cont_free(struct mjit_cont *cont);
 extern void mjit_add_class_serial(rb_serial_t class_serial);
 extern void mjit_remove_class_serial(rb_serial_t class_serial);
+extern void mjit_mark_cc_entries(const struct rb_iseq_constant_body *const body);
 
 // A threshold used to reject long iseqs from JITting as such iseqs
 // takes too much time to be compiled.
@@ -100,9 +114,42 @@ static inline int
 mjit_target_iseq_p(struct rb_iseq_constant_body *body)
 {
     return (body->type == ISEQ_TYPE_METHOD || body->type == ISEQ_TYPE_BLOCK)
+        && !body->builtin_inline_p
         && body->iseq_size < JIT_ISEQ_SIZE_THRESHOLD;
 }
 
+#  ifdef MJIT_HEADER
+NOINLINE(static COLDFUNC VALUE mjit_exec_slowpath(rb_execution_context_t *ec, const rb_iseq_t *iseq, struct rb_iseq_constant_body *body));
+#  else
+static inline VALUE mjit_exec_slowpath(rb_execution_context_t *ec, const rb_iseq_t *iseq, struct rb_iseq_constant_body *body);
+#  endif
+static VALUE
+mjit_exec_slowpath(rb_execution_context_t *ec, const rb_iseq_t *iseq, struct rb_iseq_constant_body *body)
+{
+    uintptr_t func_i = (uintptr_t)(body->jit_func);
+    ASSUME(func_i <= LAST_JIT_ISEQ_FUNC);
+    switch ((enum rb_mjit_iseq_func)func_i) {
+      case NOT_ADDED_JIT_ISEQ_FUNC:
+        RB_DEBUG_COUNTER_INC(mjit_exec_not_added);
+        if (body->total_calls == mjit_opts.min_calls && mjit_target_iseq_p(body)) {
+            rb_mjit_add_iseq_to_process(iseq);
+            if (UNLIKELY(mjit_opts.wait)) {
+                return rb_mjit_wait_call(ec, body);
+            }
+        }
+        break;
+      case NOT_READY_JIT_ISEQ_FUNC:
+        RB_DEBUG_COUNTER_INC(mjit_exec_not_ready);
+        break;
+      case NOT_COMPILED_JIT_ISEQ_FUNC:
+        RB_DEBUG_COUNTER_INC(mjit_exec_not_compiled);
+        break;
+      default: // to avoid warning with LAST_JIT_ISEQ_FUNC
+        break;
+    }
+    return Qundef;
+}
+
 // Try to execute the current iseq in ec.  Use JIT code if it is ready.
 // If it is not, add ISEQ to the compilation queue and return Qundef.
 static inline VALUE
@@ -110,8 +157,6 @@ mjit_exec(rb_execution_context_t *ec)
 {
     const rb_iseq_t *iseq;
     struct rb_iseq_constant_body *body;
-    long unsigned total_calls;
-    mjit_func_t func;
 
     if (!mjit_call_p)
         return Qundef;
@@ -119,53 +164,44 @@ mjit_exec(rb_execution_context_t *ec)
 
     iseq = ec->cfp->iseq;
     body = iseq->body;
-    total_calls = ++body->total_calls;
+    body->total_calls++;
 
-    func = body->jit_func;
-    if (UNLIKELY((uintptr_t)func <= (uintptr_t)LAST_JIT_ISEQ_FUNC)) {
-#     ifdef MJIT_HEADER
+    mjit_func_t func = body->jit_func;
+    if (UNLIKELY((uintptr_t)func <= LAST_JIT_ISEQ_FUNC)) {
+#  ifdef MJIT_HEADER
         RB_DEBUG_COUNTER_INC(mjit_frame_JT2VM);
-#     else
+#  else
         RB_DEBUG_COUNTER_INC(mjit_frame_VM2VM);
-#     endif
-        switch ((enum rb_mjit_iseq_func)func) {
-          case NOT_ADDED_JIT_ISEQ_FUNC:
-            RB_DEBUG_COUNTER_INC(mjit_exec_not_added);
-            if (total_calls == mjit_opts.min_calls && mjit_target_iseq_p(body)) {
-                RB_DEBUG_COUNTER_INC(mjit_exec_not_added_add_iseq);
-                rb_mjit_add_iseq_to_process(iseq);
-                if (UNLIKELY(mjit_opts.wait)) {
-                    return rb_mjit_wait_call(ec, body);
-                }
-            }
-            return Qundef;
-          case NOT_READY_JIT_ISEQ_FUNC:
-            RB_DEBUG_COUNTER_INC(mjit_exec_not_ready);
-            return Qundef;
-          case NOT_COMPILED_JIT_ISEQ_FUNC:
-            RB_DEBUG_COUNTER_INC(mjit_exec_not_compiled);
-            return Qundef;
-          default: // to avoid warning with LAST_JIT_ISEQ_FUNC
-            break;
-        }
+#  endif
+        return mjit_exec_slowpath(ec, iseq, body);
     }
 
-#   ifdef MJIT_HEADER
-      RB_DEBUG_COUNTER_INC(mjit_frame_JT2JT);
-#   else
-      RB_DEBUG_COUNTER_INC(mjit_frame_VM2JT);
-#   endif
+#  ifdef MJIT_HEADER
+    RB_DEBUG_COUNTER_INC(mjit_frame_JT2JT);
+#  else
+    RB_DEBUG_COUNTER_INC(mjit_frame_VM2JT);
+#  endif
     RB_DEBUG_COUNTER_INC(mjit_exec_call_func);
     return func(ec, ec->cfp);
 }
 
 void mjit_child_after_fork(void);
 
-#else // USE_MJIT
+#  ifdef MJIT_HEADER
+#define mjit_enabled true
+#  else // MJIT_HEADER
+extern bool mjit_enabled;
+#  endif // MJIT_HEADER
+VALUE mjit_pause(bool wait_p);
+VALUE mjit_resume(void);
+void mjit_finish(bool close_handle_p);
+
+# else // USE_MJIT
+
+static inline void rb_mjit_before_vm_ic_update(void){}
+static inline void rb_mjit_after_vm_ic_update(void){}
 static inline struct mjit_cont *mjit_cont_new(rb_execution_context_t *ec){return NULL;}
 static inline void mjit_cont_free(struct mjit_cont *cont){}
-static inline void mjit_postponed_job_register_start_hook(void){}
-static inline void mjit_postponed_job_register_finish_hook(void){}
 static inline void mjit_gc_start_hook(void){}
 static inline void mjit_gc_exit_hook(void){}
 static inline void mjit_free_iseq(const rb_iseq_t *iseq){}
@@ -175,5 +211,10 @@ static inline void mjit_remove_class_serial(rb_serial_t class_serial){}
 static inline VALUE mjit_exec(rb_execution_context_t *ec) { return Qundef; /* unreachable */ }
 static inline void mjit_child_after_fork(void){}
 
-#endif // USE_MJIT
+#define mjit_enabled false
+static inline VALUE mjit_pause(bool wait_p){ return Qnil; } // unreachable
+static inline VALUE mjit_resume(void){ return Qnil; } // unreachable
+static inline void mjit_finish(bool close_handle_p){}
+
+# endif // USE_MJIT
 #endif // RUBY_MJIT_H