cmd/compile/internal/inline: score call sites exposed by inlines

[gostls13.git] / test / checkbce.go

diff --git a/test/checkbce.go b/test/checkbce.go
index ef4e584ca0923a8e0aa8f7c3e8fc791e5493ded1..71acfb71ac17d46ec08acde3f0d878f40c8cec65 100644 (file)
--- a/test/checkbce.go
+++ b/test/checkbce.go
@@ -1,6 +1,7 @@
-// +build amd64,!gcflags_noopt
 // errorcheck -0 -d=ssa/check_bce/debug=3
 
+//go:build amd64 && !gcflags_noopt
+
 // 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.
@@ -10,6 +11,8 @@
 
 package main
 
+import "encoding/binary"
+
 func f0(a []int) {
        a[0] = 1 // ERROR "Found IsInBounds$"
        a[0] = 1
@@ -31,9 +34,7 @@ func f1(a [256]int, i int) {
 
        if 4 <= i && i < len(a) {
                useInt(a[i])
-               useInt(a[i-1]) // ERROR "Found IsInBounds$"
-               // TODO: 'if 4 <= i && i < len(a)' gets rewritten to 'if uint(i - 4) < 256 - 4',
-               // which the bounds checker cannot yet use to infer that the next line doesn't need a bounds check.
+               useInt(a[i-1])
                useInt(a[i-4])
        }
 }
@@ -137,23 +138,21 @@ func g4(a [100]int) {
                useInt(a[i+50])
 
                // The following are out of bounds.
+               if a[0] == 0xdeadbeef {
+                       // This is a trick to prohibit sccp to optimize out the following out of bound check
+                       continue
+               }
                useInt(a[i-11]) // ERROR "Found IsInBounds$"
                useInt(a[i+51]) // ERROR "Found IsInBounds$"
        }
 }
 
-func Uint64(b []byte) uint64 {
-       _ = b[7] // ERROR "Found IsInBounds$"
-       return uint64(b[7]) | uint64(b[6])<<8 | uint64(b[5])<<16 | uint64(b[4])<<24 |
-               uint64(b[3])<<32 | uint64(b[2])<<40 | uint64(b[1])<<48 | uint64(b[0])<<56
-}
-
 func decode1(data []byte) (x uint64) {
        for len(data) >= 32 {
-               x += Uint64(data[:8])
-               x += Uint64(data[8:16])
-               x += Uint64(data[16:24])
-               x += Uint64(data[24:32])
+               x += binary.BigEndian.Uint64(data[:8])
+               x += binary.BigEndian.Uint64(data[8:16])
+               x += binary.BigEndian.Uint64(data[16:24])
+               x += binary.BigEndian.Uint64(data[24:32])
                data = data[32:]
        }
        return x
@@ -163,13 +162,13 @@ func decode2(data []byte) (x uint64) {
        // TODO(rasky): this should behave like decode1 and compile to no
        // boundchecks. We're currently not able to remove all of them.
        for len(data) >= 32 {
-               x += Uint64(data)
+               x += binary.BigEndian.Uint64(data)
                data = data[8:]
-               x += Uint64(data) // ERROR "Found IsInBounds$"
+               x += binary.BigEndian.Uint64(data) // ERROR "Found IsInBounds$"
                data = data[8:]
-               x += Uint64(data) // ERROR "Found IsInBounds$"
+               x += binary.BigEndian.Uint64(data) // ERROR "Found IsInBounds$"
                data = data[8:]
-               x += Uint64(data) // ERROR "Found IsInBounds$"
+               x += binary.BigEndian.Uint64(data) // ERROR "Found IsInBounds$"
                data = data[8:]
        }
        return x