blob: dd893a1121c5ef4588e36f821f93fcb98951b542 [file] [log] [blame]
// 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 test
import (
"reflect"
"testing"
)
// Tests shifts of zero.
//go:noinline
func ofz64l64(n uint64) int64 {
var x int64
return x << n
}
//go:noinline
func ofz64l32(n uint32) int64 {
var x int64
return x << n
}
//go:noinline
func ofz64l16(n uint16) int64 {
var x int64
return x << n
}
//go:noinline
func ofz64l8(n uint8) int64 {
var x int64
return x << n
}
//go:noinline
func ofz64r64(n uint64) int64 {
var x int64
return x >> n
}
//go:noinline
func ofz64r32(n uint32) int64 {
var x int64
return x >> n
}
//go:noinline
func ofz64r16(n uint16) int64 {
var x int64
return x >> n
}
//go:noinline
func ofz64r8(n uint8) int64 {
var x int64
return x >> n
}
//go:noinline
func ofz64ur64(n uint64) uint64 {
var x uint64
return x >> n
}
//go:noinline
func ofz64ur32(n uint32) uint64 {
var x uint64
return x >> n
}
//go:noinline
func ofz64ur16(n uint16) uint64 {
var x uint64
return x >> n
}
//go:noinline
func ofz64ur8(n uint8) uint64 {
var x uint64
return x >> n
}
//go:noinline
func ofz32l64(n uint64) int32 {
var x int32
return x << n
}
//go:noinline
func ofz32l32(n uint32) int32 {
var x int32
return x << n
}
//go:noinline
func ofz32l16(n uint16) int32 {
var x int32
return x << n
}
//go:noinline
func ofz32l8(n uint8) int32 {
var x int32
return x << n
}
//go:noinline
func ofz32r64(n uint64) int32 {
var x int32
return x >> n
}
//go:noinline
func ofz32r32(n uint32) int32 {
var x int32
return x >> n
}
//go:noinline
func ofz32r16(n uint16) int32 {
var x int32
return x >> n
}
//go:noinline
func ofz32r8(n uint8) int32 {
var x int32
return x >> n
}
//go:noinline
func ofz32ur64(n uint64) uint32 {
var x uint32
return x >> n
}
//go:noinline
func ofz32ur32(n uint32) uint32 {
var x uint32
return x >> n
}
//go:noinline
func ofz32ur16(n uint16) uint32 {
var x uint32
return x >> n
}
//go:noinline
func ofz32ur8(n uint8) uint32 {
var x uint32
return x >> n
}
//go:noinline
func ofz16l64(n uint64) int16 {
var x int16
return x << n
}
//go:noinline
func ofz16l32(n uint32) int16 {
var x int16
return x << n
}
//go:noinline
func ofz16l16(n uint16) int16 {
var x int16
return x << n
}
//go:noinline
func ofz16l8(n uint8) int16 {
var x int16
return x << n
}
//go:noinline
func ofz16r64(n uint64) int16 {
var x int16
return x >> n
}
//go:noinline
func ofz16r32(n uint32) int16 {
var x int16
return x >> n
}
//go:noinline
func ofz16r16(n uint16) int16 {
var x int16
return x >> n
}
//go:noinline
func ofz16r8(n uint8) int16 {
var x int16
return x >> n
}
//go:noinline
func ofz16ur64(n uint64) uint16 {
var x uint16
return x >> n
}
//go:noinline
func ofz16ur32(n uint32) uint16 {
var x uint16
return x >> n
}
//go:noinline
func ofz16ur16(n uint16) uint16 {
var x uint16
return x >> n
}
//go:noinline
func ofz16ur8(n uint8) uint16 {
var x uint16
return x >> n
}
//go:noinline
func ofz8l64(n uint64) int8 {
var x int8
return x << n
}
//go:noinline
func ofz8l32(n uint32) int8 {
var x int8
return x << n
}
//go:noinline
func ofz8l16(n uint16) int8 {
var x int8
return x << n
}
//go:noinline
func ofz8l8(n uint8) int8 {
var x int8
return x << n
}
//go:noinline
func ofz8r64(n uint64) int8 {
var x int8
return x >> n
}
//go:noinline
func ofz8r32(n uint32) int8 {
var x int8
return x >> n
}
//go:noinline
func ofz8r16(n uint16) int8 {
var x int8
return x >> n
}
//go:noinline
func ofz8r8(n uint8) int8 {
var x int8
return x >> n
}
//go:noinline
func ofz8ur64(n uint64) uint8 {
var x uint8
return x >> n
}
//go:noinline
func ofz8ur32(n uint32) uint8 {
var x uint8
return x >> n
}
//go:noinline
func ofz8ur16(n uint16) uint8 {
var x uint8
return x >> n
}
//go:noinline
func ofz8ur8(n uint8) uint8 {
var x uint8
return x >> n
}
func TestShiftOfZero(t *testing.T) {
if got := ofz64l64(5); got != 0 {
t.Errorf("0<<5 == %d, want 0", got)
}
if got := ofz64l32(5); got != 0 {
t.Errorf("0<<5 == %d, want 0", got)
}
if got := ofz64l16(5); got != 0 {
t.Errorf("0<<5 == %d, want 0", got)
}
if got := ofz64l8(5); got != 0 {
t.Errorf("0<<5 == %d, want 0", got)
}
if got := ofz64r64(5); got != 0 {
t.Errorf("0>>5 == %d, want 0", got)
}
if got := ofz64r32(5); got != 0 {
t.Errorf("0>>5 == %d, want 0", got)
}
if got := ofz64r16(5); got != 0 {
t.Errorf("0>>5 == %d, want 0", got)
}
if got := ofz64r8(5); got != 0 {
t.Errorf("0>>5 == %d, want 0", got)
}
if got := ofz64ur64(5); got != 0 {
t.Errorf("0>>>5 == %d, want 0", got)
}
if got := ofz64ur32(5); got != 0 {
t.Errorf("0>>>5 == %d, want 0", got)
}
if got := ofz64ur16(5); got != 0 {
t.Errorf("0>>>5 == %d, want 0", got)
}
if got := ofz64ur8(5); got != 0 {
t.Errorf("0>>>5 == %d, want 0", got)
}
if got := ofz32l64(5); got != 0 {
t.Errorf("0<<5 == %d, want 0", got)
}
if got := ofz32l32(5); got != 0 {
t.Errorf("0<<5 == %d, want 0", got)
}
if got := ofz32l16(5); got != 0 {
t.Errorf("0<<5 == %d, want 0", got)
}
if got := ofz32l8(5); got != 0 {
t.Errorf("0<<5 == %d, want 0", got)
}
if got := ofz32r64(5); got != 0 {
t.Errorf("0>>5 == %d, want 0", got)
}
if got := ofz32r32(5); got != 0 {
t.Errorf("0>>5 == %d, want 0", got)
}
if got := ofz32r16(5); got != 0 {
t.Errorf("0>>5 == %d, want 0", got)
}
if got := ofz32r8(5); got != 0 {
t.Errorf("0>>5 == %d, want 0", got)
}
if got := ofz32ur64(5); got != 0 {
t.Errorf("0>>>5 == %d, want 0", got)
}
if got := ofz32ur32(5); got != 0 {
t.Errorf("0>>>5 == %d, want 0", got)
}
if got := ofz32ur16(5); got != 0 {
t.Errorf("0>>>5 == %d, want 0", got)
}
if got := ofz32ur8(5); got != 0 {
t.Errorf("0>>>5 == %d, want 0", got)
}
if got := ofz16l64(5); got != 0 {
t.Errorf("0<<5 == %d, want 0", got)
}
if got := ofz16l32(5); got != 0 {
t.Errorf("0<<5 == %d, want 0", got)
}
if got := ofz16l16(5); got != 0 {
t.Errorf("0<<5 == %d, want 0", got)
}
if got := ofz16l8(5); got != 0 {
t.Errorf("0<<5 == %d, want 0", got)
}
if got := ofz16r64(5); got != 0 {
t.Errorf("0>>5 == %d, want 0", got)
}
if got := ofz16r32(5); got != 0 {
t.Errorf("0>>5 == %d, want 0", got)
}
if got := ofz16r16(5); got != 0 {
t.Errorf("0>>5 == %d, want 0", got)
}
if got := ofz16r8(5); got != 0 {
t.Errorf("0>>5 == %d, want 0", got)
}
if got := ofz16ur64(5); got != 0 {
t.Errorf("0>>>5 == %d, want 0", got)
}
if got := ofz16ur32(5); got != 0 {
t.Errorf("0>>>5 == %d, want 0", got)
}
if got := ofz16ur16(5); got != 0 {
t.Errorf("0>>>5 == %d, want 0", got)
}
if got := ofz16ur8(5); got != 0 {
t.Errorf("0>>>5 == %d, want 0", got)
}
if got := ofz8l64(5); got != 0 {
t.Errorf("0<<5 == %d, want 0", got)
}
if got := ofz8l32(5); got != 0 {
t.Errorf("0<<5 == %d, want 0", got)
}
if got := ofz8l16(5); got != 0 {
t.Errorf("0<<5 == %d, want 0", got)
}
if got := ofz8l8(5); got != 0 {
t.Errorf("0<<5 == %d, want 0", got)
}
if got := ofz8r64(5); got != 0 {
t.Errorf("0>>5 == %d, want 0", got)
}
if got := ofz8r32(5); got != 0 {
t.Errorf("0>>5 == %d, want 0", got)
}
if got := ofz8r16(5); got != 0 {
t.Errorf("0>>5 == %d, want 0", got)
}
if got := ofz8r8(5); got != 0 {
t.Errorf("0>>5 == %d, want 0", got)
}
if got := ofz8ur64(5); got != 0 {
t.Errorf("0>>>5 == %d, want 0", got)
}
if got := ofz8ur32(5); got != 0 {
t.Errorf("0>>>5 == %d, want 0", got)
}
if got := ofz8ur16(5); got != 0 {
t.Errorf("0>>>5 == %d, want 0", got)
}
if got := ofz8ur8(5); got != 0 {
t.Errorf("0>>>5 == %d, want 0", got)
}
}
//go:noinline
func byz64l(n int64) int64 {
return n << 0
}
//go:noinline
func byz64r(n int64) int64 {
return n >> 0
}
//go:noinline
func byz64ur(n uint64) uint64 {
return n >> 0
}
//go:noinline
func byz32l(n int32) int32 {
return n << 0
}
//go:noinline
func byz32r(n int32) int32 {
return n >> 0
}
//go:noinline
func byz32ur(n uint32) uint32 {
return n >> 0
}
//go:noinline
func byz16l(n int16) int16 {
return n << 0
}
//go:noinline
func byz16r(n int16) int16 {
return n >> 0
}
//go:noinline
func byz16ur(n uint16) uint16 {
return n >> 0
}
//go:noinline
func byz8l(n int8) int8 {
return n << 0
}
//go:noinline
func byz8r(n int8) int8 {
return n >> 0
}
//go:noinline
func byz8ur(n uint8) uint8 {
return n >> 0
}
func TestShiftByZero(t *testing.T) {
{
var n int64 = 0x5555555555555555
if got := byz64l(n); got != n {
t.Errorf("%x<<0 == %x, want %x", n, got, n)
}
if got := byz64r(n); got != n {
t.Errorf("%x>>0 == %x, want %x", n, got, n)
}
}
{
var n uint64 = 0xaaaaaaaaaaaaaaaa
if got := byz64ur(n); got != n {
t.Errorf("%x>>>0 == %x, want %x", n, got, n)
}
}
{
var n int32 = 0x55555555
if got := byz32l(n); got != n {
t.Errorf("%x<<0 == %x, want %x", n, got, n)
}
if got := byz32r(n); got != n {
t.Errorf("%x>>0 == %x, want %x", n, got, n)
}
}
{
var n uint32 = 0xaaaaaaaa
if got := byz32ur(n); got != n {
t.Errorf("%x>>>0 == %x, want %x", n, got, n)
}
}
{
var n int16 = 0x5555
if got := byz16l(n); got != n {
t.Errorf("%x<<0 == %x, want %x", n, got, n)
}
if got := byz16r(n); got != n {
t.Errorf("%x>>0 == %x, want %x", n, got, n)
}
}
{
var n uint16 = 0xaaaa
if got := byz16ur(n); got != n {
t.Errorf("%x>>>0 == %x, want %x", n, got, n)
}
}
{
var n int8 = 0x55
if got := byz8l(n); got != n {
t.Errorf("%x<<0 == %x, want %x", n, got, n)
}
if got := byz8r(n); got != n {
t.Errorf("%x>>0 == %x, want %x", n, got, n)
}
}
{
var n uint8 = 0x55
if got := byz8ur(n); got != n {
t.Errorf("%x>>>0 == %x, want %x", n, got, n)
}
}
}
//go:noinline
func two64l(x int64) int64 {
return x << 1 << 1
}
//go:noinline
func two64r(x int64) int64 {
return x >> 1 >> 1
}
//go:noinline
func two64ur(x uint64) uint64 {
return x >> 1 >> 1
}
//go:noinline
func two32l(x int32) int32 {
return x << 1 << 1
}
//go:noinline
func two32r(x int32) int32 {
return x >> 1 >> 1
}
//go:noinline
func two32ur(x uint32) uint32 {
return x >> 1 >> 1
}
//go:noinline
func two16l(x int16) int16 {
return x << 1 << 1
}
//go:noinline
func two16r(x int16) int16 {
return x >> 1 >> 1
}
//go:noinline
func two16ur(x uint16) uint16 {
return x >> 1 >> 1
}
//go:noinline
func two8l(x int8) int8 {
return x << 1 << 1
}
//go:noinline
func two8r(x int8) int8 {
return x >> 1 >> 1
}
//go:noinline
func two8ur(x uint8) uint8 {
return x >> 1 >> 1
}
func TestShiftCombine(t *testing.T) {
if got, want := two64l(4), int64(16); want != got {
t.Errorf("4<<1<<1 == %d, want %d", got, want)
}
if got, want := two64r(64), int64(16); want != got {
t.Errorf("64>>1>>1 == %d, want %d", got, want)
}
if got, want := two64ur(64), uint64(16); want != got {
t.Errorf("64>>1>>1 == %d, want %d", got, want)
}
if got, want := two32l(4), int32(16); want != got {
t.Errorf("4<<1<<1 == %d, want %d", got, want)
}
if got, want := two32r(64), int32(16); want != got {
t.Errorf("64>>1>>1 == %d, want %d", got, want)
}
if got, want := two32ur(64), uint32(16); want != got {
t.Errorf("64>>1>>1 == %d, want %d", got, want)
}
if got, want := two16l(4), int16(16); want != got {
t.Errorf("4<<1<<1 == %d, want %d", got, want)
}
if got, want := two16r(64), int16(16); want != got {
t.Errorf("64>>1>>1 == %d, want %d", got, want)
}
if got, want := two16ur(64), uint16(16); want != got {
t.Errorf("64>>1>>1 == %d, want %d", got, want)
}
if got, want := two8l(4), int8(16); want != got {
t.Errorf("4<<1<<1 == %d, want %d", got, want)
}
if got, want := two8r(64), int8(16); want != got {
t.Errorf("64>>1>>1 == %d, want %d", got, want)
}
if got, want := two8ur(64), uint8(16); want != got {
t.Errorf("64>>1>>1 == %d, want %d", got, want)
}
}
//go:noinline
func three64l(x int64) int64 {
return x << 3 >> 1 << 2
}
//go:noinline
func three64ul(x uint64) uint64 {
return x << 3 >> 1 << 2
}
//go:noinline
func three64r(x int64) int64 {
return x >> 3 << 1 >> 2
}
//go:noinline
func three64ur(x uint64) uint64 {
return x >> 3 << 1 >> 2
}
//go:noinline
func three32l(x int32) int32 {
return x << 3 >> 1 << 2
}
//go:noinline
func three32ul(x uint32) uint32 {
return x << 3 >> 1 << 2
}
//go:noinline
func three32r(x int32) int32 {
return x >> 3 << 1 >> 2
}
//go:noinline
func three32ur(x uint32) uint32 {
return x >> 3 << 1 >> 2
}
//go:noinline
func three16l(x int16) int16 {
return x << 3 >> 1 << 2
}
//go:noinline
func three16ul(x uint16) uint16 {
return x << 3 >> 1 << 2
}
//go:noinline
func three16r(x int16) int16 {
return x >> 3 << 1 >> 2
}
//go:noinline
func three16ur(x uint16) uint16 {
return x >> 3 << 1 >> 2
}
//go:noinline
func three8l(x int8) int8 {
return x << 3 >> 1 << 2
}
//go:noinline
func three8ul(x uint8) uint8 {
return x << 3 >> 1 << 2
}
//go:noinline
func three8r(x int8) int8 {
return x >> 3 << 1 >> 2
}
//go:noinline
func three8ur(x uint8) uint8 {
return x >> 3 << 1 >> 2
}
func TestShiftCombine3(t *testing.T) {
if got, want := three64l(4), int64(64); want != got {
t.Errorf("4<<1<<1 == %d, want %d", got, want)
}
if got, want := three64ul(4), uint64(64); want != got {
t.Errorf("4<<1<<1 == %d, want %d", got, want)
}
if got, want := three64r(64), int64(4); want != got {
t.Errorf("64>>1>>1 == %d, want %d", got, want)
}
if got, want := three64ur(64), uint64(4); want != got {
t.Errorf("64>>1>>1 == %d, want %d", got, want)
}
if got, want := three32l(4), int32(64); want != got {
t.Errorf("4<<1<<1 == %d, want %d", got, want)
}
if got, want := three32ul(4), uint32(64); want != got {
t.Errorf("4<<1<<1 == %d, want %d", got, want)
}
if got, want := three32r(64), int32(4); want != got {
t.Errorf("64>>1>>1 == %d, want %d", got, want)
}
if got, want := three32ur(64), uint32(4); want != got {
t.Errorf("64>>1>>1 == %d, want %d", got, want)
}
if got, want := three16l(4), int16(64); want != got {
t.Errorf("4<<1<<1 == %d, want %d", got, want)
}
if got, want := three16ul(4), uint16(64); want != got {
t.Errorf("4<<1<<1 == %d, want %d", got, want)
}
if got, want := three16r(64), int16(4); want != got {
t.Errorf("64>>1>>1 == %d, want %d", got, want)
}
if got, want := three16ur(64), uint16(4); want != got {
t.Errorf("64>>1>>1 == %d, want %d", got, want)
}
if got, want := three8l(4), int8(64); want != got {
t.Errorf("4<<1<<1 == %d, want %d", got, want)
}
if got, want := three8ul(4), uint8(64); want != got {
t.Errorf("4<<1<<1 == %d, want %d", got, want)
}
if got, want := three8r(64), int8(4); want != got {
t.Errorf("64>>1>>1 == %d, want %d", got, want)
}
if got, want := three8ur(64), uint8(4); want != got {
t.Errorf("64>>1>>1 == %d, want %d", got, want)
}
}
var (
one64 int64 = 1
one64u uint64 = 1
one32 int32 = 1
one32u uint32 = 1
one16 int16 = 1
one16u uint16 = 1
one8 int8 = 1
one8u uint8 = 1
)
func TestShiftLargeCombine(t *testing.T) {
var N uint64 = 0x8000000000000000
if one64<<N<<N == 1 {
t.Errorf("shift overflow mishandled")
}
if one64>>N>>N == 1 {
t.Errorf("shift overflow mishandled")
}
if one64u>>N>>N == 1 {
t.Errorf("shift overflow mishandled")
}
if one32<<N<<N == 1 {
t.Errorf("shift overflow mishandled")
}
if one32>>N>>N == 1 {
t.Errorf("shift overflow mishandled")
}
if one32u>>N>>N == 1 {
t.Errorf("shift overflow mishandled")
}
if one16<<N<<N == 1 {
t.Errorf("shift overflow mishandled")
}
if one16>>N>>N == 1 {
t.Errorf("shift overflow mishandled")
}
if one16u>>N>>N == 1 {
t.Errorf("shift overflow mishandled")
}
if one8<<N<<N == 1 {
t.Errorf("shift overflow mishandled")
}
if one8>>N>>N == 1 {
t.Errorf("shift overflow mishandled")
}
if one8u>>N>>N == 1 {
t.Errorf("shift overflow mishandled")
}
}
func TestShiftLargeCombine3(t *testing.T) {
var N uint64 = 0x8000000000000001
if one64<<N>>2<<N == 1 {
t.Errorf("shift overflow mishandled")
}
if one64u<<N>>2<<N == 1 {
t.Errorf("shift overflow mishandled")
}
if one64>>N<<2>>N == 1 {
t.Errorf("shift overflow mishandled")
}
if one64u>>N<<2>>N == 1 {
t.Errorf("shift overflow mishandled")
}
if one32<<N>>2<<N == 1 {
t.Errorf("shift overflow mishandled")
}
if one32u<<N>>2<<N == 1 {
t.Errorf("shift overflow mishandled")
}
if one32>>N<<2>>N == 1 {
t.Errorf("shift overflow mishandled")
}
if one32u>>N<<2>>N == 1 {
t.Errorf("shift overflow mishandled")
}
if one16<<N>>2<<N == 1 {
t.Errorf("shift overflow mishandled")
}
if one16u<<N>>2<<N == 1 {
t.Errorf("shift overflow mishandled")
}
if one16>>N<<2>>N == 1 {
t.Errorf("shift overflow mishandled")
}
if one16u>>N<<2>>N == 1 {
t.Errorf("shift overflow mishandled")
}
if one8<<N>>2<<N == 1 {
t.Errorf("shift overflow mishandled")
}
if one8u<<N>>2<<N == 1 {
t.Errorf("shift overflow mishandled")
}
if one8>>N<<2>>N == 1 {
t.Errorf("shift overflow mishandled")
}
if one8u>>N<<2>>N == 1 {
t.Errorf("shift overflow mishandled")
}
}
func TestShiftGeneric(t *testing.T) {
for _, test := range [...]struct {
valueWidth int
signed bool
shiftWidth int
left bool
f interface{}
}{
{64, true, 64, true, func(n int64, s uint64) int64 { return n << s }},
{64, true, 64, false, func(n int64, s uint64) int64 { return n >> s }},
{64, false, 64, false, func(n uint64, s uint64) uint64 { return n >> s }},
{64, true, 32, true, func(n int64, s uint32) int64 { return n << s }},
{64, true, 32, false, func(n int64, s uint32) int64 { return n >> s }},
{64, false, 32, false, func(n uint64, s uint32) uint64 { return n >> s }},
{64, true, 16, true, func(n int64, s uint16) int64 { return n << s }},
{64, true, 16, false, func(n int64, s uint16) int64 { return n >> s }},
{64, false, 16, false, func(n uint64, s uint16) uint64 { return n >> s }},
{64, true, 8, true, func(n int64, s uint8) int64 { return n << s }},
{64, true, 8, false, func(n int64, s uint8) int64 { return n >> s }},
{64, false, 8, false, func(n uint64, s uint8) uint64 { return n >> s }},
{32, true, 64, true, func(n int32, s uint64) int32 { return n << s }},
{32, true, 64, false, func(n int32, s uint64) int32 { return n >> s }},
{32, false, 64, false, func(n uint32, s uint64) uint32 { return n >> s }},
{32, true, 32, true, func(n int32, s uint32) int32 { return n << s }},
{32, true, 32, false, func(n int32, s uint32) int32 { return n >> s }},
{32, false, 32, false, func(n uint32, s uint32) uint32 { return n >> s }},
{32, true, 16, true, func(n int32, s uint16) int32 { return n << s }},
{32, true, 16, false, func(n int32, s uint16) int32 { return n >> s }},
{32, false, 16, false, func(n uint32, s uint16) uint32 { return n >> s }},
{32, true, 8, true, func(n int32, s uint8) int32 { return n << s }},
{32, true, 8, false, func(n int32, s uint8) int32 { return n >> s }},
{32, false, 8, false, func(n uint32, s uint8) uint32 { return n >> s }},
{16, true, 64, true, func(n int16, s uint64) int16 { return n << s }},
{16, true, 64, false, func(n int16, s uint64) int16 { return n >> s }},
{16, false, 64, false, func(n uint16, s uint64) uint16 { return n >> s }},
{16, true, 32, true, func(n int16, s uint32) int16 { return n << s }},
{16, true, 32, false, func(n int16, s uint32) int16 { return n >> s }},
{16, false, 32, false, func(n uint16, s uint32) uint16 { return n >> s }},
{16, true, 16, true, func(n int16, s uint16) int16 { return n << s }},
{16, true, 16, false, func(n int16, s uint16) int16 { return n >> s }},
{16, false, 16, false, func(n uint16, s uint16) uint16 { return n >> s }},
{16, true, 8, true, func(n int16, s uint8) int16 { return n << s }},
{16, true, 8, false, func(n int16, s uint8) int16 { return n >> s }},
{16, false, 8, false, func(n uint16, s uint8) uint16 { return n >> s }},
{8, true, 64, true, func(n int8, s uint64) int8 { return n << s }},
{8, true, 64, false, func(n int8, s uint64) int8 { return n >> s }},
{8, false, 64, false, func(n uint8, s uint64) uint8 { return n >> s }},
{8, true, 32, true, func(n int8, s uint32) int8 { return n << s }},
{8, true, 32, false, func(n int8, s uint32) int8 { return n >> s }},
{8, false, 32, false, func(n uint8, s uint32) uint8 { return n >> s }},
{8, true, 16, true, func(n int8, s uint16) int8 { return n << s }},
{8, true, 16, false, func(n int8, s uint16) int8 { return n >> s }},
{8, false, 16, false, func(n uint8, s uint16) uint8 { return n >> s }},
{8, true, 8, true, func(n int8, s uint8) int8 { return n << s }},
{8, true, 8, false, func(n int8, s uint8) int8 { return n >> s }},
{8, false, 8, false, func(n uint8, s uint8) uint8 { return n >> s }},
} {
fv := reflect.ValueOf(test.f)
var args [2]reflect.Value
for i := 0; i < test.valueWidth; i++ {
// Build value to be shifted.
var n int64 = 1
for j := 0; j < i; j++ {
n <<= 1
}
args[0] = reflect.ValueOf(n).Convert(fv.Type().In(0))
for s := 0; s <= test.shiftWidth; s++ {
args[1] = reflect.ValueOf(s).Convert(fv.Type().In(1))
// Compute desired result. We're testing variable shifts
// assuming constant shifts are correct.
r := n
var op string
switch {
case test.left:
op = "<<"
for j := 0; j < s; j++ {
r <<= 1
}
switch test.valueWidth {
case 32:
r = int64(int32(r))
case 16:
r = int64(int16(r))
case 8:
r = int64(int8(r))
}
case test.signed:
op = ">>"
switch test.valueWidth {
case 32:
r = int64(int32(r))
case 16:
r = int64(int16(r))
case 8:
r = int64(int8(r))
}
for j := 0; j < s; j++ {
r >>= 1
}
default:
op = ">>>"
for j := 0; j < s; j++ {
r = int64(uint64(r) >> 1)
}
}
// Call function.
res := fv.Call(args[:])[0].Convert(reflect.ValueOf(r).Type())
if res.Int() != r {
t.Errorf("%s%dx%d(%x,%x)=%x, want %x", op, test.valueWidth, test.shiftWidth, n, s, res.Int(), r)
}
}
}
}
}
var shiftSink64 int64
func BenchmarkShiftArithmeticRight(b *testing.B) {
x := shiftSink64
for i := 0; i < b.N; i++ {
x = x >> (i & 63)
}
shiftSink64 = x
}
//go:noinline
func incorrectRotate1(x, c uint64) uint64 {
// This should not compile to a rotate instruction.
return x<<c | x>>(64-c)
}
//go:noinline
func incorrectRotate2(x uint64) uint64 {
var c uint64 = 66
// This should not compile to a rotate instruction.
return x<<c | x>>(64-c)
}
func TestIncorrectRotate(t *testing.T) {
if got := incorrectRotate1(1, 66); got != 0 {
t.Errorf("got %x want 0", got)
}
if got := incorrectRotate2(1); got != 0 {
t.Errorf("got %x want 0", got)
}
}
//go:noinline
func variableShiftOverflow64x8(x int64, y, z uint8) (a, b, c int64) {
// Verify junk bits are ignored when doing a variable shift.
return x >> (y + z), x << (y + z), int64(uint64(x) >> (y + z))
}
//go:noinline
func variableShiftOverflow32x8(x int32, y, z uint8) (a, b, c int32) {
// Verify junk bits are ignored when doing a variable shift.
return x >> (y + z), x << (y + z), int32(uint32(x) >> (y + z))
}
//go:noinline
func variableShiftOverflow16x8(x int16, y, z uint8) (a, b, c int16) {
// Verify junk bits are ignored when doing a variable shift.
return x >> (y + z), x << (y + z), int16(uint16(x) >> (y + z))
}
//go:noinline
func variableShiftOverflow8x8(x int8, y, z uint8) (a, b, c int8) {
// Verify junk bits are ignored when doing a variable shift.
return x >> (y + z), x << (y + z), int8(uint8(x) >> (y + z))
}
//go:noinline
func variableShiftOverflow64x16(x int64, y, z uint16) (a, b, c int64) {
// Verify junk bits are ignored when doing a variable shift.
return x >> (y + z), x << (y + z), int64(uint64(x) >> (y + z))
}
//go:noinline
func variableShiftOverflow32x16(x int32, y, z uint16) (a, b, c int32) {
// Verify junk bits are ignored when doing a variable shift.
return x >> (y + z), x << (y + z), int32(uint32(x) >> (y + z))
}
//go:noinline
func variableShiftOverflow16x16(x int16, y, z uint16) (a, b, c int16) {
// Verify junk bits are ignored when doing a variable shift.
return x >> (y + z), x << (y + z), int16(uint16(x) >> (y + z))
}
//go:noinline
func variableShiftOverflow8x16(x int8, y, z uint16) (a, b, c int8) {
// Verify junk bits are ignored when doing a variable shift.
return x >> (y + z), x << (y + z), int8(uint8(x) >> (y + z))
}
//go:noinline
func makeU8(x uint64) uint8 {
// Ensure the upper portions of the register are clear before testing large shift values
// using non-native types (e.g uint8 on PPC64).
return uint8(x)
}
//go:noinline
func makeU16(x uint64) uint16 {
// Ensure the upper portions of the register are clear before testing large shift values
// using non-native types (e.g uint8 on PPC64).
return uint16(x)
}
func TestShiftOverflow(t *testing.T) {
if v, w, z := variableShiftOverflow64x8(-64, makeU8(255), 2); v != -32 || w != -128 || z != 0x7fffffffffffffe0 {
t.Errorf("got %d %d 0x%x, expected -32 -128 0x7fffffffffffffe0", v, w, z)
}
if v, w, z := variableShiftOverflow32x8(-64, makeU8(255), 2); v != -32 || w != -128 || z != 0x7fffffe0 {
t.Errorf("got %d %d 0x%x, expected -32 -128 0x7fffffe0", v, w, z)
}
if v, w, z := variableShiftOverflow16x8(-64, makeU8(255), 2); v != -32 || w != -128 || z != 0x7fe0 {
t.Errorf("got %d %d 0x%x, expected -32 -128 0x7fe0", v, w, z)
}
if v, w, z := variableShiftOverflow8x8(-64, makeU8(255), 2); v != -32 || w != -128 || z != 0x60 {
t.Errorf("got %d %d 0x%x, expected -32 -128 0x60", v, w, z)
}
if v, w, z := variableShiftOverflow64x16(-64, makeU16(0xffff), 2); v != -32 || w != -128 || z != 0x7fffffffffffffe0 {
t.Errorf("got %d %d 0x%x, expected -32 -128 0x7fffffffffffffe0", v, w, z)
}
if v, w, z := variableShiftOverflow32x16(-64, makeU16(0xffff), 2); v != -32 || w != -128 || z != 0x7fffffe0 {
t.Errorf("got %d %d 0x%x, expected -32 -128 0x7fffffe0,", v, w, z)
}
if v, w, z := variableShiftOverflow16x16(-64, makeU16(0xffff), 2); v != -32 || w != -128 || z != 0x7fe0 {
t.Errorf("got %d %d 0x%x, expected -32 -128 0x7fe0", v, w, z)
}
if v, w, z := variableShiftOverflow8x16(-64, makeU16(0xffff), 2); v != -32 || w != -128 || z != 0x60 {
t.Errorf("got %d %d 0x%x, expected -32 -128 0x60", v, w, z)
}
}