Mix checklocks and atomic analyzers.

This change makes the checklocks analyzer considerable more powerful, adding:
* The ability to traverse complex structures, e.g. to have multiple nested
  fields as part of the annotation.
* The ability to resolve simple anonymous functions and closures, and perform
  lock analysis across these invocations. This does not apply to closures that
  are passed elsewhere, since it is not possible to know the context in which
  they might be invoked.
* The ability to annotate return values in addition to receivers and other
  parameters, with the same complex structures noted above.
* Ignoring locking semantics for "fresh" objects, i.e. objects that are
  allocated in the local frame (typically a new-style function).
* Sanity checking of locking state across block transitions and returns, to
  ensure that no unexpected locks are held.

Note that initially, most of these findings are excluded by a comprehensive
nogo.yaml. The findings that are included are fundamental lock violations.
The changes here should be relatively low risk, minor refactorings to either
include necessary annotations to simplify the code structure (in general
removing closures in favor of methods) so that the analyzer can be easily
track the lock state.

This change additional includes two changes to nogo itself:
* Sanity checking of all types to ensure that the binary and ast-derived
  types have a consistent objectpath, to prevent the bug above from occurring
  silently (and causing much confusion). This also requires a trick in
  order to ensure that serialized facts are consumable downstream. This can
  be removed with https://go-review.googlesource.com/c/tools/+/331789 merged.
* A minor refactoring to isolation the objdump settings in its own package.
  This was originally used to implement the sanity check above, but this
  information is now being passed another way. The minor refactor is preserved
  however, since it cleans up the code slightly and is minimal risk.

PiperOrigin-RevId: 382613300

1 files changed, 100 insertions, 0 deletions

diff --git a/tools/checklocks/test/closures.go b/tools/checklocks/test/closures.go
new file mode 100644
index 000000000..7da87540a
--- /dev/null
+++ b/tools/checklocks/test/closures.go
@@ -0,0 +1,100 @@
+// Copyright 2020 The gVisor Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package test
+
+func testClosureInvalid(tc *oneGuardStruct) {
+	// This is expected to fail.
+	callClosure(func() {
+		tc.guardedField = 1 // +checklocksfail
+	})
+}
+
+func testClosureUnsupported(tc *oneGuardStruct) {
+	// Locked outside the closure, so may or may not be valid. This cannot
+	// be handled and we should explicitly fail. This can't be handled
+	// because of the call through callClosure, below, which means the
+	// closure will actually be passed as a value somewhere.
+	tc.mu.Lock()
+	callClosure(func() {
+		tc.guardedField = 1 // +checklocksfail
+	})
+	tc.mu.Unlock()
+}
+
+func testClosureValid(tc *oneGuardStruct) {
+	// All locking happens within the closure. This should not present a
+	// problem for analysis.
+	callClosure(func() {
+		tc.mu.Lock()
+		tc.guardedField = 1
+		tc.mu.Unlock()
+	})
+}
+
+func testClosureInline(tc *oneGuardStruct) {
+	// If the closure is being dispatching inline only, then we should be
+	// able to analyze this call and give it a thumbs up.
+	tc.mu.Lock()
+	func() {
+		tc.guardedField = 1
+	}()
+	tc.mu.Unlock()
+}
+
+func testAnonymousInvalid(tc *oneGuardStruct) {
+	// Invalid, as per testClosureInvalid above.
+	callAnonymous(func(tc *oneGuardStruct) {
+		tc.guardedField = 1 // +checklocksfail
+	}, tc)
+}
+
+func testAnonymousUnsupported(tc *oneGuardStruct) {
+	// Not supportable, as per testClosureUnsupported above.
+	tc.mu.Lock()
+	callAnonymous(func(tc *oneGuardStruct) {
+		tc.guardedField = 1 // +checklocksfail
+	}, tc)
+	tc.mu.Unlock()
+}
+
+func testAnonymousValid(tc *oneGuardStruct) {
+	// Valid, as per testClosureValid above.
+	callAnonymous(func(tc *oneGuardStruct) {
+		tc.mu.Lock()
+		tc.guardedField = 1
+		tc.mu.Unlock()
+	}, tc)
+}
+
+func testAnonymousInline(tc *oneGuardStruct) {
+	// Unlike the closure case, we are able to dynamically infer the set of
+	// preconditions for the function dispatch and assert that this is
+	// a valid call.
+	tc.mu.Lock()
+	func(tc *oneGuardStruct) {
+		tc.guardedField = 1
+	}(tc)
+	tc.mu.Unlock()
+}
+
+//go:noinline
+func callClosure(fn func()) {
+	fn()
+}
+
+//go:noinline
+func callAnonymous(fn func(*oneGuardStruct), tc *oneGuardStruct) {
+	fn(tc)
+}