Expand tabs [ci skip]

[Misc #18891]

1 files changed, 567 insertions, 567 deletions

diff --git a/vm.c b/vm.c
index 4538c8b607..0004a2676d 100644
--- a/vm.c
+++ b/vm.c
@@ -70,7 +70,7 @@ static inline const VALUE *
 VM_EP_LEP(const VALUE *ep)
 {
     while (!VM_ENV_LOCAL_P(ep)) {
-	ep = VM_ENV_PREV_EP(ep);
+        ep = VM_ENV_PREV_EP(ep);
     }
     return ep;
 }
@@ -79,19 +79,19 @@ static inline const rb_control_frame_t *
 rb_vm_search_cf_from_ep(const rb_execution_context_t *ec, const rb_control_frame_t *cfp, const VALUE * const ep)
 {
     if (!ep) {
-	return NULL;
+        return NULL;
     }
     else {
-	const rb_control_frame_t * const eocfp = RUBY_VM_END_CONTROL_FRAME(ec); /* end of control frame pointer */
+        const rb_control_frame_t * const eocfp = RUBY_VM_END_CONTROL_FRAME(ec); /* end of control frame pointer */
 
-	while (cfp < eocfp) {
-	    if (cfp->ep == ep) {
-		return cfp;
-	    }
-	    cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
-	}
+        while (cfp < eocfp) {
+            if (cfp->ep == ep) {
+                return cfp;
+            }
+            cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
+        }
 
-	return NULL;
+        return NULL;
     }
 }
 
@@ -143,10 +143,10 @@ VM_CFP_IN_HEAP_P(const rb_execution_context_t *ec, const rb_control_frame_t *cfp
     VM_ASSERT(start != NULL);
 
     if (start <= (VALUE *)cfp && (VALUE *)cfp < end) {
-	return FALSE;
+        return FALSE;
     }
     else {
-	return TRUE;
+        return TRUE;
     }
 }
 
@@ -158,10 +158,10 @@ VM_EP_IN_HEAP_P(const rb_execution_context_t *ec, const VALUE *ep)
     VM_ASSERT(start != NULL);
 
     if (start <= ep && ep < end) {
-	return FALSE;
+        return FALSE;
     }
     else {
-	return TRUE;
+        return TRUE;
     }
 }
 
@@ -169,19 +169,19 @@ static int
 vm_ep_in_heap_p_(const rb_execution_context_t *ec, const VALUE *ep)
 {
     if (VM_EP_IN_HEAP_P(ec, ep)) {
-	VALUE envval = ep[VM_ENV_DATA_INDEX_ENV]; /* VM_ENV_ENVVAL(ep); */
+        VALUE envval = ep[VM_ENV_DATA_INDEX_ENV]; /* VM_ENV_ENVVAL(ep); */
 
-	if (envval != Qundef) {
-	    const rb_env_t *env = (const rb_env_t *)envval;
+        if (envval != Qundef) {
+            const rb_env_t *env = (const rb_env_t *)envval;
 
-	    VM_ASSERT(vm_assert_env(envval));
-	    VM_ASSERT(VM_ENV_FLAGS(ep, VM_ENV_FLAG_ESCAPED));
-	    VM_ASSERT(env->ep == ep);
-	}
-	return TRUE;
+            VM_ASSERT(vm_assert_env(envval));
+            VM_ASSERT(VM_ENV_FLAGS(ep, VM_ENV_FLAG_ESCAPED));
+            VM_ASSERT(env->ep == ep);
+        }
+        return TRUE;
     }
     else {
-	return FALSE;
+        return FALSE;
     }
 }
 
@@ -235,8 +235,8 @@ vm_cref_new0(VALUE klass, rb_method_visibility_t visi, int module_func, rb_cref_
 
     /* scope */
     union {
-	rb_scope_visibility_t visi;
-	VALUE value;
+        rb_scope_visibility_t visi;
+        VALUE value;
     } scope_visi;
 
     scope_visi.visi.method_visi = visi;
@@ -244,12 +244,12 @@ vm_cref_new0(VALUE klass, rb_method_visibility_t visi, int module_func, rb_cref_
 
     /* refinements */
     if (prev_cref != NULL && prev_cref != (void *)1 /* TODO: why CREF_NEXT(cref) is 1? */) {
-	refinements = CREF_REFINEMENTS(prev_cref);
+        refinements = CREF_REFINEMENTS(prev_cref);
 
-	if (!NIL_P(refinements)) {
-	    omod_shared = TRUE;
-	    CREF_OMOD_SHARED_SET(prev_cref);
-	}
+        if (!NIL_P(refinements)) {
+            omod_shared = TRUE;
+            CREF_OMOD_SHARED_SET(prev_cref);
+        }
     }
 
     VM_ASSERT(singleton || klass);
@@ -327,7 +327,7 @@ vm_cref_new_toplevel(rb_execution_context_t *ec)
     VALUE top_wrapper = rb_ec_thread_ptr(ec)->top_wrapper;
 
     if (top_wrapper) {
-	cref = vm_cref_new(top_wrapper, METHOD_VISI_PRIVATE, FALSE, cref, FALSE, FALSE);
+        cref = vm_cref_new(top_wrapper, METHOD_VISI_PRIVATE, FALSE, cref, FALSE, FALSE);
     }
 
     return cref;
@@ -345,8 +345,8 @@ vm_cref_dump(const char *mesg, const rb_cref_t *cref)
     ruby_debug_printf("vm_cref_dump: %s (%p)\n", mesg, (void *)cref);
 
     while (cref) {
-	ruby_debug_printf("= cref| klass: %s\n", RSTRING_PTR(rb_class_path(CREF_CLASS(cref))));
-	cref = CREF_NEXT(cref);
+        ruby_debug_printf("= cref| klass: %s\n", RSTRING_PTR(rb_class_path(CREF_CLASS(cref))));
+        cref = CREF_NEXT(cref);
     }
 }
 
@@ -467,36 +467,36 @@ rb_vm_inc_const_missing_count(void)
 
 MJIT_FUNC_EXPORTED int
 rb_dtrace_setup(rb_execution_context_t *ec, VALUE klass, ID id,
-		struct ruby_dtrace_method_hook_args *args)
+                struct ruby_dtrace_method_hook_args *args)
 {
     enum ruby_value_type type;
     if (!klass) {
-	if (!ec) ec = GET_EC();
-	if (!rb_ec_frame_method_id_and_class(ec, &id, 0, &klass) || !klass)
-	    return FALSE;
+        if (!ec) ec = GET_EC();
+        if (!rb_ec_frame_method_id_and_class(ec, &id, 0, &klass) || !klass)
+            return FALSE;
     }
     if (RB_TYPE_P(klass, T_ICLASS)) {
-	klass = RBASIC(klass)->klass;
+        klass = RBASIC(klass)->klass;
     }
     else if (FL_TEST(klass, FL_SINGLETON)) {
-	klass = rb_attr_get(klass, id__attached__);
-	if (NIL_P(klass)) return FALSE;
+        klass = rb_attr_get(klass, id__attached__);
+        if (NIL_P(klass)) return FALSE;
     }
     type = BUILTIN_TYPE(klass);
     if (type == T_CLASS || type == T_ICLASS || type == T_MODULE) {
-	VALUE name = rb_class_path(klass);
-	const char *classname, *filename;
-	const char *methodname = rb_id2name(id);
-	if (methodname && (filename = rb_source_location_cstr(&args->line_no)) != 0) {
-	    if (NIL_P(name) || !(classname = StringValuePtr(name)))
-		classname = "<unknown>";
-	    args->classname = classname;
-	    args->methodname = methodname;
-	    args->filename = filename;
-	    args->klass = klass;
-	    args->name = name;
-	    return TRUE;
-	}
+        VALUE name = rb_class_path(klass);
+        const char *classname, *filename;
+        const char *methodname = rb_id2name(id);
+        if (methodname && (filename = rb_source_location_cstr(&args->line_no)) != 0) {
+            if (NIL_P(name) || !(classname = StringValuePtr(name)))
+                classname = "<unknown>";
+            args->classname = classname;
+            args->methodname = methodname;
+            args->filename = filename;
+            args->klass = klass;
+            args->name = name;
+            return TRUE;
+        }
     }
     return FALSE;
 }
@@ -532,29 +532,29 @@ vm_stat(int argc, VALUE *argv, VALUE self)
 
     if (rb_check_arity(argc, 0, 1) == 1) {
         arg = argv[0];
-	if (SYMBOL_P(arg))
-	    key = arg;
-	else if (RB_TYPE_P(arg, T_HASH))
-	    hash = arg;
-	else
-	    rb_raise(rb_eTypeError, "non-hash or symbol given");
+        if (SYMBOL_P(arg))
+            key = arg;
+        else if (RB_TYPE_P(arg, T_HASH))
+            hash = arg;
+        else
+            rb_raise(rb_eTypeError, "non-hash or symbol given");
     }
     else {
-	hash = rb_hash_new();
+        hash = rb_hash_new();
     }
 
 #define S(s) sym_##s = ID2SYM(rb_intern_const(#s))
     S(constant_cache_invalidations);
     S(constant_cache_misses);
