Internal change.

PiperOrigin-RevId: 964616201

tools/checklocks/analysis.go

@@ -181,13 +181,31 @@ func (pc *passContext) checkAtomicCall(inst ssa.Instruction, obj types.Object, a
 }
 
 func resolveStruct(typ types.Type) (*types.Struct, bool) {
-	switch typ := typ.Underlying().(type) {
-	case *types.Struct:
-		return typ, true
-	case *types.Pointer:
-		return resolveStruct(typ.Elem())
+	if typ == nil {
+		return nil, false
+	}
+	// Most pointer chains are very short (<= 2).
+	// Use a small fixed array on stack to avoid allocation.
+	var buf [4]types.Type
+	visited := buf[:0]
+
+	for {
+		for _, v := range visited {
+			if v == typ {
+				return nil, false
+			}
+		}
+		visited = append(visited, typ)
+
+		switch u := typ.Underlying().(type) {
+		case *types.Struct:
+			return u, true
+		case *types.Pointer:
+			typ = u.Elem()
+		default:
+			return nil, false
+		}
 	}
-	return nil, false
 }
 
 func (pc *passContext) applyTypeAliases(ls *lockState, v ssa.Value) {

tools/checklocks/test/BUILD

@@ -15,6 +15,7 @@ go_library(
         "basics.go",
         "branches.go",
         "closures.go",
+        "cyclic.go",
         "defer.go",
         "generics.go",
         "globals.go",

tools/checklocks/test/cyclic.go

@@ -0,0 +1,60 @@
+// Copyright 2026 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
+
+import (
+	"sync"
+)
+
+// cyclicPointer is a self-referential type via pointer.
+type cyclicPointer struct {
+	mu   sync.Mutex
+	next *cyclicPointer
+	// +checklocks:mu
+	data int
+}
+
+func testCyclicPointerValid(c *cyclicPointer) {
+	c.mu.Lock()
+	c.data = 1
+	c.mu.Unlock()
+}
+
+func testCyclicPointerInvalid(c *cyclicPointer) {
+	c.data = 1 // +checklocksfail
+}
+
+// cyclicIndirect is a cyclic type via pointer to another type.
+type cyclicIndirect struct {
+	mu   sync.Mutex
+	impl *cyclicImpl
+	// +checklocks:mu
+	data int
+}
+
+// cyclicImpl is part of a cyclic type chain.
+type cyclicImpl struct {
+	parent *cyclicIndirect
+}
+
+func testCyclicIndirectValid(c *cyclicIndirect) {
+	c.mu.Lock()
+	c.data = 1
+	c.mu.Unlock()
+}
+
+func testCyclicIndirectInvalid(c *cyclicIndirect) {
+	c.data = 1 // +checklocksfail
+}