[dev.simd] simd: reorganize/rename generated emulation files

Change-Id: I8c755d3b6a1a16ac271a22ab2bd2abb308441563
Reviewed-on: https://go-review.googlesource.com/c/go/+/694097
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Junyang Shao <shaojunyang@google.com>

src/simd/compare_gen_amd64.go

@@ -0,0 +1,641 @@
+// Code generated by 'go run genfiles.go'; DO NOT EDIT.
+
+//go:build goexperiment.simd
+
+package simd
+
+// Less returns a mask whose elements indicate whether x < y
+//
+// Emulated, CPU Feature AVX
+func (x Int8x16) Less(y Int8x16) Mask8x16 {
+	return y.Greater(x)
+}
+
+// GreaterEqual returns a mask whose elements indicate whether x >= y
+//
+// Emulated, CPU Feature AVX
+func (x Int8x16) GreaterEqual(y Int8x16) Mask8x16 {
+	ones := x.Equal(x).AsInt8x16()
+	return y.Greater(x).AsInt8x16().Xor(ones).AsMask8x16()
+}
+
+// LessEqual returns a mask whose elements indicate whether x <= y
+//
+// Emulated, CPU Feature AVX
+func (x Int8x16) LessEqual(y Int8x16) Mask8x16 {
+	ones := x.Equal(x).AsInt8x16()
+	return x.Greater(y).AsInt8x16().Xor(ones).AsMask8x16()
+}
+
+// NotEqual returns a mask whose elements indicate whether x != y
+//
+// Emulated, CPU Feature AVX
+func (x Int8x16) NotEqual(y Int8x16) Mask8x16 {
+	ones := x.Equal(x).AsInt8x16()
+	return x.Equal(y).AsInt8x16().Xor(ones).AsMask8x16()
+}
+
+// Less returns a mask whose elements indicate whether x < y
+//
+// Emulated, CPU Feature AVX
+func (x Int16x8) Less(y Int16x8) Mask16x8 {
+	return y.Greater(x)
+}
+
+// GreaterEqual returns a mask whose elements indicate whether x >= y
+//
+// Emulated, CPU Feature AVX
+func (x Int16x8) GreaterEqual(y Int16x8) Mask16x8 {
+	ones := x.Equal(x).AsInt16x8()
+	return y.Greater(x).AsInt16x8().Xor(ones).AsMask16x8()
+}
+
+// LessEqual returns a mask whose elements indicate whether x <= y
+//
+// Emulated, CPU Feature AVX
+func (x Int16x8) LessEqual(y Int16x8) Mask16x8 {
+	ones := x.Equal(x).AsInt16x8()
+	return x.Greater(y).AsInt16x8().Xor(ones).AsMask16x8()
+}
+
+// NotEqual returns a mask whose elements indicate whether x != y
+//
+// Emulated, CPU Feature AVX
+func (x Int16x8) NotEqual(y Int16x8) Mask16x8 {
+	ones := x.Equal(x).AsInt16x8()
+	return x.Equal(y).AsInt16x8().Xor(ones).AsMask16x8()
+}
+
+// Less returns a mask whose elements indicate whether x < y
+//
+// Emulated, CPU Feature AVX
+func (x Int32x4) Less(y Int32x4) Mask32x4 {
+	return y.Greater(x)
+}
+
+// GreaterEqual returns a mask whose elements indicate whether x >= y
+//
+// Emulated, CPU Feature AVX
+func (x Int32x4) GreaterEqual(y Int32x4) Mask32x4 {
+	ones := x.Equal(x).AsInt32x4()
+	return y.Greater(x).AsInt32x4().Xor(ones).AsMask32x4()
+}
+
+// LessEqual returns a mask whose elements indicate whether x <= y
+//
+// Emulated, CPU Feature AVX
+func (x Int32x4) LessEqual(y Int32x4) Mask32x4 {
+	ones := x.Equal(x).AsInt32x4()
+	return x.Greater(y).AsInt32x4().Xor(ones).AsMask32x4()
+}
+
+// NotEqual returns a mask whose elements indicate whether x != y
+//
+// Emulated, CPU Feature AVX
+func (x Int32x4) NotEqual(y Int32x4) Mask32x4 {
+	ones := x.Equal(x).AsInt32x4()
+	return x.Equal(y).AsInt32x4().Xor(ones).AsMask32x4()
+}
+
+// Less returns a mask whose elements indicate whether x < y
+//
+// Emulated, CPU Feature AVX
+func (x Int64x2) Less(y Int64x2) Mask64x2 {
+	return y.Greater(x)
+}
+
+// GreaterEqual returns a mask whose elements indicate whether x >= y
+//
+// Emulated, CPU Feature AVX
+func (x Int64x2) GreaterEqual(y Int64x2) Mask64x2 {
+	ones := x.Equal(x).AsInt64x2()
+	return y.Greater(x).AsInt64x2().Xor(ones).AsMask64x2()
+}
+
+// LessEqual returns a mask whose elements indicate whether x <= y
+//
+// Emulated, CPU Feature AVX
+func (x Int64x2) LessEqual(y Int64x2) Mask64x2 {
+	ones := x.Equal(x).AsInt64x2()
+	return x.Greater(y).AsInt64x2().Xor(ones).AsMask64x2()
+}
+
+// NotEqual returns a mask whose elements indicate whether x != y
+//
+// Emulated, CPU Feature AVX
+func (x Int64x2) NotEqual(y Int64x2) Mask64x2 {
+	ones := x.Equal(x).AsInt64x2()
+	return x.Equal(y).AsInt64x2().Xor(ones).AsMask64x2()
+}
+
+// Less returns a mask whose elements indicate whether x < y
+//
+// Emulated, CPU Feature AVX2
+func (x Int8x32) Less(y Int8x32) Mask8x32 {
+	return y.Greater(x)
+}
+
+// GreaterEqual returns a mask whose elements indicate whether x >= y
+//
+// Emulated, CPU Feature AVX2
+func (x Int8x32) GreaterEqual(y Int8x32) Mask8x32 {
+	ones := x.Equal(x).AsInt8x32()
+	return y.Greater(x).AsInt8x32().Xor(ones).AsMask8x32()
+}
+
+// LessEqual returns a mask whose elements indicate whether x <= y
+//
+// Emulated, CPU Feature AVX2
+func (x Int8x32) LessEqual(y Int8x32) Mask8x32 {
+	ones := x.Equal(x).AsInt8x32()
+	return x.Greater(y).AsInt8x32().Xor(ones).AsMask8x32()
+}
+
+// NotEqual returns a mask whose elements indicate whether x != y
+//
+// Emulated, CPU Feature AVX2
+func (x Int8x32) NotEqual(y Int8x32) Mask8x32 {
+	ones := x.Equal(x).AsInt8x32()
+	return x.Equal(y).AsInt8x32().Xor(ones).AsMask8x32()
+}
+
+// Less returns a mask whose elements indicate whether x < y
+//
+// Emulated, CPU Feature AVX2
+func (x Int16x16) Less(y Int16x16) Mask16x16 {
+	return y.Greater(x)
+}
+
+// GreaterEqual returns a mask whose elements indicate whether x >= y
+//
+// Emulated, CPU Feature AVX2
+func (x Int16x16) GreaterEqual(y Int16x16) Mask16x16 {
+	ones := x.Equal(x).AsInt16x16()
+	return y.Greater(x).AsInt16x16().Xor(ones).AsMask16x16()
+}
+
+// LessEqual returns a mask whose elements indicate whether x <= y
+//
+// Emulated, CPU Feature AVX2
+func (x Int16x16) LessEqual(y Int16x16) Mask16x16 {
+	ones := x.Equal(x).AsInt16x16()
+	return x.Greater(y).AsInt16x16().Xor(ones).AsMask16x16()
+}
+
+// NotEqual returns a mask whose elements indicate whether x != y
+//
+// Emulated, CPU Feature AVX2
+func (x Int16x16) NotEqual(y Int16x16) Mask16x16 {
+	ones := x.Equal(x).AsInt16x16()
+	return x.Equal(y).AsInt16x16().Xor(ones).AsMask16x16()
+}
+
+// Less returns a mask whose elements indicate whether x < y
+//
+// Emulated, CPU Feature AVX2
+func (x Int32x8) Less(y Int32x8) Mask32x8 {
+	return y.Greater(x)
+}
+
+// GreaterEqual returns a mask whose elements indicate whether x >= y
+//
+// Emulated, CPU Feature AVX2
+func (x Int32x8) GreaterEqual(y Int32x8) Mask32x8 {
+	ones := x.Equal(x).AsInt32x8()
+	return y.Greater(x).AsInt32x8().Xor(ones).AsMask32x8()
+}
+
+// LessEqual returns a mask whose elements indicate whether x <= y
+//
+// Emulated, CPU Feature AVX2
+func (x Int32x8) LessEqual(y Int32x8) Mask32x8 {
+	ones := x.Equal(x).AsInt32x8()
+	return x.Greater(y).AsInt32x8().Xor(ones).AsMask32x8()
+}
+
+// NotEqual returns a mask whose elements indicate whether x != y
+//
+// Emulated, CPU Feature AVX2
+func (x Int32x8) NotEqual(y Int32x8) Mask32x8 {
+	ones := x.Equal(x).AsInt32x8()
+	return x.Equal(y).AsInt32x8().Xor(ones).AsMask32x8()
+}
+
+// Less returns a mask whose elements indicate whether x < y
+//
+// Emulated, CPU Feature AVX2
+func (x Int64x4) Less(y Int64x4) Mask64x4 {
+	return y.Greater(x)
+}
+
+// GreaterEqual returns a mask whose elements indicate whether x >= y
+//
+// Emulated, CPU Feature AVX2
+func (x Int64x4) GreaterEqual(y Int64x4) Mask64x4 {
+	ones := x.Equal(x).AsInt64x4()
+	return y.Greater(x).AsInt64x4().Xor(ones).AsMask64x4()
+}
+
+// LessEqual returns a mask whose elements indicate whether x <= y
+//
+// Emulated, CPU Feature AVX2
+func (x Int64x4) LessEqual(y Int64x4) Mask64x4 {
+	ones := x.Equal(x).AsInt64x4()
+	return x.Greater(y).AsInt64x4().Xor(ones).AsMask64x4()
+}
+
+// NotEqual returns a mask whose elements indicate whether x != y
+//
+// Emulated, CPU Feature AVX2
+func (x Int64x4) NotEqual(y Int64x4) Mask64x4 {
+	ones := x.Equal(x).AsInt64x4()
+	return x.Equal(y).AsInt64x4().Xor(ones).AsMask64x4()
+}
+
+// Greater returns a mask whose elements indicate whether x > y
+//
+// Emulated, CPU Feature AVX2
+func (x Uint8x16) Greater(y Uint8x16) Mask8x16 {
+	a, b := x.AsInt8x16(), y.AsInt8x16()
+	signs := BroadcastInt8x16(-1 << (8 - 1))
+	return a.Xor(signs).Greater(b.Xor(signs))
+}
+
+// Less returns a mask whose elements indicate whether x < y
+//
+// Emulated, CPU Feature AVX2
+func (x Uint8x16) Less(y Uint8x16) Mask8x16 {
+	a, b := x.AsInt8x16(), y.AsInt8x16()
+	signs := BroadcastInt8x16(-1 << (8 - 1))
+	return b.Xor(signs).Greater(a.Xor(signs))
+}
+
+// GreaterEqual returns a mask whose elements indicate whether x >= y
+//
+// Emulated, CPU Feature AVX2
+func (x Uint8x16) GreaterEqual(y Uint8x16) Mask8x16 {
+	a, b := x.AsInt8x16(), y.AsInt8x16()
+	ones := x.Equal(x).AsInt8x16()
+	signs := BroadcastInt8x16(-1 << (8 - 1))
+	return b.Xor(signs).Greater(a.Xor(signs)).AsInt8x16().Xor(ones).AsMask8x16()
+}
+
+// LessEqual returns a mask whose elements indicate whether x <= y
+//
+// Emulated, CPU Feature AVX2
+func (x Uint8x16) LessEqual(y Uint8x16) Mask8x16 {
+	a, b := x.AsInt8x16(), y.AsInt8x16()
+	ones := x.Equal(x).AsInt8x16()
+	signs := BroadcastInt8x16(-1 << (8 - 1))
+	return a.Xor(signs).Greater(b.Xor(signs)).AsInt8x16().Xor(ones).AsMask8x16()
+}
+
+// NotEqual returns a mask whose elements indicate whether x != y
+//
+// Emulated, CPU Feature AVX
+func (x Uint8x16) NotEqual(y Uint8x16) Mask8x16 {
+	a, b := x.AsInt8x16(), y.AsInt8x16()
+	ones := x.Equal(x).AsInt8x16()
+	return a.Equal(b).AsInt8x16().Xor(ones).AsMask8x16()
+}
+
+// Greater returns a mask whose elements indicate whether x > y
+//
+// Emulated, CPU Feature AVX
+func (x Uint16x8) Greater(y Uint16x8) Mask16x8 {
+	a, b := x.AsInt16x8(), y.AsInt16x8()
+	ones := x.Equal(x).AsInt16x8()
+	signs := ones.ShiftAllLeft(16 - 1)
+	return a.Xor(signs).Greater(b.Xor(signs))
+}
+
+// Less returns a mask whose elements indicate whether x < y
+//
+// Emulated, CPU Feature AVX
+func (x Uint16x8) Less(y Uint16x8) Mask16x8 {
+	a, b := x.AsInt16x8(), y.AsInt16x8()
+	ones := x.Equal(x).AsInt16x8()
+	signs := ones.ShiftAllLeft(16 - 1)
+	return b.Xor(signs).Greater(a.Xor(signs))
+}
+
+// GreaterEqual returns a mask whose elements indicate whether x >= y
+//
+// Emulated, CPU Feature AVX
+func (x Uint16x8) GreaterEqual(y Uint16x8) Mask16x8 {
+	a, b := x.AsInt16x8(), y.AsInt16x8()
+	ones := x.Equal(x).AsInt16x8()
+	signs := ones.ShiftAllLeft(16 - 1)
+	return b.Xor(signs).Greater(a.Xor(signs)).AsInt16x8().Xor(ones).AsMask16x8()
+}
+
+// LessEqual returns a mask whose elements indicate whether x <= y
+//
+// Emulated, CPU Feature AVX
+func (x Uint16x8) LessEqual(y Uint16x8) Mask16x8 {
+	a, b := x.AsInt16x8(), y.AsInt16x8()
+	ones := x.Equal(x).AsInt16x8()
+	signs := ones.ShiftAllLeft(16 - 1)
+	return a.Xor(signs).Greater(b.Xor(signs)).AsInt16x8().Xor(ones).AsMask16x8()
+}
+
+// NotEqual returns a mask whose elements indicate whether x != y
+//
+// Emulated, CPU Feature AVX
+func (x Uint16x8) NotEqual(y Uint16x8) Mask16x8 {
+	a, b := x.AsInt16x8(), y.AsInt16x8()
+	ones := x.Equal(x).AsInt16x8()
+	return a.Equal(b).AsInt16x8().Xor(ones).AsMask16x8()
+}
+
+// Greater returns a mask whose elements indicate whether x > y
+//
+// Emulated, CPU Feature AVX
+func (x Uint32x4) Greater(y Uint32x4) Mask32x4 {
+	a, b := x.AsInt32x4(), y.AsInt32x4()
+	ones := x.Equal(x).AsInt32x4()
+	signs := ones.ShiftAllLeft(32 - 1)
+	return a.Xor(signs).Greater(b.Xor(signs))
+}
+
+// Less returns a mask whose elements indicate whether x < y
+//
+// Emulated, CPU Feature AVX
+func (x Uint32x4) Less(y Uint32x4) Mask32x4 {
+	a, b := x.AsInt32x4(), y.AsInt32x4()
+	ones := x.Equal(x).AsInt32x4()
+	signs := ones.ShiftAllLeft(32 - 1)
+	return b.Xor(signs).Greater(a.Xor(signs))
+}
+
+// GreaterEqual returns a mask whose elements indicate whether x >= y
+//
+// Emulated, CPU Feature AVX
+func (x Uint32x4) GreaterEqual(y Uint32x4) Mask32x4 {
+	a, b := x.AsInt32x4(), y.AsInt32x4()
+	ones := x.Equal(x).AsInt32x4()
+	signs := ones.ShiftAllLeft(32 - 1)
+	return b.Xor(signs).Greater(a.Xor(signs)).AsInt32x4().Xor(ones).AsMask32x4()
+}
+
+// LessEqual returns a mask whose elements indicate whether x <= y
+//
+// Emulated, CPU Feature AVX
+func (x Uint32x4) LessEqual(y Uint32x4) Mask32x4 {
+	a, b := x.AsInt32x4(), y.AsInt32x4()
+	ones := x.Equal(x).AsInt32x4()
+	signs := ones.ShiftAllLeft(32 - 1)
+	return a.Xor(signs).Greater(b.Xor(signs)).AsInt32x4().Xor(ones).AsMask32x4()
+}
+
+// NotEqual returns a mask whose elements indicate whether x != y
+//
+// Emulated, CPU Feature AVX
+func (x Uint32x4) NotEqual(y Uint32x4) Mask32x4 {
+	a, b := x.AsInt32x4(), y.AsInt32x4()
+	ones := x.Equal(x).AsInt32x4()
+	return a.Equal(b).AsInt32x4().Xor(ones).AsMask32x4()
+}
+
+// Greater returns a mask whose elements indicate whether x > y
+//
+// Emulated, CPU Feature AVX
+func (x Uint64x2) Greater(y Uint64x2) Mask64x2 {
+	a, b := x.AsInt64x2(), y.AsInt64x2()
+	ones := x.Equal(x).AsInt64x2()
+	signs := ones.ShiftAllLeft(64 - 1)
+	return a.Xor(signs).Greater(b.Xor(signs))
+}
+
+// Less returns a mask whose elements indicate whether x < y
+//
+// Emulated, CPU Feature AVX
+func (x Uint64x2) Less(y Uint64x2) Mask64x2 {
+	a, b := x.AsInt64x2(), y.AsInt64x2()
+	ones := x.Equal(x).AsInt64x2()
+	signs := ones.ShiftAllLeft(64 - 1)
+	return b.Xor(signs).Greater(a.Xor(signs))
+}
+
+// GreaterEqual returns a mask whose elements indicate whether x >= y
+//
+// Emulated, CPU Feature AVX
+func (x Uint64x2) GreaterEqual(y Uint64x2) Mask64x2 {
+	a, b := x.AsInt64x2(), y.AsInt64x2()
+	ones := x.Equal(x).AsInt64x2()
+	signs := ones.ShiftAllLeft(64 - 1)
+	return b.Xor(signs).Greater(a.Xor(signs)).AsInt64x2().Xor(ones).AsMask64x2()
+}
+
+// LessEqual returns a mask whose elements indicate whether x <= y
+//
+// Emulated, CPU Feature AVX
+func (x Uint64x2) LessEqual(y Uint64x2) Mask64x2 {
+	a, b := x.AsInt64x2(), y.AsInt64x2()
+	ones := x.Equal(x).AsInt64x2()
+	signs := ones.ShiftAllLeft(64 - 1)
+	return a.Xor(signs).Greater(b.Xor(signs)).AsInt64x2().Xor(ones).AsMask64x2()
+}
+
+// NotEqual returns a mask whose elements indicate whether x != y
+//
+// Emulated, CPU Feature AVX
+func (x Uint64x2) NotEqual(y Uint64x2) Mask64x2 {
+	a, b := x.AsInt64x2(), y.AsInt64x2()
+	ones := x.Equal(x).AsInt64x2()
+	return a.Equal(b).AsInt64x2().Xor(ones).AsMask64x2()
+}
+
+// Greater returns a mask whose elements indicate whether x > y
+//
+// Emulated, CPU Feature AVX2
+func (x Uint8x32) Greater(y Uint8x32) Mask8x32 {
+	a, b := x.AsInt8x32(), y.AsInt8x32()
+	signs := BroadcastInt8x32(-1 << (8 - 1))
+	return a.Xor(signs).Greater(b.Xor(signs))
+}
+
+// Less returns a mask whose elements indicate whether x < y
+//
+// Emulated, CPU Feature AVX2
+func (x Uint8x32) Less(y Uint8x32) Mask8x32 {
+	a, b := x.AsInt8x32(), y.AsInt8x32()
+	signs := BroadcastInt8x32(-1 << (8 - 1))
+	return b.Xor(signs).Greater(a.Xor(signs))
+}
+
+// GreaterEqual returns a mask whose elements indicate whether x >= y
+//
+// Emulated, CPU Feature AVX2
+func (x Uint8x32) GreaterEqual(y Uint8x32) Mask8x32 {
+	a, b := x.AsInt8x32(), y.AsInt8x32()
+	ones := x.Equal(x).AsInt8x32()
+	signs := BroadcastInt8x32(-1 << (8 - 1))
+	return b.Xor(signs).Greater(a.Xor(signs)).AsInt8x32().Xor(ones).AsMask8x32()
+}
+
+// LessEqual returns a mask whose elements indicate whether x <= y
+//
+// Emulated, CPU Feature AVX2
+func (x Uint8x32) LessEqual(y Uint8x32) Mask8x32 {
+	a, b := x.AsInt8x32(), y.AsInt8x32()
+	ones := x.Equal(x).AsInt8x32()
+	signs := BroadcastInt8x32(-1 << (8 - 1))
+	return a.Xor(signs).Greater(b.Xor(signs)).AsInt8x32().Xor(ones).AsMask8x32()
+}
+
+// NotEqual returns a mask whose elements indicate whether x != y
+//
+// Emulated, CPU Feature AVX2
+func (x Uint8x32) NotEqual(y Uint8x32) Mask8x32 {
+	a, b := x.AsInt8x32(), y.AsInt8x32()
+	ones := x.Equal(x).AsInt8x32()
+	return a.Equal(b).AsInt8x32().Xor(ones).AsMask8x32()
+}
+
+// Greater returns a mask whose elements indicate whether x > y
+//
+// Emulated, CPU Feature AVX2
+func (x Uint16x16) Greater(y Uint16x16) Mask16x16 {
+	a, b := x.AsInt16x16(), y.AsInt16x16()
+	ones := x.Equal(x).AsInt16x16()
+	signs := ones.ShiftAllLeft(16 - 1)
+	return a.Xor(signs).Greater(b.Xor(signs))
+}
+
+// Less returns a mask whose elements indicate whether x < y
+//
+// Emulated, CPU Feature AVX2
+func (x Uint16x16) Less(y Uint16x16) Mask16x16 {
+	a, b := x.AsInt16x16(), y.AsInt16x16()
+	ones := x.Equal(x).AsInt16x16()
+	signs := ones.ShiftAllLeft(16 - 1)
+	return b.Xor(signs).Greater(a.Xor(signs))
+}
+
+// GreaterEqual returns a mask whose elements indicate whether x >= y
+//
+// Emulated, CPU Feature AVX2
+func (x Uint16x16) GreaterEqual(y Uint16x16) Mask16x16 {
+	a, b := x.AsInt16x16(), y.AsInt16x16()
+	ones := x.Equal(x).AsInt16x16()
+	signs := ones.ShiftAllLeft(16 - 1)
+	return b.Xor(signs).Greater(a.Xor(signs)).AsInt16x16().Xor(ones).AsMask16x16()
+}
+
+// LessEqual returns a mask whose elements indicate whether x <= y
+//
+// Emulated, CPU Feature AVX2
+func (x Uint16x16) LessEqual(y Uint16x16) Mask16x16 {
+	a, b := x.AsInt16x16(), y.AsInt16x16()
+	ones := x.Equal(x).AsInt16x16()
+	signs := ones.ShiftAllLeft(16 - 1)
+	return a.Xor(signs).Greater(b.Xor(signs)).AsInt16x16().Xor(ones).AsMask16x16()
+}
+
+// NotEqual returns a mask whose elements indicate whether x != y
+//
+// Emulated, CPU Feature AVX2
+func (x Uint16x16) NotEqual(y Uint16x16) Mask16x16 {
+	a, b := x.AsInt16x16(), y.AsInt16x16()
+	ones := x.Equal(x).AsInt16x16()
+	return a.Equal(b).AsInt16x16().Xor(ones).AsMask16x16()
+}
+
+// Greater returns a mask whose elements indicate whether x > y
+//
+// Emulated, CPU Feature AVX2
+func (x Uint32x8) Greater(y Uint32x8) Mask32x8 {
+	a, b := x.AsInt32x8(), y.AsInt32x8()
+	ones := x.Equal(x).AsInt32x8()
+	signs := ones.ShiftAllLeft(32 - 1)
+	return a.Xor(signs).Greater(b.Xor(signs))
+}
+
+// Less returns a mask whose elements indicate whether x < y
+//
+// Emulated, CPU Feature AVX2
+func (x Uint32x8) Less(y Uint32x8) Mask32x8 {
+	a, b := x.AsInt32x8(), y.AsInt32x8()
+	ones := x.Equal(x).AsInt32x8()
+	signs := ones.ShiftAllLeft(32 - 1)
+	return b.Xor(signs).Greater(a.Xor(signs))
+}
+
+// GreaterEqual returns a mask whose elements indicate whether x >= y
+//
+// Emulated, CPU Feature AVX2
+func (x Uint32x8) GreaterEqual(y Uint32x8) Mask32x8 {
+	a, b := x.AsInt32x8(), y.AsInt32x8()
+	ones := x.Equal(x).AsInt32x8()
+	signs := ones.ShiftAllLeft(32 - 1)
+	return b.Xor(signs).Greater(a.Xor(signs)).AsInt32x8().Xor(ones).AsMask32x8()
+}
+
+// LessEqual returns a mask whose elements indicate whether x <= y
+//
+// Emulated, CPU Feature AVX2
+func (x Uint32x8) LessEqual(y Uint32x8) Mask32x8 {
+	a, b := x.AsInt32x8(), y.AsInt32x8()
+	ones := x.Equal(x).AsInt32x8()
+	signs := ones.ShiftAllLeft(32 - 1)
+	return a.Xor(signs).Greater(b.Xor(signs)).AsInt32x8().Xor(ones).AsMask32x8()
+}
+
+// NotEqual returns a mask whose elements indicate whether x != y
+//
+// Emulated, CPU Feature AVX2
+func (x Uint32x8) NotEqual(y Uint32x8) Mask32x8 {
+	a, b := x.AsInt32x8(), y.AsInt32x8()
+	ones := x.Equal(x).AsInt32x8()
+	return a.Equal(b).AsInt32x8().Xor(ones).AsMask32x8()
+}
+
+// Greater returns a mask whose elements indicate whether x > y
+//
+// Emulated, CPU Feature AVX2
+func (x Uint64x4) Greater(y Uint64x4) Mask64x4 {
+	a, b := x.AsInt64x4(), y.AsInt64x4()
+	ones := x.Equal(x).AsInt64x4()
+	signs := ones.ShiftAllLeft(64 - 1)
+	return a.Xor(signs).Greater(b.Xor(signs))
+}
+
+// Less returns a mask whose elements indicate whether x < y
+//
+// Emulated, CPU Feature AVX2
+func (x Uint64x4) Less(y Uint64x4) Mask64x4 {
+	a, b := x.AsInt64x4(), y.AsInt64x4()
+	ones := x.Equal(x).AsInt64x4()
+	signs := ones.ShiftAllLeft(64 - 1)
+	return b.Xor(signs).Greater(a.Xor(signs))
+}
+
+// GreaterEqual returns a mask whose elements indicate whether x >= y
+//
+// Emulated, CPU Feature AVX2
+func (x Uint64x4) GreaterEqual(y Uint64x4) Mask64x4 {
+	a, b := x.AsInt64x4(), y.AsInt64x4()
+	ones := x.Equal(x).AsInt64x4()
+	signs := ones.ShiftAllLeft(64 - 1)
+	return b.Xor(signs).Greater(a.Xor(signs)).AsInt64x4().Xor(ones).AsMask64x4()
+}
+
+// LessEqual returns a mask whose elements indicate whether x <= y
+//
+// Emulated, CPU Feature AVX2
+func (x Uint64x4) LessEqual(y Uint64x4) Mask64x4 {
+	a, b := x.AsInt64x4(), y.AsInt64x4()
+	ones := x.Equal(x).AsInt64x4()
+	signs := ones.ShiftAllLeft(64 - 1)
+	return a.Xor(signs).Greater(b.Xor(signs)).AsInt64x4().Xor(ones).AsMask64x4()
+}
+
+// NotEqual returns a mask whose elements indicate whether x != y
+//
+// Emulated, CPU Feature AVX2
+func (x Uint64x4) NotEqual(y Uint64x4) Mask64x4 {
+	a, b := x.AsInt64x4(), y.AsInt64x4()
+	ones := x.Equal(x).AsInt64x4()
+	return a.Equal(b).AsInt64x4().Xor(ones).AsMask64x4()
+}

