Expand tabs [ci skip]

[Misc #18891]

1 files changed, 486 insertions, 486 deletions

diff --git a/vm_dump.c b/vm_dump.c
index 9c7227b3d7..607488388a 100644
--- a/vm_dump.c
+++ b/vm_dump.c
@@ -60,100 +60,100 @@ control_frame_dump(const rb_execution_context_t *ec, const rb_control_frame_t *c
     const rb_callable_method_entry_t *me = rb_vm_frame_method_entry(cfp);
 
     if (ep < 0 || (size_t)ep > ec->vm_stack_size) {
-	ep = (ptrdiff_t)cfp->ep;
-	ep_in_heap = 'p';
+        ep = (ptrdiff_t)cfp->ep;
+        ep_in_heap = 'p';
     }
 
     switch (VM_FRAME_TYPE(cfp)) {
       case VM_FRAME_MAGIC_TOP:
-	magic = "TOP";
-	break;
+        magic = "TOP";
+        break;
       case VM_FRAME_MAGIC_METHOD:
-	magic = "METHOD";
-	break;
+        magic = "METHOD";
+        break;
       case VM_FRAME_MAGIC_CLASS:
-	magic = "CLASS";
-	break;
+        magic = "CLASS";
+        break;
       case VM_FRAME_MAGIC_BLOCK:
-	magic = "BLOCK";
-	break;
+        magic = "BLOCK";
+        break;
       case VM_FRAME_MAGIC_CFUNC:
-	magic = "CFUNC";
-	break;
+        magic = "CFUNC";
+        break;
       case VM_FRAME_MAGIC_IFUNC:
-	magic = "IFUNC";
-	break;
+        magic = "IFUNC";
+        break;
       case VM_FRAME_MAGIC_EVAL:
-	magic = "EVAL";
-	break;
+        magic = "EVAL";
+        break;
       case VM_FRAME_MAGIC_RESCUE:
-	magic = "RESCUE";
-	break;
+        magic = "RESCUE";
+        break;
       case 0:
-	magic = "------";
-	break;
+        magic = "------";
+        break;
       default:
-	magic = "(none)";
-	break;
+        magic = "(none)";
+        break;
     }
 
     if (0) {
-	tmp = rb_inspect(cfp->self);
-	selfstr = StringValueCStr(tmp);
+        tmp = rb_inspect(cfp->self);
+        selfstr = StringValueCStr(tmp);
     }
     else {
-	selfstr = "";
+        selfstr = "";
     }
 
     if (cfp->iseq != 0) {
 #define RUBY_VM_IFUNC_P(ptr) IMEMO_TYPE_P(ptr, imemo_ifunc)
-	if (RUBY_VM_IFUNC_P(cfp->iseq)) {
-	    iseq_name = "<ifunc>";
-	}
+        if (RUBY_VM_IFUNC_P(cfp->iseq)) {
+            iseq_name = "<ifunc>";
+        }
         else if (SYMBOL_P((VALUE)cfp->iseq)) {
-	    tmp = rb_sym2str((VALUE)cfp->iseq);
-	    iseq_name = RSTRING_PTR(tmp);
-	    snprintf(posbuf, MAX_POSBUF, ":%s", iseq_name);
-	    line = -1;
-	}
-	else {
+            tmp = rb_sym2str((VALUE)cfp->iseq);
+            iseq_name = RSTRING_PTR(tmp);
+            snprintf(posbuf, MAX_POSBUF, ":%s", iseq_name);
+            line = -1;
+        }
+        else {
             iseq = cfp->iseq;
             pc = cfp->pc - ISEQ_BODY(iseq)->iseq_encoded;
             iseq_name = RSTRING_PTR(ISEQ_BODY(iseq)->location.label);
-	    line = rb_vm_get_sourceline(cfp);
-	    if (line) {
-		snprintf(posbuf, MAX_POSBUF, "%s:%d", RSTRING_PTR(rb_iseq_path(iseq)), line);
-	    }
-	}
+            line = rb_vm_get_sourceline(cfp);
+            if (line) {
+                snprintf(posbuf, MAX_POSBUF, "%s:%d", RSTRING_PTR(rb_iseq_path(iseq)), line);
+            }
+        }
     }
     else if (me != NULL) {
-	iseq_name = rb_id2name(me->def->original_id);
-	snprintf(posbuf, MAX_POSBUF, ":%s", iseq_name);
-	line = -1;
+        iseq_name = rb_id2name(me->def->original_id);
+        snprintf(posbuf, MAX_POSBUF, ":%s", iseq_name);
+        line = -1;
     }
 
     fprintf(stderr, "c:%04"PRIdPTRDIFF" ",
-	    ((rb_control_frame_t *)(ec->vm_stack + ec->vm_stack_size) - cfp));
+            ((rb_control_frame_t *)(ec->vm_stack + ec->vm_stack_size) - cfp));
     if (pc == -1) {
-	fprintf(stderr, "p:---- ");
+        fprintf(stderr, "p:---- ");
     }
     else {
-	fprintf(stderr, "p:%04"PRIdPTRDIFF" ", pc);
+        fprintf(stderr, "p:%04"PRIdPTRDIFF" ", pc);
     }
     fprintf(stderr, "s:%04"PRIdPTRDIFF" ", cfp->sp - ec->vm_stack);
     fprintf(stderr, ep_in_heap == ' ' ? "e:%06"PRIdPTRDIFF" " : "E:%06"PRIxPTRDIFF" ", ep % 10000);
     fprintf(stderr, "%-6s", magic);
     if (line) {
-	fprintf(stderr, " %s", posbuf);
+        fprintf(stderr, " %s", posbuf);
     }
     if (VM_FRAME_FINISHED_P(cfp)) {
-	fprintf(stderr, " [FINISH]");
+        fprintf(stderr, " [FINISH]");
     }
     if (0) {
-	fprintf(stderr, "              \t");
-	fprintf(stderr, "iseq: %-24s ", iseq_name);
-	fprintf(stderr, "self: %-24s ", selfstr);
-	fprintf(stderr, "%-1s ", biseq_name);
+        fprintf(stderr, "              \t");
+        fprintf(stderr, "iseq: %-24s ", iseq_name);
+        fprintf(stderr, "self: %-24s ", selfstr);
+        fprintf(stderr, "%-1s ", biseq_name);
     }
     fprintf(stderr, "\n");
 
@@ -201,25 +201,25 @@ rb_vmdebug_stack_dump_raw(const rb_execution_context_t *ec, const rb_control_fra
 
     fprintf(stderr, "-- stack frame ------------\n");
     for (p = st = ec->vm_stack; p < sp; p++) {
-	fprintf(stderr, "%04ld (%p): %08"PRIxVALUE, (long)(p - st), p, *p);
+        fprintf(stderr, "%04ld (%p): %08"PRIxVALUE, (long)(p - st), p, *p);
 
-	t = (VALUE *)*p;
-	if (ec->vm_stack <= t && t < sp) {
-	    fprintf(stderr, " (= %ld)", (long)((VALUE *)GC_GUARDED_PTR_REF((VALUE)t) - ec->vm_stack));
-	}
+        t = (VALUE *)*p;
+        if (ec->vm_stack <= t && t < sp) {
+            fprintf(stderr, " (= %ld)", (long)((VALUE *)GC_GUARDED_PTR_REF((VALUE)t) - ec->vm_stack));
+        }
 
-	if (p == ep)
-	    fprintf(stderr, " <- ep");
+        if (p == ep)
+            fprintf(stderr, " <- ep");
 
-	fprintf(stderr, "\n");
+        fprintf(stderr, "\n");
     }
 #endif
 
     fprintf(stderr, "-- Control frame information "
-	    "-----------------------------------------------\n");
+            "-----------------------------------------------\n");
     while ((void *)cfp < (void *)(ec->vm_stack + ec->vm_stack_size)) {
-	control_frame_dump(ec, cfp);
-	cfp++;
+        control_frame_dump(ec, cfp);
+        cfp++;
     }
     fprintf(stderr, "\n");
 }
