← Back to branch summary

~ubuntu-branches/ubuntu/saucy/golang/saucy

« back to all changes in this revision

Viewing changes to test/bounds.go

  • Committer: Package Import Robot
  • Author(s): Adam Conrad
  • Date: 2013-07-08 05:52:37 UTC
  • mfrom: (29.1.1 sid)
  • Revision ID: package-import@ubuntu.com-20130708055237-at01839e0hp8z3ni
Tags: 2:1.1-1ubuntu1
016-armhf-elf-header.patch: Use correct ELF header for armhf binaries.

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/bounds.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 bounds check elimination
 
8
// is eliminating the correct checks.
 
9
 
 
10
package foo
 
11
 
 
12
var (
 
13
        s []int
 
14
 
 
15
        a1 [1]int
 
16
        a1k [1000]int
 
17
        a100k [100000]int
 
18
 
 
19
        p1 *[1]int
 
20
        p1k *[1000]int
 
21
        p100k *[100000]int
 
22
 
 
23
        i int
 
24
        ui uint
 
25
        i8 int8
 
26
        ui8 uint8
 
27
        i16 int16
 
28
        ui16 uint16
 
29
        i32 int32
 
30
        ui32 uint32
 
31
        i64 int64
 
32
        ui64 uint64
 
33
)
 
