@ttsc/win32-arm64 0.33.0 → 0.34.0

package/bin/go/src/simd/simd_types.go

@@ -0,0 +1,96 @@
+// Code generated by 'go run -C $GOROOT/src/simd/archsimd/_gen/midway'; DO NOT EDIT.
+
+//go:build goexperiment.simd
+
+// Scalable vector types for rewriting and emulation
+
+package simd
+
+import "simd/internal/bridge"
+
+// internal SIMD marker, and hard dependence on simd/internal/bridge
+type _simd bridge.ZeroSized
+
+// Int8s represents a vector of 8-bit signed integers.
+type Int8s struct {
+	_    _simd
+	a, b uint64 // the actual vector size may be larger.
+}
+
+// Int16s represents a vector of 16-bit signed integers.
+type Int16s struct {
+	_    _simd
+	a, b uint64 // the actual vector size may be larger.
+}
+
+// Int32s represents a vector of 32-bit signed integers.
+type Int32s struct {
+	_    _simd
+	a, b uint64 // the actual vector size may be larger.
+}
+
+// Int64s represents a vector of 64-bit signed integers.
+type Int64s struct {
+	_    _simd
+	a, b uint64 // the actual vector size may be larger.
+}
+
+// Uint8s represents a vector of 8-bit unsigned integers.
+type Uint8s struct {
+	_    _simd
+	a, b uint64 // the actual vector size may be larger.
+}
+
+// Uint16s represents a vector of 16-bit unsigned integers.
+type Uint16s struct {
+	_    _simd
+	a, b uint64 // the actual vector size may be larger.
+}
+
+// Uint32s represents a vector of 32-bit unsigned integers.
+type Uint32s struct {
+	_    _simd
+	a, b uint64 // the actual vector size may be larger.
+}
+
+// Uint64s represents a vector of 64-bit unsigned integers.
+type Uint64s struct {
+	_    _simd
+	a, b uint64 // the actual vector size may be larger.
+}
+
+// Float32s represents a vector of 32-bit floating-point numbers.
+type Float32s struct {
+	_    _simd
+	a, b uint64 // the actual vector size may be larger.
+}
+
+// Float64s represents a vector of 64-bit floating-point numbers.
+type Float64s struct {
+	_    _simd
+	a, b uint64 // the actual vector size may be larger.
+}
+
+// Mask8s represents a boolean mask for Int8s/Uint8s vectors.
+type Mask8s struct {
+	_    _simd
+	a, b uint64 // the actual vector size may be larger.
+}
+
+// Mask16s represents a boolean mask for Int16s/Uint16s vectors.
+type Mask16s struct {
+	_    _simd
+	a, b uint64 // the actual vector size may be larger.
+}
+
+// Mask32s represents a boolean mask for Int32s/Uint32s vectors.
+type Mask32s struct {
+	_    _simd
+	a, b uint64 // the actual vector size may be larger.
+}
+
+// Mask64s represents a boolean mask for Int64s/Uint64s vectors.
+type Mask64s struct {
+	_    _simd
+	a, b uint64 // the actual vector size may be larger.
+}

package/bin/go/src/simd/tofrom_amd64.go

