runtime: remove unused skip arg from fpTracebackPCs

This was accidentally left behind when moving the logic to set the skip
sentinel in pcBuf to the caller.

Change-Id: Id7565f6ea4df6b32cf18b99c700bca322998d182
Reviewed-on: https://go-review.googlesource.com/c/go/+/489095
Reviewed-by: Michael Pratt <[email protected]>
Reviewed-by: Dmitri Shuralyov <[email protected]>
TryBot-Result: Gopher Robot <[email protected]>
Run-TryBot: Felix Geisendörfer <[email protected]>

Author: felixge

src/runtime/callers_test.go

@@ -443,7 +443,7 @@ func fpCallersCached(b *testing.B, n int) int {
 		pcs := make([]uintptr, 32)
 		b.ResetTimer()
 		for i := 0; i < b.N; i++ {
-			runtime.FPCallers(0, pcs)
+			runtime.FPCallers(pcs)
 		}
 		b.StopTimer()
 		return 0

src/runtime/export_test.go

@@ -437,7 +437,7 @@ func ShrinkStackAndVerifyFramePointers() {
 	})
 	// If our new stack contains frame pointers into the old stack, this will
 	// crash because the old stack has been poisoned.
-	FPCallers(0, make([]uintptr, 1024))
+	FPCallers(make([]uintptr, 1024))
 }
 
 // BlockOnSystemStack switches to the system stack, prints "x\n" to
@@ -1819,6 +1819,6 @@ func PersistentAlloc(n uintptr) unsafe.Pointer {
 
 // FPCallers works like Callers and uses frame pointer unwinding to populate
 // pcBuf with the return addresses of the physical frames on the stack.
-func FPCallers(skip int, pcBuf []uintptr) int {
-	return fpTracebackPCs(unsafe.Pointer(getcallerfp()), skip, pcBuf)
+func FPCallers(pcBuf []uintptr) int {
+	return fpTracebackPCs(unsafe.Pointer(getcallerfp()), pcBuf)
 }

src/runtime/trace.go

@@ -917,15 +917,15 @@ func traceStackID(mp *m, pcBuf []uintptr, skip int) uint64 {
 		// Fast path: Unwind using frame pointers.
 		pcBuf[0] = uintptr(skip)
 		if curgp == gp {
-			nstk += fpTracebackPCs(unsafe.Pointer(getcallerfp()), skip, pcBuf[1:])
+			nstk += fpTracebackPCs(unsafe.Pointer(getcallerfp()), pcBuf[1:])
 		} else if curgp != nil {
 			// We're called on the g0 stack through mcall(fn) or systemstack(fn). To
 			// behave like gcallers above, we start unwinding from sched.bp, which
 			// points to the caller frame of the leaf frame on g's stack. The return
 			// address of the leaf frame is stored in sched.pc, which we manually
 			// capture here.
 			pcBuf[1] = curgp.sched.pc
-			nstk += 1 + fpTracebackPCs(unsafe.Pointer(curgp.sched.bp), skip, pcBuf[2:])
+			nstk += 1 + fpTracebackPCs(unsafe.Pointer(curgp.sched.bp), pcBuf[2:])
 		}
 	}
 	if nstk > 0 {
@@ -948,7 +948,7 @@ func tracefpunwindoff() bool {
 // returns the number of PCs written to pcBuf. The returned PCs correspond to
 // "physical frames" rather than "logical frames"; that is if A is inlined into
 // B, this will return a PC for only B.
-func fpTracebackPCs(fp unsafe.Pointer, skip int, pcBuf []uintptr) (i int) {
+func fpTracebackPCs(fp unsafe.Pointer, pcBuf []uintptr) (i int) {
 	for i = 0; i < len(pcBuf) && fp != nil; i++ {
 		// return addr sits one word above the frame pointer
 		pcBuf[i] = *(*uintptr)(unsafe.Pointer(uintptr(fp) + goarch.PtrSize))