src/simd/genfiles.go

@@ -175,8 +175,6 @@ func prologue(s string, out io.Writer) {
 
 package simd
 
-import "unsafe"
-
 `, s)
 }
 
@@ -708,7 +706,10 @@ func Broadcast{{.Vec}}(x {{.Type}}) {{.Vec}} {
 `)
 
 func main() {
-	sl := flag.String("sl", "slice_amd64.go", "file name for slice operations")
+	sl := flag.String("sl", "slice_gen_amd64.go", "file name for slice operations")
+	cm := flag.String("cm", "compare_gen_amd64.go", "file name for comparison operations")
+	mm := flag.String("mm", "maskmerge_gen_amd64.go", "file name for mask/merge operations")
+	op := flag.String("op", "other_gen_amd64.go", "file name for other operations")
 	ush := flag.String("ush", "unsafe_helpers.go", "file name for unsafe helpers")
 	bh := flag.String("bh", "binary_helpers_test.go", "file name for binary test helpers")
 	uh := flag.String("uh", "unary_helpers_test.go", "file name for unary test helpers")
@@ -718,15 +719,27 @@ func main() {
 	flag.Parse()
 
 	if *sl != "" {
-		one(*sl, prologue,
+		one(*sl, unsafePrologue,
 			sliceTemplate,
 			avx512MaskedLoadSlicePartTemplate,
 			avx2MaskedLoadSlicePartTemplate,
 			avx2SmallLoadSlicePartTemplate,
-			avx2MaskedTemplate,
-			avx512MaskedTemplate,
+		)
+	}
+	if *cm != "" {
+		one(*cm, prologue,
 			avx2SignedComparisonsTemplate,
 			avx2UnsignedComparisonsTemplate,
+		)
+	}
+	if *mm != "" {
+		one(*mm, prologue,
+			avx2MaskedTemplate,
+			avx512MaskedTemplate,
+		)
+	}
+	if *op != "" {
+		one(*op, prologue,
 			broadcastTemplate,
 		)
 	}

src/simd/maskmerge_gen_amd64.go

@@ -0,0 +1,403 @@
+// Code generated by 'go run genfiles.go'; DO NOT EDIT.
+
+//go:build goexperiment.simd
+
+package simd
+
+// Masked returns x but with elements zeroed where mask is false.
+func (x Int8x16) Masked(mask Mask8x16) Int8x16 {
+	im := mask.AsInt8x16()
+	return im.And(x)
+}
+
+// Merge returns x but with elements set to y where mask is false.
+func (x Int8x16) Merge(y Int8x16, mask Mask8x16) Int8x16 {
+	im := mask.AsInt8x16()
+	return y.blend(x, im)
+}
+
+// Masked returns x but with elements zeroed where mask is false.
+func (x Int16x8) Masked(mask Mask16x8) Int16x8 {
+	im := mask.AsInt16x8()
+	return im.And(x)
+}
+
+// Merge returns x but with elements set to y where mask is false.
+func (x Int16x8) Merge(y Int16x8, mask Mask16x8) Int16x8 {
+	im := mask.AsInt16x8().AsInt8x16()
+	ix := x.AsInt8x16()
+	iy := y.AsInt8x16()
+	return iy.blend(ix, im).AsInt16x8()
+}
+
+// Masked returns x but with elements zeroed where mask is false.
+func (x Int32x4) Masked(mask Mask32x4) Int32x4 {
+	im := mask.AsInt32x4()
+	return im.And(x)
+}
+
+// Merge returns x but with elements set to y where mask is false.
+func (x Int32x4) Merge(y Int32x4, mask Mask32x4) Int32x4 {
+	im := mask.AsInt32x4().AsInt8x16()
+	ix := x.AsInt8x16()
+	iy := y.AsInt8x16()
+	return iy.blend(ix, im).AsInt32x4()
+}
+
+// Masked returns x but with elements zeroed where mask is false.
+func (x Int64x2) Masked(mask Mask64x2) Int64x2 {
+	im := mask.AsInt64x2()
+	return im.And(x)
+}
+
+// Merge returns x but with elements set to y where mask is false.
+func (x Int64x2) Merge(y Int64x2, mask Mask64x2) Int64x2 {
+	im := mask.AsInt64x2().AsInt8x16()
+	ix := x.AsInt8x16()
+	iy := y.AsInt8x16()
+	return iy.blend(ix, im).AsInt64x2()
+}
+
+// Masked returns x but with elements zeroed where mask is false.
+func (x Uint8x16) Masked(mask Mask8x16) Uint8x16 {
+	im := mask.AsInt8x16()
+	return x.AsInt8x16().And(im).AsUint8x16()
+}
+
+// Merge returns x but with elements set to y where mask is false.
+func (x Uint8x16) Merge(y Uint8x16, mask Mask8x16) Uint8x16 {
+	im := mask.AsInt8x16()
+	ix := x.AsInt8x16()
+	iy := y.AsInt8x16()
+	return iy.blend(ix, im).AsUint8x16()
+}
+
+// Masked returns x but with elements zeroed where mask is false.
+func (x Uint16x8) Masked(mask Mask16x8) Uint16x8 {
+	im := mask.AsInt16x8()
+	return x.AsInt16x8().And(im).AsUint16x8()
+}
+
+// Merge returns x but with elements set to y where mask is false.
+func (x Uint16x8) Merge(y Uint16x8, mask Mask16x8) Uint16x8 {
+	im := mask.AsInt16x8().AsInt8x16()
+	ix := x.AsInt8x16()
+	iy := y.AsInt8x16()
+	return iy.blend(ix, im).AsUint16x8()
+}
+
+// Masked returns x but with elements zeroed where mask is false.
+func (x Uint32x4) Masked(mask Mask32x4) Uint32x4 {
+	im := mask.AsInt32x4()
+	return x.AsInt32x4().And(im).AsUint32x4()
+}
+
+// Merge returns x but with elements set to y where mask is false.
+func (x Uint32x4) Merge(y Uint32x4, mask Mask32x4) Uint32x4 {
+	im := mask.AsInt32x4().AsInt8x16()
+	ix := x.AsInt8x16()
+	iy := y.AsInt8x16()
+	return iy.blend(ix, im).AsUint32x4()
+}
+
+// Masked returns x but with elements zeroed where mask is false.
+func (x Uint64x2) Masked(mask Mask64x2) Uint64x2 {
+	im := mask.AsInt64x2()
+	return x.AsInt64x2().And(im).AsUint64x2()
+}
+
+// Merge returns x but with elements set to y where mask is false.
+func (x Uint64x2) Merge(y Uint64x2, mask Mask64x2) Uint64x2 {
+	im := mask.AsInt64x2().AsInt8x16()
+	ix := x.AsInt8x16()
+	iy := y.AsInt8x16()
+	return iy.blend(ix, im).AsUint64x2()
+}
+
+// Masked returns x but with elements zeroed where mask is false.
+func (x Float32x4) Masked(mask Mask32x4) Float32x4 {
+	im := mask.AsInt32x4()
+	return x.AsInt32x4().And(im).AsFloat32x4()
+}
+
+// Merge returns x but with elements set to y where mask is false.
+func (x Float32x4) Merge(y Float32x4, mask Mask32x4) Float32x4 {
+	im := mask.AsInt32x4().AsInt8x16()
+	ix := x.AsInt8x16()
+	iy := y.AsInt8x16()
+	return iy.blend(ix, im).AsFloat32x4()
+}
+
+// Masked returns x but with elements zeroed where mask is false.
+func (x Float64x2) Masked(mask Mask64x2) Float64x2 {
+	im := mask.AsInt64x2()
+	return x.AsInt64x2().And(im).AsFloat64x2()
+}
+
+// Merge returns x but with elements set to y where mask is false.
+func (x Float64x2) Merge(y Float64x2, mask Mask64x2) Float64x2 {
+	im := mask.AsInt64x2().AsInt8x16()
+	ix := x.AsInt8x16()
+	iy := y.AsInt8x16()
+	return iy.blend(ix, im).AsFloat64x2()
+}
+
+// Masked returns x but with elements zeroed where mask is false.
+func (x Int8x32) Masked(mask Mask8x32) Int8x32 {
+	im := mask.AsInt8x32()
+	return im.And(x)
+}
+
+// Merge returns x but with elements set to y where mask is false.
+func (x Int8x32) Merge(y Int8x32, mask Mask8x32) Int8x32 {
+	im := mask.AsInt8x32()
+	return y.blend(x, im)
+}
+
+// Masked returns x but with elements zeroed where mask is false.
+func (x Int16x16) Masked(mask Mask16x16) Int16x16 {
+	im := mask.AsInt16x16()
+	return im.And(x)
+}
+
+// Merge returns x but with elements set to y where mask is false.
+func (x Int16x16) Merge(y Int16x16, mask Mask16x16) Int16x16 {
+	im := mask.AsInt16x16().AsInt8x32()
+	ix := x.AsInt8x32()
+	iy := y.AsInt8x32()
+	return iy.blend(ix, im).AsInt16x16()
+}
+
+// Masked returns x but with elements zeroed where mask is false.
+func (x Int32x8) Masked(mask Mask32x8) Int32x8 {
+	im := mask.AsInt32x8()
+	return im.And(x)
+}
+
+// Merge returns x but with elements set to y where mask is false.
+func (x Int32x8) Merge(y Int32x8, mask Mask32x8) Int32x8 {
+	im := mask.AsInt32x8().AsInt8x32()
+	ix := x.AsInt8x32()
+	iy := y.AsInt8x32()
+	return iy.blend(ix, im).AsInt32x8()
+}
+
+// Masked returns x but with elements zeroed where mask is false.
+func (x Int64x4) Masked(mask Mask64x4) Int64x4 {
+	im := mask.AsInt64x4()
+	return im.And(x)
+}
+
+// Merge returns x but with elements set to y where mask is false.
+func (x Int64x4) Merge(y Int64x4, mask Mask64x4) Int64x4 {
+	im := mask.AsInt64x4().AsInt8x32()
+	ix := x.AsInt8x32()
+	iy := y.AsInt8x32()
+	return iy.blend(ix, im).AsInt64x4()
+}
+
+// Masked returns x but with elements zeroed where mask is false.
+func (x Uint8x32) Masked(mask Mask8x32) Uint8x32 {
+	im := mask.AsInt8x32()
+	return x.AsInt8x32().And(im).AsUint8x32()
+}
+
+// Merge returns x but with elements set to y where mask is false.
+func (x Uint8x32) Merge(y Uint8x32, mask Mask8x32) Uint8x32 {
+	im := mask.AsInt8x32()
+	ix := x.AsInt8x32()
+	iy := y.AsInt8x32()
+	return iy.blend(ix, im).AsUint8x32()
+}
+
+// Masked returns x but with elements zeroed where mask is false.
+func (x Uint16x16) Masked(mask Mask16x16) Uint16x16 {
+	im := mask.AsInt16x16()
+	return x.AsInt16x16().And(im).AsUint16x16()
+}
+
+// Merge returns x but with elements set to y where mask is false.
+func (x Uint16x16) Merge(y Uint16x16, mask Mask16x16) Uint16x16 {
+	im := mask.AsInt16x16().AsInt8x32()
+	ix := x.AsInt8x32()
+	iy := y.AsInt8x32()
+	return iy.blend(ix, im).AsUint16x16()
+}
+
+// Masked returns x but with elements zeroed where mask is false.
+func (x Uint32x8) Masked(mask Mask32x8) Uint32x8 {
+	im := mask.AsInt32x8()
+	return x.AsInt32x8().And(im).AsUint32x8()
+}
+
+// Merge returns x but with elements set to y where mask is false.
+func (x Uint32x8) Merge(y Uint32x8, mask Mask32x8) Uint32x8 {
+	im := mask.AsInt32x8().AsInt8x32()
+	ix := x.AsInt8x32()
+	iy := y.AsInt8x32()
+	return iy.blend(ix, im).AsUint32x8()
+}
+
+// Masked returns x but with elements zeroed where mask is false.
+func (x Uint64x4) Masked(mask Mask64x4) Uint64x4 {
+	im := mask.AsInt64x4()
+	return x.AsInt64x4().And(im).AsUint64x4()
+}
+
+// Merge returns x but with elements set to y where mask is false.
+func (x Uint64x4) Merge(y Uint64x4, mask Mask64x4) Uint64x4 {
+	im := mask.AsInt64x4().AsInt8x32()
+	ix := x.AsInt8x32()
+	iy := y.AsInt8x32()
+	return iy.blend(ix, im).AsUint64x4()
+}
+
+// Masked returns x but with elements zeroed where mask is false.
+func (x Float32x8) Masked(mask Mask32x8) Float32x8 {
+	im := mask.AsInt32x8()
+	return x.AsInt32x8().And(im).AsFloat32x8()
+}
+
+// Merge returns x but with elements set to y where mask is false.
+func (x Float32x8) Merge(y Float32x8, mask Mask32x8) Float32x8 {
+	im := mask.AsInt32x8().AsInt8x32()
+	ix := x.AsInt8x32()
+	iy := y.AsInt8x32()
+	return iy.blend(ix, im).AsFloat32x8()
+}
+
+// Masked returns x but with elements zeroed where mask is false.
+func (x Float64x4) Masked(mask Mask64x4) Float64x4 {
+	im := mask.AsInt64x4()
+	return x.AsInt64x4().And(im).AsFloat64x4()
+}
+
+// Merge returns x but with elements set to y where mask is false.
+func (x Float64x4) Merge(y Float64x4, mask Mask64x4) Float64x4 {
+	im := mask.AsInt64x4().AsInt8x32()
+	ix := x.AsInt8x32()
+	iy := y.AsInt8x32()
+	return iy.blend(ix, im).AsFloat64x4()
+}
+
+// Masked returns x but with elements zeroed where mask is false.
+func (x Int8x64) Masked(mask Mask8x64) Int8x64 {
+	im := mask.AsInt8x64()
+	return im.And(x)
+}
+
+// Merge returns x but with elements set to y where m is false.
+func (x Int8x64) Merge(y Int8x64, mask Mask8x64) Int8x64 {
+	return y.blendMasked(x, mask)
+}
+
+// Masked returns x but with elements zeroed where mask is false.
+func (x Int16x32) Masked(mask Mask16x32) Int16x32 {
+	im := mask.AsInt16x32()
+	return im.And(x)
+}
+
+// Merge returns x but with elements set to y where m is false.
+func (x Int16x32) Merge(y Int16x32, mask Mask16x32) Int16x32 {
+	return y.blendMasked(x, mask)
+}
+
+// Masked returns x but with elements zeroed where mask is false.
+func (x Int32x16) Masked(mask Mask32x16) Int32x16 {
+	im := mask.AsInt32x16()
+	return im.And(x)
+}
+
+// Merge returns x but with elements set to y where m is false.
+func (x Int32x16) Merge(y Int32x16, mask Mask32x16) Int32x16 {
+	return y.blendMasked(x, mask)
+}
+
+// Masked returns x but with elements zeroed where mask is false.
+func (x Int64x8) Masked(mask Mask64x8) Int64x8 {
+	im := mask.AsInt64x8()
+	return im.And(x)
+}
+
+// Merge returns x but with elements set to y where m is false.
+func (x Int64x8) Merge(y Int64x8, mask Mask64x8) Int64x8 {
+	return y.blendMasked(x, mask)
+}
+
+// Masked returns x but with elements zeroed where mask is false.
+func (x Uint8x64) Masked(mask Mask8x64) Uint8x64 {
+	im := mask.AsInt8x64()
+	return x.AsInt8x64().And(im).AsUint8x64()
+}
+
+// Merge returns x but with elements set to y where m is false.
+func (x Uint8x64) Merge(y Uint8x64, mask Mask8x64) Uint8x64 {
+	ix := x.AsInt8x64()
+	iy := y.AsInt8x64()
+	return iy.blendMasked(ix, mask).AsUint8x64()
+}
+
+// Masked returns x but with elements zeroed where mask is false.
+func (x Uint16x32) Masked(mask Mask16x32) Uint16x32 {
+	im := mask.AsInt16x32()
+	return x.AsInt16x32().And(im).AsUint16x32()
+}
+
+// Merge returns x but with elements set to y where m is false.
+func (x Uint16x32) Merge(y Uint16x32, mask Mask16x32) Uint16x32 {
+	ix := x.AsInt16x32()
+	iy := y.AsInt16x32()
+	return iy.blendMasked(ix, mask).AsUint16x32()
+}
+
+// Masked returns x but with elements zeroed where mask is false.
+func (x Uint32x16) Masked(mask Mask32x16) Uint32x16 {
+	im := mask.AsInt32x16()
+	return x.AsInt32x16().And(im).AsUint32x16()
+}
+
+// Merge returns x but with elements set to y where m is false.
+func (x Uint32x16) Merge(y Uint32x16, mask Mask32x16) Uint32x16 {
+	ix := x.AsInt32x16()
+	iy := y.AsInt32x16()
+	return iy.blendMasked(ix, mask).AsUint32x16()
+}
+
+// Masked returns x but with elements zeroed where mask is false.
+func (x Uint64x8) Masked(mask Mask64x8) Uint64x8 {
+	im := mask.AsInt64x8()
+	return x.AsInt64x8().And(im).AsUint64x8()
+}
+
+// Merge returns x but with elements set to y where m is false.
+func (x Uint64x8) Merge(y Uint64x8, mask Mask64x8) Uint64x8 {
+	ix := x.AsInt64x8()
+	iy := y.AsInt64x8()
+	return iy.blendMasked(ix, mask).AsUint64x8()
+}
+
+// Masked returns x but with elements zeroed where mask is false.
+func (x Float32x16) Masked(mask Mask32x16) Float32x16 {
+	im := mask.AsInt32x16()
+	return x.AsInt32x16().And(im).AsFloat32x16()
+}
+
+// Merge returns x but with elements set to y where m is false.
+func (x Float32x16) Merge(y Float32x16, mask Mask32x16) Float32x16 {
+	ix := x.AsInt32x16()
+	iy := y.AsInt32x16()
+	return iy.blendMasked(ix, mask).AsFloat32x16()
+}
+
+// Masked returns x but with elements zeroed where mask is false.
+func (x Float64x8) Masked(mask Mask64x8) Float64x8 {
+	im := mask.AsInt64x8()
+	return x.AsInt64x8().And(im).AsFloat64x8()
+}
+
+// Merge returns x but with elements set to y where m is false.
+func (x Float64x8) Merge(y Float64x8, mask Mask64x8) Float64x8 {
+	ix := x.AsInt64x8()
+	iy := y.AsInt64x8()
+	return iy.blendMasked(ix, mask).AsFloat64x8()
+}

src/simd/other_gen_amd64.go

@@ -0,0 +1,275 @@
+// Code generated by 'go run genfiles.go'; DO NOT EDIT.
+
+//go:build goexperiment.simd
+
+package simd
+
+// BroadcastInt8x16 returns a vector with the input
+// x assigned to all elements of the output.
+//
+// Emulated, CPU Feature AVX2
+func BroadcastInt8x16(x int8) Int8x16 {
+	var z Int8x16
+	return z.SetElem(0, x).Broadcast128()
+}
+
+// BroadcastInt16x8 returns a vector with the input
+// x assigned to all elements of the output.
+//
+// Emulated, CPU Feature AVX2
+func BroadcastInt16x8(x int16) Int16x8 {
+	var z Int16x8
+	return z.SetElem(0, x).Broadcast128()
+}
+
+// BroadcastInt32x4 returns a vector with the input
+// x assigned to all elements of the output.
+//
+// Emulated, CPU Feature AVX2
+func BroadcastInt32x4(x int32) Int32x4 {
+	var z Int32x4
+	return z.SetElem(0, x).Broadcast128()
+}
+
+// BroadcastInt64x2 returns a vector with the input
+// x assigned to all elements of the output.
+//
+// Emulated, CPU Feature AVX2
+func BroadcastInt64x2(x int64) Int64x2 {
+	var z Int64x2
+	return z.SetElem(0, x).Broadcast128()
+}
+
+// BroadcastUint8x16 returns a vector with the input
+// x assigned to all elements of the output.
+//
+// Emulated, CPU Feature AVX2
+func BroadcastUint8x16(x uint8) Uint8x16 {
+	var z Uint8x16
+	return z.SetElem(0, x).Broadcast128()
+}
+
+// BroadcastUint16x8 returns a vector with the input
+// x assigned to all elements of the output.
+//
+// Emulated, CPU Feature AVX2
+func BroadcastUint16x8(x uint16) Uint16x8 {
+	var z Uint16x8
+	return z.SetElem(0, x).Broadcast128()
+}
+
+// BroadcastUint32x4 returns a vector with the input
+// x assigned to all elements of the output.
+//
+// Emulated, CPU Feature AVX2
+func BroadcastUint32x4(x uint32) Uint32x4 {
+	var z Uint32x4
+	return z.SetElem(0, x).Broadcast128()
+}
+
+// BroadcastUint64x2 returns a vector with the input
+// x assigned to all elements of the output.
+//
+// Emulated, CPU Feature AVX2
+func BroadcastUint64x2(x uint64) Uint64x2 {
+	var z Uint64x2
+	return z.SetElem(0, x).Broadcast128()
+}
+
+// BroadcastFloat32x4 returns a vector with the input
+// x assigned to all elements of the output.
+//
+// Emulated, CPU Feature AVX2
+func BroadcastFloat32x4(x float32) Float32x4 {
+	var z Float32x4
+	return z.SetElem(0, x).Broadcast128()
+}
+
+// BroadcastFloat64x2 returns a vector with the input
+// x assigned to all elements of the output.
+//
+// Emulated, CPU Feature AVX2
+func BroadcastFloat64x2(x float64) Float64x2 {
+	var z Float64x2
+	return z.SetElem(0, x).Broadcast128()
+}
+
+// BroadcastInt8x32 returns a vector with the input
+// x assigned to all elements of the output.
+//
+// Emulated, CPU Feature AVX2
+func BroadcastInt8x32(x int8) Int8x32 {
+	var z Int8x16
+	return z.SetElem(0, x).Broadcast256()
+}
+
+// BroadcastInt16x16 returns a vector with the input
+// x assigned to all elements of the output.
+//
+// Emulated, CPU Feature AVX2
+func BroadcastInt16x16(x int16) Int16x16 {
+	var z Int16x8
+	return z.SetElem(0, x).Broadcast256()
+}
+
+// BroadcastInt32x8 returns a vector with the input
+// x assigned to all elements of the output.
+//
+// Emulated, CPU Feature AVX2
+func BroadcastInt32x8(x int32) Int32x8 {
+	var z Int32x4
+	return z.SetElem(0, x).Broadcast256()
+}
+
+// BroadcastInt64x4 returns a vector with the input
+// x assigned to all elements of the output.
+//
+// Emulated, CPU Feature AVX2
+func BroadcastInt64x4(x int64) Int64x4 {
+	var z Int64x2
+	return z.SetElem(0, x).Broadcast256()
+}
+
+// BroadcastUint8x32 returns a vector with the input
+// x assigned to all elements of the output.
+//
+// Emulated, CPU Feature AVX2
+func BroadcastUint8x32(x uint8) Uint8x32 {
+	var z Uint8x16
+	return z.SetElem(0, x).Broadcast256()
+}
+
+// BroadcastUint16x16 returns a vector with the input
+// x assigned to all elements of the output.
+//
+// Emulated, CPU Feature AVX2
+func BroadcastUint16x16(x uint16) Uint16x16 {
+	var z Uint16x8
+	return z.SetElem(0, x).Broadcast256()
+}
+
+// BroadcastUint32x8 returns a vector with the input
+// x assigned to all elements of the output.
+//
+// Emulated, CPU Feature AVX2
+func BroadcastUint32x8(x uint32) Uint32x8 {
+	var z Uint32x4
+	return z.SetElem(0, x).Broadcast256()
+}
+
+// BroadcastUint64x4 returns a vector with the input
+// x assigned to all elements of the output.
+//
+// Emulated, CPU Feature AVX2
+func BroadcastUint64x4(x uint64) Uint64x4 {
+	var z Uint64x2
+	return z.SetElem(0, x).Broadcast256()
+}
+
+// BroadcastFloat32x8 returns a vector with the input
+// x assigned to all elements of the output.
+//
+// Emulated, CPU Feature AVX2
+func BroadcastFloat32x8(x float32) Float32x8 {
+	var z Float32x4
+	return z.SetElem(0, x).Broadcast256()
+}
+
+// BroadcastFloat64x4 returns a vector with the input
+// x assigned to all elements of the output.
+//
+// Emulated, CPU Feature AVX2
+func BroadcastFloat64x4(x float64) Float64x4 {
+	var z Float64x2
+	return z.SetElem(0, x).Broadcast256()
+}
+
+// BroadcastInt8x64 returns a vector with the input
+// x assigned to all elements of the output.
+//
+// Emulated, CPU Feature AVX512BW
+func BroadcastInt8x64(x int8) Int8x64 {
+	var z Int8x16
+	return z.SetElem(0, x).Broadcast512()
+}
+
+// BroadcastInt16x32 returns a vector with the input
+// x assigned to all elements of the output.
+//
+// Emulated, CPU Feature AVX512BW
+func BroadcastInt16x32(x int16) Int16x32 {
+	var z Int16x8
+	return z.SetElem(0, x).Broadcast512()
+}
+
+// BroadcastInt32x16 returns a vector with the input
+// x assigned to all elements of the output.
+//
+// Emulated, CPU Feature AVX512F
+func BroadcastInt32x16(x int32) Int32x16 {
+	var z Int32x4
+	return z.SetElem(0, x).Broadcast512()
+}
+
+// BroadcastInt64x8 returns a vector with the input
+// x assigned to all elements of the output.
+//
+// Emulated, CPU Feature AVX512F
+func BroadcastInt64x8(x int64) Int64x8 {
+	var z Int64x2
+	return z.SetElem(0, x).Broadcast512()
+}
+
+// BroadcastUint8x64 returns a vector with the input
+// x assigned to all elements of the output.
+//
+// Emulated, CPU Feature AVX512BW
+func BroadcastUint8x64(x uint8) Uint8x64 {
+	var z Uint8x16
+	return z.SetElem(0, x).Broadcast512()
+}
+
+// BroadcastUint16x32 returns a vector with the input
+// x assigned to all elements of the output.
+//
+// Emulated, CPU Feature AVX512BW
+func BroadcastUint16x32(x uint16) Uint16x32 {
+	var z Uint16x8
+	return z.SetElem(0, x).Broadcast512()
+}
+
+// BroadcastUint32x16 returns a vector with the input
+// x assigned to all elements of the output.
+//
+// Emulated, CPU Feature AVX512F
+func BroadcastUint32x16(x uint32) Uint32x16 {
+	var z Uint32x4
+	return z.SetElem(0, x).Broadcast512()
+}
+
+// BroadcastUint64x8 returns a vector with the input
+// x assigned to all elements of the output.
+//
+// Emulated, CPU Feature AVX512F
+func BroadcastUint64x8(x uint64) Uint64x8 {
+	var z Uint64x2
+	return z.SetElem(0, x).Broadcast512()
+}
+
+// BroadcastFloat32x16 returns a vector with the input
+// x assigned to all elements of the output.
+//
+// Emulated, CPU Feature AVX512F
+func BroadcastFloat32x16(x float32) Float32x16 {
+	var z Float32x4
+	return z.SetElem(0, x).Broadcast512()
+}
+
+// BroadcastFloat64x8 returns a vector with the input
+// x assigned to all elements of the output.
+//
+// Emulated, CPU Feature AVX512F
+func BroadcastFloat64x8(x float64) Float64x8 {
+	var z Float64x2
+	return z.SetElem(0, x).Broadcast512()
+}