Source file 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  }
   191  

View as plain text