test/fuse.go

   1 // +build amd64,!gcflags_noopt arm64,!gcflags_noopt
   2 // errorcheck -0 -d=ssa/late_fuse/debug=1
   3
   4 // Copyright 2021 The Go Authors. All rights reserved.
   5 // Use of this source code is governed by a BSD-style
   6 // license that can be found in the LICENSE file.
   7
   8 package main
   9
  10 import "strings"
  11
  12 const Cf2 = 2.0
  13
  14 func fEqEq(a int, f float64) bool {
  15         return a == 0 && f > Cf2 || a == 0 && f < -Cf2 // ERROR "Redirect Eq64 based on Eq64$"
  16 }
  17
  18 func fEqNeq(a int32, f float64) bool {
  19         return a == 0 && f > Cf2 || a != 0 && f < -Cf2 // ERROR "Redirect Neq32 based on Eq32$"
  20 }
  21
  22 func fEqLess(a int8, f float64) bool {
  23         return a == 0 && f > Cf2 || a < 0 && f < -Cf2
  24 }
  25
  26 func fEqLeq(a float64, f float64) bool {
  27         return a == 0 && f > Cf2 || a <= 0 && f < -Cf2
  28 }
  29
  30 func fEqLessU(a uint, f float64) bool {
  31         return a == 0 && f > Cf2 || a < 0 && f < -Cf2
  32 }
  33
  34 func fEqLeqU(a uint64, f float64) bool {
  35         return a == 0 && f > Cf2 || a <= 0 && f < -Cf2 // ERROR "Redirect Leq64U based on Eq64$"
  36 }
  37
  38 func fNeqEq(a int, f float64) bool {
  39         return a != 0 && f > Cf2 || a == 0 && f < -Cf2 // ERROR "Redirect Eq64 based on Neq64$"
  40 }
  41
  42 func fNeqNeq(a int32, f float64) bool {
  43         return a != 0 && f > Cf2 || a != 0 && f < -Cf2 // ERROR "Redirect Neq32 based on Neq32$"
  44 }
  45
  46 func fNeqLess(a float32, f float64) bool {
  47         // TODO: Add support for floating point numbers in prove
  48         return a != 0 && f > Cf2 || a < 0 && f < -Cf2
  49 }
  50
  51 func fNeqLeq(a int16, f float64) bool {
  52         return a != 0 && f > Cf2 || a <= 0 && f < -Cf2 // ERROR "Redirect Leq16 based on Neq16$"
  53 }
  54
  55 func fNeqLessU(a uint, f float64) bool {
  56         return a != 0 && f > Cf2 || a < 0 && f < -Cf2
  57 }
  58
  59 func fNeqLeqU(a uint32, f float64) bool {
  60         return a != 0 && f > Cf2 || a <= 0 && f < -Cf2 // ERROR "Redirect Leq32U based on Neq32$"
  61 }
  62
  63 func fLessEq(a int, f float64) bool {
  64         return a < 0 && f > Cf2 || a == 0 && f < -Cf2
  65 }
  66
  67 func fLessNeq(a int32, f float64) bool {
  68         return a < 0 && f > Cf2 || a != 0 && f < -Cf2
  69 }
  70
  71 func fLessLess(a float32, f float64) bool {
  72         return a < 0 && f > Cf2 || a < 0 && f < -Cf2 // ERROR "Redirect Less32F based on Less32F$"
  73 }
  74
  75 func fLessLeq(a float64, f float64) bool {
  76         return a < 0 && f > Cf2 || a <= 0 && f < -Cf2
  77 }
  78
  79 func fLeqEq(a float64, f float64) bool {
  80         return a <= 0 && f > Cf2 || a == 0 && f < -Cf2
  81 }
  82
  83 func fLeqNeq(a int16, f float64) bool {
  84         return a <= 0 && f > Cf2 || a != 0 && f < -Cf2 // ERROR "Redirect Neq16 based on Leq16$"
  85 }
  86
  87 func fLeqLess(a float32, f float64) bool {
  88         return a <= 0 && f > Cf2 || a < 0 && f < -Cf2
  89 }
  90
  91 func fLeqLeq(a int8, f float64) bool {
  92         return a <= 0 && f > Cf2 || a <= 0 && f < -Cf2 // ERROR "Redirect Leq8 based on Leq8$"
  93 }
  94
  95 func fLessUEq(a uint8, f float64) bool {
  96         return a < 0 && f > Cf2 || a == 0 && f < -Cf2
  97 }
  98
  99 func fLessUNeq(a uint16, f float64) bool {
 100         return a < 0 && f > Cf2 || a != 0 && f < -Cf2
 101 }
 102
 103 func fLessULessU(a uint32, f float64) bool {
 104         return a < 0 && f > Cf2 || a < 0 && f < -Cf2
 105 }
 106
 107 func fLessULeqU(a uint64, f float64) bool {
 108         return a < 0 && f > Cf2 || a <= 0 && f < -Cf2
 109 }
 110
 111 func fLeqUEq(a uint8, f float64) bool {
 112         return a <= 0 && f > Cf2 || a == 0 && f < -Cf2 // ERROR "Redirect Eq8 based on Leq8U$"
 113 }
 114
 115 func fLeqUNeq(a uint16, f float64) bool {
 116         return a <= 0 && f > Cf2 || a != 0 && f < -Cf2 // ERROR "Redirect Neq16 based on Leq16U$"
 117 }
 118
 119 func fLeqLessU(a uint32, f float64) bool {
 120         return a <= 0 && f > Cf2 || a < 0 && f < -Cf2
 121 }
 122
 123 func fLeqLeqU(a uint64, f float64) bool {
 124         return a <= 0 && f > Cf2 || a <= 0 && f < -Cf2 // ERROR "Redirect Leq64U based on Leq64U$"
 125 }
 126
 127 // Arg tests are disabled because the op name is different on amd64 and arm64.
 128
 129 func fEqPtrEqPtr(a, b *int, f float64) bool {
 130         return a == b && f > Cf2 || a == b && f < -Cf2 // ERROR "Redirect EqPtr based on EqPtr$"
 131 }
 132
 133 func fEqPtrNeqPtr(a, b *int, f float64) bool {
 134         return a == b && f > Cf2 || a != b && f < -Cf2 // ERROR "Redirect NeqPtr based on EqPtr$"
 135 }
 136
 137 func fNeqPtrEqPtr(a, b *int, f float64) bool {
 138         return a != b && f > Cf2 || a == b && f < -Cf2 // ERROR "Redirect EqPtr based on NeqPtr$"
 139 }
 140
 141 func fNeqPtrNeqPtr(a, b *int, f float64) bool {
 142         return a != b && f > Cf2 || a != b && f < -Cf2 // ERROR "Redirect NeqPtr based on NeqPtr$"
 143 }
 144
 145 func fEqInterEqInter(a interface{}, f float64) bool {
 146         return a == nil && f > Cf2 || a == nil && f < -Cf2 // ERROR "Redirect IsNonNil based on IsNonNil$"
 147 }
 148
 149 func fEqInterNeqInter(a interface{}, f float64) bool {
 150         return a == nil && f > Cf2 || a != nil && f < -Cf2
 151 }
 152
 153 func fNeqInterEqInter(a interface{}, f float64) bool {
 154         return a != nil && f > Cf2 || a == nil && f < -Cf2
 155 }
 156
 157 func fNeqInterNeqInter(a interface{}, f float64) bool {
 158         return a != nil && f > Cf2 || a != nil && f < -Cf2 // ERROR "Redirect IsNonNil based on IsNonNil$"
 159 }
 160
 161 func fEqSliceEqSlice(a []int, f float64) bool {
 162         return a == nil && f > Cf2 || a == nil && f < -Cf2 // ERROR "Redirect IsNonNil based on IsNonNil$"
 163 }
 164
 165 func fEqSliceNeqSlice(a []int, f float64) bool {
 166         return a == nil && f > Cf2 || a != nil && f < -Cf2
 167 }
 168
 169 func fNeqSliceEqSlice(a []int, f float64) bool {
 170         return a != nil && f > Cf2 || a == nil && f < -Cf2
 171 }
 172
 173 func fNeqSliceNeqSlice(a []int, f float64) bool {
 174         return a != nil && f > Cf2 || a != nil && f < -Cf2 // ERROR "Redirect IsNonNil based on IsNonNil$"
 175 }
 176
 177 func fPhi(a, b string) string {
 178         aslash := strings.HasSuffix(a, "/") // ERROR "Redirect Phi based on Phi$"
 179         bslash := strings.HasPrefix(b, "/")
 180         switch {
 181         case aslash && bslash:
 182                 return a + b[1:]
 183         case !aslash && !bslash:
 184                 return a + "/" + b
 185         }
 186         return a + b
 187 }
 188
 189 func main() {
 190 }