34
 
 
35
func main() {
 
36
        // Most things need checks.
 
37
        use(s[i])
 
38
        use(a1[i])
 
39
        use(a1k[i])
 
40
        use(a100k[i])
 
41
        use(p1[i])
 
42
        use(p1k[i])
 
43
        use(p100k[i])
 
44
 
 
45
        use(s[ui])
 
46
        use(a1[ui])
 
47
        use(a1k[ui])
 
48
        use(a100k[ui])
 
49
        use(p1[ui])
 
50
        use(p1k[ui])
 
51
        use(p100k[ui])
 
52
 
 
53
        use(s[i8])
 
54
        use(a1[i8])
 
55
        use(a1k[i8])
 
56
        use(a100k[i8])
 
57
        use(p1[i8])
 
58
        use(p1k[i8])
 
59
        use(p100k[i8])
 
60
 
 
61
        // Unsigned 8-bit numbers don't need checks for len >= 2⁸.
 
62
        use(s[ui8])
 
63
        use(a1[ui8])
 
64
        use(a1k[ui8])  // ERROR "index bounds check elided"
 
65
        use(a100k[ui8])  // ERROR "index bounds check elided"
 
66
        use(p1[ui8])
 
67
        use(p1k[ui8])  // ERROR "index bounds check elided"
 
68
        use(p100k[ui8])  // ERROR "index bounds check elided"
 
69
 
 
70
        use(s[i16])
 
71
        use(a1[i16])
 
72
        use(a1k[i16])
 
73
        use(a100k[i16])
 
74
        use(p1[i16])
 
75
        use(p1k[i16])
 
76
        use(p100k[i16])
 
77
 
 
78
        // Unsigned 16-bit numbers don't need checks for len >= 2¹⁶.
 
79
        use(s[ui16])
 
80
        use(a1[ui16])
 
81
        use(a1k[ui16])
 
82
        use(a100k[ui16])  // ERROR "index bounds check elided"
 
83
        use(p1[ui16])
 
84
        use(p1k[ui16])
 
85
        use(p100k[ui16])  // ERROR "index bounds check elided"
 
86
 
 
87
        use(s[i32])
 
88
        use(a1[i32])
 
89
        use(a1k[i32])
 
90
        use(a100k[i32])
 
91
        use(p1[i32])
 
92
        use(p1k[i32])
 
93
        use(p100k[i32])
 
94
 
 
95
        use(s[ui32])
 
96
        use(a1[ui32])
 
97
        use(a1k[ui32])
 
98
        use(a100k[ui32])
 
99
        use(p1[ui32])
 
100
        use(p1k[ui32])
 
101
        use(p100k[ui32])
 
102
 
 
103
        use(s[i64])
 
104
        use(a1[i64])
 
105
        use(a1k[i64])
 
106
        use(a100k[i64])
 
107
        use(p1[i64])
 
108
        use(p1k[i64])
 
109
        use(p100k[i64])
 
110
 
 
111
        use(s[ui64])
 
112
        use(a1[ui64])
 
113
        use(a1k[ui64])
 
114
        use(a100k[ui64])
 
115
        use(p1[ui64])
 
116
        use(p1k[ui64])
 
117
        use(p100k[ui64])
 
118
 
 
119
        // Mod truncates the maximum value to one less than the argument,
 
120
        // but signed mod can be negative, so only unsigned mod counts.
 
121
        use(s[i%999])
 
122
        use(a1[i%999])
 
123
        use(a1k[i%999])
 
124
        use(a100k[i%999])
 
125
        use(p1[i%999])
 
126
        use(p1k[i%999])
 
127
        use(p100k[i%999])
 
128
 
 
129
        use(s[ui%999])
 
130
        use(a1[ui%999])
 
131
        use(a1k[ui%999])  // ERROR "index bounds check elided"
 
132
        use(a100k[ui%999])  // ERROR "index bounds check elided"
 
133
        use(p1[ui%999])
 
134
        use(p1k[ui%999])  // ERROR "index bounds check elided"
 
135
        use(p100k[ui%999])  // ERROR "index bounds check elided"
 
136
 
 
137
        use(s[i%1000])
 
138
        use(a1[i%1000])
 
139
        use(a1k[i%1000])
 
140
        use(a100k[i%1000])
 
141
        use(p1[i%1000])
 
142
        use(p1k[i%1000])
 
143
        use(p100k[i%1000])
 
144
 
 
145
        use(s[ui%1000])
 
146
        use(a1[ui%1000])
 
147
        use(a1k[ui%1000])  // ERROR "index bounds check elided"
 
148
        use(a100k[ui%1000])  // ERROR "index bounds check elided"
 
149
        use(p1[ui%1000])
 
150
        use(p1k[ui%1000])  // ERROR "index bounds check elided"
 
151
        use(p100k[ui%1000])  // ERROR "index bounds check elided"
 
152
 
 
153
        use(s[i%1001])
 
154
        use(a1[i%1001])
 
155
        use(a1k[i%1001])
 
156
        use(a100k[i%1001])
 
157
        use(p1[i%1001])
 
158
        use(p1k[i%1001])
 
159
        use(p100k[i%1001])
 
160
 
 
161
        use(s[ui%1001])
 
162
        use(a1[ui%1001])
 
163
        use(a1k[ui%1001])
 
164
        use(a100k[ui%1001])  // ERROR "index bounds check elided"
 
165
        use(p1[ui%1001])
 
166
        use(p1k[ui%1001])
 
167
        use(p100k[ui%1001])  // ERROR "index bounds check elided"
 
168
 
 
169
        // Bitwise and truncates the maximum value to the mask value.
 
170
        // The result (for a positive mask) cannot be negative, so elision
 
171
        // applies to both signed and unsigned indexes.
 
172
        use(s[i&999])
 
173
        use(a1[i&999])
 
174
        use(a1k[i&999])  // ERROR "index bounds check elided"
 
175
        use(a100k[i&999])  // ERROR "index bounds check elided"
 
176
        use(p1[i&999])
 
177
        use(p1k[i&999])  // ERROR "index bounds check elided"
 
178
        use(p100k[i&999])  // ERROR "index bounds check elided"
 
179
 
 
180
        use(s[ui&999])
 
181
        use(a1[ui&999])
 
182
        use(a1k[ui&999])  // ERROR "index bounds check elided"
 
183
        use(a100k[ui&999])  // ERROR "index bounds check elided"
 
184
        use(p1[ui&999])
 
185
        use(p1k[ui&999])  // ERROR "index bounds check elided"
 
186
        use(p100k[ui&999])  // ERROR "index bounds check elided"
 
187
 
 
188
        use(s[i&1000])
 
189
        use(a1[i&1000])
 
190
        use(a1k[i&1000])
 
191
        use(a100k[i&1000])  // ERROR "index bounds check elided"
 
192
        use(p1[i&1000])
 
193
        use(p1k[i&1000])
 
194
        use(p100k[i&1000])  // ERROR "index bounds check elided"
 
195
 
 
196
        use(s[ui&1000])
 
197
        use(a1[ui&1000])
 
198
        use(a1k[ui&1000])
 
199
        use(a100k[ui&1000])  // ERROR "index bounds check elided"
 
200
        use(p1[ui&1000])
 
201
        use(p1k[ui&1000])
 
202
        use(p100k[ui&1000])  // ERROR "index bounds check elided"
 
203
 
 
204
        // Right shift cuts the effective number of bits in the index,
 
205
        // but only for unsigned (signed stays negative).
 
206
        use(s[i32>>22])
 
207
        use(a1[i32>>22])
 
208
        use(a1k[i32>>22])
 
209
        use(a100k[i32>>22])
 
210
        use(p1[i32>>22])
 
211
        use(p1k[i32>>22])
 
212
        use(p100k[i32>>22])
 
213
 
 
214
        use(s[ui32>>22])
 
215
        use(a1[ui32>>22])
 
216
        use(a1k[ui32>>22])
 
217
        use(a100k[ui32>>22])  // ERROR "index bounds check elided"
 
218
        use(p1[ui32>>22])
 
219
        use(p1k[ui32>>22])
 
220
        use(p100k[ui32>>22])  // ERROR "index bounds check elided"
 
221
 
 
222
        use(s[i32>>23])
 
223
        use(a1[i32>>23])
 
224
        use(a1k[i32>>23])
 
225
        use(a100k[i32>>23])
 
226
        use(p1[i32>>23])
 
227
        use(p1k[i32>>23])
 
228
        use(p100k[i32>>23])
 
229
 
 
230
        use(s[ui32>>23])
 
231
        use(a1[ui32>>23])
 
232
        use(a1k[ui32>>23])  // ERROR "index bounds check elided"
 
233
        use(a100k[ui32>>23])  // ERROR "index bounds check elided"
 
234
        use(p1[ui32>>23])
 
235
        use(p1k[ui32>>23])  // ERROR "index bounds check elided"
 
236
        use(p100k[ui32>>23])  // ERROR "index bounds check elided"
 
237
 
 
238
        // Division cuts the range like right shift does.
 
239
        use(s[i/1e6])
 
240
        use(a1[i/1e6])
 
241
        use(a1k[i/1e6])
 
242
        use(a100k[i/1e6])
 
243
        use(p1[i/1e6])
 
244
        use(p1k[i/1e6])
 
245
        use(p100k[i/1e6])
 
246
 
 
247
        use(s[ui/1e6])
 
248
        use(a1[ui/1e6])
 
249
        use(a1k[ui/1e6])
 
250
        use(p1[ui/1e6])
 
251
        use(p1k[ui/1e6])
 
252
 
 
253
        use(s[i/1e7])
 
254
        use(a1[i/1e7])
 
255
        use(a1k[i/1e7])
 
256
        use(a100k[i/1e7])
 
257
        use(p1[i/1e7])
 
258
        use(p1k[i/1e7])
 
259
        use(p100k[i/1e7])
 
260
 
 
261
        use(s[ui/1e7])
 
262
        use(a1[ui/1e7])
 
263
        use(p1[ui/1e7])
 
264
}
 
265
 
 
266
var sum int 
 
267
 
 
268
func use(x int) {
 
269
        sum += x
 
270
}