libgo patch committed: Don't call funcPC from a function

[Ian Lance Taylor]

This patch changes the libgo runtime package to not call funcPC from a
function.  The escape analysis support is not yet good enough to avoid
escaping the argument to funcPC.  This causes unnecessary and often
harmful memory allocation.  E.g., (*cpuProfile).addExtra can be called
from a signal handler, and it must not allocate memory.  This patch
moves the calls to funcPC to use variables instead.  This was done in
the original migration to using funcPC, but was not done for newer
code.  In one case, in signal handling code, use getSigtramp.
Bootstrapped and ran Go testsuite on x86_64-pc-linux-gnu.  Committed
to mainline.

Ian

Index: gcc/go/gofrontend/MERGE
===================================================================
--- gcc/go/gofrontend/MERGE     (revision 257436)
+++ gcc/go/gofrontend/MERGE     (working copy)
@@ -1,4 +1,4 @@
-5fe998e4a18cc1dbbd4869be5c8202bda55adb33
+cdc28627b7abfd73f5d552813db8eb4293b823b0
 
 The first line of this file holds the git revision number of the last
 merge done from the gofrontend repository.
Index: libgo/go/runtime/cpuprof.go
===================================================================
--- libgo/go/runtime/cpuprof.go (revision 257415)
+++ libgo/go/runtime/cpuprof.go (working copy)
@@ -156,8 +156,8 @@ func (p *cpuProfile) addExtra() {
        if p.lostExtra > 0 {
                hdr := [1]uint64{p.lostExtra}
                lostStk := [2]uintptr{
-                       funcPC(_LostExternalCode) + sys.PCQuantum,
-                       funcPC(_ExternalCode) + sys.PCQuantum,
+                       _LostExternalCodePC + sys.PCQuantum,
+                       _ExternalCodePC + sys.PCQuantum,
                }
                cpuprof.log.write(nil, 0, hdr[:], lostStk[:])
                p.lostExtra = 0
@@ -167,8 +167,8 @@ func (p *cpuProfile) addExtra() {
 func (p *cpuProfile) addLostAtomic64(count uint64) {
        hdr := [1]uint64{count}
        lostStk := [2]uintptr{
-               funcPC(_LostSIGPROFDuringAtomic64) + sys.PCQuantum,
-               funcPC(_System) + sys.PCQuantum,
+               _LostSIGPROFDuringAtomic64PC + sys.PCQuantum,
+               _SystemPC + sys.PCQuantum,
        }
        cpuprof.log.write(nil, 0, hdr[:], lostStk[:])
 }
Index: libgo/go/runtime/proc.go
===================================================================
--- libgo/go/runtime/proc.go    (revision 257415)
+++ libgo/go/runtime/proc.go    (working copy)
@@ -3369,7 +3369,9 @@ var lostAtomic64Count uint64
 
 var _SystemPC = funcPC(_System)
 var _ExternalCodePC = funcPC(_ExternalCode)
+var _LostExternalCodePC = funcPC(_LostExternalCode)
 var _GCPC = funcPC(_GC)
+var _LostSIGPROFDuringAtomic64PC = funcPC(_LostSIGPROFDuringAtomic64)
 
 // Called if we receive a SIGPROF signal.
 // Called by the signal handler, may run during STW.
@@ -3469,7 +3471,7 @@ func sigprofNonGoPC(pc uintptr) {
        if prof.hz != 0 {
                stk := []uintptr{
                        pc,
-                       funcPC(_ExternalCode) + sys.PCQuantum,
+                       _ExternalCodePC + sys.PCQuantum,
                }
                cpuprof.addNonGo(stk)
        }
Index: libgo/go/runtime/signal_unix.go
===================================================================
--- libgo/go/runtime/signal_unix.go     (revision 257415)
+++ libgo/go/runtime/signal_unix.go     (working copy)
@@ -245,7 +245,7 @@ func setProcessCPUProfiler(hz int32) {
                // Enable the Go signal handler if not enabled.
                if atomic.Cas(&handlingSig[_SIGPROF], 0, 1) {
                        atomic.Storeuintptr(&fwdSig[_SIGPROF], getsig(_SIGPROF))
-                       setsig(_SIGPROF, funcPC(sighandler))
+                       setsig(_SIGPROF, getSigtramp())
                }
        } else {
                // If the Go signal handler should be disabled by default,