-	S(class_serial);
-	S(global_cvar_state);
+        S(class_serial);
+        S(global_cvar_state);
 #undef S
 
 #define SET(name, attr) \
     if (key == sym_##name) \
-	return SERIALT2NUM(attr); \
+        return SERIALT2NUM(attr); \
     else if (hash != Qnil) \
-	rb_hash_aset(hash, sym_##name, SERIALT2NUM(attr));
+        rb_hash_aset(hash, sym_##name, SERIALT2NUM(attr));
 
     SET(constant_cache_invalidations, ruby_vm_constant_cache_invalidations);
     SET(constant_cache_misses, ruby_vm_constant_cache_misses);
@@ -563,7 +563,7 @@ vm_stat(int argc, VALUE *argv, VALUE self)
 #undef SET
 
     if (!NIL_P(key)) { /* matched key should return above */
-	rb_raise(rb_eArgError, "unknown key: %"PRIsVALUE, rb_sym2str(key));
+        rb_raise(rb_eArgError, "unknown key: %"PRIsVALUE, rb_sym2str(key));
     }
 
     return hash;
@@ -575,13 +575,13 @@ static void
 vm_set_top_stack(rb_execution_context_t *ec, const rb_iseq_t *iseq)
 {
     if (ISEQ_BODY(iseq)->type != ISEQ_TYPE_TOP) {
-	rb_raise(rb_eTypeError, "Not a toplevel InstructionSequence");
+        rb_raise(rb_eTypeError, "Not a toplevel InstructionSequence");
     }
 
     /* for return */
     vm_push_frame(ec, iseq, VM_FRAME_MAGIC_TOP | VM_ENV_FLAG_LOCAL | VM_FRAME_FLAG_FINISH, rb_ec_thread_ptr(ec)->top_self,
-		  VM_BLOCK_HANDLER_NONE,
-		  (VALUE)vm_cref_new_toplevel(ec), /* cref or me */
+                  VM_BLOCK_HANDLER_NONE,
+                  (VALUE)vm_cref_new_toplevel(ec), /* cref or me */
                   ISEQ_BODY(iseq)->iseq_encoded, ec->cfp->sp,
                   ISEQ_BODY(iseq)->local_table_size, ISEQ_BODY(iseq)->stack_max);
 }
@@ -590,8 +590,8 @@ static void
 vm_set_eval_stack(rb_execution_context_t *ec, const rb_iseq_t *iseq, const rb_cref_t *cref, const struct rb_block *base_block)
 {
     vm_push_frame(ec, iseq, VM_FRAME_MAGIC_EVAL | VM_FRAME_FLAG_FINISH,
-		  vm_block_self(base_block), VM_GUARDED_PREV_EP(vm_block_ep(base_block)),
-		  (VALUE)cref, /* cref or me */
+                  vm_block_self(base_block), VM_GUARDED_PREV_EP(vm_block_ep(base_block)),
+                  (VALUE)cref, /* cref or me */
                   ISEQ_BODY(iseq)->iseq_encoded,
                   ec->cfp->sp, ISEQ_BODY(iseq)->local_table_size,
                   ISEQ_BODY(iseq)->stack_max);
@@ -610,7 +610,7 @@ vm_set_main_stack(rb_execution_context_t *ec, const rb_iseq_t *iseq)
 
     /* save binding */
     if (ISEQ_BODY(iseq)->local_table_size > 0) {
-	vm_bind_update_env(toplevel_binding, bind, vm_make_env_object(ec, ec->cfp));
+        vm_bind_update_env(toplevel_binding, bind, vm_make_env_object(ec, ec->cfp));
     }
 }
 
@@ -618,10 +618,10 @@ rb_control_frame_t *
 rb_vm_get_binding_creatable_next_cfp(const rb_execution_context_t *ec, const rb_control_frame_t *cfp)
 {
     while (!RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(ec, cfp)) {
-	if (cfp->iseq) {
-	    return (rb_control_frame_t *)cfp;
-	}
-	cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
+        if (cfp->iseq) {
+            return (rb_control_frame_t *)cfp;
+        }
+        cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
     }
     return 0;
 }
@@ -630,10 +630,10 @@ MJIT_FUNC_EXPORTED rb_control_frame_t *
 rb_vm_get_ruby_level_next_cfp(const rb_execution_context_t *ec, const rb_control_frame_t *cfp)
 {
     while (!RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(ec, cfp)) {
-	if (VM_FRAME_RUBYFRAME_P(cfp)) {
-	    return (rb_control_frame_t *)cfp;
-	}
-	cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
+        if (VM_FRAME_RUBYFRAME_P(cfp)) {
+            return (rb_control_frame_t *)cfp;
+        }
+        cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
     }
     return 0;
 }
@@ -644,20 +644,20 @@ static rb_control_frame_t *
 vm_get_ruby_level_caller_cfp(const rb_execution_context_t *ec, const rb_control_frame_t *cfp)
 {
     if (VM_FRAME_RUBYFRAME_P(cfp)) {
-	return (rb_control_frame_t *)cfp;
+        return (rb_control_frame_t *)cfp;
     }
 
     cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
 
     while (!RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(ec, cfp)) {
-	if (VM_FRAME_RUBYFRAME_P(cfp)) {
-	    return (rb_control_frame_t *)cfp;
-	}
+        if (VM_FRAME_RUBYFRAME_P(cfp)) {
+            return (rb_control_frame_t *)cfp;
+        }
 
-	if (VM_ENV_FLAGS(cfp->ep, VM_FRAME_FLAG_PASSED) == FALSE) {
-	    break;
-	}
-	cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
+        if (VM_ENV_FLAGS(cfp->ep, VM_FRAME_FLAG_PASSED) == FALSE) {
+            break;
+        }
+        cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
     }
     return 0;
 }
@@ -682,14 +682,14 @@ rb_vm_rewind_cfp(rb_execution_context_t *ec, rb_control_frame_t *cfp)
     /* check skipped frame */
     while (ec->cfp != cfp) {
 #if VMDEBUG
-	printf("skipped frame: %s\n", vm_frametype_name(ec->cfp));
+        printf("skipped frame: %s\n", vm_frametype_name(ec->cfp));
 #endif
-	if (VM_FRAME_TYPE(ec->cfp) != VM_FRAME_MAGIC_CFUNC) {
-	    rb_vm_pop_frame(ec);
-	}
-	else { /* unlikely path */
-	    rb_vm_pop_cfunc_frame();
-	}
+        if (VM_FRAME_TYPE(ec->cfp) != VM_FRAME_MAGIC_CFUNC) {
+            rb_vm_pop_frame(ec);
+        }
+        else { /* unlikely path */
+            rb_vm_pop_cfunc_frame();
+        }
     }
 }
 
@@ -711,11 +711,11 @@ ruby_vm_run_at_exit_hooks(rb_vm_t *vm)
     rb_at_exit_list *l = vm->at_exit;
 
     while (l) {
-	rb_at_exit_list* t = l->next;
-	rb_vm_at_exit_func *func = l->func;
-	ruby_xfree(l);
-	l = t;
-	(*func)(vm);
+        rb_at_exit_list* t = l->next;
+        rb_vm_at_exit_func *func = l->func;
+        ruby_xfree(l);
+        l = t;
+        (*func)(vm);
     }
 }
 
@@ -732,9 +732,9 @@ check_env(const rb_env_t *env)
     dp(env->ep[1]);
     ruby_debug_printf("ep:    %10p\n", (void *)env->ep);
     if (rb_vm_env_prev_env(env)) {
-	fputs(">>\n", stderr);
-	check_env_value(rb_vm_env_prev_env(env));
-	fputs("<<\n", stderr);
+        fputs(">>\n", stderr);
+        check_env_value(rb_vm_env_prev_env(env));
+        fputs("<<\n", stderr);
     }
     return 1;
 }
