1
2
3
4
5 package escape
6
7 import (
8 "fmt"
9 "go/constant"
10 "go/token"
11 "internal/goexperiment"
12 "slices"
13
14 "cmd/compile/internal/base"
15 "cmd/compile/internal/ir"
16 "cmd/compile/internal/logopt"
17 "cmd/compile/internal/typecheck"
18 "cmd/compile/internal/types"
19 "cmd/internal/src"
20 )
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92 type batch struct {
93 allLocs []*location
94 closures []closure
95 reassignOracles map[*ir.Func]*ir.ReassignOracle
96
97
98
99
100 staleOracles []*ir.ReassignOracle
101
102 heapLoc location
103 mutatorLoc location
104 calleeLoc location
105 blankLoc location
106 }
107
108
109
110 type closure struct {
111 k hole
112 clo *ir.ClosureExpr
113 }
114
115
116
117 type escape struct {
118 *batch
119
120 curfn *ir.Func
121
122 labels map[*types.Sym]labelState
123
124
125
126
127
128 loopDepth int
129 }
130
131 func Funcs(all []*ir.Func) {
132
133
134
135 reassignOracles := make(map[*ir.Func]*ir.ReassignOracle)
136
137 ir.VisitFuncsBottomUp(all, func(list []*ir.Func, recursive bool) {
138 Batch(list, reassignOracles)
139 })
140 }
141
142
143
144 func Batch(fns []*ir.Func, reassignOracles map[*ir.Func]*ir.ReassignOracle) {
145 var b batch
146 b.heapLoc.attrs = attrEscapes | attrPersists | attrMutates | attrCalls
147 b.mutatorLoc.attrs = attrMutates
148 b.calleeLoc.attrs = attrCalls
149 b.reassignOracles = reassignOracles
150
151
152 for _, fn := range fns {
153 if base.Flag.W > 1 {
154 s := fmt.Sprintf("\nbefore escape %v", fn)
155 ir.Dump(s, fn)
156 }
157 b.initFunc(fn)
158 }
159 for _, fn := range fns {
160 if !fn.IsClosure() {
161 b.walkFunc(fn)
162 }
163 }
164
165
166
167
168
169 for _, closure := range b.closures {
170 b.flowClosure(closure.k, closure.clo)
171 }
172 b.closures = nil
173 b.invalidateStaleOracles()
174
175 for _, loc := range b.allLocs {
176
177 b.rewriteWithLiterals(loc.n, loc.curfn)
178
179
180
181 if why := HeapAllocReason(loc.n); why != "" {
182 b.flow(b.heapHole().addr(loc.n, why), loc)
183 }
184 }
185
186 b.walkAll()
187 b.finish(fns)
188 }
189
190 func (b *batch) with(fn *ir.Func) *escape {
191 return &escape{
192 batch: b,
193 curfn: fn,
194 loopDepth: 1,
195 }
196 }
197
198 func (b *batch) initFunc(fn *ir.Func) {
199 e := b.with(fn)
200 if fn.Esc() != escFuncUnknown {
201 base.Fatalf("unexpected node: %v", fn)
202 }
203 fn.SetEsc(escFuncPlanned)
204 if base.Flag.LowerM > 3 {
205 ir.Dump("escAnalyze", fn)
206 }
207
208
209 for _, n := range fn.Dcl {
210 e.newLoc(n, true)
211 }
212
213
214
215 if fn.OClosure == nil {
216 for _, n := range fn.ClosureVars {
217 e.newLoc(n.Canonical(), true)
218 }
219 }
220
221
222 for i, f := range fn.Type().Results() {
223 e.oldLoc(f.Nname.(*ir.Name)).resultIndex = 1 + i
224 }
225 }
226
227 func (b *batch) walkFunc(fn *ir.Func) {
228 e := b.with(fn)
229 fn.SetEsc(escFuncStarted)
230
231
232 ir.Visit(fn, func(n ir.Node) {
233 switch n.Op() {
234 case ir.OLABEL:
235 n := n.(*ir.LabelStmt)
236 if n.Label.IsBlank() {
237 break
238 }
239 if e.labels == nil {
240 e.labels = make(map[*types.Sym]labelState)
241 }
242 e.labels[n.Label] = nonlooping
243
244 case ir.OGOTO:
245
246
247 n := n.(*ir.BranchStmt)
248 if e.labels[n.Label] == nonlooping {
249 e.labels[n.Label] = looping
250 }
251 }
252 })
253
254 e.block(fn.Body)
255
256 if len(e.labels) != 0 {
257 base.FatalfAt(fn.Pos(), "leftover labels after walkFunc")
258 }
259 }
260
261 func (b *batch) flowClosure(k hole, clo *ir.ClosureExpr) {
262 for _, cv := range clo.Func.ClosureVars {
263 n := cv.Canonical()
264 loc := b.oldLoc(cv)
265 if !loc.captured {
266 base.FatalfAt(cv.Pos(), "closure variable never captured: %v", cv)
267 }
268
269
270 n.SetByval(!loc.addrtaken && !loc.reassigned && n.Type().Size() <= 128)
271 if !n.Byval() {
272 n.SetAddrtaken(true)
273 if n.Sym().Name == typecheck.LocalDictName {
274 base.FatalfAt(n.Pos(), "dictionary variable not captured by value")
275 }
276 }
277 }
278
279
280
281 b.rewriteClosureVarsWithLiterals(clo.Func)
282
283 for _, cv := range clo.Func.ClosureVars {
284 n := cv.Canonical()
285 loc := b.oldLoc(cv)
286
287 if base.Flag.LowerM > 1 {
288 how := "ref"
289 if n.Byval() {
290 how = "value"
291 }
292 base.WarnfAt(n.Pos(), "%v capturing by %s: %v (addr=%v assign=%v width=%d)", n.Curfn, how, n, loc.addrtaken, loc.reassigned, n.Type().Size())
293 }
294
295
296 k := k
297 if !cv.Byval() {
298 k = k.addr(cv, "reference")
299 }
300 b.flow(k.note(cv, "captured by a closure"), loc)
301 }
302 }
303
304
305
306
307
308
309
310 func (b *batch) rewriteClosureVarsWithLiterals(clofn *ir.Func) {
311
312
313
314
315
316 if clofn.IsInlinedClosure() {
317 return
318 }
319
320 var ro *ir.ReassignOracle
321 var repl map[*ir.Name]*ir.Name
322 var prefix ir.Nodes
323
324 for _, cv := range clofn.ClosureVars {
325
326
327 if !cv.Byval() || !ir.ValidTypeForConst(cv.Type(), constant.MakeUnknown()) {
328 continue
329 }
330
331
332 if ro == nil {
333 ro = b.reassignOracle(clofn)
334 if ro == nil {
335 base.Fatalf("no ReassignOracle for function %v with closure parent %v", clofn, clofn.ClosureParent)
336 }
337 }
338 lit, ok := ro.StaticValue(cv).(*ir.BasicLit)
339 if !ok || !ir.ValidTypeForConst(cv.Type(), lit.Val()) {
340 continue
341 }
342 declPos := cv.Canonical().Pos()
343 if !base.LiteralAllocHash.MatchPos(declPos, nil) {
344
345 continue
346 }
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362 pos := clofn.Pos()
363 name := clofn.NewLocal(declPos, cv.Sym(), cv.Type())
364 name.SetUsed(true)
365 name.SetEsc(ir.EscNever)
366 as := typecheck.Stmt(clofn, ir.NewAssignStmt(pos, name, ir.NewBasicLit(pos, cv.Type(), lit.Val())))
367 prefix.Append(typecheck.Stmt(clofn, ir.NewDecl(pos, ir.ODCL, name)))
368 prefix.Append(as)
369 name.Defn = as.(*ir.AssignStmt)
370
371 if repl == nil {
372 repl = make(map[*ir.Name]*ir.Name)
373 }
374 repl[cv] = name
375
376 if base.Debug.EscapeDebug >= 3 {
377 base.WarnfAt(pos, "rewriting closure variable %v (%v) to %v", cv, cv.Type(), lit)
378 }
379 }
380
381 if repl == nil {
382 return
383 }
384
385
386 var edit func(ir.Node) ir.Node
387 edit = func(n ir.Node) ir.Node {
388 switch n := n.(type) {
389 case *ir.Name:
390 if name := repl[n]; name != nil {
391 return name
392 }
393 case *ir.ClosureExpr:
394
395
396
397
398
399
400 for _, cv := range n.Func.ClosureVars {
401 if name := repl[cv.Outer]; name != nil {
402 cv.Outer = name
403 }
404 }
405 }
406 ir.EditChildren(n, edit)
407 return n
408 }
409 ir.EditChildren(clofn, edit)
410
411 clofn.Body.Prepend(prefix...)
412 clofn.ClosureVars = slices.DeleteFunc(clofn.ClosureVars, func(cv *ir.Name) bool {
413 return repl[cv] != nil
414 })
415
416
417 b.staleOracles = append(b.staleOracles, ro)
418 }
419
420
421
422
423
424 func (b *batch) invalidateStaleOracles() {
425 if len(b.staleOracles) == 0 {
426 return
427 }
428
429 stale := make(map[*ir.ReassignOracle]bool, len(b.staleOracles))
430 for _, ro := range b.staleOracles {
431 stale[ro] = true
432 }
433 b.staleOracles = nil
434
435 for fn, ro := range b.reassignOracles {
436 if stale[ro] {
437 delete(b.reassignOracles, fn)
438 }
439 }
440 }
441
442 func (b *batch) finish(fns []*ir.Func) {
443
444 for _, fn := range fns {
445 fn.SetEsc(escFuncTagged)
446
447 for i, param := range fn.Type().RecvParams() {
448 param.Note = b.paramTag(fn, 1+i, param)
449 }
450 }
451
452 for _, loc := range b.allLocs {
453 n := loc.n
454 if n == nil {
455 continue
456 }
457
458 if n.Op() == ir.ONAME {
459 n := n.(*ir.Name)
460 n.Opt = nil
461 }
462
463
464
465
466
467
468 goDeferWrapper := n.Op() == ir.OCLOSURE && n.(*ir.ClosureExpr).Func.Wrapper()
469
470 if loc.hasAttr(attrEscapes) {
471 if n.Op() == ir.ONAME {
472 if base.Flag.CompilingRuntime {
473 base.ErrorfAt(n.Pos(), 0, "%v escapes to heap, not allowed in runtime", n)
474 }
475 if base.Flag.LowerM != 0 {
476 base.WarnfAt(n.Pos(), "moved to heap: %v", n)
477 }
478 } else {
479 if base.Flag.LowerM != 0 && !goDeferWrapper {
480 if n.Op() == ir.OAPPEND {
481 base.WarnfAt(n.Pos(), "append escapes to heap")
482 } else {
483 base.WarnfAt(n.Pos(), "%v escapes to heap", n)
484 }
485 }
486 if logopt.Enabled() {
487 var e_curfn *ir.Func
488 logopt.LogOpt(n.Pos(), "escape", "escape", ir.FuncName(e_curfn))
489 }
490 }
491 n.SetEsc(ir.EscHeap)
492 } else {
493 if base.Flag.LowerM != 0 && n.Op() != ir.ONAME && !goDeferWrapper {
494 if n.Op() == ir.OAPPEND {
495 base.WarnfAt(n.Pos(), "append does not escape")
496 } else {
497 base.WarnfAt(n.Pos(), "%v does not escape", n)
498 }
499 }
500 n.SetEsc(ir.EscNone)
501 if !loc.hasAttr(attrPersists) {
502 switch n.Op() {
503 case ir.OCLOSURE:
504 n := n.(*ir.ClosureExpr)
505 n.SetTransient(true)
506 case ir.OMETHVALUE:
507 n := n.(*ir.SelectorExpr)
508 n.SetTransient(true)
509 case ir.OSLICELIT:
510 n := n.(*ir.CompLitExpr)
511 n.SetTransient(true)
512 }
513 }
514 }
515
516
517
518 if base.Debug.ZeroCopy != 0 {
519 if n, ok := n.(*ir.ConvExpr); ok && n.Op() == ir.OSTR2BYTES && !loc.hasAttr(attrMutates) {
520 if base.Flag.LowerM >= 1 {
521 base.WarnfAt(n.Pos(), "zero-copy string->[]byte conversion")
522 }
523 n.SetOp(ir.OSTR2BYTESTMP)
524 }
525 }
526 }
527
528 if goexperiment.RuntimeFreegc {
529
530
531 for _, fn := range fns {
532 a := aliasAnalysis{}
533 a.analyze(fn)
534 }
535 }
536
537 for _, fn := range fns {
538 if ir.MatchAstDump(fn, "escape") {
539 ir.AstDump(fn, "escape, "+ir.FuncName(fn))
540 }
541 }
542 }
543
544
545
546
547
548
549 func (b *batch) inMutualBatch(fn *ir.Name) bool {
550 if fn.Defn != nil && fn.Defn.Esc() < escFuncTagged {
551 if fn.Defn.Esc() == escFuncUnknown {
552 base.FatalfAt(fn.Pos(), "graph inconsistency: %v", fn)
553 }
554 return true
555 }
556 return false
557 }
558
559 const (
560 escFuncUnknown = 0 + iota
561 escFuncPlanned
562 escFuncStarted
563 escFuncTagged
564 )
565
566
567 type labelState int
568
569 const (
570 looping labelState = 1 + iota
571 nonlooping
572 )
573
574 func (b *batch) paramTag(fn *ir.Func, narg int, f *types.Field) string {
575 name := func() string {
576 if f.Nname != nil {
577 return f.Nname.Sym().Name
578 }
579 return fmt.Sprintf("arg#%d", narg)
580 }
581
582
583
584
585 diagnose := base.Flag.LowerM != 0 && !(fn.Wrapper() || fn.Dupok())
586
587 if len(fn.Body) == 0 {
588
589
590
591
592
593
594 fn.Pragma |= ir.UintptrKeepAlive
595
596 if f.Type.IsUintptr() {
597 if diagnose {
598 base.WarnfAt(f.Pos, "assuming %v is unsafe uintptr", name())
599 }
600 return ""
601 }
602
603 if !f.Type.HasPointers() {
604 return ""
605 }
606
607 var esc leaks
608
609
610
611 if fn.Pragma&ir.Noescape != 0 {
612 if diagnose && f.Sym != nil {
613 base.WarnfAt(f.Pos, "%v does not escape", name())
614 }
615 esc.AddMutator(0)
616 esc.AddCallee(0)
617 } else {
618 if diagnose && f.Sym != nil {
619 base.WarnfAt(f.Pos, "leaking param: %v", name())
620 }
621 esc.AddHeap(0)
622 }
623
624 return esc.Encode()
625 }
626
627 if fn.Pragma&ir.UintptrEscapes != 0 {
628 if f.Type.IsUintptr() {
629 if diagnose {
630 base.WarnfAt(f.Pos, "marking %v as escaping uintptr", name())
631 }
632 return ""
633 }
634 if f.IsDDD() && f.Type.Elem().IsUintptr() {
635
636 if diagnose {
637 base.WarnfAt(f.Pos, "marking %v as escaping ...uintptr", name())
638 }
639 return ""
640 }
641 }
642
643 if !f.Type.HasPointers() {
644 return ""
645 }
646
647
648 if f.Sym == nil || f.Sym.IsBlank() {
649 var esc leaks
650 return esc.Encode()
651 }
652
653 n := f.Nname.(*ir.Name)
654 loc := b.oldLoc(n)
655 esc := loc.paramEsc
656 esc.Optimize()
657
658 if diagnose && !loc.hasAttr(attrEscapes) {
659 b.reportLeaks(f.Pos, name(), esc, fn.Type())
660 }
661
662 return esc.Encode()
663 }
664
665 func (b *batch) reportLeaks(pos src.XPos, name string, esc leaks, sig *types.Type) {
666 warned := false
667 if x := esc.Heap(); x >= 0 {
668 if x == 0 {
669 base.WarnfAt(pos, "leaking param: %v", name)
670 } else {
671
672 base.WarnfAt(pos, "leaking param content: %v", name)
673 }
674 warned = true
675 }
676 for i := 0; i < numEscResults; i++ {
677 if x := esc.Result(i); x >= 0 {
678 res := sig.Result(i).Nname.Sym().Name
679 base.WarnfAt(pos, "leaking param: %v to result %v level=%d", name, res, x)
680 warned = true
681 }
682 }
683
684 if base.Debug.EscapeMutationsCalls <= 0 {
685 if !warned {
686 base.WarnfAt(pos, "%v does not escape", name)
687 }
688 return
689 }
690
691 if x := esc.Mutator(); x >= 0 {
692 base.WarnfAt(pos, "mutates param: %v derefs=%v", name, x)
693 warned = true
694 }
695 if x := esc.Callee(); x >= 0 {
696 base.WarnfAt(pos, "calls param: %v derefs=%v", name, x)
697 warned = true
698 }
699
700 if !warned {
701 base.WarnfAt(pos, "%v does not escape, mutate, or call", name)
702 }
703 }
704
705
706
707 func (b *batch) rewriteWithLiterals(n ir.Node, fn *ir.Func) {
708 if n == nil || fn == nil {
709 return
710 }
711
712 assignTemp := func(pos src.XPos, n ir.Node, init *ir.Nodes) {
713
714 tmp := typecheck.TempAt(pos, fn, n.Type())
715 init.Append(typecheck.Stmt(fn, ir.NewDecl(pos, ir.ODCL, tmp)))
716 init.Append(typecheck.Stmt(fn, ir.NewAssignStmt(pos, tmp, n)))
717 }
718
719 switch n.Op() {
720 case ir.OMAKESLICE:
721
722
723 n := n.(*ir.MakeExpr)
724
725 r := &n.Cap
726 if n.Cap == nil {
727 r = &n.Len
728 }
729
730
731
732
733 if r == &n.Cap && ir.AnySideEffects(n.Len) {
734 return
735 }
736
737 if (*r).Op() != ir.OLITERAL {
738
739 ro := b.reassignOracle(fn)
740 if ro == nil {
741 base.Fatalf("no ReassignOracle for function %v with closure parent %v", fn, fn.ClosureParent)
742 }
743
744 s := ro.StaticValue(*r)
745 switch s.Op() {
746 case ir.OLITERAL:
747 lit, ok := s.(*ir.BasicLit)
748 if !ok || lit.Val().Kind() != constant.Int {
749 base.Fatalf("unexpected BasicLit Kind")
750 }
751 if constant.Compare(lit.Val(), token.GEQ, constant.MakeInt64(0)) {
752 if !base.LiteralAllocHash.MatchPos(n.Pos(), nil) {
753
754 return
755 }
756
757 assignTemp(n.Pos(), *r, n.PtrInit())
758 *r = ir.NewBasicLit(n.Pos(), (*r).Type(), lit.Val())
759 }
760 case ir.OLEN:
761 x := ro.StaticValue(s.(*ir.UnaryExpr).X)
762 if x.Op() == ir.OSLICELIT {
763 x := x.(*ir.CompLitExpr)
764
765 assignTemp(n.Pos(), *r, n.PtrInit())
766 *r = ir.NewBasicLit(n.Pos(), types.Types[types.TINT], constant.MakeInt64(x.Len))
767 }
768 }
769 }
770 case ir.OCONVIFACE:
771
772
773 conv := n.(*ir.ConvExpr)
774 if conv.X.Op() != ir.OLITERAL && !conv.X.Type().IsInterface() {
775
776
777 ro := b.reassignOracle(fn)
778 if ro == nil {
779 base.Fatalf("no ReassignOracle for function %v with closure parent %v", fn, fn.ClosureParent)
780 }
781 v := ro.StaticValue(conv.X)
782 if v != nil && v.Op() == ir.OLITERAL && ir.ValidTypeForConst(conv.X.Type(), v.Val()) {
783 if !base.LiteralAllocHash.MatchPos(n.Pos(), nil) {
784
785 return
786 }
787 if base.Debug.EscapeDebug >= 3 {
788 base.WarnfAt(n.Pos(), "rewriting OCONVIFACE value from %v (%v) to %v (%v)", conv.X, conv.X.Type(), v, v.Type())
789 }
790
791 assignTemp(conv.Pos(), conv.X, conv.PtrInit())
792 v := v.(*ir.BasicLit)
793 conv.X = ir.NewBasicLit(conv.Pos(), conv.X.Type(), v.Val())
794 typecheck.Expr(fn, conv)
795 }
796 }
797 }
798 }
799
800
801
802
803
804
805 func (b *batch) reassignOracle(fn *ir.Func) *ir.ReassignOracle {
806 if ro, ok := b.reassignOracles[fn]; ok {
807 return ro
808 }
809
810
811
812 f := fn
813 for f.ClosureParent != nil && !f.ClosureParent.IsPackageInit() {
814 f = f.ClosureParent
815 }
816
817 if f != fn {
818
819 ro := b.reassignOracles[f]
820 if ro != nil {
821
822 b.reassignOracles[fn] = ro
823 return ro
824 }
825 }
826
827
828 ro := &ir.ReassignOracle{}
829 ro.Init(f)
830
831
832 b.reassignOracles[fn] = ro
833 if f != fn {
834
835 b.reassignOracles[f] = ro
836 }
837 return ro
838 }
839
View as plain text