debase-ruby_core_source 0.9.9 → 0.9.10

data/lib/debase/ruby_core_source/{ruby-2.4.0-preview2 → ruby-2.2.8-p477}/vm_core.h

@@ -2,7 +2,7 @@
 
   vm_core.h -
 
-  $Author: ko1 $
+  $Author: usa $
   created at: 04/01/01 19:41:38 JST
 
   Copyright (C) 2004-2007 Koichi Sasada
@@ -12,49 +12,6 @@
 #ifndef RUBY_VM_CORE_H
 #define RUBY_VM_CORE_H
 
-/*
- * Enable check mode.
- *   1: enable local assertions.
- */
-#ifndef VM_CHECK_MODE
-#define VM_CHECK_MODE 0
-#endif
-
-/**
- * VM Debug Level
- *
- * debug level:
- *  0: no debug output
- *  1: show instruction name
- *  2: show stack frame when control stack frame is changed
- *  3: show stack status
- *  4: show register
- *  5:
- * 10: gc check
- */
-
-#ifndef VMDEBUG
-#define VMDEBUG 0
-#endif
-
-#if 0
-#undef  VMDEBUG
-#define VMDEBUG 3
-#endif
-
-#include "ruby_assert.h"
-
-#if VM_CHECK_MODE > 0
-#define VM_ASSERT(expr) ( \
-	RUBY_ASSERT_WHEN(VM_CHECK_MODE > 0, expr))
-
-#define VM_UNREACHABLE(func) rb_bug(#func ": unreachable")
-
-#else
-#define VM_ASSERT(expr) ((void)0)
-#define VM_UNREACHABLE(func) ((void)0)
-#endif
-
 #define RUBY_VM_THREAD_MODEL 2
 
 #include "ruby/ruby.h"
@@ -79,8 +36,10 @@
 #ifdef _WIN32
 /*
  * TODO: object space independent st_table.
- * socklist and conlist will be freed exit_handler(), after object
- * space destruction.
+ * socklist needs st_table in rb_w32_sysinit(), before object space
+ * initialization.
+ * It is too early now to change st_hash_type, since it breaks binary
+ * compatibility.
  */
 #define ENABLE_VM_OBJSPACE 0
 #else
@@ -149,43 +108,15 @@
 
 typedef unsigned long rb_num_t;
 
-enum ruby_tag_type {
-    RUBY_TAG_RETURN	= 0x1,
-    RUBY_TAG_BREAK	= 0x2,
-    RUBY_TAG_NEXT	= 0x3,
-    RUBY_TAG_RETRY	= 0x4,
-    RUBY_TAG_REDO	= 0x5,
-    RUBY_TAG_RAISE	= 0x6,
-    RUBY_TAG_THROW	= 0x7,
-    RUBY_TAG_FATAL	= 0x8,
-    RUBY_TAG_MASK	= 0xf
-};
-#define TAG_RETURN	RUBY_TAG_RETURN
-#define TAG_BREAK	RUBY_TAG_BREAK
-#define TAG_NEXT	RUBY_TAG_NEXT
-#define TAG_RETRY	RUBY_TAG_RETRY
-#define TAG_REDO	RUBY_TAG_REDO
-#define TAG_RAISE	RUBY_TAG_RAISE
-#define TAG_THROW	RUBY_TAG_THROW
-#define TAG_FATAL	RUBY_TAG_FATAL
-#define TAG_MASK	RUBY_TAG_MASK
-
-enum ruby_vm_throw_flags {
-    VM_THROW_NO_ESCAPE_FLAG = 0x8000,
-    VM_THROW_LEVEL_SHIFT = 16,
-    VM_THROW_STATE_MASK = 0xff
-};
+/* iseq data type */
 
-/* forward declarations */
-struct rb_thread_struct;
-struct rb_control_frame_struct;
+struct iseq_compile_data_ensure_node_stack;
 
-/* iseq data type */
 typedef struct rb_compile_option_struct rb_compile_option_t;
 
+
 struct iseq_inline_cache_entry {
     rb_serial_t ic_serial;
-    const rb_cref_t *ic_cref;
     union {
 	size_t index;
 	VALUE value;
@@ -200,76 +131,74 @@ union iseq_inline_storage_entry {
     struct iseq_inline_cache_entry cache;
 };
 
-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
-};
-
-struct rb_call_info {
-    /* fixed at compile time */
-    ID mid;
-    unsigned int flag;
-    int orig_argc;
-};
+/* to avoid warning */
+struct rb_thread_struct;
+struct rb_control_frame_struct;
 
-struct rb_call_info_kw_arg {
+typedef struct rb_call_info_kw_arg_struct {
     int keyword_len;
     VALUE keywords[1];
-};
+} rb_call_info_kw_arg_t;
 
-struct rb_call_info_with_kwarg {
-    struct rb_call_info ci;
-    struct rb_call_info_kw_arg *kw_arg;
-};
-
-struct rb_calling_info {
-    VALUE block_handler;
-    VALUE recv;
-    int argc;
-};
+/* rb_call_info_t contains calling information including inline cache */
+typedef struct rb_call_info_struct {
+    /* fixed at compile time */
+    ID mid;
 
-struct rb_call_cache;
-typedef VALUE (*vm_call_handler)(struct rb_thread_struct *th, struct rb_control_frame_struct *cfp, struct rb_calling_info *calling, const struct rb_call_info *ci, struct rb_call_cache *cc);
+    unsigned int flag;
+    int orig_argc;
+    rb_iseq_t *blockiseq;
+    rb_call_info_kw_arg_t *kw_arg;
 
-struct rb_call_cache {
     /* inline cache: keys */
     rb_serial_t method_state;
     rb_serial_t class_serial;
+    VALUE klass;
 
     /* inline cache: values */
-    const rb_callable_method_entry_t *me;
-
-    vm_call_handler call;
+    const rb_method_entry_t *me;
+    VALUE defined_class;
 
+    /* temporary values for method calling */
+    struct rb_block_struct *blockptr;
+    VALUE recv;
+    int argc;
     union {
-	unsigned int index; /* used by ivar */
-	enum method_missing_reason method_missing_reason; /* used by method_missing */
+	int opt_pc; /* used by iseq */
+	int index; /* used by ivar */
+	int missing_reason; /* used by method_missing */
 	int inc_sp; /* used by cfunc */
     } aux;
-};
+
+    VALUE (*call)(struct rb_thread_struct *th, struct rb_control_frame_struct *cfp, struct rb_call_info_struct *ci);
+} rb_call_info_t;
 
 #if 1
-#define CoreDataFromValue(obj, type) (type*)DATA_PTR(obj)
+#define GetCoreDataFromValue(obj, type, ptr) do { \
+    (ptr) = (type*)DATA_PTR(obj); \
+} while (0)
 #else
-#define CoreDataFromValue(obj, type) (type*)rb_data_object_get(obj)
+#define GetCoreDataFromValue(obj, type, ptr) Data_Get_Struct((obj), type, (ptr))
 #endif
-#define GetCoreDataFromValue(obj, type, ptr) ((ptr) = CoreDataFromValue((obj), type))
+
+#define GetISeqPtr(obj, ptr) \
+  GetCoreDataFromValue((obj), rb_iseq_t, (ptr))
 
 typedef struct rb_iseq_location_struct {
-    VALUE path;
-    VALUE absolute_path;
-    VALUE base_label;
-    VALUE label;
+    const VALUE path;
+    const VALUE absolute_path;
+    const VALUE base_label;
+    const VALUE label;
     VALUE first_lineno; /* TODO: may be unsigned short */
 } rb_iseq_location_t;
 