@@ -238,14 +238,14 @@ rb_vmdebug_env_dump_raw(const rb_env_t *env, const VALUE *ep)
     fprintf(stderr, "-- env --------------------\n");
 
     while (env) {
-	fprintf(stderr, "--\n");
-	for (i = 0; i < env->env_size; i++) {
-	    fprintf(stderr, "%04d: %08"PRIxVALUE" (%p)", i, env->env[i], (void *)&env->env[i]);
-	    if (&env->env[i] == ep) fprintf(stderr, " <- ep");
-	    fprintf(stderr, "\n");
-	}
-
-	env = rb_vm_env_prev_env(env);
+        fprintf(stderr, "--\n");
+        for (i = 0; i < env->env_size; i++) {
+            fprintf(stderr, "%04d: %08"PRIxVALUE" (%p)", i, env->env[i], (void *)&env->env[i]);
+            if (&env->env[i] == ep) fprintf(stderr, " <- ep");
+            fprintf(stderr, "\n");
+        }
+
+        env = rb_vm_env_prev_env(env);
     }
     fprintf(stderr, "---------------------------\n");
 }
@@ -281,7 +281,7 @@ vm_base_ptr(const rb_control_frame_t *cfp)
     const VALUE *bp = prev_cfp->sp + ISEQ_BODY(cfp->iseq)->local_table_size + VM_ENV_DATA_SIZE;
 
     if (ISEQ_BODY(cfp->iseq)->type == ISEQ_TYPE_METHOD) {
-	bp += 1;
+        bp += 1;
     }
     return bp;
 }
@@ -295,7 +295,7 @@ vm_stack_dump_each(const rb_execution_context_t *ec, const rb_control_frame_t *c
     const VALUE *ep = cfp->ep;
 
     if (VM_FRAME_RUBYFRAME_P(cfp)) {
-	const rb_iseq_t *iseq = cfp->iseq;
+        const rb_iseq_t *iseq = cfp->iseq;
         argc = ISEQ_BODY(iseq)->param.lead_num;
         local_table_size = ISEQ_BODY(iseq)->local_table_size;
     }
@@ -303,56 +303,56 @@ vm_stack_dump_each(const rb_execution_context_t *ec, const rb_control_frame_t *c
     /* stack trace header */
 
     if (VM_FRAME_TYPE(cfp) == VM_FRAME_MAGIC_METHOD||
-	VM_FRAME_TYPE(cfp) == VM_FRAME_MAGIC_TOP   ||
-	VM_FRAME_TYPE(cfp) == VM_FRAME_MAGIC_BLOCK ||
-	VM_FRAME_TYPE(cfp) == VM_FRAME_MAGIC_CLASS ||
-	VM_FRAME_TYPE(cfp) == VM_FRAME_MAGIC_CFUNC ||
-	VM_FRAME_TYPE(cfp) == VM_FRAME_MAGIC_IFUNC ||
-	VM_FRAME_TYPE(cfp) == VM_FRAME_MAGIC_EVAL  ||
-	VM_FRAME_TYPE(cfp) == VM_FRAME_MAGIC_RESCUE)
+        VM_FRAME_TYPE(cfp) == VM_FRAME_MAGIC_TOP   ||
+        VM_FRAME_TYPE(cfp) == VM_FRAME_MAGIC_BLOCK ||
+        VM_FRAME_TYPE(cfp) == VM_FRAME_MAGIC_CLASS ||
+        VM_FRAME_TYPE(cfp) == VM_FRAME_MAGIC_CFUNC ||
+        VM_FRAME_TYPE(cfp) == VM_FRAME_MAGIC_IFUNC ||
+        VM_FRAME_TYPE(cfp) == VM_FRAME_MAGIC_EVAL  ||
+        VM_FRAME_TYPE(cfp) == VM_FRAME_MAGIC_RESCUE)
     {
-	const VALUE *ptr = ep - local_table_size;
-
-	control_frame_dump(ec, cfp);
-
-	for (i = 0; i < argc; i++) {
-	    rstr = rb_inspect(*ptr);
-	    fprintf(stderr, "  arg   %2d: %8s (%p)\n", i, StringValueCStr(rstr),
-		   (void *)ptr++);
-	}
-	for (; i < local_table_size - 1; i++) {
-	    rstr = rb_inspect(*ptr);
-	    fprintf(stderr, "  local %2d: %8s (%p)\n", i, StringValueCStr(rstr),
-		   (void *)ptr++);
-	}
-
-	ptr = vm_base_ptr(cfp);
-	for (; ptr < sp; ptr++, i++) {
-	    switch (TYPE(*ptr)) {
-	      case T_UNDEF:
-		rstr = rb_str_new2("undef");
-		break;
-	      case T_IMEMO:
-		rstr = rb_str_new2("imemo"); /* TODO: can put mode detail information */
-		break;
-	      default:
-		rstr = rb_inspect(*ptr);
-		break;
-	    }
-	    fprintf(stderr, "  stack %2d: %8s (%"PRIdPTRDIFF")\n", i, StringValueCStr(rstr),
-		    (ptr - ec->vm_stack));
-	}
+        const VALUE *ptr = ep - local_table_size;
+
+        control_frame_dump(ec, cfp);
+
+        for (i = 0; i < argc; i++) {
+            rstr = rb_inspect(*ptr);
+            fprintf(stderr, "  arg   %2d: %8s (%p)\n", i, StringValueCStr(rstr),
+                   (void *)ptr++);
+        }
+        for (; i < local_table_size - 1; i++) {
+            rstr = rb_inspect(*ptr);
+            fprintf(stderr, "  local %2d: %8s (%p)\n", i, StringValueCStr(rstr),
+                   (void *)ptr++);
+        }
+
+        ptr = vm_base_ptr(cfp);
+        for (; ptr < sp; ptr++, i++) {
+            switch (TYPE(*ptr)) {
+              case T_UNDEF:
+                rstr = rb_str_new2("undef");
+                break;
+              case T_IMEMO:
+                rstr = rb_str_new2("imemo"); /* TODO: can put mode detail information */
+                break;
+              default:
+                rstr = rb_inspect(*ptr);
+                break;
+            }
+            fprintf(stderr, "  stack %2d: %8s (%"PRIdPTRDIFF")\n", i, StringValueCStr(rstr),
+                    (ptr - ec->vm_stack));
+        }
     }
     else if (VM_FRAME_FINISHED_P(cfp)) {
-	if (ec->vm_stack + ec->vm_stack_size > (VALUE *)(cfp + 1)) {
-	    vm_stack_dump_each(ec, cfp + 1);
-	}
-	else {
-	    /* SDR(); */
-	}
+        if (ec->vm_stack + ec->vm_stack_size > (VALUE *)(cfp + 1)) {
+            vm_stack_dump_each(ec, cfp + 1);
+        }
+        else {
+            /* SDR(); */
+        }
     }
     else {
-	rb_bug("unsupported frame type: %08lx", VM_FRAME_TYPE(cfp));
+        rb_bug("unsupported frame type: %08lx", VM_FRAME_TYPE(cfp));
     }
 }
 #endif
