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