Home | History | Annotate | Download | only in test 
      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 }
    271