test/torture.go

   1 // compile
   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 // Various tests for expressions with high complexity.
   8
   9 package main
  10
  11 // Concatenate 16 4-bit integers into a 64-bit number.
  12 func concat(s *[16]byte) uint64 {
  13         r := (((((((((((((((uint64(s[0])<<4|
  14                 uint64(s[1]))<<4|
  15                 uint64(s[2]))<<4|
  16                 uint64(s[3]))<<4|
  17                 uint64(s[4]))<<4|
  18                 uint64(s[5]))<<4|
  19                 uint64(s[6]))<<4|
  20                 uint64(s[7]))<<4|
  21                 uint64(s[8]))<<4|
  22                 uint64(s[9]))<<4|
  23                 uint64(s[10]))<<4|
  24                 uint64(s[11]))<<4|
  25                 uint64(s[12]))<<4|
  26                 uint64(s[13]))<<4|
  27                 uint64(s[14]))<<4 |
  28                 uint64(s[15]))
  29         return r
  30 }
  31
  32 // Compute the determinant of a 4x4-matrix by the sum
  33 // over all index permutations.
  34 func determinant(m [4][4]float64) float64 {
  35         return m[0][0]*m[1][1]*m[2][2]*m[3][3] -
  36                 m[0][0]*m[1][1]*m[2][3]*m[3][2] -
  37                 m[0][0]*m[1][2]*m[2][1]*m[3][3] +
  38                 m[0][0]*m[1][2]*m[2][3]*m[3][1] +
  39                 m[0][0]*m[1][3]*m[2][1]*m[3][2] -
  40                 m[0][0]*m[1][3]*m[2][2]*m[3][1] -
  41                 m[0][1]*m[1][0]*m[2][2]*m[3][3] +
  42                 m[0][1]*m[1][0]*m[2][3]*m[3][2] +
  43                 m[0][1]*m[1][2]*m[2][0]*m[3][3] -
  44                 m[0][1]*m[1][2]*m[2][3]*m[3][0] -
  45                 m[0][1]*m[1][3]*m[2][0]*m[3][2] +
  46                 m[0][1]*m[1][3]*m[2][2]*m[3][0] +
  47                 m[0][2]*m[1][0]*m[2][1]*m[3][3] -
  48                 m[0][2]*m[1][0]*m[2][3]*m[3][1] -
  49                 m[0][2]*m[1][1]*m[2][0]*m[3][3] +
  50                 m[0][2]*m[1][1]*m[2][3]*m[3][0] +
  51                 m[0][2]*m[1][3]*m[2][0]*m[3][1] -
  52                 m[0][2]*m[1][3]*m[2][1]*m[3][0] -
  53                 m[0][3]*m[1][0]*m[2][1]*m[3][2] +
  54                 m[0][3]*m[1][0]*m[2][2]*m[3][1] +
  55                 m[0][3]*m[1][1]*m[2][0]*m[3][2] -
  56                 m[0][3]*m[1][1]*m[2][2]*m[3][0] -
  57                 m[0][3]*m[1][2]*m[2][0]*m[3][1] +
  58                 m[0][3]*m[1][2]*m[2][1]*m[3][0]
  59 }
  60
  61 // Compute the determinant of a 4x4-matrix by the sum
  62 // over all index permutations.
  63 func determinantInt(m [4][4]int) int {
  64         return m[0][0]*m[1][1]*m[2][2]*m[3][3] -
  65                 m[0][0]*m[1][1]*m[2][3]*m[3][2] -
  66                 m[0][0]*m[1][2]*m[2][1]*m[3][3] +
  67                 m[0][0]*m[1][2]*m[2][3]*m[3][1] +
  68                 m[0][0]*m[1][3]*m[2][1]*m[3][2] -
  69                 m[0][0]*m[1][3]*m[2][2]*m[3][1] -
  70                 m[0][1]*m[1][0]*m[2][2]*m[3][3] +
  71                 m[0][1]*m[1][0]*m[2][3]*m[3][2] +
  72                 m[0][1]*m[1][2]*m[2][0]*m[3][3] -
  73                 m[0][1]*m[1][2]*m[2][3]*m[3][0] -
  74                 m[0][1]*m[1][3]*m[2][0]*m[3][2] +
  75                 m[0][1]*m[1][3]*m[2][2]*m[3][0] +
  76                 m[0][2]*m[1][0]*m[2][1]*m[3][3] -
  77                 m[0][2]*m[1][0]*m[2][3]*m[3][1] -
  78                 m[0][2]*m[1][1]*m[2][0]*m[3][3] +
  79                 m[0][2]*m[1][1]*m[2][3]*m[3][0] +
  80                 m[0][2]*m[1][3]*m[2][0]*m[3][1] -
  81                 m[0][2]*m[1][3]*m[2][1]*m[3][0] -
  82                 m[0][3]*m[1][0]*m[2][1]*m[3][2] +
  83                 m[0][3]*m[1][0]*m[2][2]*m[3][1] +
  84                 m[0][3]*m[1][1]*m[2][0]*m[3][2] -
  85                 m[0][3]*m[1][1]*m[2][2]*m[3][0] -
  86                 m[0][3]*m[1][2]*m[2][0]*m[3][1] +
  87                 m[0][3]*m[1][2]*m[2][1]*m[3][0]
  88 }
  89
  90 // Compute the determinant of a 4x4-matrix by the sum
  91 // over all index permutations.
  92 func determinantByte(m [4][4]byte) byte {
  93         return m[0][0]*m[1][1]*m[2][2]*m[3][3] -
  94                 m[0][0]*m[1][1]*m[2][3]*m[3][2] -
  95                 m[0][0]*m[1][2]*m[2][1]*m[3][3] +
  96                 m[0][0]*m[1][2]*m[2][3]*m[3][1] +
  97                 m[0][0]*m[1][3]*m[2][1]*m[3][2] -
  98                 m[0][0]*m[1][3]*m[2][2]*m[3][1] -
  99                 m[0][1]*m[1][0]*m[2][2]*m[3][3] +
 100                 m[0][1]*m[1][0]*m[2][3]*m[3][2] +
 101                 m[0][1]*m[1][2]*m[2][0]*m[3][3] -
 102                 m[0][1]*m[1][2]*m[2][3]*m[3][0] -
 103                 m[0][1]*m[1][3]*m[2][0]*m[3][2] +
 104                 m[0][1]*m[1][3]*m[2][2]*m[3][0] +
 105                 m[0][2]*m[1][0]*m[2][1]*m[3][3] -
 106                 m[0][2]*m[1][0]*m[2][3]*m[3][1] -
 107                 m[0][2]*m[1][1]*m[2][0]*m[3][3] +
 108                 m[0][2]*m[1][1]*m[2][3]*m[3][0] +
 109                 m[0][2]*m[1][3]*m[2][0]*m[3][1] -
 110                 m[0][2]*m[1][3]*m[2][1]*m[3][0] -
 111                 m[0][3]*m[1][0]*m[2][1]*m[3][2] +
 112                 m[0][3]*m[1][0]*m[2][2]*m[3][1] +
 113                 m[0][3]*m[1][1]*m[2][0]*m[3][2] -
 114                 m[0][3]*m[1][1]*m[2][2]*m[3][0] -
 115                 m[0][3]*m[1][2]*m[2][0]*m[3][1] +
 116                 m[0][3]*m[1][2]*m[2][1]*m[3][0]
 117 }
 118
 119 type A []A
 120
 121 // A sequence of constant indexings.
 122 func IndexChain1(s A) A {
 123         return s[0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0]
 124 }
 125
 126 // A sequence of non-constant indexings.
 127 func IndexChain2(s A, i int) A {
 128         return s[i][i][i][i][i][i][i][i][i][i][i][i][i][i][i][i]
 129 }
 130
 131 // Another sequence of indexings.
 132 func IndexChain3(s []int) int {
 133         return s[s[s[s[s[s[s[s[s[s[s[s[s[s[s[s[s[s[s[s[s[0]]]]]]]]]]]]]]]]]]]]]
 134 }
 135
 136 // A right-leaning tree of byte multiplications.
 137 func righttree(a, b, c, d uint8) uint8 {
 138         return a * (b * (c * (d *
 139                 (a * (b * (c * (d *
 140                         (a * (b * (c * (d *
 141                                 (a * (b * (c * (d *
 142                                         (a * (b * (c * (d *
 143                                                 a * (b * (c * d)))))))))))))))))))))
 144
 145 }
 146
 147 // A left-leaning tree of byte multiplications.
 148 func lefttree(a, b, c, d uint8) uint8 {
 149         return ((((((((((((((((((a * b) * c) * d *
 150                 a) * b) * c) * d *
 151                 a) * b) * c) * d *
 152                 a) * b) * c) * d *
 153                 a) * b) * c) * d *
 154                 a) * b) * c) * d)
 155 }
 156
 157 type T struct {
 158         Next I
 159 }
 160
 161 type I interface{}
 162
 163 // A chains of type assertions.
 164 func ChainT(t *T) *T {
 165         return t.
 166                 Next.(*T).
 167                 Next.(*T).
 168                 Next.(*T).
 169                 Next.(*T).
 170                 Next.(*T).
 171                 Next.(*T).
 172                 Next.(*T).
 173                 Next.(*T).
 174                 Next.(*T).
 175                 Next.(*T).
 176                 Next.(*T).
 177                 Next.(*T).
 178                 Next.(*T).
 179                 Next.(*T).
 180                 Next.(*T).
 181                 Next.(*T).
 182                 Next.(*T).
 183                 Next.(*T).
 184                 Next.(*T).
 185                 Next.(*T)
 186 }
 187
 188 type U struct {
 189         Children []J
 190 }
 191
 192 func (u *U) Child(n int) J { return u.Children[n] }
 193
 194 type J interface {
 195         Child(n int) J
 196 }
 197
 198 func ChainUAssert(u *U) *U {
 199         return u.Child(0).(*U).
 200                 Child(0).(*U).
 201                 Child(0).(*U).
 202                 Child(0).(*U).
 203                 Child(0).(*U).
 204                 Child(0).(*U).
 205                 Child(0).(*U).
 206                 Child(0).(*U).
 207                 Child(0).(*U).
 208                 Child(0).(*U).
 209                 Child(0).(*U).
 210                 Child(0).(*U).
 211                 Child(0).(*U).
 212                 Child(0).(*U).
 213                 Child(0).(*U).
 214                 Child(0).(*U).
 215                 Child(0).(*U).
 216                 Child(0).(*U).
 217                 Child(0).(*U).
 218                 Child(0).(*U).
 219                 Child(0).(*U).
 220                 Child(0).(*U)
 221 }
 222
 223 func ChainUNoAssert(u *U) *U {
 224         return u.Child(0).
 225                 Child(0).
 226                 Child(0).
 227                 Child(0).
 228                 Child(0).
 229                 Child(0).
 230                 Child(0).
 231                 Child(0).
 232                 Child(0).
 233                 Child(0).
 234                 Child(0).
 235                 Child(0).
 236                 Child(0).
 237                 Child(0).
 238                 Child(0).
 239                 Child(0).
 240                 Child(0).
 241                 Child(0).
 242                 Child(0).
 243                 Child(0).
 244                 Child(0).
 245                 Child(0).(*U)
 246 }
 247
 248 // Type assertions and slice indexing. See issue 4207.
 249 func ChainAssertIndex(u *U) J {
 250         return u.
 251                 Children[0].(*U).
 252                 Children[0].(*U).
 253                 Children[0].(*U).
 254                 Children[0].(*U).
 255                 Children[0].(*U).
 256                 Children[0].(*U).
 257                 Children[0].(*U).
 258                 Children[0].(*U).
 259                 Children[0].(*U).
 260                 Children[0].(*U).
 261                 Children[0].(*U).
 262                 Children[0].(*U).
 263                 Children[0].(*U).
 264                 Children[0]
 265 }
 266
 267 type UArr struct {
 268         Children [2]J
 269 }
 270
 271 func (u *UArr) Child(n int) J { return u.Children[n] }
 272
 273 func ChainAssertArrayIndex(u *UArr) J {
 274         return u.
 275                 Children[0].(*UArr).
 276                 Children[0].(*UArr).
 277                 Children[0].(*UArr).
 278                 Children[0].(*UArr).
 279                 Children[0].(*UArr).
 280                 Children[0].(*UArr).
 281                 Children[0].(*UArr).
 282                 Children[0].(*UArr).
 283                 Children[0].(*UArr).
 284                 Children[0].(*UArr).
 285                 Children[0].(*UArr).
 286                 Children[0].(*UArr).
 287                 Children[0].(*UArr).
 288                 Children[0]
 289 }
 290
 291 type UArrPtr struct {
 292         Children *[2]J
 293 }
 294
 295 func (u *UArrPtr) Child(n int) J { return u.Children[n] }
 296
 297 func ChainAssertArrayptrIndex(u *UArrPtr) J {
 298         return u.
 299                 Children[0].(*UArrPtr).
 300                 Children[0].(*UArrPtr).
 301                 Children[0].(*UArrPtr).
 302                 Children[0].(*UArrPtr).
 303                 Children[0].(*UArrPtr).
 304                 Children[0].(*UArrPtr).
 305                 Children[0].(*UArrPtr).
 306                 Children[0].(*UArrPtr).
 307                 Children[0].(*UArrPtr).
 308                 Children[0].(*UArrPtr).
 309                 Children[0].(*UArrPtr).
 310                 Children[0].(*UArrPtr).
 311                 Children[0].(*UArrPtr).
 312                 Children[0]
 313 }
 314
 315 // Chains of divisions. See issue 4201.
 316
 317 func ChainDiv(a, b int) int {
 318         return a / b / a / b / a / b / a / b /
 319                 a / b / a / b / a / b / a / b /
 320                 a / b / a / b / a / b / a / b
 321 }
 322
 323 func ChainDivRight(a, b int) int {
 324         return a / (b / (a / (b /
 325                 (a / (b / (a / (b /
 326                         (a / (b / (a / (b /
 327                                 (a / (b / (a / (b /
 328                                         (a / (b / (a / b))))))))))))))))))
 329 }
 330
 331 func ChainDivConst(a int) int {
 332         return a / 17 / 17 / 17 /
 333                 17 / 17 / 17 / 17 /
 334                 17 / 17 / 17 / 17
 335 }
 336
 337 func ChainMulBytes(a, b, c byte) byte {
 338         return a*(a*(a*(a*(a*(a*(a*(a*(a*b+c)+c)+c)+c)+c)+c)+c)+c) + c
 339 }
 340
 341 func ChainCap() {
 342         select {
 343         case <-make(chan int, cap(make(chan int, cap(make(chan int, cap(make(chan int, cap(make(chan int))))))))):
 344         default:
 345         }
 346 }