test/fixedbugs/issue9604b.go

   1 // runoutput
   2
   3 // Copyright 2015 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 // terribly slow on wasm
   8 //go:build !wasm
   9
  10 package main
  11
  12 import (
  13         "fmt"
  14         "math/big"
  15         "unsafe"
  16 )
  17
  18 var one = big.NewInt(1)
  19
  20 type _type struct {
  21         name   string
  22         bits   uint
  23         signed bool
  24 }
  25
  26 // testvalues returns a list of all test values for this type.
  27 func (t *_type) testvalues() []*big.Int {
  28         var a []*big.Int
  29
  30         a = append(a, big.NewInt(0))
  31         a = append(a, big.NewInt(1))
  32         a = append(a, big.NewInt(2))
  33         if t.signed {
  34                 a = append(a, big.NewInt(-1))
  35                 a = append(a, big.NewInt(-2))
  36                 r := big.NewInt(1)
  37                 a = append(a, r.Lsh(r, t.bits-1).Sub(r, big.NewInt(1)))
  38                 r = big.NewInt(1)
  39                 a = append(a, r.Lsh(r, t.bits-1).Sub(r, big.NewInt(2)))
  40                 r = big.NewInt(1)
  41                 a = append(a, r.Lsh(r, t.bits-1).Neg(r))
  42                 r = big.NewInt(1)
  43                 a = append(a, r.Lsh(r, t.bits-1).Neg(r).Add(r, big.NewInt(1)))
  44         } else {
  45                 r := big.NewInt(1)
  46                 a = append(a, r.Lsh(r, t.bits).Sub(r, big.NewInt(1)))
  47                 r = big.NewInt(1)
  48                 a = append(a, r.Lsh(r, t.bits).Sub(r, big.NewInt(2)))
  49         }
  50         return a
  51 }
  52
  53 // trunc truncates a value to the range of the given type.
  54 func (t *_type) trunc(x *big.Int) *big.Int {
  55         r := new(big.Int)
  56         m := new(big.Int)
  57         m.Lsh(one, t.bits)
  58         m.Sub(m, one)
  59         r.And(x, m)
  60         if t.signed && r.Bit(int(t.bits)-1) == 1 {
  61                 m.Neg(one)
  62                 m.Lsh(m, t.bits)
  63                 r.Or(r, m)
  64         }
  65         return r
  66 }
  67
  68 var types = []_type{
  69         _type{"byte", 8, false},
  70         _type{"int8", 8, true},
  71         _type{"uint8", 8, false},
  72         _type{"rune", 32, true},
  73         _type{"int16", 16, true},
  74         _type{"uint16", 16, false},
  75         _type{"int32", 32, true},
  76         _type{"uint32", 32, false},
  77         _type{"int64", 64, true},
  78         _type{"uint64", 64, false},
  79         _type{"int", 8 * uint(unsafe.Sizeof(int(0))), true},
  80         _type{"uint", 8 * uint(unsafe.Sizeof(uint(0))), false},
  81         _type{"uintptr", 8 * uint(unsafe.Sizeof((*byte)(nil))), false},
  82 }
  83
  84 type binop struct {
  85         name string
  86         eval func(x, y *big.Int) *big.Int
  87 }
  88
  89 var binops = []binop{
  90         binop{"+", func(x, y *big.Int) *big.Int { return new(big.Int).Add(x, y) }},
  91         binop{"-", func(x, y *big.Int) *big.Int { return new(big.Int).Sub(x, y) }},
  92         binop{"*", func(x, y *big.Int) *big.Int { return new(big.Int).Mul(x, y) }},
  93         binop{"/", func(x, y *big.Int) *big.Int { return new(big.Int).Quo(x, y) }},
  94         binop{"%", func(x, y *big.Int) *big.Int { return new(big.Int).Rem(x, y) }},
  95         binop{"&", func(x, y *big.Int) *big.Int { return new(big.Int).And(x, y) }},
  96         binop{"|", func(x, y *big.Int) *big.Int { return new(big.Int).Or(x, y) }},
  97         binop{"^", func(x, y *big.Int) *big.Int { return new(big.Int).Xor(x, y) }},
  98         binop{"&^", func(x, y *big.Int) *big.Int { return new(big.Int).AndNot(x, y) }},
  99 }
 100
 101 type unop struct {
 102         name string
 103         eval func(x *big.Int) *big.Int
 104 }
 105
 106 var unops = []unop{
 107         unop{"+", func(x *big.Int) *big.Int { return new(big.Int).Set(x) }},
 108         unop{"-", func(x *big.Int) *big.Int { return new(big.Int).Neg(x) }},
 109         unop{"^", func(x *big.Int) *big.Int { return new(big.Int).Not(x) }},
 110 }
 111
 112 type shiftop struct {
 113         name string
 114         eval func(x *big.Int, i uint) *big.Int
 115 }
 116
 117 var shiftops = []shiftop{
 118         shiftop{"<<", func(x *big.Int, i uint) *big.Int { return new(big.Int).Lsh(x, i) }},
 119         shiftop{">>", func(x *big.Int, i uint) *big.Int { return new(big.Int).Rsh(x, i) }},
 120 }
 121
 122 // valname returns the name of n as can be used as part of a variable name.
 123 func valname(n *big.Int) string {
 124         s := fmt.Sprintf("%d", n)
 125         if s[0] == '-' {
 126                 s = "neg" + s[1:]
 127         }
 128         return s
 129 }
 130
 131 func main() {
 132         fmt.Println("package main")
 133
 134         // We make variables to hold all the different values we'd like to use.
 135         // We use global variables to prevent any constant folding.
 136         for _, t := range types {
 137                 for _, n := range t.testvalues() {
 138                         fmt.Printf("var %s_%s %s = %d\n", t.name, valname(n), t.name, n)
 139                 }
 140         }
 141
 142         fmt.Println("func main() {")
 143
 144         for _, t := range types {
 145                 // test binary ops
 146                 for _, op := range binops {
 147                         for _, x := range t.testvalues() {
 148                                 for _, y := range t.testvalues() {
 149                                         if (op.name == "/" || op.name == "%") && y.Sign() == 0 {
 150                                                 continue
 151                                         }
 152                                         r := t.trunc(op.eval(x, y))
 153                                         eqn := fmt.Sprintf("%s_%s %s %s_%s != %d", t.name, valname(x), op.name, t.name, valname(y), r)
 154                                         fmt.Printf("\tif %s { println(\"bad: %s\") }\n", eqn, eqn)
 155                                 }
 156                         }
 157                 }
 158                 // test unary ops
 159                 for _, op := range unops {
 160                         for _, x := range t.testvalues() {
 161                                 r := t.trunc(op.eval(x))
 162                                 eqn := fmt.Sprintf("%s %s_%s != %d", op.name, t.name, valname(x), r)
 163                                 fmt.Printf("\tif %s { println(\"bad: %s\") }\n", eqn, eqn)
 164                         }
 165                 }
 166                 // test shifts
 167                 for _, op := range shiftops {
 168                         for _, x := range t.testvalues() {
 169
 170                                 for _, i := range []uint{0, 1, t.bits - 2, t.bits - 1, t.bits, t.bits + 1} {
 171                                         r := t.trunc(op.eval(x, i))
 172                                         eqn := fmt.Sprintf("%s_%s %s %d != %d", t.name, valname(x), op.name, i, r)
 173                                         fmt.Printf("\tif %s { println(\"bad: %s\") }\n", eqn, eqn)
 174                                 }
 175                         }
 176                 }
 177         }
 178
 179         fmt.Println("}")
 180 }