code review 7098050: runtime: dump full stacks on throw and signals

src/pkg/runtime/traceback_arm.c

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 #include "runtime.h"
 #include "arch_GOARCH.h"
 #include "malloc.h"
 
 void runtime·deferproc(void);
 void runtime·newproc(void);
 void runtime·newstack(void);
 void runtime·morestack(void);
 void runtime·sigpanic(void);
 void _div(void);
 void _mod(void);
 void _divu(void);
 void _modu(void);
 
 int32
 runtime·gentraceback(byte *pc0, byte *sp, byte *lr0, G *gp, int32 skip, uintptr *pcbuf, int32 max)
 {
         int32 i, n, iter;
         uintptr pc, lr, tracepc, x;
         byte *fp, *p;
         bool waspanic;
         Stktop *stk;
         Func *f;
-        
+
         pc = (uintptr)pc0;
         lr = (uintptr)lr0;
         fp = nil;
         waspanic = false;
 
         // If the PC is goexit, the goroutine hasn't started yet.
         if(pc == (uintptr)runtime·goexit) {
                 pc = (uintptr)gp->entry;
                 lr = (uintptr)runtime·goexit;
         }
@@ skipping 14 matching lines @@
                 //      fp is the frame pointer (caller's stack pointer) at that program counter, or nil if unknown.
                 //      stk is the stack containing sp.
                 //      The caller's program counter is lr, unless lr is zero, in which case it is *(uintptr*)sp.
 ················
                 if(pc == (uintptr)runtime·lessstack) {
                         // Hit top of stack segment.  Unwind to next segment.
                         pc = (uintptr)stk->gobuf.pc;
                         sp = (byte*)stk->gobuf.sp;
                         lr = 0;
                         fp = nil;
-                        if(pcbuf == nil)
+                        if(pcbuf == nil && runtime·showframe(nil, gp == m->curg))
                                 runtime·printf("----- stack segment boundary -----\n");
                         stk = (Stktop*)stk->stackbase;
                         continue;
                 }
 ················
                 if(pc <= 0x1000 || (f = runtime·findfunc(pc)) == nil) {
                         // Dangerous, but worthwhile: see if this is a closure by
                         // decoding the instruction stream.
                         //
                         // We check p < p+4 to avoid wrapping and faulting if
@@ skipping 37 matching lines @@
                         fp = sp;
                         if(pc > f->entry && f->frame >= 0)
                                 fp += f->frame;
                 }
 
                 if(skip > 0)
                         skip--;
                 else if(pcbuf != nil)
                         pcbuf[n++] = pc;
                 else {
-                        if(runtime·showframe(f)) {
+                        if(runtime·showframe(f, gp == m->curg)) {
                                 // Print during crash.
                                 //      main(0x1, 0x2, 0x3)
                                 //              /home/rsc/go/src/runtime/x.go:23 +0xf
                                 tracepc = pc;   // back up to CALL instruction for funcline.
                                 if(n > 0 && pc > f->entry && !waspanic)
                                         tracepc -= sizeof(uintptr);
                                 runtime·printf("%S(", f->name);
                                 for(i = 0; i < f->args; i++) {
                                         if(i != 0)
                                                 runtime·prints(", ");
@@ skipping 45 matching lines @@
                 // If this was div or divu or mod or modu, the caller had
                 // an extra 8 bytes on its stack.  Adjust sp.
                 if(f->entry == (uintptr)_div || f->entry == (uintptr)_divu || f->entry == (uintptr)_mod || f->entry == (uintptr)_modu)
                         sp += 8;
 ················
                 // If this was deferproc or newproc, the caller had an extra 12.
                 if(f->entry == (uintptr)runtime·deferproc || f->entry == (uintptr)runtime·newproc)
                         sp += 12;
         }
 ········
-        if(pcbuf == nil && (pc = gp->gopc) != 0 && (f = runtime·findfunc(pc)) != nil && gp->goid != 1) {
+        if(pcbuf == nil && (pc = gp->gopc) != 0 && (f = runtime·findfunc(pc)) != nil
+                        && runtime·showframe(f, gp == m->curg) && gp->goid != 1) {
                 runtime·printf("created by %S\n", f->name);
                 tracepc = pc;   // back up to CALL instruction for funcline.
                 if(n > 0 && pc > f->entry)
                         tracepc -= sizeof(uintptr);
                 runtime·printf("\t%S:%d", f->src, runtime·funcline(f, tracepc));
                 if(pc > f->entry)
                         runtime·printf(" +%p", (uintptr)(pc - f->entry));
                 runtime·printf("\n");
         }
 
@@ skipping 10 matching lines @@
 int32
 runtime·callers(int32 skip, uintptr *pcbuf, int32 m)
 {
         byte *pc, *sp;
 ········
         sp = runtime·getcallersp(&skip);
         pc = runtime·getcallerpc(&skip);
 
         return runtime·gentraceback(pc, sp, 0, g, skip, pcbuf, m);
 }