← Back to branch summary

~ubuntu-branches/ubuntu/vivid/golang/vivid

« back to all changes in this revision

Viewing changes to test/escape5.go

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2013-08-20 14:06:23 UTC
  • mfrom: (14.1.23 saucy-proposed)
  • Revision ID: package-import@ubuntu.com-20130820140623-b414jfxi3m0qkmrq
Tags: 2:1.1.2-2ubuntu1
https://launchpad.net/bugs/1211749
https://launchpad.net/bugs/1202027
* Merge from Debian unstable (LP: #1211749, #1202027). Remaining changes:
  - 016-armhf-elf-header.patch: Use correct ELF header for armhf binaries.
  - d/control,control.cross: Update Breaks/Replaces for Ubuntu
    versions to ensure smooth upgrades, regenerate control file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/escape5.go
 
1
// errorcheck -0 -m -l
 
2
 
 
3
// Copyright 2012 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
package foo
 
11
 
 
12
func noleak(p *int) int { // ERROR "p does not escape"
 
13
        return *p
 
14
}
 
15
 
 
16
func leaktoret(p *int) *int { // ERROR "leaking param: p to result"
 
17
        return p
 
18
}
 
19
 
 
20
func leaktoret2(p *int) (*int, *int) { // ERROR "leaking param: p to result .anon1" "leaking param: p to result .anon2"
 
21
        return p, p
 
22
}
 
23
 
 
24
func leaktoret22(p, q *int) (*int, *int) { // ERROR "leaking param: p to result .anon2" "leaking param: q to result .anon3"
 
25
        return p, q
 
26
}
 
27
 
 
28
func leaktoret22b(p, q *int) (*int, *int) { // ERROR "leaking param: p to result .anon3" "leaking param: q to result .anon2"
 
29
        return leaktoret22(q, p)
 
30
}
 
31
 
 
32
func leaktoret22c(p, q *int) (*int, *int) { // ERROR "leaking param: p to result .anon3" "leaking param: q to result .anon2"
 
33
        r, s := leaktoret22(q, p)
 
34
        return r, s
 
35
}
 
36
 
 
37
func leaktoret22d(p, q *int) (r, s *int) { // ERROR "leaking param: p to result s" "leaking param: q to result r"
 
38
        r, s = leaktoret22(q, p)
 
39
        return
 
40
}
 
41
 
 
42
func leaktoret22e(p, q *int) (r, s *int) { // ERROR "leaking param: p to result s" "leaking param: q to result r"
 
43
        r, s = leaktoret22(q, p)
 
44
        return r, s
 
45
}
 
46
 
 
47
func leaktoret22f(p, q *int) (r, s *int) { // ERROR "leaking param: p to result s" "leaking param: q to result r"
 
48
        rr, ss := leaktoret22(q, p)
 
49
        return rr, ss
 
50
}
 
51
 
 
52
var gp *int
 
53
 
 
54
func leaktosink(p *int) *int { // ERROR "leaking param: p"
 
55
        gp = p
 
56
        return p
 
57
}
 
58
 
 
59
func f1() {
 
60
        var x int
 
61
        p := noleak(&x) // ERROR "&x does not escape"
 
62
        _ = p
 
63
}
 
64
 
 
65
func f2() {
 
66
        var x int
 
67
        p := leaktoret(&x) // ERROR "&x does not escape"
 
68
        _ = p
 
69
}
 
70
 
 
71
func f3() {
 
72
        var x int          // ERROR "moved to heap: x"
 
73
        p := leaktoret(&x) // ERROR "&x escapes to heap"
 
74
        gp = p
 
75
}
 
76
 
 
77
func f4() {
 
78
        var x int              // ERROR "moved to heap: x"
 
79
        p, q := leaktoret2(&x) // ERROR "&x escapes to heap"
 
80
        gp = p
 
81
        gp = q
 
82
}
 
83
 
 
84
func f5() {
 
85
        var x int
 
86
        leaktoret22(leaktoret2(&x)) // ERROR "&x does not escape"
 
87
}
 
88
 
 
89
func f6() {
 
90
        var x int                               // ERROR "moved to heap: x"
 
91
        px1, px2 := leaktoret22(leaktoret2(&x)) // ERROR "&x escapes to heap"
 
92
        gp = px1
 
93
        _ = px2
 
94
}
 
95
 
 
96
type T struct{ x int }
 
97
 
 
98
func (t *T) Foo(u int) (*T, bool) { // ERROR "leaking param: t to result"
 
99
        t.x += u
 
100
        return t, true
 
101
}
 
102
 
 
103
func f7() *T {
 
104
        r, _ := new(T).Foo(42) // ERROR "new.T. escapes to heap"
 
105
        return r
 
106
}
 
107
 
 
108
func leakrecursive1(p, q *int) (*int, *int) { // ERROR "leaking param: p" "leaking param: q"
 
109
        return leakrecursive2(q, p)
 
110
}
 
111
 
 
112
func leakrecursive2(p, q *int) (*int, *int) { // ERROR "leaking param: p" "leaking param: q"
 
113
        if *p > *q {
 
114
                return leakrecursive1(q, p)
 
115
        }
 
116
        // without this, leakrecursive? are safe for p and q, b/c in fact their graph does not have leaking edges.
 
117
        return p, q
 
118
}
 
119
 
 
120
 
 
121
var global interface{}
 
122
 
 
123
type T1 struct {
 
124
        X *int
 
125
}
 
126
 
 
127
type T2 struct {
 
128
        Y *T1
 
129
}
 
130
 
 
131
func f8(p *T1) (k T2) { // ERROR "leaking param: p to result k" "leaking param: p"
 
132
        if p == nil {
 
133
                k = T2{}
 
134
                return
 
135
        }
 
136
 
 
137
        global = p // should make p leak always
 
138
        return T2{p}
 
139
}
 
140
 
 
141
func f9() {
 
142
        var j T1 // ERROR "moved to heap: j"
 
143
        f8(&j) // ERROR "&j escapes to heap"
 
144
}