runtime: remove the dummy arg of getcallersp

    
    This is a port of https://golang.org/cl/109596 to the gofrontend, in
    preparation for updating libgo to 1.11.
    
    Original CL description:
    
        getcallersp is intrinsified, and so the dummy arg is no longer
        needed. Remove it, as well as a few dummy args that are solely
        to feed getcallersp.
    
    Reviewed-on: https://go-review.googlesource.com/131116

From-SVN: r263840

11 files changed, 40 insertions, 48 deletions

diff --git a/gcc/go/gofrontend/MERGE b/gcc/go/gofrontend/MERGE
index 51098e77954..8fc3878e3a2 100644
--- a/gcc/go/gofrontend/MERGE
+++ b/gcc/go/gofrontend/MERGE
@@ -1,4 +1,4 @@
-274c88df4d6f9360dcd657b6e069a3b5a1d37a90
+8deaafd14414bb5cbbdf3e2673f61b6d836d7d2a
 
 The first line of this file holds the git revision number of the last
 merge done from the gofrontend repository.
diff --git a/gcc/go/gofrontend/expressions.cc b/gcc/go/gofrontend/expressions.cc
index 2c2ae1cf1c6..143f0a73df6 100644
--- a/gcc/go/gofrontend/expressions.cc
+++ b/gcc/go/gofrontend/expressions.cc
@@ -9635,13 +9635,9 @@ Call_expression::do_lower(Gogo* gogo, Named_object* function,
 					    "__builtin_return_address",
 					    0);
 	    }
