runtime: get rid of other Go->C calls in test exports.

testSchedLocal* tests need to malloc now because their
stack frames are too big to fit on the G0 stack.

LGTM=iant
R=golang-codereviews, iant, khr
CC=golang-codereviews
https://golang.org/cl/133660043

misc/cgo/test/backdoor/runtime.c

@@ -10,20 +10,6 @@
 
 typedef char bool;
 
-bool runtime·lockedOSThread(void);
-
-static void
-FLUSH(void*)
-{
-}
-
-void
-·LockedOSThread(bool b)
-{
-	b = runtime·lockedOSThread();
-	FLUSH(&b);
-}
-
 // This is what a cgo-compiled stub declaration looks like.
 void
 ·Issue7695(struct{void *y[8*sizeof(void*)];}p)

misc/cgo/test/backdoor/thunk.s

@@ -0,0 +1,16 @@
+// 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.
+
+// Assembly to get into package runtime without using exported symbols.
+
+// +build amd64 amd64p32 arm 386
+
+#include "textflag.h"
+
+#ifdef GOARCH_arm
+#define JMP B
+#endif
+
+TEXT ·LockedOSThread(SB),NOSPLIT,$0-0
+	JMP	runtime·lockedOSThread(SB)

src/pkg/runtime/export_test.go

@@ -18,7 +18,7 @@ var Fcmp64 = fcmp64
 var Fintto64 = fintto64
 var F64toint = f64toint
 
-func lockedOSThread() bool
+// in asm_*.s
 func stackguard() (sp, limit uintptr)
 
 var Entersyscall = entersyscall
@@ -127,9 +127,12 @@ func GCMask(x interface{}) (ret []byte) {
 
 func testSchedLocalQueue()
 func testSchedLocalQueueSteal()
-
-var TestSchedLocalQueue1 = testSchedLocalQueue
-var TestSchedLocalQueueSteal1 = testSchedLocalQueueSteal
+func RunSchedLocalQueueTest() {
+	onM(testSchedLocalQueue)
+}
+func RunSchedLocalQueueStealTest() {
+	onM(testSchedLocalQueueSteal)
+}
 
 var HaveGoodHash = haveGoodHash
 var StringHash = stringHash

src/pkg/runtime/proc.c

@@ -2594,12 +2594,6 @@ badunlockOSThread(void)
 	runtime·throw("runtime: internal error: misuse of lockOSThread/unlockOSThread");
 }
 
-bool
-runtime·lockedOSThread(void)
-{
-	return g->lockedm != nil && g->m->lockedg != nil;
-}
-
 #pragma textflag NOSPLIT
 int32
 runtime·gcount(void)
@@ -3552,54 +3546,56 @@ runqsteal(P *p, P *p2)
 void
 runtime·testSchedLocalQueue(void)
 {
-	P p;
-	G gs[nelem(p.runq)];
+	P *p;
+	G *gs;
 	int32 i, j;
 
-	runtime·memclr((byte*)&p, sizeof(p));
+	p = (P*)runtime·mallocgc(sizeof(*p), nil, FlagNoScan);
+	gs = (G*)runtime·mallocgc(nelem(p->runq)*sizeof(*gs), nil, FlagNoScan);
 
-	for(i = 0; i < nelem(gs); i++) {
-		if(runqget(&p) != nil)
+	for(i = 0; i < nelem(p->runq); i++) {
+		if(runqget(p) != nil)
 			runtime·throw("runq is not empty initially");
 		for(j = 0; j < i; j++)
-			runqput(&p, &gs[i]);
+			runqput(p, &gs[i]);
 		for(j = 0; j < i; j++) {
-			if(runqget(&p) != &gs[i]) {
+			if(runqget(p) != &gs[i]) {
 				runtime·printf("bad element at iter %d/%d\n", i, j);
 				runtime·throw("bad element");
 			}
 		}
-		if(runqget(&p) != nil)
+		if(runqget(p) != nil)
 			runtime·throw("runq is not empty afterwards");
 	}
 }
 
 void
 runtime·testSchedLocalQueueSteal(void)
 {
-	P p1, p2;
-	G gs[nelem(p1.runq)], *gp;
+	P *p1, *p2;
+	G *gs, *gp;
 	int32 i, j, s;
 
-	runtime·memclr((byte*)&p1, sizeof(p1));
-	runtime·memclr((byte*)&p2, sizeof(p2));
+	p1 = (P*)runtime·mallocgc(sizeof(*p1), nil, FlagNoScan);
+	p2 = (P*)runtime·mallocgc(sizeof(*p2), nil, FlagNoScan);
+	gs = (G*)runtime·mallocgc(nelem(p1->runq)*sizeof(*gs), nil, FlagNoScan);
 
-	for(i = 0; i < nelem(gs); i++) {
+	for(i = 0; i < nelem(p1->runq); i++) {
 		for(j = 0; j < i; j++) {
 			gs[j].sig = 0;
-			runqput(&p1, &gs[j]);
+			runqput(p1, &gs[j]);
 		}
-		gp = runqsteal(&p2, &p1);
+		gp = runqsteal(p2, p1);
 		s = 0;
 		if(gp) {
 			s++;
 			gp->sig++;
 		}
-		while(gp = runqget(&p2)) {
+		while(gp = runqget(p2)) {
 			s++;
 			gp->sig++;
 		}
-		while(gp = runqget(&p1))
+		while(gp = runqget(p1))
 			gp->sig++;
 		for(j = 0; j < i; j++) {
 			if(gs[j].sig != 1) {

src/pkg/runtime/proc.go

@@ -100,3 +100,8 @@ func badmcall(fn func(*g)) {
 func badmcall2(fn func(*g)) {
 	gothrow("runtime: mcall function returned")
 }
+
+func lockedOSThread() bool {
+	gp := getg()
+	return gp.lockedm != nil && gp.m.lockedg != nil
+}

src/pkg/runtime/proc_test.go

@@ -366,11 +366,11 @@ func nonleaf(stop chan int) bool {
 }
 
 func TestSchedLocalQueue(t *testing.T) {
-	runtime.TestSchedLocalQueue1()
+	runtime.RunSchedLocalQueueTest()
 }
 
 func TestSchedLocalQueueSteal(t *testing.T) {
-	runtime.TestSchedLocalQueueSteal1()
+	runtime.RunSchedLocalQueueStealTest()
 }
 
 func benchmarkStackGrowth(b *testing.B, rec int) {

src/pkg/runtime/runtime.h

@@ -1060,7 +1060,6 @@ void	runtime·procyield(uint32);
 void	runtime·osyield(void);
 void	runtime·lockOSThread(void);
 void	runtime·unlockOSThread(void);
-bool	runtime·lockedOSThread(void);
 
 bool	runtime·showframe(Func*, G*);
 void	runtime·printcreatedby(G*);