Files
wuffs/lib/armneonintrinsics/gen.go
T
Patrick Georgi f563f32f82 Add SPDX identifier to license headers
SPDX is an ISO standard for describing licenses in a computer readable
format, which is useful when applying license compliance tools and the
like to source code.

In addition to ensuring that the Wuffs C distribution is properly
annotated to the benefit of projects using Wuffs and SPDX-supporting
tools, add it everywhere else where there's a license in this repo for
consistency, too.
2023-10-06 20:52:36 +02:00

391 lines
8.5 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// Copyright 2021 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
//
// SPDX-License-Identifier: Apache-2.0 OR MIT
// ----------------
//go:build ignore
// +build ignore
package main
import (
"bufio"
"bytes"
"flag"
"fmt"
"io"
"net/http"
"os"
"sort"
"strings"
"github.com/google/wuffs/lib/armneonintrinsics"
)
var (
// The input can be "http://etc", "https://etc" or a local file path
// (without the "file://" protocol prefix). A local file can allow faster
// iteration when debugging this generator.
//
// For example, download arm_neon.h from raw.githubusercontent.com and
// replace the middle argument with "/the/path/to/arm_neon.h".
inputFlag = flag.String("input",
"https://raw.githubusercontent.com/gcc-mirror/gcc/master/gcc/config/aarch64/arm_neon.h",
"source file")
)
const debug = false
// hashTableSize should be a power of two.
const hashTableSize = 8192
func main() {
if err := main1(); err != nil {
os.Stderr.WriteString(err.Error() + "\n")
os.Exit(1)
}
}
func main1() error {
flag.Parse()
if err := build(); err != nil {
return err
}
sort.Slice(allFuncs, func(i, j int) bool {
return allFuncs[i][0].name < allFuncs[j][0].name
})
w := &bytes.Buffer{}
fmt.Fprintln(w, header)
strtabBytes := []byte(nil)
sort.Strings(strtabList)
for _, s := range strtabList {
strtabBytes = append(strtabBytes, s...)
}
strtab := string(strtabBytes)
fmt.Fprintf(w, "const stringTable = \"\" +\n")
for s := strtab; ; {
if len(s) <= 64 {
fmt.Fprintf(w, "\t%q\n", s)
break
}
fmt.Fprintf(w, "\t%q +\n", s[:64])
s = s[64:]
}
fmt.Fprintln(w)
fmt.Fprintf(w, "var elementTable = [...]element{\n\t{},\n")
etIndex := uint32(1)
for _, f := range allFuncs {
for j, e := range f {
o := strings.Index(strtab, e.name)
n := len(e.name)
if (o < 0) || (0xFFFF < o) || (0x7F < n) {
return fmt.Errorf(`could not index name %q`, e.name)
}
if j == (len(f) - 1) {
n |= 0x80
}
fmt.Fprintf(w, "\t{0x%04X, 0x%02X, 0x%02X},", o, n, uint8(e.typ))
if j == 0 {
hash, htIndex := insert(e.name, etIndex)
if debug {
fmt.Fprintf(w, " // 0x%04X 0x%04X 0x%04X %s", etIndex, hash, htIndex, e.name)
}
}
fmt.Fprintln(w)
etIndex++
}
}
fmt.Fprintf(w, "}\n")
fmt.Fprintln(w)
fmt.Fprintf(w, "var hashTable = [%d]uint16{\n", hashTableSize)
for i, h := range hashTable {
if h.etIndex != 0 {
fmt.Fprintf(w, "\t0x%04X: 0x%04X,", i, h.etIndex)
if debug {
fmt.Fprintf(w, " // %s", h.name)
}
fmt.Fprintln(w)
}
}
fmt.Fprintf(w, "}\n")
fmt.Fprintln(w)
fmt.Fprintf(w, "// sizeof(stringTable) = %5d × 1 = %5d\n",
len(strtab), len(strtab))
fmt.Fprintf(w, "// sizeof(elementTable) = %5d × 4 = %5d\n",
etIndex, etIndex*4)
fmt.Fprintf(w, "// sizeof(hashTable) = %5d × 2 = %5d\n",
hashTableSize, hashTableSize*2)
fmt.Fprintln(w)
fmt.Fprintf(w, "// hashTable statistics:\n")
fmt.Fprintf(w, "// %4d size\n", hashTableSize)
fmt.Fprintf(w, "// %4d entries\n", htStats.nEntries)
fmt.Fprintf(w, "// ----\n")
for i, x := range htStats.nProbes {
plus := " "
if i == (len(htStats.nProbes) - 1) {
plus = "+"
}
fmt.Fprintf(w, "// %4d entries have %2d%s probes\n", x, i, plus)
}
return os.WriteFile("data.go", w.Bytes(), 0644)
}
func build() error {
in := io.ReadCloser(nil)
if strings.HasPrefix(*inputFlag, "http://") ||
strings.HasPrefix(*inputFlag, "https://") {
r, err := http.Get(*inputFlag)
if err != nil {
return err
}
in = r.Body
} else {
r, err := os.Open(*inputFlag)
if err != nil {
return err
}
in = r
}
defer in.Close()
state := 0
currFunc := []element(nil)
s := bufio.NewScanner(in)
for s.Scan() {
line := s.Bytes()
if len(line) == 0 {
continue
}
b := line
switch state {
case 0:
if !bytes.HasPrefix(b, bUUExtension) {
continue
} else if i := bytes.IndexByte(b, '\\'); i >= 0 {
continue
} else if i := bytes.Index(b, bUUInline); i < 0 {
continue
} else {
b = bytes.TrimSpace(b[i+len(bUUInline):])
}
returnTyp := armneonintrinsics.ParseType(string(b))
if returnTyp == armneonintrinsics.TypeInvalid {
return fmt.Errorf(`could not parse %q`, line)
}
currFunc = funk{{"", returnTyp}}
state = 1
case 1:
if !bytes.HasPrefix(b, bUUAttribute) {
return fmt.Errorf(`expected "__attribute", got %q`, line)
}
state = 2
case 2:
i := bytes.IndexByte(b, '(')
if i < 0 {
return fmt.Errorf(`could not parse %q`, line)
}
funcName := string(bytes.TrimSpace(b[:i]))
b = b[i+1:]
addToStrtab(funcName)
currFunc[0].name = funcName
state = 3
fallthrough
case 3:
b = bytes.TrimSpace(b)
for len(b) > 0 {
if bytes.HasPrefix(b, bUUConst) {
b = b[2:]
}
i := bytesIndexAny(b, bUnderUnder, bData, bImm6, bKey, bVal)
if i < 0 {
return fmt.Errorf(`could not parse %q`, line)
}
argTyp := parseTyp(string(bytes.TrimSpace(b[:i])))
if argTyp == armneonintrinsics.TypeInvalid {
return fmt.Errorf(`could not parse %q`, line)
}
b = b[i:]
argName := readIdent(b)
if argName == "" {
return fmt.Errorf(`could not parse %q`, line)
}
b = b[len(argName):]
addToStrtab(argName)
currFunc = append(currFunc, element{argName, argTyp})
if len(b) > 0 {
if b[0] == ',' {
b = bytes.TrimSpace(b[1:])
continue
} else if b[0] == ')' {
allFuncs = append(allFuncs, currFunc)
currFunc = nil
state = 0
break
}
}
return fmt.Errorf(`could not parse %q`, line)
}
}
}
return s.Err()
}
var (
bUnderUnder = []byte("__")
bUUAttribute = []byte("__attribute")
bUUConst = []byte("__const")
bUUExtension = []byte("__extension")
bUUInline = []byte("__inline")
// Most arm_neon.h variable names start with "__". Some are idiosyncratic.
bData = []byte("data")
bImm6 = []byte("imm6")
bKey = []byte("key")
bVal = []byte("val")
)
var (
allFuncs = []funk(nil)
strtabList = []string(nil)
strtabMap = map[string]bool{}
hashTable = [hashTableSize]htElement{}
htStats struct {
nEntries uint32
nProbes [16]uint32
}
)
func addToStrtab(s string) {
if !strtabMap[s] {
strtabMap[s] = true
strtabList = append(strtabList, s)
}
}
type funk []element
func (f funk) dup() funk {
return append(funk(nil), f...)
}
type element struct {
name string
typ armneonintrinsics.Type
}
type htElement struct {
etIndex uint32
name string
}
func bytesIndexAny(b []byte, needles ...[]byte) int {
for _, needle := range needles {
if i := bytes.Index(b, needle); i >= 0 {
return i
}
}
return -1
}
func insert(name string, etIndex uint32) (hash uint32, htIndex uint32) {
hash = jenkins(name) % hashTableSize
htIndex = hash
nProbes := 0
for hashTable[htIndex].etIndex != 0 {
htIndex = (htIndex + 1) % hashTableSize
if htIndex == hash {
panic("hashTableSize is too small")
}
nProbes++
}
hashTable[htIndex] = htElement{etIndex, name}
if nProbes >= len(htStats.nProbes) {
nProbes = len(htStats.nProbes) - 1
}
htStats.nProbes[nProbes]++
htStats.nEntries++
return hash, htIndex
}
// jenkins implements https://en.wikipedia.org/wiki/Jenkins_hash_function
func jenkins(s string) (hash uint32) {
for i := 0; i < len(s); i++ {
hash += uint32(s[i])
hash += hash << 10
hash ^= hash >> 6
}
hash += hash << 3
hash ^= hash >> 11
hash += hash << 15
return hash
}
func parseTyp(s string) armneonintrinsics.Type {
// arm_neon.h has a few of these idiosyncratic "int const"s.
if s == "int const" {
return armneonintrinsics.ParseType("const int")
}
return armneonintrinsics.ParseType(s)
}
func readIdent(b []byte) string {
for i, c := range b {
switch {
default:
return string(b[:i])
case c == '_':
case ('0' <= c) && (c <= '9'):
case ('A' <= c) && (c <= 'A'):
case ('a' <= c) && (c <= 'z'):
}
}
return string(b)
}
const header = `// Code generated by running "go generate". DO NOT EDIT.
// Copyright 2021 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
//
// SPDX-License-Identifier: Apache-2.0 OR MIT
package armneonintrinsics
`