1 // errorcheck -0 -m -l 2 3 // Copyright 2010 The Go Authors. All rights reserved. 4 // Use of this source code is governed by a BSD-style 5 // license that can be found in the LICENSE file. 6 7 // Test, using compiler diagnostic flags, that the escape analysis is working. 8 // Compiles but does not run. Inlining is disabled. 9 10 // escape2n.go contains all the same tests but compiles with -N. 11 12 package foo 13 14 import ( 15 "fmt" 16 "unsafe" 17 ) 18 19 var gxx *int 20 21 func foo1(x int) { // ERROR "moved to heap: x$" 22 gxx = &x // ERROR "&x escapes to heap$" 23 } 24 25 func foo2(yy *int) { // ERROR "leaking param: yy$" 26 gxx = yy 27 } 28 29 func foo3(x int) *int { // ERROR "moved to heap: x$" 30 return &x // ERROR "&x escapes to heap$" 31 } 32 33 type T *T 34 35 func foo3b(t T) { // ERROR "leaking param: t$" 36 *t = t 37 } 38 39 // xx isn't going anywhere, so use of yy is ok 40 func foo4(xx, yy *int) { // ERROR "foo4 xx does not escape$" "foo4 yy does not escape$" 41 xx = yy 42 } 43 44 // xx isn't going anywhere, so taking address of yy is ok 45 func foo5(xx **int, yy *int) { // ERROR "foo5 xx does not escape$" "foo5 yy does not escape$" 46 xx = &yy // ERROR "foo5 &yy does not escape$" 47 } 48 49 func foo6(xx **int, yy *int) { // ERROR "foo6 xx does not escape$" "leaking param: yy$" 50 *xx = yy 51 } 52 53 func foo7(xx **int, yy *int) { // ERROR "foo7 xx does not escape$" "foo7 yy does not escape$" 54 **xx = *yy 55 } 56 57 func foo8(xx, yy *int) int { // ERROR "foo8 xx does not escape$" "foo8 yy does not escape$" 58 xx = yy 59 return *xx 60 } 61 62 func foo9(xx, yy *int) *int { // ERROR "leaking param: xx to result ~r2 level=0$" "leaking param: yy to result ~r2 level=0$" 63 xx = yy 64 return xx 65 } 66 67 func foo10(xx, yy *int) { // ERROR "foo10 xx does not escape$" "foo10 yy does not escape$" 68 *xx = *yy 69 } 70 71 func foo11() int { 72 x, y := 0, 42 73 xx := &x // ERROR "foo11 &x does not escape$" 74 yy := &y // ERROR "foo11 &y does not escape$" 75 *xx = *yy 76 return x 77 } 78 79 var xxx **int 80 81 func foo12(yyy **int) { // ERROR "leaking param: yyy$" 82 xxx = yyy 83 } 84 85 // Must treat yyy as leaking because *yyy leaks, and the escape analysis 86 // summaries in exported metadata do not distinguish these two cases. 87 func foo13(yyy **int) { // ERROR "leaking param content: yyy$" 88 *xxx = *yyy 89 } 90 91 func foo14(yyy **int) { // ERROR "foo14 yyy does not escape$" 92 **xxx = **yyy 93 } 94 95 func foo15(yy *int) { // ERROR "moved to heap: yy$" 96 xxx = &yy // ERROR "&yy escapes to heap$" 97 } 98 99 func foo16(yy *int) { // ERROR "leaking param: yy$" 100 *xxx = yy 101 } 102 103 func foo17(yy *int) { // ERROR "foo17 yy does not escape$" 104 **xxx = *yy 105 } 106 107 func foo18(y int) { // ERROR "moved to heap: y$" 108 *xxx = &y // ERROR "&y escapes to heap$" 109 } 110 111 func foo19(y int) { 112 **xxx = y 113 } 114 115 type Bar struct { 116 i int 117 ii *int 118 } 119 120 func NewBar() *Bar { 121 return &Bar{42, nil} // ERROR "&Bar literal escapes to heap$" 122 } 123 124 func NewBarp(x *int) *Bar { // ERROR "leaking param: x to result ~r1 level=-1$" 125 return &Bar{42, x} // ERROR "&Bar literal escapes to heap$" 126 } 127 128 func NewBarp2(x *int) *Bar { // ERROR "NewBarp2 x does not escape$" 129 return &Bar{*x, nil} // ERROR "&Bar literal escapes to heap$" 130 } 131 132 func (b *Bar) NoLeak() int { // ERROR "\(\*Bar\).NoLeak b does not escape$" 133 return *(b.ii) 134 } 135 136 func (b *Bar) Leak() *int { // ERROR "leaking param: b to result ~r0 level=0$" 137 return &b.i // ERROR "&b.i escapes to heap$" 138 } 139 140 func (b *Bar) AlsoNoLeak() *int { // ERROR "leaking param: b to result ~r0 level=1$" 141 return b.ii 142 } 143 144 func (b Bar) AlsoLeak() *int { // ERROR "leaking param: b to result ~r0 level=0$" 145 return b.ii 146 } 147 148 func (b Bar) LeaksToo() *int { // ERROR "leaking param: b to result ~r0 level=0$" 149 v := 0 // ERROR "moved to heap: v$" 150 b.ii = &v // ERROR "&v escapes to heap$" 151 return b.ii 152 } 153 154 func (b *Bar) LeaksABit() *int { // ERROR "leaking param: b to result ~r0 level=1$" 155 v := 0 // ERROR "moved to heap: v$" 156 b.ii = &v // ERROR "&v escapes to heap$" 157 return b.ii 158 } 159 160 func (b Bar) StillNoLeak() int { // ERROR "Bar.StillNoLeak b does not escape$" 161 v := 0 162 b.ii = &v // ERROR "Bar.StillNoLeak &v does not escape$" 163 return b.i 164 } 165 166 func goLeak(b *Bar) { // ERROR "leaking param: b$" 167 go b.NoLeak() 168 } 169 170 type Bar2 struct { 171 i [12]int 172 ii []int 173 } 174 175 func NewBar2() *Bar2 { 176 return &Bar2{[12]int{42}, nil} // ERROR "&Bar2 literal escapes to heap$" 177 } 178 179 func (b *Bar2) NoLeak() int { // ERROR "\(\*Bar2\).NoLeak b does not escape$" 180 return b.i[0] 181 } 182 183 func (b *Bar2) Leak() []int { // ERROR "leaking param: b to result ~r0 level=0$" 184 return b.i[:] // ERROR "b.i escapes to heap$" 185 } 186 187 func (b *Bar2) AlsoNoLeak() []int { // ERROR "leaking param: b to result ~r0 level=1$" 188 return b.ii[0:1] 189 } 190 191 func (b Bar2) AgainNoLeak() [12]int { // ERROR "Bar2.AgainNoLeak b does not escape$" 192 return b.i 193 } 194 195 func (b *Bar2) LeakSelf() { // ERROR "leaking param: b$" 196 b.ii = b.i[0:4] // ERROR "b.i escapes to heap$" 197 } 198 199 func (b *Bar2) LeakSelf2() { // ERROR "leaking param: b$" 200 var buf []int 201 buf = b.i[0:] // ERROR "b.i escapes to heap$" 202 b.ii = buf 203 } 204 205 func foo21() func() int { 206 x := 42 207 return func() int { // ERROR "func literal escapes to heap$" 208 return x 209 } 210 } 211 212 func foo21a() func() int { 213 x := 42 // ERROR "moved to heap: x$" 214 return func() int { // ERROR "func literal escapes to heap$" 215 x++ // ERROR "&x escapes to heap$" 216 return x 217 } 218 } 219 220 func foo22() int { 221 x := 42 222 return func() int { // ERROR "foo22 func literal does not escape$" 223 return x 224 }() 225 } 226 227 func foo23(x int) func() int { 228 return func() int { // ERROR "func literal escapes to heap$" 229 return x 230 } 231 } 232 233 func foo23a(x int) func() int { 234 f := func() int { // ERROR "func literal escapes to heap$" 235 return x 236 } 237 return f 238 } 239 240 func foo23b(x int) *(func() int) { 241 f := func() int { return x } // ERROR "func literal escapes to heap$" "moved to heap: f$" 242 return &f // ERROR "&f escapes to heap$" 243 } 244 245 func foo23c(x int) func() int { // ERROR "moved to heap: x$" 246 return func() int { // ERROR "func literal escapes to heap$" 247 x++ // ERROR "&x escapes to heap$" 248 return x 249 } 250 } 251 252 func foo24(x int) int { 253 return func() int { // ERROR "foo24 func literal does not escape$" 254 return x 255 }() 256 } 257 258 var x *int 259 260 func fooleak(xx *int) int { // ERROR "leaking param: xx$" 261 x = xx 262 return *x 263 } 264 265 func foonoleak(xx *int) int { // ERROR "foonoleak xx does not escape$" 266 return *x + *xx 267 } 268 269 func foo31(x int) int { // ERROR "moved to heap: x$" 270 return fooleak(&x) // ERROR "&x escapes to heap$" 271 } 272 273 func foo32(x int) int { 274 return foonoleak(&x) // ERROR "foo32 &x does not escape$" 275 } 276 277 type Foo struct { 278 xx *int 279 x int 280 } 281 282 var F Foo 283 var pf *Foo 284 285 func (f *Foo) fooleak() { // ERROR "leaking param: f$" 286 pf = f 287 } 288 289 func (f *Foo) foonoleak() { // ERROR "\(\*Foo\).foonoleak f does not escape$" 290 F.x = f.x 291 } 292 293 func (f *Foo) Leak() { // ERROR "leaking param: f$" 294 f.fooleak() 295 } 296 297 func (f *Foo) NoLeak() { // ERROR "\(\*Foo\).NoLeak f does not escape$" 298 f.foonoleak() 299 } 300 301 func foo41(x int) { // ERROR "moved to heap: x$" 302 F.xx = &x // ERROR "&x escapes to heap$" 303 } 304 305 func (f *Foo) foo42(x int) { // ERROR "\(\*Foo\).foo42 f does not escape$" "moved to heap: x$" 306 f.xx = &x // ERROR "&x escapes to heap$" 307 } 308 309 func foo43(f *Foo, x int) { // ERROR "foo43 f does not escape$" "moved to heap: x$" 310 f.xx = &x // ERROR "&x escapes to heap$" 311 } 312 313 func foo44(yy *int) { // ERROR "leaking param: yy$" 314 F.xx = yy 315 } 316 317 func (f *Foo) foo45() { // ERROR "\(\*Foo\).foo45 f does not escape$" 318 F.x = f.x 319 } 320 321 // See foo13 above for explanation of why f leaks. 322 func (f *Foo) foo46() { // ERROR "leaking param content: f$" 323 F.xx = f.xx 324 } 325 326 func (f *Foo) foo47() { // ERROR "leaking param: f$" 327 f.xx = &f.x // ERROR "&f.x escapes to heap$" 328 } 329 330 var ptrSlice []*int 331 332 func foo50(i *int) { // ERROR "leaking param: i$" 333 ptrSlice[0] = i 334 } 335 336 var ptrMap map[*int]*int 337 338 func foo51(i *int) { // ERROR "leaking param: i$" 339 ptrMap[i] = i 340 } 341 342 func indaddr1(x int) *int { // ERROR "moved to heap: x$" 343 return &x // ERROR "&x escapes to heap$" 344 } 345 346 func indaddr2(x *int) *int { // ERROR "leaking param: x to result ~r1 level=0$" 347 return *&x // ERROR "indaddr2 &x does not escape$" 348 } 349 350 func indaddr3(x *int32) *int { // ERROR "leaking param: x to result ~r1 level=0$" 351 return *(**int)(unsafe.Pointer(&x)) // ERROR "indaddr3 &x does not escape$" 352 } 353 354 // From package math: 355 356 func Float32bits(f float32) uint32 { 357 return *(*uint32)(unsafe.Pointer(&f)) // ERROR "Float32bits &f does not escape$" 358 } 359 360 func Float32frombits(b uint32) float32 { 361 return *(*float32)(unsafe.Pointer(&b)) // ERROR "Float32frombits &b does not escape$" 362 } 363 364 func Float64bits(f float64) uint64 { 365 return *(*uint64)(unsafe.Pointer(&f)) // ERROR "Float64bits &f does not escape$" 366 } 367 368 func Float64frombits(b uint64) float64 { 369 return *(*float64)(unsafe.Pointer(&b)) // ERROR "Float64frombits &b does not escape$" 370 } 371 372 // contrast with 373 func float64bitsptr(f float64) *uint64 { // ERROR "moved to heap: f$" 374 return (*uint64)(unsafe.Pointer(&f)) // ERROR "&f escapes to heap$" 375 } 376 377 func float64ptrbitsptr(f *float64) *uint64 { // ERROR "leaking param: f to result ~r1 level=0$" 378 return (*uint64)(unsafe.Pointer(f)) 379 } 380 381 func typesw(i interface{}) *int { // ERROR "leaking param: i to result ~r1 level=0$" 382 switch val := i.(type) { 383 case *int: 384 return val 385 case *int8: 386 v := int(*val) // ERROR "moved to heap: v$" 387 return &v // ERROR "&v escapes to heap$" 388 } 389 return nil 390 } 391 392 func exprsw(i *int) *int { // ERROR "leaking param: i to result ~r1 level=0$" 393 switch j := i; *j + 110 { 394 case 12: 395 return j 396 case 42: 397 return nil 398 } 399 return nil 400 401 } 402 403 // assigning to an array element is like assigning to the array 404 func foo60(i *int) *int { // ERROR "leaking param: i to result ~r1 level=0$" 405 var a [12]*int 406 a[0] = i 407 return a[1] 408 } 409 410 func foo60a(i *int) *int { // ERROR "foo60a i does not escape$" 411 var a [12]*int 412 a[0] = i 413 return nil 414 } 415 416 // assigning to a struct field is like assigning to the struct 417 func foo61(i *int) *int { // ERROR "leaking param: i to result ~r1 level=0$" 418 type S struct { 419 a, b *int 420 } 421 var s S 422 s.a = i 423 return s.b 424 } 425 426 func foo61a(i *int) *int { // ERROR "foo61a i does not escape$" 427 type S struct { 428 a, b *int 429 } 430 var s S 431 s.a = i 432 return nil 433 } 434 435 // assigning to a struct field is like assigning to the struct but 436 // here this subtlety is lost, since s.a counts as an assignment to a 437 // track-losing dereference. 438 func foo62(i *int) *int { // ERROR "leaking param: i$" 439 type S struct { 440 a, b *int 441 } 442 s := new(S) // ERROR "foo62 new\(S\) does not escape$" 443 s.a = i 444 return nil // s.b 445 } 446 447 type M interface { 448 M() 449 } 450 451 func foo63(m M) { // ERROR "foo63 m does not escape$" 452 } 453 454 func foo64(m M) { // ERROR "leaking param: m$" 455 m.M() 456 } 457 458 func foo64b(m M) { // ERROR "leaking param: m$" 459 defer m.M() 460 } 461 462 type MV int 463 464 func (MV) M() {} 465 466 func foo65() { 467 var mv MV 468 foo63(&mv) // ERROR "foo65 &mv does not escape$" 469 } 470 471 func foo66() { 472 var mv MV // ERROR "moved to heap: mv$" 473 foo64(&mv) // ERROR "&mv escapes to heap$" 474 } 475 476 func foo67() { 477 var mv MV 478 foo63(mv) // ERROR "foo67 mv does not escape$" 479 } 480 481 func foo68() { 482 var mv MV 483 // escapes but it's an int so irrelevant 484 foo64(mv) // ERROR "mv escapes to heap$" 485 } 486 487 func foo69(m M) { // ERROR "leaking param: m$" 488 foo64(m) 489 } 490 491 func foo70(mv1 *MV, m M) { // ERROR "leaking param: m$" "leaking param: mv1$" 492 m = mv1 // ERROR "mv1 escapes to heap$" 493 foo64(m) 494 } 495 496 func foo71(x *int) []*int { // ERROR "leaking param: x$" 497 var y []*int 498 y = append(y, x) 499 return y 500 } 501 502 func foo71a(x int) []*int { // ERROR "moved to heap: x$" 503 var y []*int 504 y = append(y, &x) // ERROR "&x escapes to heap$" 505 return y 506 } 507 508 func foo72() { 509 var x int 510 var y [1]*int 511 y[0] = &x // ERROR "foo72 &x does not escape$" 512 } 513 514 func foo72aa() [10]*int { 515 var x int // ERROR "moved to heap: x$" 516 var y [10]*int 517 y[0] = &x // ERROR "&x escapes to heap$" 518 return y 519 } 520 521 func foo72a() { 522 var y [10]*int 523 for i := 0; i < 10; i++ { 524 // escapes its scope 525 x := i // ERROR "moved to heap: x$" 526 y[i] = &x // ERROR "&x escapes to heap$" 527 } 528 return 529 } 530 531 func foo72b() [10]*int { 532 var y [10]*int 533 for i := 0; i < 10; i++ { 534 x := i // ERROR "moved to heap: x$" 535 y[i] = &x // ERROR "&x escapes to heap$" 536 } 537 return y 538 } 539 540 // issue 2145 541 func foo73() { 542 s := []int{3, 2, 1} // ERROR "foo73 \[\]int literal does not escape$" 543 for _, v := range s { 544 vv := v 545 // actually just escapes its scope 546 defer func() { // ERROR "func literal escapes to heap$" 547 println(vv) 548 }() 549 } 550 } 551 552 func foo731() { 553 s := []int{3, 2, 1} // ERROR "foo731 \[\]int literal does not escape$" 554 for _, v := range s { 555 vv := v // ERROR "moved to heap: vv$" 556 // actually just escapes its scope 557 defer func() { // ERROR "func literal escapes to heap$" 558 vv = 42 // ERROR "&vv escapes to heap$" 559 println(vv) 560 }() 561 } 562 } 563 564 func foo74() { 565 s := []int{3, 2, 1} // ERROR "foo74 \[\]int literal does not escape$" 566 for _, v := range s { 567 vv := v 568 // actually just escapes its scope 569 fn := func() { // ERROR "func literal escapes to heap$" 570 println(vv) 571 } 572 defer fn() 573 } 574 } 575 576 func foo74a() { 577 s := []int{3, 2, 1} // ERROR "foo74a \[\]int literal does not escape$" 578 for _, v := range s { 579 vv := v // ERROR "moved to heap: vv$" 580 // actually just escapes its scope 581 fn := func() { // ERROR "func literal escapes to heap$" 582 vv += 1 // ERROR "&vv escapes to heap$" 583 println(vv) 584 } 585 defer fn() 586 } 587 } 588 589 // issue 3975 590 func foo74b() { 591 var array [3]func() 592 s := []int{3, 2, 1} // ERROR "foo74b \[\]int literal does not escape$" 593 for i, v := range s { 594 vv := v 595 // actually just escapes its scope 596 array[i] = func() { // ERROR "func literal escapes to heap$" 597 println(vv) 598 } 599 } 600 } 601 602 func foo74c() { 603 var array [3]func() 604 s := []int{3, 2, 1} // ERROR "foo74c \[\]int literal does not escape$" 605 for i, v := range s { 606 vv := v // ERROR "moved to heap: vv$" 607 // actually just escapes its scope 608 array[i] = func() { // ERROR "func literal escapes to heap$" 609 println(&vv) // ERROR "&vv escapes to heap$" "foo74c.func1 &vv does not escape$" 610 } 611 } 612 } 613 614 func myprint(y *int, x ...interface{}) *int { // ERROR "leaking param: y to result ~r2 level=0$" "myprint x does not escape$" 615 return y 616 } 617 618 func myprint1(y *int, x ...interface{}) *interface{} { // ERROR "leaking param: x to result ~r2 level=0$" "myprint1 y does not escape$" 619 return &x[0] // ERROR "&x\[0\] escapes to heap$" 620 } 621 622 func foo75(z *int) { // ERROR "foo75 z does not escape$" 623 myprint(z, 1, 2, 3) // ERROR "1 escapes to heap$" "2 escapes to heap$" "3 escapes to heap$" "foo75 ... argument does not escape$" 624 } 625 626 func foo75a(z *int) { // ERROR "foo75a z does not escape$" 627 myprint1(z, 1, 2, 3) // ERROR "1 escapes to heap$" "2 escapes to heap$" "3 escapes to heap$" "foo75a ... argument does not escape$" 628 } 629 630 func foo75esc(z *int) { // ERROR "leaking param: z$" 631 gxx = myprint(z, 1, 2, 3) // ERROR "1 escapes to heap$" "2 escapes to heap$" "3 escapes to heap$" "foo75esc ... argument does not escape$" 632 } 633 634 func foo75aesc(z *int) { // ERROR "foo75aesc z does not escape$" 635 var ppi **interface{} // assignments to pointer dereferences lose track 636 *ppi = myprint1(z, 1, 2, 3) // ERROR "... argument escapes to heap$" "1 escapes to heap$" "2 escapes to heap$" "3 escapes to heap$" 637 } 638 639 func foo75aesc1(z *int) { // ERROR "foo75aesc1 z does not escape$" 640 sink = myprint1(z, 1, 2, 3) // ERROR "... argument escapes to heap$" "1 escapes to heap$" "2 escapes to heap$" "3 escapes to heap$" "myprint1\(z, 1, 2, 3\) escapes to heap$" 641 } 642 643 // BAD: z does not escape here 644 func foo76(z *int) { // ERROR "leaking param: z$" 645 myprint(nil, z) // ERROR "foo76 ... argument does not escape$" "z escapes to heap$" 646 } 647 648 // BAD: z does not escape here 649 func foo76a(z *int) { // ERROR "leaking param: z$" 650 myprint1(nil, z) // ERROR "foo76a ... argument does not escape$" "z escapes to heap$" 651 } 652 653 func foo76b() { 654 myprint(nil, 1, 2, 3) // ERROR "1 escapes to heap$" "2 escapes to heap$" "3 escapes to heap$" "foo76b ... argument does not escape$" 655 } 656 657 func foo76c() { 658 myprint1(nil, 1, 2, 3) // ERROR "1 escapes to heap$" "2 escapes to heap$" "3 escapes to heap$" "foo76c ... argument does not escape$" 659 } 660 661 func foo76d() { 662 defer myprint(nil, 1, 2, 3) // ERROR "1 escapes to heap$" "2 escapes to heap$" "3 escapes to heap$" "foo76d ... argument does not escape$" 663 } 664 665 func foo76e() { 666 defer myprint1(nil, 1, 2, 3) // ERROR "1 escapes to heap$" "2 escapes to heap$" "3 escapes to heap$" "foo76e ... argument does not escape$" 667 } 668 669 func foo76f() { 670 for { 671 // TODO: This one really only escapes its scope, but we don't distinguish yet. 672 defer myprint(nil, 1, 2, 3) // ERROR "... argument escapes to heap$" "1 escapes to heap$" "2 escapes to heap$" "3 escapes to heap$" 673 } 674 } 675 676 func foo76g() { 677 for { 678 defer myprint1(nil, 1, 2, 3) // ERROR "... argument escapes to heap$" "1 escapes to heap$" "2 escapes to heap$" "3 escapes to heap$" 679 } 680 } 681 682 func foo77(z []interface{}) { // ERROR "foo77 z does not escape$" 683 myprint(nil, z...) // z does not escape 684 } 685 686 func foo77a(z []interface{}) { // ERROR "foo77a z does not escape$" 687 myprint1(nil, z...) 688 } 689 690 func foo77b(z []interface{}) { // ERROR "leaking param: z$" 691 var ppi **interface{} 692 *ppi = myprint1(nil, z...) 693 } 694 695 func foo77c(z []interface{}) { // ERROR "leaking param: z$" 696 sink = myprint1(nil, z...) // ERROR "myprint1\(nil, z...\) escapes to heap$" 697 } 698 699 func dotdotdot() { 700 // BAD: i should not escape here 701 i := 0 // ERROR "moved to heap: i$" 702 myprint(nil, &i) // ERROR "&i escapes to heap$" "dotdotdot ... argument does not escape$" 703 704 // BAD: j should not escape here 705 j := 0 // ERROR "moved to heap: j$" 706 myprint1(nil, &j) // ERROR "&j escapes to heap$" "dotdotdot ... argument does not escape$" 707 } 708 709 func foo78(z int) *int { // ERROR "moved to heap: z$" 710 return &z // ERROR "&z escapes to heap$" 711 } 712 713 func foo78a(z int) *int { // ERROR "moved to heap: z$" 714 y := &z // ERROR "&z escapes to heap$" 715 x := &y // ERROR "foo78a &y does not escape$" 716 return *x // really return y 717 } 718 719 func foo79() *int { 720 return new(int) // ERROR "new\(int\) escapes to heap$" 721 } 722 723 func foo80() *int { 724 var z *int 725 for { 726 // Really just escapes its scope but we don't distinguish 727 z = new(int) // ERROR "new\(int\) escapes to heap$" 728 } 729 _ = z 730 return nil 731 } 732 733 func foo81() *int { 734 for { 735 z := new(int) // ERROR "foo81 new\(int\) does not escape$" 736 _ = z 737 } 738 return nil 739 } 740 741 func tee(p *int) (x, y *int) { return p, p } // ERROR "leaking param: p to result x level=0$" "leaking param: p to result y level=0$" 742 743 func noop(x, y *int) {} // ERROR "noop x does not escape$" "noop y does not escape$" 744 745 func foo82() { 746 var x, y, z int // ERROR "moved to heap: x$" "moved to heap: y$" "moved to heap: z$" 747 go noop(tee(&z)) // ERROR "&z escapes to heap$" 748 go noop(&x, &y) // ERROR "&x escapes to heap$" "&y escapes to heap$" 749 for { 750 var u, v, w int // ERROR "moved to heap: u$" "moved to heap: v$" "moved to heap: w$" 751 defer noop(tee(&u)) // ERROR "&u escapes to heap$" 752 defer noop(&v, &w) // ERROR "&v escapes to heap$" "&w escapes to heap$" 753 } 754 } 755 756 type Fooer interface { 757 Foo() 758 } 759 760 type LimitedFooer struct { 761 Fooer 762 N int64 763 } 764 765 func LimitFooer(r Fooer, n int64) Fooer { // ERROR "leaking param: r to result ~r2 level=-1$" 766 return &LimitedFooer{r, n} // ERROR "&LimitedFooer literal escapes to heap$" 767 } 768 769 func foo90(x *int) map[*int]*int { // ERROR "leaking param: x$" 770 return map[*int]*int{nil: x} // ERROR "map\[\*int\]\*int literal escapes to heap$" 771 } 772 773 func foo91(x *int) map[*int]*int { // ERROR "leaking param: x$" 774 return map[*int]*int{x: nil} // ERROR "map\[\*int\]\*int literal escapes to heap$" 775 } 776 777 func foo92(x *int) [2]*int { // ERROR "leaking param: x to result ~r1 level=0$" 778 return [2]*int{x, nil} 779 } 780 781 // does not leak c 782 func foo93(c chan *int) *int { // ERROR "foo93 c does not escape$" 783 for v := range c { 784 return v 785 } 786 return nil 787 } 788 789 // does not leak m 790 func foo94(m map[*int]*int, b bool) *int { // ERROR "leaking param: m to result ~r2 level=1" 791 for k, v := range m { 792 if b { 793 return k 794 } 795 return v 796 } 797 return nil 798 } 799 800 // does leak x 801 func foo95(m map[*int]*int, x *int) { // ERROR "foo95 m does not escape$" "leaking param: x$" 802 m[x] = x 803 } 804 805 // does not leak m but does leak content 806 func foo96(m []*int) *int { // ERROR "leaking param: m to result ~r1 level=1" 807 return m[0] 808 } 809 810 // does leak m 811 func foo97(m [1]*int) *int { // ERROR "leaking param: m to result ~r1 level=0$" 812 return m[0] 813 } 814 815 // does not leak m 816 func foo98(m map[int]*int) *int { // ERROR "foo98 m does not escape$" 817 return m[0] 818 } 819 820 // does leak m 821 func foo99(m *[1]*int) []*int { // ERROR "leaking param: m to result ~r1 level=0$" 822 return m[:] 823 } 824 825 // does not leak m 826 func foo100(m []*int) *int { // ERROR "leaking param: m to result ~r1 level=1" 827 for _, v := range m { 828 return v 829 } 830 return nil 831 } 832 833 // does leak m 834 func foo101(m [1]*int) *int { // ERROR "leaking param: m to result ~r1 level=0$" 835 for _, v := range m { 836 return v 837 } 838 return nil 839 } 840 841 // does not leak m 842 func foo101a(m [1]*int) *int { // ERROR "foo101a m does not escape$" 843 for i := range m { // ERROR "moved to heap: i$" 844 return &i // ERROR "&i escapes to heap$" 845 } 846 return nil 847 } 848 849 // does leak x 850 func foo102(m []*int, x *int) { // ERROR "foo102 m does not escape$" "leaking param: x$" 851 m[0] = x 852 } 853 854 // does not leak x 855 func foo103(m [1]*int, x *int) { // ERROR "foo103 m does not escape$" "foo103 x does not escape$" 856 m[0] = x 857 } 858 859 var y []*int 860 861 // does not leak x but does leak content 862 func foo104(x []*int) { // ERROR "leaking param content: x" 863 copy(y, x) 864 } 865 866 // does not leak x but does leak content 867 func foo105(x []*int) { // ERROR "leaking param content: x" 868 _ = append(y, x...) 869 } 870 871 // does leak x 872 func foo106(x *int) { // ERROR "leaking param: x$" 873 _ = append(y, x) 874 } 875 876 func foo107(x *int) map[*int]*int { // ERROR "leaking param: x$" 877 return map[*int]*int{x: nil} // ERROR "map\[\*int\]\*int literal escapes to heap$" 878 } 879 880 func foo108(x *int) map[*int]*int { // ERROR "leaking param: x$" 881 return map[*int]*int{nil: x} // ERROR "map\[\*int\]\*int literal escapes to heap$" 882 } 883 884 func foo109(x *int) *int { // ERROR "leaking param: x$" 885 m := map[*int]*int{x: nil} // ERROR "foo109 map\[\*int\]\*int literal does not escape$" 886 for k, _ := range m { 887 return k 888 } 889 return nil 890 } 891 892 func foo110(x *int) *int { // ERROR "leaking param: x$" 893 m := map[*int]*int{nil: x} // ERROR "foo110 map\[\*int\]\*int literal does not escape$" 894 return m[nil] 895 } 896 897 func foo111(x *int) *int { // ERROR "leaking param: x to result ~r1 level=0" 898 m := []*int{x} // ERROR "foo111 \[\]\*int literal does not escape$" 899 return m[0] 900 } 901 902 func foo112(x *int) *int { // ERROR "leaking param: x to result ~r1 level=0$" 903 m := [1]*int{x} 904 return m[0] 905 } 906 907 func foo113(x *int) *int { // ERROR "leaking param: x to result ~r1 level=0$" 908 m := Bar{ii: x} 909 return m.ii 910 } 911 912 func foo114(x *int) *int { // ERROR "leaking param: x to result ~r1 level=0$" 913 m := &Bar{ii: x} // ERROR "foo114 &Bar literal does not escape$" 914 return m.ii 915 } 916 917 func foo115(x *int) *int { // ERROR "leaking param: x to result ~r1 level=0$" 918 return (*int)(unsafe.Pointer(uintptr(unsafe.Pointer(x)) + 1)) 919 } 920 921 func foo116(b bool) *int { 922 if b { 923 x := 1 // ERROR "moved to heap: x$" 924 return &x // ERROR "&x escapes to heap$" 925 } else { 926 y := 1 // ERROR "moved to heap: y$" 927 return &y // ERROR "&y escapes to heap$" 928 } 929 return nil 930 } 931 932 func foo117(unknown func(interface{})) { // ERROR "foo117 unknown does not escape$" 933 x := 1 // ERROR "moved to heap: x$" 934 unknown(&x) // ERROR "&x escapes to heap$" 935 } 936 937 func foo118(unknown func(*int)) { // ERROR "foo118 unknown does not escape$" 938 x := 1 // ERROR "moved to heap: x$" 939 unknown(&x) // ERROR "&x escapes to heap$" 940 } 941 942 func external(*int) 943 944 func foo119(x *int) { // ERROR "leaking param: x$" 945 external(x) 946 } 947 948 func foo120() { 949 // formerly exponential time analysis 950 L1: 951 L2: 952 L3: 953 L4: 954 L5: 955 L6: 956 L7: 957 L8: 958 L9: 959 L10: 960 L11: 961 L12: 962 L13: 963 L14: 964 L15: 965 L16: 966 L17: 967 L18: 968 L19: 969 L20: 970 L21: 971 L22: 972 L23: 973 L24: 974 L25: 975 L26: 976 L27: 977 L28: 978 L29: 979 L30: 980 L31: 981 L32: 982 L33: 983 L34: 984 L35: 985 L36: 986 L37: 987 L38: 988 L39: 989 L40: 990 L41: 991 L42: 992 L43: 993 L44: 994 L45: 995 L46: 996 L47: 997 L48: 998 L49: 999 L50: 1000 L51: 1001 L52: 1002 L53: 1003 L54: 1004 L55: 1005 L56: 1006 L57: 1007 L58: 1008 L59: 1009 L60: 1010 L61: 1011 L62: 1012 L63: 1013 L64: 1014 L65: 1015 L66: 1016 L67: 1017 L68: 1018 L69: 1019 L70: 1020 L71: 1021 L72: 1022 L73: 1023 L74: 1024 L75: 1025 L76: 1026 L77: 1027 L78: 1028 L79: 1029 L80: 1030 L81: 1031 L82: 1032 L83: 1033 L84: 1034 L85: 1035 L86: 1036 L87: 1037 L88: 1038 L89: 1039 L90: 1040 L91: 1041 L92: 1042 L93: 1043 L94: 1044 L95: 1045 L96: 1046 L97: 1047 L98: 1048 L99: 1049 L100: 1050 // use the labels to silence compiler errors 1051 goto L1 1052 goto L2 1053 goto L3 1054 goto L4 1055 goto L5 1056 goto L6 1057 goto L7 1058 goto L8 1059 goto L9 1060 goto L10 1061 goto L11 1062 goto L12 1063 goto L13 1064 goto L14 1065 goto L15 1066 goto L16 1067 goto L17 1068 goto L18 1069 goto L19 1070 goto L20 1071 goto L21 1072 goto L22 1073 goto L23 1074 goto L24 1075 goto L25 1076 goto L26 1077 goto L27 1078 goto L28 1079 goto L29 1080 goto L30 1081 goto L31 1082 goto L32 1083 goto L33 1084 goto L34 1085 goto L35 1086 goto L36 1087 goto L37 1088 goto L38 1089 goto L39 1090 goto L40 1091 goto L41 1092 goto L42 1093 goto L43 1094 goto L44 1095 goto L45 1096 goto L46 1097 goto L47 1098 goto L48 1099 goto L49 1100 goto L50 1101 goto L51 1102 goto L52 1103 goto L53 1104 goto L54 1105 goto L55 1106 goto L56 1107 goto L57 1108 goto L58 1109 goto L59 1110 goto L60 1111 goto L61 1112 goto L62 1113 goto L63 1114 goto L64 1115 goto L65 1116 goto L66 1117 goto L67 1118 goto L68 1119 goto L69 1120 goto L70 1121 goto L71 1122 goto L72 1123 goto L73 1124 goto L74 1125 goto L75 1126 goto L76 1127 goto L77 1128 goto L78 1129 goto L79 1130 goto L80 1131 goto L81 1132 goto L82 1133 goto L83 1134 goto L84 1135 goto L85 1136 goto L86 1137 goto L87 1138 goto L88 1139 goto L89 1140 goto L90 1141 goto L91 1142 goto L92 1143 goto L93 1144 goto L94 1145 goto L95 1146 goto L96 1147 goto L97 1148 goto L98 1149 goto L99 1150 goto L100 1151 } 1152 1153 func foo121() { 1154 for i := 0; i < 10; i++ { 1155 defer myprint(nil, i) // ERROR "... argument escapes to heap$" "i escapes to heap$" 1156 go myprint(nil, i) // ERROR "... argument escapes to heap$" "i escapes to heap$" 1157 } 1158 } 1159 1160 // same as foo121 but check across import 1161 func foo121b() { 1162 for i := 0; i < 10; i++ { 1163 defer fmt.Printf("%d", i) // ERROR "... argument escapes to heap$" "i escapes to heap$" 1164 go fmt.Printf("%d", i) // ERROR "... argument escapes to heap$" "i escapes to heap$" 1165 } 1166 } 1167 1168 // a harmless forward jump 1169 func foo122() { 1170 var i *int 1171 1172 goto L1 1173 L1: 1174 i = new(int) // ERROR "foo122 new\(int\) does not escape$" 1175 _ = i 1176 } 1177 1178 // a backward jump, increases loopdepth 1179 func foo123() { 1180 var i *int 1181 1182 L1: 1183 i = new(int) // ERROR "new\(int\) escapes to heap$" 1184 1185 goto L1 1186 _ = i 1187 } 1188 1189 func foo124(x **int) { // ERROR "foo124 x does not escape$" 1190 var i int // ERROR "moved to heap: i$" 1191 p := &i // ERROR "&i escapes to heap$" 1192 func() { // ERROR "foo124 func literal does not escape$" 1193 *x = p // ERROR "leaking closure reference p$" 1194 }() 1195 } 1196 1197 func foo125(ch chan *int) { // ERROR "foo125 ch does not escape$" 1198 var i int // ERROR "moved to heap: i$" 1199 p := &i // ERROR "&i escapes to heap$" 1200 func() { // ERROR "foo125 func literal does not escape$" 1201 ch <- p // ERROR "leaking closure reference p$" 1202 }() 1203 } 1204 1205 func foo126() { 1206 var px *int // loopdepth 0 1207 for { 1208 // loopdepth 1 1209 var i int // ERROR "moved to heap: i$" 1210 func() { // ERROR "foo126 func literal does not escape$" 1211 px = &i // ERROR "&i escapes to heap$" 1212 }() 1213 } 1214 _ = px 1215 } 1216 1217 var px *int 1218 1219 func foo127() { 1220 var i int // ERROR "moved to heap: i$" 1221 p := &i // ERROR "&i escapes to heap$" 1222 q := p 1223 px = q 1224 } 1225 1226 func foo128() { 1227 var i int 1228 p := &i // ERROR "foo128 &i does not escape$" 1229 q := p 1230 _ = q 1231 } 1232 1233 func foo129() { 1234 var i int // ERROR "moved to heap: i$" 1235 p := &i // ERROR "&i escapes to heap$" 1236 func() { // ERROR "foo129 func literal does not escape$" 1237 q := p // ERROR "leaking closure reference p$" 1238 func() { // ERROR "foo129.func1 func literal does not escape$" 1239 r := q // ERROR "leaking closure reference q$" 1240 px = r 1241 }() 1242 }() 1243 } 1244 1245 func foo130() { 1246 for { 1247 var i int // ERROR "moved to heap: i$" 1248 func() { // ERROR "foo130 func literal does not escape$" 1249 px = &i // ERROR "&i escapes to heap$" "leaking closure reference i$" 1250 }() 1251 } 1252 } 1253 1254 func foo131() { 1255 var i int // ERROR "moved to heap: i$" 1256 func() { // ERROR "foo131 func literal does not escape$" 1257 px = &i // ERROR "&i escapes to heap$" "leaking closure reference i$" 1258 }() 1259 } 1260 1261 func foo132() { 1262 var i int // ERROR "moved to heap: i$" 1263 go func() { // ERROR "func literal escapes to heap$" 1264 px = &i // ERROR "&i escapes to heap$" "leaking closure reference i$" 1265 }() 1266 } 1267 1268 func foo133() { 1269 var i int // ERROR "moved to heap: i$" 1270 defer func() { // ERROR "foo133 func literal does not escape$" 1271 px = &i // ERROR "&i escapes to heap$" "leaking closure reference i$" 1272 }() 1273 } 1274 1275 func foo134() { 1276 var i int 1277 p := &i // ERROR "foo134 &i does not escape$" 1278 func() { // ERROR "foo134 func literal does not escape$" 1279 q := p 1280 func() { // ERROR "foo134.func1 func literal does not escape$" 1281 r := q 1282 _ = r 1283 }() 1284 }() 1285 } 1286 1287 func foo135() { 1288 var i int // ERROR "moved to heap: i$" 1289 p := &i // ERROR "&i escapes to heap$" 1290 go func() { // ERROR "func literal escapes to heap$" 1291 q := p 1292 func() { // ERROR "foo135.func1 func literal does not escape$" 1293 r := q 1294 _ = r 1295 }() 1296 }() 1297 } 1298 1299 func foo136() { 1300 var i int // ERROR "moved to heap: i$" 1301 p := &i // ERROR "&i escapes to heap$" 1302 go func() { // ERROR "func literal escapes to heap$" 1303 q := p // ERROR "leaking closure reference p$" 1304 func() { // ERROR "foo136.func1 func literal does not escape$" 1305 r := q // ERROR "leaking closure reference q$" 1306 px = r 1307 }() 1308 }() 1309 } 1310 1311 func foo137() { 1312 var i int // ERROR "moved to heap: i$" 1313 p := &i // ERROR "&i escapes to heap$" 1314 func() { // ERROR "foo137 func literal does not escape$" 1315 q := p // ERROR "leaking closure reference p$" 1316 go func() { // ERROR "func literal escapes to heap$" 1317 r := q 1318 _ = r 1319 }() 1320 }() 1321 } 1322 1323 func foo138() *byte { 1324 type T struct { 1325 x [1]byte 1326 } 1327 t := new(T) // ERROR "new\(T\) escapes to heap$" 1328 return &t.x[0] // ERROR "&t.x\[0\] escapes to heap$" 1329 } 1330 1331 func foo139() *byte { 1332 type T struct { 1333 x struct { 1334 y byte 1335 } 1336 } 1337 t := new(T) // ERROR "new\(T\) escapes to heap$" 1338 return &t.x.y // ERROR "&t.x.y escapes to heap$" 1339 } 1340 1341 // issue 4751 1342 func foo140() interface{} { 1343 type T struct { 1344 X string 1345 } 1346 type U struct { 1347 X string 1348 T *T 1349 } 1350 t := &T{} // ERROR "&T literal escapes to heap$" 1351 return U{ // ERROR "U literal escapes to heap$" 1352 X: t.X, 1353 T: t, 1354 } 1355 } 1356 1357 //go:noescape 1358 1359 func F1([]byte) 1360 1361 func F2([]byte) 1362 1363 //go:noescape 1364 1365 func F3(x []byte) // ERROR "F3 x does not escape$" 1366 1367 func F4(x []byte) 1368 1369 func G() { 1370 var buf1 [10]byte 1371 F1(buf1[:]) // ERROR "G buf1 does not escape$" 1372 1373 var buf2 [10]byte // ERROR "moved to heap: buf2$" 1374 F2(buf2[:]) // ERROR "buf2 escapes to heap$" 1375 1376 var buf3 [10]byte 1377 F3(buf3[:]) // ERROR "G buf3 does not escape$" 1378 1379 var buf4 [10]byte // ERROR "moved to heap: buf4$" 1380 F4(buf4[:]) // ERROR "buf4 escapes to heap$" 1381 } 1382 1383 type Tm struct { 1384 x int 1385 } 1386 1387 func (t *Tm) M() { // ERROR "\(\*Tm\).M t does not escape$" 1388 } 1389 1390 func foo141() { 1391 var f func() 1392 1393 t := new(Tm) // ERROR "new\(Tm\) escapes to heap$" 1394 f = t.M // ERROR "foo141 t.M does not escape$" 1395 _ = f 1396 } 1397 1398 var gf func() 1399 1400 func foo142() { 1401 t := new(Tm) // ERROR "new\(Tm\) escapes to heap$" 1402 gf = t.M // ERROR "t.M escapes to heap$" 1403 } 1404 1405 // issue 3888. 1406 func foo143() { 1407 for i := 0; i < 1000; i++ { 1408 func() { // ERROR "foo143 func literal does not escape$" 1409 for i := 0; i < 1; i++ { 1410 var t Tm 1411 t.M() // ERROR "foo143.func1 t does not escape$" 1412 } 1413 }() 1414 } 1415 } 1416 1417 // issue 5773 1418 // Check that annotations take effect regardless of whether they 1419 // are before or after the use in the source code. 1420 1421 //go:noescape 1422 1423 func foo144a(*int) 1424 1425 func foo144() { 1426 var x int 1427 foo144a(&x) // ERROR "foo144 &x does not escape$" 1428 var y int 1429 foo144b(&y) // ERROR "foo144 &y does not escape$" 1430 } 1431 1432 //go:noescape 1433 1434 func foo144b(*int) 1435 1436 // issue 7313: for loop init should not be treated as "in loop" 1437 1438 type List struct { 1439 Next *List 1440 } 1441 1442 func foo145(l List) { // ERROR "foo145 l does not escape$" 1443 var p *List 1444 for p = &l; p.Next != nil; p = p.Next { // ERROR "foo145 &l does not escape$" 1445 } 1446 } 1447 1448 func foo146(l List) { // ERROR "foo146 l does not escape$" 1449 var p *List 1450 p = &l // ERROR "foo146 &l does not escape$" 1451 for ; p.Next != nil; p = p.Next { 1452 } 1453 } 1454 1455 func foo147(l List) { // ERROR "foo147 l does not escape$" 1456 var p *List 1457 p = &l // ERROR "foo147 &l does not escape$" 1458 for p.Next != nil { 1459 p = p.Next 1460 } 1461 } 1462 1463 func foo148(l List) { // ERROR "foo148 l does not escape$" 1464 for p := &l; p.Next != nil; p = p.Next { // ERROR "foo148 &l does not escape$" 1465 } 1466 } 1467 1468 // related: address of variable should have depth of variable, not of loop 1469 1470 func foo149(l List) { // ERROR "foo149 l does not escape$" 1471 var p *List 1472 for { 1473 for p = &l; p.Next != nil; p = p.Next { // ERROR "foo149 &l does not escape$" 1474 } 1475 } 1476 } 1477 1478 // issue 7934: missed ... if element type had no pointers 1479 1480 var save150 []byte 1481 1482 func foo150(x ...byte) { // ERROR "leaking param: x$" 1483 save150 = x 1484 } 1485 1486 func bar150() { 1487 foo150(1, 2, 3) // ERROR "... argument escapes to heap$" 1488 } 1489 1490 // issue 7931: bad handling of slice of array 1491 1492 var save151 *int 1493 1494 func foo151(x *int) { // ERROR "leaking param: x$" 1495 save151 = x 1496 } 1497 1498 func bar151() { 1499 var a [64]int // ERROR "moved to heap: a$" 1500 a[4] = 101 1501 foo151(&(&a)[4:8][0]) // ERROR "&\(&a\)\[4:8\]\[0\] escapes to heap$" "&a escapes to heap$" 1502 } 1503 1504 func bar151b() { 1505 var a [10]int // ERROR "moved to heap: a$" 1506 b := a[:] // ERROR "a escapes to heap$" 1507 foo151(&b[4:8][0]) // ERROR "&b\[4:8\]\[0\] escapes to heap$" 1508 } 1509 1510 func bar151c() { 1511 var a [64]int // ERROR "moved to heap: a$" 1512 a[4] = 101 1513 foo151(&(&a)[4:8:8][0]) // ERROR "&\(&a\)\[4:8:8\]\[0\] escapes to heap$" "&a escapes to heap$" 1514 } 1515 1516 func bar151d() { 1517 var a [10]int // ERROR "moved to heap: a$" 1518 b := a[:] // ERROR "a escapes to heap$" 1519 foo151(&b[4:8:8][0]) // ERROR "&b\[4:8:8\]\[0\] escapes to heap$" 1520 } 1521 1522 // issue 8120 1523 1524 type U struct { 1525 s *string 1526 } 1527 1528 func (u *U) String() *string { // ERROR "leaking param: u to result ~r0 level=1$" 1529 return u.s 1530 } 1531 1532 type V struct { 1533 s *string 1534 } 1535 1536 // BAD -- level of leak ought to be 0 1537 func NewV(u U) *V { // ERROR "leaking param: u to result ~r1 level=-1" 1538 return &V{u.String()} // ERROR "&V literal escapes to heap$" "NewV u does not escape" 1539 } 1540 1541 func foo152() { 1542 a := "a" // ERROR "moved to heap: a$" 1543 u := U{&a} // ERROR "&a escapes to heap$" 1544 v := NewV(u) 1545 println(v) 1546 } 1547 1548 // issue 8176 - &x in type switch body not marked as escaping 1549 1550 func foo153(v interface{}) *int { // ERROR "leaking param: v to result ~r1 level=-1$" 1551 switch x := v.(type) { 1552 case int: // ERROR "moved to heap: x$" 1553 return &x // ERROR "&x escapes to heap$" 1554 } 1555 panic(0) 1556 } 1557 1558 // issue 8185 - &result escaping into result 1559 1560 func f() (x int, y *int) { // ERROR "moved to heap: x$" 1561 y = &x // ERROR "&x escapes to heap$" 1562 return 1563 } 1564 1565 func g() (x interface{}) { // ERROR "moved to heap: x$" 1566 x = &x // ERROR "&x escapes to heap$" 1567 return 1568 } 1569 1570 var sink interface{} 1571 1572 type Lit struct { 1573 p *int 1574 } 1575 1576 func ptrlitNoescape() { 1577 // Both literal and element do not escape. 1578 i := 0 1579 x := &Lit{&i} // ERROR "ptrlitNoescape &Lit literal does not escape$" "ptrlitNoescape &i does not escape$" 1580 _ = x 1581 } 1582 1583 func ptrlitNoEscape2() { 1584 // Literal does not escape, but element does. 1585 i := 0 // ERROR "moved to heap: i$" 1586 x := &Lit{&i} // ERROR "&i escapes to heap$" "ptrlitNoEscape2 &Lit literal does not escape$" 1587 sink = *x // ERROR "\*x escapes to heap$" 1588 } 1589 1590 func ptrlitEscape() { 1591 // Both literal and element escape. 1592 i := 0 // ERROR "moved to heap: i$" 1593 x := &Lit{&i} // ERROR "&Lit literal escapes to heap$" "&i escapes to heap$" 1594 sink = x // ERROR "x escapes to heap$" 1595 } 1596 1597 // self-assignments 1598 1599 type Buffer struct { 1600 arr [64]byte 1601 buf1 []byte 1602 buf2 []byte 1603 str1 string 1604 str2 string 1605 } 1606 1607 func (b *Buffer) foo() { // ERROR "\(\*Buffer\).foo b does not escape$" 1608 b.buf1 = b.buf1[1:2] // ERROR "\(\*Buffer\).foo ignoring self-assignment to b.buf1$" 1609 b.buf1 = b.buf1[1:2:3] // ERROR "\(\*Buffer\).foo ignoring self-assignment to b.buf1$" 1610 b.buf1 = b.buf2[1:2] // ERROR "\(\*Buffer\).foo ignoring self-assignment to b.buf1$" 1611 b.buf1 = b.buf2[1:2:3] // ERROR "\(\*Buffer\).foo ignoring self-assignment to b.buf1$" 1612 } 1613 1614 func (b *Buffer) bar() { // ERROR "leaking param: b$" 1615 b.buf1 = b.arr[1:2] // ERROR "b.arr escapes to heap$" 1616 } 1617 1618 func (b *Buffer) baz() { // ERROR "\(\*Buffer\).baz b does not escape$" 1619 b.str1 = b.str1[1:2] // ERROR "\(\*Buffer\).baz ignoring self-assignment to b.str1$" 1620 b.str1 = b.str2[1:2] // ERROR "\(\*Buffer\).baz ignoring self-assignment to b.str1$" 1621 } 1622 1623 func (b *Buffer) bat() { // ERROR "leaking param content: b$" 1624 o := new(Buffer) // ERROR "new\(Buffer\) escapes to heap$" 1625 o.buf1 = b.buf1[1:2] 1626 sink = o // ERROR "o escapes to heap$" 1627 } 1628 1629 func quux(sp *string, bp *[]byte) { // ERROR "quux bp does not escape$" "quux sp does not escape$" 1630 *sp = (*sp)[1:2] // ERROR "quux ignoring self-assignment to \*sp$" 1631 *bp = (*bp)[1:2] // ERROR "quux ignoring self-assignment to \*bp$" 1632 } 1633 1634 type StructWithString struct { 1635 p *int 1636 s string 1637 } 1638 1639 // This is escape analysis false negative. 1640 // We assign the pointer to x.p but leak x.s. Escape analysis coarsens flows 1641 // to just x, and thus &i looks escaping. 1642 func fieldFlowTracking() { 1643 var x StructWithString 1644 i := 0 // ERROR "moved to heap: i$" 1645 x.p = &i // ERROR "&i escapes to heap$" 1646 sink = x.s // ERROR "x.s escapes to heap$" 1647 } 1648 1649 // String operations. 1650 1651 func slicebytetostring0() { 1652 b := make([]byte, 20) // ERROR "slicebytetostring0 make\(\[\]byte, 20\) does not escape$" 1653 s := string(b) // ERROR "slicebytetostring0 string\(b\) does not escape$" 1654 _ = s 1655 } 1656 1657 func slicebytetostring1() { 1658 b := make([]byte, 20) // ERROR "slicebytetostring1 make\(\[\]byte, 20\) does not escape$" 1659 s := string(b) // ERROR "slicebytetostring1 string\(b\) does not escape$" 1660 s1 := s[0:1] 1661 _ = s1 1662 } 1663 1664 func slicebytetostring2() { 1665 b := make([]byte, 20) // ERROR "slicebytetostring2 make\(\[\]byte, 20\) does not escape$" 1666 s := string(b) // ERROR "string\(b\) escapes to heap$" 1667 s1 := s[0:1] // ERROR "moved to heap: s1$" 1668 sink = &s1 // ERROR "&s1 escapes to heap$" 1669 } 1670 1671 func slicebytetostring3() { 1672 b := make([]byte, 20) // ERROR "slicebytetostring3 make\(\[\]byte, 20\) does not escape$" 1673 s := string(b) // ERROR "string\(b\) escapes to heap$" 1674 s1 := s[0:1] 1675 sink = s1 // ERROR "s1 escapes to heap$" 1676 } 1677 1678 func addstr0() { 1679 s0 := "a" 1680 s1 := "b" 1681 s := s0 + s1 // ERROR "addstr0 s0 \+ s1 does not escape$" 1682 _ = s 1683 } 1684 1685 func addstr1() { 1686 s0 := "a" 1687 s1 := "b" 1688 s := "c" 1689 s += s0 + s1 // ERROR "addstr1 s0 \+ s1 does not escape$" 1690 _ = s 1691 } 1692 1693 func addstr2() { 1694 b := make([]byte, 20) // ERROR "addstr2 make\(\[\]byte, 20\) does not escape$" 1695 s0 := "a" 1696 s := string(b) + s0 // ERROR "addstr2 string\(b\) \+ s0 does not escape$" "addstr2 string\(b\) does not escape$" 1697 _ = s 1698 } 1699 1700 func addstr3() { 1701 s0 := "a" 1702 s1 := "b" 1703 s := s0 + s1 // ERROR "s0 \+ s1 escapes to heap$" 1704 s2 := s[0:1] 1705 sink = s2 // ERROR "s2 escapes to heap$" 1706 } 1707 1708 func intstring0() bool { 1709 // string does not escape 1710 x := '0' 1711 s := string(x) // ERROR "intstring0 string\(x\) does not escape$" 1712 return s == "0" 1713 } 1714 1715 func intstring1() string { 1716 // string does not escape, but the buffer does 1717 x := '0' 1718 s := string(x) // ERROR "string\(x\) escapes to heap$" 1719 return s 1720 } 1721 1722 func intstring2() { 1723 // string escapes to heap 1724 x := '0' 1725 s := string(x) // ERROR "moved to heap: s$" "string\(x\) escapes to heap$" 1726 sink = &s // ERROR "&s escapes to heap$" 1727 } 1728 1729 func stringtoslicebyte0() { 1730 s := "foo" 1731 x := []byte(s) // ERROR "stringtoslicebyte0 \(\[\]byte\)\(s\) does not escape$" 1732 _ = x 1733 } 1734 1735 func stringtoslicebyte1() []byte { 1736 s := "foo" 1737 return []byte(s) // ERROR "\(\[\]byte\)\(s\) escapes to heap$" 1738 } 1739 1740 func stringtoslicebyte2() { 1741 s := "foo" 1742 sink = []byte(s) // ERROR "\(\[\]byte\)\(s\) escapes to heap$" 1743 } 1744 1745 func stringtoslicerune0() { 1746 s := "foo" 1747 x := []rune(s) // ERROR "stringtoslicerune0 \(\[\]rune\)\(s\) does not escape$" 1748 _ = x 1749 } 1750 1751 func stringtoslicerune1() []rune { 1752 s := "foo" 1753 return []rune(s) // ERROR "\(\[\]rune\)\(s\) escapes to heap$" 1754 } 1755 1756 func stringtoslicerune2() { 1757 s := "foo" 1758 sink = []rune(s) // ERROR "\(\[\]rune\)\(s\) escapes to heap$" 1759 } 1760 1761 func slicerunetostring0() { 1762 r := []rune{1, 2, 3} // ERROR "slicerunetostring0 \[\]rune literal does not escape$" 1763 s := string(r) // ERROR "slicerunetostring0 string\(r\) does not escape$" 1764 _ = s 1765 } 1766 1767 func slicerunetostring1() string { 1768 r := []rune{1, 2, 3} // ERROR "slicerunetostring1 \[\]rune literal does not escape$" 1769 return string(r) // ERROR "string\(r\) escapes to heap$" 1770 } 1771 1772 func slicerunetostring2() { 1773 r := []rune{1, 2, 3} // ERROR "slicerunetostring2 \[\]rune literal does not escape$" 1774 sink = string(r) // ERROR "string\(r\) escapes to heap$" 1775 } 1776 1777 func makemap0() { 1778 m := make(map[int]int) // ERROR "makemap0 make\(map\[int\]int\) does not escape$" 1779 m[0] = 0 1780 m[1]++ 1781 delete(m, 1) 1782 sink = m[0] // ERROR "m\[0\] escapes to heap$" 1783 } 1784 1785 func makemap1() map[int]int { 1786 return make(map[int]int) // ERROR "make\(map\[int\]int\) escapes to heap$" 1787 } 1788 1789 func makemap2() { 1790 m := make(map[int]int) // ERROR "make\(map\[int\]int\) escapes to heap$" 1791 sink = m // ERROR "m escapes to heap$" 1792 } 1793 1794 func nonescapingEface(m map[interface{}]bool) bool { // ERROR "nonescapingEface m does not escape$" 1795 return m["foo"] // ERROR "nonescapingEface .foo. does not escape$" 1796 } 1797 1798 func nonescapingIface(m map[M]bool) bool { // ERROR "nonescapingIface m does not escape$" 1799 return m[MV(0)] // ERROR "nonescapingIface MV\(0\) does not escape$" 1800 } 1801 1802 func issue10353() { 1803 x := new(int) // ERROR "new\(int\) escapes to heap$" 1804 issue10353a(x)() 1805 } 1806 1807 func issue10353a(x *int) func() { // ERROR "leaking param: x to result ~r1 level=-1$" 1808 return func() { // ERROR "func literal escapes to heap$" 1809 println(*x) 1810 } 1811 } 1812 1813 func issue10353b() { 1814 var f func() 1815 for { 1816 x := new(int) // ERROR "new\(int\) escapes to heap$" 1817 f = func() { // ERROR "func literal escapes to heap$" 1818 println(*x) 1819 } 1820 } 1821 _ = f 1822 } 1823 1824 func issue11387(x int) func() int { 1825 f := func() int { return x } // ERROR "func literal escapes to heap" 1826 slice1 := []func() int{f} // ERROR "\[\].* does not escape" 1827 slice2 := make([]func() int, 1) // ERROR "make\(.*\) does not escape" 1828 copy(slice2, slice1) 1829 return slice2[0] 1830 } 1831
