code review 12250043: runtime: use gcpc/gcsp during traceback of goroutines i...

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"
 #include "funcdata.h"
 
 void runtime·sigpanic(void);
-
-static String unknown = { (uint8*)"?", 1 };
 
 int32
 runtime·gentraceback(uintptr pc0, uintptr sp0, uintptr lr0, G *gp, int32 skip, uintptr *pcbuf, int32 max, void (*callback)(Stkframe*, void*), void *v, bool printall)
 {
         int32 i, n, nprint, line;
         uintptr x, tracepc;
         bool waspanic, printing;
         Func *f, *flr;
         Stkframe frame;
         Stktop *stk;
@@ skipping 165 matching lines @@
                                 frame.lr = x;
                 }
         }
 ········
         if(pcbuf == nil && callback == nil)
                 n = nprint;
 
         return n;···············
 }
 
-static void
-printcreatedby(G *gp)
+void
+runtime·printcreatedby(G *gp)
 {
         int32 line;
         uintptr pc, tracepc;
         Func *f;
         String file;
 
-        if((pc = gp->gopc) != 0 && (f = runtime·findfunc(pc)) != nil
-                && runtime·showframe(f, gp) && gp->goid != 1) {
+        // Show what created goroutine, except main goroutine (goid 1).
+        if((pc = gp->gopc) != 0 && (f = runtime·findfunc(pc)) != nil &&
+                runtime·showframe(f, gp) && gp->goid != 1) {
                 runtime·printf("created by %s\n", runtime·funcname(f));
                 tracepc = pc;   // back up to CALL instruction for funcline.
                 if(pc > f->entry)
-                        tracepc -= sizeof(uintptr);
+                        tracepc -= PCQuantum;
                 line = runtime·funcline(f, tracepc, &file);
                 runtime·printf("\t%S:%d", file, line);
                 if(pc > f->entry)
                         runtime·printf(" +%p", (uintptr)(pc - f->entry));
                 runtime·printf("\n");
         }
 }
 
 void
 runtime·traceback(uintptr pc, uintptr sp, uintptr lr, G *gp)
 {
         if(gp->status == Gsyscall) {
                 // Override signal registers if blocked in system call.
-                pc = gp->gcpc;
-                sp = gp->gcsp;
+                pc = gp->syscallpc;
+                sp = gp->syscallsp;
                 lr = 0;
         }
 
         // Print traceback. By default, omits runtime frames.
         // If that means we print nothing at all, repeat forcing all frames printed.
         if(runtime·gentraceback(pc, sp, lr, gp, 0, nil, 100, nil, nil, false) == 0)
                 runtime·gentraceback(pc, sp, lr, gp, 0, nil, 100, nil, nil, true);
-        printcreatedby(gp);
+        runtime·printcreatedby(gp);
 }
 
 // func caller(n int) (pc uintptr, file string, line int, ok bool)
 int32
 runtime·callers(int32 skip, uintptr *pcbuf, int32 m)
 {
         uintptr pc, sp;
 ········
         sp = runtime·getcallersp(&skip);
         pc = (uintptr)runtime·getcallerpc(&skip);
 
         return runtime·gentraceback(pc, sp, 0, g, skip, pcbuf, m, nil, nil, false);
 }