code review 134200044: runtime: convert traceback*.c to Go

src/pkg/runtime/traceback.go

 // 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.
 
 package runtime
 
 import "unsafe"
 
 // The code in this file implements stack trace walking for all architectures.
 // The most important fact about a given architecture is whether it uses a link register.
@@ skipping 10 matching lines @@
 // The other important fact is the size of a pointer: on 32-bit systems the LR
 // takes up only 4 bytes on the stack, while on 64-bit systems it takes up 8 bytes.
 // Typically this is ptrSize.
 //
 // As an exception, amd64p32 has ptrSize == 4 but the CALL instruction still
 // stores an 8-byte return PC onto the stack. To accommodate this, we use regSize
 // as the size of the architecture-pushed return PC.
 //
 // usesLR is defined below. ptrSize and regSize are defined in stubs.go.
 
-const usesLR = GOARCH == "arm"
+const usesLR = GOARCH != "amd64" && GOARCH != "amd64p32" && GOARCH != "386"
 
 // jmpdeferPC is the PC at the beginning of the jmpdefer assembly function.
 // The traceback needs to recognize it on link register architectures.
 var jmpdeferPC uintptr
 
 func init() {
         f := jmpdefer
         jmpdeferPC = **(**uintptr)(unsafe.Pointer(&f))
 }
 
@@ skipping 453 matching lines @@
 
 func callers(skip int, pcbuf *uintptr, m int) int {
         sp := getcallersp(unsafe.Pointer(&skip))
         pc := uintptr(getcallerpc(unsafe.Pointer(&skip)))
         return gentraceback(pc, sp, 0, getg(), skip, pcbuf, m, nil, nil, false)
 }
 
 func gcallers(gp *g, skip int, pcbuf *uintptr, m int) int {
         return gentraceback(^uintptr(0), ^uintptr(0), 0, gp, skip, pcbuf, m, nil, nil, false)
 }