@@ -370,12 +370,12 @@ rb_vmdebug_debug_print_register(const rb_execution_context_t *ec)
     }
 
     if (ep < 0 || (size_t)ep > ec->vm_stack_size) {
-	ep = -1;
+        ep = -1;
     }
 
     cfpi = ((rb_control_frame_t *)(ec->vm_stack + ec->vm_stack_size)) - cfp;
     fprintf(stderr, "  [PC] %04"PRIdPTRDIFF", [SP] %04"PRIdPTRDIFF", [EP] %04"PRIdPTRDIFF", [CFP] %04"PRIdPTRDIFF"\n",
-	    pc, (cfp->sp - ec->vm_stack), ep, cfpi);
+            pc, (cfp->sp - ec->vm_stack), ep, cfpi);
 }
 
 void
@@ -391,20 +391,20 @@ rb_vmdebug_debug_print_pre(const rb_execution_context_t *ec, const rb_control_fr
 
     if (iseq != 0) {
         ptrdiff_t pc = _pc - ISEQ_BODY(iseq)->iseq_encoded;
-	int i;
+        int i;
 
-	for (i=0; i<(int)VM_CFP_CNT(ec, cfp); i++) {
-	    printf(" ");
-	}
-	printf("| ");
-	if(0)printf("[%03ld] ", (long)(cfp->sp - ec->vm_stack));
+        for (i=0; i<(int)VM_CFP_CNT(ec, cfp); i++) {
+            printf(" ");
+        }
+        printf("| ");
+        if(0)printf("[%03ld] ", (long)(cfp->sp - ec->vm_stack));
 
-	/* printf("%3"PRIdPTRDIFF" ", VM_CFP_CNT(ec, cfp)); */
-	if (pc >= 0) {
-	    const VALUE *iseq_original = rb_iseq_original_iseq((rb_iseq_t *)iseq);
+        /* printf("%3"PRIdPTRDIFF" ", VM_CFP_CNT(ec, cfp)); */
+        if (pc >= 0) {
+            const VALUE *iseq_original = rb_iseq_original_iseq((rb_iseq_t *)iseq);
 
-	    rb_iseq_disasm_insn(0, iseq_original, (size_t)pc, iseq, 0);
-	}
+            rb_iseq_disasm_insn(0, iseq_original, (size_t)pc, iseq, 0);
+        }
     }
 
 #if VMDEBUG > 3
@@ -416,7 +416,7 @@ rb_vmdebug_debug_print_pre(const rb_execution_context_t *ec, const rb_control_fr
 void
 rb_vmdebug_debug_print_post(const rb_execution_context_t *ec, const rb_control_frame_t *cfp
 #if OPT_STACK_CACHING
-		 , VALUE reg_a, VALUE reg_b
+                 , VALUE reg_a, VALUE reg_b
 #endif
     )
 {
@@ -436,15 +436,15 @@ rb_vmdebug_debug_print_post(const rb_execution_context_t *ec, const rb_control_f
 
 #if OPT_STACK_CACHING
     {
-	VALUE rstr;
-	rstr = rb_inspect(reg_a);
-	fprintf(stderr, "  sc reg A: %s\n", StringValueCStr(rstr));
-	rstr = rb_inspect(reg_b);
-	fprintf(stderr, "  sc reg B: %s\n", StringValueCStr(rstr));
+        VALUE rstr;
+        rstr = rb_inspect(reg_a);
+        fprintf(stderr, "  sc reg A: %s\n", StringValueCStr(rstr));
+        rstr = rb_inspect(reg_b);
+        fprintf(stderr, "  sc reg B: %s\n", StringValueCStr(rstr));
     }
 #endif
     printf
-	("--------------------------------------------------------------\n");
+        ("--------------------------------------------------------------\n");
 #endif
 }
 
@@ -489,89 +489,89 @@ backtrace(void **trace, int size)
     unw_getcontext(&uc);
     unw_init_local(&cursor, &uc);
     while (unw_step(&cursor) > 0) {
-	unw_get_reg(&cursor, UNW_REG_IP, &ip);
-	trace[n++] = (void *)ip;
-	{
-	    char buf[256];
-	    unw_get_proc_name(&cursor, buf, 256, &ip);
-	    if (strncmp("_sigtramp", buf, sizeof("_sigtramp")) == 0) {
-		goto darwin_sigtramp;
-	    }
-	}
+        unw_get_reg(&cursor, UNW_REG_IP, &ip);
+        trace[n++] = (void *)ip;
+        {
+            char buf[256];
+            unw_get_proc_name(&cursor, buf, 256, &ip);
+            if (strncmp("_sigtramp", buf, sizeof("_sigtramp")) == 0) {
+                goto darwin_sigtramp;
+            }
+        }
     }
     return n;
 darwin_sigtramp:
     /* darwin's bundled libunwind doesn't support signal trampoline */
     {
 #if defined(__x86_64__)
-	ucontext_t *uctx;
-	char vec[1];
-	int r;
-	/* get previous frame information from %rbx at _sigtramp and set values to cursor
-	 * https://www.opensource.apple.com/source/Libc/Libc-825.25/i386/sys/_sigtramp.s
-	 * https://www.opensource.apple.com/source/libunwind/libunwind-35.1/src/unw_getcontext.s
-	 */
-	unw_get_reg(&cursor, UNW_X86_64_RBX, &ip);
-	uctx = (ucontext_t *)ip;
-	unw_set_reg(&cursor, UNW_X86_64_RAX, uctx->uc_mcontext->MCTX_SS_REG(rax));
-	unw_set_reg(&cursor, UNW_X86_64_RBX, uctx->uc_mcontext->MCTX_SS_REG(rbx));
-	unw_set_reg(&cursor, UNW_X86_64_RCX, uctx->uc_mcontext->MCTX_SS_REG(rcx));
-	unw_set_reg(&cursor, UNW_X86_64_RDX, uctx->uc_mcontext->MCTX_SS_REG(rdx));
-	unw_set_reg(&cursor, UNW_X86_64_RDI, uctx->uc_mcontext->MCTX_SS_REG(rdi));
-	unw_set_reg(&cursor, UNW_X86_64_RSI, uctx->uc_mcontext->MCTX_SS_REG(rsi));
-	unw_set_reg(&cursor, UNW_X86_64_RBP, uctx->uc_mcontext->MCTX_SS_REG(rbp));
-	unw_set_reg(&cursor, UNW_X86_64_RSP, 8+(uctx->uc_mcontext->MCTX_SS_REG(rsp)));
-	unw_set_reg(&cursor, UNW_X86_64_R8,  uctx->uc_mcontext->MCTX_SS_REG(r8));
-	unw_set_reg(&cursor, UNW_X86_64_R9,  uctx->uc_mcontext->MCTX_SS_REG(r9));
-	unw_set_reg(&cursor, UNW_X86_64_R10, uctx->uc_mcontext->MCTX_SS_REG(r10));
-	unw_set_reg(&cursor, UNW_X86_64_R11, uctx->uc_mcontext->MCTX_SS_REG(r11));
-	unw_set_reg(&cursor, UNW_X86_64_R12, uctx->uc_mcontext->MCTX_SS_REG(r12));
-	unw_set_reg(&cursor, UNW_X86_64_R13, uctx->uc_mcontext->MCTX_SS_REG(r13));
-	unw_set_reg(&cursor, UNW_X86_64_R14, uctx->uc_mcontext->MCTX_SS_REG(r14));
-	unw_set_reg(&cursor, UNW_X86_64_R15, uctx->uc_mcontext->MCTX_SS_REG(r15));
-	ip = uctx->uc_mcontext->MCTX_SS_REG(rip);
-
-	/* There are 4 cases for SEGV:
-	 * (1) called invalid address
-	 * (2) read or write invalid address
-	 * (3) received signal
-	 *
-	 * Detail:
-	 * (1) called invalid address
-	 * In this case, saved ip is invalid address.
-	 * It needs to just save the address for the information,
-	 * skip the frame, and restore the frame calling the
-	 * invalid address from %rsp.
-	 * The problem is how to check whether the ip is valid or not.
-	 * This code uses mincore(2) and assume the address's page is
-	 * incore/referenced or not reflects the problem.
-	 * Note that High Sierra's mincore(2) may return -128.
-	 * (2) read or write invalid address
-	 * saved ip is valid. just restart backtracing.
-	 * (3) received signal in user space
-	 * Same as (2).
-	 * (4) received signal in kernel
-	 * In this case saved ip points just after syscall, but registers are
-	 * already overwritten by kernel. To fix register consistency,
-	 * skip libc's kernel wrapper.
-	 * To detect this case, just previous two bytes of ip is "\x0f\x05",
-	 * syscall instruction of x86_64.
-	 */
-	r = mincore((const void *)ip, 1, vec);
-	if (r || vec[0] <= 0 || memcmp((const char *)ip-2, "\x0f\x05", 2) == 0) {
-	    /* if segv is caused by invalid call or signal received in syscall */
-	    /* the frame is invalid; skip */
-	    trace[n++] = (void *)ip;
-	    ip = *(unw_word_t*)uctx->uc_mcontext->MCTX_SS_REG(rsp);
-	}
+        ucontext_t *uctx;
+        char vec[1];
+        int r;
+        /* get previous frame information from %rbx at _sigtramp and set values to cursor
+         * https://www.opensource.apple.com/source/Libc/Libc-825.25/i386/sys/_sigtramp.s
+         * https://www.opensource.apple.com/source/libunwind/libunwind-35.1/src/unw_getcontext.s
+         */
+        unw_get_reg(&cursor, UNW_X86_64_RBX, &ip);
+        uctx = (ucontext_t *)ip;
+        unw_set_reg(&cursor, UNW_X86_64_RAX, uctx->uc_mcontext->MCTX_SS_REG(rax));
+        unw_set_reg(&cursor, UNW_X86_64_RBX, uctx->uc_mcontext->MCTX_SS_REG(rbx));
+        unw_set_reg(&cursor, UNW_X86_64_RCX, uctx->uc_mcontext->MCTX_SS_REG(rcx));
+        unw_set_reg(&cursor, UNW_X86_64_RDX, uctx->uc_mcontext->MCTX_SS_REG(rdx));
+        unw_set_reg(&cursor, UNW_X86_64_RDI, uctx->uc_mcontext->MCTX_SS_REG(rdi));
+        unw_set_reg(&cursor, UNW_X86_64_RSI, uctx->uc_mcontext->MCTX_SS_REG(rsi));
+        unw_set_reg(&cursor, UNW_X86_64_RBP, uctx->uc_mcontext->MCTX_SS_REG(rbp));
+        unw_set_reg(&cursor, UNW_X86_64_RSP, 8+(uctx->uc_mcontext->MCTX_SS_REG(rsp)));
+        unw_set_reg(&cursor, UNW_X86_64_R8,  uctx->uc_mcontext->MCTX_SS_REG(r8));
+        unw_set_reg(&cursor, UNW_X86_64_R9,  uctx->uc_mcontext->MCTX_SS_REG(r9));
+        unw_set_reg(&cursor, UNW_X86_64_R10, uctx->uc_mcontext->MCTX_SS_REG(r10));
+        unw_set_reg(&cursor, UNW_X86_64_R11, uctx->uc_mcontext->MCTX_SS_REG(r11));
+        unw_set_reg(&cursor, UNW_X86_64_R12, uctx->uc_mcontext->MCTX_SS_REG(r12));
+        unw_set_reg(&cursor, UNW_X86_64_R13, uctx->uc_mcontext->MCTX_SS_REG(r13));
+        unw_set_reg(&cursor, UNW_X86_64_R14, uctx->uc_mcontext->MCTX_SS_REG(r14));
+        unw_set_reg(&cursor, UNW_X86_64_R15, uctx->uc_mcontext->MCTX_SS_REG(r15));
+        ip = uctx->uc_mcontext->MCTX_SS_REG(rip);
+
+        /* There are 4 cases for SEGV:
+         * (1) called invalid address
+         * (2) read or write invalid address
+         * (3) received signal
+         *
+         * Detail:
+         * (1) called invalid address
+         * In this case, saved ip is invalid address.
+         * It needs to just save the address for the information,
+         * skip the frame, and restore the frame calling the
+         * invalid address from %rsp.
+         * The problem is how to check whether the ip is valid or not.
+         * This code uses mincore(2) and assume the address's page is
+         * incore/referenced or not reflects the problem.
+         * Note that High Sierra's mincore(2) may return -128.
+         * (2) read or write invalid address
+         * saved ip is valid. just restart backtracing.
+         * (3) received signal in user space
+         * Same as (2).
+         * (4) received signal in kernel
+         * In this case saved ip points just after syscall, but registers are
+         * already overwritten by kernel. To fix register consistency,
+         * skip libc's kernel wrapper.
+         * To detect this case, just previous two bytes of ip is "\x0f\x05",
+         * syscall instruction of x86_64.
+         */
+        r = mincore((const void *)ip, 1, vec);
+        if (r || vec[0] <= 0 || memcmp((const char *)ip-2, "\x0f\x05", 2) == 0) {
+            /* if segv is caused by invalid call or signal received in syscall */
+            /* the frame is invalid; skip */
+            trace[n++] = (void *)ip;
+            ip = *(unw_word_t*)uctx->uc_mcontext->MCTX_SS_REG(rsp);
+        }
 #endif
 
-	trace[n++] = (void *)ip;
-	unw_set_reg(&cursor, UNW_REG_IP, ip);
+        trace[n++] = (void *)ip;
+        unw_set_reg(&cursor, UNW_REG_IP, ip);
     }
     while (unw_step(&cursor) > 0) {
-	unw_get_reg(&cursor, UNW_REG_IP, &ip);
-	trace[n++] = (void *)ip;
+        unw_get_reg(&cursor, UNW_REG_IP, &ip);
+        trace[n++] = (void *)ip;
     }
     return n;
 }
@@ -679,75 +679,75 @@ dump_thread(void *arg)
     pSymGetLineFromAddr64 = (BOOL (WINAPI *)(HANDLE, DWORD64, DWORD *, IMAGEHLP_LINE64 *))GetProcAddress(dbghelp, "SymGetLineFromAddr64");
     pOpenThread = (HANDLE (WINAPI *)(DWORD, BOOL, DWORD))GetProcAddress(GetModuleHandle("kernel32.dll"), "OpenThread");
     if (pSymInitialize && pSymCleanup && pStackWalk64 && pSymGetModuleBase64 &&
-	pSymFromAddr && pSymGetLineFromAddr64 && pOpenThread) {
-	SymSetOptions(SYMOPT_UNDNAME | SYMOPT_DEFERRED_LOADS | SYMOPT_DEBUG | SYMOPT_LOAD_LINES);
-	ph = GetCurrentProcess();
-	pSymInitialize(ph, NULL, TRUE);
-	th = pOpenThread(THREAD_SUSPEND_RESUME|THREAD_GET_CONTEXT, FALSE, tid);
-	if (th) {
-	    if (SuspendThread(th) != (DWORD)-1) {
-		CONTEXT context;
-		memset(&context, 0, sizeof(context));
-		context.ContextFlags = CONTEXT_FULL;
-		if (GetThreadContext(th, &context)) {
-		    char libpath[MAX_PATH];
-		    char buf[sizeof(SYMBOL_INFO) + MAX_SYM_NAME];
-		    SYMBOL_INFO *info = (SYMBOL_INFO *)buf;
-		    DWORD mac;
-		    STACKFRAME64 frame;
-		    memset(&frame, 0, sizeof(frame));
+        pSymFromAddr && pSymGetLineFromAddr64 && pOpenThread) {
+        SymSetOptions(SYMOPT_UNDNAME | SYMOPT_DEFERRED_LOADS | SYMOPT_DEBUG | SYMOPT_LOAD_LINES);
+        ph = GetCurrentProcess();
+        pSymInitialize(ph, NULL, TRUE);
+        th = pOpenThread(THREAD_SUSPEND_RESUME|THREAD_GET_CONTEXT, FALSE, tid);
+        if (th) {
+            if (SuspendThread(th) != (DWORD)-1) {
+                CONTEXT context;
+                memset(&context, 0, sizeof(context));
+                context.ContextFlags = CONTEXT_FULL;
+                if (GetThreadContext(th, &context)) {
+                    char libpath[MAX_PATH];
+                    char buf[sizeof(SYMBOL_INFO) + MAX_SYM_NAME];
+                    SYMBOL_INFO *info = (SYMBOL_INFO *)buf;
+                    DWORD mac;
+                    STACKFRAME64 frame;
+                    memset(&frame, 0, sizeof(frame));
 #if defined(_M_AMD64) || defined(__x86_64__)
-		    mac = IMAGE_FILE_MACHINE_AMD64;
-		    frame.AddrPC.Mode = AddrModeFlat;
-		    frame.AddrPC.Offset = context.Rip;
-		    frame.AddrFrame.Mode = AddrModeFlat;
-		    frame.AddrFrame.Offset = context.Rbp;
-		    frame.AddrStack.Mode = AddrModeFlat;
-		    frame.AddrStack.Offset = context.Rsp;
+                    mac = IMAGE_FILE_MACHINE_AMD64;
+                    frame.AddrPC.Mode = AddrModeFlat;
+                    frame.AddrPC.Offset = context.Rip;
+                    frame.AddrFrame.Mode = AddrModeFlat;
+                    frame.AddrFrame.Offset = context.Rbp;
+                    frame.AddrStack.Mode = AddrModeFlat;
+                    frame.AddrStack.Offset = context.Rsp;
 #else	/* i386 */
-		    mac = IMAGE_FILE_MACHINE_I386;
-		    frame.AddrPC.Mode = AddrModeFlat;
-		    frame.AddrPC.Offset = context.Eip;
-		    frame.AddrFrame.Mode = AddrModeFlat;
-		    frame.AddrFrame.Offset = context.Ebp;
-		    frame.AddrStack.Mode = AddrModeFlat;
-		    frame.AddrStack.Offset = context.Esp;
+                    mac = IMAGE_FILE_MACHINE_I386;
+                    frame.AddrPC.Mode = AddrModeFlat;
+                    frame.AddrPC.Offset = context.Eip;
+                    frame.AddrFrame.Mode = AddrModeFlat;
+                    frame.AddrFrame.Offset = context.Ebp;
+                    frame.AddrStack.Mode = AddrModeFlat;
+                    frame.AddrStack.Offset = context.Esp;
 #endif
 
-		    while (pStackWalk64(mac, ph, th, &frame, &context, NULL,
-					NULL, NULL, NULL)) {
-			DWORD64 addr = frame.AddrPC.Offset;
-			IMAGEHLP_LINE64 line;
-			DWORD64 displacement;
-			DWORD tmp;
-
-			if (addr == frame.AddrReturn.Offset || addr == 0 ||
-			    frame.AddrReturn.Offset == 0)
-			    break;
-
-			memset(buf, 0, sizeof(buf));
-			info->SizeOfStruct = sizeof(SYMBOL_INFO);
-			info->MaxNameLen = MAX_SYM_NAME;
-			if (pSymFromAddr(ph, addr, &displacement, info)) {
-			    if (GetModuleFileName((HANDLE)(uintptr_t)pSymGetModuleBase64(ph, addr), libpath, sizeof(libpath)))
-				fprintf(stderr, "%s", libpath);
-			    fprintf(stderr, "(%s+0x%"PRI_64_PREFIX"x)",
-				    info->Name, displacement);
-			}
-			fprintf(stderr, " [0x%p]", (void *)(VALUE)addr);
-			memset(&line, 0, sizeof(line));
-			line.SizeOfStruct = sizeof(line);
-			if (pSymGetLineFromAddr64(ph, addr, &tmp, &line))
-			    fprintf(stderr, " %s:%lu", line.FileName, line.LineNumber);
-			fprintf(stderr, "\n");
-		    }
-		}
-
-		ResumeThread(th);
-	    }
-	    CloseHandle(th);
-	}
-	pSymCleanup(ph);
+                    while (pStackWalk64(mac, ph, th, &frame, &context, NULL,
+                                        NULL, NULL, NULL)) {
+                        DWORD64 addr = frame.AddrPC.Offset;
+                        IMAGEHLP_LINE64 line;
+                        DWORD64 displacement;
+                        DWORD tmp;
+
+                        if (addr == frame.AddrReturn.Offset || addr == 0 ||
+                            frame.AddrReturn.Offset == 0)
+                            break;
+
+                        memset(buf, 0, sizeof(buf));
+                        info->SizeOfStruct = sizeof(SYMBOL_INFO);
+                        info->MaxNameLen = MAX_SYM_NAME;
+                        if (pSymFromAddr(ph, addr, &displacement, info)) {
+                            if (GetModuleFileName((HANDLE)(uintptr_t)pSymGetModuleBase64(ph, addr), libpath, sizeof(libpath)))
+                                fprintf(stderr, "%s", libpath);
+                            fprintf(stderr, "(%s+0x%"PRI_64_PREFIX"x)",
+                                    info->Name, displacement);
+                        }
+                        fprintf(stderr, " [0x%p]", (void *)(VALUE)addr);
+                        memset(&line, 0, sizeof(line));
+                        line.SizeOfStruct = sizeof(line);
+                        if (pSymGetLineFromAddr64(ph, addr, &tmp, &line))
+                            fprintf(stderr, " %s:%lu", line.FileName, line.LineNumber);
+                        fprintf(stderr, "\n");
+                    }
+                }
+
+                ResumeThread(th);
+            }
+            CloseHandle(th);
+        }
+        pSymCleanup(ph);
     }
     FreeLibrary(dbghelp);
 }
@@ -765,18 +765,18 @@ rb_print_backtrace(void)
 #else
     char **syms = backtrace_symbols(trace, n);
     if (syms) {
-	int i;
-	for (i=0; i<n; i++) {
-	    fprintf(stderr, "%s\n", syms[i]);
-	}
-	free(syms);
+        int i;
+        for (i=0; i<n; i++) {
+            fprintf(stderr, "%s\n", syms[i]);
+        }
+        free(syms);
     }
 #endif
 #elif defined(_WIN32)
     DWORD tid = GetCurrentThreadId();
     HANDLE th = (HANDLE)_beginthread(dump_thread, 0, &tid);
     if (th != (HANDLE)-1)
-	WaitForSingleObject(th, INFINITE);
+        WaitForSingleObject(th, INFINITE);
 #endif
 }
 
