00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012 #include "ruby/ruby.h"
00013 #include "addr2line.h"
00014 #include "vm_core.h"
00015 #include "internal.h"
00016
00017
00018 #ifndef VMDEBUG
00019 #define VMDEBUG 0
00020 #endif
00021
00022 #define MAX_POSBUF 128
00023
00024 #define VM_CFP_CNT(th, cfp) \
00025 ((rb_control_frame_t *)((th)->stack + (th)->stack_size) - (rb_control_frame_t *)(cfp))
00026
00027 static void
00028 control_frame_dump(rb_thread_t *th, rb_control_frame_t *cfp)
00029 {
00030 ptrdiff_t pc = -1;
00031 ptrdiff_t ep = cfp->ep - th->stack;
00032 char ep_in_heap = ' ';
00033 char posbuf[MAX_POSBUF+1];
00034 int line = 0;
00035
00036 const char *magic, *iseq_name = "-", *selfstr = "-", *biseq_name = "-";
00037 VALUE tmp;
00038
00039 if (cfp->block_iseq != 0 && BUILTIN_TYPE(cfp->block_iseq) != T_NODE) {
00040 biseq_name = "";
00041 }
00042
00043 if (ep < 0 || (size_t)ep > th->stack_size) {
00044 ep = (ptrdiff_t)cfp->ep;
00045 ep_in_heap = 'p';
00046 }
00047
00048 switch (VM_FRAME_TYPE(cfp)) {
00049 case VM_FRAME_MAGIC_TOP:
00050 magic = "TOP";
00051 break;
00052 case VM_FRAME_MAGIC_METHOD:
00053 magic = "METHOD";
00054 break;
00055 case VM_FRAME_MAGIC_CLASS:
00056 magic = "CLASS";
00057 break;
00058 case VM_FRAME_MAGIC_BLOCK:
00059 magic = "BLOCK";
00060 break;
00061 case VM_FRAME_MAGIC_CFUNC:
00062 magic = "CFUNC";
00063 break;
00064 case VM_FRAME_MAGIC_PROC:
00065 magic = "PROC";
00066 break;
00067 case VM_FRAME_MAGIC_LAMBDA:
00068 magic = "LAMBDA";
00069 break;
00070 case VM_FRAME_MAGIC_IFUNC:
00071 magic = "IFUNC";
00072 break;
00073 case VM_FRAME_MAGIC_EVAL:
00074 magic = "EVAL";
00075 break;
00076 case VM_FRAME_MAGIC_RESCUE:
00077 magic = "RESCUE";
00078 break;
00079 case 0:
00080 magic = "------";
00081 break;
00082 default:
00083 magic = "(none)";
00084 break;
00085 }
00086
00087 if (0) {
00088 tmp = rb_inspect(cfp->self);
00089 selfstr = StringValueCStr(tmp);
00090 }
00091 else {
00092 selfstr = "";
00093 }
00094
00095 if (cfp->iseq != 0) {
00096 if (RUBY_VM_IFUNC_P(cfp->iseq)) {
00097 iseq_name = "<ifunc>";
00098 }
00099 else {
00100 pc = cfp->pc - cfp->iseq->iseq_encoded;
00101 iseq_name = RSTRING_PTR(cfp->iseq->location.label);
00102 line = rb_vm_get_sourceline(cfp);
00103 if (line) {
00104 snprintf(posbuf, MAX_POSBUF, "%s:%d", RSTRING_PTR(cfp->iseq->location.path), line);
00105 }
00106 }
00107 }
00108 else if (cfp->me) {
00109 iseq_name = rb_id2name(cfp->me->def->original_id);
00110 snprintf(posbuf, MAX_POSBUF, ":%s", iseq_name);
00111 line = -1;
00112 }
00113
00114 fprintf(stderr, "c:%04"PRIdPTRDIFF" ",
00115 ((rb_control_frame_t *)(th->stack + th->stack_size) - cfp));
00116 if (pc == -1) {
00117 fprintf(stderr, "p:---- ");
00118 }
00119 else {
00120 fprintf(stderr, "p:%04"PRIdPTRDIFF" ", pc);
00121 }
00122 fprintf(stderr, "s:%04"PRIdPTRDIFF" ", cfp->sp - th->stack);
00123 fprintf(stderr, ep_in_heap == ' ' ? "e:%06"PRIdPTRDIFF" " : "E:%06"PRIxPTRDIFF" ", ep % 10000);
00124 fprintf(stderr, "%-6s", magic);
00125 if (line) {
00126 fprintf(stderr, " %s", posbuf);
00127 }
00128 if (VM_FRAME_TYPE_FINISH_P(cfp)) {
00129 fprintf(stderr, " [FINISH]");
00130 }
00131 if (0) {
00132 fprintf(stderr, " \t");
00133 fprintf(stderr, "iseq: %-24s ", iseq_name);
00134 fprintf(stderr, "self: %-24s ", selfstr);
00135 fprintf(stderr, "%-1s ", biseq_name);
00136 }
00137 fprintf(stderr, "\n");
00138 }
00139
00140 void
00141 rb_vmdebug_stack_dump_raw(rb_thread_t *th, rb_control_frame_t *cfp)
00142 {
00143 #if 0
00144 VALUE *sp = cfp->sp, *ep = cfp->ep;
00145 VALUE *p, *st, *t;
00146
00147 fprintf(stderr, "-- stack frame ------------\n");
00148 for (p = st = th->stack; p < sp; p++) {
00149 fprintf(stderr, "%04ld (%p): %08"PRIxVALUE, (long)(p - st), p, *p);
00150
00151 t = (VALUE *)*p;
00152 if (th->stack <= t && t < sp) {
00153 fprintf(stderr, " (= %ld)", (long)((VALUE *)GC_GUARDED_PTR_REF(t) - th->stack));
00154 }
00155
00156 if (p == ep)
00157 fprintf(stderr, " <- ep");
00158
00159 fprintf(stderr, "\n");
00160 }
00161 #endif
00162
00163 fprintf(stderr, "-- Control frame information "
00164 "-----------------------------------------------\n");
00165 while ((void *)cfp < (void *)(th->stack + th->stack_size)) {
00166 control_frame_dump(th, cfp);
00167 cfp++;
00168 }
00169 fprintf(stderr, "\n");
00170 }
00171
00172 void
00173 rb_vmdebug_stack_dump_raw_current(void)
00174 {
00175 rb_thread_t *th = GET_THREAD();
00176 rb_vmdebug_stack_dump_raw(th, th->cfp);
00177 }
00178
00179 void
00180 rb_vmdebug_env_dump_raw(rb_env_t *env, VALUE *ep)
00181 {
00182 int i;
00183 fprintf(stderr, "-- env --------------------\n");
00184
00185 while (env) {
00186 fprintf(stderr, "--\n");
00187 for (i = 0; i < env->env_size; i++) {
00188 fprintf(stderr, "%04d: %08"PRIxVALUE" (%p)", -env->local_size + i, env->env[i],
00189 (void *)&env->env[i]);
00190 if (&env->env[i] == ep)
00191 fprintf(stderr, " <- ep");
00192 fprintf(stderr, "\n");
00193 }
00194
00195 if (env->prev_envval != 0) {
00196 GetEnvPtr(env->prev_envval, env);
00197 }
00198 else {
00199 env = 0;
00200 }
00201 }
00202 fprintf(stderr, "---------------------------\n");
00203 }
00204
00205 void
00206 rb_vmdebug_proc_dump_raw(rb_proc_t *proc)
00207 {
00208 rb_env_t *env;
00209 char *selfstr;
00210 VALUE val = rb_inspect(proc->block.self);
00211 selfstr = StringValueCStr(val);
00212
00213 fprintf(stderr, "-- proc -------------------\n");
00214 fprintf(stderr, "self: %s\n", selfstr);
00215 GetEnvPtr(proc->envval, env);
00216 rb_vmdebug_env_dump_raw(env, proc->block.ep);
00217 }
00218
00219 void
00220 rb_vmdebug_stack_dump_th(VALUE thval)
00221 {
00222 rb_thread_t *th;
00223 GetThreadPtr(thval, th);
00224 rb_vmdebug_stack_dump_raw(th, th->cfp);
00225 }
00226
00227 #if VMDEBUG > 2
00228
00229
00230 static VALUE *
00231 vm_base_ptr(rb_control_frame_t *cfp)
00232 {
00233 rb_control_frame_t *prev_cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
00234 VALUE *bp = prev_cfp->sp + cfp->iseq->local_size + 1;
00235
00236 if (cfp->iseq->type == ISEQ_TYPE_METHOD) {
00237 bp += 1;
00238 }
00239 return bp;
00240 }
00241
00242 static void
00243 vm_stack_dump_each(rb_thread_t *th, rb_control_frame_t *cfp)
00244 {
00245 int i;
00246
00247 VALUE rstr;
00248 VALUE *sp = cfp->sp;
00249 VALUE *ep = cfp->ep;
00250
00251 int argc = 0, local_size = 0;
00252 const char *name;
00253 rb_iseq_t *iseq = cfp->iseq;
00254
00255 if (iseq == 0) {
00256 if (RUBYVM_CFUNC_FRAME_P(cfp)) {
00257 name = rb_id2name(cfp->me->called_id);
00258 }
00259 else {
00260 name = "?";
00261 }
00262 }
00263 else if (RUBY_VM_IFUNC_P(iseq)) {
00264 name = "<ifunc>";
00265 }
00266 else {
00267 argc = iseq->argc;
00268 local_size = iseq->local_size;
00269 name = RSTRING_PTR(iseq->location.label);
00270 }
00271
00272
00273
00274 if (VM_FRAME_TYPE(cfp) == VM_FRAME_MAGIC_METHOD||
00275 VM_FRAME_TYPE(cfp) == VM_FRAME_MAGIC_TOP ||
00276 VM_FRAME_TYPE(cfp) == VM_FRAME_MAGIC_BLOCK ||
00277 VM_FRAME_TYPE(cfp) == VM_FRAME_MAGIC_CLASS ||
00278 VM_FRAME_TYPE(cfp) == VM_FRAME_MAGIC_PROC ||
00279 VM_FRAME_TYPE(cfp) == VM_FRAME_MAGIC_LAMBDA||
00280 VM_FRAME_TYPE(cfp) == VM_FRAME_MAGIC_CFUNC ||
00281 VM_FRAME_TYPE(cfp) == VM_FRAME_MAGIC_IFUNC ||
00282 VM_FRAME_TYPE(cfp) == VM_FRAME_MAGIC_EVAL ||
00283 VM_FRAME_TYPE(cfp) == VM_FRAME_MAGIC_RESCUE)
00284 {
00285
00286 VALUE *ptr = ep - local_size;
00287
00288 control_frame_dump(th, cfp);
00289
00290 for (i = 0; i < argc; i++) {
00291 rstr = rb_inspect(*ptr);
00292 fprintf(stderr, " arg %2d: %8s (%p)\n", i, StringValueCStr(rstr),
00293 (void *)ptr++);
00294 }
00295 for (; i < local_size - 1; i++) {
00296 rstr = rb_inspect(*ptr);
00297 fprintf(stderr, " local %2d: %8s (%p)\n", i, StringValueCStr(rstr),
00298 (void *)ptr++);
00299 }
00300
00301 ptr = vm_base_ptr(cfp);
00302 for (; ptr < sp; ptr++, i++) {
00303 if (*ptr == Qundef) {
00304 rstr = rb_str_new2("undef");
00305 }
00306 else {
00307 rstr = rb_inspect(*ptr);
00308 }
00309 fprintf(stderr, " stack %2d: %8s (%"PRIdPTRDIFF")\n", i, StringValueCStr(rstr),
00310 (ptr - th->stack));
00311 }
00312 }
00313 else if (VM_FRAME_TYPE_FINISH_P(cfp)) {
00314 if ((th)->stack + (th)->stack_size > (VALUE *)(cfp + 1)) {
00315 vm_stack_dump_each(th, cfp + 1);
00316 }
00317 else {
00318
00319 }
00320 }
00321 else {
00322 rb_bug("unsupport frame type: %08lx", VM_FRAME_TYPE(cfp));
00323 }
00324 }
00325 #endif
00326
00327 void
00328 rb_vmdebug_debug_print_register(rb_thread_t *th)
00329 {
00330 rb_control_frame_t *cfp = th->cfp;
00331 ptrdiff_t pc = -1;
00332 ptrdiff_t ep = cfp->ep - th->stack;
00333 ptrdiff_t cfpi;
00334
00335 if (RUBY_VM_NORMAL_ISEQ_P(cfp->iseq)) {
00336 pc = cfp->pc - cfp->iseq->iseq_encoded;
00337 }
00338
00339 if (ep < 0 || (size_t)ep > th->stack_size) {
00340 ep = -1;
00341 }
00342
00343 cfpi = ((rb_control_frame_t *)(th->stack + th->stack_size)) - cfp;
00344 fprintf(stderr, " [PC] %04"PRIdPTRDIFF", [SP] %04"PRIdPTRDIFF", [EP] %04"PRIdPTRDIFF", [CFP] %04"PRIdPTRDIFF"\n",
00345 pc, (cfp->sp - th->stack), ep, cfpi);
00346 }
00347
00348 void
00349 rb_vmdebug_thread_dump_regs(VALUE thval)
00350 {
00351 rb_thread_t *th;
00352 GetThreadPtr(thval, th);
00353 rb_vmdebug_debug_print_register(th);
00354 }
00355
00356 void
00357 rb_vmdebug_debug_print_pre(rb_thread_t *th, rb_control_frame_t *cfp)
00358 {
00359 rb_iseq_t *iseq = cfp->iseq;
00360
00361 if (iseq != 0) {
00362 VALUE *seq = iseq->iseq;
00363 ptrdiff_t pc = cfp->pc - iseq->iseq_encoded;
00364 int i;
00365
00366 for (i=0; i<(int)VM_CFP_CNT(th, cfp); i++) {
00367 printf(" ");
00368 }
00369 printf("| ");
00370
00371 if (pc >= 0) {
00372 rb_iseq_disasm_insn(0, seq, (size_t)pc, iseq, 0);
00373 }
00374 }
00375
00376 #if VMDEBUG > 3
00377 fprintf(stderr, " (1)");
00378 rb_vmdebug_debug_print_register(th);
00379 #endif
00380 }
00381
00382 void
00383 rb_vmdebug_debug_print_post(rb_thread_t *th, rb_control_frame_t *cfp
00384 #if OPT_STACK_CACHING
00385 , VALUE reg_a, VALUE reg_b
00386 #endif
00387 )
00388 {
00389 #if VMDEBUG > 9
00390 SDR2(cfp);
00391 #endif
00392
00393 #if VMDEBUG > 3
00394 fprintf(stderr, " (2)");
00395 rb_vmdebug_debug_print_register(th);
00396 #endif
00397
00398
00399 #if VMDEBUG > 2
00400
00401 vm_stack_dump_each(th, th->cfp);
00402
00403 #if OPT_STACK_CACHING
00404 {
00405 VALUE rstr;
00406 rstr = rb_inspect(reg_a);
00407 fprintf(stderr, " sc reg A: %s\n", StringValueCStr(rstr));
00408 rstr = rb_inspect(reg_b);
00409 fprintf(stderr, " sc reg B: %s\n", StringValueCStr(rstr));
00410 }
00411 #endif
00412 printf
00413 ("--------------------------------------------------------------\n");
00414 #endif
00415 }
00416
00417 VALUE
00418 rb_vmdebug_thread_dump_state(VALUE self)
00419 {
00420 rb_thread_t *th;
00421 rb_control_frame_t *cfp;
00422 GetThreadPtr(self, th);
00423 cfp = th->cfp;
00424
00425 fprintf(stderr, "Thread state dump:\n");
00426 fprintf(stderr, "pc : %p, sp : %p\n", (void *)cfp->pc, (void *)cfp->sp);
00427 fprintf(stderr, "cfp: %p, ep : %p\n", (void *)cfp, (void *)cfp->ep);
00428
00429 return Qnil;
00430 }
00431
00432 #ifndef HAVE_BACKTRACE
00433 #define HAVE_BACKTRACE 0
00434 #endif
00435 #if HAVE_BACKTRACE
00436 # include <execinfo.h>
00437 #elif defined(_WIN32)
00438 # include <imagehlp.h>
00439 # ifndef SYMOPT_DEBUG
00440 # define SYMOPT_DEBUG 0x80000000
00441 # endif
00442 # ifndef MAX_SYM_NAME
00443 # define MAX_SYM_NAME 2000
00444 typedef struct {
00445 DWORD64 Offset;
00446 WORD Segment;
00447 ADDRESS_MODE Mode;
00448 } ADDRESS64;
00449 typedef struct {
00450 DWORD64 Thread;
00451 DWORD ThCallbackStack;
00452 DWORD ThCallbackBStore;
00453 DWORD NextCallback;
00454 DWORD FramePointer;
00455 DWORD64 KiCallUserMode;
00456 DWORD64 KeUserCallbackDispatcher;
00457 DWORD64 SystemRangeStart;
00458 DWORD64 KiUserExceptionDispatcher;
00459 DWORD64 StackBase;
00460 DWORD64 StackLimit;
00461 DWORD64 Reserved[5];
00462 } KDHELP64;
00463 typedef struct {
00464 ADDRESS64 AddrPC;
00465 ADDRESS64 AddrReturn;
00466 ADDRESS64 AddrFrame;
00467 ADDRESS64 AddrStack;
00468 ADDRESS64 AddrBStore;
00469 void *FuncTableEntry;
00470 DWORD64 Params[4];
00471 BOOL Far;
00472 BOOL Virtual;
00473 DWORD64 Reserved[3];
00474 KDHELP64 KdHelp;
00475 } STACKFRAME64;
00476 typedef struct {
00477 ULONG SizeOfStruct;
00478 ULONG TypeIndex;
00479 ULONG64 Reserved[2];
00480 ULONG Index;
00481 ULONG Size;
00482 ULONG64 ModBase;
00483 ULONG Flags;
00484 ULONG64 Value;
00485 ULONG64 Address;
00486 ULONG Register;
00487 ULONG Scope;
00488 ULONG Tag;
00489 ULONG NameLen;
00490 ULONG MaxNameLen;
00491 char Name[1];
00492 } SYMBOL_INFO;
00493 typedef struct {
00494 DWORD SizeOfStruct;
00495 void *Key;
00496 DWORD LineNumber;
00497 char *FileName;
00498 DWORD64 Address;
00499 } IMAGEHLP_LINE64;
00500 typedef void *PREAD_PROCESS_MEMORY_ROUTINE64;
00501 typedef void *PFUNCTION_TABLE_ACCESS_ROUTINE64;
00502 typedef void *PGET_MODULE_BASE_ROUTINE64;
00503 typedef void *PTRANSLATE_ADDRESS_ROUTINE64;
00504 # endif
00505
00506 static void
00507 dump_thread(void *arg)
00508 {
00509 HANDLE dbghelp;
00510 BOOL (WINAPI *pSymInitialize)(HANDLE, const char *, BOOL);
00511 BOOL (WINAPI *pSymCleanup)(HANDLE);
00512 BOOL (WINAPI *pStackWalk64)(DWORD, HANDLE, HANDLE, STACKFRAME64 *, void *, PREAD_PROCESS_MEMORY_ROUTINE64, PFUNCTION_TABLE_ACCESS_ROUTINE64, PGET_MODULE_BASE_ROUTINE64, PTRANSLATE_ADDRESS_ROUTINE64);
00513 DWORD64 (WINAPI *pSymGetModuleBase64)(HANDLE, DWORD64);
00514 BOOL (WINAPI *pSymFromAddr)(HANDLE, DWORD64, DWORD64 *, SYMBOL_INFO *);
00515 BOOL (WINAPI *pSymGetLineFromAddr64)(HANDLE, DWORD64, DWORD *, IMAGEHLP_LINE64 *);
00516 HANDLE (WINAPI *pOpenThread)(DWORD, BOOL, DWORD);
00517 DWORD tid = *(DWORD *)arg;
00518 HANDLE ph;
00519 HANDLE th;
00520
00521 dbghelp = LoadLibrary("dbghelp.dll");
00522 if (!dbghelp) return;
00523 pSymInitialize = (BOOL (WINAPI *)(HANDLE, const char *, BOOL))GetProcAddress(dbghelp, "SymInitialize");
00524 pSymCleanup = (BOOL (WINAPI *)(HANDLE))GetProcAddress(dbghelp, "SymCleanup");
00525 pStackWalk64 = (BOOL (WINAPI *)(DWORD, HANDLE, HANDLE, STACKFRAME64 *, void *, PREAD_PROCESS_MEMORY_ROUTINE64, PFUNCTION_TABLE_ACCESS_ROUTINE64, PGET_MODULE_BASE_ROUTINE64, PTRANSLATE_ADDRESS_ROUTINE64))GetProcAddress(dbghelp, "StackWalk64");
00526 pSymGetModuleBase64 = (DWORD64 (WINAPI *)(HANDLE, DWORD64))GetProcAddress(dbghelp, "SymGetModuleBase64");
00527 pSymFromAddr = (BOOL (WINAPI *)(HANDLE, DWORD64, DWORD64 *, SYMBOL_INFO *))GetProcAddress(dbghelp, "SymFromAddr");
00528 pSymGetLineFromAddr64 = (BOOL (WINAPI *)(HANDLE, DWORD64, DWORD *, IMAGEHLP_LINE64 *))GetProcAddress(dbghelp, "SymGetLineFromAddr64");
00529 pOpenThread = (HANDLE (WINAPI *)(DWORD, BOOL, DWORD))GetProcAddress(GetModuleHandle("kernel32.dll"), "OpenThread");
00530 if (pSymInitialize && pSymCleanup && pStackWalk64 && pSymGetModuleBase64 &&
00531 pSymFromAddr && pSymGetLineFromAddr64 && pOpenThread) {
00532 SymSetOptions(SYMOPT_UNDNAME | SYMOPT_DEFERRED_LOADS | SYMOPT_DEBUG | SYMOPT_LOAD_LINES);
00533 ph = GetCurrentProcess();
00534 pSymInitialize(ph, NULL, TRUE);
00535 th = pOpenThread(THREAD_SUSPEND_RESUME|THREAD_GET_CONTEXT, FALSE, tid);
00536 if (th) {
00537 if (SuspendThread(th) != (DWORD)-1) {
00538 CONTEXT context;
00539 memset(&context, 0, sizeof(context));
00540 context.ContextFlags = CONTEXT_FULL;
00541 if (GetThreadContext(th, &context)) {
00542 char libpath[MAX_PATH];
00543 char buf[sizeof(SYMBOL_INFO) + MAX_SYM_NAME];
00544 SYMBOL_INFO *info = (SYMBOL_INFO *)buf;
00545 DWORD mac;
00546 STACKFRAME64 frame;
00547 memset(&frame, 0, sizeof(frame));
00548 #if defined(_M_AMD64) || defined(__x86_64__)
00549 mac = IMAGE_FILE_MACHINE_AMD64;
00550 frame.AddrPC.Mode = AddrModeFlat;
00551 frame.AddrPC.Offset = context.Rip;
00552 frame.AddrFrame.Mode = AddrModeFlat;
00553 frame.AddrFrame.Offset = context.Rbp;
00554 frame.AddrStack.Mode = AddrModeFlat;
00555 frame.AddrStack.Offset = context.Rsp;
00556 #elif defined(_M_IA64) || defined(__ia64__)
00557 mac = IMAGE_FILE_MACHINE_IA64;
00558 frame.AddrPC.Mode = AddrModeFlat;
00559 frame.AddrPC.Offset = context.StIIP;
00560 frame.AddrBStore.Mode = AddrModeFlat;
00561 frame.AddrBStore.Offset = context.RsBSP;
00562 frame.AddrStack.Mode = AddrModeFlat;
00563 frame.AddrStack.Offset = context.IntSp;
00564 #else
00565 mac = IMAGE_FILE_MACHINE_I386;
00566 frame.AddrPC.Mode = AddrModeFlat;
00567 frame.AddrPC.Offset = context.Eip;
00568 frame.AddrFrame.Mode = AddrModeFlat;
00569 frame.AddrFrame.Offset = context.Ebp;
00570 frame.AddrStack.Mode = AddrModeFlat;
00571 frame.AddrStack.Offset = context.Esp;
00572 #endif
00573
00574 while (pStackWalk64(mac, ph, th, &frame, &context, NULL,
00575 NULL, NULL, NULL)) {
00576 DWORD64 addr = frame.AddrPC.Offset;
00577 IMAGEHLP_LINE64 line;
00578 DWORD64 displacement;
00579 DWORD tmp;
00580
00581 if (addr == frame.AddrReturn.Offset || addr == 0 ||
00582 frame.AddrReturn.Offset == 0)
00583 break;
00584
00585 memset(buf, 0, sizeof(buf));
00586 info->SizeOfStruct = sizeof(SYMBOL_INFO);
00587 info->MaxNameLen = MAX_SYM_NAME;
00588 if (pSymFromAddr(ph, addr, &displacement, info)) {
00589 if (GetModuleFileName((HANDLE)(uintptr_t)pSymGetModuleBase64(ph, addr), libpath, sizeof(libpath)))
00590 fprintf(stderr, "%s", libpath);
00591 fprintf(stderr, "(%s+0x%I64x)",
00592 info->Name, displacement);
00593 }
00594 fprintf(stderr, " [0x%p]", (void *)(VALUE)addr);
00595 memset(&line, 0, sizeof(line));
00596 line.SizeOfStruct = sizeof(line);
00597 if (pSymGetLineFromAddr64(ph, addr, &tmp, &line))
00598 fprintf(stderr, " %s:%lu", line.FileName, line.LineNumber);
00599 fprintf(stderr, "\n");
00600 }
00601 }
00602
00603 ResumeThread(th);
00604 }
00605 CloseHandle(th);
00606 }
00607 pSymCleanup(ph);
00608 }
00609 FreeLibrary(dbghelp);
00610 }
00611 #endif
00612
00613 void
00614 rb_vm_bugreport(void)
00615 {
00616 #ifdef __linux__
00617 # define PROC_MAPS_NAME "/proc/self/maps"
00618 #endif
00619 #ifdef PROC_MAPS_NAME
00620 enum {other_runtime_info = 1};
00621 #else
00622 enum {other_runtime_info = 0};
00623 #endif
00624 const rb_vm_t *const vm = GET_VM();
00625
00626 #if defined __APPLE__
00627 fputs("-- Crash Report log information "
00628 "--------------------------------------------\n"
00629 " See Crash Report log file under the one of following:\n"
00630 " * ~/Library/Logs/CrashReporter\n"
00631 " * /Library/Logs/CrashReporter\n"
00632 " * ~/Library/Logs/DiagnosticReports\n"
00633 " * /Library/Logs/DiagnosticReports\n"
00634 " the more detail of.\n"
00635 "\n",
00636 stderr);
00637 #endif
00638 if (vm) {
00639 SDR();
00640 rb_backtrace_print_as_bugreport();
00641 fputs("\n", stderr);
00642 }
00643
00644 #if HAVE_BACKTRACE || defined(_WIN32)
00645 fprintf(stderr, "-- C level backtrace information "
00646 "-------------------------------------------\n");
00647
00648 {
00649 #if HAVE_BACKTRACE
00650 #define MAX_NATIVE_TRACE 1024
00651 static void *trace[MAX_NATIVE_TRACE];
00652 int n = backtrace(trace, MAX_NATIVE_TRACE);
00653 char **syms = backtrace_symbols(trace, n);
00654
00655 if (syms) {
00656 #ifdef USE_ELF
00657 rb_dump_backtrace_with_lines(n, trace, syms);
00658 #else
00659 int i;
00660 for (i=0; i<n; i++) {
00661 fprintf(stderr, "%s\n", syms[i]);
00662 }
00663 #endif
00664 free(syms);
00665 }
00666 #elif defined(_WIN32)
00667 DWORD tid = GetCurrentThreadId();
00668 HANDLE th = (HANDLE)_beginthread(dump_thread, 0, &tid);
00669 if (th != (HANDLE)-1)
00670 WaitForSingleObject(th, INFINITE);
00671 #endif
00672 }
00673
00674 fprintf(stderr, "\n");
00675 #endif
00676
00677 if (other_runtime_info || vm) {
00678 fprintf(stderr, "-- Other runtime information "
00679 "-----------------------------------------------\n\n");
00680 }
00681 if (vm) {
00682 int i;
00683 VALUE name;
00684 long len;
00685 const int max_name_length = 1024;
00686 # define LIMITED_NAME_LENGTH(s) \
00687 (((len = RSTRING_LEN(s)) > max_name_length) ? max_name_length : (int)len)
00688
00689 name = vm->progname;
00690 fprintf(stderr, "* Loaded script: %.*s\n",
00691 LIMITED_NAME_LENGTH(name), RSTRING_PTR(name));
00692 fprintf(stderr, "\n");
00693 fprintf(stderr, "* Loaded features:\n\n");
00694 for (i=0; i<RARRAY_LEN(vm->loaded_features); i++) {
00695 name = RARRAY_PTR(vm->loaded_features)[i];
00696 if (RB_TYPE_P(name, T_STRING)) {
00697 fprintf(stderr, " %4d %.*s\n", i,
00698 LIMITED_NAME_LENGTH(name), RSTRING_PTR(name));
00699 }
00700 else {
00701 fprintf(stderr, " %4d #<%s:%p>\n", i,
00702 rb_class2name(CLASS_OF(name)), (void *)name);
00703 }
00704 }
00705 fprintf(stderr, "\n");
00706 }
00707
00708 {
00709 #ifdef PROC_MAPS_NAME
00710 {
00711 FILE *fp = fopen(PROC_MAPS_NAME, "r");
00712 if (fp) {
00713 fprintf(stderr, "* Process memory map:\n\n");
00714
00715 while (!feof(fp)) {
00716 char buff[0x100];
00717 size_t rn = fread(buff, 1, 0x100, fp);
00718 if (fwrite(buff, 1, rn, stderr) != rn)
00719 break;
00720 }
00721
00722 fclose(fp);
00723 fprintf(stderr, "\n\n");
00724 }
00725 }
00726 #endif
00727 }
00728 }
00729
