cmd/compile/internal/inline: score call sites exposed by inlines

[gostls13.git] / test / live_uintptrkeepalive.go

diff --git a/test/live_uintptrkeepalive.go b/test/live_uintptrkeepalive.go
index b920ff68aabbd96b37a0e8f07f23c3bdaf452c73..ae41101954b7d3b41b9ea7f3f3757ca0cb1032cf 100644 (file)
--- a/test/live_uintptrkeepalive.go
+++ b/test/live_uintptrkeepalive.go
@@ -1,12 +1,19 @@
-// errorcheck -0 -m -live
+// errorcheck -0 -m -live -std
 
-// +build !windows,!js
+//go:build !windows && !js && !wasip1
 
 // Copyright 2015 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.
 
-// Test escape analysis and liveness inferred for syscall.Syscall-like functions.
+// Test escape analysis and liveness inferred for uintptrkeepalive functions.
+//
+// This behavior is enabled automatically for function declarations with no
+// bodies (assembly, linkname), as well as explicitly on complete functions
+// with //go:uintptrkeepalive.
+//
+// This is most important for syscall.Syscall (and similar functions), so we
+// test it explicitly.
 
 package p
 
@@ -15,25 +22,41 @@ import (
        "unsafe"
 )
 
-func f(uintptr) // ERROR "assuming arg#1 is unsafe uintptr"
+func implicit(uintptr) // ERROR "assuming ~p0 is unsafe uintptr"
 
-func g() { // ERROR "can inline g"
+//go:uintptrkeepalive
+//go:nosplit
+func explicit(uintptr) {
+}
+
+func autotmpImplicit() { // ERROR "can inline autotmpImplicit"
+       var t int
+       implicit(uintptr(unsafe.Pointer(&t))) // ERROR "live at call to implicit: .?autotmp" "stack object .autotmp_[0-9]+ unsafe.Pointer$"
+}
+
+func autotmpExplicit() { // ERROR "can inline autotmpExplicit"
        var t int
-       f(uintptr(unsafe.Pointer(&t))) // ERROR "live at call to f: .?autotmp" "stack object .autotmp_[0-9]+ unsafe.Pointer$"
+       explicit(uintptr(unsafe.Pointer(&t))) // ERROR "live at call to explicit: .?autotmp" "stack object .autotmp_[0-9]+ unsafe.Pointer$"
 }
 
-func h() { // ERROR "can inline h"
+func autotmpSyscall() { // ERROR "can inline autotmpSyscall"
        var v int
        syscall.Syscall(0, 1, uintptr(unsafe.Pointer(&v)), 2) // ERROR "live at call to Syscall: .?autotmp" "stack object .autotmp_[0-9]+ unsafe.Pointer$"
 }
 
-func i() { // ERROR "can inline i"
+func localImplicit() { // ERROR "can inline localImplicit"
+       var t int
+       p := unsafe.Pointer(&t)
+       implicit(uintptr(p)) // ERROR "live at call to implicit: .?autotmp" "stack object .autotmp_[0-9]+ unsafe.Pointer$"
+}
+
+func localExplicit() { // ERROR "can inline localExplicit"
        var t int
        p := unsafe.Pointer(&t)
-       f(uintptr(p))           // ERROR "live at call to f: .?autotmp" "stack object .autotmp_[0-9]+ unsafe.Pointer$"
+       explicit(uintptr(p)) // ERROR "live at call to explicit: .?autotmp" "stack object .autotmp_[0-9]+ unsafe.Pointer$"
 }
 
-func j() { // ERROR "can inline j"
+func localSyscall() { // ERROR "can inline localSyscall"
        var v int
        p := unsafe.Pointer(&v)
        syscall.Syscall(0, 1, uintptr(p), 2) // ERROR "live at call to Syscall: .?autotmp" "stack object .autotmp_[0-9]+ unsafe.Pointer$"