@@ -804,8 +804,8 @@ print_machine_register(size_t reg, const char *reg_name, int col_count, int max_
 
     ret = snprintf(buf, sizeof(buf), " %3.3s: 0x%.*" PRIxSIZE, reg_name, size_width, reg);
     if (col_count + ret > max_col) {
-	fputs("\n", stderr);
-	col_count = 0;
+        fputs("\n", stderr);
+        col_count = 0;
     }
     col_count += ret;
     fputs(buf, stderr);
@@ -832,173 +832,173 @@ rb_dump_machine_register(const ucontext_t *ctx)
     if (!ctx) return;
 
     fprintf(stderr, "-- Machine register context "
-	    "------------------------------------------------\n");
+            "------------------------------------------------\n");
 
 # if defined __linux__
     {
-	const mcontext_t *const mctx = &ctx->uc_mcontext;
+        const mcontext_t *const mctx = &ctx->uc_mcontext;
 #   if defined __x86_64__
-	dump_machine_register(RIP);
-	dump_machine_register(RBP);
-	dump_machine_register(RSP);
-	dump_machine_register(RAX);
-	dump_machine_register(RBX);
-	dump_machine_register(RCX);
-	dump_machine_register(RDX);
-	dump_machine_register(RDI);
-	dump_machine_register(RSI);
-	dump_machine_register(R8);
-	dump_machine_register(R9);
-	dump_machine_register(R10);
-	dump_machine_register(R11);
-	dump_machine_register(R12);
-	dump_machine_register(R13);
-	dump_machine_register(R14);
-	dump_machine_register(R15);
-	dump_machine_register(EFL);
+        dump_machine_register(RIP);
+        dump_machine_register(RBP);
+        dump_machine_register(RSP);
+        dump_machine_register(RAX);
+        dump_machine_register(RBX);
+        dump_machine_register(RCX);
+        dump_machine_register(RDX);
+        dump_machine_register(RDI);
+        dump_machine_register(RSI);
+        dump_machine_register(R8);
+        dump_machine_register(R9);
+        dump_machine_register(R10);
+        dump_machine_register(R11);
+        dump_machine_register(R12);
+        dump_machine_register(R13);
+        dump_machine_register(R14);
+        dump_machine_register(R15);
+        dump_machine_register(EFL);
 #   elif defined __i386__
-	dump_machine_register(GS);
-	dump_machine_register(FS);
-	dump_machine_register(ES);
-	dump_machine_register(DS);
-	dump_machine_register(EDI);
-	dump_machine_register(ESI);
-	dump_machine_register(EBP);
-	dump_machine_register(ESP);
-	dump_machine_register(EBX);
-	dump_machine_register(EDX);
-	dump_machine_register(ECX);
-	dump_machine_register(EAX);
-	dump_machine_register(TRAPNO);
-	dump_machine_register(ERR);
-	dump_machine_register(EIP);
-	dump_machine_register(CS);
-	dump_machine_register(EFL);
-	dump_machine_register(UESP);
-	dump_machine_register(SS);
+        dump_machine_register(GS);
+        dump_machine_register(FS);
+        dump_machine_register(ES);
+        dump_machine_register(DS);
+        dump_machine_register(EDI);
+        dump_machine_register(ESI);
+        dump_machine_register(EBP);
+        dump_machine_register(ESP);
+        dump_machine_register(EBX);
+        dump_machine_register(EDX);
+        dump_machine_register(ECX);
+        dump_machine_register(EAX);
+        dump_machine_register(TRAPNO);
+        dump_machine_register(ERR);
+        dump_machine_register(EIP);
+        dump_machine_register(CS);
+        dump_machine_register(EFL);
+        dump_machine_register(UESP);
+        dump_machine_register(SS);
 #   elif defined __aarch64__
-	dump_machine_register(mctx->regs[0], "x0");
-	dump_machine_register(mctx->regs[1], "x1");
-	dump_machine_register(mctx->regs[2], "x2");
-	dump_machine_register(mctx->regs[3], "x3");
-	dump_machine_register(mctx->regs[4], "x4");
-	dump_machine_register(mctx->regs[5], "x5");
-	dump_machine_register(mctx->regs[6], "x6");
-	dump_machine_register(mctx->regs[7], "x7");
-	dump_machine_register(mctx->regs[18], "x18");
-	dump_machine_register(mctx->regs[19], "x19");
-	dump_machine_register(mctx->regs[20], "x20");
-	dump_machine_register(mctx->regs[21], "x21");
-	dump_machine_register(mctx->regs[22], "x22");
-	dump_machine_register(mctx->regs[23], "x23");
-	dump_machine_register(mctx->regs[24], "x24");
-	dump_machine_register(mctx->regs[25], "x25");
-	dump_machine_register(mctx->regs[26], "x26");
-	dump_machine_register(mctx->regs[27], "x27");
-	dump_machine_register(mctx->regs[28], "x28");
-	dump_machine_register(mctx->regs[29], "x29");
-	dump_machine_register(mctx->sp, "sp");
-	dump_machine_register(mctx->fault_address, "fault_address");
+        dump_machine_register(mctx->regs[0], "x0");
+        dump_machine_register(mctx->regs[1], "x1");
+        dump_machine_register(mctx->regs[2], "x2");
+        dump_machine_register(mctx->regs[3], "x3");
+        dump_machine_register(mctx->regs[4], "x4");
+        dump_machine_register(mctx->regs[5], "x5");
+        dump_machine_register(mctx->regs[6], "x6");
+        dump_machine_register(mctx->regs[7], "x7");
+        dump_machine_register(mctx->regs[18], "x18");
+        dump_machine_register(mctx->regs[19], "x19");
+        dump_machine_register(mctx->regs[20], "x20");
+        dump_machine_register(mctx->regs[21], "x21");
+        dump_machine_register(mctx->regs[22], "x22");
+        dump_machine_register(mctx->regs[23], "x23");
+        dump_machine_register(mctx->regs[24], "x24");
+        dump_machine_register(mctx->regs[25], "x25");
+        dump_machine_register(mctx->regs[26], "x26");
+        dump_machine_register(mctx->regs[27], "x27");
+        dump_machine_register(mctx->regs[28], "x28");
+        dump_machine_register(mctx->regs[29], "x29");
+        dump_machine_register(mctx->sp, "sp");
+        dump_machine_register(mctx->fault_address, "fault_address");
 #   elif defined __arm__
-	dump_machine_register(mctx->arm_r0, "r0");
-	dump_machine_register(mctx->arm_r1, "r1");
-	dump_machine_register(mctx->arm_r2, "r2");
-	dump_machine_register(mctx->arm_r3, "r3");
-	dump_machine_register(mctx->arm_r4, "r4");
-	dump_machine_register(mctx->arm_r5, "r5");
-	dump_machine_register(mctx->arm_r6, "r6");
-	dump_machine_register(mctx->arm_r7, "r7");
-	dump_machine_register(mctx->arm_r8, "r8");
-	dump_machine_register(mctx->arm_r9, "r9");
-	dump_machine_register(mctx->arm_r10, "r10");
-	dump_machine_register(mctx->arm_sp, "sp");
-	dump_machine_register(mctx->fault_address, "fault_address");
+        dump_machine_register(mctx->arm_r0, "r0");
+        dump_machine_register(mctx->arm_r1, "r1");
+        dump_machine_register(mctx->arm_r2, "r2");
+        dump_machine_register(mctx->arm_r3, "r3");
+        dump_machine_register(mctx->arm_r4, "r4");
+        dump_machine_register(mctx->arm_r5, "r5");
+        dump_machine_register(mctx->arm_r6, "r6");
+        dump_machine_register(mctx->arm_r7, "r7");
+        dump_machine_register(mctx->arm_r8, "r8");
+        dump_machine_register(mctx->arm_r9, "r9");
+        dump_machine_register(mctx->arm_r10, "r10");
+        dump_machine_register(mctx->arm_sp, "sp");
+        dump_machine_register(mctx->fault_address, "fault_address");
 #   elif defined __riscv
-	dump_machine_register(mctx->__gregs[REG_SP], "sp");
-	dump_machine_register(mctx->__gregs[REG_S0], "s0");
-	dump_machine_register(mctx->__gregs[REG_S1], "s1");
-	dump_machine_register(mctx->__gregs[REG_A0], "a0");
-	dump_machine_register(mctx->__gregs[REG_A0+1], "a1");
-	dump_machine_register(mctx->__gregs[REG_A0+2], "a2");
-	dump_machine_register(mctx->__gregs[REG_A0+3], "a3");
-	dump_machine_register(mctx->__gregs[REG_A0+4], "a4");
-	dump_machine_register(mctx->__gregs[REG_A0+5], "a5");
-	dump_machine_register(mctx->__gregs[REG_A0+6], "a6");
-	dump_machine_register(mctx->__gregs[REG_A0+7], "a7");
-	dump_machine_register(mctx->__gregs[REG_S2], "s2");
-	dump_machine_register(mctx->__gregs[REG_S2+1], "s3");
-	dump_machine_register(mctx->__gregs[REG_S2+2], "s4");
-	dump_machine_register(mctx->__gregs[REG_S2+3], "s5");
-	dump_machine_register(mctx->__gregs[REG_S2+4], "s6");
-	dump_machine_register(mctx->__gregs[REG_S2+5], "s7");
-	dump_machine_register(mctx->__gregs[REG_S2+6], "s8");
-	dump_machine_register(mctx->__gregs[REG_S2+7], "s9");
-	dump_machine_register(mctx->__gregs[REG_S2+8], "s10");
-	dump_machine_register(mctx->__gregs[REG_S2+9], "s11");
+        dump_machine_register(mctx->__gregs[REG_SP], "sp");
+        dump_machine_register(mctx->__gregs[REG_S0], "s0");
+        dump_machine_register(mctx->__gregs[REG_S1], "s1");
+        dump_machine_register(mctx->__gregs[REG_A0], "a0");
+        dump_machine_register(mctx->__gregs[REG_A0+1], "a1");
+        dump_machine_register(mctx->__gregs[REG_A0+2], "a2");
+        dump_machine_register(mctx->__gregs[REG_A0+3], "a3");
+        dump_machine_register(mctx->__gregs[REG_A0+4], "a4");
+        dump_machine_register(mctx->__gregs[REG_A0+5], "a5");
+        dump_machine_register(mctx->__gregs[REG_A0+6], "a6");
+        dump_machine_register(mctx->__gregs[REG_A0+7], "a7");
+        dump_machine_register(mctx->__gregs[REG_S2], "s2");
+        dump_machine_register(mctx->__gregs[REG_S2+1], "s3");
+        dump_machine_register(mctx->__gregs[REG_S2+2], "s4");
+        dump_machine_register(mctx->__gregs[REG_S2+3], "s5");
+        dump_machine_register(mctx->__gregs[REG_S2+4], "s6");
+        dump_machine_register(mctx->__gregs[REG_S2+5], "s7");
+        dump_machine_register(mctx->__gregs[REG_S2+6], "s8");
+        dump_machine_register(mctx->__gregs[REG_S2+7], "s9");
+        dump_machine_register(mctx->__gregs[REG_S2+8], "s10");
+        dump_machine_register(mctx->__gregs[REG_S2+9], "s11");
 #   endif
     }
 # elif defined __APPLE__
     {
-	const mcontext_t mctx = ctx->uc_mcontext;
+        const mcontext_t mctx = ctx->uc_mcontext;
 #   if defined __x86_64__
-	dump_machine_register(rax);
-	dump_machine_register(rbx);
-	dump_machine_register(rcx);
-	dump_machine_register(rdx);
-	dump_machine_register(rdi);
-	dump_machine_register(rsi);
-	dump_machine_register(rbp);
-	dump_machine_register(rsp);
-	dump_machine_register(r8);
-	dump_machine_register(r9);
-	dump_machine_register(r10);
-	dump_machine_register(r11);
-	dump_machine_register(r12);
-	dump_machine_register(r13);
-	dump_machine_register(r14);
-	dump_machine_register(r15);
-	dump_machine_register(rip);
-	dump_machine_register(rflags);
+        dump_machine_register(rax);
+        dump_machine_register(rbx);
+        dump_machine_register(rcx);
+        dump_machine_register(rdx);
+        dump_machine_register(rdi);
+        dump_machine_register(rsi);
+        dump_machine_register(rbp);
+        dump_machine_register(rsp);
+        dump_machine_register(r8);
+        dump_machine_register(r9);
+        dump_machine_register(r10);
+        dump_machine_register(r11);
+        dump_machine_register(r12);
+        dump_machine_register(r13);
+        dump_machine_register(r14);
+        dump_machine_register(r15);
+        dump_machine_register(rip);
+        dump_machine_register(rflags);
 #   elif defined __i386__
-	dump_machine_register(eax);
-	dump_machine_register(ebx);
-	dump_machine_register(ecx);
-	dump_machine_register(edx);
-	dump_machine_register(edi);
-	dump_machine_register(esi);
-	dump_machine_register(ebp);
-	dump_machine_register(esp);
-	dump_machine_register(ss);
-	dump_machine_register(eflags);
-	dump_machine_register(eip);
-	dump_machine_register(cs);
-	dump_machine_register(ds);
-	dump_machine_register(es);
-	dump_machine_register(fs);
-	dump_machine_register(gs);
+        dump_machine_register(eax);
+        dump_machine_register(ebx);
+        dump_machine_register(ecx);
+        dump_machine_register(edx);
+        dump_machine_register(edi);
+        dump_machine_register(esi);
+        dump_machine_register(ebp);
+        dump_machine_register(esp);
+        dump_machine_register(ss);
+        dump_machine_register(eflags);
+        dump_machine_register(eip);
+        dump_machine_register(cs);
+        dump_machine_register(ds);
+        dump_machine_register(es);
+        dump_machine_register(fs);
+        dump_machine_register(gs);
 #   elif defined __aarch64__
-	dump_machine_register(x[0], "x0");
-	dump_machine_register(x[1], "x1");
-	dump_machine_register(x[2], "x2");
-	dump_machine_register(x[3], "x3");
-	dump_machine_register(x[4], "x4");
-	dump_machine_register(x[5], "x5");
-	dump_machine_register(x[6], "x6");
-	dump_machine_register(x[7], "x7");
-	dump_machine_register(x[18], "x18");
-	dump_machine_register(x[19], "x19");
-	dump_machine_register(x[20], "x20");
-	dump_machine_register(x[21], "x21");
-	dump_machine_register(x[22], "x22");
-	dump_machine_register(x[23], "x23");
-	dump_machine_register(x[24], "x24");
-	dump_machine_register(x[25], "x25");
-	dump_machine_register(x[26], "x26");
-	dump_machine_register(x[27], "x27");
-	dump_machine_register(x[28], "x28");
-	dump_machine_register(lr, "lr");
-	dump_machine_register(fp, "fp");
-	dump_machine_register(sp, "sp");
+        dump_machine_register(x[0], "x0");
+        dump_machine_register(x[1], "x1");
+        dump_machine_register(x[2], "x2");
+        dump_machine_register(x[3], "x3");
+        dump_machine_register(x[4], "x4");
+        dump_machine_register(x[5], "x5");
+        dump_machine_register(x[6], "x6");
+        dump_machine_register(x[7], "x7");
+        dump_machine_register(x[18], "x18");
+        dump_machine_register(x[19], "x19");
+        dump_machine_register(x[20], "x20");
+        dump_machine_register(x[21], "x21");
+        dump_machine_register(x[22], "x22");
+        dump_machine_register(x[23], "x23");
+        dump_machine_register(x[24], "x24");
+        dump_machine_register(x[25], "x25");
+        dump_machine_register(x[26], "x26");
+        dump_machine_register(x[27], "x27");
+        dump_machine_register(x[28], "x28");
+        dump_machine_register(lr, "lr");
+        dump_machine_register(fp, "fp");
+        dump_machine_register(sp, "sp");
 #   endif
     }
 # endif