-struct rb_iseq_constant_body {
+struct rb_iseq_struct;
+
+struct rb_iseq_struct {
+    /***************/
+    /* static data */
+    /***************/
+
     enum iseq_type {
 	ISEQ_TYPE_TOP,
 	ISEQ_TYPE_METHOD,
@@ -281,9 +210,34 @@ struct rb_iseq_constant_body {
 	ISEQ_TYPE_MAIN,
 	ISEQ_TYPE_DEFINED_GUARD
     } type;              /* instruction sequence type */
+#if defined(WORDS_BIGENDIAN) && (SIZEOF_VALUE > SIZEOF_INT)
+    char dummy[SIZEOF_VALUE - SIZEOF_INT]; /* [Bug #10037][ruby-core:63721] */
+#endif
+    int stack_max; /* for stack overflow check */
+
+    rb_iseq_location_t location;
 
+    VALUE *iseq_encoded; /* encoded iseq (insn addr and operands) */
     unsigned int iseq_size;
-    const VALUE *iseq_encoded; /* encoded iseq (insn addr and operands) */
+    unsigned int line_info_size;
+
+    const VALUE mark_ary;     /* Array: includes operands which should be GC marked */
+    const VALUE coverage;     /* coverage array */
+
+    /* insn info, must be freed */
+    struct iseq_line_info_entry *line_info_table;
+
+    ID *local_table;		/* must free */
+    int local_table_size;
+
+    /* sizeof(vars) + 1 */
+    int local_size;
+
+    union iseq_inline_storage_entry *is_entries;
+    int is_size;
+
+    int callinfo_size;
+    rb_call_info_t *callinfo_entries;
 
     /**
      * parameter information
@@ -321,7 +275,7 @@ struct rb_iseq_constant_body {
 	    unsigned int ambiguous_param0 : 1; /* {|a|} */
 	} flags;
 
-	unsigned int size;
+	int size;
 
 	int lead_num;
 	int opt_num;
@@ -330,7 +284,7 @@ struct rb_iseq_constant_body {
 	int post_num;
 	int block_start;
 
-	const VALUE *opt_table; /* (opt_num + 1) entries. */
+	VALUE *opt_table; /* (opt_num + 1) entries. */
 	/* opt_num and opt_table:
 	 *
 	 * def foo o1=e1, o2=e2, ..., oN=eN
@@ -345,83 +299,53 @@ struct rb_iseq_constant_body {
 	 * opt_table = [A1, A2, ..., AN, AL]
 	 */
 
-	const struct rb_iseq_param_keyword {
+	struct rb_iseq_param_keyword {
 	    int num;
 	    int required_num;
 	    int bits_start;
 	    int rest_start;
-	    const ID *table;
-	    const VALUE *default_values;
+	    ID *table;
+	    VALUE *default_values;
 	} *keyword;
     } param;
 
-    rb_iseq_location_t location;
-
-    /* insn info, must be freed */
-    const struct iseq_line_info_entry *line_info_table;
-
-    const ID *local_table;		/* must free */
-
     /* catch table */
-    const struct iseq_catch_table *catch_table;
+    struct iseq_catch_table *catch_table;
 
     /* for child iseq */
-    const struct rb_iseq_struct *parent_iseq;
-    struct rb_iseq_struct *local_iseq; /* local_iseq->flip_cnt can be modified */
+    struct rb_iseq_struct *parent_iseq;
+    struct rb_iseq_struct *local_iseq;
 
-    union iseq_inline_storage_entry *is_entries;
-    struct rb_call_info *ci_entries; /* struct rb_call_info ci_entries[ci_size];
-				      * struct rb_call_info_with_kwarg cikw_entries[ci_kw_size];
-				      * So that:
-				      * struct rb_call_info_with_kwarg *cikw_entries = &body->ci_entries[ci_size];
-				      */
-    struct rb_call_cache *cc_entries; /* size is ci_size = ci_kw_size */
-
-    VALUE mark_ary;     /* Array: includes operands which should be GC marked */
-
-    unsigned int local_table_size;
-    unsigned int is_size;
-    unsigned int ci_size;
-    unsigned int ci_kw_size;
-    unsigned int line_info_size;
-    unsigned int stack_max; /* for stack overflow check */
-};
-
-/* T_IMEMO/iseq */
-/* typedef rb_iseq_t is in method.h */
-struct rb_iseq_struct {
-    VALUE flags;
-    VALUE reserved1;
-    struct rb_iseq_constant_body *body;
+    /****************/
+    /* dynamic data */
+    /****************/
 
-    union { /* 4, 5 words */
-	struct iseq_compile_data *compile_data; /* used at compile time */
+    VALUE self;
+    const VALUE orig;			/* non-NULL if its data have origin */
+
+    /* block inlining */
+    /*
+     * NODE *node;
+     * void *special_block_builder;
+     * void *cached_special_block_builder;
+     * VALUE cached_special_block;
+     */
 
-	struct {
-	    VALUE obj;
-	    int index;
-	} loader;
-    } aux;
-};
+    /* klass/module nest information stack (cref) */
+    NODE * const cref_stack;
+    const VALUE klass;
 
-#ifndef USE_LAZY_LOAD
-#define USE_LAZY_LOAD 0
-#endif
+    /* misc */
+    ID defined_method_id;	/* for define_method */
+    rb_num_t flip_cnt;
 
-#if USE_LAZY_LOAD
-const rb_iseq_t *rb_iseq_complete(const rb_iseq_t *iseq);
-#endif
+    /* used at compile time */
+    struct iseq_compile_data *compile_data;
 
-static inline const rb_iseq_t *
-rb_iseq_check(const rb_iseq_t *iseq)
-{
-#if USE_LAZY_LOAD
-    if (iseq->body == NULL) {
-	rb_iseq_complete((rb_iseq_t *)iseq);
-    }
-#endif
-    return iseq;
-}
+    /* original iseq, before encoding
+     * used for debug/dump (TODO: union with compile_data) */
+    VALUE *iseq;
+};
 
 enum ruby_special_exceptions {
     ruby_error_reenter,
@@ -454,8 +378,6 @@ enum ruby_basic_operators {
     BOP_NEQ,
     BOP_MATCH,
     BOP_FREEZE,
-    BOP_MAX,
-    BOP_MIN,
 
     BOP_LAST_
 };
@@ -465,15 +387,15 @@ enum ruby_basic_operators {
 
 struct rb_vm_struct;
 typedef void rb_vm_at_exit_func(struct rb_vm_struct*);
-
 typedef struct rb_at_exit_list {
     rb_vm_at_exit_func *func;
     struct rb_at_exit_list *next;
 } rb_at_exit_list;
 
+#if defined(ENABLE_VM_OBJSPACE) && ENABLE_VM_OBJSPACE
 struct rb_objspace;
-struct rb_objspace *rb_objspace_alloc(void);
 void rb_objspace_free(struct rb_objspace *);
+#endif
 
 typedef struct rb_hook_list_struct {
     struct rb_event_hook_struct *hooks;
@@ -494,14 +416,14 @@ typedef struct rb_vm_struct {
     size_t living_thread_num;
     VALUE thgroup_default;
 
-    unsigned int running: 1;
-    unsigned int thread_abort_on_exception: 1;
-    unsigned int thread_report_on_exception: 1;
-    unsigned int trace_running: 1;
+    int running;
+    int thread_abort_on_exception;
+    int trace_running;
     volatile int sleeper;
 
     /* object management */
     VALUE mark_object_ary;
+
     const VALUE special_exceptions[ruby_special_error_count];
 
     /* load */
@@ -536,9 +458,13 @@ typedef struct rb_vm_struct {
     VALUE verbose, debug, orig_progname, progname;
     VALUE coverages;
 
+    struct unlinked_method_entry_list_entry *unlinked_method_entry_list;
+
     VALUE defined_module_hash;
 
+#if defined(ENABLE_VM_OBJSPACE) && ENABLE_VM_OBJSPACE
     struct rb_objspace *objspace;
+#endif
 
     rb_at_exit_list *at_exit;
 
@@ -571,18 +497,15 @@ typedef struct rb_vm_struct {
 #define RUBY_VM_FIBER_MACHINE_STACK_SIZE_MIN  (  16 * 1024 * sizeof(VALUE)) /*   64 KB or  128 KB */
 
 /* optimize insn */
-#define INTEGER_REDEFINED_OP_FLAG (1 << 0)
+#define FIXNUM_REDEFINED_OP_FLAG (1 << 0)
 #define FLOAT_REDEFINED_OP_FLAG  (1 << 1)
 #define STRING_REDEFINED_OP_FLAG (1 << 2)
 #define ARRAY_REDEFINED_OP_FLAG  (1 << 3)
 #define HASH_REDEFINED_OP_FLAG   (1 << 4)
-/* #define BIGNUM_REDEFINED_OP_FLAG (1 << 5) */
+#define BIGNUM_REDEFINED_OP_FLAG (1 << 5)
 #define SYMBOL_REDEFINED_OP_FLAG (1 << 6)
 #define TIME_REDEFINED_OP_FLAG   (1 << 7)
 #define REGEXP_REDEFINED_OP_FLAG (1 << 8)
-#define NIL_REDEFINED_OP_FLAG    (1 << 9)
-#define TRUE_REDEFINED_OP_FLAG   (1 << 10)
-#define FALSE_REDEFINED_OP_FLAG  (1 << 11)
 
 #define BASIC_OP_UNREDEFINED_P(op, klass) (LIKELY((GET_VM()->redefined_flag[(op)]&(klass)) == 0))
 
@@ -591,55 +514,34 @@ typedef struct rb_vm_struct {
 #endif
 
 #ifndef VM_DEBUG_VERIFY_METHOD_CACHE
-#define VM_DEBUG_VERIFY_METHOD_CACHE (VM_DEBUG_MODE != 0)
+#define VM_DEBUG_VERIFY_METHOD_CACHE 0
 #endif
 
-struct rb_captured_block {
-    VALUE self;
-    const VALUE *ep;
-    union {
-	const rb_iseq_t *iseq;
-	const struct vm_ifunc *ifunc;
-	VALUE val;
-    } code;
-};
-
-enum rb_block_handler_type {
-    block_handler_type_iseq,
-    block_handler_type_ifunc,
-    block_handler_type_symbol,
-    block_handler_type_proc
-};
-
-enum rb_block_type {
-    block_type_iseq,
-    block_type_ifunc,
-    block_type_symbol,
-    block_type_proc
-};
-
-struct rb_block {
-    union {
-	struct rb_captured_block captured;
-	VALUE symbol;
-	VALUE proc;
-    } as;
-    enum rb_block_type type;
-};
-
 typedef struct rb_control_frame_struct {
-    const VALUE *pc;		/* cfp[0] */
+    VALUE *pc;			/* cfp[0] */
     VALUE *sp;			/* cfp[1] */
-    const rb_iseq_t *iseq;	/* cfp[2] */
-    VALUE self;			/* cfp[3] / block[0] */
-    const VALUE *ep;		/* cfp[4] / block[1] */
-    const void *block_code;     /* cfp[5] / block[2] */ /* iseq or ifunc */
+    rb_iseq_t *iseq;		/* cfp[2] */
+    VALUE flag;			/* cfp[3] */
+    VALUE self;			/* cfp[4] / block[0] */
+    VALUE klass;		/* cfp[5] / block[1] */
+    VALUE *ep;			/* cfp[6] / block[2] */
+    rb_iseq_t *block_iseq;	/* cfp[7] / block[3] */
+    VALUE proc;			/* cfp[8] / block[4] */
+    const rb_method_entry_t *me;/* cfp[9] */
 
 #if VM_DEBUG_BP_CHECK
-    VALUE *bp_check;		/* cfp[6] */
+    VALUE *bp_check;		/* cfp[10] */
 #endif
 } rb_control_frame_t;
 
+typedef struct rb_block_struct {
+    VALUE self;			/* share with method frame if it's only block */
+    VALUE klass;		/* share with method frame if it's only block */
+    VALUE *ep;			/* share with method frame if it's only block */
+    rb_iseq_t *iseq;
+    VALUE proc;
+} rb_block_t;
+
 extern const rb_data_type_t ruby_threadptr_data_type;
 
 #define GetThreadPtr(obj, ptr) \
@@ -676,11 +578,13 @@ struct rb_unblock_callback {
 
 struct rb_mutex_struct;
 
+struct rb_thread_struct;
 typedef struct rb_thread_list_struct{
     struct rb_thread_list_struct *next;
     struct rb_thread_struct *th;
 } rb_thread_list_t;
 
+
 typedef struct rb_ensure_entry {
     VALUE marker;
     VALUE (*e_proc)(ANYARGS);
@@ -715,20 +619,22 @@ typedef struct rb_thread_struct {
     int waiting_fd;
 
     /* for rb_iterate */
-    VALUE passed_block_handler;
+    const rb_block_t *passed_block;
 
     /* for bmethod */
-    const rb_callable_method_entry_t *passed_bmethod_me;
+    const rb_method_entry_t *passed_bmethod_me;
 
     /* for cfunc */
-    struct rb_calling_info *calling;
+    rb_call_info_t *passed_ci;
 
     /* for load(true) */
     VALUE top_self;
     VALUE top_wrapper;
 
     /* eval env */
-    const VALUE *root_lep;
+    rb_block_t *base_block;
+
+    VALUE *root_lep;
     VALUE root_svar;
 
     /* thread control */
@@ -770,6 +676,20 @@ typedef struct rb_thread_struct {
     struct rb_vm_tag *tag;
     struct rb_vm_protect_tag *protect_tag;
 
+    /*! Thread-local state of evaluation context.
+     *
+     *  If negative, this thread is evaluating the main program.
+     *  If positive, this thread is evaluating a program under Kernel::eval
+     *  family.
+     */
+    int parse_in_eval;
+
+    /*! Thread-local state of compiling context.
+     *
+     * If non-zero, the parser does not automatically print error messages to
+     * stderr. */
+    int mild_compile_error;
+
     /* storage */
     st_table *local_storage;
     VALUE local_storage_recursive_hash;
@@ -810,14 +730,12 @@ typedef struct rb_thread_struct {
     rb_ensure_list_t *ensure_list;
 
     /* misc */
-    enum method_missing_reason method_missing_reason: 8;
-    unsigned int abort_on_exception: 1;
-    unsigned int report_on_exception: 1;
+    int method_missing_reason;
+    int abort_on_exception;
 #ifdef USE_SIGALTSTACK
     void *altstack;
 #endif
     unsigned long running_time_us;
-    VALUE name;
 } rb_thread_t;
 
 typedef enum {
@@ -839,25 +757,24 @@ typedef enum {
 RUBY_SYMBOL_EXPORT_BEGIN
 
 /* node -> iseq */
-rb_iseq_t *rb_iseq_new(NODE*, VALUE, VALUE, VALUE, const rb_iseq_t *parent, enum iseq_type);
-rb_iseq_t *rb_iseq_new_top(NODE *node, VALUE name, VALUE path, VALUE absolute_path, const rb_iseq_t *parent);
-rb_iseq_t *rb_iseq_new_main(NODE *node, VALUE path, VALUE absolute_path, const rb_iseq_t *parent);
-rb_iseq_t *rb_iseq_new_with_bopt(NODE*, VALUE, VALUE, VALUE, VALUE, VALUE, enum iseq_type, VALUE);
-rb_iseq_t *rb_iseq_new_with_opt(NODE*, VALUE, VALUE, VALUE, VALUE, const rb_iseq_t *parent, enum iseq_type, const rb_compile_option_t*);
+VALUE rb_iseq_new(NODE*, VALUE, VALUE, VALUE, VALUE, enum iseq_type);
+VALUE rb_iseq_new_top(NODE *node, VALUE name, VALUE path, VALUE absolute_path, VALUE parent);
+VALUE rb_iseq_new_main(NODE *node, VALUE path, VALUE absolute_path);
+VALUE rb_iseq_new_with_bopt(NODE*, VALUE, VALUE, VALUE, VALUE, VALUE, enum iseq_type, VALUE);
+VALUE rb_iseq_new_with_opt(NODE*, VALUE, VALUE, VALUE, VALUE, VALUE, enum iseq_type, const rb_compile_option_t*);
 
 /* src -> iseq */
-rb_iseq_t *rb_iseq_compile(VALUE src, VALUE file, VALUE line);
-rb_iseq_t *rb_iseq_compile_on_base(VALUE src, VALUE file, VALUE line, const struct rb_block *base_block);
-rb_iseq_t *rb_iseq_compile_with_option(VALUE src, VALUE file, VALUE absolute_path, VALUE line, const struct rb_block *base_block, VALUE opt);
+VALUE rb_iseq_compile(VALUE src, VALUE file, VALUE line);
+VALUE rb_iseq_compile_on_base(VALUE src, VALUE file, VALUE line, rb_block_t *base_block);
+VALUE rb_iseq_compile_with_option(VALUE src, VALUE file, VALUE absolute_path, VALUE line, rb_block_t *base_block, VALUE opt);
 
-VALUE rb_iseq_disasm(const rb_iseq_t *iseq);
+VALUE rb_iseq_disasm(VALUE self);
 int rb_iseq_disasm_insn(VALUE str, const VALUE *iseqval, size_t pos, const rb_iseq_t *iseq, VALUE child);
 const char *ruby_node_name(int node);
 
-VALUE rb_iseq_coverage(const rb_iseq_t *iseq);
-
 RUBY_EXTERN VALUE rb_cISeq;
 RUBY_EXTERN VALUE rb_cRubyVM;
+RUBY_EXTERN VALUE rb_cEnv;
 RUBY_EXTERN VALUE rb_mRubyVMFrozenCore;
 RUBY_SYMBOL_EXPORT_END
 
@@ -865,18 +782,24 @@ RUBY_SYMBOL_EXPORT_END
   GetCoreDataFromValue((obj), rb_proc_t, (ptr))
 
 typedef struct {
-    const struct rb_block block;
-    int8_t safe_level;		/* 0..1 */
+    rb_block_t block;
+
+    VALUE envval;		/* for GC mark */
+    VALUE blockprocval;
+    int8_t safe_level;		/* 0..3 */
     int8_t is_from_method;	/* bool */
     int8_t is_lambda;		/* bool */
 } rb_proc_t;
 
+#define GetEnvPtr(obj, ptr) \
+  GetCoreDataFromValue((obj), rb_env_t, (ptr))
+
 typedef struct {
-    VALUE flags; /* imemo header */
-    const rb_iseq_t *iseq;
-    const VALUE *ep;
-    const VALUE *env;
-    unsigned int env_size;
+    int env_size;
+    int local_size;
+    VALUE prev_envval;		/* for GC mark */
+    rb_block_t block;
+    VALUE env[1];               /* flexible array */
 } rb_env_t;
 
 extern const rb_data_type_t ruby_binding_data_type;
@@ -885,8 +808,9 @@ extern const rb_data_type_t ruby_binding_data_type;
   GetCoreDataFromValue((obj), rb_binding_t, (ptr))
 
 typedef struct {
-    struct rb_block block;
+    VALUE env;
     VALUE path;
+    VALUE blockprocval;	/* for GC mark */
     unsigned short first_lineno;
 } rb_binding_t;
 
@@ -901,16 +825,14 @@ enum vm_check_match_type {
 #define VM_CHECKMATCH_TYPE_MASK   0x03
 #define VM_CHECKMATCH_ARRAY       0x04
 
-#define VM_CALL_ARGS_SPLAT      (0x01 << 0) /* m(*args) */
-#define VM_CALL_ARGS_BLOCKARG   (0x01 << 1) /* m(&block) */
-#define VM_CALL_FCALL           (0x01 << 2) /* m(...) */
-#define VM_CALL_VCALL           (0x01 << 3) /* m */
-#define VM_CALL_ARGS_SIMPLE     (0x01 << 4) /* (ci->flag & (SPLAT|BLOCKARG)) && blockiseq == NULL && ci->kw_arg == NULL */
-#define VM_CALL_BLOCKISEQ       (0x01 << 5) /* has blockiseq */
-#define VM_CALL_KWARG           (0x01 << 6) /* has kwarg */
-#define VM_CALL_TAILCALL        (0x01 << 7) /* located at tail position */
-#define VM_CALL_SUPER           (0x01 << 8) /* super */
-#define VM_CALL_OPT_SEND        (0x01 << 9) /* internal flag */
+#define VM_CALL_ARGS_SPLAT      (0x01 << 1) /* m(*args) */
+#define VM_CALL_ARGS_BLOCKARG   (0x01 << 2) /* m(&block) */
+#define VM_CALL_FCALL           (0x01 << 3) /* m(...) */
+#define VM_CALL_VCALL           (0x01 << 4) /* m */
+#define VM_CALL_TAILCALL        (0x01 << 5) /* located at tail position */
+#define VM_CALL_SUPER           (0x01 << 6) /* super */
+#define VM_CALL_OPT_SEND        (0x01 << 7) /* internal flag */
+#define VM_CALL_ARGS_SIMPLE     (0x01 << 8) /* (ci->flag & (SPLAT|BLOCKARG)) && ci->blockiseq == NULL && ci->kw_arg == NULL */
 
 enum vm_special_object_type {
     VM_SPECIAL_OBJECT_VMCORE = 1,
@@ -918,18 +840,34 @@ enum vm_special_object_type {
     VM_SPECIAL_OBJECT_CONST_BASE
 };
 
-enum vm_svar_index {
-    VM_SVAR_LASTLINE = 0,      /* $_ */
-    VM_SVAR_BACKREF = 1,       /* $~ */
+#define VM_FRAME_MAGIC_METHOD 0x11
+#define VM_FRAME_MAGIC_BLOCK  0x21
+#define VM_FRAME_MAGIC_CLASS  0x31
+#define VM_FRAME_MAGIC_TOP    0x41
+#define VM_FRAME_MAGIC_CFUNC  0x61
+#define VM_FRAME_MAGIC_PROC   0x71
+#define VM_FRAME_MAGIC_IFUNC  0x81
+#define VM_FRAME_MAGIC_EVAL   0x91
+#define VM_FRAME_MAGIC_LAMBDA 0xa1
+#define VM_FRAME_MAGIC_RESCUE 0xb1
+#define VM_FRAME_MAGIC_MASK_BITS 8
+#define VM_FRAME_MAGIC_MASK   (~(~(VALUE)0<<VM_FRAME_MAGIC_MASK_BITS))
+
+#define VM_FRAME_TYPE(cfp) ((cfp)->flag & VM_FRAME_MAGIC_MASK)
+
+/* other frame flag */
+#define VM_FRAME_FLAG_PASSED  0x0100
+#define VM_FRAME_FLAG_FINISH  0x0200
+#define VM_FRAME_FLAG_BMETHOD 0x0400
+#define VM_FRAME_TYPE_FINISH_P(cfp)  (((cfp)->flag & VM_FRAME_FLAG_FINISH) != 0)
+#define VM_FRAME_TYPE_BMETHOD_P(cfp) (((cfp)->flag & VM_FRAME_FLAG_BMETHOD) != 0)
 
-    VM_SVAR_EXTRA_START = 2,
-    VM_SVAR_FLIPFLOP_START = 2 /* flipflop */
-};
+#define RUBYVM_CFUNC_FRAME_P(cfp) \
+  (VM_FRAME_TYPE(cfp) == VM_FRAME_MAGIC_CFUNC)
 
 /* inline cache */
 typedef struct iseq_inline_cache_entry *IC;
-typedef struct rb_call_info *CALL_INFO;
-typedef struct rb_call_cache *CALL_CACHE;
+typedef rb_call_info_t *CALL_INFO;
 
 void rb_vm_change_state(void);
 
@@ -942,231 +880,31 @@ typedef VALUE CDHASH;
 typedef rb_control_frame_t *
   (FUNC_FASTCALL(*rb_insn_func_t))(rb_thread_t *, rb_control_frame_t *);
 
-#define VM_TAGGED_PTR_SET(p, tag)  ((VALUE)(p) | (tag))
-#define VM_TAGGED_PTR_REF(v, mask) ((void *)((v) & ~mask))
-
-#define GC_GUARDED_PTR(p)     VM_TAGGED_PTR_SET((p), 0x01)
-#define GC_GUARDED_PTR_REF(p) VM_TAGGED_PTR_REF((p), 0x03)
+#define GC_GUARDED_PTR(p)     ((VALUE)((VALUE)(p) | 0x01))
+#define GC_GUARDED_PTR_REF(p) ((void *)(((VALUE)(p)) & ~0x03))
 #define GC_GUARDED_PTR_P(p)   (((VALUE)(p)) & 0x01)
 
-enum {
-    /* Frame/Environment flag bits:
-     *   MMMM MMMM MMMM MMMM ____ ____ FFFF EEEX (LSB)
-     *
-     * X   : tag for GC marking (It seems as Fixnum)
-     * EEE : 3 bits Env flags
-     * FFFF: 4 bits Frame flags
-     * MMMM: 16 bits frame magic (to check frame corruption)
-     */
-
-    /* frame types */
-    VM_FRAME_MAGIC_METHOD = 0x11110001,
-    VM_FRAME_MAGIC_BLOCK  = 0x22220001,
-    VM_FRAME_MAGIC_CLASS  = 0x33330001,
-    VM_FRAME_MAGIC_TOP    = 0x44440001,
-    VM_FRAME_MAGIC_CFUNC  = 0x55550001,
-    VM_FRAME_MAGIC_PROC   = 0x66660001,
-    VM_FRAME_MAGIC_IFUNC  = 0x77770001,
-    VM_FRAME_MAGIC_EVAL   = 0x88880001,
-    VM_FRAME_MAGIC_LAMBDA = 0x99990001,
-    VM_FRAME_MAGIC_RESCUE = 0xaaaa0001,
-    VM_FRAME_MAGIC_DUMMY  = 0xbbbb0001,
-
-    VM_FRAME_MAGIC_MASK   = 0xffff0001,
-
-    /* frame flag */
-    VM_FRAME_FLAG_PASSED    = 0x0010,
-    VM_FRAME_FLAG_FINISH    = 0x0020,
-    VM_FRAME_FLAG_BMETHOD   = 0x0040,
-    VM_FRAME_FLAG_CFRAME    = 0x0080,
-
-    /* env flag */
-    VM_ENV_FLAG_LOCAL       = 0x0002,
-    VM_ENV_FLAG_ESCAPED     = 0x0004,
-    VM_ENV_FLAG_WB_REQUIRED = 0x0008
-};
-
-#define VM_ENV_DATA_SIZE             ( 3)
-
-#define VM_ENV_DATA_INDEX_ME_CREF    (-2) /* ep[-2] */
-#define VM_ENV_DATA_INDEX_SPECVAL    (-1) /* ep[-1] */
-#define VM_ENV_DATA_INDEX_FLAGS      ( 0) /* ep[ 0] */
-#define VM_ENV_DATA_INDEX_ENV        ( 1) /* ep[ 1] */
-#define VM_ENV_DATA_INDEX_ENV_PROC   ( 2) /* ep[ 2] */
-
-#define VM_ENV_INDEX_LAST_LVAR              (-VM_ENV_DATA_SIZE)
-
-static inline void VM_FORCE_WRITE_SPECIAL_CONST(const VALUE *ptr, VALUE special_const_value);
-
-static inline void
-VM_ENV_FLAGS_SET(const VALUE *ep, VALUE flag)
-{
-    VALUE flags = ep[VM_ENV_DATA_INDEX_FLAGS];
-    VM_ASSERT(FIXNUM_P(flags));
-    VM_FORCE_WRITE_SPECIAL_CONST(&ep[VM_ENV_DATA_INDEX_FLAGS], flags | flag);
-}
-
-static inline void
-VM_ENV_FLAGS_UNSET(const VALUE *ep, VALUE flag)
-{
-    VALUE flags = ep[VM_ENV_DATA_INDEX_FLAGS];
-    VM_ASSERT(FIXNUM_P(flags));
-    VM_FORCE_WRITE_SPECIAL_CONST(&ep[VM_ENV_DATA_INDEX_FLAGS], flags & ~flag);
-}
-
-static inline unsigned long
-VM_ENV_FLAGS(const VALUE *ep, long flag)
-{
-    VALUE flags = ep[VM_ENV_DATA_INDEX_FLAGS];
-    VM_ASSERT(FIXNUM_P(flags));
-    return flags & flag;
-}
-
-static inline unsigned long
-VM_FRAME_TYPE(const rb_control_frame_t *cfp)
-{
-    return VM_ENV_FLAGS(cfp->ep, VM_FRAME_MAGIC_MASK);
-}
-
-static inline int
-VM_FRAME_FINISHED_P(const rb_control_frame_t *cfp)
-{
-    return VM_ENV_FLAGS(cfp->ep, VM_FRAME_FLAG_FINISH ) != 0;
-}
-
-static inline int
-VM_FRAME_BMETHOD_P(const rb_control_frame_t *cfp)
-{
-    return VM_ENV_FLAGS(cfp->ep, VM_FRAME_FLAG_BMETHOD) != 0;
-}
-
-static inline int
-rb_obj_is_iseq(VALUE iseq)
-{
-    return RB_TYPE_P(iseq, T_IMEMO) && imemo_type(iseq) == imemo_iseq;
-}
-
-#if VM_CHECK_MODE > 0
-#define RUBY_VM_NORMAL_ISEQ_P(iseq)  rb_obj_is_iseq((VALUE)iseq)
-#endif
-
-static inline int
-VM_FRAME_CFRAME_P(const rb_control_frame_t *cfp)
-{
-    int cframe_p = VM_ENV_FLAGS(cfp->ep, VM_FRAME_FLAG_CFRAME) != 0;
-    VM_ASSERT(RUBY_VM_NORMAL_ISEQ_P(cfp->iseq) != cframe_p);
-    return cframe_p;
-}
-
-static inline int
-VM_FRAME_RUBYFRAME_P(const rb_control_frame_t *cfp)
-{
-    return !VM_FRAME_CFRAME_P(cfp);
-}
-
-#define RUBYVM_CFUNC_FRAME_P(cfp) \
-  (VM_FRAME_TYPE(cfp) == VM_FRAME_MAGIC_CFUNC)
-
-#define VM_GUARDED_PREV_EP(ep)         GC_GUARDED_PTR(ep)
-#define VM_BLOCK_HANDLER_NONE 0
-
-static inline int
-VM_ENV_LOCAL_P(const VALUE *ep)
-{
-    return VM_ENV_FLAGS(ep, VM_ENV_FLAG_LOCAL) ? 1 : 0;
-}
-
-static inline const VALUE *
-VM_ENV_PREV_EP(const VALUE *ep)
-{
-    VM_ASSERT(VM_ENV_LOCAL_P(ep) == 0);
-    return GC_GUARDED_PTR_REF(ep[VM_ENV_DATA_INDEX_SPECVAL]);
-}
-
-static inline VALUE
-VM_ENV_BLOCK_HANDLER(const VALUE *ep)
-{
-    VM_ASSERT(VM_ENV_LOCAL_P(ep));
-    return ep[VM_ENV_DATA_INDEX_SPECVAL];
-}
-
-#if VM_CHECK_MODE > 0
-int rb_vm_ep_in_heap_p(const VALUE *ep);
-#endif
-
-static inline int
-VM_ENV_ESCAPED_P(const VALUE *ep)
-{
-    VM_ASSERT(rb_vm_ep_in_heap_p(ep) == !!VM_ENV_FLAGS(ep, VM_ENV_FLAG_ESCAPED));
-    return VM_ENV_FLAGS(ep, VM_ENV_FLAG_ESCAPED) ? 1 : 0;
-}
-
-#if VM_CHECK_MODE > 0
-static inline int
-vm_assert_env(VALUE obj)
-{
-    VM_ASSERT(RB_TYPE_P(obj, T_IMEMO));
-    VM_ASSERT(imemo_type(obj) == imemo_env);
-    return 1;
-}
-#endif
-
-static inline VALUE
-VM_ENV_ENVVAL(const VALUE *ep)
-{
-    VALUE envval = ep[VM_ENV_DATA_INDEX_ENV];
-    VM_ASSERT(VM_ENV_ESCAPED_P(ep));
-    VM_ASSERT(vm_assert_env(envval));
-    return envval;
-}
-
-static inline const rb_env_t *
-VM_ENV_ENVVAL_PTR(const VALUE *ep)
-{
-    return (const rb_env_t *)VM_ENV_ENVVAL(ep);
-}
-
-static inline VALUE
-VM_ENV_PROCVAL(const VALUE *ep)
-{
-    VM_ASSERT(VM_ENV_ESCAPED_P(ep));
-    VM_ASSERT(VM_ENV_LOCAL_P(ep));
-    VM_ASSERT(VM_ENV_BLOCK_HANDLER(ep) != VM_BLOCK_HANDLER_NONE);
-
-    return ep[VM_ENV_DATA_INDEX_ENV_PROC];
-}
-
-static inline const rb_env_t *
-vm_env_new(VALUE *env_ep, VALUE *env_body, unsigned int env_size, const rb_iseq_t *iseq)
-{
-    rb_env_t *env = (rb_env_t *)rb_imemo_new(imemo_env, (VALUE)env_ep, (VALUE)env_body, 0, (VALUE)iseq);
-    env->env_size = env_size;
-    env_ep[VM_ENV_DATA_INDEX_ENV] = (VALUE)env;
-    return env;
-}
-
-static inline void
-VM_FORCE_WRITE(const VALUE *ptr, VALUE v)
-{
-    *((VALUE *)ptr) = v;
-}
+/*
+ * block frame:
+ *  ep[ 0]: prev frame
+ *  ep[-1]: CREF (for *_eval)
+ *
+ * method frame:
+ *  ep[ 0]: block pointer (ptr | VM_ENVVAL_BLOCK_PTR_FLAG)
+ */
 
-static inline void
-VM_FORCE_WRITE_SPECIAL_CONST(const VALUE *ptr, VALUE special_const_value)
-{
-    VM_ASSERT(RB_SPECIAL_CONST_P(special_const_value));
-    VM_FORCE_WRITE(ptr, special_const_value);
-}
+#define VM_ENVVAL_BLOCK_PTR_FLAG 0x02
+#define VM_ENVVAL_BLOCK_PTR(v)     (GC_GUARDED_PTR(v) | VM_ENVVAL_BLOCK_PTR_FLAG)
+#define VM_ENVVAL_BLOCK_PTR_P(v)   ((v) & VM_ENVVAL_BLOCK_PTR_FLAG)
+#define VM_ENVVAL_PREV_EP_PTR(v)   ((VALUE)GC_GUARDED_PTR(v))
+#define VM_ENVVAL_PREV_EP_PTR_P(v) (!(VM_ENVVAL_BLOCK_PTR_P(v)))
 
-static inline void
-VM_STACK_ENV_WRITE(const VALUE *ep, int index, VALUE v)
-{
-    VM_ASSERT(VM_ENV_FLAGS(ep, VM_ENV_FLAG_WB_REQUIRED) == 0);
-    VM_FORCE_WRITE(&ep[index], v);
-}
+#define VM_EP_PREV_EP(ep)   ((VALUE *)GC_GUARDED_PTR_REF((ep)[0]))
+#define VM_EP_BLOCK_PTR(ep) ((rb_block_t *)GC_GUARDED_PTR_REF((ep)[0]))
+#define VM_EP_LEP_P(ep)     VM_ENVVAL_BLOCK_PTR_P((ep)[0])
 
-const VALUE *rb_vm_ep_local_ep(const VALUE *ep);
-VALUE rb_vm_frame_block_handler(const rb_control_frame_t *cfp);
+VALUE *rb_vm_ep_local_ep(VALUE *ep);
+rb_block_t *rb_vm_control_frame_block_ptr(rb_control_frame_t *cfp);
 
 #define RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp) ((cfp)+1)
 #define RUBY_VM_NEXT_CONTROL_FRAME(cfp) ((cfp)-1)
@@ -1177,232 +915,18 @@ VALUE rb_vm_frame_block_handler(const rb_control_frame_t *cfp);
 #define RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(th, cfp) \
   (!RUBY_VM_VALID_CONTROL_FRAME_P((cfp), RUBY_VM_END_CONTROL_FRAME(th)))
 
-static inline int
-VM_BH_ISEQ_BLOCK_P(VALUE block_handler)
-{
-    if ((block_handler & 0x03) == 0x01) {
-#if VM_CHECK_MODE > 0
-	struct rb_captured_block *captured = VM_TAGGED_PTR_REF(block_handler, 0x03);
-	VM_ASSERT(RB_TYPE_P(captured->code.val, T_IMEMO));
-	VM_ASSERT(imemo_type(captured->code.val) == imemo_iseq);
-#endif
-	return 1;
-    }
-    else {
-	return 0;
-    }
-}
-
-static inline VALUE
-VM_BH_FROM_ISEQ_BLOCK(const struct rb_captured_block *captured)
-{
-    VALUE block_handler = VM_TAGGED_PTR_SET(captured, 0x01);
-    VM_ASSERT(VM_BH_ISEQ_BLOCK_P(block_handler));
-    return block_handler;
-}
-
-static inline const struct rb_captured_block *
-VM_BH_TO_ISEQ_BLOCK(VALUE block_handler)
-{
-    struct rb_captured_block *captured = VM_TAGGED_PTR_REF(block_handler, 0x03);
-    VM_ASSERT(VM_BH_ISEQ_BLOCK_P(block_handler));
-    return captured;
-}
-
-static inline int
-VM_BH_IFUNC_P(VALUE block_handler)
-{
-    if ((block_handler & 0x03) == 0x03) {
-#if VM_CHECK_MODE > 0
-	struct rb_captured_block *captured = (void *)(block_handler & ~0x03);
-	VM_ASSERT(RB_TYPE_P(captured->code.val, T_IMEMO));
-	VM_ASSERT(imemo_type(captured->code.val) == imemo_ifunc);
-#endif
-	return 1;
-    }
-    else {
-	return 0;
-    }
-}
-
-static inline VALUE
-VM_BH_FROM_IFUNC_BLOCK(const struct rb_captured_block *captured)
-{
-    VALUE block_handler = VM_TAGGED_PTR_SET(captured, 0x03);
-    VM_ASSERT(VM_BH_IFUNC_P(block_handler));
-    return block_handler;
-}
-
-static inline const struct rb_captured_block *
-VM_BH_TO_IFUNC_BLOCK(VALUE block_handler)
-{
-    struct rb_captured_block *captured = VM_TAGGED_PTR_REF(block_handler, 0x03);
-    VM_ASSERT(VM_BH_IFUNC_P(block_handler));
-    return captured;
-}
-
-static inline const struct rb_captured_block *
-VM_BH_TO_CAPT_BLOCK(VALUE block_handler)
-{
-    struct rb_captured_block *captured = VM_TAGGED_PTR_REF(block_handler, 0x03);
-    VM_ASSERT(VM_BH_IFUNC_P(block_handler) || VM_BH_ISEQ_BLOCK_P(block_handler));
-    return captured;
-}
-
-static inline enum rb_block_handler_type
-vm_block_handler_type(VALUE block_handler)
-{
-    if (VM_BH_ISEQ_BLOCK_P(block_handler)) {
-	return block_handler_type_iseq;
-    }
-    else if (VM_BH_IFUNC_P(block_handler)) {
-	return block_handler_type_ifunc;
-    }
-    else if (SYMBOL_P(block_handler)) {
-	return block_handler_type_symbol;
-    }
-    else {
-	VM_ASSERT(rb_obj_is_proc(block_handler));
-	return block_handler_type_proc;
-    }
-}
-
-static inline int
-vm_block_handler_verify(VALUE block_handler)
-{
-    VM_ASSERT(block_handler == VM_BLOCK_HANDLER_NONE ||
-	      vm_block_handler_type(block_handler) >= 0);
-    return 1;
-}
-
-static inline enum rb_block_type
-vm_block_type(const struct rb_block *block)
-{
-#if VM_CHECK_MODE > 0
-    switch (block->type) {
-      case block_type_iseq:
-	VM_ASSERT(RB_TYPE_P(block->as.captured.code.val, T_IMEMO));
-	VM_ASSERT(imemo_type(block->as.captured.code.val) == imemo_iseq);
-	break;
-      case block_type_ifunc:
-	VM_ASSERT(RB_TYPE_P(block->as.captured.code.val, T_IMEMO));
-	VM_ASSERT(imemo_type(block->as.captured.code.val) == imemo_ifunc);
-	break;
-      case block_type_symbol:
-	VM_ASSERT(SYMBOL_P(block->as.symbol));
-	break;
-      case block_type_proc:
-	VM_ASSERT(rb_obj_is_proc(block->as.proc));
-	break;
-    }
-#endif
-    return block->type;
-}
-
-static inline void
-vm_block_type_set(const struct rb_block *block, enum rb_block_type type)
-{
-    struct rb_block *mb = (struct rb_block *)block;
-    mb->type = type;
-}
-
-static inline const struct rb_block *
-vm_proc_block(VALUE procval)
-{
-    rb_proc_t *proc = RTYPEDDATA_DATA(procval);
-    VM_ASSERT(rb_obj_is_proc(procval));
-    return &proc->block;
-}
-
-static inline const rb_iseq_t *vm_block_iseq(const struct rb_block *block);
-static inline const VALUE *vm_block_ep(const struct rb_block *block);
-
-static inline const rb_iseq_t *
-vm_proc_iseq(VALUE procval)
-{
-    VM_ASSERT(rb_obj_is_proc(procval));
-    return vm_block_iseq(vm_proc_block(procval));
-}
-
-static inline const VALUE *
-vm_proc_ep(VALUE procval)
-{
-    return vm_block_ep(vm_proc_block(procval));
-}
-
-static inline const rb_iseq_t *
-vm_block_iseq(const struct rb_block *block)
-{
-    switch (vm_block_type(block)) {
-      case block_type_iseq: return block->as.captured.code.iseq;
-      case block_type_proc: return vm_proc_iseq(block->as.proc);
-      case block_type_ifunc:
-      case block_type_symbol: return NULL;
-    }
-    VM_UNREACHABLE(vm_block_iseq);
-    return NULL;
-}
-
-static inline const VALUE *
-vm_block_ep(const struct rb_block *block)
-{
-    switch (vm_block_type(block)) {
-      case block_type_iseq:
-      case block_type_ifunc:  return block->as.captured.ep;
-      case block_type_proc:   return vm_proc_ep(block->as.proc);
-      case block_type_symbol: return NULL;
-    }
-    VM_UNREACHABLE(vm_block_ep);
-    return NULL;
-}
-
-static inline VALUE
-vm_block_self(const struct rb_block *block)
-{
-    switch (vm_block_type(block)) {
-      case block_type_iseq:
-      case block_type_ifunc:
-	return block->as.captured.self;
-      case block_type_proc:
-	return vm_block_self(vm_proc_block(block->as.proc));
-      case block_type_symbol:
-	return Qundef;
-    }
-    VM_UNREACHABLE(vm_block_self);
-    return Qundef;
-}
-
-static inline VALUE
-VM_BH_TO_SYMBOL(VALUE block_handler)
-{
-    VM_ASSERT(SYMBOL_P(block_handler));
-    return block_handler;
-}
-
-static inline VALUE
-VM_BH_FROM_SYMBOL(VALUE symbol)
-{
-    VM_ASSERT(SYMBOL_P(symbol));
-    return symbol;
-}
-
-static inline VALUE
-VM_BH_TO_PROC(VALUE block_handler)
-{
-    VM_ASSERT(rb_obj_is_proc(block_handler));
-    return block_handler;
-}
+#define RUBY_VM_IFUNC_P(ptr)        RB_TYPE_P((VALUE)(ptr), T_NODE)
+#define RUBY_VM_NORMAL_ISEQ_P(ptr) \
+  ((ptr) && !RUBY_VM_IFUNC_P(ptr))
 
-static inline VALUE
-VM_BH_FROM_PROC(VALUE procval)
-{
-    VM_ASSERT(rb_obj_is_proc(procval));
-    return procval;
-}
+#define RUBY_VM_GET_BLOCK_PTR_IN_CFP(cfp) ((rb_block_t *)(&(cfp)->self))
+#define RUBY_VM_GET_CFP_FROM_BLOCK_PTR(b) \
+  ((rb_control_frame_t *)((VALUE *)(b) - 4))
+/* magic number `4' is depend on rb_control_frame_t layout. */
 
 /* VM related object allocate functions */
 VALUE rb_thread_alloc(VALUE klass);
-VALUE rb_proc_alloc(VALUE klass);
+VALUE rb_proc_wrap(VALUE klass, rb_proc_t *); /* may use with rb_proc_alloc */
 VALUE rb_binding_alloc(VALUE klass);
 
 /* for debug */
@@ -1417,26 +941,29 @@ NORETURN(void rb_bug_context(const void *, const char *fmt, ...));
 
 /* functions about thread/vm execution */
 RUBY_SYMBOL_EXPORT_BEGIN
-VALUE rb_iseq_eval(const rb_iseq_t *iseq);
-VALUE rb_iseq_eval_main(const rb_iseq_t *iseq);
+VALUE rb_iseq_eval(VALUE iseqval);
+VALUE rb_iseq_eval_main(VALUE iseqval);
 RUBY_SYMBOL_EXPORT_END
 int rb_thread_method_id_and_class(rb_thread_t *th, ID *idp, VALUE *klassp);
 
-VALUE rb_vm_invoke_proc(rb_thread_t *th, rb_proc_t *proc, int argc, const VALUE *argv, VALUE block_handler);
-VALUE rb_vm_make_proc_lambda(rb_thread_t *th, const struct rb_captured_block *captured, VALUE klass, int8_t is_lambda);
-VALUE rb_vm_make_proc(rb_thread_t *th, const struct rb_captured_block *captured, VALUE klass);
+VALUE rb_vm_invoke_proc(rb_thread_t *th, rb_proc_t *proc,
+			int argc, const VALUE *argv, const rb_block_t *blockptr);
+VALUE rb_vm_make_proc_lambda(rb_thread_t *th, const rb_block_t *block, VALUE klass, int8_t is_lambda);
+VALUE rb_vm_make_proc(rb_thread_t *th, const rb_block_t *block, VALUE klass);
 VALUE rb_vm_make_binding(rb_thread_t *th, const rb_control_frame_t *src_cfp);
-VALUE rb_vm_env_local_variables(const rb_env_t *env);
-const rb_env_t *rb_vm_env_prev_env(const rb_env_t *env);
-const VALUE *rb_binding_add_dynavars(rb_binding_t *bind, int dyncount, const ID *dynvars);
+VALUE rb_vm_make_env_object(rb_thread_t *th, rb_control_frame_t *cfp);
+VALUE rb_vm_env_local_variables(VALUE envval);
+VALUE *rb_binding_add_dynavars(rb_binding_t *bind, int dyncount, const ID *dynvars);
 void rb_vm_inc_const_missing_count(void);
 void rb_vm_gvl_destroy(rb_vm_t *vm);
 VALUE rb_vm_call(rb_thread_t *th, VALUE recv, VALUE id, int argc,
-		 const VALUE *argv, const rb_callable_method_entry_t *me);
-void rb_vm_pop_frame(rb_thread_t *th);
+		 const VALUE *argv, const rb_method_entry_t *me,
+		 VALUE defined_class);
+void rb_unlink_method_entry(rb_method_entry_t *me);
+void rb_gc_mark_unlinked_live_method_entries(void *pvm);
 
 void rb_thread_start_timer_thread(void);
-void rb_thread_stop_timer_thread(void);
+void rb_thread_stop_timer_thread(int);
 void rb_thread_reset_timer_thread(void);
 void rb_thread_wakeup_timer_thread(void);
 
@@ -1461,11 +988,12 @@ rb_vm_living_threads_remove(rb_vm_t *vm, rb_thread_t *th)
     vm->living_thread_num--;
 }
 
+int ruby_thread_has_gvl_p(void);
 typedef int rb_backtrace_iter_func(void *, VALUE, int, VALUE);
 rb_control_frame_t *rb_vm_get_ruby_level_next_cfp(const rb_thread_t *th, const rb_control_frame_t *cfp);
 rb_control_frame_t *rb_vm_get_binding_creatable_next_cfp(const rb_thread_t *th, const rb_control_frame_t *cfp);
 int rb_vm_get_sourceline(const rb_control_frame_t *);
-VALUE rb_name_err_mesg_new(VALUE mesg, VALUE recv, VALUE method);
+VALUE rb_name_err_mesg_new(VALUE obj, VALUE mesg, VALUE recv, VALUE method);
 void rb_vm_stack_to_heap(rb_thread_t *th);
 void ruby_thread_init_stack(rb_thread_t *th);
 int rb_vm_control_frame_id_and_class(const rb_control_frame_t *cfp, ID *idp, VALUE *klassp);
@@ -1477,9 +1005,7 @@ void rb_gc_mark_machine_stack(rb_thread_t *th);
 
 int rb_autoloading_value(VALUE mod, ID id, VALUE* value);
 
-void rb_vm_rewrite_cref(rb_cref_t *node, VALUE old_klass, VALUE new_klass, rb_cref_t **new_cref_ptr);
-
-const rb_callable_method_entry_t *rb_vm_frame_method_entry(const rb_control_frame_t *cfp);
+void rb_vm_rewrite_cref_stack(NODE *node, VALUE old_klass, VALUE new_klass, NODE **new_cref_ptr);
 
 #define sysstack_error GET_VM()->special_exceptions[ruby_error_sysstack]
 
@@ -1508,20 +1034,18 @@ extern rb_event_flag_t ruby_vm_event_flags;
 #define OPT_CALL_CFUNC_WITHOUT_FRAME 0
 #endif
 
-#define GET_THREAD() vm_thread_with_frame(ruby_current_thread)
-#if OPT_CALL_CFUNC_WITHOUT_FRAME
 static inline rb_thread_t *
-vm_thread_with_frame(rb_thread_t *th)
+GET_THREAD(void)
 {
+    rb_thread_t *th = ruby_current_thread;
+#if OPT_CALL_CFUNC_WITHOUT_FRAME
     if (UNLIKELY(th->passed_ci != 0)) {
-	void rb_vm_call_cfunc_push_frame(rb_thread_t *th);
-	rb_vm_call_cfunc_push_frame(th);
+	void vm_call_cfunc_push_frame(rb_thread_t *th);
+	vm_call_cfunc_push_frame(th);
     }
+#endif
     return th;
 }
-#else
-#define vm_thread_with_frame(th) (th)
-#endif
 
 #define rb_thread_set_current_raw(th) (void)(ruby_current_thread = (th))
 #define rb_thread_set_current(th) do { \
@@ -1550,7 +1074,6 @@ enum {
 #define RUBY_VM_INTERRUPTED(th) ((th)->interrupt_flag & ~(th)->interrupt_mask & (PENDING_INTERRUPT_MASK|TRAP_INTERRUPT_MASK))
 #define RUBY_VM_INTERRUPTED_ANY(th) ((th)->interrupt_flag & ~(th)->interrupt_mask)
 
-VALUE rb_exc_set_backtrace(VALUE exc, VALUE bt);
 int rb_signal_buff_size(void);
 void rb_signal_exec(rb_thread_t *th, int sig);
 void rb_threadptr_check_signal(rb_thread_t *mth);
@@ -1562,16 +1085,23 @@ void rb_threadptr_unlock_all_locking_mutexes(rb_thread_t *th);
 void rb_threadptr_pending_interrupt_clear(rb_thread_t *th);
 void rb_threadptr_pending_interrupt_enque(rb_thread_t *th, VALUE v);
 int rb_threadptr_pending_interrupt_active_p(rb_thread_t *th);
-void rb_threadptr_error_print(rb_thread_t *th, VALUE errinfo);
 
-#define RUBY_VM_CHECK_INTS(th) ruby_vm_check_ints(th)
-static inline void
-ruby_vm_check_ints(rb_thread_t *th)
-{
-    if (UNLIKELY(RUBY_VM_INTERRUPTED_ANY(th))) {
-	rb_threadptr_execute_interrupts(th, 0);
-    }
-}
+#define RUBY_VM_CHECK_INTS_BLOCKING(th) do {				\
+	if (UNLIKELY(!rb_threadptr_pending_interrupt_empty_p(th))) {	\
+	    th->pending_interrupt_queue_checked = 0;			\
+	    RUBY_VM_SET_INTERRUPT(th);					\
+	    rb_threadptr_execute_interrupts(th, 1);			\
+	}								\
+	else if (UNLIKELY(RUBY_VM_INTERRUPTED_ANY(th))) {		\
+	    rb_threadptr_execute_interrupts(th, 1);			\
+	}								\
+    } while (0)
+
+#define RUBY_VM_CHECK_INTS(th) do { \
+    if (UNLIKELY(RUBY_VM_INTERRUPTED_ANY(th))) {	\
+	rb_threadptr_execute_interrupts(th, 0); \
+    } \
+} while (0)
 
 /* tracer */
 struct rb_trace_arg_struct {
@@ -1594,33 +1124,24 @@ void rb_threadptr_exec_event_hooks(struct rb_trace_arg_struct *trace_arg);
 void rb_threadptr_exec_event_hooks_and_pop_frame(struct rb_trace_arg_struct *trace_arg);
 
 #define EXEC_EVENT_HOOK_ORIG(th_, flag_, self_, id_, klass_, data_, pop_p_) do { \
-    const rb_event_flag_t flag_arg_ = (flag_); \
-    if (UNLIKELY(ruby_vm_event_flags & (flag_arg_))) { \
-	/* defer evaluating the other arguments */ \
-	ruby_exec_event_hook_orig(th_, flag_arg_, self_, id_, klass_, data_, pop_p_); \
+    if (UNLIKELY(ruby_vm_event_flags & (flag_))) { \
+	if (((th)->event_hooks.events | (th)->vm->event_hooks.events) & (flag_)) { \
+	    struct rb_trace_arg_struct trace_arg; \
+	    trace_arg.event = (flag_); \
+	    trace_arg.th = (th_); \
+	    trace_arg.cfp = (trace_arg.th)->cfp; \
+	    trace_arg.self = (self_); \
+	    trace_arg.id = (id_); \
+	    trace_arg.klass = (klass_); \
+	    trace_arg.data = (data_); \
+	    trace_arg.path = Qundef; \
+	    trace_arg.klass_solved = 0; \
+	    if (pop_p_) rb_threadptr_exec_event_hooks_and_pop_frame(&trace_arg); \
+	    else rb_threadptr_exec_event_hooks(&trace_arg); \
+	} \
     } \
 } while (0)
 
-static inline void
-ruby_exec_event_hook_orig(rb_thread_t *const th, const rb_event_flag_t flag,
-			  VALUE self, ID id, VALUE klass, VALUE data, int pop_p)
-{
-    if ((th->event_hooks.events | th->vm->event_hooks.events) & flag) {
-	struct rb_trace_arg_struct trace_arg;
-	trace_arg.event = flag;
-	trace_arg.th = th;
-	trace_arg.cfp = th->cfp;
-	trace_arg.self = self;
-	trace_arg.id = id;
-	trace_arg.klass = klass;
-	trace_arg.data = data;
-	trace_arg.path = Qundef;
-	trace_arg.klass_solved = 0;
-	if (pop_p) rb_threadptr_exec_event_hooks_and_pop_frame(&trace_arg);
-	else rb_threadptr_exec_event_hooks(&trace_arg);
-    }
-}
-
 #define EXEC_EVENT_HOOK(th_, flag_, self_, id_, klass_, data_) \
   EXEC_EVENT_HOOK_ORIG(th_, flag_, self_, id_, klass_, data_, 0)