github.com/go-asm/go@v1.21.1-0.20240213172139-40c5ead50c48/cmd/compile/test/shift_test.go

// 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)
	}
}