@@ -1044,16 +1044,16 @@ rb_vm_bugreport(const void *ctx)
     const rb_execution_context_t *ec = rb_current_execution_context(false);
 
     if (vm && ec) {
-	SDR();
-	rb_backtrace_print_as_bugreport();
-	fputs("\n", stderr);
+        SDR();
+        rb_backtrace_print_as_bugreport();
+        fputs("\n", stderr);
     }
 
     rb_dump_machine_register(ctx);
 
 #if USE_BACKTRACE || defined(_WIN32)
     fprintf(stderr, "-- C level backtrace information "
-	    "-------------------------------------------\n");
+            "-------------------------------------------\n");
     rb_print_backtrace();
 
 
@@ -1061,22 +1061,22 @@ rb_vm_bugreport(const void *ctx)
 #endif /* USE_BACKTRACE */
 
     if (other_runtime_info || vm) {
-	fprintf(stderr, "-- Other runtime information "
-		"-----------------------------------------------\n\n");
+        fprintf(stderr, "-- Other runtime information "
+                "-----------------------------------------------\n\n");
     }
     if (vm && !rb_during_gc()) {
-	int i;
-	VALUE name;
-	long len;
-	const int max_name_length = 1024;
+        int i;
+        VALUE name;
+        long len;
+        const int max_name_length = 1024;
 # define LIMITED_NAME_LENGTH(s) \
-	(((len = RSTRING_LEN(s)) > max_name_length) ? max_name_length : (int)len)
+        (((len = RSTRING_LEN(s)) > max_name_length) ? max_name_length : (int)len)
 
-	name = vm->progname;
+        name = vm->progname;
         if (name) {
-	    fprintf(stderr, "* Loaded script: %.*s\n",
-		    LIMITED_NAME_LENGTH(name), RSTRING_PTR(name));
-	    fprintf(stderr, "\n");
+            fprintf(stderr, "* Loaded script: %.*s\n",
+                    LIMITED_NAME_LENGTH(name), RSTRING_PTR(name));
+            fprintf(stderr, "\n");
         }
         if (vm->loaded_features) {
             fprintf(stderr, "* Loaded features:\n\n");
@@ -1110,47 +1110,47 @@ rb_vm_bugreport(const void *ctx)
                 }
             }
         }
