mirror of
https://github.com/golang/go
synced 2024-11-05 18:36:10 -07:00
c9fd997524
Unroll s == "ab" to len(s) == 2 && s[0] == 'a' && s[1] == 'b' This generates faster and shorter code by avoiding a runtime call. Do something similar for !=. The cutoff length is 6. This was chosen empirically by examining binary sizes on arm, arm64, 386, and amd64 using the SSA backend. For all architectures examined, 4, 5, and 6 were the ideal cutoff, with identical binary sizes. The distribution of constant string equality sizes during 'go build -a std' is: 40.81% 622 len 0 14.11% 215 len 4 9.45% 144 len 1 7.81% 119 len 3 7.48% 114 len 5 5.12% 78 len 7 4.13% 63 len 2 3.54% 54 len 8 2.69% 41 len 6 1.18% 18 len 10 0.85% 13 len 9 0.66% 10 len 14 0.59% 9 len 17 0.46% 7 len 11 0.26% 4 len 12 0.20% 3 len 19 0.13% 2 len 13 0.13% 2 len 15 0.13% 2 len 16 0.07% 1 len 20 0.07% 1 len 23 0.07% 1 len 33 0.07% 1 len 36 A cutoff of length 6 covers most of the cases. Benchmarks on amd64 comparing a string to a constant of length 3: Cmp/1same-8 4.78ns ± 6% 0.94ns ± 9% -80.26% (p=0.000 n=20+20) Cmp/1diffbytes-8 6.43ns ± 6% 0.96ns ±11% -85.13% (p=0.000 n=20+20) Cmp/3same-8 4.71ns ± 5% 1.28ns ± 5% -72.90% (p=0.000 n=20+20) Cmp/3difffirstbyte-8 6.33ns ± 7% 1.27ns ± 7% -79.90% (p=0.000 n=20+20) Cmp/3difflastbyte-8 6.34ns ± 8% 1.26ns ± 9% -80.13% (p=0.000 n=20+20) The change to the prove test preserves the existing intent of the test. When the string was short, there was a new "proved in bounds" report that referred to individual byte comparisons. Change-Id: I593ac303b0d11f275672090c5c786ea0c6b8da13 Reviewed-on: https://go-review.googlesource.com/26758 Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
451 lines
6.8 KiB
Go
451 lines
6.8 KiB
Go
// +build amd64
|
|
// errorcheck -0 -d=ssa/prove/debug=3
|
|
|
|
// Copyright 2016 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package main
|
|
|
|
import "math"
|
|
|
|
func f0(a []int) int {
|
|
a[0] = 1
|
|
a[0] = 1 // ERROR "Proved boolean IsInBounds$"
|
|
a[6] = 1
|
|
a[6] = 1 // ERROR "Proved boolean IsInBounds$"
|
|
a[5] = 1 // ERROR "Proved IsInBounds$"
|
|
a[5] = 1 // ERROR "Proved boolean IsInBounds$"
|
|
return 13
|
|
}
|
|
|
|
func f1(a []int) int {
|
|
if len(a) <= 5 {
|
|
return 18
|
|
}
|
|
a[0] = 1 // ERROR "Proved non-negative bounds IsInBounds$"
|
|
a[0] = 1 // ERROR "Proved boolean IsInBounds$"
|
|
a[6] = 1
|
|
a[6] = 1 // ERROR "Proved boolean IsInBounds$"
|
|
a[5] = 1 // ERROR "Proved IsInBounds$"
|
|
a[5] = 1 // ERROR "Proved boolean IsInBounds$"
|
|
return 26
|
|
}
|
|
|
|
func f1b(a []int, i int, j uint) int {
|
|
if i >= 0 && i < len(a) {
|
|
return a[i] // ERROR "Proved non-negative bounds IsInBounds$"
|
|
}
|
|
if i >= 10 && i < len(a) {
|
|
return a[i] // ERROR "Proved non-negative bounds IsInBounds$"
|
|
}
|
|
if i >= 10 && i < len(a) {
|
|
return a[i] // ERROR "Proved non-negative bounds IsInBounds$"
|
|
}
|
|
if i >= 10 && i < len(a) { // todo: handle this case
|
|
return a[i-10]
|
|
}
|
|
if j < uint(len(a)) {
|
|
return a[j] // ERROR "Proved IsInBounds$"
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func f1c(a []int, i int64) int {
|
|
c := uint64(math.MaxInt64 + 10) // overflows int
|
|
d := int64(c)
|
|
if i >= d && i < int64(len(a)) {
|
|
// d overflows, should not be handled.
|
|
return a[i]
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func f2(a []int) int {
|
|
for i := range a {
|
|
a[i+1] = i
|
|
a[i+1] = i // ERROR "Proved boolean IsInBounds$"
|
|
}
|
|
return 34
|
|
}
|
|
|
|
func f3(a []uint) int {
|
|
for i := uint(0); i < uint(len(a)); i++ {
|
|
a[i] = i // ERROR "Proved IsInBounds$"
|
|
}
|
|
return 41
|
|
}
|
|
|
|
func f4a(a, b, c int) int {
|
|
if a < b {
|
|
if a == b { // ERROR "Disproved Eq64$"
|
|
return 47
|
|
}
|
|
if a > b { // ERROR "Disproved Greater64$"
|
|
return 50
|
|
}
|
|
if a < b { // ERROR "Proved boolean Less64$"
|
|
return 53
|
|
}
|
|
if a == b { // ERROR "Disproved boolean Eq64$"
|
|
return 56
|
|
}
|
|
if a > b { // ERROR "Disproved boolean Greater64$"
|
|
return 59
|
|
}
|
|
return 61
|
|
}
|
|
return 63
|
|
}
|
|
|
|
func f4b(a, b, c int) int {
|
|
if a <= b {
|
|
if a >= b {
|
|
if a == b { // ERROR "Proved Eq64$"
|
|
return 70
|
|
}
|
|
return 75
|
|
}
|
|
return 77
|
|
}
|
|
return 79
|
|
}
|
|
|
|
func f4c(a, b, c int) int {
|
|
if a <= b {
|
|
if a >= b {
|
|
if a != b { // ERROR "Disproved Neq64$"
|
|
return 73
|
|
}
|
|
return 75
|
|
}
|
|
return 77
|
|
}
|
|
return 79
|
|
}
|
|
|
|
func f4d(a, b, c int) int {
|
|
if a < b {
|
|
if a < c {
|
|
if a < b { // ERROR "Proved boolean Less64$"
|
|
if a < c { // ERROR "Proved boolean Less64$"
|
|
return 87
|
|
}
|
|
return 89
|
|
}
|
|
return 91
|
|
}
|
|
return 93
|
|
}
|
|
return 95
|
|
}
|
|
|
|
func f4e(a, b, c int) int {
|
|
if a < b {
|
|
if b > a { // ERROR "Proved Greater64$"
|
|
return 101
|
|
}
|
|
return 103
|
|
}
|
|
return 105
|
|
}
|
|
|
|
func f4f(a, b, c int) int {
|
|
if a <= b {
|
|
if b > a {
|
|
if b == a { // ERROR "Disproved Eq64$"
|
|
return 112
|
|
}
|
|
return 114
|
|
}
|
|
if b >= a { // ERROR "Proved Geq64$"
|
|
if b == a { // ERROR "Proved Eq64$"
|
|
return 118
|
|
}
|
|
return 120
|
|
}
|
|
return 122
|
|
}
|
|
return 124
|
|
}
|
|
|
|
func f5(a, b uint) int {
|
|
if a == b {
|
|
if a <= b { // ERROR "Proved Leq64U$"
|
|
return 130
|
|
}
|
|
return 132
|
|
}
|
|
return 134
|
|
}
|
|
|
|
// These comparisons are compile time constants.
|
|
func f6a(a uint8) int {
|
|
if a < a { // ERROR "Disproved Less8U$"
|
|
return 140
|
|
}
|
|
return 151
|
|
}
|
|
|
|
func f6b(a uint8) int {
|
|
if a < a { // ERROR "Disproved Less8U$"
|
|
return 140
|
|
}
|
|
return 151
|
|
}
|
|
|
|
func f6x(a uint8) int {
|
|
if a > a { // ERROR "Disproved Greater8U$"
|
|
return 143
|
|
}
|
|
return 151
|
|
}
|
|
|
|
func f6d(a uint8) int {
|
|
if a <= a { // ERROR "Proved Leq8U$"
|
|
return 146
|
|
}
|
|
return 151
|
|
}
|
|
|
|
func f6e(a uint8) int {
|
|
if a >= a { // ERROR "Proved Geq8U$"
|
|
return 149
|
|
}
|
|
return 151
|
|
}
|
|
|
|
func f7(a []int, b int) int {
|
|
if b < len(a) {
|
|
a[b] = 3
|
|
if b < len(a) { // ERROR "Proved boolean Less64$"
|
|
a[b] = 5 // ERROR "Proved boolean IsInBounds$"
|
|
}
|
|
}
|
|
return 161
|
|
}
|
|
|
|
func f8(a, b uint) int {
|
|
if a == b {
|
|
return 166
|
|
}
|
|
if a > b {
|
|
return 169
|
|
}
|
|
if a < b { // ERROR "Proved Less64U$"
|
|
return 172
|
|
}
|
|
return 174
|
|
}
|
|
|
|
func f9(a, b bool) int {
|
|
if a {
|
|
return 1
|
|
}
|
|
if a || b { // ERROR "Disproved boolean Arg$"
|
|
return 2
|
|
}
|
|
return 3
|
|
}
|
|
|
|
func f10(a string) int {
|
|
n := len(a)
|
|
if a[:n>>1] == "aaaaaaaaaaaaaa" {
|
|
return 0
|
|
}
|
|
return 1
|
|
}
|
|
|
|
func f11a(a []int, i int) {
|
|
useInt(a[i])
|
|
useInt(a[i]) // ERROR "Proved boolean IsInBounds$"
|
|
}
|
|
|
|
func f11b(a []int, i int) {
|
|
useSlice(a[i:])
|
|
useSlice(a[i:]) // ERROR "Proved boolean IsSliceInBounds$"
|
|
}
|
|
|
|
func f11c(a []int, i int) {
|
|
useSlice(a[:i])
|
|
useSlice(a[:i]) // ERROR "Proved boolean IsSliceInBounds$"
|
|
}
|
|
|
|
func f11d(a []int, i int) {
|
|
useInt(a[2*i+7])
|
|
useInt(a[2*i+7])
|
|
}
|
|
|
|
func f12(a []int, b int) {
|
|
useSlice(a[:b])
|
|
}
|
|
|
|
func f13a(a, b, c int, x bool) int {
|
|
if a > 12 {
|
|
if x {
|
|
if a < 12 { // ERROR "Disproved Less64$"
|
|
return 1
|
|
}
|
|
}
|
|
if x {
|
|
if a <= 12 { // ERROR "Disproved Leq64$"
|
|
return 2
|
|
}
|
|
}
|
|
if x {
|
|
if a == 12 { // ERROR "Disproved Eq64$"
|
|
return 3
|
|
}
|
|
}
|
|
if x {
|
|
if a >= 12 { // ERROR "Proved Geq64$"
|
|
return 4
|
|
}
|
|
}
|
|
if x {
|
|
if a > 12 { // ERROR "Proved boolean Greater64$"
|
|
return 5
|
|
}
|
|
}
|
|
return 6
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func f13b(a int, x bool) int {
|
|
if a == -9 {
|
|
if x {
|
|
if a < -9 { // ERROR "Disproved Less64$"
|
|
return 7
|
|
}
|
|
}
|
|
if x {
|
|
if a <= -9 { // ERROR "Proved Leq64$"
|
|
return 8
|
|
}
|
|
}
|
|
if x {
|
|
if a == -9 { // ERROR "Proved boolean Eq64$"
|
|
return 9
|
|
}
|
|
}
|
|
if x {
|
|
if a >= -9 { // ERROR "Proved Geq64$"
|
|
return 10
|
|
}
|
|
}
|
|
if x {
|
|
if a > -9 { // ERROR "Disproved Greater64$"
|
|
return 11
|
|
}
|
|
}
|
|
return 12
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func f13c(a int, x bool) int {
|
|
if a < 90 {
|
|
if x {
|
|
if a < 90 { // ERROR "Proved boolean Less64$"
|
|
return 13
|
|
}
|
|
}
|
|
if x {
|
|
if a <= 90 { // ERROR "Proved Leq64$"
|
|
return 14
|
|
}
|
|
}
|
|
if x {
|
|
if a == 90 { // ERROR "Disproved Eq64$"
|
|
return 15
|
|
}
|
|
}
|
|
if x {
|
|
if a >= 90 { // ERROR "Disproved Geq64$"
|
|
return 16
|
|
}
|
|
}
|
|
if x {
|
|
if a > 90 { // ERROR "Disproved Greater64$"
|
|
return 17
|
|
}
|
|
}
|
|
return 18
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func f13d(a int) int {
|
|
if a < 5 {
|
|
if a < 9 { // ERROR "Proved Less64$"
|
|
return 1
|
|
}
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func f13e(a int) int {
|
|
if a > 9 {
|
|
if a > 5 { // ERROR "Proved Greater64$"
|
|
return 1
|
|
}
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func f13f(a int64) int64 {
|
|
if a > math.MaxInt64 {
|
|
// Unreachable, but prove doesn't know that.
|
|
if a == 0 {
|
|
return 1
|
|
}
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func f13g(a int) int {
|
|
if a < 3 {
|
|
return 5
|
|
}
|
|
if a > 3 {
|
|
return 6
|
|
}
|
|
if a == 3 { // ERROR "Proved Eq64$"
|
|
return 7
|
|
}
|
|
return 8
|
|
}
|
|
|
|
func f13h(a int) int {
|
|
if a < 3 {
|
|
if a > 1 {
|
|
if a == 2 { // ERROR "Proved Eq64$"
|
|
return 5
|
|
}
|
|
}
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func f13i(a uint) int {
|
|
if a == 0 {
|
|
return 1
|
|
}
|
|
if a > 0 { // ERROR "Proved Greater64U$"
|
|
return 2
|
|
}
|
|
return 3
|
|
}
|
|
|
|
//go:noinline
|
|
func useInt(a int) {
|
|
}
|
|
|
|
//go:noinline
|
|
func useSlice(a []int) {
|
|
}
|
|
|
|
func main() {
|
|
}
|