| // Code generated by 'simdgen -o godefs -goroot $GOROOT -arch arm64 -arm64Path $ARM64_ISA_PATH go_arm64.yaml types.yaml categories.yaml'; DO NOT EDIT. |
| |
| //go:build goexperiment.simd |
| |
| package archsimd |
| |
| /* Abs */ |
| |
| // Abs computes the absolute value of each element. |
| // |
| // Asm: VFABS, CPU Feature: NEON |
| func (x Float32x4) Abs() Float32x4 |
| |
| // Abs computes the absolute value of each element. |
| // |
| // Asm: VFABS, CPU Feature: NEON |
| func (x Float64x2) Abs() Float64x2 |
| |
| // Abs computes the absolute value of each element. |
| // |
| // Asm: VABS, CPU Feature: NEON |
| func (x Int8x16) Abs() Int8x16 |
| |
| // Abs computes the absolute value of each element. |
| // |
| // Asm: VABS, CPU Feature: NEON |
| func (x Int16x8) Abs() Int16x8 |
| |
| // Abs computes the absolute value of each element. |
| // |
| // Asm: VABS, CPU Feature: NEON |
| func (x Int32x4) Abs() Int32x4 |
| |
| // Abs computes the absolute value of each element. |
| // |
| // Asm: VABS, CPU Feature: NEON |
| func (x Int64x2) Abs() Int64x2 |
| |
| /* Add */ |
| |
| // Add adds corresponding elements of two vectors. |
| // |
| // Asm: VFADD, CPU Feature: NEON |
| func (x Float32x4) Add(y Float32x4) Float32x4 |
| |
| // Add adds corresponding elements of two vectors. |
| // |
| // Asm: VFADD, CPU Feature: NEON |
| func (x Float64x2) Add(y Float64x2) Float64x2 |
| |
| // Add adds corresponding elements of two vectors. |
| // |
| // Asm: VADD, CPU Feature: NEON |
| func (x Int8x16) Add(y Int8x16) Int8x16 |
| |
| // Add adds corresponding elements of two vectors. |
| // |
| // Asm: VADD, CPU Feature: NEON |
| func (x Int16x8) Add(y Int16x8) Int16x8 |
| |
| // Add adds corresponding elements of two vectors. |
| // |
| // Asm: VADD, CPU Feature: NEON |
| func (x Int32x4) Add(y Int32x4) Int32x4 |
| |
| // Add adds corresponding elements of two vectors. |
| // |
| // Asm: VADD, CPU Feature: NEON |
| func (x Int64x2) Add(y Int64x2) Int64x2 |
| |
| // Add adds corresponding elements of two vectors. |
| // |
| // Asm: VADD, CPU Feature: NEON |
| func (x Uint8x16) Add(y Uint8x16) Uint8x16 |
| |
| // Add adds corresponding elements of two vectors. |
| // |
| // Asm: VADD, CPU Feature: NEON |
| func (x Uint16x8) Add(y Uint16x8) Uint16x8 |
| |
| // Add adds corresponding elements of two vectors. |
| // |
| // Asm: VADD, CPU Feature: NEON |
| func (x Uint32x4) Add(y Uint32x4) Uint32x4 |
| |
| // Add adds corresponding elements of two vectors. |
| // |
| // Asm: VADD, CPU Feature: NEON |
| func (x Uint64x2) Add(y Uint64x2) Uint64x2 |
| |
| /* AddSaturated */ |
| |
| // AddSaturated adds corresponding elements of two vectors with saturation. |
| // |
| // Asm: VSQADD, CPU Feature: NEON |
| func (x Int8x16) AddSaturated(y Int8x16) Int8x16 |
| |
| // AddSaturated adds corresponding elements of two vectors with saturation. |
| // |
| // Asm: VSQADD, CPU Feature: NEON |
| func (x Int16x8) AddSaturated(y Int16x8) Int16x8 |
| |
| // AddSaturated adds corresponding elements of two vectors with saturation. |
| // |
| // Asm: VSQADD, CPU Feature: NEON |
| func (x Int32x4) AddSaturated(y Int32x4) Int32x4 |
| |
| // AddSaturated adds corresponding elements of two vectors with saturation. |
| // |
| // Asm: VSQADD, CPU Feature: NEON |
| func (x Int64x2) AddSaturated(y Int64x2) Int64x2 |
| |
| // AddSaturated adds corresponding elements of two vectors with saturation. |
| // |
| // Asm: VUQADD, CPU Feature: NEON |
| func (x Uint8x16) AddSaturated(y Uint8x16) Uint8x16 |
| |
| // AddSaturated adds corresponding elements of two vectors with saturation. |
| // |
| // Asm: VUQADD, CPU Feature: NEON |
| func (x Uint16x8) AddSaturated(y Uint16x8) Uint16x8 |
| |
| // AddSaturated adds corresponding elements of two vectors with saturation. |
| // |
| // Asm: VUQADD, CPU Feature: NEON |
| func (x Uint32x4) AddSaturated(y Uint32x4) Uint32x4 |
| |
| // AddSaturated adds corresponding elements of two vectors with saturation. |
| // |
| // Asm: VUQADD, CPU Feature: NEON |
| func (x Uint64x2) AddSaturated(y Uint64x2) Uint64x2 |
| |
| /* And */ |
| |
| // And performs a bitwise x & y. |
| // |
| // Asm: VAND, CPU Feature: NEON |
| func (x Int8x16) And(y Int8x16) Int8x16 |
| |
| // And performs a bitwise x & y. |
| // |
| // Asm: VAND, CPU Feature: NEON |
| func (x Int16x8) And(y Int16x8) Int16x8 |
| |
| // And performs a bitwise x & y. |
| // |
| // Asm: VAND, CPU Feature: NEON |
| func (x Int32x4) And(y Int32x4) Int32x4 |
| |
| // And performs a bitwise x & y. |
| // |
| // Asm: VAND, CPU Feature: NEON |
| func (x Int64x2) And(y Int64x2) Int64x2 |
| |
| // And performs a bitwise x & y. |
| // |
| // Asm: VAND, CPU Feature: NEON |
| func (x Uint8x16) And(y Uint8x16) Uint8x16 |
| |
| // And performs a bitwise x & y. |
| // |
| // Asm: VAND, CPU Feature: NEON |
| func (x Uint16x8) And(y Uint16x8) Uint16x8 |
| |
| // And performs a bitwise x & y. |
| // |
| // Asm: VAND, CPU Feature: NEON |
| func (x Uint32x4) And(y Uint32x4) Uint32x4 |
| |
| // And performs a bitwise x & y. |
| // |
| // Asm: VAND, CPU Feature: NEON |
| func (x Uint64x2) And(y Uint64x2) Uint64x2 |
| |
| /* AndNot */ |
| |
| // AndNot performs a bitwise x &^ y. |
| // |
| // Asm: VBIC, CPU Feature: NEON |
| func (x Int8x16) AndNot(y Int8x16) Int8x16 |
| |
| // AndNot performs a bitwise x &^ y. |
| // |
| // Asm: VBIC, CPU Feature: NEON |
| func (x Int16x8) AndNot(y Int16x8) Int16x8 |
| |
| // AndNot performs a bitwise x &^ y. |
| // |
| // Asm: VBIC, CPU Feature: NEON |
| func (x Int32x4) AndNot(y Int32x4) Int32x4 |
| |
| // AndNot performs a bitwise x &^ y. |
| // |
| // Asm: VBIC, CPU Feature: NEON |
| func (x Int64x2) AndNot(y Int64x2) Int64x2 |
| |
| // AndNot performs a bitwise x &^ y. |
| // |
| // Asm: VBIC, CPU Feature: NEON |
| func (x Uint8x16) AndNot(y Uint8x16) Uint8x16 |
| |
| // AndNot performs a bitwise x &^ y. |
| // |
| // Asm: VBIC, CPU Feature: NEON |
| func (x Uint16x8) AndNot(y Uint16x8) Uint16x8 |
| |
| // AndNot performs a bitwise x &^ y. |
| // |
| // Asm: VBIC, CPU Feature: NEON |
| func (x Uint32x4) AndNot(y Uint32x4) Uint32x4 |
| |
| // AndNot performs a bitwise x &^ y. |
| // |
| // Asm: VBIC, CPU Feature: NEON |
| func (x Uint64x2) AndNot(y Uint64x2) Uint64x2 |
| |
| /* Average */ |
| |
| // Average computes the rounded average of corresponding elements. |
| // |
| // Asm: VSRHADD, CPU Feature: NEON |
| func (x Int8x16) Average(y Int8x16) Int8x16 |
| |
| // Average computes the rounded average of corresponding elements. |
| // |
| // Asm: VSRHADD, CPU Feature: NEON |
| func (x Int16x8) Average(y Int16x8) Int16x8 |
| |
| // Average computes the rounded average of corresponding elements. |
| // |
| // Asm: VSRHADD, CPU Feature: NEON |
| func (x Int32x4) Average(y Int32x4) Int32x4 |
| |
| // Average computes the rounded average of corresponding elements. |
| // |
| // Asm: VURHADD, CPU Feature: NEON |
| func (x Uint8x16) Average(y Uint8x16) Uint8x16 |
| |
| // Average computes the rounded average of corresponding elements. |
| // |
| // Asm: VURHADD, CPU Feature: NEON |
| func (x Uint16x8) Average(y Uint16x8) Uint16x8 |
| |
| // Average computes the rounded average of corresponding elements. |
| // |
| // Asm: VURHADD, CPU Feature: NEON |
| func (x Uint32x4) Average(y Uint32x4) Uint32x4 |
| |
| /* Ceil */ |
| |
| // Ceil rounds elements up to the nearest integer. |
| // |
| // Asm: VFRINTP, CPU Feature: NEON |
| func (x Float32x4) Ceil() Float32x4 |
| |
| // Ceil rounds elements up to the nearest integer. |
| // |
| // Asm: VFRINTP, CPU Feature: NEON |
| func (x Float64x2) Ceil() Float64x2 |
| |
| /* ConcatAddPairs */ |
| |
| // ConcatAddPairs horizontally adds adjacent pairs of elements. |
| // For x = [x0, x1, x2, x3, ...] and y = [y0, y1, y2, y3, ...], the result is [x0+x1, x2+x3, ..., y0+y1, y2+y3, ...]. |
| // |
| // Asm: VFADDP, CPU Feature: NEON |
| func (x Float32x4) ConcatAddPairs(y Float32x4) Float32x4 |
| |
| // ConcatAddPairs horizontally adds adjacent pairs of elements. |
| // For x = [x0, x1] and y = [y0, y1], the result is [x0+x1, y0+y1]. |
| // |
| // Asm: VFADDP, CPU Feature: NEON |
| func (x Float64x2) ConcatAddPairs(y Float64x2) Float64x2 |
| |
| // ConcatAddPairs horizontally adds adjacent pairs of elements. |
| // For x = [x0, x1, x2, x3, ...] and y = [y0, y1, y2, y3, ...], the result is [x0+x1, x2+x3, ..., y0+y1, y2+y3, ...]. |
| // |
| // Asm: VADDP, CPU Feature: NEON |
| func (x Int16x8) ConcatAddPairs(y Int16x8) Int16x8 |
| |
| // ConcatAddPairs horizontally adds adjacent pairs of elements. |
| // For x = [x0, x1, x2, x3, ...] and y = [y0, y1, y2, y3, ...], the result is [x0+x1, x2+x3, ..., y0+y1, y2+y3, ...]. |
| // |
| // Asm: VADDP, CPU Feature: NEON |
| func (x Int32x4) ConcatAddPairs(y Int32x4) Int32x4 |
| |
| // ConcatAddPairs horizontally adds adjacent pairs of elements. |
| // For x = [x0, x1] and y = [y0, y1], the result is [x0+x1, y0+y1]. |
| // |
| // Asm: VADDP, CPU Feature: NEON |
| func (x Int64x2) ConcatAddPairs(y Int64x2) Int64x2 |
| |
| // ConcatAddPairs horizontally adds adjacent pairs of elements. |
| // For x = [x0, x1, x2, x3, ...] and y = [y0, y1, y2, y3, ...], the result is [x0+x1, x2+x3, ..., y0+y1, y2+y3, ...]. |
| // |
| // Asm: VADDP, CPU Feature: NEON |
| func (x Uint16x8) ConcatAddPairs(y Uint16x8) Uint16x8 |
| |
| // ConcatAddPairs horizontally adds adjacent pairs of elements. |
| // For x = [x0, x1, x2, x3, ...] and y = [y0, y1, y2, y3, ...], the result is [x0+x1, x2+x3, ..., y0+y1, y2+y3, ...]. |
| // |
| // Asm: VADDP, CPU Feature: NEON |
| func (x Uint32x4) ConcatAddPairs(y Uint32x4) Uint32x4 |
| |
| // ConcatAddPairs horizontally adds adjacent pairs of elements. |
| // For x = [x0, x1] and y = [y0, y1], the result is [x0+x1, y0+y1]. |
| // |
| // Asm: VADDP, CPU Feature: NEON |
| func (x Uint64x2) ConcatAddPairs(y Uint64x2) Uint64x2 |
| |
| /* ConcatEven */ |
| |
| // ConcatEven concatenates even-indexed elements from the concatenation of x and y. |
| // For x = [x0,x1,x2,x3] and y = [y0,y1,y2,y3], result = [x0,x2,y0,y2]. |
| // |
| // Asm: VUZP1, CPU Feature: NEON |
| func (x Int8x16) ConcatEven(y Int8x16) Int8x16 |
| |
| // ConcatEven concatenates even-indexed elements from the concatenation of x and y. |
| // For x = [x0,x1,x2,x3] and y = [y0,y1,y2,y3], result = [x0,x2,y0,y2]. |
| // |
| // Asm: VUZP1, CPU Feature: NEON |
| func (x Int16x8) ConcatEven(y Int16x8) Int16x8 |
| |
| // ConcatEven concatenates even-indexed elements from the concatenation of x and y. |
| // For x = [x0,x1,x2,x3] and y = [y0,y1,y2,y3], result = [x0,x2,y0,y2]. |
| // |
| // Asm: VUZP1, CPU Feature: NEON |
| func (x Int32x4) ConcatEven(y Int32x4) Int32x4 |
| |
| // ConcatEven concatenates even-indexed elements from the concatenation of x and y. |
| // For x = [x0,x1,x2,x3] and y = [y0,y1,y2,y3], result = [x0,x2,y0,y2]. |
| // |
| // Asm: VUZP1, CPU Feature: NEON |
| func (x Int64x2) ConcatEven(y Int64x2) Int64x2 |
| |
| // ConcatEven concatenates even-indexed elements from the concatenation of x and y. |
| // For x = [x0,x1,x2,x3] and y = [y0,y1,y2,y3], result = [x0,x2,y0,y2]. |
| // |
| // Asm: VUZP1, CPU Feature: NEON |
| func (x Uint8x16) ConcatEven(y Uint8x16) Uint8x16 |
| |
| // ConcatEven concatenates even-indexed elements from the concatenation of x and y. |
| // For x = [x0,x1,x2,x3] and y = [y0,y1,y2,y3], result = [x0,x2,y0,y2]. |
| // |
| // Asm: VUZP1, CPU Feature: NEON |
| func (x Uint16x8) ConcatEven(y Uint16x8) Uint16x8 |
| |
| // ConcatEven concatenates even-indexed elements from the concatenation of x and y. |
| // For x = [x0,x1,x2,x3] and y = [y0,y1,y2,y3], result = [x0,x2,y0,y2]. |
| // |
| // Asm: VUZP1, CPU Feature: NEON |
| func (x Uint32x4) ConcatEven(y Uint32x4) Uint32x4 |
| |
| // ConcatEven concatenates even-indexed elements from the concatenation of x and y. |
| // For x = [x0,x1,x2,x3] and y = [y0,y1,y2,y3], result = [x0,x2,y0,y2]. |
| // |
| // Asm: VUZP1, CPU Feature: NEON |
| func (x Uint64x2) ConcatEven(y Uint64x2) Uint64x2 |
| |
| /* ConcatOdd */ |
| |
| // ConcatOdd concatenates odd-indexed elements from the concatenation of x and y. |
| // For x = [x0,x1,x2,x3] and y = [y0,y1,y2,y3], result = [x1,x3,y1,y3]. |
| // |
| // Asm: VUZP2, CPU Feature: NEON |
| func (x Int8x16) ConcatOdd(y Int8x16) Int8x16 |
| |
| // ConcatOdd concatenates odd-indexed elements from the concatenation of x and y. |
| // For x = [x0,x1,x2,x3] and y = [y0,y1,y2,y3], result = [x1,x3,y1,y3]. |
| // |
| // Asm: VUZP2, CPU Feature: NEON |
| func (x Int16x8) ConcatOdd(y Int16x8) Int16x8 |
| |
| // ConcatOdd concatenates odd-indexed elements from the concatenation of x and y. |
| // For x = [x0,x1,x2,x3] and y = [y0,y1,y2,y3], result = [x1,x3,y1,y3]. |
| // |
| // Asm: VUZP2, CPU Feature: NEON |
| func (x Int32x4) ConcatOdd(y Int32x4) Int32x4 |
| |
| // ConcatOdd concatenates odd-indexed elements from the concatenation of x and y. |
| // For x = [x0,x1,x2,x3] and y = [y0,y1,y2,y3], result = [x1,x3,y1,y3]. |
| // |
| // Asm: VUZP2, CPU Feature: NEON |
| func (x Int64x2) ConcatOdd(y Int64x2) Int64x2 |
| |
| // ConcatOdd concatenates odd-indexed elements from the concatenation of x and y. |
| // For x = [x0,x1,x2,x3] and y = [y0,y1,y2,y3], result = [x1,x3,y1,y3]. |
| // |
| // Asm: VUZP2, CPU Feature: NEON |
| func (x Uint8x16) ConcatOdd(y Uint8x16) Uint8x16 |
| |
| // ConcatOdd concatenates odd-indexed elements from the concatenation of x and y. |
| // For x = [x0,x1,x2,x3] and y = [y0,y1,y2,y3], result = [x1,x3,y1,y3]. |
| // |
| // Asm: VUZP2, CPU Feature: NEON |
| func (x Uint16x8) ConcatOdd(y Uint16x8) Uint16x8 |
| |
| // ConcatOdd concatenates odd-indexed elements from the concatenation of x and y. |
| // For x = [x0,x1,x2,x3] and y = [y0,y1,y2,y3], result = [x1,x3,y1,y3]. |
| // |
| // Asm: VUZP2, CPU Feature: NEON |
| func (x Uint32x4) ConcatOdd(y Uint32x4) Uint32x4 |
| |
| // ConcatOdd concatenates odd-indexed elements from the concatenation of x and y. |
| // For x = [x0,x1,x2,x3] and y = [y0,y1,y2,y3], result = [x1,x3,y1,y3]. |
| // |
| // Asm: VUZP2, CPU Feature: NEON |
| func (x Uint64x2) ConcatOdd(y Uint64x2) Uint64x2 |
| |
| /* ConcatShiftBytesRight */ |
| |
| // ConcatShiftBytesRight concatenates x and y and shifts it right by shift bytes. |
| // The result vector will be the lower half of the concatenated vector. |
| // |
| // A non-constant value of shift may result in significantly worse performance for this operation. |
| // |
| // Asm: VEXT, CPU Feature: NEON |
| func (x Uint8x16) ConcatShiftBytesRight(y Uint8x16, shift uint64) Uint8x16 |
| |
| /* ConvertLo2ToFloat64 */ |
| |
| // ConvertLo2ToFloat64 converts low-indexed float32 element values to float64. |
| // For the high-indexed elements, use HiToLo: |
| // |
| // x.HiToLo().ConvertLo2ToFloat64(...) |
| // |
| // Asm: VFCVTL, CPU Feature: NEON |
| func (x Float32x4) ConvertLo2ToFloat64() Float64x2 |
| |
| /* ConvertToFloat32 */ |
| |
| // ConvertToFloat32 converts element values to float32. |
| // |
| // Asm: VFCVTN, CPU Feature: NEON |
| func (x Float64x2) ConvertToFloat32() Float32x4 |
| |
| // ConvertToFloat32 converts element values to float32. |
| // |
| // Asm: VSCVTF, CPU Feature: NEON |
| func (x Int32x4) ConvertToFloat32() Float32x4 |
| |
| // ConvertToFloat32 converts element values to float32. |
| // |
| // Asm: VUCVTF, CPU Feature: NEON |
| func (x Uint32x4) ConvertToFloat32() Float32x4 |
| |
| /* ConvertToFloat64 */ |
| |
| // ConvertToFloat64 converts element values to float64. |
| // |
| // Asm: VSCVTF, CPU Feature: NEON |
| func (x Int64x2) ConvertToFloat64() Float64x2 |
| |
| // ConvertToFloat64 converts element values to float64. |
| // |
| // Asm: VUCVTF, CPU Feature: NEON |
| func (x Uint64x2) ConvertToFloat64() Float64x2 |
| |
| /* ConvertToInt32 */ |
| |
| // ConvertToInt32 converts element values to int32. |
| // When a conversion is inexact, a truncated (round toward zero) value is returned. |
| // If a converted result cannot be represented in int32, an implementation-defined |
| // architecture-specific value is returned. |
| // |
| // Asm: VFCVTZS, CPU Feature: NEON |
| func (x Float32x4) ConvertToInt32() Int32x4 |
| |
| /* ConvertToInt64 */ |
| |
| // ConvertToInt64 converts element values to int64. |
| // When a conversion is inexact, a truncated (round toward zero) value is returned. |
| // If a converted result cannot be represented in int64, an implementation-defined |
| // architecture-specific value is returned. |
| // |
| // Asm: VFCVTZS, CPU Feature: NEON |
| func (x Float64x2) ConvertToInt64() Int64x2 |
| |
| /* ConvertToUint32 */ |
| |
| // ConvertToUint32 converts element values to uint32. |
| // When a conversion is inexact, a truncated (round toward zero) value is returned. |
| // If a converted result cannot be represented in uint32, an implementation-defined |
| // architecture-specific value is returned. |
| // |
| // Asm: VFCVTZU, CPU Feature: NEON |
| func (x Float32x4) ConvertToUint32() Uint32x4 |
| |
| /* ConvertToUint64 */ |
| |
| // ConvertToUint64 converts element values to uint64. |
| // When a conversion is inexact, a truncated (round toward zero) value is returned. |
| // If a converted result cannot be represented in uint64, an implementation-defined |
| // architecture-specific value is returned. |
| // |
| // Asm: VFCVTZU, CPU Feature: NEON |
| func (x Float64x2) ConvertToUint64() Uint64x2 |
| |
| /* Div */ |
| |
| // Div divides elements of two vectors. Division by zero follows IEEE 754 and does not panic. |
| // |
| // Asm: VFDIV, CPU Feature: NEON |
| func (x Float32x4) Div(y Float32x4) Float32x4 |
| |
| // Div divides elements of two vectors. Division by zero follows IEEE 754 and does not panic. |
| // |
| // Asm: VFDIV, CPU Feature: NEON |
| func (x Float64x2) Div(y Float64x2) Float64x2 |
| |
| /* Equal */ |
| |
| // Equal returns a mask whose elements indicate whether x == y. |
| // |
| // Asm: VFCMEQ, CPU Feature: NEON |
| func (x Float32x4) Equal(y Float32x4) Mask32x4 |
| |
| // Equal returns a mask whose elements indicate whether x == y. |
| // |
| // Asm: VFCMEQ, CPU Feature: NEON |
| func (x Float64x2) Equal(y Float64x2) Mask64x2 |
| |
| // Equal returns a mask whose elements indicate whether x == y. |
| // |
| // Asm: VCMEQ, CPU Feature: NEON |
| func (x Int8x16) Equal(y Int8x16) Mask8x16 |
| |
| // Equal returns a mask whose elements indicate whether x == y. |
| // |
| // Asm: VCMEQ, CPU Feature: NEON |
| func (x Int16x8) Equal(y Int16x8) Mask16x8 |
| |
| // Equal returns a mask whose elements indicate whether x == y. |
| // |
| // Asm: VCMEQ, CPU Feature: NEON |
| func (x Int32x4) Equal(y Int32x4) Mask32x4 |
| |
| // Equal returns a mask whose elements indicate whether x == y. |
| // |
| // Asm: VCMEQ, CPU Feature: NEON |
| func (x Int64x2) Equal(y Int64x2) Mask64x2 |
| |
| // Equal returns a mask whose elements indicate whether x == y. |
| // |
| // Asm: VCMEQ, CPU Feature: NEON |
| func (x Uint8x16) Equal(y Uint8x16) Mask8x16 |
| |
| // Equal returns a mask whose elements indicate whether x == y. |
| // |
| // Asm: VCMEQ, CPU Feature: NEON |
| func (x Uint16x8) Equal(y Uint16x8) Mask16x8 |
| |
| // Equal returns a mask whose elements indicate whether x == y. |
| // |
| // Asm: VCMEQ, CPU Feature: NEON |
| func (x Uint32x4) Equal(y Uint32x4) Mask32x4 |
| |
| // Equal returns a mask whose elements indicate whether x == y. |
| // |
| // Asm: VCMEQ, CPU Feature: NEON |
| func (x Uint64x2) Equal(y Uint64x2) Mask64x2 |
| |
| /* ExtendLo2ToInt64 */ |
| |
| // ExtendLo2ToInt64 sign-extends 2 lowest vector element values to int64. |
| // For the high-indexed elements, use HiToLo: |
| // |
| // x.HiToLo().ExtendLo2ToInt64(...) |
| // |
| // Asm: VSXTL, CPU Feature: NEON |
| func (x Int32x4) ExtendLo2ToInt64() Int64x2 |
| |
| /* ExtendLo2ToUint64 */ |
| |
| // ExtendLo2ToUint64 zero-extends 2 lowest vector element values to uint64. |
| // For the high-indexed elements, use HiToLo: |
| // |
| // x.HiToLo().ExtendLo2ToUint64(...) |
| // |
| // Asm: VUXTL, CPU Feature: NEON |
| func (x Uint32x4) ExtendLo2ToUint64() Uint64x2 |
| |
| /* ExtendLo4ToInt32 */ |
| |
| // ExtendLo4ToInt32 sign-extends 4 lowest vector element values to int32. |
| // For the high-indexed elements, use HiToLo: |
| // |
| // x.HiToLo().ExtendLo4ToInt32(...) |
| // |
| // Asm: VSXTL, CPU Feature: NEON |
| func (x Int16x8) ExtendLo4ToInt32() Int32x4 |
| |
| /* ExtendLo4ToUint32 */ |
| |
| // ExtendLo4ToUint32 zero-extends 4 lowest vector element values to uint32. |
| // For the high-indexed elements, use HiToLo: |
| // |
| // x.HiToLo().ExtendLo4ToUint32(...) |
| // |
| // Asm: VUXTL, CPU Feature: NEON |
| func (x Uint16x8) ExtendLo4ToUint32() Uint32x4 |
| |
| /* ExtendLo8ToInt16 */ |
| |
| // ExtendLo8ToInt16 sign-extends 8 lowest vector element values to int16. |
| // For the high-indexed elements, use HiToLo: |
| // |
| // x.HiToLo().ExtendLo8ToInt16(...) |
| // |
| // Asm: VSXTL, CPU Feature: NEON |
| func (x Int8x16) ExtendLo8ToInt16() Int16x8 |
| |
| /* ExtendLo8ToUint16 */ |
| |
| // ExtendLo8ToUint16 zero-extends 8 lowest vector element values to uint16. |
| // For the high-indexed elements, use HiToLo: |
| // |
| // x.HiToLo().ExtendLo8ToUint16(...) |
| // |
| // Asm: VUXTL, CPU Feature: NEON |
| func (x Uint8x16) ExtendLo8ToUint16() Uint16x8 |
| |
| /* Floor */ |
| |
| // Floor rounds elements down to the nearest integer. |
| // |
| // Asm: VFRINTM, CPU Feature: NEON |
| func (x Float32x4) Floor() Float32x4 |
| |
| // Floor rounds elements down to the nearest integer. |
| // |
| // Asm: VFRINTM, CPU Feature: NEON |
| func (x Float64x2) Floor() Float64x2 |
| |
| /* GetElem */ |
| |
| // GetElem returns the index'th element of x. |
| // |
| // A non-constant value of index may result in significantly worse performance for this operation. |
| // |
| // Asm: VDUP, CPU Feature: NEON |
| func (x Float32x4) GetElem(index uint8) float32 |
| |
| // GetElem returns the index'th element of x. |
| // |
| // A non-constant value of index may result in significantly worse performance for this operation. |
| // |
| // Asm: VDUP, CPU Feature: NEON |
| func (x Float64x2) GetElem(index uint8) float64 |
| |
| // GetElem returns the index'th element of x. |
| // |
| // A non-constant value of index may result in significantly worse performance for this operation. |
| // |
| // Asm: VMOV, CPU Feature: NEON |
| func (x Int8x16) GetElem(index uint8) int8 |
| |
| // GetElem returns the index'th element of x. |
| // |
| // A non-constant value of index may result in significantly worse performance for this operation. |
| // |
| // Asm: VMOV, CPU Feature: NEON |
| func (x Int16x8) GetElem(index uint8) int16 |
| |
| // GetElem returns the index'th element of x. |
| // |
| // A non-constant value of index may result in significantly worse performance for this operation. |
| // |
| // Asm: VMOV, CPU Feature: NEON |
| func (x Int32x4) GetElem(index uint8) int32 |
| |
| // GetElem returns the index'th element of x. |
| // |
| // A non-constant value of index may result in significantly worse performance for this operation. |
| // |
| // Asm: VMOV, CPU Feature: NEON |
| func (x Int64x2) GetElem(index uint8) int64 |
| |
| // GetElem returns the index'th element of x. |
| // |
| // A non-constant value of index may result in significantly worse performance for this operation. |
| // |
| // Asm: VMOV, CPU Feature: NEON |
| func (x Uint8x16) GetElem(index uint8) uint8 |
| |
| // GetElem returns the index'th element of x. |
| // |
| // A non-constant value of index may result in significantly worse performance for this operation. |
| // |
| // Asm: VMOV, CPU Feature: NEON |
| func (x Uint16x8) GetElem(index uint8) uint16 |
| |
| // GetElem returns the index'th element of x. |
| // |
| // A non-constant value of index may result in significantly worse performance for this operation. |
| // |
| // Asm: VMOV, CPU Feature: NEON |
| func (x Uint32x4) GetElem(index uint8) uint32 |
| |
| // GetElem returns the index'th element of x. |
| // |
| // A non-constant value of index may result in significantly worse performance for this operation. |
| // |
| // Asm: VMOV, CPU Feature: NEON |
| func (x Uint64x2) GetElem(index uint8) uint64 |
| |
| /* Greater */ |
| |
| // Greater returns a mask whose elements indicate whether x > y. |
| // |
| // Asm: VFCMGT, CPU Feature: NEON |
| func (x Float32x4) Greater(y Float32x4) Mask32x4 |
| |
| // Greater returns a mask whose elements indicate whether x > y. |
| // |
| // Asm: VFCMGT, CPU Feature: NEON |
| func (x Float64x2) Greater(y Float64x2) Mask64x2 |
| |
| // Greater returns a mask whose elements indicate whether x > y. |
| // |
| // Asm: VCMGT, CPU Feature: NEON |
| func (x Int8x16) Greater(y Int8x16) Mask8x16 |
| |
| // Greater returns a mask whose elements indicate whether x > y. |
| // |
| // Asm: VCMGT, CPU Feature: NEON |
| func (x Int16x8) Greater(y Int16x8) Mask16x8 |
| |
| // Greater returns a mask whose elements indicate whether x > y. |
| // |
| // Asm: VCMGT, CPU Feature: NEON |
| func (x Int32x4) Greater(y Int32x4) Mask32x4 |
| |
| // Greater returns a mask whose elements indicate whether x > y. |
| // |
| // Asm: VCMGT, CPU Feature: NEON |
| func (x Int64x2) Greater(y Int64x2) Mask64x2 |
| |
| // Greater returns a mask whose elements indicate whether x > y. |
| // |
| // Asm: VCMHI, CPU Feature: NEON |
| func (x Uint8x16) Greater(y Uint8x16) Mask8x16 |
| |
| // Greater returns a mask whose elements indicate whether x > y. |
| // |
| // Asm: VCMHI, CPU Feature: NEON |
| func (x Uint16x8) Greater(y Uint16x8) Mask16x8 |
| |
| // Greater returns a mask whose elements indicate whether x > y. |
| // |
| // Asm: VCMHI, CPU Feature: NEON |
| func (x Uint32x4) Greater(y Uint32x4) Mask32x4 |
| |
| // Greater returns a mask whose elements indicate whether x > y. |
| // |
| // Asm: VCMHI, CPU Feature: NEON |
| func (x Uint64x2) Greater(y Uint64x2) Mask64x2 |
| |
| /* GreaterEqual */ |
| |
| // GreaterEqual returns a mask whose elements indicate whether x >= y. |
| // |
| // Asm: VFCMGE, CPU Feature: NEON |
| func (x Float32x4) GreaterEqual(y Float32x4) Mask32x4 |
| |
| // GreaterEqual returns a mask whose elements indicate whether x >= y. |
| // |
| // Asm: VFCMGE, CPU Feature: NEON |
| func (x Float64x2) GreaterEqual(y Float64x2) Mask64x2 |
| |
| // GreaterEqual returns a mask whose elements indicate whether x >= y. |
| // |
| // Asm: VCMGE, CPU Feature: NEON |
| func (x Int8x16) GreaterEqual(y Int8x16) Mask8x16 |
| |
| // GreaterEqual returns a mask whose elements indicate whether x >= y. |
| // |
| // Asm: VCMGE, CPU Feature: NEON |
| func (x Int16x8) GreaterEqual(y Int16x8) Mask16x8 |
| |
| // GreaterEqual returns a mask whose elements indicate whether x >= y. |
| // |
| // Asm: VCMGE, CPU Feature: NEON |
| func (x Int32x4) GreaterEqual(y Int32x4) Mask32x4 |
| |
| // GreaterEqual returns a mask whose elements indicate whether x >= y. |
| // |
| // Asm: VCMGE, CPU Feature: NEON |
| func (x Int64x2) GreaterEqual(y Int64x2) Mask64x2 |
| |
| // GreaterEqual returns a mask whose elements indicate whether x >= y. |
| // |
| // Asm: VCMHS, CPU Feature: NEON |
| func (x Uint8x16) GreaterEqual(y Uint8x16) Mask8x16 |
| |
| // GreaterEqual returns a mask whose elements indicate whether x >= y. |
| // |
| // Asm: VCMHS, CPU Feature: NEON |
| func (x Uint16x8) GreaterEqual(y Uint16x8) Mask16x8 |
| |
| // GreaterEqual returns a mask whose elements indicate whether x >= y. |
| // |
| // Asm: VCMHS, CPU Feature: NEON |
| func (x Uint32x4) GreaterEqual(y Uint32x4) Mask32x4 |
| |
| // GreaterEqual returns a mask whose elements indicate whether x >= y. |
| // |
| // Asm: VCMHS, CPU Feature: NEON |
| func (x Uint64x2) GreaterEqual(y Uint64x2) Mask64x2 |
| |
| /* InterleaveEven */ |
| |
| // InterleaveEven interleaves even elements from x and y. |
| // For x = [a0,a1,a2,a3] and y = [b0,b1,b2,b3], result = [a0,b0,a2,b2]. |
| // |
| // Asm: VTRN1, CPU Feature: NEON |
| func (x Int8x16) InterleaveEven(y Int8x16) Int8x16 |
| |
| // InterleaveEven interleaves even elements from x and y. |
| // For x = [a0,a1,a2,a3] and y = [b0,b1,b2,b3], result = [a0,b0,a2,b2]. |
| // |
| // Asm: VTRN1, CPU Feature: NEON |
| func (x Int16x8) InterleaveEven(y Int16x8) Int16x8 |
| |
| // InterleaveEven interleaves even elements from x and y. |
| // For x = [a0,a1,a2,a3] and y = [b0,b1,b2,b3], result = [a0,b0,a2,b2]. |
| // |
| // Asm: VTRN1, CPU Feature: NEON |
| func (x Int32x4) InterleaveEven(y Int32x4) Int32x4 |
| |
| // InterleaveEven interleaves even elements from x and y. |
| // For x = [a0,a1,a2,a3] and y = [b0,b1,b2,b3], result = [a0,b0,a2,b2]. |
| // |
| // Asm: VTRN1, CPU Feature: NEON |
| func (x Int64x2) InterleaveEven(y Int64x2) Int64x2 |
| |
| // InterleaveEven interleaves even elements from x and y. |
| // For x = [a0,a1,a2,a3] and y = [b0,b1,b2,b3], result = [a0,b0,a2,b2]. |
| // |
| // Asm: VTRN1, CPU Feature: NEON |
| func (x Uint8x16) InterleaveEven(y Uint8x16) Uint8x16 |
| |
| // InterleaveEven interleaves even elements from x and y. |
| // For x = [a0,a1,a2,a3] and y = [b0,b1,b2,b3], result = [a0,b0,a2,b2]. |
| // |
| // Asm: VTRN1, CPU Feature: NEON |
| func (x Uint16x8) InterleaveEven(y Uint16x8) Uint16x8 |
| |
| // InterleaveEven interleaves even elements from x and y. |
| // For x = [a0,a1,a2,a3] and y = [b0,b1,b2,b3], result = [a0,b0,a2,b2]. |
| // |
| // Asm: VTRN1, CPU Feature: NEON |
| func (x Uint32x4) InterleaveEven(y Uint32x4) Uint32x4 |
| |
| // InterleaveEven interleaves even elements from x and y. |
| // For x = [a0,a1,a2,a3] and y = [b0,b1,b2,b3], result = [a0,b0,a2,b2]. |
| // |
| // Asm: VTRN1, CPU Feature: NEON |
| func (x Uint64x2) InterleaveEven(y Uint64x2) Uint64x2 |
| |
| /* InterleaveHi */ |
| |
| // InterleaveHi interleaves the elements of the high halves of x and y. |
| // |
| // Asm: VZIP2, CPU Feature: NEON |
| func (x Int8x16) InterleaveHi(y Int8x16) Int8x16 |
| |
| // InterleaveHi interleaves the elements of the high halves of x and y. |
| // |
| // Asm: VZIP2, CPU Feature: NEON |
| func (x Int16x8) InterleaveHi(y Int16x8) Int16x8 |
| |
| // InterleaveHi interleaves the elements of the high halves of x and y. |
| // |
| // Asm: VZIP2, CPU Feature: NEON |
| func (x Int32x4) InterleaveHi(y Int32x4) Int32x4 |
| |
| // InterleaveHi interleaves the elements of the high halves of x and y. |
| // |
| // Asm: VZIP2, CPU Feature: NEON |
| func (x Int64x2) InterleaveHi(y Int64x2) Int64x2 |
| |
| // InterleaveHi interleaves the elements of the high halves of x and y. |
| // |
| // Asm: VZIP2, CPU Feature: NEON |
| func (x Uint8x16) InterleaveHi(y Uint8x16) Uint8x16 |
| |
| // InterleaveHi interleaves the elements of the high halves of x and y. |
| // |
| // Asm: VZIP2, CPU Feature: NEON |
| func (x Uint16x8) InterleaveHi(y Uint16x8) Uint16x8 |
| |
| // InterleaveHi interleaves the elements of the high halves of x and y. |
| // |
| // Asm: VZIP2, CPU Feature: NEON |
| func (x Uint32x4) InterleaveHi(y Uint32x4) Uint32x4 |
| |
| // InterleaveHi interleaves the elements of the high halves of x and y. |
| // |
| // Asm: VZIP2, CPU Feature: NEON |
| func (x Uint64x2) InterleaveHi(y Uint64x2) Uint64x2 |
| |
| /* InterleaveLo */ |
| |
| // InterleaveLo interleaves the elements of the low halves of x and y. |
| // |
| // Asm: VZIP1, CPU Feature: NEON |
| func (x Int8x16) InterleaveLo(y Int8x16) Int8x16 |
| |
| // InterleaveLo interleaves the elements of the low halves of x and y. |
| // |
| // Asm: VZIP1, CPU Feature: NEON |
| func (x Int16x8) InterleaveLo(y Int16x8) Int16x8 |
| |
| // InterleaveLo interleaves the elements of the low halves of x and y. |
| // |
| // Asm: VZIP1, CPU Feature: NEON |
| func (x Int32x4) InterleaveLo(y Int32x4) Int32x4 |
| |
| // InterleaveLo interleaves the elements of the low halves of x and y. |
| // |
| // Asm: VZIP1, CPU Feature: NEON |
| func (x Int64x2) InterleaveLo(y Int64x2) Int64x2 |
| |
| // InterleaveLo interleaves the elements of the low halves of x and y. |
| // |
| // Asm: VZIP1, CPU Feature: NEON |
| func (x Uint8x16) InterleaveLo(y Uint8x16) Uint8x16 |
| |
| // InterleaveLo interleaves the elements of the low halves of x and y. |
| // |
| // Asm: VZIP1, CPU Feature: NEON |
| func (x Uint16x8) InterleaveLo(y Uint16x8) Uint16x8 |
| |
| // InterleaveLo interleaves the elements of the low halves of x and y. |
| // |
| // Asm: VZIP1, CPU Feature: NEON |
| func (x Uint32x4) InterleaveLo(y Uint32x4) Uint32x4 |
| |
| // InterleaveLo interleaves the elements of the low halves of x and y. |
| // |
| // Asm: VZIP1, CPU Feature: NEON |
| func (x Uint64x2) InterleaveLo(y Uint64x2) Uint64x2 |
| |
| /* InterleaveOdd */ |
| |
| // InterleaveOdd interleaves odd elements from x and y. |
| // For x = [a0,a1,a2,a3] and y = [b0,b1,b2,b3], result = [a1,b1,a3,b3]. |
| // |
| // Asm: VTRN2, CPU Feature: NEON |
| func (x Int8x16) InterleaveOdd(y Int8x16) Int8x16 |
| |
| // InterleaveOdd interleaves odd elements from x and y. |
| // For x = [a0,a1,a2,a3] and y = [b0,b1,b2,b3], result = [a1,b1,a3,b3]. |
| // |
| // Asm: VTRN2, CPU Feature: NEON |
| func (x Int16x8) InterleaveOdd(y Int16x8) Int16x8 |
| |
| // InterleaveOdd interleaves odd elements from x and y. |
| // For x = [a0,a1,a2,a3] and y = [b0,b1,b2,b3], result = [a1,b1,a3,b3]. |
| // |
| // Asm: VTRN2, CPU Feature: NEON |
| func (x Int32x4) InterleaveOdd(y Int32x4) Int32x4 |
| |
| // InterleaveOdd interleaves odd elements from x and y. |
| // For x = [a0,a1,a2,a3] and y = [b0,b1,b2,b3], result = [a1,b1,a3,b3]. |
| // |
| // Asm: VTRN2, CPU Feature: NEON |
| func (x Int64x2) InterleaveOdd(y Int64x2) Int64x2 |
| |
| // InterleaveOdd interleaves odd elements from x and y. |
| // For x = [a0,a1,a2,a3] and y = [b0,b1,b2,b3], result = [a1,b1,a3,b3]. |
| // |
| // Asm: VTRN2, CPU Feature: NEON |
| func (x Uint8x16) InterleaveOdd(y Uint8x16) Uint8x16 |
| |
| // InterleaveOdd interleaves odd elements from x and y. |
| // For x = [a0,a1,a2,a3] and y = [b0,b1,b2,b3], result = [a1,b1,a3,b3]. |
| // |
| // Asm: VTRN2, CPU Feature: NEON |
| func (x Uint16x8) InterleaveOdd(y Uint16x8) Uint16x8 |
| |
| // InterleaveOdd interleaves odd elements from x and y. |
| // For x = [a0,a1,a2,a3] and y = [b0,b1,b2,b3], result = [a1,b1,a3,b3]. |
| // |
| // Asm: VTRN2, CPU Feature: NEON |
| func (x Uint32x4) InterleaveOdd(y Uint32x4) Uint32x4 |
| |
| // InterleaveOdd interleaves odd elements from x and y. |
| // For x = [a0,a1,a2,a3] and y = [b0,b1,b2,b3], result = [a1,b1,a3,b3]. |
| // |
| // Asm: VTRN2, CPU Feature: NEON |
| func (x Uint64x2) InterleaveOdd(y Uint64x2) Uint64x2 |
| |
| /* LeadingSignBits */ |
| |
| // LeadingSignBits counts the leading sign bits of each element in x. |
| // |
| // Asm: VCLS, CPU Feature: NEON |
| func (x Int8x16) LeadingSignBits() Int8x16 |
| |
| // LeadingSignBits counts the leading sign bits of each element in x. |
| // |
| // Asm: VCLS, CPU Feature: NEON |
| func (x Int16x8) LeadingSignBits() Int16x8 |
| |
| // LeadingSignBits counts the leading sign bits of each element in x. |
| // |
| // Asm: VCLS, CPU Feature: NEON |
| func (x Int32x4) LeadingSignBits() Int32x4 |
| |
| // LeadingSignBits counts the leading sign bits of each element in x. |
| // |
| // Asm: VCLS, CPU Feature: NEON |
| func (x Uint8x16) LeadingSignBits() Uint8x16 |
| |
| // LeadingSignBits counts the leading sign bits of each element in x. |
| // |
| // Asm: VCLS, CPU Feature: NEON |
| func (x Uint16x8) LeadingSignBits() Uint16x8 |
| |
| // LeadingSignBits counts the leading sign bits of each element in x. |
| // |
| // Asm: VCLS, CPU Feature: NEON |
| func (x Uint32x4) LeadingSignBits() Uint32x4 |
| |
| /* LeadingZeros */ |
| |
| // LeadingZeros counts the leading zeros of each element in x. |
| // |
| // Asm: VCLZ, CPU Feature: NEON |
| func (x Int8x16) LeadingZeros() Int8x16 |
| |
| // LeadingZeros counts the leading zeros of each element in x. |
| // |
| // Asm: VCLZ, CPU Feature: NEON |
| func (x Int16x8) LeadingZeros() Int16x8 |
| |
| // LeadingZeros counts the leading zeros of each element in x. |
| // |
| // Asm: VCLZ, CPU Feature: NEON |
| func (x Int32x4) LeadingZeros() Int32x4 |
| |
| // LeadingZeros counts the leading zeros of each element in x. |
| // |
| // Asm: VCLZ, CPU Feature: NEON |
| func (x Uint8x16) LeadingZeros() Uint8x16 |
| |
| // LeadingZeros counts the leading zeros of each element in x. |
| // |
| // Asm: VCLZ, CPU Feature: NEON |
| func (x Uint16x8) LeadingZeros() Uint16x8 |
| |
| // LeadingZeros counts the leading zeros of each element in x. |
| // |
| // Asm: VCLZ, CPU Feature: NEON |
| func (x Uint32x4) LeadingZeros() Uint32x4 |
| |
| /* LookupOrZero */ |
| |
| // LookupOrZero looks up table. If an index is out of range, the result is 0. |
| // |
| // if 0 <= indices[i] && indices[i] < len(table) { |
| // result[i] = table[indices[i]] |
| // } else { |
| // result[i] = 0 |
| // } |
| // |
| // Asm: VTBL, CPU Feature: NEON |
| func (table Int8x16) LookupOrZero(indices Int8x16) Int8x16 |
| |
| // LookupOrZero looks up table. If an index is out of range, the result is 0. |
| // |
| // if 0 <= indices[i] && indices[i] < len(table) { |
| // result[i] = table[indices[i]] |
| // } else { |
| // result[i] = 0 |
| // } |
| // |
| // Asm: VTBL, CPU Feature: NEON |
| func (table Uint8x16) LookupOrZero(indices Uint8x16) Uint8x16 |
| |
| /* Max */ |
| |
| // Max computes the maximum of each pair of corresponding elements in x and y. |
| // |
| // Asm: VFMAX, CPU Feature: NEON |
| func (x Float32x4) Max(y Float32x4) Float32x4 |
| |
| // Max computes the maximum of each pair of corresponding elements in x and y. |
| // |
| // Asm: VFMAX, CPU Feature: NEON |
| func (x Float64x2) Max(y Float64x2) Float64x2 |
| |
| // Max computes the maximum of each pair of corresponding elements in x and y. |
| // |
| // Asm: VSMAX, CPU Feature: NEON |
| func (x Int8x16) Max(y Int8x16) Int8x16 |
| |
| // Max computes the maximum of each pair of corresponding elements in x and y. |
| // |
| // Asm: VSMAX, CPU Feature: NEON |
| func (x Int16x8) Max(y Int16x8) Int16x8 |
| |
| // Max computes the maximum of each pair of corresponding elements in x and y. |
| // |
| // Asm: VSMAX, CPU Feature: NEON |
| func (x Int32x4) Max(y Int32x4) Int32x4 |
| |
| // Max computes the maximum of each pair of corresponding elements in x and y. |
| // |
| // Asm: VUMAX, CPU Feature: NEON |
| func (x Uint8x16) Max(y Uint8x16) Uint8x16 |
| |
| // Max computes the maximum of each pair of corresponding elements in x and y. |
| // |
| // Asm: VUMAX, CPU Feature: NEON |
| func (x Uint16x8) Max(y Uint16x8) Uint16x8 |
| |
| // Max computes the maximum of each pair of corresponding elements in x and y. |
| // |
| // Asm: VUMAX, CPU Feature: NEON |
| func (x Uint32x4) Max(y Uint32x4) Uint32x4 |
| |
| /* Min */ |
| |
| // Min computes the minimum of each pair of corresponding elements in x and y. |
| // |
| // Asm: VFMIN, CPU Feature: NEON |
| func (x Float32x4) Min(y Float32x4) Float32x4 |
| |
| // Min computes the minimum of each pair of corresponding elements in x and y. |
| // |
| // Asm: VFMIN, CPU Feature: NEON |
| func (x Float64x2) Min(y Float64x2) Float64x2 |
| |
| // Min computes the minimum of each pair of corresponding elements in x and y. |
| // |
| // Asm: VSMIN, CPU Feature: NEON |
| func (x Int8x16) Min(y Int8x16) Int8x16 |
| |
| // Min computes the minimum of each pair of corresponding elements in x and y. |
| // |
| // Asm: VSMIN, CPU Feature: NEON |
| func (x Int16x8) Min(y Int16x8) Int16x8 |
| |
| // Min computes the minimum of each pair of corresponding elements in x and y. |
| // |
| // Asm: VSMIN, CPU Feature: NEON |
| func (x Int32x4) Min(y Int32x4) Int32x4 |
| |
| // Min computes the minimum of each pair of corresponding elements in x and y. |
| // |
| // Asm: VUMIN, CPU Feature: NEON |
| func (x Uint8x16) Min(y Uint8x16) Uint8x16 |
| |
| // Min computes the minimum of each pair of corresponding elements in x and y. |
| // |
| // Asm: VUMIN, CPU Feature: NEON |
| func (x Uint16x8) Min(y Uint16x8) Uint16x8 |
| |
| // Min computes the minimum of each pair of corresponding elements in x and y. |
| // |
| // Asm: VUMIN, CPU Feature: NEON |
| func (x Uint32x4) Min(y Uint32x4) Uint32x4 |
| |
| /* Mul */ |
| |
| // Mul multiplies corresponding elements of two vectors, modulo 2ⁿ. |
| // |
| // Asm: VFMUL, CPU Feature: NEON |
| func (x Float32x4) Mul(y Float32x4) Float32x4 |
| |
| // Mul multiplies corresponding elements of two vectors, modulo 2ⁿ. |
| // |
| // Asm: VFMUL, CPU Feature: NEON |
| func (x Float64x2) Mul(y Float64x2) Float64x2 |
| |
| // Mul multiplies corresponding elements of two vectors, modulo 2ⁿ. |
| // |
| // Asm: VMUL, CPU Feature: NEON |
| func (x Int8x16) Mul(y Int8x16) Int8x16 |
| |
| // Mul multiplies corresponding elements of two vectors, modulo 2ⁿ. |
| // |
| // Asm: VMUL, CPU Feature: NEON |
| func (x Int16x8) Mul(y Int16x8) Int16x8 |
| |
| // Mul multiplies corresponding elements of two vectors, modulo 2ⁿ. |
| // |
| // Asm: VMUL, CPU Feature: NEON |
| func (x Int32x4) Mul(y Int32x4) Int32x4 |
| |
| // Mul multiplies corresponding elements of two vectors, modulo 2ⁿ. |
| // |
| // Asm: VMUL, CPU Feature: NEON |
| func (x Uint8x16) Mul(y Uint8x16) Uint8x16 |
| |
| // Mul multiplies corresponding elements of two vectors, modulo 2ⁿ. |
| // |
| // Asm: VMUL, CPU Feature: NEON |
| func (x Uint16x8) Mul(y Uint16x8) Uint16x8 |
| |
| // Mul multiplies corresponding elements of two vectors, modulo 2ⁿ. |
| // |
| // Asm: VMUL, CPU Feature: NEON |
| func (x Uint32x4) Mul(y Uint32x4) Uint32x4 |
| |
| /* MulAdd */ |
| |
| // MulAdd performs a fused (x * y) + z. |
| // |
| // Asm: VFMLA, CPU Feature: NEON |
| func (x Float32x4) MulAdd(y Float32x4, z Float32x4) Float32x4 |
| |
| // MulAdd performs a fused (x * y) + z. |
| // |
| // Asm: VFMLA, CPU Feature: NEON |
| func (x Float64x2) MulAdd(y Float64x2, z Float64x2) Float64x2 |
| |
| // MulAdd computes (x * y) + z. |
| // |
| // Asm: VMLA, CPU Feature: NEON |
| func (x Int8x16) MulAdd(y Int8x16, z Int8x16) Int8x16 |
| |
| // MulAdd computes (x * y) + z. |
| // |
| // Asm: VMLA, CPU Feature: NEON |
| func (x Int16x8) MulAdd(y Int16x8, z Int16x8) Int16x8 |
| |
| // MulAdd computes (x * y) + z. |
| // |
| // Asm: VMLA, CPU Feature: NEON |
| func (x Int32x4) MulAdd(y Int32x4, z Int32x4) Int32x4 |
| |
| // MulAdd computes (x * y) + z. |
| // |
| // Asm: VMLA, CPU Feature: NEON |
| func (x Uint8x16) MulAdd(y Uint8x16, z Uint8x16) Uint8x16 |
| |
| // MulAdd computes (x * y) + z. |
| // |
| // Asm: VMLA, CPU Feature: NEON |
| func (x Uint16x8) MulAdd(y Uint16x8, z Uint16x8) Uint16x8 |
| |
| // MulAdd computes (x * y) + z. |
| // |
| // Asm: VMLA, CPU Feature: NEON |
| func (x Uint32x4) MulAdd(y Uint32x4, z Uint32x4) Uint32x4 |
| |
| /* MulWidenLo */ |
| |
| // MulWidenLo multiplies corresponding low-indexed elements and produces a result with double the element width. |
| // For the high-indexed elements, use HiToLo: |
| // |
| // x.HiToLo().MulWidenLo(y.HiToLo()) |
| // |
| // Asm: VSMULL, CPU Feature: NEON |
| func (x Int8x16) MulWidenLo(y Int8x16) Int16x8 |
| |
| // MulWidenLo multiplies corresponding low-indexed elements and produces a result with double the element width. |
| // For the high-indexed elements, use HiToLo: |
| // |
| // x.HiToLo().MulWidenLo(y.HiToLo()) |
| // |
| // Asm: VSMULL, CPU Feature: NEON |
| func (x Int16x8) MulWidenLo(y Int16x8) Int32x4 |
| |
| // MulWidenLo multiplies corresponding low-indexed elements and produces a result with double the element width. |
| // For the high-indexed elements, use HiToLo: |
| // |
| // x.HiToLo().MulWidenLo(y.HiToLo()) |
| // |
| // Asm: VSMULL, CPU Feature: NEON |
| func (x Int32x4) MulWidenLo(y Int32x4) Int64x2 |
| |
| // MulWidenLo multiplies corresponding low-indexed elements and produces a result with double the element width. |
| // For the high-indexed elements, use HiToLo: |
| // |
| // x.HiToLo().MulWidenLo(y.HiToLo()) |
| // |
| // Asm: VUMULL, CPU Feature: NEON |
| func (x Uint8x16) MulWidenLo(y Uint8x16) Uint16x8 |
| |
| // MulWidenLo multiplies corresponding low-indexed elements and produces a result with double the element width. |
| // For the high-indexed elements, use HiToLo: |
| // |
| // x.HiToLo().MulWidenLo(y.HiToLo()) |
| // |
| // Asm: VUMULL, CPU Feature: NEON |
| func (x Uint16x8) MulWidenLo(y Uint16x8) Uint32x4 |
| |
| // MulWidenLo multiplies corresponding low-indexed elements and produces a result with double the element width. |
| // For the high-indexed elements, use HiToLo: |
| // |
| // x.HiToLo().MulWidenLo(y.HiToLo()) |
| // |
| // Asm: VUMULL, CPU Feature: NEON |
| func (x Uint32x4) MulWidenLo(y Uint32x4) Uint64x2 |
| |
| /* Neg */ |
| |
| // Neg returns the elementwise negation of x. |
| // |
| // Asm: VFNEG, CPU Feature: NEON |
| func (x Float32x4) Neg() Float32x4 |
| |
| // Neg returns the elementwise negation of x. |
| // |
| // Asm: VFNEG, CPU Feature: NEON |
| func (x Float64x2) Neg() Float64x2 |
| |
| // Neg returns the elementwise negation of x. |
| // |
| // Asm: VNEG, CPU Feature: NEON |
| func (x Int8x16) Neg() Int8x16 |
| |
| // Neg returns the elementwise negation of x. |
| // |
| // Asm: VNEG, CPU Feature: NEON |
| func (x Int16x8) Neg() Int16x8 |
| |
| // Neg returns the elementwise negation of x. |
| // |
| // Asm: VNEG, CPU Feature: NEON |
| func (x Int32x4) Neg() Int32x4 |
| |
| // Neg returns the elementwise negation of x. |
| // |
| // Asm: VNEG, CPU Feature: NEON |
| func (x Int64x2) Neg() Int64x2 |
| |
| /* Not */ |
| |
| // Not returns the bitwise complement of x. |
| // |
| // Asm: VNOT, CPU Feature: NEON |
| func (x Int8x16) Not() Int8x16 |
| |
| // Not returns the bitwise complement of x. |
| // |
| // Asm: VNOT, CPU Feature: NEON |
| func (x Int16x8) Not() Int16x8 |
| |
| // Not returns the bitwise complement of x. |
| // |
| // Asm: VNOT, CPU Feature: NEON |
| func (x Int32x4) Not() Int32x4 |
| |
| // Not returns the bitwise complement of x. |
| // |
| // Asm: VNOT, CPU Feature: NEON |
| func (x Int64x2) Not() Int64x2 |
| |
| // Not returns the bitwise complement of x. |
| // |
| // Asm: VNOT, CPU Feature: NEON |
| func (x Uint8x16) Not() Uint8x16 |
| |
| // Not returns the bitwise complement of x. |
| // |
| // Asm: VNOT, CPU Feature: NEON |
| func (x Uint16x8) Not() Uint16x8 |
| |
| // Not returns the bitwise complement of x. |
| // |
| // Asm: VNOT, CPU Feature: NEON |
| func (x Uint32x4) Not() Uint32x4 |
| |
| // Not returns the bitwise complement of x. |
| // |
| // Asm: VNOT, CPU Feature: NEON |
| func (x Uint64x2) Not() Uint64x2 |
| |
| /* OnesCount */ |
| |
| // OnesCount counts the number of set bits in each element. |
| // |
| // Asm: VCNT, CPU Feature: NEON |
| func (x Int8x16) OnesCount() Int8x16 |
| |
| // OnesCount counts the number of set bits in each element. |
| // |
| // Asm: VCNT, CPU Feature: NEON |
| func (x Uint8x16) OnesCount() Uint8x16 |
| |
| /* Or */ |
| |
| // Or performs a bitwise x | y. |
| // |
| // Asm: VORR, CPU Feature: NEON |
| func (x Int8x16) Or(y Int8x16) Int8x16 |
| |
| // Or performs a bitwise x | y. |
| // |
| // Asm: VORR, CPU Feature: NEON |
| func (x Int16x8) Or(y Int16x8) Int16x8 |
| |
| // Or performs a bitwise x | y. |
| // |
| // Asm: VORR, CPU Feature: NEON |
| func (x Int32x4) Or(y Int32x4) Int32x4 |
| |
| // Or performs a bitwise x | y. |
| // |
| // Asm: VORR, CPU Feature: NEON |
| func (x Int64x2) Or(y Int64x2) Int64x2 |
| |
| // Or performs a bitwise x | y. |
| // |
| // Asm: VORR, CPU Feature: NEON |
| func (x Uint8x16) Or(y Uint8x16) Uint8x16 |
| |
| // Or performs a bitwise x | y. |
| // |
| // Asm: VORR, CPU Feature: NEON |
| func (x Uint16x8) Or(y Uint16x8) Uint16x8 |
| |
| // Or performs a bitwise x | y. |
| // |
| // Asm: VORR, CPU Feature: NEON |
| func (x Uint32x4) Or(y Uint32x4) Uint32x4 |
| |
| // Or performs a bitwise x | y. |
| // |
| // Asm: VORR, CPU Feature: NEON |
| func (x Uint64x2) Or(y Uint64x2) Uint64x2 |
| |
| /* OrNot */ |
| |
| // OrNot performs a bitwise x | ^y. |
| // |
| // Asm: VORN, CPU Feature: NEON |
| func (x Int8x16) OrNot(y Int8x16) Int8x16 |
| |
| // OrNot performs a bitwise x | ^y. |
| // |
| // Asm: VORN, CPU Feature: NEON |
| func (x Int16x8) OrNot(y Int16x8) Int16x8 |
| |
| // OrNot performs a bitwise x | ^y. |
| // |
| // Asm: VORN, CPU Feature: NEON |
| func (x Int32x4) OrNot(y Int32x4) Int32x4 |
| |
| // OrNot performs a bitwise x | ^y. |
| // |
| // Asm: VORN, CPU Feature: NEON |
| func (x Int64x2) OrNot(y Int64x2) Int64x2 |
| |
| // OrNot performs a bitwise x | ^y. |
| // |
| // Asm: VORN, CPU Feature: NEON |
| func (x Uint8x16) OrNot(y Uint8x16) Uint8x16 |
| |
| // OrNot performs a bitwise x | ^y. |
| // |
| // Asm: VORN, CPU Feature: NEON |
| func (x Uint16x8) OrNot(y Uint16x8) Uint16x8 |
| |
| // OrNot performs a bitwise x | ^y. |
| // |
| // Asm: VORN, CPU Feature: NEON |
| func (x Uint32x4) OrNot(y Uint32x4) Uint32x4 |
| |
| // OrNot performs a bitwise x | ^y. |
| // |
| // Asm: VORN, CPU Feature: NEON |
| func (x Uint64x2) OrNot(y Uint64x2) Uint64x2 |
| |
| /* Round */ |
| |
| // Round rounds elements to the nearest integer, rounding ties to even. |
| // |
| // Asm: VFRINTN, CPU Feature: NEON |
| func (x Float32x4) Round() Float32x4 |
| |
| // Round rounds elements to the nearest integer, rounding ties to even. |
| // |
| // Asm: VFRINTN, CPU Feature: NEON |
| func (x Float64x2) Round() Float64x2 |
| |
| /* SaturateToInt8 */ |
| |
| // SaturateToInt8 converts element values to int8 with signed saturation. |
| // Results are packed to low elements in the returned vector, its upper elements are zeroed. |
| // |
| // Asm: VSQXTN, CPU Feature: NEON |
| func (x Int16x8) SaturateToInt8() Int8x16 |
| |
| /* SaturateToInt16 */ |
| |
| // SaturateToInt16 converts element values to int16 with signed saturation. |
| // Results are packed to low elements in the returned vector, its upper elements are zeroed. |
| // |
| // Asm: VSQXTN, CPU Feature: NEON |
| func (x Int32x4) SaturateToInt16() Int16x8 |
| |
| /* SaturateToInt32 */ |
| |
| // SaturateToInt32 converts element values to int32 with signed saturation. |
| // Results are packed to low elements in the returned vector, its upper elements are zeroed. |
| // |
| // Asm: VSQXTN, CPU Feature: NEON |
| func (x Int64x2) SaturateToInt32() Int32x4 |
| |
| /* SaturateToUint8 */ |
| |
| // SaturateToUint8 converts element values to uint8 with unsigned saturation. |
| // Results are packed to low elements in the returned vector, its upper elements are zeroed. |
| // |
| // Asm: VSQXTUN, CPU Feature: NEON |
| func (x Int16x8) SaturateToUint8() Uint8x16 |
| |
| // SaturateToUint8 converts element values to uint8 with unsigned saturation. |
| // Results are packed to low elements in the returned vector, its upper elements are zeroed. |
| // |
| // Asm: VUQXTN, CPU Feature: NEON |
| func (x Uint16x8) SaturateToUint8() Uint8x16 |
| |
| /* SaturateToUint16 */ |
| |
| // SaturateToUint16 converts element values to uint16 with unsigned saturation. |
| // Results are packed to low elements in the returned vector, its upper elements are zeroed. |
| // |
| // Asm: VSQXTUN, CPU Feature: NEON |
| func (x Int32x4) SaturateToUint16() Uint16x8 |
| |
| // SaturateToUint16 converts element values to uint16 with unsigned saturation. |
| // Results are packed to low elements in the returned vector, its upper elements are zeroed. |
| // |
| // Asm: VUQXTN, CPU Feature: NEON |
| func (x Uint32x4) SaturateToUint16() Uint16x8 |
| |
| /* SaturateToUint32 */ |
| |
| // SaturateToUint32 converts element values to uint32 with unsigned saturation. |
| // Results are packed to low elements in the returned vector, its upper elements are zeroed. |
| // |
| // Asm: VSQXTUN, CPU Feature: NEON |
| func (x Int64x2) SaturateToUint32() Uint32x4 |
| |
| // SaturateToUint32 converts element values to uint32 with unsigned saturation. |
| // Results are packed to low elements in the returned vector, its upper elements are zeroed. |
| // |
| // Asm: VUQXTN, CPU Feature: NEON |
| func (x Uint64x2) SaturateToUint32() Uint32x4 |
| |
| /* SetElem */ |
| |
| // SetElem returns x with the index'th element set to y. |
| // |
| // A non-constant value of index may result in significantly worse performance for this operation. |
| // |
| // Asm: VMOV, CPU Feature: NEON |
| func (x Int8x16) SetElem(index uint8, y int8) Int8x16 |
| |
| // SetElem returns x with the index'th element set to y. |
| // |
| // A non-constant value of index may result in significantly worse performance for this operation. |
| // |
| // Asm: VMOV, CPU Feature: NEON |
| func (x Int16x8) SetElem(index uint8, y int16) Int16x8 |
| |
| // SetElem returns x with the index'th element set to y. |
| // |
| // A non-constant value of index may result in significantly worse performance for this operation. |
| // |
| // Asm: VMOV, CPU Feature: NEON |
| func (x Int32x4) SetElem(index uint8, y int32) Int32x4 |
| |
| // SetElem returns x with the index'th element set to y. |
| // |
| // A non-constant value of index may result in significantly worse performance for this operation. |
| // |
| // Asm: VMOV, CPU Feature: NEON |
| func (x Int64x2) SetElem(index uint8, y int64) Int64x2 |
| |
| // SetElem returns x with the index'th element set to y. |
| // |
| // A non-constant value of index may result in significantly worse performance for this operation. |
| // |
| // Asm: VMOV, CPU Feature: NEON |
| func (x Uint8x16) SetElem(index uint8, y uint8) Uint8x16 |
| |
| // SetElem returns x with the index'th element set to y. |
| // |
| // A non-constant value of index may result in significantly worse performance for this operation. |
| // |
| // Asm: VMOV, CPU Feature: NEON |
| func (x Uint16x8) SetElem(index uint8, y uint16) Uint16x8 |
| |
| // SetElem returns x with the index'th element set to y. |
| // |
| // A non-constant value of index may result in significantly worse performance for this operation. |
| // |
| // Asm: VMOV, CPU Feature: NEON |
| func (x Uint32x4) SetElem(index uint8, y uint32) Uint32x4 |
| |
| // SetElem returns x with the index'th element set to y. |
| // |
| // A non-constant value of index may result in significantly worse performance for this operation. |
| // |
| // Asm: VMOV, CPU Feature: NEON |
| func (x Uint64x2) SetElem(index uint8, y uint64) Uint64x2 |
| |
| // SetElem returns x with the index'th element set to y. |
| // |
| // index results in better performance when it's a constant, a non-constant value will be translated into a jump table. |
| // Asm: VMOV, CPU Feature: NEON |
| func (x Float32x4) SetElem(index uint8, v float32) Float32x4 |
| |
| // SetElem returns x with the index'th element set to y. |
| // |
| // index results in better performance when it's a constant, a non-constant value will be translated into a jump table. |
| // Asm: VMOV, CPU Feature: NEON |
| func (x Float64x2) SetElem(index uint8, v float64) Float64x2 |
| |
| /* Shift */ |
| |
| // Shift shifts each element in x by the signed value of the least significant byte |
| // of y's corresponding element: positive values shift left, negative values shift right. |
| // |
| // Asm: VSSHL, CPU Feature: NEON |
| func (x Int8x16) Shift(y Int8x16) Int8x16 |
| |
| // Shift shifts each element in x by the signed value of the least significant byte |
| // of y's corresponding element: positive values shift left, negative values shift right. |
| // |
| // Asm: VSSHL, CPU Feature: NEON |
| func (x Int16x8) Shift(y Int16x8) Int16x8 |
| |
| // Shift shifts each element in x by the signed value of the least significant byte |
| // of y's corresponding element: positive values shift left, negative values shift right. |
| // |
| // Asm: VSSHL, CPU Feature: NEON |
| func (x Int32x4) Shift(y Int32x4) Int32x4 |
| |
| // Shift shifts each element in x by the signed value of the least significant byte |
| // of y's corresponding element: positive values shift left, negative values shift right. |
| // |
| // Asm: VSSHL, CPU Feature: NEON |
| func (x Int64x2) Shift(y Int64x2) Int64x2 |
| |
| // Shift shifts each element in x by the signed value of the least significant byte |
| // of y's corresponding element: positive values shift left, negative values shift right. |
| // |
| // Asm: VUSHL, CPU Feature: NEON |
| func (x Uint8x16) Shift(y Int8x16) Uint8x16 |
| |
| // Shift shifts each element in x by the signed value of the least significant byte |
| // of y's corresponding element: positive values shift left, negative values shift right. |
| // |
| // Asm: VUSHL, CPU Feature: NEON |
| func (x Uint16x8) Shift(y Int16x8) Uint16x8 |
| |
| // Shift shifts each element in x by the signed value of the least significant byte |
| // of y's corresponding element: positive values shift left, negative values shift right. |
| // |
| // Asm: VUSHL, CPU Feature: NEON |
| func (x Uint32x4) Shift(y Int32x4) Uint32x4 |
| |
| // Shift shifts each element in x by the signed value of the least significant byte |
| // of y's corresponding element: positive values shift left, negative values shift right. |
| // |
| // Asm: VUSHL, CPU Feature: NEON |
| func (x Uint64x2) Shift(y Int64x2) Uint64x2 |
| |
| /* ShiftAllLeft */ |
| |
| // ShiftAllLeft shifts each element of x left by y bits. |
| // If y is greater than the element width, the result is 0. |
| // |
| // Asm: VSSHL, CPU Feature: NEON |
| func (x Int8x16) ShiftAllLeft(y uint64) Int8x16 |
| |
| // ShiftAllLeft shifts each element of x left by y bits. |
| // If y is greater than the element width, the result is 0. |
| // |
| // Asm: VSSHL, CPU Feature: NEON |
| func (x Int16x8) ShiftAllLeft(y uint64) Int16x8 |
| |
| // ShiftAllLeft shifts each element of x left by y bits. |
| // If y is greater than the element width, the result is 0. |
| // |
| // Asm: VSSHL, CPU Feature: NEON |
| func (x Int32x4) ShiftAllLeft(y uint64) Int32x4 |
| |
| // ShiftAllLeft shifts each element of x left by y bits. |
| // If y is greater than the element width, the result is 0. |
| // |
| // Asm: VSSHL, CPU Feature: NEON |
| func (x Int64x2) ShiftAllLeft(y uint64) Int64x2 |
| |
| // ShiftAllLeft shifts each element of x left by y bits. |
| // If y is greater than the element width, the result is 0. |
| // |
| // Asm: VUSHL, CPU Feature: NEON |
| func (x Uint8x16) ShiftAllLeft(y uint64) Uint8x16 |
| |
| // ShiftAllLeft shifts each element of x left by y bits. |
| // If y is greater than the element width, the result is 0. |
| // |
| // Asm: VUSHL, CPU Feature: NEON |
| func (x Uint16x8) ShiftAllLeft(y uint64) Uint16x8 |
| |
| // ShiftAllLeft shifts each element of x left by y bits. |
| // If y is greater than the element width, the result is 0. |
| // |
| // Asm: VUSHL, CPU Feature: NEON |
| func (x Uint32x4) ShiftAllLeft(y uint64) Uint32x4 |
| |
| // ShiftAllLeft shifts each element of x left by y bits. |
| // If y is greater than the element width, the result is 0. |
| // |
| // Asm: VUSHL, CPU Feature: NEON |
| func (x Uint64x2) ShiftAllLeft(y uint64) Uint64x2 |
| |
| /* ShiftAllRight */ |
| |
| // ShiftAllRight arithmetically shifts each element of x right by y bits. |
| // If y is greater than the element width, the result is 0 or -1. |
| // |
| // Asm: VSSHL, CPU Feature: NEON |
| func (x Int8x16) ShiftAllRight(y uint64) Int8x16 |
| |
| // ShiftAllRight arithmetically shifts each element of x right by y bits. |
| // If y is greater than the element width, the result is 0 or -1. |
| // |
| // Asm: VSSHL, CPU Feature: NEON |
| func (x Int16x8) ShiftAllRight(y uint64) Int16x8 |
| |
| // ShiftAllRight arithmetically shifts each element of x right by y bits. |
| // If y is greater than the element width, the result is 0 or -1. |
| // |
| // Asm: VSSHL, CPU Feature: NEON |
| func (x Int32x4) ShiftAllRight(y uint64) Int32x4 |
| |
| // ShiftAllRight arithmetically shifts each element of x right by y bits. |
| // If y is greater than the element width, the result is 0 or -1. |
| // |
| // Asm: VSSHL, CPU Feature: NEON |
| func (x Int64x2) ShiftAllRight(y uint64) Int64x2 |
| |
| // ShiftAllRight logically shifts each element of x right by y bits. |
| // If y is greater than the element width, the result is 0. |
| // |
| // Asm: VUSHL, CPU Feature: NEON |
| func (x Uint8x16) ShiftAllRight(y uint64) Uint8x16 |
| |
| // ShiftAllRight logically shifts each element of x right by y bits. |
| // If y is greater than the element width, the result is 0. |
| // |
| // Asm: VUSHL, CPU Feature: NEON |
| func (x Uint16x8) ShiftAllRight(y uint64) Uint16x8 |
| |
| // ShiftAllRight logically shifts each element of x right by y bits. |
| // If y is greater than the element width, the result is 0. |
| // |
| // Asm: VUSHL, CPU Feature: NEON |
| func (x Uint32x4) ShiftAllRight(y uint64) Uint32x4 |
| |
| // ShiftAllRight logically shifts each element of x right by y bits. |
| // If y is greater than the element width, the result is 0. |
| // |
| // Asm: VUSHL, CPU Feature: NEON |
| func (x Uint64x2) ShiftAllRight(y uint64) Uint64x2 |
| |
| /* ShiftSaturated */ |
| |
| // ShiftSaturated shifts each element in x by the signed value of the least significant byte |
| // of y's corresponding element (positive shifts left, negative shifts right). |
| // Results are saturated to the signed range on overflow. |
| // |
| // Asm: VSQSHL, CPU Feature: NEON |
| func (x Int8x16) ShiftSaturated(y Int8x16) Int8x16 |
| |
| // ShiftSaturated shifts each element in x by the signed value of the least significant byte |
| // of y's corresponding element (positive shifts left, negative shifts right). |
| // Results are saturated to the signed range on overflow. |
| // |
| // Asm: VSQSHL, CPU Feature: NEON |
| func (x Int16x8) ShiftSaturated(y Int16x8) Int16x8 |
| |
| // ShiftSaturated shifts each element in x by the signed value of the least significant byte |
| // of y's corresponding element (positive shifts left, negative shifts right). |
| // Results are saturated to the signed range on overflow. |
| // |
| // Asm: VSQSHL, CPU Feature: NEON |
| func (x Int32x4) ShiftSaturated(y Int32x4) Int32x4 |
| |
| // ShiftSaturated shifts each element in x by the signed value of the least significant byte |
| // of y's corresponding element (positive shifts left, negative shifts right). |
| // Results are saturated to the signed range on overflow. |
| // |
| // Asm: VSQSHL, CPU Feature: NEON |
| func (x Int64x2) ShiftSaturated(y Int64x2) Int64x2 |
| |
| // ShiftSaturated shifts each element in x by the signed value of the least significant byte |
| // of y's corresponding element (positive shifts left, negative shifts right). |
| // Results are saturated to the unsigned range on overflow. |
| // |
| // Asm: VUQSHL, CPU Feature: NEON |
| func (x Uint8x16) ShiftSaturated(y Int8x16) Uint8x16 |
| |
| // ShiftSaturated shifts each element in x by the signed value of the least significant byte |
| // of y's corresponding element (positive shifts left, negative shifts right). |
| // Results are saturated to the unsigned range on overflow. |
| // |
| // Asm: VUQSHL, CPU Feature: NEON |
| func (x Uint16x8) ShiftSaturated(y Int16x8) Uint16x8 |
| |
| // ShiftSaturated shifts each element in x by the signed value of the least significant byte |
| // of y's corresponding element (positive shifts left, negative shifts right). |
| // Results are saturated to the unsigned range on overflow. |
| // |
| // Asm: VUQSHL, CPU Feature: NEON |
| func (x Uint32x4) ShiftSaturated(y Int32x4) Uint32x4 |
| |
| // ShiftSaturated shifts each element in x by the signed value of the least significant byte |
| // of y's corresponding element (positive shifts left, negative shifts right). |
| // Results are saturated to the unsigned range on overflow. |
| // |
| // Asm: VUQSHL, CPU Feature: NEON |
| func (x Uint64x2) ShiftSaturated(y Int64x2) Uint64x2 |
| |
| /* Sqrt */ |
| |
| // Sqrt computes the square root of each element. |
| // |
| // Asm: VFSQRT, CPU Feature: NEON |
| func (x Float32x4) Sqrt() Float32x4 |
| |
| // Sqrt computes the square root of each element. |
| // |
| // Asm: VFSQRT, CPU Feature: NEON |
| func (x Float64x2) Sqrt() Float64x2 |
| |
| /* Sub */ |
| |
| // Sub subtracts corresponding elements of two vectors. |
| // |
| // Asm: VFSUB, CPU Feature: NEON |
| func (x Float32x4) Sub(y Float32x4) Float32x4 |
| |
| // Sub subtracts corresponding elements of two vectors. |
| // |
| // Asm: VFSUB, CPU Feature: NEON |
| func (x Float64x2) Sub(y Float64x2) Float64x2 |
| |
| // Sub subtracts corresponding elements of two vectors. |
| // |
| // Asm: VSUB, CPU Feature: NEON |
| func (x Int8x16) Sub(y Int8x16) Int8x16 |
| |
| // Sub subtracts corresponding elements of two vectors. |
| // |
| // Asm: VSUB, CPU Feature: NEON |
| func (x Int16x8) Sub(y Int16x8) Int16x8 |
| |
| // Sub subtracts corresponding elements of two vectors. |
| // |
| // Asm: VSUB, CPU Feature: NEON |
| func (x Int32x4) Sub(y Int32x4) Int32x4 |
| |
| // Sub subtracts corresponding elements of two vectors. |
| // |
| // Asm: VSUB, CPU Feature: NEON |
| func (x Int64x2) Sub(y Int64x2) Int64x2 |
| |
| // Sub subtracts corresponding elements of two vectors. |
| // |
| // Asm: VSUB, CPU Feature: NEON |
| func (x Uint8x16) Sub(y Uint8x16) Uint8x16 |
| |
| // Sub subtracts corresponding elements of two vectors. |
| // |
| // Asm: VSUB, CPU Feature: NEON |
| func (x Uint16x8) Sub(y Uint16x8) Uint16x8 |
| |
| // Sub subtracts corresponding elements of two vectors. |
| // |
| // Asm: VSUB, CPU Feature: NEON |
| func (x Uint32x4) Sub(y Uint32x4) Uint32x4 |
| |
| // Sub subtracts corresponding elements of two vectors. |
| // |
| // Asm: VSUB, CPU Feature: NEON |
| func (x Uint64x2) Sub(y Uint64x2) Uint64x2 |
| |
| /* SubSaturated */ |
| |
| // SubSaturated subtracts corresponding elements of two vectors with saturation. |
| // |
| // Asm: VSQSUB, CPU Feature: NEON |
| func (x Int8x16) SubSaturated(y Int8x16) Int8x16 |
| |
| // SubSaturated subtracts corresponding elements of two vectors with saturation. |
| // |
| // Asm: VSQSUB, CPU Feature: NEON |
| func (x Int16x8) SubSaturated(y Int16x8) Int16x8 |
| |
| // SubSaturated subtracts corresponding elements of two vectors with saturation. |
| // |
| // Asm: VSQSUB, CPU Feature: NEON |
| func (x Int32x4) SubSaturated(y Int32x4) Int32x4 |
| |
| // SubSaturated subtracts corresponding elements of two vectors with saturation. |
| // |
| // Asm: VSQSUB, CPU Feature: NEON |
| func (x Int64x2) SubSaturated(y Int64x2) Int64x2 |
| |
| // SubSaturated subtracts corresponding elements of two vectors with saturation. |
| // |
| // Asm: VUQSUB, CPU Feature: NEON |
| func (x Uint8x16) SubSaturated(y Uint8x16) Uint8x16 |
| |
| // SubSaturated subtracts corresponding elements of two vectors with saturation. |
| // |
| // Asm: VUQSUB, CPU Feature: NEON |
| func (x Uint16x8) SubSaturated(y Uint16x8) Uint16x8 |
| |
| // SubSaturated subtracts corresponding elements of two vectors with saturation. |
| // |
| // Asm: VUQSUB, CPU Feature: NEON |
| func (x Uint32x4) SubSaturated(y Uint32x4) Uint32x4 |
| |
| // SubSaturated subtracts corresponding elements of two vectors with saturation. |
| // |
| // Asm: VUQSUB, CPU Feature: NEON |
| func (x Uint64x2) SubSaturated(y Uint64x2) Uint64x2 |
| |
| /* Trunc */ |
| |
| // Trunc truncates elements towards zero. |
| // |
| // Asm: VFRINTZ, CPU Feature: NEON |
| func (x Float32x4) Trunc() Float32x4 |
| |
| // Trunc truncates elements towards zero. |
| // |
| // Asm: VFRINTZ, CPU Feature: NEON |
| func (x Float64x2) Trunc() Float64x2 |
| |
| /* TruncToInt8 */ |
| |
| // TruncToInt8 truncates element values to int8. |
| // Results are packed to low elements in the returned vector, its upper elements are zeroed. |
| // |
| // Asm: VXTN, CPU Feature: NEON |
| func (x Int16x8) TruncToInt8() Int8x16 |
| |
| /* TruncToInt16 */ |
| |
| // TruncToInt16 truncates element values to int16. |
| // Results are packed to low elements in the returned vector, its upper elements are zeroed. |
| // |
| // Asm: VXTN, CPU Feature: NEON |
| func (x Int32x4) TruncToInt16() Int16x8 |
| |
| /* TruncToInt32 */ |
| |
| // TruncToInt32 truncates element values to int32. |
| // Results are packed to low elements in the returned vector, its upper elements are zeroed. |
| // |
| // Asm: VXTN, CPU Feature: NEON |
| func (x Int64x2) TruncToInt32() Int32x4 |
| |
| /* TruncToUint8 */ |
| |
| // TruncToUint8 truncates element values to uint8. |
| // Results are packed to low elements in the returned vector, its upper elements are zeroed. |
| // |
| // Asm: VXTN, CPU Feature: NEON |
| func (x Uint16x8) TruncToUint8() Uint8x16 |
| |
| /* TruncToUint16 */ |
| |
| // TruncToUint16 truncates element values to uint16. |
| // Results are packed to low elements in the returned vector, its upper elements are zeroed. |
| // |
| // Asm: VXTN, CPU Feature: NEON |
| func (x Uint32x4) TruncToUint16() Uint16x8 |
| |
| /* TruncToUint32 */ |
| |
| // TruncToUint32 truncates element values to uint32. |
| // Results are packed to low elements in the returned vector, its upper elements are zeroed. |
| // |
| // Asm: VXTN, CPU Feature: NEON |
| func (x Uint64x2) TruncToUint32() Uint32x4 |
| |
| /* Xor */ |
| |
| // Xor performs a bitwise x ^ y. |
| // |
| // Asm: VEOR, CPU Feature: NEON |
| func (x Int8x16) Xor(y Int8x16) Int8x16 |
| |
| // Xor performs a bitwise x ^ y. |
| // |
| // Asm: VEOR, CPU Feature: NEON |
| func (x Int16x8) Xor(y Int16x8) Int16x8 |
| |
| // Xor performs a bitwise x ^ y. |
| // |
| // Asm: VEOR, CPU Feature: NEON |
| func (x Int32x4) Xor(y Int32x4) Int32x4 |
| |
| // Xor performs a bitwise x ^ y. |
| // |
| // Asm: VEOR, CPU Feature: NEON |
| func (x Int64x2) Xor(y Int64x2) Int64x2 |
| |
| // Xor performs a bitwise x ^ y. |
| // |
| // Asm: VEOR, CPU Feature: NEON |
| func (x Uint8x16) Xor(y Uint8x16) Uint8x16 |
| |
| // Xor performs a bitwise x ^ y. |
| // |
| // Asm: VEOR, CPU Feature: NEON |
| func (x Uint16x8) Xor(y Uint16x8) Uint16x8 |
| |
| // Xor performs a bitwise x ^ y. |
| // |
| // Asm: VEOR, CPU Feature: NEON |
| func (x Uint32x4) Xor(y Uint32x4) Uint32x4 |
| |
| // Xor performs a bitwise x ^ y. |
| // |
| // Asm: VEOR, CPU Feature: NEON |
| func (x Uint64x2) Xor(y Uint64x2) Uint64x2 |
| |
| // BitsToInt8 reinterprets the bits of a Uint8x16 vector as a Int8x16 vector |
| func (x Uint8x16) BitsToInt8() Int8x16 |
| |
| // ConvertToInt8 converts a Uint8x16 vector to a Int8x16 vector |
| func (x Uint8x16) ConvertToInt8() Int8x16 |
| |
| // ConvertToUint8 converts a Int8x16 vector to a Uint8x16 vector |
| func (x Int8x16) ConvertToUint8() Uint8x16 |
| |
| // ToBits reinterprets the bits of a Int8x16 vector as a Uint8x16 vector |
| func (x Int8x16) ToBits() Uint8x16 |
| |
| // ReshapeToUint16s reinterprets the bits of a Uint8x16 vector as a Uint16x8 vector |
| func (x Uint8x16) ReshapeToUint16s() Uint16x8 |
| |
| // ReshapeToUint32s reinterprets the bits of a Uint8x16 vector as a Uint32x4 vector |
| func (x Uint8x16) ReshapeToUint32s() Uint32x4 |
| |
| // ReshapeToUint64s reinterprets the bits of a Uint8x16 vector as a Uint64x2 vector |
| func (x Uint8x16) ReshapeToUint64s() Uint64x2 |
| |
| // BitsToInt16 reinterprets the bits of a Uint16x8 vector as a Int16x8 vector |
| func (x Uint16x8) BitsToInt16() Int16x8 |
| |
| // ConvertToInt16 converts a Uint16x8 vector to a Int16x8 vector |
| func (x Uint16x8) ConvertToInt16() Int16x8 |
| |
| // ConvertToUint16 converts a Int16x8 vector to a Uint16x8 vector |
| func (x Int16x8) ConvertToUint16() Uint16x8 |
| |
| // ToBits reinterprets the bits of a Int16x8 vector as a Uint16x8 vector |
| func (x Int16x8) ToBits() Uint16x8 |
| |
| // ReshapeToUint8s reinterprets the bits of a Uint16x8 vector as a Uint8x16 vector |
| func (x Uint16x8) ReshapeToUint8s() Uint8x16 |
| |
| // ReshapeToUint32s reinterprets the bits of a Uint16x8 vector as a Uint32x4 vector |
| func (x Uint16x8) ReshapeToUint32s() Uint32x4 |
| |
| // ReshapeToUint64s reinterprets the bits of a Uint16x8 vector as a Uint64x2 vector |
| func (x Uint16x8) ReshapeToUint64s() Uint64x2 |
| |
| // BitsToFloat32 reinterprets the bits of a Uint32x4 vector as a Float32x4 vector |
| func (x Uint32x4) BitsToFloat32() Float32x4 |
| |
| // ToBits reinterprets the bits of a Float32x4 vector as a Uint32x4 vector |
| func (x Float32x4) ToBits() Uint32x4 |
| |
| // BitsToInt32 reinterprets the bits of a Uint32x4 vector as a Int32x4 vector |
| func (x Uint32x4) BitsToInt32() Int32x4 |
| |
| // ConvertToInt32 converts a Uint32x4 vector to a Int32x4 vector |
| func (x Uint32x4) ConvertToInt32() Int32x4 |
| |
| // ConvertToUint32 converts a Int32x4 vector to a Uint32x4 vector |
| func (x Int32x4) ConvertToUint32() Uint32x4 |
| |
| // ToBits reinterprets the bits of a Int32x4 vector as a Uint32x4 vector |
| func (x Int32x4) ToBits() Uint32x4 |
| |
| // ReshapeToUint8s reinterprets the bits of a Uint32x4 vector as a Uint8x16 vector |
| func (x Uint32x4) ReshapeToUint8s() Uint8x16 |
| |
| // ReshapeToUint16s reinterprets the bits of a Uint32x4 vector as a Uint16x8 vector |
| func (x Uint32x4) ReshapeToUint16s() Uint16x8 |
| |
| // ReshapeToUint64s reinterprets the bits of a Uint32x4 vector as a Uint64x2 vector |
| func (x Uint32x4) ReshapeToUint64s() Uint64x2 |
| |
| // BitsToFloat64 reinterprets the bits of a Uint64x2 vector as a Float64x2 vector |
| func (x Uint64x2) BitsToFloat64() Float64x2 |
| |
| // ToBits reinterprets the bits of a Float64x2 vector as a Uint64x2 vector |
| func (x Float64x2) ToBits() Uint64x2 |
| |
| // BitsToInt64 reinterprets the bits of a Uint64x2 vector as a Int64x2 vector |
| func (x Uint64x2) BitsToInt64() Int64x2 |
| |
| // ConvertToInt64 converts a Uint64x2 vector to a Int64x2 vector |
| func (x Uint64x2) ConvertToInt64() Int64x2 |
| |
| // ConvertToUint64 converts a Int64x2 vector to a Uint64x2 vector |
| func (x Int64x2) ConvertToUint64() Uint64x2 |
| |
| // ToBits reinterprets the bits of a Int64x2 vector as a Uint64x2 vector |
| func (x Int64x2) ToBits() Uint64x2 |
| |
| // ReshapeToUint8s reinterprets the bits of a Uint64x2 vector as a Uint8x16 vector |
| func (x Uint64x2) ReshapeToUint8s() Uint8x16 |
| |
| // ReshapeToUint16s reinterprets the bits of a Uint64x2 vector as a Uint16x8 vector |
| func (x Uint64x2) ReshapeToUint16s() Uint16x8 |
| |
| // ReshapeToUint32s reinterprets the bits of a Uint64x2 vector as a Uint32x4 vector |
| func (x Uint64x2) ReshapeToUint32s() Uint32x4 |
| |
| // ToInt8x16 converts from Mask8x16 to Int8x16. |
| // If element i in the mask is "true", all bits in element i of the resulting |
| // vector will be set. |
| func (from Mask8x16) ToInt8x16() (to Int8x16) |
| |
| // 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 |
| |
| func (x Mask8x16) Not() Mask8x16 |
| |
| // ToInt16x8 converts from Mask16x8 to Int16x8. |
| // If element i in the mask is "true", all bits in element i of the resulting |
| // vector will be set. |
| func (from Mask16x8) ToInt16x8() (to Int16x8) |
| |
| // 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 |
| |
| func (x Mask16x8) Not() Mask16x8 |
| |
| // ToInt32x4 converts from Mask32x4 to Int32x4. |
| // If element i in the mask is "true", all bits in element i of the resulting |
| // vector will be set. |
| func (from Mask32x4) ToInt32x4() (to Int32x4) |
| |
| // 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 |
| |
| func (x Mask32x4) Not() Mask32x4 |
| |
| // ToInt64x2 converts from Mask64x2 to Int64x2. |
| // If element i in the mask is "true", all bits in element i of the resulting |
| // vector will be set. |
| func (from Mask64x2) ToInt64x2() (to Int64x2) |
| |
| // 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 |
| |
| func (x Mask64x2) Not() Mask64x2 |
