const (
ToBitsName = "ToBits"
ToIntsName = "BitsToInt{{.To.ElemBits}}"
ConvertToIntName = "ConvertToInt{{.To.ElemBits}}"
ConvertToUintName = "ConvertToUint{{.From.ElemBits}}" // backwards because done with ToInts
ToFloatsName = "BitsToFloat{{.To.ElemBits}}"
ReshapeName = "ReshapeToUint{{.To.ElemBits}}s"
)
var AsOp = templateOf("asConversion", `
// As{{.To.Name}} reinterprets the bits of a {{.From.Name}} vector as a {{.To.Name}} vector
//
// Deprecated: use combinations of ToBits, BitsTo{Int<N>,Float<N>}, ReshapeToUint<N>
//
//go:fix inline
func (x {{.From.Name}}) As{{.To.Name}}() {{.To.Name}} {
return x{{.AsTranslation}}
}
`)
var CvtToIntsIntrinsic = templateOf("cvtToIntIntrin", `{{.From.Name_}}.`+ConvertToIntName)
Also used in a to-from-reversed context.
var CvtToUintsIntrinsic = templateOf("cvtToUintIntrin", `{{.To.Name_}}.`+ConvertToUintName)
var ReshapeCall = templateOf("toBitsCall", "."+ReshapeName+"()")
var ReshapeDcl = templateOf("reshapeDcl", ` // `+ReshapeName+` reinterprets the bits of a {{.From.Name_}} vector as a {{.To.Name_}} vector func (x {{.From.Name_}}) `+ReshapeName+`() {{.To.Name_}} `)
var ReshapeIntrinsic = templateOf("reshapeIntrinsic", `{{.From.Name_}}.`+ReshapeName)
var ToBitsCall = templateOf("toBitsCall", "."+ToBitsName+"()")
var ToBitsDcl = templateOf("toBitsDcl", ` // `+ToBitsName+` reinterprets the bits of a {{.From.Name_}} vector as a {{.To.Name_}} vector func (x {{.From.Name_}}) `+ToBitsName+`() {{.To.Name_}} `)
ToBitsIntrinsic is used in a uint -> T context, but reverse, so T is method receiver.
var ToBitsIntrinsic = templateOf("toBitsIntrin", `{{.To.Name_}}.`+ToBitsName)
var ToFloatsCall = templateOf("toBitsCall", "."+ToFloatsName+"()")
var ToFloatsDcl = templateOf("toFloatsDcl", ` // `+ToFloatsName+` reinterprets the bits of a {{.From.Name_}} vector as a {{.To.Name_}} vector func (x {{.From.Name_}}) `+ToFloatsName+`() {{.To.Name_}} `)
var ToFloatsIntrinsic = templateOf("toFloatsIntrin", `{{.From.Name_}}.`+ToFloatsName)
var ToIntsCall = templateOf("toBitsCall", "."+ToIntsName+"()")
var ToIntsDcl = templateOf("toIntsDcl", ` // `+ToIntsName+` reinterprets the bits of a {{.From.Name_}} vector as a {{.To.Name_}} vector func (x {{.From.Name_}}) `+ToIntsName+`() {{.To.Name_}} // `+ConvertToIntName+` converts a {{.From.Name_}} vector to a {{.To.Name_}} vector func (x {{.From.Name_}}) `+ConvertToIntName+`() {{.To.Name_}} // `+ConvertToUintName+` converts a {{.To.Name_}} vector to a {{.From.Name_}} vector func (x {{.To.Name_}}) `+ConvertToUintName+`() {{.From.Name_}} `)
var ToIntsIntrinsic = templateOf("toIntsIntrin", `{{.From.Name_}}.`+ToIntsName)
func CompareNatural(s1, s2 string) int
CompareNatural performs a "natural sort" comparison of two strings. It compares non-digit sections lexicographically and digit sections numerically. In the case of string-unequal "equal" strings like "a01b" and "a1b", strings.Compare breaks the tie.
It returns:
-1 if s1 < s2 0 if s1 == s2 +1 if s1 > s2
func CreatePath(newFile string) (*os.File, error)
func FormatWriteAndClose(source *bytes.Buffer, newFile string)
FormatWriteAndClose formats the Go source code in source and writes it to newFile. If there is a problem with the formatting, the entire source is numbered and emitted along with the error message, to help figure out where the source code generation went wrong.
func MergeSIMDGenericOps(newOps []GenericOpsData, oldFile, currentArch string) *bytes.Buffer
MergeSIMDGenericOps merges a new set of generic ops with the existing ones read from goroot "/" file.
func NumberLines(data []byte) string
NumberLines takes a slice of bytes, and returns a string where each line is numbered, starting from 1.
func TemplateNamed(name, temp string) *template.Template
TemplateNamedreturns a parsed template from temp, named name.
func WriteAndClose(b []byte, newFile string)
WriteAndClose creates newFile, writes g to it, and closes the file.
type AsConversion struct {
From, To TforAsBits
}
func Conversion(from, to TforAsBits) *AsConversion
func (a *AsConversion) AsTranslation() string
func (c *AsConversion) ExecuteIntrinsicTemplateOfTypeDotMethod(w io.Writer, t *template.Template)
ExecuteIntrinsicTemplateOfTypeDotMethod executes the template t on a variety of TypeDotMethod inputs with template parameter TypeDotMethod
func (c *AsConversion) TypeDotMethod(t *template.Template) *TypeDotMethod
GenericOpsData holds one generic op entry for template rendering.
type GenericOpsData struct {
OpName string
OpInLen int
Comm bool
HasAux bool
Archs []string // e.g. ["amd64","arm64"]
}
func (d GenericOpsData) ArchTag() string
ArchTag returns the comma-separated arch list for the template comment.
type InsertMap[K comparable, V any] struct { // contains filtered or unexported fields }
func (im *InsertMap[K, V]) All() iter.Seq2[K, V]
All returns an iterator over the key-value pairs of the map in insertion order.
func (im *InsertMap[K, V]) Compare(a, b K) int
Compare compares two keys based on their insertion order. It returns:
If only one of the keys exists in the map, the existing key is considered to be "before" (less than) the non-existing key, returning -1 if 'a' exists, and 1 if 'b' exists.
func (im *InsertMap[K, V]) Contains(key K) bool
Contains reports whether the map contains the specified key.
func (im *InsertMap[K, V]) Get(key K) V
Get returns the value associated with the specified key. If the key does not exist, the zero value of type V is returned.
func (im *InsertMap[K, V]) GetOk(key K) (V, bool)
GetOk returns the value associated with the specified key and a boolean indicating whether the key exists in the map. If the key is not in the map, the zero value is returned along with false.
func (im *InsertMap[K, V]) Keys() iter.Seq[K]
Keys returns an iterator over the keys of the map in insertion order.
func (im *InsertMap[K, V]) Put(key K, val V) (old V, updated bool)
Put inserts or updates a key-value pair in the map. If the key already exists, its value is updated while its insertion order remains unchanged. Returns the old value if there is one, and a boolean indicating whether an update occurred.
func (im *InsertMap[K, V]) Values() iter.Seq[V]
Values returns an iterator over the values of the map in insertion order.
type TforAsBits interface {
ElemBits() int
Name_() string
}
type TypeDotMethod struct {
TypeDotMethod string
}