@@ -743,7 +743,7 @@ static VALUE
 check_env_value(const rb_env_t *env)
 {
     if (check_env(env)) {
-	return (VALUE)env;
+        return (VALUE)env;
     }
     rb_bug("invalid env");
     return Qnil;		/* unreachable */
@@ -775,11 +775,11 @@ vm_make_env_each(const rb_execution_context_t * const ec, rb_control_frame_t *co
     int local_size, env_size;
 
     if (VM_ENV_ESCAPED_P(ep)) {
-	return VM_ENV_ENVVAL(ep);
+        return VM_ENV_ENVVAL(ep);
     }
 
     if (!VM_ENV_LOCAL_P(ep)) {
-	const VALUE *prev_ep = VM_ENV_PREV_EP(ep);
+        const VALUE *prev_ep = VM_ENV_PREV_EP(ep);
         if (!VM_ENV_ESCAPED_P(prev_ep)) {
             rb_control_frame_t *prev_cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
 
@@ -793,16 +793,16 @@ vm_make_env_each(const rb_execution_context_t * const ec, rb_control_frame_t *co
         }
     }
     else {
-	VALUE block_handler = VM_ENV_BLOCK_HANDLER(ep);
+        VALUE block_handler = VM_ENV_BLOCK_HANDLER(ep);
 
-	if (block_handler != VM_BLOCK_HANDLER_NONE) {
+        if (block_handler != VM_BLOCK_HANDLER_NONE) {
             VALUE blockprocval = vm_block_handler_escape(ec, block_handler);
-	    VM_STACK_ENV_WRITE(ep, VM_ENV_DATA_INDEX_SPECVAL, blockprocval);
-	}
+            VM_STACK_ENV_WRITE(ep, VM_ENV_DATA_INDEX_SPECVAL, blockprocval);
+        }
     }
 
     if (!VM_FRAME_RUBYFRAME_P(cfp)) {
-	local_size = VM_ENV_DATA_SIZE;
+        local_size = VM_ENV_DATA_SIZE;
     }
     else {
         local_size = ISEQ_BODY(cfp->iseq)->local_table_size + VM_ENV_DATA_SIZE;
@@ -821,16 +821,16 @@ vm_make_env_each(const rb_execution_context_t * const ec, rb_control_frame_t *co
      */
 
     env_size = local_size +
-	       1 /* envval */;
+               1 /* envval */;
     env_body = ALLOC_N(VALUE, env_size);
     MEMCPY(env_body, ep - (local_size - 1 /* specval */), VALUE, local_size);
 
 #if 0
     for (i = 0; i < local_size; i++) {
-	if (VM_FRAME_RUBYFRAME_P(cfp)) {
-	    /* clear value stack for GC */
-	    ep[-local_size + i] = 0;
-	}
+        if (VM_FRAME_RUBYFRAME_P(cfp)) {
+            /* clear value stack for GC */
+            ep[-local_size + i] = 0;
+        }
     }
 #endif
 
@@ -851,7 +851,7 @@ vm_make_env_object(const rb_execution_context_t *ec, rb_control_frame_t *cfp)
     VALUE envval = vm_make_env_each(ec, cfp);
 
     if (PROCDEBUG) {
-	check_env_value((const rb_env_t *)envval);
+        check_env_value((const rb_env_t *)envval);
     }
 
     return envval;
@@ -862,8 +862,8 @@ rb_vm_stack_to_heap(rb_execution_context_t *ec)
 {
     rb_control_frame_t *cfp = ec->cfp;
     while ((cfp = rb_vm_get_binding_creatable_next_cfp(ec, cfp)) != 0) {
-	vm_make_env_object(ec, cfp);
-	cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
+        vm_make_env_object(ec, cfp);
+        cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
     }
 }
 
@@ -873,7 +873,7 @@ rb_vm_env_prev_env(const rb_env_t *env)
     const VALUE *ep = env->ep;
 
     if (VM_ENV_LOCAL_P(ep)) {
-	return NULL;
+        return NULL;
     }
     else {
         const VALUE *prev_ep = VM_ENV_PREV_EP(ep);
@@ -897,7 +897,7 @@ collect_local_variables_in_env(const rb_env_t *env, const struct local_var_list
 {
     do {
         if (VM_ENV_FLAGS(env->ep, VM_ENV_FLAG_ISOLATED)) break;
-	collect_local_variables_in_iseq(env->iseq, vars);
+        collect_local_variables_in_iseq(env->iseq, vars);
     } while ((env = rb_vm_env_prev_env(env)) != NULL);
 }
 
@@ -905,11 +905,11 @@ static int
 vm_collect_local_variables_in_heap(const VALUE *ep, const struct local_var_list *vars)
 {
     if (VM_ENV_ESCAPED_P(ep)) {
-	collect_local_variables_in_env(VM_ENV_ENVVAL_PTR(ep), vars);
-	return 1;
+        collect_local_variables_in_env(VM_ENV_ENVVAL_PTR(ep), vars);
+        return 1;
     }
     else {
-	return 0;
+        return 0;
     }
 }
 
@@ -937,9 +937,9 @@ rb_iseq_local_variables(const rb_iseq_t *iseq)
 
 static VALUE
 vm_proc_create_from_captured(VALUE klass,
-			     const struct rb_captured_block *captured,
-			     enum rb_block_type block_type,
-			     int8_t is_from_method, int8_t is_lambda)
+                             const struct rb_captured_block *captured,
+                             enum rb_block_type block_type,
+                             int8_t is_from_method, int8_t is_lambda)
 {
     VALUE procval = rb_proc_alloc(klass);
     rb_proc_t *proc = RTYPEDDATA_DATA(procval);
@@ -965,16 +965,16 @@ rb_vm_block_copy(VALUE obj, const struct rb_block *dst, const struct rb_block *s
     switch (vm_block_type(src)) {
       case block_type_iseq:
       case block_type_ifunc:
-	RB_OBJ_WRITE(obj, &dst->as.captured.self, src->as.captured.self);
-	RB_OBJ_WRITE(obj, &dst->as.captured.code.val, src->as.captured.code.val);
-	rb_vm_block_ep_update(obj, dst, src->as.captured.ep);
-	break;
+        RB_OBJ_WRITE(obj, &dst->as.captured.self, src->as.captured.self);
+        RB_OBJ_WRITE(obj, &dst->as.captured.code.val, src->as.captured.code.val);
+        rb_vm_block_ep_update(obj, dst, src->as.captured.ep);
+        break;
       case block_type_symbol:
-	RB_OBJ_WRITE(obj, &dst->as.symbol, src->as.symbol);
-	break;
+        RB_OBJ_WRITE(obj, &dst->as.symbol, src->as.symbol);
+        break;
       case block_type_proc:
-	RB_OBJ_WRITE(obj, &dst->as.proc, src->as.proc);
-	break;
+        RB_OBJ_WRITE(obj, &dst->as.proc, src->as.proc);
+        break;
     }
 }
 
@@ -1214,15 +1214,15 @@ rb_vm_make_proc_lambda(const rb_execution_context_t *ec, const struct rb_capture
     VALUE procval;
 
     if (!VM_ENV_ESCAPED_P(captured->ep)) {
-	rb_control_frame_t *cfp = VM_CAPTURED_BLOCK_TO_CFP(captured);
-	vm_make_env_object(ec, cfp);
+        rb_control_frame_t *cfp = VM_CAPTURED_BLOCK_TO_CFP(captured);
+        vm_make_env_object(ec, cfp);
     }
     VM_ASSERT(VM_EP_IN_HEAP_P(ec, captured->ep));
     VM_ASSERT(imemo_type_p(captured->code.val, imemo_iseq) ||
-	      imemo_type_p(captured->code.val, imemo_ifunc));
+              imemo_type_p(captured->code.val, imemo_ifunc));
 
     procval = vm_proc_create_from_captured(klass, captured,
-					   imemo_type(captured->code.val) == imemo_iseq ? block_type_iseq : block_type_ifunc, FALSE, is_lambda);
+                                           imemo_type(captured->code.val) == imemo_iseq ? block_type_iseq : block_type_ifunc, FALSE, is_lambda);
     return procval;
 }
 
@@ -1237,7 +1237,7 @@ rb_vm_make_binding(const rb_execution_context_t *ec, const rb_control_frame_t *s
     rb_binding_t *bind;
 
     if (cfp == 0 || ruby_level_cfp == 0) {
-	rb_raise(rb_eRuntimeError, "Can't create Binding Object on top of Fiber.");
+        rb_raise(rb_eRuntimeError, "Can't create Binding Object on top of Fiber.");
     }
     if (!VM_FRAME_RUBYFRAME_P(src_cfp) &&
         !VM_FRAME_RUBYFRAME_P(RUBY_VM_PREVIOUS_CONTROL_FRAME(src_cfp))) {
@@ -1288,8 +1288,8 @@ rb_binding_add_dynavars(VALUE bindval, rb_binding_t *bind, int dyncount, const I
         iseq = rb_iseq_new(&ast, ISEQ_BODY(base_iseq)->location.label, path, realpath, base_iseq, ISEQ_TYPE_EVAL);
     }
     else {
-	VALUE tempstr = rb_fstring_lit("<temp>");
-	iseq = rb_iseq_new_top(&ast, tempstr, tempstr, tempstr, NULL);
+        VALUE tempstr = rb_fstring_lit("<temp>");
+        iseq = rb_iseq_new_top(&ast, tempstr, tempstr, tempstr, NULL);
     }
     tmp_node.nd_tbl = 0; /* reset table */
     ALLOCV_END(idtmp);
@@ -1310,10 +1310,10 @@ invoke_block(rb_execution_context_t *ec, const rb_iseq_t *iseq, VALUE self, cons
     int arg_size = ISEQ_BODY(iseq)->param.size;
 
     vm_push_frame(ec, iseq, type | VM_FRAME_FLAG_FINISH, self,
-		  VM_GUARDED_PREV_EP(captured->ep),
-		  (VALUE)cref, /* cref or method */
+                  VM_GUARDED_PREV_EP(captured->ep),
+                  (VALUE)cref, /* cref or method */
                   ISEQ_BODY(iseq)->iseq_encoded + opt_pc,
-		  ec->cfp->sp + arg_size,
+                  ec->cfp->sp + arg_size,
                   ISEQ_BODY(iseq)->local_table_size - arg_size,
                   ISEQ_BODY(iseq)->stack_max);
     return vm_exec(ec, true);
@@ -1329,10 +1329,10 @@ invoke_bmethod(rb_execution_context_t *ec, const rb_iseq_t *iseq, VALUE self, co
     VM_ASSERT(me->def->type == VM_METHOD_TYPE_BMETHOD);
 
     vm_push_frame(ec, iseq, type | VM_FRAME_FLAG_BMETHOD, self,
-		  VM_GUARDED_PREV_EP(captured->ep),
-		  (VALUE)me,
+                  VM_GUARDED_PREV_EP(captured->ep),
+                  (VALUE)me,
                   ISEQ_BODY(iseq)->iseq_encoded + opt_pc,
-		  ec->cfp->sp + arg_size,
+                  ec->cfp->sp + arg_size,
                   ISEQ_BODY(iseq)->local_table_size - arg_size,
                   ISEQ_BODY(iseq)->stack_max);
 
@@ -1349,7 +1349,7 @@ ALWAYS_INLINE(static VALUE
 
 static inline VALUE
 invoke_iseq_block_from_c(rb_execution_context_t *ec, const struct rb_captured_block *captured,
-			 VALUE self, int argc, const VALUE *argv, int kw_splat, VALUE passed_block_handler,
+                         VALUE self, int argc, const VALUE *argv, int kw_splat, VALUE passed_block_handler,
                          const rb_cref_t *cref, int is_lambda, const rb_callable_method_entry_t *me)
 {
     const rb_iseq_t *iseq = rb_iseq_check(captured->code.iseq);
@@ -1364,49 +1364,49 @@ invoke_iseq_block_from_c(rb_execution_context_t *ec, const struct rb_captured_bl
     vm_check_canary(ec, sp);
     cfp->sp = sp + argc;
     for (i=0; i<argc; i++) {
-	sp[i] = argv[i];
+        sp[i] = argv[i];
     }
 
     opt_pc = vm_yield_setup_args(ec, iseq, argc, sp, kw_splat, passed_block_handler,
-				 (is_lambda ? arg_setup_method : arg_setup_block));
+                                 (is_lambda ? arg_setup_method : arg_setup_block));
     cfp->sp = sp;
 
     if (me == NULL) {
-	return invoke_block(ec, iseq, self, captured, cref, type, opt_pc);
+        return invoke_block(ec, iseq, self, captured, cref, type, opt_pc);
     }
     else {
-	return invoke_bmethod(ec, iseq, self, captured, me, type, opt_pc);
+        return invoke_bmethod(ec, iseq, self, captured, me, type, opt_pc);
     }
 }
 
 static inline VALUE
 invoke_block_from_c_bh(rb_execution_context_t *ec, VALUE block_handler,
-		       int argc, const VALUE *argv,
-		       int kw_splat, VALUE passed_block_handler, const rb_cref_t *cref,
-		       int is_lambda, int force_blockarg)
+                       int argc, const VALUE *argv,
+                       int kw_splat, VALUE passed_block_handler, const rb_cref_t *cref,
+                       int is_lambda, int force_blockarg)
 {
   again:
     switch (vm_block_handler_type(block_handler)) {
       case block_handler_type_iseq:
-	{
-	    const struct rb_captured_block *captured = VM_BH_TO_ISEQ_BLOCK(block_handler);
-	    return invoke_iseq_block_from_c(ec, captured, captured->self,
-					    argc, argv, kw_splat, passed_block_handler,
+        {
+            const struct rb_captured_block *captured = VM_BH_TO_ISEQ_BLOCK(block_handler);
+            return invoke_iseq_block_from_c(ec, captured, captured->self,
+                                            argc, argv, kw_splat, passed_block_handler,
                                             cref, is_lambda, NULL);
-	}
+        }
       case block_handler_type_ifunc:
-	return vm_yield_with_cfunc(ec, VM_BH_TO_IFUNC_BLOCK(block_handler),
-				   VM_BH_TO_IFUNC_BLOCK(block_handler)->self,
+        return vm_yield_with_cfunc(ec, VM_BH_TO_IFUNC_BLOCK(block_handler),
+                                   VM_BH_TO_IFUNC_BLOCK(block_handler)->self,
                                    argc, argv, kw_splat, passed_block_handler, NULL);
       case block_handler_type_symbol:
-	return vm_yield_with_symbol(ec, VM_BH_TO_SYMBOL(block_handler),
-				    argc, argv, kw_splat, passed_block_handler);
+        return vm_yield_with_symbol(ec, VM_BH_TO_SYMBOL(block_handler),
+                                    argc, argv, kw_splat, passed_block_handler);
       case block_handler_type_proc:
-	if (force_blockarg == FALSE) {
-	    is_lambda = block_proc_is_lambda(VM_BH_TO_PROC(block_handler));
-	}
-	block_handler = vm_proc_to_block_handler(VM_BH_TO_PROC(block_handler));
-	goto again;
+        if (force_blockarg == FALSE) {
+            is_lambda = block_proc_is_lambda(VM_BH_TO_PROC(block_handler));
+        }
+        block_handler = vm_proc_to_block_handler(VM_BH_TO_PROC(block_handler));
+        goto again;
     }
     VM_UNREACHABLE(invoke_block_from_c_splattable);
     return Qundef;
@@ -1418,7 +1418,7 @@ check_block_handler(rb_execution_context_t *ec)
     VALUE block_handler = VM_CF_BLOCK_HANDLER(ec->cfp);
     vm_block_handler_verify(block_handler);
     if (UNLIKELY(block_handler == VM_BLOCK_HANDLER_NONE)) {
-	rb_vm_localjump_error("no block given", Qnil, 0);
+        rb_vm_localjump_error("no block given", Qnil, 0);
     }
 
     return block_handler;
@@ -1429,7 +1429,7 @@ vm_yield_with_cref(rb_execution_context_t *ec, int argc, const VALUE *argv, int
 {
     return invoke_block_from_c_bh(ec, check_block_handler(ec),
                                   argc, argv, kw_splat, VM_BLOCK_HANDLER_NONE,
-				  cref, is_lambda, FALSE);
+                                  cref, is_lambda, FALSE);
 }
 
 static VALUE
@@ -1443,7 +1443,7 @@ vm_yield_with_block(rb_execution_context_t *ec, int argc, const VALUE *argv, VAL
 {
     return invoke_block_from_c_bh(ec, check_block_handler(ec),
                                   argc, argv, kw_splat, block_handler,
-				  NULL, FALSE, FALSE);
+                                  NULL, FALSE, FALSE);
 }
 
 static VALUE
@@ -1461,7 +1461,7 @@ ALWAYS_INLINE(static VALUE
 
 static inline VALUE
 invoke_block_from_c_proc(rb_execution_context_t *ec, const rb_proc_t *proc,
-			 VALUE self, int argc, const VALUE *argv,
+                         VALUE self, int argc, const VALUE *argv,
                          int kw_splat, VALUE passed_block_handler, int is_lambda,
                          const rb_callable_method_entry_t *me)
 {
@@ -1486,11 +1486,11 @@ invoke_block_from_c_proc(rb_execution_context_t *ec, const rb_proc_t *proc,
         }
         return vm_yield_with_cfunc(ec, &block->as.captured, self, argc, argv, kw_splat, passed_block_handler, me);
       case block_type_symbol:
-	return vm_yield_with_symbol(ec, block->as.symbol, argc, argv, kw_splat, passed_block_handler);
+        return vm_yield_with_symbol(ec, block->as.symbol, argc, argv, kw_splat, passed_block_handler);
       case block_type_proc:
-	is_lambda = block_proc_is_lambda(block->as.proc);
-	block = vm_proc_block(block->as.proc);
-	goto again;
+        is_lambda = block_proc_is_lambda(block->as.proc);
+        block = vm_proc_block(block->as.proc);
+        goto again;
     }
     VM_UNREACHABLE(invoke_block_from_c_proc);
     return Qundef;
@@ -1498,7 +1498,7 @@ invoke_block_from_c_proc(rb_execution_context_t *ec, const rb_proc_t *proc,
 
 static VALUE
 vm_invoke_proc(rb_execution_context_t *ec, rb_proc_t *proc, VALUE self,
-	       int argc, const VALUE *argv, int kw_splat, VALUE passed_block_handler)
+               int argc, const VALUE *argv, int kw_splat, VALUE passed_block_handler)
 {
     return invoke_block_from_c_proc(ec, proc, self, argc, argv, kw_splat, passed_block_handler, proc->is_lambda, NULL);
 }
@@ -1512,7 +1512,7 @@ rb_vm_invoke_bmethod(rb_execution_context_t *ec, rb_proc_t *proc, VALUE self,
 
 MJIT_FUNC_EXPORTED VALUE
 rb_vm_invoke_proc(rb_execution_context_t *ec, rb_proc_t *proc,
-		  int argc, const VALUE *argv, int kw_splat, VALUE passed_block_handler)
+                  int argc, const VALUE *argv, int kw_splat, VALUE passed_block_handler)
 {
     VALUE self = vm_block_self(&proc->block);
     vm_block_handler_verify(passed_block_handler);
@@ -1521,7 +1521,7 @@ rb_vm_invoke_proc(rb_execution_context_t *ec, rb_proc_t *proc,
         return rb_vm_invoke_bmethod(ec, proc, self, argc, argv, kw_splat, passed_block_handler, NULL);
     }
     else {
-	return vm_invoke_proc(ec, proc, self, argc, argv, kw_splat, passed_block_handler);
+        return vm_invoke_proc(ec, proc, self, argc, argv, kw_splat, passed_block_handler);
     }
 }
 
@@ -1535,7 +1535,7 @@ rb_vm_invoke_proc_with_self(rb_execution_context_t *ec, rb_proc_t *proc, VALUE s
         return rb_vm_invoke_bmethod(ec, proc, self, argc, argv, kw_splat, passed_block_handler, NULL);
     }
     else {
-	return vm_invoke_proc(ec, proc, self, argc, argv, kw_splat, passed_block_handler);
+        return vm_invoke_proc(ec, proc, self, argc, argv, kw_splat, passed_block_handler);
     }
 }
 
@@ -1545,10 +1545,10 @@ static rb_control_frame_t *
 vm_normal_frame(const rb_execution_context_t *ec, rb_control_frame_t *cfp)
 {
     while (cfp->pc == 0) {
-	cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
-	if (RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(ec, cfp)) {
-	    return 0;
-	}
+        cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
+        if (RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(ec, cfp)) {
+            return 0;
+        }
     }
     return cfp;
 }
@@ -1612,10 +1612,10 @@ rb_sourcefile(void)
     const rb_control_frame_t *cfp = rb_vm_get_ruby_level_next_cfp(ec, ec->cfp);
 
     if (cfp) {
-	return RSTRING_PTR(rb_iseq_path(cfp->iseq));
+        return RSTRING_PTR(rb_iseq_path(cfp->iseq));
     }
     else {
-	return 0;
+        return 0;
     }
 }
 
@@ -1626,10 +1626,10 @@ rb_sourceline(void)
     const rb_control_frame_t *cfp = rb_vm_get_ruby_level_next_cfp(ec, ec->cfp);
 
     if (cfp) {
-	return rb_vm_get_sourceline(cfp);
+        return rb_vm_get_sourceline(cfp);
     }
     else {
-	return 0;
+        return 0;
     }
 }
 
@@ -1640,12 +1640,12 @@ rb_source_location(int *pline)
     const rb_control_frame_t *cfp = rb_vm_get_ruby_level_next_cfp(ec, ec->cfp);
 
     if (cfp && VM_FRAME_RUBYFRAME_P(cfp)) {
-	if (pline) *pline = rb_vm_get_sourceline(cfp);
-	return rb_iseq_path(cfp->iseq);
+        if (pline) *pline = rb_vm_get_sourceline(cfp);
+        return rb_iseq_path(cfp->iseq);
     }
     else {
-	if (pline) *pline = 0;
-	return Qnil;
+        if (pline) *pline = 0;
+        return Qnil;
     }
 }
 
@@ -1692,9 +1692,9 @@ void
 debug_cref(rb_cref_t *cref)
 {
     while (cref) {
-	dp(CREF_CLASS(cref));
-	printf("%ld\n", CREF_VISI(cref));
-	cref = CREF_NEXT(cref);
+        dp(CREF_CLASS(cref));
+        printf("%ld\n", CREF_VISI(cref));
+        cref = CREF_NEXT(cref);
     }
 }
 #endif
@@ -1706,7 +1706,7 @@ rb_vm_cbase(void)
     const rb_control_frame_t *cfp = rb_vm_get_ruby_level_next_cfp(ec, ec->cfp);
 
     if (cfp == 0) {
-	rb_raise(rb_eRuntimeError, "Can't call on top of Fiber or Thread");
+        rb_raise(rb_eRuntimeError, "Can't call on top of Fiber or Thread");
     }
     return vm_get_cbase(cfp->ep);
 }
@@ -1722,23 +1722,23 @@ make_localjump_error(const char *mesg, VALUE value, int reason)
 
     switch (reason) {
       case TAG_BREAK:
-	CONST_ID(id, "break");
-	break;
+        CONST_ID(id, "break");
+        break;
       case TAG_REDO:
-	CONST_ID(id, "redo");
-	break;
+        CONST_ID(id, "redo");
+        break;
       case TAG_RETRY:
-	CONST_ID(id, "retry");
-	break;
+        CONST_ID(id, "retry");
+        break;
       case TAG_NEXT:
-	CONST_ID(id, "next");
-	break;
+        CONST_ID(id, "next");
+        break;
       case TAG_RETURN:
-	CONST_ID(id, "return");
-	break;
+        CONST_ID(id, "return");
+        break;
       default:
-	CONST_ID(id, "noreason");
-	break;
+        CONST_ID(id, "noreason");
+        break;
     }
     rb_iv_set(exc, "@exit_value", value);
     rb_iv_set(exc, "@reason", ID2SYM(id));
@@ -1759,27 +1759,27 @@ rb_vm_make_jump_tag_but_local_jump(int state, VALUE val)
 
     switch (state) {
       case TAG_RETURN:
-	mesg = "unexpected return";
-	break;
+        mesg = "unexpected return";
+        break;
       case TAG_BREAK:
-	mesg = "unexpected break";
-	break;
+        mesg = "unexpected break";
+        break;
       case TAG_NEXT:
-	mesg = "unexpected next";
-	break;
+        mesg = "unexpected next";
+        break;
       case TAG_REDO:
-	mesg = "unexpected redo";
-	val = Qnil;
-	break;
+        mesg = "unexpected redo";
+        val = Qnil;
+        break;
       case TAG_RETRY:
-	mesg = "retry outside of rescue clause";
-	val = Qnil;
-	break;
+        mesg = "retry outside of rescue clause";
+        val = Qnil;
+        break;
       default:
-	return Qnil;
+        return Qnil;
     }
     if (val == Qundef) {
-	val = GET_EC()->tag->retval;
+        val = GET_EC()->tag->retval;
     }
     return make_localjump_error(mesg, val, state);
 }
@@ -1796,7 +1796,7 @@ static rb_control_frame_t *
 next_not_local_frame(rb_control_frame_t *cfp)
 {
     while (VM_ENV_LOCAL_P(cfp->ep)) {
-	cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
+        cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
     }
     return cfp;
 }
@@ -1811,7 +1811,7 @@ vm_iter_break(rb_execution_context_t *ec, VALUE val)
     const rb_control_frame_t *target_cfp = rb_vm_search_cf_from_ep(ec, cfp, ep);
 
     if (!target_cfp) {
-	rb_vm_localjump_error("unexpected break", val, TAG_BREAK);
+        rb_vm_localjump_error("unexpected break", val, TAG_BREAK);
     }
 
     ec->errinfo = (VALUE)THROW_DATA_NEW(val, target_cfp, TAG_BREAK);
@@ -1876,9 +1876,9 @@ vm_redefinition_check_method_type(const rb_method_entry_t *me)
     switch (def->type) {
       case VM_METHOD_TYPE_CFUNC:
       case VM_METHOD_TYPE_OPTIMIZED:
-	return TRUE;
+        return TRUE;
       default:
-	return FALSE;
+        return FALSE;
     }
 }
 
@@ -1926,11 +1926,11 @@ add_opt_method(VALUE klass, ID mid, VALUE bop)
     const rb_method_entry_t *me = rb_method_entry_at(klass, mid);
 
     if (me && vm_redefinition_check_method_type(me)) {
-	st_insert(vm_opt_method_def_table, (st_data_t)me->def, (st_data_t)bop);
-	st_insert(vm_opt_mid_table, (st_data_t)mid, (st_data_t)Qtrue);
+        st_insert(vm_opt_method_def_table, (st_data_t)me->def, (st_data_t)bop);
+        st_insert(vm_opt_mid_table, (st_data_t)mid, (st_data_t)Qtrue);
     }
     else {
-	rb_bug("undefined optimized method: %s", rb_id2name(mid));
+        rb_bug("undefined optimized method: %s", rb_id2name(mid));
     }
 }
 
@@ -1952,7 +1952,7 @@ vm_init_redefined_flag(void)
     OP(MOD, MOD), (C(Integer), C(Float));
     OP(Eq, EQ), (C(Integer), C(Float), C(String), C(Symbol));
     OP(Eqq, EQQ), (C(Integer), C(Float), C(Symbol), C(String),
-		   C(NilClass), C(TrueClass), C(FalseClass));
+                   C(NilClass), C(TrueClass), C(FalseClass));
     OP(LT, LT), (C(Integer), C(Float));
     OP(LE, LE), (C(Integer), C(Float));
     OP(GT, GT), (C(Integer), C(Float));
@@ -1993,7 +1993,7 @@ vm_frametype_name(const rb_control_frame_t *cfp)
       case VM_FRAME_MAGIC_EVAL:   return "eval";
       case VM_FRAME_MAGIC_RESCUE: return "rescue";
       default:
-	rb_bug("unknown frame");
+        rb_bug("unknown frame");
     }
 }
 #endif
@@ -2002,12 +2002,12 @@ static VALUE
 frame_return_value(const struct vm_throw_data *err)
 {
     if (THROW_DATA_P(err) &&
-	THROW_DATA_STATE(err) == TAG_BREAK &&
-	THROW_DATA_CONSUMED_P(err) == FALSE) {
-	return THROW_DATA_VAL(err);
+        THROW_DATA_STATE(err) == TAG_BREAK &&
+        THROW_DATA_CONSUMED_P(err) == FALSE) {
+        return THROW_DATA_VAL(err);
     }
     else {
-	return Qnil;
+        return Qnil;
     }
 }
 
@@ -2041,7 +2041,7 @@ hook_before_rewind(rb_execution_context_t *ec, const rb_control_frame_t *cfp,
                    bool cfp_returning_with_value, int state, struct vm_throw_data *err)
 {
     if (state == TAG_RAISE && RBASIC(err)->klass == rb_eSysStackError) {
-	return;
+        return;
     }
     else {
         const rb_iseq_t *iseq = cfp->iseq;
@@ -2293,17 +2293,17 @@ vm_exec(rb_execution_context_t *ec, bool mjit_enable_p)
         goto vm_loop_start; /* fallback to the VM */
     }
     else {
-	result = ec->errinfo;
+        result = ec->errinfo;
         rb_ec_raised_reset(ec, RAISED_STACKOVERFLOW | RAISED_NOMEMORY);
         while ((result = vm_exec_handle_exception(ec, state, result, &initial)) == Qundef) {
             /* caught a jump, exec the handler */
             result = vm_exec_core(ec, initial);
-	  vm_loop_start:
-	    VM_ASSERT(ec->tag == &_tag);
-	    /* when caught `throw`, `tag.state` is set. */
-	    if ((state = _tag.state) == TAG_NONE) break;
-	    _tag.state = TAG_NONE;
-	}
+          vm_loop_start:
+            VM_ASSERT(ec->tag == &_tag);
+            /* when caught `throw`, `tag.state` is set. */
+            if ((state = _tag.state) == TAG_NONE) break;
+            _tag.state = TAG_NONE;
+        }
     }
     EC_POP_TAG();
     return result;
@@ -2317,121 +2317,121 @@ vm_exec_handle_exception(rb_execution_context_t *ec, enum ruby_tag_type state,
     struct vm_throw_data *err = (struct vm_throw_data *)errinfo;
 
     for (;;) {
-	unsigned int i;
-	const struct iseq_catch_table_entry *entry;
-	const struct iseq_catch_table *ct;
-	unsigned long epc, cont_pc, cont_sp;
-	const rb_iseq_t *catch_iseq;
-	rb_control_frame_t *cfp;
-	VALUE type;
-	const rb_control_frame_t *escape_cfp;
-
-	cont_pc = cont_sp = 0;
-	catch_iseq = NULL;
-
-	while (ec->cfp->pc == 0 || ec->cfp->iseq == 0) {
-	    if (UNLIKELY(VM_FRAME_TYPE(ec->cfp) == VM_FRAME_MAGIC_CFUNC)) {
-		EXEC_EVENT_HOOK_AND_POP_FRAME(ec, RUBY_EVENT_C_RETURN, ec->cfp->self,
-					      rb_vm_frame_method_entry(ec->cfp)->def->original_id,
-					      rb_vm_frame_method_entry(ec->cfp)->called_id,
-					      rb_vm_frame_method_entry(ec->cfp)->owner, Qnil);
-		RUBY_DTRACE_CMETHOD_RETURN_HOOK(ec,
-						rb_vm_frame_method_entry(ec->cfp)->owner,
-						rb_vm_frame_method_entry(ec->cfp)->def->original_id);
-	    }
-	    rb_vm_pop_frame(ec);
-	}
-
-	cfp = ec->cfp;
+        unsigned int i;
+        const struct iseq_catch_table_entry *entry;
+        const struct iseq_catch_table *ct;
+        unsigned long epc, cont_pc, cont_sp;
+        const rb_iseq_t *catch_iseq;
+        rb_control_frame_t *cfp;
+        VALUE type;
+        const rb_control_frame_t *escape_cfp;
+
+        cont_pc = cont_sp = 0;
+        catch_iseq = NULL;
+
+        while (ec->cfp->pc == 0 || ec->cfp->iseq == 0) {
+            if (UNLIKELY(VM_FRAME_TYPE(ec->cfp) == VM_FRAME_MAGIC_CFUNC)) {
+                EXEC_EVENT_HOOK_AND_POP_FRAME(ec, RUBY_EVENT_C_RETURN, ec->cfp->self,
+                                              rb_vm_frame_method_entry(ec->cfp)->def->original_id,
+                                              rb_vm_frame_method_entry(ec->cfp)->called_id,
+                                              rb_vm_frame_method_entry(ec->cfp)->owner, Qnil);
+                RUBY_DTRACE_CMETHOD_RETURN_HOOK(ec,
+                                                rb_vm_frame_method_entry(ec->cfp)->owner,
+                                                rb_vm_frame_method_entry(ec->cfp)->def->original_id);
+            }
+            rb_vm_pop_frame(ec);
+        }
+
+        cfp = ec->cfp;
         epc = cfp->pc - ISEQ_BODY(cfp->iseq)->iseq_encoded;
 
-	escape_cfp = NULL;
-	if (state == TAG_BREAK || state == TAG_RETURN) {
-	    escape_cfp = THROW_DATA_CATCH_FRAME(err);
-
-	    if (cfp == escape_cfp) {
-		if (state == TAG_RETURN) {
-		    if (!VM_FRAME_FINISHED_P(cfp)) {
-			THROW_DATA_CATCH_FRAME_SET(err, cfp + 1);
-			THROW_DATA_STATE_SET(err, state = TAG_BREAK);
-		    }
-		    else {
+        escape_cfp = NULL;
+        if (state == TAG_BREAK || state == TAG_RETURN) {
+            escape_cfp = THROW_DATA_CATCH_FRAME(err);
+
+            if (cfp == escape_cfp) {
+                if (state == TAG_RETURN) {
+                    if (!VM_FRAME_FINISHED_P(cfp)) {
+                        THROW_DATA_CATCH_FRAME_SET(err, cfp + 1);
+                        THROW_DATA_STATE_SET(err, state = TAG_BREAK);
+                    }
+                    else {
                         ct = ISEQ_BODY(cfp->iseq)->catch_table;
-			if (ct) for (i = 0; i < ct->size; i++) {
-			    entry = UNALIGNED_MEMBER_PTR(ct, entries[i]);
-			    if (entry->start < epc && entry->end >= epc) {
-				if (entry->type == CATCH_TYPE_ENSURE) {
-				    catch_iseq = entry->iseq;
-				    cont_pc = entry->cont;
-				    cont_sp = entry->sp;
-				    break;
-				}
-			    }
-			}
-			if (catch_iseq == NULL) {
-			    ec->errinfo = Qnil;
-			    THROW_DATA_CATCH_FRAME_SET(err, cfp + 1);
+                        if (ct) for (i = 0; i < ct->size; i++) {
+                            entry = UNALIGNED_MEMBER_PTR(ct, entries[i]);
+                            if (entry->start < epc && entry->end >= epc) {
+                                if (entry->type == CATCH_TYPE_ENSURE) {
+                                    catch_iseq = entry->iseq;
+                                    cont_pc = entry->cont;
+                                    cont_sp = entry->sp;
+                                    break;
+                                }
+                            }
+                        }
+                        if (catch_iseq == NULL) {
+                            ec->errinfo = Qnil;
+                            THROW_DATA_CATCH_FRAME_SET(err, cfp + 1);
                             // cfp == escape_cfp here so calling with cfp_returning_with_value = true
                             hook_before_rewind(ec, ec->cfp, true, state, err);
-			    rb_vm_pop_frame(ec);
-			    return THROW_DATA_VAL(err);
-			}
-		    }
-		    /* through */
-		}
-		else {
-		    /* TAG_BREAK */
+                            rb_vm_pop_frame(ec);
+                            return THROW_DATA_VAL(err);
+                        }
+                    }
+                    /* through */
+                }
+                else {
+                    /* TAG_BREAK */
 #if OPT_STACK_CACHING
-		    *initial = THROW_DATA_VAL(err);
+                    *initial = THROW_DATA_VAL(err);
 #else
-		    *ec->cfp->sp++ = THROW_DATA_VAL(err);
+                    *ec->cfp->sp++ = THROW_DATA_VAL(err);
 #endif
-		    ec->errinfo = Qnil;
-		    return Qundef;
-		}
-	    }
-	}
+                    ec->errinfo = Qnil;
+                    return Qundef;
+                }
+            }
+        }
 
-	if (state == TAG_RAISE) {
+        if (state == TAG_RAISE) {
             ct = ISEQ_BODY(cfp->iseq)->catch_table;
-	    if (ct) for (i = 0; i < ct->size; i++) {
-		entry = UNALIGNED_MEMBER_PTR(ct, entries[i]);
-		if (entry->start < epc && entry->end >= epc) {
-
-		    if (entry->type == CATCH_TYPE_RESCUE ||
-			entry->type == CATCH_TYPE_ENSURE) {
-			catch_iseq = entry->iseq;
-			cont_pc = entry->cont;
-			cont_sp = entry->sp;
-			break;
-		    }
-		}
-	    }
-	}
-	else if (state == TAG_RETRY) {
+            if (ct) for (i = 0; i < ct->size; i++) {
+                entry = UNALIGNED_MEMBER_PTR(ct, entries[i]);
+                if (entry->start < epc && entry->end >= epc) {
+
+                    if (entry->type == CATCH_TYPE_RESCUE ||
+                        entry->type == CATCH_TYPE_ENSURE) {
+                        catch_iseq = entry->iseq;
+                        cont_pc = entry->cont;
+                        cont_sp = entry->sp;
+                        break;
+                    }
+                }
+            }
+        }
+        else if (state == TAG_RETRY) {
             ct = ISEQ_BODY(cfp->iseq)->catch_table;
-	    if (ct) for (i = 0; i < ct->size; i++) {
-		entry = UNALIGNED_MEMBER_PTR(ct, entries[i]);
-		if (entry->start < epc && entry->end >= epc) {
-
-		    if (entry->type == CATCH_TYPE_ENSURE) {
-			catch_iseq = entry->iseq;
-			cont_pc = entry->cont;
-			cont_sp = entry->sp;
-			break;
-		    }
-		    else if (entry->type == CATCH_TYPE_RETRY) {
-			const rb_control_frame_t *escape_cfp;
-			escape_cfp = THROW_DATA_CATCH_FRAME(err);
-			if (cfp == escape_cfp) {
+            if (ct) for (i = 0; i < ct->size; i++) {
+                entry = UNALIGNED_MEMBER_PTR(ct, entries[i]);
+                if (entry->start < epc && entry->end >= epc) {
+
+                    if (entry->type == CATCH_TYPE_ENSURE) {
+                        catch_iseq = entry->iseq;
+                        cont_pc = entry->cont;
+                        cont_sp = entry->sp;
+                        break;
+                    }
+                    else if (entry->type == CATCH_TYPE_RETRY) {
+                        const rb_control_frame_t *escape_cfp;
+                        escape_cfp = THROW_DATA_CATCH_FRAME(err);
+                        if (cfp == escape_cfp) {
                             cfp->pc = ISEQ_BODY(cfp->iseq)->iseq_encoded + entry->cont;
-			    ec->errinfo = Qnil;
-			    return Qundef;
-			}
-		    }
-		}
-	    }
-	}
+                            ec->errinfo = Qnil;
+                            return Qundef;
+                        }
+                    }
+                }
+            }
+        }
         else if ((state == TAG_BREAK && !escape_cfp) ||
                  (state == TAG_REDO) ||
                  (state == TAG_NEXT)) {
@@ -2443,88 +2443,88 @@ vm_exec_handle_exception(rb_execution_context_t *ec, enum ruby_tag_type state,
             }[state];
 
             ct = ISEQ_BODY(cfp->iseq)->catch_table;
-	    if (ct) for (i = 0; i < ct->size; i++) {
-		entry = UNALIGNED_MEMBER_PTR(ct, entries[i]);
-
-		if (entry->start < epc && entry->end >= epc) {
-		    if (entry->type == CATCH_TYPE_ENSURE) {
-			catch_iseq = entry->iseq;
-			cont_pc = entry->cont;
-			cont_sp = entry->sp;
-			break;
-		    }
-		    else if (entry->type == type) {
+            if (ct) for (i = 0; i < ct->size; i++) {
+                entry = UNALIGNED_MEMBER_PTR(ct, entries[i]);
+
+                if (entry->start < epc && entry->end >= epc) {
+                    if (entry->type == CATCH_TYPE_ENSURE) {
+                        catch_iseq = entry->iseq;
+                        cont_pc = entry->cont;
+                        cont_sp = entry->sp;
+                        break;
+                    }
+                    else if (entry->type == type) {
                         cfp->pc = ISEQ_BODY(cfp->iseq)->iseq_encoded + entry->cont;
-			cfp->sp = vm_base_ptr(cfp) + entry->sp;
+                        cfp->sp = vm_base_ptr(cfp) + entry->sp;
 
-			if (state != TAG_REDO) {
+                        if (state != TAG_REDO) {
 #if OPT_STACK_CACHING
-			    *initial = THROW_DATA_VAL(err);
+                            *initial = THROW_DATA_VAL(err);
 #else
-			    *ec->cfp->sp++ = THROW_DATA_VAL(err);
+                            *ec->cfp->sp++ = THROW_DATA_VAL(err);
 #endif
-			}
-			ec->errinfo = Qnil;
-			VM_ASSERT(ec->tag->state == TAG_NONE);
-			return Qundef;
-		    }
-		}
-	    }
-	}
-	else {
+                        }
+                        ec->errinfo = Qnil;
+                        VM_ASSERT(ec->tag->state == TAG_NONE);
+                        return Qundef;
+                    }
+                }
+            }
+        }
+        else {
             ct = ISEQ_BODY(cfp->iseq)->catch_table;
-	    if (ct) for (i = 0; i < ct->size; i++) {
-		entry = UNALIGNED_MEMBER_PTR(ct, entries[i]);
-		if (entry->start < epc && entry->end >= epc) {
-
-		    if (entry->type == CATCH_TYPE_ENSURE) {
-			catch_iseq = entry->iseq;
-			cont_pc = entry->cont;
-			cont_sp = entry->sp;
-			break;
-		    }
-		}
-	    }
-	}
-
-	if (catch_iseq != NULL) { /* found catch table */
-	    /* enter catch scope */
-	    const int arg_size = 1;
-
-	    rb_iseq_check(catch_iseq);
-	    cfp->sp = vm_base_ptr(cfp) + cont_sp;
+            if (ct) for (i = 0; i < ct->size; i++) {
+                entry = UNALIGNED_MEMBER_PTR(ct, entries[i]);
+                if (entry->start < epc && entry->end >= epc) {
+
+                    if (entry->type == CATCH_TYPE_ENSURE) {
+                        catch_iseq = entry->iseq;
+                        cont_pc = entry->cont;
+                        cont_sp = entry->sp;
+                        break;
+                    }
+                }
+            }
+        }
+
+        if (catch_iseq != NULL) { /* found catch table */
+            /* enter catch scope */
+            const int arg_size = 1;
+
+            rb_iseq_check(catch_iseq);
+            cfp->sp = vm_base_ptr(cfp) + cont_sp;
             cfp->pc = ISEQ_BODY(cfp->iseq)->iseq_encoded + cont_pc;
 
-	    /* push block frame */
-	    cfp->sp[0] = (VALUE)err;
-	    vm_push_frame(ec, catch_iseq, VM_FRAME_MAGIC_RESCUE,
-			  cfp->self,
-			  VM_GUARDED_PREV_EP(cfp->ep),
-			  0, /* cref or me */
+            /* push block frame */
+            cfp->sp[0] = (VALUE)err;
+            vm_push_frame(ec, catch_iseq, VM_FRAME_MAGIC_RESCUE,
+                          cfp->self,
+                          VM_GUARDED_PREV_EP(cfp->ep),
+                          0, /* cref or me */
                           ISEQ_BODY(catch_iseq)->iseq_encoded,
-			  cfp->sp + arg_size /* push value */,
+                          cfp->sp + arg_size /* push value */,
                           ISEQ_BODY(catch_iseq)->local_table_size - arg_size,
                           ISEQ_BODY(catch_iseq)->stack_max);
 
-	    state = 0;
-	    ec->tag->state = TAG_NONE;
-	    ec->errinfo = Qnil;
+            state = 0;
+            ec->tag->state = TAG_NONE;
+            ec->errinfo = Qnil;
 
-	    return Qundef;
-	}
-	else {
-	    hook_before_rewind(ec, ec->cfp, (cfp == escape_cfp), state, err);
+            return Qundef;
+        }
+        else {
+            hook_before_rewind(ec, ec->cfp, (cfp == escape_cfp), state, err);
 
-	    if (VM_FRAME_FINISHED_P(ec->cfp)) {
-		rb_vm_pop_frame(ec);
-		ec->errinfo = (VALUE)err;
-		ec->tag = ec->tag->prev;
-		EC_JUMP_TAG(ec, state);
-	    }
-	    else {
-		rb_vm_pop_frame(ec);
-	    }
-	}
+            if (VM_FRAME_FINISHED_P(ec->cfp)) {
+                rb_vm_pop_frame(ec);
+                ec->errinfo = (VALUE)err;
+                ec->tag = ec->tag->prev;
+                EC_JUMP_TAG(ec, state);
+            }
+            else {
+                rb_vm_pop_frame(ec);
+            }
+        }
     }
 }
 
@@ -2557,13 +2557,13 @@ rb_vm_control_frame_id_and_class(const rb_control_frame_t *cfp, ID *idp, ID *cal
     const rb_callable_method_entry_t *me = rb_vm_frame_method_entry(cfp);
 
     if (me) {
-	if (idp) *idp = me->def->original_id;
-	if (called_idp) *called_idp = me->called_id;
-	if (klassp) *klassp = me->owner;
-	return TRUE;
+        if (idp) *idp = me->def->original_id;
+        if (called_idp) *called_idp = me->called_id;
+        if (klassp) *klassp = me->owner;
+        return TRUE;
     }
     else {
-	return FALSE;
+        return FALSE;
     }
 }
 
@@ -2581,7 +2581,7 @@ rb_frame_method_id_and_class(ID *idp, VALUE *klassp)
 
 VALUE
 rb_vm_call_cfunc(VALUE recv, VALUE (*func)(VALUE), VALUE arg,
-		 VALUE block_handler, VALUE filename)
+                 VALUE block_handler, VALUE filename)
 {
     rb_execution_context_t *ec = GET_EC();
     const rb_control_frame_t *reg_cfp = ec->cfp;
@@ -2589,9 +2589,9 @@ rb_vm_call_cfunc(VALUE recv, VALUE (*func)(VALUE), VALUE arg,
     VALUE val;
 
     vm_push_frame(ec, iseq, VM_FRAME_MAGIC_TOP | VM_ENV_FLAG_LOCAL | VM_FRAME_FLAG_FINISH,
-		  recv, block_handler,
-		  (VALUE)vm_cref_new_toplevel(ec), /* cref or me */
-		  0, reg_cfp->sp, 0, 0);
+                  recv, block_handler,
+                  (VALUE)vm_cref_new_toplevel(ec), /* cref or me */
+                  0, reg_cfp->sp, 0, 0);
 
     val = (*func)(arg);
 
@@ -2675,17 +2675,17 @@ rb_vm_mark(void *ptr)
     RUBY_MARK_ENTER("vm");
     RUBY_GC_INFO("-------------------------------------------------\n");
     if (ptr) {
-	rb_vm_t *vm = ptr;
+        rb_vm_t *vm = ptr;
         rb_ractor_t *r = 0;
         long i, len;
         const VALUE *obj_ary;
 
-	ccan_list_for_each(&vm->ractor.set, r, vmlr_node) {
+        ccan_list_for_each(&vm->ractor.set, r, vmlr_node) {
             // ractor.set only contains blocking or running ractors
             VM_ASSERT(rb_ractor_status_p(r, ractor_blocking) ||
                       rb_ractor_status_p(r, ractor_running));
             rb_gc_mark(rb_ractor_self(r));
-	}
+        }
 
         rb_gc_mark_movable(vm->mark_object_ary);
 
@@ -2718,9 +2718,9 @@ rb_vm_mark(void *ptr)
         /* Prevent classes from moving */
         rb_mark_tbl(vm->defined_module_hash);
 
-	if (vm->loading_table) {
-	    rb_mark_tbl(vm->loading_table);
-	}
+        if (vm->loading_table) {
+            rb_mark_tbl(vm->loading_table);
+        }
 
         rb_gc_mark_values(RUBY_NSIG, vm->trap_list.cmd);
 
@@ -2779,34 +2779,34 @@ ruby_vm_destruct(rb_vm_t *vm)
     RUBY_FREE_ENTER("vm");
 
     if (vm) {
-	rb_thread_t *th = vm->ractor.main_thread;
-	struct rb_objspace *objspace = vm->objspace;
+        rb_thread_t *th = vm->ractor.main_thread;
+        struct rb_objspace *objspace = vm->objspace;
         vm->ractor.main_thread = NULL;
 
         if (th) {
             rb_fiber_reset_root_local_storage(th);
-	    thread_free(th);
-	}
-	rb_vm_living_threads_init(vm);
-	ruby_vm_run_at_exit_hooks(vm);
-	if (vm->loading_table) {
-	    st_foreach(vm->loading_table, free_loading_table_entry, 0);
-	    st_free_table(vm->loading_table);
-	    vm->loading_table = 0;
-	}
-	if (vm->frozen_strings) {
-	    st_free_table(vm->frozen_strings);
-	    vm->frozen_strings = 0;
-	}
-	RB_ALTSTACK_FREE(vm->main_altstack);
-	if (objspace) {
-	    rb_objspace_free(objspace);
-	}
+            thread_free(th);
+        }
+        rb_vm_living_threads_init(vm);
+        ruby_vm_run_at_exit_hooks(vm);
+        if (vm->loading_table) {
+            st_foreach(vm->loading_table, free_loading_table_entry, 0);
+            st_free_table(vm->loading_table);
+            vm->loading_table = 0;
+        }
+        if (vm->frozen_strings) {
+            st_free_table(vm->frozen_strings);
+            vm->frozen_strings = 0;
+        }
+        RB_ALTSTACK_FREE(vm->main_altstack);
+        if (objspace) {
+            rb_objspace_free(objspace);
+        }
         rb_native_mutex_destroy(&vm->waitpid_lock);
         rb_native_mutex_destroy(&vm->workqueue_lock);
-	/* after freeing objspace, you *can't* use ruby_xfree() */
-	ruby_mimfree(vm);
-	ruby_current_vm_ptr = NULL;
+        /* after freeing objspace, you *can't* use ruby_xfree() */
+        ruby_mimfree(vm);
+        ruby_current_vm_ptr = NULL;
     }
     RUBY_FREE_LEAVE("vm");
     return 0;
@@ -2920,11 +2920,11 @@ get_param(const char *name, size_t default_value, size_t min_value)
     const char *envval;
     size_t result = default_value;
     if ((envval = getenv(name)) != 0) {
-	long val = atol(envval);
-	if (val < (long)min_value) {
-	    val = (long)min_value;
-	}
-	result = (size_t)(((val -1 + RUBY_VM_SIZE_ALIGN) / RUBY_VM_SIZE_ALIGN) * RUBY_VM_SIZE_ALIGN);
+        long val = atol(envval);
+        if (val < (long)min_value) {
+            val = (long)min_value;
+        }
+        result = (size_t)(((val -1 + RUBY_VM_SIZE_ALIGN) / RUBY_VM_SIZE_ALIGN) * RUBY_VM_SIZE_ALIGN);
     }
     if (0) ruby_debug_printf("%s: %"PRIuSIZE"\n", name, result); /* debug print */
 
@@ -2940,7 +2940,7 @@ check_machine_stack_size(size_t *sizep)
 
 #ifdef PTHREAD_STACK_MIN
     if (size < (size_t)PTHREAD_STACK_MIN) {
-	*sizep = (size_t)PTHREAD_STACK_MIN * 2;
+        *sizep = (size_t)PTHREAD_STACK_MIN * 2;
     }
 #endif
 }
@@ -2950,23 +2950,23 @@ vm_default_params_setup(rb_vm_t *vm)
 {
     vm->default_params.thread_vm_stack_size =
       get_param("RUBY_THREAD_VM_STACK_SIZE",
-		RUBY_VM_THREAD_VM_STACK_SIZE,
-		RUBY_VM_THREAD_VM_STACK_SIZE_MIN);
+                RUBY_VM_THREAD_VM_STACK_SIZE,
+                RUBY_VM_THREAD_VM_STACK_SIZE_MIN);
 
     vm->default_params.thread_machine_stack_size =
       get_param("RUBY_THREAD_MACHINE_STACK_SIZE",
-		RUBY_VM_THREAD_MACHINE_STACK_SIZE,
-		RUBY_VM_THREAD_MACHINE_STACK_SIZE_MIN);
+                RUBY_VM_THREAD_MACHINE_STACK_SIZE,
+                RUBY_VM_THREAD_MACHINE_STACK_SIZE_MIN);
 
     vm->default_params.fiber_vm_stack_size =
       get_param("RUBY_FIBER_VM_STACK_SIZE",
-		RUBY_VM_FIBER_VM_STACK_SIZE,
-		RUBY_VM_FIBER_VM_STACK_SIZE_MIN);
+                RUBY_VM_FIBER_VM_STACK_SIZE,
+                RUBY_VM_FIBER_VM_STACK_SIZE_MIN);
 
     vm->default_params.fiber_machine_stack_size =
       get_param("RUBY_FIBER_MACHINE_STACK_SIZE",
-		RUBY_VM_FIBER_MACHINE_STACK_SIZE,
-		RUBY_VM_FIBER_MACHINE_STACK_SIZE_MIN);
+                RUBY_VM_FIBER_MACHINE_STACK_SIZE,
+                RUBY_VM_FIBER_MACHINE_STACK_SIZE_MIN);
 
     /* environment dependent check */
     check_machine_stack_size(&vm->default_params.thread_machine_stack_size);
