Functions
            
            
               
                  ABI 
                  method
                  
                  #
               
               
               func (a *AuxCall) ABI() *abi.ABIConfig
            
            
            
               
                  ABIInfo 
                  method
                  
                  #
               
               
               func (a *AuxCall) ABIInfo() *abi.ABIParamResultInfo
            
            
            
               
                  AddArg 
                  method
                  
                  #
               
               
               If/when midstack inlining is enabled (-l=4), the compiler gets both larger and slower.
Not-inlining this method is a help (*Value.reset and *Block.NewValue0 are similar).
go:noinline
               
               func (v *Value) AddArg(w *Value)
            
            
            
               
                  AddArg2 
                  method
                  
                  #
               
               
               go:noinline
               
               func (v *Value) AddArg2(w1 *Value, w2 *Value)
            
            
            
               
                  AddArg3 
                  method
                  
                  #
               
               
               go:noinline
               
               func (v *Value) AddArg3(w1 *Value, w2 *Value, w3 *Value)
            
            
            
               
                  AddArg4 
                  method
                  
                  #
               
               
               go:noinline
               
               func (v *Value) AddArg4(w1 *Value, w2 *Value, w3 *Value, w4 *Value)
            
            
            
               
                  AddArg5 
                  method
                  
                  #
               
               
               go:noinline
               
               func (v *Value) AddArg5(w1 *Value, w2 *Value, w3 *Value, w4 *Value, w5 *Value)
            
            
            
               
                  AddArg6 
                  method
                  
                  #
               
               
               go:noinline
               
               func (v *Value) AddArg6(w1 *Value, w2 *Value, w3 *Value, w4 *Value, w5 *Value, w6 *Value)
            
            
            
               
                  AddArgs 
                  method
                  
                  #
               
               
               func (v *Value) AddArgs(a ...*Value)
            
            
            
               
                  AddControl 
                  method
                  
                  #
               
               
               AddControl appends a control value to the existing list of control values.
               
               func (b *Block) AddControl(v *Value)
            
            
            
               
                  AddEdgeTo 
                  method
                  
                  #
               
               
               AddEdgeTo adds an edge from block b to block c.
               
               func (b *Block) AddEdgeTo(c *Block)
            
            
            
               
                  ArgOpAndRegisterFor 
                  function
                  
                  #
               
               
               ArgOpAndRegisterFor converts an abi register index into an ssa Op and corresponding
arg register index.
               
               func ArgOpAndRegisterFor(r abi.RegIndex, abiConfig *abi.ABIConfig) (Op, int64)
            
            
            
               
                  ArgOpAndRegisterFor 
                  method
                  
                  #
               
               
               func (c *registerCursor) ArgOpAndRegisterFor() (Op, int64)
            
            
            
               
                  ArgWidth 
                  method
                  
                  #
               
               
               ArgWidth returns the amount of stack needed for all the inputs
and outputs of a function or method, including ABI-defined parameter
slots and ABI-defined spill slots for register-resident parameters.
The name is taken from the types package's ArgWidth(),
which predated changes to the ABI; this version handles those changes.
               
               func (a *AuxCall) ArgWidth() int64
            
            
            
               
                  Asm 
                  method
                  
                  #
               
               
               func (o Op) Asm() obj.As
            
            
            
               
                  AutoVar 
                  function
                  
                  #
               
               
               AutoVar returns a *Name and int64 representing the auto variable and offset within it
where v should be spilled.
               
               func AutoVar(v *Value) (*ir.Name, int64)
            
            
            
               
                  AuxArm64BitField 
                  method
                  
                  #
               
               
               func (v *Value) AuxArm64BitField() arm64BitField
            
            
            
               
                  AuxFloat 
                  method
                  
                  #
               
               
               func (v *Value) AuxFloat() float64
            
            
            
               
                  AuxInt16 
                  method
                  
                  #
               
               
               func (v *Value) AuxInt16() int16
            
            
            
               
                  AuxInt32 
                  method
                  
                  #
               
               
               func (v *Value) AuxInt32() int32
            
            
            
               
                  AuxInt8 
                  method
                  
                  #
               
               
               func (v *Value) AuxInt8() int8
            
            
            
               
                  AuxIntString 
                  method
                  
                  #
               
               
               func (b *Block) AuxIntString() string
            
            
            
               
                  AuxIntType 
                  method
                  
                  #
               
               
               func (k BlockKind) AuxIntType() string
            
            
            
               
                  AuxUInt8 
                  method
                  
                  #
               
               
               func (v *Value) AuxUInt8() uint8
            
            
            
               
                  AuxUnsigned 
                  method
                  
                  #
               
               
               AuxUnsigned returns v.AuxInt as an unsigned value for OpConst*.
v.AuxInt is always sign-extended to 64 bits, even if the
represented value is unsigned. This undoes that sign extension.
               
               func (v *Value) AuxUnsigned() uint64
            
            
            
               
                  AuxValAndOff 
                  method
                  
                  #
               
               
               func (v *Value) AuxValAndOff() ValAndOff
            
            
            
               
                  Block 
                  method
                  
                  #
               
               
               func (e Edge) Block() *Block
            
            
            
               
                  BuildFuncDebug 
                  function
                  
                  #
               
               
               BuildFuncDebug debug information for f, placing the results
in "rval". f must be fully processed, so that each Value is where it
will be when machine code is emitted.
               
               func BuildFuncDebug(ctxt *obj.Link, f *Func, loggingLevel int, stackOffset func(LocalSlot) int32, rval *FuncDebug)
            
            
            
               
                  BuildFuncDebugNoOptimized 
                  function
                  
                  #
               
               
               BuildFuncDebugNoOptimized populates a FuncDebug object "rval" with
entries corresponding to the register-resident input parameters for
the function "f"; it is used when we are compiling without
optimization but the register ABI is enabled. For each reg param,
it constructs a 2-element location list: the first element holds
the input register, and the second element holds the stack location
of the param (the assumption being that when optimization is off,
each input param reg will be spilled in the prolog). In addition
to the register params, here we also build location lists (where
appropriate for the ".closureptr" compiler-synthesized variable
needed by the debugger for range func bodies.
               
               func BuildFuncDebugNoOptimized(ctxt *obj.Link, f *Func, loggingEnabled bool, stackOffset func(LocalSlot) int32, rval *FuncDebug)
            
            
            
               
                  ByTopoCmp 
                  function
                  
                  #
               
               
               ByTopoCmp sorts topologically: target function is on top,
followed by inlined functions sorted by filename and line numbers.
               
               func ByTopoCmp(a *FuncLines, b *FuncLines) int
            
            
            
               
                  C 
                  method
                  
                  #
               
               
               C reports whether an unsigned add overflowed (carry), or an
unsigned subtract did not underflow (borrow).
               
               func (fc flagConstant) C() bool
            
            
            
               
                  CanBeAnSSAAux 
                  method
                  
                  #
               
               
               func (stringAux) CanBeAnSSAAux()
            
            
            
               
                  CanBeAnSSAAux 
                  method
                  
                  #
               
               
               func (a *AuxNameOffset) CanBeAnSSAAux()
            
            
            
               
                  CanBeAnSSAAux 
                  method
                  
                  #
               
               
               func (*AuxCall) CanBeAnSSAAux()
            
            
            
               
                  CanBeAnSSAAux 
                  method
                  
                  #
               
               
               func (auxMark) CanBeAnSSAAux()
            
            
            
               
                  CanSSA 
                  function
                  
                  #
               
               
               CanSSA reports whether values of type t can be represented as a Value.
               
               func CanSSA(t *types.Type) bool
            
            
            
               
                  CheckEmpty 
                  method
                  
                  #
               
               
               CheckEmpty checks that a poset is completely empty.
It can be used for debugging purposes, as a poset is supposed to
be empty after it's fully rolled back through Undo.
               
               func (po *poset) CheckEmpty() error
            
            
            
               
                  CheckIntegrity 
                  method
                  
                  #
               
               
               CheckIntegrity verifies internal integrity of a poset. It is intended
for debugging purposes.
               
               func (po *poset) CheckIntegrity()
            
            
            
               
                  Checkpoint 
                  method
                  
                  #
               
               
               Checkpoint saves the current state of the DAG so that it's possible
to later undo this state.
Complexity is O(1).
               
               func (po *poset) Checkpoint()
            
            
            
               
                  Child 
                  method
                  
                  #
               
               
               Child returns a child of x in the dominator tree, or
nil if there are none. The choice of first child is
arbitrary but repeatable.
               
               func (t SparseTree) Child(x *Block) *Block
            
            
            
               
                  Clear 
                  method
                  
                  #
               
               
               func (bs bitset) Clear(idx uint32)
            
            
            
               
                  Close 
                  method
                  
                  #
               
               
               func (w *HTMLWriter) Close()
            
            
            
               
                  ClosureAuxCall 
                  function
                  
                  #
               
               
               ClosureAuxCall returns an AuxCall for a closure call.
               
               func ClosureAuxCall(paramResultInfo *abi.ABIParamResultInfo) *AuxCall
            
            
            
               
                  Compile 
                  function
                  
                  #
               
               
               Compile is the main entry point for this package.
Compile modifies f so that on return:
- all Values in f map to 0 or 1 assembly instructions of the target architecture
- the order of f.Blocks is the order to emit the Blocks
- the order of b.Values is the order to emit the Values in each Block
- f has a non-nil regAlloc field
               
               func Compile(f *Func)
            
            
            
               
                  ConstBool 
                  method
                  
                  #
               
               
               ConstBool returns an int constant representing its argument.
               
               func (f *Func) ConstBool(t *types.Type, c bool) *Value
            
            
            
               
                  ConstEmptyString 
                  method
                  
                  #
               
               
               func (f *Func) ConstEmptyString(t *types.Type) *Value
            
            
            
               
                  ConstFloat32 
                  method
                  
                  #
               
               
               func (f *Func) ConstFloat32(t *types.Type, c float64) *Value
            
            
            
               
                  ConstFloat64 
                  method
                  
                  #
               
               
               func (f *Func) ConstFloat64(t *types.Type, c float64) *Value
            
            
            
               
                  ConstInt16 
                  method
                  
                  #
               
               
               func (f *Func) ConstInt16(t *types.Type, c int16) *Value
            
            
            
               
                  ConstInt32 
                  method
                  
                  #
               
               
               func (f *Func) ConstInt32(t *types.Type, c int32) *Value
            
            
            
               
                  ConstInt64 
                  method
                  
                  #
               
               
               func (f *Func) ConstInt64(t *types.Type, c int64) *Value
            
            
            
               
                  ConstInt8 
                  method
                  
                  #
               
               
               func (f *Func) ConstInt8(t *types.Type, c int8) *Value
            
            
            
               
                  ConstInterface 
                  method
                  
                  #
               
               
               func (f *Func) ConstInterface(t *types.Type) *Value
            
            
            
               
                  ConstNil 
                  method
                  
                  #
               
               
               func (f *Func) ConstNil(t *types.Type) *Value
            
            
            
               
                  ConstOffPtrSP 
                  method
                  
                  #
               
               
               func (f *Func) ConstOffPtrSP(t *types.Type, c int64, sp *Value) *Value
            
            
            
               
                  ConstSlice 
                  method
                  
                  #
               
               
               func (f *Func) ConstSlice(t *types.Type) *Value
            
            
            
               
                  ControlValues 
                  method
                  
                  #
               
               
               ControlValues returns a slice containing the non-nil control
values of the block. The index of each control value will be
the same as it is in the Controls property and can be used
in ReplaceControl calls.
               
               func (b *Block) ControlValues() []*Value
            
            
            
               
                  CopyControls 
                  method
                  
                  #
               
               
               CopyControls replaces the controls for this block with those from the
provided block. The provided block is not modified.
               
               func (b *Block) CopyControls(from *Block)
            
            
            
               
                  Ctxt 
                  method
                  
                  #
               
               
               func (c *Config) Ctxt() *obj.Link
            
            
            
               
                  DebugHashMatch 
                  method
                  
                  #
               
               
               DebugHashMatch returns
base.DebugHashMatch(this function's package.name)
for use in bug isolation.  The return value is true unless
environment variable GOCOMPILEDEBUG=gossahash=X is set, in which case "it depends on X".
See [base.DebugHashMatch] for more information.
               
               func (f *Func) DebugHashMatch() bool
            
            
            
               
                  DecodePPC64RotateMask 
                  function
                  
                  #
               
               
               DecodePPC64RotateMask is the inverse operation of encodePPC64RotateMask.  The values returned as
mb and me satisfy the POWER ISA definition of MASK(x,y) where MASK(mb,me) = mask.
               
               func DecodePPC64RotateMask(sauxint int64) (rotate int64, mb int64, me int64, mask uint64)
            
            
            
               
                  DivisionNeedsFixUp 
                  function
                  
                  #
               
               
               DivisionNeedsFixUp reports whether the division needs fix-up code.
               
               func DivisionNeedsFixUp(v *Value) bool
            
            
            
               
                  DotDump 
                  method
                  
                  #
               
               
               DotDump dumps the poset in graphviz format to file fn, with the specified title.
               
               func (po *poset) DotDump(fn string, title string) error
            
            
            
               
                  DumpFileForPhase 
                  method
                  
                  #
               
               
               DumpFileForPhase creates a file from the function name and phase name,
warning and returning nil if this is not possible.
               
               func (f *Func) DumpFileForPhase(phaseName string) io.WriteCloser
            
            
            
               
                  Entry 
                  method
                  
                  #
               
               
               func (s *SparseTreeNode) Entry() int32
            
            
            
               
                  Equal 
                  method
                  
                  #
               
               
               Equal reports whether n1==n2. It returns false either when it is
certain that n1==n2 is false, or if there is not enough information
to tell.
Complexity is O(1).
               
               func (po *poset) Equal(n1 *Value, n2 *Value) bool
            
            
            
               
                  Exit 
                  method
                  
                  #
               
               
               func (s *SparseTreeNode) Exit() int32
            
            
            
               
                  Fatalf 
                  method
                  
                  #
               
               
               func (f *Func) Fatalf(msg string, args ...interface{})
            
            
            
               
                  Fatalf 
                  method
                  
                  #
               
               
               Fatalf reports an error and exits.
               
               func (w *HTMLWriter) Fatalf(msg string, args ...interface{})
            
            
            
               
                  Fatalf 
                  method
                  
                  #
               
               
               func (v *Value) Fatalf(msg string, args ...interface{})
            
            
            
               
                  Fatalf 
                  method
                  
                  #
               
               
               func (b *Block) Fatalf(msg string, args ...interface{})
            
            
            
               
                  FirstPossibleStmtValue 
                  method
                  
                  #
               
               
               func (b *Block) FirstPossibleStmtValue() *Value
            
            
            
               
                  FrameOffset 
                  method
                  
                  #
               
               
               func (a *AuxNameOffset) FrameOffset() int64
            
            
            
               
                  Frontend 
                  method
                  
                  #
               
               
               func (f *Func) Frontend() Frontend
            
            
            
               
                  FuncNameABI 
                  function
                  
                  #
               
               
               FuncNameABI returns n followed by a comma and the value of a.
This is a separate function to allow a single point encoding
of the format, which is used in places where there's not a Func yet.
               
               func FuncNameABI(n string, a obj.ABI) string
            
            
            
               
                  GCNum 
                  method
                  
                  #
               
               
               GCNum returns the runtime GC register index of r, or -1 if this
register can't contain pointers.
               
               func (r *Register) GCNum() int16
            
            
            
               
                  GetPPC64Shiftmb 
                  function
                  
                  #
               
               
               func GetPPC64Shiftmb(auxint int64) int64
            
            
            
               
                  GetPPC64Shiftme 
                  function
                  
                  #
               
               
               func GetPPC64Shiftme(auxint int64) int64
            
            
            
               
                  GetPPC64Shiftsh 
                  function
                  
                  #
               
               
               func GetPPC64Shiftsh(auxint int64) int64
            
            
            
               
                  HTML 
                  method
                  
                  #
               
               
               func (v *Value) HTML() string
            
            
            
               
                  HTML 
                  method
                  
                  #
               
               
               func (b *Block) HTML() string
            
            
            
               
                  HTML 
                  method
                  
                  #
               
               
               func (f *Func) HTML(phase string, dot *dotWriter) string
            
            
            
               
                  HasSideEffects 
                  method
                  
                  #
               
               
               func (o Op) HasSideEffects() bool
            
            
            
               
                  Idom 
                  method
                  
                  #
               
               
               Idom returns a map from block ID to the immediate dominator of that block.
f.Entry.ID maps to nil. Unreachable blocks map to nil as well.
               
               func (f *Func) Idom() []*Block
            
            
            
               
                  Index 
                  method
                  
                  #
               
               
               func (e Edge) Index() int
            
            
            
               
                  InterfaceAuxCall 
                  function
                  
                  #
               
               
               InterfaceAuxCall returns an AuxCall for an interface call.
               
               func InterfaceAuxCall(paramResultInfo *abi.ABIParamResultInfo) *AuxCall
            
            
            
               
                  IsAncestorEq 
                  method
                  
                  #
               
               
               IsAncestorEq reports whether x is an ancestor of or equal to y.
               
               func (t SparseTree) IsAncestorEq(x *Block, y *Block) bool
            
            
            
               
                  IsCall 
                  method
                  
                  #
               
               
               func (o Op) IsCall() bool
            
            
            
               
                  IsGlobalAddr 
                  function
                  
                  #
               
               
               IsGlobalAddr reports whether v is known to be an address of a global (or nil).
               
               func IsGlobalAddr(v *Value) bool
            
            
            
               
                  IsInlinableMemmove 
                  function
                  
                  #
               
               
               func IsInlinableMemmove(dst *Value, src *Value, sz int64, c *Config) bool
            
            
            
               
                  IsMergeCandidate 
                  function
                  
                  #
               
               
               IsMergeCandidate returns true if variable n could participate in
stack slot merging. For now we're restricting the set to things to
items larger than what CanSSA would allow (approximateky, we disallow things
marked as open defer slots so as to avoid complicating liveness
analysis.
               
               func IsMergeCandidate(n *ir.Name) bool
            
            
            
               
                  IsNewObject 
                  function
                  
                  #
               
               
               IsNewObject reports whether v is a pointer to a freshly allocated & zeroed object,
if so, also returns the memory state mem at which v is zero.
               
               func IsNewObject(v *Value, select1 []*Value) (mem *Value, ok bool)
            
            
            
               
                  IsReadOnlyGlobalAddr 
                  function
                  
                  #
               
               
               IsReadOnlyGlobalAddr reports whether v is known to be an address of a read-only global.
               
               func IsReadOnlyGlobalAddr(v *Value) bool
            
            
            
               
                  IsSanitizerSafeAddr 
                  function
                  
                  #
               
               
               IsSanitizerSafeAddr reports whether v is known to be an address
that doesn't need instrumentation.
               
               func IsSanitizerSafeAddr(v *Value) bool
            
            
            
               
                  IsStackAddr 
                  function
                  
                  #
               
               
               IsStackAddr reports whether v is known to be an address of a stack slot.
               
               func IsStackAddr(v *Value) bool
            
            
            
               
                  IsTailCall 
                  method
                  
                  #
               
               
               func (o Op) IsTailCall() bool
            
            
            
               
                  IsVarWantedForDebug 
                  function
                  
                  #
               
               
               IsVarWantedForDebug returns true if the debug info for the node should
be generated.
For example, internal variables for range-over-func loops have little
value to users, so we don't generate debug info for them.
               
               func IsVarWantedForDebug(n ir.Node) bool
            
            
            
               
                  LackingPos 
                  method
                  
                  #
               
               
               LackingPos indicates whether v is a value that is unlikely to have a correct
position assigned to it.  Ignoring such values leads to more user-friendly positions
assigned to nearby values and the blocks containing them.
               
               func (v *Value) LackingPos() bool
            
            
            
               
                  LackingPos 
                  method
                  
                  #
               
               
               LackingPos indicates whether b is a block whose position should be inherited
from its successors.  This is true if all the values within it have unreliable positions
and if it is "plain", meaning that there is no control flow that is also very likely
to correspond to a well-understood source position.
               
               func (b *Block) LackingPos() bool
            
            
            
               
                  LateExpansionResultType 
                  method
                  
                  #
               
               
               LateExpansionResultType returns the result type (including trailing mem)
for a call that will be expanded later in the SSA phase.
               
               func (a *AuxCall) LateExpansionResultType() *types.Type
            
            
            
               
                  Len 
                  method
                  
                  #
               
               
               func (fap fileAndPairs) Len() int
            
            
            
               
                  Len 
                  method
                  
                  #
               
               
               func (h ValHeap) Len() int
            
            
            
               
                  Less 
                  method
                  
                  #
               
               
               func (h ValHeap) Less(i int, j int) bool
            
            
            
               
                  Less 
                  method
                  
                  #
               
               
               func (fap fileAndPairs) Less(i int, j int) bool
            
            
            
               
                  LocString 
                  method
                  
                  #
               
               
               func (s *debugState) LocString(loc VarLoc) string
            
            
            
               
                  Log 
                  method
                  
                  #
               
               
               func (b *Block) Log() bool
            
            
            
               
                  Log 
                  method
                  
                  #
               
               
               func (f *Func) Log() bool
            
            
            
               
                  Log 
                  method
                  
                  #
               
               
               func (v *Value) Log() bool
            
            
            
               
                  LogLargeCopy 
                  function
                  
                  #
               
               
               func LogLargeCopy(funcName string, pos src.XPos, s int64)
            
            
            
               
                  LogStat 
                  method
                  
                  #
               
               
               LogStat writes a string key and int value as a warning in a
tab-separated format easily handled by spreadsheets or awk.
file names, lines, and function names are included to provide enough (?)
context to allow item-by-item comparisons across runs.
For example:
awk 'BEGIN {FS="\t"} $3~/TIME/{sum+=$4} END{print "t(ns)=",sum}' t.log
               
               func (f *Func) LogStat(key string, args ...interface{})
            
            
            
               
                  Logf 
                  method
                  
                  #
               
               
               func (v *Value) Logf(msg string, args ...interface{})
            
            
            
               
                  Logf 
                  method
                  
                  #
               
               
               func (f *Func) Logf(msg string, args ...interface{})
            
            
            
               
                  Logf 
                  method
                  
                  #
               
               
               Logf calls the (w *HTMLWriter).Func's Logf method passing along a msg and args.
               
               func (w *HTMLWriter) Logf(msg string, args ...interface{})
            
            
            
               
                  Logf 
                  method
                  
                  #
               
               
               func (b *Block) Logf(msg string, args ...interface{})
            
            
            
               
                  LongHTML 
                  method
                  
                  #
               
               
               func (v *Value) LongHTML() string
            
            
            
               
                  LongHTML 
                  method
                  
                  #
               
               
               func (b *Block) LongHTML() string
            
            
            
               
                  LongString 
                  method
                  
                  #
               
               
               func (l *loop) LongString() string
            
            
            
               
                  LongString 
                  method
                  
                  #
               
               
               long form print.  v# = opcode  [aux] args [: reg] (names)
               
               func (v *Value) LongString() string
            
            
            
               
                  LongString 
                  method
                  
                  #
               
               
               long form print
               
               func (b *Block) LongString() string
            
            
            
               
                  MemoryArg 
                  method
                  
                  #
               
               
               MemoryArg returns the memory argument for the Value.
The returned value, if non-nil, will be memory-typed (or a tuple with a memory-typed second part).
Otherwise, nil is returned.
               
               func (v *Value) MemoryArg() *Value
            
            
            
               
                  N 
                  method
                  
                  #
               
               
               N reports whether the result of an operation is negative (high bit set).
               
               func (fc flagConstant) N() bool
            
            
            
               
                  NArgs 
                  method
                  
                  #
               
               
               NArgs returns the number of arguments (including receiver, if there is one).
               
               func (a *AuxCall) NArgs() int64
            
            
            
               
                  NResults 
                  method
                  
                  #
               
               
               NResults returns the number of results.
               
               func (a *AuxCall) NResults() int64
            
            
            
               
                  NameABI 
                  method
                  
                  #
               
               
               NameABI returns the function name followed by comma and the ABI number.
This is intended for use with GOSSAFUNC and HTML dumps, and differs from
the linker's "<1>" convention because "<" and ">" require shell quoting
and are not legal file names (for use with GOSSADIR) on Windows.
               
               func (f *Func) NameABI() string
            
            
            
               
                  NameOfResult 
                  method
                  
                  #
               
               
               NameOfResult returns the ir.Name of result which (indexed 0, 1, etc).
               
               func (a *AuxCall) NameOfResult(which int64) *ir.Name
            
            
            
               
                  NewBlock 
                  method
                  
                  #
               
               
               NewBlock allocates a new Block of the given kind and places it at the end of f.Blocks.
               
               func (f *Func) NewBlock(kind BlockKind) *Block
            
            
            
               
                  NewConfig 
                  function
                  
                  #
               
               
               NewConfig returns a new configuration object for the given architecture.
               
               func NewConfig(arch string, types Types, ctxt *obj.Link, optimize bool, softfloat bool) *Config
            
            
            
               
                  NewFunc 
                  method
                  
                  #
               
               
               NewFunc returns a new, empty function object.
Caller must reset cache before calling NewFunc.
               
               func (c *Config) NewFunc(fe Frontend, cache *Cache) *Func
            
            
            
               
                  NewHTMLWriter 
                  function
                  
                  #
               
               
               func NewHTMLWriter(path string, f *Func, cfgMask string) *HTMLWriter
            
            
            
               
                  NewLocal 
                  method
                  
                  #
               
               
               NewLocal returns a new anonymous local variable of the given type.
               
               func (f *Func) NewLocal(pos src.XPos, typ *types.Type) *ir.Name
            
            
            
               
                  NewTypes 
                  function
                  
                  #
               
               
               NewTypes creates and populates a Types.
               
               func NewTypes() *Types
            
            
            
               
                  NewValue0 
                  method
                  
                  #
               
               
               NewValue0 returns a new value in the block with no arguments and zero aux values.
               
               func (b *Block) NewValue0(pos src.XPos, op Op, t *types.Type) *Value
            
            
            
               
                  NewValue0A 
                  method
                  
                  #
               
               
               NewValue0A returns a new value in the block with no arguments and an aux value.
               
               func (b *Block) NewValue0A(pos src.XPos, op Op, t *types.Type, aux Aux) *Value
            
            
            
               
                  NewValue0I 
                  method
                  
                  #
               
               
               NewValue0I returns a new value in the block with no arguments and an auxint value.
               
               func (b *Block) NewValue0I(pos src.XPos, op Op, t *types.Type, auxint int64) *Value
            
            
            
               
                  NewValue0IA 
                  method
                  
                  #
               
               
               NewValue0IA returns a new value in the block with no arguments and both an auxint and aux values.
               
               func (b *Block) NewValue0IA(pos src.XPos, op Op, t *types.Type, auxint int64, aux Aux) *Value
            
            
            
               
                  NewValue1 
                  method
                  
                  #
               
               
               NewValue1 returns a new value in the block with one argument and zero aux values.
               
               func (b *Block) NewValue1(pos src.XPos, op Op, t *types.Type, arg *Value) *Value
            
            
            
               
                  NewValue1A 
                  method
                  
                  #
               
               
               NewValue1A returns a new value in the block with one argument and an aux value.
               
               func (b *Block) NewValue1A(pos src.XPos, op Op, t *types.Type, aux Aux, arg *Value) *Value
            
            
            
               
                  NewValue1I 
                  method
                  
                  #
               
               
               NewValue1I returns a new value in the block with one argument and an auxint value.
               
               func (b *Block) NewValue1I(pos src.XPos, op Op, t *types.Type, auxint int64, arg *Value) *Value
            
            
            
               
                  NewValue1IA 
                  method
                  
                  #
               
               
               NewValue1IA returns a new value in the block with one argument and both an auxint and aux values.
               
               func (b *Block) NewValue1IA(pos src.XPos, op Op, t *types.Type, auxint int64, aux Aux, arg *Value) *Value
            
            
            
               
                  NewValue2 
                  method
                  
                  #
               
               
               NewValue2 returns a new value in the block with two arguments and zero aux values.
               
               func (b *Block) NewValue2(pos src.XPos, op Op, t *types.Type, arg0 *Value, arg1 *Value) *Value
            
            
            
               
                  NewValue2A 
                  method
                  
                  #
               
               
               NewValue2A returns a new value in the block with two arguments and one aux values.
               
               func (b *Block) NewValue2A(pos src.XPos, op Op, t *types.Type, aux Aux, arg0 *Value, arg1 *Value) *Value
            
            
            
               
                  NewValue2I 
                  method
                  
                  #
               
               
               NewValue2I returns a new value in the block with two arguments and an auxint value.
               
               func (b *Block) NewValue2I(pos src.XPos, op Op, t *types.Type, auxint int64, arg0 *Value, arg1 *Value) *Value
            
            
            
               
                  NewValue2IA 
                  method
                  
                  #
               
               
               NewValue2IA returns a new value in the block with two arguments and both an auxint and aux values.
               
               func (b *Block) NewValue2IA(pos src.XPos, op Op, t *types.Type, auxint int64, aux Aux, arg0 *Value, arg1 *Value) *Value
            
            
            
               
                  NewValue3 
                  method
                  
                  #
               
               
               NewValue3 returns a new value in the block with three arguments and zero aux values.
               
               func (b *Block) NewValue3(pos src.XPos, op Op, t *types.Type, arg0 *Value, arg1 *Value, arg2 *Value) *Value
            
            
            
               
                  NewValue3A 
                  method
                  
                  #
               
               
               NewValue3A returns a new value in the block with three argument and an aux value.
               
               func (b *Block) NewValue3A(pos src.XPos, op Op, t *types.Type, aux Aux, arg0 *Value, arg1 *Value, arg2 *Value) *Value
            
            
            
               
                  NewValue3I 
                  method
                  
                  #
               
               
               NewValue3I returns a new value in the block with three arguments and an auxint value.
               
               func (b *Block) NewValue3I(pos src.XPos, op Op, t *types.Type, auxint int64, arg0 *Value, arg1 *Value, arg2 *Value) *Value
            
            
            
               
                  NewValue4 
                  method
                  
                  #
               
               
               NewValue4 returns a new value in the block with four arguments and zero aux values.
               
               func (b *Block) NewValue4(pos src.XPos, op Op, t *types.Type, arg0 *Value, arg1 *Value, arg2 *Value, arg3 *Value) *Value
            
            
            
               
                  NewValue4I 
                  method
                  
                  #
               
               
               NewValue4I returns a new value in the block with four arguments and auxint value.
               
               func (b *Block) NewValue4I(pos src.XPos, op Op, t *types.Type, auxint int64, arg0 *Value, arg1 *Value, arg2 *Value, arg3 *Value) *Value
            
            
            
               
                  NonEqual 
                  method
                  
                  #
               
               
               NonEqual reports whether n1!=n2. It returns false either when it is
certain that n1!=n2 is false, or if there is not enough information
to tell.
Complexity is O(n) (because it internally calls Ordered to see if we
can infer n1!=n2 from n1
               
               func (po *poset) NonEqual(n1 *Value, n2 *Value) bool
            
            
            
               
                  NumBlocks 
                  method
                  
                  #
               
               
               NumBlocks returns an integer larger than the id of any Block in the Func.
               
               func (f *Func) NumBlocks() int
            
            
            
               
                  NumControls 
                  method
                  
                  #
               
               
               NumControls returns the number of non-nil control values the
block has.
               
               func (b *Block) NumControls() int
            
            
            
               
                  NumValues 
                  method
                  
                  #
               
               
               NumValues returns an integer larger than the id of any Value in the Func.
               
               func (f *Func) NumValues() int
            
            
            
               
                  ObjNum 
                  method
                  
                  #
               
               
               ObjNum returns the register number from cmd/internal/obj/$ARCH that
corresponds to this register.
               
               func (r *Register) ObjNum() int16
            
            
            
               
                  ObjRegForAbiReg 
                  function
                  
                  #
               
               
               For ABI register index r, returns the register number used in the obj
package (assembler).
               
               func ObjRegForAbiReg(r abi.RegIndex, c *Config) int16
            
            
            
               
                  Off 
                  method
                  
                  #
               
               
               func (x ValAndOff) Off() int32
            
            
            
               
                  Off64 
                  method
                  
                  #
               
               
               func (x ValAndOff) Off64() int64
            
            
            
               
                  OffsetOfArg 
                  method
                  
                  #
               
               
               OffsetOfArg returns the SP offset of argument which (indexed 0, 1, etc).
If the call is to a method, the receiver is the first argument (i.e., index 0)
               
               func (a *AuxCall) OffsetOfArg(which int64) int64
            
            
            
               
                  OffsetOfResult 
                  method
                  
                  #
               
               
               OffsetOfResult returns the SP offset of result which (indexed 0, 1, etc).
               
               func (a *AuxCall) OffsetOfResult(which int64) int64
            
            
            
               
                  Ordered 
                  method
                  
                  #
               
               
               Ordered reports whether n1
               
               func (po *poset) Ordered(n1 *Value, n2 *Value) bool
            
            
            
               
                  OrderedOrEqual 
                  method
                  
                  #
               
               
               OrderedOrEqual reports whether n1<=n2. It returns false either when it is
certain that n1<=n2 is false, or if there is not enough information
to tell.
Complexity is O(n).
               
               func (po *poset) OrderedOrEqual(n1 *Value, n2 *Value) bool
            
            
            
               
                  OwnAuxCall 
                  function
                  
                  #
               
               
               OwnAuxCall returns a function's own AuxCall.
               
               func OwnAuxCall(fn *obj.LSym, paramResultInfo *abi.ABIParamResultInfo) *AuxCall
            
            
            
               
                  ParamAssignmentForArgName 
                  function
                  
                  #
               
               
               ParamAssignmentForArgName returns the ABIParamAssignment for f's arg with matching name.
               
               func ParamAssignmentForArgName(f *Func, name *ir.Name) *abi.ABIParamAssignment
            
            
            
               
                  ParamAssignmentForResult 
                  method
                  
                  #
               
               
               ParamAssignmentForResult returns the ABI Parameter assignment for result which (indexed 0, 1, etc).
               
               func (a *AuxCall) ParamAssignmentForResult(which int64) *abi.ABIParamAssignment
            
            
            
               
                  Parent 
                  method
                  
                  #
               
               
               Parent returns the parent of x in the dominator tree, or
nil if x is the function's entry.
               
               func (t SparseTree) Parent(x *Block) *Block
            
            
            
               
                  PhaseOption 
                  function
                  
                  #
               
               
               PhaseOption sets the specified flag in the specified ssa phase,
returning empty string if this was successful or a string explaining
the error if it was not.
A version of the phase name with "_" replaced by " " is also checked for a match.
If the phase name begins a '~' then the rest of the underscores-replaced-with-blanks
version is used as a regular expression to match the phase name(s).
Special cases that have turned out to be useful:
- ssa/check/on enables checking after each phase
- ssa/all/time enables time reporting for all phases
See gc/lex.go for dissection of the option string.
Example uses:
GO_GCFLAGS=-d=ssa/generic_cse/time,ssa/generic_cse/stats,ssa/generic_cse/debug=3 ./make.bash
BOOT_GO_GCFLAGS=-d='ssa/~^.*scc$/off' GO_GCFLAGS='-d=ssa/~^.*scc$/off' ./make.bash
               
               func PhaseOption(phase string, flag string, val int, valString string) string
            
            
            
               
                  Pop 
                  method
                  
                  #
               
               
               func (h *ValHeap) Pop() interface{}
            
            
            
               
                  PopulateABIInRegArgOps 
                  function
                  
                  #
               
               
               PopulateABIInRegArgOps examines the entry block of the function
and looks for incoming parameters that have missing or partial
OpArg{Int,Float}Reg values, inserting additional values in
cases where they are missing. Example:
func foo(s string, used int, notused int) int {
return len(s) + used
}
In the function above, the incoming parameter "used" is fully live,
"notused" is not live, and "s" is partially live (only the length
field of the string is used). At the point where debug value
analysis runs, we might expect to see an entry block with:
b1:
v4 = ArgIntReg  {s+8} [0] : BX
v5 = ArgIntReg  {used} [0] : CX
While this is an accurate picture of the live incoming params,
we also want to have debug locations for non-live params (or
their non-live pieces), e.g. something like
b1:
v9 = ArgIntReg <*uint8> {s+0} [0] : AX
v4 = ArgIntReg  {s+8} [0] : BX
v5 = ArgIntReg  {used} [0] : CX
v10 = ArgIntReg  {unused} [0] : DI
This function examines the live OpArg{Int,Float}Reg values and
synthesizes new (dead) values for the non-live params or the
non-live pieces of partially live params.
               
               func PopulateABIInRegArgOps(f *Func)
            
            
            
               
                  Postorder 
                  method
                  
                  #
               
               
               func (f *Func) Postorder() []*Block
            
            
            
               
                  Printf 
                  method
                  
                  #
               
               
               func (w *HTMLWriter) Printf(msg string, v ...interface{})
            
            
            
               
                  Printf 
                  method
                  
                  #
               
               
               Printf does an indented fmt.Printf on the format and args.
               
               func (x *expandState) Printf(format string, a ...interface{}) (n int, err error)
            
            
            
               
                  Push 
                  method
                  
                  #
               
               
               func (h *ValHeap) Push(x interface{})
            
            
            
               
                  PutLocationList 
                  method
                  
                  #
               
               
               PutLocationList adds list (a location list in its intermediate representation) to listSym.
               
               func (debugInfo *FuncDebug) PutLocationList(list []byte, ctxt *obj.Link, listSym *obj.LSym, startPC *obj.LSym)
            
            
            
               
                  ReachableBlocks 
                  function
                  
                  #
               
               
               ReachableBlocks returns the reachable blocks in f.
               
               func ReachableBlocks(f *Func) []bool
            
            
            
               
                  Reg 
                  method
                  
                  #
               
               
               Reg returns the regInfo for a given call, combining the derived in/out register masks
with the machine-specific register information in the input i.  (The machine-specific
regInfo is much handier at the call site than it is when the AuxCall is being constructed,
therefore do this lazily).
TODO: there is a Clever Hack that allows pre-generation of a small-ish number of the slices
of inputInfo and outputInfo used here, provided that we are willing to reorder the inputs
and outputs from calls, so that all integer registers come first, then all floating registers.
At this point (active development of register ABI) that is very premature,
but if this turns out to be a cost, we could do it.
               
               func (a *AuxCall) Reg(i *regInfo, c *Config) *regInfo
            
            
            
               
                  Reg 
                  method
                  
                  #
               
               
               Reg returns the register assigned to v, in cmd/internal/obj/$ARCH numbering.
               
               func (v *Value) Reg() int16
            
            
            
               
                  Reg0 
                  method
                  
                  #
               
               
               Reg0 returns the register assigned to the first output of v, in cmd/internal/obj/$ARCH numbering.
               
               func (v *Value) Reg0() int16
            
            
            
               
                  Reg1 
                  method
                  
                  #
               
               
               Reg1 returns the register assigned to the second output of v, in cmd/internal/obj/$ARCH numbering.
               
               func (v *Value) Reg1() int16
            
            
            
               
                  RegMaskString 
                  method
                  
                  #
               
               
               func (s *regAllocState) RegMaskString(m regMask) string
            
            
            
               
                  RegName 
                  method
                  
                  #
               
               
               func (v *Value) RegName() string
            
            
            
               
                  RegTmp 
                  method
                  
                  #
               
               
               RegTmp returns the temporary register assigned to v, in cmd/internal/obj/$ARCH numbering.
               
               func (v *Value) RegTmp() int16
            
            
            
               
                  RegsOfArg 
                  method
                  
                  #
               
               
               RegsOfArg returns the register(s) used for argument which (indexed 0, 1, etc).
If the call is to a method, the receiver is the first argument (i.e., index 0)
               
               func (a *AuxCall) RegsOfArg(which int64) []abi.RegIndex
            
            
            
               
                  RegsOfResult 
                  method
                  
                  #
               
               
               RegsOfResult returns the register(s) used for result which (indexed 0, 1, etc).
               
               func (a *AuxCall) RegsOfResult(which int64) []abi.RegIndex
            
            
            
               
                  ReplaceControl 
                  method
                  
                  #
               
               
               ReplaceControl exchanges the existing control value at the index provided
for the new value. The index must refer to a valid control value.
               
               func (b *Block) ReplaceControl(i int, v *Value)
            
            
            
               
                  Reset 
                  method
                  
                  #
               
               
               func (c *Cache) Reset()
            
            
            
               
                  Reset 
                  method
                  
                  #
               
               
               func (bs bitset) Reset()
            
            
            
               
                  Reset 
                  method
                  
                  #
               
               
               Reset sets the block to the provided kind and clears all the blocks control
and auxiliary values. Other properties of the block, such as its successors,
predecessors and values are left unmodified.
               
               func (b *Block) Reset(kind BlockKind)
            
            
            
               
                  ResetControls 
                  method
                  
                  #
               
               
               ResetControls sets the number of controls for the block to 0.
               
               func (b *Block) ResetControls()
            
            
            
               
                  ResultInArg0 
                  method
                  
                  #
               
               
               func (o Op) ResultInArg0() bool
            
            
            
               
                  ResultReg 
                  method
                  
                  #
               
               
               ResultReg returns the result register assigned to v, in cmd/internal/obj/$ARCH numbering.
It is similar to Reg and Reg0, except that it is usable interchangeably for all Value Ops.
If you know v.Op, using Reg or Reg0 (as appropriate) will be more efficient.
               
               func (v *Value) ResultReg() int16
            
            
            
               
                  ResultReg 
                  method
                  
                  #
               
               
               func (a *AuxCall) ResultReg(c *Config) *regInfo
            
            
            
               
                  Scale 
                  method
                  
                  #
               
               
               func (o Op) Scale() int16
            
            
            
               
                  Sdom 
                  method
                  
                  #
               
               
               Sdom returns a sparse tree representing the dominator relationships
among the blocks of f.
               
               func (f *Func) Sdom() SparseTree
            
            
            
               
                  Set 
                  method
                  
                  #
               
               
               func (bs bitset) Set(idx uint32)
            
            
            
               
                  SetArg 
                  method
                  
                  #
               
               
               func (v *Value) SetArg(i int, w *Value)
            
            
            
               
                  SetArgs1 
                  method
                  
                  #
               
               
               func (v *Value) SetArgs1(a *Value)
            
            
            
               
                  SetArgs2 
                  method
                  
                  #
               
               
               func (v *Value) SetArgs2(a *Value, b *Value)
            
            
            
               
                  SetArgs3 
                  method
                  
                  #
               
               
               func (v *Value) SetArgs3(a *Value, b *Value, c *Value)
            
            
            
               
                  SetControl 
                  method
                  
                  #
               
               
               SetControl removes all existing control values and then adds
the control value provided. The number of control values after
a call to SetControl will always be 1.
               
               func (b *Block) SetControl(v *Value)
            
            
            
               
                  SetEqual 
                  method
                  
                  #
               
               
               SetEqual records that n1==n2. Returns false if this is a contradiction
(that is, if it is already recorded that n1
               
               func (po *poset) SetEqual(n1 *Value, n2 *Value) bool
            
            
            
               
                  SetNonEqual 
                  method
                  
                  #
               
               
               SetNonEqual records that n1!=n2. Returns false if this is a contradiction
(that is, if it is already recorded that n1==n2).
Complexity is O(n).
               
               func (po *poset) SetNonEqual(n1 *Value, n2 *Value) bool
            
            
            
               
                  SetOrder 
                  method
                  
                  #
               
               
               SetOrder records that n1
               
               func (po *poset) SetOrder(n1 *Value, n2 *Value) bool
            
            
            
               
                  SetOrderOrEqual 
                  method
                  
                  #
               
               
               SetOrderOrEqual records that n1<=n2. Returns false if this is a contradiction
Complexity is O(1) if n2 was never seen before, or O(n) otherwise.
               
               func (po *poset) SetOrderOrEqual(n1 *Value, n2 *Value) bool
            
            
            
               
                  SetTypPtrs 
                  method
                  
                  #
               
               
               SetTypPtrs populates t.
               
               func (t *Types) SetTypPtrs()
            
            
            
               
                  SetUnsigned 
                  method
                  
                  #
               
               
               func (po *poset) SetUnsigned(uns bool)
            
            
            
               
                  Sibling 
                  method
                  
                  #
               
               
               Sibling returns a sibling of x in the dominator tree (i.e.,
a node with the same immediate dominator) or nil if there
are no remaining siblings in the arbitrary but repeatable
order chosen. Because the Child-Sibling order is used
to assign entry and exit numbers in the treewalk, those
numbers are also consistent with this order (i.e.,
Sibling(x) has entry number larger than x's exit number).
               
               func (t SparseTree) Sibling(x *Block) *Block
            
            
            
               
                  SizeOfArg 
                  method
                  
                  #
               
               
               SizeOfArg returns the size of argument which (indexed 0, 1, etc).
If the call is to a method, the receiver is the first argument (i.e., index 0)
               
               func (a *AuxCall) SizeOfArg(which int64) int64
            
            
            
               
                  SizeOfResult 
                  method
                  
                  #
               
               
               SizeOfResult returns the size of result which (indexed 0, 1, etc).
               
               func (a *AuxCall) SizeOfResult(which int64) int64
            
            
            
               
                  SplitArray 
                  method
                  
                  #
               
               
               func (f *Func) SplitArray(name *LocalSlot) *LocalSlot
            
            
            
               
                  SplitComplex 
                  method
                  
                  #
               
               
               func (f *Func) SplitComplex(name *LocalSlot) (*LocalSlot, *LocalSlot)
            
            
            
               
                  SplitInt64 
                  method
                  
                  #
               
               
               func (f *Func) SplitInt64(name *LocalSlot) (*LocalSlot, *LocalSlot)
            
            
            
               
                  SplitInterface 
                  method
                  
                  #
               
               
               func (f *Func) SplitInterface(name *LocalSlot) (*LocalSlot, *LocalSlot)
            
            
            
               
                  SplitSlice 
                  method
                  
                  #
               
               
               func (f *Func) SplitSlice(name *LocalSlot) (*LocalSlot, *LocalSlot, *LocalSlot)
            
            
            
               
                  SplitSlot 
                  method
                  
                  #
               
               
               func (f *Func) SplitSlot(name *LocalSlot, sfx string, offset int64, t *types.Type) *LocalSlot
            
            
            
               
                  SplitString 
                  method
                  
                  #
               
               
               func (f *Func) SplitString(name *LocalSlot) (*LocalSlot, *LocalSlot)
            
            
            
               
                  SplitStruct 
                  method
                  
                  #
               
               
               func (f *Func) SplitStruct(name *LocalSlot, i int) *LocalSlot
            
            
            
               
                  StaticAuxCall 
                  function
                  
                  #
               
               
               StaticAuxCall returns an AuxCall for a static call.
               
               func StaticAuxCall(sym *obj.LSym, paramResultInfo *abi.ABIParamResultInfo) *AuxCall
            
            
            
               
                  StmtString 
                  function
                  
                  #
               
               
               func StmtString(p src.XPos) string
            
            
            
               
                  Strict 
                  method
                  
                  #
               
               
               func (e posetEdge) Strict() bool
            
            
            
               
                  String 
                  method
                  
                  #
               
               
               func (ls *liveSlot) String() string
            
            
            
               
                  String 
                  method
                  
                  #
               
               
               func (r *rewrite) String() string
            
            
            
               
                  String 
                  method
                  
                  #
               
               
               func (x ValAndOff) String() string
            
            
            
               
                  String 
                  method
                  
                  #
               
               
               func (f *Func) String() string
            
            
            
               
                  String 
                  method
                  
                  #
               
               
               func (l limit) String() string
            
            
            
               
                  String 
                  method
                  
                  #
               
               
               func (r *Register) String() string
            
            
            
               
                  String 
                  method
                  
                  #
               
               
               func (e Edge) String() string
            
            
            
               
                  String 
                  method
                  
                  #
               
               
               short form print
               
               func (b *Block) String() string
            
            
            
               
                  String 
                  method
                  
                  #
               
               
               func (s LocalSlot) String() string
            
            
            
               
                  String 
                  method
                  
                  #
               
               
               short form print. Just v#.
               
               func (v *Value) String() string
            
            
            
               
                  String 
                  method
                  
                  #
               
               
               func (r *regInfo) String() string
            
            
            
               
                  String 
                  method
                  
                  #
               
               
               func (e posetEdge) String() string
            
            
            
               
                  String 
                  method
                  
                  #
               
               
               func (c *registerCursor) String() string
            
            
            
               
                  String 
                  method
                  
                  #
               
               
               func (o Op) String() string
            
            
            
               
                  String 
                  method
                  
                  #
               
               
               func (fc flagConstant) String() string
            
            
            
               
                  String 
                  method
                  
                  #
               
               
               func (b branch) String() string
            
            
            
               
                  String 
                  method
                  
                  #
               
               
               func (k BlockKind) String() string
            
            
            
               
                  String 
                  method
                  
                  #
               
               
               func (l *loop) String() string
            
            
            
               
                  String 
                  method
                  
                  #
               
               
               func (p *pass) String() string
            
            
            
               
                  String 
                  method
                  
                  #
               
               
               func (t LocPair) String() string
            
            
            
               
                  String 
                  method
                  
                  #
               
               
               func (s *SparseTreeNode) String() string
            
            
            
               
                  String 
                  method
                  
                  #
               
               
               func (t LocResults) String() string
            
            
            
               
                  String 
                  method
                  
                  #
               
               
               func (m regMask) String() string
            
            
            
               
                  String 
                  method
                  
                  #
               
               
               func (a *AuxNameOffset) String() string
            
            
            
               
                  String 
                  method
                  
                  #
               
               
               func (d domain) String() string
            
            
            
               
                  String 
                  method
                  
                  #
               
               
               String returns "AuxCall{}"
               
               func (a *AuxCall) String() string
            
            
            
               
                  String 
                  method
                  
                  #
               
               
               func (r relation) String() string
            
            
            
               
                  StringToAux 
                  function
                  
                  #
               
               
               func StringToAux(s string) Aux
            
            
            
               
                  Swap 
                  method
                  
                  #
               
               
               func (fap fileAndPairs) Swap(i int, j int)
            
            
            
               
                  Swap 
                  method
                  
                  #
               
               
               func (h ValHeap) Swap(i int, j int)
            
            
            
               
                  SymEffect 
                  method
                  
                  #
               
               
               func (o Op) SymEffect() SymEffect
            
            
            
               
                  Target 
                  method
                  
                  #
               
               
               func (e posetEdge) Target() uint32
            
            
            
               
                  TypeOfArg 
                  method
                  
                  #
               
               
               TypeOfArg returns the type of argument which (indexed 0, 1, etc).
If the call is to a method, the receiver is the first argument (i.e., index 0)
               
               func (a *AuxCall) TypeOfArg(which int64) *types.Type
            
            
            
               
                  TypeOfResult 
                  method
                  
                  #
               
               
               TypeOfResult returns the type of result which (indexed 0, 1, etc).
               
               func (a *AuxCall) TypeOfResult(which int64) *types.Type
            
            
            
               
                  Undo 
                  method
                  
                  #
               
               
               Undo restores the state of the poset to the previous checkpoint.
Complexity depends on the type of operations that were performed
since the last checkpoint; each Set* operation creates an undo
pass which Undo has to revert with a worst-case complexity of O(n).
               
               func (po *poset) Undo()
            
            
            
               
                  UnsafePoint 
                  method
                  
                  #
               
               
               func (o Op) UnsafePoint() bool
            
            
            
               
                  V 
                  method
                  
                  #
               
               
               V reports whether a signed operation overflowed or underflowed.
               
               func (fc flagConstant) V() bool
            
            
            
               
                  Val 
                  method
                  
                  #
               
               
               func (x ValAndOff) Val() int32
            
            
            
               
                  Val16 
                  method
                  
                  #
               
               
               func (x ValAndOff) Val16() int16
            
            
            
               
                  Val64 
                  method
                  
                  #
               
               
               func (x ValAndOff) Val64() int64
            
            
            
               
                  Val8 
                  method
                  
                  #
               
               
               func (x ValAndOff) Val8() int8
            
            
            
               
                  Warnl 
                  method
                  
                  #
               
               
               func (f *Func) Warnl(pos src.XPos, msg string, args ...interface{})
            
            
            
               
                  WriteAST 
                  method
                  
                  #
               
               
               func (w *HTMLWriter) WriteAST(phase string, buf *bytes.Buffer)
            
            
            
               
                  WriteColumn 
                  method
                  
                  #
               
               
               WriteColumn writes raw HTML in a column headed by title.
It is intended for pre- and post-compilation log output.
               
               func (w *HTMLWriter) WriteColumn(phase string, title string, class string, html string)
            
            
            
               
                  WriteMultiTitleColumn 
                  method
                  
                  #
               
               
               func (w *HTMLWriter) WriteMultiTitleColumn(phase string, titles []string, class string, html string)
            
            
            
               
                  WritePhase 
                  method
                  
                  #
               
               
               WritePhase writes f in a column headed by title.
phase is used for collapsing columns and should be unique across the table.
               
               func (w *HTMLWriter) WritePhase(phase string, title string)
            
            
            
               
                  WriteSources 
                  method
                  
                  #
               
               
               WriteSources writes lines as source code in a column headed by title.
phase is used for collapsing columns and should be unique across the table.
               
               func (w *HTMLWriter) WriteSources(phase string, all []*FuncLines)
            
            
            
               
                  WriteString 
                  method
                  
                  #
               
               
               func (w *HTMLWriter) WriteString(s string)
            
            
            
               
                  Z 
                  method
                  
                  #
               
               
               Z reports whether the result of an operation is 0.
               
               func (fc flagConstant) Z() bool
            
            
            
               
                  absent 
                  method
                  
                  #
               
               
               func (loc VarLoc) absent() bool
            
            
            
               
                  absent 
                  method
                  
                  #
               
               
               func (ls liveSlot) absent() bool
            
            
            
               
                  add 
                  method
                  
                  #
               
               
               add adds p to m, treating m as a set instead of as a map.
If p does not fall within the set of fileindex->lineRange used to construct m, this will panic.
Use clear() in between set/map interpretations of m.
               
               func (m *xposmap) add(p src.XPos)
            
            
            
               
                  add 
                  method
                  
                  #
               
               
               add inserts x->0 into s, provided that x is in the range of keys stored in s.
               
               func (s *biasedSparseMap) add(x uint)
            
            
            
               
                  add 
                  method
                  
                  #
               
               
               add returns the limit obtained by adding a value with limit l
to a value with limit l2. The result must fit in b bits.
               
               func (l limit) add(l2 limit, b uint) limit
            
            
            
               
                  add 
                  method
                  
                  #
               
               
               add records that we'd like value vid to be in register r.
               
               func (d *desiredState) add(vid ID, r register)
            
            
            
               
                  add 
                  method
                  
                  #
               
               
               func (s *sparseSet) add(x ID)
            
            
            
               
                  addAll 
                  method
                  
                  #
               
               
               func (s *sparseSet) addAll(a []ID)
            
            
            
               
                  addAllValues 
                  method
                  
                  #
               
               
               func (s *sparseSet) addAllValues(a []*Value)
            
            
            
               
                  addArg 
                  method
                  
                  #
               
               
               func (c *registerCursor) addArg(v *Value)
            
            
            
               
                  addBranchRestrictions 
                  function
                  
                  #
               
               
               addBranchRestrictions updates the factsTables ft with the facts learned when
branching from Block b in direction br.
               
               func addBranchRestrictions(ft *factsTable, b *Block, br branch)
            
            
            
               
                  addDFphis 
                  function
                  
                  #
               
               
               addDFphis creates new trivial phis that are necessary to correctly reflect (within SSA)
a new definition for variable "x" inserted at h (usually but not necessarily a phi).
These new phis can only occur at the dominance frontier of h; block s is in the dominance
frontier of h if h does not strictly dominate s and if s is a successor of a block b where
either b = h or h strictly dominates b.
These newly created phis are themselves new definitions that may require addition of their
own trivial phi functions in their own dominance frontier, and this is handled recursively.
               
               func addDFphis(x *Value, h *Block, b *Block, f *Func, defForUses []*Value, newphis map[*Block]rewrite, sdom SparseTree)
            
            
            
               
                  addDump 
                  method
                  
                  #
               
               
               func (p *pass) addDump(s string)
            
            
            
               
                  addFlags32 
                  function
                  
                  #
               
               
               addFlags32 returns the flags that would be set from computing x+y.
               
               func addFlags32(x int32, y int32) flagConstant
            
            
            
               
                  addFlags64 
                  function
                  
                  #
               
               
               addFlags64 returns the flags that would be set from computing x+y.
               
               func addFlags64(x int64, y int64) flagConstant
            
            
            
               
                  addIndVarRestrictions 
                  function
                  
                  #
               
               
               addIndVarRestrictions updates the factsTables ft with the facts
learned from the induction variable indVar which drives the loop
starting in Block b.
               
               func addIndVarRestrictions(ft *factsTable, b *Block, iv indVar)
            
            
            
               
                  addList 
                  method
                  
                  #
               
               
               func (d *desiredState) addList(vid ID, regs [4]register)
            
            
            
               
                  addLocalFacts 
                  function
                  
                  #
               
               
               func addLocalFacts(ft *factsTable, b *Block)
            
            
            
               
                  addLocalFactsPhi 
                  function
                  
                  #
               
               
               func addLocalFactsPhi(ft *factsTable, v *Value)
            
            
            
               
                  addOffset32 
                  method
                  
                  #
               
               
               func (x ValAndOff) addOffset32(off int32) ValAndOff
            
            
            
               
                  addOffset64 
                  method
                  
                  #
               
               
               func (x ValAndOff) addOffset64(off int64) ValAndOff
            
            
            
               
                  addOrdering 
                  method
                  
                  #
               
               
               func (ft *factsTable) addOrdering(v *Value, w *Value, d domain, r relation)
            
            
            
               
                  addRestrictions 
                  function
                  
                  #
               
               
               addRestrictions updates restrictions from the immediate
dominating block (p) using r.
               
               func addRestrictions(parent *Block, ft *factsTable, t domain, v *Value, w *Value, r relation)
            
            
            
               
                  addU 
                  function
                  
                  #
               
               
               addU returns x+y. Requires that x+y does not overflow an int64.
               
               func addU(x int64, y uint64) int64
            
            
            
               
                  addUse 
                  method
                  
                  #
               
               
               Adds a use record for id at distance dist from the start of the block.
All calls to addUse must happen with nonincreasing dist.
               
               func (s *regAllocState) addUse(id ID, dist int32, pos src.XPos)
            
            
            
               
                  addUses 
                  method
                  
                  #
               
               
               addUses finds all uses of value and appends them into work list for further process
               
               func (t *worklist) addUses(val *Value)
            
            
            
               
                  addWillOverflow 
                  function
                  
                  #
               
               
               addWillOverflow reports whether x+y would result in a value more than maxint.
               
               func addWillOverflow(x int64, y int64) bool
            
            
            
               
                  addchild 
                  method
                  
                  #
               
               
               addchild adds i2 as direct child of i1.
               
               func (po *poset) addchild(i1 uint32, i2 uint32, strict bool)
            
            
            
               
                  addressingModes 
                  function
                  
                  #
               
               
               addressingModes combines address calculations into memory operations
that can perform complicated addressing modes.
               
               func addressingModes(f *Func)
            
            
            
               
                  advanceUses 
                  method
                  
                  #
               
               
               advanceUses advances the uses of v's args from the state before v to the state after v.
Any values which have no more uses are deallocated from registers.
               
               func (s *regAllocState) advanceUses(v *Value)
            
            
            
               
                  aliasnewnode 
                  method
                  
                  #
               
               
               aliasnewnode records that a single node n2 (not in the poset yet) is an alias
of the master node n1.
               
               func (po *poset) aliasnewnode(n1 *Value, n2 *Value)
            
            
            
               
                  aliasnodes 
                  method
                  
                  #
               
               
               aliasnodes records that all the nodes i2s are aliases of a single master node n1.
aliasnodes takes care of rearranging the DAG, changing references of parent/children
of nodes in i2s, so that they point to n1 instead.
Complexity is O(n) (with n being the total number of nodes in the poset, not just
the number of nodes being aliased).
               
               func (po *poset) aliasnodes(n1 *Value, i2s bitset)
            
            
            
               
                  allocBlock 
                  method
                  
                  #
               
               
               func (state *debugState) allocBlock(b *Block) *BlockDebug
            
            
            
               
                  allocBlockSlice 
                  method
                  
                  #
               
               
               func (c *Cache) allocBlockSlice(n int) []*Block
            
            
            
               
                  allocBoolSlice 
                  method
                  
                  #
               
               
               func (c *Cache) allocBoolSlice(n int) []bool
            
            
            
               
                  allocIDSlice 
                  method
                  
                  #
               
               
               func (c *Cache) allocIDSlice(n int) []ID
            
            
            
               
                  allocInt32Slice 
                  method
                  
                  #
               
               
               func (c *Cache) allocInt32Slice(n int) []int32
            
            
            
               
                  allocInt64 
                  method
                  
                  #
               
               
               func (c *Cache) allocInt64(n int) []int64
            
            
            
               
                  allocInt8Slice 
                  method
                  
                  #
               
               
               func (c *Cache) allocInt8Slice(n int) []int8
            
            
            
               
                  allocIntSlice 
                  method
                  
                  #
               
               
               func (c *Cache) allocIntSlice(n int) []int
            
            
            
               
                  allocLimitSlice 
                  method
                  
                  #
               
               
               func (c *Cache) allocLimitSlice(n int) []limit
            
            
            
               
                  allocReg 
                  method
                  
                  #
               
               
               allocReg chooses a register from the set of registers in mask.
If there is no unused register, a Value will be kicked out of
a register to make room.
               
               func (s *regAllocState) allocReg(mask regMask, v *Value) register
            
            
            
               
                  allocSparseMap 
                  method
                  
                  #
               
               
               func (c *Cache) allocSparseMap(n int) *sparseMap
            
            
            
               
                  allocSparseMapPos 
                  method
                  
                  #
               
               
               func (c *Cache) allocSparseMapPos(n int) *sparseMapPos
            
            
            
               
                  allocSparseSet 
                  method
                  
                  #
               
               
               func (c *Cache) allocSparseSet(n int) *sparseSet
            
            
            
               
                  allocValToReg 
                  method
                  
                  #
               
               
               allocValToReg allocates v to a register selected from regMask and
returns the register copy of v. Any previous user is kicked out and spilled
(if necessary). Load code is added at the current pc. If nospill is set the
allocated register is marked nospill so the assignment cannot be
undone until the caller allows it by clearing nospill. Returns a
*Value which is either v or a copy of v allocated to the chosen register.
               
               func (s *regAllocState) allocValToReg(v *Value, mask regMask, nospill bool, pos src.XPos) *Value
            
            
            
               
                  allocValueSlice 
                  method
                  
                  #
               
               
               func (c *Cache) allocValueSlice(n int) []*Value
            
            
            
               
                  appendPtr 
                  function
                  
                  #
               
               
               Append a pointer-sized uint to buf.
               
               func appendPtr(ctxt *obj.Link, buf []byte, word uint64) []byte
            
            
            
               
                  applyRewrite 
                  function
                  
                  #
               
               
               deadcode indicates whether rewrite should try to remove any values that become dead.
               
               func applyRewrite(f *Func, rb blockRewriter, rv valueRewriter, deadcode deadValueChoice)
            
            
            
               
                  archRegForAbiReg 
                  function
                  
                  #
               
               
               For ABI register index r, returns the (dense) register number used in
SSA backend.
               
               func archRegForAbiReg(r abi.RegIndex, c *Config) uint8
            
            
            
               
                  areMergeableInequalities 
                  function
                  
                  #
               
               
               func areMergeableInequalities(x *Value, y *Value) bool
            
            
            
               
                  arm64BFWidth 
                  function
                  
                  #
               
               
               returns the bitfield width of mask >> rshift for arm64 bitfield ops.
               
               func arm64BFWidth(mask int64, rshift int64) int64
            
            
            
               
                  arm64BitFieldToAuxInt 
                  function
                  
                  #
               
               
               func arm64BitFieldToAuxInt(v arm64BitField) int64
            
            
            
               
                  arm64Invert 
                  function
                  
                  #
               
               
               arm64Invert evaluates (InvertFlags op), which
is the same as altering the condition codes such
that the same result would be produced if the arguments
to the flag-generating instruction were reversed, e.g.
(InvertFlags (CMP x y)) -> (CMP y x)
               
               func arm64Invert(op Op) Op
            
            
            
               
                  arm64Negate 
                  function
                  
                  #
               
               
               arm64Negate finds the complement to an ARM64 condition code,
for example !Equal -> NotEqual or !LessThan -> GreaterEqual
For floating point, it's more subtle because NaN is unordered. We do
!LessThanF -> NotLessThanF, the latter takes care of NaNs.
               
               func arm64Negate(op Op) Op
            
            
            
               
                  armBFAuxInt 
                  function
                  
                  #
               
               
               encodes the lsb and width for arm(64) bitfield ops into the expected auxInt format.
               
               func armBFAuxInt(lsb int64, width int64) arm64BitField
            
            
            
               
                  assembleChildren 
                  method
                  
                  #
               
               
               assembleChildren initializes the children field of each
loop in the nest.  Loop A is a child of loop B if A is
directly nested within B (based on the reducible-loops
detection above)
               
               func (ln *loopnest) assembleChildren()
            
            
            
               
                  assignReg 
                  method
                  
                  #
               
               
               assignReg assigns register r to hold c, a copy of v.
r must be unused.
               
               func (s *regAllocState) assignReg(r register, v *Value, c *Value)
            
            
            
               
                  at 
                  method
                  
                  #
               
               
               at returns the register cursor for component i of t, where the first
component is numbered 0.
               
               func (c *registerCursor) at(t *types.Type, i int) registerCursor
            
            
            
               
                  auxFrom32F 
                  function
                  
                  #
               
               
               auxFrom32F encodes a float32 value so it can be stored in an AuxInt.
               
               func auxFrom32F(f float32) int64
            
            
            
               
                  auxFrom64F 
                  function
                  
                  #
               
               
               auxFrom64F encodes a float64 value so it can be stored in an AuxInt.
               
               func auxFrom64F(f float64) int64
            
            
            
               
                  auxIntToArm64BitField 
                  function
                  
                  #
               
               
               func auxIntToArm64BitField(i int64) arm64BitField
            
            
            
               
                  auxIntToBool 
                  function
                  
                  #
               
               
               func auxIntToBool(i int64) bool
            
            
            
               
                  auxIntToFlagConstant 
                  function
                  
                  #
               
               
               func auxIntToFlagConstant(x int64) flagConstant
            
            
            
               
                  auxIntToFloat32 
                  function
                  
                  #
               
               
               func auxIntToFloat32(i int64) float32
            
            
            
               
                  auxIntToFloat64 
                  function
                  
                  #
               
               
               func auxIntToFloat64(i int64) float64
            
            
            
               
                  auxIntToInt128 
                  function
                  
                  #
               
               
               func auxIntToInt128(x int64) int128
            
            
            
               
                  auxIntToInt16 
                  function
                  
                  #
               
               
               func auxIntToInt16(i int64) int16
            
            
            
               
                  auxIntToInt32 
                  function
                  
                  #
               
               
               func auxIntToInt32(i int64) int32
            
            
            
               
                  auxIntToInt64 
                  function
                  
                  #
               
               
               func auxIntToInt64(i int64) int64
            
            
            
               
                  auxIntToInt8 
                  function
                  
                  #
               
               
               func auxIntToInt8(i int64) int8
            
            
            
               
                  auxIntToOp 
                  function
                  
                  #
               
               
               func auxIntToOp(cc int64) Op
            
            
            
               
                  auxIntToUint8 
                  function
                  
                  #
               
               
               func auxIntToUint8(i int64) uint8
            
            
            
               
                  auxIntToValAndOff 
                  function
                  
                  #
               
               
               func auxIntToValAndOff(i int64) ValAndOff
            
            
            
               
                  auxString 
                  method
                  
                  #
               
               
               func (v *Value) auxString() string
            
            
            
               
                  auxTo32F 
                  function
                  
                  #
               
               
               auxTo32F decodes a float32 from the AuxInt value provided.
               
               func auxTo32F(i int64) float32
            
            
            
               
                  auxTo64F 
                  function
                  
                  #
               
               
               auxTo64F decodes a float64 from the AuxInt value provided.
               
               func auxTo64F(i int64) float64
            
            
            
               
                  auxToCall 
                  function
                  
                  #
               
               
               func auxToCall(i Aux) *AuxCall
            
            
            
               
                  auxToS390xCCMask 
                  function
                  
                  #
               
               
               func auxToS390xCCMask(i Aux) s390x.CCMask
            
            
            
               
                  auxToS390xRotateParams 
                  function
                  
                  #
               
               
               func auxToS390xRotateParams(i Aux) s390x.RotateParams
            
            
            
               
                  auxToString 
                  function
                  
                  #
               
               
               func auxToString(i Aux) string
            
            
            
               
                  auxToSym 
                  function
                  
                  #
               
               
               func auxToSym(i Aux) Sym
            
            
            
               
                  auxToType 
                  function
                  
                  #
               
               
               func auxToType(i Aux) *types.Type
            
            
            
               
                  b2i 
                  function
                  
                  #
               
               
               b2i translates a boolean value to 0 or 1 for assigning to auxInt.
               
               func b2i(b bool) int64
            
            
            
               
                  b2i32 
                  function
                  
                  #
               
               
               b2i32 translates a boolean value to 0 or 1.
               
               func b2i32(b bool) int32
            
            
            
               
                  backedges 
                  function
                  
                  #
               
               
               backedges returns a slice of successor edges that are back
edges.  For reducible loops, edge.b is the header.
               
               func backedges(f *Func) []Edge
            
            
            
               
                  blockEndStateString 
                  method
                  
                  #
               
               
               func (s *debugState) blockEndStateString(b *BlockDebug) string
            
            
            
               
                  boolToAuxInt 
                  function
                  
                  #
               
               
               func boolToAuxInt(b bool) int64
            
            
            
               
                  booleanFalse 
                  method
                  
                  #
               
               
               func (ft *factsTable) booleanFalse(v *Value) bool
            
            
            
               
                  booleanTrue 
                  method
                  
                  #
               
               
               func (ft *factsTable) booleanTrue(v *Value) bool
            
            
            
               
                  boundsABI 
                  function
                  
                  #
               
               
               boundsABI determines which register arguments a bounds check call should use. For an [a:b:c] slice, we do:
CMPQ c, cap
JA   fail1
CMPQ b, c
JA   fail2
CMPQ a, b
JA   fail3
fail1: CALL panicSlice3Acap (c, cap)
fail2: CALL panicSlice3B (b, c)
fail3: CALL panicSlice3C (a, b)
When we register allocate that code, we want the same register to be used for
the first arg of panicSlice3Acap and the second arg to panicSlice3B. That way,
initializing that register once will satisfy both calls.
That desire ends up dividing the set of bounds check calls into 3 sets. This function
determines which set to use for a given panic call.
The first arg for set 0 should be the second arg for set 1.
The first arg for set 1 should be the second arg for set 2.
               
               func boundsABI(b int64) int
            
            
            
               
                  branchelim 
                  function
                  
                  #
               
               
               branchelim tries to eliminate branches by
generating CondSelect instructions.
Search for basic blocks that look like
bb0            bb0
| \          /   \
| bb1  or  bb1   bb2    <- trivial if/else blocks
| /          \   /
bb2            bb3
where the intermediate blocks are mostly empty (with no side-effects);
rewrite Phis in the postdominator as CondSelects.
               
               func branchelim(f *Func)
            
            
            
               
                  buildDefUses 
                  method
                  
                  #
               
               
               buildDefUses builds def-use chain for some values early, because once the
lattice of a value is changed, we need to update lattices of use. But we don't
need all uses of it, only uses that can become constants would be added into
re-visit worklist since no matter how many times they are revisited, uses which
can't become constants lattice remains unchanged, i.e. Bottom.
               
               func (t *worklist) buildDefUses()
            
            
            
               
                  buildInterferenceGraph 
                  method
                  
                  #
               
               
               func (s *stackAllocState) buildInterferenceGraph()
            
            
            
               
                  buildLocationLists 
                  method
                  
                  #
               
               
               buildLocationLists builds location lists for all the user variables
in state.f, using the information about block state in blockLocs.
The returned location lists are not fully complete. They are in
terms of SSA values rather than PCs, and have no base address/end
entries. They will be finished by PutLocationList.
               
               func (state *debugState) buildLocationLists(blockLocs []*BlockDebug)
            
            
            
               
                  byteSwap 
                  function
                  
                  #
               
               
               func byteSwap(b *Block, pos src.XPos, v *Value) *Value
            
            
            
               
                  calculateDepths 
                  method
                  
                  #
               
               
               calculateDepths uses the children field of loops
to determine the nesting depth (outer=1) of each
loop.  This is helpful for finding exit edges.
               
               func (ln *loopnest) calculateDepths()
            
            
            
               
                  callToAux 
                  function
                  
                  #
               
               
               func callToAux(s *AuxCall) Aux
            
            
            
               
                  canAdd32 
                  method
                  
                  #
               
               
               func (x ValAndOff) canAdd32(off int32) bool
            
            
            
               
                  canAdd64 
                  method
                  
                  #
               
               
               func (x ValAndOff) canAdd64(off int64) bool
            
            
            
               
                  canCondSelect 
                  function
                  
                  #
               
               
               func canCondSelect(v *Value, arch string, loadAddr *sparseSet) bool
            
            
            
               
                  canLoadUnaligned 
                  function
                  
                  #
               
               
               canLoadUnaligned reports if the architecture supports unaligned load operations.
               
               func canLoadUnaligned(c *Config) bool
            
            
            
               
                  canMerge 
                  function
                  
                  #
               
               
               canMerge reports whether a new location description is a superset
of the (non-empty) pending location description, if so, the two
can be merged (i.e., pending is still a valid and useful location
description).
               
               func canMerge(pending VarLoc, new VarLoc) bool
            
            
            
               
                  canMergeLoad 
                  function
                  
                  #
               
               
               canMergeLoad reports whether the load can be merged into target without
invalidating the schedule.
               
               func canMergeLoad(target *Value, load *Value) bool
            
            
            
               
                  canMergeLoadClobber 
                  function
                  
                  #
               
               
               canMergeLoadClobber reports whether the load can be merged into target without
invalidating the schedule.
It also checks that the other non-load argument x is something we
are ok with clobbering.
               
               func canMergeLoadClobber(target *Value, load *Value, x *Value) bool
            
            
            
               
                  canMergeSym 
                  function
                  
                  #
               
               
               func canMergeSym(x Sym, y Sym) bool
            
            
            
               
                  canRotate 
                  function
                  
                  #
               
               
               canRotate reports whether the architecture supports
rotates of integer registers with the given number of bits.
               
               func canRotate(c *Config, bits int64) bool
            
            
            
               
                  canSpeculativelyExecute 
                  function
                  
                  #
               
               
               canSpeculativelyExecute reports whether every value in the block can
be evaluated without causing any observable side effects (memory
accesses, panics and so on) except for execution time changes. It
also ensures that the block does not contain any phis which we can't
speculatively execute.
Warning: this function cannot currently detect values that represent
instructions the execution of which need to be guarded with CPU
hardware feature checks. See issue #34950.
               
               func canSpeculativelyExecute(b *Block) bool
            
            
            
               
                  canonLessThan 
                  function
                  
                  #
               
               
               canonLessThan returns whether x is "ordered" less than y, for purposes of normalizing
generated code as much as possible.
               
               func canonLessThan(x *Value, y *Value) bool
            
            
            
               
                  canonSlot 
                  method
                  
                  #
               
               
               func (sc *slotCanonicalizer) canonSlot(idx SlKeyIdx) LocalSlot
            
            
            
               
                  cap 
                  method
                  
                  #
               
               
               cap returns one more than the largest key valid for s
               
               func (s *biasedSparseMap) cap() int
            
            
            
               
                  cap 
                  method
                  
                  #
               
               
               func (s *sparseSet) cap() int
            
            
            
               
                  cap 
                  method
                  
                  #
               
               
               func (s *sparseMap) cap() int
            
            
            
               
                  cap 
                  method
                  
                  #
               
               
               func (s *sparseMapPos) cap() int
            
            
            
               
                  ccARM64Eval 
                  function
                  
                  #
               
               
               evaluate an ARM64 op against a flags value
that is potentially constant; return 1 for true,
-1 for false, and 0 for not constant.
               
               func ccARM64Eval(op Op, flags *Value) int
            
            
            
               
                  changeroot 
                  method
                  
                  #
               
               
               func (po *poset) changeroot(oldr uint32, newr uint32)
            
            
            
               
                  checkContainsCall 
                  function
                  
                  #
               
               
               func checkContainsCall(bb *Block) bool
            
            
            
               
                  checkFunc 
                  function
                  
                  #
               
               
               checkFunc checks invariants of f.
               
               func checkFunc(f *Func)
            
            
            
               
                  checkLower 
                  function
                  
                  #
               
               
               checkLower checks for unlowered opcodes and fails if we find one.
               
               func checkLower(f *Func)
            
            
            
               
                  checkbce 
                  function
                  
                  #
               
               
               checkbce prints all bounds checks that are present in the function.
Useful to find regressions. checkbce is only activated when with
corresponding debug options, so it's off by default.
See test/checkbce.go
               
               func checkbce(f *Func)
            
            
            
               
                  checkpoint 
                  method
                  
                  #
               
               
               checkpoint saves the current state of known relations.
Called when descending on a branch.
               
               func (ft *factsTable) checkpoint()
            
            
            
               
                  children 
                  method
                  
                  #
               
               
               func (po *poset) children(i uint32) (posetEdge, posetEdge)
            
            
            
               
                  chl 
                  method
                  
                  #
               
               
               func (po *poset) chl(i uint32) uint32
            
            
            
               
                  chr 
                  method
                  
                  #
               
               
               func (po *poset) chr(i uint32) uint32
            
            
            
               
                  cleanup 
                  method
                  
                  #
               
               
               cleanup returns the posets to the free list
               
               func (ft *factsTable) cleanup(f *Func)
            
            
            
               
                  clear 
                  method
                  
                  #
               
               
               func (d *desiredState) clear()
            
            
            
               
                  clear 
                  method
                  
                  #
               
               
               func (s *sparseMapPos) clear()
            
            
            
               
                  clear 
                  method
                  
                  #
               
               
               func (s *biasedSparseMap) clear()
            
            
            
               
                  clear 
                  method
                  
                  #
               
               
               clear removes data from the map but leaves the sparse skeleton.
               
               func (m *xposmap) clear()
            
            
            
               
                  clear 
                  method
                  
                  #
               
               
               func (s *sparseMap) clear()
            
            
            
               
                  clear 
                  method
                  
                  #
               
               
               func (e *pendingEntry) clear()
            
            
            
               
                  clear 
                  method
                  
                  #
               
               
               func (s *sparseSet) clear()
            
            
            
               
                  clobber 
                  function
                  
                  #
               
               
               clobber invalidates values. Returns true.
clobber is used by rewrite rules to:
A) make sure the values are really dead and never used again.
B) decrement use counts of the values' args.
               
               func clobber(vv ...*Value) bool
            
            
            
               
                  clobber 
                  method
                  
                  #
               
               
               clobber erases any desired registers in the set m.
               
               func (d *desiredState) clobber(m regMask)
            
            
            
               
                  clobberBlock 
                  function
                  
                  #
               
               
               func clobberBlock(b *Block)
            
            
            
               
                  clobberIfDead 
                  function
                  
                  #
               
               
               clobberIfDead resets v when use count is 1. Returns true.
clobberIfDead is used by rewrite rules to decrement
use counts of v's args when v is dead and never used.
               
               func clobberIfDead(v *Value) bool
            
            
            
               
                  clobberRegs 
                  method
                  
                  #
               
               
               clobberRegs inserts instructions that clobber registers listed in m.
               
               func (s *regAllocState) clobberRegs(m regMask)
            
            
            
               
                  clobbersFlags 
                  method
                  
                  #
               
               
               func (v *Value) clobbersFlags() bool
            
            
            
               
                  close 
                  method
                  
                  #
               
               
               func (s *regAllocState) close()
            
            
            
               
                  cmpVal 
                  function
                  
                  #
               
               
               func cmpVal(v *Value, w *Value, auxIDs auxmap) types.Cmp
            
            
            
               
                  collapsepath 
                  method
                  
                  #
               
               
               collapsepath marks n1 and n2 as equal and collapses as equal all
nodes across all paths between n1 and n2. If a strict edge is
found, the function does not modify the DAG and returns false.
Complexity is O(n).
               
               func (po *poset) collapsepath(n1 *Value, n2 *Value) bool
            
            
            
               
                  com 
                  method
                  
                  #
               
               
               Similar to add, but computes the complement of the limit for bitsize b.
               
               func (l limit) com(b uint) limit
            
            
            
               
                  combineLoads 
                  function
                  
                  #
               
               
               func combineLoads(root *Value, n int64) bool
            
            
            
               
                  combineStores 
                  function
                  
                  #
               
               
               Try to combine the n stores ending in root.
Returns true if successful.
               
               func combineStores(root *Value, n int64) bool
            
            
            
               
                  compatRegs 
                  method
                  
                  #
               
               
               compatRegs returns the set of registers which can store a type t.
               
               func (s *regAllocState) compatRegs(t *types.Type) regMask
            
            
            
               
                  compressOrig 
                  function
                  
                  #
               
               
               compressOrig is the "simple" compress function from LT paper.
               
               func compressOrig(v ID, ancestor []ID, semi []ID, label []ID)
            
            
            
               
                  computeLattice 
                  function
                  
                  #
               
               
               func computeLattice(f *Func, val *Value, args ...*Value) lattice
            
            
            
               
                  computeLive 
                  method
                  
                  #
               
               
               computeLive computes a map from block ID to a list of value IDs live at the end
of that block. Together with the value ID is a count of how many instructions
to the next use of that value. The resulting map is stored in s.live.
computeLive also computes the desired register information at the end of each block.
This desired register information is stored in s.desired.
TODO: this could be quadratic if lots of variables are live across lots of
basic blocks. Figure out a way to make this function (or, more precisely, the user
of this function) require only linear size & time.
               
               func (s *regAllocState) computeLive()
            
            
            
               
                  computeLive 
                  method
                  
                  #
               
               
               computeLive computes a map from block ID to a list of
stack-slot-needing value IDs live at the end of that block.
TODO: this could be quadratic if lots of variables are live across lots of
basic blocks. Figure out a way to make this function (or, more precisely, the user
of this function) require only linear size & time.
               
               func (s *stackAllocState) computeLive(spillLive [][]ID)
            
            
            
               
                  computeZeroMap 
                  method
                  
                  #
               
               
               computeZeroMap returns a map from an ID of a memory value to
a set of locations that are known to be zeroed at that memory value.
               
               func (f *Func) computeZeroMap(select1 []*Value) map[ID]ZeroRegion
            
            
            
               
                  constVal 
                  method
                  
                  #
               
               
               constVal returns a constant value for c.
               
               func (f *Func) constVal(op Op, t *types.Type, c int64, setAuxInt bool) *Value
            
            
            
               
                  contains 
                  method
                  
                  #
               
               
               contains reports whether x is a key in s
               
               func (s *biasedSparseMap) contains(x uint) bool
            
            
            
               
                  contains 
                  method
                  
                  #
               
               
               contains reports whether [lo:hi] is completely within sr.
               
               func (sr shadowRange) contains(lo int64, hi int64) bool
            
            
            
               
                  contains 
                  method
                  
                  #
               
               
               func (s *sparseMapPos) contains(k ID) bool
            
            
            
               
                  contains 
                  method
                  
                  #
               
               
               contains returns whether the file index and line of p are in m,
treating m as a set instead of as a map.
               
               func (m *xposmap) contains(p src.XPos) bool
            
            
            
               
                  contains 
                  method
                  
                  #
               
               
               func (s *sparseMap) contains(k ID) bool
            
            
            
               
                  contains 
                  method
                  
                  #
               
               
               func (s *sparseSet) contains(x ID) bool
            
            
            
               
                  contents 
                  method
                  
                  #
               
               
               func (s *sparseMap) contents() []sparseEntry
            
            
            
               
                  contents 
                  method
                  
                  #
               
               
               func (s *sparseMapPos) contents() []sparseEntryPos
            
            
            
               
                  contents 
                  method
                  
                  #
               
               
               func (s *sparseSet) contents() []ID
            
            
            
               
                  convertPPC64OpToOpCC 
                  function
                  
                  #
               
               
               Convert a PPC64 opcode from the Op to OpCC form. This converts (op x y)
to (Select0 (opCC x y)) without having to explicitly fixup every user
of op.
E.g consider the case:
a = (ADD x y)
b = (CMPconst [0] a)
c = (OR a z)
A rule like (CMPconst [0] (ADD x y)) => (CMPconst [0] (Select0 (ADDCC x y)))
would produce:
a  = (ADD x y)
a' = (ADDCC x y)
a” = (Select0 a')
b  = (CMPconst [0] a”)
c  = (OR a z)
which makes it impossible to rewrite the second user. Instead the result
of this conversion is:
a' = (ADDCC x y)
a  = (Select0 a')
b  = (CMPconst [0] a)
c  = (OR a z)
Which makes it trivial to rewrite b using a lowering rule.
               
               func convertPPC64OpToOpCC(op *Value) *Value
            
            
            
               
                  convertPPC64RldiclAndccconst 
                  function
                  
                  #
               
               
               Try converting a RLDICL to ANDCC. If successful, return the mask otherwise 0.
               
               func convertPPC64RldiclAndccconst(sauxint int64) int64
            
            
            
               
                  convertPhi 
                  function
                  
                  #
               
               
               b is the If block giving the boolean value.
v is the phi value v = (OpPhi (ConstBool [true]) (ConstBool [false])).
reverse is the predecessor from which the truth value comes.
               
               func convertPhi(b *Block, v *Value, reverse int)
            
            
            
               
                  copy 
                  method
                  
                  #
               
               
               copy copies a desired state from another desiredState x.
               
               func (d *desiredState) copy(x *desiredState)
            
            
            
               
                  copyFlags 
                  function
                  
                  #
               
               
               copyFlags copies v (flag generator) into b, returns the copy.
If v's arg is also flags, copy recursively.
               
               func copyFlags(v *Value, b *Block) *Value
            
            
            
               
                  copyInto 
                  method
                  
                  #
               
               
               copyInto makes a new value identical to v and adds it to the end of b.
unlike copyIntoWithXPos this does not check for v.Pos being a statement.
               
               func (v *Value) copyInto(b *Block) *Value
            
            
            
               
                  copyIntoWithXPos 
                  method
                  
                  #
               
               
               copyIntoWithXPos makes a new value identical to v and adds it to the end of b.
The supplied position is used as the position of the new value.
Because this is used for rematerialization, check for case that (rematerialized)
input to value with position 'pos' carried a statement mark, and that the supplied
position (of the instruction using the rematerialized value) is not marked, and
preserve that mark if its line matches the supplied position.
               
               func (v *Value) copyIntoWithXPos(b *Block, pos src.XPos) *Value
            
            
            
               
                  copyOf 
                  method
                  
                  #
               
               
               copyOf is called from rewrite rules.
It modifies v to be (Copy a).
go:noinline
               
               func (v *Value) copyOf(a *Value)
            
            
            
               
                  copySource 
                  function
                  
                  #
               
               
               copySource returns the (non-copy) op which is the
ultimate source of v.  v must be a copy op.
               
               func copySource(v *Value) *Value
            
            
            
               
                  copyUntil 
                  method
                  
                  #
               
               
               func (d *dotWriter) copyUntil(w io.Writer, buf *bytes.Buffer, sep string) error
            
            
            
               
                  copyelim 
                  function
                  
                  #
               
               
               combine copyelim and phielim into a single pass.
copyelim removes all uses of OpCopy values from f.
A subsequent deadcode pass is needed to actually remove the copies.
               
               func copyelim(f *Func)
            
            
            
               
                  copyelimValue 
                  function
                  
                  #
               
               
               copyelimValue ensures that no args of v are copies.
               
               func copyelimValue(v *Value)
            
            
            
               
                  countRegs 
                  function
                  
                  #
               
               
               countRegs returns the number of set bits in the register mask.
               
               func countRegs(r regMask) int
            
            
            
               
                  countRule 
                  function
                  
                  #
               
               
               countRule increments Func.ruleMatches[key].
If Func.ruleMatches is non-nil at the end
of compilation, it will be printed to stdout.
This is intended to make it easier to find which functions
which contain lots of rules matches when developing new rules.
               
               func countRule(v *Value, key string) bool
            
            
            
               
                  critical 
                  function
                  
                  #
               
               
               critical splits critical edges (those that go from a block with
more than one outedge to a block with more than one inedge).
Regalloc wants a critical-edge-free CFG so it can implement phi values.
               
               func critical(f *Func)
            
            
            
               
                  cse 
                  function
                  
                  #
               
               
               cse does common-subexpression elimination on the Function.
Values are just relinked, nothing is deleted. A subsequent deadcode
pass is required to actually remove duplicate expressions.
               
               func cse(f *Func)
            
            
            
               
                  deadcode 
                  function
                  
                  #
               
               
               deadcode removes dead code from f.
               
               func deadcode(f *Func)
            
            
            
               
                  decodeValue 
                  function
                  
                  #
               
               
               Unpack a value and block ID encoded by encodeValue.
               
               func decodeValue(ctxt *obj.Link, word uint64) (ID, ID)
            
            
            
               
                  decomposeArrayPhi 
                  function
                  
                  #
               
               
               decomposeArrayPhi replaces phi-of-array with arraymake(phi-of-array-element),
and then recursively decomposes the element phi.
               
               func decomposeArrayPhi(v *Value)
            
            
            
               
                  decomposeAsNecessary 
                  method
                  
                  #
               
               
               decomposeAsNecessary converts a value (perhaps an aggregate) passed to a call or returned by a function,
into the appropriate sequence of stores and register assignments to transmit that value in a given ABI, and
returns the current memory after this convert/rewrite (it may be the input memory, perhaps stores were needed.)
'pos' is the source position all this is tied to
'b' is the enclosing block
'a' is the value to decompose
'm0' is the input memory arg used for the first store (or returned if there are no stores)
'rc' is a registerCursor which identifies the register/memory destination for the value
               
               func (x *expandState) decomposeAsNecessary(pos src.XPos, b *Block, a *Value, m0 *Value, rc registerCursor) *Value
            
            
            
               
                  decomposeBuiltIn 
                  function
                  
                  #
               
               
               decompose converts phi ops on compound builtin types into phi
ops on simple types, then invokes rewrite rules to decompose
other ops on those types.
               
               func decomposeBuiltIn(f *Func)
            
            
            
               
                  decomposeBuiltInPhi 
                  function
                  
                  #
               
               
               func decomposeBuiltInPhi(v *Value)
            
            
            
               
                  decomposeComplexPhi 
                  function
                  
                  #
               
               
               func decomposeComplexPhi(v *Value)
            
            
            
               
                  decomposeInt64Phi 
                  function
                  
                  #
               
               
               func decomposeInt64Phi(v *Value)
            
            
            
               
                  decomposeInterfacePhi 
                  function
                  
                  #
               
               
               func decomposeInterfacePhi(v *Value)
            
            
            
               
                  decomposeOne 
                  method
                  
                  #
               
               
               func (x *expandState) decomposeOne(pos src.XPos, b *Block, a *Value, mem *Value, t0 *types.Type, o0 Op, rc *registerCursor) *Value
            
            
            
               
                  decomposePair 
                  method
                  
                  #
               
               
               func (x *expandState) decomposePair(pos src.XPos, b *Block, a *Value, mem *Value, t0 *types.Type, t1 *types.Type, o0 Op, o1 Op, rc *registerCursor) *Value
            
            
            
               
                  decomposeSlicePhi 
                  function
                  
                  #
               
               
               func decomposeSlicePhi(v *Value)
            
            
            
               
                  decomposeStringPhi 
                  function
                  
                  #
               
               
               func decomposeStringPhi(v *Value)
            
            
            
               
                  decomposeStructPhi 
                  function
                  
                  #
               
               
               decomposeStructPhi replaces phi-of-struct with structmake(phi-for-each-field),
and then recursively decomposes the phis for each field.
               
               func decomposeStructPhi(v *Value)
            
            
            
               
                  decomposeUser 
                  function
                  
                  #
               
               
               func decomposeUser(f *Func)
            
            
            
               
                  decomposeUserArrayInto 
                  function
                  
                  #
               
               
               decomposeUserArrayInto creates names for the element(s) of arrays referenced
by name where possible, and appends those new names to slots, which is then
returned.
               
               func decomposeUserArrayInto(f *Func, name *LocalSlot, slots []*LocalSlot) []*LocalSlot
            
            
            
               
                  decomposeUserPhi 
                  function
                  
                  #
               
               
               func decomposeUserPhi(v *Value)
            
            
            
               
                  decomposeUserStructInto 
                  function
                  
                  #
               
               
               decomposeUserStructInto creates names for the fields(s) of structs referenced
by name where possible, and appends those new names to slots, which is then
returned.
               
               func decomposeUserStructInto(f *Func, name *LocalSlot, slots []*LocalSlot) []*LocalSlot
            
            
            
               
                  deleteNamedVals 
                  function
                  
                  #
               
               
               deleteNamedVals removes particular values with debugger names from f's naming data structures,
removes all values with OpInvalid, and re-sorts the list of Names.
               
               func deleteNamedVals(f *Func, toDelete []namedVal)
            
            
            
               
                  depth 
                  method
                  
                  #
               
               
               depth returns the loop nesting level of block b.
               
               func (ln *loopnest) depth(b ID) int16
            
            
            
               
                  describeBranchPrediction 
                  function
                  
                  #
               
               
               func describeBranchPrediction(f *Func, b *Block, likely int8, not int8, prediction BranchPrediction)
            
            
            
               
                  describePredictionAgrees 
                  function
                  
                  #
               
               
               func describePredictionAgrees(b *Block, prediction BranchPrediction) string
            
            
            
               
                  devirtLECall 
                  function
                  
                  #
               
               
               func devirtLECall(v *Value, sym *obj.LSym) *Value
            
            
            
               
                  dfs 
                  method
                  
                  #
               
               
               dfs performs a depth-first search within the DAG whose root is r.
f is the visit function called for each node; if it returns true,
the search is aborted and true is returned. The root node is
visited too.
If strict, ignore edges across a path until at least one
strict edge is found. For instance, for a chain A<=B<=C
               
               func (po *poset) dfs(r uint32, strict bool, f func(i uint32) bool) bool
            
            
            
               
                  dfsOrig 
                  method
                  
                  #
               
               
               dfsOrig performs a depth first search over the blocks starting at entry block
(in arbitrary order).  This is a de-recursed version of dfs from the
original Tarjan-Lengauer TOPLAS article.  It's important to return the
same values for parent as the original algorithm.
               
               func (f *Func) dfsOrig(entry *Block, succFn linkedBlocks, semi []ID, vertex []ID, label []ID, parent []ID) ID
            
            
            
               
                  diff 
                  function
                  
                  #
               
               
               diff returns x-y as a uint64. Requires x>=y.
               
               func diff(x int64, y int64) uint64
            
            
            
               
                  disjoint 
                  function
                  
                  #
               
               
               disjoint reports whether the memory region specified by [p1:p1+n1)
does not overlap with [p2:p2+n2).
A return value of false does not imply the regions overlap.
               
               func disjoint(p1 *Value, n1 int64, p2 *Value, n2 int64) bool
            
            
            
               
                  domCheck 
                  function
                  
                  #
               
               
               domCheck reports whether x dominates y (including x==y).
               
               func domCheck(f *Func, sdom SparseTree, x *Block, y *Block) bool
            
            
            
               
                  dominators 
                  function
                  
                  #
               
               
               func dominators(f *Func) []*Block
            
            
            
               
                  dominatorsLTOrig 
                  method
                  
                  #
               
               
               dominatorsLTOrig runs Lengauer-Tarjan to compute a dominator tree starting at
entry and using predFn/succFn to find predecessors/successors to allow
computing both dominator and post-dominator trees.
               
               func (f *Func) dominatorsLTOrig(entry *Block, predFn linkedBlocks, succFn linkedBlocks) []*Block
            
            
            
            
            
               
                  domorder 
                  method
                  
                  #
               
               
               domorder returns a value for dominator-oriented sorting.
Block domination does not provide a total ordering,
but domorder two has useful properties.
1. If domorder(x) > domorder(y) then x does not dominate y.
2. If domorder(x) < domorder(y) and domorder(y) < domorder(z) and x does not dominate y,
then x does not dominate z.
Property (1) means that blocks sorted by domorder always have a maximal dominant block first.
Property (2) allows searches for dominated blocks to exit early.
               
               func (t SparseTree) domorder(x *Block) int32
            
            
            
               
                  dropIfUnused 
                  method
                  
                  #
               
               
               Drop v from registers if it isn't used again, or its only uses are after
a call instruction.
               
               func (s *regAllocState) dropIfUnused(v *Value)
            
            
            
               
                  dse 
                  function
                  
                  #
               
               
               dse does dead-store elimination on the Function.
Dead stores are those which are unconditionally followed by
another store to the same location, with no intervening load.
This implementation only works within a basic block. TODO: use something more global.
               
               func dse(f *Func)
            
            
            
               
                  dumpFile 
                  method
                  
                  #
               
               
               dumpFile creates a file from the phase name and function name
Dumping is done to files to avoid buffering huge strings before
output.
               
               func (f *Func) dumpFile(phaseName string)
            
            
            
               
                  elimDeadAutosGeneric 
                  function
                  
                  #
               
               
               elimDeadAutosGeneric deletes autos that are never accessed. To achieve this
we track the operations that the address of each auto reaches and if it only
reaches stores then we delete all the stores. The other operations will then
be eliminated by the dead code elimination pass.
               
               func elimDeadAutosGeneric(f *Func)
            
            
            
               
                  elimIf 
                  function
                  
                  #
               
               
               elimIf converts the one-way branch starting at dom in f to a conditional move if possible.
loadAddr is a set of values which are used to compute the address of a load.
Those values are exempt from CMOV generation.
               
               func elimIf(f *Func, loadAddr *sparseSet, dom *Block) bool
            
            
            
               
                  elimIfElse 
                  function
                  
                  #
               
               
               elimIfElse converts the two-way branch starting at dom in f to a conditional move if possible.
loadAddr is a set of values which are used to compute the address of a load.
Those values are exempt from CMOV generation.
               
               func elimIfElse(f *Func, loadAddr *sparseSet, b *Block) bool
            
            
            
               
                  elimUnreadAutos 
                  function
                  
                  #
               
               
               elimUnreadAutos deletes stores (and associated bookkeeping ops VarDef and VarKill)
to autos that are never read from.
               
               func elimUnreadAutos(f *Func)
            
            
            
               
                  emptyBlock 
                  function
                  
                  #
               
               
               emptyBlock reports whether the block does not contain actual
instructions.
               
               func emptyBlock(b *Block) bool
            
            
            
               
                  encode 
                  method
                  
                  #
               
               
               func (fcs flagConstantBuilder) encode() flagConstant
            
            
            
               
                  encodePPC64RotateMask 
                  function
                  
                  #
               
               
               Compress mask and shift into single value of the form
me | mb<<8 | rotate<<16 | nbits<<24 where me and mb can
be used to regenerate the input mask.
               
               func encodePPC64RotateMask(rotate int64, mask int64, nbits int64) int64
            
            
            
               
                  encodeValue 
                  function
                  
                  #
               
               
               Pack a value and block ID into an address-sized uint, returning
encoded value and boolean indicating whether the encoding succeeded.
For 32-bit architectures the process may fail for very large
procedures(the theory being that it's ok to have degraded debug
quality in this case).
               
               func encodeValue(ctxt *obj.Link, b ID, v ID) (uint64, bool)
            
            
            
               
                  endBlock 
                  method
                  
                  #
               
               
               func (p htmlFuncPrinter) endBlock(b *Block, reachable bool)
            
            
            
               
                  endBlock 
                  method
                  
                  #
               
               
               func (p stringFuncPrinter) endBlock(b *Block, reachable bool)
            
            
            
               
                  endDepCycle 
                  method
                  
                  #
               
               
               func (p htmlFuncPrinter) endDepCycle()
            
            
            
               
                  endDepCycle 
                  method
                  
                  #
               
               
               func (p stringFuncPrinter) endDepCycle()
            
            
            
               
                  eq 
                  method
                  
                  #
               
               
               func (fc flagConstant) eq() bool
            
            
            
               
                  equals 
                  function
                  
                  #
               
               
               func equals(a lattice, b lattice) bool
            
            
            
               
                  erase 
                  method
                  
                  #
               
               
               erase removes any user of loc.
               
               func (e *edgeState) erase(loc Location)
            
            
            
               
                  evalOrig 
                  function
                  
                  #
               
               
               evalOrig is the "simple" eval function from LT paper.
               
               func evalOrig(v ID, ancestor []ID, semi []ID, label []ID) ID
            
            
            
               
                  exp2 
                  method
                  
                  #
               
               
               Similar to add, but compute 1 << l if it fits without overflow in b bits.
               
               func (l limit) exp2(b uint) limit
            
            
            
               
                  expandCalls 
                  function
                  
                  #
               
               
               func expandCalls(f *Func)
            
            
            
               
                  extend32Fto64F 
                  function
                  
                  #
               
               
               extend32Fto64F converts a float32 value to a float64 value preserving the bit
pattern of the mantissa.
               
               func extend32Fto64F(f float32) float64
            
            
            
               
                  find 
                  method
                  
                  #
               
               
               find returns the lowest common ancestor of a and b.
               
               func (lca *lcaRange) find(a *Block, b *Block) *Block
            
            
            
               
                  findExits 
                  method
                  
                  #
               
               
               findExits uses loop depth information to find the
exits from a loop.
               
               func (ln *loopnest) findExits()
            
            
            
               
                  findIndVar 
                  function
                  
                  #
               
               
               findIndVar finds induction variables in a function.
Look for variables and blocks that satisfy the following
loop:
ind = (Phi min nxt),
if ind < max
then goto enter_loop
else goto exit_loop
enter_loop:
do something
nxt = inc + ind
goto loop
exit_loop:
               
               func findIndVar(f *Func) []indVar
            
            
            
               
                  findKNN 
                  function
                  
                  #
               
               
               if v is known to be x - c, where x is known to be nonnegative and c is a
constant, return x, c. Otherwise return nil, 0.
               
               func findKNN(v *Value) (*Value, int64)
            
            
            
               
                  findLastMems 
                  function
                  
                  #
               
               
               findLastMems maps block ids to last memory-output op in a block, if any.
               
               func findLastMems(f *Func) []*Value
            
            
            
               
                  findRegFor 
                  method
                  
                  #
               
               
               findRegFor finds a register we can use to make a temp copy of type typ.
               
               func (e *edgeState) findRegFor(typ *types.Type) Location
            
            
            
               
                  findlive 
                  function
                  
                  #
               
               
               findlive returns the reachable blocks and live values in f.
The caller should call f.Cache.freeBoolSlice(live) when it is done with it.
               
               func findlive(f *Func) (reachable []bool, live []bool)
            
            
            
               
                  findpaths 
                  method
                  
                  #
               
               
               findpaths is a recursive function that calculates all paths from cur to dst
and return them as a bitset (the index of a node is set in the bitset if
that node is on at least one path from cur to dst).
We do a DFS from cur (stopping going deep any time we reach dst, if ever),
and mark as part of the paths any node that has a children which is already
part of the path (or is dst itself).
               
               func (po *poset) findpaths(cur uint32, dst uint32) bitset
            
            
            
               
                  findpaths1 
                  method
                  
                  #
               
               
               func (po *poset) findpaths1(cur uint32, dst uint32, seen bitset, path bitset)
            
            
            
               
                  findroot 
                  method
                  
                  #
               
               
               findroot finds i's root, that is which DAG contains i.
Returns the root; if i is itself a root, it is returned.
Panic if i is not in any DAG.
               
               func (po *poset) findroot(i uint32) uint32
            
            
            
               
                  firstReg 
                  function
                  
                  #
               
               
               firstReg returns the first register in set that is present.
               
               func firstReg(set RegisterSet) uint8
            
            
            
               
                  fitsInBits 
                  function
                  
                  #
               
               
               fitsInBits reports whether x fits in b bits (signed).
               
               func fitsInBits(x int64, b uint) bool
            
            
            
               
                  fitsInBitsU 
                  function
                  
                  #
               
               
               fitsInBitsU reports whether x fits in b bits (unsigned).
               
               func fitsInBitsU(x uint64, b uint) bool
            
            
            
               
                  fixed32 
                  function
                  
                  #
               
               
               func fixed32(c *Config, sym Sym, off int64) int32
            
            
            
               
                  fixedSym 
                  function
                  
                  #
               
               
               func fixedSym(f *Func, sym Sym, off int64) Sym
            
            
            
               
                  flagArg 
                  function
                  
                  #
               
               
               for a pseudo-op like (LessThan x), extract x.
               
               func flagArg(v *Value) *Value
            
            
            
               
                  flagConstantToAuxInt 
                  function
                  
                  #
               
               
               func flagConstantToAuxInt(x flagConstant) int64
            
            
            
               
                  flagalloc 
                  function
                  
                  #
               
               
               flagalloc allocates the flag register among all the flag-generating
instructions. Flag values are recomputed if they need to be
spilled/restored.
               
               func flagalloc(f *Func)
            
            
            
               
                  flc 
                  function
                  
                  #
               
               
               func flc(p src.XPos) string
            
            
            
               
                  float32ToAuxInt 
                  function
                  
                  #
               
               
               func float32ToAuxInt(f float32) int64
            
            
            
               
                  float64ToAuxInt 
                  function
                  
                  #
               
               
               func float64ToAuxInt(f float64) int64
            
            
            
               
                  flowLimit 
                  method
                  
                  #
               
               
               flowLimit updates the known limits of v in ft. Returns true if anything changed.
flowLimit can use the ranges of input arguments.
Note: this calculation only happens at the point the value is defined. We do not reevaluate
it later. So for example:
v := x + y
if 0 <= x && x < 5 && 0 <= y && y < 5 { ... use v ... }
we don't discover that the range of v is bounded in the conditioned
block. We could recompute the range of v once we enter the block so
we know that it is 0 <= v <= 8, but we don't have a mechanism to do
that right now.
               
               func (ft *factsTable) flowLimit(v *Value) bool
            
            
            
               
                  flushPhases 
                  method
                  
                  #
               
               
               flushPhases collects any pending phases and titles, writes them to the html, and resets the pending slices.
               
               func (w *HTMLWriter) flushPhases()
            
            
            
               
                  foreachEntry 
                  method
                  
                  #
               
               
               foreachEntry applies f to each (fileindex, line, value) triple in m.
               
               func (m *xposmap) foreachEntry(f func(j int32, l uint, v int32))
            
            
            
               
                  fprintFunc 
                  function
                  
                  #
               
               
               func fprintFunc(p funcPrinter, f *Func)
            
            
            
               
                  freeBlock 
                  method
                  
                  #
               
               
               func (f *Func) freeBlock(b *Block)
            
            
            
               
                  freeBlockSlice 
                  method
                  
                  #
               
               
               func (c *Cache) freeBlockSlice(s []*Block)
            
            
            
               
                  freeBoolSlice 
                  method
                  
                  #
               
               
               func (c *Cache) freeBoolSlice(s []bool)
            
            
            
               
                  freeIDSlice 
                  method
                  
                  #
               
               
               func (c *Cache) freeIDSlice(s []ID)
            
            
            
               
                  freeInt32Slice 
                  method
                  
                  #
               
               
               func (c *Cache) freeInt32Slice(s []int32)
            
            
            
               
                  freeInt64 
                  method
                  
                  #
               
               
               func (c *Cache) freeInt64(s []int64)
            
            
            
               
                  freeInt8Slice 
                  method
                  
                  #
               
               
               func (c *Cache) freeInt8Slice(s []int8)
            
            
            
               
                  freeIntSlice 
                  method
                  
                  #
               
               
               func (c *Cache) freeIntSlice(s []int)
            
            
            
               
                  freeLimitSlice 
                  method
                  
                  #
               
               
               func (c *Cache) freeLimitSlice(s []limit)
            
            
            
               
                  freeReg 
                  method
                  
                  #
               
               
               freeReg frees up register r. Any current user of r is kicked out.
               
               func (s *regAllocState) freeReg(r register)
            
            
            
               
                  freeRegs 
                  method
                  
                  #
               
               
               freeRegs frees up all registers listed in m.
               
               func (s *regAllocState) freeRegs(m regMask)
            
            
            
               
                  freeSparseMap 
                  method
                  
                  #
               
               
               func (c *Cache) freeSparseMap(s *sparseMap)
            
            
            
               
                  freeSparseMapPos 
                  method
                  
                  #
               
               
               func (c *Cache) freeSparseMapPos(s *sparseMapPos)
            
            
            
               
                  freeSparseSet 
                  method
                  
                  #
               
               
               func (c *Cache) freeSparseSet(s *sparseSet)
            
            
            
               
                  freeValue 
                  method
                  
                  #
               
               
               freeValue frees a value. It must no longer be referenced or have any args.
               
               func (f *Func) freeValue(v *Value)
            
            
            
               
                  freeValueSlice 
                  method
                  
                  #
               
               
               func (c *Cache) freeValueSlice(s []*Value)
            
            
            
               
                  fuse 
                  function
                  
                  #
               
               
               fuse simplifies control flow by joining basic blocks.
               
               func fuse(f *Func, typ fuseType)
            
            
            
               
                  fuseBlockIf 
                  function
                  
                  #
               
               
               fuseBlockIf handles the following cases where s0 and s1 are empty blocks.
b        b           b       b
\ / \ /    | \  /    \ / |     | |
s0  s1    |  s1      s0 |     | |
\ /      | /         \ |     | |
ss      ss           ss      ss
If all Phi ops in ss have identical variables for slots corresponding to
s0, s1 and b then the branch can be dropped.
This optimization often comes up in switch statements with multiple
expressions in a case clause:
switch n {
case 1,2,3: return 4
}
TODO: If ss doesn't contain any OpPhis, are s0 and s1 dead code anyway.
               
               func fuseBlockIf(b *Block) bool
            
            
            
               
                  fuseBlockPlain 
                  function
                  
                  #
               
               
               fuseBlockPlain handles a run of blocks with length >= 2,
whose interior has single predecessors and successors,
b must be BlockPlain, allowing it to be any node except the
last (multiple successors means not BlockPlain).
Cycles are handled and merged into b's successor.
               
               func fuseBlockPlain(b *Block) bool
            
            
            
               
                  fuseBranchRedirect 
                  function
                  
                  #
               
               
               fuseBranchRedirect checks for a CFG in which the outbound branch
of an If block can be derived from its predecessor If block, in
some such cases, we can redirect the predecessor If block to the
corresponding successor block directly. For example:
p:
v11 = Less64  v10 v8
If v11 goto b else u
b: <- p ...
v17 = Leq64  v10 v8
If v17 goto s else o
We can redirect p to s directly.
The implementation here borrows the framework of the prove pass.
1, Traverse all blocks of function f to find If blocks.
2,   For any If block b, traverse all its predecessors to find If blocks.
3,     For any If block predecessor p, update relationship p->b.
4,     Traverse all successors of b.
5,       For any successor s of b, try to update relationship b->s, if a
contradiction is found then redirect p to another successor of b.
               
               func fuseBranchRedirect(f *Func) bool
            
            
            
               
                  fuseEarly 
                  function
                  
                  #
               
               
               fuseEarly runs fuse(f, fuseTypePlain|fuseTypeIntInRange).
               
               func fuseEarly(f *Func)
            
            
            
               
                  fuseIntegerComparisons 
                  function
                  
                  #
               
               
               fuseIntegerComparisons optimizes inequalities such as '1 <= x && x < 5',
which can be optimized to 'unsigned(x-1) < 4'.
Look for branch structure like:
p
|\
| b
|/ \
s0 s1
In our example, p has control '1 <= x', b has control 'x < 5',
and s0 and s1 are the if and else results of the comparison.
This will be optimized into:
p
\
b
/ \
s0 s1
where b has the combined control value 'unsigned(x-1) < 4'.
Later passes will then fuse p and b.
               
               func fuseIntegerComparisons(b *Block) bool
            
            
            
               
                  fuseLate 
                  function
                  
                  #
               
               
               fuseLate runs fuse(f, fuseTypePlain|fuseTypeIf|fuseTypeBranchRedirect).
               
               func fuseLate(f *Func)
            
            
            
               
                  ge 
                  method
                  
                  #
               
               
               func (fc flagConstant) ge() bool
            
            
            
               
                  geNoov 
                  method
                  
                  #
               
               
               func (fc flagConstant) geNoov() bool
            
            
            
               
                  get 
                  method
                  
                  #
               
               
               get returns the value s maps for key x, or -1 if
x is not mapped or is out of range for s.
               
               func (s *biasedSparseMap) get(x uint) int32
            
            
            
               
                  get 
                  method
                  
                  #
               
               
               get allocates an ID and returns it. IDs are always > 0.
               
               func (a *idAlloc) get() ID
            
            
            
               
                  get 
                  method
                  
                  #
               
               
               get returns the int32 associated with the file index and line of p.
               
               func (m *xposmap) get(p src.XPos) int32
            
            
            
               
                  get 
                  method
                  
                  #
               
               
               get returns a list of desired registers for value vid.
               
               func (d *desiredState) get(vid ID) [4]register
            
            
            
               
                  get 
                  method
                  
                  #
               
               
               get returns the value for key k, or -1 if k does
not appear in the map.
               
               func (s *sparseMapPos) get(k ID) int32
            
            
            
               
                  get 
                  method
                  
                  #
               
               
               get returns the value for key k, or -1 if k does
not appear in the map.
               
               func (s *sparseMap) get(k ID) int32
            
            
            
               
                  getBranch 
                  function
                  
                  #
               
               
               getBranch returns the range restrictions added by p
when reaching b. p is the immediate dominator of b.
               
               func getBranch(sdom SparseTree, p *Block, b *Block) branch
            
            
            
               
                  getConstIntArgIndex 
                  function
                  
                  #
               
               
               getConstIntArgIndex returns the index of the first argument that is a
constant integer or -1 if no such argument exists.
               
               func getConstIntArgIndex(v *Value) int
            
            
            
               
                  getEntry 
                  method
                  
                  #
               
               
               getEntry returns the i'th key and value stored in s,
where 0 <= i < s.size()
               
               func (s *biasedSparseMap) getEntry(i int) (x uint, v int32)
            
            
            
               
                  getHome 
                  method
                  
                  #
               
               
               func (f *Func) getHome(vid ID) Location
            
            
            
               
                  getLatticeCell 
                  method
                  
                  #
               
               
               func (t *worklist) getLatticeCell(val *Value) lattice
            
            
            
               
                  getPPC64ShiftMaskLength 
                  function
                  
                  #
               
               
               func getPPC64ShiftMaskLength(v int64) int64
            
            
            
               
                  gt 
                  method
                  
                  #
               
               
               func (fc flagConstant) gt() bool
            
            
            
               
                  gtNoov 
                  method
                  
                  #
               
               
               func (fc flagConstant) gtNoov() bool
            
            
            
               
                  hasAnyArgOp 
                  function
                  
                  #
               
               
               func hasAnyArgOp(v *Value) bool
            
            
            
               
                  hasFlagInput 
                  method
                  
                  #
               
               
               hasFlagInput reports whether v has a flag value as any of its inputs.
               
               func (v *Value) hasFlagInput() bool
            
            
            
               
                  hasRegs 
                  method
                  
                  #
               
               
               func (c *registerCursor) hasRegs() bool
            
            
            
               
                  hasSmallRotate 
                  function
                  
                  #
               
               
               hasSmallRotate reports whether the architecture has rotate instructions
for sizes < 32-bit.  This is used to decide whether to promote some rotations.
               
               func hasSmallRotate(c *Config) bool
            
            
            
               
                  hashFunc 
                  function
                  
                  #
               
               
               func hashFunc(f *Func) []byte
            
            
            
               
                  haveByteSwap 
                  method
                  
                  #
               
               
               func (c *Config) haveByteSwap(size int64) bool
            
            
            
            
            
            
            
               
                  hi 
                  method
                  
                  #
               
               
               func (sr shadowRange) hi() int64
            
            
            
               
                  indent 
                  method
                  
                  #
               
               
               indent increments (or decrements) the indentation.
               
               func (x *expandState) indent(n int)
            
            
            
               
                  init 
                  method
                  
                  #
               
               
               func (s *stackAllocState) init(f *Func, spillLive [][]ID)
            
            
            
               
                  init 
                  method
                  
                  #
               
               
               func (c *registerCursor) init(regs []abi.RegIndex, info *abi.ABIParamResultInfo, result *[]*Value, storeDest *Value, storeOffset int64)
            
            
            
               
                  init 
                  function
                  
                  #
               
               
               func init()
            
            
            
               
                  init 
                  method
                  
                  #
               
               
               func (s *regAllocState) init(f *Func)
            
            
            
               
                  init 
                  function
                  
                  #
               
               
               func init()
            
            
            
               
                  initLimit 
                  function
                  
                  #
               
               
               initLimit sets initial constant limit for v.  This limit is based
only on the operation itself, not any of its input arguments. This
method is only used in two places, once when the prove pass startup
and the other when a new ssa value is created, both for init. (unlike
flowLimit, below, which computes additional constraints based on
ranges of opcode arguments).
               
               func initLimit(v *Value) limit
            
            
            
               
                  initLimitForNewValue 
                  method
                  
                  #
               
               
               initLimitForNewValue initializes the limits for newly created values,
possibly needing to expand the limits slice. Currently used by
simplifyBlock when certain provably constant results are folded.
               
               func (ft *factsTable) initLimitForNewValue(v *Value)
            
            
            
               
                  initializeCache 
                  method
                  
                  #
               
               
               func (state *debugState) initializeCache(f *Func, numVars int, numSlots int)
            
            
            
               
                  insertLoopReschedChecks 
                  function
                  
                  #
               
               
               insertLoopReschedChecks inserts rescheduling checks on loop backedges.
               
               func insertLoopReschedChecks(f *Func)
            
            
            
               
                  int128ToAuxInt 
                  function
                  
                  #
               
               
               func int128ToAuxInt(x int128) int64
            
            
            
               
                  int16ToAuxInt 
                  function
                  
                  #
               
               
               func int16ToAuxInt(i int16) int64
            
            
            
               
                  int32ToAuxInt 
                  function
                  
                  #
               
               
               func int32ToAuxInt(i int32) int64
            
            
            
               
                  int64ToAuxInt 
                  function
                  
                  #
               
               
               func int64ToAuxInt(i int64) int64
            
            
            
               
                  int8ToAuxInt 
                  function
                  
                  #
               
               
               func int8ToAuxInt(i int8) int64
            
            
            
               
                  intPairTypes 
                  method
                  
                  #
               
               
               intPairTypes returns the pair of 32-bit int types needed to encode a 64-bit integer type on a target
that has no 64-bit integer registers.
               
               func (x *expandState) intPairTypes(et types.Kind) (tHi *types.Type, tLo *types.Type)
            
            
            
               
                  intersect 
                  function
                  
                  #
               
               
               intersect finds the closest dominator of both b and c.
It requires a postorder numbering of all the blocks.
               
               func intersect(b *Block, c *Block, postnum []int, idom []*Block) *Block
            
            
            
               
                  intersect 
                  method
                  
                  #
               
               
               func (l limit) intersect(l2 limit) limit
            
            
            
               
                  intersect 
                  method
                  
                  #
               
               
               func (loc VarLoc) intersect(other VarLoc) VarLoc
            
            
            
               
                  invalidateCFG 
                  method
                  
                  #
               
               
               invalidateCFG tells f that its CFG has changed.
               
               func (f *Func) invalidateCFG()
            
            
            
               
                  invalidateRecursively 
                  method
                  
                  #
               
               
               invalidateRecursively marks a value as invalid (unused)
and after decrementing reference counts on its Args,
also recursively invalidates any of those whose use
count goes to zero.  It returns whether any of the
invalidated values was marked with IsStmt.
BEWARE of doing this *before* you've applied intended
updates to SSA.
               
               func (v *Value) invalidateRecursively() bool
            
            
            
               
                  invalidateRecursively 
                  method
                  
                  #
               
               
               func (x *expandState) invalidateRecursively(a *Value)
            
            
            
               
                  is16Bit 
                  function
                  
                  #
               
               
               is16Bit reports whether n can be represented as a signed 16 bit integer.
               
               func is16Bit(n int64) bool
            
            
            
               
                  is16BitInt 
                  function
                  
                  #
               
               
               func is16BitInt(t *types.Type) bool
            
            
            
               
                  is20Bit 
                  function
                  
                  #
               
               
               is20Bit reports whether n can be represented as a signed 20 bit integer.
               
               func is20Bit(n int64) bool
            
            
            
               
                  is32Bit 
                  function
                  
                  #
               
               
               is32Bit reports whether n can be represented as a signed 32 bit integer.
               
               func is32Bit(n int64) bool
            
            
            
               
                  is32BitFloat 
                  function
                  
                  #
               
               
               func is32BitFloat(t *types.Type) bool
            
            
            
               
                  is32BitInt 
                  function
                  
                  #
               
               
               func is32BitInt(t *types.Type) bool
            
            
            
               
                  is64BitFloat 
                  function
                  
                  #
               
               
               func is64BitFloat(t *types.Type) bool
            
            
            
               
                  is64BitInt 
                  function
                  
                  #
               
               
               func is64BitInt(t *types.Type) bool
            
            
            
               
                  is8Bit 
                  function
                  
                  #
               
               
               is8Bit reports whether n can be represented as a signed 8 bit integer.
               
               func is8Bit(n int64) bool
            
            
            
               
                  is8BitInt 
                  function
                  
                  #
               
               
               func is8BitInt(t *types.Type) bool
            
            
            
               
                  isARM64BFMask 
                  function
                  
                  #
               
               
               checks if mask >> rshift applied at lsb is a valid arm64 bitfield op mask.
               
               func isARM64BFMask(lsb int64, mask int64, rshift int64) bool
            
            
            
               
                  isARM64addcon 
                  function
                  
                  #
               
               
               isARM64addcon reports whether x can be encoded as the immediate value in an ADD or SUB instruction.
               
               func isARM64addcon(v int64) bool
            
            
            
               
                  isARM64bitcon 
                  function
                  
                  #
               
               
               isARM64bitcon reports whether a constant can be encoded into a logical instruction.
               
               func isARM64bitcon(x uint64) bool
            
            
            
               
                  isARMImmRot 
                  function
                  
                  #
               
               
               check if an immediate can be directly encoded into an ARM's instruction.
               
               func isARMImmRot(v uint32) bool
            
            
            
               
                  isAncestor 
                  method
                  
                  #
               
               
               isAncestor reports whether x is a strict ancestor of y.
               
               func (t SparseTree) isAncestor(x *Block, y *Block) bool
            
            
            
               
                  isBlockMultiValueExit 
                  function
                  
                  #
               
               
               func isBlockMultiValueExit(b *Block) bool
            
            
            
               
                  isCleanExt 
                  function
                  
                  #
               
               
               isCleanExt reports whether v is the result of a value-preserving
sign or zero extension.
               
               func isCleanExt(v *Value) bool
            
            
            
               
                  isConst 
                  function
                  
                  #
               
               
               func isConst(val *Value) bool
            
            
            
               
                  isConstDelta 
                  function
                  
                  #
               
               
               isConstDelta returns non-nil if v is equivalent to w+delta (signed).
               
               func isConstDelta(v *Value) (w *Value, delta int64)
            
            
            
               
                  isConstZero 
                  function
                  
                  #
               
               
               func isConstZero(v *Value) bool
            
            
            
               
                  isDivMod 
                  function
                  
                  #
               
               
               func isDivMod(op Op) bool
            
            
            
               
                  isEmpty 
                  function
                  
                  #
               
               
               isEmpty reports whether b contains any live values.
There may be false positives.
               
               func isEmpty(b *Block) bool
            
            
            
               
                  isExactFloat32 
                  function
                  
                  #
               
               
               isExactFloat32 reports whether x can be exactly represented as a float32.
               
               func isExactFloat32(x float64) bool
            
            
            
               
                  isFixed 
                  function
                  
                  #
               
               
               isFixed returns true if the range [off,off+size] of the symbol sym
is known and constant.
               
               func isFixed(c *Config, sym Sym, off int64, size int64) bool
            
            
            
               
                  isFixed32 
                  function
                  
                  #
               
               
               isFixed32 returns true if the int32 at offset off in symbol sym
is known and constant.
               
               func isFixed32(c *Config, sym Sym, off int64) bool
            
            
            
               
                  isFixedSym 
                  function
                  
                  #
               
               
               isFixedSym returns true if the contents of sym at the given offset
is known and is the constant address of another symbol.
               
               func isFixedSym(sym Sym, off int64) bool
            
            
            
               
                  isFlagOp 
                  method
                  
                  #
               
               
               isFlagOp reports if v is an OP with the flag type.
               
               func (v *Value) isFlagOp() bool
            
            
            
               
                  isGReg 
                  method
                  
                  #
               
               
               func (s *regAllocState) isGReg(r register) bool
            
            
            
               
                  isGenericIntConst 
                  method
                  
                  #
               
               
               isGenericIntConst reports whether v is a generic integer constant.
               
               func (v *Value) isGenericIntConst() bool
            
            
            
               
                  isInlinableMemclr 
                  function
                  
                  #
               
               
               func isInlinableMemclr(c *Config, sz int64) bool
            
            
            
               
                  isInlinableMemmove 
                  function
                  
                  #
               
               
               isInlinableMemmove reports whether the given arch performs a Move of the given size
faster than memmove. It will only return true if replacing the memmove with a Move is
safe, either because Move will do all of its loads before any of its stores, or
because the arguments are known to be disjoint.
This is used as a check for replacing memmove with Move ops.
               
               func isInlinableMemmove(dst *Value, src *Value, sz int64, c *Config) bool
            
            
            
               
                  isLeaf 
                  function
                  
                  #
               
               
               isLeaf reports whether f performs any calls.
               
               func isLeaf(f *Func) bool
            
            
            
               
                  isLeafPlain 
                  function
                  
                  #
               
               
               is this a BlockPlain with one predecessor?
               
               func isLeafPlain(b *Block) bool
            
            
            
               
                  isLoweredGetClosurePtr 
                  method
                  
                  #
               
               
               func (op Op) isLoweredGetClosurePtr() bool
            
            
            
               
                  isNamedRegParam 
                  function
                  
                  #
               
               
               isNamedRegParam returns true if the param corresponding to "p"
is a named, non-blank input parameter assigned to one or more
registers.
               
               func isNamedRegParam(p abi.ABIParamAssignment) bool
            
            
            
               
                  isNonNegative 
                  method
                  
                  #
               
               
               isNonNegative reports whether v is known to be non-negative.
               
               func (ft *factsTable) isNonNegative(v *Value) bool
            
            
            
               
                  isNonNegative 
                  function
                  
                  #
               
               
               isNonNegative reports whether v is known to be greater or equal to zero.
Note that this is pretty simplistic. The prove pass generates more detailed
nonnegative information about values.
               
               func isNonNegative(v *Value) bool
            
            
            
               
                  isPPC64ValidShiftMask 
                  function
                  
                  #
               
               
               This verifies that the mask is a set of
consecutive bits including the least
significant bit.
               
               func isPPC64ValidShiftMask(v int64) bool
            
            
            
               
                  isPPC64WordRotateMask 
                  function
                  
                  #
               
               
               Test if this value can encoded as a mask for a rlwinm like
operation.  Masks can also extend from the msb and wrap to
the lsb too.  That is, the valid masks are 32 bit strings
of the form: 0..01..10..0 or 1..10..01..1 or 1...1
Note: This ignores the upper 32 bits of the input. When a
zero extended result is desired (e.g a 64 bit result), the
user must verify the upper 32 bits are 0 and the mask is
contiguous (that is, non-wrapping).
               
               func isPPC64WordRotateMask(v64 int64) bool
            
            
            
               
                  isPPC64WordRotateMaskNonWrapping 
                  function
                  
                  #
               
               
               Test if this mask is a valid, contiguous bitmask which can be
represented by a RLWNM mask and also clears the upper 32 bits
of the register.
               
               func isPPC64WordRotateMaskNonWrapping(v64 int64) bool
            
            
            
               
                  isPoorStatementOp 
                  function
                  
                  #
               
               
               func isPoorStatementOp(op Op) bool
            
            
            
               
                  isPowerOfTwo 
                  function
                  
                  #
               
               
               isPowerOfTwoX functions report whether n is a power of 2.
               
               func isPowerOfTwo(n T) bool
            
            
            
               
                  isPtr 
                  function
                  
                  #
               
               
               func isPtr(t *types.Type) bool
            
            
            
               
                  isPtrArithmetic 
                  function
                  
                  #
               
               
               func isPtrArithmetic(op Op) bool
            
            
            
               
                  isSameCall 
                  function
                  
                  #
               
               
               isSameCall reports whether sym is the same as the given named symbol.
               
               func isSameCall(sym interface{}, name string) bool
            
            
            
               
                  isSamePtr 
                  function
                  
                  #
               
               
               isSamePtr reports whether p1 and p2 point to the same address.
               
               func isSamePtr(p1 *Value, p2 *Value) bool
            
            
            
               
                  isSignedInequality 
                  function
                  
                  #
               
               
               isSignedInequality reports whether op represents the inequality < or ≤
in the signed domain.
               
               func isSignedInequality(v *Value) bool
            
            
            
               
                  isStackPtr 
                  function
                  
                  #
               
               
               func isStackPtr(v *Value) bool
            
            
            
               
                  isU12Bit 
                  function
                  
                  #
               
               
               isU12Bit reports whether n can be represented as an unsigned 12 bit integer.
               
               func isU12Bit(n int64) bool
            
            
            
               
                  isU16Bit 
                  function
                  
                  #
               
               
               isU16Bit reports whether n can be represented as an unsigned 16 bit integer.
               
               func isU16Bit(n int64) bool
            
            
            
               
                  isU32Bit 
                  function
                  
                  #
               
               
               isU32Bit reports whether n can be represented as an unsigned 32 bit integer.
               
               func isU32Bit(n int64) bool
            
            
            
               
                  isU8Bit 
                  function
                  
                  #
               
               
               isU8Bit reports whether n can be represented as an unsigned 8 bit integer.
               
               func isU8Bit(n int64) bool
            
            
            
               
                  isUint32PowerOfTwo 
                  function
                  
                  #
               
               
               isUint32PowerOfTwo reports whether uint32(n) is a power of 2.
               
               func isUint32PowerOfTwo(in int64) bool
            
            
            
               
                  isUint64PowerOfTwo 
                  function
                  
                  #
               
               
               isUint64PowerOfTwo reports whether uint64(n) is a power of 2.
               
               func isUint64PowerOfTwo(in int64) bool
            
            
            
               
                  isUnsignedInequality 
                  function
                  
                  #
               
               
               isUnsignedInequality reports whether op represents the inequality < or ≤
in the unsigned domain.
               
               func isUnsignedInequality(v *Value) bool
            
            
            
               
                  isVolatile 
                  function
                  
                  #
               
               
               isVolatile reports whether v is a pointer to argument region on stack which
will be clobbered by a function call.
               
               func isVolatile(v *Value) bool
            
            
            
               
                  isWithinOrEq 
                  method
                  
                  #
               
               
               func (l *loop) isWithinOrEq(ll *loop) bool
            
            
            
               
                  isnoneq 
                  method
                  
                  #
               
               
               Check whether it is recorded that i1!=i2
               
               func (po *poset) isnoneq(i1 uint32, i2 uint32) bool
            
            
            
               
                  isroot 
                  method
                  
                  #
               
               
               func (po *poset) isroot(r uint32) bool
            
            
            
               
                  iterationEnd 
                  method
                  
                  #
               
               
               iterationEnd checks if block b ends iteration of loop l.
Ending iteration means either escaping to outer loop/code or
going back to header
               
               func (l *loop) iterationEnd(b *Block, b2l []*loop) bool
            
            
            
               
                  keyFor 
                  function
                  
                  #
               
               
               keyFor returns the AuxInt portion of a  key structure uniquely identifying a
zero arg value for the supported ops.
               
               func keyFor(v *Value) int64
            
            
            
               
                  lateLower 
                  function
                  
                  #
               
               
               lateLower applies those rules that need to be run after the general lower rules.
               
               func lateLower(f *Func)
            
            
            
               
                  layout 
                  function
                  
                  #
               
               
               layout orders basic blocks in f with the goal of minimizing control flow instructions.
After this phase returns, the order of f.Blocks matters and is the order
in which those blocks will appear in the assembly output.
               
               func layout(f *Func)
            
            
            
               
                  layoutOrder 
                  function
                  
                  #
               
               
               func layoutOrder(f *Func) []*Block
            
            
            
               
                  layoutRegallocOrder 
                  function
                  
                  #
               
               
               Register allocation may use a different order which has constraints
imposed by the linear-scan algorithm.
               
               func layoutRegallocOrder(f *Func) []*Block
            
            
            
               
                  le 
                  method
                  
                  #
               
               
               func (fc flagConstant) le() bool
            
            
            
               
                  leNoov 
                  method
                  
                  #
               
               
               func (fc flagConstant) leNoov() bool
            
            
            
               
                  leftShift 
                  function
                  
                  #
               
               
               func leftShift(b *Block, pos src.XPos, v *Value, shift int64) *Value
            
            
            
               
                  likelyBranch 
                  method
                  
                  #
               
               
               likelyBranch reports whether block b is the likely branch of all of its predecessors.
               
               func (b *Block) likelyBranch() bool
            
            
            
               
                  likelyadjust 
                  function
                  
                  #
               
               
               func likelyadjust(f *Func)
            
            
            
               
                  linkOrig 
                  function
                  
                  #
               
               
               func linkOrig(v ID, w ID, ancestor []ID)
            
            
            
               
                  liveAfterCurrentInstruction 
                  method
                  
                  #
               
               
               liveAfterCurrentInstruction reports whether v is live after
the current instruction is completed.  v must be used by the
current instruction.
               
               func (s *regAllocState) liveAfterCurrentInstruction(v *Value) bool
            
            
            
               
                  liveValues 
                  function
                  
                  #
               
               
               liveValues returns the live values in f and a list of values that are eligible
to be statements in reversed data flow order.
The second result is used to help conserve statement boundaries for debugging.
reachable is a map from block ID to whether the block is reachable.
The caller should call f.Cache.freeBoolSlice(live) and f.Cache.freeValueSlice(liveOrderStmts).
when they are done with the return values.
               
               func liveValues(f *Func, reachable []bool) (live []bool, liveOrderStmts []*Value)
            
            
            
               
                  liveness 
                  method
                  
                  #
               
               
               liveness walks the function in control flow order, calculating the start
and end state of each block.
               
               func (state *debugState) liveness() []*BlockDebug
            
            
            
               
                  lo 
                  method
                  
                  #
               
               
               func (sr shadowRange) lo() int64
            
            
            
               
                  loadLSymOffset 
                  function
                  
                  #
               
               
               loadLSymOffset simulates reading a word at an offset into a
read-only symbol's runtime memory. If it would read a pointer to
another symbol, that symbol is returned. Otherwise, it returns nil.
               
               func loadLSymOffset(lsym *obj.LSym, offset int64) *obj.LSym
            
            
            
               
                  localSlotAddr 
                  method
                  
                  #
               
               
               func (f *Func) localSlotAddr(slot LocalSlot) *LocalSlot
            
            
            
               
                  locatePrologEnd 
                  function
                  
                  #
               
               
               locatePrologEnd walks the entry block of a function with incoming
register arguments and locates the last instruction in the prolog
that spills a register arg. It returns the ID of that instruction,
and (where appropriate) the prolog's lowered closure ptr store inst.
Example:
b1:
v3 = ArgIntReg  {p1+0} [0] : AX
... more arg regs ..
v4 = ArgFloatReg  {f1+0} [0] : X0
v52 = MOVQstore  {p1} v2 v3 v1
... more stores ...
v68 = MOVSSstore  {f4} v2 v67 v66
v38 = MOVQstoreconst  {blob} [val=0,off=0] v2 v32
Important: locatePrologEnd is expected to work properly only with
optimization turned off (e.g. "-N"). If optimization is enabled
we can't be assured of finding all input arguments spilled in the
entry block prolog.
               
               func locatePrologEnd(f *Func, needCloCtx bool) (ID, *Value)
            
            
            
               
                  log16 
                  function
                  
                  #
               
               
               func log16(n int16) int64
            
            
            
               
                  log2uint32 
                  function
                  
                  #
               
               
               log2uint32 returns logarithm in base 2 of uint32(n), with log2(0) = -1.
Rounds down.
               
               func log2uint32(n int64) int64
            
            
            
               
                  log32 
                  function
                  
                  #
               
               
               func log32(n int32) int64
            
            
            
               
                  log64 
                  function
                  
                  #
               
               
               func log64(n int64) int64
            
            
            
               
                  log8 
                  function
                  
                  #
               
               
               logX returns logarithm of n base 2.
n must be a positive power of 2 (isPowerOfTwoX returns true).
               
               func log8(n int8) int64
            
            
            
               
                  logLargeCopy 
                  function
                  
                  #
               
               
               logLargeCopy logs the occurrence of a large copy.
The best place to do this is in the rewrite rules where the size of the move is easy to find.
"Large" is arbitrarily chosen to be 128 bytes; this may change.
               
               func logLargeCopy(v *Value, s int64) bool
            
            
            
               
                  logRule 
                  function
                  
                  #
               
               
               logRule logs the use of the rule s. This will only be enabled if
rewrite rules were generated with the -log option, see _gen/rulegen.go.
               
               func logRule(s string)
            
            
            
               
                  logf 
                  method
                  
                  #
               
               
               logf prints debug-specific logging to stdout (always stdout) if the
current function is tagged by GOSSAFUNC (for ssa output directed
either to stdout or html).
               
               func (s *debugState) logf(msg string, args ...interface{})
            
            
            
               
                  logicFlags32 
                  function
                  
                  #
               
               
               logicFlags32 returns flags set to the sign/zeroness of x.
C and V are set to false.
               
               func logicFlags32(x int32) flagConstant
            
            
            
               
                  logicFlags64 
                  function
                  
                  #
               
               
               logicFlags64 returns flags set to the sign/zeroness of x.
C and V are set to false.
               
               func logicFlags64(x int64) flagConstant
            
            
            
               
                  lookup 
                  method
                  
                  #
               
               
               lookup looks up a LocalSlot in the slot canonicalizer "sc", returning
a canonical index for the slot, and adding it to the table if need
be. Return value is the canonical slot index, and a boolean indicating
whether the slot was found in the table already (TRUE => found).
               
               func (sc *slotCanonicalizer) lookup(ls LocalSlot) (SlKeyIdx, bool)
            
            
            
               
                  lookup 
                  method
                  
                  #
               
               
               lookup searches for a SSA value into the forest of DAGS, and return its node.
               
               func (po *poset) lookup(n *Value) (uint32, bool)
            
            
            
               
                  loopRotate 
                  function
                  
                  #
               
               
               loopRotate converts loops with a check-loop-condition-at-beginning
to loops with a check-loop-condition-at-end.
This helps loops avoid extra unnecessary jumps.
loop:
CMPQ ...
JGE exit
...
JMP loop
exit:
JMP entry
loop:
...
entry:
CMPQ ...
JLT loop
               
               func loopRotate(f *Func)
            
            
            
               
                  loopnest 
                  method
                  
                  #
               
               
               loopnest returns the loop nest information for f.
               
               func (f *Func) loopnest() *loopnest
            
            
            
               
                  loopnestfor 
                  function
                  
                  #
               
               
               func loopnestfor(f *Func) *loopnest
            
            
            
               
                  lower 
                  function
                  
                  #
               
               
               convert to machine-dependent ops.
               
               func lower(f *Func)
            
            
            
               
                  lsb 
                  method
                  
                  #
               
               
               returns the lsb part of the auxInt field of arm64 bitfield ops.
               
               func (bfc arm64BitField) lsb() int64
            
            
            
               
                  lt 
                  method
                  
                  #
               
               
               func (fc flagConstant) lt() bool
            
            
            
               
                  lt2Cmp 
                  function
                  
                  #
               
               
               func lt2Cmp(isLt bool) types.Cmp
            
            
            
               
                  ltNoov 
                  method
                  
                  #
               
               
               func (fc flagConstant) ltNoov() bool
            
            
            
               
                  makeJumpTableSym 
                  function
                  
                  #
               
               
               func makeJumpTableSym(b *Block) *obj.LSym
            
            
            
               
                  makeLCArange 
                  function
                  
                  #
               
               
               func makeLCArange(f *Func) *lcaRange
            
            
            
               
                  makeSpill 
                  method
                  
                  #
               
               
               makeSpill returns a Value which represents the spilled value of v.
b is the block in which the spill is used.
               
               func (s *regAllocState) makeSpill(v *Value, b *Block) *Value
            
            
            
               
                  makeValAndOff 
                  function
                  
                  #
               
               
               func makeValAndOff(val int32, off int32) ValAndOff
            
            
            
               
                  mapFor 
                  method
                  
                  #
               
               
               mapFor returns the line range map for a given file index.
               
               func (m *xposmap) mapFor(index int32) *biasedSparseMap
            
            
            
               
                  maxSignedValue 
                  function
                  
                  #
               
               
               func maxSignedValue(t *types.Type) int64
            
            
            
               
                  maybeAppend 
                  function
                  
                  #
               
               
               func maybeAppend(f *Func, ss []*LocalSlot, s *LocalSlot) []*LocalSlot
            
            
            
               
                  maybeAppend2 
                  function
                  
                  #
               
               
               func maybeAppend2(f *Func, ss []*LocalSlot, s1 *LocalSlot, s2 *LocalSlot) []*LocalSlot
            
            
            
               
                  meet 
                  method
                  
                  #
               
               
               meet meets all of phi arguments and computes result lattice
               
               func (t *worklist) meet(val *Value) lattice
            
            
            
               
                  memCheck 
                  function
                  
                  #
               
               
               func memCheck(f *Func)
            
            
            
               
                  memState 
                  function
                  
                  #
               
               
               memState computes the memory state at the beginning and end of each block of
the function. The memory state is represented by a value of mem type.
The returned result is stored in startMem and endMem, and endMem is nil for
blocks with no successors (Exit,Ret,RetJmp blocks). This algorithm is not
suitable for infinite loop blocks that do not contain any mem operations.
For example:
b1:
(some values)
plain -> b2
b2: <- b1 b2
Plain -> b2
Algorithm introduction:
1. The start memory state of a block is InitMem, a Phi node of type mem or
an incoming memory value.
2. The start memory state of a block is consistent with the end memory state
of its parent nodes. If the start memory state of a block is a Phi value,
then the end memory state of its parent nodes is consistent with the
corresponding argument value of the Phi node.
3. The algorithm first obtains the memory state of some blocks in the tree
in the first step. Then floods the known memory state to other nodes in
the second step.
               
               func memState(f *Func, startMem []*Value, endMem []*Value)
            
            
            
               
                  memcombine 
                  function
                  
                  #
               
               
               memcombine combines smaller loads and stores into larger ones.
We ensure this generates good code for encoding/binary operations.
It may help other cases also.
               
               func memcombine(f *Func)
            
            
            
               
                  memcombineLoads 
                  function
                  
                  #
               
               
               func memcombineLoads(f *Func)
            
            
            
               
                  memcombineStores 
                  function
                  
                  #
               
               
               func memcombineStores(f *Func)
            
            
            
               
                  merge 
                  method
                  
                  #
               
               
               merge merges another desired state x into d.
               
               func (d *desiredState) merge(x *desiredState)
            
            
            
               
                  merge 
                  method
                  
                  #
               
               
               merge returns the union of sr and [lo:hi].
merge is allowed to return something smaller than the union.
               
               func (sr shadowRange) merge(lo int64, hi int64) shadowRange
            
            
            
               
                  mergePPC64AndRlwinm 
                  function
                  
                  #
               
               
               Test if RLWINM feeding into an ANDconst can be merged. Return the encoded RLWINM constant,
or 0 if they cannot be merged.
               
               func mergePPC64AndRlwinm(mask uint32, rlw int64) int64
            
            
            
               
                  mergePPC64AndSldi 
                  function
                  
                  #
               
               
               Combine (ANDconst [m] (SLDconst [s])) into (RLWINM [y]) or return 0
               
               func mergePPC64AndSldi(m int64, s int64) int64
            
            
            
               
                  mergePPC64AndSrdi 
                  function
                  
                  #
               
               
               Combine (ANDconst [m] (SRDconst [s])) into (RLWINM [y]) or return 0
               
               func mergePPC64AndSrdi(m int64, s int64) int64
            
            
            
               
                  mergePPC64AndSrwi 
                  function
                  
                  #
               
               
               Combine (ANDconst [m] (SRWconst [s])) into (RLWINM [y]) or return 0
               
               func mergePPC64AndSrwi(m int64, s int64) int64
            
            
            
               
                  mergePPC64ClrlsldiRlwinm 
                  function
                  
                  #
               
               
               Test if a RLWINM feeding into a CLRLSLDI can be merged into RLWINM.  Return
the encoded RLWINM constant, or 0 if they cannot be merged.
               
               func mergePPC64ClrlsldiRlwinm(sld int32, rlw int64) int64
            
            
            
               
                  mergePPC64ClrlsldiSrd 
                  function
                  
                  #
               
               
               Test if a doubleword shift right feeding into a CLRLSLDI can be merged into RLWINM.
Return the encoded RLWINM constant, or 0 if they cannot be merged.
               
               func mergePPC64ClrlsldiSrd(sld int64, srd int64) int64
            
            
            
               
                  mergePPC64ClrlsldiSrw 
                  function
                  
                  #
               
               
               Test if a word shift right feeding into a CLRLSLDI can be merged into RLWINM.
Return the encoded RLWINM constant, or 0 if they cannot be merged.
               
               func mergePPC64ClrlsldiSrw(sld int64, srw int64) int64
            
            
            
               
                  mergePPC64MovwzregRlwinm 
                  function
                  
                  #
               
               
               Test if RLWINM opcode rlw clears the upper 32 bits of the
result. Return rlw if it does, 0 otherwise.
               
               func mergePPC64MovwzregRlwinm(rlw int64) int64
            
            
            
               
                  mergePPC64RLDICLandSRDconst 
                  function
                  
                  #
               
               
               Merge (RLDICL [encoded] (SRDconst [s] x)) into (RLDICL [new_encoded] x)
SRDconst on PPC64 is an extended mnemonic of RLDICL. If the input to an
RLDICL is an SRDconst, and the RLDICL does not rotate its value, the two
operations can be combined. This functions assumes the two opcodes can
be merged, and returns an encoded rotate+mask value of the combined RLDICL.
               
               func mergePPC64RLDICLandSRDconst(encoded int64, s int64) int64
            
            
            
               
                  mergePPC64RShiftMask 
                  function
                  
                  #
               
               
               Decompose a shift right into an equivalent rotate/mask,
and return mask & m.
               
               func mergePPC64RShiftMask(m int64, s int64, nbits int64) int64
            
            
            
               
                  mergePPC64RlwinmAnd 
                  function
                  
                  #
               
               
               Test if AND feeding into an ANDconst can be merged. Return the encoded RLWINM constant,
or 0 if they cannot be merged.
               
               func mergePPC64RlwinmAnd(rlw int64, mask uint32) int64
            
            
            
               
                  mergePPC64SldiRlwinm 
                  function
                  
                  #
               
               
               Test if RLWINM feeding into SRDconst can be merged. Return the encoded RLIWNM constant,
or 0 if they cannot be merged.
               
               func mergePPC64SldiRlwinm(sldi int64, rlw int64) int64
            
            
            
               
                  mergePPC64SldiSrw 
                  function
                  
                  #
               
               
               Compute the encoded RLWINM constant from combining (SLDconst [sld] (SRWconst [srw] x)),
or return 0 if they cannot be combined.
               
               func mergePPC64SldiSrw(sld int64, srw int64) int64
            
            
            
               
                  mergePhi 
                  function
                  
                  #
               
               
               mergePhi adjusts the number of `v`s arguments to account for merge
of `b`, which was `i`th predecessor of the `v`s block.
               
               func mergePhi(v *Value, i int, b *Block)
            
            
            
               
                  mergePoint 
                  function
                  
                  #
               
               
               mergePoint finds a block among a's blocks which dominates b and is itself
dominated by all of a's blocks. Returns nil if it can't find one.
Might return nil even if one does exist.
               
               func mergePoint(b *Block, a ...*Value) *Block
            
            
            
               
                  mergePredecessors 
                  method
                  
                  #
               
               
               mergePredecessors takes the end state of each of b's predecessors and
intersects them to form the starting state for b. It puts that state
in blockLocs[b.ID].startState, and fills state.currentState with it.
It returns the start state and whether this is changed from the
previously approximated value of startState for this block.  After
the first call, subsequent calls can only shrink startState.
Passing forLocationLists=true enables additional side-effects that
are necessary for building location lists but superfluous while still
iterating to an answer.
If previousBlock is non-nil, it registers changes vs. that block's
end state in state.changedVars. Note that previousBlock will often
not be a predecessor.
Note that mergePredecessors behaves slightly differently between
first and subsequent calls for a block.  For the first call, the
starting state is approximated by taking the state from the
predecessor whose state is smallest, and removing any elements not
in all the other predecessors; this makes the smallest number of
changes and shares the most state.  On subsequent calls the old
value of startState is adjusted with new information; this is judged
to do the least amount of extra work.
To improve performance, each block's state information is marked with
lastChanged and lastChecked "times" so unchanged predecessors can be
skipped on after-the-first iterations.  Doing this allows extra
iterations by the caller to be almost free.
It is important to know that the set representation used for
startState, endState, and merges can share data for two sets where
one is a small delta from the other.  Doing this does require a
little care in how sets are updated, both in mergePredecessors, and
using its result.
               
               func (state *debugState) mergePredecessors(b *Block, blockLocs []*BlockDebug, previousBlock *Block, forLocationLists bool) (abt.T, bool)
            
            
            
               
                  mergeSym 
                  function
                  
                  #
               
               
               mergeSym merges two symbolic offsets. There is no real merging of
offsets, we just pick the non-nil one.
               
               func mergeSym(x Sym, y Sym) Sym
            
            
            
               
                  mergeroot 
                  method
                  
                  #
               
               
               mergeroot merges two DAGs into one DAG by creating a new extra root
               
               func (po *poset) mergeroot(r1 uint32, r2 uint32) uint32
            
            
            
               
                  mightBeHeapPointer 
                  function
                  
                  #
               
               
               mightBeHeapPointer reports whether v might point to the heap.
v must have pointer type.
               
               func mightBeHeapPointer(v *Value) bool
            
            
            
               
                  mightContainHeapPointer 
                  function
                  
                  #
               
               
               mightContainHeapPointer reports whether the data currently at addresses
[ptr,ptr+size) might contain heap pointers. "currently" means at memory state mem.
zeroes contains ZeroRegion data to help make that decision (see computeZeroMap).
               
               func mightContainHeapPointer(ptr *Value, size int64, mem *Value, zeroes map[ID]ZeroRegion) bool
            
            
            
               
                  minSignedValue 
                  function
                  
                  #
               
               
               func minSignedValue(t *types.Type) int64
            
            
            
               
                  moveSize 
                  function
                  
                  #
               
               
               moveSize returns the number of bytes an aligned MOV instruction moves.
               
               func moveSize(align int64, c *Config) int64
            
            
            
               
                  moveTo 
                  method
                  
                  #
               
               
               moveTo moves v to dst, adjusting the appropriate Block.Values slices.
The caller is responsible for ensuring that this is safe.
i is the index of v in v.Block.Values.
               
               func (v *Value) moveTo(dst *Block, i int)
            
            
            
               
                  mul 
                  method
                  
                  #
               
               
               same as add but for multiplication.
               
               func (l limit) mul(l2 limit, b uint) limit
            
            
            
               
                  named 
                  method
                  
                  #
               
               
               func (p htmlFuncPrinter) named(n LocalSlot, vals []*Value)
            
            
            
               
                  named 
                  method
                  
                  #
               
               
               func (p stringFuncPrinter) named(n LocalSlot, vals []*Value)
            
            
            
               
                  ne 
                  method
                  
                  #
               
               
               func (fc flagConstant) ne() bool
            
            
            
               
                  nearestOuterLoop 
                  method
                  
                  #
               
               
               nearestOuterLoop returns the outer loop of loop most nearly
containing block b; the header must dominate b.  loop itself
is assumed to not be that loop. For acceptable performance,
we're relying on loop nests to not be terribly deep.
               
               func (l *loop) nearestOuterLoop(sdom SparseTree, b *Block) *loop
            
            
            
               
                  needRaceCleanup 
                  function
                  
                  #
               
               
               needRaceCleanup reports whether this call to racefuncenter/exit isn't needed.
               
               func needRaceCleanup(sym *AuxCall, v *Value) bool
            
            
            
               
                  needRegister 
                  method
                  
                  #
               
               
               needRegister reports whether v needs a register.
               
               func (v *Value) needRegister() bool
            
            
            
               
                  needWBdst 
                  function
                  
                  #
               
               
               needWBdst reports whether GC needs to see what used to be in *ptr when ptr is
the target of a pointer store.
               
               func needWBdst(ptr *Value, mem *Value, zeroes map[ID]ZeroRegion) bool
            
            
            
               
                  needWBsrc 
                  function
                  
                  #
               
               
               needWBsrc reports whether GC needs to see v when it is the source of a store.
               
               func needWBsrc(v *Value) bool
            
            
            
               
                  needwb 
                  function
                  
                  #
               
               
               needwb reports whether we need write barrier for store op v.
v must be Store/Move/Zero.
zeroes provides known zero information (keyed by ID of memory-type values).
               
               func needwb(v *Value, zeroes map[ID]ZeroRegion) bool
            
            
            
               
                  newBiasedSparseMap 
                  function
                  
                  #
               
               
               newBiasedSparseMap returns a new biasedSparseMap for values between first and last, inclusive.
               
               func newBiasedSparseMap(first int, last int) *biasedSparseMap
            
            
            
               
                  newBitset 
                  function
                  
                  #
               
               
               func newBitset(n int) bitset
            
            
            
               
                  newDotWriter 
                  function
                  
                  #
               
               
               newDotWriter returns non-nil value when mask is valid.
dotWriter will generate SVGs only for the phases specified in the mask.
mask can contain following patterns and combinations of them:
*   - all of them;
x-y - x through y, inclusive;
x,y - x and y, but not the passes between.
               
               func newDotWriter(mask string) *dotWriter
            
            
            
               
                  newFactsTable 
                  function
                  
                  #
               
               
               func newFactsTable(f *Func) *factsTable
            
            
            
               
                  newLimit 
                  method
                  
                  #
               
               
               newLimit adds new limiting information for v.
Returns true if the new limit added any new information.
               
               func (ft *factsTable) newLimit(v *Value, newLim limit) bool
            
            
            
               
                  newPPC64ShiftAuxInt 
                  function
                  
                  #
               
               
               func newPPC64ShiftAuxInt(sh int64, mb int64, me int64, sz int64) int32
            
            
            
               
                  newPhiFor 
                  function
                  
                  #
               
               
               newPhiFor inserts a new Phi function into b,
with all inputs set to v.
               
               func newPhiFor(b *Block, v *Value) *Value
            
            
            
               
                  newPoset 
                  method
                  
                  #
               
               
               newPoset returns a new poset from the internal cache
               
               func (f *Func) newPoset() *poset
            
            
            
               
                  newPoset 
                  function
                  
                  #
               
               
               func newPoset() *poset
            
            
            
               
                  newSlotCanonicalizer 
                  function
                  
                  #
               
               
               func newSlotCanonicalizer() *slotCanonicalizer
            
            
            
               
                  newSparseMap 
                  method
                  
                  #
               
               
               newSparseMap returns a sparse map that can store at least up to n integers.
               
               func (f *Func) newSparseMap(n int) *sparseMap
            
            
            
               
                  newSparseMap 
                  function
                  
                  #
               
               
               newSparseMap returns a sparseMap that can map
integers between 0 and n-1 to int32s.
               
               func newSparseMap(n int) *sparseMap
            
            
            
               
                  newSparseMapPos 
                  function
                  
                  #
               
               
               newSparseMapPos returns a sparseMapPos that can map
integers between 0 and n-1 to the pair .
               
               func newSparseMapPos(n int) *sparseMapPos
            
            
            
               
                  newSparseMapPos 
                  method
                  
                  #
               
               
               newSparseMapPos returns a sparse map that can store at least up to n integers.
               
               func (f *Func) newSparseMapPos(n int) *sparseMapPos
            
            
            
               
                  newSparseOrderedTree 
                  function
                  
                  #
               
               
               newSparseOrderedTree creates a SparseTree from a block-to-parent map (array indexed by Block.ID)
children will appear in the reverse of their order in reverseOrder
in particular, if reverseOrder is a dfs-reversePostOrder, then the root-to-children
walk of the tree will yield a pre-order.
               
               func newSparseOrderedTree(f *Func, parentOf []*Block, reverseOrder []*Block) SparseTree
            
            
            
               
                  newSparseSet 
                  function
                  
                  #
               
               
               newSparseSet returns a sparseSet that can represent
integers between 0 and n-1.
               
               func newSparseSet(n int) *sparseSet
            
            
            
               
                  newSparseSet 
                  method
                  
                  #
               
               
               newSparseSet returns a sparse set that can store at least up to n integers.
               
               func (f *Func) newSparseSet(n int) *sparseSet
            
            
            
               
                  newSparseTree 
                  function
                  
                  #
               
               
               newSparseTree creates a SparseTree from a block-to-parent map (array indexed by Block.ID).
               
               func newSparseTree(f *Func, parentOf []*Block) SparseTree
            
            
            
               
                  newStackAllocState 
                  function
                  
                  #
               
               
               func newStackAllocState(f *Func) *stackAllocState
            
            
            
               
                  newValue 
                  method
                  
                  #
               
               
               newValue allocates a new Value with the given fields and places it at the end of b.Values.
               
               func (f *Func) newValue(op Op, t *types.Type, b *Block, pos src.XPos) *Value
            
            
            
               
                  newValueNoBlock 
                  method
                  
                  #
               
               
               newValueNoBlock allocates a new Value with the given fields.
The returned value is not placed in any block.  Once the caller
decides on a block b, it must set b.Block and append
the returned value to b.Values.
               
               func (f *Func) newValueNoBlock(op Op, t *types.Type, pos src.XPos) *Value
            
            
            
               
                  newXposmap 
                  function
                  
                  #
               
               
               newXposmap constructs an xposmap valid for inputs which have a file index in the keys of x,
and line numbers in the range x[file index].
The resulting xposmap will panic if a caller attempts to set or add an XPos not in that range.
               
               func newXposmap(x map[int]lineRange) *xposmap
            
            
            
               
                  newedge 
                  function
                  
                  #
               
               
               func newedge(t uint32, strict bool) posetEdge
            
            
            
               
                  newnode 
                  method
                  
                  #
               
               
               newnode allocates a new node bound to SSA value n.
If n is nil, this is an extra node (= only used internally).
               
               func (po *poset) newnode(n *Value) uint32
            
            
            
               
                  next 
                  method
                  
                  #
               
               
               next effectively post-increments the register cursor; the receiver is advanced,
the (aligned) old value is returned.
               
               func (c *registerCursor) next(t *types.Type) registerCursor
            
            
            
               
                  nextGoodStatementIndex 
                  function
                  
                  #
               
               
               nextGoodStatementIndex returns an index at i or later that is believed
to be a good place to start the statement for b.  This decision is
based on v's Op, the possibility of a better later operation, and
whether the values following i are the same line as v.
If a better statement index isn't found, then i is returned.
               
               func nextGoodStatementIndex(v *Value, i int, b *Block) int
            
            
            
               
                  nilcheckelim 
                  function
                  
                  #
               
               
               nilcheckelim eliminates unnecessary nil checks.
runs on machine-independent code.
               
               func nilcheckelim(f *Func)
            
            
            
               
                  nilcheckelim2 
                  function
                  
                  #
               
               
               nilcheckelim2 eliminates unnecessary nil checks.
Runs after lowering and scheduling.
               
               func nilcheckelim2(f *Func)
            
            
            
               
                  nlz16 
                  function
                  
                  #
               
               
               func nlz16(x int16) int
            
            
            
               
                  nlz32 
                  function
                  
                  #
               
               
               func nlz32(x int32) int
            
            
            
               
                  nlz64 
                  function
                  
                  #
               
               
               nlzX returns the number of leading zeros.
               
               func nlz64(x int64) int
            
            
            
               
                  nlz8 
                  function
                  
                  #
               
               
               func nlz8(x int8) int
            
            
            
               
                  nonnegative 
                  method
                  
                  #
               
               
               func (l limit) nonnegative() bool
            
            
            
               
                  nonzero 
                  method
                  
                  #
               
               
               func (l limit) nonzero() bool
            
            
            
               
                  notStmtBoundary 
                  function
                  
                  #
               
               
               notStmtBoundary reports whether a value with opcode op can never be a statement
boundary. Such values don't correspond to a user's understanding of a
statement boundary.
               
               func notStmtBoundary(op Op) bool
            
            
            
               
                  noteRule 
                  function
                  
                  #
               
               
               noteRule is an easy way to track if a rule is matched when writing
new ones.  Make the rule of interest also conditional on
noteRule("note to self: rule of interest matched")
and that message will print when the rule matches.
               
               func noteRule(s string) bool
            
            
            
               
                  nto 
                  function
                  
                  #
               
               
               nto returns the number of trailing ones.
               
               func nto(x int64) int64
            
            
            
               
                  ntz16 
                  function
                  
                  #
               
               
               func ntz16(x int16) int
            
            
            
               
                  ntz32 
                  function
                  
                  #
               
               
               func ntz32(x int32) int
            
            
            
               
                  ntz64 
                  function
                  
                  #
               
               
               ntzX returns the number of trailing zeros.
               
               func ntz64(x int64) int
            
            
            
               
                  ntz8 
                  function
                  
                  #
               
               
               func ntz8(x int8) int
            
            
            
               
                  num 
                  method
                  
                  #
               
               
               num returns the maximum ID ever returned + 1.
               
               func (a *idAlloc) num() int
            
            
            
               
                  numberBlock 
                  method
                  
                  #
               
               
               func (t SparseTree) numberBlock(b *Block, n int32) int32
            
            
            
               
                  numberLines 
                  function
                  
                  #
               
               
               -d=ssa/number_lines/stats=1 (that bit) for line and file distribution statistics
-d=ssa/number_lines/debug for information about why particular values are marked as statements.
               
               func numberLines(f *Func)
            
            
            
               
                  offsetFrom 
                  method
                  
                  #
               
               
               offsetFrom creates an offset from a pointer, simplifying chained offsets and offsets from SP
               
               func (x *expandState) offsetFrom(b *Block, from *Value, offset int64, pt *types.Type) *Value
            
            
            
               
                  onStack 
                  method
                  
                  #
               
               
               func (s StackOffset) onStack() bool
            
            
            
               
                  oneBit 
                  function
                  
                  #
               
               
               func oneBit(x int64) bool
            
            
            
               
                  oneBit16 
                  function
                  
                  #
               
               
               func oneBit16(x int16) bool
            
            
            
               
                  oneBit32 
                  function
                  
                  #
               
               
               func oneBit32(x int32) bool
            
            
            
               
                  oneBit64 
                  function
                  
                  #
               
               
               func oneBit64(x int64) bool
            
            
            
               
                  oneBit8 
                  function
                  
                  #
               
               
               func oneBit8(x int8) bool
            
            
            
               
                  opToAuxInt 
                  function
                  
                  #
               
               
               func opToAuxInt(o Op) int64
            
            
            
               
                  opt 
                  function
                  
                  #
               
               
               machine-independent optimization.
               
               func opt(f *Func)
            
            
            
               
                  outerinner 
                  method
                  
                  #
               
               
               outerinner records that outer contains inner
               
               func (sdom SparseTree) outerinner(outer *loop, inner *loop)
            
            
            
               
                  overlap 
                  function
                  
                  #
               
               
               overlap reports whether the ranges given by the given offset and
size pairs overlap.
               
               func overlap(offset1 int64, size1 int64, offset2 int64, size2 int64) bool
            
            
            
               
                  parseIndVar 
                  function
                  
                  #
               
               
               parseIndVar checks whether the SSA value passed as argument is a valid induction
variable, and, if so, extracts:
- the minimum bound
- the increment value
- the "next" value (SSA value that is Phi'd into the induction variable every loop)
Currently, we detect induction variables that match (Phi min nxt),
with nxt being (Add inc ind).
If it can't parse the induction variable correctly, it returns (nil, nil, nil).
               
               func parseIndVar(ind *Value) (min *Value, inc *Value, nxt *Value)
            
            
            
               
                  partitionValues 
                  function
                  
                  #
               
               
               partitionValues partitions the values into equivalence classes
based on having all the following features match:
- opcode
- type
- auxint
- aux
- nargs
- block # if a phi op
- first two arg's opcodes and auxint
- NOT first two arg's aux; that can break CSE.
partitionValues returns a list of equivalence classes, each
being a sorted by ID list of *Values. The eqclass slices are
backed by the same storage as the input slice.
Equivalence classes of size 1 are ignored.
               
               func partitionValues(a []*Value, auxIDs auxmap) []eqclass
            
            
            
               
                  passIdxByName 
                  function
                  
                  #
               
               
               func passIdxByName(name string) int
            
            
            
               
                  phiTighten 
                  function
                  
                  #
               
               
               phiTighten moves constants closer to phi users.
This pass avoids having lots of constants live for lots of the program.
See issue 16407.
               
               func phiTighten(f *Func)
            
            
            
               
                  phielim 
                  function
                  
                  #
               
               
               phielim eliminates redundant phi values from f.
A phi is redundant if its arguments are all equal. For
purposes of counting, ignore the phi itself. Both of
these phis are redundant:
v = phi(x,x,x)
v = phi(x,v,x,v)
We repeat this process to also catch situations like:
v = phi(x, phi(x, x), phi(x, v))
TODO: Can we also simplify cases like:
v = phi(v, w, x)
w = phi(v, w, x)
and would that be useful?
               
               func phielim(f *Func)
            
            
            
               
                  phielimValue 
                  function
                  
                  #
               
               
               phielimValue tries to convert the phi v to a copy.
               
               func phielimValue(v *Value) bool
            
            
            
               
                  phiopt 
                  function
                  
                  #
               
               
               phiopt eliminates boolean Phis based on the previous if.
Main use case is to transform:
x := false
if b {
x = true
}
into x = b.
In SSA code this appears as
b0
If b -> b1 b2
b1
Plain -> b2
b2
x = (OpPhi (ConstBool [true]) (ConstBool [false]))
In this case we can replace x with a copy of b.
               
               func phiopt(f *Func)
            
            
            
               
                  phioptint 
                  function
                  
                  #
               
               
               func phioptint(v *Value, b0 *Block, reverse int)
            
            
            
               
                  pickReg 
                  function
                  
                  #
               
               
               pickReg picks an arbitrary register from the register mask.
               
               func pickReg(r regMask) register
            
            
            
               
                  placeSpills 
                  method
                  
                  #
               
               
               func (s *regAllocState) placeSpills()
            
            
            
               
                  plus 
                  method
                  
                  #
               
               
               plus returns a register cursor offset from the original, without modifying the original.
               
               func (c *registerCursor) plus(regWidth Abi1RO) registerCursor
            
            
            
               
                  pointerNil 
                  method
                  
                  #
               
               
               func (ft *factsTable) pointerNil(v *Value) bool
            
            
            
               
                  pointerNonNil 
                  method
                  
                  #
               
               
               func (ft *factsTable) pointerNonNil(v *Value) bool
            
            
            
               
                  pop 
                  method
                  
                  #
               
               
               pop removes an arbitrary element from the set.
The set must be nonempty.
               
               func (s *sparseSet) pop() ID
            
            
            
               
                  possibleConst 
                  function
                  
                  #
               
               
               possibleConst checks if Value can be folded to const. For those Values that can
never become constants(e.g. StaticCall), we don't make futile efforts.
               
               func possibleConst(val *Value) bool
            
            
            
               
                  postExpandCallsDecompose 
                  function
                  
                  #
               
               
               func postExpandCallsDecompose(f *Func)
            
            
            
               
                  postorder 
                  function
                  
                  #
               
               
               postorder computes a postorder traversal ordering for the
basic blocks in f. Unreachable blocks will not appear.
               
               func postorder(f *Func) []*Block
            
            
            
               
                  postorder 
                  method
                  
                  #
               
               
               postorder returns the reachable blocks in f in a postorder traversal.
               
               func (f *Func) postorder() []*Block
            
            
            
               
                  postorderWithNumbering 
                  function
                  
                  #
               
               
               postorderWithNumbering provides a DFS postordering.
This seems to make loop-finding more robust.
               
               func postorderWithNumbering(f *Func, ponums []int32) []*Block
            
            
            
               
                  prAssignForArg 
                  method
                  
                  #
               
               
               prAssignForArg returns the ABIParamAssignment for v, assumed to be an OpArg.
               
               func (x *expandState) prAssignForArg(v *Value) *abi.ABIParamAssignment
            
            
            
               
                  printFunc 
                  function
                  
                  #
               
               
               func printFunc(f *Func)
            
            
            
               
                  printIndVar 
                  function
                  
                  #
               
               
               func printIndVar(b *Block, i *Value, min *Value, max *Value, inc int64, flags indVarFlags)
            
            
            
               
                  process 
                  method
                  
                  #
               
               
               process generates code to move all the values to the right destination locations.
               
               func (e *edgeState) process()
            
            
            
               
                  processDest 
                  method
                  
                  #
               
               
               processDest generates code to put value vid into location loc. Returns true
if progress was made.
               
               func (e *edgeState) processDest(loc Location, vid ID, splice **Value, pos src.XPos) bool
            
            
            
               
                  processValue 
                  method
                  
                  #
               
               
               processValue updates locs and state.registerContents to reflect v, a
value with the names in vSlots and homed in vReg.  "v" becomes
visible after execution of the instructions evaluating it. It
returns which VarIDs were modified by the Value's execution.
               
               func (state *debugState) processValue(v *Value, vSlots []SlotID, vReg *Register) bool
            
            
            
               
                  propagate 
                  method
                  
                  #
               
               
               propagate propagates constants facts through CFG. If the block has single successor,
add the successor anyway. If the block has multiple successors, only add the
branch destination corresponding to lattice value of condition value.
               
               func (t *worklist) propagate(block *Block)
            
            
            
               
                  prove 
                  function
                  
                  #
               
               
               prove removes redundant BlockIf branches that can be inferred
from previous dominating comparisons.
By far, the most common redundant pair are generated by bounds checking.
For example for the code:
a[i] = 4
foo(a[i])
The compiler will generate the following code:
if i >= len(a) {
panic("not in bounds")
}
a[i] = 4
if i >= len(a) {
panic("not in bounds")
}
foo(a[i])
The second comparison i >= len(a) is clearly redundant because if the
else branch of the first comparison is executed, we already know that i < len(a).
The code for the second panic can be removed.
prove works by finding contradictions and trimming branches whose
conditions are unsatisfiable given the branches leading up to them.
It tracks a "fact table" of branch conditions. For each branching
block, it asserts the branch conditions that uniquely dominate that
block, and then separately asserts the block's branch condition and
its negation. If either leads to a contradiction, it can trim that
successor.
               
               func prove(f *Func)
            
            
            
               
                  putStackAllocState 
                  function
                  
                  #
               
               
               func putStackAllocState(s *stackAllocState)
            
            
            
               
                  reaches 
                  method
                  
                  #
               
               
               Returns true if there is a path from i1 to i2.
If strict ==  true: if the function returns true, then i1 <  i2.
If strict == false: if the function returns true, then i1 <= i2.
If the function returns false, no relation is known.
               
               func (po *poset) reaches(i1 uint32, i2 uint32, strict bool) bool
            
            
            
               
                  read16 
                  function
                  
                  #
               
               
               read16 reads two bytes from the read-only global sym at offset off.
               
               func read16(sym interface{}, off int64, byteorder binary.ByteOrder) uint16
            
            
            
               
                  read32 
                  function
                  
                  #
               
               
               read32 reads four bytes from the read-only global sym at offset off.
               
               func read32(sym interface{}, off int64, byteorder binary.ByteOrder) uint32
            
            
            
               
                  read64 
                  function
                  
                  #
               
               
               read64 reads eight bytes from the read-only global sym at offset off.
               
               func read64(sym interface{}, off int64, byteorder binary.ByteOrder) uint64
            
            
            
               
                  read8 
                  function
                  
                  #
               
               
               read8 reads one byte from the read-only global sym at offset off.
               
               func read8(sym interface{}, off int64) uint8
            
            
            
               
                  readPtr 
                  function
                  
                  #
               
               
               Read a pointer-sized uint from the beginning of buf.
               
               func readPtr(ctxt *obj.Link, buf []byte) uint64
            
            
            
               
                  reciprocalExact32 
                  function
                  
                  #
               
               
               reciprocalExact32 reports whether 1/c is exactly representable.
               
               func reciprocalExact32(c float32) bool
            
            
            
               
                  reciprocalExact64 
                  function
                  
                  #
               
               
               reciprocalExact64 reports whether 1/c is exactly representable.
               
               func reciprocalExact64(c float64) bool
            
            
            
               
                  recordIfExit 
                  function
                  
                  #
               
               
               recordIfExit checks sl (the loop containing b) to see if it
is outside of loop l, and if so, records b as an exit block
from l and returns true.
               
               func recordIfExit(l *loop, sl *loop, b *Block) bool
            
            
            
               
                  regOffset 
                  method
                  
                  #
               
               
               regOffset returns the register offset of the i'th element of type t
               
               func (x *expandState) regOffset(t *types.Type, i int) Abi1RO
            
            
            
               
                  regWidth 
                  method
                  
                  #
               
               
               func (x *expandState) regWidth(t *types.Type) Abi1RO
            
            
            
               
                  regalloc 
                  function
                  
                  #
               
               
               regalloc performs register allocation on f. It sets f.RegAlloc
to the resulting allocation.
               
               func regalloc(f *Func)
            
            
            
               
                  regalloc 
                  method
                  
                  #
               
               
               func (s *regAllocState) regalloc(f *Func)
            
            
            
               
                  registerizable 
                  function
                  
                  #
               
               
               registerizable reports whether t is a primitive type that fits in
a register. It assumes float64 values will always fit into registers
even if that isn't strictly true.
               
               func registerizable(b *Block, typ *types.Type) bool
            
            
            
               
                  regspec 
                  method
                  
                  #
               
               
               regspec returns the regInfo for operation op.
               
               func (s *regAllocState) regspec(v *Value) regInfo
            
            
            
               
                  rematerializeable 
                  method
                  
                  #
               
               
               rematerializeable reports whether the register allocator should recompute
a value instead of spilling/restoring it.
               
               func (v *Value) rematerializeable() bool
            
            
            
               
                  remove 
                  method
                  
                  #
               
               
               func (s *sparseMapPos) remove(k ID)
            
            
            
               
                  remove 
                  method
                  
                  #
               
               
               func (s *sparseSet) remove(x ID)
            
            
            
               
                  remove 
                  method
                  
                  #
               
               
               remove removes key x from s.
               
               func (s *biasedSparseMap) remove(x uint)
            
            
            
               
                  remove 
                  method
                  
                  #
               
               
               func (s *sparseMap) remove(k ID)
            
            
            
               
                  remove 
                  method
                  
                  #
               
               
               remove removes the desired registers for vid and returns them.
               
               func (d *desiredState) remove(vid ID) [4]register
            
            
            
               
                  remove 
                  method
                  
                  #
               
               
               remove removes the file index and line for p from m,
whether m is currently treated as a map or set.
               
               func (m *xposmap) remove(p src.XPos)
            
            
            
               
                  removeBranch 
                  function
                  
                  #
               
               
               func removeBranch(b *Block, branch branch)
            
            
            
               
                  removeEdge 
                  method
                  
                  #
               
               
               removeEdge removes the i'th outgoing edge from b (and
the corresponding incoming edge from b.Succs[i].b).
Note that this potentially reorders successors of b, so it
must be used very carefully.
               
               func (b *Block) removeEdge(i int)
            
            
            
               
                  removePhiArg 
                  method
                  
                  #
               
               
               removePhiArg removes the ith arg from phi.
It must be called after calling b.removePred(i) to
adjust the corresponding phi value of the block:
b.removePred(i)
for _, v := range b.Values {
if v.Op != OpPhi {
continue
}
b.removePhiArg(v, i)
}
               
               func (b *Block) removePhiArg(phi *Value, i int)
            
            
            
               
                  removePred 
                  method
                  
                  #
               
               
               removePred removes the ith input edge from b.
It is the responsibility of the caller to remove
the corresponding successor edge, and adjust any
phi values by calling b.removePhiArg(v, i).
               
               func (b *Block) removePred(i int)
            
            
            
               
                  removeSucc 
                  method
                  
                  #
               
               
               removeSucc removes the ith output edge from b.
It is the responsibility of the caller to remove
the corresponding predecessor edge.
Note that this potentially reorders successors of b, so it
must be used very carefully.
               
               func (b *Block) removeSucc(i int)
            
            
            
               
                  removeable 
                  method
                  
                  #
               
               
               removeable reports whether the value v can be removed from the SSA graph entirely
if its use count drops to 0.
               
               func (v *Value) removeable() bool
            
            
            
               
                  removeroot 
                  method
                  
                  #
               
               
               func (po *poset) removeroot(r uint32)
            
            
            
               
                  replaceConst 
                  method
                  
                  #
               
               
               replaceConst will replace non-constant values that have been proven by sccp
to be constants.
               
               func (t *worklist) replaceConst() (int, int)
            
            
            
               
                  replaceUses 
                  method
                  
                  #
               
               
               replaceUses replaces all uses of old in b with new.
               
               func (b *Block) replaceUses(old *Value, new *Value)
            
            
            
               
                  reset 
                  method
                  
                  #
               
               
               reset is called from most rewrite rules.
Allowing it to be inlined increases the size
of cmd/compile by almost 10%, and slows it down.
go:noinline
               
               func (v *Value) reset(op Op)
            
            
            
               
                  reset 
                  method
                  
                  #
               
               
               reset fills state with the live variables from live.
               
               func (state *stateAtPC) reset(live abt.T)
            
            
            
               
                  resetArgs 
                  method
                  
                  #
               
               
               func (v *Value) resetArgs()
            
            
            
               
                  resetWithControl 
                  method
                  
                  #
               
               
               resetWithControl resets b and adds control v.
It is equivalent to b.Reset(kind); b.AddControl(v),
except that it is one call instead of two and avoids a bounds check.
It is intended for use by rewrite rules, where this matters.
               
               func (b *Block) resetWithControl(kind BlockKind, v *Value)
            
            
            
               
                  resetWithControl2 
                  method
                  
                  #
               
               
               resetWithControl2 resets b and adds controls v and w.
It is equivalent to b.Reset(kind); b.AddControl(v); b.AddControl(w),
except that it is one call instead of three and avoids two bounds checks.
It is intended for use by rewrite rules, where this matters.
               
               func (b *Block) resetWithControl2(kind BlockKind, v *Value, w *Value)
            
            
            
               
                  restore 
                  method
                  
                  #
               
               
               restore restores known relation to the state just
before the previous checkpoint.
Called when backing up on a branch.
               
               func (ft *factsTable) restore()
            
            
            
               
                  retPoset 
                  method
                  
                  #
               
               
               retPoset returns a poset to the internal cache
               
               func (f *Func) retPoset(po *poset)
            
            
            
               
                  retSparseMap 
                  method
                  
                  #
               
               
               retSparseMap returns a sparse map to the config's cache of sparse
sets to be reused by f.newSparseMap.
               
               func (f *Func) retSparseMap(ss *sparseMap)
            
            
            
               
                  retSparseMapPos 
                  method
                  
                  #
               
               
               retSparseMapPos returns a sparse map to the config's cache of sparse
sets to be reused by f.newSparseMapPos.
               
               func (f *Func) retSparseMapPos(ss *sparseMapPos)
            
            
            
               
                  retSparseSet 
                  method
                  
                  #
               
               
               retSparseSet returns a sparse set to the config's cache of sparse
sets to be reused by f.newSparseSet.
               
               func (f *Func) retSparseSet(ss *sparseSet)
            
            
            
               
                  rewireSuccessor 
                  function
                  
                  #
               
               
               rewireSuccessor rewires corresponding successors according to constant value
discovered by previous analysis. As the result, some successors become unreachable
and thus can be removed in further deadcode phase
               
               func rewireSuccessor(block *Block, constVal *Value) bool
            
            
            
               
                  rewriteBlock386 
                  function
                  
                  #
               
               
               func rewriteBlock386(b *Block) bool
            
            
            
               
                  rewriteBlock386splitload 
                  function
                  
                  #
               
               
               func rewriteBlock386splitload(b *Block) bool
            
            
            
               
                  rewriteBlockAMD64 
                  function
                  
                  #
               
               
               func rewriteBlockAMD64(b *Block) bool
            
            
            
               
                  rewriteBlockAMD64latelower 
                  function
                  
                  #
               
               
               func rewriteBlockAMD64latelower(b *Block) bool
            
            
            
               
                  rewriteBlockAMD64splitload 
                  function
                  
                  #
               
               
               func rewriteBlockAMD64splitload(b *Block) bool
            
            
            
               
                  rewriteBlockARM 
                  function
                  
                  #
               
               
               func rewriteBlockARM(b *Block) bool
            
            
            
               
                  rewriteBlockARM64 
                  function
                  
                  #
               
               
               func rewriteBlockARM64(b *Block) bool
            
            
            
               
                  rewriteBlockARM64latelower 
                  function
                  
                  #
               
               
               func rewriteBlockARM64latelower(b *Block) bool
            
            
            
               
                  rewriteBlockLOONG64 
                  function
                  
                  #
               
               
               func rewriteBlockLOONG64(b *Block) bool
            
            
            
               
                  rewriteBlockMIPS 
                  function
                  
                  #
               
               
               func rewriteBlockMIPS(b *Block) bool
            
            
            
               
                  rewriteBlockMIPS64 
                  function
                  
                  #
               
               
               func rewriteBlockMIPS64(b *Block) bool
            
            
            
               
                  rewriteBlockPPC64 
                  function
                  
                  #
               
               
               func rewriteBlockPPC64(b *Block) bool
            
            
            
               
                  rewriteBlockPPC64latelower 
                  function
                  
                  #
               
               
               func rewriteBlockPPC64latelower(b *Block) bool
            
            
            
               
                  rewriteBlockRISCV64 
                  function
                  
                  #
               
               
               func rewriteBlockRISCV64(b *Block) bool
            
            
            
               
                  rewriteBlockRISCV64latelower 
                  function
                  
                  #
               
               
               func rewriteBlockRISCV64latelower(b *Block) bool
            
            
            
               
                  rewriteBlockS390X 
                  function
                  
                  #
               
               
               func rewriteBlockS390X(b *Block) bool
            
            
            
               
                  rewriteBlockWasm 
                  function
                  
                  #
               
               
               func rewriteBlockWasm(b *Block) bool
            
            
            
               
                  rewriteBlockdec 
                  function
                  
                  #
               
               
               func rewriteBlockdec(b *Block) bool
            
            
            
               
                  rewriteBlockdec64 
                  function
                  
                  #
               
               
               func rewriteBlockdec64(b *Block) bool
            
            
            
               
                  rewriteBlockgeneric 
                  function
                  
                  #
               
               
               func rewriteBlockgeneric(b *Block) bool
            
            
            
               
                  rewriteCallArgs 
                  method
                  
                  #
               
               
               func (x *expandState) rewriteCallArgs(v *Value, firstArg int)
            
            
            
               
                  rewriteFuncResults 
                  method
                  
                  #
               
               
               func (x *expandState) rewriteFuncResults(v *Value, b *Block, aux *AuxCall)
            
            
            
               
                  rewriteHash 
                  method
                  
                  #
               
               
               rewriteHash returns a hash of f suitable for detecting rewrite cycles.
               
               func (f *Func) rewriteHash() string
            
            
            
               
                  rewriteNewPhis 
                  function
                  
                  #
               
               
               rewriteNewPhis updates newphis[h] to record all places where the new phi function inserted
in block h will replace a previous definition.  Block b is the block currently being processed;
if b has its own phi definition then it takes the place of h.
defsForUses provides information about other definitions of the variable that are present
(and if nil, indicates that the variable is no longer live)
sdom must yield a preorder of the flow graph if recursively walked, root-to-children.
The result of newSparseOrderedTree with order supplied by a dfs-postorder satisfies this
requirement.
               
               func rewriteNewPhis(h *Block, b *Block, f *Func, defsForUses []*Value, newphis map[*Block]rewrite, dfPhiTargets map[rewriteTarget]bool, sdom SparseTree)
            
            
            
               
                  rewriteSelectOrArg 
                  method
                  
                  #
               
               
               Convert scalar OpArg into the proper OpWhateverArg instruction
Convert scalar OpSelectN into perhaps-differently-indexed OpSelectN
Convert aggregate OpArg into Make of its parts (which are eventually scalars)
Convert aggregate OpSelectN into Make of its parts (which are eventually scalars)
Returns the converted value.
- "pos" the position for any generated instructions
- "b" the block for any generated instructions
- "container" the outermost OpArg/OpSelectN
- "a" the instruction to overwrite, if any (only the outermost caller)
- "m0" the memory arg for any loads that are necessary
- "at" the type of the Arg/part
- "rc" the register/memory cursor locating the various parts of the Arg.
               
               func (x *expandState) rewriteSelectOrArg(pos src.XPos, b *Block, container *Value, a *Value, m0 *Value, at *types.Type, rc registerCursor) *Value
            
            
            
               
                  rewriteStructLoad 
                  function
                  
                  #
               
               
               func rewriteStructLoad(v *Value) *Value
            
            
            
               
                  rewriteStructStore 
                  function
                  
                  #
               
               
               func rewriteStructStore(v *Value) *Value
            
            
            
               
                  rewriteValue386 
                  function
                  
                  #
               
               
               func rewriteValue386(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386ADCL 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386ADCL(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386ADDL 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386ADDL(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386ADDLcarry 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386ADDLcarry(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386ADDLconst 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386ADDLconst(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386ADDLconstmodify 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386ADDLconstmodify(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386ADDLload 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386ADDLload(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386ADDLmodify 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386ADDLmodify(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386ADDSD 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386ADDSD(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386ADDSDload 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386ADDSDload(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386ADDSS 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386ADDSS(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386ADDSSload 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386ADDSSload(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386ANDL 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386ANDL(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386ANDLconst 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386ANDLconst(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386ANDLconstmodify 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386ANDLconstmodify(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386ANDLload 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386ANDLload(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386ANDLmodify 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386ANDLmodify(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386CMPB 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386CMPB(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386CMPBconst 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386CMPBconst(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386CMPBload 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386CMPBload(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386CMPL 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386CMPL(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386CMPLconst 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386CMPLconst(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386CMPLload 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386CMPLload(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386CMPW 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386CMPW(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386CMPWconst 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386CMPWconst(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386CMPWload 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386CMPWload(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386DIVSD 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386DIVSD(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386DIVSDload 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386DIVSDload(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386DIVSS 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386DIVSS(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386DIVSSload 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386DIVSSload(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386LEAL 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386LEAL(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386LEAL1 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386LEAL1(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386LEAL2 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386LEAL2(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386LEAL4 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386LEAL4(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386LEAL8 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386LEAL8(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386MOVBLSX 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386MOVBLSX(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386MOVBLSXload 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386MOVBLSXload(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386MOVBLZX 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386MOVBLZX(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386MOVBload 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386MOVBload(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386MOVBstore 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386MOVBstore(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386MOVBstoreconst 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386MOVBstoreconst(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386MOVLload 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386MOVLload(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386MOVLstore 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386MOVLstore(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386MOVLstoreconst 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386MOVLstoreconst(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386MOVSDconst 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386MOVSDconst(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386MOVSDload 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386MOVSDload(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386MOVSDstore 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386MOVSDstore(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386MOVSSconst 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386MOVSSconst(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386MOVSSload 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386MOVSSload(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386MOVSSstore 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386MOVSSstore(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386MOVWLSX 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386MOVWLSX(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386MOVWLSXload 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386MOVWLSXload(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386MOVWLZX 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386MOVWLZX(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386MOVWload 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386MOVWload(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386MOVWstore 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386MOVWstore(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386MOVWstoreconst 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386MOVWstoreconst(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386MULL 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386MULL(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386MULLconst 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386MULLconst(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386MULLload 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386MULLload(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386MULSD 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386MULSD(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386MULSDload 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386MULSDload(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386MULSS 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386MULSS(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386MULSSload 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386MULSSload(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386NEGL 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386NEGL(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386NOTL 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386NOTL(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386ORL 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386ORL(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386ORLconst 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386ORLconst(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386ORLconstmodify 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386ORLconstmodify(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386ORLload 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386ORLload(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386ORLmodify 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386ORLmodify(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386ROLB 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386ROLB(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386ROLBconst 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386ROLBconst(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386ROLL 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386ROLL(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386ROLLconst 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386ROLLconst(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386ROLW 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386ROLW(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386ROLWconst 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386ROLWconst(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386SARB 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386SARB(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386SARBconst 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386SARBconst(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386SARL 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386SARL(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386SARLconst 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386SARLconst(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386SARW 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386SARW(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386SARWconst 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386SARWconst(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386SBBL 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386SBBL(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386SBBLcarrymask 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386SBBLcarrymask(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386SETA 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386SETA(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386SETAE 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386SETAE(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386SETB 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386SETB(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386SETBE 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386SETBE(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386SETEQ 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386SETEQ(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386SETG 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386SETG(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386SETGE 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386SETGE(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386SETL 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386SETL(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386SETLE 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386SETLE(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386SETNE 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386SETNE(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386SHLL 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386SHLL(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386SHLLconst 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386SHLLconst(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386SHRB 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386SHRB(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386SHRBconst 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386SHRBconst(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386SHRL 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386SHRL(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386SHRLconst 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386SHRLconst(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386SHRW 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386SHRW(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386SHRWconst 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386SHRWconst(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386SUBL 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386SUBL(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386SUBLcarry 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386SUBLcarry(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386SUBLconst 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386SUBLconst(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386SUBLload 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386SUBLload(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386SUBLmodify 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386SUBLmodify(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386SUBSD 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386SUBSD(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386SUBSDload 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386SUBSDload(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386SUBSS 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386SUBSS(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386SUBSSload 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386SUBSSload(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386XORL 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386XORL(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386XORLconst 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386XORLconst(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386XORLconstmodify 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386XORLconstmodify(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386XORLload 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386XORLload(v *Value) bool
            
            
            
               
                  rewriteValue386_Op386XORLmodify 
                  function
                  
                  #
               
               
               func rewriteValue386_Op386XORLmodify(v *Value) bool
            
            
            
               
                  rewriteValue386_OpAddr 
                  function
                  
                  #
               
               
               func rewriteValue386_OpAddr(v *Value) bool
            
            
            
               
                  rewriteValue386_OpBswap16 
                  function
                  
                  #
               
               
               func rewriteValue386_OpBswap16(v *Value) bool
            
            
            
               
                  rewriteValue386_OpConst16 
                  function
                  
                  #
               
               
               func rewriteValue386_OpConst16(v *Value) bool
            
            
            
               
                  rewriteValue386_OpConst8 
                  function
                  
                  #
               
               
               func rewriteValue386_OpConst8(v *Value) bool
            
            
            
               
                  rewriteValue386_OpConstBool 
                  function
                  
                  #
               
               
               func rewriteValue386_OpConstBool(v *Value) bool
            
            
            
               
                  rewriteValue386_OpConstNil 
                  function
                  
                  #
               
               
               func rewriteValue386_OpConstNil(v *Value) bool
            
            
            
               
                  rewriteValue386_OpCtz16 
                  function
                  
                  #
               
               
               func rewriteValue386_OpCtz16(v *Value) bool
            
            
            
               
                  rewriteValue386_OpCtz8 
                  function
                  
                  #
               
               
               func rewriteValue386_OpCtz8(v *Value) bool
            
            
            
               
                  rewriteValue386_OpDiv8 
                  function
                  
                  #
               
               
               func rewriteValue386_OpDiv8(v *Value) bool
            
            
            
               
                  rewriteValue386_OpDiv8u 
                  function
                  
                  #
               
               
               func rewriteValue386_OpDiv8u(v *Value) bool
            
            
            
               
                  rewriteValue386_OpEq16 
                  function
                  
                  #
               
               
               func rewriteValue386_OpEq16(v *Value) bool
            
            
            
               
                  rewriteValue386_OpEq32 
                  function
                  
                  #
               
               
               func rewriteValue386_OpEq32(v *Value) bool
            
            
            
               
                  rewriteValue386_OpEq32F 
                  function
                  
                  #
               
               
               func rewriteValue386_OpEq32F(v *Value) bool
            
            
            
               
                  rewriteValue386_OpEq64F 
                  function
                  
                  #
               
               
               func rewriteValue386_OpEq64F(v *Value) bool
            
            
            
               
                  rewriteValue386_OpEq8 
                  function
                  
                  #
               
               
               func rewriteValue386_OpEq8(v *Value) bool
            
            
            
               
                  rewriteValue386_OpEqB 
                  function
                  
                  #
               
               
               func rewriteValue386_OpEqB(v *Value) bool
            
            
            
               
                  rewriteValue386_OpEqPtr 
                  function
                  
                  #
               
               
               func rewriteValue386_OpEqPtr(v *Value) bool
            
            
            
               
                  rewriteValue386_OpIsInBounds 
                  function
                  
                  #
               
               
               func rewriteValue386_OpIsInBounds(v *Value) bool
            
            
            
               
                  rewriteValue386_OpIsNonNil 
                  function
                  
                  #
               
               
               func rewriteValue386_OpIsNonNil(v *Value) bool
            
            
            
               
                  rewriteValue386_OpIsSliceInBounds 
                  function
                  
                  #
               
               
               func rewriteValue386_OpIsSliceInBounds(v *Value) bool
            
            
            
               
                  rewriteValue386_OpLeq16 
                  function
                  
                  #
               
               
               func rewriteValue386_OpLeq16(v *Value) bool
            
            
            
               
                  rewriteValue386_OpLeq16U 
                  function
                  
                  #
               
               
               func rewriteValue386_OpLeq16U(v *Value) bool
            
            
            
               
                  rewriteValue386_OpLeq32 
                  function
                  
                  #
               
               
               func rewriteValue386_OpLeq32(v *Value) bool
            
            
            
               
                  rewriteValue386_OpLeq32F 
                  function
                  
                  #
               
               
               func rewriteValue386_OpLeq32F(v *Value) bool
            
            
            
               
                  rewriteValue386_OpLeq32U 
                  function
                  
                  #
               
               
               func rewriteValue386_OpLeq32U(v *Value) bool
            
            
            
               
                  rewriteValue386_OpLeq64F 
                  function
                  
                  #
               
               
               func rewriteValue386_OpLeq64F(v *Value) bool
            
            
            
               
                  rewriteValue386_OpLeq8 
                  function
                  
                  #
               
               
               func rewriteValue386_OpLeq8(v *Value) bool
            
            
            
               
                  rewriteValue386_OpLeq8U 
                  function
                  
                  #
               
               
               func rewriteValue386_OpLeq8U(v *Value) bool
            
            
            
               
                  rewriteValue386_OpLess16 
                  function
                  
                  #
               
               
               func rewriteValue386_OpLess16(v *Value) bool
            
            
            
               
                  rewriteValue386_OpLess16U 
                  function
                  
                  #
               
               
               func rewriteValue386_OpLess16U(v *Value) bool
            
            
            
               
                  rewriteValue386_OpLess32 
                  function
                  
                  #
               
               
               func rewriteValue386_OpLess32(v *Value) bool
            
            
            
               
                  rewriteValue386_OpLess32F 
                  function
                  
                  #
               
               
               func rewriteValue386_OpLess32F(v *Value) bool
            
            
            
               
                  rewriteValue386_OpLess32U 
                  function
                  
                  #
               
               
               func rewriteValue386_OpLess32U(v *Value) bool
            
            
            
               
                  rewriteValue386_OpLess64F 
                  function
                  
                  #
               
               
               func rewriteValue386_OpLess64F(v *Value) bool
            
            
            
               
                  rewriteValue386_OpLess8 
                  function
                  
                  #
               
               
               func rewriteValue386_OpLess8(v *Value) bool
            
            
            
               
                  rewriteValue386_OpLess8U 
                  function
                  
                  #
               
               
               func rewriteValue386_OpLess8U(v *Value) bool
            
            
            
               
                  rewriteValue386_OpLoad 
                  function
                  
                  #
               
               
               func rewriteValue386_OpLoad(v *Value) bool
            
            
            
               
                  rewriteValue386_OpLocalAddr 
                  function
                  
                  #
               
               
               func rewriteValue386_OpLocalAddr(v *Value) bool
            
            
            
               
                  rewriteValue386_OpLsh16x16 
                  function
                  
                  #
               
               
               func rewriteValue386_OpLsh16x16(v *Value) bool
            
            
            
               
                  rewriteValue386_OpLsh16x32 
                  function
                  
                  #
               
               
               func rewriteValue386_OpLsh16x32(v *Value) bool
            
            
            
               
                  rewriteValue386_OpLsh16x64 
                  function
                  
                  #
               
               
               func rewriteValue386_OpLsh16x64(v *Value) bool
            
            
            
               
                  rewriteValue386_OpLsh16x8 
                  function
                  
                  #
               
               
               func rewriteValue386_OpLsh16x8(v *Value) bool
            
            
            
               
                  rewriteValue386_OpLsh32x16 
                  function
                  
                  #
               
               
               func rewriteValue386_OpLsh32x16(v *Value) bool
            
            
            
               
                  rewriteValue386_OpLsh32x32 
                  function
                  
                  #
               
               
               func rewriteValue386_OpLsh32x32(v *Value) bool
            
            
            
               
                  rewriteValue386_OpLsh32x64 
                  function
                  
                  #
               
               
               func rewriteValue386_OpLsh32x64(v *Value) bool
            
            
            
               
                  rewriteValue386_OpLsh32x8 
                  function
                  
                  #
               
               
               func rewriteValue386_OpLsh32x8(v *Value) bool
            
            
            
               
                  rewriteValue386_OpLsh8x16 
                  function
                  
                  #
               
               
               func rewriteValue386_OpLsh8x16(v *Value) bool
            
            
            
               
                  rewriteValue386_OpLsh8x32 
                  function
                  
                  #
               
               
               func rewriteValue386_OpLsh8x32(v *Value) bool
            
            
            
               
                  rewriteValue386_OpLsh8x64 
                  function
                  
                  #
               
               
               func rewriteValue386_OpLsh8x64(v *Value) bool
            
            
            
               
                  rewriteValue386_OpLsh8x8 
                  function
                  
                  #
               
               
               func rewriteValue386_OpLsh8x8(v *Value) bool
            
            
            
               
                  rewriteValue386_OpMod8 
                  function
                  
                  #
               
               
               func rewriteValue386_OpMod8(v *Value) bool
            
            
            
               
                  rewriteValue386_OpMod8u 
                  function
                  
                  #
               
               
               func rewriteValue386_OpMod8u(v *Value) bool
            
            
            
               
                  rewriteValue386_OpMove 
                  function
                  
                  #
               
               
               func rewriteValue386_OpMove(v *Value) bool
            
            
            
               
                  rewriteValue386_OpNeg32F 
                  function
                  
                  #
               
               
               func rewriteValue386_OpNeg32F(v *Value) bool
            
            
            
               
                  rewriteValue386_OpNeg64F 
                  function
                  
                  #
               
               
               func rewriteValue386_OpNeg64F(v *Value) bool
            
            
            
               
                  rewriteValue386_OpNeq16 
                  function
                  
                  #
               
               
               func rewriteValue386_OpNeq16(v *Value) bool
            
            
            
               
                  rewriteValue386_OpNeq32 
                  function
                  
                  #
               
               
               func rewriteValue386_OpNeq32(v *Value) bool
            
            
            
               
                  rewriteValue386_OpNeq32F 
                  function
                  
                  #
               
               
               func rewriteValue386_OpNeq32F(v *Value) bool
            
            
            
               
                  rewriteValue386_OpNeq64F 
                  function
                  
                  #
               
               
               func rewriteValue386_OpNeq64F(v *Value) bool
            
            
            
               
                  rewriteValue386_OpNeq8 
                  function
                  
                  #
               
               
               func rewriteValue386_OpNeq8(v *Value) bool
            
            
            
               
                  rewriteValue386_OpNeqB 
                  function
                  
                  #
               
               
               func rewriteValue386_OpNeqB(v *Value) bool
            
            
            
               
                  rewriteValue386_OpNeqPtr 
                  function
                  
                  #
               
               
               func rewriteValue386_OpNeqPtr(v *Value) bool
            
            
            
               
                  rewriteValue386_OpNot 
                  function
                  
                  #
               
               
               func rewriteValue386_OpNot(v *Value) bool
            
            
            
               
                  rewriteValue386_OpOffPtr 
                  function
                  
                  #
               
               
               func rewriteValue386_OpOffPtr(v *Value) bool
            
            
            
               
                  rewriteValue386_OpPanicBounds 
                  function
                  
                  #
               
               
               func rewriteValue386_OpPanicBounds(v *Value) bool
            
            
            
               
                  rewriteValue386_OpPanicExtend 
                  function
                  
                  #
               
               
               func rewriteValue386_OpPanicExtend(v *Value) bool
            
            
            
               
                  rewriteValue386_OpRsh16Ux16 
                  function
                  
                  #
               
               
               func rewriteValue386_OpRsh16Ux16(v *Value) bool
            
            
            
               
                  rewriteValue386_OpRsh16Ux32 
                  function
                  
                  #
               
               
               func rewriteValue386_OpRsh16Ux32(v *Value) bool
            
            
            
               
                  rewriteValue386_OpRsh16Ux64 
                  function
                  
                  #
               
               
               func rewriteValue386_OpRsh16Ux64(v *Value) bool
            
            
            
               
                  rewriteValue386_OpRsh16Ux8 
                  function
                  
                  #
               
               
               func rewriteValue386_OpRsh16Ux8(v *Value) bool
            
            
            
               
                  rewriteValue386_OpRsh16x16 
                  function
                  
                  #
               
               
               func rewriteValue386_OpRsh16x16(v *Value) bool
            
            
            
               
                  rewriteValue386_OpRsh16x32 
                  function
                  
                  #
               
               
               func rewriteValue386_OpRsh16x32(v *Value) bool
            
            
            
               
                  rewriteValue386_OpRsh16x64 
                  function
                  
                  #
               
               
               func rewriteValue386_OpRsh16x64(v *Value) bool
            
            
            
               
                  rewriteValue386_OpRsh16x8 
                  function
                  
                  #
               
               
               func rewriteValue386_OpRsh16x8(v *Value) bool
            
            
            
               
                  rewriteValue386_OpRsh32Ux16 
                  function
                  
                  #
               
               
               func rewriteValue386_OpRsh32Ux16(v *Value) bool
            
            
            
               
                  rewriteValue386_OpRsh32Ux32 
                  function
                  
                  #
               
               
               func rewriteValue386_OpRsh32Ux32(v *Value) bool
            
            
            
               
                  rewriteValue386_OpRsh32Ux64 
                  function
                  
                  #
               
               
               func rewriteValue386_OpRsh32Ux64(v *Value) bool
            
            
            
               
                  rewriteValue386_OpRsh32Ux8 
                  function
                  
                  #
               
               
               func rewriteValue386_OpRsh32Ux8(v *Value) bool
            
            
            
               
                  rewriteValue386_OpRsh32x16 
                  function
                  
                  #
               
               
               func rewriteValue386_OpRsh32x16(v *Value) bool
            
            
            
               
                  rewriteValue386_OpRsh32x32 
                  function
                  
                  #
               
               
               func rewriteValue386_OpRsh32x32(v *Value) bool
            
            
            
               
                  rewriteValue386_OpRsh32x64 
                  function
                  
                  #
               
               
               func rewriteValue386_OpRsh32x64(v *Value) bool
            
            
            
               
                  rewriteValue386_OpRsh32x8 
                  function
                  
                  #
               
               
               func rewriteValue386_OpRsh32x8(v *Value) bool
            
            
            
               
                  rewriteValue386_OpRsh8Ux16 
                  function
                  
                  #
               
               
               func rewriteValue386_OpRsh8Ux16(v *Value) bool
            
            
            
               
                  rewriteValue386_OpRsh8Ux32 
                  function
                  
                  #
               
               
               func rewriteValue386_OpRsh8Ux32(v *Value) bool
            
            
            
               
                  rewriteValue386_OpRsh8Ux64 
                  function
                  
                  #
               
               
               func rewriteValue386_OpRsh8Ux64(v *Value) bool
            
            
            
               
                  rewriteValue386_OpRsh8Ux8 
                  function
                  
                  #
               
               
               func rewriteValue386_OpRsh8Ux8(v *Value) bool
            
            
            
               
                  rewriteValue386_OpRsh8x16 
                  function
                  
                  #
               
               
               func rewriteValue386_OpRsh8x16(v *Value) bool
            
            
            
               
                  rewriteValue386_OpRsh8x32 
                  function
                  
                  #
               
               
               func rewriteValue386_OpRsh8x32(v *Value) bool
            
            
            
               
                  rewriteValue386_OpRsh8x64 
                  function
                  
                  #
               
               
               func rewriteValue386_OpRsh8x64(v *Value) bool
            
            
            
               
                  rewriteValue386_OpRsh8x8 
                  function
                  
                  #
               
               
               func rewriteValue386_OpRsh8x8(v *Value) bool
            
            
            
               
                  rewriteValue386_OpSelect0 
                  function
                  
                  #
               
               
               func rewriteValue386_OpSelect0(v *Value) bool
            
            
            
               
                  rewriteValue386_OpSelect1 
                  function
                  
                  #
               
               
               func rewriteValue386_OpSelect1(v *Value) bool
            
            
            
               
                  rewriteValue386_OpSignmask 
                  function
                  
                  #
               
               
               func rewriteValue386_OpSignmask(v *Value) bool
            
            
            
               
                  rewriteValue386_OpSlicemask 
                  function
                  
                  #
               
               
               func rewriteValue386_OpSlicemask(v *Value) bool
            
            
            
               
                  rewriteValue386_OpStore 
                  function
                  
                  #
               
               
               func rewriteValue386_OpStore(v *Value) bool
            
            
            
               
                  rewriteValue386_OpZero 
                  function
                  
                  #
               
               
               func rewriteValue386_OpZero(v *Value) bool
            
            
            
               
                  rewriteValue386_OpZeromask 
                  function
                  
                  #
               
               
               func rewriteValue386_OpZeromask(v *Value) bool
            
            
            
               
                  rewriteValue386splitload 
                  function
                  
                  #
               
               
               func rewriteValue386splitload(v *Value) bool
            
            
            
               
                  rewriteValue386splitload_Op386CMPBconstload 
                  function
                  
                  #
               
               
               func rewriteValue386splitload_Op386CMPBconstload(v *Value) bool
            
            
            
               
                  rewriteValue386splitload_Op386CMPBload 
                  function
                  
                  #
               
               
               func rewriteValue386splitload_Op386CMPBload(v *Value) bool
            
            
            
               
                  rewriteValue386splitload_Op386CMPLconstload 
                  function
                  
                  #
               
               
               func rewriteValue386splitload_Op386CMPLconstload(v *Value) bool
            
            
            
               
                  rewriteValue386splitload_Op386CMPLload 
                  function
                  
                  #
               
               
               func rewriteValue386splitload_Op386CMPLload(v *Value) bool
            
            
            
               
                  rewriteValue386splitload_Op386CMPWconstload 
                  function
                  
                  #
               
               
               func rewriteValue386splitload_Op386CMPWconstload(v *Value) bool
            
            
            
               
                  rewriteValue386splitload_Op386CMPWload 
                  function
                  
                  #
               
               
               func rewriteValue386splitload_Op386CMPWload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64 
                  function
                  
                  #
               
               
               func rewriteValueAMD64(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64ADCQ 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64ADCQ(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64ADCQconst 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64ADCQconst(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64ADDL 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64ADDL(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64ADDLconst 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64ADDLconst(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64ADDLconstmodify 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64ADDLconstmodify(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64ADDLload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64ADDLload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64ADDLmodify 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64ADDLmodify(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64ADDQ 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64ADDQ(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64ADDQcarry 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64ADDQcarry(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64ADDQconst 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64ADDQconst(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64ADDQconstmodify 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64ADDQconstmodify(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64ADDQload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64ADDQload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64ADDQmodify 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64ADDQmodify(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64ADDSD 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64ADDSD(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64ADDSDload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64ADDSDload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64ADDSS 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64ADDSS(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64ADDSSload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64ADDSSload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64ANDL 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64ANDL(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64ANDLconst 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64ANDLconst(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64ANDLconstmodify 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64ANDLconstmodify(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64ANDLload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64ANDLload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64ANDLmodify 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64ANDLmodify(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64ANDNL 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64ANDNL(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64ANDNQ 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64ANDNQ(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64ANDQ 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64ANDQ(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64ANDQconst 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64ANDQconst(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64ANDQconstmodify 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64ANDQconstmodify(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64ANDQload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64ANDQload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64ANDQmodify 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64ANDQmodify(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64BSFQ 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64BSFQ(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64BSWAPL 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64BSWAPL(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64BSWAPQ 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64BSWAPQ(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64BTCQconst 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64BTCQconst(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64BTLconst 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64BTLconst(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64BTQconst 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64BTQconst(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64BTRQconst 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64BTRQconst(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64BTSQconst 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64BTSQconst(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64CMOVLCC 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64CMOVLCC(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64CMOVLCS 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64CMOVLCS(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64CMOVLEQ 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64CMOVLEQ(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64CMOVLGE 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64CMOVLGE(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64CMOVLGT 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64CMOVLGT(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64CMOVLHI 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64CMOVLHI(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64CMOVLLE 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64CMOVLLE(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64CMOVLLS 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64CMOVLLS(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64CMOVLLT 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64CMOVLLT(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64CMOVLNE 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64CMOVLNE(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64CMOVQCC 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64CMOVQCC(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64CMOVQCS 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64CMOVQCS(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64CMOVQEQ 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64CMOVQEQ(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64CMOVQGE 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64CMOVQGE(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64CMOVQGT 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64CMOVQGT(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64CMOVQHI 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64CMOVQHI(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64CMOVQLE 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64CMOVQLE(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64CMOVQLS 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64CMOVQLS(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64CMOVQLT 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64CMOVQLT(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64CMOVQNE 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64CMOVQNE(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64CMOVWCC 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64CMOVWCC(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64CMOVWCS 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64CMOVWCS(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64CMOVWEQ 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64CMOVWEQ(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64CMOVWGE 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64CMOVWGE(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64CMOVWGT 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64CMOVWGT(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64CMOVWHI 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64CMOVWHI(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64CMOVWLE 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64CMOVWLE(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64CMOVWLS 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64CMOVWLS(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64CMOVWLT 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64CMOVWLT(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64CMOVWNE 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64CMOVWNE(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64CMPB 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64CMPB(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64CMPBconst 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64CMPBconst(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64CMPBconstload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64CMPBconstload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64CMPBload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64CMPBload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64CMPL 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64CMPL(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64CMPLconst 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64CMPLconst(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64CMPLconstload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64CMPLconstload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64CMPLload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64CMPLload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64CMPQ 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64CMPQ(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64CMPQconst 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64CMPQconst(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64CMPQconstload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64CMPQconstload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64CMPQload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64CMPQload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64CMPW 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64CMPW(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64CMPWconst 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64CMPWconst(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64CMPWconstload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64CMPWconstload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64CMPWload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64CMPWload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64CMPXCHGLlock 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64CMPXCHGLlock(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64CMPXCHGQlock 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64CMPXCHGQlock(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64DIVSD 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64DIVSD(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64DIVSDload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64DIVSDload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64DIVSS 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64DIVSS(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64DIVSSload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64DIVSSload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64HMULL 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64HMULL(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64HMULLU 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64HMULLU(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64HMULQ 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64HMULQ(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64HMULQU 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64HMULQU(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64LEAL 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64LEAL(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64LEAL1 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64LEAL1(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64LEAL2 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64LEAL2(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64LEAL4 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64LEAL4(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64LEAL8 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64LEAL8(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64LEAQ 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64LEAQ(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64LEAQ1 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64LEAQ1(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64LEAQ2 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64LEAQ2(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64LEAQ4 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64LEAQ4(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64LEAQ8 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64LEAQ8(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64MOVBELstore 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64MOVBELstore(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64MOVBEQstore 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64MOVBEQstore(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64MOVBEWstore 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64MOVBEWstore(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64MOVBQSX 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64MOVBQSX(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64MOVBQSXload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64MOVBQSXload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64MOVBQZX 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64MOVBQZX(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64MOVBatomicload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64MOVBatomicload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64MOVBload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64MOVBload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64MOVBstore 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64MOVBstore(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64MOVBstoreconst 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64MOVBstoreconst(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64MOVLQSX 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64MOVLQSX(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64MOVLQSXload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64MOVLQSXload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64MOVLQZX 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64MOVLQZX(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64MOVLatomicload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64MOVLatomicload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64MOVLf2i 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64MOVLf2i(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64MOVLi2f 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64MOVLi2f(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64MOVLload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64MOVLload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64MOVLstore 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64MOVLstore(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64MOVLstoreconst 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64MOVLstoreconst(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64MOVOload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64MOVOload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64MOVOstore 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64MOVOstore(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64MOVOstoreconst 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64MOVOstoreconst(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64MOVQatomicload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64MOVQatomicload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64MOVQf2i 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64MOVQf2i(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64MOVQi2f 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64MOVQi2f(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64MOVQload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64MOVQload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64MOVQstore 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64MOVQstore(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64MOVQstoreconst 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64MOVQstoreconst(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64MOVSDload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64MOVSDload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64MOVSDstore 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64MOVSDstore(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64MOVSSload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64MOVSSload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64MOVSSstore 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64MOVSSstore(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64MOVWQSX 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64MOVWQSX(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64MOVWQSXload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64MOVWQSXload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64MOVWQZX 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64MOVWQZX(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64MOVWload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64MOVWload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64MOVWstore 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64MOVWstore(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64MOVWstoreconst 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64MOVWstoreconst(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64MULL 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64MULL(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64MULLconst 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64MULLconst(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64MULQ 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64MULQ(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64MULQconst 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64MULQconst(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64MULSD 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64MULSD(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64MULSDload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64MULSDload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64MULSS 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64MULSS(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64MULSSload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64MULSSload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64NEGL 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64NEGL(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64NEGQ 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64NEGQ(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64NOTL 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64NOTL(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64NOTQ 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64NOTQ(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64ORL 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64ORL(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64ORLconst 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64ORLconst(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64ORLconstmodify 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64ORLconstmodify(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64ORLload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64ORLload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64ORLmodify 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64ORLmodify(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64ORQ 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64ORQ(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64ORQconst 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64ORQconst(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64ORQconstmodify 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64ORQconstmodify(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64ORQload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64ORQload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64ORQmodify 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64ORQmodify(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64ROLB 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64ROLB(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64ROLBconst 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64ROLBconst(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64ROLL 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64ROLL(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64ROLLconst 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64ROLLconst(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64ROLQ 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64ROLQ(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64ROLQconst 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64ROLQconst(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64ROLW 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64ROLW(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64ROLWconst 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64ROLWconst(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64RORB 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64RORB(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64RORL 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64RORL(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64RORQ 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64RORQ(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64RORW 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64RORW(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SARB 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SARB(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SARBconst 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SARBconst(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SARL 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SARL(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SARLconst 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SARLconst(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SARQ 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SARQ(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SARQconst 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SARQconst(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SARW 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SARW(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SARWconst 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SARWconst(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SARXLload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SARXLload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SARXQload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SARXQload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SBBLcarrymask 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SBBLcarrymask(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SBBQ 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SBBQ(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SBBQcarrymask 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SBBQcarrymask(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SBBQconst 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SBBQconst(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SETA 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SETA(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SETAE 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SETAE(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SETAEstore 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SETAEstore(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SETAstore 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SETAstore(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SETB 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SETB(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SETBE 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SETBE(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SETBEstore 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SETBEstore(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SETBstore 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SETBstore(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SETEQ 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SETEQ(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SETEQstore 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SETEQstore(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SETG 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SETG(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SETGE 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SETGE(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SETGEstore 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SETGEstore(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SETGstore 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SETGstore(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SETL 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SETL(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SETLE 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SETLE(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SETLEstore 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SETLEstore(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SETLstore 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SETLstore(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SETNE 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SETNE(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SETNEstore 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SETNEstore(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SHLL 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SHLL(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SHLLconst 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SHLLconst(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SHLQ 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SHLQ(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SHLQconst 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SHLQconst(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SHLXLload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SHLXLload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SHLXQload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SHLXQload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SHRB 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SHRB(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SHRBconst 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SHRBconst(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SHRL 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SHRL(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SHRLconst 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SHRLconst(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SHRQ 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SHRQ(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SHRQconst 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SHRQconst(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SHRW 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SHRW(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SHRWconst 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SHRWconst(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SHRXLload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SHRXLload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SHRXQload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SHRXQload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SUBL 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SUBL(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SUBLconst 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SUBLconst(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SUBLload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SUBLload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SUBLmodify 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SUBLmodify(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SUBQ 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SUBQ(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SUBQborrow 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SUBQborrow(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SUBQconst 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SUBQconst(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SUBQload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SUBQload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SUBQmodify 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SUBQmodify(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SUBSD 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SUBSD(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SUBSDload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SUBSDload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SUBSS 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SUBSS(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64SUBSSload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64SUBSSload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64TESTB 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64TESTB(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64TESTBconst 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64TESTBconst(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64TESTL 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64TESTL(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64TESTLconst 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64TESTLconst(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64TESTQ 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64TESTQ(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64TESTQconst 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64TESTQconst(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64TESTW 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64TESTW(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64TESTWconst 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64TESTWconst(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64XADDLlock 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64XADDLlock(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64XADDQlock 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64XADDQlock(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64XCHGL 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64XCHGL(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64XCHGQ 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64XCHGQ(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64XORL 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64XORL(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64XORLconst 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64XORLconst(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64XORLconstmodify 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64XORLconstmodify(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64XORLload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64XORLload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64XORLmodify 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64XORLmodify(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64XORQ 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64XORQ(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64XORQconst 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64XORQconst(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64XORQconstmodify 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64XORQconstmodify(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64XORQload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64XORQload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAMD64XORQmodify 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAMD64XORQmodify(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAddr 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAddr(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAtomicAdd32 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAtomicAdd32(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAtomicAdd64 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAtomicAdd64(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAtomicAnd32 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAtomicAnd32(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAtomicAnd32value 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAtomicAnd32value(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAtomicAnd64value 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAtomicAnd64value(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAtomicAnd8 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAtomicAnd8(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAtomicCompareAndSwap32 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAtomicCompareAndSwap32(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAtomicCompareAndSwap64 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAtomicCompareAndSwap64(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAtomicExchange32 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAtomicExchange32(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAtomicExchange64 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAtomicExchange64(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAtomicExchange8 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAtomicExchange8(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAtomicLoad32 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAtomicLoad32(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAtomicLoad64 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAtomicLoad64(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAtomicLoad8 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAtomicLoad8(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAtomicLoadPtr 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAtomicLoadPtr(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAtomicOr32 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAtomicOr32(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAtomicOr32value 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAtomicOr32value(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAtomicOr64value 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAtomicOr64value(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAtomicOr8 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAtomicOr8(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAtomicStore32 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAtomicStore32(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAtomicStore64 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAtomicStore64(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAtomicStore8 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAtomicStore8(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpAtomicStorePtrNoWB 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpAtomicStorePtrNoWB(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpBitLen16 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpBitLen16(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpBitLen32 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpBitLen32(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpBitLen64 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpBitLen64(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpBitLen8 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpBitLen8(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpBswap16 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpBswap16(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpCeil 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpCeil(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpCondSelect 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpCondSelect(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpConst16 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpConst16(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpConst8 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpConst8(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpConstBool 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpConstBool(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpConstNil 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpConstNil(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpCtz16 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpCtz16(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpCtz16NonZero 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpCtz16NonZero(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpCtz32 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpCtz32(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpCtz32NonZero 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpCtz32NonZero(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpCtz64 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpCtz64(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpCtz64NonZero 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpCtz64NonZero(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpCtz8 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpCtz8(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpCtz8NonZero 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpCtz8NonZero(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpDiv16 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpDiv16(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpDiv16u 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpDiv16u(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpDiv32 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpDiv32(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpDiv32u 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpDiv32u(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpDiv64 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpDiv64(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpDiv64u 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpDiv64u(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpDiv8 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpDiv8(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpDiv8u 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpDiv8u(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpEq16 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpEq16(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpEq32 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpEq32(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpEq32F 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpEq32F(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpEq64 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpEq64(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpEq64F 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpEq64F(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpEq8 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpEq8(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpEqB 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpEqB(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpEqPtr 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpEqPtr(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpFMA 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpFMA(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpFloor 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpFloor(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpGetG 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpGetG(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpHasCPUFeature 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpHasCPUFeature(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpIsInBounds 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpIsInBounds(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpIsNonNil 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpIsNonNil(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpIsSliceInBounds 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpIsSliceInBounds(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpLeq16 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpLeq16(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpLeq16U 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpLeq16U(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpLeq32 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpLeq32(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpLeq32F 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpLeq32F(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpLeq32U 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpLeq32U(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpLeq64 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpLeq64(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpLeq64F 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpLeq64F(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpLeq64U 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpLeq64U(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpLeq8 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpLeq8(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpLeq8U 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpLeq8U(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpLess16 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpLess16(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpLess16U 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpLess16U(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpLess32 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpLess32(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpLess32F 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpLess32F(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpLess32U 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpLess32U(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpLess64 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpLess64(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpLess64F 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpLess64F(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpLess64U 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpLess64U(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpLess8 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpLess8(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpLess8U 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpLess8U(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpLoad 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpLoad(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpLocalAddr 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpLocalAddr(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpLsh16x16 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpLsh16x16(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpLsh16x32 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpLsh16x32(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpLsh16x64 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpLsh16x64(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpLsh16x8 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpLsh16x8(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpLsh32x16 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpLsh32x16(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpLsh32x32 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpLsh32x32(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpLsh32x64 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpLsh32x64(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpLsh32x8 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpLsh32x8(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpLsh64x16 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpLsh64x16(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpLsh64x32 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpLsh64x32(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpLsh64x64 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpLsh64x64(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpLsh64x8 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpLsh64x8(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpLsh8x16 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpLsh8x16(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpLsh8x32 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpLsh8x32(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpLsh8x64 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpLsh8x64(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpLsh8x8 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpLsh8x8(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpMax32F 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpMax32F(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpMax64F 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpMax64F(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpMin32F 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpMin32F(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpMin64F 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpMin64F(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpMod16 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpMod16(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpMod16u 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpMod16u(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpMod32 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpMod32(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpMod32u 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpMod32u(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpMod64 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpMod64(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpMod64u 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpMod64u(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpMod8 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpMod8(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpMod8u 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpMod8u(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpMove 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpMove(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpNeg32F 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpNeg32F(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpNeg64F 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpNeg64F(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpNeq16 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpNeq16(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpNeq32 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpNeq32(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpNeq32F 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpNeq32F(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpNeq64 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpNeq64(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpNeq64F 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpNeq64F(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpNeq8 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpNeq8(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpNeqB 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpNeqB(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpNeqPtr 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpNeqPtr(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpNot 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpNot(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpOffPtr 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpOffPtr(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpPanicBounds 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpPanicBounds(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpPopCount16 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpPopCount16(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpPopCount8 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpPopCount8(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpRoundToEven 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpRoundToEven(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpRsh16Ux16 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpRsh16Ux16(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpRsh16Ux32 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpRsh16Ux32(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpRsh16Ux64 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpRsh16Ux64(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpRsh16Ux8 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpRsh16Ux8(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpRsh16x16 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpRsh16x16(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpRsh16x32 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpRsh16x32(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpRsh16x64 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpRsh16x64(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpRsh16x8 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpRsh16x8(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpRsh32Ux16 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpRsh32Ux16(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpRsh32Ux32 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpRsh32Ux32(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpRsh32Ux64 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpRsh32Ux64(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpRsh32Ux8 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpRsh32Ux8(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpRsh32x16 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpRsh32x16(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpRsh32x32 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpRsh32x32(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpRsh32x64 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpRsh32x64(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpRsh32x8 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpRsh32x8(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpRsh64Ux16 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpRsh64Ux16(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpRsh64Ux32 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpRsh64Ux32(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpRsh64Ux64 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpRsh64Ux64(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpRsh64Ux8 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpRsh64Ux8(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpRsh64x16 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpRsh64x16(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpRsh64x32 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpRsh64x32(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpRsh64x64 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpRsh64x64(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpRsh64x8 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpRsh64x8(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpRsh8Ux16 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpRsh8Ux16(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpRsh8Ux32 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpRsh8Ux32(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpRsh8Ux64 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpRsh8Ux64(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpRsh8Ux8 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpRsh8Ux8(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpRsh8x16 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpRsh8x16(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpRsh8x32 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpRsh8x32(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpRsh8x64 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpRsh8x64(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpRsh8x8 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpRsh8x8(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpSelect0 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpSelect0(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpSelect1 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpSelect1(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpSelectN 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpSelectN(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpSlicemask 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpSlicemask(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpSpectreIndex 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpSpectreIndex(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpSpectreSliceIndex 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpSpectreSliceIndex(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpStore 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpStore(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpTrunc 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpTrunc(v *Value) bool
            
            
            
               
                  rewriteValueAMD64_OpZero 
                  function
                  
                  #
               
               
               func rewriteValueAMD64_OpZero(v *Value) bool
            
            
            
               
                  rewriteValueAMD64latelower 
                  function
                  
                  #
               
               
               func rewriteValueAMD64latelower(v *Value) bool
            
            
            
               
                  rewriteValueAMD64latelower_OpAMD64MOVBQZX 
                  function
                  
                  #
               
               
               func rewriteValueAMD64latelower_OpAMD64MOVBQZX(v *Value) bool
            
            
            
               
                  rewriteValueAMD64latelower_OpAMD64MOVLQZX 
                  function
                  
                  #
               
               
               func rewriteValueAMD64latelower_OpAMD64MOVLQZX(v *Value) bool
            
            
            
               
                  rewriteValueAMD64latelower_OpAMD64MOVWQZX 
                  function
                  
                  #
               
               
               func rewriteValueAMD64latelower_OpAMD64MOVWQZX(v *Value) bool
            
            
            
               
                  rewriteValueAMD64latelower_OpAMD64SARL 
                  function
                  
                  #
               
               
               func rewriteValueAMD64latelower_OpAMD64SARL(v *Value) bool
            
            
            
               
                  rewriteValueAMD64latelower_OpAMD64SARQ 
                  function
                  
                  #
               
               
               func rewriteValueAMD64latelower_OpAMD64SARQ(v *Value) bool
            
            
            
               
                  rewriteValueAMD64latelower_OpAMD64SHLL 
                  function
                  
                  #
               
               
               func rewriteValueAMD64latelower_OpAMD64SHLL(v *Value) bool
            
            
            
               
                  rewriteValueAMD64latelower_OpAMD64SHLQ 
                  function
                  
                  #
               
               
               func rewriteValueAMD64latelower_OpAMD64SHLQ(v *Value) bool
            
            
            
               
                  rewriteValueAMD64latelower_OpAMD64SHRL 
                  function
                  
                  #
               
               
               func rewriteValueAMD64latelower_OpAMD64SHRL(v *Value) bool
            
            
            
               
                  rewriteValueAMD64latelower_OpAMD64SHRQ 
                  function
                  
                  #
               
               
               func rewriteValueAMD64latelower_OpAMD64SHRQ(v *Value) bool
            
            
            
               
                  rewriteValueAMD64splitload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64splitload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64splitload_OpAMD64CMPBconstload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64splitload_OpAMD64CMPBconstload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64splitload_OpAMD64CMPBconstloadidx1 
                  function
                  
                  #
               
               
               func rewriteValueAMD64splitload_OpAMD64CMPBconstloadidx1(v *Value) bool
            
            
            
               
                  rewriteValueAMD64splitload_OpAMD64CMPBload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64splitload_OpAMD64CMPBload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64splitload_OpAMD64CMPBloadidx1 
                  function
                  
                  #
               
               
               func rewriteValueAMD64splitload_OpAMD64CMPBloadidx1(v *Value) bool
            
            
            
               
                  rewriteValueAMD64splitload_OpAMD64CMPLconstload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64splitload_OpAMD64CMPLconstload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64splitload_OpAMD64CMPLconstloadidx1 
                  function
                  
                  #
               
               
               func rewriteValueAMD64splitload_OpAMD64CMPLconstloadidx1(v *Value) bool
            
            
            
               
                  rewriteValueAMD64splitload_OpAMD64CMPLconstloadidx4 
                  function
                  
                  #
               
               
               func rewriteValueAMD64splitload_OpAMD64CMPLconstloadidx4(v *Value) bool
            
            
            
               
                  rewriteValueAMD64splitload_OpAMD64CMPLload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64splitload_OpAMD64CMPLload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64splitload_OpAMD64CMPLloadidx1 
                  function
                  
                  #
               
               
               func rewriteValueAMD64splitload_OpAMD64CMPLloadidx1(v *Value) bool
            
            
            
               
                  rewriteValueAMD64splitload_OpAMD64CMPLloadidx4 
                  function
                  
                  #
               
               
               func rewriteValueAMD64splitload_OpAMD64CMPLloadidx4(v *Value) bool
            
            
            
               
                  rewriteValueAMD64splitload_OpAMD64CMPQconstload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64splitload_OpAMD64CMPQconstload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64splitload_OpAMD64CMPQconstloadidx1 
                  function
                  
                  #
               
               
               func rewriteValueAMD64splitload_OpAMD64CMPQconstloadidx1(v *Value) bool
            
            
            
               
                  rewriteValueAMD64splitload_OpAMD64CMPQconstloadidx8 
                  function
                  
                  #
               
               
               func rewriteValueAMD64splitload_OpAMD64CMPQconstloadidx8(v *Value) bool
            
            
            
               
                  rewriteValueAMD64splitload_OpAMD64CMPQload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64splitload_OpAMD64CMPQload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64splitload_OpAMD64CMPQloadidx1 
                  function
                  
                  #
               
               
               func rewriteValueAMD64splitload_OpAMD64CMPQloadidx1(v *Value) bool
            
            
            
               
                  rewriteValueAMD64splitload_OpAMD64CMPQloadidx8 
                  function
                  
                  #
               
               
               func rewriteValueAMD64splitload_OpAMD64CMPQloadidx8(v *Value) bool
            
            
            
               
                  rewriteValueAMD64splitload_OpAMD64CMPWconstload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64splitload_OpAMD64CMPWconstload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64splitload_OpAMD64CMPWconstloadidx1 
                  function
                  
                  #
               
               
               func rewriteValueAMD64splitload_OpAMD64CMPWconstloadidx1(v *Value) bool
            
            
            
               
                  rewriteValueAMD64splitload_OpAMD64CMPWconstloadidx2 
                  function
                  
                  #
               
               
               func rewriteValueAMD64splitload_OpAMD64CMPWconstloadidx2(v *Value) bool
            
            
            
               
                  rewriteValueAMD64splitload_OpAMD64CMPWload 
                  function
                  
                  #
               
               
               func rewriteValueAMD64splitload_OpAMD64CMPWload(v *Value) bool
            
            
            
               
                  rewriteValueAMD64splitload_OpAMD64CMPWloadidx1 
                  function
                  
                  #
               
               
               func rewriteValueAMD64splitload_OpAMD64CMPWloadidx1(v *Value) bool
            
            
            
               
                  rewriteValueAMD64splitload_OpAMD64CMPWloadidx2 
                  function
                  
                  #
               
               
               func rewriteValueAMD64splitload_OpAMD64CMPWloadidx2(v *Value) bool
            
            
            
               
                  rewriteValueARM 
                  function
                  
                  #
               
               
               func rewriteValueARM(v *Value) bool
            
            
            
               
                  rewriteValueARM64 
                  function
                  
                  #
               
               
               func rewriteValueARM64(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64ADCSflags 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64ADCSflags(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64ADD 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64ADD(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64ADDSflags 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64ADDSflags(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64ADDconst 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64ADDconst(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64ADDshiftLL 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64ADDshiftLL(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64ADDshiftRA 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64ADDshiftRA(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64ADDshiftRL 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64ADDshiftRL(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64AND 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64AND(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64ANDconst 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64ANDconst(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64ANDshiftLL 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64ANDshiftLL(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64ANDshiftRA 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64ANDshiftRA(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64ANDshiftRL 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64ANDshiftRL(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64ANDshiftRO 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64ANDshiftRO(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64BIC 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64BIC(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64BICshiftLL 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64BICshiftLL(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64BICshiftRA 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64BICshiftRA(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64BICshiftRL 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64BICshiftRL(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64BICshiftRO 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64BICshiftRO(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64CMN 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64CMN(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64CMNW 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64CMNW(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64CMNWconst 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64CMNWconst(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64CMNconst 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64CMNconst(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64CMNshiftLL 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64CMNshiftLL(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64CMNshiftRA 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64CMNshiftRA(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64CMNshiftRL 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64CMNshiftRL(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64CMP 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64CMP(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64CMPW 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64CMPW(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64CMPWconst 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64CMPWconst(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64CMPconst 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64CMPconst(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64CMPshiftLL 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64CMPshiftLL(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64CMPshiftRA 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64CMPshiftRA(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64CMPshiftRL 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64CMPshiftRL(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64CSEL 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64CSEL(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64CSEL0 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64CSEL0(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64CSETM 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64CSETM(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64CSINC 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64CSINC(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64CSINV 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64CSINV(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64CSNEG 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64CSNEG(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64DIV 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64DIV(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64DIVW 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64DIVW(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64EON 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64EON(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64EONshiftLL 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64EONshiftLL(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64EONshiftRA 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64EONshiftRA(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64EONshiftRL 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64EONshiftRL(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64EONshiftRO 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64EONshiftRO(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64Equal 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64Equal(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64FADDD 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64FADDD(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64FADDS 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64FADDS(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64FCMPD 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64FCMPD(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64FCMPS 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64FCMPS(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64FMOVDfpgp 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64FMOVDfpgp(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64FMOVDgpfp 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64FMOVDgpfp(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64FMOVDload 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64FMOVDload(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64FMOVDloadidx 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64FMOVDloadidx(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64FMOVDloadidx8 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64FMOVDloadidx8(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64FMOVDstore 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64FMOVDstore(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64FMOVDstoreidx 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64FMOVDstoreidx(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64FMOVDstoreidx8 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64FMOVDstoreidx8(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64FMOVSload 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64FMOVSload(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64FMOVSloadidx 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64FMOVSloadidx(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64FMOVSloadidx4 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64FMOVSloadidx4(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64FMOVSstore 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64FMOVSstore(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64FMOVSstoreidx 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64FMOVSstoreidx(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64FMOVSstoreidx4 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64FMOVSstoreidx4(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64FMULD 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64FMULD(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64FMULS 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64FMULS(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64FNEGD 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64FNEGD(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64FNEGS 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64FNEGS(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64FNMULD 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64FNMULD(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64FNMULS 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64FNMULS(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64FSUBD 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64FSUBD(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64FSUBS 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64FSUBS(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64GreaterEqual 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64GreaterEqual(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64GreaterEqualF 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64GreaterEqualF(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64GreaterEqualNoov 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64GreaterEqualNoov(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64GreaterEqualU 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64GreaterEqualU(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64GreaterThan 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64GreaterThan(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64GreaterThanF 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64GreaterThanF(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64GreaterThanU 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64GreaterThanU(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64LDP 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64LDP(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64LessEqual 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64LessEqual(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64LessEqualF 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64LessEqualF(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64LessEqualU 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64LessEqualU(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64LessThan 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64LessThan(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64LessThanF 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64LessThanF(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64LessThanNoov 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64LessThanNoov(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64LessThanU 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64LessThanU(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MADD 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MADD(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MADDW 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MADDW(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MNEG 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MNEG(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MNEGW 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MNEGW(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MOD 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MOD(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MODW 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MODW(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MOVBUload 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MOVBUload(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MOVBUloadidx 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MOVBUloadidx(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MOVBUreg 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MOVBUreg(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MOVBload 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MOVBload(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MOVBloadidx 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MOVBloadidx(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MOVBreg 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MOVBreg(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MOVBstore 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MOVBstore(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MOVBstoreidx 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MOVBstoreidx(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MOVBstorezero 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MOVBstorezero(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MOVBstorezeroidx 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MOVBstorezeroidx(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MOVDload 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MOVDload(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MOVDloadidx 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MOVDloadidx(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MOVDloadidx8 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MOVDloadidx8(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MOVDnop 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MOVDnop(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MOVDreg 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MOVDreg(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MOVDstore 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MOVDstore(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MOVDstoreidx 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MOVDstoreidx(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MOVDstoreidx8 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MOVDstoreidx8(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MOVDstorezero 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MOVDstorezero(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MOVDstorezeroidx 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MOVDstorezeroidx(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MOVDstorezeroidx8 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MOVDstorezeroidx8(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MOVHUload 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MOVHUload(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MOVHUloadidx 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MOVHUloadidx(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MOVHUloadidx2 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MOVHUloadidx2(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MOVHUreg 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MOVHUreg(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MOVHload 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MOVHload(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MOVHloadidx 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MOVHloadidx(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MOVHloadidx2 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MOVHloadidx2(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MOVHreg 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MOVHreg(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MOVHstore 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MOVHstore(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MOVHstoreidx 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MOVHstoreidx(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MOVHstoreidx2 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MOVHstoreidx2(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MOVHstorezero 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MOVHstorezero(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MOVHstorezeroidx 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MOVHstorezeroidx(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MOVHstorezeroidx2 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MOVHstorezeroidx2(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MOVQstorezero 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MOVQstorezero(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MOVWUload 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MOVWUload(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MOVWUloadidx 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MOVWUloadidx(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MOVWUloadidx4 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MOVWUloadidx4(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MOVWUreg 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MOVWUreg(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MOVWload 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MOVWload(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MOVWloadidx 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MOVWloadidx(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MOVWloadidx4 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MOVWloadidx4(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MOVWreg 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MOVWreg(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MOVWstore 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MOVWstore(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MOVWstoreidx 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MOVWstoreidx(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MOVWstoreidx4 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MOVWstoreidx4(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MOVWstorezero 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MOVWstorezero(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MOVWstorezeroidx 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MOVWstorezeroidx(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MOVWstorezeroidx4 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MOVWstorezeroidx4(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MSUB 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MSUB(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MSUBW 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MSUBW(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MUL 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MUL(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MULW 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MULW(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MVN 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MVN(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MVNshiftLL 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MVNshiftLL(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MVNshiftRA 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MVNshiftRA(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MVNshiftRL 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MVNshiftRL(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64MVNshiftRO 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64MVNshiftRO(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64NEG 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64NEG(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64NEGshiftLL 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64NEGshiftLL(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64NEGshiftRA 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64NEGshiftRA(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64NEGshiftRL 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64NEGshiftRL(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64NotEqual 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64NotEqual(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64OR 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64OR(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64ORN 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64ORN(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64ORNshiftLL 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64ORNshiftLL(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64ORNshiftRA 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64ORNshiftRA(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64ORNshiftRL 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64ORNshiftRL(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64ORNshiftRO 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64ORNshiftRO(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64ORconst 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64ORconst(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64ORshiftLL 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64ORshiftLL(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64ORshiftRA 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64ORshiftRA(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64ORshiftRL 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64ORshiftRL(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64ORshiftRO 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64ORshiftRO(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64REV 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64REV(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64REVW 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64REVW(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64ROR 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64ROR(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64RORW 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64RORW(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64SBCSflags 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64SBCSflags(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64SBFX 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64SBFX(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64SLL 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64SLL(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64SLLconst 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64SLLconst(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64SRA 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64SRA(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64SRAconst 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64SRAconst(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64SRL 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64SRL(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64SRLconst 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64SRLconst(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64STP 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64STP(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64SUB 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64SUB(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64SUBconst 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64SUBconst(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64SUBshiftLL 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64SUBshiftLL(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64SUBshiftRA 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64SUBshiftRA(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64SUBshiftRL 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64SUBshiftRL(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64TST 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64TST(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64TSTW 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64TSTW(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64TSTWconst 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64TSTWconst(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64TSTconst 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64TSTconst(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64TSTshiftLL 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64TSTshiftLL(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64TSTshiftRA 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64TSTshiftRA(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64TSTshiftRL 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64TSTshiftRL(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64TSTshiftRO 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64TSTshiftRO(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64UBFIZ 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64UBFIZ(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64UBFX 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64UBFX(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64UDIV 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64UDIV(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64UDIVW 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64UDIVW(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64UMOD 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64UMOD(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64UMODW 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64UMODW(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64XOR 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64XOR(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64XORconst 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64XORconst(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64XORshiftLL 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64XORshiftLL(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64XORshiftRA 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64XORshiftRA(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64XORshiftRL 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64XORshiftRL(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpARM64XORshiftRO 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpARM64XORshiftRO(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpAddr 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpAddr(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpAvg64u 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpAvg64u(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpBitLen32 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpBitLen32(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpBitLen64 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpBitLen64(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpBitRev16 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpBitRev16(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpBitRev8 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpBitRev8(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpCondSelect 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpCondSelect(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpConst16 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpConst16(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpConst32 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpConst32(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpConst32F 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpConst32F(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpConst64 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpConst64(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpConst64F 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpConst64F(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpConst8 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpConst8(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpConstBool 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpConstBool(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpConstNil 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpConstNil(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpCtz16 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpCtz16(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpCtz32 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpCtz32(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpCtz64 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpCtz64(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpCtz8 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpCtz8(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpDiv16 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpDiv16(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpDiv16u 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpDiv16u(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpDiv32 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpDiv32(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpDiv64 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpDiv64(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpDiv8 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpDiv8(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpDiv8u 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpDiv8u(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpEq16 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpEq16(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpEq32 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpEq32(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpEq32F 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpEq32F(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpEq64 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpEq64(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpEq64F 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpEq64F(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpEq8 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpEq8(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpEqB 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpEqB(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpEqPtr 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpEqPtr(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpFMA 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpFMA(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpHmul32 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpHmul32(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpHmul32u 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpHmul32u(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpIsInBounds 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpIsInBounds(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpIsNonNil 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpIsNonNil(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpIsSliceInBounds 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpIsSliceInBounds(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpLeq16 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpLeq16(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpLeq16U 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpLeq16U(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpLeq32 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpLeq32(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpLeq32F 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpLeq32F(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpLeq32U 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpLeq32U(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpLeq64 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpLeq64(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpLeq64F 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpLeq64F(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpLeq64U 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpLeq64U(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpLeq8 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpLeq8(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpLeq8U 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpLeq8U(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpLess16 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpLess16(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpLess16U 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpLess16U(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpLess32 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpLess32(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpLess32F 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpLess32F(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpLess32U 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpLess32U(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpLess64 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpLess64(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpLess64F 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpLess64F(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpLess64U 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpLess64U(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpLess8 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpLess8(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpLess8U 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpLess8U(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpLoad 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpLoad(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpLocalAddr 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpLocalAddr(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpLsh16x16 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpLsh16x16(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpLsh16x32 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpLsh16x32(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpLsh16x64 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpLsh16x64(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpLsh16x8 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpLsh16x8(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpLsh32x16 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpLsh32x16(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpLsh32x32 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpLsh32x32(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpLsh32x64 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpLsh32x64(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpLsh32x8 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpLsh32x8(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpLsh64x16 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpLsh64x16(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpLsh64x32 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpLsh64x32(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpLsh64x64 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpLsh64x64(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpLsh64x8 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpLsh64x8(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpLsh8x16 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpLsh8x16(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpLsh8x32 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpLsh8x32(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpLsh8x64 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpLsh8x64(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpLsh8x8 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpLsh8x8(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpMod16 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpMod16(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpMod16u 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpMod16u(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpMod32 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpMod32(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpMod64 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpMod64(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpMod8 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpMod8(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpMod8u 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpMod8u(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpMove 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpMove(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpNeq16 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpNeq16(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpNeq32 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpNeq32(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpNeq32F 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpNeq32F(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpNeq64 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpNeq64(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpNeq64F 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpNeq64F(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpNeq8 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpNeq8(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpNeqPtr 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpNeqPtr(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpNot 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpNot(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpOffPtr 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpOffPtr(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpPanicBounds 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpPanicBounds(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpPopCount16 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpPopCount16(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpPopCount32 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpPopCount32(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpPopCount64 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpPopCount64(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpPrefetchCache 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpPrefetchCache(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpPrefetchCacheStreamed 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpPrefetchCacheStreamed(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpPubBarrier 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpPubBarrier(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpRotateLeft16 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpRotateLeft16(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpRotateLeft32 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpRotateLeft32(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpRotateLeft64 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpRotateLeft64(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpRotateLeft8 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpRotateLeft8(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpRsh16Ux16 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpRsh16Ux16(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpRsh16Ux32 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpRsh16Ux32(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpRsh16Ux64 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpRsh16Ux64(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpRsh16Ux8 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpRsh16Ux8(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpRsh16x16 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpRsh16x16(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpRsh16x32 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpRsh16x32(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpRsh16x64 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpRsh16x64(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpRsh16x8 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpRsh16x8(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpRsh32Ux16 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpRsh32Ux16(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpRsh32Ux32 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpRsh32Ux32(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpRsh32Ux64 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpRsh32Ux64(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpRsh32Ux8 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpRsh32Ux8(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpRsh32x16 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpRsh32x16(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpRsh32x32 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpRsh32x32(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpRsh32x64 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpRsh32x64(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpRsh32x8 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpRsh32x8(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpRsh64Ux16 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpRsh64Ux16(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpRsh64Ux32 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpRsh64Ux32(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpRsh64Ux64 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpRsh64Ux64(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpRsh64Ux8 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpRsh64Ux8(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpRsh64x16 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpRsh64x16(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpRsh64x32 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpRsh64x32(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpRsh64x64 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpRsh64x64(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpRsh64x8 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpRsh64x8(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpRsh8Ux16 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpRsh8Ux16(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpRsh8Ux32 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpRsh8Ux32(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpRsh8Ux64 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpRsh8Ux64(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpRsh8Ux8 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpRsh8Ux8(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpRsh8x16 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpRsh8x16(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpRsh8x32 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpRsh8x32(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpRsh8x64 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpRsh8x64(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpRsh8x8 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpRsh8x8(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpSelect0 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpSelect0(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpSelect1 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpSelect1(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpSelectN 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpSelectN(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpSlicemask 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpSlicemask(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpStore 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpStore(v *Value) bool
            
            
            
               
                  rewriteValueARM64_OpZero 
                  function
                  
                  #
               
               
               func rewriteValueARM64_OpZero(v *Value) bool
            
            
            
               
                  rewriteValueARM64latelower 
                  function
                  
                  #
               
               
               func rewriteValueARM64latelower(v *Value) bool
            
            
            
               
                  rewriteValueARM64latelower_OpARM64ADDSconstflags 
                  function
                  
                  #
               
               
               func rewriteValueARM64latelower_OpARM64ADDSconstflags(v *Value) bool
            
            
            
               
                  rewriteValueARM64latelower_OpARM64ADDconst 
                  function
                  
                  #
               
               
               func rewriteValueARM64latelower_OpARM64ADDconst(v *Value) bool
            
            
            
               
                  rewriteValueARM64latelower_OpARM64ANDconst 
                  function
                  
                  #
               
               
               func rewriteValueARM64latelower_OpARM64ANDconst(v *Value) bool
            
            
            
               
                  rewriteValueARM64latelower_OpARM64CMNWconst 
                  function
                  
                  #
               
               
               func rewriteValueARM64latelower_OpARM64CMNWconst(v *Value) bool
            
            
            
               
                  rewriteValueARM64latelower_OpARM64CMNconst 
                  function
                  
                  #
               
               
               func rewriteValueARM64latelower_OpARM64CMNconst(v *Value) bool
            
            
            
               
                  rewriteValueARM64latelower_OpARM64CMPWconst 
                  function
                  
                  #
               
               
               func rewriteValueARM64latelower_OpARM64CMPWconst(v *Value) bool
            
            
            
               
                  rewriteValueARM64latelower_OpARM64CMPconst 
                  function
                  
                  #
               
               
               func rewriteValueARM64latelower_OpARM64CMPconst(v *Value) bool
            
            
            
               
                  rewriteValueARM64latelower_OpARM64MOVBUreg 
                  function
                  
                  #
               
               
               func rewriteValueARM64latelower_OpARM64MOVBUreg(v *Value) bool
            
            
            
               
                  rewriteValueARM64latelower_OpARM64MOVBreg 
                  function
                  
                  #
               
               
               func rewriteValueARM64latelower_OpARM64MOVBreg(v *Value) bool
            
            
            
               
                  rewriteValueARM64latelower_OpARM64MOVHUreg 
                  function
                  
                  #
               
               
               func rewriteValueARM64latelower_OpARM64MOVHUreg(v *Value) bool
            
            
            
               
                  rewriteValueARM64latelower_OpARM64MOVHreg 
                  function
                  
                  #
               
               
               func rewriteValueARM64latelower_OpARM64MOVHreg(v *Value) bool
            
            
            
               
                  rewriteValueARM64latelower_OpARM64MOVWUreg 
                  function
                  
                  #
               
               
               func rewriteValueARM64latelower_OpARM64MOVWUreg(v *Value) bool
            
            
            
               
                  rewriteValueARM64latelower_OpARM64MOVWreg 
                  function
                  
                  #
               
               
               func rewriteValueARM64latelower_OpARM64MOVWreg(v *Value) bool
            
            
            
               
                  rewriteValueARM64latelower_OpARM64ORconst 
                  function
                  
                  #
               
               
               func rewriteValueARM64latelower_OpARM64ORconst(v *Value) bool
            
            
            
               
                  rewriteValueARM64latelower_OpARM64SUBconst 
                  function
                  
                  #
               
               
               func rewriteValueARM64latelower_OpARM64SUBconst(v *Value) bool
            
            
            
               
                  rewriteValueARM64latelower_OpARM64TSTWconst 
                  function
                  
                  #
               
               
               func rewriteValueARM64latelower_OpARM64TSTWconst(v *Value) bool
            
            
            
               
                  rewriteValueARM64latelower_OpARM64TSTconst 
                  function
                  
                  #
               
               
               func rewriteValueARM64latelower_OpARM64TSTconst(v *Value) bool
            
            
            
               
                  rewriteValueARM64latelower_OpARM64XORconst 
                  function
                  
                  #
               
               
               func rewriteValueARM64latelower_OpARM64XORconst(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMADC 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMADC(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMADCconst 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMADCconst(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMADCshiftLL 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMADCshiftLL(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMADCshiftLLreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMADCshiftLLreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMADCshiftRA 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMADCshiftRA(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMADCshiftRAreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMADCshiftRAreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMADCshiftRL 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMADCshiftRL(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMADCshiftRLreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMADCshiftRLreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMADD 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMADD(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMADDD 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMADDD(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMADDF 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMADDF(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMADDS 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMADDS(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMADDSshiftLL 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMADDSshiftLL(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMADDSshiftLLreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMADDSshiftLLreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMADDSshiftRA 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMADDSshiftRA(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMADDSshiftRAreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMADDSshiftRAreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMADDSshiftRL 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMADDSshiftRL(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMADDSshiftRLreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMADDSshiftRLreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMADDconst 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMADDconst(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMADDshiftLL 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMADDshiftLL(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMADDshiftLLreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMADDshiftLLreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMADDshiftRA 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMADDshiftRA(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMADDshiftRAreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMADDshiftRAreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMADDshiftRL 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMADDshiftRL(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMADDshiftRLreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMADDshiftRLreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMAND 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMAND(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMANDconst 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMANDconst(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMANDshiftLL 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMANDshiftLL(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMANDshiftLLreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMANDshiftLLreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMANDshiftRA 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMANDshiftRA(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMANDshiftRAreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMANDshiftRAreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMANDshiftRL 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMANDshiftRL(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMANDshiftRLreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMANDshiftRLreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMBFX 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMBFX(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMBFXU 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMBFXU(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMBIC 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMBIC(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMBICconst 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMBICconst(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMBICshiftLL 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMBICshiftLL(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMBICshiftLLreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMBICshiftLLreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMBICshiftRA 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMBICshiftRA(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMBICshiftRAreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMBICshiftRAreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMBICshiftRL 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMBICshiftRL(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMBICshiftRLreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMBICshiftRLreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMCMN 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMCMN(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMCMNconst 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMCMNconst(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMCMNshiftLL 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMCMNshiftLL(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMCMNshiftLLreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMCMNshiftLLreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMCMNshiftRA 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMCMNshiftRA(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMCMNshiftRAreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMCMNshiftRAreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMCMNshiftRL 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMCMNshiftRL(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMCMNshiftRLreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMCMNshiftRLreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMCMOVWHSconst 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMCMOVWHSconst(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMCMOVWLSconst 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMCMOVWLSconst(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMCMP 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMCMP(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMCMPD 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMCMPD(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMCMPF 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMCMPF(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMCMPconst 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMCMPconst(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMCMPshiftLL 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMCMPshiftLL(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMCMPshiftLLreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMCMPshiftLLreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMCMPshiftRA 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMCMPshiftRA(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMCMPshiftRAreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMCMPshiftRAreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMCMPshiftRL 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMCMPshiftRL(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMCMPshiftRLreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMCMPshiftRLreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMEqual 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMEqual(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMGreaterEqual 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMGreaterEqual(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMGreaterEqualU 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMGreaterEqualU(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMGreaterThan 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMGreaterThan(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMGreaterThanU 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMGreaterThanU(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMLessEqual 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMLessEqual(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMLessEqualU 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMLessEqualU(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMLessThan 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMLessThan(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMLessThanU 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMLessThanU(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMMOVBUload 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMMOVBUload(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMMOVBUloadidx 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMMOVBUloadidx(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMMOVBUreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMMOVBUreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMMOVBload 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMMOVBload(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMMOVBloadidx 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMMOVBloadidx(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMMOVBreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMMOVBreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMMOVBstore 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMMOVBstore(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMMOVBstoreidx 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMMOVBstoreidx(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMMOVDload 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMMOVDload(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMMOVDstore 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMMOVDstore(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMMOVFload 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMMOVFload(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMMOVFstore 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMMOVFstore(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMMOVHUload 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMMOVHUload(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMMOVHUloadidx 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMMOVHUloadidx(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMMOVHUreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMMOVHUreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMMOVHload 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMMOVHload(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMMOVHloadidx 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMMOVHloadidx(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMMOVHreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMMOVHreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMMOVHstore 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMMOVHstore(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMMOVHstoreidx 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMMOVHstoreidx(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMMOVWload 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMMOVWload(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMMOVWloadidx 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMMOVWloadidx(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMMOVWloadshiftLL 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMMOVWloadshiftLL(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMMOVWloadshiftRA 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMMOVWloadshiftRA(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMMOVWloadshiftRL 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMMOVWloadshiftRL(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMMOVWnop 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMMOVWnop(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMMOVWreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMMOVWreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMMOVWstore 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMMOVWstore(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMMOVWstoreidx 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMMOVWstoreidx(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMMOVWstoreshiftLL 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMMOVWstoreshiftLL(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMMOVWstoreshiftRA 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMMOVWstoreshiftRA(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMMOVWstoreshiftRL 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMMOVWstoreshiftRL(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMMUL 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMMUL(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMMULA 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMMULA(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMMULD 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMMULD(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMMULF 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMMULF(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMMULS 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMMULS(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMMVN 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMMVN(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMMVNshiftLL 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMMVNshiftLL(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMMVNshiftLLreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMMVNshiftLLreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMMVNshiftRA 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMMVNshiftRA(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMMVNshiftRAreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMMVNshiftRAreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMMVNshiftRL 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMMVNshiftRL(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMMVNshiftRLreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMMVNshiftRLreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMNEGD 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMNEGD(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMNEGF 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMNEGF(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMNMULD 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMNMULD(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMNMULF 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMNMULF(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMNotEqual 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMNotEqual(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMOR 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMOR(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMORconst 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMORconst(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMORshiftLL 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMORshiftLL(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMORshiftLLreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMORshiftLLreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMORshiftRA 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMORshiftRA(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMORshiftRAreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMORshiftRAreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMORshiftRL 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMORshiftRL(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMORshiftRLreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMORshiftRLreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMRSB 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMRSB(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMRSBSshiftLL 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMRSBSshiftLL(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMRSBSshiftLLreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMRSBSshiftLLreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMRSBSshiftRA 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMRSBSshiftRA(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMRSBSshiftRAreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMRSBSshiftRAreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMRSBSshiftRL 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMRSBSshiftRL(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMRSBSshiftRLreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMRSBSshiftRLreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMRSBconst 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMRSBconst(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMRSBshiftLL 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMRSBshiftLL(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMRSBshiftLLreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMRSBshiftLLreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMRSBshiftRA 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMRSBshiftRA(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMRSBshiftRAreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMRSBshiftRAreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMRSBshiftRL 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMRSBshiftRL(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMRSBshiftRLreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMRSBshiftRLreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMRSCconst 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMRSCconst(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMRSCshiftLL 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMRSCshiftLL(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMRSCshiftLLreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMRSCshiftLLreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMRSCshiftRA 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMRSCshiftRA(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMRSCshiftRAreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMRSCshiftRAreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMRSCshiftRL 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMRSCshiftRL(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMRSCshiftRLreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMRSCshiftRLreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMSBC 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMSBC(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMSBCconst 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMSBCconst(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMSBCshiftLL 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMSBCshiftLL(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMSBCshiftLLreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMSBCshiftLLreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMSBCshiftRA 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMSBCshiftRA(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMSBCshiftRAreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMSBCshiftRAreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMSBCshiftRL 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMSBCshiftRL(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMSBCshiftRLreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMSBCshiftRLreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMSLL 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMSLL(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMSLLconst 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMSLLconst(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMSRA 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMSRA(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMSRAcond 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMSRAcond(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMSRAconst 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMSRAconst(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMSRL 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMSRL(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMSRLconst 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMSRLconst(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMSRR 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMSRR(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMSUB 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMSUB(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMSUBD 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMSUBD(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMSUBF 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMSUBF(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMSUBS 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMSUBS(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMSUBSshiftLL 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMSUBSshiftLL(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMSUBSshiftLLreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMSUBSshiftLLreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMSUBSshiftRA 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMSUBSshiftRA(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMSUBSshiftRAreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMSUBSshiftRAreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMSUBSshiftRL 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMSUBSshiftRL(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMSUBSshiftRLreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMSUBSshiftRLreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMSUBconst 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMSUBconst(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMSUBshiftLL 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMSUBshiftLL(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMSUBshiftLLreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMSUBshiftLLreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMSUBshiftRA 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMSUBshiftRA(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMSUBshiftRAreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMSUBshiftRAreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMSUBshiftRL 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMSUBshiftRL(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMSUBshiftRLreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMSUBshiftRLreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMTEQ 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMTEQ(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMTEQconst 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMTEQconst(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMTEQshiftLL 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMTEQshiftLL(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMTEQshiftLLreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMTEQshiftLLreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMTEQshiftRA 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMTEQshiftRA(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMTEQshiftRAreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMTEQshiftRAreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMTEQshiftRL 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMTEQshiftRL(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMTEQshiftRLreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMTEQshiftRLreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMTST 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMTST(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMTSTconst 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMTSTconst(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMTSTshiftLL 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMTSTshiftLL(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMTSTshiftLLreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMTSTshiftLLreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMTSTshiftRA 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMTSTshiftRA(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMTSTshiftRAreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMTSTshiftRAreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMTSTshiftRL 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMTSTshiftRL(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMTSTshiftRLreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMTSTshiftRLreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMXOR 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMXOR(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMXORconst 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMXORconst(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMXORshiftLL 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMXORshiftLL(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMXORshiftLLreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMXORshiftLLreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMXORshiftRA 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMXORshiftRA(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMXORshiftRAreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMXORshiftRAreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMXORshiftRL 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMXORshiftRL(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMXORshiftRLreg 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMXORshiftRLreg(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpARMXORshiftRR 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpARMXORshiftRR(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpAddr 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpAddr(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpAvg32u 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpAvg32u(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpBitLen32 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpBitLen32(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpBswap32 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpBswap32(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpConst16 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpConst16(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpConst32 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpConst32(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpConst32F 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpConst32F(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpConst64F 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpConst64F(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpConst8 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpConst8(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpConstBool 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpConstBool(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpConstNil 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpConstNil(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpCtz16 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpCtz16(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpCtz32 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpCtz32(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpCtz8 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpCtz8(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpDiv16 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpDiv16(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpDiv16u 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpDiv16u(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpDiv32 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpDiv32(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpDiv32u 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpDiv32u(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpDiv8 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpDiv8(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpDiv8u 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpDiv8u(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpEq16 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpEq16(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpEq32 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpEq32(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpEq32F 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpEq32F(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpEq64F 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpEq64F(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpEq8 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpEq8(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpEqB 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpEqB(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpEqPtr 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpEqPtr(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpFMA 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpFMA(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpIsInBounds 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpIsInBounds(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpIsNonNil 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpIsNonNil(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpIsSliceInBounds 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpIsSliceInBounds(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpLeq16 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpLeq16(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpLeq16U 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpLeq16U(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpLeq32 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpLeq32(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpLeq32F 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpLeq32F(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpLeq32U 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpLeq32U(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpLeq64F 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpLeq64F(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpLeq8 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpLeq8(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpLeq8U 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpLeq8U(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpLess16 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpLess16(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpLess16U 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpLess16U(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpLess32 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpLess32(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpLess32F 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpLess32F(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpLess32U 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpLess32U(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpLess64F 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpLess64F(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpLess8 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpLess8(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpLess8U 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpLess8U(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpLoad 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpLoad(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpLocalAddr 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpLocalAddr(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpLsh16x16 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpLsh16x16(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpLsh16x32 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpLsh16x32(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpLsh16x64 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpLsh16x64(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpLsh16x8 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpLsh16x8(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpLsh32x16 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpLsh32x16(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpLsh32x32 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpLsh32x32(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpLsh32x64 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpLsh32x64(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpLsh32x8 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpLsh32x8(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpLsh8x16 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpLsh8x16(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpLsh8x32 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpLsh8x32(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpLsh8x64 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpLsh8x64(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpLsh8x8 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpLsh8x8(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpMod16 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpMod16(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpMod16u 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpMod16u(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpMod32 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpMod32(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpMod32u 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpMod32u(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpMod8 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpMod8(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpMod8u 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpMod8u(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpMove 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpMove(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpNeg16 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpNeg16(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpNeg32 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpNeg32(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpNeg8 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpNeg8(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpNeq16 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpNeq16(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpNeq32 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpNeq32(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpNeq32F 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpNeq32F(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpNeq64F 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpNeq64F(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpNeq8 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpNeq8(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpNeqPtr 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpNeqPtr(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpNot 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpNot(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpOffPtr 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpOffPtr(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpPanicBounds 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpPanicBounds(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpPanicExtend 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpPanicExtend(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpRotateLeft16 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpRotateLeft16(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpRotateLeft32 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpRotateLeft32(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpRotateLeft8 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpRotateLeft8(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpRsh16Ux16 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpRsh16Ux16(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpRsh16Ux32 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpRsh16Ux32(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpRsh16Ux64 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpRsh16Ux64(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpRsh16Ux8 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpRsh16Ux8(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpRsh16x16 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpRsh16x16(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpRsh16x32 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpRsh16x32(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpRsh16x64 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpRsh16x64(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpRsh16x8 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpRsh16x8(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpRsh32Ux16 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpRsh32Ux16(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpRsh32Ux32 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpRsh32Ux32(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpRsh32Ux64 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpRsh32Ux64(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpRsh32Ux8 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpRsh32Ux8(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpRsh32x16 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpRsh32x16(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpRsh32x32 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpRsh32x32(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpRsh32x64 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpRsh32x64(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpRsh32x8 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpRsh32x8(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpRsh8Ux16 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpRsh8Ux16(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpRsh8Ux32 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpRsh8Ux32(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpRsh8Ux64 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpRsh8Ux64(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpRsh8Ux8 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpRsh8Ux8(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpRsh8x16 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpRsh8x16(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpRsh8x32 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpRsh8x32(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpRsh8x64 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpRsh8x64(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpRsh8x8 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpRsh8x8(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpSelect0 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpSelect0(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpSelect1 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpSelect1(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpSignmask 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpSignmask(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpSlicemask 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpSlicemask(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpStore 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpStore(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpZero 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpZero(v *Value) bool
            
            
            
               
                  rewriteValueARM_OpZeromask 
                  function
                  
                  #
               
               
               func rewriteValueARM_OpZeromask(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpAddr 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpAddr(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpAtomicAnd8 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpAtomicAnd8(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpAtomicCompareAndSwap32 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpAtomicCompareAndSwap32(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpAtomicCompareAndSwap32Variant 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpAtomicCompareAndSwap32Variant(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpAtomicOr8 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpAtomicOr8(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpAvg64u 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpAvg64u(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpBitLen32 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpBitLen32(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpBitLen64 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpBitLen64(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpBitRev16 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpBitRev16(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpCom16 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpCom16(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpCom32 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpCom32(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpCom64 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpCom64(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpCom8 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpCom8(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpCondSelect 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpCondSelect(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpConst16 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpConst16(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpConst32 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpConst32(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpConst32F 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpConst32F(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpConst64 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpConst64(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpConst64F 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpConst64F(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpConst8 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpConst8(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpConstBool 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpConstBool(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpConstNil 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpConstNil(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpDiv16 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpDiv16(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpDiv16u 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpDiv16u(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpDiv32 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpDiv32(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpDiv32u 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpDiv32u(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpDiv64 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpDiv64(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpDiv8 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpDiv8(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpDiv8u 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpDiv8u(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpEq16 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpEq16(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpEq32 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpEq32(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpEq32F 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpEq32F(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpEq64 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpEq64(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpEq64F 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpEq64F(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpEq8 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpEq8(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpEqB 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpEqB(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpEqPtr 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpEqPtr(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpHmul32 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpHmul32(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpHmul32u 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpHmul32u(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpIsInBounds 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpIsInBounds(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpIsNonNil 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpIsNonNil(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpIsSliceInBounds 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpIsSliceInBounds(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64ADDD 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64ADDD(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64ADDF 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64ADDF(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64ADDV 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64ADDV(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64ADDVconst 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64ADDVconst(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64AND 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64AND(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64ANDconst 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64ANDconst(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64DIVV 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64DIVV(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64DIVVU 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64DIVVU(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64MASKEQZ 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64MASKEQZ(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64MASKNEZ 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64MASKNEZ(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64MOVBUload 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64MOVBUload(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64MOVBUloadidx 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64MOVBUloadidx(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64MOVBUreg 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64MOVBUreg(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64MOVBload 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64MOVBload(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64MOVBloadidx 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64MOVBloadidx(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64MOVBreg 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64MOVBreg(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64MOVBstore 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64MOVBstore(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64MOVBstoreidx 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64MOVBstoreidx(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64MOVBstorezero 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64MOVBstorezero(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64MOVBstorezeroidx 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64MOVBstorezeroidx(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64MOVDload 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64MOVDload(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64MOVDloadidx 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64MOVDloadidx(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64MOVDstore 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64MOVDstore(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64MOVDstoreidx 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64MOVDstoreidx(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64MOVFload 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64MOVFload(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64MOVFloadidx 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64MOVFloadidx(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64MOVFstore 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64MOVFstore(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64MOVFstoreidx 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64MOVFstoreidx(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64MOVHUload 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64MOVHUload(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64MOVHUloadidx 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64MOVHUloadidx(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64MOVHUreg 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64MOVHUreg(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64MOVHload 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64MOVHload(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64MOVHloadidx 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64MOVHloadidx(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64MOVHreg 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64MOVHreg(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64MOVHstore 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64MOVHstore(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64MOVHstoreidx 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64MOVHstoreidx(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64MOVHstorezero 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64MOVHstorezero(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64MOVHstorezeroidx 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64MOVHstorezeroidx(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64MOVVload 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64MOVVload(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64MOVVloadidx 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64MOVVloadidx(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64MOVVnop 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64MOVVnop(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64MOVVreg 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64MOVVreg(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64MOVVstore 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64MOVVstore(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64MOVVstoreidx 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64MOVVstoreidx(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64MOVVstorezero 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64MOVVstorezero(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64MOVVstorezeroidx 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64MOVVstorezeroidx(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64MOVWUload 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64MOVWUload(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64MOVWUloadidx 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64MOVWUloadidx(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64MOVWUreg 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64MOVWUreg(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64MOVWload 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64MOVWload(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64MOVWloadidx 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64MOVWloadidx(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64MOVWreg 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64MOVWreg(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64MOVWstore 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64MOVWstore(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64MOVWstoreidx 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64MOVWstoreidx(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64MOVWstorezero 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64MOVWstorezero(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64MOVWstorezeroidx 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64MOVWstorezeroidx(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64MULV 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64MULV(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64NEGV 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64NEGV(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64NOR 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64NOR(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64NORconst 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64NORconst(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64OR 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64OR(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64ORconst 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64ORconst(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64REMV 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64REMV(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64REMVU 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64REMVU(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64ROTR 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64ROTR(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64ROTRV 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64ROTRV(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64SGT 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64SGT(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64SGTU 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64SGTU(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64SGTUconst 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64SGTUconst(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64SGTconst 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64SGTconst(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64SLLV 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64SLLV(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64SLLVconst 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64SLLVconst(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64SRAV 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64SRAV(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64SRAVconst 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64SRAVconst(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64SRLV 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64SRLV(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64SRLVconst 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64SRLVconst(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64SUBD 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64SUBD(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64SUBF 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64SUBF(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64SUBV 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64SUBV(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64SUBVconst 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64SUBVconst(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64XOR 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64XOR(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLOONG64XORconst 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLOONG64XORconst(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLeq16 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLeq16(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLeq16U 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLeq16U(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLeq32 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLeq32(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLeq32F 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLeq32F(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLeq32U 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLeq32U(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLeq64 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLeq64(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLeq64F 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLeq64F(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLeq64U 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLeq64U(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLeq8 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLeq8(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLeq8U 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLeq8U(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLess16 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLess16(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLess16U 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLess16U(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLess32 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLess32(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLess32F 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLess32F(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLess32U 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLess32U(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLess64 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLess64(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLess64F 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLess64F(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLess64U 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLess64U(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLess8 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLess8(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLess8U 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLess8U(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLoad 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLoad(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLocalAddr 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLocalAddr(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLsh16x16 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLsh16x16(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLsh16x32 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLsh16x32(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLsh16x64 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLsh16x64(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLsh16x8 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLsh16x8(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLsh32x16 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLsh32x16(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLsh32x32 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLsh32x32(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLsh32x64 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLsh32x64(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLsh32x8 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLsh32x8(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLsh64x16 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLsh64x16(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLsh64x32 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLsh64x32(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLsh64x64 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLsh64x64(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLsh64x8 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLsh64x8(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLsh8x16 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLsh8x16(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLsh8x32 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLsh8x32(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLsh8x64 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLsh8x64(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpLsh8x8 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpLsh8x8(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpMod16 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpMod16(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpMod16u 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpMod16u(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpMod32 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpMod32(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpMod32u 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpMod32u(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpMod64 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpMod64(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpMod8 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpMod8(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpMod8u 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpMod8u(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpMove 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpMove(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpNeq16 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpNeq16(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpNeq32 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpNeq32(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpNeq32F 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpNeq32F(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpNeq64 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpNeq64(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpNeq64F 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpNeq64F(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpNeq8 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpNeq8(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpNeqPtr 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpNeqPtr(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpNot 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpNot(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpOffPtr 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpOffPtr(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpPanicBounds 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpPanicBounds(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpPopCount16 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpPopCount16(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpPopCount32 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpPopCount32(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpPopCount64 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpPopCount64(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpRotateLeft16 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpRotateLeft16(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpRotateLeft32 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpRotateLeft32(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpRotateLeft64 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpRotateLeft64(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpRotateLeft8 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpRotateLeft8(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpRsh16Ux16 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpRsh16Ux16(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpRsh16Ux32 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpRsh16Ux32(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpRsh16Ux64 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpRsh16Ux64(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpRsh16Ux8 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpRsh16Ux8(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpRsh16x16 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpRsh16x16(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpRsh16x32 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpRsh16x32(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpRsh16x64 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpRsh16x64(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpRsh16x8 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpRsh16x8(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpRsh32Ux16 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpRsh32Ux16(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpRsh32Ux32 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpRsh32Ux32(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpRsh32Ux64 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpRsh32Ux64(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpRsh32Ux8 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpRsh32Ux8(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpRsh32x16 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpRsh32x16(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpRsh32x32 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpRsh32x32(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpRsh32x64 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpRsh32x64(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpRsh32x8 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpRsh32x8(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpRsh64Ux16 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpRsh64Ux16(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpRsh64Ux32 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpRsh64Ux32(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpRsh64Ux64 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpRsh64Ux64(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpRsh64Ux8 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpRsh64Ux8(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpRsh64x16 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpRsh64x16(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpRsh64x32 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpRsh64x32(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpRsh64x64 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpRsh64x64(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpRsh64x8 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpRsh64x8(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpRsh8Ux16 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpRsh8Ux16(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpRsh8Ux32 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpRsh8Ux32(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpRsh8Ux64 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpRsh8Ux64(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpRsh8Ux8 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpRsh8Ux8(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpRsh8x16 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpRsh8x16(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpRsh8x32 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpRsh8x32(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpRsh8x64 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpRsh8x64(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpRsh8x8 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpRsh8x8(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpSelect0 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpSelect0(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpSelect1 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpSelect1(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpSelectN 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpSelectN(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpSlicemask 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpSlicemask(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpStore 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpStore(v *Value) bool
            
            
            
               
                  rewriteValueLOONG64_OpZero 
                  function
                  
                  #
               
               
               func rewriteValueLOONG64_OpZero(v *Value) bool
            
            
            
               
                  rewriteValueMIPS 
                  function
                  
                  #
               
               
               func rewriteValueMIPS(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpAddr 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpAddr(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpAtomicAnd8 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpAtomicAnd8(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpAtomicCompareAndSwap32 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpAtomicCompareAndSwap32(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpAtomicOr8 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpAtomicOr8(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpAvg64u 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpAvg64u(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpCom16 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpCom16(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpCom32 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpCom32(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpCom64 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpCom64(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpCom8 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpCom8(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpConst16 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpConst16(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpConst32 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpConst32(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpConst32F 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpConst32F(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpConst64 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpConst64(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpConst64F 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpConst64F(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpConst8 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpConst8(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpConstBool 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpConstBool(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpConstNil 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpConstNil(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpDiv16 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpDiv16(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpDiv16u 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpDiv16u(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpDiv32 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpDiv32(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpDiv32u 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpDiv32u(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpDiv64 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpDiv64(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpDiv64u 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpDiv64u(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpDiv8 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpDiv8(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpDiv8u 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpDiv8u(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpEq16 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpEq16(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpEq32 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpEq32(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpEq32F 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpEq32F(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpEq64 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpEq64(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpEq64F 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpEq64F(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpEq8 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpEq8(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpEqB 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpEqB(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpEqPtr 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpEqPtr(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpHmul32 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpHmul32(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpHmul32u 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpHmul32u(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpHmul64 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpHmul64(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpHmul64u 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpHmul64u(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpIsInBounds 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpIsInBounds(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpIsNonNil 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpIsNonNil(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpIsSliceInBounds 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpIsSliceInBounds(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpLeq16 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpLeq16(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpLeq16U 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpLeq16U(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpLeq32 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpLeq32(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpLeq32F 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpLeq32F(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpLeq32U 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpLeq32U(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpLeq64 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpLeq64(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpLeq64F 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpLeq64F(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpLeq64U 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpLeq64U(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpLeq8 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpLeq8(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpLeq8U 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpLeq8U(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpLess16 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpLess16(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpLess16U 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpLess16U(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpLess32 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpLess32(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpLess32F 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpLess32F(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpLess32U 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpLess32U(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpLess64 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpLess64(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpLess64F 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpLess64F(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpLess64U 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpLess64U(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpLess8 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpLess8(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpLess8U 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpLess8U(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpLoad 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpLoad(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpLocalAddr 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpLocalAddr(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpLsh16x16 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpLsh16x16(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpLsh16x32 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpLsh16x32(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpLsh16x64 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpLsh16x64(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpLsh16x8 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpLsh16x8(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpLsh32x16 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpLsh32x16(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpLsh32x32 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpLsh32x32(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpLsh32x64 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpLsh32x64(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpLsh32x8 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpLsh32x8(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpLsh64x16 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpLsh64x16(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpLsh64x32 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpLsh64x32(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpLsh64x64 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpLsh64x64(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpLsh64x8 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpLsh64x8(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpLsh8x16 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpLsh8x16(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpLsh8x32 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpLsh8x32(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpLsh8x64 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpLsh8x64(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpLsh8x8 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpLsh8x8(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64ADDV 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64ADDV(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64ADDVconst 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64ADDVconst(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64AND 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64AND(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64ANDconst 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64ANDconst(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64LoweredAtomicAdd32 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64LoweredAtomicAdd32(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64LoweredAtomicAdd64 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64LoweredAtomicAdd64(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64LoweredAtomicStore32 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64LoweredAtomicStore32(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64LoweredAtomicStore64 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64LoweredAtomicStore64(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64MOVBUload 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64MOVBUload(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64MOVBUreg 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64MOVBUreg(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64MOVBload 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64MOVBload(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64MOVBreg 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64MOVBreg(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64MOVBstore 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64MOVBstore(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64MOVBstorezero 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64MOVBstorezero(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64MOVDload 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64MOVDload(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64MOVDstore 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64MOVDstore(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64MOVFload 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64MOVFload(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64MOVFstore 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64MOVFstore(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64MOVHUload 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64MOVHUload(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64MOVHUreg 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64MOVHUreg(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64MOVHload 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64MOVHload(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64MOVHreg 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64MOVHreg(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64MOVHstore 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64MOVHstore(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64MOVHstorezero 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64MOVHstorezero(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64MOVVload 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64MOVVload(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64MOVVnop 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64MOVVnop(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64MOVVreg 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64MOVVreg(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64MOVVstore 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64MOVVstore(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64MOVVstorezero 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64MOVVstorezero(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64MOVWUload 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64MOVWUload(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64MOVWUreg 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64MOVWUreg(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64MOVWload 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64MOVWload(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64MOVWreg 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64MOVWreg(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64MOVWstore 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64MOVWstore(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64MOVWstorezero 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64MOVWstorezero(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64NEGV 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64NEGV(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64NOR 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64NOR(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64NORconst 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64NORconst(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64OR 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64OR(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64ORconst 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64ORconst(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64SGT 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64SGT(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64SGTU 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64SGTU(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64SGTUconst 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64SGTUconst(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64SGTconst 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64SGTconst(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64SLLV 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64SLLV(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64SLLVconst 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64SLLVconst(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64SRAV 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64SRAV(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64SRAVconst 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64SRAVconst(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64SRLV 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64SRLV(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64SRLVconst 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64SRLVconst(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64SUBV 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64SUBV(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64SUBVconst 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64SUBVconst(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64XOR 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64XOR(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMIPS64XORconst 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMIPS64XORconst(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMod16 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMod16(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMod16u 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMod16u(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMod32 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMod32(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMod32u 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMod32u(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMod64 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMod64(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMod64u 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMod64u(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMod8 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMod8(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMod8u 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMod8u(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMove 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMove(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMul16 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMul16(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMul32 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMul32(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMul64 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMul64(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpMul8 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpMul8(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpNeq16 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpNeq16(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpNeq32 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpNeq32(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpNeq32F 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpNeq32F(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpNeq64 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpNeq64(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpNeq64F 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpNeq64F(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpNeq8 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpNeq8(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpNeqPtr 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpNeqPtr(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpNot 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpNot(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpOffPtr 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpOffPtr(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpPanicBounds 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpPanicBounds(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpRotateLeft16 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpRotateLeft16(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpRotateLeft32 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpRotateLeft32(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpRotateLeft64 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpRotateLeft64(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpRotateLeft8 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpRotateLeft8(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpRsh16Ux16 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpRsh16Ux16(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpRsh16Ux32 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpRsh16Ux32(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpRsh16Ux64 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpRsh16Ux64(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpRsh16Ux8 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpRsh16Ux8(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpRsh16x16 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpRsh16x16(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpRsh16x32 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpRsh16x32(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpRsh16x64 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpRsh16x64(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpRsh16x8 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpRsh16x8(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpRsh32Ux16 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpRsh32Ux16(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpRsh32Ux32 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpRsh32Ux32(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpRsh32Ux64 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpRsh32Ux64(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpRsh32Ux8 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpRsh32Ux8(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpRsh32x16 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpRsh32x16(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpRsh32x32 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpRsh32x32(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpRsh32x64 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpRsh32x64(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpRsh32x8 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpRsh32x8(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpRsh64Ux16 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpRsh64Ux16(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpRsh64Ux32 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpRsh64Ux32(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpRsh64Ux64 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpRsh64Ux64(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpRsh64Ux8 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpRsh64Ux8(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpRsh64x16 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpRsh64x16(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpRsh64x32 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpRsh64x32(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpRsh64x64 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpRsh64x64(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpRsh64x8 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpRsh64x8(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpRsh8Ux16 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpRsh8Ux16(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpRsh8Ux32 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpRsh8Ux32(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpRsh8Ux64 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpRsh8Ux64(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpRsh8Ux8 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpRsh8Ux8(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpRsh8x16 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpRsh8x16(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpRsh8x32 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpRsh8x32(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpRsh8x64 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpRsh8x64(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpRsh8x8 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpRsh8x8(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpSelect0 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpSelect0(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpSelect1 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpSelect1(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpSlicemask 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpSlicemask(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpStore 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpStore(v *Value) bool
            
            
            
               
                  rewriteValueMIPS64_OpZero 
                  function
                  
                  #
               
               
               func rewriteValueMIPS64_OpZero(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpAdd32withcarry 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpAdd32withcarry(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpAddr 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpAddr(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpAtomicAnd8 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpAtomicAnd8(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpAtomicOr8 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpAtomicOr8(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpAvg32u 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpAvg32u(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpBitLen32 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpBitLen32(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpCom16 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpCom16(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpCom32 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpCom32(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpCom8 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpCom8(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpConst16 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpConst16(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpConst32 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpConst32(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpConst8 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpConst8(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpConstBool 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpConstBool(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpConstNil 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpConstNil(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpCtz32 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpCtz32(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpDiv16 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpDiv16(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpDiv16u 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpDiv16u(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpDiv32 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpDiv32(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpDiv32u 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpDiv32u(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpDiv8 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpDiv8(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpDiv8u 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpDiv8u(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpEq16 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpEq16(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpEq32 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpEq32(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpEq32F 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpEq32F(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpEq64F 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpEq64F(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpEq8 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpEq8(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpEqB 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpEqB(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpEqPtr 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpEqPtr(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpHmul32 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpHmul32(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpHmul32u 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpHmul32u(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpIsInBounds 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpIsInBounds(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpIsNonNil 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpIsNonNil(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpIsSliceInBounds 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpIsSliceInBounds(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpLeq16 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpLeq16(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpLeq16U 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpLeq16U(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpLeq32 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpLeq32(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpLeq32F 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpLeq32F(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpLeq32U 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpLeq32U(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpLeq64F 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpLeq64F(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpLeq8 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpLeq8(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpLeq8U 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpLeq8U(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpLess16 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpLess16(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpLess16U 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpLess16U(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpLess32 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpLess32(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpLess32F 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpLess32F(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpLess32U 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpLess32U(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpLess64F 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpLess64F(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpLess8 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpLess8(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpLess8U 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpLess8U(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpLoad 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpLoad(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpLocalAddr 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpLocalAddr(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpLsh16x16 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpLsh16x16(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpLsh16x32 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpLsh16x32(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpLsh16x64 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpLsh16x64(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpLsh16x8 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpLsh16x8(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpLsh32x16 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpLsh32x16(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpLsh32x32 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpLsh32x32(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpLsh32x64 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpLsh32x64(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpLsh32x8 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpLsh32x8(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpLsh8x16 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpLsh8x16(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpLsh8x32 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpLsh8x32(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpLsh8x64 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpLsh8x64(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpLsh8x8 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpLsh8x8(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMIPSADD 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMIPSADD(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMIPSADDconst 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMIPSADDconst(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMIPSAND 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMIPSAND(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMIPSANDconst 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMIPSANDconst(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMIPSCMOVZ 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMIPSCMOVZ(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMIPSCMOVZzero 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMIPSCMOVZzero(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMIPSLoweredAtomicAdd 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMIPSLoweredAtomicAdd(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMIPSLoweredAtomicStore32 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMIPSLoweredAtomicStore32(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMIPSMOVBUload 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMIPSMOVBUload(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMIPSMOVBUreg 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMIPSMOVBUreg(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMIPSMOVBload 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMIPSMOVBload(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMIPSMOVBreg 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMIPSMOVBreg(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMIPSMOVBstore 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMIPSMOVBstore(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMIPSMOVBstorezero 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMIPSMOVBstorezero(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMIPSMOVDload 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMIPSMOVDload(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMIPSMOVDstore 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMIPSMOVDstore(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMIPSMOVFload 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMIPSMOVFload(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMIPSMOVFstore 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMIPSMOVFstore(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMIPSMOVHUload 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMIPSMOVHUload(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMIPSMOVHUreg 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMIPSMOVHUreg(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMIPSMOVHload 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMIPSMOVHload(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMIPSMOVHreg 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMIPSMOVHreg(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMIPSMOVHstore 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMIPSMOVHstore(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMIPSMOVHstorezero 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMIPSMOVHstorezero(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMIPSMOVWload 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMIPSMOVWload(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMIPSMOVWnop 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMIPSMOVWnop(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMIPSMOVWreg 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMIPSMOVWreg(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMIPSMOVWstore 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMIPSMOVWstore(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMIPSMOVWstorezero 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMIPSMOVWstorezero(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMIPSMUL 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMIPSMUL(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMIPSNEG 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMIPSNEG(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMIPSNOR 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMIPSNOR(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMIPSNORconst 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMIPSNORconst(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMIPSOR 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMIPSOR(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMIPSORconst 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMIPSORconst(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMIPSSGT 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMIPSSGT(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMIPSSGTU 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMIPSSGTU(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMIPSSGTUconst 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMIPSSGTUconst(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMIPSSGTUzero 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMIPSSGTUzero(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMIPSSGTconst 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMIPSSGTconst(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMIPSSGTzero 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMIPSSGTzero(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMIPSSLL 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMIPSSLL(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMIPSSLLconst 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMIPSSLLconst(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMIPSSRA 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMIPSSRA(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMIPSSRAconst 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMIPSSRAconst(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMIPSSRL 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMIPSSRL(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMIPSSRLconst 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMIPSSRLconst(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMIPSSUB 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMIPSSUB(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMIPSSUBconst 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMIPSSUBconst(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMIPSXOR 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMIPSXOR(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMIPSXORconst 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMIPSXORconst(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMod16 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMod16(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMod16u 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMod16u(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMod32 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMod32(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMod32u 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMod32u(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMod8 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMod8(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMod8u 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMod8u(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpMove 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpMove(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpNeq16 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpNeq16(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpNeq32 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpNeq32(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpNeq32F 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpNeq32F(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpNeq64F 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpNeq64F(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpNeq8 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpNeq8(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpNeqPtr 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpNeqPtr(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpNot 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpNot(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpOffPtr 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpOffPtr(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpPanicBounds 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpPanicBounds(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpPanicExtend 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpPanicExtend(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpRotateLeft16 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpRotateLeft16(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpRotateLeft32 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpRotateLeft32(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpRotateLeft64 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpRotateLeft64(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpRotateLeft8 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpRotateLeft8(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpRsh16Ux16 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpRsh16Ux16(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpRsh16Ux32 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpRsh16Ux32(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpRsh16Ux64 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpRsh16Ux64(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpRsh16Ux8 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpRsh16Ux8(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpRsh16x16 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpRsh16x16(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpRsh16x32 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpRsh16x32(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpRsh16x64 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpRsh16x64(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpRsh16x8 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpRsh16x8(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpRsh32Ux16 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpRsh32Ux16(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpRsh32Ux32 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpRsh32Ux32(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpRsh32Ux64 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpRsh32Ux64(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpRsh32Ux8 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpRsh32Ux8(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpRsh32x16 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpRsh32x16(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpRsh32x32 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpRsh32x32(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpRsh32x64 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpRsh32x64(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpRsh32x8 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpRsh32x8(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpRsh8Ux16 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpRsh8Ux16(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpRsh8Ux32 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpRsh8Ux32(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpRsh8Ux64 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpRsh8Ux64(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpRsh8Ux8 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpRsh8Ux8(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpRsh8x16 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpRsh8x16(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpRsh8x32 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpRsh8x32(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpRsh8x64 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpRsh8x64(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpRsh8x8 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpRsh8x8(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpSelect0 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpSelect0(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpSelect1 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpSelect1(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpSignmask 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpSignmask(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpSlicemask 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpSlicemask(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpStore 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpStore(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpSub32withcarry 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpSub32withcarry(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpZero 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpZero(v *Value) bool
            
            
            
               
                  rewriteValueMIPS_OpZeromask 
                  function
                  
                  #
               
               
               func rewriteValueMIPS_OpZeromask(v *Value) bool
            
            
            
               
                  rewriteValuePPC64 
                  function
                  
                  #
               
               
               func rewriteValuePPC64(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpAddr 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpAddr(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpAtomicCompareAndSwap32 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpAtomicCompareAndSwap32(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpAtomicCompareAndSwap64 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpAtomicCompareAndSwap64(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpAtomicCompareAndSwapRel32 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpAtomicCompareAndSwapRel32(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpAtomicLoad32 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpAtomicLoad32(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpAtomicLoad64 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpAtomicLoad64(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpAtomicLoad8 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpAtomicLoad8(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpAtomicLoadAcq32 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpAtomicLoadAcq32(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpAtomicLoadAcq64 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpAtomicLoadAcq64(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpAtomicLoadPtr 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpAtomicLoadPtr(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpAtomicStore32 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpAtomicStore32(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpAtomicStore64 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpAtomicStore64(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpAtomicStore8 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpAtomicStore8(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpAtomicStoreRel32 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpAtomicStoreRel32(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpAtomicStoreRel64 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpAtomicStoreRel64(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpAvg64u 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpAvg64u(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpBitLen32 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpBitLen32(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpBitLen64 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpBitLen64(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpBswap16 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpBswap16(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpBswap32 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpBswap32(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpBswap64 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpBswap64(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpCom16 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpCom16(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpCom32 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpCom32(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpCom64 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpCom64(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpCom8 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpCom8(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpCondSelect 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpCondSelect(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpConst16 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpConst16(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpConst32 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpConst32(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpConst64 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpConst64(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpConst8 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpConst8(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpConstBool 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpConstBool(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpConstNil 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpConstNil(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpCopysign 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpCopysign(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpCtz16 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpCtz16(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpCtz32 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpCtz32(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpCtz64 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpCtz64(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpCtz8 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpCtz8(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpCvt32Fto32 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpCvt32Fto32(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpCvt32Fto64 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpCvt32Fto64(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpCvt32to32F 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpCvt32to32F(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpCvt32to64F 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpCvt32to64F(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpCvt64Fto32 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpCvt64Fto32(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpCvt64Fto64 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpCvt64Fto64(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpCvt64to32F 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpCvt64to32F(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpCvt64to64F 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpCvt64to64F(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpDiv16 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpDiv16(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpDiv16u 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpDiv16u(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpDiv32 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpDiv32(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpDiv64 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpDiv64(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpDiv8 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpDiv8(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpDiv8u 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpDiv8u(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpEq16 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpEq16(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpEq32 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpEq32(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpEq32F 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpEq32F(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpEq64 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpEq64(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpEq64F 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpEq64F(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpEq8 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpEq8(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpEqB 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpEqB(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpEqPtr 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpEqPtr(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpIsInBounds 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpIsInBounds(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpIsNonNil 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpIsNonNil(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpIsSliceInBounds 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpIsSliceInBounds(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpLeq16 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpLeq16(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpLeq16U 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpLeq16U(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpLeq32 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpLeq32(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpLeq32F 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpLeq32F(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpLeq32U 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpLeq32U(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpLeq64 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpLeq64(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpLeq64F 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpLeq64F(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpLeq64U 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpLeq64U(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpLeq8 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpLeq8(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpLeq8U 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpLeq8U(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpLess16 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpLess16(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpLess16U 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpLess16U(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpLess32 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpLess32(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpLess32F 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpLess32F(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpLess32U 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpLess32U(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpLess64 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpLess64(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpLess64F 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpLess64F(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpLess64U 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpLess64U(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpLess8 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpLess8(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpLess8U 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpLess8U(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpLoad 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpLoad(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpLocalAddr 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpLocalAddr(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpLsh16x16 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpLsh16x16(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpLsh16x32 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpLsh16x32(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpLsh16x64 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpLsh16x64(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpLsh16x8 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpLsh16x8(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpLsh32x16 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpLsh32x16(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpLsh32x32 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpLsh32x32(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpLsh32x64 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpLsh32x64(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpLsh32x8 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpLsh32x8(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpLsh64x16 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpLsh64x16(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpLsh64x32 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpLsh64x32(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpLsh64x64 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpLsh64x64(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpLsh64x8 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpLsh64x8(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpLsh8x16 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpLsh8x16(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpLsh8x32 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpLsh8x32(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpLsh8x64 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpLsh8x64(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpLsh8x8 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpLsh8x8(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpMax32F 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpMax32F(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpMax64F 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpMax64F(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpMin32F 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpMin32F(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpMin64F 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpMin64F(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpMod16 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpMod16(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpMod16u 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpMod16u(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpMod32 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpMod32(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpMod32u 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpMod32u(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpMod64 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpMod64(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpMod64u 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpMod64u(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpMod8 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpMod8(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpMod8u 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpMod8u(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpMove 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpMove(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpNeq16 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpNeq16(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpNeq32 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpNeq32(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpNeq32F 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpNeq32F(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpNeq64 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpNeq64(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpNeq64F 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpNeq64F(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpNeq8 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpNeq8(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpNeqPtr 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpNeqPtr(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpNot 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpNot(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpOffPtr 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpOffPtr(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64ADD 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64ADD(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64ADDC 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64ADDC(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64ADDE 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64ADDE(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64ADDconst 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64ADDconst(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64AND 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64AND(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64ANDN 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64ANDN(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64ANDconst 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64ANDconst(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64BRD 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64BRD(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64BRH 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64BRH(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64BRW 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64BRW(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64CLRLSLDI 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64CLRLSLDI(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64CMP 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64CMP(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64CMPU 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64CMPU(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64CMPUconst 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64CMPUconst(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64CMPW 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64CMPW(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64CMPWU 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64CMPWU(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64CMPWUconst 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64CMPWUconst(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64CMPWconst 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64CMPWconst(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64CMPconst 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64CMPconst(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64Equal 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64Equal(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64FABS 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64FABS(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64FADD 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64FADD(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64FADDS 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64FADDS(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64FCEIL 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64FCEIL(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64FFLOOR 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64FFLOOR(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64FGreaterEqual 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64FGreaterEqual(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64FGreaterThan 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64FGreaterThan(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64FLessEqual 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64FLessEqual(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64FLessThan 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64FLessThan(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64FMOVDload 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64FMOVDload(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64FMOVDstore 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64FMOVDstore(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64FMOVSload 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64FMOVSload(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64FMOVSstore 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64FMOVSstore(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64FNEG 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64FNEG(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64FSQRT 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64FSQRT(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64FSUB 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64FSUB(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64FSUBS 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64FSUBS(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64FTRUNC 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64FTRUNC(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64GreaterEqual 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64GreaterEqual(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64GreaterThan 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64GreaterThan(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64ISEL 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64ISEL(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64LessEqual 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64LessEqual(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64LessThan 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64LessThan(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64MFVSRD 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64MFVSRD(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64MOVBZload 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64MOVBZload(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64MOVBZloadidx 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64MOVBZloadidx(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64MOVBZreg 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64MOVBZreg(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64MOVBreg 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64MOVBreg(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64MOVBstore 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64MOVBstore(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64MOVBstoreidx 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64MOVBstoreidx(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64MOVBstorezero 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64MOVBstorezero(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64MOVDaddr 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64MOVDaddr(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64MOVDload 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64MOVDload(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64MOVDloadidx 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64MOVDloadidx(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64MOVDstore 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64MOVDstore(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64MOVDstoreidx 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64MOVDstoreidx(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64MOVDstorezero 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64MOVDstorezero(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64MOVHBRstore 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64MOVHBRstore(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64MOVHZload 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64MOVHZload(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64MOVHZloadidx 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64MOVHZloadidx(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64MOVHZreg 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64MOVHZreg(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64MOVHload 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64MOVHload(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64MOVHloadidx 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64MOVHloadidx(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64MOVHreg 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64MOVHreg(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64MOVHstore 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64MOVHstore(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64MOVHstoreidx 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64MOVHstoreidx(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64MOVHstorezero 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64MOVHstorezero(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64MOVWBRstore 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64MOVWBRstore(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64MOVWZload 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64MOVWZload(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64MOVWZloadidx 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64MOVWZloadidx(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64MOVWZreg 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64MOVWZreg(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64MOVWload 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64MOVWload(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64MOVWloadidx 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64MOVWloadidx(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64MOVWreg 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64MOVWreg(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64MOVWstore 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64MOVWstore(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64MOVWstoreidx 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64MOVWstoreidx(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64MOVWstorezero 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64MOVWstorezero(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64MTVSRD 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64MTVSRD(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64MULLD 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64MULLD(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64MULLW 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64MULLW(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64NEG 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64NEG(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64NOR 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64NOR(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64NotEqual 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64NotEqual(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64OR 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64OR(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64ORN 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64ORN(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64ORconst 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64ORconst(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64RLWINM 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64RLWINM(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64ROTL 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64ROTL(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64ROTLW 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64ROTLW(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64ROTLWconst 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64ROTLWconst(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64SETBC 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64SETBC(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64SETBCR 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64SETBCR(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64SLD 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64SLD(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64SLDconst 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64SLDconst(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64SLW 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64SLW(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64SLWconst 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64SLWconst(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64SRAD 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64SRAD(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64SRAW 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64SRAW(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64SRD 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64SRD(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64SRW 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64SRW(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64SRWconst 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64SRWconst(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64SUB 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64SUB(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64SUBE 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64SUBE(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64SUBFCconst 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64SUBFCconst(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64XOR 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64XOR(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPPC64XORconst 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPPC64XORconst(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPanicBounds 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPanicBounds(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPopCount16 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPopCount16(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPopCount32 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPopCount32(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPopCount8 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPopCount8(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPrefetchCache 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPrefetchCache(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpPrefetchCacheStreamed 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpPrefetchCacheStreamed(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpRotateLeft16 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpRotateLeft16(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpRotateLeft8 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpRotateLeft8(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpRsh16Ux16 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpRsh16Ux16(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpRsh16Ux32 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpRsh16Ux32(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpRsh16Ux64 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpRsh16Ux64(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpRsh16Ux8 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpRsh16Ux8(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpRsh16x16 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpRsh16x16(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpRsh16x32 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpRsh16x32(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpRsh16x64 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpRsh16x64(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpRsh16x8 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpRsh16x8(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpRsh32Ux16 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpRsh32Ux16(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpRsh32Ux32 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpRsh32Ux32(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpRsh32Ux64 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpRsh32Ux64(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpRsh32Ux8 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpRsh32Ux8(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpRsh32x16 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpRsh32x16(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpRsh32x32 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpRsh32x32(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpRsh32x64 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpRsh32x64(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpRsh32x8 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpRsh32x8(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpRsh64Ux16 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpRsh64Ux16(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpRsh64Ux32 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpRsh64Ux32(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpRsh64Ux64 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpRsh64Ux64(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpRsh64Ux8 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpRsh64Ux8(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpRsh64x16 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpRsh64x16(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpRsh64x32 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpRsh64x32(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpRsh64x64 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpRsh64x64(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpRsh64x8 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpRsh64x8(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpRsh8Ux16 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpRsh8Ux16(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpRsh8Ux32 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpRsh8Ux32(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpRsh8Ux64 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpRsh8Ux64(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpRsh8Ux8 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpRsh8Ux8(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpRsh8x16 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpRsh8x16(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpRsh8x32 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpRsh8x32(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpRsh8x64 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpRsh8x64(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpRsh8x8 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpRsh8x8(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpSelect0 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpSelect0(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpSelect1 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpSelect1(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpSelectN 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpSelectN(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpSlicemask 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpSlicemask(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpStore 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpStore(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpTrunc16to8 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpTrunc16to8(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpTrunc32to16 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpTrunc32to16(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpTrunc32to8 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpTrunc32to8(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpTrunc64to16 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpTrunc64to16(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpTrunc64to32 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpTrunc64to32(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpTrunc64to8 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpTrunc64to8(v *Value) bool
            
            
            
               
                  rewriteValuePPC64_OpZero 
                  function
                  
                  #
               
               
               func rewriteValuePPC64_OpZero(v *Value) bool
            
            
            
               
                  rewriteValuePPC64latelower 
                  function
                  
                  #
               
               
               func rewriteValuePPC64latelower(v *Value) bool
            
            
            
               
                  rewriteValuePPC64latelower_OpPPC64ADD 
                  function
                  
                  #
               
               
               func rewriteValuePPC64latelower_OpPPC64ADD(v *Value) bool
            
            
            
               
                  rewriteValuePPC64latelower_OpPPC64AND 
                  function
                  
                  #
               
               
               func rewriteValuePPC64latelower_OpPPC64AND(v *Value) bool
            
            
            
               
                  rewriteValuePPC64latelower_OpPPC64ANDconst 
                  function
                  
                  #
               
               
               func rewriteValuePPC64latelower_OpPPC64ANDconst(v *Value) bool
            
            
            
               
                  rewriteValuePPC64latelower_OpPPC64CMPconst 
                  function
                  
                  #
               
               
               func rewriteValuePPC64latelower_OpPPC64CMPconst(v *Value) bool
            
            
            
               
                  rewriteValuePPC64latelower_OpPPC64ISEL 
                  function
                  
                  #
               
               
               func rewriteValuePPC64latelower_OpPPC64ISEL(v *Value) bool
            
            
            
               
                  rewriteValuePPC64latelower_OpPPC64RLDICL 
                  function
                  
                  #
               
               
               func rewriteValuePPC64latelower_OpPPC64RLDICL(v *Value) bool
            
            
            
               
                  rewriteValuePPC64latelower_OpPPC64RLDICLCC 
                  function
                  
                  #
               
               
               func rewriteValuePPC64latelower_OpPPC64RLDICLCC(v *Value) bool
            
            
            
               
                  rewriteValuePPC64latelower_OpPPC64SETBC 
                  function
                  
                  #
               
               
               func rewriteValuePPC64latelower_OpPPC64SETBC(v *Value) bool
            
            
            
               
                  rewriteValuePPC64latelower_OpPPC64SETBCR 
                  function
                  
                  #
               
               
               func rewriteValuePPC64latelower_OpPPC64SETBCR(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpAddr 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpAddr(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpAtomicAnd8 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpAtomicAnd8(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpAtomicCompareAndSwap32 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpAtomicCompareAndSwap32(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpAtomicOr8 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpAtomicOr8(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpAvg64u 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpAvg64u(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpConst16 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpConst16(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpConst32 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpConst32(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpConst32F 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpConst32F(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpConst64 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpConst64(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpConst64F 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpConst64F(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpConst8 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpConst8(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpConstBool 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpConstBool(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpConstNil 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpConstNil(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpDiv16 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpDiv16(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpDiv16u 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpDiv16u(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpDiv32 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpDiv32(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpDiv64 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpDiv64(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpDiv8 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpDiv8(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpDiv8u 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpDiv8u(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpEq16 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpEq16(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpEq32 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpEq32(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpEq64 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpEq64(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpEq8 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpEq8(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpEqB 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpEqB(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpEqPtr 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpEqPtr(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpHmul32 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpHmul32(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpHmul32u 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpHmul32u(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpLeq16 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpLeq16(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpLeq16U 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpLeq16U(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpLeq32 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpLeq32(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpLeq32U 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpLeq32U(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpLeq64 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpLeq64(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpLeq64U 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpLeq64U(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpLeq8 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpLeq8(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpLeq8U 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpLeq8U(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpLess16 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpLess16(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpLess16U 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpLess16U(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpLess32 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpLess32(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpLess32U 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpLess32U(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpLess8 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpLess8(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpLess8U 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpLess8U(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpLoad 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpLoad(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpLocalAddr 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpLocalAddr(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpLsh16x16 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpLsh16x16(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpLsh16x32 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpLsh16x32(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpLsh16x64 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpLsh16x64(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpLsh16x8 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpLsh16x8(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpLsh32x16 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpLsh32x16(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpLsh32x32 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpLsh32x32(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpLsh32x64 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpLsh32x64(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpLsh32x8 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpLsh32x8(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpLsh64x16 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpLsh64x16(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpLsh64x32 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpLsh64x32(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpLsh64x64 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpLsh64x64(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpLsh64x8 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpLsh64x8(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpLsh8x16 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpLsh8x16(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpLsh8x32 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpLsh8x32(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpLsh8x64 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpLsh8x64(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpLsh8x8 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpLsh8x8(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpMax64 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpMax64(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpMax64u 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpMax64u(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpMin64 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpMin64(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpMin64u 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpMin64u(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpMod16 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpMod16(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpMod16u 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpMod16u(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpMod32 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpMod32(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpMod64 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpMod64(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpMod8 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpMod8(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpMod8u 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpMod8u(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpMove 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpMove(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpMul16 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpMul16(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpMul8 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpMul8(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpNeq16 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpNeq16(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpNeq32 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpNeq32(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpNeq64 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpNeq64(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpNeq8 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpNeq8(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpNeqB 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpNeqB(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpNeqPtr 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpNeqPtr(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpOffPtr 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpOffPtr(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpPanicBounds 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpPanicBounds(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64ADD 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64ADD(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64ADDI 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64ADDI(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64AND 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64AND(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64ANDI 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64ANDI(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64FADDD 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64FADDD(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64FADDS 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64FADDS(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64FMADDD 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64FMADDD(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64FMADDS 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64FMADDS(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64FMSUBD 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64FMSUBD(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64FMSUBS 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64FMSUBS(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64FNMADDD 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64FNMADDD(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64FNMADDS 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64FNMADDS(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64FNMSUBD 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64FNMSUBD(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64FNMSUBS 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64FNMSUBS(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64FSUBD 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64FSUBD(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64FSUBS 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64FSUBS(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64MOVBUload 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64MOVBUload(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64MOVBUreg 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64MOVBUreg(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64MOVBload 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64MOVBload(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64MOVBreg 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64MOVBreg(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64MOVBstore 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64MOVBstore(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64MOVBstorezero 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64MOVBstorezero(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64MOVDload 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64MOVDload(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64MOVDnop 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64MOVDnop(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64MOVDreg 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64MOVDreg(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64MOVDstore 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64MOVDstore(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64MOVDstorezero 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64MOVDstorezero(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64MOVHUload 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64MOVHUload(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64MOVHUreg 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64MOVHUreg(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64MOVHload 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64MOVHload(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64MOVHreg 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64MOVHreg(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64MOVHstore 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64MOVHstore(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64MOVHstorezero 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64MOVHstorezero(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64MOVWUload 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64MOVWUload(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64MOVWUreg 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64MOVWUreg(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64MOVWload 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64MOVWload(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64MOVWreg 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64MOVWreg(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64MOVWstore 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64MOVWstore(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64MOVWstorezero 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64MOVWstorezero(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64NEG 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64NEG(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64NEGW 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64NEGW(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64OR 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64OR(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64ORI 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64ORI(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64ROL 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64ROL(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64ROLW 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64ROLW(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64ROR 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64ROR(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64RORW 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64RORW(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64SEQZ 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64SEQZ(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64SLL 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64SLL(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64SLLI 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64SLLI(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64SLLW 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64SLLW(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64SLT 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64SLT(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64SLTI 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64SLTI(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64SLTIU 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64SLTIU(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64SLTU 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64SLTU(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64SNEZ 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64SNEZ(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64SRA 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64SRA(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64SRAI 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64SRAI(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64SRAW 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64SRAW(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64SRL 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64SRL(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64SRLI 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64SRLI(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64SRLW 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64SRLW(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64SUB 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64SUB(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64SUBW 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64SUBW(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRISCV64XOR 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRISCV64XOR(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRotateLeft16 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRotateLeft16(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRotateLeft8 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRotateLeft8(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRsh16Ux16 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRsh16Ux16(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRsh16Ux32 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRsh16Ux32(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRsh16Ux64 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRsh16Ux64(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRsh16Ux8 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRsh16Ux8(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRsh16x16 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRsh16x16(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRsh16x32 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRsh16x32(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRsh16x64 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRsh16x64(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRsh16x8 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRsh16x8(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRsh32Ux16 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRsh32Ux16(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRsh32Ux32 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRsh32Ux32(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRsh32Ux64 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRsh32Ux64(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRsh32Ux8 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRsh32Ux8(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRsh32x16 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRsh32x16(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRsh32x32 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRsh32x32(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRsh32x64 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRsh32x64(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRsh32x8 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRsh32x8(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRsh64Ux16 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRsh64Ux16(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRsh64Ux32 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRsh64Ux32(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRsh64Ux64 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRsh64Ux64(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRsh64Ux8 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRsh64Ux8(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRsh64x16 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRsh64x16(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRsh64x32 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRsh64x32(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRsh64x64 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRsh64x64(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRsh64x8 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRsh64x8(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRsh8Ux16 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRsh8Ux16(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRsh8Ux32 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRsh8Ux32(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRsh8Ux64 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRsh8Ux64(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRsh8Ux8 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRsh8Ux8(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRsh8x16 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRsh8x16(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRsh8x32 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRsh8x32(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRsh8x64 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRsh8x64(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpRsh8x8 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpRsh8x8(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpSelect0 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpSelect0(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpSelect1 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpSelect1(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpSlicemask 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpSlicemask(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpStore 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpStore(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64_OpZero 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64_OpZero(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64latelower 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64latelower(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64latelower_OpRISCV64AND 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64latelower_OpRISCV64AND(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64latelower_OpRISCV64NOT 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64latelower_OpRISCV64NOT(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64latelower_OpRISCV64OR 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64latelower_OpRISCV64OR(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64latelower_OpRISCV64SLLI 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64latelower_OpRISCV64SLLI(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64latelower_OpRISCV64SRAI 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64latelower_OpRISCV64SRAI(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64latelower_OpRISCV64SRLI 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64latelower_OpRISCV64SRLI(v *Value) bool
            
            
            
               
                  rewriteValueRISCV64latelower_OpRISCV64XOR 
                  function
                  
                  #
               
               
               func rewriteValueRISCV64latelower_OpRISCV64XOR(v *Value) bool
            
            
            
               
                  rewriteValueS390X 
                  function
                  
                  #
               
               
               func rewriteValueS390X(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpAdd32F 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpAdd32F(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpAdd64F 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpAdd64F(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpAddr 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpAddr(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpAtomicAdd32 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpAtomicAdd32(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpAtomicAdd64 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpAtomicAdd64(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpAtomicAnd8 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpAtomicAnd8(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpAtomicCompareAndSwap32 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpAtomicCompareAndSwap32(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpAtomicCompareAndSwap64 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpAtomicCompareAndSwap64(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpAtomicExchange32 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpAtomicExchange32(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpAtomicExchange64 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpAtomicExchange64(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpAtomicLoad32 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpAtomicLoad32(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpAtomicLoad64 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpAtomicLoad64(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpAtomicLoad8 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpAtomicLoad8(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpAtomicLoadAcq32 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpAtomicLoadAcq32(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpAtomicLoadPtr 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpAtomicLoadPtr(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpAtomicOr8 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpAtomicOr8(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpAtomicStore32 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpAtomicStore32(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpAtomicStore64 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpAtomicStore64(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpAtomicStore8 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpAtomicStore8(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpAtomicStorePtrNoWB 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpAtomicStorePtrNoWB(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpAtomicStoreRel32 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpAtomicStoreRel32(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpAvg64u 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpAvg64u(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpBitLen64 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpBitLen64(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpBswap16 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpBswap16(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpCeil 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpCeil(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpConst16 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpConst16(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpConst32 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpConst32(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpConst64 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpConst64(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpConst8 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpConst8(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpConstBool 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpConstBool(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpConstNil 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpConstNil(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpCtz32 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpCtz32(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpCtz64 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpCtz64(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpDiv16 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpDiv16(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpDiv16u 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpDiv16u(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpDiv32 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpDiv32(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpDiv32u 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpDiv32u(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpDiv64 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpDiv64(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpDiv8 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpDiv8(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpDiv8u 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpDiv8u(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpEq16 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpEq16(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpEq32 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpEq32(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpEq32F 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpEq32F(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpEq64 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpEq64(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpEq64F 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpEq64F(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpEq8 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpEq8(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpEqB 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpEqB(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpEqPtr 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpEqPtr(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpFMA 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpFMA(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpFloor 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpFloor(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpHmul32 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpHmul32(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpHmul32u 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpHmul32u(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpITab 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpITab(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpIsInBounds 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpIsInBounds(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpIsNonNil 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpIsNonNil(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpIsSliceInBounds 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpIsSliceInBounds(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpLeq16 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpLeq16(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpLeq16U 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpLeq16U(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpLeq32 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpLeq32(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpLeq32F 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpLeq32F(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpLeq32U 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpLeq32U(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpLeq64 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpLeq64(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpLeq64F 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpLeq64F(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpLeq64U 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpLeq64U(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpLeq8 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpLeq8(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpLeq8U 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpLeq8U(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpLess16 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpLess16(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpLess16U 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpLess16U(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpLess32 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpLess32(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpLess32F 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpLess32F(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpLess32U 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpLess32U(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpLess64 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpLess64(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpLess64F 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpLess64F(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpLess64U 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpLess64U(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpLess8 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpLess8(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpLess8U 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpLess8U(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpLoad 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpLoad(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpLocalAddr 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpLocalAddr(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpLsh16x16 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpLsh16x16(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpLsh16x32 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpLsh16x32(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpLsh16x64 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpLsh16x64(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpLsh16x8 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpLsh16x8(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpLsh32x16 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpLsh32x16(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpLsh32x32 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpLsh32x32(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpLsh32x64 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpLsh32x64(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpLsh32x8 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpLsh32x8(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpLsh64x16 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpLsh64x16(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpLsh64x32 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpLsh64x32(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpLsh64x64 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpLsh64x64(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpLsh64x8 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpLsh64x8(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpLsh8x16 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpLsh8x16(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpLsh8x32 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpLsh8x32(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpLsh8x64 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpLsh8x64(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpLsh8x8 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpLsh8x8(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpMod16 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpMod16(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpMod16u 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpMod16u(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpMod32 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpMod32(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpMod32u 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpMod32u(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpMod64 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpMod64(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpMod8 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpMod8(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpMod8u 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpMod8u(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpMove 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpMove(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpNeq16 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpNeq16(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpNeq32 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpNeq32(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpNeq32F 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpNeq32F(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpNeq64 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpNeq64(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpNeq64F 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpNeq64F(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpNeq8 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpNeq8(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpNeqB 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpNeqB(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpNeqPtr 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpNeqPtr(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpNot 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpNot(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpOffPtr 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpOffPtr(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpPanicBounds 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpPanicBounds(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpPopCount16 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpPopCount16(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpPopCount32 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpPopCount32(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpPopCount64 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpPopCount64(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpPopCount8 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpPopCount8(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpRotateLeft16 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpRotateLeft16(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpRotateLeft8 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpRotateLeft8(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpRound 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpRound(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpRoundToEven 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpRoundToEven(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpRsh16Ux16 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpRsh16Ux16(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpRsh16Ux32 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpRsh16Ux32(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpRsh16Ux64 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpRsh16Ux64(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpRsh16Ux8 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpRsh16Ux8(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpRsh16x16 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpRsh16x16(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpRsh16x32 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpRsh16x32(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpRsh16x64 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpRsh16x64(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpRsh16x8 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpRsh16x8(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpRsh32Ux16 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpRsh32Ux16(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpRsh32Ux32 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpRsh32Ux32(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpRsh32Ux64 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpRsh32Ux64(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpRsh32Ux8 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpRsh32Ux8(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpRsh32x16 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpRsh32x16(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpRsh32x32 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpRsh32x32(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpRsh32x64 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpRsh32x64(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpRsh32x8 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpRsh32x8(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpRsh64Ux16 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpRsh64Ux16(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpRsh64Ux32 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpRsh64Ux32(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpRsh64Ux64 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpRsh64Ux64(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpRsh64Ux8 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpRsh64Ux8(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpRsh64x16 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpRsh64x16(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpRsh64x32 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpRsh64x32(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpRsh64x64 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpRsh64x64(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpRsh64x8 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpRsh64x8(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpRsh8Ux16 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpRsh8Ux16(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpRsh8Ux32 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpRsh8Ux32(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpRsh8Ux64 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpRsh8Ux64(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpRsh8Ux8 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpRsh8Ux8(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpRsh8x16 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpRsh8x16(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpRsh8x32 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpRsh8x32(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpRsh8x64 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpRsh8x64(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpRsh8x8 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpRsh8x8(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XADD 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XADD(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XADDC 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XADDC(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XADDE 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XADDE(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XADDW 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XADDW(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XADDWconst 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XADDWconst(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XADDWload 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XADDWload(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XADDconst 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XADDconst(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XADDload 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XADDload(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XAND 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XAND(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XANDW 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XANDW(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XANDWconst 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XANDWconst(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XANDWload 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XANDWload(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XANDconst 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XANDconst(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XANDload 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XANDload(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XCMP 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XCMP(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XCMPU 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XCMPU(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XCMPUconst 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XCMPUconst(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XCMPW 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XCMPW(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XCMPWU 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XCMPWU(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XCMPWUconst 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XCMPWUconst(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XCMPWconst 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XCMPWconst(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XCMPconst 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XCMPconst(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XCPSDR 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XCPSDR(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XFCMP 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XFCMP(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XFCMPS 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XFCMPS(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XFMOVDload 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XFMOVDload(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XFMOVDstore 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XFMOVDstore(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XFMOVSload 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XFMOVSload(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XFMOVSstore 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XFMOVSstore(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XFNEG 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XFNEG(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XFNEGS 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XFNEGS(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XLDGR 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XLDGR(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XLEDBR 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XLEDBR(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XLGDR 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XLGDR(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XLOCGR 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XLOCGR(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XLTDBR 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XLTDBR(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XLTEBR 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XLTEBR(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XLoweredRound32F 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XLoweredRound32F(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XLoweredRound64F 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XLoweredRound64F(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XMOVBZload 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XMOVBZload(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XMOVBZreg 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XMOVBZreg(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XMOVBload 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XMOVBload(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XMOVBreg 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XMOVBreg(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XMOVBstore 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XMOVBstore(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XMOVBstoreconst 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XMOVBstoreconst(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XMOVDBR 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XMOVDBR(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XMOVDaddridx 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XMOVDaddridx(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XMOVDload 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XMOVDload(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XMOVDstore 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XMOVDstore(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XMOVDstoreconst 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XMOVDstoreconst(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XMOVDstoreidx 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XMOVDstoreidx(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XMOVHZload 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XMOVHZload(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XMOVHZreg 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XMOVHZreg(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XMOVHload 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XMOVHload(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XMOVHreg 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XMOVHreg(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XMOVHstore 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XMOVHstore(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XMOVHstoreconst 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XMOVHstoreconst(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XMOVHstoreidx 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XMOVHstoreidx(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XMOVWBR 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XMOVWBR(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XMOVWZload 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XMOVWZload(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XMOVWZreg 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XMOVWZreg(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XMOVWload 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XMOVWload(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XMOVWreg 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XMOVWreg(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XMOVWstore 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XMOVWstore(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XMOVWstoreconst 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XMOVWstoreconst(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XMOVWstoreidx 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XMOVWstoreidx(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XMULLD 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XMULLD(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XMULLDconst 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XMULLDconst(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XMULLDload 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XMULLDload(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XMULLW 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XMULLW(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XMULLWconst 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XMULLWconst(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XMULLWload 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XMULLWload(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XNEG 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XNEG(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XNEGW 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XNEGW(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XNOT 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XNOT(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XNOTW 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XNOTW(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XOR 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XOR(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XORW 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XORW(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XORWconst 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XORWconst(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XORWload 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XORWload(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XORconst 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XORconst(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XORload 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XORload(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XRISBGZ 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XRISBGZ(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XRLL 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XRLL(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XRLLG 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XRLLG(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XSLD 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XSLD(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XSLDconst 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XSLDconst(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XSLW 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XSLW(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XSLWconst 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XSLWconst(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XSRAD 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XSRAD(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XSRADconst 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XSRADconst(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XSRAW 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XSRAW(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XSRAWconst 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XSRAWconst(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XSRD 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XSRD(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XSRDconst 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XSRDconst(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XSRW 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XSRW(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XSRWconst 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XSRWconst(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XSTM2 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XSTM2(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XSTMG2 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XSTMG2(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XSUB 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XSUB(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XSUBE 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XSUBE(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XSUBW 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XSUBW(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XSUBWconst 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XSUBWconst(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XSUBWload 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XSUBWload(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XSUBconst 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XSUBconst(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XSUBload 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XSUBload(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XSumBytes2 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XSumBytes2(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XSumBytes4 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XSumBytes4(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XSumBytes8 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XSumBytes8(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XXOR 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XXOR(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XXORW 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XXORW(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XXORWconst 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XXORWconst(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XXORWload 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XXORWload(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XXORconst 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XXORconst(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpS390XXORload 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpS390XXORload(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpSelect0 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpSelect0(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpSelect1 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpSelect1(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpSlicemask 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpSlicemask(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpStore 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpStore(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpSub32F 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpSub32F(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpSub64F 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpSub64F(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpTrunc 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpTrunc(v *Value) bool
            
            
            
               
                  rewriteValueS390X_OpZero 
                  function
                  
                  #
               
               
               func rewriteValueS390X_OpZero(v *Value) bool
            
            
            
               
                  rewriteValueWasm 
                  function
                  
                  #
               
               
               func rewriteValueWasm(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpAddr 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpAddr(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpBitLen64 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpBitLen64(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpCom16 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpCom16(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpCom32 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpCom32(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpCom64 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpCom64(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpCom8 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpCom8(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpConst16 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpConst16(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpConst32 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpConst32(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpConst8 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpConst8(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpConstBool 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpConstBool(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpConstNil 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpConstNil(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpCtz16 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpCtz16(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpCtz32 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpCtz32(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpCtz8 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpCtz8(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpCvt32Uto32F 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpCvt32Uto32F(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpCvt32Uto64F 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpCvt32Uto64F(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpCvt32to32F 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpCvt32to32F(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpCvt32to64F 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpCvt32to64F(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpDiv16 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpDiv16(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpDiv16u 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpDiv16u(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpDiv32 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpDiv32(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpDiv32u 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpDiv32u(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpDiv64 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpDiv64(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpDiv8 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpDiv8(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpDiv8u 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpDiv8u(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpEq16 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpEq16(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpEq32 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpEq32(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpEq8 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpEq8(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpIsNonNil 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpIsNonNil(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpLeq16 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpLeq16(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpLeq16U 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpLeq16U(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpLeq32 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpLeq32(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpLeq32U 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpLeq32U(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpLeq8 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpLeq8(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpLeq8U 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpLeq8U(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpLess16 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpLess16(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpLess16U 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpLess16U(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpLess32 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpLess32(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpLess32U 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpLess32U(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpLess8 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpLess8(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpLess8U 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpLess8U(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpLoad 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpLoad(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpLocalAddr 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpLocalAddr(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpLsh16x16 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpLsh16x16(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpLsh16x32 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpLsh16x32(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpLsh16x8 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpLsh16x8(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpLsh32x16 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpLsh32x16(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpLsh32x32 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpLsh32x32(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpLsh32x8 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpLsh32x8(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpLsh64x16 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpLsh64x16(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpLsh64x32 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpLsh64x32(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpLsh64x64 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpLsh64x64(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpLsh64x8 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpLsh64x8(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpLsh8x16 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpLsh8x16(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpLsh8x32 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpLsh8x32(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpLsh8x8 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpLsh8x8(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpMod16 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpMod16(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpMod16u 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpMod16u(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpMod32 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpMod32(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpMod32u 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpMod32u(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpMod64 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpMod64(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpMod8 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpMod8(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpMod8u 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpMod8u(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpMove 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpMove(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpNeg16 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpNeg16(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpNeg32 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpNeg32(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpNeg64 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpNeg64(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpNeg8 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpNeg8(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpNeq16 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpNeq16(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpNeq32 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpNeq32(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpNeq8 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpNeq8(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpPopCount16 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpPopCount16(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpPopCount32 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpPopCount32(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpPopCount8 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpPopCount8(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpRotateLeft16 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpRotateLeft16(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpRotateLeft8 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpRotateLeft8(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpRsh16Ux16 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpRsh16Ux16(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpRsh16Ux32 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpRsh16Ux32(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpRsh16Ux64 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpRsh16Ux64(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpRsh16Ux8 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpRsh16Ux8(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpRsh16x16 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpRsh16x16(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpRsh16x32 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpRsh16x32(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpRsh16x64 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpRsh16x64(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpRsh16x8 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpRsh16x8(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpRsh32Ux16 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpRsh32Ux16(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpRsh32Ux32 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpRsh32Ux32(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpRsh32Ux64 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpRsh32Ux64(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpRsh32Ux8 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpRsh32Ux8(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpRsh32x16 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpRsh32x16(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpRsh32x32 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpRsh32x32(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpRsh32x64 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpRsh32x64(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpRsh32x8 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpRsh32x8(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpRsh64Ux16 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpRsh64Ux16(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpRsh64Ux32 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpRsh64Ux32(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpRsh64Ux64 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpRsh64Ux64(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpRsh64Ux8 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpRsh64Ux8(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpRsh64x16 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpRsh64x16(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpRsh64x32 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpRsh64x32(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpRsh64x64 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpRsh64x64(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpRsh64x8 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpRsh64x8(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpRsh8Ux16 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpRsh8Ux16(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpRsh8Ux32 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpRsh8Ux32(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpRsh8Ux64 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpRsh8Ux64(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpRsh8Ux8 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpRsh8Ux8(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpRsh8x16 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpRsh8x16(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpRsh8x32 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpRsh8x32(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpRsh8x64 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpRsh8x64(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpRsh8x8 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpRsh8x8(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpSignExt16to32 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpSignExt16to32(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpSignExt16to64 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpSignExt16to64(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpSignExt32to64 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpSignExt32to64(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpSignExt8to16 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpSignExt8to16(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpSignExt8to32 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpSignExt8to32(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpSignExt8to64 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpSignExt8to64(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpSlicemask 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpSlicemask(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpStore 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpStore(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpWasmF64Add 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpWasmF64Add(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpWasmF64Mul 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpWasmF64Mul(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpWasmI64Add 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpWasmI64Add(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpWasmI64AddConst 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpWasmI64AddConst(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpWasmI64And 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpWasmI64And(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpWasmI64Eq 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpWasmI64Eq(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpWasmI64Eqz 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpWasmI64Eqz(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpWasmI64LeU 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpWasmI64LeU(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpWasmI64Load 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpWasmI64Load(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpWasmI64Load16S 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpWasmI64Load16S(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpWasmI64Load16U 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpWasmI64Load16U(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpWasmI64Load32S 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpWasmI64Load32S(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpWasmI64Load32U 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpWasmI64Load32U(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpWasmI64Load8S 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpWasmI64Load8S(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpWasmI64Load8U 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpWasmI64Load8U(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpWasmI64LtU 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpWasmI64LtU(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpWasmI64Mul 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpWasmI64Mul(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpWasmI64Ne 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpWasmI64Ne(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpWasmI64Or 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpWasmI64Or(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpWasmI64Shl 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpWasmI64Shl(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpWasmI64ShrS 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpWasmI64ShrS(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpWasmI64ShrU 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpWasmI64ShrU(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpWasmI64Store 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpWasmI64Store(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpWasmI64Store16 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpWasmI64Store16(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpWasmI64Store32 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpWasmI64Store32(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpWasmI64Store8 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpWasmI64Store8(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpWasmI64Xor 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpWasmI64Xor(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpZero 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpZero(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpZeroExt16to32 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpZeroExt16to32(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpZeroExt16to64 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpZeroExt16to64(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpZeroExt32to64 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpZeroExt32to64(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpZeroExt8to16 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpZeroExt8to16(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpZeroExt8to32 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpZeroExt8to32(v *Value) bool
            
            
            
               
                  rewriteValueWasm_OpZeroExt8to64 
                  function
                  
                  #
               
               
               func rewriteValueWasm_OpZeroExt8to64(v *Value) bool
            
            
            
               
                  rewriteValuedec 
                  function
                  
                  #
               
               
               func rewriteValuedec(v *Value) bool
            
            
            
               
                  rewriteValuedec64 
                  function
                  
                  #
               
               
               func rewriteValuedec64(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpAdd64 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpAdd64(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpAnd64 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpAnd64(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpArg 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpArg(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpBitLen64 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpBitLen64(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpBswap64 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpBswap64(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpCom64 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpCom64(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpConst64 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpConst64(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpCtz64 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpCtz64(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpEq64 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpEq64(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpInt64Hi 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpInt64Hi(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpInt64Lo 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpInt64Lo(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpLeq64 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpLeq64(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpLeq64U 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpLeq64U(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpLess64 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpLess64(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpLess64U 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpLess64U(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpLoad 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpLoad(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpLsh16x64 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpLsh16x64(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpLsh32x64 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpLsh32x64(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpLsh64x16 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpLsh64x16(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpLsh64x32 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpLsh64x32(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpLsh64x64 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpLsh64x64(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpLsh64x8 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpLsh64x8(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpLsh8x64 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpLsh8x64(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpMul64 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpMul64(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpNeg64 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpNeg64(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpNeq64 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpNeq64(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpOr32 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpOr32(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpOr64 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpOr64(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpRotateLeft16 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpRotateLeft16(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpRotateLeft32 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpRotateLeft32(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpRotateLeft64 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpRotateLeft64(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpRotateLeft8 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpRotateLeft8(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpRsh16Ux64 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpRsh16Ux64(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpRsh16x64 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpRsh16x64(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpRsh32Ux64 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpRsh32Ux64(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpRsh32x64 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpRsh32x64(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpRsh64Ux16 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpRsh64Ux16(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpRsh64Ux32 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpRsh64Ux32(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpRsh64Ux64 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpRsh64Ux64(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpRsh64Ux8 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpRsh64Ux8(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpRsh64x16 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpRsh64x16(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpRsh64x32 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpRsh64x32(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpRsh64x64 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpRsh64x64(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpRsh64x8 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpRsh64x8(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpRsh8Ux64 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpRsh8Ux64(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpRsh8x64 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpRsh8x64(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpSignExt16to64 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpSignExt16to64(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpSignExt32to64 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpSignExt32to64(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpSignExt8to64 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpSignExt8to64(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpStore 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpStore(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpSub64 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpSub64(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpTrunc64to16 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpTrunc64to16(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpTrunc64to32 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpTrunc64to32(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpTrunc64to8 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpTrunc64to8(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpXor64 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpXor64(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpZeroExt16to64 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpZeroExt16to64(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpZeroExt32to64 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpZeroExt32to64(v *Value) bool
            
            
            
               
                  rewriteValuedec64_OpZeroExt8to64 
                  function
                  
                  #
               
               
               func rewriteValuedec64_OpZeroExt8to64(v *Value) bool
            
            
            
               
                  rewriteValuedec_OpArrayMake1 
                  function
                  
                  #
               
               
               func rewriteValuedec_OpArrayMake1(v *Value) bool
            
            
            
               
                  rewriteValuedec_OpArraySelect 
                  function
                  
                  #
               
               
               func rewriteValuedec_OpArraySelect(v *Value) bool
            
            
            
               
                  rewriteValuedec_OpComplexImag 
                  function
                  
                  #
               
               
               func rewriteValuedec_OpComplexImag(v *Value) bool
            
            
            
               
                  rewriteValuedec_OpComplexReal 
                  function
                  
                  #
               
               
               func rewriteValuedec_OpComplexReal(v *Value) bool
            
            
            
               
                  rewriteValuedec_OpIData 
                  function
                  
                  #
               
               
               func rewriteValuedec_OpIData(v *Value) bool
            
            
            
               
                  rewriteValuedec_OpIMake 
                  function
                  
                  #
               
               
               func rewriteValuedec_OpIMake(v *Value) bool
            
            
            
               
                  rewriteValuedec_OpITab 
                  function
                  
                  #
               
               
               func rewriteValuedec_OpITab(v *Value) bool
            
            
            
               
                  rewriteValuedec_OpLoad 
                  function
                  
                  #
               
               
               func rewriteValuedec_OpLoad(v *Value) bool
            
            
            
               
                  rewriteValuedec_OpSliceCap 
                  function
                  
                  #
               
               
               func rewriteValuedec_OpSliceCap(v *Value) bool
            
            
            
               
                  rewriteValuedec_OpSliceLen 
                  function
                  
                  #
               
               
               func rewriteValuedec_OpSliceLen(v *Value) bool
            
            
            
               
                  rewriteValuedec_OpSlicePtr 
                  function
                  
                  #
               
               
               func rewriteValuedec_OpSlicePtr(v *Value) bool
            
            
            
               
                  rewriteValuedec_OpSlicePtrUnchecked 
                  function
                  
                  #
               
               
               func rewriteValuedec_OpSlicePtrUnchecked(v *Value) bool
            
            
            
               
                  rewriteValuedec_OpStore 
                  function
                  
                  #
               
               
               func rewriteValuedec_OpStore(v *Value) bool
            
            
            
               
                  rewriteValuedec_OpStringLen 
                  function
                  
                  #
               
               
               func rewriteValuedec_OpStringLen(v *Value) bool
            
            
            
               
                  rewriteValuedec_OpStringPtr 
                  function
                  
                  #
               
               
               func rewriteValuedec_OpStringPtr(v *Value) bool
            
            
            
               
                  rewriteValuedec_OpStructMake 
                  function
                  
                  #
               
               
               func rewriteValuedec_OpStructMake(v *Value) bool
            
            
            
               
                  rewriteValuedec_OpStructSelect 
                  function
                  
                  #
               
               
               func rewriteValuedec_OpStructSelect(v *Value) bool
            
            
            
               
                  rewriteValuegeneric 
                  function
                  
                  #
               
               
               func rewriteValuegeneric(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpAdd16 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpAdd16(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpAdd32 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpAdd32(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpAdd32F 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpAdd32F(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpAdd64 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpAdd64(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpAdd64F 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpAdd64F(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpAdd8 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpAdd8(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpAddPtr 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpAddPtr(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpAnd16 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpAnd16(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpAnd32 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpAnd32(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpAnd64 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpAnd64(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpAnd8 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpAnd8(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpAndB 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpAndB(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpArraySelect 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpArraySelect(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpBitLen16 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpBitLen16(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpBitLen32 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpBitLen32(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpBitLen64 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpBitLen64(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpBitLen8 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpBitLen8(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpCeil 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpCeil(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpCom16 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpCom16(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpCom32 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpCom32(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpCom64 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpCom64(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpCom8 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpCom8(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpConstInterface 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpConstInterface(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpConstSlice 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpConstSlice(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpConstString 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpConstString(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpConvert 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpConvert(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpCtz16 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpCtz16(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpCtz32 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpCtz32(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpCtz64 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpCtz64(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpCtz8 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpCtz8(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpCvt32Fto32 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpCvt32Fto32(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpCvt32Fto64 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpCvt32Fto64(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpCvt32Fto64F 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpCvt32Fto64F(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpCvt32to32F 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpCvt32to32F(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpCvt32to64F 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpCvt32to64F(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpCvt64Fto32 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpCvt64Fto32(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpCvt64Fto32F 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpCvt64Fto32F(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpCvt64Fto64 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpCvt64Fto64(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpCvt64to32F 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpCvt64to32F(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpCvt64to64F 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpCvt64to64F(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpCvtBoolToUint8 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpCvtBoolToUint8(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpDiv16 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpDiv16(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpDiv16u 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpDiv16u(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpDiv32 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpDiv32(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpDiv32F 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpDiv32F(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpDiv32u 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpDiv32u(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpDiv64 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpDiv64(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpDiv64F 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpDiv64F(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpDiv64u 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpDiv64u(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpDiv8 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpDiv8(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpDiv8u 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpDiv8u(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpEq16 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpEq16(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpEq32 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpEq32(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpEq32F 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpEq32F(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpEq64 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpEq64(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpEq64F 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpEq64F(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpEq8 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpEq8(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpEqB 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpEqB(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpEqInter 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpEqInter(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpEqPtr 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpEqPtr(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpEqSlice 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpEqSlice(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpFloor 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpFloor(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpIMake 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpIMake(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpInterLECall 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpInterLECall(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpIsInBounds 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpIsInBounds(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpIsNonNil 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpIsNonNil(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpIsSliceInBounds 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpIsSliceInBounds(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpLeq16 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpLeq16(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpLeq16U 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpLeq16U(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpLeq32 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpLeq32(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpLeq32F 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpLeq32F(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpLeq32U 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpLeq32U(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpLeq64 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpLeq64(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpLeq64F 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpLeq64F(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpLeq64U 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpLeq64U(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpLeq8 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpLeq8(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpLeq8U 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpLeq8U(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpLess16 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpLess16(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpLess16U 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpLess16U(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpLess32 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpLess32(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpLess32F 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpLess32F(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpLess32U 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpLess32U(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpLess64 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpLess64(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpLess64F 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpLess64F(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpLess64U 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpLess64U(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpLess8 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpLess8(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpLess8U 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpLess8U(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpLoad 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpLoad(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpLsh16x16 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpLsh16x16(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpLsh16x32 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpLsh16x32(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpLsh16x64 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpLsh16x64(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpLsh16x8 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpLsh16x8(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpLsh32x16 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpLsh32x16(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpLsh32x32 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpLsh32x32(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpLsh32x64 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpLsh32x64(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpLsh32x8 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpLsh32x8(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpLsh64x16 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpLsh64x16(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpLsh64x32 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpLsh64x32(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpLsh64x64 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpLsh64x64(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpLsh64x8 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpLsh64x8(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpLsh8x16 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpLsh8x16(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpLsh8x32 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpLsh8x32(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpLsh8x64 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpLsh8x64(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpLsh8x8 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpLsh8x8(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpMod16 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpMod16(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpMod16u 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpMod16u(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpMod32 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpMod32(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpMod32u 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpMod32u(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpMod64 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpMod64(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpMod64u 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpMod64u(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpMod8 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpMod8(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpMod8u 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpMod8u(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpMove 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpMove(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpMul16 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpMul16(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpMul32 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpMul32(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpMul32F 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpMul32F(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpMul64 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpMul64(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpMul64F 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpMul64F(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpMul8 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpMul8(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpNeg16 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpNeg16(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpNeg32 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpNeg32(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpNeg32F 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpNeg32F(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpNeg64 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpNeg64(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpNeg64F 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpNeg64F(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpNeg8 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpNeg8(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpNeq16 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpNeq16(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpNeq32 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpNeq32(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpNeq32F 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpNeq32F(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpNeq64 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpNeq64(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpNeq64F 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpNeq64F(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpNeq8 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpNeq8(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpNeqB 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpNeqB(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpNeqInter 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpNeqInter(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpNeqPtr 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpNeqPtr(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpNeqSlice 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpNeqSlice(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpNilCheck 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpNilCheck(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpNot 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpNot(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpOffPtr 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpOffPtr(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpOr16 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpOr16(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpOr32 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpOr32(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpOr64 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpOr64(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpOr8 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpOr8(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpOrB 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpOrB(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpPhi 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpPhi(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpPtrIndex 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpPtrIndex(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpRotateLeft16 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpRotateLeft16(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpRotateLeft32 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpRotateLeft32(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpRotateLeft64 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpRotateLeft64(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpRotateLeft8 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpRotateLeft8(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpRound32F 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpRound32F(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpRound64F 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpRound64F(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpRoundToEven 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpRoundToEven(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpRsh16Ux16 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpRsh16Ux16(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpRsh16Ux32 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpRsh16Ux32(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpRsh16Ux64 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpRsh16Ux64(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpRsh16Ux8 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpRsh16Ux8(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpRsh16x16 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpRsh16x16(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpRsh16x32 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpRsh16x32(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpRsh16x64 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpRsh16x64(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpRsh16x8 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpRsh16x8(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpRsh32Ux16 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpRsh32Ux16(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpRsh32Ux32 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpRsh32Ux32(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpRsh32Ux64 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpRsh32Ux64(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpRsh32Ux8 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpRsh32Ux8(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpRsh32x16 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpRsh32x16(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpRsh32x32 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpRsh32x32(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpRsh32x64 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpRsh32x64(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpRsh32x8 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpRsh32x8(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpRsh64Ux16 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpRsh64Ux16(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpRsh64Ux32 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpRsh64Ux32(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpRsh64Ux64 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpRsh64Ux64(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpRsh64Ux8 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpRsh64Ux8(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpRsh64x16 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpRsh64x16(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpRsh64x32 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpRsh64x32(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpRsh64x64 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpRsh64x64(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpRsh64x8 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpRsh64x8(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpRsh8Ux16 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpRsh8Ux16(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpRsh8Ux32 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpRsh8Ux32(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpRsh8Ux64 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpRsh8Ux64(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpRsh8Ux8 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpRsh8Ux8(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpRsh8x16 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpRsh8x16(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpRsh8x32 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpRsh8x32(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpRsh8x64 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpRsh8x64(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpRsh8x8 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpRsh8x8(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpSelect0 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpSelect0(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpSelect1 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpSelect1(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpSelectN 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpSelectN(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpSignExt16to32 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpSignExt16to32(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpSignExt16to64 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpSignExt16to64(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpSignExt32to64 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpSignExt32to64(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpSignExt8to16 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpSignExt8to16(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpSignExt8to32 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpSignExt8to32(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpSignExt8to64 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpSignExt8to64(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpSliceCap 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpSliceCap(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpSliceLen 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpSliceLen(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpSlicePtr 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpSlicePtr(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpSlicemask 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpSlicemask(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpSqrt 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpSqrt(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpStaticCall 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpStaticCall(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpStaticLECall 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpStaticLECall(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpStore 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpStore(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpStringLen 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpStringLen(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpStringPtr 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpStringPtr(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpStructSelect 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpStructSelect(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpSub16 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpSub16(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpSub32 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpSub32(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpSub32F 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpSub32F(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpSub64 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpSub64(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpSub64F 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpSub64F(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpSub8 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpSub8(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpTrunc 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpTrunc(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpTrunc16to8 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpTrunc16to8(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpTrunc32to16 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpTrunc32to16(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpTrunc32to8 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpTrunc32to8(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpTrunc64to16 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpTrunc64to16(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpTrunc64to32 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpTrunc64to32(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpTrunc64to8 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpTrunc64to8(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpXor16 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpXor16(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpXor32 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpXor32(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpXor64 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpXor64(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpXor8 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpXor8(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpZero 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpZero(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpZeroExt16to32 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpZeroExt16to32(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpZeroExt16to64 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpZeroExt16to64(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpZeroExt32to64 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpZeroExt32to64(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpZeroExt8to16 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpZeroExt8to16(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpZeroExt8to32 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpZeroExt8to32(v *Value) bool
            
            
            
               
                  rewriteValuegeneric_OpZeroExt8to64 
                  function
                  
                  #
               
               
               func rewriteValuegeneric_OpZeroExt8to64(v *Value) bool
            
            
            
               
                  rewriteWideSelectToStores 
                  method
                  
                  #
               
               
               rewriteWideSelectToStores handles the case of a SelectN'd result from a function call that is too large for SSA,
but is transferred in registers.  In this case the register cursor tracks both operands; the register sources and
the memory destinations.
This returns the memory flowing out of the last store
               
               func (x *expandState) rewriteWideSelectToStores(pos src.XPos, b *Block, container *Value, m0 *Value, at *types.Type, rc registerCursor) *Value
            
            
            
               
                  rightShift 
                  function
                  
                  #
               
               
               func rightShift(b *Block, pos src.XPos, v *Value, shift int64) *Value
            
            
            
               
                  rotateLeft32 
                  function
                  
                  #
               
               
               Convenience function to rotate a 32 bit constant value by another constant.
               
               func rotateLeft32(v int64, rotate int64) int64
            
            
            
               
                  rotateRight64 
                  function
                  
                  #
               
               
               func rotateRight64(v int64, rotate int64) int64
            
            
            
               
                  round 
                  function
                  
                  #
               
               
               round to a multiple of r, r is a power of 2.
               
               func round(o int64, r int64) int64
            
            
            
               
                  s390xCCMaskToAux 
                  function
                  
                  #
               
               
               func s390xCCMaskToAux(c s390x.CCMask) Aux
            
            
            
               
                  s390xRotateParamsToAux 
                  function
                  
                  #
               
               
               func s390xRotateParamsToAux(r s390x.RotateParams) Aux
            
            
            
               
                  safeAdd 
                  function
                  
                  #
               
               
               If x and y can add without overflow or underflow
(using b bits), safeAdd returns x+y, true.
Otherwise, returns 0, false.
               
               func safeAdd(x int64, y int64, b uint) (int64, bool)
            
            
            
               
                  safeAddU 
                  function
                  
                  #
               
               
               same as safeAdd for unsigned arithmetic.
               
               func safeAddU(x uint64, y uint64, b uint) (uint64, bool)
            
            
            
               
                  safeSub 
                  function
                  
                  #
               
               
               same as safeAdd but for subtraction.
               
               func safeSub(x int64, y int64, b uint) (int64, bool)
            
            
            
               
                  safeSubU 
                  function
                  
                  #
               
               
               same as safeAddU but for subtraction.
               
               func safeSubU(x uint64, y uint64, b uint) (uint64, bool)
            
            
            
               
                  sccp 
                  function
                  
                  #
               
               
               sccp stands for sparse conditional constant propagation, it propagates constants
through CFG conditionally and applies constant folding, constant replacement and
dead code elimination all together.
               
               func sccp(f *Func)
            
            
            
               
                  schedule 
                  function
                  
                  #
               
               
               Schedule the Values in each Block. After this phase returns, the
order of b.Values matters and is the order in which those values
will appear in the assembly output. For now it generates a
reasonable valid schedule using a priority queue. TODO(khr):
schedule smarter.
               
               func schedule(f *Func)
            
            
            
               
                  sdivisible 
                  function
                  
                  #
               
               
               func sdivisible(n uint, c int64) sdivisibleData
            
            
            
               
                  sdivisible16 
                  function
                  
                  #
               
               
               func sdivisible16(c int16) sdivisibleData
            
            
            
               
                  sdivisible32 
                  function
                  
                  #
               
               
               func sdivisible32(c int32) sdivisibleData
            
            
            
               
                  sdivisible64 
                  function
                  
                  #
               
               
               func sdivisible64(c int64) sdivisibleData
            
            
            
               
                  sdivisible8 
                  function
                  
                  #
               
               
               func sdivisible8(c int8) sdivisibleData
            
            
            
               
                  sdivisibleOK 
                  function
                  
                  #
               
               
               sdivisibleOK reports whether we should strength reduce a signed n-bit divisibility check by c.
               
               func sdivisibleOK(n uint, c int64) bool
            
            
            
               
                  sdivisibleOK16 
                  function
                  
                  #
               
               
               func sdivisibleOK16(c int16) bool
            
            
            
               
                  sdivisibleOK32 
                  function
                  
                  #
               
               
               func sdivisibleOK32(c int32) bool
            
            
            
               
                  sdivisibleOK64 
                  function
                  
                  #
               
               
               func sdivisibleOK64(c int64) bool
            
            
            
               
                  sdivisibleOK8 
                  function
                  
                  #
               
               
               func sdivisibleOK8(c int8) bool
            
            
            
               
                  sequenceOfOnes 
                  function
                  
                  #
               
               
               sequenceOfOnes tests whether a constant is a sequence of ones in binary, with leading and trailing zeros.
               
               func sequenceOfOnes(x uint64) bool
            
            
            
               
                  sequentialAddresses 
                  function
                  
                  #
               
               
               sequentialAddresses reports true if it can prove that x + n == y
               
               func sequentialAddresses(x *Value, y *Value, n int64) bool
            
            
            
               
                  set 
                  method
                  
                  #
               
               
               set changes the contents of location loc to hold the given value and its cached representative.
               
               func (e *edgeState) set(loc Location, vid ID, c *Value, final bool, pos src.XPos)
            
            
            
               
                  set 
                  method
                  
                  #
               
               
               func (s *sparseMap) set(k ID, v int32)
            
            
            
               
                  set 
                  method
                  
                  #
               
               
               func (s *sparseMapPos) set(k ID, v int32, a src.XPos)
            
            
            
               
                  set 
                  method
                  
                  #
               
               
               set inserts p->v into the map.
If p does not fall within the set of fileindex->lineRange used to construct m, this will panic.
               
               func (m *xposmap) set(p src.XPos, v int32)
            
            
            
               
                  set 
                  method
                  
                  #
               
               
               add inserts x->v into s, provided that x is in the range of keys stored in s.
               
               func (s *biasedSparseMap) set(x uint, v int32)
            
            
            
               
                  setBit 
                  method
                  
                  #
               
               
               setBit sets the v'th bit of k's value, where 0 <= v < 32
               
               func (s *sparseMap) setBit(k ID, v uint)
            
            
            
               
                  setDepth 
                  method
                  
                  #
               
               
               func (l *loop) setDepth(d int16)
            
            
            
               
                  setHome 
                  method
                  
                  #
               
               
               func (f *Func) setHome(v *Value, loc Location)
            
            
            
               
                  setNonNegative 
                  method
                  
                  #
               
               
               setNonNegative records the fact that v is known to be non-negative.
               
               func (ft *factsTable) setNonNegative(v *Value) bool
            
            
            
               
                  setOrder 
                  method
                  
                  #
               
               
               setOrder records that n1
               
               func (po *poset) setOrder(n1 *Value, n2 *Value, strict bool) bool
            
            
            
               
                  setOrig 
                  method
                  
                  #
               
               
               setOrig records that c's original value is the same as
v's original value.
               
               func (s *regAllocState) setOrig(c *Value, v *Value)
            
            
            
               
                  setPos 
                  function
                  
                  #
               
               
               setPos sets the position of v to pos, then returns true.
Useful for setting the result of a rewrite's position to
something other than the default.
               
               func setPos(v *Value, pos src.XPos) bool
            
            
            
               
                  setState 
                  method
                  
                  #
               
               
               Sets the state of the registers to that encoded in regs.
               
               func (s *regAllocState) setState(regs []endReg)
            
            
            
               
                  setchl 
                  method
                  
                  #
               
               
               Handle children
               
               func (po *poset) setchl(i uint32, l posetEdge)
            
            
            
               
                  setchr 
                  method
                  
                  #
               
               
               func (po *poset) setchr(i uint32, r posetEdge)
            
            
            
               
                  setnoneq 
                  method
                  
                  #
               
               
               Record that i1!=i2
               
               func (po *poset) setnoneq(n1 *Value, n2 *Value)
            
            
            
               
                  setup 
                  method
                  
                  #
               
               
               setup initializes the edge state for shuffling.
               
               func (e *edgeState) setup(idx int, srcReg []endReg, dstReg []startReg, stacklive []ID)
            
            
            
               
                  setupLocList 
                  function
                  
                  #
               
               
               setupLocList creates the initial portion of a location list for a
user variable. It emits the encoded start/end of the range and a
placeholder for the size. Return value is the new list plus the
slot in the list holding the size (to be updated later).
               
               func setupLocList(ctxt *obj.Link, f *Func, list []byte, st ID, en ID) ([]byte, int)
            
            
            
               
                  shiftIsBounded 
                  function
                  
                  #
               
               
               shiftIsBounded reports whether (left/right) shift Value v is known to be bounded.
A shift is bounded if it is shifting by less than the width of the shifted value.
               
               func shiftIsBounded(v *Value) bool
            
            
            
               
                  shortcircuit 
                  function
                  
                  #
               
               
               shortcircuit finds situations where branch directions
are always correlated and rewrites the CFG to take
advantage of that fact.
This optimization is useful for compiling && and || expressions.
               
               func shortcircuit(f *Func)
            
            
            
               
                  shortcircuitBlock 
                  function
                  
                  #
               
               
               shortcircuitBlock checks for a CFG in which an If block
has as its control value a Phi that has a ConstBool arg.
In some such cases, we can rewrite the CFG into a flatter form.
(1) Look for a CFG of the form
p   other pred(s)
\ /
b
/ \
t   other succ
in which b is an If block containing a single phi value with a single use (b's Control),
which has a ConstBool arg.
p is the predecessor corresponding to the argument slot in which the ConstBool is found.
t is the successor corresponding to the value of the ConstBool arg.
Rewrite this into
p   other pred(s)
|  /
| b
|/ \
t   u
and remove the appropriate phi arg(s).
(2) Look for a CFG of the form
p   q
\ /
b
/ \
t   u
in which b is as described in (1).
However, b may also contain other phi values.
The CFG will be modified as described in (1).
However, in order to handle those other phi values,
for each other phi value w, we must be able to eliminate w from b.
We can do that though a combination of moving w to a different block
and rewriting uses of w to use a different value instead.
See shortcircuitPhiPlan for details.
               
               func shortcircuitBlock(b *Block) bool
            
            
            
               
                  shortcircuitPhiPlan 
                  function
                  
                  #
               
               
               shortcircuitPhiPlan returns a function to handle non-ctl phi values in b,
where b is as described in shortcircuitBlock.
The returned function accepts a value v
and the index i of v in v.Block: v.Block.Values[i] == v.
If the returned function moves v to a different block, it will use v.moveTo.
cidx is the index in ctl of the ConstBool arg.
ti is the index in b.Succs of the always taken branch when arriving from p.
If shortcircuitPhiPlan returns nil, there is no plan available,
and the CFG modifications must not proceed.
The returned function assumes that shortcircuitBlock has completed its CFG modifications.
               
               func shortcircuitPhiPlan(b *Block, ctl *Value, cidx int, ti int64) (func(*Value, int))
            
            
            
               
                  shouldElimIfElse 
                  function
                  
                  #
               
               
               shouldElimIfElse reports whether estimated cost of eliminating branch
is lower than threshold.
               
               func shouldElimIfElse(no *Block, yes *Block, post *Block, arch string) bool
            
            
            
               
                  shuffle 
                  method
                  
                  #
               
               
               shuffle fixes up all the merge edges (those going into blocks of indegree > 1).
               
               func (s *regAllocState) shuffle(stacklive [][]ID)
            
            
            
               
                  signedMax 
                  method
                  
                  #
               
               
               func (l limit) signedMax(m int64) limit
            
            
            
               
                  signedMax 
                  method
                  
                  #
               
               
               signedMax records the fact that we know v is at most
max in the signed domain.
               
               func (ft *factsTable) signedMax(v *Value, max int64) bool
            
            
            
               
                  signedMin 
                  method
                  
                  #
               
               
               func (l limit) signedMin(m int64) limit
            
            
            
               
                  signedMin 
                  method
                  
                  #
               
               
               signedMin records the fact that we know v is at least
min in the signed domain.
               
               func (ft *factsTable) signedMin(v *Value, min int64) bool
            
            
            
               
                  signedMinMax 
                  method
                  
                  #
               
               
               func (ft *factsTable) signedMinMax(v *Value, min int64, max int64) bool
            
            
            
               
                  signedMinMax 
                  method
                  
                  #
               
               
               func (l limit) signedMinMax(min int64, max int64) limit
            
            
            
               
                  simplifyBlock 
                  function
                  
                  #
               
               
               simplifyBlock simplifies some constant values in b and evaluates
branches to non-uniquely dominated successors of b.
               
               func simplifyBlock(sdom SparseTree, ft *factsTable, b *Block)
            
            
            
               
                  size 
                  method
                  
                  #
               
               
               func (s *sparseSet) size() int
            
            
            
               
                  size 
                  method
                  
                  #
               
               
               func (s *sparseMap) size() int
            
            
            
               
                  size 
                  method
                  
                  #
               
               
               func (s *sparseMapPos) size() int
            
            
            
               
                  size 
                  method
                  
                  #
               
               
               size returns the number of entries stored in s
               
               func (s *biasedSparseMap) size() int
            
            
            
               
                  sizeType 
                  function
                  
                  #
               
               
               func sizeType(size int64) *types.Type
            
            
            
               
                  smagic 
                  function
                  
                  #
               
               
               smagic computes the constants needed to strength reduce signed n-bit divides by the constant c.
Must have c>0.
The return values satisfy for all -2^(n-1) <= x < 2^(n-1)
trunc(x / c) = x * m >> (n+s) + (x < 0 ? 1 : 0)
               
               func smagic(n uint, c int64) smagicData
            
            
            
               
                  smagic16 
                  function
                  
                  #
               
               
               func smagic16(c int16) smagicData
            
            
            
               
                  smagic32 
                  function
                  
                  #
               
               
               func smagic32(c int32) smagicData
            
            
            
               
                  smagic64 
                  function
                  
                  #
               
               
               func smagic64(c int64) smagicData
            
            
            
               
                  smagic8 
                  function
                  
                  #
               
               
               func smagic8(c int8) smagicData
            
            
            
               
                  smagicOK 
                  function
                  
                  #
               
               
               func smagicOK(n uint, c int64) bool
            
            
            
               
                  smagicOK16 
                  function
                  
                  #
               
               
               func smagicOK16(c int16) bool
            
            
            
               
                  smagicOK32 
                  function
                  
                  #
               
               
               func smagicOK32(c int32) bool
            
            
            
               
                  smagicOK64 
                  function
                  
                  #
               
               
               func smagicOK64(c int64) bool
            
            
            
               
                  smagicOK8 
                  function
                  
                  #
               
               
               smagicOKn reports whether we should strength reduce a signed n-bit divide by c.
               
               func smagicOK8(c int8) bool
            
            
            
               
                  softfloat 
                  function
                  
                  #
               
               
               func softfloat(f *Func)
            
            
            
               
                  spSb 
                  method
                  
                  #
               
               
               func (f *Func) spSb() (sp *Value, sb *Value)
            
            
            
               
                  splitPtr 
                  function
                  
                  #
               
               
               splitPtr returns the base address of ptr and any
constant offset from that base.
BaseAddress{ptr,nil},0 is always a valid result, but splitPtr
tries to peel away as many constants into off as possible.
               
               func splitPtr(ptr *Value) (BaseAddress, int64)
            
            
            
               
                  stackOffsetValue 
                  method
                  
                  #
               
               
               func (s StackOffset) stackOffsetValue() int32
            
            
            
               
                  stackalloc 
                  function
                  
                  #
               
               
               stackalloc allocates storage in the stack frame for
all Values that did not get a register.
Returns a map from block ID to the stack values live at the end of that block.
               
               func stackalloc(f *Func, spillLive [][]ID) [][]ID
            
            
            
               
                  stackalloc 
                  method
                  
                  #
               
               
               func (s *stackAllocState) stackalloc()
            
            
            
               
                  start 
                  method
                  
                  #
               
               
               func (w *HTMLWriter) start()
            
            
            
               
                  startBlock 
                  method
                  
                  #
               
               
               func (p stringFuncPrinter) startBlock(b *Block, reachable bool)
            
            
            
               
                  startBlock 
                  method
                  
                  #
               
               
               func (p htmlFuncPrinter) startBlock(b *Block, reachable bool)
            
            
            
               
                  startDepCycle 
                  method
                  
                  #
               
               
               func (p htmlFuncPrinter) startDepCycle()
            
            
            
               
                  startDepCycle 
                  method
                  
                  #
               
               
               func (p stringFuncPrinter) startDepCycle()
            
            
            
               
                  stateString 
                  method
                  
                  #
               
               
               func (s *debugState) stateString(state stateAtPC) string
            
            
            
               
                  storeOrder 
                  function
                  
                  #
               
               
               storeOrder orders values with respect to stores. That is,
if v transitively depends on store s, v is ordered after s,
otherwise v is ordered before s.
Specifically, values are ordered like
store1
NilCheck that depends on store1
other values that depends on store1
store2
NilCheck that depends on store2
other values that depends on store2
...
The order of non-store and non-NilCheck values are undefined
(not necessarily dependency order). This should be cheaper
than a full scheduling as done above.
Note that simple dependency order won't work: there is no
dependency between NilChecks and values like IsNonNil.
Auxiliary data structures are passed in as arguments, so
that they can be allocated in the caller and be reused.
This function takes care of reset them.
               
               func storeOrder(values []*Value, sset *sparseSet, storeNumber []int32) []*Value
            
            
            
               
                  storeOrdering 
                  function
                  
                  #
               
               
               storeOrdering computes the order for stores by iterate over the store
chain, assigns a score to each store. The scores only make sense for
stores within the same block, and the first store by store order has
the lowest score. The cache was used to ensure only compute once.
               
               func storeOrdering(v *Value, cache []int32) int32
            
            
            
               
                  sub 
                  method
                  
                  #
               
               
               same as add but for subtraction.
               
               func (l limit) sub(l2 limit, b uint) limit
            
            
            
               
                  subFlags32 
                  function
                  
                  #
               
               
               subFlags32 returns the flags that would be set from computing x-y.
               
               func subFlags32(x int32, y int32) flagConstant
            
            
            
               
                  subFlags64 
                  function
                  
                  #
               
               
               subFlags64 returns the flags that would be set from computing x-y.
               
               func subFlags64(x int64, y int64) flagConstant
            
            
            
               
                  subU 
                  function
                  
                  #
               
               
               subU returns x-y. Requires that x-y does not underflow an int64.
               
               func subU(x int64, y uint64) int64
            
            
            
               
                  subWillUnderflow 
                  function
                  
                  #
               
               
               subWillUnderflow reports whether x-y would result in a value less than minint.
               
               func subWillUnderflow(x int64, y int64) bool
            
            
            
               
                  supportsPPC64PCRel 
                  function
                  
                  #
               
               
               func supportsPPC64PCRel() bool
            
            
            
               
                  swapSuccessors 
                  method
                  
                  #
               
               
               func (b *Block) swapSuccessors()
            
            
            
               
                  swapSuccessorsByIdx 
                  method
                  
                  #
               
               
               Swaps b.Succs[x] and b.Succs[y].
               
               func (b *Block) swapSuccessorsByIdx(x int, y int)
            
            
            
               
                  symIsRO 
                  function
                  
                  #
               
               
               symIsRO reports whether sym is a read-only global.
               
               func symIsRO(sym interface{}) bool
            
            
            
               
                  symIsROZero 
                  function
                  
                  #
               
               
               symIsROZero reports whether sym is a read-only global whose data contains all zeros.
               
               func symIsROZero(sym Sym) bool
            
            
            
               
                  symToAux 
                  function
                  
                  #
               
               
               func symToAux(s Sym) Aux
            
            
            
               
                  tighten 
                  function
                  
                  #
               
               
               tighten moves Values closer to the Blocks in which they are used.
This can reduce the amount of register spilling required,
if it doesn't also create more live values.
A Value can be moved to any block that
dominates all blocks in which it is used.
               
               func tighten(f *Func)
            
            
            
               
                  tightenTupleSelectors 
                  function
                  
                  #
               
               
               tightenTupleSelectors ensures that tuple selectors (Select0, Select1,
and SelectN ops) are in the same block as their tuple generator. The
function also ensures that there are no duplicate tuple selectors.
These properties are expected by the scheduler but may not have
been maintained by the optimization pipeline up to this point.
See issues 16741 and 39472.
               
               func tightenTupleSelectors(f *Func)
            
            
            
               
                  treestructure 
                  method
                  
                  #
               
               
               treestructure provides a string description of the dominator
tree and flow structure of block b and all blocks that it
dominates.
               
               func (t SparseTree) treestructure(b *Block) string
            
            
            
               
                  treestructure1 
                  method
                  
                  #
               
               
               func (t SparseTree) treestructure1(b *Block, i int) string
            
            
            
               
                  trim 
                  function
                  
                  #
               
               
               trim removes blocks with no code in them.
These blocks were inserted to remove critical edges.
               
               func trim(f *Func)
            
            
            
               
                  trimmableBlock 
                  function
                  
                  #
               
               
               trimmableBlock reports whether the block can be trimmed from the CFG,
subject to the following criteria:
- it should not be the first block.
- it should be BlockPlain.
- it should not loop back to itself.
- it either is the single predecessor of the successor block or
contains no actual instructions.
               
               func trimmableBlock(b *Block) bool
            
            
            
               
                  truncate 
                  function
                  
                  #
               
               
               func truncate(b *Block, pos src.XPos, v *Value, from int64, to int64) *Value
            
            
            
               
                  truncate64Fto32F 
                  function
                  
                  #
               
               
               truncate64Fto32F converts a float64 value to a float32 preserving the bit pattern
of the mantissa. It will panic if the truncation results in lost information.
               
               func truncate64Fto32F(f float64) float32
            
            
            
               
                  truncateValues 
                  method
                  
                  #
               
               
               truncateValues truncates b.Values at the ith element, zeroing subsequent elements.
The values in b.Values after i must already have had their args reset,
to maintain correct value uses counts.
               
               func (b *Block) truncateValues(i int)
            
            
            
               
                  typeToAux 
                  function
                  
                  #
               
               
               func typeToAux(t *types.Type) Aux
            
            
            
               
                  uaddOvf 
                  function
                  
                  #
               
               
               uaddOvf reports whether unsigned a+b would overflow.
               
               func uaddOvf(a int64, b int64) bool
            
            
            
               
                  udivisible 
                  function
                  
                  #
               
               
               func udivisible(n uint, c int64) udivisibleData
            
            
            
               
                  udivisible16 
                  function
                  
                  #
               
               
               func udivisible16(c int16) udivisibleData
            
            
            
               
                  udivisible32 
                  function
                  
                  #
               
               
               func udivisible32(c int32) udivisibleData
            
            
            
               
                  udivisible64 
                  function
                  
                  #
               
               
               func udivisible64(c int64) udivisibleData
            
            
            
               
                  udivisible8 
                  function
                  
                  #
               
               
               func udivisible8(c int8) udivisibleData
            
            
            
               
                  udivisibleOK 
                  function
                  
                  #
               
               
               udivisibleOK reports whether we should strength reduce an unsigned n-bit divisibility check by c.
               
               func udivisibleOK(n uint, c int64) bool
            
            
            
               
                  udivisibleOK16 
                  function
                  
                  #
               
               
               func udivisibleOK16(c int16) bool
            
            
            
               
                  udivisibleOK32 
                  function
                  
                  #
               
               
               func udivisibleOK32(c int32) bool
            
            
            
               
                  udivisibleOK64 
                  function
                  
                  #
               
               
               func udivisibleOK64(c int64) bool
            
            
            
               
                  udivisibleOK8 
                  function
                  
                  #
               
               
               func udivisibleOK8(c int8) bool
            
            
            
               
                  uge 
                  method
                  
                  #
               
               
               func (fc flagConstant) uge() bool
            
            
            
               
                  ugt 
                  method
                  
                  #
               
               
               func (fc flagConstant) ugt() bool
            
            
            
               
                  uint8ToAuxInt 
                  function
                  
                  #
               
               
               func uint8ToAuxInt(i uint8) int64
            
            
            
               
                  ule 
                  method
                  
                  #
               
               
               func (fc flagConstant) ule() bool
            
            
            
               
                  ult 
                  method
                  
                  #
               
               
               func (fc flagConstant) ult() bool
            
            
            
               
                  umagic 
                  function
                  
                  #
               
               
               umagic computes the constants needed to strength reduce unsigned n-bit divides by the constant uint64(c).
The return values satisfy for all 0 <= x < 2^n
floor(x / uint64(c)) = x * (m + 2^n) >> (n+s)
               
               func umagic(n uint, c int64) umagicData
            
            
            
               
                  umagic16 
                  function
                  
                  #
               
               
               func umagic16(c int16) umagicData
            
            
            
               
                  umagic32 
                  function
                  
                  #
               
               
               func umagic32(c int32) umagicData
            
            
            
               
                  umagic64 
                  function
                  
                  #
               
               
               func umagic64(c int64) umagicData
            
            
            
               
                  umagic8 
                  function
                  
                  #
               
               
               func umagic8(c int8) umagicData
            
            
            
               
                  umagicOK 
                  function
                  
                  #
               
               
               umagicOK reports whether we should strength reduce a n-bit divide by c.
               
               func umagicOK(n uint, c int64) bool
            
            
            
               
                  umagicOK16 
                  function
                  
                  #
               
               
               func umagicOK16(c int16) bool
            
            
            
               
                  umagicOK32 
                  function
                  
                  #
               
               
               func umagicOK32(c int32) bool
            
            
            
               
                  umagicOK64 
                  function
                  
                  #
               
               
               func umagicOK64(c int64) bool
            
            
            
               
                  umagicOK8 
                  function
                  
                  #
               
               
               umagicOKn reports whether we should strength reduce an unsigned n-bit divide by c.
We can strength reduce when c != 0 and c is not a power of two.
               
               func umagicOK8(c int8) bool
            
            
            
               
                  unCache 
                  method
                  
                  #
               
               
               unCache removes v from f's constant cache.
               
               func (f *Func) unCache(v *Value)
            
            
            
               
                  unCacheLine 
                  method
                  
                  #
               
               
               unCacheLine removes v from f's constant cache "line" for aux,
resets v.InCache when it is found (and removed),
and returns whether v was found in that line.
               
               func (f *Func) unCacheLine(v *Value, aux int64) bool
            
            
            
               
                  uniquePred 
                  method
                  
                  #
               
               
               uniquePred returns the predecessor of b, if there is exactly one.
Returns nil otherwise.
               
               func (b *Block) uniquePred() *Block
            
            
            
               
                  unlikelyIndex 
                  method
                  
                  #
               
               
               func (b *Block) unlikelyIndex() int
            
            
            
               
                  unsat 
                  method
                  
                  #
               
               
               func (l limit) unsat() bool
            
            
            
               
                  unsignedMax 
                  method
                  
                  #
               
               
               unsignedMax records the fact that we know v is at most
max in the unsigned domain.
               
               func (ft *factsTable) unsignedMax(v *Value, max uint64) bool
            
            
            
               
                  unsignedMax 
                  method
                  
                  #
               
               
               func (l limit) unsignedMax(m uint64) limit
            
            
            
               
                  unsignedMin 
                  method
                  
                  #
               
               
               func (l limit) unsignedMin(m uint64) limit
            
            
            
               
                  unsignedMin 
                  method
                  
                  #
               
               
               unsignedMin records the fact that we know v is at least
min in the unsigned domain.
               
               func (ft *factsTable) unsignedMin(v *Value, min uint64) bool
            
            
            
               
                  unsignedMinMax 
                  method
                  
                  #
               
               
               func (l limit) unsignedMinMax(min uint64, max uint64) limit
            
            
            
               
                  unsignedMinMax 
                  method
                  
                  #
               
               
               func (ft *factsTable) unsignedMinMax(v *Value, min uint64, max uint64) bool
            
            
            
               
                  update 
                  method
                  
                  #
               
               
               update updates the set of relations between v and w in domain d
restricting it to r.
               
               func (ft *factsTable) update(parent *Block, v *Value, w *Value, d domain, r relation)
            
            
            
               
                  updateVar 
                  method
                  
                  #
               
               
               updateVar updates the pending location list entry for varID to
reflect the new locations in curLoc, beginning at v in block b.
v may be one of the special values indicating block start or end.
               
               func (state *debugState) updateVar(varID VarID, b *Block, v *Value)
            
            
            
               
                  upush 
                  method
                  
                  #
               
               
               upush records a new undo step. It can be used for simple
undo passes that record up to one index and one edge.
               
               func (po *poset) upush(typ undoType, p uint32, e posetEdge)
            
            
            
               
                  upushalias 
                  method
                  
                  #
               
               
               upushalias pushes a new undo pass for aliasing two nodes
               
               func (po *poset) upushalias(id ID, i2 uint32)
            
            
            
               
                  upushneq 
                  method
                  
                  #
               
               
               upushneq pushes a new undo pass for a nonequal relation
               
               func (po *poset) upushneq(idx1 uint32, idx2 uint32)
            
            
            
               
                  upushnew 
                  method
                  
                  #
               
               
               upushnew pushes an undo pass for a new node
               
               func (po *poset) upushnew(id ID, idx uint32)
            
            
            
               
                  useFMA 
                  method
                  
                  #
               
               
               useFMA allows targeted debugging w/ GOFMAHASH
If you have an architecture-dependent FP glitch, this will help you find it.
               
               func (f *Func) useFMA(v *Value) bool
            
            
            
               
                  valAndOffToAuxInt 
                  function
                  
                  #
               
               
               func valAndOffToAuxInt(v ValAndOff) int64
            
            
            
               
                  validVal 
                  function
                  
                  #
               
               
               validVal reports whether the value can be used
as an argument to makeValAndOff.
               
               func validVal(val int64) bool
            
            
            
               
                  value 
                  method
                  
                  #
               
               
               func (p htmlFuncPrinter) value(v *Value, live bool)
            
            
            
               
                  value 
                  method
                  
                  #
               
               
               func (p stringFuncPrinter) value(v *Value, live bool)
            
            
            
               
                  valuePosCmp 
                  function
                  
                  #
               
               
               func valuePosCmp(a *Value, b *Value) int
            
            
            
               
                  varOffset 
                  function
                  
                  #
               
               
               varOffset returns the offset of slot within the user variable it was
decomposed from. This has nothing to do with its stack offset.
               
               func varOffset(slot LocalSlot) int64
            
            
            
               
                  visitValue 
                  method
                  
                  #
               
               
               func (t *worklist) visitValue(val *Value)
            
            
            
               
                  warnRule 
                  function
                  
                  #
               
               
               warnRule generates compiler debug output with string s when
v is not in autogenerated code, cond is true and the rule has fired.
               
               func warnRule(cond bool, v *Value, s string) bool
            
            
            
               
                  wbcall 
                  function
                  
                  #
               
               
               wbcall emits write barrier runtime call in b, returns memory.
               
               func wbcall(pos src.XPos, b *Block, fn *obj.LSym, sp *Value, mem *Value, args ...*Value) *Value
            
            
            
               
                  width 
                  method
                  
                  #
               
               
               returns the width part of the auxInt field of arm64 bitfield ops.
               
               func (bfc arm64BitField) width() int64
            
            
            
               
                  writeFuncSVG 
                  method
                  
                  #
               
               
               func (d *dotWriter) writeFuncSVG(w io.Writer, phase string, f *Func)
            
            
            
               
                  writePendingEntry 
                  method
                  
                  #
               
               
               writePendingEntry writes out the pending entry for varID, if any,
terminated at endBlock/Value.
               
               func (state *debugState) writePendingEntry(varID VarID, endBlock ID, endValue ID)
            
            
            
               
                  writePtr 
                  function
                  
                  #
               
               
               Write a pointer-sized uint to the beginning of buf.
               
               func writePtr(ctxt *obj.Link, buf []byte, word uint64)
            
            
            
               
                  writebarrier 
                  function
                  
                  #
               
               
               writebarrier pass inserts write barriers for store ops (Store, Move, Zero)
when necessary (the condition above). It rewrites store ops to branches
and runtime calls, like
if writeBarrier.enabled {
buf := gcWriteBarrier2()	// Not a regular Go call
buf[0] = val
buf[1] = *ptr
}
*ptr = val
A sequence of WB stores for many pointer fields of a single type will
be emitted together, with a single branch.
               
               func writebarrier(f *Func)
            
            
            
               
                  zcse 
                  function
                  
                  #
               
               
               zcse does an initial pass of common-subexpression elimination on the
function for values with zero arguments to allow the more expensive cse
to begin with a reduced number of values. Values are just relinked,
nothing is deleted. A subsequent deadcode pass is required to actually
remove duplicate expressions.
               
               func zcse(f *Func)
            
            
            
               
                  zeroExtend 
                  function
                  
                  #
               
               
               func zeroExtend(b *Block, pos src.XPos, v *Value, from int64, to int64) *Value
            
            
            
               
                  zeroUpper32Bits 
                  function
                  
                  #
               
               
               check if value zeroes out upper 32-bit of 64-bit register.
depth limits recursion depth. In AMD64.rules 3 is used as limit,
because it catches same amount of cases as 4.
               
               func zeroUpper32Bits(x *Value, depth int) bool
            
            
            
               
                  zeroUpper48Bits 
                  function
                  
                  #
               
               
               zeroUpper48Bits is similar to zeroUpper32Bits, but for upper 48 bits.
               
               func zeroUpper48Bits(x *Value, depth int) bool
            
            
            
               
                  zeroUpper56Bits 
                  function
                  
                  #
               
               
               zeroUpper56Bits is similar to zeroUpper32Bits, but for upper 56 bits.
               
               func zeroUpper56Bits(x *Value, depth int) bool