@@ -0,0 +1,374 @@
+// Code generated by 'go run -C $GOROOT/src/simd/archsimd/_gen/midway'; DO NOT EDIT.
+
+//go:build goexperiment.simd && amd64
+
+package simd
+
+import (
+	"simd/archsimd"
+	"simd/internal/bridge"
+)
+
+func (x Int8s) ToArch() any
+
+type archSimdInt8s interface {
+	archsimd.Int8x16 | archsimd.Int8x32 | archsimd.Int8x64
+}
+
+func Int8sFromArch[T archSimdInt8s](x T) Int8s {
+	switch a := any(x).(type) {
+	// The return expression is written this way because the code will be rewritten
+	// with Int8s replaced by one of the arch types, and without the any-assert
+	// hack the rewritten code would not pass type checking.
+	// The backend of the compiler will eat this and turn it into no code at all,
+	// assuming it inlines.
+	case archsimd.Int8x16:
+		var t bridge.Int8x16 = bridge.Int8x16(a)
+		return (any(t)).(Int8s)
+	case archsimd.Int8x32:
+		var t bridge.Int8x32 = bridge.Int8x32(a)
+		return (any(t)).(Int8s)
+	case archsimd.Int8x64:
+		var t bridge.Int8x64 = bridge.Int8x64(a)
+		return (any(t)).(Int8s)
+	}
+	panic("wrong type")
+}
+
+func (x Int16s) ToArch() any
+
+type archSimdInt16s interface {
+	archsimd.Int16x8 | archsimd.Int16x16 | archsimd.Int16x32
+}
+
+func Int16sFromArch[T archSimdInt16s](x T) Int16s {
+	switch a := any(x).(type) {
+	// The return expression is written this way because the code will be rewritten
+	// with Int16s replaced by one of the arch types, and without the any-assert
+	// hack the rewritten code would not pass type checking.
+	// The backend of the compiler will eat this and turn it into no code at all,
+	// assuming it inlines.
+	case archsimd.Int16x8:
+		var t bridge.Int16x8 = bridge.Int16x8(a)
+		return (any(t)).(Int16s)
+	case archsimd.Int16x16:
+		var t bridge.Int16x16 = bridge.Int16x16(a)
+		return (any(t)).(Int16s)
+	case archsimd.Int16x32:
+		var t bridge.Int16x32 = bridge.Int16x32(a)
+		return (any(t)).(Int16s)
+	}
+	panic("wrong type")
+}
+
+func (x Int32s) ToArch() any
+
+type archSimdInt32s interface {
+	archsimd.Int32x4 | archsimd.Int32x8 | archsimd.Int32x16
+}
+
+func Int32sFromArch[T archSimdInt32s](x T) Int32s {
+	switch a := any(x).(type) {
+	// The return expression is written this way because the code will be rewritten
+	// with Int32s replaced by one of the arch types, and without the any-assert
+	// hack the rewritten code would not pass type checking.
+	// The backend of the compiler will eat this and turn it into no code at all,
+	// assuming it inlines.
+	case archsimd.Int32x4:
+		var t bridge.Int32x4 = bridge.Int32x4(a)
+		return (any(t)).(Int32s)
+	case archsimd.Int32x8:
+		var t bridge.Int32x8 = bridge.Int32x8(a)
+		return (any(t)).(Int32s)
+	case archsimd.Int32x16:
+		var t bridge.Int32x16 = bridge.Int32x16(a)
+		return (any(t)).(Int32s)
+	}
+	panic("wrong type")
+}
+
+func (x Int64s) ToArch() any
+
+type archSimdInt64s interface {
+	archsimd.Int64x2 | archsimd.Int64x4 | archsimd.Int64x8
+}
+
+func Int64sFromArch[T archSimdInt64s](x T) Int64s {
+	switch a := any(x).(type) {
+	// The return expression is written this way because the code will be rewritten
+	// with Int64s replaced by one of the arch types, and without the any-assert
+	// hack the rewritten code would not pass type checking.
+	// The backend of the compiler will eat this and turn it into no code at all,
+	// assuming it inlines.
+	case archsimd.Int64x2:
+		var t bridge.Int64x2 = bridge.Int64x2(a)
+		return (any(t)).(Int64s)
+	case archsimd.Int64x4:
+		var t bridge.Int64x4 = bridge.Int64x4(a)
+		return (any(t)).(Int64s)
+	case archsimd.Int64x8:
+		var t bridge.Int64x8 = bridge.Int64x8(a)
+		return (any(t)).(Int64s)
+	}
+	panic("wrong type")
+}
+
+func (x Uint8s) ToArch() any
+
+type archSimdUint8s interface {
+	archsimd.Uint8x16 | archsimd.Uint8x32 | archsimd.Uint8x64
+}
+
+func Uint8sFromArch[T archSimdUint8s](x T) Uint8s {
+	switch a := any(x).(type) {
+	// The return expression is written this way because the code will be rewritten
+	// with Uint8s replaced by one of the arch types, and without the any-assert
+	// hack the rewritten code would not pass type checking.
+	// The backend of the compiler will eat this and turn it into no code at all,
+	// assuming it inlines.
+	case archsimd.Uint8x16:
+		var t bridge.Uint8x16 = bridge.Uint8x16(a)
+		return (any(t)).(Uint8s)
+	case archsimd.Uint8x32:
+		var t bridge.Uint8x32 = bridge.Uint8x32(a)
+		return (any(t)).(Uint8s)
+	case archsimd.Uint8x64:
+		var t bridge.Uint8x64 = bridge.Uint8x64(a)
+		return (any(t)).(Uint8s)
+	}
+	panic("wrong type")
+}
+
+func (x Uint16s) ToArch() any
+
+type archSimdUint16s interface {
+	archsimd.Uint16x8 | archsimd.Uint16x16 | archsimd.Uint16x32
+}
+
+func Uint16sFromArch[T archSimdUint16s](x T) Uint16s {
+	switch a := any(x).(type) {
+	// The return expression is written this way because the code will be rewritten
+	// with Uint16s replaced by one of the arch types, and without the any-assert
+	// hack the rewritten code would not pass type checking.
+	// The backend of the compiler will eat this and turn it into no code at all,
+	// assuming it inlines.
+	case archsimd.Uint16x8:
+		var t bridge.Uint16x8 = bridge.Uint16x8(a)
+		return (any(t)).(Uint16s)
+	case archsimd.Uint16x16:
+		var t bridge.Uint16x16 = bridge.Uint16x16(a)
+		return (any(t)).(Uint16s)
+	case archsimd.Uint16x32:
+		var t bridge.Uint16x32 = bridge.Uint16x32(a)
+		return (any(t)).(Uint16s)
+	}
+	panic("wrong type")
+}
+
+func (x Uint32s) ToArch() any
+
+type archSimdUint32s interface {
+	archsimd.Uint32x4 | archsimd.Uint32x8 | archsimd.Uint32x16
+}
+
+func Uint32sFromArch[T archSimdUint32s](x T) Uint32s {
+	switch a := any(x).(type) {
+	// The return expression is written this way because the code will be rewritten
+	// with Uint32s replaced by one of the arch types, and without the any-assert
+	// hack the rewritten code would not pass type checking.
+	// The backend of the compiler will eat this and turn it into no code at all,
+	// assuming it inlines.
+	case archsimd.Uint32x4:
+		var t bridge.Uint32x4 = bridge.Uint32x4(a)
+		return (any(t)).(Uint32s)
+	case archsimd.Uint32x8:
+		var t bridge.Uint32x8 = bridge.Uint32x8(a)
+		return (any(t)).(Uint32s)
+	case archsimd.Uint32x16:
+		var t bridge.Uint32x16 = bridge.Uint32x16(a)
+		return (any(t)).(Uint32s)
+	}
+	panic("wrong type")
+}
+
+func (x Uint64s) ToArch() any
+
+type archSimdUint64s interface {
+	archsimd.Uint64x2 | archsimd.Uint64x4 | archsimd.Uint64x8
+}
+
+func Uint64sFromArch[T archSimdUint64s](x T) Uint64s {
+	switch a := any(x).(type) {
+	// The return expression is written this way because the code will be rewritten
+	// with Uint64s replaced by one of the arch types, and without the any-assert
+	// hack the rewritten code would not pass type checking.
+	// The backend of the compiler will eat this and turn it into no code at all,
+	// assuming it inlines.
+	case archsimd.Uint64x2:
+		var t bridge.Uint64x2 = bridge.Uint64x2(a)
+		return (any(t)).(Uint64s)
+	case archsimd.Uint64x4:
+		var t bridge.Uint64x4 = bridge.Uint64x4(a)
+		return (any(t)).(Uint64s)
+	case archsimd.Uint64x8:
+		var t bridge.Uint64x8 = bridge.Uint64x8(a)
+		return (any(t)).(Uint64s)
+	}
+	panic("wrong type")
+}
+
+func (x Float32s) ToArch() any
+
+type archSimdFloat32s interface {
+	archsimd.Float32x4 | archsimd.Float32x8 | archsimd.Float32x16
+}
+
+func Float32sFromArch[T archSimdFloat32s](x T) Float32s {
+	switch a := any(x).(type) {
+	// The return expression is written this way because the code will be rewritten
+	// with Float32s replaced by one of the arch types, and without the any-assert
+	// hack the rewritten code would not pass type checking.
+	// The backend of the compiler will eat this and turn it into no code at all,
+	// assuming it inlines.
+	case archsimd.Float32x4:
+		var t bridge.Float32x4 = bridge.Float32x4(a)
+		return (any(t)).(Float32s)
+	case archsimd.Float32x8:
+		var t bridge.Float32x8 = bridge.Float32x8(a)
+		return (any(t)).(Float32s)
+	case archsimd.Float32x16:
+		var t bridge.Float32x16 = bridge.Float32x16(a)
+		return (any(t)).(Float32s)
+	}
+	panic("wrong type")
+}
+
+func (x Float64s) ToArch() any
+
+type archSimdFloat64s interface {
+	archsimd.Float64x2 | archsimd.Float64x4 | archsimd.Float64x8
+}
+
+func Float64sFromArch[T archSimdFloat64s](x T) Float64s {
+	switch a := any(x).(type) {
+	// The return expression is written this way because the code will be rewritten
+	// with Float64s replaced by one of the arch types, and without the any-assert
+	// hack the rewritten code would not pass type checking.
+	// The backend of the compiler will eat this and turn it into no code at all,
+	// assuming it inlines.
+	case archsimd.Float64x2:
+		var t bridge.Float64x2 = bridge.Float64x2(a)
+		return (any(t)).(Float64s)
+	case archsimd.Float64x4:
+		var t bridge.Float64x4 = bridge.Float64x4(a)
+		return (any(t)).(Float64s)
+	case archsimd.Float64x8:
+		var t bridge.Float64x8 = bridge.Float64x8(a)
+		return (any(t)).(Float64s)
+	}
+	panic("wrong type")
+}
+
+func (x Mask8s) ToArch() any
+
+type archSimdMask8s interface {
+	archsimd.Mask8x16 | archsimd.Mask8x32 | archsimd.Mask8x64
+}
+
+func Mask8sFromArch[T archSimdMask8s](x T) Mask8s {
+	switch a := any(x).(type) {
+	// The return expression is written this way because the code will be rewritten
+	// with Mask8s replaced by one of the arch types, and without the any-assert
+	// hack the rewritten code would not pass type checking.
+	// The backend of the compiler will eat this and turn it into no code at all,
+	// assuming it inlines.
+	case archsimd.Mask8x16:
+		var t bridge.Mask8x16 = bridge.Mask8x16(a)
+		return (any(t)).(Mask8s)
+	case archsimd.Mask8x32:
+		var t bridge.Mask8x32 = bridge.Mask8x32(a)
+		return (any(t)).(Mask8s)
+	case archsimd.Mask8x64:
+		var t bridge.Mask8x64 = bridge.Mask8x64(a)
+		return (any(t)).(Mask8s)
+	}
+	panic("wrong type")
+}
+
+func (x Mask16s) ToArch() any
+
+type archSimdMask16s interface {
+	archsimd.Mask16x8 | archsimd.Mask16x16 | archsimd.Mask16x32
+}
+
+func Mask16sFromArch[T archSimdMask16s](x T) Mask16s {
+	switch a := any(x).(type) {
+	// The return expression is written this way because the code will be rewritten
+	// with Mask16s replaced by one of the arch types, and without the any-assert
+	// hack the rewritten code would not pass type checking.
+	// The backend of the compiler will eat this and turn it into no code at all,
+	// assuming it inlines.
+	case archsimd.Mask16x8:
+		var t bridge.Mask16x8 = bridge.Mask16x8(a)
+		return (any(t)).(Mask16s)
+	case archsimd.Mask16x16:
+		var t bridge.Mask16x16 = bridge.Mask16x16(a)
+		return (any(t)).(Mask16s)
+	case archsimd.Mask16x32:
+		var t bridge.Mask16x32 = bridge.Mask16x32(a)
+		return (any(t)).(Mask16s)
+	}
+	panic("wrong type")
+}
+
+func (x Mask32s) ToArch() any
+
+type archSimdMask32s interface {
+	archsimd.Mask32x4 | archsimd.Mask32x8 | archsimd.Mask32x16
+}
+
+func Mask32sFromArch[T archSimdMask32s](x T) Mask32s {
+	switch a := any(x).(type) {
+	// The return expression is written this way because the code will be rewritten
+	// with Mask32s replaced by one of the arch types, and without the any-assert
+	// hack the rewritten code would not pass type checking.
+	// The backend of the compiler will eat this and turn it into no code at all,
+	// assuming it inlines.
+	case archsimd.Mask32x4:
+		var t bridge.Mask32x4 = bridge.Mask32x4(a)
+		return (any(t)).(Mask32s)
+	case archsimd.Mask32x8:
+		var t bridge.Mask32x8 = bridge.Mask32x8(a)
+		return (any(t)).(Mask32s)
+	case archsimd.Mask32x16:
+		var t bridge.Mask32x16 = bridge.Mask32x16(a)
+		return (any(t)).(Mask32s)
+	}
+	panic("wrong type")
+}
+
+func (x Mask64s) ToArch() any
+
+type archSimdMask64s interface {
+	archsimd.Mask64x2 | archsimd.Mask64x4 | archsimd.Mask64x8
+}
+
+func Mask64sFromArch[T archSimdMask64s](x T) Mask64s {
+	switch a := any(x).(type) {
+	// The return expression is written this way because the code will be rewritten
+	// with Mask64s replaced by one of the arch types, and without the any-assert
+	// hack the rewritten code would not pass type checking.
+	// The backend of the compiler will eat this and turn it into no code at all,
+	// assuming it inlines.
+	case archsimd.Mask64x2:
+		var t bridge.Mask64x2 = bridge.Mask64x2(a)
+		return (any(t)).(Mask64s)
+	case archsimd.Mask64x4:
+		var t bridge.Mask64x4 = bridge.Mask64x4(a)
+		return (any(t)).(Mask64s)
+	case archsimd.Mask64x8:
+		var t bridge.Mask64x8 = bridge.Mask64x8(a)
+		return (any(t)).(Mask64s)
+	}
+	panic("wrong type")
+}