@@ -3040,17 +3040,17 @@ rb_execution_context_mark(const rb_execution_context_t *ec)
     /* mark VM stack */
     if (ec->vm_stack) {
         VM_ASSERT(ec->cfp);
-	VALUE *p = ec->vm_stack;
-	VALUE *sp = ec->cfp->sp;
-	rb_control_frame_t *cfp = ec->cfp;
-	rb_control_frame_t *limit_cfp = (void *)(ec->vm_stack + ec->vm_stack_size);
+        VALUE *p = ec->vm_stack;
+        VALUE *sp = ec->cfp->sp;
+        rb_control_frame_t *cfp = ec->cfp;
+        rb_control_frame_t *limit_cfp = (void *)(ec->vm_stack + ec->vm_stack_size);
 
         VM_ASSERT(sp == ec->cfp->sp);
         rb_gc_mark_vm_stack_values((long)(sp - p), p);
 
-	while (cfp != limit_cfp) {
-	    const VALUE *ep = cfp->ep;
-	    VM_ASSERT(!!VM_ENV_FLAGS(ep, VM_ENV_FLAG_ESCAPED) == vm_ep_in_heap_p_(ec, ep));
+        while (cfp != limit_cfp) {
+            const VALUE *ep = cfp->ep;
+            VM_ASSERT(!!VM_ENV_FLAGS(ep, VM_ENV_FLAG_ESCAPED) == vm_ep_in_heap_p_(ec, ep));
             rb_gc_mark_movable(cfp->self);
             rb_gc_mark_movable((VALUE)cfp->iseq);
             rb_gc_mark_movable((VALUE)cfp->block_code);
@@ -3061,24 +3061,24 @@ rb_execution_context_mark(const rb_execution_context_t *ec)
                     rb_gc_mark_movable(prev_ep[VM_ENV_DATA_INDEX_ENV]);
                 }
 
-		if (VM_ENV_FLAGS(ep, VM_ENV_FLAG_ESCAPED)) {
+                if (VM_ENV_FLAGS(ep, VM_ENV_FLAG_ESCAPED)) {
                     rb_gc_mark_movable(ep[VM_ENV_DATA_INDEX_ENV]);
                     rb_gc_mark(ep[VM_ENV_DATA_INDEX_ME_CREF]);
-		}
+                }
             }
 
-	    cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
-	}
+            cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
+        }
     }
 
     /* mark machine stack */
     if (ec->machine.stack_start && ec->machine.stack_end &&
-	ec != GET_EC() /* marked for current ec at the first stage of marking */
-	) {
-	rb_gc_mark_machine_stack(ec);
-	rb_gc_mark_locations((VALUE *)&ec->machine.regs,
-			     (VALUE *)(&ec->machine.regs) +
-			     sizeof(ec->machine.regs) / (sizeof(VALUE)));
+        ec != GET_EC() /* marked for current ec at the first stage of marking */
+        ) {
+        rb_gc_mark_machine_stack(ec);
+        rb_gc_mark_locations((VALUE *)&ec->machine.regs,
+                             (VALUE *)(&ec->machine.regs) +
+                             sizeof(ec->machine.regs) / (sizeof(VALUE)));
     }
 
     RUBY_MARK_UNLESS_NULL(ec->errinfo);
