1 // errorcheck -0 -N -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 // Registerization is disabled too (-N), which should 10 // have no effect on escape analysis. 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 does not escape" "2 does not escape" "3 does not escape" "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 does not escape" "2 does not escape" "3 does not escape" "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 does not escape" "2 does not escape" "3 does not escape" "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 func foo76(z *int) { // ERROR "z does not escape" 644 myprint(nil, z) // ERROR "foo76 ... argument does not escape$" "z does not escape" 645 } 646 647 func foo76a(z *int) { // ERROR "z does not escape" 648 myprint1(nil, z) // ERROR "foo76a ... argument does not escape$" "z does not escape" 649 } 650 651 func foo76b() { 652 myprint(nil, 1, 2, 3) // ERROR "1 does not escape" "2 does not escape" "3 does not escape" "foo76b ... argument does not escape$" 653 } 654 655 func foo76c() { 656 myprint1(nil, 1, 2, 3) // ERROR "1 does not escape" "2 does not escape" "3 does not escape" "foo76c ... argument does not escape$" 657 } 658 659 func foo76d() { 660 defer myprint(nil, 1, 2, 3) // ERROR "1 does not escape" "2 does not escape" "3 does not escape" "foo76d ... argument does not escape$" 661 } 662 663 func foo76e() { 664 defer myprint1(nil, 1, 2, 3) // ERROR "1 does not escape" "2 does not escape" "3 does not escape" "foo76e ... argument does not escape$" 665 } 666 667 func foo76f() { 668 for { 669 // TODO: This one really only escapes its scope, but we don't distinguish yet. 670 defer myprint(nil, 1, 2, 3) // ERROR "... argument escapes to heap$" "1 escapes to heap$" "2 escapes to heap$" "3 escapes to heap$" 671 } 672 } 673 674 func foo76g() { 675 for { 676 defer myprint1(nil, 1, 2, 3) // ERROR "... argument escapes to heap$" "1 escapes to heap$" "2 escapes to heap$" "3 escapes to heap$" 677 } 678 } 679 680 func foo77(z []interface{}) { // ERROR "foo77 z does not escape$" 681 myprint(nil, z...) // z does not escape 682 } 683 684 func foo77a(z []interface{}) { // ERROR "foo77a z does not escape$" 685 myprint1(nil, z...) 686 } 687 688 func foo77b(z []interface{}) { // ERROR "leaking param: z$" 689 var ppi **interface{} 690 *ppi = myprint1(nil, z...) 691 } 692 693 func foo77c(z []interface{}) { // ERROR "leaking param: z$" 694 sink = myprint1(nil, z...) // ERROR "myprint1\(nil, z...\) escapes to heap$" 695 } 696 697 func dotdotdot() { 698 i := 0 699 myprint(nil, &i) // ERROR "&i does not escape" "dotdotdot ... argument does not escape$" 700 701 j := 0 702 myprint1(nil, &j) // ERROR "&j does not escape" "dotdotdot ... argument does not escape$" 703 } 704 705 func foo78(z int) *int { // ERROR "moved to heap: z$" 706 return &z // ERROR "&z escapes to heap$" 707 } 708 709 func foo78a(z int) *int { // ERROR "moved to heap: z$" 710 y := &z // ERROR "&z escapes to heap$" 711 x := &y // ERROR "foo78a &y does not escape$" 712 return *x // really return y 713 } 714 715 func foo79() *int { 716 return new(int) // ERROR "new\(int\) escapes to heap$" 717 } 718 719 func foo80() *int { 720 var z *int 721 for { 722 // Really just escapes its scope but we don't distinguish 723 z = new(int) // ERROR "new\(int\) escapes to heap$" 724 } 725 _ = z 726 return nil 727 } 728 729 func foo81() *int { 730 for { 731 z := new(int) // ERROR "foo81 new\(int\) does not escape$" 732 _ = z 733 } 734 return nil 735 } 736 737 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$" 738 739 func noop(x, y *int) {} // ERROR "noop x does not escape$" "noop y does not escape$" 740 741 func foo82() { 742 var x, y, z int // ERROR "moved to heap: x$" "moved to heap: y$" "moved to heap: z$" 743 go noop(tee(&z)) // ERROR "&z escapes to heap$" 744 go noop(&x, &y) // ERROR "&x escapes to heap$" "&y escapes to heap$" 745 for { 746 var u, v, w int // ERROR "moved to heap: u$" "moved to heap: v$" "moved to heap: w$" 747 defer noop(tee(&u)) // ERROR "&u escapes to heap$" 748 defer noop(&v, &w) // ERROR "&v escapes to heap$" "&w escapes to heap$" 749 } 750 } 751 752 type Fooer interface { 753 Foo() 754 } 755 756 type LimitedFooer struct { 757 Fooer 758 N int64 759 } 760 761 func LimitFooer(r Fooer, n int64) Fooer { // ERROR "leaking param: r to result ~r2 level=-1$" 762 return &LimitedFooer{r, n} // ERROR "&LimitedFooer literal escapes to heap$" 763 } 764 765 func foo90(x *int) map[*int]*int { // ERROR "leaking param: x$" 766 return map[*int]*int{nil: x} // ERROR "map\[\*int\]\*int literal escapes to heap$" 767 } 768 769 func foo91(x *int) map[*int]*int { // ERROR "leaking param: x$" 770 return map[*int]*int{x: nil} // ERROR "map\[\*int\]\*int literal escapes to heap$" 771 } 772 773 func foo92(x *int) [2]*int { // ERROR "leaking param: x to result ~r1 level=0$" 774 return [2]*int{x, nil} 775 } 776 777 // does not leak c 778 func foo93(c chan *int) *int { // ERROR "foo93 c does not escape$" 779 for v := range c { 780 return v 781 } 782 return nil 783 } 784 785 // does not leak m 786 func foo94(m map[*int]*int, b bool) *int { // ERROR "leaking param: m to result ~r2 level=1" 787 for k, v := range m { 788 if b { 789 return k 790 } 791 return v 792 } 793 return nil 794 } 795 796 // does leak x 797 func foo95(m map[*int]*int, x *int) { // ERROR "foo95 m does not escape$" "leaking param: x$" 798 m[x] = x 799 } 800 801 // does not leak m but does leak content 802 func foo96(m []*int) *int { // ERROR "leaking param: m to result ~r1 level=1" 803 return m[0] 804 } 805 806 // does leak m 807 func foo97(m [1]*int) *int { // ERROR "leaking param: m to result ~r1 level=0$" 808 return m[0] 809 } 810 811 // does not leak m 812 func foo98(m map[int]*int) *int { // ERROR "foo98 m does not escape$" 813 return m[0] 814 } 815 816 // does leak m 817 func foo99(m *[1]*int) []*int { // ERROR "leaking param: m to result ~r1 level=0$" 818 return m[:] 819 } 820 821 // does not leak m 822 func foo100(m []*int) *int { // ERROR "leaking param: m to result ~r1 level=1" 823 for _, v := range m { 824 return v 825 } 826 return nil 827 } 828 829 // does leak m 830 func foo101(m [1]*int) *int { // ERROR "leaking param: m to result ~r1 level=0$" 831 for _, v := range m { 832 return v 833 } 834 return nil 835 } 836 837 // does not leak m 838 func foo101a(m [1]*int) *int { // ERROR "foo101a m does not escape$" 839 for i := range m { // ERROR "moved to heap: i$" 840 return &i // ERROR "&i escapes to heap$" 841 } 842 return nil 843 } 844 845 // does leak x 846 func foo102(m []*int, x *int) { // ERROR "foo102 m does not escape$" "leaking param: x$" 847 m[0] = x 848 } 849 850 // does not leak x 851 func foo103(m [1]*int, x *int) { // ERROR "foo103 m does not escape$" "foo103 x does not escape$" 852 m[0] = x 853 } 854 855 var y []*int 856 857 // does not leak x but does leak content 858 func foo104(x []*int) { // ERROR "leaking param content: x" 859 copy(y, x) 860 } 861 862 // does not leak x but does leak content 863 func foo105(x []*int) { // ERROR "leaking param content: x" 864 _ = append(y, x...) 865 } 866 867 // does leak x 868 func foo106(x *int) { // ERROR "leaking param: x$" 869 _ = append(y, x) 870 } 871 872 func foo107(x *int) map[*int]*int { // ERROR "leaking param: x$" 873 return map[*int]*int{x: nil} // ERROR "map\[\*int\]\*int literal escapes to heap$" 874 } 875 876 func foo108(x *int) map[*int]*int { // ERROR "leaking param: x$" 877 return map[*int]*int{nil: x} // ERROR "map\[\*int\]\*int literal escapes to heap$" 878 } 879 880 func foo109(x *int) *int { // ERROR "leaking param: x$" 881 m := map[*int]*int{x: nil} // ERROR "foo109 map\[\*int\]\*int literal does not escape$" 882 for k, _ := range m { 883 return k 884 } 885 return nil 886 } 887 888 func foo110(x *int) *int { // ERROR "leaking param: x$" 889 m := map[*int]*int{nil: x} // ERROR "foo110 map\[\*int\]\*int literal does not escape$" 890 return m[nil] 891 } 892 893 func foo111(x *int) *int { // ERROR "leaking param: x to result ~r1 level=0" 894 m := []*int{x} // ERROR "foo111 \[\]\*int literal does not escape$" 895 return m[0] 896 } 897 898 func foo112(x *int) *int { // ERROR "leaking param: x to result ~r1 level=0$" 899 m := [1]*int{x} 900 return m[0] 901 } 902 903 func foo113(x *int) *int { // ERROR "leaking param: x to result ~r1 level=0$" 904 m := Bar{ii: x} 905 return m.ii 906 } 907 908 func foo114(x *int) *int { // ERROR "leaking param: x to result ~r1 level=0$" 909 m := &Bar{ii: x} // ERROR "foo114 &Bar literal does not escape$" 910 return m.ii 911 } 912 913 func foo115(x *int) *int { // ERROR "leaking param: x to result ~r1 level=0$" 914 return (*int)(unsafe.Pointer(uintptr(unsafe.Pointer(x)) + 1)) 915 } 916 917 func foo116(b bool) *int { 918 if b { 919 x := 1 // ERROR "moved to heap: x$" 920 return &x // ERROR "&x escapes to heap$" 921 } else { 922 y := 1 // ERROR "moved to heap: y$" 923 return &y // ERROR "&y escapes to heap$" 924 } 925 return nil 926 } 927 928 func foo117(unknown func(interface{})) { // ERROR "foo117 unknown does not escape$" 929 x := 1 // ERROR "moved to heap: x$" 930 unknown(&x) // ERROR "&x escapes to heap$" 931 } 932 933 func foo118(unknown func(*int)) { // ERROR "foo118 unknown does not escape$" 934 x := 1 // ERROR "moved to heap: x$" 935 unknown(&x) // ERROR "&x escapes to heap$" 936 } 937 938 func external(*int) 939 940 func foo119(x *int) { // ERROR "leaking param: x$" 941 external(x) 942 } 943 944 func foo120() { 945 // formerly exponential time analysis 946 L1: 947 L2: 948 L3: 949 L4: 950 L5: 951 L6: 952 L7: 953 L8: 954 L9: 955 L10: 956 L11: 957 L12: 958 L13: 959 L14: 960 L15: 961 L16: 962 L17: 963 L18: 964 L19: 965 L20: 966 L21: 967 L22: 968 L23: 969 L24: 970 L25: 971 L26: 972 L27: 973 L28: 974 L29: 975 L30: 976 L31: 977 L32: 978 L33: 979 L34: 980 L35: 981 L36: 982 L37: 983 L38: 984 L39: 985 L40: 986 L41: 987 L42: 988 L43: 989 L44: 990 L45: 991 L46: 992 L47: 993 L48: 994 L49: 995 L50: 996 L51: 997 L52: 998 L53: 999 L54: 1000 L55: 1001 L56: 1002 L57: 1003 L58: 1004 L59: 1005 L60: 1006 L61: 1007 L62: 1008 L63: 1009 L64: 1010 L65: 1011 L66: 1012 L67: 1013 L68: 1014 L69: 1015 L70: 1016 L71: 1017 L72: 1018 L73: 1019 L74: 1020 L75: 1021 L76: 1022 L77: 1023 L78: 1024 L79: 1025 L80: 1026 L81: 1027 L82: 1028 L83: 1029 L84: 1030 L85: 1031 L86: 1032 L87: 1033 L88: 1034 L89: 1035 L90: 1036 L91: 1037 L92: 1038 L93: 1039 L94: 1040 L95: 1041 L96: 1042 L97: 1043 L98: 1044 L99: 1045 L100: 1046 // use the labels to silence compiler errors 1047 goto L1 1048 goto L2 1049 goto L3 1050 goto L4 1051 goto L5 1052 goto L6 1053 goto L7 1054 goto L8 1055 goto L9 1056 goto L10 1057 goto L11 1058 goto L12 1059 goto L13 1060 goto L14 1061 goto L15 1062 goto L16 1063 goto L17 1064 goto L18 1065 goto L19 1066 goto L20 1067 goto L21 1068 goto L22 1069 goto L23 1070 goto L24 1071 goto L25 1072 goto L26 1073 goto L27 1074 goto L28 1075 goto L29 1076 goto L30 1077 goto L31 1078 goto L32 1079 goto L33 1080 goto L34 1081 goto L35 1082 goto L36 1083 goto L37 1084 goto L38 1085 goto L39 1086 goto L40 1087 goto L41 1088 goto L42 1089 goto L43 1090 goto L44 1091 goto L45 1092 goto L46 1093 goto L47 1094 goto L48 1095 goto L49 1096 goto L50 1097 goto L51 1098 goto L52 1099 goto L53 1100 goto L54 1101 goto L55 1102 goto L56 1103 goto L57 1104 goto L58 1105 goto L59 1106 goto L60 1107 goto L61 1108 goto L62 1109 goto L63 1110 goto L64 1111 goto L65 1112 goto L66 1113 goto L67 1114 goto L68 1115 goto L69 1116 goto L70 1117 goto L71 1118 goto L72 1119 goto L73 1120 goto L74 1121 goto L75 1122 goto L76 1123 goto L77 1124 goto L78 1125 goto L79 1126 goto L80 1127 goto L81 1128 goto L82 1129 goto L83 1130 goto L84 1131 goto L85 1132 goto L86 1133 goto L87 1134 goto L88 1135 goto L89 1136 goto L90 1137 goto L91 1138 goto L92 1139 goto L93 1140 goto L94 1141 goto L95 1142 goto L96 1143 goto L97 1144 goto L98 1145 goto L99 1146 goto L100 1147 } 1148 1149 func foo121() { 1150 for i := 0; i < 10; i++ { 1151 defer myprint(nil, i) // ERROR "... argument escapes to heap$" "i escapes to heap$" 1152 go myprint(nil, i) // ERROR "... argument escapes to heap$" "i escapes to heap$" 1153 } 1154 } 1155 1156 // same as foo121 but check across import 1157 func foo121b() { 1158 for i := 0; i < 10; i++ { 1159 defer fmt.Printf("%d", i) // ERROR "... argument escapes to heap$" "i escapes to heap$" 1160 go fmt.Printf("%d", i) // ERROR "... argument escapes to heap$" "i escapes to heap$" 1161 } 1162 } 1163 1164 // a harmless forward jump 1165 func foo122() { 1166 var i *int 1167 1168 goto L1 1169 L1: 1170 i = new(int) // ERROR "foo122 new\(int\) does not escape$" 1171 _ = i 1172 } 1173 1174 // a backward jump, increases loopdepth 1175 func foo123() { 1176 var i *int 1177 1178 L1: 1179 i = new(int) // ERROR "new\(int\) escapes to heap$" 1180 1181 goto L1 1182 _ = i 1183 } 1184 1185 func foo124(x **int) { // ERROR "foo124 x does not escape$" 1186 var i int // ERROR "moved to heap: i$" 1187 p := &i // ERROR "&i escapes to heap$" 1188 func() { // ERROR "foo124 func literal does not escape$" 1189 *x = p // ERROR "leaking closure reference p$" 1190 }() 1191 } 1192 1193 func foo125(ch chan *int) { // ERROR "foo125 ch does not escape$" 1194 var i int // ERROR "moved to heap: i$" 1195 p := &i // ERROR "&i escapes to heap$" 1196 func() { // ERROR "foo125 func literal does not escape$" 1197 ch <- p // ERROR "leaking closure reference p$" 1198 }() 1199 } 1200 1201 func foo126() { 1202 var px *int // loopdepth 0 1203 for { 1204 // loopdepth 1 1205 var i int // ERROR "moved to heap: i$" 1206 func() { // ERROR "foo126 func literal does not escape$" 1207 px = &i // ERROR "&i escapes to heap$" "leaking closure reference i" 1208 }() 1209 } 1210 _ = px 1211 } 1212 1213 var px *int 1214 1215 func foo127() { 1216 var i int // ERROR "moved to heap: i$" 1217 p := &i // ERROR "&i escapes to heap$" 1218 q := p 1219 px = q 1220 } 1221 1222 func foo128() { 1223 var i int 1224 p := &i // ERROR "foo128 &i does not escape$" 1225 q := p 1226 _ = q 1227 } 1228 1229 func foo129() { 1230 var i int // ERROR "moved to heap: i$" 1231 p := &i // ERROR "&i escapes to heap$" 1232 func() { // ERROR "foo129 func literal does not escape$" 1233 q := p // ERROR "leaking closure reference p$" 1234 func() { // ERROR "foo129.func1 func literal does not escape$" 1235 r := q // ERROR "leaking closure reference q$" 1236 px = r 1237 }() 1238 }() 1239 } 1240 1241 func foo130() { 1242 for { 1243 var i int // ERROR "moved to heap: i$" 1244 func() { // ERROR "foo130 func literal does not escape$" 1245 px = &i // ERROR "&i escapes to heap$" "leaking closure reference i$" 1246 }() 1247 } 1248 } 1249 1250 func foo131() { 1251 var i int // ERROR "moved to heap: i$" 1252 func() { // ERROR "foo131 func literal does not escape$" 1253 px = &i // ERROR "&i escapes to heap$" "leaking closure reference i$" 1254 }() 1255 } 1256 1257 func foo132() { 1258 var i int // ERROR "moved to heap: i$" 1259 go func() { // ERROR "func literal escapes to heap$" 1260 px = &i // ERROR "&i escapes to heap$" "leaking closure reference i$" 1261 }() 1262 } 1263 1264 func foo133() { 1265 var i int // ERROR "moved to heap: i$" 1266 defer func() { // ERROR "foo133 func literal does not escape$" 1267 px = &i // ERROR "&i escapes to heap$" "leaking closure reference i$" 1268 }() 1269 } 1270 1271 func foo134() { 1272 var i int 1273 p := &i // ERROR "foo134 &i does not escape$" 1274 func() { // ERROR "foo134 func literal does not escape$" 1275 q := p 1276 func() { // ERROR "foo134.func1 func literal does not escape$" 1277 r := q 1278 _ = r 1279 }() 1280 }() 1281 } 1282 1283 func foo135() { 1284 var i int // ERROR "moved to heap: i$" 1285 p := &i // ERROR "&i escapes to heap$" 1286 go func() { // ERROR "func literal escapes to heap$" 1287 q := p 1288 func() { // ERROR "foo135.func1 func literal does not escape$" 1289 r := q 1290 _ = r 1291 }() 1292 }() 1293 } 1294 1295 func foo136() { 1296 var i int // ERROR "moved to heap: i$" 1297 p := &i // ERROR "&i escapes to heap$" 1298 go func() { // ERROR "func literal escapes to heap$" 1299 q := p // ERROR "leaking closure reference p$" 1300 func() { // ERROR "foo136.func1 func literal does not escape$" 1301 r := q // ERROR "leaking closure reference q$" 1302 px = r 1303 }() 1304 }() 1305 } 1306 1307 func foo137() { 1308 var i int // ERROR "moved to heap: i$" 1309 p := &i // ERROR "&i escapes to heap$" 1310 func() { // ERROR "foo137 func literal does not escape$" 1311 q := p // ERROR "leaking closure reference p$" 1312 go func() { // ERROR "func literal escapes to heap$" 1313 r := q 1314 _ = r 1315 }() 1316 }() 1317 } 1318 1319 func foo138() *byte { 1320 type T struct { 1321 x [1]byte 1322 } 1323 t := new(T) // ERROR "new\(T\) escapes to heap$" 1324 return &t.x[0] // ERROR "&t.x\[0\] escapes to heap$" 1325 } 1326 1327 func foo139() *byte { 1328 type T struct { 1329 x struct { 1330 y byte 1331 } 1332 } 1333 t := new(T) // ERROR "new\(T\) escapes to heap$" 1334 return &t.x.y // ERROR "&t.x.y escapes to heap$" 1335 } 1336 1337 // issue 4751 1338 func foo140() interface{} { 1339 type T struct { 1340 X string 1341 } 1342 type U struct { 1343 X string 1344 T *T 1345 } 1346 t := &T{} // ERROR "&T literal escapes to heap$" 1347 return U{ // ERROR "U literal escapes to heap$" 1348 X: t.X, 1349 T: t, 1350 } 1351 } 1352 1353 //go:noescape 1354 1355 func F1([]byte) 1356 1357 func F2([]byte) 1358 1359 //go:noescape 1360 1361 func F3(x []byte) // ERROR "F3 x does not escape$" 1362 1363 func F4(x []byte) 1364 1365 func G() { 1366 var buf1 [10]byte 1367 F1(buf1[:]) // ERROR "G buf1 does not escape$" 1368 1369 var buf2 [10]byte // ERROR "moved to heap: buf2$" 1370 F2(buf2[:]) // ERROR "buf2 escapes to heap$" 1371 1372 var buf3 [10]byte 1373 F3(buf3[:]) // ERROR "G buf3 does not escape$" 1374 1375 var buf4 [10]byte // ERROR "moved to heap: buf4$" 1376 F4(buf4[:]) // ERROR "buf4 escapes to heap$" 1377 } 1378 1379 type Tm struct { 1380 x int 1381 } 1382 1383 func (t *Tm) M() { // ERROR "\(\*Tm\).M t does not escape$" 1384 } 1385 1386 func foo141() { 1387 var f func() 1388 1389 t := new(Tm) // ERROR "new\(Tm\) escapes to heap$" 1390 f = t.M // ERROR "foo141 t.M does not escape$" 1391 _ = f 1392 } 1393 1394 var gf func() 1395 1396 func foo142() { 1397 t := new(Tm) // ERROR "new\(Tm\) escapes to heap$" 1398 gf = t.M // ERROR "t.M escapes to heap$" 1399 } 1400 1401 // issue 3888. 1402 func foo143() { 1403 for i := 0; i < 1000; i++ { 1404 func() { // ERROR "foo143 func literal does not escape$" 1405 for i := 0; i < 1; i++ { 1406 var t Tm 1407 t.M() // ERROR "foo143.func1 t does not escape$" 1408 } 1409 }() 1410 } 1411 } 1412 1413 // issue 5773 1414 // Check that annotations take effect regardless of whether they 1415 // are before or after the use in the source code. 1416 1417 //go:noescape 1418 1419 func foo144a(*int) 1420 1421 func foo144() { 1422 var x int 1423 foo144a(&x) // ERROR "foo144 &x does not escape$" 1424 var y int 1425 foo144b(&y) // ERROR "foo144 &y does not escape$" 1426 } 1427 1428 //go:noescape 1429 1430 func foo144b(*int) 1431 1432 // issue 7313: for loop init should not be treated as "in loop" 1433 1434 type List struct { 1435 Next *List 1436 } 1437 1438 func foo145(l List) { // ERROR "foo145 l does not escape$" 1439 var p *List 1440 for p = &l; p.Next != nil; p = p.Next { // ERROR "foo145 &l does not escape$" 1441 } 1442 } 1443 1444 func foo146(l List) { // ERROR "foo146 l does not escape$" 1445 var p *List 1446 p = &l // ERROR "foo146 &l does not escape$" 1447 for ; p.Next != nil; p = p.Next { 1448 } 1449 } 1450 1451 func foo147(l List) { // ERROR "foo147 l does not escape$" 1452 var p *List 1453 p = &l // ERROR "foo147 &l does not escape$" 1454 for p.Next != nil { 1455 p = p.Next 1456 } 1457 } 1458 1459 func foo148(l List) { // ERROR "foo148 l does not escape$" 1460 for p := &l; p.Next != nil; p = p.Next { // ERROR "foo148 &l does not escape$" 1461 } 1462 } 1463 1464 // related: address of variable should have depth of variable, not of loop 1465 1466 func foo149(l List) { // ERROR "foo149 l does not escape$" 1467 var p *List 1468 for { 1469 for p = &l; p.Next != nil; p = p.Next { // ERROR "foo149 &l does not escape$" 1470 } 1471 } 1472 } 1473 1474 // issue 7934: missed ... if element type had no pointers 1475 1476 var save150 []byte 1477 1478 func foo150(x ...byte) { // ERROR "leaking param: x$" 1479 save150 = x 1480 } 1481 1482 func bar150() { 1483 foo150(1, 2, 3) // ERROR "... argument escapes to heap$" 1484 } 1485 1486 // issue 7931: bad handling of slice of array 1487 1488 var save151 *int 1489 1490 func foo151(x *int) { // ERROR "leaking param: x$" 1491 save151 = x 1492 } 1493 1494 func bar151() { 1495 var a [64]int // ERROR "moved to heap: a$" 1496 a[4] = 101 1497 foo151(&(&a)[4:8][0]) // ERROR "&\(&a\)\[4:8\]\[0\] escapes to heap$" "&a escapes to heap$" 1498 } 1499 1500 func bar151b() { 1501 var a [10]int // ERROR "moved to heap: a$" 1502 b := a[:] // ERROR "a escapes to heap$" 1503 foo151(&b[4:8][0]) // ERROR "&b\[4:8\]\[0\] escapes to heap$" 1504 } 1505 1506 func bar151c() { 1507 var a [64]int // ERROR "moved to heap: a$" 1508 a[4] = 101 1509 foo151(&(&a)[4:8:8][0]) // ERROR "&\(&a\)\[4:8:8\]\[0\] escapes to heap$" "&a escapes to heap$" 1510 } 1511 1512 func bar151d() { 1513 var a [10]int // ERROR "moved to heap: a$" 1514 b := a[:] // ERROR "a escapes to heap$" 1515 foo151(&b[4:8:8][0]) // ERROR "&b\[4:8:8\]\[0\] escapes to heap$" 1516 } 1517 1518 // issue 8120 1519 1520 type U struct { 1521 s *string 1522 } 1523 1524 func (u *U) String() *string { // ERROR "leaking param: u to result ~r0 level=1$" 1525 return u.s 1526 } 1527 1528 type V struct { 1529 s *string 1530 } 1531 1532 // BAD -- level of leak ought to be 0 1533 func NewV(u U) *V { // ERROR "leaking param: u to result ~r1 level=-1" 1534 return &V{u.String()} // ERROR "&V literal escapes to heap$" "NewV u does not escape" 1535 } 1536 1537 func foo152() { 1538 a := "a" // ERROR "moved to heap: a$" 1539 u := U{&a} // ERROR "&a escapes to heap$" 1540 v := NewV(u) 1541 println(v) 1542 } 1543 1544 // issue 8176 - &x in type switch body not marked as escaping 1545 1546 func foo153(v interface{}) *int { // ERROR "leaking param: v to result ~r1 level=-1$" 1547 switch x := v.(type) { 1548 case int: // ERROR "moved to heap: x$" 1549 return &x // ERROR "&x escapes to heap$" 1550 } 1551 panic(0) 1552 } 1553 1554 // issue 8185 - &result escaping into result 1555 1556 func f() (x int, y *int) { // ERROR "moved to heap: x$" 1557 y = &x // ERROR "&x escapes to heap$" 1558 return 1559 } 1560 1561 func g() (x interface{}) { // ERROR "moved to heap: x$" 1562 x = &x // ERROR "&x escapes to heap$" 1563 return 1564 } 1565 1566 var sink interface{} 1567 1568 type Lit struct { 1569 p *int 1570 } 1571 1572 func ptrlitNoescape() { 1573 // Both literal and element do not escape. 1574 i := 0 1575 x := &Lit{&i} // ERROR "ptrlitNoescape &Lit literal does not escape$" "ptrlitNoescape &i does not escape$" 1576 _ = x 1577 } 1578 1579 func ptrlitNoEscape2() { 1580 // Literal does not escape, but element does. 1581 i := 0 // ERROR "moved to heap: i$" 1582 x := &Lit{&i} // ERROR "&i escapes to heap$" "ptrlitNoEscape2 &Lit literal does not escape$" 1583 sink = *x // ERROR "\*x escapes to heap$" 1584 } 1585 1586 func ptrlitEscape() { 1587 // Both literal and element escape. 1588 i := 0 // ERROR "moved to heap: i$" 1589 x := &Lit{&i} // ERROR "&Lit literal escapes to heap$" "&i escapes to heap$" 1590 sink = x // ERROR "x escapes to heap$" 1591 } 1592 1593 // self-assignments 1594 1595 type Buffer struct { 1596 arr [64]byte 1597 buf1 []byte 1598 buf2 []byte 1599 str1 string 1600 str2 string 1601 } 1602 1603 func (b *Buffer) foo() { // ERROR "\(\*Buffer\).foo b does not escape$" 1604 b.buf1 = b.buf1[1:2] // ERROR "\(\*Buffer\).foo ignoring self-assignment to b.buf1$" 1605 b.buf1 = b.buf1[1:2:3] // ERROR "\(\*Buffer\).foo ignoring self-assignment to b.buf1$" 1606 b.buf1 = b.buf2[1:2] // ERROR "\(\*Buffer\).foo ignoring self-assignment to b.buf1$" 1607 b.buf1 = b.buf2[1:2:3] // ERROR "\(\*Buffer\).foo ignoring self-assignment to b.buf1$" 1608 } 1609 1610 func (b *Buffer) bar() { // ERROR "leaking param: b$" 1611 b.buf1 = b.arr[1:2] // ERROR "b.arr escapes to heap$" 1612 } 1613 1614 func (b *Buffer) baz() { // ERROR "\(\*Buffer\).baz b does not escape$" 1615 b.str1 = b.str1[1:2] // ERROR "\(\*Buffer\).baz ignoring self-assignment to b.str1$" 1616 b.str1 = b.str2[1:2] // ERROR "\(\*Buffer\).baz ignoring self-assignment to b.str1$" 1617 } 1618 1619 func (b *Buffer) bat() { // ERROR "leaking param content: b$" 1620 o := new(Buffer) // ERROR "new\(Buffer\) escapes to heap$" 1621 o.buf1 = b.buf1[1:2] 1622 sink = o // ERROR "o escapes to heap$" 1623 } 1624 1625 func quux(sp *string, bp *[]byte) { // ERROR "quux bp does not escape$" "quux sp does not escape$" 1626 *sp = (*sp)[1:2] // ERROR "quux ignoring self-assignment to \*sp$" 1627 *bp = (*bp)[1:2] // ERROR "quux ignoring self-assignment to \*bp$" 1628 } 1629 1630 type StructWithString struct { 1631 p *int 1632 s string 1633 } 1634 1635 // This is escape analysis false negative. 1636 // We assign the pointer to x.p but leak x.s. Escape analysis coarsens flows 1637 // to just x, and thus &i looks escaping. 1638 func fieldFlowTracking() { 1639 var x StructWithString 1640 i := 0 // ERROR "moved to heap: i$" 1641 x.p = &i // ERROR "&i escapes to heap$" 1642 sink = x.s // ERROR "x.s escapes to heap$" 1643 } 1644 1645 // String operations. 1646 1647 func slicebytetostring0() { 1648 b := make([]byte, 20) // ERROR "slicebytetostring0 make\(\[\]byte, 20\) does not escape$" 1649 s := string(b) // ERROR "slicebytetostring0 string\(b\) does not escape$" 1650 _ = s 1651 } 1652 1653 func slicebytetostring1() { 1654 b := make([]byte, 20) // ERROR "slicebytetostring1 make\(\[\]byte, 20\) does not escape$" 1655 s := string(b) // ERROR "slicebytetostring1 string\(b\) does not escape$" 1656 s1 := s[0:1] 1657 _ = s1 1658 } 1659 1660 func slicebytetostring2() { 1661 b := make([]byte, 20) // ERROR "slicebytetostring2 make\(\[\]byte, 20\) does not escape$" 1662 s := string(b) // ERROR "string\(b\) escapes to heap$" 1663 s1 := s[0:1] // ERROR "moved to heap: s1$" 1664 sink = &s1 // ERROR "&s1 escapes to heap$" 1665 } 1666 1667 func slicebytetostring3() { 1668 b := make([]byte, 20) // ERROR "slicebytetostring3 make\(\[\]byte, 20\) does not escape$" 1669 s := string(b) // ERROR "string\(b\) escapes to heap$" 1670 s1 := s[0:1] 1671 sink = s1 // ERROR "s1 escapes to heap$" 1672 } 1673 1674 func addstr0() { 1675 s0 := "a" 1676 s1 := "b" 1677 s := s0 + s1 // ERROR "addstr0 s0 \+ s1 does not escape$" 1678 _ = s 1679 } 1680 1681 func addstr1() { 1682 s0 := "a" 1683 s1 := "b" 1684 s := "c" 1685 s += s0 + s1 // ERROR "addstr1 s0 \+ s1 does not escape$" 1686 _ = s 1687 } 1688 1689 func addstr2() { 1690 b := make([]byte, 20) // ERROR "addstr2 make\(\[\]byte, 20\) does not escape$" 1691 s0 := "a" 1692 s := string(b) + s0 // ERROR "addstr2 string\(b\) \+ s0 does not escape$" "addstr2 string\(b\) does not escape$" 1693 _ = s 1694 } 1695 1696 func addstr3() { 1697 s0 := "a" 1698 s1 := "b" 1699 s := s0 + s1 // ERROR "s0 \+ s1 escapes to heap$" 1700 s2 := s[0:1] 1701 sink = s2 // ERROR "s2 escapes to heap$" 1702 } 1703 1704 func intstring0() bool { 1705 // string does not escape 1706 x := '0' 1707 s := string(x) // ERROR "intstring0 string\(x\) does not escape$" 1708 return s == "0" 1709 } 1710 1711 func intstring1() string { 1712 // string does not escape, but the buffer does 1713 x := '0' 1714 s := string(x) // ERROR "string\(x\) escapes to heap$" 1715 return s 1716 } 1717 1718 func intstring2() { 1719 // string escapes to heap 1720 x := '0' 1721 s := string(x) // ERROR "moved to heap: s$" "string\(x\) escapes to heap$" 1722 sink = &s // ERROR "&s escapes to heap$" 1723 } 1724 1725 func stringtoslicebyte0() { 1726 s := "foo" 1727 x := []byte(s) // ERROR "stringtoslicebyte0 \(\[\]byte\)\(s\) does not escape$" 1728 _ = x 1729 } 1730 1731 func stringtoslicebyte1() []byte { 1732 s := "foo" 1733 return []byte(s) // ERROR "\(\[\]byte\)\(s\) escapes to heap$" 1734 } 1735 1736 func stringtoslicebyte2() { 1737 s := "foo" 1738 sink = []byte(s) // ERROR "\(\[\]byte\)\(s\) escapes to heap$" 1739 } 1740 1741 func stringtoslicerune0() { 1742 s := "foo" 1743 x := []rune(s) // ERROR "stringtoslicerune0 \(\[\]rune\)\(s\) does not escape$" 1744 _ = x 1745 } 1746 1747 func stringtoslicerune1() []rune { 1748 s := "foo" 1749 return []rune(s) // ERROR "\(\[\]rune\)\(s\) escapes to heap$" 1750 } 1751 1752 func stringtoslicerune2() { 1753 s := "foo" 1754 sink = []rune(s) // ERROR "\(\[\]rune\)\(s\) escapes to heap$" 1755 } 1756 1757 func slicerunetostring0() { 1758 r := []rune{1, 2, 3} // ERROR "slicerunetostring0 \[\]rune literal does not escape$" 1759 s := string(r) // ERROR "slicerunetostring0 string\(r\) does not escape$" 1760 _ = s 1761 } 1762 1763 func slicerunetostring1() string { 1764 r := []rune{1, 2, 3} // ERROR "slicerunetostring1 \[\]rune literal does not escape$" 1765 return string(r) // ERROR "string\(r\) escapes to heap$" 1766 } 1767 1768 func slicerunetostring2() { 1769 r := []rune{1, 2, 3} // ERROR "slicerunetostring2 \[\]rune literal does not escape$" 1770 sink = string(r) // ERROR "string\(r\) escapes to heap$" 1771 } 1772 1773 func makemap0() { 1774 m := make(map[int]int) // ERROR "makemap0 make\(map\[int\]int\) does not escape$" 1775 m[0] = 0 1776 m[1]++ 1777 delete(m, 1) 1778 sink = m[0] // ERROR "m\[0\] escapes to heap$" 1779 } 1780 1781 func makemap1() map[int]int { 1782 return make(map[int]int) // ERROR "make\(map\[int\]int\) escapes to heap$" 1783 } 1784 1785 func makemap2() { 1786 m := make(map[int]int) // ERROR "make\(map\[int\]int\) escapes to heap$" 1787 sink = m // ERROR "m escapes to heap$" 1788 } 1789 1790 func nonescapingEface(m map[interface{}]bool) bool { // ERROR "nonescapingEface m does not escape$" 1791 return m["foo"] // ERROR "nonescapingEface .foo. does not escape$" 1792 } 1793 1794 func nonescapingIface(m map[M]bool) bool { // ERROR "nonescapingIface m does not escape$" 1795 return m[MV(0)] // ERROR "nonescapingIface MV\(0\) does not escape$" 1796 } 1797 1798 func issue10353() { 1799 x := new(int) // ERROR "new\(int\) escapes to heap$" 1800 issue10353a(x)() 1801 } 1802 1803 func issue10353a(x *int) func() { // ERROR "leaking param: x to result ~r1 level=-1$" 1804 return func() { // ERROR "func literal escapes to heap$" 1805 println(*x) 1806 } 1807 } 1808 1809 func issue10353b() { 1810 var f func() 1811 for { 1812 x := new(int) // ERROR "new\(int\) escapes to heap$" 1813 f = func() { // ERROR "func literal escapes to heap$" 1814 println(*x) 1815 } 1816 } 1817 _ = f 1818 } 1819 1820 func issue11387(x int) func() int { 1821 f := func() int { return x } // ERROR "func literal escapes to heap" 1822 slice1 := []func() int{f} // ERROR "\[\].* does not escape" 1823 slice2 := make([]func() int, 1) // ERROR "make\(.*\) does not escape" 1824 copy(slice2, slice1) 1825 return slice2[0] 1826 } 1827
