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 // A right-leaning tree of byte multiplications.
 120 func righttree(a, b, c, d uint8) uint8 {
 121         return a * (b * (c * (d *
 122                 (a * (b * (c * (d *
 123                         (a * (b * (c * (d *
 124                                 (a * (b * (c * (d *
 125                                         (a * (b * (c * (d *
 126                                                 a * (b * (c * d)))))))))))))))))))))
 127
 128 }
 129
 130 // A left-leaning tree of byte multiplications.
 131 func lefttree(a, b, c, d uint8) uint8 {
 132         return ((((((((((((((((((a * b) * c) * d *
 133                 a) * b) * c) * d *
 134                 a) * b) * c) * d *
 135                 a) * b) * c) * d *
 136                 a) * b) * c) * d *
 137                 a) * b) * c) * d)
 138 }
 139
 140 type T struct {
 141         Next I
 142 }
 143
 144 type I interface{}
 145
 146 // A chains of type assertions.
 147 func ChainT(t *T) *T {
 148         return t.
 149                 Next.(*T).
 150                 Next.(*T).
 151                 Next.(*T).
 152                 Next.(*T).
 153                 Next.(*T).
 154                 Next.(*T).
 155                 Next.(*T).
 156                 Next.(*T).
 157                 Next.(*T).
 158                 Next.(*T).
 159                 Next.(*T).
 160                 Next.(*T).
 161                 Next.(*T).
 162                 Next.(*T).
 163                 Next.(*T).
 164                 Next.(*T).
 165                 Next.(*T).
 166                 Next.(*T).
 167                 Next.(*T).
 168                 Next.(*T)
 169 }
 170
 171 type U struct {
 172         Children []J
 173 }
 174
 175 func (u *U) Child(n int) J { return u.Children[n] }
 176
 177 type J interface {
 178         Child(n int) J
 179 }
 180
 181 func ChainUAssert(u *U) *U {
 182         return u.Child(0).(*U).
 183                 Child(0).(*U).
 184                 Child(0).(*U).
 185                 Child(0).(*U).
 186                 Child(0).(*U).
 187                 Child(0).(*U).
 188                 Child(0).(*U).
 189                 Child(0).(*U).
 190                 Child(0).(*U).
 191                 Child(0).(*U).
 192                 Child(0).(*U).
 193                 Child(0).(*U).
 194                 Child(0).(*U).
 195                 Child(0).(*U).
 196                 Child(0).(*U).
 197                 Child(0).(*U).
 198                 Child(0).(*U).
 199                 Child(0).(*U).
 200                 Child(0).(*U).
 201                 Child(0).(*U).
 202                 Child(0).(*U).
 203                 Child(0).(*U)
 204 }
 205
 206 func ChainUNoAssert(u *U) *U {
 207         return u.Child(0).
 208                 Child(0).
 209                 Child(0).
 210                 Child(0).
 211                 Child(0).
 212                 Child(0).
 213                 Child(0).
 214                 Child(0).
 215                 Child(0).
 216                 Child(0).
 217                 Child(0).
 218                 Child(0).
 219                 Child(0).
 220                 Child(0).
 221                 Child(0).
 222                 Child(0).
 223                 Child(0).
 224                 Child(0).
 225                 Child(0).
 226                 Child(0).
 227                 Child(0).
 228                 Child(0).(*U)
 229 }
 230
 231 // Type assertions and slice indexing. See issue 4207.
 232 func ChainAssertIndex(u *U) J {
 233         return u.
 234                 Children[0].(*U).
 235                 Children[0].(*U).
 236                 Children[0].(*U).
 237                 Children[0].(*U).
 238                 Children[0].(*U).
 239                 Children[0].(*U).
 240                 Children[0].(*U).
 241                 Children[0].(*U).
 242                 Children[0].(*U).
 243                 Children[0].(*U).
 244                 Children[0].(*U).
 245                 Children[0].(*U).
 246                 Children[0].(*U).
 247                 Children[0]
 248 }
 249
 250 type UArr struct {
 251         Children [2]J
 252 }
 253
 254 func (u *UArr) Child(n int) J { return u.Children[n] }
 255
 256 func ChainAssertArrayIndex(u *UArr) J {
 257         return u.
 258                 Children[0].(*UArr).
 259                 Children[0].(*UArr).
 260                 Children[0].(*UArr).
 261                 Children[0].(*UArr).
 262                 Children[0].(*UArr).
 263                 Children[0].(*UArr).
 264                 Children[0].(*UArr).
 265                 // Children[0].(*UArr).
 266                 // Children[0].(*UArr).
 267                 // Children[0].(*UArr).
 268                 // Children[0].(*UArr).
 269                 // Children[0].(*UArr).
 270                 // Children[0].(*UArr).
 271                 Children[0]
 272 }
 273
 274 type UArrPtr struct {
 275         Children *[2]J
 276 }
 277
 278 func (u *UArrPtr) Child(n int) J { return u.Children[n] }
 279
 280 func ChainAssertArrayptrIndex(u *UArrPtr) J {
 281         // TODO: don't crash on longer chains.
 282         return u.
 283                 Children[0].(*UArrPtr).
 284                 Children[0].(*UArrPtr).
 285                 Children[0].(*UArrPtr).
 286                 Children[0].(*UArrPtr).
 287                 // Children[0].(*UArrPtr).
 288                 // Children[0].(*UArrPtr).
 289                 // Children[0].(*UArrPtr).
 290                 // Children[0].(*UArrPtr).
 291                 // Children[0].(*UArrPtr).
 292                 // Children[0].(*UArrPtr).
 293                 // Children[0].(*UArrPtr).
 294                 // Children[0].(*UArrPtr).
 295                 // Children[0].(*UArrPtr).
 296                 Children[0]
 297 }
 298
 299 // Chains of divisions. See issue 4201.
 300
 301 func ChainDiv(a, b int) int {
 302         return a / b / a / b / a / b / a / b /
 303                 a / b / a / b / a / b / a / b /
 304                 a / b / a / b / a / b / a / b
 305 }
 306
 307 func ChainDivRight(a, b int) int {
 308         return a / (b / (a / (b /
 309                 (a / (b / (a / (b /
 310                         (a / (b / (a / (b /
 311                                 (a / (b / (a / (b /
 312                                         (a / (b / (a / b))))))))))))))))))
 313 }
 314
 315 func ChainDivConst(a int) int {
 316         return a / 17 / 17 / 17 /
 317                 17 / 17 / 17 / 17 /
 318                 17 / 17 / 17 / 17
 319 }