@ttsc/win32-arm64 0.33.1 → 0.34.0

package/bin/go/src/simd/archsimd/unsafe_helpers.go

@@ -9,6 +9,8 @@ import "unsafe"
 // paInt8x16 returns a type-unsafe pointer to array that can
 // only be used with partial load/store operations that only
 // access the known-safe portions of the array.
+//
+//go:nocheckptr
 func paInt8x16(s []int8) *[16]int8 {
 	return (*[16]int8)(unsafe.Pointer(&s[0]))
 }
@@ -16,6 +18,8 @@ func paInt8x16(s []int8) *[16]int8 {
 // paInt16x8 returns a type-unsafe pointer to array that can
 // only be used with partial load/store operations that only
 // access the known-safe portions of the array.
+//
+//go:nocheckptr
 func paInt16x8(s []int16) *[8]int16 {
 	return (*[8]int16)(unsafe.Pointer(&s[0]))
 }
@@ -23,6 +27,8 @@ func paInt16x8(s []int16) *[8]int16 {
 // paInt32x4 returns a type-unsafe pointer to array that can
 // only be used with partial load/store operations that only
 // access the known-safe portions of the array.
+//
+//go:nocheckptr
 func paInt32x4(s []int32) *[4]int32 {
 	return (*[4]int32)(unsafe.Pointer(&s[0]))
 }
@@ -30,6 +36,8 @@ func paInt32x4(s []int32) *[4]int32 {
 // paInt64x2 returns a type-unsafe pointer to array that can
 // only be used with partial load/store operations that only
 // access the known-safe portions of the array.
+//
+//go:nocheckptr
 func paInt64x2(s []int64) *[2]int64 {
 	return (*[2]int64)(unsafe.Pointer(&s[0]))
 }
@@ -37,6 +45,8 @@ func paInt64x2(s []int64) *[2]int64 {
 // paUint8x16 returns a type-unsafe pointer to array that can
 // only be used with partial load/store operations that only
 // access the known-safe portions of the array.
+//
+//go:nocheckptr
 func paUint8x16(s []uint8) *[16]uint8 {
 	return (*[16]uint8)(unsafe.Pointer(&s[0]))
 }
@@ -44,6 +54,8 @@ func paUint8x16(s []uint8) *[16]uint8 {
 // paUint16x8 returns a type-unsafe pointer to array that can
 // only be used with partial load/store operations that only
 // access the known-safe portions of the array.
+//
+//go:nocheckptr
 func paUint16x8(s []uint16) *[8]uint16 {
 	return (*[8]uint16)(unsafe.Pointer(&s[0]))
 }
@@ -51,6 +63,8 @@ func paUint16x8(s []uint16) *[8]uint16 {
 // paUint32x4 returns a type-unsafe pointer to array that can
 // only be used with partial load/store operations that only
 // access the known-safe portions of the array.
+//
+//go:nocheckptr
 func paUint32x4(s []uint32) *[4]uint32 {
 	return (*[4]uint32)(unsafe.Pointer(&s[0]))
 }
@@ -58,6 +72,8 @@ func paUint32x4(s []uint32) *[4]uint32 {
 // paUint64x2 returns a type-unsafe pointer to array that can
 // only be used with partial load/store operations that only
 // access the known-safe portions of the array.
+//
+//go:nocheckptr
 func paUint64x2(s []uint64) *[2]uint64 {
 	return (*[2]uint64)(unsafe.Pointer(&s[0]))
 }
@@ -65,6 +81,8 @@ func paUint64x2(s []uint64) *[2]uint64 {
 // paFloat32x4 returns a type-unsafe pointer to array that can
 // only be used with partial load/store operations that only
 // access the known-safe portions of the array.
+//
+//go:nocheckptr
 func paFloat32x4(s []float32) *[4]float32 {
 	return (*[4]float32)(unsafe.Pointer(&s[0]))
 }
@@ -72,6 +90,8 @@ func paFloat32x4(s []float32) *[4]float32 {
 // paFloat64x2 returns a type-unsafe pointer to array that can
 // only be used with partial load/store operations that only
 // access the known-safe portions of the array.
+//
+//go:nocheckptr
 func paFloat64x2(s []float64) *[2]float64 {
 	return (*[2]float64)(unsafe.Pointer(&s[0]))
 }
@@ -79,6 +99,8 @@ func paFloat64x2(s []float64) *[2]float64 {
 // paInt8x32 returns a type-unsafe pointer to array that can
 // only be used with partial load/store operations that only
 // access the known-safe portions of the array.
+//
+//go:nocheckptr
 func paInt8x32(s []int8) *[32]int8 {
 	return (*[32]int8)(unsafe.Pointer(&s[0]))
 }
@@ -86,6 +108,8 @@ func paInt8x32(s []int8) *[32]int8 {
 // paInt16x16 returns a type-unsafe pointer to array that can
 // only be used with partial load/store operations that only
 // access the known-safe portions of the array.
+//
+//go:nocheckptr
 func paInt16x16(s []int16) *[16]int16 {
 	return (*[16]int16)(unsafe.Pointer(&s[0]))
 }
@@ -93,6 +117,8 @@ func paInt16x16(s []int16) *[16]int16 {
 // paInt32x8 returns a type-unsafe pointer to array that can
 // only be used with partial load/store operations that only
 // access the known-safe portions of the array.
+//
+//go:nocheckptr
 func paInt32x8(s []int32) *[8]int32 {
 	return (*[8]int32)(unsafe.Pointer(&s[0]))
 }
@@ -100,6 +126,8 @@ func paInt32x8(s []int32) *[8]int32 {
 // paInt64x4 returns a type-unsafe pointer to array that can
 // only be used with partial load/store operations that only
 // access the known-safe portions of the array.
+//
+//go:nocheckptr
 func paInt64x4(s []int64) *[4]int64 {
 	return (*[4]int64)(unsafe.Pointer(&s[0]))
 }
@@ -107,6 +135,8 @@ func paInt64x4(s []int64) *[4]int64 {
 // paUint8x32 returns a type-unsafe pointer to array that can
 // only be used with partial load/store operations that only
 // access the known-safe portions of the array.
+//
+//go:nocheckptr
 func paUint8x32(s []uint8) *[32]uint8 {
 	return (*[32]uint8)(unsafe.Pointer(&s[0]))
 }
@@ -114,6 +144,8 @@ func paUint8x32(s []uint8) *[32]uint8 {
 // paUint16x16 returns a type-unsafe pointer to array that can
 // only be used with partial load/store operations that only
 // access the known-safe portions of the array.
+//
+//go:nocheckptr
 func paUint16x16(s []uint16) *[16]uint16 {
 	return (*[16]uint16)(unsafe.Pointer(&s[0]))
 }
@@ -121,6 +153,8 @@ func paUint16x16(s []uint16) *[16]uint16 {
 // paUint32x8 returns a type-unsafe pointer to array that can
 // only be used with partial load/store operations that only
 // access the known-safe portions of the array.
+//
+//go:nocheckptr
 func paUint32x8(s []uint32) *[8]uint32 {
 	return (*[8]uint32)(unsafe.Pointer(&s[0]))
 }
@@ -128,6 +162,8 @@ func paUint32x8(s []uint32) *[8]uint32 {
 // paUint64x4 returns a type-unsafe pointer to array that can
 // only be used with partial load/store operations that only
 // access the known-safe portions of the array.
+//
+//go:nocheckptr
 func paUint64x4(s []uint64) *[4]uint64 {
 	return (*[4]uint64)(unsafe.Pointer(&s[0]))
 }
@@ -135,6 +171,8 @@ func paUint64x4(s []uint64) *[4]uint64 {
 // paFloat32x8 returns a type-unsafe pointer to array that can
 // only be used with partial load/store operations that only
 // access the known-safe portions of the array.
+//
+//go:nocheckptr
 func paFloat32x8(s []float32) *[8]float32 {
 	return (*[8]float32)(unsafe.Pointer(&s[0]))
 }
@@ -142,6 +180,8 @@ func paFloat32x8(s []float32) *[8]float32 {
 // paFloat64x4 returns a type-unsafe pointer to array that can
 // only be used with partial load/store operations that only
 // access the known-safe portions of the array.
+//
+//go:nocheckptr
 func paFloat64x4(s []float64) *[4]float64 {
 	return (*[4]float64)(unsafe.Pointer(&s[0]))
 }
@@ -149,6 +189,8 @@ func paFloat64x4(s []float64) *[4]float64 {
 // paInt8x64 returns a type-unsafe pointer to array that can
 // only be used with partial load/store operations that only
 // access the known-safe portions of the array.
+//
+//go:nocheckptr
 func paInt8x64(s []int8) *[64]int8 {
 	return (*[64]int8)(unsafe.Pointer(&s[0]))
 }
@@ -156,6 +198,8 @@ func paInt8x64(s []int8) *[64]int8 {
 // paInt16x32 returns a type-unsafe pointer to array that can
 // only be used with partial load/store operations that only
 // access the known-safe portions of the array.
+//
+//go:nocheckptr
 func paInt16x32(s []int16) *[32]int16 {
 	return (*[32]int16)(unsafe.Pointer(&s[0]))
 }
@@ -163,6 +207,8 @@ func paInt16x32(s []int16) *[32]int16 {
 // paInt32x16 returns a type-unsafe pointer to array that can
 // only be used with partial load/store operations that only
 // access the known-safe portions of the array.
+//
+//go:nocheckptr
 func paInt32x16(s []int32) *[16]int32 {
 	return (*[16]int32)(unsafe.Pointer(&s[0]))
 }
@@ -170,6 +216,8 @@ func paInt32x16(s []int32) *[16]int32 {
 // paInt64x8 returns a type-unsafe pointer to array that can
 // only be used with partial load/store operations that only
 // access the known-safe portions of the array.
+//
+//go:nocheckptr
 func paInt64x8(s []int64) *[8]int64 {
 	return (*[8]int64)(unsafe.Pointer(&s[0]))
 }
@@ -177,6 +225,8 @@ func paInt64x8(s []int64) *[8]int64 {
 // paUint8x64 returns a type-unsafe pointer to array that can
 // only be used with partial load/store operations that only
 // access the known-safe portions of the array.
+//
+//go:nocheckptr
 func paUint8x64(s []uint8) *[64]uint8 {
 	return (*[64]uint8)(unsafe.Pointer(&s[0]))
 }
@@ -184,6 +234,8 @@ func paUint8x64(s []uint8) *[64]uint8 {
 // paUint16x32 returns a type-unsafe pointer to array that can
 // only be used with partial load/store operations that only
 // access the known-safe portions of the array.
+//
+//go:nocheckptr
 func paUint16x32(s []uint16) *[32]uint16 {
 	return (*[32]uint16)(unsafe.Pointer(&s[0]))
 }
@@ -191,6 +243,8 @@ func paUint16x32(s []uint16) *[32]uint16 {
 // paUint32x16 returns a type-unsafe pointer to array that can
 // only be used with partial load/store operations that only
 // access the known-safe portions of the array.
+//
+//go:nocheckptr
 func paUint32x16(s []uint32) *[16]uint32 {
 	return (*[16]uint32)(unsafe.Pointer(&s[0]))
 }
@@ -198,6 +252,8 @@ func paUint32x16(s []uint32) *[16]uint32 {
 // paUint64x8 returns a type-unsafe pointer to array that can
 // only be used with partial load/store operations that only
 // access the known-safe portions of the array.
+//
+//go:nocheckptr
 func paUint64x8(s []uint64) *[8]uint64 {
 	return (*[8]uint64)(unsafe.Pointer(&s[0]))
 }
@@ -205,6 +261,8 @@ func paUint64x8(s []uint64) *[8]uint64 {
 // paFloat32x16 returns a type-unsafe pointer to array that can
 // only be used with partial load/store operations that only
 // access the known-safe portions of the array.
+//
+//go:nocheckptr
 func paFloat32x16(s []float32) *[16]float32 {
 	return (*[16]float32)(unsafe.Pointer(&s[0]))
 }
@@ -212,6 +270,8 @@ func paFloat32x16(s []float32) *[16]float32 {
 // paFloat64x8 returns a type-unsafe pointer to array that can
 // only be used with partial load/store operations that only
 // access the known-safe portions of the array.
+//
+//go:nocheckptr
 func paFloat64x8(s []float64) *[8]float64 {
 	return (*[8]float64)(unsafe.Pointer(&s[0]))
 }

package/bin/go/src/simd/doc.go

@@ -0,0 +1,91 @@
+// Copyright 2026 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build goexperiment.simd
+
+/*
+Package simd implements portable and vector-size-agnostic SIMD types,
+and functions and methods for working with these types.  SIMD types
+are either implemented in hardware (for example, arm64 "Neon" or
+amd64 "AVX/AVX2/AVX512") using the corresponding types in the
+[simd/archsimd] package, or emulated in pure Go.  In all cases, the
+vector length is at least 128 bits, and within a given program
+execution, all vectors have the same length.
+
+# SIMD Types
+
+There is a simd type corresponding to each primitive numeric type,
+except for complex64 and complex128.  Each of these is the type name,
+capitalized, with an "s" suffix, for example [Int8s], [Uint16s],
+or [Float64s].
+
+There are also simd "mask" types that abstract the mask registers
+present in some architectures, otherwise these will be implemented
+as bit masks.
+
+# Obtaining SIMD values
+
+The zero value of a SIMD vector type is valid and represents a zero vector.
+
+For each SIMD type, "Load<Types>(s []<type>) <Types>"
+loads a full verctor of the type from a long-enough slice.
+
+For slices that are not long enough, "Load<Types>Part(s []<type>) (<Types>, int)"
+will load as many elements as are available from the slice, fill the remainder
+with zero, and also return the number that were loaded.
+
+For each SIMD type, "Broadcast<Types>(x type) <Types>"
+returns a vector whose elements are all initialized to x.
+
+Examples:
+  - [LoadInt8s]
+  - [LoadUint16sPart]
+  - [BroadcastFloat32s]
+
+# Operations
+
+SIMD types provide methods for unary ([Float32s.Abs], [Int16s.Not]), binary
+([Float64s.Add], [Uint32s.GreaterEqual]), and ternary operations ([Int64s.IfElse], [Float32s.MulAdd]).
+Relational operations produce masks.
+
+SIMD types also support conversions between types, both those that are
+mostly value-preserving ([Int32s.ConvertToFloat32], [Float32s.ConvertToInt32]) and
+those that change types without altering the underlying vector bit
+pattern.
+
+Signed integer types convert to mask types ([Int16s.ToMask]), but this is a
+comparison against zero, not a simple bitwise conversion.  Mask types
+convert to signed integers in an operation ([Mask32s.ToInt32s]) that may be a
+zero-cost bitwise conversion, or not, depending on the underlying hardware.
+
+# Storing
+
+SIMD vector types have two methods, one for storing the entire vector into a slice
+"Store([]<type>)"" and a second for storing part of a vector into a slice "StorePart([]<type>) int".
+StorePart returns the number of elements actually stored.
+
+# String conversion
+
+Vectors and masks provide a String method for conversion to strings.
+
+# Conversion to and from simd/archsimd types.
+
+Each SIMD vector type has a "ToArch() any" method that returns the type
+supported by the current hardware as an "any".  Code using
+these methods must be build-tagged to the relevant architecture(s)
+and type-assert the returned value to the appropriate type.
+
+The simd package also includes generic functions for converting an
+architecture-dependent simd/archsimd value (e.g. [archsimd.Float32x4])
+into the corresponding simd type.  This function will panic if the
+correspondence is incorrect.
+
+For an example of converting between [simd] and [arch/simd] types,
+see the test file sum_amd64_test.go.
+*/
+package simd
+
+// BUG(reflection): Calls won't work, and there may be other bugs.
+// BUG(global initialization): SIMD-dependent var initializers don't work.
+// BUG(modified names): Modified names may appear in stack traces and debugging.

package/bin/go/src/simd/dummy.s

@@ -0,0 +1,7 @@
+// Copyright 2026 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build goexperiment.simd
+
+// Empty file to allow bodyless functions.