code review 140870044: runtime: introduce, use funcPC to convert Go func to PC

src/pkg/runtime/select.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
 
 // This file contains the implementation of Go select statements.
 
 import "unsafe"
 
 const (
         debugSelect = false
 )
 
 var (
-        chansendpc uintptr
-        chanrecvpc uintptr
+        chansendpc = funcPC(chansend)
+        chanrecvpc = funcPC(chanrecv)
 )
-
-func init() {
-        f := chansend
-        chansendpc = **(**uintptr)(unsafe.Pointer(&f))
-        g := chanrecv
-        chanrecvpc = **(**uintptr)(unsafe.Pointer(&g))
-}
 
 func selectsize(size uintptr) uintptr {
         selsize := unsafe.Sizeof(_select{}) +
                 (size-1)*unsafe.Sizeof(_select{}.scase[0]) +
                 size*unsafe.Sizeof(*_select{}.lockorder) +
                 size*unsafe.Sizeof(*_select{}.pollorder)
         return round(selsize, _Int64Align)
 }
 
 func newselect(sel *_select, selsize int64, size int32) {
@@ skipping 243 matching lines @@
         sellock(sel)
 
         var (
                 gp     *g
                 done   uint32
                 sg     *sudog
                 c      *hchan
                 k      *scase
                 sglist *sudog
                 sgnext *sudog
-                fn     func(*g, *_select) bool
         )
 
 loop:
         // pass 1 - look for something already waiting
         var dfl *scase
         var cas *scase
         for i := 0; i < int(sel.ncase); i++ {
                 cas = &scases[pollorder[i]]
                 c = cas._chan
 
@@ skipping 64 matching lines @@
                 case _CaseRecv:
                         c.recvq.enqueue(sg)
 
                 case _CaseSend:
                         c.sendq.enqueue(sg)
                 }
         }
 
         // wait for someone to wake us up
         gp.param = nil
-        fn = selparkcommit
-        gopark(**(**unsafe.Pointer)(unsafe.Pointer(&fn)), unsafe.Pointer(sel), "select")
+        gopark(unsafe.Pointer(funcPC(selparkcommit)), unsafe.Pointer(sel), "select")
 
         // someone woke us up
         sellock(sel)
         sg = (*sudog)(gp.param)
 
         // pass 3 - dequeue from unsuccessful chans
         // otherwise they stack up on quiet channels
         // record the successful case, if any.
         // We singly-linked up the SudoGs in case order, so when
         // iterating through the linked list they are in reverse order.
@@ skipping 250 matching lines @@
                         *l = sgp.next
                         if q.last == sgp {
                                 q.last = prevsgp
                         }
                         return
                 }
                 l = &sgp.next
                 prevsgp = sgp
         }
 }