@@ -3156,20 +3156,20 @@ thread_free(void *ptr)
     RUBY_FREE_ENTER("thread");
 
     if (th->locking_mutex != Qfalse) {
-	rb_bug("thread_free: locking_mutex must be NULL (%p:%p)", (void *)th, (void *)th->locking_mutex);
+        rb_bug("thread_free: locking_mutex must be NULL (%p:%p)", (void *)th, (void *)th->locking_mutex);
     }
     if (th->keeping_mutexes != NULL) {
-	rb_bug("thread_free: keeping_mutexes must be NULL (%p:%p)", (void *)th, (void *)th->keeping_mutexes);
+        rb_bug("thread_free: keeping_mutexes must be NULL (%p:%p)", (void *)th, (void *)th->keeping_mutexes);
     }
 
     rb_threadptr_root_fiber_release(th);
 
     if (th->vm && th->vm->ractor.main_thread == th) {
-	RUBY_GC_INFO("MRI main thread\n");
+        RUBY_GC_INFO("MRI main thread\n");
     }
     else {
         ruby_xfree(th->nt); // TODO
-	ruby_xfree(th);
+        ruby_xfree(th);
     }
 
     RUBY_FREE_LEAVE("thread");
@@ -3182,10 +3182,10 @@ thread_memsize(const void *ptr)
     size_t size = sizeof(rb_thread_t);
 
     if (!th->root_fiber) {
-	size += th->ec->vm_stack_size * sizeof(VALUE);
+        size += th->ec->vm_stack_size * sizeof(VALUE);
     }
     if (th->ec->local_storage) {
-	size += rb_id_table_memsize(th->ec->local_storage);
+        size += rb_id_table_memsize(th->ec->local_storage);
     }
     return size;
 }
