"strings"
"bytes"
"flag"
"fmt"
"go/format"
"log"
"math/bits"
"os"
"path"
"regexp"
"runtime"
"runtime/pprof"
"runtime/trace"
"slices"
"sort"
"strings"
"sync"
"strings"
"strings"
"strings"
"bytes"
"fmt"
"go/format"
"io"
"log"
"os"
"strings"
"strings"
"bufio"
"bytes"
"flag"
"fmt"
"go/ast"
"go/format"
"go/parser"
"go/printer"
"go/token"
"io"
"log"
"os"
"path"
"regexp"
"sort"
"strconv"
"strings"
"golang.org/x/tools/go/ast/astutil"
"strings"
"strings"
"fmt"
"strings"
"strings"
var addLine = *ast.CallExprvar archs []archvar cpuprofile = *ast.CallExprvar dec64Blocks = []blockData{...}var dec64Ops = []opData{...}var decBlocks = []blockData{...}var decOps = []opData{...}var emptyFset = *ast.CallExprfindAllOpcode is a function to find the opcode portion of s-expressions.
var findAllOpcode = *ast.CallExpr.FindAllStringIndexvar genLog = *ast.CallExprvar genericBlocks = []blockData{...}var genericOps = []opData{...}var memprofile = *ast.CallExprpredeclared contains globally known tokens that should not be redefined.
var predeclared = map[string]bool{...}var printConfig = printer.Config{...}copied from ../../x86/reg.go
var regNames386 = []string{...}copied from ../../amd64/reg.go
var regNamesAMD64 = []string{...}var regNamesARM = []string{...}Note: registers not used in regalloc are not included in this list, so that regmask stays within int64 Be careful when hand coding regmasks.
var regNamesARM64 = []string{...}Note: registers not used in regalloc are not included in this list, so that regmask stays within int64 Be careful when hand coding regmasks.
var regNamesLOONG64 = []string{...}Note: registers not used in regalloc are not included in this list, so that regmask stays within int64 Be careful when hand coding regmasks.
var regNamesMIPS = []string{...}Note: registers not used in regalloc are not included in this list, so that regmask stays within int64 Be careful when hand coding regmasks.
var regNamesMIPS64 = []string{...}var regNamesPPC64 = []string{...}copied from ../../s390x/reg.go
var regNamesS390X = []string{...}var regNamesWasm = []string{...}var reservedNames = map[string]bool{...}const riscv64REG_CTXT = 26const riscv64REG_G = 27const riscv64REG_GP = 3const riscv64REG_LR = 1const riscv64REG_SP = 2const riscv64REG_TMP = 31const riscv64REG_TP = 4const riscv64REG_ZERO = 0var tracefile = *ast.CallExprtype byKey []intPairtype regMask uint64Node can be a Statement or an ast.Expr.
type Node interface {
}Statement can be one of our high-level statement struct types, or an ast.Stmt under some limited circumstances.
type Statement interface {
}BodyBase is shared by all of our statement pseudo-node types which can contain other statements.
type BodyBase struct {
List []Statement
CanFail bool
}These types define some high-level statement struct types, which can be used as a Statement. This allows us to keep some node structs simpler, and have higher-level nodes such as an entire rule rewrite. Note that ast.Expr is always used as-is; we don't declare our own expression nodes.
type Case struct {
BodyBase
Expr ast.Expr
}These types define some high-level statement struct types, which can be used as a Statement. This allows us to keep some node structs simpler, and have higher-level nodes such as an entire rule rewrite. Note that ast.Expr is always used as-is; we don't declare our own expression nodes.
type CondBreak struct {
Cond ast.Expr
InsideCommuteLoop bool
}These types define some high-level statement struct types, which can be used as a Statement. This allows us to keep some node structs simpler, and have higher-level nodes such as an entire rule rewrite. Note that ast.Expr is always used as-is; we don't declare our own expression nodes.
type Declare struct {
Name string
Value ast.Expr
}These types define some high-level statement struct types, which can be used as a Statement. This allows us to keep some node structs simpler, and have higher-level nodes such as an entire rule rewrite. Note that ast.Expr is always used as-is; we don't declare our own expression nodes.
type File struct {
BodyBase
Arch arch
Suffix string
}These types define some high-level statement struct types, which can be used as a Statement. This allows us to keep some node structs simpler, and have higher-level nodes such as an entire rule rewrite. Note that ast.Expr is always used as-is; we don't declare our own expression nodes.
type Func struct {
BodyBase
Kind string
Suffix string
ArgLen int32
}type Rule struct {
Rule string
Loc string
}These types define some high-level statement struct types, which can be used as a Statement. This allows us to keep some node structs simpler, and have higher-level nodes such as an entire rule rewrite. Note that ast.Expr is always used as-is; we don't declare our own expression nodes.
type RuleRewrite struct {
BodyBase
Match string
Cond string
Result string
Check string
Alloc int
Loc string
CommuteDepth int
}These types define some high-level statement struct types, which can be used as a Statement. This allows us to keep some node structs simpler, and have higher-level nodes such as an entire rule rewrite. Note that ast.Expr is always used as-is; we don't declare our own expression nodes.
type StartCommuteLoop struct {
Depth int
V string
}These types define some high-level statement struct types, which can be used as a Statement. This allows us to keep some node structs simpler, and have higher-level nodes such as an entire rule rewrite. Note that ast.Expr is always used as-is; we don't declare our own expression nodes.
type Switch struct {
BodyBase
Expr ast.Expr
}type allocator struct {
name string
typ string
mak string
capacity string
resize string
clear string
minLog int
maxLog int
}type arch struct {
name string
pkg string
genfile string
ops []opData
blocks []blockData
regnames []string
ParamIntRegNames string
ParamFloatRegNames string
gpregmask regMask
fpregmask regMask
fp32regmask regMask
fp64regmask regMask
specialregmask regMask
framepointerreg int8
linkreg int8
generic bool
imports []string
}type blockData struct {
name string
controls int
aux string
}type derived struct {
name string
typ string
base string
}for sorting a pair of integers by key
type intPair struct {
key int
val int
}object keeps track of a declared name, such as a variable or import.
type object struct {
name string
pos token.Pos
numUses int
used []*object
}type opData struct {
name string
reg regInfo
asm string
typ string
aux string
rematerializeable bool
argLength int32
commutative bool
resultInArg0 bool
resultNotInArgs bool
clobberFlags bool
needIntTemp bool
call bool
tailCall bool
nilCheck bool
faultOnNilArg0 bool
faultOnNilArg1 bool
hasSideEffects bool
zeroWidth bool
unsafePoint bool
symEffect string
scale uint8
}type regInfo struct {
inputs []regMask
clobbers regMask
outputs []regMask
}scope keeps track of a certain scope and its declared names, as well as the outer (parent) scope.
type scope struct {
outer *scope
objects map[string]*object
}unusedInspector can be used to detect unused variables and imports in an ast.Node via its node method. The result is available in the "unused" map. note that unusedInspector is lazy and best-effort; it only supports the node types and patterns used by the rulegen program.
type unusedInspector struct {
scope *scope
unused map[token.Pos]bool
defining *object
}func (a byKey) Len() intfunc (a byKey) Less(i int, j int) boolfunc (s *scope) Lookup(name string) *objectName returns the name of the architecture for use in Op* and Block* enumerations.
func (a arch) Name() stringfunc (r Rule) String() stringfunc (a byKey) Swap(i int, j int)func (w *BodyBase) add(node Statement)auxIntType returns the Go type that this operation should store in its auxInt field.
func (op opData) auxIntType() stringauxIntType returns the Go type that this block should store in its auxInt field.
func (b blockData) auxIntType() stringauxType returns the Go type that this operation should store in its aux field.
func (op opData) auxType() stringauxType returns the Go type that this block should store in its aux field.
func (b blockData) auxType() stringbalance returns the number of unclosed '(' characters in s. If a ')' appears without a corresponding '(', balance returns -1.
func balance(s string) intbreakf constructs a simple "if cond { break }" statement, using exprf for its condition.
func breakf(format string, a ...interface{}) *CondBreakfunc checkEllipsisRuleCandidate(rule Rule, arch arch)countRegs returns the number of set bits in the register mask.
func countRegs(r regMask) intdeclReserved is like declf, but the name must be one of reservedNames. Calls to declReserved should generally be static and top-level.
func declReserved(name string, value string) *Declaredeclared reports if the body contains a Declare with the given name.
func (w *BodyBase) declared(name string) booldeclf constructs a simple "name := value" declaration, using exprf for its value. name must not be one of reservedNames. This helps prevent unintended shadowing and name clashes. To declare a reserved name, use declReserved.
func declf(loc string, name string, format string, a ...interface{}) *DeclareexcludeFromExpansion reports whether the substring s[idx[0]:idx[1]] in a rule should be disregarded as a candidate for | expansion. It uses simple syntactic checks to see whether the substring is inside an AuxInt expression or inside the && conditions.
func excludeFromExpansion(s string, idx []int) boolexpandOr converts a rule into multiple rules by expanding | ops.
func expandOr(r string) []stringexprf parses a Go expression generated from fmt.Sprintf, panicking if an error occurs.
func exprf(format string, a ...interface{}) ast.Exprfunc (u *unusedInspector) exprs(list []ast.Expr)func extract(val string) (op string, typ string, auxint string, aux string, args []string)func fprint(w io.Writer, n Node)func genAllocator(w io.Writer, a allocator)func genAllocators()func genBlockRewrite(rule Rule, arch arch, data blockData) *RuleRewritefunc genDerived(w io.Writer, d derived, base allocator)func genLateLowerRules(arch arch)genMatch returns the variable whose source position should be used for the result (or "" if no opinion), and a boolean that reports whether the match can fail.
func genMatch(rr *RuleRewrite, arch arch, match string, pregenTop bool) (pos string, checkOp string)func genMatch0(rr *RuleRewrite, arch arch, match string, v string, cnt map[string]int, pregenTop bool) (pos string, checkOp string)func genOp()func genResult(rr *RuleRewrite, arch arch, result string, pos string)func genResult0(rr *RuleRewrite, arch arch, result string, top bool, move bool, pos string, cse map[string]string) stringfunc genRules(arch arch)func genRulesSuffix(arch arch, suff string)func genSplitLoadRules(arch arch)func getBlockInfo(op string, arch arch) (name string, data blockData)func init()func init()func init()func init()func init()func init()func init()func init()func init()func init()func init()func init()func init()func init()isBlock reports whether this op is a block opcode.
func isBlock(name string, arch arch) boolisEllipsisValue reports whether s is of the form (OpX ...).
func isEllipsisValue(s string) boolfunc main()func (u *unusedInspector) node(node ast.Node)func normalizeMatch(m string, arch arch) stringfunc normalizeSpaces(s string) stringnormalizeWhitespace replaces 2+ whitespace sequences with a single space.
func normalizeWhitespace(x string) stringfunc opByName(arch arch, name string) opDatafunc opHasAux(op opData) boolfunc opHasAuxInt(op opData) boolopIsCommutative reports whether op s is commutative.
func opIsCommutative(op string, arch arch) boolparse returns the matching part of the rule, additional conditions, and the result.
func (r Rule) parse() (match string, cond string, result string)func parseEllipsisRules(rules []Rule, arch arch) (newop string, ok bool)parseValue parses a parenthesized value from a rule. The value can be from the match or the result side. It returns the op and unparsed strings for typ, auxint, and aux restrictions and for all args. oparch is the architecture that op is located in, or "" for generic.
func parseValue(val string, arch arch, loc string) (op opData, oparch string, typ string, auxint string, aux string, args []string)func (a arch) regMaskComment(r regMask) stringfunc riscv64RegName(r int) stringscoped opens a new scope when called, and returns a function which closes that same scope. When a scope is closed, unused variables are recorded.
func (u *unusedInspector) scoped() func()func split(s string) []stringsplitNameExpr splits s-expr arg, possibly prefixed by "name:", into name and the unprefixed expression. For example, "x:(Foo)" yields "x", "(Foo)", and "(Foo)" yields "", "(Foo)".
func splitNameExpr(arg string) (name string, expr string)stmtf parses a Go statement generated from fmt.Sprintf. This function is only meant for simple statements that don't have a custom Statement node declared in this package, such as ast.ReturnStmt or ast.ExprStmt.
func stmtf(format string, a ...interface{}) Statementfunc title(s string) stringtypeName returns the string to use to generate a type.
func typeName(typ string) stringfunc unTitle(s string) stringvarCount returns a map which counts the number of occurrences of Value variables in the s-expression rr.Match and the Go expression rr.Cond.
func varCount(rr *RuleRewrite) map[string]intfunc varCount1(loc string, m string, cnt map[string]int)Generated with Arrow