addF(simdPackage, "LoadMaskedMask64x8", simdMaskedLoad(ssa.OpLoadMasked64), sys.AMD64)
addF(simdPackage, "Mask64x8.StoreMasked", simdMaskedStore(ssa.OpStoreMasked64), sys.AMD64)
addF(simdPackage, "Mask8x16.AsInt8x16", func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value { return args[0] }, sys.AMD64)
- addF(simdPackage, "Int8x16.AsMask8x16", func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value { return args[0] }, sys.AMD64)
+ addF(simdPackage, "Int8x16.asMask", func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value { return args[0] }, sys.AMD64)
addF(simdPackage, "Mask8x16.And", opLen2(ssa.OpAndInt32x4, types.TypeVec128), sys.AMD64)
addF(simdPackage, "Mask8x16.Or", opLen2(ssa.OpOrInt32x4, types.TypeVec128), sys.AMD64)
addF(simdPackage, "LoadMask8x16FromBits", simdLoadMask(8, 16), sys.AMD64)
addF(simdPackage, "Mask8x16FromBits", simdCvtVToMask(8, 16), sys.AMD64)
addF(simdPackage, "Mask8x16.ToBits", simdCvtMaskToV(8, 16), sys.AMD64)
addF(simdPackage, "Mask8x32.AsInt8x32", func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value { return args[0] }, sys.AMD64)
- addF(simdPackage, "Int8x32.AsMask8x32", func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value { return args[0] }, sys.AMD64)
+ addF(simdPackage, "Int8x32.asMask", func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value { return args[0] }, sys.AMD64)
addF(simdPackage, "Mask8x32.And", opLen2(ssa.OpAndInt32x8, types.TypeVec256), sys.AMD64)
addF(simdPackage, "Mask8x32.Or", opLen2(ssa.OpOrInt32x8, types.TypeVec256), sys.AMD64)
addF(simdPackage, "LoadMask8x32FromBits", simdLoadMask(8, 32), sys.AMD64)
addF(simdPackage, "Mask8x32FromBits", simdCvtVToMask(8, 32), sys.AMD64)
addF(simdPackage, "Mask8x32.ToBits", simdCvtMaskToV(8, 32), sys.AMD64)
addF(simdPackage, "Mask8x64.AsInt8x64", func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value { return args[0] }, sys.AMD64)
- addF(simdPackage, "Int8x64.AsMask8x64", func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value { return args[0] }, sys.AMD64)
+ addF(simdPackage, "Int8x64.asMask", func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value { return args[0] }, sys.AMD64)
addF(simdPackage, "Mask8x64.And", opLen2(ssa.OpAndInt32x16, types.TypeVec512), sys.AMD64)
addF(simdPackage, "Mask8x64.Or", opLen2(ssa.OpOrInt32x16, types.TypeVec512), sys.AMD64)
addF(simdPackage, "LoadMask8x64FromBits", simdLoadMask(8, 64), sys.AMD64)
addF(simdPackage, "Mask8x64FromBits", simdCvtVToMask(8, 64), sys.AMD64)
addF(simdPackage, "Mask8x64.ToBits", simdCvtMaskToV(8, 64), sys.AMD64)
addF(simdPackage, "Mask16x8.AsInt16x8", func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value { return args[0] }, sys.AMD64)
- addF(simdPackage, "Int16x8.AsMask16x8", func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value { return args[0] }, sys.AMD64)
+ addF(simdPackage, "Int16x8.asMask", func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value { return args[0] }, sys.AMD64)
addF(simdPackage, "Mask16x8.And", opLen2(ssa.OpAndInt32x4, types.TypeVec128), sys.AMD64)
addF(simdPackage, "Mask16x8.Or", opLen2(ssa.OpOrInt32x4, types.TypeVec128), sys.AMD64)
addF(simdPackage, "LoadMask16x8FromBits", simdLoadMask(16, 8), sys.AMD64)
addF(simdPackage, "Mask16x8FromBits", simdCvtVToMask(16, 8), sys.AMD64)
addF(simdPackage, "Mask16x8.ToBits", simdCvtMaskToV(16, 8), sys.AMD64)
addF(simdPackage, "Mask16x16.AsInt16x16", func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value { return args[0] }, sys.AMD64)
- addF(simdPackage, "Int16x16.AsMask16x16", func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value { return args[0] }, sys.AMD64)
+ addF(simdPackage, "Int16x16.asMask", func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value { return args[0] }, sys.AMD64)
addF(simdPackage, "Mask16x16.And", opLen2(ssa.OpAndInt32x8, types.TypeVec256), sys.AMD64)
addF(simdPackage, "Mask16x16.Or", opLen2(ssa.OpOrInt32x8, types.TypeVec256), sys.AMD64)
addF(simdPackage, "LoadMask16x16FromBits", simdLoadMask(16, 16), sys.AMD64)
addF(simdPackage, "Mask16x16FromBits", simdCvtVToMask(16, 16), sys.AMD64)
addF(simdPackage, "Mask16x16.ToBits", simdCvtMaskToV(16, 16), sys.AMD64)
addF(simdPackage, "Mask16x32.AsInt16x32", func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value { return args[0] }, sys.AMD64)
- addF(simdPackage, "Int16x32.AsMask16x32", func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value { return args[0] }, sys.AMD64)
+ addF(simdPackage, "Int16x32.asMask", func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value { return args[0] }, sys.AMD64)
addF(simdPackage, "Mask16x32.And", opLen2(ssa.OpAndInt32x16, types.TypeVec512), sys.AMD64)
addF(simdPackage, "Mask16x32.Or", opLen2(ssa.OpOrInt32x16, types.TypeVec512), sys.AMD64)
addF(simdPackage, "LoadMask16x32FromBits", simdLoadMask(16, 32), sys.AMD64)
addF(simdPackage, "Mask16x32FromBits", simdCvtVToMask(16, 32), sys.AMD64)
addF(simdPackage, "Mask16x32.ToBits", simdCvtMaskToV(16, 32), sys.AMD64)
addF(simdPackage, "Mask32x4.AsInt32x4", func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value { return args[0] }, sys.AMD64)
- addF(simdPackage, "Int32x4.AsMask32x4", func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value { return args[0] }, sys.AMD64)
+ addF(simdPackage, "Int32x4.asMask", func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value { return args[0] }, sys.AMD64)
addF(simdPackage, "Mask32x4.And", opLen2(ssa.OpAndInt32x4, types.TypeVec128), sys.AMD64)
addF(simdPackage, "Mask32x4.Or", opLen2(ssa.OpOrInt32x4, types.TypeVec128), sys.AMD64)
addF(simdPackage, "LoadMask32x4FromBits", simdLoadMask(32, 4), sys.AMD64)
addF(simdPackage, "Mask32x4FromBits", simdCvtVToMask(32, 4), sys.AMD64)
addF(simdPackage, "Mask32x4.ToBits", simdCvtMaskToV(32, 4), sys.AMD64)
addF(simdPackage, "Mask32x8.AsInt32x8", func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value { return args[0] }, sys.AMD64)
- addF(simdPackage, "Int32x8.AsMask32x8", func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value { return args[0] }, sys.AMD64)
+ addF(simdPackage, "Int32x8.asMask", func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value { return args[0] }, sys.AMD64)
addF(simdPackage, "Mask32x8.And", opLen2(ssa.OpAndInt32x8, types.TypeVec256), sys.AMD64)
addF(simdPackage, "Mask32x8.Or", opLen2(ssa.OpOrInt32x8, types.TypeVec256), sys.AMD64)
addF(simdPackage, "LoadMask32x8FromBits", simdLoadMask(32, 8), sys.AMD64)
addF(simdPackage, "Mask32x8FromBits", simdCvtVToMask(32, 8), sys.AMD64)
addF(simdPackage, "Mask32x8.ToBits", simdCvtMaskToV(32, 8), sys.AMD64)
addF(simdPackage, "Mask32x16.AsInt32x16", func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value { return args[0] }, sys.AMD64)
- addF(simdPackage, "Int32x16.AsMask32x16", func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value { return args[0] }, sys.AMD64)
+ addF(simdPackage, "Int32x16.asMask", func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value { return args[0] }, sys.AMD64)
addF(simdPackage, "Mask32x16.And", opLen2(ssa.OpAndInt32x16, types.TypeVec512), sys.AMD64)
addF(simdPackage, "Mask32x16.Or", opLen2(ssa.OpOrInt32x16, types.TypeVec512), sys.AMD64)
addF(simdPackage, "LoadMask32x16FromBits", simdLoadMask(32, 16), sys.AMD64)
addF(simdPackage, "Mask32x16FromBits", simdCvtVToMask(32, 16), sys.AMD64)
addF(simdPackage, "Mask32x16.ToBits", simdCvtMaskToV(32, 16), sys.AMD64)
addF(simdPackage, "Mask64x2.AsInt64x2", func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value { return args[0] }, sys.AMD64)
- addF(simdPackage, "Int64x2.AsMask64x2", func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value { return args[0] }, sys.AMD64)
+ addF(simdPackage, "Int64x2.asMask", func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value { return args[0] }, sys.AMD64)
addF(simdPackage, "Mask64x2.And", opLen2(ssa.OpAndInt32x4, types.TypeVec128), sys.AMD64)
addF(simdPackage, "Mask64x2.Or", opLen2(ssa.OpOrInt32x4, types.TypeVec128), sys.AMD64)
addF(simdPackage, "LoadMask64x2FromBits", simdLoadMask(64, 2), sys.AMD64)
addF(simdPackage, "Mask64x2FromBits", simdCvtVToMask(64, 2), sys.AMD64)
addF(simdPackage, "Mask64x2.ToBits", simdCvtMaskToV(64, 2), sys.AMD64)
addF(simdPackage, "Mask64x4.AsInt64x4", func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value { return args[0] }, sys.AMD64)
- addF(simdPackage, "Int64x4.AsMask64x4", func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value { return args[0] }, sys.AMD64)
+ addF(simdPackage, "Int64x4.asMask", func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value { return args[0] }, sys.AMD64)
addF(simdPackage, "Mask64x4.And", opLen2(ssa.OpAndInt32x8, types.TypeVec256), sys.AMD64)
addF(simdPackage, "Mask64x4.Or", opLen2(ssa.OpOrInt32x8, types.TypeVec256), sys.AMD64)
addF(simdPackage, "LoadMask64x4FromBits", simdLoadMask(64, 4), sys.AMD64)
addF(simdPackage, "Mask64x4FromBits", simdCvtVToMask(64, 4), sys.AMD64)
addF(simdPackage, "Mask64x4.ToBits", simdCvtMaskToV(64, 4), sys.AMD64)
addF(simdPackage, "Mask64x8.AsInt64x8", func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value { return args[0] }, sys.AMD64)
- addF(simdPackage, "Int64x8.AsMask64x8", func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value { return args[0] }, sys.AMD64)
+ addF(simdPackage, "Int64x8.asMask", func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value { return args[0] }, sys.AMD64)
addF(simdPackage, "Mask64x8.And", opLen2(ssa.OpAndInt32x16, types.TypeVec512), sys.AMD64)
addF(simdPackage, "Mask64x8.Or", opLen2(ssa.OpOrInt32x16, types.TypeVec512), sys.AMD64)
addF(simdPackage, "LoadMask64x8FromBits", simdLoadMask(64, 8), sys.AMD64)
{{end}}
{{define "mask"}} addF(simdPackage, "{{.Name}}.As{{.VectorCounterpart}}", func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value { return args[0] }, sys.AMD64)
- addF(simdPackage, "{{.VectorCounterpart}}.As{{.Name}}", func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value { return args[0] }, sys.AMD64)
+ addF(simdPackage, "{{.VectorCounterpart}}.asMask", func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value { return args[0] }, sys.AMD64)
addF(simdPackage, "{{.Name}}.And", opLen2(ssa.OpAnd{{.ReshapedVectorWithAndOr}}, types.TypeVec{{.Size}}), sys.AMD64)
addF(simdPackage, "{{.Name}}.Or", opLen2(ssa.OpOr{{.ReshapedVectorWithAndOr}}, types.TypeVec{{.Size}}), sys.AMD64)
addF(simdPackage, "Load{{.Name}}FromBits", simdLoadMask({{.ElemBits}}, {{.Lanes}}), sys.AMD64)
{{end}}
{{define "mask"}}
-// converts from {{.Name}} to {{.VectorCounterpart}}
+// As{{.VectorCounterpart}} converts from {{.Name}} to {{.VectorCounterpart}}
func (from {{.Name}}) As{{.VectorCounterpart}}() (to {{.VectorCounterpart}})
-// converts from {{.VectorCounterpart}} to {{.Name}}
-func (from {{.VectorCounterpart}}) As{{.Name}}() (to {{.Name}})
+// asMask converts from {{.VectorCounterpart}} to {{.Name}}
+func (from {{.VectorCounterpart}}) asMask() (to {{.Name}})
func (x {{.Name}}) And(y {{.Name}}) {{.Name}}
// Emulated, CPU Feature AVX
func (x Int8x16) GreaterEqual(y Int8x16) Mask8x16 {
ones := x.Equal(x).AsInt8x16()
- return y.Greater(x).AsInt8x16().Xor(ones).AsMask8x16()
+ return y.Greater(x).AsInt8x16().Xor(ones).asMask()
}
// 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()
+ return x.Greater(y).AsInt8x16().Xor(ones).asMask()
}
// 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()
+ return x.Equal(y).AsInt8x16().Xor(ones).asMask()
}
// Less 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()
+ return y.Greater(x).AsInt16x8().Xor(ones).asMask()
}
// 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()
+ return x.Greater(y).AsInt16x8().Xor(ones).asMask()
}
// 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()
+ return x.Equal(y).AsInt16x8().Xor(ones).asMask()
}
// Less 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()
+ return y.Greater(x).AsInt32x4().Xor(ones).asMask()
}
// 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()
+ return x.Greater(y).AsInt32x4().Xor(ones).asMask()
}
// 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()
+ return x.Equal(y).AsInt32x4().Xor(ones).asMask()
}
// Less 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()
+ return y.Greater(x).AsInt64x2().Xor(ones).asMask()
}
// 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()
+ return x.Greater(y).AsInt64x2().Xor(ones).asMask()
}
// 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()
+ return x.Equal(y).AsInt64x2().Xor(ones).asMask()
}
// Less 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()
+ return y.Greater(x).AsInt8x32().Xor(ones).asMask()
}
// 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()
+ return x.Greater(y).AsInt8x32().Xor(ones).asMask()
}
// 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()
+ return x.Equal(y).AsInt8x32().Xor(ones).asMask()
}
// Less 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()
+ return y.Greater(x).AsInt16x16().Xor(ones).asMask()
}
// 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()
+ return x.Greater(y).AsInt16x16().Xor(ones).asMask()
}
// 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()
+ return x.Equal(y).AsInt16x16().Xor(ones).asMask()
}
// Less 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()
+ return y.Greater(x).AsInt32x8().Xor(ones).asMask()
}
// 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()
+ return x.Greater(y).AsInt32x8().Xor(ones).asMask()
}
// 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()
+ return x.Equal(y).AsInt32x8().Xor(ones).asMask()
}
// Less 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()
+ return y.Greater(x).AsInt64x4().Xor(ones).asMask()
}
// 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()
+ return x.Greater(y).AsInt64x4().Xor(ones).asMask()
}
// 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()
+ return x.Equal(y).AsInt64x4().Xor(ones).asMask()
}
// Greater returns a mask whose elements indicate whether x > y
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()
+ return b.Xor(signs).Greater(a.Xor(signs)).AsInt8x16().Xor(ones).asMask()
}
// LessEqual returns a mask whose elements indicate whether x <= y
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()
+ return a.Xor(signs).Greater(b.Xor(signs)).AsInt8x16().Xor(ones).asMask()
}
// NotEqual returns a mask whose elements indicate whether x != y
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()
+ return a.Equal(b).AsInt8x16().Xor(ones).asMask()
}
// Greater returns a mask whose elements indicate whether x > y
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()
+ return b.Xor(signs).Greater(a.Xor(signs)).AsInt16x8().Xor(ones).asMask()
}
// LessEqual returns a mask whose elements indicate whether x <= y
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()
+ return a.Xor(signs).Greater(b.Xor(signs)).AsInt16x8().Xor(ones).asMask()
}
// NotEqual returns a mask whose elements indicate whether x != y
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()
+ return a.Equal(b).AsInt16x8().Xor(ones).asMask()
}
// Greater returns a mask whose elements indicate whether x > y
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()
+ return b.Xor(signs).Greater(a.Xor(signs)).AsInt32x4().Xor(ones).asMask()
}
// LessEqual returns a mask whose elements indicate whether x <= y
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()
+ return a.Xor(signs).Greater(b.Xor(signs)).AsInt32x4().Xor(ones).asMask()
}
// NotEqual returns a mask whose elements indicate whether x != y
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()
+ return a.Equal(b).AsInt32x4().Xor(ones).asMask()
}
// Greater returns a mask whose elements indicate whether x > y
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()
+ return b.Xor(signs).Greater(a.Xor(signs)).AsInt64x2().Xor(ones).asMask()
}
// LessEqual returns a mask whose elements indicate whether x <= y
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()
+ return a.Xor(signs).Greater(b.Xor(signs)).AsInt64x2().Xor(ones).asMask()
}
// NotEqual returns a mask whose elements indicate whether x != y
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()
+ return a.Equal(b).AsInt64x2().Xor(ones).asMask()
}
// Greater returns a mask whose elements indicate whether x > y
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()
+ return b.Xor(signs).Greater(a.Xor(signs)).AsInt8x32().Xor(ones).asMask()
}
// LessEqual returns a mask whose elements indicate whether x <= y
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()
+ return a.Xor(signs).Greater(b.Xor(signs)).AsInt8x32().Xor(ones).asMask()
}
// NotEqual returns a mask whose elements indicate whether x != y
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()
+ return a.Equal(b).AsInt8x32().Xor(ones).asMask()
}
// Greater returns a mask whose elements indicate whether x > y
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()
+ return b.Xor(signs).Greater(a.Xor(signs)).AsInt16x16().Xor(ones).asMask()
}
// LessEqual returns a mask whose elements indicate whether x <= y
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()
+ return a.Xor(signs).Greater(b.Xor(signs)).AsInt16x16().Xor(ones).asMask()
}
// NotEqual returns a mask whose elements indicate whether x != y
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()
+ return a.Equal(b).AsInt16x16().Xor(ones).asMask()
}
// Greater returns a mask whose elements indicate whether x > y
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()
+ return b.Xor(signs).Greater(a.Xor(signs)).AsInt32x8().Xor(ones).asMask()
}
// LessEqual returns a mask whose elements indicate whether x <= y
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()
+ return a.Xor(signs).Greater(b.Xor(signs)).AsInt32x8().Xor(ones).asMask()
}
// NotEqual returns a mask whose elements indicate whether x != y
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()
+ return a.Equal(b).AsInt32x8().Xor(ones).asMask()
}
// Greater returns a mask whose elements indicate whether x > y
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()
+ return b.Xor(signs).Greater(a.Xor(signs)).AsInt64x4().Xor(ones).asMask()
}
// LessEqual returns a mask whose elements indicate whether x <= y
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()
+ return a.Xor(signs).Greater(b.Xor(signs)).AsInt64x4().Xor(ones).asMask()
}
// NotEqual returns a mask whose elements indicate whether x != y
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()
+ return a.Equal(b).AsInt64x4().Xor(ones).asMask()
}
t.Helper()
a := simd.LoadInt8x16Slice(x)
b := simd.LoadInt8x16Slice(y)
- k := simd.LoadInt8x16Slice(toVect[int8](m)).AsMask8x16()
+ k := simd.LoadInt8x16Slice(toVect[int8](m)).ToMask()
g := make([]int8, n)
f(a, b, k).AsInt8x16().StoreSlice(g)
w := want(x, y)
t.Helper()
a := simd.LoadInt16x8Slice(x)
b := simd.LoadInt16x8Slice(y)
- k := simd.LoadInt16x8Slice(toVect[int16](m)).AsMask16x8()
+ k := simd.LoadInt16x8Slice(toVect[int16](m)).ToMask()
g := make([]int16, n)
f(a, b, k).AsInt16x8().StoreSlice(g)
w := want(x, y)
t.Helper()
a := simd.LoadInt32x4Slice(x)
b := simd.LoadInt32x4Slice(y)
- k := simd.LoadInt32x4Slice(toVect[int32](m)).AsMask32x4()
+ k := simd.LoadInt32x4Slice(toVect[int32](m)).ToMask()
g := make([]int32, n)
f(a, b, k).AsInt32x4().StoreSlice(g)
w := want(x, y)
t.Helper()
a := simd.LoadInt64x2Slice(x)
b := simd.LoadInt64x2Slice(y)
- k := simd.LoadInt64x2Slice(toVect[int64](m)).AsMask64x2()
+ k := simd.LoadInt64x2Slice(toVect[int64](m)).ToMask()
g := make([]int64, n)
f(a, b, k).AsInt64x2().StoreSlice(g)
w := want(x, y)
t.Helper()
a := simd.LoadUint8x16Slice(x)
b := simd.LoadUint8x16Slice(y)
- k := simd.LoadInt8x16Slice(toVect[int8](m)).AsMask8x16()
+ k := simd.LoadInt8x16Slice(toVect[int8](m)).ToMask()
g := make([]int8, n)
f(a, b, k).AsInt8x16().StoreSlice(g)
w := want(x, y)
t.Helper()
a := simd.LoadUint16x8Slice(x)
b := simd.LoadUint16x8Slice(y)
- k := simd.LoadInt16x8Slice(toVect[int16](m)).AsMask16x8()
+ k := simd.LoadInt16x8Slice(toVect[int16](m)).ToMask()
g := make([]int16, n)
f(a, b, k).AsInt16x8().StoreSlice(g)
w := want(x, y)
t.Helper()
a := simd.LoadUint32x4Slice(x)
b := simd.LoadUint32x4Slice(y)
- k := simd.LoadInt32x4Slice(toVect[int32](m)).AsMask32x4()
+ k := simd.LoadInt32x4Slice(toVect[int32](m)).ToMask()
g := make([]int32, n)
f(a, b, k).AsInt32x4().StoreSlice(g)
w := want(x, y)
t.Helper()
a := simd.LoadUint64x2Slice(x)
b := simd.LoadUint64x2Slice(y)
- k := simd.LoadInt64x2Slice(toVect[int64](m)).AsMask64x2()
+ k := simd.LoadInt64x2Slice(toVect[int64](m)).ToMask()
g := make([]int64, n)
f(a, b, k).AsInt64x2().StoreSlice(g)
w := want(x, y)
t.Helper()
a := simd.LoadFloat32x4Slice(x)
b := simd.LoadFloat32x4Slice(y)
- k := simd.LoadInt32x4Slice(toVect[int32](m)).AsMask32x4()
+ k := simd.LoadInt32x4Slice(toVect[int32](m)).ToMask()
g := make([]int32, n)
f(a, b, k).AsInt32x4().StoreSlice(g)
w := want(x, y)
t.Helper()
a := simd.LoadFloat64x2Slice(x)
b := simd.LoadFloat64x2Slice(y)
- k := simd.LoadInt64x2Slice(toVect[int64](m)).AsMask64x2()
+ k := simd.LoadInt64x2Slice(toVect[int64](m)).ToMask()
g := make([]int64, n)
f(a, b, k).AsInt64x2().StoreSlice(g)
w := want(x, y)
t.Helper()
a := simd.LoadInt8x32Slice(x)
b := simd.LoadInt8x32Slice(y)
- k := simd.LoadInt8x32Slice(toVect[int8](m)).AsMask8x32()
+ k := simd.LoadInt8x32Slice(toVect[int8](m)).ToMask()
g := make([]int8, n)
f(a, b, k).AsInt8x32().StoreSlice(g)
w := want(x, y)
t.Helper()
a := simd.LoadInt16x16Slice(x)
b := simd.LoadInt16x16Slice(y)
- k := simd.LoadInt16x16Slice(toVect[int16](m)).AsMask16x16()
+ k := simd.LoadInt16x16Slice(toVect[int16](m)).ToMask()
g := make([]int16, n)
f(a, b, k).AsInt16x16().StoreSlice(g)
w := want(x, y)
t.Helper()
a := simd.LoadInt32x8Slice(x)
b := simd.LoadInt32x8Slice(y)
- k := simd.LoadInt32x8Slice(toVect[int32](m)).AsMask32x8()
+ k := simd.LoadInt32x8Slice(toVect[int32](m)).ToMask()
g := make([]int32, n)
f(a, b, k).AsInt32x8().StoreSlice(g)
w := want(x, y)
t.Helper()
a := simd.LoadInt64x4Slice(x)
b := simd.LoadInt64x4Slice(y)
- k := simd.LoadInt64x4Slice(toVect[int64](m)).AsMask64x4()
+ k := simd.LoadInt64x4Slice(toVect[int64](m)).ToMask()
g := make([]int64, n)
f(a, b, k).AsInt64x4().StoreSlice(g)
w := want(x, y)
t.Helper()
a := simd.LoadUint8x32Slice(x)
b := simd.LoadUint8x32Slice(y)
- k := simd.LoadInt8x32Slice(toVect[int8](m)).AsMask8x32()
+ k := simd.LoadInt8x32Slice(toVect[int8](m)).ToMask()
g := make([]int8, n)
f(a, b, k).AsInt8x32().StoreSlice(g)
w := want(x, y)
t.Helper()
a := simd.LoadUint16x16Slice(x)
b := simd.LoadUint16x16Slice(y)
- k := simd.LoadInt16x16Slice(toVect[int16](m)).AsMask16x16()
+ k := simd.LoadInt16x16Slice(toVect[int16](m)).ToMask()
g := make([]int16, n)
f(a, b, k).AsInt16x16().StoreSlice(g)
w := want(x, y)
t.Helper()
a := simd.LoadUint32x8Slice(x)
b := simd.LoadUint32x8Slice(y)
- k := simd.LoadInt32x8Slice(toVect[int32](m)).AsMask32x8()
+ k := simd.LoadInt32x8Slice(toVect[int32](m)).ToMask()
g := make([]int32, n)
f(a, b, k).AsInt32x8().StoreSlice(g)
w := want(x, y)
t.Helper()
a := simd.LoadUint64x4Slice(x)
b := simd.LoadUint64x4Slice(y)
- k := simd.LoadInt64x4Slice(toVect[int64](m)).AsMask64x4()
+ k := simd.LoadInt64x4Slice(toVect[int64](m)).ToMask()
g := make([]int64, n)
f(a, b, k).AsInt64x4().StoreSlice(g)
w := want(x, y)
t.Helper()
a := simd.LoadFloat32x8Slice(x)
b := simd.LoadFloat32x8Slice(y)
- k := simd.LoadInt32x8Slice(toVect[int32](m)).AsMask32x8()
+ k := simd.LoadInt32x8Slice(toVect[int32](m)).ToMask()
g := make([]int32, n)
f(a, b, k).AsInt32x8().StoreSlice(g)
w := want(x, y)
t.Helper()
a := simd.LoadFloat64x4Slice(x)
b := simd.LoadFloat64x4Slice(y)
- k := simd.LoadInt64x4Slice(toVect[int64](m)).AsMask64x4()
+ k := simd.LoadInt64x4Slice(toVect[int64](m)).ToMask()
g := make([]int64, n)
f(a, b, k).AsInt64x4().StoreSlice(g)
w := want(x, y)
t.Helper()
a := simd.LoadInt8x64Slice(x)
b := simd.LoadInt8x64Slice(y)
- k := simd.LoadInt8x64Slice(toVect[int8](m)).AsMask8x64()
+ k := simd.LoadInt8x64Slice(toVect[int8](m)).ToMask()
g := make([]int8, n)
f(a, b, k).AsInt8x64().StoreSlice(g)
w := want(x, y)
t.Helper()
a := simd.LoadInt16x32Slice(x)
b := simd.LoadInt16x32Slice(y)
- k := simd.LoadInt16x32Slice(toVect[int16](m)).AsMask16x32()
+ k := simd.LoadInt16x32Slice(toVect[int16](m)).ToMask()
g := make([]int16, n)
f(a, b, k).AsInt16x32().StoreSlice(g)
w := want(x, y)
t.Helper()
a := simd.LoadInt32x16Slice(x)
b := simd.LoadInt32x16Slice(y)
- k := simd.LoadInt32x16Slice(toVect[int32](m)).AsMask32x16()
+ k := simd.LoadInt32x16Slice(toVect[int32](m)).ToMask()
g := make([]int32, n)
f(a, b, k).AsInt32x16().StoreSlice(g)
w := want(x, y)
t.Helper()
a := simd.LoadInt64x8Slice(x)
b := simd.LoadInt64x8Slice(y)
- k := simd.LoadInt64x8Slice(toVect[int64](m)).AsMask64x8()
+ k := simd.LoadInt64x8Slice(toVect[int64](m)).ToMask()
g := make([]int64, n)
f(a, b, k).AsInt64x8().StoreSlice(g)
w := want(x, y)
t.Helper()
a := simd.LoadUint8x64Slice(x)
b := simd.LoadUint8x64Slice(y)
- k := simd.LoadInt8x64Slice(toVect[int8](m)).AsMask8x64()
+ k := simd.LoadInt8x64Slice(toVect[int8](m)).ToMask()
g := make([]int8, n)
f(a, b, k).AsInt8x64().StoreSlice(g)
w := want(x, y)
t.Helper()
a := simd.LoadUint16x32Slice(x)
b := simd.LoadUint16x32Slice(y)
- k := simd.LoadInt16x32Slice(toVect[int16](m)).AsMask16x32()
+ k := simd.LoadInt16x32Slice(toVect[int16](m)).ToMask()
g := make([]int16, n)
f(a, b, k).AsInt16x32().StoreSlice(g)
w := want(x, y)
t.Helper()
a := simd.LoadUint32x16Slice(x)
b := simd.LoadUint32x16Slice(y)
- k := simd.LoadInt32x16Slice(toVect[int32](m)).AsMask32x16()
+ k := simd.LoadInt32x16Slice(toVect[int32](m)).ToMask()
g := make([]int32, n)
f(a, b, k).AsInt32x16().StoreSlice(g)
w := want(x, y)
t.Helper()
a := simd.LoadUint64x8Slice(x)
b := simd.LoadUint64x8Slice(y)
- k := simd.LoadInt64x8Slice(toVect[int64](m)).AsMask64x8()
+ k := simd.LoadInt64x8Slice(toVect[int64](m)).ToMask()
g := make([]int64, n)
f(a, b, k).AsInt64x8().StoreSlice(g)
w := want(x, y)
t.Helper()
a := simd.LoadFloat32x16Slice(x)
b := simd.LoadFloat32x16Slice(y)
- k := simd.LoadInt32x16Slice(toVect[int32](m)).AsMask32x16()
+ k := simd.LoadInt32x16Slice(toVect[int32](m)).ToMask()
g := make([]int32, n)
f(a, b, k).AsInt32x16().StoreSlice(g)
w := want(x, y)
t.Helper()
a := simd.LoadFloat64x8Slice(x)
b := simd.LoadFloat64x8Slice(y)
- k := simd.LoadInt64x8Slice(toVect[int64](m)).AsMask64x8()
+ k := simd.LoadInt64x8Slice(toVect[int64](m)).ToMask()
g := make([]int64, n)
f(a, b, k).AsInt64x8().StoreSlice(g)
w := want(x, y)
t.Helper()
a := simd.Load{{.Vec}}Slice(x)
b := simd.Load{{.Vec}}Slice(y)
- k := simd.LoadInt{{.WxC}}Slice(toVect[int{{.Width}}](m)).AsMask{{.WxC}}()
+ k := simd.LoadInt{{.WxC}}Slice(toVect[int{{.Width}}](m)).ToMask()
g := make([]int{{.Width}}, n)
f(a, b, k).AsInt{{.WxC}}().StoreSlice(g)
w := want(x, y)
return x
}
mask := vecMask{{.Width}}[len(vecMask{{.Width}})/2-l:]
- return LoadMasked{{.Vec}}(pa{{.Vec}}(s), LoadInt{{.WxC}}Slice(mask).AsMask{{.WxC}}())
+ return LoadMasked{{.Vec}}(pa{{.Vec}}(s), LoadInt{{.WxC}}Slice(mask).asMask())
}
// StoreSlicePart stores the {{.Count}} elements of x into the slice s.
return
}
mask := vecMask{{.Width}}[len(vecMask{{.Width}})/2-l:]
- x.StoreMasked(pa{{.Vec}}(s), LoadInt{{.WxC}}Slice(mask).AsMask{{.WxC}}())
+ x.StoreMasked(pa{{.Vec}}(s), LoadInt{{.WxC}}Slice(mask).asMask())
}
`)
// Emulated, CPU Feature {{.CPUfeature}}
func (x {{.Vec}}) GreaterEqual(y {{.Vec}}) Mask{{.WxC}} {
ones := x.Equal(x).AsInt{{.WxC}}()
- return y.Greater(x).AsInt{{.WxC}}().Xor(ones).AsMask{{.WxC}}()
+ return y.Greater(x).AsInt{{.WxC}}().Xor(ones).asMask()
}
// LessEqual returns a mask whose elements indicate whether x <= y
// Emulated, CPU Feature {{.CPUfeature}}
func (x {{.Vec}}) LessEqual(y {{.Vec}}) Mask{{.WxC}} {
ones := x.Equal(x).AsInt{{.WxC}}()
- return x.Greater(y).AsInt{{.WxC}}().Xor(ones).AsMask{{.WxC}}()
+ return x.Greater(y).AsInt{{.WxC}}().Xor(ones).asMask()
}
// NotEqual returns a mask whose elements indicate whether x != y
// Emulated, CPU Feature {{.CPUfeature}}
func (x {{.Vec}}) NotEqual(y {{.Vec}}) Mask{{.WxC}} {
ones := x.Equal(x).AsInt{{.WxC}}()
- return x.Equal(y).AsInt{{.WxC}}().Xor(ones).AsMask{{.WxC}}()
+ return x.Equal(y).AsInt{{.WxC}}().Xor(ones).asMask()
}
`)
{{- else}}
signs := ones.ShiftAllLeft({{.Width}}-1)
{{- end }}
- return b.Xor(signs).Greater(a.Xor(signs)).AsInt{{.WxC}}().Xor(ones).AsMask{{.WxC}}()
+ return b.Xor(signs).Greater(a.Xor(signs)).AsInt{{.WxC}}().Xor(ones).asMask()
}
// LessEqual returns a mask whose elements indicate whether x <= y
{{- else}}
signs := ones.ShiftAllLeft({{.Width}}-1)
{{- end }}
- return a.Xor(signs).Greater(b.Xor(signs)).AsInt{{.WxC}}().Xor(ones).AsMask{{.WxC}}()
+ return a.Xor(signs).Greater(b.Xor(signs)).AsInt{{.WxC}}().Xor(ones).asMask()
}
// NotEqual returns a mask whose elements indicate whether x != y
func (x {{.Vec}}) NotEqual(y {{.Vec}}) Mask{{.WxC}} {
a, b := x.AsInt{{.WxC}}(), y.AsInt{{.WxC}}()
ones := x.Equal(x).AsInt{{.WxC}}()
- return a.Equal(b).AsInt{{.WxC}}().Xor(ones).AsMask{{.WxC}}()
+ return a.Equal(b).AsInt{{.WxC}}().Xor(ones).asMask()
}
`)
}
`)
+var maskCvtTemplate = templateOf("Mask conversions", `
+// ToMask converts from {{.Base}}{{.WxC}} to Mask{{.WxC}}, mask element is set to true when the corresponding vector element is non-zero.
+func (from {{.Base}}{{.WxC}}) ToMask() (to Mask{{.WxC}}) {
+ return from.NotEqual({{.Base}}{{.WxC}}{})
+}
+`)
+
func main() {
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")
if *op != "" {
one(*op, prologue,
broadcastTemplate,
+ maskCvtTemplate,
)
}
if *ush != "" {
// Uint32x16 converts from Uint64x8 to Uint32x16
func (from Uint64x8) AsUint32x16() (to Uint32x16)
-// converts from Mask8x16 to Int8x16
+// AsInt8x16 converts from Mask8x16 to Int8x16
func (from Mask8x16) AsInt8x16() (to Int8x16)
-// converts from Int8x16 to Mask8x16
-func (from Int8x16) AsMask8x16() (to Mask8x16)
+// asMask converts from Int8x16 to Mask8x16
+func (from Int8x16) asMask() (to Mask8x16)
func (x Mask8x16) And(y Mask8x16) Mask8x16
func (x Mask8x16) Or(y Mask8x16) Mask8x16
-// converts from Mask8x32 to Int8x32
+// AsInt8x32 converts from Mask8x32 to Int8x32
func (from Mask8x32) AsInt8x32() (to Int8x32)
-// converts from Int8x32 to Mask8x32
-func (from Int8x32) AsMask8x32() (to Mask8x32)
+// asMask converts from Int8x32 to Mask8x32
+func (from Int8x32) asMask() (to Mask8x32)
func (x Mask8x32) And(y Mask8x32) Mask8x32
func (x Mask8x32) Or(y Mask8x32) Mask8x32
-// converts from Mask8x64 to Int8x64
+// AsInt8x64 converts from Mask8x64 to Int8x64
func (from Mask8x64) AsInt8x64() (to Int8x64)
-// converts from Int8x64 to Mask8x64
-func (from Int8x64) AsMask8x64() (to Mask8x64)
+// asMask converts from Int8x64 to Mask8x64
+func (from Int8x64) asMask() (to Mask8x64)
func (x Mask8x64) And(y Mask8x64) Mask8x64
func (x Mask8x64) Or(y Mask8x64) Mask8x64
-// converts from Mask16x8 to Int16x8
+// AsInt16x8 converts from Mask16x8 to Int16x8
func (from Mask16x8) AsInt16x8() (to Int16x8)
-// converts from Int16x8 to Mask16x8
-func (from Int16x8) AsMask16x8() (to Mask16x8)
+// asMask converts from Int16x8 to Mask16x8
+func (from Int16x8) asMask() (to Mask16x8)
func (x Mask16x8) And(y Mask16x8) Mask16x8
func (x Mask16x8) Or(y Mask16x8) Mask16x8
-// converts from Mask16x16 to Int16x16
+// AsInt16x16 converts from Mask16x16 to Int16x16
func (from Mask16x16) AsInt16x16() (to Int16x16)
-// converts from Int16x16 to Mask16x16
-func (from Int16x16) AsMask16x16() (to Mask16x16)
+// asMask converts from Int16x16 to Mask16x16
+func (from Int16x16) asMask() (to Mask16x16)
func (x Mask16x16) And(y Mask16x16) Mask16x16
func (x Mask16x16) Or(y Mask16x16) Mask16x16
-// converts from Mask16x32 to Int16x32
+// AsInt16x32 converts from Mask16x32 to Int16x32
func (from Mask16x32) AsInt16x32() (to Int16x32)
-// converts from Int16x32 to Mask16x32
-func (from Int16x32) AsMask16x32() (to Mask16x32)
+// asMask converts from Int16x32 to Mask16x32
+func (from Int16x32) asMask() (to Mask16x32)
func (x Mask16x32) And(y Mask16x32) Mask16x32
func (x Mask16x32) Or(y Mask16x32) Mask16x32
-// converts from Mask32x4 to Int32x4
+// AsInt32x4 converts from Mask32x4 to Int32x4
func (from Mask32x4) AsInt32x4() (to Int32x4)
-// converts from Int32x4 to Mask32x4
-func (from Int32x4) AsMask32x4() (to Mask32x4)
+// asMask converts from Int32x4 to Mask32x4
+func (from Int32x4) asMask() (to Mask32x4)
func (x Mask32x4) And(y Mask32x4) Mask32x4
func (x Mask32x4) Or(y Mask32x4) Mask32x4
-// converts from Mask32x8 to Int32x8
+// AsInt32x8 converts from Mask32x8 to Int32x8
func (from Mask32x8) AsInt32x8() (to Int32x8)
-// converts from Int32x8 to Mask32x8
-func (from Int32x8) AsMask32x8() (to Mask32x8)
+// asMask converts from Int32x8 to Mask32x8
+func (from Int32x8) asMask() (to Mask32x8)
func (x Mask32x8) And(y Mask32x8) Mask32x8
func (x Mask32x8) Or(y Mask32x8) Mask32x8
-// converts from Mask32x16 to Int32x16
+// AsInt32x16 converts from Mask32x16 to Int32x16
func (from Mask32x16) AsInt32x16() (to Int32x16)
-// converts from Int32x16 to Mask32x16
-func (from Int32x16) AsMask32x16() (to Mask32x16)
+// asMask converts from Int32x16 to Mask32x16
+func (from Int32x16) asMask() (to Mask32x16)
func (x Mask32x16) And(y Mask32x16) Mask32x16
func (x Mask32x16) Or(y Mask32x16) Mask32x16
-// converts from Mask64x2 to Int64x2
+// AsInt64x2 converts from Mask64x2 to Int64x2
func (from Mask64x2) AsInt64x2() (to Int64x2)
-// converts from Int64x2 to Mask64x2
-func (from Int64x2) AsMask64x2() (to Mask64x2)
+// asMask converts from Int64x2 to Mask64x2
+func (from Int64x2) asMask() (to Mask64x2)
func (x Mask64x2) And(y Mask64x2) Mask64x2
func (x Mask64x2) Or(y Mask64x2) Mask64x2
-// converts from Mask64x4 to Int64x4
+// AsInt64x4 converts from Mask64x4 to Int64x4
func (from Mask64x4) AsInt64x4() (to Int64x4)
-// converts from Int64x4 to Mask64x4
-func (from Int64x4) AsMask64x4() (to Mask64x4)
+// asMask converts from Int64x4 to Mask64x4
+func (from Int64x4) asMask() (to Mask64x4)
func (x Mask64x4) And(y Mask64x4) Mask64x4
func (x Mask64x4) Or(y Mask64x4) Mask64x4
-// converts from Mask64x8 to Int64x8
+// AsInt64x8 converts from Mask64x8 to Int64x8
func (from Mask64x8) AsInt64x8() (to Int64x8)
-// converts from Int64x8 to Mask64x8
-func (from Int64x8) AsMask64x8() (to Mask64x8)
+// asMask converts from Int64x8 to Mask64x8
+func (from Int64x8) asMask() (to Mask64x8)
func (x Mask64x8) And(y Mask64x8) Mask64x8
var z Float64x2
return z.SetElem(0, x).Broadcast512()
}
+
+// ToMask converts from Int8x16 to Mask8x16, mask element is set to true when the corresponding vector element is non-zero.
+func (from Int8x16) ToMask() (to Mask8x16) {
+ return from.NotEqual(Int8x16{})
+}
+
+// ToMask converts from Int16x8 to Mask16x8, mask element is set to true when the corresponding vector element is non-zero.
+func (from Int16x8) ToMask() (to Mask16x8) {
+ return from.NotEqual(Int16x8{})
+}
+
+// ToMask converts from Int32x4 to Mask32x4, mask element is set to true when the corresponding vector element is non-zero.
+func (from Int32x4) ToMask() (to Mask32x4) {
+ return from.NotEqual(Int32x4{})
+}
+
+// ToMask converts from Int64x2 to Mask64x2, mask element is set to true when the corresponding vector element is non-zero.
+func (from Int64x2) ToMask() (to Mask64x2) {
+ return from.NotEqual(Int64x2{})
+}
+
+// ToMask converts from Uint8x16 to Mask8x16, mask element is set to true when the corresponding vector element is non-zero.
+func (from Uint8x16) ToMask() (to Mask8x16) {
+ return from.NotEqual(Uint8x16{})
+}
+
+// ToMask converts from Uint16x8 to Mask16x8, mask element is set to true when the corresponding vector element is non-zero.
+func (from Uint16x8) ToMask() (to Mask16x8) {
+ return from.NotEqual(Uint16x8{})
+}
+
+// ToMask converts from Uint32x4 to Mask32x4, mask element is set to true when the corresponding vector element is non-zero.
+func (from Uint32x4) ToMask() (to Mask32x4) {
+ return from.NotEqual(Uint32x4{})
+}
+
+// ToMask converts from Uint64x2 to Mask64x2, mask element is set to true when the corresponding vector element is non-zero.
+func (from Uint64x2) ToMask() (to Mask64x2) {
+ return from.NotEqual(Uint64x2{})
+}
+
+// ToMask converts from Float32x4 to Mask32x4, mask element is set to true when the corresponding vector element is non-zero.
+func (from Float32x4) ToMask() (to Mask32x4) {
+ return from.NotEqual(Float32x4{})
+}
+
+// ToMask converts from Float64x2 to Mask64x2, mask element is set to true when the corresponding vector element is non-zero.
+func (from Float64x2) ToMask() (to Mask64x2) {
+ return from.NotEqual(Float64x2{})
+}
+
+// ToMask converts from Int8x32 to Mask8x32, mask element is set to true when the corresponding vector element is non-zero.
+func (from Int8x32) ToMask() (to Mask8x32) {
+ return from.NotEqual(Int8x32{})
+}
+
+// ToMask converts from Int16x16 to Mask16x16, mask element is set to true when the corresponding vector element is non-zero.
+func (from Int16x16) ToMask() (to Mask16x16) {
+ return from.NotEqual(Int16x16{})
+}
+
+// ToMask converts from Int32x8 to Mask32x8, mask element is set to true when the corresponding vector element is non-zero.
+func (from Int32x8) ToMask() (to Mask32x8) {
+ return from.NotEqual(Int32x8{})
+}
+
+// ToMask converts from Int64x4 to Mask64x4, mask element is set to true when the corresponding vector element is non-zero.
+func (from Int64x4) ToMask() (to Mask64x4) {
+ return from.NotEqual(Int64x4{})
+}
+
+// ToMask converts from Uint8x32 to Mask8x32, mask element is set to true when the corresponding vector element is non-zero.
+func (from Uint8x32) ToMask() (to Mask8x32) {
+ return from.NotEqual(Uint8x32{})
+}
+
+// ToMask converts from Uint16x16 to Mask16x16, mask element is set to true when the corresponding vector element is non-zero.
+func (from Uint16x16) ToMask() (to Mask16x16) {
+ return from.NotEqual(Uint16x16{})
+}
+
+// ToMask converts from Uint32x8 to Mask32x8, mask element is set to true when the corresponding vector element is non-zero.
+func (from Uint32x8) ToMask() (to Mask32x8) {
+ return from.NotEqual(Uint32x8{})
+}
+
+// ToMask converts from Uint64x4 to Mask64x4, mask element is set to true when the corresponding vector element is non-zero.
+func (from Uint64x4) ToMask() (to Mask64x4) {
+ return from.NotEqual(Uint64x4{})
+}
+
+// ToMask converts from Float32x8 to Mask32x8, mask element is set to true when the corresponding vector element is non-zero.
+func (from Float32x8) ToMask() (to Mask32x8) {
+ return from.NotEqual(Float32x8{})
+}
+
+// ToMask converts from Float64x4 to Mask64x4, mask element is set to true when the corresponding vector element is non-zero.
+func (from Float64x4) ToMask() (to Mask64x4) {
+ return from.NotEqual(Float64x4{})
+}
+
+// ToMask converts from Int8x64 to Mask8x64, mask element is set to true when the corresponding vector element is non-zero.
+func (from Int8x64) ToMask() (to Mask8x64) {
+ return from.NotEqual(Int8x64{})
+}
+
+// ToMask converts from Int16x32 to Mask16x32, mask element is set to true when the corresponding vector element is non-zero.
+func (from Int16x32) ToMask() (to Mask16x32) {
+ return from.NotEqual(Int16x32{})
+}
+
+// ToMask converts from Int32x16 to Mask32x16, mask element is set to true when the corresponding vector element is non-zero.
+func (from Int32x16) ToMask() (to Mask32x16) {
+ return from.NotEqual(Int32x16{})
+}
+
+// ToMask converts from Int64x8 to Mask64x8, mask element is set to true when the corresponding vector element is non-zero.
+func (from Int64x8) ToMask() (to Mask64x8) {
+ return from.NotEqual(Int64x8{})
+}
+
+// ToMask converts from Uint8x64 to Mask8x64, mask element is set to true when the corresponding vector element is non-zero.
+func (from Uint8x64) ToMask() (to Mask8x64) {
+ return from.NotEqual(Uint8x64{})
+}
+
+// ToMask converts from Uint16x32 to Mask16x32, mask element is set to true when the corresponding vector element is non-zero.
+func (from Uint16x32) ToMask() (to Mask16x32) {
+ return from.NotEqual(Uint16x32{})
+}
+
+// ToMask converts from Uint32x16 to Mask32x16, mask element is set to true when the corresponding vector element is non-zero.
+func (from Uint32x16) ToMask() (to Mask32x16) {
+ return from.NotEqual(Uint32x16{})
+}
+
+// ToMask converts from Uint64x8 to Mask64x8, mask element is set to true when the corresponding vector element is non-zero.
+func (from Uint64x8) ToMask() (to Mask64x8) {
+ return from.NotEqual(Uint64x8{})
+}
+
+// ToMask converts from Float32x16 to Mask32x16, mask element is set to true when the corresponding vector element is non-zero.
+func (from Float32x16) ToMask() (to Mask32x16) {
+ return from.NotEqual(Float32x16{})
+}
+
+// ToMask converts from Float64x8 to Mask64x8, mask element is set to true when the corresponding vector element is non-zero.
+func (from Float64x8) ToMask() (to Mask64x8) {
+ return from.NotEqual(Float64x8{})
+}
vals := [4]int32{1, 2, 3, 4}
v := myStruct{x: simd.LoadInt32x4(&vals)}
// masking elements 1 and 2.
- maskv := [4]int32{-1, -1, 0, 0}
want := []int32{2, 4, 0, 0}
y := simd.LoadInt32x4(&vals)
v.y = &y
t.Skip("Test requires HasAVX512, not available on this hardware")
return
}
- v.z = maskT(simd.LoadInt32x4(&maskv).AsMask32x4())
+ v.z = maskT(simd.Mask32x4FromBits(0b0011))
*v.y = v.y.AddMasked(v.x, simd.Mask32x4(v.z))
got := [4]int32{}
t.Skip("Test requires HasAVX512, not available on this hardware")
return
}
- v := [4]int32{1, 0, 1, 0}
- x := simd.LoadInt32x4(&v)
- var y simd.Int32x4
- mask := y.Sub(x).AsMask32x4()
- v = [4]int32{5, 6, 7, 8}
- y = simd.LoadInt32x4(&v)
- y = y.AddMasked(x, mask)
- got := [4]int32{6, 0, 8, 0}
- y.Store(&v)
+ x := simd.LoadInt32x4Slice([]int32{5, 0, 7, 0})
+ mask := simd.Int32x4{}.Sub(x).ToMask()
+ y := simd.LoadInt32x4Slice([]int32{1, 2, 3, 4}).AddMasked(x, mask)
+ want := [4]int32{6, 0, 10, 0}
+ got := make([]int32, 4)
+ y.StoreSlice(got)
for i := range 4 {
- if v[i] != got[i] {
- t.Errorf("Result at %d incorrect: want %d, got %d", i, v[i], got[i])
+ if want[i] != got[i] {
+ t.Errorf("Result at %d incorrect: want %d, got %d", i, want[i], got[i])
}
}
}
return
}
v1234 := simd.LoadInt32x4Slice([]int32{1, 2, 3, 4})
- v0101 := simd.LoadInt32x4Slice([]int32{0, -1, 0, -1})
- v2400 := v1234.Compress(v0101.AsMask32x4())
+ v2400 := v1234.Compress(simd.Mask32x4FromBits(0b1010))
got := make([]int32, 4)
v2400.StoreSlice(got)
want := []int32{2, 4, 0, 0}
return
}
v3400 := simd.LoadInt32x4Slice([]int32{3, 4, 0, 0})
- v0101 := simd.LoadInt32x4Slice([]int32{0, -1, 0, -1})
- v2400 := v3400.Expand(v0101.AsMask32x4())
+ v2400 := v3400.Expand(simd.Mask32x4FromBits(0b1010))
got := make([]int32, 4)
v2400.StoreSlice(got)
want := []int32{0, 3, 0, 4}
t.Skip("Test requires HasAVX512, not available on this hardware")
return
}
- if v := simd.LoadInt16x8Slice([]int16{-1, 0, -1, 0, 0, 0, 0, 0}).AsMask16x8().ToBits(); v != 0b101 {
+ if v := simd.LoadInt16x8Slice([]int16{1, 0, 1, 0, 0, 0, 0, 0}).ToMask().ToBits(); v != 0b101 {
t.Errorf("Want 0b101, got %b", v)
}
}
return x
}
mask := vecMask32[len(vecMask32)/2-l:]
- return LoadMaskedInt32x4(paInt32x4(s), LoadInt32x4Slice(mask).AsMask32x4())
+ return LoadMaskedInt32x4(paInt32x4(s), LoadInt32x4Slice(mask).asMask())
}
// StoreSlicePart stores the 4 elements of x into the slice s.
return
}
mask := vecMask32[len(vecMask32)/2-l:]
- x.StoreMasked(paInt32x4(s), LoadInt32x4Slice(mask).AsMask32x4())
+ x.StoreMasked(paInt32x4(s), LoadInt32x4Slice(mask).asMask())
}
// LoadInt64x2SlicePart loads a Int64x2 from the slice s.
return x
}
mask := vecMask64[len(vecMask64)/2-l:]
- return LoadMaskedInt64x2(paInt64x2(s), LoadInt64x2Slice(mask).AsMask64x2())
+ return LoadMaskedInt64x2(paInt64x2(s), LoadInt64x2Slice(mask).asMask())
}
// StoreSlicePart stores the 2 elements of x into the slice s.
return
}
mask := vecMask64[len(vecMask64)/2-l:]
- x.StoreMasked(paInt64x2(s), LoadInt64x2Slice(mask).AsMask64x2())
+ x.StoreMasked(paInt64x2(s), LoadInt64x2Slice(mask).asMask())
}
// LoadUint32x4SlicePart loads a Uint32x4 from the slice s.
return x
}
mask := vecMask32[len(vecMask32)/2-l:]
- return LoadMaskedUint32x4(paUint32x4(s), LoadInt32x4Slice(mask).AsMask32x4())
+ return LoadMaskedUint32x4(paUint32x4(s), LoadInt32x4Slice(mask).asMask())
}
// StoreSlicePart stores the 4 elements of x into the slice s.
return
}
mask := vecMask32[len(vecMask32)/2-l:]
- x.StoreMasked(paUint32x4(s), LoadInt32x4Slice(mask).AsMask32x4())
+ x.StoreMasked(paUint32x4(s), LoadInt32x4Slice(mask).asMask())
}
// LoadUint64x2SlicePart loads a Uint64x2 from the slice s.
return x
}
mask := vecMask64[len(vecMask64)/2-l:]
- return LoadMaskedUint64x2(paUint64x2(s), LoadInt64x2Slice(mask).AsMask64x2())
+ return LoadMaskedUint64x2(paUint64x2(s), LoadInt64x2Slice(mask).asMask())
}
// StoreSlicePart stores the 2 elements of x into the slice s.
return
}
mask := vecMask64[len(vecMask64)/2-l:]
- x.StoreMasked(paUint64x2(s), LoadInt64x2Slice(mask).AsMask64x2())
+ x.StoreMasked(paUint64x2(s), LoadInt64x2Slice(mask).asMask())
}
// LoadFloat32x4SlicePart loads a Float32x4 from the slice s.
return x
}
mask := vecMask32[len(vecMask32)/2-l:]
- return LoadMaskedFloat32x4(paFloat32x4(s), LoadInt32x4Slice(mask).AsMask32x4())
+ return LoadMaskedFloat32x4(paFloat32x4(s), LoadInt32x4Slice(mask).asMask())
}
// StoreSlicePart stores the 4 elements of x into the slice s.
return
}
mask := vecMask32[len(vecMask32)/2-l:]
- x.StoreMasked(paFloat32x4(s), LoadInt32x4Slice(mask).AsMask32x4())
+ x.StoreMasked(paFloat32x4(s), LoadInt32x4Slice(mask).asMask())
}
// LoadFloat64x2SlicePart loads a Float64x2 from the slice s.
return x
}
mask := vecMask64[len(vecMask64)/2-l:]
- return LoadMaskedFloat64x2(paFloat64x2(s), LoadInt64x2Slice(mask).AsMask64x2())
+ return LoadMaskedFloat64x2(paFloat64x2(s), LoadInt64x2Slice(mask).asMask())
}
// StoreSlicePart stores the 2 elements of x into the slice s.
return
}
mask := vecMask64[len(vecMask64)/2-l:]
- x.StoreMasked(paFloat64x2(s), LoadInt64x2Slice(mask).AsMask64x2())
+ x.StoreMasked(paFloat64x2(s), LoadInt64x2Slice(mask).asMask())
}
// LoadInt32x8SlicePart loads a Int32x8 from the slice s.
return x
}
mask := vecMask32[len(vecMask32)/2-l:]
- return LoadMaskedInt32x8(paInt32x8(s), LoadInt32x8Slice(mask).AsMask32x8())
+ return LoadMaskedInt32x8(paInt32x8(s), LoadInt32x8Slice(mask).asMask())
}
// StoreSlicePart stores the 8 elements of x into the slice s.
return
}
mask := vecMask32[len(vecMask32)/2-l:]
- x.StoreMasked(paInt32x8(s), LoadInt32x8Slice(mask).AsMask32x8())
+ x.StoreMasked(paInt32x8(s), LoadInt32x8Slice(mask).asMask())
}
// LoadInt64x4SlicePart loads a Int64x4 from the slice s.
return x
}
mask := vecMask64[len(vecMask64)/2-l:]
- return LoadMaskedInt64x4(paInt64x4(s), LoadInt64x4Slice(mask).AsMask64x4())
+ return LoadMaskedInt64x4(paInt64x4(s), LoadInt64x4Slice(mask).asMask())
}
// StoreSlicePart stores the 4 elements of x into the slice s.
return
}
mask := vecMask64[len(vecMask64)/2-l:]
- x.StoreMasked(paInt64x4(s), LoadInt64x4Slice(mask).AsMask64x4())
+ x.StoreMasked(paInt64x4(s), LoadInt64x4Slice(mask).asMask())
}
// LoadUint32x8SlicePart loads a Uint32x8 from the slice s.
return x
}
mask := vecMask32[len(vecMask32)/2-l:]
- return LoadMaskedUint32x8(paUint32x8(s), LoadInt32x8Slice(mask).AsMask32x8())
+ return LoadMaskedUint32x8(paUint32x8(s), LoadInt32x8Slice(mask).asMask())
}
// StoreSlicePart stores the 8 elements of x into the slice s.
return
}
mask := vecMask32[len(vecMask32)/2-l:]
- x.StoreMasked(paUint32x8(s), LoadInt32x8Slice(mask).AsMask32x8())
+ x.StoreMasked(paUint32x8(s), LoadInt32x8Slice(mask).asMask())
}
// LoadUint64x4SlicePart loads a Uint64x4 from the slice s.
return x
}
mask := vecMask64[len(vecMask64)/2-l:]
- return LoadMaskedUint64x4(paUint64x4(s), LoadInt64x4Slice(mask).AsMask64x4())
+ return LoadMaskedUint64x4(paUint64x4(s), LoadInt64x4Slice(mask).asMask())
}
// StoreSlicePart stores the 4 elements of x into the slice s.
return
}
mask := vecMask64[len(vecMask64)/2-l:]
- x.StoreMasked(paUint64x4(s), LoadInt64x4Slice(mask).AsMask64x4())
+ x.StoreMasked(paUint64x4(s), LoadInt64x4Slice(mask).asMask())
}
// LoadFloat32x8SlicePart loads a Float32x8 from the slice s.
return x
}
mask := vecMask32[len(vecMask32)/2-l:]
- return LoadMaskedFloat32x8(paFloat32x8(s), LoadInt32x8Slice(mask).AsMask32x8())
+ return LoadMaskedFloat32x8(paFloat32x8(s), LoadInt32x8Slice(mask).asMask())
}
// StoreSlicePart stores the 8 elements of x into the slice s.
return
}
mask := vecMask32[len(vecMask32)/2-l:]
- x.StoreMasked(paFloat32x8(s), LoadInt32x8Slice(mask).AsMask32x8())
+ x.StoreMasked(paFloat32x8(s), LoadInt32x8Slice(mask).asMask())
}
// LoadFloat64x4SlicePart loads a Float64x4 from the slice s.
return x
}
mask := vecMask64[len(vecMask64)/2-l:]
- return LoadMaskedFloat64x4(paFloat64x4(s), LoadInt64x4Slice(mask).AsMask64x4())
+ return LoadMaskedFloat64x4(paFloat64x4(s), LoadInt64x4Slice(mask).asMask())
}
// StoreSlicePart stores the 4 elements of x into the slice s.
return
}
mask := vecMask64[len(vecMask64)/2-l:]
- x.StoreMasked(paFloat64x4(s), LoadInt64x4Slice(mask).AsMask64x4())
+ x.StoreMasked(paFloat64x4(s), LoadInt64x4Slice(mask).asMask())
}
// LoadUint8x16SlicePart loads a Uint8x16 from the slice s.