@@ -3194,9 +3194,9 @@ thread_memsize(const void *ptr)
 const rb_data_type_t ruby_threadptr_data_type = {
     "VM/thread",
     {
-	thread_mark,
-	thread_free,
-	thread_memsize,
+        thread_mark,
+        thread_free,
+        thread_memsize,
         thread_compact,
     },
     0, 0, RUBY_TYPED_FREE_IMMEDIATELY
@@ -3315,7 +3315,7 @@ static VALUE
 m_core_set_method_alias(VALUE self, VALUE cbase, VALUE sym1, VALUE sym2)
 {
     REWIND_CFP({
-	rb_alias(cbase, SYM2ID(sym1), SYM2ID(sym2));
+        rb_alias(cbase, SYM2ID(sym1), SYM2ID(sym2));
     });
     return Qnil;
 }
@@ -3324,7 +3324,7 @@ static VALUE
 m_core_set_variable_alias(VALUE self, VALUE sym1, VALUE sym2)
 {
     REWIND_CFP({
-	rb_alias_variable(SYM2ID(sym1), SYM2ID(sym2));
+        rb_alias_variable(SYM2ID(sym1), SYM2ID(sym2));
     });
     return Qnil;
 }
@@ -3334,8 +3334,8 @@ m_core_undef_method(VALUE self, VALUE cbase, VALUE sym)
 {
     REWIND_CFP({
         ID mid = SYM2ID(sym);
-	rb_undef(cbase, mid);
-	rb_clear_method_cache(self, mid);
+        rb_undef(cbase, mid);
+        rb_clear_method_cache(self, mid);
     });
     return Qnil;
 }
@@ -3434,11 +3434,11 @@ nsdr(VALUE self)
     int i;
 
     if (syms == 0) {
-	rb_memerror();
+        rb_memerror();
     }
 
     for (i=0; i<n; i++) {
-	rb_ary_push(ary, rb_str_new2(syms[i]));
+        rb_ary_push(ary, rb_str_new2(syms[i]));
     }
     free(syms); /* OK */
 #endif
@@ -3829,37 +3829,37 @@ Init_VM(void)
 
     /* VM bootstrap: phase 2 */
     {
-	rb_vm_t *vm = ruby_current_vm_ptr;
-	rb_thread_t *th = GET_THREAD();
-	VALUE filename = rb_fstring_lit("<main>");
-	const rb_iseq_t *iseq = rb_iseq_new(0, filename, filename, Qnil, 0, ISEQ_TYPE_TOP);
+        rb_vm_t *vm = ruby_current_vm_ptr;
+        rb_thread_t *th = GET_THREAD();
+        VALUE filename = rb_fstring_lit("<main>");
+        const rb_iseq_t *iseq = rb_iseq_new(0, filename, filename, Qnil, 0, ISEQ_TYPE_TOP);
 
         // Ractor setup
         rb_ractor_main_setup(vm, th->ractor, th);
 
-	/* create vm object */
-	vm->self = TypedData_Wrap_Struct(rb_cRubyVM, &vm_data_type, vm);
+        /* create vm object */
+        vm->self = TypedData_Wrap_Struct(rb_cRubyVM, &vm_data_type, vm);
 
-	/* create main thread */
+        /* create main thread */
         th->self = TypedData_Wrap_Struct(rb_cThread, &thread_data_type, th);
-	vm->ractor.main_thread = th;
+        vm->ractor.main_thread = th;
         vm->ractor.main_ractor = th->ractor;
-	th->vm = vm;
-	th->top_wrapper = 0;
-	th->top_self = rb_vm_top_self();
+        th->vm = vm;
+        th->top_wrapper = 0;
+        th->top_self = rb_vm_top_self();
 
         rb_gc_register_mark_object((VALUE)iseq);
-	th->ec->cfp->iseq = iseq;
+        th->ec->cfp->iseq = iseq;
         th->ec->cfp->pc = ISEQ_BODY(iseq)->iseq_encoded;
-	th->ec->cfp->self = th->top_self;
+        th->ec->cfp->self = th->top_self;
 
-	VM_ENV_FLAGS_UNSET(th->ec->cfp->ep, VM_FRAME_FLAG_CFRAME);
-	VM_STACK_ENV_WRITE(th->ec->cfp->ep, VM_ENV_DATA_INDEX_ME_CREF, (VALUE)vm_cref_new(rb_cObject, METHOD_VISI_PRIVATE, FALSE, NULL, FALSE, FALSE));
+        VM_ENV_FLAGS_UNSET(th->ec->cfp->ep, VM_FRAME_FLAG_CFRAME);
+        VM_STACK_ENV_WRITE(th->ec->cfp->ep, VM_ENV_DATA_INDEX_ME_CREF, (VALUE)vm_cref_new(rb_cObject, METHOD_VISI_PRIVATE, FALSE, NULL, FALSE, FALSE));
 
-	/*
-	 * The Binding of the top level scope
-	 */
-	rb_define_global_const("TOPLEVEL_BINDING", rb_binding_new());
+        /*
+         * The Binding of the top level scope
+         */
+        rb_define_global_const("TOPLEVEL_BINDING", rb_binding_new());
 
         rb_objspace_gc_enable(vm->objspace);
     }
@@ -3894,8 +3894,8 @@ Init_BareVM(void)
     rb_vm_t * vm = ruby_mimmalloc(sizeof(*vm));
     rb_thread_t * th = ruby_mimmalloc(sizeof(*th));
     if (!vm || !th) {
-	fputs("[FATAL] failed to allocate memory\n", stderr);
-	exit(EXIT_FAILURE);
+        fputs("[FATAL] failed to allocate memory\n", stderr);
+        exit(EXIT_FAILURE);
     }
 
     // setup the VM
@@ -3982,8 +3982,8 @@ rb_ruby_debug_ptr(void)
 
 /* iseq.c */
 VALUE rb_insn_operand_intern(const rb_iseq_t *iseq,
-			     VALUE insn, int op_no, VALUE op,
-			     int len, size_t pos, VALUE *pnop, VALUE child);
+                             VALUE insn, int op_no, VALUE op,
+                             int len, size_t pos, VALUE *pnop, VALUE child);
 
 st_table *
 rb_vm_fstring_table(void)
