code review 122090043: runtime: convert markallocated from C to Go

src/pkg/runtime/stubs.go

 // Copyright 2014 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"
 
 // Declarations for runtime services implemented in C or assembly.
 // C implementations of these functions are in stubs.goc.
@@ skipping 26 matching lines @@
 
 // n must be a power of 2
 func roundup(p unsafe.Pointer, n uintptr) unsafe.Pointer {
         return unsafe.Pointer((uintptr(p) + n - 1) &^ (n - 1))
 }
 
 // in stubs.goc
 func acquirem() *m
 func releasem(mp *m)
 
+// An mFunction represents a C function that runs on the M stack.  It
+// can be called from Go using mcall or onM.  Through the magic of
+// linking, an mFunction variable and the corresponding C code entry
+// point live at the same address.
+type mFunction byte
+
 // in asm_*.s
-func mcall(fn *byte)
-func onM(fn *byte)
+func mcall(fn *mFunction)
+func onM(fn *mFunction)
 
-// C routines that run on the M stack.  Call these like
-//   mcall(&mcacheRefill)
+// C functions that run on the M stack.  Call these like
+//   mcall(&mcacheRefill_m)
 // Arguments should be passed in m->scalararg[x] and
 // m->ptrarg[x].  Return values can be passed in those
 // same slots.
-var mcacheRefill byte
-var largeAlloc byte
-var mprofMalloc byte
-var mgc2 byte
-var setFinalizer byte
-var unrollgcprog byte
-var unrollgcproginplace byte
+var (
+        mcacheRefill_m,
+        largeAlloc_m,
+        mprofMalloc_m,
+        gc_m,
+        setFinalizer_m,
+        markallocated_m,
+        unrollgcprog_m,
+        unrollgcproginplace_m mFunction
+)
 
 // memclr clears n bytes starting at ptr.
 // in memclr_*.s
 func memclr(ptr unsafe.Pointer, n uintptr)
 
 func racemalloc(p unsafe.Pointer, size uintptr)
 func tracealloc(p unsafe.Pointer, size uintptr, typ *_type)
 
 // memmove copies n bytes from "from" to "to".
 // in memmove_*.s
 func memmove(to unsafe.Pointer, from unsafe.Pointer, n uintptr)
 
 // in asm_*.s
 func fastrand2() uint32
 
 const (
         gcpercentUnknown = -2
         concurrentSweep  = true
 )
 
-// in asm_*.s
+// Atomic operations to read/write a pointer.
+// in stubs.goc
+func goatomicloadp(p unsafe.Pointer) unsafe.Pointer     // return *p
+func goatomicstorep(p unsafe.Pointer, v unsafe.Pointer) // *p = v
+
+// in stubs.goc
 // if *p == x { *p = y; return true } else { return false }, atomically
 //go:noescape
 func gocas(p *uint32, x uint32, y uint32) bool
 
 //go:noescape
 func gocasx(p *uintptr, x uintptr, y uintptr) bool
 
 func goreadgogc() int32
 func gonanotime() int64
 func gosched()
@@ skipping 44 matching lines @@
 
 // noescape hides a pointer from escape analysis.  noescape is
 // the identity function but escape analysis doesn't think the
 // output depends on the input.  noescape is inlined and currently
 // compiles down to a single xor instruction.
 // USE CAREFULLY!
 func noescape(p unsafe.Pointer) unsafe.Pointer {
         x := uintptr(p)
         return unsafe.Pointer(x ^ 0)
 }