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

diff --git a/gcc/go/gofrontend/MERGE b/gcc/go/gofrontend/MERGE
index 51098e77954450cde69a07ca13505bc4aff141aa..8fc3878e3a2c03f72f47c9a6e78144cd671615dd 100644 (file)
--- 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 2c2ae1cf1c6a77062d653e70bc6a00dab8def20d..143f0a73df68f1783bbc4e4169864b0398dc0231 100644 (file)
--- 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 05be496450057445e43f53e90530e58d656c5323..e689b0e26169b1876d4149843ca8853855d2b6b3 100644 (file)
--- 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 7ddd378662421da1a219114ef5e336ecaf8a5568..b2c9ccb37ee17591853d264c0812c47ed4d4e3ce 100644 (file)
--- 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 d000b112f44448d83387e0e9a28e57d9cfd55870..b5cce6af58314e6750020d739ba6ef45e92adec1 100644 (file)
--- 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 c8d528474c515edcddf22b712f409bedde5e7196..523989e2181146991d50b852ad80b92cfb0c25c4 100644 (file)
--- 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 e9b39b2f4553fa0d3dc1dde971654d0996958e54..e90128bb6d412a866656713b42a949c28f186583 100644 (file)
--- 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 5826958dfd362389d73b3412777206e658769e5a..4c217cc1c0af1f1563f1c8e3513176a4124a5df8 100644 (file)
--- 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 bda2c694ac67ab79c47c3752b83f693d9f1a08a2..1d214454ed4d7ffaeb2a7d169b88490f4e7463e8 100644 (file)
--- 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 913ce5c014c283812cfc7f87578554784aeaf606..d8d231bae30d848e67a07157d347d75a974c9fa7 100644 (file)
--- 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 0ffcf4bde9e92cb6e79ea17ae22e0d55ebb1dd3d..0856618b4998f7df7d43b42555c0df26432ae9bd 100644 (file)
--- 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 **);