@@ -4021,29 +4021,29 @@ vm_analysis_insn(int insn)
     CONST_ID(bigram_hash, "USAGE_ANALYSIS_INSN_BIGRAM");
     uh = rb_const_get(rb_cRubyVM, usage_hash);
     if (NIL_P(ihash = rb_hash_aref(uh, INT2FIX(insn)))) {
-	ihash = rb_hash_new();
-	HASH_ASET(uh, INT2FIX(insn), ihash);
+        ihash = rb_hash_new();
+        HASH_ASET(uh, INT2FIX(insn), ihash);
     }
     if (NIL_P(cv = rb_hash_aref(ihash, INT2FIX(-1)))) {
-	cv = INT2FIX(0);
+        cv = INT2FIX(0);
     }
     HASH_ASET(ihash, INT2FIX(-1), INT2FIX(FIX2INT(cv) + 1));
 
     /* calc bigram */
     if (prev_insn != -1) {
-	VALUE bi;
-	VALUE ary[2];
-	VALUE cv;
+        VALUE bi;
+        VALUE ary[2];
+        VALUE cv;
 
-	ary[0] = INT2FIX(prev_insn);
-	ary[1] = INT2FIX(insn);
-	bi = rb_ary_new4(2, &ary[0]);
+        ary[0] = INT2FIX(prev_insn);
+        ary[1] = INT2FIX(insn);
+        bi = rb_ary_new4(2, &ary[0]);
 
-	uh = rb_const_get(rb_cRubyVM, bigram_hash);
-	if (NIL_P(cv = rb_hash_aref(uh, bi))) {
-	    cv = INT2FIX(0);
-	}
-	HASH_ASET(uh, bi, INT2FIX(FIX2INT(cv) + 1));
+        uh = rb_const_get(rb_cRubyVM, bigram_hash);
+        if (NIL_P(cv = rb_hash_aref(uh, bi))) {
+            cv = INT2FIX(0);
+        }
+        HASH_ASET(uh, bi, INT2FIX(FIX2INT(cv) + 1));
     }
     prev_insn = insn;
 }