-	  else if (this->args_ != NULL
-		   && this->args_->size() == 1
+	  else if ((this->args_ == NULL || this->args_->size() == 0)
 		   && n == "getcallersp")
 	    {
-	      // The actual argument to getcallersp is always the
-	      // address of a parameter; we don't need that for the
-	      // GCC builtin function, so we just ignore it.
 	      static Named_object* builtin_frame_address;
 	      return this->lower_to_builtin(&builtin_frame_address,
 					    "__builtin_frame_address",
diff --git a/libgo/go/runtime/cgo_gccgo.go b/libgo/go/runtime/cgo_gccgo.go
index 05be4964500..e689b0e2616 100644
--- a/libgo/go/runtime/cgo_gccgo.go
+++ b/libgo/go/runtime/cgo_gccgo.go
@@ -47,7 +47,7 @@ func Cgocall() {
 	mp := getg().m
 	mp.ncgocall++
 	mp.ncgo++
-	entersyscall(0)
+	entersyscall()
 	mp.incgo = true
 }
 
@@ -63,7 +63,7 @@ func CgocallDone() {
 	// If we are invoked because the C function called _cgo_panic,
 	// then _cgo_panic will already have exited syscall mode.
 	if readgstatus(gp)&^_Gscan == _Gsyscall {
-		exitsyscall(0)
+		exitsyscall()
 	}
 }
 
@@ -84,7 +84,7 @@ func CgocallBack() {
 
 	lockOSThread()
 
-	exitsyscall(0)
+	exitsyscall()
 	gp.m.incgo = false
 
 	if gp.m.ncgo == 0 {
@@ -134,7 +134,7 @@ func CgocallBackDone() {
 	}
 
 	gp.m.incgo = true
-	entersyscall(0)
+	entersyscall()
 
 	if drop {
 		mp.dropextram = false
@@ -144,7 +144,7 @@ func CgocallBackDone() {
 
 // _cgo_panic may be called by SWIG code to panic.
 func _cgo_panic(p *byte) {
-	exitsyscall(0)
+	exitsyscall()
 	panic(gostringnocopy(p))
 }
 
diff --git a/libgo/go/runtime/lock_futex.go b/libgo/go/runtime/lock_futex.go
index 7ddd3786624..b2c9ccb37ee 100644
--- a/libgo/go/runtime/lock_futex.go
+++ b/libgo/go/runtime/lock_futex.go
@@ -236,8 +236,8 @@ func notetsleepg(n *note, ns int64) bool {
 		throw("notetsleepg on g0")
 	}
 
-	entersyscallblock(0)
+	entersyscallblock()
 	ok := notetsleep_internal(n, ns)
-	exitsyscall(0)
+	exitsyscall()
 	return ok
 }
diff --git a/libgo/go/runtime/lock_sema.go b/libgo/go/runtime/lock_sema.go
index d000b112f44..b5cce6af583 100644
--- a/libgo/go/runtime/lock_sema.go
+++ b/libgo/go/runtime/lock_sema.go
@@ -289,8 +289,8 @@ func notetsleepg(n *note, ns int64) bool {
 		throw("notetsleepg on g0")
 	}
 	semacreate(gp.m)
-	entersyscallblock(0)
+	entersyscallblock()
 	ok := notetsleep_internal(n, ns, nil, 0)
-	exitsyscall(0)
+	exitsyscall()
 	return ok
 }
diff --git a/libgo/go/runtime/malloc.go b/libgo/go/runtime/malloc.go
index c8d528474c5..523989e2181 100644
--- a/libgo/go/runtime/malloc.go
+++ b/libgo/go/runtime/malloc.go
@@ -621,7 +621,7 @@ func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 	// callback.
 	incallback := false
 	if gomcache() == nil && getg().m.ncgo > 0 {
-		exitsyscall(0)
+		exitsyscall()
 		incallback = true
 	}
 
@@ -709,7 +709,7 @@ func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 				mp.mallocing = 0
 				releasem(mp)
 				if incallback {
-					entersyscall(0)
+					entersyscall()
 				}
 				return x
 			}
@@ -835,7 +835,7 @@ func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
 	}
 
 	if incallback {
-		entersyscall(0)
+		entersyscall()
 	}
 
 	return x
diff --git a/libgo/go/runtime/norace_test.go b/libgo/go/runtime/norace_test.go
index e9b39b2f455..e90128bb6d4 100644
--- a/libgo/go/runtime/norace_test.go
+++ b/libgo/go/runtime/norace_test.go
@@ -34,12 +34,12 @@ func benchmarkSyscall(b *testing.B, work, excess int) {
 	b.RunParallel(func(pb *testing.PB) {
 		foo := 42
 		for pb.Next() {
-			runtime.Entersyscall(0)
+			runtime.Entersyscall()
 			for i := 0; i < work; i++ {
 				foo *= 2
 				foo /= 2
 			}
-			runtime.Exitsyscall(0)
+			runtime.Exitsyscall()
 		}
 		_ = foo
 	})
diff --git a/libgo/go/runtime/proc.go b/libgo/go/runtime/proc.go
index 5826958dfd3..4c217cc1c0a 100644
--- a/libgo/go/runtime/proc.go
+++ b/libgo/go/runtime/proc.go
@@ -1168,7 +1168,7 @@ func kickoff() {
 	goexit1()
 }
 
-func mstart1(dummy int32) {
+func mstart1() {
 	_g_ := getg()
 
 	if _g_ != _g_.m.g0 {
@@ -2774,7 +2774,7 @@ func entersyscallblock_handoff() {
 //
 //go:nosplit
 //go:nowritebarrierrec
-func exitsyscall(dummy int32) {
+func exitsyscall() {
 	_g_ := getg()
 
 	_g_.m.locks++ // see comment in entersyscall
@@ -2984,13 +2984,13 @@ func exitsyscallclear(gp *g) {
 //go:linkname syscall_entersyscall syscall.Entersyscall
 //go:nosplit
 func syscall_entersyscall() {
-	entersyscall(0)
+	entersyscall()
 }
 
 //go:linkname syscall_exitsyscall syscall.Exitsyscall
 //go:nosplit
 func syscall_exitsyscall() {
-	exitsyscall(0)
+	exitsyscall()
 }
 
 func beforefork() {
diff --git a/libgo/go/runtime/stubs.go b/libgo/go/runtime/stubs.go
index bda2c694ac6..1d214454ed4 100644
--- a/libgo/go/runtime/stubs.go
+++ b/libgo/go/runtime/stubs.go
@@ -199,16 +199,14 @@ func publicationBarrier()
 // getcallerpc returns the program counter (PC) of its caller's caller.
 // getcallersp returns the stack pointer (SP) of its caller's caller.
 // argp must be a pointer to the caller's first function argument.
-// The implementation may or may not use argp, depending on
-// the architecture. The implementation may be a compiler
-// intrinsic; there is not necessarily code implementing this
-// on every platform.
+// The implementation may be a compiler intrinsic; there is not
+// necessarily code implementing this on every platform.
 //
 // For example:
 //
 //	func f(arg1, arg2, arg3 int) {
 //		pc := getcallerpc()
-//		sp := getcallersp(unsafe.Pointer(&arg1))
+//		sp := getcallersp()
 //	}
 //
 // These two lines find the PC and SP immediately following
@@ -230,7 +228,7 @@ func publicationBarrier()
 func getcallerpc() uintptr
 
 //go:noescape
-func getcallersp(argp unsafe.Pointer) uintptr
+func getcallersp() uintptr
 
 func asmcgocall(fn, arg unsafe.Pointer) int32 {
 	throw("asmcgocall")
@@ -309,9 +307,9 @@ func setSupportAES(v bool) {
 // Here for gccgo.
 func errno() int
 
-// Temporary for gccgo until we port proc.go.
-func entersyscall(int32)
-func entersyscallblock(int32)
+// For gccgo these are written in C.
+func entersyscall()
+func entersyscallblock()
 
 // For gccgo to call from C code, so that the C code and the Go code
 // can share the memstats variable for now.
diff --git a/libgo/runtime/proc.c b/libgo/runtime/proc.c
index 913ce5c014c..d8d231bae30 100644
--- a/libgo/runtime/proc.c
+++ b/libgo/runtime/proc.c
@@ -382,7 +382,7 @@ extern void kickoff(void)
   __asm__(GOSYM_PREFIX "runtime.kickoff");
 extern void minit(void)
   __asm__(GOSYM_PREFIX "runtime.minit");
-extern void mstart1(int32)
+extern void mstart1()
   __asm__(GOSYM_PREFIX "runtime.mstart1");
 extern void stopm(void)
   __asm__(GOSYM_PREFIX "runtime.stopm");
@@ -542,7 +542,7 @@ runtime_mstart(void *arg)
 	}
 #endif
 
-	mstart1(0);
+	mstart1();
 
 	// mstart1 does not return, but we need a return statement
 	// here to avoid a compiler warning.
@@ -621,12 +621,12 @@ makeGContext(G* gp, byte* sp, uintptr spsize) {
 // make g->sched refer to the caller's stack segment, because
 // entersyscall is going to return immediately after.
 
-void runtime_entersyscall(int32) __attribute__ ((no_split_stack));
+void runtime_entersyscall() __attribute__ ((no_split_stack));
 static void doentersyscall(uintptr, uintptr)
   __attribute__ ((no_split_stack, noinline));
 
 void
-runtime_entersyscall(int32 dummy __attribute__ ((unused)))
+runtime_entersyscall()
 {
 	// Save the registers in the g structure so that any pointers
 	// held in registers will be seen by the garbage collector.
@@ -638,8 +638,8 @@ runtime_entersyscall(int32 dummy __attribute__ ((unused)))
 	// callee-saved registers to access the TLS variable g.  We
 	// don't want to put the ucontext_t on the stack because it is
 	// large and we can not split the stack here.
-	doentersyscall((uintptr)runtime_getcallerpc(&dummy),
-		       (uintptr)runtime_getcallersp(&dummy));
+	doentersyscall((uintptr)runtime_getcallerpc(),
+		       (uintptr)runtime_getcallersp());
 }
 
 static void
@@ -672,15 +672,15 @@ static void doentersyscallblock(uintptr, uintptr)
 
 // The same as runtime_entersyscall(), but with a hint that the syscall is blocking.
 void
-runtime_entersyscallblock(int32 dummy __attribute__ ((unused)))
+runtime_entersyscallblock()
 {
 	// Save the registers in the g structure so that any pointers
 	// held in registers will be seen by the garbage collector.
 	getcontext(ucontext_arg(&g->gcregs[0]));
 
 	// See comment in runtime_entersyscall.
-	doentersyscallblock((uintptr)runtime_getcallerpc(&dummy),
-			    (uintptr)runtime_getcallersp(&dummy));
+	doentersyscallblock((uintptr)runtime_getcallerpc(),
+			    (uintptr)runtime_getcallersp());
 }
 
 static void
diff --git a/libgo/runtime/runtime.h b/libgo/runtime/runtime.h
index 0ffcf4bde9e..0856618b499 100644
--- a/libgo/runtime/runtime.h
+++ b/libgo/runtime/runtime.h
@@ -268,7 +268,7 @@ void*	runtime_sysAlloc(uintptr, uint64*)
 void	runtime_sysFree(void*, uintptr, uint64*)
   __asm__ (GOSYM_PREFIX "runtime.sysFree");
 void	runtime_mprofinit(void);
-#define runtime_getcallersp(p) __builtin_frame_address(0)
+#define runtime_getcallersp() __builtin_frame_address(0)
 void	runtime_mcall(FuncVal*)
   __asm__ (GOSYM_PREFIX "runtime.mcall");
 int32	runtime_timediv(int64, int32, int32*)
@@ -305,12 +305,10 @@ void	runtime_schedtrace(bool)
 void	runtime_goparkunlock(Lock*, String, byte, intgo)
   __asm__ (GOSYM_PREFIX "runtime.goparkunlock");
 void	runtime_tsleep(int64, const char*);
-void	runtime_entersyscall(int32)
+void	runtime_entersyscall()
   __asm__ (GOSYM_PREFIX "runtime.entersyscall");
-void	runtime_entersyscallblock(int32)
+void	runtime_entersyscallblock()
   __asm__ (GOSYM_PREFIX "runtime.entersyscallblock");
-void	runtime_exitsyscall(int32)
-  __asm__ (GOSYM_PREFIX "runtime.exitsyscall");
 G*	__go_go(void (*pfn)(void*), void*);
 int32	runtime_callers(int32, Location*, int32, bool keep_callers);
 int64	runtime_nanotime(void)	// monotonic time
@@ -385,7 +383,7 @@ bool	runtime_notetsleepg(Note*, int64)  // false - timeout
 #define runtime_munmap munmap
 #define runtime_madvise madvise
 #define runtime_memclr(buf, size) __builtin_memset((buf), 0, (size))
-#define runtime_getcallerpc(p) __builtin_return_address(0)
+#define runtime_getcallerpc() __builtin_return_address(0)
 
 #ifdef __rtems__
 void __wrap_rtems_task_variable_add(void **);