-	fprintf(stderr, "\n");
+        fprintf(stderr, "\n");
     }
 
     {
 #ifdef PROC_MAPS_NAME
-	{
-	    FILE *fp = fopen(PROC_MAPS_NAME, "r");
-	    if (fp) {
-		fprintf(stderr, "* Process memory map:\n\n");
-
-		while (!feof(fp)) {
-		    char buff[0x100];
-		    size_t rn = fread(buff, 1, 0x100, fp);
-		    if (fwrite(buff, 1, rn, stderr) != rn)
-			break;
-		}
-
-		fclose(fp);
-		fprintf(stderr, "\n\n");
-	    }
-	}
+        {
+            FILE *fp = fopen(PROC_MAPS_NAME, "r");
+            if (fp) {
+                fprintf(stderr, "* Process memory map:\n\n");
+
+                while (!feof(fp)) {
+                    char buff[0x100];
+                    size_t rn = fread(buff, 1, 0x100, fp);
+                    if (fwrite(buff, 1, rn, stderr) != rn)
+                        break;
+                }
+
+                fclose(fp);
+                fprintf(stderr, "\n\n");
+            }
+        }
 #endif /* __linux__ */
 #ifdef HAVE_LIBPROCSTAT
 # define MIB_KERN_PROC_PID_LEN 4
-	int mib[MIB_KERN_PROC_PID_LEN];
-	struct kinfo_proc kp;
-	size_t len = sizeof(struct kinfo_proc);
-	mib[0] = CTL_KERN;
-	mib[1] = KERN_PROC;
-	mib[2] = KERN_PROC_PID;
-	mib[3] = getpid();
-	if (sysctl(mib, MIB_KERN_PROC_PID_LEN, &kp, &len, NULL, 0) == -1) {
-	    perror("sysctl");
-	}
-	else {
-	    struct procstat *prstat = procstat_open_sysctl();
-	    fprintf(stderr, "* Process memory map:\n\n");
-	    procstat_vm(prstat, &kp);
-	    procstat_close(prstat);
-	    fprintf(stderr, "\n");
-	}
+        int mib[MIB_KERN_PROC_PID_LEN];
+        struct kinfo_proc kp;
+        size_t len = sizeof(struct kinfo_proc);
+        mib[0] = CTL_KERN;
+        mib[1] = KERN_PROC;
+        mib[2] = KERN_PROC_PID;
+        mib[3] = getpid();
+        if (sysctl(mib, MIB_KERN_PROC_PID_LEN, &kp, &len, NULL, 0) == -1) {
+            perror("sysctl");
+        }
+        else {
+            struct procstat *prstat = procstat_open_sysctl();
+            fprintf(stderr, "* Process memory map:\n\n");
+            procstat_vm(prstat, &kp);
+            procstat_close(prstat);
+            fprintf(stderr, "\n");
+        }
 #endif /* __FreeBSD__ */
 #ifdef __APPLE__
         vm_address_t addr = 0;
@@ -1200,10 +1200,10 @@ rb_vmdebug_stack_dump_all_threads(void)
     // TODO: now it only shows current ractor
     ccan_list_for_each(&r->threads.set, th, lt_node) {
 #ifdef NON_SCALAR_THREAD_ID
-	fprintf(stderr, "th: %p, native_id: N/A\n", th);
+        fprintf(stderr, "th: %p, native_id: N/A\n", th);
 #else
         fprintf(stderr, "th: %p, native_id: %p\n", (void *)th, (void *)(uintptr_t)th->nt->thread_id);
 #endif
-	rb_vmdebug_stack_dump_raw(th->ec, th->ec->cfp);
+        rb_vmdebug_stack_dump_raw(th->ec, th->ec->cfp);
     }
 }