@@ -4063,19 +4063,19 @@ vm_analysis_operand(int insn, int n, VALUE op)
 
     uh = rb_const_get(rb_cRubyVM, usage_hash);
     if (NIL_P(ihash = rb_hash_aref(uh, INT2FIX(insn)))) {
-	ihash = rb_hash_new();
-	HASH_ASET(uh, INT2FIX(insn), ihash);
+        ihash = rb_hash_new();
+        HASH_ASET(uh, INT2FIX(insn), ihash);
     }
     if (NIL_P(ophash = rb_hash_aref(ihash, INT2FIX(n)))) {
-	ophash = rb_hash_new();
-	HASH_ASET(ihash, INT2FIX(n), ophash);
+        ophash = rb_hash_new();
+        HASH_ASET(ihash, INT2FIX(n), ophash);
     }
     /* intern */
     valstr = rb_insn_operand_intern(GET_EC()->cfp->iseq, insn, n, op, 0, 0, 0, 0);
 
     /* set count */
     if (NIL_P(cv = rb_hash_aref(ophash, valstr))) {
-	cv = INT2FIX(0);
+        cv = INT2FIX(0);
     }
     HASH_ASET(ophash, valstr, INT2FIX(FIX2INT(cv) + 1));
 }
@@ -4087,16 +4087,16 @@ vm_analysis_register(int reg, int isset)
     VALUE uh;
     VALUE valstr;
     static const char regstrs[][5] = {
-	"pc",			/* 0 */
-	"sp",			/* 1 */
-	"ep",                   /* 2 */
-	"cfp",			/* 3 */
-	"self",			/* 4 */
-	"iseq",			/* 5 */
+        "pc",			/* 0 */
+        "sp",			/* 1 */
+        "ep",                   /* 2 */
+        "cfp",			/* 3 */
+        "self",			/* 4 */
+        "iseq",			/* 5 */
     };
     static const char getsetstr[][4] = {
-	"get",
-	"set",
+        "get",
+        "set",
     };
     static VALUE syms[sizeof(regstrs) / sizeof(regstrs[0])][2];
 
@@ -4104,22 +4104,22 @@ vm_analysis_register(int reg, int isset)
 
     CONST_ID(usage_hash, "USAGE_ANALYSIS_REGS");
     if (syms[0] == 0) {
-	char buff[0x10];
-	int i;
-
-	for (i = 0; i < (int)(sizeof(regstrs) / sizeof(regstrs[0])); i++) {
-	    int j;
-	    for (j = 0; j < 2; j++) {
-		snprintf(buff, 0x10, "%d %s %-4s", i, getsetstr[j], regstrs[i]);
-		syms[i][j] = ID2SYM(rb_intern(buff));
-	    }
-	}
+        char buff[0x10];
+        int i;
+
+        for (i = 0; i < (int)(sizeof(regstrs) / sizeof(regstrs[0])); i++) {
+            int j;
+            for (j = 0; j < 2; j++) {
+                snprintf(buff, 0x10, "%d %s %-4s", i, getsetstr[j], regstrs[i]);
+                syms[i][j] = ID2SYM(rb_intern(buff));
+            }
+        }
     }
     valstr = syms[reg][isset];
 
     uh = rb_const_get(rb_cRubyVM, usage_hash);
     if (NIL_P(cv = rb_hash_aref(uh, valstr))) {
-	cv = INT2FIX(0);
+        cv = INT2FIX(0);
     }
     HASH_ASET(uh, valstr, INT2FIX(FIX2INT(cv) + 1));
 }
@@ -4260,10 +4260,10 @@ static void
 vm_collect_usage_insn(int insn)
 {
     if (RUBY_DTRACE_INSN_ENABLED()) {
-	RUBY_DTRACE_INSN(rb_insns_name(insn));
+        RUBY_DTRACE_INSN(rb_insns_name(insn));
     }
     if (ruby_vm_collect_usage_func_insn)
-	(*ruby_vm_collect_usage_func_insn)(insn);
+        (*ruby_vm_collect_usage_func_insn)(insn);
 }
 
 /* @param insn instruction number
@@ -4274,15 +4274,15 @@ static void
 vm_collect_usage_operand(int insn, int n, VALUE op)
 {
     if (RUBY_DTRACE_INSN_OPERAND_ENABLED()) {
-	VALUE valstr;
+        VALUE valstr;
 
-	valstr = rb_insn_operand_intern(GET_EC()->cfp->iseq, insn, n, op, 0, 0, 0, 0);
+        valstr = rb_insn_operand_intern(GET_EC()->cfp->iseq, insn, n, op, 0, 0, 0, 0);
 
-	RUBY_DTRACE_INSN_OPERAND(RSTRING_PTR(valstr), rb_insns_name(insn));
-	RB_GC_GUARD(valstr);
+        RUBY_DTRACE_INSN_OPERAND(RSTRING_PTR(valstr), rb_insns_name(insn));
+        RB_GC_GUARD(valstr);
     }
     if (ruby_vm_collect_usage_func_operand)
-	(*ruby_vm_collect_usage_func_operand)(insn, n, op);
+        (*ruby_vm_collect_usage_func_operand)(insn, n, op);
 }
 
 /* @param reg register id. see code of vm_analysis_register() */
@@ -4291,7 +4291,7 @@ static void
 vm_collect_usage_register(int reg, int isset)
 {
     if (ruby_vm_collect_usage_func_register)
-	(*ruby_vm_collect_usage_func_register)(reg, isset);
+        (*ruby_vm_collect_usage_func_register)(reg, isset);
 }
 #endif